cmdlang.c

Go to the documentation of this file.

/*
 * cmdlang.c
 *
 * A command interpreter for OpenIPMI
 *
 * Author: MontaVista Software, Inc.
 *         Corey Minyard <minyard@mvista.com>
 *         source@mvista.com
 *
 * Copyright 2004 MontaVista Software Inc.
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public License
 *  as published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *
 *  THIS SOFTWARE IS PROVIDED ``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 AUTHOR 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.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */


#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <OpenIPMI/ipmiif.h>
#include <OpenIPMI/ipmi_cmdlang.h>
#include <OpenIPMI/ipmi_pet.h>
#include <OpenIPMI/ipmi_lanparm.h>
#include <OpenIPMI/ipmi_solparm.h>
#include <OpenIPMI/ipmi_fru.h>
#include <OpenIPMI/ipmi_pef.h>
#include <OpenIPMI/ipmi_auth.h>
#include <OpenIPMI/ipmi_debug.h>
#include <OpenIPMI/ipmi_mc.h>

/* Internal includes, do not use in your programs */
#include <OpenIPMI/internal/ipmi_locks.h>
#include <OpenIPMI/internal/ipmi_malloc.h>

/*
 * This is the value passed to a command handler.
 */
struct ipmi_cmd_info_s
{
    void               *handler_data; /* From cb_data in the cmd reg */
    int                curr_arg;      /* Argument you should start at */
    int                argc;          /* Total number of arguments */
    char               **argv;        /* The arguments */

    /* Only allow one writer at a time */
    ipmi_lock_t        *lock;

    /* The cmdlang structure the user passed in.  Use this for output
       and error reporting. */
    ipmi_cmdlang_t     *cmdlang;

    /* The matching cmd structure for the command being executed.  May
       be NULL if no command is being processed. */
    ipmi_cmdlang_cmd_t *cmd;

    /* Refcount for the structure. */
    unsigned int       usecount;

    /* For use by the user commands */
    void *data;

    /* Used to know if the command generated output. */
    int did_output;
};


struct ipmi_cmdlang_cmd_s
{
    char                  *name;
    char                  *help;
    ipmi_help_finisher_cb help_finish;

    /* Only one of handler or subcmds may be non-NULL. */
    ipmi_cmdlang_handler_cb handler;
    ipmi_cmdlang_cmd_t      *subcmds;

    void                    *handler_data;

    /* Used for a linked list. */
    ipmi_cmdlang_cmd_t *next;
};

static os_handler_t *cmdlang_os_hnd;

/* Parse a string of the form [domain][(class)][.obj] and return each
   of the strings in the given string pointers. */
static int
parse_ipmi_objstr(char *str,
                  char **domain,
                  char **class,
                  char **obj)
{
    int  i;
    char *class_start = NULL, *class_end = NULL;

    for (i=0; str[i]; i++) {
        if (str[i] == '(') {
            if (class_start)
                /* Only one '(' allowed. */
                return EINVAL;
            class_start = str + i;
        } else if (str[i] == ')') {
            if (class_start) {
                /* a ')' only means something after a '('. */
                class_end = str + i;
                i++;
                break;
            }
        }
    }

    if (str[i]) {
        if (str[i] != '.')
            return EINVAL;
    }

    if (class_start) {
        if (!class_end)
            /* If class starts, must see the end paren. */
            return EINVAL;
        *class_start = '\0';
        *class_end = '\0';
        *class = class_start + 1;
    } else {
        *class = NULL;
    }

    if (strlen(str) == 0)
        *domain = NULL;
    else
        *domain = str;

    if (str[i])
        *obj = str + i + 1;
    else
        *obj = NULL;

    return 0;
}


/*
 * Handling for iterating domains.
 */

typedef struct domain_iter_info_s
{
    char               *cmpstr;
    ipmi_domain_ptr_cb handler;
    void               *cb_data;
    ipmi_cmd_info_t    *cmd_info;
} domain_iter_info_t;

