usr/src/lib/libfru/libfruraw/fruraw.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #include <stdio.h>
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <string.h>
  31
  32 #include "fru_access_impl.h"
  33
  34 #include "libfruds.h"
  35 #include "libfrup.h"
  36 #include "fru_access.h"
  37 #include "fruraw.h"
  38
  39
  40 raw_list_t *g_raw = NULL;
  41
  42
  43 /* ARGSUSED */
  44 static raw_list_t *
  45 treehdl_to_rawlist(fru_treehdl_t handle)
  46 {
  47         return (g_raw);
  48 }
  49
  50
  51 static container_hdl_t
  52 treehdl_to_conthdl(fru_treehdl_t handle)
  53 {
  54         raw_list_t *ptr;
  55
  56         ptr = treehdl_to_rawlist(handle);
  57         if (ptr == NULL) {
  58                 return (-1);
  59         }
  60
  61         return (ptr->cont);
  62 }
  63
  64
  65 static fru_errno_t
  66 map_errno(int err)
  67 {
  68         switch (err) {
  69         case ENFILE:
  70         case EEXIST:
  71                 return (FRU_DUPSEG);
  72         case EAGAIN:
  73                 return (FRU_NOSPACE);
  74         case EPERM:
  75                 return (FRU_INVALPERM);
  76         default :
  77                 return (FRU_IOERROR);
  78         }
  79 }
  80
  81
  82 static raw_list_t *
  83 make_raw(uint8_t *buffer, size_t size, char *cont_type)
  84 {
  85         raw_list_t *node;
  86
  87         node = (raw_list_t *)malloc(sizeof (raw_list_t));
  88         if (node == NULL) {
  89                 return (NULL);
  90         }
  91
  92         node->hdl = 0;
  93         node->raw = buffer;
  94         node->size = size;
  95         node->cont_type = strdup(cont_type);
  96         if (node->cont_type == NULL) {
  97                 free(node);
  98                 return (NULL);
  99         }
 100         node->segs = NULL;
 101
 102         return (node);
 103 }
 104
 105
 106 /*
 107  * Arguments :
 108  * 0 - pointer to byte buffer (in)
 109  * 1 - size of buffer (in)
 110  * 2 - container type, string (in)
 111  */
 112 static fru_errno_t
 113 frt_initialize(int num, char **args)
 114 {
 115
 116
 117         if (num != 3) {
 118                 return (FRU_FAILURE);
 119         }
 120
 121         g_raw = make_raw((uint8_t *)args[0], (size_t)args[1], args[2]);
 122         if (g_raw == NULL) {
 123                 return (FRU_FAILURE);
 124         }
 125
 126         g_raw->cont = open_raw_data(g_raw);
 127         if (g_raw->cont == NULL) {
 128                 return (FRU_FAILURE);
 129         }
 130
 131         return (FRU_SUCCESS);
 132 }
 133
 134
 135 static fru_errno_t
 136 frt_shutdown(void)
 137 {
 138         segment_list_t *lptr, *lptr2;
 139
 140         (void) fru_close_container(g_raw->cont);
 141         free(g_raw->cont_type);
 142         lptr = g_raw->segs;
 143         while (lptr) {
 144                 lptr2 = lptr;
 145                 lptr = lptr->next;
 146                 free(lptr2);
 147         }
 148         g_raw = NULL;
 149
 150         return (FRU_SUCCESS);
 151 }
 152
 153
 154 static fru_errno_t
 155 frt_get_root(fru_treehdl_t *node)
 156 {
 157         *node = g_raw->hdl;
 158
 159         return (FRU_SUCCESS);
 160 }
 161
 162 /* ARGSUSED */
 163 static fru_errno_t
 164 frt_get_peer(fru_treehdl_t sibling, fru_treehdl_t *peer)
 165 {
 166         return (FRU_NODENOTFOUND);
 167 }
 168 /* ARGSUSED */
 169 static fru_errno_t
 170 frt_get_child(fru_treehdl_t handle, fru_treehdl_t *child)
 171 {
 172         return (FRU_NODENOTFOUND);
 173 }
 174
 175 /* ARGSUSED */
 176 static fru_errno_t
 177 frt_get_parent(fru_treehdl_t handle, fru_treehdl_t *parent)
 178 {
 179         return (FRU_NODENOTFOUND);
 180 }
 181
 182 /* ARGSUSED */
 183 static fru_errno_t
 184 frt_get_name_from_hdl(fru_treehdl_t handle, char **name)
 185 {
 186         *name = strdup("unknown");
 187         return (FRU_SUCCESS);
 188 }
 189
 190 /* ARGSUSED */
 191 static fru_errno_t
 192 frt_get_node_type(fru_treehdl_t node, fru_node_t *type)
 193 {
 194         *type = FRU_NODE_CONTAINER;
 195         return (FRU_SUCCESS);
 196 }
 197
 198
 199
 200 static fru_errno_t
 201 add_segs_for_section(section_t *section, fru_strlist_t *list)
 202 {
 203         int i = 0;
 204         segment_t *segs = NULL;
 205         int acc_err = 0;
 206
 207         int num_segment = fru_get_num_segments(section->handle, NULL);
 208         if (num_segment == -1) {
 209                 return (map_errno(errno));
 210         } else if (num_segment == 0) {
 211                 return (FRU_SUCCESS);
 212         }
 213
 214         segs = malloc(sizeof (*segs) * (num_segment));
 215         if (segs == NULL) {
 216                 return (FRU_FAILURE);
 217         }
 218
 219         acc_err = fru_get_segments(section->handle, segs, num_segment, NULL);
 220         if (acc_err == -1) {
 221                 free(segs);
 222                 return (map_errno(errno));
 223         }
 224
 225         list->strs = realloc(list->strs, sizeof (char *)
 226             * (list->num + num_segment));
 227
 228         for (i = 0; i < num_segment; i++) {
 229                 /* ensure NULL terminated. */
 230                 char *tmp = malloc(sizeof (*tmp) * (sizeof (segs[i].name)+1));
 231                 if (tmp == NULL) {
 232                         free(segs);
 233                         return (FRU_FAILURE);
 234                 }
 235                 (void) memcpy(tmp, segs[i].name, sizeof (segs[i].name));
 236                 tmp[sizeof (segs[i].name)] = '\0';
 237
 238                 list->strs[(list->num)++] = tmp;
 239         }
 240
 241         free(segs);
 242
 243         return (FRU_SUCCESS);
 244 }
 245
 246
 247
 248 static fru_errno_t
 249 frt_get_seg_list(fru_treehdl_t handle, fru_strlist_t *list)
 250 {
 251         fru_strlist_t rc_list;
 252         fru_errno_t err = FRU_SUCCESS;
 253         int acc_err = 0;
 254         int i = 0;
 255         int num_section = 0;
 256         section_t *sects = NULL;
 257         container_hdl_t cont;
 258
 259         cont = treehdl_to_conthdl(handle);
 260
 261         num_section = fru_get_num_sections(cont, NULL);
 262         if (num_section == -1) {
 263                 return (map_errno(errno));
 264         }
 265
 266         sects = malloc(sizeof (*sects) * (num_section));
 267         if (sects == NULL) {
 268                 return (FRU_FAILURE);
 269         }
 270
 271         acc_err = fru_get_sections(cont, sects, num_section, NULL);
 272         if (acc_err == -1) {
 273                 free(sects);
 274                 return (map_errno(errno));
 275         }
 276
 277         rc_list.num = 0;
 278         rc_list.strs = NULL;
 279         for (i = 0; i < num_section; i++) {
 280                 if ((err = add_segs_for_section(&(sects[i]), &rc_list))
 281                     != FRU_SUCCESS) {
 282                         fru_destroy_strlist(&rc_list);
 283                         free(sects);
 284                         return (err);
 285                 }
 286         }
 287
 288         list->strs = rc_list.strs;
 289         list->num = rc_list.num;
 290
 291         return (FRU_SUCCESS);
 292 }
 293
 294
 295 static fru_errno_t
 296 find_seg_in_sect(section_t *sect, const char *seg_name, int *prot_flg,
 297     segment_t *segment)
 298 {
 299         int j = 0;
 300         int acc_err = 0;
 301         segment_t *segs = NULL;
 302
 303         int num_seg = fru_get_num_segments(sect->handle, NULL);
 304         if (num_seg == -1) {
 305                 return (FRU_FAILURE);
 306         }
 307
 308         segs = malloc(sizeof (*segs) * (num_seg));
 309         if (segs == NULL) {
 310                 return (FRU_FAILURE);
 311         }
 312
 313         acc_err = fru_get_segments(sect->handle, segs, num_seg, NULL);
 314         if (acc_err == -1) {
 315                 free(segs);
 316                 return (map_errno(errno));
 317         }
 318
 319         for (j = 0; j < num_seg; j++) {
 320                 /* NULL terminate */
 321                 char tmp[SEG_NAME_LEN+1];
 322                 (void) memcpy(tmp, segs[j].name, SEG_NAME_LEN);
 323                 tmp[SEG_NAME_LEN] = '\0';
 324                 if (strcmp(tmp, seg_name) == 0) {
 325                         *segment = segs[j];
 326                         *prot_flg = (sect->protection ? 1 : 0);
 327                         free(segs);
 328                         return (FRU_SUCCESS);
 329                 }
 330         }
 331
 332         free(segs);
 333         return (FRU_INVALSEG);
 334 }
 335
 336
 337 static fru_errno_t
 338 find_segment(fru_treehdl_t handle, const char *seg_name, int *prot_flg,
 339     segment_t *segment)
 340 {
 341         int i = 0;
 342         int acc_err = 0;
 343         section_t *sect = NULL;
 344         container_hdl_t cont;
 345         int num_sect;
 346
 347         cont = treehdl_to_conthdl(handle);
 348
 349         num_sect = fru_get_num_sections(cont, NULL);
 350         if (num_sect == -1) {
 351                 return (map_errno(errno));
 352         }
 353
 354         sect = malloc(sizeof (*sect) * (num_sect));
 355         if (sect == NULL) {
 356                 return (FRU_FAILURE);
 357         }
 358
 359         acc_err = fru_get_sections(cont, sect, num_sect, NULL);
 360         if (acc_err == -1) {
 361                 free(sect);
 362                 return (map_errno(errno));
 363         }
 364
 365         for (i = 0; i < num_sect; i++) {
 366                 if (find_seg_in_sect(&(sect[i]), seg_name, prot_flg, segment)
 367                     == FRU_SUCCESS) {
 368                         free(sect);
 369                         return (FRU_SUCCESS);
 370                 }
 371         }
 372
 373         free(sect);
 374         return (FRU_INVALSEG);
 375 }
 376
 377
 378 static fru_errno_t
 379 frt_get_seg_def(fru_treehdl_t handle, const char *seg_name, fru_segdef_t *def)
 380 {
 381         fru_errno_t err = FRU_SUCCESS;
 382         int prot_flg = 0;
 383         segment_t segment;
 384
 385         if ((err = find_segment(handle, seg_name, &prot_flg, &segment))
 386             != FRU_SUCCESS) {
 387                 return (err);
 388         }
 389
 390         (void) memcpy(def->name, segment.name, SEG_NAME_LEN);
 391         def->name[SEG_NAME_LEN] = '\0';
 392         def->desc.raw_data = segment.descriptor;
 393         def->size = segment.length;
 394         def->address = segment.offset;
 395
 396         if (prot_flg == 0)
 397                 def->hw_desc.field.read_only = 0;
 398         else
 399                 def->hw_desc.field.read_only = 1;
 400
 401         return (FRU_SUCCESS);
 402
 403 }
 404
 405 /* ARGSUSED */
 406 static fru_errno_t
 407 frt_add_seg(fru_treehdl_t handle, fru_segdef_t *def)
 408 {
 409         /* NOT SUPPORTED */
 410         return (FRU_NOTSUP);
 411 }
 412
 413 /* ARGSUSED */
 414 static fru_errno_t
 415 frt_delete_seg(fru_treehdl_t handle, const char *seg_name)
 416 {
 417         /* NOT SUPPORTED */
 418         return (FRU_NOTSUP);
 419 }
 420
 421 /* ARGSUSED */
 422 static fru_errno_t
 423 frt_for_each_segment(fru_nodehdl_t node,
 424     int (*function)(fru_seghdl_t hdl, void *args), void *args)
 425 {
 426         int num_segment;
 427         int cnt;
 428         int num_sect;
 429         int each_seg;
 430         section_t *sects;
 431         segment_t *segs;
 432         segment_list_t *tmp_list;
 433         int acc_err;
 434         int status;
 435         container_hdl_t cont;
 436
 437         cont = g_raw->cont;
 438
 439         num_sect = fru_get_num_sections(cont, NULL);
 440         if (num_sect == -1) {
 441                 return (map_errno(errno));
 442         }
 443
 444         sects = malloc((num_sect + 1) * sizeof (section_t));
 445         if (sects == NULL) {
 446                 return (FRU_FAILURE);
 447         }
 448         num_sect = fru_get_sections(cont, sects, num_sect, NULL);
 449         if (num_sect == -1) {
 450                 free(sects);
 451                 return (map_errno(errno));
 452         }
 453         for (cnt = 0; cnt < num_sect; cnt++) {
 454                 num_segment = fru_get_num_segments(sects[cnt].handle, NULL);
 455                 if (num_segment == -1) {
 456                         return (map_errno(errno));
 457                 } else if (num_segment == 0) {
 458                         continue;
 459                 }
 460                 segs = malloc((num_segment + 1) * sizeof (segment_t));
 461                 if (segs == NULL) {
 462                         free(sects);
 463                         return (FRU_FAILURE);
 464                 }
 465                 acc_err = fru_get_segments(sects[cnt].handle, segs,
 466                     num_segment, NULL);
 467                 if (acc_err == -1) {
 468                         free(sects);
 469                         free(segs);
 470                         return (map_errno(errno));
 471                 }
 472                 for (each_seg = 0; each_seg < num_segment; each_seg++) {
 473                         tmp_list = malloc(sizeof (segment_list_t));
 474                         tmp_list->segment = &segs[each_seg];
 475                         tmp_list->next = NULL;
 476                         if (g_raw->segs == NULL) {
 477                                 g_raw->segs = tmp_list;
 478                         } else {
 479                                 tmp_list->next = g_raw->segs;
 480                                 g_raw->segs = tmp_list;
 481                         }
 482
 483                         if ((status = function(segs[each_seg].handle, args))
 484                             != FRU_SUCCESS) {
 485                                 free(segs);
 486                                 free(sects);
 487                                 return (status);
 488                         }
 489                 }
 490                 free(segs);
 491                 free(sects);
 492
 493         }
 494         return (FRU_SUCCESS);
 495 }
 496
 497
 498 static fru_errno_t
 499 frt_get_segment_name(fru_seghdl_t node, char **name)
 500 {
 501         int num_sect;
 502         int acc_err;
 503         int cnt;
 504         int num_segment;
 505         section_t *sects;
 506         segment_t *segs;
 507         int each_seg;
 508         container_hdl_t cont;
 509
 510         cont = treehdl_to_conthdl(node);
 511
 512         num_sect = fru_get_num_sections(cont, NULL);
 513         if (num_sect == -1) {
 514                 return (map_errno(errno));
 515         }
 516
 517         sects = malloc(sizeof (*sects) * (num_sect));
 518         if (sects == NULL) {
 519                 return (FRU_FAILURE);
 520         }
 521         acc_err = fru_get_sections(cont, sects, num_sect, NULL);
 522         if (acc_err == -1) {
 523                 free(sects);
 524                 return (map_errno(errno));
 525         }
 526
 527         for (cnt = 0; cnt < num_sect; cnt++) {
 528                 num_segment = fru_get_num_segments(sects[cnt].handle, NULL);
 529                 if (num_segment == -1) {
 530                         free(sects);
 531                         return (map_errno(errno));
 532                 } else if (num_segment == 0) {
 533                         continue;
 534                 }
 535
 536                 segs = malloc(sizeof (*segs) * (num_segment));
 537                 if (segs == NULL) {
 538                         free(sects);
 539                         return (FRU_FAILURE);
 540                 }
 541
 542                 acc_err = fru_get_segments(sects[cnt].handle, segs,
 543                     num_segment, NULL);
 544                 if (acc_err == -1) {
 545                         free(sects);
 546                         free(segs);
 547                         return (map_errno(errno));
 548                 }
 549
 550                 for (each_seg = 0; each_seg < num_segment; each_seg++) {
 551                         if (segs[each_seg].handle == node) {
 552                                 segs[each_seg].name[FRU_SEGNAMELEN] = '\0';
 553                                 *name = strdup(segs[each_seg].name);
 554                                 free(sects);
 555                                 free(segs);
 556                                 return (FRU_SUCCESS);
 557                         }
 558                 }
 559                 free(segs);
 560         }
 561
 562         return (FRU_FAILURE);
 563 }
 564
 565
 566 /* ARGSUSED */
 567 static fru_errno_t
 568 frt_add_tag_to_seg(fru_treehdl_t handle, const char *seg_name,
 569     fru_tag_t tag, uint8_t *data, size_t data_len)
 570 {
 571         /* NOT SUPPORTED */
 572         return (FRU_NOTSUP);
 573 }
 574
 575
 576 /* ARGSUSED */
 577 static fru_errno_t
 578 frt_get_tag_list(fru_treehdl_t handle, const char *seg_name,
 579     fru_tag_t **tags, int *number)
 580 {
 581         /* NOT SUPPORTED */
 582         return (FRU_NOTSUP);
 583 }
 584
 585
 586 /* ARGSUSED */
 587 static fru_errno_t
 588 frt_get_tag_data(fru_treehdl_t handle, const char *seg_name, fru_tag_t tag,
 589     int instance, uint8_t **data, size_t *data_len)
 590 {
 591         /* NOT SUPPORTED */
 592         return (FRU_NOTSUP);
 593 }
 594
 595
 596 /* ARGSUSED */
 597 static fru_errno_t
 598 frt_set_tag_data(fru_treehdl_t handle, const char *seg_name, fru_tag_t tag,
 599     int instance, uint8_t *data, size_t data_len)
 600 {
 601         /* NOT SUPPORTED */
 602         return (FRU_NOTSUP);
 603 }
 604
 605
 606 /* ARGSUSED */
 607 static fru_errno_t
 608 frt_delete_tag(fru_treehdl_t handle, const char *seg_name, fru_tag_t tag,
 609     int instance)
 610 {
 611         /* NOT SUPPORTED */
 612         return (FRU_NOTSUP);
 613 }
 614
 615
 616 static fru_errno_t
 617 frt_for_each_packet(fru_seghdl_t node, int (*function)(fru_tag_t *tag,
 618     uint8_t *payload, size_t length, void *args), void *args)
 619 {
 620         int rc_num;
 621         int status;
 622         char *rc_data;
 623         int i;
 624         packet_t *packets = NULL;
 625         segment_list_t *tmp_list;
 626         fru_segdesc_t *descriptor;
 627
 628         tmp_list = g_raw->segs;
 629
 630         /* num of packet */
 631         rc_num = fru_get_num_packets(node, NULL);
 632         if (rc_num == -1) {
 633                 return (map_errno(errno));
 634         } else if (rc_num == 0) {
 635                 return (FRU_SUCCESS);
 636         }
 637         while (tmp_list) {
 638                 if (node == tmp_list->segment->handle) {
 639                         break;
 640                 }
 641                 tmp_list = tmp_list->next;
 642         }
 643         if (tmp_list) {
 644                 descriptor = (fru_segdesc_t *)&tmp_list->segment->descriptor;
 645                 if (descriptor->field.opaque) {
 646                         return (FRU_SUCCESS);
 647                 }
 648
 649                 if (descriptor->field.encrypted && (encrypt_func == NULL)) {
 650                         return (FRU_SUCCESS);
 651                 }
 652         }
 653
 654         packets = malloc(sizeof (*packets) * (rc_num));
 655         if (packets == NULL) {
 656                 return (FRU_FAILURE);
 657         }
 658         /* get all packets */
 659         if (fru_get_packets(node, packets, rc_num, NULL) == -1) {
 660                 free(packets);
 661                 return (map_errno(errno));
 662         }
 663
 664         /* number of tags */
 665         for (i = 0; i < rc_num; i++) {
 666                 size_t rc_len =
 667                     get_payload_length((fru_tag_t *)&packets[i].tag);
 668
 669                 rc_data = malloc(sizeof (*rc_data) * (rc_len));
 670                 if (rc_data == NULL) {
 671                         free(packets);
 672                         return (FRU_FAILURE);
 673                 }
 674                 /* get the payload data */
 675                 (void) fru_get_payload(packets[i].handle, (void *)rc_data,
 676                     rc_len, NULL);
 677
 678                 if (tmp_list) {
 679                         descriptor =
 680                             (fru_segdesc_t *)&tmp_list->segment->descriptor;
 681
 682                         if ((descriptor->field.encrypted) &&
 683                             ((status = encrypt_func(FRU_DECRYPT,
 684                             (void *)rc_data, rc_len))
 685                             != FRU_SUCCESS)) {
 686                                 return (status);
 687                         }
 688                 }
 689                 /* print packet */
 690                 if ((status = function((fru_tag_t *)&packets[i].tag,
 691                     (uint8_t *)rc_data, rc_len, args)) != FRU_SUCCESS) {
 692                         free(rc_data);
 693                         free(packets);
 694                         return (status);
 695                 }
 696                 free(rc_data);
 697         }
 698         return (FRU_SUCCESS);
 699
 700 }
 701
 702
 703 /* object for libfru to link to */
 704 fru_datasource_t data_source =
 705 {
 706         LIBFRU_DS_VER,
 707         frt_initialize,
 708         frt_shutdown,
 709         frt_get_root,
 710         frt_get_child,
 711         frt_get_peer,
 712         frt_get_parent,
 713         frt_get_name_from_hdl,
 714         frt_get_node_type,
 715         frt_get_seg_list,
 716         frt_get_seg_def,
 717         frt_add_seg,
 718         frt_delete_seg,
 719         frt_for_each_segment,
 720         frt_get_segment_name,
 721         frt_add_tag_to_seg,
 722         frt_get_tag_list,
 723         frt_get_tag_data,
 724         frt_set_tag_data,
 725         frt_delete_tag,
 726         frt_for_each_packet
 727 };