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 * 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)), 0, 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 * 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 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 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 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 0, 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 0, 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 0, 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 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 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), 0, ISO_DEFAULT_BLOCK_SIZE, 442 fp->f_buf, &read); 443 if (rc) 444 return (rc); 445 if (read != ISO_DEFAULT_BLOCK_SIZE) 446 return (EIO); 447 448 fp->f_buf_blkno = blkno; 449 } 450 451 *buf_p = fp->f_buf + blkoff; 452 *size_p = ISO_DEFAULT_BLOCK_SIZE - blkoff; 453 454 if (*size_p > fp->f_size - fp->f_off) 455 *size_p = fp->f_size - fp->f_off; 456 return (rc); 457 } 458 459 static int 460 cd9660_read(struct open_file *f, void *start, size_t size, size_t *resid) 461 { 462 struct file *fp = (struct file *)f->f_fsdata; 463 char *buf, *addr; 464 size_t buf_size, csize; 465 int rc = 0; 466 467 addr = start; 468 while (size) { 469 if (fp->f_off < 0 || fp->f_off >= fp->f_size) 470 break; 471 472 rc = buf_read_file(f, &buf, &buf_size); 473 if (rc) 474 break; 475 476 csize = size > buf_size ? buf_size : size; 477 bcopy(buf, addr, csize); 478 479 fp->f_off += csize; 480 addr += csize; 481 size -= csize; 482 } 483 if (resid) 484 *resid = size; 485 return (rc); 486 } 487 488 static int 489 cd9660_readdir(struct open_file *f, struct dirent *d) 490 { 491 struct file *fp = (struct file *)f->f_fsdata; 492 struct iso_directory_record *ep; 493 size_t buf_size, reclen, namelen; 494 int error = 0; 495 int lenskip; 496 char *buf, *name; 497 498 again: 499 if (fp->f_off >= fp->f_size) 500 return (ENOENT); 501 error = buf_read_file(f, &buf, &buf_size); 502 if (error) 503 return (error); 504 ep = (struct iso_directory_record *)buf; 505 506 if (isonum_711(ep->length) == 0) { 507 daddr_t blkno; 508 509 /* skip to next block, if any */ 510 blkno = fp->f_off / ISO_DEFAULT_BLOCK_SIZE; 511 fp->f_off = (blkno + 1) * ISO_DEFAULT_BLOCK_SIZE; 512 goto again; 513 } 514 515 if (fp->f_flags & F_RR) { 516 if (fp->f_flags & F_ROOTDIR && fp->f_off == 0) 517 lenskip = 0; 518 else 519 lenskip = fp->f_susp_skip; 520 name = rrip_lookup_name(f, ep, lenskip, &namelen); 521 } else 522 name = NULL; 523 if (name == NULL) { 524 namelen = isonum_711(ep->name_len); 525 name = ep->name; 526 if (namelen == 1) { 527 if (ep->name[0] == 0) 528 name = "."; 529 else if (ep->name[0] == 1) { 530 namelen = 2; 531 name = ".."; 532 } 533 } 534 } 535 reclen = sizeof(struct dirent) - (MAXNAMLEN+1) + namelen + 1; 536 reclen = (reclen + 3) & ~3; 537 538 d->d_fileno = isonum_733(ep->extent); 539 d->d_reclen = reclen; 540 if (isonum_711(ep->flags) & 2) 541 d->d_type = DT_DIR; 542 else 543 d->d_type = DT_REG; 544 d->d_namlen = namelen; 545 546 bcopy(name, d->d_name, d->d_namlen); 547 d->d_name[d->d_namlen] = 0; 548 549 fp->f_off += isonum_711(ep->length); 550 return (0); 551 } 552 553 static int 554 cd9660_write(struct open_file *f __unused, void *start __unused, size_t size __unused, size_t *resid __unused) 555 { 556 return EROFS; 557 } 558 559 static off_t 560 cd9660_seek(struct open_file *f, off_t offset, int where) 561 { 562 struct file *fp = (struct file *)f->f_fsdata; 563 564 switch (where) { 565 case SEEK_SET: 566 fp->f_off = offset; 567 break; 568 case SEEK_CUR: 569 fp->f_off += offset; 570 break; 571 case SEEK_END: 572 fp->f_off = fp->f_size - offset; 573 break; 574 default: 575 return -1; 576 } 577 return fp->f_off; 578 } 579 580 static int 581 cd9660_stat(struct open_file *f, struct stat *sb) 582 { 583 struct file *fp = (struct file *)f->f_fsdata; 584 585 /* only important stuff */ 586 sb->st_mode = S_IRUSR | S_IRGRP | S_IROTH; 587 if (fp->f_flags & F_ISDIR) 588 sb->st_mode |= S_IFDIR; 589 else 590 sb->st_mode |= S_IFREG; 591 sb->st_uid = sb->st_gid = 0; 592 sb->st_size = fp->f_size; 593 return 0; 594 } 595