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         return (NULL);
 159 }
 160
 161 static char *
 162 rrip_lookup_name(struct open_file *f, struct iso_directory_record *dp,
 163     int lenskip, size_t *len)
 164 {
 165         ISO_RRIP_ALTNAME *p;
 166
 167         if (len == NULL)
 168                 return (NULL);
 169
 170         p = (ISO_RRIP_ALTNAME *)susp_lookup_record(f, RRIP_NAME, dp, lenskip);
 171         if (p == NULL)
 172                 return (NULL);
 173         switch (*p->flags) {
 174         case ISO_SUSP_CFLAG_CURRENT:
 175                 *len = 1;
 176                 return (".");
 177         case ISO_SUSP_CFLAG_PARENT:
 178                 *len = 2;
 179                 return ("..");
 180         case 0:
 181                 *len = isonum_711(p->h.length) - 5;
 182                 return ((char *)p + 5);
 183         default:
 184                 /*
 185                  * We don't handle hostnames or continued names as they are
 186                  * too hard, so just bail and use the default name.
 187                  */
 188                 return (NULL);
 189         }
 190 }
 191
 192 static int
 193 rrip_check(struct open_file *f, struct iso_directory_record *dp, int *lenskip)
 194 {
 195         ISO_SUSP_PRESENT *sp;
 196         ISO_RRIP_EXTREF *er;
 197         char *p;
 198
 199         /* First, see if we can find a SP field. */
 200         p = dp->name + isonum_711(dp->name_len);
 201         if (p > (char *)dp + isonum_711(dp->length))
 202                 return (0);
 203         sp = (ISO_SUSP_PRESENT *)p;
 204         if (bcmp(sp->h.type, SUSP_PRESENT, 2) != 0)
 205                 return (0);
 206         if (isonum_711(sp->h.length) != sizeof(ISO_SUSP_PRESENT))
 207                 return (0);
 208         if (sp->signature[0] != 0xbe || sp->signature[1] != 0xef)
 209                 return (0);
 210         *lenskip = isonum_711(sp->len_skp);
 211
 212         /*
 213          * Now look for an ER field.  If RRIP is present, then there must
 214          * be at least one of these.  It would be more pedantic to walk
 215          * through the list of fields looking for a Rock Ridge ER field.
 216          */
 217         er = (ISO_RRIP_EXTREF *)susp_lookup_record(f, SUSP_EXTREF, dp, 0);
 218         if (er == NULL)
 219                 return (0);
 220         return (1);
 221 }
 222
 223 static int
 224 dirmatch(struct open_file *f, const char *path, struct iso_directory_record *dp,
 225     int use_rrip, int lenskip)
 226 {
 227         size_t len;
 228         char *cp;
 229         int i, icase;
 230
 231         if (use_rrip)
 232                 cp = rrip_lookup_name(f, dp, lenskip, &len);
 233         else
 234                 cp = NULL;
 235         if (cp == NULL) {
 236                 len = isonum_711(dp->name_len);
 237                 cp = dp->name;
 238                 icase = 1;
 239         } else
 240                 icase = 0;
 241         for (i = len; --i >= 0; path++, cp++) {
 242                 if (!*path || *path == '/')
 243                         break;
 244                 if (*path == *cp)
 245                         continue;
 246                 if (!icase && toupper(*path) == *cp)
 247                         continue;
 248                 return 0;
 249         }
 250         if (*path && *path != '/')
 251                 return 0;
 252         /*
 253          * Allow stripping of trailing dots and the version number.
 254          * Note that this will find the first instead of the last version
 255          * of a file.
 256          */
 257         if (i >= 0 && (*cp == ';' || *cp == '.')) {
 258                 /* This is to prevent matching of numeric extensions */
 259                 if (*cp == '.' && cp[1] != ';')
 260                         return 0;
 261                 while (--i >= 0)
 262                         if (*++cp != ';' && (*cp < '0' || *cp > '9'))
 263                                 return 0;
 264         }
 265         return 1;
 266 }
 267
 268 static int
 269 cd9660_open(const char *path, struct open_file *f)
 270 {
 271         struct file *fp = 0;
 272         void *buf;
 273         struct iso_primary_descriptor *vd;
 274         size_t buf_size, read, dsize, off;
 275         daddr_t bno, boff;
 276         struct iso_directory_record rec;
 277         struct iso_directory_record *dp = 0;
 278         int rc, first, use_rrip, lenskip;
 279
 280         /* First find the volume descriptor */
 281         buf = malloc(buf_size = ISO_DEFAULT_BLOCK_SIZE);
 282         vd = buf;
 283         for (bno = 16;; bno++) {
 284                 twiddle();
 285                 rc = f->f_dev->dv_strategy(f->f_devdata, F_READ, cdb2devb(bno),
 286                                            ISO_DEFAULT_BLOCK_SIZE, buf, &read);
 287                 if (rc)
 288                         goto out;
 289                 if (read != ISO_DEFAULT_BLOCK_SIZE) {
 290                         rc = EIO;
 291                         goto out;
 292                 }
 293                 rc = EINVAL;
 294                 if (bcmp(vd->id, ISO_STANDARD_ID, sizeof vd->id) != 0)
 295                         goto out;
 296                 if (isonum_711(vd->type) == ISO_VD_END)
 297                         goto out;
 298                 if (isonum_711(vd->type) == ISO_VD_PRIMARY)
 299                         break;
 300         }
 301         if (isonum_723(vd->logical_block_size) != ISO_DEFAULT_BLOCK_SIZE)
 302                 goto out;
 303
 304         rec = *(struct iso_directory_record *) vd->root_directory_record;
 305         if (*path == '/') path++; /* eat leading '/' */
 306
 307         first = 1;
 308         use_rrip = 0;
 309         while (*path) {
 310                 bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
 311                 dsize = isonum_733(rec.size);
 312                 off = 0;
 313                 boff = 0;
 314
 315                 while (off < dsize) {
 316                         if ((off % ISO_DEFAULT_BLOCK_SIZE) == 0) {
 317                                 twiddle();
 318                                 rc = f->f_dev->dv_strategy
 319                                         (f->f_devdata, F_READ,
 320                                          cdb2devb(bno + boff),
 321                                          ISO_DEFAULT_BLOCK_SIZE,
 322                                          buf, &read);
 323                                 if (rc)
 324                                         goto out;
 325                                 if (read != ISO_DEFAULT_BLOCK_SIZE) {
 326                                         rc = EIO;
 327                                         goto out;
 328                                 }
 329                                 boff++;
 330                                 dp = (struct iso_directory_record *) buf;
 331                         }
 332                         if (isonum_711(dp->length) == 0) {
 333                             /* skip to next block, if any */
 334                             off = boff * ISO_DEFAULT_BLOCK_SIZE;
 335                             continue;
 336                         }
 337
 338                         /* See if RRIP is in use. */
 339                         if (first)
 340                                 use_rrip = rrip_check(f, dp, &lenskip);
 341
 342                         if (dirmatch(f, path, dp, use_rrip,
 343                                 first ? 0 : lenskip)) {
 344                                 first = 0;
 345                                 break;
 346                         } else
 347                                 first = 0;
 348
 349                         dp = (struct iso_directory_record *)
 350                                 ((char *) dp + isonum_711(dp->length));
 351                         off += isonum_711(dp->length);
 352                 }
 353                 if (off >= dsize) {
 354                         rc = ENOENT;
 355                         goto out;
 356                 }
 357
 358                 rec = *dp;
 359                 while (*path && *path != '/') /* look for next component */
 360                         path++;
 361                 if (*path) path++; /* skip '/' */
 362         }
 363
 364         /* allocate file system specific data structure */
 365         fp = malloc(sizeof(struct file));
 366         bzero(fp, sizeof(struct file));
 367         f->f_fsdata = (void *)fp;
 368
 369         if ((isonum_711(rec.flags) & 2) != 0) {
 370                 fp->f_flags = F_ISDIR;
 371         }
 372         if (first) {
 373                 fp->f_flags |= F_ROOTDIR;
 374
 375                 /* Check for Rock Ridge since we didn't in the loop above. */
 376                 bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
 377                 twiddle();
 378                 rc = f->f_dev->dv_strategy(f->f_devdata, F_READ, cdb2devb(bno),
 379                     ISO_DEFAULT_BLOCK_SIZE, buf, &read);
 380                 if (rc)
 381                         goto out;
 382                 if (read != ISO_DEFAULT_BLOCK_SIZE) {
 383                         rc = EIO;
 384                         goto out;
 385                 }
 386                 dp = (struct iso_directory_record *)buf;
 387                 use_rrip = rrip_check(f, dp, &lenskip);
 388         }
 389         if (use_rrip) {
 390                 fp->f_flags |= F_RR;
 391                 fp->f_susp_skip = lenskip;
 392         }
 393         fp->f_off = 0;
 394         fp->f_bno = isonum_733(rec.extent) + isonum_711(rec.ext_attr_length);
 395         fp->f_size = isonum_733(rec.size);
 396         free(buf);
 397
 398         return 0;
 399
 400 out:
 401         if (fp)
 402                 free(fp);
 403         free(buf);
 404
 405         return rc;
 406 }
 407
 408 static int
 409 cd9660_close(struct open_file *f)
 410 {
 411         struct file *fp = (struct file *)f->f_fsdata;
 412
 413         f->f_fsdata = 0;
 414         free(fp);
 415
 416         return 0;
 417 }
 418
 419 static int
 420 buf_read_file(struct open_file *f, char **buf_p, size_t *size_p)
 421 {
 422         struct file *fp = (struct file *)f->f_fsdata;
 423         daddr_t blkno, blkoff;
 424         int rc = 0;
 425         size_t read;
 426
 427         blkno = fp->f_off / ISO_DEFAULT_BLOCK_SIZE + fp->f_bno;
 428         blkoff = fp->f_off % ISO_DEFAULT_BLOCK_SIZE;
 429
 430         if (blkno != fp->f_buf_blkno) {
 431                 if (fp->f_buf == (char *)0)
 432                         fp->f_buf = malloc(ISO_DEFAULT_BLOCK_SIZE);
 433
 434                 twiddle();
 435                 rc = f->f_dev->dv_strategy(f->f_devdata, F_READ,
 436                     cdb2devb(blkno), ISO_DEFAULT_BLOCK_SIZE, fp->f_buf, &read);
 437                 if (rc)
 438                         return (rc);
 439                 if (read != ISO_DEFAULT_BLOCK_SIZE)
 440                         return (EIO);
 441
 442                 fp->f_buf_blkno = blkno;
 443         }
 444
 445         *buf_p = fp->f_buf + blkoff;
 446         *size_p = ISO_DEFAULT_BLOCK_SIZE - blkoff;
 447
 448         if (*size_p > fp->f_size - fp->f_off)
 449                 *size_p = fp->f_size - fp->f_off;
 450         return (rc);
 451 }
 452
 453 static int
 454 cd9660_read(struct open_file *f, void *start, size_t size, size_t *resid)
 455 {
 456         struct file *fp = (struct file *)f->f_fsdata;
 457         char *buf, *addr;
 458         size_t buf_size, csize;
 459         int rc = 0;
 460
 461         addr = start;
 462         while (size) {
 463                 if (fp->f_off < 0 || fp->f_off >= fp->f_size)
 464                         break;
 465
 466                 rc = buf_read_file(f, &buf, &buf_size);
 467                 if (rc)
 468                         break;
 469
 470                 csize = size > buf_size ? buf_size : size;
 471                 bcopy(buf, addr, csize);
 472
 473                 fp->f_off += csize;
 474                 addr += csize;
 475                 size -= csize;
 476         }
 477         if (resid)
 478                 *resid = size;
 479         return (rc);
 480 }
 481
 482 static int
 483 cd9660_readdir(struct open_file *f, struct dirent *d)
 484 {
 485         struct file *fp = (struct file *)f->f_fsdata;
 486         struct iso_directory_record *ep;
 487         size_t buf_size, reclen, namelen;
 488         int error = 0;
 489         int lenskip;
 490         char *buf, *name;
 491
 492 again:
 493         if (fp->f_off >= fp->f_size)
 494                 return (ENOENT);
 495         error = buf_read_file(f, &buf, &buf_size);
 496         if (error)
 497                 return (error);
 498         ep = (struct iso_directory_record *)buf;
 499
 500         if (isonum_711(ep->length) == 0) {
 501                 daddr_t blkno;
 502
 503                 /* skip to next block, if any */
 504                 blkno = fp->f_off / ISO_DEFAULT_BLOCK_SIZE;
 505                 fp->f_off = (blkno + 1) * ISO_DEFAULT_BLOCK_SIZE;
 506                 goto again;
 507         }
 508
 509         if (fp->f_flags & F_RR) {
 510                 if (fp->f_flags & F_ROOTDIR && fp->f_off == 0)
 511                         lenskip = 0;
 512                 else
 513                         lenskip = fp->f_susp_skip;
 514                 name = rrip_lookup_name(f, ep, lenskip, &namelen);
 515         } else
 516                 name = NULL;
 517         if (name == NULL) {
 518                 namelen = isonum_711(ep->name_len);
 519                 name = ep->name;
 520                 if (namelen == 1) {
 521                         if (ep->name[0] == 0)
 522                                 name = ".";
 523                         else if (ep->name[0] == 1) {
 524                                 namelen = 2;
 525                                 name = "..";
 526                         }
 527                 }
 528         }
 529         reclen = sizeof(struct dirent) - (MAXNAMLEN+1) + namelen + 1;
 530         reclen = (reclen + 3) & ~3;
 531
 532         d->d_fileno = isonum_733(ep->extent);
 533         d->d_reclen = reclen;
 534         if (isonum_711(ep->flags) & 2)
 535                 d->d_type = DT_DIR;
 536         else
 537                 d->d_type = DT_REG;
 538         d->d_namlen = namelen;
 539
 540         bcopy(name, d->d_name, d->d_namlen);
 541         d->d_name[d->d_namlen] = 0;
 542
 543         fp->f_off += isonum_711(ep->length);
 544         return (0);
 545 }
 546
 547 static int
 548 cd9660_write(struct open_file *f __unused, void *start __unused, size_t size __unused, size_t *resid __unused)
 549 {
 550         return EROFS;
 551 }
 552
 553 static off_t
 554 cd9660_seek(struct open_file *f, off_t offset, int where)
 555 {
 556         struct file *fp = (struct file *)f->f_fsdata;
 557
 558         switch (where) {
 559         case SEEK_SET:
 560                 fp->f_off = offset;
 561                 break;
 562         case SEEK_CUR:
 563                 fp->f_off += offset;
 564                 break;
 565         case SEEK_END:
 566                 fp->f_off = fp->f_size - offset;
 567                 break;
 568         default:
 569                 return -1;
 570         }
 571         return fp->f_off;
 572 }
 573
 574 static int
 575 cd9660_stat(struct open_file *f, struct stat *sb)
 576 {
 577         struct file *fp = (struct file *)f->f_fsdata;
 578
 579         /* only important stuff */
 580         sb->st_mode = S_IRUSR | S_IRGRP | S_IROTH;
 581         if (fp->f_flags & F_ISDIR)
 582                 sb->st_mode |= S_IFDIR;
 583         else
 584                 sb->st_mode |= S_IFREG;
 585         sb->st_uid = sb->st_gid = 0;
 586         sb->st_size = fp->f_size;
 587         return 0;
 588 }