Example #1
0
void
analyze_label_sector(uint8_t *sector, struct vdm_label **dl,
    struct vdm_boot_info **dbi)
{
	struct vdm_label *l;
	struct vdm_boot_info *bi;

	l = (struct vdm_label *)(sector + VDM_LABEL_OFFSET);
	if (betoh32(l->signature) != VDM_LABEL_SIGNATURE) {
		l = (struct vdm_label *)(sector + VDM_LABEL_OFFSET_ALT);
		if (betoh32(l->signature) != VDM_LABEL_SIGNATURE)
			l = NULL;
	}

	if (l != NULL) {
		bi = (struct vdm_boot_info *)
		    (sector + VDM_BLOCK_SIZE - sizeof *bi);
		if (betoh32(bi->signature) != VDM_LABEL_SIGNATURE)
			bi = NULL;
	} else
		bi = NULL;

	*dl = l;
	*dbi = bi;
}
Example #2
0
uint32_t
print_vdmpart_instance(uint8_t *buf, uint32_t size)
{
	struct vdit_vdmpart_instance entry;

	if (size < sizeof entry) {
		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
		    size, sizeof entry);
		return 0;
	}

	memcpy(&entry, buf, sizeof entry);
	entry.version = betoh16(entry.version);
	entry.start_blkno = betoh32(entry.start_blkno);
	entry.size = betoh32(entry.size);
	printf("\tvdmpart: version %02x", entry.version);
	print_vdit_instance_id(&entry.child_instance, " child");
	printf("\n");
	printf("\t\tstarting block %08x size %08x",
	    entry.start_blkno, entry.size);
	print_vdit_instance_id(&entry.remap_instance, " remap");
	printf("\n");

	return size - sizeof entry;
}
Example #3
0
uint32_t
get_vdit_size(int fd, uint32_t secno)
{
	uint8_t sector[VDM_BLOCK_SIZE];
	struct vdit_block_header *hdr;
	uint32_t cursize = 0;
	int kind = VDIT_BLOCK_HEAD_BE;

	for (;;) {
		read_sector(fd, secno, sector);
		hdr = (struct vdit_block_header *)sector;
		if (VDM_ID_KIND(&hdr->id) != kind) {
			printf("unexpected VDIT block kind "
			    "on sector %08x: %02x\n",
			    secno, VDM_ID_KIND(&hdr->id));
			return 0;
		}

		if (verbose)
			printf("sector %08x: vdit frag type %02x, length %04x, "
			    "next frag at %08x\n",
			    secno, VDM_ID_KIND(&hdr->id),
			    betoh16(hdr->chunksz), secno);

		cursize += betoh16(hdr->chunksz);
		if (betoh32(hdr->nextblk) == VDM_NO_BLK_NUMBER)
			break;

		secno = betoh32(hdr->nextblk);
		kind = VDIT_PORTION_HEADER_BLOCK;
	}

	return cursize;
}
Example #4
0
/*
 * Retrieves next node, skipping all the children nodes of the pointed node
 * if passed 0 wil return first node of the tree (root)
 */
