tree.c File Reference

#include <schily/mconfig.h>
#include "mkisofs.h"
#include "rock.h"
#include "match.h"
#include <schily/time.h>
#include <schily/errno.h>
#include <schily/fcntl.h>
#include <schily/device.h>
#include <schily/schily.h>

Include dependency graph for tree.c:

Go to the source code of this file.

Macros
#define	is_archive(st)   ((st).st_dev == archive_dev && (st).st_ino == archive_ino)

Functions
LOCAL char *filetype	__PR ((int t))
LOCAL char *rstr	__PR ((char *s1, char *s2))
LOCAL void stat_fix	__PR ((struct stat *st))
EXPORT int stat_filter	__PR ((char *path, struct stat *st))
LOCAL int sort_n_finish	__PR ((struct directory *this_dir))
LOCAL void generate_reloc_directory	__PR ((void))
EXPORT void attach_dot_entries	__PR ((struct directory *dirnode, struct stat *this_stat, struct stat *parent_stat))
EXPORT char *find_rr_attribute	__PR ((unsigned char *pnt, int len, char *attr_type))
LOCAL void dir_nesting_warn	__PR ((struct directory *this_dir, char *path, int contflag))
EXPORT int scan_directory_tree	__PR ((struct directory *this_dir, char *path, struct directory_entry *de))
LOCAL struct directory_entry *dup_relocated_dir	__PR ((struct directory *this_dir, struct directory_entry *s_entry, char *whole_path, char *short_name, struct stat *statp))
EXPORT int insert_file_entry	__PR ((struct directory *this_dir, char *whole_path, char *short_name, struct stat *statp, int have_rsrc))
EXPORT struct directory_entry *dup_directory_entry	__PR ((struct directory_entry *s_entry))
EXPORT void generate_iso9660_directories	__PR ((struct directory *node, FILE *outfile))
LOCAL void set_de_path	__PR ((struct directory *parent, struct directory *this))
EXPORT struct directory *find_or_create_directory	__PR ((struct directory *parent, char *path, struct directory_entry *de, int flag))
LOCAL void delete_directory	__PR ((struct directory *parent, struct directory *child))
EXPORT int sort_tree	__PR ((struct directory *node))
EXPORT struct directory_entry *search_tree_file	__PR ((struct directory *node, char *filename))
LOCAL char *	filetype (int t)
LOCAL char *	rstr (char *s1, char *s2)
LOCAL void	stat_fix (struct stat *st)
EXPORT int	stat_filter (char *path, struct stat *st)
EXPORT int	lstat_filter (char *path, struct stat *st)
LOCAL int	sort_n_finish (struct directory *this_dir)
LOCAL void	generate_reloc_directory ()
EXPORT void	attach_dot_entries (struct directory *dirnode, struct stat *this_stat, struct stat *parent_stat)
EXPORT char *	find_rr_attribute (unsigned char *pnt, int len, char *attr_type)
EXPORT void	finish_cl_pl_entries ()
LOCAL void	dir_nesting_warn (struct directory *this_dir, char *path, int contflag)
EXPORT int	scan_directory_tree (struct directory *this_dir, char *path, struct directory_entry *de)
LOCAL struct directory_entry *	dup_relocated_dir (struct directory *this_dir, struct directory_entry *s_entry, char *whole_path, char *short_name, struct stat *statp)
EXPORT int	insert_file_entry (struct directory *this_dir, char *whole_path, char *short_name, struct stat *statp, int have_rsrc)
EXPORT struct directory_entry *	dup_directory_entry (struct directory_entry *s_entry)
EXPORT void	generate_iso9660_directories (struct directory *node, FILE *outfile)
LOCAL void	set_de_path (struct directory *parent, struct directory *this)
EXPORT struct directory *	find_or_create_directory (struct directory *parent, char *path, struct directory_entry *de, int flag)
LOCAL void	delete_directory (struct directory *parent, struct directory *child)
EXPORT int	sort_tree (struct directory *node)
EXPORT void	dump_tree (struct directory *node)
EXPORT struct directory_entry *	search_tree_file (struct directory *node, char *filename)
EXPORT void	init_fstatbuf ()

Variables
static UConst char	sccsid []
LOCAL Uchar	symlink_buff [PATH_MAX+1]
int	verbose
struct stat	fstatbuf
struct stat	root_statbuf
struct directory *	reloc_dir

Macro Definition Documentation

is_archive

#define is_archive

(

st

)

((st).st_dev == archive_dev && (st).st_ino == archive_ino)

Function Documentation

__PR() [1/19]

EXPORT int stat_filter __PR

(

(char *path, struct stat *st)

)

__PR() [2/19]

LOCAL char *rstr __PR

(

(char *s1, char *s2)

)

__PR() [3/19]

LOCAL char *filetype __PR

(

(int t)

)

__PR() [4/19]

EXPORT void attach_dot_entries __PR

(

(struct directory *dirnode, struct stat *this_stat, struct stat *parent_stat)

)

__PR() [5/19]

EXPORT int sort_tree __PR

(

(struct directory *node)

)

__PR() [6/19]

EXPORT struct directory_entry *search_tree_file __PR

(

(struct directory *node, char *filename)

)

__PR() [7/19]

EXPORT void generate_iso9660_directories __PR

(

(struct directory *node, FILE *outfile)

)

__PR() [8/19]

EXPORT struct directory *find_or_create_directory __PR

(

(struct directory *parent, char *path, struct directory_entry *de, int flag)

)

__PR() [9/19]

LOCAL void delete_directory __PR

(

(struct directory *parent, struct directory *child)

)

__PR() [10/19]

LOCAL void set_de_path __PR

(

(struct directory *parent, struct directory *this)

)

__PR() [11/19]

LOCAL int sort_n_finish __PR

(

(struct directory *this_dir)

)

__PR() [12/19]

LOCAL void dir_nesting_warn __PR

(

(struct directory *this_dir, char *path, int contflag)

)

__PR() [13/19]

EXPORT int scan_directory_tree __PR

(

(struct directory *this_dir, char *path, struct directory_entry *de)

)

__PR() [14/19]

EXPORT int insert_file_entry __PR

(

(struct directory *this_dir, char *whole_path, char *short_name, struct stat *statp, int have_rsrc)

)

__PR() [15/19]

LOCAL struct directory_entry *dup_relocated_dir __PR

(

(struct directory *this_dir, struct directory_entry *s_entry, char *whole_path, char *short_name, struct stat *statp)

)

__PR() [16/19]

EXPORT struct directory_entry *dup_directory_entry __PR

(

(struct directory_entry *s_entry)

)

__PR() [17/19]

LOCAL void stat_fix __PR

(

(struct stat *st)

)

__PR() [18/19]

EXPORT char *find_rr_attribute __PR

(

(unsigned char *pnt, int len, char *attr_type)

)

__PR() [19/19]

LOCAL void generate_reloc_directory __PR

(

(void)

)

attach_dot_entries()

EXPORT void attach_dot_entries	(	struct directory *	dirnode,
		struct stat *	this_stat,
		struct stat *	parent_stat
	)

Definition at line 905 of file tree.c.

{
    struct directory_entry *s_entry;
    struct directory_entry *orig_contents;
    int     deep_flag = 0;
 
    init_fstatbuf();
    fstatbuf.st_mode = new_dir_mode | S_IFDIR;
    fstatbuf.st_nlink = 2;
    if (parent_stat == NULL)
        parent_stat = &fstatbuf;
    if (this_stat == NULL)
        this_stat = &fstatbuf;
 
    orig_contents = dirnode->contents;
 
    if ((dirnode->dir_flags & DIR_HAS_DOTDOT) == 0) {
        if (dirnode->parent &&
            dirnode->parent == reloc_dir) {
            deep_flag = NEED_PL;
        }
        s_entry = (struct directory_entry *)
            e_malloc(sizeof (struct directory_entry));
        memcpy(s_entry, dirnode->self,
            sizeof (struct directory_entry));
#ifdef  APPLE_HYB
        if (dirnode->self->hfs_ent) {
            s_entry->hfs_ent = (hfsdirent *)
                e_malloc(sizeof (hfsdirent));
            memcpy(s_entry->hfs_ent, dirnode->self->hfs_ent,
                sizeof (hfsdirent));
        }
#endif
        s_entry->name = e_strdup("..");
        s_entry->whole_name = NULL;
        s_entry->isorec.name_len[0] = 1;
        s_entry->isorec.flags[0] = ISO_DIRECTORY;
        iso9660_file_length("..", s_entry, 1);
        iso9660_date(s_entry->isorec.date, parent_stat->st_mtime);
        set_723(s_entry->isorec.volume_sequence_number,
                        volume_sequence_number);
        set_733(s_entry->isorec.size, SECTOR_SIZE);
        memset(s_entry->isorec.extent, 0, 8);
        s_entry->filedir = dirnode->parent;
 
        dirnode->contents = s_entry;
        dirnode->contents->next = orig_contents;
        orig_contents = s_entry;
 
        if (use_XA || use_RockRidge) {
            generate_xa_rr_attributes("",
                "..", s_entry,
                parent_stat,
                parent_stat, deep_flag);
        }
        dirnode->dir_flags |= DIR_HAS_DOTDOT;
    }
    deep_flag = 0;
    if ((dirnode->dir_flags & DIR_HAS_DOT) == 0) {
        s_entry = (struct directory_entry *)
            e_malloc(sizeof (struct directory_entry));
        memcpy(s_entry, dirnode->self,
            sizeof (struct directory_entry));
#ifdef  APPLE_HYB
        if (dirnode->self->hfs_ent) {
            s_entry->hfs_ent = (hfsdirent *)
                e_malloc(sizeof (hfsdirent));
            memcpy(s_entry->hfs_ent, dirnode->self->hfs_ent,
                sizeof (hfsdirent));
        }
#endif
        s_entry->name = e_strdup(".");
        s_entry->whole_name = NULL;
        s_entry->isorec.name_len[0] = 1;
        s_entry->isorec.flags[0] = ISO_DIRECTORY;
        iso9660_file_length(".", s_entry, 1);
        iso9660_date(s_entry->isorec.date, this_stat->st_mtime);
        set_723(s_entry->isorec.volume_sequence_number,
                        volume_sequence_number);
        set_733(s_entry->isorec.size, SECTOR_SIZE);
        memset(s_entry->isorec.extent, 0, 8);
        s_entry->filedir = dirnode;
 
        dirnode->contents = s_entry;
        dirnode->contents->next = orig_contents;
 
        if (use_XA || use_RockRidge) {
            if (dirnode == root) {
                deep_flag |= NEED_CE | NEED_SP; /* For extension record */
            }
            generate_xa_rr_attributes("",
                ".", s_entry,
                this_stat, this_stat, deep_flag);
        }
        dirnode->dir_flags |= DIR_HAS_DOT;
    }
}

Referenced by find_or_create_directory(), generate_reloc_directory(), and sort_n_finish().

delete_directory()

LOCAL void delete_directory	(	struct directory *	parent,
		struct directory *	child
	)

Definition at line 2801 of file tree.c.

{
    struct directory *tdir;
 
    if (child == NULL)
        return;
    if (child->contents != NULL) {
        comerrno(EX_BAD, _("Unable to delete non-empty directory\n"));
    }
    free(child->whole_name);
    child->whole_name = NULL;
 
    free(child->de_name);
    child->de_name = NULL;
 
#ifdef APPLE_HYB
    if (apple_both && child->hfs_ent)
        free(child->hfs_ent);
#endif  /* APPLE_HYB */
 
    if (parent->subdir == child) {
        parent->subdir = child->next;
    } else {
        for (tdir = parent->subdir; tdir != NULL && tdir->next != NULL;
                            tdir = tdir->next) {
            if (tdir->next == child) {
                tdir->next = child->next;
                break;
            }
        }
        if (tdir == NULL || tdir->next != child->next) {
            comerrno(EX_BAD,
            _("Unable to locate child directory in parent list\n"));
        }
    }
    free(child);
}

Referenced by insert_file_entry().

dir_nesting_warn()

LOCAL void dir_nesting_warn	(	struct directory *	this_dir,
		char *	path,
		int	contflag
	)

Definition at line 1118 of file tree.c.

{
    static  BOOL    did_hint = FALSE;
 
    errmsgno(EX_BAD,
        _("Directories too deep for '%s' (%d) max is %d%s.\n"),
        path, this_dir->depth, RR_relocation_depth,
        contflag?_("; ignored - continuing"):"");
    if (!did_hint) {
        did_hint = TRUE;
        errmsgno(EX_BAD, _("To include the complete directory tree,\n"));
        errmsgno(EX_BAD, _("use Rock Ridge extensions via -R or -r,\n"));
        errmsgno(EX_BAD, _("or allow deep ISO9660 directory nesting via -D.\n"));
    }
}

Referenced by find_or_create_directory(), and insert_file_entry().

dump_tree()

