summaryrefslogtreecommitdiff
path: root/util/subs.c
diff options
context:
space:
mode:
Diffstat (limited to 'util/subs.c')
-rw-r--r--util/subs.c848
1 files changed, 848 insertions, 0 deletions
diff --git a/util/subs.c b/util/subs.c
new file mode 100644
index 0000000..9f11423
--- /dev/null
+++ b/util/subs.c
@@ -0,0 +1,848 @@
+/*
+ * subs.c
+ *
+ * Some common helper subroutines
+ *
+ * Author: Andy Cress arcress at users.sourceforge.net
+ * Copyright (c) 2010 Kontron America, Inc.
+ *
+ * 08/18/11 Andy Cress - created to consolidate subroutines
+ */
+/*M*
+Copyright (c) 2010 Kontron America, Inc.
+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*/
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <limits.h>
+#ifdef WIN32
+#include <windows.h>
+// #if !defined(LONG_MAX)
+// # if __WORDSIZE == 64
+// # define LONG_MAX 9223372036854775807L
+// # else
+// # define LONG_MAX 2147483647L
+// # endif
+// # define LONG_MIN (-LONG_MAX - 1L)
+// #endif
+
+#else
+/* Linux */
+#include <unistd.h>
+#include <syslog.h>
+#include <errno.h>
+#endif
+
+#include "ipmicmd.h"
+
+extern char fdebug; /*ipmicmd.c*/
+extern char fdbglog; /*ipmilanplus.c*/
+extern int verbose; /*ipmilanplus.c*/
+extern FILE *fpdbg; /*ipmicmd.c*/
+extern FILE *fplog; /*ipmicmd.c */
+extern char log_name[60]; /*log_name global, from ipmicmd.c*/
+
+static int loglevel = LOG_WARN;
+#ifdef WIN32
+#define SELMSG_ID 0x40000101 /* showselmsg.dll EventID 257. = 0x101 */
+static HANDLE hLog = NULL;
+#endif
+
+/* decode_rv, decode_cc are in ipmicmd.c */
+
+/* strlen_ wrapper for size_t/int warnings*/
+int strlen_(const char *s)
+{
+ return((int)strlen(s));
+}
+
+/* Need our own copy of strdup(), named strdup_(), since Windows does
+ * not have the same subroutine. */
+char * strdup_(const char *instr)
+{
+ char *newstr = NULL;
+ if (instr != NULL) {
+ newstr = malloc(strlen_(instr)+1);
+ if (newstr != NULL) strcpy(newstr,instr);
+ }
+ return (newstr);
+}
+
+#ifdef WIN32
+int strncasecmp(const char *s1, const char *s2, int n)
+{
+ int i, val;
+ char c1, c2;
+ if (s1 == NULL || s2 == NULL) return (-1);
+ val = 0;
+ for (i = 0; i < n; i++) {
+ c1 = s1[i] & 0x5f;
+ c2 = s2[i] & 0x5f;
+ if (c1 < c2) { val = -1; break; }
+ if (c1 > c2) { val = 1; break; }
+ }
+ return(val);
+}
+#endif
+
+/* case insensitive string compare */
+int str_icmp(char *s1, char *s2)
+{
+ int n1, n2, val;
+ if (s1 == NULL || s2 == NULL) return (-1);
+ n1 = strlen_(s1);
+ n2 = strlen_(s2);
+ if (n1 != n2) return(-1);
+ val = strncasecmp(s1,s2,n1);
+ return(val);
+}
+void set_loglevel(int level)
+{
+ loglevel = level;
+}
+
+void lprintf(int level, const char * format, ...)
+{
+ va_list vptr;
+ static char logtmp[LOG_MSG_LENGTH];
+ FILE *fp = stderr;
+ if (!verbose && (level > loglevel)) return;
+ if (fdbglog && (fplog != NULL)) fp = fplog;
+#ifdef WIN32
+ va_start(vptr, format);
+ vfprintf(fp, format, vptr);
+ va_end(vptr);
+ fprintf(fp,"\r\n");
+#else
+ va_start(vptr, format);
+ vsnprintf(logtmp, LOG_MSG_LENGTH, format, vptr);
+ va_end(vptr);
+ fprintf(fp, "%s\r\n", logtmp);
+#endif
+ return;
+}
+
+void lperror(int level, const char * format, ...)
+{
+ va_list vptr;
+ FILE *fp;
+ if (level > loglevel) return;
+ fp = stderr;
+ if (fdbglog && verbose > 1) {
+ if (fplog != NULL) fp = fplog;
+ }
+ va_start(vptr, format);
+ vfprintf(fp, format, vptr);
+ va_end(vptr);
+ fprintf(fp,"\r\n");
+ return;
+}
+
+void printbuf(const uchar * buf, int len, const char * desc)
+{
+ int i;
+ FILE *fp = stderr;
+
+ if (len <= 0) return;
+ if (verbose < 1) return;
+ if (fdbglog && (fplog != NULL)) fp = fplog;
+ fprintf(fp, "%s (%d bytes)\r\n", desc, len);
+ for (i=0; i<len; i++) {
+ if (((i%16) == 0) && (i != 0))
+ fprintf(fp, "\r\n");
+ fprintf(fp, " %2.2x", buf[i]);
+ }
+ fprintf(fp, "\r\n");
+}
+
+const char * buf2str(uchar * buf, int len)
+{
+ static char str[1024];
+ int i;
+ if (len <= 0 || len > sizeof(str)) return NULL;
+ memset(str, 0, sizeof(str));
+ for (i=0; i<len; i++) sprintf(str+i+i, "%2.2x", buf[i]);
+ str[len*2] = '\0';
+ return (const char *)str;
+}
+ushort buf2short(uchar * buf)
+{
+ return (ushort)(buf[1] << 8 | buf[0]);
+}
+ulong buf2long(uchar * buf)
+{
+ return (ulong)(buf[3] << 24 | buf[2] << 16 | buf[1] << 8 | buf[0]);
+}
+
+#define IPMI_OEM_PICMG 12634
+#define SZUN 32
+const char * oemval2str(ushort oem, uchar val, const struct oemvalstr *vs)
+{
+ static char un_str[SZUN];
+ int i;
+ for (i = 0; vs[i].oem != 0x00 && vs[i].str != NULL; i++) {
+ if ( ( vs[i].oem == oem || vs[i].oem == IPMI_OEM_PICMG )
+ && vs[i].val == val ) {
+ return vs[i].str;
+ }
+ }
+ memset(un_str, 0, SZUN);
+ snprintf(un_str, SZUN, "OEM reserved #%02x", val);
+ return un_str;
+}
+const char * val2str(ushort val, const struct valstr *vs)
+{
+ static char un_str[SZUN];
+ int i;
+ for (i = 0; vs[i].str != NULL; i++) {
+ if (vs[i].val == val) return vs[i].str;
+ }
+ memset(un_str, 0, SZUN);
+ snprintf(un_str, SZUN, "Unknown (0x%x)", val);
+ return un_str;
+}
+ushort str2val( char *str, struct valstr *vs)
+{
+ int i, x, y;
+ for (i = 0; vs[i].str != NULL; i++) {
+ x = strlen_(str);
+ y = strlen_(vs[i].str);
+ if (strncasecmp(vs[i].str, str, (x > y)? x : y) == 0)
+ return vs[i].val;
+ }
+ return vs[i].val;
+}
+
+
+void dump_buf(char *tag, uchar *pbuf, int sz, char fshowascii)
+{
+ uchar line[17];
+ uchar a;
+ int i, j;
+ char *stag;
+ FILE *fpdbg1;
+
+ if (fpdbg != NULL) fpdbg1 = fpdbg;
+ else fpdbg1 = stdout;
+ if (tag == NULL) stag = "dump_buf"; /*safety valve*/
+ else stag = tag;
+ fprintf(fpdbg1,"%s (len=%d): ", stag,sz);
+ line[0] = 0; line[16] = 0;
+ j = 0;
+ if (sz < 0) { fprintf(fpdbg1,"\n"); return; } /*safety valve*/
+ for (i = 0; i < sz; i++) {
+ if (i % 16 == 0) {
+ line[j] = 0;
+ j = 0;
+ fprintf(fpdbg1,"%s\n %04x: ",line,i);
+ }
+ if (fshowascii) {
+ a = pbuf[i];
+ if (a < 0x20 || a > 0x7f) a = '.';
+ line[j++] = a;
+ }
+ fprintf(fpdbg1,"%02x ",pbuf[i]);
+ }
+ if (fshowascii) {
+ if ((j > 0) && (j < 16)) {
+ /* space over the remaining number of hex bytes */
+ for (i = 0; i < (16-j); i++) fprintf(fpdbg1," ");
+ }
+ else j = 16;
+ line[j] = 0;
+ }
+ fprintf(fpdbg1,"%s\n",line);
+ return;
+}
+
+void close_log(void)
+{
+ if ((fplog != NULL) && (fplog != stderr) && (fplog != stdout)) {
+ fclose(fplog);
+ fplog = NULL;
+ }
+}
+
+FILE *open_log(char *mname)
+{
+ FILE *fp = NULL;
+ char *pname;
+ int len;
+
+ /* log_name is global, for reuse */
+ if (log_name[0] == 0) {
+ if (mname == NULL) { /*make a default name*/
+ pname = "ipmiutil";
+#ifdef WIN32
+ sprintf(log_name,"%s.log",pname);
+#elif defined(DOS)
+ sprintf(log_name,"%s.log",pname);
+#else
+ /*LINUX, SOLARIS, BSD */
+ sprintf(log_name,"/var/log/%s.log",pname);
+#endif
+ } else { /*use mname arg*/
+ len = strlen_(mname);
+ if (len >= sizeof(log_name)) len = sizeof(log_name) - 1;
+ strncpy(log_name, mname, len);
+ }
+ }
+ close_log();
+ if (log_name[0] != 0)
+ fp = fopen( log_name, "a+" );
+ if (fp == NULL) {
+ fp = stdout; /*was stderr*/
+ fprintf(fp,"cannot open log: %s\n",log_name);
+ }
+ fplog = fp;
+ return fp;
+}
+
+void flush_log(void)
+{
+ if (fplog != NULL) fflush(fplog);
+}
+
+void print_log( char *pattn, ... )
+{
+ va_list arglist;
+ if (fplog == NULL) fplog = open_log(NULL);
+ /* if error, open_log sets fplog = stdout */
+ va_start( arglist, pattn );
+ vfprintf( fplog, pattn, arglist );
+ va_end( arglist );
+}
+
+/*
+ * logmsg
+ * This does an open/close if no log is already open, but does not set fplog.
+ */
+void logmsg( char *pname, char *pattn, ... )
+{
+ va_list arglist;
+ FILE *fp = NULL;
+ int opened = 0;
+
+ if (fplog == NULL) { /*no log alread open, open temp fp*/
+ fp = open_log(pname);
+ if (fp == NULL) return;
+ opened = 1;
+ } else fp = fplog;
+ va_start( arglist, pattn );
+ vfprintf( fp, pattn, arglist );
+ va_end( arglist );
+ if ((opened) && (fp != stderr)) /*opened temp fp, so close it*/
+ { fclose(fp); }
+}
+
+void dump_log(FILE *fp, char *tag, uchar *pbuf, int sz, char fshowascii)
+{
+ FILE *fpsav;
+ fpsav = fpdbg;
+ if (fplog != NULL) fpdbg = fplog;
+ if (fp != NULL) fpdbg = fp;
+ dump_buf(tag, pbuf, sz, fshowascii); /*uses fpdbg*/
+ fflush(fpdbg);
+ fpdbg = fpsav;
+}
+
+
+extern int lasterr; /*defined in ipmilan.c */
+extern void show_LastError(char *tag, int err); /*ipmilan.c */
+
+#ifdef WIN32
+/* Windows stdlib.h: extern int * __cdecl _errno(void); */
+int get_errno(void)
+{
+ return(errno);
+}
+#else
+extern int errno; /* Linux<errno.h has this also */
+int get_errno(void)
+{
+ return(errno);
+}
+#endif
+
+ /* For a list of all IANA enterprise mfg vendor numbers,
+ * see http://www.iana.org/assignments/enterprise-numbers
+ * Product numbers are different for each mfg vendor. */
+#define N_MFG 43
+static struct { int val; char *pstr; } mfgs[N_MFG] = {
+ {0, " "},
+ {0x0000BA, "Toshiba"},
+ {0x000074, "Hitachi"},
+ {0x00018F, "Hitachi"},
+ {0x000175, "Tatung"},
+ {0x000614, "Performance Technologies"},
+ {0x000F85, "Aelita Software"}, /*3973. HP DL140*/
+ {0x0028B2, "Avocent"},
+ {0x002B5E, "OSA"},
+ {0x0035AE, "Raritan"}, /*13742.*/
+ {0x0051EE, "AMI"},
+ { 94, "Nokia-Siemens"},
+ { 107, "Bull"},
+ { 4337, "Radisys"},
+ { 4542, "ASF"},
+ { 6569, "Inventec"},
+ { 7154, "IPMI forum"},
+ { 11129, "Google"},
+ { 12634, "PICMG"},
+ { 16394, "Pigeon Point"},
+ { 20569, "Inventec ESC"},
+ { 24673, "ServerEngines"},
+ { 27768, "NAT"},
+ {VENDOR_CISCO, "Cisco"}, /*=5771.*/
+ {VENDOR_IBM, "IBM"}, /*0x000002*/
+ {VENDOR_NEWISYS, "Newisys"}, /*=9237. */
+ {VENDOR_XYRATEX, "Xyratex"}, /*=1993. */
+ {VENDOR_QUANTA, "Quanta"}, /*=7244. */
+ {VENDOR_MAGNUM, "Magnum Technologies"}, /*=5593. */
+ {VENDOR_SUPERMICROX, "xSuperMicro"}, /* 47488. used by Winbond/SuperMicro*/
+ {VENDOR_HP, "HP"}, /* 0x00000B for HP */
+ {VENDOR_DELL, "Dell"}, /*0x0002A2*/
+ {VENDOR_KONTRON, "Kontron"}, /*=0x003A98, 15000.*/
+ {VENDOR_SUPERMICRO, "SuperMicro"}, /*=0x002A7C, 10876. used in AOC-SIMSO*/
+ {VENDOR_FUJITSU, "Fujitsu-Siemens"}, /* 0x002880, 10368. */
+ {VENDOR_PEPPERCON, "Peppercon"}, /* 0x0028C5, 10437. now w Raritan*/
+ {VENDOR_MICROSOFT, "Microsoft"}, /*=0x000137, 311.*/
+ {VENDOR_NEC, "NEC"}, /*=0x000077*/
+ {VENDOR_NSC, "NSC"}, /*=0x000322*/
+ {VENDOR_LMC, "LMC"}, /*=0x000878 with SuperMicro*/
+ {VENDOR_TYAN, "Tyan"}, /*=0x0019FD*/
+ {VENDOR_SUN, "Sun"}, /*=0x00002A*/
+ {VENDOR_INTEL, "Intel"} /*=0x000157*/
+};
+
+char * get_iana_str(int mfg)
+{
+ char *mfgstr = "";
+ int i;
+ for (i = 0; i < N_MFG; i++) {
+ if (mfgs[i].val == mfg) {
+ mfgstr = mfgs[i].pstr;
+ break;
+ }
+ }
+ if (i >= N_MFG) mfgstr = mfgs[0].pstr;
+ return(mfgstr);
+}
+
+/*
+ * str2uchar
+ * Convert string into unsigned char and check for overflows
+ * @str: (input) array of chars to parse from
+ * @uchr_ptr: (output) pointer to address where uint8_t will be stored
+ * returns 0 if successful, or -1,-2,-3 if error
+ */
+int str2uchar(char *str, uchar *uchr_ptr)
+{
+ ulong lval = 0;
+ char *end_ptr = NULL;
+ if (str == NULL || uchr_ptr == NULL) return -1; /*NULL pointer arg*/
+ *uchr_ptr = 0; /*seed with default result*/
+ errno = 0;
+ /* handle use of 08, 09 to avoid octal overflow */
+ if (strncmp(str,"08",2) == 0) lval = 8;
+ else if (strncmp(str,"09",2) == 0) lval = 9;
+ else { /*else do strtoul*/
+ lval = strtoul(str, &end_ptr, 0);
+ if ((end_ptr == NULL) || *end_ptr != '\0' || errno != 0)
+ return -2; /* invalid input given by user/overflow occurred */
+ if (lval > 0xFF || lval == LONG_MIN || lval == LONG_MAX)
+ return -3; /* Argument is too big to fit unsigned char */
+ }
+ *uchr_ptr = (uchar)lval;
+ return 0;
+}
+
+/* atob is like atoi, but using str2uchar */
+uchar atob(char *str_in)
+{
+ uchar b = 0;
+ int rv;
+ rv = str2uchar(str_in,&b);
+ /* if error, show error, but use default. */
+ switch (rv) {
+ case -1:
+ printf("atob error: input pointer is NULL\n");
+ break;
+ case -2:
+ printf("atob error: string-to-number conversion overflow\n");
+ break;
+ case -3:
+ printf("atob error: numeric argument is too big for one byte\n");
+ break;
+ default:
+ break;
+ }
+ return(b);
+}
+
+void atoip(uchar *array,char *instr)
+{
+ int i,j,n;
+ char *pi;
+ char tmpstr[16];
+ /* converts ASCII input string into binary IP Address (array) */
+ if (array == NULL || instr == NULL) {
+ if (fdebug) printf("atoip(%p,%p) NULL pointer error\n",array,instr);
+ return;
+ }
+ j = 0;
+ n = strlen_(instr);
+ n++; /*include the null char*/
+ if (n > sizeof(tmpstr)) n = sizeof(tmpstr);
+ memcpy(tmpstr,instr,n);
+ pi = tmpstr;
+ for (i = 0; i < n; i++) {
+ if (tmpstr[i] == '.') {
+ tmpstr[i] = 0;
+ array[j++] = atob(pi);
+ pi = &tmpstr[i+1];
+ }
+ else if (tmpstr[i] == 0) {
+ array[j++] = atob(pi);
+ }
+ }
+ if (fdebug)
+ printf("atoip: %d %d %d %d\n", array[0],array[1],array[2],array[3]);
+} /*end atoip()*/
+
+/*
+ * htoi
+ * Almost all of the utilities use this subroutine
+ * Input: a 2 character string of hex digits.
+ * Output: a hex byte.
+ */
+uchar htoi(char *inhex)
+{
+ // char rghex[16] = "0123456789ABCDEF";
+ uchar val;
+ uchar c;
+ if (inhex[1] == 0) { /* short string, one char */
+ c = inhex[0] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val = (c & 0x0f);
+ } else {
+ c = inhex[0] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val = (c & 0x0f) << 4;
+ c = inhex[1] & 0x5f; /* force cap */
+ if (c > '9') c += 9; /* c >= 'A' */
+ val += (c & 0x0f);
+ }
+ return(val);
+}
+
+
+void os_usleep(int s, int u)
+{
+#ifdef WIN32
+ if (s == 0) {
+ int i;
+ if (u >= 1000) Sleep(u/1000);
+ else for (i=0; i<u; i++) s = 0; /*spin for u loops*/
+ } else {
+ Sleep(s * 1000);
+ }
+#elif defined(DOS)
+ if (s == 0) delay(u);
+ else delay(s * 1000);
+#else
+ if (s == 0) {
+ usleep(u);
+ } else {
+ sleep(s);
+ }
+#endif
+}
+
+#define SYS_INFO_MAX 64
+
+static int sysinfo_has_len(uchar enc, int vendor)
+{
+ int rv = 1;
+ int vend;
+ if (enc > (uchar)2) return(0); /*encoding max is 2*/
+ if (vendor == 0) get_mfgid(&vend, NULL);
+ else vend = vendor;
+ if (vend == VENDOR_INTEL) rv = 0;
+ if (vend == VENDOR_SUPERMICRO) rv = 0;
+ return(rv);
+}
+
+int get_device_guid(char *pbuf, int *szbuf)
+{
+ int rv = -1;
+ //uchar idata[8];
+ uchar rdata[32];
+ int rlen, len;
+ uchar cc;
+ ushort cmdw;
+
+ len = *szbuf;
+ *szbuf = 0;
+ cmdw = 0x08 | (NETFN_APP << 8);
+ rv = ipmi_cmd_mc(cmdw, NULL,0,rdata,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv == 0) {
+ if (rlen > len) rlen = len;
+ memcpy(pbuf,rdata,rlen);
+ *szbuf = rlen;
+ }
+ return(rv);
+}
+
+int get_sysinfo(uchar parm, uchar set, uchar block, uchar *pbuf, int *szbuf)
+{
+ uchar idata[8];
+ uchar rdata[32];
+ int rlen, j, len;
+ int rv = -1;
+ uchar cc;
+ ushort cmdw;
+
+ if (pbuf == NULL || szbuf == NULL) return(rv);
+ len = 0;
+ idata[0] = 0;
+ idata[1] = parm;
+ idata[2] = set;
+ idata[3] = block;
+ rlen = sizeof(rdata);
+ cmdw = CMD_GET_SYSTEM_INFO | (NETFN_APP << 8);
+ rv = ipmi_cmd_mc(cmdw, idata,4,rdata,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (rv == 0) {
+ j = 2;
+ if (set == 0) { /*NEW_FMT: first set includes type, len */
+ if (sysinfo_has_len(rdata[2],0)) { /*but len not used if Intel*/
+ j = 4;
+ len = rdata[3];
+ }
+ }
+ rdata[rlen] = 0; /*stringify for debug below*/
+ rlen -= j;
+ if (fdebug) printf("get_sysinfo(%d,%d) j=%d len=%d %s\n",
+ parm,set,j,rlen,&rdata[j]);
+ if (rlen > *szbuf) rlen = *szbuf;
+ memcpy(pbuf,&rdata[j],rlen);
+ *szbuf = rlen;
+ }
+ return(rv);
+}
+
+int set_system_info(uchar parm, uchar *pbuf, int szbuf)
+{
+ uchar idata[32];
+ uchar rdata[8];
+ int rlen, ilen, i, j, n;
+ int rv = -1;
+ uchar cc, set;
+ ushort cmdw;
+
+ if (pbuf == NULL) return(rv);
+ if (szbuf > SYS_INFO_MAX) szbuf = SYS_INFO_MAX;
+ n = 0; set = 0;
+ while ((n < szbuf) || (n == 0)) {
+ ilen = 16;
+ j = 2;
+ memset(idata,0,sizeof(idata));
+ idata[0] = parm;
+ idata[1] = set;
+ if (set == 0) { /*NEW_FMT: first set includes type, len */
+ if (sysinfo_has_len(0,0)) { /*but len not used if Intel*/
+ j = 4;
+ idata[2] = 0; /*type = ASCII+Latin1*/
+ idata[3] = szbuf; /*overall length*/
+ }
+ }
+ i = ilen;
+ if (i > (szbuf - n)) i = (szbuf - n);
+ memcpy(&idata[j],&pbuf[n],i);
+ rlen = sizeof(rdata);
+ cmdw = CMD_SET_SYSTEM_INFO | (NETFN_APP << 8);
+ rv = ipmi_cmd_mc(cmdw, idata,(ilen+j),rdata,&rlen,&cc,fdebug);
+ if (rv == 0 && cc != 0) rv = cc;
+ if (fdebug) printf("set_system_info(%d,%d) rv=%d j=%d ilen=%d %s\n",
+ parm,set,rv,j,ilen,&pbuf[n]);
+ if (rv != 0) break;
+ else {
+ n += ilen;
+ set++;
+ }
+ }
+ return(rv);
+}
+
+int get_system_info(uchar parm, char *pbuf, int *szbuf)
+{
+ int rv = -1;
+ int i, off, len, szchunk;
+
+ off = 0; len = *szbuf;
+ /* SYS_INFO_MAX = 64 (4 * 16) */
+ for (i = 0; i < 4; i++) {
+ szchunk = 16;
+ if ((off + szchunk) > *szbuf) break;
+ rv = get_sysinfo(parm,i,0,&pbuf[off],&szchunk);
+ if (rv != 0) break;
+ off += szchunk;
+ if (off >= len) break;
+ }
+ if (off < *szbuf) *szbuf = off;
+ return(rv);
+}
+
+int ipmi_reserved_user(int vend, int userid)
+{
+ int ret = 0;
+ if (userid == 1) {
+ switch(vend) {
+ case VENDOR_INTEL: ret = 0; break;
+ case VENDOR_KONTRON: ret = 1; break;
+ case VENDOR_SUPERMICRO: ret = 1; break;
+ case VENDOR_SUPERMICROX: ret = 1; break;
+ default: ret = 0; break;
+ }
+ }
+ return(ret);
+}
+
+#define NSEV 4
+static char *sev_str[NSEV] = {
+ /*0*/ "INF",
+ /*1*/ "MIN",
+ /*2*/ "MAJ",
+ /*3*/ "CRT" };
+
+uchar find_msg_sev(char *msg)
+{
+ int i;
+ char *p;
+ uchar sev = SEV_INFO;
+
+ if (msg == NULL) return(sev);
+ for (i = 0; i < NSEV; i++) {
+ p = strstr(msg,sev_str[i]);
+ if (p != NULL) { sev = (uchar)i; break; }
+ }
+ return(sev);
+}
+
+int OpenSyslog(char *tag)
+{
+ int ret = -1;
+ if (tag == NULL) tag = "ipmiutil";
+#ifdef WIN32
+ /* Requires showselmsg.dll and this Registry entry:
+ HKLM/SYSTEM/CurrentControlSet/Services/EventLog/Application/showsel
+ EventMessageFile REG_EXPAND_SZ "%SystemRoot%\system32\showselmsg.dll"
+ TypesSupported REG_DWORD 0x000000007
+ */
+ hLog = RegisterEventSource(NULL, "showsel");
+ if (hLog == (void *)ERROR_INVALID_HANDLE) { hLog = NULL; }
+ if (hLog == NULL)
+ printf("RegisterEventSource error, %lx\n", GetLastError());
+ else ret = 0; /*success*/
+#elif defined(DOS)
+ ret = LAN_ERR_NOTSUPPORT;
+#else
+ // Open syslog
+ openlog( tag, LOG_CONS, LOG_KERN);
+ ret = 0; /* success if here */
+#endif
+ return(ret);
+}
+
+void CloseSyslog(void)
+{
+#ifdef WIN32
+ DeregisterEventSource(hLog);
+#elif defined(DOS)
+ ;
+#else
+ // Close syslog
+ closelog();
+#endif
+}
+
+void WriteSyslog(char *msgbuf)
+{
+ uchar sev;
+#ifdef WIN32
+ BOOL status;
+ char *rgstrings[2] = {NULL, NULL};
+ WORD level;
+ rgstrings[0] = msgbuf; /*decoded SEL entry*/
+ sev = find_msg_sev(msgbuf);
+ switch(sev) {
+ case SEV_MIN: level = EVENTLOG_WARNING_TYPE; break;
+ case SEV_MAJ: level = EVENTLOG_ERROR_TYPE; break;
+ case SEV_CRIT: level = EVENTLOG_ERROR_TYPE; break;
+ case SEV_INFO:
+ default: level = EVENTLOG_INFORMATION_TYPE; break;
+ }
+ if (hLog != NULL) {
+ status = ReportEvent(hLog,EVENTLOG_INFORMATION_TYPE,
+ 0, SELMSG_ID, NULL, 1,0,
+ rgstrings,NULL);
+ /* showsel eventid = 0x101. */
+ if (fdebug || (status == 0)) { /*error or debug*/
+ printf("ReportEvent status=%d, %lx\n",
+ status,GetLastError());
+ }
+ }
+#elif defined(DOS)
+ ;
+#else
+ int level;
+ sev = find_msg_sev(msgbuf);
+ switch(sev) {
+ case SEV_MIN: level = LOG_WARNING; break;
+ case SEV_MAJ: level = LOG_ERR; break;
+ case SEV_CRIT: level = LOG_CRIT; break;
+ case SEV_INFO:
+ default: level = LOG_INFO; break;
+ }
+ syslog(level,"%s",msgbuf);
+#endif
+} /*end WriteSyslog*/
+
+int write_syslog(char *msg)
+{ /* not used in showsel, but used by getevent, hwreset */
+ int rv;
+ rv = OpenSyslog("ipmiutil");
+ if (rv == 0) {
+ WriteSyslog(msg);
+ CloseSyslog();
+ }
+ return(rv);
+}
+
+/* end subs.c */
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-26 05:41:20 +0000