deepblue/ipmitool
1
0
Fork 0
mirror of https://github.com/ipmitool/ipmitool.git synced 2025-05-12 11:37:23 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix gcc4 compile warnings

Browse Source
This commit is contained in:
Duncan Laurie 2006-03-19 20:54:44 +00:00
parent a3d206523d
commit c65b206144
20 changed files with 1403 additions and 1397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ipmitool/include/ipmitool/ipmi_picmg.h
View File

@ -57,7 +57,7 @@ struct picmg_set_fru_activation_cmd {
/* the LED color capabilities */ /* the LED color capabilities */
static unsigned char* led_color_str[] = { static const char* led_color_str[] = {
"reserved", "reserved",
"BLUE", "BLUE",
"RED", "RED",

2
ipmitool/include/ipmitool/ipmi_sel.h
View File

@ -545,6 +545,6 @@ uint16_t ipmi_sel_get_std_entry(struct ipmi_intf * intf, uint16_t id, struct sel
char * get_newisys_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec); char * get_newisys_evt_desc(struct ipmi_intf * intf, struct sel_event_record * rec);
IPMI_OEM ipmi_get_oem(struct ipmi_intf * intf); IPMI_OEM ipmi_get_oem(struct ipmi_intf * intf);
char * ipmi_get_oem_desc(struct ipmi_intf * intf, struct sel_event_record * rec); char * ipmi_get_oem_desc(struct ipmi_intf * intf, struct sel_event_record * rec);
int ipmi_sel_oem_init(char * filename); int ipmi_sel_oem_init(const char * filename);
#endif /* IPMI_SEL_H */ #endif /* IPMI_SEL_H */

8
ipmitool/lib/ipmi_channel.c
View File

@ -222,16 +222,16 @@ ipmi_get_channel_info(struct ipmi_intf * intf, uint8_t channel)
printf(" Session Support : "); printf(" Session Support : ");
switch (channel_info.session_support) { switch (channel_info.session_support) {
case 0x00: case 0x0:
printf("session-less\n"); printf("session-less\n");
break; break;
case 0x40: case 0x1:
printf("single-session\n"); printf("single-session\n");
break; break;
case 0x80: case 0x2:
printf("multi-session\n"); printf("multi-session\n");
break; break;
case 0xc0: case 0x3:
default: default:
printf("session-based\n"); printf("session-based\n");
break; break;

31
ipmitool/lib/ipmi_fru.c
View File

@ -57,26 +57,26 @@
extern int verbose; extern int verbose;
extern int ipmi_spd_print(struct ipmi_intf * intf, uint8_t id); extern int ipmi_spd_print(struct ipmi_intf * intf, uint8_t id);
static void ipmi_fru_read_to_bin(struct ipmi_intf * intf,unsigned char * pFileName, unsigned char fruId); static void ipmi_fru_read_to_bin(struct ipmi_intf * intf, char * pFileName, unsigned char fruId);
static void ipmi_fru_write_from_bin(struct ipmi_intf * intf, unsigned char * pFileName, unsigned char fruId); static void ipmi_fru_write_from_bin(struct ipmi_intf * intf, char * pFileName, unsigned char fruId);
static int ipmi_fru_upg_ekeying(struct ipmi_intf * intf,unsigned char * pFileName, unsigned char fruId); static int ipmi_fru_upg_ekeying(struct ipmi_intf * intf, char * pFileName, unsigned char fruId);
static int ipmi_fru_get_multirec_location_from_fru(struct ipmi_intf * intf, static int ipmi_fru_get_multirec_location_from_fru(struct ipmi_intf * intf,
unsigned char fruId, unsigned char fruId,
struct fru_info *pFruInfo, struct fru_info *pFruInfo,
unsigned long * pRetLocation, unsigned long * pRetLocation,
unsigned long * pRetSize); unsigned long * pRetSize);
static int ipmi_fru_get_multirec_from_file(unsigned char * pFileName, static int ipmi_fru_get_multirec_from_file(char * pFileName,
unsigned char * pBufArea, unsigned char * pBufArea,
unsigned long size, unsigned long size,
unsigned long offset); unsigned long offset);
static int ipmi_fru_get_multirec_size_from_file(unsigned char * pFileName, static int ipmi_fru_get_multirec_size_from_file(char * pFileName,
unsigned long * pSize, unsigned long * pSize,
unsigned long * pOffset); unsigned long * pOffset);
static void ipmi_fru_get_adjust_size_from_buffer(unsigned char * pBufArea, static void ipmi_fru_get_adjust_size_from_buffer(unsigned char * pBufArea,
unsigned long *pSize); unsigned long *pSize);
static unsigned char fileName[512]; static char fileName[512];
static void ipmi_fru_picmg_ext_print(unsigned char * fru_data, int off, int length); static void ipmi_fru_picmg_ext_print(unsigned char * fru_data, int off, int length);
@ -377,7 +377,8 @@ static void
fru_area_print_chassis(struct ipmi_intf * intf, struct fru_info * fru, fru_area_print_chassis(struct ipmi_intf * intf, struct fru_info * fru,
uint8_t id, uint32_t offset) uint8_t id, uint32_t offset)
{ {
uint8_t * fru_area, * fru_data; char * fru_area;
uint8_t * fru_data;
uint32_t fru_len, area_len, i; uint32_t fru_len, area_len, i;
i = offset; i = offset;
@ -449,7 +450,8 @@ static void
fru_area_print_board(struct ipmi_intf * intf, struct fru_info * fru, fru_area_print_board(struct ipmi_intf * intf, struct fru_info * fru,
uint8_t id, uint32_t offset) uint8_t id, uint32_t offset)
{ {
uint8_t * fru_area, * fru_data; char * fru_area;
uint8_t * fru_data;
uint32_t fru_len, area_len, i; uint32_t fru_len, area_len, i;
i = offset; i = offset;
@ -540,7 +542,8 @@ static void
fru_area_print_product(struct ipmi_intf * intf, struct fru_info * fru, fru_area_print_product(struct ipmi_intf * intf, struct fru_info * fru,
uint8_t id, uint32_t offset) uint8_t id, uint32_t offset)
{ {
uint8_t * fru_area, * fru_data; char * fru_area;
uint8_t * fru_data;
uint32_t fru_len, area_len, i; uint32_t fru_len, area_len, i;
i = offset; i = offset;
@ -1420,7 +1423,7 @@ ipmi_fru_main(struct ipmi_intf * intf, int argc, char ** argv)
return rc; return rc;
} }
static void ipmi_fru_read_to_bin(struct ipmi_intf * intf,unsigned char * pFileName, unsigned char fruId) static void ipmi_fru_read_to_bin(struct ipmi_intf * intf, char * pFileName, unsigned char fruId)
{ {
struct ipmi_rs * rsp; struct ipmi_rs * rsp;
struct ipmi_rq req; struct ipmi_rq req;
@ -1489,7 +1492,7 @@ static void ipmi_fru_read_to_bin(struct ipmi_intf * intf,unsigned char * pFileNa
} }
static void ipmi_fru_write_from_bin(struct ipmi_intf * intf, static void ipmi_fru_write_from_bin(struct ipmi_intf * intf,
unsigned char * pFileName, unsigned char fruId) char * pFileName, unsigned char fruId)
{ {
struct ipmi_rs *rsp; struct ipmi_rs *rsp;
struct ipmi_rq req; struct ipmi_rq req;
@ -1551,7 +1554,7 @@ static void ipmi_fru_write_from_bin(struct ipmi_intf * intf,
} }
static int static int
ipmi_fru_upg_ekeying(struct ipmi_intf * intf,unsigned char * pFileName, ipmi_fru_upg_ekeying(struct ipmi_intf * intf, char * pFileName,
unsigned char fruId) unsigned char fruId)
{ {
unsigned int retStatus = 0; unsigned int retStatus = 0;
@ -1615,7 +1618,7 @@ ipmi_fru_upg_ekeying(struct ipmi_intf * intf,unsigned char * pFileName,
} }
} }
static int ipmi_fru_get_multirec_size_from_file(unsigned char * pFileName, static int ipmi_fru_get_multirec_size_from_file(char * pFileName,
unsigned long * pSize, unsigned long * pSize,
unsigned long * pOffset) unsigned long * pOffset)
{ {
@ -1768,7 +1771,7 @@ static void ipmi_fru_get_adjust_size_from_buffer(unsigned char * fru_data,
} }
static int ipmi_fru_get_multirec_from_file(unsigned char * pFileName, static int ipmi_fru_get_multirec_from_file(char * pFileName,
unsigned char * pBufArea, unsigned char * pBufArea,
unsigned long size, unsigned long size,
unsigned long offset) unsigned long offset)

19
ipmitool/lib/ipmi_fwum.c
View File

@ -109,18 +109,18 @@ typedef struct sKFWUM_InFirmwareInfo {
#define KFWUM_PAGE_SIZE 256 #define KFWUM_PAGE_SIZE 256
extern int verbose; extern int verbose;
static unsigned char fileName[512]; static char fileName[512];
static unsigned char firmBuf[1024 * 512]; static unsigned char firmBuf[1024 * 512];
static unsigned char firmMaj; static unsigned char firmMaj;
static unsigned char firmMinSub; static unsigned char firmMinSub;
static void KfwumOutputHelp(void); static void KfwumOutputHelp(void);
static void KfwumMain(struct ipmi_intf *intf, tKFWUM_Task task); static void KfwumMain(struct ipmi_intf *intf, tKFWUM_Task task);
static tKFWUM_Status KfwumGetFileSize(unsigned char *pFileName, static tKFWUM_Status KfwumGetFileSize(char *pFileName,
unsigned long *pFileSize); unsigned long *pFileSize);
static tKFWUM_Status KfwumSetupBuffersFromFile(unsigned char *pFileName, static tKFWUM_Status KfwumSetupBuffersFromFile(char *pFileName,
unsigned long fileSize); unsigned long fileSize);
static void KfwumShowProgress(const unsigned char *task, static void KfwumShowProgress(const char *task,
unsigned long current, unsigned long total); unsigned long current, unsigned long total);
static unsigned short KfwumCalculateChecksumPadding(unsigned char *pBuffer, static unsigned short KfwumCalculateChecksumPadding(unsigned char *pBuffer,
unsigned long totalSize); unsigned long totalSize);
@ -353,7 +353,7 @@ KfwumMain(struct ipmi_intf *intf, tKFWUM_Task task)
} }
static tKFWUM_Status static tKFWUM_Status
KfwumGetFileSize(unsigned char *pFileName, unsigned long *pFileSize) KfwumGetFileSize(char *pFileName, unsigned long *pFileSize)
{ {
tKFWUM_Status status = KFWUM_STATUS_ERROR; tKFWUM_Status status = KFWUM_STATUS_ERROR;
FILE *pFileHandle; FILE *pFileHandle;
@ -376,7 +376,7 @@ KfwumGetFileSize(unsigned char *pFileName, unsigned long *pFileSize)
#define MAX_BUFFER_SIZE 1024*16 #define MAX_BUFFER_SIZE 1024*16
static tKFWUM_Status static tKFWUM_Status
KfwumSetupBuffersFromFile(unsigned char *pFileName, unsigned long fileSize) KfwumSetupBuffersFromFile(char *pFileName, unsigned long fileSize)
{ {
tKFWUM_Status status = KFWUM_STATUS_OK; tKFWUM_Status status = KFWUM_STATUS_OK;
FILE *pFileHandle; FILE *pFileHandle;
@ -391,8 +391,9 @@ KfwumSetupBuffersFromFile(unsigned char *pFileName, unsigned long fileSize)
rewind(pFileHandle); rewind(pFileHandle);
for (qty = 0; qty < count; qty++) { for (qty = 0; qty < count; qty++) {
KfwumShowProgress("Reading Firmware from File", qty, KfwumShowProgress("Reading Firmware from File",
count); (unsigned long)qty,
(unsigned long)count);
if (fread if (fread
(&firmBuf[qty * MAX_BUFFER_SIZE], 1, (&firmBuf[qty * MAX_BUFFER_SIZE], 1,
MAX_BUFFER_SIZE, pFileHandle) MAX_BUFFER_SIZE, pFileHandle)
@ -417,7 +418,7 @@ KfwumSetupBuffersFromFile(unsigned char *pFileName, unsigned long fileSize)
#define PROG_LENGTH 42 #define PROG_LENGTH 42
void void
KfwumShowProgress(const unsigned char *task, unsigned long current, KfwumShowProgress(const char *task, unsigned long current,
unsigned long total) unsigned long total)
{ {
static unsigned long staticProgress = 0xffffffff; static unsigned long staticProgress = 0xffffffff;

10
ipmitool/lib/ipmi_lanp.c
View File

@ -456,7 +456,7 @@ lan_set_arp_interval(struct ipmi_intf * intf,
return -1; return -1;
if (ival != 0) { if (ival != 0) {
interval = ((uint8_t)atoi(ival) * 2) - 1; interval = ((uint8_t)atoi((const char *)ival) * 2) - 1;
rc = set_lan_param(intf, chan, IPMI_LANP_GRAT_ARP, &interval, 1); rc = set_lan_param(intf, chan, IPMI_LANP_GRAT_ARP, &interval, 1);
} else { } else {
interval = lp->data[0]; interval = lp->data[0];
@ -897,7 +897,7 @@ ipmi_lan_set_password(struct ipmi_intf * intf,
data[1] = 0x02; /* set password */ data[1] = 0x02; /* set password */
if (password != NULL) if (password != NULL)
memcpy(data+2, password, __min(strlen(password), 16)); memcpy(data+2, password, __min(strlen((const char *)password), 16));
memset(&req, 0, sizeof(req)); memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_APP; req.msg.netfn = IPMI_NETFN_APP;
@ -919,7 +919,7 @@ ipmi_lan_set_password(struct ipmi_intf * intf,
/* adjust our session password /* adjust our session password
* or we will no longer be able to communicate with BMC * or we will no longer be able to communicate with BMC
*/ */
ipmi_intf_session_set_password(intf, password); ipmi_intf_session_set_password(intf, (char *)password);
printf("Password %s for user %d\n", printf("Password %s for user %d\n",
(password == NULL) ? "cleared" : "set", userid); (password == NULL) ? "cleared" : "set", userid);
@ -1349,7 +1349,7 @@ ipmi_lan_set(struct ipmi_intf * intf, int argc, char ** argv)
"example: lan set 7 arp gratuitous off\n"); "example: lan set 7 arp gratuitous off\n");
} }
else if (strncmp(argv[2], "interval", 8) == 0) { else if (strncmp(argv[2], "interval", 8) == 0) {
rc = lan_set_arp_interval(intf, chan, argv[3]); rc = lan_set_arp_interval(intf, chan, (uint8_t *)argv[3]);
} }
else if (strncmp(argv[2], "generate", 8) == 0) { else if (strncmp(argv[2], "generate", 8) == 0) {
if (argc < 4) if (argc < 4)
@ -1423,7 +1423,7 @@ ipmi_lan_set(struct ipmi_intf * intf, int argc, char ** argv)
/* session password /* session password
* not strictly a lan setting, but its used for lan connections */ * not strictly a lan setting, but its used for lan connections */
else if (strncmp(argv[1], "password", 8) == 0) { else if (strncmp(argv[1], "password", 8) == 0) {
rc = ipmi_lan_set_password(intf, 1, argv[2]); rc = ipmi_lan_set_password(intf, 1, (uint8_t *)argv[2]);
} }
/* snmp community string */ /* snmp community string */
else if (strncmp(argv[1], "snmp", 4) == 0) { else if (strncmp(argv[1], "snmp", 4) == 0) {

2
ipmitool/lib/ipmi_mc.c
View File

@ -412,7 +412,7 @@ ipmi_mc_get_guid(struct ipmi_intf * intf)
} }
if (rsp->data_len == sizeof(struct ipmi_guid)) { if (rsp->data_len == sizeof(struct ipmi_guid)) {
uint8_t tbuf[40]; char tbuf[40];
time_t s; time_t s;
memset(tbuf, 0, 40); memset(tbuf, 0, 40);
memset(&guid, 0, sizeof(struct ipmi_guid)); memset(&guid, 0, sizeof(struct ipmi_guid));

2
ipmitool/lib/ipmi_pef.c
View File

@ -307,7 +307,7 @@ ipmi_pef_print_lan_dest(struct ipmi_intf * intf, uint8_t ch, uint8_t dest)
"PET community"); "PET community");
else { else {
rsp->data[19] = '\0'; rsp->data[19] = '\0';
ipmi_pef_print_str("PET Community", &rsp->data[1]); ipmi_pef_print_str("PET Community", (const char *)&rsp->data[1]);
} }
} }
ipmi_pef_print_dec("ACK timeout/retry (secs)", timeout); ipmi_pef_print_dec("ACK timeout/retry (secs)", timeout);

66
ipmitool/lib/ipmi_sdr.c
View File

@ -3191,39 +3191,39 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf *intf, char *id)
for (e = sdr_list_head; e != NULL; e = e->next) { for (e = sdr_list_head; e != NULL; e = e->next) {
switch (e->type) { switch (e->type) {
case SDR_RECORD_TYPE_FULL_SENSOR: case SDR_RECORD_TYPE_FULL_SENSOR:
if (!strncmp(e->record.full->id_string, id, if (!strncmp((const char *)e->record.full->id_string,
__max(e->record.full->id_code & 0x1f, (const char *)id,
idlen))) __max(e->record.full->id_code & 0x1f, idlen)))
return e; return e;
break; break;
case SDR_RECORD_TYPE_COMPACT_SENSOR: case SDR_RECORD_TYPE_COMPACT_SENSOR:
if (!strncmp(e->record.compact->id_string, id, if (!strncmp((const char *)e->record.compact->id_string,
__max(e->record.compact->id_code & 0x1f, (const char *)id,
idlen))) __max(e->record.compact->id_code & 0x1f, idlen)))
return e; return e;
break; break;
case SDR_RECORD_TYPE_EVENTONLY_SENSOR: case SDR_RECORD_TYPE_EVENTONLY_SENSOR:
if (!strncmp(e->record.eventonly->id_string, id, if (!strncmp((const char *)e->record.eventonly->id_string,
__max(e->record.eventonly->id_code & 0x1f, (const char *)id,
idlen))) __max(e->record.eventonly->id_code & 0x1f, idlen)))
return e; return e;
break; break;
case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR:
if (!strncmp(e->record.genloc->id_string, id, if (!strncmp((const char *)e->record.genloc->id_string,
__max(e->record.genloc->id_code & 0x1f, (const char *)id,
idlen))) __max(e->record.genloc->id_code & 0x1f, idlen)))
return e; return e;
break; break;
case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR:
if (!strncmp(e->record.fruloc->id_string, id, if (!strncmp((const char *)e->record.fruloc->id_string,
__max(e->record.fruloc->id_code & 0x1f, (const char *)id,
idlen))) __max(e->record.fruloc->id_code & 0x1f, idlen)))
return e; return e;
break; break;
case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR:
if (!strncmp(e->record.mcloc->id_string, id, if (!strncmp((const char *)e->record.mcloc->id_string,
__max(e->record.mcloc->id_code & 0x1f, (const char *)id,
idlen))) __max(e->record.mcloc->id_code & 0x1f, idlen)))
return e; return e;
break; break;
} }
@ -3251,16 +3251,18 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf *intf, char *id)
case SDR_RECORD_TYPE_FULL_SENSOR: case SDR_RECORD_TYPE_FULL_SENSOR:
sdrr->record.full = sdrr->record.full =
(struct sdr_record_full_sensor *) rec; (struct sdr_record_full_sensor *) rec;
if (!strncmp if (!strncmp(
(sdrr->record.full->id_string, id, (const char *)sdrr->record.full->id_string,
(const char *)id,
__max(sdrr->record.full->id_code & 0x1f, idlen))) __max(sdrr->record.full->id_code & 0x1f, idlen)))
found = 1; found = 1;
break; break;
case SDR_RECORD_TYPE_COMPACT_SENSOR: case SDR_RECORD_TYPE_COMPACT_SENSOR:
sdrr->record.compact = sdrr->record.compact =
(struct sdr_record_compact_sensor *) rec; (struct sdr_record_compact_sensor *) rec;
if (!strncmp if (!strncmp(
(sdrr->record.compact->id_string, id, (const char *)sdrr->record.compact->id_string,
(const char *)id,
__max(sdrr->record.compact->id_code & 0x1f, __max(sdrr->record.compact->id_code & 0x1f,
idlen))) idlen)))
found = 1; found = 1;
@ -3268,8 +3270,9 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf *intf, char *id)
case SDR_RECORD_TYPE_EVENTONLY_SENSOR: case SDR_RECORD_TYPE_EVENTONLY_SENSOR:
sdrr->record.eventonly = sdrr->record.eventonly =
(struct sdr_record_eventonly_sensor *) rec; (struct sdr_record_eventonly_sensor *) rec;
if (!strncmp if (!strncmp(
(sdrr->record.eventonly->id_string, id, (const char *)sdrr->record.eventonly->id_string,
(const char *)id,
__max(sdrr->record.eventonly->id_code & 0x1f, __max(sdrr->record.eventonly->id_code & 0x1f,
idlen))) idlen)))
found = 1; found = 1;
@ -3277,24 +3280,27 @@ ipmi_sdr_find_sdr_byid(struct ipmi_intf *intf, char *id)
case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR: case SDR_RECORD_TYPE_GENERIC_DEVICE_LOCATOR:
sdrr->record.genloc = sdrr->record.genloc =
(struct sdr_record_generic_locator *) rec; (struct sdr_record_generic_locator *) rec;
if (!strncmp if (!strncmp(
(sdrr->record.genloc->id_string, id, (const char *)sdrr->record.genloc->id_string,
(const char *)id,
__max(sdrr->record.genloc->id_code & 0x1f, idlen))) __max(sdrr->record.genloc->id_code & 0x1f, idlen)))
found = 1; found = 1;
break; break;
case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR: case SDR_RECORD_TYPE_FRU_DEVICE_LOCATOR:
sdrr->record.fruloc = sdrr->record.fruloc =
(struct sdr_record_fru_locator *) rec; (struct sdr_record_fru_locator *) rec;
if (!strncmp if (!strncmp(
(sdrr->record.fruloc->id_string, id, (const char *)sdrr->record.fruloc->id_string,
(const char *)id,
__max(sdrr->record.fruloc->id_code & 0x1f, idlen))) __max(sdrr->record.fruloc->id_code & 0x1f, idlen)))
found = 1; found = 1;
break; break;
case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR: case SDR_RECORD_TYPE_MC_DEVICE_LOCATOR:
sdrr->record.mcloc = sdrr->record.mcloc =
(struct sdr_record_mc_locator *) rec; (struct sdr_record_mc_locator *) rec;
if (!strncmp if (!strncmp(
(sdrr->record.mcloc->id_string, id, (const char *)sdrr->record.mcloc->id_string,
(const char *)id,
__max(sdrr->record.mcloc->id_code & 0x1f, idlen))) __max(sdrr->record.mcloc->id_code & 0x1f, idlen)))
found = 1; found = 1;
break; break;

12
ipmitool/lib/ipmi_sel.c
View File

@ -98,7 +98,7 @@ static int ipmi_sel_oem_match(uint8_t *evt, struct ipmi_sel_oem_msg_rec rec)
} }
} }
void ipmi_sel_oem_init(const char * filename) int ipmi_sel_oem_init(const char * filename)
{ {
FILE * fp; FILE * fp;
int i, j, k, n, byte; int i, j, k, n, byte;
@ -215,7 +215,7 @@ ipmi_get_event_type(uint8_t code)
static char * static char *
ipmi_sel_timestamp(uint32_t stamp) ipmi_sel_timestamp(uint32_t stamp)
{ {
static uint8_t tbuf[40]; static char tbuf[40];
time_t s = (time_t)stamp; time_t s = (time_t)stamp;
memset(tbuf, 0, 40); memset(tbuf, 0, 40);
strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", localtime(&s)); strftime(tbuf, sizeof(tbuf), "%m/%d/%Y %H:%M:%S", localtime(&s));
@ -225,7 +225,7 @@ ipmi_sel_timestamp(uint32_t stamp)
static char * static char *
ipmi_sel_timestamp_date(uint32_t stamp) ipmi_sel_timestamp_date(uint32_t stamp)
{ {
static uint8_t tbuf[11]; static char tbuf[11];
time_t s = (time_t)stamp; time_t s = (time_t)stamp;
strftime(tbuf, sizeof(tbuf), "%m/%d/%Y", localtime(&s)); strftime(tbuf, sizeof(tbuf), "%m/%d/%Y", localtime(&s));
return tbuf; return tbuf;
@ -234,7 +234,7 @@ ipmi_sel_timestamp_date(uint32_t stamp)
static char * static char *
ipmi_sel_timestamp_time(uint32_t stamp) ipmi_sel_timestamp_time(uint32_t stamp)
{ {
static uint8_t tbuf[9]; static char tbuf[9];
time_t s = (time_t)stamp; time_t s = (time_t)stamp;
strftime(tbuf, sizeof(tbuf), "%H:%M:%S", localtime(&s)); strftime(tbuf, sizeof(tbuf), "%H:%M:%S", localtime(&s));
return tbuf; return tbuf;
@ -244,7 +244,7 @@ static char *
hex2ascii (uint8_t * hexChars, uint8_t numBytes) hex2ascii (uint8_t * hexChars, uint8_t numBytes)
{ {
int count; int count;
static uint8_t hexString[SEL_OEM_NOTS_DATA_LEN+1]; /*Max Size*/ static char hexString[SEL_OEM_NOTS_DATA_LEN+1]; /*Max Size*/
if(numBytes > SEL_OEM_NOTS_DATA_LEN) if(numBytes > SEL_OEM_NOTS_DATA_LEN)
numBytes = SEL_OEM_NOTS_DATA_LEN; numBytes = SEL_OEM_NOTS_DATA_LEN;
@ -1470,7 +1470,7 @@ ipmi_sel_get_time(struct ipmi_intf * intf)
{ {
struct ipmi_rs * rsp; struct ipmi_rs * rsp;
struct ipmi_rq req; struct ipmi_rq req;
static uint8_t tbuf[40]; static char tbuf[40];
uint32_t timei; uint32_t timei;
time_t time; time_t time;

2
ipmitool/lib/ipmi_sol.c
View File

@ -1366,7 +1366,7 @@ ipmi_sol_red_pill(struct ipmi_intf * intf)
if (numRead > 0) if (numRead > 0)
{ {
int rc = processSolUserInput(intf, buffer, numRead); int rc = processSolUserInput(intf, (uint8_t *)buffer, numRead);
if (rc) if (rc)
{ {

8
ipmitool/lib/ipmi_user.c
View File

@ -326,7 +326,7 @@ ipmi_user_set_username(
/* The channel number will remain constant throughout this function */ /* The channel number will remain constant throughout this function */
msg_data[0] = user_id; msg_data[0] = user_id;
memset(msg_data + 1, 0, 16); memset(msg_data + 1, 0, 16);
strcpy(msg_data + 1, name); strcpy((char *)(msg_data + 1), name);
rsp = intf->sendrecv(intf, &req); rsp = intf->sendrecv(intf, &req);
@ -404,11 +404,11 @@ ipmi_user_set_password(
{ {
struct ipmi_rs * rsp; struct ipmi_rs * rsp;
struct ipmi_rq req; struct ipmi_rq req;
char * msg_data; uint8_t * msg_data;
int password_length = (is_twenty_byte_password? 20 : 16); int password_length = (is_twenty_byte_password? 20 : 16);
msg_data = (char*)malloc(password_length + 2); msg_data = (uint8_t*)malloc(password_length + 2);
memset(&req, 0, sizeof(req)); memset(&req, 0, sizeof(req));
@ -429,7 +429,7 @@ ipmi_user_set_password(
memset(msg_data + 2, 0, password_length); memset(msg_data + 2, 0, password_length);
if (password != NULL) if (password != NULL)
strncpy(msg_data + 2, password, password_length); strncpy((char *)(msg_data + 2), password, password_length);
rsp = intf->sendrecv(intf, &req); rsp = intf->sendrecv(intf, &req);

2
ipmitool/src/plugins/lan/auth.c
View File

@ -176,7 +176,7 @@ uint8_t * ipmi_auth_special(struct ipmi_session * s)
memset(&ctx, 0, sizeof(MD5_CTX)); memset(&ctx, 0, sizeof(MD5_CTX));
MD5_Init(&ctx); MD5_Init(&ctx);
MD5_Update(&ctx, (const uint8_t *)s->authcode, strlen(s->authcode)); MD5_Update(&ctx, (const uint8_t *)s->authcode, strlen((const char *)s->authcode));
MD5_Final(md, &ctx); MD5_Final(md, &ctx);
for (i=0; i<16; i++) for (i=0; i<16; i++)

6
ipmitool/src/plugins/lan/lan.c
View File

@ -1378,7 +1378,7 @@ int ipmi_lan_open(struct ipmi_intf * intf)
if (s->retry == 0) if (s->retry == 0)
s->retry = IPMI_LAN_RETRY; s->retry = IPMI_LAN_RETRY;
if (s->hostname == NULL || strlen(s->hostname) == 0) { if (s->hostname == NULL || strlen((const char *)s->hostname) == 0) {
lprintf(LOG_ERR, "No hostname specified!"); lprintf(LOG_ERR, "No hostname specified!");
return -1; return -1;
} }
@ -1390,9 +1390,9 @@ int ipmi_lan_open(struct ipmi_intf * intf)
s->addr.sin_family = AF_INET; s->addr.sin_family = AF_INET;
s->addr.sin_port = htons(s->port); s->addr.sin_port = htons(s->port);
rc = inet_pton(AF_INET, s->hostname, &s->addr.sin_addr); rc = inet_pton(AF_INET, (const char *)s->hostname, &s->addr.sin_addr);
if (rc <= 0) { if (rc <= 0) {
struct hostent *host = gethostbyname(s->hostname); struct hostent *host = gethostbyname((const char *)s->hostname);
if (host == NULL) { if (host == NULL) {
lprintf(LOG_ERR, "Address lookup for %s failed", lprintf(LOG_ERR, "Address lookup for %s failed",
s->hostname); s->hostname);

22
ipmitool/src/plugins/lanplus/lanplus.c
View File

@ -2876,7 +2876,7 @@ ipmi_lanplus_rakp1(struct ipmi_intf * intf)
/* Username specification */ /* Username specification */
msg[27] = strlen(session->username); msg[27] = strlen((const char *)session->username);
if (msg[27] > IPMI_MAX_USER_NAME_LENGTH) if (msg[27] > IPMI_MAX_USER_NAME_LENGTH)
{ {
lprintf(LOG_ERR, "ERROR: user name too long. " lprintf(LOG_ERR, "ERROR: user name too long. "
@ -3204,7 +3204,7 @@ ipmi_lanplus_open(struct ipmi_intf * intf)
if (!session->retry) if (!session->retry)
session->retry = IPMI_LAN_RETRY; session->retry = IPMI_LAN_RETRY;
if (session->hostname == NULL || strlen(session->hostname) == 0) { if (session->hostname == NULL || strlen((const char *)session->hostname) == 0) {
lprintf(LOG_ERR, "No hostname specified!"); lprintf(LOG_ERR, "No hostname specified!");
return -1; return -1;
} }
@ -3232,9 +3232,9 @@ ipmi_lanplus_open(struct ipmi_intf * intf)
addr.sin_family = AF_INET; addr.sin_family = AF_INET;
addr.sin_port = htons(session->port); addr.sin_port = htons(session->port);
rc = inet_pton(AF_INET, session->hostname, &addr.sin_addr); rc = inet_pton(AF_INET, (const char *)session->hostname, &addr.sin_addr);
if (rc <= 0) { if (rc <= 0) {
struct hostent *host = gethostbyname(session->hostname); struct hostent *host = gethostbyname((const char *)session->hostname);
if (host == NULL) { if (host == NULL) {
lprintf(LOG_ERR, "Address lookup for %s failed", lprintf(LOG_ERR, "Address lookup for %s failed",
session->hostname); session->hostname);
@ -3400,22 +3400,22 @@ void test_crypt2(void)
uint8_t iv[] = uint8_t iv[] =
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14}; 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14};
uint8_t * data = "12345678"; uint8_t data[8] = "12345678";
char encrypt_buffer[1000]; uint8_t encrypt_buffer[1000];
char decrypt_buffer[1000]; uint8_t decrypt_buffer[1000];
uint32_t bytes_encrypted; uint32_t bytes_encrypted;
uint32_t bytes_decrypted; uint32_t bytes_decrypted;
printbuf(data, strlen(data), "input data"); printbuf((const uint8_t *)data, strlen((const char *)data), "input data");
lanplus_encrypt_aes_cbc_128(iv, lanplus_encrypt_aes_cbc_128(iv,
key, key,
data, data,
strlen(data), strlen((const char *)data),
encrypt_buffer, encrypt_buffer,
&bytes_encrypted); &bytes_encrypted);
printbuf(encrypt_buffer, bytes_encrypted, "encrypt_buffer"); printbuf((const uint8_t *)encrypt_buffer, bytes_encrypted, "encrypt_buffer");
lanplus_decrypt_aes_cbc_128(iv, lanplus_decrypt_aes_cbc_128(iv,
key, key,
@ -3423,7 +3423,7 @@ void test_crypt2(void)
bytes_encrypted, bytes_encrypted,
decrypt_buffer, decrypt_buffer,
&bytes_decrypted); &bytes_decrypted);
printbuf(decrypt_buffer, bytes_decrypted, "decrypt_buffer"); printbuf((const uint8_t *)decrypt_buffer, bytes_decrypted, "decrypt_buffer");
lprintf(LOG_INFO, "\nDone testing the encrypt/decyrpt methods!\n"); lprintf(LOG_INFO, "\nDone testing the encrypt/decyrpt methods!\n");
exit(0); exit(0);

41
ipmitool/src/plugins/lanplus/lanplus_crypt.c
View File

@ -70,7 +70,7 @@ int lanplus_rakp2_hmac_matches(const struct ipmi_session * session,
const uint8_t * bmc_mac, const uint8_t * bmc_mac,
struct ipmi_intf * intf) struct ipmi_intf * intf)
{ {
char * buffer; uint8_t * buffer;
int bufferLength, i; int bufferLength, i;
uint8_t mac[20]; uint8_t mac[20];
uint32_t macLength; uint32_t macLength;
@ -93,7 +93,7 @@ int lanplus_rakp2_hmac_matches(const struct ipmi_session * session,
16 + /* GUIDc */ 16 + /* GUIDc */
1 + /* ROLEm */ 1 + /* ROLEm */
1 + /* ULENGTHm */ 1 + /* ULENGTHm */
strlen(session->username); /* optional */ strlen((const char *)session->username); /* optional */
buffer = malloc(bufferLength); buffer = malloc(bufferLength);
if (buffer == NULL) { if (buffer == NULL) {
@ -152,7 +152,7 @@ int lanplus_rakp2_hmac_matches(const struct ipmi_session * session,
buffer[56] = session->v2_data.requested_role; buffer[56] = session->v2_data.requested_role;
/* ULENGTHm */ /* ULENGTHm */
buffer[57] = strlen(session->username); buffer[57] = strlen((const char *)session->username);
/* UserName [optional] */ /* UserName [optional] */
for (i = 0; i < buffer[57]; ++i) for (i = 0; i < buffer[57]; ++i)
@ -160,8 +160,8 @@ int lanplus_rakp2_hmac_matches(const struct ipmi_session * session,
if (verbose > 2) if (verbose > 2)
{ {
printbuf(buffer, bufferLength, ">> rakp2 mac input buffer"); printbuf((const uint8_t *)buffer, bufferLength, ">> rakp2 mac input buffer");
printbuf((char*)(session->authcode), IPMI_AUTHCODE_BUFFER_SIZE, ">> rakp2 mac key"); printbuf((const uint8_t *)session->authcode, IPMI_AUTHCODE_BUFFER_SIZE, ">> rakp2 mac key");
} }
/* /*
@ -214,11 +214,10 @@ int lanplus_rakp4_hmac_matches(const struct ipmi_session * session,
const uint8_t * bmc_mac, const uint8_t * bmc_mac,
struct ipmi_intf * intf) struct ipmi_intf * intf)
{ {
char * buffer; uint8_t * buffer;
int bufferLength, i; int bufferLength, i;
uint8_t mac[20]; uint8_t mac[20];
uint32_t macLength; uint32_t macLength;
uint32_t SIDc_lsbf; uint32_t SIDc_lsbf;
if (ipmi_oem_active(intf, "intelplus")){ if (ipmi_oem_active(intf, "intelplus")){
@ -242,7 +241,7 @@ int lanplus_rakp4_hmac_matches(const struct ipmi_session * session,
4 + /* SIDc */ 4 + /* SIDc */
16; /* GUIDc */ 16; /* GUIDc */
buffer = (char*)malloc(bufferLength); buffer = (uint8_t *)malloc(bufferLength);
if (buffer == NULL) { if (buffer == NULL) {
lprintf(LOG_ERR, "ipmitool: malloc failure"); lprintf(LOG_ERR, "ipmitool: malloc failure");
return 1; return 1;
@ -283,7 +282,7 @@ int lanplus_rakp4_hmac_matches(const struct ipmi_session * session,
if (verbose > 2) if (verbose > 2)
{ {
printbuf(buffer, bufferLength, ">> rakp4 mac input buffer"); printbuf((const uint8_t *)buffer, bufferLength, ">> rakp4 mac input buffer");
printbuf(session->v2_data.sik, 20l, ">> rakp4 mac key (sik)"); printbuf(session->v2_data.sik, 20l, ">> rakp4 mac key (sik)");
} }
@ -339,14 +338,14 @@ int lanplus_rakp4_hmac_matches(const struct ipmi_session * session,
* returns 0 on success * returns 0 on success
* 1 on failure * 1 on failure
*/ */
int lanplus_generate_rakp3_authcode(char * output_buffer, int lanplus_generate_rakp3_authcode(uint8_t * output_buffer,
const struct ipmi_session * session, const struct ipmi_session * session,
uint32_t * mac_length, uint32_t * mac_length,
struct ipmi_intf * intf) struct ipmi_intf * intf)
{ {
int ret = 0; int ret = 0;
int input_buffer_length, i; int input_buffer_length, i;
char * input_buffer; uint8_t * input_buffer;
uint32_t SIDm_lsbf; uint32_t SIDm_lsbf;
@ -364,7 +363,7 @@ int lanplus_generate_rakp3_authcode(char * output_buffer,
4 + /* SIDm */ 4 + /* SIDm */
1 + /* ROLEm */ 1 + /* ROLEm */
1 + /* ULENGTHm */ 1 + /* ULENGTHm */
strlen(session->username); strlen((const char *)session->username);
input_buffer = malloc(input_buffer_length); input_buffer = malloc(input_buffer_length);
if (input_buffer == NULL) { if (input_buffer == NULL) {
@ -400,7 +399,7 @@ int lanplus_generate_rakp3_authcode(char * output_buffer,
input_buffer[20] = session->v2_data.requested_role; input_buffer[20] = session->v2_data.requested_role;
/* ULENGTHm */ /* ULENGTHm */
input_buffer[21] = strlen(session->username); input_buffer[21] = strlen((const char *)session->username);
/* USERNAME */ /* USERNAME */
for (i = 0; i < input_buffer[21]; ++i) for (i = 0; i < input_buffer[21]; ++i)
@ -408,8 +407,8 @@ int lanplus_generate_rakp3_authcode(char * output_buffer,
if (verbose > 2) if (verbose > 2)
{ {
printbuf(input_buffer, input_buffer_length, ">> rakp3 mac input buffer"); printbuf((const uint8_t *)input_buffer, input_buffer_length, ">> rakp3 mac input buffer");
printbuf((char*)(session->authcode), IPMI_AUTHCODE_BUFFER_SIZE, ">> rakp3 mac key"); printbuf((const uint8_t *)session->authcode, IPMI_AUTHCODE_BUFFER_SIZE, ">> rakp3 mac key");
} }
lanplus_HMAC(session->v2_data.auth_alg, lanplus_HMAC(session->v2_data.auth_alg,
@ -421,7 +420,7 @@ int lanplus_generate_rakp3_authcode(char * output_buffer,
mac_length); mac_length);
if (verbose > 2) if (verbose > 2)
printbuf(output_buffer, *mac_length, "generated rakp3 mac"); printbuf((const uint8_t *)output_buffer, *mac_length, "generated rakp3 mac");
free(input_buffer); free(input_buffer);
@ -459,9 +458,9 @@ int lanplus_generate_rakp3_authcode(char * output_buffer,
*/ */
int lanplus_generate_sik(struct ipmi_session * session) int lanplus_generate_sik(struct ipmi_session * session)
{ {
char * input_buffer; uint8_t * input_buffer;
int input_buffer_length, i; int input_buffer_length, i;
char * input_key; uint8_t * input_key;
uint32_t mac_length; uint32_t mac_length;
@ -478,7 +477,7 @@ int lanplus_generate_sik(struct ipmi_session * session)
16 + /* Rc */ 16 + /* Rc */
1 + /* ROLEm */ 1 + /* ROLEm */
1 + /* ULENGTHm */ 1 + /* ULENGTHm */
strlen(session->username); strlen((const char *)session->username);
input_buffer = malloc(input_buffer_length); input_buffer = malloc(input_buffer_length);
if (input_buffer == NULL) { if (input_buffer == NULL) {
@ -514,7 +513,7 @@ int lanplus_generate_sik(struct ipmi_session * session)
input_buffer[32] = session->v2_data.requested_role; input_buffer[32] = session->v2_data.requested_role;
/* ULENGTHm */ /* ULENGTHm */
input_buffer[33] = strlen(session->username); input_buffer[33] = strlen((const char *)session->username);
/* USERNAME */ /* USERNAME */
for (i = 0; i < input_buffer[33]; ++i) for (i = 0; i < input_buffer[33]; ++i)
@ -538,7 +537,7 @@ int lanplus_generate_sik(struct ipmi_session * session)
if (verbose >= 2) if (verbose >= 2)
printbuf(input_buffer, input_buffer_length, "session integrity key input"); printbuf((const uint8_t *)input_buffer, input_buffer_length, "session integrity key input");
lanplus_HMAC(session->v2_data.auth_alg, lanplus_HMAC(session->v2_data.auth_alg,
input_key, input_key,

2
ipmitool/src/plugins/lanplus/lanplus_crypt.h
View File

@ -47,7 +47,7 @@ int lanplus_rakp2_hmac_matches(const struct ipmi_session * session,
int lanplus_rakp4_hmac_matches(const struct ipmi_session * session, int lanplus_rakp4_hmac_matches(const struct ipmi_session * session,
const uint8_t * hmac, const uint8_t * hmac,
struct ipmi_intf * intf); struct ipmi_intf * intf);
int lanplus_generate_rakp3_authcode(char * buffer, int lanplus_generate_rakp3_authcode(uint8_t * buffer,
const struct ipmi_session * session, const struct ipmi_session * session,
uint32_t * auth_length, uint32_t * auth_length,
struct ipmi_intf * intf); struct ipmi_intf * intf);

8
ipmitool/src/plugins/lanplus/lanplus_crypt_impl.c
View File

@ -183,7 +183,7 @@ lanplus_encrypt_aes_cbc_128(const uint8_t * iv,
assert((input_length % IPMI_CRYPT_AES_CBC_128_BLOCK_SIZE) == 0); assert((input_length % IPMI_CRYPT_AES_CBC_128_BLOCK_SIZE) == 0);
if(!EVP_EncryptUpdate(&ctx, output, (unsigned int *)bytes_written, input, input_length)) if(!EVP_EncryptUpdate(&ctx, output, (int *)bytes_written, input, input_length))
{ {
/* Error */ /* Error */
*bytes_written = 0; *bytes_written = 0;
@ -193,7 +193,7 @@ lanplus_encrypt_aes_cbc_128(const uint8_t * iv,
{ {
uint32_t tmplen; uint32_t tmplen;
if(!EVP_EncryptFinal_ex(&ctx, output + *bytes_written, (unsigned int *)&tmplen)) if(!EVP_EncryptFinal_ex(&ctx, output + *bytes_written, (int *)&tmplen))
{ {
*bytes_written = 0; *bytes_written = 0;
return; /* Error */ return; /* Error */
@ -259,7 +259,7 @@ lanplus_decrypt_aes_cbc_128(const uint8_t * iv,
assert((input_length % IPMI_CRYPT_AES_CBC_128_BLOCK_SIZE) == 0); assert((input_length % IPMI_CRYPT_AES_CBC_128_BLOCK_SIZE) == 0);
if (!EVP_DecryptUpdate(&ctx, output, (unsigned int *)bytes_written, input, input_length)) if (!EVP_DecryptUpdate(&ctx, output, (int *)bytes_written, input, input_length))
{ {
/* Error */ /* Error */
fprintf(stderr, "ERROR: decrypt update failed"); fprintf(stderr, "ERROR: decrypt update failed");
@ -270,7 +270,7 @@ lanplus_decrypt_aes_cbc_128(const uint8_t * iv,
{ {
uint32_t tmplen; uint32_t tmplen;
if (!EVP_DecryptFinal_ex(&ctx, output + *bytes_written, (unsigned int *)&tmplen)) if (!EVP_DecryptFinal_ex(&ctx, output + *bytes_written, (int *)&tmplen))
{ {
char buffer[1000]; char buffer[1000];
ERR_error_string(ERR_get_error(), buffer); ERR_error_string(ERR_get_error(), buffer);

19
ipmitool/src/plugins/open/open.c
View File

@ -105,12 +105,11 @@ ipmi_openipmi_open(struct ipmi_intf * intf)
#ifdef INCLUDE_PICMG_GET_DEVICE_LOCATOR #ifdef INCLUDE_PICMG_GET_DEVICE_LOCATOR
/* PICMG hack to set right IPMB address, /* PICMG hack to set right IPMB address,
we might want to do GetPICMGProperties first. * we might want to do GetPICMGProperties first.
* In any case, on a server board or a non-picmg IpmC blade , this code
In any case, on a server board or a non-picmg IpmC blade , this code * will not have any adverse side effect
will not have any adverse side effect
*/ */
if ( (intf->my_addr == IPMI_BMC_SLAVE_ADDR) ) { if (intf->my_addr == IPMI_BMC_SLAVE_ADDR) {
lprintf(LOG_DEBUG, "Running PICMG GetDeviceLocator" ); lprintf(LOG_DEBUG, "Running PICMG GetDeviceLocator" );
memset(&req, 0, sizeof(req)); memset(&req, 0, sizeof(req));
req.msg.netfn = IPMI_NETFN_PICMG; req.msg.netfn = IPMI_NETFN_PICMG;
@ -121,14 +120,12 @@ ipmi_openipmi_open(struct ipmi_intf * intf)
msg_data = 0; msg_data = 0;
rsp = intf->sendrecv(intf, &req); rsp = intf->sendrecv(intf, &req);
if (rsp) { if (rsp && !rsp->ccode) {
if ( !rsp->ccode ) {
intf->my_addr = rsp->data[2]; intf->my_addr = rsp->data[2];
intf->target_addr = intf->my_addr; intf->target_addr = intf->my_addr;
lprintf(LOG_DEBUG, "Discovered IPMB address = 0x%x", intf->my_addr); lprintf(LOG_DEBUG, "Discovered IPMB address = 0x%x", intf->my_addr);
} }
} }
}
#endif #endif
return intf->fd; return intf->fd;
@ -183,7 +180,7 @@ ipmi_openipmi_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
intf->target_addr != intf->my_addr) { intf->target_addr != intf->my_addr) {
/* use IPMB address if needed */ /* use IPMB address if needed */
ipmb_addr.slave_addr = intf->target_addr; ipmb_addr.slave_addr = intf->target_addr;
_req.addr = (char *) &ipmb_addr; _req.addr = (unsigned char *) &ipmb_addr;
_req.addr_len = sizeof(ipmb_addr); _req.addr_len = sizeof(ipmb_addr);
lprintf(LOG_DEBUG, "Sending request to " lprintf(LOG_DEBUG, "Sending request to "
"IPMB target @ 0x%x", intf->target_addr); "IPMB target @ 0x%x", intf->target_addr);
@ -192,7 +189,7 @@ ipmi_openipmi_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
lprintf(LOG_DEBUG+2, "Sending request to " lprintf(LOG_DEBUG+2, "Sending request to "
"System Interface"); "System Interface");
bmc_addr.lun = req->msg.lun; bmc_addr.lun = req->msg.lun;
_req.addr = (char *) &bmc_addr; _req.addr = (unsigned char *) &bmc_addr;
_req.addr_len = sizeof(bmc_addr); _req.addr_len = sizeof(bmc_addr);
} }
@ -226,7 +223,7 @@ ipmi_openipmi_send_cmd(struct ipmi_intf * intf, struct ipmi_rq * req)
return NULL; return NULL;
} }
recv.addr = (char *) &addr; recv.addr = (unsigned char *) &addr;
recv.addr_len = sizeof(addr); recv.addr_len = sizeof(addr);
recv.msg.data = rsp.data; recv.msg.data = rsp.data;
recv.msg.data_len = sizeof(rsp.data); recv.msg.data_len = sizeof(rsp.data);