elxu_mgmt.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "elxu_mgmt.h"

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ioctl.h>

#include <ocs_ioctl.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>

#include <elxu_device.h>

static void display_mgmt_list(elxu_device_t *device);
static void parse_node(mgmt_list_t *list, xmlNodePtr node);

/*  Functions for manipulating lists, objects, and properties */
static mgmt_list_t *parse_list(char *buf);

#define INFO_BUFFER_SIZE 1024*1024
#define OCS_MGMT_MAX_NAME 128
#define EBUSY 16

void elxu_mgmt_info(elxu_device_t *device)
{
        display_mgmt_list(device);
}

static void display_mgmt_list(elxu_device_t *device)
{
    mgmt_list_t *status_list;
    mgmt_object_t *obj;

    printf("Mgmt values:\n");

    status_list = mgmt_get_all(device);

    obj = status_list->head;

    while (obj) {
        mgmt_property_t *prop;

        prop = obj->head;
        while (prop) {
            if (strstr(prop->access, "r")) {
                printf("%s (%s) = %s\n", prop->name, prop->access, prop->value);
            } else {
                printf("%s (%s)\n", prop->name, prop->access);
            }

            prop = prop->next;
        }
        obj = obj->next;
    }
    mgmt_delete_list(status_list);
}

/**
 * @brief mgmt_new_list:  Create a new empty linked list
 */
mgmt_list_t* mgmt_new_list()
{
    mgmt_list_t *ret;

    ret = malloc(sizeof(mgmt_list_t));
    if (ret != NULL) {
        ret->head = NULL;
    }

    return ret;
}

/**
 * @brief mgmt_delete_list Delete a linked list and free its contents
 */
void mgmt_delete_list(mgmt_list_t *list)
{
    mgmt_object_t *node;
    mgmt_object_t *next;

    if (list != NULL) {
        node = list->head;
        while (node != NULL) {
            next = node->next;
            mgmt_delete_object(node);
            node = next;
        }

        free(list);
    }
}

/**
 * @brief mgmt_list_add: Add an object to the tail of a list
 */
void mgmt_list_add(mgmt_list_t *list, mgmt_object_t *object)
{
    mgmt_object_t *node;

    object->next = NULL;

    if (list != NULL) {
        if (list->head == NULL) {
            list->head = object;
            return;
        }

        node = list->head;
        while (node->next != NULL) {
            node = node->next;
        }

        node->next = object;
    }
}

/**
 * @brief Remove an object from a list
 *
 * @par Description
 * Given a list and a property name, remove the first object found with that
 * property name from the list.
 *
 * @param list The list to operate on.
 * @param name The name of a property to remove.
 *
 * @return Returns a pointer to the removed object if found, NULL if not found.
 */
mgmt_object_t *mgmt_list_remove(mgmt_list_t *list, char *name)
{
    mgmt_object_t *node;
    mgmt_object_t *result;
    mgmt_object_t *previous;

    result = NULL;
    previous = NULL;

    if (list == NULL) {
        return NULL;
    }

    if ((name == NULL) || (strlen(name) < 1)) {
        return NULL;
    }

    node = list->head;

    while (node) {
        if (strcmp(node->head->name, name) == 0) {
            /* Found the object */
            result = node;

            if (previous == NULL) {
                /* Found it at the head of the list */
                list->head = node->next;
            } else {
                /* Not at the head of the list */
                previous->next = node->next;
            }

            break;
        }

        previous = node;
        node = node->next;
    }

    return result;
}

int mgmt_list_is_empty(mgmt_list_t *list)
{
    return (list->head == NULL);
}

void mgmt_list_sort(mgmt_list_t *list)
{
    mgmt_list_t *new_list;
    mgmt_object_t *obj;
    mgmt_object_t *smallest_obj;
    char *smallest_name;

    new_list = mgmt_new_list();

    while (!mgmt_list_is_empty(list)) {
        /* Find the smallest in the list */
        obj = list->head;
        smallest_obj = obj;
        smallest_name = obj->head->name;

        while (obj) {
            if (strcmp(obj->head->name, smallest_name) < 0) {
                smallest_name = obj->head->name;
                smallest_obj = obj;
            }

            obj = obj->next;
        }

        /* Remove the smallest from the list */
        mgmt_list_remove(list, smallest_obj->head->name);

        /* Add it to the new list */
        mgmt_list_add(new_list, smallest_obj);
    }

    /* At this point all items have been removed from list and placed on new_list in order */

    /* Swap the lists */
    list->head = new_list->head;
    new_list->head = NULL;

    mgmt_delete_list(new_list);
}

/**
 * @brief mgmt_new_property: Create a new property with the given name and value
 *
 */
mgmt_property_t *mgmt_new_property(char *name, char *value, char *access)
{
    mgmt_property_t *ret;

    ret = malloc(sizeof(mgmt_property_t));
    if (ret != NULL) {
        ret->name = strdup(name);
        ret->value = strdup(value);
        ret->access = strdup(access);
        ret->next = NULL;
    }

    return ret;
}

