root/isofs/udf/udf_subr.c

DEFINITIONS

1. udf_rawnametounicode
2. udf_disklabelspoof
3. udf_vat_get
4. udf_vat_map
5. udf_vat_read

    1 /*      $OpenBSD: udf_subr.c,v 1.13 2007/06/08 05:35:32 deraadt Exp $   */
    3 /*
    4  * Copyright (c) 2006, Miodrag Vallat
    5  * Copyright (c) 2006, Pedro Martelletto
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *    notice, this list of conditions and the following disclaimer in the
   14  *    documentation and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   19  * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
   20  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   22  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   24  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
   25  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   26  * POSSIBILITY OF SUCH DAMAGE.
   27  */
   29 #include <sys/param.h>
   30 #include <sys/systm.h>
   31 #include <sys/buf.h>
   32 #include <sys/kernel.h>
   33 #include <sys/malloc.h>
   34 #include <sys/mutex.h>
   35 #include <sys/stat.h>
   36 #include <sys/mount.h>
   37 #include <sys/vnode.h>
   38 #include <sys/dirent.h>
   39 #include <sys/unistd.h>
   40 #include <sys/disklabel.h>
   42 #include <isofs/udf/ecma167-udf.h>
   43 #include <isofs/udf/udf.h>
   44 #include <isofs/udf/udf_extern.h>
   46 int udf_vat_read(struct umount *, uint32_t *);
   48 /*
   49  * Convert a CS0 dstring to a 16-bit Unicode string.
   50  * Returns the length of the Unicode string, in unicode characters (not
   51  * bytes!), or -1 if an error arises.
   52  * Note that the transname destination buffer is expected to be large
   53  * enough to hold the result, and will not be terminated in any way.
   54  */
   55 int
udf_rawnametounicode(u_int len, char *cs0string, unicode_t *transname)
   57 {
unicode_t *origname = transname;
   60         if (len-- == 0)
   61                 return (-1);
   63         switch (*cs0string++) {
   64         case 8:         /* bytes string */
   65                 while (len-- != 0)
   66                         *transname++ = (unicode_t)*cs0string++;
   67                 break;
   68         case 16:        /* 16 bit unicode string */
   69                 if (len & 1)
   70                         return (-1);
len >>= 1;
   72                 while (len-- != 0) {
unicode_t tmpchar;
tmpchar = (unicode_t)*cs0string++;
tmpchar = (tmpchar << 8) | (unicode_t)*cs0string++;
   77                         *transname++ = tmpchar;
   78                 }
   79                 break;
   80         default:
   81                 return (-1);
   82         }
   84         return (transname - origname);
   85 }
   87 /*
   88  * Do a lazy probe on the underlying media to check if it's a UDF volume, in
   89  * which case we fake a disk label for it.
   90  */
   91 int
