cd9660read.c revision 344408 
1/*
2 * Copyright (C) 1996 Wolfgang Solfrank.
3 * Copyright (C) 1996 TooLs GmbH.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 *    notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 *    notice, this list of conditions and the following disclaimer in the
13 *    documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 *    must display the following acknowledgement:
16 *	This product includes software developed by TooLs GmbH.
17 * 4. The name of TooLs GmbH may not be used to endorse or promote products
18 *    derived from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
21 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23 * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/* Originally derived from libsa/cd9660.c: */
33/*	$NetBSD: cd9660.c,v 1.5 1997/06/26 19:11:33 drochner Exp $	*/
34
35#include <sys/cdefs.h>
36__FBSDID("$FreeBSD: stable/11/stand/libsa/cd9660read.c 344408 2019-02-21 02:43:48Z kevans $");
37
38#include <fs/cd9660/iso.h>
39#include <fs/cd9660/cd9660_rrip.h>
40
41static uint64_t cd9660_lookup(const char *);
42static ssize_t cd9660_fsread(uint64_t, void *, size_t);
43
44#define	SUSP_CONTINUATION	"CE"
45#define	SUSP_PRESENT		"SP"
46#define	SUSP_STOP		"ST"
47#define	SUSP_EXTREF		"ER"
48#define	RRIP_NAME		"NM"
49
50typedef struct {
51	ISO_SUSP_HEADER		h;
52	u_char signature	[ISODCL (  5,    6)];
53	u_char len_skp		[ISODCL (  7,    7)]; /* 711 */
54} ISO_SUSP_PRESENT;
55
56static int
57read_iso_block(void *buffer, daddr_t blkno)
58{
59
60	return (drvread(&dsk, buffer, blkno * 4, 4));
61}
62
63static ISO_SUSP_HEADER *
64susp_lookup_record(const char *identifier, struct iso_directory_record *dp,
65    int lenskip)
66{
67	static char susp_buffer[ISO_DEFAULT_BLOCK_SIZE];
68	ISO_SUSP_HEADER *sh;
69	ISO_RRIP_CONT *shc;
70	char *p, *end;
71	int error;
72
73	p = dp->name + isonum_711(dp->name_len) + lenskip;
74	/* Names of even length have a padding byte after the name. */
75	if ((isonum_711(dp->name_len) & 1) == 0)
76		p++;
77	end = (char *)dp + isonum_711(dp->length);
78	while (p + 3 < end) {
79		sh = (ISO_SUSP_HEADER *)p;
80		if (bcmp(sh->type, identifier, 2) == 0)
81			return (sh);
82		if (bcmp(sh->type, SUSP_STOP, 2) == 0)
83			return (NULL);
84		if (bcmp(sh->type, SUSP_CONTINUATION, 2) == 0) {
85			shc = (ISO_RRIP_CONT *)sh;
86			error = read_iso_block(susp_buffer,
87			    isonum_733(shc->location));
88
89			/* Bail if it fails. */
90			if (error != 0)
91				return (NULL);
92			p = susp_buffer + isonum_733(shc->offset);
93			end = p + isonum_733(shc->length);
94		} else {
95			/* Ignore this record and skip to the next. */
96			p += isonum_711(sh->length);
97
98			/* Avoid infinite loops with corrupted file systems */
99			if (isonum_711(sh->length) == 0)
100				return (NULL);
101		}
102	}
103	return (NULL);
104}
105
106static const char *
107rrip_lookup_name(struct iso_directory_record *dp, int lenskip, size_t *len)
108{
109	ISO_RRIP_ALTNAME *p;
110
111	if (len == NULL)
112		return (NULL);
113
114	p = (ISO_RRIP_ALTNAME *)susp_lookup_record(RRIP_NAME, dp, lenskip);
115	if (p == NULL)
116		return (NULL);
117	switch (*p->flags) {
118	case ISO_SUSP_CFLAG_CURRENT:
119		*len = 1;
120		return (".");
121	case ISO_SUSP_CFLAG_PARENT:
122		*len = 2;
123		return ("..");
124	case 0:
125		*len = isonum_711(p->h.length) - 5;
126		return ((char *)p + 5);
127	default:
128		/*
129		 * We don't handle hostnames or continued names as they are
130		 * too hard, so just bail and use the default name.
131		 */
132		return (NULL);
133	}
134}
135
136static int
137rrip_check(struct iso_directory_record *dp, int *lenskip)
138{
139	ISO_SUSP_PRESENT *sp;
140	ISO_RRIP_EXTREF *er;
141	char *p;
142
143	/* First, see if we can find a SP field. */
144	p = dp->name + isonum_711(dp->name_len);
145	if (p > (char *)dp + isonum_711(dp->length)) {
146		return (0);
147	}
148	sp = (ISO_SUSP_PRESENT *)p;
149	if (bcmp(sp->h.type, SUSP_PRESENT, 2) != 0) {
150		return (0);
151	}
152	if (isonum_711(sp->h.length) != sizeof(ISO_SUSP_PRESENT)) {
153		return (0);
154	}
155	if (sp->signature[0] != 0xbe || sp->signature[1] != 0xef) {
156		return (0);
157	}
158	*lenskip = isonum_711(sp->len_skp);
159
160	/*
161	 * Now look for an ER field.  If RRIP is present, then there must
162	 * be at least one of these.  It would be more pedantic to walk
163	 * through the list of fields looking for a Rock Ridge ER field.
164	 */
165	er = (ISO_RRIP_EXTREF *)susp_lookup_record(SUSP_EXTREF, dp, 0);
166	if (er == NULL) {
167		return (0);
168	}
169	return (1);
170}
171
172static int
173dirmatch(const char *path, struct iso_directory_record *dp, int use_rrip,
174    int lenskip)
175{
176	size_t len;
177	const char *cp = NULL;
178	int i, icase;
179
180	if (use_rrip)
181		cp = rrip_lookup_name(dp, lenskip, &len);
182	else
183		cp = NULL;
184	if (cp == NULL) {
185		len = isonum_711(dp->name_len);
186		cp = dp->name;
187		icase = 1;
188	} else
189		icase = 0;
190	for (i = len; --i >= 0; path++, cp++) {
191		if (!*path || *path == '/')
192			break;
193		if (*path == *cp)
194			continue;
195		if (!icase && toupper(*path) == *cp)
196			continue;
197		return 0;
198	}
199	if (*path && *path != '/') {
200		return 0;
201	}
202	/*
203	 * Allow stripping of trailing dots and the version number.
204	 * Note that this will find the first instead of the last version
205	 * of a file.
206	 */
207	if (i >= 0 && (*cp == ';' || *cp == '.')) {
208		/* This is to prevent matching of numeric extensions */
209		if (*cp == '.' && cp[1] != ';') {
210			return 0;
211		}
212		while (--i >= 0)
213			if (*++cp != ';' && (*cp < '0' || *cp > '9')) {
214				return 0;
215			}
216	}
217	return 1;
218}
219
220static uint64_t
221cd9660_lookup(const char *path)
222{
223	static char blkbuf[ISO_DEFAULT_BLOCK_SIZE];
224	struct iso_primary_descriptor *vd;
225	struct iso_directory_record rec;
226	struct iso_directory_record *dp = NULL;
227	size_t dsize, off;
228	daddr_t bno, boff;
229	int rc, first, use_rrip, lenskip;
230	uint64_t cookie;
231
232	for (bno = 16;; bno++) {
233		rc = read_iso_block(blkbuf, bno);
234		vd = (struct iso_primary_descriptor *)blkbuf;
235
236		if (bcmp(vd->id, ISO_STANDARD_ID, sizeof vd->id) != 0)
237			return (0);
238		if (isonum_711(vd->type) == ISO_VD_END)
239			return (0);
240		if (isonum_711(vd->type) == ISO_VD_PRIMARY)
241			break;
242	}
243
244	bcopy(vd->root_directory_record, &rec, sizeof(rec));
245	if (*path == '/') path++; /* eat leading '/' */
246
247	first = 1;
248	use_rrip = 0;
249	lenskip = 0;
250	while (*path) {
251		bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
252		dsize = isonum_733(rec.size);
253		off = 0;
254		boff = 0;
255
256		while (off < dsize) {
257			if ((off % ISO_DEFAULT_BLOCK_SIZE) == 0) {
258				rc = read_iso_block(blkbuf, bno + boff);
259				if (rc) {
260					return (0);
261				}
262				boff++;
263				dp = (struct iso_directory_record *) blkbuf;
264			}
265			if (isonum_711(dp->length) == 0) {
266				/* skip to next block, if any */
267				off = boff * ISO_DEFAULT_BLOCK_SIZE;
268				continue;
269			}
270
271			/* See if RRIP is in use. */
272			if (first)
273				use_rrip = rrip_check(dp, &lenskip);
274
275			if (dirmatch(path, dp, use_rrip,
276			    first ? 0 : lenskip)) {
277				first = 0;
278				break;
279			} else
280				first = 0;
281
282			dp = (struct iso_directory_record *)
283			    ((char *) dp + isonum_711(dp->length));
284			/* If the new block has zero length, it is padding. */
285			if (isonum_711(dp->length) == 0) {
286				/* Skip to next block, if any. */
287				off = boff * ISO_DEFAULT_BLOCK_SIZE;
288				continue;
289			}
290			off += isonum_711(dp->length);
291		}
292		if (off >= dsize) {
293			return (0);
294		}
295
296		rec = *dp;
297		while (*path && *path != '/') /* look for next component */
298			path++;
299		if (*path) path++; /* skip '/' */
300	}
301
302	if ((isonum_711(rec.flags) & 2) != 0) {
303		return (0);
304	}
305
306	cookie = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
307	cookie = (cookie << 32) | isonum_733(rec.size);
308
309	return (cookie);
310}
311
312static ssize_t
313cd9660_fsread(uint64_t cookie, void *buf, size_t nbytes)
314{
315	static char blkbuf[ISO_DEFAULT_BLOCK_SIZE];
316	static daddr_t curstart = 0, curblk = 0;
317	daddr_t blk, blk_off;
318	off_t byte_off;
319	size_t size, remaining, n;
320	char *s;
321
322	size = cookie & 0xffffffff;
323	blk = (cookie >> 32) & 0xffffffff;
324
325	/* Make sure we're looking at the right file. */
326	if (((blk << 32) | size) != cookie) {
327		return (-1);
328	}
329
330	if (blk != curstart) {
331		curstart = blk;
332		fs_off = 0;
333	}
334
335	size -= fs_off;
336	if (size < nbytes) {
337		nbytes = size;
338	}
339	remaining = nbytes;
340	s = buf;
341
342	while (remaining > 0) {
343		blk_off = fs_off >> ISO_DEFAULT_BLOCK_SHIFT;
344		byte_off = fs_off & (ISO_DEFAULT_BLOCK_SIZE - 1);
345
346		if (curblk != curstart + blk_off) {
347			curblk = curstart + blk_off;
348			read_iso_block(blkbuf, curblk);
349		}
350
351		if (remaining < ISO_DEFAULT_BLOCK_SIZE - byte_off) {
352			n = remaining;
353		} else {
354			n = ISO_DEFAULT_BLOCK_SIZE - byte_off;
355		}
356		memcpy(s, blkbuf + byte_off, n);
357		remaining -= n;
358		s += n;
359
360		fs_off += n;
361	}
362
363	return (nbytes);
364}
365