Subversion Repositories Kolibri OS

#include "fitz.h"

/* Pretend we have a filter that just copies data forever */

fz_stream *

fz_open_copy(fz_stream *chain)

{

	return fz_keep_stream(chain);

}

/* Null filter copies a specified amount of data */

struct null_filter

{

	fz_stream *chain;

	int remain;

};

static int

read_null(fz_stream *stm, unsigned char *buf, int len)

{

	struct null_filter *state = stm->state;

	int amount = MIN(len, state->remain);

	int n = fz_read(state->chain, buf, amount);

	if (n < 0)

		return fz_rethrow(n, "read error in null filter");

	state->remain -= n;

	return n;

}

static void

close_null(fz_stream *stm)

{

	struct null_filter *state = stm->state;

	fz_close(state->chain);

	fz_free(state);

}

fz_stream *

fz_open_null(fz_stream *chain, int len)

{

	struct null_filter *state;

	state = fz_malloc(sizeof(struct null_filter));

	state->chain = chain;

	state->remain = len;

	return fz_new_stream(state, read_null, close_null);

}

/* ASCII Hex Decode */

typedef struct fz_ahxd_s fz_ahxd;

struct fz_ahxd_s

{

	fz_stream *chain;

	int eod;

};

static inline int iswhite(int a)

{

	switch (a) {

	case '\n': case '\r': case '\t': case ' ':

	case '\0': case '\f': case '\b': case 0177:

		return 1;

	}

	return 0;

}

static inline int ishex(int a)

{

	return (a >= 'A' && a <= 'F') ||

		(a >= 'a' && a <= 'f') ||

		(a >= '0' && a <= '9');

}

static inline int unhex(int a)

{

	if (a >= 'A' && a <= 'F') return a - 'A' + 0xA;

	if (a >= 'a' && a <= 'f') return a - 'a' + 0xA;

	if (a >= '0' && a <= '9') return a - '0';

	return 0;

}

static int

read_ahxd(fz_stream *stm, unsigned char *buf, int len)

{

	fz_ahxd *state = stm->state;

	unsigned char *p = buf;

	unsigned char *ep = buf + len;

	int a, b, c, odd;

	odd = 0;

	while (p < ep)

	{

		if (state->eod)

			return p - buf;

		c = fz_read_byte(state->chain);

		if (c < 0)

			return p - buf;

		if (ishex(c))

		{

			if (!odd)

			{

				a = unhex(c);

				odd = 1;

			}

			else

			{

				b = unhex(c);

				*p++ = (a << 4) | b;

				odd = 0;

			}

		}

		else if (c == '>')

		{

			if (odd)

				*p++ = (a << 4);

			state->eod = 1;

		}

		else if (!iswhite(c))

		{

			return fz_throw("bad data in ahxd: '%c'", c);

		}

	}

	return p - buf;

}

static void

close_ahxd(fz_stream *stm)

{

	fz_ahxd *state = stm->state;

	fz_close(state->chain);

	fz_free(state);

}

fz_stream *

fz_open_ahxd(fz_stream *chain)

{

	fz_ahxd *state;

	state = fz_malloc(sizeof(fz_ahxd));

	state->chain = chain;

	state->eod = 0;

	return fz_new_stream(state, read_ahxd, close_ahxd);

}

/* ASCII 85 Decode */

typedef struct fz_a85d_s fz_a85d;

struct fz_a85d_s

{

	fz_stream *chain;

	unsigned char bp[4];

	unsigned char *rp, *wp;

	int eod;

};

static int

read_a85d(fz_stream *stm, unsigned char *buf, int len)

{

	fz_a85d *state = stm->state;

	unsigned char *p = buf;

	unsigned char *ep = buf + len;

	int count = 0;

	int word = 0;

	int c;

	while (state->rp < state->wp && p < ep)

		*p++ = *state->rp++;

	while (p < ep)

	{

		if (state->eod)

			return p - buf;

		c = fz_read_byte(state->chain);

		if (c < 0)

			return p - buf;

		if (c >= '!' && c <= 'u')

		{

			if (count == 4)

			{

				word = word * 85 + (c - '!');

				state->bp[0] = (word >> 24) & 0xff;

				state->bp[1] = (word >> 16) & 0xff;

				state->bp[2] = (word >> 8) & 0xff;

				state->bp[3] = (word) & 0xff;

				state->rp = state->bp;

				state->wp = state->bp + 4;

				word = 0;

				count = 0;

			}

			else

			{

				word = word * 85 + (c - '!');

				count ++;

			}

		}

		else if (c == 'z' && count == 0)

		{

			state->bp[0] = 0;

			state->bp[1] = 0;

			state->bp[2] = 0;

			state->bp[3] = 0;

			state->rp = state->bp;

			state->wp = state->bp + 4;

		}

		else if (c == '~')

		{

			c = fz_read_byte(state->chain);

			if (c != '>')

				fz_warn("bad eod marker in a85d");

			switch (count) {

			case 0:

				break;

			case 1:

				return fz_throw("partial final byte in a85d");

			case 2:

				word = word * (85 * 85 * 85) + 0xffffff;

				state->bp[0] = word >> 24;

				state->rp = state->bp;

				state->wp = state->bp + 1;

				break;

			case 3:

				word = word * (85 * 85) + 0xffff;

				state->bp[0] = word >> 24;

				state->bp[1] = word >> 16;

				state->rp = state->bp;

				state->wp = state->bp + 2;

				break;

			case 4:

				word = word * 85 + 0xff;

				state->bp[0] = word >> 24;

				state->bp[1] = word >> 16;

				state->bp[2] = word >> 8;

				state->rp = state->bp;

				state->wp = state->bp + 3;

				break;

			}

			state->eod = 1;

		}

		else if (!iswhite(c))

		{

			return fz_throw("bad data in a85d: '%c'", c);

		}

		while (state->rp < state->wp && p < ep)

			*p++ = *state->rp++;

	}

	return p - buf;

}

