xref: /titanic_50/usr/src/cmd/fs.d/udfs/mkfs/udfslib.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Library of support routines for UDFS data structures and conversions.
 */
#include	<stdio.h>
#include	<string.h>
#include	<strings.h>
#include	<sys/time.h>
#include	<sys/mutex.h>
#include	<sys/vnode.h>
#include	<sys/fs/udf_volume.h>
#include	"udfs.h"

char *tagerrs[] = {
	"no error",
	"invalid checksum",	/* TAGERR_CKSUM */
	"unknown tag id",	/* TAGERR_ID */
	"invalid version",	/* TAGERR_VERSION */
	"CRC length too large",	/* TAGERR_TOOBIG */
	"invalid CRC",		/* TAGERR_CRC */
	"location mismatch"	/* TAGERR_LOC */
};

#ifdef sparc
#define	SWAP16(x) (((x) & 0xff) << 8 | ((x) >> 8) & 0xff)
#define	SWAP32(x) (((x) & 0xff) << 24 | ((x) & 0xff00) << 8 | \
	((x) & 0xff0000) >> 8 | ((x) >> 24) & 0xff)
#define	SWAP64(x) (SWAP32((x) >> 32) & 0xffffffff | SWAP32(x) << 32)
#else
#define	SWAP16(x) (x)
#define	SWAP32(x) (x)
#define	SWAP64(x) (x)
#endif

static void ud_swap_ext_ad(struct extent_ad *);
static void ud_swap_tstamp(struct tstamp *);
static void ud_swap_icb_tag(struct icb_tag *);
void ud_swap_short_ad(struct short_ad *);
void ud_swap_long_ad(struct long_ad *);
static void ud_swap_pri_vol_desc(struct pri_vol_desc *);
static void ud_swap_vdp(struct vol_desc_ptr *);
static void ud_swap_iuvd(struct iuvd_desc *);
static void ud_swap_avdp(struct anch_vol_desc_ptr *);
static void ud_swap_part_desc(struct part_desc *);
static void ud_swap_log_desc(struct log_vol_desc *);
static void ud_swap_unall_desc(struct unall_spc_desc *);
static void ud_swap_lvint(struct log_vol_int_desc *);
static void ud_swap_fileset_desc(struct file_set_desc *);
static void ud_swap_term_desc(struct term_desc *);
static void ud_swap_file_id(struct file_id *);
static void ud_swap_file_entry(struct file_entry *, int);
static void ud_swap_alloc_ext(struct alloc_ext_desc *);
static void ud_swap_tstamp(tstamp_t *);
static void ud_swap_space_bitmap(struct space_bmap_desc *);
static uint16_t crc16(uint8_t *, int32_t, int32_t);

extern uint32_t ecma_version;

