#include <schily/mconfig.h>
#include "mkisofs.h"
#include "rock.h"
#include <schily/device.h>
#include <schily/schily.h>

Include dependency graph for rock.c:

Macros
#define	SU_VERSION 1

#define	SL_ROOT 8

#define	SL_PARENT 4

#define	SL_CURRENT 2

#define	SL_CONTINUE 1

#define	CE_SIZE 28 /* SUSP Continuation aerea */

#define	CL_SIZE 12 /* RR Child Link for deep dir relocation */

#define	ER_SIZE 8 /* RR Extension record for RR signature */

#define	NM_SIZE 5 /* RR Real name */

#define	PL_SIZE 12 /* RR Paren Link for deep dir relocation */

#define	PN_SIZE 20 /* RR POSIX device modes (Major/Minor) */

#define	PX_OLD_SIZE 36 /* RR POSIX Extensions (mode/nlink/uid/gid) */

#define	PX_SIZE 44 /* RR POSIX Extensions (mode/nlink/uid/gid/ino) */

#define	RE_SIZE 4 /* RR Relocated directory */

#define	RR_SIZE 5 /* RR RR Signature in every file */

#define	SL_SIZE 20 /* RR Symlink */

#define	ZF_SIZE 16 /* RR* Linux compression extension */

#define	TF_SIZE (5 + 3 * 7)

#define	TF_SIZE_LONG (5 + 3 * 17)

#define	RR_CUR_USE (CE_SIZE + currlen + (ipnt - recstart))

#define	MAYBE_ADD_CE_ENTRY(BYTES) (((int)(BYTES)) + CE_SIZE + currlen + (ipnt - recstart) > reclimit ? 1 : 0)

Functions
LOCAL void rstrncpy	__PR ((char t, char f, size_t tlen, siconvt_t inls, siconvt_t onls))

LOCAL void add_CE_entry	__PR ((char *field, int line))

LOCAL int gen_xa_attr	__PR ((mode_t attr))

LOCAL void gen_xa	__PR ((struct stat *lstatbuf))

EXPORT int generate_xa_rr_attributes	__PR ((char whole_name, char name, struct directory_entry s_entry, struct stat statbuf, struct stat *lstatbuf, int deep_opt))

char *generate_rr_extension_record	__PR ((char id, char descriptor, char source, int size))

LOCAL void	rstrncpy (char t, char f, size_t tlen, siconvt_t inls, siconvt_t onls)

LOCAL void	add_CE_entry (char *field, int line)

LOCAL int	gen_xa_attr (mode_t attr)

LOCAL void	gen_xa (struct stat *lstatbuf)

EXPORT int	generate_xa_rr_attributes (char whole_name, char name, struct directory_entry s_entry, struct stat statbuf, struct stat *lstatbuf, int deep_opt)

EXPORT char *	generate_rr_extension_record (char id, char descriptor, char source, int size)

Variables
static UConst char	sccsid []

LOCAL Uchar	Rock [16384]

LOCAL Uchar	symlink_buff [PATH_MAX+1]

LOCAL int	ipnt = 0

LOCAL int	recstart = 0

LOCAL int	currlen = 0

LOCAL int	mainrec = 0

LOCAL int	reclimit

Macro Definition Documentation

◆ CE_SIZE

#define CE_SIZE 28 /* SUSP Continuation aerea */

Definition at line 42 of file rock.c.

◆ CL_SIZE

#define CL_SIZE 12 /* RR Child Link for deep dir relocation */

Definition at line 43 of file rock.c.

◆ ER_SIZE

#define ER_SIZE 8 /* RR Extension record for RR signature */

Definition at line 44 of file rock.c.

◆ MAYBE_ADD_CE_ENTRY

#define MAYBE_ADD_CE_ENTRY ( BYTES ) (((int)(BYTES)) + CE_SIZE + currlen + (ipnt - recstart) > reclimit ? 1 : 0)

Definition at line 88 of file rock.c.

◆ NM_SIZE

#define NM_SIZE 5 /* RR Real name */

Definition at line 45 of file rock.c.

◆ PL_SIZE

#define PL_SIZE 12 /* RR Paren Link for deep dir relocation */

Definition at line 46 of file rock.c.

◆ PN_SIZE

#define PN_SIZE 20 /* RR POSIX device modes (Major/Minor) */

Definition at line 47 of file rock.c.

◆ PX_OLD_SIZE

#define PX_OLD_SIZE 36 /* RR POSIX Extensions (mode/nlink/uid/gid) */

Definition at line 48 of file rock.c.

◆ PX_SIZE

#define PX_SIZE 44 /* RR POSIX Extensions (mode/nlink/uid/gid/ino) */

Definition at line 49 of file rock.c.

◆ RE_SIZE

#define RE_SIZE 4 /* RR Relocated directory */

Definition at line 50 of file rock.c.

◆ RR_CUR_USE

