Split out decompression functions and jigdo parsing functions into
authorSteve McIntyre <steve@einval.com>
Wed, 27 Apr 2005 21:06:49 +0000 (21:06 +0000)
committerSteve McIntyre <steve@einval.com>
Wed, 27 Apr 2005 21:06:49 +0000 (21:06 +0000)
separate source files.

Makefile
decompress.c [new file with mode: 0644]
jte.h [new file with mode: 0644]
mkimage.c
parse_jigdo.c [new file with mode: 0644]

index 9a8b4f0..424791a 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ all: $(BINS)
 DB_OBJ=jigdb-sql.o
 DBLIB=-lsqlite3
 
-mkimage: mkimage.o endian.o md5.o $(DB_OBJ)
+mkimage: mkimage.o endian.o md5.o parse_jigdo.o decompress.o $(DB_OBJ)
        $(CC) -o $@ $+ -lz -lbz2 $(DBLIB)
 
 jigsum: jigsum.o md5.o $(DB_OBJ)
diff --git a/decompress.c b/decompress.c
new file mode 100644 (file)
index 0000000..d5874da
--- /dev/null
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <zlib.h>
+#ifdef BZ2_SUPPORT
+#   include <bzlib.h>
+#endif
+#include "jte.h"
+
+static int ungzip_data_block(char *in_buf, INT64 in_len, char *out_buf, INT64 out_len)
+{
+    int error = 0;
+    z_stream uc_stream;
+    
+    uc_stream.zalloc = NULL;
+    uc_stream.zfree = NULL;
+    uc_stream.opaque = NULL;
+    uc_stream.next_in = (unsigned char *)in_buf;
+    uc_stream.avail_in = in_len;
+
+    error = inflateInit(&uc_stream);
+    if (Z_OK != error)
+    {
+        fprintf(logfile, "ungzip_data_block: failed to init, error %d\n", error);
+        return EIO;
+    }
+    
+    uc_stream.next_out = (unsigned char *)out_buf;
+    uc_stream.avail_out = out_len;
+
+    error = inflate(&uc_stream, Z_FINISH);
+    if (Z_OK != error && Z_STREAM_END != error)
+    {
+        fprintf(logfile, "ungzip_data_block: failed to decompress, error %d\n", error);
+        return EIO;
+    }
+    
+    error = inflateEnd(&uc_stream);
+    if (Z_OK != error)
+    {
+        fprintf(logfile, "ungzip_data_block: failed to end, error %d\n", error);
+        return EIO;
+    }
+    
+    return 0;
+}    
+
+#ifdef BZ2_SUPPORT
+static int unbzip_data_block(char *in_buf, INT64 in_len, char *out_buf, INT64 out_len)
+{
+    int error = 0;
+    bz_stream uc_stream;
+    
+    uc_stream.bzalloc = NULL;
+    uc_stream.bzfree = NULL;
+    uc_stream.opaque = NULL;
+    uc_stream.next_in = in_buf;
+    uc_stream.avail_in = in_len;
+
+    error = BZ2_bzDecompressInit(&uc_stream, 0, 0);
+    if (BZ_OK != error)
+    {
+        fprintf(logfile, "unbzip_data_block: failed to init, error %d\n", error);
+        return EIO;
+    }
+    
+    uc_stream.next_out = out_buf;
+    uc_stream.avail_out = out_len;
+
+    error = BZ2_bzDecompress(&uc_stream);
+    if (BZ_OK != error && BZ_STREAM_END != error)
+    {
+        fprintf(logfile, "unbzip_data_block: failed to decompress, error %d\n", error);
+        return EIO;
+    }
+    
+    error = BZ2_bzDecompressEnd(&uc_stream);
+    if (BZ_OK != error)
+    {
+        fprintf(logfile, "unbzip_data_block: failed to end, error %d\n", error);
+        return EIO;
+    }
+    
+    return 0;
+}    
+#endif
+
+int decompress_data_block(char *in_buf, INT64 in_len, char *out_buf,
+                                 INT64 out_len, int compress_type)
+{
+#ifdef BZ2_SUPPORT
+    if (CT_BZIP2 == compress_type)
+        return unbzip_data_block(in_buf, in_len, out_buf, out_len);
+    else
+#endif
+        return ungzip_data_block(in_buf, in_len, out_buf, out_len);
+}
+
diff --git a/jte.h b/jte.h
new file mode 100644 (file)
index 0000000..e1ed2d7
--- /dev/null
+++ b/jte.h
@@ -0,0 +1,47 @@
+typedef long long INT64;
+typedef unsigned long long UINT64;
+typedef unsigned long      UINT32;
+
+#ifndef LLONG_MAX
+#   define LLONG_MAX (INT64)INT_MAX * INT_MAX
+#endif
+
+#define BUF_SIZE 65536
+#define MISSING -1
+
+#ifndef MIN
+#define MIN(x,y)        ( ((x) < (y)) ? (x) : (y))
+#endif
+
+typedef struct match_list_
+{
+    struct match_list_ *next;
+    char *match;
+    char *mirror_path;
+} match_list_t;
+
+extern match_list_t *match_list_head;
+extern match_list_t *match_list_tail;
+
+typedef struct md5_list_
+{
+    struct md5_list_ *next;
+    INT64 file_size;
+    char *md5;
+    char *full_path;
+} md5_list_t;
+
+extern md5_list_t *md5_list_head;
+extern md5_list_t *md5_list_tail;
+extern FILE *logfile;
+extern char *missing_filename;
+
+int parse_jigdo_file(char *filename);
+int parse_md5_file(char *filename);
+md5_list_t *find_file_in_md5_list(unsigned char *base64_md5);
+INT64 get_file_size(char *filename);
+
+int decompress_data_block(char *in_buf, INT64 in_len, char *out_buf,
+                          INT64 out_len, int compress_type);
+
+
index 3e22546..996e069 100644 (file)
--- a/mkimage.c
+++ b/mkimage.c
 #include <stdio.h>
 #include <string.h>
 #include <limits.h>
