cmd_domain.c File Reference

#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <OpenIPMI/ipmiif.h>
#include <OpenIPMI/ipmi_mc.h>
#include <OpenIPMI/ipmi_err.h>
#include <OpenIPMI/ipmi_cmdlang.h>
#include <OpenIPMI/ipmi_fru.h>
#include <OpenIPMI/ipmi_conn.h>
#include <OpenIPMI/internal/ipmi_malloc.h>

Go to the source code of this file.

Classes
struct	domain_close_info_s
Defines
#define	CMDS_DOMAIN_LEN   (sizeof(cmds_domain)/sizeof(ipmi_cmdlang_init_t))
Typedefs
typedef domain_close_info_s	domain_close_info_t
Functions
void	ipmi_cmdlang_dump_fru_info (ipmi_cmd_info_t *cmd_info, ipmi_fru_t *fru)
static void	domain_list_handler (ipmi_domain_t *domain, void *cb_data)
static void	domain_list (ipmi_cmd_info_t *cmd_info)
static void	domain_info (ipmi_domain_t *domain, void *cb_data)
static void	domain_con_change (ipmi_domain_t *domain, int err, unsigned int conn_num, unsigned int port_num, int still_connected, void *cb_data)
void	ipmi_cmdlang_entity_change (enum ipmi_update_e op, ipmi_domain_t *domain, ipmi_entity_t *entity, void *cb_data)
void	ipmi_cmdlang_mc_change (enum ipmi_update_e op, ipmi_domain_t *domain, ipmi_mc_t *mc, void *cb_data)
static void	domain_new_done (ipmi_domain_t *domain, int err, unsigned int conn_num, unsigned int port_num, int still_connected, void *cb_data)
void	domain_fully_up (ipmi_domain_t *domain, void *cb_data)
static void	domain_new (ipmi_cmd_info_t *cmd_info)
static void	domain_open (ipmi_cmd_info_t *cmd_info)
void	con_usage (const char *name, const char *help, void *cb_data)
static void	domain_open_help (ipmi_cmdlang_t *cmdlang)
static void	domain_fru_fetched (ipmi_domain_t *domain, ipmi_fru_t *fru, int err, void *cb_data)
static void	domain_fru (ipmi_domain_t *domain, void *cb_data)
static int	domain_msg_handler (ipmi_domain_t *domain, ipmi_msgi_t *rspi)
static void	domain_msg (ipmi_domain_t *domain, void *cb_data)
static void	scan_done (ipmi_domain_t *domain, int err, void *cb_data)
static void	domain_scan (ipmi_domain_t *domain, void *cb_data)
static void	domain_rescan_sels_done (ipmi_domain_t *domain, int err, void *cb_data)
static void	domain_rescan_sels (ipmi_domain_t *domain, void *cb_data)
static void	domain_presence (ipmi_domain_t *domain, void *cb_data)
static void	domain_sel_rescan_time (ipmi_domain_t *domain, void *cb_data)
static void	domain_ipmb_rescan_time (ipmi_domain_t *domain, void *cb_data)
static void	handle_stat (ipmi_domain_t *domain, ipmi_domain_stat_t *stat, void *cb_data)
static void	domain_stats (ipmi_domain_t *domain, void *cb_data)
static void	final_close (void *cb_data)
static void	domain_close (ipmi_domain_t *domain, void *cb_data)
static void	domain_event_handler (ipmi_domain_t *domain, ipmi_event_t *event, void *cb_data)
void	domain_change (ipmi_domain_t *domain, enum ipmi_update_e op, void *cb_data)
static void	get_mc_name (ipmi_mc_t *mc, void *cb_data)
void	ipmi_cmdlang_event_out (ipmi_event_t *event, ipmi_cmd_info_t *cmd_info)
int	ipmi_cmdlang_domain_init (os_handler_t *os_hnd)
Variables
static ipmi_cmdlang_cmd_t *	domain_cmds
static ipmi_cmdlang_init_t	cmds_domain []

---

Define Documentation

#define CMDS_DOMAIN_LEN   (sizeof(cmds_domain)/sizeof(ipmi_cmdlang_init_t))

