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

cmd_control.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/internal/ipmi_malloc.h>

Go to the source code of this file.

Defines

#define CMDS_CONTROL_LEN   (sizeof(cmds_control)/sizeof(ipmi_cmdlang_init_t))

Functions

static void control_list_handler (ipmi_entity_t *entity, ipmi_control_t *control, void *cb_data)
static void control_list (ipmi_entity_t *entity, void *cb_data)
static void control_dump (ipmi_control_t *control, ipmi_cmd_info_t *cmd_info)
static void control_info (ipmi_control_t *control, void *cb_data)
static void control_set_done (ipmi_control_t *control, int err, void *cb_data)
static void control_set (ipmi_control_t *control, void *cb_data)
static void control_get_light_done (ipmi_control_t *control, int err, ipmi_light_setting_t *s, void *cb_data)
static void control_get_id_done (ipmi_control_t *control, int err, unsigned char *val, int length, void *cb_data)
static void control_get_done (ipmi_control_t *control, int err, int *val, void *cb_data)
static void control_get (ipmi_control_t *control, void *cb_data)
static int control_event_handler (ipmi_control_t *control, int *valid_vals, int *vals, void *cb_data, ipmi_event_t *event)
void ipmi_cmdlang_control_change (enum ipmi_update_e op, ipmi_entity_t *entity, ipmi_control_t *control, void *cb_data)
int ipmi_cmdlang_control_init (os_handler_t *os_hnd)

Variables

static ipmi_cmdlang_cmd_t * control_cmds
static ipmi_cmdlang_init_t cmds_control []

Define Documentation

#define CMDS_CONTROL_LEN   (sizeof(cmds_control)/sizeof(ipmi_cmdlang_init_t))
 

Definition at line 775 of file cmd_control.c.

Referenced by ipmi_cmdlang_control_init().

Function Documentation

static void control_dump (  ipmi_control_t *  control,
ipmi_cmd_info_t *  cmd_info
)  [static]
 