#define RR_CUR_USE (CE_SIZE + currlen + (ipnt - recstart))

Definition at line 86 of file rock.c.

◆ RR_SIZE

#define RR_SIZE 5 /* RR RR Signature in every file */

Definition at line 51 of file rock.c.

◆ SL_CONTINUE

#define SL_CONTINUE 1

Definition at line 40 of file rock.c.

◆ SL_CURRENT

#define SL_CURRENT 2

Definition at line 39 of file rock.c.

◆ SL_PARENT

#define SL_PARENT 4

Definition at line 38 of file rock.c.

◆ SL_ROOT

#define SL_ROOT 8

Definition at line 37 of file rock.c.

◆ SL_SIZE

#define SL_SIZE 20 /* RR Symlink */

Definition at line 52 of file rock.c.

◆ SU_VERSION

#define SU_VERSION 1

Definition at line 35 of file rock.c.

◆ TF_SIZE

#define TF_SIZE (5 + 3 * 7)

Definition at line 61 of file rock.c.

◆ TF_SIZE_LONG

#define TF_SIZE_LONG (5 + 3 * 17)

Definition at line 62 of file rock.c.

◆ ZF_SIZE

#define ZF_SIZE 16 /* RR* Linux compression extension */

Definition at line 53 of file rock.c.

Function Documentation

◆ __PR() [1/6]

LOCAL void add_CE_entry __PR ( (char *field, int line) )

◆ __PR() [2/6]

char *generate_rr_extension_record __PR ( (char *id, char *descriptor, char *source, int *size) )

◆ __PR() [3/6]

LOCAL void rstrncpy __PR ( (char *t, char *f, size_t tlen, siconvt_t *inls, siconvt_t *onls) )

◆ __PR() [4/6]

EXPORT int generate_xa_rr_attributes __PR ( (char *whole_name, char *name, struct directory_entry *s_entry, struct stat *statbuf, struct stat *lstatbuf, int deep_opt) )

◆ __PR() [5/6]

LOCAL int gen_xa_attr __PR ( (mode_t attr) )

◆ __PR() [6/6]

LOCAL void gen_xa __PR ( (struct stat *lstatbuf) )

◆ add_CE_entry()

LOCAL void add_CE_entry	(	char *	field,
		int	line
	)

Definition at line 127 of file rock.c.

{
    if (MAYBE_ADD_CE_ENTRY(0)) {
        errmsgno(EX_BAD,
        _("Panic: no space, cannot add RR CE entry (%d bytes mising) for %s line %d.\n"),
        (CE_SIZE + currlen + (ipnt - recstart) - reclimit),
        field, line);
        errmsgno(EX_BAD, _("currlen: %d ipnt: %d, recstart: %d\n"),
                currlen, ipnt, recstart);
        errmsgno(EX_BAD, _("Send  bug report to the maintainer.\n"));
        comerrno(EX_BAD, _("Aborting.\n"));
    }
 
    if (recstart)
        set_733((char *)Rock + recstart - 8, ipnt + 28 - recstart);
    Rock[ipnt++] = 'C';
    Rock[ipnt++] = 'E';
    Rock[ipnt++] = CE_SIZE;
    Rock[ipnt++] = SU_VERSION;
    set_733((char *)Rock + ipnt, 0);
    ipnt += 8;
    set_733((char *)Rock + ipnt, 0);
    ipnt += 8;
    set_733((char *)Rock + ipnt, 0);
    ipnt += 8;
    recstart = ipnt;
    currlen = 0;
    if (!mainrec)
        mainrec = ipnt;
    reclimit = SECTOR_SIZE - 8; /* Limit to one sector */
}

Referenced by generate_xa_rr_attributes().

◆ gen_xa()

LOCAL void gen_xa ( struct stat * lstatbuf )

Definition at line 196 of file rock.c.

{
        /*
         * Group ID
         */
        set_722((char *)Rock + ipnt, lstatbuf->st_gid);
        ipnt += 2;
        /*
         * User ID
         */
        set_722((char *)Rock + ipnt, lstatbuf->st_uid);
        ipnt += 2;
        /*
         * Attributes
         */
        set_722((char *)Rock + ipnt, gen_xa_attr(lstatbuf->st_mode));
        ipnt += 2;
 
        Rock[ipnt++] = 'X'; /* XA Signature */
        Rock[ipnt++] = 'A';
        Rock[ipnt++] = 0;   /* File number (we always use '0' */
 
        Rock[ipnt++] = 0;   /* Reserved (5 Byte) */
        Rock[ipnt++] = 0;
        Rock[ipnt++] = 0;
        Rock[ipnt++] = 0;
        Rock[ipnt++] = 0;
 
}

Referenced by generate_xa_rr_attributes().

◆ gen_xa_attr()

LOCAL int gen_xa_attr ( mode_t attr )

Definition at line 166 of file rock.c.

