/*
 *  Extract RAR archives
 *
 *  Copyright (C) 2005 trog@uncon.org
 *  Patches added by Sourcefire, Inc. Copyright (C) 2007-2013
 *
 *  This code is based on the work of Alexander L. Roshal (C)
 *
 *  The unRAR sources may be used in any software to handle RAR
 *  archives without limitations free of charge, but cannot be used
 *  to re-create the RAR compression algorithm, which is proprietary.
 *  Distribution of modified unRAR sources in separate form or as a
 *  part of other software is permitted, provided that it is clearly
 *  stated in the documentation and source comments that the code may
 *  not be used to develop a RAR (WinRAR) compatible archiver.
 *
 */

#include <stdio.h>
#include <string.h>

#include "libclamunrar/unrar.h"
#include "libclamunrar/unrar20.h"

#ifdef RAR_HIGH_DEBUG
#define rar_dbgmsg printf
#else
static void rar_dbgmsg(const char* fmt,...){(void)fmt;}
#endif

void unpack_init_data20(int solid, unpack_data_t *unpack_data)
{
	if (!solid) {
		unpack_data->unp_channel_delta = 0;
		unpack_data->unp_cur_channel = 0;
		unpack_data->unp_audio_block = 0;
		unpack_data->unp_channels = 1;
		memset(unpack_data->audv, 0, sizeof(unpack_data->audv));
		memset(unpack_data->unp_old_table20, 0, sizeof(unpack_data->unp_old_table20));
		memset(unpack_data->MD, 0, sizeof(unpack_data->MD));
	}
}

static void copy_string20(unpack_data_t *unpack_data, unsigned int length, unsigned int distance)
{
	unsigned int dest_ptr;
	
	unpack_data->last_dist = unpack_data->old_dist[unpack_data->old_dist_ptr++ & 3] = distance;
	unpack_data->last_length = length;
	unpack_data->dest_unp_size -= length;
	
	dest_ptr = unpack_data->unp_ptr - distance;
	if (dest_ptr < MAXWINSIZE-300 && unpack_data->unp_ptr < MAXWINSIZE-300) {
		unpack_data->window[unpack_data->unp_ptr++] = unpack_data->window[dest_ptr++];
		unpack_data->window[unpack_data->unp_ptr++] = unpack_data->window[dest_ptr++];
		while (length > 2) {
			length--;
			unpack_data->window[unpack_data->unp_ptr++] = unpack_data->window[dest_ptr++];
		}
	} else while (length--) {
		unpack_data->window[unpack_data->unp_ptr] = unpack_data->window[dest_ptr++ & MAXWINMASK];
		unpack_data->unp_ptr = (unpack_data->unp_ptr+1) & MAXWINMASK;
	}
}
			
static int read_tables20(int fd, unpack_data_t *unpack_data)
{
	unsigned char bit_length[BC20];
	unsigned char table[MC20 * 4];
	int table_size, n, i, number;
	unsigned int bit_field;
	
	rar_dbgmsg("in read_tables20\n");
	
	if (unpack_data->in_addr > unpack_data->read_top-25) {
		if (!rar_unp_read_buf(fd, unpack_data)) {
			return FALSE;
		}
	}
	bit_field = rar_getbits(unpack_data);
	unpack_data->unp_audio_block = (bit_field & 0x8000);
	
	if (!(bit_field & 0x4000)) {
		memset(unpack_data->unp_old_table20, 0, sizeof(unpack_data->unp_old_table20));
	}
	rar_addbits(unpack_data, 2);
	
	if (unpack_data->unp_audio_block) {
		unpack_data->unp_channels = ((bit_field>>12) & 3) + 1;
		if (unpack_data->unp_cur_channel >= unpack_data->unp_channels) {
			unpack_data->unp_cur_channel = 0;
		}
		rar_addbits(unpack_data, 2);
		table_size = MC20 * unpack_data->unp_channels;
	} else {
		table_size = NC20+DC20+RC20;
	}
	
	for (i=0 ; i < BC20 ; i++) {
		bit_length[i] = (unsigned char) (rar_getbits(unpack_data) >> 12);
		rar_addbits(unpack_data, 4);
	}
	rar_make_decode_tables(bit_length, (struct Decode *)&unpack_data->BD, BC20);

	memset(table, 0, sizeof(table));
	for (i=0; i<table_size;) {
		if (unpack_data->in_addr > unpack_data->read_top-5) {
			if (!rar_unp_read_buf(fd, unpack_data)) {
				return FALSE;
			}
		}
		number = rar_decode_number(unpack_data, (struct Decode *)&unpack_data->BD);
		if (number < 16) {
			table[i] = (number + unpack_data->unp_old_table20[i]) & 0xf;
			i++;
		} else if (number == 16) {
			n = (rar_getbits(unpack_data) >> 14) + 3;
			rar_addbits(unpack_data, 2);
			while ((n-- > 0) && (i < table_size)) {
				if (i>0)
					table[i] = table[i-1];
				i++;
			}
		} else {
			if (number == 17) {
				n = (rar_getbits(unpack_data) >> 13) + 3;
				rar_addbits(unpack_data, 3);
			} else {
				n = (rar_getbits(unpack_data) >> 9) + 11;
				rar_addbits(unpack_data, 7);
			}
			while ((n-- > 0) && (i < table_size)) {
				table[i++] = 0;
			}
		}
	}
	if (unpack_data->in_addr > unpack_data->read_top) {
		return TRUE;
	}
	if (unpack_data->unp_audio_block) {
		for (i=0 ; i < unpack_data->unp_channels ; i++) {
			rar_make_decode_tables(&table[i*MC20], (struct Decode *)&unpack_data->MD[i], MC20);
		}
	} else {
		rar_make_decode_tables(&table[0], (struct Decode *)&unpack_data->LD, NC20);
		rar_make_decode_tables(&table[NC20], (struct Decode *)&unpack_data->DD, DC20);
		rar_make_decode_tables(&table[NC20+DC20], (struct Decode *)&unpack_data->RD, RC20);
	}
	memcpy(unpack_data->unp_old_table20, table, sizeof(unpack_data->unp_old_table20));
	return TRUE;
}

