Version leap to 1.1.0

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

COPYRIGHT

@@ -1,7 +1,7 @@
 Vreixo Formoso <metalpain2002@yahoo.es>,
 Mario Danic <mario.danic@gmail.com>, 
 Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2007-2010 Vreixo Formoso, Mario Danic, Thomas Schmitt
+Copyright (C) 2007-2011 Vreixo Formoso, Mario Danic, Thomas Schmitt
 
 
     This program is free software; you can redistribute it and/or modify

ChangeLog

@@ -1,8 +1,34 @@
-bzr branch lp:libisofs/for-libisoburn (to become libisofs-1.0.2.tar.gz)
-===============================================================================
-- no novelties yet
 
-libisofs-1.0.2.tar.gz Tue Wed 23 2011
+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
+           1=MIPS Big Endian and 2=MIPS Little Endian caused SIGSEGV.
+* Bug fix: SIGSEGV if the path given by iso_image_add_mips_boot_file()
+           does not exist in the image at image production time.
+* Bug fix: While loading an ISO image: Several reads to malloc
+           memory occured with byte index -1. (Found by Valgrind after
+           years of operation without visible problems.)
+* Bug fix: Closed a memory leak of 32 kB per loaded ISO image.
+
+libisofs-1.0.6.tar.gz Sat Apr 09 2011
+===============================================================================
+* New API call iso_write_opts_set_joliet_long_names()
+* New error codes for oversized file addresses
+
+libisofs-1.0.4.tar.gz Thu Mar 10 2011
+===============================================================================
+* Bug fix: Compilation failed if --disable-zlib was configured
+* Bug fix: isohybrid image size was not aligned to cylinder boundary.
+* New no_md5 value 2 for API call iso_read_opts_set_no_md5()
+* New option bits 8 and 9 with iso_write_opts_set_system_area()
+
+libisofs-1.0.2.tar.gz Tue Feb 23 2011
 ===============================================================================
 * Bug fix: iso_write_opts_set_aaip(opts, 1) could cause fatal miscalculation
            of the root directory size. This eventually truncated directory

Makefile.am

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

README

@@ -54,6 +54,7 @@ applications which use it. This dependency can be avoided by configure options
     --disable-libacl   avoid use of ACL functions like acl_to_text()
     --disable-xattr    avoid use of xattr functions like listxattr()
     --disable-zlib     avoid use of zlib functions like compress2()