static void
for_each_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    domain_iter_info_t *info = cb_data;
    ipmi_cmd_info_t    *cmd_info = info->cmd_info;
    char               domain_name[IPMI_DOMAIN_NAME_LEN];

    if (cmd_info->cmdlang->err)
        return;

    ipmi_domain_get_name(domain, domain_name, sizeof(domain_name));
    if ((!info->cmpstr) || (strcmp(info->cmpstr, domain_name) == 0))
        info->handler(domain, info->cb_data);
}

static void
for_each_domain(ipmi_cmd_info_t    *cmd_info,
                char               *domain,
                char               *class,
                char               *obj,
                ipmi_domain_ptr_cb handler,
                void               *cb_data)
{
    domain_iter_info_t info;

    if (class || obj) {
        cmd_info->cmdlang->errstr = "Invalid domain";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_domain)";
        return;
    }

    info.cmpstr = domain;
    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    ipmi_domain_iterate_domains(for_each_domain_handler, &info);
}

void
ipmi_cmdlang_domain_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;
    int  rv;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        rv = parse_ipmi_objstr(cmd_info->argv[cmd_info->curr_arg],
                               &domain, &class, &obj);
        if (rv) {
            cmd_info->cmdlang->errstr = "Invalid domain";
            cmd_info->cmdlang->err = rv;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_domain_handler)";
            return;
        }
        cmd_info->curr_arg++;
    }

    for_each_domain(cmd_info, domain, class, obj,
                    cmd_info->handler_data, cmd_info);
}


/*
 * Handling for iterating PETs.
 */
typedef struct pet_iter_info_s
{
    char            *cmdstr;
    ipmi_pet_ptr_cb handler;
    void            *cb_data;
    ipmi_cmd_info_t *cmd_info;
} pet_iter_info_t;

static void
for_each_pet_handler(ipmi_pet_t *pet, void *cb_data)
{
    pet_iter_info_t *info = cb_data;
    ipmi_cmd_info_t *cmd_info = info->cmd_info;
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
    char            name[IPMI_PET_NAME_LEN];
    char            *c;

    if (cmdlang->err)
        return;

    ipmi_pet_get_name(pet, name, sizeof(name));

    c = strrchr(name, '.');
    if (!c)
        goto out_err;
    c++;
    if ((! info->cmdstr) || (strcmp(info->cmdstr, c) == 0))
        info->handler(pet, info->cb_data);
    return;

 out_err:
    ipmi_cmdlang_global_err(name,
                            "cmdlang.c(for_each_pet_handler)",
                            "Bad PET name", EINVAL);
}

static void
for_each_pet_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_pet_iterate_pets(domain, for_each_pet_handler, cb_data);
}

static void
for_each_pet(ipmi_cmd_info_t *cmd_info,
             char            *domain,
             char            *class,
             char            *obj,
             ipmi_pet_ptr_cb handler,
             void            *cb_data)
{
    pet_iter_info_t info;

    if (class) {
        cmd_info->cmdlang->errstr = "Invalid PET";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_pet)";
        return;
    }

    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    info.cmdstr = obj;
    for_each_domain(cmd_info, domain, NULL, NULL,
                    for_each_pet_domain_handler, &info);
}

void
ipmi_cmdlang_pet_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        domain = cmd_info->argv[cmd_info->curr_arg];
        class = NULL;
        obj = strrchr(domain, '.');
        if (!obj) {
            cmd_info->cmdlang->errstr = "Invalid PET";
            cmd_info->cmdlang->err = EINVAL;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_pet_handler)";
            return;
        }
        *obj = '\0';
        obj++;
        cmd_info->curr_arg++;
    }

    for_each_pet(cmd_info, domain, class, obj, cmd_info->handler_data,
                 cmd_info);
}

/*
 * Handling for iterating LANPARMs.
 */
typedef struct lanparm_iter_info_s
{
    char                *cmdstr;
    ipmi_lanparm_ptr_cb handler;
    void                *cb_data;
    ipmi_cmd_info_t     *cmd_info;
} lanparm_iter_info_t;

