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