Initial code commit for Sweetcomb project

The initial code is contruted by Cisco and HuachenTel.
It supports three key features:
1). Keeps compatible with IETF Yang Model and Honeycomb Yang Model.
2). Supports mulitiple clients to configure VPP simultaneously.
3). Automatically connect to VPP.

Change-Id: I3dda4fddb14062e5f113d505c6a7ee64d60c44c0
Signed-off-by: Rastislav Szabo <raszabo@cisco.com>
Signed-off-by: Chuanguo Wang <wangchuanguo@huachentel.com>
Signed-off-by: Hongjun Ni <hongjun.ni@intel.com>

6 files changed, 2576 insertions, 0 deletions

diff --git a/src/plugins/CMakeLists.txt b/src/plugins/CMakeLists.txt
new file mode 100644
index 0000000..f21d06f
--- /dev/null
+++ b/src/plugins/CMakeLists.txt
@@ -0,0 +1,39 @@
+#
+# Copyright (c) 2016 Cisco and/or its affiliates.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+cmake_minimum_required(VERSION 2.8)
+project(sysrepo-vpp-plugins)
+
+find_package(PkgConfig)
+pkg_check_modules(SYSREPO REQUIRED libsysrepo)
+pkg_check_modules(SRVPP REQUIRED libsrvpp)
+
+# get sysrepo plugins directory from pkgconfig
+if (NOT SR_PLUGINS_DIR)
+    if (PKG_CONFIG_FOUND)
+        execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} "--variable=SR_PLUGINS_DIR" "libsysrepo" OUTPUT_VARIABLE SR_PLUGINS_DIR)
+        string(STRIP ${SR_PLUGINS_DIR} SR_PLUGINS_DIR)
+    endif()
+endif()
+if (NOT SR_PLUGINS_DIR)
+    message(FATAL_ERROR "Cannot get sysrepo plugins directory due to missing pkg-config, set SR_PLUGINS_DIR manually.")
+endif()
+
+# build the source code into shared library
+add_library(vpp-interfaces SHARED vpp-interfaces.c)
+target_link_libraries(vpp-interfaces ${SYSREPO_LIBRARIES} ${SRVPP_LIBRARIES})
+
+# install the plugin into plugins dir
+install(TARGETS vpp-interfaces DESTINATION ${SR_PLUGINS_DIR})
diff --git a/src/plugins/vpp-interfaces.c b/src/plugins/vpp-interfaces.c
new file mode 100644
index 0000000..9525c18
--- /dev/null
+++ b/src/plugins/vpp-interfaces.c
@@ -0,0 +1,593 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <sysrepo.h>
+#include <sysrepo/plugins.h>
+#include <sysrepo/values.h>
+#include <sysrepo/xpath.h>
+#include <srvpp.h>
+
+/** forward declaration */
+void sr_plugin_cleanup_cb(sr_session_ctx_t *session, void *private_ctx);
+
+/**
+ * @brief Plugin context structure.
+ */
+typedef struct plugin_ctx_s {
+    srvpp_ctx_t *srvpp_ctx;                  /**< srvpp context. */
+    sr_subscription_ctx_t *sr_subscription;  /**< Sysrepo subscription context. */
+} plugin_ctx_t;
+
+/**
+ * @brief Helper function for converting netmask into prefix length.
+ */
+static uint8_t
+netmask_to_prefix(const char *netmask)
+{
+    in_addr_t n = 0;
+    uint8_t i = 0;
+
+    inet_pton(AF_INET, netmask, &n);
+
+    while (n > 0) {
+        n = n >> 1;
+        i++;
+    }
+
+    return i;
+}
+
+/**
+ * @brief Helper function for converting IPv4/IPv6 address string into binary representation.
+ */
+static void
+ip_addr_str_to_binary(const char *ip_address_str, uint8_t *ip_address_bin, bool is_ipv6)
+{
+    struct in6_addr addr6 = { 0, };
+    struct in_addr addr4 = { 0, };
+
+    if (is_ipv6) {
+        inet_pton(AF_INET6, ip_address_str, &(addr6));
+        memcpy(ip_address_bin, &addr6, sizeof(addr6));
+    } else {
+        inet_pton(AF_INET, ip_address_str, &(addr4));
+        memcpy(ip_address_bin, &addr4, sizeof(addr4));
+    }
+}
+
+/**
+ * @brief Helper function for converting VPP interface speed information into actual number in bits per second.
+ */
+static uint64_t
+get_if_link_speed(uint8_t speed)
+{
+#define ONE_MEGABIT (uint64_t)1000000
+    switch (speed) {
+        case 1:
+            /* 10M */
+            return 10 * ONE_MEGABIT;
+            break;
+        case 2:
+            /* 100M */
+            return 100 * ONE_MEGABIT;
+            break;
+        case 4:
+            /* 1G */
+            return 1000 * ONE_MEGABIT;
+            break;
+        case 8:
+            /* 10G */
+            return 10000 * ONE_MEGABIT;
+            break;
+        case 16:
+            /* 40 G */
+            return 40000 * ONE_MEGABIT;
+            break;
+        case 32:
+            /* 100G */
+            return 100000 * ONE_MEGABIT;
+            break;
+        default:
+            return 0;
+    }
+}
+
+/**
+ * @brief Enable or disable given interface.
+ */
+static int
+interface_enable_disable(plugin_ctx_t *plugin_ctx, const char *if_name, bool enable)
+{
+    vl_api_sw_interface_set_flags_t *if_set_flags_req = NULL;
+    uint32_t if_index = ~0;
+    int rc = 0;
+
+    SRP_LOG_DBG("%s interface '%s'", enable ? "Enabling" : "Disabling", if_name);
+
+    /* get interface index */
+    rc = srvpp_get_if_index(plugin_ctx->srvpp_ctx, if_name, &if_index);
+    if (0 != rc) {
+        SRP_LOG_ERR("Invalid interface name: %s", if_name);
+        return SR_ERR_INVAL_ARG;
+    }
+
+    /* process VPP API request */
+    if_set_flags_req = srvpp_alloc_msg(VL_API_SW_INTERFACE_SET_FLAGS, sizeof(*if_set_flags_req));
+
+    if_set_flags_req->sw_if_index = ntohl(if_index);
+    if_set_flags_req->admin_up_down = (uint8_t)enable;
+
+    rc = srvpp_send_request(plugin_ctx->srvpp_ctx, if_set_flags_req, NULL);
+
+    if (0 != rc) {
+        SRP_LOG_ERR("Error by processing of the sw_interface_set_flags request, rc=%d", rc);
+        return SR_ERR_OPERATION_FAILED;
+    } else {
+        return SR_ERR_OK;
+    }
+}
+
+/**
+ * @brief Callback to be called by any config change of "/ietf-interfaces:interfaces/interface/enabled" leaf.
+ */
+static int
+interface_enable_disable_cb(sr_session_ctx_t *session, const char *xpath, sr_notif_event_t event, void *private_ctx)
+{
+    char *if_name = NULL;
+    sr_change_iter_t *iter = NULL;
+    sr_change_oper_t op = SR_OP_CREATED;
+    sr_val_t *old_val = NULL;
+    sr_val_t *new_val = NULL;
+    sr_xpath_ctx_t xpath_ctx = { 0, };
+    int rc = SR_ERR_OK, op_rc = SR_ERR_OK;
+
+    /* no-op for apply, we only care about SR_EV_ENABLED, SR_EV_VERIFY, SR_EV_ABORT */
+    if (SR_EV_APPLY == event) {
+        return SR_ERR_OK;
+    }
+    SRP_LOG_DBG("'%s' modified, event=%d", xpath, event);
+
+    /* get changes iterator */
+    rc = sr_get_changes_iter(session, xpath, &iter);
+    if (SR_ERR_OK != rc) {
+        SRP_LOG_ERR("Unable to retrieve change iterator: %s", sr_strerror(rc));
+        return rc;
+    }
+
+    /* iterate over all changes */
+    while ((SR_ERR_OK == op_rc || event == SR_EV_ABORT) &&
+            (SR_ERR_OK == (rc = sr_get_change_next(session, iter, &op, &old_val, &new_val)))) {
+
+        SRP_LOG_DBG("A change detected in '%s', op=%d", new_val ? new_val->xpath : old_val->xpath, op);
+        if_name = sr_xpath_key_value(new_val ? new_val->xpath : old_val->xpath, "interface", "name", &xpath_ctx);
+        switch (op) {
+            case SR_OP_CREATED:
+            case SR_OP_MODIFIED:
+                op_rc = interface_enable_disable(private_ctx, if_name, new_val->data.bool_val);
+                break;
+            case SR_OP_DELETED:
+                op_rc = interface_enable_disable(private_ctx, if_name, false /* !enable */);
+                break;
+            default:
+                break;
+        }
+        sr_xpath_recover(&xpath_ctx);
+        if (SR_ERR_INVAL_ARG == op_rc) {
+            sr_set_error(session, "Invalid interface name.", new_val ? new_val->xpath : old_val->xpath);
+        }
+        sr_free_val(old_val);
+        sr_free_val(new_val);
+    }
+    sr_free_change_iter(iter);
+
+    return op_rc;
+}
+
+/**
+ * @brief Add or remove IPv4/IPv6 address to/from an interface.
+ */
+static int
+interface_ipv46_config_add_remove(plugin_ctx_t *plugin_ctx, const char *if_name, uint8_t *addr, uint8_t prefix,
+        bool is_ipv6, bool add)
+{
+    vl_api_sw_interface_add_del_address_t *add_del_req = NULL;
+    uint32_t if_index = ~0;
+    int rc = 0;
+
+    SRP_LOG_DBG("%s IP config on interface '%s'.", add ? "Adding" : "Removing", if_name);
+
+    /* get interface index */
+    rc = srvpp_get_if_index(plugin_ctx->srvpp_ctx, if_name, &if_index);
+    if (0 != rc) {
+        SRP_LOG_ERR("Invalid interface name: %s", if_name);
+        return SR_ERR_INVAL_ARG;
+    }
+
+    /* process VPP API request */
+    add_del_req = srvpp_alloc_msg(VL_API_SW_INTERFACE_ADD_DEL_ADDRESS, sizeof(*add_del_req));
+
+    memcpy(&add_del_req->address, addr, is_ipv6 ? 16 : 4);
+    add_del_req->is_ipv6 = (uint32_t)is_ipv6;
+    add_del_req->address_length = prefix;
+
+    add_del_req->sw_if_index = ntohl(if_index);
+    add_del_req->is_add = (uint32_t)add;
+
+    rc = srvpp_send_request(plugin_ctx->srvpp_ctx, add_del_req, NULL);
+
+    if (0 != rc) {
+        SRP_LOG_ERR("Error by processing of the sw_interface_set_flags request, rc=%d", rc);
+        return SR_ERR_OPERATION_FAILED;
+    } else {
+        return SR_ERR_OK;
+    }
+}
+
+/**
+ * @brief Modify existing IPv4/IPv6 config on an interface.
+ */
+static int
+interface_ipv46_config_modify(plugin_ctx_t *plugin_ctx, sr_session_ctx_t *session, const char *if_name,
+        sr_val_t *old_val, sr_val_t *new_val, bool is_ipv6)
+{
+    sr_xpath_ctx_t xpath_ctx = { 0, };
+    char *addr_str = NULL;
+    uint8_t addr[16] = { 0, };
+    uint8_t prefix = 0;
+    int rc = SR_ERR_OK;
+
+    SRP_LOG_DBG("Updating IP config on interface '%s'.", if_name);
+
+    /* get old config to be deleted */
+    if (SR_UINT8_T == old_val->type) {
+        prefix = old_val->data.uint8_val;
+    } else if (SR_STRING_T == old_val->type) {
+        prefix = netmask_to_prefix(old_val->data.string_val);
+    } else {
+        return SR_ERR_INVAL_ARG;
+    }
+    addr_str = sr_xpath_key_value((char*)old_val->xpath, "address", "ip", &xpath_ctx);
+    ip_addr_str_to_binary(addr_str, addr, is_ipv6);
+    sr_xpath_recover(&xpath_ctx);
+
+    /* delete old IP config */
+    rc = interface_ipv46_config_add_remove(plugin_ctx, if_name, addr, prefix, is_ipv6, false /* remove */);
+    if (SR_ERR_OK != rc) {
+        SRP_LOG_ERR("Unable to remove old IP address config, rc=%d", rc);
+        return rc;
+    }
+
+    /* update the config with the new value */
+    if (sr_xpath_node_name_eq(new_val->xpath, "prefix-length")) {
+        prefix = new_val->data.uint8_val;
+    } else if (sr_xpath_node_name_eq(new_val->xpath, "netmask")) {
+        prefix = netmask_to_prefix(new_val->data.string_val);
+    }
+
+    /* set new IP config */
+    rc = interface_ipv46_config_add_remove(plugin_ctx, if_name, addr, prefix, is_ipv6, true /* add */);
+    if (SR_ERR_OK != rc) {
+        SRP_LOG_ERR("Unable to remove old IP address config, rc=%d", rc);
+        return rc;
+    }
+
+    return rc;
+}
+
+/**
+ * @brief Callback to be called by any config change in subtrees "/ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address"
+ * or "/ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address".
+ */
+static int
+interface_ipv46_address_change_cb(sr_session_ctx_t *session, const char *xpath, sr_notif_event_t event, void *private_ctx)
+{
+    sr_change_iter_t *iter = NULL;
+    sr_change_oper_t op = SR_OP_CREATED;
+    sr_val_t *old_val = NULL;
+    sr_val_t *new_val = NULL;
+    sr_xpath_ctx_t xpath_ctx = { 0, };
+    bool is_ipv6 = false, has_addr = false, has_prefix = false;
+    uint8_t addr[16] = { 0, };
+    uint8_t prefix = 0;
+    char *node_name = NULL, *if_name = NULL;
+    int rc = SR_ERR_OK, op_rc = SR_ERR_OK;
+
+    /* no-op for apply, we only care about SR_EV_ENABLED, SR_EV_VERIFY, SR_EV_ABORT */
+    if (SR_EV_APPLY == event) {
+        return SR_ERR_OK;
+    }
+    SRP_LOG_DBG("'%s' modified, event=%d", xpath, event);
+
+    /* check whether we are handling ipv4 or ipv6 config */
+    node_name = sr_xpath_node_idx((char*)xpath, 2, &xpath_ctx);
+    if (NULL != node_name && 0 == strcmp(node_name, "ipv6")) {
+        is_ipv6 = true;
+    }
+    sr_xpath_recover(&xpath_ctx);
+
+    /* get changes iterator */
+    rc = sr_get_changes_iter(session, xpath, &iter);
+    if (SR_ERR_OK != rc) {
+        SRP_LOG_ERR("Unable to retrieve change iterator: %s", sr_strerror(rc));
+        return rc;
+    }
+
+    /* iterate over all changes */
+    while ((SR_ERR_OK == op_rc || event == SR_EV_ABORT) &&
+            (SR_ERR_OK == (rc = sr_get_change_next(session, iter, &op, &old_val, &new_val)))) {
+
+        SRP_LOG_DBG("A change detected in '%s', op=%d", new_val ? new_val->xpath : old_val->xpath, op);
+        if_name = strdup(sr_xpath_key_value(new_val ? new_val->xpath : old_val->xpath, "interface", "name", &xpath_ctx));
+        sr_xpath_recover(&xpath_ctx);
+
+        switch (op) {
+            case SR_OP_CREATED:
+                if (SR_LIST_T == new_val->type) {
+                    /* create on list item - reset state vars */
+                    has_addr = has_prefix = false;
+                } else {
+                    if (sr_xpath_node_name_eq(new_val->xpath, "ip")) {
+                        ip_addr_str_to_binary(new_val->data.string_val, addr, is_ipv6);
+                        has_addr = true;
+                    } else if (sr_xpath_node_name_eq(new_val->xpath, "prefix-length")) {
+                        prefix = new_val->data.uint8_val;
+                        has_prefix = true;
+                    } else if (sr_xpath_node_name_eq(new_val->xpath, "netmask")) {
+                        prefix = netmask_to_prefix(new_val->data.string_val);
+                        has_prefix = true;
+                    }
+                    if (has_addr && has_prefix) {
+                        op_rc = interface_ipv46_config_add_remove(private_ctx, if_name, addr, prefix, is_ipv6, true /* add */);
+                    }
+                }
+                break;
+            case SR_OP_MODIFIED:
+                op_rc = interface_ipv46_config_modify(private_ctx, session, if_name, old_val, new_val, is_ipv6);
+                break;
+            case SR_OP_DELETED:
+                if (SR_LIST_T == old_val->type) {
+                    /* delete on list item - reset state vars */
+                    has_addr = has_prefix = false;
+                } else {
+                    if (sr_xpath_node_name_eq(old_val->xpath, "ip")) {
+                        ip_addr_str_to_binary(old_val->data.string_val, addr, is_ipv6);
+                        has_addr = true;
+                    } else if (sr_xpath_node_name_eq(old_val->xpath, "prefix-length")) {
+                        prefix = old_val->data.uint8_val;
+                        has_prefix = true;
+                    } else if (sr_xpath_node_name_eq(old_val->xpath, "netmask")) {
+                        prefix = netmask_to_prefix(old_val->data.string_val);
+                        has_prefix = true;
+                    }
+                    if (has_addr && has_prefix) {
+                        op_rc = interface_ipv46_config_add_remove(private_ctx, if_name, addr, prefix, is_ipv6, false /* !add */);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        if (SR_ERR_INVAL_ARG == op_rc) {
+            sr_set_error(session, "Invalid interface name.", new_val ? new_val->xpath : old_val->xpath);
+        }
+        free(if_name);
+        sr_free_val(old_val);
+        sr_free_val(new_val);
+    }
+    sr_free_change_iter(iter);
+
+    return op_rc;
+}
+
+/**
+ * @brief Callback to be called by any config change under "/ietf-interfaces:interfaces-state/interface" path.
+ * Does not provide any functionality, needed just to cover not supported config leaves.
+ */
+static int
+interface_change_cb(sr_session_ctx_t *session, const char *xpath, sr_notif_event_t event, void *private_ctx)
+{
+    SRP_LOG_DBG("'%s' modified, event=%d", xpath, event);
+
+    return SR_ERR_OK;
+}
+
+/**
+ * @brief Callback to be called by any request for state data under "/ietf-interfaces:interfaces-state/interface" path.
+ */
+static int
+interface_state_cb(const char *xpath, sr_val_t **values, size_t *values_cnt, void *private_ctx)
+{
+    plugin_ctx_t *plugin_ctx = private_ctx;
+    vl_api_sw_interface_dump_t *if_dump_req = NULL;
+    vl_api_sw_interface_details_t *if_details = NULL;
+    void **details = NULL;
+    size_t details_cnt = 0;
+    sr_val_t *values_arr = NULL;
+    size_t values_arr_size = 0, values_arr_cnt = 0;
+    int rc = 0;
+
+    SRP_LOG_DBG("Requesting state data for '%s'", xpath);
+
+    if (! sr_xpath_node_name_eq(xpath, "interface")) {
+        /* statistics, ipv4 and ipv6 state data not supported */
+        *values_cnt = 0;
+        return SR_ERR_OK;
+    }
+
+    /* dump interfaces */
+    if_dump_req = srvpp_alloc_msg(VL_API_SW_INTERFACE_DUMP, sizeof(*if_dump_req));
+    rc = srvpp_send_dumprequest(plugin_ctx->srvpp_ctx, if_dump_req, &details, &details_cnt);
+    if (0 != rc) {
+        SRP_LOG_ERR_MSG("Error by processing of a interface dump request.");
+        return SR_ERR_INTERNAL;
+    }
+
+    /* allocate array of values to be returned */
+    values_arr_size = details_cnt * 5;
+    rc = sr_new_values(values_arr_size, &values_arr);
+    if (0 != rc) {
+        return rc;
+    }
+
+    for (size_t i = 0; i < details_cnt; i++) {
+        if_details = (vl_api_sw_interface_details_t *) details[i];
+
+        /* currently the only supported interface types are propVirtual / ethernetCsmacd */
+        sr_val_build_xpath(&values_arr[values_arr_cnt], "%s[name='%s']/type", xpath, if_details->interface_name);
+        sr_val_set_str_data(&values_arr[values_arr_cnt], SR_IDENTITYREF_T,
+                strstr((char*)if_details->interface_name, "local") ? "iana-if-type:propVirtual" : "iana-if-type:ethernetCsmacd");
+        values_arr_cnt++;
+
+        sr_val_build_xpath(&values_arr[values_arr_cnt], "%s[name='%s']/admin-status", xpath, if_details->interface_name);
+        sr_val_set_str_data(&values_arr[values_arr_cnt], SR_ENUM_T, if_details->admin_up_down ? "up" : "down");
+        values_arr_cnt++;
+
+        sr_val_build_xpath(&values_arr[values_arr_cnt], "%s[name='%s']/oper-status", xpath, if_details->interface_name);
+        sr_val_set_str_data(&values_arr[values_arr_cnt], SR_ENUM_T, if_details->link_up_down ? "up" : "down");
+        values_arr_cnt++;
+
+        if (if_details->l2_address_length > 0) {
+            sr_val_build_xpath(&values_arr[values_arr_cnt], "%s[name='%s']/phys-address", xpath, if_details->interface_name);
+            sr_val_build_str_data(&values_arr[values_arr_cnt], SR_STRING_T, "%02x:%02x:%02x:%02x:%02x:%02x",
+                    if_details->l2_address[0], if_details->l2_address[1], if_details->l2_address[2],
+                    if_details->l2_address[3], if_details->l2_address[4], if_details->l2_address[5]);
+            values_arr_cnt++;
+        }
+
+        sr_val_build_xpath(&values_arr[values_arr_cnt], "%s[name='%s']/speed", xpath, if_details->interface_name);
+        values_arr[values_arr_cnt].type = SR_UINT64_T;
+        values_arr[values_arr_cnt].data.uint64_val = get_if_link_speed(if_details->link_speed);
+        values_arr_cnt++;
+    }
+
+    SRP_LOG_DBG("Returning %zu state data elements for '%s'", values_arr, xpath);
+
+    *values = values_arr;
+    *values_cnt = values_arr_cnt;
+    return SR_ERR_OK;
+}
+
+/**
+ * @brief Callback to be called by plugin daemon upon plugin load.
+ */
+int
+sr_plugin_init_cb(sr_session_ctx_t *session, void **private_ctx)
+{
+    plugin_ctx_t *ctx = NULL;
+    int rc = SR_ERR_OK;
+
+    SRP_LOG_DBG_MSG("Initializing vpp-interfaces plugin.");
+
+    /* allocate the plugin context */
+    ctx = calloc(1, sizeof(*ctx));
+    if (NULL == ctx) {
+        return SR_ERR_NOMEM;
+    }
+
+    /* get srvpp context */
+    ctx->srvpp_ctx = srvpp_get_ctx();
+    if (NULL == ctx->srvpp_ctx) {
+        return SR_ERR_INIT_FAILED;
+    }
+
+    /* setup handlers for required VPP API messages */
+    srvpp_setup_handler(SW_INTERFACE_SET_FLAGS_REPLY, sw_interface_set_flags_reply);
+    srvpp_setup_handler(SW_INTERFACE_ADD_DEL_ADDRESS_REPLY, sw_interface_add_del_address_reply);
+
+    rc = sr_subtree_change_subscribe(session, "/ietf-interfaces:interfaces/interface",
+            interface_change_cb, ctx, 0, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_EV_ENABLED, &ctx->sr_subscription);
+    if (SR_ERR_OK != rc) {
+        goto error;
+    }
+
+    rc = sr_subtree_change_subscribe(session, "/ietf-interfaces:interfaces/interface/enabled",
+            interface_enable_disable_cb, ctx, 100, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_EV_ENABLED, &ctx->sr_subscription);
+    if (SR_ERR_OK != rc) {
+        goto error;
+    }
+
+    rc = sr_subtree_change_subscribe(session, "/ietf-interfaces:interfaces/interface/ietf-ip:ipv4/address",
+            interface_ipv46_address_change_cb, ctx, 99, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_EV_ENABLED, &ctx->sr_subscription);
+    if (SR_ERR_OK != rc) {
+        goto error;
+    }
+
+    rc = sr_subtree_change_subscribe(session, "/ietf-interfaces:interfaces/interface/ietf-ip:ipv6/address",
+            interface_ipv46_address_change_cb, ctx, 98, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_EV_ENABLED, &ctx->sr_subscription);
+    if (SR_ERR_OK != rc) {
+        goto error;
+    }
+
+    rc = sr_dp_get_items_subscribe(session, "/ietf-interfaces:interfaces-state",
+            interface_state_cb, ctx, SR_SUBSCR_CTX_REUSE, &ctx->sr_subscription);
+    if (SR_ERR_OK != rc) {
+        goto error;
+    }
+
+    *private_ctx = ctx;
+
+    SRP_LOG_INF_MSG("vpp-interfaces plugin initialized successfully.");
+
+    return SR_ERR_OK;
+
+error:
+    SRP_LOG_ERR_MSG("Error by initialization of the vpp-interfaces plugin.");
+    sr_plugin_cleanup_cb(session, ctx);
+    return rc;
+}
+
+/**
+ * @brief Callback to be called by plugin daemon upon plugin unload.
+ */
+void
+sr_plugin_cleanup_cb(sr_session_ctx_t *session, void *private_ctx)
+{
+    plugin_ctx_t *ctx = (plugin_ctx_t *) private_ctx;
+
+    SRP_LOG_DBG_MSG("Cleanup of vpp-interfaces plugin requested.");
+
+    sr_unsubscribe(session, ctx->sr_subscription);
+
+    srvpp_release_ctx(ctx->srvpp_ctx);
+    free(ctx);
+}
+
+/**
+ * @brief Callback to be called by plugin daemon periodically, to check whether the plugin and managed app is healthy.
+ */
+/*
+int
+sr_plugin_health_check_cb(sr_session_ctx_t *session, void *private_ctx)
+{
+    plugin_ctx_t *ctx = (plugin_ctx_t *) private_ctx;
+    vl_api_control_ping_t *ping = NULL;
+    int rc = 0;
+
+    ping = srvpp_alloc_msg(VL_API_CONTROL_PING, sizeof(*ping));
+
+    rc = srvpp_send_request(ctx->srvpp_ctx, ping, NULL);
+
+    if (0 != rc) {
+        return SR_ERR_DISCONNECT;
+    } else {
+        return SR_ERR_OK;
+    }
+}
+*/
diff --git a/src/plugins/yang/ietf-interfaces.data.xml b/src/plugins/yang/ietf-interfaces.data.xml
new file mode 100644
index 0000000..3aae96e
--- /dev/null
+++ b/src/plugins/yang/ietf-interfaces.data.xml
@@ -0,0 +1,21 @@
+<interfaces xmlns="urn:ietf:params:xml:ns:yang:ietf-interfaces">
+  <interface>
+    <name>GigabitEthernet0/8/0</name>
+    <description>Ethernet 8</description>
+    <type>ethernetCsmacd</type>
+    <enabled>true</enabled>
+    <ipv4 xmlns="urn:ietf:params:xml:ns:yang:ietf-ip">
+      <address>
+        <ip>192.168.2.100</ip>
+        <prefix-length>24</prefix-length>
+      </address>
+    </ipv4>
+    <ipv6 xmlns="urn:ietf:params:xml:ns:yang:ietf-ip">
+      <address>
+        <ip>2001:db8::10</ip>
+        <prefix-length>32</prefix-length>
+      </address>
+    </ipv6>
+  </interface>
+</interfaces>
+
diff --git a/src/plugins/yang/ietf-interfaces@2014-05-08.yang b/src/plugins/yang/ietf-interfaces@2014-05-08.yang
new file mode 100644
index 0000000..a0eb30e
--- /dev/null
+++ b/src/plugins/yang/ietf-interfaces@2014-05-08.yang
@@ -0,0 +1,707 @@
+module ietf-interfaces {
+
+    yang-version 1;
+
+    namespace
+      "urn:ietf:params:xml:ns:yang:ietf-interfaces";
+
+    prefix if;
+
+    import ietf-yang-types {
+      prefix yang;
+    }
+
+    organization
+      "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+    contact
+      "WG Web:   <http://tools.ietf.org/wg/netmod/>
+     WG List:  <mailto:netmod@ietf.org>
+
+     WG Chair: Thomas Nadeau
+               <mailto:tnadeau@lucidvision.com>
+
+     WG Chair: Juergen Schoenwaelder
+               <mailto:j.schoenwaelder@jacobs-university.de>
+
+     Editor:   Martin Bjorklund
+               <mailto:mbj@tail-f.com>";
+
+    description
+      "This module contains a collection of YANG definitions for
+     managing network interfaces.
+
+     Copyright (c) 2014 IETF Trust and the persons identified as
+     authors of the code.  All rights reserved.
+
+     Redistribution and use in source and binary forms, with or
+     without modification, is permitted pursuant to, and subject
+     to the license terms contained in, the Simplified BSD License
+     set forth in Section 4.c of the IETF Trust's Legal Provisions
+     Relating to IETF Documents
+     (http://trustee.ietf.org/license-info).
+
+     This version of this YANG module is part of RFC 7223; see
+     the RFC itself for full legal notices.";
+
+    revision "2014-05-08" {
+      description "Initial revision.";
+      reference
+        "RFC 7223: A YANG Data Model for Interface Management";
+
+    }
+
+
+    typedef interface-ref {
+      type leafref {
+        path "/if:interfaces/if:interface/if:name";
+      }
+      description
+        "This type is used by data models that need to reference
+       configured interfaces.";
+    }
+
+    typedef interface-state-ref {
+      type leafref {
+        path "/if:interfaces-state/if:interface/if:name";
+      }
+      description
+        "This type is used by data models that need to reference
+       the operationally present interfaces.";
+    }
+
+    identity interface-type {
+      description
+        "Base identity from which specific interface types are
+       derived.";
+    }
+
+    feature arbitrary-names {
+      description
+        "This feature indicates that the device allows user-controlled
+       interfaces to be named arbitrarily.";
+    }
+
+    feature pre-provisioning {
+      description
+        "This feature indicates that the device supports
+       pre-provisioning of interface configuration, i.e., it is
+       possible to configure an interface whose physical interface
+       hardware is not present on the device.";
+    }
+
+    feature if-mib {
+      description
+        "This feature indicates that the device implements
+       the IF-MIB.";
+      reference
+        "RFC 2863: The Interfaces Group MIB";
+
+    }
+
+    container interfaces {
+      description
+        "Interface configuration parameters.";
+      list interface {
+        key "name";
+        description
+          "The list of configured interfaces on the device.
+
+         The operational state of an interface is available in the
+         /interfaces-state/interface list.  If the configuration of a
+         system-controlled interface cannot be used by the system
+         (e.g., the interface hardware present does not match the
+         interface type), then the configuration is not applied to
+         the system-controlled interface shown in the
+         /interfaces-state/interface list.  If the configuration
+         of a user-controlled interface cannot be used by the system,
+         the configured interface is not instantiated in the
+         /interfaces-state/interface list.";
+        leaf name {
+          type string;
+          description
+            "The name of the interface.
+
+           A device MAY restrict the allowed values for this leaf,
+           possibly depending on the type of the interface.
+           For system-controlled interfaces, this leaf is the
+           device-specific name of the interface.  The 'config false'
+           list /interfaces-state/interface contains the currently
+           existing interfaces on the device.
+
+           If a client tries to create configuration for a
+           system-controlled interface that is not present in the
+           /interfaces-state/interface list, the server MAY reject
+           the request if the implementation does not support
+           pre-provisioning of interfaces or if the name refers to
+           an interface that can never exist in the system.  A
+           NETCONF server MUST reply with an rpc-error with the
+           error-tag 'invalid-value' in this case.
+
+           If the device supports pre-provisioning of interface
+           configuration, the 'pre-provisioning' feature is
+           advertised.
+
+           If the device allows arbitrarily named user-controlled
+           interfaces, the 'arbitrary-names' feature is advertised.
+
+           When a configured user-controlled interface is created by
+           the system, it is instantiated with the same name in the
+           /interface-state/interface list.";
+        }
+
+        leaf description {
+          type string;
+          description
+            "A textual description of the interface.
+
+           A server implementation MAY map this leaf to the ifAlias
+           MIB object.  Such an implementation needs to use some
+           mechanism to handle the differences in size and characters
+           allowed between this leaf and ifAlias.  The definition of
+           such a mechanism is outside the scope of this document.
+
+           Since ifAlias is defined to be stored in non-volatile
+           storage, the MIB implementation MUST map ifAlias to the
+           value of 'description' in the persistently stored
+           datastore.
+
+           Specifically, if the device supports ':startup', when
+           ifAlias is read the device MUST return the value of
+           'description' in the 'startup' datastore, and when it is
+           written, it MUST be written to the 'running' and 'startup'
+           datastores.  Note that it is up to the implementation to
+
+           decide whether to modify this single leaf in 'startup' or
+           perform an implicit copy-config from 'running' to
+           'startup'.
+
+           If the device does not support ':startup', ifAlias MUST
+           be mapped to the 'description' leaf in the 'running'
+           datastore.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifAlias";
+
+        }
+
+        leaf type {
+          type identityref {
+            base interface-type;
+          }
+          mandatory true;
+          description
+            "The type of the interface.
+
+           When an interface entry is created, a server MAY
+           initialize the type leaf with a valid value, e.g., if it
+           is possible to derive the type from the name of the
+           interface.
+
+           If a client tries to set the type of an interface to a
+           value that can never be used by the system, e.g., if the
+           type is not supported or if the type does not match the
+           name of the interface, the server MUST reject the request.
+           A NETCONF server MUST reply with an rpc-error with the
+           error-tag 'invalid-value' in this case.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifType";
+
+        }
+
+        leaf enabled {
+          type boolean;
+          default "true";
+          description
+            "This leaf contains the configured, desired state of the
+           interface.
+
+           Systems that implement the IF-MIB use the value of this
+           leaf in the 'running' datastore to set
+           IF-MIB.ifAdminStatus to 'up' or 'down' after an ifEntry
+           has been initialized, as described in RFC 2863.
+
+
+
+           Changes in this leaf in the 'running' datastore are
+           reflected in ifAdminStatus, but if ifAdminStatus is
+           changed over SNMP, this leaf is not affected.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifAdminStatus";
+
+        }
+
+        leaf link-up-down-trap-enable {
+          if-feature if-mib;
+          type enumeration {
+            enum "enabled" {
+              value 1;
+            }
+            enum "disabled" {
+              value 2;
+            }
+          }
+          description
+            "Controls whether linkUp/linkDown SNMP notifications
+           should be generated for this interface.
+
+           If this node is not configured, the value 'enabled' is
+           operationally used by the server for interfaces that do
+           not operate on top of any other interface (i.e., there are
+           no 'lower-layer-if' entries), and 'disabled' otherwise.";
+          reference
+            "RFC 2863: The Interfaces Group MIB -
+                  ifLinkUpDownTrapEnable";
+
+        }
+      }  // list interface
+    }  // container interfaces
+
+    container interfaces-state {
+      config false;
+      description
+        "Data nodes for the operational state of interfaces.";
+      list interface {
+        key "name";
+        description
+          "The list of interfaces on the device.
+
+         System-controlled interfaces created by the system are
+         always present in this list, whether they are configured or
+         not.";
+        leaf name {
+          type string;
+          description
+            "The name of the interface.
+
+           A server implementation MAY map this leaf to the ifName
+           MIB object.  Such an implementation needs to use some
+           mechanism to handle the differences in size and characters
+           allowed between this leaf and ifName.  The definition of
+           such a mechanism is outside the scope of this document.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifName";
+
+        }
+
+        leaf type {
+          type identityref {
+            base interface-type;
+          }
+          mandatory true;
+          description
+            "The type of the interface.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifType";
+
+        }
+
+        leaf admin-status {
+          if-feature if-mib;
+          type enumeration {
+            enum "up" {
+              value 1;
+              description
+                "Ready to pass packets.";
+            }
+            enum "down" {
+              value 2;
+              description
+                "Not ready to pass packets and not in some test mode.";
+            }
+            enum "testing" {
+              value 3;
+              description
+                "In some test mode.";
+            }
+          }
+          mandatory true;
+          description
+            "The desired state of the interface.
+
+           This leaf has the same read semantics as ifAdminStatus.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifAdminStatus";
+
+        }
+
+        leaf oper-status {
+          type enumeration {
+            enum "up" {
+              value 1;
+              description
+                "Ready to pass packets.";
+            }
+            enum "down" {
+              value 2;
+              description
+                "The interface does not pass any packets.";
+            }
+            enum "testing" {
+              value 3;
+              description
+                "In some test mode.  No operational packets can
+               be passed.";
+            }
+            enum "unknown" {
+              value 4;
+              description
+                "Status cannot be determined for some reason.";
+            }
+            enum "dormant" {
+              value 5;
+              description
+                "Waiting for some external event.";
+            }
+            enum "not-present" {
+              value 6;
+              description
+                "Some component (typically hardware) is missing.";
+            }
+            enum "lower-layer-down" {
+              value 7;
+              description
+                "Down due to state of lower-layer interface(s).";
+            }
+          }
+          mandatory true;
+          description
+            "The current operational state of the interface.
+
+           This leaf has the same semantics as ifOperStatus.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifOperStatus";
+
+        }
+
+        leaf last-change {
+          type yang:date-and-time;
+          description
+            "The time the interface entered its current operational
+           state.  If the current state was entered prior to the
+           last re-initialization of the local network management
+           subsystem, then this node is not present.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifLastChange";
+
+        }
+
+        leaf if-index {
+          if-feature if-mib;
+          type int32 {
+            range "1..2147483647";
+          }
+          mandatory true;
+          description
+            "The ifIndex value for the ifEntry represented by this
+           interface.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifIndex";
+
+        }
+
+        leaf phys-address {
+          type yang:phys-address;
+          description
+            "The interface's address at its protocol sub-layer.  For
+           example, for an 802.x interface, this object normally
+           contains a Media Access Control (MAC) address.  The
+           interface's media-specific modules must define the bit
+
+
+           and byte ordering and the format of the value of this
+           object.  For interfaces that do not have such an address
+           (e.g., a serial line), this node is not present.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifPhysAddress";
+
+        }
+
+        leaf-list higher-layer-if {
+          type interface-state-ref;
+          description
+            "A list of references to interfaces layered on top of this
+           interface.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifStackTable";
+
+        }
+
+        leaf-list lower-layer-if {
+          type interface-state-ref;
+          description
+            "A list of references to interfaces layered underneath this
+           interface.";
+          reference
+            "RFC 2863: The Interfaces Group MIB - ifStackTable";
+
+        }
+
+        leaf speed {
+          type yang:gauge64;
+          units "bits/second";
+          description
+            "An estimate of the interface's current bandwidth in bits
+             per second.  For interfaces that do not vary in
+             bandwidth or for those where no accurate estimation can
+             be made, this node should contain the nominal bandwidth.
+             For interfaces that have no concept of bandwidth, this
+             node is not present.";
+          reference
+            "RFC 2863: The Interfaces Group MIB -
+                  ifSpeed, ifHighSpeed";
+
+        }
+
+        container statistics {
+          description
+            "A collection of interface-related statistics objects.";
+          leaf discontinuity-time {
+            type yang:date-and-time;
+            mandatory true;
+            description
+              "The time on the most recent occasion at which any one or
+             more of this interface's counters suffered a
+             discontinuity.  If no such discontinuities have occurred
+             since the last re-initialization of the local management
+             subsystem, then this node contains the time the local
+             management subsystem re-initialized itself.";
+          }
+
+          leaf in-octets {
+            type yang:counter64;
+            description
+              "The total number of octets received on the interface,
+             including framing characters.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifHCInOctets";
+
+          }
+
+          leaf in-unicast-pkts {
+            type yang:counter64;
+            description
+              "The number of packets, delivered by this sub-layer to a
+             higher (sub-)layer, that were not addressed to a
+             multicast or broadcast address at this sub-layer.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifHCInUcastPkts";
+
+          }
+
+          leaf in-broadcast-pkts {
+            type yang:counter64;
+            description
+              "The number of packets, delivered by this sub-layer to a
+             higher (sub-)layer, that were addressed to a broadcast
+             address at this sub-layer.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB -
+                  ifHCInBroadcastPkts";
+
+          }
+
+          leaf in-multicast-pkts {
+            type yang:counter64;
+            description
+              "The number of packets, delivered by this sub-layer to a
+             higher (sub-)layer, that were addressed to a multicast
+             address at this sub-layer.  For a MAC-layer protocol,
+             this includes both Group and Functional addresses.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB -
+                  ifHCInMulticastPkts";
+
+          }
+
+          leaf in-discards {
+            type yang:counter32;
+            description
+              "The number of inbound packets that were chosen to be
+             discarded even though no errors had been detected to
+             prevent their being deliverable to a higher-layer
+             protocol.  One possible reason for discarding such a
+             packet could be to free up buffer space.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifInDiscards";
+
+          }
+
+          leaf in-errors {
+            type yang:counter32;
+            description
+              "For packet-oriented interfaces, the number of inbound
+             packets that contained errors preventing them from being
+             deliverable to a higher-layer protocol.  For character-
+             oriented or fixed-length interfaces, the number of
+             inbound transmission units that contained errors
+             preventing them from being deliverable to a higher-layer
+             protocol.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifInErrors";
+
+          }
+
+          leaf in-unknown-protos {
+            type yang:counter32;
+            description
+              "For packet-oriented interfaces, the number of packets
+             received via the interface that were discarded because
+             of an unknown or unsupported protocol.  For
+             character-oriented or fixed-length interfaces that
+             support protocol multiplexing, the number of
+             transmission units received via the interface that were
+             discarded because of an unknown or unsupported protocol.
+             For any interface that does not support protocol
+             multiplexing, this counter is not present.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifInUnknownProtos";
+
+          }
+
+          leaf out-octets {
+            type yang:counter64;
+            description
+              "The total number of octets transmitted out of the
+             interface, including framing characters.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifHCOutOctets";
+
+          }
+
+          leaf out-unicast-pkts {
+            type yang:counter64;
+            description
+              "The total number of packets that higher-level protocols
+             requested be transmitted, and that were not addressed
+             to a multicast or broadcast address at this sub-layer,
+             including those that were discarded or not sent.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifHCOutUcastPkts";
+
+          }
+
+          leaf out-broadcast-pkts {
+            type yang:counter64;
+            description
+              "The total number of packets that higher-level protocols
+             requested be transmitted, and that were addressed to a
+             broadcast address at this sub-layer, including those
+             that were discarded or not sent.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB -
+                  ifHCOutBroadcastPkts";
+
+          }
+
+          leaf out-multicast-pkts {
+            type yang:counter64;
+            description
+              "The total number of packets that higher-level protocols
+             requested be transmitted, and that were addressed to a
+             multicast address at this sub-layer, including those
+             that were discarded or not sent.  For a MAC-layer
+             protocol, this includes both Group and Functional
+             addresses.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB -
+                  ifHCOutMulticastPkts";
+
+          }
+
+          leaf out-discards {
+            type yang:counter32;
+            description
+              "The number of outbound packets that were chosen to be
+             discarded even though no errors had been detected to
+             prevent their being transmitted.  One possible reason
+             for discarding such a packet could be to free up buffer
+             space.
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifOutDiscards";
+
+          }
+
+          leaf out-errors {
+            type yang:counter32;
+            description
+              "For packet-oriented interfaces, the number of outbound
+             packets that could not be transmitted because of errors.
+             For character-oriented or fixed-length interfaces, the
+             number of outbound transmission units that could not be
+             transmitted because of errors.
+
+
+
+
+             Discontinuities in the value of this counter can occur
+             at re-initialization of the management system, and at
+             other times as indicated by the value of
+             'discontinuity-time'.";
+            reference
+              "RFC 2863: The Interfaces Group MIB - ifOutErrors";
+
+          }
+        }  // container statistics
+      }  // list interface
+    }  // container interfaces-state
+  }  // module ietf-interfaces
diff --git a/src/plugins/yang/ietf-ip@2014-06-16.yang b/src/plugins/yang/ietf-ip@2014-06-16.yang
new file mode 100644
index 0000000..79606cc
--- /dev/null
+++ b/src/plugins/yang/ietf-ip@2014-06-16.yang
@@ -0,0 +1,742 @@
+module ietf-ip {
+
+    yang-version 1;
+
+    namespace
+      "urn:ietf:params:xml:ns:yang:ietf-ip";
+
+    prefix ip;
+
+    import ietf-interfaces {
+      prefix if;
+    }
+    import ietf-inet-types {
+      prefix inet;
+    }
+    import ietf-yang-types {
+      prefix yang;
+    }
+
+    organization
+      "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+    contact
+      "WG Web:   <http://tools.ietf.org/wg/netmod/>
+    WG List:  <mailto:netmod@ietf.org>
+
+    WG Chair: Thomas Nadeau
+              <mailto:tnadeau@lucidvision.com>
+
+    WG Chair: Juergen Schoenwaelder
+              <mailto:j.schoenwaelder@jacobs-university.de>
+
+    Editor:   Martin Bjorklund
+              <mailto:mbj@tail-f.com>";
+
+    description
+      "This module contains a collection of YANG definitions for
+    configuring IP implementations.
+
+    Copyright (c) 2014 IETF Trust and the persons identified as
+    authors of the code.  All rights reserved.
+
+    Redistribution and use in source and binary forms, with or
+    without modification, is permitted pursuant to, and subject
+    to the license terms contained in, the Simplified BSD License
+    set forth in Section 4.c of the IETF Trust's Legal Provisions
+    Relating to IETF Documents
+    (http://trustee.ietf.org/license-info).
+
+    This version of this YANG module is part of RFC 7277; see
+    the RFC itself for full legal notices.";
+
+    revision "2014-06-16" {
+      description "Initial revision.";
+      reference
+        "RFC 7277: A YANG Data Model for IP Management";
+
+    }
+
+
+    feature ipv4-non-contiguous-netmasks {
+      description
+        "Indicates support for configuring non-contiguous
+      subnet masks.";
+    }
+
+    feature ipv6-privacy-autoconf {
+      description
+        "Indicates support for Privacy Extensions for Stateless Address
+      Autoconfiguration in IPv6.";
+      reference
+        "RFC 4941: Privacy Extensions for Stateless Address
+              Autoconfiguration in IPv6";
+
+    }
+
+    typedef ip-address-origin {
+      type enumeration {
+        enum "other" {
+          value 0;
+          description
+            "None of the following.";
+        }
+        enum "static" {
+          value 1;
+          description
+            "Indicates that the address has been statically
+          configured - for example, using NETCONF or a Command Line
+          Interface.";
+        }
+        enum "dhcp" {
+          value 2;
+          description
+            "Indicates an address that has been assigned to this
+          system by a DHCP server.";
+        }
+        enum "link-layer" {
+          value 3;
+          description
+            "Indicates an address created by IPv6 stateless
+          autoconfiguration that embeds a link-layer address in its
+          interface identifier.";
+        }
+        enum "random" {
+          value 4;
+          description
+            "Indicates an address chosen by the system at
+
+          random, e.g., an IPv4 address within 169.254/16, an
+          RFC 4941 temporary address, or an RFC 7217 semantically
+          opaque address.";
+          reference
+            "RFC 4941: Privacy Extensions for Stateless Address
+                  Autoconfiguration in IPv6
+             RFC 7217: A Method for Generating Semantically Opaque
+                  Interface Identifiers with IPv6 Stateless
+                  Address Autoconfiguration (SLAAC)";
+
+        }
+      }
+      description
+        "The origin of an address.";
+    }
+
+    typedef neighbor-origin {
+      type enumeration {
+        enum "other" {
+          value 0;
+          description
+            "None of the following.";
+        }
+        enum "static" {
+          value 1;
+          description
+            "Indicates that the mapping has been statically
+          configured - for example, using NETCONF or a Command Line
+          Interface.";
+        }
+        enum "dynamic" {
+          value 2;
+          description
+            "Indicates that the mapping has been dynamically resolved
+          using, e.g., IPv4 ARP or the IPv6 Neighbor Discovery
+          protocol.";
+        }
+      }
+      description
+        "The origin of a neighbor entry.";
+    }
+
+    augment /if:interfaces/if:interface {
+      description
+        "Parameters for configuring IP on interfaces.
+
+      If an interface is not capable of running IP, the server
+      must not allow the client to configure these parameters.";
+      container ipv4 {
+        presence
+          "Enables IPv4 unless the 'enabled' leaf
+        (which defaults to 'true') is set to 'false'";
+        description
+          "Parameters for the IPv4 address family.";
+        leaf enabled {
+          type boolean;
+          default 'true';
+          description
+            "Controls whether IPv4 is enabled or disabled on this
+          interface.  When IPv4 is enabled, this interface is
+          connected to an IPv4 stack, and the interface can send
+          and receive IPv4 packets.";
+        }
+
+        leaf forwarding {
+          type boolean;
+          default 'false';
+          description
+            "Controls IPv4 packet forwarding of datagrams received by,
+          but not addressed to, this interface.  IPv4 routers
+          forward datagrams.  IPv4 hosts do not (except those
+          source-routed via the host).";
+        }
+
+        leaf mtu {
+          type uint16 {
+            range "68..max";
+          }
+          units "octets";
+          description
+            "The size, in octets, of the largest IPv4 packet that the
+          interface will send and receive.
+
+          The server may restrict the allowed values for this leaf,
+          depending on the interface's type.
+
+          If this leaf is not configured, the operationally used MTU
+          depends on the interface's type.";
+          reference
+            "RFC 791: Internet Protocol";
+
+        }
+
+        list address {
+          key "ip";
+          description
+            "The list of configured IPv4 addresses on the interface.";
+          leaf ip {
+            type inet:ipv4-address-no-zone;
+            description
+              "The IPv4 address on the interface.";
+          }
+
+          choice subnet {
+            mandatory true;
+            description
+              "The subnet can be specified as a prefix-length, or,
+            if the server supports non-contiguous netmasks, as
+            a netmask.";
+            leaf prefix-length {
+              type uint8 {
+                range "0..32";
+              }
+              description
+                "The length of the subnet prefix.";
+            }
+            leaf netmask {
+              if-feature ipv4-non-contiguous-netmasks;
+              type yang:dotted-quad;
+              description
+                "The subnet specified as a netmask.";
+            }
+          }  // choice subnet
+        }  // list address
+
+        list neighbor {
+          key "ip";
+          description
+            "A list of mappings from IPv4 addresses to
+          link-layer addresses.
+
+          Entries in this list are used as static entries in the
+          ARP Cache.";
+          reference
+            "RFC 826: An Ethernet Address Resolution Protocol";
+
+          leaf ip {
+            type inet:ipv4-address-no-zone;
+            description
+              "The IPv4 address of the neighbor node.";
+          }
+
+          leaf link-layer-address {
+            type yang:phys-address;
+            mandatory true;
+            description
+              "The link-layer address of the neighbor node.";
+          }
+        }  // list neighbor
+      }  // container ipv4
+
+      container ipv6 {
+        presence
+          "Enables IPv6 unless the 'enabled' leaf
+        (which defaults to 'true') is set to 'false'";
+        description
+          "Parameters for the IPv6 address family.";
+        leaf enabled {
+          type boolean;
+          default 'true';
+          description
+            "Controls whether IPv6 is enabled or disabled on this
+          interface.  When IPv6 is enabled, this interface is
+          connected to an IPv6 stack, and the interface can send
+          and receive IPv6 packets.";
+        }
+
+        leaf forwarding {
+          type boolean;
+          default 'false';
+          description
+            "Controls IPv6 packet forwarding of datagrams received by,
+          but not addressed to, this interface.  IPv6 routers
+          forward datagrams.  IPv6 hosts do not (except those
+          source-routed via the host).";
+          reference
+            "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
+                  Section 6.2.1, IsRouter";
+
+        }
+
+        leaf mtu {
+          type uint32 {
+            range "1280..max";
+          }
+          units "octets";
+          description
+            "The size, in octets, of the largest IPv6 packet that the
+          interface will send and receive.
+
+          The server may restrict the allowed values for this leaf,
+          depending on the interface's type.
+
+          If this leaf is not configured, the operationally used MTU
+          depends on the interface's type.";
+          reference
+            "RFC 2460: Internet Protocol, Version 6 (IPv6) Specification
+                  Section 5";
+
+        }
+
+        list address {
+          key "ip";
+          description
+            "The list of configured IPv6 addresses on the interface.";
+          leaf ip {
+            type inet:ipv6-address-no-zone;
+            description
+              "The IPv6 address on the interface.";
+          }
+
+          leaf prefix-length {
+            type uint8 {
+              range "0..128";
+            }
+            mandatory true;
+            description
+              "The length of the subnet prefix.";
+          }
+        }  // list address
+
+        list neighbor {
+          key "ip";
+          description
+            "A list of mappings from IPv6 addresses to
+          link-layer addresses.
+
+          Entries in this list are used as static entries in the
+          Neighbor Cache.";
+          reference
+            "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)";
+
+          leaf ip {
+            type inet:ipv6-address-no-zone;
+            description
+              "The IPv6 address of the neighbor node.";
+          }
+
+          leaf link-layer-address {
+            type yang:phys-address;
+            mandatory true;
+            description
+              "The link-layer address of the neighbor node.";
+          }
+        }  // list neighbor
+
+        leaf dup-addr-detect-transmits {
+          type uint32;
+          default '1';
+          description
+            "The number of consecutive Neighbor Solicitation messages
+          sent while performing Duplicate Address Detection on a
+          tentative address.  A value of zero indicates that
+          Duplicate Address Detection is not performed on
+          tentative addresses.  A value of one indicates a single
+          transmission with no follow-up retransmissions.";
+          reference
+            "RFC 4862: IPv6 Stateless Address Autoconfiguration";
+
+        }
+
+        container autoconf {
+          description
+            "Parameters to control the autoconfiguration of IPv6
+          addresses, as described in RFC 4862.";
+          reference
+            "RFC 4862: IPv6 Stateless Address Autoconfiguration";
+
+          leaf create-global-addresses {
+            type boolean;
+            default 'true';
+            description
+              "If enabled, the host creates global addresses as
+            described in RFC 4862.";
+            reference
+              "RFC 4862: IPv6 Stateless Address Autoconfiguration
+                  Section 5.5";
+
+          }
+
+          leaf create-temporary-addresses {
+            if-feature ipv6-privacy-autoconf;
+            type boolean;
+            default 'false';
+            description
+              "If enabled, the host creates temporary addresses as
+            described in RFC 4941.";
+            reference
+              "RFC 4941: Privacy Extensions for Stateless Address
+                  Autoconfiguration in IPv6";
+
+          }
+
+          leaf temporary-valid-lifetime {
+            if-feature ipv6-privacy-autoconf;
+            type uint32;
+            units "seconds";
+            default '604800';
+            description
+              "The time period during which the temporary address
+            is valid.";
+            reference
+              "RFC 4941: Privacy Extensions for Stateless Address
+                  Autoconfiguration in IPv6
+                  - TEMP_VALID_LIFETIME";
+
+          }
+
+          leaf temporary-preferred-lifetime {
+            if-feature ipv6-privacy-autoconf;
+            type uint32;
+            units "seconds";
+            default '86400';
+            description
+              "The time period during which the temporary address is
+            preferred.";
+            reference
+              "RFC 4941: Privacy Extensions for Stateless Address
+                  Autoconfiguration in IPv6
+                  - TEMP_PREFERRED_LIFETIME";
+
+          }
+        }  // container autoconf
+      }  // container ipv6
+    }
+
+    augment /if:interfaces-state/if:interface {
+      description
+        "Data nodes for the operational state of IP on interfaces.";
+      container ipv4 {
+        presence
+          "Present if IPv4 is enabled on this interface";
+        config false;
+        description
+          "Interface-specific parameters for the IPv4 address family.";
+        leaf forwarding {
+          type boolean;
+          description
+            "Indicates whether IPv4 packet forwarding is enabled or
+          disabled on this interface.";
+        }
+
+        leaf mtu {
+          type uint16 {
+            range "68..max";
+          }
+          units "octets";
+          description
+            "The size, in octets, of the largest IPv4 packet that the
+          interface will send and receive.";
+          reference
+            "RFC 791: Internet Protocol";
+
+        }
+
+        list address {
+          key "ip";
+          description
+            "The list of IPv4 addresses on the interface.";
+          leaf ip {
+            type inet:ipv4-address-no-zone;
+            description
+              "The IPv4 address on the interface.";
+          }
+
+          choice subnet {
+            description
+              "The subnet can be specified as a prefix-length, or,
+            if the server supports non-contiguous netmasks, as
+            a netmask.";
+            leaf prefix-length {
+              type uint8 {
+                range "0..32";
+              }
+              description
+                "The length of the subnet prefix.";
+            }
+            leaf netmask {
+              if-feature ipv4-non-contiguous-netmasks;
+              type yang:dotted-quad;
+              description
+                "The subnet specified as a netmask.";
+            }
+          }  // choice subnet
+
+          leaf origin {
+            type ip-address-origin;
+            description
+              "The origin of this address.";
+          }
+        }  // list address
+
+        list neighbor {
+          key "ip";
+          description
+            "A list of mappings from IPv4 addresses to
+          link-layer addresses.
+
+          This list represents the ARP Cache.";
+          reference
+            "RFC 826: An Ethernet Address Resolution Protocol";
+
+          leaf ip {
+            type inet:ipv4-address-no-zone;
+            description
+              "The IPv4 address of the neighbor node.";
+          }
+
+          leaf link-layer-address {
+            type yang:phys-address;
+            description
+              "The link-layer address of the neighbor node.";
+          }
+
+          leaf origin {
+            type neighbor-origin;
+            description
+              "The origin of this neighbor entry.";
+          }
+        }  // list neighbor
+      }  // container ipv4
+
+      container ipv6 {
+        presence
+          "Present if IPv6 is enabled on this interface";
+        config false;
+        description
+          "Parameters for the IPv6 address family.";
+        leaf forwarding {
+          type boolean;
+          default 'false';
+          description
+            "Indicates whether IPv6 packet forwarding is enabled or
+          disabled on this interface.";
+          reference
+            "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
+                  Section 6.2.1, IsRouter";
+
+        }
+
+        leaf mtu {
+          type uint32 {
+            range "1280..max";
+          }
+          units "octets";
+          description
+            "The size, in octets, of the largest IPv6 packet that the
+          interface will send and receive.";
+          reference
+            "RFC 2460: Internet Protocol, Version 6 (IPv6) Specification
+                  Section 5";
+
+        }
+
+        list address {
+          key "ip";
+          description
+            "The list of IPv6 addresses on the interface.";
+          leaf ip {
+            type inet:ipv6-address-no-zone;
+            description
+              "The IPv6 address on the interface.";
+          }
+
+          leaf prefix-length {
+            type uint8 {
+              range "0..128";
+            }
+            mandatory true;
+            description
+              "The length of the subnet prefix.";
+          }
+
+          leaf origin {
+            type ip-address-origin;
+            description
+              "The origin of this address.";
+          }
+
+          leaf status {
+            type enumeration {
+              enum "preferred" {
+                value 0;
+                description
+                  "This is a valid address that can appear as the
+                destination or source address of a packet.";
+              }
+              enum "deprecated" {
+                value 1;
+                description
+                  "This is a valid but deprecated address that should
+                no longer be used as a source address in new
+                communications, but packets addressed to such an
+                address are processed as expected.";
+              }
+              enum "invalid" {
+                value 2;
+                description
+                  "This isn't a valid address, and it shouldn't appear
+                as the destination or source address of a packet.";
+              }
+              enum "inaccessible" {
+                value 3;
+                description
+                  "The address is not accessible because the interface
+                to which this address is assigned is not
+                operational.";
+              }
+              enum "unknown" {
+                value 4;
+                description
+                  "The status cannot be determined for some reason.";
+              }
+              enum "tentative" {
+                value 5;
+                description
+                  "The uniqueness of the address on the link is being
+                verified.  Addresses in this state should not be
+                used for general communication and should only be
+                used to determine the uniqueness of the address.";
+              }
+              enum "duplicate" {
+                value 6;
+                description
+                  "The address has been determined to be non-unique on
+                the link and so must not be used.";
+              }
+              enum "optimistic" {
+                value 7;
+                description
+                  "The address is available for use, subject to
+                restrictions, while its uniqueness on a link is
+                being verified.";
+              }
+            }
+            description
+              "The status of an address.  Most of the states correspond
+            to states from the IPv6 Stateless Address
+            Autoconfiguration protocol.";
+            reference
+              "RFC 4293: Management Information Base for the
+                  Internet Protocol (IP)
+                  - IpAddressStatusTC
+               RFC 4862: IPv6 Stateless Address Autoconfiguration";
+
+          }
+        }  // list address
+
+        list neighbor {
+          key "ip";
+          description
+            "A list of mappings from IPv6 addresses to
+          link-layer addresses.
+
+          This list represents the Neighbor Cache.";
+          reference
+            "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)";
+
+          leaf ip {
+            type inet:ipv6-address-no-zone;
+            description
+              "The IPv6 address of the neighbor node.";
+          }
+
+          leaf link-layer-address {
+            type yang:phys-address;
+            description
+              "The link-layer address of the neighbor node.";
+          }
+
+          leaf origin {
+            type neighbor-origin;
+            description
+              "The origin of this neighbor entry.";
+          }
+
+          leaf is-router {
+            type empty;
+            description
+              "Indicates that the neighbor node acts as a router.";
+          }
+
+          leaf state {
+            type enumeration {
+              enum "incomplete" {
+                value 0;
+                description
+                  "Address resolution is in progress, and the link-layer
+                address of the neighbor has not yet been
+                determined.";
+              }
+              enum "reachable" {
+                value 1;
+                description
+                  "Roughly speaking, the neighbor is known to have been
+                reachable recently (within tens of seconds ago).";
+              }
+              enum "stale" {
+                value 2;
+                description
+                  "The neighbor is no longer known to be reachable, but
+                until traffic is sent to the neighbor no attempt
+                should be made to verify its reachability.";
+              }
+              enum "delay" {
+                value 3;
+                description
+                  "The neighbor is no longer known to be reachable, and
+                traffic has recently been sent to the neighbor.
+                Rather than probe the neighbor immediately, however,
+                delay sending probes for a short while in order to
+                give upper-layer protocols a chance to provide
+                reachability confirmation.";
+              }
+              enum "probe" {
+                value 4;
+                description
+                  "The neighbor is no longer known to be reachable, and
+                unicast Neighbor Solicitation probes are being sent
+                to verify reachability.";
+              }
+            }
+            description
+              "The Neighbor Unreachability Detection state of this
+            entry.";
+            reference
+              "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
+                  Section 7.3.2";
+
+          }
+        }  // list neighbor
+      }  // container ipv6
+    }
+  }  // module ietf-ip
diff --git a/src/plugins/yang/ietf-yang-types@2013-07-15.yang b/src/plugins/yang/ietf-yang-types@2013-07-15.yang
new file mode 100644
index 0000000..ee58fa3
--- /dev/null
+++ b/src/plugins/yang/ietf-yang-types@2013-07-15.yang
@@ -0,0 +1,474 @@
+module ietf-yang-types {
+
+  namespace "urn:ietf:params:xml:ns:yang:ietf-yang-types";
+  prefix "yang";
+
+  organization
+   "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+  contact
+   "WG Web:   <http://tools.ietf.org/wg/netmod/>
+    WG List:  <mailto:netmod@ietf.org>
+
+    WG Chair: David Kessens
+              <mailto:david.kessens@nsn.com>
+
+    WG Chair: Juergen Schoenwaelder
+              <mailto:j.schoenwaelder@jacobs-university.de>
+
+    Editor:   Juergen Schoenwaelder
+              <mailto:j.schoenwaelder@jacobs-university.de>";
+
+  description
+   "This module contains a collection of generally useful derived
+    YANG data types.
+
+    Copyright (c) 2013 IETF Trust and the persons identified as
+    authors of the code.  All rights reserved.
+
+    Redistribution and use in source and binary forms, with or
+    without modification, is permitted pursuant to, and subject
+    to the license terms contained in, the Simplified BSD License
+    set forth in Section 4.c of the IETF Trust's Legal Provisions
+    Relating to IETF Documents
+    (http://trustee.ietf.org/license-info).
+
+    This version of this YANG module is part of RFC 6991; see
+    the RFC itself for full legal notices.";
+
+  revision 2013-07-15 {
+    description
+     "This revision adds the following new data types:
+      - yang-identifier
+      - hex-string
+      - uuid
+      - dotted-quad";
+    reference
+     "RFC 6991: Common YANG Data Types";
+  }
+
+  revision 2010-09-24 {
+    description
+     "Initial revision.";
+    reference
+     "RFC 6021: Common YANG Data Types";
+  }
+
+  /*** collection of counter and gauge types ***/
+
+  typedef counter32 {
+    type uint32;
+    description
+     "The counter32 type represents a non-negative integer
+      that monotonically increases until it reaches a
+      maximum value of 2^32-1 (4294967295 decimal), when it
+      wraps around and starts increasing again from zero.
+
+      Counters have no defined 'initial' value, and thus, a
+      single value of a counter has (in general) no information
+      content.  Discontinuities in the monotonically increasing
+      value normally occur at re-initialization of the
+      management system, and at other times as specified in the
+      description of a schema node using this type.  If such
+      other times can occur, for example, the creation of
+      a schema node of type counter32 at times other than
+      re-initialization, then a corresponding schema node
+      should be defined, with an appropriate type, to indicate
+      the last discontinuity.
+
+      The counter32 type should not be used for configuration
+      schema nodes.  A default statement SHOULD NOT be used in
+      combination with the type counter32.
+
+      In the value set and its semantics, this type is equivalent
+      to the Counter32 type of the SMIv2.";
+    reference
+     "RFC 2578: Structure of Management Information Version 2
+                (SMIv2)";
+  }
+
+  typedef zero-based-counter32 {
+    type yang:counter32;
+    default "0";
+    description
+     "The zero-based-counter32 type represents a counter32
+      that has the defined 'initial' value zero.
+
+      A schema node of this type will be set to zero (0) on creation
+      and will thereafter increase monotonically until it reaches
+      a maximum value of 2^32-1 (4294967295 decimal), when it
+      wraps around and starts increasing again from zero.
+
+      Provided that an application discovers a new schema node
+      of this type within the minimum time to wrap, it can use the
+      'initial' value as a delta.  It is important for a management
+      station to be aware of this minimum time and the actual time
+      between polls, and to discard data if the actual time is too
+      long or there is no defined minimum time.
+
+      In the value set and its semantics, this type is equivalent
+      to the ZeroBasedCounter32 textual convention of the SMIv2.";
+    reference
+      "RFC 4502: Remote Network Monitoring Management Information
+                 Base Version 2";
+  }
+
+  typedef counter64 {
+    type uint64;
+    description
+     "The counter64 type represents a non-negative integer
+      that monotonically increases until it reaches a
+      maximum value of 2^64-1 (18446744073709551615 decimal),
+      when it wraps around and starts increasing again from zero.
+
+      Counters have no defined 'initial' value, and thus, a
+      single value of a counter has (in general) no information
+      content.  Discontinuities in the monotonically increasing
+      value normally occur at re-initialization of the
+      management system, and at other times as specified in the
+      description of a schema node using this type.  If such
+      other times can occur, for example, the creation of
+      a schema node of type counter64 at times other than
+      re-initialization, then a corresponding schema node
+      should be defined, with an appropriate type, to indicate
+      the last discontinuity.
+
+      The counter64 type should not be used for configuration
+      schema nodes.  A default statement SHOULD NOT be used in
+      combination with the type counter64.
+
+      In the value set and its semantics, this type is equivalent
+      to the Counter64 type of the SMIv2.";
+    reference
+     "RFC 2578: Structure of Management Information Version 2
+                (SMIv2)";
+  }
+
+  typedef zero-based-counter64 {
+    type yang:counter64;
+    default "0";
+    description
+     "The zero-based-counter64 type represents a counter64 that
+      has the defined 'initial' value zero.
+
+      A schema node of this type will be set to zero (0) on creation
+      and will thereafter increase monotonically until it reaches
+      a maximum value of 2^64-1 (18446744073709551615 decimal),
+      when it wraps around and starts increasing again from zero.
+
+      Provided that an application discovers a new schema node
+      of this type within the minimum time to wrap, it can use the
+      'initial' value as a delta.  It is important for a management
+      station to be aware of this minimum time and the actual time
+      between polls, and to discard data if the actual time is too
+      long or there is no defined minimum time.
+
+      In the value set and its semantics, this type is equivalent
+      to the ZeroBasedCounter64 textual convention of the SMIv2.";
+    reference
+     "RFC 2856: Textual Conventions for Additional High Capacity
+                Data Types";
+  }
+
+  typedef gauge32 {
+    type uint32;
+    description
+     "The gauge32 type represents a non-negative integer, which
+      may increase or decrease, but shall never exceed a maximum
+      value, nor fall below a minimum value.  The maximum value
+      cannot be greater than 2^32-1 (4294967295 decimal), and
+      the minimum value cannot be smaller than 0.  The value of
+      a gauge32 has its maximum value whenever the information
+      being modeled is greater than or equal to its maximum
+      value, and has its minimum value whenever the information
+      being modeled is smaller than or equal to its minimum value.
+      If the information being modeled subsequently decreases
+      below (increases above) the maximum (minimum) value, the
+      gauge32 also decreases (increases).
+
+      In the value set and its semantics, this type is equivalent
+      to the Gauge32 type of the SMIv2.";
+    reference
+     "RFC 2578: Structure of Management Information Version 2
+                (SMIv2)";
+  }
+
+  typedef gauge64 {
+    type uint64;
+    description
+     "The gauge64 type represents a non-negative integer, which
+      may increase or decrease, but shall never exceed a maximum
+      value, nor fall below a minimum value.  The maximum value
+      cannot be greater than 2^64-1 (18446744073709551615), and
+      the minimum value cannot be smaller than 0.  The value of
+      a gauge64 has its maximum value whenever the information
+      being modeled is greater than or equal to its maximum
+      value, and has its minimum value whenever the information
+      being modeled is smaller than or equal to its minimum value.
+      If the information being modeled subsequently decreases
+      below (increases above) the maximum (minimum) value, the
+      gauge64 also decreases (increases).
+
+      In the value set and its semantics, this type is equivalent
+      to the CounterBasedGauge64 SMIv2 textual convention defined
+      in RFC 2856";
+    reference
+     "RFC 2856: Textual Conventions for Additional High Capacity
+                Data Types";
+  }
+
+  /*** collection of identifier-related types ***/
+
+  typedef object-identifier {
+    type string {
+      pattern '(([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))'
+            + '(\.(0|([1-9]\d*)))*';
+    }
+    description
+     "The object-identifier type represents administratively
+      assigned names in a registration-hierarchical-name tree.
+
+      Values of this type are denoted as a sequence of numerical
+      non-negative sub-identifier values.  Each sub-identifier
+      value MUST NOT exceed 2^32-1 (4294967295).  Sub-identifiers
+      are separated by single dots and without any intermediate
+      whitespace.
+
+      The ASN.1 standard restricts the value space of the first
+      sub-identifier to 0, 1, or 2.  Furthermore, the value space
+      of the second sub-identifier is restricted to the range
+      0 to 39 if the first sub-identifier is 0 or 1.  Finally,
+      the ASN.1 standard requires that an object identifier
+      has always at least two sub-identifiers.  The pattern
+      captures these restrictions.
+
+      Although the number of sub-identifiers is not limited,
+      module designers should realize that there may be
+      implementations that stick with the SMIv2 limit of 128
+      sub-identifiers.
+
+      This type is a superset of the SMIv2 OBJECT IDENTIFIER type
+      since it is not restricted to 128 sub-identifiers.  Hence,
+      this type SHOULD NOT be used to represent the SMIv2 OBJECT
+      IDENTIFIER type; the object-identifier-128 type SHOULD be
+      used instead.";
+    reference
+     "ISO9834-1: Information technology -- Open Systems
+      Interconnection -- Procedures for the operation of OSI
+      Registration Authorities: General procedures and top
+      arcs of the ASN.1 Object Identifier tree";
+  }
+
+  typedef object-identifier-128 {
+    type object-identifier {
+      pattern '\d*(\.\d*){1,127}';
+    }
+    description
+     "This type represents object-identifiers restricted to 128
+      sub-identifiers.
+
+      In the value set and its semantics, this type is equivalent
+      to the OBJECT IDENTIFIER type of the SMIv2.";
+    reference
+     "RFC 2578: Structure of Management Information Version 2
+                (SMIv2)";
+  }
+
+  typedef yang-identifier {
+    type string {
+      length "1..max";
+      pattern '[a-zA-Z_][a-zA-Z0-9\-_.]*';
+      pattern '.|..|[^xX].*|.[^mM].*|..[^lL].*';
+    }
+    description
+      "A YANG identifier string as defined by the 'identifier'
+       rule in Section 12 of RFC 6020.  An identifier must
+       start with an alphabetic character or an underscore
+       followed by an arbitrary sequence of alphabetic or
+       numeric characters, underscores, hyphens, or dots.
+
+       A YANG identifier MUST NOT start with any possible
+       combination of the lowercase or uppercase character
+       sequence 'xml'.";
+    reference
+      "RFC 6020: YANG - A Data Modeling Language for the Network
+                 Configuration Protocol (NETCONF)";
+  }
+
+  /*** collection of types related to date and time***/
+
+  typedef date-and-time {
+    type string {
+      pattern '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?'
+            + '(Z|[\+\-]\d{2}:\d{2})';
+    }
+    description
+     "The date-and-time type is a profile of the ISO 8601
+      standard for representation of dates and times using the
+      Gregorian calendar.  The profile is defined by the
+      date-time production in Section 5.6 of RFC 3339.
+
+      The date-and-time type is compatible with the dateTime XML
+      schema type with the following notable exceptions:
+
+      (a) The date-and-time type does not allow negative years.
+
+      (b) The date-and-time time-offset -00:00 indicates an unknown
+          time zone (see RFC 3339) while -00:00 and +00:00 and Z
+          all represent the same time zone in dateTime.
+
+      (c) The canonical format (see below) of data-and-time values
+          differs from the canonical format used by the dateTime XML
+          schema type, which requires all times to be in UTC using
+          the time-offset 'Z'.
+
+      This type is not equivalent to the DateAndTime textual
+      convention of the SMIv2 since RFC 3339 uses a different
+      separator between full-date and full-time and provides
+      higher resolution of time-secfrac.
+
+      The canonical format for date-and-time values with a known time
+      zone uses a numeric time zone offset that is calculated using
+      the device's configured known offset to UTC time.  A change of
+      the device's offset to UTC time will cause date-and-time values
+      to change accordingly.  Such changes might happen periodically
+      in case a server follows automatically daylight saving time
+      (DST) time zone offset changes.  The canonical format for
+      date-and-time values with an unknown time zone (usually
+      referring to the notion of local time) uses the time-offset
+      -00:00.";
+    reference
+     "RFC 3339: Date and Time on the Internet: Timestamps
+      RFC 2579: Textual Conventions for SMIv2
+      XSD-TYPES: XML Schema Part 2: Datatypes Second Edition";
+  }
+
+  typedef timeticks {
+    type uint32;
+    description
+     "The timeticks type represents a non-negative integer that
+      represents the time, modulo 2^32 (4294967296 decimal), in
+      hundredths of a second between two epochs.  When a schema
+      node is defined that uses this type, the description of
+      the schema node identifies both of the reference epochs.
+
+      In the value set and its semantics, this type is equivalent
+      to the TimeTicks type of the SMIv2.";
+    reference
+     "RFC 2578: Structure of Management Information Version 2
+                (SMIv2)";
+  }
+
+  typedef timestamp {
+    type yang:timeticks;
+    description
+     "The timestamp type represents the value of an associated
+      timeticks schema node at which a specific occurrence
+      happened.  The specific occurrence must be defined in the
+      description of any schema node defined using this type.  When
+      the specific occurrence occurred prior to the last time the
+      associated timeticks attribute was zero, then the timestamp
+      value is zero.  Note that this requires all timestamp values
+      to be reset to zero when the value of the associated timeticks
+      attribute reaches 497+ days and wraps around to zero.
+
+      The associated timeticks schema node must be specified
+      in the description of any schema node using this type.
+
+      In the value set and its semantics, this type is equivalent
+      to the TimeStamp textual convention of the SMIv2.";
+    reference
+     "RFC 2579: Textual Conventions for SMIv2";
+  }
+
+  /*** collection of generic address types ***/
+
+  typedef phys-address {
+    type string {
+      pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?';
+    }
+
+    description
+     "Represents media- or physical-level addresses represented
+      as a sequence octets, each octet represented by two hexadecimal
+      numbers.  Octets are separated by colons.  The canonical
+      representation uses lowercase characters.
+
+      In the value set and its semantics, this type is equivalent
+      to the PhysAddress textual convention of the SMIv2.";
+    reference
+     "RFC 2579: Textual Conventions for SMIv2";
+  }
+
+  typedef mac-address {
+    type string {
+      pattern '[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}';
+    }
+    description
+     "The mac-address type represents an IEEE 802 MAC address.
+      The canonical representation uses lowercase characters.
+
+      In the value set and its semantics, this type is equivalent
+      to the MacAddress textual convention of the SMIv2.";
+    reference
+     "IEEE 802: IEEE Standard for Local and Metropolitan Area
+                Networks: Overview and Architecture
+      RFC 2579: Textual Conventions for SMIv2";
+  }
+
+  /*** collection of XML-specific types ***/
+
+  typedef xpath1.0 {
+    type string;
+    description
+     "This type represents an XPATH 1.0 expression.
+
+      When a schema node is defined that uses this type, the
+      description of the schema node MUST specify the XPath
+      context in which the XPath expression is evaluated.";
+    reference
+     "XPATH: XML Path Language (XPath) Version 1.0";
+  }
+
+  /*** collection of string types ***/
+
+  typedef hex-string {
+    type string {
+      pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?';
+    }
+    description
+     "A hexadecimal string with octets represented as hex digits
+      separated by colons.  The canonical representation uses
+      lowercase characters.";
+  }
+
+  typedef uuid {
+    type string {
+      pattern '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-'
+            + '[0-9a-fA-F]{4}-[0-9a-fA-F]{12}';
+    }
+    description
+     "A Universally Unique IDentifier in the string representation
+      defined in RFC 4122.  The canonical representation uses
+      lowercase characters.
+
+      The following is an example of a UUID in string representation:
+      f81d4fae-7dec-11d0-a765-00a0c91e6bf6
+      ";
+    reference
+     "RFC 4122: A Universally Unique IDentifier (UUID) URN
+                Namespace";
+  }
+
+  typedef dotted-quad {
+    type string {
+      pattern
+        '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}'
+      + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';
+    }
+    description
+      "An unsigned 32-bit number expressed in the dotted-quad
+       notation, i.e., four octets written as decimal numbers
+       and separated with the '.' (full stop) character.";
+  }
+}