void
maketag(struct tag *itp, struct tag *otp)
{
	int32_t sum, i;
	uint8_t *cp;

	if (itp != otp) {
		bcopy((unsigned char *)(itp + 1), (unsigned char *)(otp + 1),
			itp->tag_crc_len);
	}

	/* Swap fields */
	switch (itp->tag_id) {
		case UD_PRI_VOL_DESC:
			ud_swap_pri_vol_desc((struct pri_vol_desc *)otp);
			break;
		case UD_ANCH_VOL_DESC:
			ud_swap_avdp((struct anch_vol_desc_ptr *)otp);
			break;
		case UD_VOL_DESC_PTR:
			ud_swap_vdp((struct vol_desc_ptr *)otp);
			break;
		case UD_IMPL_USE_DESC:
			ud_swap_iuvd((struct iuvd_desc *)otp);
			break;
		case UD_PART_DESC:
			ud_swap_part_desc((struct part_desc *)otp);
			break;
		case UD_LOG_VOL_DESC:
			ud_swap_log_desc((struct log_vol_desc *)otp);
			break;
		case UD_UNALL_SPA_DESC:
			ud_swap_unall_desc((struct unall_spc_desc *)otp);
			break;
		case UD_TERM_DESC:
			ud_swap_term_desc((struct term_desc *)otp);
			break;
		case UD_LOG_VOL_INT:
			/* LINTED */
			ud_swap_lvint((struct log_vol_int_desc *)otp);
			break;
		case UD_FILE_SET_DESC:
			ud_swap_fileset_desc((struct file_set_desc *)otp);
			break;
		case UD_FILE_ID_DESC:
			ud_swap_file_id((struct file_id *)otp);
			break;
		case UD_ALLOC_EXT_DESC:
			break;
		case UD_INDIRECT_ENT:
			break;
		case UD_TERMINAL_ENT:
			break;
		case UD_FILE_ENTRY:
			/* LINTED */
			ud_swap_file_entry((struct file_entry *)otp, 0);
			break;
		case UD_EXT_ATTR_HDR:
			break;
		case UD_UNALL_SPA_ENT:
			break;
		case UD_SPA_BMAP_DESC:
			ud_swap_space_bitmap((struct space_bmap_desc *)otp);
			break;
		case UD_PART_INT_DESC:
			break;
	}
	otp->tag_id = SWAP16(itp->tag_id);
	otp->tag_desc_ver = SWAP16(itp->tag_desc_ver);
	otp->tag_cksum = otp->tag_res = 0;
	otp->tag_sno = SWAP16(itp->tag_sno);
	otp->tag_crc = SWAP16(crc16((unsigned char *)(otp+1),
		itp->tag_crc_len, 0));
	otp->tag_crc_len = SWAP16(itp->tag_crc_len);
	otp->tag_loc = SWAP32(itp->tag_loc);

	/*
	 * Now do checksum on tag itself
	 */
	cp = (unsigned char *)otp;
	sum = 0;
	for (i = 0; i < sizeof (*otp); i++)
		sum += *cp++;
	otp->tag_cksum = sum;
}


int32_t
verifytag(struct tag *tp, uint32_t loc, struct tag *otp, int expect)
{
	uint8_t *cp;
	uint32_t id, vers, length, tloc;
	int sum, i;

	sum = -tp->tag_cksum;
	cp = (unsigned char *)tp;
	for (i = 0; i < sizeof (*tp); i++)
		sum += *cp++;
	if ((sum & 0xff) != tp->tag_cksum)
		return (TAGERR_CKSUM);
	id = SWAP16(tp->tag_id);
	if (id > 9 && id < 256 || id > 266 || (expect > 0 && id != expect))
		return (TAGERR_ID);
	vers = SWAP16(tp->tag_desc_ver);
	if (vers > ecma_version)
		return (TAGERR_VERSION);
	length = SWAP16(tp->tag_crc_len);
	if (length > MAXBSIZE)
		return (TAGERR_TOOBIG);
	if (crc16((unsigned char *)(tp+1), length, SWAP16(tp->tag_crc)) != 0)
		return (TAGERR_CRC);
	tloc = SWAP32(tp->tag_loc);
	if ((int)loc != -1 && tloc != loc)
		return (TAGERR_LOC);
	if (!otp)
		return (0);
	otp->tag_id = id;
	otp->tag_desc_ver = vers;
	otp->tag_cksum = tp->tag_cksum;
	otp->tag_res = 0;
	otp->tag_sno = SWAP16(tp->tag_sno);
	otp->tag_crc = SWAP16(tp->tag_crc);
	otp->tag_crc_len = length;
	otp->tag_loc = tloc;

	if (tp != otp)
		bcopy((unsigned char *)(tp + 1), (unsigned char *)(otp + 1),
			otp->tag_crc_len);
	/* Swap fields */
	switch (otp->tag_id) {
	case UD_PRI_VOL_DESC:
		ud_swap_pri_vol_desc((struct pri_vol_desc *)otp);
		break;
	case UD_ANCH_VOL_DESC:
		ud_swap_avdp((struct anch_vol_desc_ptr *)otp);
		break;
	case UD_VOL_DESC_PTR:
		ud_swap_vdp((struct vol_desc_ptr *)otp);
		break;
	case UD_IMPL_USE_DESC:
		ud_swap_iuvd((struct iuvd_desc *)otp);
		break;
	case UD_PART_DESC:
		ud_swap_part_desc((struct part_desc *)otp);
		break;
	case UD_LOG_VOL_DESC:
		ud_swap_log_desc((struct log_vol_desc *)otp);
		break;
	case UD_UNALL_SPA_DESC:
		ud_swap_unall_desc((struct unall_spc_desc *)otp);
		break;
	case UD_TERM_DESC:
		ud_swap_term_desc((struct term_desc *)otp);
		break;
	case UD_LOG_VOL_INT:
		/* LINTED */
		ud_swap_lvint((struct log_vol_int_desc *)otp);
		break;
	case UD_FILE_SET_DESC:
		ud_swap_fileset_desc((struct file_set_desc *)otp);
		break;
	case UD_FILE_ID_DESC:
		ud_swap_file_id((struct file_id *)otp);
		break;
	case UD_ALLOC_EXT_DESC:
		ud_swap_alloc_ext((struct alloc_ext_desc *)otp);
		break;
	case UD_INDIRECT_ENT:
		break;
	case UD_TERMINAL_ENT:
		break;
	case UD_FILE_ENTRY:
		/* LINTED */
		ud_swap_file_entry((struct file_entry *)otp, 1);
		break;
	case UD_EXT_ATTR_HDR:
		break;
	case UD_UNALL_SPA_ENT:
		break;
	case UD_SPA_BMAP_DESC:
		ud_swap_space_bitmap((struct space_bmap_desc *)otp);
		break;
	case UD_PART_INT_DESC:
		break;
	}
	return (0);
}

