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