+    --disable-libjte   avoid use of libjte functions
 
 See INSTALL file for general options of ./configure.
 

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.2], [http://libburnia-project.org])
+AC_INIT([libisofs], [1.1.0], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	
 
@@ -8,6 +8,7 @@ AC_CANONICAL_TARGET
 LIBBURNIA_SET_FLAGS
 
 AM_INIT_AUTOMAKE([subdir-objects])
+AC_CONFIG_MACRO_DIR([./])
 
 dnl
 dnl if MAJOR or MINOR version changes, be sure to change AC_INIT above to match
@@ -39,8 +40,8 @@ dnl
 dnl If LIBISOFS_*_VERSION changes, be sure to change AC_INIT above to match.
 dnl
 LIBISOFS_MAJOR_VERSION=1
-LIBISOFS_MINOR_VERSION=0
-LIBISOFS_MICRO_VERSION=2
+LIBISOFS_MINOR_VERSION=1
+LIBISOFS_MICRO_VERSION=0
 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.02.23  development jump has not yet happened
-# SONAME = 46 - 40 = 6 . Library name = libisofs.6.40.0
-LT_CURRENT=46
-LT_AGE=40
+# 2011.06.18  development jump has not yet happened
+# SONAME = 54 - 48 = 6 . Library name = libisofs.6.48.0
+LT_CURRENT=54
+LT_AGE=48
 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

demo/demo.c

@@ -50,6 +50,7 @@ static char helptext[][80] = {
 #include <fcntl.h>
 #include <err.h>
 #include <limits.h>
+#include <errno.h>
 
 
 #ifndef PATH_MAX
@@ -372,7 +373,11 @@ int gesture_iso(int argc, char **argv)
     iso_write_opts_free(opts);
 
     while (burn_src->read_xt(burn_src, buf, 2048) == 2048) {
-        fwrite(buf, 1, 2048, fp);
+        result = fwrite(buf, 1, 2048, fp);
+        if (result < 2048) {
+            printf ("Cannot write block. errno= %d\n", errno);
+            goto ex;
+        }
     }
     fclose(fp);
     burn_src->free_data(burn_src);
@@ -537,7 +542,7 @@ int gesture_iso_read(int argc, char **argv)
 
 int gesture_iso_cat(int argc, char **argv)
 {
-    int res;
+    int res, write_ret;
     IsoFilesystem *fs;
     IsoFileSource *file;
     struct stat info;
@@ -596,7 +601,11 @@ int gesture_iso_cat(int argc, char **argv)
             return 1;
         }
         while ((res = iso_file_source_read(file, buf, 1024)) > 0) {
-            fwrite(buf, 1, res, stdout);
+            write_ret = fwrite(buf, 1, res, stdout);
+            if (write_ret < res) {
+                printf ("Cannot write block to stdout. errno= %d\n", errno);
+                return 1;
+            }
         }
         if (res < 0) {
             fprintf(stderr, "Error reading, err = %d\n", res);
@@ -700,7 +709,11 @@ int gesture_iso_modify(int argc, char **argv)
     iso_write_opts_free(opts);
     
     while (burn_src->read_xt(burn_src, buf, 2048) == 2048) {
-        fwrite(buf, 1, 2048, fp);
+        result = fwrite(buf, 1, 2048, fp);
+        if (result < 2048) {
+            printf ("Cannot write block. errno= %d\n", errno);
+            goto ex;
+        }
     }
     fclose(fp);
     burn_src->free_data(burn_src);
@@ -814,7 +827,11 @@ int gesture_iso_ms(int argc, char **argv)
     iso_write_opts_free(opts);
     
     while (burn_src->read_xt(burn_src, buf, 2048) == 2048) {
-        fwrite(buf, 1, 2048, fp);
+        result = fwrite(buf, 1, 2048, fp);
+        if (result < 2048) {
+            printf ("Cannot write block. errno= %d\n", errno);
+            goto ex;
+        }
     }
     fclose(fp);
     burn_src->free_data(burn_src);

doc/doxygen.conf.in

@@ -1143,7 +1143,8 @@ HIDE_UNDOC_RELATIONS   = YES
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section 
 # have no effect if this option is set to NO (the default)
 
-HAVE_DOT               = YES
+# ts B10415: dot causes sigsegv on Debian buildd
+HAVE_DOT               = NO
 
 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
 # will generate a graph for each documented class showing the direct and 

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);
    }
@@ -401,7 +401,7 @@ int aaip_set_attr_list(char *path, size_t num_attrs, char **names,
  size_t i, consumed, acl_text_fill, acl_idx= 0, h_consumed;
  char *acl_text= NULL, *list= NULL;
 #ifdef Libisofs_with_aaip_xattR
- size_t list_size= 0;
+ ssize_t list_size= 0;
 #endif
 
 #ifdef Libisofs_with_aaip_xattR
@@ -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
@@ -187,7 +188,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 +199,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 +293,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 +347,23 @@ static ssize_t aaip_encode_acl_text(char *acl_text, mode_t st_mode,
                            size_t result_size, unsigned char *result, int flag)
 {
  char *rpt, *npt, *cpt;
- int qualifier= 0, perms, type, i, qualifier_len= 0, num_recs, needed= 0;
+ int qualifier= 0, perms, type, i, qualifier_len= 0, num_recs, needed= 0, ret;
  unsigned int has_u= 0, has_g= 0, has_o= 0, has_m= 0, is_trivial= 1;
  uid_t uid, huid;
  gid_t gid, hgid;
  ssize_t count= 0;
  struct passwd *pwd;
  struct group *grp;
- char name[1024];
+ char *name = NULL;
+ int name_size= 1024;
  double num;
 
+ LIBISO_ALLOC_MEM(name, char, name_size);
  if(flag & 4) {
    /* set SWITCH_MARK to indicate a default ACL */;
    if(!(flag & 1)) {
-     if(count >= result_size)
-       return(-1);
+     if((size_t) count >= result_size)
+       {ret= -1; goto ex;}
      result[count]= (Aaip_SWITCH_MARK << 4) | Aaip_EXEC;
    }
    count++;
@@ -386,7 +389,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 +422,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 +464,8 @@ group_by_name:;
    perms= aaip_make_aaip_perms(cpt[1] == 'r', cpt[2] == 'w', cpt[3] == 'x');
 
    if(!(flag & 1)) {
-     if(count >= result_size)
-       return(-1);
+     if((size_t) count >= result_size)
+       {ret= -1; goto ex;}
      result[count]= perms | ((!!qualifier) << 3) | (type << 4);
    }
    count++;
@@ -470,8 +473,8 @@ group_by_name:;
    if(qualifier) {
      num_recs= (qualifier_len / 127) + !!(qualifier_len % 127);
      if(!(flag & 1)) {
-       if(count + 1 > result_size)
-         return(-1);
+       if((size_t) (count + 1) > result_size)
+         {ret= -1; goto ex;}
        for(i= 0; i < num_recs; i++) {
          if(i < num_recs - 1)
            result[count++]= 255;
@@ -480,8 +483,8 @@ group_by_name:;
            if(result[count - 1] == 0)
              result[count - 1]= 127;
          }
-         if(count + (result[count - 1] & 127) > result_size)
-           return(-1);
+         if((size_t) (count + (result[count - 1] & 127)) > result_size)
+           {ret= -1; goto ex;}
          memcpy(result + count, name + i * 127, result[count - 1] & 127);
          count+= result[count - 1] & 127;
        }
@@ -495,8 +498,8 @@ group_by_name:;
    if(flag & 1)
      count+= needed;
    else {
-     if(count + needed > result_size)
-       return(-1);
+     if((size_t) (count + needed) > result_size)
+       {ret= -1; goto ex;}
    }
  }
  if ((flag & 8) && needed > 0 && !(flag & 1)) {
@@ -521,7 +524,10 @@ group_by_name:;
      result[count++]= perms | (Aaip_ACL_MASK << 4);
    }
  }
- return(count);
+ ret= count;
+ex:;
+ LIBISO_FREE_MEM(name);
+ return(ret);
 }
 
 
@@ -1120,9 +1126,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 +1150,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 +1184,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 +1231,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;
@@ -1968,14 +1974,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 +2021,21 @@ int aaip_decode_acl(unsigned char *data, size_t num_data, size_t *consumed,
                     size_t *acl_text_fill, int flag)
 {
  unsigned char *rpt;
- char perm_text[4], *wpt, name[1024];
- int type, qualifier= 0, perm, ret, i, cnt;
- size_t w_size, name_fill= 0;
+ char perm_text[4], *wpt, *name= NULL;
+ int type, qualifier= 0, perm, ret, cnt, name_size= 1024;
+ size_t w_size, name_fill= 0, i;
  uid_t uid;
  gid_t gid;
  struct passwd *pwd;
  struct group *grp;
 
+ LIBISO_ALLOC_MEM(name, char, name_size);
  cnt= flag & 1;
  *consumed= 0;
  wpt= acl_text;
  w_size= acl_text_size;
  *acl_text_fill= 0;
- for(rpt= data; rpt - data < num_data; ) {
+ for(rpt= data; (size_t) (rpt - data) < num_data; ) {
    perm= *rpt;
    strcpy(perm_text, "---");
    if(perm & Aaip_READ)
@@ -2038,14 +2047,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 +2095,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 +2109,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 +2117,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,16 +20,13 @@
 #include "fsource.h"
 #include "image.h"
 #include "aaip_0_2.h"
+#include "util.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
 #include <stdio.h>
 
-#ifndef PATH_MAX
-#define PATH_MAX Libisofs_default_path_maX
-#endif
-
 
 
 void iso_node_builder_ref(IsoNodeBuilder *builder)
@@ -75,6 +72,8 @@ int default_create_file(IsoNodeBuilder *builder, IsoImage *image,
     iso_file_source_ref(src);
     
     name = iso_file_source_get_name(src);
+    if (strlen(name) > LIBISOFS_NODE_NAME_MAX)
+        name[LIBISOFS_NODE_NAME_MAX] = 0;
     ret = iso_node_new_file(name, stream, &node);
     if (ret < 0) {
         iso_stream_unref(stream);
@@ -106,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 */
@@ -118,10 +119,12 @@ 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);
+    if (strlen(name) > LIBISOFS_NODE_NAME_MAX)
+        name[LIBISOFS_NODE_NAME_MAX] = 0;
     fs = iso_file_source_get_filesystem(src);
     new = NULL;
 
@@ -157,10 +160,8 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
     case S_IFLNK:
         {
             /* source is a symbolic link */
-            char dest[PATH_MAX];
-            IsoSymlink *link;
-
-            ret = iso_file_source_readlink(src, dest, PATH_MAX);
+            LIBISO_ALLOC_MEM(dest, char, LIBISOFS_NODE_PATH_MAX);
+            ret = iso_file_source_readlink(src, dest, LIBISOFS_NODE_PATH_MAX);
             if (ret < 0) {
                 break;
             }
@@ -198,7 +199,7 @@ int default_create_node(IsoNodeBuilder *builder, IsoImage *image,
     
     if (ret < 0) {
         free(name);
-        return ret;
+        goto ex;
     }
 
     /* fill fields */
@@ -233,19 +234,25 @@ 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
 void default_free(IsoNodeBuilder *builder)
 {
+    /* The .free() method of IsoNodeBuilder shall free private data but not
+       the builder itself. The latter is done in iso_node_builder_unref().
+    */
     return;
 }
 

libisofs/ecma119.c

@@ -576,16 +576,16 @@ static
 int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
 {
     int ret;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;
     size_t i;
     size_t fi_len, len;
     struct susp_info info;
 
     /* buf will point to current write position on buffer */
-    uint8_t *buf = buffer;
+    uint8_t *buf;
 
-    /* initialize buffer with 0s */
-    memset(buffer, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
+    buf = buffer;
 
     /*
      * set susp_info to 0's, this way code for both plain ECMA-119 and
@@ -602,7 +602,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
     if (t->rockridge) {
         ret = rrip_get_susp_fields(t, dir, 1, 34, &info);
         if (ret < 0) {
-            return ret;
+            goto ex;
         }
     }
     len = 34 + info.suf_len;
@@ -612,7 +612,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
     if (t->rockridge) {
         ret = rrip_get_susp_fields(t, dir, 2, 34, &info);
         if (ret < 0) {
-            return ret;
+            goto ex;
         }
     }
     len = 34 + info.suf_len;
@@ -638,7 +638,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
             if (t->rockridge) {
                 ret = rrip_get_susp_fields(t, child, 0, len, &info);
                 if (ret < 0) {
-                    return ret;
+                    goto ex;
                 }
                 len += info.suf_len;
             }
@@ -647,7 +647,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
                 /* dir doesn't fit in current block */
                 ret = iso_write(t, buffer, BLOCK_SIZE);
                 if (ret < 0) {
-                    return ret;
+                    goto ex;
                 }
                 memset(buffer, 0, BLOCK_SIZE);
                 buf = buffer;
@@ -661,7 +661,7 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
     /* write the last block */
     ret = iso_write(t, buffer, BLOCK_SIZE);
     if (ret < 0) {
-        return ret;
+        goto ex;
     }
 
     /* write the Continuation Area if needed */
@@ -669,6 +669,8 @@ int write_one_dir(Ecma119Image *t, Ecma119Node *dir, Ecma119Node *parent)
         ret = rrip_write_ce_fields(t, &info);
     }
 
+ex:;
+    LIBISO_FREE_MEM(buffer);
     return ret;
 }
 
@@ -708,6 +710,7 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
     uint32_t path_table_size;
     int parent = 0;
     int ret= ISO_SUCCESS;
+    uint8_t *zeros = NULL;
 
     path_table_size = 0;
     write_int = l_type ? iso_lsb : iso_msb;
@@ -735,7 +738,7 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
         ret = iso_write(t, buf, len);
         if (ret < 0) {
             /* error */
-            return ret;
+            goto ex;
         }
         path_table_size += len;
     }
@@ -743,11 +746,12 @@ int write_path_table(Ecma119Image *t, Ecma119Node **pathlist, int l_type)
     /* we need to fill the last block with zeros */
     path_table_size %= BLOCK_SIZE;
     if (path_table_size) {
-        uint8_t zeros[BLOCK_SIZE];
         len = BLOCK_SIZE - path_table_size;
-        memset(zeros, 0, len);
+        LIBISO_ALLOC_MEM(zeros, uint8_t, len);
         ret = iso_write(t, zeros, len);
     }
+ex:;
+    LIBISO_FREE_MEM(zeros);
     return ret;
 }
 
@@ -878,28 +882,28 @@ int ecma119_writer_write_data(IsoImageWriter *writer)
     int ret;
     Ecma119Image *t;
     uint32_t curblock;
+    char *msg = NULL;
+
+    if (writer == NULL)
+        {ret = ISO_ASSERT_FAILURE; goto ex;}
 
-    if (writer == NULL) {
-        return ISO_ASSERT_FAILURE;
-    }
     t = writer->target;
 
     ret = ecma119_writer_write_dirs(writer);
     if (ret < 0)
-        return ret;
+        goto ex;
 
     if (t->partition_offset > 0) {
         t->eff_partition_offset = t->partition_offset;
         ret = ecma119_writer_write_dirs(writer);
         t->eff_partition_offset = 0;
         if (ret < 0) 
-            return ret;
+            goto ex;
     }
 
     curblock = (t->bytes_written / 2048) + t->ms_block;
     if (curblock != t->tree_end_block) {
-        char msg[100];
-
+        LIBISO_ALLOC_MEM(msg, char, 100);
         sprintf(msg,
                 "Calculated and written ECMA-119 tree end differ: %lu <> %lu",
                 (unsigned long) t->tree_end_block,
@@ -908,8 +912,10 @@ int ecma119_writer_write_data(IsoImageWriter *writer)
 
         t->tree_end_block = 1;/* Mark for harsher reaction at end of writing */
     }
-
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(msg);
+    return ret;
 }
 
 static
@@ -990,27 +996,30 @@ int mspad_writer_write_data(IsoImageWriter *writer)
 {
     int ret;
     Ecma119Image *t;
-    uint8_t pad[BLOCK_SIZE];
+    uint8_t *pad = NULL;
     size_t i;
 
     if (writer == NULL) {
-        return ISO_ASSERT_FAILURE;
+        {ret = ISO_ASSERT_FAILURE; goto ex;}
     }
     t = writer->target;
 
     if (t->mspad_blocks == 0) {
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
     }
 
-    memset(pad, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(pad, uint8_t, BLOCK_SIZE);
     for (i = 0; i < t->mspad_blocks; ++i) {
         ret = iso_write(t, pad, BLOCK_SIZE);
         if (ret < 0) {
-            return ret;
+            goto ex;
         }
     }
 
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(pad);
+    return ret;
 }
 
 static
@@ -1076,23 +1085,26 @@ int zero_writer_write_data(IsoImageWriter *writer)
     int ret;
     Ecma119Image *t;
     struct iso_zero_writer_data_struct *data;
-    uint8_t pad[BLOCK_SIZE];
+    uint8_t *pad = NULL;
     size_t i;
 
     if (writer == NULL)
-        return ISO_ASSERT_FAILURE;
+        {ret = ISO_ASSERT_FAILURE; goto ex;}
     t = writer->target;
     data = (struct iso_zero_writer_data_struct *) writer->data;
 
     if (data->num_blocks == 0) 
-        return ISO_SUCCESS;
-    memset(pad, 0, BLOCK_SIZE);
+        {ret = ISO_SUCCESS; goto ex;}
+    LIBISO_ALLOC_MEM(pad, uint8_t, BLOCK_SIZE);
     for (i = 0; i < data->num_blocks; ++i) {
         ret = iso_write(t, pad, BLOCK_SIZE);
         if (ret < 0) 
-            return ret;
+            goto ex;
     }
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(pad);
+    return ret;
 }
 
 static
@@ -1108,7 +1120,36 @@ int zero_writer_free_data(IsoImageWriter *writer)
 }
 
 static
-int zero_writer_create(Ecma119Image *target, uint32_t num_blocks)
+int tail_writer_compute_data_blocks(IsoImageWriter *writer)
+{
+    int ret;
+    Ecma119Image *target;
+    struct iso_zero_writer_data_struct *data;
+    char msg[80];
+
+    target = writer->target;
+    ret = iso_align_isohybrid(target, 0);
+    if (ret < 0)
+        return ret;
+    data = (struct iso_zero_writer_data_struct *) writer->data;
+    if (data->num_blocks != target->tail_blocks) {
+        sprintf(msg, "Aligned image size to cylinder size by %d blocks",
+                     target->tail_blocks - data->num_blocks);
+        iso_msgs_submit(0, msg, 0, "NOTE", 0);
+        data->num_blocks = target->tail_blocks;
+    }
+    if (target->tail_blocks <= 0)
+        return ISO_SUCCESS;
+    ret = zero_writer_compute_data_blocks(writer);
+    return ret;
+}
+
+/*
+  @param flag bit0= use tail_writer_compute_data_blocks rather than
+                    zero_writer_compute_data_blocks
+*/
+static
+int zero_writer_create(Ecma119Image *target, uint32_t num_blocks, int flag)
 {
     IsoImageWriter *writer;
     struct iso_zero_writer_data_struct *data;
@@ -1124,7 +1165,11 @@ int zero_writer_create(Ecma119Image *target, uint32_t num_blocks)
     }
     data->num_blocks = num_blocks;
 
-    writer->compute_data_blocks = zero_writer_compute_data_blocks;
+    if (flag & 1) {
+        writer->compute_data_blocks = tail_writer_compute_data_blocks;
+    } else {
+        writer->compute_data_blocks = zero_writer_compute_data_blocks;
+    }
     writer->write_vol_desc = zero_writer_write_vol_desc;
     writer->write_data = zero_writer_write_data;
     writer->free_data = zero_writer_free_data;
@@ -1152,11 +1197,11 @@ int transplant_checksum_buffer(Ecma119Image *target, int flag)
 static
 int write_vol_desc_terminator(Ecma119Image *target)
 {
-    int res;
-    uint8_t buf[BLOCK_SIZE];
+    int ret;
+    uint8_t *buf = NULL;
     struct ecma119_vol_desc_terminator *vol;
 
-    memset(buf, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buf, uint8_t, BLOCK_SIZE);
 
     vol = (struct ecma119_vol_desc_terminator *) buf;
 
@@ -1164,8 +1209,10 @@ int write_vol_desc_terminator(Ecma119Image *target)
     memcpy(vol->std_identifier, "CD001", 5);
     vol->vol_desc_version[0] = 1;
 
-    res = iso_write(target, buf, BLOCK_SIZE);
-    return res;
+    ret = iso_write(target, buf, BLOCK_SIZE);
+ex:
+    LIBISO_FREE_MEM(buf);
+    return ret;
 }
 
 
@@ -1196,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) 
@@ -1224,26 +1271,27 @@ write_error:;
 static
 int write_head_part2(Ecma119Image *target, int *write_count, int flag)
 {
-    int res, i;
-    uint8_t buf[BLOCK_SIZE];
+    int ret, i;
+    uint8_t *buf = NULL;
     IsoImageWriter *writer;
 
     if (target->partition_offset <= 0)
-        return ISO_SUCCESS;
+        {ret = ISO_SUCCESS; goto ex;}
 
     /* Write multi-session padding up to target->partition_offset + 16 */
-    memset(buf, 0, BLOCK_SIZE);
-    for(; *write_count < target->partition_offset + 16; (*write_count)++) {
-        res = iso_write(target, buf, BLOCK_SIZE);
-        if (res < 0)
-            goto write_error;
+    LIBISO_ALLOC_MEM(buf, uint8_t, BLOCK_SIZE);
+    for(; *write_count < (int) target->partition_offset + 16;
+        (*write_count)++) {
+        ret = iso_write(target, buf, BLOCK_SIZE);
+        if (ret < 0)
+            goto ex;
     }
 
     /* Write volume descriptors subtracting
       target->partiton_offset from any LBA pointer.
     */
     target->eff_partition_offset = target->partition_offset;
-    for (i = 0; i < target->nwriters; ++i) {
+    for (i = 0; i < (int) target->nwriters; ++i) {
         writer = target->writers[i];
         /* Not all writers have an entry in the partion volume descriptor set.
            It must be guaranteed that they write exactly one block.
@@ -1254,23 +1302,23 @@ int write_head_part2(Ecma119Image *target, int *write_count, int flag)
         if(writer->write_vol_desc != ecma119_writer_write_vol_desc &&
            writer->write_vol_desc != joliet_writer_write_vol_desc)
     continue;
-        res = writer->write_vol_desc(writer);
-        if (res < 0)
-            goto write_error;
+        ret = writer->write_vol_desc(writer);
+        if (ret < 0)
+            goto ex;
         (*write_count)++;
     }
-    res = write_vol_desc_terminator(target);
-    if (res < 0)
-        goto write_error;
+    ret = write_vol_desc_terminator(target);
+    if (ret < 0)
+        goto ex;
     (*write_count)++;
     target->eff_partition_offset = 0;
 
     /* >>> TWINTREE: Postponed for now:
                      Write second superblock checksum tag */;
 
-    return ISO_SUCCESS;
-write_error:;
-    return res;
+    ret = ISO_SUCCESS;
+ex:;
+    return ret;
 }
 
 static
@@ -1326,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);
@@ -1352,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;
 }
 
 
@@ -1365,7 +1416,7 @@ static
 void *write_function(void *arg)
 {
     int res, first_partition = 1, last_partition = 0, sa_type;
-    size_t i;
+    int i;
     IsoImageWriter *writer;
 
     Ecma119Image *target = (Ecma119Image*)arg;
@@ -1379,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) {
@@ -1426,7 +1477,7 @@ void *write_function(void *arg)
     if (target->tree_end_block == 1) {
         iso_msgs_submit(0,
     "Image is most likely damaged. Calculated/written block address mismatch.",
-                        0, "WARNING", 0);
+                        0, "FATAL", 0);
     }
 
 #ifdef Libisofs_with_pthread_exiT
@@ -1436,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,
@@ -1617,6 +1668,7 @@ int ecma119_image_new(IsoImage *src, IsoWriteOpts *opts, Ecma119Image **img)
     target->allow_full_ascii = opts->allow_full_ascii;
     target->relaxed_vol_atts = opts->relaxed_vol_atts;
     target->joliet_longer_paths = opts->joliet_longer_paths;
+    target->joliet_long_names = opts->joliet_long_names;
     target->rrip_version_1_10 = opts->rrip_version_1_10;
     target->rrip_1_10_px_ino = opts->rrip_1_10_px_ino;
     target->aaip_susp_1_10 = opts->aaip_susp_1_10;
@@ -1666,7 +1718,7 @@ int ecma119_image_new(IsoImage *src, IsoWriteOpts *opts, Ecma119Image **img)
         system_area = src->system_area_data;
         system_area_options = src->system_area_options;
     } else {
-        system_area_options = opts->system_area_options & 0xfc;
+        system_area_options = opts->system_area_options & 0xfffffffc;
     }
     sa_type = (system_area_options >> 2) & 0x3f;
     if (sa_type != 0 && sa_type != 3)
@@ -1695,9 +1747,9 @@ int ecma119_image_new(IsoImage *src, IsoWriteOpts *opts, Ecma119Image **img)
     target->partition_secs_per_head = opts->partition_secs_per_head;
     target->partition_heads_per_cyl = opts->partition_heads_per_cyl;
     if (target->partition_secs_per_head == 0)
-        target->partition_secs_per_head = 63;
+        target->partition_secs_per_head = 32;
     if (target->partition_heads_per_cyl == 0)
-        target->partition_heads_per_cyl = 255;
+        target->partition_heads_per_cyl = 64;
     target->eff_partition_offset = 0;
     target->partition_root = NULL;
     target->partition_l_table_pos = 0;
@@ -1810,8 +1862,7 @@ int ecma119_image_new(IsoImage *src, IsoWriteOpts *opts, Ecma119Image **img)
     if (target->iso1999) {
         nwriters++;
     }
-    if (target->tail_blocks > 0) 
-        nwriters++;
+    nwriters++; /* Tail padding writer */
     if ((target->md5_file_checksums & 1) || target->md5_session_checksum) {
         nwriters++;
         image_checksums_mad = 1; /* from here on the loaded checksums are
@@ -1893,11 +1944,9 @@ int ecma119_image_new(IsoImage *src, IsoWriteOpts *opts, Ecma119Image **img)
 
 
     /* IMPORTANT: This must be the last writer before the checksum writer */
-    if (target->tail_blocks > 0) {
-        ret = zero_writer_create(target, target->tail_blocks);
-        if (ret < 0)
-            goto target_cleanup;
-    }
+    ret = zero_writer_create(target, target->tail_blocks, 1);
+    if (ret < 0)
+        goto target_cleanup;
 
     if ((target->md5_file_checksums & 1) || target->md5_session_checksum) {
         ret = checksum_writer_create(target);
@@ -1918,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.
             */
@@ -1944,15 +1993,15 @@ 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 */
         if (i == el_torito_writer_index)
     continue;
 
-        /* Exposing address of data start to IsoWriteOpts iand memorizing
-           this address for for all files which have no block address: 
+        /* Exposing address of data start to IsoWriteOpts and memorizing
+           this address for all files which have no block address: 
            symbolic links, device files, empty data files.
            filesrc_writer_compute_data_blocks() and filesrc_writer_write_data()
            will account resp. write this single block. 
@@ -2611,6 +2660,15 @@ int iso_write_opts_set_joliet_longer_paths(IsoWriteOpts *opts, int allow)
     return ISO_SUCCESS;
 }
 
+int iso_write_opts_set_joliet_long_names(IsoWriteOpts *opts, int allow)
+{
+    if (opts == NULL) {
+        return ISO_NULL_POINTER;
+    }
+    opts->joliet_long_names = allow ? 1 : 0;
+    return ISO_SUCCESS;
+}
+
 int iso_write_opts_set_rrip_version_1_10(IsoWriteOpts *opts, int oldvers)
 {
     if (opts == NULL) {
@@ -2880,7 +2938,7 @@ int iso_write_opts_set_system_area(IsoWriteOpts *opts, char data[32768],
         memcpy(opts->system_area_data, data, 32768);
     }
     if (!(flag & 4))
-        opts->system_area_options = options & 0xff;
+        opts->system_area_options = options & 0x3ff;
     return ISO_SUCCESS;
 }
 

libisofs/ecma119.h

@@ -161,6 +161,11 @@ struct iso_write_opts {
      */
     unsigned int joliet_longer_paths :1;
 
+    /**
+     * Allow Joliet names up to 103 characters rather than 64.
+     */
+    unsigned int joliet_long_names :1;
+
     /**
      * Write Rock Ridge info as of specification RRIP-1.10 rather than
      * RRIP-1.12: signature "RRIP_1991A" rather than "IEEE_1282",
@@ -459,6 +464,9 @@ struct ecma119_image
     /** Allow paths on Joliet tree to be larger than 240 bytes */
     unsigned int joliet_longer_paths :1;
 
+    /** Allow Joliet names up to 103 characters rather than 64  */
+    unsigned int joliet_long_names :1;
+
     /** Write old fashioned RRIP-1.10 rather than RRIP-1.12 */
     unsigned int rrip_version_1_10 :1;
 
@@ -575,19 +583,27 @@ struct ecma119_image
      */
     char *system_area_data;
     /*
-     * bit0= Only with PC-BIOS DOS MBR
+     * bit0= Only with DOS MBR
      *       Make bytes 446 - 512 of the system area a partition
      *       table which reserves partition 1 from byte 63*512 to the
      *       end of the ISO image. Assumed are 63 secs/hed, 255 head/cyl.
      *       (GRUB protective msdos label.)
      *       This works with and without system_area_data.
-     * bit1= Only with PC-BIOS DOS MBR
+     * bit1= Only with DOS MBR
      *       Apply isohybrid MBR patching to the system area.
      *       This works only with system_area_data plus ISOLINUX boot image
      *       and only if not bit0 is set.
      * bit2-7= System area type
      *       0= DOS MBR
      *       1= MIPS Big Endian Volume Header
+     *       2= DEC Boot Block for MIPS Little Endian
+     *       3= SUN Disk Label for SUN SPARC
+     * bit8-9= Only with DOS MBR
+     *       Cylinder alignment mode eventually pads the image to make it
+     *       end at a cylinder boundary.
+     *       0 = auto (align if bit1)
+     *       1 = always align to cylinder boundary
+     *       2 = never align to cylinder boundary
      */
     int system_area_options;
 

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

@@ -239,6 +239,7 @@ int iso_tree_add_boot_node(IsoDir *parent, const char *name, IsoBoot **boot)
     IsoBoot *node;
     IsoNode **pos;
     time_t now;
+    int ret;
 
     if (parent == NULL || name == NULL || boot == NULL) {
         return ISO_NULL_POINTER;
@@ -248,9 +249,9 @@ int iso_tree_add_boot_node(IsoDir *parent, const char *name, IsoBoot **boot)
     }
 
     /* check if the name is valid */
-    if (!iso_node_is_valid_name(name)) {
-        return ISO_WRONG_ARG_VALUE;
-    }
+    ret = iso_node_is_valid_name(name);
+    if (ret < 0)
+        return ret;
 
     /* find place where to insert */
     pos = &(parent->children);
@@ -383,14 +384,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 */
@@ -486,7 +487,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);
@@ -836,10 +837,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;
@@ -895,7 +896,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;
 }
@@ -935,7 +936,11 @@ IsoStreamIface catalog_stream_class = {
     catalog_read,
     catalog_is_repeatable,
     catalog_get_id,
-    catalog_free
+    catalog_free,
+    NULL,
+    NULL,
+    NULL,
+    NULL
 };
 
 /**
@@ -1126,8 +1131,8 @@ int eltorito_writer_compute_data_blocks(IsoImageWriter *writer)
         }
         ret = iso_stream_read(original, buf, size);
         iso_stream_close(original);
-        if (ret != size) {
-            return (ret < 0) ? ret : ISO_FILE_READ_ERROR;
+        if (ret != (int) size) {
+            return (ret < 0) ? ret : (int) ISO_FILE_READ_ERROR;
         }
 
         /* ok, patch the read buffer */

libisofs/filesrc.c

@@ -335,11 +335,11 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
 {
     int res, ret, was_error;
     size_t i, b;
-    Ecma119Image *t;
+    Ecma119Image *t = NULL;
     IsoFileSrc *file;
     IsoFileSrc **filelist;
-    char name[PATH_MAX];
-    char buffer[BLOCK_SIZE];
+    char *name = NULL;
+    char *buffer = NULL;
     off_t file_size;
     uint32_t nblocks;
     void *ctx= NULL;
@@ -350,10 +350,11 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
 #endif
 
     if (writer == NULL) {
-        return ISO_ASSERT_FAILURE;
+        ret = ISO_ASSERT_FAILURE; goto ex;
     }
 
-    memset(buffer, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(name, char, PATH_MAX);
+    LIBISO_ALLOC_MEM(buffer, char, BLOCK_SIZE);
     t = writer->target;
     filelist = writer->data;
 
@@ -562,13 +563,15 @@ ex:;
         iso_md5_end(&ctx, md5);
 
 #ifdef Libisofs_with_libjtE
-    if (jte_begun) {
+    if (jte_begun && t != NULL) {
         libjte_end_data_file(t->libjte_handle);
         iso_libjte_forward_msgs(t->libjte_handle, t->image->id,
                                 ISO_LIBJTE_END_FAILED, 0);
     }
 #endif /* Libisofs_with_libjtE */
 
+    LIBISO_FREE_MEM(buffer);
+    LIBISO_FREE_MEM(name);
     return ret;
 }
 

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;
@@ -534,6 +534,9 @@ IsoStream *gzip_get_input_stream(IsoStream *stream, int flag)
 static
 int gzip_clone_stream(IsoStream *old_stream, IsoStream **new_stream, int flag)
 {
+
+#ifdef Libisofs_with_zliB
+
     int ret;
     IsoStream *new_input_stream, *stream;
     GzipFilterStreamData *stream_data, *old_stream_data;
@@ -558,6 +561,13 @@ int gzip_clone_stream(IsoStream *old_stream, IsoStream **new_stream, int flag)
     stream->data = stream_data;
     *new_stream = stream;
     return ISO_SUCCESS;
+
+#else /* Libisofs_with_zliB */
+
+    return ISO_STREAM_NO_CLONE;
+
+#endif /* ! Libisofs_with_zliB */
+
 }
 
 static

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

@@ -35,11 +35,6 @@
 #include <stdio.h>
 
 
-#ifndef PATH_MAX
-#define PATH_MAX Libisofs_default_path_maX
-#endif
-
-
 /**
  * Options for image reading.
  * There are four kind of options:
@@ -72,7 +67,7 @@ struct iso_read_opts
     unsigned int nojoliet : 1; /*< Do not read Joliet extensions */
     unsigned int noiso1999 : 1; /*< Do not read ISO 9660:1999 enhanced tree */
     unsigned int noaaip : 1; /* Do not read AAIP extension for xattr and ACL */
-    unsigned int nomd5 : 1;  /* Do not read MD5 array */
+    unsigned int nomd5 : 2;  /* Do not read MD5 array */
 
     /**
      * Hand out new inode numbers and overwrite eventually read PX inode
@@ -267,7 +262,7 @@ typedef struct
     int aaip_load;
 
     /** Whether the MD5 array shall be read if available.
-     *  1 = yes , 0 = no
+     *  2 = yes, but do not check tags , 1 = yes , 0 = no
      */
     int md5_load;
 
@@ -397,6 +392,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;
@@ -475,15 +472,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;
 
@@ -491,7 +489,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 */
@@ -515,7 +513,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;
@@ -560,7 +558,7 @@ int read_dir(ImageFileSourceData *data)
                 free(ifsdata);
                 free(child);
             }
-            return ret;
+            goto ex;
         }
 
         /* add to the child list */
@@ -569,7 +567,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
@@ -586,7 +584,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
@@ -953,6 +954,7 @@ int ifs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
 {
     char *dest;
     size_t len;
+    int ret;
     ImageFileSourceData *data;
 
     if (src == NULL || buf == NULL || src->data == NULL) {
@@ -971,14 +973,15 @@ int ifs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
 
     dest = (char*)data->data.content;
     len = strlen(dest);
-    if (bufsiz <= len) {
+
+    ret = ISO_SUCCESS;
+    if (len >= bufsiz) {
+        ret = ISO_RR_PATH_TOO_LONG;
         len = bufsiz - 1;
     }
-
     strncpy(buf, dest, len);
     buf[len] = '\0';
-
-    return ISO_SUCCESS;
+    return ret;
 }
 
 static
@@ -1248,7 +1251,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;
 
@@ -1258,7 +1262,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;
@@ -1277,7 +1281,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;}
     }
 
     /*
@@ -1288,7 +1292,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 */
@@ -1303,13 +1307,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);
     }
@@ -1324,7 +1328,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) {
@@ -1365,7 +1369,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;}
     }
 
     /*
@@ -1383,7 +1387,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) {
@@ -1452,7 +1456,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.
@@ -1584,13 +1588,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);
@@ -1602,6 +1607,7 @@ int iso_file_source_new_ifs(IsoImageFilesystem *fs, IsoFileSource *parent,
                     sprintf(msg,
                            "Character set name recorded in ISO image: '%.80s'",
                            cs_value);
+                    free(cs_value);
                 }
                 iso_msgs_submit(0, msg, 0, "NOTE", 0);
                 cs_value = NULL;
@@ -1623,7 +1629,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);
@@ -1645,7 +1651,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);
@@ -1678,15 +1684,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 */
@@ -1712,24 +1720,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
@@ -1765,7 +1773,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 */
@@ -1833,13 +1841,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;
 }
 
