diff options
Diffstat (limited to 'contrib/syslinux-4.02/gpxe/src/util/zbin.c')
| -rw-r--r-- | contrib/syslinux-4.02/gpxe/src/util/zbin.c | 383 |
1 files changed, 383 insertions, 0 deletions
diff --git a/contrib/syslinux-4.02/gpxe/src/util/zbin.c b/contrib/syslinux-4.02/gpxe/src/util/zbin.c new file mode 100644 index 0000000..707ae99 --- /dev/null +++ b/contrib/syslinux-4.02/gpxe/src/util/zbin.c @@ -0,0 +1,383 @@ +#include <stdio.h> +#include <sys/stat.h> + +#define ENCODE +#define VERBOSE +#include "nrv2b.c" +FILE *infile, *outfile; + +#define DEBUG 0 + +struct input_file { + void *buf; + size_t len; +}; + +struct output_file { + void *buf; + size_t len; + size_t max_len; +}; + +struct zinfo_common { + char type[4]; + char pad[12]; +}; + +struct zinfo_copy { + char type[4]; + uint32_t offset; + uint32_t len; + uint32_t align; +}; + +struct zinfo_pack { + char type[4]; + uint32_t offset; + uint32_t len; + uint32_t align; +}; + +struct zinfo_add { + char type[4]; + uint32_t offset; + uint32_t divisor; + uint32_t pad; +}; + +union zinfo_record { + struct zinfo_common common; + struct zinfo_copy copy; + struct zinfo_pack pack; + struct zinfo_add add; +}; + +struct zinfo_file { + union zinfo_record *zinfo; + unsigned int num_entries; +}; + +static unsigned long align ( unsigned long value, unsigned long align ) { + return ( ( value + align - 1 ) & ~( align - 1 ) ); +} + +static int read_file ( const char *filename, void **buf, size_t *len ) { + FILE *file; + struct stat stat; + + file = fopen ( filename, "r" ); + if ( ! file ) { + fprintf ( stderr, "Could not open %s: %s\n", filename, + strerror ( errno ) ); + goto err; + } + + if ( fstat ( fileno ( file ), &stat ) < 0 ) { + fprintf ( stderr, "Could not stat %s: %s\n", filename, + strerror ( errno ) ); + goto err; + } + + *len = stat.st_size; + *buf = malloc ( *len ); + if ( ! *buf ) { + fprintf ( stderr, "Could not malloc() %zd bytes for %s: %s\n", + *len, filename, strerror ( errno ) ); + goto err; + } + + if ( fread ( *buf, 1, *len, file ) != *len ) { + fprintf ( stderr, "Could not read %zd bytes from %s: %s\n", + *len, filename, strerror ( errno ) ); + goto err; + } + + fclose ( file ); + return 0; + + err: + if ( file ) + fclose ( file ); + return -1; +} + +static int read_input_file ( const char *filename, + struct input_file *input ) { + return read_file ( filename, &input->buf, &input->len ); +} + +static int read_zinfo_file ( const char *filename, + struct zinfo_file *zinfo ) { + void *buf; + size_t len; + + if ( read_file ( filename, &buf, &len ) < 0 ) + return -1; + + if ( ( len % sizeof ( *(zinfo->zinfo) ) ) != 0 ) { + fprintf ( stderr, ".zinfo file %s has invalid length %zd\n", + filename, len ); + return -1; + } + + zinfo->zinfo = buf; + zinfo->num_entries = ( len / sizeof ( *(zinfo->zinfo) ) ); + return 0; +} + +static int alloc_output_file ( size_t max_len, struct output_file *output ) { + output->len = 0; + output->max_len = ( max_len ); + output->buf = malloc ( max_len ); + if ( ! output->buf ) { + fprintf ( stderr, "Could not allocate %zd bytes for output\n", + max_len ); + return -1; + } + memset ( output->buf, 0xff, sizeof ( output->buf ) ); + return 0; +} + +static int process_zinfo_copy ( struct input_file *input, + struct output_file *output, + union zinfo_record *zinfo ) { + struct zinfo_copy *copy = &zinfo->copy; + size_t offset = copy->offset; + size_t len = copy->len; + + if ( ( offset + len ) > input->len ) { + fprintf ( stderr, "Input buffer overrun on copy\n" ); + return -1; + } + + output->len = align ( output->len, copy->align ); + if ( ( output->len + len ) > output->max_len ) { + fprintf ( stderr, "Output buffer overrun on copy\n" ); + return -1; + } + + if ( DEBUG ) { + fprintf ( stderr, "COPY [%#zx,%#zx) to [%#zx,%#zx)\n", + offset, ( offset + len ), output->len, + ( output->len + len ) ); + } + + memcpy ( ( output->buf + output->len ), + ( input->buf + offset ), len ); + output->len += len; + return 0; +} + +static int process_zinfo_pack ( struct input_file *input, + struct output_file *output, + union zinfo_record *zinfo ) { + struct zinfo_pack *pack = &zinfo->pack; + size_t offset = pack->offset; + size_t len = pack->len; + unsigned long packed_len; + + if ( ( offset + len ) > input->len ) { + fprintf ( stderr, "Input buffer overrun on pack\n" ); + return -1; + } + + output->len = align ( output->len, pack->align ); + if ( output->len > output->max_len ) { + fprintf ( stderr, "Output buffer overrun on pack\n" ); + return -1; + } + + if ( ucl_nrv2b_99_compress ( ( input->buf + offset ), len, + ( output->buf + output->len ), + &packed_len, 0 ) != UCL_E_OK ) { + fprintf ( stderr, "Compression failure\n" ); + return -1; + } + + if ( DEBUG ) { + fprintf ( stderr, "PACK [%#zx,%#zx) to [%#zx,%#zx)\n", + offset, ( offset + len ), output->len, + ( size_t )( output->len + packed_len ) ); + } + + output->len += packed_len; + if ( output->len > output->max_len ) { + fprintf ( stderr, "Output buffer overrun on pack\n" ); + return -1; + } + + return 0; +} + +static int process_zinfo_add ( struct input_file *input, + struct output_file *output, + struct zinfo_add *add, + size_t datasize ) { + size_t offset = add->offset; + void *target; + signed long addend; + unsigned long size; + signed long val; + unsigned long mask; + + if ( ( offset + datasize ) > output->len ) { + fprintf ( stderr, "Add at %#zx outside output buffer\n", + offset ); + return -1; + } + + target = ( output->buf + offset ); + size = ( align ( output->len, add->divisor ) / add->divisor ); + + switch ( datasize ) { + case 1: + addend = *( ( int8_t * ) target ); + break; + case 2: + addend = *( ( int16_t * ) target ); + break; + case 4: + addend = *( ( int32_t * ) target ); + break; + default: + fprintf ( stderr, "Unsupported add datasize %zd\n", + datasize ); + return -1; + } + + val = size + addend; + + /* The result of 1UL << ( 8 * sizeof(unsigned long) ) is undefined */ + mask = ( ( datasize < sizeof ( mask ) ) ? + ( ( 1UL << ( 8 * datasize ) ) - 1 ) : ~0UL ); + + if ( val < 0 ) { + fprintf ( stderr, "Add %s%#x+%#lx at %#zx %sflows field\n", + ( ( addend < 0 ) ? "-" : "" ), abs ( addend ), size, + offset, ( ( addend < 0 ) ? "under" : "over" ) ); + return -1; + } + + if ( val & ~mask ) { + fprintf ( stderr, "Add %s%#x+%#lx at %#zx overflows %zd-byte " + "field (%d bytes too big)\n", + ( ( addend < 0 ) ? "-" : "" ), abs ( addend ), size, + offset, datasize, + ( int )( ( val - mask - 1 ) * add->divisor ) ); + return -1; + } + + switch ( datasize ) { + case 1: + *( ( uint8_t * ) target ) = val; + break; + case 2: + *( ( uint16_t * ) target ) = val; + break; + case 4: + *( ( uint32_t * ) target ) = val; + break; + } + + if ( DEBUG ) { + fprintf ( stderr, "ADDx [%#zx,%#zx) (%s%#x+(%#zx/%#x)) = " + "%#lx\n", offset, ( offset + datasize ), + ( ( addend < 0 ) ? "-" : "" ), abs ( addend ), + output->len, add->divisor, val ); + } + + return 0; +} + +static int process_zinfo_addb ( struct input_file *input, + struct output_file *output, + union zinfo_record *zinfo ) { + return process_zinfo_add ( input, output, &zinfo->add, 1 ); +} + +static int process_zinfo_addw ( struct input_file *input, + struct output_file *output, + union zinfo_record *zinfo ) { + return process_zinfo_add ( input, output, &zinfo->add, 2 ); +} + +static int process_zinfo_addl ( struct input_file *input, + struct output_file *output, + union zinfo_record *zinfo ) { + return process_zinfo_add ( input, output, &zinfo->add, 4 ); +} + +struct zinfo_processor { + char *type; + int ( * process ) ( struct input_file *input, + struct output_file *output, + union zinfo_record *zinfo ); +}; + +static struct zinfo_processor zinfo_processors[] = { + { "COPY", process_zinfo_copy }, + { "PACK", process_zinfo_pack }, + { "ADDB", process_zinfo_addb }, + { "ADDW", process_zinfo_addw }, + { "ADDL", process_zinfo_addl }, +}; + +static int process_zinfo ( struct input_file *input, + struct output_file *output, + union zinfo_record *zinfo ) { + struct zinfo_common *common = &zinfo->common; + struct zinfo_processor *processor; + char type[ sizeof ( common->type ) + 1 ] = ""; + unsigned int i; + + strncat ( type, common->type, sizeof ( type ) - 1 ); + for ( i = 0 ; i < ( sizeof ( zinfo_processors ) / + sizeof ( zinfo_processors[0] ) ) ; i++ ) { + processor = &zinfo_processors[i]; + if ( strcmp ( processor->type, type ) == 0 ) + return processor->process ( input, output, zinfo ); + } + + fprintf ( stderr, "Unknown zinfo record type \"%s\"\n", &type[0] ); + return -1; +} + +static int write_output_file ( struct output_file *output ) { + if ( fwrite ( output->buf, 1, output->len, stdout ) != output->len ) { + fprintf ( stderr, "Could not write %zd bytes of output: %s\n", + output->len, strerror ( errno ) ); + return -1; + } + return 0; +} + +int main ( int argc, char **argv ) { + struct input_file input; + struct output_file output; + struct zinfo_file zinfo; + unsigned int i; + + if ( argc != 3 ) { + fprintf ( stderr, "Syntax: %s file.bin file.zinfo " + "> file.zbin\n", argv[0] ); + exit ( 1 ); + } + + if ( read_input_file ( argv[1], &input ) < 0 ) + exit ( 1 ); + if ( read_zinfo_file ( argv[2], &zinfo ) < 0 ) + exit ( 1 ); + if ( alloc_output_file ( ( input.len * 4 ), &output ) < 0 ) + exit ( 1 ); + + for ( i = 0 ; i < zinfo.num_entries ; i++ ) { + if ( process_zinfo ( &input, &output, + &zinfo.zinfo[i] ) < 0 ) + exit ( 1 ); + } + + if ( write_output_file ( &output ) < 0 ) + exit ( 1 ); + + return 0; +} |