Use jd_log() for loggins instead of fprintf()
authorSteve McIntyre <steve@einval.com>
Sun, 19 Jun 2005 22:59:34 +0000 (22:59 +0000)
committerSteve McIntyre <steve@einval.com>
Sun, 19 Jun 2005 22:59:34 +0000 (22:59 +0000)
Removed globals to make jigdoofus easier

jte.h
mkimage.c
parse_jigdo.c
parse_template.c

diff --git a/jte.h b/jte.h
index 662a29c..bbfe2a8 100644 (file)
--- a/jte.h
+++ b/jte.h
@@ -36,6 +36,9 @@ int jd_size(JD *state, INT64 *size);
 int jd_last_filename(JD *state, char **name);
 int jd_close(JD *state);
 
+/* Must be implemented by the caller */
+int jd_log(int verbose_level, char *fmt, ...);
+
 typedef struct match_list_
 {
     struct match_list_ *next;
@@ -51,21 +54,8 @@ typedef struct md5_list_
     char *full_path;
 } md5_list_t;
 
-extern match_list_t *G_match_list_head;
-extern match_list_t *G_match_list_tail;
-extern md5_list_t *G_md5_list_head;
-extern md5_list_t *G_md5_list_tail;
-extern FILE *G_logfile;
-extern FILE *G_missing_file;
-extern char *G_missing_filename;
-extern int G_verbose;
-extern int G_quick;
-extern UINT64 G_out_size;
-extern long long G_start_offset;
-extern long long G_end_offset;
-
 /* Interface functions */
-extern void display_progress(FILE *file, char *text);
+void display_progress(int verbose_level, INT64 image_size, INT64 current_offset, char *text);
 extern void file_missing(char *missing, char *filename);
 
 /* decompress.c */
@@ -73,16 +63,18 @@ int decompress_data_block(char *in_buf, INT64 in_len, char *out_buf,
                           INT64 out_len, int compress_type);
 
 /* parse_jigdo.c */
-int parse_jigdo_file(char *filename);
-int parse_md5_file(char *filename);
-md5_list_t *find_file_in_md5_list(unsigned char *base64_md5);
+int parse_jigdo_file(char *filename, md5_list_t **md5_list_head, match_list_t *match_list_head, char *missing_filename);
+int parse_md5_file(char *filename, md5_list_t **md5_list_head);
+md5_list_t *find_file_in_md5_list(unsigned char *base64_md5, md5_list_t **md5_list_head);
 INT64 get_file_size(char *filename);
 time_t get_file_mtime(char *filename);
 
 /* parse_template.c */
 int add_new_template_file(JIGDB *dbp, char *filename);
-int parse_template_file(char *filename, int sizeonly, char *missing,
-                        FILE *outfile, char *output_name, JIGDB *dbp);
+int parse_template_file(char *filename, int sizeonly, int no_md5, char *missing,
+                        FILE *outfile, char *output_name, JIGDB *dbp,
+                        md5_list_t **md5_list_head, FILE *missing_file,
+                        UINT64 start_offset, UINT64 end_offset);
 
 
 
index 4b2a311..673f495 100644 (file)
--- a/mkimage.c
+++ b/mkimage.c
@@ -21,6 +21,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/mman.h>
+#include <stdarg.h>
 #include "endian.h"
 #include "jigdb.h"
 #include "jte.h"
@@ -59,19 +60,18 @@ extern void file_missing(char *missing, char *filename)
         G_missing_file = fopen(missing, "wb");
         if (!G_missing_file)
         {
-            fprintf(G_logfile, "file_missing: Unable to open missing log %s; error %d\n", missing, errno);
+            jd_log(0, "file_missing: Unable to open missing log %s; error %d\n", missing, errno);
             exit(1);
         }
     }
     fprintf(G_missing_file, "%s\n", filename);
 }
 
-extern void display_progress(FILE *file, char *text)
+void display_progress(int verbose_level, INT64 image_size, INT64 current_offset, char *text)
 {
-    INT64 written = ftello(file);
-    if (G_out_size > 0)
-        fprintf(G_logfile, "\r %5.2f%%  %-60.60s",
-               100.0 * written / G_out_size, text);
+    if ((verbose_level <= G_verbose) && (image_size > 0))
+        jd_log(1, "\r %5.2f%%  %-60.60s",
+               100.0 * current_offset / image_size, text);
 }
 
 static int add_match_entry(char *match)
@@ -95,7 +95,7 @@ static int add_match_entry(char *match)
 
     if (!mirror_path)
     {
-        fprintf(G_logfile, "Could not parse malformed match entry \"%s\"\n", match);
+        jd_log(0, "Could not parse malformed match entry \"%s\"\n", match);
         return EINVAL;
     }        
     
@@ -103,7 +103,7 @@ static int add_match_entry(char *match)
     if (!entry)
         return ENOMEM;
 
-    fprintf(G_logfile, "Adding match entry %s:%s\n", match, mirror_path);
+    jd_log(1, "Adding match entry %s:%s\n", match, mirror_path);
 
     entry->match = match;
     entry->mirror_path = mirror_path;
@@ -198,14 +198,14 @@ int main(int argc, char **argv)
                 G_outfile = fopen(output_name, "wb");
                 if (!G_outfile)
                 {
-                    fprintf(stderr, "Unable to open output file %s\n", optarg);
+                    jd_log(0, "Unable to open output file %s\n", optarg);
                     return errno;
                 }
                 break;
             case 'j':
                 if (jigdo_filename)
                 {
-                    fprintf(G_logfile, "Can only specify one jigdo file!\n");
+                    jd_log(0, "Can only specify one jigdo file!\n");
                     return EINVAL;
                 }
                 /* else */