EXPORT void dump_tree

(

struct directory *

node

)

Definition at line 2863 of file tree.c.

{
    struct directory *dpnt;
 
    dpnt = node;
 
    while (dpnt) {
        fprintf(stderr, "%4d %5d %s\n",
                dpnt->extent, dpnt->size, dpnt->de_name);
        if (dpnt->subdir)
            dump_tree(dpnt->subdir);
        dpnt = dpnt->next;
    }
}

Referenced by dirtree_dump(), and dump_tree().

dup_directory_entry()

EXPORT struct directory_entry * dup_directory_entry

(

struct directory_entry *

s_entry

)

Definition at line 2429 of file tree.c.

{
    struct directory_entry  *s_entry1;
 
    s_entry1 = (struct directory_entry *)
        e_malloc(sizeof (struct directory_entry));
    memcpy(s_entry1, s_entry, sizeof (struct directory_entry));
 
    if (s_entry->rr_attributes) {
        s_entry1->rr_attributes =
                e_malloc(s_entry->total_rr_attr_size);
        memcpy(s_entry1->rr_attributes, s_entry->rr_attributes,
                    s_entry->total_rr_attr_size);
    }
    if (s_entry->name)
        s_entry1->name = e_strdup(s_entry->name);
    if (s_entry->whole_name)
        s_entry1->whole_name = e_strdup(s_entry->whole_name);
#ifdef  APPLE_HYB
    /*
     * If we also duplicate s_entry->hfs_ent, we would need to change
     * free_one_directory() and other calls to free(s_entry->hfs_ent) too.
     */
#endif
    return (s_entry1);
}

Referenced by copy_mult_extent(), insert_file_entry(), and read_merging_directory().

dup_relocated_dir()

LOCAL struct directory_entry * dup_relocated_dir	(	struct directory *	this_dir,
		struct directory_entry *	s_entry,
		char *	whole_path,
		char *	short_name,
		struct stat *	statp
	)

Definition at line 1376 of file tree.c.

{
    struct directory_entry *s_entry1;
 
    if (!reloc_dir)
        generate_reloc_directory();
    init_fstatbuf();
 
    /*
     * Replicate the entry for this directory.  The old one will
     * stay where it is, and it will be neutered so that it no
     * longer looks like a directory. The new one will look like
     * a directory, and it will be put in the reloc_dir.
     */
    s_entry1 = (struct directory_entry *)
        e_malloc(sizeof (struct directory_entry));
    memcpy(s_entry1, s_entry, sizeof (struct directory_entry));
    s_entry1->table = NULL;
    s_entry1->name = e_strdup(short_name);
    s_entry1->whole_name = e_strdup(whole_path);
    s_entry1->next = reloc_dir->contents;
    reloc_dir->contents = s_entry1;
    s_entry1->priority = 32768;
    s_entry1->parent_rec = this_dir->contents;
    set_723(s_entry1->isorec.volume_sequence_number,
                        volume_sequence_number);
    s_entry1->filedir = this_dir;
    iso9660_date(s_entry1->isorec.date, fstatbuf.st_mtime);
 
    if (use_XA || use_RockRidge) {
        generate_xa_rr_attributes(whole_path,
            short_name, s_entry1,
            statp, statp, NEED_RE);
    }
 
    statp->st_size = (off_t)0;
    statp->st_mode &= 0777;
    set_733((char *)s_entry->isorec.size, 0);
    s_entry->size = 0;
    s_entry->isorec.flags[0] = ISO_FILE;
    s_entry->inode = UNCACHED_INODE;
    s_entry->dev = UNCACHED_DEVICE;
    s_entry->de_flags |= RELOCATED_DIRECTORY;
 
    return (s_entry1);
}

Referenced by find_or_create_directory(), and insert_file_entry().

filetype()

LOCAL char * filetype

(

int

t

)

Definition at line 114 of file tree.c.

{
    static  char    unkn[32];
 
    if (S_ISFIFO(t))        /* 1 */
        return ("fifo");
    if (S_ISCHR(t))         /* 2 */
        return ("chr");
    if (S_ISMPC(t))         /* 3 */
        return ("multiplexed chr");
    if (S_ISDIR(t))         /* 4 */
        return ("dir");
    if (S_ISNAM(t))         /* 5 */
        return ("named file");
    if (S_ISBLK(t))         /* 6 */
        return ("blk");
    if (S_ISMPB(t))         /* 7 */
        return ("multiplexed blk");
    if (S_ISREG(t))         /* 8 */
        return ("regular file");
    if (S_ISCTG(t))         /* 9 */
        return ("contiguous file");
    if (S_ISLNK(t))         /* 10 */
        return ("symlink");
    if (S_ISSHAD(t))        /* 11 */
        return ("Solaris shadow inode");
    if (S_ISSOCK(t))        /* 12 */
        return ("socket");
    if (S_ISDOOR(t))        /* 13 */
        return ("door");
    if (S_ISWHT(t))         /* 14 */
        return ("whiteout");
    if (S_ISEVC(t))         /* 15 */
        return ("event count");
 
    /*
     * Needs to be last in case somebody makes this
     * a supported file type.
     */
    if ((t & S_IFMT) == 0)      /* 0 (unallocated) */
        return ("unallocated");
 
    sprintf(unkn, "octal '%o'", t & S_IFMT);
    return (unkn);
}

Referenced by ACTION_UnregisterClassInfo(), ext2_add_entry(), ext2_mkdir(), ext2_new_dir_block(), CQueryAssociations::GetCommand(), insert_file_entry(), InternalGetBinaryType(), reg_context_menu_handler(), reg_prop_sheet_handler(), test_basics(), unreg_context_menu_handler(), and unreg_prop_sheet_handler().

find_or_create_directory()

EXPORT struct directory * find_or_create_directory	(	struct directory *	parent,
		char *	path,
		struct directory_entry *	de,
		int	flag
	)

Definition at line 2508 of file tree.c.

{
    struct directory *child = 0;
    struct directory *dpnt;
    struct directory_entry *orig_de;
    struct directory *next_brother;
    const char  *cpnt;
    const char  *pnt;
    int     deep_flag = 0;
 
    orig_de = de;
 
    /*
     * XXX It seems that the tree that has been read from the
     * XXX previous session does not carry whole_name entries.
     * XXX We provide a hack in multi.c:find_or_create_directory()
     * XXX that should be removed when a reasonable method could
     * XXX be found.
     */
    if (path == NULL) {
        error(_("Warning: missing whole name for: '%s'\n"), de->name);
        path = de->name;
        if (path == NULL)
            comerrno(EX_BAD, _("Panic no node name.\n"));
    }
    pnt = strrchr(path, PATH_SEPARATOR);
    if (pnt == NULL) {
        pnt = path;
    } else {
        pnt++;
    }
 
    if (parent != NULL) {
 
        dpnt = parent->subdir;
        if (dpnt == NULL) {
            struct directory_entry *s_entry;
 
            for (s_entry = parent->contents; s_entry;
                        s_entry = s_entry->next) {
                if ((strcmp(s_entry->name, pnt) == 0) &&
                    (s_entry->de_flags & RELOCATED_DIRECTORY)) {
                    return (find_or_create_directory(
                            reloc_dir, path, de,
                                    flag));
                }
            }
        }
 
        while (dpnt) {
            /*
             * Weird hack time - if there are two directories by
             * the same name in the reloc_dir, they are not
             * treated as the same thing unless the entire path
             * matches completely.
             */
            if (flag && strcmp(dpnt->de_name, pnt) == 0) {
 
                /*
                 * XXX Remove test?
                 * XXX dpnt->de_path should always be != NULL
                 */
                if (dpnt->de_path != NULL &&
                    strcmp(dpnt->de_path, path) == 0)
                    return (dpnt);
 
                if (parent != reloc_dir &&
                    strcmp(dpnt->de_name, pnt) == 0)
                    return (dpnt);
            }
            dpnt = dpnt->next;
        }
    }
    /*
     * We don't know if we have a valid directory entry for this one yet.
     * If not, we need to create one.
     */
    if (de == NULL) {
        de = (struct directory_entry *)
            e_malloc(sizeof (struct directory_entry));
        memset(de, 0, sizeof (struct directory_entry));
        de->next = parent->contents;
        parent->contents = de;
        de->name = e_strdup(pnt);
        de->whole_name = e_strdup(path);
        de->filedir = parent;
        de->isorec.flags[0] = ISO_DIRECTORY;
        de->priority = 32768;
        de->inode = UNCACHED_INODE;
        de->dev = UNCACHED_DEVICE;
        set_723(de->isorec.volume_sequence_number,
                        volume_sequence_number);
        iso9660_file_length(pnt, de, 1);
 
        init_fstatbuf();
#ifdef APPLE_HYB
        if (apple_both) {
            /*
             * Give the directory an HFS entry
             */
            hfsdirent   *hfs_ent;
 
            hfs_ent = (hfsdirent *) e_malloc(sizeof (hfsdirent));
 
            /*
             * Fill in the defaults
             */
            memset(hfs_ent, 0, sizeof (hfsdirent));
            hfs_ent->crdate = fstatbuf.st_ctime;
            hfs_ent->mddate = fstatbuf.st_mtime;
 
            de->hfs_ent = hfs_ent;
 
            /*
             * Get the Mac directory name
             */
            get_hfs_dir((char *)path, (char *)pnt, de);
        }
#endif  /* APPLE_HYB */
    }
    /*
     * If we don't have a directory for this one yet, then allocate it now,
     * and patch it into the tree in the appropriate place.
     */
    dpnt = (struct directory *)e_malloc(sizeof (struct directory));
    memset(dpnt, 0, sizeof (struct directory));
    dpnt->next = NULL;
    dpnt->subdir = NULL;
    dpnt->self = de;
    dpnt->contents = NULL;
    dpnt->whole_name = e_strdup(path);
    cpnt = strrchr(path, PATH_SEPARATOR);
    if (cpnt)
        cpnt++;
    else
        cpnt = path;
    dpnt->de_name = e_strdup(cpnt);
    dpnt->de_path = NULL;
    set_de_path(parent, dpnt);
    dpnt->size = 0;
    dpnt->extent = 0;
    dpnt->jextent = 0;
    dpnt->jsize = 0;
#ifdef APPLE_HYB
    dpnt->hfs_ent = de->hfs_ent;
#endif  /* APPLE_HYB */
 
    if (orig_de == NULL) {
        struct stat xstatbuf;
        int     sts;
 
        /*
         * Now add a . and .. entry in the directory itself. This is a
         * little tricky - if the real directory exists, we need to
         * stat it first. Otherwise, we use the fictitious fstatbuf
         * which points to the time at which mkisofs was started.
         */
        if (parent == NULL || parent->whole_name[0] == '\0')
            sts = -1;
        else
            sts = stat_filter(parent->whole_name, &xstatbuf);
        if (debug && parent) {
            error(_("stat parent->whole_name: '%s' -> %d.\n"),
                parent->whole_name, sts);
        }
        if (sts == 0) {
            attach_dot_entries(dpnt, NULL, &xstatbuf);
        } else {
            attach_dot_entries(dpnt, NULL, NULL);
        }
    }
    if (!parent || parent == root) {
        if (!root) {
            root = dpnt;    /* First time through for root  */
                    /* directory only       */
            root->depth = 0;
            root->parent = root;
        } else {
            dpnt->depth = 1;
            if (!root->subdir) {
                root->subdir = dpnt;
            } else {
                next_brother = root->subdir;
                while (next_brother->next)
                    next_brother = next_brother->next;
                next_brother->next = dpnt;
            }
            dpnt->parent = parent;
        }
    } else {
        struct directory_entry *s_entry1;
 
        /*
         * Come through here for  normal traversal of  tree
         */
#ifdef DEBUG
        fprintf(stderr, "%s(%d) ", path, dpnt->depth);
#endif
 
        if (parent->depth > RR_relocation_depth && use_RockRidge) {
            /*
             * We come here in case that a graft-point needs to
             * create a new relocated (deep) directory.
             *
             * Replicate the entry for this directory.  The old one
             * will stay where it is, and it will be neutered so
             * that it no longer looks like a directory. The new
             * one will look like a directory, and it will be put
             * in the reloc_dir.
             */
            s_entry1 = dup_relocated_dir(parent, de, path,
                        dpnt->de_name, &fstatbuf);
            child = find_or_create_directory(reloc_dir, path,
                                s_entry1, 0);
            free(child->de_path);   /* allocated in this case */
            set_de_path(parent, child);
 
            deep_flag |= NEED_CL;
        }
        if (parent->depth > RR_relocation_depth && !use_RockRidge) {
            dir_nesting_warn(parent, path, FALSE);
            exit(EX_BAD);
        }
        dpnt->parent = parent;
        dpnt->depth = parent->depth + 1;
 
        if ((deep_flag & NEED_CL) == 0) {
            /*
             * Do not add this directory to the list of subdirs if
             * this is a relocated directory.
             */
            if (!parent->subdir) {
                parent->subdir = dpnt;
            } else {
                next_brother = parent->subdir;
                while (next_brother->next)
                    next_brother = next_brother->next;
                next_brother->next = dpnt;
            }
        }
    }
    /*
     * It doesn't exist for real, so we cannot add any
     * XA or Rock Ridge attributes.
     */
    if (orig_de == NULL || (parent == NULL && path[0] == '\0')) {
        init_fstatbuf();
        fstatbuf.st_mode = new_dir_mode | S_IFDIR;
        fstatbuf.st_nlink = 2;
        if ((use_XA || use_RockRidge) &&
            !(parent == NULL && path[0] == '\0')) {
            /*
             * We cannot set up RR attrubutes for the real
             * ISO-9660 root directory. This is why we
             * check for parent == NULL && path[0] == '\0'.
             */
            generate_xa_rr_attributes("",
                (char *)pnt, de,
                &fstatbuf,
                &fstatbuf, deep_flag);
        }
#ifdef UDF
        /* set some info used for udf */
        de->mode = fstatbuf.st_mode;
        de->uid =  fstatbuf.st_uid;
        de->gid =  fstatbuf.st_gid;
        de->atime.tv_sec = fstatbuf.st_atime;
        de->atime.tv_nsec = stat_ansecs(&fstatbuf);
        de->mtime.tv_sec = fstatbuf.st_mtime;
        de->mtime.tv_nsec = stat_mnsecs(&fstatbuf);
        de->ctime.tv_sec = fstatbuf.st_ctime;
        de->ctime.tv_nsec = stat_cnsecs(&fstatbuf);
#endif
        iso9660_date(de->isorec.date, fstatbuf.st_mtime);
    }
    if (child)
        return (child); /* Return reloaction target */
 
    return (dpnt);
}