Definition at line 1288 of file cmd_domain.c. Referenced by ipmi_cmdlang_domain_init().

---

Typedef Documentation

typedef struct domain_close_info_s domain_close_info_t

---

Function Documentation

void con_usage (  const char *  name, const char *  help, void *  cb_data )

Definition at line 407 of file cmd_domain.c. References cmdlang, and ipmi_cmdlang_s::out. Referenced by domain_open_help(), and usage(). { ipmi_cmdlang_t *cmdlang = cb_data; cmdlang->out(cmdlang, name, help); }

void domain_change (  ipmi_domain_t *  domain, enum ipmi_update_e  op, void *  cb_data )

Definition at line 1109 of file cmd_domain.c. References domain_event_handler(), domain_info(), IPMI_ADDED, ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_entity_change(), ipmi_cmdlang_get_evinfo(), ipmi_cmdlang_global_err(), ipmi_cmdlang_mc_change(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), IPMI_DELETED, ipmi_domain_add_entity_update_handler(), ipmi_domain_add_event_handler(), ipmi_domain_add_mc_updated_handler(), ipmi_domain_enable_events(), ipmi_domain_get_name(), and IPMI_DOMAIN_NAME_LEN. Referenced by ipmi_cmdlang_domain_init(). { ipmi_cmd_info_t *evi; int rv = 0; char *errstr = NULL; char domain_name[IPMI_DOMAIN_NAME_LEN]; evi = ipmi_cmdlang_alloc_event_info(); if (!evi) { rv = ENOMEM; errstr = "Out of memory"; goto out_err; } ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_out(evi, "Object Type", "Domain"); ipmi_cmdlang_out(evi, "Name", domain_name); switch (op) { case IPMI_ADDED: ipmi_cmdlang_out(evi, "Operation", "Add"); if (ipmi_cmdlang_get_evinfo()) { ipmi_cmdlang_down(evi); domain_info(domain, evi); ipmi_cmdlang_up(evi); } /* Register handlers. */ rv = ipmi_domain_add_event_handler(domain, domain_event_handler, NULL); if (rv) { errstr = "ipmi_register_for_events"; goto out_err; } rv = ipmi_domain_enable_events(domain); if (rv) { errstr = "ipmi_domain_enable_events"; goto out_err; } rv = ipmi_domain_add_entity_update_handler(domain, ipmi_cmdlang_entity_change, domain); if (rv) { errstr = "ipmi_bmc_set_entity_update_handler"; goto out_err; } rv = ipmi_domain_add_mc_updated_handler(domain, ipmi_cmdlang_mc_change, domain); if (rv) { errstr = "ipmi_bmc_set_entity_update_handler"; goto out_err; } break; case IPMI_DELETED: ipmi_cmdlang_out(evi, "Operation", "Delete"); break; default: break; } out_err: /* FIXME - should we shut the connection down on errors? */ if (rv) { ipmi_cmdlang_global_err(domain_name, "cmd_domain.c(domain_change)", errstr, rv); } if (evi) ipmi_cmdlang_cmd_info_put(evi); }

static void domain_close (  ipmi_domain_t *  domain, void *  cb_data )  [static]

