xref: /illumos-gate/usr/src/boot/lib/libstand/cd9660.c (revision e58ba7f2)
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