void *
fdt_next_node(void *node)
{
	u_int32_t *ptr;

	if (!tree_inited)
		return NULL;

	ptr = node;

	if (!node) {
		ptr = tree.tree;
		return (betoh32(*ptr) == FDT_NODE_BEGIN) ? ptr : NULL;
	}

	if (betoh32(*ptr) != FDT_NODE_BEGIN)
		return NULL;

	ptr++;

	ptr = skip_node_name(ptr);
	ptr = skip_props(ptr);

	/* skip children */
	while (betoh32(*ptr) == FDT_NODE_BEGIN)
		ptr = fdt_next_node(ptr);

	return (betoh32(*ptr) == FDT_NODE_END) ? (ptr + 1) : NULL;
}
Example #5
0
void
report(int fd)
{
	uint8_t *vdit, *vdit2, *tmpvdit;
	size_t vditsize, vditsize2;
	struct vdm_label *dl;
	struct vdm_boot_info *bi;
	struct disklabel *lp;
	uint8_t sector[VDM_BLOCK_SIZE];
	struct vdit_block_header *hdr;

	read_sector(fd, VDM_LABEL_SECTOR, sector);
	analyze_label_sector(sector, &dl, &bi);

	if (dl == NULL)
		return;

	printf("label version %04x\n", betoh16(dl->version));

	if (bi != NULL)
		printf("disk boot info: start %08x size %08x version %08x\n",
		    betoh32(bi->boot_start),
		    betoh32(bi->boot_size), betoh32(bi->version));

	read_sector(fd, VDIT_SECTOR, sector);
	hdr = (struct vdit_block_header *)sector;
	if (VDM_ID_KIND(&hdr->id) != VDIT_BLOCK_HEAD_BE) {
		lp = (struct disklabel *)(sector + LABELOFFSET);
		if (lp->d_magic == DISKMAGIC && lp->d_magic2 == DISKMAGIC) {
			if (verbose)
				printf("no VDIT but a native OpenBSD label\n");
			return;
		}
		errx(3, "unexpected block kind on sector %08x: %02x",
		    1, VDM_ID_KIND(&hdr->id));
	}

	vdit = read_vdit(fd, 1, &vditsize);
	if (vdit != NULL) {
		tmpvdit = vdit;
		while (tmpvdit != NULL)
			tmpvdit = print_vdit_entry(tmpvdit);

		vdit2 = read_vdit(fd, betoh32(hdr->secondary_vdit), &vditsize2);
		if (vdit2 == NULL)
			printf("can't read backup VDIT\n");
		else {
			if (vditsize2 < vditsize) {
				printf("WARNING: backup VDIT is smaller "
				    "than main VDIT!\n");
				vditsize = vditsize2;
			}
			if (memcmp(vdit, vdit2, vditsize) != 0)
				printf("VDIT and backup VDIT differ!\n");
			free(vdit2);
		}

		free(vdit);
	}
}
Example #6
0
/*
 * Retrieves node property, the returned pointer is inside the fdt tree,
 * so we should not modify content pointed by it directly.
 * A NULL out parameter will cause this function to only return the size.
 */
int
fdt_node_property(void *node, char *name, char **out)
{
	u_int32_t *ptr;
	u_int32_t nameid;
	char *tmp;

	if (!tree_inited)
		return 0;

	ptr = (u_int32_t *)node;

	if (betoh32(*ptr) != FDT_NODE_BEGIN)
		return 0;

	ptr = skip_node_name(ptr + 1);

	while (betoh32(*ptr) == FDT_PROPERTY) {
		nameid = betoh32(*(ptr + 2)); /* id of name in strings table */
		tmp = fdt_get_str(nameid);
		if (!strcmp(name, tmp)) {
			if (out != NULL)
				*out = (char *)(ptr + 3); /* begining of the value */
			return betoh32(*(ptr + 1)); /* size of value */
		}
		ptr = skip_property(ptr);
	}
	return 0;
}
Example #7
0
void
ikev1_recv(struct iked *env, struct iked_message *msg)
{
	struct ike_header	*hdr;

	if (ibuf_size(msg->msg_data) <= sizeof(*hdr)) {
		log_debug("%s: short message", __func__);
		return;
	}

	hdr = (struct ike_header *)ibuf_data(msg->msg_data);

	log_debug("%s: header ispi %s rspi %s"
	    " nextpayload %u version 0x%02x exchange %u flags 0x%02x"
	    " msgid %u length %u", __func__,
	    print_spi(betoh64(hdr->ike_ispi), 8),
	    print_spi(betoh64(hdr->ike_rspi), 8),
	    hdr->ike_nextpayload,
	    hdr->ike_version,
	    hdr->ike_exchange,
	    hdr->ike_flags,
	    betoh32(hdr->ike_msgid),
	    betoh32(hdr->ike_length));

	log_debug("%s: IKEv1 not supported", __func__);
}
Example #8
0
int
ikev2_pld_parse(struct iked *env, struct ike_header *hdr,
    struct iked_message *msg, off_t offset)
{
	log_debug("%s: header ispi %s rspi %s"
	    " nextpayload %s version 0x%02x exchange %s flags 0x%02x"
	    " msgid %d length %d response %d", __func__,
	    print_spi(betoh64(hdr->ike_ispi), 8),
	    print_spi(betoh64(hdr->ike_rspi), 8),
	    print_map(hdr->ike_nextpayload, ikev2_payload_map),
	    hdr->ike_version,
	    print_map(hdr->ike_exchange, ikev2_exchange_map),
	    hdr->ike_flags,
	    betoh32(hdr->ike_msgid),
	    betoh32(hdr->ike_length),
	    msg->msg_response);