static void
for_each_lanparm_handler(ipmi_lanparm_t *lanparm, void *cb_data)
{
    lanparm_iter_info_t *info = cb_data;
    ipmi_cmd_info_t *cmd_info = info->cmd_info;
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
    char            name[IPMI_LANPARM_NAME_LEN];
    char            *c;

    if (cmdlang->err)
        return;

    ipmi_lanparm_get_name(lanparm, name, sizeof(name));

    c = strrchr(name, '.');
    if (!c)
        goto out_err;
    c++;
    if ((! info->cmdstr) || (strcmp(info->cmdstr, c) == 0))
        info->handler(lanparm, info->cb_data);
    return;

 out_err:
    ipmi_cmdlang_global_err(name,
                            "cmdlang.c(for_each_lanparm_handler)",
                            "Bad LANPARM name", EINVAL);
}

static void
for_each_lanparm_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_lanparm_iterate_lanparms(domain, for_each_lanparm_handler, cb_data);
}

static void
for_each_lanparm(ipmi_cmd_info_t *cmd_info,
             char            *domain,
             char            *class,
             char            *obj,
             ipmi_lanparm_ptr_cb handler,
             void            *cb_data)
{
    lanparm_iter_info_t info;

    if (class) {
        cmd_info->cmdlang->errstr = "Invalid LANPARM";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_lanparm)";
        return;
    }

    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    info.cmdstr = obj;
    for_each_domain(cmd_info, domain, NULL, NULL,
                    for_each_lanparm_domain_handler, &info);
}

void
ipmi_cmdlang_lanparm_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        domain = cmd_info->argv[cmd_info->curr_arg];
        class = NULL;
        obj = strrchr(domain, '.');
        if (!obj) {
            cmd_info->cmdlang->errstr = "Invalid LANPARM";
            cmd_info->cmdlang->err = EINVAL;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_lanparm_handler)";
            return;
        }
        *obj = '\0';
        obj++;
        cmd_info->curr_arg++;
    }

    for_each_lanparm(cmd_info, domain, class, obj, cmd_info->handler_data,
                 cmd_info);
}

/*
 * Handling for iterating SOLPARMs.
 */
typedef struct solparm_iter_info_s
{
    char                *cmdstr;
    ipmi_solparm_ptr_cb handler;
    void                *cb_data;
    ipmi_cmd_info_t     *cmd_info;
} solparm_iter_info_t;

static void
for_each_solparm_handler(ipmi_solparm_t *solparm, void *cb_data)
{
    solparm_iter_info_t *info = cb_data;
    ipmi_cmd_info_t *cmd_info = info->cmd_info;
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
    char            name[IPMI_SOLPARM_NAME_LEN];
    char            *c;

    if (cmdlang->err)
        return;

    ipmi_solparm_get_name(solparm, name, sizeof(name));

    c = strrchr(name, '.');
    if (!c)
        goto out_err;
    c++;
    if ((! info->cmdstr) || (strcmp(info->cmdstr, c) == 0))
        info->handler(solparm, info->cb_data);
    return;

 out_err:
    ipmi_cmdlang_global_err(name,
                            "cmdlang.c(for_each_solparm_handler)",
                            "Bad SOLPARM name", EINVAL);
}

static void
for_each_solparm_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_solparm_iterate_solparms(domain, for_each_solparm_handler, cb_data);
}

static void
for_each_solparm(ipmi_cmd_info_t *cmd_info,
             char            *domain,
             char            *class,
             char            *obj,
             ipmi_solparm_ptr_cb handler,
             void            *cb_data)
{
    solparm_iter_info_t info;

    if (class) {
        cmd_info->cmdlang->errstr = "Invalid SOLPARM";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_solparm)";
        return;
    }

    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    info.cmdstr = obj;
    for_each_domain(cmd_info, domain, NULL, NULL,
                    for_each_solparm_domain_handler, &info);
}