{
    int ret = 0;
 
    if (attr & S_IRUSR)
        ret |= XA_O_READ;
    if (attr & S_IXUSR)
        ret |= XA_O_EXEC;
 
    if (attr & S_IRGRP)
        ret |= XA_G_READ;
    if (attr & S_IXGRP)
        ret |= XA_G_EXEC;
 
    if (attr & S_IROTH)
        ret |= XA_W_READ;
    if (attr & S_IXOTH)
        ret |= XA_W_EXEC;
 
    ret |= XA_FORM1;
 
    if (S_ISDIR(attr))
        ret |= XA_DIR;
 
    return (ret);
}

Referenced by gen_xa().

◆ generate_rr_extension_record()

EXPORT char * generate_rr_extension_record	(	char *	id,
		char *	descriptor,
		char *	source,
		int *	size
	)

Definition at line 903 of file rock.c.

{
    int     lipnt = 0;
    char        *pnt;
    int     len_id;
    int     len_des;
    int     len_src;
 
    len_id = strlen(id);
    len_des = strlen(descriptor);
    len_src = strlen(source);
    Rock[lipnt++] = 'E';
    Rock[lipnt++] = 'R';
    Rock[lipnt++] = ER_SIZE + len_id + len_des + len_src;
    Rock[lipnt++] = 1;
    Rock[lipnt++] = len_id;
    Rock[lipnt++] = len_des;
    Rock[lipnt++] = len_src;
    Rock[lipnt++] = 1;
 
    memcpy(Rock + lipnt, id, len_id);
    lipnt += len_id;
 
    memcpy(Rock + lipnt, descriptor, len_des);
    lipnt += len_des;
 
    memcpy(Rock + lipnt, source, len_src);
    lipnt += len_src;
 
    if (lipnt > SECTOR_SIZE) {
        comerrno(EX_BAD, _("Extension record too long\n"));
    }
    pnt = (char *)e_malloc(SECTOR_SIZE);
    memset(pnt, 0, SECTOR_SIZE);
    memcpy(pnt, Rock, lipnt);
    *size = lipnt;
    return (pnt);
}

Referenced by main().

◆ generate_xa_rr_attributes()

EXPORT int generate_xa_rr_attributes	(	char *	whole_name,
		char *	name,
		struct directory_entry *	s_entry,
		struct stat *	statbuf,
		struct stat *	lstatbuf,
		int	deep_opt
	)

Definition at line 236 of file rock.c.

{
    int     flagpos;
    int     flagval;
    int     need_ce;
 
    statbuf = statbuf;  /* this shuts up unreferenced compiler */
                /* warnings */
    mainrec = recstart = ipnt = 0;
 
    if (use_XA) {
        gen_xa(lstatbuf);
    }
 
/*  reclimit = 0xf8; XXX we now use 254 == 0xfe */
    reclimit = MAX_ISODIR;
 
    /* no need to fill in the RR stuff if we won't see the file */
    if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY)
        return (0);
 
    /*
     * Obtain the amount of space that is currently used for the directory
     * record.  We may safely use the current name length; because if name
     * confilcts force us to change the ISO-9660 name later, the name will
     * never become longer than now.
     */
    if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) {
        s_entry->isorec.name_len[0] = 1;
    } else {
        s_entry->isorec.name_len[0] = strlen(s_entry->isorec.name);
    }
    currlen = s_entry->isorec.length[0] = s_entry->isorec.name_len[0] +
                offsetof(struct iso_directory_record, name[0]);
    if (currlen & 1)
        s_entry->isorec.length[0] = ++currlen;
 
    if (currlen < 33+37) {
        /*
         * If the ISO-9660 name length is less than 37, we may use
         * ISO-9660:1988 name rules and for this reason, the name len
         * may later increase from adding e.g. ".;1"; in this case
         * just use the upper limit.
         */
        currlen = 33+37;
    }
 
#ifdef APPLE_HYB
    /* if we have regular file, then add Apple extensions */
    if (S_ISREG(lstatbuf->st_mode) && apple_ext && s_entry->hfs_ent) {
        if (MAYBE_ADD_CE_ENTRY(AA_SIZE))
            add_CE_entry("AA", __LINE__);
        Rock[ipnt++] = 'A'; /* AppleSignature */
        Rock[ipnt++] = 'A';
        Rock[ipnt++] = AA_SIZE; /* includes AppleSignature bytes */
        Rock[ipnt++] = 0x02;    /* SystemUseID */
        Rock[ipnt++] = s_entry->hfs_ent->u.file.type[0];
        Rock[ipnt++] = s_entry->hfs_ent->u.file.type[1];
        Rock[ipnt++] = s_entry->hfs_ent->u.file.type[2];
        Rock[ipnt++] = s_entry->hfs_ent->u.file.type[3];
        Rock[ipnt++] = s_entry->hfs_ent->u.file.creator[0];
        Rock[ipnt++] = s_entry->hfs_ent->u.file.creator[1];
        Rock[ipnt++] = s_entry->hfs_ent->u.file.creator[2];
        Rock[ipnt++] = s_entry->hfs_ent->u.file.creator[3];
        Rock[ipnt++] = (s_entry->hfs_ent->fdflags >> 8) & 0xff;
        Rock[ipnt++] = s_entry->hfs_ent->fdflags & 0xff;
    }
