usr/src/cmd/fs.d/udfs/mkfs/udfslib.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 1999 by Sun Microsystems, Inc.
  24  * All rights reserved.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * Library of support routines for UDFS data structures and conversions.
  31  */
  32 #include        <stdio.h>
  33 #include        <string.h>
  34 #include        <strings.h>
  35 #include        <sys/time.h>
  36 #include        <sys/mutex.h>
  37 #include        <sys/vnode.h>
  38 #include        <sys/fs/udf_volume.h>
  39 #include        "udfs.h"
  40
  41 char *tagerrs[] = {
  42         "no error",
  43         "invalid checksum",     /* TAGERR_CKSUM */
  44         "unknown tag id",       /* TAGERR_ID */
  45         "invalid version",      /* TAGERR_VERSION */
  46         "CRC length too large", /* TAGERR_TOOBIG */
  47         "invalid CRC",          /* TAGERR_CRC */
  48         "location mismatch"     /* TAGERR_LOC */
  49 };
  50
  51 #ifdef sparc
  52 #define SWAP16(x) (((x) & 0xff) << 8 | ((x) >> 8) & 0xff)
  53 #define SWAP32(x) (((x) & 0xff) << 24 | ((x) & 0xff00) << 8 | \
  54         ((x) & 0xff0000) >> 8 | ((x) >> 24) & 0xff)
  55 #define SWAP64(x) (SWAP32((x) >> 32) & 0xffffffff | SWAP32(x) << 32)
  56 #else
  57 #define SWAP16(x) (x)
  58 #define SWAP32(x) (x)
  59 #define SWAP64(x) (x)
  60 #endif
  61
  62 static void ud_swap_ext_ad(struct extent_ad *);
  63 static void ud_swap_tstamp(struct tstamp *);
  64 static void ud_swap_icb_tag(struct icb_tag *);
  65 void ud_swap_short_ad(struct short_ad *);
  66 void ud_swap_long_ad(struct long_ad *);
  67 static void ud_swap_pri_vol_desc(struct pri_vol_desc *);
  68 static void ud_swap_vdp(struct vol_desc_ptr *);
  69 static void ud_swap_iuvd(struct iuvd_desc *);
  70 static void ud_swap_avdp(struct anch_vol_desc_ptr *);
  71 static void ud_swap_part_desc(struct part_desc *);
  72 static void ud_swap_log_desc(struct log_vol_desc *);
  73 static void ud_swap_unall_desc(struct unall_spc_desc *);
  74 static void ud_swap_lvint(struct log_vol_int_desc *);
  75 static void ud_swap_fileset_desc(struct file_set_desc *);
  76 static void ud_swap_term_desc(struct term_desc *);
  77 static void ud_swap_file_id(struct file_id *);
  78 static void ud_swap_file_entry(struct file_entry *, int);
  79 static void ud_swap_alloc_ext(struct alloc_ext_desc *);
  80 static void ud_swap_tstamp(tstamp_t *);
  81 static void ud_swap_space_bitmap(struct space_bmap_desc *);
  82 static uint16_t crc16(uint8_t *, int32_t, int32_t);
  83
  84 extern uint32_t ecma_version;
  85
  86 void
  87 maketag(struct tag *itp, struct tag *otp)
  88 {
  89         int32_t sum, i;
  90         uint8_t *cp;
  91
  92         if (itp != otp) {
  93                 bcopy((unsigned char *)(itp + 1), (unsigned char *)(otp + 1),
  94                         itp->tag_crc_len);
  95         }
  96
  97         /* Swap fields */
  98         switch (itp->tag_id) {
  99                 case UD_PRI_VOL_DESC:
 100                         ud_swap_pri_vol_desc((struct pri_vol_desc *)otp);
 101                         break;
 102                 case UD_ANCH_VOL_DESC:
 103                         ud_swap_avdp((struct anch_vol_desc_ptr *)otp);
 104                         break;
 105                 case UD_VOL_DESC_PTR:
 106                         ud_swap_vdp((struct vol_desc_ptr *)otp);
 107                         break;
 108                 case UD_IMPL_USE_DESC:
 109                         ud_swap_iuvd((struct iuvd_desc *)otp);
 110                         break;
 111                 case UD_PART_DESC:
 112                         ud_swap_part_desc((struct part_desc *)otp);
 113                         break;
 114                 case UD_LOG_VOL_DESC:
 115                         ud_swap_log_desc((struct log_vol_desc *)otp);
 116                         break;
 117                 case UD_UNALL_SPA_DESC:
 118                         ud_swap_unall_desc((struct unall_spc_desc *)otp);
 119                         break;
 120                 case UD_TERM_DESC:
 121                         ud_swap_term_desc((struct term_desc *)otp);
 122                         break;
 123                 case UD_LOG_VOL_INT:
 124                         /* LINTED */
 125                         ud_swap_lvint((struct log_vol_int_desc *)otp);
 126                         break;
 127                 case UD_FILE_SET_DESC:
 128                         ud_swap_fileset_desc((struct file_set_desc *)otp);
 129                         break;
 130                 case UD_FILE_ID_DESC:
 131                         ud_swap_file_id((struct file_id *)otp);
 132                         break;
 133                 case UD_ALLOC_EXT_DESC:
 134                         break;
 135                 case UD_INDIRECT_ENT:
 136                         break;
 137                 case UD_TERMINAL_ENT:
 138                         break;
 139                 case UD_FILE_ENTRY:
 140                         /* LINTED */
 141                         ud_swap_file_entry((struct file_entry *)otp, 0);
 142                         break;
 143                 case UD_EXT_ATTR_HDR:
 144                         break;
 145                 case UD_UNALL_SPA_ENT:
 146                         break;
 147                 case UD_SPA_BMAP_DESC:
 148                         ud_swap_space_bitmap((struct space_bmap_desc *)otp);
 149                         break;
 150                 case UD_PART_INT_DESC:
 151                         break;
 152         }
 153         otp->tag_id = SWAP16(itp->tag_id);
 154         otp->tag_desc_ver = SWAP16(itp->tag_desc_ver);
 155         otp->tag_cksum = otp->tag_res = 0;
 156         otp->tag_sno = SWAP16(itp->tag_sno);
 157         otp->tag_crc = SWAP16(crc16((unsigned char *)(otp+1),
 158                 itp->tag_crc_len, 0));
 159         otp->tag_crc_len = SWAP16(itp->tag_crc_len);
 160         otp->tag_loc = SWAP32(itp->tag_loc);
 161
 162         /*
 163          * Now do checksum on tag itself
 164          */
 165         cp = (unsigned char *)otp;
 166         sum = 0;
 167         for (i = 0; i < sizeof (*otp); i++)
 168                 sum += *cp++;
 169         otp->tag_cksum = sum;
 170 }
 171
 172
 173 int32_t
 174 verifytag(struct tag *tp, uint32_t loc, struct tag *otp, int expect)
 175 {
 176         uint8_t *cp;
 177         uint32_t id, vers, length, tloc;
 178         int sum, i;
 179
 180         sum = -tp->tag_cksum;
 181         cp = (unsigned char *)tp;
 182         for (i = 0; i < sizeof (*tp); i++)
 183                 sum += *cp++;
 184         if ((sum & 0xff) != tp->tag_cksum)
 185                 return (TAGERR_CKSUM);
 186         id = SWAP16(tp->tag_id);
 187         if (id > 9 && id < 256 || id > 266 || (expect > 0 && id != expect))
 188                 return (TAGERR_ID);
 189         vers = SWAP16(tp->tag_desc_ver);
 190         if (vers > ecma_version)
 191                 return (TAGERR_VERSION);
 192         length = SWAP16(tp->tag_crc_len);
 193         if (length > MAXBSIZE)
 194                 return (TAGERR_TOOBIG);
 195         if (crc16((unsigned char *)(tp+1), length, SWAP16(tp->tag_crc)) != 0)
 196                 return (TAGERR_CRC);
 197         tloc = SWAP32(tp->tag_loc);
 198         if ((int)loc != -1 && tloc != loc)
 199                 return (TAGERR_LOC);
 200         if (!otp)
 201                 return (0);
 202         otp->tag_id = id;
 203         otp->tag_desc_ver = vers;
 204         otp->tag_cksum = tp->tag_cksum;
 205         otp->tag_res = 0;
 206         otp->tag_sno = SWAP16(tp->tag_sno);
 207         otp->tag_crc = SWAP16(tp->tag_crc);
 208         otp->tag_crc_len = length;
 209         otp->tag_loc = tloc;
 210
 211         if (tp != otp)
 212                 bcopy((unsigned char *)(tp + 1), (unsigned char *)(otp + 1),
 213                         otp->tag_crc_len);
 214         /* Swap fields */
 215         switch (otp->tag_id) {
 216         case UD_PRI_VOL_DESC:
 217                 ud_swap_pri_vol_desc((struct pri_vol_desc *)otp);
 218                 break;
 219         case UD_ANCH_VOL_DESC:
 220                 ud_swap_avdp((struct anch_vol_desc_ptr *)otp);
 221                 break;
 222         case UD_VOL_DESC_PTR:
 223                 ud_swap_vdp((struct vol_desc_ptr *)otp);
 224                 break;
 225         case UD_IMPL_USE_DESC:
 226                 ud_swap_iuvd((struct iuvd_desc *)otp);
 227                 break;
 228         case UD_PART_DESC:
 229                 ud_swap_part_desc((struct part_desc *)otp);
 230                 break;
 231         case UD_LOG_VOL_DESC:
 232                 ud_swap_log_desc((struct log_vol_desc *)otp);
 233                 break;
 234         case UD_UNALL_SPA_DESC:
 235                 ud_swap_unall_desc((struct unall_spc_desc *)otp);
 236                 break;
 237         case UD_TERM_DESC:
 238                 ud_swap_term_desc((struct term_desc *)otp);
 239                 break;
 240         case UD_LOG_VOL_INT:
 241                 /* LINTED */
 242                 ud_swap_lvint((struct log_vol_int_desc *)otp);
 243                 break;
 244         case UD_FILE_SET_DESC:
 245                 ud_swap_fileset_desc((struct file_set_desc *)otp);
 246                 break;
 247         case UD_FILE_ID_DESC:
 248                 ud_swap_file_id((struct file_id *)otp);
 249                 break;
 250         case UD_ALLOC_EXT_DESC:
 251                 ud_swap_alloc_ext((struct alloc_ext_desc *)otp);
 252                 break;
 253         case UD_INDIRECT_ENT:
 254                 break;
 255         case UD_TERMINAL_ENT:
 256                 break;
 257         case UD_FILE_ENTRY:
 258                 /* LINTED */
 259                 ud_swap_file_entry((struct file_entry *)otp, 1);
 260                 break;
 261         case UD_EXT_ATTR_HDR:
 262                 break;
 263         case UD_UNALL_SPA_ENT:
 264                 break;
 265         case UD_SPA_BMAP_DESC:
 266                 ud_swap_space_bitmap((struct space_bmap_desc *)otp);
 267                 break;
 268         case UD_PART_INT_DESC:
 269                 break;
 270         }
 271         return (0);
 272 }
 273
 274 static void
 275 ud_swap_ext_ad(struct extent_ad *p)
 276 {
 277         p->ext_len = SWAP32(p->ext_len);
 278         p->ext_loc = SWAP32(p->ext_loc);
 279 }
 280
 281
 282 /* ARGSUSED */
 283 static void
 284 ud_swap_regid(struct regid *p)
 285 {
 286 }
 287
 288 static void
 289 ud_swap_icb_tag(struct icb_tag *p)
 290 {
 291         p->itag_prnde = SWAP32(p->itag_prnde);
 292         p->itag_strategy = SWAP16(p->itag_strategy);
 293         p->itag_param = SWAP16(p->itag_param);
 294         p->itag_max_ent = SWAP16(p->itag_max_ent);
 295         p->itag_lb_loc = SWAP32(p->itag_lb_loc);
 296         p->itag_lb_prn = SWAP16(p->itag_lb_prn);
 297         p->itag_flags = SWAP16(p->itag_flags);
 298 }
 299
 300 void
 301 ud_swap_short_ad(struct short_ad *p)
 302 {
 303         p->sad_ext_len = SWAP32(p->sad_ext_len);
 304         p->sad_ext_loc = SWAP32(p->sad_ext_loc);
 305 }
 306
 307 void
 308 ud_swap_long_ad(struct long_ad *p)
 309 {
 310         p->lad_ext_len = SWAP32(p->lad_ext_len);
 311         p->lad_ext_loc = SWAP32(p->lad_ext_loc);
 312         p->lad_ext_prn = SWAP16(p->lad_ext_prn);
 313 }
 314
 315 static void
 316 ud_swap_pri_vol_desc(struct pri_vol_desc *p)
 317 {
 318         p->pvd_vdsn = SWAP32(p->pvd_vdsn);
 319         p->pvd_pvdn = SWAP32(p->pvd_pvdn);
 320         p->pvd_vsn = SWAP16(p->pvd_vsn);
 321         p->pvd_mvsn = SWAP16(p->pvd_mvsn);
 322         p->pvd_il = SWAP16(p->pvd_il);
 323         p->pvd_mil = SWAP16(p->pvd_mil);
 324         p->pvd_csl = SWAP32(p->pvd_csl);
 325         p->pvd_mcsl = SWAP32(p->pvd_mcsl);
 326         ud_swap_ext_ad(&p->pvd_vol_abs);
 327         ud_swap_ext_ad(&p->pvd_vcn);
 328         ud_swap_regid(&p->pvd_appl_id);
 329         ud_swap_tstamp(&p->pvd_time);
 330         ud_swap_regid(&p->pvd_ii);
 331         p->pvd_pvdsl = SWAP32(p->pvd_pvdsl);
 332         p->pvd_flags = SWAP16(p->pvd_flags);
 333 }
 334
 335 static void
 336 ud_swap_iuvd(struct iuvd_desc *p)
 337 {
 338         p->iuvd_vdsn = SWAP32(p->iuvd_vdsn);
 339         ud_swap_regid(&p->iuvd_ii);
 340         ud_swap_regid(&p->iuvd_iid);
 341 }
 342
 343 static void
 344 ud_swap_vdp(struct vol_desc_ptr *p)
 345 {
 346         p->vdp_vdsn = SWAP32(p->vdp_vdsn);
 347         ud_swap_ext_ad(&p->vdp_nvdse);
 348 }
 349
 350 static void
 351 ud_swap_avdp(struct anch_vol_desc_ptr *p)
 352 {
 353         ud_swap_ext_ad(&p->avd_main_vdse);
 354         ud_swap_ext_ad(&p->avd_res_vdse);
 355 }
 356
 357 static void
 358 ud_swap_part_desc(struct part_desc *p)
 359 {
 360         struct phdr_desc *php;
 361
 362         p->pd_vdsn = SWAP32(p->pd_vdsn);
 363         p->pd_pflags = SWAP16(p->pd_pflags);
 364         p->pd_pnum = SWAP16(p->pd_pnum);
 365         ud_swap_regid(&p->pd_pcontents);
 366         p->pd_acc_type = SWAP32(p->pd_acc_type);
 367         p->pd_part_start = SWAP32(p->pd_part_start);
 368         p->pd_part_length = SWAP32(p->pd_part_length);
 369         ud_swap_regid(&p->pd_ii);
 370         if (strncmp(p->pd_pcontents.reg_id, "+NSR", 4) == 0) {
 371                 /* LINTED */
 372                 php = (struct phdr_desc *)p->pd_pc_use;
 373                 ud_swap_short_ad(&php->phdr_ust);
 374                 ud_swap_short_ad(&php->phdr_usb);
 375                 ud_swap_short_ad(&php->phdr_it);
 376                 ud_swap_short_ad(&php->phdr_fst);
 377                 ud_swap_short_ad(&php->phdr_fsb);
 378         }
 379 }
 380
 381 static void
 382 ud_swap_log_desc(struct log_vol_desc *p)
 383 {
 384         p->lvd_vdsn = SWAP32(p->lvd_vdsn);
 385         p->lvd_log_bsize = SWAP32(p->lvd_log_bsize);
 386         ud_swap_regid(&p->lvd_dom_id);
 387         ud_swap_long_ad(&p->lvd_lvcu);
 388         p->lvd_mtbl_len = SWAP32(p->lvd_mtbl_len);
 389         p->lvd_num_pmaps = SWAP32(p->lvd_num_pmaps);
 390         ud_swap_regid(&p->lvd_ii);
 391         ud_swap_ext_ad(&p->lvd_int_seq_ext);
 392 }
 393
 394 static void
 395 ud_swap_unall_desc(struct unall_spc_desc *p)
 396 {
 397         p->ua_vdsn = SWAP32(p->ua_vdsn);
 398         p->ua_nad = SWAP32(p->ua_nad);
 399 }
 400
 401 static void
 402 ud_swap_lvint(struct log_vol_int_desc *p)
 403 {
 404         struct lvid_iu *lvup;
 405
 406         ud_swap_tstamp(&p->lvid_tstamp);
 407         p->lvid_int_type = SWAP32(p->lvid_int_type);
 408         ud_swap_ext_ad(&p->lvid_nie);
 409         p->lvid_npart = SWAP32(p->lvid_npart);
 410         p->lvid_liu = SWAP32(p->lvid_liu);
 411         p->lvid_uniqid = SWAP64(p->lvid_uniqid);
 412         p->lvid_fst[0] = SWAP32(p->lvid_fst[0]);
 413         p->lvid_fst[1] = SWAP32(p->lvid_fst[1]);
 414
 415         lvup = (struct lvid_iu *)&p->lvid_fst[2];
 416         ud_swap_regid(&lvup->lvidiu_regid);
 417         lvup->lvidiu_nfiles = SWAP32(lvup->lvidiu_nfiles);
 418         lvup->lvidiu_ndirs = SWAP32(lvup->lvidiu_ndirs);
 419         lvup->lvidiu_mread = SWAP16(lvup->lvidiu_mread);
 420         lvup->lvidiu_mwrite = SWAP16(lvup->lvidiu_mwrite);
 421         lvup->lvidiu_maxwr = SWAP16(lvup->lvidiu_maxwr);
 422 }
 423
 424 static void
 425 ud_swap_fileset_desc(struct file_set_desc *p)
 426 {
 427         ud_swap_tstamp(&p->fsd_time);
 428         p->fsd_ilevel = SWAP16(p->fsd_ilevel);
 429         p->fsd_mi_level = SWAP16(p->fsd_mi_level);
 430         p->fsd_cs_list = SWAP32(p->fsd_cs_list);
 431         p->fsd_mcs_list = SWAP32(p->fsd_mcs_list);
 432         p->fsd_fs_no = SWAP32(p->fsd_fs_no);
 433         p->fsd_fsd_no = SWAP32(p->fsd_fsd_no);
 434         ud_swap_long_ad(&p->fsd_root_icb);
 435         ud_swap_regid(&p->fsd_did);
 436         ud_swap_long_ad(&p->fsd_next);
 437 }
 438
 439 /* ARGSUSED */
 440 static void
 441 ud_swap_term_desc(struct term_desc *p)
 442 {
 443 }
 444
 445 static void
 446 ud_swap_file_id(struct file_id *p)
 447 {
 448         p->fid_ver = SWAP16(p->fid_ver);
 449         ud_swap_long_ad(&p->fid_icb);
 450         p->fid_iulen = SWAP16(p->fid_iulen);
 451 }
 452
 453 static void
 454 ud_swap_alloc_ext(struct alloc_ext_desc *p)
 455 {
 456         p->aed_rev_ael = SWAP32(p->aed_rev_ael);
 457         p->aed_len_aed = SWAP32(p->aed_len_aed);
 458 }
 459
 460 static void
 461 ud_swap_space_bitmap(struct space_bmap_desc *p)
 462 {
 463         p->sbd_nbits = SWAP32(p->sbd_nbits);
 464         p->sbd_nbytes = SWAP32(p->sbd_nbytes);
 465 }
 466
 467 static void
 468 ud_swap_file_entry(struct file_entry *p, int32_t rdflag)
 469 {
 470         int32_t i;
 471         short_ad_t *sap;
 472         long_ad_t *lap;
 473
 474         /* Do Extended Attributes and Allocation Descriptors */
 475         if (rdflag) {
 476                 p->fe_len_adesc = SWAP32(p->fe_len_adesc);
 477                 p->fe_len_ear = SWAP32(p->fe_len_ear);
 478                 ud_swap_icb_tag(&p->fe_icb_tag);
 479         }
 480         switch (p->fe_icb_tag.itag_flags & 0x3) {
 481         case ICB_FLAG_SHORT_AD:
 482                 /* LINTED */
 483                 sap = (short_ad_t *)(p->fe_spec + p->fe_len_ear);
 484                 for (i = 0; i < p->fe_len_adesc / sizeof (short_ad_t);
 485                         i++, sap++)
 486                         ud_swap_short_ad(sap);
 487                 break;
 488         case ICB_FLAG_LONG_AD:
 489                 /* LINTED */
 490                 lap = (long_ad_t *)(p->fe_spec + p->fe_len_ear);
 491                 for (i = 0; i < p->fe_len_adesc / sizeof (long_ad_t);
 492                         i++, lap++)
 493                         ud_swap_long_ad(lap);
 494                 break;
 495         case ICB_FLAG_EXT_AD:
 496                 break;
 497         case ICB_FLAG_ONE_AD:
 498                 break;
 499         }
 500         p->fe_uid = SWAP32(p->fe_uid);
 501         p->fe_gid = SWAP32(p->fe_gid);
 502         p->fe_perms = SWAP32(p->fe_perms);
 503         p->fe_lcount = SWAP16(p->fe_lcount);
 504         p->fe_rec_len = SWAP32(p->fe_rec_len);
 505         p->fe_info_len = SWAP64(p->fe_info_len);
 506         p->fe_lbr = SWAP64(p->fe_lbr);
 507         ud_swap_tstamp(&p->fe_acc_time);
 508         ud_swap_tstamp(&p->fe_mod_time);
 509         ud_swap_tstamp(&p->fe_attr_time);
 510         p->fe_ckpoint = SWAP32(p->fe_ckpoint);
 511         ud_swap_long_ad(&p->fe_ea_icb);
 512         ud_swap_regid(&p->fe_impl_id);
 513         p->fe_uniq_id = SWAP64(p->fe_uniq_id);
 514         if (!rdflag) {
 515                 p->fe_len_adesc = SWAP32(p->fe_len_adesc);
 516                 p->fe_len_ear = SWAP32(p->fe_len_ear);
 517                 ud_swap_icb_tag(&p->fe_icb_tag);
 518         }
 519 }
 520
 521 static void
 522 ud_swap_tstamp(tstamp_t *tp)
 523 {
 524         tp->ts_tzone = SWAP16(tp->ts_tzone);
 525         tp->ts_year = SWAP16(tp->ts_year);
 526 }
 527
 528 void
 529 setcharspec(struct charspec *cp, int32_t type, uint8_t *info)
 530 {
 531         cp->cs_type = type;
 532         bzero(cp->cs_info, sizeof (cp->cs_info));
 533         (void) strncpy(cp->cs_info, (int8_t *)info, sizeof (cp->cs_info));
 534 }
 535
 536 static unsigned short crctab[] = {
 537         0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
 538         0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
 539         0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
 540         0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
 541         0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
 542         0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
 543         0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
 544         0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
 545         0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
 546         0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
 547         0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
 548         0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
 549         0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
 550         0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
 551         0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
 552         0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
 553         0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
 554         0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
 555         0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
 556         0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
 557         0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
 558         0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
 559         0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
 560         0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
 561         0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
 562         0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
 563         0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
 564         0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
 565         0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
 566         0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
 567         0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
 568         0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
 569 };
 570
 571 static uint16_t
 572 crc16(uint8_t *buf, int32_t size, int32_t rem)
 573 {
 574         uint16_t crc = 0;
 575
 576         while (size-- > 0)
 577                 crc = (crc << 8) ^ crctab[((crc >> 8) ^ *buf++) & 0xff];
 578         return ((crc ^ rem) & 0xffff);
 579 }