joliet.c File Reference

#include <schily/mconfig.h>
#include "mkisofs.h"
#include <schily/time.h>
#include <schily/utypes.h>
#include <schily/intcvt.h>
#include <schily/schily.h>
#include <schily/errno.h>

Include dependency graph for joliet.c:

Go to the source code of this file.

Functions
LOCAL void convert_to_unicode	__PR ((unsigned char *buffer, int size, char *source, siconvt_t *inls))
LOCAL int joliet_strlen	__PR ((const char *string, size_t maxlen, siconvt_t *inls))
LOCAL void get_joliet_vol_desc	__PR ((struct iso_primary_descriptor *jvol_desc))
LOCAL void assign_joliet_directory_addresses	__PR ((struct directory *node))
LOCAL int joliet_compare_paths	__PR ((void const *r, void const *l))
LOCAL int generate_joliet_path_tables	__PR ((void))
LOCAL void generate_one_joliet_directory	__PR ((struct directory *dpnt, FILE *outfile))
LOCAL int joliet_sort_n_finish	__PR ((struct directory *this_dir))
LOCAL int joliet_compare_dirs	__PR ((const void *rr, const void *ll))
LOCAL int joliet_sort_directory	__PR ((struct directory_entry **sort_dir))
LOCAL void generate_joliet_directories	__PR ((struct directory *node, FILE *outfile))
LOCAL int jpathtab_write	__PR ((FILE *outfile))
LOCAL int jdirtree_size	__PR ((UInt32_t starting_extent))
EXPORT void	conv_charset (unsigned char *to, size_t *tosizep, unsigned char *from, size_t *fromsizep, siconvt_t *inls, siconvt_t *onls)
LOCAL void	convert_to_unicode (unsigned char *buffer, int size, char *source, siconvt_t *inls)
LOCAL int	joliet_strlen (char *string, size_t maxlen, siconvt_t *inls) const
LOCAL void	get_joliet_vol_desc (struct iso_primary_descriptor *jvol_desc)
LOCAL void	assign_joliet_directory_addresses (struct directory *node)
LOCAL void	build_jpathlist (struct directory *node)
LOCAL int	joliet_compare_paths (void const *r, void const *l)
LOCAL int	generate_joliet_path_tables ()
LOCAL void	generate_one_joliet_directory (struct directory *dpnt, FILE *outfile)
LOCAL int	joliet_sort_n_finish (struct directory *this_dir)
LOCAL int	joliet_compare_dirs (void *rr, const void *ll) const
LOCAL int	joliet_sort_directory (struct directory_entry **sort_dir)
EXPORT int	joliet_sort_tree (struct directory *node)
LOCAL void	generate_joliet_directories (struct directory *node, FILE *outfile)
LOCAL int	jpathtab_write (FILE *outfile)
LOCAL int	jdirtree_size (UInt32_t starting_extent)
LOCAL int	jroot_gen ()
LOCAL int	jdirtree_write (FILE *outfile)
LOCAL int	jvd_write (FILE *outfile)
LOCAL int	jpathtab_size (UInt32_t starting_extent)

Variables
static UConst char	sccsid []
LOCAL Uint	jpath_table_index
LOCAL struct directory **	jpathlist
LOCAL int	next_jpath_index = 1
LOCAL int	jsort_goof
LOCAL int	jsort_glen
LOCAL char	ucs_codes []
struct output_fragment	joliet_desc = {NULL, oneblock_size, jroot_gen, jvd_write, "Joliet Volume Descriptor" }
struct output_fragment	jpathtable_desc = {NULL, jpathtab_size, generate_joliet_path_tables, jpathtab_write, "Joliet path table" }
struct output_fragment	jdirtree_desc = {NULL, jdirtree_size, NULL, jdirtree_write, "Joliet directory tree" }

Function Documentation

__PR() [1/13]

LOCAL int joliet_strlen __PR

(

(const char *string, size_t maxlen, siconvt_t *inls)

)

__PR() [2/13]

LOCAL int joliet_compare_dirs __PR

(

(const void *rr, const void *ll)

)

__PR() [3/13]

LOCAL int jpathtab_write __PR

(

(FILE *outfile)

)

__PR() [4/13]

LOCAL void generate_one_joliet_directory __PR

(

(struct directory *dpnt, FILE *outfile)

)

__PR() [5/13]

LOCAL void assign_joliet_directory_addresses __PR

(

(struct directory *node)

)

__PR() [6/13]

LOCAL void generate_joliet_directories __PR

(

(struct directory *node, FILE *outfile)

)

__PR() [7/13]

LOCAL int joliet_sort_n_finish __PR

(

(struct directory *this_dir)

)

__PR() [8/13]

LOCAL int joliet_sort_directory __PR

(

(struct directory_entry **sort_dir)

)

__PR() [9/13]

LOCAL void get_joliet_vol_desc __PR

(

(struct iso_primary_descriptor *jvol_desc)

)

__PR() [10/13]

LOCAL int jdirtree_size __PR

(

(UInt32_t starting_extent)

)

__PR() [11/13]

LOCAL void convert_to_unicode __PR

(

(unsigned char *buffer, int size, char *source, siconvt_t *inls)

)

__PR() [12/13]

LOCAL int joliet_compare_paths __PR

(

(void const *r, void const *l)

)

__PR() [13/13]

LOCAL int generate_joliet_path_tables __PR

(

(void)

)

assign_joliet_directory_addresses()

LOCAL void assign_joliet_directory_addresses

(

struct directory *

node

)

Definition at line 492 of file joliet.c.

{
    int     dir_size;
    struct directory *dpnt;
 
    dpnt = node;
 
    while (dpnt) {
        if ((dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) == 0) {
            /*
             * If we already have an extent for this
             * (i.e. it came from a multisession disc), then
             * don't reassign a new extent.
             */
            dpnt->jpath_index = next_jpath_index++;
            if (dpnt->jextent == 0) {
                dpnt->jextent = last_extent;
                dir_size = ISO_BLOCKS(dpnt->jsize);
                last_extent += dir_size;
            }
        }
        /* skip if hidden - but not for the rr_moved dir */
        if (dpnt->subdir &&
            ((dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) == 0 ||
            dpnt == reloc_dir)) {
            assign_joliet_directory_addresses(dpnt->subdir);
        }
        dpnt = dpnt->next;
    }
}