-#include <zlib.h>
-#ifdef BZ2_SUPPORT
-#   include <bzlib.h>
-#endif
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include "endian.h"
 #include "md5.h"
 #include "jigdb.h"
-
-typedef long long INT64;
-typedef unsigned long long UINT64;
-typedef unsigned long      UINT32;
-
-#ifndef LLONG_MAX
-#   define LLONG_MAX (INT64)INT_MAX * INT_MAX
-#endif
-
-#define BUF_SIZE 65536
-#define MISSING -1
-
-#ifndef MIN
-#define MIN(x,y)        ( ((x) < (y)) ? (x) : (y))
-#endif
-
-#define COMP_GZIP 2
-#define COMP_BZIP 8
+#include "jte.h"
 
 FILE *logfile = NULL;
 FILE *outfile = NULL;
@@ -67,24 +46,9 @@ typedef enum state_
     ERROR
 } e_state;
 
-typedef struct match_list_
-{
-    struct match_list_ *next;
-    char *match;
-    char *mirror_path;
-} match_list_t;
-
 match_list_t *match_list_head = NULL;
 match_list_t *match_list_tail = NULL;
 
-typedef struct md5_list_
-{
-    struct md5_list_ *next;
-    INT64 file_size;
-    char *md5;
-    char *full_path;
-} md5_list_t;
-
 md5_list_t *md5_list_head = NULL;
 md5_list_t *md5_list_tail = NULL;
 
@@ -133,18 +97,6 @@ static void write_missing_entry(char *missing, char *filename)
     fprintf(missing_file, "%s\n", filename);
 }
 
-static INT64 get_file_size(char *filename)
-{
-    struct stat sb;
-    int error = 0;
-    
-    error = stat(filename, &sb);
-    if (error)
-        return MISSING;
-    else
-        return sb.st_size;
-}
-
 static void display_progress(FILE *file, char *text)
 {
     INT64 written = ftello(file);
@@ -201,326 +153,6 @@ static int add_match_entry(char *match)
     return 0;
 }
 
