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