Referenced by assign_joliet_directory_addresses(), and jdirtree_size().

build_jpathlist()

LOCAL void build_jpathlist

(

struct directory *

node

)

Definition at line 525 of file joliet.c.

{
    struct directory    *dpnt;
 
    dpnt = node;
 
    while (dpnt) {
        if ((dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) == 0) {
            jpathlist[dpnt->jpath_index] = dpnt;
        }
        if (dpnt->subdir)
            build_jpathlist(dpnt->subdir);
        dpnt = dpnt->next;
    }
} /* build_jpathlist(... */

Referenced by build_jpathlist(), and generate_joliet_path_tables().

conv_charset()

EXPORT void conv_charset	(	unsigned char *	to,
		size_t *	tosizep,
		unsigned char *	from,
		size_t *	fromsizep,
		siconvt_t *	inls,
		siconvt_t *	onls
	)

Definition at line 148 of file joliet.c.

{
    UInt16_t    unichar;
    size_t      fromsize = *fromsizep;
    size_t      tosize   = *tosizep;
    Uchar       ob[2];          /* 2 octets (16 Bit) UCS-2 */
 
    if (fromsize == 0 || tosize == 0)
        return;
 
    /*
     * If we have a null mapping, just return the input character
     */
    if (inls->sic_name == onls->sic_name) {
        *to = *from;
        (*fromsizep)--;
        (*tosizep)--;
        return;
    }
#ifdef  USE_ICONV
#ifdef  HAVE_ICONV_CONST
#define __IC_CONST  const
#else
#define __IC_CONST
#endif
    if (use_iconv(inls)) {
        char    *obuf = (char *)ob;
        size_t  osize = 2;      /* UCS-2 character size */
 
        if (iconv(inls->sic_cd2uni, (__IC_CONST char **)&from,
                    fromsizep,
                    &obuf, &osize) == -1) {
            int err = geterrno();
 
            if ((err == EINVAL || err == EILSEQ) &&
                *fromsizep == fromsize) {
                ob[0] = 0; ob[1] = '_';
                (*fromsizep)--;
            }
        }
        unichar = ob[0] * 256 + ob[1];  /* Compute 16 Bit UCS-2 char */
    } else
#endif
    {
        unsigned char c = *from;
 
        unichar = sic_c2uni(inls, c);   /* Get the UNICODE char */
        (*fromsizep)--;
 
        if (unichar == 0)
            unichar = '_';
 
        ob[0] = unichar >> 8 & 0xFF;    /* Compute 2 octet variant */
        ob[1] = unichar & 0xFF;
    }
 
#ifdef  USE_ICONV
    if (use_iconv(onls)) {
        char    *ibuf = (char *)ob;
        size_t  isize = 2;      /* UCS-2 character size */
 
        if (iconv(onls->sic_uni2cd, (__IC_CONST char **)&ibuf, &isize,
                    (char **)&to, tosizep) == -1) {
            int err = geterrno();
 
            if ((err == EINVAL || err == EILSEQ) &&
                *tosizep == tosize) {
                *to = '_';
                (*tosizep)--;
            }
        }
    } else
#endif
    {
        *to = sic_uni2c(onls, unichar); /* Get the backconverted char */
        (*tosizep)--;
    }
}

Referenced by iso9660_file_length(), and rstrncpy().

convert_to_unicode()

LOCAL void convert_to_unicode	(	unsigned char *	buffer,
		int	size,
		char *	source,
		siconvt_t *	inls
	)

Definition at line 247 of file joliet.c.

{
    unsigned char   *tmpbuf;
    int     i;
    int     j;
    UInt16_t    unichar;
    unsigned char   uc;
    int     jsize = size;
 
    /*
     * If we get a NULL pointer for the source, it means we have an
     * inplace copy, and we need to make a temporary working copy first.
     */
    if (source == NULL) {
        tmpbuf = (Uchar *) e_malloc(size);
        memcpy(tmpbuf, buffer, size);
    } else {
        tmpbuf = (Uchar *) source;
    }
 
    /*
     * Now start copying characters.  If the size was specified to be 0,
     * then assume the input was 0 terminated.
     */
    j = 0;
    for (i = 0; (i + 1) < size; i += 2, j++) {  /* Size may be odd! */
        /*
         * Let all valid unicode characters pass
         * through (according to charset). Others are set to '_' .
         */
        if (j < jsize)
            uc = tmpbuf[j];     /* temporary copy */
        else
            uc = '\0';
        if (uc == '\0') {
            jsize = j;
            unichar = 0;
        } else {            /* must be converted */
#ifdef  USE_ICONV
            if (use_iconv(inls)) {
                Uchar       ob[2];
                __IC_CONST char *inbuf = (char *)&tmpbuf[j];
                size_t  isize = 3;
                char    *obuf = (char *)ob;
                size_t  osize = 2;
 
                /*
                 * iconv() from glibc ignores osize and thus
                 * may try to access more than a single multi
                 * byte character from the input and read from
                 * non-existent memory.
                 */
                if (iconv(inls->sic_cd2uni, &inbuf, &isize,
                            &obuf, &osize) == -1) {
                    int err = geterrno();
 
                    if ((err == EINVAL || err == EILSEQ) &&
                        isize == 3) {
                        ob[0] = ob[1] = 0;
                        isize--;
                    }
                }
                unichar = ob[0] * 256 + ob[1];
                j += 2 - isize;
            } else
#endif
            unichar = sic_c2uni(inls, uc);  /* Get the UNICODE */
 
            /*
             * This code is currently also used for UDF formatting.
             * Do not enforce silly Microsoft limitations in case
             * that we only create UDF extensions.
             */
            if (!use_Joliet)
                goto all_chars;
 
            if (unichar <= 0x1f || unichar == 0x7f)
                unichar = '\0'; /* control char */
 
            switch (unichar) {  /* test special characters */
 
            case '*':
            case '/':
            case ':':
            case ';':
            case '?':
            case '\\':
            case '\0':      /* illegal char mark */
                /*
                 * Even Joliet has some standards as to what is
                 * allowed in a pathname. Pretty tame in
                 * comparison to what DOS restricts you to.
                 */
                unichar = '_';
            }
        all_chars:
            ;
        }
        buffer[i] = unichar >> 8 & 0xFF; /* final UNICODE */
        buffer[i + 1] = unichar & 0xFF; /* conversion */
    }
 
    if (size & 1) { /* beautification */
        buffer[size - 1] = 0;
    }
    if (source == NULL) {
        free(tmpbuf);
    }
}

