Version leap to 1.1.2

Updated changelog
Clarified a comment about retrieving content of boot catalog.
2011-07-08 10:28:12 +02:00 · 2011-07-08 10:25:24 +02:00 · 2011-07-07 14:11:30 +02:00 · 2011-07-06 12:31:37 +02:00 · 2011-07-04 18:54:11 +02:00 · 2011-07-04 16:07:35 +02:00
34 changed files with 822 additions and 453 deletions
--- a/10
+++ b/10
@ -1,3 +1,13 @@
+libisofs-1.1.2.tar.gz Fri Jul 08 2011
+===============================================================================
+* New API call iso_image_get_bootcat()
+
+libisofs-1.1.0.tar.gz Sat Jun 18 2011
+===============================================================================
+* Bug fix: Padding as of iso_write_opts_set_tail_blocks() was added only
+           after cylinder alignment as of iso_write_opts_set_system_area()
+           and thus spoiled this alignment.
+
 libisofs-1.0.8.tar.gz Thu May 12 2011
 ===============================================================================
 * Bug fix: iso_write_opts_set_system_area() with system area types
--- a/Makefile.am
+++ b/Makefile.am
@ -6,6 +6,7 @@ pkgconfigdir=$(LIBBURNIA_PKGCONFDIR)
 libincludedir=$(includedir)/libisofs

 lib_LTLIBRARIES = libisofs/libisofs.la
+ACLOCAL_AMFLAGS = -I ./

 ## ========================================================================= ##

--- a/5
+++ b/5
@ -1,10 +1,7 @@
 #!/bin/sh -x

-aclocal
+aclocal -I .
 libtoolize --copy --force
 autoconf

-# ts A61101 : libburn is not prepared for config.h
-# autoheader
-
 automake --foreign --add-missing --copy --include-deps
