util/cbfstool/common.c

   1 /* common utility functions for cbfstool */
   2 /* SPDX-License-Identifier: GPL-2.0-only */
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <strings.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <unistd.h>
  11 #include <libgen.h>
  12 #include "common.h"
  13 #include "cbfs.h"
  14
  15 /* Utilities */
  16 int verbose = 0;
  17
  18 static off_t get_file_size(FILE *f)
  19 {
  20         off_t fsize;
  21         fseek(f, 0, SEEK_END);
  22         fsize = ftell(f);
  23         fseek(f, 0, SEEK_SET);
  24         return fsize;
  25 }
  26
  27 /* Buffer and file I/O */
  28 int buffer_create(struct buffer *buffer, size_t size, const char *name)
  29 {
  30         buffer->name = strdup(name);
  31         buffer->offset = 0;
  32         buffer->size = size;
  33         buffer->data = (char *)malloc(buffer->size);
  34         if (!buffer->data) {
  35                 fprintf(stderr, "buffer_create: Insufficient memory (0x%zx).\n",
  36                         size);
  37         }
  38         return (buffer->data == NULL);
  39 }
  40
  41 int buffer_from_file_aligned_size(struct buffer *buffer, const char *filename,
  42                                   size_t size_granularity)
  43 {
  44         FILE *fp = fopen(filename, "rb");
  45         if (!fp) {
  46                 perror(filename);
  47                 return -1;
  48         }
  49         buffer->offset = 0;
  50         off_t file_size = get_file_size(fp);
  51         if (file_size < 0) {
  52                 fprintf(stderr, "could not determine size of %s\n", filename);
  53                 fclose(fp);
  54                 return -1;
  55         }
  56         buffer->size = ALIGN_UP(file_size, size_granularity);
  57         buffer->name = strdup(filename);
  58         buffer->data = (char *)malloc(buffer->size);
  59         assert(buffer->data);
  60         if (fread(buffer->data, 1, file_size, fp) != (size_t)file_size) {
  61                 fprintf(stderr, "incomplete read: %s\n", filename);
  62                 fclose(fp);
  63                 buffer_delete(buffer);
  64                 return -1;
  65         }
  66         fclose(fp);
  67
  68         if (buffer->size > (size_t)file_size)
  69                 memset(buffer->data + file_size, 0xff, buffer->size - file_size);
  70
  71         return 0;
  72 }
  73
  74 int buffer_from_file(struct buffer *buffer, const char *filename)
  75 {
  76         return buffer_from_file_aligned_size(buffer, filename, 1);
  77 }
  78
  79 int buffer_write_file(struct buffer *buffer, const char *filename)
  80 {
  81         FILE *fp = fopen(filename, "wb");
  82         if (!fp) {
  83                 perror(filename);
  84                 return -1;
  85         }
  86         assert(buffer && buffer->data);
  87         if (fwrite(buffer->data, 1, buffer->size, fp) != buffer->size) {
  88                 fprintf(stderr, "incomplete write: %s\n", filename);
  89                 fclose(fp);
  90                 return -1;
  91         }
  92         fclose(fp);
  93         return 0;
  94 }
  95
  96 void buffer_delete(struct buffer *buffer)
  97 {
  98         assert(buffer);
  99         if (buffer->name) {
 100                 free(buffer->name);
 101                 buffer->name = NULL;
 102         }
 103         if (buffer->data) {
 104                 free(buffer_get_original_backing(buffer));
 105                 buffer->data = NULL;
 106         }
 107         buffer->offset = 0;
 108         buffer->size = 0;
 109 }
 110
 111 static struct {
 112         uint32_t arch;
 113         const char *name;
 114 } arch_names[] = {
 115         { CBFS_ARCHITECTURE_AARCH64, "arm64" },
 116         { CBFS_ARCHITECTURE_ARM, "arm" },
 117         { CBFS_ARCHITECTURE_MIPS, "mips" },
 118         { CBFS_ARCHITECTURE_PPC64, "ppc64" },
 119         /* power8 is a reasonable alias */
 120         { CBFS_ARCHITECTURE_PPC64, "power8" },
 121         { CBFS_ARCHITECTURE_RISCV, "riscv" },
 122         { CBFS_ARCHITECTURE_X86, "x86" },
 123         { CBFS_ARCHITECTURE_UNKNOWN, "unknown" }
 124 };
 125
 126 uint32_t string_to_arch(const char *arch_string)
 127 {
 128         size_t i;
 129         uint32_t ret = CBFS_ARCHITECTURE_UNKNOWN;
 130
 131         for (i = 0; i < ARRAY_SIZE(arch_names); i++) {
 132                 if (!strcasecmp(arch_string, arch_names[i].name)) {
 133                         ret = arch_names[i].arch;
 134                         break;
 135                 }
 136         }
 137
 138         return ret;
 139 }
 140
 141 const char *arch_to_string(uint32_t a)
 142 {
 143         size_t i;
 144         const char *ret = NULL;
 145
 146         for (i = 0; i < ARRAY_SIZE(arch_names); i++) {
 147                 if (a == arch_names[i].arch) {
 148                         ret = arch_names[i].name;
 149                         break;
 150                 }
 151         }
 152
 153         return ret;
 154 }
 155
 156 void print_supported_architectures(void)
 157 {
 158         size_t i;
 159
 160         for (i = 0; i < ARRAY_SIZE(arch_names); i++) {
 161                 printf(i == 0? "  ":", ");
 162                 printf("%s", arch_names[i].name);
 163         }
 164
 165         printf("\n");
 166 }
 167
 168 void print_supported_filetypes(void)
 169 {
 170         int i;
 171
 172         for (i=0; filetypes[i].name; i++) {
 173                 printf(" %s%c", filetypes[i].name, filetypes[i + 1].name ? ',' : '\n');
 174                 if ((i%8) == 7)
 175                         printf("\n");
 176         }
 177 }
 178
 179 uint64_t intfiletype(const char *name)
 180 {
 181         size_t i;
 182         for (i = 0; filetypes[i].name; i++)
 183                 if (strcmp(filetypes[i].name, name) == 0)
 184                         return filetypes[i].type;
 185         return -1;
 186 }
 187
 188 char *bintohex(uint8_t *data, size_t len)
 189 {
 190         static const char translate[16] = "0123456789abcdef";
 191
 192         char *result = malloc(len * 2 + 1);
 193         if (result == NULL)
 194                 return NULL;
 195
 196         result[len*2] = '\0';
 197         unsigned int i;
 198         for (i = 0; i < len; i++) {
 199                 result[i*2] = translate[(data[i] >> 4) & 0xf];
 200                 result[i*2+1] = translate[data[i] & 0xf];
 201         }
 202         return result;
 203 }