File: OpenIPMI.i

package info (click to toggle)
openipmi 2.0.37-1
links: PTS, VCS
area: main
in suites: forky, sid, trixie
size: 11,100 kB
sloc: ansic: 140,279; python: 8,801; sh: 5,723; perl: 5,394; makefile: 490
file content (12252 lines) | stat: -rw-r--r-- 330,112 bytes
/*
 * OpenIPMI.i
 *
 * A SWIG interface file 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.
 */

%module OpenIPMI

%{

#include <config.h>
#include <sys/types.h>
#include <sys/socket.h>

#ifdef HAVE_GETADDRINFO
#include <netdb.h>
#endif

#include <OpenIPMI/ipmiif.h>
#include <OpenIPMI/ipmi_auth.h>
#include <OpenIPMI/ipmi_mc.h>
#include <OpenIPMI/ipmi_fru.h>
#include <OpenIPMI/ipmi_msgbits.h>
#include <OpenIPMI/ipmi_conn.h>
#include <OpenIPMI/ipmi_posix.h>
#include <OpenIPMI/ipmi_debug.h>
#include <OpenIPMI/ipmi_user.h>
#include <OpenIPMI/ipmi_lanparm.h>
#include <OpenIPMI/ipmi_pef.h>
#include <OpenIPMI/ipmi_pet.h>
#include <OpenIPMI/ipmi_sol.h>
#include <OpenIPMI/ipmi_solparm.h>
#include <OpenIPMI/ipmi_err.h>
#include <OpenIPMI/ipmi_cmdlang.h>

#include <signal.h>

/* For ipmi_debug_malloc_cleanup() */
#include <OpenIPMI/internal/ipmi_malloc.h>

#include "OpenIPMI.h"

typedef struct intarray
{
    int *val;
    int len;
} intarray;

typedef struct charbuf
{
    char *val;
    int len;
} charbuf;

os_handler_t *swig_os_hnd;

static int
next_parm(char *s, int *start, int *next)
{
    while (s[*start] && isspace(s[*start]))
	(*start)++;
    if (!s[*start])
	return EINVAL;

    *next = *start;
    while (s[*next] && !isspace(s[*next]))
	(*next)++;
    return 0;
}

static int
next_colon_parm(char *s, int *start, int *next)
{
    while (s[*start] && (s[*start] == ':'))
	(*start)++;
    if (!s[*start])
	return EINVAL;

    *next = *start;
    while (s[*next] && (s[*next] != ':'))
	(*next)++;
    return 0;
}

static int
num_parm(char *s, int len, int *rval)
{
    char numstr[10];
    char *end;
    int  val;

    if (len > 9)
	return EINVAL;
    memcpy(numstr, s, len);
    numstr[len] = '\0';
    val = strtoul(numstr, &end, 0);
    if (*end != '\0')
	return EINVAL;
    *rval = val;
    return 0;
}

static int
parse_ipmi_addr(char *addr, int lun, ipmi_addr_t *i, unsigned int *addr_len)
{
    int start, next;
    int rv;
    int num;
    int len;

    start = 0;
    rv = next_parm(addr, &start, &next);
    if (rv)
	return rv;
    len = next - start;

    if (strncmp(addr+start, "smi", len) == 0) {
	ipmi_system_interface_addr_t *si = (void *) i;

	si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	si->lun = lun;
	start = next;
	rv = next_parm(addr, &start, &next);
	if (rv)
	    return rv;
	len = next - start;
	rv = num_parm(addr+start, len, &num);
	if (rv)
	    return rv;
	si->channel = num;
	*addr_len = sizeof(*si);
    } else if (strncmp(addr+start, "ipmb", len) == 0) {
	ipmi_ipmb_addr_t *ipmb = (void *) i;

	ipmb->addr_type = IPMI_IPMB_ADDR_TYPE;
	ipmb->lun = lun;

	start = next;
	rv = next_parm(addr, &start, &next);
	if (rv)
	    return rv;
	len = next - start;
	rv = num_parm(addr+start, len, &num);
	if (rv)
	    return rv;
	ipmb->channel = num;

	start = next;
	rv = next_parm(addr, &start, &next);
	if (rv)
	    return rv;
	len = next - start;
	rv = num_parm(addr+start, len, &num);
	if (rv)
	    return rv;
	ipmb->slave_addr = num;

	*addr_len = sizeof(*ipmb);
    } else {
	return EINVAL;
    }

    return 0;
}

static void
make_ipmi_addr(char *out, int max_len, ipmi_addr_t *addr, int addr_len,
	       int *lun)
{
    if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
	ipmi_system_interface_addr_t *si = (void *) addr;
	snprintf(out, max_len, "smi %d", si->channel);
	*lun = si->lun;
    } else if (addr->addr_type == IPMI_IPMB_ADDR_TYPE) {
	ipmi_ipmb_addr_t *ipmb = (void *) addr;
	snprintf(out, max_len, "ipmb %d %d", ipmb->channel, ipmb->slave_addr);
	*lun = ipmb->lun;
    } else {
	strncpy(out, "unknown", max_len);
	*lun = 0;
    }
}

static int
parse_ipmi_data(intarray data, unsigned char *odata,
		unsigned int max_len,
		unsigned int *rlen)
{
    int i;
    if (data.len > max_len)
	return E2BIG;
    for (i=0; i<data.len; i++)
	odata[i] = data.val[i];
    *rlen = data.len;
    return 0;
}

static unsigned char *
parse_raw_str_data(char *str, unsigned int *length)
{
    char *s = str;
    int  inspace = 1;
    int  count = 0;
    int  i;
    unsigned char *rv;
    char *endstr;

    while (*s) {
	if (inspace && !isspace(*s)) {
	    inspace = 0;
	    count++;
	} else if (!inspace && isspace(*s)) {
	    inspace = 1;
	}
	s++;
    }

    if (count == 0) {
	*length = 0;
	return malloc(1);
    }

    rv = malloc(count);
    if (!rv)
	return NULL;

    s = str;
    i = 0;
    while ((*s) && (i < count)) {
	rv[i] = strtoul(s, &endstr, 0);
	if (*endstr && (!isspace(*endstr)))
	    goto out_err;
	i++;
	s = endstr;
    }

    *length = count;
    return rv;

 out_err:
    free(rv);
    return NULL;
}

static int
parse_ip_addr(char *str, struct in_addr *addr)
{
#ifdef HAVE_GETADDRINFO
    struct addrinfo    hints, *res0, *s;
    struct sockaddr_in *paddr;
    int                rv;
 
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = PF_UNSPEC;
    hints.ai_socktype = SOCK_DGRAM;
    rv = getaddrinfo(str, "100", &hints, &res0);
    if (rv) {
	return EINVAL;
    }
    /* Only get the first ipv4 */
    s = res0;
    while (s) {
	if (s->ai_family == PF_INET)
	    break;
	s = s->ai_next;
    }
    if (!s) {
	freeaddrinfo(res0);
	return EINVAL;
    }
    paddr = (struct sockaddr_in *) s->ai_addr;
    *addr = paddr->sin_addr;
    freeaddrinfo(res0);
    return 0;
#else
/* System does not support getaddrinfo, just for IPv4*/
    struct hostent *ent;
    ent = gethostbyname(str);
    if (!ent)
	return EINVAL;
    memcpy(&addr->s_addr, ent->h_addr_list[0], 4);
    return 0;
#endif
}

static int
parse_mac_addr(char *str, unsigned char *addr)
{
    char *s;
    int  i;
    char *endstr;

    s = str;
    while (isspace(*s))
	s++;
    if (! isxdigit(*s))
	return EINVAL;
    for (i=0; i<5; i++) {
	addr[i] = strtoul(s, &endstr, 16);
	if (*endstr != ':')
	    return EINVAL;
	s = endstr+1;
    }
    addr[i] = strtoul(s, &endstr, 16);
    if (*endstr != '\0')
	return EINVAL;
    return 0;
}
%}

%{
/* For output returning an array of constant strings */
typedef struct strconstarray
{
    const char **val;
    int len;
} strconstarray;

/* For input only */
typedef struct argarray
{
    char **val;
    int len;
} argarray;

/* For input only */
typedef struct iargarray
{
    ipmi_args_t **val;
    int         len;
} iargarray;
%}
typedef struct strconstarray
{
    const char **val;
    int len;
} strconstarray;
typedef struct argarray
{
    char **val;
    int len;
} argarray;
typedef struct iargarray
{
    ipmi_args_t **val;
    int        len;
} iargarray;

%include "OpenIPMI_lang.i"

%nodefault;

%{
swig_cb_val *swig_log_handler;

void
openipmi_swig_vlog(os_handler_t *os_handler, const char *format,
		   enum ipmi_log_type_e log_type, va_list ap)
{
    char *pfx = "";
    static char log[1024];
    static int curr = 0;
    swig_cb_val *handler = swig_log_handler;

    if (! handler)
	return;

    switch(log_type)
    {
    case IPMI_LOG_INFO:
	pfx = "INFO";
	break;

    case IPMI_LOG_WARNING:
	pfx = "WARN";
	break;

    case IPMI_LOG_SEVERE:
	pfx = "SEVR";
	break;

    case IPMI_LOG_FATAL:
	pfx = "FATL";
	break;

    case IPMI_LOG_ERR_INFO:
	pfx = "EINF";
	break;

    case IPMI_LOG_DEBUG:
	pfx = "DEBG";
	break;

    case IPMI_LOG_DEBUG_START:
    case IPMI_LOG_DEBUG_CONT:
	if (curr < sizeof(log))
	    curr += vsnprintf(log+curr, sizeof(log)-curr, format, ap);
	return;

    case IPMI_LOG_DEBUG_END:
	if (curr < sizeof(log))
	    vsnprintf(log+curr, sizeof(log)-curr, format, ap);
	pfx = "DEBG";
	curr = 0;
	goto plog;
    }

    vsnprintf(log, sizeof(log), format, ap);

 plog:
    swig_call_cb(handler, "log", "%s%s", pfx, log);
}

static void
handle_domain_cb(ipmi_domain_t *domain, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "domain_cb", "%p", &domain_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
}

static void
domain_connect_change_handler(ipmi_domain_t *domain,
			      int           err,
			      unsigned int  conn_num,
			      unsigned int  port_num,
			      int           still_connected,
			      void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "conn_change_cb", "%p%d%d%d%d",
		 &domain_ref, err, conn_num, port_num, still_connected);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
}

static void
domain_connect_change_handler_cl(ipmi_domain_con_cb handler,
				 void               *handler_data,
				 void               *cb_data)
{
    if (handler != domain_connect_change_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
domain_iterate_connections_handler(ipmi_domain_t *domain, int conn,
				   void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "domain_iter_connection_cb", "%p%d", &domain_ref, conn);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
}

static void
domain_event_handler(ipmi_domain_t *domain, ipmi_event_t *event, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    swig_ref    event_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    event_ref = swig_make_ref_destruct(ipmi_event_dup(event), ipmi_event_t);
    swig_call_cb(cb, "event_cb", "%p%p", &domain_ref, &event_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    swig_free_ref(event_ref);
}

static void
domain_event_handler_cl(ipmi_event_handler_cb handler,
			void                  *handler_data,
			void                  *cb_data)
{
    if (handler != domain_event_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
domain_mc_updated_handler(enum ipmi_update_e op, ipmi_domain_t *domain,
			  ipmi_mc_t *mc, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    swig_ref    mc_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_update_cb", "%s%p%p",
		 ipmi_update_e_string(op), &domain_ref, &mc_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
}

static void
domain_mc_updated_handler_cl(ipmi_domain_mc_upd_cb handler,
			     void                  *handler_data,
			     void                  *cb_data)
{
    if (handler != domain_mc_updated_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
domain_entity_update_handler(enum ipmi_update_e op, ipmi_domain_t *domain,
			      ipmi_entity_t *entity, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    swig_ref    entity_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    swig_call_cb(cb, "entity_update_cb", "%s%p%p",
		 ipmi_update_e_string(op), &domain_ref, &entity_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
}

static void
domain_entity_update_handler_cl(ipmi_domain_entity_cb handler,
				void                  *handler_data,
				void                  *cb_data)
{
    if (handler != domain_entity_update_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
domain_fully_up(ipmi_domain_t *domain, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "domain_up_cb", "%p", &domain_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
parse_args_iter_help_hnd(const char *name, const char *help, void *cb_data)
{
    swig_cb_val *cb = cb_data;

    swig_call_cb(cb, "parse_args_iter_help_cb", "%s%s", name, help);
}

static void
domain_close_done(void *cb_data)
{
    swig_cb_val *cb = cb_data;

    swig_call_cb(cb, "domain_close_done_cb", " ");
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
domain_iterate_entities_handler(ipmi_entity_t *entity, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    swig_ref    entity_ref;

    domain_ref = swig_make_ref(ipmi_entity_get_domain(entity), ipmi_domain_t);
    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    swig_call_cb(cb, "domain_iter_entity_cb", "%p%p",
		 &domain_ref, &entity_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
}

static void
ipmb_mc_scan_handler(ipmi_domain_t *domain, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "domain_ipmb_mc_scan_cb", "%p%d", &domain_ref, err);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
domain_reread_sels_handler(ipmi_domain_t *domain, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "domain_reread_sels_cb", "%p%d", &domain_ref, err);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
}

static int
domain_msg_cb(ipmi_domain_t *domain, ipmi_msgi_t *rspi)
{
    swig_cb_val   *cb = rspi->data1;
    swig_ref      domain_ref;
    ipmi_msg_t    *msg = &rspi->msg;
    ipmi_addr_t   *addr = &rspi->addr;
    int           addr_len = rspi->addr_len;
    char          addr_str[50];
    int           lun;

    make_ipmi_addr(addr_str, sizeof(addr_str), addr, addr_len, &lun);
    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "domain_addr_cmd_cb", "%p%s%d%d%d%*s", &domain_ref,
		 addr_str, lun, msg->netfn, msg->cmd,
		 msg->data_len, msg->data);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    
    return IPMI_MSG_ITEM_NOT_USED;
}

static void
domain_iterate_mcs_handler(ipmi_domain_t *domain, ipmi_mc_t *mc, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    swig_ref    mc_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "domain_iter_mc_cb", "%p%p", &domain_ref, &mc_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
}

static void
fru_written_done(ipmi_domain_t *domain, ipmi_fru_t *fru,
		 int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    swig_ref    fru_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    fru_ref = swig_make_ref_destruct(fru, ipmi_fru_t);
    /* The FRU is already referenced because of the callback, no need
       to mess with refcounts. */
    swig_call_cb(cb, "fru_written", "%p%p%d", &domain_ref, &fru_ref, err);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    swig_free_ref(fru_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
fru_fetched(ipmi_domain_t *domain, ipmi_fru_t *fru, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    swig_ref    fru_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    fru_ref = swig_make_ref_destruct(fru, ipmi_fru_t);
    /* The FRU is already referenced because of the callback, no need
       to mess with refcounts. */
    swig_call_cb(cb, "fru_fetched", "%p%p%d", &domain_ref, &fru_ref, err);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    swig_free_ref(fru_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
handle_entity_cb(ipmi_entity_t *entity, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    swig_call_cb(cb, "entity_cb", "%p", &entity_ref);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
}

static void
entity_iterate_entities_handler(ipmi_entity_t *ent1,
				ipmi_entity_t *ent2,
				void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    ent1_ref;
    swig_ref    ent2_ref;

    ent1_ref = swig_make_ref(ent1, ipmi_entity_t);
    ent2_ref = swig_make_ref(ent2, ipmi_entity_t);
    swig_call_cb(cb, "entity_iter_entities_cb", "%p%p", &ent1_ref, &ent2_ref);
    swig_free_ref_check(ent2_ref, ipmi_entity_t);
    swig_free_ref_check(ent1_ref, ipmi_entity_t);
}

static void
entity_iterate_sensors_handler(ipmi_entity_t *entity,
			       ipmi_sensor_t *sensor,
			       void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    sensor_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "entity_iter_sensors_cb", "%p%p",
		 &entity_ref, &sensor_ref);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
}

static void
entity_iterate_controls_handler(ipmi_entity_t  *entity,
				ipmi_control_t *control,
				void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    control_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    control_ref = swig_make_ref(control, ipmi_control_t);
    swig_call_cb(cb, "entity_iter_controls_cb", "%p%p",
		 &entity_ref, &control_ref);
    swig_free_ref_check(control_ref, ipmi_control_t);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
}

static int
entity_presence_handler(ipmi_entity_t *entity,
			int           present,
			void          *cb_data,
			ipmi_event_t  *event)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    event_ref;
    int         rv = IPMI_EVENT_NOT_HANDLED;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    event_ref = swig_make_ref_destruct(ipmi_event_dup(event), ipmi_event_t);
    swig_call_cb_rv('I', &rv, cb, "entity_presence_cb", "%p%d%p",
		    &entity_ref, present, &event_ref);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    swig_free_ref(event_ref);
    return rv;
}

static void
entity_presence_handler_cl(ipmi_entity_presence_change_cb handler,
			   void                           *handler_data,
			   void                           *cb_data)
{
    if (handler != entity_presence_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
entity_sensor_update_handler(enum ipmi_update_e op,
			     ipmi_entity_t      *entity,
			     ipmi_sensor_t      *sensor,
			     void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    sensor_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "entity_sensor_update_cb", "%s%p%p",
		 ipmi_update_e_string(op), &entity_ref, &sensor_ref);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
}

static void
entity_sensor_update_handler_cl(ipmi_entity_sensor_cb handler,
				 void                  *handler_data,
				 void                  *cb_data)
{
    if (handler != entity_sensor_update_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
entity_control_update_handler(enum ipmi_update_e op,
			      ipmi_entity_t      *entity,
			      ipmi_control_t     *control,
			      void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    control_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    control_ref = swig_make_ref(control, ipmi_control_t);
    swig_call_cb(cb, "entity_control_update_cb", "%s%p%p",
		 ipmi_update_e_string(op), &entity_ref, &control_ref);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    swig_free_ref_check(control_ref, ipmi_control_t);
}

static void
entity_control_update_handler_cl(ipmi_entity_control_cb handler,
				 void                  *handler_data,
				 void                  *cb_data)
{
    if (handler != entity_control_update_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
entity_fru_update_handler(enum ipmi_update_e op,
			  ipmi_entity_t      *entity,
			  void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    fru_ref;
    ipmi_fru_t  *fru;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    fru = ipmi_entity_get_fru(entity);
    if (fru)
	ipmi_fru_ref(fru);
    fru_ref = swig_make_ref_destruct(fru, ipmi_fru_t);
    swig_call_cb(cb, "entity_fru_update_cb", "%s%p%p",
		 ipmi_update_e_string(op), &entity_ref, &fru_ref);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    swig_free_ref(fru_ref);
}

static void
entity_fru_update_werr_handler(enum ipmi_update_werr_e op,
			       int                     err,
			       ipmi_entity_t           *entity,
			       void                    *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    fru_ref;
    ipmi_fru_t  *fru;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    fru = ipmi_entity_get_fru(entity);
    if (fru)
	ipmi_fru_ref(fru);
    fru_ref = swig_make_ref_destruct(fru, ipmi_fru_t);
    swig_call_cb(cb, "entity_fru_update_werr_cb", "%s%d%p%p",
		 ipmi_update_werr_e_string(op), err, &entity_ref, &fru_ref);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    swig_free_ref(fru_ref);
}

static void
entity_fru_update_handler_cl(ipmi_entity_fru_cb handler,
			     void               *handler_data,
			     void               *cb_data)
{
    if (handler != entity_fru_update_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
entity_fru_update_werr_handler_cl(ipmi_entity_fru_werr_cb handler,
				  void                    *handler_data,
				  void                    *cb_data)
{
    if (handler != entity_fru_update_werr_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static int
entity_hot_swap_handler(ipmi_entity_t             *entity,
			enum ipmi_hot_swap_states last_state,
			enum ipmi_hot_swap_states curr_state,
			void                      *cb_data,
			ipmi_event_t              *event)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;
    swig_ref    event_ref;
    int         rv = IPMI_EVENT_NOT_HANDLED;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    event_ref = swig_make_ref_destruct(ipmi_event_dup(event), ipmi_event_t);
    swig_call_cb_rv('I', &rv,
		    cb, "entity_hot_swap_update_cb", "%p%s%s%p", &entity_ref,
		    ipmi_hot_swap_state_name(last_state),
		    ipmi_hot_swap_state_name(curr_state),
		    &event_ref);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    swig_free_ref(event_ref);
    return rv;
}

static void
entity_hot_swap_handler_cl(ipmi_entity_hot_swap_cb handler,
			   void                    *handler_data,
			   void                    *cb_data)
{
    if (handler != entity_hot_swap_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
entity_get_hot_swap_handler(ipmi_entity_t             *entity,
			    int                       err,
			    enum ipmi_hot_swap_states state,
			    void                      *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    swig_call_cb(cb, "entity_hot_swap_cb", "%p%d%s", &entity_ref,
		 err, ipmi_hot_swap_state_name(state));
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
entity_get_hot_swap_time_handler(ipmi_entity_t  *entity,
				 int            err,
				 ipmi_timeout_t time,
				 void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    swig_call_cb(cb, "entity_hot_swap_get_time_cb", "%p%d%f", &entity_ref,
		 err, ((double) time) / 1000000000.0);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
entity_set_hot_swap_time_handler(ipmi_entity_t  *entity,
				 int            err,
				 void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    swig_call_cb(cb, "entity_hot_swap_set_time_cb", "%p%d", &entity_ref, err);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
entity_activate_handler(ipmi_entity_t  *entity,
			int            err,
			void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    entity_ref;

    entity_ref = swig_make_ref(entity, ipmi_entity_t);
    swig_call_cb(cb, "entity_activate_cb", "%p%d", &entity_ref, err);
    swig_free_ref_check(entity_ref, ipmi_entity_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
handle_mc_cb(ipmi_mc_t *mc, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_cb", "%p", &mc_ref);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
}

static void
mc_active_handler(ipmi_mc_t  *mc,
		  int        active,
		  void       *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_active_cb", "%p%d", &mc_ref, active);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
}

static void
mc_active_handler_cl(ipmi_mc_active_cb handler,
		     void              *handler_data,
		     void              *cb_data)
{
    if (handler != mc_active_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
mc_fully_up_handler(ipmi_mc_t *mc, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_fully_up_cb", "%p", &mc_ref);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
}

static void
mc_fully_up_handler_cl(ipmi_mc_ptr_cb handler,
		       void           *handler_data,
		       void           *cb_data)
{
    if (handler != mc_fully_up_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
mc_msg_cb(ipmi_mc_t  *mc,
	  ipmi_msg_t *msg,
	  void       *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_cmd_cb", "%p%d%d%*s", &mc_ref,
		 msg->netfn, msg->cmd, msg->data_len, msg->data);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_reset_handler(ipmi_mc_t *mc, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_reset_cb", "%p%d", &mc_ref, err);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_events_enable_handler(ipmi_mc_t *mc, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_events_enable_cb", "%p%d", &mc_ref, err);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_get_event_log_enable_handler(ipmi_mc_t *mc, int err, int val, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_get_event_log_enable_cb", "%p%d%d",
		 &mc_ref, err, val);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_set_event_log_enable_handler(ipmi_mc_t *mc, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_set_event_log_enable_cb", "%p%d", &mc_ref, err);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_reread_sensors_handler(ipmi_mc_t *mc, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_reread_sensors_cb", "%p%d", &mc_ref, err);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_reread_sel_handler(ipmi_mc_t *mc, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_reread_sel_cb", "%p%d", &mc_ref, err);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_sel_get_time_cb(ipmi_mc_t     *mc,
		   int           err,
		   unsigned long time,
		   void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_get_sel_time_cb", "%p%d%ld", &mc_ref, err, time);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_channel_get_info(ipmi_mc_t           *mc,
		    int                 err,
		    ipmi_channel_info_t *info,
		    void                *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;
    swig_ref    info_ref;

    info = ipmi_channel_info_copy(info);
    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    info_ref = swig_make_ref_destruct(info, ipmi_channel_info_t);
    swig_call_cb(cb, "mc_channel_got_info_cb", "%p%d%p", &mc_ref, err,
		 &info_ref);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    swig_free_ref(info_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_channel_get_access(ipmi_mc_t             *mc,
		      int                   err,
		      ipmi_channel_access_t *info,
		      void                  *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;
    swig_ref    info_ref;

    info = ipmi_channel_access_copy(info);
    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    info_ref = swig_make_ref_destruct(info, ipmi_channel_access_t);
    swig_call_cb(cb, "mc_channel_got_access_cb", "%p%d%p", &mc_ref, err,
		 &info_ref);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    swig_free_ref(info_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_channel_set_access(ipmi_mc_t *mc,
		      int       err,
		      void      *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_channel_set_access_cb", "%p%d", &mc_ref, err);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_channel_got_users(ipmi_mc_t        *mc,
		     int              err,
		     ipmi_user_list_t *info,
		     void             *cb_data)
{
    swig_cb_val  *cb = cb_data;
    swig_ref     mc_ref;
    swig_ref     *info_ref;
    int		 free_info_ref = 0;
    int          count;
    swig_ref     dummy;
    int          i;
    unsigned int max, enabled, fixed;

    if (info) {
	count = ipmi_user_list_get_user_count(info);
	info_ref = malloc(count * sizeof(swig_ref));
	if (!info_ref) {
	    count = 0;
	    info_ref = &dummy;
	} else {
	    free_info_ref = 1;
	}
    } else {
	count = 0;
	info_ref = &dummy;
    }

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    for (i=0; i<count; i++) {
	ipmi_user_t *user = ipmi_user_list_get_user(info, i);
	info_ref[i] = swig_make_ref_destruct(user, ipmi_user_t);
    }
    ipmi_user_list_get_max_user(info, &max);
    ipmi_user_list_get_enabled_users(info, &enabled);
    ipmi_user_list_get_fixed_users(info, &fixed);
    swig_call_cb(cb, "mc_channel_got_users_cb", "%p%d%d%d%d%*o", &mc_ref, err,
		 max, enabled, fixed, count, info_ref);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    for (i=0; i<count; i++)
	swig_free_ref(info_ref[i]);
    if (free_info_ref)
	free(info_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
mc_channel_set_user(ipmi_mc_t *mc,
		    int       err,
		    void      *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    mc_ref;

    mc_ref = swig_make_ref(mc, ipmi_mc_t);
    swig_call_cb(cb, "mc_channel_set_user_cb", "%p%d", &mc_ref, err);
    swig_free_ref_check(mc_ref, ipmi_mc_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
handle_sensor_cb(ipmi_sensor_t *sensor, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_cb", "%p", &sensor_ref);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
}

static char *
threshold_str(char *s, enum ipmi_thresh_e thresh)
{
    if (thresh == IPMI_UPPER_NON_CRITICAL) {
	*s = 'u'; s++; *s = 'n'; s++;
    } else if (thresh == IPMI_UPPER_CRITICAL) {
	*s = 'u'; s++; *s = 'c'; s++;
    } else if (thresh == IPMI_UPPER_NON_RECOVERABLE) {
	*s = 'u'; s++; *s = 'r'; s++;
    } else if (thresh == IPMI_LOWER_NON_CRITICAL) {
	*s = 'l'; s++; *s = 'n'; s++;
    } else if (thresh == IPMI_LOWER_CRITICAL) {
	*s = 'l'; s++; *s = 'c'; s++;
    } else if (thresh == IPMI_LOWER_NON_RECOVERABLE) {
	*s = 'l'; s++; *s = 'r'; s++;
    }
      
    return s;
}

static char *
threshold_from_str(char *s, int len, enum ipmi_thresh_e *thresh)
{
    if (len != 2)
	return NULL;

    if (strncasecmp(s, "un", 2) == 0)
	*thresh = IPMI_UPPER_NON_CRITICAL;
    else if (strncasecmp(s, "uc", 2) == 0)
	*thresh = IPMI_UPPER_CRITICAL;
    else if (strncasecmp(s, "ur", 2) == 0)
	*thresh = IPMI_UPPER_NON_RECOVERABLE;
    else if (strncasecmp(s, "ln", 2) == 0)
	*thresh = IPMI_LOWER_NON_CRITICAL;
    else if (strncasecmp(s, "lc", 2) == 0)
	*thresh = IPMI_LOWER_CRITICAL;
    else if (strncasecmp(s, "lr", 2) == 0)
	*thresh = IPMI_LOWER_NON_RECOVERABLE;
    else
	return NULL;
    return s+2;
}

static char *
threshold_event_str(char                        *s, 
		    enum ipmi_thresh_e          thresh,
		    enum ipmi_event_value_dir_e value_dir,
		    enum ipmi_event_dir_e       dir)
{
    s = threshold_str(s, thresh);
    if (value_dir == IPMI_GOING_HIGH) {
	*s = 'h'; s++;
    } else {
	*s = 'l'; s++;
    }
    if (dir == IPMI_ASSERTION) {
	*s = 'a'; s++;
    } else {
	*s = 'd'; s++;
    }
    *s = '\0';
    return s;
}

static char *
threshold_event_from_str(char                        *s,
			 int                        len,
			 enum ipmi_thresh_e          *thresh,
			 enum ipmi_event_value_dir_e *value_dir,
			 enum ipmi_event_dir_e       *dir)
{
    if (len != 4)
	return NULL;

    s = threshold_from_str(s, 2, thresh);

    if (*s == 'l')
	*value_dir = IPMI_GOING_LOW;
    else if (*s == 'h')
	*value_dir = IPMI_GOING_HIGH;
    else
	return NULL;
    s++;
    if (*s == 'a')
	*dir = IPMI_ASSERTION;
    else if (*s == 'd')
	*dir = IPMI_DEASSERTION;
    else
	return NULL;
    s++;
    return s;
}

static char *
discrete_event_from_str(char                  *s,
			int                   len,
			int                   *offset,
			enum ipmi_event_dir_e *dir)
{
    if ((len < 2) || (len > 3))
	return NULL;

    *offset = strtoul(s, &s, 0);
    if (*offset >= 15)
	return NULL;
    if (*s == 'a')
	*dir = IPMI_ASSERTION;
    else if (*s == 'd')
	*dir = IPMI_DEASSERTION;
    else
	return NULL;
    s++;
    return s;
}

static char *
discrete_event_str(char                   *s, 
		   int                    offset,
		   enum ipmi_event_dir_e dir)
{
    if (offset >= 100)
	offset = 99;
    if (offset < 0)
	offset = 0;
    s += sprintf(s, "%d", offset);
    if (dir == IPMI_ASSERTION) {
	*s = 'a'; s++;
    } else {
	*s = 'd'; s++;
    }
    *s = '\0';
    return s;
}

static char *
threshold_event_state_to_str(ipmi_event_state_t *events)
{
    int                         len = 0;
    char                        *str;
    enum ipmi_thresh_e          thresh;
    enum ipmi_event_value_dir_e value_dir;
    enum ipmi_event_dir_e       dir;
    char                        *s;

    if (ipmi_event_state_get_events_enabled(events))
	len += strlen("events ");
    if (ipmi_event_state_get_scanning_enabled(events))
	len += strlen("scanning ");
    if (ipmi_event_state_get_busy(events))
	len += strlen("busy ");

    for (thresh = IPMI_LOWER_NON_CRITICAL;
	 thresh <= IPMI_UPPER_NON_RECOVERABLE; 
	 thresh++)
    {
	for (value_dir = IPMI_GOING_LOW;
	     value_dir <= IPMI_GOING_HIGH;
	     value_dir++)
	{
	    for (dir = IPMI_ASSERTION;
		 dir <= IPMI_DEASSERTION;
		 dir++)
	    {
		if (ipmi_is_threshold_event_set(events,thresh, value_dir, dir))
		    len += 5;
	    }
	}
    }

    str = malloc(len+1);
    str[0] = '\0';
    
    if (ipmi_event_state_get_events_enabled(events))
	strcat(str, "events ");
    if (ipmi_event_state_get_scanning_enabled(events))
	strcat(str, "scanning ");
    if (ipmi_event_state_get_busy(events))
	strcat(str, "busy ");
    s = str + strlen(str);

    for (thresh = IPMI_LOWER_NON_CRITICAL;
	 thresh <= IPMI_UPPER_NON_RECOVERABLE; 
	 thresh++)
    {
	for (value_dir = IPMI_GOING_LOW;
	     value_dir <= IPMI_GOING_HIGH;
	     value_dir++)
	{
	    for (dir = IPMI_ASSERTION;
		 dir <= IPMI_DEASSERTION;
		 dir++)
	    {
		if (!ipmi_is_threshold_event_set(events,thresh,value_dir,dir))
		    continue;

		s = threshold_event_str(s, thresh, value_dir, dir);
		*s = ' ';
		s++;
	    }
	}
    }
    *s = '\0';
    len = s - str;
    if (len > 0)
	str[len-1] = '\0'; /* Remove the final space */

    return str;
}

static int
str_to_threshold_event_state(char               *str,
			     ipmi_event_state_t **events)
{
    enum ipmi_thresh_e          thresh;
    enum ipmi_event_value_dir_e value_dir;
    enum ipmi_event_dir_e       dir;
    ipmi_event_state_t          *e;
    int                         start, next;
    int                         rv;

    e = malloc(ipmi_event_state_size());
    ipmi_event_state_init(e);

    start = 0;
    rv = next_parm(str, &start, &next);
    while (!rv) {
	char *s = str+start;
	int  len = next - start;
	if (strncasecmp(s, "events", len) == 0)
	    ipmi_event_state_set_events_enabled(e, 1);
	else if (strncasecmp(s, "scanning", len) == 0)
	    ipmi_event_state_set_scanning_enabled(e, 1);
	else if (strncasecmp(s, "busy", len) == 0)
	    ipmi_event_state_set_busy(e, 1);
	else {
	    s = threshold_event_from_str(s, len, &thresh, &value_dir, &dir);
	    if (!s)
		goto out_err;

	    ipmi_threshold_event_set(e, thresh, value_dir, dir);
	}

	start = next;
	rv = next_parm(str, &start, &next);
    }

    *events = e;
    return 0;

 out_err:
    free(e);
    return EINVAL;
}

static char *
discrete_event_state_to_str(ipmi_event_state_t *events)
{
    int                   len = 0;
    char                  *str;
    int                   offset;
    enum ipmi_event_dir_e dir;
    char                  *s;

    if (ipmi_event_state_get_events_enabled(events))
	len += strlen("events ");
    if (ipmi_event_state_get_scanning_enabled(events))
	len += strlen("scanning ");
    if (ipmi_event_state_get_busy(events))
	len += strlen("busy ");

    for (offset=0; offset<15; offset++) {
	for (dir = IPMI_ASSERTION;
	     dir <= IPMI_DEASSERTION;
	     dir++)
	{
	    if (ipmi_is_discrete_event_set(events, offset, dir))
		    len += 4;
	}
    }

    str = malloc(len+1);
    str[0] = '\0';
    
    if (ipmi_event_state_get_events_enabled(events))
	strcat(str, "events ");
    if (ipmi_event_state_get_scanning_enabled(events))
	strcat(str, "scanning ");
    if (ipmi_event_state_get_busy(events))
	strcat(str, "busy ");
    s = str + strlen(str);

    for (offset=0; offset<15; offset++) {
	for (dir = IPMI_ASSERTION;
	     dir <= IPMI_DEASSERTION;
	     dir++)
	{
	    if (! ipmi_is_discrete_event_set(events, offset, dir))
		continue;

	    s = discrete_event_str(s, offset, dir);
	    *s = ' ';
	    s++;
	}
    }
    *s = '\0';

    len = s - str;
    if (len > 0)
	str[len-1] = '\0'; /* Remove the final space */

    return str;
}

static int
str_to_discrete_event_state(char               *str,
			    ipmi_event_state_t **events)
{
    int                   offset;
    enum ipmi_event_dir_e dir;
    ipmi_event_state_t    *e;
    int                   start, next;
    int                   rv;

    e = malloc(ipmi_event_state_size());
    ipmi_event_state_init(e);

    start = 0;
    rv = next_parm(str, &start, &next);
    while (!rv) {
	char *s = str+start;
	int  len = next - start;
	if (strncasecmp(s, "events", len) == 0)
	    ipmi_event_state_set_events_enabled(e, 1);
	else if (strncasecmp(s, "scanning", len) == 0)
	    ipmi_event_state_set_scanning_enabled(e, 1);
	else if (strncasecmp(s, "busy", len) == 0)
	    ipmi_event_state_set_busy(e, 1);
	else {
	    s = discrete_event_from_str(s, len, &offset, &dir);
	    if (!s)
		goto out_err;
	    ipmi_discrete_event_set(e, offset, dir);
	}
	start = next;
	rv = next_parm(str, &start, &next);
    }

    *events = e;
    return 0;

 out_err:
    free(e);
    return EINVAL;
}

static char *
threshold_states_to_str(ipmi_states_t *states)
{
    int                len = 0;
    char               *str;
    enum ipmi_thresh_e thresh;
    char               *s;

    if (ipmi_is_event_messages_enabled(states))
	len += strlen("events ");
    if (ipmi_is_sensor_scanning_enabled(states))
	len += strlen("scanning ");
    if (ipmi_is_initial_update_in_progress(states))
	len += strlen("busy ");

    for (thresh = IPMI_LOWER_NON_CRITICAL;
	 thresh <= IPMI_UPPER_NON_RECOVERABLE; 
	 thresh++)
    {
	if (ipmi_is_threshold_out_of_range(states, thresh))
	    len += 3;
    }

    str = malloc(len+1);
    str[0] = '\0';
    
    if (ipmi_is_event_messages_enabled(states))
	strcat(str, "events ");
    if (ipmi_is_sensor_scanning_enabled(states))
	strcat(str, "scanning ");
    if (ipmi_is_initial_update_in_progress(states))
	strcat(str, "busy ");
    s = str + strlen(str);

    for (thresh = IPMI_LOWER_NON_CRITICAL;
	 thresh <= IPMI_UPPER_NON_RECOVERABLE; 
	 thresh++)
    {
	if (!ipmi_is_threshold_out_of_range(states, thresh))
	    continue;

	s = threshold_str(s, thresh);
	*s = ' ';
	s++;
    }
    *s = '\0';

    len = s - str;
    if (len > 0)
	str[len-1] = '\0'; /* Remove the final space */

    return str;
}

static char *
discrete_states_to_str(ipmi_states_t *states)
{
    int  len = 0;
    char *str;
    int  offset;
    char *s;

    if (ipmi_is_event_messages_enabled(states))
	len += strlen("events ");
    if (ipmi_is_sensor_scanning_enabled(states))
	len += strlen("scanning ");
    if (ipmi_is_initial_update_in_progress(states))
	len += strlen("busy ");

    for (offset=0; offset<15; offset++) {
	if (ipmi_is_state_set(states, offset))
	    len += 3;
    }

    str = malloc(len+1);
    str[0] = '\0';
    
    if (ipmi_is_event_messages_enabled(states))
	strcat(str, "events ");
    if (ipmi_is_sensor_scanning_enabled(states))
	strcat(str, "scanning ");
    if (ipmi_is_initial_update_in_progress(states))
	strcat(str, "busy ");
    s = str + strlen(str);

    for (offset=0; offset<15; offset++) {
	if (! ipmi_is_state_set(states, offset))
	    continue;

	s += sprintf(s, "%d", offset);
	*s = ' ';
	s++;
    }
    *s = '\0';

    len = s - str;
    if (len > 0)
	str[len-1] = '\0'; /* Remove the final space */

    return str;
}

static char *
thresholds_to_str(ipmi_thresholds_t *t)
{
    int                len = 0;
    char               *str;
    enum ipmi_thresh_e thresh;
    char               dummy[3];
    char               *s;
    double             val;

    for (thresh = IPMI_LOWER_NON_CRITICAL;
	 thresh <= IPMI_UPPER_NON_RECOVERABLE; 
	 thresh++)
    {
	if (ipmi_threshold_get(t, thresh, &val) == 0)
	    len += snprintf(dummy, 1, "aa %f:", val) + 1;
    }

    str = malloc(len+1);
    s = str;
    
    for (thresh = IPMI_LOWER_NON_CRITICAL;
	 thresh <= IPMI_UPPER_NON_RECOVERABLE; 
	 thresh++)
    {
	if (ipmi_threshold_get(t, thresh, &val) != 0)
	    continue;

	threshold_str(dummy, thresh);
	dummy[2] = '\0';

	s += sprintf(s, "%s %f:", dummy, val);
	*s = ' ';
	s++;
    }
    *s = '\0';

    len = s - str;
    if (len > 0)
	str[len-2] = '\0'; /* Remove the final ': ' */

    return str;
}

static int
str_to_thresholds(char              *str,
		  ipmi_sensor_t     *sensor,
		  ipmi_thresholds_t **thresholds)
{
    enum ipmi_thresh_e thresh;
    ipmi_thresholds_t  *t;
    int                start, next;
    int                rv;
    double             val;
    int                err = EINVAL;

    t = malloc(ipmi_thresholds_size());
    ipmi_thresholds_init(t);

    start = 0;
    rv = next_colon_parm(str, &start, &next);
    while (!rv) {
	char *s = str+start;
	char *endstr;
	int  len = next - start;
	if (len < 4)
	    goto out_err;

	if (strncasecmp(s, "un ", 3) == 0)
	    thresh = IPMI_UPPER_NON_CRITICAL;
	else if (strncasecmp(s, "uc ", 3) == 0)
	    thresh = IPMI_UPPER_CRITICAL;
	else if (strncasecmp(s, "ur ", 3) == 0)
	    thresh = IPMI_UPPER_NON_RECOVERABLE;
	else if (strncasecmp(s, "ln ", 3) == 0)
	    thresh = IPMI_LOWER_NON_CRITICAL;
	else if (strncasecmp(s, "lc ", 3) == 0)
	    thresh = IPMI_LOWER_CRITICAL;
	else if (strncasecmp(s, "lr ", 3) == 0)
	    thresh = IPMI_LOWER_NON_RECOVERABLE;
	else
	    goto out_err;

	val = strtod(s+3, &endstr);
	if ((*endstr != ':') && (*endstr != '\0'))
	    goto out_err;

	rv = ipmi_threshold_set(t, sensor, thresh, val);
	if (rv) {
	    err = rv;
	    goto out_err;
	}
	start = next;
	rv = next_colon_parm(str, &start, &next);
    }

    *thresholds = t;
    return 0;

 out_err:
    free(t);
    return err;
}

static int
sensor_threshold_event_handler(ipmi_sensor_t               *sensor,
			       enum ipmi_event_dir_e       dir,
			       enum ipmi_thresh_e          threshold,
			       enum ipmi_event_value_dir_e high_low,
			       enum ipmi_value_present_e   value_present,
			       unsigned int                raw_value,
			       double                      value,
			       void                        *cb_data,
			       ipmi_event_t                *event)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;
    char        eventstr[5];
    int         raw_set = 0;
    int         value_set = 0;
    swig_ref    event_ref;
    int         rv = IPMI_EVENT_NOT_HANDLED;

    if (value_present == IPMI_RAW_VALUE_PRESENT)
	raw_set = 1;
    if (value_present == IPMI_BOTH_VALUES_PRESENT) {
	raw_set = 1;
	value_set = 1;
    }
    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    threshold_event_str(eventstr, threshold, high_low, dir);
    event_ref = swig_make_ref_destruct(ipmi_event_dup(event), ipmi_event_t);
    swig_call_cb_rv('I', &rv,
		    cb, "threshold_event_cb", "%p%s%d%d%d%f%p", &sensor_ref,
		    eventstr, raw_set, raw_value, value_set, value,
		    &event_ref);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    swig_free_ref(event_ref);
    return rv;
}

static void
sensor_threshold_event_handler_cl(ipmi_sensor_threshold_event_cb handler,
				  void                           *handler_data,
				  void                           *cb_data)
{
    if (handler != sensor_threshold_event_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static int
sensor_discrete_event_handler(ipmi_sensor_t         *sensor,
			      enum ipmi_event_dir_e dir,
			      int                   offset,
			      int                   severity,
			      int                   prev_severity,
			      void                  *cb_data,
			      ipmi_event_t          *event)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;
    char        eventstr[5];
    swig_ref    event_ref;
    int         rv = IPMI_EVENT_NOT_HANDLED;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    discrete_event_str(eventstr, offset, dir);
    event_ref = swig_make_ref_destruct(ipmi_event_dup(event), ipmi_event_t);
    swig_call_cb_rv('I', &rv,
		    cb, "discrete_event_cb", "%p%s%d%d%p", &sensor_ref,
		    eventstr, severity, prev_severity, &event_ref);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    swig_free_ref(event_ref);
    return rv;
}

static void
sensor_discrete_event_handler_cl(ipmi_sensor_discrete_event_cb handler,
				 void                          *handler_data,
				 void                          *cb_data)
{
    if (handler != sensor_discrete_event_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

/*
 * For the event method call_handler to use.
 */
typedef struct event_call_handler_data_s
{
    ipmi_event_t          *event;
    swig_cb_val           *handlers_val;
    ipmi_event_handlers_t *handlers;
    int                   rv;
} event_call_handler_data_t;

static void event_call_handler_mc_cb(ipmi_mc_t *mc, void *cb_data)
{
    event_call_handler_data_t *info = cb_data;
    ipmi_domain_t             *domain = ipmi_mc_get_domain(mc);

    info->rv = ipmi_event_call_handler(domain, info->handlers,
				       info->event, info->handlers_val);
}

/* A generic callback for a lot of things. */
static void
sensor_event_enable_handler(ipmi_sensor_t *sensor,
			    int           err,
			    void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_event_enable_cb", "%p%d", &sensor_ref, err);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sensor_get_event_enables_handler(ipmi_sensor_t      *sensor,
				 int                err,
				 ipmi_event_state_t *states,
				 void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;
    char        *st;

    if (ipmi_sensor_get_event_reading_type(sensor)
	== IPMI_EVENT_READING_TYPE_THRESHOLD)
    {
	st = threshold_event_state_to_str(states);
    } else {
	st = discrete_event_state_to_str(states);
    }

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_get_event_enable_cb", "%p%d%s",
		 &sensor_ref, err, st);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    free(st);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sensor_rearm_handler(ipmi_sensor_t      *sensor,
		     int                err,
		     void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_rearm_cb", "%p%d", &sensor_ref, err);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sensor_get_hysteresis_handler(ipmi_sensor_t *sensor,
			      int           err,
			      unsigned int  positive_hysteresis,
			      unsigned int  negative_hysteresis,
			      void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_get_hysteresis_cb", "%p%d%d%d", &sensor_ref, err,
		 positive_hysteresis, negative_hysteresis);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sensor_set_hysteresis_handler(ipmi_sensor_t      *sensor,
			      int                err,
			      void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_set_hysteresis_cb", "%p%d", &sensor_ref, err);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sensor_set_thresholds_handler(ipmi_sensor_t      *sensor,
			      int                err,
			      void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_set_thresholds_cb", "%p%d", &sensor_ref, err);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void sensor_get_thresholds_handler(ipmi_sensor_t     *sensor,
					  int               err,
					  ipmi_thresholds_t *th,
					  void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;
    char        *thstr = thresholds_to_str(th);

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    swig_call_cb(cb, "sensor_get_thresholds_cb", "%p%d%s", &sensor_ref, err,
		 thstr);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    free(thstr);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sensor_get_reading_handler(ipmi_sensor_t             *sensor,
			   int                       err,
			   enum ipmi_value_present_e value_present,
			   unsigned int              raw_value,
			   double                    value,
			   ipmi_states_t             *states,
			   void                      *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;
    int         raw_set = 0;
    int         value_set = 0;
    char        *statestr;

    if (value_present == IPMI_RAW_VALUE_PRESENT)
	raw_set = 1;
    if (value_present == IPMI_BOTH_VALUES_PRESENT) {
	raw_set = 1;
	value_set = 1;
    }
    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    statestr = threshold_states_to_str(states);
    swig_call_cb(cb, "threshold_reading_cb", "%p%d%d%d%d%f%s", &sensor_ref,
		 err, raw_set, raw_value, value_set, value, statestr);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    free(statestr);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sensor_get_states_handler(ipmi_sensor_t *sensor,
			  int           err,
			  ipmi_states_t *states,
			  void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    sensor_ref;
    char        *statestr;

    sensor_ref = swig_make_ref(sensor, ipmi_sensor_t);
    statestr = discrete_states_to_str(states);
    swig_call_cb(cb, "discrete_states_cb", "%p%d%s", &sensor_ref,
		 err, statestr);
    swig_free_ref_check(sensor_ref, ipmi_sensor_t);
    free(statestr);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static int
str_to_color(char *s, int len, int *color)
{
    int i;

    for (i=IPMI_CONTROL_COLOR_BLACK; i<=IPMI_CONTROL_COLOR_ORANGE; i++) {
	if (strncasecmp(s, ipmi_get_color_string(i), len) == 0) {
	    *color = i;
	    return 0;
	}
    }

    return EINVAL;
}

static int
str_to_light_setting(char *s, ipmi_light_setting_t **setting)
{
    int                  rv;
    ipmi_light_setting_t *e;
    int                  start, next;
    int                  count;

    count = 0;
    start = 0;
    rv = next_colon_parm(s, &start, &next);
    while (!rv) {
	start = next;
	count++;
	rv = next_colon_parm(s, &start, &next);
    }
    if (count == 0)
	return EINVAL;

    e = ipmi_alloc_light_settings(count);

    count = 0;
    start = 0;
    rv = next_colon_parm(s, &start, &next);
    while (!rv) {
	int  color, on_time, off_time;
	char *ms;
	int  mstart, mnext;
	char *endstr;
	char buf[100];
	int  len = next - start;

	if (len >= 100)
	    goto out_err;

	memcpy(buf, s+start, len);
	buf[len] = '\0';

	ms = buf;
	mstart = 0;
	rv = next_parm(ms, &mstart, &mnext);
	if (rv)
	    goto out_err;
	len = mnext - mstart;
	if ((len == 2) && (strncasecmp(ms+mstart, "lc", 2) == 0)) {
	    rv = ipmi_light_setting_set_local_control(e, count, 1);
	    if (rv)
		goto out_err;

	    mstart = mnext;
	    rv = next_parm(ms, &mstart, &mnext);
	    if (rv)
		goto out_err;
	}

	rv = str_to_color(ms+mstart, mnext-mstart, &color);
	if (rv)
	    goto out_err;

	mstart = mnext;
	rv = next_parm(ms, &mstart, &mnext);
	if (rv)
	    goto out_err;
	on_time = strtoul(ms+mstart, &endstr, 0);
	if (endstr != (ms+mnext))
	    goto out_err;

	mstart = mnext;
	rv = next_parm(ms, &mstart, &mnext);
	if (rv)
	    goto out_err;
	off_time = strtoul(ms+mstart, &endstr, 0);
	if (endstr != (ms+mnext))
	    goto out_err;

	rv = ipmi_light_setting_set_color(e, count, color);
	rv |= ipmi_light_setting_set_on_time(e, count, on_time);
	rv |= ipmi_light_setting_set_off_time(e, count, off_time);
	if (rv)
	    goto out_err;

	count++;

	start = next;
	rv = next_colon_parm(s, &start, &next);
    }
    
    *setting = e;
    return 0;

 out_err:
    ipmi_free_light_settings(e);
    return EINVAL;
}

static char *
light_setting_to_str(ipmi_light_setting_t *e)
{
    char *s, *str;
    int  i;
    int  count = ipmi_light_setting_get_count(e);
    char dummy[1];
    int  size = 0;

    for (i = 0; i < count; i++) {
	int val;
	size += 1; /* For the colon */
	val = 0;
	ipmi_light_setting_in_local_control(e, i, &val);
	if (val)
	    size += 3;
	val = 0;
	ipmi_light_setting_get_color(e, i, &val);
	size += strlen(ipmi_get_color_string(val)) + 1;
	val = 0;
	ipmi_light_setting_get_on_time(e, i, &val);
	size += snprintf(dummy, 1, "%d ", val);
	val = 0;
	ipmi_light_setting_get_off_time(e, i, &val);
	size += snprintf(dummy, 1, "%d ", val);
    }

    str = malloc(size + 1);
    if (!str)
	return NULL;
    s = str;

    for (i = 0; i < count; i++) {
	int val;
	const char *ov;

	val = 0;
	ipmi_light_setting_in_local_control(e, i, &val);
	if (val) {
	    strcpy(s, "lc ");
	    s += 3;
	}

	val = 0;
	ipmi_light_setting_get_color(e, i, &val);
	ov = ipmi_get_color_string(val);
	strcpy(s, ov);
	s += strlen(ov);
	*s = ' ';
	s++;

	val = 0;
	ipmi_light_setting_get_on_time(e, i, &val);
	s += sprintf(s, "%d ", val);

	val = 0;
	ipmi_light_setting_get_off_time(e, i, &val);
	s += sprintf(s, "%d", val);

	*s = ':';
	s++;
    }
    if (s != str) {
	/* Remove the final colon. */
	s--;
	*s = '\0';
    } else {
	*s = '\0';
    }

    return str;
}

static void
handle_control_cb(ipmi_control_t *control, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    control_ref;

    control_ref = swig_make_ref(control, ipmi_control_t);
    swig_call_cb(cb, "control_cb", "%p", &control_ref);
    swig_free_ref_check(control_ref, ipmi_control_t);
}

static void
control_val_set_handler(ipmi_control_t *control, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    control_ref;

    control_ref = swig_make_ref(control, ipmi_control_t);
    swig_call_cb(cb, "control_set_val_cb", "%p%d", &control_ref, err);
    swig_free_ref_check(control_ref, ipmi_control_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
control_val_get_handler(ipmi_control_t *control, int err, int *val,
			void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    control_ref;

    control_ref = swig_make_ref(control, ipmi_control_t);
    if (err) {
	/* On err, value may be NULL */
	int dummy;
	swig_call_cb(cb, "control_get_val_cb", "%p%d%*p", &control_ref, err,
		     1, &dummy);
    } else {
	swig_call_cb(cb, "control_get_val_cb", "%p%d%*p", &control_ref, err,
		     ipmi_control_get_num_vals(control), val);
    }
    swig_free_ref_check(control_ref, ipmi_control_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
control_val_get_light_handler(ipmi_control_t *control, int err,
			      ipmi_light_setting_t *val,
			      void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    control_ref;
    char        *str;
    int		free_str = 1;

    control_ref = swig_make_ref(control, ipmi_control_t);
    str = light_setting_to_str(val);
    if (!str) {
	str = "err";
	free_str = 0;
    }
    swig_call_cb(cb, "control_get_light_cb", "%p%d%s", &control_ref, err, str);
    swig_free_ref_check(control_ref, ipmi_control_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    if (free_str)
	free(str);
}

static void
control_val_get_id_handler(ipmi_control_t *control, int err,
			   unsigned char *val, int length,
			   void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    control_ref;

    control_ref = swig_make_ref(control, ipmi_control_t);
    swig_call_cb(cb, "control_get_id_cb", "%p%d%*s", &control_ref, err,
		 length, val);
    swig_free_ref_check(control_ref, ipmi_control_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static int
control_val_event_handler(ipmi_control_t *control, int *valid_vals, int *val,
			  void *cb_data, ipmi_event_t *event)
{
    swig_cb_val *cb = cb_data;
    swig_ref    control_ref;
    swig_ref    event_ref;
    int         rv = IPMI_EVENT_NOT_HANDLED;

    control_ref = swig_make_ref(control, ipmi_control_t);
    event_ref = swig_make_ref_destruct(ipmi_event_dup(event), ipmi_event_t);
    swig_call_cb_rv('I', &rv,
		    cb, "control_event_val_cb", "%p%p%*p%*p", &control_ref,
		    &event_ref,
		    ipmi_control_get_num_vals(control), valid_vals,
		    ipmi_control_get_num_vals(control), val);
    swig_free_ref_check(control_ref, ipmi_control_t);
    swig_free_ref(event_ref);
    return rv;
}

static void
control_val_event_handler_cl(ipmi_control_val_event_cb handler,
			     void                      *handler_data,
			     void                      *cb_data)
{
    if (handler != control_val_event_handler)
	return;
    swig_cb_val *handler_val = handler_data;
    deref_swig_cb_val(handler_val);
}

static void
lanparm_get_parm(ipmi_lanparm_t *lanparm,
		 int            err,
		 unsigned char  *data,
		 unsigned int   data_len,
		 void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    lanparm_ref;

    lanparm_ref = swig_make_ref_destruct(lanparm, ipmi_lanparm_t);
    swig_call_cb(cb, "lanparm_got_parm_cb", "%p%d%*s", &lanparm_ref, err,
		 data_len, (char *) data);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(lanparm_ref);
}

static void
lanparm_set_parm(ipmi_lanparm_t *lanparm,
		 int            err,
		 void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    lanparm_ref;

    if (cb) {
	lanparm_ref = swig_make_ref_destruct(lanparm, ipmi_lanparm_t);
	swig_call_cb(cb, "lanparm_set_parm_cb", "%p%d", &lanparm_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(lanparm_ref);
    }
}

static void
lanparm_get_config(ipmi_lanparm_t    *lanparm,
		   int               err,
		   ipmi_lan_config_t *config,
		   void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    lanparm_ref;
    swig_ref    config_ref;

    lanparm_ref = swig_make_ref_destruct(lanparm, ipmi_lanparm_t);
    config_ref = swig_make_ref_destruct(config, ipmi_lan_config_t);
    swig_call_cb(cb, "lanparm_got_config_cb", "%p%d%p", &lanparm_ref, err,
		 &config_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(lanparm_ref);
    swig_free_ref(config_ref);
}

static void
lanparm_set_config(ipmi_lanparm_t    *lanparm,
		   int               err,
		   void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    lanparm_ref;

    if (cb) {
	lanparm_ref = swig_make_ref_destruct(lanparm, ipmi_lanparm_t);
	swig_call_cb(cb, "lanparm_set_config_cb", "%p%d", &lanparm_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(lanparm_ref);
    }
}

static void
lanparm_clear_lock(ipmi_lanparm_t    *lanparm,
		   int               err,
		   void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    lanparm_ref;

    if (cb) {
	lanparm_ref = swig_make_ref_destruct(lanparm, ipmi_lanparm_t);
	swig_call_cb(cb, "lanparm_clear_lock_cb", "%p%d", &lanparm_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(lanparm_ref);
    }
}

static void
get_pef(ipmi_pef_t *pef, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    pef_ref;

    pef_ref = swig_make_ref_destruct(pef, ipmi_pef_t);
    ipmi_pef_ref(pef);
    swig_call_cb(cb, "got_pef_cb", "%p%d", &pef_ref, err);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(pef_ref);
}

static void
pef_get_parm(ipmi_pef_t    *pef,
	     int           err,
	     unsigned char *data,
	     unsigned int  data_len,
	     void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    pef_ref;

    pef_ref = swig_make_ref_destruct(pef, ipmi_pef_t);
    swig_call_cb(cb, "pef_got_parm_cb", "%p%d%*s", &pef_ref, err,
		 data_len, (char *) data);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(pef_ref);
}

static void
pef_set_parm(ipmi_pef_t *pef,
	     int        err,
	     void       *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    pef_ref;

    if (cb) {
	pef_ref = swig_make_ref_destruct(pef, ipmi_pef_t);
	swig_call_cb(cb, "pef_set_parm_cb", "%p%d", &pef_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(pef_ref);
    }
}

static void
pef_get_config(ipmi_pef_t        *pef,
	       int               err,
	       ipmi_pef_config_t *config,
	       void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    pef_ref;
    swig_ref    config_ref;

    pef_ref = swig_make_ref_destruct(pef, ipmi_pef_t);
    config_ref = swig_make_ref_destruct(config, ipmi_pef_config_t);
    swig_call_cb(cb, "pef_got_config_cb", "%p%d%p", &pef_ref, err,
		 &config_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(pef_ref);
    swig_free_ref(config_ref);
}

static void
pef_set_config(ipmi_pef_t    *pef,
	       int           err,
	       void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    pef_ref;

    if (cb) {
	pef_ref = swig_make_ref_destruct(pef, ipmi_pef_t);
	swig_call_cb(cb, "pef_set_config_cb", "%p%d", &pef_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(pef_ref);
    }
}

static void
pef_clear_lock(ipmi_pef_t    *pef,
	       int           err,
	       void          *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    pef_ref;

    if (cb) {
	pef_ref = swig_make_ref_destruct(pef, ipmi_pef_t);
	swig_call_cb(cb, "pef_clear_lock_cb", "%p%d", &pef_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(pef_ref);
    }
}

static void
get_pet(ipmi_pet_t *pet, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    pet_ref;

    pet_ref = swig_make_ref_destruct(pet, ipmi_pet_t);
    ipmi_pet_ref(pet);
    swig_call_cb(cb, "got_pet_cb", "%p%d", &pet_ref, err);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(pet_ref);
}

static void
event_deleted_handler(ipmi_domain_t *domain, int err, void *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;

    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "event_delete_cb", "%p%d", &domain_ref, err);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
}

static void
sol_connection_state_change_cb(ipmi_sol_conn_t *conn,
			       ipmi_sol_state  state,
			       int             error,
			       void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_connection_state_change", "%p%d%d",
		 &conn_ref, state, error);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
}


static int
sol_data_received_cb(ipmi_sol_conn_t *conn,
		     const void      *buf,
		     size_t          count,
		     void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;
    int         rv = 0;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb_rv('i', &rv, cb, "sol_data_received", "%p%*s",
		    &conn_ref, (int) count, (char *) buf);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
    return rv;
}

static void
sol_break_detected_cb(ipmi_sol_conn_t *conn,
		      void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_break_detected", "%p", &conn_ref);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
}

static void
sol_bmc_transmit_overrun_cb(ipmi_sol_conn_t *conn,
			    void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_bmc_transmit_overrun", "%p", &conn_ref);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
}

static void
sol_write_complete_cb(ipmi_sol_conn_t *conn,
		      int             error,
		      void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_write_complete", "%p%d", &conn_ref, error);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
    /* One-time callback */
    deref_swig_cb_val(cb);
}

static void
sol_send_break_cb(ipmi_sol_conn_t *conn,
		  int             error,
		  void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_send_break", "%p%d", &conn_ref, error);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
    /* One-time callback */
    deref_swig_cb_val(cb);
}

static void
sol_set_CTS_assertable_cb(ipmi_sol_conn_t *conn,
			  int             error,
			  void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_set_CTS_assertable", "%p%d", &conn_ref, error);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
    /* One-time callback */
    deref_swig_cb_val(cb);
}

static void
sol_set_DCD_DSR_asserted_cb(ipmi_sol_conn_t *conn,
			    int             error,
			    void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_set_DCD_DSR_asserted", "%p%d", &conn_ref, error);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
    /* One-time callback */
    deref_swig_cb_val(cb);
}

static void
sol_set_RI_asserted_cb(ipmi_sol_conn_t *conn,
		       int             error,
		       void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_set_RI_asserted", "%p%d", &conn_ref, error);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
    /* One-time callback */
    deref_swig_cb_val(cb);
}

static void
sol_flush_complete_cb(ipmi_sol_conn_t *conn,
		      int             error,
		      int             queue_selectors_flushed,
		      void            *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    conn_ref;

    conn_ref = swig_make_ref(conn, ipmi_sol_conn_t);
    swig_call_cb(cb, "sol_flush_complete", "%p%d%d", &conn_ref, error,
		 queue_selectors_flushed);
    swig_free_ref_check(conn_ref, ipmi_sol_conn_t);
    /* One-time callback */
    deref_swig_cb_val(cb);
}

static void
solparm_get_parm(ipmi_solparm_t *solparm,
		 int            err,
		 unsigned char  *data,
		 unsigned int   data_len,
		 void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    solparm_ref;

    solparm_ref = swig_make_ref_destruct(solparm, ipmi_solparm_t);
    swig_call_cb(cb, "solparm_got_parm_cb", "%p%d%*s", &solparm_ref, err,
		 data_len, (char *) data);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(solparm_ref);
}

static void
solparm_set_parm(ipmi_solparm_t *solparm,
		 int            err,
		 void           *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    solparm_ref;

    if (cb) {
	solparm_ref = swig_make_ref_destruct(solparm, ipmi_solparm_t);
	swig_call_cb(cb, "solparm_set_parm_cb", "%p%d", &solparm_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(solparm_ref);
    }
}

static void
solparm_get_config(ipmi_solparm_t    *solparm,
		   int               err,
		   ipmi_sol_config_t *config,
		   void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    solparm_ref;
    swig_ref    config_ref;

    solparm_ref = swig_make_ref_destruct(solparm, ipmi_solparm_t);
    config_ref = swig_make_ref_destruct(config, ipmi_sol_config_t);
    swig_call_cb(cb, "solparm_got_config_cb", "%p%d%p", &solparm_ref, err,
		 &config_ref);
    /* One-time call, get rid of the CB. */
    deref_swig_cb_val(cb);
    swig_free_ref(solparm_ref);
    swig_free_ref(config_ref);
}

static void
solparm_set_config(ipmi_solparm_t    *solparm,
		   int               err,
		   void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    solparm_ref;

    if (cb) {
	solparm_ref = swig_make_ref_destruct(solparm, ipmi_solparm_t);
	swig_call_cb(cb, "solparm_set_config_cb", "%p%d", &solparm_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(solparm_ref);
    }
}

static void
solparm_clear_lock(ipmi_solparm_t    *solparm,
		   int               err,
		   void              *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    solparm_ref;

    if (cb) {
	solparm_ref = swig_make_ref_destruct(solparm, ipmi_solparm_t);
	swig_call_cb(cb, "solparm_clear_lock_cb", "%p%d", &solparm_ref, err);
	/* One-time call, get rid of the CB. */
	deref_swig_cb_val(cb);
	swig_free_ref(solparm_ref);
    }
}

#if defined(HAVE_GLIB) || defined(HAVE_GLIB12)
#include <OpenIPMI/ipmi_glib.h>
static void
glib_handle_log(const char *domain,
		const char *pfx,
		const char *message)
{
    swig_cb_val *handler = swig_log_handler;

    if (! handler)
	return;

    swig_call_cb(handler, "log", "%s%s", pfx, message);
}

#if defined(HAVE_GLIB) && defined(HAVE_GLIB12)
#include <dlfcn.h>
#endif

/*
 * Initialize the OS handler with the glib version.
 */
os_handler_t *
init_glib_shim(char *ver)
{
    os_handler_t *swig_os_hnd;
#if defined(HAVE_GLIB) && defined(HAVE_GLIB12)
/* Two versions of glib.  Go through special machinations to make this
   work right.  We can't directly link with glib, we have to dlopen it
   to get the right version. */

    static char  *olibst = "libOpenIPMIglib%s.so";
    char         dummy[1];
    char         *name;
    void         *hndl;
    os_handler_t *(*get)(int);
    void         (*setlog)(void (*hndlr)(const char *domain,
					 const char *pfx,
					 const char *msg));
    int          len;

    len = snprintf(dummy, 1, olibst, ver);
    name = malloc(len+1);
    if (!name) {
	fprintf(stderr, "Unable to allocation memory for glib\n");
	abort();
    }
    snprintf(name, len+1, olibst, ver);
    hndl = dlopen(name, RTLD_LAZY | RTLD_GLOBAL);
    if (!hndl) {
	fprintf(stderr, "Unable to open the glib library: %s: %s\n",
		name, dlerror());
	free(name);
	abort();
    }
    free(name);
    get = dlsym(hndl, "ipmi_glib_get_os_handler");
    if (!get) {
	fprintf(stderr,
		"Could not find glib function: ipmi_glib_get_os_handler: %s\n",
		dlerror());
	abort();
    }
    setlog = dlsym(hndl, "ipmi_glib_set_log_handler");
    if (!setlog) {
	fprintf(stderr,
		"Could not find glib function: ipmi_glib_set_log_handler: %s\n",
		dlerror());
	abort();
    }

    swig_os_hnd = get(0);
    swig_os_hnd->set_log_handler(swig_os_hnd, openipmi_swig_vlog);
    ipmi_init(swig_os_hnd);
    ipmi_cmdlang_init(swig_os_hnd);
    setlog(glib_handle_log);
#else
    swig_os_hnd = ipmi_glib_get_os_handler(0);
    swig_os_hnd->set_log_handler(swig_os_hnd, openipmi_swig_vlog);
    ipmi_init(swig_os_hnd);
    ipmi_cmdlang_init(swig_os_hnd);
    ipmi_glib_set_log_handler(glib_handle_log);
#endif
    return swig_os_hnd;
}
#endif

%}

typedef struct {
} ipmi_domain_t;

typedef struct {
} ipmi_domain_id_t;

typedef struct {
} ipmi_args_t;

typedef struct {
} ipmi_entity_t;

typedef struct {
} ipmi_entity_id_t;

typedef struct {
} ipmi_fru_t;

typedef struct {
} ipmi_fru_node_t;

typedef struct {
} ipmi_mc_t;

typedef struct {
} ipmi_mcid_t;

typedef struct {
} ipmi_event_t;

typedef struct {
} ipmi_sensor_t;

typedef struct {
} ipmi_sensor_id_t;

typedef struct {
} ipmi_control_t;

typedef struct {
} ipmi_control_id_t;

typedef struct {
} ipmi_channel_info_t;

typedef struct {
} ipmi_channel_access_t;

typedef struct {
} ipmi_user_t;

typedef struct {
} ipmi_lanparm_t;

typedef struct {
} ipmi_lan_config_t;

typedef struct {
} ipmi_pef_t;

typedef struct {
} ipmi_pef_config_t;

typedef struct {
} ipmi_pet_t;

typedef struct {
} ipmi_cmdlang_t;

typedef struct {
} ipmi_cmdlang_event_t;

typedef struct {
} ipmi_sol_conn_t;

typedef struct {
} ipmi_sol_config_t;

typedef struct {
} ipmi_solparm_t;

%inline %{
void enable_debug_malloc()
{
    if (!swig_os_hnd) {
	DEBUG_MALLOC_ENABLE();
    }
}

void enable_debug_msg()
{
    DEBUG_MSG_ENABLE();
}

void disable_debug_msg()
{
    DEBUG_MSG_DISABLE();
}

void enable_debug_rawmsg()
{
    DEBUG_RAWMSG_ENABLE();
}

void disable_debug_rawmsg()
{
    DEBUG_RAWMSG_DISABLE();
}

int
init_glib(void)
{
#ifdef HAVE_GLIB
    if (swig_os_hnd)
	return 0;
#ifdef OpenIPMI_HAVE_INIT_LANG
    init_lang();
#endif
    swig_os_hnd = init_glib_shim("");
    return 0;
#else
    return ENOSYS;
#endif
}

int
init_glib12(void)
{
#ifdef HAVE_GLIB12
    if (swig_os_hnd)
	return 0;
#ifdef OpenIPMI_HAVE_INIT_LANG
    init_lang();
#endif
    swig_os_hnd = init_glib_shim("12");
    return 0;
#else
    return ENOSYS;
#endif
}

#if defined(HAVE_TCL)
#include <OpenIPMI/ipmi_tcl.h>
#endif

int
init_tcl(void)
{
#ifdef HAVE_TCL
    if (swig_os_hnd)
	return 0;
#ifdef OpenIPMI_HAVE_INIT_LANG
    init_lang();
#endif
    swig_os_hnd = ipmi_tcl_get_os_handler(0);
    swig_os_hnd->set_log_handler(swig_os_hnd, openipmi_swig_vlog);
    ipmi_init(swig_os_hnd);
    ipmi_cmdlang_init(swig_os_hnd);
    return 0;
#else
    return ENOSYS;
#endif
}

/*
 * Initialize the OS handler and use the POSIX version.
 */
int
init_posix(void)
{
    if (swig_os_hnd)
	return 0;
#ifdef OpenIPMI_HAVE_INIT_LANG
    init_lang();
#endif
#ifdef USE_POSIX_THREADS
    swig_os_hnd = ipmi_posix_thread_setup_os_handler(SIGUSR1);
#else
    swig_os_hnd = ipmi_posix_setup_os_handler();
#endif
    swig_os_hnd->set_log_handler(swig_os_hnd, openipmi_swig_vlog);
    ipmi_init(swig_os_hnd);
    ipmi_cmdlang_init(swig_os_hnd);
    return 0;
}

/*
 * Initialize the OS handler with the default version.  This is glib
 * if it is present, POSIX if it is not.
 */
int
init(void)
{
    int rv;

    if (rv = init_glib())
        rv = init_posix();
    return rv;
}

/*
 * Free up all the memory used by OpenIPMI.
 */
void
shutdown_everything()
{
    IPMI_SWIG_C_CB_ENTRY
    ipmi_cmdlang_cleanup();
    ipmi_shutdown();
    swig_os_hnd->free_os_handler(swig_os_hnd);
    swig_os_hnd = NULL;
#ifdef OpenIPMI_HAVE_CLEANUP_LANG
    void cleanup_lang();
#endif
    IPMI_SWIG_C_CB_EXIT
}

/*
 * Perform one operation.  The first parameter is a timeout in
 * milliseconds.
 */
void
wait_io(int timeout)
{
    struct timeval tv = { (timeout / 1000), ((timeout + 999) % 1000) };
    IPMI_SWIG_C_BLOCK_ENTRY
    swig_os_hnd->perform_one_op(swig_os_hnd, &tv);
    IPMI_SWIG_C_BLOCK_EXIT
}

%}

/*
 * Error return constants returned by OpenIPMI.
 */
%constant int ebadf = EBADF;
%constant int einval = EINVAL;
%constant int e2big = E2BIG;
%constant int enomem = ENOMEM;
%constant int enoent = ENOENT;
%constant int ecanceled = ECANCELED;
%constant int enosys = ENOSYS;
%constant int eexist = EEXIST;
%constant int eagain = EAGAIN;
%constant int eperm = EPERM;

/*
 * Return values for event handlers
 */
%constant int EVENT_NOT_HANDLED = IPMI_EVENT_NOT_HANDLED;
%constant int EVENT_HANDLED = IPMI_EVENT_HANDLED;
%constant int EVENT_HANDLED_PASS = IPMI_EVENT_HANDLED_PASS;

/* These two defines simplify the functions that do addition/removal
   of callbacks.  The type is the object type (domain, entity, etc)
   and the name is the stuff in the middle of the name, ie
   (ipmi_<type>_add_<name>_handler.  The function that will be called
   with the info is <type>_<name>_handler. */
#define cb_add(type, name, func) \
	int         rv;							\
	swig_cb_val *handler_val;					\
	IPMI_SWIG_C_CB_ENTRY						\
	if (! valid_swig_cb(handler, func))				\
	    rv = EINVAL;						\
	else {								\
	    handler_val = ref_swig_cb(handler, func);			\
	    rv = ipmi_ ## type ## _add_ ## name ## _handler		\
		 (self, type ## _ ## name ## _handler, handler_val);	\
	    if (rv)							\
		deref_swig_cb_val(handler_val);				\
	}								\
	IPMI_SWIG_C_CB_EXIT						\
	return rv;
#define cb_rm(type, name, func) \
	int         rv;							\
	swig_cb_val *handler_val;					\
	IPMI_SWIG_C_CB_ENTRY						\
	if (! valid_swig_cb(handler, func))				\
	    rv = EINVAL;						\
	else {								\
	    handler_val = get_swig_cb(handler, func);			\
	    rv = ipmi_ ## type ## _remove_ ## name ##_handler		\
		 (self, type ## _ ## name ## _handler, handler_val);	\
	    if (!rv)							\
		deref_swig_cb_val(handler_val);				\
	}								\
	IPMI_SWIG_C_CB_EXIT						\
	return rv;
    

/*
 * A bug in swig (default parameters not used in inline) causes this
 * to have to not be in an inline and done the hard way.
 */
%{
static void
domain_cleanup_add(ipmi_domain_t *domain, void *cb_data)
{
    ipmi_domain_add_connect_change_handler_cl
	(domain, domain_connect_change_handler_cl, NULL);
}

static ipmi_domain_id_t *
open_domain(char *name, argarray *args, swig_cb *done, swig_cb *up)
{
    int                i, j;
    int                num_options = 0;
    ipmi_open_option_t options[10];
    int                set = 0;
    ipmi_args_t        *con_parms[2];
    ipmi_con_t         *con[2];
    ipmi_domain_id_t   *nd;
    int                rv;
    swig_cb_val        *done_val = NULL;
    swig_cb_val        *up_val = NULL;
    ipmi_domain_con_cb con_change = NULL;
    ipmi_domain_ptr_cb domain_up = NULL;

    IPMI_SWIG_C_CB_ENTRY
    nd = malloc(sizeof(*nd));

    for (i=0; i<args->len; i++) {
	if (num_options >= 10) {
	    free(nd);
	    nd = NULL;
	    goto out_err;
	}

	if (! ipmi_parse_options(options+num_options, args->val[i]))
	    num_options++;
	else
	    break;
    }

    rv = ipmi_parse_args(&i, args->len, args->val, &con_parms[set]);
    if (rv) {
	free(nd);
	nd = NULL;
	goto out_err;
    }
    set++;

    if (i < args->len) {
	rv = ipmi_parse_args(&i, args->len, args->val, &con_parms[set]);
	if (rv) {
	    ipmi_free_args(con_parms[0]);
	    free(nd);
	    nd = NULL;
	    goto out_err;
	}
	set++;
    }
    
    for (i=0; i<set; i++) {
	rv = ipmi_args_setup_con(con_parms[i],
				 swig_os_hnd,
				 NULL,
				 &con[i]);
	if (rv) {
	    for (j=0; j<i; j++)
		con[j]->close_connection(con[j]);
            free(nd);
	    nd = NULL;
	    goto out;
	}
    }

    if (!nil_swig_cb(up)) {
	if (valid_swig_cb(up, domain_up_cb)) {
	    up_val = ref_swig_cb(up, domain_up_cb);
	    domain_up = domain_fully_up;
	} else {
	    free(nd);
	    nd = NULL;
	    goto out;
	}
    }
    if (!nil_swig_cb(done)){
	if (valid_swig_cb(done, conn_change_cb)) {
	    done_val = ref_swig_cb(done, conn_change_cb);
	    con_change = domain_connect_change_handler;
	} else {
	    if (domain_up)
		deref_swig_cb(up);
	    free(nd);
	    nd = NULL;
	    goto out;
	}
    }
    rv = ipmi_open_domain(name, con, set, con_change, done_val,
			  domain_up, up_val,
			  options, num_options, nd);
    if (rv) {
	if (domain_up)
	    deref_swig_cb(up);
	if (con_change)
	    deref_swig_cb(done);
	for (i=0; i<set; i++)
	    con[i]->close_connection(con[i]);
	free(nd);
	nd = NULL;
	goto out;
    }

    ipmi_domain_pointer_cb(*nd, domain_cleanup_add, NULL);

 out:
    for (i=0; i<set; i++)
	ipmi_free_args(con_parms[i]);

 out_err:
    IPMI_SWIG_C_CB_EXIT
    return nd;
}

static ipmi_domain_id_t *
open_domain2(char *name, argarray *args, swig_cb *done, swig_cb *up)
{
    int                i, j;
    int                num_options = 0;
    ipmi_open_option_t options[10];
    int                set = 0;
    ipmi_args_t        *con_parms[2];
    ipmi_con_t         *con[2];
    ipmi_domain_id_t   *nd;
    int                rv;
    swig_cb_val        *done_val = NULL;
    swig_cb_val        *up_val = NULL;
    ipmi_domain_con_cb con_change = NULL;
    ipmi_domain_ptr_cb domain_up = NULL;

    IPMI_SWIG_C_CB_ENTRY
    nd = malloc(sizeof(*nd));

    for (i=0; i<args->len; i++) {
	if (num_options >= 10) {
	    free(nd);
	    nd = NULL;
	    goto out_err;
	}

	if (! ipmi_parse_options(options+num_options, args->val[i]))
	    num_options++;
	else
	    break;
    }

    rv = ipmi_parse_args2(&i, args->len, args->val, &con_parms[set]);
    if (rv) {
	free(nd);
	nd = NULL;
	goto out_err;
    }
    set++;

    if (i < args->len) {
	rv = ipmi_parse_args2(&i, args->len, args->val, &con_parms[set]);
	if (rv) {
	    ipmi_free_args(con_parms[0]);
	    free(nd);
	    nd = NULL;
	    goto out_err;
	}
	set++;
    }

    for (i=0; i<set; i++) {
	rv = ipmi_args_setup_con(con_parms[i],
				 swig_os_hnd,
				 NULL,
				 &con[i]);
	if (rv) {
	    for (j=0; j<i; j++)
		con[j]->close_connection(con[j]);
            free(nd);
	    nd = NULL;
	    goto out;
	}
    }

    if (!nil_swig_cb(up)) {
	if (valid_swig_cb(up, domain_up_cb)) {
	    up_val = ref_swig_cb(up, domain_up_cb);
	    domain_up = domain_fully_up;
	} else {
	    free(nd);
	    nd = NULL;
	    goto out;
	}
    }
    if (!nil_swig_cb(done)){
	if (valid_swig_cb(done, conn_change_cb)) {
	    done_val = ref_swig_cb(done, conn_change_cb);
	    con_change = domain_connect_change_handler;
	} else {
	    if (domain_up)
		deref_swig_cb(up);
	    free(nd);
	    nd = NULL;
	    goto out;
	}
    }
    rv = ipmi_open_domain(name, con, set, con_change, done_val,
			  domain_up, up_val,
			  options, num_options, nd);
    if (rv) {
	if (domain_up)
	    deref_swig_cb(up);
	if (con_change)
	    deref_swig_cb(done);
	for (i=0; i<set; i++)
	    con[i]->close_connection(con[i]);
	free(nd);
	nd = NULL;
	goto out;
    }

    ipmi_domain_pointer_cb(*nd, domain_cleanup_add, NULL);

 out:
    for (i=0; i<set; i++)
	ipmi_free_args(con_parms[i]);

 out_err:
    IPMI_SWIG_C_CB_EXIT
    return nd;
}

static ipmi_domain_id_t *
open_domain3(char *name, argarray *ioptions, iargarray *args,
	     swig_cb *done, swig_cb *up)
{
    int                i, j;
    int                num_options = 0;
    ipmi_open_option_t options[10];
    int                set = 0;
    ipmi_con_t         *con[2];
    ipmi_domain_id_t   *nd;
    int                rv;
    swig_cb_val        *done_val = NULL;
    swig_cb_val        *up_val = NULL;
    ipmi_domain_con_cb con_change = NULL;
    ipmi_domain_ptr_cb domain_up = NULL;

    IPMI_SWIG_C_CB_ENTRY
    nd = malloc(sizeof(*nd));

    for (i=0; i<ioptions->len; i++) {
	if (num_options >= 10) {
	    free(nd);
	    nd = NULL;
	    goto out_err;
	}
	
	if (! ipmi_parse_options(options+num_options, ioptions->val[i]))
	    num_options++;
	else
	    break;
    }

    for (i=0; i<args->len; i++) {
	rv = ipmi_args_setup_con(args->val[i],
				 swig_os_hnd,
				 NULL,
				 &con[i]);
	if (rv) {
	    for (j=0; j<i; j++)
		con[j]->close_connection(con[j]);
            free(nd);
	    nd = NULL;
	    goto out;
	}
	set++;
    }

    if (!nil_swig_cb(up)) {
	if (valid_swig_cb(up, domain_up_cb)) {
	    up_val = ref_swig_cb(up, domain_up_cb);
	    domain_up = domain_fully_up;
	} else {
	    free(nd);
	    nd = NULL;
	    goto out;
	}
    }
    if (!nil_swig_cb(done)){
	if (valid_swig_cb(done, conn_change_cb)) {
	    done_val = ref_swig_cb(done, conn_change_cb);
	    con_change = domain_connect_change_handler;
	} else {
	    if (domain_up)
		deref_swig_cb(up);
	    free(nd);
	    nd = NULL;
	    goto out;
	}
    }
    rv = ipmi_open_domain(name, con, set, con_change, done_val,
			  domain_up, up_val,
			  options, num_options, nd);
    if (rv) {
	if (domain_up)
	    deref_swig_cb(up);
	if (con_change)
	    deref_swig_cb(done);
	for (i=0; i<set; i++)
	    con[i]->close_connection(con[i]);
	free(nd);
	nd = NULL;
	goto out;
    }

    ipmi_domain_pointer_cb(*nd, domain_cleanup_add, NULL);

 out:

 out_err:
    IPMI_SWIG_C_CB_EXIT
    return nd;
}

static void
set_log_handler(swig_cb *handler)
{
    swig_cb_val *old_handler = swig_log_handler;
    IPMI_SWIG_C_CB_ENTRY
    if (valid_swig_cb(handler, log))
	swig_log_handler = ref_swig_cb(handler, log);
    else
	swig_log_handler = NULL;
    if (old_handler)
	deref_swig_cb_val(old_handler);
    IPMI_SWIG_C_CB_EXIT
}

static const char *
color_string(int color)
{
    return ipmi_get_color_string(color);
}

static const char *
lanparm_parm_to_str(int parm)
{
    return ipmi_lanconfig_parm_to_str(parm);
}

static int
lanconfig_enum_val(int parm, int val, int *nval, const char **sval)
{
    return ipmi_lanconfig_enum_val(parm, val, nval, sval);
}

static int
lanconfig_enum_idx(int parm, int idx, const char **sval)
{
    return ipmi_lanconfig_enum_idx(parm, idx, sval);
}


static int
lanparm_str_to_parm(char *str)
{
    return ipmi_lanconfig_str_to_parm(str);
}

static const char *
pef_parm_to_str(int parm)
{
    return ipmi_pefconfig_parm_to_str(parm);
}

static int
pef_str_to_parm(char *str)
{
    return ipmi_pefconfig_str_to_parm(str);
}

static int
pefconfig_enum_val(int parm, int val, int *nval, const char **sval)
{
    return ipmi_lanconfig_enum_val(parm, val, nval, sval);
}

static int
pefconfig_enum_idx(int parm, int idx, const char **sval)
{
    return ipmi_pefconfig_enum_idx(parm, idx, sval);
}

static const char *
get_threshold_access_support_string(int val)
{
    return ipmi_get_threshold_access_support_string(val);
}

static const char *
get_hysteresis_support_string(int val)
{
    return ipmi_get_hysteresis_support_string(val);
}

static const char *
get_event_support_string(int val)
{
    return ipmi_get_event_support_string(val);
}

static const char *
channel_medium_string(int val)
{
    return ipmi_channel_medium_string(val);
}

static const char *
channel_protocol_string(int val)
{
    return ipmi_channel_protocol_string(val);
}

static const char *
channel_session_support_string(int val)
{
    return ipmi_channel_session_support_string(val);
}

static const char *
channel_access_mode_string(int val)
{
    return ipmi_channel_access_mode_string(val);
}

static const char *
privilege_string(int val)
{
    return ipmi_privilege_string(val);
}

static const char *
authtype_string(int val)
{
    return ipmi_authtype_string(val);
}

static const char *
solparm_parm_to_str(int parm)
{
    return ipmi_solconfig_parm_to_str(parm);
}

static int
solparm_str_to_parm(char *str)
{
    return ipmi_solconfig_str_to_parm(str);
}

static int
solconfig_enum_val(int parm, int val, int *nval, const char **sval)
{
    return ipmi_solconfig_enum_val(parm, val, nval, sval);
}

static int
solconfig_enum_idx(int parm, int idx, const char **sval)
{
    return ipmi_solconfig_enum_idx(parm, idx, sval);
}

static char *
get_error_string(unsigned int err)
{
    int  len;
    char *buf;

    len = ipmi_get_error_string_len(err);
    buf = malloc(len);
    if (!buf)
	return NULL;
    ipmi_get_error_string(err, buf, len);
    return buf;
}

static void
domain_change_handler(ipmi_domain_t      *domain,
		      enum ipmi_update_e op,
		      void               *cb_data)
{
    swig_cb_val *cb = cb_data;
    swig_ref    domain_ref;
    domain_ref = swig_make_ref(domain, ipmi_domain_t);
    swig_call_cb(cb, "domain_change_cb", "%s%p",
		 ipmi_update_e_string(op), &domain_ref);
    swig_free_ref_check(domain_ref, ipmi_domain_t);
}

int
add_domain_change_handler(swig_cb *handler)
{
    int rv;
    swig_cb_val *handler_val;
    IPMI_SWIG_C_CB_ENTRY
    if (! valid_swig_cb(handler, domain_change_cb)) {
	rv = EINVAL;
	goto out_err;
    }
    handler_val = ref_swig_cb(handler, domain_change_cb);
    rv = ipmi_domain_add_domain_change_handler(domain_change_handler,
					       handler_val);
    if (rv)
	deref_swig_cb_val(handler_val);
out_err:
    IPMI_SWIG_C_CB_EXIT
    return rv;
}

int
remove_domain_change_handler(swig_cb *handler)
{
    int rv;
    swig_cb_val *handler_val;
    IPMI_SWIG_C_CB_ENTRY
    if (! valid_swig_cb(handler, domain_change_cb)) {
	rv = EINVAL;
	goto out_err;
    }
    handler_val = get_swig_cb(handler, domain_change_cb);
    rv = ipmi_domain_remove_domain_change_handler(domain_change_handler,
						  handler_val);
    if (!rv)
	deref_swig_cb_val(handler_val);
out_err:
    IPMI_SWIG_C_CB_EXIT
    return rv;
}

%}

%newobject open_domain;
%newobject open_domain2;
%newobject open_domain3;
/*
 * Create a new domain.  The domain will be named with the first parm,
 * the startup arguments are in a reference to a list in the second
 * parm (\@args), the third parm is a callback object whose
 * conn_change_cb method will be called when the domain has connected
 * (but it may not be fully up yet).  The fourth parameter's
 * domain_up_cb method will be called when the domain is completely up
 * Note that the done method will be kept around and will continue to
 * be called on connection changes.  If you don't want it any more,
 * it must be deregistered with remove_connect_change_handler.
 * Passing in a reference to an undefined value will cause the handlers
 * to not be called.
 * The domain_up_cb methods is called with the following parmeters:
 * <self> <domain>
 * The parameters of the connection change handler are defined in
 * the domain->add_connect_change_handler method.
 * The third and fourth parameters are optional, if not provided
 * or undefined the handler will be ignored.
 *
 * The format of the arguments is the same as described in the
 * ipmi_cmdlang.7 man page for domain open, except the -wait_til_up
 * option is not supported.  See that for more details.  These options
 * allow you to turn on and off various automatic operations that
 * OpenIPMI does, such as scanning SDRs, fetching the SEL, etc.
 */
ipmi_domain_id_t *open_domain(char *name, argarray *args,
			      swig_cb *done = NULL, swig_cb *up = NULL);

/*
 * Like open_domain, but takes the new parameter types and is more
 * flexible.  This is required for RMCP+.
 */
ipmi_domain_id_t *open_domain2(char *name, argarray *args,
			       swig_cb *done = NULL, swig_cb *up = NULL);

/*
 * Like open_domain2, but takes ipmi_args_t.  Works with RMCP+.
 */
ipmi_domain_id_t *open_domain3(char *name, argarray *options,
			       iargarray *args,
			       swig_cb *done = NULL, swig_cb *up = NULL);

/*
 * Iterate through the help for the various connection types used with
 * open_domain2() and open_domain3() and argument parsing and
 * allocating.  This will call the parse_args_iter_help_cb method on
 * the supplied object for each registered connection type.  The
 * parameters are <self> <name> <help>.  This can also be used to find
 * the names of all registered connections.
 */
void parse_args_iter_help(swig_cb *help_cb);
%{
    static void parse_args_iter_help(swig_cb *help_cb)
    {
	int         rv;
	swig_cb_val *handler_val;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(help_cb, parse_args_iter_help_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(help_cb, parse_args_iter_help_cb);
	    ipmi_parse_args_iter_help(parse_args_iter_help_hnd, handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
    }
%}

const char *parse_option_help();
%{
    static const char *parse_option_help(void)
    {
	return ipmi_parse_options_help();
    }
%}

/*
 * Add a handler whose domain_change_cb method will be called whenever
 * a domain is added or removed.  The handler will be called with the
 * following parameters: <self> added|deleted|changed <domain>
 */
int add_domain_change_handler(swig_cb *handler);

/*
 * Remove a previously registered domain handler.
 */
int
remove_domain_change_handler(swig_cb *handler);

/*
 * Set the handler for OpenIPMI logs.  This is a global value and
 * there is only one, setting it replaces the old one.  The logs will
 * be sent to the "log" method of the first parameter.  The log method
 * will receive the following parameters: <self>, <log_level (a
 * string)>, and <log (a string)>.  If the log method is undefined or
 * not provided, the current log handler will be removed.
 */
void set_log_handler(swig_cb *handler = NULL);


/*
 * Convert the given color to a string.
 */
char *color_string(int color);

/* Convert between lanparm string names and parm numbers. */
char *lanparm_parm_to_str(int parm);
int lanparm_str_to_parm(char *str);

/* Used to discover enum values for lanparms. */
int lanconfig_enum_val(int parm, int val, int *nval, const char **sval);
int lanconfig_enum_idx(int parm, int idx, const char **sval);

/* Convert between pef string names and parm numbers. */
char *pef_parm_to_str(int parm);
int pef_str_to_parm(char *str);

/* Used to discover enum values for lanparms. */
int pefconfig_enum_val(int parm, int val, int *nval, const char **sval);
int pefconfig_enum_idx(int parm, int idx, const char **sval);

/* Convert between SoL string names and parm numbers. */
char *solparm_parm_to_str(int parm);
int solparm_str_to_parm(char *str);

/* Used to discover enum values for solparms. */
int solconfig_enum_val(int parm, int val, int *nval, const char **sval);
int solconfig_enum_idx(int parm, int idx, const char **sval);

/* Convert various sensor values to strings. */
char *get_threshold_access_support_string(int val);
char *get_hysteresis_support_string(int val);
char *get_event_support_string(int val);

/* Convert various channel/mc values to strings. */
char *channel_medium_string(int val);
char *channel_protocol_string(int val);
char *channel_session_support_string(int val);
char *channel_access_mode_string(int val);
char *privilege_string(int val);
char *authtype_string(int val);

%newobject get_error_string;
char *get_error_string(unsigned int val);

%constant long long TIMEOUT_FOREVER = IPMI_TIMEOUT_FOREVER;

/*
 * A domain id object.  This object is guaranteed to be valid and
 * can be converted into a domain pointer later.
 */
%extend ipmi_domain_id_t {
    ~ipmi_domain_id_t()
    {
	free(self);
    }

    /* Compare self with other, return -1 if self<other, 0 if
       self==other, or 1 if self>other.  */
    int cmp(ipmi_domain_id_t *other)
    {
	return ipmi_cmp_domain_id(*self, *other);
    }

    /*
     * Convert a domain id to a domain pointer.  The "domain_cb" method
     * will be called on the first parameter with the following parameters:
     * <self> <domain>
     */
    int to_domain(swig_cb *handler)
    {
	int rv;
	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, domain_cb))
	    rv = EINVAL;
	else
	    rv = ipmi_domain_pointer_cb(*self, handle_domain_cb,
					get_swig_cb(handler, domain_cb));
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

/*
 * A domain object.
 */
%extend ipmi_domain_t {
    %newobject get_name;
    /*
     * Get the name of the domain.
     */
    char *get_name()
    {
	char name[IPMI_DOMAIN_NAME_LEN];

	ipmi_domain_get_name(self, name, sizeof(name));
	return strdup(name);
    }

    %newobject get_id;
    /*
     * Get the ID of the domain so you can hold on to the reference.
     */
    ipmi_domain_id_t *get_id()
    {
	ipmi_domain_id_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_domain_convert_to_id(self);
	return rv;
    }

    %newobject get_guid;
    /*
     * Get the system GUID for the domain.  Returns NULL if it is not
     * supported.
     */
    char *get_guid()
    {
	char          *str = NULL;
	unsigned char guid[16];

	if (ipmi_domain_get_guid(self, guid) == 0) {
	    str = malloc(16 * 3);
	    if (str) {
		char *s = str;
		int  i;
		s += sprintf(s, "%2.2x", guid[0]);
		for (i=1; i<16; i++)
		    s += sprintf(s, " %2.2x", guid[i]);
	    }
	}
	return str;
    }

    /*
     * Shut down the connections to the domain and free it up.  The
     * domain_close_done_cb method for the handler object will be
     * called with the following parameters: <self>
     */
    int close(swig_cb *handler)
    {
	int         rv;
	swig_cb_val *handler_val;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, domain_close_done_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, domain_close_done_cb);
	    rv = ipmi_domain_close(self, domain_close_done, handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Add a handler to be called when the connection changes status.
     * The conn_change_cb method on the first parameter will be
     * called when the connection changes status with the following
     * parameters: <self>, <domain>, <errorval>, <connection_number>,
     * <port_number>, <anything_still_connected>.
     */
    int add_connect_change_handler(swig_cb *handler)
    {
	/* cleanup handler is added when the domain is added. */
	cb_add(domain, connect_change, conn_change_cb);
    }

    /*
     * Remove the connection change handler.
     */
    int remove_connect_change_handler(swig_cb *handler)
    {
	cb_rm(domain, connect_change, conn_change_cb);
    }

    /*
     * Iterate through all the connections in the object.  The
     * domain_iter_connection_cb method will be called on the first
     * parameter for each connection in the domain.  The parameters it
     * receives will be: <self>, <domain>, <connection (integer)>.
     */
    int iterate_connections(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv = 0;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, domain_iter_connection_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(handler, domain_iter_connection_cb);
	    ipmi_domain_iterate_connections(self,
					    domain_iterate_connections_handler,
					    handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Attempt to activate the given connection.
     */
    int activate_connection(int connection)
    {
	int rv;
	IPMI_SWIG_C_CB_ENTRY
	rv = ipmi_domain_activate_connection(self, connection);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Parm 1 is a connection number.  Sets the second parameter to
     * true if the connection is active, false if not.  Returns an
     * error value.
     */
    int is_connection_active(int connection, unsigned int *active)
    {
	return ipmi_domain_is_connection_active(self, connection, active);
    }

    /*
     * Parm 1 is a connection number.  Sets the second parameter to true
     * if the connection is up, false if not.  Returns an error value.
     */
    int is_connection_up(int connection, unsigned int *up)
    {
	return ipmi_domain_is_connection_up(self, connection, up);
    }

    /*
     * Parm 1 is a connection number.  Sets the second parameter to
     * the number of ports in the connection.  A connection may have
     * multiple ports (ie, multiple IP addresses to the same BMC,
     * whereas a separate connection is a connection to a different
     * BMC); these functions let you check their status.  Returns an
     * error value.
     */
    int num_connection_ports(int connection, unsigned int *ports)
    {
	return ipmi_domain_num_connection_ports(self, connection, ports);
    }

    /*
     * Parm 1 is a connection number, parm 2 is a port number.  Sets
     * parm 3 to true if the given port is up, false if not.  Returns
     * an error value.
     */
    int is_connection_port_up(int          connection,
			      int          port,
			      unsigned int *up)
    {
	return ipmi_domain_is_connection_port_up(self, connection, port, up);
    }

    %newobject get_port_info;
    char *get_port_info(int connection, int port)
    {
	int rv;
	char buf[256];
	int  len = sizeof(buf);
	rv = ipmi_domain_get_port_info(self, connection, port, buf, &len);
	if (rv)
	    return NULL;
	return strdup(buf);
    }
			
    %newobject get_connection_args;
    ipmi_args_t *get_connection_args(int connection)
    {
	return ipmi_domain_get_connection_args(self, connection);
    }

    char *get_connection_type(int connection)
    {
	return ipmi_domain_get_connection_type(self, connection);
    }

    /*
     * Add a handler to be called when an entity is added, updated, or
     * removed. When the entity is updated the entity_update_cb
     * method on the first parameter will be called with the following
     * parameters: <self>, added|deleted|changed <domain>, <entity>.
     */
    int add_entity_update_handler(swig_cb *handler)
    {
	ipmi_domain_add_entity_update_handler_cl
	    (self, domain_entity_update_handler_cl, NULL);
	cb_add(domain, entity_update, entity_update_cb);
    }

    /*
     * Remove the entity change handler.
     */
    int remove_entity_update_handler(swig_cb *handler)
    {
	cb_rm(domain, entity_update, entity_update_cb);
    }

    /*
     * Iterate through all the entities in the object.  The
     * domain_iter_entities_cb method will be called on the first
     * parameter for each entity in the domain.  The parameters it
     * receives will be: <self> <domain> <entity>.
     */
    int iterate_entities(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv = 0;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, domain_iter_entities_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(handler, domain_iter_entities_cb);
	    ipmi_domain_iterate_entities(self, domain_iterate_entities_handler,
					 handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Add a handler to be called when an MC is added, updated, or
     * removed. When the mc is updated the mc_update_cb method on the
     * first parameter will be called with the following parameters:
     * <self>, added|deleted|changed <domain>, <mc>.
     */
    int add_mc_update_handler(swig_cb *handler)
    {
	ipmi_domain_add_mc_updated_handler_cl
	    (self, domain_mc_updated_handler_cl, NULL);
	cb_add(domain, mc_updated, mc_update_cb);
    }

    /*
     * Remove the mc change handler.
     */
    int remove_mc_update_handler(swig_cb *handler)
    {
	cb_rm(domain, mc_updated, mc_update_cb);
    }

    /*
     * Iterate through all the MCs in the object.  The
     * domain_iter_mc_cb method will be called on the first parameter for
     * each mc in the domain.  The parameters it receives will be:
     * <self> <domain> <mc>.
     */
    int iterate_mcs(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv = 0;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, domain_iter_mc_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(handler, domain_iter_mc_cb);
	    ipmi_domain_iterate_mcs(self, domain_iterate_mcs_handler,
				    handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Return the type of the domain, either unknown, mxp, or atca.
     * Others may be added later.
     */
    const char *get_type()
    {
	return ipmi_domain_get_type_string(ipmi_domain_get_type(self));
    }

    /*
     * Scan all the addresses on the given channel (parm 1) between
     * (and including) start_addr (parm 2) and end_addr (parm 3) and
     * call the "domain_ipmb_mc_scan_cb" method on the handler (parm4)
     * with the following parms (if the parm is provided and defined):
     * <self>, <domain>, <error val>
     */
    int start_ipmb_mc_scan(int channel, int start_addr, int end_addr,
			   swig_cb *handler = NULL)
    {
	int            rv;
	swig_cb_val    *handler_val = NULL;
	ipmi_domain_cb domain_cb = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, domain_ipmb_mc_scan_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    domain_cb = ipmb_mc_scan_handler;
	    handler_val = ref_swig_cb(handler, domain_ipmb_mc_scan_cb);
	}
	rv = ipmi_start_ipmb_mc_scan(self, channel, start_addr, end_addr,
				     domain_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /* Scan all IPMB busses for new/lost MCs. */
    void start_full_ipmb_scan()
    {
	ipmi_domain_start_full_ipmb_scan(self);
    }

    /*
     * Send a command to a given address (parm 1) with the given lun
     * (parm 2), netfn (parm 3), command (parm 4).  Parm 5 is the
     * message data in an array reference.  Parm 6 is the handler, it
     * will be called with the response.  The addr_cmd_cb method will
     * be called on the handler handler if it is provided and defined;
     * its parameters are: <domain> <addr> <lun> <netfn> <cmd>
     * <response data>
     */
    int send_command_addr(char *addr, int lun, int netfn, int cmd,
			  intarray msg_data, swig_cb *handler = NULL)
    {
	int                          rv;
	swig_cb_val                  *handler_val = NULL;
	ipmi_addr_response_handler_t msg_cb = NULL;
	ipmi_addr_t                  iaddr;
	unsigned int                 addr_len;
	ipmi_msg_t                   msg;
	unsigned char                data[MAX_IPMI_DATA_SIZE];
	unsigned int                 data_len;

	IPMI_SWIG_C_CB_ENTRY
	rv = parse_ipmi_addr(addr, lun, &iaddr, &addr_len);
	if (rv)
	    goto out_err;

	msg.netfn = netfn;
	msg.cmd = cmd;
	msg.data = data;
	rv = parse_ipmi_data(msg_data, data, sizeof(data), &data_len);
	msg.data_len = data_len;
	if (rv)
	    goto out_err;

	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, addr_cmd_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    msg_cb = domain_msg_cb;
	    handler_val = ref_swig_cb(handler, addr_cmd_cb);
	}
	rv = ipmi_send_command_addr(self, &iaddr, addr_len, &msg,
				    msg_cb, handler_val, NULL);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Cause the domain to start detecting presence changes.  If parm
     * 1 is supplied, it tells whether to force all entities to have
     * their presence checked (if true) or just detect entity presence
     * for ones that might have changed.
     */
    int detect_presence_changes(int force = 0)
    {
	return ipmi_detect_domain_presence_changes(self, force);
    }

    /*
     * Set the time (in seconds) between SEL rescans for all
     * SELs in the domain
     */
    void set_sel_rescan_time(int seconds)
    {
	return ipmi_domain_set_sel_rescan_time(self, seconds);
    }

    /*
     * Get the default SEL rescan time for the domain.
     */
    int get_sel_rescan_time()
    {
	return ipmi_domain_get_sel_rescan_time(self);
    }

    /*
     * Set the time (in seconds) between IPMB bus rescans for the
     * domain.
     */
    void set_ipmb_rescan_time(int seconds)
    {
	return ipmi_domain_set_ipmb_rescan_time(self, seconds);
    }

    /*
     * Get the default IPMB rescan time for the domain.
     */
    int get_ipmb_rescan_time()
    {
	return ipmi_domain_get_ipmb_rescan_time(self);
    }

    /*
     * Add a handler to be called when a new unhandled event comes
     * into the domain.  When the event comes in, the event_cb method
     * on the first parameter will be called with the following
     * parameters: <self>, <domain>, <event>
     */
    int add_event_handler(swig_cb *handler)
    {
	ipmi_domain_add_event_handler_cl
	    (self, domain_event_handler_cl, NULL);
	cb_add(domain, event, event_cb);
    }

    /*
     * Remove the event handler.
     */
    int remove_event_handler(swig_cb *handler)
    {
	cb_rm(domain, event, event_cb);
    }

    %newobject first_event;
    /*
     * Retrieve the first event from the domain.  Return NULL (undef)
     * if the event does not exist.
     */
    ipmi_event_t *first_event()
    {
	return ipmi_domain_first_event(self);
    }

    %newobject last_event;
    /*
     * Retrieve the last event from the domain.
     */
    ipmi_event_t *last_event()
    {
	return ipmi_domain_last_event(self);
    }

    %newobject next_event;
    /*
     * Retrieve the event after the given event from the domain.
     */
    ipmi_event_t *next_event(ipmi_event_t  *event)
    {
	return ipmi_domain_next_event(self, event);
    }

    %newobject prev_event;
    /*
     * Retrieve the event before the given event from the domain.
     */
    ipmi_event_t *prev_event(ipmi_event_t  *event)
    {
	return ipmi_domain_prev_event(self, event);
    }

    /*
     * Number of live entries in the local SEL copy.
     */
    int sel_count()
    {
	int          rv;
	unsigned int count;
	rv = ipmi_domain_sel_count(self, &count);
	if (rv)
	    return 0;
	else
	    return count;
    }

    /*
     * Number of entries in the the remote SEL.  If an entry has been
     * deleted in the local copy of the SEL but has not yet finished
     * being deleted in the remote copy, it will be counted here.
     */
    int sel_entries_used()
    {
	int          rv;
	unsigned int count;
	rv = ipmi_domain_sel_entries_used(self, &count);
	if (rv)
	    return 0;
	else
	    return count;
    }

    /*
     * Reread all SELs in the domain.  The domain_reread_sels_cb
     * method on the first parameter (if supplied) will be called with
     * the following values: <domain> <error value>
     */
    int reread_sels(swig_cb *handler = NULL)
    {
	int            rv;
	swig_cb_val    *handler_val = NULL;
	ipmi_domain_cb domain_cb = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, domain_reread_sels_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    domain_cb = domain_reread_sels_handler;
	    handler_val = ref_swig_cb(handler, domain_reread_sels_cb);
	}
	rv = ipmi_domain_reread_sels(self, domain_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Fetch a FRU with the given parameters.  The first parameter (the object)
     * is the domain, successive parameters are:
     *  is_logical - do a logical or physical FRU fetch.
     *  device_address - The IPMB address of the FRU device.
     *  device_id - The particular FRU device id to fetch.
     *  LUN - The LUN to talk to for the device.
     *  private_bus - for physical FRUs, the bus it is on.
     *  channel - The channel where the device is located.
     * If the handler is supplied, then the fru_fetched method on that
     * will be called upon completion with the handler object as the first
     * parameter, the domain as the second, the FRU as the third, and an
     * error value as the fourth.
     * This returns the FRU, or undefined if a failure occurred.
     */
    %newobject fru_alloc;
    ipmi_fru_t *fru_alloc(int is_logical, int device_address, int device_id,
			  int lun, int private_bus, int channel,
			  swig_cb *handler = NULL)
    {
	ipmi_fru_t *fru = NULL;
	int         rv;
	swig_cb_val *handler_val = NULL;
	ipmi_fru_cb cb_handler = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, fru_fetched))
		goto out_err;
	    cb_handler = fru_fetched;
	    handler_val = ref_swig_cb(handler, fru_fetched);
	}

	rv = ipmi_domain_fru_alloc(self, is_logical, device_address, device_id,
				   lun, private_bus, channel, cb_handler,
				   handler_val, &fru);
	if (rv) {
	    if (handler_val)
		deref_swig_cb_val(handler_val);
	    fru = NULL;
	} else {
	    /* We have one ref for the callback already, add a ref for
	       the returned value. */
	    if (handler_val)
		ipmi_fru_ref(fru);
	}

    out_err:
	IPMI_SWIG_C_CB_EXIT
	return fru;
    }

    /*
     * Allocate a pet object for the domain over the given connection.
     * The pet is returned.  The ninth parameter is an optional
     * callback object, the got_pet_cb method will be called on it
     * when the PET fetch is complete.  It will have the following
     * parameters: <self> <pet> <err>.  The parameters are:
     *   int connection: the connection to the domain to set up the PET for
     *   int channel: the channel number to set the PET for
     *   char ip_addr: the address to send the traps to
     *   char mac_addr: the mac address to send the traps to
     * The rest are the selectors in the various tables, you have to
     * read the spec and know your system to know how to set them.
     *   int eft_sel:
     *   int policy_num:
     *   int apt_sel:
     *   int lan_dest_sel:
     *
     * Note that you must keep a reference to the pet around, or it will
     * be automatically destroyed by the garbage collector.
     */
    %newobject get_pet;
    ipmi_pet_t *get_pet(int     connection,
			int     channel,
			char    *ip_addr,
			char    *mac_addr,
			int     eft_sel,
			int     policy_num,
			int     apt_sel,
			int     lan_dest_sel,
			swig_cb *handler = NULL)
    {
	int              rv;
	ipmi_pet_t       *pet = NULL;
	swig_cb_val      *handler_val = NULL;
	struct in_addr   ip;
	unsigned char    mac[6];
	ipmi_pet_done_cb done = NULL;

	IPMI_SWIG_C_CB_ENTRY
        rv = parse_ip_addr(ip_addr, &ip);
	if (rv)
	    goto out_err;

        rv = parse_mac_addr(mac_addr, mac);
	if (rv)
	    goto out_err;

	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, got_pet_cb))
		goto out_err;
	    handler_val = ref_swig_cb(handler, got_pet_cb);
	    done = get_pet;
	}
	rv = ipmi_pet_create(self, connection, channel, ip, mac, eft_sel,
			     policy_num, apt_sel, lan_dest_sel, get_pet,
			     handler_val, &pet);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return pet;
    }

    /*
     * Allocate a SoL object using the given domain's connection.
     * Note that this does not cause a connection, it just creates an
     * object for doing an SoL connection.
     *
     * The handler val will handle all events from the SOL session.
     * this means it must implement the following callbacks:
     *
     *  sol_connection_state_change <self> <conn> <state> <error>
     *  sol_data_received <self> <conn> <string>
     *  sol_break_detected <self> <conn>
     *  sol_bmc_transmit_overrun <self> <conn>
     */
    %newobject create_sol;
    ipmi_sol_conn_t *create_sol(int connection, swig_cb *handler)
    {
	ipmi_con_t      *con;
	ipmi_sol_conn_t *scon;
	int             rv;
	swig_cb_val     *handler_val;

	if (nil_swig_cb(handler))
	    return NULL;

	if (!valid_swig_cb(handler, sol_connection_state_change))
	    return NULL;
	if (!valid_swig_cb(handler, sol_data_received))
	    return NULL;
	if (!valid_swig_cb(handler, sol_break_detected))
	    return NULL;
	if (!valid_swig_cb(handler, sol_bmc_transmit_overrun))
	    return NULL;

	con = ipmi_domain_get_connection(self, connection);
	if (!con)
	    return NULL;

	rv = ipmi_sol_create(con, &scon);
	if (rv) {
	    con->close_connection(con);
	    return NULL;
	}

	handler_val = ref_swig_gencb(handler);

	rv = ipmi_sol_register_connection_state_callback
	    (scon,
	     sol_connection_state_change_cb,
	     handler_val);
	if (rv)
	    goto out_err;

	rv = ipmi_sol_register_data_received_callback
	    (scon,
	     sol_data_received_cb,
	     handler_val);
	if (rv)
	    goto out_err;

	rv = ipmi_sol_register_break_detected_callback
	    (scon,
	     sol_break_detected_cb,
	     handler_val);
	if (rv)
	    goto out_err;

	rv = ipmi_sol_register_bmc_transmit_overrun_callback
	    (scon,
	     sol_bmc_transmit_overrun_cb,
	     handler_val);
	if (rv)
	    goto out_err;

	return scon;

    out_err:
	deref_swig_cb_val(handler_val);
	ipmi_sol_free(scon);
	return NULL;
    }
}

/*
 * Allocate an args structure of the given connection type, generally
 * "smi" or Lan".
 */
%newobject alloc_empty_args;
ipmi_args_t *alloc_empty_args(char *con_type);
%{
    static ipmi_args_t *
    alloc_empty_args(char *con_type)
    {
	int         rv;
	ipmi_args_t *argv;
	rv = ipmi_args_alloc(con_type, &argv);
	if (rv)
	    return NULL;
	return argv;
    }
%}

/*
 * Parse the array of arguments.  The arguments is a list/array of
 * strings and parsed using the standard algorithms.
 */
%newobject alloc_parse_args;
ipmi_args_t *alloc_parse_args(argarray *args);
%{
    static ipmi_args_t *
    alloc_parse_args(argarray *args)
    {
	int         rv;
	ipmi_args_t *argv;
	int         i = 0;

	rv = ipmi_parse_args(&i, args->len, args->val, &argv);
	if (rv)
	    return NULL;
	return argv;
    }
%}

%extend ipmi_args_t {
    ~ipmi_args_t()
    {
	ipmi_free_args(self);
    }

    /*
     * Return the type of connection, generally "lan" or "smi".
     */
    const char *get_type()
    {
	return ipmi_args_get_type(self);
    }

    /*
     * An args is a set of fields indexed by argnum.  Fetching an
     * argument returns the name, type, help string, and value.  E2BIG
     * is returned if argnum is larger than the number of fields.
     * Type will be either "str" for a string or integer or IP address
     * or other field like that, "bool" for a boolean, and "enum" for
     * an enumeration type.  The "str" type, obviously, may have
     * semantics behind it.  The "bool" value will be either "true" or
     * "false".  For enums, an array of strings is returned as "range"
     * and the value will be one of these strings.
     */
    int get_val(int           argnum,
		const char    **name,
		const char    **type,
		const char    **help,
		char          **value,
		strconstarray *range)
    {
	int        rv;
	const char **irange = NULL;
	char       *ivalue = NULL;

	rv = ipmi_args_get_val(self, argnum, name, type, help,
			       &ivalue, &irange);
	if (rv)
	    return rv;
	if (ivalue) {
	    /* Convert it to a normal malloc() so char ** will work. */
	    char *ivalue2 = strdup(ivalue);
	    ipmi_args_free_str(self, ivalue);
	    ivalue = ivalue2;
	}
	*value = ivalue;
	if (irange) {
	    int len;
	    for (len=0; irange[len]; len++)
		;
	    range->len = len;
	    range->val = irange;
	}
	return 0;
    }

    /*
     * Set the given field.  If name is not NULL, then find the field
     * by name.  If name is NULL, then argnum is used for the field.
     * If the value does not match the semantics of the field, an
     * error is returned.
     */
    int set_val(int argnum, const char *name, const char *value)
    {
	return ipmi_args_set_val(self, argnum, name, value);
    }
}

/*
 * A entity id object.  This object is guaranteed to be valid and
 * can be converted into a entity pointer later.
 */
%extend ipmi_entity_id_t {
    ~ipmi_entity_id_t()
    {
	free(self);
    }

    /* Compare self with other, return -1 if self<other, 0 if
       self==other, or 1 if self>other.  */
    int cmp(ipmi_entity_id_t *other)
    {
	return ipmi_cmp_entity_id(*self, *other);
    }

    /*
     * Convert a entity id to a entity pointer.  The "entity_cb" method
     * will be called on the first parameter with the following parameters:
     * <self> <entity>
     */
    int to_entity(swig_cb *handler)
    {
	int rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_cb))
	    rv = EINVAL;
	else
	    rv = ipmi_entity_pointer_cb(*self, handle_entity_cb,
					get_swig_cb(handler, entity_cb));
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

%constant int ENTITY_ID_UNSPECIFIED = IPMI_ENTITY_ID_UNSPECIFIED;
%constant int ENTITY_ID_OTHER = IPMI_ENTITY_ID_OTHER;
%constant int ENTITY_ID_UNKOWN = IPMI_ENTITY_ID_UNKOWN;
%constant int ENTITY_ID_PROCESSOR = IPMI_ENTITY_ID_PROCESSOR;
%constant int ENTITY_ID_DISK = IPMI_ENTITY_ID_DISK;
%constant int ENTITY_ID_PERIPHERAL = IPMI_ENTITY_ID_PERIPHERAL;
%constant int ENTITY_ID_SYSTEM_MANAGEMENT_MODULE = IPMI_ENTITY_ID_SYSTEM_MANAGEMENT_MODULE;
%constant int ENTITY_ID_SYSTEM_BOARD = IPMI_ENTITY_ID_SYSTEM_BOARD;
%constant int ENTITY_ID_MEMORY_MODULE = IPMI_ENTITY_ID_MEMORY_MODULE;
%constant int ENTITY_ID_PROCESSOR_MODULE = IPMI_ENTITY_ID_PROCESSOR_MODULE;
%constant int ENTITY_ID_POWER_SUPPLY = IPMI_ENTITY_ID_POWER_SUPPLY;
%constant int ENTITY_ID_ADD_IN_CARD = IPMI_ENTITY_ID_ADD_IN_CARD;
%constant int ENTITY_ID_FRONT_PANEL_BOARD = IPMI_ENTITY_ID_FRONT_PANEL_BOARD;
%constant int ENTITY_ID_BACK_PANEL_BOARD = IPMI_ENTITY_ID_BACK_PANEL_BOARD;
%constant int ENTITY_ID_POWER_SYSTEM_BOARD = IPMI_ENTITY_ID_POWER_SYSTEM_BOARD;
%constant int ENTITY_ID_DRIVE_BACKPLANE = IPMI_ENTITY_ID_DRIVE_BACKPLANE;
%constant int ENTITY_ID_SYSTEM_INTERNAL_EXPANSION_BOARD = IPMI_ENTITY_ID_SYSTEM_INTERNAL_EXPANSION_BOARD;
%constant int ENTITY_ID_OTHER_SYSTEM_BOARD = IPMI_ENTITY_ID_OTHER_SYSTEM_BOARD;
%constant int ENTITY_ID_PROCESSOR_BOARD = IPMI_ENTITY_ID_PROCESSOR_BOARD;
%constant int ENTITY_ID_POWER_UNIT = IPMI_ENTITY_ID_POWER_UNIT;
%constant int ENTITY_ID_POWER_MODULE = IPMI_ENTITY_ID_POWER_MODULE;
%constant int ENTITY_ID_POWER_MANAGEMENT_BOARD = IPMI_ENTITY_ID_POWER_MANAGEMENT_BOARD;
%constant int ENTITY_ID_CHASSIS_BACK_PANEL_BOARD = IPMI_ENTITY_ID_CHASSIS_BACK_PANEL_BOARD;
%constant int ENTITY_ID_SYSTEM_CHASSIS = IPMI_ENTITY_ID_SYSTEM_CHASSIS;
%constant int ENTITY_ID_SUB_CHASSIS = IPMI_ENTITY_ID_SUB_CHASSIS;
%constant int ENTITY_ID_OTHER_CHASSIS_BOARD = IPMI_ENTITY_ID_OTHER_CHASSIS_BOARD;
%constant int ENTITY_ID_DISK_DRIVE_BAY = IPMI_ENTITY_ID_DISK_DRIVE_BAY;
%constant int ENTITY_ID_PERIPHERAL_BAY = IPMI_ENTITY_ID_PERIPHERAL_BAY;
%constant int ENTITY_ID_DEVICE_BAY = IPMI_ENTITY_ID_DEVICE_BAY;
%constant int ENTITY_ID_FAN_COOLING = IPMI_ENTITY_ID_FAN_COOLING;
%constant int ENTITY_ID_COOLING_UNIT = IPMI_ENTITY_ID_COOLING_UNIT;
%constant int ENTITY_ID_CABLE_INTERCONNECT = IPMI_ENTITY_ID_CABLE_INTERCONNECT;
%constant int ENTITY_ID_MEMORY_DEVICE = IPMI_ENTITY_ID_MEMORY_DEVICE;
%constant int ENTITY_ID_SYSTEM_MANAGEMENT_SOFTWARE = IPMI_ENTITY_ID_SYSTEM_MANAGEMENT_SOFTWARE;
%constant int ENTITY_ID_BIOS = IPMI_ENTITY_ID_BIOS;
%constant int ENTITY_ID_OPERATING_SYSTEM = IPMI_ENTITY_ID_OPERATING_SYSTEM;
%constant int ENTITY_ID_SYSTEM_BUS = IPMI_ENTITY_ID_SYSTEM_BUS;
%constant int ENTITY_ID_GROUP = IPMI_ENTITY_ID_GROUP;
%constant int ENTITY_ID_REMOTE_MGMT_COMM_DEVICE = IPMI_ENTITY_ID_REMOTE_MGMT_COMM_DEVICE;
%constant int ENTITY_ID_EXTERNAL_ENVIRONMENT = IPMI_ENTITY_ID_EXTERNAL_ENVIRONMENT;
%constant int ENTITY_ID_BATTERY = IPMI_ENTITY_ID_BATTERY;
%constant int ENTITY_ID_PROCESSING_BLADE = IPMI_ENTITY_ID_PROCESSING_BLADE;
%constant int ENTITY_ID_CONNECTIVITY_SWITCH = IPMI_ENTITY_ID_CONNECTIVITY_SWITCH;
%constant int ENTITY_ID_PROCESSOR_MEMORY_MODULE = IPMI_ENTITY_ID_PROCESSOR_MEMORY_MODULE;
%constant int ENTITY_ID_IO_MODULE = IPMI_ENTITY_ID_IO_MODULE;
%constant int ENTITY_ID_PROCESSOR_IO_MODULE = IPMI_ENTITY_ID_PROCESSOR_IO_MODULE;
%constant int ENTITY_ID_MGMT_CONTROLLER_FIRMWARE = IPMI_ENTITY_ID_MGMT_CONTROLLER_FIRMWARE;
%constant int ENTITY_ID_IPMI_CHANNEL = IPMI_ENTITY_ID_IPMI_CHANNEL;
%constant int ENTITY_ID_PCI_BUS = IPMI_ENTITY_ID_PCI_BUS;
%constant int ENTITY_ID_PCI_EXPRESS_BUS = IPMI_ENTITY_ID_PCI_EXPRESS_BUS;
%constant int ENTITY_ID_SCSI_BUS = IPMI_ENTITY_ID_SCSI_BUS;
%constant int ENTITY_ID_SATA_SAS_BUS = IPMI_ENTITY_ID_SATA_SAS_BUS;
%constant int ENTITY_ID_PROCESSOR_FRONT_SIDE_BUS = IPMI_ENTITY_ID_PROCESSOR_FRONT_SIDE_BUS;

/*
 * An entity object.
 */
%extend ipmi_entity_t {
    /*
     * Get the domain the entity belongs to.
     */
    ipmi_domain_t *get_domain()
    {
	return ipmi_entity_get_domain(self);
    }

    %newobject get_name;
    /*
     * Get the name of an entity.
     */
    char *get_name()
    {
	char name[IPMI_ENTITY_NAME_LEN];

	ipmi_entity_get_name(self, name, sizeof(name));
	return strdup(name);
    }

    %newobject get_id;
    /*
     * Get the id for the entity.
     */
    ipmi_entity_id_t *get_id()
    {
	ipmi_entity_id_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_entity_convert_to_id(self);
	return rv;
    }

    /*
     * Iterate through all the entity's children.  The
     * entity_iter_entities_cb method will be called on the first
     * parameter for each child entity of the parent.  The parameters
     * it receives will be: <self> <parent> <child>.
     */
    int iterate_children(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv = 0;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_iter_entities_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(handler, entity_iter_entities_cb);
	    ipmi_entity_iterate_children(self, entity_iterate_entities_handler,
					 handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Iterate through all the entity's parents.  The
     * entity_iter_entities_cb method will be called on the first
     * parameter for each parent entity of the child.  The parameters
     * it receives will be: <self> <child> <parent>.
     */
    int iterate_parents(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv = 0;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_iter_entities_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(handler, entity_iter_entities_cb);
	    ipmi_entity_iterate_parents(self, entity_iterate_entities_handler,
					handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Iterate through all the entity's sensors.  The
     * entity_iter_sensors_cb method will be called on the first
     * parameter for each sensor of the entity.  The parameters
     * it receives will be: <self> <entity> <sensor>.
     */
    int iterate_sensors(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv = 0;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_iter_sensors_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(handler, entity_iter_sensors_cb);
	    ipmi_entity_iterate_sensors(self, entity_iterate_sensors_handler,
					handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Iterate through all the entity's controls.  The
     * entity_iter_controls_cb method will be called on the first
     * parameter for each control of the entity.  The parameters
     * it receives will be: <self> <entity> <control>.
     */
    int iterate_controls(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv = 0;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_iter_controls_cb))
	    rv = EINVAL;
	else {
	    handler_val = get_swig_cb(handler, entity_iter_controls_cb);
	    ipmi_entity_iterate_controls(self, entity_iterate_controls_handler,
					 handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Add a handler to be called when an entity's presence
     * changes. When the presence changes the entity_presence_cb
     * method on the first parameter will be called with the following
     * parameters: <self> <entity> <present (boolean integer)> <event>.
     * The event is optional and may not be present.
     */
    int add_presence_handler(swig_cb *handler)
    {
	ipmi_entity_add_presence_handler_cl
	    (self, entity_presence_handler_cl, NULL);
	cb_add(entity, presence, entity_presence_cb);
    }

    /*
     * Remove the presence handler.
     */
    int remove_presence_handler(swig_cb *handler)
    {
	cb_rm(entity, presence, entity_presence_cb);
    }

    /*
     * Add a handler to be called when a sensor in the entity is
     * added, deleted, or updated.  When the sensor changes the
     * entity_sensor_update_cb method on the first parameter will be
     * called with the following parameters: <self>
     * added|deleted|changed <entity> <sensor>.
     */
    int add_sensor_update_handler(swig_cb *handler)
    {
	ipmi_entity_add_sensor_update_handler_cl
	    (self, entity_sensor_update_handler_cl, NULL);
	cb_add(entity, sensor_update, entity_sensor_update_cb);
    }

    /*
     * Remove the sensor update handler.
     */
    int remove_sensor_update_handler(swig_cb *handler)
    {
	cb_rm(entity, sensor_update, entity_sensor_update_cb);
    }

    /*
     * Add a handler to be called when a control in the entity is
     * added, deleted, or updated.  When the control changes the
     * entity_control_update_cb method on the first parameter will be
     * called with the following parameters: <self>
     * added|deleted|changed <entity> <control>.
     */
    int add_control_update_handler(swig_cb *handler)
    {
	ipmi_entity_add_control_update_handler_cl
	    (self, entity_control_update_handler_cl, NULL);
	cb_add(entity, control_update, entity_control_update_cb);
    }

    /*
     * Remove the control update handler.
     */
    int remove_control_update_handler(swig_cb *handler)
    {
	cb_rm(entity, control_update, entity_control_update_cb);
    }

    /*
     * Add a handler to be called when the FRU data in the entity is
     * added, deleted, or updated.  When the FRU data changes the
     * entity_fru_update_cb method on the first parameter will be
     * called with the following parameters: <self>
     * added|deleted|changed <entity> <fru>.
     *
     * Deprecated, use the werr version below so you can get errors
     * reported.
     */
    int add_fru_update_handler(swig_cb *handler)
    {
	ipmi_entity_add_fru_update_handler_cl
	    (self, entity_fru_update_handler_cl, NULL);
	cb_add(entity, fru_update, entity_fru_update_cb);
    }

    /*
     * Remove the FRU data update handler.
     */
    int remove_fru_update_handler(swig_cb *handler)
    {
	cb_rm(entity, fru_update, entity_fru_update_cb);
    }

    /*
     * Add a handler to be called when the FRU data in the entity is
     * added, deleted, or updated.  When the FRU data changes the
     * entity_fru_update_werr_cb method on the first parameter will be
     * called with the following parameters: <self>
     * added|deleted|changed|error <errnum> <entity> <fru>.
     */
    int add_fru_update_werr_handler(swig_cb *handler)
    {
	ipmi_entity_add_fru_update_werr_handler_cl
	    (self, entity_fru_update_werr_handler_cl, NULL);
	cb_add(entity, fru_update_werr, entity_fru_update_werr_cb);
    }

    /*
     * Remove the FRU data update handler.
     */
    int remove_fru_update_werr_handler(swig_cb *handler)
    {
	cb_rm(entity, fru_update_werr, entity_fru_update_werr_cb);
    }

    /*
     * Get the entities type, return "mc", "fru", "generic", or "unknown".
     */
    char *get_type()
    {
	switch (ipmi_entity_get_type(self)) {
	case IPMI_ENTITY_MC: return "mc";
	case IPMI_ENTITY_FRU: return "fru";
	case IPMI_ENTITY_GENERIC: return "generic";
	default: return "unknown";
	}
    }

    /*
     * Returns if the entity has FRU data or not.
     */
    int is_fru()
    {
	return ipmi_entity_get_is_fru(self);
    }

    %newobject get_id_string;
    /*
     * Get the ID string from the SDR
     */
    char *get_id_string()
    {
	int length = ipmi_entity_get_id_length(self);
	char *str;
	if (length < 2)
	    return NULL;
	str = malloc(length);
	if (!str)
	    return NULL;
	ipmi_entity_get_id(self, str, length);
	return str;
    }

    /*
     * Get the entity id for the entity
     */
    int get_entity_id()
    {
	return ipmi_entity_get_entity_id(self);
    }

    /*
     * Get the string representation of the entity id
     */
    const char *get_entity_id_string()
    {
	return ipmi_entity_get_entity_id_string(self);
    }

    /*
     * Get the entity instance for the entity
     */
    int get_entity_instance()
    {
	return ipmi_entity_get_entity_instance(self);
    }

    /*
     * Get the channel for the entity.  Only valid if the entity
     * instance is 0x60 or larger.
     */
    int get_entity_device_channel()
    {
	return ipmi_entity_get_device_channel(self);
    }

    /*
     * Get the address for the entity.  Only valid if the entity
     * instance is 0x60 or larger.
     */
    int get_entity_device_address()
    {
	return ipmi_entity_get_device_address(self);
    }

    /*
     * Get the FRU data for the entity.  Note that you cannot hold the
     * FRU data pointer outside the context of where the entity pointer
     * is valid.
     */
    %newobject get_fru;
    ipmi_fru_t *get_fru()
    {
	ipmi_fru_t *fru = ipmi_entity_get_fru(self);
	if (fru)
	    ipmi_fru_ref(fru);
	return fru;
    }

    /*
     * If this returns true, then the presence sensor is always there
     * for this entity.
     */
    int get_presence_sensor_always_there()
    {
	return ipmi_entity_get_presence_sensor_always_there(self);
    }

    /*
     * Returns if the entity has a parent.
     */
    int is_child()
    {
	return ipmi_entity_get_is_child(self);
    }

    /*
     * Returns if the entity has a child.
     */
    int is_parent()
    {
	return ipmi_entity_get_is_parent(self);
    }

    /*
     * Return the channel from the device locator record.  Valid for
     * all entities except unknown.
     */
    int get_channel()
    {
	return ipmi_entity_get_channel(self);
    }

    /*
     * Return the LUN from the device locator record.  Valid for
     * all entities except unknown.
     */
    int get_lun()
    {
	return ipmi_entity_get_lun(self);
    }

    /*
     * Return the OEM byte from the device locator record.  Valid for
     * all entities except unknown.
     */
    int get_oem()
    {
	return ipmi_entity_get_oem(self);
    }

    /*
     * Return the access address from the device locator record.  Valid for
     * FRU and generic entities.
     */
    int get_access_address()
    {
	return ipmi_entity_get_access_address(self);
    }

    /*
     * Return the private bus id from the device locator record.  Valid for
     * FRU and generic entities.
     */
    int get_private_bus_id()
    {
	return ipmi_entity_get_private_bus_id(self);
    }

    /*
     * Return the device type from the device locator record.  Valid for
     * FRU and generic entities.
     */
    int get_device_type()
    {
	return ipmi_entity_get_device_type(self);
    }

    /*
     * Return the device modifier from the device locator record.
     * Valid for FRU and generic entities.
     */
    int get_device_modifier()
    {
	return ipmi_entity_get_device_modifier(self);
    }

    /*
     * Return the slave address from the device locator record.  Valid for
     * MC and generic entities.
     */
    int get_slave_address()
    {
	return ipmi_entity_get_slave_address(self);
    }

    %newobject get_mc_id;
    ipmi_mcid_t *get_mc_id()
    {
	ipmi_mcid_t *mc_id = malloc(sizeof(*mc_id));
	int rv;
	rv = ipmi_entity_get_mc_id(self, mc_id);
	if (rv) {
	    free(mc_id);
	    mc_id = NULL;
	}
	return mc_id;
    }
    /*
     * Return if the FRU is logical (from the device locator record).
     * Valid for FRU entities.
     */
    int get_is_logical_fru()
    {
	return ipmi_entity_get_is_logical_fru(self);
    }

    /*
     * Return the device id from the device locator record.  Valid for
     * FRU entities.
     */
    int get_fru_device_id()
    {
	return ipmi_entity_get_fru_device_id(self);
    }

    /*
     * Return the ACPI system power notify required bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_ACPI_system_power_notify_required()
    {
	return ipmi_entity_get_ACPI_system_power_notify_required(self);
    }

    /*
     * Return the ACPI device power notify required bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_ACPI_device_power_notify_required()
    {
	return ipmi_entity_get_ACPI_device_power_notify_required(self);
    }

    /*
     * Return the controller logs init agent errors bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_controller_logs_init_agent_errors()
    {
	return ipmi_entity_get_controller_logs_init_agent_errors(self);
    }

    /*
     * Return the log init agent errors accessing bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_log_init_agent_errors_accessing()
    {
	return ipmi_entity_get_log_init_agent_errors_accessing(self);
    }

    /*
     * Return the global init bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_global_init()
    {
	return ipmi_entity_get_global_init(self);
    }

    /*
     * Return the chassis device bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_chassis_device()
    {
	return ipmi_entity_get_chassis_device(self);
    }

    /*
     * Return the !bridge bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_bridge()
    {
	return ipmi_entity_get_bridge(self);
    }

    /*
     * Return the IPMB event generator bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_IPMB_event_generator()
    {
	return ipmi_entity_get_IPMB_event_generator(self);
    }

    /*
     * Return the IPMB event receiver bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_IPMB_event_receiver()
    {
	return ipmi_entity_get_IPMB_event_receiver(self);
    }

    /*
     * Return the FRU inventory device bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_FRU_inventory_device()
    {
	return ipmi_entity_get_FRU_inventory_device(self);
    }

    /*
     * Return the SEL device bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_SEL_device()
    {
	return ipmi_entity_get_SEL_device(self);
    }

    /*
     * Return the SDR repository device bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_SDR_repository_device()
    {
	return ipmi_entity_get_SDR_repository_device(self);
    }

    /*
     * Return the sensor device bit from the
     * device locator record.  Valid for MC entities.
     */
    int get_sensor_device()
    {
	return ipmi_entity_get_sensor_device(self);
    }

    /*
     * Return the address span from the device locator record.  Valid
     * for generic entities.
     */
    int get_address_span()
    {
	return ipmi_entity_get_address_span(self);
    }

    %newobject get_dlr_id;
    /*
     * Return the id string from the DLR.
     */
    char *get_dlr_id()
    {
	/* FIXME - no unicode handling. */
	int len = ipmi_entity_get_id_length(self) + 1;
	char *id = malloc(len);
	ipmi_entity_get_id(self, id, len);
	return id;
    }

    /*
     * Returns true if the entity is present, false if not.
     */
    int is_present()
    {
	return ipmi_entity_is_present(self);
    }

    /*
     * Returns the physical slot number, or -1 if there is not
     * a slot number.
     */
    int get_physical_slot_num()
    {
	unsigned int num;
	if (ipmi_entity_get_physical_slot_num(self, &num) == 0)
	    return num;
	else
	    return -1;
    }

    /*
     * Returns true if the entity is hot-swappable, false if not.
     */
    int is_hot_swappable()
    {
	return ipmi_entity_hot_swappable(self);
    }

    int supports_managed_hot_swap()
    {
	return ipmi_entity_supports_managed_hot_swap(self);
    }

    /*
     * Add a handler to be called when the hot-swap state for the
     * entity changes.  When the hot-swap state changes the
     * entity_hot_swap_update_cb method on the first parameter will be
     * called with the following parameters: <self> <entity> <old
     * state> <new state> <event>.  The event is optional and may not
     * be present.
     */
    int add_hot_swap_handler(swig_cb *handler)
    {
	ipmi_entity_add_hot_swap_handler_cl
	    (self, entity_hot_swap_handler_cl, NULL);
	cb_add(entity, hot_swap, entity_hot_swap_update_cb);
    }

    /*
     * Remove the hot-swap update handler.
     */
    int remove_hot_swap_handler(swig_cb *handler)
    {
	cb_rm(entity, hot_swap, entity_hot_swap_update_cb);
    }

    /*
     * Get the current hot-swap state for the entity.  The
     * entity_hot_swap_cb handler will be called with the following
     * parameters: <self> <entity> <err> <state>
     */
    int get_hot_swap_state(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_hot_swap_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, entity_hot_swap_cb);
	    rv = ipmi_entity_get_hot_swap_state(self,
						entity_get_hot_swap_handler,
						handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /* Returns if the entity supports auto-activate. */
    int supports_auto_activate_time()
    {
	return ipmi_entity_supports_auto_activate_time(self);
    }

    /*
     * Get the current hot-swap activation time for the entity.  The
     * entity_hot_swap_get_time_cb handler will be called with the
     * following parameters: <self> <entity> <err> <time>
     */
    int get_auto_activate_time(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_hot_swap_get_time_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, entity_hot_swap_get_time_cb);
	    rv = ipmi_entity_get_auto_activate_time
		(self,
		 entity_get_hot_swap_time_handler,
		 handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set the current hot-swap activation time for the entity.  The
     * entity_hot_swap_set_time_cb handler will be called with the
     * following parameters (if it is supplied): <self> <entity> <err>
     */
    int set_auto_activate_time(ipmi_timeout_t auto_act,
			       swig_cb *handler = NULL)
    {
	swig_cb_val    *handler_val = NULL;
	ipmi_entity_cb done = NULL;
	int            rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, entity_hot_swap_set_time_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, entity_hot_swap_set_time_cb);
	    done = entity_set_hot_swap_time_handler;
	}
	rv = ipmi_entity_set_auto_activate_time
	    (self, auto_act, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /* Returns if the entity supports auto-deactivate. */
    int supports_auto_deactivate_time()
    {
	return ipmi_entity_supports_auto_deactivate_time(self);
    }

    /*
     * Get the current hot-swap deactivation time for the entity.  The
     * entity_hot_swap_get_time_cb handler will be called with the
     * following parameters: <self> <entity> <err> <time>
     */
    int get_auto_deactivate_time(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, entity_hot_swap_get_time_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, entity_hot_swap_get_time_cb);
	    rv = ipmi_entity_get_auto_deactivate_time
		(self,
		 entity_get_hot_swap_time_handler,
		 handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set the current hot-swap deactivation time for the entity.  The
     * entity_hot_swap_set_time_cb handler will be called with the
     * following parameters (if it is supplied): <self> <entity> <err>
     */
    int set_auto_deactivate_time(ipmi_timeout_t auto_act,
				 swig_cb        *handler = NULL)
    {
	swig_cb_val    *handler_val = NULL;
	ipmi_entity_cb done = NULL;
	int            rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, entity_hot_swap_set_time_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, entity_hot_swap_set_time_cb);
	    done = entity_set_hot_swap_time_handler;
	}
	rv = ipmi_entity_set_auto_deactivate_time
	    (self, auto_act, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Cause the entity to move from INACTIVE to ACTIVATION_REQUESTED
     * state, if possible. If the entity does not support this
     * operation, this will return ENOSYS and you can move straight
     * from INACTIVE to ACTIVE state by calling ipmi_entity_activate.
     * After this is done, the entity_activate_cb handler will be
     * called with the following parameters (if it is supplied):
     * <self> <entity> <err>
     */
    int set_activation_requested(swig_cb *handler = NULL)
    {
	swig_cb_val    *handler_val = NULL;
	ipmi_entity_cb done = NULL;
	int            rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, entity_activate_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, entity_activate_cb);
	    done = entity_activate_handler;
	}
	rv = ipmi_entity_set_activation_requested(self, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Attempt to activate an entity.  Activate will cause a
     * transition from INACTIVE to ACTIVE (but only if
     * ipmi_entity_set_activation_requested() returns ENOSYS), or from
     * ACTIVATION_REQUESTED to ACTIVE.  After this is done, the
     * entity_activate_cb handler will be called with the following
     * parameters (if it is supplied): <self> <entity> <err>
     */
    int activate(swig_cb *handler = NULL)
    {
	swig_cb_val    *handler_val = NULL;
	ipmi_entity_cb done = NULL;
	int            rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, entity_activate_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, entity_activate_cb);
	    done = entity_activate_handler;
	}
	rv = ipmi_entity_activate(self, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Attempt to deactivate an entity.  Deactivate will cause a
     * transition from DEACTIVATION_REQUESTED or ACTIVE to INACTIVE.
     * After this is done, the entity_activate_cb handler will be
     * called with the following parameters (if it is supplied):
     * <self> <entity> <err>
     */
    int deactivate(swig_cb *handler = NULL)
    {
	swig_cb_val    *handler_val = NULL;
	ipmi_entity_cb done = NULL;
	int            rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, entity_activate_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, entity_activate_cb);
	    done = entity_activate_handler;
	}
	rv = ipmi_entity_deactivate(self, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Check the state of hot-swap for the entity.  This causes the
     * local state to be audited against the actual state.
     */
    int check_hot_swap_state()
    {
	return ipmi_entity_check_hot_swap_state(self);
    }

}

/*
 * A mc id object.  This object is guaranteed to be valid and
 * can be converted into a mc pointer later.
 */
%extend ipmi_mcid_t {
    ~ipmi_mcid_t()
    {
	free(self);
    }

    /* Compare self with other, return -1 if self<other, 0 if
       self==other, or 1 if self>other.  */
    int cmp(ipmi_mcid_t *other)
    {
	return ipmi_cmp_mc_id(*self, *other);
    }

    /*
     * Convert a mc id to a mc pointer.  The "mc_cb" method
     * will be called on the first parameter with the following parameters:
     * <self> <mc>
     */
    int to_mc(swig_cb *handler)
    {
	int rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, mc_cb))
	    rv = EINVAL;
	else
	    rv = ipmi_mc_pointer_cb(*self, handle_mc_cb,
				    get_swig_cb(handler, mc_cb));
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

/*
 * An MC object
 */
%extend ipmi_mc_t {
    /*
     * Get the domain the mc belongs to.
     */
    ipmi_domain_t *get_domain()
    {
	return ipmi_mc_get_domain(self);
    }

    %newobject get_name;
    /*
     * Get the name of an mc.
     */
    char *get_name()
    {
	char name[IPMI_MC_NAME_LEN];

	ipmi_mc_get_name(self, name, sizeof(name));
	return strdup(name);
    }

    %newobject get_id;
    /*
     * Get the id for the mc.
     */
    ipmi_mcid_t *get_id()
    {
	ipmi_mcid_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_mc_convert_to_id(self);
	return rv;
    }

    %newobject get_guid;
    /*
     * Get the GUID for the MC.  Returns NULL if it is not supported.
     */
    char *get_guid()
    {
	char          *str = NULL;
	unsigned char guid[16];

	if (ipmi_mc_get_guid(self, guid) == 0) {
	    str = malloc(16 * 3);
	    if (str) {
		char *s = str;
		int  i;
		s += sprintf(s, "%2.2x", guid[0]);
		for (i=1; i<16; i++)
		    s += sprintf(s, " %2.2x", guid[i]);
	    }
	}
	return str;
    }

    /*
     * Get the provides_device_sdrs from the get device id response
     * from the MC.
     */
    int provides_device_sdrs()
    {
	return ipmi_mc_provides_device_sdrs(self);
    }

    /*
     * Get the device_available bit from the get device id response
     * from the MC.
     */
    int device_available()
    {
	return ipmi_mc_device_available(self);
    }

    /*
     * Get the chassis_support bit from the get device id response
     * from the MC.
     */
    int chassis_support()
    {
	return ipmi_mc_chassis_support(self);
    }

    /*
     * Get the bridge_support bit from the get device id response
     * from the MC.
     */
    int bridge_support()
    {
	return ipmi_mc_bridge_support(self);
    }

    /*
     * Get the ipmb_event_generator_support bit from the get device id response
     * from the MC.
     */
    int ipmb_event_generator_support()
    {
	return ipmi_mc_ipmb_event_generator_support(self);
    }

    /*
     * Get the ipmb_event_receiver_support bit from the get device id response
     * from the MC.
     */
    int ipmb_event_receiver_support()
    {
	return ipmi_mc_ipmb_event_receiver_support(self);
    }

    /*
     * Get the fru_inventory_support bit from the get device id response
     * from the MC.
     */
    int fru_inventory_support()
    {
	return ipmi_mc_fru_inventory_support(self);
    }

    /*
     * Get the sel_device_support bit from the get device id response
     * from the MC.
     */
    int sel_device_support()
    {
	return ipmi_mc_sel_device_support(self);
    }

    /*
     * Get the sdr_repository_support bit from the get device id response
     * from the MC.
     */
    int sdr_repository_support()
    {
	return ipmi_mc_sdr_repository_support(self);
    }

    /*
     * Get the sensor_device_support bit from the get device id response
     * from the MC.
     */
    int sensor_device_support()
    {
	return ipmi_mc_sensor_device_support(self);
    }

    /*
     * Get the device_id from the get device id response
     * from the MC.
     */
    int device_id()
    {
	return ipmi_mc_device_id(self);
    }

    /*
     * Get the device_revision from the get device id response
     * from the MC.
     */
    int device_revision()
    {
	return ipmi_mc_device_revision(self);
    }

    /*
     * Get the major_fw_revision from the get device id response
     * from the MC.
     */
    int major_fw_revision()
    {
	return ipmi_mc_major_fw_revision(self);
    }

    /*
     * Get the minor_fw_revision from the get device id response
     * from the MC.
     */
    int minor_fw_revision()
    {
	return ipmi_mc_minor_fw_revision(self);
    }

    /*
     * Get the major_version from the get device id response
     * from the MC.
     */
    int major_version()
    {
	return ipmi_mc_major_version(self);
    }

    /*
     * Get the minor_version from the get device id response
     * from the MC.
     */
    int minor_version()
    {
	return ipmi_mc_minor_version(self);
    }

    /*
     * Get the manufacturer_id from the get device id response
     * from the MC.
     */
    int manufacturer_id()
    {
	return ipmi_mc_manufacturer_id(self);
    }

    /*
     * Get the product_id from the get device id response
     * from the MC.
     */
    int product_id()
    {
	return ipmi_mc_product_id(self);
    }

    /*
     * Get the auxiliary firmware revision.  This returns a string
     * with four bytes set.
     */
    %newobject aux_fw_revision;
    char *aux_fw_revision()
    {
	char *str;
	unsigned char data[4];

	str = malloc(28);
	ipmi_mc_aux_fw_revision(self, data);
	snprintf(str, 28,
		 "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x",
		 data[0], data[1], data[2], data[3]);
	return str;
    }

    /*
     * Check to see if the MC is operational in the system.  If this
     * is return sfalse, then the MC was referred to by an SDR, but it
     * doesn't really exist (at least not yet).
     */
    int is_active()
    {
	return ipmi_mc_is_active(self);
    }

    /*
     * Add a handler to be called when an mc's active state
     * changes. When the active state changes the mc_active_cb
     * method on the first parameter will be called with the following
     * parameters: <self> <mc> <active (boolean integer)>.
     */
    int add_active_handler(swig_cb *handler)
    {
	ipmi_mc_add_active_handler_cl
	    (self, mc_active_handler_cl, NULL);
	cb_add(mc, active, mc_active_cb);
    }

    /*
     * Remove the presence handler.
     */
    int remove_active_handler(swig_cb *handler)
    {
	cb_rm(mc, active, mc_active_cb);
    }

    /*
     * Add a handler to be called when an mc has reached fully up
     * status.  When this happens the mc_fully_up_cb
     * method on the first parameter will be called with the following
     * parameters: <self> <mc>.
     */
    int add_fully_up_handler(swig_cb *handler)
    {
	ipmi_mc_add_fully_up_handler_cl
	    (self, mc_fully_up_handler_cl, NULL);
	cb_add(mc, fully_up, mc_fully_up_cb);
    }

    /*
     * Remove the presence handler.
     */
    int remove_fully_up_handler(swig_cb *handler)
    {
	cb_rm(mc, fully_up, mc_fully_up_cb);
    }

    /*
     * Send a command to a given MC with the given lun (parm 1), netfn
     * (parm 2), command (parm 3).  Parm 4 is the message data in an
     * array reference.  Parm 5 is the handler, it will be called with
     * the response.  The mc_cmd_cb method will be called on the
     * handler (if it is supplied); its parameters are: <mc> <netfn> <cmd>
     * <response data>
     */
    int send_command(int       lun,
		     int       netfn,
		     int       cmd,
		     intarray  msg_data,
		     swig_cb   *handler = NULL)
    {
	int                        rv;
	swig_cb_val                *handler_val = NULL;
	ipmi_mc_response_handler_t msg_cb = NULL;
	ipmi_msg_t                 msg;
	unsigned char              data[MAX_IPMI_DATA_SIZE];
	unsigned int               data_len;

	IPMI_SWIG_C_CB_ENTRY
	msg.netfn = netfn;
	msg.cmd = cmd;
	msg.data = data;
	rv = parse_ipmi_data(msg_data, data, sizeof(data), &data_len);
	msg.data_len = data_len;
	if (rv)
	    goto out_err;

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_cmd_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    msg_cb = mc_msg_cb;
	    handler_val = ref_swig_cb(handler, mc_cmd_cb);
	}
	rv = ipmi_mc_send_command(self, lun, &msg, msg_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

%constant int MC_RESET_COLD = IPMI_MC_RESET_COLD;
%constant int MC_RESET_WARM = IPMI_MC_RESET_WARM;
    /*
     * Reset the MC, either a cold or warm reset depending on the
     * first parm.  Note that the effects of a reset are not defined
     * by IPMI, so this might do wierd things.  Some systems do not
     * support resetting the MC.  This is not a standard control
     * because there is no entity to hang if from and you don't want
     * people messing with it unless they really know what they are
     * doing.  When the reset is complete the mc_reset_cb will be
     * called on the second parameter of this call (if it is
     * supplied) with the following parameters: <self> <mc> <err>
     */
    int reset(int     reset_type,
	      swig_cb *handler = NULL)
    {
	swig_cb_val     *handler_val = NULL;
	ipmi_mc_done_cb done = NULL;
	int             rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_reset_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_reset_cb);
	    done = mc_reset_handler;
	}
	rv = ipmi_mc_reset(self, reset_type, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /* Get the setting to enable events for the entire MC.  The value
       returned by the get function is a boolean telling whether
       events are enabled. */
    int get_events_enable()
    {
	return ipmi_mc_get_events_enable(self);
    }

    /*
     * Set the setting to enable events for the entire MC.  The "val"
     * passed in as the first parameter is a boolean telling whether
     * to turn events on (true) or off (false).  When the operation
     * completes the mc_events_enable_cb will be called on the handler
     * (if it is supplied) with the following parameters: <self> <mc>
     * <err>.
     */
    int set_events_enable(int     val,
			  swig_cb *handler = NULL)
    {
	swig_cb_val     *handler_val = NULL;
	ipmi_mc_done_cb done = NULL;
	int             rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_events_enable_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_events_enable_cb);
	    done = mc_events_enable_handler;
	}
	rv = ipmi_mc_set_events_enable(self, val, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Find out of the event log is enabled.  The
     * mc_get_event_log_enable_cb will be called on the supplied
     * handler with the following parms: <self> <mc> <err> <val>
     */
    int get_event_log_enable(swig_cb *handler)
    {
	swig_cb_val *handler_val;
	int         rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, mc_get_event_log_enable_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, mc_get_event_log_enable_cb);
	    
	    rv = ipmi_mc_get_event_log_enable(self,
					      mc_get_event_log_enable_handler,
					      handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set the MC's event log enable.  The mc_set_event_log_enable_cb
     * will be called on the supplied handler with the following
     * parms: <self> <mc> <err>
     */
    int set_event_log_enable(int val, swig_cb *handler = NULL)
    {
	swig_cb_val     *handler_val = NULL;
	ipmi_mc_done_cb done = NULL;
	int             rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_set_event_log_enable_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_set_event_log_enable_cb);
	    done = mc_set_event_log_enable_handler;
	}
	rv = ipmi_mc_set_event_log_enable(self, val, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Reread all the sensors for a given mc.  This will request the
     * device SDRs for that mc (And only for that MC) and change the
     * sensors as necessary.  When the operation completes, the
     * mc_reread_sensors_cb on the first parameter (if supplied) will
     * be called with the following parms: <self> <mc> <err>.
     */
    int reread_sensors(swig_cb *handler = NULL)
    {
	swig_cb_val     *handler_val = NULL;
	ipmi_mc_done_cb done = NULL;
	int             rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_reread_sensors_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_reread_sensors_cb);
	    done = mc_reread_sensors_handler;
	}
	rv = ipmi_mc_reread_sensors(self, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set the time between SEL rescans for the MC (and only that MC).
     * Parm 1 is the time in seconds.
     */
    void set_sel_rescan_time(unsigned int seconds)
    {
	ipmi_mc_set_sel_rescan_time(self, seconds);
    }

    /*
     * Return the current SEL rescan time for the MC.
     */
    int get_sel_rescan_time()
    {
	return ipmi_mc_get_sel_rescan_time(self);
    }

    /*
     * Reread the sel for the MC.  When the handler is called, all the
     * events in the SEL have been fetched into the local copy of the
     * SEL (with the obvious caveat that this is a distributed system
     * and other things may have come in after the read has finised).
     * When this completes, the mc_reread_sel_cb method will be called
     * on the handler (parm 1, if it is supplied) with the parameters:
     * <self> <mc> <err>.
     */
    int reread_sel(swig_cb *handler = NULL)
    {
	swig_cb_val     *handler_val = NULL;
	ipmi_mc_done_cb done = NULL;
	int             rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_reread_sel_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_reread_sel_cb);
	    done = mc_reread_sel_handler;
	}
	rv = ipmi_mc_reread_sel(self, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Fetch the current time from the SEL.  When the operation
     * completes, the mc_get_sel_time_cb method will be called on the
     * first parameter (if it is supplied) with the following
     * values: <self> <mc> <err> <time>
     */
    int get_current_sel_time(swig_cb *handler)
    {
	swig_cb_val     *handler_val = NULL;
	sel_get_time_cb done = NULL;
	int             rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_get_sel_time_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_get_sel_time_cb);
	    done = mc_sel_get_time_cb;
	}
	rv = ipmi_mc_get_current_sel_time(self, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    %newobject first_event;
    /*
     * Retrieve the first event from the MC.  Return NULL (undef)
     * if the event does not exist.
     */
    ipmi_event_t *first_event()
    {
	return ipmi_mc_first_event(self);
    }

    %newobject last_event;
    /*
     * Retrieve the last event from the MC.
     */
    ipmi_event_t *last_event()
    {
	return ipmi_mc_last_event(self);
    }

    %newobject next_event;
    /*
     * Retrieve the next event from the MC.
     */
    ipmi_event_t *next_event(ipmi_event_t *event)
    {
	return ipmi_mc_next_event(self, event);
    }

    %newobject prev_event;
    /*
     * Retrieve the previous event from the MC.
     */
    ipmi_event_t *prev_event(ipmi_event_t *event)
    {
	return ipmi_mc_prev_event(self, event);
    }

    %newobject event_by_recid;
    /*
     * Retrieve the event with the given record id from the MC.
     */
    ipmi_event_t *event_by_recid(int record_id)
    {
	return ipmi_mc_event_by_recid(self, record_id);
    }

    /*
     * The number of live items in the local copy of the MC's SEL.
     */
    int sel_count()
    {
	return ipmi_mc_sel_count(self);
    }

    /*
     * Number of entries in the the remote SEL.  If an entry has been
     * deleted in the local copy of the SEL but has not yet finished
     * being deleted in the remote copy, it will be counted here.
     */
    int sel_entries_used()
    {
	return ipmi_mc_sel_entries_used(self);
    }

    /*
     * The major version of the MC's SEL.
     */
    int sel_get_major_version()
    {
	return ipmi_mc_sel_get_major_version(self);
    }

    /*
     * The minor version of the MC's SEL.
     */
    int sel_get_minor_version()
    {
	return ipmi_mc_sel_get_minor_version(self);
    }

    /*
     * The number of entries available in the MC's SEL.
     */
    int sel_get_num_entries()
    {
	return ipmi_mc_sel_get_num_entries(self);
    }

    /*
     * The number of free bytes available in the MC's SEL.
     */
    int sel_get_free_bytes()
    {
	return ipmi_mc_sel_get_free_bytes(self);
    }

    /*
     * Has an overflow occurred since the last SEL operation?
     */
    int sel_get_overflow()
    {
	return ipmi_mc_sel_get_overflow(self);
    }

    /*
     * Does the SEL support individual deletes of entries?
     */
    int sel_get_supports_delete_sel()
    {
	return ipmi_mc_sel_get_supports_delete_sel(self);
    }

    /*
     * Does the SEL support partial adds of entries?
     */
    int sel_get_supports_partial_add_sel()
    {
	return ipmi_mc_sel_get_supports_partial_add_sel(self);
    }

    /*
     * Does the SEL support the reserve protocol?
     */
    int sel_get_supports_reserve_sel()
    {
	return ipmi_mc_sel_get_supports_reserve_sel(self);
    }

    /*
     * Does the SEL support getting the SEL allocastion?
     */
    int sel_get_supports_get_sel_allocation()
    {
	return ipmi_mc_sel_get_supports_get_sel_allocation(self);
    }

    /*
     * The timestamp of the last time something was added to the SEL.
     */
    int sel_get_last_addition_timestamp()
    {
	return ipmi_mc_sel_get_last_addition_timestamp(self);
    }

%constant int MAX_USED_CHANNELS = MAX_IPMI_USED_CHANNELS;
    /*
     * Get the info for a channel on the MC.  The first parm is the
     * integer channel number.  The second is the handler object,
     * the mc_channel_got_info_cb method will be called on it with the
     * following parameters: <self> <mc> <err> <chan_info>
     * where chan_info is ipmi_channel_info_t.
     */
    int channel_get_info(int channel, swig_cb *handler)
    {
	int         rv;
	swig_cb_val *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, mc_channel_got_info_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, mc_channel_got_info_cb);
	    rv = ipmi_mc_channel_get_info(self, channel,
					  mc_channel_get_info, handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the access info for a channel on the MC.  The first parm is
     * the integer channel number.  The second parm is the type to
     * set, either "volatile" or "nonvolatile".  The third is the
     * handler object, the mc_channel_got_access_cb method will be
     * called on it with the following parameters: <self> <mc> <err>
     * <access_info> where access_info is ipmi_channel_access_t.
     */
    int channel_get_access(int channel, char *type, swig_cb *handler)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	enum ipmi_set_dest_e dest;

	IPMI_SWIG_C_CB_ENTRY
	if (strcmp(type, "nonvolatile") == 0)
	    dest = IPMI_SET_DEST_NON_VOLATILE;
	else if (strcmp(type, "volatile") == 0)
	    dest = IPMI_SET_DEST_VOLATILE;
	else {
	    rv = EINVAL;
	    goto out_err;
	}

	if (!valid_swig_cb(handler, mc_channel_got_access_cb)) {
	    rv = EINVAL;
	    goto out_err;
	}
	handler_val = ref_swig_cb(handler, mc_channel_got_access_cb);
	rv = ipmi_mc_channel_get_access(self, channel, dest,
					mc_channel_get_access, handler_val);
	if (rv)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set the access info for a channel on the MC, generally from one
     * that you have previously fetched.  The first parameter is the
     * access object you with to set the channel to.  The second parm
     * is the integer channel number.  The third parm is the type to
     * set, either "volatile" or "nonvolatile".  The forth is the
     * handler object, the mc_channel_set_access_cb method will be
     * called on it with the following parameters: <self> <mc> <err>.
     */
    int channel_set_access(ipmi_channel_access_t *access,
			   int                   channel,
			   char                  *type,
			   swig_cb               *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	ipmi_mc_done_cb      done = NULL;
	enum ipmi_set_dest_e dest;

	IPMI_SWIG_C_CB_ENTRY
	if (strcmp(type, "nonvolatile") == 0)
	    dest = IPMI_SET_DEST_NON_VOLATILE;
	else if (strcmp(type, "volatile") == 0)
	    dest = IPMI_SET_DEST_VOLATILE;
	else {
	    rv = EINVAL;
	    goto out_err;
	}

	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, mc_channel_set_access_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_channel_set_access_cb);
	    done = mc_channel_set_access;
	}
	rv = ipmi_mc_channel_set_access(self, channel, dest, access,
					done, handler_val);
	if (rv)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the user info for a channel on the MC.  The first parameter
     * is the channel.  The second is the user number; if a valid user
     * number is passed in, then that user is the only one fetched.
     * If 0 is passed for the user number, then all users are
     * fetched.  The third is the handler object, the
     * mc_channel_got_users_cb method will be called on it with the
     * following parameters: <self> <mc> <err> <max users>
     * <enabled users> <fixed users> <user1> [<user2> ...]
     * where the users are ipmi_user_t objects.
     */
    int get_users(int channel, int user, swig_cb *handler)
    {
	int         rv;
	swig_cb_val *handler_val;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, mc_channel_got_users_cb)) 
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, mc_channel_got_users_cb);
	    rv = ipmi_mc_get_users(self, channel, user,
				   mc_channel_got_users, handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set the user info for a channel on the MC.  The first parameter
     * is the ipmi_user_t object.  The second parameter is the
     * channel.  The third is the user number; if a valid user number
     * is passed in, then that user is the only one fetched.  The
     * fourth is the handler object, the mc_channel_set_user_cb
     * method will be called on it with the following parameters:
     * <self> <mc> <err>.  Note that some info is channel-specific.
     * Just the name and password and enable are global to the MC.
     */
    int set_user(ipmi_user_t *userinfo,
		 int         channel,
		 int         usernum,
		 swig_cb     *handler = NULL)
    {
	int             rv;
	swig_cb_val     *handler_val = NULL;
	ipmi_mc_done_cb done = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, mc_channel_set_user_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, mc_channel_set_user_cb);
	    done = mc_channel_set_user;
	}
	rv = ipmi_mc_set_user(self, channel, usernum, userinfo,
			      done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Allocate a lanparm object for the MC.  The channel is the first
     * parameter, the lanparm is returned.
     */
    %newobject get_lanparm;
    ipmi_lanparm_t *get_lanparm(int channel)
    {
	int            rv;
	ipmi_lanparm_t *lp;

	rv = ipmi_lanparm_alloc(self, channel, &lp);
	if (rv)
	    return NULL;
	return lp;
    }

    /*
     * Allocate a pef object for the MC.  The pef object is returned.
     * The first parameter is an optional callback object, the
     * got_pef_cb method will be called on it when the PEF fetch is
     * complete.  It will have the following parameters: <self> <pef>
     * <err>.  Note that you cannot use the PEF until the fetch is
     * complete.
     */
    %newobject get_pef;
    ipmi_pef_t *get_pef(swig_cb *handler = NULL)
    {
	int              rv;
	ipmi_pef_t       *pef = NULL;
	swig_cb_val      *handler_val = NULL;
	ipmi_pef_done_cb done = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, got_pef_cb))
		goto out_err;
	    handler_val = ref_swig_cb(handler, got_pef_cb);
	    done = get_pef;
	}
	rv = ipmi_pef_alloc(self, done, handler_val, &pef);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return pef;
    }

    /*
     * Allocate a pet object for the MC.  The pet is returned.  The
     * eighth parameter is an optional callback object, the got_pet_cb
     * method will be called on it when the PET fetch is complete.  It
     * will have the following parameters: <self> <pet> <err>.
     * The parameters are:
     *   int channel: the channel number to set the PET for
     *   char ip_addr: the address to send the traps to
     *   char mac_addr: the mac address to send the traps to
     * The rest are the selectors in the various tables, you have to
     * read the spec and know your system to know how to set them.
     *   int eft_sel:
     *   int policy_num:
     *   int apt_sel:
     *   int lan_dest_sel:
     *
     * Note that you must keep a reference to the pet around, or it will
     * be automatically destroyed by the garbage collector.
     */
    %newobject get_pet;
    ipmi_pet_t *get_pet(int     channel,
			char    *ip_addr,
			char    *mac_addr,
			int     eft_sel,
			int     policy_num,
			int     apt_sel,
			int     lan_dest_sel,
			swig_cb *handler = NULL)
    {
	int              rv;
	ipmi_pet_t       *pet = NULL;
	swig_cb_val      *handler_val = NULL;
	struct in_addr   ip;
	unsigned char    mac[6];
	ipmi_pet_done_cb done = NULL;

	IPMI_SWIG_C_CB_ENTRY
        rv = parse_ip_addr(ip_addr, &ip);
	if (rv)
	    goto out_err;

        rv = parse_mac_addr(mac_addr, mac);
	if (rv)
	    goto out_err;

	if (!nil_swig_cb(handler)) {
	    if (!valid_swig_cb(handler, got_pet_cb))
		goto out_err;
	    handler_val = ref_swig_cb(handler, got_pet_cb);
	    done = get_pet;
	}
	rv = ipmi_pet_create_mc(self, channel, ip, mac, eft_sel, policy_num,
				apt_sel, lan_dest_sel, done, handler_val,
				&pet);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return pet;
    }

    /*
     * Allocate a solparm object for the MC.  The channel is the first
     * parameter, the solparm is returned.
     */
    %newobject get_solparm;
    ipmi_solparm_t *get_solparm(int channel)
    {
	int            rv;
	ipmi_solparm_t *lp;

	rv = ipmi_solparm_alloc(self, channel, &lp);
	if (rv)
	    return NULL;
	return lp;
    }
}

%extend ipmi_channel_info_t {
    ~ipmi_channel_info_t()
    {
	ipmi_channel_info_free(self);
    }

    %newobject copy;
    ipmi_channel_info_t *copy()
    {
	return ipmi_channel_info_copy(self);
    }

    int get_channel(int *channel)
    {
	unsigned int val;
	int rv = ipmi_channel_info_get_channel(self, &val);
	*channel = val;
	return rv;
    }

%constant int CHANNEL_MEDIUM_IPMB = IPMI_CHANNEL_MEDIUM_IPMB;
%constant int CHANNEL_MEDIUM_ICMB_V10 = IPMI_CHANNEL_MEDIUM_ICMB_V10;
%constant int CHANNEL_MEDIUM_ICMB_V09 = IPMI_CHANNEL_MEDIUM_ICMB_V09;
%constant int CHANNEL_MEDIUM_8023_LAN = IPMI_CHANNEL_MEDIUM_8023_LAN;
%constant int CHANNEL_MEDIUM_RS232 = IPMI_CHANNEL_MEDIUM_RS232;
%constant int CHANNEL_MEDIUM_OTHER_LAN = IPMI_CHANNEL_MEDIUM_OTHER_LAN;
    %constant int CHANNEL_MEDIUM_PCI_SMBUS = IPMI_CHANNEL_MEDIUM_PCI_SMBUS;
%constant int CHANNEL_MEDIUM_SMBUS_v1 = IPMI_CHANNEL_MEDIUM_SMBUS_v1;
%constant int CHANNEL_MEDIUM_SMBUS_v2 = IPMI_CHANNEL_MEDIUM_SMBUS_v2;
%constant int CHANNEL_MEDIUM_USB_v1 = IPMI_CHANNEL_MEDIUM_USB_v1;
%constant int CHANNEL_MEDIUM_USB_v2 = IPMI_CHANNEL_MEDIUM_USB_v2;
%constant int CHANNEL_MEDIUM_SYS_INTF = IPMI_CHANNEL_MEDIUM_SYS_INTF;
    int get_medium(int *medium)
    {
	unsigned int val;
	int rv = ipmi_channel_info_get_medium(self, &val);
	*medium = val;
	return rv;
    }

%constant int CHANNEL_PROTOCOL_IPMB = IPMI_CHANNEL_PROTOCOL_IPMB;
%constant int CHANNEL_PROTOCOL_ICMB = IPMI_CHANNEL_PROTOCOL_ICMB;
%constant int CHANNEL_PROTOCOL_SMBus = IPMI_CHANNEL_PROTOCOL_SMBus;
%constant int CHANNEL_PROTOCOL_KCS = IPMI_CHANNEL_PROTOCOL_KCS;
%constant int CHANNEL_PROTOCOL_SMIC = IPMI_CHANNEL_PROTOCOL_SMIC;
%constant int CHANNEL_PROTOCOL_BT_v10 = IPMI_CHANNEL_PROTOCOL_BT_v10;
%constant int CHANNEL_PROTOCOL_BT_v15 = IPMI_CHANNEL_PROTOCOL_BT_v15;
%constant int CHANNEL_PROTOCOL_TMODE = IPMI_CHANNEL_PROTOCOL_TMODE;
    int get_protocol_type(int *prot_type)
    {
	unsigned int val;
	int rv = ipmi_channel_info_get_protocol_type(self, &val);
	*prot_type = val;
	return rv;
    }


%constant int CHANNEL_SESSION_LESS = IPMI_CHANNEL_SESSION_LESS;
%constant int CHANNEL_SINGLE_SESSION = IPMI_CHANNEL_SINGLE_SESSION;
%constant int CHANNEL_MULTI_SESSION = IPMI_CHANNEL_MULTI_SESSION;
%constant int CHANNEL_SESSION_BASED = IPMI_CHANNEL_SESSION_BASED;
    int get_session_support(int *sup)
    {
	unsigned int val;
	int rv = ipmi_channel_info_get_session_support(self, &val);
	*sup = val;
	return rv;
    }

    /* Data is 3 bytes long */
    %newobject get_vendor_id;
    char *get_vendor_id()
    {
	unsigned char data[3];
	int           rv;
	char          *rdata = malloc(15);

	if (!rdata)
	    return NULL;
	rv = ipmi_channel_info_get_vendor_id(self, data);
	if (rv)
	    return NULL;
	sprintf(rdata, "0x%2.2x 0x%2.2x 0x%2.2x", data[0], data[1], data[2]);
	return rdata;
    }

    /* Data is 2 bytes long */
    %newobject get_aux_info;
    char *get_aux_info()
    {
	unsigned char data[2];
	int           rv;
	char          *rdata = malloc(10);

	if (!rdata)
	    return NULL;
	rv = ipmi_channel_info_get_aux_info(self, data);
	if (rv)
	    return NULL;
	sprintf(rdata, "0x%2.2x 0x%2.2x", data[0], data[1]);
	return rdata;
    }
}

%extend ipmi_channel_access_t {
    ~ipmi_channel_access_t()
    {
	ipmi_channel_access_free(self);
    }

    %newobject copy;
    ipmi_channel_access_t *copy()
    {
	return ipmi_channel_access_copy(self);
    }

    int get_channel(int *channel)
    {
	unsigned int val;
	int rv = ipmi_channel_access_get_channel(self, &val);
	*channel = val;
	return rv;
    }

    int get_alerting_enabled(int *enab)
    {
	unsigned int val;
	int rv = ipmi_channel_access_get_alerting_enabled(self, &val);
	*enab = val;
	return rv;
    }

    int set_alerting_enabled(int enab)
    {
	return ipmi_channel_access_set_alerting_enabled(self, enab);
    }

    int get_per_msg_auth(int *msg_auth)
    {
	unsigned int val;
	int rv = ipmi_channel_access_get_per_msg_auth(self, &val);
	*msg_auth = val;
	return rv;
    }

    int set_per_msg_auth(int msg_auth)
    {
	return ipmi_channel_access_set_per_msg_auth(self, msg_auth);
    }

    int get_user_auth(int *user_auth)
    {
	unsigned int val;
	int rv = ipmi_channel_access_get_user_auth(self, &val);
	*user_auth = val;
	return rv;
    }

    int set_user_auth(int user_auth)
    {
	return ipmi_channel_access_set_user_auth(self, user_auth);
    }

%constant int CHANNEL_ACCESS_MODE_DISABLED = IPMI_CHANNEL_ACCESS_MODE_DISABLED;
%constant int CHANNEL_ACCESS_MODE_PRE_BOOT = IPMI_CHANNEL_ACCESS_MODE_PRE_BOOT;
%constant int CHANNEL_ACCESS_MODE_ALWAYS = IPMI_CHANNEL_ACCESS_MODE_ALWAYS;
%constant int CHANNEL_ACCESS_MODE_SHARED = IPMI_CHANNEL_ACCESS_MODE_SHARED;
    int get_access_mode(int *access_mode)
    {
	unsigned int val;
	int rv = ipmi_channel_access_get_access_mode(self, &val);
	*access_mode = val;
	return rv;
    }

    int set_access_mode(int access_mode)
    {
	return ipmi_channel_access_set_access_mode(self, access_mode);
    }

%constant int PRIVILEGE_CALLBACK = IPMI_PRIVILEGE_CALLBACK;
%constant int PRIVILEGE_USER = IPMI_PRIVILEGE_USER;
%constant int PRIVILEGE_OPERATOR = IPMI_PRIVILEGE_OPERATOR;
%constant int PRIVILEGE_ADMIN = IPMI_PRIVILEGE_ADMIN;
%constant int PRIVILEGE_OEM = IPMI_PRIVILEGE_OEM;
    int get_privilege_limit(int *priv_limit)
    {
	unsigned int val;
	int rv = ipmi_channel_access_get_priv_limit(self, &val);
	*priv_limit = val;
	return rv;
    }

    int set_privilege_limit(int priv_limit)
    {
	return ipmi_channel_access_set_priv_limit(self, priv_limit);
    }

    /* Normally setting will only set the values you have changed.  This
       forces all the values to be set. */
    int setall() {
	return ipmi_channel_access_setall(self);
    }
}

%extend ipmi_user_t {
    ~ipmi_user_t()
    {
	ipmi_user_free(self);
    }

    %newobject copy;
    ipmi_user_t *copy()
    {
	return ipmi_user_copy(self);
    }

    int get_channel(int *channel)
    {
	unsigned int val;
	int rv = ipmi_user_get_channel(self, &val);
	*channel = val;
	return rv;
    }

    int get_num(int *num)
    {
	unsigned int val;
	int rv = ipmi_user_get_num(self, &val);
	*num = val;
	return rv;
    }

    int set_num(int num)
    {
	return ipmi_user_set_num(self, num);
    }

    char *get_name()
    {
	unsigned int len;
	int rv;
	char *name;

	rv = ipmi_user_get_name_len(self, &len);
	if (rv)
	    return NULL;
	name = malloc(len+1);
	if (!name)
	    return NULL;
	rv = ipmi_user_get_name(self, name, &len);
	if (rv) {
	    free(name);
	    return NULL;
	}
	return name;
    }

    int set_name(char *name)
    {
	return ipmi_user_set_name(self, name, strlen(name));
    }

    int set_password(char *pw)
    {
	return ipmi_user_set_password(self, pw, strlen(pw));
    }

    int set_password2(char *pw)
    {
	return ipmi_user_set_password2(self, pw, strlen(pw));
    }

    /* Set the password, using either set_password or set_password2,
       depending on the length of the password. */
    int set_password_auto(char *pw)
    {
	if (strlen(pw) > 16)
	    return ipmi_user_set_password2(self, pw, strlen(pw));
	else
	    return ipmi_user_set_password(self, pw, strlen(pw));
    }

    int get_enable(int *enable)
    {
	unsigned int val;
	int rv = ipmi_user_get_enable(self, &val);
	*enable = val;
	return rv;
    }

    int set_enable(int val)
    {
	return ipmi_user_set_enable(self, val);
    }

    int get_link_auth_enabled(int *enable)
    {
	unsigned int val;
	int rv = ipmi_user_get_link_auth_enabled(self, &val);
	*enable = val;
	return rv;
    }

    int set_link_auth_enabled(int val)
    {
	return ipmi_user_set_link_auth_enabled(self, val);
    }

    int get_msg_auth_enabled(int *enable)
    {
	unsigned int val;
	int rv = ipmi_user_get_msg_auth_enabled(self, &val);
	*enable = val;
	return rv;
    }

    int set_msg_auth_enabled(int val)
    {
	return ipmi_user_set_msg_auth_enabled(self, val);
    }

    int get_access_cb_only(int *cb)
    {
	unsigned int val;
	int rv = ipmi_user_get_access_cb_only(self, &val);
	*cb = val;
	return rv;
    }

    int set_access_cb_only(int val)
    {
	return ipmi_user_set_access_cb_only(self, val);
    }

    int get_privilege_limit(int *limit)
    {
	unsigned int val;
	int rv = ipmi_user_get_privilege_limit(self, &val);
	*limit = val;
	return rv;
    }

    int set_privilege_limit(int val)
    {
	return ipmi_user_set_privilege_limit(self, val);
    }

    int get_session_limit(int *limit)
    {
	unsigned int val;
	int rv = ipmi_user_get_session_limit(self, &val);
	*limit = val;
	return rv;
    }

    int set_session_limit(int val)
    {
	return ipmi_user_set_session_limit(self, val);
    }

    int set_all()
    {
	return ipmi_user_set_all(self);
    }
}

/*
 * A sensor id object.  This object is guaranteed to be valid and
 * can be converted into a mc pointer later.
 */
%extend ipmi_sensor_id_t {
    ~ipmi_sensor_id_t()
    {
	free(self);
    }

    /* Compare self with other, return -1 if self<other, 0 if
       self==other, or 1 if self>other.  */
    int cmp(ipmi_sensor_id_t *other)
    {
	return ipmi_cmp_sensor_id(*self, *other);
    }

    /*
     * Convert a sensor id to a sensor pointer.  The "sensor_cb" method
     * will be called on the first parameter with the following parameters:
     * <self> <sensor>
     */
    int to_sensor(swig_cb *handler)
    {
	int rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, sensor_cb))
	    rv = EINVAL;
	else
	    rv = ipmi_sensor_pointer_cb(*self, handle_sensor_cb,
					get_swig_cb(handler, sensor_cb));
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

/*
 * An sensor object.  Sensor operations take several different types
 * of objects.  These are mostly strings that are a list of values.
 *
 * Event states are represented as a string with value separated by
 * spaces.  These value are settings and the events.  The strings
 * "events", "scanning", and "busy" are settings for the full sensor
 * event states.  For threshold sensor, the other values in the string
 * are 4 characters with: 1st character: u for upper or l for lower.
 * 2nd character: n for non-critical, c for critical, and r for
 * non-recoverable.  3rd character: h for going high and l for going
 * low.  4th character: a for assertion and d for deassertion.  For
 * discrete sensors, the other values are a 1 or 2-digit number
 * representing the offset and then a for assertion and d for
 * deassertion.
 *
 * A states structure is similar to event status, but does not have
 * the last two characters (direction and assertion) for thresholds
 * and last chararacter (assertion) for discrete values.
 */
%extend ipmi_sensor_t {
    %newobject get_name;
    /*
     * Get the name of an sensor.
     */
    char *get_name()
    {
	char name[IPMI_SENSOR_NAME_LEN];

	ipmi_sensor_get_name(self, name, sizeof(name));
	return strdup(name);
    }

    %newobject get_id;
    /*
     * Get the id for the sensor.
     */
    ipmi_sensor_id_t *get_id()
    {
	ipmi_sensor_id_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_sensor_convert_to_id(self);
	return rv;
    }

    /*
     * Register a handler to be called when an event comes from the
     * sensor.  If the sensor is a threshold sensor, the
     * threshold_event_cb method will be called on the sensor.
     * Otherwise, the sensor is discrete and the discrete_event_cb
     * will be called.  The threshold_event_cb method takes the
     * following parameters:
     * <self> <sensor> <event spec> <raw_set> <raw> <value_set> <value> <event>
     * The discrete_event_cb method takes the following parameters:
     * <self> <sensor> <event spec> <severity> <old_severity> <event>
     */
    int add_event_handler(swig_cb *handler)
    {
	if (ipmi_sensor_get_event_reading_type(self)
	    == IPMI_EVENT_READING_TYPE_THRESHOLD)
	{
	    ipmi_sensor_add_threshold_event_handler_cl
		(self, sensor_threshold_event_handler_cl, NULL);
	    cb_add(sensor, threshold_event, threshold_event_cb);
	} else {
	    ipmi_sensor_add_discrete_event_handler_cl
		(self, sensor_discrete_event_handler_cl, NULL);
	    cb_add(sensor, discrete_event, discrete_event_cb);
	}
    }

    /*
     * Remove the event handler from the sensor
     */
    int remove_event_handler(swig_cb *handler)
    {
	if (ipmi_sensor_get_event_reading_type(self)
	    == IPMI_EVENT_READING_TYPE_THRESHOLD)
	{
	    cb_rm(sensor, threshold_event, threshold_event_cb);
	} else {
	    cb_rm(sensor, discrete_event, discrete_event_cb);
	}
    }

    /* Set the event enables for the given sensor to exactly the event
     * states given in the first parameter.  This will first enable
     * the events/thresholds that are set, then disable the
     * events/thresholds that are not set.  When the operation is
     * done, the sensor_event_enable_cb method on the second parm (if
     * it is supplied) will be called with the following parameters:
     * <self> <sensor> <err>
     */
    int set_event_enables(char *states, swig_cb *handler = NULL)
    {
	int                 rv;
	swig_cb_val         *handler_val = NULL;
	ipmi_sensor_done_cb sensor_cb = NULL;
	ipmi_event_state_t  *st = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (ipmi_sensor_get_event_reading_type(self)
	    == IPMI_EVENT_READING_TYPE_THRESHOLD)
	{
	    rv = str_to_threshold_event_state(states, &st);
	} else {
	    rv = str_to_discrete_event_state(states, &st);
	}
	if (rv)
	    goto out_err;
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sensor_event_enable_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    sensor_cb = sensor_event_enable_handler;
	    handler_val = ref_swig_cb(handler, sensor_event_enable_cb);
	}
	rv = ipmi_sensor_set_event_enables(self, st, sensor_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	if (st)
	    free(st);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Enable the event states that are set in the first parameter.
     * This will *only* enable those states, it will not disable any
     * states.  It will, however, set the "events" flag and the
     * "scanning" flag for the sensor to the value in the states
     * parameter.  When the operation is done, the
     * sensor_event_enable_cb method on the second parm (if it is
     * supplied) will be called with the following parameters: <self>
     * <sensor> <err>
     */
    int enable_events(char *states, swig_cb *handler = NULL)
    {
	int                 rv;
	swig_cb_val         *handler_val = NULL;
	ipmi_sensor_done_cb sensor_cb = NULL;
	ipmi_event_state_t  *st = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (ipmi_sensor_get_event_reading_type(self)
	    == IPMI_EVENT_READING_TYPE_THRESHOLD)
	{
	    rv = str_to_threshold_event_state(states, &st);
	} else {
	    rv = str_to_discrete_event_state(states, &st);
	}
	if (rv)
	    goto out_err;
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sensor_event_enable_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    sensor_cb = sensor_event_enable_handler;
	    handler_val = ref_swig_cb(handler, sensor_event_enable_cb);
	}
	rv = ipmi_sensor_enable_events(self, st, sensor_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	if (st)
	    free(st);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Disable the event states that are set in the first parameter.
     * This will *only* disable those states, it will not enable any
     * states.  It will, however, set the "events" flag and the
     * "scanning" flag for the sensor to the value in the states
     * parameter.  When the operation is done, the
     * sensor_event_enable_cb method on the second parm (if it is
     * supplied) will be called with the following parameters: <self>
     * <sensor> <err>
     */
    int disable_events(char *states, swig_cb *handler = NULL)
    {
	int                 rv;
	swig_cb_val         *handler_val = NULL;
	ipmi_sensor_done_cb sensor_cb = NULL;
	ipmi_event_state_t  *st = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (ipmi_sensor_get_event_reading_type(self)
	    == IPMI_EVENT_READING_TYPE_THRESHOLD)
	{
	    rv = str_to_threshold_event_state(states, &st);
	} else {
	    rv = str_to_discrete_event_state(states, &st);
	}
	if (rv)
	    goto out_err;
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sensor_event_enable_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    sensor_cb = sensor_event_enable_handler;
	    handler_val = ref_swig_cb(handler, sensor_event_enable_cb);
	}
	rv = ipmi_sensor_disable_events(self, st, sensor_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	if (st)
	    free(st);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the event enables for the given sensor.  When done, the
     * sensor_get_event_enable_cb method on the first parameter will
     * be called with the following parameters: <self> <sensor> <err>
     * <event states>
     */
    int get_event_enables(swig_cb *handler)
    {
	int                          rv;
	swig_cb_val                  *handler_val = NULL;
	ipmi_sensor_event_enables_cb sensor_cb = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, sensor_get_event_enable_cb))
	    rv = EINVAL;
	else {
	    sensor_cb = sensor_get_event_enables_handler;
	    handler_val = ref_swig_cb(handler, sensor_get_event_enable_cb);
	    rv = ipmi_sensor_get_event_enables(self, sensor_cb, handler_val);
	    if (rv && handler_val)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Rearm the current sensor.  This will cause the sensor to resend
     * it's current event state if it is out of range.  If
     * get_supports_auto_rearm() returns false and you receive an
     * event, you have to rearm a sensor manually to get another event
     * from it.  If global_enable (parm 1) is set, all events are
     * enabled and the state is ignored (and may be NULL).  Otherwise,
     * the events set in the event state (parm 2) are enabled.  When
     * the operation is complete, the sensor_rearm_cb method of the
     * third parameter (if it is supplied) will be called with the
     * following parameters: <self> <sensor> <err>
     */
    int rearm(int     global_enable,
	      char    *states,
	      swig_cb *handler = NULL)
    {
	int                 rv;
	swig_cb_val         *handler_val = NULL;
	ipmi_sensor_done_cb sensor_cb = NULL;
	ipmi_event_state_t  *st = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!global_enable) {
	    if (!states) {
		rv = EINVAL;
		goto out_err;
	    }
	    if (ipmi_sensor_get_event_reading_type(self)
		== IPMI_EVENT_READING_TYPE_THRESHOLD)
	    {
		rv = str_to_threshold_event_state(states, &st);
	    } else {
		rv = str_to_discrete_event_state(states, &st);
	    }
	    if (rv)
		goto out_err;
	}
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sensor_rearm_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    sensor_cb = sensor_rearm_handler;
	    handler_val = ref_swig_cb(handler, sensor_rearm_cb);
	}
	rv = ipmi_sensor_rearm(self, global_enable, st,
			       sensor_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	if (st)
	    free(st);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the hysteresis values for the given sensor.  These are the
     * raw values, there doesn't seem to be an easy way to calculate
     * the cooked values.  The sensor_get_hysteresis_cb method on the
     * first parameter will be called with the values.  It's
     * parameters are: <self> <sensor> <err> <positive hysteresis>
     * <negative hysteresis>
     */
    int get_hysteresis(swig_cb *handler)
    {
	int                       rv;
	swig_cb_val               *handler_val = NULL;
	ipmi_sensor_hysteresis_cb sensor_cb = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, sensor_get_hysteresis_cb))
	    rv = EINVAL;
	else {
	    sensor_cb = sensor_get_hysteresis_handler;
	    handler_val = ref_swig_cb(handler, sensor_get_hysteresis_cb);
	    rv = ipmi_sensor_get_hysteresis(self, sensor_cb, handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set the hysteresis values for the given sensor.  These are the
     * raw values, there doesn't seem to be an easy way to calculate
     * the cooked values.  The positive hysteresis is the first
     * parameter, the negative hystersis is the second.  When the
     * operation completes, the sensor_set_hysteresis_cb will be
     * called on the third parameter (if it is supplied) with the
     * following parms: <self> <sensor> <err>
     */
    int set_hysteresis(unsigned int positive_hysteresis,
		       unsigned int negative_hysteresis,
		       swig_cb      *handler = NULL)
    {
	int                 rv;
	swig_cb_val         *handler_val = NULL;
	ipmi_sensor_done_cb sensor_cb = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sensor_set_hysteresis_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    sensor_cb = sensor_set_hysteresis_handler;
	    handler_val = ref_swig_cb(handler, sensor_set_hysteresis_cb);
	}
	rv = ipmi_sensor_set_hysteresis(self, positive_hysteresis,
					negative_hysteresis,
					sensor_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    %newobject get_default_thresholds;
    /*
     * Return the default threshold settings for a sensor.
     */
    char *get_default_thresholds()
    {
	ipmi_thresholds_t *th = malloc(ipmi_thresholds_size());
	char              *str = NULL;
	int               rv;

	rv = ipmi_get_default_sensor_thresholds(self, th);
	if (!rv) {
	    str = thresholds_to_str(th);
	}
	free(th);
	return str;
    }

    /*
     * Set the thresholds for the given sensor to the threshold values
     * specified in the first parameter.  When the thresholds are set,
     * the sensor_set_thresholds_cb method on the second parm (if it
     * is supplied) will be called with the following parameters:
     * <self> <sensor> <err>
     */
    int set_thresholds(char    *thresholds,
		       swig_cb *handler = NULL)
    {
	ipmi_thresholds_t   *th = NULL;
	int                 rv;
	swig_cb_val         *handler_val = NULL;
	ipmi_sensor_done_cb sensor_cb = NULL;

	IPMI_SWIG_C_CB_ENTRY
	rv = str_to_thresholds(thresholds, self, &th);
	if (rv)
	    goto out_err;

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sensor_set_thresholds_cb)) {
		rv = EINVAL;
		goto out_err_free;
	    }
	    sensor_cb = sensor_set_thresholds_handler;
	    handler_val = ref_swig_cb(handler, sensor_set_thresholds_cb);
	}
	rv = ipmi_sensor_set_thresholds(self, th, sensor_cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err_free:
	free(th);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Fetch the thresholds for the given sensor.  When the thresholds
     * are received, the sensor_get_thresholds_cb method on the second
     * parm will be called with the following parameters: <self>
     * <sensor> <err> <thresholds>
     */
    int get_thresholds(swig_cb *handler)
    {
	int                       rv;
	swig_cb_val               *handler_val = NULL;
	ipmi_sensor_thresholds_cb sensor_cb = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, sensor_get_thresholds_cb))
	    rv = EINVAL;
	else {
	    sensor_cb = sensor_get_thresholds_handler;
	    handler_val = ref_swig_cb(handler, sensor_get_thresholds_cb);
	    rv = ipmi_sensor_get_thresholds(self, sensor_cb, handler_val);
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /* Read the current value of the given sensor.  If this is a
       discrete sensor, the discrete_states_cb method of the first
       parameter will be called with the following parameters: <self>
       <sensor> <err> <states>.  If this is a threshold sensor, the
       threshold_reading_cb method of the first parameter will be
       called with the following parameters: <self> <sensor> <err>
       <raw_set> <raw> <value_set> <value> <states>. */
    int get_value(swig_cb *handler)
    {
	int                    rv;
	swig_cb_val            *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, threshold_reading_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, threshold_reading_cb);
	    if (ipmi_sensor_get_event_reading_type(self)
		== IPMI_EVENT_READING_TYPE_THRESHOLD)
	    {
		ipmi_sensor_reading_cb sensor_cb;

		sensor_cb = sensor_get_reading_handler;
		rv = ipmi_sensor_get_reading(self, sensor_cb, handler_val);
	    } else {
		ipmi_sensor_states_cb sensor_cb;
		    
		sensor_cb = sensor_get_states_handler;
		rv = ipmi_sensor_get_states(self, sensor_cb, handler_val);
	    }
	    if (rv)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /* 
     * Return the LUN for the sensor (with respect to the MC).
     */
    int get_lun()
    {
	int lun = 0;
	ipmi_sensor_get_num(self, &lun, NULL);
	return lun;
    }

    /* 
     * Return the number for the sensor (The number in the MC/LUN).
     */
    int get_num()
    {
	int num = 0;
	ipmi_sensor_get_num(self, NULL, &num);
	return num;
    }

    /*
     * The sensor type.  This return sa string representing the sensor
     * type.
     */
    const char *get_sensor_type_string()
    {
	return ipmi_sensor_get_sensor_type_string(self);
    }

%constant int SENSOR_TYPE_TEMPERATURE = IPMI_SENSOR_TYPE_TEMPERATURE;
%constant int SENSOR_TYPE_VOLTAGE = IPMI_SENSOR_TYPE_VOLTAGE;
%constant int SENSOR_TYPE_CURRENT = IPMI_SENSOR_TYPE_CURRENT;
%constant int SENSOR_TYPE_FAN = IPMI_SENSOR_TYPE_FAN;
%constant int SENSOR_TYPE_PHYSICAL_SECURITY = IPMI_SENSOR_TYPE_PHYSICAL_SECURITY;
%constant int SENSOR_TYPE_PLATFORM_SECURITY = IPMI_SENSOR_TYPE_PLATFORM_SECURITY;
%constant int SENSOR_TYPE_PROCESSOR = IPMI_SENSOR_TYPE_PROCESSOR;
%constant int SENSOR_TYPE_POWER_SUPPLY = IPMI_SENSOR_TYPE_POWER_SUPPLY;
%constant int SENSOR_TYPE_POWER_UNIT = IPMI_SENSOR_TYPE_POWER_UNIT;
%constant int SENSOR_TYPE_COOLING_DEVICE = IPMI_SENSOR_TYPE_COOLING_DEVICE;
%constant int SENSOR_TYPE_OTHER_UNITS_BASED_SENSOR = IPMI_SENSOR_TYPE_OTHER_UNITS_BASED_SENSOR;
%constant int SENSOR_TYPE_MEMORY = IPMI_SENSOR_TYPE_MEMORY;
%constant int SENSOR_TYPE_DRIVE_SLOT = IPMI_SENSOR_TYPE_DRIVE_SLOT;
%constant int SENSOR_TYPE_POWER_MEMORY_RESIZE = IPMI_SENSOR_TYPE_POWER_MEMORY_RESIZE;
%constant int SENSOR_TYPE_SYSTEM_FIRMWARE_PROGRESS = IPMI_SENSOR_TYPE_SYSTEM_FIRMWARE_PROGRESS;
%constant int SENSOR_TYPE_EVENT_LOGGING_DISABLED = IPMI_SENSOR_TYPE_EVENT_LOGGING_DISABLED;
%constant int SENSOR_TYPE_WATCHDOG_1 = IPMI_SENSOR_TYPE_WATCHDOG_1;
%constant int SENSOR_TYPE_SYSTEM_EVENT = IPMI_SENSOR_TYPE_SYSTEM_EVENT;
%constant int SENSOR_TYPE_CRITICAL_INTERRUPT = IPMI_SENSOR_TYPE_CRITICAL_INTERRUPT;
%constant int SENSOR_TYPE_BUTTON = IPMI_SENSOR_TYPE_BUTTON;
%constant int SENSOR_TYPE_MODULE_BOARD = IPMI_SENSOR_TYPE_MODULE_BOARD;
%constant int SENSOR_TYPE_MICROCONTROLLER_COPROCESSOR = IPMI_SENSOR_TYPE_MICROCONTROLLER_COPROCESSOR;
%constant int SENSOR_TYPE_ADD_IN_CARD = IPMI_SENSOR_TYPE_ADD_IN_CARD;
%constant int SENSOR_TYPE_CHASSIS = IPMI_SENSOR_TYPE_CHASSIS;
%constant int SENSOR_TYPE_CHIP_SET = IPMI_SENSOR_TYPE_CHIP_SET;
%constant int SENSOR_TYPE_OTHER_FRU = IPMI_SENSOR_TYPE_OTHER_FRU;
%constant int SENSOR_TYPE_CABLE_INTERCONNECT = IPMI_SENSOR_TYPE_CABLE_INTERCONNECT;
%constant int SENSOR_TYPE_TERMINATOR = IPMI_SENSOR_TYPE_TERMINATOR;
%constant int SENSOR_TYPE_SYSTEM_BOOT_INITIATED = IPMI_SENSOR_TYPE_SYSTEM_BOOT_INITIATED;
%constant int SENSOR_TYPE_BOOT_ERROR = IPMI_SENSOR_TYPE_BOOT_ERROR;
%constant int SENSOR_TYPE_OS_BOOT = IPMI_SENSOR_TYPE_OS_BOOT;
%constant int SENSOR_TYPE_OS_CRITICAL_STOP = IPMI_SENSOR_TYPE_OS_CRITICAL_STOP;
%constant int SENSOR_TYPE_SLOT_CONNECTOR = IPMI_SENSOR_TYPE_SLOT_CONNECTOR;
%constant int SENSOR_TYPE_SYSTEM_ACPI_POWER_STATE = IPMI_SENSOR_TYPE_SYSTEM_ACPI_POWER_STATE;
%constant int SENSOR_TYPE_WATCHDOG_2 = IPMI_SENSOR_TYPE_WATCHDOG_2;
%constant int SENSOR_TYPE_PLATFORM_ALERT = IPMI_SENSOR_TYPE_PLATFORM_ALERT;
%constant int SENSOR_TYPE_ENTITY_PRESENCE = IPMI_SENSOR_TYPE_ENTITY_PRESENCE;
%constant int SENSOR_TYPE_MONITOR_ASIC_IC = IPMI_SENSOR_TYPE_MONITOR_ASIC_IC;
%constant int SENSOR_TYPE_LAN = IPMI_SENSOR_TYPE_LAN;
%constant int SENSOR_TYPE_MANAGEMENT_SUBSYSTEM_HEALTH = IPMI_SENSOR_TYPE_MANAGEMENT_SUBSYSTEM_HEALTH;
%constant int SENSOR_TYPE_BATTERY = IPMI_SENSOR_TYPE_BATTERY;
    /*
     * Return the numeric sensor type.
     */
    int get_sensor_type()
    {
	return ipmi_sensor_get_sensor_type(self);
    }

    /*
     * Return the event reading type string.  If this returns
     * "threshold", then this is a threshold sensor.  Otherwise it is
     * a discrete sensor.
     */
    const char *get_event_reading_type_string()
    {
	return ipmi_sensor_get_event_reading_type_string(self);
    }

%constant int EVENT_READING_TYPE_THRESHOLD = IPMI_EVENT_READING_TYPE_THRESHOLD;
%constant int EVENT_READING_TYPE_DISCRETE_USAGE = IPMI_EVENT_READING_TYPE_DISCRETE_USAGE;
%constant int EVENT_READING_TYPE_DISCRETE_STATE = IPMI_EVENT_READING_TYPE_DISCRETE_STATE;
%constant int EVENT_READING_TYPE_DISCRETE_PREDICTIVE_FAILURE = IPMI_EVENT_READING_TYPE_DISCRETE_PREDICTIVE_FAILURE;
%constant int EVENT_READING_TYPE_DISCRETE_LIMIT_EXCEEDED = IPMI_EVENT_READING_TYPE_DISCRETE_LIMIT_EXCEEDED;
%constant int EVENT_READING_TYPE_DISCRETE_PERFORMANCE_MET = IPMI_EVENT_READING_TYPE_DISCRETE_PERFORMANCE_MET;
%constant int EVENT_READING_TYPE_DISCRETE_SEVERITY = IPMI_EVENT_READING_TYPE_DISCRETE_SEVERITY;
%constant int EVENT_READING_TYPE_DISCRETE_DEVICE_PRESENCE = IPMI_EVENT_READING_TYPE_DISCRETE_DEVICE_PRESENCE;
%constant int EVENT_READING_TYPE_DISCRETE_DEVICE_ENABLE = IPMI_EVENT_READING_TYPE_DISCRETE_DEVICE_ENABLE;
%constant int EVENT_READING_TYPE_DISCRETE_AVAILABILITY = IPMI_EVENT_READING_TYPE_DISCRETE_AVAILABILITY;
%constant int EVENT_READING_TYPE_DISCRETE_REDUNDANCY = IPMI_EVENT_READING_TYPE_DISCRETE_REDUNDANCY;
%constant int EVENT_READING_TYPE_DISCRETE_ACPI_POWER = IPMI_EVENT_READING_TYPE_DISCRETE_ACPI_POWER;
%constant int EVENT_READING_TYPE_SENSOR_SPECIFIC = IPMI_EVENT_READING_TYPE_SENSOR_SPECIFIC;
    /*
     * Return the numeric event reading type.  This will return
     * EVENT_READING_TYPE_THRESHOLD for threshold sensors; everthing
     * else is a discrete sensor.
     */
    int get_event_reading_type()
    {
	return ipmi_sensor_get_event_reading_type(self);
    }

    /*
     * Get the string for the sensor's rate unit.  This will be blank
     * if there is not a rate unit for this sensor.
     */
    const char *get_rate_unit_string()
    {
	return ipmi_sensor_get_rate_unit_string(self);
    }

%constant int RATE_UNIT_NONE = IPMI_RATE_UNIT_NONE;
%constant int RATE_UNIT_PER_US = IPMI_RATE_UNIT_PER_US;
%constant int RATE_UNIT_PER_MS = IPMI_RATE_UNIT_PER_MS;
%constant int RATE_UNIT_PER_SEC = IPMI_RATE_UNIT_PER_SEC;
%constant int RATE_UNIT_MIN = IPMI_RATE_UNIT_MIN;
%constant int RATE_UNIT_HOUR = IPMI_RATE_UNIT_HOUR;
%constant int RATE_UNIT_DAY = IPMI_RATE_UNIT_DAY;

    /*
     * Get the rate unit for this sensor.
     */
    int get_rate_unit()
    {
	return ipmi_sensor_get_rate_unit(self);
    }

    /*
     * Get the string for the sensor's base unit.
     */
    const char *get_base_unit_string()
    {
	return ipmi_sensor_get_base_unit_string(self);
    }

%constant int UNIT_TYPE_UNSPECIFIED = IPMI_UNIT_TYPE_UNSPECIFIED;
%constant int UNIT_TYPE_DEGREES_C = IPMI_UNIT_TYPE_DEGREES_C;
%constant int UNIT_TYPE_DEGREES_F = IPMI_UNIT_TYPE_DEGREES_F;
%constant int UNIT_TYPE_DEGREES_K = IPMI_UNIT_TYPE_DEGREES_K;
%constant int UNIT_TYPE_VOLTS = IPMI_UNIT_TYPE_VOLTS;
%constant int UNIT_TYPE_AMPS = IPMI_UNIT_TYPE_AMPS;
%constant int UNIT_TYPE_WATTS = IPMI_UNIT_TYPE_WATTS;
%constant int UNIT_TYPE_JOULES = IPMI_UNIT_TYPE_JOULES;
%constant int UNIT_TYPE_COULOMBS = IPMI_UNIT_TYPE_COULOMBS;
%constant int UNIT_TYPE_VA = IPMI_UNIT_TYPE_VA;
%constant int UNIT_TYPE_NITS = IPMI_UNIT_TYPE_NITS;
%constant int UNIT_TYPE_LUMENS = IPMI_UNIT_TYPE_LUMENS;
%constant int UNIT_TYPE_LUX = IPMI_UNIT_TYPE_LUX;
%constant int UNIT_TYPE_CANDELA = IPMI_UNIT_TYPE_CANDELA;
%constant int UNIT_TYPE_KPA = IPMI_UNIT_TYPE_KPA;
%constant int UNIT_TYPE_PSI = IPMI_UNIT_TYPE_PSI;
%constant int UNIT_TYPE_NEWTONS = IPMI_UNIT_TYPE_NEWTONS;
%constant int UNIT_TYPE_CFM = IPMI_UNIT_TYPE_CFM;
%constant int UNIT_TYPE_RPM = IPMI_UNIT_TYPE_RPM;
%constant int UNIT_TYPE_HZ = IPMI_UNIT_TYPE_HZ;
%constant int UNIT_TYPE_USECONDS = IPMI_UNIT_TYPE_USECONDS;
%constant int UNIT_TYPE_MSECONDS = IPMI_UNIT_TYPE_MSECONDS;
%constant int UNIT_TYPE_SECONDS = IPMI_UNIT_TYPE_SECONDS;
%constant int UNIT_TYPE_MINUTE = IPMI_UNIT_TYPE_MINUTE;
%constant int UNIT_TYPE_HOUR = IPMI_UNIT_TYPE_HOUR;
%constant int UNIT_TYPE_DAY = IPMI_UNIT_TYPE_DAY;
%constant int UNIT_TYPE_WEEK = IPMI_UNIT_TYPE_WEEK;
%constant int UNIT_TYPE_MIL = IPMI_UNIT_TYPE_MIL;
%constant int UNIT_TYPE_INCHES = IPMI_UNIT_TYPE_INCHES;
%constant int UNIT_TYPE_FEET = IPMI_UNIT_TYPE_FEET;
%constant int UNIT_TYPE_CUBIC_INCHS = IPMI_UNIT_TYPE_CUBIC_INCHS;
%constant int UNIT_TYPE_CUBIC_FEET = IPMI_UNIT_TYPE_CUBIC_FEET;
%constant int UNIT_TYPE_MILLIMETERS = IPMI_UNIT_TYPE_MILLIMETERS;
%constant int UNIT_TYPE_CENTIMETERS = IPMI_UNIT_TYPE_CENTIMETERS;
%constant int UNIT_TYPE_METERS = IPMI_UNIT_TYPE_METERS;
%constant int UNIT_TYPE_CUBIC_CENTIMETERS = IPMI_UNIT_TYPE_CUBIC_CENTIMETERS;
%constant int UNIT_TYPE_CUBIC_METERS = IPMI_UNIT_TYPE_CUBIC_METERS;
%constant int UNIT_TYPE_LITERS = IPMI_UNIT_TYPE_LITERS;
%constant int UNIT_TYPE_FL_OZ = IPMI_UNIT_TYPE_FL_OZ;
%constant int UNIT_TYPE_RADIANS = IPMI_UNIT_TYPE_RADIANS;
%constant int UNIT_TYPE_SERADIANS = IPMI_UNIT_TYPE_SERADIANS;
%constant int UNIT_TYPE_REVOLUTIONS = IPMI_UNIT_TYPE_REVOLUTIONS;
%constant int UNIT_TYPE_CYCLES = IPMI_UNIT_TYPE_CYCLES;
%constant int UNIT_TYPE_GRAVITIES = IPMI_UNIT_TYPE_GRAVITIES;
%constant int UNIT_TYPE_OUNCES = IPMI_UNIT_TYPE_OUNCES;
%constant int UNIT_TYPE_POUNDS = IPMI_UNIT_TYPE_POUNDS;
%constant int UNIT_TYPE_FOOT_POUNDS = IPMI_UNIT_TYPE_FOOT_POUNDS;
%constant int UNIT_TYPE_OUNCE_INCHES = IPMI_UNIT_TYPE_OUNCE_INCHES;
%constant int UNIT_TYPE_GAUSS = IPMI_UNIT_TYPE_GAUSS;
%constant int UNIT_TYPE_GILBERTS = IPMI_UNIT_TYPE_GILBERTS;
%constant int UNIT_TYPE_HENRIES = IPMI_UNIT_TYPE_HENRIES;
%constant int UNIT_TYPE_MHENRIES = IPMI_UNIT_TYPE_MHENRIES;
%constant int UNIT_TYPE_FARADS = IPMI_UNIT_TYPE_FARADS;
%constant int UNIT_TYPE_UFARADS = IPMI_UNIT_TYPE_UFARADS;
%constant int UNIT_TYPE_OHMS = IPMI_UNIT_TYPE_OHMS;
%constant int UNIT_TYPE_SIEMENS = IPMI_UNIT_TYPE_SIEMENS;
%constant int UNIT_TYPE_MOLES = IPMI_UNIT_TYPE_MOLES;
%constant int UNIT_TYPE_BECQUERELS = IPMI_UNIT_TYPE_BECQUERELS;
%constant int UNIT_TYPE_PPM = IPMI_UNIT_TYPE_PPM;
%constant int UNIT_TYPE_reserved1 = IPMI_UNIT_TYPE_reserved1;
%constant int UNIT_TYPE_DECIBELS = IPMI_UNIT_TYPE_DECIBELS;
%constant int UNIT_TYPE_DbA = IPMI_UNIT_TYPE_DbA;
%constant int UNIT_TYPE_DbC = IPMI_UNIT_TYPE_DbC;
%constant int UNIT_TYPE_GRAYS = IPMI_UNIT_TYPE_GRAYS;
%constant int UNIT_TYPE_SIEVERTS = IPMI_UNIT_TYPE_SIEVERTS;
%constant int UNIT_TYPE_COLOR_TEMP_DEG_K = IPMI_UNIT_TYPE_COLOR_TEMP_DEG_K;
%constant int UNIT_TYPE_BITS = IPMI_UNIT_TYPE_BITS;
%constant int UNIT_TYPE_KBITS = IPMI_UNIT_TYPE_KBITS;
%constant int UNIT_TYPE_MBITS = IPMI_UNIT_TYPE_MBITS;
%constant int UNIT_TYPE_GBITS = IPMI_UNIT_TYPE_GBITS;
%constant int UNIT_TYPE_BYTES = IPMI_UNIT_TYPE_BYTES;
%constant int UNIT_TYPE_KBYTES = IPMI_UNIT_TYPE_KBYTES;
%constant int UNIT_TYPE_MBYTES = IPMI_UNIT_TYPE_MBYTES;
%constant int UNIT_TYPE_GBYTES = IPMI_UNIT_TYPE_GBYTES;
%constant int UNIT_TYPE_WORDS = IPMI_UNIT_TYPE_WORDS;
%constant int UNIT_TYPE_DWORDS = IPMI_UNIT_TYPE_DWORDS;
%constant int UNIT_TYPE_QWORDS = IPMI_UNIT_TYPE_QWORDS;
%constant int UNIT_TYPE_LINES = IPMI_UNIT_TYPE_LINES;
%constant int UNIT_TYPE_HITS = IPMI_UNIT_TYPE_HITS;
%constant int UNIT_TYPE_MISSES = IPMI_UNIT_TYPE_MISSES;
%constant int UNIT_TYPE_RETRIES = IPMI_UNIT_TYPE_RETRIES;
%constant int UNIT_TYPE_RESETS = IPMI_UNIT_TYPE_RESETS;
%constant int UNIT_TYPE_OVERRUNS = IPMI_UNIT_TYPE_OVERRUNS;
%constant int UNIT_TYPE_UNDERRUNS = IPMI_UNIT_TYPE_UNDERRUNS;
%constant int UNIT_TYPE_COLLISIONS = IPMI_UNIT_TYPE_COLLISIONS;
%constant int UNIT_TYPE_PACKETS = IPMI_UNIT_TYPE_PACKETS;
%constant int UNIT_TYPE_MESSAGES = IPMI_UNIT_TYPE_MESSAGES;
%constant int UNIT_TYPE_CHARACTERS = IPMI_UNIT_TYPE_CHARACTERS;
%constant int UNIT_TYPE_ERRORS = IPMI_UNIT_TYPE_ERRORS;
%constant int UNIT_TYPE_CORRECTABLE_ERRORS = IPMI_UNIT_TYPE_CORRECTABLE_ERRORS;
%constant int UNIT_TYPE_UNCORRECTABLE_ERRORS = IPMI_UNIT_TYPE_UNCORRECTABLE_ERRORS;
%constant int UNIT_TYPE_FATAL_ERRORS = IPMI_UNIT_TYPE_FATAL_ERRORS;
%constant int UNIT_TYPE_GRAMS = IPMI_UNIT_TYPE_GRAMS;

    /*
     * Get the sensor's base unit.
     */
    int get_base_unit()
    {
	return ipmi_sensor_get_base_unit(self);
    }

    /*
     * Get the modifier unit string for the sensor, this will be an empty
     * string if there is none.
     */
    const char *get_modifier_unit_string()
    {
	return ipmi_sensor_get_modifier_unit_string(self);
    }

    /*
     * Get the sensor's modifier unit.
     */
    int get_modifier_unit()
    {
	return ipmi_sensor_get_modifier_unit(self);
    }

%constant int MODIFIER_UNIT_NONE = IPMI_MODIFIER_UNIT_NONE;
%constant int MODIFIER_UNIT_BASE_DIV_MOD = IPMI_MODIFIER_UNIT_BASE_DIV_MOD;
%constant int MODIFIER_UNIT_BASE_MULT_MOD = IPMI_MODIFIER_UNIT_BASE_MULT_MOD;

    /*
     * Return the how the modifier unit should be used.  If this
     * returns MODIFIER_UNIT_NONE, then the modifier unit is not
     * used.  If it returns MODIFIER_UNIT_BASE_DIV_MOD, the modifier
     * unit is dividied by the base unit (eg per hour, per second,
     * etc.).  If it returns MODIFIER_UNIT_BASE_MULT_MOD, the modifier
     * unit is multiplied by the base unit.
     */
    int get_modifier_unit_use()
    {
	return ipmi_sensor_get_modifier_unit_use(self);
    }

    /*
     * Returns if the value is a percentage.
     */
    int get_percentage()
    {
	return ipmi_sensor_get_percentage(self);
    }


    /*
     * This call is a little different from the other string calls.
     * For a discrete sensor, you can pass the offset into this call
     * and it will return the string associated with the reading.
     * This way, OEM sensors can supply their own strings as necessary
     * for the various offsets.  This is only for discrete sensors.
     */
    const char *reading_name_string(int offset)
    {
	return ipmi_sensor_reading_name_string(self, offset);
    }

    /*
     * Get the entity id of the entity the sensor is hooked to.
     */
    int get_entity_id()
    {
	return ipmi_sensor_get_entity_id(self);
    }

    /*
     * Get the entity instance of the entity the sensor is hooked to.
     */
    int get_entity_instance()
    {
	return ipmi_sensor_get_entity_instance(self);
    }

    /*
     * Get the entity the sensor is hooked to.
     */
    ipmi_entity_t *get_entity()
    {
	return ipmi_sensor_get_entity(self);
    }


    /*
     * Initialization information about a sensor from it's SDR.
     */
    int get_sensor_init_scanning()
    {
	return ipmi_sensor_get_sensor_init_scanning(self);
    }

    /*
     * Initialization information about a sensor from it's SDR.
     */
    int get_sensor_init_events()
    {
	return ipmi_sensor_get_sensor_init_events(self);
    }

    /*
     * Initialization information about a sensor from it's SDR.
     */
    int get_sensor_init_thresholds()
    {
	return ipmi_sensor_get_sensor_init_thresholds(self);
    }

    /*
     * Initialization information about a sensor from it's SDR.
     */
    int get_sensor_init_hysteresis()
    {
	return ipmi_sensor_get_sensor_init_hysteresis(self);
    }

    /*
     * Initialization information about a sensor from it's SDR.
     */
    int get_sensor_init_type()
    {
	return ipmi_sensor_get_sensor_init_type(self);
    }

    /*
     * Initialization information about a sensor from it's SDR.
     */
    int get_sensor_init_pu_events()
    {
	return ipmi_sensor_get_sensor_init_pu_events(self);
    }

    /*
     * Initialization information about a sensor from it's SDR.
     */
    int get_sensor_init_pu_scanning()
    {
	return ipmi_sensor_get_sensor_init_pu_scanning(self);
    }

    /*
     * Ignore the sensor if the entity it is attached to is not
     * present.
     */
    int get_ignore_if_no_entity()
    {
	return ipmi_sensor_get_ignore_if_no_entity(self);
    }

    /*
     * If this is false, the user must manually re-arm the sensor to get
     * any more events from it.
     */
    int get_supports_auto_rearm()
    {
	return ipmi_sensor_get_supports_auto_rearm(self);
    }


%constant int THRESHOLD_ACCESS_SUPPORT_NONE = IPMI_THRESHOLD_ACCESS_SUPPORT_NONE;
%constant int THRESHOLD_ACCESS_SUPPORT_READABLE = IPMI_THRESHOLD_ACCESS_SUPPORT_READABLE;
%constant int THRESHOLD_ACCESS_SUPPORT_SETTABLE = IPMI_THRESHOLD_ACCESS_SUPPORT_SETTABLE;
%constant int THRESHOLD_ACCESS_SUPPORT_FIXED = IPMI_THRESHOLD_ACCESS_SUPPORT_FIXED;

    /*
     * Get how the thresholds of the sensor may be accessed.
     */
    int get_threshold_access()
    {
	return ipmi_sensor_get_threshold_access(self);
    }

%constant int HYSTERESIS_SUPPORT_NONE = IPMI_HYSTERESIS_SUPPORT_NONE;
%constant int HYSTERESIS_SUPPORT_READABLE = IPMI_HYSTERESIS_SUPPORT_READABLE;
%constant int HYSTERESIS_SUPPORT_SETTABLE = IPMI_HYSTERESIS_SUPPORT_SETTABLE;
%constant int HYSTERESIS_SUPPORT_FIXED = IPMI_HYSTERESIS_SUPPORT_FIXED;

    /*
     * Get how the hysteresis of the sensor may be accessed.
     */
    int get_hysteresis_support()
    {
	return ipmi_sensor_get_hysteresis_support(self);
    }

%constant int EVENT_SUPPORT_PER_STATE = IPMI_EVENT_SUPPORT_PER_STATE;
%constant int EVENT_SUPPORT_ENTIRE_SENSOR = IPMI_EVENT_SUPPORT_ENTIRE_SENSOR;
%constant int EVENT_SUPPORT_GLOBAL_ENABLE = IPMI_EVENT_SUPPORT_GLOBAL_ENABLE;
%constant int EVENT_SUPPORT_GLOBAL_DISABLE = IPMI_EVENT_SUPPORT_GLOBAL_DISABLE;
%constant int EVENT_SUPPORT_NONE = IPMI_EVENT_SUPPORT_NONE;

    /*
     * Get how the events in the sensor may be enabled and disabled.
     */
    int get_event_support()
    {
	return ipmi_sensor_get_event_support(self);
    }

%constant int SENSOR_DIRECTION_UNSPECIFIED = IPMI_SENSOR_DIRECTION_UNSPECIFIED;
%constant int SENSOR_DIRECTION_INPUT = IPMI_SENSOR_DIRECTION_INPUT;
%constant int SENSOR_DIRECTION_OUTPUT = IPMI_SENSOR_DIRECTION_OUTPUT;

    /*
     * Get whether the sensor is monitoring an input or an output.
     * For instance, the +5V sensor on the output of a power supply
     * would be the output, the +5V sensor measuring the voltage
     * coming into a card would be an input.
     */
    int get_sensor_direction()
    {
	return ipmi_sensor_get_sensor_direction(self);
    }

    /*
     * Get whether the sensor's value can be read or not (with
     * get_value()).  Sensors with system software owners and
     * event-only sensors cannot be read.
     */
    int is_readable()
    {
	return ipmi_sensor_get_is_readable(self);
    }

    /*
     * Sets the second parameter to if an event is supported for this
     * particular threshold event on the sensor. The first parameter
     * is the event specifier string.  This will return 0 on success
     * or EINVAL on an invalid event.
     */
    int threshold_event_supported(char *event, int *val)
    {
	enum ipmi_thresh_e          thresh;
	enum ipmi_event_value_dir_e value_dir;
	enum ipmi_event_dir_e       dir;
	char                        *s;

	s = threshold_event_from_str(event, strlen(event), &thresh,
				     &value_dir, &dir);
	if (!s)
	    return EINVAL;
	return ipmi_sensor_threshold_event_supported(self,
						     thresh,
						     value_dir,
						     dir,
						     val);
    }

    /*
     * Sets the second parameter to if a specific threshold can be
     * set.  The first parameter is the threshold.  Returns EINVAL
     * if the threshold is invalid, otherwise returns zero.
     */
    int threshold_settable(char *threshold, int *val)
    {
	enum ipmi_thresh_e thresh;
	char               *s;

	s = threshold_from_str(threshold, strlen(threshold), &thresh);
	if (!s)
	    return EINVAL;
	return ipmi_sensor_threshold_settable(self, thresh, val);
    }

    /*
     * Sets the second parameter to if a specific threshold can be
     * read.  The first parameter is the threshold.  Returns EINVAL
     * if the threshold is invalid, otherwise returns zero.
     */
    int threshold_readable(char *threshold, int *val)
    {
	enum ipmi_thresh_e thresh;
	char               *s;

	s = threshold_from_str(threshold, strlen(threshold), &thresh);
	if (!s)
	    return EINVAL;
	return ipmi_sensor_threshold_readable(self, thresh, val);
    }

    /*
     * Sets the second parameter to if a specific threshold has its
     * reading returned when reading the value of the sensor.  The
     * first parameter is the threshold.  Returns EINVAL if the
     * threshold is invalid, otherwise returns zero.
     */
    int threshold_reading_supported(char *threshold, int *val)
    {
	enum ipmi_thresh_e thresh;
	char               *s;

	s = threshold_from_str(threshold, strlen(threshold), &thresh);
	if (!s)
	    return EINVAL;
	return ipmi_sensor_threshold_reading_supported(self, thresh, val);
    }

    /*
     * Sets the second parameter to if an offset will generate an
     * event for the given event specifier for this particular
     * sensor. The first parameter is the event specifier string.
     * This will return 0 on success or EINVAL on an invalid event.
     */
    int discrete_event_supported(char *event, int *val)
    {
	int                   offset;
	enum ipmi_event_dir_e dir;
	char                  *s;

	s = discrete_event_from_str(event, strlen(event), &offset, &dir);
	if (!s)
	    return EINVAL;
	return ipmi_sensor_discrete_event_supported(self, offset, dir, val);
    }

    /*
     * Sets the second parameter to if a specific offset is set by the
     * sensor.  The first parameter is the offset.  Returns EINVAL if
     * the threshold is invalid, otherwise returns zero.
     */
    int discrete_event_readable(int offset, int *val)
    {
	return ipmi_sensor_discrete_event_readable(self, offset, val);
    }

    /*
     * Returns the tolerance for the sensor at the given raw value
     * (first parameter).  The tolerance is returned as a double in
     * the second parameter.  Returns an error value.
     */
    int get_tolerance(int val, double *tolerance)
    {
	return ipmi_sensor_get_tolerance(self, val, tolerance);
    }

    /*
     * Returns the accuracy for the sensor at the given raw value
     * (first parameter).  The accuracy is returned as a double in the
     * second parameter.  Returns an error value.
     */
    int get_accuracy(int val, double *accuracy)
    {
	return ipmi_sensor_get_accuracy(self, val, accuracy);
    }

    /*
     * Is the normal minimum for the sensor specified?
     */
    int get_normal_min_specified()
    {
	return ipmi_sensor_get_normal_min_specified(self);
    }

    /*
     * Get the normal minimum for the sensor into the first parameter.
     * Returns an error value.
     */
    int get_normal_min(double *normal_min)
    {
	return ipmi_sensor_get_normal_min(self, normal_min);
    }

    /*
     * Is the normal maximum for the sensor specified?
     */
    int get_normal_max_specified()
    {
	return ipmi_sensor_get_normal_max_specified(self);
    }

    /*
     * Get the normal maximum for the sensor into the first parameter.
     * Returns an error value.
     */
    int get_normal_max(double *normal_max)
    {
	return ipmi_sensor_get_normal_max(self, normal_max);
    }

    /*
     * Returns if the nominal reading for the sensor is specified.
     */
    int get_nominal_reading_specified()
    {
	return ipmi_sensor_get_nominal_reading_specified(self);
    }

    /*
     * Get the nominal value for the sensor into the first parameter.
     * Returns an error value.
     */
    int get_nominal_reading(double *nominal_reading)
    {
	return ipmi_sensor_get_nominal_reading(self, nominal_reading);
    }

    /*
     * Get the sensor maximum for the sensor into the first parameter.
     * Returns an error value.
     */
    int get_sensor_max(double *sensor_max)
    {
	return ipmi_sensor_get_sensor_max(self, sensor_max);
    }

    /*
     * Get the sensor minimum for the sensor into the first parameter.
     * Returns an error value.
     */
    int get_sensor_min(double *sensor_min)
    {
	return ipmi_sensor_get_sensor_min(self, sensor_min);
    }

    /*
     * Get the OEM value from the sensor's SDR.
     */
    int get_oem1()
    {
	return ipmi_sensor_get_oem1(self);
    }

    %newobject get_sensor_id;
    /*
     * Get the ID string from the sensor's SDR.
     */
    char *get_sensor_id()
    {
	/* FIXME - no unicode handling. */
	int len = ipmi_sensor_get_id_length(self) + 1;
	char *id = malloc(len);
	ipmi_sensor_get_id(self, id, len);
	return id;
    }

    /*
     * Return the MC that owns the sensor.
     */
    ipmi_mc_t *get_mc()
    {
	return ipmi_sensor_get_mc(self);
    }
}

/*
 * A control id object.  This object is guaranteed to be valid and
 * can be converted into a mc pointer later.
 */
%extend ipmi_control_id_t {
    ~ipmi_control_id_t()
    {
	free(self);
    }

    /* Compare self with other, return -1 if self<other, 0 if
       self==other, or 1 if self>other.  */
    int cmp(ipmi_control_id_t *other)
    {
	return ipmi_cmp_control_id(*self, *other);
    }

    /*
     * Convert a control id to a control pointer.  The "control_cb" method
     * will be called on the first parameter with the following parameters:
     * <self> <control>
     */
    int to_control(swig_cb *handler)
    {
	int rv;
	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, control_cb))
	    rv = EINVAL;
	else
	    rv = ipmi_control_pointer_cb(*self, handle_control_cb,
					 get_swig_cb(handler, control_cb));
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

/*
 * An control object
 */
%extend ipmi_control_t {

    %newobject get_name;
    /*
     * Get the name of an control.
     */
    char *get_name()
    {
	char name[IPMI_CONTROL_NAME_LEN];

	ipmi_control_get_name(self, name, sizeof(name));
	return strdup(name);
    }

    %newobject get_id;
    /*
     * Get the id for the control.
     */
    ipmi_control_id_t *get_id()
    {
	ipmi_control_id_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_control_convert_to_id(self);
	return rv;
    }

    /*
     * Get the string type of control.
     */
    const char *get_type_string()
    {
	return ipmi_control_get_type_string(self);
    }

%constant int CONTROL_LIGHT = IPMI_CONTROL_LIGHT;
%constant int CONTROL_RELAY = IPMI_CONTROL_RELAY;
%constant int CONTROL_DISPLAY = IPMI_CONTROL_DISPLAY;
%constant int CONTROL_ALARM = IPMI_CONTROL_ALARM;
%constant int CONTROL_RESET = IPMI_CONTROL_RESET;
%constant int CONTROL_POWER = IPMI_CONTROL_POWER;
%constant int CONTROL_FAN_SPEED = IPMI_CONTROL_FAN_SPEED;
%constant int CONTROL_IDENTIFIER = IPMI_CONTROL_IDENTIFIER;
%constant int CONTROL_ONE_SHOT_RESET = IPMI_CONTROL_ONE_SHOT_RESET;
%constant int CONTROL_OUTPUT = IPMI_CONTROL_OUTPUT;
%constant int CONTROL_ONE_SHOT_OUTPUT = IPMI_CONTROL_ONE_SHOT_OUTPUT;

    /*
     * Get the numeric type of control.
     */
    int get_type()
    {
	return ipmi_control_get_type(self);
    }

    /*
     * Get the entity id for the control's entity.
     */
    int get_entity_id()
    {
	return ipmi_control_get_entity_id(self);
    }

    /*
     * Get the entity instance for the control's entity.
     */
    int get_entity_instance()
    {
	return ipmi_control_get_entity_instance(self);
    }

    /*
     * Get the entity for the control.
     */
    ipmi_entity_t *get_entity()
    {
	return ipmi_control_get_entity(self);
    }

    /*
     * Can the control's value be set?
     */
    int is_settable()
    {
	return ipmi_control_is_settable(self);
    }

    /*
     * Can the control's value be read?
     */
    int is_readable()
    {
	return ipmi_control_is_readable(self);
    }

    /*
     * Should the control be ignored if its entity is not present?
     */
    int get_ignore_if_no_entity()
    {
	return ipmi_control_get_ignore_if_no_entity(self);
    }

    %newobject get_control_id;
    /*
     * Get the ID string from the control's SDR.
     */
    char *get_control_id()
    {
	/* FIXME - no unicode handling. */
	int len = ipmi_control_get_id_length(self) + 1;
	char *id = malloc(len);
	ipmi_control_get_id(self, id, len);
	return id;
    }

    /*
     * Returns true if the control can generate events upon change,
     * and false if not.
     */
    int has_events()
    {
	return ipmi_control_has_events(self);
    }

    /*
     * Get the number of values the control supports.
     */
    int get_num_vals()
    {
	return ipmi_control_get_num_vals(self);
    }


    /*
     * Set the value of a control.  Note that an control may support
     * more than one element, the array reference passed in as the
     * first parameter must match the number of elements the control
     * supports.  All the elements will be set simultaneously.  The
     * control_set_val_cb method on the second parameter (if it is
     * supplied) will be called after the operation completes with.
     * It will be called with the following parameters: <self>
     * <control> <err>
     */
    int set_val(intarray val, swig_cb *handler = NULL)
    {
	swig_cb_val        *handler_val = NULL;
	ipmi_control_op_cb done = NULL;
	int                rv;

	IPMI_SWIG_C_CB_ENTRY
	if (val.len != ipmi_control_get_num_vals(self)) {
	    rv = EINVAL;
	    goto out_err;
	}

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, control_set_val_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, control_set_val_cb);
	    done = control_val_set_handler;
	}
	rv = ipmi_control_set_val(self, val.val, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the setting of an control.  The control_get_val_cb method
     * on the first parameter will be called with the following
     * parameters: <self> <control> <err> <val1> [<val2> ...]. The
     * number of values passed to the handler will be the number of
     * values the control supports.
     */
    int get_val(swig_cb *handler)
    {
	swig_cb_val         *handler_val = NULL;
	ipmi_control_val_cb done = NULL;
	int                 rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, control_get_val_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, control_get_val_cb);
	    done = control_val_get_handler;

	    rv = ipmi_control_get_val(self, done, handler_val);
	    if (rv && handler_val)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Register a handler that will be called when the control changes
     * value.  Note that if the control does not support this
     * operation, it will return ENOSYS.  When a control event comes
     * in, the control_event_val_cb method on the first parameter will
     * be called with the following parameters: <self> <control>
     * <valid1> [<valid2> ...] val1 [<val2> ...].  The valid fields
     * tell if a particular value is corrected, the number of these
     * is the same as what get_num_vals() returns for this control.
     * the val fields are the actual values, the value is valid only
     * if the valid field corresponding to it is true.
     */
    int add_event_handler(swig_cb *handler)
    {
	ipmi_control_add_val_event_handler_cl
	    (self, control_val_event_handler_cl, NULL);
	cb_add(control, val_event, control_event_val_cb);
    }

    /*
     * Remove a control event handler.
     */
    int remove_event_handler(swig_cb *handler)
    {
	cb_rm(control, val_event, control_event_val_cb);
    }

%constant int CONTROL_COLOR_BLACK = IPMI_CONTROL_COLOR_BLACK;
%constant int CONTROL_COLOR_WHITE = IPMI_CONTROL_COLOR_WHITE;
%constant int CONTROL_COLOR_RED = IPMI_CONTROL_COLOR_RED;
%constant int CONTROL_COLOR_GREEN = IPMI_CONTROL_COLOR_GREEN;
%constant int CONTROL_COLOR_BLUE = IPMI_CONTROL_COLOR_BLUE;
%constant int CONTROL_COLOR_YELLOW = IPMI_CONTROL_COLOR_YELLOW;
%constant int CONTROL_COLOR_ORANGE = IPMI_CONTROL_COLOR_ORANGE;
%constant int CONTROL_NUM_COLORS = IPMI_CONTROL_COLOR_ORANGE+1;

    /*
     * This describes a setting for a light.  There are two types of
     * lights.  One type has a general ability to be set to a color, on
     * time, and off time.  The other has a pre-defined set of
     * transitions.  For transition-based lights, each light is defined to
     * go through a number of transitions.  Each transition is described
     * by a color, a time (in milliseconds) that the color is present.
     * For non-blinking lights, there will only be one transition.  For
     * blinking lights, there will be one or more transitions.
     */

    /*
     * If this returns true, then you set the light with the
     * set_light() function and get the values with the get_light()
     * function.  Otherwise you get/set it with the normal
     * get_val/set_valfunctions and use the transitions functions to
     * get what the LED can do.
     */
    int light_set_with_setting()
    {
	return ipmi_control_light_set_with_setting(self);
    }

    /*
     * Allows detecting if a setting light supports a specific
     * color.
     */
    int light_is_color_supported(int light_num, int color)
    {
	return ipmi_control_light_is_color_sup(self, light_num, color);
    }

    /*
     * Returns true if the light has a local control mode, false if
     * not.
     */
    int light_has_local_control(int light_num)
    {
	return ipmi_control_light_has_loc_ctrl(self, light_num);
    }

    /*
     * Set a setting style light's settings.  The first parm is a
     * string in the form:
     * "[lc] <color> <on_time> <off time>[:[lc] <color>...]".  The
     * second parm turns on or off local control of the light.  When
     * the operation is complete the control_set_val_cb method on the
     * second parameter (if it is supplied) will be called with the
     * following parameters: <self> <control> <err>.
     */
    int set_light(char *settings, swig_cb *handler = NULL)
    {
	ipmi_light_setting_t *s;
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	ipmi_control_op_cb   done = NULL;

	IPMI_SWIG_C_CB_ENTRY
	rv = str_to_light_setting(settings, &s);
	if (rv)
	    goto out_err;

	if (ipmi_light_setting_get_count(s)
	    != ipmi_control_get_num_vals(self))
	{
	    free(s);
	    rv = EINVAL;
	    goto out_err;
	}

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, control_set_val_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, control_set_val_cb);
	    done = control_val_set_handler;
	}
	rv = ipmi_control_set_light(self, s, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
	ipmi_free_light_settings(s);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the current values of the light.  The control_get_light_cb
     * method on the first parm will be called with the following
     * parameters: <self> <control> <err> <light settings>
     * The light settings is a string with each light separated by
     * colons with the (optional) local control (lc), color, on, and
     * off time like this:
     * "[lc] <color> <on_time> <off time>[:[lc] <color>...]"
     */
    int get_light(swig_cb *handler)
    {
	swig_cb_val            *handler_val = NULL;
	ipmi_light_settings_cb done = NULL;
	int                    rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, control_get_light_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, control_get_light_cb);
	    done = control_val_get_light_handler;

	    rv = ipmi_control_get_light(self, done, handler_val);
	    if (rv && handler_val)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
		       
    /*
     * For lights that are transition based, this returns the number
     * of values for a specific light.  So if you put a 2 in the first
     * parm, this will return the number of possible settings for the
     * 3rd light.
     */
    int get_num_light_values(int light)
    {
	return ipmi_control_get_num_light_values(self, light);
    }

    /*
     * For lights that are transition based, return the number of
     * transitions for the given light and value setting.  So if you
     * put a 1 and a 3, this returns the number of transitions that
     * the second light will go through if you set it's value to 3.
     * Each transition will have a color and duration time and can be
     * fetched with other values.  Returns -1 if the inputs are
     * invalid.
     */
    int get_num_light_transitions(int light, int value)
    {
	return ipmi_control_get_num_light_transitions(self, light, value);
    }

    /*
     * For lights that are transition based, return the color of the
     * given transition.  Returns -1 if the inputs are invalid.
     */
    int get_light_color(int light, int value, int transition)
    {
	return ipmi_control_get_light_color(self, light, value, transition);
    }

    /*
     * For lights that are transition based, return the duration of
     * the given transition.  Returns -1 if the inputs are invalid.
     */
    int get_light_color_time(int light, int value, int transition)
    {
	return ipmi_control_get_light_color_time(self, light, value,
						 transition);
    }

    /*
     * Set the value of the identifier.  The first parameter is a
     * reference to an array of byte values to se the identifier to.
     * When the setting is complete, the control_set_val_cb method on
     * the second parameter (if it is supplied) will be called with
     * the following parameters: <self> <control> <err>.
     */
    int identifier_set_val(intarray val, swig_cb *handler = NULL)
    {
	swig_cb_val        *handler_val = NULL;
	ipmi_control_op_cb done = NULL;
	int                rv;
	unsigned char      *data;
	int                i;

	IPMI_SWIG_C_CB_ENTRY
	data = malloc(val.len);
	if (!data) {
	    rv = ENOMEM;
	    goto out_err;
	}
	for (i=0; i<val.len; i++)
	    data[i] = val.val[i];

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, control_set_val_cb)) {
		free(data);
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, control_set_val_cb);
	    done = control_val_set_handler;
	}
	rv = ipmi_control_identifier_set_val(self, data, val.len,
					     done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
	free(data);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the value of the identifier control.  The control_get_id_cb
     * method on the first parameter will be called when the operation
     * completes.  The values passed to that method will be:
     * <self> <control> <err> byte1 [<byte2> ...].
     * The id value is all the bytes after the error value.
     */
    int identifier_get_val(swig_cb *handler)
    {
	swig_cb_val                    *handler_val = NULL;
	ipmi_control_identifier_val_cb done = NULL;
	int                            rv;

	IPMI_SWIG_C_CB_ENTRY
	if (! valid_swig_cb(handler, control_get_id_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, control_get_id_cb);
	    done = control_val_get_id_handler;

	    rv = ipmi_control_identifier_get_val(self, done, handler_val);
	    if (rv && handler_val)
		deref_swig_cb_val(handler_val);
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Return the maximum possible length of the identifier control's
     * value.
     */
    int identifier_get_max_length()
    {
	return ipmi_control_identifier_get_max_length(self);
    }
}

/*
 * Convert the FRU index to a string.  Returns undefined if the
 * index is out of range.
 */
%rename(fru_index_to_str) ipmi_fru_index_to_str;
extern char *ipmi_fru_index_to_str(int idx);

/*
 * Convert a name to an index.  Returns -1 if the name is not valid.
 */
%rename(fru_str_to_index) ipmi_fru_str_to_index;
extern int ipmi_fru_str_to_index(char *name);

/*
 * A FRU object
 */
%extend ipmi_fru_t {

    ~ipmi_fru_t()
    {
	ipmi_fru_deref(self);
    }

/* Area numbers */
%constant int FRU_INTERNAL_USE_AREA = IPMI_FRU_FTR_INTERNAL_USE_AREA;
%constant int FRU_CHASSIS_INFO_AREA = IPMI_FRU_FTR_CHASSIS_INFO_AREA;
%constant int FRU_BOARD_INFO_AREA = IPMI_FRU_FTR_BOARD_INFO_AREA;
%constant int FRU_PRODUCT_INFO_AREA = IPMI_FRU_FTR_PRODUCT_INFO_AREA;
%constant int FRU_MULTI_RECORD_AREA = IPMI_FRU_FTR_MULTI_RECORD_AREA;

    %newobject get_domain_id;
    /*
     * Get the domain the FRU belongs to.
     */
    ipmi_domain_id_t *get_domain_id()
    {
	ipmi_domain_id_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_fru_get_domain_id(self);
	return rv;
    }

    /*
     * Convert the string to a FRU index.  Use this if you have a specfiic
     * fru data object you are after.  Returns -1 if the name is not valid.
     */
    int str_to_index(char *name)
    {
	return ipmi_fru_str_to_index(name);
    }

    /*
     * Get a FRU data item.  The first parameter is an index to get,
     * the second is an integer reference to an item number.  This
     * returns a string of the particular object with the following:
     * "<name> <type> <data>".  If the index or number are invalid,
     * then an undefined value will be returned (NULL, undef, etc).
     * If the FRU item is not supported for this FRU, only the name
     * will be filled out and there will be no type or value.
     *
     * If the type is integer, a single integer number will follow.
     * If the type is ascii, an ascii string will follow starting one
     * space after the type.  If the type is unicode or binary, then
     * a set of ascii-encoded binary bytes will follow "0x01 0x03 ..."
     *
     * The second parameter (the number) is zero based and should be
     * set to zero when fetching an index for the first time.  It will
     * be unchanged if the data item does not support multiple items.
     * If it does support multiple items, then the number will be
     * changed to the next supported value, or to -1 if this is the
     * last item.
     */
    %newobject get;
    char *get(int index, int *num)
    {
	const char                *name;
	enum ipmi_fru_data_type_e dtype;
	int                       intval;
	time_t                    time;
	char                      *data;
	unsigned int              data_len;
	int                       rv;
	char                      dummy[1];
	char                      *str = NULL, *s;
	int                       len;
	int                       i;

	data = NULL;
	rv = ipmi_fru_get(self, index, &name, num, &dtype, &intval,
			  &time, &data, &data_len);
	if ((rv == ENOSYS) || (rv == E2BIG))
	    return strdup(name);
	else if (rv)
	    return NULL;

	switch(dtype) {
	case IPMI_FRU_DATA_INT:
	    len = snprintf(dummy, 1, "%s integer %d", name, intval);
	    str = malloc(len + 1);
	    sprintf(str, "%s integer %d", name, intval);
	    break;

	case IPMI_FRU_DATA_TIME:
	    len = snprintf(dummy, 1, "%s time %ld", name, (long) time);
	    str = malloc(len + 1);
	    sprintf(str, "%s time %ld", name, (long) time);
	    break;

	case IPMI_FRU_DATA_BINARY:
	    len = snprintf(dummy, 1, "%s binary", name);
	    len += data_len * 5;
	    str = malloc(len + 1);
	    s = str;
	    s += sprintf(s, "%s binary", name);
	    for (i=0; i<data_len; i++)
		s += sprintf(s, " 0x%2.2x", (unsigned char) data[i]);
	    break;

	case IPMI_FRU_DATA_UNICODE:
	    len = snprintf(dummy, 1, "%s unicode", name);
	    len += data_len * 5;
	    str = malloc(len + 1);
	    s = str;
	    s += sprintf(s, "%s unicode", name);
	    for (i=0; i<data_len; i++)
		s += sprintf(s, " 0x%2.2x", (unsigned char) data[i]);
	    break;

	case IPMI_FRU_DATA_ASCII:
	    len = snprintf(dummy, 1, "%s ascii %s", name, data);
	    str = malloc(len + 1);
	    sprintf(str, "%s ascii %s", name, data);
	    break;

	default:
	    str = NULL;
	}

	if (data)
	    ipmi_fru_data_free(data);

	return str;
    }

    /*
     * Return the number of multi-records the FRU has.
     */
    int get_num_multi_records()
    {
	return ipmi_fru_get_num_multi_records(self);
    }

    /*
     * Fetch a multi record from the FRU.  The data comes out in a
     * string with the format:
     *    "<type num> <version num> [data1 [data2 ...]]"
     * It returns an undefined value if the num is invalid.  The data
     * items will not be present if the length is zero.
     */
    %newobject get_multirecord;
    char *get_multirecord(int num)
    {
	unsigned char type;
	unsigned char version;
	unsigned int length;
	unsigned char *data;
	int           rv;
	char          dummy[1];
	char          *str, *s;
	int           str_len;
	int           i;

	rv = ipmi_fru_get_multi_record_type(self, num, &type);
	if (rv)
	    return NULL;
	rv = ipmi_fru_get_multi_record_format_version(self, num, &version);
	if (rv)
	    return NULL;
	rv = ipmi_fru_get_multi_record_data_len(self, num, &length);
	if (rv)
	    return NULL;
	if (length == 0)
	    data = malloc(1);
	else
	    data = malloc(length);
	if (!data)
	    return NULL;
	rv = ipmi_fru_get_multi_record_data(self, num, data, &length);
	if (rv) {
	    free(data);
	    return NULL;
	}

	str_len = snprintf(dummy, 1, "%d %d", type, version);
	str_len += length * 5;
	str = malloc(str_len + 1);
	if (!str) {
	    free(data);
	    return NULL;
	}

	s = str;
	s += sprintf(s, "%d %d", type, version);
	for (i=0; i<length; i++)
	    s += sprintf(s, " 0x%2.2x", data[i]);
	free(data);
	return str;
    }

    /*
     * Set a specific data item by index (see the get function for more
     * info on what index and num mean).  Note that the "num "field is
     * not updated by this call, unlike the get function.
     *
     * The type passed in tells the kind of data being passed in.  It is
     * either:
     *  "integer" - An integer value passed in.
     *  "time" - An integer value passed in.
     *  "binary" - A string of 8-bit values is passed in, like 
     *    "0x10 0x20 0x99".
     *  "unicode" - A string of 8-bit values is passed in, like 
     *    "0x10 0x20 0x99".
     *  "ascii" - The string passed in is used.
     * Passing an undefined value for binary, unicode, and ascii
     * will result in the field being cleared or (for custom fields)
     * deleted.  NULL values are not allowed for integer or time.
     */
    int set(int index, int num, char *type, char *value = NULL)
    {
	if (!type)
	    return EINVAL;
	if (strcmp(type, "integer") == 0) {
	    unsigned int val;
	    char         *endstr;
	    if (!value)
		return EINVAL;
	    if (*value == '\0')
		return EINVAL;
	    val = strtol(value, &endstr, 0);
	    if (*endstr != '\0')
		return EINVAL;
	    return ipmi_fru_set_int_val(self, index, num, val);
	} else if (strcmp(type, "time") == 0) {
	    unsigned int val;
	    char         *endstr;
	    if (!value)
		return EINVAL;
	    if (*value == '\0')
		return EINVAL;
	    val = strtol(value, &endstr, 0);
	    if (*endstr != '\0')
		return EINVAL;
	    return ipmi_fru_set_time_val(self, index, num, val);
	} else if (strcmp(type, "binary") == 0) {
	    unsigned int length = 0;
	    unsigned char *data;
	    int rv;
	    if (!value) {
		data = NULL;
	    } else {
		data = parse_raw_str_data(value, &length);
		if (!data)
		    return ENOMEM;
	    }
	    rv = ipmi_fru_set_data_val(self, index, num, IPMI_FRU_DATA_BINARY,
				       (char *) data, length);
	    if (data)
		free(data);
	    return rv;
	} else if (strcmp(type, "unicode") == 0) {
	    unsigned int length = 0;
	    unsigned char *data;
	    int rv;
	    if (!value) {
		data = NULL;
	    } else {
		data = parse_raw_str_data(value, &length);
		if (!data)
		    return ENOMEM;
	    }
	    rv = ipmi_fru_set_data_val(self, index, num, IPMI_FRU_DATA_UNICODE,
				       (char *) data, length);
	    if (data)
		free(data);
	    return rv;
	} else if (strcmp(type, "ascii") == 0) {
	    int length = 0;
	    if (value)
		length = strlen(value);
	    return ipmi_fru_set_data_val(self, index, num, IPMI_FRU_DATA_ASCII,
					 value, length);
	} else {
	    return EINVAL;
	}
    }

    /*
     * Set a specific data item by index (see the get function for more
     * info on what index and num mean).  Note that the "num" field is
     * not updated by this call, unlike the get function.
     *
     * The type passed in tells the kind of data being passed in.  It is
     * either:
     *  "integer" - The first element of the integer array is used.
     *  "time" - The first element of the integer array is used.
     *  "binary" - An array of 8-bit values is taken, like 
     *    [ 0x10, 0x20, 0x99 ].
     *  "unicode" - An array of 8-bit values is passed in, like 
     *    [ 0x10, 0x20, 0x99 ].
     *  "ascii" - An array of 8-bit values is passed in, like 
     *    [ 0x10, 0x20, 0x99 ].
     * Undefined values are not allowed here, but that shouldn't
     * matter because the above function should be used for those.
     */
    int set_array(int index, int num, char *type, intarray value)
    {
	if (value.len < 0)
	    return EINVAL;
	if (!type)
	    return EINVAL;

	if (strcmp(type, "integer") == 0) {
	    /* Only take the first value. */
	    if (value.len <= 0)
		return EINVAL;
	    return ipmi_fru_set_int_val(self, index, num, value.val[0]);
	} else if (strcmp(type, "time") == 0) {
	    /* Only take the first value. */
	    if (value.len <= 0)
		return EINVAL;
	    return ipmi_fru_set_time_val(self, index, num, value.val[0]);
	} else if (strcmp(type, "binary") == 0) {
	    unsigned int length = value.len;
	    unsigned char *data;
	    int rv;

	    if (length == 0)
		data = malloc(1);
	    else
		data = malloc(length);
	    if (!data)
		return ENOMEM;
	    parse_ipmi_data(value, data, length, &length);
	    rv = ipmi_fru_set_data_val(self, index, num, IPMI_FRU_DATA_BINARY,
				       (char *) data, length);
	    free(data);
	    return rv;
	} else if (strcmp(type, "unicode") == 0) {
	    unsigned int length = value.len;
	    unsigned char *data = malloc(length);
	    int rv;
	    if (!data)
		return EINVAL;
	    parse_ipmi_data(value, data, length, &length);
	    rv = ipmi_fru_set_data_val(self, index, num, IPMI_FRU_DATA_UNICODE,
				       (char *) data, length);
	    free(data);
	    return rv;
	} else if (strcmp(type, "ascii") == 0) {
	    unsigned int length = value.len;
	    unsigned char *data;
	    int rv;
	    if (length == 0)
		data = malloc(1);
	    else
		data = malloc(length);
	    if (!data)
		return ENOMEM;
	    parse_ipmi_data(value, data, length, &length);
	    rv = ipmi_fru_set_data_val(self, index, num, IPMI_FRU_DATA_ASCII,
				       (char *) data, length);
	    free(data);
	    return rv;
	} else {
	    return EINVAL;
	}
    }

    /*
     * Set multi-record fields from a string of the form:
     *  "0x10 0x20 0x99"
     *
     * It take a number (which multi-record), type, version, and a
     * string value.  Passing in an undefined value will delete the
     * specific multi-record.  Note that if the number is less than
     * the number of fields in the record, then the record will be
     * replaced.  If it is larger than or equal to the number of
     * fields, a new record will be appended in the next location, not
     * in the number supplied.
     */
    int set_multirecord(unsigned int num,
			unsigned int type,
			unsigned int version,
			char         *value = NULL)
    {
	unsigned int length = 0;
	unsigned char *data;
	int rv;

	if (!value) {
	    data = NULL;
	} else {
	    data = parse_raw_str_data(value, &length);
	    if (!data)
		return ENOMEM;
	}
	rv = ipmi_fru_set_multi_record(self, num, type, version,
				       data, length);
	if (data)
	    free(data);
	return rv;
    }

    /*
     * Set multi-record fields from a string of the form:
     *  "0x10 0x20 0x99"
     *
     * It take a number (which multi-record), type, version, and an
     * integer array.  Undefined values are not allowed here, use
     * the previous call to delete records.  Note that if the number
     * is less than the number of fields in the record, then the
     * record will be replaced.  If it is larger than or equal to the
     * number of fields, a new record will be appended in the next
     * location, not in the number supplied.
     */
    int set_multirecord_array(unsigned int num,
			      unsigned int type,
			      unsigned int version,
			      intarray     value)
    {
	unsigned int length = value.len;
	unsigned char *data;
	int rv;

	if (length == 0)
	    data = malloc(1);
	else
	    data = malloc(length);
	if (!data)
	    return ENOMEM;
	parse_ipmi_data(value, data, length, &length);
	rv = ipmi_fru_set_multi_record(self, num, type, version,
				       data, length);
	free(data);
	return rv;
    }

    /*
     * Add a new area to the FRU.  You must pass in the area number, the
     * start offset and length of the area.  The offset must be a multiple
     * of 8 and the length will be truncated to a multiple of 8.
     */
    int add_area(unsigned int area,
		 unsigned int offset,
		 unsigned int length)
    {
	return ipmi_fru_add_area(self, area, offset, length);
    }

    /*
     * Delete the given area from the FRU.
     */
    int delete_area(int area)
    {
	return ipmi_fru_delete_area(self, area);
    }

    /*
     * Get the offset of the given area into the offset pointer.
     */
    int area_get_offset(unsigned int area,
			unsigned int *offset)
    {
	return ipmi_fru_area_get_offset(self, area, offset);
    }

    /*
     * Get the length of the given area into the length pointer.
     */
    int area_get_length(unsigned int area,
			unsigned int *length)
    {
	return ipmi_fru_area_get_length(self, area, length);
    }

    /*
     * Set the offset of the given area.
     */
    int area_set_offset(unsigned int area,
			unsigned int offset)
    {
	return ipmi_fru_area_set_offset(self, area, offset);
    }

    /*
     * Set the length of the given area.
     */
    int area_set_length(unsigned int area,
			unsigned int length)
    {
	return ipmi_fru_area_set_length(self, area, length);
    }

    /*
     * Get the number of bytes currently used in the given area into
     * the used_length pointer.
     */
    int area_get_used_length(unsigned int area,
			     unsigned int *used_length)
    {
	return ipmi_fru_area_get_used_length(self, area, used_length);
    }

    /*
     * Write the contents of the fru back into the FRU device.  If the
     * handler (first parm) is non-null, the "fru_written" method on
     * that object will be called with the domain as the first
     * parameter, the FRU as the second parameter and the error value
     * for the write as the third parameter.
     */
    int write(swig_cb *handler = NULL)
    {
	int         rv;
	swig_cb_val *handler_val = NULL;
	ipmi_fru_cb cb_handler = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, fru_written)) {
		rv = EINVAL;
		goto out_err;
	    }
	    cb_handler = fru_written_done;
	    handler_val = ref_swig_cb(handler, fru_written);
	    ipmi_fru_ref(self);
	}

	rv = ipmi_fru_write(self, cb_handler, handler_val);
	if (rv) {
	    if (handler_val)
		deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    int multi_record_get_root_node(unsigned int    record_num,
				   const char      **name,
				   ipmi_fru_node_t **sub_node)
    {
	int rv;
	rv = ipmi_fru_multi_record_get_root_node(self, record_num,
						 name, sub_node);
	return rv;
    }

    int get_root_node(const char **type, ipmi_fru_node_t **sub_node)
    {
	return ipmi_fru_get_root_node(self, type, sub_node);
    }
}

/*
 * A FRU node object
 */
%extend ipmi_fru_node_t {
    ~ipmi_fru_node_t()
    {
	ipmi_fru_put_node(self);
    }

    int get_field(unsigned int    index,
		  const char      **name,
		  const char      **type,
		  char            **value,
		  ipmi_fru_node_t **sub_node)
    {
	int                       rv;
	enum ipmi_fru_data_type_e dtype;
	int                       intval;
	double                    floatval;
	time_t                    time;
	char                      *data = NULL;
	unsigned int              data_len;
	int                       len;
	char                      dummy[1];
	char                      *str, *s;
	int                       i;
	
	rv = ipmi_fru_node_get_field(self,
				     index,
				     name,
				     &dtype,
				     &intval,
				     &time,
				     &floatval,
				     &data,
				     &data_len,
				     sub_node);
	if (rv)
	    return rv;

	switch(dtype) {
	case IPMI_FRU_DATA_INT:
	    len = snprintf(dummy, 1, "%d", intval);
	    str = malloc(len + 1);
	    sprintf(str, "%d", intval);
	    *type = "integer";
	    break;

	case IPMI_FRU_DATA_BOOLEAN:
	    len = snprintf(dummy, 1, "%d", intval);
	    str = malloc(len + 1);
	    sprintf(str, "%d", intval);
	    *type = "boolean";
	    break;

	case IPMI_FRU_DATA_TIME:
	    len = snprintf(dummy, 1, "%ld", (long) time);
	    str = malloc(len + 1);
	    sprintf(str, "%ld", (long) time);
	    *type = "time";
	    break;

	case IPMI_FRU_DATA_FLOAT:
	    len = snprintf(dummy, 1, "%lf", floatval);
	    str = malloc(len + 1);
	    sprintf(str, "%lf", floatval);
	    *type = "float";
	    break;

	case IPMI_FRU_DATA_BINARY:
	    len = data_len * 5;
	    str = malloc(len + 1);
	    s = str;
	    if (data_len > 0)
		s += sprintf(s, "0x%2.2x", (unsigned char) data[0]);
	    else
		*s = '\0';
	    for (i=1; i<data_len; i++)
		s += sprintf(s, " 0x%2.2x", (unsigned char) data[i]);
	    *type = "binary";
	    break;

	case IPMI_FRU_DATA_UNICODE:
	    len = data_len * 5;
	    str = malloc(len + 1);
	    s = str;
	    if (data_len > 0)
		s += sprintf(s, "0x%2.2x", (unsigned char) data[0]);
	    else
		*s = '\0';
	    for (i=1; i<data_len; i++)
		s += sprintf(s, " 0x%2.2x", (unsigned char) data[i]);
	    *type = "unicode";
	    break;

	case IPMI_FRU_DATA_ASCII:
	    str = strdup(data);
	    *type = "ascii";
	    break;

	case IPMI_FRU_DATA_SUB_NODE:
	    str = NULL;
	    *type = "subnode";

	    /* Put the array length (or the -1) in the value */
	    len = snprintf(dummy, 1, "%d", intval);
	    str = malloc(len + 1);
	    sprintf(str, "%d", intval);
	    break;

	default:
	    str = NULL;
	}

	if (data)
	    ipmi_fru_data_free(data);

	*value = str;

	return 0;
    }

    int get_enum_val(unsigned int index,
		     int          *pos,
		     int          *nextpos,
		     const char   **data)
    {
	return ipmi_fru_node_get_enum_val(self, index, pos, nextpos, data);
    }

    int set_field(unsigned int    index,
		  const char      *type,
		  char            *value)
    {
	int                       rv;
	enum ipmi_fru_data_type_e dtype;
	int                       intval = 0;
	double                    floatval = 0.0;
	time_t                    time = 0;
	char                      *data = NULL;
	unsigned int              data_len = 0;
	char                      *s;

	if (!type)
	    return EINVAL;

	if (strcmp(type, "subnode") == 0) {
	    dtype = IPMI_FRU_DATA_SUB_NODE;
	    if (value) {
		data = (char *) parse_raw_str_data(value, &data_len);
		if (!data)
		    return ENOMEM;
	    }
	    goto ready_to_set;
	} else if (strcmp(type, "binary") == 0) {
	    dtype = IPMI_FRU_DATA_BINARY;
	    if (value) {
		data = (char *) parse_raw_str_data(value, &data_len);
		if (!data)
		    return ENOMEM;
	    }
	    goto ready_to_set;
	} else if (strcmp(type, "unicode") == 0) {
	    dtype = IPMI_FRU_DATA_UNICODE;
	    if (value) {
		data = (char *) parse_raw_str_data(value, &data_len);
		if (!data)
		    return ENOMEM;
	    }
	    goto ready_to_set;
	} else if (strcmp(type, "ascii") == 0) {
	    dtype = IPMI_FRU_DATA_ASCII;
	    if (value) {
		data = strdup(value);
		if (!data)
		    return ENOMEM;
		data_len = strlen(value);
	    }
	    goto ready_to_set;
	}

	if (!value || !(*value))
	    return EINVAL;

	if (strcmp(type, "integer") == 0) {
	    dtype = IPMI_FRU_DATA_INT;
	    intval = strtol(value, &s, 0);
	    if (*s != '\0')
		return EINVAL;
	} else if (strcmp(type, "boolean") == 0) {
	    dtype = IPMI_FRU_DATA_BOOLEAN;
	    intval = strtol(value, &s, 0);
	    if (*s == '\0')
		intval = !!intval;
	    else if (strcasecmp(value, "true") == 0)
		intval = 1;
	    else if (strcasecmp(value, "false") == 0)
		intval = 0;
	    else
		return EINVAL;
	} else if (strcmp(type, "time") == 0) {
	    dtype = IPMI_FRU_DATA_TIME;
	    time = strtol(value, &s, 0);
	    if (*s != '\0')
		return EINVAL;
	} else if (strcmp(type, "float") == 0) {
	    dtype = IPMI_FRU_DATA_FLOAT;
	    floatval = strtod(value, &s);
	    if (*s != '\0')
		return EINVAL;
	} else
	    return EINVAL;

    ready_to_set:
	rv = ipmi_fru_node_set_field(self, index, dtype, intval, time,
				     floatval, data, data_len);

	if (data)
	    free(data);
	return rv;
    }

    int settable(unsigned int index)
    {
	return ipmi_fru_node_settable(self, index);
    }

    char *get_subtype()
    {
	enum ipmi_fru_data_type_e dtype;        
	char                      *type;
	int                       rv;

	rv = ipmi_fru_node_get_subtype(self, &dtype);
	if (rv)
	    return NULL;
	switch (dtype) {
	case IPMI_FRU_DATA_INT:
	    type = "integer";
	    break;

	case IPMI_FRU_DATA_BOOLEAN:
	    type = "boolean";
	    break;

	case IPMI_FRU_DATA_TIME:
	    type = "time";
	    break;

	case IPMI_FRU_DATA_FLOAT:
	    type = "float";
	    break;

	case IPMI_FRU_DATA_BINARY:
	    type = "binary";
	    break;

	case IPMI_FRU_DATA_UNICODE:
	    type = "unicode";
	    break;

	case IPMI_FRU_DATA_ASCII:
	    type = "ascii";
	    break;

	case IPMI_FRU_DATA_SUB_NODE:
	    type = "subnode";
	    break;

	default:
	    return NULL;
	}

	return type;
    }
}

/*
 * An event object
 */
%extend ipmi_event_t {
    ~ipmi_event_t()
    {
	ipmi_event_free(self);
    }

    /* When you are done with an event, you should delete it.  This
       removes the event from the local event queue and removes it
       from the external system event log. */
    int delete(swig_cb *handler = NULL)
    {
	swig_cb_val    *handler_val = NULL;
	ipmi_domain_cb done = NULL;
	int            rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, event_delete_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, event_delete_cb);
	    done = event_deleted_handler;
	}
	rv = ipmi_event_delete(self, done, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }


    %newobject get_mc_id;
    /*
     * Get the MC id the event came from.  Note that the MC may not exist
     * any more.
     */
    ipmi_mcid_t *get_mc_id()
    {
	ipmi_mcid_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_event_get_mcid(self);
	return rv;
    }

    /*
     * Get the event's record id
     */
    int get_record_id()
    {
	return ipmi_event_get_record_id(self);
    }

    /*
     * Get the event's type.
     */
    int get_type()
    {
	return ipmi_event_get_type(self);
    }

    /*
     * Get the event's timestamp.  This is in seconds.
     */
    double get_timestamp()
    {
	return ((double) ipmi_event_get_timestamp(self)) / 1000000000.0;
    }

    /*
     * Get the data from the event.  This returns a reference to an
     * array, so you have to reference it like @$val.
     */
    intarray get_data()
    {
	intarray      rv;
	int           i;
	unsigned char *data;
	int           data_len;

	data_len = ipmi_event_get_data_len(self);
	data = malloc(data_len);
	data_len = ipmi_event_get_data(self, data, 0, data_len);
	rv.val = malloc(sizeof(int) * data_len);
	for (i=0; i<data_len; i++)
	    rv.val[i] = data[i];
	free(data);
	rv.len = data_len;
	return rv;
    }

    /* Call the sensor callback for the event.  If the sensor is a
     * threshold sensor, the threshold_event_cb method will be called
     * on the sensor. Otherwise, the sensor is discrete and the
     * discrete_event_cb will be called.  The threshold_event_cb
     * method takes the following parameters:
     * <self> <sensor> <event spec> <raw_set> <raw> <value_set> <value> <event>
     * The discrete_event_cb method takes the following parameters:
     * <self> <sensor> <event spec> <severity> <old_severity> <event>
     *
     * Note: In the future, this may take control callbacks, too.
     */
    int call_handler(swig_cb *handler)
    {
	event_call_handler_data_t info;
	int                       rv;
	
	if (! valid_swig_2cb(handler, threshold_event_cb, discrete_event_cb))
	    return EINVAL;

	info.handlers = ipmi_event_handlers_alloc();
	if (! info.handlers)
	    return ENOMEM;

	ipmi_event_handlers_set_threshold(info.handlers,
					  sensor_threshold_event_handler);
	ipmi_event_handlers_set_discrete(info.handlers,
					 sensor_discrete_event_handler);

	info.handlers_val = ref_swig_2cb(handler, threshold_event_cb,
					 discrete_event_cb);

	info.event = self;
	info.rv = 0;
	rv = ipmi_mc_pointer_cb(ipmi_event_get_mcid(self),
				event_call_handler_mc_cb,
				&info);
	if (rv == 0)
	    rv = info.rv;
	
	ipmi_event_handlers_free(info.handlers);
	deref_swig_cb_val(handler);

	return rv;
    }
}

%extend ipmi_lanparm_t {
    ~ipmi_lanparm_t()
    {
	ipmi_lanparm_deref(self);
    }

    %newobject get_mc_id;
    ipmi_mcid_t *get_mc_id()
    {
	ipmi_mcid_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_lanparm_get_mc_id(self);
	return rv;
    }

    int get_channel()
    {
	return ipmi_lanparm_get_channel(self);
    }

%constant int LANPARM_SET_IN_PROGRESS = IPMI_LANPARM_SET_IN_PROGRESS;
%constant int LANPARM_AUTH_TYPE_SUPPORT = IPMI_LANPARM_AUTH_TYPE_SUPPORT;
%constant int LANPARM_AUTH_TYPE_ENABLES = IPMI_LANPARM_AUTH_TYPE_ENABLES;
%constant int LANPARM_IP_ADDRESS = IPMI_LANPARM_IP_ADDRESS;
%constant int LANPARM_IP_ADDRESS_SRC = IPMI_LANPARM_IP_ADDRESS_SRC;
%constant int LANPARM_MAC_ADDRESS = IPMI_LANPARM_MAC_ADDRESS;
%constant int LANPARM_SUBNET_MASK = IPMI_LANPARM_SUBNET_MASK;
%constant int LANPARM_IPV4_HDR_PARMS = IPMI_LANPARM_IPV4_HDR_PARMS;
%constant int LANPARM_PRIMARY_RMCP_PORT = IPMI_LANPARM_PRIMARY_RMCP_PORT;
%constant int LANPARM_SECONDARY_RMCP_PORT = IPMI_LANPARM_SECONDARY_RMCP_PORT;
%constant int LANPARM_BMC_GENERATED_ARP_CNTL = IPMI_LANPARM_BMC_GENERATED_ARP_CNTL;
%constant int LANPARM_GRATUIDOUS_ARP_INTERVAL = IPMI_LANPARM_GRATUIDOUS_ARP_INTERVAL;
%constant int LANPARM_DEFAULT_GATEWAY_ADDR = IPMI_LANPARM_DEFAULT_GATEWAY_ADDR;
%constant int LANPARM_DEFAULT_GATEWAY_MAC_ADDR = IPMI_LANPARM_DEFAULT_GATEWAY_MAC_ADDR;
%constant int LANPARM_BACKUP_GATEWAY_ADDR = IPMI_LANPARM_BACKUP_GATEWAY_ADDR;
%constant int LANPARM_BACKUP_GATEWAY_MAC_ADDR = IPMI_LANPARM_BACKUP_GATEWAY_MAC_ADDR;
%constant int LANPARM_COMMUNITY_STRING = IPMI_LANPARM_COMMUNITY_STRING;
%constant int LANPARM_NUM_DESTINATIONS = IPMI_LANPARM_NUM_DESTINATIONS;
%constant int LANPARM_DEST_TYPE = IPMI_LANPARM_DEST_TYPE;
%constant int LANPARM_DEST_ADDR = IPMI_LANPARM_DEST_ADDR;
%constant int LANPARM_VLAN_ID = IPMI_LANPARM_VLAN_ID;
%constant int LANPARM_VLAN_PRIORITY = IPMI_LANPARM_VLAN_PRIORITY;
%constant int LANPARM_NUM_CIPHER_SUITE_ENTRIES = IPMI_LANPARM_NUM_CIPHER_SUITE_ENTRIES;
%constant int LANPARM_CIPHER_SUITE_ENTRY_SUPPORT = IPMI_LANPARM_CIPHER_SUITE_ENTRY_SUPPORT;
%constant int LANPARM_CIPHER_SUITE_ENTRY_PRIV = IPMI_LANPARM_CIPHER_SUITE_ENTRY_PRIV;
%constant int LANPARM_DEST_VLAN_TAG = IPMI_LANPARM_DEST_VLAN_TAG;

    /*
     * Fetch an individual parm from the MC.  The parameter (parm1) ,
     * and set (parm2) and block (parm3) are specified, along with a
     * handler (parm4).  The lanparm_got_parm_cb method on the handler
     * will be called when the the operation completes with the
     * following parms: <self> <lanparm> <err> <parm_rev> <data1> [<data2> ...]
     */
    int get_parm(int parm, int set, int block, swig_cb *handler)
    {
	int         rv;
	swig_cb_val *handler_val;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, lanparm_got_parm_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, lanparm_got_parm_cb);
	    ipmi_lanparm_ref(self);
	    rv = ipmi_lanparm_get_parm(self, parm, set, block,
				       lanparm_get_parm, handler_val);
	    if (rv) {
		ipmi_lanparm_deref(self);
		deref_swig_cb_val(handler_val);
	    }
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set an individual parm on the MC.  The parameter (parm1),
     * and string value (parm2) is specified, along with an optional
     * handler (parm3).  The lanparm_set_parm_cb method on the handler
     * will be called when the the operation completes with the
     * following parms: <self> <lanparm> <err>.
     *
     * The string value is in the form "0xNN 0xNN ...", basically
     * a string of integer values.
     */
    int set_parm(int parm, char *value, swig_cb *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	unsigned char        *data;
	unsigned int         length;

	IPMI_SWIG_C_CB_ENTRY
	data = parse_raw_str_data(value, &length);
	if (!data) {
	    rv = ENOMEM;
	    goto out_err;
	}

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, lanparm_set_parm_cb)) {
		free(data);
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, lanparm_set_parm_cb);
	}

	if (handler_val)
	    ipmi_lanparm_ref(self);
	rv = ipmi_lanparm_set_parm(self, parm, data, length,
				   lanparm_set_parm, handler_val);
	free(data);
	if (rv && handler_val) {
	    ipmi_lanparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set an individual parm on the MC.  The parameter (parm1), and
     * an array of integers (parm2) is specified, along with an
     * optional handler (parm3).  The lanparm_set_parm_cb method on
     * the handler will be called when the the operation completes
     * with the following parms: <self> <lanparm> <err>.
     *
     * The string value is in the form "0xNN 0xNN ...", basically
     * a string of integer values.
     */
    int set_parm_array(int parm, intarray value, swig_cb *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	unsigned char        *data;
	unsigned int         length = value.len;

	IPMI_SWIG_C_CB_ENTRY
	if (length == 0)
	    data = malloc(1);
	else
	    data = malloc(length);
	if (!data) {
	    rv = ENOMEM;
	    goto out_err;
	}
	parse_ipmi_data(value, data, length, &length);

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, lanparm_set_parm_cb)) {
		free(data);
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, lanparm_set_parm_cb);
	}

	if (handler_val)
	    ipmi_lanparm_ref(self);
	rv = ipmi_lanparm_set_parm(self, parm, data, length,
				   lanparm_set_parm, handler_val);
	free(data);
	if (rv && handler_val) {
	    ipmi_lanparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the full standard configuration for the lanparms.  When
     * done, the lanparm_got_config_cb method will be called on the
     * handler (first parm) with the following parms: <self> <lanparm>
     * <err> <lanconfig>.  The lanconfig will be an object of type
     * ipmi_lan_config_t.
     */
    int get_config(swig_cb *handler)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, lanparm_got_config_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, lanparm_got_config_cb);

	    ipmi_lanparm_ref(self);
	    rv = ipmi_lan_get_config(self, lanparm_get_config, handler_val);
	    if (rv) {
		ipmi_lanparm_deref(self);
		deref_swig_cb_val(handler_val);
	    }
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
	
    }

    /*
     * Set the full standard configuration for the lanparms.  The
     * config to set is the first parm of type ipmi_lan_config_t.  When
     * done, the lanparm_set_config_cb method will be called on the
     * handler (second parm) with the following parms: <self>
     * <lanparm> <err>.
     */
    int set_config(ipmi_lan_config_t *config, swig_cb *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, lanparm_set_config_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, lanparm_set_config_cb);
	}

	if (handler_val)
	    ipmi_lanparm_ref(self);
	rv = ipmi_lan_set_config(self, config,
				 lanparm_set_config, handler_val);
	if (rv && handler_val) {
	    ipmi_lanparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Unlock the lock for the lanparm.  The config to set is the
     * first parm of type ipmi_lan_config_t and may be undefined
     * (meaning that the MC of the lanparm will be unlocked).  If the
     * config is supplied, it will be marked as unlocked.  When done,
     * the lanparm_clear_lock_cb method will be called on the handler
     * (second parm) with the following parms: <self> <lanparm> <err>.
     */
    int clear_lock(ipmi_lan_config_t *config = NULL, swig_cb *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, lanparm_clear_lock_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, lanparm_clear_lock_cb);
	}

	if (handler_val)
	    ipmi_lanparm_ref(self);
	rv = ipmi_lan_clear_lock(self, config,
				 lanparm_clear_lock, handler_val);
	if (rv && handler_val) {
	    ipmi_lanparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

%extend ipmi_lan_config_t {
    ~ipmi_lan_config_t()
    {
	ipmi_lan_free_config(self);
    }

    /*
     * Get a value from the lanconfig.  The first parameter is the
     * parm number, the second is the parm index (which is a pointer
     * to an integer).  The returned value will be undefined if
     * an error occurred, it will be of the format:
     *   "<name> <type> <data>"
     * The type and data will not be present if the data value is not
     * supported or the index is out of range, but the name will still
     * be present.
     *
     * The supports types are: integer, bool, data, ip, and mac.  The
     * data for an integer is a number.  The data for a bool is true
     * or false.  The data for ip is an IP address in the form
     * "n.n.n.n".  Data for mac is a mac address in the form
     * "nn:nn:nn:nn:nn:nn"
     *
     * The second parameter (the index) is zero based and should be
     * set to zero when fetching an index for the first time.  It will
     * be unchanged if the data item does not support multiple items.
     * If it does support multiple items, then the number will be
     * changed to the next supported value, or to -1 if this is the
     * last item.
     *
     * Be careful with the index, it must be a number, not something
     * that can be interpreted to a number.  If necessary, in perl,
     * you must do $idx = int($idx) in some cases.
     */
    %newobject get_val;
    char *get_val(int parm, int *index)
    {
	enum ipmi_lanconf_val_type_e valtype;
	unsigned int      ival = 0;
	unsigned char     *dval = NULL;
	unsigned int      dval_len = 0;
	const char        *name;
	char              dummy[1];
	char              *str = NULL, *s;
	int               rv;
	int               i;
	unsigned int      len;

	rv = ipmi_lanconfig_get_val(self, parm, &name, index, &valtype,
				    &ival, &dval, &dval_len);
	if ((rv == ENOSYS) || (rv == E2BIG))
	    return strdup(name);
	else if (rv)
	    return NULL;

	switch (valtype) {
	case IPMI_LANCONFIG_INT:
	    len = snprintf(dummy, 1, "%s integer %d", name, ival);
	    str = malloc(len + 1);
	    sprintf(str, "%s integer %d", name, ival);
	    break;
	    
	case IPMI_LANCONFIG_BOOL:
	    len = snprintf(dummy, 1, "%s bool %s", name,
			   ival ? "true" : "false");
	    str = malloc(len + 1);
	    sprintf(str, "%s bool %s", name, 
		    ival ? "true" : "false");
	    break;
	    
	case IPMI_LANCONFIG_DATA:
	    len = snprintf(dummy, 1, "%s data", name);
	    len += dval_len * 5;
	    str = malloc(len + 1);
	    s = str;
	    s += sprintf(s, "%s data", name);
	    for (i=0; i<dval_len; i++)
		s += sprintf(s, " 0x%2.2x", dval[i]);
	    break;

	case IPMI_LANCONFIG_IP:
	    len = snprintf(dummy, 1, "%s ip", name);
	    len += 4 * 4; /* worst case */
	    str = malloc(len + 1);
	    sprintf(str, "%s ip %d.%d.%d.%d", name,
		    dval[0], dval[1], dval[2], dval[3]);
	    break;

	case IPMI_LANCONFIG_MAC:
	    len = snprintf(dummy, 1, "%s mac", name);
	    len += 6 * 3;
	    str = malloc(len + 1);
	    s = str;
	    s += sprintf(s, "%s mac ", name);
	    for (i=0; i<5; i++)
		s += sprintf(s, "%2.2x:", dval[i]);
	    sprintf(s, "%2.2x", dval[i]);
	    break;
	}

	if (dval)
	    ipmi_lanconfig_data_free(dval);

	return str;
    }

    /*
     * Set a value in the lanconfig.  The first parameter is the parm
     * number, the second is the parm index.  The type is a string
     * in the third parm.  The data is the fourth parm.
     *
     * The supports types are: integer, bool, data, ip, and mac.  The
     * data for an integer is a number.  The data for a bool is true
     * or false.  The data for ip is an IP address in the form
     * "n.n.n.n".  Data for mac is a mac address in the form
     * "nn.nn.nn.nn.nn.nn"
     *
     * The index is ignored for types that do not use it.
     */
    int set_val(int parm, int idx, char *type, char *value) {
	enum ipmi_lanconf_val_type_e valtype;
	int               rv;
	unsigned int      ival = 0;
	unsigned char     *dval = NULL;
	unsigned int      dval_len = 0;

	rv = ipmi_lanconfig_parm_to_type(parm, &valtype);
	if (rv)
	    return rv;

	switch (valtype) {
	case IPMI_LANCONFIG_INT:
	{
	    char *endstr;
	    if (strcmp(type, "integer") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    if (*value == '\0')
		return EINVAL;
	    ival = strtol(value, &endstr, 0);
	    if (*endstr != '\0')
		return EINVAL;
	    break;
	}
	    
	case IPMI_LANCONFIG_BOOL:
	    if (strcmp(type, "bool") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    if (strcasecmp(value, "true") == 0)
		ival = 1;
	    else if (strcasecmp(value, "false") == 0)
		ival = 0;
	    else if (strcasecmp(value, "on") == 0)
		ival = 1;
	    else if (strcasecmp(value, "off") == 0)
		ival = 0;
	    else
		return EINVAL;
	    break;
	    
	case IPMI_LANCONFIG_DATA:
	    if (strcmp(type, "data") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    dval = parse_raw_str_data(value, &dval_len);
	    if (!dval)
		return ENOMEM;
	    break;

	case IPMI_LANCONFIG_IP:
	    {
		struct in_addr addr;
		if (strcmp(type, "ip") != 0)
		    return EINVAL;
		rv = parse_ip_addr(value, &addr);
		if (rv)
		    return rv;
		dval = malloc(4);
		memcpy(dval, &addr.s_addr, 4);
		dval_len = 4;
	    }
	    break;

	case IPMI_LANCONFIG_MAC:
	    if (strcmp(type, "mac") != 0)
		return EINVAL;
	    dval = malloc(6);
	    rv = parse_mac_addr(value, dval);
	    if (rv) {
		free(dval);
		return rv;
	    }
	    dval_len = 6;
	    break;
	}

	rv = ipmi_lanconfig_set_val(self, parm, idx, ival, dval, dval_len);
	if (dval)
	    free(dval);
	return rv;
    }
}

%extend ipmi_pef_t {
    ~ipmi_pef_t()
    {
	ipmi_pef_deref(self);
    }

    %newobject get_mc_id;
    ipmi_mcid_t *get_mc_id()
    {
	ipmi_mcid_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_pef_get_mc(self);
	return rv;
    }

%constant int PEFPARM_SET_IN_PROGRESS = IPMI_PEFPARM_SET_IN_PROGRESS;
%constant int PEFPARM_CONTROL = IPMI_PEFPARM_CONTROL;
%constant int PEFPARM_ACTION_GLOBAL_CONTROL = IPMI_PEFPARM_ACTION_GLOBAL_CONTROL;
%constant int PEFPARM_STARTUP_DELAY = IPMI_PEFPARM_STARTUP_DELAY;
%constant int PEFPARM_ALERT_STARTUP_DELAY = IPMI_PEFPARM_ALERT_STARTUP_DELAY;
%constant int PEFPARM_NUM_EVENT_FILTERS = IPMI_PEFPARM_NUM_EVENT_FILTERS;
%constant int PEFPARM_EVENT_FILTER_TABLE = IPMI_PEFPARM_EVENT_FILTER_TABLE;
%constant int PEFPARM_EVENT_FILTER_TABLE_DATA1 = IPMI_PEFPARM_EVENT_FILTER_TABLE_DATA1;
%constant int PEFPARM_NUM_ALERT_POLICIES = IPMI_PEFPARM_NUM_ALERT_POLICIES;
%constant int PEFPARM_ALERT_POLICY_TABLE = IPMI_PEFPARM_ALERT_POLICY_TABLE;
%constant int PEFPARM_SYSTEM_GUID = IPMI_PEFPARM_SYSTEM_GUID;
%constant int PEFPARM_NUM_ALERT_STRINGS = IPMI_PEFPARM_NUM_ALERT_STRINGS;
%constant int PEFPARM_ALERT_STRING_KEY = IPMI_PEFPARM_ALERT_STRING_KEY;
%constant int PEFPARM_ALERT_STRING = IPMI_PEFPARM_ALERT_STRING;

    /*
     * Fetch an individual parm from the MC.  The parameter (parm1) ,
     * and set (parm2) and block (parm3) are specified, along with a
     * handler (parm4).  The pef_got_parm_cb method on the handler
     * will be called when the the operation completes with the
     * following parms: <self> <pef> <err> <parm_rev> <data1> [<data2> ...]
     */
    int get_parm(int parm, int set, int block, swig_cb *handler)
    {
	int         rv;
	swig_cb_val *handler_val;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, pef_got_parm_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, pef_got_parm_cb);
	    ipmi_pef_ref(self);
	    rv = ipmi_pef_get_parm(self, parm, set, block, pef_get_parm,
				   handler_val);
	    if (rv) {
		ipmi_pef_deref(self);
		deref_swig_cb_val(handler_val);
	    }
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set an individual parm on the MC.  The parameter (parm1),
     * and string value (parm2) is specified, along with an optional
     * handler (parm3).  The pef_set_parm_cb method on the handler
     * will be called when the the operation completes with the
     * following parms: <self> <pef> <err>.
     *
     * The string value is in the form "0xNN 0xNN ...", basically
     * a string of integer values.
     */
    int set_parm(int parm, char *value, swig_cb *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	unsigned char        *data;
	unsigned int         length;

	IPMI_SWIG_C_CB_ENTRY
	data = parse_raw_str_data(value, &length);
	if (!data) {
	    rv = ENOMEM;
	    goto out_err;
	}

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, pef_set_parm_cb)) {
		free(data);
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, pef_set_parm_cb);
	}

	if (handler_val)
	    ipmi_pef_ref(self);
	rv = ipmi_pef_set_parm(self, parm, data, length,
			       pef_set_parm, handler_val);
	free(data);
	if (rv && handler_val) {
	    ipmi_pef_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set an individual parm on the MC.  The parameter (parm1), and
     * an array of integers (parm2) is specified, along with an
     * optional handler (parm3).  The pef_set_parm_cb method on
     * the handler will be called when the the operation completes
     * with the following parms: <self> <pef> <err>.
     *
     * The string value is in the form "0xNN 0xNN ...", basically
     * a string of integer values.
     */
    int set_parm_array(int parm, intarray value, swig_cb *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	unsigned char        *data;
	unsigned int         length = value.len;

	IPMI_SWIG_C_CB_ENTRY
	if (length == 0)
	    data = malloc(1);
	else
	    data = malloc(length);
	if (!data) {
	    rv = ENOMEM;
	    goto out_err;
	}
	parse_ipmi_data(value, data, length, &length);

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, pef_set_parm_cb)) {
		free(data);
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, pef_set_parm_cb);
	}

	if (handler_val)
	    ipmi_pef_ref(self);
	rv = ipmi_pef_set_parm(self, parm, data, length,
			       pef_set_parm, handler_val);
	free(data);
	if (rv && handler_val) {
	    ipmi_pef_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the full standard configuration for the pefs.  When
     * done, the pef_got_config_cb method will be called on the
     * handler (first parm) with the following parms: <self> <pef>
     * <err> <pefconfig>.  The pefconfig will be an object of type
     * ipmi_pef_config_t.
     */
    int get_config(swig_cb *handler)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, pef_got_config_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, pef_got_config_cb);

	    ipmi_pef_ref(self);
	    rv = ipmi_pef_get_config(self, pef_get_config, handler_val);
	    if (rv) {
		ipmi_pef_deref(self);
		deref_swig_cb_val(handler_val);
	    }
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
	
    }

    /*
     * Set the full standard configuration for the pefs.  The
     * config to set is the first parm of type ipmi_pef_config_t.  When
     * done, the pef_set_config_cb method will be called on the
     * handler (second parm) with the following parms: <self>
     * <pef> <err>.
     */
    int set_config(ipmi_pef_config_t *config, swig_cb *handler = NULL)
    {
	int                  rv;
	swig_cb_val          *handler_val = NULL;
	ipmi_pef_done_cb done = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, pef_set_config_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    done = pef_set_config;
	    handler_val = ref_swig_cb(handler, pef_set_config_cb);
	}

	if (handler_val)
	    ipmi_pef_ref(self);
	rv = ipmi_pef_set_config(self, config, done, handler_val);
	if (rv && handler_val) {
	    ipmi_pef_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Unlock the lock for the pef.  The config to set is the
     * first parm of type ipmi_pef_config_t and may be undefined
     * (meaning that the MC of the pef will be unlocked).  If the
     * config is supplied, it will be marked as unlocked.  When done,
     * the pef_clear_lock_cb method will be called on the handler
     * (second parm) with the following parms: <self> <pef> <err>.
     */
    int clear_lock(ipmi_pef_config_t *config = NULL, swig_cb *handler = NULL)
    {
	int         rv;
	swig_cb_val *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, pef_clear_lock_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, pef_clear_lock_cb);
	}

	if (handler_val)
	    ipmi_pef_ref(self);
	rv = ipmi_pef_clear_lock(self, config, pef_clear_lock, handler_val);
	if (rv && handler_val) {
	    ipmi_pef_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

%extend ipmi_pef_config_t {
    ~ipmi_pef_config_t()
    {
	ipmi_pef_free_config(self);
    }

    /*
     * Get a value from the pefconfig.  The first parameter is the
     * parm number, the second is the parm index (which is a pointer
     * to an integer).  The returned value will be undefined if
     * an error occurred, it will be of the format:
     *   "<name> <type> <data>"
     * The type and data will not be present if the data value is not
     * supported or the index is out of range, but the name will still
     * be present.
     *
     * The supports types are: integer, bool, data, and string.  The
     * data for an integer is a number.  The data for a bool is true
     * or false.  The data for string is a string, starting one space
     * after the string and going to the end of the returned valid
     *
     * The second parameter (the index) is zero based and should be
     * set to zero when fetching an index for the first time.  It will
     * be unchanged if the data item does not support multiple items.
     * If it does support multiple items, then the number will be
     * changed to the next supported value, or to -1 if this is the
     * last item.
     *
     * Be careful with the index, it must be a number, not something
     * that can be interpreted to a number.  If necessary, in perl,
     * you must do $idx = int($idx) in some cases.
     */
    %newobject get_val;
    char *get_val(int parm, int *index)
    {
	enum ipmi_pefconf_val_type_e valtype;
	unsigned int      ival = 0;
	unsigned char     *dval = NULL;
	unsigned int      dval_len = 0;
	const char        *name;
	char              dummy[1];
	char              *str = NULL, *s;
	int               rv;
	int               i;
	unsigned int      len;

	rv = ipmi_pefconfig_get_val(self, parm, &name, index, &valtype,
				    &ival, &dval, &dval_len);
	if ((rv == ENOSYS) || (rv == E2BIG))
	    return strdup(name);
	else if (rv)
	    return NULL;

	switch (valtype) {
	case IPMI_PEFCONFIG_INT:
	    len = snprintf(dummy, 1, "%s integer %d", name, ival);
	    str = malloc(len + 1);
	    sprintf(str, "%s integer %d", name, ival);
	    break;
	    
	case IPMI_PEFCONFIG_BOOL:
	    len = snprintf(dummy, 1, "%s bool %s", name,
			   ival ? "true" : "false");
	    str = malloc(len + 1);
	    sprintf(str, "%s bool %s", name, 
		    ival ? "true" : "false");
	    break;
	    
	case IPMI_PEFCONFIG_DATA:
	    len = snprintf(dummy, 1, "%s data", name);
	    len += dval_len * 5;
	    str = malloc(len + 1);
	    s = str;
	    s += sprintf(s, "%s data", name);
	    for (i=0; i<dval_len; i++)
		s += sprintf(s, " 0x%2.2x", dval[i]);
	    break;

	case IPMI_PEFCONFIG_STR:
	    len = snprintf(dummy, 1, "%s string %s", name, (char *) dval);
	    str = malloc(len + 1);
	    sprintf(str, "%s string %s", name, (char *) dval);
	    break;
	}

	if (dval)
	    ipmi_pefconfig_data_free(dval);

	return str;
    }

    /*
     * Set a value in the pefconfig.  The first parameter is the parm
     * number, the second is the parm index.  The type is a string
     * in the third parm.  The data is the fourth parm.
     *
     * The supports types are: integer, bool, data, and string.  The
     * data for an integer is a number.  The data for a bool is true
     * or false.  The data for string is just a string.
     *
     * The index is ignored for types that do not use it.
     */
    int set_val(int parm, int idx, char *type, char *value) {
	enum ipmi_pefconf_val_type_e valtype;
	int               rv;
	unsigned int      ival = 0;
	unsigned char     *dval = NULL;
	unsigned int      dval_len = 0;

	rv = ipmi_pefconfig_parm_to_type(parm, &valtype);
	if (rv)
	    return rv;

	switch (valtype) {
	case IPMI_PEFCONFIG_INT:
	{
	    char *endstr;
	    if (strcmp(type, "integer") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    if (*value == '\0')
		return EINVAL;
	    ival = strtol(value, &endstr, 0);
	    if (*endstr != '\0')
		return EINVAL;
	    break;
	}
	    
	case IPMI_PEFCONFIG_BOOL:
	    if (strcmp(type, "bool") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    if (strcasecmp(value, "true") == 0)
		ival = 1;
	    else if (strcasecmp(value, "false") == 0)
		ival = 0;
	    else if (strcasecmp(value, "on") == 0)
		ival = 1;
	    else if (strcasecmp(value, "off") == 0)
		ival = 0;
	    else
		return EINVAL;
	    break;
	    
	case IPMI_PEFCONFIG_DATA:
	    if (strcmp(type, "data") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    dval = parse_raw_str_data(value, &dval_len);
	    if (!dval)
		return ENOMEM;
	    break;

	case IPMI_PEFCONFIG_STR:
	    if (strcmp(type, "string") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    dval = (unsigned char *) strdup((char *) value);
	    if (!dval)
		return ENOMEM;
	    break;
	}

	rv = ipmi_pefconfig_set_val(self, parm, idx, ival, dval, dval_len);
	if (dval)
	    free(dval);
	return rv;
    }
}

%extend ipmi_pet_t {
    ~ipmi_pet_t()
    {
	ipmi_pet_deref(self);
    }

    %newobject get_mc_id;
    ipmi_mcid_t *get_mc_id()
    {
	ipmi_mcid_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_pet_get_mc_id(self);
	return rv;
    }

    int get_channel()
    {
	return ipmi_pet_get_channel(self);
    }

    %newobject get_ip_addr;
    char *get_ip_addr()
    {
	struct in_addr ip;
	char           *dval = malloc(16);
	unsigned char  d[4];

	if (!dval)
	    return NULL;
	ipmi_pet_get_ip_addr(self, &ip);
	d[0] = (ip.s_addr >> 24) & 0xff;
	d[1] = (ip.s_addr >> 16) & 0xff;
	d[2] = (ip.s_addr >> 8) & 0xff;
	d[3] = (ip.s_addr >> 0) & 0xff;
	sprintf(dval, "%d.%d.%d.%d", d[0], d[1], d[2], d[3]);
	return dval;
    }

    %newobject get_mac_addr;
    char *get_mac_addr()
    {
	char          *dval = malloc(18);
	unsigned char d[6];

	if (!dval)
	    return NULL;
	ipmi_pet_get_mac_addr(self, d);
	sprintf(dval, "%d:%d:%d:%d:%d:%d", d[0], d[1], d[2], d[3], d[4], d[5]);
	return dval;
    }

    int get_eft_sel()
    {
	return ipmi_pet_get_eft_sel(self);
    }

    int get_policy_num()
    {
	return ipmi_pet_get_policy_num(self);
    }
    
    int get_apt_sel()
    {
	return ipmi_pet_get_apt_sel(self);
    }
    
    int get_lan_dest_sel()
    {
	return ipmi_pet_get_lan_dest_sel(self);
    }
}

%newobject alloc_cmdlang;
/*
 * Allocate a command language handler for use by the interpreted
 * language.  This allows commands to be entered and the responses
 * received by the handler object passed in.  The handler object must
 * implement a large number of methods:
 *
 * cmdlang_out - Normal output of a name/value pair.  Has the following
 *  parameters: <self> <cmdlang> <name> <value>
 *
 * cmdlang_out_binary - Output binary information.  Has the following
 *  parameters: <self> <cmdlang> <name> <val1> [<val2> ...] where the
 *  values are either a list of parameters or an array of integer
 *  values (depending on the language).
 *
 * cmdlang_out_unicode - Output a unicode string.  Has the following
 *  parameters: <self> <cmdlang> <name> <val1> [<val2> ...] where the
 *  values are either a list of parameters or an array of integer
 *  values (depending on the language).
 *
 * cmdlang_down - increase the nesting level of the output.  Takes
 *  the following parameters: <self> <cmdlang>.

 * cmdlang_up - decrease the nesting level of the output.  Takes
 *  the following parameters: <self> <cmdlang>.
 *
 * cmdlang_done - Execution of a command is complete.  This will be
 * called after every handled command so the upper layer will know
 * when a new command can be entered..  Takes the following
 * parameters: <self> <cmdlang>.
 */
ipmi_cmdlang_t *alloc_cmdlang(swig_cb *handler);

/*
 * Enable or disable full information for events registers with
 * set_cmdlang_event_handler.  Normally (with this set to false) only
 * minimal event information is printed.  With this set to true, all
 * information about the object the event occurs for is printed.
 */
void cmdlang_set_evinfo(int evinfo);

/* 
 * Get the event info flag value.
 */
int cmdlang_get_evinfo(void);

/*
 * Set an error handler for handling "global" errors from the OpenIPMI
 * command language.  Basically, these are errors that are note
 * related to any specific command handler.  The handler has the
 * global_cmdlang_err method called on it with the following parms:
 * <self>
 * <objstr> - The name of the object associated with the error.  May
 * be empty.
 * <location> - The location (in the source code) where the error was
 * generated.  May be empty.
 * <errstr> - The error string generated.
 * <errval> - an integer value for the error.
 */
void set_cmdlang_global_err_handler(swig_cb *handler);

/*
 * Handle event from the cmdlang interface.  These are basically
 * events that occur asyncronously and are thus not associated with
 * any specific cmdlang handler.  The handler's cmdlang_event method
 * will be called with the following parameters: <self> <event>.  The
 * event is of the type ipmi_cmdlang_event_t.
 */
void set_cmdlang_event_handler(swig_cb *handler);


%{
    static void cmdlang_set_evinfo(int evinfo)
    {
	ipmi_cmdlang_set_evinfo(evinfo);
    }

    static int cmdlang_get_evinfo(void)
    {
	return ipmi_cmdlang_get_evinfo();
    }

    static void cmdlang_down(ipmi_cmdlang_t *info)
    {
	swig_cb_val *cb = info->user_data;
	swig_ref    ref = swig_make_ref(info, ipmi_cmdlang_t);

	swig_call_cb(cb, "cmdlang_down", "%p", &ref);
	swig_free_ref(ref);
    }

    static void cmdlang_up(ipmi_cmdlang_t *info)
    {
	swig_cb_val *cb = info->user_data;
	swig_ref    ref = swig_make_ref(info, ipmi_cmdlang_t);

	swig_call_cb(cb, "cmdlang_up", "%p", &ref);
	swig_free_ref(ref);
    }

    static void cmdlang_done(ipmi_cmdlang_t *info)
    {
	swig_cb_val *cb = info->user_data;
	swig_ref    ref = swig_make_ref(info, ipmi_cmdlang_t);

	swig_call_cb(cb, "cmdlang_done", "%p", &ref);
	swig_free_ref(ref);

	/* Clean up the cmdlang information */
	if (info->errstr_dynalloc)
	    ipmi_mem_free(info->errstr);
	info->errstr_dynalloc = 0;
	info->errstr = NULL;
	info->objstr[0] = '\0';
	info->err = 0;
    }

    static void cmdlang_out(ipmi_cmdlang_t *info,
			    const char     *name,
			    const char     *value)
    {
	swig_cb_val *cb = info->user_data;
	swig_ref    ref = swig_make_ref(info, ipmi_cmdlang_t);

	if (!value)
	    value = "";
	swig_call_cb(cb, "cmdlang_out", "%p%s%s", &ref, name, value);
	swig_free_ref(ref);
    }

    static void cmdlang_out_binary(ipmi_cmdlang_t *info,
				   const char     *name,
				   const char     *value,
				   unsigned int   len)
    {
	swig_cb_val *cb = info->user_data;
	swig_ref    ref = swig_make_ref(info, ipmi_cmdlang_t);

	swig_call_cb(cb, "cmdlang_out_binary", "%p%s%*s", &ref, name,
		     len, value);
	swig_free_ref(ref);
    }
    
    static void cmdlang_out_unicode(ipmi_cmdlang_t *info,
				    const char     *name,
				    const char     *value,
				    unsigned int   len)
    {
	swig_cb_val *cb = info->user_data;
	swig_ref    ref = swig_make_ref(info, ipmi_cmdlang_t);

	swig_call_cb(cb, "cmdlang_out_unicode", "%p%s%*s", &ref, name,
		     len, value);
	swig_free_ref(ref);
    }

    static ipmi_cmdlang_t *
    alloc_cmdlang(swig_cb *handler)
    {
	ipmi_cmdlang_t *cmdlang = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (nil_swig_cb(handler))
	    goto out;

	if (!valid_swig_cb(handler, cmdlang_out))
	    goto out;
	if (!valid_swig_cb(handler, cmdlang_out_binary))
	    goto out;
	if (!valid_swig_cb(handler, cmdlang_out_unicode))
	    goto out;
	if (!valid_swig_cb(handler, cmdlang_down))
	    goto out;
	if (!valid_swig_cb(handler, cmdlang_up))
	    goto out;
	if (!valid_swig_cb(handler, cmdlang_done))
	    goto out;

	cmdlang = malloc(sizeof(*cmdlang));
	if (!cmdlang)
	    goto out;
	memset(cmdlang, 0, sizeof(*cmdlang));

	cmdlang->out = cmdlang_out;
	cmdlang->down = cmdlang_down;
	cmdlang->up = cmdlang_up;
	cmdlang->done = cmdlang_done;
	cmdlang->out_binary = cmdlang_out_binary;
	cmdlang->out_unicode = cmdlang_out_unicode;

	cmdlang->os_hnd = swig_os_hnd;

	cmdlang->objstr = malloc(IPMI_MAX_NAME_LEN);
	if (!cmdlang->objstr) {
	    free(cmdlang);
	    cmdlang = NULL;
	    goto out;
	}
	cmdlang->objstr[0] = '\0';
	cmdlang->objstr_len = IPMI_MAX_NAME_LEN;

	cmdlang->user_data = ref_swig_gencb(handler);

    out:
	IPMI_SWIG_C_CB_EXIT
	return cmdlang;
    }

    swig_cb_val *cmdlang_global_err_handler = NULL;

    static void cmdlang_global_err(char *objstr,
				   char *location,
				   char *errstr,
				   int  errval)
    {
	swig_cb_val *handler = cmdlang_global_err_handler;

	if (!objstr)
	    objstr = "";
	if (!location)
	    location = "";
	if (! handler) {
	    fprintf(stderr, "Global IPMI cmdlang error: %s(%s): %s (%d)\n",
		    objstr, location, errstr, errval);
	} else {
	    swig_call_cb(handler,
			 "global_cmdlang_err",
			 "%s%s%s%d", objstr, location, errstr, errval);
	}
    }

    swig_cb_val *cmdlang_event_handler = NULL;

    static void cmdlang_report_event(ipmi_cmdlang_event_t *event)
    {
	swig_ref event_ref;
	swig_cb_val *handler = cmdlang_event_handler;

	if (! handler)
	    return;

	event_ref = swig_make_ref(event, ipmi_cmdlang_event_t);
	swig_call_cb(handler, "cmdlang_event", "%p", &event_ref);
	/* User shouldn't keep these around. */
	swig_free_ref_check(event_ref, ipmi_cmdlang_event_t);
    }

    void set_cmdlang_global_err_handler(swig_cb *handler)
    {
	swig_cb_val *old_handler = cmdlang_global_err_handler;
	IPMI_SWIG_C_CB_ENTRY
	ipmi_cmdlang_err_rpt = cmdlang_global_err;
	if (valid_swig_cb(handler, global_cmdlang_err))
	    cmdlang_global_err_handler = ref_swig_cb(handler,
						     global_cmdlang_err);
	else
	    cmdlang_global_err_handler = NULL;
	if (old_handler)
	    deref_swig_cb_val(old_handler);
	IPMI_SWIG_C_CB_EXIT
    }

    void set_cmdlang_event_handler(swig_cb *handler)
    {
	swig_cb_val *old_handler = cmdlang_event_handler;
	IPMI_SWIG_C_CB_ENTRY
	ipmi_cmdlang_event_rpt = cmdlang_report_event;
	if (valid_swig_cb(handler, cmdlang_event))
	    cmdlang_event_handler = ref_swig_cb(handler, cmdlang_event);
	else
	    cmdlang_event_handler = NULL;
	if (old_handler)
	    deref_swig_cb_val(old_handler);
	IPMI_SWIG_C_CB_EXIT
    }
%}


%extend ipmi_cmdlang_t {
    ~ipmi_cmdlang_t()
    {
	swig_cb_val *handler_val = self->user_data;

	IPMI_SWIG_C_CB_ENTRY
	if (handler_val)
	    deref_swig_cb_val(handler_val);
	if (self->objstr)
	    free(self->objstr);
	free(self);
	IPMI_SWIG_C_CB_EXIT
    }

    /*
     * Process a command for the command language.
     */
    void handle(const char *icmd)
    {
	char *cmd = strdup(icmd);

	IPMI_SWIG_C_CB_ENTRY
	ipmi_cmdlang_handle(self, cmd);
	IPMI_SWIG_C_CB_EXIT
    }

    /* 
     * When outputting, tells if this is help output.
     */
    int is_help()
    {
	return self->help;
    }

    /* 
     * When outputting, gets the error value, or 0 if there was no
     * error.
     */
    int get_err()
    {
	return self->err;
    }

    %newobject get_errstr;
    /*
     * If there was an error, get the error string.
     */
    char *get_errstr()
    {
	return strdup(self->errstr);
    }

    /*
     * If there was an error, get the object name associated with the error.
     */
    %newobject get_objstr;
    char *get_objstr()
    {
	return strdup(self->objstr);
    }

    /*
     * If there was an error, get the location in the source code
     * where the error was generated.
     */
    %newobject get_location;
    char *get_location()
    {
	return strdup(self->location);
    }
}

/*
 * A cmdlang event is a series of name/value fields that may be
 * fetched in sequence.
 */
%extend ipmi_cmdlang_event_t {
    ~ipmi_cmdlang_event_t()
    {
	/* Nothing to do. */
    }

    /*
     * Restart with the first field.
     */
    void restart()
    {
	ipmi_cmdlang_event_restart(self);
    }

    /*
     * Get the values of the next field.  The level is the nesting
     * level, the type is either "string", "binary", or "unicode", the
     * name is the name of the field, and value is its value.  binary
     * and unicode are returned as a string of hex values (0xnn 0xnn ...).
     */
    int next_field(unsigned int *level,
		   const char   **type,
		   char         **name,
		   char         **value)
    {
	int rv;
	unsigned int len;
	char         *n, *v;
	char         *np, *vp;
	enum ipmi_cmdlang_out_types t;
	char         *tp;
	int          i;
	char         *s;

	rv = ipmi_cmdlang_event_next_field(self, level, &t, &n, &len, &v);
	if (!rv) {
	    *type = "";
	    *name = NULL;
	    *value = NULL;
	    return rv;
	}

	if (!v)
	    v = "";

	np = strdup(n);
	if (!np)
	    return ENOMEM;

	switch (t) {
	case IPMI_CMDLANG_STRING:
	    tp = "string";
	    vp = strdup(v);
	    break;
	case IPMI_CMDLANG_BINARY:
	    tp = "binary";
	    vp = malloc(len * 5);
	    if (!vp)
		break;
	    s = vp;
	    if (len > 0)
		s += sprintf(s, "0x%2.2x", (unsigned char) v[0]);
	    for (i=1; i<len; i++)
		s += sprintf(s, " 0x%2.2x", (unsigned char) v[i]);
	    break;
	case IPMI_CMDLANG_UNICODE:
	    tp = "unicode";
	    vp = malloc(len * 5);
	    if (!vp)
		break;
	    s = vp;
	    if (len > 0)
		s += sprintf(s, "0x%2.2x", (unsigned char) v[0]);
	    for (i=1; i<len; i++)
		s += sprintf(s, " 0x%2.2x", (unsigned char) v[i]);
	    break;
	default:
	    free(np);
	    return EINVAL;
	}

	if (!vp) {
	    free(np);
	    return ENOMEM;
	}

	*name = np;
	*value = vp;
	*type = tp;

	return 1;
    }
}

%{
static char *sol_state_string(int val)
{
    switch (val) {
    case ipmi_sol_state_closed:
	return "closed";
    case ipmi_sol_state_connecting:
	return "connecting";
    case ipmi_sol_state_connected:
	return "connected";
    case ipmi_sol_state_connected_ctu:
	return "connected no char xfer";
    case ipmi_sol_state_closing:
	return "closing";
    default:
	return "unknown";
    }
}
%}
char *sol_state_string(int val);

%extend ipmi_sol_conn_t
{
    ~ipmi_sol_conn_t()
    {
	ipmi_sol_free(self);
    }

%constant int sol_state_closed = ipmi_sol_state_closed;
%constant int sol_state_connecting = ipmi_sol_state_connecting;
%constant int sol_state_connected = ipmi_sol_state_connected;
%constant int sol_state_connected_ctu = ipmi_sol_state_connected_ctu;
%constant int sol_state_closing = ipmi_sol_state_closing;

    void set_ACK_timeout(int timeout_usec)
    {
	ipmi_sol_set_ACK_timeout(self, timeout_usec);
    }

    int get_ACK_timeout()
    {
	return ipmi_sol_get_ACK_timeout(self);
    }

    void set_ACK_retries(int retries)
    {
	ipmi_sol_set_ACK_retries(self, retries);
    }

    int get_ACK_retries()
    {
	return ipmi_sol_get_ACK_retries(self);
    }

    int set_use_authentication(int use_authentication)
    {
	return ipmi_sol_set_use_authentication(self, use_authentication);
    }

    int get_use_authentication()
    {
	return ipmi_sol_get_use_authentication(self);
    }

    int set_use_encryption(int use_encryption)
    {
	return ipmi_sol_set_use_encryption(self, use_encryption);
    }

    int get_use_encryption()
    {
	return ipmi_sol_get_use_encryption(self);
    }


%constant int sol_serial_alerts_fail = ipmi_sol_serial_alerts_fail;
%constant int sol_serial_alerts_deferred = ipmi_sol_serial_alerts_deferred;
%constant int sol_serial_alerts_succeed = ipmi_sol_serial_alerts_succeed;

    int set_shared_serial_alert_behavior(int behavior)
    {
	return ipmi_sol_set_shared_serial_alert_behavior(self, behavior);
    }

    int get_shared_serial_alert_behavior()
    {
	return ipmi_sol_get_shared_serial_alert_behavior(self);
    }

    int set_deassert_CTS_DCD_DSR_on_connect(int assert)
    {
	return ipmi_sol_set_deassert_CTS_DCD_DSR_on_connect(self, assert);
    }

    int get_deassert_CTS_DCD_DSR_on_connect()
    {
	return ipmi_sol_get_deassert_CTS_DCD_DSR_on_connect(self);
    }


%constant int SOL_BIT_RATE_DEFAULT = IPMI_SOL_BIT_RATE_DEFAULT;
%constant int SOL_BIT_RATE_9600 = IPMI_SOL_BIT_RATE_9600;
%constant int SOL_BIT_RATE_19200 = IPMI_SOL_BIT_RATE_19200;
%constant int SOL_BIT_RATE_38400 = IPMI_SOL_BIT_RATE_38400;
%constant int SOL_BIT_RATE_57600 = IPMI_SOL_BIT_RATE_57600;
%constant int SOL_BIT_RATE_115200 = IPMI_SOL_BIT_RATE_115200;

    int set_bit_rate(unsigned int rate)
    {
	return ipmi_sol_set_bit_rate(self, rate);
    }

    unsigned int get_bit_rate()
    {
	return ipmi_sol_get_bit_rate(self);
    }


    int open()
    {
	int rv;
	IPMI_SWIG_C_CB_ENTRY
	rv = ipmi_sol_open(self);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    int close()
    {
	int rv;
	IPMI_SWIG_C_CB_ENTRY
	rv = ipmi_sol_close(self);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    int force_close()
    {
	int rv;
	IPMI_SWIG_C_CB_ENTRY
	rv = ipmi_sol_force_close(self);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Write the given buffer to the serial port.  When complete, the
     * sol_write_complete method of the handler will be called with
     * the following parameters: <self> <conn> <error>
     */
    int write(charbuf buf, swig_cb *handler = NULL)
    {
	ipmi_sol_transmit_complete_cb cb = NULL;
	swig_cb_val                   *handler_val = NULL;
	int                           rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sol_write_complete)) {
		rv = EINVAL;
		goto out_err;
	    }
	    cb = sol_write_complete_cb;
	    handler_val = ref_swig_cb(handler, sol_write_complete);
	}
	rv = ipmi_sol_write(self, buf.val, buf.len, cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * For every NACK returned from the receive routine, this function
     * must be called to release the NACK.
     */
    int release_nack()
    {
	int rv;
	IPMI_SWIG_C_CB_ENTRY
	rv = ipmi_sol_release_nack(self);
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Send a break to the serial port.  When complete, the
     * sol_send_break method of the handler will be called with
     * the following parameters: <self> <conn> <error>
     */
    int send_break(swig_cb *handler = NULL)
    {
	ipmi_sol_transmit_complete_cb cb = NULL;
	swig_cb_val                   *handler_val = NULL;
	int                           rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sol_send_break)) {
		rv = EINVAL;
		goto out_err;
	    }
	    cb = sol_send_break_cb;
	    handler_val = ref_swig_cb(handler, sol_send_break);
	}
	rv = ipmi_sol_send_break(self, cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Send CTS assertable (or not) on the serial port.  When
     * complete, the sol_set_CTS_assertable method of the handler will
     * be called with the following parameters: <self> <conn> <error>
     */
    int set_CTS_assertable(int asserted, swig_cb *handler = NULL)
    {
	ipmi_sol_transmit_complete_cb cb = NULL;
	swig_cb_val                   *handler_val = NULL;
	int                           rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sol_set_CTS_assertable)) {
		rv = EINVAL;
		goto out_err;
	    }
	    cb = sol_set_CTS_assertable_cb;
	    handler_val = ref_swig_cb(handler, sol_set_CTS_assertable);
	}
	rv = ipmi_sol_set_CTS_assertable(self, asserted, cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Assert or deassert DCD and DSR on the serial port.  When
     * complete, the sol_set_DCD_DSR_asserted method of the handler
     * will be called with the following parameters: <self> <conn>
     * <error>
     */
    int set_DCD_DSR_asserted(int asserted, swig_cb *handler = NULL)
    {
	ipmi_sol_transmit_complete_cb cb = NULL;
	swig_cb_val                   *handler_val = NULL;
	int                           rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sol_set_DCD_DSR_asserted)) {
		rv = EINVAL;
		goto out_err;
	    }
	    cb = sol_set_DCD_DSR_asserted_cb;
	    handler_val = ref_swig_cb(handler, sol_set_DCD_DSR_asserted);
	}
	rv = ipmi_sol_set_DCD_DSR_asserted(self, asserted, cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Assert or deassert RI on the serial port.  When complete, the
     * sol_set_RI_asserted method of the handler will be called with
     * the following parameters: <self> <conn> <error>
     */
    int set_RI_asserted(int asserted, swig_cb *handler = NULL)
    {
	ipmi_sol_transmit_complete_cb cb = NULL;
	swig_cb_val                   *handler_val = NULL;
	int                           rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sol_set_RI_asserted)) {
		rv = EINVAL;
		goto out_err;
	    }
	    cb = sol_set_RI_asserted_cb;
	    handler_val = ref_swig_cb(handler, sol_set_RI_asserted);
	}
	rv = ipmi_sol_set_RI_asserted(self, asserted, cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }


%constant int SOL_BMC_TRANSMIT_QUEUE = IPMI_SOL_BMC_TRANSMIT_QUEUE;
%constant int SOL_BMC_RECEIVE_QUEUE = IPMI_SOL_BMC_RECEIVE_QUEUE;
%constant int SOL_MANAGEMENT_CONSOLE_TRANSMIT_QUEUE = IPMI_SOL_MANAGEMENT_CONSOLE_TRANSMIT_QUEUE;
%constant int SOL_MANAGEMENT_CONSOLE_RECEIVE_QUEUE = IPMI_SOL_MANAGEMENT_CONSOLE_RECEIVE_QUEUE;
%constant int SOL_BMC_QUEUES = IPMI_SOL_BMC_QUEUES;
%constant int SOL_MANAGEMENT_CONSOLE_QUEUES = IPMI_SOL_MANAGEMENT_CONSOLE_QUEUES;
%constant int SOL_ALL_QUEUES = IPMI_SOL_ALL_QUEUES;

    /*
     * Flush the given queues, as specified by the queue selectors
     * above.  When complete, the sol_flush_complete method of the
     * handler will be called with the following parameters: <self>
     * <conn> <queue selectors> <error>
     */
    int flush(int queue_selectors, swig_cb *handler = NULL)
    {
	ipmi_sol_flush_complete_cb cb = NULL;
	swig_cb_val                *handler_val = NULL;
	int                        rv;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, sol_flush_complete)) {
		rv = EINVAL;
		goto out_err;
	    }
	    cb = sol_flush_complete_cb;
	    handler_val = ref_swig_cb(handler, sol_flush_complete);
	}
	rv = ipmi_sol_flush(self, queue_selectors, cb, handler_val);
	if (rv && handler_val)
	    deref_swig_cb_val(handler_val);
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

}

%extend ipmi_solparm_t {
    ~ipmi_solparm_t()
    {
	ipmi_solparm_deref(self);
    }

    %newobject get_mc_id;
    ipmi_mcid_t *get_mc_id()
    {
	ipmi_mcid_t *rv = malloc(sizeof(*rv));
	if (rv)
	    *rv = ipmi_solparm_get_mc_id(self);
	return rv;
    }

    int get_channel()
    {
	return ipmi_solparm_get_channel(self);
    }

%constant int SOLPARM_SET_IN_PROGRESS = IPMI_SOLPARM_SET_IN_PROGRESS;
%constant int SOLPARM_ENABLE = IPMI_SOLPARM_ENABLE;
%constant int SOLPARM_AUTHENTICATION = IPMI_SOLPARM_AUTHENTICATION;
%constant int SOLPARM_CHAR_SETTINGS = IPMI_SOLPARM_CHAR_SETTINGS;
%constant int SOLPARM_RETRY = IPMI_SOLPARM_RETRY;
%constant int SOLPARM_NONVOLATILE_BITRATE = IPMI_SOLPARM_NONVOLATILE_BITRATE;
%constant int SOLPARM_VOLATILE_BITRATE = IPMI_SOLPARM_VOLATILE_BITRATE;
%constant int SOLPARM_PAYLOAD_CHANNEL = IPMI_SOLPARM_PAYLOAD_CHANNEL;
%constant int SOLPARM_PAYLOAD_PORT_NUMBER = IPMI_SOLPARM_PAYLOAD_PORT_NUMBER;

    /*
     * Fetch an individual parm from the MC.  The parameter (parm1) ,
     * and set (parm2) and block (parm3) are specified, along with a
     * handler (parm4).  The solparm_got_parm_cb method on the handler
     * will be called when the the operation completes with the
     * following parms: <self> <solparm> <err> <parm_rev> <data1> [<data2> ...]
     */
    int get_parm(int parm, int set, int block, swig_cb *handler)
    {
	int         rv;
	swig_cb_val *handler_val;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, solparm_got_parm_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, solparm_got_parm_cb);
	    ipmi_solparm_ref(self);
	    rv = ipmi_solparm_get_parm(self, parm, set, block,
				       solparm_get_parm, handler_val);
	    if (rv) {
		ipmi_solparm_deref(self);
		deref_swig_cb_val(handler_val);
	    }
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set an individual parm on the MC.  The parameter (parm1),
     * and string value (parm2) is specified, along with an optional
     * handler (parm3).  The solparm_set_parm_cb method on the handler
     * will be called when the the operation completes with the
     * following parms: <self> <solparm> <err>.
     *
     * The string value is in the form "0xNN 0xNN ...", basically
     * a string of integer values.
     */
    int set_parm(int parm, char *value, swig_cb *handler = NULL)
    {
	int           rv;
	swig_cb_val   *handler_val = NULL;
	unsigned char *data;
	unsigned int  length;

	IPMI_SWIG_C_CB_ENTRY
	data = parse_raw_str_data(value, &length);
	if (!data) {
	    rv = ENOMEM;
	    goto out_err;
	}

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, solparm_set_parm_cb)) {
		free(data);
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, solparm_set_parm_cb);
	}

	if (handler_val)
	    ipmi_solparm_ref(self);
	rv = ipmi_solparm_set_parm(self, parm, data, length,
				   solparm_set_parm, handler_val);
	free(data);
	if (rv && handler_val) {
	    ipmi_solparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Set an individual parm on the MC.  The parameter (parm1), and
     * an array of integers (parm2) is specified, along with an
     * optional handler (parm3).  The solparm_set_parm_cb method on
     * the handler will be called when the the operation completes
     * with the following parms: <self> <solparm> <err>.
     *
     * The string value is in the form "0xNN 0xNN ...", basically
     * a string of integer values.
     */
    int set_parm_array(int parm, intarray value, swig_cb *handler = NULL)
    {
	int           rv;
	swig_cb_val   *handler_val = NULL;
	unsigned char *data;
	unsigned int  length = value.len;

	IPMI_SWIG_C_CB_ENTRY
	if (length == 0)
	    data = malloc(1);
	else
	    data = malloc(length);
	if (!data) {
	    rv = ENOMEM;
	    goto out_err;
	}
	parse_ipmi_data(value, data, length, &length);

	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, solparm_set_parm_cb)) {
		free(data);
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, solparm_set_parm_cb);
	}

	if (handler_val)
	    ipmi_solparm_ref(self);
	rv = ipmi_solparm_set_parm(self, parm, data, length,
				   solparm_set_parm, handler_val);
	free(data);
	if (rv && handler_val) {
	    ipmi_solparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Get the full standard configuration for the solparms.  When
     * done, the solparm_got_config_cb method will be called on the
     * handler (first parm) with the following parms: <self> <solparm>
     * <err> <solconfig>.  The solconfig will be an object of type
     * ipmi_sol_config_t.
     */
    int get_config(swig_cb *handler)
    {
	int         rv;
	swig_cb_val *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!valid_swig_cb(handler, solparm_got_config_cb))
	    rv = EINVAL;
	else {
	    handler_val = ref_swig_cb(handler, solparm_got_config_cb);

	    ipmi_solparm_ref(self);
	    rv = ipmi_sol_get_config(self, solparm_get_config, handler_val);
	    if (rv) {
		ipmi_solparm_deref(self);
		deref_swig_cb_val(handler_val);
	    }
	}
	IPMI_SWIG_C_CB_EXIT
	return rv;
	
    }

    /*
     * Set the full standard configuration for the solparms.  The
     * config to set is the first parm of type ipmi_sol_config_t.  When
     * done, the solparm_set_config_cb method will be called on the
     * handler (second parm) with the following parms: <self>
     * <solparm> <err>.
     */
    int set_config(ipmi_sol_config_t *config, swig_cb *handler = NULL)
    {
	int         rv;
	swig_cb_val *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, solparm_set_config_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, solparm_set_config_cb);
	}

	if (handler_val)
	    ipmi_solparm_ref(self);
	rv = ipmi_sol_set_config(self, config,
				 solparm_set_config, handler_val);
	if (rv && handler_val) {
	    ipmi_solparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }

    /*
     * Unlock the lock for the solparm.  The config to set is the
     * first parm of type ipmi_sol_config_t and may be undefined
     * (meaning that the MC of the solparm will be unlocked).  If the
     * config is supplied, it will be marked as unlocked.  When done,
     * the solparm_clear_lock_cb method will be called on the handler
     * (second parm) with the following parms: <self> <solparm> <err>.
     */
    int clear_lock(ipmi_sol_config_t *config = NULL, swig_cb *handler = NULL)
    {
	int         rv;
	swig_cb_val *handler_val = NULL;

	IPMI_SWIG_C_CB_ENTRY
	if (!nil_swig_cb(handler)) {
	    if (! valid_swig_cb(handler, solparm_clear_lock_cb)) {
		rv = EINVAL;
		goto out_err;
	    }
	    handler_val = ref_swig_cb(handler, solparm_clear_lock_cb);
	}

	if (handler_val)
	    ipmi_solparm_ref(self);
	rv = ipmi_sol_clear_lock(self, config,
				 solparm_clear_lock, handler_val);
	if (rv && handler_val) {
	    ipmi_solparm_deref(self);
	    deref_swig_cb_val(handler_val);
	}
    out_err:
	IPMI_SWIG_C_CB_EXIT
	return rv;
    }
}

%extend ipmi_sol_config_t {
    ~ipmi_sol_config_t()
    {
	ipmi_sol_free_config(self);
    }

    /*
     * Get a value from the solconfig.  The first parameter is the
     * parm number, the second is the parm index (which is a pointer
     * to an integer).  The returned value will be undefined if
     * an error occurred, it will be of the format:
     *   "<name> <type> <data>"
     * The type and data will not be present if the data value is not
     * supported or the index is out of range, but the name will still
     * be present.
     *
     * The supports types are: integer, bool, data, ip, and mac.  The
     * data for an integer is a number.  The data for a bool is true
     * or false.  The data for ip is an IP address in the form
     * "n.n.n.n".  Data for mac is a mac address in the form
     * "nn:nn:nn:nn:nn:nn"
     *
     * The second parameter (the index) is zero based and should be
     * set to zero when fetching an index for the first time.  It will
     * be unchanged if the data item does not support multiple items.
     * If it does support multiple items, then the number will be
     * changed to the next supported value, or to -1 if this is the
     * last item.
     *
     * Be careful with the index, it must be a number, not something
     * that can be interpreted to a number.  If necessary, in perl,
     * you must do $idx = int($idx) in some cases.
     */
    %newobject get_val;
    char *get_val(int parm, int *index)
    {
	enum ipmi_solconf_val_type_e valtype;
	unsigned int      ival = 0;
	unsigned char     *dval = NULL;
	unsigned int      dval_len = 0;
	const char        *name;
	char              dummy[1];
	char              *str = NULL, *s;
	int               rv;
	int               i;
	unsigned int      len;

	rv = ipmi_solconfig_get_val(self, parm, &name, index, &valtype,
				    &ival, &dval, &dval_len);
	if ((rv == ENOSYS) || (rv == E2BIG))
	    return strdup(name);
	else if (rv)
	    return NULL;

	switch (valtype) {
	case IPMI_SOLCONFIG_INT:
	    len = snprintf(dummy, 1, "%s integer %d", name, ival);
	    str = malloc(len + 1);
	    sprintf(str, "%s integer %d", name, ival);
	    break;
	    
	case IPMI_SOLCONFIG_BOOL:
	    len = snprintf(dummy, 1, "%s bool %s", name,
			   ival ? "true" : "false");
	    str = malloc(len + 1);
	    sprintf(str, "%s bool %s", name, 
		    ival ? "true" : "false");
	    break;
	    
	case IPMI_SOLCONFIG_DATA:
	    len = snprintf(dummy, 1, "%s data", name);
	    len += dval_len * 5;
	    str = malloc(len + 1);
	    s = str;
	    s += sprintf(s, "%s data", name);
	    for (i=0; i<dval_len; i++)
		s += sprintf(s, " 0x%2.2x", dval[i]);
	    break;

	case IPMI_SOLCONFIG_IP:
	    len = snprintf(dummy, 1, "%s ip", name);
	    len += 4 * 4; /* worst case */
	    str = malloc(len + 1);
	    sprintf(str, "%s ip %d.%d.%d.%d", name,
		    dval[0], dval[1], dval[2], dval[3]);
	    break;

	case IPMI_SOLCONFIG_MAC:
	    len = snprintf(dummy, 1, "%s mac", name);
	    len += 6 * 3;
	    str = malloc(len + 1);
	    s = str;
	    s += sprintf(s, "%s mac ", name);
	    for (i=0; i<5; i++)
		s += sprintf(s, "%2.2x:", dval[i]);
	    sprintf(s, "%2.2x", dval[i]);
	    break;
	}

	if (dval)
	    ipmi_solconfig_data_free(dval);

	return str;
    }

    /*
     * Set a value in the solconfig.  The first parameter is the parm
     * number, the second is the parm index.  The type is a string
     * in the third parm.  The data is the fourth parm.
     *
     * The supports types are: integer, bool, data, ip, and mac.  The
     * data for an integer is a number.  The data for a bool is true
     * or false.  The data for ip is an IP address in the form
     * "n.n.n.n".  Data for mac is a mac address in the form
     * "nn.nn.nn.nn.nn.nn"
     *
     * The index is ignored for types that do not use it.
     */
    int set_val(int parm, int idx, char *type, char *value) {
	enum ipmi_solconf_val_type_e valtype;
	int               rv;
	unsigned int      ival = 0;
	unsigned char     *dval = NULL;
	unsigned int      dval_len = 0;

	rv = ipmi_solconfig_parm_to_type(parm, &valtype);
	if (rv)
	    return rv;

	switch (valtype) {
	case IPMI_SOLCONFIG_INT:
	{
	    char *endstr;
	    if (strcmp(type, "integer") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    if (*value == '\0')
		return EINVAL;
	    ival = strtol(value, &endstr, 0);
	    if (*endstr != '\0')
		return EINVAL;
	    break;
	}
	    
	case IPMI_SOLCONFIG_BOOL:
	    if (strcmp(type, "bool") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    if (strcasecmp(value, "true") == 0)
		ival = 1;
	    else if (strcasecmp(value, "false") == 0)
		ival = 0;
	    else if (strcasecmp(value, "on") == 0)
		ival = 1;
	    else if (strcasecmp(value, "off") == 0)
		ival = 0;
	    else
		return EINVAL;
	    break;
	    
	case IPMI_SOLCONFIG_DATA:
	    if (strcmp(type, "data") != 0)
		return EINVAL;
	    if (!value)
		return EINVAL;
	    dval = parse_raw_str_data(value, &dval_len);
	    if (!dval)
		return ENOMEM;
	    break;

	case IPMI_SOLCONFIG_IP:
	    {
		struct in_addr addr;
		if (strcmp(type, "ip") != 0)
		    return EINVAL;
		rv = parse_ip_addr(value, &addr);
		if (rv)
		    return rv;
		dval = malloc(4);
		memcpy(dval, &addr.s_addr, 4);
		dval_len = 4;
	    }
	    break;

	case IPMI_SOLCONFIG_MAC:
	    if (strcmp(type, "mac") != 0)
		return EINVAL;
	    dval = malloc(6);
	    rv = parse_mac_addr(value, dval);
	    if (rv) {
		free(dval);
		return rv;
	    }
	    dval_len = 6;
	    break;
	}

	rv = ipmi_solconfig_set_val(self, parm, idx, ival, dval, dval_len);
	if (dval)
	    free(dval);
	return rv;
    }
}