	if (ibuf_size(msg->msg_data) < betoh32(hdr->ike_length)) {
		log_debug("%s: short message", __func__);
		return (-1);
	}

	offset += sizeof(*hdr);

	return (ikev2_pld_payloads(env, msg, offset,
	    betoh32(hdr->ike_length), hdr->ike_nextpayload, 0));
}
Example #9
0
void
read_file(void)
{
    FILE *fp;
    int i;

    if (!quiet)
        printf("Reading file %s\n", vfilename);
    for (i = 0; i < SGI_SIZE_VOLDIR; ++i) {
        if (strncmp(vfilename, volhdr->voldir[i].name,
                    strlen(volhdr->voldir[i].name)) == 0)
            break;
    }
    if (i >= SGI_SIZE_VOLDIR)
        errx(1, "%s: file not found", vfilename);
    /* XXX assumes volume header starts at 0? */
    lseek(fd, betoh32(volhdr->voldir[i].block) * DEV_BSIZE, SEEK_SET);
    if ((fp = fopen(ufilename, "w")) == NULL)
        err(1, "open %s", ufilename);
    i = betoh32(volhdr->voldir[i].bytes);
    while (i > 0) {
        if (read(fd, buf, bufsize) != bufsize)
            err(1, "read file");
        fwrite(buf, 1, i > bufsize ? bufsize : i, fp);
        i -= i > bufsize ? bufsize : i;
    }
    fclose(fp);
}
Example #10
0
int handle_msg_vault(void *data, unsigned int n)
{
    uint8_t cmd;
    uint32_t id;

    if (n < 1)
        return 0;

    cmd = *(uint8_t *)data;
    n--;
    data++;

    if (cmd == 1) /* LIST */
    {
        int i;
        uint32_t *buf = malloc(the_vault->num_contents * 8);
        if (buf == NULL)
        {
            write_msg(1, NULL, 0);
        }
        else
        {
            for (i = 0; i < the_vault->num_contents; i++)
            {
                buf[i * 2] = htobe32((uint32_t)&the_vault->contents[i]);
                buf[i * 2 + 1] = htobe32(the_vault->contents[i].len);
            }
            
            write_msg(1, buf, the_vault->num_contents * 8);
            free(buf);
        }
    }
    else if (cmd == 2) /* STORE */
    {
        id = htobe32(store_in_vault(0, data, n));
        write_msg(2, &id, sizeof(uint32_t));
    }
    else if (cmd == 3 && n >= 4) /* UPDATE */
    {
        id = betoh32(*(uint32_t *)data);
        id = htobe32(store_in_vault(id, data + 4, n - 4));
        write_msg(3, &id, sizeof(uint32_t));
    }
    else if (cmd == 4 && n >= 4) /* RETRIEVE */
    {
        void *outdata;
        unsigned int len;
        id = betoh32(*(uint32_t *)data);
        outdata = retrieve_from_vault(id, &len);
        if (outdata == NULL)
            write_msg(4, NULL, 0);
        else
            write_msg(4, outdata, len);
        free(outdata);
    }

    return 1;
}
Example #11
0
/**
 * Initializes a property object from its database data
 *
 * The property's id should be set before it is initialized
 *
 * Args:
 *      self: The property being initialized
 *      data: An array of bytes that represent this property in the database (17 bytes)
 *
 * Returns: FABRIC_OK on success, other error code on failure
 */