Definition at line 989 of file cmd_domain.c. References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, final_close(), ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_domain_close(), ipmi_domain_get_name(), ipmi_mem_alloc(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len. { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int rv; domain_close_info_t *info = cb_data; info = ipmi_mem_alloc(sizeof(*info)); if (!info) { cmdlang->errstr = "Out of memory"; cmdlang->err = ENOMEM; goto out_err; } ipmi_domain_get_name(domain, info->domain_name, sizeof(info->domain_name)); info->cmd_info = cmd_info; ipmi_cmdlang_cmd_info_get(cmd_info); rv = ipmi_domain_close(domain, final_close, info); if (rv) { ipmi_cmdlang_cmd_info_put(cmd_info); cmdlang->errstr = "Unable to close domain"; cmdlang->err = rv; goto out_err; } return; out_err: ipmi_domain_get_name(domain, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_domain.c(domain_close)"; }

static void domain_con_change (  ipmi_domain_t *  domain, int  err, unsigned int  conn_num, unsigned int  port_num, int  still_connected, void *  cb_data )  [static]

Definition at line 1061 of file cmd_domain.c. References ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_int(), ipmi_domain_get_name(), IPMI_DOMAIN_NAME_LEN, and ipmi_get_error_string(). Referenced by domain_new_done(). { char *errstr; int rv = 0; ipmi_cmd_info_t *evi; char domain_name[IPMI_DOMAIN_NAME_LEN]; ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); evi = ipmi_cmdlang_alloc_event_info(); if (!evi) { rv = ENOMEM; errstr = "Out of memory"; goto out_err; } ipmi_cmdlang_out(evi, "Object Type", "Domain"); ipmi_cmdlang_out(evi, "Name", domain_name); ipmi_cmdlang_out(evi, "Operation", "Connection Change"); ipmi_cmdlang_out_int(evi, "Connection Number", conn_num); ipmi_cmdlang_out_int(evi, "Port Number", port_num); ipmi_cmdlang_out_bool(evi, "Any Connection Up", still_connected); ipmi_cmdlang_out_int(evi, "Error", err); if (err) { char errval[128]; ipmi_cmdlang_out(evi, "Error String", ipmi_get_error_string(err, errval, sizeof(errval))); } errstr = NULL; /* Get rid of warning */ out_err: if (rv) { ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_global_err(domain_name, "cmd_domain.c(domain_con_change)", errstr, rv); } if (evi) ipmi_cmdlang_cmd_info_put(evi); }

static void domain_event_handler (  ipmi_domain_t *  domain, ipmi_event_t *  event, void *  cb_data )  [static]

Definition at line 1029 of file cmd_domain.c. References ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_event_out(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), ipmi_domain_get_name(), and IPMI_DOMAIN_NAME_LEN. Referenced by domain_change(). { char *errstr = NULL; int rv = 0; ipmi_cmd_info_t *evi; evi = ipmi_cmdlang_alloc_event_info(); if (!evi) { rv = ENOMEM; errstr = "Out of memory"; goto out_err; } ipmi_cmdlang_out(evi, "Object Type", "Event"); ipmi_cmdlang_event_out(event, evi); out_err: if (rv) { char domain_name[IPMI_DOMAIN_NAME_LEN]; ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_global_err(domain_name, "cmd_domain.c(domain_event_handler)", errstr, rv); } if (evi) ipmi_cmdlang_cmd_info_put(evi); }

static void domain_fru (  ipmi_domain_t *  domain, void *  cb_data )  [static]

Definition at line 455 of file cmd_domain.c. References cmdlang, domain_fru_fetched(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_bool(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_get_int(), ipmi_domain_fru_alloc(), ipmi_domain_get_name(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len. { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int is_logical; int device_addr; int device_id; int lun; int private_bus; int channel; int rv; int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info); int argc = ipmi_cmdlang_get_argc(cmd_info); char **argv = ipmi_cmdlang_get_argv(cmd_info); if ((argc - curr_arg) < 6) { /* Not enough parameters */ cmdlang->errstr = "Not enough parameters"; cmdlang->err = EINVAL; goto out_err; } ipmi_cmdlang_get_bool(argv[curr_arg], &is_logical, cmd_info); if (cmdlang->err) { cmdlang->errstr = "is_logical invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &device_addr, cmd_info); if (cmdlang->err) { cmdlang->errstr = "device_address invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &device_id, cmd_info); if (cmdlang->err) { cmdlang->errstr = "device_id invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &lun, cmd_info); if (cmdlang->err) { cmdlang->errstr = "lun invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &private_bus, cmd_info); if (cmdlang->err) { cmdlang->errstr = "private_bus invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info); if (cmdlang->err) { cmdlang->errstr = "channel invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_cmd_info_get(cmd_info); rv = ipmi_domain_fru_alloc(domain, is_logical, device_addr, device_id, lun, private_bus, channel, domain_fru_fetched, cmd_info, NULL); if (rv) { ipmi_cmdlang_cmd_info_put(cmd_info); cmdlang->errstr = "Error allocating FRU info"; cmdlang->err = rv; goto out_err; } return; out_err: ipmi_domain_get_name(domain, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_domain.c(domain_fru)"; }

static void domain_fru_fetched (  ipmi_domain_t *  domain, ipmi_fru_t *  fru, int  err, void *  cb_data )  [static]

Definition at line 422 of file cmd_domain.c. References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_dump_fru_info(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_domain_get_name(), IPMI_DOMAIN_NAME_LEN, ipmi_fru_get_data_length(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len. Referenced by domain_fru(). { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); char domain_name[IPMI_DOMAIN_NAME_LEN]; ipmi_cmdlang_lock(cmd_info); if (err && (ipmi_fru_get_data_length(fru) == 0)) { cmdlang->errstr = "Error fetching FRU info"; cmdlang->err = err; ipmi_domain_get_name(domain, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_domain.c(domain_fru_fetched)"; goto out; } ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_out(cmd_info, "Domain", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out(cmd_info, "Name", domain_name); if (err) ipmi_cmdlang_out_int(cmd_info, "Warning fetching FRU", err); ipmi_cmdlang_dump_fru_info(cmd_info, fru); ipmi_cmdlang_up(cmd_info); out: ipmi_cmdlang_unlock(cmd_info); ipmi_cmdlang_cmd_info_put(cmd_info); }

void domain_fully_up (  ipmi_domain_t *  domain, void *  cb_data )

Definition at line 154 of file cmd_domain.c. References ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_global_err(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_unlock(), ipmi_domain_get_name(), and IPMI_DOMAIN_NAME_LEN. Referenced by _ipmi_put_domain_fully_up(), domain_new(), and domain_open(). { ipmi_cmd_info_t *cmd_info = cb_data; char *errstr = NULL; int rv = 0; ipmi_cmd_info_t *evi; char domain_name[IPMI_DOMAIN_NAME_LEN]; ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); evi = ipmi_cmdlang_alloc_event_info(); if (!evi) { rv = ENOMEM; errstr = "Out of memory"; goto out_err; } ipmi_cmdlang_out(evi, "Object Type", "Domain"); ipmi_cmdlang_out(evi, "Domain", domain_name); ipmi_cmdlang_out(evi, "Operation", "Domain fully up"); out_err: if (rv) { ipmi_cmdlang_global_err(domain_name, "cmd_domain.c(domain_fully_up)", errstr, rv); } if (evi) ipmi_cmdlang_cmd_info_put(evi); if (cmd_info) { ipmi_cmdlang_lock(cmd_info); ipmi_cmdlang_out(cmd_info, "Domain Created", domain_name); ipmi_cmdlang_unlock(cmd_info); ipmi_cmdlang_cmd_info_put(cmd_info); } }

static void domain_info (  ipmi_domain_t *  domain, void *  cb_data )  [static]

Definition at line 77 of file cmd_domain.c. References ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_out_binary(), ipmi_cmdlang_out_int(), ipmi_cmdlang_up(), ipmi_domain_get_guid(), ipmi_domain_get_ipmb_rescan_time(), ipmi_domain_get_name(), ipmi_domain_get_sel_rescan_time(), ipmi_domain_get_type(), ipmi_domain_get_type_string(), and IPMI_DOMAIN_NAME_LEN. Referenced by domain_change(). { ipmi_cmd_info_t *cmd_info = cb_data; char domain_name[IPMI_DOMAIN_NAME_LEN]; unsigned char guid[16]; ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_out(cmd_info, "Domain", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out(cmd_info, "Name", domain_name); if (ipmi_domain_get_guid(domain, guid) == 0) ipmi_cmdlang_out_binary(cmd_info, "GUID", (char *) guid, 16); ipmi_cmdlang_out(cmd_info, "Type", ipmi_domain_get_type_string(ipmi_domain_get_type(domain))); ipmi_cmdlang_out_int(cmd_info, "SEL Rescan Time", ipmi_domain_get_sel_rescan_time(domain)); ipmi_cmdlang_out_int(cmd_info, "IPMB Rescan Time", ipmi_domain_get_ipmb_rescan_time(domain)); ipmi_cmdlang_up(cmd_info); }

static void domain_ipmb_rescan_time (  ipmi_domain_t *  domain, void *  cb_data )  [static]

Definition at line 902 of file cmd_domain.c. References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_get_int(), ipmi_cmdlang_out(), ipmi_domain_get_name(), IPMI_DOMAIN_NAME_LEN, ipmi_domain_set_ipmb_rescan_time(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len. { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int time; int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info); int argc = ipmi_cmdlang_get_argc(cmd_info); char **argv = ipmi_cmdlang_get_argv(cmd_info); char domain_name[IPMI_DOMAIN_NAME_LEN]; if ((argc - curr_arg) < 1) { cmdlang->errstr = "Not enough parameters"; cmdlang->err = EINVAL; goto out_err; } ipmi_cmdlang_get_int(argv[curr_arg], &time, cmd_info); if (cmdlang->err) { cmdlang->errstr = "time invalid"; goto out_err; } curr_arg++; ipmi_domain_set_ipmb_rescan_time(domain, time); ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_out(cmd_info, "Domain IPMB rescan time set", domain_name); out_err: if (cmdlang->err) { ipmi_domain_get_name(domain, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_domain.c(domain_ipmb_rescan_time)"; } }

static void domain_list (  ipmi_cmd_info_t *  cmd_info  )  [static]

Definition at line 68 of file cmd_domain.c. References domain_list_handler(), ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), and ipmi_domain_iterate_domains(). { ipmi_cmdlang_out(cmd_info, "Domains", NULL); ipmi_cmdlang_down(cmd_info); ipmi_domain_iterate_domains(domain_list_handler, cmd_info); ipmi_cmdlang_up(cmd_info); }

static void domain_list_handler (  ipmi_domain_t *  domain, void *  cb_data )  [static]

Definition at line 53 of file cmd_domain.c. References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_out(), ipmi_domain_get_name(), and IPMI_DOMAIN_NAME_LEN. Referenced by domain_list(). { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); char domain_name[IPMI_DOMAIN_NAME_LEN]; if (cmdlang->err) return; ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_out(cmd_info, "Name", domain_name); }

static void domain_msg (  ipmi_domain_t *  domain, void *  cb_data )  [static]

Definition at line 576 of file cmd_domain.c. References addr, ipmi_ipmb_addr::addr_type, ipmi_ipmb_addr::channel, ipmi_msg::cmd, cmdlang, ipmi_msg::data, ipmi_msg::data_len, domain_msg_handler(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, i, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_get_int(), ipmi_cmdlang_get_uchar(), ipmi_domain_get_name(), IPMI_IPMB_ADDR_TYPE, IPMI_IPMB_BROADCAST_ADDR_TYPE, ipmi_send_command_addr(), ipmi_cmdlang_s::location, ipmi_ipmb_addr::lun, ipmi_msg::netfn, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and ipmi_ipmb_addr::slave_addr. { ipmi_cmd_info_t *cmd_info = cb_data; ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int channel; int ipmb; int is_broadcast = 0; int LUN; int NetFN; int command; unsigned char data[100]; int rv; int i; ipmi_ipmb_addr_t addr; ipmi_msg_t msg; int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info); int argc = ipmi_cmdlang_get_argc(cmd_info); char **argv = ipmi_cmdlang_get_argv(cmd_info); if ((argc - curr_arg) < 5) { /* Not enough parameters */ cmdlang->errstr = "Not enough parameters"; cmdlang->err = EINVAL; goto out_err; } ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info); if (cmdlang->err) { cmdlang->errstr = "channel invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &ipmb, cmd_info); if (cmdlang->err) { cmdlang->errstr = "ipmb invalid"; goto out_err; } curr_arg++; if (ipmb == 0) { is_broadcast = 1; if ((argc - curr_arg) < 5) { /* Not enough parameters */ cmdlang->errstr = "Not enough parameters"; cmdlang->err = EINVAL; goto out_err; } ipmi_cmdlang_get_int(argv[curr_arg], &ipmb, cmd_info); if (cmdlang->err) { cmdlang->errstr = "ipmb invalid"; goto out_err; } curr_arg++; } ipmi_cmdlang_get_int(argv[curr_arg], &LUN, cmd_info); if (cmdlang->err) { cmdlang->errstr = "LUN invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &NetFN, cmd_info); if (cmdlang->err) { cmdlang->errstr = "NetFN invalid"; goto out_err; } curr_arg++; ipmi_cmdlang_get_int(argv[curr_arg], &command, cmd_info); if (cmdlang->err) { cmdlang->errstr = "command invalid"; goto out_err; } curr_arg++; i = 0; while (curr_arg < argc) { ipmi_cmdlang_get_uchar(argv[curr_arg], &data[i], cmd_info); if (cmdlang->err) { cmdlang->errstr = "data invalid"; goto out_err; } curr_arg++; i++; } if (is_broadcast) addr.addr_type = IPMI_IPMB_BROADCAST_ADDR_TYPE; else addr.addr_type = IPMI_IPMB_ADDR_TYPE; addr.channel = channel; addr.slave_addr = ipmb; addr.lun = LUN; msg.netfn = NetFN; msg.cmd = command; msg.data_len = i; msg.data = data; ipmi_cmdlang_cmd_info_get(cmd_info); rv = ipmi_send_command_addr(domain, (ipmi_addr_t *) &(addr), sizeof(addr), &msg, domain_msg_handler, cmd_info, NULL); if (rv) { ipmi_cmdlang_cmd_info_put(cmd_info); cmdlang->errstr = "Error sending message"; cmdlang->err = rv; goto out_err; } return; out_err: if (cmdlang->err) { ipmi_domain_get_name(domain, cmdlang->objstr, cmdlang->objstr_len); cmdlang->location = "cmd_domain.c(domain_msg)"; } }

static int domain_msg_handler (  ipmi_domain_t *  domain, ipmi_msgi_t *  rspi )  [static]

Definition at line 546 of file cmd_domain.c. References ipmi_msg_item_s::addr, addr, ipmi_ipmb_addr::channel, ipmi_msg::cmd, ipmi_msg::data, ipmi_msg_item_s::data1, ipmi_msg::data_len, ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_binary(), ipmi_cmdlang_out_hex(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_domain_get_name(), IPMI_DOMAIN_NAME_LEN, IPMI_MSG_ITEM_NOT_USED, ipmi_ipmb_addr::lun, ipmi_msg_item_s::msg, ipmi_msg::netfn, and ipmi_ipmb_addr::slave_addr. Referenced by domain_msg(). { ipmi_msg_t *msg = &rspi->msg; ipmi_ipmb_addr_t *addr = (ipmi_ipmb_addr_t *) &rspi->addr; ipmi_cmd_info_t *cmd_info = rspi->data1; char domain_name[IPMI_DOMAIN_NAME_LEN]; ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_lock(cmd_info); ipmi_cmdlang_out(cmd_info, "Response", NULL); ipmi_cmdlang_down(cmd_info); ipmi_cmdlang_out(cmd_info, "Domain", domain_name); ipmi_cmdlang_out_int(cmd_info, "channel", addr->channel); ipmi_cmdlang_out_hex(cmd_info, "ipmb", addr->slave_addr); ipmi_cmdlang_out_int(cmd_info, "LUN", addr->lun); ipmi_cmdlang_out_int(cmd_info, "NetFN", msg->netfn); ipmi_cmdlang_out_int(cmd_info, "command", msg->cmd); if (msg->data_len) ipmi_cmdlang_out_binary(cmd_info, "Data", (char *) msg->data, msg->data_len); ipmi_cmdlang_unlock(cmd_info); ipmi_cmdlang_up(cmd_info); ipmi_cmdlang_cmd_info_put(cmd_info); return IPMI_MSG_ITEM_NOT_USED; }

static void domain_new (  ipmi_cmd_info_t *  cmd_info  )  [static]

Definition at line 193 of file cmd_domain.c. References ipmi_con_s::close_connection, cmdlang, con, con_info(), domain_fully_up(), domain_new_done(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, i, ipmi_args_setup_con(), ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_free_args(), ipmi_open_domain(), ipmi_parse_args(), ipmi_parse_options(), ipmi_cmdlang_s::location, name, and ipmi_cmdlang_s::os_hnd. { ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); ipmi_args_t *con_parms[2]; int set = 0; int i, j; ipmi_con_t *con[2]; int rv; char *name; int curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info); int argc = ipmi_cmdlang_get_argc(cmd_info); char **argv = ipmi_cmdlang_get_argv(cmd_info); int num_options = 0; ipmi_open_option_t options[10]; int wait_til_up = 0; void *up_info = NULL; void *con_info = NULL; if (curr_arg >= argc) { cmdlang->errstr = "No domain name entered"; cmdlang->err = EINVAL; goto out; } name = argv[curr_arg]; curr_arg++; while ((curr_arg < argc) && argv[curr_arg][0] == '-') { if (num_options >= 10) { cmdlang->errstr = "Too many options"; cmdlang->err = EINVAL; goto out; } if (! ipmi_parse_options(options+num_options, argv[curr_arg])) num_options++; else if (strcmp(argv[curr_arg], "-wait_til_up") == 0) wait_til_up = 1; else break; curr_arg++; } rv = ipmi_parse_args(&curr_arg, argc, argv, &con_parms[set]); if (rv) { cmdlang->errstr = "First connection parms are invalid"; cmdlang->err = rv; goto out; } set++; if (curr_arg < argc) { rv = ipmi_parse_args(&curr_arg, argc, argv, &con_parms[set]); if (rv) { ipmi_free_args(con_parms[0]); cmdlang->errstr = "Second connection parms are invalid"; cmdlang->err = rv; goto out; } set++; } for (i=0; i<set; i++) { rv = ipmi_args_setup_con(con_parms[i], cmdlang->os_hnd, NULL, &con[i]); if (rv) { cmdlang->errstr = "Unable to setup connection"; cmdlang->err = rv; for (j=0; j<set; j++) ipmi_free_args(con_parms[j]); goto out; } } if (wait_til_up) up_info = cmd_info; else con_info = cmd_info; ipmi_cmdlang_cmd_info_get(cmd_info); rv = ipmi_open_domain(name, con, set, domain_new_done, con_info, domain_fully_up, up_info, options, num_options, NULL); if (rv) { ipmi_cmdlang_cmd_info_put(cmd_info); cmdlang->errstr = strerror(rv); cmdlang->err = rv; for (i=0; i<set; i++) { ipmi_free_args(con_parms[i]); con[i]->close_connection(con[i]); } goto out; } for (i=0; i<set; i++) ipmi_free_args(con_parms[i]); out: if (cmdlang->err) cmdlang->location = "cmd_domain.c(domain_new)"; return; }

static void domain_new_done (  ipmi_domain_t *  domain, int  err, unsigned int  conn_num, unsigned int  port_num, int  still_connected, void *  cb_data )  [static]

Definition at line 115 of file cmd_domain.c. References domain_con_change(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_unlock(), ipmi_domain_add_connect_change_handler(), ipmi_domain_get_name(), IPMI_DOMAIN_NAME_LEN, and ipmi_domain_remove_connect_change_handler(). Referenced by domain_new(), and domain_open(). { ipmi_cmd_info_t *cmd_info = cb_data; int rv; /* This call will detect and ignore duplicates, no special handling required. */ ipmi_domain_add_connect_change_handler(domain, domain_con_change, NULL); /* Remove ourselves from the connection change list. This may fail, but that means it's already been done and we don't care. */ rv = ipmi_domain_remove_connect_change_handler(domain, domain_new_done, cb_data); /* Handle the rest as a normal event. */ domain_con_change(domain, err, conn_num, port_num, still_connected, NULL); /* If we get an error removing the connect change handler, that means this has already been done. */ if ((!rv) && cmd_info) { char domain_name[IPMI_DOMAIN_NAME_LEN]; ipmi_domain_get_name(domain, domain_name, sizeof(domain_name)); ipmi_cmdlang_lock(cmd_info); ipmi_cmdlang_out(cmd_info, "Domain Created", domain_name); ipmi_cmdlang_unlock(cmd_info); ipmi_cmdlang_cmd_info_put(cmd_info); } }

static void domain_open (  ipmi_cmd_info_t *  cmd_info  )  [static]

Definition at line 300 of file cmd_domain.c. References ipmi_con_s::close_connection, cmdlang, con, con_info(), domain_fully_up(), domain_new_done(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, i, ipmi_args_setup_con(), ipmi_cmdinfo_get_cmdlang(),