Value::Value(int protocol_version,
const DataType::ConstPtr& data_type,
char* data, int32_t size)
: protocol_version_(protocol_version)
, data_type_(data_type) {
if (size > 0 && data_type->is_collection()) {
data_ = decode_size(protocol_version, data, count_);
if (protocol_version_ >= 3) {
size_ = size - sizeof(int32_t);
} else {
size_ = size - sizeof(uint16_t);
}
} else {
if (data_type->is_tuple()) {
SharedRefPtr<const CompositeType> composite_type(data_type);
count_ = composite_type->types().size();
} else if (data_type->is_user_type()) {
UserType::ConstPtr user_type(data_type);
count_ = user_type->fields().size();
} else {
count_ = 0;
}
data_ = data;
size_ = size;
}
}
enum sllp_err packet_process (sllp_instance_t *sllp,
struct sllp_raw_packet *recv_pkt,
struct sllp_raw_packet *send_pkt)
{
if(!sllp || !recv_pkt || !send_pkt)
return SLLP_ERR_PARAM_INVALID;
// Interpret packet payload as a message
struct raw_message *recv_raw_msg = (struct raw_message *) recv_pkt->data;
struct raw_message *send_raw_msg = (struct raw_message *) send_pkt->data;
// Create proper messages from the raw messages
struct message recv_msg, send_msg;
recv_msg.command_code = (enum command_code) recv_raw_msg->command_code;
recv_msg.payload_size = decode_size(recv_raw_msg->encoded_size);
recv_msg.payload = recv_raw_msg->payload;
send_msg.payload = send_raw_msg->payload;
// Check inconsistency between the size of the received data and the size
// specified in the message header
if(!is_size_ok(recv_pkt->len, recv_msg.payload_size))
message_set_answer(&send_msg, CMD_ERR_MALFORMED_MESSAGE);
else
message_process(sllp, &recv_msg, &send_msg);
send_raw_msg->command_code = send_msg.command_code;
send_raw_msg->encoded_size = encode_size(send_msg.payload_size);
send_pkt->len = send_msg.payload_size + 2;
return SLLP_SUCCESS;
}
int
verify_datatype_size(struct attropl * pattr, char **err_msg)
{
struct attribute atr;
atr.at_flags = 0;
return (decode_size(&atr, pattr->name, pattr->resource, pattr->value));
}
static int process_args(int argc, char **argv)
{
int c;
int option_index = 0;
while ((c = getopt_long(argc, argv, "vqe:nrhps:i:",
long_options, &option_index)) != -1) {
switch (c) {
case 'v':
opt_verbose = 1;
break;
case 'q':
opt_quiet = 1;
break;
case 'e':
strcpy(file_ext, ".");
strncat(file_ext, optarg, FILEEXT_LEN-1);
break;
case OPTION_GETRAWFB:
opt_write_fb = 1;
break;
case 'n':
opt_convert = 0;
opt_delete_raw = 0;
break;
case 'r':
opt_delete_raw = 0;
break;
case 'p':
opt_process_raw_input_only = 1;
opt_delete_raw = 0;
break;
case 's':
decode_size(optarg);
break;
case 'i':
get_vc = atol(optarg);
break;
case 'h':
usage();
exit(0);
default:
printf("Unknown option.\n");
usage();
exit(1);
}
}
return optind;
}
char* CollectionIterator::decode_value(char* position) {
int protocol_version = collection_->protocol_version();
int32_t size;
char* buffer = decode_size(protocol_version, position, size);
SharedRefPtr<const DataType> data_type;
if (collection_->value_type() == CASS_VALUE_TYPE_MAP) {
data_type = (index_ % 2 == 0) ? collection_->primary_data_type()
: collection_->secondary_data_type();
} else {
data_type = collection_->primary_data_type();
}
value_ = Value(protocol_version, data_type, buffer, size);
return buffer + size;
}
void
decode_event(DBusMessageIter *iter, int *err, alarm_event_t *eve)
{
size_t action_cnt = 0;
size_t recurrence_cnt = 0;
alarm_event_del_actions(eve);
alarm_event_del_recurrences(eve);
decode_cookie (iter, err, &eve->ALARMD_PRIVATE(cookie));
decode_time (iter, err, &eve->ALARMD_PRIVATE(trigger));
decode_dstring (iter, err, &eve->title);
decode_dstring (iter, err, &eve->message);
decode_dstring (iter, err, &eve->sound);
decode_dstring (iter, err, &eve->icon);
decode_unsigned (iter, err, &eve->flags);
decode_dstring (iter, err, &eve->alarm_appid);
decode_time (iter, err, &eve->alarm_time);
decode_tm (iter, err, &eve->alarm_tm);
decode_dstring (iter, err, &eve->alarm_tz);
decode_time (iter, err, &eve->recur_secs);
decode_int (iter, err, &eve->recur_count);
decode_time (iter, err, &eve->snooze_secs);
decode_time (iter, err, &eve->snooze_total);
decode_size (iter, err, &action_cnt);
decode_int (iter, err, &eve->response);
/* - - - - - - - - - - - - - - - - - - - *
* action table
* - - - - - - - - - - - - - - - - - - - */
alarm_action_t *act = alarm_event_add_actions(eve, action_cnt);
for( size_t i = 0; i < action_cnt; ++i )
{
decode_action(iter, err, &act[i]);
}
/* - - - - - - - - - - - - - - - - - - - *
* recurrence table
* - - - - - - - - - - - - - - - - - - - */
decode_size (iter, err, &recurrence_cnt);
alarm_recur_t *rec = alarm_event_add_recurrences(eve, recurrence_cnt);
for( size_t i = 0; i < recurrence_cnt; ++i )
{
decode_recur(iter, err, &rec[i]);
}
/* - - - - - - - - - - - - - - - - - - - *
* attribute table sent by libalarm >= 1.0.4
* - - - - - - - - - - - - - - - - - - - */
if( !decode_eom_p(iter, err) )
{
size_t count = 0;
decode_size (iter, err, &count);
for( size_t i = 0; i < count; ++i )
{
alarm_attr_t *att = alarm_event_add_attr(eve, "\x7f");
decode_attr(iter, err, att);
}
}
}