error_t Fabric_Property_init(Property *self, uint8_t *data) {
    // A Propery's id must be set externally
    if (self->id < 1) {
        return FABRIC_PROPERTY_INVALID_ID;
    }
    self->label_id = betoh32(*(labelid_t*)(data));
    self->next_property_id = betoh32(*(propertyid_t*)(data + 4));
    self->type = data[8];
    memcpy(&self->data, (data + 9), 8);

    return FABRIC_OK;
}
Example #12
0
File: nm.c Project: McIkye/tools
/*
 * show_symtab()
 *	show archive ranlib index (fs5)
 */
int
show_symtab(off_t off, u_long len, const char *name, FILE *fp)
{
	struct ar_hdr ar_head;
	int *symtab, *ps;
	char *strtab, *p;
	int num, rval = 0;
	int namelen;

	if ((symtab = malloc(len)) == NULL) {
		warn("%s: malloc", name);
		return 1;
	}

	if (pread(fileno(fp), symtab, len, off) != len) {
		free(symtab);
		warn("%s: pread", name);
		return 1;
	}

	namelen = sizeof(ar_head.ar_name);
	if ((p = malloc(sizeof(ar_head.ar_name))) == NULL) {
		warn("%s: malloc", name);
		free(symtab);
		return 1;
	}

	printf("\nArchive index:\n");
	num = betoh32(*symtab);
	strtab = (char *)(symtab + num + 1);
	for (ps = symtab + 1; num--; ps++, strtab += strlen(strtab) + 1) {
		if (pread(fileno(fp), &ar_head, sizeof ar_head,
		    betoh32(*ps)) != sizeof ar_head ||
		    memcmp(ar_head.ar_fmag, ARFMAG, sizeof(ar_head.ar_fmag))) {
			warnx("%s: member pread", name);
			rval = 1;
			break;
		}

		*p = '\0';
		if (mmbr_name(&ar_head, &p, 0, &namelen, fp)) {
			rval = 1;
			break;
		}

		printf("%s in %s\n", strtab, p);
	}

	free(p);
	free(symtab);
	return (rval);
}
Example #13
0
void
print_vdit_instance_id(struct vdit_instance_id *buf, const char *descr)
{
	struct vdit_instance_id instance;

	memcpy(&instance, buf, sizeof instance);
	instance.generation_timestamp = betoh32(instance.generation_timestamp);
	instance.system_id = betoh32(instance.system_id);
	if (instance.generation_timestamp != 0 || instance.system_id != 0 ||
	    verbose)
		printf("%s id %08x:%08x",
		    descr, instance.generation_timestamp, instance.system_id);
}
Example #14
0
unsigned int
fdt_check_head(void *fdt)
{
	struct fdt_head *fh;
	u_int32_t *ptr;

	fh = fdt;
	ptr = (u_int32_t *)fdt;

	if (betoh32(fh->fh_magic) != FDT_MAGIC)
		return 0;

	if (betoh32(fh->fh_version) > FDT_CODE_VERSION)
		return 0;

	if (betoh32(*(ptr + (betoh32(fh->fh_struct_off) / 4))) != FDT_NODE_BEGIN)
		return 0;

#ifdef notyet
	/* check for end signature on version 17 blob */
	if ((betoh32(fh->fh_version) >= 17) & (betoh32(*(ptr + (betoh32(fh->fh_struct_off) / 4) + (betoh32(fh->fh_struct_size) / 4))) != FDT_END))
		return 0;
#endif

	return betoh32(fh->fh_version);
}
Example #15
0
/*
 * Debug methods for printing whole tree, particular odes and properies
 */