@@ -1848,25 +1860,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 */
@@ -1875,6 +1888,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;
 }
 
@@ -2077,14 +2092,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 */
@@ -2099,7 +2115,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 */
@@ -2107,11 +2123,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 */
@@ -2119,9 +2135,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.");
@@ -2206,10 +2223,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
@@ -2242,11 +2262,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;
 
@@ -2294,7 +2315,10 @@ int read_pvm(_ImageFsData *data, uint32_t block)
      * example.
      */
 
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }
 
 /**
@@ -2308,12 +2332,13 @@ int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)
     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;
 
+    LIBISO_ALLOC_MEM(buffer, unsigned char, BLOCK_SIZE);
     data->num_bootimgs = 0;
     ret = data->src->read_block(data->src, block, buffer);
     if (ret < 0) {
-        return ret;
+        goto ex;
     }
 
     ve = (struct el_torito_validation_entry*)buffer;
@@ -2324,7 +2349,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 */
@@ -2332,7 +2357,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 */
@@ -2385,7 +2410,10 @@ int read_el_torito_boot_catalog(_ImageFsData *data, uint32_t block)
         }
     }
 after_bootblocks:;
-    return ISO_SUCCESS;
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }
 
 
@@ -2399,11 +2427,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;
@@ -2418,7 +2447,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_AREA_CORRUPTED || ret == ISO_MD5_TAG_MISMATCH)
+        if (ret == (int) ISO_MD5_TAG_COPIED) {/* growing without emulated TOC */
+            ret = 2;
+            goto ex;
+        }
+        if (ret == (int) ISO_MD5_AREA_CORRUPTED ||
+            ret == (int) ISO_MD5_TAG_MISMATCH)
             ret = ISO_SB_TREE_CORRUPTED;
         if (ret < 0)
             goto ex;