@@ -214,7 +214,7 @@ int main(int argc, char **argv)
             case 't':
                 if (template_filename)
                 {
-                    fprintf(G_logfile, "Can only specify one template file!\n");
+                    jd_log(0, "Can only specify one template file!\n");
                     return EINVAL;
                 }
                 /* else */
@@ -223,7 +223,7 @@ int main(int argc, char **argv)
             case 'f':
                 if (md5_filename)
                 {
-                    fprintf(G_logfile, "Can only specify one MD5 file!\n");
+                    jd_log(0, "Can only specify one MD5 file!\n");
                     return EINVAL;
                 }
                 /* else */
@@ -232,7 +232,7 @@ int main(int argc, char **argv)
             case 'd':
                 if (db_filename)
                 {
-                    fprintf(G_logfile, "Can only specify one db file!\n");
+                    jd_log(0, "Can only specify one db file!\n");
                     return EINVAL;
                 }
                 /* else */
@@ -247,7 +247,7 @@ int main(int argc, char **argv)
                 G_missing_filename = optarg;
                 break;
             case ':':
-                fprintf(G_logfile, "Missing argument!\n");
+                jd_log(0, "Missing argument!\n");
                 return EINVAL;
                 break;
             case 'h':
@@ -269,7 +269,7 @@ int main(int argc, char **argv)
                 sizeonly = 1;
                 break;
             default:
-                fprintf(G_logfile, "Unknown option!\n");
+                jd_log(0, "Unknown option!\n");
                 return EINVAL;
         }
     }
@@ -279,14 +279,14 @@ int main(int argc, char **argv)
         (NULL == db_filename) && 
         !sizeonly)
     {
-        fprintf(G_logfile, "No jigdo file, DB file or MD5 file specified!\n");
+        jd_log(0, "No jigdo file, DB file or MD5 file specified!\n");
         usage(argv[0]);
         return EINVAL;
     }
     
     if (NULL == template_filename)
     {
-        fprintf(G_logfile, "No template file specified!\n");
+        jd_log(0, "No template file specified!\n");
         usage(argv[0]);
         return EINVAL;
     }    
@@ -294,10 +294,10 @@ int main(int argc, char **argv)
     if (md5_filename)
     {
         /* Build up a list of the files we've been fed */
-        error = parse_md5_file(md5_filename);
+        error = parse_md5_file(md5_filename, &G_md5_list_head);
         if (error)
         {
-            fprintf(G_logfile, "Unable to parse the MD5 file %s\n", md5_filename);
+            jd_log(0, "Unable to parse the MD5 file %s\n", md5_filename);
             return error;
         }
     }
@@ -305,10 +305,10 @@ int main(int argc, char **argv)
     if (jigdo_filename)
     {
         /* Build up a list of file mappings */
-        error = parse_jigdo_file(jigdo_filename);
+        error = parse_jigdo_file(jigdo_filename, &G_md5_list_head, G_match_list_head, G_missing_filename);
         if (error)
         {
-            fprintf(G_logfile, "Unable to parse the jigdo file %s\n", jigdo_filename);
+            jd_log(0, "Unable to parse the jigdo file %s\n", jigdo_filename);
             return error;
         }
     }
@@ -321,7 +321,7 @@ int main(int argc, char **argv)
         dbp = db_open(db_filename);
         if (!dbp)
         {
-            fprintf(G_logfile, "Failed to open DB file %s, error %d\n", db_filename, errno);
+            jd_log(0, "Failed to open DB file %s, error %d\n", db_filename, errno);
             return errno;
         }
         /* If we have a DB, then we should cache the template
@@ -338,15 +338,15 @@ int main(int argc, char **argv)
         error = add_new_template_file(dbp, template_filename);
         if (error)
         {
-            fprintf(G_logfile, "Unable to add template file %s to database, error %d\n",
-                    template_filename, error);
+            jd_log(0, "Unable to add template file %s to database, error %d\n",
+                   template_filename, error);
             return error;
         }
         error = db_lookup_template_by_path(dbp, template_filename, &template);
         if (error)
         {
-            fprintf(G_logfile, "Unable to re-read newly-added template file %s, error %d!\n",
-                    template_filename, error);
+            jd_log(0, "Unable to re-read newly-added template file %s, error %d!\n",
+                   template_filename, error);
             return error;
         }
     }
@@ -356,7 +356,7 @@ int main(int argc, char **argv)
     error = jd_init(1);
     if (error)
     {
-        fprintf(G_logfile, "Unable to init JD cache interface, error %d\n", error);
+        jd_log(0, "Unable to init JD cache interface, error %d\n", error);
         return error;
     }
 
@@ -364,23 +364,23 @@ int main(int argc, char **argv)
     if (!jdp)
     {
         error = errno;
-        fprintf(G_logfile, "Unable to open JD interface for template file %s (error %d)\n",
-                template_filename, error);
+        jd_log(0, "Unable to open JD interface for template file %s (error %d)\n",
+               template_filename, error);
         return error;
     }
 
     if (!G_quick)
         mk_MD5Init(&image_context);
 
-    if (0 == G_end_offset)
+    error = jd_size(jdp, &G_out_size);
+    if (error)
     {
-        error = jd_size(jdp, &G_end_offset);
-        if (error)
-        {
-            fprintf(G_logfile, "Unable to read image size from the template information. Error %d\n", error);
-            return error;
-        }
+        jd_log(0, "Unable to read image size from the template information. Error %d\n", error);
+        return error;
     }
+    
+    if (0 == G_end_offset)
+        G_end_offset = G_out_size;
 
     /* Now the main loop - iterate in read/write/md5sum */
     current_offset = G_start_offset;