void *
fdt_print_property(void *node, int level)
{
	u_int32_t *ptr;
	char *tmp, *value;
	int cnt;
	u_int32_t nameid, size;

	ptr = (u_int32_t *)node;

	if (!tree_inited)
		return NULL;

	if (betoh32(*ptr) != FDT_PROPERTY)
		return ptr; /* should never happen */

	/* extract property name_id and size */
	size = betoh32(*++ptr);
	nameid = betoh32(*++ptr);

	for (cnt = 0; cnt < level; cnt++)
		printf("\t");

	tmp = fdt_get_str(nameid);
	printf("\t%s : ", tmp ? tmp : "NO_NAME");

	ptr++;
	value = (char *)ptr;

	if (!strcmp(tmp, "device_type") || !strcmp(tmp, "compatible") ||
	    !strcmp(tmp, "model") || !strcmp(tmp, "bootargs") ||
	    !strcmp(tmp, "linux,stdout-path")) {
		printf("%s", value);
	} else if (!strcmp(tmp, "clock-frequency") ||
	    !strcmp(tmp, "timebase-frequency")) {
		printf("%d", betoh32(*((unsigned int *)value)));
	} else {
		for (cnt = 0; cnt < size; cnt++) {
			if ((cnt % sizeof(u_int32_t)) == 0)
				printf(" ");
			printf("%02x", value[cnt]);
		}
	}
	ptr += roundup(size, sizeof(u_int32_t)) / sizeof(u_int32_t);
	printf("\n");

	return ptr;
}
Example #16
0
uint32_t
print_vdit_instance_info(uint8_t *buf, uint32_t size)
{
	struct vdit_instance_entry entry;
	vdit_id_t id;

	if (size < sizeof entry) {
		printf("\tTRUNCATED ENTRY (%02x bytes, expected %02zx)\n",
		    size, sizeof entry);
		return 0;
	}

	memcpy(&entry, buf, sizeof entry);
	entry.version = betoh16(entry.version);
	printf("\tinstance: version %02x name \"%s\"\n",
	    entry.version, entry.name);
	memcpy(&id, &entry.subdriver_id, sizeof id);
	id = betoh32(id);
	printf("\t\tsubdriver id %08x", id);
	print_vdit_instance_id(&entry.instance_id, "");
	printf(" export %d\n", entry.exported);

	if (id == subdriver_vdmphys_id)
		return print_vdmphys_instance(buf, size);
	if (id == subdriver_vdmpart_id)
		return print_vdmpart_instance(buf, size);
	if (id == subdriver_vdmaggr_id)
		return print_vdmaggr_instance(buf, size);
	if (id == subdriver_vdmremap_id)
		return print_vdmremap_instance(buf, size);

	return size - sizeof entry;
}
Example #17
0
/* file should be in full USB packet format (ubertooth-dump -f) */
int stream_rx_file(FILE* fp, uint16_t num_blocks, rx_callback cb, void* cb_args)
{
	uint8_t bank = 0;
	uint8_t buf[BUFFER_SIZE];
	size_t nitems;

	/* unused parameter */ num_blocks = num_blocks;

        /*
	fprintf(stderr, "reading %d blocks of 64 bytes from file\n", num_blocks);
	*/

	while(1) {
		uint32_t systime_be;
		nitems = fread(&systime_be, sizeof(systime_be), 1, fp);
		if (nitems != 1)
			return 0;
		systime = (time_t)betoh32(systime_be);

		nitems = fread(buf, sizeof(buf[0]), PKT_LEN, fp);
		if (nitems != PKT_LEN)
			return 0;
		(*cb)(cb_args, (usb_pkt_rx *)buf, bank);
		bank = (bank + 1) % NUM_BANKS;
	}
}
Example #18
0
void
register_subdriver(uint8_t *buf)
{
	struct vdit_subdriver_entry entry;
	vdit_id_t id, *regid;

	memcpy(&entry, buf, sizeof entry);
	entry.version = betoh16(entry.version);
	memcpy(&id, &entry.subdriver_id, sizeof id);
	id = betoh32(id);

	if (strcmp(entry.name, VDM_SUBDRIVER_VDMPHYS) == 0)
		regid = &subdriver_vdmphys_id;
	else if (strcmp(entry.name, VDM_SUBDRIVER_VDMPART) == 0)
		regid = &subdriver_vdmpart_id;
	else if (strcmp(entry.name, VDM_SUBDRIVER_VDMAGGR) == 0)
		regid = &subdriver_vdmaggr_id;
	else if (strcmp(entry.name, VDM_SUBDRIVER_VDMREMAP) == 0)
		regid = &subdriver_vdmremap_id;
	else
		regid = NULL;

	if (regid != NULL) {
		if (*regid != 0)
			printf("WARNING: subdriver \"%s\" overriden\n",
			    entry.name);
		*regid = id;
	}
}
Example #19
0
void *
skip_props(u_int32_t *ptr)
{
	while (betoh32(*ptr) == FDT_PROPERTY) {
		ptr = skip_property(ptr);
	}
	return ptr;
}
Example #20
0
/* Read an unsigned 32-bit integer from a big-endian file. */
int read_uint32be(int fd, uint32_t* buf)
{
  size_t n;

  n = read(fd, (char*) buf, 4);
  *buf = betoh32(*buf);
  return n;
}
Example #21
0
UInt32 ByteOrder::ntoh32(UInt32 data)
{
#ifndef ANDROID
   return be32toh(data);
#else
   return betoh32(data);
#endif //ANDROID
}
Example #22
0
static int readInt() {
	int ret = *(int*)(s_data + s_pos);
	if(s_bigEndian)
		ret = betoh32(ret);
	else
		ret = letoh32(ret);
	s_pos += sizeof(int);
	return ret;
}
Example #23
0
int
cksum(int ck, int *p, int size)
{
	/* we assume size is int-aligned */
	for (size = (size + sizeof(int) - 1) / sizeof(int); size--; p++ )
		ck += betoh32(*p);

	return ck;
}
Example #24
0
/**
 * Initializes a text object from it's stored data
 *
 * This does not initialize the text objects text value.
 * the text value must be set separately.  The reason
 * for this is that it may be expensive in terms of
 * memory to load the text's value, and there are
 * situations in which it is sufficient to only load
 * the size.
 *
 * The text objects id should be set before this method
 * is used.
 *
 * Args:
 *      self: The text object being initialized
 *      data: The text object's header (4 bytes)
 *
 * Returns: FABRIC_OK on success, other error number of failure
 */
