int get_head(struct protocol_head *head, void **p, int *left)
{
NEG_RET_LN(get_uint8(p, left, &head->result));
NEG_RET_LN(get_uint8(p, left, &head->command));
NEG_RET_LN(get_uint32(p, left, &head->sequence));
static void *echo_buf;
static size_t echo_buf_len;
int echo_len = 0;
NEG_RET_LN(echo_len = get_bin2(p, left, &echo_buf, &echo_buf_len));
head->echo_len = (uint16_t)echo_len;
head->echo = echo_buf;
return 0;
}
static void
test_util_format_unaligned_accessors(void *ignored)
{
(void)ignored;
char buf[9] = "onionsoup"; // 6f6e696f6e736f7570
tt_u64_op(get_uint64(buf+1), OP_EQ, htonll(U64_LITERAL(0x6e696f6e736f7570)));
tt_uint_op(get_uint32(buf+1), OP_EQ, htonl(0x6e696f6e));
tt_uint_op(get_uint16(buf+1), OP_EQ, htons(0x6e69));
tt_uint_op(get_uint8(buf+1), OP_EQ, 0x6e);
set_uint8(buf+7, 0x61);
tt_mem_op(buf, OP_EQ, "onionsoap", 9);
set_uint16(buf+6, htons(0x746f));
tt_mem_op(buf, OP_EQ, "onionstop", 9);
set_uint32(buf+1, htonl(0x78696465));
tt_mem_op(buf, OP_EQ, "oxidestop", 9);
set_uint64(buf+1, htonll(U64_LITERAL(0x6266757363617465)));
tt_mem_op(buf, OP_EQ, "obfuscate", 9);
done:
;
}
uint8 HCI_SET_EVENT_FILTER_T_PDU::get_filter_condition_type() const
{
if ( size() > HCI_SET_EVENT_FILTER_T_filter_condition_type )
return get_uint8 ( HCI_SET_EVENT_FILTER_T_filter_condition_type );
else
return 0xFF;
}
static void
test_routerkeys_rsa_ed_crosscert(void *arg)
{
(void)arg;
ed25519_public_key_t ed;
crypto_pk_t *rsa = pk_generate(2);
uint8_t *cc = NULL;
ssize_t cc_len;
time_t expires_in = 1470846177;
tt_int_op(0, OP_EQ, ed25519_public_from_base64(&ed,
"ThisStringCanContainAnythingSoNoKeyHereNowX"));
cc_len = tor_make_rsa_ed25519_crosscert(&ed, rsa, expires_in, &cc);
tt_int_op(cc_len, OP_GT, 0);
tt_int_op(cc_len, OP_GT, 37); /* key, expires, siglen */
tt_mem_op(cc, OP_EQ, ed.pubkey, 32);
time_t expires_out = 3600 * ntohl(get_uint32(cc+32));
tt_int_op(expires_out, OP_GE, expires_in);
tt_int_op(expires_out, OP_LE, expires_in + 3600);
tt_int_op(cc_len, OP_EQ, 37 + get_uint8(cc+36));
tt_int_op(0, OP_EQ, rsa_ed25519_crosscert_check(cc, cc_len, rsa, &ed,
expires_in - 10));
/* Now try after it has expired */
tt_int_op(-4, OP_EQ, rsa_ed25519_crosscert_check(cc, cc_len, rsa, &ed,
expires_out + 1));
/* Truncated object */
tt_int_op(-2, OP_EQ, rsa_ed25519_crosscert_check(cc, cc_len - 2, rsa, &ed,
expires_in - 10));
/* Key not as expected */
cc[0] ^= 3;
tt_int_op(-3, OP_EQ, rsa_ed25519_crosscert_check(cc, cc_len, rsa, &ed,
expires_in - 10));
cc[0] ^= 3;
/* Bad signature */
cc[40] ^= 3;
tt_int_op(-5, OP_EQ, rsa_ed25519_crosscert_check(cc, cc_len, rsa, &ed,
expires_in - 10));
cc[40] ^= 3;
/* Signature of wrong data */
cc[0] ^= 3;
ed.pubkey[0] ^= 3;
tt_int_op(-6, OP_EQ, rsa_ed25519_crosscert_check(cc, cc_len, rsa, &ed,
expires_in - 10));
cc[0] ^= 3;
ed.pubkey[0] ^= 3;
done:
crypto_pk_free(rsa);
tor_free(cc);
}
static
int _vlsctlc_unpack_cmd(struct vlsctlc* lsctlc, void* buf, int len)
{
struct vlsctlc_unpack_cmd_desc* desc = lsctlc_unpack_cmd_desc;
uint32_t magic = 0;
int tsz = 0;
int bsz = 0;
int csz = 0;
int ret = 0;
vassert(lsctlc);
vassert(buf);
vassert(len > 0);
tsz += sizeof(uint8_t); // skip version;
lsctlc->type = get_uint8(buf + tsz);
tsz += sizeof(uint8_t);
bsz = (int)get_uint16(buf + tsz);
tsz += sizeof(uint16_t);
magic = get_uint32(buf + tsz);
tsz += sizeof(uint32_t);
// _aux_vhexbuf_dump(buf, bsz);
if (magic != VLSCTL_MAGIC) {
return -1;
}
while(bsz - csz > 0) {
uint16_t cmd_id = 0;
int cmd_len = 0;
int i = 0;
cmd_id = get_uint16(buf + tsz);
tsz += sizeof(uint16_t);
csz += sizeof(uint16_t);
cmd_len = get_uint16(buf + tsz);
tsz += sizeof(uint16_t);
csz += sizeof(uint16_t);
lsctlc->bound_cmd = cmd_id;
while(cmd_len > 0) {
for (i = 0; desc[i].cmd; i++) {
ret = desc[i].cmd(lsctlc, buf + tsz, cmd_len);
if (ret < 0) {
return -1;
} else if (ret > 0) {
tsz += ret;
csz += ret;
cmd_len -= ret;
break;
}else {
//do nothing;
}
}
}
}
return 0;
}
int get_str1(void **buf, int *len, char **value, size_t *n)
{
GET_STR_ARG_CHECK;
uint8_t slen = 0;
if (get_uint8(buf, len, &slen) < 0)
return -2;
GET_STR(slen);
}
int get_bin1(void **buf, int *len, void **value, size_t *n)
{
GET_BIN_ARG_CHECK;
uint8_t blen = 0;
if (get_uint8(buf, len, &blen) < 0)
return -2;
GET_BIN(blen);
}
static ast::TransposeExp::Kind get_TransposeExp_Kind(void)
{
int code = get_uint8();
switch(code){
case 1 : return ast::TransposeExp::_Conjugate_;
case 2 : return ast::TransposeExp::_NonConjugate_;
}
std::cerr << "Unknown get_TransposeExp_Kind code " << code << std::endl;
exit(2);
}
void print_u8(cbuf_t* in, int n)
{
int i;
for (i = 0; i < n; i++) {
u_int8_t val;
get_uint8(in, &val);
printf("%u ", val);
}
printf("\n");
}
static ast::VarDec::Kind get_VarDec_Kind(void)
{
int code = get_uint8();
switch(code){
case 1 : return ast::VarDec::invalid_kind;
case 2 : return ast::VarDec::evaluation_kind;
case 3 : return ast::VarDec::assignment_kind;
}
std::cerr << "Unknown get_VarDec_Kind code " << code << std::endl;
exit(2);
}
static ast::IntExp::Prec get_IntExp_Prec(void)
{
int code = get_uint8();
switch(code){
case 1: return ast::IntExp::_8_;
case 2: return ast::IntExp::_16_;
case 3: return ast::IntExp::_32_;
case 4: return ast::IntExp::_64_;
}
std::cerr << "Unknown get_IntExp_Prec code " << code << std::endl;
exit(2);
}
static ast::IfExp::Kind get_IfExp_Kind(void)
{
int code = get_uint8();
switch(code){
case 1 : return ast::IfExp::invalid_kind ;
case 2 : return ast::IfExp::instruction_kind;
case 3 : return ast::IfExp::expression_kind;
case 4 : return (ast::IfExp::Kind)0;
}
std::cerr << "Unknown get_IfExp_Kind code " << code << std::endl;
exit(2);
}
bool HCI_SET_EVENT_FILTER_T_PDU::get_condition ( uint8& auto_accept_flag ) const
{
bool ok = (get_filter_type() == 2);
if ( ok )
{
switch ( get_filter_condition_type() )
{
case 0:
auto_accept_flag = get_uint8(HCI_SET_EVENT_FILTER_T_AAF_all );
break;
case 1:
auto_accept_flag = get_uint8(HCI_SET_EVENT_FILTER_T_AAF_COD );
break;
case 2:
auto_accept_flag = get_uint8(HCI_SET_EVENT_FILTER_T_AAF_BDA );
break;
default:
ok = false;
break;
}
}
return ok;
}
static ast::OpExp::Oper get_OpExp_Oper(void)
{
int code = get_uint8();
switch(code){
case 1 : return ast::OpExp::plus;
case 2 : return ast::OpExp::minus;
case 3 : return ast::OpExp::times;
case 4 : return ast::OpExp::rdivide;
case 5 : return ast::OpExp::ldivide;
case 6 : return ast::OpExp::power;
case 7 : return ast::OpExp::dottimes;
case 8 : return ast::OpExp::dotrdivide;
case 9 : return ast::OpExp::dotldivide;
case 10 : return ast::OpExp::dotpower;
case 11 : return ast::OpExp::krontimes;
case 12 : return ast::OpExp::kronrdivide;
case 13 : return ast::OpExp::kronldivide;
case 14 : return ast::OpExp::controltimes;
case 15 : return ast::OpExp::controlrdivide;
case 16 : return ast::OpExp::controlldivide;
case 17 : return ast::OpExp::eq;
case 18 : return ast::OpExp::ne;
case 19 : return ast::OpExp::lt;
case 20 : return ast::OpExp::le;
case 21 : return ast::OpExp::gt;
case 22 : return ast::OpExp::ge;
case 23 : return ast::OpExp::unaryMinus;
case 24 : return ast::OpExp::logicalAnd;
case 25 : return ast::OpExp::logicalOr;
case 26 : return ast::OpExp::logicalShortCutAnd;
case 27 : return ast::OpExp::logicalShortCutOr;
}
std::cerr << "Unknown get_OpExp_Oper code " << code << std::endl;
exit(2);
}
static
int _aux_vlsctlc_unpack_vaddr(void* buf, int len, struct vsockaddr_in* addr)
{
int tsz = 0;
vassert(addr);
vassert(buf);
vassert(len > 0);
memset(addr, 0, sizeof(*addr));
tsz += sizeof(uint8_t);
addr->addr.sin_family = get_uint8(buf + tsz);
tsz += sizeof(uint8_t);
addr->addr.sin_port = get_uint16(buf + tsz);
tsz += sizeof(uint16_t);
addr->addr.sin_addr.s_addr = get_uint32(buf + tsz);
tsz += sizeof(uint32_t);
addr->type = get_uint32(buf + tsz);
tsz += sizeof(uint32_t);
return tsz;
}
/** Check <b>buf</b> for a variable-length cell according to the rules of link
* protocol version <b>linkproto</b>. If one is found, pull it off the buffer
* and assign a newly allocated var_cell_t to *<b>out</b>, and return 1.
* Return 0 if whatever is on the start of buf_t is not a variable-length
* cell. Return 1 and set *<b>out</b> to NULL if there seems to be the start
* of a variable-length cell on <b>buf</b>, but the whole thing isn't there
* yet. */
int
fetch_var_cell_from_buf(buf_t *buf, var_cell_t **out, int linkproto)
{
char hdr[VAR_CELL_MAX_HEADER_SIZE];
var_cell_t *result;
uint8_t command;
uint16_t length;
const int wide_circ_ids = linkproto >= MIN_LINK_PROTO_FOR_WIDE_CIRC_IDS;
const int circ_id_len = get_circ_id_size(wide_circ_ids);
const unsigned header_len = get_var_cell_header_size(wide_circ_ids);
*out = NULL;
if (buf_datalen(buf) < header_len)
return 0;
buf_peek(buf, hdr, header_len);
command = get_uint8(hdr + circ_id_len);
if (!(cell_command_is_var_length(command, linkproto)))
return 0;
length = ntohs(get_uint16(hdr + circ_id_len + 1));
if (buf_datalen(buf) < (size_t)(header_len+length))
return 1;
result = var_cell_new(length);
result->command = command;
if (wide_circ_ids)
result->circ_id = ntohl(get_uint32(hdr));
else
result->circ_id = ntohs(get_uint16(hdr));
buf_drain(buf, header_len);
buf_peek(buf, (char*) result->payload, length);
buf_drain(buf, length);
*out = result;
return 1;
}
static ast::OpExp::Kind get_OpExp_Kind(void)
{
int code = get_uint8();
switch(code){
case 1 : return ast::OpExp::invalid_kind;
case 2 : return ast::OpExp::bool_kind;
case 3 : return ast::OpExp::string_kind;
case 4 : return ast::OpExp::integer_kind;
case 5 : return ast::OpExp::float_kind;
case 6 : return ast::OpExp::double_kind;
case 7 : return ast::OpExp::float_complex_kind;
case 8 : return ast::OpExp::double_complex_kind;
case 9 : return ast::OpExp::bool_matrix_kind;
case 10 : return ast::OpExp::string_matrix_kind;
case 11 : return ast::OpExp::integer_matrix_kind;
case 12 : return ast::OpExp::float_matrix_kind;
case 13 : return ast::OpExp::double_matrix_kind;
case 14 : return ast::OpExp::float_complex_matrix_kind;
case 15 : return ast::OpExp::double_complex_matrix_kind;
}
std::cerr << "Unknown get_OpExp_Kind code " << code << std::endl;
exit(2);
}
uint8 HCIEventPDU::get_parameter_length() const
{
return get_uint8(1) ;
}
uint8 HCIEventPDU::get_event_code() const
{
/* the event code is the first thing in the pdu */
return get_uint8(0) ;
}
uint8 BNEP_HCI_SWITCH_ROLE_RSP_T_PDU::get_status() const
{
return get_uint8 ( BNEP_HCI_SWITCH_ROLE_RSP_T_status );
}
static ast::Exp* get_exp(void)
{
ast::Exp* exp;
// std::cerr << "get_exp at pos " << (buf - initial_buf) << std::endl;
int code = get_uint8();
// std::cerr << " code = " << code << std::endl;
Location *loc = get_location();
int is_verbose = get_bool();
int is_break = get_bool();
int is_breakable = get_bool();
int is_return = get_bool();
int is_returnable = get_bool();
int is_continue = get_bool();
int is_continuable = get_bool();
switch(code){
case 1: {
std::list<ast::Exp *>* l_body = get_exps();
exp = new ast::SeqExp(*loc, *l_body);
break;
}
case 2: {
std::wstring* s = get_wstring();
exp = new ast::StringExp(*loc, *s);
break;
}
case 3: {
std::wstring* s = get_wstring();
exp = new ast::CommentExp(*loc, s);
break;
}
case 4: {
ast::IntExp::Prec prec = get_IntExp_Prec();
int value = get_int32();
exp = new ast::IntExp(*loc, prec, value);
break;
}
case 5: {
double d = get_double();
exp = new ast::FloatExp(*loc, d);
break;
}
case 6: {
double d = get_double();
exp = new ast::DoubleExp(*loc,d);
break;
}
case 7: {
bool b = get_bool();
exp = new ast::BoolExp(*loc, b);
break;
}
case 8: {
exp = new ast::NilExp(*loc);
break;
}
case 9: {
symbol::Symbol *name = get_Symbol();
exp = new ast::SimpleVar(*loc, *name);
break;
}
case 10: {
exp = new ast::ColonVar(*loc);
break;
}
case 11: {
exp = new ast::DollarVar(*loc);
break;
}
case 12: {
std::list<ast::Var*>* vars = get_vars();
exp = new ast::ArrayListVar(*loc, *vars);
break;
}
case 13: {
ast::Exp *head = get_exp();
ast::Exp *tail = get_exp();
exp = new ast::FieldExp(*loc, *head, *tail);
break;
}
case 14: {
ast::IfExp::Kind kind = get_IfExp_Kind();
bool has_else = get_bool();
ast::Exp* test = get_exp();
ast::Exp* _then = get_exp();
ast::IfExp* ifexp;
if( has_else ){
ast::Exp* _else = get_exp();
ifexp = new ast::IfExp(*loc, *test, *_then, *_else);
} else {
ifexp = new ast::IfExp(*loc, *test, *_then);
}
ifexp->kind_set(kind);
exp = ifexp;
break;
}
case 15: {
Location *try_location = get_location();
Location *catch_location = get_location();
std::list<ast::Exp *>* try_exps = get_exps();
std::list<ast::Exp *>* catch_exps = get_exps();
ast::SeqExp *_try = new ast::SeqExp(*try_location, *try_exps);
ast::SeqExp *_catch = new ast::SeqExp(*catch_location, *catch_exps);
exp = new ast::TryCatchExp(*loc, *_try, *_catch);
break;
}
case 16: {
ast::Exp* test = get_exp();
ast::Exp* body = get_exp();
exp = new ast::WhileExp(*loc, *test, *body);
break;
}
case 17: {
Location *vardec_location = get_location();
ast::VarDec* vardec = get_VarDec(vardec_location);
ast::Exp* body = get_exp();
exp = new ast::ForExp(*loc, *vardec, *body);
break;
}
case 18: {
exp = new ast::BreakExp(*loc);
break;
}
case 19: {
exp = new ast::ContinueExp(*loc);
break;
}
case 20: {
bool is_global = get_bool();
if( is_global ){
exp = new ast::ReturnExp(*loc);
} else {
ast::Exp* returnExp_exp = get_exp();
exp = new ast::ReturnExp(*loc, returnExp_exp);
}
break;
}
case 21: {
bool has_default = get_bool();
ast::SeqExp * default_case = NULL;
if( has_default ){
Location *default_case_location = get_location();
std::list<ast::Exp *>* default_case_exps = get_exps();
default_case = new ast::SeqExp(*default_case_location,
*default_case_exps);
}
ast::Exp* select = get_exp();
int nitems = get_uint32();
std::list<ast::CaseExp*> *cases = new std::list<ast::CaseExp*>;
for(int i = 0; i < nitems; i++){
Location *case_location = get_location();
Location *body_location = get_location();
ast::Exp* test = get_exp();
std::list<ast::Exp *>* body_exps = get_exps();
ast::SeqExp *body = new ast::SeqExp(*body_location, *body_exps);
ast::CaseExp* _case = new ast::CaseExp(*case_location, *test, *body);
cases->push_back(_case);
}
if( has_default ){
exp = new ast::SelectExp(*loc, *select, *cases, *default_case);
} else {
exp = new ast::SelectExp(*loc, *select, *cases);
}
break;
}
/* SHOULD NEVER HAPPEN
case 22: {
exp = new ast::CaseExp(*loc);
break;
}
*/
case 23: {
std::list<ast::MatrixLineExp *>* lines = get_MatrixLines();
exp = new ast::CellExp(*loc, *lines);
break;
}
case 24: {
std::list<ast::Exp *>* exps = get_exps();
exp = new ast::ArrayListExp(*loc, *exps);
break;
}
case 25: {
std::list<ast::Exp *>* exps = get_exps();
exp = new ast::AssignListExp(*loc, *exps);
break;
}
case 26: {
ast::Exp* notexp = get_exp();
exp = new ast::NotExp(*loc, *notexp);
break;
}
case 27: {
ast::TransposeExp::Kind kind = get_TransposeExp_Kind();
ast::Exp* _exp = get_exp();
exp = new ast::TransposeExp(*loc, *_exp, kind);
break;
}
case 28: {
exp = get_VarDec(loc);
break;
}
case 29: {
symbol::Symbol* name = get_Symbol();
Location *args_loc = get_location();
Location *returns_loc = get_location();
ast::Exp* body = get_exp();
std::list <ast::Var*>* args_list = get_vars();
std::list <ast::Var*>* returns_list = get_vars();
ast::ArrayListVar *args = new ast::ArrayListVar(*args_loc, *args_list);
ast::ArrayListVar *returns = new ast::ArrayListVar(*returns_loc, *returns_list);
exp = new ast::FunctionDec(*loc, *name, *args, *returns, *body);
break;
}
case 30: {
ast::Exp* _start = get_exp();
ast::Exp* _step = get_exp();
ast::Exp* _end = get_exp();
exp = new ast::ListExp(*loc, *_start, *_step, *_end);
break;
}
case 31: {
ast::Exp* _left = get_exp();
ast::Exp* _right = get_exp();
exp = new ast::AssignExp(*loc, *_left, *_right);
break;
}
case 32: {
ast::OpExp::Kind kind = get_OpExp_Kind();
ast::OpExp::Oper oper = get_OpExp_Oper();
ast::Exp *left = get_exp();
ast::Exp *right = get_exp();
ast::OpExp *_opexp = new ast::OpExp(*loc, *left, oper, *right);
exp = _opexp;
_opexp->kind_set(kind);
break;
}
case 33: {
ast::OpExp::Kind kind = get_OpExp_Kind();
ast::OpExp::Oper oper = get_OpExp_Oper();
ast::Exp *left = get_exp();
ast::Exp *right = get_exp();
ast::LogicalOpExp *_opexp =
new ast::LogicalOpExp(*loc, *left, oper, *right);
exp = _opexp;
_opexp->kind_set(kind);
break;
}
case 34: {
std::list<ast::MatrixLineExp *>* lines = get_MatrixLines();
exp = new ast::MatrixExp(*loc, *lines);
break;
}
case 35: {
ast::Exp* name = get_exp();
std::list<ast::Exp *> * args = get_exps();
exp = new ast::CallExp(*loc, *name, *args);
break;
}
/* SHOULD NEVER HAPPEN
case 36: {
exp = new ast::MatrixLineExp(*loc);
break;
}
*/
case 37: {
ast::Exp* name = get_exp();
std::list<ast::Exp *>* args = get_exps();
exp = new ast::CellCallExp(*loc, *name, *args);
break;
}
default:
std::cerr << "Unknown code " << code << std::endl;
exit(2);
}
exp->set_verbose(is_verbose);
if(is_break) exp->break_set();
if(is_breakable) exp->breakable_set();
if(is_return) exp->return_set();
if(is_returnable) exp->returnable_set();
if(is_continue) exp->continue_set();
if(is_continuable) exp->continuable_set();
return exp;
}
uint8 BNEP_HCI_SWITCH_ROLE_RSP_T_PDU::get_role() const
{
return get_uint8 ( BNEP_HCI_SWITCH_ROLE_RSP_T_role );
}
uint8 HCICommandCompletePDU::get_num_hci_command_pkts () const
{
return get_uint8 ( 2 );
}
uint8 HCICommandCompletePDU::get_status () const
{
return get_uint8(5) ;
}
static int
decode_data(double **data, const xmlChar * input, dataFormat data_format,
codingTypes coding, byteOrder byte_order, int max_input_len)
{
GArray *data_stream, *debase64_buf, *decoded_data;
char *p, *end_ptr;
unsigned int i;
double val;
int data_count = 0;
gwy_debug("start.");
if (input == NULL) {
g_warning("SPML: decode_data(): NULL input");
*data = NULL;
return 0;
}
switch (coding) {
case ZLIB_COMPR_BASE64:
/*/ XXX: strlen() may not be nice there */
if (decode_b64((char *)input, &debase64_buf, strlen(input)) != 0) {
if (debase64_buf != NULL) {
g_array_free(debase64_buf, TRUE);
}
g_warning("Cannot decode data in BASE64 code.");
*data = NULL;
return 0;
}
if (inflate_dynamic_array(debase64_buf, &data_stream) != 0) {
g_warning("Cannot inflate compressed data.");
g_array_free(debase64_buf, TRUE);
if (data_stream != NULL) {
g_array_free(data_stream, TRUE);
}
*data = NULL;
return 0;
}
g_array_free(debase64_buf, TRUE);
break;
case BASE64:
/*/ XXX: strlen() may not be nice there */
if (decode_b64((char *)input, &data_stream, strlen(input)) != 0) {
g_warning("Cannot decode data in BASE64 code.");
if (data_stream != NULL) {
g_array_free(data_stream, TRUE);
}
*data = NULL;
return 0;
}
break;
case ASCII:
p = (char *)input;
data_stream = g_array_new(FALSE, FALSE, sizeof(double));
while (p != NULL) {
double num;
if (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') {
p++;
continue;
}
num = g_ascii_strtod(p, &end_ptr);
if (num == 0 && end_ptr == p) {
g_warning("SPML: decode_data(): No conversion performed "
"from ASCII string.");
break;
}
g_array_append_val(data_stream, num);
p = end_ptr;
data_count++;
}
break;
/*/ TODO: */
case HEX:
case BINARY:
g_warning("SPML: decode_data(): Data coding 'HEX' and 'BINARY' "
"not supported.");
break;
case UNKNOWN_CODING:
break;
}
if (coding == ASCII) {
/* we have already decoded data */
if (max_input_len != -1 && data_count != max_input_len) {
/* not enough input data to fill array defined by length
* max_input_len */
g_warning("SPML: decode_data():\n"
"Input has not the same length as declared in "
"dimensions\n"
"(max:%d vs read:%d). Has the channel attribute\n"
"'channelReadMethodName'? The channel may be one\n"
"dimensional data used for axis values but not as\n"
"a source of data for Gwyddion.",
max_input_len, data_count);
g_array_free(data_stream, TRUE);
*data = NULL;
return 0;
}
else {
*data = (double *)data_stream->data;
/* we can free dynamic array, but not */
g_array_free(data_stream, FALSE);
/* containing data. */
gwy_debug("Datacount: %d", data_count);
return data_count;
}
}
decoded_data = g_array_new(FALSE, FALSE, sizeof(double));
p = data_stream->data;
i = 0;
switch (data_format) {
case FLOAT32:
while (i < data_stream->len) {
val = get_float32(&p, byte_order);
g_array_append_val(decoded_data, val);
data_count++;
i += sizeof(float);
}
break;
case FLOAT64:
while (i < data_stream->len) {
val = get_float64(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(double);
}
break;
case INT8:
while (i < data_stream->len) {
val = get_int8(&p);
g_array_append_val(decoded_data, val);
i += sizeof(gint8);
}
break;
case INT16:
while (i < data_stream->len) {
val = get_int16(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(gint16);
}
break;
case INT32:
while (i < data_stream->len) {
val = get_int32(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(gint32);
}
break;
case UINT32:
while (i < data_stream->len) {
val = get_uint32(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(guint32);
}
break;
case UINT8:
while (i < data_stream->len) {
val = get_uint8(&p);
g_array_append_val(decoded_data, val);
i += sizeof(guint8);
}
break;
case UINT16:
while (i < data_stream->len) {
val = get_uint16(&p, byte_order);
g_array_append_val(decoded_data, val);
i += sizeof(guint16);
}
break;
case STRING:
g_warning
("SPML: decode_data(): Data format 'String' not supported.");
break;
case UNKNOWN_DATAFORMAT:
g_warning("SPML: decode_data(): Unknown dataformat.");
break;
}
g_array_free(data_stream, TRUE);
data_count = decoded_data->len;
if (max_input_len != -1 && data_count != max_input_len) {
g_warning("SPML: decode_data():\n"
"Input has not the same length as declared in dimensions\n"
"(max:%d vs read:%d). Has the channel attribute\n"
"'channelReadMethodName'? The channel may be one\n"
"dimensional data used for axis values but not as\n"
"a source of data for Gwyddion.", max_input_len, data_count);
g_array_free(decoded_data, TRUE);
*data = NULL;
return 0;
}
*data = (double *)decoded_data->data;
g_array_free(decoded_data, FALSE); /* we can free dynamic array, but not */
/* containing data. */
gwy_debug("Datacount: %d", data_count);
return data_count;
}
uint8 HCI_HOST_NUM_COMPLETED_PACKETS_T_PDU::get_num_handles(void) const
{
return get_uint8(HCI_HOST_NUM_COMPLETED_PACKETS_T_num_handles) ;
}
uint8 HCI_WRITE_STORED_LINK_KEY_T_PDU::get_number_keys(void) const
{
return get_uint8(HCI_WRITE_STORED_LINK_KEY_T_number_keys) ;
}
uint8 HCI_SET_EVENT_FILTER_T_PDU::get_filter_type() const
{
return get_uint8 ( HCI_SET_EVENT_FILTER_T_filter_type );
}
uint8 HCI_WRITE_CURRENT_IAC_LAP_T_PDU::get_num_current_iac(void) const
{
return get_uint8(HCI_WRITE_CURRENT_IAC_LAP_T_num_current_iac) ;
}
BluetoothDeviceAddress HCIPDU::get_BluetoothDeviceAddress(uint16 offset) const
{
return BluetoothDeviceAddress ( get_uint16 ( offset + 4 ),
get_uint8 ( offset + 3 ),
get_uint24 ( offset ) ) ;
}
