ipmish.c File Reference

#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <termios.h>
#include <unistd.h>
#include <signal.h>
#include <OpenIPMI/selector.h>
#include <OpenIPMI/ipmi_conn.h>
#include <OpenIPMI/ipmi_err.h>
#include <OpenIPMI/ipmi_posix.h>
#include <OpenIPMI/ipmi_glib.h>
#include <OpenIPMI/ipmi_cmdlang.h>
#include <OpenIPMI/ipmi_debug.h>
#include <editline/readline.h>
#include <OpenIPMI/internal/ipmi_malloc.h>

Go to the source code of this file.

Classes
struct	out_data_s
struct	exec_list_s
Typedefs
typedef out_data_s	out_data_t
typedef exec_list_s	exec_list_t
Functions
static void	user_input_ready (int fd, void *data, os_hnd_fd_id_t *id)
static void	redraw_cmdline (int force)
static void	my_vlog (os_handler_t *handler, const char *format, enum ipmi_log_type_e log_type, va_list ap)
static void	enable_term_fd (ipmi_cmdlang_t *cmdlang)
static void	disable_term_fd (ipmi_cmdlang_t *cmdlang)
static void	out_help (FILE *s, int indent, const char *name, const char *v)
static void	out_value (ipmi_cmdlang_t *info, const char *name, const char *value)
static void	out_binary (ipmi_cmdlang_t *info, const char *name, const char *value, unsigned int len)
static void	out_unicode (ipmi_cmdlang_t *info, const char *name, const char *value, unsigned int len)
static void	down_level (ipmi_cmdlang_t *info)
static void	up_level (ipmi_cmdlang_t *info)
static void	cmd_done (ipmi_cmdlang_t *info)
void	ipmi_cmdlang_global_err (char *objstr, char *location, char *errstr, int errval)
void	ipmi_cmdlang_report_event (ipmi_cmdlang_event_t *event)
static void	rl_ipmish_cb_handler (char *cmdline)
static void	cleanup_term (void)
static void	cleanup_sig (int sig)
static void	setup_term (os_handler_t *os_hnd)
static void	redisp_cmd (ipmi_cmd_info_t *cmd_info)
static void	exit_cmd (ipmi_cmd_info_t *cmd_info)
static void	read_cmd (ipmi_cmd_info_t *cmd_info)
static void	setup_cmds (void)
static void	domain_down (void *cb_data)
static void	shutdown_domain_handler (ipmi_domain_t *domain, void *cb_data)
static void	add_exec_str (char *str)
static void	usage (char *name)
int	main (int argc, char *argv[])
Variables
os_handler_t	ipmi_debug_os_handlers
selector_t *	debug_sel
os_hnd_fd_id_t *	term_fd_id
static int	done = 0
static int	evcount = 0
static int	handling_input = 0
static int	cmd_redisp = 1
static int	columns = 80
static out_data_t	lout_data
static char	cmdlang_objstr [IPMI_MAX_NAME_LEN]
static ipmi_cmdlang_t	cmdlang
int *	done_ptr = NULL
static int	read_nest = 0
static exec_list_t *	execs
static exec_list_t *	execs_tail
static char *	usage_str

---

Typedef Documentation

typedef struct exec_list_s exec_list_t

typedef struct out_data_s out_data_t

---

Function Documentation

static void add_exec_str (  char *  str  )  [static]

Definition at line 845 of file ipmish.c. References e, and exec_list_s::next. Referenced by main(). { exec_list_t *e; e = malloc(sizeof(*e)); if (!e) { fprintf(stderr, "Out of memory"); exit(1); } e->str = str; e->next = NULL; if (execs) execs_tail->next = e; else execs = e; execs_tail = e; }

static void cleanup_sig (  int  sig  )  [static]