#endif  /* APPLE_HYB */
 
    if (!use_RockRidge)
        goto xa_only;
 
    /* Identify that we are using the SUSP protocol */
    if (deep_opt & NEED_SP) {
        /*
         * We may not use a CE record here but we never will need to
         * do so, as this SP record is only used for the "." entry
         * of the root directory.
         */
        Rock[ipnt++] = 'S';
        Rock[ipnt++] = 'P';
        Rock[ipnt++] = 7;
        Rock[ipnt++] = SU_VERSION;
        Rock[ipnt++] = 0xbe;
        Rock[ipnt++] = 0xef;
        if (use_XA)
            Rock[ipnt++] = sizeof (struct iso_xa_dir_record);
        else
            Rock[ipnt++] = 0;
    }
 
    /* First build the posix name field */
    if (MAYBE_ADD_CE_ENTRY(RR_SIZE))
        add_CE_entry("RR", __LINE__);
    Rock[ipnt++] = 'R';
    Rock[ipnt++] = 'R';
    Rock[ipnt++] = 5;
    Rock[ipnt++] = SU_VERSION;
    flagpos = ipnt;
    flagval = 0;
    Rock[ipnt++] = 0;   /* We go back and fix this later */
 
    if (strcmp(name, ".") != 0 && strcmp(name, "..") != 0) {
        char        *npnt;
        int     remain; /* Remaining name length  */
        int     use;    /* Current name part used */
 
#ifdef APPLE_HYB
        /* use the HFS name if it exists */
        if (USE_MAC_NAME(s_entry)) {
            remain = strlen(s_entry->hfs_ent->name);
            npnt = s_entry->hfs_ent->name;
        } else {
#endif  /* APPLE_HYB */
 
            remain = strlen(name);
            npnt = name;
#ifdef APPLE_HYB
        }
#endif  /* APPLE_HYB */
 
        if (MAYBE_ADD_CE_ENTRY(NM_SIZE+1))
            add_CE_entry("NM", __LINE__);
        while (remain) {
            use = remain;
            need_ce = 0;
            /* Can we fit this SUSP and a CE entry? */
            if (MAYBE_ADD_CE_ENTRY(NM_SIZE+use)) {
                use = reclimit - NM_SIZE - RR_CUR_USE;
                need_ce++;
            }
            /* Only room for 256 per SUSP field */
            if (use > 0xf8) {
                use = 0xf8;
                need_ce++;
            }
            if (use < 0) {
                comerrno(EX_BAD,
                _("Negative RR name length residual: %d\n"),
                    use);
            }
 
            /* First build the posix name field */
            Rock[ipnt++] = 'N';
            Rock[ipnt++] = 'M';
            Rock[ipnt++] = NM_SIZE + use;
            Rock[ipnt++] = SU_VERSION;
            Rock[ipnt++] = (remain != use ? 1 : 0);
            flagval |= (1 << 3);
 
            /*
             * Convert charsets as required
             * XXX If we are using iconv() based locales and in/out
             * XXX locale differ, then strlen(&Rock[ipnt]) may
             * XXX increase. We would need to compute the length
             * XXX early enough.
             */
#ifdef APPLE_HYB
            if (USE_MAC_NAME(s_entry))
                rstrncpy((char *)&Rock[ipnt], npnt, use,
                            hfs_inls, out_nls);
            else
#endif  /* APPLE_HYB */
                rstrncpy((char *)&Rock[ipnt], npnt, use,
                            in_nls, out_nls);
            npnt += use;
            ipnt += use;
            remain -= use;
            if (remain && need_ce)
                add_CE_entry("NM", __LINE__);
        }
    }
 
    /* Add the posix modes */
    if (MAYBE_ADD_CE_ENTRY(PX_SIZE))
        add_CE_entry("PX", __LINE__);
    Rock[ipnt++] = 'P';
    Rock[ipnt++] = 'X';
    if (rrip112) {
        Rock[ipnt++] = PX_SIZE;
    } else {
        Rock[ipnt++] = PX_OLD_SIZE;
    }
    Rock[ipnt++] = SU_VERSION;
    flagval |= (1 << 0);
    set_733((char *)Rock + ipnt, lstatbuf->st_mode);
    ipnt += 8;
    set_733((char *)Rock + ipnt, lstatbuf->st_nlink);
    ipnt += 8;
    set_733((char *)Rock + ipnt, lstatbuf->st_uid);
    ipnt += 8;
    set_733((char *)Rock + ipnt, lstatbuf->st_gid);
    ipnt += 8;
    if (rrip112) {
        /*
         * We will set up correct inode numbers later
         * after we did assign them.
         */
        set_733((char *)Rock + ipnt, 0);
        ipnt += 8;
    }
 
    /* Check for special devices */
