int dcnids_decode_header(struct nids_header_st *nheader){
/*
* This function returns the same error codes as nids_verify_header(),
* namely 0, or a positive error code indicative of the failure.
*/
int status;
unsigned char *b;
int n;
struct tm tm;
/* Go past the wmo header and to the start of the awips line */
b = nheader->buffer;
b += CTRLHDR_WMO_SIZE;
for(n = 0; n < WMO_AWIPS_SIZE; ++n)
nheader->awipsid[n] = tolower(*b++);
nheader->awipsid[WMO_AWIPS_SIZE] = '\0';
/* Go past the the wmo and awips headers */
b = nheader->buffer;
b += WMOAWIPS_HEADER_SIZE;
nheader->m_code = extract_uint16(b, 1);
nheader->m_days = extract_uint16(b, 2) - 1;
nheader->m_seconds = extract_uint32(b, 3);
/* msglength is the file length without headers or trailers */
nheader->m_msglength = extract_uint32(b, 5);
nheader->m_source = extract_uint16(b, 7);
nheader->m_destination = extract_uint16(b, 8);
nheader->m_numblocks = extract_uint16(b, 9);
nheader->pdb_divider = extract_int16(b, 10);
nheader->pdb_lat = extract_int32(b, 11);
nheader->pdb_lon = extract_int32(b, 13);
nheader->pdb_height = extract_uint16(b, 15);
nheader->pdb_code = extract_uint16(b, 16); /* same as m_code */
nheader->pdb_mode = extract_uint16(b, 17);
nheader->pdb_version = extract_uint8(b, 54);
nheader->pdb_symbol_block_offset = extract_uint32(b, 55) * 2;
nheader->pdb_graphic_block_offset = extract_uint32(b, 57) * 2;
nheader->pdb_tabular_block_offset = extract_uint32(b, 59) * 2;
/* derived */
nheader->lat = ((double)nheader->pdb_lat)/1000.0;
nheader->lon = ((double)nheader->pdb_lon)/1000.0;
nheader->unixseconds = nheader->m_days * 24 * 3600 + nheader->m_seconds;
(void)gmtime_r(&nheader->unixseconds, &tm);
nheader->year = tm.tm_year + 1900;
nheader->month = tm.tm_mon + 1;
nheader->day = tm.tm_mday;
nheader->hour = tm.tm_hour;
nheader->min = tm.tm_min;
nheader->sec = tm.tm_sec;
status = nids_verify_pdb_header(nheader);
return(status);
}
bool
UNPACK_VALUE(serial_context *ser_cont, as_val **value)
{
int32_t type = READ_CHAR(ser_cont->fd, ser_cont->line_no, ser_cont->col_no, ser_cont->bytes);
if (type == EOF) {
err("Error while reading value type");
return false;
}
switch (type) {
case 0xc0: // nil
return unpack_nil(ser_cont, value);
case 0xc3: // boolean true
return unpack_boolean(ser_cont, true, value);
case 0xc2: // boolean false
return unpack_boolean(ser_cont, false, value);
case 0xca: { // float
float tmp;
return extract_float(ser_cont, &tmp) && unpack_double(ser_cont, tmp, value);
}
case 0xcb: { // double
double tmp;
return extract_double(ser_cont, &tmp) && unpack_double(ser_cont, tmp, value);
}
case 0xd0: { // signed 8 bit integer
int8_t tmp;
return extract_uint8(ser_cont, (uint8_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xcc: { // unsigned 8 bit integer
uint8_t tmp;
return extract_uint8(ser_cont, &tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xd1: { // signed 16 bit integer
int16_t tmp;
return extract_uint16(ser_cont, (uint16_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xcd: { // unsigned 16 bit integer
uint16_t tmp;
return extract_uint16(ser_cont, &tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xd2: { // signed 32 bit integer
int32_t tmp;
return extract_uint32(ser_cont, (uint32_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xce: { // unsigned 32 bit integer
uint32_t tmp;
return extract_uint32(ser_cont, &tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xd3: { // signed 64 bit integer
int64_t tmp;
return extract_uint64(ser_cont, (uint64_t *)&tmp) && unpack_integer(ser_cont, tmp, value);
}
case 0xcf: { // unsigned 64 bit integer
uint64_t tmp;
return extract_uint64(ser_cont, &tmp) && unpack_integer(ser_cont, (int64_t)tmp, value);
}
case 0xc4:
case 0xd9: { // raw bytes with 8 bit header
uint8_t size;
return extract_uint8(ser_cont, &size) && unpack_blob(ser_cont, size, value);
}
case 0xc5:
case 0xda: { // raw bytes with 16 bit header
uint16_t size;
return extract_uint16(ser_cont, &size) && unpack_blob(ser_cont, size, value);
}
case 0xc6:
case 0xdb: { // raw bytes with 32 bit header
uint32_t size;
return extract_uint32(ser_cont, &size) && unpack_blob(ser_cont, size, value);
}
case 0xdc: { // list with 16 bit header
uint16_t size;
return extract_uint16(ser_cont, &size) && unpack_list(ser_cont, size, value);
}
case 0xdd: { // list with 32 bit header
uint32_t size;
return extract_uint32(ser_cont, &size) && unpack_list(ser_cont, size, value);
}
case 0xde: { // map with 16 bit header
uint16_t size;
return extract_uint16(ser_cont, &size) && unpack_map(ser_cont, size, value);
}
case 0xdf: { // map with 32 bit header
uint32_t size;
return extract_uint32(ser_cont, &size) && unpack_map(ser_cont, size, value);
}
default:
if ((type & 0xe0) == 0xa0) { // raw bytes with 8 bit combined header
return unpack_blob(ser_cont, type & 0x1f, value);
}
if ((type & 0xf0) == 0x80) { // map with 8 bit combined header
return unpack_map(ser_cont, type & 0x0f, value);
}
if ((type & 0xf0) == 0x90) { // list with 8 bit combined header
return unpack_list(ser_cont, type & 0x0f, value);
}
if (type < 0x80) { // 8 bit combined unsigned integer
return unpack_integer(ser_cont, type, value);
}
if (type >= 0xe0) { // 8 bit combined signed integer
return unpack_integer(ser_cont, type - 0xe0 - 32, value);
}
return false;
}
}
