xueye/cdrtools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
7c6bd698f9
cdrtools/mkisofs/multi.c

2235 lines
57 KiB
C
Raw Normal View History

Initial commit
2025-06-15 04:19:58 +08:00
/* @(#)multi.c 1.104 16/01/06 joerg */
#include <schily/mconfig.h>
#ifndef lint
static UConst char sccsid[] =
"@(#)multi.c 1.104 16/01/06 joerg";
#endif
/*
* File multi.c - scan existing iso9660 image and merge into
* iso9660 filesystem. Used for multisession support.
*
* Written by Eric Youngdale (1996).
* Copyright (c) 1999-2016 J. Schilling
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "mkisofs.h"
#include "rock.h"
#include <schily/time.h>
#include <schily/errno.h>
#include <schily/utypes.h>
#include <schily/schily.h>
#include <schily/ctype.h> /* Needed for printasc() */
#ifdef VMS
#include <sys/file.h>
#include <vms/fabdef.h>
#include "vms.h"
#endif
#ifndef howmany
#define howmany(x, y) (((x)+((y)-1))/(y))
#endif
#ifndef roundup
#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
#endif
/*
* Cannot debug memset() with gdb on Linux, so use fillbytes()
*/
/*#define memset(s, c, n) fillbytes(s, n, c)*/
#define TF_CREATE 1
#define TF_MODIFY 2
#define TF_ACCESS 4
#define TF_ATTRIBUTES 8
LOCAL void printasc __PR((char *txt, unsigned char *p, int len));
LOCAL void prbytes __PR((char *txt, unsigned char *p, int len));
unsigned char *parse_xa __PR((unsigned char *pnt, int *lenp,
struct directory_entry *dpnt));
EXPORT int rr_flags __PR((struct iso_directory_record *idr));
LOCAL int parse_rrflags __PR((Uchar *pnt, int len, int cont_flag));
LOCAL BOOL find_rr __PR((struct iso_directory_record *idr, Uchar **pntp, int *lenp));
LOCAL int parse_rr __PR((unsigned char *pnt, int len,
struct directory_entry *dpnt));
LOCAL int check_rr_dates __PR((struct directory_entry *dpnt,
struct directory_entry *current,
struct stat *statbuf,
struct stat *lstatbuf));
LOCAL BOOL valid_iso_directory __PR((struct iso_directory_record *idr,
int idr_off,
size_t space_left));
LOCAL struct directory_entry **
read_merging_directory __PR((struct iso_directory_record *, int *));
LOCAL int free_mdinfo __PR((struct directory_entry **, int len));
LOCAL void free_directory_entry __PR((struct directory_entry *dirp));
LOCAL int iso_dir_ents __PR((struct directory_entry *de));
LOCAL void copy_mult_extent __PR((struct directory_entry *se1,
struct directory_entry *se2));
LOCAL void merge_remaining_entries __PR((struct directory *,
struct directory_entry **, int));
LOCAL int merge_old_directory_into_tree __PR((struct directory_entry *,
struct directory *));
LOCAL void check_rr_relocation __PR((struct directory_entry *de));
FILE *in_image = NULL;
BOOL ignerr = FALSE;
int su_version = -1;
int rr_version = -1;
int aa_version = -1;
char er_id[256];
#ifndef USE_SCG
/*
* Don't define readsecs if mkisofs is linked with
* the SCSI library.
* readsecs() will be implemented as SCSI command in this case.
*
* Use global var in_image directly in readsecs()
* the SCSI equivalent will not use a FILE* for I/O.
*
* The main point of this pointless abstraction is that Solaris won't let
* you read 2K sectors from the cdrom driver. The fact that 99.9% of the
* discs out there have a 2K sectorsize doesn't seem to matter that much.
* Anyways, this allows the use of a scsi-generics type of interface on
* Solaris.
*/
#ifdef PROTOTYPES
EXPORT int
readsecs(UInt32_t startsecno, void *buffer, int sectorcount)
#else
EXPORT int
readsecs(startsecno, buffer, sectorcount)
UInt32_t startsecno;
void *buffer;
int sectorcount;
#endif
{
int f = fileno(in_image);
if (lseek(f, (off_t)startsecno * SECTOR_SIZE, SEEK_SET) == (off_t)-1) {
comerr(_("Seek error on old image\n"));
}
if (read(f, buffer, (sectorcount * SECTOR_SIZE))
!= (sectorcount * SECTOR_SIZE)) {
comerr(_("Read error on old image\n"));
}
return (sectorcount * SECTOR_SIZE);
}
#endif
LOCAL void
printasc(txt, p, len)
char *txt;
unsigned char *p;
int len;
{
int i;
error("%s ", txt);
for (i = 0; i < len; i++) {
if (isprint(p[i]))
error("%c", p[i]);
else
error(".");
}
error("\n");
}
LOCAL void
prbytes(txt, p, len)
char *txt;
register Uchar *p;
register int len;
{
error("%s", txt);
while (--len >= 0)
error(" %02X", *p++);
error("\n");
}
unsigned char *
parse_xa(pnt, lenp, dpnt)
unsigned char *pnt;
int *lenp;
struct directory_entry *dpnt;
{
struct iso_xa_dir_record *xadp;
int len = *lenp;
static int did_xa = 0;
/*error("len: %d\n", len);*/
if (len >= 14) {
xadp = (struct iso_xa_dir_record *)pnt;
/* if (dpnt) prbytes("XA ", pnt, len);*/
if (xadp->signature[0] == 'X' && xadp->signature[1] == 'A' &&
xadp->reserved[0] == '\0') {
len -= 14;
pnt += 14;
*lenp = len;
if (!did_xa) {
did_xa = 1;
errmsgno(EX_BAD, _("Found XA directory extension record.\n"));
}
} else if (pnt[2] == 0) {
char *cp = NULL;
if (dpnt)
cp = (char *)&dpnt->isorec;
if (cp) {
prbytes("ISOREC:", (Uchar *)cp, 33+cp[32]);
printasc("ISOREC:", (Uchar *)cp, 33+cp[32]);
prbytes("XA REC:", pnt, len);
printasc("XA REC:", pnt, len);
}
if (no_rr == 0) {
errmsgno(EX_BAD, _("Disabling RR / XA / AA.\n"));
no_rr = 1;
}
*lenp = 0;
if (cp) {
errmsgno(EX_BAD, _("Problems with old ISO directory entry for file: '%s'.\n"), &cp[33]);
}
errmsgno(EX_BAD, _("Illegal extended directory attributes found (bad XA disk?).\n"));
/* errmsgno(EX_BAD, _("Disabling Rock Ridge for old session.\n"));*/
comerrno(EX_BAD, _("Try again using the -no-rr option.\n"));
}
}
if (len >= 4 && pnt[3] != 1 && pnt[3] != 2) {
prbytes("BAD RR ATTRIBUTES:", pnt, len);
printasc("BAD RR ATTRIBUTES:", pnt, len);
}
return (pnt);
}
LOCAL BOOL
find_rr(idr, pntp, lenp)
struct iso_directory_record *idr;
Uchar **pntp;
int *lenp;
{
struct iso_xa_dir_record *xadp;
int len;
unsigned char *pnt;
BOOL ret = FALSE;
len = idr->length[0] & 0xff;
len -= sizeof (struct iso_directory_record);
len += sizeof (idr->name);
len -= idr->name_len[0];
pnt = (unsigned char *) idr;
pnt += sizeof (struct iso_directory_record);
pnt -= sizeof (idr->name);
pnt += idr->name_len[0];
if ((idr->name_len[0] & 1) == 0) {
pnt++;
len--;
}
if (len >= 14) {
xadp = (struct iso_xa_dir_record *)pnt;
if (xadp->signature[0] == 'X' && xadp->signature[1] == 'A' &&
xadp->reserved[0] == '\0') {
len -= 14;
pnt += 14;
ret = TRUE;
}
}
*pntp = pnt;
*lenp = len;
return (ret);
}
LOCAL int
parse_rrflags(pnt, len, cont_flag)
Uchar *pnt;
int len;
int cont_flag;
{
int ncount;
UInt32_t cont_extent;
UInt32_t cont_offset;
UInt32_t cont_size;
int flag1;
int flag2;
cont_extent = cont_offset = cont_size = 0;
ncount = 0;
flag1 = -1;
flag2 = 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]);
return (0); /* JS ??? Is this right ??? */
}
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 (0); /* JS ??? Is this right ??? */
}
ncount++;
if (pnt[0] == 'R' && pnt[1] == 'R')
flag1 = pnt[4] & 0xff;
if (strncmp((char *)pnt, "PX", 2) == 0) /* POSIX attributes */
flag2 |= RR_FLAG_PX;
if (strncmp((char *)pnt, "PN", 2) == 0) /* POSIX device number */
flag2 |= RR_FLAG_PN;
if (strncmp((char *)pnt, "SL", 2) == 0) /* Symlink */
flag2 |= RR_FLAG_SL;
if (strncmp((char *)pnt, "NM", 2) == 0) /* Alternate Name */
flag2 |= RR_FLAG_NM;
if (strncmp((char *)pnt, "CL", 2) == 0) /* Child link */
flag2 |= RR_FLAG_CL;
if (strncmp((char *)pnt, "PL", 2) == 0) /* Parent link */
flag2 |= RR_FLAG_PL;
if (strncmp((char *)pnt, "RE", 2) == 0) /* Relocated Direcotry */
flag2 |= RR_FLAG_RE;
if (strncmp((char *)pnt, "TF", 2) == 0) /* Time stamp */
flag2 |= RR_FLAG_TF;
if (strncmp((char *)pnt, "SP", 2) == 0) { /* SUSP record */
flag2 |= RR_FLAG_SP;
if (su_version < 0)
su_version = pnt[3] & 0xff;
}
if (strncmp((char *)pnt, "AA", 2) == 0) { /* Apple Signature record */
flag2 |= RR_FLAG_AA;
if (aa_version < 0)
aa_version = pnt[3] & 0xff;
}
if (strncmp((char *)pnt, "ER", 2) == 0) {
flag2 |= RR_FLAG_ER; /* ER record */
if (rr_version < 0)
rr_version = pnt[7] & 0xff; /* Ext Version */
strlcpy(er_id, (char *)&pnt[8], (pnt[4] & 0xFF) + 1);
}
if (strncmp((char *)pnt, "CE", 2) == 0) { /* Continuation Area */
cont_extent = get_733(pnt+4);
cont_offset = get_733(pnt+12);
cont_size = get_733(pnt+20);
}
if (strncmp((char *)pnt, "ST", 2) == 0) { /* Terminate SUSP */
break;
}
len -= pnt[2];
pnt += pnt[2];
}
if (cont_extent) {
unsigned char sector[SECTOR_SIZE];
readsecs(cont_extent, sector, 1);
flag2 |= parse_rrflags(&sector[cont_offset], cont_size, 1);
}
return (flag2);
}
int
rr_flags(idr)
struct iso_directory_record *idr;
{
int len;
unsigned char *pnt;
int ret = 0;
if (find_rr(idr, &pnt, &len))
ret |= RR_FLAG_XA;
ret |= parse_rrflags(pnt, len, 0);
return (ret);
}
/*
* Parse the RR attributes so we can find the file name.
*/
LOCAL int
parse_rr(pnt, len, dpnt)
unsigned char *pnt;
int len;
struct directory_entry *dpnt;
{
UInt32_t cont_extent;
UInt32_t cont_offset;
UInt32_t cont_size;
char name_buf[256];
cont_extent = cont_offset = cont_size = 0;
pnt = parse_xa(pnt, &len, dpnt /* 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]);
return (-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 (-1);
}
if (strncmp((char *)pnt, "NM", 2) == 0) {
strncpy(name_buf, (char *)pnt + 5, pnt[2] - 5);
name_buf[pnt[2] - 5] = 0;
if (dpnt->name) {
size_t nlen = strlen(dpnt->name);
/*
* append to name from previous NM records
*/
dpnt->name = realloc(dpnt->name, nlen +
strlen(name_buf) + 1);
strcpy(dpnt->name + nlen, name_buf);
} else {
dpnt->name = e_strdup(name_buf);
dpnt->got_rr_name = 1;
}
/* continue searching for more NM records */
} else if (strncmp((char *)pnt, "CE", 2) == 0) {
cont_extent = get_733(pnt + 4);
cont_offset = get_733(pnt + 12);
cont_size = get_733(pnt + 20);
} else if (strncmp((char *)pnt, "ST", 2) == 0) {
break;
}
len -= pnt[2];
pnt += pnt[2];
}
if (cont_extent) {
unsigned char sector[SECTOR_SIZE];
readsecs(cont_extent, sector, 1);
if (parse_rr(&sector[cont_offset], cont_size, dpnt) == -1)
return (-1);
}
/* Fall back to the iso name if no RR name found */
if (dpnt->name == NULL) {
char *cp;
strlcpy(name_buf, dpnt->isorec.name, sizeof (name_buf));
cp = strchr(name_buf, ';');
if (cp != NULL) {
*cp = '\0';
}
dpnt->name = e_strdup(name_buf);
}
return (0);
} /* parse_rr */
/*
* Returns 1 if the two files are identical
* Returns 0 if the two files differ
*/
LOCAL int
check_rr_dates(dpnt, current, statbuf, lstatbuf)
struct directory_entry *dpnt;
struct directory_entry *current;
struct stat *statbuf;
struct stat *lstatbuf;
{
UInt32_t cont_extent;
UInt32_t cont_offset;
UInt32_t cont_size;
UInt32_t offset;
unsigned char *pnt;
int len;
int same_file;
int same_file_type;
mode_t mode;
char time_buf[7];
cont_extent = cont_offset = cont_size = 0;
same_file = 1;
same_file_type = 1;
pnt = dpnt->rr_attributes;
len = dpnt->rr_attr_size;
/*
* We basically need to parse the rr attributes again, and dig out the
* dates and file types.
*/
pnt = parse_xa(pnt, &len, /* dpnt */ 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]);
return (-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 (-1);
}
/*
* If we have POSIX file modes, make sure that the file type is
* the same. If it isn't, then we must always write the new
* file.
*/
if (strncmp((char *)pnt, "PX", 2) == 0) {
mode = get_733(pnt + 4);
if ((lstatbuf->st_mode & S_IFMT) != (mode & S_IFMT)) {
same_file_type = 0;
same_file = 0;
}
}
if (strncmp((char *)pnt, "TF", 2) == 0) {
offset = 5;
if (pnt[4] & TF_CREATE) {
iso9660_date((char *)time_buf,
lstatbuf->st_ctime);
if (memcmp(time_buf, pnt + offset, 7) != 0)
same_file = 0;
offset += 7;
}
if (pnt[4] & TF_MODIFY) {
iso9660_date((char *)time_buf,
lstatbuf->st_mtime);
if (memcmp(time_buf, pnt + offset, 7) != 0)
same_file = 0;
offset += 7;
}
}
if (strncmp((char *)pnt, "CE", 2) == 0) {
cont_extent = get_733(pnt + 4);
cont_offset = get_733(pnt + 12);
cont_size = get_733(pnt + 20);
}
if (strncmp((char *)pnt, "ST", 2) == 0) { /* Terminate SUSP */
break;
}
len -= pnt[2];
pnt += pnt[2];
}
if (cont_extent) {
unsigned char sector[SECTOR_SIZE];
readsecs(cont_extent, sector, 1);
/*
* Continue to scan the extension record.
* Note that this has not been tested yet, but it is
* definitely more correct that calling parse_rr()
* as done in Eric's old code.
*/
pnt = &sector[cont_offset];
len = cont_size;
/*
* Clear the "pending extension record" state as
* we did already read it now.
*/
cont_extent = cont_offset = cont_size = 0;
}
/*
* If we have the same fundamental file type, then it is clearly safe
* to reuse the TRANS.TBL entry.
*/
if (same_file_type) {
current->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY;
}
return (same_file);
}
LOCAL BOOL
valid_iso_directory(idr, idr_off, space_left)
struct iso_directory_record *idr;
int idr_off;
size_t space_left;
{
size_t idr_length = idr->length[0] & 0xFF;
size_t idr_ext_length = idr->ext_attr_length[0] & 0xFF;
size_t idr_namelength = idr->name_len[0] & 0xFF;
int namelimit = space_left -
offsetof(struct iso_directory_record, name[0]);
int nlimit = (idr_namelength < namelimit) ?
idr_namelength : namelimit;
/*
* Check for sane length entries.
*/
if (idr_length > space_left) {
comerrno(EX_BAD,
_("Bad directory length %zu (> %d available) for '%.*s'.\n"),
idr_length, namelimit, nlimit, idr->name);
}
if (idr_length == 0) {
if ((idr_off % SECTOR_SIZE) != 0) {
/*
* It marks a valid continuation entry.
*/
return (TRUE);
} else {
comerrno(EX_BAD,
_("Zero directory length for '%.*s'.\n"),
nlimit, idr->name);
}
}
if (idr_length <= offsetof(struct iso_directory_record, name[0])) {
comerrno(EX_BAD, _("Bad directory length %zu (< %zu minimum).\n"),
idr_length, 1 + offsetof(struct iso_directory_record, name[0]));
}
if ((idr_length & 1) != 0) {
comerrno(EX_BAD, _("Odd directory length %zu for '%.*s'.\n"),
idr_length, nlimit, idr->name);
}
if (idr_namelength == 0) {
comerrno(EX_BAD, _("Zero filename length.\n"));
}
if (!(idr_namelength & 1)) {
/*
* if nam_len[0] is even, there has to be a pad byte at the end
* to make the directory length even
*/
idr_namelength++;
}
if ((offsetof(struct iso_directory_record, name[0]) +
idr_namelength) > idr_length) {
int xlimit = idr_length -
offsetof(struct iso_directory_record, name[0]) -
idr_ext_length;
if (xlimit < 0)
xlimit = 0;
if (nlimit < xlimit)
xlimit = nlimit;
comerrno(EX_BAD, _("Bad filename length %zu (> %d) for '%.*s'.\n"),
idr_namelength, xlimit, xlimit, idr->name);
}
if ((offsetof(struct iso_directory_record, name[0]) +
idr_namelength + idr_ext_length) > idr_length) {
int xlimit = idr_length -
offsetof(struct iso_directory_record, name[0]) -
idr_namelength;
comerrno(EX_BAD, _("Bad extended attribute length %zu (> %d) for '%.*s'.\n"),
idr_ext_length, xlimit, nlimit, idr->name);
}
#ifdef __do_rr_
/* check for rock ridge extensions */
if (no_rr) {
/*
* Rock Ridge extensions are not present or manually disabled.
*/
return (TRUE);
} else {
int rlen = idr_length -
offsetof(struct iso_directory_record, name[0]) -
idr_namelength;
/* Check for the minimum of Rock Ridge extensions. */
}
#endif
return (TRUE);
}
LOCAL struct directory_entry **
read_merging_directory(mrootp, nentp)
struct iso_directory_record *mrootp;
int *nentp;
{
unsigned char *cpnt;
unsigned char *cpnt1;
char *p;
char *dirbuff;
int i;
struct iso_directory_record *idr;
UInt32_t len;
UInt32_t nbytes;
int nent;
int nmult; /* # of multi extent root entries */
int mx;
struct directory_entry **pnt;
UInt32_t rlen;
struct directory_entry **rtn;
int seen_rockridge;
unsigned char *tt_buf;
UInt32_t tt_extent;
UInt32_t tt_size;
static int warning_given = 0;
/*
* This is the number of sectors we will need to read. We need to
* round up to get the last fractional sector - we are asking for the
* data in terms of a number of sectors.
*/
nbytes = roundup(get_733(mrootp->size), SECTOR_SIZE);
/*
* First, allocate a buffer large enough to read in the entire
* directory.
*/
dirbuff = (char *)e_malloc(nbytes);
readsecs(get_733(mrootp->extent), dirbuff, nbytes / SECTOR_SIZE);
/*
* Next look over the directory, and count up how many entries we have.
*/
len = get_733(mrootp->size);
i = 0;
*nentp = 0;
nent = 0;
nmult = 0;
mx = 0;
while ((i + offsetof(struct iso_directory_record, name[0])) < len) {
idr = (struct iso_directory_record *)&dirbuff[i];
if (!valid_iso_directory(idr, i, len - i))
break;
if (idr->length[0] == 0) {
i = ISO_ROUND_UP(i);
continue;
}
nent++;
if ((mx & ISO_MULTIEXTENT) == 0 &&
(idr->flags[0] & ISO_MULTIEXTENT) != 0) {
nmult++; /* Need a multi extent root entry */
}
mx = idr->flags[0];
i += idr->length[0];
}
/*
* Now allocate the buffer which will hold the array we are about to
* return. We need one entry per real directory entry and in addition
* one multi-extent root entry per multi-extent file.
*/
rtn = (struct directory_entry **)e_malloc((nent+nmult) * sizeof (*rtn));
/*
* Finally, scan the directory one last time, and pick out the relevant
* bits of information, and store it in the relevant bits of the
* structure.
*/
i = 0;
pnt = rtn;
tt_extent = 0;
seen_rockridge = 0;
tt_size = 0;
mx = 0;
while ((i + offsetof(struct iso_directory_record, name[0])) < len) {
idr = (struct iso_directory_record *)&dirbuff[i];
if (!valid_iso_directory(idr, i, len - i))
break;
if (idr->length[0] == 0) {
i = ISO_ROUND_UP(i);
continue;
}
*pnt = (struct directory_entry *)e_malloc(sizeof (**rtn));
(*pnt)->next = NULL;
#ifdef DEBUG
error("IDR name: '%s' ist: %d soll: %d\n",
idr->name, strlen(idr->name), idr->name_len[0]);
#endif
movebytes(idr, &(*pnt)->isorec, idr->length[0] & 0xFF);
(*pnt)->starting_block =
get_733(idr->extent);
(*pnt)->size = get_733(idr->size);
if ((*pnt)->size == 0) {
/*
* Find lowest used inode number for zero sized files
*/
if (((UInt32_t)(*pnt)->starting_block) <= null_inodes) {
null_inodes = (UInt32_t)(*pnt)->starting_block;
null_inodes--;
}
}
(*pnt)->priority = 0;
(*pnt)->name = NULL;
(*pnt)->got_rr_name = 0;
(*pnt)->table = NULL;
(*pnt)->whole_name = NULL;
(*pnt)->filedir = NULL;
(*pnt)->parent_rec = NULL;
/*
* Set this information so that we correctly cache previous
* session bits of information.
*/
(*pnt)->inode = (*pnt)->starting_block;
(*pnt)->dev = PREV_SESS_DEV;
(*pnt)->rr_attributes = NULL;
(*pnt)->rr_attr_size = 0;
(*pnt)->total_rr_attr_size = 0;
(*pnt)->de_flags = SAFE_TO_REUSE_TABLE_ENTRY;
#ifdef APPLE_HYB
(*pnt)->assoc = NULL;
(*pnt)->hfs_ent = NULL;
#endif /* APPLE_HYB */
/*
* Check for and parse any RR attributes for the file. All we
* are really looking for here is the original name of the
* file.
*/
rlen = idr->length[0] & 0xff;
cpnt = (unsigned char *) idr;
rlen -= offsetof(struct iso_directory_record, name[0]);
cpnt += offsetof(struct iso_directory_record, name[0]);
rlen -= idr->name_len[0];
cpnt += idr->name_len[0];
if ((idr->name_len[0] & 1) == 0) {
cpnt++;
rlen--;
}
if (no_rr)
rlen = 0;
if (rlen > 0) {
(*pnt)->total_rr_attr_size =
(*pnt)->rr_attr_size = rlen;
(*pnt)->rr_attributes = e_malloc(rlen);
memcpy((*pnt)->rr_attributes, cpnt, rlen);
seen_rockridge = 1;
}
#ifdef DEBUG
error("INT name: '%s' ist: %d soll: %d\n",
(*pnt)->isorec.name, strlen((*pnt)->isorec.name),
idr->name_len[0]);
#endif
if (idr->name_len[0] < sizeof ((*pnt)->isorec.name)) {
/*
* Now zero out the remainder of the name field.
*/
cpnt = (unsigned char *) (*pnt)->isorec.name;
cpnt += idr->name_len[0];
memset(cpnt, 0,
sizeof ((*pnt)->isorec.name) - idr->name_len[0]);
} else {
/*
* Simple sanity work to make sure that we have no
* illegal data structures in our tree.
*/
(*pnt)->isorec.name[MAX_ISONAME] = '\0';
(*pnt)->isorec.name_len[0] = MAX_ISONAME;
}
/*
* If the filename len from the old session is more
* then 31 chars, there is a high risk of hard violations
* of the ISO9660 standard.
* Run it through our name canonication machine....
*/
if (idr->name_len[0] > LEN_ISONAME || check_oldnames) {
iso9660_check(idr, *pnt);
}
if (parse_rr((*pnt)->rr_attributes, rlen, *pnt) == -1) {
comerrno(EX_BAD,
_("Cannot parse Rock Ridge attributes for '%s'.\n"),
idr->name);
}
if (((*pnt)->isorec.name_len[0] == 1) &&
(((*pnt)->isorec.name[0] == 0) || /* "." entry */
((*pnt)->isorec.name[0] == 1))) { /* ".." entry */
if ((*pnt)->name != NULL) {
free((*pnt)->name);
}
if ((*pnt)->whole_name != NULL) {
free((*pnt)->whole_name);
}
if ((*pnt)->isorec.name[0] == 0) {
(*pnt)->name = e_strdup(".");
} else {
(*pnt)->name = e_strdup("..");
}
}
#ifdef DEBUG
fprintf(stderr, "got DE name: %s\n", (*pnt)->name);
#endif
if (strncmp(idr->name, trans_tbl, strlen(trans_tbl)) == 0) {
if ((*pnt)->name != NULL) {
free((*pnt)->name);
}
if ((*pnt)->whole_name != NULL) {
free((*pnt)->whole_name);
}
/* (*pnt)->name = e_strdup("<translation table>");*/
(*pnt)->name = e_strdup(trans_tbl);
tt_extent = get_733(idr->extent);
tt_size = get_733(idr->size);
if (tt_extent == 0)
tt_size = 0;
}
/*
* The beginning of a new multi extent directory chain is when
* the last directory had no ISO_MULTIEXTENT flag set and the
* current entry did set ISO_MULTIEXTENT.
*/
if ((mx & ISO_MULTIEXTENT) == 0 &&
(idr->flags[0] & ISO_MULTIEXTENT) != 0) {
struct directory_entry *s_entry;
struct iso_directory_record *idr2 = idr;
int i2 = i;
off_t tsize = 0;
/*
* Sum up the total file size for the multi extent file
*/
while ((i2 + offsetof(struct iso_directory_record, name[0])) < len) {
idr2 = (struct iso_directory_record *)&dirbuff[i2];
if (idr2->length[0] == 0) {
i2 = ISO_ROUND_UP(i2);
continue;
}
tsize += get_733(idr2->size);
if ((idr2->flags[0] & ISO_MULTIEXTENT) == 0)
break;
i2 += idr2->length[0];
}
s_entry = dup_directory_entry(*pnt); /* dup first for mxroot */
s_entry->de_flags |= MULTI_EXTENT;
s_entry->de_flags |= INHIBIT_ISO9660_ENTRY|INHIBIT_JOLIET_ENTRY;
s_entry->size = tsize;
s_entry->starting_block = (*pnt)->starting_block;
s_entry->mxroot = s_entry;
s_entry->mxpart = 0;
s_entry->next = *pnt; /* Next in list */
pnt[1] = pnt[0]; /* Move to next slot */
*pnt = s_entry; /* First slot is mxroot */
pnt++; /* Point again to cur. */
}
if ((mx & ISO_MULTIEXTENT) != 0 ||
(idr->flags[0] & ISO_MULTIEXTENT) != 0) {
(*pnt)->de_flags |= MULTI_EXTENT;
(*pnt)->de_flags |= INHIBIT_UDF_ENTRY;
(pnt[-1])->next = *pnt;
(*pnt)->mxroot = (pnt[-1])->mxroot;
(*pnt)->mxpart = (pnt[-1])->mxpart + 1;
}
pnt++;
mx = idr->flags[0];
i += idr->length[0];
}
#ifdef APPLE_HYB
/*
* If we find an associated file, check if there is a file
* with same ISO name and link it to this entry
*/
for (pnt = rtn, i = 0; i < nent; i++, pnt++) {
int j;
rlen = get_711((*pnt)->isorec.name_len);
if ((*pnt)->isorec.flags[0] & ISO_ASSOCIATED) {
for (j = 0; j < nent; j++) {
if (strncmp(rtn[j]->isorec.name,
(*pnt)->isorec.name, rlen) == 0 &&
(rtn[j]->isorec.flags[0] & ISO_ASSOCIATED) == 0) {
rtn[j]->assoc = *pnt;
/*
* don't want this entry to be
* in the Joliet tree
*/
(*pnt)->de_flags |= INHIBIT_JOLIET_ENTRY;
/*
* XXX Is it correct to exclude UDF too?
*/
(*pnt)->de_flags |= INHIBIT_UDF_ENTRY;
/*
* as we have associated files, then
* assume we are are dealing with
* Apple's extensions - if not already
* set
*/
if (apple_both == 0) {
apple_both = apple_ext = 1;
}
break;
}
}
}
}
#endif /* APPLE_HYB */
/*
* If there was a TRANS.TBL;1 entry, then grab it, read it, and use it
* to get the filenames of the files. Also, save the table info, just
* in case we need to use it.
*
* The entries look something like: F ISODUMP.;1 isodump
*/
if (tt_extent != 0 && tt_size != 0) {
nbytes = roundup(tt_size, SECTOR_SIZE);
tt_buf = (unsigned char *) e_malloc(nbytes);
readsecs(tt_extent, tt_buf, nbytes / SECTOR_SIZE);
/*
* Loop through the file, examine each entry, and attempt to
* attach it to the correct entry.
*/
cpnt = tt_buf;
cpnt1 = tt_buf;
while (cpnt - tt_buf < tt_size) {
/* Skip to a line terminator, or end of the file. */
while ((cpnt1 - tt_buf < tt_size) &&
(*cpnt1 != '\n') &&
(*cpnt1 != '\0')) {
cpnt1++;
}
/* Zero terminate this particular line. */
if (cpnt1 - tt_buf < tt_size) {
*cpnt1 = '\0';
}
/*
* Now dig through the actual directories, and try and
* find the attachment for this particular filename.
*/
for (pnt = rtn, i = 0; i < nent; i++, pnt++) {
rlen = get_711((*pnt)->isorec.name_len);
/*
* If this filename is so long that it would
* extend past the end of the file, it cannot
* be the one we want.
*/
if (cpnt + 2 + rlen - tt_buf >= tt_size) {
continue;
}
/*
* Now actually compare the name, and make sure
* that the character at the end is a ' '.
*/
if (strncmp((char *)cpnt + 2,
(*pnt)->isorec.name, rlen) == 0 &&
cpnt[2 + rlen] == ' ' &&
(p = strchr((char *)&cpnt[2 + rlen], '\t'))) {
p++;
/*
* This is a keeper. Now determine the
* correct table entry that we will
* use on the new image.
*/
if (strlen(p) > 0) {
(*pnt)->table =
e_malloc(strlen(p) + 4);
sprintf((*pnt)->table,
"%c\t%s\n",
*cpnt, p);
}
if (!(*pnt)->got_rr_name) {
if ((*pnt)->name != NULL) {
free((*pnt)->name);
}
(*pnt)->name = e_strdup(p);
}
break;
}
}
cpnt = cpnt1 + 1;
cpnt1 = cpnt;
}
free(tt_buf);
} else if (!seen_rockridge && !warning_given) {
/*
* Warn the user that iso-9660 names were used because neither
* Rock Ridge (-R) nor TRANS.TBL (-T) name translations were
* found.
*/
fprintf(stderr,
_("Warning: Neither Rock Ridge (-R) nor TRANS.TBL (-T) \n"));
fprintf(stderr,
_("name translations were found on previous session.\n"));
fprintf(stderr,
_("ISO-9660 file names have been used instead.\n"));
warning_given = 1;
}
if (dirbuff != NULL) {
free(dirbuff);
}
*nentp = nent + nmult;
return (rtn);
} /* read_merging_directory */
/*
* Free any associated data related to the structures.
*/
LOCAL int
free_mdinfo(ptr, len)
struct directory_entry **ptr;
int len;
{
int i;
struct directory_entry **p;
p = ptr;
for (i = 0; i < len; i++, p++) {
/*
* If the tree-handling code decided that it needed an entry, it
* will have removed it from the list. Thus we must allow for
* null pointers here.
*/
if (*p == NULL) {
continue;
}
free_directory_entry(*p);
}
free(ptr);
return (0);
}
LOCAL void
free_directory_entry(dirp)
struct directory_entry *dirp;
{
if (dirp->name != NULL)
free(dirp->name);
if (dirp->whole_name != NULL)
free(dirp->whole_name);
if (dirp->rr_attributes != NULL)
free(dirp->rr_attributes);
if (dirp->table != NULL)
free(dirp->table);
free(dirp);
}
/*
* Search the list to see if we have any entries from the previous
* session that match this entry. If so, copy the extent number
* over so we don't bother to write it out to the new session.
*/
int
check_prev_session(ptr, len, curr_entry, statbuf, lstatbuf, odpnt)
struct directory_entry **ptr;
int len;
struct directory_entry *curr_entry;
struct stat *statbuf;
struct stat *lstatbuf;
struct directory_entry **odpnt;
{
int i;
int rr;
int retcode = -2; /* Default not found */
for (i = 0; i < len; i++) {
if (ptr[i] == NULL) { /* Used or empty entry skip */
continue;
}
#if 0
if (ptr[i]->name != NULL && ptr[i]->isorec.name_len[0] == 1 &&
ptr[i]->name[0] == '\0') {
continue;
}
if (ptr[i]->name != NULL && ptr[i]->isorec.name_len[0] == 1 &&
ptr[i]->name[0] == 1) {
continue;
}
#else
if (ptr[i]->name != NULL && strcmp(ptr[i]->name, ".") == 0) {
continue;
}
if (ptr[i]->name != NULL && strcmp(ptr[i]->name, "..") == 0) {
continue;
}
#endif
if (ptr[i]->name != NULL &&
strcmp(ptr[i]->name, curr_entry->name) != 0) {
/* Not the same name continue */
continue;
}
/*
* It's a directory so we must always merge it with the new
* session. Never ever reuse directory extents. See comments
* in tree.c for an explaination of why this must be the case.
*/
if ((curr_entry->isorec.flags[0] & ISO_DIRECTORY) != 0) {
retcode = i;
goto found_it;
}
/*
* We know that the files have the same name. If they also
* have the same file type (i.e. file, dir, block, etc), then
* we can safely reuse the TRANS.TBL entry for this file. The
* check_rr_dates() function will do this for us.
*
* Verify that the file type and dates are consistent. If not,
* we probably have a different file, and we need to write it
* out again.
*/
retcode = i;
if (ptr[i]->rr_attributes != NULL) {
if ((rr = check_rr_dates(ptr[i], curr_entry, statbuf,
lstatbuf)) == -1)
return (-1);
if (rr == 0) { /* Different files */
goto found_it;
}
}
/*
* Verify size and timestamp. If rock ridge is in use, we
* need to compare dates from RR too. Directories are special,
* we calculate their size later.
*/
if (ptr[i]->size != curr_entry->size) {
/* Different files */
goto found_it;
}
if (memcmp(ptr[i]->isorec.date,
curr_entry->isorec.date, 7) != 0) {
/* Different files */
goto found_it;
}
/* We found it and we can reuse the extent */
memcpy(curr_entry->isorec.extent, ptr[i]->isorec.extent, 8);
curr_entry->starting_block = get_733(ptr[i]->isorec.extent);
curr_entry->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY;
if ((curr_entry->isorec.flags[0] & ISO_MULTIEXTENT) ||
(ptr[i]->isorec.flags[0] & ISO_MULTIEXTENT)) {
copy_mult_extent(curr_entry, ptr[i]);
}
goto found_it;
}
return (retcode);
found_it:
if (ptr[i]->mxroot == ptr[i]) { /* Remove all multi ext. entries */
int j = i + 1; /* First one will be removed below */
while (j < len && ptr[j] && ptr[j]->mxroot == ptr[i]) {
free(ptr[j]);
ptr[j++] = NULL;
}
}
if (odpnt != NULL) {
*odpnt = ptr[i];
} else {
free(ptr[i]);
}
ptr[i] = NULL;
return (retcode);
}
/*
* Return the number of directory entries for a file. This is usually 1
* but may be 3 or more in case of multi extent files.
*/
LOCAL int
iso_dir_ents(de)
struct directory_entry *de;
{
struct directory_entry *de2;
int ret = 0;
if (de->mxroot == NULL)
return (1);
de2 = de;
while (de2 != NULL && de2->mxroot == de->mxroot) {
ret++;
de2 = de2->next;
}
return (ret);
}
/*
* Copy old multi-extent directory information from the previous session.
* If both the old session and the current session are created by mkisofs
* then this code could be extremely simple as the information is only copied
* in case that the file did not change since the last session was made.
* As we don't know the other ISO formatter program, any combination of
* multi-extent files and even a single extent file could be possible.
* We need to handle all files the same way ad the old session was created as
* we reuse the data extents from the file in the old session.
*/
LOCAL void
copy_mult_extent(se1, se2)
struct directory_entry *se1;
struct directory_entry *se2;
{
struct directory_entry *curr_entry = se1;
int len1;
int len2;
int mxpart = 0;
len1 = iso_dir_ents(se1);
len2 = iso_dir_ents(se2);
if (len1 == 1) {
/*
* Convert single-extent to multi-extent.
* If *se1 is not multi-extent, *se2 definitely is
* and we need to set up a MULTI_EXTENT directory header.
*/
se1->de_flags |= MULTI_EXTENT;
se1->isorec.flags[0] |= ISO_MULTIEXTENT;
se1->mxroot = curr_entry;
se1->mxpart = 0;
se1 = dup_directory_entry(se1);
curr_entry->de_flags |= INHIBIT_ISO9660_ENTRY|INHIBIT_JOLIET_ENTRY;
se1->de_flags |= INHIBIT_UDF_ENTRY;
se1->next = curr_entry->next;
curr_entry->next = se1;
se1 = curr_entry;
len1 = 2;
}
while (se2->isorec.flags[0] & ISO_MULTIEXTENT) {
len1--;
len2--;
if (len1 <= 0) {
struct directory_entry *sex = dup_directory_entry(se1);
sex->mxroot = curr_entry;
sex->next = se1->next;
se1->next = sex;
len1++;
}
memcpy(se1->isorec.extent, se2->isorec.extent, 8);
se1->starting_block = get_733(se2->isorec.extent);
se1->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY;
se1->de_flags |= MULTI_EXTENT;
se1->isorec.flags[0] |= ISO_MULTIEXTENT;
se1->mxroot = curr_entry;
se1->mxpart = mxpart++;
se1 = se1->next;
se2 = se2->next;
}
memcpy(se1->isorec.extent, se2->isorec.extent, 8);
se1->starting_block = get_733(se2->isorec.extent);
se1->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY;
se1->isorec.flags[0] &= ~ISO_MULTIEXTENT; /* Last entry */
se1->mxpart = mxpart;
while (len1 > 1) { /* Drop other entries */
struct directory_entry *sex;
sex = se1->next;
se1->next = sex->next;
free(sex);
len1--;
}
}
/*
* open_merge_image: Open an existing image.
*/
int
open_merge_image(path)
char *path;
{
#ifndef USE_SCG
in_image = fopen(path, "rb");
if (in_image == NULL) {
return (-1);
}
#else
in_image = fopen(path, "rb");
if (in_image == NULL) {
if (scsidev_open(path) < 0)
return (-1);
}
#endif
return (0);
}
/*
* close_merge_image: Close an existing image.
*/
int
close_merge_image()
{
#ifdef USE_SCG
return (scsidev_close());
#else
return (fclose(in_image));
#endif
}
/*
* merge_isofs: Scan an existing image, and return a pointer
* to the root directory for this image.
*/
struct iso_directory_record *
merge_isofs(path)
char *path;
{
char buffer[SECTOR_SIZE];
int file_addr;
int i;
int sum = 0;
char *p = buffer;
struct iso_primary_descriptor *pri = NULL;
struct iso_directory_record *rootp;
struct iso_volume_descriptor *vdp;
/*
* Start by searching for the volume header. Ultimately, we need to
* search for volume headers in multiple places because we might be
* starting with a multisession image. FIXME(eric).
*/
get_session_start(&file_addr);
for (i = 0; i < 100; i++) {
if (readsecs(file_addr, buffer,
sizeof (buffer) / SECTOR_SIZE) != sizeof (buffer)) {
comerr(_("Read error on old image %s\n"), path);
}
vdp = (struct iso_volume_descriptor *)buffer;
if ((strncmp(vdp->id, ISO_STANDARD_ID, sizeof (vdp->id)) == 0) &&
(get_711(vdp->type) == ISO_VD_PRIMARY)) {
break;
}
file_addr += 1;
}
if (i == 100) {
return (NULL);
}
for (i = 0; i < 2048-3; i++) {
sum += p[i] & 0xFF;
}
pri = (struct iso_primary_descriptor *)vdp;
/* Check the blocksize of the image to make sure it is compatible. */
if (get_723(pri->logical_block_size) != SECTOR_SIZE) {
errmsgno(EX_BAD,
_("Previous session has incompatible sector size %u.\n"),
get_723(pri->logical_block_size));
return (NULL);
}
if (get_723(pri->volume_set_size) != 1) {
errmsgno(EX_BAD,
_("Previous session has volume set size %u (must be 1).\n"),
get_723(pri->volume_set_size));
return (NULL);
}
/* Get the location and size of the root directory. */
rootp = (struct iso_directory_record *)
e_malloc(sizeof (struct iso_directory_record));
memcpy(rootp, pri->root_directory_record,
sizeof (pri->root_directory_record));
for (i = 0; i < 100; i++) {
if (readsecs(file_addr, buffer,
sizeof (buffer) / SECTOR_SIZE) != sizeof (buffer)) {
comerr(_("Read error on old image %s\n"), path);
}
if (strncmp(buffer, "MKI ", 4) == 0) {
int sum2;
sum2 = p[2045] & 0xFF;
sum2 *= 256;
sum2 += p[2046] & 0xFF;
sum2 *= 256;
sum2 += p[2047] & 0xFF;
if (sum == sum2) {
error(_("ISO-9660 image includes checksum signature for correct inode numbers.\n"));
} else {
correct_inodes = FALSE;
rrip112 = FALSE;
}
break;
}
file_addr += 1;
}
return (rootp);
}
LOCAL void
merge_remaining_entries(this_dir, pnt, n_orig)
struct directory *this_dir;
struct directory_entry **pnt;
int n_orig;
{
int i;
struct directory_entry *s_entry;
UInt32_t ttbl_extent = 0;
unsigned int ttbl_index = 0;
char whole_path[PATH_MAX];
/*
* Whatever is leftover in the list needs to get merged back into the
* directory.
*/
for (i = 0; i < n_orig; i++) {
if (pnt[i] == NULL) {
continue;
}
if (pnt[i]->name != NULL && pnt[i]->whole_name == NULL) {
/* Set the name for this directory. */
strlcpy(whole_path, this_dir->de_name,
sizeof (whole_path));
strcat(whole_path, SPATH_SEPARATOR);
strcat(whole_path, pnt[i]->name);
pnt[i]->whole_name = e_strdup(whole_path);
}
if (pnt[i]->name != NULL &&
/* strcmp(pnt[i]->name, "<translation table>") == 0 )*/
strcmp(pnt[i]->name, trans_tbl) == 0) {
ttbl_extent =
get_733(pnt[i]->isorec.extent);
ttbl_index = i;
continue;
}
/*
* Skip directories for now - these need to be treated
* differently.
*/
if ((pnt[i]->isorec.flags[0] & ISO_DIRECTORY) != 0) {
/*
* FIXME - we need to insert this directory into the
* tree, so that the path tables we generate will be
* correct.
*/
if ((strcmp(pnt[i]->name, ".") == 0) ||
(strcmp(pnt[i]->name, "..") == 0)) {
free_directory_entry(pnt[i]);
pnt[i] = NULL;
continue;
} else {
merge_old_directory_into_tree(pnt[i], this_dir);
}
}
pnt[i]->next = this_dir->contents;
pnt[i]->filedir = this_dir;
this_dir->contents = pnt[i];
pnt[i] = NULL;
}
/*
* If we don't have an entry for the translation table, then don't
* bother trying to copy the starting extent over. Note that it is
* possible that if we are copying the entire directory, the entry for
* the translation table will have already been inserted into the
* linked list and removed from the old entries list, in which case we
* want to leave the extent number as it was before.
*/
if (ttbl_extent == 0) {
return;
}
/*
* Finally, check the directory we are creating to see whether there
* are any new entries in it. If there are not, we can reuse the same
* translation table.
*/
for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next) {
/*
* Don't care about '.' or '..'. They are never in the table
* anyways.
*/
if (s_entry->name != NULL && strcmp(s_entry->name, ".") == 0) {
continue;
}
if (s_entry->name != NULL && strcmp(s_entry->name, "..") == 0) {
continue;
}
/* if (s_entry->name != NULL &&*/
/* strcmp(s_entry->name, "<translation table>") == 0)*/
if (s_entry->name != NULL &&
strcmp(s_entry->name, trans_tbl) == 0) {
continue;
}
if ((s_entry->de_flags & SAFE_TO_REUSE_TABLE_ENTRY) == 0) {
return;
}
}
/*
* Locate the translation table, and re-use the same extent. It isn't
* clear that there should ever be one in there already so for now we
* try and muddle through the best we can.
*/
for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next) {
/* if (strcmp(s_entry->name, "<translation table>") == 0)*/
if (strcmp(s_entry->name, trans_tbl) == 0) {
fprintf(stderr, "Should never get here\n");
set_733(s_entry->isorec.extent, ttbl_extent);
return;
}
}
pnt[ttbl_index]->next = this_dir->contents;
pnt[ttbl_index]->filedir = this_dir;
this_dir->contents = pnt[ttbl_index];
pnt[ttbl_index] = NULL;
}
/*
* Here we have a case of a directory that has completely disappeared from
* the face of the earth on the tree we are mastering from. Go through and
* merge it into the tree, as well as everything beneath it.
*
* Note that if a directory has been moved for some reason, this will
* incorrectly pick it up and attempt to merge it back into the old
* location. FIXME(eric).
*/
LOCAL int
merge_old_directory_into_tree(dpnt, parent)
struct directory_entry *dpnt;
struct directory *parent;
{
struct directory_entry **contents = NULL;
int i;
int n_orig;
struct directory *this_dir,
*next_brother;
char whole_path[PATH_MAX];
this_dir = (struct directory *)e_malloc(sizeof (struct directory));
memset(this_dir, 0, sizeof (struct directory));
this_dir->next = NULL;
this_dir->subdir = NULL;
this_dir->self = dpnt;
this_dir->contents = NULL;
this_dir->size = 0;
this_dir->extent = 0;
this_dir->depth = parent->depth + 1;
this_dir->parent = parent;
if (!parent->subdir)
parent->subdir = this_dir;
else {
next_brother = parent->subdir;
while (next_brother->next)
next_brother = next_brother->next;
next_brother->next = this_dir;
}
/* Set the name for this directory. */
if (strlcpy(whole_path, parent->de_name, sizeof (whole_path)) >= sizeof (whole_path) ||
strlcat(whole_path, SPATH_SEPARATOR, sizeof (whole_path)) >= sizeof (whole_path) ||
strlcat(whole_path, dpnt->name, sizeof (whole_path)) >= sizeof (whole_path))
comerrno(EX_BAD, _("Path name '%s%s%s' exceeds max length %zd\n"),
parent->de_name,
SPATH_SEPARATOR,
dpnt->name,
sizeof (whole_path));
this_dir->de_name = e_strdup(whole_path);
this_dir->whole_name = e_strdup(whole_path);
/*
* Now fill this directory using information from the previous session.
*/
contents = read_merging_directory(&dpnt->isorec, &n_orig);
/*
* Start by simply copying the '.', '..' and non-directory entries to
* this directory. Technically we could let merge_remaining_entries
* handle this, but it gets rather confused by the '.' and '..' entries
*/
for (i = 0; i < n_orig; i++) {
/*
* We can always reuse the TRANS.TBL in this particular case.
*/
contents[i]->de_flags |= SAFE_TO_REUSE_TABLE_ENTRY;
if (((contents[i]->isorec.flags[0] & ISO_DIRECTORY) != 0) &&
(i >= 2)) {
continue;
}
/* If we have a directory, don't reuse the extent number. */
if ((contents[i]->isorec.flags[0] & ISO_DIRECTORY) != 0) {
memset(contents[i]->isorec.extent, 0, 8);
if (strcmp(contents[i]->name, ".") == 0)
this_dir->dir_flags |= DIR_HAS_DOT;
if (strcmp(contents[i]->name, "..") == 0)
this_dir->dir_flags |= DIR_HAS_DOTDOT;
}
/*
* for regilar files, we do it here.
* If it has CL or RE attributes, remember its extent
*/
check_rr_relocation(contents[i]);
/*
* Set the whole name for this file.
*/
if (strlcpy(whole_path, this_dir->whole_name, sizeof (whole_path)) >= sizeof (whole_path) ||
strlcat(whole_path, SPATH_SEPARATOR, sizeof (whole_path)) >= sizeof (whole_path) ||
strlcat(whole_path, contents[i]->name, sizeof (whole_path)) >= sizeof (whole_path))
comerrno(EX_BAD, _("Path name '%s%s%s' exceeds max length %zd\n"),
this_dir->whole_name,
SPATH_SEPARATOR,
contents[i]->name,
sizeof (whole_path));
contents[i]->whole_name = e_strdup(whole_path);
contents[i]->next = this_dir->contents;
contents[i]->filedir = this_dir;
this_dir->contents = contents[i];
contents[i] = NULL;
}
/*
* and for directories, we do it here.
* If it has CL or RE attributes, remember its extent
*/
check_rr_relocation(dpnt);
/*
* Zero the extent number for ourselves.
*/
memset(dpnt->isorec.extent, 0, 8);
/*
* Anything that is left are other subdirectories that need to be
* merged.
*/
merge_remaining_entries(this_dir, contents, n_orig);
free_mdinfo(contents, n_orig);
#if 0
/*
* This is no longer required. The post-scan sort will handle all of
* this for us.
*/
sort_n_finish(this_dir);
#endif
return (0);
}
char *cdrecord_data = NULL;
int
get_session_start(file_addr)
int *file_addr;
{
char *pnt;
#ifdef CDRECORD_DETERMINES_FIRST_WRITABLE_ADDRESS
/*
* FIXME(eric). We need to coordinate with cdrecord to obtain the
* parameters. For now, we assume we are writing the 2nd session, so
* we start from the session that starts at 0.
*/
if (file_addr != NULL)
*file_addr = 16;
/*
* We need to coordinate with cdrecord to get the next writable address
* from the device. Here is where we use it.
*/
session_start = last_extent = last_extent_written = cdrecord_result();
#else
if (file_addr != NULL)
*file_addr = 0L;
session_start = last_extent = last_extent_written = 0L;
if (check_session && cdrecord_data == NULL)
return (0);
if (cdrecord_data == NULL) {
comerrno(EX_BAD,
_("Special parameters for cdrecord not specified with -C\n"));
}
/*
* Next try and find the ',' in there which delimits the two numbers.
*/
pnt = strchr(cdrecord_data, ',');
if (pnt == NULL) {
comerrno(EX_BAD, _("Malformed cdrecord parameters\n"));
}
*pnt = '\0';
if (file_addr != NULL) {
*file_addr = atol(cdrecord_data);
}
pnt++;
session_start = last_extent = last_extent_written = atol(pnt);
pnt--;
*pnt = ',';
#endif
return (0);
}
/*
* This function scans the directory tree, looking for files, and it makes
* note of everything that is found. We also begin to construct the ISO9660
* directory entries, so that we can determine how large each directory is.
*/
int
merge_previous_session(this_dir, mrootp, reloc_root, reloc_old_root)
struct directory *this_dir;
struct iso_directory_record *mrootp;
char *reloc_root;
char *reloc_old_root;
{
struct directory_entry **orig_contents = NULL;
struct directory_entry *odpnt = NULL;
int n_orig;
struct directory_entry *s_entry;
int status;
int lstatus;
struct stat statbuf,
lstatbuf;
int retcode;
/* skip leading slash */
while (reloc_old_root && reloc_old_root[0] == PATH_SEPARATOR) {
reloc_old_root++;
}
while (reloc_root && reloc_root[0] == PATH_SEPARATOR) {
reloc_root++;
}
/*
* Parse the same directory in the image that we are merging for
* multisession stuff.
*/
orig_contents = read_merging_directory(mrootp, &n_orig);
if (orig_contents == NULL) {
if (reloc_old_root) {
comerrno(EX_BAD,
_("Reading old session failed, cannot execute -old-root.\n"));
}
return (0);
}
if (reloc_old_root && reloc_old_root[0]) {
struct directory_entry **new_orig_contents = orig_contents;
int new_n_orig = n_orig;
/* decend until we reach the original root */
while (reloc_old_root[0]) {
int i;
char *next;
int last;
for (next = reloc_old_root; *next && *next != PATH_SEPARATOR; next++);
if (*next) {
last = 0;
*next = 0;
next++;
} else {
last = 1;
}
while (*next == PATH_SEPARATOR) {
next++;
}
for (i = 0; i < new_n_orig; i++) {
struct iso_directory_record subroot;
if (new_orig_contents[i]->name != NULL &&
strcmp(new_orig_contents[i]->name, reloc_old_root) != 0) {
/* Not the same name continue */
continue;
}
/*
* enter directory, free old one only if not the top level,
* which is still needed
*/
subroot = new_orig_contents[i]->isorec;
if (new_orig_contents != orig_contents) {
free_mdinfo(new_orig_contents, new_n_orig);
}
new_orig_contents = read_merging_directory(&subroot, &new_n_orig);
if (!new_orig_contents) {
comerrno(EX_BAD,
_("Reading directory %s in old session failed, cannot execute -old-root.\n"),
reloc_old_root);
}
i = -1;
break;
}
if (i == new_n_orig) {
comerrno(EX_BAD,
_("-old-root (sub)directory %s not found in old session.\n"),
reloc_old_root);
}
/* restore string, proceed to next sub directory */
if (!last) {
reloc_old_root[strlen(reloc_old_root)] = PATH_SEPARATOR;
}
reloc_old_root = next;
}
/*
* preserve the old session, skipping those dirs/files that are found again
* in the new root
*/
for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next) {
status = stat_filter(s_entry->whole_name, &statbuf);
lstatus = lstat_filter(s_entry->whole_name, &lstatbuf);
/*
* check_prev_session() will search for s_entry and remove it from
* orig_contents if found
*/
retcode = check_prev_session(orig_contents, n_orig, s_entry,
&statbuf, &lstatbuf, NULL);
if (retcode == -1)
return (-1);
/*
* Skip other directory entries for multi-extent files
*/
if (s_entry->de_flags & MULTI_EXTENT) {
struct directory_entry *s_e;
for (s_e = s_entry->mxroot;
s_e && s_e->mxroot == s_entry->mxroot;
s_e = s_e->next) {
s_entry = s_e;
;
}
}
}
merge_remaining_entries(this_dir, orig_contents, n_orig);
/* use new directory */
free_mdinfo(orig_contents, n_orig);
orig_contents = new_orig_contents;
n_orig = new_n_orig;
if (reloc_root && reloc_root[0]) {
/* also decend into new root before searching for files */
this_dir = find_or_create_directory(this_dir, reloc_root, NULL, TRUE);
if (!this_dir) {
return (-1);
}
}
}
/*
* Now we scan the directory itself, and look at what is inside of it.
*/
for (s_entry = this_dir->contents; s_entry; s_entry = s_entry->next) {
status = stat_filter(s_entry->whole_name, &statbuf);
lstatus = lstat_filter(s_entry->whole_name, &lstatbuf);
/*
* We always should create an entirely new directory tree
* whenever we generate a new session, unless there were
* *no* changes whatsoever to any of the directories, in which
* case it would be kind of pointless to generate a new
* session.
* I believe it is possible to rigorously prove that any change
* anywhere in the filesystem will force the entire tree to be
* regenerated because the modified directory will get a new
* extent number. Since each subdirectory of the changed
* directory has a '..' entry, all of them will need to be
* rewritten too, and since the parent directory of the
* modified directory will have an extent pointer to the
* directory it too will need to be rewritten. Thus we will
* never be able to reuse any directory information when
* writing new sessions.
*
* We still check the previous session so we can mark off the
* equivalent entry in the list we got from the original disc,
* however.
*/
/*
* The check_prev_session function looks for an identical
* entry in the previous session. If we see it, then we copy
* the extent number to s_entry, and cross it off the list.
*/
retcode = check_prev_session(orig_contents, n_orig, s_entry,
&statbuf, &lstatbuf, &odpnt);
if (retcode == -1)
return (-1);
if (odpnt != NULL &&
(s_entry->isorec.flags[0] & ISO_DIRECTORY) != 0) {
int dflag;
if (strcmp(s_entry->name, ".") != 0 &&
strcmp(s_entry->name, "..") != 0) {
struct directory *child;
/*
* XXX It seems that the tree that has been
* XXX read from the previous session does not
* XXX carry whole_name entries. We provide a
* XXX hack in
* XXX multi.c:find_or_create_directory()
* XXX that should be removed when a
* XXX reasonable method could be found.
*/
child = find_or_create_directory(this_dir,
s_entry->whole_name,
s_entry, 1);
dflag = merge_previous_session(child,
&odpnt->isorec,
NULL, reloc_old_root);
if (dflag == -1) {
return (-1);
}
free(odpnt);
odpnt = NULL;
}
}
if (odpnt) {
free(odpnt);
odpnt = NULL;
}
/*
* Skip other directory entries for multi-extent files
*/
if (s_entry->de_flags & MULTI_EXTENT) {
struct directory_entry *s_e;
for (s_e = s_entry->mxroot;
s_e && s_e->mxroot == s_entry->mxroot;
s_e = s_e->next) {
s_entry = s_e;
;
}
}
}
if (!reloc_old_root) {
/*
* Whatever is left over, are things which are no longer in the tree on
* disk. We need to also merge these into the tree.
*/
merge_remaining_entries(this_dir, orig_contents, n_orig);
}
free_mdinfo(orig_contents, n_orig);
return (1);
}
/*
* This code deals with relocated directories which may exist
* in the previous session.
*/
struct dir_extent_link {
unsigned int extent;
struct directory_entry *de;
struct dir_extent_link *next;
};
static struct dir_extent_link *cl_dirs = NULL;
static struct dir_extent_link *re_dirs = NULL;
LOCAL void
check_rr_relocation(de)
struct directory_entry *de;
{
unsigned char sector[SECTOR_SIZE];
unsigned char *pnt = de->rr_attributes;
int len = de->rr_attr_size;
UInt32_t cont_extent = 0,
cont_offset = 0,
cont_size = 0;
pnt = parse_xa(pnt, &len, /* dpnt */ 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]);
break;
}
if (strncmp((char *)pnt, "CL", 2) == 0) {
struct dir_extent_link *dlink = e_malloc(sizeof (*dlink));
dlink->extent = get_733(pnt + 4);
dlink->de = de;
dlink->next = cl_dirs;
cl_dirs = dlink;
} else if (strncmp((char *)pnt, "RE", 2) == 0) {
struct dir_extent_link *dlink = e_malloc(sizeof (*dlink));
dlink->extent = de->starting_block;
dlink->de = de;
dlink->next = re_dirs;
re_dirs = dlink;
} else if (strncmp((char *)pnt, "CE", 2) == 0) {
cont_extent = get_733(pnt + 4);
cont_offset = get_733(pnt + 12);
cont_size = get_733(pnt + 20);
} else if (strncmp((char *)pnt, "ST", 2) == 0) {
len = pnt[2];
}
len -= pnt[2];
pnt += pnt[2];
if (len <= 3 && cont_extent) {
/* ??? What if cont_offset+cont_size > SECTOR_SIZE */
readsecs(cont_extent, sector, 1);
pnt = sector + cont_offset;
len = cont_size;
cont_extent = cont_offset = cont_size = 0;
}
}
}
void
match_cl_re_entries()
{
struct dir_extent_link *re = re_dirs;
/* for each relocated directory */
for (; re; re = re->next) {
struct dir_extent_link *cl = cl_dirs;
for (; cl; cl = cl->next) {
/* find a place where it was relocated from */
if (cl->extent == re->extent) {
/* set link to that place */
re->de->parent_rec = cl->de;
re->de->filedir = cl->de->filedir;
/*
* see if it is in rr_moved
*/
if (reloc_dir != NULL) {
struct directory_entry *rr_moved_e = reloc_dir->contents;
for (; rr_moved_e; rr_moved_e = rr_moved_e->next) {
/* yes it is */
if (re->de == rr_moved_e) {
/* forget it */
re->de = NULL;
}
}
}
break;
}
}
}
}
void
finish_cl_pl_for_prev_session()
{
struct dir_extent_link *re = re_dirs;
/* for those that were relocated, but NOT to rr_moved */
re = re_dirs;
for (; re; re = re->next) {
if (re->de != NULL) {
/*
* here we have hypothetical case when previous session
* was not created by mkisofs and contains relocations
*/
struct directory_entry *s_entry = re->de;
struct directory_entry *s_entry1;
struct directory *d_entry = reloc_dir->subdir;
/* do the same as finish_cl_pl_entries */
if (s_entry->de_flags & INHIBIT_ISO9660_ENTRY) {
continue;
}
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;
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;
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);
}
}
}
/* free memory */
re = re_dirs;
while (re) {
struct dir_extent_link *next = re->next;
free(re);
re = next;
}
re = cl_dirs;
while (re) {
struct dir_extent_link *next = re->next;
free(re);
re = next;
}
}
Reference in New Issue Copy Permalink