util/smmstoretool/data.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2
   3 #include "data.h"
   4
   5 #include <ctype.h>
   6 #include <limits.h>
   7 #include <stdint.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11
  12 #include "utils.h"
  13
  14 void print_data(const uint8_t data[], size_t data_size, enum data_type type)
  15 {
  16         if (data_size == 0)
  17                 return;
  18
  19         switch (type) {
  20         case DATA_TYPE_BOOL:
  21                 bool value = false;
  22                 for (size_t i = 0; i < data_size; ++i) {
  23                         if (data[i] != 0) {
  24                                 value = true;
  25                                 break;
  26                         }
  27                 }
  28                 printf("%s\n", value ? "true" : "false");
  29                 break;
  30         case DATA_TYPE_UINT8:
  31                 if (data_size != 1) {
  32                         fprintf(stderr,
  33                                 "warning: expected size of 1, got %zu\n",
  34                                 data_size);
  35                 }
  36
  37                 if (data_size >= 1)
  38                         printf("%u\n", *(uint8_t *)data);
  39                 break;
  40         case DATA_TYPE_UINT16:
  41                 if (data_size != 2) {
  42                         fprintf(stderr,
  43                                 "warning: expected size of 2, got %zu\n",
  44                                 data_size);
  45                 }
  46
  47                 if (data_size >= 2)
  48                         printf("%u\n", *(uint16_t *)data);
  49                 break;
  50         case DATA_TYPE_UINT32:
  51                 if (data_size != 4) {
  52                         fprintf(stderr,
  53                                 "warning: expected size of 4, got %zu\n",
  54                                 data_size);
  55                 }
  56
  57                 if (data_size >= 4)
  58                         printf("%u\n", *(uint32_t *)data);
  59                 break;
  60         case DATA_TYPE_UINT64:
  61                 if (data_size != 8) {
  62                         fprintf(stderr,
  63                                 "warning: expected size of 8, got %zu\n",
  64                                 data_size);
  65                 }
  66
  67                 if (data_size >= 8)
  68                         printf("%llu\n", (unsigned long long)*(uint64_t *)data);
  69                 break;
  70         case DATA_TYPE_ASCII:
  71                 for (size_t i = 0; i < data_size; ++i) {
  72                         char c = data[i];
  73                         if (isprint(c))
  74                                 printf("%c", c);
  75                 }
  76                 printf("\n");
  77                 break;
  78         case DATA_TYPE_UNICODE:
  79                 char *chars = to_chars((const CHAR16 *)data, data_size);
  80                 printf("%s\n", chars);
  81                 free(chars);
  82                 break;
  83         case DATA_TYPE_RAW:
  84                 fwrite(data, 1, data_size, stdout);
  85                 break;
  86         }
  87 }
  88
  89 static uint64_t parse_uint(const char source[],
  90                            const char type[],
  91                            unsigned long long max,
  92                            bool *failed)
  93 {
  94         char *end;
  95         unsigned long long uint = strtoull(source, &end, /*base=*/0);
  96         if (*end != '\0') {
  97                 fprintf(stderr, "Trailing characters in \"%s\": %s\n",
  98                         source, end);
  99                 *failed = true;
 100                 return 0;
 101         }
 102         if (uint > max) {
 103                 fprintf(stderr, "Invalid %s value: %llu\n", type, uint);
 104                 *failed = true;
 105                 return 0;
 106         }
 107
 108         *failed = false;
 109         return uint;
 110 }
 111
 112 void *make_data(const char source[], size_t *data_size, enum data_type type)
 113 {
 114         switch (type) {
 115         void *data;
 116         bool boolean;
 117         uint64_t uint;
 118         bool failed;
 119
 120         case DATA_TYPE_BOOL:
 121                 if (str_eq(source, "true")) {
 122                         boolean = true;
 123                 } else if (str_eq(source, "false")) {
 124                         boolean = false;
 125                 } else {
 126                         fprintf(stderr, "Invalid boolean value: \"%s\"\n",
 127                                 source);
 128                         return NULL;
 129                 }
 130
 131                 *data_size = 1;
 132                 data = xmalloc(*data_size);
 133                 *(uint8_t *)data = boolean;
 134                 return data;
 135         case DATA_TYPE_UINT8:
 136                 uint = parse_uint(source, "uint8", UINT8_MAX, &failed);
 137                 if (failed)
 138                         return NULL;
 139
 140                 *data_size = 1;
 141                 data = xmalloc(*data_size);
 142                 *(uint8_t *)data = uint;
 143                 return data;
 144         case DATA_TYPE_UINT16:
 145                 uint = parse_uint(source, "uint16", UINT16_MAX, &failed);
 146                 if (failed)
 147                         return NULL;
 148
 149                 *data_size = 2;
 150                 data = xmalloc(*data_size);
 151                 *(uint16_t *)data = uint;
 152                 return data;
 153         case DATA_TYPE_UINT32:
 154                 uint = parse_uint(source, "uint32", UINT32_MAX, &failed);
 155                 if (failed)
 156                         return NULL;
 157
 158                 *data_size = 4;
 159                 data = xmalloc(*data_size);
 160                 *(uint32_t *)data = uint;
 161                 return data;
 162         case DATA_TYPE_UINT64:
 163                 uint = parse_uint(source, "uint64", UINT64_MAX, &failed);
 164                 if (failed)
 165                         return NULL;
 166
 167                 *data_size = 8;
 168                 data = xmalloc(*data_size);
 169                 *(uint64_t *)data = uint;
 170                 return data;
 171         case DATA_TYPE_ASCII:
 172                 *data_size = strlen(source) + 1;
 173                 return strdup(source);
 174         case DATA_TYPE_UNICODE:
 175                 return to_uchars(source, data_size);
 176         case DATA_TYPE_RAW:
 177                 fprintf(stderr, "Raw data type is output only\n");
 178                 return NULL;
 179         }
 180
 181         return NULL;
 182 }
 183
 184 bool parse_data_type(const char str[], enum data_type *type)
 185 {
 186         if (str_eq(str, "bool"))
 187                 *type = DATA_TYPE_BOOL;
 188         else if (str_eq(str, "uint8"))
 189                 *type = DATA_TYPE_UINT8;
 190         else if (str_eq(str, "uint16"))
 191                 *type = DATA_TYPE_UINT16;
 192         else if (str_eq(str, "uint32"))
 193                 *type = DATA_TYPE_UINT32;
 194         else if (str_eq(str, "uint64"))
 195                 *type = DATA_TYPE_UINT64;
 196         else if (str_eq(str, "ascii"))
 197                 *type = DATA_TYPE_ASCII;
 198         else if (str_eq(str, "unicode"))
 199                 *type = DATA_TYPE_UNICODE;
 200         else if (str_eq(str, "raw"))
 201                 *type = DATA_TYPE_RAW;
 202         else
 203                 return false;
 204
 205         return true;
 206 }