X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/rsbs2/blobdiff_plain/650ebf3b096355d69644d60d9d8da84d947dd3a4..e726b380eaf48b6af8b06fe28383a183f35ceace:/rsb-lz.c

diff --git a/rsb-lz.c b/rsb-lz.c
index b0129b5..bb735d6 100644
--- a/rsb-lz.c
+++ b/rsb-lz.c
@@ -1,87 +1,316 @@
-/* TODO: IMPLEMET THIS! */
-/* Probably very broken lzw implementation by Agilent:
- *
- * 59a38:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, r10, r11, r14}
- * 59a3c:	e1a07000 	mov	r7, r0
- * 59a40:	e1a0a001 	mov	r10, r1
- * 59a44:	e1a0b002 	mov	r11, r2
- * 59a48:	ebfffeae 	bl	0x59508
- * 59a4c:	e3a03033 	mov	r3, #51	; 0x33
- * 59a50:	e3a0203f 	mov	r2, #63	; 0x3f
- * 59a54:	e3a01000 	mov	r1, #0	; 0x0
- * 59a58:	e3a00000 	mov	r0, #0	; 0x0
- * 59a5c:	ebfffec5 	bl	0x59578
- * 59a60:	e59f3100 	ldr	r3, [pc, #256]	; 0x59b68
- * 59a64:	e3a02033 	mov	r2, #51	; 0x33
- * 59a68:	e3a01540 	mov	r1, #268435456	; 0x10000000
- * 59a6c:	e3a00004 	mov	r0, #4	; 0x4
- * 59a70:	ebfffec0 	bl	0x59578
- * 59a74:	e59f30f0 	ldr	r3, [pc, #240]	; 0x59b6c
- * 59a78:	e3a0201b 	mov	r2, #27	; 0x1b
- * 59a7c:	e3a01550 	mov	r1, #335544320	; 0x14000000
- * 59a80:	e3a00005 	mov	r0, #5	; 0x5
- * 59a84:	ebfffebb 	bl	0x59578
- * 59a88:	e3a03033 	mov	r3, #51	; 0x33
- * 59a8c:	e3a0203b 	mov	r2, #59	; 0x3b
- * 59a90:	e3a014c0 	mov	r1, #-1073741824	; 0xc0000000
- * 59a94:	e3a00007 	mov	r0, #7	; 0x7
- * 59a98:	ebfffeb6 	bl	0x59578
- * 59a9c:	e59f00cc 	ldr	r0, [pc, #204]	; 0x59b70
- * 59aa0:	ebfffeae 	bl	0x59560
- * 59aa4:	e59b5000 	ldr	r5, [r11]
- * 59aa8:	e59f20c4 	ldr	r2, [pc, #196]	; 0x59b74
- * 59aac:	e1550002 	cmp	r5, r2
- * 59ab0:	0a000000 	beq	0x59ab8
- * 59ab4:	ebffff33 	bl	0x59788
- * 59ab8:	e28b3004 	add	r3, r11, #4	; 0x4
- * 59abc:	e5935000 	ldr	r5, [r3]
- * 59ac0:	e0853007 	add	r3, r5, r7
- * 59ac4:	e153000a 	cmp	r3, r10
- * 59ac8:	3a000000 	bcc	0x59ad0
- * 59acc:	ebffff2d 	bl	0x59788
- * 59ad0:	e28b2008 	add	r2, r11, #8	; 0x8
- * 59ad4:	e59f809c 	ldr	r8, [pc, #156]	; 0x59b78
- * 59ad8:	e5882000 	str	r2, [r8]
- * 59adc:	e085200b 	add	r2, r5, r11
- * 59ae0:	e59f8090 	ldr	r8, [pc, #144]	; 0x59b78
- * 59ae4:	e5882004 	str	r2, [r8, #4]
- * 59ae8:	e3a02000 	mov	r2, #0	; 0x0
- * 59aec:	e59f8084 	ldr	r8, [pc, #132]	; 0x59b78
- * 59af0:	e5c82009 	strb	r2, [r8, #9]
- * 59af4:	e3a02080 	mov	r2, #128	; 0x80
- * 59af8:	e59f8078 	ldr	r8, [pc, #120]	; 0x59b78
- * 59afc:	e5c82008 	strb	r2, [r8, #8]
- * 59b00:	e59f8074 	ldr	r8, [pc, #116]	; 0x59b7c
- * 59b04:	e5887000 	str	r7, [r8]
- * 59b08:	e0853007 	add	r3, r5, r7
- * 59b0c:	e59f8068 	ldr	r8, [pc, #104]	; 0x59b7c
- * 59b10:	e5883004 	str	r3, [r8, #4]
- * 59b14:	e59f1060 	ldr	r1, [pc, #96]	; 0x59b7c
- * 59b18:	e59f0058 	ldr	r0, [pc, #88]	; 0x59b78
- * 59b1c:	ebffff86 	bl	0x5993c
- * 59b20:	e2873020 	add	r3, r7, #32	; 0x20
- * 59b24:	e5935000 	ldr	r5, [r3]
- * 59b28:	e59f2050 	ldr	r2, [pc, #80]	; 0x59b80
- * 59b2c:	e1a01005 	mov	r1, r5
- * 59b30:	e1a00007 	mov	r0, r7
- * 59b34:	ebfffed2 	bl	0x59684
- * 59b38:	e1a01000 	mov	r1, r0
- * 59b3c:	e1a04001 	mov	r4, r1
- * 59b40:	e3540000 	cmp	r4, #0	; 0x0
- * 59b44:	0a000000 	beq	0x59b4c
- * 59b48:	ebffff0e 	bl	0x59788
- * 59b4c:	ebfffe6d 	bl	0x59508
- * 59b50:	e8bd8ff0 	pop	{r4, r5, r6, r7, r8, r9, r10, r11, r15}
- * 59b54:	c00b003c 	andgt	r0, r11, r12, lsr r0
- * 59b58:	c00b0038 	andgt	r0, r11, r8, lsr r0
- * 59b5c:	c00b0034 	andgt	r0, r11, r4, lsr r0
- * 59b60:	c00b0030 	andgt	r0, r11, r0, lsr r0
- * 59b64:	14000418 	strne	r0, [r0], #-1048
- * 59b68:	00000366 	andeq	r0, r0, r6, ror #6
- * 59b6c:	00000733 	andeq	r0, r0, r3, lsr r7
- * 59b70:	00001005 	andeq	r1, r0, r5
- * 59b74:	6110beef 	tstvs	r0, r15, ror #29  <- LZW Header...
- * 59b78:	14000404 	strne	r0, [r0], #-1028
- * 59b7c:	14000410 	strne	r0, [r0], #-1040
- * 59b80:	46335053 	undefined
- */
+#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;
+	unsigned char *stop;
+	unsigned char bitpos;
+	unsigned char byte;
+};
+
+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 get_next_bit(struct data_in_s *data_in)
+{
+	unsigned char bitval;
+
+	if (data_in->bitpos == 0x80) {
+		data_in->byte = get_next_in_byte(data_in);
+	}
+
+	bitval = data_in->bitpos & data_in->byte;
+
+	data_in->bitpos >>= 1;
+	if (data_in->bitpos == 0) {
+		data_in->bitpos = 0x80;
+	}
+
+	if (bitval == 0)
+		return 0;
+
+	return 1;
+}
+
+unsigned int get_next_bits(struct data_in_s *data_in, unsigned int bits)
+{
+	unsigned int bit;
+	unsigned int next_bits;
+
+	bit = 1 << (bits - 1);
+
+	next_bits = 0;
+	while (bit != 0) {
+		if (data_in->bitpos == 0x80) {
+			data_in->byte = get_next_in_byte(data_in);
+		}
+
+		if ((data_in->bitpos & data_in->byte) != 0)
+			next_bits = next_bits | bit;
+
+		bit = bit >> 1;
+
+		data_in->bitpos >>= 1;
+
+		if(data_in->bitpos == 0) {
+			data_in->bitpos = 0x80;
+		}
+	}
+
+	return next_bits;
+}
+
+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 *data_in, struct data_out_s *data_out)
+{
+	unsigned int pos;
+	unsigned int wordoffset;
+	unsigned int i;
+	unsigned char byte;
+	unsigned int wordlen;
+	unsigned char buf[1024];
+
+	pos = 1;
+
+	while (1) {
+		while (1) {
+			/* Compressed/uncompressed? */
+			if (get_next_bit(data_in) == 0)
+				break;
+
+			/* Uncompressed byte */
+			byte = get_next_bits(data_in, 8);
+
+			write_byte(byte, data_out);
+
+			/* Save byte in buffer, to be reused later */
+			buf[pos] = byte;
+			pos = (pos + 1) & 0x3ff;
+		}
+
+		/* offset for start of dictionary word */
+		wordoffset = get_next_bits(data_in, 0x0a);
+		if(wordoffset == 0)
+			return;
+
+		/* length of dictionary word used */
+		wordlen = get_next_bits(data_in, 0x04) + 1;
+		for (i = 0; i <= wordlen ; i++) {
+			/* lookup dictionary byte */
+			byte = buf[(wordoffset + i) & 0x3ff];
+			write_byte(byte, data_out);
+			/* Save byte in buffer, to be reused later */
+			buf[pos] = byte;
+			pos = (pos + 1) & 0x3ff;
+		}
+	}
+}
+
+void set_next_bit(unsigned char *buf, unsigned int set, unsigned int *currbit) {
+	unsigned char *pos;
+	unsigned char bitpos;
+
+	if (set) {
+		pos = buf + ((*currbit) / 8);
+		bitpos = 0x80 >> ((*currbit) % 8);
+		*pos |= bitpos;
+	}
+
+	*currbit = *currbit + 1;
+}
+
+void write_bits(unsigned char *buf, unsigned int data, unsigned int bits, unsigned int *currbit) {
+	int i;
+	unsigned int bitpos;
+
+	bitpos = 1 << (bits - 1);
+
+	for (i = 0; i < bits; i++) {
+		set_next_bit(buf, data & bitpos, currbit);
+		bitpos >>= 1;
+	}
+}
+
+unsigned char *compress_lz(unsigned char *inbuf, int inlen, int *outlen)
+{
+	unsigned char *end = inbuf + inlen;
+	unsigned char *outbuf;
+	unsigned char window[1024];
+	int pos = 0;
+	int fill = 0;
+	unsigned int currbit = 0;
+	int offset;
+	int wordlen;
+	int found;
+	int i;
+
+	if ((outbuf = malloc((inlen * 2) + 4)) == NULL) {
+		perror("malloc");
+	}
+
+	*((unsigned int*)outbuf) = LZ_MAGIC;
+	currbit = 8 * 8;
+
+	while(inbuf < end) {
+		found = 0;
+		for (wordlen = 17; wordlen > 1; wordlen--) {
+			for (offset = 1; offset < ((fill < 1023) ? fill : 1023); offset++) {
+				if ((fill < 1023) &&
+				    (wordlen + offset > fill))
+					break;
+
+				for (i = 0; i < wordlen; i++) {
+					if (inbuf[i] != window[(offset + i) & 0x3ff]) {
+						break;
+					}
+				}
+				if (i == wordlen)
+					found = 1;
+			}
+			if (found)
+				break;
+		}
+
+		if (found) {
+			write_bits(outbuf, 0x00, 0x01, &currbit);
+			write_bits(outbuf, offset, 0x0a, &currbit);
+			write_bits(outbuf, wordlen - 1, 0x04, &currbit);
+			for (i = 0; i < wordlen; i++) {
+				window[pos] = *(inbuf + i);
+				pos = (pos + 1) & 0x3ff;
+			}
+			inbuf += wordlen;
+
+			if (fill < sizeof(window))
+				fill += wordlen;
+		} else {
+			write_bits(outbuf, 0x01, 0x01, &currbit);
+			write_bits(outbuf, *inbuf, 0x08, &currbit);
+			window[pos] = *inbuf;
+			pos = (pos + 1) & 0x3ff;
+			inbuf++;
+			if (fill < sizeof(window))
+				fill++;
+		}
+	}
+
+	write_bits(outbuf, 0x00, 0x01, &currbit);
+	write_bits(outbuf, 0x00, 0x0a, &currbit);
+
+	*outlen = (currbit / 8) + 1;
+
+	*((unsigned int*)(outbuf + 4)) = *outlen;
+
+	return outbuf;
+}
+
+/* Checksum is only used for the compressed firmware in 'firmware' */
+unsigned int crc_check(unsigned char *buf, unsigned int len, unsigned int magic)
+{
+	unsigned int file_crc;
+	unsigned int my_len;
+	unsigned int crc;
+	unsigned int my_magic;
+
+	my_len = *((unsigned int*)(buf + 0x20));
+	my_magic = *((unsigned int*)(buf + 0x24));
+
+	if (my_magic != magic) {
+		printf("\nmagic: 0x%08x <-> 0x%08x\n", my_magic, magic);
+		return 2;
+	}
+	
+	if (len < my_len)
+		return 3;
+
+	crc = ~rsb_crc(~0x00, buf, len);
+	file_crc = *((unsigned int*)(buf + len));
+
+	if (file_crc != crc) {
+		printf("\nChecksums: 0x%08x <-> 0x%08x!\n", crc, file_crc);
+		return 4;
+	}
+
+	return 0;
+}
+
+unsigned char *extract_lz_file(unsigned char *inbuf, unsigned int *outlen , unsigned char check_crc)
+{
+	unsigned char *outbuf;
+	struct data_in_s data_in;
+	struct data_out_s data_out;
+
+	if (*((unsigned int*)inbuf) != LZ_MAGIC)
+		err_exit(__func__);
+
+	*outlen = *((unsigned int*)(inbuf + 4));
+	printf(", length: %d", *outlen);
+
+	if ((outbuf = malloc(*outlen)) == NULL) {
+		perror("malloc");
+		exit(1);
+	}
+
+	bzero(outbuf, *outlen);
+
+	data_in.start = inbuf + 8;
+	data_in.stop = inbuf + *outlen;
+	data_in.byte = 0x00;
+	data_in.bitpos = 0x80;
+
+	data_out.pos = outbuf;
+	data_out.end = outbuf + *outlen;
+
+	lz_expand(&data_in, &data_out);
+
+	if (check_crc) {
+		unsigned int crclen;
+		int ret;
+
+		crclen = *((unsigned int*)(outbuf + 0x20));
+
+		if ((ret = crc_check(outbuf, crclen, 0x46335053)) != 0) {
+			printf("crc_check return: %d\n", ret);
+			err_exit(__func__);
+		}
+	}
+
+	return outbuf;
+}