src/util/zbin.c

   1 #include <stdio.h>
   2 #include <sys/stat.h>
   3
   4 #define ENCODE
   5 #define VERBOSE
   6 #include "nrv2b.c"
   7 FILE *infile, *outfile;
   8
   9 #define DEBUG 0
  10
  11 struct input_file {
  12         void *buf;
  13         size_t len;
  14 };
  15
  16 struct output_file {
  17         void *buf;
  18         size_t len;
  19         size_t max_len;
  20 };
  21
  22 struct zinfo_common {
  23         char type[4];
  24         char pad[12];
  25 };
  26
  27 struct zinfo_copy {
  28         char type[4];
  29         uint32_t offset;
  30         uint32_t len;
  31         uint32_t align;
  32 };
  33
  34 struct zinfo_pack {
  35         char type[4];
  36         uint32_t offset;
  37         uint32_t len;
  38         uint32_t align;
  39 };
  40
  41 struct zinfo_subtract {
  42         char type[4];
  43         uint32_t offset;
  44         uint32_t divisor;
  45         uint32_t pad;
  46 };
  47
  48 union zinfo_record {
  49         struct zinfo_common common;
  50         struct zinfo_copy copy;
  51         struct zinfo_pack pack;
  52         struct zinfo_subtract subtract;
  53 };
  54
  55 struct zinfo_file {
  56         union zinfo_record *zinfo;
  57         unsigned int num_entries;
  58 };
  59
  60 static unsigned long align ( unsigned long value, unsigned long align ) {
  61         return ( ( value + align - 1 ) & ~( align - 1 ) );
  62 }
  63
  64 static int read_file ( const char *filename, void **buf, size_t *len ) {
  65         FILE *file;
  66         struct stat stat;
  67
  68         file = fopen ( filename, "r" );
  69         if ( ! file ) {
  70                 fprintf ( stderr, "Could not open %s: %s\n", filename,
  71                           strerror ( errno ) );
  72                 goto err;
  73         }
  74
  75         if ( fstat ( fileno ( file ), &stat ) < 0 ) {
  76                 fprintf ( stderr, "Could not stat %s: %s\n", filename,
  77                           strerror ( errno ) );
  78                 goto err;
  79         }
  80
  81         *len = stat.st_size;
  82         *buf = malloc ( *len );
  83         if ( ! *buf ) {
  84                 fprintf ( stderr, "Could not malloc() %d bytes for %s: %s\n",
  85                           *len, filename, strerror ( errno ) );
  86                 goto err;
  87         }
  88
  89         if ( fread ( *buf, 1, *len, file ) != *len ) {
  90                 fprintf ( stderr, "Could not read %d bytes from %s: %s\n",
  91                           *len, filename, strerror ( errno ) );
  92                 goto err;
  93         }
  94
  95         fclose ( file );
  96         return 0;
  97
  98  err:
  99         if ( file )
 100                 fclose ( file );
 101         return -1;
 102 }
 103
 104 static int read_input_file ( const char *filename,
 105                              struct input_file *input ) {
 106         return read_file ( filename, &input->buf, &input->len );
 107 }
 108
 109 static int read_zinfo_file ( const char *filename,
 110                              struct zinfo_file *zinfo ) {
 111         void *buf;
 112         size_t len;
 113
 114         if ( read_file ( filename, &buf, &len ) < 0 )
 115                 return -1;
 116
 117         if ( ( len % sizeof ( *(zinfo->zinfo) ) ) != 0 ) {
 118                 fprintf ( stderr, ".zinfo file %s has invalid length %d\n",
 119                           filename, len );
 120                 return -1;
 121         }
 122
 123         zinfo->zinfo = buf;
 124         zinfo->num_entries = ( len / sizeof ( *(zinfo->zinfo) ) );
 125         return 0;
 126 }
 127
 128 static int alloc_output_file ( size_t max_len, struct output_file *output ) {
 129         output->len = 0;
 130         output->max_len = ( max_len );
 131         output->buf = malloc ( max_len );
 132         if ( ! output->buf ) {
 133                 fprintf ( stderr, "Could not allocate %d bytes for output\n",
 134                           max_len );
 135                 return -1;
 136         }
 137         memset ( output->buf, 0xff, sizeof ( output->buf ) );
 138         return 0;
 139 }
 140
 141 static int process_zinfo_copy ( struct input_file *input,
 142                                 struct output_file *output,
 143                                 union zinfo_record *zinfo ) {
 144         struct zinfo_copy *copy = &zinfo->copy;
 145         size_t offset = copy->offset;
 146         size_t len = copy->len;
 147
 148         if ( ( offset + len ) > input->len ) {
 149                 fprintf ( stderr, "Input buffer overrun on copy\n" );
 150                 return -1;
 151         }
 152
 153         output->len = align ( output->len, copy->align );
 154         if ( ( output->len + len ) > output->max_len ) {
 155                 fprintf ( stderr, "Output buffer overrun on copy\n" );
 156                 return -1;
 157         }
 158
 159         if ( DEBUG ) {
 160                 fprintf ( stderr, "COPY [%#zx,%#zx) to [%#zx,%#zx)\n", offset, ( offset + len ),
 161                           output->len, ( output->len + len ) );
 162         }
 163
 164         memcpy ( ( output->buf + output->len ),
 165                  ( input->buf + offset ), len );
 166         output->len += len;
 167         return 0;
 168 }
 169
 170 static int process_zinfo_pack ( struct input_file *input,
 171                                 struct output_file *output,
 172                                 union zinfo_record *zinfo ) {
 173         struct zinfo_pack *pack = &zinfo->pack;
 174         size_t offset = pack->offset;
 175         size_t len = pack->len;
 176         unsigned long packed_len;
 177
 178         if ( ( offset + len ) > input->len ) {
 179                 fprintf ( stderr, "Input buffer overrun on pack\n" );
 180                 return -1;
 181         }
 182
 183         output->len = align ( output->len, pack->align );
 184         if ( output->len > output->max_len ) {
 185                 fprintf ( stderr, "Output buffer overrun on pack\n" );
 186                 return -1;
 187         }
 188
 189         if ( ucl_nrv2b_99_compress ( ( input->buf + offset ), len,
 190                                      ( output->buf + output->len ),
 191                                      &packed_len, 0 ) != UCL_E_OK ) {
 192                 fprintf ( stderr, "Compression failure\n" );
 193                 return -1;
 194         }
 195
 196         if ( DEBUG ) {
 197                 fprintf ( stderr, "PACK [%#zx,%#zx) to [%#zx,%#zx)\n", offset, ( offset + len ),
 198                           output->len, ( output->len + packed_len ) );
 199         }
 200
 201         output->len += packed_len;
 202         if ( output->len > output->max_len ) {
 203                 fprintf ( stderr, "Output buffer overrun on pack\n" );
 204                 return -1;
 205         }
 206
 207         return 0;
 208 }
 209
 210 static int process_zinfo_subtract ( struct input_file *input,
 211                                     struct output_file *output,
 212                                     struct zinfo_subtract *subtract,
 213                                     size_t datasize ) {
 214         size_t offset = subtract->offset;
 215         void *target;
 216         long delta;
 217         unsigned long old;
 218         unsigned long new;
 219
 220         if ( ( offset + datasize ) > output->len ) {
 221                 fprintf ( stderr, "Subtract at %#zx outside output buffer\n",
 222                           offset );
 223                 return -1;
 224         }
 225
 226         target = ( output->buf + offset );
 227         delta = ( ( align ( output->len, subtract->divisor ) -
 228                     align ( input->len, subtract->divisor ) )
 229                   / subtract->divisor );
 230
 231         switch ( datasize ) {
 232         case 1: {
 233                 uint8_t *byte = target;
 234                 old = *byte;
 235                 *byte += delta;
 236                 new = *byte;
 237                 break; }
 238         case 2: {
 239                 uint16_t *word = target;
 240                 old = *word;
 241                 *word += delta;
 242                 new = *word;
 243                 break; }
 244         case 4: {
 245                 uint32_t *dword = target;
 246                 old = *dword;
 247                 *dword += delta;
 248                 new = *dword;
 249                 break; }
 250         default:
 251                 fprintf ( stderr, "Unsupported subtract datasize %d\n",
 252                           datasize );
 253                 return -1;
 254         }
 255
 256         if ( DEBUG ) {
 257                 fprintf ( stderr, "SUBx [%#zx,%#zx) (%#lx+(%#lx/%#x)-(%#lx/%#x)) = %#lx\n",
 258                           offset, ( offset + datasize ), old, output->len, subtract->divisor,
 259                           input->len, subtract->divisor, new );
 260         }
 261
 262         return 0;
 263 }
 264
 265 static int process_zinfo_subb ( struct input_file *input,
 266                                 struct output_file *output,
 267                                 union zinfo_record *zinfo ) {
 268         return process_zinfo_subtract ( input, output, &zinfo->subtract, 1 );
 269 }
 270
 271 static int process_zinfo_subw ( struct input_file *input,
 272                                 struct output_file *output,
 273                                 union zinfo_record *zinfo ) {
 274         return process_zinfo_subtract ( input, output, &zinfo->subtract, 2 );
 275 }
 276
 277 static int process_zinfo_subl ( struct input_file *input,
 278                                 struct output_file *output,
 279                                 union zinfo_record *zinfo ) {
 280         return process_zinfo_subtract ( input, output, &zinfo->subtract, 4 );
 281 }
 282
 283 struct zinfo_processor {
 284         char *type;
 285         int ( * process ) ( struct input_file *input,
 286                             struct output_file *output,
 287                             union zinfo_record *zinfo );
 288 };
 289
 290 static struct zinfo_processor zinfo_processors[] = {
 291         { "COPY", process_zinfo_copy },
 292         { "PACK", process_zinfo_pack },
 293         { "SUBB", process_zinfo_subb },
 294         { "SUBW", process_zinfo_subw },
 295         { "SUBL", process_zinfo_subl },
 296 };
 297
 298 static int process_zinfo ( struct input_file *input,
 299                            struct output_file *output,
 300                            union zinfo_record *zinfo ) {
 301         struct zinfo_common *common = &zinfo->common;
 302         struct zinfo_processor *processor;
 303         char type[ sizeof ( common->type ) + 1 ] = "";
 304         unsigned int i;
 305
 306         strncat ( type, common->type, sizeof ( type ) - 1 );
 307         for ( i = 0 ; i < ( sizeof ( zinfo_processors ) /
 308                             sizeof ( zinfo_processors[0] ) ) ; i++ ) {
 309                 processor = &zinfo_processors[i];
 310                 if ( strcmp ( processor->type, type ) == 0 )
 311                         return processor->process ( input, output, zinfo );
 312         }
 313
 314         fprintf ( stderr, "Unknown zinfo record type \"%s\"\n", &type[0] );
 315         return -1;
 316 }
 317
 318 static int write_output_file ( struct output_file *output ) {
 319         if ( fwrite ( output->buf, 1, output->len, stdout ) != output->len ) {
 320                 fprintf ( stderr, "Could not write %d bytes of output: %s\n",
 321                           output->len, strerror ( errno ) );
 322                 return -1;
 323         }
 324         return 0;
 325 }
 326
 327 int main ( int argc, char **argv ) {
 328         struct input_file input;
 329         struct output_file output;
 330         struct zinfo_file zinfo;
 331         unsigned int i;
 332
 333         if ( argc != 3 ) {
 334                 fprintf ( stderr, "Syntax: %s file.bin file.zinfo "
 335                           "> file.zbin\n", argv[0] );
 336                 exit ( 1 );
 337         }
 338
 339         if ( read_input_file ( argv[1], &input ) < 0 )
 340                 exit ( 1 );
 341         if ( read_zinfo_file ( argv[2], &zinfo ) < 0 )
 342                 exit ( 1 );
 343         if ( alloc_output_file ( ( input.len * 4 ), &output ) < 0 )
 344                 exit ( 1 );
 345
 346         for ( i = 0 ; i < zinfo.num_entries ; i++ ) {
 347                 if ( process_zinfo ( &input, &output,
 348                                      &zinfo.zinfo[i] ) < 0 )
 349                         exit ( 1 );
 350         }
 351
 352         if ( write_output_file ( &output ) < 0 )
 353                 exit ( 1 );
 354
 355         return 0;
 356 }