error_t Fabric_Text_init(Text *self, uint8_t *data) {
    if (self->id < 1) {
        return FABRIC_TEXT_INVALID_ID;
    }
    self->size = betoh32(*(uint32_t*)data);
    // The value isn't loaded at initialization time
    // It must be set externally
    self->value = NULL;
    return FABRIC_OK;
}
Example #25
0
int
scsi_cmd(struct scsi_state *s, void *cdb_p, size_t len)
{
	union scsi_cdb *cdb = cdb_p;
	enum scsi_cmd cmd;
	size_t alloc_len;

	if (len < 1)
		goto error;

	cmd = cdb->op;
	switch (cmd) {
	case SCSI_CMD_TEST_UNIT_READY:
		break;

	case SCSI_CMD_INQUIRY:
		if (len < sizeof(cdb->inquiry))
			goto error;
		if (cdb->inquiry.evpd || cdb->inquiry.page != 0)
			goto error;
		scsi_queue_send_data(s, s->inquiry, sizeof(*s->inquiry),
				     betoh16(&cdb->inquiry.alloc_len));
		break;

	case SCSI_CMD_REQUEST_SENSE:
		scsi_queue_send_data(s, &s->sense, sizeof(s->sense), cdb->request_sense.alloc_len);
		break;

	case SCSI_CMD_READ_CAPACITY_10:
                scsi_queue_send_data(s, &s->read_capacity, sizeof(s->read_capacity),
				     sizeof(s->read_capacity));
                break;

	case SCSI_CMD_READ_10:
        case SCSI_CMD_WRITE_10:
                s->cmd_lba = betoh32(&cdb->read_write_10.lba);
		s->cmd_len = betoh16(&cdb->read_write_10.length);
                if (s->cmd_lba > s->read_capacity.lba ||
		    s->cmd_lba + s->cmd_len > s->read_capacity.lba) {
			s->cmd_len = 0;
			goto error;
		}
		if (cmd == SCSI_CMD_READ_10)
			s->dir = SCSI_STATE_DIR_RECV;
		else
			s->dir = SCSI_STATE_DIR_SEND;
		break;
        }

	return (0);

error:
	s->sense.sense_key = SCSI_SENSE_ILLEGAL_REQUEST;
	return (-1);
}
Example #26
0
/*
 * Return the size of the FDT.
 */