#if defined(S_IFCHR) || defined(S_IFBLK)
    /*
     * The code in this if statement used to be #ifdef'd with NON_UNIXFS.
     * But as schily/stat.h always provides the macros S_ISCHR() & S_ISBLK()
     * and schily/device.h always provides major()/minor() it is not needed
     * anymore.
     */
    if (S_ISCHR(lstatbuf->st_mode) || S_ISBLK(lstatbuf->st_mode)) {
        if (MAYBE_ADD_CE_ENTRY(PN_SIZE))
            add_CE_entry("PN", __LINE__);
        Rock[ipnt++] = 'P';
        Rock[ipnt++] = 'N';
        Rock[ipnt++] = PN_SIZE;
        Rock[ipnt++] = SU_VERSION;
        flagval |= (1 << 1);
#if 1
        /* This is the new and only code which uses <schily/device.h> */
        set_733((char *)Rock + ipnt, major(lstatbuf->st_rdev));
        ipnt += 8;
        set_733((char *)Rock + ipnt, minor(lstatbuf->st_rdev));
        ipnt += 8;
#else
        /*
         * If we don't have sysmacros.h, then we have to guess as to
         * how best to pick apart the device number for major/minor.
         * Note: this may very well be wrong for many systems, so it
         * is always best to use the major/minor macros if the system
         * supports it.
         */
        if (sizeof (dev_t) <= 2) {
            set_733((char *)Rock + ipnt, (lstatbuf->st_rdev >> 8));
            ipnt += 8;
            set_733((char *)Rock + ipnt, lstatbuf->st_rdev & 0xff);
            ipnt += 8;
        } else if (sizeof (dev_t) <= 4) {
            set_733((char *)Rock + ipnt,
                        (lstatbuf->st_rdev >> 8) >> 8);
            ipnt += 8;
            set_733((char *)Rock + ipnt,
                        lstatbuf->st_rdev & 0xffff);
            ipnt += 8;
        } else {
            set_733((char *)Rock + ipnt,
                        (lstatbuf->st_rdev >> 16)>>16);
            ipnt += 8;
            set_733((char *)Rock + ipnt, lstatbuf->st_rdev);
            ipnt += 8;
        }
#endif
    }
#endif  /* defined(S_IFCHR) || defined(S_IFBLK) */
 
    /* Check for and symbolic links.  VMS does not have these. */
