// In MRI, this only sets properties on sockets, which requires
// tracking all fd's that are sockets...
int fcntl(int fd, int cmd, ...) {
if(cmd != F_SETFL) {
errno = EINVAL;
return -1;
}
va_list va;
va_start(va, cmd);
int arg = va_arg(va, int);
va_end(va);
unsigned long ioctl_arg;
if(arg & O_NONBLOCK) {
ioctl_arg = 1;
}
else {
ioctl_arg = 0;
}
int ret = ioctlsocket(fd, FIONBIO, &ioctl_arg);
if(ret) errno = map_errno(WSAGetLastError());
return ret;
}
static fru_errno_t
frt_get_seg_list(fru_treehdl_t handle, fru_strlist_t *list)
{
fru_strlist_t rc_list;
fru_errno_t err = FRU_SUCCESS;
int acc_err = 0;
int i = 0;
int num_section = 0;
section_t *sects = NULL;
container_hdl_t cont;
cont = treehdl_to_conthdl(handle);
num_section = fru_get_num_sections(cont, NULL);
if (num_section == -1) {
return (map_errno(errno));
}
sects = malloc(sizeof (*sects) * (num_section));
if (sects == NULL) {
return (FRU_FAILURE);
}
acc_err = fru_get_sections(cont, sects, num_section, NULL);
if (acc_err == -1) {
free(sects);
return (map_errno(errno));
}
rc_list.num = 0;
rc_list.strs = NULL;
for (i = 0; i < num_section; i++) {
if ((err = add_segs_for_section(&(sects[i]), &rc_list))
!= FRU_SUCCESS) {
fru_destroy_strlist(&rc_list);
free(sects);
return (err);
}
}
list->strs = rc_list.strs;
list->num = rc_list.num;
return (FRU_SUCCESS);
}
static fru_errno_t
add_segs_for_section(section_t *section, fru_strlist_t *list)
{
int i = 0;
segment_t *segs = NULL;
int acc_err = 0;
int num_segment = fru_get_num_segments(section->handle, NULL);
if (num_segment == -1) {
return (map_errno(errno));
} else if (num_segment == 0) {
return (FRU_SUCCESS);
}
segs = malloc(sizeof (*segs) * (num_segment));
if (segs == NULL) {
return (FRU_FAILURE);
}
acc_err = fru_get_segments(section->handle, segs, num_segment, NULL);
if (acc_err == -1) {
free(segs);
return (map_errno(errno));
}
list->strs = realloc(list->strs, sizeof (char *)
* (list->num + num_segment));
for (i = 0; i < num_segment; i++) {
/* ensure NULL terminated. */
char *tmp = malloc(sizeof (*tmp) * (sizeof (segs[i].name)+1));
if (tmp == NULL) {
free(segs);
return (FRU_FAILURE);
}
(void) memcpy(tmp, segs[i].name, sizeof (segs[i].name));
tmp[sizeof (segs[i].name)] = '\0';
list->strs[(list->num)++] = tmp;
}
free(segs);
return (FRU_SUCCESS);
}
static fru_errno_t
find_segment(fru_treehdl_t handle, const char *seg_name, int *prot_flg,
segment_t *segment)
{
int i = 0;
int acc_err = 0;
section_t *sect = NULL;
container_hdl_t cont;
int num_sect;
cont = treehdl_to_conthdl(handle);
num_sect = fru_get_num_sections(cont, NULL);
if (num_sect == -1) {
return (map_errno(errno));
}
sect = malloc(sizeof (*sect) * (num_sect));
if (sect == NULL) {
return (FRU_FAILURE);
}
acc_err = fru_get_sections(cont, sect, num_sect, NULL);
if (acc_err == -1) {
free(sect);
return (map_errno(errno));
}
for (i = 0; i < num_sect; i++) {
if (find_seg_in_sect(&(sect[i]), seg_name, prot_flg, segment)
== FRU_SUCCESS) {
free(sect);
return (FRU_SUCCESS);
}
}
free(sect);
return (FRU_INVALSEG);
}
static fru_errno_t
find_seg_in_sect(section_t *sect, const char *seg_name, int *prot_flg,
segment_t *segment)
{
int j = 0;
int acc_err = 0;
segment_t *segs = NULL;
int num_seg = fru_get_num_segments(sect->handle, NULL);
if (num_seg == -1) {
return (FRU_FAILURE);
}
segs = malloc(sizeof (*segs) * (num_seg));
if (segs == NULL) {
return (FRU_FAILURE);
}
acc_err = fru_get_segments(sect->handle, segs, num_seg, NULL);
if (acc_err == -1) {
free(segs);
return (map_errno(errno));
}
for (j = 0; j < num_seg; j++) {
/* NULL terminate */
char tmp[SEG_NAME_LEN+1];
(void) memcpy(tmp, segs[j].name, SEG_NAME_LEN);
tmp[SEG_NAME_LEN] = '\0';
if (strcmp(tmp, seg_name) == 0) {
*segment = segs[j];
*prot_flg = (sect->protection ? 1 : 0);
free(segs);
return (FRU_SUCCESS);
}
}
free(segs);
return (FRU_INVALSEG);
}
static fru_errno_t
frt_for_each_packet(fru_seghdl_t node,
int (*function)(fru_tag_t *tag, uint8_t *payload, size_t length,
void *args), void *args)
{
int rc_num;
int status;
char *rc_tags;
char *rc_data;
int i;
packet_t *packets = NULL;
segment_list_t *tmp_list;
fru_segdesc_t *descriptor;
tmp_list = g_raw->segs;
/* num of packet */
rc_num = fru_get_num_packets(node, NULL);
if (rc_num == -1) {
return (map_errno(errno));
} else if (rc_num == 0) {
return (FRU_SUCCESS);
}
while (tmp_list) {
if (node == tmp_list->segment->handle) {
break;
}
tmp_list = tmp_list->next;
}
if (tmp_list) {
descriptor = (fru_segdesc_t *)&tmp_list->segment->descriptor;
if (descriptor->field.opaque) {
return (FRU_SUCCESS);
}
if (descriptor->field.encrypted && (encrypt_func == NULL)) {
return (FRU_SUCCESS);
}
}
packets = malloc(sizeof (*packets) * (rc_num));
if (packets == NULL) {
return (FRU_FAILURE);
}
/* get all packets */
if (fru_get_packets(node, packets, rc_num, NULL) == -1) {
free(packets);
return (map_errno(errno));
}
rc_tags = malloc(sizeof (*rc_tags) * (rc_num));
if (rc_tags == NULL) {
free(packets);
return (FRU_FAILURE);
}
/* number of tags */
for (i = 0; i < rc_num; i++) {
size_t rc_len =
get_payload_length((fru_tag_t *)&packets[i].tag);
rc_data = malloc(sizeof (*rc_data) * (rc_len));
if (rc_data == NULL) {
free(packets);
return (FRU_FAILURE);
}
/* get the payload data */
(void) fru_get_payload(packets[i].handle, (void *)rc_data,
rc_len, NULL);
if (tmp_list) {
descriptor =
(fru_segdesc_t *)&tmp_list->segment->descriptor;
if ((descriptor->field.encrypted) &&
((status = encrypt_func(FRU_DECRYPT,
(void *)rc_data, rc_len))
!= FRU_SUCCESS)) {
return (status);
}
}
/* print packet */
if ((status = function((fru_tag_t *)&packets[i].tag,
(uint8_t *)rc_data, rc_len, args)) != FRU_SUCCESS) {
free(rc_data);
free(packets);
return (status);
}
free(rc_data);
}
return (FRU_SUCCESS);
}
static fru_errno_t
frt_get_segment_name(fru_seghdl_t node, char **name)
{
int num_sect;
int acc_err;
int cnt;
int num_segment;
section_t *sects;
segment_t *segs;
int each_seg;
container_hdl_t cont;
cont = treehdl_to_conthdl(node);
num_sect = fru_get_num_sections(cont, NULL);
if (num_sect == -1) {
return (map_errno(errno));
}
sects = malloc(sizeof (*sects) * (num_sect));
if (sects == NULL) {
return (FRU_FAILURE);
}
acc_err = fru_get_sections(cont, sects, num_sect, NULL);
if (acc_err == -1) {
free(sects);
return (map_errno(errno));
}
for (cnt = 0; cnt < num_sect; cnt++) {
num_segment = fru_get_num_segments(sects[cnt].handle, NULL);
if (num_segment == -1) {
free(sects);
return (map_errno(errno));
} else if (num_segment == 0) {
continue;
}
segs = malloc(sizeof (*segs) * (num_segment));
if (segs == NULL) {
free(sects);
return (FRU_FAILURE);
}
acc_err = fru_get_segments(sects[cnt].handle, segs,
num_segment, NULL);
if (acc_err == -1) {
free(sects);
free(segs);
return (map_errno(errno));
}
for (each_seg = 0; each_seg < num_segment; each_seg++) {
if (segs[each_seg].handle == node) {
segs[each_seg].name[FRU_SEGNAMELEN] = '\0';
*name = strdup(segs[each_seg].name);
free(sects);
free(segs);
return (FRU_SUCCESS);
}
}
free(segs);
}
return (FRU_FAILURE);
}
/* ARGSUSED */
static fru_errno_t
frt_for_each_segment(fru_nodehdl_t node,
int (*function)(fru_seghdl_t hdl, void *args), void *args)
{
int num_segment;
int cnt;
int num_sect;
int each_seg;
section_t *sects;
segment_t *segs;
segment_list_t *tmp_list;
int acc_err;
int status;
container_hdl_t cont;
cont = g_raw->cont;
num_sect = fru_get_num_sections(cont, NULL);
if (num_sect == -1) {
return (map_errno(errno));
}
sects = malloc((num_sect + 1) * sizeof (section_t));
if (sects == NULL) {
return (FRU_FAILURE);
}
num_sect = fru_get_sections(cont, sects, num_sect, NULL);
if (num_sect == -1) {
free(sects);
return (map_errno(errno));
}
for (cnt = 0; cnt < num_sect; cnt++) {
num_segment = fru_get_num_segments(sects[cnt].handle, NULL);
if (num_segment == -1) {
return (map_errno(errno));
} else if (num_segment == 0) {
continue;
}
segs = malloc((num_segment + 1) * sizeof (segment_t));
if (segs == NULL) {
free(sects);
return (FRU_FAILURE);
}
acc_err = fru_get_segments(sects[cnt].handle, segs,
num_segment, NULL);
if (acc_err == -1) {
free(sects);
free(segs);
return (map_errno(errno));
}
for (each_seg = 0; each_seg < num_segment; each_seg++) {
tmp_list = malloc(sizeof (segment_list_t));
tmp_list->segment = &segs[each_seg];
tmp_list->next = NULL;
if (g_raw->segs == NULL) {
g_raw->segs = tmp_list;
} else {
tmp_list->next = g_raw->segs;
g_raw->segs = tmp_list;
}
if ((status = function(segs[each_seg].handle, args))
!= FRU_SUCCESS) {
free(segs);
free(sects);
return (status);
}
}
free(segs);
free(sects);
}
return (FRU_SUCCESS);
}
