Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2021-2022 DMTF. All rights reserved.
       4              :  *  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
       5              :  **/
       6              : 
       7              : #include "spdm_unit_test.h"
       8              : 
       9              : #if !(defined(_WIN32) || (defined(__clang__) && (defined (LIBSPDM_CPU_AARCH64) || \
      10              :     defined(LIBSPDM_CPU_ARM))))
      11              :     #include <fcntl.h>
      12              :     #include <unistd.h>
      13              :     #include <sys/stat.h>
      14              : #endif
      15              : 
      16           71 : void libspdm_dump_hex_str(const uint8_t *buffer, size_t buffer_size)
      17              : {
      18              :     size_t index;
      19              : 
      20          923 :     for (index = 0; index < buffer_size; index++) {
      21          852 :         printf("%02x", buffer[index]);
      22              :     }
      23           71 : }
      24              : 
      25         1583 : void libspdm_dump_data(const uint8_t *buffer, size_t buffer_size)
      26              : {
      27              :     size_t index;
      28              : 
      29        49475 :     for (index = 0; index < buffer_size; index++) {
      30        47892 :         printf("%02x ", buffer[index]);
      31              :     }
      32         1583 : }
      33              : 
      34          185 : void libspdm_dump_hex(const uint8_t *data, size_t size)
      35              : {
      36              :     size_t index;
      37              :     size_t count;
      38              :     size_t left;
      39              : 
      40              : #define COLUME_SIZE (16 * 2)
      41              : 
      42          185 :     count = size / COLUME_SIZE;
      43          185 :     left = size % COLUME_SIZE;
      44         1610 :     for (index = 0; index < count; index++) {
      45         1425 :         printf("%04x: ", (uint32_t)(index * COLUME_SIZE));
      46         1425 :         libspdm_dump_data(data + index * COLUME_SIZE, COLUME_SIZE);
      47         1425 :         printf("\n");
      48              :     }
      49              : 
      50          185 :     if (left != 0) {
      51          157 :         printf("%04x: ", (uint32_t)(index * COLUME_SIZE));
      52          157 :         libspdm_dump_data(data + index * COLUME_SIZE, left);
      53          157 :         printf("\n");
      54              :     }
      55          185 : }
      56              : 
      57         1116 : bool libspdm_read_input_file(const char *file_name, void **file_data,
      58              :                              size_t *file_size)
      59              : {
      60              : #if defined(_WIN32) || (defined(__clang__) && (defined (LIBSPDM_CPU_AARCH64) || \
      61              :     defined(LIBSPDM_CPU_ARM)))
      62              :     FILE *fp_in;
      63              :     size_t temp_result;
      64              : #else
      65              :     int32_t temp_result;
      66              :     int64_t fp_in;
      67              : #endif
      68              : 
      69              : #if defined(_WIN32) || (defined(__clang__) && (defined (LIBSPDM_CPU_AARCH64) || \
      70              :     defined(LIBSPDM_CPU_ARM)))
      71              :     if ((fp_in = fopen(file_name, "rb")) == NULL) {
      72              :         printf("Unable to open file %s\n", file_name);
      73              :         *file_data = NULL;
      74              :         return false;
      75              :     }
      76              : 
      77              :     fseek(fp_in, 0, SEEK_END);
      78              :     *file_size = ftell(fp_in);
      79              : 
      80              :     *file_data = (void *)malloc(*file_size);
      81              :     if (NULL == *file_data) {
      82              :         printf("No sufficient memory to allocate %s\n", file_name);
      83              :         fclose(fp_in);
      84              :         return false;
      85              :     }
      86              : 
      87              :     fseek(fp_in, 0, SEEK_SET);
      88              :     temp_result = fread(*file_data, 1, *file_size, fp_in);
      89              :     if (temp_result != *file_size) {
      90              :         printf("Read input file error %s", file_name);
      91              :         free((void *)*file_data);
      92              :         fclose(fp_in);
      93              :         return false;
      94              :     }
      95              : 
      96              :     fclose(fp_in);
      97              : 
      98              : #else
      99         1116 :     fp_in = open(file_name, O_RDONLY, S_IRWXU);
     100         1116 :     if (fp_in == -1) {
     101           28 :         printf("Unable to open file %s\n", file_name);
     102           28 :         *file_data = NULL;
     103           28 :         return false;
     104              :     }
     105              : 
     106         1088 :     temp_result = lseek(fp_in, 0, SEEK_END);
     107         1088 :     if (temp_result == -1) {
     108            0 :         printf("Unable to open file %s\n", file_name);
     109            0 :         *file_data = NULL;
     110            0 :         return false;
     111              :     } else {
     112         1088 :         *file_size = (size_t)temp_result;
     113              :     }
     114              : 
     115         1088 :     *file_data = (void *)malloc(*file_size);
     116         1088 :     if (NULL == *file_data) {
     117            0 :         printf("No sufficient memory to allocate %s\n", file_name);
     118            0 :         close(fp_in);
     119            0 :         return false;
     120              :     }
     121              : 
     122         1088 :     if (lseek(fp_in, 0, SEEK_SET) == -1) {
     123            0 :         close(fp_in);
     124            0 :         return false;
     125              :     }
     126              : 
     127         1088 :     temp_result = read(fp_in, *file_data, *file_size);
     128         1088 :     if (temp_result != *file_size) {
     129            0 :         printf("Read input file error %s", file_name);
     130            0 :         free((void *)*file_data);
     131            0 :         close(fp_in);
     132            0 :         return false;
     133              :     }
     134              : 
     135         1088 :     close(fp_in);
     136              : #endif
     137              : 
     138         1088 :     return true;
     139              : }
     140              : 
     141           67 : bool libspdm_write_output_file(const char *file_name, const void *file_data,
     142              :                                size_t file_size)
     143              : {
     144              :     FILE *fp_out;
     145              : 
     146           67 :     if ((fp_out = fopen(file_name, "w+b")) == NULL) {
     147            0 :         printf("Unable to open file %s\n", file_name);
     148            0 :         return false;
     149              :     }
     150              : 
     151           67 :     if ((fwrite(file_data, 1, file_size, fp_out)) != file_size) {
     152            0 :         printf("Write output file error %s\n", file_name);
     153            0 :         fclose(fp_out);
     154            0 :         return false;
     155              :     }
     156              : 
     157           67 :     fclose(fp_out);
     158              : 
     159           67 :     return true;
     160              : }