Referenced by generate_joliet_path_tables(), generate_one_joliet_directory(), get_joliet_vol_desc(), joliet_compare_dirs(), and joliet_compare_paths().

generate_joliet_directories()

LOCAL void generate_joliet_directories	(	struct directory *	node,
		FILE *	outfile
	)

Definition at line 1341 of file joliet.c.

{
    struct directory *dpnt;
 
    dpnt = node;
 
    while (dpnt) {
        if ((dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) == 0) {
            /*
             * In theory we should never reuse a directory, so this
             * doesn't make much sense.
             */
            if (dpnt->jextent > session_start) {
                generate_one_joliet_directory(dpnt, outfile);
            }
        }
        /* skip if hidden - but not for the rr_moved dir */
        if (dpnt->subdir &&
            (!(dpnt->dir_flags & INHIBIT_JOLIET_ENTRY) ||
            dpnt == reloc_dir)) {
            generate_joliet_directories(dpnt->subdir, outfile);
        }
        dpnt = dpnt->next;
    }
}

Referenced by generate_joliet_directories(), and jdirtree_write().

generate_joliet_path_tables()

LOCAL int generate_joliet_path_tables

(

)

Definition at line 629 of file joliet.c.

{
    struct directory_entry *de;
    struct directory *dpnt;
    int     fix;
    int     j;
    int     namelen;
    char        *npnt;
    char        *npnt1;
    int     tablesize;
    unsigned int    jpindex;
 
    /* First allocate memory for the tables and initialize the memory */
    tablesize = jpath_blocks << 11;
    jpath_table_m = (char *)e_malloc(tablesize);
    jpath_table_l = (char *)e_malloc(tablesize);
    memset(jpath_table_l, 0, tablesize);
    memset(jpath_table_m, 0, tablesize);
 
    /* Now start filling in the path tables.  Start with root directory */
    jpath_table_index = 0;
    jpathlist = (struct directory **)e_malloc(sizeof (struct directory *)
        * next_jpath_index);
    memset(jpathlist, 0, sizeof (struct directory *) * next_jpath_index);
    build_jpathlist(root);
 
    do {
        fix = 0;
#ifdef  PROTOTYPES
        qsort(&jpathlist[1], next_jpath_index - 1, sizeof (struct directory *),
            (int (*) (const void *, const void *)) joliet_compare_paths);
#else
        qsort(&jpathlist[1], next_jpath_index - 1, sizeof (struct directory *),
            joliet_compare_paths);
#endif
 
        for (j = 1; j < next_jpath_index; j++) {
            if (jpathlist[j]->jpath_index != j) {
                jpathlist[j]->jpath_index = j;
                fix++;
            }
        }
    } while (fix);
 
    for (j = 1; j < next_jpath_index; j++) {
        dpnt = jpathlist[j];
        if (!dpnt) {
            comerrno(EX_BAD, _("Entry %d not in path tables\n"), j);
        }
        npnt = dpnt->de_name;
 
        npnt1 = strrchr(npnt, PATH_SEPARATOR);
        if (npnt1) {
            npnt = npnt1 + 1;
        }
        de = dpnt->self;
        if (!de) {
            comerrno(EX_BAD,
            _("Fatal Joliet goof - directory has amnesia\n"));
        }
#ifdef APPLE_HYB
        if (USE_MAC_NAME(de))
            namelen = joliet_strlen(de->hfs_ent->name, jlen, hfs_inls);
        else
#endif  /* APPLE_HYB */
            namelen = joliet_strlen(de->name, jlen, in_nls);
 
        if (dpnt == root) {
            jpath_table_l[jpath_table_index] = 1;
            jpath_table_m[jpath_table_index] = 1;
        } else {
            jpath_table_l[jpath_table_index] = namelen;
            jpath_table_m[jpath_table_index] = namelen;
        }
        jpath_table_index += 2;
 
        set_731(jpath_table_l + jpath_table_index, dpnt->jextent);
        set_732(jpath_table_m + jpath_table_index, dpnt->jextent);
        jpath_table_index += 4;
 
 
        if (dpnt->parent != reloc_dir) {
            set_721(jpath_table_l + jpath_table_index,
                dpnt->parent->jpath_index);
            set_722(jpath_table_m + jpath_table_index,
                dpnt->parent->jpath_index);
            jpindex = dpnt->parent->jpath_index;
        } else {
            set_721(jpath_table_l + jpath_table_index,
                dpnt->self->parent_rec->filedir->jpath_index);
            set_722(jpath_table_m + jpath_table_index,
                dpnt->self->parent_rec->filedir->jpath_index);
            jpindex = dpnt->self->parent_rec->filedir->jpath_index;
        }
 
        if (jpindex > 0xffff) {
            static int warned = 0;
 
            if (!warned) {
                warned++;
                errmsgno(EX_BAD,
            _("Unable to generate sane Joliet path tables - too many directories (%u)\n"),
                    jpindex);
                if (!nolimitpathtables)
                    errmsgno(EX_BAD,
                    _("Try to use the option -no-limit-pathtables\n"));
            }
            if (!nolimitpathtables)
                exit(EX_BAD);
            /*
             * Let it point to the root directory instead.
             */
            set_721(jpath_table_l + jpath_table_index, 1);
            set_722(jpath_table_m + jpath_table_index, 1);
        }
 
        jpath_table_index += 2;
 
        /*
         * The root directory is still represented in non-unicode
         * fashion.
         */
        if (dpnt == root) {
            jpath_table_l[jpath_table_index] = 0;
            jpath_table_m[jpath_table_index] = 0;
            jpath_table_index++;
        } else {
#ifdef APPLE_HYB
            if (USE_MAC_NAME(de)) {
                convert_to_unicode((Uchar *) jpath_table_l +
                    jpath_table_index,
                    namelen, de->hfs_ent->name, hfs_inls);
                convert_to_unicode((Uchar *) jpath_table_m +
                    jpath_table_index,
                    namelen, de->hfs_ent->name, hfs_inls);
            } else {
#endif  /* APPLE_HYB */
                convert_to_unicode((Uchar *) jpath_table_l +
                    jpath_table_index,
                    namelen, de->name, in_nls);
                convert_to_unicode((Uchar *) jpath_table_m +
                    jpath_table_index,
                    namelen, de->name, in_nls);
#ifdef APPLE_HYB
            }
#endif  /* APPLE_HYB */
 
            jpath_table_index += namelen;
        }
 
        if (jpath_table_index & 1) {
            jpath_table_index++;    /* For odd lengths we pad */
        }
    }
 
    free(jpathlist);
    if (jpath_table_index != jpath_table_size) {
        errmsgno(EX_BAD,
        _("Joliet path table lengths do not match %d expected: %d\n"),
            jpath_table_index,
            jpath_table_size);
    }
    return (0);
} /* generate_path_tables(... */