-static int file_exists(char *path, INT64 *size)
-{
-    struct stat sb;
-    int error = 0;
-    
-    error = stat(path, &sb);
-    if (!error && S_ISREG(sb.st_mode))
-    {
-        *size = sb.st_size;
-        return 1;
-    }
-    
-    /* else */
-    return 0;
-}
-
-static md5_list_t *find_file_in_md5_list(unsigned char *base64_md5)
-{
-    md5_list_t *md5_list_entry = md5_list_head;
-    
-    while (md5_list_entry)
-    {        
-        if (!memcmp(md5_list_entry->md5, base64_md5, 16))
-            return md5_list_entry;
-        /* else */
-        md5_list_entry = md5_list_entry->next;
-    }
-    return NULL; /* Not found */
-}
-
-static int find_file_in_mirror(char *jigdo_match, char *jigdo_name,
-                               char *match, INT64 *file_size, char **mirror_path)
-{
-    match_list_t *entry = match_list_head;
-    char path[PATH_MAX];
-
-    while (entry)
-    {
-        if (!strcmp(entry->match, match))
-        {
-            sprintf(path, "%s/%s", entry->mirror_path, jigdo_name);
-            if (file_exists(path, file_size))
-            {
-                *mirror_path = strdup(path);
-                return 0;
-            }
-        }
-        entry = entry->next;
-    }
-    
-    *mirror_path = jigdo_name;
-    return ENOENT;
-}
-
-
-static int add_md5_entry(INT64 size, char *md5, char *path)
-{
-    md5_list_t *new = NULL;    
-    new = calloc(1, sizeof(*new));
-    if (!new)
-        return ENOMEM;
-
-    new->md5 = md5;
-    new->full_path = path;
-    new->file_size = size;
-    
-    if (!md5_list_head)
-    {
-        md5_list_head = new;
-        md5_list_tail = new;
-    }
-    else
-    {
-        md5_list_tail->next = new;
-        md5_list_tail = new;
-    }
-    
-    return 0;
-}
-
-static int parse_md5_entry(char *md5_entry)
-{
-    int error = 0;
-    char *file_name = NULL;
-    char *md5 = NULL;
-    INT64 file_size = 0;
-
-    md5_entry[22] = 0;
-    md5_entry[23] = 0;
-
-    md5 = md5_entry;
-    file_name = &md5_entry[24];
-
-    if ('\n' == file_name[strlen(file_name) -1])
-        file_name[strlen(file_name) - 1] = 0;
-    
-    file_size = get_file_size(file_name);
-
-    error = add_md5_entry(file_size, md5, file_name);
-    return 0;
-}
-
-static int parse_md5_file(char *filename)
-{
-    char buf[2048];
-    FILE *file = NULL;
-    char *ret = NULL;
-    int error = 0;
-
-    file = fopen(filename, "rb");
-    if (!file)
-    {
-        fprintf(logfile, "Failed to open MD5 file %s, error %d!\n", filename, errno);
-        return errno;
-    }
-    
-    while(1)
-    {
-        ret = fgets(buf, sizeof(buf), file);
-        if (NULL == ret)
-            break;
-        error = parse_md5_entry(strdup(buf));
-    }
-    return 0;
-}
-
-/* DELIBERATELY do not sort these, or do anything clever with
-   insertion. The entries in the jigdo file should be in the same
-   order as the ones we'll want from the template. Simply add to the
-   end of the singly-linked list each time! */
-static int add_file_entry(char *jigdo_entry)
-{
-    int error = 0;
-    char *file_name = NULL;
-    INT64 file_size = 0;
-    char *ptr = jigdo_entry;
-    char *base64_md5 = NULL;
-    char *match = NULL;
-    char *jigdo_name = NULL;
-    
-    /* Grab out the component strings from the entry in the jigdo file */
-    base64_md5 = jigdo_entry;
-    while (0 != *ptr)
-    {
-        if ('=' == *ptr)
-        {
-            *ptr = 0;
-            ptr++;
-            match = ptr;
-        }
-        else if (':' == *ptr)
-        {
-            *ptr = 0;
-            ptr++;
-            jigdo_name = ptr;
-        }
-        else if ('\n' == *ptr)
-            *ptr = 0;
-        else
-            ptr++;
-    }
-
-    if (find_file_in_md5_list(base64_md5))
-        return 0; /* We already have an entry for this file; don't
-                   * waste any more time on it */
-
-    /* else look for the file in the filesystem */
-    if (NULL == match || NULL == jigdo_name)
-    {
-        fprintf(logfile, "Could not parse malformed jigdo entry \"%s\"\n", jigdo_entry);
-        return EINVAL;
-    }
-    error = find_file_in_mirror(match, jigdo_name, match, &file_size, &file_name);
-
-    if (error)
-       {
-               if (missing_filename)
-                       add_md5_entry(MISSING, base64_md5, file_name);
-               else
-               {
-                       fprintf(logfile, "Unable to find a file to match %s\n", file_name);
-                       fprintf(logfile, "Abort!\n");
-                       exit (ENOENT);
-               }
-       }
-    else
-        add_md5_entry(file_size, base64_md5, file_name);
-    return 0;
-}
-
-static int parse_jigdo_file(char *filename)
-{
-    char buf[2048];
-    gzFile *file = NULL;
-    char *ret = NULL;
-    int error = 0;
-    
-    file = gzopen(filename, "rb");
-    if (!file)
-    {
-        fprintf(logfile, "Failed to open jigdo file %s, error %d!\n", filename, errno);
-        return errno;
-    }
-
-    /* Find the [Parts] section of the jigdo file */
-    while (1)
-    {
-        ret = gzgets(file, buf, sizeof(buf));
-        if (NULL == ret)
-            break;
-        if (!strncmp(buf, "[Parts]", 7))
-            break;
-    }
-
-    /* Now grab the individual file entries and build a list */
-    while (1)
-    {
-        ret = gzgets(file, buf, sizeof(buf));
-        if (NULL == ret || !strcmp(buf, "\n"))
-            break;
-        if (!strcmp(buf, "[") || !strcmp(buf, "#"))
-            continue;
-        error = add_file_entry(strdup(buf));
-        if (error)
-            break;
-    }
-
-    gzclose(file);
-    return error;
-}
-
-static int ungzip_data_block(char *in_buf, INT64 in_len, char *out_buf, INT64 out_len)
-{
-    int error = 0;
-    z_stream uc_stream;
-    
-    uc_stream.zalloc = NULL;
-    uc_stream.zfree = NULL;
-    uc_stream.opaque = NULL;
-    uc_stream.next_in = (unsigned char *)in_buf;
-    uc_stream.avail_in = in_len;
-
-    error = inflateInit(&uc_stream);
-    if (Z_OK != error)
-    {
-        fprintf(logfile, "ungzip_data_block: failed to init, error %d\n", error);
-        return EIO;
-    }
-    
-    uc_stream.next_out = (unsigned char *)out_buf;
-    uc_stream.avail_out = out_len;
-
-    error = inflate(&uc_stream, Z_FINISH);
-    if (Z_OK != error && Z_STREAM_END != error)
-    {
-        fprintf(logfile, "ungzip_data_block: failed to decompress, error %d\n", error);
-        return EIO;
-    }
-    
-    error = inflateEnd(&uc_stream);
-    if (Z_OK != error)
-    {
-        fprintf(logfile, "ungzip_data_block: failed to end, error %d\n", error);
-        return EIO;
-    }
-    
-    return 0;
-}    
-
-#ifdef BZ2_SUPPORT
-static int unbzip_data_block(char *in_buf, INT64 in_len, char *out_buf, INT64 out_len)
-{
-    int error = 0;
-    bz_stream uc_stream;
-    
-    uc_stream.bzalloc = NULL;
-    uc_stream.bzfree = NULL;
-    uc_stream.opaque = NULL;
-    uc_stream.next_in = in_buf;
-    uc_stream.avail_in = in_len;
-
-    error = BZ2_bzDecompressInit(&uc_stream, 0, 0);
-    if (BZ_OK != error)
-    {
-        fprintf(logfile, "unbzip_data_block: failed to init, error %d\n", error);
-        return EIO;
-    }
-    
-    uc_stream.next_out = out_buf;
-    uc_stream.avail_out = out_len;
-
-    error = BZ2_bzDecompress(&uc_stream);
-    if (BZ_OK != error && BZ_STREAM_END != error)
-    {
-        fprintf(logfile, "unbzip_data_block: failed to decompress, error %d\n", error);
-        return EIO;
-    }
-    
-    error = BZ2_bzDecompressEnd(&uc_stream);
-    if (BZ_OK != error)
-    {
-        fprintf(logfile, "unbzip_data_block: failed to end, error %d\n", error);
-        return EIO;
-    }
-    
-    return 0;
-}    
-#endif
-
-static int decompress_data_block(char *in_buf, INT64 in_len, char *out_buf,
-                                 INT64 out_len, int compress_type)
-{
-#ifdef BZ2_SUPPORT
-    if (CT_BZIP2 == compress_type)
-        return unbzip_data_block(in_buf, in_len, out_buf, out_len);
-    else
-#endif
-        return ungzip_data_block(in_buf, in_len, out_buf, out_len);
-}
-
 static int read_data_block(FILE *template_file)
 {
     char inbuf[1024];
diff --git a/parse_jigdo.c b/parse_jigdo.c
new file mode 100644 (file)
index 0000000..6ce12e8
--- /dev/null
@@ -0,0 +1,258 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <limits.h>
+#include <zlib.h>
+#ifdef BZ2_SUPPORT
+#   include <bzlib.h>
+#endif
+#include "jte.h"
+
+INT64 get_file_size(char *filename)
+{
+    struct stat sb;
+    int error = 0;
+    
+    error = stat(filename, &sb);
+    if (error)
+        return MISSING;
+    else
+        return sb.st_size;
+}
+
+md5_list_t *find_file_in_md5_list(unsigned char *base64_md5)
+{
+    md5_list_t *md5_list_entry = md5_list_head;
+    
+    while (md5_list_entry)
+    {        
+        if (!memcmp(md5_list_entry->md5, base64_md5, 16))
+            return md5_list_entry;
+        /* else */
+        md5_list_entry = md5_list_entry->next;
+    }
+    return NULL; /* Not found */
+}
+
+static int add_md5_entry(INT64 size, char *md5, char *path)
+{
+    md5_list_t *new = NULL;    
+    new = calloc(1, sizeof(*new));
+    if (!new)
+        return ENOMEM;
+
+    new->md5 = md5;
+    new->full_path = path;
+    new->file_size = size;
+    
+    if (!md5_list_head)
+    {
+        md5_list_head = new;
+        md5_list_tail = new;
+    }
+    else
+    {
+        md5_list_tail->next = new;
+        md5_list_tail = new;
+    }
+    
+    return 0;
+}
+
+static int parse_md5_entry(char *md5_entry)
+{
+    int error = 0;
+    char *file_name = NULL;
+    char *md5 = NULL;
+    INT64 file_size = 0;
+
+    md5_entry[22] = 0;
+    md5_entry[23] = 0;
+
+    md5 = md5_entry;
+    file_name = &md5_entry[24];
+
+    if ('\n' == file_name[strlen(file_name) -1])
+        file_name[strlen(file_name) - 1] = 0;
+    
+    file_size = get_file_size(file_name);
+
+    error = add_md5_entry(file_size, md5, file_name);
+    return 0;
+}
+
+int parse_md5_file(char *filename)
+{
+    char buf[2048];
+    FILE *file = NULL;
+    char *ret = NULL;
+    int error = 0;
+
+    file = fopen(filename, "rb");
+    if (!file)
+    {
+        fprintf(logfile, "Failed to open MD5 file %s, error %d!\n", filename, errno);
+        return errno;
+    }
+    
+    while(1)
+    {
+        ret = fgets(buf, sizeof(buf), file);
+        if (NULL == ret)
+            break;
+        error = parse_md5_entry(strdup(buf));
+    }
+    return 0;
+}
+
+static int file_exists(char *path, INT64 *size)
+{
+    struct stat sb;
+    int error = 0;
+    
+    error = stat(path, &sb);
+    if (!error && S_ISREG(sb.st_mode))
+    {
+        *size = sb.st_size;
+        return 1;
+    }
+    
+    /* else */
+    return 0;
+}
+
+static int find_file_in_mirror(char *jigdo_match, char *jigdo_name,
+                               char *match, INT64 *file_size, char **mirror_path)
+{
+    match_list_t *entry = match_list_head;
+    char path[PATH_MAX];
+
+    while (entry)
+    {
+        if (!strcmp(entry->match, match))
+        {
+            sprintf(path, "%s/%s", entry->mirror_path, jigdo_name);
+            if (file_exists(path, file_size))
+            {
+                *mirror_path = strdup(path);
+                return 0;
+            }
+        }
+        entry = entry->next;
+    }
+    
+    *mirror_path = jigdo_name;
+    return ENOENT;
+}
+
+
+/* DELIBERATELY do not sort these, or do anything clever with
+   insertion. The entries in the jigdo file should be in the same
+   order as the ones we'll want from the template. Simply add to the
+   end of the singly-linked list each time! */
+static int add_file_entry(char *jigdo_entry)
+{
+    int error = 0;
+    char *file_name = NULL;
+    INT64 file_size = 0;
+    char *ptr = jigdo_entry;
+    char *base64_md5 = NULL;
+    char *match = NULL;
+    char *jigdo_name = NULL;
+    
+    /* Grab out the component strings from the entry in the jigdo file */
+    base64_md5 = jigdo_entry;
+    while (0 != *ptr)
+    {
+        if ('=' == *ptr)
+        {
+            *ptr = 0;
+            ptr++;
+            match = ptr;
+        }
+        else if (':' == *ptr)
+        {
+            *ptr = 0;
+            ptr++;
+            jigdo_name = ptr;
+        }
+        else if ('\n' == *ptr)
+            *ptr = 0;
+        else
+            ptr++;
+    }
+
+    if (find_file_in_md5_list(base64_md5))
+        return 0; /* We already have an entry for this file; don't
+                   * waste any more time on it */
+
+    /* else look for the file in the filesystem */
+    if (NULL == match || NULL == jigdo_name)
+    {
+        fprintf(logfile, "Could not parse malformed jigdo entry \"%s\"\n", jigdo_entry);
+        return EINVAL;
+    }
+    error = find_file_in_mirror(match, jigdo_name, match, &file_size, &file_name);
+
+    if (error)
+       {
+               if (missing_filename)
+                       add_md5_entry(MISSING, base64_md5, file_name);
+               else
+               {
+                       fprintf(logfile, "Unable to find a file to match %s\n", file_name);
+                       fprintf(logfile, "Abort!\n");
+                       exit (ENOENT);
+               }
+       }
+    else
+        add_md5_entry(file_size, base64_md5, file_name);
+    return 0;
+}
+
+
+
+int parse_jigdo_file(char *filename)
+{
+    char buf[2048];
+    gzFile *file = NULL;
+    char *ret = NULL;
+    int error = 0;
+    
+    file = gzopen(filename, "rb");
+    if (!file)
+    {
+        fprintf(logfile, "Failed to open jigdo file %s, error %d!\n", filename, errno);
+        return errno;
+    }
+
+    /* Find the [Parts] section of the jigdo file */
+    while (1)
+    {
+        ret = gzgets(file, buf, sizeof(buf));
+        if (NULL == ret)
+            break;
+        if (!strncmp(buf, "[Parts]", 7))
+            break;
+    }
+
+    /* Now grab the individual file entries and build a list */
+    while (1)
+    {
+        ret = gzgets(file, buf, sizeof(buf));
+        if (NULL == ret || !strcmp(buf, "\n"))
+            break;
+        if (!strcmp(buf, "[") || !strcmp(buf, "#"))
+            continue;
+        error = add_file_entry(strdup(buf));
+        if (error)
+            break;
+    }
+
+    gzclose(file);
+    return error;
+}