@@ -389,8 +389,8 @@ int main(int argc, char **argv)
         error = jd_read(jdp, current_offset, sizeof(data_buf), data_buf, &bytes_read);
         if (error)
         {
-            fprintf(G_logfile, "Failed to read %d bytes at offset %lld, error %d\n",
-                    sizeof(data_buf), current_offset, error);
+            jd_log(0, "Failed to read %d bytes at offset %lld, error %d\n",
+                   sizeof(data_buf), current_offset, error);
             break;
         }
         if (0 == bytes_read)
@@ -402,8 +402,8 @@ int main(int argc, char **argv)
             size_t this_write = fwrite(data_buf, 1, bytes_read, G_outfile);
             if (-1 == this_write)
             {
-                fprintf(G_logfile, "Failed to write %lld bytes at offset %lld, error %d\n",
-                        bytes_read, current_offset, error);
+                jd_log(0, "Failed to write %lld bytes at offset %lld, error %d\n",
+                       bytes_read, current_offset, error);
                 break;
             }
             bytes_written += this_write;
@@ -419,27 +419,27 @@ int main(int argc, char **argv)
             char *last_file = NULL;                
             error = jd_last_filename(jdp, &last_file);
             if (!error && (G_end_offset > G_start_offset))
-                fprintf(G_logfile, "\r %5.2f%%  %-60.60s",
-                        100.0 * (current_offset - G_start_offset) / (G_end_offset - G_start_offset), last_file);
+                jd_log(1, "\r %5.2f%%  %-60.60s",
+                       100.0 * (current_offset - G_start_offset) / (G_end_offset - G_start_offset), last_file);
         }
     }
     if (error)
     {
-        fprintf(G_logfile, "Failed to create image, error %d\n", error);
+        jd_log(0, "Failed to create image, error %d\n", error);
         return error;
     }
 
     if (G_verbose)
     {
-        fprintf(G_logfile, "\n");
+        jd_log(1, "\n");
         if (!G_quick)
         {
             mk_MD5Final (image_md5, &image_context);
             char *out_md5 = hex_dump(image_md5, 16);
-            fprintf(G_logfile, "Output image MD5 is    %s\n", out_md5);
+            jd_log(1, "Output image MD5 is    %s\n", out_md5);
             free(out_md5);
         }
-        fprintf(G_logfile, "Output image length written is %lld bytes\n", G_end_offset - G_start_offset);
+        jd_log(1, "Output image length written is %lld bytes\n", G_end_offset - G_start_offset);
     }
 
 #if 0
@@ -448,9 +448,9 @@ int main(int argc, char **argv)
                                 G_outfile, output_name, dbp);
     if (error)
     {
-        fprintf(G_logfile, "Unable to recreate image from template file %s\n", template_filename);
+        jd_log(0, "Unable to recreate image from template file %s\n", template_filename);
         if (G_missing_filename)
-            fprintf(G_logfile, "%s contains the list of missing files\n", G_missing_filename);
+            jd_log(0, "%s contains the list of missing files\n", G_missing_filename);
         return error;
     }        
 #endif
@@ -459,3 +459,16 @@ int main(int argc, char **argv)
     return 0;
 }
 
+int jd_log(int level, char *fmt, ...)
+{
+    int error = 0;    
+    va_list ap;
+
+    if (level <= G_verbose)
+    {
+        va_start(ap, fmt);
+        error = vfprintf(G_logfile, fmt, ap);
+        va_end(ap);
+    }
+    return error;
+}
index 5f4d416..4ba3ae6 100644 (file)
@@ -37,9 +37,9 @@ time_t get_file_mtime(char *filename)
         return sb.st_mtime;
 }
 
-md5_list_t *find_file_in_md5_list(unsigned char *base64_md5)
+md5_list_t *find_file_in_md5_list(unsigned char *base64_md5, md5_list_t **md5_list_head)
 {
-    md5_list_t *md5_list_entry = G_md5_list_head;
+    md5_list_t *md5_list_entry = *md5_list_head;
     
     while (md5_list_entry)
     {        
@@ -51,9 +51,11 @@ md5_list_t *find_file_in_md5_list(unsigned char *base64_md5)
     return NULL; /* Not found */
 }
 
-static int add_md5_entry(INT64 size, char *md5, char *path)
+static int add_md5_entry(INT64 size, char *md5, char *path, md5_list_t **md5_list_head)
 {
     md5_list_t *new = NULL;    
+    static md5_list_t *md5_list_tail = NULL;
+    
     new = calloc(1, sizeof(*new));
     if (!new)
         return ENOMEM;
@@ -62,21 +64,21 @@ static int add_md5_entry(INT64 size, char *md5, char *path)
     new->full_path = path;
     new->file_size = size;
     
-    if (!G_md5_list_head)
+    if (*md5_list_head)
     {
-        G_md5_list_head = new;
-        G_md5_list_tail = new;
+        *md5_list_head = new;
+        md5_list_tail = new;
     }
     else
     {
-        G_md5_list_tail->next = new;
-        G_md5_list_tail = new;
+        md5_list_tail->next = new;
+        md5_list_tail = new;
     }
     
     return 0;
 }
 
-static int parse_md5_entry(char *md5_entry)
+static int parse_md5_entry(char *md5_entry, md5_list_t **md5_list_head)
 {
     int error = 0;
     char *file_name = NULL;
@@ -94,11 +96,11 @@ static int parse_md5_entry(char *md5_entry)
     
     file_size = get_file_size(file_name);
 
-    error = add_md5_entry(file_size, md5, file_name);
+    error = add_md5_entry(file_size, md5, file_name, md5_list_head);
     return 0;
 }
 
-int parse_md5_file(char *filename)
+int parse_md5_file(char *filename, md5_list_t **md5_list_head)
 {
     char buf[2048];
     FILE *file = NULL;
@@ -108,7 +110,7 @@ int parse_md5_file(char *filename)
     file = fopen(filename, "rb");
     if (!file)
     {
-        fprintf(G_logfile, "Failed to open MD5 file %s, error %d!\n", filename, errno);
+        jd_log(0, "Failed to open MD5 file %s, error %d!\n", filename, errno);
         return errno;
     }
     
@@ -117,7 +119,7 @@ int parse_md5_file(char *filename)
         ret = fgets(buf, sizeof(buf), file);
         if (NULL == ret)
             break;
-        error = parse_md5_entry(strdup(buf));
+        error = parse_md5_entry(strdup(buf), md5_list_head);
     }
     return 0;
 }
