Main Page | Class List | Directories | File List | Class Members | File Members
cmdlang

cmd_mc.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_cmdlang.h>
#include <OpenIPMI/ipmi_mc.h>
#include <OpenIPMI/ipmi_sdr.h>
#include <OpenIPMI/ipmi_err.h>
#include <OpenIPMI/ipmi_msgbits.h>
#include <OpenIPMI/ipmi_auth.h>
#include <OpenIPMI/ipmi_user.h>
#include <OpenIPMI/internal/ipmi_malloc.h>

Go to the source code of this file.

Classes

struct  sdr_info_s
struct  event_log_s
struct  get_chan_info_s
struct  set_chan_parm_s
struct  set_chan_info_s
struct  user_set_s

Defines

#define CMDS_MC_LEN   (sizeof(cmds_mc)/sizeof(ipmi_cmdlang_init_t))

Typedefs

typedef sdr_info_s sdr_info_t
typedef event_log_s event_log_t
typedef get_chan_info_s get_chan_info_t
typedef set_chan_parm_s set_chan_parm_t
typedef set_chan_info_s set_chan_info_t
typedef user_set_s user_set_t

Functions

static void mc_list_handler (ipmi_domain_t *domain, ipmi_mc_t *mc, void *cb_data)
static void mc_list (ipmi_domain_t *domain, void *cb_data)
static void mc_dump (ipmi_mc_t *mc, ipmi_cmd_info_t *cmd_info)
static void mc_info (ipmi_mc_t *mc, void *cb_data)
static void mc_reset_done (ipmi_mc_t *mc, int err, void *cb_data)
static void mc_reset (ipmi_mc_t *mc, void *cb_data)
static void set_events_enable_done (ipmi_mc_t *mc, int err, void *cb_data)
static void mc_set_events_enable (ipmi_mc_t *mc, void *cb_data)
static void mc_get_events_enable (ipmi_mc_t *mc, void *cb_data)
static void mc_sel_info (ipmi_mc_t *mc, void *cb_data)
static void get_sel_time_handler (ipmi_mc_t *mc, int err, unsigned long time, void *cb_data)
static void mc_get_sel_time (ipmi_mc_t *mc, void *cb_data)
static void set_sel_time_handler (ipmi_mc_t *mc, int err, void *cb_data)
static void mc_set_sel_time (ipmi_mc_t *mc, void *cb_data)
static void mc_rescan_sel_done (ipmi_mc_t *mc, int err, void *cb_data)
static void mc_rescan_sels (ipmi_mc_t *mc, void *cb_data)
static void mc_sel_rescan_time (ipmi_mc_t *mc, void *cb_data)
static void mc_msg_handler (ipmi_mc_t *mc, ipmi_msg_t *msg, void *cb_data)
static void mc_msg (ipmi_mc_t *mc, void *cb_data)
void sdrs_fetched (ipmi_sdr_info_t *sdrs, int err, int changed, unsigned int count, void *cb_data)
static void mc_sdrs (ipmi_mc_t *mc, void *cb_data)
static void mc_got_event_log_enable (ipmi_mc_t *mc, int err, int val, void *cb_data)
static void mc_get_event_log_enable (ipmi_mc_t *mc, void *cb_data)
static void mc_event_log_enable_set (ipmi_mc_t *mc, int err, void *cb_data)
static void mc_set_event_log_enable (ipmi_mc_t *mc, void *cb_data)
static void dump_chan_info (ipmi_mc_t *mc, ipmi_channel_info_t *info, ipmi_cmd_info_t *cmd_info)
static void got_chan_info (ipmi_mc_t *mc, int err, ipmi_channel_info_t *info, void *cb_data)
static void got_chan_info_multi (ipmi_mc_t *mc, int err, ipmi_channel_info_t *info, void *cb_data)
static void mc_get_chan_info (ipmi_mc_t *mc, void *cb_data)
void got_chan_access (ipmi_mc_t *mc, int err, ipmi_channel_access_t *info, void *cb_data)
static void mc_get_chan_access (ipmi_mc_t *mc, void *cb_data)
void set_chan_access2 (ipmi_mc_t *mc, int err, void *cb_data)
void set_chan_access1 (ipmi_mc_t *mc, int err, ipmi_channel_access_t *info, void *cb_data)
static void mc_set_chan_access (ipmi_mc_t *mc, void *cb_data)
static void got_users (ipmi_mc_t *mc, int err, ipmi_user_list_t *list, void *cb_data)
static void mc_user_list (ipmi_mc_t *mc, void *cb_data)
static void set_user2 (ipmi_mc_t *mc, int err, void *cb_data)
static void set_user1 (ipmi_mc_t *mc, int err, ipmi_user_list_t *list, void *cb_data)
static void mc_user_set (ipmi_mc_t *mc, void *cb_data)
static void mc_active (ipmi_mc_t *mc, int active, void *cb_data)
static void mc_fully_up (ipmi_mc_t *mc, void *cb_data)
void ipmi_cmdlang_mc_change (enum ipmi_update_e op, ipmi_domain_t *domain, ipmi_mc_t *mc, void *cb_data)
int ipmi_cmdlang_mc_init (os_handler_t *os_hnd)