static void
ud_swap_ext_ad(struct extent_ad *p)
{
	p->ext_len = SWAP32(p->ext_len);
	p->ext_loc = SWAP32(p->ext_loc);
}


/* ARGSUSED */
static void
ud_swap_regid(struct regid *p)
{
}

static void
ud_swap_icb_tag(struct icb_tag *p)
{
	p->itag_prnde = SWAP32(p->itag_prnde);
	p->itag_strategy = SWAP16(p->itag_strategy);
	p->itag_param = SWAP16(p->itag_param);
	p->itag_max_ent = SWAP16(p->itag_max_ent);
	p->itag_lb_loc = SWAP32(p->itag_lb_loc);
	p->itag_lb_prn = SWAP16(p->itag_lb_prn);
	p->itag_flags = SWAP16(p->itag_flags);
}

void
ud_swap_short_ad(struct short_ad *p)
{
	p->sad_ext_len = SWAP32(p->sad_ext_len);
	p->sad_ext_loc = SWAP32(p->sad_ext_loc);
}

void
ud_swap_long_ad(struct long_ad *p)
{
	p->lad_ext_len = SWAP32(p->lad_ext_len);
	p->lad_ext_loc = SWAP32(p->lad_ext_loc);
	p->lad_ext_prn = SWAP16(p->lad_ext_prn);
}

static void
ud_swap_pri_vol_desc(struct pri_vol_desc *p)
{
	p->pvd_vdsn = SWAP32(p->pvd_vdsn);
	p->pvd_pvdn = SWAP32(p->pvd_pvdn);
	p->pvd_vsn = SWAP16(p->pvd_vsn);
	p->pvd_mvsn = SWAP16(p->pvd_mvsn);
	p->pvd_il = SWAP16(p->pvd_il);
	p->pvd_mil = SWAP16(p->pvd_mil);
	p->pvd_csl = SWAP32(p->pvd_csl);
	p->pvd_mcsl = SWAP32(p->pvd_mcsl);
	ud_swap_ext_ad(&p->pvd_vol_abs);
	ud_swap_ext_ad(&p->pvd_vcn);
	ud_swap_regid(&p->pvd_appl_id);
	ud_swap_tstamp(&p->pvd_time);
	ud_swap_regid(&p->pvd_ii);
	p->pvd_pvdsl = SWAP32(p->pvd_pvdsl);
	p->pvd_flags = SWAP16(p->pvd_flags);
}

static void
ud_swap_iuvd(struct iuvd_desc *p)
{
	p->iuvd_vdsn = SWAP32(p->iuvd_vdsn);
	ud_swap_regid(&p->iuvd_ii);
	ud_swap_regid(&p->iuvd_iid);
}

static void
ud_swap_vdp(struct vol_desc_ptr *p)
{
	p->vdp_vdsn = SWAP32(p->vdp_vdsn);
	ud_swap_ext_ad(&p->vdp_nvdse);
}

static void
ud_swap_avdp(struct anch_vol_desc_ptr *p)
{
	ud_swap_ext_ad(&p->avd_main_vdse);
	ud_swap_ext_ad(&p->avd_res_vdse);
}

