voltha:虚拟OLT硬件抽象

/* * Copyright 2017-present Open Networking Foundation * 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. */ /* * This is automatically generated callbacks file * It contains 3 parts: Configuration callbacks, RPC callbacks and state data callbacks. * Do NOT alter function signatures or any structures unless you know exactly what you are doing. */ #include <stdlib.h> #include <sys/inotify.h> #include <libxml/tree.h> #include <libxml/xmlsave.h> #include <libxml/xmlwriter.h> #include <libnetconf_xml.h> #include <voltha-netconf-model.h> #include <voltha.h> #include <string.h> /* transAPI version which must be compatible with libnetconf */ int transapi_version = 6; /* Signal to libnetconf that configuration data were modified by any callback. * 0 - data not modified * 1 - data have been modified */ int config_modified = 0; /* * Determines the callbacks order. * Set this variable before compilation and DO NOT modify it in runtime. * TRANSAPI_CLBCKS_LEAF_TO_ROOT (default) * TRANSAPI_CLBCKS_ROOT_TO_LEAF */ const TRANSAPI_CLBCKS_ORDER_TYPE callbacks_order = TRANSAPI_CLBCKS_ORDER_DEFAULT; /* Do not modify or set! This variable is set by libnetconf to announce edit-config's error-option Feel free to use it to distinguish module behavior for different error-option values. * Possible values: * NC_EDIT_ERROPT_STOP - Following callback after failure are not executed, all successful callbacks executed till failure point must be applied to the device. * NC_EDIT_ERROPT_CONT - Failed callbacks are skipped, but all callbacks needed to apply configuration changes are executed * NC_EDIT_ERROPT_ROLLBACK - After failure, following callbacks are not executed, but previous successful callbacks are executed again with previous configuration data to roll it back. */ NC_EDIT_ERROPT_TYPE erropt = NC_EDIT_ERROPT_NOTSET; /** * @brief Initialize plugin after loaded and before any other functions are called. * This function should not apply any configuration data to the controlled device. If no * running is returned (it stays *NULL), complete startup configuration is consequently * applied via module callbacks. When a running configuration is returned, libnetconf * then applies (via module's callbacks) only the startup configuration data that * differ from the returned running configuration data. * Please note, that copying startup data to the running is performed only after the * libnetconf's system-wide close - see nc_close() function documentation for more * information. * @param[out] running Current configuration of managed device. * @return EXIT_SUCCESS or EXIT_FAILURE */ int transapi_init(xmlDocPtr *running) { return EXIT_SUCCESS; } /** * @brief Free all resources allocated on plugin runtime and prepare plugin for removal. */ void transapi_close(void) { return; } /** * @brief Retrieve state data from device and return them as XML document * * @param model Device data model. libxml2 xmlDocPtr. * @param running Running datastore content. libxml2 xmlDocPtr. * @param[out] err Double pointer to error structure. Fill error when some occurs. * @return State data as libxml2 xmlDocPtr or NULL in case of error. */ xmlDocPtr get_state_data(xmlDocPtr model, xmlDocPtr running, struct nc_err **err) { return(NULL); } /* * Mapping prefixes with namespaces. * Do NOT modify this structure! */ struct ns_pair namespace_mapping[] = {{NULL, NULL}}; /* * CONFIGURATION callbacks * Here follows set of callback functions run every time some change in associated part of running datastore occurs. * You can safely modify the bodies of all function as well as add new functions for better lucidity of code. */ /* * Structure transapi_config_callbacks provide mapping between callback and path in configuration datastore. * It is used by libnetconf library to decide which callbacks will be run. * DO NOT alter this structure */ struct transapi_data_callbacks clbks = { .callbacks_count = 0, .data = NULL, .callbacks = { } }; /** * @brief Get a node from the RPC input. The first found node is returned, so if traversing lists, * call repeatedly with result->next as the node argument. * * @param name Name of the node to be retrieved. * @param node List of nodes that will be searched. * @return Pointer to the matching node or NULL */ xmlNodePtr get_rpc_node(const char *name, const xmlNodePtr node) { xmlNodePtr ret = NULL; for (ret = node; ret != NULL; ret = ret->next) { if (xmlStrEqual(BAD_CAST name, ret->name)) { break; } } return ret; } void walk_nodes(const xmlNodePtr node) { xmlNodePtr ret = NULL; /* walk through the document what to do with nodes ... pass to a channel? to construct a map at the other end? */ for (ret = node; ret != NULL; ret = ret->next) { if (xmlNodeIsText(ret)) { nc_verb_verbose("content : %s", (char*)xmlNodeGetContent(ret)); } else { nc_verb_verbose("name : %s", ret->name); } if (ret->children != NULL) { walk_nodes(ret->children); } } } /* * RPC callbacks * Here follows set of callback functions run every time RPC specific for this device arrives. * You can safely modify the bodies of all function as well as add new functions for better lucidity of code. * Every function takes an libxml2 list of inputs as an argument. * If input was not set in RPC message argument is set to NULL. To retrieve each argument, preferably use get_rpc_node(). */ /* * Local service functions */ nc_reply *rpc_VolthaLocalService_GetVolthaInstance(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_GetHealth(xmlNodePtr input) { HealthStatus health; health = (HealthStatus) GetHealthStatus(); char* data; data = (char*) TranslateHealthStatus(health); return nc_reply_data(data); } nc_reply *rpc_VolthaLocalService_ListAdapters(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_ListLogicalDevices(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_GetLogicalDevice(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_ListLogicalDevicePorts(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_ListLogicalDeviceFlows(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_UpdateLogicalDeviceFlowTable(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_ListLogicalDeviceFlowGroups(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_UpdateLogicalDeviceFlowGroupTable(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_ListDevices(xmlNodePtr input) { DeviceArray devices; devices = (DeviceArray) ListDevices(); char* data; data = (char*) TranslateDevices(devices); return nc_reply_data(data); } nc_reply *rpc_VolthaLocalService_GetDevice(xmlNodePtr input) { return NULL; } nc_reply *rpc_VolthaLocalService_CreateDevice(xmlNodePtr input) { Device d; xmlNodePtr ret = NULL; if ((ret = get_rpc_node("type", input)) != NULL) { d.Type = (char*)xmlNodeGetContent(ret); } if ((ret = get_rpc_node("host_and_port", input)) != NULL) { d.Address.Type = (int)HOST_AND_PORT; d.Address.Value = (char*)xmlNodeGetContent(ret); } else if ((ret = get_rpc_node("mac_address", input)) != NULL) { d.Address.Type = (int)MAC; d.Address.Value = (char*)xmlNodeGetContent(ret); } else if ((ret = get