Definition at line 79 of file cmd_control.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, i, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_out_bool(), ipmi_cmdlang_out_int(), ipmi_cmdlang_out_type(), ipmi_cmdlang_up(), IPMI_CONTROL_ALARM, IPMI_CONTROL_COLOR_BLACK, IPMI_CONTROL_COLOR_ORANGE, IPMI_CONTROL_DISPLAY, IPMI_CONTROL_FAN_SPEED, ipmi_control_get_id(), ipmi_control_get_id_length(), ipmi_control_get_id_type(), ipmi_control_get_light_color(), ipmi_control_get_light_color_time(), ipmi_control_get_name(), ipmi_control_get_num_light_transitions(), ipmi_control_get_num_light_values(), ipmi_control_get_num_vals(), ipmi_control_get_type(), ipmi_control_get_type_string(), ipmi_control_has_events(), IPMI_CONTROL_IDENTIFIER, ipmi_control_identifier_get_max_length(), ipmi_control_is_readable(), ipmi_control_is_settable(), IPMI_CONTROL_LIGHT, ipmi_control_light_has_loc_ctrl(), ipmi_control_light_is_color_sup(), ipmi_control_light_set_with_setting(), IPMI_CONTROL_ONE_SHOT_OUTPUT, IPMI_CONTROL_ONE_SHOT_RESET, IPMI_CONTROL_OUTPUT, IPMI_CONTROL_POWER, IPMI_CONTROL_RELAY, IPMI_CONTROL_RESET, ipmi_get_color_string(), ipmi_mem_alloc(), ipmi_mem_free(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by control_info(), and ipmi_cmdlang_control_change().

00080 {
00081     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00082     int             num;
00083     char            *str;
00084     int             len;
00085     int             val, val2, val3;
00086     int             i, j, k;
00087 
00088     ipmi_cmdlang_out(cmd_info, "Type", ipmi_control_get_type_string(control));
00089     ipmi_cmdlang_out_bool(cmd_info, "Generates events",
00090                           ipmi_control_has_events(control));
00091     ipmi_cmdlang_out_bool(cmd_info, "Settable",
00092                           ipmi_control_is_settable(control));
00093     ipmi_cmdlang_out_bool(cmd_info, "Readable",
00094                           ipmi_control_is_readable(control));
00095     num = ipmi_control_get_num_vals(control);
00096     ipmi_cmdlang_out_int(cmd_info, "Num Values", num);
00097     len = ipmi_control_get_id_length(control);
00098     if (len) {
00099         str = ipmi_mem_alloc(len);
00100         if (!str) {
00101             cmdlang->err = ENOMEM;
00102             cmdlang->errstr = "Out of memory";
00103             goto out_err;
00104         }
00105         len = ipmi_control_get_id(control, str, len);
00106         ipmi_cmdlang_out_type(cmd_info, "Id",
00107                               ipmi_control_get_id_type(control),
00108                               str, len);
00109         ipmi_mem_free(str);
00110     }
00111 
00112     switch (ipmi_control_get_type(control)) {
00113     case IPMI_CONTROL_LIGHT:
00114         val = ipmi_control_light_set_with_setting(control);
00115         if (val) {
00116             ipmi_cmdlang_out(cmd_info, "Set with", "settings");
00117             for (j=0; j<num; j++) {
00118                 ipmi_cmdlang_out(cmd_info, "Light", NULL);
00119                 ipmi_cmdlang_down(cmd_info);
00120                 ipmi_cmdlang_out_int(cmd_info, "Number", j);
00121                 val = ipmi_control_light_has_loc_ctrl(control, j);
00122                 ipmi_cmdlang_out_bool(cmd_info, "Local Control", val);
00123                 for (i=IPMI_CONTROL_COLOR_BLACK;
00124                      i<IPMI_CONTROL_COLOR_ORANGE;
00125                      i++)
00126                 {
00127                     val = ipmi_control_light_is_color_sup(control, j, i);
00128                     if (val)
00129                         ipmi_cmdlang_out(cmd_info, "Color",
00130                                          ipmi_get_color_string(i));
00131                 }
00132                 ipmi_cmdlang_up(cmd_info);
00133             }
00134         } else {
00135             ipmi_cmdlang_out(cmd_info, "Set with", "transitions");
00136             for (i=0; i<num; i++) {
00137                 ipmi_cmdlang_out(cmd_info, "Light", NULL);
00138                 ipmi_cmdlang_down(cmd_info);
00139                 ipmi_cmdlang_out_int(cmd_info, "Number", i);
00140                 val = ipmi_control_get_num_light_values(control, i);
00141                 ipmi_cmdlang_out_int(cmd_info, "Num Values", val);
00142                 for (j=0; j<val; j++) {
00143                     ipmi_cmdlang_out(cmd_info, "Value", NULL);
00144                     ipmi_cmdlang_down(cmd_info);
00145                     ipmi_cmdlang_out_int(cmd_info, "Number", j);
00146                     val2 = ipmi_control_get_num_light_transitions(control,
00147                                                                   i, j);
00148                     ipmi_cmdlang_out_int(cmd_info, "Num Transitions", val2);
00149                     for (k=0; k<val2; k++) {
00150                         ipmi_cmdlang_out(cmd_info, "Transition", NULL);
00151                         ipmi_cmdlang_down(cmd_info);
00152                         ipmi_cmdlang_out_int(cmd_info, "Number", k);
00153                         val3 = ipmi_control_get_light_color(control, i, j, k);
00154                         ipmi_cmdlang_out(cmd_info, "Color",
00155                                          ipmi_get_color_string(val3));
00156                         ipmi_cmdlang_out_int(cmd_info, "Time",
00157                                              ipmi_control_get_light_color_time
00158                                              (control, i, j, k));
00159                         ipmi_cmdlang_up(cmd_info);
00160                     }
00161                     ipmi_cmdlang_up(cmd_info);
00162                 }
00163                 ipmi_cmdlang_up(cmd_info);
00164             }
00165         }
00166         break;
00167 
00168     case IPMI_CONTROL_IDENTIFIER:
00169         ipmi_cmdlang_out_int(cmd_info, "Max Length",
00170                              ipmi_control_identifier_get_max_length(control));
00171         break;
00172 
00173     case IPMI_CONTROL_DISPLAY:
00174         break;
00175 
00176     case IPMI_CONTROL_RELAY:
00177     case IPMI_CONTROL_ALARM:
00178     case IPMI_CONTROL_RESET:
00179     case IPMI_CONTROL_POWER:
00180     case IPMI_CONTROL_FAN_SPEED:
00181     case IPMI_CONTROL_ONE_SHOT_RESET:
00182     case IPMI_CONTROL_OUTPUT:
00183     case IPMI_CONTROL_ONE_SHOT_OUTPUT:
00184         break;
00185     }
00186     return;
00187 
00188  out_err:
00189     ipmi_control_get_name(control, cmdlang->objstr,
00190                          cmdlang->objstr_len);
00191     cmdlang->location = "cmd_control.c(control_dump)";
00192 }

static int control_event_handler (  ipmi_control_t *  control,
int *  valid_vals,
int *  vals,
void *  cb_data,
ipmi_event_t *  event
)  [static]
 

Definition at line 632 of file cmd_control.c.

References control_name, i, ipmi_cmdlang_alloc_event_info(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_down(), ipmi_cmdlang_event_out(), ipmi_cmdlang_global_err(), ipmi_cmdlang_out(), ipmi_cmdlang_out_int(), ipmi_cmdlang_up(), ipmi_control_get_name(), ipmi_control_get_num_vals(), IPMI_CONTROL_NAME_LEN, and IPMI_EVENT_NOT_HANDLED.

Referenced by ipmi_cmdlang_control_change().

00637 {
00638     ipmi_cmd_info_t *evi;
00639     char            control_name[IPMI_CONTROL_NAME_LEN];
00640     int             rv;
00641     char            *errstr;
00642     int             i;
00643     int             num;
00644 
00645     ipmi_control_get_name(control, control_name, sizeof(control_name));
00646 
00647     evi = ipmi_cmdlang_alloc_event_info();
00648     if (!evi) {
00649         rv = ENOMEM;
00650         errstr = "Out of memory";
00651         goto out_err;
00652     }
00653 
00654     ipmi_cmdlang_out(evi, "Object Type", "Control");
00655     ipmi_cmdlang_out(evi, "Name", control_name);
00656     ipmi_cmdlang_out(evi, "Operation", "Event");
00657     num = ipmi_control_get_num_vals(control);
00658     for (i=0; i<num; i++) {
00659         if (!valid_vals[i])
00660             continue;
00661         ipmi_cmdlang_out(evi, "Value", NULL);
00662         ipmi_cmdlang_down(evi);
00663         ipmi_cmdlang_out_int(evi, "Number", i);
00664         ipmi_cmdlang_out_int(evi, "Value", vals[i]);
00665         ipmi_cmdlang_up(evi);
00666     }
00667     if (event) {
00668         ipmi_cmdlang_out(evi, "Event", NULL);
00669         ipmi_cmdlang_down(evi);
00670         ipmi_cmdlang_event_out(event, evi);
00671         ipmi_cmdlang_up(evi);
00672     }
00673     ipmi_cmdlang_cmd_info_put(evi);
00674     return IPMI_EVENT_NOT_HANDLED;
00675 
00676  out_err:
00677     ipmi_cmdlang_global_err(control_name,
00678                             "cmd_control.c(ipmi_cmdlang_control_change)",
00679                             errstr, rv);
00680     if (evi)
00681         ipmi_cmdlang_cmd_info_put(evi);
00682     return IPMI_EVENT_NOT_HANDLED;
00683 }

static void control_get (  ipmi_control_t *  control,
void *  cb_data
)  [static]
 

Definition at line 564 of file cmd_control.c.

References cmdlang, control_get_done(), control_get_id_done(), control_get_light_done(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_get(), ipmi_cmdlang_cmd_info_put(), IPMI_CONTROL_ALARM, IPMI_CONTROL_DISPLAY, IPMI_CONTROL_FAN_SPEED, ipmi_control_get_light(), ipmi_control_get_name(), ipmi_control_get_type(), ipmi_control_get_val(), IPMI_CONTROL_IDENTIFIER, ipmi_control_identifier_get_val(), IPMI_CONTROL_LIGHT, ipmi_control_light_set_with_setting(), IPMI_CONTROL_ONE_SHOT_OUTPUT, IPMI_CONTROL_ONE_SHOT_RESET, IPMI_CONTROL_OUTPUT, IPMI_CONTROL_POWER, IPMI_CONTROL_RELAY, IPMI_CONTROL_RESET, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

00565 {
00566     ipmi_cmd_info_t      *cmd_info = cb_data;
00567     ipmi_cmdlang_t       *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00568     int                  rv;
00569 
00570 
00571     switch (ipmi_control_get_type(control)) {
00572     case IPMI_CONTROL_LIGHT:
00573         if (!ipmi_control_light_set_with_setting(control))
00574             goto normal_val_get;
00575 
00576         ipmi_cmdlang_cmd_info_get(cmd_info);
00577         rv = ipmi_control_get_light(control, control_get_light_done, cmd_info);
00578         if (rv) {
00579             ipmi_cmdlang_cmd_info_put(cmd_info);
00580             cmdlang->errstr = "Error getting light control";
00581             cmdlang->err = rv;
00582             goto out_err;
00583         }
00584         break;
00585 
00586     case IPMI_CONTROL_IDENTIFIER:
00587         ipmi_cmdlang_cmd_info_get(cmd_info);
00588         rv = ipmi_control_identifier_get_val(control, 
00589                                              control_get_id_done, cmd_info);
00590         if (rv) {
00591             ipmi_cmdlang_cmd_info_put(cmd_info);
00592             cmdlang->errstr = "Error getting id control";
00593             cmdlang->err = rv;
00594             goto out_err;
00595         }
00596         break;
00597 
00598     case IPMI_CONTROL_DISPLAY:
00599         cmdlang->errstr = "Getting displays not currently supported";
00600         cmdlang->err = ENOSYS;
00601         goto out_err;
00602         break;
00603 
00604     case IPMI_CONTROL_RELAY:
00605     case IPMI_CONTROL_ALARM:
00606     case IPMI_CONTROL_RESET:
00607     case IPMI_CONTROL_POWER:
00608     case IPMI_CONTROL_FAN_SPEED:
00609     case IPMI_CONTROL_ONE_SHOT_RESET:
00610     case IPMI_CONTROL_OUTPUT:
00611     case IPMI_CONTROL_ONE_SHOT_OUTPUT:
00612     normal_val_get:
00613         ipmi_cmdlang_cmd_info_get(cmd_info);
00614         rv = ipmi_control_get_val(control, control_get_done, cmd_info);
00615         if (rv) {
00616             ipmi_cmdlang_cmd_info_put(cmd_info);
00617             cmdlang->errstr = "Error getting control";
00618             cmdlang->err = rv;
00619             goto out_err;
00620         }
00621         break;
00622     }
00623     return;
00624 
00625  out_err:
00626     ipmi_control_get_name(control, cmdlang->objstr,
00627                          cmdlang->objstr_len);
00628     cmdlang->location = "cmd_control.c(control_get)";
00629 }

static void control_get_done (  ipmi_control_t *  control,
int  err,
int *  val,
void *  cb_data
)  [static]
 

Definition at line 521 of file cmd_control.c.

References cmdlang, control_name, 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_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_control_get_name(), ipmi_control_get_num_vals(), IPMI_CONTROL_NAME_LEN, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by control_get().

00525 {
00526     ipmi_cmd_info_t *cmd_info = cb_data;
00527     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00528     int             i, num;
00529     char            control_name[IPMI_CONTROL_NAME_LEN];
00530 
00531     ipmi_control_get_name(control, control_name, sizeof(control_name));
00532 
00533     ipmi_cmdlang_lock(cmd_info);
00534     if (err) {
00535         cmdlang->errstr = "Error setting control";
00536         cmdlang->err = err;
00537         goto out;
00538     }
00539 
00540     ipmi_cmdlang_out(cmd_info, "Control", NULL);
00541     ipmi_cmdlang_down(cmd_info);
00542     ipmi_cmdlang_out(cmd_info, "Name", control_name);
00543     num = ipmi_control_get_num_vals(control);
00544     for (i=0; i<num; i++) {
00545         ipmi_cmdlang_out(cmd_info, "Value", NULL);
00546         ipmi_cmdlang_down(cmd_info);
00547         ipmi_cmdlang_out_int(cmd_info, "Num", i);
00548         ipmi_cmdlang_out_int(cmd_info, "Value", val[i]);
00549         ipmi_cmdlang_up(cmd_info);
00550     }
00551     ipmi_cmdlang_up(cmd_info);
00552 
00553  out:
00554     if (cmdlang->err) {
00555         ipmi_control_get_name(control, cmdlang->objstr,
00556                               cmdlang->objstr_len);
00557         cmdlang->location = "cmd_control.c(control_get_light_done)";
00558     }
00559     ipmi_cmdlang_unlock(cmd_info);
00560     ipmi_cmdlang_cmd_info_put(cmd_info);
00561 }

static void control_get_id_done (  ipmi_control_t *  control,
int  err,
unsigned char *  val,
int  length,
void *  cb_data
)  [static]
 

Definition at line 492 of file cmd_control.c.

References cmdlang, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_lock(), ipmi_cmdlang_out_binary(), ipmi_cmdlang_unlock(), ipmi_control_get_name(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by control_get().

00497 {
00498     ipmi_cmd_info_t *cmd_info = cb_data;
00499     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00500 
00501     ipmi_cmdlang_lock(cmd_info);
00502     if (err) {
00503         cmdlang->errstr = "Error setting control";
00504         cmdlang->err = err;
00505         goto out;
00506     }
00507 
00508     ipmi_cmdlang_out_binary(cmd_info, "Data", (char *) val, length);
00509 
00510  out:
00511     if (cmdlang->err) {
00512         ipmi_control_get_name(control, cmdlang->objstr,
00513                               cmdlang->objstr_len);
00514         cmdlang->location = "cmd_control.c(control_get_light_done)";
00515     }
00516     ipmi_cmdlang_unlock(cmd_info);
00517     ipmi_cmdlang_cmd_info_put(cmd_info);
00518 }

static void control_get_light_done (  ipmi_control_t *  control,
int  err,
ipmi_light_setting_t *  s,
void *  cb_data
)  [static]
 

Definition at line 422 of file cmd_control.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_bool(), ipmi_cmdlang_out_int(), ipmi_cmdlang_unlock(), ipmi_cmdlang_up(), ipmi_control_get_name(), ipmi_get_color_string(), ipmi_light_setting_get_color(), ipmi_light_setting_get_count(), ipmi_light_setting_get_off_time(), ipmi_light_setting_get_on_time(), ipmi_light_setting_in_local_control(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by control_get().

00426 {
00427     ipmi_cmd_info_t *cmd_info = cb_data;
00428     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00429     int             i, num;
00430     int             rv;
00431 
00432     ipmi_cmdlang_lock(cmd_info);
00433     if (err) {
00434         cmdlang->errstr = "Error setting control";
00435         cmdlang->err = err;
00436         goto out;
00437     }
00438 
00439     num = ipmi_light_setting_get_count(s);
00440     for (i=0; i<num; i++) {
00441         int val;
00442 
00443         ipmi_cmdlang_out(cmd_info, "Light", NULL);
00444         ipmi_cmdlang_down(cmd_info);
00445         ipmi_cmdlang_out_int(cmd_info, "Num", i);
00446         rv = ipmi_light_setting_in_local_control(s, i, &val);
00447         if (rv) {
00448             cmdlang->errstr = "Error getting if in local control";
00449             cmdlang->err = rv;
00450             goto out;
00451         }
00452         ipmi_cmdlang_out_bool(cmd_info, "Local Control", val);
00453         if (!val) {
00454             rv = ipmi_light_setting_get_color(s, i, &val);
00455             if (rv) {
00456                 cmdlang->errstr = "Error getting color";
00457                 cmdlang->err = rv;
00458                 goto out;
00459             }
00460             ipmi_cmdlang_out(cmd_info, "Color", ipmi_get_color_string(val));
00461 
00462             rv = ipmi_light_setting_get_on_time(s, i, &val);
00463             if (rv) {
00464                 cmdlang->errstr = "Error getting on time";
00465                 cmdlang->err = rv;
00466                 goto out;
00467             }
00468             ipmi_cmdlang_out_int(cmd_info, "On Time", val);
00469 
00470             rv = ipmi_light_setting_get_off_time(s, i, &val);
00471             if (rv) {
00472                 cmdlang->errstr = "Error getting off time";
00473                 cmdlang->err = rv;
00474                 goto out;
00475             }
00476             ipmi_cmdlang_out_int(cmd_info, "Off Time", val);
00477         }
00478         ipmi_cmdlang_up(cmd_info);
00479     }
00480 
00481  out:
00482     if (cmdlang->err) {
00483         ipmi_control_get_name(control, cmdlang->objstr,
00484                               cmdlang->objstr_len);
00485         cmdlang->location = "cmd_control.c(control_get_light_done)";
00486     }
00487     ipmi_cmdlang_unlock(cmd_info);
00488     ipmi_cmdlang_cmd_info_put(cmd_info);
00489 }

static void control_info (  ipmi_control_t *  control,
void *  cb_data
)  [static]
 

Definition at line 195 of file cmd_control.c.

References control_dump(), control_name, ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), ipmi_control_get_name(), and IPMI_CONTROL_NAME_LEN.

00196 {
00197     ipmi_cmd_info_t *cmd_info = cb_data;
00198     char            control_name[IPMI_CONTROL_NAME_LEN];
00199 
00200     ipmi_control_get_name(control, control_name, sizeof(control_name));
00201 
00202     ipmi_cmdlang_out(cmd_info, "Control", NULL);
00203     ipmi_cmdlang_down(cmd_info);
00204     ipmi_cmdlang_out(cmd_info, "Name", control_name);
00205     control_dump(control, cmd_info);
00206     ipmi_cmdlang_up(cmd_info);
00207 }

static void control_list (  ipmi_entity_t *  entity,
void *  cb_data
)  [static]
 

Definition at line 62 of file cmd_control.c.

References control_list_handler(), ipmi_cmdlang_down(), ipmi_cmdlang_out(), ipmi_cmdlang_up(), ipmi_entity_get_name(), ipmi_entity_iterate_controls(), and IPMI_ENTITY_NAME_LEN.

00063 {
00064     ipmi_cmd_info_t *cmd_info = cb_data;
00065     char            entity_name[IPMI_ENTITY_NAME_LEN];
00066 
00067     ipmi_entity_get_name(entity, entity_name, sizeof(entity_name));
00068     ipmi_cmdlang_out(cmd_info, "Entity", NULL);
00069     ipmi_cmdlang_down(cmd_info);
00070     ipmi_cmdlang_out(cmd_info, "Name", entity_name);
00071     ipmi_cmdlang_out(cmd_info, "Controls", NULL);
00072     ipmi_cmdlang_down(cmd_info);
00073     ipmi_entity_iterate_controls(entity, control_list_handler, cmd_info);
00074     ipmi_cmdlang_up(cmd_info);
00075     ipmi_cmdlang_up(cmd_info);
00076 }

static void control_list_handler (  ipmi_entity_t *  entity,
ipmi_control_t *  control,
void *  cb_data
)  [static]
 

Definition at line 46 of file cmd_control.c.

References cmdlang, control_name, ipmi_cmdlang_s::err, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_out(), ipmi_control_get_name(), and IPMI_CONTROL_NAME_LEN.

Referenced by control_list().

00048 {
00049     ipmi_cmd_info_t *cmd_info = cb_data;
00050     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00051     char            control_name[IPMI_CONTROL_NAME_LEN];
00052 
00053     if (cmdlang->err)
00054         return;
00055 
00056     ipmi_control_get_name(control, control_name, sizeof(control_name));
00057 
00058     ipmi_cmdlang_out(cmd_info, "Name", control_name);
00059 }

static void control_set (  ipmi_control_t *  control,
void *  cb_data
)  [static]
 

Definition at line 237 of file cmd_control.c.

References cmdlang, control_set_done(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, i, ipmi_alloc_light_settings(), 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_color(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_get_int(), ipmi_cmdlang_get_uchar(), IPMI_CONTROL_ALARM, IPMI_CONTROL_DISPLAY, IPMI_CONTROL_FAN_SPEED, ipmi_control_get_name(), ipmi_control_get_num_vals(), ipmi_control_get_type(), IPMI_CONTROL_IDENTIFIER, ipmi_control_identifier_get_max_length(), ipmi_control_identifier_set_val(), IPMI_CONTROL_LIGHT, ipmi_control_light_set_with_setting(), IPMI_CONTROL_ONE_SHOT_OUTPUT, IPMI_CONTROL_ONE_SHOT_RESET, IPMI_CONTROL_OUTPUT, IPMI_CONTROL_POWER, IPMI_CONTROL_RELAY, IPMI_CONTROL_RESET, ipmi_control_set_light(), ipmi_control_set_val(), ipmi_free_light_settings(), ipmi_light_setting_set_color(), ipmi_light_setting_set_local_control(), ipmi_light_setting_set_off_time(), ipmi_light_setting_set_on_time(), ipmi_mem_alloc(), ipmi_mem_free(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, ipmi_cmdlang_s::objstr_len, and s.

00238 {
00239     ipmi_cmd_info_t      *cmd_info = cb_data;
00240     ipmi_cmdlang_t       *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00241     int                  *data = NULL;
00242     unsigned char        *ucdata = NULL;
00243     int                  num;
00244     int                  i;
00245     int                  rv;
00246     int                  curr_arg = ipmi_cmdlang_get_curr_arg(cmd_info);
00247     int                  argc = ipmi_cmdlang_get_argc(cmd_info);
00248     char                 **argv = ipmi_cmdlang_get_argv(cmd_info);
00249     ipmi_light_setting_t *s = NULL;
00250 
00251 
00252     num = ipmi_control_get_num_vals(control);
00253     if ((argc - curr_arg) < num) {
00254         /* Not enough parameters */
00255         cmdlang->errstr = "Not enough parameters";
00256         cmdlang->err = EINVAL;
00257         goto out_err;
00258     }
00259 
00260     switch (ipmi_control_get_type(control)) {
00261     case IPMI_CONTROL_LIGHT:
00262         if (!ipmi_control_light_set_with_setting(control))
00263             goto normal_val_set;
00264 
00265         s = ipmi_alloc_light_settings(num);
00266         if (!s) {
00267             cmdlang->errstr = "Out of memory";
00268             cmdlang->err = ENOMEM;
00269             goto out_err;
00270         }
00271 
00272         for (i=0; i<num; i++) {
00273             int val;
00274 
00275             if (strcmp(argv[curr_arg], "lc") == 0) {
00276                 ipmi_light_setting_set_local_control(s, i, 1);
00277                 continue;
00278             } else if (strcmp(argv[curr_arg], "nolc") == 0) {
00279                 ipmi_light_setting_set_local_control(s, i, 0);
00280             } else {
00281                 cmdlang->errstr = "Invalid local control setting";
00282                 cmdlang->err = EINVAL;
00283                 goto out_err;
00284             }
00285             curr_arg++;
00286 
00287             ipmi_cmdlang_get_color(argv[curr_arg], &val, cmd_info);
00288             if (cmdlang->err)
00289                 goto out_err;
00290             rv = ipmi_light_setting_set_color(s, i, val);
00291             if (rv) {
00292                 cmdlang->errstr = "Error setting color";
00293                 cmdlang->err = rv;
00294                 goto out_err;
00295             }
00296             curr_arg++;
00297 
00298             ipmi_cmdlang_get_int(argv[curr_arg], &val, cmd_info);
00299             if (cmdlang->err) {
00300                 cmdlang->errstr = "Invalid on time";
00301                 goto out_err;
00302             }
00303             rv = ipmi_light_setting_set_on_time(s, i, val);
00304             if (rv) {
00305                 cmdlang->errstr = "Error setting on time";
00306                 cmdlang->err = rv;
00307                 goto out_err;
00308             }
00309             curr_arg++;
00310 
00311             ipmi_cmdlang_get_int(argv[curr_arg], &val, cmd_info);
00312             if (cmdlang->err) {
00313                 cmdlang->errstr = "Invalid off time";
00314                 goto out_err;
00315             }
00316             rv = ipmi_light_setting_set_off_time(s, i, val);
00317             if (rv) {
00318                 cmdlang->errstr = "Error setting off time";
00319                 cmdlang->err = rv;
00320                 goto out_err;
00321             }
00322             curr_arg++;
00323         }
00324 
00325         ipmi_cmdlang_cmd_info_get(cmd_info);
00326         rv = ipmi_control_set_light(control, s, control_set_done,
00327                                     cmd_info);
00328         if (rv) {
00329             ipmi_cmdlang_cmd_info_put(cmd_info);
00330             cmdlang->errstr = "Error setting light control";
00331             cmdlang->err = rv;
00332             goto out_err;
00333         }
00334         ipmi_free_light_settings(s);
00335         break;
00336 
00337     case IPMI_CONTROL_IDENTIFIER:
00338         num = ipmi_control_identifier_get_max_length(control);
00339         ucdata = ipmi_mem_alloc(num);
00340         if (!ucdata) {
00341             cmdlang->errstr = "Out of memory";
00342             cmdlang->err = ENOMEM;
00343             goto out_err;
00344         }
00345         for (i=0; i<num; i++) {
00346             ipmi_cmdlang_get_uchar(argv[curr_arg], &ucdata[i], cmd_info);
00347             if (cmdlang->err) {
00348                 cmdlang->errstr = "value invalid";
00349                 goto out_err;
00350             }
00351             curr_arg++;
00352         }
00353         
00354         ipmi_cmdlang_cmd_info_get(cmd_info);
00355         rv = ipmi_control_identifier_set_val(control, ucdata, i,
00356                                              control_set_done, cmd_info);
00357         if (rv) {
00358             ipmi_cmdlang_cmd_info_put(cmd_info);
00359             cmdlang->errstr = "Error setting id control";
00360             cmdlang->err = rv;
00361             goto out_err;
00362         }
00363         ipmi_mem_free(ucdata);
00364         break;
00365 
00366     case IPMI_CONTROL_DISPLAY:
00367         cmdlang->errstr = "Setting displays not currently supported";
00368         cmdlang->err = ENOSYS;
00369         goto out_err;
00370         break;
00371 
00372     case IPMI_CONTROL_RELAY:
00373     case IPMI_CONTROL_ALARM:
00374     case IPMI_CONTROL_RESET:
00375     case IPMI_CONTROL_POWER:
00376     case IPMI_CONTROL_FAN_SPEED:
00377     case IPMI_CONTROL_ONE_SHOT_RESET:
00378     case IPMI_CONTROL_OUTPUT:
00379     case IPMI_CONTROL_ONE_SHOT_OUTPUT:
00380     normal_val_set:
00381         data = ipmi_mem_alloc(num * sizeof(int));
00382         if (!data) {
00383             cmdlang->errstr = "Out of memory";
00384             cmdlang->err = ENOMEM;
00385             goto out_err;
00386         }
00387         for (i=0; i<num; i++) {
00388             ipmi_cmdlang_get_int(argv[curr_arg], &data[i], cmd_info);
00389             if (cmdlang->err) {
00390                 cmdlang->errstr = "value invalid";
00391                 goto out_err;
00392             }
00393             curr_arg++;
00394         }
00395 
00396         ipmi_cmdlang_cmd_info_get(cmd_info);
00397         rv = ipmi_control_set_val(control, data, control_set_done, cmd_info);
00398         if (rv) {
00399             ipmi_cmdlang_cmd_info_put(cmd_info);
00400             cmdlang->errstr = "Error setting control";
00401             cmdlang->err = rv;
00402             goto out_err;
00403         }
00404         ipmi_mem_free(data);
00405         break;
00406     }
00407     return;
00408 
00409  out_err:
00410     ipmi_control_get_name(control, cmdlang->objstr,
00411                          cmdlang->objstr_len);
00412     cmdlang->location = "cmd_control.c(control_set)";
00413     if (s)
00414         ipmi_free_light_settings(s);
00415     if (ucdata)
00416         ipmi_mem_free(ucdata);
00417     if (data)
00418         ipmi_mem_free(data);
00419 }

static void control_set_done (  ipmi_control_t *  control,
int  err,
void *  cb_data
)  [static]
 

Definition at line 210 of file cmd_control.c.

References cmdlang, control_name, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_cmd_info_put(), ipmi_cmdlang_lock(), ipmi_cmdlang_out(), ipmi_cmdlang_unlock(), ipmi_control_get_name(), IPMI_CONTROL_NAME_LEN, ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, and ipmi_cmdlang_s::objstr_len.

Referenced by control_set().

00213 {
00214     ipmi_cmd_info_t *cmd_info = cb_data;
00215     ipmi_cmdlang_t  *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info);
00216     char            control_name[IPMI_CONTROL_NAME_LEN];
00217 
00218     ipmi_cmdlang_lock(cmd_info);
00219     if (err) {
00220         cmdlang->errstr = "Error setting control";
00221         cmdlang->err = err;
00222         ipmi_control_get_name(control, cmdlang->objstr,
00223                               cmdlang->objstr_len);
00224         cmdlang->location = "cmd_control.c(control_set_done)";
00225         goto out;
00226     }
00227 
00228     ipmi_control_get_name(control, control_name, sizeof(control_name));
00229     ipmi_cmdlang_out(cmd_info, "Set done", control_name);
00230 
00231  out:
00232     ipmi_cmdlang_unlock(cmd_info);
00233     ipmi_cmdlang_cmd_info_put(cmd_info);
00234 }

void ipmi_cmdlang_control_change (  enum ipmi_update_e  op,
ipmi_entity_t *  entity,
ipmi_control_t *  control,
void *  cb_data
) 
 

Definition at line 686 of file cmd_control.c.

References control_dump(), control_event_handler(), control_name, 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_control_add_val_event_handler(), ipmi_control_get_name(), ipmi_control_has_events(), IPMI_CONTROL_NAME_LEN, and IPMI_DELETED.

Referenced by ipmi_cmdlang_entity_change().

00690 {
00691     char            *errstr;
00692     int             rv;
00693     ipmi_cmd_info_t *evi;
00694     char            control_name[IPMI_CONTROL_NAME_LEN];
00695 
00696     ipmi_control_get_name(control, control_name, sizeof(control_name));
00697 
00698     evi = ipmi_cmdlang_alloc_event_info();
00699     if (!evi) {
00700         rv = ENOMEM;
00701         errstr = "Out of memory";
00702         goto out_err;
00703     }
00704 
00705     ipmi_cmdlang_out(evi, "Object Type", "Control");
00706     ipmi_cmdlang_out(evi, "Name", control_name);
00707 
00708     switch (op) {
00709     case IPMI_ADDED:
00710         ipmi_cmdlang_out(evi, "Operation", "Add");
00711         if (ipmi_cmdlang_get_evinfo())
00712             control_dump(control, evi);
00713 
00714         if (ipmi_control_has_events(control)) {
00715             rv = ipmi_control_add_val_event_handler(control,
00716                                                     control_event_handler,
00717                                                     NULL);
00718             if (rv) {
00719                 ipmi_cmdlang_global_err
00720                     (control_name,
00721                      "cmd_control.c(ipmi_cmdlang_control_change)",
00722                      "Unable to set event handler for control",
00723                      rv);
00724             }
00725         }
00726         break;
00727 
00728         case IPMI_DELETED:
00729             ipmi_cmdlang_out(evi, "Operation", "Delete");
00730             break;
00731 
00732         case IPMI_CHANGED:
00733             ipmi_cmdlang_out(evi, "Operation", "Change");
00734             if (ipmi_cmdlang_get_evinfo())
00735                 control_dump(control, evi);
00736             break;
00737     }
00738 
00739     ipmi_cmdlang_cmd_info_put(evi);
00740     return;
00741 
00742  out_err:
00743     ipmi_cmdlang_global_err(control_name,
00744                             "cmd_control.c(ipmi_cmdlang_control_change)",
00745                             errstr, rv);
00746     if (evi)
00747         ipmi_cmdlang_cmd_info_put(evi);
00748 }

int ipmi_cmdlang_control_init (  os_handler_t *  os_hnd  ) 
 

Definition at line 778 of file cmd_control.c.

References CMDS_CONTROL_LEN, and ipmi_cmdlang_reg_table().

Referenced by ipmi_cmdlang_init().

00779 {
00780     return ipmi_cmdlang_reg_table(cmds_control, CMDS_CONTROL_LEN);
00781 }

Variable Documentation

ipmi_cmdlang_init_t cmds_control[] [static]
 

Initial value:

{
    { "control", NULL,
      "- Commands dealing with controls",
      NULL, NULL, &control_cmds },
    { "list", &control_cmds,
      "- List all the entities in the system",
      ipmi_cmdlang_entity_handler, control_list, NULL },
    { "info", &control_cmds,
      "<control> - Dump information about an control",
      ipmi_cmdlang_control_handler, control_info, NULL },
    { "set", &control_cmds,
      "<control> <values> - Set the value of a control.  The settings"
      " depend on control type, most take one or more integer values. "
      " An identifier type takes one or more unsigned characters.  A"
      " light set with settings take the form 'lc|nolc <color> <on time>"
      " <off time>.  lc and nolc turn on or of local control, the over"
      " values should be obvious.",
      ipmi_cmdlang_control_handler, control_set, NULL },
    { "get", &control_cmds,
      "<control> - Get the value of a control",
      ipmi_cmdlang_control_handler, control_get, NULL },
}

Definition at line 752 of file cmd_control.c.

ipmi_cmdlang_cmd_t* control_cmds [static]
 

Definition at line 750 of file cmd_control.c.

© sourcejam.com 2005-2008