udf_disklabelspoof(dev_t dev, void (*strat)(struct buf *),
   93     struct disklabel *lp)
   94 {
   95         char vid[32];
   96         int i, bsize = 2048, error = EINVAL;
uint32_t sector = 256, mvds_start, mvds_end;
   98         struct buf *bp;
   99         struct anchor_vdp avdp;
  100         struct pri_vol_desc *pvd;
  102         /*
  103          * Get a buffer to work with.
  104          */
bp = geteblk(bsize);
bp->b_dev = dev;
  108         /*
  109          * Look for an Anchor Volume Descriptor at sector 256.
  110          */
bp->b_blkno = sector * btodb(bsize);
bp->b_bcount = bsize;
bp->b_flags = B_BUSY | B_READ;
bp->b_resid = bp->b_blkno / lp->d_secpercyl;
  116         (*strat)(bp);
  117         if (biowait(bp))
  118                 goto out;
  120         if (udf_checktag((struct desc_tag *)bp->b_data, TAGID_ANCHOR))
  121                 goto out;
bcopy(bp->b_data, &avdp, sizeof(avdp));
mvds_start = letoh32(avdp.main_vds_ex.loc);
mvds_end = mvds_start + (letoh32(avdp.main_vds_ex.len) - 1) / bsize;
  127         /*
  128          * Then try to find a reference to a Primary Volume Descriptor.
  129          */
  130         for (sector = mvds_start; sector < mvds_end; sector++) {
bp->b_blkno = sector * btodb(bsize);
bp->b_bcount = bsize;
bp->b_flags = B_BUSY | B_READ;
bp->b_resid = bp->b_blkno / lp->d_secpercyl;
  136                 (*strat)(bp);
  137                 if (biowait(bp))
  138                         goto out;
pvd = (struct pri_vol_desc *)bp->b_data;
  141                 if (!udf_checktag(&pvd->tag, TAGID_PRI_VOL))
  142                         break;
  143         }
  145         /*
  146          * If we couldn't find a reference, bail out.
  147          */
  148         if (sector == mvds_end)
  149                 goto out;
  151         /*
  152          * Okay, it's a UDF volume. Spoof a disk label for it.
  153          */
  154         if (udf_transname(pvd->vol_id, vid, sizeof(pvd->vol_id) - 1, NULL))
strlcpy(lp->d_typename, vid, sizeof(lp->d_typename));
  157         for (i = 0; i < MAXPARTITIONS; i++) {
DL_SETPSIZE(&lp->d_partitions[i], 0);
DL_SETPOFFSET(&lp->d_partitions[i], 0);
  160         }
  162         /*
  163          * Fake two partitions, 'a' and 'c'.
  164          */
DL_SETPSIZE(&lp->d_partitions[0], DL_GETDSIZE(lp));
lp->d_partitions[0].p_fstype = FS_UDF;
DL_SETPSIZE(&lp->d_partitions[RAW_PART], DL_GETDSIZE(lp));
lp->d_partitions[RAW_PART].p_fstype = FS_UDF;
lp->d_npartitions = RAW_PART + 1;
lp->d_version = 1;
lp->d_bbsize = 8192;    /* Fake. */
lp->d_sbsize = 64*1024; /* Fake. */
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(lp);
error = 0;
out:
bp->b_flags |= B_INVAL;
brelse(bp);
  183         return (error);
  184 }
  186 /* Get a vnode for the Virtual Allocation Table (VAT) */
  187 int
udf_vat_get(struct umount *ump, uint32_t lb)
  189 {
  190         struct vnode *vp;
  191         struct unode *up;
  192         int error;
error = udf_vget(ump->um_mountp, lb - ump->um_start - 3, &vp);
  195         if (error)
  196                 return (error);
up = VTOU(vp);
up->u_vatlen = (letoh64(up->u_fentry->inf_len) - 36) >> 2;
ump->um_vat = malloc(sizeof(struct unode), M_UDFMOUNT, M_WAITOK);
  202        *ump->um_vat = *up;
ump->um_flags &= ~UDF_MNT_FIND_VAT;
ump->um_flags |=  UDF_MNT_USES_VAT;
vput(vp);
  209         return (0);
  210 }
  212 /* Look up a sector in the VAT */
  213 int
udf_vat_map(struct umount *ump, uint32_t *sector)
  215 {
  216         /* If there's no VAT, then it's easy */
  217         if (!(ump->um_flags & UDF_MNT_USES_VAT)) {
  218                 *sector += ump->um_start;
  219                 return (0);
  220         }
  222         /* Sanity check the given sector */
  223         if (*sector >= ump->um_vat->u_vatlen)
  224                 return (EINVAL);
  226         return (udf_vat_read(ump, sector));
  227 }
  229 /* Read from the VAT */
  230 int
udf_vat_read(struct umount *ump, uint32_t *sector)
  232 {
  233         struct buf *bp;
uint8_t *data;
  235         int error, size;
size = 4;
  239         /*
  240          * Note that we rely on the buffer cache to keep frequently accessed
  241          * buffers around to avoid reading them from the disk all the time.
  242          */
error = udf_readatoffset(ump->um_vat, &size, *sector << 2, &bp, &data);
  244         if (error) {
  245                 if (bp != NULL)
brelse(bp);
  248                 return (error);
  249         }
  251         /* Make sure we read at least a whole entry */
  252         if (size < 4) {
  253                 if (bp != NULL)
brelse(bp);
  256                 return (EINVAL);
  257         }
  259         /* Map the sector */
  260         *sector = letoh32(*(uint32_t *)data) + ump->um_start;
brelse(bp);
  264         return (0);
  265 }