Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
       2                 :            : /* Copyright 2013-2019 IBM Corp. */
       3                 :            : 
       4                 :            : #include <unistd.h>
       5                 :            : #include <sys/stat.h>
       6                 :            : #include <fcntl.h>
       7                 :            : 
       8                 :            : #define __TEST__
       9                 :            : 
      10                 :            : #include "../ipmi-fru.c"
      11                 :            : 
      12                 :            : #include <string.h>
      13                 :            : 
      14                 :            : int error = 0;
      15                 :            : 
      16                 :            : const char version[] = "a-too-long-version-test-string-is-here";
      17                 :            : 
      18                 :          0 : void ipmi_free_msg(struct ipmi_msg __unused *msg)
      19                 :            : {
      20                 :          0 : }
      21                 :            : 
      22                 :          0 : void ipmi_init_msg(struct ipmi_msg __unused *msg, int __unused interface,
      23                 :            :                    uint32_t __unused code,
      24                 :            :                    void __unused (*complete)(struct ipmi_msg *),
      25                 :            :                    void __unused *user_data, size_t __unused req_size,
      26                 :            :                    size_t __unused resp_size)
      27                 :            : {
      28                 :          0 : }
      29                 :            : 
      30                 :          0 : struct ipmi_msg *ipmi_mkmsg(int __unused interface, uint32_t __unused code,
      31                 :            :                             void __unused (*complete)(struct ipmi_msg *),
      32                 :            :                             void __unused *user_data, void __unused *req_data, size_t __unused req_size,
      33                 :            :                             size_t __unused resp_size)
      34                 :            : {
      35                 :          0 :         return NULL;
      36                 :            : }
      37                 :            : 
      38                 :          0 : int ipmi_queue_msg(struct ipmi_msg __unused *msg)
      39                 :            : {
      40                 :          0 :         return 0;
      41                 :            : }
      42                 :            : 
      43                 :          0 : void _prlog(int __unused log_level, const __unused char* fmt, ...)
      44                 :            : {
      45                 :          0 :         return;
      46                 :            : }
      47                 :            : 
      48                 :          1 : int main(void)
      49                 :            : {
      50                 :            :         u8 *buf;
      51                 :            :         int len;
      52                 :          1 :         struct product_info info = {
      53                 :            :                 .manufacturer = (char *) "IBM",
      54                 :            :                 .product = (char *) "skiboot",
      55                 :            :                 .part_no = (char *) "hello",
      56                 :            :                 .version = (char *) "12345",
      57                 :            :                 .serial_no = (char *) "12345",
      58                 :            :                 .asset_tag = (char *) "abcd",
      59                 :            :         };
      60                 :          1 :         struct product_info invalid_info = {
      61                 :            :                 .manufacturer = (char *) "I",
      62                 :            :                 .product = (char *) "skiboot",
      63                 :            :                 .part_no = (char *) "hello",
      64                 :            :                 .version = (char *) "12345",
      65                 :            :                 .serial_no = (char *) "12345",
      66                 :            :                 .asset_tag = (char *) "abcd",
      67                 :            :         };
      68                 :          1 :         struct product_info invalid_info2 = {
      69                 :            :                 .manufacturer = (char *) "IBM",
      70                 :            :                 .product = (char *) "skiboot",
      71                 :            :                 .part_no = (char *) "this is a really long string that's more"
      72                 :            :                 "than 32 characters, because it turns out that's invalid.",
      73                 :            :                 .version = (char *) "12345",
      74                 :            :                 .serial_no = (char *) "12345",
      75                 :            :                 .asset_tag = (char *) "abcd",
      76                 :            :         };
      77                 :            : 
      78                 :          1 :         buf = malloc(256);
      79                 :            : 
      80                 :          1 :         len = fru_fill_product_info(buf, &info, 40);
      81                 :          1 :         assert(len == 40);
      82                 :          1 :         assert(memcmp(buf, "\001\005\000\303IBM\307skiboot\305hello"
      83                 :            :                       "\30512345\30512345\304abcd\301-",len) == 0);
      84                 :            : 
      85                 :            : 
      86                 :            :         /* Make sure the checksum is right */
      87                 :          1 :         assert(!fru_checksum(buf, len));
      88                 :            : 
      89                 :            :         /* This should fail (not enough space) */
      90                 :          1 :         assert(fru_fill_product_info(buf, &info, 39) < 0);
      91                 :            : 
      92                 :          1 :         memset(buf, 0, 256);
      93                 :          1 :         len = fru_fill_product_info(buf, &invalid_info, 40);
      94                 :          1 :         assert(len == OPAL_PARAMETER);
      95                 :            : 
      96                 :          1 :         memset(buf, 0, 256);
      97                 :          1 :         len = fru_fill_product_info(buf, &invalid_info2, 256);
      98                 :          1 :         assert(len == OPAL_PARAMETER);
      99                 :            : 
     100                 :          1 :         memset(buf, 0, 256);
     101                 :          1 :         assert(fru_add(buf, 256) > 0);
     102                 :          1 :         assert(0 == memcmp(&buf[64], "\001\a\000\303IBM\307skiboot\300"
     103                 :            :                            "\337a-too-long-version-test-string+\300\300\301"
     104                 :            :                            "\0\0\0",54));
     105                 :            : 
     106                 :            : 
     107                 :          1 :         memset(buf, 0, 256);
     108                 :          1 :         assert(fru_add(buf, 1) == OPAL_PARAMETER);
     109                 :            : 
     110                 :          1 :         memset(buf, 0, 256);
     111                 :          1 :         assert(fru_add(buf, 65) == OPAL_PARAMETER);
     112                 :            : 
     113                 :          1 :         free(buf);
     114                 :            : 
     115                 :          1 :         return 0;
     116                 :            : }