Initial commit.

16 files changed, 952 insertions, 0 deletions

diff --git a/src/base64.c b/src/base64.c
new file mode 100644
index 0000000..6a2c873
--- /dev/null
+++ b/src/base64.c
@@ -0,0 +1,95 @@
+#include "base64.h"
+
+static void
+base64_decode_block(const char *src, char *dest)
+{
+	int i;
+	char buf[4];
+
+	/* Convert base 64 characters into values. */
+	/* Supports ASCII and EBCDIC systems. */
+	for (i = 0; i < 4; ++i) {
+		if (src[i] >= 'A' && src[i] <= 'I') {
+			buf[i] = src[i] - 'A' + 0;
+		} else if (src[i] >= 'J' && src[i] <= 'R') {
+			buf[i] = src[i] - 'J' + 9;
+		} else if (src[i] >= 'S' && src[i] <= 'Z') {
+			buf[i] = src[i] - 'S' + 18;
+		} else if (src[i] >= 'a' && src[i] <= 'i') {
+			buf[i] = src[i] - 'a' + 26;
+		} else if (src[i] >= 'j' && src[i] <= 'r') {
+			buf[i] = src[i] - 'j' + 35;
+		} else if (src[i] >= 's' && src[i] <= 'z') {
+			buf[i] = src[i] - 's' + 44;
+		} else if (src[i] >= '0' && src[i] <= '9') {
+			buf[i] = src[i] - '0' + 52;
+		} else if (src[i] == '+') {
+			buf[i] = 62;
+		} else if (src[i] == '/') {
+			buf[i] = 63;
+		} else {
+			buf[i] = '\0';
+		}
+	}
+
+	/* Map four decoded value bytes into three output bytes. */
+	dest[0] = (buf[0] << 2) | (buf[1] >> 4);
+	dest[1] = (buf[1] << 4) | (buf[2] >> 2);
+	dest[2] = (buf[2] << 6) | (buf[3] >> 0);
+}
+	
+void
+base64_decode(const char *src, char *dest, size_t dest_len)
+{
+	size_t i;
+
+	/* Decode the input one entire block at a time. */
+	for (i = 0; i < (dest_len - 1) / 3; ++i) {
+		if (src[i * 4] == '\0' || 
+				src[i * 4 + 1] == '\0' || 
+				src[i * 4 + 2] == '\0' || 
+				src[i * 4 + 3] == '\0') {
+			dest[i * 3] = '\0';
+			break;
+		}
+		base64_decode_block(src + i * 4, dest + i * 3);
+	}
+
+	/* Ensure NUL termination. */
+	dest[dest_len - 1] = '\0';
+}
+
+#if 0
+int
+main()
+{
+	char dest[1024];
+	base64_decode(
+			"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5v"
+			"dCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1"
+			"dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Np"
+			"b24gZnJvbSBvdGhlciBhbmltYWxzLCB3"
+			"aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1p"
+			"bmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFu"
+			"Y2Ugb2YgZGVsaWdodCBpbiB0aGUgY29u"
+			"dGludWVkIGFuZCBpbmRlZmF0aWdhYmxl"
+			"IGdlbmVyYXRpb24gb2Yga25vd2xlZGdl"
+			"LCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhl"
+			"bWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVh"
+			"c3VyZS4=", dest, 1024);
+	printf("Decoded string: \"%s\"\n", dest);
+	base64_decode("YW55IGNhcm5hbCBwbGVhc3VyZS4=", dest, 1024);
+	printf("Decoded string: \"%s\"\n", dest);
+	base64_decode("YW55IGNhcm5hbCBwbGVhc3VyZQ==", dest, 1024);
+	printf("Decoded string: \"%s\"\n", dest);
+	base64_decode("YW55IGNhcm5hbCBwbGVhc3Vy", dest, 1024);
+	printf("Decoded string: \"%s\"\n", dest);
+	base64_decode("YW55IGNhcm5hbCBwbGVhc3U=", dest, 1024);
+	printf("Decoded string: \"%s\"\n", dest);
+	base64_decode("YW55IGNhcm5hbCBwbGVhcw==", dest, 1024);
+	printf("Decoded string: \"%s\"\n", dest);
+	base64_decode("YW55IGNhcm5hbCBwbGVhcw==", dest, 4);
+	printf("Decoded string: \"%s\"\n", dest);
+	return 0;
+}
+#endif
diff --git a/src/base64.h b/src/base64.h
new file mode 100644
index 0000000..b56b9db
--- /dev/null
+++ b/src/base64.h
@@ -0,0 +1,8 @@
+#ifndef BASE64_H
+#define BASE64_H
+
+#include <stdlib.h>
+
+void base64_decode(const char *src, char *dest, size_t dest_len);
+
+#endif
diff --git a/src/compression.c b/src/compression.c
new file mode 100644
index 0000000..cf88de6
--- /dev/null
+++ b/src/compression.c
@@ -0,0 +1,226 @@
+#include <stdlib.h>
+#include <string.h>
+#include <zlib.h>
+#include "logging.h"
+
+static void
+zlib_err(int status)
+{
+	switch (status) {
+		case Z_OK:
+		case Z_STREAM_END:
+			break;
+		case Z_MEM_ERROR:
+			err(1, "zlib error: out of memory");
+			break;
+		case Z_VERSION_ERROR:
+			err(1, "zlib error: incompatible library version");
+			break;
+		case Z_STREAM_ERROR:
+			err(1, "zlib error: invalid stream");
+			break;
+		case Z_NEED_DICT:
+			err(1, "zlib error: need dictionary");
+			break;
+		case Z_DATA_ERROR:
+			err(1, "zlib error: corrupted data");
+			break;
+		case Z_BUF_ERROR:
+			err(1, "zlib error: buffer error");
+			break;
+		default:
+			err(1, "zlib error: unknown");
+			break;
+	}
+}
+
+void
+decompress(const char *src, size_t src_len, char *dest, size_t dest_len)
+{
+	z_stream d_stream;
+
+	d_stream.zalloc = Z_NULL;
+	d_stream.zfree = Z_NULL;
+	d_stream.opaque = Z_NULL;
+	d_stream.next_in = (Bytef *) src;
+	d_stream.avail_in = src_len;
+	d_stream.next_out = (Bytef *) dest;
+	d_stream.avail_out = dest_len;
+
+	debug("Initializing inflation stream...");
+	zlib_err(inflateInit2(&d_stream, 15 + 32));
+
+	debug("Inflating %d bytes into up to %d bytes...", src_len, dest_len);
+	zlib_err(inflate(&d_stream, Z_NO_FLUSH));
+
+	debug("Ending inflation stream...");
+	zlib_err(inflateEnd(&d_stream));
+}
+
+#if 0
+#include <stdio.h>
+#include "base64.h"
+
+int
+main()
+{
+	char decoded_data[4801], compressed_data[4801], decompressed_data[4801];
+
+	base64_decode(
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAAAMAAAADQAAAA0AAAANAAAADQAAAA0AAABvAAAA"
+			"HQAAAB0AAAAeAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAAAcAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAeAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAAAcAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAeAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAAAcAAAAHQAAAB0AAACAAAAALQAAAC0AAAAtAAAA"
+			"LQAAAC0AAAAuAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAAAcAAAAHQAAAB0AAAAeAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"TwAAAFAAAAAMAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAAA"
+			"DQAAAA0AAAANAAAADQAAAA4AAABPAAAAUAAAAE8AAABQAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAAXwAAAGAAAAAcAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB4AAABfAAAA"
+			"YAAAAF8AAABgAAAATwAAAFAAAAAMAAAADQAAAA0AAAANAAAA"
+			"DQAAAA0AAABvAAAAHQAAAB0AAAAeAAAATwAAAFAAAAAcAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB4AAABPAAAAUAAAAE8AAABQAAAAXwAAAGAAAAAcAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAeAAAA"
+			"XwAAAGAAAAAcAAAAHQAAAB0AAACAAAAALQAAAC0AAAAtAAAA"
+			"LQAAAH8AAAAdAAAAHQAAAB4AAABfAAAAYAAAAF8AAABgAAAA"
+			"TwAAAFAAAAAcAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB0AAAAeAAAATwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"TwAAAFAAAABPAAAAUAAAABwAAAAdAAAAHQAAAB4AAABPAAAA"
+			"UAAAAE8AAABQAAAAXwAAAGAAAAAcAAAAHQAAAB0AAACAAAAA"
+			"LQAAAC0AAAAtAAAALQAAAC0AAAAuAAAAXwAAAGAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAAXwAAAGAAAABfAAAAYAAAABwAAAAdAAAA"
+			"HQAAAB4AAABfAAAAYAAAAF8AAABgAAAATwAAAFAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAATwAAAFAAAABPAAAA"
+			"UAAAABwAAAAdAAAAHQAAAB4AAABPAAAAUAAAAE8AAABQAAAA"
+			"XwAAAGAAAAAcAAAAHQAAAB0AAAAeAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"XwAAAGAAAABfAAAAYAAAABwAAAAdAAAAHQAAAB4AAABfAAAA"
+			"YAAAAF8AAABgAAAATwAAAFAAAAAcAAAAHQAAAB0AAAAeAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAATwAAAFAAAABPAAAAUAAAABwAAAAdAAAA"
+			"HQAAAB4AAABPAAAAUAAAAE8AAABQAAAAXwAAAGAAAAAcAAAA"
+			"HQAAAB0AAAAeAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAAAcAAAAHQAAAB0AAAAeAAAAXwAAAGAAAABfAAAA"
+			"YAAAABwAAAAdAAAAHQAAAB4AAABfAAAAYAAAAF8AAABgAAAA"
+			"TwAAAFAAAAAcAAAAHQAAAB0AAABwAAAADQAAAA0AAAANAAAA"
+			"DQAAAA0AAAANAAAADQAAAA0AAABvAAAAHQAAAB0AAAAeAAAA"
+			"TwAAAFAAAABPAAAAUAAAABwAAAAdAAAAHQAAAB4AAABPAAAA"
+			"UAAAAE8AAABQAAAAXwAAAGAAAAAcAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB0AAAAeAAAAXwAAAGAAAABfAAAAYAAAABwAAAAdAAAA"
+			"HQAAAB4AAABfAAAAYAAAAF8AAABgAAAATwAAAFAAAAAcAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB0AAAAdAAAAHQAAAB0AAAAeAAAATwAAAFAAAABPAAAA"
+			"UAAAABwAAAAdAAAAHQAAAB4AAABPAAAAUAAAAE8AAABQAAAA"
+			"XwAAAGAAAAAsAAAALQAAAC0AAAAtAAAALQAAAC0AAAAtAAAA"
+			"LQAAAC0AAAAtAAAALQAAAC0AAAAtAAAALQAAAC0AAAAuAAAA"
+			"XwAAAGAAAABfAAAAYAAAABwAAAAdAAAAHQAAAB4AAABfAAAA"
+			"YAAAAF8AAABgAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAABwAAAAdAAAA"
+			"HQAAAB4AAABPAAAAUAAAAE8AAABQAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAABwAAAAdAAAAHQAAAB4AAABfAAAAYAAAAF8AAABgAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAABwAAAAdAAAAHQAAAB4AAABPAAAA"
+			"UAAAAE8AAABQAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAABwAAAAdAAAA"
+			"HQAAAB4AAABfAAAAYAAAAF8AAABgAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAADAAAAA0AAAANAAAA"
+			"DQAAAG8AAAAdAAAAHQAAAB4AAABPAAAAUAAAAE8AAABQAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"HAAAAB0AAAAdAAAAHQAAAB0AAAAdAAAAHQAAAB4AAABfAAAA"
+			"YAAAAF8AAABgAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAAHAAAAB0AAAAdAAAAHQAAAB0AAAAdAAAA"
+			"HQAAAB4AAABPAAAAUAAAAE8AAABQAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAHAAAAB0AAAAdAAAA"
+			"gAAAAC0AAAAtAAAALQAAAC4AAABfAAAAYAAAAF8AAABgAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"HAAAAB0AAAAdAAAAHgAAAE8AAABQAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAHAAAAB0AAAAdAAAAHgAAAF8AAABgAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAATwAAAFAAAABPAAAA"
+			"UAAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"TwAAAFAAAABPAAAAUAAAAE8AAABQAAAAHAAAAB0AAAAdAAAA"
+			"HgAAAE8AAABQAAAATwAAAFAAAABPAAAAUAAAAE8AAABQAAAA"
+			"XwAAAGAAAABfAAAAYAAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAAXwAAAGAAAABfAAAAYAAAAF8AAABgAAAA"
+			"HAAAAB0AAAAdAAAAHgAAAF8AAABgAAAAXwAAAGAAAABfAAAA"
+			"YAAAAF8AAABgAAAA",
+			decoded_data, 4801);
+	base64_decode(
+			"eJztlsERAjEIRSlArUCtwLWVtQPtQDtwS18OHpwdIvwv7EFz"
+			"+MMhkyEvgR9GEbmoRjDuVYeXjsT+q+pGxGVedD96zl/n3ai2"
+			"hu7FvO9cLVXwRvNW8k6qwdC5mJfhyuBl3rHzdl6Et+VjlnaJ"
+			"vBE/+XRPrA+jeVu8qA97PvYM8qI+7NW5t876sFfn3jrbpxW8"
+			"kT7tvN/zPsT3IG++YnhRZfEyeVnek9g9G5E1X0V5s2OUNzt2"
+			"3hre5f/t9XcFHzJvZL4nMm9k8k7i9/da9bsGb+Q/+zfeGUt8"
+			"RgE=",
+			compressed_data, 4801);
+	decompress(compressed_data, decompressed_data, 4801);
+	decoded_data[4800] = '\0';
+	compressed_data[4800] = '\0';
+	decompressed_data[4800] = '\0';
+	if (strncmp(decoded_data, decompressed_data, 4800) == 0) {
+		puts("Matched!");
+	} else {
+		puts("No match. :(");
+	}
+
+	return 0;
+}
+#endif
diff --git a/src/compression.h b/src/compression.h
new file mode 100644
index 0000000..387d634
--- /dev/null
+++ b/src/compression.h
@@ -0,0 +1,6 @@
+#ifndef COMPRESSION_H
+#define COMPRESSION_H
+
+void decompress(const char *src, size_t src_len, char *dest, size_t dest_len);
+	
+#endif
diff --git a/src/image.c b/src/image.c
new file mode 100644
index 0000000..557e1de
--- /dev/null
+++ b/src/image.c
@@ -0,0 +1,22 @@
+#include <SDL.h>
+#include <SDL_image.h>
+#include "logging.h"
+#include "image.h"
+	
+SDL_Surface *
+load_png(const char *path)
+{
+	SDL_RWops *rwops;
+	SDL_Surface *img;
+
+	debug("Loading PNG image \"%s\"...", path);
+
+	rwops = SDL_RWFromFile(path, "rb");
+	img = IMG_LoadPNG_RW(rwops);
+	if (!img) {
+		err(1, "Failed to load image \"%s\" (%s)",
+				path, IMG_GetError());
+	}
+
+	return img;
+}
diff --git a/src/image.h b/src/image.h
new file mode 100644
index 0000000..0de4083
--- /dev/null
+++ b/src/image.h
@@ -0,0 +1,6 @@
+#ifndef IMAGE_H
+#define IMAGE_H
+
+SDL_Surface *load_png(const char *path);
+
+#endif
diff --git a/src/init.c b/src/init.c
new file mode 100644
index 0000000..f893d1d
--- /dev/null
+++ b/src/init.c
@@ -0,0 +1,36 @@
+#include <SDL.h>
+#include <SDL_image.h>
+#include "init.h"
+#include "logging.h"
+
+void
+init(void)
+{
+	debug("Initializing SDL...");
+	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) == -1) {
+		err(1, "Failed to initialize SDL (%s)", SDL_GetError());
+	}
+
+	debug("Initializing SDL_Image...");
+	if (IMG_Init(IMG_INIT_PNG) != IMG_INIT_PNG) {
+		err(1, "Failed to initialize SDL_Image (%s)", IMG_GetError());
+	}
+
+	debug("Setting video mode...");
+	screen = SDL_SetVideoMode(240, 160, 8, SDL_SWSURFACE | SDL_ANYFORMAT);
+	if (screen == NULL) {
+		err(1, "Failed to set video mode (%s)", SDL_GetError());
+	}
+}
+
+void
+quit(int status)
+{
+	debug("Quitting SDL_Image...");
+	IMG_Quit();
+
+	debug("Quitting SDL...");
+	SDL_Quit();
+
+	exit(status);
+}
diff --git a/src/init.h b/src/init.h
new file mode 100644
index 0000000..f04b1fe
--- /dev/null
+++ b/src/init.h
@@ -0,0 +1,11 @@
+#ifndef INIT_H
+#define INIT_H
+
+#include <SDL.h>
+
+SDL_Surface *screen;
+
+void init(void);
+void quit(int status);
+
+#endif
diff --git a/src/layer.h b/src/layer.h
new file mode 100644
index 0000000..126c3d9
--- /dev/null
+++ b/src/layer.h
@@ -0,0 +1,20 @@
+#ifndef LAYER_H
+#define LAYER_H
+
+#include <SDL_stdinc.h>
+
+const int LAYER_GROUND = 0;
+const int LAYER_OBJ_LOW = 1;
+const int LAYER_CHAR_BOT = 2;
+const int LAYER_OBJ_MID = 3;
+const int LAYER_CHAR_TOP = 4;
+const int LAYER_OBJ_HIGH = 5;
+const int LAYER_WEATHER = 6;
+
+struct layer {
+	char *name;
+	Uint32 *tiles;
+	struct layer *next;
+};
+
+#endif
diff --git a/src/logging.c b/src/logging.c
new file mode 100644
index 0000000..be03528
--- /dev/null
+++ b/src/logging.c
@@ -0,0 +1,43 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "init.h"
+#include "logging.h"
+
+void
+debug(const char *fmt, ...)
+{
+	va_list ap;
+
+	printf("Debug: ");
+	va_start(ap, fmt);
+	vprintf(fmt, ap);
+	va_end(ap);
+	putchar('\n');
+}
+
+void
+warn(const char *fmt, ...)
+{
+	va_list ap;
+
+	printf("Warning: ");
+	va_start(ap, fmt);
+	vprintf(fmt, ap);
+	va_end(ap);
+	putchar('\n');
+}
+
+void
+err(int status, const char *fmt, ...)
+{
+	va_list ap;
+
+	printf("Error: ");
+	va_start(ap, fmt);
+	vprintf(fmt, ap);
+	va_end(ap);
+	putchar('\n');
+
+	quit(status);
+}
diff --git a/src/logging.h b/src/logging.h
new file mode 100644
index 0000000..e03dad6
--- /dev/null
+++ b/src/logging.h
@@ -0,0 +1,8 @@
+#ifndef LOGGING_H
+#define LOGGING_H
+
+void debug(const char *fmt, ...);
+void warn(const char *fmt, ...);
+void err(int status, const char *fmt, ...);
+
+#endif
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..b30d0b2
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,65 @@
+#include <SDL.h>
+#include "init.h"
+#include "logging.h"
+#include "image.h"
+#include "tmx.h"
+
+int
+main(void)
+{
+	SDL_Surface *img;
+	SDL_Rect imgrect, surfacerect;
+
+	init();
+
+	tmx_load("data/forest1.tmx");
+
+	img = load_png("../forest-6-layer-test_ground.png");
+	imgrect.w = 240;
+	imgrect.h = 160;
+	surfacerect.x = 0;
+	surfacerect.y = 0;
+	surfacerect.w = 240;
+	surfacerect.h = 160;
+
+	imgrect.x = 208;
+	imgrect.y = 480;
+	SDL_BlitSurface(img, &imgrect, screen, &surfacerect);
+	SDL_Flip(screen);
+	SDL_Delay(500);
+
+	imgrect.x = 208;
+	imgrect.y = 464;
+	SDL_BlitSurface(img, &imgrect, screen, &surfacerect);
+	SDL_Flip(screen);
+	SDL_Delay(500);
+
+	imgrect.x = 224;
+	imgrect.y = 464;
+	SDL_BlitSurface(img, &imgrect, screen, &surfacerect);
+	SDL_Flip(screen);
+	SDL_Delay(500);
+
+	imgrect.x = 240;
+	imgrect.y = 464;
+	SDL_BlitSurface(img, &imgrect, screen, &surfacerect);
+	SDL_Flip(screen);
+	SDL_Delay(500);
+
+	imgrect.x = 256;
+	imgrect.y = 464;
+	SDL_BlitSurface(img, &imgrect, screen, &surfacerect);
+	SDL_Flip(screen);
+	SDL_Delay(500);
+
+	imgrect.x = 256;
+	imgrect.y = 448;
+	SDL_BlitSurface(img, &imgrect, screen, &surfacerect);
+	SDL_Flip(screen);
+	SDL_Delay(500);
+
+	quit(0);
+
+	/* Control doesn't actually reach here. */
+	return 0;
+}
diff --git a/src/map.h b/src/map.h
new file mode 100644
index 0000000..554b428
--- /dev/null
+++ b/src/map.h
@@ -0,0 +1,16 @@
+#ifndef MAP_H
+#define MAP_H
+
+#include "tileset.h"
+#include "layer.h"
+
+struct map {
+	int width;
+	int height;
+	int tilewidth;
+	int tileheight;
+	struct tileset *tilesets;
+	struct layer *layers;
+};
+
+#endif
diff --git a/src/tileset.h b/src/tileset.h
new file mode 100644
index 0000000..2fd384a
--- /dev/null
+++ b/src/tileset.h
@@ -0,0 +1,12 @@
+#ifndef TILESET_H
+#define TILESET_H
+
+struct tileset {
+	int firstgid;
+	int tilewidth;
+	int tileheight;
+	SDL_Surface *image;
+	struct tileset *next;
+};
+
+#endif
diff --git a/src/tmx.c b/src/tmx.c
new file mode 100644
index 0000000..0e401b3
--- /dev/null
+++ b/src/tmx.c
@@ -0,0 +1,370 @@
+#include <stdio.h>
+#include <string.h>
+#include <libgen.h>
+#include <expat.h>
+#include <SDL.h>
+#include "logging.h"
+#include "base64.h"
+#include "compression.h"
+#include "map.h"
+#include "image.h"
+
+struct tmx {
+	char *dirname;
+	struct map *map;
+	enum {
+		TMX_PARSING_NONE = 0,
+		TMX_PARSING_MAP,
+		TMX_PARSING_TILESET,
+		TMX_PARSING_IMAGE,
+		TMX_PARSING_LAYER,
+		TMX_PARSING_DATA
+	} parsing;
+	struct tileset *cur_tileset;
+	struct layer *cur_layer;
+	enum {
+		TMX_DATA_ENC_NONE = 0,
+		TMX_DATA_ENC_BASE64,
+		TMX_DATA_ENC_CSV
+	} data_encoding;
+	enum {
+		TMX_DATA_COMP_NONE = 0,
+		TMX_DATA_COMP_GZIP,
+		TMX_DATA_COMP_ZLIB
+	} data_compression;
+	char *layer_data;
+};
+
+#define foreach_tmx_attr(attr)                                                \
+	for (; (attr)[0] != NULL; (attr) += 2)
+
+#define tmx_get_int_attr(attr, name, p)                                       \
+	do {                                                                  \
+		if (strcmp((attr)[0], (name)) == 0) {                         \
+			if (sscanf((attr)[1], "%d", (p)) != 1) {              \
+				err(1, "Invalid \"%s\" attribute", (name));   \
+			}                                                     \
+		}                                                             \
+	} while (0);
+
+#define tmx_get_string_attr(attr, name, p)                                    \
+	do {                                                                  \
+		if (strcmp((attr)[0], (name)) == 0) {                         \
+			(p) = strdup((attr)[1]);                              \
+		}                                                             \
+	} while (0);
+
+static void
+tmx_start_map(struct tmx *cur_tmx, const char **attr)
+{
+	if (cur_tmx->map != NULL) {
+		err(1, "Found multiple maps in TMX file");
+	}
+
+	cur_tmx->map = malloc(sizeof(*cur_tmx->map));
+	if (cur_tmx->map == NULL) {
+		err(1, "Failed to allocate map");
+	}
+	memset(cur_tmx->map, 0, sizeof(*cur_tmx->map));
+
+	foreach_tmx_attr (attr) {
+		tmx_get_int_attr(attr, "width", &cur_tmx->map->width);
+		tmx_get_int_attr(attr, "height", &cur_tmx->map->height);
+		tmx_get_int_attr(attr, "tilewidth", &cur_tmx->map->tilewidth);
+		tmx_get_int_attr(attr, "tileheight", &cur_tmx->map->tileheight);
+	}
+}
+
+static void
+tmx_start_tileset(struct tmx *cur_tmx, const char **attr)
+{
+	struct tileset *new_tileset;
+
+	if (cur_tmx->map == NULL) {
+		err(1, "Malformed TMX file");
+	}
+
+	new_tileset = malloc(sizeof(*new_tileset));
+	if (new_tileset == NULL) {
+		err(1, "Failed to allocate tileset");
+	}
+	memset(new_tileset, 0, sizeof(*new_tileset));
+
+	if (cur_tmx->cur_tileset == NULL) {
+		cur_tmx->map->tilesets = new_tileset;
+	} else {
+		cur_tmx->cur_tileset->next = new_tileset;
+	}
+	cur_tmx->cur_tileset = new_tileset;
+
+	foreach_tmx_attr (attr) {
+		tmx_get_int_attr(attr, "firstgid",
+				&cur_tmx->cur_tileset->firstgid);
+		tmx_get_int_attr(attr, "tilewidth",
+				&cur_tmx->cur_tileset->tilewidth);
+		tmx_get_int_attr(attr, "tileheight",
+				&cur_tmx->cur_tileset->tileheight);
+	}
+
+	/* TODO: Parse tilesets referenced in "source" attributes. */
+}
+
+static void
+tmx_start_image(struct tmx *cur_tmx, const char **attr)
+{
+	char *source;
+	char *path;
+
+	if (cur_tmx->cur_tileset == NULL) {
+		err(1, "Malformed TMX file");
+	}
+
+	foreach_tmx_attr (attr) {
+		tmx_get_string_attr(attr, "source", source);
+	}
+
+	/* TODO: Move to end tag handler and check for "loadimage" property. */
+	path = malloc(strlen(cur_tmx->dirname) + strlen(source) + 2);
+	if (path == NULL) {
+		err(1, "Failed to allocate resource path string");
+	}
+	sprintf(path, "%s/%s", cur_tmx->dirname, source);
+	cur_tmx->cur_tileset->image = load_png(path);
+	free(path);
+
+	debug("  Found tileset with firstgid %d and source \"%s\"",
+			cur_tmx->cur_tileset->firstgid, source);
+
+	free(source);
+}
+
+static void
+tmx_start_layer(struct tmx *cur_tmx, const char **attr)
+{
+	struct layer *new_layer;
+
+	if (cur_tmx->map == NULL) {
+		err(1, "Malformed TMX file");
+	}
+
+	new_layer = malloc(sizeof(*new_layer));
+	if (new_layer == NULL) {
+		err(1, "Failed to allocate layer");
+	}
+	memset(new_layer, 0, sizeof(*new_layer));
+
+	if (cur_tmx->cur_layer == NULL) {
+		cur_tmx->map->layers = new_layer;
+	} else {
+		cur_tmx->cur_layer->next = new_layer;
+	}
+	cur_tmx->cur_layer = new_layer;
+
+	foreach_tmx_attr (attr) {
+		tmx_get_string_attr(attr, "name", cur_tmx->cur_layer->name);
+	}
+
+	debug("  Found layer with name \"%s\"", cur_tmx->cur_layer->name);
+}
+
+static void
+tmx_start_data(struct tmx *cur_tmx, const char **attr)
+{
+	if (cur_tmx->cur_layer == NULL) {
+		err(1, "Malformed TMX file");
+	}
+
+	foreach_tmx_attr (attr) {
+		if (strcmp(attr[0], "encoding") == 0) {
+			if (strcmp(attr[1], "base64") == 0) {
+				cur_tmx->data_encoding = TMX_DATA_ENC_BASE64;
+			} else if (strcmp(attr[1], "csv") == 0) {
+				cur_tmx->data_encoding = TMX_DATA_ENC_CSV;
+			} else {
+				err(1, "Unsupported data encoding in TMX file");
+			}
+		} else if (strcmp(attr[0], "compression") == 0) {
+			if (strcmp(attr[1], "gzip") == 0) {
+				cur_tmx->data_compression = TMX_DATA_COMP_GZIP;
+			} else if (strcmp(attr[1], "zlib") == 0) {
+				cur_tmx->data_compression = TMX_DATA_COMP_ZLIB;
+			} else {
+				err(1, "Unsupported compression in TMX file");
+			}
+		}
+	}
+}
+
+static void XMLCALL
+tmx_start(void *data, const char *el, const char **attr)
+{
+	struct tmx *cur_tmx;
+
+	cur_tmx = (struct tmx *) data;
+
+	if (strcmp(el, "map") == 0) {
+		tmx_start_map(cur_tmx, attr);
+		cur_tmx->parsing = TMX_PARSING_MAP;
+	} else if (strcmp(el, "tileset") == 0) {
+		tmx_start_tileset(cur_tmx, attr);
+		cur_tmx->parsing = TMX_PARSING_TILESET;
+	} else if (strcmp(el, "image") == 0) {
+		tmx_start_image(cur_tmx, attr);
+		cur_tmx->parsing = TMX_PARSING_IMAGE;
+	} else if (strcmp(el, "layer") == 0) {
+		tmx_start_layer(cur_tmx, attr);
+		cur_tmx->parsing = TMX_PARSING_LAYER;
+	} else if (strcmp(el, "data") == 0) {
+		tmx_start_data(cur_tmx, attr);
+		cur_tmx->parsing = TMX_PARSING_DATA;
+	}
+
+	/* TODO: Handle objectgroup, object, properties, and property tags. */
+}
+
+static void
+tmx_end_data(struct tmx *cur_tmx)
+{
+	size_t decoded_len;
+	size_t decomp_len;
+	char *decoded_buf;
+	char *decomp_buf;
+
+	decoded_len = strlen(cur_tmx->layer_data);
+
+	decomp_len = 4 * cur_tmx->map->width * cur_tmx->map->height;
+	debug("  Expected map data size: %d", decomp_len);
+
+	decoded_buf = malloc(decoded_len + 1);
+	if (decoded_buf == NULL) {
+		err(1, "Failed to allocate map layer data buffer");
+	}
+
+	if (cur_tmx->data_encoding == TMX_DATA_ENC_BASE64) {
+		debug("  Decoding base 64 layer data...");
+		base64_decode(cur_tmx->layer_data,
+				decoded_buf, decoded_len + 1);
+	}
+
+	if (cur_tmx->data_compression == TMX_DATA_COMP_NONE) {
+		debug("  Layer data already decompressed");
+		decomp_buf = decoded_buf;
+	} else if (cur_tmx->data_compression == TMX_DATA_COMP_ZLIB) {
+		debug("  Decompressing layer data with zlib...");
+		decomp_buf = malloc(decomp_len);
+		if (decomp_buf == NULL) {
+			err(1, "Failed to allocate map layer data buffer");
+		}
+		decompress(decoded_buf, decoded_len, decomp_buf, decomp_len);
+		free(decoded_buf);
+	} else if (cur_tmx->data_compression == TMX_DATA_COMP_GZIP) {
+		debug("  Decompressing layer data with gzip...");
+		decomp_buf = malloc(decomp_len);
+		if (decomp_buf == NULL) {
+			err(1, "Failed to allocate map layer data buffer");
+		}
+		decompress(decoded_buf, decoded_len, decomp_buf, decomp_len);
+		free(decoded_buf);
+	}
+
+	free(cur_tmx->layer_data);
+
+	cur_tmx->cur_layer->tiles = (Uint32 *) decomp_buf;
+}
+
+static void XMLCALL
+tmx_end(void *data, const char *el)
+{
+	struct tmx *cur_tmx;
+
+	cur_tmx = (struct tmx *) data;
+
+	if (strcmp(el, "data") == 0) {
+		tmx_end_data(cur_tmx);
+	}
+
+	cur_tmx->parsing = TMX_PARSING_NONE;
+}
+
+static void XMLCALL
+tmx_data(void *data, const char *s, int len)
+{
+	struct tmx *cur_tmx;
+	char *s_z;
+	char *s_z_trimmed, *s_z_trimmed_end;
+
+	cur_tmx = (struct tmx *) data;
+
+	if (cur_tmx->parsing != TMX_PARSING_DATA) {
+		return;
+	}
+
+	s_z = s_z_trimmed = strndup(s, len);
+
+	while(isspace(*s_z_trimmed)) {
+		++s_z_trimmed;
+		--len;
+	}
+	if (*s_z_trimmed == '\0') {
+		return;
+	}
+	s_z_trimmed_end = s_z_trimmed + len - 1;
+	while (s_z_trimmed_end > s_z_trimmed && isspace(*s_z_trimmed_end)) {
+		--s_z_trimmed_end;
+	}
+	*(s_z_trimmed_end + 1) = '\0';
+
+	cur_tmx->layer_data = strdup(s_z_trimmed);
+
+	free(s_z);
+}
+
+struct map *
+tmx_load(const char *path)
+{
+	XML_Parser p;
+	struct tmx cur_tmx;
+	char *path_dup;
+	FILE *tmx_fp;
+	void *tmx_buf;
+	size_t len;
+
+	debug("Parsing TMX file \"%s\"...", path);
+
+	p = XML_ParserCreate(NULL);
+	if (p == NULL) {
+		err(1, "Failed to create TMX parser");
+	}
+
+	XML_SetElementHandler(p, tmx_start, tmx_end);
+	XML_SetCharacterDataHandler(p, tmx_data);
+
+	memset(&cur_tmx, 0, sizeof(cur_tmx));
+	path_dup = strdup(path);
+	cur_tmx.dirname = dirname(path_dup);
+	XML_SetUserData(p, &cur_tmx);
+
+	tmx_fp = fopen(path, "rb");
+	if (tmx_fp == NULL) {
+		err(1, "Failed to open TMX file");
+	}
+
+	tmx_buf = XML_GetBuffer(p, 8192);
+	if (tmx_buf == NULL) {
+		err(1, "Failed to create TMX parse buffer");
+	}
+
+	while (!feof(tmx_fp)) {
+		len = fread(tmx_buf, 1, 8192, tmx_fp);
+		if (XML_ParseBuffer(p, len, feof(tmx_fp)) == XML_STATUS_ERROR) {
+			err(1, "Failed to parse TMX file (%s)",
+					XML_ErrorString(XML_GetErrorCode(p)));
+		}
+	}
+
+	fclose(tmx_fp);
+
+	free(path_dup);
+
+	return cur_tmx.map;
+}
diff --git a/src/tmx.h b/src/tmx.h
new file mode 100644
index 0000000..e2ab766
--- /dev/null
+++ b/src/tmx.h
@@ -0,0 +1,8 @@
+#ifndef TMX_H
+#define TMX_H
+
+#include "map.h"
+
+struct map *tmx_load(const char *path);
+
+#endif