--- a/configure.ac
+++ b/configure.ac
@ -1,4 +1,4 @@
-AC_INIT([libisofs], [1.0.8], [http://libburnia-project.org])
+AC_INIT([libisofs], [1.1.2], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	

@ -8,6 +8,7 @@ AC_CANONICAL_TARGET
 LIBBURNIA_SET_FLAGS

 AM_INIT_AUTOMAKE([subdir-objects])
+AC_CONFIG_MACRO_DIR([./])

 dnl
 dnl if MAJOR or MINOR version changes, be sure to change AC_INIT above to match
@ -39,8 +40,8 @@ dnl
 dnl If LIBISOFS_*_VERSION changes, be sure to change AC_INIT above to match.
 dnl
 LIBISOFS_MAJOR_VERSION=1
-LIBISOFS_MINOR_VERSION=0
-LIBISOFS_MICRO_VERSION=8
+LIBISOFS_MINOR_VERSION=1
+LIBISOFS_MICRO_VERSION=2
 LIBISOFS_VERSION=$LIBISOFS_MAJOR_VERSION.$LIBISOFS_MINOR_VERSION.$LIBISOFS_MICRO_VERSION

 AC_SUBST(LIBISOFS_MAJOR_VERSION)
@ -50,10 +51,10 @@ AC_SUBST(LIBISOFS_VERSION)

 dnl Libtool versioning
 LT_RELEASE=$LIBISOFS_MAJOR_VERSION.$LIBISOFS_MINOR_VERSION
-# 2011.05.12  development jump has not yet happened
-# SONAME = 52 - 46 = 6 . Library name = libisofs.6.46.0
-LT_CURRENT=52
-LT_AGE=46
+# 2011.07.08  development jump has not yet happened
+# SONAME = 56 - 50 = 6 . Library name = libisofs.6.50.0
+LT_CURRENT=56
+LT_AGE=50
 LT_REVISION=0
 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`

@ -139,7 +140,7 @@ if test x$enable_debug != xyes; then
    CFLAGS="-DNDEBUG $CFLAGS"
 else
    if test x$GCC = xyes; then
-        CFLAGS="-g -pedantic -Wall $CFLAGS"
+        CFLAGS="-g -pedantic -Wall -Wextra -Wno-unused-parameter $CFLAGS"
    fi
    CFLAGS="-DDEBUG $CFLAGS"
 fi
--- a/libisofs/aaip-os-freebsd.c
+++ b/libisofs/aaip-os-freebsd.c
@ -229,7 +229,7 @@ ex:;

 if(ret <= 0 || (flag & (1 << 15))) {
   if(*names != NULL) {
-     for(i= 0; i < *num_attrs; i++)
+     for(i= 0; i < (ssize_t) *num_attrs; i++)
       free((*names)[i]);
     free(*names);
   }
@ -238,7 +238,7 @@ ex:;
     free(*value_lengths);
   *value_lengths= NULL;
   if(*values != NULL) {
-     for(i= 0; i < *num_attrs; i++)
+     for(i= 0; i < (ssize_t) *num_attrs; i++)
       free((*values)[i]);
     free(*values);
   }
--- a/libisofs/aaip-os-linux.c
+++ b/libisofs/aaip-os-linux.c
@ -220,7 +220,7 @@ int aaip_get_attr_list(char *path, size_t *num_attrs, char ***names,
   (*value_lengths)[i]= 0;
 }
 if(!(flag & 4)) {
-   for(i= 0; i < list_size && num_names > *num_attrs;
+   for(i= 0; i < list_size && (size_t) num_names > *num_attrs;
       i+= strlen(list + i) + 1) {
     if(!(flag & 8))
       if(strncmp(list + i, "user.", 5))
@ -234,7 +234,7 @@ int aaip_get_attr_list(char *path, size_t *num_attrs, char ***names,
 #ifdef Libisofs_with_aaip_xattR

 if(!(flag & 4)) { /* Get xattr values */
-   for(i= 0; i < *num_attrs; i++) {
+   for(i= 0; (size_t) i < *num_attrs; i++) {
     if(!(flag & 8))
       if(strncmp((*names)[i], "user.", 5))
   continue;
@ -299,7 +299,7 @@ ex:;
   free(list);
 if(ret <= 0 || (flag & (1 << 15))) {
   if(*names != NULL) {
-     for(i= 0; i < *num_attrs; i++)
+     for(i= 0; (size_t) i < *num_attrs; i++)
       free((*names)[i]);
     free(*names);
   }
@ -308,7 +308,7 @@ ex:;
     free(*value_lengths);
   *value_lengths= NULL;
   if(*values != NULL) {
-     for(i= 0; i < *num_attrs; i++)
+     for(i= 0; (size_t) i < *num_attrs; i++)
       free((*values)[i]);
     free(*values);
   }
@ -422,7 +422,7 @@ int aaip_set_attr_list(char *path, size_t num_attrs, char **names,
     list_size= llistxattr(path, list, list_size);
   if(list_size == -1)
     {ret= -5; goto ex;}
-   for(i= 0; i < list_size; i+= strlen(list + i) + 1) {
+   for(i= 0; i < (size_t) list_size; i+= strlen(list + i) + 1) {
      if(!(flag & 8))
        if(strncmp(list + i, "user.", 5))
   continue;
--- a/libisofs/aaip_0_2.c
+++ b/libisofs/aaip_0_2.c
@ -4,10 +4,10 @@
 Arbitrary Attribute Interchange Protocol , AAIP versions 0.2 , 1.0 , 2.0.
 Implementation of encoding and decoding xattr and ACL.

- See test/aaip_0_2.h
+ See libisofs/aaip_0_2.h
     http://libburnia-project.org/wiki/AAIP

- Copyright (c) 2009 Thomas Schmitt, libburnia project, GPLv2+
+ Copyright (c) 2009 - 2011 Thomas Schmitt, libburnia project, GPLv2+

 */

@ -26,6 +26,7 @@
 #include <sys/stat.h>

 #include "libisofs.h"
+#include "util.h"

 /*
 #define Aaip_encode_debuG 1
@ -95,7 +96,7 @@ size_t aaip_encode(size_t num_attrs, char **names,
                   size_t *result_len, unsigned char **result, int flag)
 {
 size_t mem_size= 0, comp_size;
- unsigned int number_of_fields, i, num_recs, total_recs= 0, ret;
+ unsigned int number_of_fields, i, num_recs, ret;

 /* Predict memory needs, number of SUSP fields and component records */
 *result_len= 0;
@ -105,7 +106,6 @@ size_t aaip_encode(size_t num_attrs, char **names,
   if(ret <= 0)
     return(ret);
   mem_size+= comp_size;
-   total_recs= num_recs;
 }
 number_of_fields= mem_size / 250 + !!(mem_size % 250);
 mem_size+= number_of_fields * 5;
@ -187,7 +187,7 @@ static int aaip_encode_comp(unsigned char *result, size_t *result_fill,
   aaip_encode_byte(result, result_fill, 0);
   return(1);
 }
- for(rpt= data; rpt - data < l;) {
+ for(rpt= data; rpt - data < (ssize_t) l;) {
   todo= l - (rpt - data) + (prefix > 0);
   aaip_encode_byte(result, result_fill, (todo > 255));
   if(todo > 255)
@ -198,7 +198,7 @@ static int aaip_encode_comp(unsigned char *result, size_t *result_fill,
     todo--;
     prefix= 0;
   }
-   for(comp_start= rpt; rpt - comp_start < todo; rpt++)
+   for(comp_start= rpt; rpt - comp_start < (ssize_t) todo; rpt++)
     aaip_encode_byte(result, result_fill, *((unsigned char *) rpt));
 }
 return(1);
@ -292,7 +292,7 @@ int aaip_encode_acl(char *acl_text, mode_t st_mode,
 *result_len= bytes;
 bytes= aaip_encode_acl_text(acl_text, st_mode, *result_len, *result,
                             (flag & (2 | 4 | 8)));
- if(bytes != *result_len) {
+ if((size_t) bytes != *result_len) {
   *result_len= 0;
   return(0);
 }
@ -346,21 +346,23 @@ static ssize_t aaip_encode_acl_text(char *acl_text, mode_t st_mode,
                           size_t result_size, unsigned char *result, int flag)
 {
 char *rpt, *npt, *cpt;
- int qualifier= 0, perms, type, i, qualifier_len= 0, num_recs, needed= 0;
+ int qualifier= 0, perms, type, i, qualifier_len= 0, num_recs, needed= 0, ret;
 unsigned int has_u= 0, has_g= 0, has_o= 0, has_m= 0, is_trivial= 1;
 uid_t uid, huid;
 gid_t gid, hgid;
 ssize_t count= 0;
 struct passwd *pwd;
 struct group *grp;
- char name[1024];
+ char *name = NULL;
+ int name_size= 1024;
 double num;

+ LIBISO_ALLOC_MEM(name, char, name_size);
 if(flag & 4) {
   /* set SWITCH_MARK to indicate a default ACL */;
   if(!(flag & 1)) {
-     if(count >= result_size)
-       return(-1);
+     if((size_t) count >= result_size)
+       {ret= -1; goto ex;}
     result[count]= (Aaip_SWITCH_MARK << 4) | Aaip_EXEC;
   }
   count++;
@ -386,7 +388,7 @@ static ssize_t aaip_encode_acl_text(char *acl_text, mode_t st_mode,
       type= Aaip_ACL_USER_OBJ;
       has_u++;
     } else {
-       if(cpt - (rpt + 5) >= sizeof(name))
+       if(cpt - (rpt + 5) >= name_size)
 continue;
       is_trivial= 0;
       strncpy(name, rpt + 5, cpt - (rpt + 5)); 
@ -419,7 +421,7 @@ user_by_name:;
       type= Aaip_ACL_GROUP_OBJ;
       has_g++;
     } else {
-       if(cpt - (rpt + 6) >= sizeof(name))
+       if(cpt - (rpt + 6) >= name_size)
 continue;
       is_trivial= 0;
       strncpy(name, rpt + 6, cpt - (rpt + 6)); 
@ -461,8 +463,8 @@ group_by_name:;
   perms= aaip_make_aaip_perms(cpt[1] == 'r', cpt[2] == 'w', cpt[3] == 'x');

   if(!(flag & 1)) {
-     if(count >= result_size)
-       return(-1);
+     if((size_t) count >= result_size)
+       {ret= -1; goto ex;}
     result[count]= perms | ((!!qualifier) << 3) | (type << 4);
   }
   count++;
@ -470,8 +472,8 @@ group_by_name:;
   if(qualifier) {
     num_recs= (qualifier_len / 127) + !!(qualifier_len % 127);
     if(!(flag & 1)) {
-       if(count + 1 > result_size)
-         return(-1);
+       if((size_t) (count + 1) > result_size)
+         {ret= -1; goto ex;}
       for(i= 0; i < num_recs; i++) {
         if(i < num_recs - 1)
           result[count++]= 255;
@ -480,8 +482,8 @@ group_by_name:;
           if(result[count - 1] == 0)
             result[count - 1]= 127;
         }
-         if(count + (result[count - 1] & 127) > result_size)
-           return(-1);
+         if((size_t) (count + (result[count - 1] & 127)) > result_size)
+           {ret= -1; goto ex;}
         memcpy(result + count, name + i * 127, result[count - 1] & 127);
         count+= result[count - 1] & 127;
       }
@ -495,8 +497,8 @@ group_by_name:;
   if(flag & 1)
     count+= needed;
   else {
-     if(count + needed > result_size)
-       return(-1);
+     if((size_t) (count + needed) > result_size)
+       {ret= -1; goto ex;}
   }
 }
 if ((flag & 8) && needed > 0 && !(flag & 1)) {
@ -521,7 +523,10 @@ group_by_name:;
     result[count++]= perms | (Aaip_ACL_MASK << 4);
   }
 }
- return(count);
+ ret= count;
+ex:;
+ LIBISO_FREE_MEM(name);
+ return(ret);
 }


@ -1120,9 +1125,9 @@ static int aaip_consume_rec_head(struct aaip_state *aaip,
 size_t todo;

 todo= *num_data;
- if(todo > aaip->aa_missing)
+ if(todo > (size_t) aaip->aa_missing)
   todo= aaip->aa_missing;
- if(todo >= aaip->rec_head_missing)
+ if(todo >= (size_t) aaip->rec_head_missing)
   todo= aaip->rec_head_missing;
 if(!aaip->recs_invalid)
   aaip_push_to_recs(aaip, *data, todo, 0);
@ -1144,9 +1149,9 @@ static int aaip_consume_rec_data(struct aaip_state *aaip,
 size_t todo;
 
 todo= *num_data;
- if(todo > aaip->aa_missing)
+ if(todo > (size_t) aaip->aa_missing)
   todo= aaip->aa_missing;
- if(todo > aaip->rec_missing)
+ if(todo > (size_t) aaip->rec_missing)
   todo= aaip->rec_missing;
 if(!aaip->recs_invalid)
   aaip_push_to_recs(aaip, *data, todo, 1);
@ -1178,7 +1183,7 @@ static int aaip_consume_aa_head(struct aaip_state *aaip,
 unsigned char aa_head[5];

 todo= *num_data;
- if(todo >= aaip->aa_head_missing)
+ if(todo >= (size_t) aaip->aa_head_missing)
   todo= aaip->aa_head_missing;
 aaip_push_to_recs(aaip, *data, todo, 0);
 aaip->aa_head_missing-= todo;
@ -1225,7 +1230,7 @@ static int aaip_consume_aa_data(struct aaip_state *aaip,
         aaip_push_to_recs(aaip, zero_char, 1, 0);
       } else {
         /* fill in missing btes */
-         for(i= 0; i < aaip->rec_missing; i++)
+         for(i= 0; (int) i < aaip->rec_missing; i++)
           aaip_push_to_recs(aaip, zero_char, 1, 1);
       }
       aaip->rec_head_missing= 2;
@ -1696,7 +1701,7 @@ int aaip_decode_attrs(struct aaip_state **handle,
                      unsigned char *data, size_t num_data, size_t *consumed, 
                      int flag)
 {
- int ret, was_non_aa= 0;
+ int ret;
 struct aaip_state *aaip;
 size_t h_num, *h_lengths, i, new_mem, pair_consumed= 0;
 char **h_names, **h_values, *hpt;
@ -1785,7 +1790,6 @@ int aaip_decode_attrs(struct aaip_state **handle,
       return(ret);

   } else if(ret == -1) { /* non-AAIP field detected */
-     was_non_aa= 1;
     if(pair_consumed <= 0)
       return(-4); /* interpretation did not advance */

@ -1968,14 +1972,16 @@ static int aaip_read_qualifier(unsigned char *data, size_t num_data,
                               char *name, size_t name_size, size_t *name_fill,
                               int flag)
 {
- int is_done= 0, rec_len= 0;
+ int is_done= 0;
+ size_t rec_len= 0;
 unsigned char *rpt;

 *name_fill= 0;
 for(rpt= data; !is_done; rpt+= rec_len) {
   rec_len= (*rpt) & 127;
   is_done= !((*rpt) & 128);
-   if(*name_fill + rec_len >= name_size || rpt + 1 + rec_len - data > num_data)
+   if(*name_fill + rec_len >= name_size ||
+      (size_t) (rpt + 1 + rec_len - data) > num_data)
     return(-1);
   memcpy(name + *name_fill, rpt + 1, rec_len);
   rpt+= 1 + rec_len;
@ -2013,20 +2019,21 @@ int aaip_decode_acl(unsigned char *data, size_t num_data, size_t *consumed,
                    size_t *acl_text_fill, int flag)
 {
 unsigned char *rpt;
- char perm_text[4], *wpt, name[1024];
- int type, qualifier= 0, perm, ret, i, cnt;
- size_t w_size, name_fill= 0;
+ char perm_text[4], *wpt, *name= NULL;
+ int type, qualifier= 0, perm, ret, cnt, name_size= 1024;
+ size_t w_size, name_fill= 0, i;
 uid_t uid;
 gid_t gid;
 struct passwd *pwd;
 struct group *grp;

+ LIBISO_ALLOC_MEM(name, char, name_size);
 cnt= flag & 1;
 *consumed= 0;
 wpt= acl_text;
 w_size= acl_text_size;
 *acl_text_fill= 0;
- for(rpt= data; rpt - data < num_data; ) {
+ for(rpt= data; (size_t) (rpt - data) < num_data; ) {
   perm= *rpt;
   strcpy(perm_text, "---");
   if(perm & Aaip_READ)
@ -2038,14 +2045,14 @@ int aaip_decode_acl(unsigned char *data, size_t num_data, size_t *consumed,
     
   type= (*rpt) >> 4;
   if(type == Aaip_FUTURE_VERSION) /* indicate to caller: version mismatch */
-     return(-3);
+     {ret = -3; goto ex;}

   qualifier= !!((*rpt) & 8);
   if(qualifier) {
     ret= aaip_read_qualifier(rpt + 1, num_data - (rpt + 1 - data),
-                              name, sizeof(name), &name_fill, 0);
+                              name, name_size, &name_fill, 0);
     if(ret <= 0)
-       return(-1);
+       {ret = -1; goto ex;}
   }

   /* Advance read pointer */
@ -2086,7 +2093,7 @@ int aaip_decode_acl(unsigned char *data, size_t num_data, size_t *consumed,
     pwd= getpwuid(uid);
     if(pwd == NULL)
       sprintf(name, "%.f", (double) uid);
-     else if(strlen(pwd->pw_name) >= sizeof(name))
+     else if(strlen(pwd->pw_name) >= (size_t) name_size)
       sprintf(name, "%.f", (double) uid);
     else
       strcpy(name, pwd->pw_name);
@ -2100,7 +2107,7 @@ int aaip_decode_acl(unsigned char *data, size_t num_data, size_t *consumed,
     grp= getgrgid(gid);
     if(grp == NULL)
       sprintf(name, "%.f", (double) gid);
-     else if(strlen(grp->gr_name) >= sizeof(name))
+     else if(strlen(grp->gr_name) >= (size_t) name_size)
       sprintf(name, "%.f", (double) gid);
     else
       strcpy(name, grp->gr_name);
@ -2108,15 +2115,16 @@ int aaip_decode_acl(unsigned char *data, size_t num_data, size_t *consumed,
     ret= aaip_write_acl_line(&wpt, &w_size, "group", name, perm_text, cnt);
   } else {
     /* indicate to caller: unknown type */
-     return(-4);
+     {ret = -4; goto ex;}
   }
   if(ret <= 0)
-     return(-2);
+     {ret = -2; goto ex;}
 }
 ret= 1;
 ex:;
 if(flag & 1)
   *acl_text_fill= w_size + 1;
+ LIBISO_FREE_MEM(name);
 return(ret);
 }

--- a/libisofs/buffer.c
+++ b/libisofs/buffer.c
@ -150,7 +150,7 @@ void iso_ring_buffer_free(IsoRingBuffer *buf)
 int iso_ring_buffer_write(IsoRingBuffer *buf, uint8_t *data, size_t count)
 {
    size_t len;
-    int bytes_write = 0;
+    size_t bytes_write = 0;

    if (buf == NULL || data == NULL) {
        return ISO_NULL_POINTER;
@ -206,7 +206,7 @@ int iso_ring_buffer_write(IsoRingBuffer *buf, uint8_t *data, size_t count)
 int iso_ring_buffer_read(IsoRingBuffer *buf, uint8_t *dest, size_t count)
 {
    size_t len;
-    int bytes_read = 0;
+    size_t bytes_read = 0;

    if (buf == NULL || dest == NULL) {
        return ISO_NULL_POINTER;
--- a/libisofs/builder.c
+++ b/libisofs/builder.c
@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
 * 
 * This file is part of the libisofs project; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License version 2 
@ -20,6 +20,7 @@
 #include "fsource.h"
 #include "image.h"
 #include "aaip_0_2.h"
+#include "util.h"

 #include <stdlib.h>
 #include <string.h>
@ -104,9 +105,11 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
    char *name;
    unsigned char *aa_string = NULL;
    char *a_text = NULL, *d_text = NULL;
+    char *dest = NULL;
+    IsoSymlink *link;

    if (builder == NULL || src == NULL || node == NULL) {
-        return ISO_NULL_POINTER;
+        {ret = ISO_NULL_POINTER; goto ex;}
    }

    /* get info about source */
@ -116,7 +119,7 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
        ret = iso_file_source_lstat(src, &info);
    }
    if (ret < 0) {
-        return ret;
+        goto ex;
    }

    name = iso_file_source_get_name(src);
@ -157,9 +160,7 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
    case S_IFLNK:
        {
            /* source is a symbolic link */
-            char dest[LIBISOFS_NODE_PATH_MAX];
-            IsoSymlink *link;
-
+            LIBISO_ALLOC_MEM(dest, char, LIBISOFS_NODE_PATH_MAX);
            ret = iso_file_source_readlink(src, dest, LIBISOFS_NODE_PATH_MAX);
            if (ret < 0) {
                break;
@ -198,7 +199,7 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
    
    if (ret < 0) {
        free(name);
-        return ret;
+        goto ex;
    }

    /* fill fields */
@ -233,14 +234,17 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
    if (ret == 1 && aa_string != NULL) {
        ret = iso_node_add_xinfo(new, aaip_xinfo_func, aa_string);
        if (ret < 0)
-            return ret;
+            goto ex;
    } else if(aa_string != NULL) {
        free(aa_string);
    }

    *node = new;

-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(dest);
+    return ret;
 }

 static
--- a/libisofs/ecma119.c
+++ b/libisofs/ecma119.c
@ -576,16 +576,16 @@ static
 int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
 {
    int ret;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;
    size_t i;
    size_t fi_len, len;
    struct susp_info info;

    /* buf will point to current write position on buffer */
-    uint8_t *buf = buffer;
+    uint8_t *buf;

-    /* initialize buffer with 0s */
-    memset(buffer, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
+    buf = buffer;

    /*
     * set susp_info to 0's, this way code for both plain ECMA-119 and
@ -602,7 +602,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
    if (t->rockridge) {
        ret = rrip_get_susp_fields(t, dir, 1, 34, &info);
        if (ret < 0) {
-            return ret;
+            goto ex;
        }
    }
    len = 34 + info.suf_len;
@ -612,7 +612,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
    if (t->rockridge) {
        ret = rrip_get_susp_fields(t, dir, 2, 34, &info);
        if (ret < 0) {
-            return ret;
+            goto ex;
        }
    }
    len = 34 + info.suf_len;
@ -638,7 +638,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
            if (t->rockridge) {
                ret = rrip_get_susp_fields(t, child, 0, len, &info);
                if (ret < 0) {
-                    return ret;
+                    goto ex;
                }
                len += info.suf_len;
            }
@ -647,7 +647,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
                /* dir doesn't fit in current block */
                ret = iso_write(t, buffer, BLOCK_SIZE);
                if (ret < 0) {
-                    return ret;
+                    goto ex;
                }
                memset(buffer, 0, BLOCK_SIZE);
                buf = buffer;
@ -661,7 +661,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
    /* write the last block */
    ret = iso_write(t, buffer, BLOCK_SIZE);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }

    /* write the Continuation Area if needed */
@ -669,6 +669,8 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
        ret = rrip_write_ce_fields(t, &info);
    }

+ex:;
+    LIBISO_FREE_MEM(buffer);
    return ret;
 }

@ -708,6 +710,7 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
    uint32_t path_table_size;
    int parent = 0;
    int ret= ISO_SUCCESS;
+    uint8_t *zeros = NULL;

    path_table_size = 0;
    write_int = l_type ? iso_lsb : iso_msb;
@ -735,7 +738,7 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
        ret = iso_write(t, buf, len);
        if (ret < 0) {
            /* error */
-            return ret;
+            goto ex;
        }
        path_table_size += len;
    }
@ -743,11 +746,12 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
    /* we need to fill the last block with zeros */
    path_table_size %= BLOCK_SIZE;
    if (path_table_size) {
-        uint8_t zeros[BLOCK_SIZE];
        len = BLOCK_SIZE - path_table_size;
-        memset(zeros, 0, len);
+        LIBISO_ALLOC_MEM(zeros, uint8_t, len);
        ret = iso_write(t, zeros, len);
    }
+ex:;
+    LIBISO_FREE_MEM(zeros);
    return ret;
 }

@ -878,28 +882,28 @@ int ecma119_writer_write_data(IsoImageWriter *writer)
    int ret;
    Ecma119Image *t;
    uint32_t curblock;
+    char *msg = NULL;
+
+    if (writer == NULL)
+        {ret = ISO_ASSERT_FAILURE; goto ex;}

-    if (writer == NULL) {
-        return ISO_ASSERT_FAILURE;
-    }
    t = writer->target;

    ret = ecma119_writer_write_dirs(writer);
    if (ret < 0)
-        return ret;
+        goto ex;

    if (t->partition_offset > 0) {
        t->eff_partition_offset = t->partition_offset;
        ret = ecma119_writer_write_dirs(writer);
        t->eff_partition_offset = 0;
        if (ret < 0) 
-            return ret;
+            goto ex;
    }

    curblock = (t->bytes_written / 2048) + t->ms_block;
    if (curblock != t->tree_end_block) {
-        char msg[100];
-
+        LIBISO_ALLOC_MEM(msg, char, 100);
        sprintf(msg,
                "Calculated and written ECMA-119 tree end differ: %lu <> %lu",
                (unsigned long) t->tree_end_block,
@ -908,8 +912,10 @@ int ecma119_writer_write_data(IsoImageWriter *writer)

        t->tree_end_block = 1;/* Mark for harsher reaction at end of writing */
    }
-
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(msg);
+    return ret;
 }

 static
@ -990,27 +996,30 @@ int mspad_writer_write_data(IsoImageWriter *writer)
 {
    int ret;
    Ecma119Image *t;
-    uint8_t pad[BLOCK_SIZE];
+    uint8_t *pad = NULL;
    size_t i;

    if (writer == NULL) {
-        return ISO_ASSERT_FAILURE;
+        {ret = ISO_ASSERT_FAILURE; goto ex;}
    }
    t = writer->target;

    if (t->mspad_blocks == 0) {
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
    }

-    memset(pad, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(pad, uint8_t, BLOCK_SIZE);
    for (i = 0; i < t->mspad_blocks; ++i) {
        ret = iso_write(t, pad, BLOCK_SIZE);
        if (ret < 0) {
-            return ret;
+            goto ex;
        }
    }

-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(pad);
+    return ret;
 }

 static
@ -1076,23 +1085,26 @@ int zero_writer_write_data(IsoImageWriter *writer)
    int ret;
    Ecma119Image *t;
    struct iso_zero_writer_data_struct *data;
-    uint8_t pad[BLOCK_SIZE];
+    uint8_t *pad = NULL;
    size_t i;

    if (writer == NULL)
-        return ISO_ASSERT_FAILURE;
+        {ret = ISO_ASSERT_FAILURE; goto ex;}
    t = writer->target;
    data = (struct iso_zero_writer_data_struct *) writer->data;

    if (data->num_blocks == 0) 
-        return ISO_SUCCESS;
-    memset(pad, 0, BLOCK_SIZE);
+        {ret = ISO_SUCCESS; goto ex;}
+    LIBISO_ALLOC_MEM(pad, uint8_t, BLOCK_SIZE);
    for (i = 0; i < data->num_blocks; ++i) {
        ret = iso_write(t, pad, BLOCK_SIZE);
        if (ret < 0) 
-            return ret;
+            goto ex;
    }
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(pad);
+    return ret;
 }

 static
@ -1113,7 +1125,7 @@ int tail_writer_compute_data_blocks(IsoImageWriter *writer)
    int ret;
    Ecma119Image *target;
    struct iso_zero_writer_data_struct *data;
-    char msg[160];
+    char msg[80];

    target = writer->target;
    ret = iso_align_isohybrid(target, 0);
@ -1185,11 +1197,11 @@ int transplant_checksum_buffer(Ecma119Image *target, int flag)
 static
 int write_vol_desc_terminator(Ecma119Image *target)
 {
-    int res;
-    uint8_t buf[BLOCK_SIZE];
+    int ret;
+    uint8_t *buf = NULL;
    struct ecma119_vol_desc_terminator *vol;

-    memset(buf, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buf, uint8_t, BLOCK_SIZE);

    vol = (struct ecma119_vol_desc_terminator *) buf;

@ -1197,8 +1209,10 @@ int write_vol_desc_terminator(Ecma119Image *target)
    memcpy(vol->std_identifier, "CD001", 5);
    vol->vol_desc_version[0] = 1;

-    res = iso_write(target, buf, BLOCK_SIZE);
-    return res;
+    ret = iso_write(target, buf, BLOCK_SIZE);
+ex:
+    LIBISO_FREE_MEM(buf);
+    return ret;
 }


@ -1229,7 +1243,7 @@ int write_head_part1(Ecma119Image *target, int *write_count, int flag)

    /* write volume descriptors, one per writer */
    iso_msg_debug(target->image->id, "Write volume descriptors");
-    for (i = 0; i < target->nwriters; ++i) {
+    for (i = 0; i < (int) target->nwriters; ++i) {
        writer = target->writers[i];
        res = writer->write_vol_desc(writer);
        if (res < 0) 
@ -1257,26 +1271,27 @@ write_error:;
 static
 int write_head_part2(Ecma119Image *target, int *write_count, int flag)
 {
-    int res, i;
-    uint8_t buf[BLOCK_SIZE];
+    int ret, i;
+    uint8_t *buf = NULL;
    IsoImageWriter *writer;

    if (target->partition_offset <= 0)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}

    /* Write multi-session padding up to target->partition_offset + 16 */
-    memset(buf, 0, BLOCK_SIZE);
-    for(; *write_count < target->partition_offset + 16; (*write_count)++) {
-        res = iso_write(target, buf, BLOCK_SIZE);
-        if (res < 0)
-            goto write_error;
+    LIBISO_ALLOC_MEM(buf, uint8_t, BLOCK_SIZE);
+    for(; *write_count < (int) target->partition_offset + 16;
+        (*write_count)++) {
+        ret = iso_write(target, buf, BLOCK_SIZE);
+        if (ret < 0)
+            goto ex;
    }

    /* Write volume descriptors subtracting
      target->partiton_offset from any LBA pointer.
    */
    target->eff_partition_offset = target->partition_offset;
-    for (i = 0; i < target->nwriters; ++i) {
+    for (i = 0; i < (int) target->nwriters; ++i) {
        writer = target->writers[i];
        /* Not all writers have an entry in the partion volume descriptor set.
           It must be guaranteed that they write exactly one block.
@ -1287,23 +1302,23 @@ int write_head_part2(Ecma119Image *target, int *write_count, int flag)
        if(writer->write_vol_desc != ecma119_writer_write_vol_desc &&
           writer->write_vol_desc != joliet_writer_write_vol_desc)
    continue;
-        res = writer->write_vol_desc(writer);
-        if (res < 0)
-            goto write_error;
+        ret = writer->write_vol_desc(writer);
+        if (ret < 0)
+            goto ex;
        (*write_count)++;
    }
-    res = write_vol_desc_terminator(target);
-    if (res < 0)
-        goto write_error;
+    ret = write_vol_desc_terminator(target);
+    if (ret < 0)
+        goto ex;
    (*write_count)++;
    target->eff_partition_offset = 0;

    /* >>> TWINTREE: Postponed for now:
                     Write second superblock checksum tag */;

-    return ISO_SUCCESS;
-write_error:;
-    return res;
+    ret = ISO_SUCCESS;
+ex:;
+    return ret;
 }

 static
@ -1359,19 +1374,19 @@ static int write_mbr_partition_file(Ecma119Image *target, char *path,
 {
    FILE *fp = NULL;
    uint32_t i;
-    uint8_t buf[BLOCK_SIZE];
+    uint8_t *buf = NULL;
    int ret;

-    memset(buf, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buf, uint8_t, BLOCK_SIZE);
    for (i = 0; i < prepad; i++) {
        ret = iso_write(target, buf, BLOCK_SIZE);
        if (ret < 0)
-            return ret;
+            goto ex;
    }

    fp = fopen(path, "rb");
    if (fp == NULL)
-        return ISO_BAD_PARTITION_FILE;
+        {ret = ISO_BAD_PARTITION_FILE; goto ex;}

    for (i = 0; i < blocks; i++) {
        memset(buf, 0, BLOCK_SIZE);
@ -1385,12 +1400,15 @@ static int write_mbr_partition_file(Ecma119Image *target, char *path,
        ret = iso_write(target, buf, BLOCK_SIZE);
        if (ret < 0) {
            fclose(fp);
-            return ret;
+            goto ex;
        }
    }
    if (fp != NULL) 
        fclose(fp);
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(buf);
+    return ret;
 }


@ -1412,7 +1430,7 @@ void *write_function(void *arg)
        goto write_error;

    /* write data for each writer */
-    for (i = 0; i < target->nwriters; ++i) {
+    for (i = 0; i < (int) target->nwriters; ++i) {
        writer = target->writers[i];
        res = writer->write_data(writer);
        if (res < 0) {
@ -1469,10 +1487,10 @@ void *write_function(void *arg)
 #endif

    write_error: ;
-    if (res != ISO_LIBJTE_END_FAILED)
+    if (res != (int) ISO_LIBJTE_END_FAILED)
        finish_libjte(target);
    target->eff_partition_offset = 0;
-    if (res == ISO_CANCELED) {
+    if (res == (int) ISO_CANCELED) {
        /* canceled */
        if (!target->will_cancel)
            iso_msg_submit(target->image->id, ISO_IMAGE_WRITE_CANCELED,
@ -1949,7 +1967,7 @@ int ecma119_image_new(IsoImage *src, IsoWriteOpts *opts, Ecma119Image **img)
        target->curblock = target->ms_block + target->partition_offset + 16;

        /* Account for partition tree volume descriptors */
-        for (i = 0; i < target->nwriters; ++i) {
+        for (i = 0; i < (int) target->nwriters; ++i) {
            /* Not all writers have an entry in the partition
               volume descriptor set.
            */
@ -1975,7 +1993,7 @@ int ecma119_image_new(IsoImage *src, IsoWriteOpts *opts, Ecma119Image **img)
     * That function computes the size needed by its structures and
     * increments image current block propertly.
     */
-    for (i = 0; i < target->nwriters; ++i) {
+    for (i = 0; i < (int) target->nwriters; ++i) {
        IsoImageWriter *writer = target->writers[i];

        /* Delaying boot image patching until new LBA is known */
--- a/libisofs/ecma119_tree.c
+++ b/libisofs/ecma119_tree.c
@ -299,7 +299,7 @@ void ecma119_node_free(Ecma119Node *node)
        return;
    }
    if (node->type == ECMA119_DIR) {
-        int i;
+        size_t i;
        for (i = 0; i < node->info.dir->nchildren; i++) {
            ecma119_node_free(node->info.dir->children[i]);
        }
@ -643,7 +643,7 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
                    max = max_file_len - digits;
                }
                name = full_name;
-                if (max < strlen(name)) {
+                if ((size_t) max < strlen(name)) {
                    name[max] = '\0';
                }
                /* let ext be an empty string */
--- a/libisofs/eltorito.c
+++ b/libisofs/eltorito.c
@ -275,6 +275,9 @@ int iso_tree_add_boot_node(IsoDir *parent, const char *name, IsoBoot **boot)
        free(node);
        return ISO_OUT_OF_MEM;
    }
+    node->lba = 0;
+    node->size = 0;
+    node->content = NULL;

    /* atributes from parent */
    node->node.mode = S_IFREG | (parent->node.mode & 0444);
@ -384,14 +387,14 @@ int create_image(IsoImage *image, const char *image_path,
        if (ret != sizeof(mbr)) {
            iso_msg_submit(image->id, ISO_BOOT_IMAGE_NOT_VALID, 0,
                          "Can't read MBR from image file.");
-            return ret < 0 ? ret : ISO_FILE_READ_ERROR;
+            return ret < 0 ? ret : (int) ISO_FILE_READ_ERROR;
        }

        /* check valid MBR signature */
        if ( mbr.sign1 != 0x55 || mbr.sign2 != 0xAA ) {
            iso_msg_submit(image->id, ISO_BOOT_IMAGE_NOT_VALID, 0,
                          "Invalid MBR. Wrong signature.");
-            return ISO_BOOT_IMAGE_NOT_VALID;
+            return (int) ISO_BOOT_IMAGE_NOT_VALID;
        }

        /* ensure single partition */
@ -487,7 +490,7 @@ int iso_image_set_boot_image(IsoImage *image, const char *image_path,
         "Cannot find directory for El Torito boot catalog in ISO image: '%s'",
                               catdir);
                free(catdir);
-                return ret < 0 ? ret : ISO_NODE_DOESNT_EXIST;
+                return ret < 0 ? ret : (int) ISO_NODE_DOESNT_EXIST;
            }
            if (p->type != LIBISO_DIR) {
                free(catdir);
@ -598,6 +601,30 @@ int iso_image_get_boot_image(IsoImage *image, ElToritoBootImage **boot,
    return ISO_SUCCESS;
 }

+int iso_image_get_bootcat(IsoImage *image, IsoBoot **catnode, uint32_t *lba,
+                          char **content, off_t *size)
+{
+    IsoBoot *bootcat;
+
+    *catnode = NULL;
+    *lba = 0;
+    *content = NULL;
+    *size = 0;
+    bootcat = image->bootcat->node;
+    if (bootcat == NULL)
+        return 0;
+    *catnode = bootcat;
+    *lba = bootcat->lba;
+    *size = bootcat->size;
+    if (bootcat->size > 0 && bootcat->content != NULL) {
+        *content = calloc(1, bootcat->size);
+        if (*content == NULL) 
+            return ISO_OUT_OF_MEM;
+        memcpy(*content, bootcat->content, bootcat->size);
+    }
+    return 1;
+}
+
 int iso_image_get_all_boot_imgs(IsoImage *image, int *num_boots,
               ElToritoBootImage ***boots, IsoFile ***bootnodes, int flag)
 {
@ -760,7 +787,6 @@ write_validation_entry(uint8_t *buf, uint8_t platform_id,
 static void
 write_section_header(uint8_t *buf, Ecma119Image *t, int idx, int num_entries)
 {
-    int pi;
    char *id_string;

    struct el_torito_section_header *e =
@ -768,7 +794,7 @@ write_section_header(uint8_t *buf, Ecma119Image *t, int idx, int num_entries)

    /* 0x90 = more section headers follow , 0x91 = final section */
    e->header_indicator[0] = 0x90 + (idx == t->catalog->num_bootimages - 1);
-    pi= e->platform_id[0] = t->catalog->bootimages[idx]->platform_id;
+    e->platform_id[0] = t->catalog->bootimages[idx]->platform_id;
    e->num_entries[0] = num_entries & 0xff;
    e->num_entries[1] = (num_entries >> 8) & 0xff;;
    id_string = (char *) e->id_string;
@ -837,10 +863,10 @@ int catalog_open(IsoStream *stream)
        for (j = i + 1; j < cat->num_bootimages; j++) {
             if (boots[i]->platform_id != boots[j]->platform_id)
        break;
-             for (k = 0; k < sizeof(boots[i]->id_string); k++)
+             for (k = 0; k < (int) sizeof(boots[i]->id_string); k++)
                 if (boots[i]->id_string[k] != boots[j]->id_string[k])
             break;
-             if (k < sizeof(boots[i]->id_string))
+             if (k < (int) sizeof(boots[i]->id_string))
        break;
        }
        num_entries = j - i;
@ -896,7 +922,7 @@ int catalog_read(IsoStream *stream, void *buf, size_t count)
        return ISO_FILE_NOT_OPENED;
    }

-    len = MIN(count, BLOCK_SIZE - data->offset);
+    len = MIN(count, (size_t) (BLOCK_SIZE - data->offset));
    memcpy(buf, data->buffer + data->offset, len);
    return len;
 }
@ -936,7 +962,11 @@ IsoStreamIface catalog_stream_class = {
    catalog_read,
    catalog_is_repeatable,
    catalog_get_id,
-    catalog_free
+    catalog_free,
+    NULL,
+    NULL,
+    NULL,
+    NULL
 };

 /**
@ -1127,8 +1157,8 @@ int eltorito_writer_compute_data_blocks(IsoImageWriter *writer)
        }
        ret = iso_stream_read(original, buf, size);
        iso_stream_close(original);
-        if (ret != size) {
-            return (ret < 0) ? ret : ISO_FILE_READ_ERROR;
+        if (ret != (int) size) {
+            return (ret < 0) ? ret : (int) ISO_FILE_READ_ERROR;
        }

        /* ok, patch the read buffer */
@ -1156,7 +1186,6 @@ static
 int eltorito_writer_write_vol_desc(IsoImageWriter *writer)
 {
    Ecma119Image *t;
-    struct el_torito_boot_catalog *cat;
    struct ecma119_boot_rec_vol_desc vol;

    if (writer == NULL) {
@ -1164,7 +1193,6 @@ int eltorito_writer_write_vol_desc(IsoImageWriter *writer)
    }

    t = writer->target;
-    cat = t->catalog;
    iso_msg_debug(t->image->id, "Write El-Torito boot record");

    memset(&vol, 0, sizeof(struct ecma119_boot_rec_vol_desc));
--- a/libisofs/eltorito.h
+++ b/libisofs/eltorito.h
@ -26,6 +26,14 @@
 struct Iso_Boot
 {
    IsoNode node;
+
+    /* Want to get content of loaded boot catalog.
+       Vreixo took care not to make it an IsoFile at load time.
+       So this is implemented independently of IsoStream.
+     */
+    uint32_t lba;
+    off_t size;
+    char *content;
 };

 /* Not more than 32 so that all entries fit into 2048 bytes */
--- a/libisofs/filesrc.c
+++ b/libisofs/filesrc.c
@ -335,11 +335,11 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
 {
    int res, ret, was_error;
    size_t i, b;
-    Ecma119Image *t;
+    Ecma119Image *t = NULL;
    IsoFileSrc *file;
    IsoFileSrc **filelist;
-    char name[PATH_MAX];
-    char buffer[BLOCK_SIZE];
+    char *name = NULL;
+    char *buffer = NULL;
    off_t file_size;
    uint32_t nblocks;
    void *ctx= NULL;
@ -350,10 +350,11 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
 #endif

    if (writer == NULL) {
-        return ISO_ASSERT_FAILURE;
+        ret = ISO_ASSERT_FAILURE; goto ex;
    }

-    memset(buffer, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(name, char, PATH_MAX);
+    LIBISO_ALLOC_MEM(buffer, char, BLOCK_SIZE);
    t = writer->target;
    filelist = writer->data;

@ -562,13 +563,15 @@ ex:;
        iso_md5_end(&ctx, md5);

 #ifdef Libisofs_with_libjtE
-    if (jte_begun) {
+    if (jte_begun && t != NULL) {
        libjte_end_data_file(t->libjte_handle);
        iso_libjte_forward_msgs(t->libjte_handle, t->image->id,
                                ISO_LIBJTE_END_FAILED, 0);
    }
 #endif /* Libisofs_with_libjtE */

+    LIBISO_FREE_MEM(buffer);
+    LIBISO_FREE_MEM(name);
    return ret;
 }

--- a/libisofs/filters/gzip.c
+++ b/libisofs/filters/gzip.c
@ -394,7 +394,7 @@ int gzip_stream_convert(IsoStream *stream, void *buf, size_t desired, int flag)
            if (cnv_ret == Z_STREAM_ERROR || cnv_ret == Z_BUF_ERROR) {
                return (rng->error_ret = ISO_ZLIB_COMPR_ERR);
            }
-            if (strm->avail_out < rng->out_buffer_size)
+            if ((int) strm->avail_out < rng->out_buffer_size)
        break; /* output is available */
            if (strm->avail_in == 0) /* all pending input consumed */
        break;
--- a/libisofs/filters/zisofs.c
+++ b/libisofs/filters/zisofs.c
@ -576,7 +576,8 @@ int ziso_stream_uncompress(IsoStream *stream, void *buf, size_t desired)
                 rng->block_pointers[i] =
                      iso_read_lsb((uint8_t *) (rng->block_pointers + i), 4);
                 if (i > 0)
-                     if (rng->block_pointers[i] - rng->block_pointers[i - 1]
+                     if ((int) (rng->block_pointers[i] -
+                                rng->block_pointers[i - 1])
                         > block_max)
                         block_max = rng->block_pointers[i]
                                     - rng->block_pointers[i - 1];
@ -619,7 +620,7 @@ int ziso_stream_uncompress(IsoStream *stream, void *buf, size_t desired)
                    if (ret != Z_OK)
                        return (rng->error_ret = ISO_ZLIB_COMPR_ERR);
                    rng->buffer_fill = buf_len;
-                    if (buf_len < rng->block_size &&
+                    if ((int) buf_len < rng->block_size &&
                        i != rng->block_pointer_fill - 1)
                        return (rng->error_ret = ISO_ZISOFS_WRONG_INPUT);
                } else if(ret == 0) {
--- a/libisofs/fs_image.c
+++ b/libisofs/fs_image.c
@ -293,6 +293,8 @@ typedef struct
    uint32_t bootblocks[Libisofs_max_boot_imageS];

    uint32_t catblock; /**< Block for El-Torito catalog */
+    off_t catsize; /* Size of boot catalog in bytes */
+    char *catcontent;

    /* Whether inode numbers from PX entries shall be discarded */
    unsigned int make_new_ino : 1 ;
@ -392,6 +394,8 @@ char* ifs_get_path(IsoFileSource *src)
        char *path, *new_path;
        int pathlen;

+        if (data->name == NULL)
+            return NULL;
        path = ifs_get_path(data->parent);
        if (path == NULL)
            return NULL;
@ -470,15 +474,16 @@ int read_dir(ImageFileSourceData *data)
    IsoImageFilesystem *fs;
    _ImageFsData *fsdata;
    struct ecma119_dir_record *record;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;
    IsoFileSource *child = NULL;
    uint32_t pos = 0;
    uint32_t tlen = 0;

    if (data == NULL) {
-        return ISO_NULL_POINTER;
+        ret = ISO_NULL_POINTER; goto ex;
    }

+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
    fs = data->fs;
    fsdata = fs->data;

@ -486,7 +491,7 @@ int read_dir(ImageFileSourceData *data)
    block = data->sections[0].block;
    ret = fsdata->src->read_block(fsdata->src, block, buffer);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }

    /* "." entry, get size of the dir and skip */
@ -510,7 +515,7 @@ int read_dir(ImageFileSourceData *data)
             */
            ret = fsdata->src->read_block(fsdata->src, ++block, buffer);
            if (ret < 0) {
-                return ret;
+                goto ex;
            }
            tlen += 2048 - pos;
            pos = 0;
@ -555,7 +560,7 @@ int read_dir(ImageFileSourceData *data)
                free(ifsdata);
                free(child);
            }
-            return ret;
+            goto ex;
        }

        /* add to the child list */
@ -564,7 +569,7 @@ int read_dir(ImageFileSourceData *data)
            node = malloc(sizeof(struct child_list));
            if (node == NULL) {
                iso_file_source_unref(child);
-                return ISO_OUT_OF_MEM;
+                {ret = ISO_OUT_OF_MEM; goto ex;}
            }
            /*
             * Note that we insert in reverse order. This leads to faster
@ -581,7 +586,10 @@ int read_dir(ImageFileSourceData *data)
        pos += record->len_dr[0];
    }

-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }

 static
@ -1245,7 +1253,8 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
    int aa_done = 0;
    char *cs_value = NULL;
    size_t cs_value_length = 0;
-    char msg[160];
+    char *msg = NULL;
+    uint8_t *buffer = NULL;

    int has_px = 0;

@ -1255,7 +1264,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
 #endif

    if (fs == NULL || fs->data == NULL || record == NULL || src == NULL) {
-        return ISO_NULL_POINTER;
+        ret = ISO_NULL_POINTER; goto ex;
    }

    fsdata = (_ImageFsData*)fs->data;
@ -1274,7 +1283,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
              "in interleaved mode. We do not support this mode, as we think "
              "it is not used. If you are reading this, then we are wrong :) "
              "Please contact libisofs developers, so we can fix this.");
-        return ISO_UNSUPPORTED_ECMA119;
+        {ret = ISO_UNSUPPORTED_ECMA119; goto ex;}
    }

    /*
@ -1285,7 +1294,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
        iso_msg_submit(fsdata->msgid, ISO_UNSUPPORTED_ECMA119, 0,
              "Unsupported image. This image has at least one file with "
              "ECMA-119 Extended Attributes, that are not supported");
-        return ISO_UNSUPPORTED_ECMA119;
+        {ret = ISO_UNSUPPORTED_ECMA119; goto ex;}
    }

    /* TODO #00013 : check for unsupported flags when reading a dir record */
@ -1300,13 +1309,13 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
        if (new_name == NULL) {
            iso_msg_submit(fsdata->msgid, ISO_WRONG_ECMA119, 0,
                          "Cannot retrieve file name");
-            return ISO_WRONG_ECMA119;
+            {ret = ISO_WRONG_ECMA119; goto ex;}
        }
        if (strcmp(new_name, data->name)) {
            iso_msg_submit(fsdata->msgid, ISO_WRONG_ECMA119, 0,
                          "Multi-extent file lacks last entry.");
            free(new_name);
-            return ISO_WRONG_ECMA119;
+            {ret = ISO_WRONG_ECMA119; goto ex;}
        }
        free(new_name);
    }
@ -1321,7 +1330,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
        if (record->flags[0] & 0x02) {
            iso_msg_submit(fsdata->msgid, ISO_WRONG_ECMA119, 0,
                          "Directories with more than one section are not allowed.");
-            return ISO_WRONG_ECMA119;
+            {ret = ISO_WRONG_ECMA119; goto ex;}
        }

        if (*src == NULL) {
@ -1362,7 +1371,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,

        ifsdata->info.st_size += (off_t) ifsdata->sections[ifsdata->nsections].size;
        ifsdata->nsections++;
-        return 2;
+        {ret = 2; goto ex;}
    }

    /*
@ -1380,7 +1389,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
        iter = susp_iter_new(fsdata->src, record, fsdata->len_skp,
                             fsdata->msgid);
        if (iter == NULL) {
-            return ISO_OUT_OF_MEM;
+            {ret = ISO_OUT_OF_MEM; goto ex;}
        }

        while ((ret = susp_iter_next(iter, &sue)) > 0) {
@ -1449,7 +1458,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
                 */
                susp_iter_free(iter);
                free(name);
-                return 0; /* it's not an error */
+                {ret = 0; goto ex;} /* it's not an error */
            } else if (SUSP_SIG(sue, 'C', 'L')) {
                /*
                 * This entry is a placeholder for a relocated dir.
@ -1581,13 +1590,14 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,

        if (ret < 0) {
            free(name);
-            return ret;
+            goto ex;
        }

        if ((flag & 1)  && aa_string != NULL) {
            ret = iso_aa_lookup_attr(aa_string, "isofs.cs",
                                     &cs_value_length, &cs_value, 0);
            if (ret == 1) {
+                LIBISO_ALLOC_MEM(msg, char, 160);
                if (fsdata->auto_input_charset & 1) {
                    if (fsdata->input_charset != NULL)
                        free(fsdata->input_charset);
@ -1621,7 +1631,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
                free(newname);
                if (ret < 0) {
                    free(name);
-                    return ret;
+                    goto ex;
                }
            } else {
                free(name);
@ -1643,7 +1653,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
                free(newlinkdest);
                if (ret < 0) {
                    free(name);
-                    return ret;
+                    goto ex;
                }
            } else {
                free(linkdest);
@ -1676,15 +1686,17 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
        if (record->len_fi[0] == 1 && record->file_id[0] == 0) {
            /* "." entry, we can call this for root node, so... */
            if (!(atts.st_mode & S_IFDIR)) {
-                return iso_msg_submit(fsdata->msgid, ISO_WRONG_ECMA119, 0,
+                ret = iso_msg_submit(fsdata->msgid, ISO_WRONG_ECMA119, 0,
                              "Wrong ISO file name. \".\" not dir");
+                goto ex;
            }
        } else {

            name = get_name(fsdata, (char*)record->file_id, record->len_fi[0]);
            if (name == NULL) {
-                return iso_msg_submit(fsdata->msgid, ISO_WRONG_ECMA119, 0,
+                ret = iso_msg_submit(fsdata->msgid, ISO_WRONG_ECMA119, 0,
                              "Cannot retrieve file name");
+                goto ex;
            }

            /* remove trailing version number */
@ -1710,24 +1722,24 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
         * Thus, we need to read attributes for this directory from the "."
         * entry of the relocated dir.
         */
-        uint8_t buffer[BLOCK_SIZE];

+        LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
        ret = fsdata->src->read_block(fsdata->src, relocated_dir, buffer);
        if (ret < 0) {
-            return ret;
+            goto ex;
        }

        ret = iso_file_source_new_ifs(fs, parent, (struct ecma119_dir_record*)
                                      buffer, src, 0);
        if (ret <= 0) {
-            return ret;
+            goto ex;
        }

        /* but the real name is the name of the placeholder */
        ifsdata = (ImageFileSourceData*) (*src)->data;
        ifsdata->name = name;

-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
    }

    /* Production of missing inode numbers is delayed until the image is
@ -1763,7 +1775,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
        ret = iso_msg_submit(fsdata->msgid, ISO_WRONG_RR, 0,
                             "Link without destination.");
        free(name);
-        return ret;
+        goto ex;
    }

    /* ok, we can now create the file source */
@ -1831,13 +1843,17 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
    ifsrc->refcount = 1;

    *src = ifsrc;
-    return ISO_SUCCESS;
+    {ret = ISO_SUCCESS; goto ex;}

 ifs_cleanup: ;
    free(name);
    free(linkdest);
    free(ifsdata);
    free(ifsrc);
+
+ex:;
+    LIBISO_FREE_MEM(msg);
+    LIBISO_FREE_MEM(buffer);
    return ret;
 }

@ -1846,25 +1862,26 @@ int ifs_get_root(IsoFilesystem *fs, IsoFileSource **root)
 {
    int ret;
    _ImageFsData *data;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;

    if (fs == NULL || fs->data == NULL || root == NULL) {
-        return ISO_NULL_POINTER;
+        ret = ISO_NULL_POINTER; goto ex;
    }

+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
    data = (_ImageFsData*)fs->data;

    /* open the filesystem */
    ret = ifs_fs_open((IsoImageFilesystem*)fs);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }

    /* read extend for root record */
    ret = data->src->read_block(data->src, data->iso_root_block, buffer);
    if (ret < 0) {
        ifs_fs_close((IsoImageFilesystem*)fs);
-        return ret;
+        goto ex;
    }

    /* get root attributes from "." entry */
@ -1873,6 +1890,8 @@ int ifs_get_root(IsoFilesystem *fs, IsoFileSource **root)
                                 (struct ecma119_dir_record*) buffer, root, 1);

    ifs_fs_close((IsoImageFilesystem*)fs);
+ex:;
+    LIBISO_FREE_MEM(buffer);
    return ret;
 }

@ -1913,7 +1932,6 @@ static
 int ifs_get_by_path(IsoFilesystem *fs, const char *path, IsoFileSource **file)
 {
    int ret;
-    _ImageFsData *data;
    IsoFileSource *src;
    char *ptr, *brk_info, *component;

@ -1926,8 +1944,6 @@ int ifs_get_by_path(IsoFilesystem *fs, const char *path, IsoFileSource **file)
        return ISO_FILE_BAD_PATH;
    }

-    data = (_ImageFsData*)fs->data;
-
    /* open the filesystem */
    ret = ifs_fs_open((IsoImageFilesystem*)fs);
    if (ret < 0) {
@ -2035,10 +2051,8 @@ int ifs_fs_close(IsoImageFilesystem *fs)
 static
 void ifs_fs_free(IsoFilesystem *fs)
 {
-    IsoImageFilesystem *ifs;
    _ImageFsData *data;

-    ifs = (IsoImageFilesystem*)fs;
    data = (_ImageFsData*) fs->data;

    /* close data source if already openned */
@ -2061,6 +2075,10 @@ void ifs_fs_free(IsoFilesystem *fs)
    free(data->biblio_file_id);
    free(data->input_charset);
    free(data->local_charset);
+
+    if(data->catcontent != NULL)
+        free(data->catcontent);
+
    free(data);
 }

@ -2075,14 +2093,15 @@ static
 int read_root_susp_entries(_ImageFsData *data, uint32_t block)
 {
    int ret;
-    unsigned char buffer[2048];
+    unsigned char *buffer = NULL;
    struct ecma119_dir_record *record;
    struct susp_sys_user_entry *sue;
    SuspIterator *iter;

+    LIBISO_ALLOC_MEM(buffer, unsigned char, 2048);
    ret = data->src->read_block(data->src, block, buffer);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }

    /* record will be the "." directory entry for the root record */
@ -2097,7 +2116,7 @@ int read_root_susp_entries(_ImageFsData *data, uint32_t block)

    iter = susp_iter_new(data->src, record, data->len_skp, data->msgid);
    if (iter == NULL) {
-        return ISO_OUT_OF_MEM;
+        ret = ISO_OUT_OF_MEM; goto ex;
    }

    /* first entry must be an SP system use entry */
@ -2105,11 +2124,11 @@ int read_root_susp_entries(_ImageFsData *data, uint32_t block)
    if (ret < 0) {
        /* error */
        susp_iter_free(iter);
-        return ret;
+        goto ex;
    } else if (ret == 0 || !SUSP_SIG(sue, 'S', 'P') ) {
        iso_msg_debug(data->msgid, "SUSP/RR is not being used.");
        susp_iter_free(iter);
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
    }

    /* it is a SP system use entry */
@ -2117,9 +2136,10 @@ int read_root_susp_entries(_ImageFsData *data, uint32_t block)
        || sue->data.SP.ef[0] != 0xEF) {

        susp_iter_free(iter);
-        return iso_msg_submit(data->msgid, ISO_UNSUPPORTED_SUSP, 0,
+        ret = iso_msg_submit(data->msgid, ISO_UNSUPPORTED_SUSP, 0,
                              "SUSP SP system use entry seems to be wrong. "
                              "Ignoring Rock Ridge Extensions.");
+        goto ex;
    }

    iso_msg_debug(data->msgid, "SUSP/RR is being used.");
@ -2204,10 +2224,13 @@ int read_root_susp_entries(_ImageFsData *data, uint32_t block)
    susp_iter_free(iter);

    if (ret < 0) {
-        return ret;
+        goto ex;
    }

-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }

 static
@ -2240,11 +2263,12 @@ int read_pvm(_ImageFsData *data, uint32_t block)
    int ret;
    struct ecma119_pri_vol_desc *pvm;
    struct ecma119_dir_record *rootdr;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;

+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
    ret = read_pvd_block(data->src, block, buffer, NULL);
    if (ret < 0)
-        return ret;
+        goto ex;
    /* ok, it is a valid PVD */
    pvm = (struct ecma119_pri_vol_desc *)buffer;

@ -2292,7 +2316,10 @@ int read_pvm(_ImageFsData *data, uint32_t block)
     * example.
     */

-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }

 /**
@ -2302,16 +2329,18 @@ int read_pvm(_ImageFsData *data, uint32_t block)
 static
 int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)
 {
-    int ret, i, rx, last_done, idx;
+    int ret, i, rx, last_done, idx, bufsize;
    struct el_torito_validation_entry *ve;
    struct el_torito_section_header *sh;
    struct el_torito_section_entry *entry; /* also usable as default_entry */
-    unsigned char buffer[BLOCK_SIZE];
+    unsigned char *buffer = NULL, *rpt;

+    LIBISO_ALLOC_MEM(buffer, unsigned char, BLOCK_SIZE);
    data->num_bootimgs = 0;
+    data->catsize = 0;
    ret = data->src->read_block(data->src, block, buffer);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }

    ve = (struct el_torito_validation_entry*)buffer;
@ -2322,7 +2351,7 @@ int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)
        iso_msg_submit(data->msgid, ISO_WRONG_EL_TORITO, 0,
                      "Wrong or damaged El-Torito Catalog. El-Torito info "
                      "will be ignored.");
-        return ISO_WRONG_EL_TORITO;
+        {ret = ISO_WRONG_EL_TORITO; goto ex;}
    }

    /* check for a valid platform */
@ -2330,7 +2359,7 @@ int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)
        iso_msg_submit(data->msgid, ISO_UNSUPPORTED_EL_TORITO, 0,
                     "Unsupported El-Torito platform. Only 80x86 and EFI are "
                     "supported. El-Torito info will be ignored.");
-        return ISO_UNSUPPORTED_EL_TORITO;
+        {ret = ISO_UNSUPPORTED_EL_TORITO; goto ex;}
    }

    /* ok, once we are here we assume it is a valid catalog */
@ -2340,6 +2369,7 @@ int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)

    data->eltorito = 1;
    /* The Default Entry is declared mandatory */
+    data->catsize = 64;
    data->num_bootimgs = 1;
    data->platform_ids[0] = ve->platform_id[0];
    memcpy(data->id_strings[0], ve->id_string, 24);
@ -2358,10 +2388,21 @@ int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)
    for (rx = 64; (buffer[rx] & 0xfe) == 0x90 && !last_done; rx += 32) {
        last_done = buffer[rx] & 1;
        /* Read Section Header */
+
+        /* >>> ts B10703 : load a new buffer if needed */;
+
        sh = (struct el_torito_section_header *) (buffer + rx);
+        data->catsize += 32;
        for (i = 0; i < sh->num_entries[0]; i++) {
            rx += 32;
+            data->catsize += 32;
+
+            /* >>> ts B10703 : load a new buffer if needed */;
+
            if (data->num_bootimgs >= Libisofs_max_boot_imageS) {
+
+                /* >>> ts B10703 : need to continue rather than abort */;
+
                ret = iso_msg_submit(data->msgid, ISO_EL_TORITO_WARN, 0,
                                "Too many boot images found. List truncated.");
                goto after_bootblocks;
@ -2383,7 +2424,31 @@ int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)
        }
    }
 after_bootblocks:;
-    return ISO_SUCCESS;
+    if(data->catsize > 0) {
+      if(data->catcontent != NULL)
+          free(data->catcontent);
+      if(data->catsize > 10 * BLOCK_SIZE)
+          data->catsize = 10 * BLOCK_SIZE;
+      bufsize = data->catsize;
+      if (bufsize % BLOCK_SIZE)
+          bufsize += BLOCK_SIZE - (bufsize % BLOCK_SIZE);
+      data->catcontent = calloc(bufsize , 1);
+      if(data->catcontent == NULL) {
+         data->catsize = 0;
+         ret = ISO_OUT_OF_MEM;
+         goto ex; 
+      }
+      for(rx = 0; rx < bufsize; rx += BLOCK_SIZE) {
+        rpt = (unsigned char *) (data->catcontent + rx);
+        ret = data->src->read_block(data->src, block + rx / BLOCK_SIZE, rpt);
+        if (ret < 0)
+           goto ex;
+      }
+    }
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }


@ -2397,11 +2462,12 @@ static
 int iso_src_check_sb_tree(IsoDataSource *src, uint32_t start_lba, int flag)
 {
    int tag_type, ret;
-    char block[2048], md5[16];
+    char *block = NULL, md5[16];
    int desired = (1 << 2);
    void *ctx = NULL;
    uint32_t next_tag = 0, i;
-    
+
+    LIBISO_ALLOC_MEM(block, char, 2048);    
    ret = iso_md5_start(&ctx);
    if (ret < 0)
        goto ex;
@ -2416,11 +2482,12 @@ int iso_src_check_sb_tree(IsoDataSource *src, uint32_t start_lba, int flag)
            ret = iso_util_eval_md5_tag(block, desired, start_lba + i,
                                      ctx, start_lba, &tag_type, &next_tag, 0);
        iso_md5_compute(ctx, block, 2048);
-        if (ret == ISO_MD5_TAG_COPIED) { /* growing without emulated TOC */
+        if (ret == (int) ISO_MD5_TAG_COPIED) {/* growing without emulated TOC */
            ret = 2;
            goto ex;
        }
-        if (ret == ISO_MD5_AREA_CORRUPTED || ret == ISO_MD5_TAG_MISMATCH)
+        if (ret == (int) ISO_MD5_AREA_CORRUPTED ||
+            ret == (int) ISO_MD5_TAG_MISMATCH)
            ret = ISO_SB_TREE_CORRUPTED;
        if (ret < 0)
            goto ex;
@ -2454,7 +2521,8 @@ int iso_src_check_sb_tree(IsoDataSource *src, uint32_t start_lba, int flag)
    }
    ret = iso_util_eval_md5_tag(block, (1 << 3), start_lba + i - 1,
                                ctx, start_lba, &tag_type, &next_tag, 0);
-    if (ret == ISO_MD5_AREA_CORRUPTED || ret == ISO_MD5_TAG_MISMATCH)
+    if (ret == (int) ISO_MD5_AREA_CORRUPTED ||
+        ret == (int) ISO_MD5_TAG_MISMATCH)
        ret = ISO_SB_TREE_CORRUPTED;
    if (ret < 0)
        goto ex;
@ -2463,6 +2531,7 @@ int iso_src_check_sb_tree(IsoDataSource *src, uint32_t start_lba, int flag)
 ex:
    if (ctx != NULL)
        iso_md5_end(&ctx, md5);
+    LIBISO_FREE_MEM(block);
    return ret;
 }

@ -2474,21 +2543,22 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
    uint32_t block;
    IsoImageFilesystem *ifs;
    _ImageFsData *data;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;

    if (src == NULL || opts == NULL || fs == NULL) {
-        return ISO_NULL_POINTER;
+        ret = ISO_NULL_POINTER; goto ex;
    }

+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
    data = calloc(1, sizeof(_ImageFsData));
    if (data == NULL) {
-        return ISO_OUT_OF_MEM;
+        ret = ISO_OUT_OF_MEM; goto ex;
    }

    ifs = calloc(1, sizeof(IsoImageFilesystem));
    if (ifs == NULL) {
        free(data);
-        return ISO_OUT_OF_MEM;
+        {ret = ISO_OUT_OF_MEM; goto ex;}
    }

    /* get our ref to IsoDataSource */
@ -2496,6 +2566,8 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
    iso_data_source_ref(src);
    data->open_count = 0;

+    data->catcontent = NULL;
+
    /* get an id for the filesystem */
    data->id = ++fs_dev_id;

@ -2590,8 +2662,8 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
                } else {
                    data->catblock = iso_read_lsb(vol->boot_catalog, 4);
                    ret = read_el_torito_boot_catalog(data, data->catblock);
-                    if (ret < 0 && ret != ISO_UNSUPPORTED_EL_TORITO &&
-                        ret != ISO_WRONG_EL_TORITO) {
+                    if (ret < 0 && ret != (int) ISO_UNSUPPORTED_EL_TORITO &&
+                        ret != (int) ISO_WRONG_EL_TORITO) {
                        goto fs_cleanup;
                    }
                }
@ -2712,11 +2784,14 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
    /* and finally return. Note that we keep the DataSource opened */

    *fs = ifs;
-    return ISO_SUCCESS;
+    {ret = ISO_SUCCESS; goto ex;}

-    fs_cleanup: ;
+fs_cleanup: ;
    ifs_fs_free(ifs);
    free(ifs);
+
+ex:;
+    LIBISO_FREE_MEM(buffer);
    return ret;
 }

@ -2764,10 +2839,12 @@ static
 int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                              IsoFileSource *src, IsoNode **node)
 {
-    int ret, idx;
+    int ret, idx, to_copy;
    struct stat info;
    IsoNode *new;
+    IsoBoot *bootcat;
    char *name;
+    char *dest = NULL;
    ImageFileSourceData *data;
    _ImageFsData *fsdata;

@ -2780,7 +2857,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,


    if (builder == NULL || src == NULL || node == NULL || src->data == NULL) {
-        return ISO_NULL_POINTER;
+        ret = ISO_NULL_POINTER; goto ex;
    }

    data = (ImageFileSourceData*)src->data;
@ -2791,7 +2868,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
    /* get info about source */
    ret = iso_file_source_lstat(src, &info);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }

    new = NULL;
@ -2809,7 +2886,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                                 "We can continue, but that could lead to "
                                 "problems");
                    if (ret < 0) {
-                        return ret;
+                        goto ex;
                    }
                    iso_node_unref((IsoNode*)image->bootcat->node);
                }
@ -2820,11 +2897,30 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                if (new == NULL) {
                    ret = ISO_OUT_OF_MEM;
                    free(name);
-                    return ret;
+                    goto ex;
+                }
+                bootcat = (IsoBoot *) new;
+                bootcat->lba = data->sections[0].block;
+                bootcat->size = info.st_size;
+                if (bootcat->size > 10 * BLOCK_SIZE)
+                    bootcat->size = 10 * BLOCK_SIZE;
+                bootcat->content = NULL;
+                if (bootcat->size > 0) {
+                    bootcat->content = calloc(1, bootcat->size);
+                    if (bootcat->content == NULL) {
+                        ret = ISO_OUT_OF_MEM;
+                        free(name);
+                        free(new);
+                        goto ex;
+                    }
+                    to_copy = bootcat->size;
+                    if (bootcat->size > fsdata->catsize)
+                        to_copy = fsdata->catsize;
+                    memcpy(bootcat->content, fsdata->catcontent, to_copy);
                }

                /* and set the image node */
-                image->bootcat->node = (IsoBoot*)new;
+                image->bootcat->node = bootcat;
                new->type = LIBISO_BOOT;
                new->refcount = 1;
            } else {
@ -2834,7 +2930,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                ret = iso_file_source_stream_new(src, &stream);
                if (ret < 0) {
                    free(name);
-                    return ret;
+                    goto ex;
                }
                /* take a ref to the src, as stream has taken our ref */
                iso_file_source_ref(src);
@ -2843,7 +2939,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                if (file == NULL) {
                    free(name);
                    iso_stream_unref(stream);
-                    return ISO_OUT_OF_MEM;
+                    {ret = ISO_OUT_OF_MEM; goto ex;}
                }

                /* mark file as from old session */
@ -2867,7 +2963,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                    if (ret < 0) {
                        free(name);
                        iso_stream_unref(stream);
-                        return ret;
+                        goto ex;
                    }
                }

@ -2898,7 +2994,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                        if (ret < 0) {
                            free(name);
                            iso_stream_unref(stream);
-                            return ret;
+                            goto ex;
                        }
                    } else {
                        /* and set the image node */
@ -2915,7 +3011,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
            new = calloc(1, sizeof(IsoDir));
            if (new == NULL) {
                free(name);
-                return ISO_OUT_OF_MEM;
+                {ret = ISO_OUT_OF_MEM; goto ex;}
            }
            new->type = LIBISO_DIR;
            new->refcount = 0;
@ -2924,18 +3020,19 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
    case S_IFLNK:
        {
            /* source is a symbolic link */
-            char dest[LIBISOFS_NODE_PATH_MAX];
            IsoSymlink *link;

+            LIBISO_ALLOC_MEM(dest, char, LIBISOFS_NODE_PATH_MAX);
+
            ret = iso_file_source_readlink(src, dest, LIBISOFS_NODE_PATH_MAX);
            if (ret < 0) {
                free(name);
-                return ret;
+                goto ex;
            }
            link = calloc(1, sizeof(IsoSymlink));
            if (link == NULL) {
                free(name);
-                return ISO_OUT_OF_MEM;
+                {ret = ISO_OUT_OF_MEM; goto ex;}
            }
            link->dest = strdup(dest);
            link->node.type = LIBISO_SYMLINK;
@ -2956,7 +3053,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
            special = calloc(1, sizeof(IsoSpecial));
            if (special == NULL) {
                free(name);
-                return ISO_OUT_OF_MEM;
+                {ret = ISO_OUT_OF_MEM; goto ex;}
            }
            special->dev = info.st_rdev;
            special->node.type = LIBISO_SPECIAL;
@ -2998,13 +3095,15 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
    }

    *node = new;
-    return ISO_SUCCESS;
+    {ret = ISO_SUCCESS; goto ex;}

 failure:;
    /* todo: stuff any possible memory leak here */
    if (name != NULL)
        free(name);
    free(new);
+ex:;
+    LIBISO_FREE_MEM(dest);
    return ret;
 }

@ -3130,12 +3229,13 @@ int iso_image_eval_boot_info_table(IsoImage *image, struct iso_read_opts *opts,
    uint32_t img_lba, img_size, boot_pvd_found, image_pvd, alleged_size;
    struct iso_file_section *sections = NULL;
    struct el_torito_boot_image *boot;
-    uint8_t *boot_image_buf = NULL, boot_info_found[16], buf[BLOCK_SIZE];
+    uint8_t *boot_image_buf = NULL, boot_info_found[16], *buf = NULL;
    IsoStream *stream = NULL;
    IsoFile *boot_file;

    if (image->bootcat == NULL)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
+    LIBISO_ALLOC_MEM(buf, uint8_t, BLOCK_SIZE);
    for (i = 0; i < image->bootcat->num_bootimages; i++) {
        boot = image->bootcat->bootimages[i];
        boot_file = boot->image;
@ -3175,7 +3275,7 @@ int iso_image_eval_boot_info_table(IsoImage *image, struct iso_read_opts *opts,
          ret = iso_stream_read(stream, boot_image_buf + (img_size - todo),
                                chunk);
          if (ret != chunk) {
-            ret = (ret < 0) ? ret : ISO_FILE_READ_ERROR;
+            ret = (ret < 0) ? ret : (int) ISO_FILE_READ_ERROR;
            goto ex;
          }
          todo -= chunk;
@ -3214,6 +3314,7 @@ ex:;
        free(boot_image_buf);
    if (stream != NULL)
        iso_stream_close(stream);
+    LIBISO_FREE_MEM(buf);
    return ret;
 }

@ -3232,9 +3333,6 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
    uint8_t *rpt;
    IsoFileSource *boot_src;
    IsoNode *node;
-    uint32_t old_checksum_start_lba;
-    uint32_t old_checksum_end_lba;
-    uint32_t old_checksum_idx_count;
    char *old_checksum_array = NULL;
    char checksum_type[81];
    uint32_t checksum_size;
@ -3284,9 +3382,6 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
    oldroot = image->root;
    oldbootcat = image->bootcat; /* could be NULL */
    image->bootcat = NULL;
-    old_checksum_start_lba = image->checksum_start_lba;
-    old_checksum_end_lba = image->checksum_end_lba;
-    old_checksum_idx_count = image->checksum_idx_count;
    old_checksum_array = image->checksum_array;
    image->checksum_array = NULL;

@ -3419,11 +3514,25 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
                           "patching may lead to bad results.");
        }
        if (image->bootcat->node == NULL) {
-            IsoNode *node = calloc(1, sizeof(IsoBoot));
+            IsoNode *node;
+            IsoBoot *bootcat;
+            node = calloc(1, sizeof(IsoBoot));
            if (node == NULL) {
                ret = ISO_OUT_OF_MEM;
                goto import_revert;
            }
+            bootcat = (IsoBoot *) node;
+            bootcat->lba = data->catblock;
+            bootcat->size = data->catsize;
+            bootcat->content = NULL; 
+            if (bootcat->size > 0) {
+                bootcat->content = calloc(1, bootcat->size);
+                if (bootcat->content == NULL) {
+                    ret = ISO_OUT_OF_MEM;
+                    goto import_revert;
+                }
+                memcpy(bootcat->content, data->catcontent, bootcat->size);
+            }
            node->type = LIBISO_BOOT;
            node->mode = S_IFREG;
            node->refcount = 1;
@ -3484,7 +3593,7 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
            }

            /* Load from image->checksum_end_lba */;
-            for (i = 0; i < size; i++) {
+            for (i = 0; i < (int) size; i++) {
                rpt = (uint8_t *) (image->checksum_array + i * 2048);
                ret = src->read_block(src, image->checksum_end_lba + i, rpt);
                if (ret <= 0)
@ -3497,7 +3606,7 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
                ret = ISO_OUT_OF_MEM;
                goto import_revert;
            }
-            for (i = 0; i < image->checksum_idx_count - 1; i++)
+            for (i = 0; i < (int) image->checksum_idx_count - 1; i++)
                iso_md5_compute(ctx, image->checksum_array + i * 16, 16);
            iso_md5_end(&ctx, md5);
            for (i = 0; i < 16; i++)
@ -3528,9 +3637,6 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
    el_torito_boot_catalog_free(image->bootcat);
    image->root = oldroot;
    image->bootcat = oldbootcat;
-    old_checksum_start_lba = image->checksum_start_lba;
-    old_checksum_end_lba = image->checksum_end_lba;
-    old_checksum_idx_count = image->checksum_idx_count;
    image->checksum_array = old_checksum_array;
    old_checksum_array = NULL;

--- a/libisofs/fs_local.c
+++ b/libisofs/fs_local.c
@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
 * 
 * This file is part of the libisofs project; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License version 2 
@ -95,14 +95,14 @@ char* lfs_get_name(IsoFileSource *src)
 static
 int lfs_lstat(IsoFileSource *src, struct stat *info)
 {
-    _LocalFsFileSource *data;
    char *path;

    if (src == NULL || info == NULL) {
        return ISO_NULL_POINTER;
    }
-    data = src->data;
    path = lfs_get_path(src);
+    if (path == NULL)
+        return ISO_OUT_OF_MEM;

    if (lstat(path, info) != 0) {
        int err;
@ -128,6 +128,7 @@ int lfs_lstat(IsoFileSource *src, struct stat *info)
            err = ISO_FILE_ERROR;
            break;
        }
+        free(path);
        return err;
    }
    free(path);
@ -137,14 +138,14 @@ int lfs_lstat(IsoFileSource *src, struct stat *info)
 static
 int lfs_stat(IsoFileSource *src, struct stat *info)
 {
-    _LocalFsFileSource *data;
    char *path;

    if (src == NULL || info == NULL) {
        return ISO_NULL_POINTER;
    }
-    data = src->data;
    path = lfs_get_path(src);
+    if (path == NULL)
+        return ISO_OUT_OF_MEM;

    if (stat(path, info) != 0) {
        int err;
@ -170,6 +171,7 @@ int lfs_stat(IsoFileSource *src, struct stat *info)
            err = ISO_FILE_ERROR;
            break;
        }
+        free(path);
        return err;
    }
    free(path);
@ -180,13 +182,11 @@ static
 int lfs_access(IsoFileSource *src)
 {
    int ret;
-    _LocalFsFileSource *data;
    char *path;

    if (src == NULL) {
        return ISO_NULL_POINTER;
    }
-    data = src->data;
    path = lfs_get_path(src);

    ret = iso_eaccess(path);
@ -413,7 +413,6 @@ static
 int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
 {
    int size, ret;
-    _LocalFsFileSource *data;
    char *path;

    if (src == NULL || buf == NULL) {
@ -424,7 +423,6 @@ int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
        return ISO_WRONG_ARG_VALUE;
    }

-    data = src->data;
    path = lfs_get_path(src);

    /*
@ -456,7 +454,7 @@ int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)

    /* NULL-terminate the buf */
    ret = ISO_SUCCESS;
-    if (size >= bufsiz) {
+    if ((size_t) size >= bufsiz) {
        ret = ISO_RR_PATH_TOO_LONG;
        size = bufsiz - 1;
    }
@ -497,9 +495,6 @@ int lfs_get_aa_string(IsoFileSource *src, unsigned char **aa_string, int flag)
    size_t num_attrs = 0, *value_lengths = NULL, result_len, sret;
    char *path = NULL, **names = NULL, **values = NULL;
    unsigned char *result = NULL;
-    _LocalFsFileSource *data;
-
-    data = src->data;

    *aa_string = NULL;

@ -511,6 +506,10 @@ int lfs_get_aa_string(IsoFileSource *src, unsigned char **aa_string, int flag)
       to AAIP ACL representation. Clean out st_mode ACL entries.
    */ 
    path = iso_file_source_get_path(src);
+    if (path == NULL) {
+        ret = ISO_NULL_POINTER;
+        goto ex;
+    }
    ret = aaip_get_attr_list(path, &num_attrs, &names,
                             &value_lengths, &values,
                             (!(flag & 2)) | 2 | (flag & 4) | 16);
--- a/libisofs/iso1999.c
+++ b/libisofs/iso1999.c
@ -1,5 +1,6 @@
 /*
 * Copyright (c) 2007 Vreixo Formoso
+ * Copyright (c) 2011 Thomas Schmitt
 *
 * This file is part of the libisofs project; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2 
@ -17,6 +18,7 @@
 #include "image.h"
 #include "filesrc.h"
 #include "eltorito.h"
+#include "util.h"

 #include <stdlib.h>
 #include <stdio.h>
@ -73,7 +75,7 @@ void iso1999_node_free(Iso1999Node *node)
        return;
    }
    if (node->type == ISO1999_DIR) {
-        int i;
+        size_t i;
        for (i = 0; i < node->info.dir->nchildren; i++) {
            iso1999_node_free(node->info.dir->children[i]);
        }
@ -307,7 +309,10 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
    Iso1999Node **children;
    IsoHTable *table;
    int need_sort = 0;
+    char *full_name = NULL, *tmp = NULL;

+    LIBISO_ALLOC_MEM(full_name, char, 208);
+    LIBISO_ALLOC_MEM(tmp, char, 208);
    nchildren = dir->info.dir->nchildren;
    children = dir->info.dir->children;

@ -315,19 +320,18 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
    ret = iso_htable_create((nchildren * 100) / 80, iso_str_hash,
                            (compare_function_t)strcmp, &table);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }
    for (i = 0; i < nchildren; ++i) {
        char *name = children[i]->name;
        ret = iso_htable_add(table, name, name);
        if (ret < 0) {
-            goto mangle_cleanup;
+            goto ex;
        }
    }

    for (i = 0; i < nchildren; ++i) {
        char *name, *ext;
-        char full_name[208];
        int max; /* computed max len for name, without extension */
        int j = i;
        int digits = 1; /* characters to change per name */
@ -384,7 +388,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
                         * This can't happen with current limit of digits.
                         */
                        ret = ISO_ERROR;
-                        goto mangle_cleanup;
+                        goto ex;
                    }
                }
                /* ok, reduce name by digits */
@ -398,7 +402,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
                }
                max = 207 - digits;
                name = full_name;
-                if (max < strlen(name)) {
+                if ((size_t) max < strlen(name)) {
                    name[max] = '\0';
                }
                /* let ext be an empty string */
@ -408,7 +412,6 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
            ok = 1;
            /* change name of each file */
            for (k = i; k <= j; ++k) {
-                char tmp[208];
                char fmt[16];
                if (dot != NULL) {
                    sprintf(fmt, "%%s%%0%dd.%%s", digits);
@ -431,7 +434,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
                    char *new = strdup(tmp);
                    if (new == NULL) {
                        ret = ISO_OUT_OF_MEM;
-                        goto mangle_cleanup;
+                        goto ex;
                    }
                    iso_msg_debug(img->image->id, "\"%s\" renamed to \"%s\"",
                                  children[k]->name, new);
@ -459,7 +462,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
        }
        if (digits == 8) {
            ret = ISO_MANGLE_TOO_MUCH_FILES;
-            goto mangle_cleanup;
+            goto ex;
        }
        i = j;
    }
@ -473,8 +476,10 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)

    ret = ISO_SUCCESS;

-mangle_cleanup : ;
+ex:;
    iso_htable_destroy(table, NULL);
+    LIBISO_FREE_MEM(tmp);
+    LIBISO_FREE_MEM(full_name);
    return ret;
 }

@ -810,15 +815,15 @@ static
 int write_one_dir(Ecma119Image *t, Iso1999Node *dir)
 {
    int ret;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;
    size_t i;
    size_t fi_len, len;

    /* buf will point to current write position on buffer */
-    uint8_t *buf = buffer;
+    uint8_t *buf;

-    /* initialize buffer with 0s */
-    memset(buffer, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
+    buf = buffer;

    /* write the "." and ".." entries first */
    write_one_dir_record(t, dir, 0, buf, 1, 0);
@ -840,7 +845,7 @@ int write_one_dir(Ecma119Image *t, Iso1999Node *dir)
                /* dir doesn't fit in current block */
                ret = iso_write(t, buffer, BLOCK_SIZE);
                if (ret < 0) {
-                    return ret;
+                    goto ex;
                }
                memset(buffer, 0, BLOCK_SIZE);
                buf = buffer;
@ -853,6 +858,8 @@ int write_one_dir(Ecma119Image *t, Iso1999Node *dir)

    /* write the last block */
    ret = iso_write(t, buffer, BLOCK_SIZE);
+ex:;
+    LIBISO_FREE_MEM(buffer);
    return ret;
 }

@ -885,13 +892,17 @@ static
 int write_path_table(Ecma119Image *t, Iso1999Node **pathlist, int l_type)
 {
    size_t i, len;
-    uint8_t buf[256]; /* 256 is just a convenient size larger enought */
+    uint8_t *buf = NULL;
    struct ecma119_path_table_record *rec;
    void (*write_int)(uint8_t*, uint32_t, int);
    Iso1999Node *dir;
    uint32_t path_table_size;
    int parent = 0;
    int ret= ISO_SUCCESS;
+    uint8_t *zeros = NULL;
+
+    /* 256 is just a convenient size large enought */
+    LIBISO_ALLOC_MEM(buf, uint8_t, 256);

    path_table_size = 0;
    write_int = l_type ? iso_lsb : iso_msb;
@ -918,7 +929,7 @@ int write_path_table(Ecma119Image *t, Iso1999Node **pathlist, int l_type)
        ret = iso_write(t, buf, len);
        if (ret < 0) {
            /* error */
-            return ret;
+            goto ex;
        }
        path_table_size += len;
    }
@ -926,11 +937,14 @@ int write_path_table(Ecma119Image *t, Iso1999Node **pathlist, int l_type)
    /* we need to fill the last block with zeros */
    path_table_size %= BLOCK_SIZE;
    if (path_table_size) {
-        uint8_t zeros[BLOCK_SIZE];
+        LIBISO_ALLOC_MEM(zeros, uint8_t, BLOCK_SIZE);
        len = BLOCK_SIZE - path_table_size;
        memset(zeros, 0, len);
        ret = iso_write(t, zeros, len);
    }
+ex:;
+    LIBISO_FREE_MEM(zeros);
+    LIBISO_FREE_MEM(buf);
    return ret;
 }

--- a/libisofs/joliet.c
+++ b/libisofs/joliet.c
@ -1,6 +1,7 @@
 /*
 * Copyright (c) 2007 Vreixo Formoso
 * Copyright (c) 2007 Mario Danic
+ * Copyright (c) 2011 Thomas Schmitt
 *
 * This file is part of the libisofs project; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2 
@ -69,7 +70,7 @@ void joliet_node_free(JolietNode *node)
        return;
    }
    if (node->type == JOLIET_DIR) {
-        int i;
+        size_t i;
        for (i = 0; i < node->info.dir->nchildren; i++) {
            joliet_node_free(node->info.dir->children[i]);
        }
@ -348,7 +349,11 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
    JolietNode **children;
    IsoHTable *table;
    int need_sort = 0;
+    uint16_t *full_name = NULL;
+    uint16_t *tmp = NULL;

+    LIBISO_ALLOC_MEM(full_name, uint16_t, LIBISO_JOLIET_NAME_MAX);
+    LIBISO_ALLOC_MEM(tmp, uint16_t, LIBISO_JOLIET_NAME_MAX);
    nchildren = dir->info.dir->nchildren;
    children = dir->info.dir->children;

@ -359,7 +364,7 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
    ret = iso_htable_create((nchildren * 100) / 80, iso_str_hash,
                            (compare_function_t)ucscmp, &table);
    if (ret < 0) {
-        return ret;
+        goto ex;
    }
    for (i = 0; i < nchildren; ++i) {
        uint16_t *name = children[i]->name;
@ -371,7 +376,6 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)

    for (i = 0; i < nchildren; ++i) {
        uint16_t *name, *ext;
-        uint16_t full_name[LIBISO_JOLIET_NAME_MAX];
        int max; /* computed max len for name, without extension */
        int j = i;
        int digits = 1; /* characters to change per name */
@ -446,7 +450,7 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
                    max = maxchar + 1 - digits;
                }
                name = full_name;
-                if (max < ucslen(name)) {
+                if ((size_t) max < ucslen(name)) {
                    name[max] = 0;
                }
                /* let ext be an empty string */
@ -456,7 +460,6 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
            ok = 1;
            /* change name of each file */
            for (k = i; k <= j; ++k) {
-                uint16_t tmp[LIBISO_JOLIET_NAME_MAX];
                while (1) {
                    ret = joliet_create_mangled_name(tmp, name, digits,
                                                     change, ext);
@ -518,7 +521,10 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
    ret = ISO_SUCCESS;

 mangle_cleanup : ;
+ex:;
    iso_htable_destroy(table, NULL);
+    LIBISO_FREE_MEM(tmp);
+    LIBISO_FREE_MEM(full_name);
    return ret;
 }

@ -919,15 +925,16 @@ static
 int write_one_dir(Ecma119Image *t, JolietNode *dir)
 {
    int ret;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;
    size_t i;
    size_t fi_len, len;

    /* buf will point to current write position on buffer */
-    uint8_t *buf = buffer;
+    uint8_t *buf;

    /* initialize buffer with 0s */
-    memset(buffer, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
+    buf = buffer;

    /* write the "." and ".." entries first */
    write_one_dir_record(t, dir, 0, buf, 1, 0);
@ -954,7 +961,7 @@ int write_one_dir(Ecma119Image *t, JolietNode *dir)
                /* dir doesn't fit in current block */
                ret = iso_write(t, buffer, BLOCK_SIZE);
                if (ret < 0) {
-                    return ret;
+                    goto ex;
                }
                memset(buffer, 0, BLOCK_SIZE);
                buf = buffer;
@ -967,6 +974,8 @@ int write_one_dir(Ecma119Image *t, JolietNode *dir)

    /* write the last block */
    ret = iso_write(t, buffer, BLOCK_SIZE);
+ex:;
+    LIBISO_FREE_MEM(buffer);
    return ret;
 }

@ -999,14 +1008,18 @@ static
 int write_path_table(Ecma119Image *t, JolietNode **pathlist, int l_type)
 {
    size_t i, len;
-    uint8_t buf[256]; /* 256 is just a convenient size larger enought */
+    uint8_t *buf = NULL;
    struct ecma119_path_table_record *rec;
    void (*write_int)(uint8_t*, uint32_t, int);
    JolietNode *dir;
    uint32_t path_table_size;
    int parent = 0;
    int ret= ISO_SUCCESS;
+    uint8_t *zeros = NULL;

+    /* 256 is just a convenient size large enought */
+    LIBISO_ALLOC_MEM(buf, uint8_t, 256);
+    LIBISO_ALLOC_MEM(zeros, uint8_t, BLOCK_SIZE);
    path_table_size = 0;
    write_int = l_type ? iso_lsb : iso_msb;

@ -1033,7 +1046,7 @@ int write_path_table(Ecma119Image *t, JolietNode **pathlist, int l_type)
        ret = iso_write(t, buf, len);
        if (ret < 0) {
            /* error */
-            return ret;
+            goto ex;
        }
        path_table_size += len;
    }
@ -1041,11 +1054,13 @@ int write_path_table(Ecma119Image *t, JolietNode **pathlist, int l_type)
    /* we need to fill the last block with zeros */
    path_table_size %= BLOCK_SIZE;
    if (path_table_size) {
-        uint8_t zeros[BLOCK_SIZE];
        len = BLOCK_SIZE - path_table_size;
        memset(zeros, 0, len);
        ret = iso_write(t, zeros, len);
    }
+ex:;
+    LIBISO_FREE_MEM(zeros);
+    LIBISO_FREE_MEM(buf);
    return ret;
 }

--- a/libisofs/libisofs.h
+++ b/libisofs/libisofs.h
@ -18,15 +18,32 @@

 /* 
 *
- * Applications must use 64 bit off_t, e.g. on 32-bit GNU/Linux by defining
+ * Applications must use 64 bit off_t.
+ * E.g. on 32-bit GNU/Linux by defining
 *   #define _LARGEFILE_SOURCE
 *   #define _FILE_OFFSET_BITS 64
- * or take special precautions to interface with the library by 64 bit integers
- * where this .h files prescribe off_t. Not to use 64 bit file i/o will keep
- * the application from producing and processing ISO images of more than 2 GB
- * size.
- *
+ * The minimum requirement is to interface with the library by 64 bit signed
+ * integers where libisofs.h or libisoburn.h prescribe off_t.
+ * Failure to do so may result in surprising malfunction or memory faults.
+ * 
+ * Application files which include libisofs/libisofs.h must provide
+ * definitions for uint32_t and uint8_t.
+ * This can be achieved either:
+ * - by using autotools which will define HAVE_STDINT_H or HAVE_INTTYPES_H
+ *   according to its ./configure tests,
+ * - or by defining the macros HAVE_STDINT_H resp. HAVE_INTTYPES_H according
+ *   to the local situation,
+ * - or by appropriately defining uint32_t and uint8_t by other means,
+ *   e.g. by including inttypes.h before including libisofs.h
 */
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+

 /*
 * Normally this API is operated via public functions and opaque object
@ -42,14 +59,6 @@

 #include <sys/stat.h>

-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#else
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
-#endif
-
 #include <stdlib.h>

 struct burn_source;
@ -158,6 +167,15 @@ struct iso_file_section
    uint32_t size;
 };

+/* If you get here because of a compilation error like
+
+       /usr/include/libisofs/libisofs.h:166: error:
+       expected specifier-qualifier-list before 'uint32_t'
+
+   then see the paragraph above about the definition of uint32_t.
+*/
+
+
 /**
 * Context for iterate on directory children.
 * @see iso_dir_get_children()
@ -1209,8 +1227,8 @@ int iso_lib_is_compatible(int major, int minor, int micro);
 * @since 0.6.2
 */
 #define iso_lib_header_version_major  1
-#define iso_lib_header_version_minor  0
-#define iso_lib_header_version_micro  8
+#define iso_lib_header_version_minor  1
+#define iso_lib_header_version_micro  2

 /**
 * Usage discussion:
@ -2858,6 +2876,35 @@ int iso_image_add_boot_image(IsoImage *image, const char *image_path,
 int iso_image_get_boot_image(IsoImage *image, ElToritoBootImage **boot,
                             IsoFile **imgnode, IsoBoot **catnode);

+/**
+ * Get detailed information about the boot catalog that was loaded from
+ * an ISO image.
+ * The boot catalog links the El Torito boot record at LBA 17 with the 
+ * boot images which are IsoFile objects in the image. The boot catalog
+ * itself is not a regular file and thus will not deliver an IsoStream.
+ * Its content is usually quite short and can be obtained by this call.
+ *
+ * @param image
+ *      The image to inquire.
+ * @param catnode
+ *      Will return the boot catalog tree node. No extra ref is taken.
+ * @param lba
+ *      Will return the block address of the boot catalog in the image.
+ * @param content
+ *      Will return either NULL or an allocated memory buffer with the
+ *      content bytes of the boot catalog.
+ *      Dispose it by free() when no longer needed.
+ * @param size
+ *      Will return the number of bytes in content.
+ * @return
+ *      1 if reply is valid, 0 if not boot catalog was loaded, < 0 on error.
+ *
+ * @since 1.1.2
+ */
+int iso_image_get_bootcat(IsoImage *image, IsoBoot **catnode, uint32_t *lba,
+                          char **content, off_t *size);
+
+
 /**
 * Get all El-Torito boot images of an ISO image.
 *
--- a/libisofs/libisofs.ver
+++ b/libisofs/libisofs.ver
@ -88,6 +88,7 @@ iso_image_get_all_boot_imgs;
 iso_image_get_application_id;
 iso_image_get_attached_data;
 iso_image_get_biblio_file_id;
+iso_image_get_bootcat;
 iso_image_get_boot_image;
 iso_image_get_copyright_file_id;
 iso_image_get_data_preparer_id;
--- a/libisofs/make_isohybrid_mbr.c
+++ b/libisofs/make_isohybrid_mbr.c
@ -135,7 +135,7 @@ int make_isohybrid_mbr(int bin_lba, int *img_blocks, char *mbr, int flag)

    static int h = 64, s = 32;

-    int i, warn_size = 0, id;
+    int i, id;
    char *wpt;
    off_t imgsize, cylsize, frac, padding, c, cc;

@ -164,7 +164,6 @@ int make_isohybrid_mbr(int bin_lba, int *img_blocks, char *mbr, int flag)
    *img_blocks = imgsize / (off_t) 2048;
    c = imgsize / cylsize;
    if (c > 1024) {
-        warn_size = 1;
        cc = 1024;
    } else
        cc = c;
@ -424,7 +423,7 @@ int make_isolinux_mbr(int32_t *img_blocks, uint32_t boot_lba,
    /* # Offset 446
    */
    for (part = 1 ; part <= 4; part++) {
-        if (part != part_number) {
+        if ((int) part != part_number) {
            /* if this_partition != partition_number: write 16 zero bytes */
            memset(wpt, 0, 16);
            wpt+= 16;
--- a/libisofs/md5.c
+++ b/libisofs/md5.c
@ -229,10 +229,10 @@ static int md5_init(libisofs_md5_ctx *ctx, int flag)
 static int md5_update(libisofs_md5_ctx *ctx, unsigned char *data,
                      int datalen, int flag)
 {
- unsigned int i, index, partlen;
+ int i, index, partlen;

 /* Compute number of bytes mod 64 */
- index = (unsigned int)((ctx->count[0] >> 3) & 0x3F);
+ index = ((ctx->count[0] >> 3) & 0x3F);
 /* Update number of bits */
 if ((ctx->count[0] += ((uint32_t) datalen << 3)) < 
     ((uint32_t) datalen << 3))
@ -621,11 +621,6 @@ int checksum_writer_write_data(IsoImageWriter *writer)
    void *ctx = NULL;
    char md5[16];

-#ifdef NIX
-    char tag_block[2048];
-    int l;
-#endif
-
    if (writer == NULL) {
        return ISO_ASSERT_FAILURE;
    }
@ -724,15 +719,16 @@ int iso_md5_write_scdbackup_tag(Ecma119Image *t, char *tag_block, int flag)
 {
    void *ctx = NULL;
    off_t pos = 0, line_start;
-    int record_len, block_len, res, i;
-    char postext[40], md5[16], record[160];
+    int record_len, block_len, ret, i;
+    char postext[40], md5[16], *record = NULL;

+    LIBISO_ALLOC_MEM(record, char, 160);
    line_start = strlen(tag_block);
    iso_md5_compute(t->checksum_ctx, tag_block, line_start);
-    res = iso_md5_clone(t->checksum_ctx, &ctx);
-    if (res < 0)
+    ret = iso_md5_clone(t->checksum_ctx, &ctx);
+    if (ret < 0)
        goto ex;
-    res = iso_md5_end(&ctx, md5);
+    ret = iso_md5_end(&ctx, md5);

    pos = (off_t) t->checksum_tag_pos * (off_t) 2048 + line_start;
    if(pos >= 1000000000)
@ -747,8 +743,8 @@ int iso_md5_write_scdbackup_tag(Ecma119Image *t, char *tag_block, int flag)
                 "%2.2x", ((unsigned char *) md5)[i]);
    record_len += 32;

-    res = iso_md5_start(&ctx);
-    if (res < 0)
+    ret = iso_md5_start(&ctx);
+    if (ret < 0)
        goto ex;
    iso_md5_compute(ctx, record, record_len);
    iso_md5_end(&ctx, md5);
@ -765,11 +761,12 @@ int iso_md5_write_scdbackup_tag(Ecma119Image *t, char *tag_block, int flag)
    if (t->scdbackup_tag_written != NULL)
    	strncpy(t->scdbackup_tag_written, tag_block + line_start,
                block_len - line_start);
-    res = ISO_SUCCESS;
+    ret = ISO_SUCCESS;
 ex:;
    if (ctx != NULL)
        iso_md5_end(&ctx, md5);
-    return res;
+    LIBISO_FREE_MEM(record);
+    return ret;
 }


@ -783,20 +780,20 @@ ex:;
 */
 int iso_md5_write_tag(Ecma119Image *t, int flag)
 {
-    int res, mode, l, i, wres, tag_id_len;
+    int ret, mode, l, i, wres, tag_id_len;
    void *ctx = NULL;
-    char md5[16], tag_block[2048], *tag_id;
+    char md5[16], *tag_block = NULL, *tag_id;
    uint32_t size = 0, pos = 0, start;

+    LIBISO_ALLOC_MEM(tag_block, char, 2048);
    start = t->checksum_range_start;
-    memset(tag_block, 0, 2048);
    mode = flag & 255;
    if (mode < 1 || mode > 4)
-        return ISO_WRONG_ARG_VALUE;
-    res = iso_md5_clone(t->checksum_ctx, &ctx);
-    if (res < 0)
-        return res;
-    res = iso_md5_end(&ctx, md5);
+        {ret = ISO_WRONG_ARG_VALUE; goto ex;}
+    ret = iso_md5_clone(t->checksum_ctx, &ctx);
+    if (ret < 0)
+        goto ex;
+    ret = iso_md5_end(&ctx, md5);
    if (mode == 1) {
        size = t->checksum_range_size;
        pos = t->checksum_tag_pos;
@ -811,7 +808,7 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
        }
        size = pos - start;
    }
-    if (res < 0)
+    if (ret < 0)
        goto ex;

    iso_util_tag_magic(mode, &tag_id, &tag_id_len, 0);
@ -833,8 +830,8 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
                ((unsigned char *) md5)[i]);
    l+= 32;
        
-    res = iso_md5_start(&ctx);
-    if (res > 0) {
+    ret = iso_md5_start(&ctx);
+    if (ret > 0) {
        iso_md5_compute(ctx, tag_block, l);
        iso_md5_end(&ctx, md5);
        strcpy(tag_block + l, " self=");
@ -849,8 +846,8 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
        if (t->ms_block > 0) {
            iso_msg_submit(t->image->id, ISO_SCDBACKUP_TAG_NOT_0, 0, NULL);
        } else {
-            res = iso_md5_write_scdbackup_tag(t, tag_block, 0);
-            if (res < 0)
+            ret = iso_md5_write_scdbackup_tag(t, tag_block, 0);
+            if (ret < 0)
                goto ex;
        }
    }
@ -861,16 +858,17 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
    } else {
        wres = iso_write(t, tag_block, 2048);
        if (wres < 0) {
-            res = wres;
+            ret = wres;
            goto ex;
        }
    }

-    res = ISO_SUCCESS;
+    ret = ISO_SUCCESS;
 ex:;
    if (ctx != NULL)
        iso_md5_end(&ctx, md5);
-    return res;
+    LIBISO_FREE_MEM(tag_block);
+    return ret;
 }


--- a/libisofs/messages.c
+++ b/libisofs/messages.c
@ -245,15 +245,18 @@ int iso_set_abort_severity(char *severity)

 void iso_msg_debug(int imgid, const char *fmt, ...)
 {
-    char msg[MAX_MSG_LEN];
+    char *msg = NULL;
    va_list ap;

+    LIBISO_ALLOC_MEM_VOID(msg, char, MAX_MSG_LEN);
    va_start(ap, fmt);
    vsnprintf(msg, MAX_MSG_LEN, fmt, ap);
    va_end(ap);

    libiso_msgs_submit(libiso_msgr, imgid, 0x00000002, LIBISO_MSGS_SEV_DEBUG,
                       LIBISO_MSGS_PRIO_ZERO, msg, 0, 0);
+ex:;
+    LIBISO_FREE_MEM(msg);
 }

 const char *iso_error_to_msg(int errcode)
@ -480,7 +483,7 @@ int iso_msg_submit(int imgid, int errcode, int causedby, const char *fmt, ...)
    va_list ap;

    /* when called with ISO_CANCELED, we don't need to submit any message */
-    if (errcode == ISO_CANCELED && fmt == NULL) {
+    if (errcode == (int) ISO_CANCELED && fmt == NULL) {
        return ISO_CANCELED;
    }

--- a/libisofs/node.c
+++ b/libisofs/node.c
@ -19,6 +19,7 @@
 #include "aaip_0_2.h"
 #include "messages.h"
 #include "util.h"
+#include "eltorito.h"


 #include <stdlib.h>
@ -78,6 +79,14 @@ void iso_node_unref(IsoNode *node)
                IsoSymlink *link = (IsoSymlink*) node;
                free(link->dest);
            }
+            break;
+        case LIBISO_BOOT:
+            {
+                IsoBoot *bootcat = (IsoBoot *) node;
+                if (bootcat->content != NULL)
+                    free(bootcat->content);
+            }
+            break;
        default:
            /* other kind of nodes does not need to delete anything here */
            break;
@ -1573,7 +1582,7 @@ int iso_aa_get_attrs(unsigned char *aa_string, size_t *num_attrs,
         goto ex;
    }

-    if (rpt - aa_string != len) {
+    if ((size_t) (rpt - aa_string) != len) {
         /* aaip_decode_attrs() returns 2 but still bytes are left */
         ret = ISO_AAIP_BAD_AASTRING;
         goto ex;
@ -1615,7 +1624,9 @@ int iso_aa_lookup_attr(unsigned char *aa_string, char *name,

    ret = iso_aa_get_attrs(aa_string, &num_attrs, &names,
                           &value_lengths, &values, 0);
-    for (i = 0; i < num_attrs; i++) {
+    if (ret < 0)
+        return ret;
+    for (i = 0; i < (int) num_attrs; i++) {
        if (strcmp(names[i], name))
    continue;
        *value_length = value_lengths[i];
@ -2850,7 +2861,7 @@ int iso_file_get_md5(IsoImage *image, IsoFile *file, char md5[16], int flag)
        ret = 0;
        goto ex;
    }
-    for (i = 0; i < value_len; i++)
+    for (i = 0; i < (int) value_len; i++)
        idx = (idx << 8) | ((unsigned char *) value)[i];
    if (idx == 0 || idx > image->checksum_idx_count - 1) {
                                       /* (last index is not MD5 of a file) */
--- a/libisofs/rockridge.c
+++ b/libisofs/rockridge.c
@ -1,7 +1,7 @@
 /*
 * Copyright (c) 2007 Vreixo Formoso
 * Copyright (c) 2007 Mario Danic
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
 * 
 * This file is part of the libisofs project; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License version 2 
@ -450,8 +450,8 @@ static
 int rrip_add_SL(Ecma119Image *t, struct susp_info *susp, uint8_t **comp,
                size_t n, int ce)
 {
-    int ret, i, j;
-
+    int ret;
+    size_t i, j;
    int total_comp_len = 0;
    size_t pos, written = 0;

@ -1054,8 +1054,8 @@ int susp_calc_nm_sl_al(Ecma119Image *t, Ecma119Node *n, size_t space,
                         * First, we check how many bytes fit in current
                         * SL field 
                         */
-                        int fit = 255 - sl_len - 2;
-                        if (clen - 250 <= fit) {
+                        ssize_t fit = 255 - sl_len - 2;
+                        if ((ssize_t) (clen - 250) <= fit) {
                            /* 
                             * the component can be divided between this
                             * and another SL entry
@ -1257,7 +1257,8 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t used_up,

        /* "." or ".." entry */

-        su_size += 5; /* NM field */
+        if (!t->rrip_version_1_10)
+            su_size += 5; /* NM field */

        if (type == 1 && n->parent == NULL) {
            /* 
@ -1342,7 +1343,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
    size_t su_size_pd, ce_len_pd; /* predicted sizes of SUA and CA */
    int ce_is_predicted = 0;
    size_t aaip_sua_free= 0, aaip_len= 0;
-    size_t space;
+    int space;

    if (t == NULL || n == NULL || info == NULL) {
        return ISO_NULL_POINTER;
@ -1354,7 +1355,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
    if (type < 0 || type > 2 || space < ISO_ROCKRIDGE_IN_DIR_REC) {
        iso_msg_submit(t->image->id, ISO_ASSERT_FAILURE, 0,
          "Unknown node type %d or short RR space %d < %d in directory record",
-          type, (int) space, ISO_ROCKRIDGE_IN_DIR_REC);
+          type, space, ISO_ROCKRIDGE_IN_DIR_REC);
        return ISO_ASSERT_FAILURE;
    }

@ -1438,7 +1439,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
    if (info->suf_len + 28 > space) {
        iso_msg_submit(t->image->id, ISO_ASSERT_FAILURE, 0,
         "Directory Record overflow. name='%s' , suf_len=%d > space=%d - 28\n", 
-         node->iso_name, (int) info->suf_len, (int) space);
+         node->iso_name, (int) info->suf_len, space);
        return ISO_ASSERT_FAILURE;
    }

@ -1460,9 +1461,11 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
        /* Try whether NM, SL, AL will fit into SUA */
        su_size_pd = info->suf_len;
        ce_len_pd = ce_len;
-        ret = susp_calc_nm_sl_al(t, n, space, &su_size_pd, &ce_len_pd, 0);
+        ret = susp_calc_nm_sl_al(t, n, (size_t) space,
+                                 &su_size_pd, &ce_len_pd, 0);
        if (ret == 0) { /* Have to use CA. 28 bytes of CE are necessary */
-            ret = susp_calc_nm_sl_al(t, n, space, &su_size_pd, &ce_len_pd, 1);
+            ret = susp_calc_nm_sl_al(t, n, (size_t) space,
+                                     &su_size_pd, &ce_len_pd, 1);
            sua_free -= 28;
            ce_is_predicted = 1;
        }
@ -1554,8 +1557,8 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
                             * First, we check how many bytes fit in current
                             * SL field 
                             */
-                            int fit = 255 - sl_len - 2;
-                            if (clen - 250 <= fit) {
+                            ssize_t fit = 255 - sl_len - 2;
+                            if ((ssize_t) (clen - 250) <= fit) {
                                /* 
                                 * the component can be divided between this
                                 * and another SL entry
@ -1711,9 +1714,36 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
        /* "." or ".." entry */

        /* write the NM entry */
-        ret = rrip_add_NM(t, info, NULL, 0, 1 << type, 0);
-        if (ret < 0) {
-            goto add_susp_cleanup;
+        if (t->rrip_version_1_10) {
+            /* RRIP-1.10:
+               "NM" System Use Fields recorded for the ISO 9660 directory
+                records with names (00) and (01), used to designate the
+                current and parent directories, respectively, should be
+                ignored. Instead, the receiving system should convert these
+                names to the appropriate receiving system-dependent
+                designations for the current and parent directories.
+            */
+            /* mkisofs obviously writes no NM for '.' and '..' .
+               Program isoinfo shows empty names with records as of RRIP-1.12
+            */
+            /* no op */;
+        } else {
+            /* RRIP-1.12:
+               If the ISO 9660 Directory Record File Identifier is (00), then
+               the CURRENT bit of the "NM" Flags field [...], if present, shall
+               be set to ONE. If the ISO 9660 Directory Record File Identifier
+               is (01), then the PARENT bit of the "NM" Flags field [...],
+               if present, shall be set to ONE.
+               [...]
+               "BP 3 - Length (LEN_NM)" shall specify as an 8-bit number the
+               length in bytes [...]. If bit position 1, 2, or 5 of the "NM"
+               Flags is set to ONE, the value of this field shall be 5 and no
+               Name Content shall be recorded.
+               [The CURRENT bit has position 1. The PARENT bit has position 2.]
+            */
+            ret = rrip_add_NM(t, info, NULL, 0, 1 << type, 0);
+            if (ret < 0)
+                goto add_susp_cleanup;
        }

        if (type == 1 && n->parent == NULL) {
@ -1821,12 +1851,13 @@ void rrip_write_susp_fields(Ecma119Image *t, struct susp_info *info,
 int rrip_write_ce_fields(Ecma119Image *t, struct susp_info *info)
 {
    size_t i;
-    uint8_t padding[BLOCK_SIZE];
+    uint8_t *padding = NULL;
    int ret= ISO_SUCCESS;

    if (info->n_ce_susp_fields == 0) {
-        return ret;
+        goto ex;
    }
+    LIBISO_ALLOC_MEM(padding, uint8_t, BLOCK_SIZE);

    for (i = 0; i < info->n_ce_susp_fields; i++) {
        ret = iso_write(t, info->ce_susp_fields[i], 
@ -1852,6 +1883,8 @@ int rrip_write_ce_fields(Ecma119Image *t, struct susp_info *info)
    info->ce_susp_fields = NULL;
    info->n_ce_susp_fields = 0;
    info->ce_len = 0;
+ex:;
+    LIBISO_FREE_MEM(padding);
    return ret;
 }

--- a/libisofs/rockridge_read.c
+++ b/libisofs/rockridge_read.c
@ -81,8 +81,7 @@ int susp_iter_next(SuspIterator *iter, struct susp_sys_user_entry **sue)
         * (IEEE 1281, SUSP. section 4) 
         */
        if (iter->ce_len) {
-            uint32_t block;
-            int nblocks;
+            uint32_t block, nblocks;

            /* A CE has found, there is another continuation area */
            nblocks = DIV_UP(iter->ce_off + iter->ce_len, BLOCK_SIZE);
--- a/libisofs/stream.c
+++ b/libisofs/stream.c
@ -398,7 +398,7 @@ static
 int cut_out_read(IsoStream *stream, void *buf, size_t count)
 {
    struct cut_out_stream *data = stream->data;
-    count = (size_t)MIN(data->size - data->pos, count);
+    count = (size_t) MIN((size_t) (data->size - data->pos), count);
    if (count == 0) {
        return 0;
    }
@ -647,7 +647,7 @@ int mem_read(IsoStream *stream, void *buf, size_t count)
        return ISO_FILE_NOT_OPENED;
    }

-    if (data->offset >= data->size) {
+    if (data->offset >= (ssize_t) data->size) {
        return 0; /* EOF */
    }

@ -869,6 +869,10 @@ void iso_stream_get_file_name(IsoStream *stream, char *name)
    if (!strncmp(type, "fsrc", 4)) {
        FSrcStreamData *data = stream->data;
        char *path = iso_file_source_get_path(data->src);
+        if (path == NULL) {
+            name[0] = 0;
+            return;
+        }
        strncpy(name, path, PATH_MAX - 1);
        name[PATH_MAX - 1] = 0;
        free(path);
@ -1076,14 +1080,15 @@ int iso_stream_read_buffer(IsoStream *stream, char *buf, size_t count,
 */  
 int iso_stream_make_md5(IsoStream *stream, char md5[16], int flag)
 {
-    int res, is_open = 0;
-    char buffer[2048];
+    int ret, is_open = 0;
+    char * buffer = NULL;
    void *ctx= NULL;
    off_t file_size;
    uint32_t b, nblocks;
    size_t got_bytes;
    IsoStream *input_stream;

+    LIBISO_ALLOC_MEM(buffer, char, 2048);
    if (flag & 1) {
        while(1) {
           input_stream = iso_stream_get_input_stream(stream, 0);
@ -1094,36 +1099,37 @@ int iso_stream_make_md5(IsoStream *stream, char md5[16], int flag)
    }

    if (! iso_stream_is_repeatable(stream))
-        return 0;
-    res = iso_md5_start(&ctx);
-    if (res < 0)
-        return res;
-    res = iso_stream_open(stream);
-    if (res < 0)
-        return 0;
+        {ret = 0; goto ex;}
+    ret = iso_md5_start(&ctx);
+    if (ret < 0)
+        goto ex;
+    ret = iso_stream_open(stream);
+    if (ret < 0)
+        goto ex;
    is_open = 1;
    file_size = iso_stream_get_size(stream);
    nblocks = DIV_UP(file_size, 2048);
    for (b = 0; b < nblocks; ++b) {
-        res = iso_stream_read_buffer(stream, buffer, 2048, &got_bytes);
-        if (res < 0) {
-            res = 0;
+        ret = iso_stream_read_buffer(stream, buffer, 2048, &got_bytes);
+        if (ret < 0) {
+            ret = 0;
            goto ex;
        }
        /* Do not use got_bytes to stay closer to IsoFileSrc processing */
        if (file_size - b * 2048 > 2048)
-            res = 2048;
+            ret = 2048;
        else
-            res = file_size - b * 2048;
-        iso_md5_compute(ctx, buffer, res);
+            ret = file_size - b * 2048;
+        iso_md5_compute(ctx, buffer, ret);
    }
-    res = 1;
+    ret = 1;
 ex:;
    if (is_open)
        iso_stream_close(stream);
    if (ctx != NULL)
        iso_md5_end(&ctx, md5);
-    return res;
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }

 /* API */
--- a/libisofs/system_area.c
+++ b/libisofs/system_area.c
@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2008 Vreixo Formoso
- * Copyright (c) 2010 Thomas Schmitt
+ * Copyright (c) 2010 - 2011 Thomas Schmitt
 *
 * This file is part of the libisofs project; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2 
@ -387,7 +387,7 @@ static int make_mips_volume_header(Ecma119Image *t, uint8_t *buf, int flag)
    /*  84 -  87 | boot_bytes | File length in bytes */
    /*  88 - 311 |          0 | Volume Directory Entries 2 to 15 */

-    for (idx = 0; idx < t->image->num_mips_boot_files; idx++) {
+    for (idx = 0; (int) idx < t->image->num_mips_boot_files; idx++) {
        ret = boot_nodes_from_iso_path(t, t->image->mips_boot_file_paths[idx], 
                                       &node, &ecma_node, "MIPS boot file", 0);
        if (ret < 0)
@ -457,18 +457,19 @@ int iso_read_mipsel_elf(Ecma119Image *t, int flag)
 {
    uint32_t phdr_adr, todo, count;
    int ret;
-    uint8_t elf_buf[2048];
+    uint8_t *elf_buf = NULL;
    IsoNode *iso_node;
    Ecma119Node *ecma_node;
    IsoStream *stream;
    
    if (t->image->num_mips_boot_files <= 0)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}

+    LIBISO_ALLOC_MEM(elf_buf, uint8_t, 2048);
    ret = boot_nodes_from_iso_path(t, t->image->mips_boot_file_paths[0],
                                   &iso_node, &ecma_node, "MIPS boot file", 0);
    if (ret < 0)
-        return ret;
+        goto ex;
    stream = iso_file_get_stream((IsoFile *) iso_node);

    ret = iso_stream_open(stream);
@ -476,7 +477,7 @@ int iso_read_mipsel_elf(Ecma119Image *t, int flag)
        iso_msg_submit(t->image->id, ret, 0,
                       "Cannot open designated MIPS boot file '%s'",
                       t->image->mips_boot_file_paths[0]);
-        return ret;
+        goto ex;
    }
    ret = iso_stream_read(stream, elf_buf, 32);
    if (ret != 32) {
@ -485,7 +486,7 @@ cannot_read:;
        iso_msg_submit(t->image->id, ret, 0,
                       "Cannot read from designated MIPS boot file '%s'",
                       t->image->mips_boot_file_paths[0]);
-        return ret;
+        goto ex;
    }


@ -504,7 +505,7 @@ cannot_read:;
            count = todo;
        todo -= count;
        ret = iso_stream_read(stream, elf_buf, count);
-        if (ret != count)
+        if (ret != (int) count)
            goto cannot_read;
    }
    ret = iso_stream_read(stream, elf_buf, 20);
@ -521,7 +522,10 @@ cannot_read:;
    t->mipsel_p_filesz = iso_read_lsb(elf_buf + 16, 4);

    iso_stream_close(stream);
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(elf_buf);
+    return ret;
 }


@ -679,7 +683,8 @@ static int make_sun_disk_label(Ecma119Image *t, uint8_t *buf, int flag)
    ret = write_sun_partition_entry(1, t->appended_partitions,
                  t->appended_part_start, t->appended_part_size,
                  ISO_SUN_CYL_SIZE, buf, 0);
- 
+    if (ret < 0)
+        return ret;
    return ISO_SUCCESS;
 }

@ -844,14 +849,15 @@ int iso_align_isohybrid(Ecma119Image *t, int flag)
    int sa_type, ret, always_align;
    uint32_t img_blocks;
    off_t imgsize, cylsize = 0, frac;
-    char msg[160];
+    char *msg = NULL;

+    LIBISO_ALLOC_MEM(msg, char, 160);
    sa_type = (t->system_area_options >> 2) & 0x3f;
    if (sa_type != 0)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
    always_align = (t->system_area_options >> 8) & 3;

-    img_blocks = t->curblock;
+    img_blocks = t->curblock + t->tail_blocks;
    imgsize = ((off_t) img_blocks) * (off_t) 2048;
    if (((t->system_area_options & 3) || always_align)
        && (off_t) (t->partition_heads_per_cyl * t->partition_secs_per_head
@ -877,7 +883,7 @@ int iso_align_isohybrid(Ecma119Image *t, int flag)
    }

    if (always_align >= 2)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}

    cylsize = 0;
    if (t->catalog != NULL &&
@ -886,7 +892,7 @@ int iso_align_isohybrid(Ecma119Image *t, int flag)
           an MBR from our built-in template. (Deprecated since 31 Mar 2010)
        */
        if (img_blocks >= 0x40000000)
-            return ISO_SUCCESS;
+            {ret = ISO_SUCCESS; goto ex;}
        cylsize = 64 * 32 * 512;
    } else if ((t->system_area_options & 2) || always_align) {
        /* Patch externally provided system area as isohybrid MBR */
@ -894,18 +900,18 @@ int iso_align_isohybrid(Ecma119Image *t, int flag)
            /* isohybrid makes only sense together with ISOLINUX boot image
               and externally provided System Area.
            */
-            return ISO_ISOLINUX_CANT_PATCH;
+            {ret = ISO_ISOLINUX_CANT_PATCH; goto ex;}
        }
        cylsize = t->partition_heads_per_cyl * t->partition_secs_per_head
                  * 512;
    } 
    if (cylsize == 0)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
    if (((double) imgsize) / (double) cylsize > 1024.0) {
        iso_msgs_submit(0,
                  "Image size exceeds 1024 cylinders. Cannot align partition.",
                  0, "WARNING", 0);
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
    }

    frac = imgsize % cylsize;
@ -913,7 +919,7 @@ int iso_align_isohybrid(Ecma119Image *t, int flag)

    frac = imgsize - ((off_t) img_blocks) * (off_t) 2048;
    if (frac == 0)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
    if (frac % 2048) {
        sprintf(msg,
             "Cylinder size %d not divisible by 2048. Cannot align partition.",
@ -922,5 +928,8 @@ int iso_align_isohybrid(Ecma119Image *t, int flag)
    } else {
        t->tail_blocks += frac / 2048;
    }
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(msg);
+    return ret;
 }
--- a/libisofs/tree.c
+++ b/libisofs/tree.c
@ -478,12 +478,12 @@ int iso_tree_remove_exclude(IsoImage *image, const char *path)
        return ISO_NULL_POINTER;
    }

-    for (i = 0; i < image->nexcludes; ++i) {
+    for (i = 0; (int) i < image->nexcludes; ++i) {
        if (strcmp(image->excludes[i], path) == 0) {
            /* exclude found */
            free(image->excludes[i]);
            --image->nexcludes;
-            for (j = i; j < image->nexcludes; ++j) {
+            for (j = i; (int) j < image->nexcludes; ++j) {
                image->excludes[j] = image->excludes[j+1]; 
            }
            image->excludes = realloc(image->excludes, image->nexcludes * 
@ -761,11 +761,16 @@ int iso_add_dir_src_rec(IsoImage *image, IsoDir *parent, IsoFileSource *dir)

    ret = iso_file_source_open(dir);
    if (ret < 0) {
-        char *path = iso_file_source_get_path(dir);
+        path = iso_file_source_get_path(dir);
        /* instead of the probable error, we throw a sorry event */
-        ret = iso_msg_submit(image->id, ISO_FILE_CANT_ADD, ret, 
-                             "Can't open dir %s", path);
-        free(path);
+	if (path != NULL) {
+            ret = iso_msg_submit(image->id, ISO_FILE_CANT_ADD, ret, 
+                                 "Can't open dir %s", path);
+            free(path);
+        } else {
+            ret = iso_msg_submit(image->id, ISO_NULL_POINTER, ret,
+                           "Can't open dir. NULL pointer caught as dir name");
+        }
        return ret;
    }

@ -785,6 +790,11 @@ int iso_add_dir_src_rec(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
        }

        path = iso_file_source_get_path(file);
+        if (path == NULL) {
+            ret = iso_msg_submit(image->id, ISO_NULL_POINTER, ret, 
+                                 "NULL pointer caught as file path");
+            return ret;
+        }
        name = strrchr(path, '/') + 1;

        if (image->follow_symlinks) {
@ -847,7 +857,7 @@ int iso_add_dir_src_rec(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
        ret = iso_dir_insert(parent, new, pos, replace);
        if (ret < 0) {
            iso_node_unref(new);
-            if (ret != ISO_NODE_NAME_NOT_UNIQUE) {
+            if (ret != (int) ISO_NODE_NAME_NOT_UNIQUE) {
                /* error */
                goto dir_rec_continue;
            } else {
--- a/libisofs/util.c
+++ b/libisofs/util.c
@ -219,7 +219,7 @@ int strconv(const char *str, const char *icharset, const char *ocharset,
    src = (char *)str;
    ret = (char *)out;
    n = iso_iconv(&conv, &src, &inbytes, &ret, &outbytes, 0);
-    if (n == -1) {
+    if (n == (size_t) -1) {
        /* error */
        iso_iconv_close(&conv, 0);
        retval = ISO_CHARSET_CONV_ERROR;
@ -269,7 +269,7 @@ int strnconv(const char *str, const char *icharset, const char *ocharset,
    src = (char *)str;
    ret = (char *)out;
    n = iso_iconv(&conv, &src, &inbytes, &ret, &outbytes, 0);
-    if (n == -1) {
+    if (n == (size_t) -1) {
        /* error */
        iso_iconv_close(&conv, 0);
        retval = ISO_CHARSET_CONV_ERROR;
@ -336,7 +336,7 @@ int str2wchar(const char *icharset, const char *input, wchar_t **output)
    src = (char *)input;

    n = iso_iconv(&conv, &src, &inbytes, &ret, &outbytes, 0);
-    while (n == -1) {
+    while (n == (size_t) -1) {

        if (errno == E2BIG) {
            /* error, should never occur */
@ -435,7 +435,7 @@ int str2ascii(const char *icharset, const char *input, char **output)
    }

    n = iso_iconv(&conv, &src, &inbytes, &ret, &outbytes, 0);
-    while (n == -1) {
+    while (n == (size_t) -1) {
        /* The destination buffer is too small. Stops here. */
        if (errno == E2BIG)
            break;
@ -566,7 +566,7 @@ int str2ucs(const char *icharset, const char *input, uint16_t **output)
    }

    n = iso_iconv(&conv, &src, &inbytes, &ret, &outbytes, 0);
-    while (n == -1) {
+    while (n == (size_t) -1) {
        /* The destination buffer is too small. Stops here. */
        if (errno == E2BIG)
            break;
@ -636,7 +636,7 @@ char *iso_dirid(const char *src, int size)
    char name[32];

    len = strlen(src);
-    if (len > size) {
+    if ((int) len > size) {
        len = size;
    }
    for (i = 0; i < len; i++) {
@ -770,7 +770,7 @@ char *iso_r_dirid(const char *src, int size, int relaxed)
    char *dest;

    len = strlen(src);
-    if (len > size) {
+    if ((int) len > size) {
        len = size;
    }
    dest = malloc(len + 1);
@ -838,15 +838,15 @@ char *iso_r_fileid(const char *src, size_t len, int relaxed, int forcedot)
     */
    if (dot == NULL || *(dot + 1) == '\0') {
        lname = strlen(src);
-        lnname = (lname > len) ? len : lname;
+        lnname = (lname > (int) len) ? (int) len : lname;
        lext = lnext = 0;
    } else {
        lext = strlen(dot + 1);
        lname = strlen(src) - lext - 1;
        lnext = (strlen(src) > len + 1 && lext > 3) ? 
-                (lname < len - 3 ? len - lname : 3)
+                (lname < (int) len - 3 ? (int) len - lname : 3)
                : lext;
-        lnname = (strlen(src) > len + 1) ? len - lnext : lname;
+        lnname = (strlen(src) > len + 1) ? (int) len - lnext : lname;
    }

    if (lnname == 0 && lnext == 0) {
@ -921,13 +921,15 @@ ex:;
 */
 uint16_t *iso_j_file_id(const uint16_t *src, int flag)
 {
-    uint16_t *dot;
+    uint16_t *dot, *retval = NULL;
    size_t lname, lext, lnname, lnext, pos, i, maxchar = 64;
-    uint16_t dest[LIBISO_JOLIET_NAME_MAX];
+    uint16_t *dest = NULL;
+
+    LIBISO_ALLOC_MEM_VOID(dest, uint16_t, LIBISO_JOLIET_NAME_MAX);
                               /* was: 66 = 64 (name + ext) + 1 (.) + 1 (\0) */

    if (src == NULL) {
-        return NULL;
+        goto ex;
    }
    if (flag & 2)
        maxchar = 103;
@ -954,7 +956,7 @@ uint16_t *iso_j_file_id(const uint16_t *src, int flag)
    }

    if (lnname == 0 && lnext == 0) {
-        return NULL;
+        goto ex;
    }

    pos = 0;
@ -989,7 +991,10 @@ uint16_t *iso_j_file_id(const uint16_t *src, int flag)

 is_done:;
    set_ucsbe(dest + pos, '\0');
-    return ucsdup(dest);
+    retval = ucsdup(dest);
+ex:;
+    LIBISO_FREE_MEM(dest);
+    return retval;
 }

 /* @param flag bit1= allow 103 characters rather than 64
@ -997,10 +1002,12 @@ is_done:;
 uint16_t *iso_j_dir_id(const uint16_t *src, int flag)
 {
    size_t len, i, maxchar = 64;
-    uint16_t dest[LIBISO_JOLIET_NAME_MAX]; /* was: 65 = 64 + 1 (\0) */
+    uint16_t *dest = NULL, *retval = NULL;
+                                                    /* was: 65 = 64 + 1 (\0) */
+    LIBISO_ALLOC_MEM_VOID(dest, uint16_t, LIBISO_JOLIET_NAME_MAX);

    if (src == NULL) {
-        return NULL;
+        goto ex;
    }
    if (flag & 2)
        maxchar = 103;
@ -1018,7 +1025,10 @@ uint16_t *iso_j_dir_id(const uint16_t *src, int flag)
        }
    }
    set_ucsbe(dest + len, '\0');
-    return ucsdup(dest);
+    retval = ucsdup(dest);
+ex:
+    LIBISO_FREE_MEM(dest);
+    return retval;
 }

 size_t ucslen(const uint16_t *str)
@ -1564,12 +1574,12 @@ void strncpy_pad(char *dest, const char *src, size_t max)
    
    if (src != NULL) {
        len = MIN(strlen(src), max);
+        for (i = 0; i < len; ++i)
+            dest[i] = src[i];
    } else {
        len = 0;
    }
    
-    for (i = 0; i < len; ++i)
-        dest[i] = src[i];
    for (i = len; i < max; ++i) 
        dest[i] = ' ';
 }
@ -1601,7 +1611,7 @@ char *ucs2str(const char *buf, size_t len)

    n = iso_iconv(&conv, &src, &inbytes, &str, &outbytes, 0);
    iso_iconv_close(&conv, 0);
-    if (n == -1) {
+    if (n == (size_t) -1) {
        /* error */
        goto ex;
    }
@ -1838,12 +1848,12 @@ int iso_util_eval_md5_tag(char *block, int desired, uint32_t lba,
    *tag_type = 0;
    decode_ret = iso_util_decode_md5_tag(block, tag_type, &pos,
                                  &range_start, &range_size, next_tag, md5, 0);
-    if (decode_ret != 1 && decode_ret != ISO_MD5_AREA_CORRUPTED)
+    if (decode_ret != 1 && decode_ret != (int) ISO_MD5_AREA_CORRUPTED)
        return 0;
    if (*tag_type > 30)
        goto unexpected_type;

-    if (decode_ret == ISO_MD5_AREA_CORRUPTED) {
+    if (decode_ret == (int) ISO_MD5_AREA_CORRUPTED) {
        ret = decode_ret; 
        goto ex;
    } else if (!((1 << *tag_type) & desired)) {
@ -1886,4 +1896,14 @@ ex:;
    return ret;
 }

+
+void *iso_alloc_mem(size_t size, size_t count, int flag)
+{
+    void *pt;
+
+    pt = calloc(size, count);
+    if(pt == NULL)
+	iso_msg_submit(-1, ISO_OUT_OF_MEM, 0, "Out of virtual memory");
+    return pt;
+}
 
--- a/libisofs/util.h
+++ b/libisofs/util.h
@ -539,4 +539,24 @@ int checksum_md5_xinfo_cloner(void *old_data, void **new_data, int flag);
 /* ------------------------------------------------------------------------- */


+void *iso_alloc_mem(size_t size, size_t count, int flag);
+
+#define LIBISO_ALLOC_MEM(pt, typ, count) { \
+        pt= (typ *) iso_alloc_mem(sizeof(typ), (size_t) (count), 0); \
+        if(pt == NULL) { \
+                ret= ISO_OUT_OF_MEM; goto ex; \
+        } }
+
+#define LIBISO_ALLOC_MEM_VOID(pt, typ, count) { \
+        pt= (typ *) iso_alloc_mem(sizeof(typ), (size_t) (count), 0); \
+        if(pt == NULL) { \
+                goto ex; \
+        } }
+
+#define LIBISO_FREE_MEM(pt) { \
+        if(pt != NULL) \
+                free((char *) pt); \
+        }
+
+
 #endif /*LIBISO_UTIL_H_*/
--- a/libisofs/util_rbtree.c
+++ b/libisofs/util_rbtree.c
@ -164,7 +164,7 @@ int iso_rbtree_insert(IsoRBTree *tree, void *data, void **item)
        new = data;
        added = 1;
    } else {
-        struct iso_rbnode head = { 0 }; /* False tree root */
+        struct iso_rbnode head = { 0, {NULL, NULL}, 0 }; /* False tree root */

        struct iso_rbnode *g, *t; /* Grandparent & parent */
        struct iso_rbnode *p, *q; /* Iterator & parent */
Author	SHA1	Message	Date
Thomas Schmitt	286648574d	Version leap to 1.1.2	2011-07-08 10:28:12 +02:00
Thomas Schmitt	317bba395e	Updated changelog	2011-07-08 10:25:24 +02:00
Thomas Schmitt	541b41b6a1	Clarified a comment about retrieving content of boot catalog.	2011-07-07 14:11:30 +02:00
Thomas Schmitt	91a8be5262	Silenced a warning of cppcheck about possible null pointer dereference.	2011-07-06 12:31:37 +02:00
Thomas Schmitt	91e99703b4	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 18:54:11 +02:00
Thomas Schmitt	dd7dac3397	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 16:07:35 +02:00
Thomas Schmitt	43d4833dd6	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 16:06:16 +02:00
Thomas Schmitt	dd1629b5ca	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 16:04:05 +02:00
Thomas Schmitt	bc8138ce78	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 16:00:29 +02:00
Thomas Schmitt	2d568c1dbb	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 15:56:26 +02:00
Thomas Schmitt	842b62d111	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 15:50:52 +02:00
Thomas Schmitt	4f3357e3ec	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 15:39:38 +02:00
Thomas Schmitt	9ffe91c372	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 15:37:55 +02:00
Thomas Schmitt	7e2add413a	Reacted on warnings of -Wunused-but-set-variable	2011-07-04 15:35:43 +02:00
Thomas Schmitt	004aefd0b7	New API call iso_image_get_bootcat()	2011-07-03 21:02:19 +02:00
Thomas Schmitt	00955ba85c	Version leap to 1.1.1	2011-06-18 19:22:11 +02:00
Thomas Schmitt	4a79812d15	Version leap to 1.1.0	2011-06-18 14:23:02 +02:00
Thomas Schmitt	9b2f97e4b7	Updated changelog	2011-06-18 14:06:38 +02:00
Thomas Schmitt	35cfb756be	Bug fix: Padding as of iso_write_opts_set_tail_blocks() was added only after cylinder alignment as of iso_write_opts_set_system_area() and thus spoiled this alignment.	2011-06-15 17:09:48 +02:00
Thomas Schmitt	2835fccfa4	Replaced some large local variables by other means in libisofs/util.c	2011-06-12 12:46:52 +02:00
Thomas Schmitt	31c7f68990	Replaced some large local variables by other means in libisofs/system_area.c	2011-06-12 12:28:38 +02:00
Thomas Schmitt	4e0ca258de	Replaced some large local variables by other means in libisofs/stream.c	2011-06-12 09:59:53 +02:00
Thomas Schmitt	9653854462	Replaced some large local variables by other means in libisofs/rockridge.c	2011-06-12 09:51:08 +02:00
Thomas Schmitt	6e95f8bbcb	Replaced some large local variables by other means in libisofs/messages.c	2011-06-11 22:23:44 +02:00
Thomas Schmitt	ce3aa0d5c7	Replaced some large local variables by other means in libisofs/md5.c	2011-06-11 19:23:32 +02:00
Thomas Schmitt	d5bfc552c4	Replaced some large local variables by other means in libisofs/joliet.c	2011-06-11 16:33:57 +02:00
Thomas Schmitt	bad54a5967	Replaced some large local variables by other means in libisofs/iso1999.c	2011-06-11 13:42:55 +02:00
Thomas Schmitt	49b0a89bfe	Replaced some large local variables by other means in libisofs/fs_image.c	2011-06-11 12:40:33 +02:00
Thomas Schmitt	265df5fbe3	Replaced some large local variables by other means in libisofs/filesrc.c	2011-06-11 11:08:20 +02:00
Thomas Schmitt	f089bcf66a	Replaced some large local variables by other means in libisofs/ecma119.c	2011-06-10 14:55:57 +02:00
Thomas Schmitt	062e5f0bf0	Changed error code of libisofs/util.h from -1 to ISO_OUT_OF_MEM	2011-06-10 14:55:34 +02:00
Thomas Schmitt	d932bfcdea	Replaced some large local variables by other means in libisofs/builder.c	2011-06-09 16:51:00 +02:00
Thomas Schmitt	3ef67cb49d	Replaced some large local variables by other means in libisofs/aaip_0_2.c	2011-06-09 14:27:41 +02:00
Thomas Schmitt	f08ae22dbe	Macros LIBISO_ALLOC_MEM, LIBISO_FREE_MEM for replaceing local variables	2011-06-09 14:23:21 +02:00
Thomas Schmitt	45d316d1ca	Added option -I . to aclocal in bootstrap script on advise of George Danchev	2011-06-09 14:21:20 +02:00
Thomas Schmitt	4d8fc6ffee	Introduced AC_CONFIG_MACRO_DIR() and ACLOCAL_AMFLAGS on advise of George Danchev	2011-06-08 21:27:53 +02:00
Thomas Schmitt	023e413624	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for libisofs/aaip-os-freebsd.c	2011-06-02 10:28:52 +02:00
Thomas Schmitt	d361186bca	Made callers of iso_file_source_get_path() aware that NULL might be returned.	2011-06-01 11:37:30 +02:00
Thomas Schmitt	e7d9559d16	Avoiding to produce NM field for "." and ".." entries if Rock Ridge version 1.10 is chosen by iso_write_opts_set_rrip_version_1_10()	2011-06-01 11:34:45 +02:00
Thomas Schmitt	94eecbb123	Reacted on static code checker warning reported by George Danchev	2011-05-22 20:23:48 +02:00
Thomas Schmitt	777f74ea0b	Added options -Wextra -Wno-unused-parameter for gcc	2011-05-22 16:35:22 +02:00
Thomas Schmitt	2b8d47ddd8	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for util_rbtree.c	2011-05-21 23:21:14 +02:00
Thomas Schmitt	e839b7b368	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for util.c	2011-05-21 23:20:44 +02:00
Thomas Schmitt	1334027a83	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for tree.c	2011-05-21 23:19:34 +02:00
Thomas Schmitt	8d3a0a6a9e	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for system_area.c	2011-05-21 23:19:06 +02:00
Thomas Schmitt	7b7ea41f12	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for stream.c	2011-05-21 23:18:35 +02:00
Thomas Schmitt	bb5886094e	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for rockridge_read.c	2011-05-21 23:18:00 +02:00
Thomas Schmitt	b076ce9b44	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for rockridge.c	2011-05-21 23:17:38 +02:00
Thomas Schmitt	05f26898f3	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for node.c	2011-05-21 23:16:35 +02:00
Thomas Schmitt	a698f0ee22	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for messages.c	2011-05-21 23:16:10 +02:00
Thomas Schmitt	e69854b35f	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for md5.c	2011-05-21 23:15:48 +02:00
Thomas Schmitt	228995c148	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for make_isohybrid_mbr.c	2011-05-21 23:15:19 +02:00
Thomas Schmitt	071e14f9b0	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for joliet.c	2011-05-21 23:14:49 +02:00
Thomas Schmitt	b08d6271ab	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for iso1999.c	2011-05-21 23:14:16 +02:00
Thomas Schmitt	431d31fff6	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for fs_local.c	2011-05-21 23:13:40 +02:00
Thomas Schmitt	a37571c6c5	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for fs_image.c	2011-05-21 23:13:16 +02:00
Thomas Schmitt	6e98006640	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for filters/zisofs.c	2011-05-21 23:12:29 +02:00
Thomas Schmitt	d264e818c3	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for filters/gzip.c	2011-05-21 23:11:48 +02:00
Thomas Schmitt	d0f740facf	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for eltorito.c	2011-05-21 23:11:18 +02:00
Thomas Schmitt	944b5a6152	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for ecma119_tree.c	2011-05-21 23:10:21 +02:00
Thomas Schmitt	b51232fef4	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for ecma119.c	2011-05-21 23:09:44 +02:00
Thomas Schmitt	99f037e210	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for buffer.c	2011-05-21 23:08:53 +02:00
Thomas Schmitt	c794a48a06	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for aaip_0_2.c	2011-05-21 23:08:14 +02:00
Thomas Schmitt	47d599e8c3	Reacted on -Wextra -Wno-unused-parameter warnings of gcc for aaip-os-linux.c	2011-05-21 23:05:17 +02:00
Thomas Schmitt	0a87e838df	Mentioned the need to define uint32_t when including libisofs.h	2011-05-19 15:43:44 +02:00
Thomas Schmitt	e945e38add	Mentioned upcomming version in ChangeLog	2011-05-13 09:01:01 +02:00
Thomas Schmitt	6d68abc707	Version leap to 1.0.9	2011-05-12 18:59:38 +02:00