git.zerfleddert.de Git - rsbs2/blob - rsb-lz.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <strings.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6 #include <errno.h>
   7 #include "rsb-crc.h"
   8 #include "rsb-lz.h"
   9 #include "filesystem.h"
  10
  11 void err_exit(const char *fname)
  12 {
  13         fprintf(stderr,"%s: error extracting...\n", fname);
  14         exit(1);
  15 }
  16
  17 struct data_in_s {
  18         unsigned char *start;
  19         unsigned char *stop;
  20         unsigned char bitpos;
  21         unsigned char byte;
  22 };
  23
  24 struct data_out_s {
  25         unsigned char *pos;
  26         unsigned char *end;
  27 };
  28
  29 unsigned char get_next_in_byte(struct data_in_s *data_in)
  30 {
  31         unsigned char byte;
  32
  33         if (data_in->stop < data_in->start)
  34                 err_exit(__func__);
  35
  36         byte = *(data_in->start);
  37         data_in->start++;
  38
  39         return byte;
  40 }
  41
  42 unsigned char get_next_bit(struct data_in_s *data_in)
  43 {
  44         unsigned char bitval;
  45
  46         if (data_in->bitpos == 0x80) {
  47                 data_in->byte = get_next_in_byte(data_in);
  48         }
  49
  50         bitval = data_in->bitpos & data_in->byte;
  51
  52         data_in->bitpos >>= 1;
  53         if (data_in->bitpos == 0) {
  54                 data_in->bitpos = 0x80;
  55         }
  56
  57         if (bitval == 0)
  58                 return 0;
  59
  60         return 1;
  61 }
  62
  63 unsigned int get_next_bits(struct data_in_s *data_in, unsigned int bits)
  64 {
  65         unsigned int bit;
  66         unsigned int next_bits;
  67
  68         bit = 1 << (bits - 1);
  69
  70         next_bits = 0;
  71         while (bit != 0) {
  72                 if (data_in->bitpos == 0x80) {
  73                         data_in->byte = get_next_in_byte(data_in);
  74                 }
  75
  76                 if ((data_in->bitpos & data_in->byte) != 0)
  77                         next_bits = next_bits | bit;
  78
  79                 bit = bit >> 1;
  80
  81                 data_in->bitpos >>= 1;
  82
  83                 if(data_in->bitpos == 0) {
  84                         data_in->bitpos = 0x80;
  85                 }
  86         }
  87
  88         return next_bits;
  89 }
  90
  91 void write_byte(unsigned char byte, struct data_out_s *data_out)
  92 {
  93         if (data_out->pos > data_out->end) {
  94                 err_exit(__func__);
  95         }
  96
  97         *(data_out->pos) = byte;
  98         data_out->pos++;
  99 }
 100
 101 void lz_expand(struct data_in_s *r10_data, struct data_out_s *data_out)
 102 {
 103         unsigned int r5;
 104         unsigned int r2;
 105         unsigned char r4;
 106         unsigned int r6;
 107         unsigned int r7;
 108         unsigned int r11;
 109         unsigned char window[1024];
 110
 111         r5 = 1;
 112
 113         while (1) {
 114                 while (1) {
 115                         r2 = get_next_bit(r10_data);
 116                         if (r2 == 0)
 117                                 break;
 118
 119                         r2 = get_next_bits(r10_data, 8) & 0xff;
 120
 121                         write_byte(r2, data_out);
 122                         window[r5] = r2 & 0xff;
 123                         r5 = (r5 + 1) & 0x3ff;
 124                 }
 125
 126                 r11 = get_next_bits(r10_data, 0x0a);
 127                 if(r11 == 0)
 128                         return;
 129
 130                 r2 = get_next_bits(r10_data, 0x04);
 131                 r7 = r2 + 1;
 132                 r6 = 0;
 133                 while (r6 <= r7) {
 134                         r2 = (r6 + r11) & 0x3ff;
 135                         r4 = window[r2];
 136                         write_byte(r4, data_out);
 137                         window[r5] = r4;
 138                         r5 = (r5 + 1) & 0x3ff;
 139                         r6++;
 140                 }
 141         }
 142 }
 143
 144 /* Checksum is only used for the compressed firmware in 'firmware' */
 145 #if 0
 146 unsigned int crc_check_59684(unsigned char *arg1, unsigned int arg2, unsigned int magic)
 147 {
 148         unsigned int r3;
 149         unsigned int r4;
 150         unsigned int r5;
 151
 152 #if 0
 153         if (r0 < 0xc0000000)
 154                 return 1;
 155 #endif
 156
 157         /* ??? */
 158         r4 = *((unsigned int*)arg1 + 0x20);
 159         r5 = *((unsigned int*)arg1 + 0x24);
 160
 161         printf("magic: 0x%08x <-> 0x%08x\n", r5, magic);
 162         if (r5 != magic)
 163                 return 2;
 164
 165         if (arg2 >= r4)
 166                 r5 = 0;
 167         else
 168                 return 3;
 169
 170         r5 = ~rsb_crc(~0x00, arg1, r4);
 171         r3 = *((unsigned int*)(arg1 + r4));
 172         printf("Checksums: 0x%02x <-> 0x%02x\n", r5, r3);
 173
 174         if (r3 == r5)
 175                 return 0;
 176
 177         return 4;
 178 }
 179 #endif
 180
 181 void extract_lz_file(unsigned char *inbuf, unsigned char *name)
 182 {
 183         unsigned int len;
 184         unsigned char *outbuf;
 185         struct data_in_s data_in;
 186         struct data_out_s data_out;
 187
 188         if (*((unsigned int*)inbuf) != LZ_MAGIC)
 189                 err_exit(__func__);
 190
 191         len = *((unsigned int*)(inbuf + 4));
 192         printf(", length: %d", len);
 193
 194         if ((outbuf = malloc(len)) == NULL) {
 195                 perror("malloc");
 196                 exit(1);
 197         }
 198
 199         bzero(outbuf, len);
 200
 201         data_in.start = inbuf + 8;
 202         data_in.stop = inbuf + len;
 203         data_in.byte = 0x00;
 204         data_in.bitpos = 0x80;
 205
 206         data_out.pos = outbuf;
 207         data_out.end = outbuf + len;
 208
 209         lz_expand(&data_in, &data_out);
 210
 211 #if 0
 212         /* Checksum is only used for the compressed firmware in 'firmware' */
 213         r3 = r7 + 0x20;
 214         r5 = *((unsigned int*)r3);
 215
 216         if ((ret = crc_check_59684(r7, r5, 0x46335053)) != 0) {
 217                 printf("crc_check return: %d\n", ret);
 218                 err_exit(__func__);
 219         }
 220 #endif
 221
 222         write_file((char*)name, outbuf, len);
 223
 224         free(outbuf);
 225 }