Annotation of sys/isofs/cd9660/cd9660_rrip.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: cd9660_rrip.c,v 1.9 2007/02/14 00:53:48 jsg Exp $ */
! 2: /* $NetBSD: cd9660_rrip.c,v 1.17 1997/01/24 00:27:32 cgd Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 1993, 1994
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley
! 9: * by Pace Willisson (pace@blitz.com). The Rock Ridge Extension
! 10: * Support code is derived from software contributed to Berkeley
! 11: * by Atsushi Murai (amurai@spec.co.jp).
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: * @(#)cd9660_rrip.c 8.6 (Berkeley) 12/5/94
! 38: */
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/namei.h>
! 43: #include <sys/buf.h>
! 44: #include <sys/file.h>
! 45: #include <sys/vnode.h>
! 46: #include <sys/mount.h>
! 47: #include <sys/kernel.h>
! 48: #include <sys/stat.h>
! 49: #include <sys/types.h>
! 50:
! 51: #include <sys/time.h>
! 52:
! 53: #include <isofs/cd9660/iso.h>
! 54: #include <isofs/cd9660/cd9660_extern.h>
! 55: #include <isofs/cd9660/cd9660_node.h>
! 56: #include <isofs/cd9660/cd9660_rrip.h>
! 57: #include <isofs/cd9660/iso_rrip.h>
! 58:
! 59: typedef struct {
! 60: char type[2];
! 61: int (*func)(void *, ISO_RRIP_ANALYZE *);
! 62: void (*func2)(void *, ISO_RRIP_ANALYZE *);
! 63: int result;
! 64: } RRIP_TABLE;
! 65:
! 66: static int cd9660_rrip_attr(void *, ISO_RRIP_ANALYZE *);
! 67: static void cd9660_rrip_defattr(void *, ISO_RRIP_ANALYZE *);
! 68: static int cd9660_rrip_slink(void *, ISO_RRIP_ANALYZE *);
! 69: static int cd9660_rrip_altname(void *, ISO_RRIP_ANALYZE *);
! 70: static void cd9660_rrip_defname(void *, ISO_RRIP_ANALYZE *);
! 71: static int cd9660_rrip_pclink(void *, ISO_RRIP_ANALYZE *);
! 72: static int cd9660_rrip_reldir(void *, ISO_RRIP_ANALYZE *);
! 73: static int cd9660_rrip_tstamp(void *, ISO_RRIP_ANALYZE *);
! 74: static void cd9660_rrip_deftstamp(void *, ISO_RRIP_ANALYZE *);
! 75: static int cd9660_rrip_device(void *, ISO_RRIP_ANALYZE *);
! 76: static int cd9660_rrip_idflag(void *, ISO_RRIP_ANALYZE *);
! 77: static int cd9660_rrip_cont(void *, ISO_RRIP_ANALYZE *);
! 78: static int cd9660_rrip_stop(void *, ISO_RRIP_ANALYZE *);
! 79: static int cd9660_rrip_extref(void *, ISO_RRIP_ANALYZE *);
! 80: static int cd9660_rrip_loop(struct iso_directory_record *,
! 81: ISO_RRIP_ANALYZE *, RRIP_TABLE *);
! 82: /*
! 83: * POSIX file attribute
! 84: */
! 85: static int
! 86: cd9660_rrip_attr(v, ana)
! 87: void *v;
! 88: ISO_RRIP_ANALYZE *ana;
! 89: {
! 90: ISO_RRIP_ATTR *p = v;
! 91:
! 92: ana->inop->inode.iso_mode = isonum_733(p->mode);
! 93: ana->inop->inode.iso_uid = isonum_733(p->uid);
! 94: ana->inop->inode.iso_gid = isonum_733(p->gid);
! 95: ana->inop->inode.iso_links = isonum_733(p->links);
! 96: ana->fields &= ~ISO_SUSP_ATTR;
! 97: return (ISO_SUSP_ATTR);
! 98: }
! 99:
! 100: static void
! 101: cd9660_rrip_defattr(v, ana)
! 102: void *v;
! 103: ISO_RRIP_ANALYZE *ana;
! 104: {
! 105: struct iso_directory_record *isodir = v;
! 106:
! 107: /* But this is a required field! */
! 108: printf("RRIP without PX field?\n");
! 109: cd9660_defattr(isodir, ana->inop, NULL);
! 110: }
! 111:
! 112: /*
! 113: * Symbolic Links
! 114: */
! 115: static int
! 116: cd9660_rrip_slink(v, ana)
! 117: void *v;
! 118: ISO_RRIP_ANALYZE *ana;
! 119: {
! 120: ISO_RRIP_SLINK *p = v;
! 121: register ISO_RRIP_SLINK_COMPONENT *pcomp;
! 122: register ISO_RRIP_SLINK_COMPONENT *pcompe;
! 123: int len, wlen, cont;
! 124: char *outbuf, *inbuf;
! 125:
! 126: pcomp = (ISO_RRIP_SLINK_COMPONENT *)p->component;
! 127: pcompe =
! 128: (ISO_RRIP_SLINK_COMPONENT *)((char *)p + isonum_711(p->h.length));
! 129: len = *ana->outlen;
! 130: outbuf = ana->outbuf;
! 131: cont = ana->cont;
! 132:
! 133: /*
! 134: * Gathering a Symbolic name from each component with path
! 135: */
! 136: for (; pcomp < pcompe;
! 137: pcomp = (ISO_RRIP_SLINK_COMPONENT *)
! 138: ((char *)pcomp + ISO_RRIP_SLSIZ + isonum_711(pcomp->clen))) {
! 139:
! 140: if (!cont) {
! 141: if (len < ana->maxlen) {
! 142: len++;
! 143: *outbuf++ = '/';
! 144: }
! 145: }
! 146: cont = 0;
! 147:
! 148: inbuf = "..";
! 149: wlen = 0;
! 150:
! 151: switch (*pcomp->cflag) {
! 152:
! 153: case ISO_SUSP_CFLAG_CURRENT:
! 154: /* Inserting Current */
! 155: wlen = 1;
! 156: break;
! 157:
! 158: case ISO_SUSP_CFLAG_PARENT:
! 159: /* Inserting Parent */
! 160: wlen = 2;
! 161: break;
! 162:
! 163: case ISO_SUSP_CFLAG_ROOT:
! 164: /* Inserting slash for ROOT */
! 165: /* start over from beginning(?) */
! 166: outbuf -= len;
! 167: len = 0;
! 168: break;
! 169:
! 170: case ISO_SUSP_CFLAG_VOLROOT:
! 171: /* Inserting a mount point i.e. "/cdrom" */
! 172: /* same as above */
! 173: outbuf -= len;
! 174: len = 0;
! 175: inbuf = ana->imp->im_mountp->mnt_stat.f_mntonname;
! 176: wlen = strlen(inbuf);
! 177: break;
! 178:
! 179: case ISO_SUSP_CFLAG_HOST:
! 180: /* Inserting hostname i.e. "kurt.tools.de" */
! 181: inbuf = hostname;
! 182: wlen = hostnamelen;
! 183: break;
! 184:
! 185: case ISO_SUSP_CFLAG_CONTINUE:
! 186: cont = 1;
! 187: /* FALLTHROUGH */
! 188: case 0:
! 189: /* Inserting component */
! 190: wlen = isonum_711(pcomp->clen);
! 191: inbuf = pcomp->name;
! 192: break;
! 193: default:
! 194: printf("RRIP with incorrect flags?");
! 195: wlen = ana->maxlen + 1;
! 196: break;
! 197: }
! 198:
! 199: if (len + wlen > ana->maxlen) {
! 200: /* indicate error to caller */
! 201: ana->cont = 1;
! 202: ana->fields = 0;
! 203: ana->outbuf -= *ana->outlen;
! 204: *ana->outlen = 0;
! 205: return (0);
! 206: }
! 207:
! 208: bcopy(inbuf, outbuf, wlen);
! 209: outbuf += wlen;
! 210: len += wlen;
! 211: }
! 212: ana->outbuf = outbuf;
! 213: *ana->outlen = len;
! 214: ana->cont = cont;
! 215:
! 216: if (!isonum_711(p->flags)) {
! 217: ana->fields &= ~ISO_SUSP_SLINK;
! 218: return (ISO_SUSP_SLINK);
! 219: }
! 220: return (0);
! 221: }
! 222:
! 223: /*
! 224: * Alternate name
! 225: */
! 226: static int
! 227: cd9660_rrip_altname(v, ana)
! 228: void *v;
! 229: ISO_RRIP_ANALYZE *ana;
! 230: {
! 231: ISO_RRIP_ALTNAME *p = v;
! 232: char *inbuf;
! 233: int wlen;
! 234: int cont;
! 235:
! 236: inbuf = "..";
! 237: wlen = 0;
! 238: cont = 0;
! 239:
! 240: switch (*p->flags) {
! 241: case ISO_SUSP_CFLAG_CURRENT:
! 242: /* Inserting Current */
! 243: wlen = 1;
! 244: break;
! 245:
! 246: case ISO_SUSP_CFLAG_PARENT:
! 247: /* Inserting Parent */
! 248: wlen = 2;
! 249: break;
! 250:
! 251: case ISO_SUSP_CFLAG_HOST:
! 252: /* Inserting hostname i.e. "kurt.tools.de" */
! 253: inbuf = hostname;
! 254: wlen = hostnamelen;
! 255: break;
! 256:
! 257: case ISO_SUSP_CFLAG_CONTINUE:
! 258: cont = 1;
! 259: /* FALLTHROUGH */
! 260: case 0:
! 261: /* Inserting component */
! 262: wlen = isonum_711(p->h.length) - 5;
! 263: inbuf = (char *)p + 5;
! 264: break;
! 265:
! 266: default:
! 267: printf("RRIP with incorrect NM flags?\n");
! 268: wlen = ana->maxlen + 1;
! 269: break;
! 270: }
! 271:
! 272: if ((*ana->outlen += wlen) > ana->maxlen) {
! 273: /* treat as no name field */
! 274: ana->fields &= ~ISO_SUSP_ALTNAME;
! 275: ana->outbuf -= *ana->outlen - wlen;
! 276: *ana->outlen = 0;
! 277: return (0);
! 278: }
! 279:
! 280: bcopy(inbuf, ana->outbuf, wlen);
! 281: ana->outbuf += wlen;
! 282:
! 283: if (!cont) {
! 284: ana->fields &= ~ISO_SUSP_ALTNAME;
! 285: return (ISO_SUSP_ALTNAME);
! 286: }
! 287: return (0);
! 288: }
! 289:
! 290: static void
! 291: cd9660_rrip_defname(v, ana)
! 292: void *v;
! 293: ISO_RRIP_ANALYZE *ana;
! 294: {
! 295: struct iso_directory_record *isodir = v;
! 296:
! 297: strlcpy(ana->outbuf, "..", ana->maxlen - *ana->outlen);
! 298: switch (*isodir->name) {
! 299: default:
! 300: isofntrans(isodir->name, isonum_711(isodir->name_len),
! 301: ana->outbuf, ana->outlen, 1,
! 302: isonum_711(isodir->flags) & 4, ana->imp->joliet_level);
! 303: break;
! 304: case 0:
! 305: *ana->outlen = 1;
! 306: break;
! 307: case 1:
! 308: *ana->outlen = 2;
! 309: break;
! 310: }
! 311: }
! 312:
! 313: /*
! 314: * Parent or Child Link
! 315: */
! 316: static int
! 317: cd9660_rrip_pclink(v, ana)
! 318: void *v;
! 319: ISO_RRIP_ANALYZE *ana;
! 320: {
! 321: ISO_RRIP_CLINK *p = v;
! 322:
! 323: *ana->inump = isonum_733(p->dir_loc) << ana->imp->im_bshift;
! 324: ana->fields &= ~(ISO_SUSP_CLINK | ISO_SUSP_PLINK);
! 325: return (*p->h.type == 'C' ? ISO_SUSP_CLINK : ISO_SUSP_PLINK);
! 326: }
! 327:
! 328: /*
! 329: * Relocated directory
! 330: */
! 331: /*ARGSUSED*/
! 332: static int
! 333: cd9660_rrip_reldir(v, ana)
! 334: void *v;
! 335: ISO_RRIP_ANALYZE *ana;
! 336: {
! 337: /* special hack to make caller aware of RE field */
! 338: *ana->outlen = 0;
! 339: ana->fields = 0;
! 340: return (ISO_SUSP_RELDIR | ISO_SUSP_ALTNAME | ISO_SUSP_CLINK |
! 341: ISO_SUSP_PLINK);
! 342: }
! 343:
! 344: static int
! 345: cd9660_rrip_tstamp(v, ana)
! 346: void *v;
! 347: ISO_RRIP_ANALYZE *ana;
! 348: {
! 349: ISO_RRIP_TSTAMP *p = v;
! 350: u_char *ptime;
! 351:
! 352: ptime = p->time;
! 353:
! 354: /* Check a format of time stamp (7bytes/17bytes) */
! 355: if (!(*p->flags & ISO_SUSP_TSTAMP_FORM17)) {
! 356: if (*p->flags & ISO_SUSP_TSTAMP_CREAT)
! 357: ptime += 7;
! 358:
! 359: if (*p->flags & ISO_SUSP_TSTAMP_MODIFY) {
! 360: cd9660_tstamp_conv7(ptime,
! 361: &ana->inop->inode.iso_mtime);
! 362: ptime += 7;
! 363: } else
! 364: bzero(&ana->inop->inode.iso_mtime,
! 365: sizeof(struct timespec));
! 366:
! 367: if (*p->flags & ISO_SUSP_TSTAMP_ACCESS) {
! 368: cd9660_tstamp_conv7(ptime,
! 369: &ana->inop->inode.iso_atime);
! 370: ptime += 7;
! 371: } else
! 372: ana->inop->inode.iso_atime =
! 373: ana->inop->inode.iso_mtime;
! 374:
! 375: if (*p->flags & ISO_SUSP_TSTAMP_ATTR)
! 376: cd9660_tstamp_conv7(ptime,
! 377: &ana->inop->inode.iso_ctime);
! 378: else
! 379: ana->inop->inode.iso_ctime =
! 380: ana->inop->inode.iso_mtime;
! 381:
! 382: } else {
! 383: if (*p->flags & ISO_SUSP_TSTAMP_CREAT)
! 384: ptime += 17;
! 385:
! 386: if (*p->flags & ISO_SUSP_TSTAMP_MODIFY) {
! 387: cd9660_tstamp_conv17(ptime,
! 388: &ana->inop->inode.iso_mtime);
! 389: ptime += 17;
! 390: } else
! 391: bzero(&ana->inop->inode.iso_mtime,
! 392: sizeof(struct timespec));
! 393:
! 394: if (*p->flags & ISO_SUSP_TSTAMP_ACCESS) {
! 395: cd9660_tstamp_conv17(ptime,
! 396: &ana->inop->inode.iso_atime);
! 397: ptime += 17;
! 398: } else
! 399: ana->inop->inode.iso_atime =
! 400: ana->inop->inode.iso_mtime;
! 401:
! 402: if (*p->flags & ISO_SUSP_TSTAMP_ATTR)
! 403: cd9660_tstamp_conv17(ptime,
! 404: &ana->inop->inode.iso_ctime);
! 405: else
! 406: ana->inop->inode.iso_ctime =
! 407: ana->inop->inode.iso_mtime;
! 408:
! 409: }
! 410: ana->fields &= ~ISO_SUSP_TSTAMP;
! 411: return (ISO_SUSP_TSTAMP);
! 412: }
! 413:
! 414: static void
! 415: cd9660_rrip_deftstamp(v, ana)
! 416: void *v;
! 417: ISO_RRIP_ANALYZE *ana;
! 418: {
! 419: struct iso_directory_record *isodir = v;
! 420:
! 421: cd9660_deftstamp(isodir, ana->inop, NULL);
! 422: }
! 423:
! 424: /*
! 425: * POSIX device modes
! 426: */
! 427: static int
! 428: cd9660_rrip_device(v, ana)
! 429: void *v;
! 430: ISO_RRIP_ANALYZE *ana;
! 431: {
! 432: ISO_RRIP_DEVICE *p = v;
! 433: u_int high, low;
! 434:
! 435: high = isonum_733(p->dev_t_high);
! 436: low = isonum_733(p->dev_t_low);
! 437:
! 438: if (high == 0)
! 439: ana->inop->inode.iso_rdev = makedev(major(low), minor(low));
! 440: else
! 441: ana->inop->inode.iso_rdev = makedev(high, minor(low));
! 442: ana->fields &= ~ISO_SUSP_DEVICE;
! 443: return (ISO_SUSP_DEVICE);
! 444: }
! 445:
! 446: /*
! 447: * Flag indicating
! 448: */
! 449: static int
! 450: cd9660_rrip_idflag(v, ana)
! 451: void *v;
! 452: ISO_RRIP_ANALYZE *ana;
! 453: {
! 454: ISO_RRIP_IDFLAG *p = v;
! 455:
! 456: /* don't touch high bits */
! 457: ana->fields &= isonum_711(p->flags) | ~0xff;
! 458: /* special handling of RE field */
! 459: if (ana->fields & ISO_SUSP_RELDIR)
! 460: return (cd9660_rrip_reldir(p, ana));
! 461:
! 462: return (ISO_SUSP_IDFLAG);
! 463: }
! 464:
! 465: /*
! 466: * Continuation pointer
! 467: */
! 468: static int
! 469: cd9660_rrip_cont(v, ana)
! 470: void *v;
! 471: ISO_RRIP_ANALYZE *ana;
! 472: {
! 473: ISO_RRIP_CONT *p = v;
! 474:
! 475: ana->iso_ce_blk = isonum_733(p->location);
! 476: ana->iso_ce_off = isonum_733(p->offset);
! 477: ana->iso_ce_len = isonum_733(p->length);
! 478: return (ISO_SUSP_CONT);
! 479: }
! 480:
! 481: /*
! 482: * System Use end
! 483: */
! 484: static int
! 485: cd9660_rrip_stop(v, ana)
! 486: void *v;
! 487: ISO_RRIP_ANALYZE *ana;
! 488: {
! 489: return (ISO_SUSP_STOP);
! 490: }
! 491:
! 492: /*
! 493: * Extension reference
! 494: */
! 495: static int
! 496: cd9660_rrip_extref(v, ana)
! 497: void *v;
! 498: ISO_RRIP_ANALYZE *ana;
! 499: {
! 500: ISO_RRIP_EXTREF *p = v;
! 501:
! 502: if (isonum_711(p->version) != 1)
! 503: return (0);
! 504: if (isonum_711(p->len_id) != 9 &&
! 505: isonum_711(p->len_id) != 10)
! 506: return (0);
! 507: if (isonum_711(p->len_id) == 9 &&
! 508: bcmp((char *)p + 8, "IEEE_1282", 9))
! 509: return (0);
! 510: if (isonum_711(p->len_id) == 10 &&
! 511: bcmp((char *)p + 8, "IEEE_P1282", 10) &&
! 512: bcmp((char *)p + 8, "RRIP_1991A", 10))
! 513: return (0);
! 514: ana->fields &= ~ISO_SUSP_EXTREF;
! 515: return (ISO_SUSP_EXTREF);
! 516: }
! 517:
! 518:
! 519: static int
! 520: cd9660_rrip_loop(isodir, ana, table)
! 521: struct iso_directory_record *isodir;
! 522: ISO_RRIP_ANALYZE *ana;
! 523: RRIP_TABLE *table;
! 524: {
! 525: register RRIP_TABLE *ptable;
! 526: register ISO_SUSP_HEADER *phead;
! 527: register ISO_SUSP_HEADER *pend;
! 528: struct buf *bp = NULL;
! 529: char *pwhead;
! 530: u_char c;
! 531: int result;
! 532:
! 533: /*
! 534: * Note: If name length is odd,
! 535: * it will be padded by 1 byte after the name
! 536: */
! 537: pwhead = isodir->name + isonum_711(isodir->name_len);
! 538: if (!(isonum_711(isodir->name_len) & 1))
! 539: pwhead++;
! 540: isochar(isodir->name, pwhead, ana->imp->joliet_level, &c);
! 541:
! 542: /* If it's not the '.' entry of the root dir obey SP field */
! 543: if (c != 0 || isonum_733(isodir->extent) != ana->imp->root_extent)
! 544: pwhead += ana->imp->rr_skip;
! 545: else
! 546: pwhead += ana->imp->rr_skip0;
! 547:
! 548: phead = (ISO_SUSP_HEADER *)pwhead;
! 549: pend =
! 550: (ISO_SUSP_HEADER *)((char *)isodir + isonum_711(isodir->length));
! 551:
! 552: result = 0;
! 553: while (1) {
! 554: ana->iso_ce_len = 0;
! 555: /*
! 556: * Note: "pend" should be more than one SUSP header
! 557: */
! 558: while (pend >= phead + 1) {
! 559: if (isonum_711(phead->version) == 1) {
! 560: for (ptable = table; ptable->func; ptable++) {
! 561: if (*phead->type == *ptable->type &&
! 562: phead->type[1] == ptable->type[1])
! 563: {
! 564: result |=
! 565: ptable->func(phead, ana);
! 566: break;
! 567: }
! 568: }
! 569: if (!ana->fields)
! 570: break;
! 571: }
! 572: if (result & ISO_SUSP_STOP) {
! 573: result &= ~ISO_SUSP_STOP;
! 574: break;
! 575: }
! 576: /* plausibility check */
! 577: if (isonum_711(phead->length) < sizeof(*phead))
! 578: break;
! 579: /*
! 580: * move to next SUSP
! 581: * Hopefully this works with newer versions, too
! 582: */
! 583: phead = (ISO_SUSP_HEADER *)
! 584: ((char *)phead + isonum_711(phead->length));
! 585: }
! 586:
! 587: if (ana->fields && ana->iso_ce_len) {
! 588: if (ana->iso_ce_blk >= ana->imp->volume_space_size ||
! 589: ana->iso_ce_off + ana->iso_ce_len >
! 590: ana->imp->logical_block_size ||
! 591: bread(ana->imp->im_devvp, ana->iso_ce_blk <<
! 592: (ana->imp->im_bshift - DEV_BSHIFT),
! 593: ana->imp->logical_block_size, NOCRED, &bp))
! 594: /* what to do now? */
! 595: break;
! 596: phead =
! 597: (ISO_SUSP_HEADER *)(bp->b_data + ana->iso_ce_off);
! 598: pend = (ISO_SUSP_HEADER *)
! 599: ((char *)phead + ana->iso_ce_len);
! 600: } else
! 601: break;
! 602: }
! 603: if (bp)
! 604: brelse(bp);
! 605: /*
! 606: * If we don't find the Basic SUSP stuffs, just set default value
! 607: * (attribute/time stamp)
! 608: */
! 609: for (ptable = table; ptable->func2; ptable++)
! 610: if (!(ptable->result & result))
! 611: ptable->func2(isodir, ana);
! 612:
! 613: return (result);
! 614: }
! 615:
! 616: /*
! 617: * Get Attributes.
! 618: */
! 619: static RRIP_TABLE rrip_table_analyze[] = {
! 620: { "PX", cd9660_rrip_attr, cd9660_rrip_defattr,
! 621: ISO_SUSP_ATTR },
! 622: { "TF", cd9660_rrip_tstamp, cd9660_rrip_deftstamp,
! 623: ISO_SUSP_TSTAMP },
! 624: { "PN", cd9660_rrip_device, 0,
! 625: ISO_SUSP_DEVICE },
! 626: { "RR", cd9660_rrip_idflag, 0,
! 627: ISO_SUSP_IDFLAG },
! 628: { "CE", cd9660_rrip_cont, 0,
! 629: ISO_SUSP_CONT },
! 630: { "ST", cd9660_rrip_stop, 0,
! 631: ISO_SUSP_STOP },
! 632: { "", 0, 0,
! 633: 0 }
! 634: };
! 635:
! 636: int
! 637: cd9660_rrip_analyze(isodir, inop, imp)
! 638: struct iso_directory_record *isodir;
! 639: struct iso_node *inop;
! 640: struct iso_mnt *imp;
! 641: {
! 642: ISO_RRIP_ANALYZE analyze;
! 643:
! 644: analyze.inop = inop;
! 645: analyze.imp = imp;
! 646: analyze.fields = ISO_SUSP_ATTR | ISO_SUSP_TSTAMP | ISO_SUSP_DEVICE;
! 647:
! 648: return (cd9660_rrip_loop(isodir, &analyze, rrip_table_analyze));
! 649: }
! 650:
! 651: /*
! 652: * Get Alternate Name.
! 653: */
! 654: static RRIP_TABLE rrip_table_getname[] = {
! 655: { "NM", cd9660_rrip_altname, cd9660_rrip_defname,
! 656: ISO_SUSP_ALTNAME },
! 657: { "CL", cd9660_rrip_pclink, 0,
! 658: ISO_SUSP_CLINK|ISO_SUSP_PLINK },
! 659: { "PL", cd9660_rrip_pclink, 0,
! 660: ISO_SUSP_CLINK|ISO_SUSP_PLINK },
! 661: { "RE", cd9660_rrip_reldir, 0,
! 662: ISO_SUSP_RELDIR },
! 663: { "RR", cd9660_rrip_idflag, 0,
! 664: ISO_SUSP_IDFLAG },
! 665: { "CE", cd9660_rrip_cont, 0,
! 666: ISO_SUSP_CONT },
! 667: { "ST", cd9660_rrip_stop, 0,
! 668: ISO_SUSP_STOP },
! 669: { "", 0, 0,
! 670: 0 }
! 671: };
! 672:
! 673: int
! 674: cd9660_rrip_getname(isodir, outbuf, outlen, inump, imp)
! 675: struct iso_directory_record *isodir;
! 676: char *outbuf;
! 677: u_short *outlen;
! 678: ino_t *inump;
! 679: struct iso_mnt *imp;
! 680: {
! 681: ISO_RRIP_ANALYZE analyze;
! 682: RRIP_TABLE *tab;
! 683: u_char c;
! 684:
! 685: analyze.outbuf = outbuf;
! 686: analyze.outlen = outlen;
! 687: analyze.maxlen = NAME_MAX;
! 688: analyze.inump = inump;
! 689: analyze.imp = imp;
! 690: analyze.fields = ISO_SUSP_ALTNAME | ISO_SUSP_RELDIR | ISO_SUSP_CLINK |
! 691: ISO_SUSP_PLINK;
! 692: *outlen = 0;
! 693:
! 694: isochar(isodir->name, isodir->name + isonum_711(isodir->name_len),
! 695: imp->joliet_level, &c);
! 696: tab = rrip_table_getname;
! 697: if (c == 0 || c == 1) {
! 698: cd9660_rrip_defname(isodir, &analyze);
! 699:
! 700: analyze.fields &= ~ISO_SUSP_ALTNAME;
! 701: tab++;
! 702: }
! 703:
! 704: return (cd9660_rrip_loop(isodir, &analyze, tab));
! 705: }
! 706:
! 707: /*
! 708: * Get Symbolic Link.
! 709: */
! 710: static RRIP_TABLE rrip_table_getsymname[] = {
! 711: { "SL", cd9660_rrip_slink, 0, ISO_SUSP_SLINK },
! 712: { "RR", cd9660_rrip_idflag, 0, ISO_SUSP_IDFLAG },
! 713: { "CE", cd9660_rrip_cont, 0, ISO_SUSP_CONT },
! 714: { "ST", cd9660_rrip_stop, 0, ISO_SUSP_STOP },
! 715: { "", 0, 0, 0 }
! 716: };
! 717:
! 718: int
! 719: cd9660_rrip_getsymname(isodir, outbuf, outlen, imp)
! 720: struct iso_directory_record *isodir;
! 721: char *outbuf;
! 722: u_short *outlen;
! 723: struct iso_mnt *imp;
! 724: {
! 725: ISO_RRIP_ANALYZE analyze;
! 726:
! 727: analyze.outbuf = outbuf;
! 728: analyze.outlen = outlen;
! 729: *outlen = 0;
! 730: analyze.maxlen = MAXPATHLEN;
! 731: analyze.cont = 1; /* don't start with a slash */
! 732: analyze.imp = imp;
! 733: analyze.fields = ISO_SUSP_SLINK;
! 734:
! 735: return (cd9660_rrip_loop(isodir, &analyze, rrip_table_getsymname) &
! 736: ISO_SUSP_SLINK);
! 737: }
! 738:
! 739: static RRIP_TABLE rrip_table_extref[] = {
! 740: { "ER", cd9660_rrip_extref, 0, ISO_SUSP_EXTREF },
! 741: { "CE", cd9660_rrip_cont, 0, ISO_SUSP_CONT },
! 742: { "ST", cd9660_rrip_stop, 0, ISO_SUSP_STOP },
! 743: { "", 0, 0, 0 }
! 744: };
! 745:
! 746: /*
! 747: * Check for Rock Ridge Extension and return offset of its fields.
! 748: * Note: We insist on the ER field.
! 749: */
! 750: int
! 751: cd9660_rrip_offset(isodir, imp)
! 752: struct iso_directory_record *isodir;
! 753: struct iso_mnt *imp;
! 754: {
! 755: ISO_RRIP_OFFSET *p;
! 756: ISO_RRIP_ANALYZE analyze;
! 757:
! 758: imp->rr_skip0 = 0;
! 759: p = (ISO_RRIP_OFFSET *)(isodir->name + 1);
! 760: if (bcmp(p, "SP\7\1\276\357", 6)) {
! 761: /* Maybe, it's a CDROM XA disc? */
! 762: imp->rr_skip0 = 15;
! 763: p = (ISO_RRIP_OFFSET *)((char *)p + 15);
! 764: if (bcmp(p, "SP\7\1\276\357", 6))
! 765: return (-1);
! 766: }
! 767:
! 768: analyze.imp = imp;
! 769: analyze.fields = ISO_SUSP_EXTREF;
! 770: if (!(cd9660_rrip_loop(isodir, &analyze, rrip_table_extref) &
! 771: ISO_SUSP_EXTREF))
! 772: return (-1);
! 773:
! 774: return (isonum_711(p->skip));
! 775: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cd9660_rrip.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / isofs / cd9660