the unknown element of the data_in struct is the current working byte

[rsbs2] / rsb-lz.c

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include "rsb-crc.h"
#include "rsb-lz.h"
#include "filesystem.h"

void err_exit(const char *fname)
{
	fprintf(stderr,"%s: error extracting...\n", fname);
	exit(1);
}

struct data_in_s {
	unsigned char *start; /* 0 */
	unsigned char *stop; /* 4 */
	unsigned char bitpos; /* 8 */
	unsigned char byte; /* 9 */
};

struct data_out_s {
	unsigned char *pos;
	unsigned char *end;
};

unsigned char get_next_in_byte(struct data_in_s *data_in)
{
	unsigned char byte;

	if (data_in->stop < data_in->start)
		err_exit(__func__);

	byte = *(data_in->start);
	data_in->start++;

	return byte;
}

unsigned char fn_59848(struct data_in_s *data_in)
{
	unsigned char r5;

	if (data_in->bitpos == 0x80) {
		data_in->byte = get_next_in_byte(data_in);
	}

	r5 = data_in->bitpos & data_in->byte;

	data_in->bitpos >>= 1;
	if (data_in->bitpos == 0) {
		data_in->bitpos = 0x80;
	}

	if (r5 == 0)
		return 0;

	return 1;
}

unsigned int fn_598b4(struct data_in_s *r11_data, unsigned int r10_arg2)
{
	unsigned int r6;
	unsigned int r7;

	r6 = 1 << (r10_arg2 - 1);

	r7 = 0;
	while (r6 != 0) {
		if (r11_data->bitpos == 0x80) {
			r11_data->byte = get_next_in_byte(r11_data);
		}
		if ((r11_data->bitpos & r11_data->byte) != 0)
			r7 = r7 | r6;

		r6 = r6 >> 1;

		r11_data->bitpos >>= 1;

		if(r11_data->bitpos == 0) {
			r11_data->bitpos = 0x80;
		}
	}

	return r7;
}

void write_byte(unsigned char byte, struct data_out_s *data_out)
{
	if (data_out->pos > data_out->end) {
		err_exit(__func__);
	}

	*(data_out->pos) = byte;
	data_out->pos++;
}

void lz_expand(struct data_in_s *r10_data, struct data_out_s *data_out)
{
	unsigned int r5;
	unsigned int r2;
	unsigned char r4;
	unsigned int r6;
	unsigned int r7;
	unsigned int r11;
	unsigned char arr_59b64[1024];

	r5 = 1;

	while (1) {
		while (1) {
			r2 = fn_59848(r10_data);
			if (r2 == 0)
				break;

			r2 = fn_598b4(r10_data, 8) & 0xff;

			write_byte(r2, data_out);
			arr_59b64[r5] = r2 & 0xff;
			r5 = (r5 + 1) & 0x3ff;
		}

		r11 = fn_598b4(r10_data, 0x0a);
		if(r11 == 0)
			return;

		r2 = fn_598b4(r10_data, 0x04);
		r7 = r2 + 1;
		r6 = 0;
		while (r6 <= r7) {
			r2 = (r6 + r11) & 0x3ff;
			r4 = arr_59b64[r2];
			write_byte(r4, data_out);
			arr_59b64[r5] = r4;
			r5 = (r5 + 1) & 0x3ff;
			r6++;
		}
	}
}

/* Checksum is only used for the compressed firmware in 'firmware' */
#if 0
unsigned int crc_check_59684(unsigned char *arg1, unsigned int arg2, unsigned int magic)
{
	unsigned int r3;
	unsigned int r4;
	unsigned int r5;

#if 0
	if (r0 < 0xc0000000)
		return 1;
#endif

	/* ??? */
	r4 = *((unsigned int*)arg1 + 0x20);
	r5 = *((unsigned int*)arg1 + 0x24);

	printf("magic: 0x%08x <-> 0x%08x\n", r5, magic);
	if (r5 != magic)
		return 2;
	
	if (arg2 >= r4)
		r5 = 0;
	else
		return 3;

	r5 = ~rsb_crc(~0x00, arg1, r4);
	r3 = *((unsigned int*)(arg1 + r4));
	printf("Checksums: 0x%02x <-> 0x%02x\n", r5, r3);

	if (r3 == r5)
		return 0;

	return 4;
}
#endif

void extract_lz_file(unsigned char *inbuf, unsigned char *name)
{
	unsigned int len;
	unsigned char *outbuf;
	struct data_in_s data_in;
	struct data_out_s data_out;

	if (*((unsigned int*)inbuf) != LZ_MAGIC)
		err_exit(__func__);

	len = *((unsigned int*)(inbuf + 4));
	printf(", length: %d", len);

	if ((outbuf = malloc(len)) == NULL) {
		perror("malloc");
		exit(1);
	}

	bzero(outbuf, len);

	data_in.start = inbuf + 8;
	data_in.stop = inbuf + len;
	data_in.byte = 0x00;
	data_in.bitpos = 0x80;

	data_out.pos = outbuf;
	data_out.end = outbuf + len;

	lz_expand(&data_in, &data_out);

#if 0
	/* Checksum is only used for the compressed firmware in 'firmware' */
	r3 = r7 + 0x20;
	r5 = *((unsigned int*)r3);

	if ((ret = crc_check_59684(r7, r5, 0x46335053)) != 0) {
		printf("crc_check return: %d\n", ret);
		err_exit(__func__);
	}
#endif

	write_file((char*)name, outbuf, len);
	
	free(outbuf);
}