Version leap to 1.1.2

after cylinder alignment as of iso_write_opts_set_system_area()
         and thus spoiled this alignment.

ChangeLog

@@ -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

Makefile.am

@@ -6,6 +6,7 @@ pkgconfigdir=$(LIBBURNIA_PKGCONFDIR)
 libincludedir=$(includedir)/libisofs
 
 lib_LTLIBRARIES = libisofs/libisofs.la
+ACLOCAL_AMFLAGS = -I ./
 
 ## ========================================================================= ##
 

bootstrap

@@ -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

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_MINOR_VERSION=1
-LIBISOFS_MICRO_VERSION=8
+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
+# 2011.07.08  development jump has not yet happened
-# SONAME = 52 - 46 = 6 . Library name = libisofs.6.46.0
+# SONAME = 56 - 50 = 6 . Library name = libisofs.6.50.0
-LT_CURRENT=52
+LT_CURRENT=56
-LT_AGE=46
+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

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);
    }

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;

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)
+     if((size_t) count >= result_size)
-       return(-1);
+       {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)
+     if((size_t) count >= result_size)
-       return(-1);
+       {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)
+       if((size_t) (count + 1) > result_size)
-         return(-1);
+         {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)
+         if((size_t) (count + (result[count - 1] & 127)) > result_size)
-           return(-1);
+           {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)
+     if((size_t) (count + needed) > result_size)
-       return(-1);
+       {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];
+ char perm_text[4], *wpt, *name= NULL;
- int type, qualifier= 0, perm, ret, i, cnt;
+ int type, qualifier= 0, perm, ret, cnt, name_size= 1024;
- size_t w_size, name_fill= 0;
+ 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);
 }
 

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;

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];
+            LIBISO_ALLOC_MEM(dest, char, LIBISOFS_NODE_PATH_MAX);
-            IsoSymlink *link;
-
             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

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 */
+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
-    memset(buffer, 0, 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 */
     }
-
+    ret = ISO_SUCCESS;
-    return 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;
+        {ret = ISO_SUCCESS; goto ex;}
-    memset(pad, 0, BLOCK_SIZE);
+    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;
+    int ret;
-    uint8_t buf[BLOCK_SIZE];
+    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);
+    ret = iso_write(target, buf, BLOCK_SIZE);
-    return res;
+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;
+    int ret, i;
-    uint8_t buf[BLOCK_SIZE];
+    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);
+    LIBISO_ALLOC_MEM(buf, uint8_t, BLOCK_SIZE);
-    for(; *write_count < target->partition_offset + 16; (*write_count)++) {
+    for(; *write_count < (int) target->partition_offset + 16;
-        res = iso_write(target, buf, BLOCK_SIZE);
+        (*write_count)++) {
-        if (res < 0)
+        ret = iso_write(target, buf, BLOCK_SIZE);
-            goto write_error;
+        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);
+        ret = writer->write_vol_desc(writer);
-        if (res < 0)
+        if (ret < 0)
-            goto write_error;
+            goto ex;
         (*write_count)++;
     }
-    res = write_vol_desc_terminator(target);
+    ret = write_vol_desc_terminator(target);
-    if (res < 0)
+    if (ret < 0)
-        goto write_error;
+        goto ex;
     (*write_count)++;
     target->eff_partition_offset = 0;
 
     /* >>> TWINTREE: Postponed for now:
                      Write second superblock checksum tag */;
 
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
-write_error:;
+ex:;
-    return res;
+    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 */

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 */

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) {
+        if (ret != (int) size) {
-            return (ret < 0) ? ret : ISO_FILE_READ_ERROR;
+            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));

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 */

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 *name = NULL;
-    char buffer[BLOCK_SIZE];
+    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;
 }
 

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;

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) {

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 &&
+                    if (ret < 0 && ret != (int) ISO_UNSUPPORTED_EL_TORITO &&
-                        ret != ISO_WRONG_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;
 

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);

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 */
+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
-    memset(buffer, 0, 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;
 }
 

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;
 }
 

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
+ * The minimum requirement is to interface with the library by 64 bit signed
- * where this .h files prescribe off_t. Not to use 64 bit file i/o will keep
+ * integers where libisofs.h or libisoburn.h prescribe off_t.
- * the application from producing and processing ISO images of more than 2 GB
+ * Failure to do so may result in surprising malfunction or memory faults.
- * size.
  * 
+ * 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_minor  1
-#define iso_lib_header_version_micro  8
+#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.
  *

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;

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;

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;
+    int record_len, block_len, ret, i;
-    char postext[40], md5[16], record[160];
+    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);
+    ret = iso_md5_clone(t->checksum_ctx, &ctx);
-    if (res < 0)
+    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);
+    ret = iso_md5_start(&ctx);
-    if (res < 0)
+    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;
+        {ret = ISO_WRONG_ARG_VALUE; goto ex;}
-    res = iso_md5_clone(t->checksum_ctx, &ctx);
+    ret = iso_md5_clone(t->checksum_ctx, &ctx);
-    if (res < 0)
+    if (ret < 0)
-        return res;
+        goto ex;
-    res = iso_md5_end(&ctx, md5);
+    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);
+    ret = iso_md5_start(&ctx);
-    if (res > 0) {
+    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);
+            ret = iso_md5_write_scdbackup_tag(t, tag_block, 0);
-            if (res < 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;
 }
 
 

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;
     }
 

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) */

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;
+                        ssize_t fit = 255 - sl_len - 2;
-                        if (clen - 250 <= fit) {
+                        if ((ssize_t) (clen - 250) <= fit) {
                             /* 
                              * the component can be divided between this
                              * and another SL entry
@@ -1257,6 +1257,7 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t used_up,
 
         /* "." or ".." entry */
 
+        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;
+                            ssize_t fit = 255 - sl_len - 2;
-                            if (clen - 250 <= fit) {
+                            if ((ssize_t) (clen - 250) <= fit) {
                                 /* 
                                  * the component can be divided between this
                                  * and another SL entry
@@ -1711,8 +1714,35 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
         /* "." or ".." entry */
 
         /* write the NM entry */
+        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) {
+            if (ret < 0)
                 goto add_susp_cleanup;
         }
 
@@ -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;
 }
 

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;
+            uint32_t block, nblocks;
-            int nblocks;
 
             /* A CE has found, there is another continuation area */
             nblocks = DIV_UP(iter->ce_off + iter->ce_len, BLOCK_SIZE);

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;
+    int ret, is_open = 0;
-    char buffer[2048];
+    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;
+        {ret = 0; goto ex;}
-    res = iso_md5_start(&ctx);
+    ret = iso_md5_start(&ctx);
-    if (res < 0)
+    if (ret < 0)
-        return res;
+        goto ex;
-    res = iso_stream_open(stream);
+    ret = iso_stream_open(stream);
-    if (res < 0)
+    if (ret < 0)
-        return 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);
+        ret = iso_stream_read_buffer(stream, buffer, 2048, &got_bytes);
-        if (res < 0) {
+        if (ret < 0) {
-            res = 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;
+            ret = file_size - b * 2048;
-        iso_md5_compute(ctx, buffer, res);
+        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 */

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;
 }

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 */
+	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 {

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)) {
@@ -1887,3 +1897,13 @@ ex:;
 }
 
 
+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;
+}
+ 

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_*/

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 */