sys/geom/geom_bsd_enc.c

   1 /*-
   2  * Copyright (c) 2002 Poul-Henning Kamp
   3  * Copyright (c) 2002 Networks Associates Technology, Inc.
   4  * All rights reserved.
   5  *
   6  * This software was developed for the FreeBSD Project by Poul-Henning Kamp
   7  * and NAI Labs, the Security Research Division of Network Associates, Inc.
   8  * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
   9  * DARPA CHATS research program.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. The names of the authors may not be used to endorse or promote
  20  *    products derived from this software without specific prior written
  21  *    permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 /*
  37  * Functions to encode and decode struct disklabel and struct partition into
  38  * a bytestream of little endianess and correct packing.
  39  *
  40  * NB!  This file must be usable both in kernel and userland.
  41  */
  42
  43 #include <sys/cdefs.h>
  44 __FBSDID("$FreeBSD$");
  45
  46 #include <sys/types.h>
  47 #include <sys/endian.h>
  48 #include <sys/disklabel.h>
  49 #include <sys/errno.h>
  50 #ifdef _KERNEL
  51 #include <sys/systm.h>
  52 #else
  53 #include <string.h>
  54 #endif
  55
  56 void
  57 bsd_partition_le_dec(u_char *ptr, struct partition *d)
  58 {
  59         d->p_size = le32dec(ptr + 0);
  60         d->p_offset = le32dec(ptr + 4);
  61         d->p_fsize = le32dec(ptr + 8);
  62         d->p_fstype = ptr[12];
  63         d->p_frag = ptr[13];
  64         d->p_cpg = le16dec(ptr + 14);
  65 }
  66
  67 int
  68 bsd_disklabel_le_dec(u_char *ptr, struct disklabel *d, int maxpart)
  69 {
  70         int i;
  71         u_char *p, *pe;
  72         uint16_t sum;
  73
  74         d->d_magic = le32dec(ptr + 0);
  75         if (d->d_magic != DISKMAGIC)
  76                 return(EINVAL);
  77
  78         d->d_magic2 = le32dec(ptr + 132);
  79         if (d->d_magic2 != DISKMAGIC) {
  80                 return(EINVAL);
  81         }
  82
  83         d->d_npartitions = le16dec(ptr + 138);
  84         if (d->d_npartitions > maxpart) {
  85                 return(EINVAL);
  86         }
  87
  88         pe = ptr + 148 + 16 * d->d_npartitions;
  89         sum = 0;
  90         for (p = ptr; p < pe; p += 2)
  91                 sum ^= le16dec(p);
  92         if (sum != 0) {
  93                 return(EINVAL);
  94         }
  95
  96         d->d_type = le16dec(ptr + 4);
  97         d->d_subtype = le16dec(ptr + 6);
  98         bcopy(ptr + 8, d->d_typename, 16);
  99         bcopy(ptr + 24, d->d_packname, 16);
 100         d->d_secsize = le32dec(ptr + 40);
 101         d->d_nsectors = le32dec(ptr + 44);
 102         d->d_ntracks = le32dec(ptr + 48);
 103         d->d_ncylinders = le32dec(ptr + 52);
 104         d->d_secpercyl = le32dec(ptr + 56);
 105         d->d_secperunit = le32dec(ptr + 60);
 106         d->d_sparespertrack = le16dec(ptr + 64);
 107         d->d_sparespercyl = le16dec(ptr + 66);
 108         d->d_acylinders = le32dec(ptr + 68);
 109         d->d_rpm = le16dec(ptr + 72);
 110         d->d_interleave = le16dec(ptr + 74);
 111         d->d_trackskew = le16dec(ptr + 76);
 112         d->d_cylskew = le16dec(ptr + 78);
 113         d->d_headswitch = le32dec(ptr + 80);
 114         d->d_trkseek = le32dec(ptr + 84);
 115         d->d_flags = le32dec(ptr + 88);
 116         d->d_drivedata[0] = le32dec(ptr + 92);
 117         d->d_drivedata[1] = le32dec(ptr + 96);
 118         d->d_drivedata[2] = le32dec(ptr + 100);
 119         d->d_drivedata[3] = le32dec(ptr + 104);
 120         d->d_drivedata[4] = le32dec(ptr + 108);
 121         d->d_spare[0] = le32dec(ptr + 112);
 122         d->d_spare[1] = le32dec(ptr + 116);
 123         d->d_spare[2] = le32dec(ptr + 120);
 124         d->d_spare[3] = le32dec(ptr + 124);
 125         d->d_spare[4] = le32dec(ptr + 128);
 126         d->d_checksum = le16dec(ptr + 136);
 127         d->d_npartitions = le16dec(ptr + 138);
 128         d->d_bbsize = le32dec(ptr + 140);
 129         d->d_sbsize = le32dec(ptr + 144);
 130         for (i = 0; i < d->d_npartitions; i++)
 131                 bsd_partition_le_dec(ptr + 148 + 16 * i, &d->d_partitions[i]);
 132         return(0);
 133 }
 134
 135 void
 136 bsd_partition_le_enc(u_char *ptr, struct partition *d)
 137 {
 138         le32enc(ptr + 0, d->p_size);
 139         le32enc(ptr + 4, d->p_offset);
 140         le32enc(ptr + 8, d->p_fsize);
 141         ptr[12] = d->p_fstype;
 142         ptr[13] = d->p_frag;
 143         le16enc(ptr + 14, d->p_cpg);
 144 }
 145
 146 void
 147 bsd_disklabel_le_enc(u_char *ptr, struct disklabel *d)
 148 {
 149         int i;
 150         u_char *p, *pe;
 151         uint16_t sum;
 152
 153         le32enc(ptr + 0, d->d_magic);
 154         le16enc(ptr + 4, d->d_type);
 155         le16enc(ptr + 6, d->d_subtype);
 156         bcopy(d->d_typename, ptr + 8, 16);
 157         bcopy(d->d_packname, ptr + 24, 16);
 158         le32enc(ptr + 40, d->d_secsize);
 159         le32enc(ptr + 44, d->d_nsectors);
 160         le32enc(ptr + 48, d->d_ntracks);
 161         le32enc(ptr + 52, d->d_ncylinders);
 162         le32enc(ptr + 56, d->d_secpercyl);
 163         le32enc(ptr + 60, d->d_secperunit);
 164         le16enc(ptr + 64, d->d_sparespertrack);
 165         le16enc(ptr + 66, d->d_sparespercyl);
 166         le32enc(ptr + 68, d->d_acylinders);
 167         le16enc(ptr + 72, d->d_rpm);
 168         le16enc(ptr + 74, d->d_interleave);
 169         le16enc(ptr + 76, d->d_trackskew);
 170         le16enc(ptr + 78, d->d_cylskew);
 171         le32enc(ptr + 80, d->d_headswitch);
 172         le32enc(ptr + 84, d->d_trkseek);
 173         le32enc(ptr + 88, d->d_flags);
 174         le32enc(ptr + 92, d->d_drivedata[0]);
 175         le32enc(ptr + 96, d->d_drivedata[1]);
 176         le32enc(ptr + 100, d->d_drivedata[2]);
 177         le32enc(ptr + 104, d->d_drivedata[3]);
 178         le32enc(ptr + 108, d->d_drivedata[4]);
 179         le32enc(ptr + 112, d->d_spare[0]);
 180         le32enc(ptr + 116, d->d_spare[1]);
 181         le32enc(ptr + 120, d->d_spare[2]);
 182         le32enc(ptr + 124, d->d_spare[3]);
 183         le32enc(ptr + 128, d->d_spare[4]);
 184         le32enc(ptr + 132, d->d_magic2);
 185         le16enc(ptr + 136, 0);
 186         le16enc(ptr + 138, d->d_npartitions);
 187         le32enc(ptr + 140, d->d_bbsize);
 188         le32enc(ptr + 144, d->d_sbsize);
 189         for (i = 0; i < d->d_npartitions; i++)
 190                 bsd_partition_le_enc(ptr + 148 + 16 * i, &d->d_partitions[i]);
 191         pe = ptr + 148 + 16 * d->d_npartitions;
 192         sum = 0;
 193         for (p = ptr; p < pe; p += 2)
 194                 sum ^= le16dec(p);
 195         le16enc(ptr + 136, sum);
 196 }