int tsdp_header_serialize(const tsdp_header_t *self, tsk_buffer_t *output)
{
static char name;
int ret = -1;
if(!self || !output) {
return -1;
}
/* Name */
name = tsdp_header_get_nameex(self);
tsk_buffer_append_2(output, "%c=", name);
/* Value */
if((ret = self->tostring(self, output))) {
// Abort?
}
/* CRLF*/
if(output->size>2) {
if(*(TSK_BUFFER_TO_U8(output)+TSK_BUFFER_SIZE(output)-2) != '\r'
&& *(TSK_BUFFER_TO_U8(output)+TSK_BUFFER_SIZE(output)-1) != '\n') {
ret = tsk_buffer_append(output, "\r\n", 2);
}
}
else {
ret = tsk_buffer_append(output, "\r\n", 2);
}
return ret;
}
/** Serializes a QName.
*/
int tnet_dns_rr_qname_serialize(const char* qname, tsk_buffer_t* output)
{
/*
QNAME a domain name represented as a sequence of labels, where
each label consists of a length octet followed by that
number of octets. The domain name terminates with the
zero length octet for the null label of the root. Note
that this field may be an odd number of octets; no
padding is used.
Example: "doubango.com" ==> 8doubango3comNULL
*/
static uint8_t null = 0;
if(qname){
char* _qname = tsk_strdup(qname);
char* label = strtok(_qname, ".");
while(label){
uint8_t length = tsk_strlen(label);
tsk_buffer_append(output, &length, 1);
tsk_buffer_append(output, label, tsk_strlen(label));
label = strtok (tsk_null, ".");
}
TSK_FREE(_qname);
}
/* terminates domain name */
tsk_buffer_append(output, &null, 1);
return 0;
}
int tnet_dhcp_option_serializeex(tnet_dhcp_option_code_t code, uint8_t length, const void* value, tsk_buffer_t *output)
{
if(value && length && output){
tsk_buffer_append(output, &(code), 1);
tsk_buffer_append(output, &(length), 1);
tsk_buffer_append(output, value, length);
return 0;
}
return -1;
}
/**@ingroup tnet_stun_group
* Pads a STUN attribute to align it on 4 octets.
* @param attribute The STUN attribute to pad.
* @param output The output buffer into which to put zeros.
*/
void tnet_stun_attribute_pad(const tnet_stun_attribute_t* attribute, tsk_buffer_t *output)
{
if(attribute->length%4){
static uint32_t zeros = 0x00000000;
tsk_buffer_append(output, &zeros, 4-(attribute->length%4));
}
}
/*=======================================================================================
* RFC 2132 - 9.8. Parameter Request List
*=======================================================================================*/
int tnet_dhcp_option_paramslist_add_code(tnet_dhcp_option_paramslist_t* self, tnet_dhcp_option_code_t code)
{
if(self){
if(!TNET_DHCP_OPTION(self)->value){
TNET_DHCP_OPTION(self)->value = tsk_buffer_create_null();
}
return tsk_buffer_append(TNET_DHCP_OPTION(self)->value, &code, 1);
}
return -1;
}
int tnet_dhcp6_option_serialize(const tnet_dhcp6_option_t* self, tsk_buffer_t *output)
{
uint16_t _2bytes;
int ret = -1;
if(!self || !output){
goto bail;
}
/*== Code */
_2bytes = tnet_htons(self->code);
tsk_buffer_append(output, &(_2bytes), 2);
switch(self->code){
case dhcp6_code_clientid:
case dhcp6_code_serverid:
{
break;
}
case dhcp6_code_oro:
default:
{
if(self->data)
{
const tnet_dhcp6_option_orequest_t* opt = (const tnet_dhcp6_option_orequest_t*)self->data;
if(opt->codes){
/* option-len */
_2bytes = tnet_htons((unsigned short)opt->codes->size);
tsk_buffer_append(output, &(_2bytes), 2);
/* option-data */
ret = tsk_buffer_append(output, opt->codes->data, opt->codes->size);
}
}
break;
}
}
bail:
return ret;
}
int tnet_dhcp_option_serialize(const tnet_dhcp_option_t* self, tsk_buffer_t *output)
{
if(!self || !output){
return -1;
}
/* Code */
tsk_buffer_append(output, &(self->code), 1);
if(self->value){
/* Length */
tsk_buffer_append(output, &(self->value->size), 1);
/* Value */
tsk_buffer_append(output, self->value->data, self->value->size);
}
else{
/* Length */
static uint8_t zero = 0x00;
tsk_buffer_append(output, &zero, 1);
}
return 0;
}
int tnet_dhcp6_option_orequest_add_code(tnet_dhcp6_option_orequest_t* self, uint16_t code)
{
uint16_t _2bytes;
int ret = -1;
if(self){
if(!self->codes){
if(!(self->codes = tsk_buffer_create_null())){
return -3;
}
}
_2bytes = tnet_ntohs(code);
if(!(ret = tsk_buffer_append(self->codes, &_2bytes, 2))){
TNET_DHCP6_OPTION(self)->len += 2;
}
}
return ret;
}
/** internal function used to serialize a SMS-DELIVER message. */
int _tsms_tpdu_deliver_serialize(const tsms_tpdu_deliver_t* self, tsk_buffer_t* output)
{
uint8_t _1byte;
if(!self){
return -1;
}
/* SMSC address */
#if TSMS_TPDU_APPEND_SMSC
tsms_address_serialize(self->smsc, output);
#endif
/* SMS-DELIVER first Octect:
- TP-Message-Type-Indicator(2b)
- TP-More-Messages-to-Send(1b)
- TP-Loop-Prevention(1b)
- TP-Reply-Path(1b)
- TP-User-Data-Header-Indicator(1b)
- TP-Status-Report-Indication(1b)
+----+----+----+----+----+----+----+----+
| RP|UDHI|SRI | |LP |MMS | MTI |
+----+----+----+----+----+----+----+----+
*/
_1byte = (TSMS_TPDU_MESSAGE(self)->mti & 0xF3); /*2b*/
_1byte |= ((uint8_t)self->mms) << 2 /*1b*/
| ((uint8_t)self->lp) << 3 /*1b*/
/*1b (unused)*/
| ((uint8_t)self->sri) << 5 /*1b*/
| ((uint8_t)self->udhi) << 6 /*1b*/
| ((uint8_t)self->rp) << 7; /*1b*/
tsk_buffer_append(output, &_1byte, 1);
/* 3GPP TS 23.040 ==> TP-Originating-Address (TP-OA)*/
tsms_address_serialize(self->oa, output);
/* 3GPP TS 23.040 ==> 9.2.3.9 TP-Protocol-Identifier (TP-PID)*/
tsk_buffer_append(output, &TSMS_TPDU_MESSAGE(self)->pid, 1); /*1o*/
/* 3GPP TS 23.040 ==> 9.2.3.10 TP-Data-Coding-Scheme (TP-DCS)*/
tsk_buffer_append(output, &TSMS_TPDU_MESSAGE(self)->dcs, 1); /*1o*/
/* 3GPP TS 23.040 ==> TP-Service-Centre-Time-Stamp (TP-SCTS)*/
tsk_buffer_append(output, self->scts, sizeof(self->scts)); /*7o*/
/* 3GPP TS 23.040 ==> 9.2.3.16 TP-User-Data-Length (TP-UDL) */
tsk_buffer_append(output, &TSMS_TPDU_MESSAGE(self)->udl, 1); /*1o*/
/* 3GPP TS 23.040 ==> 9.2.3.24 TP-User Data (TP-UD) */
tsk_buffer_append(output, TSK_BUFFER_DATA(TSMS_TPDU_MESSAGE(self)->ud), TSK_BUFFER_SIZE(TSMS_TPDU_MESSAGE(self)->ud));
return 0;
}
int tmsrp_header_serialize(const tmsrp_header_t *self, tsk_buffer_t *output)
{
int ret = -1;
if(!self || !output){
return -1;
}
/* Name */
tsk_buffer_append_2(output, "%s: ", tmsrp_header_get_nameex(self));
/* Value */
if((ret = self->tostring(self, output))){
// Abort?
}
/* CRLF*/
ret = tsk_buffer_append(output, "\r\n", 2);
return ret;
}
int tmsrp_data_in_put(tmsrp_data_in_t* self, const void* pdata, tsk_size_t size)
{
int ret = -1;
if(!self || !self->buffer || !pdata || !size){
TSK_DEBUG_ERROR("Invalid parameter");
return ret;
}
if((ret = tsk_buffer_append(self->buffer, pdata, size))){
TSK_DEBUG_ERROR("Failed to append data");
tsk_buffer_cleanup(self->buffer);
return ret;
}
else{
if(TSK_BUFFER_SIZE(self->buffer) > TMSRP_DATA_IN_MAX_BUFFER){
tsk_buffer_cleanup(self->buffer);
TSK_DEBUG_ERROR("Too many bytes are waiting.");
return -3;
}
}
return ret;
}
int tsk_hmac_xxxcompute(const uint8_t* input, tsk_size_t input_size, const char* key, tsk_size_t key_size, tsk_hash_type_t type, uint8_t* digest)
{
#define TSK_MAX_BLOCK_SIZE TSK_SHA1_BLOCK_SIZE
tsk_size_t i, newkey_size;
tsk_size_t block_size = type == md5 ? TSK_MD5_BLOCK_SIZE : TSK_SHA1_BLOCK_SIZE; // Only SHA-1 and MD5 are supported for now
tsk_size_t digest_size = type == md5 ? TSK_MD5_DIGEST_SIZE : TSK_SHA1_DIGEST_SIZE;
char hkey [TSK_MAX_BLOCK_SIZE];
uint8_t ipad [TSK_MAX_BLOCK_SIZE];
uint8_t opad [TSK_MAX_BLOCK_SIZE];
memset(ipad, 0, sizeof(ipad));
memset(opad, 0, sizeof(ipad));
/*
* H(K XOR opad, H(K XOR ipad, input))
*/
// Check key len
if (key_size > block_size){
if(type == md5){
TSK_MD5_DIGEST_CALC(key, key_size, (uint8_t*)hkey);
}
else if(type == sha1){
TSK_SHA1_DIGEST_CALC((uint8_t*)key, (unsigned int)key_size, (uint8_t*)hkey);
}
else return -3;
newkey_size = digest_size;
}
else{
memcpy(hkey, key, key_size);
newkey_size = key_size;
}
memcpy(ipad, hkey, newkey_size);
memcpy(opad, hkey, newkey_size);
/* [K XOR ipad] and [K XOR opad]*/
for (i=0; i<block_size; i++){
ipad[i] ^= 0x36;
opad[i] ^= 0x5c;
}
{
tsk_buffer_t *passx; // pass1 or pass2
int pass1_done = 0;
passx = tsk_buffer_create(ipad, block_size); // pass1
tsk_buffer_append(passx, input, input_size);
digest_compute:
if(type == md5){
TSK_MD5_DIGEST_CALC(TSK_BUFFER_TO_U8(passx), (unsigned int)TSK_BUFFER_SIZE(passx), digest);
}
else{
TSK_SHA1_DIGEST_CALC(TSK_BUFFER_TO_U8(passx), (unsigned int)TSK_BUFFER_SIZE(passx), digest);
}
if(pass1_done){
TSK_OBJECT_SAFE_FREE(passx);
goto pass1_and_pass2_done;
}
else{
pass1_done = 1;
}
tsk_buffer_cleanup(passx);
tsk_buffer_append(passx, opad, block_size); // pass2
tsk_buffer_append(passx, digest, digest_size);
goto digest_compute;
}
pass1_and_pass2_done:
return 0;
}
/* === entry point === */
int main(int argc, char** argv)
{
char cmdbuf[4096];
tsk_buffer_t* buffer = tsk_null;
cmd_t* cmd = tsk_null;
tsk_bool_t comment = tsk_false;
int ret;
int i, index;
const char* start = tsk_null, *end = tsk_null;
int a = 32 | 1 | 2;
/* Copyright */
printf("Doubango Project (tinyDEMO)\nCopyright (C) 2009 - 2013 Mamadou Diop \n\n");
/* Initialize Network Layer ==> Mandatory */
tnet_startup();
/* Initialize Doubango Audio/Video Framework ==> will register all plugins(codecs and sessions)
* Not mandatory if you have your own plugins*/
tdav_init();
/* Print Usage */
//cmd_print_help();
/* create user's ctx */
if(!(ctx = ctx_create()) || !ctx->stack){
TSK_DEBUG_ERROR("Failed to create user's ctx.");
goto bail;
}
/* create new buffer */
if(!(buffer = tsk_buffer_create_null())){
TSK_DEBUG_ERROR("Failed to create new buffer.");
goto bail;
}
/* initial args */
for(i=1 /* index zero contains the exe path */, index=0; i<argc && argv[i]; i++){
if(index){
tsk_buffer_append(buffer, " ", 1);
}
tsk_buffer_append(buffer, argv[i], tsk_strlen(argv[i]));
}
/* If initial args ==> parse it now */
if(buffer->size){
TSK_DEBUG_INFO("Initial command-line: %s", buffer->data);
goto init_buffer;
}
/* always use fgets() instead of gets. gets() is considered to be unsafe.(Android and Mac OS X will warn) */
while(fgets(cmdbuf, sizeof(cmdbuf), stdin)){
TSK_DEBUG_INFO("Command-Line: %s", cmdbuf);
tsk_buffer_cleanup(buffer); /* cannot read from console while executing scenario */
tsk_buffer_append(buffer, cmdbuf, tsk_strlen(cmdbuf));
init_buffer:
start = buffer->data;
//start = trim(start);
end = start + buffer->size;
if(start >= end){
TSK_DEBUG_INFO("Empty buffer");
continue;
}
parse_buffer:
TSK_OBJECT_SAFE_FREE(cmd); /* Free old value */
cmd = cmd_parse(start, (end-start), &comment, ctx->params);
if(cmd){
if(comment || cmd->type == cmd_none){
goto nex_line;
}
}
else{
continue;
}
/* Load from scenario file? */
if(cmd->type == cmd_scenario){
FILE* file;
const opt_t* opt;
tsk_size_t read = 0;
tsk_bool_t rm_lf = tsk_false;
if((opt = opt_get_by_type(cmd->opts, opt_path)) && !tsk_strnullORempty(opt->value)){ /* --path option */
if((file = fopen(opt->value, "r"))){
memset(cmdbuf, '\0', sizeof(cmdbuf)), cmdbuf[0] = '\n';
read = fread(cmdbuf+1, sizeof(uint8_t), sizeof(cmdbuf)-1, file);
fclose(file), file = tsk_null;
if(read == 0){
TSK_DEBUG_ERROR("[%s] is empty.", opt->value);
goto nex_line;
}
else if(read == sizeof(cmdbuf)-1){
TSK_DEBUG_ERROR("Buffer too short.");
goto nex_line;
}
read++; /* \n */
/* repplace all '\' with spaces (easier than handling that in the ragel file) */
for(i=0; ((tsk_size_t)i)<read; i++){
if(cmdbuf[i] == '\\'){
cmdbuf[i] = ' ';
rm_lf = tsk_true;
}
else if(rm_lf && cmdbuf[i] == '\n'){
cmdbuf[i] = ' ';
rm_lf = tsk_false;
}
}
cmdbuf[read] = '\n';
/* insert embedded scenario */
if((index = tsk_strindexOf(start, (end-start), "\n")) == -1){ /* ++sn line */
index = buffer->size;
}
else{
index += (start - ((const char*)buffer->data));
}
if(tsk_buffer_insert(buffer, index, cmdbuf, read)){
continue;
}
else{
start = ((const char*)buffer->data) + index; // because insert use realloc()
end = (((const char*)buffer->data) + buffer->size);
goto nex_line;
}
}
else{
TSK_DEBUG_ERROR("Failed to open scenario-file [%s].", opt->value);
goto nex_line;
}
continue;
}
else{
TSK_DEBUG_ERROR("++scenario command must have --path option.");
continue;
}
}
/* execute current command */
switch(cmd->type){
case cmd_exit:
TSK_DEBUG_INFO("Exit/Quit");
goto bail;
default:
ret = execute(cmd);
break;
}
/* next line */
nex_line:
if((index = tsk_strindexOf(start, (end - start), "\n")) !=-1){
start += index;
while((start < end) && isspace(*start)){
start ++;
}
if((start + 2/*++*/) < end){
goto parse_buffer; /* next line */
}
else{
continue; /* wait for new commands */
}
}
} /* while(buffer) */
bail:
/* Free current command */
TSK_OBJECT_SAFE_FREE(cmd);
/* Free buffer */
TSK_OBJECT_SAFE_FREE(buffer);
/* Destroy the user's ctx */
TSK_OBJECT_SAFE_FREE(ctx);
/* Deinitialize Doubango Audio/Video Framework ==> will unregister all plugins(codecs and sessions)
* Not mandatory */
tdav_init();
/* Uninitilize Network Layer */
tnet_cleanup();
#if ANDROID
exit(0);
#endif
return 0;
}
/**@ingroup tnet_stun_group
* Serializes a @ref tnet_stun_attribute_t objet in binary format.
* @param attribute The STUN attribute to serialize.
* @param output The output binary buffer.
* @retval Zero if succeed and non-zero error code otherwise.
*/
int tnet_stun_attribute_serialize(const tnet_stun_attribute_t* attribute, tsk_buffer_t *output)
{
if(!attribute || !output){
return -1;
}
/* Attribute Type
*/
{
uint16_t type = tnet_htons(attribute->type);
tsk_buffer_append(output, &(type), 2);
}
/* Attribute Length
*/
{
uint16_t length = tnet_htons(attribute->length);
tsk_buffer_append(output, &(length), 2);
}
/* Attribute Value
*/
switch(attribute->type){
/* RFC 5389 - 15.1. MAPPED-ADDRESS */
case stun_mapped_address:
{
TSK_DEBUG_ERROR("NOT IMPLEMENTED");
return -3;
}
/* RFC 5389 - 15.2. XOR-MAPPED-ADDRESS*/
case stun_xor_mapped_address:
{
TSK_DEBUG_ERROR("NOT IMPLEMENTED");
return -3;
}
/* RFC 5389 - 15.3. USERNAME*/
case stun_username:
{
tnet_stun_attribute_username_t *username = (tnet_stun_attribute_username_t*)attribute;
tsk_buffer_append(output, username->value, tsk_strlen(username->value));
return 0;
}
/* RFC 5389 - MESSAGE-INTEGRITY*/
case stun_message_integrity:
{
tnet_stun_attribute_integrity_t *integrity = (tnet_stun_attribute_integrity_t*)attribute;
tsk_buffer_append(output, integrity->sha1digest, TSK_SHA1_DIGEST_SIZE);
return 0;
}
/* RFC 5389 - 15.5. FINGERPRINT*/
case stun_fingerprint:
{
uint32_t fingerprint = /*tnet_htonl*/(((tnet_stun_attribute_fingerprint_t*)attribute)->value);
tsk_buffer_append(output, &fingerprint, 4);
return 0;
}
/* RFC 5389 - 15.6. ERROR-CODE*/
case stun_error_code:
{
TSK_DEBUG_ERROR("NOT IMPLEMENTED");
return -3;
}
/* RFC 5389 - 15.7. REALM*/
case stun_realm:
{
tnet_stun_attribute_realm_t *realm = (tnet_stun_attribute_realm_t*)attribute;
tsk_buffer_append(output, realm->value, tsk_strlen(realm->value));
return 0;
}
/* RFC 5389 - 15.8. NONCE*/
case stun_nonce:
{
tnet_stun_attribute_nonce_t *nonce = (tnet_stun_attribute_nonce_t*)attribute;
tsk_buffer_append(output, nonce->value, tsk_strlen(nonce->value));
return 0;
}
/* RFC 5389 - 15.9. UNKNOWN-ATTRIBUTES*/
case stun_unknown_attributes:
{
TSK_DEBUG_ERROR("NOT IMPLEMENTED");
return -3;
}
/* RFC 5389 - 15.10. SOFTWARE */
case stun_software:
{
tnet_stun_attribute_software_t *software = (tnet_stun_attribute_software_t*)attribute;
tsk_buffer_append(output, software->value, tsk_strlen(software->value));
return 0;
}
/* RFC 5389 - 15.11. ALTERNATE-SERVER */
case stun_alternate_server:
{
TSK_DEBUG_ERROR("NOT IMPLEMENTED");
return -3;
}
/* draft-ietf-behave-turn-16 - */
case stun_channel_number:
case stun_lifetime:
case stun_reserved2:
case stun_xor_peer_address:
case stun_data:
case stun_xor_relayed_address:
case stun_even_port:
case stun_requested_transport:
case stun_dont_fragment:
case stun_reserved3:
case stun_reservation_token:
{
return tnet_turn_attribute_serialize(attribute, output);
}
default:
return -2;
}
}
/**@ingroup tnet_turn_group
*/
int tnet_turn_attribute_serialize(const tnet_stun_attribute_t* attribute, tsk_buffer_t *output)
{
if(!attribute || !output){
return -1;
}
/* Attribute Value
*/
switch(attribute->type){
/* draft-ietf-behave-turn-16 - 14.1. CHANNEL-NUMBER */
case stun_channel_number:
{
tnet_turn_attribute_channelnum_t *number = (tnet_turn_attribute_channelnum_t*)attribute;
tsk_buffer_append(output, &(number->number), 2);
return 0;
}
/* draft-ietf-behave-turn-16 - 14.2. LIFETIME */
case stun_lifetime:
{
tnet_turn_attribute_lifetime_t *lifetime = (tnet_turn_attribute_lifetime_t*)attribute;
tsk_buffer_append(output, &(lifetime->value), 4);
return 0;
}
/* draft-ietf-behave-turn-16 - 14.3. XOR-PEER-ADDRESS */
case stun_xor_peer_address:
{
tnet_turn_attribute_xpeer_addr_t* xpeer = (tnet_turn_attribute_xpeer_addr_t*)attribute;
if(xpeer){
if(xpeer->family == stun_ipv4){
uint8_t pad = 0x00;
tsk_buffer_append(output, &pad, 1);
tsk_buffer_append(output, &xpeer->family, 1);
tsk_buffer_append(output, &xpeer->xport, 2);
tsk_buffer_append(output, xpeer->xaddress, 4);
}
else
{
TSK_DEBUG_ERROR("SERIALIZE:XOR-PEER-ADDRESS ==> IPV6 - NOT IMPLEMENTED");
return -3;
}
}
return 0;
}
/* draft-ietf-behave-turn-16 - 14.4. DATA */
case stun_data:
{
tnet_turn_attribute_data_t *data = (tnet_turn_attribute_data_t*)attribute;
if(data->value){
tsk_buffer_append(output, data->value->data, data->value->size);
}
return 0;
}
/* draft-ietf-behave-turn-16 - 14.5. XOR-RELAYED-ADDRESS */
case stun_xor_relayed_address:
{
TSK_DEBUG_ERROR("SERIALIZE:XOR-RELAYED-ADDRESS ==> NOT IMPLEMENTED");
return -3;
}
/* draft-ietf-behave-turn-16 - 14.6. EVEN-PORT */
case stun_even_port:
{
tnet_turn_attribute_even_port_t *even_port = (tnet_turn_attribute_even_port_t*)attribute;
uint8_t value = (even_port->R << 7);
tsk_buffer_append(output, &(value), 1);
return 0;
}
/* draft-ietf-behave-turn-16 - 14.7. REQUESTED-TRANSPORT */
case stun_requested_transport:
{
tnet_turn_attribute_reqtrans_t *reqtrans = (tnet_turn_attribute_reqtrans_t*)attribute;
tsk_buffer_append(output, &(reqtrans->protocol), 1);
tsk_buffer_append(output, &(reqtrans->rffu), 3);
return 0;
}
/* draft-ietf-behave-turn-16 - 14.8. DONT-FRAGMENT */
case stun_dont_fragment:
{
TSK_DEBUG_ERROR("SERIALIZE:DONT-FRAGMENT ==> NOT IMPLEMENTED");
return -3;
}
/* draft-ietf-behave-turn-16 - 14.9. RESERVATION-TOKEN */
case stun_reservation_token:
{
TSK_DEBUG_ERROR("SERIALIZE:TOKEN ==> NOT IMPLEMENTED");
return -3;
}
}
return 0;
}
/** Serializes a DNS RR.
*/
int tnet_dns_rr_serialize(const tnet_dns_rr_t* rr, tsk_buffer_t *output)
{
if(!rr || !output){
return -1;
}
/*=== NAME ===*/
{
tnet_dns_rr_qname_serialize(rr->name, output);
}
/*=== TYPE ===*/
{
uint16_t qtype = tnet_htons(rr->qtype);
tsk_buffer_append(output, &(qtype), 2);
}
/*=== CLASS ===*/
{
uint16_t qclass = tnet_htons(rr->qclass);
tsk_buffer_append(output, &(qclass), 2);
}
/*=== TTL ===*/
{
uint32_t ttl = tnet_htonl(rr->ttl);
tsk_buffer_append(output, &(ttl), 4);
}
/*=== RDLENGTH ===*/
{
uint16_t length = tnet_htons(rr->rdlength);
tsk_buffer_append(output, &(length), 2);
}
/*=== RDATA : Request never contains data
===*/
if(!rr->rpdata){
goto done;
}
switch(rr->qtype){
case qtype_a:
case qtype_aaaa:
case qtype_cname:
case qtype_mx:
case qtype_naptr:
case qtype_ns:
case qtype_opt:
case qtype_ptr:
case qtype_soa:
case qtype_srv:
case qtype_txt:
default:
{
TSK_DEBUG_WARN("DNS Request should not contains RDATA (not supported).");
break;
}
}
done:
return 0;
}