generate_one_joliet_directory()

LOCAL void generate_one_joliet_directory	(	struct directory *	dpnt,
		FILE *	outfile
	)

Definition at line 795 of file joliet.c.

{
    unsigned int        dir_index;
    char            *directory_buffer;
    int         new_reclen;
    struct directory_entry *s_entry;
    struct directory_entry *s_entry1;
    struct iso_directory_record jrec;
    unsigned int    total_size;
    int         cvt_len;
    struct directory    *finddir;
 
    total_size = ISO_ROUND_UP(dpnt->jsize);
    directory_buffer = (char *)e_malloc(total_size);
    memset(directory_buffer, 0, total_size);
    dir_index = 0;
 
    s_entry = dpnt->jcontents;
    while (s_entry) {
        if (s_entry->de_flags & INHIBIT_JOLIET_ENTRY) {
            s_entry = s_entry->jnext;
            continue;
        }
        /*
         * If this entry was a directory that was relocated,
         * we have a bit of trouble here.  We need to dig out the real
         * thing and put it back here.  In the Joliet tree, there is
         * no relocated rock ridge, as there are no depth limits to a
         * directory tree.
         */
        if ((s_entry->de_flags & RELOCATED_DIRECTORY) != 0) {
            for (s_entry1 = reloc_dir->contents; s_entry1;
                        s_entry1 = s_entry1->next) {
                if (s_entry1->parent_rec == s_entry) {
                    break;
                }
            }
            if (s_entry1 == NULL) {
                /* We got trouble. */
                comerrno(EX_BAD,
                _("Unable to locate relocated directory\n"));
            }
        } else {
            s_entry1 = s_entry;
        }
 
        /*
         * We do not allow directory entries to cross sector
         * boundaries. Simply pad, and then start the next entry at
         * the next sector
         */
        new_reclen = s_entry1->jreclen;
        if ((dir_index & (SECTOR_SIZE - 1)) + new_reclen >= SECTOR_SIZE) {
            dir_index = ISO_ROUND_UP(dir_index);
        }
        memcpy(&jrec, &s_entry1->isorec, offsetof(struct iso_directory_record, name[0]));
 
#ifdef APPLE_HYB
        /* Use the HFS name if it exists */
        if (USE_MAC_NAME(s_entry1))
            cvt_len = joliet_strlen(s_entry1->hfs_ent->name, jlen, hfs_inls);
        else
#endif  /* APPLE_HYB */
            cvt_len = joliet_strlen(s_entry1->name, jlen, in_nls);
 
        /*
         * Fix the record length
         * - this was the non-Joliet version we were seeing.
         */
        jrec.name_len[0] = cvt_len;
        jrec.length[0] = s_entry1->jreclen;
 
        /*
         * If this is a directory,
         * fix the correct size and extent number.
         */
        if ((jrec.flags[0] & ISO_DIRECTORY) != 0) {
            if (strcmp(s_entry1->name, ".") == 0) {
                jrec.name_len[0] = 1;
                set_733((char *)jrec.extent, dpnt->jextent);
                set_733((char *)jrec.size, ISO_ROUND_UP(dpnt->jsize));
            } else if (strcmp(s_entry1->name, "..") == 0) {
                jrec.name_len[0] = 1;
                if (dpnt->parent == reloc_dir) {
                    set_733((char *)jrec.extent, dpnt->self->parent_rec->filedir->jextent);
                    set_733((char *)jrec.size, ISO_ROUND_UP(dpnt->self->parent_rec->filedir->jsize));
                } else {
                    set_733((char *)jrec.extent, dpnt->parent->jextent);
                    set_733((char *)jrec.size, ISO_ROUND_UP(dpnt->parent->jsize));
                }
            } else {
                if ((s_entry->de_flags & RELOCATED_DIRECTORY) != 0) {
                    finddir = reloc_dir->subdir;
                } else {
                    finddir = dpnt->subdir;
                }
                while (finddir && finddir->self != s_entry1) {
                    finddir = finddir->next;
                }
                if (!finddir) {
                    comerrno(EX_BAD,
                        _("Fatal goof - unable to find directory location\n"));
                }
                set_733((char *)jrec.extent, finddir->jextent);
                set_733((char *)jrec.size,
                        ISO_ROUND_UP(finddir->jsize));
            }
        }
        memcpy(directory_buffer + dir_index, &jrec,
            offsetof(struct iso_directory_record, name[0]));
 
        dir_index += offsetof(struct iso_directory_record, name[0]);
 
        /*
         * Finally dump the Unicode version of the filename.
         * Note - . and .. are the same as with non-Joliet discs.
         */
        if ((jrec.flags[0] & ISO_DIRECTORY) != 0 &&
            strcmp(s_entry1->name, ".") == 0) {
            directory_buffer[dir_index++] = 0;
        } else if ((jrec.flags[0] & ISO_DIRECTORY) != 0 &&
            strcmp(s_entry1->name, "..") == 0) {
            directory_buffer[dir_index++] = 1;
        } else {
#ifdef APPLE_HYB
            if (USE_MAC_NAME(s_entry1)) {
                /* Use the HFS name if it exists */
                convert_to_unicode(
                    (Uchar *) directory_buffer+dir_index,
                    cvt_len,
                    s_entry1->hfs_ent->name, hfs_inls);
            } else
#endif  /* APPLE_HYB */
            {
                convert_to_unicode(
                    (Uchar *) directory_buffer+dir_index,
                    cvt_len,
                    s_entry1->name, in_nls);
            }
            dir_index += cvt_len;
        }
 
        if (dir_index & 1) {
            directory_buffer[dir_index++] = 0;
        }
        s_entry = s_entry->jnext;
    }
 
    if (dpnt->jsize != dir_index) {
        errmsgno(EX_BAD,
        _("Unexpected joliet directory length %d expected: %d '%s'\n"),
            dpnt->jsize,
            dir_index, dpnt->de_name);
    }
    xfwrite(directory_buffer, total_size, 1, outfile, 0, FALSE);
    last_extent_written += total_size >> 11;
    free(directory_buffer);
} /* generate_one_joliet_directory(... */