@@ -138,10 +140,10 @@ static int file_exists(char *path, INT64 *size)
     return 0;
 }
 
-static int find_file_in_mirror(char *jigdo_match, char *jigdo_name,
+static int find_file_in_mirror(match_list_t *match_list_head, char *jigdo_match, char *jigdo_name,
                                char *match, INT64 *file_size, char **mirror_path)
 {
-    match_list_t *entry = G_match_list_head;
+    match_list_t *entry = match_list_head;
     char path[PATH_MAX];
 
     while (entry)
@@ -167,7 +169,8 @@ static int find_file_in_mirror(char *jigdo_match, char *jigdo_name,
    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)
+static int add_file_entry(char *jigdo_entry, match_list_t *match_list_head,
+                          md5_list_t **md5_list_head, char *missing_filename)
 {
     int error = 0;
     char *file_name = NULL;
@@ -199,37 +202,35 @@ static int add_file_entry(char *jigdo_entry)
             ptr++;
     }
 
-    if (find_file_in_md5_list(base64_md5))
+    if (find_file_in_md5_list(base64_md5, md5_list_head))
         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(G_logfile, "Could not parse malformed jigdo entry \"%s\"\n", jigdo_entry);
+        jd_log(0, "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);
+    error = find_file_in_mirror(match_list_head, match, jigdo_name, match, &file_size, &file_name);
 
     if (error)
        {
-               if (G_missing_filename)
-                       add_md5_entry(MISSING, base64_md5, file_name);
+               if (missing_filename)
+                       add_md5_entry(MISSING, base64_md5, file_name, md5_list_head);
                else
                {
-                       fprintf(G_logfile, "Unable to find a file to match %s\n", file_name);
-                       fprintf(G_logfile, "Abort!\n");
+                       jd_log(0, "Unable to find a file to match %s\n", file_name);
+                       jd_log(0, "Abort!\n");
                        exit (ENOENT);
                }
        }
     else
-        add_md5_entry(file_size, base64_md5, file_name);
+        add_md5_entry(file_size, base64_md5, file_name, md5_list_head);
     return 0;
 }
 
-
-
-int parse_jigdo_file(char *filename)
+int parse_jigdo_file(char *filename, md5_list_t **md5_list_head, match_list_t *match_list_head, char *missing_filename)
 {
     char buf[2048];
     gzFile *file = NULL;
@@ -239,7 +240,7 @@ int parse_jigdo_file(char *filename)
     file = gzopen(filename, "rb");
     if (!file)
     {
-        fprintf(G_logfile, "Failed to open jigdo file %s, error %d!\n", filename, errno);
+        jd_log(0, "Failed to open jigdo file %s, error %d!\n", filename, errno);
         return errno;
     }
 
@@ -261,7 +262,7 @@ int parse_jigdo_file(char *filename)
             break;
         if (!strcmp(buf, "[") || !strcmp(buf, "#"))
             continue;
-        error = add_file_entry(strdup(buf));
+        error = add_file_entry(strdup(buf), match_list_head, md5_list_head, missing_filename);
         if (error)
             break;
     }
index beff4e2..a46f984 100644 (file)
@@ -72,8 +72,8 @@ static int read_data_block(FILE *template_file)
         }
         if (-1 == template_offset)
         {
-            fprintf(G_logfile, "Unable to locate DATA block in template (offset %lld)\n",
-                    template_offset);
+            jd_log(0, "Unable to locate DATA block in template (offset %lld)\n",
+                   template_offset);
             return EINVAL;
         }    
     }
@@ -82,8 +82,8 @@ static int read_data_block(FILE *template_file)
     fread(inbuf, 16, 1, template_file);
     if (strncmp(inbuf, "DATA", 4) && strncmp(inbuf, "BZIP", 4))
     {
-        fprintf(G_logfile, "Unable to locate DATA block in template (offset %lld)\n",
-                template_offset);
+        jd_log(0, "Unable to locate DATA block in template (offset %lld)\n",
+               template_offset);
         return EINVAL;
     }    
     
@@ -93,24 +93,24 @@ static int read_data_block(FILE *template_file)
     comp_buf = calloc(1, compressed_len);
     if (!comp_buf)
     {
-        fprintf(G_logfile, "Unable to locate DATA block in template (offset %lld)\n",
-                template_offset);
+        jd_log(0, "Unable to locate DATA block in template (offset %lld)\n",
+               template_offset);
         return ENOMEM;
     }
     
     zip_state.data_buf = calloc(1, uncompressed_len);
     if (!zip_state.data_buf)
     {
-        fprintf(G_logfile, "Unable to allocate %lld bytes for decompression\n",
-                uncompressed_len);
+        jd_log(0, "Unable to allocate %lld bytes for decompression\n",
+               uncompressed_len);
         return ENOMEM;
     }
 
     read_num = fread(comp_buf, compressed_len, 1, template_file);
     if (0 == read_num)
     {
-        fprintf(G_logfile, "Unable to read %lld bytes for decompression\n",
-                uncompressed_len);
+        jd_log(0, "Unable to read %lld bytes for decompression\n",
+               uncompressed_len);
         return EIO;
     }
 