@@ -2452,7 +2486,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;
@@ -2461,6 +2496,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;
 }
 
@@ -2472,21 +2508,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 */
@@ -2504,7 +2541,12 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
     data->dir_mode = opts->dir_mode & ~S_IFMT;
     data->msgid = msgid;
     data->aaip_load = !opts->noaaip;
-    data->md5_load = !opts->nomd5;
+    if (opts->nomd5 == 0)
+        data->md5_load = 1;
+    else if (opts->nomd5 == 2)
+        data->md5_load = 2;
+    else
+        data->md5_load = 0;
     data->aaip_version = -1;
     data->make_new_ino = opts->make_new_ino;
     data->num_bootimgs = 0;
@@ -2532,7 +2574,7 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
     ifs->free = ifs_fs_free;
 
     /* read Volume Descriptors and ensure it is a valid image */
-    if (data->md5_load) {
+    if (data->md5_load == 1) {
         /* From opts->block on : check for superblock and tree tags */;
         ret = iso_src_check_sb_tree(src, opts->block, 0);
         if (ret < 0) {
@@ -2583,8 +2625,8 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
                 } else {
                     data->catblock = iso_read_lsb(vol->boot_catalog, 4);
                     ret = read_el_torito_boot_catalog(data, data->catblock);
-                    if (ret < 0 && ret != ISO_UNSUPPORTED_EL_TORITO &&
-                        ret != ISO_WRONG_EL_TORITO) {
+                    if (ret < 0 && ret != (int) ISO_UNSUPPORTED_EL_TORITO &&
+                        ret != (int) ISO_WRONG_EL_TORITO) {
                         goto fs_cleanup;
                     }
                 }
@@ -2705,11 +2747,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;
 }
 
@@ -2761,6 +2806,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
     struct stat info;
     IsoNode *new;
     char *name;
+    char *dest = NULL;
     ImageFileSourceData *data;
     _ImageFsData *fsdata;
 
@@ -2773,7 +2819,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;
@@ -2784,7 +2830,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;
@@ -2802,7 +2848,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);
                 }
@@ -2813,7 +2859,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                 if (new == NULL) {
                     ret = ISO_OUT_OF_MEM;
                     free(name);
-                    return ret;
+                    goto ex;
                 }
 
                 /* and set the image node */
@@ -2827,7 +2873,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);
@@ -2836,7 +2882,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 */
@@ -2860,7 +2906,7 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                     if (ret < 0) {
                         free(name);
                         iso_stream_unref(stream);
-                        return ret;
+                        goto ex;
                     }
                 }
 
@@ -2891,7 +2937,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 */
@@ -2908,7 +2954,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;
@@ -2917,18 +2963,19 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
     case S_IFLNK:
         {
             /* source is a symbolic link */
-            char dest[PATH_MAX];
             IsoSymlink *link;
 
-            ret = iso_file_source_readlink(src, dest, PATH_MAX);
+            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;
@@ -2949,7 +2996,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;
@@ -2991,13 +3038,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;
 }
 
@@ -3123,12 +3172,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;
@@ -3168,7 +3218,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;
@@ -3207,6 +3257,7 @@ ex:;
         free(boot_image_buf);
     if (stream != NULL)
         iso_stream_close(stream);
+    LIBISO_FREE_MEM(buf);
     return ret;
 }
 
@@ -3234,6 +3285,8 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
     size_t size;
     void *ctx = NULL;
     char md5[16];
+    struct el_torito_boot_catalog *catalog = NULL;
+    ElToritoBootImage *boot_image = NULL;
 
     if (image == NULL || src == NULL || opts == NULL) {
         return ISO_NULL_POINTER;
@@ -3321,8 +3374,6 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
 
     /* if old image has el-torito, add a new catalog */
     if (data->eltorito) {
-        struct el_torito_boot_catalog *catalog;
-        ElToritoBootImage *boot_image= NULL;
 
         catalog = calloc(1, sizeof(struct el_torito_boot_catalog));
         if (catalog == NULL) {
@@ -3348,11 +3399,13 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
             memcpy(boot_image->selection_crit, data->selection_crits, 20);
 
             catalog->bootimages[catalog->num_bootimages] = boot_image;
+            boot_image = NULL;
             catalog->num_bootimages++;
         }
         for ( ; idx < Libisofs_max_boot_imageS; idx++)
             catalog->bootimages[idx] = NULL;
         image->bootcat = catalog;
+        catalog = NULL; /* So it does not get freed */
     }
 
     /* recursively add image */
@@ -3475,7 +3528,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)
@@ -3488,7 +3541,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++)
@@ -3531,6 +3584,10 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
     image->fs = fsback;
     image->builder = blback;
 
+    if (catalog != NULL)
+        el_torito_boot_catalog_free(catalog);
+    if (boot_image != NULL)
+        free((char *) boot_image);
     iso_file_source_unref(newroot);
     fs->close(fs);
     iso_filesystem_unref(fs);
@@ -3682,7 +3739,7 @@ int iso_read_opts_set_no_md5(IsoReadOpts *opts, int no_md5)
     if (opts == NULL) {
         return ISO_NULL_POINTER;
     }
-    opts->nomd5 = no_md5 ? 1 : 0;
+    opts->nomd5 = no_md5 == 2 ? 2 : no_md5 == 1 ? 1 : 0;
     return ISO_SUCCESS;
 }
 

libisofs/fs_local.c

@@ -103,6 +103,8 @@ int lfs_lstat(IsoFileSource *src, struct stat *info)
     }
     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 +130,7 @@ int lfs_lstat(IsoFileSource *src, struct stat *info)
             err = ISO_FILE_ERROR;
             break;
         }
+        free(path);
         return err;
     }
     free(path);
@@ -145,6 +148,8 @@ int lfs_stat(IsoFileSource *src, struct stat *info)
     }
     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 +175,7 @@ int lfs_stat(IsoFileSource *src, struct stat *info)
             err = ISO_FILE_ERROR;
             break;
         }
+        free(path);
         return err;
     }
     free(path);
@@ -412,7 +418,7 @@ int lfs_readdir(IsoFileSource *src, IsoFileSource **child)
 static
 int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
 {
-    int size;
+    int size, ret;
     _LocalFsFileSource *data;
     char *path;
 
@@ -431,7 +437,7 @@ int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
      * invoke readlink, with bufsiz -1 to reserve an space for
      * the NULL character
      */
-    size = readlink(path, buf, bufsiz - 1);
+    size = readlink(path, buf, bufsiz);
     free(path);
     if (size < 0) {
         /* error */
@@ -455,8 +461,13 @@ int lfs_readlink(IsoFileSource *src, char *buf, size_t bufsiz)
     }
 
     /* NULL-terminate the buf */
+    ret = ISO_SUCCESS;
+    if ((size_t) size >= bufsiz) {
+        ret = ISO_RR_PATH_TOO_LONG;
+        size = bufsiz - 1;
+    }
     buf[size] = '\0';
-    return ISO_SUCCESS;
+    return ret;
 }
 
 static
@@ -506,6 +517,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/image.c

@@ -32,7 +32,7 @@
  * @param image
  *     Location where the image pointer will be stored.
  * @return
- *     1 sucess, < 0 error
+ *     1 success, < 0 error
  */
 int iso_image_new(const char *name, IsoImage **image)
 {
@@ -142,6 +142,8 @@ void iso_image_unref(IsoImage *image)
         free(image->biblio_file_id);
         if (image->used_inodes != NULL)
             free(image->used_inodes);
+        if (image->system_area_data != NULL)
+            free(image->system_area_data);
         iso_image_free_checksums(image, 0);
         free(image);
     }

libisofs/iso1999.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
+ * Copyright (c) 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -17,6 +18,7 @@
 #include "image.h"
 #include "filesrc.h"
 #include "eltorito.h"
+#include "util.h"
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -73,7 +75,7 @@ void iso1999_node_free(Iso1999Node *node)
         return;
     }
     if (node->type == ISO1999_DIR) {
-        int i;
+        size_t i;
         for (i = 0; i < node->info.dir->nchildren; i++) {
             iso1999_node_free(node->info.dir->children[i]);
         }
@@ -307,7 +309,10 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
     Iso1999Node **children;
     IsoHTable *table;
     int need_sort = 0;
+    char *full_name = NULL, *tmp = NULL;
 
+    LIBISO_ALLOC_MEM(full_name, char, 208);
+    LIBISO_ALLOC_MEM(tmp, char, 208);
     nchildren = dir->info.dir->nchildren;
     children = dir->info.dir->children;
 
@@ -315,19 +320,18 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
     ret = iso_htable_create((nchildren * 100) / 80, iso_str_hash,
                             (compare_function_t)strcmp, &table);
     if (ret < 0) {
-        return ret;
+        goto ex;
     }
     for (i = 0; i < nchildren; ++i) {
         char *name = children[i]->name;
         ret = iso_htable_add(table, name, name);
         if (ret < 0) {
-            goto mangle_cleanup;
+            goto ex;
         }
     }
 
     for (i = 0; i < nchildren; ++i) {
         char *name, *ext;
-        char full_name[208];
         int max; /* computed max len for name, without extension */
         int j = i;
         int digits = 1; /* characters to change per name */
@@ -384,7 +388,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
                          * This can't happen with current limit of digits.
                          */
                         ret = ISO_ERROR;
-                        goto mangle_cleanup;
+                        goto ex;
                     }
                 }
                 /* ok, reduce name by digits */
@@ -398,7 +402,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
                 }
                 max = 207 - digits;
                 name = full_name;
-                if (max < strlen(name)) {
+                if ((size_t) max < strlen(name)) {
                     name[max] = '\0';
                 }
                 /* let ext be an empty string */
@@ -408,7 +412,6 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
             ok = 1;
             /* change name of each file */
             for (k = i; k <= j; ++k) {
-                char tmp[208];
                 char fmt[16];
                 if (dot != NULL) {
                     sprintf(fmt, "%%s%%0%dd.%%s", digits);
@@ -431,7 +434,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
                     char *new = strdup(tmp);
                     if (new == NULL) {
                         ret = ISO_OUT_OF_MEM;
-                        goto mangle_cleanup;
+                        goto ex;
                     }
                     iso_msg_debug(img->image->id, "\"%s\" renamed to \"%s\"",
                                   children[k]->name, new);
@@ -459,7 +462,7 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
         }
         if (digits == 8) {
             ret = ISO_MANGLE_TOO_MUCH_FILES;
-            goto mangle_cleanup;
+            goto ex;
         }
         i = j;
     }
@@ -473,8 +476,10 @@ int mangle_single_dir(Ecma119Image *img, Iso1999Node *dir)
 
     ret = ISO_SUCCESS;
 
-mangle_cleanup : ;
+ex:;
     iso_htable_destroy(table, NULL);
+    LIBISO_FREE_MEM(tmp);
+    LIBISO_FREE_MEM(full_name);
     return ret;
 }
 
@@ -810,15 +815,15 @@ static
 int write_one_dir(Ecma119Image *t, Iso1999Node *dir)
 {
     int ret;
-    uint8_t buffer[BLOCK_SIZE];
+    uint8_t *buffer = NULL;
     size_t i;
     size_t fi_len, len;
 
     /* buf will point to current write position on buffer */
-    uint8_t *buf = buffer;
+    uint8_t *buf;
 
-    /* initialize buffer with 0s */
-    memset(buffer, 0, BLOCK_SIZE);
+    LIBISO_ALLOC_MEM(buffer, uint8_t, BLOCK_SIZE);
+    buf = buffer;
 
     /* write the "." and ".." entries first */
     write_one_dir_record(t, dir, 0, buf, 1, 0);
@@ -840,7 +845,7 @@ int write_one_dir(Ecma119Image *t, Iso1999Node *dir)
                 /* dir doesn't fit in current block */
                 ret = iso_write(t, buffer, BLOCK_SIZE);
                 if (ret < 0) {
-                    return ret;
+                    goto ex;
                 }
                 memset(buffer, 0, BLOCK_SIZE);
                 buf = buffer;
@@ -853,6 +858,8 @@ int write_one_dir(Ecma119Image *t, Iso1999Node *dir)
 
     /* write the last block */
     ret = iso_write(t, buffer, BLOCK_SIZE);
+ex:;
+    LIBISO_FREE_MEM(buffer);
     return ret;
 }
 
@@ -885,13 +892,17 @@ static
 int write_path_table(Ecma119Image *t, Iso1999Node **pathlist, int l_type)
 {
     size_t i, len;
-    uint8_t buf[256]; /* 256 is just a convenient size larger enought */
+    uint8_t *buf = NULL;
     struct ecma119_path_table_record *rec;
     void (*write_int)(uint8_t*, uint32_t, int);
     Iso1999Node *dir;
     uint32_t path_table_size;
     int parent = 0;
     int ret= ISO_SUCCESS;
+    uint8_t *zeros = NULL;
+
+    /* 256 is just a convenient size large enought */
+    LIBISO_ALLOC_MEM(buf, uint8_t, 256);
 
     path_table_size = 0;
     write_int = l_type ? iso_lsb : iso_msb;
@@ -918,7 +929,7 @@ int write_path_table(Ecma119Image *t, Iso1999Node **pathlist, int l_type)
         ret = iso_write(t, buf, len);
         if (ret < 0) {
             /* error */
-            return ret;
+            goto ex;
         }
         path_table_size += len;
     }