/**
 * @brief mgmt_delete_property: delete a property, freeing the name and value
 */
void mgmt_delete_property(mgmt_property_t *prop)
{
    if (prop != NULL) {
        if (prop->name != NULL) {
            free(prop->name);
        }
        if (prop->value != NULL) {
            free(prop->value);
        }

        free(prop);
    }
}

/**
 * @brief mgmt_new_object: Create a new mgmt object
 */
mgmt_object_t *mgmt_new_object()
{
    mgmt_object_t *ret;

    ret = malloc(sizeof(mgmt_object_t));
    if (ret != NULL) {
        ret->head = NULL;
        ret->next = NULL;
    }

    return ret;
}

/**
 * @brief mgmt_delete_object: Delete a mgmt object
 *
 * Since an object is just a list of properties we just delete the list
 */
void mgmt_delete_object(mgmt_object_t *obj)
{
    mgmt_property_t *prop;
    mgmt_property_t *next;

    if (obj != NULL) {
        prop = obj->head;
        while (prop) {
            next = prop->next;
            mgmt_delete_property(prop);
            prop = next;

        }

        free(obj);
    }
}

/**
 * @brief mgmt_object_add_property: Add a name/value pair to an object as a new property
 */
void mgmt_object_add_property(mgmt_object_t *obj, char *name, char *value, char *access)
{
    mgmt_property_t *prop;
    mgmt_property_t *node;

    if (obj == NULL) {
        return;
    }

    prop = mgmt_new_property(name, value, access);
    if (prop != NULL) {
        if (obj->head == NULL) {
            obj->head = prop;
            return;
        }

        node = obj->head;
        while (node->next != NULL) {
            node = node->next;
        }

        node->next = prop;
    }
}

char* mgmt_get_value(elxu_device_t *device, char *name)
{
    int rval;
    char *buf = calloc(INFO_BUFFER_SIZE, sizeof(char));
    static char result[INFO_BUFFER_SIZE];
    ocs_ioctl_cmd_get_t req;
    xmlDocPtr doc;
    xmlXPathContextPtr xpathCtx;
    xmlXPathObjectPtr xpathObj;
    char xmlExpr[1024];

    result[0] = '\0';

    req.name = (uint8_t *)name;
    req.value = (uint8_t *) buf;
    req.value_length = INFO_BUFFER_SIZE;
    req.status = 0;

    rval = elxu_ioctl_device(device, OCS_IOCTL_CMD_MGMT_GET, &req);
    if (rval) {
        if (req.status == -EBUSY) {
            printf("Error: Device is busy in performing other operations. Please retry the command\n");
        }
        free(buf);
        return result;
    }

    doc = xmlParseMemory(buf, strlen(buf));
    if (doc == NULL) {
        // Failed to parse the XML result
        free(buf);
        return result;
    }
    xpathCtx = xmlXPathNewContext(doc);
    if (xpathCtx == NULL) {
        xmlFreeDoc(doc);
        free(buf);
        return result;
    }

    if (strchr(name, '[')) {
        /*
         * If the name has predicates in it we need to change the format
         * to the correct XPath format.  That's because in the mgmt API
         * when we ask for domain[0] we want the domain with an instance
         * number of 0.  In XPath indexes start with 1, and they are numbered
         * sequentially.  So domain[1] would be the first domain found, not
         * the one with an instance number of 1.
         *
         * To fix this, anything in the name of the form "name[n]" needs to
         * be changed to "name[@instance='n']"
         */
        char *src;
        char *dest;

        dest = xmlExpr;
        src = name;

        while (*src != '\0') {
            if (*src == '[') {
                *dest++ = *src++;
                strcpy(dest, "@instance='");
                dest += strlen("@instance='");
                while (*src != ']') {
                    *dest++ = *src++;
                }
                *dest++ = '\'';
            } else {
                *dest++ = *src++;
            }
        }
        *dest = '\0';
    } else {
        /* Simple case - no predicates in the name, just use it as-is */
        sprintf(xmlExpr, "//%s", name);
    }

    xpathObj = xmlXPathEval((xmlChar *)xmlExpr, xpathCtx);
    if (xpathObj == NULL) {
        xmlXPathFreeContext(xpathCtx);
        xmlFreeDoc(doc);
        free(buf);
        return result;
    }

    strncpy(result, (char *)xmlXPathCastNodeSetToString(xpathObj->nodesetval) , sizeof(result) - 1);

    xmlXPathFreeContext(xpathCtx);
    xmlFreeDoc(doc);
    free(buf);
    return result;
}

int mgmt_set_value(elxu_device_t *device, char *name, char *value)
{
    ocs_ioctl_cmd_set_t req;
    int rc;

    req.name = (uint8_t *) name;
    req.value = (uint8_t *) value;

    rc = elxu_ioctl_device(device, OCS_IOCTL_CMD_MGMT_SET, &req);
    if (rc == 0) {
        rc = req.result;
        if (rc == -EBUSY) {
            printf("Device is busy in performing other operations. Please retry the command\n");
        }
    }

    return rc;
}