void
ipmi_cmdlang_solparm_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        domain = cmd_info->argv[cmd_info->curr_arg];
        class = NULL;
        obj = strrchr(domain, '.');
        if (!obj) {
            cmd_info->cmdlang->errstr = "Invalid SOLPARM";
            cmd_info->cmdlang->err = EINVAL;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_solparm_handler)";
            return;
        }
        *obj = '\0';
        obj++;
        cmd_info->curr_arg++;
    }

    for_each_solparm(cmd_info, domain, class, obj, cmd_info->handler_data,
                 cmd_info);
}

/*
 * Handling for iterating PEFs.
 */
typedef struct pef_iter_info_s
{
    char            *cmdstr;
    ipmi_pef_ptr_cb handler;
    void            *cb_data;
    ipmi_cmd_info_t *cmd_info;
} pef_iter_info_t;

static void
for_each_pef_handler(ipmi_pef_t *pef, void *cb_data)
{
    pef_iter_info_t *info = cb_data;
    ipmi_cmd_info_t *cmd_info = info->cmd_info;
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
    char            name[IPMI_PEF_NAME_LEN];
    char            *c;

    if (cmdlang->err)
        return;

    ipmi_pef_get_name(pef, name, sizeof(name));

    c = strrchr(name, '.');
    if (!c)
        goto out_err;
    c++;
    if ((! info->cmdstr) || (strcmp(info->cmdstr, c) == 0))
        info->handler(pef, info->cb_data);
    return;

 out_err:
    ipmi_cmdlang_global_err(name,
                            "cmdlang.c(for_each_pef_handler)",
                            "Bad PEF name", EINVAL);
}

static void
for_each_pef_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_pef_iterate_pefs(domain, for_each_pef_handler, cb_data);
}

static void
for_each_pef(ipmi_cmd_info_t *cmd_info,
             char            *domain,
             char            *class,
             char            *obj,
             ipmi_pef_ptr_cb handler,
             void            *cb_data)
{
    pef_iter_info_t info;

    if (class) {
        cmd_info->cmdlang->errstr = "Invalid PEF";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_pef)";
        return;
    }

    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    info.cmdstr = obj;
    for_each_domain(cmd_info, domain, NULL, NULL,
                    for_each_pef_domain_handler, &info);
}

void
ipmi_cmdlang_pef_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        domain = cmd_info->argv[cmd_info->curr_arg];
        class = NULL;
        obj = strrchr(domain, '.');
        if (!obj) {
            cmd_info->cmdlang->errstr = "Invalid PEF";
            cmd_info->cmdlang->err = EINVAL;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_pef_handler)";
            return;
        }
        *obj = '\0';
        obj++;
        cmd_info->curr_arg++;
    }

    for_each_pef(cmd_info, domain, class, obj, cmd_info->handler_data,
                 cmd_info);
}


/*
 * Handling for iterating FRUs.
 */
typedef struct fru_iter_info_s
{
    char            *cmdstr;
    ipmi_fru_ptr_cb handler;
    void            *cb_data;
    ipmi_cmd_info_t *cmd_info;
} fru_iter_info_t;

static void
for_each_fru_handler(ipmi_fru_t *fru, void *cb_data)
{
    fru_iter_info_t *info = cb_data;
    ipmi_cmd_info_t *cmd_info = info->cmd_info;
    ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
    char            name[IPMI_FRU_NAME_LEN];
    char            *c;

    if (cmdlang->err)
        return;

    ipmi_fru_get_name(fru, name, sizeof(name));

    c = strrchr(name, '.');
    if (!c)
        goto out_err;
    c++;
    if ((! info->cmdstr) || (strcmp(info->cmdstr, c) == 0))
        info->handler(fru, info->cb_data);
    return;

 out_err:
    ipmi_cmdlang_global_err(name,
                            "cmdlang.c(for_each_fru_handler)",
                            "Bad FRU name", EINVAL);
}

static void
for_each_fru_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_fru_iterate_frus(domain, for_each_fru_handler, cb_data);
}