static void read_last_tables(int fd, unpack_data_t *unpack_data)
{
	if (unpack_data->read_top >= unpack_data->in_addr+5) {
		if (unpack_data->unp_audio_block) {
			if (rar_decode_number(unpack_data,
				(struct Decode *)&unpack_data->MD[unpack_data->unp_cur_channel]) == 256) {
				read_tables20(fd, unpack_data);
			}
		} else if (rar_decode_number(unpack_data, (struct Decode *)&unpack_data->LD) == 269) {
			read_tables20(fd, unpack_data);
		}
	}
}

static unsigned char decode_audio(unpack_data_t *unpack_data, int delta)
{
	struct AudioVariables *v;
	int pch, d, i;
	unsigned int ch, mindif, num_min_dif;
	
	v = &unpack_data->audv[unpack_data->unp_cur_channel];
	v->byte_count++;
	v->D4 = v->D3;
	v->D3 = v->D2;
	v->D2 = v->last_delta - v->D1;
	v->D1 = v->last_delta;
	
	pch = 8 * v->last_char + v->K1 * v->D1 + v->K2 * v->D2 + v->K3 *
		v->D3 + v->K4 * v->D4 + v->K5 * unpack_data->unp_channel_delta;
	pch = (pch >> 3) & 0xff;
	
	ch = pch - delta;
	
	d = ((signed char) delta) << 3;
	
	v->dif[0] += abs(d);
	v->dif[1] += abs(d - v->D1);
	v->dif[2] += abs(d + v->D1);
	v->dif[3] += abs(d - v->D2);
	v->dif[4] += abs(d + v->D2);
	v->dif[5] += abs(d - v->D3);
	v->dif[6] += abs(d + v->D3);
	v->dif[7] += abs(d - v->D4);
	v->dif[8] += abs(d + v->D4);
	v->dif[9] += abs(d - unpack_data->unp_channel_delta);
	v->dif[10] += abs(d + unpack_data->unp_channel_delta);

	unpack_data->unp_channel_delta = v->last_delta = (signed char) (ch - v->last_char);
	v->last_char = ch;
	
	if ((v->byte_count & 0x1f) == 0) {
		mindif = v->dif[0];
		num_min_dif = 0;
		v->dif[0] = 0;
		for (i = 1 ; i < 11 ; i++) {
			if (v->dif[i] < mindif) {
				mindif = v->dif[i];
				num_min_dif = i;
			}
			v->dif[i]=0; /* ?????? looks wrong to me */
		}
		switch(num_min_dif) {
			case 1:
				if (v->K1 >= -16) {
					v->K1--;
				}
				break;
			case 2:
				if (v->K1 < 16) {
					v->K1++;
				}
				break;
			case 3:
				if (v->K2 >= -16) {
					v->K2--;
				}
				break;
			case 4:
				if (v->K2 < 16) {
					v->K2++;
				}
				break;
			case 5:
				if (v->K3 >= -16) {
					v->K3--;
				}
				break;
			case 6:
				if (v->K3 < 16) {
					v->K3++;
				}
				break;
			case 7:
				if (v->K4 >= -16) {
					v->K4--;
				}
				break;
			case 8:
				if (v->K4 < 16) {
					v->K4++;
				}
				break;
			case 9:
				if (v->K5 >= -16) {
					v->K5--;
				}
				break;
			case 10:
				if (v->K5 < 16) {
					v->K5++;
				}
				break;
		}
	}
	return ((unsigned char) ch);
}