static void
ud_swap_part_desc(struct part_desc *p)
{
	struct phdr_desc *php;

	p->pd_vdsn = SWAP32(p->pd_vdsn);
	p->pd_pflags = SWAP16(p->pd_pflags);
	p->pd_pnum = SWAP16(p->pd_pnum);
	ud_swap_regid(&p->pd_pcontents);
	p->pd_acc_type = SWAP32(p->pd_acc_type);
	p->pd_part_start = SWAP32(p->pd_part_start);
	p->pd_part_length = SWAP32(p->pd_part_length);
	ud_swap_regid(&p->pd_ii);
	if (strncmp(p->pd_pcontents.reg_id, "+NSR", 4) == 0) {
		/* LINTED */
		php = (struct phdr_desc *)p->pd_pc_use;
		ud_swap_short_ad(&php->phdr_ust);
		ud_swap_short_ad(&php->phdr_usb);
		ud_swap_short_ad(&php->phdr_it);
		ud_swap_short_ad(&php->phdr_fst);
		ud_swap_short_ad(&php->phdr_fsb);
	}
}

static void
ud_swap_log_desc(struct log_vol_desc *p)
{
	p->lvd_vdsn = SWAP32(p->lvd_vdsn);
	p->lvd_log_bsize = SWAP32(p->lvd_log_bsize);
	ud_swap_regid(&p->lvd_dom_id);
	ud_swap_long_ad(&p->lvd_lvcu);
	p->lvd_mtbl_len = SWAP32(p->lvd_mtbl_len);
	p->lvd_num_pmaps = SWAP32(p->lvd_num_pmaps);
	ud_swap_regid(&p->lvd_ii);
	ud_swap_ext_ad(&p->lvd_int_seq_ext);
}

static void
ud_swap_unall_desc(struct unall_spc_desc *p)
{
	p->ua_vdsn = SWAP32(p->ua_vdsn);
	p->ua_nad = SWAP32(p->ua_nad);
}

static void
ud_swap_lvint(struct log_vol_int_desc *p)
{
	struct lvid_iu *lvup;

	ud_swap_tstamp(&p->lvid_tstamp);
	p->lvid_int_type = SWAP32(p->lvid_int_type);
	ud_swap_ext_ad(&p->lvid_nie);
	p->lvid_npart = SWAP32(p->lvid_npart);
	p->lvid_liu = SWAP32(p->lvid_liu);
	p->lvid_uniqid = SWAP64(p->lvid_uniqid);
	p->lvid_fst[0] = SWAP32(p->lvid_fst[0]);
	p->lvid_fst[1] = SWAP32(p->lvid_fst[1]);

	lvup = (struct lvid_iu *)&p->lvid_fst[2];
	ud_swap_regid(&lvup->lvidiu_regid);
	lvup->lvidiu_nfiles = SWAP32(lvup->lvidiu_nfiles);
	lvup->lvidiu_ndirs = SWAP32(lvup->lvidiu_ndirs);
	lvup->lvidiu_mread = SWAP16(lvup->lvidiu_mread);
	lvup->lvidiu_mwrite = SWAP16(lvup->lvidiu_mwrite);
	lvup->lvidiu_maxwr = SWAP16(lvup->lvidiu_maxwr);
}

static void
ud_swap_fileset_desc(struct file_set_desc *p)
{
	ud_swap_tstamp(&p->fsd_time);
	p->fsd_ilevel = SWAP16(p->fsd_ilevel);
	p->fsd_mi_level = SWAP16(p->fsd_mi_level);
	p->fsd_cs_list = SWAP32(p->fsd_cs_list);
	p->fsd_mcs_list = SWAP32(p->fsd_mcs_list);
	p->fsd_fs_no = SWAP32(p->fsd_fs_no);
	p->fsd_fsd_no = SWAP32(p->fsd_fsd_no);
	ud_swap_long_ad(&p->fsd_root_icb);
	ud_swap_regid(&p->fsd_did);
	ud_swap_long_ad(&p->fsd_next);
}

/* ARGSUSED */
static void
ud_swap_term_desc(struct term_desc *p)
{
}

