void parse_oncore_shmem(char *buf, struct gps_status *gps) {
struct oncore_shmem o;
memcpy(&o, buf, sizeof(o));
gps->month = o.month;
gps->day = o.day;
gps->year = be16toh(o.year);
gps->hour = o.hour;
gps->minute = o.minute;
gps->second = o.second;
gps->flags = o.flags;
gps->visible = o.visible;
gps->tracking = o.tracking;
gps->ns = be32toh(o.ns);
gps->latitude = (int32_t)be32toh(o.latitude) * (1 / 3600000.0);
gps->longitude = (int32_t)be32toh(o.longitude) * (1 / 3600000.0);
gps->altitude = (int32_t)be32toh(o.altitude) / 100.0;
gps->heading = be16toh(o.heading) / 10.0;
gps->velocity = be16toh(o.velocity) / 100.0;
gps->dop = be16toh(o.dop) / 10.0;
gps->ant_uc = ((o.flags & (1<<7)) != 0);
gps->ant_oc = ((o.flags & (1<<6)) != 0);
gps->survey = ((o.flags & (1<<5)) != 0);
gps->dopmode = ((o.flags & 1) != 0) ? 2 : 3;
}
int usb_handle_packet(usb_t *self)
{
uint32_t cmd;
if (self->attached == 0)
{
/* only support metadata commands */
metadata_hdr_t hdr;
if (self->recv(&hdr, sizeof(hdr)) != sizeof(hdr))
return 0;
if (be16toh(hdr.version) != VERSION_CODE)
return 0;
const command_t *command = lookup_command((1<<31) | be16toh(hdr.command));
if (command == NULL)
return 0;
return command->handler(self, &hdr);
}
else
{
/* only support data commands */
data_hdr_t hdr;
if (self->recv(&hdr, sizeof(hdr)) != sizeof(hdr))
return 0;
const command_t *command = lookup_command(be32toh(hdr.command));
if (command == NULL)
return 0;
return command->handler(self, &hdr);
}
}
static vfnt_map_t *
load_vt4mappingtable(unsigned int nmappings, FILE *f)
{
vfnt_map_t *t;
unsigned int i;
if (nmappings == 0)
return (NULL);
if ((t = calloc(nmappings, sizeof(*t))) == NULL) {
warn("calloc");
return (NULL);
}
if (fread(t, sizeof *t * nmappings, 1, f) != 1) {
warn("read mappings");
free(t);
return (NULL);
}
for (i = 0; i < nmappings; i++) {
t[i].src = be32toh(t[i].src);
t[i].dst = be16toh(t[i].dst);
t[i].len = be16toh(t[i].len);
}
return (t);
}
void convert_packed(netinfo_packed_t *packed) {
int i;
packed->nbcpu = be32toh(packed->nbcpu);
packed->memory.ram_total = be64toh(packed->memory.ram_total);
packed->memory.ram_used = be64toh(packed->memory.ram_used);
packed->memory.swap_total = be64toh(packed->memory.swap_total);
packed->memory.swap_free = be64toh(packed->memory.swap_free);
for(i = 0; i < 3; i++)
packed->loadavg[i] = be32toh(packed->loadavg[i]);
packed->battery.charge_full = be32toh(packed->battery.charge_full);
packed->battery.charge_now = be32toh(packed->battery.charge_now);
packed->battery.status = be64toh(packed->battery.status);
packed->uptime.uptime = be32toh(packed->uptime.uptime);
packed->temp_cpu.critical = be16toh(packed->temp_cpu.critical);
packed->temp_cpu.cpu_average = be16toh(packed->temp_cpu.cpu_average);
packed->temp_hdd.peak = be16toh(packed->temp_hdd.peak);
packed->temp_hdd.hdd_average = be16toh(packed->temp_hdd.hdd_average);
packed->timestamp = be32toh(packed->timestamp);
}
static int
print_mappings(struct file_header *fh, int map_index)
{
struct file_mapping fm;
unsigned int nmappings, i, col = 0;
nmappings = be32toh(fh->map_count[map_index]);
if (nmappings == 0)
return (0);
printf("\nstatic struct vt_font_map font_mapping_%s[%u] = {",
map_names[map_index], nmappings);
for (i = 0; i < nmappings; i++) {
if (fread(&fm, sizeof fm, 1, stdin) != 1) {
perror("mapping");
return (1);
}
printf(col == 0 ? "\n\t" : " ");
printf("{ 0x%04x, 0x%04x, 0x%02x },",
be32toh(fm.source), be16toh(fm.destination),
be16toh(fm.length));
col = (col + 1) % 2;
}
printf("\n};\n");
return (0);
}
/* START FUNCTION DESCRIPTION ********************************************
xbee_disc_nd_parse <xbee_discovery.c>
SYNTAX:
int xbee_disc_nd_parse( xbee_node_id_t FAR *parsed, const void FAR *source)
DESCRIPTION:
Parse a Node Discovery response and store it in an xbee_node_id_t structure.
**************************************************************************/
int xbee_disc_nd_parse( xbee_node_id_t FAR *parsed, const void FAR *source)
{
int ni_len;
const xbee_node_id1_t FAR *id1;
const xbee_node_id2_t FAR *id2;
if (parsed == NULL || source == NULL)
{
return -EINVAL;
}
id1 = (const xbee_node_id1_t FAR *) source;
ni_len = strlen( id1->node_info);
if (ni_len > XBEE_DISC_MAX_NODEID_LEN)
{
return -EINVAL;
}
id2 = (const xbee_node_id2_t FAR *) &id1->node_info[ni_len + 1];
parsed->ieee_addr_be = id1->ieee_addr_be;
parsed->network_addr = be16toh( id1->network_addr_be);
parsed->parent_addr = be16toh( id2->parent_addr_be);
parsed->device_type = id2->device_type;
_f_memset( parsed->node_info, 0, sizeof(parsed->node_info));
_f_memcpy( parsed->node_info, id1->node_info, ni_len);
return 0;
}
static void discovery_read_raw(
struct disk *d, unsigned int tracknr, struct tbuf *tbuf)
{
struct track_info *ti = &d->di->track[tracknr];
uint16_t sum, val, *dat = (uint16_t *)ti->dat;
unsigned int i;
tbuf_bits(tbuf, SPEED_AVG, bc_raw, 16, dat[ti->len/2+2]);
val = (ti->type == TRKTYP_sword_sodan) ? 0 :
(ti->type == TRKTYP_hybris) ? 0 : dat[ti->len/2+2];
tbuf_bits(tbuf, SPEED_AVG, bc_mfm_even_odd, 16, val);
tbuf_bits(tbuf, SPEED_AVG, bc_mfm_even_odd, 16, dat[ti->len/2]);
tbuf_bits(tbuf, SPEED_AVG, bc_mfm_even_odd, 16, ti->len);
tbuf_bits(tbuf, SPEED_AVG, bc_mfm_even_odd, 16, dat[ti->len/2+1]);
tbuf_bytes(tbuf, SPEED_AVG, bc_mfm_even_odd, ti->len, dat);
tbuf_bits(tbuf, SPEED_AVG, bc_mfm_even_odd, 16, 0xdead);
sum = discovery_sum(be16toh(val), 0);
sum = discovery_sum(be16toh(dat[ti->len/2]), sum);
sum = discovery_sum(be16toh(ti->len), sum);
sum = discovery_sum(be16toh(dat[ti->len/2+1]), sum);
for (i = 0 ; i < ti->len/2; i++)
sum = discovery_sum(dat[i], sum);
sum = discovery_sum(be16toh(0xdead), sum);
tbuf_bits(tbuf, SPEED_AVG, bc_mfm_even_odd, 16, sum);
}
int lootr_tlv_next(lootr_tlv_ctx_t *ctx) {
uint16_t type, length;
uint8_t *p;
assert(ctx);
if (ctx->offset + 2 * sizeof(uint16_t) > ctx->msg_length) {
return 0;
}
p = ctx->msg + ctx->offset;
type = be16toh(*(uint16_t *)p);
p += sizeof(uint16_t);
length = be16toh(*(uint16_t *)p);
p += sizeof(uint16_t);
if (ctx->offset + 2 * sizeof(uint16_t) + length > ctx->msg_length) {
return -ESHORTBUF;
}
ctx->tlv.type = type;
ctx->tlv.length = length;
ctx->tlv.value = p;
ctx->offset += 2 * sizeof(uint16_t) + length;
return 1;
}
ProcessState * exec(ProcessState * myprocess, char * filename) {
int fd = open(filename, O_RDONLY);
//load header
char header[9];
read(fd, header, 8);
header[8] = '\0';
if(strcmp(header, "SIDECHAN") == 0){
// printf("SIDECHAN file detected\n");
} else {
return NULL;
}
//initialize ip and sp from top of file
read(fd, &(myprocess->registers.ip.reg), sizeof(uint16_t));
read(fd, &(myprocess->registers.sp.reg), sizeof(uint16_t));
myprocess->registers.ip.reg = be16toh(myprocess->registers.ip.reg);
myprocess->registers.sp.reg = be16toh(myprocess->registers.sp.reg);
int i;
for(i = 0; i < 65536 && read(fd, myprocess->mem + i, sizeof(char)) > 0; i++);
// printf("file load complete\n");
close(fd);
return myprocess;
}
static int
do_rx_iscsi_data(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
{
struct adapter *sc = iq->adapter;
struct cxgbei_data *ci = sc->iscsi_ulp_softc;
struct cpl_iscsi_data *cpl = mtod(m, struct cpl_iscsi_data *);
u_int tid = GET_TID(cpl);
struct toepcb *toep = lookup_tid(sc, tid);
struct icl_cxgbei_pdu *icp = toep->ulpcb2;
M_ASSERTPKTHDR(m);
MPASS(m->m_pkthdr.len == be16toh(cpl->len) + sizeof(*cpl));
/* Must already have received the header (but not the data). */
MPASS(icp != NULL);
MPASS(icp->icp_flags == ICPF_RX_HDR);
MPASS(icp->ip.ip_data_mbuf == NULL);
m_adj(m, sizeof(*cpl));
MPASS(icp->ip.ip_data_len == m->m_pkthdr.len);
icp->icp_flags |= ICPF_RX_FLBUF;
icp->ip.ip_data_mbuf = m;
counter_u64_add(ci->fl_pdus, 1);
counter_u64_add(ci->fl_bytes, m->m_pkthdr.len);
#if 0
CTR3(KTR_CXGBE, "%s: tid %u, cpl->len %u", __func__, tid,
be16toh(cpl->len));
#endif
return (0);
}
void read_mapdesc(int s)
{
mxbp_header_t header;
struct msghdr mh;
struct sockaddr_in addr;
struct iovec v[3];
int bytes;
memset(&addr, 0, sizeof(addr));
memset(&mh, 0, sizeof(mh));
memset(recvfilename, 0, FILENAMESIZE);
v[0].iov_base = &header;
v[0].iov_len = sizeof(header);
v[1].iov_base = &mapdesc;
v[1].iov_len = sizeof(mapdesc);
v[2].iov_base = recvfilename;
v[2].iov_len = FILENAMESIZE - 1;
mh.msg_name = &addr;
mh.msg_namelen = sizeof(addr);
mh.msg_iov = v;
mh.msg_iovlen = 3;
bytes = recvmsg(s, &mh, 0);
if (bytes < 0 || bytes < (sizeof(header) + sizeof(mapdesc))) {
printf("Bad receive: %d %s\n", bytes, strerror(errno));
printf("header.magic = 0x%08x\n", be32toh(header.magic));
printf("header.op = %u\n", be16toh(header.op));
printf("header.size = %u\n", be16toh(header.size));
printf("header.blockid = %u\n", be32toh(header.blockid));
printf("sizeof(header) == %ld\n", sizeof(header));
memset(&mapdesc, 0, sizeof(mapdesc));
return;
}
header.magic = be32toh(header.magic);
if (header.magic != MXBP_MAGIC) {
memset(&mapdesc, 0, sizeof(mapdesc));
return;
}
header.op = be16toh(header.op);
if (header.op != MXBP_BLOCKDESC) {
memset(&mapdesc, 0, sizeof(mapdesc));
return;
}
header.size = be16toh(header.size);
if (header.size > FILENAMESIZE - 1) {
printf
("Holy crap, we got a horrendous filename size of %d bytes, this can't be right.\n",
header.size);
memset(&mapdesc, 0, sizeof(mapdesc));
return;
}
mapdesc.filesize = be64toh(mapdesc.filesize);
mapdesc.blocksize = be32toh(mapdesc.blocksize);
mapdesc.nblocks = be32toh(mapdesc.nblocks);
}
static void *psygnosis_b_write_raw(
struct disk *d, unsigned int tracknr, struct stream *s)
{
struct track_info *ti = &d->di->track[tracknr];
char *block = memalloc(ti->len);
unsigned int j, k, nr_valid_blocks = 0;
while ((stream_next_bit(s) != -1) &&
(nr_valid_blocks != ti->nr_sectors)) {
uint16_t raw_dat[6*513];
uint32_t idx_off, new_valid = 0;
if ((uint16_t)s->word != 0x4489)
continue;
idx_off = s->index_offset_bc - 15;
if (stream_next_bits(s, 32) == -1)
goto done;
if (s->word != 0x552aaaaa)
continue;
for (j = 0; j < sizeof(raw_dat)/2; j++) {
uint32_t dat;
if (stream_next_bytes(s, &dat, 4) == -1)
goto done;
mfm_decode_bytes(bc_mfm_even_odd, 2, &dat, &raw_dat[j]);
}
for (j = 0; j < 6; j++) {
uint16_t *sec = &raw_dat[j*513];
uint16_t csum = be16toh(*sec++), c = 0;
for (k = 0; k < 512; k++)
c += be16toh(sec[k]);
if ((c == csum) && !is_valid_sector(ti, j)) {
memcpy(&block[j*1024], sec, 1024);
set_sector_valid(ti, j);
nr_valid_blocks++;
new_valid++;
}
}
if (new_valid)
ti->data_bitoff = idx_off;
}
done:
if (nr_valid_blocks == 0) {
free(block);
return NULL;
}
return block;
}
void parse_v6_hdr(struct rtas_v6_hdr *v6hdr, struct rtas_v6_hdr_raw *rawv6)
{
v6hdr->id[0] = rawv6->id[0];
v6hdr->id[1] = rawv6->id[1];
v6hdr->length = be16toh(rawv6->length);
v6hdr->version = rawv6->version;
v6hdr->subtype = rawv6->subtype;
v6hdr->creator_comp_id = be16toh(rawv6->creator_comp_id);
}
static struct container *eadf_open(struct disk *d)
{
struct disk_header dhdr;
struct track_header thdr;
struct disk_info *di;
struct track_info *ti;
unsigned int i;
lseek(d->fd, 0, SEEK_SET);
read_exact(d->fd, &dhdr, sizeof(dhdr));
if (strncmp(dhdr.sig, "UAE-1ADF", sizeof(dhdr.sig)))
return NULL;
d->di = di = memalloc(sizeof(*di));
di->nr_tracks = be16toh(dhdr.nr_tracks);
di->track = memalloc(di->nr_tracks * sizeof(struct track_info));
for (i = 0; i < di->nr_tracks; i++) {
ti = &di->track[i];
read_exact(d->fd, &thdr, sizeof(thdr));
thdr.type = be16toh(thdr.type);
if (thdr.type != 1) {
warnx("Bad track type %u in Ext-ADF", thdr.type);
goto cleanup_error;
}
init_track_info(ti, TRKTYP_raw);
ti->len = be32toh(thdr.len);
if (ti->len == 0) {
init_track_info(ti, TRKTYP_unformatted);
ti->total_bits = TRK_WEAK;
} else {
ti->dat = memalloc(ti->len);
ti->total_bits = be32toh(thdr.bitlen);
}
}
for (i = 0; i < di->nr_tracks; i++) {
ti = &di->track[i];
read_exact(d->fd, ti->dat, ti->len);
}
return &container_eadf;
cleanup_error:
for (i = 0; i < di->nr_tracks; i++)
memfree(di->track[i].dat);
memfree(di->track);
memfree(di);
d->di = NULL;
return NULL;
}
/*
* Map the ELF headers into the process' address space. We do this in two
* steps: first the ELF header itself and using that information the whole
* set of headers.
*/
static int
powerpc_maphdrs(kvm_t *kd)
{
struct vmstate *vm;
size_t mapsz;
vm = kd->vmst;
vm->mapsz = PAGE_SIZE;
vm->map = mmap(NULL, vm->mapsz, PROT_READ, MAP_PRIVATE, kd->pmfd, 0);
if (vm->map == MAP_FAILED) {
_kvm_err(kd, kd->program, "cannot map corefile");
return (-1);
}
vm->dmphdrsz = 0;
vm->eh = vm->map;
if (!valid_elf_header(vm->eh)) {
/*
* Hmmm, no ELF header. Maybe we still have a dump header.
* This is normal when the core file wasn't created by
* savecore(8), but instead was dumped over TFTP. We can
* easily skip the dump header...
*/
vm->dmphdrsz = dump_header_size(vm->map);
if (vm->dmphdrsz == 0)
goto inval;
vm->eh = (void *)((uintptr_t)vm->map + vm->dmphdrsz);
if (!valid_elf_header(vm->eh))
goto inval;
}
mapsz = be16toh(vm->eh->e_phentsize) * be16toh(vm->eh->e_phnum) +
be32toh(vm->eh->e_phoff);
munmap(vm->map, vm->mapsz);
/* Map all headers. */
vm->mapsz = vm->dmphdrsz + mapsz;
vm->map = mmap(NULL, vm->mapsz, PROT_READ, MAP_PRIVATE, kd->pmfd, 0);
if (vm->map == MAP_FAILED) {
_kvm_err(kd, kd->program, "cannot map corefle headers");
return (-1);
}
vm->eh = (void *)((uintptr_t)vm->map + vm->dmphdrsz);
vm->ph = (void *)((uintptr_t)vm->eh + be32toh(vm->eh->e_phoff));
return (0);
inval:
munmap(vm->map, vm->mapsz);
vm->map = MAP_FAILED;
_kvm_err(kd, kd->program, "invalid corefile");
return (-1);
}
/*
* Given a pointer to a command buffer and an offset into said buffer that
* should point to an entry in the auth area this function will return the
* number of bytes till the next auth entry.
*/
size_t
next_auth_offset (uint8_t *buffer)
{
UINT16 hash_size, auth_size;
size_t accumulator = 0;
accumulator += sizeof (UINT32); /* step over session handle */
hash_size = be16toh (*(UINT16*)(&buffer [accumulator])); /* get hash size */
accumulator += sizeof (UINT16) + hash_size; /* step over hash size & hash */
accumulator += sizeof (UINT8); /* step over session attributes */
auth_size = be16toh (*(UINT16*)(&buffer [accumulator])); /* get auth size */
accumulator += sizeof (UINT16) + auth_size; /* step over auth size + auth */
return accumulator;
}
/*** EndHeader */
int xbee_route_dump_record_indicator( xbee_dev_t *xbee,
const void FAR *frame, uint16_t length, void FAR *context)
{
const xbee_frame_route_record_indicator_t FAR *record = frame;
char buffer[ADDR64_STRING_LENGTH];
const uint16_t FAR *addr_be;
int i;
if (frame == NULL)
{
return -EINVAL;
}
if (record->address_count == 0
&& record->address_count > XBEE_ROUTE_MAX_ADDRESS_COUNT)
{
printf( "invalid address count, must be 1 to %u (not %u)\n",
XBEE_ROUTE_MAX_ADDRESS_COUNT, record->address_count);
}
else if (length ==
offsetof( xbee_frame_route_record_indicator_t, route_address_be) +
record->address_count * sizeof *record->route_address_be)
{
printf( "route record indicator from %" PRIsFAR " (0x%04X):\n",
addr64_format( buffer, &record->ieee_address),
be16toh( record->network_address_be));
if (record->receive_options & XBEE_RX_OPT_ACKNOWLEDGED)
{
printf( "acknowledged, ");
}
if (record->receive_options & XBEE_RX_OPT_BROADCAST)
{
printf( "broadcast, ");
}
printf( "\t%u addresses:\n\tdest -> ", record->address_count);
addr_be = record->route_address_be;
for (i = record->address_count; i; ++addr_be, --i)
{
printf( "0x%04X -> ", be16toh( *addr_be));
}
puts( "source");
return 0;
}
puts( "malformed route record indicator:");
hex_dump( frame, length, HEX_DUMP_FLAG_TAB);
return -EINVAL;
}
static void *puffys_saga_write_raw(
struct disk *d, unsigned int tracknr, struct stream *s)
{
struct track_info *ti = &d->di->track[tracknr];
while (stream_next_bit(s) != -1) {
uint16_t dat[2*2818], csum;
unsigned int i;
char *block;
if (s->word != 0x44894489)
continue;
ti->data_bitoff = s->index_offset - 31;
for (i = 0; i < 30; i++) {
if (stream_next_bits(s, 32) == -1)
goto fail;
if (mfm_decode_bits(bc_mfm, s->word))
break;
}
if (i != 30)
continue;
if (stream_next_bits(s, 16) == -1)
goto fail;
if ((uint16_t)s->word != 0x4444)
continue;
if (stream_next_bytes(s, dat, sizeof(dat)) == -1)
goto fail;
mfm_decode_bytes(bc_mfm, sizeof(dat)/2, dat, dat);
csum = 0;
for (i = 1; i < 2818; i++)
csum += be16toh(dat[i]);
if ((be16toh(dat[0]) != csum) || (be16toh(dat[1]) != (tracknr/2)))
continue;
block = memalloc(ti->len);
memcpy(block, &dat[2], ti->len);
set_all_sectors_valid(ti);
return block;
}
fail:
return NULL;
}
void parse_rtas_date(struct rtas_date *rtas_date,
struct rtas_date_raw *rawdate)
{
rtas_date->year = be16toh(rawdate->year);
rtas_date->month = rawdate->month;
rtas_date->day = rawdate->day;
}
/**
* parse_usr_hdr_scn
*
*/
int
parse_usr_hdr_scn(struct rtas_event *re)
{
struct rtas_usr_hdr_scn *usrhdr;
struct rtas_usr_hdr_scn_raw *rawhdr;
usrhdr = malloc(sizeof(*usrhdr));
if (usrhdr == NULL) {
errno = ENOMEM;
return -1;
}
memset(usrhdr, 0, sizeof(*usrhdr));
usrhdr->shdr.raw_offset = re->offset;
rawhdr = (struct rtas_usr_hdr_scn_raw *)(re->buffer + re->offset);
parse_v6_hdr(&usrhdr->v6hdr, &rawhdr->v6hdr);
usrhdr->subsystem_id = rawhdr->subsystem_id;
usrhdr->event_data = rawhdr->event_data;
usrhdr->event_severity = rawhdr->event_severity;
usrhdr->event_type = rawhdr->event_type;
usrhdr->action = be16toh(rawhdr->action);
re->offset += RE_USR_HDR_SCN_SZ;
add_re_scn(re, usrhdr, RTAS_USR_HDR_SCN);
return 0;
}
static int
getfutxent(struct futx *fu)
{
if (uf == NULL)
setutxent();
if (uf == NULL)
return (-1);
if (udb == UTXDB_LOG) {
uint16_t len;
if (fread(&len, sizeof(len), 1, uf) != 1)
return (-1);
len = be16toh(len);
if (len > sizeof *fu) {
/* Forward compatibility. */
if (fread(fu, sizeof(*fu), 1, uf) != 1)
return (-1);
fseek(uf, len - sizeof(*fu), SEEK_CUR);
} else {
/* Partial record. */
memset(fu, 0, sizeof(*fu));
if (fread(fu, len, 1, uf) != 1)
return (-1);
}
} else {
if (fread(fu, sizeof(*fu), 1, uf) != 1)
return (-1);
}
return (0);
}
int16_t readFlat16Integer(ContentBuffer & reader) {
int16_t value;
reader.prepare(2);
memcpy(&value, reader.content + reader.cursor, 2);
value = be16toh(value);
return value;
}
int mem_read(uint32_t addr, uint32_t *val, unsigned int bytes,
struct amiga_state *s)
{
struct memory *m = find_memory(s, addr, bytes);
if (m == NULL) {
log_warn("Read %u bytes non-RAM", bytes);
return M68KEMUL_UNHANDLEABLE;
*val = bytes == 1 ? 0xff : bytes == 2 ? 0xffff : 0xffffffff;
return M68KEMUL_OKAY;
}
addr -= m->start;
switch (bytes) {
case 1:
*val = *(uint8_t *)&m->dat[addr];
break;
case 2:
*val = be16toh(*(uint16_t *)&m->dat[addr]);
break;
case 4:
*val = be32toh(*(uint32_t *)&m->dat[addr]);
break;
default:
return M68KEMUL_UNHANDLEABLE;
}
return M68KEMUL_OKAY;
}
const char * umad_sa_mad_status_str(__be16 _status)
{
uint16_t status = be16toh(_status);
switch((status & UMAD_STATUS_CLASS_MASK) >> 8) {
case UMAD_SA_STATUS_SUCCESS:
return ("Success");
case UMAD_SA_STATUS_NO_RESOURCES:
return ("No Resources");
case UMAD_SA_STATUS_REQ_INVALID:
return ("Request Invalid");
case UMAD_SA_STATUS_NO_RECORDS:
return ("No Records");
case UMAD_SA_STATUS_TOO_MANY_RECORDS:
return ("Too Many Records");
case UMAD_SA_STATUS_INVALID_GID:
return ("Invalid GID");
case UMAD_SA_STATUS_INSUF_COMPS:
return ("Insufficient Components");
case UMAD_SA_STATUS_REQ_DENIED:
return ("Request Denied");
case UMAD_SA_STATUS_PRI_SUGGESTED:
return ("Priority Suggested");
}
return ("Undefined Error");
}
static bool is_close_frame(enum ws_status_code code)
{
const uint8_t *ptr = write_buffer;
uint8_t header;
::memcpy(&header, ptr, sizeof(header));
if ((header & WS_HEADER_FIN) != WS_HEADER_FIN) {
return false;
}
if ((header & WS_OPCODE_CLOSE) != WS_OPCODE_CLOSE) {
return false;
}
ptr += sizeof(header);
uint8_t length;
::memcpy(&length, ptr, sizeof(length));
if ((length & WS_HEADER_MASK) == WS_HEADER_MASK) {
return false;
}
if (length != 2) {
return false;
}
ptr += sizeof(length);
uint16_t status_code;
::memcpy(&status_code, ptr, sizeof(status_code));
status_code = be16toh(status_code);
if (status_code != code) {
return false;
}
return true;
}
// see xbee/device.h for documentation
xbee_wpan_debug
int _xbee_handle_transmit_status( xbee_dev_t *xbee,
const void FAR *payload, uint16_t length, void FAR *context)
{
#ifdef XBEE_DEVICE_VERBOSE
const xbee_frame_transmit_status_t FAR *frame = payload;
#else
XBEE_UNUSED_PARAMETER( payload);
#endif
// standard XBee frame handler; stub isn't using any parameters yet
XBEE_UNUSED_PARAMETER( xbee);
XBEE_UNUSED_PARAMETER( length);
XBEE_UNUSED_PARAMETER( context);
// it may be necessary to push information up to user code so they know when
// a packet has been received or if it didn't make it out
#ifdef XBEE_DEVICE_VERBOSE
xSerialxPrintf_P( &xSerial1Port, PSTR( "%s: id 0x%02x to 0x%04x retries=%d del=0x%02x disc=0x%02x\n"),
__FUNCTION__, frame->frame_id,
be16toh( frame->network_address_be), frame->retries, frame->delivery,
frame->discovery);
#endif
return 0;
}
static const char * umad_cm_attr_str(__be16 attr_id)
{
switch(be16toh(attr_id)) {
case UMAD_CM_ATTR_REQ:
return "ConnectRequest";
case UMAD_CM_ATTR_MRA:
return "MsgRcptAck";
case UMAD_CM_ATTR_REJ:
return "ConnectReject";
case UMAD_CM_ATTR_REP:
return "ConnectReply";
case UMAD_CM_ATTR_RTU:
return "ReadyToUse";
case UMAD_CM_ATTR_DREQ:
return "DisconnectRequest";
case UMAD_CM_ATTR_DREP:
return "DisconnectReply";
case UMAD_CM_ATTR_SIDR_REQ:
return "ServiceIDResReq";
case UMAD_CM_ATTR_SIDR_REP:
return "ServiceIDResReqResp";
case UMAD_CM_ATTR_LAP:
return "LoadAlternatePath";
case UMAD_CM_ATTR_APR:
return "AlternatePathResponse";
case UMAD_CM_ATTR_SAP:
return "SuggestAlternatePath";
case UMAD_CM_ATTR_SPR:
return "SuggestPathResponse";
default:
return (umad_common_attr_str(attr_id));
}
return ("<unknown>");
}
int sd_netlink_message_read_u16(sd_netlink_message *m, unsigned short type, uint16_t *data) {
void *attr_data;
bool net_byteorder;
int r;
assert_return(m, -EINVAL);
r = message_attribute_has_type(m, NULL, type, NETLINK_TYPE_U16);
if (r < 0)
return r;
r = netlink_message_read_internal(m, type, &attr_data, &net_byteorder);
if (r < 0)
return r;
else if ((size_t) r < sizeof(uint16_t))
return -EIO;
if (data) {
if (net_byteorder)
*data = be16toh(*(uint16_t *) attr_data);
else
*data = *(uint16_t *) attr_data;
}
return 0;
}
void put_status(uint8_t *data, size_t *decoder_rank)
{
auto hdr = header(data);
*decoder_rank = be16toh(hdr->rank);
m_coder->read_feedback(hdr->status);
}
int utf16_gb(const uint16_t *utf16, char *gb, size_t cnt, int endian)
{
int wc = 0; /* word count */
uint16_t utf_16; /* UTF-16 data */
uint16_t gb2; /* GB 2-byte data */
size_t max = sizeof(UCS_GB) / 4 - 1; /* high index */
while(cnt > 0) {
utf_16 = *utf16++;
utf_16 = (BIG_ENDIAN == endian) ? be16toh(utf_16) : le16toh(utf_16);
if((0xD800 <= utf_16) && (utf_16 <= 0xDFFF)) {
fprintf(stderr, "Unsupported UTF-16 data(0x%04X)!\n", utf_16);
break;
}
if(utf_16 == 0x0000) {
break;
}
else if(utf_16 <= 0x007F) {
*gb++ = (char)utf_16;
cnt -= 2;
}
else {
gb2 = half_search(utf_16, DFLT_GB, max, UCS_GB);
*gb++ = (char)(gb2 >> 8);
*gb++ = (char)(gb2 >> 0);
cnt -= 2;
}
wc++;
}
*gb = '\0';
return wc;
}