#ifdef S_IFLNK
    if (S_ISLNK(lstatbuf->st_mode)) {
        int     lenpos;
        int     lenval;
        int     j0;
        int     j1;
        int     nchar;
        Uchar       *cpnt;
        Uchar       *cpnt1;
        BOOL        last_sl = FALSE; /* Don't suppress last '/' */
 
#ifdef  HAVE_READLINK
        nchar = readlink(deep_opt&DID_CHDIR?name:whole_name,
                        (char *)symlink_buff,
                        sizeof (symlink_buff)-1);
        if (nchar < 0)
            errmsg(_("Cannot read link '%s'.\n"), whole_name);
#else
        nchar = -1;
#endif  /* HAVE_READLINK */
        symlink_buff[nchar < 0 ? 0 : nchar] = 0;
        nchar = strlen((char *)symlink_buff);
        set_733(s_entry->isorec.size, 0);
        cpnt = &symlink_buff[0];
        flagval |= (1 << 2);
 
        if (!split_SL_field) {
            int     sl_bytes = 0;
 
            for (cpnt1 = cpnt; *cpnt1 != '\0'; cpnt1++) {
                if (*cpnt1 == '/') {
                    sl_bytes += 4;
                } else {
                    sl_bytes += 1;
                }
            }
            if (sl_bytes > 250) {
                /*
                 * the symbolic link won't fit into one
                 * SL System Use Field print an error message
                 * and continue with splited one
                 */
                fprintf(stderr,
                _("symbolic link ``%s'' to long for one SL System Use Field, splitting"),
                                cpnt);
            }
            if (MAYBE_ADD_CE_ENTRY(SL_SIZE + sl_bytes))
                add_CE_entry("SL+", __LINE__);
        }
        while (nchar) {
            if (MAYBE_ADD_CE_ENTRY(SL_SIZE))
                add_CE_entry("SL", __LINE__);
            Rock[ipnt++] = 'S';
            Rock[ipnt++] = 'L';
            lenpos = ipnt;
            Rock[ipnt++] = SL_SIZE;
            Rock[ipnt++] = SU_VERSION;
            Rock[ipnt++] = 0;   /* Flags */
            lenval = 5;
            while (*cpnt || last_sl) {
                cpnt1 = (Uchar *)
                        strchr((char *)cpnt, '/');
                if (cpnt1) {
                    nchar--;
                    *cpnt1 = 0;
                }
 
                /*
                 * We treat certain components in a special
                 * way.
                 */
                if (cpnt[0] == '.' && cpnt[1] == '.' &&
                                cpnt[2] == 0) {
                    if (MAYBE_ADD_CE_ENTRY(2)) {
                        add_CE_entry("SL-parent", __LINE__);
                        if (cpnt1) {
                            *cpnt1 = '/';
                            nchar++;
                            /*
                             * A kluge so that we
                             * can restart properly
                             */
                            cpnt1 = NULL;
                        }
                        break;
                    }
                    Rock[ipnt++] = SL_PARENT;
                    Rock[ipnt++] = 0; /* length is zero */
                    lenval += 2;
                    nchar -= 2;
                } else if (cpnt[0] == '.' && cpnt[1] == 0) {
                    if (MAYBE_ADD_CE_ENTRY(2)) {
                        add_CE_entry("SL-current", __LINE__);
                        if (cpnt1) {
                            *cpnt1 = '/';
                            nchar++;
                            /*
                             * A kluge so that we
                             * can restart properly
                             */
                            cpnt1 = NULL;
                        }
                        break;
                    }
                    Rock[ipnt++] = SL_CURRENT;
                    Rock[ipnt++] = 0; /* length is zero */
                    lenval += 2;
                    nchar -= 1;
                } else if (cpnt[0] == 0) {
                    if (MAYBE_ADD_CE_ENTRY(2)) {
                        add_CE_entry("SL-root", __LINE__);
                        if (cpnt1) {
                            *cpnt1 = '/';
                            nchar++;
                            /*
                             * A kluge so that we
                             * can restart properly
                             */
                            cpnt1 = NULL;
                        }
                        break;
                    }
                    if (cpnt == &symlink_buff[0])
                        Rock[ipnt++] = SL_ROOT;
                    else
                        Rock[ipnt++] = 0;
                    Rock[ipnt++] = 0; /* length is zero */
                    lenval += 2;
                } else {
                    /*
                     * If we do not have enough room for a
                     * component, start a new continuations
                     * segment now
                     */
                    if (split_SL_component ?
                        MAYBE_ADD_CE_ENTRY(6) :
                        MAYBE_ADD_CE_ENTRY(6 + strlen((char *)cpnt))) {
                        add_CE_entry("SL++", __LINE__);
                        if (cpnt1) {
                            *cpnt1 = '/';
                            nchar++;
                            /*
                             * A kluge so that we
                             * can restart properly
                             */
                            cpnt1 = NULL;
                        }
                        break;
                    }
                    j0 = strlen((char *)cpnt);
                    while (j0) {
                        j1 = j0;
                        if (j1 > 0xf8)
                            j1 = 0xf8;
                        need_ce = 0;
                        if (j1 + currlen + 2 + CE_SIZE +
                            (ipnt - recstart) >
                                reclimit) {
 
                            j1 = reclimit -
                                (currlen + 2) -
                                CE_SIZE -
                                (ipnt - recstart);
                            need_ce++;
                        }
                        Rock[ipnt++] =
                            (j1 != j0 ?
                            SL_CONTINUE : 0);
                        Rock[ipnt++] = j1;
                        strncpy((char *)Rock + ipnt,
                            (char *)cpnt, j1);
                        ipnt += j1;
                        lenval += j1 + 2;
                        cpnt += j1;
                        /*
                         * Number we processed
                         * this time
                         */
                        nchar -= j1;
                        j0 -= j1;
                        if (need_ce) {
                            add_CE_entry(
                                "SL-path-split",
                                __LINE__);
                            if (cpnt1) {
                                *cpnt1 = '/';
                                nchar++;
                                /*
                                 * A kluge so
                                 * that we can
                                 * restart
                                 * properly
                                 */
                                cpnt1 = NULL;
                            }
                            break;
                        }
                    }
                }
                if (cpnt1) {
                    *cpnt1 = '/';
                    if (cpnt1 > symlink_buff && !last_sl &&
                        cpnt1[1] == '\0') {
                        last_sl = TRUE;
                    }
                    cpnt = cpnt1 + 1;
                } else
                    break;
            }
            Rock[lenpos] = lenval;
            if (nchar) {
                /* We need another SL entry */
                Rock[lenpos + 2] = SL_CONTINUE;
            }
        }   /* while nchar */
    }   /* Is a symbolic link */
#endif  /* S_IFLNK */
 
    /* Add in the Rock Ridge TF time field */
    if (MAYBE_ADD_CE_ENTRY(long_rr_time ? TF_SIZE_LONG:TF_SIZE))
        add_CE_entry("TF", __LINE__);
    Rock[ipnt++] = 'T';
    Rock[ipnt++] = 'F';
    Rock[ipnt++] = long_rr_time ? TF_SIZE_LONG:TF_SIZE;
    Rock[ipnt++] = SU_VERSION;