@@ -926,11 +937,14 @@ int write_path_table(Ecma119Image *t, Iso1999Node **pathlist, int l_type)
     /* we need to fill the last block with zeros */
     path_table_size %= BLOCK_SIZE;
     if (path_table_size) {
-        uint8_t zeros[BLOCK_SIZE];
+        LIBISO_ALLOC_MEM(zeros, uint8_t, BLOCK_SIZE);
         len = BLOCK_SIZE - path_table_size;
         memset(zeros, 0, len);
         ret = iso_write(t, zeros, len);
     }
+ex:;
+    LIBISO_FREE_MEM(zeros);
+    LIBISO_FREE_MEM(buf);
     return ret;
 }
 

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 
@@ -19,6 +20,7 @@
 #include "filesrc.h"
 #include "eltorito.h"
 #include "libisofs.h"
+#include "util.h"
 
 
 #include <stdlib.h>
@@ -42,12 +44,11 @@ int get_joliet_name(Ecma119Image *t, IsoNode *iso, uint16_t **name)
         iso_msg_debug(t->image->id, "Can't convert %s", iso->name);
         return ret;
     }
-
-    /* TODO #00022 : support relaxed constraints in joliet filenames */
     if (iso->type == LIBISO_DIR) {
-        jname = iso_j_dir_id(ucs_name);
+        jname = iso_j_dir_id(ucs_name, t->joliet_long_names << 1);
     } else {
-        jname = iso_j_file_id(ucs_name, !!(t->no_force_dots & 2));
+        jname = iso_j_file_id(ucs_name,
+                       (t->joliet_long_names << 1) | !!(t->no_force_dots & 2));
     }
     free(ucs_name);
     if (jname != NULL) {
@@ -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]);
         }
@@ -303,8 +304,15 @@ int joliet_create_mangled_name(uint16_t *dest, uint16_t *src, int digits,
     int ret, pos;
     uint16_t *ucsnumber;
     char fmt[16];
-    char nstr[72]; /* The only caller of this function allocates dest with 66
-                      elements and limits digits to < 8 */
+    char nstr[72];
+              /* was: The only caller of this function allocates dest
+                      with 66 elements and limits digits to < 8
+                 But this does not match the usage of nstr which has to take
+                 the decimal representation of an int.
+              */
+
+    if (digits >= 8)
+        return ISO_ASSERT_FAILURE;
 
     sprintf(fmt, "%%0%dd", digits);
     sprintf(nstr, fmt, number);
@@ -337,19 +345,26 @@ static
 int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
 {
     int ret;
-    int i, nchildren;
+    int i, nchildren, maxchar = 64;
     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;
 
+    if (t->joliet_long_names)
+        maxchar = 103;
+
     /* a hash table will temporary hold the names, for fast searching */
     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;
@@ -361,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[66];
         int max; /* computed max len for name, without extension */
         int j = i;
         int digits = 1; /* characters to change per name */
@@ -380,7 +394,7 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
          * A max of 7 characters is good enought, it allows handling up to
          * 9,999,999 files with same name.
          */
-         /* Important: joliet_create_mangled_name() relies on digits < 72 */
+         /* Important: joliet_create_mangled_name() relies on digits < 8 */
 
         while (digits < 8) {
             int ok, k;
@@ -403,7 +417,7 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
                 ext = dot + 1;
 
                 extlen = ucslen(ext);
-                max = 65 - extlen - 1 - digits;
+                max = maxchar + 1 - extlen - 1 - digits;
                 if (max <= 0) {
                     /* this can happen if extension is too long */
                     if (extlen + max > 3) {
@@ -413,7 +427,7 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
                          */
                         extlen = extlen + max - 1;
                         ext[extlen] = 0;
-                        max = 66 - extlen - 1 - digits;
+                        max = maxchar + 2 - extlen - 1 - digits;
                     } else {
                         /*
                          * error, we don't support extensions < 3
@@ -430,13 +444,13 @@ int mangle_single_dir(Ecma119Image *t, JolietNode *dir)
             } else {
                 /* Directory, or file without extension */
                 if (children[i]->type == JOLIET_DIR) {
-                    max = 65 - digits;
+                    max = maxchar + 1 - digits;
                     dot = NULL; /* dots have no meaning in dirs */
                 } else {
-                    max = 65 - digits;
+                    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 */
@@ -446,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[66];
                 while (1) {
                     ret = joliet_create_mangled_name(tmp, name, digits,
                                                      change, ext);
@@ -508,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;
 }
 
@@ -909,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);
@@ -944,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;
@@ -957,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;
 }
 
@@ -989,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;
 
@@ -1023,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;
     }
@@ -1031,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/joliet.h

@@ -18,6 +18,10 @@
 #include "libisofs.h"
 #include "ecma119.h"
 
+/* was formerly 66 = 64 + 2. Now 105 = 103 + 2.
+*/
+#define LIBISO_JOLIET_NAME_MAX 105
+
 enum joliet_node_type {
 	JOLIET_FILE,
 	JOLIET_DIR

libisofs/libisofs.h

@@ -18,15 +18,32 @@
 
 /* 
  *
- * Applications must use 64 bit off_t, e.g. on 32-bit GNU/Linux by defining
+ * Applications must use 64 bit off_t.
+ * E.g. on 32-bit GNU/Linux by defining
  *   #define _LARGEFILE_SOURCE
  *   #define _FILE_OFFSET_BITS 64
- * or take special precautions to interface with the library by 64 bit integers
- * where this .h files prescribe off_t. Not to use 64 bit file i/o will keep
- * the application from producing and processing ISO images of more than 2 GB
- * size.
- *
+ * The minimum requirement is to interface with the library by 64 bit signed
+ * integers where libisofs.h or libisoburn.h prescribe off_t.
+ * Failure to do so may result in surprising malfunction or memory faults.
+ * 
+ * Application files which include libisofs/libisofs.h must provide
+ * definitions for uint32_t and uint8_t.
+ * This can be achieved either:
+ * - by using autotools which will define HAVE_STDINT_H or HAVE_INTTYPES_H
+ *   according to its ./configure tests,
+ * - or by defining the macros HAVE_STDINT_H resp. HAVE_INTTYPES_H according
+ *   to the local situation,
+ * - or by appropriately defining uint32_t and uint8_t by other means,
+ *   e.g. by including inttypes.h before including libisofs.h
  */
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
 
 /*
  * Normally this API is operated via public functions and opaque object
@@ -42,14 +59,6 @@
 
 #include <sys/stat.h>
 
-#ifdef HAVE_STDINT_H
-#include <stdint.h>
-#else
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-#endif
-#endif
-
 #include <stdlib.h>
 
 struct burn_source;
@@ -158,6 +167,15 @@ struct iso_file_section
     uint32_t size;
 };
 
+/* If you get here because of a compilation error like
+
+       /usr/include/libisofs/libisofs.h:166: error:
+       expected specifier-qualifier-list before 'uint32_t'
+
+   then see the paragraph above about the definition of uint32_t.
+*/
+
+
 /**
  * Context for iterate on directory children.
  * @see iso_dir_get_children()
@@ -440,7 +458,10 @@ struct iso_filesystem
 
     /**
      * Retrieve a file from its absolute path inside the filesystem.
-     *
+     * @param file
+     *     Returns a pointer to a IsoFileSource object representing the
+     *     file. It has to be disposed by iso_file_source_unref() when
+     *     no longer needed.
      * @return
      *     1 success, < 0 error (has to be a valid libisofs error code)
      *      Error codes:
@@ -1206,8 +1227,8 @@ int iso_lib_is_compatible(int major, int minor, int micro);
  * @since 0.6.2
  */
 #define iso_lib_header_version_major  1
-#define iso_lib_header_version_minor  0
-#define iso_lib_header_version_micro  2
+#define iso_lib_header_version_minor  1
+#define iso_lib_header_version_micro  0
 
 /**
  * Usage discussion:
@@ -1585,6 +1606,15 @@ int iso_write_opts_set_relaxed_vol_atts(IsoWriteOpts *opts, int allow);
  */
 int iso_write_opts_set_joliet_longer_paths(IsoWriteOpts *opts, int allow);
 
+/**
+ * Allow leaf names in the Joliet tree to have up to 103 characters.
+ * Normal limit is 64. 
+ * This breaks Joliet specification. Use with caution.
+ *
+ * @since 1.0.6
+ */
+int iso_write_opts_set_joliet_long_names(IsoWriteOpts *opts, int allow);
+
 /**
  * Write Rock Ridge info as of specification RRIP-1.10 rather than RRIP-1.12:
  * signature "RRIP_1991A" rather than "IEEE_1282", field PX without file
@@ -1959,7 +1989,13 @@ int iso_write_opts_set_fifo_size(IsoWriteOpts *opts, size_t fifo_size);
  *                 iso_write_opts_set_partition_img() for partition numbers 2
  *                 to 8.
  *                 This will overwrite the first 512 bytes of the submitted
- *                 data.
+ *        bit8-9= Only with System area type 0 = MBR
+ *                @since 1.0.4
+ *                Cylinder alignment mode eventually pads the image to make it
+ *                end at a cylinder boundary.
+ *                0 = auto (align if bit1)
+ *                1 = always align to cylinder boundary
+ *                2 = never align to cylinder boundary
  * @param flag
  *        bit0 = invalidate any attached system area data. Same as data == NULL
  *               (This re-activates eventually loaded image System Area data.
@@ -2069,9 +2105,9 @@ int iso_write_opts_set_part_offset(IsoWriteOpts *opts,
     tests. It can be prevented by ./configure option --disable-libjte .
     @since 0.6.38
 */
-#define iso_libjte_req_major 0
-#define iso_libjte_req_minor 1
-#define iso_libjte_req_micro 1
+#define iso_libjte_req_major 1
+#define iso_libjte_req_minor 0
+#define iso_libjte_req_micro 0
 
 /** 
  * Associate a libjte environment object to the upcomming write run.
@@ -2331,8 +2367,10 @@ int iso_read_opts_set_no_aaip(IsoReadOpts *opts, int noaaip);
  * @param opts
  *       The option set to be manipulated
  * @param no_md5
+ *       0 = Read MD5 array if available, refuse on non-matching MD5 tags
  *       1 = Do not read MD5 checksum array
- *       0 = Read Md% array if available
+ *       2 = Read MD5 array, but do not check MD5 tags
+ *           @since 1.0.4
  *       All other values are reserved.
  *
  * @since 0.6.22
@@ -3120,6 +3158,8 @@ int el_torito_seems_boot_info_table(ElToritoBootImage *bootimg, int flag);
  * Specifies options for ISOLINUX or GRUB boot images. This should only be used
  * if the type of boot image is known.
  *
+ * @param bootimg
+ *      The image to set options on 
  * @param options
  *        bitmask style flag. The following values are defined:
  *
@@ -3147,8 +3187,6 @@ int el_torito_seems_boot_info_table(ElToritoBootImage *bootimg, int flag);
  *                 For that you need isolinux.bin from SYSLINUX 3.72 or later.
  *                 IMPORTANT: The application has to take care that the image
  *                            on media gets padded up to the next full MB.
- * @param bootimg
- *      The image to set options on 
  * @param flag
  *        Reserved for future usage, set to 0.
  * @return
@@ -5164,11 +5202,12 @@ int iso_file_source_readdir(IsoFileSource *src, IsoFileSource **child);
  * @param src
  *     An IsoFileSource corresponding to a symbolic link.
  * @param buf
- *     allocated buffer of at least bufsiz bytes.
- *     The dest. will be copied there, and it will be NULL-terminated
+ *     Allocated buffer of at least bufsiz bytes.
+ *     The destination string will be copied there, and it will be 0-terminated
+ *     if the return value indicates success or ISO_RR_PATH_TOO_LONG.
  * @param bufsiz
- *     characters to be copied. Destination link will be truncated if
- *     it is larger than given size. This includes the 0x0 character.
+ *     Maximum number of buf characters + 1. The string will be truncated if
+ *     it is larger than bufsiz - 1 and ISO_RR_PATH_TOO_LONG. will be returned.
  * @return
  *     1 on success, < 0 on error
  *      Error codes:
@@ -5179,6 +5218,7 @@ int iso_file_source_readdir(IsoFileSource *src, IsoFileSource **child);
  *         ISO_OUT_OF_MEM
  *         ISO_FILE_BAD_PATH
  *         ISO_FILE_DOESNT_EXIST
+ *         ISO_RR_PATH_TOO_LONG (@since 1.0.6)
  *
  * @since 0.6.2
  */
@@ -6808,6 +6848,19 @@ int iso_md5_match(char first_md5[16], char second_md5[16]);
                                                        (FAILURE, HIGH, -375) */
 #define ISO_XINFO_NO_CLONE         0xE830FE89
 
+/** Found copied superblock checksum tag  (WARNING, HIGH, -376) */
+#define ISO_MD5_TAG_COPIED         0xD030FE88
+
+/** Rock Ridge leaf name too long (FAILURE, HIGH, -377) */
+#define ISO_RR_NAME_TOO_LONG       0xE830FE87
+
+/** Reserved Rock Ridge leaf name  (FAILURE, HIGH, -378) */
+#define ISO_RR_NAME_RESERVED       0xE830FE86
+
+/** Rock Ridge path too long (FAILURE, HIGH, -379) */
+#define ISO_RR_PATH_TOO_LONG       0xE830FE85
+
+
 
 /* Internal developer note: 
    Place new error codes directly above this comment. 

libisofs/libisofs.ver

@@ -282,6 +282,7 @@ iso_write_opts_set_hardlinks;
 iso_write_opts_set_iso1999;
 iso_write_opts_set_iso_level;
 iso_write_opts_set_joliet;
+iso_write_opts_set_joliet_long_names;
 iso_write_opts_set_joliet_longer_paths;
 iso_write_opts_set_max_37_char_filenames;
 iso_write_opts_set_ms_block;

libisofs/make_isohybrid_mbr.c

@@ -386,21 +386,19 @@ int make_isolinux_mbr(int32_t *img_blocks, uint32_t boot_lba,
                       int part_offset, int part_number, int fs_type,
                       uint8_t *buf, int flag)
 {
-    uint32_t spc, id, part, nominal_part_size;
+    uint32_t id, part, nominal_part_size;
     off_t hd_img_blocks, hd_boot_lba;
     char *wpt;
     /* For generating a weak random number */
     struct timeval tv;
     struct timezone tz;
 
-    /* Pad image_size to a multiple of sector_count*head_count
-    */
-    spc = head_count * sector_count;
     hd_img_blocks = ((off_t) *img_blocks) * (off_t) 4;
-    if (hd_img_blocks % spc) {
-        hd_img_blocks += spc - (hd_img_blocks % spc);
-        *img_blocks = hd_img_blocks / 4 + !!(hd_img_blocks % 4);
-    }
+
+    /* Padding of image_size to a multiple of sector_count*head_count
+       happens already at compute time and is implemented by
+       an appropriate increase of Ecma119Image->tail_blocks.
+    */
 
     wpt = (char *) buf + 432;
 
@@ -426,7 +424,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;
-    char postext[40], md5[16], record[160];
+    int record_len, block_len, ret, i;
+    char postext[40], md5[16], *record = NULL;
 
+    LIBISO_ALLOC_MEM(record, char, 160);
     line_start = strlen(tag_block);
     iso_md5_compute(t->checksum_ctx, tag_block, line_start);
-    res = iso_md5_clone(t->checksum_ctx, &ctx);
-    if (res < 0)
+    ret = iso_md5_clone(t->checksum_ctx, &ctx);
+    if (ret < 0)
         goto ex;
-    res = iso_md5_end(&ctx, md5);
+    ret = iso_md5_end(&ctx, md5);
 
     pos = (off_t) t->checksum_tag_pos * (off_t) 2048 + line_start;
     if(pos >= 1000000000)
@@ -747,8 +743,8 @@ int iso_md5_write_scdbackup_tag(Ecma119Image *t, char *tag_block, int flag)
                  "%2.2x", ((unsigned char *) md5)[i]);
     record_len += 32;
 
-    res = iso_md5_start(&ctx);
-    if (res < 0)
+    ret = iso_md5_start(&ctx);
+    if (ret < 0)
         goto ex;
     iso_md5_compute(ctx, record, record_len);
     iso_md5_end(&ctx, md5);
@@ -765,11 +761,12 @@ int iso_md5_write_scdbackup_tag(Ecma119Image *t, char *tag_block, int flag)
     if (t->scdbackup_tag_written != NULL)
     	strncpy(t->scdbackup_tag_written, tag_block + line_start,
                 block_len - line_start);
-    res = ISO_SUCCESS;
+    ret = ISO_SUCCESS;
 ex:;
     if (ctx != NULL)
         iso_md5_end(&ctx, md5);
-    return res;
+    LIBISO_FREE_MEM(record);
+    return ret;
 }
 
 
@@ -783,20 +780,20 @@ ex:;
  */
 int iso_md5_write_tag(Ecma119Image *t, int flag)
 {
-    int res, mode, l, i, wres, tag_id_len;
+    int ret, mode, l, i, wres, tag_id_len;
     void *ctx = NULL;
-    char md5[16], tag_block[2048], *tag_id;
+    char md5[16], *tag_block = NULL, *tag_id;
     uint32_t size = 0, pos = 0, start;
 
+    LIBISO_ALLOC_MEM(tag_block, char, 2048);
     start = t->checksum_range_start;
-    memset(tag_block, 0, 2048);
     mode = flag & 255;
     if (mode < 1 || mode > 4)
-        return ISO_WRONG_ARG_VALUE;
-    res = iso_md5_clone(t->checksum_ctx, &ctx);
-    if (res < 0)
-        return res;
-    res = iso_md5_end(&ctx, md5);
+        {ret = ISO_WRONG_ARG_VALUE; goto ex;}
+    ret = iso_md5_clone(t->checksum_ctx, &ctx);
+    if (ret < 0)
+        goto ex;
+    ret = iso_md5_end(&ctx, md5);
     if (mode == 1) {
         size = t->checksum_range_size;
         pos = t->checksum_tag_pos;
@@ -811,7 +808,7 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
         }
         size = pos - start;
     }
-    if (res < 0)
+    if (ret < 0)
         goto ex;
 
     iso_util_tag_magic(mode, &tag_id, &tag_id_len, 0);
@@ -833,8 +830,8 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
                 ((unsigned char *) md5)[i]);
     l+= 32;
         
-    res = iso_md5_start(&ctx);
-    if (res > 0) {
+    ret = iso_md5_start(&ctx);
+    if (ret > 0) {
         iso_md5_compute(ctx, tag_block, l);
         iso_md5_end(&ctx, md5);
         strcpy(tag_block + l, " self=");
@@ -849,8 +846,8 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
         if (t->ms_block > 0) {
             iso_msg_submit(t->image->id, ISO_SCDBACKUP_TAG_NOT_0, 0, NULL);
         } else {
-            res = iso_md5_write_scdbackup_tag(t, tag_block, 0);
-            if (res < 0)
+            ret = iso_md5_write_scdbackup_tag(t, tag_block, 0);
+            if (ret < 0)
                 goto ex;
         }
     }
@@ -861,16 +858,17 @@ int iso_md5_write_tag(Ecma119Image *t, int flag)
     } else {
         wres = iso_write(t, tag_block, 2048);
         if (wres < 0) {
-            res = wres;
+            ret = wres;
             goto ex;
         }
     }
 
-    res = ISO_SUCCESS;
+    ret = ISO_SUCCESS;
 ex:;
     if (ctx != NULL)
         iso_md5_end(&ctx, md5);
-    return res;
+    LIBISO_FREE_MEM(tag_block);
+    return ret;
 }
 
 