static void
for_each_fru(ipmi_cmd_info_t *cmd_info,
             char            *domain,
             char            *class,
             char            *obj,
             ipmi_fru_ptr_cb handler,
             void            *cb_data)
{
    fru_iter_info_t info;

    if (class) {
        cmd_info->cmdlang->errstr = "Invalid FRU";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_fru)";
        return;
    }

    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    info.cmdstr = obj;
    for_each_domain(cmd_info, domain, NULL, NULL,
                    for_each_fru_domain_handler, &info);
}

void
ipmi_cmdlang_fru_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        domain = cmd_info->argv[cmd_info->curr_arg];
        class = NULL;
        obj = strrchr(domain, '.');
        if (!obj) {
            cmd_info->cmdlang->errstr = "Invalid FRU";
            cmd_info->cmdlang->err = EINVAL;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_fru_handler)";
            return;
        }
        *obj = '\0';
        obj++;
        cmd_info->curr_arg++;
    }

    for_each_fru(cmd_info, domain, class, obj, cmd_info->handler_data,
                 cmd_info);
}


/*
 * Handling for iterating entities.
 */
typedef struct entity_iter_info_s
{
    char               *cmpstr;
    ipmi_entity_ptr_cb handler;
    void               *cb_data;
    ipmi_cmd_info_t    *cmd_info;
} entity_iter_info_t;

static void
for_each_entity_handler(ipmi_entity_t *entity, void *cb_data)
{
    entity_iter_info_t *info = cb_data;
    ipmi_cmd_info_t    *cmd_info = info->cmd_info;
    char               entity_name[IPMI_ENTITY_NAME_LEN];
    char               *c, *c2;

    if (cmd_info->cmdlang->err)
        return;

    ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
    c = strchr(entity_name, '(');
    if (!c)
        goto out_err;
    c++;
    c2 = strchr(c, ')');
    if (!c2)
        goto out_err;
    *c2 = '\0';
    if ((!info->cmpstr) || (strcmp(info->cmpstr, c) == 0)) {
        *c2 = ')';
        info->handler(entity, info->cb_data);
    } else
        *c2 = ')';
    return;

 out_err:
    ipmi_cmdlang_global_err(entity_name,
                            "cmdlang.c(for_each_entity_handler)",
                            "Bad entity name", EINVAL);
}

static void
for_each_entity_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_domain_iterate_entities(domain, for_each_entity_handler, cb_data);
}

static void
for_each_entity(ipmi_cmd_info_t    *cmd_info,
                char               *domain,
                char               *class,
                char               *obj,
                ipmi_entity_ptr_cb handler,
                void               *cb_data)
{
    entity_iter_info_t info;

    if (obj) {
        cmd_info->cmdlang->errstr = "Invalid entity";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_entity)";
        return;
    }

    info.cmpstr = class;
    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    for_each_domain(cmd_info, domain, NULL, NULL,
                    for_each_entity_domain_handler, &info);
}

void
ipmi_cmdlang_entity_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;
    int  rv;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        rv = parse_ipmi_objstr(cmd_info->argv[cmd_info->curr_arg],
                               &domain, &class, &obj);
        if (rv) {
            cmd_info->cmdlang->errstr = "Invalid entity";
            cmd_info->cmdlang->err = rv;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_entity_handler)";
            return;
        }
        cmd_info->curr_arg++;
    }

    for_each_entity(cmd_info, domain, class, obj,
                    cmd_info->handler_data, cmd_info);
}


/*
 * Handling for iterating sensors.
 */
typedef struct sensor_iter_info_s
{
    char               *cmpstr;
    ipmi_sensor_ptr_cb handler;
    void               *cb_data;
    ipmi_cmd_info_t    *cmd_info;
} sensor_iter_info_t;