Referenced by find_or_create_directory(), get_graft(), insert_file_entry(), main(), and merge_previous_session().

find_rr_attribute()

EXPORT char * find_rr_attribute	(	unsigned char *	pnt,
		int	len,
		char *	attr_type
	)

Definition at line 1007 of file tree.c.

{
    pnt = parse_xa(pnt, &len, 0);
    while (len >= 4) {
        if (pnt[3] != 1 && pnt[3] != 2) {
            errmsgno(EX_BAD,
                _("**BAD RRVERSION (%d) in '%c%c' field (%2.2X %2.2X).\n"),
                pnt[3], pnt[0], pnt[1], pnt[0], pnt[1]);
        }
        if (pnt[2] < 4) {
            errmsgno(EX_BAD,
                _("**BAD RRLEN (%d) in '%2.2s' field %2.2X %2.2X.\n"),
                pnt[2], pnt, pnt[0], pnt[1]);
            return (NULL);
        }
        if (strncmp((char *)pnt, attr_type, 2) == 0)
            return ((char *)pnt);
        else if (strncmp((char *)pnt, "ST", 2) == 0)
            return (NULL);
        len -= pnt[2];
        pnt += pnt[2];
    }
    return (NULL);
}

Referenced by finish_cl_pl_entries(), and finish_cl_pl_for_prev_session().

finish_cl_pl_entries()

EXPORT void finish_cl_pl_entries

(

)

Definition at line 1036 of file tree.c.

{
    struct directory_entry  *s_entry;
    struct directory_entry  *s_entry1;
    struct directory    *d_entry;
 
    /*
     * If the reloc_dir is hidden (empty), then return
     */
    if (reloc_dir->dir_flags & INHIBIT_ISO9660_ENTRY)
        return;
 
    s_entry = reloc_dir->contents;
    s_entry = s_entry->next->next;  /* Skip past . and .. */
    for (; s_entry; s_entry = s_entry->next) {
        /* skip if it's hidden */
        if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY) {
            continue;
        }
        d_entry = reloc_dir->subdir;
        while (d_entry) {
            if (d_entry->self == s_entry)
                break;
            d_entry = d_entry->next;
        };
        if (!d_entry) {
            comerrno(EX_BAD,
                    _("Unable to locate directory parent\n"));
        };
 
        if (s_entry->filedir != NULL && s_entry->parent_rec != NULL) {
            char    *rr_attr;
 
            /*
             * First fix the PL pointer in the directory in the
             * rr_reloc dir
             */
            s_entry1 = d_entry->contents->next;
 
/*          set_733((char *) s_entry1->rr_attributes +*/
/*              s_entry1->total_rr_attr_size - 8,*/
/*              s_entry->filedir->extent); */
            /*
             * The line above won't work when entry was read from
             * the previous session, because if total_rr_attr_size
             * was odd when recording previous session, now we have
             * total_rr_attr_size off by 1 due to padding.
             *
             * So, just search for the attributes by name
             */
            rr_attr = find_rr_attribute(s_entry1->rr_attributes,
                s_entry1->total_rr_attr_size, "PL");
            if (rr_attr != NULL)
                set_733(rr_attr + 4, s_entry->filedir->extent);
 
 
            /*
             * Now fix the CL pointer
             */
            s_entry1 = s_entry->parent_rec;
 
/*          set_733((char *) s_entry1->rr_attributes +*/
/*          s_entry1->total_rr_attr_size - 8, d_entry->extent); */
            rr_attr = find_rr_attribute(s_entry1->rr_attributes,
                s_entry1->total_rr_attr_size, "CL");
            if (rr_attr != NULL)
                set_733(rr_attr + 4, d_entry->extent);
        }
        s_entry->filedir = reloc_dir;   /* Now we can fix this */
    }
    /*
     * We would need to modify the NLINK terms in the assorted root
     * directory records to account for the presence of the RR_MOVED
     * directory. We do not do this here because we do it later when
     * we correct the link count for all direstories in the tree.
     */
 
 
    finish_cl_pl_for_prev_session();
}

Referenced by dirtree_fixup().

generate_iso9660_directories()

EXPORT void generate_iso9660_directories	(	struct directory *	node,
		FILE *	outfile
	)

Definition at line 2458 of file tree.c.

{
    struct directory *dpnt;
 
    dpnt = node;
 
    while (dpnt) {
        if (dpnt->extent > session_start) {
            generate_one_directory(dpnt, outfile);
        }
        if (dpnt->subdir)
            generate_iso9660_directories(dpnt->subdir, outfile);
        dpnt = dpnt->next;
    }
}

Referenced by dirtree_write(), and generate_iso9660_directories().

generate_reloc_directory()

LOCAL void generate_reloc_directory

(

)

Definition at line 820 of file tree.c.

{
    time_t      current_time;
    struct directory_entry *s_entry;
 
    /*
     * Create an  entry for our internal tree
     */
    time(&current_time);
    reloc_dir = (struct directory *)
        e_malloc(sizeof (struct directory));
    memset(reloc_dir, 0, sizeof (struct directory));
    reloc_dir->parent = root;
    reloc_dir->next = root->subdir;
    root->subdir = reloc_dir;
    reloc_dir->depth = 1;
    if (hide_rr_moved) {
        reloc_dir->whole_name = e_strdup("./.rr_moved");
        reloc_dir->de_name = e_strdup(".rr_moved");
    } else {
        reloc_dir->whole_name = e_strdup("./rr_moved");
        reloc_dir->de_name = e_strdup("rr_moved");
    }
    reloc_dir->de_path = reloc_dir->de_name;
    reloc_dir->extent = 0;
 
 
    /*
     * Now create an actual directory entry
     */
    s_entry = (struct directory_entry *)
        e_malloc(sizeof (struct directory_entry));
    memset(s_entry, 0, sizeof (struct directory_entry));
    s_entry->next = root->contents;
    reloc_dir->self = s_entry;
 
    /*
     * The rr_moved entry will not appear in the Joliet nor the UDF tree.
     */
    reloc_dir->dir_flags |= INHIBIT_JOLIET_ENTRY;
    s_entry->de_flags |= INHIBIT_JOLIET_ENTRY;
 
    reloc_dir->dir_flags |= INHIBIT_UDF_ENTRY;
    s_entry->de_flags |= INHIBIT_UDF_ENTRY;
 
    root->contents = s_entry;
    root->contents->name = e_strdup(reloc_dir->de_name);
    root->contents->filedir = root;
    root->contents->isorec.flags[0] = ISO_DIRECTORY;
    root->contents->priority = 32768;
    iso9660_date(root->contents->isorec.date, current_time);
    root->contents->inode = UNCACHED_INODE;
    root->contents->dev = UNCACHED_DEVICE;
    set_723(root->contents->isorec.volume_sequence_number,
                        volume_sequence_number);
    iso9660_file_length(reloc_dir->de_name, root->contents, 1);
 
    init_fstatbuf();
 
    if (use_XA || use_RockRidge) {
        fstatbuf.st_mode = 0555 | S_IFDIR;
        fstatbuf.st_nlink = 2;
        generate_xa_rr_attributes("",
            hide_rr_moved ? ".rr_moved" : "rr_moved",
            s_entry, &fstatbuf, &fstatbuf, NEED_RE);
    };
 
    /*
     * Now create the . and .. entries in rr_moved
     * Now create an actual directory entry
     */
    if (root_statbuf.st_nlink == 0)
        root_statbuf = fstatbuf;
    attach_dot_entries(reloc_dir, NULL, &root_statbuf);
}

Referenced by dup_relocated_dir().

init_fstatbuf()

EXPORT void init_fstatbuf

(

)

Definition at line 2974 of file tree.c.

{
    struct timeval  current_time;
 
    if (fstatbuf.st_ctime == 0) {
        gettimeofday(&current_time, NULL);
        if (rationalize_uid)
            fstatbuf.st_uid = uid_to_use;
        else
            fstatbuf.st_uid = getuid();
        if (rationalize_gid)
            fstatbuf.st_gid = gid_to_use;
        else
            fstatbuf.st_gid = getgid();
 
        current_time.tv_usec *= 1000;
        fstatbuf.st_ctime = current_time.tv_sec;
        stat_set_ansecs(&fstatbuf, current_time.tv_usec);
        fstatbuf.st_mtime = current_time.tv_sec;
        stat_set_mnsecs(&fstatbuf, current_time.tv_usec);
        fstatbuf.st_atime = current_time.tv_sec;
        stat_set_cnsecs(&fstatbuf, current_time.tv_usec);
    }
}

Referenced by attach_dot_entries(), dup_relocated_dir(), find_or_create_directory(), generate_reloc_directory(), insert_boot_cat(), root_gen(), and sort_n_finish().

insert_file_entry()

EXPORT int insert_file_entry	(	struct directory *	this_dir,
		char *	whole_path,
		char *	short_name,
		struct stat *	statp,
		int	have_rsrc
	)

Definition at line 1444 of file tree.c.