Definition at line 826 of file ipmish.c. References cleanup_term(), done, ipmi_domain_iterate_domains(), ipmi_cmdlang_s::os_hnd, os_handler_s::perform_one_op, and shutdown_domain_handler(). Referenced by setup_term(). { fprintf(stderr, "Exiting due to signal %d\n", sig); done = 0; ipmi_domain_iterate_domains(shutdown_domain_handler, &done); while (done) cmdlang.os_hnd->perform_one_op(cmdlang.os_hnd, NULL); cleanup_term(); exit(1); }

static void cleanup_term (  void   )  [static]

Definition at line 639 of file ipmish.c. References disable_term_fd(), and rl_callback_handler_remove(). Referenced by cleanup_sig(), and main(). { rl_callback_handler_remove(); disable_term_fd(&cmdlang); }

static void cmd_done (  ipmi_cmdlang_t *  info  )  [static]

Definition at line 506 of file ipmish.c. References enable_term_fd(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdlang_s::errstr_dynalloc, handling_input, ipmi_get_error_string(), ipmi_mem_free(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::objstr, redraw_cmdline(), out_data_s::stream, and ipmi_cmdlang_s::user_data. { out_data_t *out_data = info->user_data; if (info->err) { char errval[128]; if (!info->location) info->location = ""; if (strlen(info->objstr) == 0) { fprintf(out_data->stream, "error: %s: %s (0x%x, %s)\n", info->location, info->errstr, info->err, ipmi_get_error_string(info->err, errval, sizeof(errval))); } else { fprintf(out_data->stream, "error: %s %s: %s (0x%x, %s)\n", info->location, info->objstr, info->errstr, info->err, ipmi_get_error_string(info->err, errval, sizeof(errval))); } if (info->errstr_dynalloc) ipmi_mem_free(info->errstr); info->errstr_dynalloc = 0; info->errstr = NULL; info->location = NULL; info->objstr[0] = '\0'; info->err = 0; } if (done_ptr) { *done_ptr = 1; } else { handling_input = 1; redraw_cmdline(1); enable_term_fd(info); fflush(out_data->stream); } }

static void disable_term_fd (  ipmi_cmdlang_t *  cmdlang  )  [static]

Definition at line 201 of file ipmish.c. References ipmi_cmdlang_s::os_hnd, and os_handler_s::remove_fd_to_wait_for. Referenced by cleanup_term(), and read_cmd(). { int rv; if (!term_fd_id) return; rv = cmdlang->os_hnd->remove_fd_to_wait_for(cmdlang->os_hnd, term_fd_id); if (rv) { fprintf(stderr, "error removing terminal handler, giving up\n"); exit(1); } term_fd_id = NULL; }

static void domain_down (  void *  cb_data  )  [static]

Definition at line 808 of file ipmish.c. Referenced by shutdown_domain_handler(). { int *count = cb_data; (*count)--; }

static void down_level (  ipmi_cmdlang_t *  info  )  [static]

Definition at line 463 of file ipmish.c. References out_data_s::indent, and ipmi_cmdlang_s::user_data. { out_data_t *out_data = info->user_data; out_data->indent++; }

static void enable_term_fd (  ipmi_cmdlang_t *  cmdlang  )  [static]

Definition at line 183 of file ipmish.c. References os_handler_s::add_fd_to_wait_for, ipmi_cmdlang_s::os_hnd, and user_input_ready(). Referenced by cmd_done(), main(), and read_cmd(). { int rv; if (term_fd_id) return; rv = cmdlang->os_hnd->add_fd_to_wait_for(cmdlang->os_hnd, 0, user_input_ready, cmdlang, NULL, &term_fd_id); if (rv) { fprintf(stderr, "error enabling terminal handler, giving up\n"); exit(1); } }

static void exit_cmd (  ipmi_cmd_info_t *  cmd_info  )  [static]

Definition at line 695 of file ipmish.c. References done, evcount, and ipmi_cmdlang_out(). Referenced by setup_cmds(). { done = 1; evcount = 0; ipmi_cmdlang_out(cmd_info, "Exiting ipmish", NULL); }

void ipmi_cmdlang_global_err (  char *  objstr, char *  location, char *  errstr, int  errval )

Definition at line 545 of file ipmish.c. References cmd_redisp, done, evcount, handling_input, and redraw_cmdline(). Referenced by control_event_handler(), domain_change(), domain_con_change(), domain_event_handler(), domain_fully_up(), entity_hot_swap(), event_done(), for_each_control_handler(), for_each_entity_handler(), for_each_fru_handler(), for_each_lanparm_handler(), for_each_mc_handler(), for_each_pef_handler(), for_each_pet_handler(), for_each_sensor_handler(), for_each_solparm_handler(), fru_change(), ipmi_cmdlang_control_change(), ipmi_cmdlang_entity_change(), ipmi_cmdlang_mc_change(), ipmi_cmdlang_sensor_change(), mc_active(), mc_fully_up(), presence_change(), sensor_discrete_event_handler(), and sensor_threshold_event_handler(). { if (handling_input && !done && cmd_redisp) fputc('\n', stdout); if (objstr) fprintf(stderr, "global error: %s %s: %s (0x%x)", location, objstr, errstr, errval); else fprintf(stderr, "global error: %s: %s (0x%x)", location, errstr, errval); evcount = 0; redraw_cmdline(0); }

void ipmi_cmdlang_report_event (  ipmi_cmdlang_event_t *  event  )

Definition at line 563 of file ipmish.c. References cmd_redisp, done, evcount, handling_input, i, IPMI_CMDLANG_BINARY, ipmi_cmdlang_event_next_field(), ipmi_cmdlang_event_restart(), IPMI_CMDLANG_STRING, IPMI_CMDLANG_UNICODE, name, and redraw_cmdline(). Referenced by event_done(). { unsigned int level, len; enum ipmi_cmdlang_out_types type; char *name, *value; int indent2; int i; if (handling_input && !done && cmd_redisp) fputc('\n', stdout); ipmi_cmdlang_event_restart(event); printf("Event\n"); while (ipmi_cmdlang_event_next_field(event, &level, &type, &name, &len, &value)) { switch (type) { case IPMI_CMDLANG_STRING: if (value) printf(" %*s%s: %s\n", level*2, "", name, value); else printf(" %*s%s\n", level*2, "", name); break; case IPMI_CMDLANG_BINARY: case IPMI_CMDLANG_UNICODE: indent2 = (level * 2) + strlen(name) + 1; printf(" %*s%s:", level*2, "", name); for (i=0; i<len; i++) { if ((i != 0) && ((i % 8) == 0)) printf("\n %*s", indent2, ""); printf(" 0x%2.2x", value[i] & 0xff); } printf("\n"); fflush(stdout); break; } } evcount = 0; redraw_cmdline(0); }

int main (  int  argc, char *  argv[] )

Definition at line 890 of file ipmish.c. References add_exec_str(), cleanup_term(), DEBUG_LOCKS_ENABLE, DEBUG_MALLOC_ENABLE, DEBUG_MSG_ENABLE, DEBUG_MSG_ERR_ENABLE, DEBUG_RAWMSG_ENABLE, done, e, enable_term_fd(), evcount, glib_handle_log(), handling_input, ipmi_cmdlang_cleanup(), ipmi_cmdlang_init(), ipmi_debug_malloc_cleanup(), ipmi_domain_iterate_domains(), ipmi_glib_get_os_handler(), ipmi_init(), ipmi_posix_os_handler_get_sel(), ipmi_posix_setup_os_handler(), ipmi_shutdown(), my_vlog(), exec_list_s::next, os_hnd, os_handler_s::perform_one_op, rl_ipmish_cb_handler(), sel_alloc_selector(), os_handler_s::set_log_handler, setup_cmds(), setup_term(), shutdown_domain_handler(), exec_list_s::str, and usage(). { int rv; int curr_arg = 1; const char *arg; #ifdef HAVE_UCDSNMP int init_snmp = 0; selector_t *sel; #endif os_handler_t *os_hnd; int use_debug_os = 0; char *colstr; #ifdef HAVE_GLIB int use_glib = 0; #endif colstr = getenv("COLUMNS"); if (colstr) { int tmp = strtoul(colstr, NULL, 0); if (tmp) columns = tmp; } while ((curr_arg < argc) && (argv[curr_arg][0] == '-')) { arg = argv[curr_arg]; curr_arg++; if (strcmp(arg, "--") == 0) { break; } else if ((strcmp(arg, "-x") == 0) || (strcmp(arg, "--execute") == 0)) { if (curr_arg >= argc) { fprintf(stderr, "No option given for %s", arg); usage(argv[0]); return 1; } add_exec_str(argv[curr_arg]); curr_arg++; } else if (strcmp(arg, "--dlock") == 0) { DEBUG_LOCKS_ENABLE(); use_debug_os = 1; } else if (strcmp(arg, "--dmem") == 0) { DEBUG_MALLOC_ENABLE(); } else if (strcmp(arg, "--drawmsg") == 0) { DEBUG_RAWMSG_ENABLE(); } else if (strcmp(arg, "--dmsg") == 0) { DEBUG_MSG_ENABLE(); } else if (strcmp(arg, "--dmsgerr") == 0) { DEBUG_MSG_ERR_ENABLE(); #ifdef HAVE_UCDSNMP } else if (strcmp(arg, "--snmp") == 0) { init_snmp = 1; #endif #ifdef HAVE_GLIB } else if (strcmp(arg, "--glib") == 0) { use_glib = 1; #endif } else if (strcmp(arg, "--help") == 0) { usage(argv[0]); return 0; } else { fprintf(stderr, "Unknown option: %s\n", arg); usage(argv[0]); return 1; } } if (use_debug_os) { os_hnd = &ipmi_debug_os_handlers; rv = sel_alloc_selector(os_hnd, &debug_sel); if (rv) { fprintf(stderr, "Could not allocate selector\n"); return 1; } #ifdef HAVE_UCDSNMP sel = debug_sel; #endif #ifdef HAVE_GLIB } else if (use_glib) { #ifdef HAVE_UCDSNMP init_snmp = 0; /* No SNMP support for glib yet. */ sel = NULL; #endif g_thread_init(NULL); os_hnd = ipmi_glib_get_os_handler(); if (!os_hnd) { fprintf(stderr, "ipmi_smi_setup_con: Unable to allocate os handler\n"); return 1; } g_log_set_handler("OpenIPMI", G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_FATAL, glib_handle_log, NULL); #endif } else { os_hnd = ipmi_posix_setup_os_handler(); if (!os_hnd) { fprintf(stderr, "ipmi_smi_setup_con: Unable to allocate os handler\n"); return 1; } #ifdef HAVE_UCDSNMP sel = ipmi_posix_os_handler_get_sel(os_hnd); #endif } os_hnd->set_log_handler(os_hnd, my_vlog); /* Initialize the OpenIPMI library. */ ipmi_init(os_hnd); #ifdef HAVE_UCDSNMP if (init_snmp) { if (snmp_init(sel) < 0) return 1; } #endif rv = ipmi_cmdlang_init(os_hnd); if (rv) { fprintf(stderr, "Unable to initialize command processor: 0x%x\n", rv); return 1; } setup_cmds(); setup_term(os_hnd); while (execs) { exec_list_t *e = execs; int cdone = 0; read_nest = 1; execs = e->next; printf("> %s\n", e->str); fflush(stdout); done_ptr = &cdone; rl_ipmish_cb_handler(e->str); while (!cdone) os_hnd->perform_one_op(os_hnd, NULL); done_ptr = NULL; free(e); read_nest = 0; } fflush(stdout); handling_input = 1; enable_term_fd(&cmdlang); while (!done) os_hnd->perform_one_op(os_hnd, NULL); cleanup_term(); /* Shut down all existing domains. */ done = 0; ipmi_domain_iterate_domains(shutdown_domain_handler, &done); while (done) os_hnd->perform_one_op(os_hnd, NULL); ipmi_cmdlang_cleanup(); ipmi_shutdown(); ipmi_debug_malloc_cleanup(); os_hnd->free_os_handler(os_hnd); /* remove the prompt which editline printed */ printf("\b\b \b\b"); if (evcount) printf("\n"); fflush(stdout); if (rv) return 1; return 0; }

static void my_vlog (  os_handler_t *  handler, const char *  format, enum ipmi_log_type_e  log_type, va_list  ap )  [static]

Definition at line 101 of file ipmish.c. References cmd_redisp, done, handling_input, IPMI_LOG_DEBUG, IPMI_LOG_DEBUG_CONT, IPMI_LOG_DEBUG_END, IPMI_LOG_DEBUG_START, IPMI_LOG_ERR_INFO, IPMI_LOG_FATAL, IPMI_LOG_INFO, IPMI_LOG_SEVERE, IPMI_LOG_WARNING, and redraw_cmdline(). Referenced by main(), and test_os_handler(). { int do_nl = 1; static int last_was_cont = 0; if (handling_input && !last_was_cont && !done && cmd_redisp) fputc('\n', stdout); last_was_cont = 0; switch(log_type) { case IPMI_LOG_INFO: printf("INFO: "); break; case IPMI_LOG_WARNING: printf("WARN: "); break; case IPMI_LOG_SEVERE: printf("SEVR: "); break; case IPMI_LOG_FATAL: printf("FATL: "); break; case IPMI_LOG_ERR_INFO: printf("EINF: "); break; case IPMI_LOG_DEBUG_START: do_nl = 0; last_was_cont = 1; /* FALLTHROUGH */ case IPMI_LOG_DEBUG: printf("DEBG: "); break; case IPMI_LOG_DEBUG_CONT: last_was_cont = 1; do_nl = 0; /* FALLTHROUGH */ case IPMI_LOG_DEBUG_END: break; } vprintf(format, ap); if (do_nl) { printf("\n"); redraw_cmdline(0); } }

static void out_binary (  ipmi_cmdlang_t *  info, const char *  name, const char *  value, unsigned int  len )  [static]

Definition at line 432 of file ipmish.c. References ipmi_cmdlang_s::help, i, out_data_s::indent, out_data_s::stream, and ipmi_cmdlang_s::user_data. Referenced by out_unicode(). { out_data_t *out_data = info->user_data; unsigned char *data = (unsigned char *) value; int indent2 = (out_data->indent * 2) + strlen(name) + 1; int i; char *sep = ":"; if (info->help) sep = ""; fprintf(out_data->stream, "%*s%s%s", out_data->indent*2, "", name, sep); for (i=0; i<len; i++) { if ((i != 0) && ((i % 8) == 0)) fprintf(out_data->stream, "\n%*s", indent2, ""); fprintf(out_data->stream, " 0x%2.2x", (data[i] & 0xff)); } fprintf(out_data->stream, "\n"); fflush(out_data->stream); }

static void out_help (  FILE *  s, int  indent, const char *  name, const char *  v )  [static]

Definition at line 381 of file ipmish.c. References pos. Referenced by out_value(). { int pos, endpos; const char *endword; const char *endspace; pos = fprintf(s, "%*s%s ", indent, "", name); while (*v) { endword = v; while (isspace(*endword)) { if (*endword == '\n') { v = endword + 1; fprintf(s, "\n%*s", indent+2, ""); pos = indent + 2; } endword++; } endspace = endword; while (*endword && !isspace(*endword)) endword++; endpos = pos + endword - v; if (endpos > columns) { v = endspace; fprintf(s, "\n%*s", indent+2, ""); pos = indent + 2; } fwrite(v, 1, endword-v, s); pos += endword - v; v = endword; } fputc('\n', s); }

static void out_unicode (  ipmi_cmdlang_t *  info, const char *  name, const char *  value, unsigned int  len )  [static]

Definition at line 456 of file ipmish.c. References out_binary(). { out_binary(info, name, value, len); }

static void out_value (  ipmi_cmdlang_t *  info, const char *  name, const char *  value )  [static]

Definition at line 415 of file ipmish.c. References ipmi_cmdlang_s::help, out_data_s::indent, out_help(), out_data_s::stream, and ipmi_cmdlang_s::user_data. { out_data_t *out_data = info->user_data; if (value) { if (info->help) { out_help(out_data->stream, out_data->indent*2, name, value); } else { fprintf(out_data->stream, "%*s%s: %s\n", out_data->indent*2, "", name, value); } } else fprintf(out_data->stream, "%*s%s\n", out_data->indent*2, "", name); fflush(out_data->stream); }

static void read_cmd (  ipmi_cmd_info_t *  cmd_info  )  [static]

Definition at line 704 of file ipmish.c. References disable_term_fd(), enable_term_fd(), ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, handling_input, out_data_s::indent, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_handle(), ipmi_cmdlang_out(), ipmi_cmdlang_s::location, ipmi_cmdlang_s::os_hnd, os_handler_s::perform_one_op, s, out_data_s::stream, and ipmi_cmdlang_s::user_data. Referenced by setup_cmds(). { ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); int cdone; char cmdline[256]; FILE *s; out_data_t my_out_data; ipmi_cmdlang_t my_cmdlang = *cmdlang; 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 *saved_done_ptr; char *fname; if ((argc - curr_arg) < 1) { cmdlang->errstr = "No filename entered"; cmdlang->err = EINVAL; goto out_err; } fname = argv[curr_arg]; curr_arg++; s = fopen(fname, "r"); if (!s) { cmdlang->errstr = "Unable to openfile"; cmdlang->err = errno; goto out_err; } if (!read_nest) { handling_input = 0; disable_term_fd(cmdlang); } read_nest++; saved_done_ptr = done_ptr; /* not record the file's commands into history */ while (fgets(cmdline, sizeof(cmdline), s)) { my_out_data.stream = stdout; my_out_data.indent = 0; my_cmdlang.user_data = &my_out_data; cdone = 0; done_ptr = &cdone; printf("> %s", cmdline); fflush(stdout); ipmi_cmdlang_handle(&my_cmdlang, cmdline); while (!cdone) cmdlang->os_hnd->perform_one_op(cmdlang->os_hnd, NULL); done_ptr = NULL; } fclose(s); done_ptr = saved_done_ptr; read_nest--; if (!read_nest) { handling_input = 1; enable_term_fd(cmdlang); } ipmi_cmdlang_out(cmd_info, "File read", fname); return; out_err: cmdlang->location = "ipmish.c(read_cmd)"; }

static void redisp_cmd (  ipmi_cmd_info_t *  cmd_info  )  [static]

Definition at line 664 of file ipmish.c. References cmd_redisp, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdinfo_get_cmdlang(), ipmi_cmdlang_get_argc(), ipmi_cmdlang_get_argv(), ipmi_cmdlang_get_bool(), ipmi_cmdlang_get_curr_arg(), ipmi_cmdlang_out(), and ipmi_cmdlang_s::location. Referenced by setup_cmds(). { ipmi_cmdlang_t *cmdlang = ipmi_cmdinfo_get_cmdlang(cmd_info); 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 redisp; if ((argc - curr_arg) < 1) { /* Not enough parameters */ cmdlang->errstr = "Not enough parameters"; cmdlang->err = EINVAL; goto out_err; } ipmi_cmdlang_get_bool(argv[curr_arg], &redisp, cmd_info); if (cmdlang->err) { cmdlang->errstr = "redisp setting invalid"; goto out_err; } curr_arg++; cmd_redisp = redisp; ipmi_cmdlang_out(cmd_info, "redisp set", NULL); out_err: cmdlang->location = "ipmish.c(redisp_cmd)"; }

static void redraw_cmdline (  int  force  )  [static]

Definition at line 88 of file ipmish.c. References cmd_redisp, done, handling_input, and rl_redisplay(). Referenced by cmd_done(), ipmi_cmdlang_global_err(), ipmi_cmdlang_report_event(), and my_vlog(). { int redisp = cmd_redisp; if (force) redisp = 1; if (!done && handling_input && redisp) { rl_redisplay(); fflush(stdout); } }

static void rl_ipmish_cb_handler (  char *  cmdline  )  [static]

Definition at line 612 of file ipmish.c. References add_history(), done, ipmi_cmdlang_s::err, ipmi_cmdlang_s::errstr, ipmi_cmdlang_s::errstr_dynalloc, evcount, handling_input, history_expand(), ipmi_cmdlang_handle(), and ipmi_cmdlang_s::location. Referenced by main(), and setup_term(). { char *expansion = NULL; int result; if (cmdline == NULL) { done = 1; evcount = 1; /* Force a newline */ return; } result = history_expand(cmdline, &expansion); if (result < 0 || result == 2) { fprintf(stderr, "%s\n", expansion); } else if (expansion && strlen(expansion)){ cmdlang.err = 0; cmdlang.errstr = NULL; cmdlang.errstr_dynalloc = 0; cmdlang.location = NULL; handling_input = 0; add_history(expansion); ipmi_cmdlang_handle(&cmdlang, expansion); } if (expansion) free(expansion); }

static void setup_cmds (  void   )  [static]

Definition at line 772 of file ipmish.c. References exit_cmd(), ipmi_cmdlang_reg_cmd(), read_cmd(), and redisp_cmd(). Referenced by main(). { int rv; rv = ipmi_cmdlang_reg_cmd(NULL, "redisp_cmd", "on|off - If an asynchronous event comes in," " redisplay the current working command. This" " is on by default.", redisp_cmd, NULL, NULL, NULL); if (rv) { fprintf(stderr, "Error adding exit command: 0x%x\n", rv); exit(1); } rv = ipmi_cmdlang_reg_cmd(NULL, "exit", "- leave the program", exit_cmd, NULL, NULL, NULL); if (rv) { fprintf(stderr, "Error adding exit command: 0x%x\n", rv); exit(1); } rv = ipmi_cmdlang_reg_cmd(NULL, "read", "<file> - Read commands from the file and" " execute them", read_cmd, NULL, NULL, NULL); if (rv) { fprintf(stderr, "Error adding read command: 0x%x\n", rv); exit(1); } }

static void setup_term (  os_handler_t *  os_hnd  )  [static]

Definition at line 648 of file ipmish.c. References cleanup_sig(), ipmi_cmdlang_s::os_hnd, rl_callback_handler_install(), rl_ipmish_cb_handler(), stifle_history(), and out_data_s::stream. Referenced by main(). { signal(SIGINT, cleanup_sig); signal(SIGPIPE, cleanup_sig); signal(SIGUSR1, cleanup_sig); signal(SIGUSR2, cleanup_sig); signal(SIGPWR, cleanup_sig); stifle_history(500); rl_callback_handler_install("> ", rl_ipmish_cb_handler); lout_data.stream = stdout; cmdlang.os_hnd = os_hnd; }

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

Definition at line 815 of file ipmish.c. References domain_down(), and ipmi_domain_close(). Referenced by cleanup_sig(), and main(). { int *count = cb_data; int rv; rv = ipmi_domain_close(domain, domain_down, cb_data); if (!rv) (*count)++; }

static void up_level (  ipmi_cmdlang_t *  info  )  [static]

Definition at line 471 of file ipmish.c. References out_data_s::indent, and ipmi_cmdlang_s::user_data. { out_data_t *out_data = info->user_data; out_data->indent--; }

static void usage (  char *  name  )  [static]

Definition at line 884 of file ipmish.c. Referenced by main(). { fprintf(stderr, usage_str, name, name); }

static void user_input_ready (  int  fd, void *  data, os_hnd_fd_id_t *  id )  [static]

Definition at line 606 of file ipmish.c. References rl_callback_read_char(). Referenced by enable_term_fd(), ipmi_ui_init(), and main(). { rl_callback_read_char(); }