static void

close_a85d(fz_stream *stm)

{

	fz_a85d *state = stm->state;

	fz_close(state->chain);

	fz_free(state);

}

fz_stream *

fz_open_a85d(fz_stream *chain)

{

	fz_a85d *state;

	state = fz_malloc(sizeof(fz_a85d));

	state->chain = chain;

	state->rp = state->bp;

	state->wp = state->bp;

	state->eod = 0;

	return fz_new_stream(state, read_a85d, close_a85d);

}

/* Run Length Decode */

typedef struct fz_rld_s fz_rld;

struct fz_rld_s

{

	fz_stream *chain;

	int run, n, c;

};

static int

read_rld(fz_stream *stm, unsigned char *buf, int len)

{

	fz_rld *state = stm->state;

	unsigned char *p = buf;

	unsigned char *ep = buf + len;

	while (p < ep)

	{

		if (state->run == 128)

			return p - buf;

		if (state->n == 0)

		{

			state->run = fz_read_byte(state->chain);

			if (state->run < 0)

				state->run = 128;

			if (state->run < 128)

				state->n = state->run + 1;

			if (state->run > 128)

			{

				state->n = 257 - state->run;

				state->c = fz_read_byte(state->chain);

				if (state->c < 0)

					return fz_throw("premature end of data in run length decode");

			}

		}

		if (state->run < 128)

		{

			while (p < ep && state->n)

			{

				int c = fz_read_byte(state->chain);

				if (c < 0)

					return fz_throw("premature end of data in run length decode");

				*p++ = c;

				state->n--;

			}

		}

		if (state->run > 128)

		{

			while (p < ep && state->n)

			{

				*p++ = state->c;

				state->n--;

			}

		}

	}

	return p - buf;

}

static void

close_rld(fz_stream *stm)

{

	fz_rld *state = stm->state;

	fz_close(state->chain);

	fz_free(state);

}

fz_stream *

fz_open_rld(fz_stream *chain)

{

	fz_rld *state;

	state = fz_malloc(sizeof(fz_rld));

	state->chain = chain;

	state->run = 0;

	state->n = 0;

	state->c = 0;

	return fz_new_stream(state, read_rld, close_rld);

}

/* RC4 Filter */

typedef struct fz_arc4c_s fz_arc4c;

struct fz_arc4c_s

{

	fz_stream *chain;

	fz_arc4 arc4;

};

static int

read_arc4(fz_stream *stm, unsigned char *buf, int len)

{

	fz_arc4c *state = stm->state;

	int n;

	n = fz_read(state->chain, buf, len);

	if (n < 0)

		return fz_rethrow(n, "read error in arc4 filter");

	fz_arc4_encrypt(&state->arc4, buf, buf, n);

	return n;

}

static void

close_arc4(fz_stream *stm)

{

	fz_arc4c *state = stm->state;

	fz_close(state->chain);

	fz_free(state);

}

fz_stream *

fz_open_arc4(fz_stream *chain, unsigned char *key, unsigned keylen)

{

	fz_arc4c *state;

	state = fz_malloc(sizeof(fz_arc4c));

	state->chain = chain;

	fz_arc4_init(&state->arc4, key, keylen);

	return fz_new_stream(state, read_arc4, close_arc4);

}

/* AES Filter */

typedef struct fz_aesd_s fz_aesd;

struct fz_aesd_s

{

	fz_stream *chain;

	fz_aes aes;

	unsigned char iv[16];

	int ivcount;

	unsigned char bp[16];

	unsigned char *rp, *wp;

};

static int

read_aesd(fz_stream *stm, unsigned char *buf, int len)

{

	fz_aesd *state = stm->state;

	unsigned char *p = buf;

	unsigned char *ep = buf + len;

	while (state->ivcount < 16)

	{

		int c = fz_read_byte(state->chain);

		if (c < 0)

			return fz_throw("premature end in aes filter");

		state->iv[state->ivcount++] = c;

	}

	while (state->rp < state->wp && p < ep)

		*p++ = *state->rp++;

	while (p < ep)

	{

		int n = fz_read(state->chain, state->bp, 16);

		if (n < 0)

			return fz_rethrow(n, "read error in aes filter");

		else if (n == 0)

			return p - buf;

		else if (n < 16)

			return fz_throw("partial block in aes filter");

		aes_crypt_cbc(&state->aes, AES_DECRYPT, 16, state->iv, state->bp, state->bp);

		state->rp = state->bp;

		state->wp = state->bp + 16;

		/* strip padding at end of file */

		if (fz_is_eof(state->chain))

		{

			int pad = state->bp[15];

			if (pad < 1 || pad > 16)

				return fz_throw("aes padding out of range: %d", pad);

			state->wp -= pad;

		}

		while (state->rp < state->wp && p < ep)

			*p++ = *state->rp++;

	}

	return p - buf;

}

static void

close_aesd(fz_stream *stm)

{

	fz_aesd *state = stm->state;

	fz_close(state->chain);

	fz_free(state);

}

fz_stream *

fz_open_aesd(fz_stream *chain, unsigned char *key, unsigned keylen)

{

	fz_aesd *state;

	state = fz_malloc(sizeof(fz_aesd));

	state->chain = chain;

	aes_setkey_dec(&state->aes, key, keylen * 8);

	state->ivcount = 0;

	state->rp = state->bp;

	state->wp = state->bp;

	return fz_new_stream(state, read_aesd, close_aesd);

}