Variables

static ipmi_cmdlang_cmd_t * mc_cmds
static ipmi_cmdlang_cmd_t * mc_chan_cmds
static ipmi_cmdlang_cmd_t * mc_user_cmds
static ipmi_cmdlang_init_t cmds_mc []

Define Documentation

#define CMDS_MC_LEN   (sizeof(cmds_mc)/sizeof(ipmi_cmdlang_init_t))
 

Definition at line 2283 of file cmd_mc.c.

Referenced by ipmi_cmdlang_mc_init().

Typedef Documentation

typedef struct event_log_s event_log_t
 

typedef struct get_chan_info_s get_chan_info_t
 

typedef struct sdr_info_s sdr_info_t
 

typedef struct set_chan_info_s set_chan_info_t
 

typedef struct set_chan_parm_s set_chan_parm_t
 

typedef struct user_set_s user_set_t
 

Function Documentation

static void dump_chan_info (  ipmi_mc_t *  mc,
ipmi_channel_info_t *  info,
ipmi_cmd_info_t *  cmd_info
)  [static]
 

Definition at line 938 of file cmd_mc.c.

References ipmi_channel_info_get_aux_info(), ipmi_channel_info_get_channel(), ipmi_channel_info_get_medium(), ipmi_channel_info_get_protocol_type(), ipmi_channel_info_get_session_support(), ipmi_channel_info_get_vendor_id(), ipmi_channel_medium_string(), IPMI_CHANNEL_MULTI_SESSION, ipmi_channel_protocol_string(), IPMI_CHANNEL_SESSION_BASED, IPMI_CHANNEL_SESSION_LESS, IPMI_CHANNEL_SINGLE_SESSION, ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_binary(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_mc_get_name(), and IPMI_MC_NAME_LEN.

Referenced by got_chan_info(), and got_chan_info_multi().

00941 {
00942     char            mc_name[IPMI_MC_NAME_LEN];
00943     char            *str;
00944     unsigned int    val;
00945     int             rv;
00946     unsigned char   data[3];
00947 
00948     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
00949 
00950     ipmi_cmdlang_lock(cmd_info);
00951     ipmi_cmdlang_out(cmd_info, "Channel Info", NULL);
00952     ipmi_cmdlang_down(cmd_info);
00953     ipmi_cmdlang_out(cmd_info, "MC", mc_name);
00954     rv = ipmi_channel_info_get_channel(info, &val);
00955     if (!rv)
00956         ipmi_cmdlang_out_int(cmd_info, "Channel", val);
00957     rv = ipmi_channel_info_get_medium(info, &val);
00958     if (!rv) {
00959         ipmi_cmdlang_out_int(cmd_info, "Medium", val);
00960         ipmi_cmdlang_out(cmd_info, "Medium String",
00961                          ipmi_channel_medium_string(val));
00962     }
00963     rv = ipmi_channel_info_get_protocol_type(info, &val);
00964     if (!rv) {
00965         ipmi_cmdlang_out_int(cmd_info, "Protocol Type", val);
00966         ipmi_cmdlang_out(cmd_info, "Protocol Type String",
00967                          ipmi_channel_protocol_string(val));
00968     }
00969     rv = ipmi_channel_info_get_session_support(info, &val);
00970     if (!rv) {
00971         switch (val) {
00972         case IPMI_CHANNEL_SESSION_LESS: str = "session-less"; break;
00973         case IPMI_CHANNEL_SINGLE_SESSION: str = "single-session"; break;
00974         case IPMI_CHANNEL_MULTI_SESSION: str = "multi-session"; break;
00975         case IPMI_CHANNEL_SESSION_BASED: str = "session-based"; break;
00976         default: str = "unknown";
00977         }
00978         ipmi_cmdlang_out(cmd_info, "Session Support", str);
00979     }
00980     rv = ipmi_channel_info_get_vendor_id(info, data);
00981     if (!rv)
00982         ipmi_cmdlang_out_binary(cmd_info, "Vendor ID", (char *) data, 3);
00983     rv = ipmi_channel_info_get_aux_info(info, data);
00984     if (!rv)
00985         ipmi_cmdlang_out_binary(cmd_info, "Aux Info", (char *) data, 2);
00986     ipmi_cmdlang_up(cmd_info);
00987     ipmi_cmdlang_unlock(cmd_info);
00988 }

static void get_sel_time_handler (  ipmi_mc_t *  mc,
int  err,
unsigned long  time,
void *  cb_data
)  [static]
 

Definition at line 335 of file cmd_mc.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_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_long(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_mc_get_name(), IPMI_MC_NAME_LEN, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by get_sel_time_cmd(), and mc_get_sel_time().

00336 {
00337     ipmi_cmd_info_t *cmd_info = cb_data;
00338     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00339     char            mc_name[IPMI_MC_NAME_LEN];
00340 
00341     ipmi_cmdlang_lock(cmd_info);
00342     if (err) {
00343         cmdlang->errstr = "Error getting SEL time";
00344         cmdlang->err = err;
00345         ipmi_mc_get_name(mc, cmdlang->objstr,
00346                          cmdlang->objstr_len);
00347         cmdlang->location = "cmd_mc.c(get_sel_time_handler)";
00348     } else {
00349         ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
00350         ipmi_cmdlang_out(cmd_info, "MC", NULL);
00351         ipmi_cmdlang_down(cmd_info);
00352         ipmi_cmdlang_out(cmd_info, "Name", mc_name);
00353         ipmi_cmdlang_out_long(cmd_info, "SEL Time", time);
00354         ipmi_cmdlang_up(cmd_info);
00355     }
00356     ipmi_cmdlang_unlock(cmd_info);
00357     ipmi_cmdlang_cmd_info_put(cmd_info);
00358 }

void got_chan_access (  ipmi_mc_t *  mc,
int  err,
ipmi_channel_access_t *  info,
void *  cb_data
) 
 

Definition at line 1095 of file cmd_mc.c.

References get_chan_info_s::cmd_info, cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_channel_access_get_access_mode(), ipmi_channel_access_get_alerting_enabled(), ipmi_channel_access_get_channel(), ipmi_channel_access_get_per_msg_auth(), ipmi_channel_access_get_priv_limit(), ipmi_channel_access_get_user_auth(), IPMI_CHANNEL_ACCESS_MODE_ALWAYS, IPMI_CHANNEL_ACCESS_MODE_DISABLED, IPMI_CHANNEL_ACCESS_MODE_PRE_BOOT, IPMI_CHANNEL_ACCESS_MODE_SHARED, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_mc_get_name(), IPMI_MC_NAME_LEN, ipmi_mem_free(), ipmi_privilege_string(), ipmi_cmdlang_s::location, and get_chan_info_s::type.

Referenced by ipmi_mc_channel_get_access(), and mc_get_chan_access().

01099 {
01100     get_chan_info_t *chan_info = cb_data;
01101     ipmi_cmd_info_t *cmd_info = chan_info->cmd_info;
01102     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
01103     char            mc_name[IPMI_MC_NAME_LEN];
01104     char            *str;
01105     int             rv;
01106     unsigned int    val;
01107 
01108     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
01109 
01110     if (err) {
01111         cmdlang->err = err;
01112         cmdlang->errstr = "Error getting channel access info";
01113         goto out_err;
01114     }
01115 
01116     ipmi_cmdlang_lock(cmd_info);
01117     ipmi_cmdlang_out(cmd_info, "Channel Access", NULL);
01118     ipmi_cmdlang_down(cmd_info);
01119     ipmi_cmdlang_out(cmd_info, "MC", mc_name);
01120     rv = ipmi_channel_access_get_channel(info, &val);
01121     if (!rv)
01122         ipmi_cmdlang_out_int(cmd_info, "Channel", val);
01123     ipmi_cmdlang_out(cmd_info, "Type", chan_info->type);
01124     rv = ipmi_channel_access_get_alerting_enabled(info, &val);
01125     if (!rv)
01126         ipmi_cmdlang_out_bool(cmd_info, "Alerting Enabled", val);
01127     rv = ipmi_channel_access_get_per_msg_auth(info, &val);
01128     if (!rv)
01129         ipmi_cmdlang_out_bool(cmd_info, "Per-Message Auth", val);
01130     rv = ipmi_channel_access_get_user_auth(info, &val);
01131     if (!rv)
01132         ipmi_cmdlang_out_bool(cmd_info, "User Auth", val);
01133     rv = ipmi_channel_access_get_access_mode(info, &val);
01134     if (!rv) {
01135         switch (val) {
01136         case IPMI_CHANNEL_ACCESS_MODE_DISABLED: str = "disabled"; break;
01137         case IPMI_CHANNEL_ACCESS_MODE_PRE_BOOT: str = "pre-boot"; break;
01138         case IPMI_CHANNEL_ACCESS_MODE_ALWAYS: str = "always"; break;
01139         case IPMI_CHANNEL_ACCESS_MODE_SHARED: str = "shared"; break;
01140         default: str = "unknown";
01141         }
01142         ipmi_cmdlang_out(cmd_info, "Access Mode", str);
01143     }
01144     rv = ipmi_channel_access_get_priv_limit(info, &val);
01145     if (!rv)
01146         ipmi_cmdlang_out(cmd_info, "Privilege Limit",
01147                          ipmi_privilege_string(val));
01148     ipmi_cmdlang_up(cmd_info);
01149     ipmi_cmdlang_unlock(cmd_info);
01150 
01151  out_err:
01152     if (cmdlang->err) {
01153         cmdlang->location = "cmd_mc.c(got_chan_access)";
01154     }
01155 
01156     ipmi_cmdlang_cmd_info_put(cmd_info);
01157     ipmi_mem_free(chan_info);
01158 }

static void got_chan_info (  ipmi_mc_t *  mc,
int  err,
ipmi_channel_info_t *  info,
void *  cb_data
)  [static]
 

Definition at line 991 of file cmd_mc.c.

References cmdlang, dump_chan_info(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), and ipmi_cmdlang_s::location.

Referenced by ipmi_mc_channel_get_info(), and mc_get_chan_info().

00995 {
00996     ipmi_cmd_info_t *cmd_info = cb_data;
00997     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00998 
00999     if (err) {
01000         cmdlang->err = err;
01001         cmdlang->errstr = "Error getting channel info";
01002         goto out_err;
01003     }
01004 
01005     dump_chan_info(mc, info, cmd_info);
01006 
01007  out_err:
01008     if (cmdlang->err) {
01009         cmdlang->location = "cmd_mc.c(got_chan_info)";
01010     }
01011 
01012     ipmi_cmdlang_cmd_info_put(cmd_info);
01013 }

static void got_chan_info_multi (  ipmi_mc_t *  mc,
int  err,
ipmi_channel_info_t *  info,
void *  cb_data
)  [static]
 

Definition at line 1016 of file cmd_mc.c.

References dump_chan_info(), and ipmi_cmdlang_cmd_info_put().

Referenced by mc_get_chan_info().

01020 {
01021     ipmi_cmd_info_t *cmd_info = cb_data;
01022 
01023     if (err)
01024         /* Ignore this on multiple fetches, don't print an error */
01025         goto out;
01026 
01027     dump_chan_info(mc, info, cmd_info);
01028             
01029 
01030  out:
01031     ipmi_cmdlang_cmd_info_put(cmd_info);
01032 }

static void got_users (  ipmi_mc_t *  mc,
int  err,
ipmi_user_list_t *  list,
void *  cb_data
)  [static]
 

Definition at line 1586 of file cmd_mc.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, i, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_out_binary(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_mc_get_name(), IPMI_MC_NAME_LEN, ipmi_privilege_string(), ipmi_user_free(), ipmi_user_get_access_cb_only(), ipmi_user_get_link_auth_enabled(), ipmi_user_get_msg_auth_enabled(), ipmi_user_get_name(), ipmi_user_get_num(), ipmi_user_get_privilege_limit(), ipmi_user_get_session_limit(), ipmi_user_list_get_channel(), ipmi_user_list_get_enabled_users(), ipmi_user_list_get_fixed_users(), ipmi_user_list_get_max_user(), ipmi_user_list_get_user(), ipmi_user_list_get_user_count(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by mc_user_list().

01590 {
01591     ipmi_cmd_info_t *cmd_info = cb_data;
01592     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
01593     ipmi_user_t     *user;
01594     char            mc_name[IPMI_MC_NAME_LEN];
01595     int             i, j, k;
01596     char            str[17];
01597     unsigned int    count;
01598     unsigned int    channel;
01599     unsigned int    val;
01600     int             rv;
01601 
01602     if (err) {
01603         cmdlang->err = err;
01604         cmdlang->errstr = "Error getting user info";
01605         goto out_err;
01606     }
01607 
01608     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
01609 
01610     count = ipmi_user_list_get_user_count(list);
01611 
01612     rv = ipmi_user_list_get_channel(list, &channel);
01613     if (rv) {
01614         cmdlang->err = rv;
01615         cmdlang->errstr = "Error getting channel";
01616         goto out_err;
01617     }
01618 
01619     ipmi_cmdlang_lock(cmd_info);
01620     ipmi_cmdlang_out(cmd_info, "MC", mc_name);
01621     ipmi_cmdlang_out_int(cmd_info, "Channel", channel);
01622     rv = ipmi_user_list_get_max_user(list, &val);
01623     if (!rv)
01624         ipmi_cmdlang_out_int(cmd_info, "Max User", val);
01625     rv = ipmi_user_list_get_enabled_users(list, &val);
01626     if (!rv)
01627         ipmi_cmdlang_out_int(cmd_info, "Enabled Users", val);
01628     rv = ipmi_user_list_get_fixed_users(list, &val);
01629     if (!rv)
01630         ipmi_cmdlang_out_int(cmd_info, "Fixed Users", val);
01631     for (i=0; i<count; i++) {
01632         user = ipmi_user_list_get_user(list, i);
01633         if (!user)
01634             continue;
01635         ipmi_cmdlang_out(cmd_info, "User", NULL);
01636         ipmi_cmdlang_down(cmd_info);
01637         rv = ipmi_user_get_num(user, &val);
01638         if (!rv)
01639             ipmi_cmdlang_out_int(cmd_info, "Number", val);
01640         
01641         val = 17;
01642         rv = ipmi_user_get_name(user, str, &val);
01643         if (!rv) {
01644             val = 1;
01645             for (j=15; j>=0; j--) {
01646                 if (str[j] != '\0')
01647                     break;
01648             }
01649             for (k=0; k<=j; k++) {
01650                 if (! isprint(str[k])) {
01651                     val = 0;
01652                     break;
01653                 }
01654             }
01655             if (val)
01656                 ipmi_cmdlang_out(cmd_info, "String Name", str);
01657             else
01658                 ipmi_cmdlang_out_binary(cmd_info, "Binary Name", str, 16);
01659         }
01660         rv = ipmi_user_get_link_auth_enabled(user, &val);
01661         if (!rv)
01662             ipmi_cmdlang_out_bool(cmd_info, "Link Auth Enabled", val);
01663         rv = ipmi_user_get_msg_auth_enabled(user, &val);
01664         if (!rv)
01665             ipmi_cmdlang_out_bool(cmd_info, "Msg Auth Enabled", val);
01666         rv = ipmi_user_get_access_cb_only(user, &val);
01667         if (!rv)
01668             ipmi_cmdlang_out_bool(cmd_info, "Access CB Only", val);
01669         rv = ipmi_user_get_privilege_limit(user, &val);
01670         if (!rv)
01671             ipmi_cmdlang_out(cmd_info, "Privilege Limit",
01672                              ipmi_privilege_string(val));
01673         rv = ipmi_user_get_session_limit(user, &val);
01674         if (!rv)
01675             ipmi_cmdlang_out_bool(cmd_info, "Session Limit", val);
01676         ipmi_cmdlang_up(cmd_info);
01677         ipmi_user_free(user);
01678     }
01679     ipmi_cmdlang_unlock(cmd_info);
01680     ipmi_cmdlang_cmd_info_put(cmd_info);
01681     return;
01682 
01683  out_err:
01684     ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
01685     cmdlang->location = "cmd_mc.c(got_users)";
01686     ipmi_cmdlang_cmd_info_put(cmd_info);
01687 }

void ipmi_cmdlang_mc_change (  enum ipmi_update_e  op,
ipmi_domain_t *  domain,
ipmi_mc_t *  mc,
void *  cb_data
) 
 

Definition at line 2111 of file cmd_mc.c.

References IPMI_ADDED, IPMI_CHANGED, ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_get_evinfo(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), IPMI_DELETED, ipmi_mc_add_active_handler(), ipmi_mc_add_fully_up_handler(), ipmi_mc_get_name(), IPMI_MC_NAME_LEN, mc_active(), mc_dump(), and mc_fully_up().

Referenced by domain_change().

02115 {
02116     char            *errstr;
02117     int             rv;
02118     ipmi_cmd_info_t *evi;
02119     char            mc_name[IPMI_MC_NAME_LEN];
02120 
02121     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
02122 
02123     evi = ipmi_cmdlang_alloc_event_info();
02124     if (!evi) {
02125         errstr = "Out of memory";
02126         rv = ENOMEM;
02127         goto out_err;
02128     }
02129 
02130     ipmi_cmdlang_out(evi, "Object Type", "MC");
02131     ipmi_cmdlang_out(evi, "Name", mc_name);
02132 
02133     switch (op) {
02134     case IPMI_ADDED:
02135         ipmi_cmdlang_out(evi, "Operation", "Add");
02136         if (ipmi_cmdlang_get_evinfo())
02137             mc_dump(mc, evi);
02138         rv = ipmi_mc_add_active_handler(mc, mc_active, NULL);
02139         if (rv) {
02140             errstr = "ipmi_mc_add_active_handler failed";
02141             goto out_err;
02142         }
02143         rv = ipmi_mc_add_fully_up_handler(mc, mc_fully_up, NULL);
02144         if (rv) {
02145             errstr = "ipmi_mc_add_fully_up_handler failed";
02146             goto out_err;
02147         }
02148         break;
02149 
02150         case IPMI_DELETED:
02151             ipmi_cmdlang_out(evi, "Operation", "Delete");
02152             break;
02153 
02154         case IPMI_CHANGED:
02155             ipmi_cmdlang_out(evi, "Operation", "Change");
02156             if (ipmi_cmdlang_get_evinfo())
02157                 mc_dump(mc, evi);
02158             break;
02159     }
02160 
02161     ipmi_cmdlang_cmd_info_put(evi);
02162     return;
02163 
02164  out_err:
02165     if (rv) {
02166         ipmi_cmdlang_global_err(mc_name, "cmd_mc.c(ipmi_cmdlang_mc_change)",
02167                                 errstr, rv);
02168     }
02169     if (evi)
02170         ipmi_cmdlang_cmd_info_put(evi);
02171 }

int ipmi_cmdlang_mc_init (  os_handler_t *  os_hnd  ) 
 

Definition at line 2286 of file cmd_mc.c.

References CMDS_MC_LEN, and ipmi_cmdlang_reg_table().

Referenced by ipmi_cmdlang_init().

02287 {
02288     return ipmi_cmdlang_reg_table(cmds_mc, CMDS_MC_LEN);
02289 }

static void mc_active (  ipmi_mc_t *  mc,
int  active,
void *  cb_data
)  [static]
 

Definition at line 2046 of file cmd_mc.c.

References ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_mc_get_name(), and IPMI_MC_NAME_LEN.

Referenced by ipmi_cmdlang_mc_change(), and mc_change().

02047 {
02048     char            *errstr;
02049     int             rv;
02050     ipmi_cmd_info_t *evi;
02051     char            mc_name[IPMI_MC_NAME_LEN];
02052 
02053     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
02054 
02055     evi = ipmi_cmdlang_alloc_event_info();
02056     if (!evi) {
02057         rv = ENOMEM;
02058         errstr = "Out of memory";
02059         goto out_err;
02060     }
02061 
02062     ipmi_cmdlang_out(evi, "Object Type", "MC");
02063     ipmi_cmdlang_out(evi, "Name", mc_name);
02064     ipmi_cmdlang_out(evi, "Operation", "Active Changed");
02065     ipmi_cmdlang_out_bool(evi, "Active", active);
02066 
02067     ipmi_cmdlang_cmd_info_put(evi);
02068     return;
02069 
02070  out_err:
02071     ipmi_cmdlang_global_err(mc_name,
02072                             "cmd_mc.c(mc_active)",
02073                             errstr, rv);
02074     if (evi)
02075         ipmi_cmdlang_cmd_info_put(evi);
02076 }

static void mc_dump (  ipmi_mc_t *  mc,
ipmi_cmd_info_t *  cmd_info
)  [static]
 

Definition at line 84 of file cmd_mc.c.

References ipmi_cmdlang_out(), ipmi_cmdlang_out_binary(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_hex(), ipmi_cmdlang_out_int(), ipmi_mc_aux_fw_revision(), ipmi_mc_bridge_support(), ipmi_mc_chassis_support(), ipmi_mc_device_available(), ipmi_mc_device_id(), ipmi_mc_device_revision(), ipmi_mc_fru_inventory_support(), ipmi_mc_get_guid(), ipmi_mc_get_sel_rescan_time(), ipmi_mc_ipmb_event_generator_support(), ipmi_mc_ipmb_event_receiver_support(), ipmi_mc_is_active(), ipmi_mc_major_fw_revision(), ipmi_mc_major_version(), ipmi_mc_manufacturer_id(), ipmi_mc_minor_fw_revision(), ipmi_mc_minor_version(), ipmi_mc_product_id(), ipmi_mc_provides_device_sdrs(), ipmi_mc_sdr_repository_support(), ipmi_mc_sel_device_support(), ipmi_mc_sensor_device_support(), and vals.

Referenced by ipmi_cmdlang_mc_change(), and mc_info().

00085 {
00086     unsigned char vals[4];
00087     char          str[100];
00088     unsigned char guid[16];
00089 
00090     ipmi_cmdlang_out_bool(cmd_info, "Active", ipmi_mc_is_active(mc));
00091     if (ipmi_mc_get_guid(mc, guid) == 0)
00092         ipmi_cmdlang_out_binary(cmd_info, "GUID", (char *) guid, 16);
00093     ipmi_cmdlang_out_int(cmd_info, "SEL Rescan Time",
00094                          ipmi_mc_get_sel_rescan_time(mc));
00095     ipmi_cmdlang_out_bool(cmd_info, "provides_device_sdrs",
00096                           ipmi_mc_provides_device_sdrs(mc));
00097     ipmi_cmdlang_out_bool(cmd_info, "device_available",
00098                           ipmi_mc_device_available(mc));
00099     ipmi_cmdlang_out_bool(cmd_info, "chassis_support",
00100                           ipmi_mc_chassis_support(mc));
00101     ipmi_cmdlang_out_bool(cmd_info, "bridge_support",
00102                           ipmi_mc_bridge_support(mc));
00103     ipmi_cmdlang_out_bool(cmd_info, "ipmb_event_generator",
00104                           ipmi_mc_ipmb_event_generator_support(mc));
00105     ipmi_cmdlang_out_bool(cmd_info, "ipmb_event_receiver",
00106                           ipmi_mc_ipmb_event_receiver_support(mc));
00107     ipmi_cmdlang_out_bool(cmd_info, "fru_inventory_support",
00108                           ipmi_mc_fru_inventory_support(mc));
00109     ipmi_cmdlang_out_bool(cmd_info, "sel_device_support",
00110                           ipmi_mc_sel_device_support(mc));
00111     ipmi_cmdlang_out_bool(cmd_info, "sdr_repository_support",
00112                           ipmi_mc_sdr_repository_support(mc));
00113     ipmi_cmdlang_out_bool(cmd_info, "sensor_device_support",
00114                           ipmi_mc_sensor_device_support(mc));
00115     ipmi_cmdlang_out_hex(cmd_info, "device_id", ipmi_mc_device_id(mc));
00116     ipmi_cmdlang_out_int(cmd_info, "device_revision",
00117                          ipmi_mc_device_revision(mc));
00118     snprintf(str, sizeof(str), "%d.%d%d",
00119              ipmi_mc_major_fw_revision(mc),
00120              ipmi_mc_minor_fw_revision(mc)>>4,
00121              ipmi_mc_minor_fw_revision(mc)&0xf);
00122     ipmi_cmdlang_out(cmd_info, "fw_revision", str);
00123     snprintf(str, sizeof(str), "%d.%d",
00124              ipmi_mc_major_version(mc),
00125              ipmi_mc_minor_version(mc));
00126     ipmi_cmdlang_out(cmd_info, "version", str);
00127     ipmi_cmdlang_out_hex(cmd_info, "manufacturer_id",
00128                          ipmi_mc_manufacturer_id(mc));
00129     ipmi_cmdlang_out_hex(cmd_info, "product_id", ipmi_mc_product_id(mc));
00130     ipmi_mc_aux_fw_revision(mc, vals);
00131     ipmi_cmdlang_out_binary(cmd_info, "aux_fw_revision",
00132                             (char *) vals, sizeof(vals));
00133 }

static void mc_event_log_enable_set (  ipmi_mc_t *  mc,
int  err,
void *  cb_data
)  [static]
 

Definition at line 857 of file cmd_mc.c.

References event_log_s::cmd_info, cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), ipmi_mc_get_name(), IPMI_MC_NAME_LEN, ipmi_mem_free(), and ipmi_cmdlang_s::location.

Referenced by mc_set_event_log_enable().

00858 {
00859     event_log_t     *info = cb_data;
00860     ipmi_cmd_info_t *cmd_info = info->cmd_info;
00861     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00862     char             mc_name[IPMI_MC_NAME_LEN];
00863 
00864     if (err) {
00865         cmdlang->err = err;
00866         cmdlang->errstr = "Error setting event log enable";
00867         goto out_err;
00868     }
00869 
00870     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
00871     ipmi_cmdlang_out(cmd_info, "Event Log Enable Set", NULL);
00872     ipmi_cmdlang_down(cmd_info);
00873     ipmi_cmdlang_out(cmd_info, "MC", mc_name);
00874     ipmi_cmdlang_up(cmd_info);
00875 
00876  out_err:
00877     if (cmdlang->err) {
00878         cmdlang->location = "cmd_mc.c(mc_event_log_enable_set)";
00879     }
00880     ipmi_cmdlang_cmd_info_put(cmd_info);
00881     ipmi_mem_free(info);
00882 }

static void mc_fully_up (  ipmi_mc_t *  mc,
void *  cb_data
)  [static]
 

Definition at line 2079 of file cmd_mc.c.

References ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), ipmi_mc_get_name(), and IPMI_MC_NAME_LEN.

Referenced by ipmi_cmdlang_mc_change().

02080 {
02081     char            *errstr;
02082     int             rv;
02083     ipmi_cmd_info_t *evi;
02084     char            mc_name[IPMI_MC_NAME_LEN];
02085 
02086     ipmi_mc_get_name(mc, mc_name, sizeof(mc_name));
02087 
02088     evi = ipmi_cmdlang_alloc_event_info();
02089     if (!evi) {
02090         rv = ENOMEM;
02091         errstr = "Out of memory";
02092         goto out_err;
02093     }
02094 
02095     ipmi_cmdlang_out(evi, "Object Type", "MC");
02096     ipmi_cmdlang_out(evi, "Name", mc_name);
02097     ipmi_cmdlang_out(evi, "Operation", "Fully Up");
02098 
02099     ipmi_cmdlang_cmd_info_put(evi);
02100     return;
02101 
02102  out_err:
02103     ipmi_cmdlang_global_err(mc_name,
02104                             "cmd_mc.c(mc_fully_up)",
02105                             errstr, rv);
02106     if (evi)
02107         ipmi_cmdlang_cmd_info_put(evi);
02108 }

static void mc_get_chan_access (  ipmi_mc_t *  mc,
void *  cb_data
)  [static]
 

Definition at line 1161 of file cmd_mc.c.

References get_chan_info_s::cmd_info, cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, got_chan_access(), 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_mc_channel_get_access(), ipmi_mc_get_name(), ipmi_mem_alloc(), ipmi_mem_free(), IPMI_SET_DEST_NON_VOLATILE, IPMI_SET_DEST_VOLATILE, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and get_chan_info_s::type.

01162 {
01163     ipmi_cmd_info_t *cmd_info = cb_data;
01164     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
01165     int             rv;
01166     int             curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
01167     int             argc = ipmi_cmdlang_get_argc(cmd_info);
01168     char            **argv = ipmi_cmdlang_get_argv(cmd_info);
01169     int             channel;
01170     get_chan_info_t *present = NULL;
01171     get_chan_info_t *non_volatile = NULL;
01172 
01173 
01174     if ((argc - curr_arg) < 2) {
01175         /* Not enough parameters */
01176         cmdlang->errstr = "Not enough parameters";
01177         cmdlang->err = EINVAL;
01178         goto out_err;
01179     }
01180 
01181     ipmi_cmdlang_get_int(argv[curr_arg], &channel, cmd_info);
01182     if (cmdlang->err) {
01183         cmdlang->errstr = "channel invalid";
01184         goto out_err;
01185     }
01186     curr_arg++;
01187 
01188     if (strcmp(argv[curr_arg], "non-volatile") == 0) {
01189         non_volatile = ipmi_mem_alloc(sizeof(*non_volatile));
01190         if (!non_volatile) {
01191             cmdlang->err = ENOMEM;
01192             cmdlang->errstr = "Out of memory";
01193         }
01194     } else if (strcmp(argv[curr_arg], "present") == 0) {
01195         present = ipmi_mem_alloc(sizeof(*present));
01196         if (!present) {
01197             cmdlang->err = ENOMEM;
01198             cmdlang->errstr = "Out of memory";
01199         }
01200     } else if (strcmp(argv[curr_arg], "both") == 0) {
01201         non_volatile = ipmi_mem_alloc(sizeof(*non_volatile));
01202         if (!non_volatile) {
01203             cmdlang->err = ENOMEM;
01204             cmdlang->errstr = "Out of memory";
01205         }
01206         present = ipmi_mem_alloc(sizeof(*present));
01207         if (!present) {
01208             ipmi_mem_free(non_volatile);
01209             cmdlang->err = ENOMEM;
01210             cmdlang->errstr = "Out of memory";
01211         }
01212     } else {
01213         cmdlang->err = EINVAL;
01214         cmdlang->errstr = "fetch type invalid";
01215         goto out_err;
01216     }
01217 
01218     if (present) {
01219         present->type = "present";
01220         present->cmd_info = cmd_info;
01221 
01222         ipmi_cmdlang_cmd_info_get(cmd_info);
01223         rv = ipmi_mc_channel_get_access(mc, channel,
01224                                         IPMI_SET_DEST_VOLATILE, 
01225                                         got_chan_access,
01226                                         present);
01227         if (rv) {
01228             ipmi_cmdlang_cmd_info_put(cmd_info);
01229             cmdlang->err = rv;
01230             cmdlang->errstr = "Could not send command to get present value";
01231             ipmi_mem_free(present);
01232             present = NULL;
01233         }
01234     }
01235 
01236     if (non_volatile) {
01237         non_volatile->type = "non-volatile";
01238         non_volatile->cmd_info = cmd_info;
01239 
01240         ipmi_cmdlang_cmd_info_get(cmd_info);
01241         rv = ipmi_mc_channel_get_access(mc, channel,
01242                                         IPMI_SET_DEST_NON_VOLATILE,
01243                                         got_chan_access,
01244                                         non_volatile);
01245         if (rv) {
01246             ipmi_cmdlang_cmd_info_put(cmd_info);
01247             cmdlang->err = rv;
01248             cmdlang->errstr = "Could not send command to get non-volatile"
01249                 " value";
01250             ipmi_mem_free(non_volatile);
01251             non_volatile = NULL;
01252         }
01253     }
01254 
01255     if ((present == NULL) && (non_volatile == NULL))
01256         goto out_err;
01257 
01258     return;
01259 
01260  out_err:
01261     ipmi_mc_get_name(mc, cmdlang->objstr, cmdlang->objstr_len);
01262     cmdlang->location = "cmd_mc.c(mc_get_chan_access)";
01263 }

static void mc_get_chan_info (  ipmi_mc_t *  mc,
void *  cb_data
)  [static]
 

Definition at line 1035 of file cmd_mc.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, got_chan_info(), got_chan_info_multi(), 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_mc_channel_get_info(), ipmi_mc_get_name(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

01036 {
01037     ipmi_cmd_info_t *cmd_info = cb_data;
01038     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
01039     int             rv;
01040     int             curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
01041     int             argc = ipmi_cmdlang_get_argc(cmd_info);
01042     char            **argv = ipmi_cmdlang_get_argv(cmd_info);
01043     int             channel;
01044 
01045 
01046     if ((argc - curr_arg) < 1) {
01047         int count = 0;
01048         /* List them all */
01049         for (channel=0; channel<8; channel++) {
01050             ipmi_cmdlang_cmd_info_get(cmd_info);
01051             rv = ipmi_mc_channel_get_info(mc, channel, got_chan_info_multi,
01052                                           cmd_info);
01053             if (rv)
01054                 ipmi_cmdlang_cmd_info_put(cmd_info);
01055             else
01056                 count++;
01057         }