Referenced by generate_joliet_directories().

get_joliet_vol_desc()

LOCAL void get_joliet_vol_desc

(

struct iso_primary_descriptor *

jvol_desc

)

Definition at line 436 of file joliet.c.

{
    jvol_desc->type[0] = ISO_VD_SUPPLEMENTARY;
    jvol_desc->version[0] = 1;
    jvol_desc->file_structure_version[0] = 1;
    /*
     * For now, always do Unicode level 3.
     * I don't really know what 1 and 2 are - perhaps a more limited
     * Unicode set.
     * FIXME(eric) - how does Romeo fit in here?
     */
    sprintf(jvol_desc->escape_sequences, "%%/%c", ucs_codes[ucs_level]);
 
    /* Until we have Unicode path tables, leave these unset. */
    set_733((char *)jvol_desc->path_table_size, jpath_table_size);
    set_731(jvol_desc->type_l_path_table, jpath_table[0]);
    set_731(jvol_desc->opt_type_l_path_table, jpath_table[1]);
    set_732(jvol_desc->type_m_path_table, jpath_table[2]);
    set_732(jvol_desc->opt_type_m_path_table, jpath_table[3]);
 
    /* Set this one up. */
    memcpy(jvol_desc->root_directory_record, &jroot_record,
        offsetof(struct iso_directory_record, name[0]) + 1);
 
    /*
     * Finally, we have a bunch of strings to convert to Unicode.
     * FIXME(eric) - I don't know how to do this in general,
     * so we will just be really lazy and do a char -> short conversion.
     *  We probably will want to filter any characters >= 0x80.
     */
    convert_to_unicode((Uchar *)jvol_desc->system_id,
            sizeof (jvol_desc->system_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->volume_id,
            sizeof (jvol_desc->volume_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->volume_set_id,
            sizeof (jvol_desc->volume_set_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->publisher_id,
            sizeof (jvol_desc->publisher_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->preparer_id,
            sizeof (jvol_desc->preparer_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->application_id,
            sizeof (jvol_desc->application_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->copyright_file_id,
            sizeof (jvol_desc->copyright_file_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->abstract_file_id,
            sizeof (jvol_desc->abstract_file_id), NULL, in_nls);
    convert_to_unicode((Uchar *)jvol_desc->bibliographic_file_id,
            sizeof (jvol_desc->bibliographic_file_id), NULL, in_nls);
}

Referenced by jvd_write().

jdirtree_size()

LOCAL int jdirtree_size

(

UInt32_t

starting_extent

)

Definition at line 1389 of file joliet.c.

{
    assign_joliet_directory_addresses(root);
    return (0);
}

jdirtree_write()

LOCAL int jdirtree_write

(

FILE *

outfile

)

Definition at line 1414 of file joliet.c.

{
    generate_joliet_directories(root, outfile);
    return (0);
}

joliet_compare_dirs()

LOCAL int joliet_compare_dirs	(	void *	rr,
		const void *	ll
	)		const

Definition at line 1080 of file joliet.c.

{
    char        *rpnt,
            *lpnt;
    struct directory_entry **r,
            **l;
    unsigned char   rtmp[2],
            ltmp[2];
    siconvt_t   *linls, *rinls;
 
    r = (struct directory_entry **)rr;
    l = (struct directory_entry **)ll;
 
#ifdef APPLE_HYB
    /*
     * we may be using the HFS name - so select the correct input
     * charset
     */
    if (USE_MAC_NAME(*r)) {
        rpnt = (*r)->hfs_ent->name;
        rinls = hfs_inls;
    } else {
        rpnt = (*r)->name;
        rinls = in_nls;
    }
 
    if (USE_MAC_NAME(*l)) {
        lpnt = (*l)->hfs_ent->name;
        linls = hfs_inls;
    } else {
        lpnt = (*l)->name;
        linls = in_nls;
    }
#else
    rpnt = (*r)->name;
    lpnt = (*l)->name;
    rinls = linls = in_nls;
#endif  /* APPLE_HYB */
 
    /*
     * If the entries are the same, this is an error.
     * Joliet specs allow for a maximum of 64 characters.
     * If we see different multi extent parts, it is OK to
     * have the same name more than once.
     */
    if (strncmp(rpnt, lpnt, jlen) == 0) {
#ifdef USE_LARGEFILES
        if ((*r)->mxpart == (*l)->mxpart)
#endif
        {
            errmsgno(EX_BAD,
                _("Error: %s and %s have the same Joliet name\n"),
                (*r)->whole_name, (*l)->whole_name);
            jsort_goof++;
            {
                char    *p1 = rpnt;
                char    *p2 = lpnt;
                int len = 0;
 
                for (; *p1 == *p2; p1++, p2++, len++) {
                    if (*p1 == '\0')
                        break;
                }
                if (len > jsort_glen)
                    jsort_glen = len;
            }
        }
    }
    /*
     * Put the '.' and '..' entries on the head of the sorted list.
     * For normal ASCII, this always happens to be the case, but out of
     * band characters cause this not to be the case sometimes.
     */
    if (strcmp(rpnt, ".") == 0)
        return (-1);
    if (strcmp(lpnt, ".") == 0)
        return (1);
 
    if (strcmp(rpnt, "..") == 0)
        return (-1);
    if (strcmp(lpnt, "..") == 0)
        return (1);
 
#ifdef DVD_AUD_VID
    /*
     * There're rumors claiming that some players assume VIDEO_TS.IFO
     * to be the first file in VIDEO_TS/ catalog. Well, it's basically
     * the only file a player has to actually look for, as the whole
     * video content can be "rolled down" from this file alone.
     *              <appro@fy.chalmers.se>
     */
    /*
     * XXX This code has to be moved from the Joliet implementation
     * XXX to the UDF implementation if we implement decent UDF support
     * XXX with a separate name space for the UDF file tree.
     */
    if (dvd_aud_vid_flag & DVD_SPEC_VIDEO) {
        if (strcmp(rpnt, "VIDEO_TS.IFO") == 0)
            return (-1);
        if (strcmp(lpnt, "VIDEO_TS.IFO") == 0)
            return (1);
    }
#endif
 
    while (*rpnt && *lpnt) {
        if (*rpnt == ';' && *lpnt != ';')
            return (-1);
        if (*rpnt != ';' && *lpnt == ';')
            return (1);
 
        if (*rpnt == ';' && *lpnt == ';')
            return (0);
 
        /*
         * Extensions are not special here.
         * Don't treat the dot as something that must be bumped to
         * the start of the list.
         */
#if 0
        if (*rpnt == '.' && *lpnt != '.')
            return (-1);
        if (*rpnt != '.' && *lpnt == '.')
            return (1);
#endif
 
        convert_to_unicode(rtmp, 2, rpnt, rinls);
        convert_to_unicode(ltmp, 2, lpnt, linls);
 
        if (a_to_u_2_byte(rtmp) < a_to_u_2_byte(ltmp))
            return (-1);
        if (a_to_u_2_byte(rtmp) > a_to_u_2_byte(ltmp))
            return (1);
 
        rpnt++;
        lpnt++;
    }
    if (*rpnt)
        return (1);
    if (*lpnt)
        return (-1);
#ifdef USE_LARGEFILES
    /*
     * (*r)->mxpart == (*l)->mxpart cannot happen here
     */
    if ((*r)->mxpart < (*l)->mxpart)
        return (-1);
    else if ((*r)->mxpart > (*l)->mxpart)
        return (1);
#endif
    return (0);
}

Referenced by joliet_sort_directory().

joliet_compare_paths()

LOCAL int joliet_compare_paths	(	void const *	r,
		void const *	l
	)

Definition at line 543 of file joliet.c.

{
    struct directory const *ll = *(struct directory * const *) l;
    struct directory const *rr = *(struct directory * const *) r;
    int     rparent,
            lparent;
    char        *rpnt,
            *lpnt;
    unsigned char   rtmp[2],
            ltmp[2];
    siconvt_t   *rinls, *linls;
 
    /* make sure root directory is first */
    if (rr == root)
        return (-1);
 
    if (ll == root)
        return (1);
 
    rparent = rr->parent->jpath_index;
    lparent = ll->parent->jpath_index;
    if (rr->parent == reloc_dir) {
        rparent = rr->self->parent_rec->filedir->jpath_index;
    }
    if (ll->parent == reloc_dir) {
        lparent = ll->self->parent_rec->filedir->jpath_index;
    }
    if (rparent < lparent) {
        return (-1);
    }
    if (rparent > lparent) {
        return (1);
    }
#ifdef APPLE_HYB
    /*
     * we may be using the HFS name - so select the correct input
     * charset
     */
    if (USE_MAC_NAME(rr->self)) {
        rpnt = rr->self->hfs_ent->name;
        rinls = hfs_inls;
    } else {
        rpnt = rr->self->name;
        rinls = in_nls;
    }
 
    if (USE_MAC_NAME(ll->self)) {
        lpnt = ll->self->hfs_ent->name;
        linls = hfs_inls;
    } else {
        lpnt = ll->self->name;
        linls = in_nls;
    }
#else
    rpnt = rr->self->name;
    lpnt = ll->self->name;
    linls = rinls = in_nls;
#endif  /* APPLE_HYB */
 
    /* compare the Unicode names */
 
    while (*rpnt && *lpnt) {
        convert_to_unicode(rtmp, 2, rpnt, rinls);
        convert_to_unicode(ltmp, 2, lpnt, linls);
 
        if (a_to_u_2_byte(rtmp) < a_to_u_2_byte(ltmp))
            return (-1);
        if (a_to_u_2_byte(rtmp) > a_to_u_2_byte(ltmp))
            return (1);
 
        rpnt++;
        lpnt++;
    }
 
    if (*rpnt)
        return (1);
    if (*lpnt)
        return (-1);
 
    return (0);
 
} /* compare_paths(... */

Referenced by generate_joliet_path_tables().

joliet_sort_directory()

LOCAL int joliet_sort_directory

(

struct directory_entry **

sort_dir

)

Definition at line 1244 of file joliet.c.

{
    int         dcount = 0;
    int         i;
    struct directory_entry  *s_entry;
    struct directory_entry  **sortlist;
 
    s_entry = *sort_dir;
    while (s_entry) {
        /*
         * only colletc non-hidden entries
         */
        if ((s_entry->de_flags & (INHIBIT_JOLIET_ENTRY|INHIBIT_UDF_ENTRY)) !=
                    (INHIBIT_JOLIET_ENTRY|INHIBIT_UDF_ENTRY))
            dcount++;
        s_entry = s_entry->next;
    }
 
    /* OK, now we know how many there are.  Build a vector for sorting. */
    sortlist = (struct directory_entry **)
        e_malloc(sizeof (struct directory_entry *) * dcount);
 
    dcount = 0;
    s_entry = *sort_dir;
    while (s_entry) {
        /*
         * only collect non-hidden entries
         */
        if ((s_entry->de_flags & (INHIBIT_JOLIET_ENTRY|INHIBIT_UDF_ENTRY)) !=
                    (INHIBIT_JOLIET_ENTRY|INHIBIT_UDF_ENTRY)) {
            sortlist[dcount] = s_entry;
            dcount++;
        }
        s_entry = s_entry->next;
    }
 
    jsort_goof = 0;
    jsort_glen = 0;
#ifdef  PROTOTYPES
    qsort(sortlist, dcount, sizeof (struct directory_entry *),
        (int (*) (const void *, const void *)) joliet_compare_dirs);
#else
    qsort(sortlist, dcount, sizeof (struct directory_entry *),
        joliet_compare_dirs);
#endif
 
    if (jsort_goof) {
        errmsgno(EX_BAD,
            _("Joliet file names differ after %d chars\n"),
            jsort_glen);
        if (jsort_glen > JLONGMAX) {
            errmsgno(EX_BAD,
            _("Cannot use Joliet, please remove -J from the option list.\n"));
        } else if (jsort_glen > JMAX) {
            errmsgno(EX_BAD,
            _("Try to use the option -joliet-long\n"));
        }
    }
 
    /* Now reassemble the linked list in the proper sorted order */
    for (i = 0; i < dcount - 1; i++) {
        sortlist[i]->jnext = sortlist[i + 1];
    }
 
    sortlist[dcount - 1]->jnext = NULL;
    *sort_dir = sortlist[0];
 
    free(sortlist);
    return (jsort_goof);
}

Referenced by joliet_sort_n_finish().

joliet_sort_n_finish()

LOCAL int joliet_sort_n_finish

(

struct directory *

this_dir

)

Definition at line 957 of file joliet.c.

{
    struct directory_entry  *s_entry;
    int         status = 0;
 
    /*
     * don't want to skip this directory if it's the reloc_dir
     * at the moment
     */
    if (this_dir != reloc_dir &&
                this_dir->dir_flags & INHIBIT_JOLIET_ENTRY) {
        return (0);
    }
    for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next) {
        /* skip hidden entries */
        if ((s_entry->de_flags & INHIBIT_JOLIET_ENTRY) != 0) {
            continue;
        }
        /*
         * First update the path table sizes for directories.
         *
         * Finally, set the length of the directory entry if Joliet is
         * used. The name is longer, but no Rock Ridge is ever used
         * here, so depending upon the options the entry size might
         * turn out to be about the same.  The Unicode name is always
         * a multiple of 2 bytes, so we always add 1 to make it an
         * even number.
         */
        if (s_entry->isorec.flags[0] & ISO_DIRECTORY) {
            if (strcmp(s_entry->name, ".") != 0 &&
                    strcmp(s_entry->name, "..") != 0) {
#ifdef APPLE_HYB
                if (USE_MAC_NAME(s_entry))
                    /* Use the HFS name if it exists */
                    jpath_table_size +=
                        joliet_strlen(s_entry->hfs_ent->name, jlen, hfs_inls) +
                        offsetof(struct iso_path_table, name[0]);
                else
#endif  /* APPLE_HYB */
                    jpath_table_size +=
                        joliet_strlen(s_entry->name, jlen, in_nls) +
                        offsetof(struct iso_path_table, name[0]);
                if (jpath_table_size & 1) {
                    jpath_table_size++;
                }
            } else {
                if (this_dir == root &&
                        strlen(s_entry->name) == 1) {
 
                    jpath_table_size += 1 + offsetof(struct iso_path_table, name[0]);
                    if (jpath_table_size & 1)
                        jpath_table_size++;
                }
            }
        }
        if (strcmp(s_entry->name, ".") != 0 &&
                    strcmp(s_entry->name, "..") != 0) {
#ifdef APPLE_HYB
            if (USE_MAC_NAME(s_entry))
                /* Use the HFS name if it exists */
                s_entry->jreclen =
                offsetof(struct iso_directory_record, name[0])
                    + joliet_strlen(s_entry->hfs_ent->name, jlen, hfs_inls)
                    + 1;
            else
#endif  /* APPLE_HYB */
                s_entry->jreclen =
                offsetof(struct iso_directory_record, name[0])
                    + joliet_strlen(s_entry->name, jlen, in_nls)
                    + 1;
        } else {
            /*
             * Special - for '.' and '..' we generate the same
             * records we did for non-Joliet discs.
             */
            s_entry->jreclen =
            offsetof(struct iso_directory_record, name[0])
                + 1;
        }
 
 
    }
 
    if ((this_dir->dir_flags & INHIBIT_JOLIET_ENTRY) != 0) {
        return (0);
    }
    this_dir->jcontents = this_dir->contents;
    status = joliet_sort_directory(&this_dir->jcontents);
 
    /*
     * Now go through the directory and figure out how large this one will
     * be. Do not split a directory entry across a sector boundary
     */
    s_entry = this_dir->jcontents;
    /*
     * XXX Is it ok to comment this out?
     */
/*XXX JS  this_dir->ce_bytes = 0;*/
    for (s_entry = this_dir->jcontents; s_entry;
                        s_entry = s_entry->jnext) {
        int jreclen;
 
        if ((s_entry->de_flags & INHIBIT_JOLIET_ENTRY) != 0) {
            continue;
        }
        jreclen = s_entry->jreclen;
 
        if ((this_dir->jsize & (SECTOR_SIZE - 1)) + jreclen >=
                                SECTOR_SIZE) {
            this_dir->jsize = ISO_ROUND_UP(this_dir->jsize);
        }
        this_dir->jsize += jreclen;
    }
    return (status);
}

Referenced by joliet_sort_tree().

joliet_sort_tree()

EXPORT int joliet_sort_tree

(

struct directory *

node

)

Definition at line 1317 of file joliet.c.

{
    struct directory    *dpnt;
    int         ret = 0;
 
    dpnt = node;
 
    while (dpnt) {
        ret = joliet_sort_n_finish(dpnt);
        if (ret) {
            break;
        }
        if (dpnt->subdir)
            ret = joliet_sort_tree(dpnt->subdir);
        if (ret) {
            break;
        }
        dpnt = dpnt->next;
    }
    return (ret);
}

Referenced by joliet_sort_tree(), and main().

joliet_strlen()

LOCAL int joliet_strlen	(	char *	string,
		size_t	maxlen,
		siconvt_t *	inls
	)		const

Definition at line 375 of file joliet.c.

{
    int rtn = 0;
 
#ifdef  USE_ICONV
    if (use_iconv(inls)) {
        int j = 0;
 
        while (string[j] != '\0') {
            Uchar       ob[2];
            __IC_CONST char *inbuf = (char *)&string[j];
            size_t  isize = 3;
            char    *obuf = (char *)ob;
            size_t  osize = 2;
 
            /*
             * iconv() from glibc ignores osize and thus
             * may try to access more than a single multi
             * byte character from the input and read from
             * non-existent memory.
             */
            if (iconv(inls->sic_cd2uni, &inbuf, &isize,
                        &obuf, &osize) == -1) {
                int err = geterrno();
 
                if ((err == EINVAL || err == EILSEQ) &&
                    isize == 3) {
                    ob[0] = ob[1] = 0;
                    isize--;
                }
            }
            j += 3 - isize;
            rtn += 2;
        }
    } else
#endif
    rtn = strlen(string) << 1;
 
    /*
     * We do clamp the maximum length of a Joliet or UDF string to be the
     * maximum path size.
     */
    if (rtn > 2*maxlen) {
        rtn = 2*maxlen;
    }
    return (rtn);
}

Referenced by generate_joliet_path_tables(), generate_one_joliet_directory(), and joliet_sort_n_finish().

jpathtab_size()

LOCAL int jpathtab_size

(

UInt32_t

starting_extent

)

Definition at line 1442 of file joliet.c.

{
    jpath_table[0] = starting_extent;
    jpath_table[1] = 0;
    jpath_table[2] = jpath_table[0] + jpath_blocks;
    jpath_table[3] = 0;
 
    last_extent += 2 * jpath_blocks;
    return (0);
}

jpathtab_write()

LOCAL int jpathtab_write

(

FILE *

outfile

)

Definition at line 1374 of file joliet.c.

{
    /* Next we write the path tables */
    xfwrite(jpath_table_l, jpath_blocks << 11, 1, outfile, 0, FALSE);
    xfwrite(jpath_table_m, jpath_blocks << 11, 1, outfile, 0, FALSE);
    last_extent_written += 2 * jpath_blocks;
    free(jpath_table_l);
    free(jpath_table_m);
    jpath_table_l = NULL;
    jpath_table_m = NULL;
    return (0);
}

jroot_gen()

LOCAL int jroot_gen

(

)

Definition at line 1397 of file joliet.c.

{
    jroot_record.length[0] =
            1 + offsetof(struct iso_directory_record, name[0]);
    jroot_record.ext_attr_length[0] = 0;
    set_733((char *)jroot_record.extent, root->jextent);
    set_733((char *)jroot_record.size, ISO_ROUND_UP(root->jsize));
    iso9660_date(jroot_record.date, root_statbuf.st_mtime);
    jroot_record.flags[0] = ISO_DIRECTORY;
    jroot_record.file_unit_size[0] = 0;
    jroot_record.interleave[0] = 0;
    set_723(jroot_record.volume_sequence_number, volume_sequence_number);
    jroot_record.name_len[0] = 1;
    return (0);
}

jvd_write()

LOCAL int jvd_write

(

FILE *

outfile

)

Definition at line 1425 of file joliet.c.

{
    struct iso_primary_descriptor jvol_desc;
 
    /* Next we write out the boot volume descriptor for the disc */
    jvol_desc = vol_desc;
    get_joliet_vol_desc(&jvol_desc);
    xfwrite(&jvol_desc, SECTOR_SIZE, 1, outfile, 0, FALSE);
    last_extent_written++;
    return (0);
}

Variable Documentation

jdirtree_desc

struct output_fragment jdirtree_desc = {NULL, jdirtree_size, NULL, jdirtree_write, "Joliet directory tree" }

Definition at line 1456 of file joliet.c.

Referenced by main().

joliet_desc

struct output_fragment joliet_desc = {NULL, oneblock_size, jroot_gen, jvd_write, "Joliet Volume Descriptor" }

Definition at line 1454 of file joliet.c.

Referenced by main().

jpath_table_index

LOCAL Uint jpath_table_index

Definition at line 93 of file joliet.c.

Referenced by generate_joliet_path_tables().

jpathlist

LOCAL struct directory** jpathlist

Definition at line 94 of file joliet.c.

Referenced by build_jpathlist(), and generate_joliet_path_tables().

jpathtable_desc

struct output_fragment jpathtable_desc = {NULL, jpathtab_size, generate_joliet_path_tables, jpathtab_write, "Joliet path table" }

Definition at line 1455 of file joliet.c.

Referenced by main().

jsort_glen

LOCAL int jsort_glen

Definition at line 97 of file joliet.c.

Referenced by joliet_compare_dirs(), and joliet_sort_directory().

jsort_goof

LOCAL int jsort_goof

Definition at line 96 of file joliet.c.

Referenced by joliet_compare_dirs(), and joliet_sort_directory().

next_jpath_index

LOCAL int next_jpath_index = 1

Definition at line 95 of file joliet.c.

Referenced by assign_joliet_directory_addresses(), and generate_joliet_path_tables().

sccsid

UConst char sccsid[]

static

Initial value:

=
    "@(#)joliet.c   1.68 15/12/30 joerg"

Definition at line 4 of file joliet.c.

ucs_codes

LOCAL char ucs_codes[]

Initial value:

= {
        '\0',       
        '@',        
        'C',        
        'E',        
}

Definition at line 99 of file joliet.c.

Referenced by get_joliet_vol_desc().