#if defined(__QNX__) && !defined(__QNXNTO__)    /* Not on Neutrino! never OK? */
    Rock[ipnt++] = long_rr_time ? 0x8f:0x0f;
#else
    Rock[ipnt++] = long_rr_time ? 0x8e:0x0e;
#endif
    flagval |= (1 << 7);
 
#if defined(__QNX__) && !defined(__QNXNTO__)    /* Not on Neutrino! never OK? */
    if (long_rr_time) {
        iso9660_date((char *)&Rock[ipnt], lstatbuf->st_ftime);
        ipnt += 7;
    } else {
        /*
         * XXX Do we have nanoseconds on QNX?
         */
        iso9660_ldate((char *)&Rock[ipnt], lstatbuf->st_ftime, 0, -100);
        ipnt += 17;
    }
#endif
    if (long_rr_time) {
        iso9660_ldate((char *)&Rock[ipnt],
                lstatbuf->st_mtime, stat_mnsecs(lstatbuf), -100);
        ipnt += 17;
        iso9660_ldate((char *)&Rock[ipnt],
                lstatbuf->st_atime, stat_ansecs(lstatbuf), -100);
        ipnt += 17;
        iso9660_ldate((char *)&Rock[ipnt],
                lstatbuf->st_ctime, stat_cnsecs(lstatbuf), -100);
        ipnt += 17;
    } else {
        iso9660_date((char *)&Rock[ipnt], lstatbuf->st_mtime);
        ipnt += 7;
        iso9660_date((char *)&Rock[ipnt], lstatbuf->st_atime);
        ipnt += 7;
        iso9660_date((char *)&Rock[ipnt], lstatbuf->st_ctime);
        ipnt += 7;
    }
 
    /* Add in the Rock Ridge RE (relocated dir) field */
    if (deep_opt & NEED_RE) {
        if (MAYBE_ADD_CE_ENTRY(RE_SIZE))
            add_CE_entry("RE", __LINE__);
        Rock[ipnt++] = 'R';
        Rock[ipnt++] = 'E';
        Rock[ipnt++] = RE_SIZE;
        Rock[ipnt++] = SU_VERSION;
        flagval |= (1 << 6);
    }
    /* Add in the Rock Ridge PL record, if required. */
    if (deep_opt & NEED_PL) {
        if (MAYBE_ADD_CE_ENTRY(PL_SIZE))
            add_CE_entry("PL", __LINE__);
        Rock[ipnt++] = 'P';
        Rock[ipnt++] = 'L';
        Rock[ipnt++] = PL_SIZE;
        Rock[ipnt++] = SU_VERSION;
        set_733((char *)Rock + ipnt, 0);
        ipnt += 8;
        flagval |= (1 << 5);
    }
 
    /* Add in the Rock Ridge CL field, if required. */
    if (deep_opt & NEED_CL) {
        if (MAYBE_ADD_CE_ENTRY(CL_SIZE))
            add_CE_entry("CL", __LINE__);
        Rock[ipnt++] = 'C';
        Rock[ipnt++] = 'L';
        Rock[ipnt++] = CL_SIZE;
        Rock[ipnt++] = SU_VERSION;
        set_733((char *)Rock + ipnt, 0);
        ipnt += 8;
        flagval |= (1 << 4);
    }
 
#ifndef VMS
    /*
     * If transparent compression was requested, fill in the correct field
     * for this file, if (and only if) it is actually a compressed file!
     * This relies only on magic number, but it should in general not
     * be an issue since if you're using -z odds are most of your
     * files are already compressed.
     *
     * In the future it would be nice if mkisofs actually did the
     * compression.
     */
    if (transparent_compression && S_ISREG(lstatbuf->st_mode)) {
        static const Uchar zisofs_magic[8] =
            { 0x37, 0xE4, 0x53, 0x96, 0xC9, 0xDB, 0xD6, 0x07 };
        FILE        *zffile;
        unsigned int    file_size;
        Uchar       header[16];
        int     OK_flag;
        int     blocksize;
        int     headersize;
 
        /*
         * First open file and verify that the correct algorithm was
         * used
         */
        file_size = 0;
        OK_flag = 1;
 
        memset(header, 0, sizeof (header));
 
        zffile = fopen(whole_name, "rb");
        if (zffile != NULL) {
            if (fread(header, 1, sizeof (header), zffile) != sizeof (header))
                OK_flag = 0;
 
            /* Check magic number */
            if (memcmp(header, zisofs_magic, sizeof (zisofs_magic)))
                OK_flag = 0;
 
            /* Get the real size of the file */
            file_size = get_731((char *)header+8);
 
            /* Get the header size (>> 2) */
            headersize = header[12];
 
            /* Get the block size (log2) */
            blocksize = header[13];
 
            fclose(zffile);
        } else {
            OK_flag = 0;
            blocksize = headersize = 0; /* Make silly GCC quiet */
        }
 
        if (OK_flag) {
            if (MAYBE_ADD_CE_ENTRY(ZF_SIZE))
                add_CE_entry("ZF", __LINE__);
            Rock[ipnt++] = 'Z';
            Rock[ipnt++] = 'F';
            Rock[ipnt++] = ZF_SIZE;
            Rock[ipnt++] = SU_VERSION;
            Rock[ipnt++] = 'p'; /* Algorithm: "paged zlib" */
            Rock[ipnt++] = 'z';
            /* 2 bytes for algorithm-specific information */
            Rock[ipnt++] = headersize;
            Rock[ipnt++] = blocksize;
            set_733((char *)Rock + ipnt, file_size); /* Real file size */
            ipnt += 8;
        }
    }