libisofs/messages.c

@@ -245,15 +245,19 @@ 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;
+    int ret;
 
+    LIBISO_ALLOC_MEM(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)
@@ -453,6 +457,14 @@ const char *iso_error_to_msg(int errcode)
         return "Data file input stream object offers no cloning method";
     case ISO_XINFO_NO_CLONE:
         return "Extended information class offers no cloning method";
+    case ISO_MD5_TAG_COPIED:
+        return "Found copied superblock checksum tag";
+    case ISO_RR_NAME_TOO_LONG:
+        return "Rock Ridge leaf name too long";
+    case ISO_RR_NAME_RESERVED:
+        return "Reserved Rock Ridge leaf name";
+    case ISO_RR_PATH_TOO_LONG:
+        return "Rock Ridge path too long";
     default:
         return "Unknown error";
     }
@@ -472,7 +484,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

@@ -28,11 +28,6 @@
 #include <stdio.h>
 
 
-#ifndef PATH_MAX
-#define PATH_MAX Libisofs_default_path_maX
-#endif
-
-
 struct dir_iter_data
 {
     /* points to the last visited child, to NULL before start */
@@ -325,6 +320,7 @@ enum IsoNodeType iso_node_get_type(IsoNode *node)
 int iso_node_set_name(IsoNode *node, const char *name)
 {
     char *new;
+    int ret;
 
     if ((IsoNode*)node->parent == node) {
         /* you can't change name of the root node */
@@ -332,9 +328,9 @@ int iso_node_set_name(IsoNode *node, const char *name)
     }
 
     /* check if the name is valid */
-    if (!iso_node_is_valid_name(name)) {
-        return ISO_WRONG_ARG_VALUE;
-    }
+    ret = iso_node_is_valid_name(name);
+    if (ret < 0)
+        return ret;
 
     if (node->parent != NULL) {
         /* check if parent already has a node with same name */
@@ -1005,10 +1001,11 @@ const char *iso_symlink_get_dest(const IsoSymlink *link)
 int iso_symlink_set_dest(IsoSymlink *link, const char *dest)
 {
     char *d;
-    if (!iso_node_is_valid_link_dest(dest)) {
-        /* guard against null or empty dest */
-        return ISO_WRONG_ARG_VALUE;
-    }
+    int ret;
+
+    ret = iso_node_is_valid_link_dest(dest);
+    if (ret < 0)
+        return ret;
     d = strdup(dest);
     if (d == NULL) {
         return ISO_OUT_OF_MEM;
@@ -1159,22 +1156,23 @@ int iso_node_is_valid_name(const char *name)
 {
     /* a name can't be NULL */
     if (name == NULL) {
-        return 0;
+        return ISO_NULL_POINTER;
     }
 
     /* guard against the empty string or big names... */
-    if (name[0] == '\0' || strlen(name) > 255) {
-        return 0;
-    }
+    if (name[0] == '\0')
+        return ISO_RR_NAME_RESERVED;
+    if (strlen(name) > LIBISOFS_NODE_NAME_MAX)
+        return ISO_RR_NAME_TOO_LONG;
 
     /* ...against "." and ".." names... */
     if (!strcmp(name, ".") || !strcmp(name, "..")) {
-        return 0;
+        return ISO_RR_NAME_RESERVED;
     }
 
     /* ...and against names with '/' */
     if (strchr(name, '/') != NULL) {
-        return 0;
+        return ISO_RR_NAME_RESERVED;
     }
     return 1;
 }
@@ -1192,13 +1190,14 @@ int iso_node_is_valid_link_dest(const char *dest)
 
     /* a dest can't be NULL */
     if (dest == NULL) {
-        return 0;
+        return ISO_NULL_POINTER;
     }
 
     /* guard against the empty string or big dest... */
-    if (dest[0] == '\0' || strlen(dest) > PATH_MAX) {
-        return 0;
-    }
+    if (dest[0] == '\0')
+        return ISO_RR_NAME_RESERVED;
+    if (strlen(dest) > LIBISOFS_NODE_PATH_MAX)
+        return ISO_RR_PATH_TOO_LONG;
 
     /* check that all components are valid */
     if (!strcmp(dest, "/")) {
@@ -1208,7 +1207,7 @@ int iso_node_is_valid_link_dest(const char *dest)
 
     ptr = strdup(dest);
     if (ptr == NULL) {
-        return 0;
+        return ISO_OUT_OF_MEM;
     }
 
     ret = 1;
@@ -1216,7 +1215,7 @@ int iso_node_is_valid_link_dest(const char *dest)
     while (component) {
         if (strcmp(component, ".") && strcmp(component, "..")) {
             ret = iso_node_is_valid_name(component);
-            if (ret == 0) {
+            if (ret < 0) {
                 break;
             }
         }
@@ -1375,15 +1374,16 @@ int iso_node_new_root(IsoDir **root)
 int iso_node_new_dir(char *name, IsoDir **dir)
 {
     IsoDir *new;
+    int ret;
 
     if (dir == NULL || name == NULL) {
         return ISO_NULL_POINTER;
     }
 
     /* check if the name is valid */
-    if (!iso_node_is_valid_name(name)) {
-        return ISO_WRONG_ARG_VALUE;
-    }
+    ret = iso_node_is_valid_name(name);
+    if (ret < 0)
+        return ret;
 
     new = calloc(1, sizeof(IsoDir));
     if (new == NULL) {
@@ -1400,15 +1400,16 @@ int iso_node_new_dir(char *name, IsoDir **dir)
 int iso_node_new_file(char *name, IsoStream *stream, IsoFile **file)
 {
     IsoFile *new;
+    int ret;
 
     if (file == NULL || name == NULL || stream == NULL) {
         return ISO_NULL_POINTER;
     }
 
     /* check if the name is valid */
-    if (!iso_node_is_valid_name(name)) {
-        return ISO_WRONG_ARG_VALUE;
-    }
+    ret = iso_node_is_valid_name(name);
+    if (ret < 0)
+        return ret;
 
     new = calloc(1, sizeof(IsoFile));
     if (new == NULL) {
@@ -1428,21 +1429,21 @@ int iso_node_new_file(char *name, IsoStream *stream, IsoFile **file)
 int iso_node_new_symlink(char *name, char *dest, IsoSymlink **link)
 {
     IsoSymlink *new;
+    int ret;
 
     if (link == NULL || name == NULL || dest == NULL) {
         return ISO_NULL_POINTER;
     }
 
     /* check if the name is valid */
-    if (!iso_node_is_valid_name(name)) {
-        return ISO_WRONG_ARG_VALUE;
-    }
+    ret = iso_node_is_valid_name(name);
+    if (ret < 0)
+        return ret;
 
     /* check if destination is valid */
-    if (!iso_node_is_valid_link_dest(dest)) {
-        /* guard against null or empty dest */
-        return ISO_WRONG_ARG_VALUE;
-    }
+    ret = iso_node_is_valid_link_dest(dest);
+    if (ret < 0) 
+        return ret;
 
     new = calloc(1, sizeof(IsoSymlink));
     if (new == NULL) {
@@ -1464,6 +1465,7 @@ int iso_node_new_special(char *name, mode_t mode, dev_t dev,
                          IsoSpecial **special)
 {
     IsoSpecial *new;
+    int ret;
 
     if (special == NULL || name == NULL) {
         return ISO_NULL_POINTER;
@@ -1473,9 +1475,9 @@ int iso_node_new_special(char *name, mode_t mode, dev_t dev,
     }
 
     /* check if the name is valid */
-    if (!iso_node_is_valid_name(name)) {
-        return ISO_WRONG_ARG_VALUE;
-    }
+    ret = iso_node_is_valid_name(name);
+    if (ret < 0)
+        return ret;
 
     new = calloc(1, sizeof(IsoSpecial));
     if (new == NULL) {
@@ -1571,7 +1573,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;
@@ -1613,13 +1615,13 @@ 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++) {
+    for (i = 0; i < (int) num_attrs; i++) {
         if (strcmp(names[i], name))
     continue;
         *value_length = value_lengths[i];
         *value = calloc(*value_length + 1, 1);
         if (*value == NULL) {
-            ret = ISO_OUT_OF_MEM;
+            found = ISO_OUT_OF_MEM;
     break;
         }
         if (*value_length > 0)
@@ -2848,7 +2850,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/node.h

@@ -30,6 +30,29 @@
 #endif
 
 
+/* Maximum length of a leaf name in the libisofs node tree. This is currently
+   restricted by the implemented maximum length of a Rock Ridge name.
+   This might later become larger and may then be limited to smaller values.
+
+   Rock Ridge specs do not impose an explicit limit on name length.
+   But 255 is also specified by
+     http://pubs.opengroup.org/onlinepubs/009695399/basedefs/limits.h.html
+   which says
+     NAME_MAX >= _XOPEN_NAME_MAX = 255 
+*/
+#define LIBISOFS_NODE_NAME_MAX 255
+
+
+/* Maximum length of a path in the libisofs node tree.
+   Rock Ridge specs do not impose an explicit limit on path length.
+
+     http://pubs.opengroup.org/onlinepubs/009695399/basedefs/limits.h.html
+   says
+     PATH_MAX >= _XOPEN_PATH_MAX = 1024
+*/
+#define LIBISOFS_NODE_PATH_MAX 1024
+
+
 /**
  * The extended information is a way to attach additional information to each
  * IsoNode. External applications may want to use this extension system to
@@ -286,7 +309,7 @@ int iso_node_new_special(char *name, mode_t mode, dev_t dev,
  * Check if a given name is valid for an iso node.
  *
  * @return
- *     1 if yes, 0 if not
+ *     1 if yes, <0 if not. The value is a specific ISO_* error code.
  */
 int iso_node_is_valid_name(const char *name);
 

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 
@@ -337,7 +337,12 @@ static
 int rrip_add_NM(Ecma119Image *t, struct susp_info *susp, char *name, int size,
                 int flags, int ce)
 {
-    uint8_t *NM = malloc(size + 5);
+    uint8_t *NM;
+
+    if (size > 250)
+        return ISO_ASSERT_FAILURE;
+
+    NM = malloc(size + 5);
     if (NM == NULL) {
         return ISO_OUT_OF_MEM;
     }
@@ -445,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;
 
@@ -945,6 +950,7 @@ int aaip_xinfo_cloner(void *old_data, void **new_data, int flag)
  *                     (*su_size and *ce stay unaltered in this case)
  *                 <0= error:
  *                 -1= not enough SUA space for 28 bytes of CE entry
+ *                 -2= out of memory
  */
 static
 int susp_calc_nm_sl_al(Ecma119Image *t, Ecma119Node *n, size_t space,
@@ -981,6 +987,9 @@ int susp_calc_nm_sl_al(Ecma119Image *t, Ecma119Node *n, size_t space,
         if (!(flag & 1))
             goto unannounced_ca;
         namelen = namelen - (space - *su_size - 5);
+
+        /* >>> Need to handle lengths > 250 */;
+
         *ce = 5 + namelen;
         *su_size = space;
     }
@@ -993,6 +1002,8 @@ int susp_calc_nm_sl_al(Ecma119Image *t, Ecma119Node *n, size_t space,
         int cew = (*ce != 0); /* are we writing to CA ? */
 
         dest = get_rr_fname(t, ((IsoSymlink*)n->node)->dest);
+        if (dest == NULL)
+            return -2;
         prev = dest;
         cur = strchr(prev, '/');
         while (1) {
@@ -1021,8 +1032,10 @@ int susp_calc_nm_sl_al(Ecma119Image *t, Ecma119Node *n, size_t space,
                      * TODO this can be handled better, but for now SL
                      * will be completelly moved into the CA
                      */
-                    if (!(flag & 1))
+                    if (!(flag & 1)) {
+                        free(dest);
                         goto unannounced_ca;
+                    }
                     cew = 1;
                 } else {
                     sl_len += clen;
@@ -1041,8 +1054,8 @@ int susp_calc_nm_sl_al(Ecma119Image *t, Ecma119Node *n, size_t space,
                          * First, we check how many bytes fit in current
                          * SL field 
                          */
-                        int fit = 255 - sl_len - 2;
-                        if (clen - 250 <= fit) {
+                        ssize_t fit = 255 - sl_len - 2;
+                        if ((ssize_t) (clen - 250) <= fit) {
                             /* 
                              * the component can be divided between this
                              * and another SL entry
@@ -1236,13 +1249,16 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t used_up,
         /* Try without CE */
         ret = susp_calc_nm_sl_al(t, n, space, &su_size, ce, 0);
         if (ret == 0) /* Retry with CE */
-            susp_calc_nm_sl_al(t, n, space, &su_size, ce, 1);
+            ret = susp_calc_nm_sl_al(t, n, space, &su_size, ce, 1);
+        if (ret == -2)
+           return ISO_OUT_OF_MEM;
 
     } else {
 
         /* "." or ".." entry */
 
-        su_size += 5; /* NM field */
+        if (!t->rrip_version_1_10)
+            su_size += 5; /* NM field */
 
         if (type == 1 && n->parent == NULL) {
             /* 
@@ -1327,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;
@@ -1339,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;
     }
 
@@ -1423,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;
     }
 
@@ -1445,12 +1461,18 @@ 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 */
-            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;
         }
+        if (ret == -2) {
+           ret = ISO_OUT_OF_MEM;
+           goto add_susp_cleanup;
+        }
 
         /* NM entry */
         if (5 + namelen <= sua_free) {
@@ -1535,8 +1557,8 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
                              * First, we check how many bytes fit in current
                              * SL field 
                              */
-                            int fit = 255 - sl_len - 2;
-                            if (clen - 250 <= fit) {
+                            ssize_t fit = 255 - sl_len - 2;
+                            if ((ssize_t) (clen - 250) <= fit) {
                                 /* 
                                  * the component can be divided between this
                                  * and another SL entry
@@ -1648,6 +1670,9 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
             /* 
              * ..and the part that goes to continuation area.
              */
+
+            /* >>> Need a loop to handle lengths > 250 */;
+
             ret = rrip_add_NM(t, info, name + namelen, strlen(name + namelen),
                               0, 1);
             if (ret < 0) {
@@ -1689,9 +1714,36 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
         /* "." or ".." entry */
 
         /* write the NM entry */
-        ret = rrip_add_NM(t, info, NULL, 0, 1 << type, 0);
-        if (ret < 0) {
-            goto add_susp_cleanup;
+        if (t->rrip_version_1_10) {
+            /* RRIP-1.10:
+               "NM" System Use Fields recorded for the ISO 9660 directory
+                records with names (00) and (01), used to designate the
+                current and parent directories, respectively, should be
+                ignored. Instead, the receiving system should convert these
+                names to the appropriate receiving system-dependent
+                designations for the current and parent directories.
+            */
+            /* mkisofs obviously writes no NM for '.' and '..' .
+               Program isoinfo shows empty names with records as of RRIP-1.12
+            */
+            /* no op */;
+        } else {
+            /* RRIP-1.12:
+               If the ISO 9660 Directory Record File Identifier is (00), then
+               the CURRENT bit of the "NM" Flags field [...], if present, shall
+               be set to ONE. If the ISO 9660 Directory Record File Identifier
+               is (01), then the PARENT bit of the "NM" Flags field [...],
+               if present, shall be set to ONE.
+               [...]
+               "BP 3 - Length (LEN_NM)" shall specify as an 8-bit number the
+               length in bytes [...]. If bit position 1, 2, or 5 of the "NM"
+               Flags is set to ONE, the value of this field shall be 5 and no
+               Name Content shall be recorded.
+               [The CURRENT bit has position 1. The PARENT bit has position 2.]
+            */
+            ret = rrip_add_NM(t, info, NULL, 0, 1 << type, 0);
+            if (ret < 0)
+                goto add_susp_cleanup;
         }
 
         if (type == 1 && n->parent == NULL) {
@@ -1799,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], 
@@ -1830,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;
-            int nblocks;
+            uint32_t block, nblocks;
 
             /* A CE has found, there is another continuation area */
             nblocks = DIV_UP(iter->ce_off + iter->ce_len, BLOCK_SIZE);

libisofs/stream.c

@@ -16,6 +16,7 @@
 #include "stream.h"
 #include "fsource.h"
 #include "util.h"
+#include "node.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -397,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;
     }
@@ -646,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 */
     }
 
@@ -769,7 +770,7 @@ IsoStreamIface mem_stream_class = {
  * When the Stream refcount reach 0, the buffer is free(3).
  *
  * @return
- *      1 sucess, < 0 error
+ *      1 success, < 0 error
  */
 int iso_memory_stream_new(unsigned char *buf, size_t size, IsoStream **stream)
 {
@@ -868,7 +869,12 @@ 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);
-        strncpy(name, path, PATH_MAX);
+        if (path == NULL) {
+            name[0] = 0;
+            return;
+        }
+        strncpy(name, path, PATH_MAX - 1);
+        name[PATH_MAX - 1] = 0;
         free(path);
     } else if (!strncmp(type, "boot", 4)) {
         strcpy(name, "BOOT CATALOG");
@@ -1074,14 +1080,15 @@ int iso_stream_read_buffer(IsoStream *stream, char *buf, size_t count,
 */  
 int iso_stream_make_md5(IsoStream *stream, char md5[16], int flag)
 {
-    int res, is_open = 0;
-    char buffer[2048];
+    int ret, is_open = 0;
+    char * buffer = NULL;
     void *ctx= NULL;
     off_t file_size;
     uint32_t b, nblocks;
     size_t got_bytes;
     IsoStream *input_stream;
 
+    LIBISO_ALLOC_MEM(buffer, char, 2048);
     if (flag & 1) {
         while(1) {
            input_stream = iso_stream_get_input_stream(stream, 0);
@@ -1092,36 +1099,37 @@ int iso_stream_make_md5(IsoStream *stream, char md5[16], int flag)
     }
 
     if (! iso_stream_is_repeatable(stream))
-        return 0;
-    res = iso_md5_start(&ctx);
-    if (res < 0)
-        return res;
-    res = iso_stream_open(stream);
-    if (res < 0)
-        return 0;
+        {ret = 0; goto ex;}
+    ret = iso_md5_start(&ctx);
+    if (ret < 0)
+        goto ex;
+    ret = iso_stream_open(stream);
+    if (ret < 0)
+        goto ex;
     is_open = 1;
     file_size = iso_stream_get_size(stream);
     nblocks = DIV_UP(file_size, 2048);
     for (b = 0; b < nblocks; ++b) {
-        res = iso_stream_read_buffer(stream, buffer, 2048, &got_bytes);
-        if (res < 0) {
-            res = 0;
+        ret = iso_stream_read_buffer(stream, buffer, 2048, &got_bytes);
+        if (ret < 0) {
+            ret = 0;
             goto ex;
         }
         /* Do not use got_bytes to stay closer to IsoFileSrc processing */
         if (file_size - b * 2048 > 2048)
-            res = 2048;
+            ret = 2048;
         else
-            res = file_size - b * 2048;
-        iso_md5_compute(ctx, buffer, res);
+            ret = file_size - b * 2048;
+        iso_md5_compute(ctx, buffer, ret);
     }
-    res = 1;
+    ret = 1;
 ex:;
     if (is_open)
         iso_stream_close(stream);
     if (ctx != NULL)
         iso_md5_end(&ctx, md5);
-    return res;
+    LIBISO_FREE_MEM(buffer);
+    return ret;
 }
 
 /* API */

libisofs/stream.h

@@ -29,7 +29,8 @@ typedef struct
 /**
  * Get an identifier for the file of the source, for debug purposes
  * @param name
- *      Should provide at least PATH_MAX bytes
+ *      Must provide at least PATH_MAX bytes. If no PATH_MAX is defined
+ *      then assume PATH_MAX = Libisofs_default_path_maX from libisofs.h
  */
 void iso_stream_get_file_name(IsoStream *stream, char *name);
 

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 
@@ -305,9 +305,9 @@ static int boot_nodes_from_iso_path(Ecma119Image *t, char *path,
     int ret;
 
     ret = iso_tree_path_to_node(t->image, path, iso_node);
-    if (ret < 0) {
+    if (ret <= 0) {
         iso_msg_submit(t->image->id, ISO_BOOT_FILE_MISSING, 0,
-                       "Cannot find %s '%s'", purpose, path);
+                       "Cannot find in ISO image: %s '%s'", purpose, path);
         return ISO_BOOT_FILE_MISSING;
     }
     if ((*iso_node)->type != LIBISO_FILE) {
@@ -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;
 }
 
 
@@ -809,3 +813,122 @@ int iso_write_system_area(Ecma119Image *t, uint8_t *buf)
 
     return ISO_SUCCESS;
 }
+
+/* Choose *heads_per_cyl so that
+   - *heads_per_cyl * secs_per_head * 1024 >= imgsize / 512
+   - *heads_per_cyl * secs_per_head is divisible by 4
+   - it is as small as possible (to reduce aligment overhead)
+   - it is <= 255
+   @return 1= success , 0= cannot achieve goals
+*/
+static
+int try_sph(off_t imgsize, int secs_per_head, int *heads_per_cyl, int flag)
+{
+    off_t hd_blocks, hpc;
+
+    hd_blocks= imgsize / 512;
+    hpc = hd_blocks / secs_per_head / 1024;
+    if (hpc * secs_per_head * 1024 < hd_blocks)
+        hpc++;
+    if ((secs_per_head % 4) == 0) {
+        ;
+    } else if ((secs_per_head % 2) == 0) {
+        hpc += (hpc % 2);
+    } else if(hpc % 4) {
+        hpc += 4 - (hpc % 4);
+    }
+    if (hpc > 255)
+        return 0;
+    *heads_per_cyl = hpc;
+    return 1;
+}
+
+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 = NULL;
+
+    LIBISO_ALLOC_MEM(msg, char, 160);
+    sa_type = (t->system_area_options >> 2) & 0x3f;
+    if (sa_type != 0)
+        {ret = ISO_SUCCESS; goto ex;}
+    always_align = (t->system_area_options >> 8) & 3;
+
+    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
+                    * 1024) * (off_t) 512 < imgsize) {
+        /* Choose small values which can represent the image size */
+        /* First try 32 sectors per head */
+        ret = try_sph(imgsize, 32, &(t->partition_heads_per_cyl), 0);
+        if (ret == 1) {
+            t->partition_secs_per_head = 32;
+        } else {
+            /* Did not work with 32. Try 63 */
+            t->partition_secs_per_head = 63;
+            ret = try_sph(imgsize, 63, &(t->partition_heads_per_cyl), 0);
+            if (ret != 1)
+                t->partition_heads_per_cyl = 255;
+        }
+        cylsize = t->partition_heads_per_cyl * t->partition_secs_per_head *512;
+        frac = imgsize % cylsize;
+        sprintf(msg, "Automatically adjusted MBR geometry to %d/%d/%d",
+                      (int) (imgsize / cylsize + !!frac),
+                      t->partition_heads_per_cyl, t->partition_secs_per_head);
+        iso_msgs_submit(0, msg, 0, "NOTE", 0);
+    }
+
+    if (always_align >= 2)
+        {ret = ISO_SUCCESS; goto ex;}
+
+    cylsize = 0;
+    if (t->catalog != NULL &&
+               (t->catalog->bootimages[0]->isolinux_options & 0x0a) == 0x02) {
+        /* Check for isolinux image with magic number of 3.72 and produce
+           an MBR from our built-in template. (Deprecated since 31 Mar 2010)
+        */
+        if (img_blocks >= 0x40000000)
+            {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 */
+        if (t->catalog == NULL || t->system_area_data == NULL) {
+            /* isohybrid makes only sense together with ISOLINUX boot image
+               and externally provided System Area.
+            */
+            {ret = ISO_ISOLINUX_CANT_PATCH; goto ex;}
+        }
+        cylsize = t->partition_heads_per_cyl * t->partition_secs_per_head
+                  * 512;
+    } 
+    if (cylsize == 0)
+        {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);
+        {ret = ISO_SUCCESS; goto ex;}
+    }
+
+    frac = imgsize % cylsize;
+    imgsize += (frac > 0 ? cylsize - frac : 0);
+
+    frac = imgsize - ((off_t) img_blocks) * (off_t) 2048;
+    if (frac == 0)
+        {ret = ISO_SUCCESS; goto ex;}
+    if (frac % 2048) {
+        sprintf(msg,
+             "Cylinder size %d not divisible by 2048. Cannot align partition.",
+             (int) cylsize);
+        iso_msgs_submit(0, msg, 0, "WARNING", 0);
+    } else {
+        t->tail_blocks += frac / 2048;
+    }
+    ret = ISO_SUCCESS;
+ex:;
+    LIBISO_FREE_MEM(msg);
+    return ret;
+}

libisofs/system_area.h

@@ -46,6 +46,11 @@ int make_isohybrid_mbr(int bin_lba, int *img_blocks, char *mbr, int flag);
  */
 int iso_write_system_area(Ecma119Image *t, uint8_t *buf);
 
+/**
+ * Adjust t->tail_blocks to the eventual alignment needs of isohybrid booting.
+ */
+int iso_align_isohybrid(Ecma119Image *t, int flag);
+
 
 /** 
  * Read the necessary ELF information from the first MIPS boot file.

libisofs/tree.c

@@ -32,11 +32,6 @@
 #include <fnmatch.h>
 
 
-#ifndef PATH_MAX
-#define PATH_MAX Libisofs_default_path_maX
-#endif
-
-
 /**
  * Add a new directory to the iso tree.
  * 
@@ -483,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 * 
@@ -579,20 +574,19 @@ int iso_tree_add_new_node(IsoImage *image, IsoDir *parent, const char *name,
         *node = NULL;
     }
 
-    fs = image->fs;
-    result = fs->get_by_path(fs, path, &file);
-    if (result < 0) {
-        return result;
-    }
-
     /* find place where to insert */
     result = iso_dir_exists(parent, name, &pos);
     if (result) {
         /* a node with same name already exists */
-        iso_file_source_unref(file);
         return ISO_NODE_NAME_NOT_UNIQUE;
     }
 
+    fs = image->fs;
+    result = fs->get_by_path(fs, path, &file);
+    if (result < 0) {
+        return result;
+    }
+
     result = image->builder->create_node(image->builder, image, file, &new);
     
     /* free the file */
@@ -767,11 +761,16 @@ int iso_add_dir_src_rec(IsoImage *image, IsoDir *parent, IsoFileSource *dir)
 
     ret = iso_file_source_open(dir);
     if (ret < 0) {
-        char *path = iso_file_source_get_path(dir);
+        path = iso_file_source_get_path(dir);
         /* instead of the probable error, we throw a sorry event */
-        ret = iso_msg_submit(image->id, ISO_FILE_CANT_ADD, ret, 
-                             "Can't open dir %s", path);
-        free(path);
+	if (path != NULL) {
+            ret = iso_msg_submit(image->id, ISO_FILE_CANT_ADD, ret, 
+                                 "Can't open dir %s", path);
+            free(path);
+        } else {
+            ret = iso_msg_submit(image->id, ISO_NULL_POINTER, ret,
+                           "Can't open dir. NULL pointer caught as dir name");
+        }
         return ret;
     }
 
@@ -791,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) {
@@ -853,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 {
@@ -973,26 +977,33 @@ int iso_tree_path_to_node(IsoImage *image, const char *path, IsoNode **node)
 
 char *iso_tree_get_node_path(IsoNode *node)
 {
-    if (node == NULL || node->parent == NULL) {
+    char *path = NULL, *parent_path = NULL;
+
+    if (node == NULL || node->parent == NULL)
         return NULL;
-    }
     
     if ((IsoNode*)node->parent == node) {
         return strdup("/");
     } else {
-        char path[PATH_MAX];
-        char *parent_path = iso_tree_get_node_path((IsoNode*)node->parent);
-        if (parent_path == NULL) {
-            return NULL;
-        }
+        parent_path = iso_tree_get_node_path((IsoNode*)node->parent);
+        if (parent_path == NULL)
+            goto ex;
         if (strlen(parent_path) == 1) {
-            snprintf(path, PATH_MAX, "/%s", node->name);
+            path = calloc(1, strlen(node->name) + 2);
+            if (path == NULL)
+                goto ex;
+            sprintf(path, "/%s", node->name);
         } else {
-            snprintf(path, PATH_MAX, "%s/%s", parent_path, node->name);
+            path = calloc(1, strlen(parent_path) + strlen(node->name) + 2);
+            if (path == NULL)
+                goto ex;
+            sprintf(path, "%s/%s", parent_path, node->name);
         }
-        free(parent_path);
-        return strdup(path);
     }
+ex:;
+    if (parent_path != NULL)
+        free(parent_path);
+    return path;
 }
 
 /* ------------------------- tree cloning ------------------------------ */

libisofs/util.c

@@ -16,6 +16,7 @@
 #include "util.h"
 #include "libisofs.h"
 #include "messages.h"
+#include "joliet.h"
 #include "../version.h"
 
 #include <stdlib.h>
@@ -218,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;
@@ -268,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;
@@ -335,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 */
@@ -434,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;
@@ -565,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;
@@ -635,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++) {
@@ -769,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);
@@ -837,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) {
@@ -916,16 +917,23 @@ ex:;
 
 /*
    bit0= no_force_dots
+   bit1= allow 103 characters rather than 64
 */
 uint16_t *iso_j_file_id(const uint16_t *src, int flag)
 {
-    uint16_t *dot;
-    size_t lname, lext, lnname, lnext, pos, i;
-    uint16_t dest[66]; /* 66 = 64 (name + ext) + 1 (.) + 1 (\0) */
+    uint16_t *dot, *retval = NULL;
+    size_t lname, lext, lnname, lnext, pos, i, maxchar = 64;
+    uint16_t *dest = NULL;
+    int ret;
+
+    LIBISO_ALLOC_MEM(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;
 
     dot = ucsrchr(src, '.');
 
@@ -937,18 +945,19 @@ uint16_t *iso_j_file_id(const uint16_t *src, int flag)
      */
     if (dot == NULL || cmp_ucsbe(dot + 1, '\0') == 0) {
         lname = ucslen(src);
-        lnname = (lname > 64) ? 64 : lname;
+        lnname = (lname > maxchar) ? maxchar : lname;
         lext = lnext = 0;
     } else {
         lext = ucslen(dot + 1);
         lname = ucslen(src) - lext - 1;
-        lnext = (ucslen(src) > 65 && lext > 3) ? (lname < 61 ? 64 - lname : 3)
+        lnext = (ucslen(src) > maxchar + 1 && lext > 3)
+                ? (lname < maxchar - 3 ? maxchar - lname : 3)
                 : lext;
-        lnname = (ucslen(src) > 65) ? 64 - lnext : lname;
+        lnname = (ucslen(src) > maxchar + 1) ? maxchar - lnext : lname;
     }
 
     if (lnname == 0 && lnext == 0) {
-        return NULL;
+        goto ex;
     }
 
     pos = 0;
@@ -983,21 +992,31 @@ 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;
 }
 
-uint16_t *iso_j_dir_id(const uint16_t *src)
+/* @param flag bit1= allow 103 characters rather than 64
+*/
+uint16_t *iso_j_dir_id(const uint16_t *src, int flag)
 {
-    size_t len, i;
-    uint16_t dest[65]; /* 65 = 64 + 1 (\0) */
+    size_t len, i, maxchar = 64;
+    uint16_t *dest = NULL, *retval = NULL;
+    int ret;
+                                                    /* was: 65 = 64 + 1 (\0) */
+    LIBISO_ALLOC_MEM(dest, uint16_t, LIBISO_JOLIET_NAME_MAX);
 
     if (src == NULL) {
-        return NULL;
+        goto ex;
     }
+    if (flag & 2)
+        maxchar = 103;
 
     len = ucslen(src);
-    if (len > 64) {
-        len = 64;
+    if (len > maxchar) {
+        len = maxchar;
     }
     for (i = 0; i < len; i++) {
         uint16_t c = src[i];
@@ -1008,7 +1027,10 @@ uint16_t *iso_j_dir_id(const uint16_t *src)
         }
     }
     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)
@@ -1526,16 +1548,17 @@ char *iso_util_strcopy(const char *buf, size_t len)
     return str;
 }
 
-char *iso_util_strcopy_untail(const char *buf, size_t len)
+char *iso_util_strcopy_untail(const char *buf, size_t len_in)
 {
     char *str;
+    int len;
     
-    str = iso_util_strcopy(buf, len);
+    str = iso_util_strcopy(buf, len_in);
     if (str == NULL) {
         return NULL;
     }
     /* remove trailing spaces */
-    for (len = len-1; len >= 0; --len) {
+    for (len = len_in - 1; len >= 0; --len) {
         if (str[len] != ' ')
     break;
         str[len] = 0; 
@@ -1590,7 +1613,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;
     }
@@ -1827,12 +1850,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)) {
@@ -1840,10 +1863,24 @@ unexpected_type:;
         iso_msg_submit(-1, ISO_MD5_TAG_UNEXPECTED, 0, NULL);
         ret = 0;
         goto ex;
-    } else if(pos != lba) {
+    } else if (pos != lba) {
+        if (*tag_type == 2) { /* Superblock tag */
+            if (lba < 32) {
+                /* Check whether this is a copied superblock */
+                range_start -= (off_t) pos - (off_t) lba;
+                if (range_start != ctx_start_lba) {
+
+                    /* >>> check for matching MD5 ? */;
+
+                    ret = ISO_MD5_TAG_MISPLACED;
+                } else
+                    ret = ISO_MD5_TAG_COPIED;
+                goto ex;
+            }
+        }
         ret = ISO_MD5_TAG_MISPLACED;
         goto ex;
-    } else if(range_start != ctx_start_lba) {
+    } else if (range_start != ctx_start_lba) {
         ret = ISO_MD5_TAG_MISPLACED;
     }
     ret = iso_md5_clone(ctx, &cloned_ctx);
@@ -1861,4 +1898,14 @@ ex:;
     return ret;
 }
 
+
+void *iso_alloc_mem(size_t size, size_t count, int flag)
+{
+    void *pt;
+
+    pt = calloc(size, count);
+    if(pt == NULL)
+	iso_msg_submit(-1, ISO_OUT_OF_MEM, 0, "Out of virtual memory");
+    return pt;
+}
  

libisofs/util.h

@@ -153,13 +153,15 @@ char *iso_r_fileid(const char *src, size_t len, int relaxed, int forcedot);
 
 /**
  * Create a Joliet file identifier that consists of name and extension. The 
- * combined name and extension length will not exceed 128 bytes, and the 
- * name and extension will be separated (.). All characters consist of 
- * 2 bytes and the resulting string is NULL-terminated by a 2-byte NULL. 
+ * combined name and extension length will normally not exceed 64 characters
+ * (= 128 bytes). The name and the extension will be separated (.).
+ * All characters consist of 2 bytes and the resulting string is
+ * NULL-terminated by a 2-byte NULL. 
  * 
  * Note that version number and (;1) is not appended.
  * @param flag
  *        bit0= no_force_dots
+ *        bit1= allow 103 characters rather than 64
  * @return 
  *        NULL if the original name and extension both are of length 0.
  */
@@ -171,10 +173,12 @@ uint16_t *iso_j_file_id(const uint16_t *src, int flag);
  * and the name and extension will be separated (.). All characters consist of 
  * 2 bytes and the resulting string is NULL-terminated by a 2-byte NULL. 
  * 
+ * @param flag
+ *        bit1= allow 103 characters rather than 64
  * @return 
  *        NULL if the original name and extension both are of length 0.
  */
-uint16_t *iso_j_dir_id(const uint16_t *src);
+uint16_t *iso_j_dir_id(const uint16_t *src, int flag);
 
 /**
  * Like strlen, but for Joliet strings.
@@ -535,4 +539,18 @@ 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_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 */