@@ -118,7 +118,7 @@ static int read_data_block(FILE *template_file)
                                   zip_state.data_buf, uncompressed_len, zip_state.algorithm);
     if (error)
     {
-        fprintf(G_logfile, "Unable to decompress data block, error %d\n", error);
+        jd_log(0, "Unable to decompress data block, error %d\n", error);
         return error;
     }
         
@@ -144,8 +144,8 @@ static int skip_data_block(INT64 data_size, FILE *template_file)
             error = read_data_block(template_file);
             if (error)
             {
-                fprintf(G_logfile, "Unable to decompress template data, error %d\n",
-                        error);
+                jd_log(0, "Unable to decompress template data, error %d\n",
+                       error);
                 return error;
             }
         }
@@ -160,11 +160,12 @@ static int skip_data_block(INT64 data_size, FILE *template_file)
         }
     }
     
-    fprintf(G_logfile, "skip_data_block: skipped %lld bytes of unmatched data\n", data_size);
+    jd_log(2, "skip_data_block: skipped %lld bytes of unmatched data\n", data_size);
     return error;
 }
 
-static int parse_data_block(INT64 data_size, FILE *template_file, struct mk_MD5Context *context, FILE *outfile)
+static int parse_data_block(INT64 data_size, FILE *template_file, INT64 image_size, INT64 current_offset,
+                            struct mk_MD5Context *context, FILE *outfile, int no_md5)
 {
     int error = 0;
     INT64 remaining = data_size;
@@ -178,8 +179,8 @@ static int parse_data_block(INT64 data_size, FILE *template_file, struct mk_MD5C
             error = read_data_block(template_file);
             if (error)
             {
-                fprintf(G_logfile, "Unable to decompress template data, error %d\n",
-                        error);
+                jd_log(0, "Unable to decompress template data, error %d\n",
+                       error);
                 return error;
             }
         }
@@ -187,14 +188,12 @@ static int parse_data_block(INT64 data_size, FILE *template_file, struct mk_MD5C
         write_size = fwrite(&zip_state.data_buf[zip_state.offset_in_curr_buf], size, 1, outfile);
         if (!write_size)
         {
-            fprintf(G_logfile, "parse_data_block: fwrite %lld failed with error %d; aborting\n", size, ferror(outfile));
+            jd_log(0, "parse_data_block: fwrite %lld failed with error %d; aborting\n", size, ferror(outfile));
             return ferror(outfile);
         }
 
-        if (G_verbose)
-            display_progress(outfile, "template data");
-
-        if (!G_quick)
+        display_progress(1, image_size, current_offset, "template data");
+        if (!no_md5)
             mk_MD5Update(context,
                                                 (unsigned char *)&zip_state.data_buf[zip_state.offset_in_curr_buf],
                                                 size);
@@ -207,12 +206,12 @@ static int parse_data_block(INT64 data_size, FILE *template_file, struct mk_MD5C
             zip_state.data_buf = NULL;
         }
     }
-    if (G_verbose > 1)
-        fprintf(G_logfile, "parse_data_block: wrote %lld bytes of unmatched data\n", data_size);
+    jd_log(2, "parse_data_block: wrote %lld bytes of unmatched data\n", data_size);
     return error;
 }
 
