lib/libstand/cd9660.c

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