int rar_unpack20(int fd, int solid, unpack_data_t *unpack_data)
{
	unsigned char ldecode[]={0,1,2,3,4,5,6,7,8,10,12,14,16,20,24,28,
			32,40,48,56,64,80,96,112,128,160,192,224};
	unsigned char lbits[]={0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5};
	int ddecode[]={0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,
			768,1024,1536,2048,3072,4096,6144,8192,12288,16384,24576,
			32768U,49152U,65536,98304,131072,196608,262144,327680,393216,
			458752,524288,589824,655360,720896,786432,851968,917504,983040};
	unsigned char dbits[]={0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,
			12,12,13,13,14,14,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16,16};
	unsigned char sddecode[]={0,4,8,16,32,64,128,192};
	unsigned char sdbits[]={2,2,3,4,5,6,6,6};
	unsigned int bits, distance;
	int retval=TRUE, audio_number, number, length, dist_number, length_number;
	
	rar_dbgmsg("in rar_unpack20\n");

	rar_unpack_init_data(solid, unpack_data);
	if (!rar_unp_read_buf(fd, unpack_data)) {
		rar_dbgmsg("rar_unp_read_buf 1 failed\n");
		return FALSE;
	}
	if (!solid) {
		if (!read_tables20(fd, unpack_data)) {
			rar_dbgmsg("read_tables20 failed\n");
			return FALSE;
		}
	}
	--unpack_data->dest_unp_size;
	
	while (unpack_data->dest_unp_size >= 0) {
		rar_dbgmsg("dest_unp_size = %ld\n", unpack_data->dest_unp_size);
		unpack_data->unp_ptr &= MAXWINMASK;
		
		if (unpack_data->in_addr > unpack_data->read_top-30) {
			if (!rar_unp_read_buf(fd, unpack_data)) {
				rar_dbgmsg("rar_unp_read_buf 2 failed\n");
				break;
			}
		}
		if (((unpack_data->wr_ptr - unpack_data->unp_ptr) & MAXWINMASK) < 270 &&
				(unpack_data->wr_ptr != unpack_data->unp_ptr)) {
			rar_unp_write_buf_old(unpack_data);
		}
		if (unpack_data->unp_audio_block) {
			audio_number = rar_decode_number(unpack_data,
				(struct Decode *)&unpack_data->MD[unpack_data->unp_cur_channel]);
			if (audio_number == 256) {
				if (!read_tables20(fd, unpack_data)) {
					retval = FALSE;
					break;
				}
				continue;
			}
			unpack_data->window[unpack_data->unp_ptr++] =
					decode_audio(unpack_data, audio_number);
			if (++unpack_data->unp_cur_channel == unpack_data->unp_channels) {
				unpack_data->unp_cur_channel = 0;
			}
			--unpack_data->dest_unp_size;
			continue;
		}
		
		number = rar_decode_number(unpack_data, (struct Decode *)&unpack_data->LD);
		if (number < 256) {
			unpack_data->window[unpack_data->unp_ptr++] = (unsigned char) number;
			--unpack_data->dest_unp_size;
			continue;
		}
		if (number > 269) {
			/* If number is higher or equal to 298 in this instance something has likely
			 * gone horribly wrong and/or this is a RAR 5 file that Clam does not yet
			 * support parsing. Either way, this is a total failure case. */
			if (number < 298) {
				length = ldecode[number-=270]+3;
			} else {
				retval = FALSE;
				break;
			}

			if ((bits = lbits[number]) > 0) {
				length += rar_getbits(unpack_data) >> (16-bits);
				rar_addbits(unpack_data, bits);
			}
			
			dist_number = rar_decode_number(unpack_data, (struct Decode *)&unpack_data->DD);
			if (dist_number > 47 || dist_number < 0) {
				retval = FALSE;
				break;
			}
			distance = ddecode[dist_number] + 1;
			if ((bits = dbits[dist_number]) > 0) {
				distance += rar_getbits(unpack_data)>>(16-bits);
				rar_addbits(unpack_data, bits);
			}
			
			if (distance >= 0x2000) {
				length++;
				if (distance >= 0x40000L) {
					length++;
				}
			}
			
			copy_string20(unpack_data, length, distance);
			continue;
		}
		if (number == 269) {
			if (!read_tables20(fd, unpack_data)) {
				retval = FALSE;
				break;
			}
			continue;
		}
		if (number == 256) {
			copy_string20(unpack_data, unpack_data->last_length, unpack_data->last_dist);
			continue;
		}
		if (number < 261) {
			distance = unpack_data->old_dist[(unpack_data->old_dist_ptr-(number-256)) & 3];
			length_number = rar_decode_number(unpack_data, (struct Decode *)&unpack_data->RD);
			length = ldecode[length_number]+2;
			if ((bits = lbits[length_number]) > 0) {
				length += rar_getbits(unpack_data) >> (16-bits);
				rar_addbits(unpack_data, bits);
			}
			if (distance >= 0x101) {
				length++;
				if (distance >= 0x2000) {
					length++;
					if (distance >= 0x40000) {
						length++;
					}
				}
			}
			copy_string20(unpack_data, length, distance);
			continue;
		}
		if (number < 270) {
			distance = sddecode[number-=261]+1;
			if ((bits=sdbits[number]) > 0) {
				distance += rar_getbits(unpack_data) >> (16-bits);
				rar_addbits(unpack_data, bits);
			}
			copy_string20(unpack_data, 2, distance);
			continue;
		}
	}
	if (retval) {
		read_last_tables(fd, unpack_data);
		rar_unp_write_buf_old(unpack_data);
	}
	return retval;
}
