/* decode the service request only */
int timesync_decode_service_request(
uint8_t * apdu,
unsigned apdu_len,
BACNET_DATE * my_date,
BACNET_TIME * my_time)
{
int len = 0;
uint8_t tag_number = 0;
uint32_t len_value = 0;
if (apdu_len && my_date && my_time) {
/* date */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number == BACNET_APPLICATION_TAG_DATE) {
len += decode_date(&apdu[len], my_date);
} else
return -1;
/* time */
len +=
decode_tag_number_and_value(&apdu[len], &tag_number, &len_value);
if (tag_number == BACNET_APPLICATION_TAG_TIME) {
len += decode_bacnet_time(&apdu[len], my_time);
} else
return -1;
}
return len;
}
//----------------------------------------------------------------
// Format routine
//----------------------------------------------------------------
void Fl_Date_Time::format_date (char *str) const {
char *ptr = str;
short month, day, year;
if (m_dateTime == 0) {
*str = 0;
return;
}
decode_date(m_dateTime,year,month,day);
for (int i = 0; i < 3; i++) {
switch (datePartsOrder[i]) {
case 'M': sprintf(ptr,"%02i%c",month,dateSeparator);
break;
case 'D': sprintf(ptr,"%02i%c",day,dateSeparator);
break;
case 'Y': sprintf(ptr,"%04i%c",year,dateSeparator);
break;
}
ptr += strlen(ptr);
}
*(ptr-1) = 0;
}
void Fl_Date_Time::decode_date(short *y,short *m,short *d) const {
decode_date(m_dateTime,*y,*m,*d);
}
short Fl_Date_Time::year() const {
short y, m, d;
decode_date(m_dateTime,y,m,d);
return y;
}
short Fl_Date_Time::month() const {
short y, m, d;
decode_date(m_dateTime,y,m,d);
return m;
}
short Fl_Date_Time::day() const {
short y, m, d;
decode_date(m_dateTime,y,m,d);
return d;
}
short Fl_Date_Time::days_in_month() const {
short y, m, d;
decode_date(m_dateTime,y,m,d);
return _monthDays[is_leap_year(y)][m-1];
}
void decode_cell(pTHX_ unsigned char *input, STRLEN len, STRLEN *pos, struct cc_type *type, SV *output)
{
unsigned char *bytes;
STRLEN bytes_len;
if (unpack_bytes(aTHX_ input, len, pos, &bytes, &bytes_len) != 0) {
sv_setsv(output, &PL_sv_undef);
return;
}
switch (type->type_id) {
case CC_TYPE_ASCII:
case CC_TYPE_CUSTOM:
case CC_TYPE_BLOB:
decode_blob(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_BOOLEAN:
decode_boolean(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_VARCHAR:
case CC_TYPE_TEXT:
decode_utf8(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_INET:
decode_inet(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_SET:
case CC_TYPE_LIST:
decode_list(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_UUID:
case CC_TYPE_TIMEUUID:
decode_uuid(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_FLOAT:
decode_float(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_DOUBLE:
decode_double(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_DECIMAL:
decode_decimal(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_VARINT:
case CC_TYPE_BIGINT:
case CC_TYPE_COUNTER:
case CC_TYPE_TIMESTAMP:
case CC_TYPE_SMALLINT:
case CC_TYPE_TINYINT:
case CC_TYPE_INT:
decode_varint(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_DATE:
decode_date(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_TIME:
decode_time(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_MAP:
decode_map(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_UDT:
decode_udt(aTHX_ bytes, bytes_len, type, output);
break;
case CC_TYPE_TUPLE:
decode_tuple(aTHX_ bytes, bytes_len, type, output);
break;
default:
sv_setsv(output, &PL_sv_undef);
warn("Decoder doesn't yet understand type %d, returning undef instead", type->type_id);
break;
}
}
static int do_element(deark *c, lctx *d, i64 pos1,
i64 nbytes_avail, i64 *bytes_used)
{
i64 ele_id;
i64 ele_dlen;
i64 pos = pos1;
int retval = 0;
const struct ele_id_info *einfo;
const char *ele_name;
int saved_indent_level;
unsigned int dtype;
int should_call_start_handler = 0;
int should_decode_default = 0;
int should_print_NOT_DECODING_msg = 0;
int should_call_end_handler = 0;
int len_ret;
char tmpbuf[80];
de_dbg_indent_save(c, &saved_indent_level);
de_dbg(c, "element at %"I64_FMT", max_len=%"I64_FMT, pos1, nbytes_avail);
de_dbg_indent(c, 1);
if(1!=get_var_size_int(c->infile, &ele_id, &pos, nbytes_avail)) {
de_err(c, "Failed to read ID of element at %"I64_FMT, pos1);
goto done;
}
einfo = find_ele_id_info(ele_id);
if(einfo && einfo->name)
ele_name = einfo->name;
else
ele_name = "?";
if(einfo)
dtype = einfo->flags & 0xff;
else
dtype = 0;
de_dbg(c, "id: 0x%"U64_FMTx" (%s)", (u64)ele_id, ele_name);
if(d->show_encoded_id) {
print_encoded_id(c, d, pos1, pos-pos1);
}
len_ret = get_var_size_int(c->infile, &ele_dlen, &pos, pos1+nbytes_avail-pos);
if(len_ret==1) {
de_snprintf(tmpbuf, sizeof(tmpbuf), "%"I64_FMT, ele_dlen);
}
else if(len_ret==2) {
ele_dlen = c->infile->len - pos;
de_strlcpy(tmpbuf, "unknown", sizeof(tmpbuf));
}
else {
de_err(c, "Failed to read length of element at %"I64_FMT, pos1);
goto done;
}
de_dbg(c, "data at %"I64_FMT", dlen=%s, type=%s", pos, tmpbuf,
get_type_name(dtype));
if(len_ret==2) {
// EBML does not have any sort of end-of-master-element marker, which
// presents a problem when a master element has an unknown length.
//
// EBML's "solution" is this:
// "The end of an Unknown-Sized Element is determined by whichever
// comes first: the end of the file or the beginning of the next EBML
// Element, defined by this document or the corresponding EBML Schema,
// that is not independently valid as Descendant Element of the
// Unknown-Sized Element."
//
// This would appear to require a sophisticated, high-level algorithm
// with 100% complete knowledge of the latest version of the specific
// application format. We do not have such an algorithm.
de_err(c, "EBML files with unknown-length elements are not supported");
goto done;
}
if(pos + ele_dlen > c->infile->len) {
de_err(c, "Element at %"I64_FMT" goes beyond end of file", pos1);
goto done;
}
if(einfo) {
should_decode_default = 1;
if(einfo->flags & 0x0200) {
should_decode_default = 0;
}
else if((einfo->flags & 0x0100) && c->debug_level<2) {
should_decode_default = 0;
should_print_NOT_DECODING_msg = 1;
}
}
if(should_decode_default && einfo && einfo->hfn) {
should_call_start_handler = 1;
}
if(should_decode_default && einfo && einfo->hfn && (einfo->flags & 0x0800)) {
should_call_end_handler = 1;
}
if(should_call_start_handler) {
struct handler_params hp;
de_zeromem(&hp, sizeof(struct handler_params));
hp.dpos = pos;
hp.dlen = ele_dlen;
einfo->hfn(c, d, &hp);
}
if(should_decode_default) {
switch(dtype) {
case TY_m:
do_element_sequence(c, d, pos, ele_dlen);
break;
case TY_u:
decode_uint(c, d, einfo, pos, ele_dlen);
break;
case TY_f:
decode_float(c, d, einfo, pos, ele_dlen);
break;
case TY_8:
decode_string(c, d, einfo, pos, ele_dlen, DE_ENCODING_UTF8);
break;
case TY_s:
decode_string(c, d, einfo, pos, ele_dlen, DE_ENCODING_PRINTABLEASCII);
break;
case TY_d:
decode_date(c, d, einfo, pos, ele_dlen);
break;
}
}
else {
if(should_print_NOT_DECODING_msg) {
de_dbg(c, "[not decoding this element]");
}
}
if(should_call_end_handler) {
struct handler_params hp;
de_zeromem(&hp, sizeof(struct handler_params));
hp.dpos = pos;
hp.dlen = ele_dlen;
hp.end_flag = 1;
einfo->hfn(c, d, &hp);
}
pos += ele_dlen;
*bytes_used = pos - pos1;
retval = 1;
done:
de_dbg_indent_restore(c, saved_indent_level);
return retval;
}
void TimeStamp::decode_timestamp(const ISC_TIMESTAMP ts, struct tm* times, int* fractions)
{
decode_date(ts.timestamp_date, times);
decode_time(ts.timestamp_time, ×->tm_hour, ×->tm_min, ×->tm_sec, fractions);
}