From a7f89980e5b3f4b9a74c70dbc5ffe8aabd28be28 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Sun, 6 Jul 2014 18:04:32 +0200 Subject: Imported Upstream version 2.9.3 --- util/igetevent.c | 1439 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1439 insertions(+) create mode 100644 util/igetevent.c (limited to 'util/igetevent.c') diff --git a/util/igetevent.c b/util/igetevent.c new file mode 100644 index 0000000..6e2fe27 --- /dev/null +++ b/util/igetevent.c @@ -0,0 +1,1439 @@ +/* + * igetevent.c + * + * This utility waits for IPMI Event Messages. + * Some server management functions want to trigger custom actions or + * alerts when IPMI hardware-related events occur, but do not want to + * track all events, just newly occurring events. + * The IPMI events also include BIOS events such as Memory and POST errors, + * which would not be captured by reading the IPMI sensors. + * This utility waits a specified timeout period for any events, and + * returns interpreted output for each event. It is designed as a + * scriptable command-line utility, but if the timeout is infinite + * (-t 0), then this code could be used for a sample service as well. + * + * There are several methods to do this which are implemented here. + * The SEL method (-s): + * This method polls the SEL once a second, keeps track of the last + * SEL event read, and only new events are processed. This ensures + * that in a series of rapid events, all events are received in order, + * however, some transition-to-OK events may not be configured to + * write to the SEL on certain platforms. + * This method is used if getevent -s is specified. + * The ReadEventMessageBuffer method (-m getmessage option): + * This uses an IPMI Message Buffer in the BMC firmware to read + * each new event. This receives any event, but if two events + * occur nearly simultaneously, only the most recent of the two + * will be returned with this method. An example of simultaneous + * events might be, if a fan stops/fails, both the non-critical + * and critical fan threshold events would occur at that time. + * This is the default method for getevent. It would be used + * locally with the Intel IMB driver or with direct/driverless. + * The OpenIPMI custom method (-m getmessage_mv option if DRV_MV): + * Different IPMI drivers may have varying behavior. For instance, + * the OpenIPMI driver uses the IPMI GetMessage commands internally + * and does not allow client programs to use those commands. It has + * its own custom mechanism, see getevent_mv(). + * This method is used locally if the OpenIPMI driver is detected. + * The Async Event method (-a): + * This only gets certain Asynchronous events, like a shutdown + * request from the BMC to an SMS OS service, and get_software_id. + * This is supported for Intel IMB driver and OpenIPMI driver only. + * This method is only used locally if getevent option -a is used, + * and if either MV (openipmi) or IMB driver is loaded. + * The ipmiutil_asy init script controls the getevent -a service. + * (see DO_ASYNC compile flag comments) + * + * Author: Andy Cress arcress at users.sourceforge.net + * Copyright (c) 2005-2006 Intel Corporation. + * Copyright (c) 2009 Kontron America, Inc. + * + * 02/11/05 Andy Cress - created + * 05/18/05 Andy Cress - modified bmc_enable bits + * 05/26/05 Andy Cress - added call to decode_sel_entry + * 09/09/05 Andy Cress - added sensor_type filtering & return type. + * 03/16/05 Andy Cress - added loop, and -o for frunOnce + * 06/27/06 Andy Cress 1.1 - specific message for cc=0x80 (no data) + * 07/18/06 Andy Cress 1.1 - added getevent_mv, etc. + * 07/26/06 Andy Cress 1.1 - added msgout() routine for fflush + * 08/08/06 Andy Cress 1.2 - added -s for SEL method + * 08/08/06 Andy Cress 1.2 - added -s for SEL method + * 08/22/06 Andy Cress 1.3 - direct IOs added with ipmiutil-1.7.5 + * 09/13/06 Andy Cress 1.4 - handle empty SEL (0xCB), + * call syncevent_sel after every new event. + * 09/21/07 Andy Cress 1.21 - implemented IMB Async method for remote + * OS shutdown via SMS requests. + */ +/*M* +Copyright (c) 2009 Kontron America, Inc. +Copyright (c) 2013 Andy Cress +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + a.. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + b.. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + c.. Neither the name of Kontron nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *M*/ +#ifdef WIN32 +#include +#include +#include +#include "getopt.h" +#elif defined(DOS) +#include +#include +#include +#include +#include +#include "getopt.h" +#else +#include +#include +#include +#include +#include +#include +#if defined(HPUX) +/* getopt is defined in stdio.h */ +#elif defined(MACOS) +/* getopt is defined in unistd.h */ +#include +#else +#include +#include +#endif +#include +#include +#endif +#include +#ifdef SOLARIS +/* Solaris */ +#define HandleType long +#elif WIN32 +#include "imb_api.h" +#define DO_ASYNC 1 +#elif LINUX +#define LINUX 1 +#include "imb_api.h" +#define DO_ASYNC 1 +#define DO_MVL 1 +#elif BSD +#define DO_MVL 1 +#define HandleType long +#else +/* other OS */ +#define HandleType long +#endif +#include "ipmicmd.h" + +#define THREADS_OK 1 +#define IMBPTIMEOUT 200 /*200 ms*/ +// #define IPMB_CHANNEL 0x00 +// #define LAN_CHANNEL 0x02 +#define ulong unsigned long +#define uint unsigned int +#define ushort unsigned short +#define uchar unsigned char + +#define CMD_GET_SOFTWARE_ID 0x00 +#define CMD_SMS_OS_REQUEST 0x10 + +extern int decode_sel_entry(uchar *evt, char *obuf, int sz); /*see ievents.c*/ +extern void set_sel_opts(int sensdesc, int canon, void *sdrs, char fdbg, char utc); /* ievents.c */ +extern char *get_sensor_type_desc(uchar stype); /*see ievents.c*/ +extern int write_syslog(char *msg); /*see isel.c*/ +extern char *show_driver_type(int idx); /*see ipmicmd.h*/ +extern int get_sdr_cache(uchar **pret); /*see isensor.c*/ +extern void free_sdr_cache(uchar *pret); /*see isensor.c*/ + +/* + * Global variables + */ +static char * progname = "igetevent"; +static char * progver = "2.93"; +static char fdebug = 0; +static char fipmilan = 0; +static char frunonce = 0; +static char futc = 0; +static char fAsync = 0; +static char fAsyncOK = 0; /*=1 if drvtype detected for it*/ +static char fAsyncNOP = 0; /*=1 if skip Async actions*/ +static char fbackground = 0; +static char frunscript = 0; +static char fcanonical = 0; +static char fsettime = 0; /* =1 if timeout is set by -t */ +static uchar evt_stype = 0xff; /* event sensor type, 0xff = get any events */ +static uchar evt_snum = 0xff; /* event sensor num, 0xff = get any events */ +static int timeout = 120; /* 120 seconds default timeout */ +static int wait_interval = 1; /* 1 second between calls */ +static FILE *fdout = NULL; +static char *run_script = NULL; +static uchar ipmi_maj = 0; +static uchar ipmi_min = 0; +static HandleType imb_handle = 0; +static int drvtype = 0; /* driver_type from ipmicmd.h: 1=Intel_imb, 3=MV_OpenIPMI */ +static int vend_id = 0; +static int prod_id = 0; +static char fselevts = 0; +static char fmsgevts = 0; +static ushort sel_recid = 0; +static uint sel_time = 0; +static uchar sms_sa = 0x81; +static uchar *sdrs = NULL; +#define LAST_REC 0xFFFF +#ifdef WIN32 +#define IDXFILE "ipmi_evt.idx" +static char idxfile[80] = IDXFILE; +static char idxfile2[80] = "c:\\ipmi_evt.idx"; +static char outfile[80] = "c:\\ipmiutil_evt.log"; +#define SHUTDOWN_CMD "shutdown -s -d p:01:01 -t 10" +#define REBOOT_CMD "shutdown -r -d p:01:01 -t 10" +#else +static char idxfile[80] = "/var/lib/ipmiutil/evt.idx"; +static char idxfile2[80] = "/usr/share/ipmiutil/evt.idx"; +static char outfile[80] = "/var/log/ipmiutil_evt.log"; +#define SHUTDOWN_CMD "init 0" // or shutdown now +#define REBOOT_CMD "init 6" +#endif +#ifdef METACOMMAND +extern FILE *fpdbg; /*from ipmicmd.c*/ +extern FILE *fperr; /*from ipmicmd.c*/ +#endif +/* prototypes */ +static void iclose(void); +static void ievt_siginit(void); +static void ievt_cleanup(void); + +#define METHOD_UNKNOWN 0 +#define METHOD_SEL_EVTS 1 +#define METHOD_MSG_GET 2 +#define METHOD_MSG_MV 3 +#define METHOD_ASYNC_MV 4 +#define METHOD_ASYNC_IMB 5 +static char *methodstr[6] = { + "unknown", + "SEL_events", + "GetMessage", + "GetMessage_mv", + "Async_mv", + "Async_imb" }; + +static int do_wait(int nsec) +{ + int rv = 0; + if (nsec > 0) os_usleep(nsec,0); /*declared in ipmicmd.h*/ + return(rv); +} + +static int get_event_receiver(uchar *sa, uchar *lun) +{ + uchar rdata[30]; + int rlen; + uchar ccode; + int ret; + + rlen = 2; +#if 0 + ret = ipmi_cmdraw( 0x01,NETFN_SEVT,BMC_SA,PUBLIC_BUS,BMC_LUN, + idata,0, rdata,&rlen,&ccode, fdebug); +#endif + ret = ipmi_cmd(GET_EVENT_RECEIVER,NULL,0, rdata,&rlen,&ccode, 0); + if (ret == 0 && ccode != 0) ret = ccode; + if (ret == 0) { + *sa = rdata[0]; + *lun = rdata[1]; + } + return(ret); +} + +static int get_msg_flags(uchar *flags) +{ + uchar rdata[8]; + int rlen = 1; + uchar ccode; + int ret; + ret = ipmi_cmdraw( 0x31,NETFN_APP,BMC_SA,PUBLIC_BUS,BMC_LUN, + NULL,0, rdata,&rlen,&ccode, fdebug); + if (ret == 0 && ccode != 0) ret = ccode; + if ((ret == 0) && (flags != NULL)) *flags = rdata[0]; + return(ret); +} + +static int set_bmc_enables(uchar enab) +{ + uchar idata[8]; + uchar rdata[30]; + int rlen; + uchar ccode; + int ret; + + idata[0] = enab; + rlen = 1; + ret = ipmi_cmdraw( 0x2E,NETFN_APP,BMC_SA,PUBLIC_BUS,BMC_LUN, + idata,1, rdata,&rlen,&ccode, fdebug); + if (ret == 0 && ccode != 0) ret = ccode; + return(ret); +} + +static int get_bmc_enables(uchar *enab) +{ + uchar rdata[30]; + int rlen; + uchar ccode; + int ret; + + rlen = 1; + ret = ipmi_cmdraw( 0x2F,NETFN_APP,BMC_SA,PUBLIC_BUS,BMC_LUN, + NULL,0, rdata,&rlen,&ccode, fdebug); + if (ret == 0 && ccode != 0) ret = ccode; + + if (ret == 0) *enab = rdata[0]; + return(ret); +} + +/* + * msgout + * wrapper for printf() to include fflush + */ +void msgout(char *pattn, ...) +{ + va_list arglist; + + if (fdout == NULL) return; + va_start( arglist, pattn ); + vfprintf( fdout, pattn, arglist ); + va_end( arglist ); + fflush( fdout ); +} + +#ifdef DO_ASYNC +/* The DO_ASYNC flag enables the IMB Async Message method via get_imb_event. + * This requires the Intel IMB driver, and is used only for remote shutdown + * and software ID events. */ + +/* The LANDesk library has the same function names as the imbapi.c */ +#ifdef LINK_LANDESK +#define StartAsyncMesgPoll ia_StartAsyncMesgPoll +#define SendAsyncImbpRequest ia_SendAsyncImbpRequest +#define GetAsyncImbpMessage ia_GetAsyncImbpMessage +#define GetAsyncImbpMessage_Ex ia_GetAsyncImbpMessage_Ex +#define IsAsyncMessageAvailable ia_IsAsyncMessageAvailable +#define RegisterForImbAsyncMessageNotification ia_RegisterForImbAsyncMessageNotification +#define UnRegisterForImbAsyncMessageNotification ia_UnRegisterForImbAsyncMessageNotification +#define SendTimedLanMessageResponse_Ex ia_SendTimedLanMessageResponse_Ex +#define SendTimedEmpMessageResponse_Ex ia_SendTimedEmpMessageResponse_Ex +#endif /*endif LINK_LANDESK*/ + +typedef struct { + uchar rsSa; + uchar nfLn; + uchar cSum1; + uchar rqSa; + uchar seqLn; + uchar cmd; + uchar data[1]; +} AsyImbPacket; + +#ifdef THREADS_OK + char message[32]; +#ifdef WIN32 + HANDLE threadid = NULL; +#else + pthread_t threadid = 0; +#endif +#endif + +#ifdef WIN32 +#define ThreadRType DWORD +ThreadRType WINAPI pollThread( LPVOID p) +#else +#define ThreadRType void * +ThreadRType pollThread(void *p) +#endif +{ + int i; + int ret, limit; +#ifdef THREADS_OK + limit = 0; +#else + limit = 30; +#endif + for (i = 0; (limit == 0) || (i < limit); i++) + { + ret = StartAsyncMesgPoll(); + if (fdebug && i < 5) + msgout("StartAsyncMesgPoll [%d] ret = %d\n",i,ret); + // os_usleep(0,5000); /* poll interval 5 msec */ + os_usleep(1,0); /* poll interval 1 sec */ + } + return((ThreadRType)0); +} + +static int GetBmcLanChannel(uchar *chan) +{ + int ret = 0; + int j; + int rlen; + uchar iData[2]; + uchar rData[10]; + uchar cc; + uchar mtype; + uchar chn = 1; + + if (vend_id == VENDOR_INTEL) { + if (prod_id == 0x000C || prod_id == 0x001B) { + *chan = 7; + return(ret); + } + } + for (j = 1; j < 12; j++) { + rlen = sizeof(rData); + iData[0] = (uchar)j; /*channel #*/ + memset(rData,0,9); /*initialize recv data*/ + ret = ipmi_cmd(GET_CHANNEL_INFO, iData, 1, rData, &rlen, &cc, fdebug); + if (ret == 0xcc || cc == 0xcc) /* special case for ipmi_lan */ + continue; + if (ret != 0) { + if (fdebug) printf("get_chan_info rc = %x\n",ret); + break; + } + mtype = rData[1]; /* channel medium type */ + if (mtype == 4) { /* 802.3 LAN type*/ + if (fdebug) printf("chan[%d] = lan\n",j); + chn = (uchar)j; + break; + } + } + *chan = chn; + return(ret); +} + +int SoftwareIdResponse(uchar *buf, int blen, uchar hnd, uchar chan) +{ + int rv = 0; + uchar resp[12] = {0,0xa6,0,0,0,1,0,0x00,0x01,0x57,0x00,0x01}; +#ifdef WIN32 + /* check OS version & arch (32/64) */ +#else + struct utsname uts; + rv = uname(&uts); + // uts.release=`uname -r` uts.machine=x86_64,ia64,i586,i386 + // kver <= 24 bytes, mach/arch <= 6 bytes +#endif + +#ifdef USE_LANMSG + rv = SendTimedLanMessageResponse_Ex( (ImbPacket *)buf, (char *)(&resp), 12, + IMBPTIMEOUT, hnd, chan); +#else + rv = SendTimedEmpMessageResponse_Ex((ImbPacket *)buf, (char *)(&resp), 12, + IMBPTIMEOUT, hnd,chan); +#endif + if (fdebug) msgout("SoftwareIdResponse(%d) ret = %d\n",chan,rv); + return(rv); +} + + +int SmsOsResponse(uchar *buf, int blen, uchar func, uchar hnd, uchar chan) +{ + int rv = 0; + char cc = 0; + if (frunscript) { + write_syslog("igetevent -a running script\n"); + rv = system(run_script); + if (fdebug) msgout("run(%s) ret = %d\n",run_script,rv); + } + switch(func) /*data byte has function*/ + { + case 0x01: /*shutdown & power down*/ + rv = SendTimedEmpMessageResponse_Ex((ImbPacket *)buf, &cc,1, + IMBPTIMEOUT, hnd,chan); + if (fdebug) msgout("OsResponse(%d) ret = %d\n",chan,rv); + if (!fAsyncNOP) { + write_syslog("igetevent -a initiating OS shutdown\n"); + rv = system(SHUTDOWN_CMD); + if (fdebug) msgout("shutdown ret = %d\n",rv); + } + break; + case 0x02: /*shutdown & reset*/ + rv = SendTimedEmpMessageResponse_Ex((ImbPacket *)buf, &cc,1, + IMBPTIMEOUT, hnd,chan); + if (fdebug) msgout("OsResponse(%d) ret = %d\n",chan,rv); + if (!fAsyncNOP) { + write_syslog("igetevent -a initiating OS reboot\n"); + rv = system(REBOOT_CMD); + if (fdebug) msgout("reboot ret = %d\n",rv); + } + break; + default: + if (fdebug) msgout("igetevent -a unknown function %d\n",func); + rv = 1; + break; + } + return(rv); +} + +/* + * get_imb_event + * This only gets certain IMB events, like + * OS requests (e.g. shutdown), and get_software_id + */ +static int get_imb_event(uchar etype, int timeout, uchar *evt) +{ + int ret = -1; + int i; + int done = 0; + ulong mlen; + uchar buffer[512]; + uchar sendbuf[18]; + static uint asyseqnum = 0; + uchar chan; + uchar sessHandle = 0; + uchar privilege = 0; + uchar cmd, func; + // uchar *pbuf; + + ret = GetBmcLanChannel(&chan); + + /* clean out pre-existing async messages */ + while(1) { + mlen = sizeof(buffer); + if (GetAsyncImbpMessage((ImbPacket *)buffer,&mlen, IMBPTIMEOUT, + &asyseqnum, IPMB_CHANNEL) != 0) + break; + if (fdebug) msgout("cleaned out an IPMB message seq=%d\n",asyseqnum); + } + while(1) { + mlen = sizeof(buffer); + if (GetAsyncImbpMessage((ImbPacket *)buffer,&mlen, IMBPTIMEOUT, + &asyseqnum, LAN_CHANNEL) != 0) + break; + if (fdebug) msgout("cleaned out a LAN message seq=%d\n",asyseqnum); + } + ret = RegisterForImbAsyncMessageNotification(&imb_handle); + if (fdebug) + msgout("RegisterForImbAsync ret=%d, handle=%x\n",ret,imb_handle); + if (ret != 0) { + msgout("RegisterAsync error %d\n",ret); + return(ret); + } + + for (i = 0; (timeout == 0) || (i < timeout); i++) + { /*get one imb event*/ + if (fdebug) msgout("IsAsyncMessageAvailable ...\n"); + if (IsAsyncMessageAvailable(imb_handle) == 0) + { + if (fdebug) msgout("Async Message is Available\n"); + mlen = sizeof(buffer); + ret = GetAsyncImbpMessage_Ex ((ImbPacket *)buffer, &mlen, + IMBPTIMEOUT, &asyseqnum, ANY_CHANNEL, + &sessHandle, &privilege); + /* Hack: buffer contains an extra byte to return channel */ + if (fdebug) + msgout("GetAsync(%d,%d) ret = %d, newchan=%x\n", + asyseqnum,chan,ret,buffer[mlen]); + if (ret == 0) { + /* get the async message command */ + if (fdebug) dump_buf("async msg",buffer,mlen+1,0); + chan = buffer[mlen]; + if (mlen > 16) mlen = 16; + if (buffer[0] == sms_sa) { + memcpy(&sendbuf[0],buffer,mlen); + } else { /* handle shorter format for some BMCs */ + sendbuf[0] = sms_sa; + memcpy(&sendbuf[1],buffer,mlen); + } + cmd = sendbuf[5]; func = sendbuf[6]; + msgout("got async msg: cmd=%02x len=%d\n",cmd,mlen); + memcpy(evt,sendbuf,mlen); + + switch(cmd) { + case CMD_GET_SOFTWARE_ID: /*Get Software ID*/ + ret = SoftwareIdResponse(sendbuf,mlen,sessHandle,chan); + break; + case CMD_SMS_OS_REQUEST: /*SMS OS Request*/ + ret = SmsOsResponse(sendbuf,mlen,func,sessHandle,chan); + if (ret == 0) done = 1; + break; + default: + ret = LAN_ERR_INVPARAM; + msgout("SmsOS cmd %02x unknown, ret = %d\n",cmd,ret); + } + if (fdebug) + msgout("async msg cmd=%02x ret = %d\n",cmd,ret); + if (done == 1) { + if (func == 0x01) msgout("shutting down\n"); + else msgout("rebooting\n"); + ret = 0x81; + break; + } + } + } /*endif have an event*/ + else ret = 0x80; /* no event yet */ + } /*loop for one event*/ + if (fdebug) msgout("Unregister for imb events\n"); + UnRegisterForImbAsyncMessageNotification (imb_handle,0); + return(ret); +} +#endif + /*endif DO_ASYNC*/ + +#ifdef DO_MVL +/* Linux, enable MV OpenIPMI interface */ +extern int register_async_mv(uchar cmd, uchar netfn); /*see ipmimv.c*/ +extern int unregister_async_mv(uchar cmd, uchar netfn); /*see ipmimv.c*/ +extern int getevent_mv(uchar *evt_data, int *evt_len, uchar *cc, int t); +extern int ipmi_rsp_mv(uchar cmd, uchar netfn, uchar lun, uchar sa, uchar bus, + uchar *pdata, int sdata, char fdebugcmd); + +static int send_mv_asy_resp(uchar *evt) +{ + uchar cmd, sa, bus, cc; + uchar data0[12] = {0,0xa6,0,0,0,1,0,0x00,0x01,0x57,0x00,0x01}; + uchar data1[1] = { 0x00 }; + uchar rdata[80]; + int sdata, rlen, i; + uchar *pdata; + int rv = -1; + + cmd = evt[2]; + sa = sms_sa; /* sa = SMS_SA (0x81) */ + bus = 0x01; /* usu lan_ch == 1 */ + switch(cmd) { + case CMD_GET_SOFTWARE_ID: /*software id*/ + pdata = &data0[0]; + sdata = sizeof(data0); + break; + case CMD_SMS_OS_REQUEST: /*restart*/ + pdata = &data1[0]; + sdata = sizeof(data1); + break; + default: rv = LAN_ERR_INVPARAM; return (rv); + break; + } + rv = ipmi_rsp_mv(cmd, (NETFN_APP | 0x01), sa, bus, BMC_LUN, + pdata,sdata, fdebug); + if (rv == 0) { + for (i = 0; i < 5; i++) + { + rlen = sizeof(rdata); + rv = getevent_mv(rdata,&rlen,&cc,1); + if (fdebug) msgout("send_mv_asy_resp: rv=%d cc=%x\n",rv,cc); + if (rv == 0 && cc == 0) { + if (fdebug) msgout("got rsp ccode: type=%02x len=%d cc=%x\n", + rdata[0],rlen,rdata[3]); + if (rlen > 0) rv = rdata[3]; /*cc*/ + break; + } + os_usleep(0,5000); /*wait 5 ms*/ + } + } + return (rv); +} + +static int get_mv_asy_event(uchar cmd, int timeout, uchar *evt) +{ + int ret = -1; + int rv = -1; + uchar cc = 0; + uchar rdata[120]; + int rlen, i; + + rv = register_async_mv(cmd,NETFN_APP); /*reserved,GetSoftwareID*/ + if (rv != 0) return(rv); + + for (i = 0; (timeout == 0) || (i < timeout); i++) + { /*get one async event*/ + rv = getevent_mv(rdata,&rlen,&cc,timeout); + if (fdebug) + msgout("get_mv_asy_event: i=%d cmd=%x rv=%d cc=%x\n",i,cmd,rv,cc); + if (rv == 0 && cc == 0) { + msgout("got async msg: type=%02x cmd=%x len=%d\n", + rdata[0],rdata[2],rlen); + if (fdebug) dump_buf("async msg",rdata,rlen,0); + /* check recv_type == 3 (IPMI_CMD_RECV_TYPE) */ + if (rdata[0] == 3 && rdata[2] == cmd) { + if (rlen > 16) rlen = 16; + memcpy(evt,rdata,rlen); + break; + } else { /*else msg, but no match*/ + rv = ERR_BAD_PARAM; + break; + } + } + else do_wait(wait_interval); /*wait 1 sec*/ + } + ret = unregister_async_mv(cmd,NETFN_APP); /*reserved,GetSoftwareID*/ + return(rv); +} +#endif + +static int get_evt_method(char *evtmethod) +{ + int method = METHOD_UNKNOWN; + if (fAsync) { + if (drvtype == DRV_MV) method = METHOD_ASYNC_MV; + else /* if (drvtype == DRV_IMB) */ method = METHOD_ASYNC_IMB; + } else if (fselevts) method = METHOD_SEL_EVTS; + else { /*fmsgevts*/ + if (drvtype == DRV_MV) method = METHOD_MSG_MV; + else method = METHOD_MSG_GET; + } + if (evtmethod != NULL) + strcpy(evtmethod,methodstr[method]); + return(method); +} + +static int get_sel_entry(ushort recid, ushort *nextid, uchar *rec) +{ + uchar ibuf[6]; + uchar rbuf[32]; + int rlen; + ushort xid, id = 0; + uchar cc; + int rv; + + ibuf[0] = 0; + ibuf[1] = 0; + ibuf[2] = (recid & 0x00ff); + ibuf[3] = (recid & 0xff00) >> 8; + ibuf[4] = 0; + ibuf[5] = 0xFF; /*get entire record*/ + rlen = sizeof(rbuf); + rv = ipmi_cmd(GET_SEL_ENTRY, ibuf, 6, rbuf, &rlen, &cc, fdebug); + if (rv == 0) { + if (cc != 0) rv = cc; + else { /*success*/ + xid = rbuf[0] + (rbuf[1] << 8); /*next rec id*/ + memcpy(rec,&rbuf[2],16); + *nextid = xid; + id = rbuf[2] + (rbuf[3] << 8); /*curr rec id*/ + /* recid (requested) should match newid (received) */ + if (fdebug) { + if ((recid != id) && (recid != LAST_REC) && (recid != 0)) { + /* the OpenIPMI driver does this sometimes */ + msgout("get_sel MISMATCH: recid=%x newid=%x next=%x\n", + recid,id,xid); + dump_buf("get_sel cmd",ibuf,6,0); + dump_buf("get_sel rsp",rbuf,rlen,0); + } + } + } + } + if (fdebug) msgout("get_sel(%x) rv=%d cc=%x id=%x next=%x\n", + recid,rv,cc,id,*nextid); + return(rv); +} + +static int startevent_sel(ushort *precid, uint *ptime) +{ + FILE *fd; + uchar rec[24]; + uint t = 0; + ushort r = 0; + ushort r2 = 0; + int rv = -1; + + fd = fopen(idxfile,"r"); + if (fd == NULL) fd = fopen(idxfile2,"r"); /*handle old location*/ + if (fdebug) msgout("start: idxfile=%s fd=%p\n",idxfile,fd); + if (fd != NULL) { + // Read the file, get savtime & savid + rv = fscanf(fd,"%x %x",&t,&r); + fclose(fd); + if (r == LAST_REC) r = 0; + rv = 0; /*read it, success*/ + } else { /* treat as first time */ + r = LAST_REC; + rv = get_sel_entry(r,&r2,rec); + if (rv == 0) { + memcpy(&t,&rec[3],4); + r = rec[0] + (rec[1] << 8); /*use current rec id*/ + } else r = 0; + rv = 1; /*first time*/ + } + if (fdebug) msgout("start: recid=%x time=%x\n",r,t); + *ptime = t; + *precid = r; + return(rv); +} + +static int syncevent_sel(ushort recid, uint itime) +{ + FILE *fd; + int rv; + // Rewrite the saved time & record id + if (fdebug) msgout("sync: recid=%x time=%x\n",recid,itime); + fd = fopen(idxfile,"w"); + if (fd == NULL) { + msgout("syncevent: cannot open %s for writing\n",idxfile); + rv = -1; + } else { + fprintf(fd,"%x %x\n",itime,recid); + fclose(fd); + rv = 0; + } + return(rv); +} + +int getevent_sel(uchar *rdata, int *rlen, uchar *ccode) +{ + uchar rec[24]; + int rv = 0; + ushort newid; + ushort nextid; + ushort recid; + + /* get current last record */ + recid = sel_recid; + rv = get_sel_entry(recid,&nextid,rec); + if (rv == 0xCB && recid == 0) { /* SEL is empty */ + *ccode = (uchar)rv; /* save the real ccode */ + rv = 0x80; /* this is ok, just keep waiting */ + } + if (rv == 0) { + if (fdebug) msgout("sel ok, id=%x next=%x\n",recid,nextid); + if ((nextid == LAST_REC) || (recid == nextid)) { + *ccode = 0x80; /*nothing new*/ + } else { + recid = nextid; /* else get new one */ + rv = get_sel_entry(recid,&nextid,rec); + if (rv == 0) { /* new event */ + newid = rec[0] + (rec[1] << 8); + if (drvtype == DRV_MV && recid != newid) { + /* handle MV driver bug, try to get next one. */ + if (fdebug) msgout("%s bug, record mismatch\n", + show_driver_type(DRV_MV)); + } + if (fdebug) msgout("recid=%x newid=%x next=%x\n", + recid,newid,nextid); + memcpy(rdata,rec,16); + *rlen = 16; + *ccode = 0; + sel_recid = recid; /*or newid*/ + memcpy(&sel_time,&rec[3],4); + } + } + } + else { /* Error reading last recid saved */ + if (fdebug) msgout("sel recid %x error, rv = %d\n",recid,rv); + /* We want to set sel_recid = 0 here for some errors. */ + if (rv == 0xCB || rv == 0xCD) { /* empty, or wrong SDR id */ + sel_recid = 0; + *ccode = (uchar)rv; + rv = 0x80; /* wait again */ + } + } + return(rv); +} + +static int get_event(uchar etype, uchar snum, int timeout, + uchar *evt, uchar *stype) +{ + int ret = 0; + uchar rdata[64]; + int rlen; + uchar ccode; + int fretry; + int i; + + for (i = 0; (timeout == 0) || (i < timeout); i++) + { + rlen = sizeof(rdata); + fretry = 0; ccode = 0; + if (fselevts) { + ret = getevent_sel(rdata,&rlen,&ccode); + } else +#ifdef DO_MVL + if (drvtype == DRV_MV) { /* if MV OpenIPMI driver (Linux only) */ + if (timeout == 0) wait_interval = 0; + /* use special MV API instead (see ipmimv.c) */ + ret = getevent_mv(rdata,&rlen,&ccode,timeout); + } else +#endif + ret = ipmi_cmd(READ_EVENT_MSGBUF,NULL,0,rdata,&rlen,&ccode,fdebug); + /* now we have an event from one of the above methods*/ + + /* IPMI 1.5 spec, section 18.8 says cc 0x80 means + * "data not available (queue/buffer empty)" */ + if (ret == 0 && ccode != 0) { ret = ccode; } + if (ret == 0x80) { + fretry = 1; + do_wait(wait_interval); /*wait 1 sec*/ + } else { + if (ret == 0) { + char ismatch = 0; + /* parse event types for a specified type */ + /* etype param == 0xff means get any event */ + /* rdata[10] is sensor_type, rdata[11] is sensor_num */ + if ((etype == 0xff) || (etype == rdata[10])) ismatch++; + if ((snum == 0xff) || (snum == rdata[11])) ismatch++; + if (ismatch == 2) { + /*event sensor type matches*/ + memcpy(evt,rdata,rlen); + *stype = rdata[10]; /* return sensor type */ + } else { /* keep looking */ + do_wait(wait_interval); + continue; + } + } + /* if here, either got one, or need to return error */ + break; + } + } /*end for loop*/ + return(ret); +} + +int send_nmi(void) +{ + uchar idata[8]; + uchar rdata[30]; + int rlen; + uchar ccode; + int ret; + + idata[0] = 4; /* do NMI */ + rlen = sizeof(rdata); + ret = ipmi_cmdraw( CHASSIS_CTL, NETFN_CHAS, BMC_SA,PUBLIC_BUS,BMC_LUN, + idata,1, rdata,&rlen,&ccode, fdebug); + if (ret == 0 && ccode != 0) ret = ccode; + return(ret); +} + +void show_event(uchar *evt,char *obuf, int sz) +{ + int i; + char sysbuf[250]; + /* obuf should be 132 chars or more */ + + msgout("event data: "); + for (i=0; i<16; i++) msgout("%02x ",evt[i]); + msgout("\n"); + + decode_sel_entry(evt,obuf,sz); + msgout(obuf); /*writes to outfile*/ + /* write the message to syslog also. */ + snprintf(sysbuf,sizeof(sysbuf),"%s: %s",progname,obuf); + write_syslog(sysbuf); +} + +static void ievt_cleanup(void) +{ + char obuf[48]; + if (fselevts) syncevent_sel(sel_recid,sel_time); + snprintf(obuf,sizeof(obuf),"%s exiting.\n",progname); + msgout(obuf); + write_syslog(obuf); + free_sdr_cache(sdrs); + iclose(); + exit(EXIT_SUCCESS); +} + +#if defined(WIN32) | defined(DOS) +/* no daemon code */ +static void ievt_siginit(void) { return; } +#else +/* Linux daemon code */ +#include +static void ievt_sighnd(int sig) +{ + ievt_cleanup(); + exit(EXIT_SUCCESS); +} + +static void ievt_siginit(void); +static void ievt_siginit(void) +{ + struct sigaction sact; + + /* handle signals for cleanup */ + sact.sa_handler = ievt_sighnd; + sact.sa_flags = 0; + sigemptyset(&sact.sa_mask); + sigaction(SIGINT, &sact, NULL); + sigaction(SIGQUIT, &sact, NULL); + sigaction(SIGTERM, &sact, NULL); +} + +static int mkdaemon(int fchdir, int fclose); +static int mkdaemon(int fchdir, int fclose) +{ + int fdlimit = sysconf(_SC_OPEN_MAX); /*fdlimit usu = 1024.*/ + int fd = 0; + + + fdlimit = fileno(stderr); /*only close files up to stderr*/ + switch (fork()) { + case 0: break; + case -1: return -1; + default: _exit(0); /* exit the original process */ + } + if (setsid() < 0) return -1; /* shouldn't fail */ + switch (fork()) { + case 0: break; + case -1: return -1; + default: _exit(0); /* exit the original process */ + } + if (fchdir) { + chdir("/"); + /* umask(0022); * leave file creation mask at default (0022) & 0777 */ + } + if (fclose) { + /* Close stdin,stdout,stderr and replace them with /dev/null */ + for (fd = 0; fd < fdlimit; fd++) close(fd); + open("/dev/null",O_RDWR); + dup(0); dup(0); + } + return 0; +} +#endif + +static void iclose() +{ + /* close out any IPMI handles or sessions */ +#ifdef THREADS_OK +#ifdef WIN32 + if (threadid != NULL) CloseHandle(threadid); +#else + /* thread close not needed in Linux */ +#endif +#endif + ipmi_close_(); + if (fbackground && fdout != NULL) fclose(fdout); +} + +#ifdef METACOMMAND +int i_getevt(int argc, char **argv) +#else +#ifdef WIN32 +int __cdecl +#else +int +#endif +main(int argc, char **argv) +#endif +{ + int ret = 0; + int c, j; + uchar devrec[16]; + uchar event[16]; + uchar sa, lun; + uchar enables = 0; + uchar fevmsgok = 0; + uchar sensor_type = 0; + uchar msg_flags = 0; + FILE *fp; + char outbuf[160]; + char tmpout[20]; + char *sdesc; + + fdout = stdout; + msgout("%s ver %s\n", progname,progver); + + while ( (c = getopt(argc,argv,"abce:lmn:or:st:uvT:V:J:YEF:P:N:R:U:Z:x?")) != EOF ) + switch(c) { + case 'a': fAsync = 1; /* imb async message method */ + /* chenge the output log filename */ + sdesc = strstr(outfile,"evt.log"); + if (sdesc != NULL) strcpy(sdesc,"asy.log"); + break; + case 'b': fbackground = 1; break; /* background */ + case 'c': fcanonical = 1; break; /* canonical */ + case 'e': /* event sensor type */ + if (strncmp(optarg,"0x",2) == 0) + evt_stype = htoi(&optarg[2]); + else evt_stype = atob(optarg); + break; + case 'l': fAsyncNOP = 1; break; /* do not reset (for testing)*/ + case 'm': fmsgevts = 1; break; /* use local getmessage method */ + case 'n': /* event sensor num, always hex */ + if (strncmp(optarg,"0x",2) == 0) + evt_snum = htoi(&optarg[2]); + else evt_snum = htoi(&optarg[0]); + break; + case 'o': frunonce = 1; break; /* only run once for first event */ + case 'r': /* run script (or binary) on an event */ + run_script = optarg; + fp = fopen(run_script,"r"); + if (fp == NULL) { + printf("cannot open %s\n",run_script); + ret = ERR_FILE_OPEN; + goto do_exit; + } else { + fclose(fp); + frunscript = 1; + } + break; + case 's': fselevts = 1; break; /* use SEL event method*/ + case 't': timeout = atoi(optarg); fsettime = 1; break; /*timeout*/ + case 'u': futc = 1; break; + case 'x': fdebug = 1; break; /* debug messages */ + case 'v': fdebug = 3; break; /* verbose debug with lan */ + case 'N': /* nodename */ + case 'U': /* remote username */ + case 'P': /* remote password */ + case 'R': /* remote password */ + case 'E': /* get password from IPMI_PASSWORD environment var */ + case 'F': /* force driver type */ + case 'T': /* auth type */ + case 'J': /* cipher suite */ + case 'V': /* priv level */ + case 'Y': /* prompt for remote password */ + case 'Z': /* set local MC address */ + parse_lan_options(c,optarg,fdebug); + break; + default: + printf("Usage: %s [-abenorsux -t sec -NPRUEFTVY]\n", progname); + printf(" where -a use Async method\n"); + printf(" -b run in Background\n"); + printf(" -c use Canonical/delimited event format\n"); + printf(" -e T wait for specific event sensor type T\n"); + printf(" -n N wait for specific event sensor num N\n"); + printf(" -o run Once for the first event\n"); + printf(" -r F Run file F when an event occurs\n"); + printf(" -s use SEL event method\n"); + printf(" -t N set timeout to N seconds\n"); + printf(" -u use raw UTC time\n"); + printf(" -x show eXtra debug messages\n"); + print_lan_opt_usage(); + ret = ERR_USAGE; + goto do_exit; + } + + fipmilan = is_remote(); + ret = ipmi_getdeviceid(devrec,16,fdebug); + if (ret != 0) { + goto do_exit; + } else { + ipmi_maj = devrec[4] & 0x0f; + ipmi_min = devrec[4] >> 4; + show_devid( devrec[2], devrec[3], ipmi_maj, ipmi_min); + vend_id = devrec[6] + (devrec[7] << 8) + (devrec[8] << 16); + prod_id = devrec[9] + (devrec[10] << 8); + if (vend_id == VENDOR_INTEL) { + if (prod_id == 0x003E) /* NSN2U or CG2100 Urbanna */ + sms_sa = 0x41; + } + } + + /* get event receiver */ + ret = get_event_receiver(&sa ,&lun); + if (ret != 0) + msgout("event receiver error %d\n",ret); + else msgout("event receiver sa = %02x lun = %02x\n",sa,lun); + + ret = get_bmc_enables(&enables); + if (ret != 0) msgout("bmc enables error %d\n",ret); + else { + msgout("bmc enables = %02x\n",enables); + if ((enables & 0x02) == 2) fevmsgok = 1; + else fevmsgok = 0; + } + if (fevmsgok == 0 && !fipmilan) { + msgout("Event Message Buffers not enabled.\n"); + enables |= 0x0f; /* 0x08=SEL, 0x02=EvtMsgBuf, rest is gravy */ + ret = set_bmc_enables(enables); + if (ret != 0) { + msgout("set_bmc_enables error 0x%x\n",ret); + } + else msgout("set_bmc_enables success\n"); + } + if (fipmilan && !fselevts) { + msgout("Only the SEL method (-s) is supported over IPMI LAN\n"); + ret = LAN_ERR_NOTSUPPORT; + goto do_exit; + } + ret = get_msg_flags(&msg_flags); + msgout("igetevent reading sensors ...\n"); + write_syslog("igetevent reading sensors ...\n"); + ret = get_sdr_cache(&sdrs); + // if (!fipmilan) set_sel_opts(1,0, NULL,fdebug); + if (fdebug) msgout("get_sdr_cache ret = %d\n",ret); + if (ret == 0) set_sel_opts(1, fcanonical, sdrs,fdebug,futc); + else ret = 0; /*if error, keep going anyway*/ + + if (fselevts) { +#ifdef WIN32 + { /*resolve path of idxfile*/ + char *ipath; + ipath = getenv("ipmiutildir"); /*ipmiutil directory path*/ + if (ipath != NULL) { + if (strlen(ipath)+12 < sizeof(idxfile)) { + sprintf(idxfile,"%s\\%s",ipath,"\\",IDXFILE); + } + } + } +#endif + + if (fipmilan) { + char *node; + node = get_nodename(); + strcat(idxfile,"-"); + strcat(idxfile,node); + strcat(idxfile2,"-"); + strcat(idxfile2,node); + strcat(outfile,"-"); + strcat(outfile,node); + } + ret = startevent_sel(&sel_recid,&sel_time); + ret = 0; /*ignore any earlier errors, keep going*/ + } + + drvtype = get_driver_type(); + if (fdebug) msgout("driver_type = %d (%s)\n", + drvtype,show_driver_type(drvtype)); + + if (evt_stype == 0xFF) sdesc = "any event"; + else sdesc = get_sensor_type_desc(evt_stype); + if (evt_snum == 0xFF) tmpout[0] = 0; + else sprintf(tmpout,"with snum %02x",evt_snum); + if (evt_stype != 0xFF || evt_snum != 0xFF) + msgout("Look for event sensor type %02x (%s) %s\n", evt_stype,sdesc,tmpout); + +#ifdef TEST_SEL + /* This is used to verify that the interface returns valid next ids, + * and that the get_sel_entry is ok. */ + { + int i; + ushort r, r1, r2; + uchar rec[40]; + int rv; + r = 0; + for (i = 0; i < 4; i++) + { + rv = get_sel_entry(r,&r2,rec); + if (rv == 0) { + r1 = rec[0] + (rec[1] << 8); /*get current rec id*/ + if (fdebug) msgout("get_sel: r=%x r1=%x rnext=%x\n",r,r1,r2); + show_event(&rec[0],outbuf,sizeof(outbuf)); + r = r2; + } else break; + } + } +#endif + if (drvtype == DRV_IMB) fAsyncOK = 1; + else if (drvtype == DRV_MV) { + if (fsettime == 0) timeout = 0; /*DRV_MV default to infinite*/ + fAsyncOK = 1; + } else fAsyncOK = 0; + + if (fAsync && (!fAsyncOK)) { + msgout("Cannot open %s or %s driver, required for -a\n", + show_driver_type(DRV_IMB),show_driver_type(DRV_MV)); + ret = ERR_NO_DRV; + goto do_exit; + } + + if (fbackground) { /* convert to a daemon if background */ +#ifdef WIN32 + msgout("Background not implemented for Windows\n"); + ret = LAN_ERR_NOTSUPPORT; + goto do_exit; +#elif defined(DOS) + msgout("Background not implemented for DOS\n"); + ret = LAN_ERR_NOTSUPPORT; + goto do_exit; +#else + /* make sure we can open the log file before doing mkdaemon */ + fdout = fopen(outfile,"a"); + if (fdout == NULL) + printf("%s: Cannot open %s\n", progname,outfile); + else { + pid_t p; + fclose(fdout); + + ret = mkdaemon(1,1); + if (ret != 0) { + msgout("%s: Cannot become daemon, ret = %d\n", progname,ret); + goto do_exit; + } + /* open a log file for messages, set fdout */ + fdout = fopen(outfile,"a"); +#ifdef METACOMMAND + /* make sure driver debug also goes to log */ + fpdbg = fdout; + fperr = fdout; +#endif + p = getpid(); + msgout("PID %d: %s ver %s\n",p,progname,progver); /*log start message*/ + } +#endif + } + ievt_siginit(); + + if (fAsync && (fAsyncOK)) /*use imb/mv async messages*/ + { + msgout("Wait for an async event\n"); /* no timeout */ + if (drvtype == DRV_IMB) + { +#ifdef DO_ASYNC +#ifdef THREADS_OK +#ifdef WIN32 + /* Windows threads */ + threadid = CreateThread(NULL, 0, &pollThread, NULL, 0, NULL); + if (threadid == NULL) pollThread(NULL); +#else + /* Linux threads */ + ret = pthread_create( &threadid, NULL, pollThread, (void*) message); + // if (ret == 0) pthread_join( threadid, NULL); + // if (ret == 0) pthread_detach( threadid); +#endif + if (fdebug) msgout("pollThread create ret=%d handle=%x\n",ret,threadid); +#else + /* no threads */ + pollThread(NULL); +#endif + while (ret == 0) + { /*wait for imb message events*/ + msgout("Waiting %d seconds for an async event ...\n",timeout); + ret = get_imb_event(0xff,timeout,event); + if (ret == 0x81) { /*ok, shutting down OS*/ + ret = 0; + break; + } + if (frunonce) break; + if (timeout == 0 && ret == 0x80) { /*0x80 = no data yet */ + if (fdebug) msgout("get_event timeout, no event yet.\n"); + do_wait(wait_interval); + ret = 0; /*ok, keep going*/ + } + } +#endif + } /*endif DRV_IMB*/ +#ifdef DO_MVL + else { /*DRV_MV*/ + int stage; + stage = 0; + while (stage < 3) + { /*wait for mv message events*/ + if (fdebug) msgout("Waiting for async_mv event, stage %d\n",stage); + if (stage == 0) { + ret = get_mv_asy_event(CMD_GET_SOFTWARE_ID,timeout,event); + if (fdebug) msgout("got SmsOS GetSWID event ret = %d\n",ret); + /* send a reply */ + if (ret == 0) ret = send_mv_asy_resp(event); + if (ret == 0) stage = 1; /* got the SoftwareID request/response */ + else stage = 0; + } + if (stage == 1) { + /* get the reset command */ + memset(event,0,sizeof(event)); + ret = get_mv_asy_event(CMD_SMS_OS_REQUEST,timeout,event); + if (fdebug) msgout("got SmsOS GetSmsOS event ret = %d\n",ret); + if (ret == 0) ret = send_mv_asy_resp(event); + if (ret == 0) stage = 2; + else stage = 0; + } + if (stage == 2) { /* got the SmsOs request in event */ + uchar cmd, func; + cmd = event[2]; + func = event[3]; + if (cmd != CMD_SMS_OS_REQUEST) { /*cmd*/ + ret = LAN_ERR_INVPARAM; + if (fdebug) msgout("SmsOS cmd %x ret = %d\n",cmd,ret); + } else { + if (frunscript) { + write_syslog("igetevent -a running script\n"); + ret = system(run_script); + if (fdebug) msgout("run(%s) ret = %d\n",run_script,ret); + } + if (!fAsyncNOP) + switch(func) { /*subfunction*/ + case 0x01: /*shutdown & power down*/ + write_syslog("igetevent -a OS shutdown\n"); + ret = system(SHUTDOWN_CMD); + msgout("SmsOs shutdown, ret = %d\n",ret); + break; + case 0x02: /*shutdown & reboot*/ + write_syslog("igetevent -a OS reboot\n"); + ret = system(REBOOT_CMD); + msgout("SmsOs reboot, ret = %d\n",ret); + break; + case 0x03: /*send NMI locally*/ + write_syslog("igetevent -a NMI\n"); + ret = send_nmi(); + msgout("SmsOs NMI, ret = %d\n",ret); + default: + ret = LAN_ERR_INVPARAM; + msgout("SmsOS func %02x, ret = %d\n",func,ret); + break; + } + } + if (ret == 0) stage = 3; /*done, exit loop*/ + else { + if (fdebug) msgout("SmsOS error = %d, start over\n",ret); + stage = 0; /*start over*/ + } + } /*endif stage 2*/ + } /*end-while*/ + } /*end else DRV_MV*/ +#endif + + } else { /*not Async, std IPMI events */ + if (fselevts) { + msgout("Get IPMI SEL events after ID %04x\n",sel_recid); + } else + msgout("Get IPMI events from %s driver\n",show_driver_type(drvtype)); + j = get_evt_method(tmpout); + sprintf(outbuf,"igetevent waiting for events via method %d (%s)\n", + j, tmpout); + msgout(outbuf); + write_syslog(outbuf); + + /* loop on events here, like a daemon would. */ + while (ret == 0) + { /*wait for bmc message events*/ + msgout("Waiting %d seconds for an event ...\n",timeout); + /* note: could also get message flags here */ + ret = get_event(evt_stype,evt_snum,timeout,event,&sensor_type); + if (fdebug) msgout("get_event ret = %d\n",ret); + if (ret == 0) { /* got an event successfully */ + msgout("got event id %04x, sensor_type = %02x\n", + sel_recid, sensor_type); + show_event(event,outbuf,sizeof(outbuf)); + if (fselevts) syncevent_sel(sel_recid,sel_time); + if (frunscript) { /*run some script for each event*/ + char run_cmd[256]; + sprintf(run_cmd,"%s \"%s\"\n",run_script,outbuf); + j = system(run_cmd); + msgout("run(%s $1), ret = %d\n",run_script,j); + ret = j; /*if that failed, exit loop*/ + } + } else { + if (ret == 0x80) msgout("get_event timeout\n"); + else msgout("get_event error: ret = 0x%x\n",ret); + } + if (frunonce) break; + if (timeout == 0 && ret == 0x80) { /*0x80 = no data yet */ + if (fdebug) msgout("get_event timeout, no data yet.\n"); + do_wait(wait_interval); + ret = 0; /*ok, keep going*/ + } + } /*end while loop*/ + } + +do_exit: + ievt_cleanup(); + if (ret == 0x80) ret = 0; + // show_outcome(progname,ret); /*inert if background*/ + return(ret); +} /* end main()*/ + +/* end getevent.c */ -- cgit v1.2.3