static void
for_each_sensor_handler(ipmi_entity_t *entity,
                        ipmi_sensor_t *sensor,
                        void          *cb_data)
{
    sensor_iter_info_t *info = cb_data;
    char               sensor_name[IPMI_SENSOR_NAME_LEN];
    char               *c;

    ipmi_sensor_get_name(sensor, sensor_name, sizeof(sensor_name));
    c = strchr(sensor_name, '(');
    if (!c)
        goto out_err;
    c = strchr(c, ')');
    if (!c)
        goto out_err;
    c = strchr(c, '.');
    if (!c)
        goto out_err;
    c++;
    if ((!info->cmpstr) || (strcmp(info->cmpstr, c) == 0))
        info->handler(sensor, info->cb_data);
    return;

 out_err:
    ipmi_cmdlang_global_err(sensor_name,
                            "cmdlang.c(for_each_sensor_handler)",
                            "Bad sensor name", EINVAL);
}

static void
for_each_sensor_entity_handler(ipmi_entity_t *entity, void *cb_data)
{
    ipmi_entity_iterate_sensors(entity, for_each_sensor_handler, cb_data);
}

static void
for_each_sensor(ipmi_cmd_info_t    *cmd_info,
                char               *domain,
                char               *class,
                char               *obj,
                ipmi_sensor_ptr_cb handler,
                void               *cb_data)
{
    sensor_iter_info_t info;

    info.cmpstr = obj;
    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    for_each_entity(cmd_info, domain, class, NULL,
                    for_each_sensor_entity_handler, &info);
}

void
ipmi_cmdlang_sensor_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;
    int  rv;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        rv = parse_ipmi_objstr(cmd_info->argv[cmd_info->curr_arg],
                               &domain, &class, &obj);
        if (rv) {
            cmd_info->cmdlang->errstr = "Invalid sensor";
            cmd_info->cmdlang->err = rv;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_sensor_handler)";
            return;
        }
        cmd_info->curr_arg++;
    }

    for_each_sensor(cmd_info, domain, class, obj,
                    cmd_info->handler_data, cmd_info);
}


/*
 * Handling for iterating controls.
 */
typedef struct control_iter_info_s
{
    char                *cmpstr;
    ipmi_control_ptr_cb handler;
    void                *cb_data;
    ipmi_cmd_info_t     *cmd_info;
} control_iter_info_t;

static void
for_each_control_handler(ipmi_entity_t  *entity,
                         ipmi_control_t *control,
                         void           *cb_data)
{
    control_iter_info_t *info = cb_data;
    char                control_name[IPMI_CONTROL_NAME_LEN];
    char               *c;

    ipmi_control_get_name(control, control_name, sizeof(control_name));
    c = strchr(control_name, '(');
    if (!c)
        goto out_err;
    c = strchr(c, ')');
    if (!c)
        goto out_err;
    c = strchr(c, '.');
    if (!c)
        goto out_err;
    c++;
    if ((!info->cmpstr) || (strcmp(info->cmpstr, c) == 0))
        info->handler(control, info->cb_data);
    return;

 out_err:
    ipmi_cmdlang_global_err(control_name,
                            "cmdlang.c(for_each_control_handler)",
                            "Bad control name", EINVAL);
}

static void
for_each_control_entity_handler(ipmi_entity_t *entity, void *cb_data)
{
    ipmi_entity_iterate_controls(entity, for_each_control_handler, cb_data);
}

static void
for_each_control(ipmi_cmd_info_t     *cmd_info,
                 char                *domain,
                 char                *class,
                 char                *obj,
                 ipmi_control_ptr_cb handler,
                 void                *cb_data)
{
    control_iter_info_t info;

    info.cmpstr = obj;
    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    for_each_entity(cmd_info, domain, class, NULL,
                    for_each_control_entity_handler, &info);
}

void
ipmi_cmdlang_control_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;
    int  rv;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        rv = parse_ipmi_objstr(cmd_info->argv[cmd_info->curr_arg],
                               &domain, &class, &obj);
        if (rv) {
            cmd_info->cmdlang->errstr = "Invalid control";
            cmd_info->cmdlang->err = rv;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_control_handler)";
            return;
        }
        cmd_info->curr_arg++;
    }

    for_each_control(cmd_info, domain, class, obj,
                     cmd_info->handler_data, cmd_info);
}


/*
 * Handling for iterating mcs.
 */