int mgmt_exec(elxu_device_t *device, char *name, void* arg_in, int arg_in_len, void* arg_out, int arg_out_len)
{
    ocs_ioctl_action_t req;

    req.name = (uint8_t *)name;
    req.arg_in = arg_in;
    req.arg_in_length = arg_in_len;
    req.arg_out = arg_out;
    req.arg_out_length = arg_out_len;

    if (elxu_ioctl_device(device, OCS_IOCTL_CMD_MGMT_EXEC, &req) != 0) {
        perror("ioctl");
    }
    return req.result;
}

mgmt_list_t* mgmt_get_all(elxu_device_t* device)
{
    char *buf = calloc(INFO_BUFFER_SIZE, sizeof(char));
    ocs_ioctl_mgmt_buffer_t req;
    int rval;
    mgmt_list_t *status_list;

    // Send the MGMT_GET_ALL ioctl to get all mgmt values
    req.user_buffer = (uint8_t *) buf;
    req.user_buffer_len = INFO_BUFFER_SIZE;

    rval = elxu_ioctl_device(device, OCS_IOCTL_CMD_MGMT_GET_ALL, &req);

    if (rval < 0) {
        perror("ioctl");
    }

    buf[req.bytes_written] = '\0';

    status_list = parse_list(buf);

    free(buf);
    return status_list;
}

static mgmt_list_t *parse_list(char *buf)
{
    mgmt_list_t *status_list;

    xmlDocPtr doc;
    xmlNodePtr cur;


    /* Create a list to store the values that we get back */
    status_list = mgmt_new_list();

    doc = xmlParseMemory(buf, strlen(buf));
    if (doc == NULL) {
        // Failed to parse the XML result
        return status_list;
    }
    cur = xmlDocGetRootElement(doc);

    parse_node(status_list, cur);

    xmlFreeDoc(doc);
    return status_list;
}

static void parse_node(mgmt_list_t *list, xmlNodePtr node)
{
    int numChildren;
    mgmt_object_t *obj;
    char long_name[OCS_MGMT_MAX_NAME];
    char *value = calloc(INFO_BUFFER_SIZE, sizeof(char));
    char *access;

    numChildren = xmlChildElementCount(node);
    if (numChildren == 0) {
        /* Leaf */
        strncpy(long_name, (char *)xmlGetNodePath(node) , sizeof(long_name) - 1);
        strncpy(value, (char *)xmlNodeGetContent(node) , INFO_BUFFER_SIZE - 1);
        access = (char *)xmlGetProp(node, (xmlChar *)"mode");
        if (access == NULL) {
            access = "";
        }

        obj = mgmt_new_object();
        mgmt_object_add_property(obj, long_name, value, access);
        mgmt_list_add(list, obj);
    } else {
        // Iterate over children, recursively parsing each
        xmlNodePtr child;

        child = xmlFirstElementChild(node);
        while (child) {
            parse_node(list, child);
            child = xmlNextElementSibling(child);
        }
    }
    free(value);
}

#if 0
    current_section[0] = '\0';



    /* Parse the values
     * We're looking for the beginning of a section:
     *   <section name="foo">
     * Or the end of a section:
     *   </section>
     * Or a property:
     *   <property name="foo" />
     */
    p = strtok(buf, "<");
    while (p) {

        if (strncmp(p, "section", 7) == 0) {
            // Beginning of a section
            // Extract the name
            char *p2 = strstr(p, "name=");
            p2 += 6;
            char *p3 = strchr(p2, '"');
            int len = p3 - p2;
            // The name is the (len) characters starting at (p2)
            char name[OCS_MGMT_MAX_NAME];
            strncpy(name, p2, len);
            name[len] = '\0';

            if (strlen(current_section) != 0) {
                strcat(current_section, ".");
            }
            strcat(current_section, name);

        } else if (strncmp(p, "/section", 8) == 0) {
            // End of a section
            char *p = strrchr(current_section, '.');
            if (p != NULL) {
                *p = '\0';
            } else {
                current_section[0] = '\0';
            }
        } else if (strncmp(p, "property", 8) == 0) {
            // Property
            // Extract the name
            char *p2 = strstr(p, "name=");
            p2 += 6;
            char *p3 = strchr(p2, '"');
            int len = p3 - p2;
            // The name is the (len) characters starting at (p2)
            char name[OCS_MGMT_MAX_NAME];
            strncpy(name, p2, len);
            name[len] = '\0';

            char long_name[OCS_MGMT_MAX_NAME];
            strcpy(long_name, current_section);
            if (strlen(long_name) > 0) {
                strcat(long_name, ".");
            }
            strcat(long_name, name);

            obj = mgmt_new_object();
            mgmt_object_add_property(obj, "name", long_name);
            mgmt_list_add(status_list, obj);
        } else {
            // Don't know what it is
        }

        p = strtok(NULL, "<");
    }

    return status_list;
}
#endif