#endif
    /*
     * Add in the Rock Ridge CE field, if required.  We use  this for the
     * extension record that is stored in the root directory.
     */
    if (deep_opt & NEED_CE)
        add_CE_entry("ER", __LINE__);
 
    /*
     * Done filling in all of the fields.  Now copy it back to a buffer
     * for the file in question.
     */
    /* Now copy this back to the buffer for the file */
    Rock[flagpos] = flagval;
 
    /* If there was a CE, fill in the size field */
    if (recstart)
        set_733((char *)Rock + recstart - 8, ipnt - recstart);
 
xa_only:
    s_entry->rr_attributes = (Uchar *) e_malloc(ipnt);
    s_entry->total_rr_attr_size = ipnt;
    s_entry->rr_attr_size = (mainrec ? mainrec : ipnt);
    memcpy(s_entry->rr_attributes, Rock, ipnt);
    return (ipnt);
}

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

◆ rstrncpy()

LOCAL void rstrncpy	(	char *	t,
		char *	f,
		size_t	tlen,
		siconvt_t *	inls,
		siconvt_t *	onls
	)

Definition at line 104 of file rock.c.

{
    size_t  flen = strlen(f);
 
    while (tlen > 0 && *f) {
        size_t  ofl = flen;
        size_t  otl = tlen;
 
        conv_charset((Uchar *)t, &tlen, (Uchar *)f, &flen, inls, onls);
        if (*t == '/') {
            *t = '_';
        }
        t += otl - tlen;
        f += ofl - flen;
    }
}

Referenced by generate_xa_rr_attributes().

Variable Documentation

◆ currlen

LOCAL int currlen = 0

Definition at line 98 of file rock.c.

Referenced by add_CE_entry(), and generate_xa_rr_attributes().

◆ ipnt

LOCAL int ipnt = 0

Definition at line 96 of file rock.c.

Referenced by add_CE_entry(), gen_xa(), and generate_xa_rr_attributes().

◆ mainrec

LOCAL int mainrec = 0

Definition at line 99 of file rock.c.

Referenced by add_CE_entry(), and generate_xa_rr_attributes().

◆ reclimit

LOCAL int reclimit

Definition at line 100 of file rock.c.

Referenced by add_CE_entry(), and generate_xa_rr_attributes().

◆ recstart

LOCAL int recstart = 0

Definition at line 97 of file rock.c.

Referenced by add_CE_entry(), and generate_xa_rr_attributes().

◆ Rock

LOCAL Uchar Rock[16384]

Definition at line 94 of file rock.c.

Referenced by add_CE_entry(), gen_xa(), generate_rr_extension_record(), and generate_xa_rr_attributes().

◆ sccsid

UConst char sccsid[]

static

Initial value:

=

"@(#)rock.c 1.66 12/12/02 joerg"

Definition at line 4 of file rock.c.

◆ symlink_buff

LOCAL Uchar symlink_buff[PATH_MAX+1]

Definition at line 95 of file rock.c.

Referenced by generate_xa_rr_attributes().

Macros

Functions

Variables

Macro Definition Documentation

◆ CE_SIZE

◆ CL_SIZE

◆ ER_SIZE

◆ MAYBE_ADD_CE_ENTRY

◆ NM_SIZE

◆ PL_SIZE

◆ PN_SIZE

◆ PX_OLD_SIZE

◆ PX_SIZE

◆ RE_SIZE

◆ RR_CUR_USE

◆ RR_SIZE

◆ SL_CONTINUE

◆ SL_CURRENT

◆ SL_PARENT

◆ SL_ROOT

◆ SL_SIZE

◆ SU_VERSION

◆ TF_SIZE

◆ TF_SIZE_LONG

◆ ZF_SIZE

Function Documentation

◆ __PR() [1/6]

◆ __PR() [2/6]

◆ __PR() [3/6]

◆ __PR() [4/6]

◆ __PR() [5/6]

◆ __PR() [6/6]

◆ add_CE_entry()

◆ gen_xa()

◆ gen_xa_attr()

◆ generate_rr_extension_record()

◆ generate_xa_rr_attributes()

◆ rstrncpy()

Variable Documentation

◆ currlen

◆ ipnt

◆ mainrec

◆ reclimit

◆ recstart

◆ Rock

◆ sccsid

◆ symlink_buff