{
    struct stat statbuf,
            lstatbuf;
    struct directory_entry *s_entry,
            *s_entry1;
    int     lstatus;
    int     status;
    int     deep_flag;
#ifdef  USE_NO_SCANDIR
    int     no_scandir = 0;
#endif
 
#ifdef APPLE_HYB
    int     x_hfs = 0;
    int     htype = TYPE_NONE;
 
#endif  /* APPLE_HYB */
 
    if (statp) {
        status = lstatus = 0;
        lstatbuf = *statp;
        if (S_ISLNK(lstatbuf.st_mode)) {
            status = stat_filter(short_name, &statbuf);
        } else {
            statbuf = *statp;
        }
    } else {
        status = stat_filter(whole_path, &statbuf);
 
        lstatus = lstat_filter(whole_path, &lstatbuf);
    }
 
    if ((status == -1) && (lstatus == -1)) {
        /*
         * This means that the file doesn't exist, or isn't accessible.
         * Sometimes this is because of NFS permissions problems.
         */
        errmsg(_("Non-existent or inaccessible: %s\n"), whole_path);
        return (0);
    }
    if (S_ISDIR(statbuf.st_mode) &&
        (this_dir->depth > RR_relocation_depth) && !use_RockRidge &&
        strcmp(short_name, ".") != 0 && strcmp(short_name, "..") != 0) {
        dir_nesting_warn(this_dir, whole_path, TRUE);
        return (0);
    }
    if (this_dir == root && strcmp(short_name, ".") == 0)
        root_statbuf = statbuf; /* Save this for later on */
 
    /*
     * We do this to make sure that the root entries are consistent
     */
    if (this_dir == root && strcmp(short_name, "..") == 0) {
        statbuf = root_statbuf;
        lstatbuf = root_statbuf;
    }
    if (S_ISLNK(lstatbuf.st_mode)) {
        /*
         * Here we decide how to handle the symbolic links.  Here we
         * handle the general case - if we are not following links or
         * there is an error, then we must change something.  If RR
         * is in use, it is easy, we let RR describe the file.  If
         * not, then we punt the file.
         */
        if ((status || !follow_links)) {
#ifdef UDF
            if (use_RockRidge || use_udf) {
#else
            if (use_RockRidge) {
#endif
                status = 0;
                STAT_INODE(statbuf) = UNCACHED_INODE;
                statbuf.st_dev = UNCACHED_DEVICE;
#ifdef UDF
                if (create_udfsymlinks) {
                    char symlinkcontents[2048];
                    off_t size = sizeof (symlinkcontents);
 
                    if (udf_get_symlinkcontents(whole_path,
                        symlinkcontents, &size) == -1) {
                        statbuf.st_size = (off_t)0;
                        statbuf.st_mode =
                            (statbuf.st_mode & ~S_IFMT) | S_IFREG;
                    } else {
                        statbuf.st_size = size;
                        statbuf.st_mode = lstatbuf.st_mode;
                    }
                } else {
#endif
                    statbuf.st_size = (off_t)0;
                    statbuf.st_mode =
                        (statbuf.st_mode & ~S_IFMT) | S_IFREG;
#ifdef UDF
                }
#endif
            } else {
                if (follow_links) {
                    /* XXX errno may be wrong! */
                    errmsg(_("Unable to stat file %s - ignoring and continuing.\n"),
                        whole_path);
                } else {
                    errmsgno(EX_BAD,
                        _("Symlink %s ignored - continuing.\n"),
                        whole_path);
                    return (0); /* Non Rock Ridge discs */
                            /* - ignore all symlinks */
                }
            }
        }
        /*
         * Here we handle a different kind of case.  Here we have a
         * symlink, but we want to follow symlinks.  If we run across
         * a directory loop, then we need to pretend that we are not
         * following symlinks for this file.  If this is the first
         * time we have seen this, then make this seem as if there was
         * no symlink there in the first place
         */
        if (follow_links &&
            S_ISDIR(statbuf.st_mode)) {
            if (strcmp(short_name, ".") != 0 &&
                strcmp(short_name, "..") != 0) {
                if (find_directory_hash(statbuf.st_dev,
                            STAT_INODE(statbuf))) {
                    if (!use_RockRidge) {
                        fprintf(stderr,
                        _("Already cached directory seen (%s)\n"),
                            whole_path);
                        return (0);
                    }
                    lstatbuf = statbuf;
                    /*
                     * XXX when this line was active,
                     * XXX mkisofs did not include all
                     * XXX files if it was called with '-f'
                     * XXX (follow symlinks).
                     * XXX Now scan_directory_tree()
                     * XXX checks if the directory has
                     * XXX already been scanned via the
                     * XXX DIR_WAS_SCANNED flag.
                     */
/*                  no_scandir = 1;*/
                } else {
                    lstatbuf = statbuf;
                    add_directory_hash(statbuf.st_dev,
                            STAT_INODE(statbuf));
                }
            }
        }
        /*
         * For non-directories, we just copy the stat information over
         * so we correctly include this file.
         */
        if (follow_links &&
            !S_ISDIR(statbuf.st_mode)) {
            lstatbuf = statbuf;
        }
    }
    /*
     * Add directories to the cache so that we don't waste space even if
     * we are supposed to be following symlinks.
     */
    if (follow_links &&
        strcmp(short_name, ".") != 0 &&
        strcmp(short_name, "..") != 0 &&
        S_ISDIR(statbuf.st_mode)) {
        add_directory_hash(statbuf.st_dev, STAT_INODE(statbuf));
    }
#ifdef VMS
    if (!S_ISDIR(lstatbuf.st_mode) && (statbuf.st_fab_rfm != FAB$C_FIX &&
            statbuf.st_fab_rfm != FAB$C_STMLF)) {
        fprintf(stderr,
        _("Warning - file %s has an unsupported VMS record format (%d)\n"),
            whole_path, statbuf.st_fab_rfm);
    }
#endif
 
    if (S_ISREG(lstatbuf.st_mode) &&
        ((statp != NULL && (status = access(short_name, R_OK))) ||
        (statp == NULL && (status = access(whole_path, R_OK))))) {
        errmsg(_("File %s is not readable - ignoring\n"),
            whole_path);
        return (0);
    }
#ifdef  USE_LARGEFILES
    if (S_ISREG(lstatbuf.st_mode) && (lstatbuf.st_size >= maxnonlarge) &&
        !do_largefiles) {
#else
    /*
     * >= is required by the large file summit standard.
     */
    if (S_ISREG(lstatbuf.st_mode) && (lstatbuf.st_size >= (off_t)0x7FFFFFFF)) {
#endif
#ifdef  EOVERFLOW
        errno = EOVERFLOW;
#else
        errno = EFBIG;
#endif
        errmsg(_("File %s is too large for current mkisofs settings (-iso-level 3 or more required) - ignoring\n"),
            whole_path);
        return (0);
    }
    /*
     * Add this so that we can detect directory loops with hard links.
     * If we are set up to follow symlinks, then we skip this checking.
     */
    if (!follow_links &&
        S_ISDIR(lstatbuf.st_mode) &&
        strcmp(short_name, ".") != 0 &&
        strcmp(short_name, "..") != 0) {
        if (find_directory_hash(statbuf.st_dev, STAT_INODE(statbuf))) {
/*          comerrno(EX_BAD,*/
/*          _("Directory loop - fatal goof (%s %lx %lu).\n"),*/
            errmsgno(EX_BAD,
            _("Warning: Directory loop (%s dev: %lx ino: %lu).\n"),
                whole_path, (unsigned long) statbuf.st_dev,
                (unsigned long) STAT_INODE(statbuf));
        }
        add_directory_hash(statbuf.st_dev, STAT_INODE(statbuf));
    }
    if (!S_ISCHR(lstatbuf.st_mode) && !S_ISBLK(lstatbuf.st_mode) &&
        !S_ISFIFO(lstatbuf.st_mode) && !S_ISSOCK(lstatbuf.st_mode) &&
        !S_ISLNK(lstatbuf.st_mode) && !S_ISREG(lstatbuf.st_mode) &&
        !S_ISDIR(lstatbuf.st_mode)) {
        fprintf(stderr,
        _("Unknown file type (%s) %s - ignoring and continuing.\n"),
            filetype((int)lstatbuf.st_mode), whole_path);
        return (0);
    }
    /*
     * Who knows what trash this is - ignore and continue
     */
    if (status) {
        errmsg(_("Unable to stat file %s - ignoring and continuing.\n"),
            whole_path);
        return (0);
    }
 
#if !defined(__MINGW32__) && !defined(_MSC_VER)
#define is_archive(st)  ((st).st_dev == archive_dev && (st).st_ino == archive_ino)
    if (archive_isreg && is_archive(statbuf)) {
        errmsgno(EX_BAD,
            _("'%s' is the archive. Not dumped.\n"), whole_path);
        return (0);
    }
#endif
 
    /*
     * Check to see if we have already seen this directory node. If so,
     * then we don't create a new entry for it, but we do want to recurse
     * beneath it and add any new files we do find.
     */
    if (S_ISDIR(statbuf.st_mode)) {
        int dflag;
 
        for (s_entry = this_dir->contents; s_entry;
                        s_entry = s_entry->next) {
            if (strcmp(s_entry->name, short_name) == 0) {
                break;
            }
        }
        if (s_entry != NULL &&
            strcmp(short_name, ".") != 0 &&
            strcmp(short_name, "..") != 0) {
            struct directory *child;
 
            /*
             * This should not create a new directory
             */
            if ((s_entry->de_flags & RELOCATED_DIRECTORY) != 0) {
                for (s_entry = reloc_dir->contents; s_entry;
                        s_entry = s_entry->next) {
                    if (strcmp(s_entry->name, short_name)
                                    == 0) {
                        break;
                    }
                }
                child = find_or_create_directory(reloc_dir,
                    whole_path,
                    s_entry, 1);
            } else {
                child = find_or_create_directory(this_dir,
                    whole_path,
                    s_entry, 1);
                /*
                 * If unable to scan directory, mark this as a
                 * non-directory
                 */
            }
/*          if (no_scandir)*/
            if (0)
                dflag = 1;
            else
                dflag = scan_directory_tree(child,
                            whole_path, s_entry);
            if (!dflag) {
                lstatbuf.st_mode =
                    (lstatbuf.st_mode & ~S_IFMT) | S_IFREG;
            }
            return (0);
        }
    }
#ifdef APPLE_HYB
    /*
     * Should we exclude this HFS file ? - only works with -hfs
     */
    if (!have_rsrc && apple_hyb && strcmp(short_name, ".") != 0 &&
                    strcmp(short_name, "..") != 0) {
        if ((x_hfs = (hfs_matches(short_name) ||
                    hfs_matches(whole_path))) == 1) {
            if (verbose > 1) {
                fprintf(stderr, _("Hidden from HFS tree: %s\n"),
                            whole_path);
            }
        }
    }
    /*
     * check we are a file, using Apple extensions and have a .resource
     * part and not excluded
     */
    if (S_ISREG(lstatbuf.st_mode) && !have_rsrc && apple_both && !x_hfs) {
        char    rsrc_path[PATH_MAX];    /* rsrc fork filename */
 
        /*
         * Construct the resource full path
         */
        htype = get_hfs_rname(whole_path, short_name, rsrc_path);
        /*
         * Check we can read the resouce fork
         */
        if (htype) {
            struct stat rstatbuf,
                    rlstatbuf;
 
            /*
             * Some further checks on the file
             */
            status = stat_filter(rsrc_path, &rstatbuf);
 
            lstatus = lstat_filter(rsrc_path, &rlstatbuf);
 
/*          if (!status && !lstatus && S_ISREG(rlstatbuf.st_mode)*/
/*                  && rlstatbuf.st_size > (off_t)0) { */
            if (!status && !lstatus && S_ISREG(rstatbuf.st_mode) &&
                    rstatbuf.st_size > (off_t)0) {
 
                /*
                 * have a resource file - insert it into the
                 * current directory but flag that we have a
                 * resource fork
                 */
                insert_file_entry(this_dir, rsrc_path,
                            short_name, NULL, htype);
            }
        }
    }
#endif  /* APPLE_HYB */
 
    s_entry = (struct directory_entry *)
        e_malloc(sizeof (struct directory_entry));
    /* memset the whole struct, not just the isorec.extent part JCP */
    memset(s_entry, 0, sizeof (struct directory_entry));
    s_entry->next = this_dir->contents;
/*  memset(s_entry->isorec.extent, 0, 8); */
    this_dir->contents = s_entry;
    deep_flag = 0;
    s_entry->table = NULL;
 
    s_entry->name = e_strdup(short_name);
    s_entry->whole_name = e_strdup(whole_path);
 
    s_entry->de_flags = 0;
    if (S_ISLNK(lstatbuf.st_mode))
        s_entry->de_flags |= IS_SYMLINK;
#ifdef  DUPLICATES_ONCE
    s_entry->digest_fast = NULL;
    s_entry->digest_full = NULL;
#endif
 
    /*
     * If the current directory is hidden, then hide all it's members
     * otherwise check if this entry needs to be hidden as well
     */
    if (this_dir->dir_flags & INHIBIT_ISO9660_ENTRY) {
        s_entry->de_flags |= INHIBIT_ISO9660_ENTRY;
    } else if (strcmp(short_name, ".") != 0 &&
            strcmp(short_name, "..") != 0) {
        if (i_matches(short_name) || i_matches(whole_path)) {
            if (verbose > 1) {
                fprintf(stderr,
                    _("Hidden from ISO9660 tree: %s\n"),
                    whole_path);
            }
            s_entry->de_flags |= INHIBIT_ISO9660_ENTRY;
        }
        if (h_matches(short_name) || h_matches(whole_path)) {
            if (verbose > 1) {
                fprintf(stderr,
                    _("Hidden ISO9660 attribute: %s\n"),
                    whole_path);
            }
            s_entry->de_flags |= HIDDEN_FILE;
        }
    }
    if (this_dir != reloc_dir &&
                this_dir->dir_flags & INHIBIT_JOLIET_ENTRY) {
        s_entry->de_flags |= INHIBIT_JOLIET_ENTRY;
    } else if (strcmp(short_name, ".") != 0 &&
            strcmp(short_name, "..") != 0) {
        if (j_matches(short_name) || j_matches(whole_path)) {
            if (verbose > 1) {
                fprintf(stderr,
                    _("Hidden from Joliet tree: %s\n"),
                    whole_path);
            }
            s_entry->de_flags |= INHIBIT_JOLIET_ENTRY;
        }
    }
    if (this_dir != reloc_dir &&
                this_dir->dir_flags & INHIBIT_UDF_ENTRY) {
        s_entry->de_flags |= INHIBIT_UDF_ENTRY;
    } else if (strcmp(short_name, ".") != 0 &&
            strcmp(short_name, "..") != 0) {
        if (u_matches(short_name) || u_matches(whole_path)) {
            if (verbose > 1) {
                fprintf(stderr,
                    _("Hidden from UDF tree: %s\n"),
                    whole_path);
            }
            s_entry->de_flags |= INHIBIT_UDF_ENTRY;
        }
    }
 
#ifdef SORTING
    /*
     * Inherit any sort weight from parent directory
     */
    s_entry->sort = this_dir->sort;
 
#ifdef  DVD_AUD_VID
    /*
     * No use at all to do a sort if we don't make a dvd video/audio
     */
    /*
     * Assign special weights to VIDEO_TS and AUDIO_TS files.
     * This can't be done with sort_matches for two reasons:
     * first, we need to match against the destination (DVD)
     * path rather than the source path, and second, there are
     * about 2400 different file names to check, each needing
     * a different priority, and adding that many patterns to
     * sort_matches would slow things to a crawl.
     */
 
    if (dvd_aud_vid_flag) {
        s_entry->sort = assign_dvd_weights(s_entry->name, this_dir, s_entry->sort);
        /*
         * Turn on sorting if necessary, regardless of cmd-line options
         */
        if ((s_entry->sort != this_dir->sort) && do_sort == 0)
            do_sort++;
    }
#endif
 
    /*
     * See if this entry should have a new weighting
     */
    if (do_sort && strcmp(short_name, ".") != 0 &&
            strcmp(short_name, "..") != 0) {
        s_entry->sort = sort_matches(whole_path, s_entry->sort);
    }
#endif /* SORTING */
 
    s_entry->filedir = this_dir;
    s_entry->isorec.flags[0] = ISO_FILE;
    if (s_entry->de_flags & HIDDEN_FILE)
        s_entry->isorec.flags[0] |= ISO_EXISTENCE;
    s_entry->isorec.ext_attr_length[0] = 0;
    iso9660_date(s_entry->isorec.date, statbuf.st_mtime);
    s_entry->isorec.file_unit_size[0] = 0;
    s_entry->isorec.interleave[0] = 0;
 
#ifdef APPLE_HYB
    if (apple_both && !x_hfs) {
        s_entry->hfs_ent = NULL;
        s_entry->assoc = NULL;
        s_entry->hfs_off = (off_t)0;
        s_entry->hfs_type = htype;
        if (have_rsrc) {
            /* associated (rsrc) file */
            s_entry->isorec.flags[0] |= ISO_ASSOCIATED;
            /* set the type of HFS file */
            s_entry->hfs_type = have_rsrc;
            /*
             * don't want the rsrc file to be included in any
             * Joliet/UDF tree
             */
            s_entry->de_flags |= INHIBIT_JOLIET_ENTRY;
            s_entry->de_flags |= INHIBIT_UDF_ENTRY;
        } else if (s_entry->next) {
            /*
             * if previous entry is an associated file,
             * then "link" it to this file i.e. we have a
             * data/resource pair
             */
            if (s_entry->next->isorec.flags[0] & ISO_ASSOCIATED) {
                s_entry->assoc = s_entry->next;
                /*
                 * share the same HFS parameters
                 */
                s_entry->hfs_ent = s_entry->next->hfs_ent;
                s_entry->hfs_type = s_entry->next->hfs_type;
            }
        }
        /*
         * Allocate HFS entry if required
         */
        if (apple_both && strcmp(short_name, ".") != 0 &&
                    strcmp(short_name, "..") != 0) {
            if (!s_entry->hfs_ent) {
                hfsdirent   *hfs_ent;
 
                hfs_ent =
                (hfsdirent *) e_malloc(sizeof (hfsdirent));
 
                /*
                 * Sill in the defaults
                 */
                memset(hfs_ent, 0, sizeof (hfsdirent));
 
                s_entry->hfs_ent = hfs_ent;
            }
            /*
             * the resource fork is processed first, but the
             * data fork's time info is used in preference
             * i.e. time info is set from the resource fork
             * initially, then it is set from the data fork
             */
            if (have_rsrc) {
                /*
                 * Set rsrc size
                 */
                s_entry->hfs_ent->u.file.rsize = lstatbuf.st_size;
                /*
                 * This will be overwritten - but might as
                 * well set it here ...
                 */
                s_entry->hfs_ent->crdate = lstatbuf.st_ctime;
                s_entry->hfs_ent->mddate = lstatbuf.st_mtime;
            } else {
                /*
                 * Set data size
                 */
                s_entry->hfs_ent->u.file.dsize = lstatbuf.st_size;
                s_entry->hfs_ent->crdate = lstatbuf.st_ctime;
                s_entry->hfs_ent->mddate = lstatbuf.st_mtime;
            }
        }
    }
#endif  /* APPLE_HYB */
 
    if (strcmp(short_name, ".") == 0) {
        this_dir->dir_flags |= DIR_HAS_DOT;
    }
    if (strcmp(short_name, "..") == 0) {
        this_dir->dir_flags |= DIR_HAS_DOTDOT;
    }
    if (this_dir->parent &&
        this_dir->parent == reloc_dir &&
        strcmp(short_name, "..") == 0) {
        s_entry->inode = UNCACHED_INODE;
        s_entry->dev = UNCACHED_DEVICE;
        deep_flag = NEED_PL;
    } else
#ifdef APPLE_HYB
    if (have_rsrc) {
        /*
         * don't want rsrc files to be cached
         */
        s_entry->de_flags |= RESOURCE_FORK;
        s_entry->inode = UNCACHED_INODE;
        s_entry->dev = UNCACHED_DEVICE;
    } else
#endif  /* APPLE_HYB */
    {
        s_entry->inode = STAT_INODE(statbuf);
        s_entry->dev = statbuf.st_dev;
    }
    set_723(s_entry->isorec.volume_sequence_number,
                        volume_sequence_number);
    iso9660_file_length(short_name, s_entry, S_ISDIR(statbuf.st_mode));
    s_entry->rr_attr_size = 0;
    s_entry->total_rr_attr_size = 0;
    s_entry->rr_attributes = NULL;
 
    /*
     * Directories are assigned sizes later on
     */
    if (!S_ISDIR(statbuf.st_mode)) {
        if (S_ISCHR(lstatbuf.st_mode) || S_ISBLK(lstatbuf.st_mode) ||
            S_ISFIFO(lstatbuf.st_mode) ||
                S_ISSOCK(lstatbuf.st_mode) ||
#ifdef  UDF
                (S_ISLNK(lstatbuf.st_mode) && !create_udfsymlinks)) {
#else
                FALSE) {
#endif
            s_entry->size = (off_t)0;
            statbuf.st_size = (off_t)0;
        } else {
            s_entry->size = statbuf.st_size;
        }
 
        set_733((char *)s_entry->isorec.size, statbuf.st_size);
    } else {
        s_entry->isorec.flags[0] |= ISO_DIRECTORY;
    }
#ifdef APPLE_HYB
    /*
     * If the directory is HFS excluded, then we don't have an hfs_ent
     */
    if (apple_both && s_entry->hfs_ent &&
                (s_entry->isorec.flags[0] & ISO_DIRECTORY)) {
        /*
         * Get the Mac directory name
         */
        get_hfs_dir(whole_path, short_name, s_entry);
 
        /*
         * If required, set ISO directory name from HFS name
         */
        if (use_mac_name)
            iso9660_file_length(s_entry->hfs_ent->name, s_entry, 1);
    }
#endif  /* APPLE_HYB */
 
    if (strcmp(short_name, ".") != 0 && strcmp(short_name, "..") != 0 &&
        S_ISDIR(statbuf.st_mode) &&
                this_dir->depth > RR_relocation_depth) {
        struct directory *child;
 
        /*
         * Replicate the entry for this directory.  The old one will
         * stay where it is, and it will be neutered so that it no
         * longer looks like a directory. The new one will look like
         * a directory, and it will be put in the reloc_dir.
         */
        s_entry1 = dup_relocated_dir(this_dir, s_entry,
                    whole_path, short_name, &statbuf);
 
        /*
         * We need to set this temporarily so that the parent to this
         * is correctly determined.
         */
        s_entry1->filedir = reloc_dir;
        child = find_or_create_directory(reloc_dir, whole_path,
            s_entry1, 0);
        free(child->de_path);       /* allocated in this case */
        set_de_path(this_dir, child);
 
 
/*      if (!no_scandir)*/
        if (!0)
            scan_directory_tree(child, whole_path, s_entry1);
        s_entry1->filedir = this_dir;
        deep_flag = NEED_CL;
    }
    if (generate_tables &&
        strcmp(s_entry->name, ".") != 0 &&
        strcmp(s_entry->name, "..") != 0) {
 
        char    buffer[SECTOR_SIZE];
        int nchar;
 
        switch (lstatbuf.st_mode & S_IFMT) {
        case S_IFDIR:
            sprintf(buffer, "D\t%s\n",
                s_entry->name);
            break;
 
/*
 * extra for WIN32 - if it doesn't have the major/minor defined, then
 * S_IFBLK and S_IFCHR type files are unlikely to exist anyway ...
 * code similar to that in rock.c
 */
#if 0
/*
 * Use the device handling code from <schily/device.h>
 */
#ifndef major
#define major(dev) (sizeof (dev_t) <= 2 ? ((dev) >> 8) : \
    (sizeof (dev_t) <= 4 ? (((dev) >> 8) >> 8) : \
    (((dev) >> 16) >> 16)))
#define minor(dev) (sizeof (dev_t) <= 2 ? (dev) & 0xff : \
    (sizeof (dev_t) <= 4 ? (dev) & 0xffff : \
    (dev) & 0xffffffff))
#endif
#endif
 
#ifdef S_IFBLK
        case S_IFBLK:
            sprintf(buffer, "B\t%s\t%lu %lu\n",
                s_entry->name,
                (unsigned long) major(statbuf.st_rdev),
                (unsigned long) minor(statbuf.st_rdev));
            break;
#endif
#ifdef S_IFIFO
        case S_IFIFO:
            sprintf(buffer, "P\t%s\n",
                s_entry->name);
            break;
#endif
#ifdef S_IFCHR
        case S_IFCHR:
            sprintf(buffer, "C\t%s\t%lu %lu\n",
                s_entry->name,
                (unsigned long) major(statbuf.st_rdev),
                (unsigned long) minor(statbuf.st_rdev));
            break;
#endif
#ifdef S_IFLNK
        case S_IFLNK:
#ifdef  HAVE_READLINK
            nchar = readlink(statp?short_name:whole_path,
                (char *)symlink_buff,
                sizeof (symlink_buff)-1);
            if (nchar < 0) {
                errmsg(_("Cannot read link '%s'.\n"),
                    statp?short_name:whole_path);
            }
#else
            nchar = -1;
#endif
            symlink_buff[nchar < 0 ? 0 : nchar] = 0;
            sprintf(buffer, "L\t%s\t%s\n",
                s_entry->name, symlink_buff);
            break;
#endif
#ifdef S_IFSOCK
        case S_IFSOCK:
            sprintf(buffer, "S\t%s\n",
                s_entry->name);
            break;
#endif
        case S_IFREG:
        default:
            sprintf(buffer, "F\t%s\n",
                s_entry->name);
            break;
        };
        s_entry->table = e_strdup(buffer);
    }
    if (S_ISDIR(statbuf.st_mode)) {
        int dflag;
 
        if (strcmp(short_name, ".") != 0 &&
            strcmp(short_name, "..") != 0) {
            struct directory *child;
 
            child = find_or_create_directory(this_dir, whole_path,
                s_entry, 1);
#ifdef  USE_NO_SCANDIR
            if (no_scandir)
                dflag = 1;
            else
#endif
                dflag = scan_directory_tree(child, whole_path,
                                s_entry);
 
            if (!dflag) {
                lstatbuf.st_mode =
                    (lstatbuf.st_mode & ~S_IFMT) | S_IFREG;
                if (child->contents == NULL) {
                    delete_directory(this_dir, child);
                }
            }
        }
        /* If unable to scan directory, mark this as a non-directory */
    }
    if (use_RockRidge && this_dir == root &&
        strcmp(s_entry->name, ".") == 0) {
        deep_flag |= NEED_CE | NEED_SP; /* For extension record */
    }
    /*
     * Now figure out how much room this file will take in the directory
     */
 
#ifdef APPLE_HYB
    /*
     * Ff the file is HFS excluded, then we don't have an hfs_ent
     */
    if (apple_both && !have_rsrc && s_entry->hfs_ent) {
        if (S_ISREG(lstatbuf.st_mode)) { /* it's a regular file */
 
            /*
             * Fill in the rest of the HFS entry
             */
            get_hfs_info(whole_path, short_name, s_entry);
 
            /*
             * If required, set ISO directory name from HFS name
             */
            if (use_mac_name)
                iso9660_file_length(s_entry->hfs_ent->name,
                                s_entry, 0);
 
            /*
             * Print details about the HFS file
             */
            if (verbose > 2)
                print_hfs_info(s_entry);
 
            /*
             * copy the new ISO9660 name to the rsrc fork
             * - if it exists
             */
            if (s_entry->assoc)
                strcpy(s_entry->assoc->isorec.name,
                            s_entry->isorec.name);
 
            /*
             * we can't handle hard links in the hybrid case, so we
             * "uncache" the file. The downside to this is that
             * hard linked files are added to the output image
             * more than once (we've already done this for rsrc
             * files)
             */
            if (apple_hyb && have_rsrc) {
                s_entry->de_flags |= RESOURCE_FORK;
                s_entry->inode = UNCACHED_INODE;
                s_entry->dev = UNCACHED_DEVICE;
            }
        } else if (!(s_entry->isorec.flags[0] & ISO_DIRECTORY)) {
            /* not a directory .. */
 
            /*
             * no mac equivalent, so ignore - have to be careful
             * here, the hfs_ent may be also be for a relocated
             * directory
             */
            if (s_entry->hfs_ent &&
                !(s_entry->de_flags & RELOCATED_DIRECTORY) &&
                (s_entry->isorec.flags[0] & ISO_MULTIEXTENT) == 0) {
                free(s_entry->hfs_ent);
            }
            s_entry->hfs_ent = NULL;
        }
        /*
         * if the rsrc size is zero, then we don't need the entry, so
         * we might as well delete it - this will only happen if we
         * didn't know the rsrc size from the rsrc file size
         */
        if (s_entry->assoc && s_entry->assoc->size == 0)
            delete_rsrc_ent(s_entry);
    }
    if (apple_ext && s_entry->assoc) {
        /*
         * Need Apple extensions for the resource fork as well
         */
        generate_xa_rr_attributes(whole_path,
            short_name, s_entry->assoc,
            &statbuf, &lstatbuf, deep_flag | (statp?DID_CHDIR:0));
    }
    /* leave out resource fork for the time being */
    /*
     * XXX This is most likely wrong and should just be:
     * XXX if (use_XA || use_RockRidge) {
     */
/*  if ((use_XA || use_RockRidge) && !have_rsrc) {*/
    if (use_XA || use_RockRidge) {
#else
    if (use_XA || use_RockRidge) {
#endif  /* APPLE_HYB */
        generate_xa_rr_attributes(whole_path,
            short_name, s_entry,
            &statbuf, &lstatbuf, deep_flag | (statp?DID_CHDIR:0));
 
    }
#ifdef UDF
    /* set some info used for udf */
    s_entry->mode = lstatbuf.st_mode;
    s_entry->rdev = lstatbuf.st_rdev;
    s_entry->uid = lstatbuf.st_uid;
    s_entry->gid = lstatbuf.st_gid;
    s_entry->atime.tv_sec = lstatbuf.st_atime;
    s_entry->atime.tv_nsec = stat_ansecs(&lstatbuf);
    s_entry->mtime.tv_sec = lstatbuf.st_mtime;
    s_entry->mtime.tv_nsec = stat_mnsecs(&lstatbuf);
    s_entry->ctime.tv_sec = lstatbuf.st_ctime;
    s_entry->ctime.tv_nsec = stat_cnsecs(&lstatbuf);
#endif
 
#ifdef  USE_LARGEFILES
#ifndef MAX_EXTENT
    /*
     * Allow to #define MAX_EXTENT from outside for debug purposes.
     */
#ifdef  PROTOTYPES
#define LARGE_EXTENT    ((off_t)0xFFFFF800UL)
#define MAX_EXTENT  ((off_t)0xFFFFFFFEUL)
#else
#define LARGE_EXTENT    ((off_t)0xFFFFF800L)
#define MAX_EXTENT  ((off_t)0xFFFFFFFEL)
#endif
#else   /* MAX_EXTENT */
#define LARGE_EXTENT    MAX_EXTENT & ~(off_t)2047L
#endif  /* !MAX_EXTENT */
    /*
     * Break up files greater than (4GB -2) into multiple extents.
     * The original entry, with ->size untouched, remains for UDF.
     * Each of the new file sections will get its own entry.
     * The file sections are the only entries actually written out to the
     * disk. The UDF entry will use "mxroot" to get the same start
     * block as the first file section, and all the sections will end up
     * in the ISO9660 directory in the correct order by "mxpart",
     * which the directory sorting routine knows about.
     *
     * If we ever need to be able to find mxpart == 1 after sorting,
     * we need to add another pointer to s_entry or to be very careful
     * with the loops above where the ISO-9660 name is copied back to
     * all multi-extent parts.
     */
    if (s_entry->size > MAX_EXTENT) {
        off_t   size;
 
        s_entry->de_flags |= MULTI_EXTENT;
        s_entry->isorec.flags[0] |= ISO_MULTIEXTENT;
        s_entry->mxroot = s_entry;
        s_entry->mxpart = 0;
        set_733((char *)s_entry->isorec.size, LARGE_EXTENT);
        s_entry1 = dup_directory_entry(s_entry);
        s_entry->next = s_entry1;
 
        /*
         * full size UDF version
         */
        s_entry->de_flags |= INHIBIT_ISO9660_ENTRY|INHIBIT_JOLIET_ENTRY;
        if (s_entry->size > (((off_t)190)*0x3FFFF800)) {
#ifndef EOVERFLOW
#define EOVERFLOW   EFBIG
#endif
            errmsgno(EOVERFLOW,
            _("File %s is too large - hiding from UDF tree.\n"),
                            whole_path);
            s_entry->de_flags |= INHIBIT_UDF_ENTRY;
        }
 
        /*
         * Prepare the first file multi-extent section of the file.
         */
        s_entry = s_entry1;
        s_entry->de_flags |= INHIBIT_UDF_ENTRY;
        size = s_entry->size;
        s_entry->size = LARGE_EXTENT;
        s_entry->mxpart++;
 
        /*
         * Additional extents, as needed
         */
        while (size > MAX_EXTENT) {
            s_entry1 = dup_directory_entry(s_entry);
            s_entry->next = s_entry1;
 
            s_entry = s_entry1;
            s_entry->mxpart++;
            size -= LARGE_EXTENT;
        }
        /*
         * That was the last one.
         */
        s_entry->isorec.flags[0] &= ~ISO_MULTIEXTENT;
        s_entry->size = size;
        set_733((char *)s_entry->isorec.size, (UInt32_t)s_entry->size);
    }
#endif /* USE_LARGEFILES */
 
    return (1);
}

Referenced by get_graft(), insert_file_entry(), and scan_directory_tree().

lstat_filter()

EXPORT int lstat_filter	(	char *	path,
		struct stat *	st
	)

Definition at line 244 of file tree.c.

{
    int result = lstat(path, st);
 
    if (result >= 0 && rationalize)
        stat_fix(st);
    return (result);
}

Referenced by get_graft(), insert_file_entry(), and merge_previous_session().

rstr()

LOCAL char * rstr	(	char *	s1,
		char *	s2
	)

Definition at line 165 of file tree.c.

{
    int l1;
    int l2;
 
    l1 = strlen(s1);
    l2 = strlen(s2);
    if (l2 > l1)
        return ((char *)NULL);
 
    if (strcmp(&s1[l1 - l2], s2) == 0)
        return (&s1[l1 - l2]);
    return ((char *)NULL);
}

Referenced by add_eval(), eval_binary(), eval_like(), eval_refcmp(), eval_strcmp(), RopeTest::io(), and scan_directory_tree().

scan_directory_tree()

EXPORT int scan_directory_tree	(	struct directory *	this_dir,
		char *	path,
		struct directory_entry *	de
	)

Definition at line 1147 of file tree.c.

{
    DIR     *current_dir;
    char        whole_path[2*PATH_MAX]; /* Avoid stat buffer overflow */
    struct dirent   *d_entry;
    int     dflag;
extern  BOOL        nodesc;
 
    if (nodesc)
        return (1);
 
    if (verbose > 1) {
        fprintf(stderr, _("Scanning %s\n"), path);
    }
/*#define   check_needed*/
#ifdef  check_needed
    /*
     * Trying to use this to avoid directory loops from hard links
     * or followed symlinks does not work. It would prevent us from
     * implementing merge directories.
     */
    if (this_dir->dir_flags & DIR_WAS_SCANNED) {
        fprintf(stderr, _("Already scanned directory %s\n"), path);
        return (1); /* It's a directory */
    }
#endif
    this_dir->dir_flags |= DIR_WAS_SCANNED;
 
    errno = 0;  /* Paranoia */
    current_dir = opendir(path);
    d_entry = NULL;
 
    /*
     * Apparently NFS sometimes allows you to open the directory, but then
     * refuses to allow you to read the contents.  Allow for this
     */
    if (current_dir) {
        errno = 0;
        d_entry = readdir(current_dir);
    }
 
    if (!current_dir || (!d_entry && errno != 0)) {
        int ret = 1;
 
        errmsg(_("Unable to open directory %s\n"), path);
 
        if (errno == ENOTDIR) {
            /*
             * Mark as not a directory
             */
            de->isorec.flags[0] &= ~ISO_DIRECTORY;
            ret = 0;
        }
        if (current_dir)
            closedir(current_dir);
        return (ret);
    }
 
    /*
     * Set up the struct for the current directory, and insert it into
     * the tree
     */
#ifdef VMS
    vms_path_fixup(path);
#endif
 
    /*
     * if entry for this sub-directory is hidden, then hide this directory
     */
    if (de->de_flags & INHIBIT_ISO9660_ENTRY)
        this_dir->dir_flags |= INHIBIT_ISO9660_ENTRY;
 
    if (de->de_flags & INHIBIT_JOLIET_ENTRY)
        this_dir->dir_flags |= INHIBIT_JOLIET_ENTRY;
 
#ifdef SORTING
    /*
     * set any sort weighting from it's own directory entry - if a
     * directory is given a weighting, then all the contents will use
     * this as the default weighting
     */
    this_dir->sort = de->sort;
#endif /* SORTING */
 
    /*
     * Now we scan the directory itself, and look at what is inside of it.
     */
    whole_path[0] = '\0';
    dflag = -2;
    while (1 == 1) {
        char    *d_name;
 
        if (dflag < 0) {
            /*
             * Some filesystems do not deliver "." and ".." at all,
             * others (on Linux) deliver them in the wrong order.
             * Make sure we add "." and ".." before all other
             * entries.
             */
            if (dflag < -1)
                d_name = ".";
            else
                d_name = "..";
            dflag++;
        } else {
            /*
             * The first time through, skip this, since we already
             * asked for the first entry when we opened the
             * directory.
             */
            if (dflag > 0) {
                d_entry = readdir(current_dir);
            } else {
                dflag++;
            }
            if (!d_entry)
                break;
            d_name = d_entry->d_name;
        }
 
        /*
         * OK, got a valid entry
         *
         * If we do not want all files, then pitch the backups.
         */
        if (!all_files) {
            if (strchr(d_name, '~') ||
                strchr(d_name, '#') ||
                rstr(d_name, ".bak")) {
                if (verbose > 0) {
                    fprintf(stderr,
                        _("Ignoring file %s\n"),
                        d_name);
                }
                continue;
            }
        }
#ifdef APPLE_HYB
        if (apple_both) {
            /*
             * exclude certain HFS type files/directories for the
             * time being
             */
            if (hfs_exclude(d_name))
                continue;
        }
#endif  /* APPLE_HYB */
 
        if (strlen(path) + strlen(d_name) + 2 > sizeof (whole_path)) {
            errmsgno(EX_BAD, _("Path name %s/%s too long.\n"),
                    path, d_name);
            comerrno(EX_BAD, _("Overflow of stat buffer\n"));
        };
 
        /*
         * Generate the complete ASCII path for this file
         */
        strlcpy(whole_path, path, sizeof (whole_path));
#ifndef VMS
        if (whole_path[strlen(whole_path) - 1] != '/')
            strcat(whole_path, "/");
#endif
        strcat(whole_path, d_name);
 
        /*
         * Should we exclude this file ?
         * Do no check "." and ".."
         */
        if (!(d_name[0] == '.' && (d_name[1] == '\0' ||
            (d_name[1] == '.' && d_name[2] == '\0'))) &&
            (matches(d_name) || matches(whole_path))) {
            if (verbose > 1) {
                fprintf(stderr,
                    _("Excluded by match: %s\n"), whole_path);
            }
            continue;
        }
        if (generate_tables &&
            strcmp(d_name, trans_tbl) == 0) {
            /*
             * Ignore this entry.  We are going to be generating
             * new versions of these files, and we need to ignore
             * any originals that we might have found.
             */
            if (verbose > 1) {
                fprintf(stderr, _("Excluded: %s\n"), whole_path);
            }
            continue;
        }
        /*
         * If we already have a '.' or a '..' entry, then don't insert
         * new ones.
         */
        if (strcmp(d_name, ".") == 0 &&
            this_dir->dir_flags & DIR_HAS_DOT) {
            continue;
        }
        if (strcmp(d_name, "..") == 0 &&
            this_dir->dir_flags & DIR_HAS_DOTDOT) {
            continue;
        }
#if 0
        if (verbose > 1)
            fprintf(stderr, "%s\n", whole_path);
#endif
        /*
         * This actually adds the entry to the directory in question.
         */
        insert_file_entry(this_dir, whole_path, d_name, NULL, 0);
    }
    closedir(current_dir);
 
#ifdef APPLE_HYB
    /*
     * if we cached the HFS info stuff for this directory, then delete it
     */
    if (this_dir->hfs_info) {
        del_hfs_info(this_dir->hfs_info);
        this_dir->hfs_info = 0;
    }
#endif  /* APPLE_HYB */
 
    return (1);
}

Referenced by get_graft(), and insert_file_entry().

search_tree_file()

EXPORT struct directory_entry * search_tree_file	(	struct directory *	node,
		char *	filename
	)

Definition at line 2885 of file tree.c.

{
    struct directory_entry *depnt;
    struct directory *dpnt;
    char        *p1;
    char        *rest;
    char        *subdir;
 
    /*
     * Strip off next directory name from filename:
     */
    subdir = e_strdup(filename);
 
    if ((p1 = strchr(subdir, '/')) == subdir) {
        fprintf(stderr,
        _("call to search_tree_file with an absolute path, stripping\n"));
        fprintf(stderr,
        _("initial path separator. Hope this was intended...\n"));
        memmove(subdir, subdir + 1, strlen(subdir) - 1);
        p1 = strchr(subdir, '/');
    }
    /*
     * Do we need to find a subdirectory?
     */
    if (p1) {
        *p1 = '\0';
 
#ifdef DEBUG_TORITO
        fprintf(stderr, _("Looking for subdir called %s\n"), p1);
#endif
 
        rest = p1 + 1;
 
#ifdef DEBUG_TORITO
        fprintf(stderr, _("Remainder of path name is now %s\n"), rest);
#endif
 
        dpnt = node->subdir;
        while (dpnt) {
#ifdef DEBUG_TORITO
            fprintf(stderr,
                "%4d %5d %s\n", dpnt->extent, dpnt->size,
                dpnt->de_name);
#endif
            if (strcmp(subdir, dpnt->de_name) == 0) {
#ifdef DEBUG_TORITO
                fprintf(stderr,
                _("Calling next level with filename = %s\n"), rest);
#endif
                return (search_tree_file(dpnt, rest));
            }
            dpnt = dpnt->next;
        }
 
        /*
         * If we got here means we couldn't find the subdir.
         */
        return (NULL);
    } else {
        /*
         * Look for a normal file now
         */
        depnt = node->contents;
        while (depnt) {
#ifdef DEBUG_TORITO
            fprintf(stderr, "%4d %5d %s\n", depnt->isorec.extent,
                depnt->size, depnt->name);
#endif
            if (strcmp(filename, depnt->name) == 0) {
#ifdef DEBUG_TORITO
                fprintf(stderr, _("Found our file %s"), filename);
#endif
                return (depnt);
            }
            depnt = depnt->next;
        }
        /*
         * If we got here means we couldn't find the subdir.
         */
        return (NULL);
    }
#ifdef  ERIC_FUN
    fprintf(stderr, _("We cant get here in search_tree_file :-/ \n"));
#endif
}

Referenced by fill_boot_desc(), get_torito_desc(), insert_boot_cat(), and search_tree_file().

set_de_path()

LOCAL void set_de_path	(	struct directory *	parent,
		struct directory *	this
	)

Definition at line 2480 of file tree.c.

{
    char    *p;
    size_t  len;
 
    if (parent == NULL) {           /* We are just creating root */
        this->de_path = this->whole_name;
        return;
    } else if (parent == root) {        /* full path == component    */
        this->de_path = this->de_name;
        return;
    }
    len = strlen(parent->de_path)+1+strlen(this->de_name)+1;
    p = e_malloc(len);
    js_snprintf(p, len, "%s/%s", parent->de_path, this->de_name);
    this->de_path = p;
}

Referenced by find_or_create_directory(), and insert_file_entry().

sort_n_finish()

LOCAL int sort_n_finish

(

struct directory *

this_dir

)

Definition at line 256 of file tree.c.

{
    struct directory_entry *s_entry;
    struct directory_entry *s_entry1;
    struct directory_entry *table;
    int     count;
    int     d1;
    int     d2;
    int     d3;
    register int    new_reclen;
    char        *c;
    int     status = 0;
    int     tablesize = 0;
    char        newname[MAX_ISONAME+1];
    char        rootname[MAX_ISONAME+1];
    char        extname[MAX_ISONAME+1];
 
    /*
     * Here we can take the opportunity to toss duplicate entries from the
     * directory.
     */
    /* ignore if it's hidden */
    if (this_dir->dir_flags & INHIBIT_ISO9660_ENTRY) {
        return (0);
    }
    table = NULL;
 
    init_fstatbuf();
 
    /*
     * If we had artificially created this directory, then we might be
     * missing the required '.' entries.  Create these now if we need
     * them.
     */
    if ((this_dir->dir_flags & (DIR_HAS_DOT | DIR_HAS_DOTDOT)) !=
        (DIR_HAS_DOT | DIR_HAS_DOTDOT)) {
        attach_dot_entries(this_dir, NULL, NULL);
    }
    flush_file_hash();
    s_entry = this_dir->contents;
    while (s_entry) {
#ifdef  USE_LARGEFILES
        /*
         * Skip all but the last extent from a multi extent file,
         * we like them all have the same name.
         */
        if ((s_entry->de_flags & MULTI_EXTENT) &&
            (s_entry->isorec.flags[0] & ISO_MULTIEXTENT)) {
            s_entry = s_entry->next;
            continue;
        }
#endif
        /* ignore if it's hidden */
        if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY) {
            s_entry = s_entry->next;
            continue;
        }
        /*
         * First assume no conflict, and handle this case
         */
        if (!(s_entry1 = find_file_hash(s_entry->isorec.name))) {
            add_file_hash(s_entry);
            s_entry = s_entry->next;
            continue;
        }
#ifdef APPLE_HYB
        /*
         * if the pair are associated, then skip (as they have the
         * same name!)
         */
        if (apple_both && s_entry1->assoc &&
                        s_entry1->assoc == s_entry) {
            s_entry = s_entry->next;
            continue;
        }
#endif  /* APPLE_HYB */
 
        if (s_entry1 == s_entry) {
            comerrno(EX_BAD,
            _("Fatal goof, file '%s' already in hash table.\n"),
            s_entry->isorec.name);
        }
        /*
         * OK, handle the conflicts.  Try substitute names until we
         * come up with a winner
         */
        strlcpy(rootname, s_entry->isorec.name, sizeof (rootname));
        /*
         * Strip off the non-significant part of the name so that we
         * are left with a sensible root filename.  If we don't find
         * a '.', then try a ';'.
         */
        c = strchr(rootname, '.');
        /*
         * In case we ever allow more than on dot, only modify the
         * section past the last dot if the file name starts with a
         * dot.
         */
        if (c != NULL && c == rootname && c != strrchr(rootname, '.')) {
            c = strrchr(rootname, '.');
        }
        extname[0] = '\0';      /* In case we have no ext.  */
        if (c) {
            strlcpy(extname, c, sizeof (extname));
            *c = 0;         /* Cut off complete ext.    */
        } else {
            /*
             * Could not find any '.'.
             */
            c = strchr(rootname, ';');
            if (c) {
                *c = 0;     /* Cut off version number    */
            }
        }
        c = strchr(extname, ';');
        if (c) {
            *c = 0;         /* Cut off version number    */
        }
        d1 = strlen(rootname);
        if (full_iso9660_filenames || iso9660_level > 1) {
            d2 = strlen(extname);
            /*
             * 31/37 chars minus the 3 characters we are
             * appending below to create unique filenames.
             */
            if ((d1 + d2) > (iso9660_namelen - 3))
                rootname[iso9660_namelen - 3 - d2] = 0;
        } else {
            if (d1 > 5)
                rootname[5] = 0;
        }
        new_reclen = strlen(rootname);
        sprintf(newname, "%s000%s%s",
                rootname,
                extname,
                ((s_entry->isorec.flags[0] & ISO_DIRECTORY) ||
                omit_version_number ? "" : ";1"));
 
        for (d1 = 0; d1 < 36; d1++) {
            for (d2 = 0; d2 < 36; d2++) {
                for (d3 = 0; d3 < 36; d3++) {
                    newname[new_reclen + 0] =
                        (d1 <= 9 ? '0' + d1 : 'A' + d1 - 10);
                    newname[new_reclen + 1] =
                        (d2 <= 9 ? '0' + d2 : 'A' + d2 - 10);
                    newname[new_reclen + 2] =
                        (d3 <= 9 ? '0' + d3 : 'A' + d3 - 10);
                    if (debug)
                        error(_("NEW name '%s'\n"), newname);
 
#ifdef VMS
                    /* Sigh.  VAXCRTL seems to be broken here */
                    {
                        int ijk = 0;
 
                        while (newname[ijk]) {
                            if (newname[ijk] == ' ')
                                newname[ijk] = '0';
                            ijk++;
                        }
                    }
#endif
 
                    if (!find_file_hash(newname))
                        goto got_valid_name;
                }
            }
        }
 
        /*
         * If we fell off the bottom here, we were in real trouble.
         */
        comerrno(EX_BAD,
            _("Unable to generate unique name for file %s\n"),
            s_entry->name);
 
got_valid_name:
        /*
         * OK, now we have a good replacement name.  Now decide which
         * one of these two beasts should get the name changed
         */
        if (s_entry->priority < s_entry1->priority) {
            if (verbose > 0) {
                fprintf(stderr, _("Using %s for  %s%s%s (%s)\n"),
                    newname,
                    this_dir->whole_name, SPATH_SEPARATOR,
                    s_entry->name, s_entry1->name);
            }
 
            s_entry->isorec.name_len[0] = strlen(newname);
            new_reclen = offsetof(struct iso_directory_record,
                name[0]) +
                strlen(newname);
            if (use_XA || use_RockRidge) {
                if (new_reclen & 1)
                    new_reclen++; /* Pad to an even byte */
                new_reclen += s_entry->rr_attr_size;
            }
            if (new_reclen & 1)
                new_reclen++;   /* Pad to an even byte */
            s_entry->isorec.length[0] = new_reclen;
            strcpy(s_entry->isorec.name, newname);
#ifdef  USE_LARGEFILES
            if (s_entry->de_flags & MULTI_EXTENT) {
                struct directory_entry  *s_e;
 
                /*
                 * Copy over the new name to all other entries
                 */
                for (s_e = s_entry->mxroot;
                    s_e && s_e->mxroot == s_entry->mxroot;
                            s_e = s_e->next) {
                    s_e->isorec.length[0] = new_reclen;
                    s_e->isorec.name_len[0] = s_entry->isorec.name_len[0];
                    strcpy(s_e->isorec.name, newname);
                }
            }
#endif
#ifdef APPLE_HYB
            /*
             * Has resource fork - needs new name
             */
            if (apple_both && s_entry->assoc) {
                struct directory_entry *s_entry2 =
                                s_entry->assoc;
 
                /*
                 * resource fork name *should* be the same as
                 * the data fork
                 */
                s_entry2->isorec.name_len[0] =
                        s_entry->isorec.name_len[0];
                strcpy(s_entry2->isorec.name,
                        s_entry->isorec.name);
                s_entry2->isorec.length[0] = new_reclen;
            }
#endif  /* APPLE_HYB */
        } else {
            delete_file_hash(s_entry1);
            if (verbose > 0) {
                fprintf(stderr, _("Using %s for  %s%s%s (%s)\n"),
                    newname,
                    this_dir->whole_name, SPATH_SEPARATOR,
                    s_entry1->name, s_entry->name);
            }
            s_entry1->isorec.name_len[0] = strlen(newname);
            new_reclen = offsetof(struct iso_directory_record,
                    name[0]) +
                    strlen(newname);
            if (use_XA || use_RockRidge) {
                if (new_reclen & 1)
                    new_reclen++; /* Pad to an even byte */
                new_reclen += s_entry1->rr_attr_size;
            }
            if (new_reclen & 1)
                new_reclen++;   /* Pad to an even byte */
            s_entry1->isorec.length[0] = new_reclen;
            strcpy(s_entry1->isorec.name, newname);
#ifdef  USE_LARGEFILES
            if (s_entry1->de_flags & MULTI_EXTENT) {
                struct directory_entry  *s_e;
 
                /*
                 * Copy over the new name to all other entries
                 */
                for (s_e = s_entry1->mxroot;
                    s_e && s_e->mxroot == s_entry1->mxroot;
                            s_e = s_e->next) {
                    s_e->isorec.length[0] = new_reclen;
                    s_e->isorec.name_len[0] = s_entry1->isorec.name_len[0];
                    strcpy(s_e->isorec.name, newname);
                }
            }
#endif
            add_file_hash(s_entry1);
#ifdef APPLE_HYB
            /*
             * Has resource fork - needs new name
             */
            if (apple_both && s_entry1->assoc) {
                struct directory_entry *s_entry2 =
                            s_entry1->assoc;
 
                /*
                 * resource fork name *should* be the same as
                 * the data fork
                 */
                s_entry2->isorec.name_len[0] =
                        s_entry1->isorec.name_len[0];
                strcpy(s_entry2->isorec.name,
                            s_entry1->isorec.name);
                s_entry2->isorec.length[0] = new_reclen;
            }
#endif  /* APPLE_HYB */
        }
        add_file_hash(s_entry);
        s_entry = s_entry->next;
    }
 
    if (generate_tables &&
        !find_file_hash(trans_tbl) &&
        (reloc_dir != this_dir) &&
        (this_dir->extent == 0)) {
        /*
         * First we need to figure out how big this table is
         */
        for (s_entry = this_dir->contents; s_entry;
                        s_entry = s_entry->next) {
            if (strcmp(s_entry->name, ".") == 0 ||
                strcmp(s_entry->name, "..") == 0)
                continue;
#ifdef APPLE_HYB
            /*
             * Skip table entry for the resource fork
             */
            if (apple_both &&
                (s_entry->isorec.flags[0] & ISO_ASSOCIATED))
                continue;
#endif  /* APPLE_HYB */
            if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY)
                continue;
            if (s_entry->table) {
                /*
                 * Max namelen, a space before and a space
                 * after the iso filename.
                 */
                tablesize += MAX_ISONAME + 2 +
                        strlen(s_entry->table);
            }
        }
    }
    if (tablesize > 0) {
        table = (struct directory_entry *)
            e_malloc(sizeof (struct directory_entry));
        memset(table, 0, sizeof (struct directory_entry));
        table->table = NULL;
        table->next = this_dir->contents;
        this_dir->contents = table;
 
        table->filedir = root;
        table->isorec.flags[0] = ISO_FILE;
        table->priority = 32768;
        iso9660_date(table->isorec.date, fstatbuf.st_mtime);
        table->inode = TABLE_INODE;
        table->dev = UNCACHED_DEVICE;
        set_723(table->isorec.volume_sequence_number,
                        volume_sequence_number);
        set_733((char *)table->isorec.size, tablesize);
        table->size = tablesize;
        table->filedir = this_dir;
        if (jhide_trans_tbl)
            table->de_flags |= INHIBIT_JOLIET_ENTRY;
        /*
         * Always hide transtable from UDF tree.
         */
        table->de_flags |= INHIBIT_UDF_ENTRY;
/*      table->name = e_strdup("<translation table>");*/
        table->name = e_strdup(trans_tbl);
        /*
         * We use sprintf() to create the strings, for this reason
         * we need to add one byte for the null character at the
         * end of the string even though we don't use it.
         */
        table->table = (char *)e_malloc(ISO_ROUND_UP(tablesize)+1);
        memset(table->table, 0, ISO_ROUND_UP(tablesize)+1);
        iso9660_file_length(trans_tbl, table, 0);
 
        if (use_XA || use_RockRidge) {
            fstatbuf.st_mode = 0444 | S_IFREG;
            fstatbuf.st_nlink = 1;
            generate_xa_rr_attributes("",
                trans_tbl, table,
                &fstatbuf, &fstatbuf, 0);
        }
    }
    /*
     * We have now chosen the 8.3 names and we should now know the length
     * of every entry in the directory.
     */
    for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next) {
        /* skip if it's hidden */
        if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY) {
            continue;
        }
        new_reclen = strlen(s_entry->isorec.name);
 
        /*
         * First update the path table sizes for directories.
         */
        if (s_entry->isorec.flags[0] & ISO_DIRECTORY) {
            if (strcmp(s_entry->name, ".") != 0 &&
                    strcmp(s_entry->name, "..") != 0) {
                path_table_size += new_reclen +
                        offsetof(struct iso_path_table,
                        name[0]);
                if (new_reclen & 1)
                    path_table_size++;
            } else {
                new_reclen = 1;
                if (this_dir == root && strlen(s_entry->name)
                                    == 1) {
                    path_table_size += new_reclen +
                        offsetof(struct iso_path_table,
                        name[0]);
                }
            }
        }
        if (path_table_size & 1)
            path_table_size++;  /* For odd lengths we pad */
        s_entry->isorec.name_len[0] = new_reclen;
 
        new_reclen += offsetof(struct iso_directory_record, name[0]);
 
        if (new_reclen & 1)
            new_reclen++;
 
        new_reclen += s_entry->rr_attr_size;
 
        if (new_reclen & 1)
            new_reclen++;
 
        if (new_reclen > 0xff) {
            comerrno(EX_BAD,
                _("Fatal error - RR overflow (reclen %d) for file %s\n"),
                new_reclen,
                s_entry->name);
        }
        s_entry->isorec.length[0] = new_reclen;
    }
 
    status = sort_directory(&this_dir->contents, (reloc_dir == this_dir));
    if (status > 0) {
        errmsgno(EX_BAD, _("Unable to sort directory %s\n"),
            this_dir->whole_name);
        errmsgno(EX_BAD,
        _("If there was more than one directory type argument to mkisofs\n"));
        comerrno(EX_BAD,
        _("use -graft-points to create different target directory names.\n"));
    }
    /*
     * If we are filling out a TRANS.TBL, generate the entries that will
     * go in the thing.
     */
    if (table) {
        count = 0;
        for (s_entry = this_dir->contents; s_entry;
                        s_entry = s_entry->next) {
            if (s_entry == table)
                continue;
            if (!s_entry->table)
                continue;
            if (strcmp(s_entry->name, ".") == 0 ||
                strcmp(s_entry->name, "..") == 0)
                continue;
#ifdef APPLE_HYB
            /*
             * Skip table entry for the resource fork
             */
            if (apple_both &&
                (s_entry->isorec.flags[0] & ISO_ASSOCIATED))
                continue;
#endif  /* APPLE_HYB */
            if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY)
                continue;
            /*
             * Warning: we cannot use the return value of sprintf
             * because old BSD based sprintf() implementations
             * will return a pointer to the result instead of a
             * count.
             * Old mkiofs introduced a space after the iso
             * filename to make parsing TRANS.TBL easier.
             */
            sprintf(table->table + count, "%c %-*s%s",
                s_entry->table[0],
                MAX_ISONAME + 1,
                s_entry->isorec.name, s_entry->table + 1);
            count += strlen(table->table + count);
            free(s_entry->table);
            /*
             * for a memory file, set s_entry->table to the
             * correct data - which is stored in
             * s_entry->whole_name
             */
            if (s_entry->de_flags & MEMORY_FILE) {
                s_entry->table = s_entry->whole_name;
                s_entry->whole_name = NULL;
            } else {
                s_entry->table = NULL;
            }
        }
 
        if (count != tablesize) {
            comerrno(EX_BAD,
                _("Translation table size mismatch %d %d\n"),
                count, tablesize);
        }
    }
    /*
     * 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->contents;
    this_dir->ce_bytes = 0;
    while (s_entry) {
        /* skip if it's hidden */
        if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY) {
            s_entry = s_entry->next;
            continue;
        }
        new_reclen = s_entry->isorec.length[0];
        if ((this_dir->size & (SECTOR_SIZE - 1)) + new_reclen
                                >= SECTOR_SIZE)
 
            this_dir->size = (this_dir->size + (SECTOR_SIZE - 1)) &
                ~(SECTOR_SIZE - 1);
        this_dir->size += new_reclen;
 
        /*
         * See if continuation entries were used on disc
         */
        if (use_RockRidge &&
            s_entry->rr_attr_size != s_entry->total_rr_attr_size) {
            unsigned char   *pnt;
            int     len;
            int     nbytes;
 
            pnt = s_entry->rr_attributes;
            len = s_entry->total_rr_attr_size;
            pnt = parse_xa(pnt, &len, 0);
/*          pnt = parse_xa(pnt, &len, s_entry);*/
 
            /*
             * We make sure that each continuation entry record is
             * not split across sectors, but each file could in
             * theory have more than one CE, so we scan through
             * and figure out what we need.
             */
            while (len > 3) {
                if (pnt[0] == 'C' && pnt[1] == 'E') {
                    nbytes = get_733((char *)pnt + 20);
 
                    if ((this_dir->ce_bytes & (SECTOR_SIZE - 1)) + nbytes >=
                        SECTOR_SIZE)
                        this_dir->ce_bytes =
                            ISO_ROUND_UP(this_dir->ce_bytes);
                    /*
                     * Now store the block in the
                     * ce buffer
                     */
                    this_dir->ce_bytes += nbytes;
                    if (this_dir->ce_bytes & 1)
                        this_dir->ce_bytes++;
                }
                len -= pnt[2];
                pnt += pnt[2];
            }
        }
        s_entry = s_entry->next;
    }
    return (status);
}

