1 /* $NetBSD: cd9660.c,v 1.5 1997/06/26 19:11:33 drochner Exp $ */
2
3 /*
4 * Copyright (C) 1996 Wolfgang Solfrank.
5 * Copyright (C) 1996 TooLs GmbH.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by TooLs GmbH.
19 * 4. The name of TooLs GmbH may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
27 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
28 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
29 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
30 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
31 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #include <sys/cdefs.h>
35
36 /*
37 * Stand-alone ISO9660 file reading package.
38 *
39 * Note: This doesn't support Rock Ridge extensions, extended attributes,
40 * blocksizes other than 2048 bytes, multi-extent files, etc.
41 */
42 #include <sys/param.h>
43 #include <string.h>
44 #include <sys/dirent.h>
45 #include <isofs/cd9660/iso.h>
46 #include <isofs/cd9660/cd9660_rrip.h>
47
48 #include "stand.h"
49
50 #define SUSP_CONTINUATION "CE"
51 #define SUSP_PRESENT "SP"
52 #define SUSP_STOP "ST"
53 #define SUSP_EXTREF "ER"
54 #define RRIP_NAME "NM"
55
56 typedef struct {
57 ISO_SUSP_HEADER h;
58 u_char signature [ISODCL ( 5, 6)];
59 u_char len_skp [ISODCL ( 7, 7)]; /* 711 */
60 } ISO_SUSP_PRESENT;
61
62 static int buf_read_file(struct open_file *f, char **buf_p,
63 size_t *size_p);
64 static int cd9660_open(const char *path, struct open_file *f);
65 static int cd9660_close(struct open_file *f);
66 static int cd9660_read(struct open_file *f, void *buf, size_t size,
67 size_t *resid);
68 static off_t cd9660_seek(struct open_file *f, off_t offset, int where);
69 static int cd9660_stat(struct open_file *f, struct stat *sb);
70 static int cd9660_readdir(struct open_file *f, struct dirent *d);
71 static int dirmatch(struct open_file *f, const char *path,
72 struct iso_directory_record *dp, int use_rrip, int lenskip);
73 static int rrip_check(struct open_file *f, struct iso_directory_record *dp,
74 int *lenskip);
75 static char *rrip_lookup_name(struct open_file *f,
76 struct iso_directory_record *dp, int lenskip, size_t *len);
77 static ISO_SUSP_HEADER *susp_lookup_record(struct open_file *f,
78 const char *identifier, struct iso_directory_record *dp,
79 int lenskip);
80
81 struct fs_ops cd9660_fsops = {
82 "cd9660",
83 cd9660_open,
84 cd9660_close,
85 cd9660_read,
86 null_write,
87 cd9660_seek,
88 cd9660_stat,
89 cd9660_readdir
90 };
91
92 #define F_ISDIR 0x0001 /* Directory */
93 #define F_ROOTDIR 0x0002 /* Root directory */
94 #define F_RR 0x0004 /* Rock Ridge on this volume */
95
96 struct file {
97 int f_flags; /* file flags */
98 off_t f_off; /* Current offset within file */
99 daddr_t f_bno; /* Starting block number */
100 off_t f_size; /* Size of file */
101 daddr_t f_buf_blkno; /* block number of data block */
102 char *f_buf; /* buffer for data block */
103 int f_susp_skip; /* len_skip for SUSP records */
104 };
105
106 struct ptable_ent {
107 char namlen [ISODCL( 1, 1)]; /* 711 */
108 char extlen [ISODCL( 2, 2)]; /* 711 */
109 char block [ISODCL( 3, 6)]; /* 732 */
110 char parent [ISODCL( 7, 8)]; /* 722 */
111 char name [1];
112 };
113 #define PTFIXSZ 8
114 #define PTSIZE(pp) roundup(PTFIXSZ + isonum_711((pp)->namlen), 2)
115
116 #define cdb2devb(bno) ((bno) * ISO_DEFAULT_BLOCK_SIZE / DEV_BSIZE)
117
118 static ISO_SUSP_HEADER *
119 susp_lookup_record(struct open_file *f, const char *identifier,
120 struct iso_directory_record *dp, int lenskip)
121 {
122 static char susp_buffer[ISO_DEFAULT_BLOCK_SIZE];
123 ISO_SUSP_HEADER *sh;
124 ISO_RRIP_CONT *shc;
125 char *p, *end;
126 int error;
127 size_t read;
128
129 p = dp->name + isonum_711(dp->name_len) + lenskip;
130 /* Names of even length have a padding byte after the name. */
131 if ((isonum_711(dp->name_len) & 1) == 0)
132 p++;
133 end = (char *)dp + isonum_711(dp->length);
134 while (p + 3 < end) {
135 sh = (ISO_SUSP_HEADER *)p;
136 if (bcmp(sh->type, identifier, 2) == 0)
137 return (sh);
138 if (bcmp(sh->type, SUSP_STOP, 2) == 0)
139 return (NULL);
140 if (bcmp(sh->type, SUSP_CONTINUATION, 2) == 0) {
141 shc = (ISO_RRIP_CONT *)sh;
142 error = f->f_dev->dv_strategy(f->f_devdata, F_READ,
143 cdb2devb(isonum_733(shc->location)),
144 ISO_DEFAULT_BLOCK_SIZE, susp_buffer, &read);
145
146 /* Bail if it fails. */
147 if (error != 0 || read != ISO_DEFAULT_BLOCK_SIZE)
148 return (NULL);
149 p = susp_buffer + isonum_733(shc->offset);
150 end = p + isonum_733(shc->length);
151 } else {
152 /* Ignore this record and skip to the next. */
153 p += isonum_711(sh->length);
154
155 /* Avoid infinite loops with corrupted file systems */
156 if (isonum_711(sh->length) == 0)
157 return (NULL);
158 }
159 }
160 return (NULL);
161 }
162
163 static char *
164 rrip_lookup_name(struct open_file *f, struct iso_directory_record *dp,
165 int lenskip, size_t *len)
166 {
167 ISO_RRIP_ALTNAME *p;
168
169 if (len == NULL)
170 return (NULL);
171
172 p = (ISO_RRIP_ALTNAME *)susp_lookup_record(f, RRIP_NAME, dp, lenskip);
173 if (p == NULL)
174 return (NULL);
175 switch (*p->flags) {
176 case ISO_SUSP_CFLAG_CURRENT:
177 *len = 1;
178 return (".");
179 case ISO_SUSP_CFLAG_PARENT:
180 *len = 2;
181 return ("..");
182 case 0:
183 *len = isonum_711(p->h.length) - 5;
184 return ((char *)p + 5);
185 default:
186 /*
187 * We don't handle hostnames or continued names as they are
188 * too hard, so just bail and use the default name.
189 */
190 return (NULL);
191 }
192 }
193
194 static int
195 rrip_check(struct open_file *f, struct iso_directory_record *dp, int *lenskip)
196 {
197 ISO_SUSP_PRESENT *sp;
198 ISO_RRIP_EXTREF *er;
199 char *p;
200
201 /* First, see if we can find a SP field. */
202 p = dp->name + isonum_711(dp->name_len);
203 if (p > (char *)dp + isonum_711(dp->length))
204 return (0);
205 sp = (ISO_SUSP_PRESENT *)p;
206 if (bcmp(sp->h.type, SUSP_PRESENT, 2) != 0)
207 return (0);
208 if (isonum_711(sp->h.length) != sizeof(ISO_SUSP_PRESENT))
209 return (0);
210 if (sp->signature[0] != 0xbe || sp->signature[1] != 0xef)
211 return (0);
212 *lenskip = isonum_711(sp->len_skp);
213
214 /*
215 * Now look for an ER field. If RRIP is present, then there must
216 * be at least one of these. It would be more pedantic to walk
217 * through the list of fields looking for a Rock Ridge ER field.
218 */
219 er = (ISO_RRIP_EXTREF *)susp_lookup_record(f, SUSP_EXTREF, dp, 0);
220 if (er == NULL)
221 return (0);
222 return (1);
223 }
224
225 static int
226 dirmatch(struct open_file *f, const char *path, struct iso_directory_record *dp,
227 int use_rrip, int lenskip)
228 {
229 size_t len;
230 char *cp;
231 int i, icase;
232
233 if (use_rrip)
234 cp = rrip_lookup_name(f, dp, lenskip, &len);
235 else
236 cp = NULL;
237 if (cp == NULL) {
238 len = isonum_711(dp->name_len);
239 cp = dp->name;
240 icase = 1;
241 } else
242 icase = 0;
243 for (i = len; --i >= 0; path++, cp++) {
244 if (!*path || *path == '/')
245 break;
246 if (*path == *cp)
247 continue;
248 if (!icase && toupper(*path) == *cp)
249 continue;
250 return 0;
251 }
252 if (*path && *path != '/')
253 return 0;
254 /*
255 * Allow stripping of trailing dots and the version number.
256 * Note that this will find the first instead of the last version
257 * of a file.
258 */
259 if (i >= 0 && (*cp == ';' || *cp == '.')) {
260 /* This is to prevent matching of numeric extensions */
261 if (*cp == '.' && cp[1] != ';')
262 return 0;
263 while (--i >= 0)
264 if (*++cp != ';' && (*cp < '0' || *cp > '9'))
265 return 0;
266 }
267 return 1;
268 }
269
270 static int
271 cd9660_open(const char *path, struct open_file *f)
272 {
273 struct file *fp = NULL;
274 void *buf;
275 struct iso_primary_descriptor *vd;
276 size_t buf_size, read, dsize, off;
277 daddr_t bno, boff;
278 struct iso_directory_record rec;
279 struct iso_directory_record *dp = NULL;
280 int rc, first, use_rrip, lenskip;
281
282 /* First find the volume descriptor */
283 buf = malloc(buf_size = ISO_DEFAULT_BLOCK_SIZE);
284 vd = buf;
285 for (bno = 16;; bno++) {
286 twiddle(1);
287 rc = f->f_dev->dv_strategy(f->f_devdata, F_READ, cdb2devb(bno),
288 ISO_DEFAULT_BLOCK_SIZE, buf, &read);
289 if (rc)
290 goto out;
291 if (read != ISO_DEFAULT_BLOCK_SIZE) {
292 rc = EIO;
293 goto out;
294 }
295 rc = EINVAL;
296 if (bcmp(vd->id, ISO_STANDARD_ID, sizeof vd->id) != 0)
297 goto out;
298 if (isonum_711(vd->type) == ISO_VD_END)
299 goto out;
300 if (isonum_711(vd->type) == ISO_VD_PRIMARY)
301 break;
302 }
303 if (isonum_723(vd->logical_block_size) != ISO_DEFAULT_BLOCK_SIZE)
304 goto out;
305
306 rec = *(struct iso_directory_record *) vd->root_directory_record;
307 if (*path == '/') path++; /* eat leading '/' */
308
309 first = 1;
310 use_rrip = 0;
311 while (*path) {
312 bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
313 dsize = isonum_733(rec.size);
314 off = 0;
315 boff = 0;
316
317 while (off < dsize) {
318 if ((off % ISO_DEFAULT_BLOCK_SIZE) == 0) {
319 twiddle(1);
320 rc = f->f_dev->dv_strategy
321 (f->f_devdata, F_READ,
322 cdb2devb(bno + boff),
323 ISO_DEFAULT_BLOCK_SIZE,
324 buf, &read);
325 if (rc)
326 goto out;
327 if (read != ISO_DEFAULT_BLOCK_SIZE) {
328 rc = EIO;
329 goto out;
330 }
331 boff++;
332 dp = (struct iso_directory_record *) buf;
333 }
334 if (isonum_711(dp->length) == 0) {
335 /* skip to next block, if any */
336 off = boff * ISO_DEFAULT_BLOCK_SIZE;
337 continue;
338 }
339
340 /* See if RRIP is in use. */
341 if (first)
342 use_rrip = rrip_check(f, dp, &lenskip);
343
344 if (dirmatch(f, path, dp, use_rrip,
345 first ? 0 : lenskip)) {
346 first = 0;
347 break;
348 } else
349 first = 0;
350
351 dp = (struct iso_directory_record *)
352 ((char *) dp + isonum_711(dp->length));
353 /* If the new block has zero length, it is padding. */
354 if (isonum_711(dp->length) == 0) {
355 /* Skip to next block, if any. */
356 off = boff * ISO_DEFAULT_BLOCK_SIZE;
357 continue;
358 }
359 off += isonum_711(dp->length);
360 }
361 if (off >= dsize) {
362 rc = ENOENT;
363 goto out;
364 }
365
366 rec = *dp;
367 while (*path && *path != '/') /* look for next component */
368 path++;
369 if (*path) path++; /* skip '/' */
370 }
371
372 /* allocate file system specific data structure */
373 fp = malloc(sizeof(struct file));
374 bzero(fp, sizeof(struct file));
375 f->f_fsdata = (void *)fp;
376
377 if ((isonum_711(rec.flags) & 2) != 0) {
378 fp->f_flags = F_ISDIR;
379 }
380 if (first) {
381 fp->f_flags |= F_ROOTDIR;
382
383 /* Check for Rock Ridge since we didn't in the loop above. */
384 bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
385 twiddle(1);
386 rc = f->f_dev->dv_strategy(f->f_devdata, F_READ, cdb2devb(bno),
387 ISO_DEFAULT_BLOCK_SIZE, buf, &read);
388 if (rc)
389 goto out;
390 if (read != ISO_DEFAULT_BLOCK_SIZE) {
391 rc = EIO;
392 goto out;
393 }
394 dp = (struct iso_directory_record *)buf;
395 use_rrip = rrip_check(f, dp, &lenskip);
396 }
397 if (use_rrip) {
398 fp->f_flags |= F_RR;
399 fp->f_susp_skip = lenskip;
400 }
401 fp->f_off = 0;
402 fp->f_bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
403 fp->f_size = isonum_733(rec.size);
404 free(buf);
405
406 return 0;
407
408 out:
409 if (fp)
410 free(fp);
411 free(buf);
412
413 return rc;
414 }
415
416 static int
417 cd9660_close(struct open_file *f)
418 {
419 struct file *fp = (struct file *)f->f_fsdata;
420
421 f->f_fsdata = NULL;
422 free(fp);
423
424 return 0;
425 }
426
427 static int
428 buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
429 {
430 struct file *fp = (struct file *)f->f_fsdata;
431 daddr_t blkno, blkoff;
432 int rc = 0;
433 size_t read;
434
435 blkno = fp->f_off / ISO_DEFAULT_BLOCK_SIZE + fp->f_bno;
436 blkoff = fp->f_off % ISO_DEFAULT_BLOCK_SIZE;
437
438 if (blkno != fp->f_buf_blkno) {
439 if (fp->f_buf == (char *)0)
440 fp->f_buf = malloc(ISO_DEFAULT_BLOCK_SIZE);
441
442 twiddle(16);
443 rc = f->f_dev->dv_strategy(f->f_devdata, F_READ,
444 cdb2devb(blkno), ISO_DEFAULT_BLOCK_SIZE,
445 fp->f_buf, &read);
446 if (rc)
447 return (rc);
448 if (read != ISO_DEFAULT_BLOCK_SIZE)
449 return (EIO);
450
451 fp->f_buf_blkno = blkno;
452 }
453
454 *buf_p = fp->f_buf + blkoff;
455 *size_p = ISO_DEFAULT_BLOCK_SIZE - blkoff;
456
457 if (*size_p > fp->f_size - fp->f_off)
458 *size_p = fp->f_size - fp->f_off;
459 return (rc);
460 }
461
462 static int
463 cd9660_read(struct open_file *f, void *start, size_t size, size_t *resid)
464 {
465 struct file *fp = (struct file *)f->f_fsdata;
466 char *buf, *addr;
467 size_t buf_size, csize;
468 int rc = 0;
469
470 addr = start;
471 while (size) {
472 if (fp->f_off < 0 || fp->f_off >= fp->f_size)
473 break;
474
475 rc = buf_read_file(f, &buf, &buf_size);
476 if (rc)
477 break;
478
479 csize = size > buf_size ? buf_size : size;
480 bcopy(buf, addr, csize);
481
482 fp->f_off += csize;
483 addr += csize;
484 size -= csize;
485 }
486 if (resid)
487 *resid = size;
488 return (rc);
489 }
490
491 static int
492 cd9660_readdir(struct open_file *f, struct dirent *d)
493 {
494 struct file *fp = (struct file *)f->f_fsdata;
495 struct iso_directory_record *ep;
496 size_t buf_size, reclen, namelen;
497 int error = 0;
498 int lenskip;
499 char *buf, *name;
500
501 again:
502 if (fp->f_off >= fp->f_size)
503 return (ENOENT);
504 error = buf_read_file(f, &buf, &buf_size);
505 if (error)
506 return (error);
507 ep = (struct iso_directory_record *)buf;
508
509 if (isonum_711(ep->length) == 0) {
510 daddr_t blkno;
511
512 /* skip to next block, if any */
513 blkno = fp->f_off / ISO_DEFAULT_BLOCK_SIZE;
514 fp->f_off = (blkno + 1) * ISO_DEFAULT_BLOCK_SIZE;
515 goto again;
516 }
517
518 if (fp->f_flags & F_RR) {
519 if (fp->f_flags & F_ROOTDIR && fp->f_off == 0)
520 lenskip = 0;
521 else
522 lenskip = fp->f_susp_skip;
523 name = rrip_lookup_name(f, ep, lenskip, &namelen);
524 } else
525 name = NULL;
526 if (name == NULL) {
527 namelen = isonum_711(ep->name_len);
528 name = ep->name;
529 if (namelen == 1) {
530 if (ep->name[0] == 0)
531 name = ".";
532 else if (ep->name[0] == 1) {
533 namelen = 2;
534 name = "..";
535 }
536 }
537 }
538 reclen = sizeof(struct dirent) - (MAXNAMLEN+1) + namelen + 1;
539 reclen = (reclen + 3) & ~3;
540
541 d->d_fileno = isonum_733(ep->extent);
542 d->d_reclen = reclen;
543 if (isonum_711(ep->flags) & 2)
544 d->d_type = DT_DIR;
545 else
546 d->d_type = DT_REG;
547 d->d_namlen = namelen;
548
549 bcopy(name, d->d_name, d->d_namlen);
550 d->d_name[d->d_namlen] = 0;
551
552 fp->f_off += isonum_711(ep->length);
553 return (0);
554 }
555
556 static off_t
557 cd9660_seek(struct open_file *f, off_t offset, int where)
558 {
559 struct file *fp = (struct file *)f->f_fsdata;
560
561 switch (where) {
562 case SEEK_SET:
563 fp->f_off = offset;
564 break;
565 case SEEK_CUR:
566 fp->f_off += offset;
567 break;
568 case SEEK_END:
569 fp->f_off = fp->f_size - offset;
570 break;
571 default:
572 return -1;
573 }
574 return fp->f_off;
575 }
576
577 static int
578 cd9660_stat(struct open_file *f, struct stat *sb)
579 {
580 struct file *fp = (struct file *)f->f_fsdata;
581
582 /* only important stuff */
583 sb->st_mode = S_IRUSR | S_IRGRP | S_IROTH;
584 if (fp->f_flags & F_ISDIR)
585 sb->st_mode |= S_IFDIR;
586 else
587 sb->st_mode |= S_IFREG;
588 sb->st_uid = sb->st_gid = 0;
589 sb->st_size = fp->f_size;
590 return 0;
591 }