typedef struct mc_iter_info_s
{
    char            *cmpstr;
    ipmi_mc_ptr_cb  handler;
    void            *cb_data;
    ipmi_cmd_info_t *cmd_info;
} mc_iter_info_t;

static void
for_each_mc_handler(ipmi_domain_t *domain, ipmi_mc_t *mc, void *cb_data)
{
    mc_iter_info_t  *info = cb_data;
    char            mc_name[IPMI_MC_NAME_LEN];
    char            *c, *c2;

    ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
    c = strchr(mc_name, '(');
    if (!c)
        goto out_err;
    c++;
    c2 = strchr(c, ')');
    if (!c2)
        goto out_err;
    *c2 = '\0';
    if ((!info->cmpstr) || (strcmp(info->cmpstr, c) == 0)) {
        *c2 = ')';
        info->handler(mc, info->cb_data);
    } else
        *c2 = ')';
    return;

 out_err:
    ipmi_cmdlang_global_err(mc_name,
                            "cmdlang.c(for_each_entity_handler)",
                            "Bad mc name", EINVAL);
}

static void
for_each_mc_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_domain_iterate_mcs(domain, for_each_mc_handler, cb_data);
}

static void
for_each_mc(ipmi_cmd_info_t *cmd_info,
            char            *domain,
            char            *class,
            char            *obj,
            ipmi_mc_ptr_cb  handler,
            void            *cb_data)
{
    mc_iter_info_t info;

    if (obj) {
        cmd_info->cmdlang->errstr = "Invalid MC";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_mc)";
        return;
    }

    info.cmpstr = class;
    info.handler = handler;
    info.cb_data = cb_data;
    info.cmd_info = cmd_info;
    for_each_domain(cmd_info, domain, NULL, NULL,
                    for_each_mc_domain_handler, &info);
}

void
ipmi_cmdlang_mc_handler(ipmi_cmd_info_t *cmd_info)
{
    char *domain, *class, *obj;
    int  rv;

    if (cmd_info->curr_arg >= cmd_info->argc) {
        domain = class = obj = NULL;
    } else {
        rv = parse_ipmi_objstr(cmd_info->argv[cmd_info->curr_arg],
                               &domain, &class, &obj);
        if (rv) {
            cmd_info->cmdlang->errstr = "Invalid MC";
            cmd_info->cmdlang->err = rv;
            cmd_info->cmdlang->location
                = "cmdlang.c(ipmi_cmdlang_mc_handler)";
            return;
        }
        cmd_info->curr_arg++;
    }

    for_each_mc(cmd_info, domain, class, obj, cmd_info->handler_data,
                cmd_info);
}


/*
 * Handling for iterating connections.
 */
typedef struct conn_iter_info_s
{
    int                    conn;
    ipmi_connection_ptr_cb handler;
    void                   *cb_data;
    ipmi_cmd_info_t        *cmd_info;
} conn_iter_info_t;

static void
for_each_conn_handler(ipmi_domain_t *domain, int conn, void *cb_data)
{
    conn_iter_info_t *info = cb_data;

    if ((info->conn == -1) || (info->conn == conn))
        info->handler(domain, conn, info->cb_data);
}

static void
for_each_conn_domain_handler(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_domain_iterate_connections(domain, for_each_conn_handler, cb_data);
}

static void
for_each_connection(ipmi_cmd_info_t        *cmd_info,
                    char                   *domain,
                    char                   *class,
                    char                   *obj,
                    ipmi_connection_ptr_cb handler,
                    void                   *cb_data)
{
    conn_iter_info_t info;
    char             *endptr;

    if (class) {
        cmd_info->cmdlang->errstr = "Invalid connection";
        cmd_info->cmdlang->err = EINVAL;
        cmd_info->cmdlang->location = "cmdlang.c(for_each_connection)";
        return;
    }

    if (obj) {
        if (!isdigit(obj[0])) {
            cmd_info->cmdlang->errstr = "Invalid connection number";
            cmd_info->cmdlang->err = EINVAL;
            cmd_info->cmdlang->location = "cmdlang.c(for_each_connection)";
            return;
        }
        info.