Referenced by merge_old_directory_into_tree(), and sort_tree().

sort_tree()

EXPORT int sort_tree

(

struct directory *

node

)

Definition at line 2842 of file tree.c.

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

Referenced by main(), and sort_tree().

stat_filter()

EXPORT int stat_filter	(	char *	path,
		struct stat *	st
	)

Definition at line 232 of file tree.c.

{
    int result = stat(path, st);
 
    if (result >= 0 && rationalize)
        stat_fix(st);
    return (result);
}

Referenced by find_or_create_directory(), get_graft(), insert_file_entry(), main(), merge_previous_session(), scan_sparc_boot(), and scan_sunx86_boot().

stat_fix()

LOCAL void stat_fix

(

struct stat *

st

)

Definition at line 183 of file tree.c.

{
    int adjust_modes = 0;
 
    if (S_ISREG(st->st_mode))
        adjust_modes = rationalize_filemode;
    else if (S_ISDIR(st->st_mode))
        adjust_modes = rationalize_dirmode;
    else
        adjust_modes = (rationalize_filemode || rationalize_dirmode);
 
    /*
     * If rationalizing, override the uid and gid, since the
     * originals will only be useful on the author's system.
     */
    if (rationalize_uid)
        st->st_uid = uid_to_use;
    if (rationalize_gid)
        st->st_gid = gid_to_use;
 
    if (adjust_modes) {
 
        if (S_ISREG(st->st_mode) && (filemode_to_use != 0)) {
            st->st_mode = filemode_to_use | S_IFREG;
        } else if (S_ISDIR(st->st_mode) && (dirmode_to_use != 0)) {
            st->st_mode = dirmode_to_use | S_IFDIR;
        } else {
            /*
             * Make sure the file modes make sense.  Turn
             * on all read bits.  Turn on all exec/search
             * bits if any exec/search bit is set.  Turn
             * off all write bits, and all special mode
             * bits (on a r/o fs lock bits are useless,
             * and with uid+gid 0 don't want set-id bits,
             * either).
             */
 
            st->st_mode |= 0444;
#if !defined(_WIN32) && !defined(__DJGPP__) /* make all file "executable" */
            if (st->st_mode & 0111)
#endif
                st->st_mode |= 0111;
            st->st_mode &= ~07222;
        }
    }
}

