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                 if (buffer->name) {
  38                         free(buffer->name);
  39                         buffer->name = NULL;
  40                 }
  41                 return -1;
  42         }
  43         return 0;
  44 }
  45
  46 int buffer_from_file_aligned_size(struct buffer *buffer, const char *filename,
  47                                   size_t size_granularity)
  48 {
  49         FILE *fp = fopen(filename, "rb");
  50         if (!fp) {
  51                 perror(filename);
  52                 return -1;
  53         }
  54         off_t file_size = get_file_size(fp);
  55         if (file_size < 0) {
  56                 fprintf(stderr, "could not determine size of %s\n", filename);
  57                 fclose(fp);
  58                 return -1;
  59         }
  60         if (buffer_create(buffer, ALIGN_UP(file_size, size_granularity), filename)) {
  61                 fprintf(stderr, "could not allocate buffer\n");
  62                 fclose(fp);
  63                 return -1;
  64         }
  65         if (fread(buffer->data, 1, file_size, fp) != (size_t)file_size) {
  66                 fprintf(stderr, "incomplete read: %s\n", filename);
  67                 fclose(fp);
  68                 buffer_delete(buffer);
  69                 return -1;
  70         }
  71         fclose(fp);
  72
  73         if (buffer->size > (size_t)file_size)
  74                 memset(buffer->data + file_size, 0xff, buffer->size - file_size);
  75
  76         return 0;
  77 }
  78
  79 int buffer_from_file(struct buffer *buffer, const char *filename)
  80 {
  81         return buffer_from_file_aligned_size(buffer, filename, 1);
  82 }
  83
  84 int buffer_write_file(struct buffer *buffer, const char *filename)
  85 {
  86         FILE *fp = fopen(filename, "wb");
  87         if (!fp) {
  88                 perror(filename);
  89                 return -1;
  90         }
  91         assert(buffer && buffer->data);
  92         if (fwrite(buffer->data, 1, buffer->size, fp) != buffer->size) {
  93                 fprintf(stderr, "incomplete write: %s\n", filename);
  94                 fclose(fp);
  95                 return -1;
  96         }
  97         fclose(fp);
  98         return 0;
  99 }
 100
 101 void buffer_delete(struct buffer *buffer)
 102 {
 103         assert(buffer);
 104         if (buffer->name) {
 105                 free(buffer->name);
 106                 buffer->name = NULL;
 107         }
 108         if (buffer->data) {
 109                 free(buffer_get_original_backing(buffer));
 110                 buffer->data = NULL;
 111         }
 112         buffer->offset = 0;
 113         buffer->size = 0;
 114 }
 115
 116 static struct {
 117         uint32_t arch;
 118         const char *name;
 119 } arch_names[] = {
 120         { CBFS_ARCHITECTURE_AARCH64, "arm64" },
 121         { CBFS_ARCHITECTURE_ARM, "arm" },
 122         { CBFS_ARCHITECTURE_MIPS, "mips" },
 123         { CBFS_ARCHITECTURE_PPC64, "ppc64" },
 124         /* power8 is a reasonable alias */
 125         { CBFS_ARCHITECTURE_PPC64, "power8" },
 126         { CBFS_ARCHITECTURE_RISCV, "riscv" },
 127         { CBFS_ARCHITECTURE_X86, "x86" },
 128         { CBFS_ARCHITECTURE_UNKNOWN, "unknown" }
 129 };
 130
 131 uint32_t string_to_arch(const char *arch_string)
 132 {
 133         size_t i;
 134         uint32_t ret = CBFS_ARCHITECTURE_UNKNOWN;
 135
 136         for (i = 0; i < ARRAY_SIZE(arch_names); i++) {
 137                 if (!strcasecmp(arch_string, arch_names[i].name)) {
 138                         ret = arch_names[i].arch;
 139                         break;
 140                 }
 141         }
 142
 143         return ret;
 144 }
 145
 146 const char *arch_to_string(uint32_t a)
 147 {
 148         size_t i;
 149         const char *ret = NULL;
 150
 151         for (i = 0; i < ARRAY_SIZE(arch_names); i++) {
 152                 if (a == arch_names[i].arch) {
 153                         ret = arch_names[i].name;
 154                         break;
 155                 }
 156         }
 157
 158         return ret;
 159 }
 160
 161 void print_supported_architectures(void)
 162 {
 163         size_t i;
 164
 165         for (i = 0; i < ARRAY_SIZE(arch_names); i++) {
 166                 printf(i == 0? "  ":", ");
 167                 printf("%s", arch_names[i].name);
 168         }
 169
 170         printf("\n");
 171 }
 172
 173 void print_supported_filetypes(void)
 174 {
 175         int i;
 176
 177         for (i=0; filetypes[i].name; i++) {
 178                 printf(" %s%c", filetypes[i].name, filetypes[i + 1].name ? ',' : '\n');
 179                 if ((i%8) == 7)
 180                         printf("\n");
 181         }
 182 }
 183
 184 uint64_t intfiletype(const char *name)
 185 {
 186         size_t i;
 187         for (i = 0; filetypes[i].name; i++)
 188                 if (strcmp(filetypes[i].name, name) == 0)
 189                         return filetypes[i].type;
 190         return -1;
 191 }
 192
 193 char *bintohex(uint8_t *data, size_t len)
 194 {
 195         static const char translate[16] = "0123456789abcdef";
 196
 197         char *result = malloc(len * 2 + 1);
 198         if (result == NULL)
 199                 return NULL;
 200
 201         result[len*2] = '\0';
 202         unsigned int i;
 203         for (i = 0; i < len; i++) {
 204                 result[i*2] = translate[(data[i] >> 4) & 0xf];
 205                 result[i*2+1] = translate[data[i] & 0xf];
 206         }
 207         return result;
 208 }