static void
ud_swap_file_id(struct file_id *p)
{
	p->fid_ver = SWAP16(p->fid_ver);
	ud_swap_long_ad(&p->fid_icb);
	p->fid_iulen = SWAP16(p->fid_iulen);
}

static void
ud_swap_alloc_ext(struct alloc_ext_desc *p)
{
	p->aed_rev_ael = SWAP32(p->aed_rev_ael);
	p->aed_len_aed = SWAP32(p->aed_len_aed);
}

static void
ud_swap_space_bitmap(struct space_bmap_desc *p)
{
	p->sbd_nbits = SWAP32(p->sbd_nbits);
	p->sbd_nbytes = SWAP32(p->sbd_nbytes);
}

static void
ud_swap_file_entry(struct file_entry *p, int32_t rdflag)
{
	int32_t i;
	short_ad_t *sap;
	long_ad_t *lap;

	/* Do Extended Attributes and Allocation Descriptors */
	if (rdflag) {
		p->fe_len_adesc = SWAP32(p->fe_len_adesc);
		p->fe_len_ear = SWAP32(p->fe_len_ear);
		ud_swap_icb_tag(&p->fe_icb_tag);
	}
	switch (p->fe_icb_tag.itag_flags & 0x3) {
	case ICB_FLAG_SHORT_AD:
		/* LINTED */
		sap = (short_ad_t *)(p->fe_spec + p->fe_len_ear);
		for (i = 0; i < p->fe_len_adesc / sizeof (short_ad_t);
			i++, sap++)
			ud_swap_short_ad(sap);
		break;
	case ICB_FLAG_LONG_AD:
		/* LINTED */
		lap = (long_ad_t *)(p->fe_spec + p->fe_len_ear);
		for (i = 0; i < p->fe_len_adesc / sizeof (long_ad_t);
			i++, lap++)
			ud_swap_long_ad(lap);
		break;
	case ICB_FLAG_EXT_AD:
		break;
	case ICB_FLAG_ONE_AD:
		break;
	}
	p->fe_uid = SWAP32(p->fe_uid);
	p->fe_gid = SWAP32(p->fe_gid);
	p->fe_perms = SWAP32(p->fe_perms);
	p->fe_lcount = SWAP16(p->fe_lcount);
	p->fe_rec_len = SWAP32(p->fe_rec_len);
	p->fe_info_len = SWAP64(p->fe_info_len);
	p->fe_lbr = SWAP64(p->fe_lbr);
	ud_swap_tstamp(&p->fe_acc_time);
	ud_swap_tstamp(&p->fe_mod_time);
	ud_swap_tstamp(&p->fe_attr_time);
	p->fe_ckpoint = SWAP32(p->fe_ckpoint);
	ud_swap_long_ad(&p->fe_ea_icb);
	ud_swap_regid(&p->fe_impl_id);
	p->fe_uniq_id = SWAP64(p->fe_uniq_id);
	if (!rdflag) {
		p->fe_len_adesc = SWAP32(p->fe_len_adesc);
		p->fe_len_ear = SWAP32(p->fe_len_ear);
		ud_swap_icb_tag(&p->fe_icb_tag);
	}
}

static void
ud_swap_tstamp(tstamp_t *tp)
{
	tp->ts_tzone = SWAP16(tp->ts_tzone);
	tp->ts_year = SWAP16(tp->ts_year);
}

void
setcharspec(struct charspec *cp, int32_t type, uint8_t *info)
{
	cp->cs_type = type;
	bzero(cp->cs_info, sizeof (cp->cs_info));
	(void) strncpy(cp->cs_info, (int8_t *)info, sizeof (cp->cs_info));
}

static unsigned short crctab[] = {
	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
	0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
	0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
	0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
	0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
	0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
	0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
	0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
	0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
	0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
	0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
	0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
	0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
	0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
	0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
	0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
	0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
	0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
	0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
	0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
	0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
	0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
	0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
	0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
	0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
	0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
	0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
	0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
	0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
	0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
	0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
	0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};

static uint16_t
crc16(uint8_t *buf, int32_t size, int32_t rem)
{
	uint16_t crc = 0;

	while (size-- > 0)
		crc = (crc << 8) ^ crctab[((crc >> 8) ^ *buf++) & 0xff];
	return ((crc ^ rem) & 0xffff);
}