Referenced by lstat_filter(), and stat_filter().

Variable Documentation

fstatbuf

struct stat fstatbuf

Definition at line 108 of file tree.c.

Referenced by attach_dot_entries(), dup_relocated_dir(), find_or_create_directory(), generate_reloc_directory(), init_fstatbuf(), insert_boot_cat(), and sort_n_finish().

reloc_dir

struct directory* reloc_dir

Definition at line 111 of file tree.c.

Referenced by assign_joliet_directory_addresses(), attach_dot_entries(), dirtree_fixup(), do_dir_nlink(), dup_relocated_dir(), find_or_create_directory(), finish_cl_pl_entries(), finish_cl_pl_for_prev_session(), generate_joliet_directories(), generate_joliet_path_tables(), generate_one_joliet_directory(), generate_reloc_directory(), hide_reloc_dir(), insert_file_entry(), joliet_compare_paths(), joliet_sort_n_finish(), main(), match_cl_re_entries(), and sort_n_finish().

root_statbuf

struct stat root_statbuf

Definition at line 110 of file tree.c.

Referenced by generate_reloc_directory(), insert_file_entry(), jroot_gen(), and root_gen().

sccsid

UConst char sccsid[]

static

Initial value:

=
    "@(#)tree.c 1.137 16/12/13 joerg"

Definition at line 4 of file tree.c.

symlink_buff

LOCAL Uchar symlink_buff[PATH_MAX+1]

Definition at line 55 of file tree.c.

Referenced by insert_file_entry().

verbose

int verbose

extern

Definition at line 60 of file main.c.

Referenced by insert_file_entry(), main(), read_rcfile(), scan_directory_tree(), and sort_n_finish().