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 * 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 * 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 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 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 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 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 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 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 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 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 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