u_int32_t
fdt_get_size(void *fdt)
{
	if (!fdt)
		return 0;

	if (!fdt_check_head(fdt))
		return 0;

	return betoh32(((struct fdt_head *)fdt)->fh_size);
}
Example #27
0
/*
 * Utility functions for skipping parts of tree.
 */
void *
skip_property(u_int32_t *ptr)
{
	u_int32_t size;

	size = betoh32(*(ptr + 1));
	/* move forward by magic + size + nameid + rounded up property size */
	ptr += 3 + roundup(size, sizeof(u_int32_t)) / sizeof(u_int32_t);

	return ptr;
}
Example #28
0
/*
 * Retrieves next node, skipping all the children nodes of the pointed node
 */
void *
fdt_child_node(void *node)
{
	u_int32_t *ptr;

	if (!tree_inited)
		return NULL;

	ptr = node;

	if (betoh32(*ptr) != FDT_NODE_BEGIN)
		return NULL;

	ptr++;

	ptr = skip_node_name(ptr);
	ptr = skip_props(ptr);
	/* check if there is a child node */
	return (betoh32(*ptr) == FDT_NODE_BEGIN) ? (ptr) : NULL;
}
Example #29
0
int
get_media_capabilities(int *cap)
{
	scsireq_t scr;
	u_char buf[4096];
	int error;
	u_int32_t i, dsz;
	u_int16_t feature;

	*cap = 0;
	memset(buf, 0, sizeof(buf));
	memset(&scr, 0, sizeof(scr));

	scr.cmd[0] = SCSI_GET_CONFIGURATION;
	scr.cmd[1] = 1;	/* enumerate only "current" features */
	*(u_int16_t *)(scr.cmd + 7) = betoh16(sizeof(buf));

	scr.flags = SCCMD_ESCAPE | SCCMD_READ;
	scr.databuf = buf;
	scr.datalen = sizeof(buf);
	scr.cmdlen = 10;
	scr.timeout = 120000;
	scr.senselen = SENSEBUFLEN;

	error = ioctl(fd, SCIOCCOMMAND, &scr);
	if (error == -1 || scr.retsts != 0)
		return (-1);
	if (scr.datalen_used < 8)
		return (-1);	/* can't get header */

	dsz = betoh32(*(u_int32_t *)buf);
	if (dsz > scr.datalen_used - 4)
		dsz = scr.datalen_used - 4;

	dsz += 4;	/* total size of bufer for all features */
	i = 8;
	while (i <= dsz - 4) {
		if (dsz - i < (u_int32_t)buf[i + 3] + 4)
			break;	/* partial feature descriptor */
		feature = betoh16(*(u_int16_t *)(buf + i));

		if (feature == MMC_FEATURE_CDRW_CAV)
			*cap |= MEDIACAP_CDRW_CAV;
		else if (feature == MMC_FEATURE_CD_TAO)
			*cap |= MEDIACAP_TAO;
		else if (feature == MMC_FEATURE_CDRW_WRITE)
			*cap |= MEDIACAP_CDRW_WRITE;

		i += 4 + buf[i + 3];
	}

	return (0);
}
Example #30
0
void
checksum_vol(void)
{
    int32_t *l;
    int i;

    volhdr->checksum = checksum = 0;
    l = (int32_t *)buf;
    for (i = 0; i < sizeof(struct sgilabel) / sizeof(int32_t); ++i)
        checksum += betoh32(l[i]);
    volhdr->checksum = htobe32(-checksum);
}