-static int read_file_data(char *filename, char *missing, INT64 offset, INT64 data_size,
+static int read_file_data(char *filename, char *missing, INT64 image_size, INT64 current_offset,
+                          INT64 offset, INT64 data_size, 
                           struct mk_MD5Context *file_context, struct mk_MD5Context *image_context,
                           FILE *outfile)
 {
@@ -225,8 +224,8 @@ static int read_file_data(char *filename, char *missing, INT64 offset, INT64 dat
     input_file = fopen(filename, "rb");
     if (!input_file)
     {
-        fprintf(G_logfile, "Unable to open mirror file %s, error %d\n",
-                filename, errno);
+        jd_log(0, "Unable to open mirror file %s, error %d\n",
+               filename, errno);
         return errno;
     }
 
@@ -245,8 +244,8 @@ static int read_file_data(char *filename, char *missing, INT64 offset, INT64 dat
         num_read = fread(buf, size, 1, input_file);
         if (!num_read)
         {
-            fprintf(G_logfile, "Unable to read from mirror file %s, error %d (offset %ld, length %d)\n",
-                    filename, errno, ftell(input_file), size);
+            jd_log(0, "Unable to read from mirror file %s, error %d (offset %ld, length %d)\n",
+                   filename, errno, ftell(input_file), size);
             fclose(input_file);
             return errno;
         }
@@ -259,25 +258,22 @@ static int read_file_data(char *filename, char *missing, INT64 offset, INT64 dat
         write_size = fwrite(buf, size, 1, outfile);
         if (!write_size)
         {
-            fprintf(G_logfile, "read_file_data: fwrite %d failed with error %d; aborting\n", size, ferror(outfile));
+            jd_log(0, "read_file_data: fwrite %d failed with error %d; aborting\n", size, ferror(outfile));
             return ferror(outfile);
         }
         
-        if (G_verbose)
-            display_progress(outfile, file_base_name(filename));
-        
+        display_progress(1, image_size, current_offset, file_base_name(filename));        
         remaining -= size;
     }
-    if (G_verbose > 1)
-        fprintf(G_logfile, "read_file_data: wrote %lld bytes of data from %s\n",
-                data_size, filename);
+    jd_log(2, "read_file_data: wrote %lld bytes of data from %s\n", data_size, filename);
     fclose(input_file);
     return 0;
 }
 
-static int parse_file_block(INT64 offset, INT64 data_size, INT64 file_size, FILE *outfile,
+static int parse_file_block(INT64 offset, INT64 data_size, INT64 image_size, INT64 current_offset,
+                            INT64 file_size, FILE *outfile,
                             JIGDB *dbp, unsigned char *md5, struct mk_MD5Context *image_context,
-                            char *missing)
+                            char *missing, int no_md5, md5_list_t **md5_list_head)
 {
     char *base64_md5 = base64_dump(md5, 16);
     struct mk_MD5Context file_context;
@@ -288,7 +284,7 @@ static int parse_file_block(INT64 offset, INT64 data_size, INT64 file_size, FILE
     int error = 0;
     char *filename = NULL;
 
-    if (!G_quick)
+    if (!no_md5)
     {
         use_context = &file_context;
         mk_MD5Init(use_context);
@@ -305,24 +301,24 @@ static int parse_file_block(INT64 offset, INT64 data_size, INT64 file_size, FILE
     /* No joy; fall back to the MD5 list */
     if (!filename)
     {
-        md5_list_entry = find_file_in_md5_list(base64_md5);
+        md5_list_entry = find_file_in_md5_list(base64_md5, md5_list_head);
         if (md5_list_entry && file_size == md5_list_entry->file_size)
             filename = md5_list_entry->full_path;
     }
 
     if (filename)
     {
-        error = read_file_data(filename, missing, offset, data_size,
+        error = read_file_data(filename, missing, image_size, current_offset, offset, data_size,
                                use_context, image_context, outfile);
         
         if (error && (ENOENT != error))
         {
-            fprintf(G_logfile, "Failed to read file %s, error %d\n", filename, error);
+            jd_log(0, "Failed to read file %s, error %d\n", filename, error);
             free(base64_md5);
             return error;
         }
         
-        if (!G_quick)
+        if (!no_md5)
         {
             mk_MD5Final(file_md5, &file_context);
             
@@ -330,14 +326,14 @@ static int parse_file_block(INT64 offset, INT64 data_size, INT64 file_size, FILE
             {
                 char *tmp_md5 = NULL;
 
-                fprintf(G_logfile, "MD5 MISMATCH for file %s\n", filename);
+                jd_log(0, "MD5 MISMATCH for file %s\n", filename);
 
                 tmp_md5 = base64_dump(md5, 16);
-                fprintf(G_logfile, "    template looking for %s\n", tmp_md5);
+                jd_log(0, "    template looking for %s\n", tmp_md5);
                 free(tmp_md5);
                 
                 tmp_md5 = base64_dump(file_md5, 16);
-                fprintf(G_logfile, "    file %s is    %s\n", filename, tmp_md5);
+                jd_log(0, "    file %s is    %s\n", filename, tmp_md5);
                 free(tmp_md5);
                 free(base64_md5);
                 return EINVAL;
@@ -362,8 +358,10 @@ static int parse_file_block(INT64 offset, INT64 data_size, INT64 file_size, FILE
     return ENOENT;
 }
 
-int parse_template_file(char *filename, int sizeonly, char *missing,
-                        FILE *outfile, char *output_name, JIGDB *dbp)
+int parse_template_file(char *filename, int sizeonly, int no_md5, char *missing,
+                        FILE *outfile, char *output_name, JIGDB *dbp,
+                        md5_list_t **md5_list_head, FILE *missing_file,
+                        UINT64 start_offset, UINT64 end_offset)
 {
     INT64 template_offset = 0;
     INT64 bytes = 0;
@@ -383,14 +381,14 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
     file = fopen(filename, "rb");
     if (!file)
     {
-        fprintf(G_logfile, "Failed to open template file %s, error %d!\n", filename, errno);
+        jd_log(0, "Failed to open template file %s, error %d!\n", filename, errno);
         return errno;
     }
 
     buf = malloc(BUF_SIZE);
     if (!buf)
     {
-        fprintf(G_logfile, "Failed to malloc %d bytes. Abort!\n", BUF_SIZE);
+        jd_log(0, "Failed to malloc %d bytes. Abort!\n", BUF_SIZE);
         fclose(file);
         return ENOMEM;
     }
@@ -407,39 +405,36 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
     fread(buf, BUF_SIZE, 1, file);
     if (buf[0] != 5) /* image data */
     {
-        fprintf(G_logfile, "Failed to find image desc in the template file\n");
+        jd_log(0, "Failed to find image desc in the template file\n");
         fclose(file);
         return EINVAL;
     }
 
     memcpy(image_md5sum, &buf[7], 16);
 
-    G_out_size = read_le48((unsigned char *)&buf[1]);
-    
     /* Now seek back to the start of the desc block */
     fseek(file, desc_start, SEEK_SET);
     fread(buf, 10, 1, file);
     if (strncmp(buf, "DESC", 4))
     {
-        fprintf(G_logfile, "Failed to find desc start in the template file\n");
+        jd_log(0, "Failed to find desc start in the template file\n");
         fclose(file);
         return EINVAL;
     }
     if ((file_size - desc_start) != read_le48((unsigned char *)&buf[4]))
     {
-        fprintf(G_logfile, "Inconsistent desc length in the template file!\n");
-        fprintf(G_logfile, "Final chunk says %lld, first chunk says %lld\n",
-                file_size - desc_start, read_le48((unsigned char *)&buf[4]));
+        jd_log(0, "Inconsistent desc length in the template file!\n");
+        jd_log(0, "Final chunk says %lld, first chunk says %lld\n",
+               file_size - desc_start, read_le48((unsigned char *)&buf[4]));
         fclose(file);
         return EINVAL;
     }
 
-    if (!G_quick)
+    if (!no_md5)
         mk_MD5Init(&template_context);
     template_offset = desc_start + 10;
 
-    if (1 == G_verbose)
-        fprintf(G_logfile, "Creating ISO image %s\n", output_name);
+    jd_log(1, "Creating ISO image %s\n", output_name);
 
     /* Main loop - walk through the template file and expand each entry we find */
     while (1)
@@ -450,14 +445,13 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
 
         if (template_offset >= (file_size - 33))
         {
-            if (G_verbose > 1)
-                fprintf(G_logfile, "Reached end of template file\n");
+            jd_log(2, "Reached end of template file\n");
             break; /* Finished! */
         }
         
-        if (output_offset > G_end_offset) /* Past the range we were asked for */
+        if (output_offset > end_offset) /* Past the range we were asked for */
         {
-            fprintf(G_logfile, "Reached end of range requested\n");            
+            jd_log(2, "Reached end of range requested\n");            
             break;
         }
         
@@ -465,7 +459,7 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
         bytes = fread(buf, (MIN (BUF_SIZE, file_size - template_offset)), 1, file);
         if (1 != bytes)
         {
-            fprintf(G_logfile, "Failed to read template file!\n");
+            jd_log(0, "Failed to read template file!\n");
             fclose(file);
             return EINVAL;
         }
@@ -473,10 +467,10 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
         extent_size = read_le48((unsigned char *)&buf[1]);
         read_length = extent_size;
         
-        if (G_start_offset > output_offset)
-            skip = G_start_offset - output_offset;
-        if ((output_offset + extent_size) > G_end_offset)
-            read_length -= (output_offset + extent_size - G_end_offset - 1);
+        if (start_offset > output_offset)
+            skip = start_offset - output_offset;
+        if ((output_offset + extent_size) > end_offset)
+            read_length -= (output_offset + extent_size - end_offset - 1);
         read_length -= skip;
         
         switch (buf[0])
@@ -486,20 +480,21 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
                 template_offset += 7;
                 if (missing)
                     break;
-                if ((output_offset + extent_size) >= G_start_offset)
+                if ((output_offset + extent_size) >= start_offset)
                 {
                     if (skip)
                         error = skip_data_block(skip, file);
                     if (error)
                     {
-                        fprintf(G_logfile, "Unable to read data block to skip, error %d\n", error);
+                        jd_log(0, "Unable to read data block to skip, error %d\n", error);
                         fclose(file);
                         return error;
                     }
-                    error = parse_data_block(read_length, file, &template_context, outfile);
+                    error = parse_data_block(read_length, file, end_offset - start_offset, output_offset,
+                                             &template_context, outfile, no_md5);
                     if (error)
                     {
-                        fprintf(G_logfile, "Unable to read data block, error %d\n", error);
+                        jd_log(0, "Unable to read data block, error %d\n", error);
                         fclose(file);
                         return error;
                     }
@@ -510,13 +505,15 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
                 break;
             case 6:
                 template_offset += 31;
-                if ((output_offset + extent_size) >= G_start_offset)
+                if ((output_offset + extent_size) >= start_offset)
                 {
-                    error = parse_file_block(skip, read_length, extent_size, outfile, dbp,
-                                             (unsigned char *)&buf[15], &template_context, missing);
+                    error = parse_file_block(skip, read_length, end_offset - start_offset, output_offset,
+                                             extent_size, outfile, dbp,
+                                             (unsigned char *)&buf[15], &template_context, missing,
+                                             no_md5, md5_list_head);
                     if (error)
                     {
-                        fprintf(G_logfile, "Unable to read file block, error %d\n", error);
+                        jd_log(0, "Unable to read file block, error %d\n", error);
                         fclose(file);
                         return error;
                     }
@@ -524,29 +521,26 @@ int parse_template_file(char *filename, int sizeonly, char *missing,
                 }
                 break;
             default:
-                fprintf(G_logfile, "Unknown block type %d!\n", buf[0]);
+                jd_log(0, "Unknown block type %d!\n", buf[0]);
                 fclose(file);
                 return EINVAL;
         }
         output_offset += extent_size;
     }
 
-    if (missing && G_missing_file)
+    if (missing && missing_file)
         return ENOENT;
     
     fclose(file);
-    if (G_verbose)
+    jd_log(1, "\n");
+    if (!no_md5)
     {
-        fprintf(G_logfile, "\n");
-        if (!G_quick)
-        {
-            mk_MD5Final (image_md5sum, &template_context);
-            fprintf(G_logfile, "Output image MD5 is    ");
-            for (i = 0; i < 16; i++)
-                fprintf(G_logfile, "%2.2x", image_md5sum[i]);
-            fprintf(G_logfile, "\n");
-        }
-        fprintf(G_logfile, "Output image length is %lld bytes\n", written_length);
+        mk_MD5Final (image_md5sum, &template_context);
+        jd_log(1, "Output image MD5 is    ");
+        for (i = 0; i < 16; i++)
+            jd_log(1, "%2.2x", image_md5sum[i]);
+        jd_log(1, "\n");
+        jd_log(1, "Output image length is %lld bytes\n", written_length);
     }
 
     free(buf);
@@ -577,14 +571,14 @@ int add_new_template_file(JIGDB *dbp, char *filename)
     file = fopen(filename, "rb");
     if (!file)
     {
-        fprintf(G_logfile, "add_new_template_file: Failed to open template file %s, error %d!\n", filename, errno);
+        jd_log(0, "add_new_template_file: Failed to open template file %s, error %d!\n", filename, errno);
         return errno;
     }
 
     buf = malloc(BUF_SIZE);
     if (!buf)
     {
-        fprintf(G_logfile, "add_new_template_file: Failed to malloc %d bytes. Abort!\n", BUF_SIZE);
+        jd_log(0, "add_new_template_file: Failed to malloc %d bytes. Abort!\n", BUF_SIZE);
         fclose(file);
         return ENOMEM;
     }
@@ -601,7 +595,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
     fread(buf, BUF_SIZE, 1, file);
     if (buf[0] != 5) /* image data */
     {
-        fprintf(G_logfile, "add_new_template_file: Failed to find image desc in the template file\n");
+        jd_log(0, "add_new_template_file: Failed to find image desc in the template file\n");
         fclose(file);
         return EINVAL;
     }
@@ -615,7 +609,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
     error = mk_MD5File(filename, tmp_md5sum);
     if (error)
     {
-        fprintf(G_logfile, "add_new_template_file: failed to get md5sum of template file %s, error %d\n", filename, error);
+        jd_log(0, "add_new_template_file: failed to get md5sum of template file %s, error %d\n", filename, error);
         return error;
     }
     md5_out = hex_dump(tmp_md5sum, 16);
@@ -629,7 +623,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
     error = db_store_template(dbp, &template);
     if (error)
     {
-        fprintf(G_logfile, "add_new_template_file: failed to store template entry for %s in the DB, error %d\n", filename, error);
+        jd_log(0, "add_new_template_file: failed to store template entry for %s in the DB, error %d\n", filename, error);
         return error;
     }
     
@@ -639,15 +633,15 @@ int add_new_template_file(JIGDB *dbp, char *filename)
     fread(buf, 10, 1, file);
     if (strncmp(buf, "DESC", 4))
     {
-        fprintf(G_logfile, "Failed to find desc start in template file %s\n", filename);
+        jd_log(0, "Failed to find desc start in template file %s\n", filename);
         fclose(file);
         return EINVAL;
     }
     if ((file_size - desc_start) != read_le48((unsigned char *)&buf[4]))
     {
-        fprintf(G_logfile, "Inconsistent desc length in template file %s!\n", filename);
-        fprintf(G_logfile, "Final chunk says %lld, first chunk says %lld\n",
-                file_size - desc_start, read_le48((unsigned char *)&buf[4]));
+        jd_log(0, "Inconsistent desc length in template file %s!\n", filename);
+        jd_log(0, "Final chunk says %lld, first chunk says %lld\n",
+               file_size - desc_start, read_le48((unsigned char *)&buf[4]));
         fclose(file);
         return EINVAL;
     }
@@ -664,8 +658,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
 
         if (template_offset >= (file_size - 33))
         {
-            if (G_verbose > 1)
-                fprintf(G_logfile, "Reached end of template file\n");
+            jd_log(2, "Reached end of template file\n");
             break; /* Finished! */
         }
         
@@ -673,7 +666,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
         bytes = fread(buf, (MIN (BUF_SIZE, file_size - template_offset)), 1, file);
         if (1 != bytes)
         {
-            fprintf(G_logfile, "Failed to read template file %s!\n", filename);
+            jd_log(0, "Failed to read template file %s!\n", filename);
             fclose(file);
             return EINVAL;
         }
@@ -694,7 +687,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
                 error = db_store_block(dbp, &block);
                 if (error)
                 {
-                    fprintf(G_logfile, "Failed to store unmatched data block at offset %lld in template file %s!\n", template_offset, filename);
+                    jd_log(0, "Failed to store unmatched data block at offset %lld in template file %s!\n", template_offset, filename);
                     fclose(file);
                     return error;
                 }
@@ -714,7 +707,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
                 error = db_store_block(dbp, &block);
                 if (error)
                 {
-                    fprintf(G_logfile, "Failed to store file block at offset %lld in template file %s!\n", template_offset, filename);
+                    jd_log(0, "Failed to store file block at offset %lld in template file %s!\n", template_offset, filename);
                     fclose(file);
                     return error;
                 }
@@ -722,16 +715,15 @@ int add_new_template_file(JIGDB *dbp, char *filename)
                 break;
 
             default:
-                fprintf(G_logfile, "Unknown block type %d in template file %s\n", buf[0], filename);
+                jd_log(0, "Unknown block type %d in template file %s\n", buf[0], filename);
                 fclose(file);
                 return EINVAL;
         }
         image_offset += extent_size;
     }
 
-    if (G_verbose)
-        fprintf(G_logfile, "Template file %s contains %d data blocks and %d file blocks\n",
-                filename, num_data_blocks, num_file_blocks);
+    jd_log(1, "Template file %s contains %d data blocks and %d file blocks\n",
+           filename, num_data_blocks, num_file_blocks);
 
     /* Now go back to the start of the template file. Look at all the
      * compressed blocks and add those to the "compressed" table */
@@ -764,7 +756,7 @@ int add_new_template_file(JIGDB *dbp, char *filename)
             break;
         else
         {
-            fprintf(G_logfile, "Failed to find compressed block at offset %lld in template file %s!\n", template_offset, filename);
+            jd_log(0, "Failed to find compressed block at offset %lld in template file %s!\n", template_offset, filename);
             fclose(file);
             return EINVAL;
         }
@@ -782,15 +774,14 @@ int add_new_template_file(JIGDB *dbp, char *filename)
         error = db_store_compressed(dbp, &compressed);
         if (error)
         {
-            fprintf(G_logfile, "Failed to store file block at offset %lld in template file %s!\n", template_offset, filename);
+            jd_log(0, "Failed to store file block at offset %lld in template file %s!\n", template_offset, filename);
             fclose(file);
             return error;
         }
     }
 
-    if (G_verbose)
-        fprintf(G_logfile, "Template file %s contains %d compressed blocks\n",
-                filename, num_compressed_blocks);
+    jd_log(1, "Template file %s contains %d compressed blocks\n",
+           filename, num_compressed_blocks);
 
     fclose(file);
     free(buf);