From 46caaa21ad580ac3f0f74f9fd00a12619a1f2033 Mon Sep 17 00:00:00 2001
From: Allanis <allanis@saracraft.net>
Date: Sun, 3 Feb 2013 17:35:44 +0000
Subject: [PATCH] [Add] First working version of pack!
---
bin/Makefile | 14 +-
src/ship.c | 2 +-
utils/pack/Makefile | 7 +-
utils/pack/main.c | 41 +++++
utils/pack/md5.c | 381 ++++++++++++++++++++++++++++++++++++++++++++
utils/pack/md5.h | 88 ++++++++++
utils/pack/pack | Bin 11311 -> 16715 bytes
utils/pack/pack.c | 283 +++++++++++++++++++++++++-------
utils/pack/pack.h | 17 ++
9 files changed, 769 insertions(+), 64 deletions(-)
create mode 100644 utils/pack/main.c
create mode 100644 utils/pack/md5.c
create mode 100644 utils/pack/md5.h
create mode 100644 utils/pack/pack.h
diff --git a/bin/Makefile b/bin/Makefile
index 77808b5..e2c6b50 100644
--- a/bin/Makefile
+++ b/bin/Makefile
@@ -6,13 +6,10 @@ VERSION = -DVMAJOR=0 -DVMINOR=0 -DVREV=1
OBJS := $(shell find ../src/ -name '*.c' -print)
OBJS := $(OBJS:../src/%.c=../src/%.o)
-DATA = data
-DATAFILES = $(shell find ../gfx/ ../dat/ -name '*.png' -o -name '*.xml' -print)
-
CLUA = -I/usr/include/lua5.1
-CSDL = `sdl-config --cflags`
-CXML = `xml2-config --cflags`
-CTTF = `freetype-config --cflags`
+CSDL = $(shell sdl-config --cflags)
+CXML = $(shell xml2-config --cflags)
+CTTF = $(shell freetype-config --cflags)
CGL =
CFLAGS = -Wall $(CLUA) $(CSDL) $(CXML) $(CTTF) $(CGL) $(VERSION)
ifdef DEBUG
@@ -28,6 +25,9 @@ LDTTF = `freetype-config --libs`
LDGL = -lGL
LDFLAGS = -lm $(LDLUA) $(LDSDL) $(LDXML) $(LDTTF) $(LDGL)
+DATA = data
+DATAFILES = $(shell find ../scripts/ai/ ../gfx/ ../dat/ -name '*.lua' -o -name '*.png' -o -name '*.xml')
+
%.o: ../src/%.c
@gcc -c $(CFLAGS) -o $@ $<
@echo -e "\tCC $@"
@@ -38,7 +38,7 @@ all: data $(OBJS)
data: $(DATAFILES)
@echo -e "\tCreating data..\n"
- @ls -1 $(DATAFILES) | cpio --quiet -o > $(DATA)
+ @ls -1 $(DATAFILES) | cpio --quiet --format crc -o > $(DATA)
clean:
@echo -e "\tRemoving data.."
diff --git a/src/ship.c b/src/ship.c
index f2dc9e4..1bb46b6 100644
--- a/src/ship.c
+++ b/src/ship.c
@@ -1,5 +1,5 @@
#include <string.h>
-#include "libxml/xmlreader.h"
+#include <libxml/xmlreader.h>
#include "log.h"
#include "ship.h"
diff --git a/utils/pack/Makefile b/utils/pack/Makefile
index c7de177..32b8fcc 100644
--- a/utils/pack/Makefile
+++ b/utils/pack/Makefile
@@ -1,4 +1,7 @@
-CFLAGS += -g
+CFLAGS += -O2 -Wall
all:
- $(CC) $(CFLAGS) -o pack pack.c
\ No newline at end of file
+ $(CC) $(CFLAGS) -o pack main.c pack.c md5.c
+
+clean:
+ rm -rf pack
diff --git a/utils/pack/main.c b/utils/pack/main.c
new file mode 100644
index 0000000..b39c2ed
--- /dev/null
+++ b/utils/pack/main.c
@@ -0,0 +1,41 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "pack.h"
+
+#define USAGE "Usage is: %s output input\n", argv[0]
+
+int main(int argc, char** argv) {
+ switch(argc) {
+ case 1:
+ fprintf(stderr, "Missing output file\n");
+ case 2:
+ fprintf(stderr, "Missing input file/s\n");
+ goto usage;
+ break;
+ }
+
+ char* outfile = argv[1];
+ uint32_t nfiles = (uint32_t)argc - 2;
+ argv += 2;
+
+ printf("%d\n", pack_check(outfile));
+ pack_files(outfile, argv, nfiles);
+
+ Packfile packfile;
+
+ printf("%s\n", argv[0]);
+ pack_open(&packfile, outfile, argv[2]);
+
+ char* buf = calloc(100, 1);
+ nfiles = pack_read(&packfile, buf, 100);
+ printf("%d -> <%s>\n", nfiles, buf);
+ free(buf);
+
+ exit(EXIT_SUCCESS);
+
+usage:
+ printf(USAGE);
+ exit(EXIT_SUCCESS);
+}
+
diff --git a/utils/pack/md5.c b/utils/pack/md5.c
new file mode 100644
index 0000000..c35d96c
--- /dev/null
+++ b/utils/pack/md5.c
@@ -0,0 +1,381 @@
+/*
+ Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved.
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ L. Peter Deutsch
+ ghost@aladdin.com
+
+ */
+/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
+/*
+ Independent implementation of MD5 (RFC 1321).
+
+ This code implements the MD5 Algorithm defined in RFC 1321, whose
+ text is available at
+ http://www.ietf.org/rfc/rfc1321.txt
+ The code is derived from the text of the RFC, including the test suite
+ (section A.5) but excluding the rest of Appendix A. It does not include
+ any code or documentation that is identified in the RFC as being
+ copyrighted.
+
+ The original and principal author of md5.c is L. Peter Deutsch
+ <ghost@aladdin.com>. Other authors are noted in the change history
+ that follows (in reverse chronological order):
+
+ 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
+ either statically or dynamically; added missing #include <string.h>
+ in library.
+ 2002-03-11 lpd Corrected argument list for main(), and added int return
+ type, in test program and T value program.
+ 2002-02-21 lpd Added missing #include <stdio.h> in test program.
+ 2000-07-03 lpd Patched to eliminate warnings about "constant is
+ unsigned in ANSI C, signed in traditional"; made test program
+ self-checking.
+ 1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+ 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
+ 1999-05-03 lpd Original version.
+ */
+
+#include "md5.h"
+#include <string.h>
+
+#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */
+#ifdef ARCH_IS_BIG_ENDIAN
+# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#else
+# define BYTE_ORDER 0
+#endif
+
+#define T_MASK ((md5_word_t)~0)
+#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
+#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
+#define T3 0x242070db
+#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
+#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
+#define T6 0x4787c62a
+#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
+#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
+#define T9 0x698098d8
+#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
+#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
+#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
+#define T13 0x6b901122
+#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
+#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
+#define T16 0x49b40821
+#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
+#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
+#define T19 0x265e5a51
+#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
+#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
+#define T22 0x02441453
+#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
+#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
+#define T25 0x21e1cde6
+#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
+#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
+#define T28 0x455a14ed
+#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
+#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
+#define T31 0x676f02d9
+#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
+#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
+#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
+#define T35 0x6d9d6122
+#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
+#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
+#define T38 0x4bdecfa9
+#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
+#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
+#define T41 0x289b7ec6
+#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
+#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
+#define T44 0x04881d05
+#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
+#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
+#define T47 0x1fa27cf8
+#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
+#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
+#define T50 0x432aff97
+#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
+#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
+#define T53 0x655b59c3
+#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
+#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
+#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
+#define T57 0x6fa87e4f
+#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
+#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
+#define T60 0x4e0811a1
+#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
+#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
+#define T63 0x2ad7d2bb
+#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
+
+
+static void
+md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
+{
+ md5_word_t
+ a = pms->abcd[0], b = pms->abcd[1],
+ c = pms->abcd[2], d = pms->abcd[3];
+ md5_word_t t;
+#if BYTE_ORDER > 0
+ /* Define storage only for big-endian CPUs. */
+ md5_word_t X[16];
+#else
+ /* Define storage for little-endian or both types of CPUs. */
+ md5_word_t xbuf[16];
+ const md5_word_t *X;
+#endif
+
+ {
+#if BYTE_ORDER == 0
+ /*
+ * Determine dynamically whether this is a big-endian or
+ * little-endian machine, since we can use a more efficient
+ * algorithm on the latter.
+ */
+ static const int w = 1;
+
+ if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
+#endif
+#if BYTE_ORDER <= 0 /* little-endian */
+ {
+ /*
+ * On little-endian machines, we can process properly aligned
+ * data without copying it.
+ */
+ if (!((data - (const md5_byte_t *)0) & 3)) {
+ /* data are properly aligned */
+ X = (const md5_word_t *)data;
+ } else {
+ /* not aligned */
+ memcpy(xbuf, data, 64);
+ X = xbuf;
+ }
+ }
+#endif
+#if BYTE_ORDER == 0
+ else /* dynamic big-endian */
+#endif
+#if BYTE_ORDER >= 0 /* big-endian */
+ {
+ /*
+ * On big-endian machines, we must arrange the bytes in the
+ * right order.
+ */
+ const md5_byte_t *xp = data;
+ int i;
+
+# if BYTE_ORDER == 0
+ X = xbuf; /* (dynamic only) */
+# else
+# define xbuf X /* (static only) */
+# endif
+ for (i = 0; i < 16; ++i, xp += 4)
+ xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+ }
+#endif
+ }
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+ /* Round 1. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + F(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 7, T1);
+ SET(d, a, b, c, 1, 12, T2);
+ SET(c, d, a, b, 2, 17, T3);
+ SET(b, c, d, a, 3, 22, T4);
+ SET(a, b, c, d, 4, 7, T5);
+ SET(d, a, b, c, 5, 12, T6);
+ SET(c, d, a, b, 6, 17, T7);
+ SET(b, c, d, a, 7, 22, T8);
+ SET(a, b, c, d, 8, 7, T9);
+ SET(d, a, b, c, 9, 12, T10);
+ SET(c, d, a, b, 10, 17, T11);
+ SET(b, c, d, a, 11, 22, T12);
+ SET(a, b, c, d, 12, 7, T13);
+ SET(d, a, b, c, 13, 12, T14);
+ SET(c, d, a, b, 14, 17, T15);
+ SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+ /* Round 2. */
+ /* Let [abcd k s i] denote the operation
+ a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + G(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 1, 5, T17);
+ SET(d, a, b, c, 6, 9, T18);
+ SET(c, d, a, b, 11, 14, T19);
+ SET(b, c, d, a, 0, 20, T20);
+ SET(a, b, c, d, 5, 5, T21);
+ SET(d, a, b, c, 10, 9, T22);
+ SET(c, d, a, b, 15, 14, T23);
+ SET(b, c, d, a, 4, 20, T24);
+ SET(a, b, c, d, 9, 5, T25);
+ SET(d, a, b, c, 14, 9, T26);
+ SET(c, d, a, b, 3, 14, T27);
+ SET(b, c, d, a, 8, 20, T28);
+ SET(a, b, c, d, 13, 5, T29);
+ SET(d, a, b, c, 2, 9, T30);
+ SET(c, d, a, b, 7, 14, T31);
+ SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+ /* Round 3. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + H(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 5, 4, T33);
+ SET(d, a, b, c, 8, 11, T34);
+ SET(c, d, a, b, 11, 16, T35);
+ SET(b, c, d, a, 14, 23, T36);
+ SET(a, b, c, d, 1, 4, T37);
+ SET(d, a, b, c, 4, 11, T38);
+ SET(c, d, a, b, 7, 16, T39);
+ SET(b, c, d, a, 10, 23, T40);
+ SET(a, b, c, d, 13, 4, T41);
+ SET(d, a, b, c, 0, 11, T42);
+ SET(c, d, a, b, 3, 16, T43);
+ SET(b, c, d, a, 6, 23, T44);
+ SET(a, b, c, d, 9, 4, T45);
+ SET(d, a, b, c, 12, 11, T46);
+ SET(c, d, a, b, 15, 16, T47);
+ SET(b, c, d, a, 2, 23, T48);
+#undef SET
+
+ /* Round 4. */
+ /* Let [abcd k s t] denote the operation
+ a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+ t = a + I(b,c,d) + X[k] + Ti;\
+ a = ROTATE_LEFT(t, s) + b
+ /* Do the following 16 operations. */
+ SET(a, b, c, d, 0, 6, T49);
+ SET(d, a, b, c, 7, 10, T50);
+ SET(c, d, a, b, 14, 15, T51);
+ SET(b, c, d, a, 5, 21, T52);
+ SET(a, b, c, d, 12, 6, T53);
+ SET(d, a, b, c, 3, 10, T54);
+ SET(c, d, a, b, 10, 15, T55);
+ SET(b, c, d, a, 1, 21, T56);
+ SET(a, b, c, d, 8, 6, T57);
+ SET(d, a, b, c, 15, 10, T58);
+ SET(c, d, a, b, 6, 15, T59);
+ SET(b, c, d, a, 13, 21, T60);
+ SET(a, b, c, d, 4, 6, T61);
+ SET(d, a, b, c, 11, 10, T62);
+ SET(c, d, a, b, 2, 15, T63);
+ SET(b, c, d, a, 9, 21, T64);
+#undef SET
+
+ /* Then perform the following additions. (That is increment each
+ of the four registers by the value it had before this block
+ was started.) */
+ pms->abcd[0] += a;
+ pms->abcd[1] += b;
+ pms->abcd[2] += c;
+ pms->abcd[3] += d;
+}
+
+void
+md5_init(md5_state_t *pms)
+{
+ pms->count[0] = pms->count[1] = 0;
+ pms->abcd[0] = 0x67452301;
+ pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
+ pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
+ pms->abcd[3] = 0x10325476;
+}
+
+void
+md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
+{
+ const md5_byte_t *p = data;
+ int left = nbytes;
+ int offset = (pms->count[0] >> 3) & 63;
+ md5_word_t nbits = (md5_word_t)(nbytes << 3);
+
+ if (nbytes <= 0)
+ return;
+
+ /* Update the message length. */
+ pms->count[1] += nbytes >> 29;
+ pms->count[0] += nbits;
+ if (pms->count[0] < nbits)
+ pms->count[1]++;
+
+ /* Process an initial partial block. */
+ if (offset) {
+ int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+ memcpy(pms->buf + offset, p, copy);
+ if (offset + copy < 64)
+ return;
+ p += copy;
+ left -= copy;
+ md5_process(pms, pms->buf);
+ }
+
+ /* Process full blocks. */
+ for (; left >= 64; p += 64, left -= 64)
+ md5_process(pms, p);
+
+ /* Process a final partial block. */
+ if (left)
+ memcpy(pms->buf, p, left);
+}
+
+void
+md5_finish(md5_state_t *pms, md5_byte_t digest[16])
+{
+ static const md5_byte_t pad[64] = {
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ };
+ md5_byte_t data[8];
+ int i;
+
+ /* Save the length before padding. */
+ for (i = 0; i < 8; ++i)
+ data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+ /* Pad to 56 bytes mod 64. */
+ md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+ /* Append the length. */
+ md5_append(pms, data, 8);
+ for (i = 0; i < 16; ++i)
+ digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}
diff --git a/utils/pack/md5.h b/utils/pack/md5.h
new file mode 100644
index 0000000..995208d
--- /dev/null
+++ b/utils/pack/md5.h
@@ -0,0 +1,88 @@
+/*
+ Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved.
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+ 3. This notice may not be removed or altered from any source distribution.
+
+ L. Peter Deutsch
+ ghost@aladdin.com
+
+ */
+/* $Id$ */
+/*
+ Independent implementation of MD5 (RFC 1321).
+
+ This code implements the MD5 Algorithm defined in RFC 1321, whose
+ text is available at
+ http://www.ietf.org/rfc/rfc1321.txt
+ The code is derived from the text of the RFC, including the test suite
+ (section A.5) but excluding the rest of Appendix A. It does not include
+ any code or documentation that is identified in the RFC as being
+ copyrighted.
+
+ The original and principal author of md5.h is L. Peter Deutsch
+ <ghost@aladdin.com>. Other authors are noted in the change history
+ that follows (in reverse chronological order):
+
+ 2007-04-15 bobbens using uint8_t and uint32_t for compatibility.
+ removed C++ conditionalization.
+ 2002-04-13 lpd Removed support for non-ANSI compilers; removed
+ references to Ghostscript; clarified derivation from RFC 1321;
+ now handles byte order either statically or dynamically.
+ 1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+ 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+ added conditionalization for C++ compilation from Martin
+ Purschke <purschke@bnl.gov>.
+ 1999-05-03 lpd Original version.
+ */
+
+#ifndef MD5_H
+# define MD5_H
+
+#include <stdint.h>
+
+/*
+ * This package supports both compile-time and run-time determination of CPU
+ * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
+ * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
+ * defined as non-zero, the code will be compiled to run only on big-endian
+ * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
+ * run on either big- or little-endian CPUs, but will run slightly less
+ * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
+ */
+
+typedef uint8_t md5_byte_t; /* 8-bit byte */
+typedef uint32_t md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+ md5_word_t count[2]; /* message length in bits, lsw first */
+ md5_word_t abcd[4]; /* digest buffer */
+ md5_byte_t buf[64]; /* accumulate block */
+} md5_state_t;
+
+
+/* Initialize the algorithm. */
+void md5_init(md5_state_t *pms);
+
+/* Append a string to the message. */
+void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
+
+/* Finish the message and return the digest. */
+void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
+
+
+#endif /* MD5_H */
diff --git a/utils/pack/pack b/utils/pack/pack
index 240431370cace9de25474b11b17121046981347d..ac22a132fd6cc13aec39d38ebc9c80d4127febba 100755
GIT binary patch
literal 16715
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
B4(0#=
literal 11311
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
diff --git a/utils/pack/pack.c b/utils/pack/pack.c
index f2ab738..68f31f0 100644
--- a/utils/pack/pack.c
+++ b/utils/pack/pack.c
@@ -1,75 +1,250 @@
#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <fcntl.h> // creat() and co.
#include <sys/stat.h> // S_IRUSR
#include <unistd.h>
#include <errno.h>
#include <string.h>
+#include <malloc.h>
+
+#include "pack.h"
+#include "md5.h"
+
+// == Store data in a funky format. =======================
+// Format:
+// -- Index (in 512 byte chunks).
+// -- Magic number (16 bytes).
+// -- Number of files (uint32_t).
+// -- Files in format name/location.
+// -- File name (128 bytes max, ending in \0).
+// -- File location (uint32_t).
+// -- File data in format Size/Data.
+// -- File size (uint32_t).
+// -- File data (char*).
+// -- File MD5 (16 byte char*).
+// -- EOF
+//
+// -- Write magic number and number of files.
+// -- Write the index.
+// -- Pack the files.
+// ========================================================
+
+// The read/write block size.
+#define BLOCKSIZE 128*1024
+
+// Max filename length.
+#define MAX_FILENAME 100
+
+#define LOG(str, args...)(fprintf(stdout, str"\n", ## args))
+#define WARN(str, args...)(fprintf(stderr, "[%d] "str"\n", SDL_GetTicks(), ## args))
+#define ERR(str, args...) (fprintf(stderr, "%s:%d: "str"\n", __FILE__, __LINE__, ## args))
+
+#ifdef DEBUG
+# undef DEBUG
+# define DEBUG(str, args...) LOG(str, ## args)
+# define DEBUGGING
+#else
+# define DEBUG(str, args...) do {;} while(0)
+#endif
-#define USAGE "Usage: %s output input\n", argv[0]
#define PERMS S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH
const uint64_t magic = 0x25524573; // sER%
-off_t getfilesize(const char* filename);
-int fileexists(const char* filename);
-
-int main(int argc, char** argv) {
- switch(argc) {
- case 1:
- printf("Missing output file\n");
- case 2:
- printf("Missing input file/s\n\n");
- goto usage;
- break;
- }
-
- int i, namesize;
- int outfd, infd;
- uint32_t nfiles = (uint32_t)argc - 2;
-
- for(namesize = 0; i < nfiles; i++) {
- // Make sure file exists before writing.
- if(!fileexists(argv[i+2])) {
- printf("File %s does not exist!\n", argv[i+2]);
- goto failure;
- }
- namesize += strlen(argv[i+2]);
- }
-
- // Create the output file.
- outfd = creat(argv[1], PERMS);
- if(outfd == -1) goto failure;
-
- // Magic number.
- write(outfd, &magic, sizeof(magic));
-
- close(outfd);
-
- exit(EXIT_SUCCESS);
-
-usage:
- printf(USAGE);
-failure:
- exit(EXIT_FAILURE);
-}
-
-// Grab file size.
-off_t getfilesize(const char* filename) {
+// Grab the filesize.
+static off_t getfilesize(const char* filename) {
struct stat file;
+
if(!stat(filename, &file))
return file.st_size;
- printf("Unable to get filesize of %s\n", filename);
+ ERR("Unable to get filesize of %s", filename);
return 0;
}
-// Does the file exist?
-int fileexists(const char* filename) {
+// Return true if filename is a Packfile.
+int pack_check(char* filename) {
+ int fd = open(filename, O_RDONLY);
+ if(fd == -1) {
+ ERR("Error opening %s: %s", filename, strerror(errno));
+ return -1;
+ }
+
+ char* buf = malloc(sizeof(magic));
+ if(read(fd, buf, sizeof(magic)) != sizeof(magic)) {
+ ERR("Error reading magic number: %s", strerror(errno));
+ free(buf);
+ return -1;
+ }
+
+ int ret = (memcmp(buf, &magic, sizeof(magic))==0) ? 0 : 1;
+ free(buf);
+ return ret;
+}
+
+// Pack nfiles, infiles into outfile.
+#define WRITE(f,b,n) if(write(f,b,n)==-1) { \
+ ERR("Error writing to file: %s", strerror(errno)); \
+ free(buf); return -1; }
+
+int pack_files(char* outfile, char** infiles, uint32_t nfiles) {
+ void* buf;
struct stat file;
- if(!stat(filename, &file))
- return 1;
+ int i, namesize;
+ int outfd, infd;
+ uint32_t indexsize, pointer;
+ int bytes;
+ const uint8_t b = '\0';
+
+ for(namesize = 0, i = 0; i < nfiles; i++) {
+ // Make sure file exists before writing.
+ if(stat(infiles[i], &file)) {
+ ERR("File %s does not exist", infiles[i]);
+ return -1;
+ }
+ if(strlen(infiles[i]) < MAX_FILENAME) {
+ ERR("filename '%s' is too long, should be only %d characters", infiles[i], MAX_FILENAME);
+ return -1;
+ }
+ namesize += strlen(infiles[i]);
+ }
+
+ indexsize = (sizeof(magic) + 4 + // Magic number and number of files.
+ namesize + // Total length of file names.
+ (1+4)*nfiles); // File size and extra end of string char '\0'.
+ DEBUG("Index size is %d", indexsize);
+
+ // Create the output file.
+ outfd = creat(outfile, PERMS);
+ if(outfd == -1) {
+ ERR("Unable to open %s for writing", outfile);
+ return -1;
+ }
+
+ // Index!
+ buf = malloc(BLOCKSIZE);
+
+ // Magic number.
+ WRITE(outfd, &magic, sizeof(magic));
+ DEBUG("Wrote magic number");
+ // Number of files.
+ WRITE(outfd, &nfiles, sizeof(nfiles));
+ DEBUG("Wrote number of files: %d", nfiles);
+ // Create file dependent index part.
+ pointer = indexsize;
+ for(i = 0; i < nfiles; i++) {
+ WRITE(outfd, infiles[i], strlen(infiles[i]));
+ DEBUG("File: '%s' at %d", infiles[i], pointer);
+ WRITE(outfd, &b, 1);
+ WRITE(outfd, &pointer, 4);
+ pointer += getfilesize(infiles[i]) + 8; // Set pointer to be next file pos.
+ }
+
+ // Data!
+ md5_state_t md5;
+ md5_byte_t* md5val = malloc(16);
+ for(i = 0; i < nfiles; i++) {
+ bytes = (uint32_t)getfilesize(infiles[i]);
+ WRITE(outfd, &bytes, 4); // filesize.
+ DEBUG("About to write '%s' of %d bytes", infiles[i], bytes);
+ infd = open(infiles[i], O_RDONLY);
+ md5_init(&md5);
+ while((bytes = read(infd, buf, BLOCKSIZE))) {
+ WRITE(outfd, buf, bytes); // Data.
+ md5_append(&md5, buf, bytes);
+ }
+ md5_finish(&md5, md5val);
+ WRITE(outfd, md5val, sizeof(md5val));
+ close(infd);
+ DEBUG("Wrote file '%s'", infiles[i]);
+ }
+ free(md5val);
+
+ close(outfd);
+ free(buf);
+
+ DEBUG("Packfile success\n\t%d files\n\t%d bytes", nfiles, (int)getfilesize(outfile));
return 0;
}
+#undef WRITE
+
+// Opens the filename in packfile for reading.
+#define READ(f,b,n) if(read(f,b,n) != n) { \
+ ERR("Too few bytes read. Expected more."); \
+ free(buf); return -1; }
+int pack_open(Packfile* file, char* packfile, char* filename) {
+ int i, j;
+ uint32_t nfiles;
+ char* buf = (char*)malloc(MAX_FILENAME);
+
+ file = (Packfile*)malloc(sizeof(Packfile));
+
+ file->start = file->end = 0;
+
+ file->fd = open(packfile, O_RDONLY);
+ if(file->fd == -1) {
+ ERR("Error opening %s: %s", filename, strerror(errno));
+ return -1;
+ }
+
+ READ(file->fd, buf, sizeof(magic)); // Make sure it's a packfile.
+ if(memcmp(buf, &magic, sizeof(magic))) {
+ ERR("File %s is not a valid packfile", filename);
+ return -1;
+ }
+
+ READ(file->fd, &nfiles, 4);
+ for(i = 0; i < nfiles; i++) {
+ // Start to search files.
+ j = 0;
+ READ(file->fd, &buf[j], 1); // Get the name.
+ while(buf[j++] != '\0')
+ READ(file->fd, &buf[j], 1);
+
+ if(strcmp(filename, buf) == 0) {
+ // We found the file.
+ READ(file->fd, &file->start, 4);
+ DEBUG("'%s' found at %d", filename, file->start);
+ break;
+ }
+ lseek(file->fd, 4, SEEK_CUR); // Ignore the file location.
+ }
+ free(buf);
+
+ if(file->start) {
+ // Go to the beginning of the file.
+ if(lseek(file->fd, file->start, SEEK_SET) != file->start) {
+ ERR("Failure to seek to file start: %s", strerror(errno));
+ return -1;
+ }
+ if(read(file->fd, &file->end, 4) != 4) {
+ ERR("Too few bytes read. Expected more.");
+ return -1;
+ }
+ DEBUG("\t%d bytes", file->end);
+ file->pos = file->start;
+ file->end += file->start;
+ }
+
+ return 0;
+}
+#undef READ
+
+// Read count bytes from file and put them into buf.
+ssize_t pack_read(Packfile* file, void* buf, size_t count) {
+ if(file->pos + count > file->end) count = file->end - file->pos; // Can't go past the end!
+ if(count == 0) return 0;
+
+ int bytes;
+
+ bytes = read(file->fd, buf, count);
+ file->pos += bytes;
+
+ return bytes;
+}
+
+// Close the packfile.
+int pack_close(Packfile* file) {
+ int i = close(file->fd);
+ free(file);
+ return (i) ? -1 : 0;
+}
diff --git a/utils/pack/pack.h b/utils/pack/pack.h
new file mode 100644
index 0000000..2d753ba
--- /dev/null
+++ b/utils/pack/pack.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <fcntl.h>
+#include <stdint.h>
+
+typedef struct {
+ int fd; // File descriptor.
+ uint32_t pos; // position.
+ uint32_t start, end; // file limits.
+} Packfile;
+
+// Packfile manipulation. Automatically allocated and freed (with open and close).
+int pack_check(char* filename);
+int pack_files(char* outfile, char** infiles, uint32_t nfiles);
+int pack_open(Packfile* file, char* packfile, char* filename);
+ssize_t pack_read(Packfile* file, void* buf, size_t count);
+int pack_close(Packfile* file);
+