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