tnet_dhcp6_option_t* tnet_dhcp6_option_deserialize(const void* data, tsk_size_t size)
{
tnet_dhcp6_option_t *option = 0;
uint8_t* dataPtr = ((uint8_t*)data);
//uint8_t* dataEnd = (dataPtr+size);
tnet_dhcp6_option_code_t code;
uint16_t len;
/* Check validity */
if(!dataPtr || size<4/*Code Len*/){
goto bail;
}
code = (tnet_dhcp6_option_code_t) tnet_ntohs_2(dataPtr);
dataPtr += 2;
len = tnet_ntohs_2(dataPtr);
dataPtr += 2;
switch(code){
case dhcp6_code_clientid:
case dhcp6_code_serverid:
{
break;
}
default:
{
break;
}
}
bail:
return option;
}
//=================================================================================================
// [[RFC 5389 - 15.2. XOR-MAPPED-ADDRESS]] object definition
//
static tsk_object_t* tnet_stun_attribute_xmapped_addr_ctor(tsk_object_t * self, va_list * app)
{
tnet_stun_attribute_xmapped_addr_t *attribute = self;
if(attribute){
const void *payload = va_arg(*app, const void*);
tsk_size_t payload_size = va_arg(*app, tsk_size_t);
if(payload && payload_size){
const uint8_t *payloadPtr = (const uint8_t*)payload;
payloadPtr += 1; /* Ignore first 8bits */
TNET_STUN_ATTRIBUTE(attribute)->type = stun_xor_mapped_address;
TNET_STUN_ATTRIBUTE(attribute)->length = payload_size;
attribute->family = (tnet_stun_addr_family_t)(*(payloadPtr++));
/* RFC 5389 - 15.2. XOR-MAPPED-ADDRESS
X-Port is computed by taking the mapped port in host byte order,
XOR'ing it with the most significant 16 bits of the magic cookie, and
then the converting the result to network byte order.
*/
attribute->xport = tnet_ntohs_2(payloadPtr);
attribute->xport ^= 0x2112;
payloadPtr+=2;
{ /*=== Compute IP address */
/* RFC 5389 - 15.2. XOR-MAPPED-ADDRESS
If the IP address family is IPv4, X-Address is computed by taking the mapped IP
address in host byte order, XOR'ing it with the magic cookie, and
converting the result to network byte order.
*/
tsk_size_t addr_size = (attribute->family == stun_ipv6) ? 16 : (attribute->family == stun_ipv4 ? 4 : 0);
if(addr_size){
tsk_size_t i;
uint32_t addr;
for(i=0; i<addr_size; i+=4){
addr = tnet_ntohl(tnet_ntohl_2(payloadPtr) ^ TNET_STUN_MAGIC_COOKIE);
memcpy(&attribute->xaddress[i], &addr, 4);
payloadPtr+=4;
}
}
else{
TSK_DEBUG_ERROR("UNKNOWN FAMILY [%u].", attribute->family);
}
}
}
}
return self;
}
//=================================================================================================
// [[draft-ietf-behave-turn-16 - 14.5. XOR-RELAYED-ADDRESS]] object definition
//
static tsk_object_t* tnet_turn_attribute_xrelayed_addr_ctor(tsk_object_t * self, va_list * app)
{
tnet_turn_attribute_xrelayed_addr_t *attribute = self;
if(attribute){
const void *payload = va_arg(*app, const void*);
tsk_size_t payload_size = va_arg(*app, tsk_size_t);
if(payload && payload_size){
const uint8_t *payloadPtr = (const uint8_t*)payload;
payloadPtr += 1; /* Ignore first 8bits */
TNET_STUN_ATTRIBUTE(attribute)->type = stun_xor_relayed_address;
TNET_STUN_ATTRIBUTE(attribute)->length = payload_size;
attribute->family = (tnet_stun_addr_family_t)(*(payloadPtr++));
attribute->xport = tnet_ntohs_2(payloadPtr);
attribute->xport ^= 0x2112;
payloadPtr+=2;
{ /*=== Compute IP address */
tsk_size_t addr_size = (attribute->family == stun_ipv6) ? 16 : (attribute->family == stun_ipv4 ? 4 : 0);
if(addr_size){
tsk_size_t i;
uint32_t addr;
for(i=0; i<addr_size; i+=4){
addr = tnet_htonl_2(payloadPtr);
addr ^= TNET_STUN_MAGIC_COOKIE;
memcpy(&attribute->xaddress[i], &addr, 4);
payloadPtr+=4;
}
}
else{
TSK_DEBUG_ERROR("UNKNOWN FAMILY [%u].", attribute->family);
}
}
}
}
return self;
}
//=================================================================================================
// [[RFC 5389 - 15.1. MAPPED-ADDRESS]] object definition
//
static tsk_object_t* tnet_stun_attribute_mapped_addr_ctor(tsk_object_t * self, va_list * app)
{
tnet_stun_attribute_mapped_addr_t *attribute = self;
if(attribute){
const void *payload = va_arg(*app, const void*);
tsk_size_t payload_size = va_arg(*app, tsk_size_t);
if(payload && payload_size){
const uint8_t *payloadPtr = (const uint8_t*)payload;
payloadPtr += 1; /* Ignore first 8bits */
TNET_STUN_ATTRIBUTE(attribute)->type = stun_mapped_address;
TNET_STUN_ATTRIBUTE(attribute)->length = payload_size;
attribute->family = (tnet_stun_addr_family_t) (*(payloadPtr++));
attribute->port = tnet_ntohs_2(payloadPtr);
payloadPtr+=2;
{ /*=== Compute IP address */
tsk_size_t addr_size = (attribute->family == stun_ipv6) ? 16 : (attribute->family == stun_ipv4 ? 4 : 0);
if(addr_size){
tsk_size_t i;
for(i=0; i<addr_size; i+=4){
// ntohl() not needed : byte per byte to avoid endianness problem
attribute->address[i] = payloadPtr[0],
attribute->address[i+1] = payloadPtr[1],
attribute->address[i+2] = payloadPtr[2],
attribute->address[i+3] = payloadPtr[3];
payloadPtr+=4;
}
}
else{
TSK_DEBUG_ERROR("UNKNOWN FAMILY [%u].", attribute->family);
}
}
}
}
return self;
}
/**@ingroup tnet_stun_group
* Creates @ref tnet_stun_attribute_t from raw buffer.
* @param data Raw buffer from which to create the STUN attribute.*
* @param size The size of the eaw buffer.
* @retval @ref tnet_stun_attribute_t object if succeed and NULL other wise.
*/
tnet_stun_attribute_t* tnet_stun_attribute_deserialize(const void* data, tsk_size_t size)
{
tnet_stun_attribute_t *attribute = 0;
const uint8_t* dataPtr = data;
tnet_stun_attribute_type_t type = (tnet_stun_attribute_type_t)tnet_ntohs_2(dataPtr);
uint16_t length = tnet_ntohs_2(&dataPtr[2]);
/* Check validity */
if(!data || size<=4/* Type(2-bytes) plus Length (2-bytes) */)
{
return 0;
}
dataPtr += (2 /* Type */+ 2/* Length */);
/* Attribute Value
*/
switch(type)
{
/* RFC 5389 - 15.1. MAPPED-ADDRESS */
case stun_mapped_address:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_mapped_address_create(dataPtr, length);
break;
}
/* RFC 5389 - 15.2. XOR-MAPPED-ADDRESS*/
case stun_xor_mapped_address:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_xmapped_address_create(dataPtr, length);
break;
}
/* RFC 5389 - 15.3. USERNAME*/
case stun_username:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_username_create(dataPtr, length);
break;
}
/* RFC 5389 - MESSAGE-INTEGRITY*/
case stun_message_integrity:
{
if(length == TSK_SHA1_DIGEST_SIZE){
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_integrity_create(dataPtr, length);
}
break;
}
/* RFC 5389 - 15.5. FINGERPRINT*/
case stun_fingerprint:
{
uint32_t fingerprint = tnet_htonl_2(dataPtr);
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_fingerprint_create(fingerprint);
break;
}
/* RFC 5389 - 15.6. ERROR-CODE*/
case stun_error_code:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_errorcode_create(dataPtr, length);
break;
}
/* RFC 5389 - 15.7. REALM*/
case stun_realm:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_realm_create(dataPtr, length);
break;
}
/* RFC 5389 - 15.8. NONCE*/
case stun_nonce:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_nonce_create(dataPtr, length);
break;
}
/* RFC 5389 - 15.9. UNKNOWN-ATTRIBUTES*/
case stun_unknown_attributes:
{
TSK_DEBUG_ERROR("DESERIALIZE:UNKNOWN-ATTRIBUTES ==> NOT IMPLEMENTED");
attribute = tnet_stun_attribute_create();
break;
}
/* RFC 5389 - 15.10. SOFTWARE */
case stun_software:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_software_create(dataPtr, length);
break;
}
/* RFC 5389 - 15.11. ALTERNATE-SERVER */
case stun_alternate_server:
{
attribute = (tnet_stun_attribute_t *)tnet_stun_attribute_altserver_create(dataPtr, length);
break;
}
/* draft-ietf-behave-turn-16 subclause 14 */
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:
{
attribute = tnet_turn_attribute_deserialize(type, length, dataPtr, length);
break;
}
default:
//TSK_DEBUG_WARN("==> NOT IMPLEMENTED");
break;
}
if(!attribute){
/* Create default */
attribute = tnet_stun_attribute_create();
}
/* Set common values (Do I need this ==> already set by the constructor). */
attribute->type = type;
attribute->length = length;
return attribute;
}
/** Deserializes a DNS RR.
*/
tnet_dns_rr_t* tnet_dns_rr_deserialize(const void* data, tsk_size_t size, tsk_size_t* offset)
{
tnet_dns_rr_t *rr = tsk_null;
uint8_t* dataStart = (uint8_t*)data;
uint8_t* dataPtr = (dataStart + *offset);
//uint8_t* dataEnd = (dataPtr+size);
tnet_dns_qtype_t qtype;
tnet_dns_qclass_t qclass;
uint32_t ttl;
uint16_t rdlength;
char* qname = tsk_null;
/* Check validity */
if(!dataPtr || !size){
goto bail;
}
/* == Parse QNAME == */
tnet_dns_rr_qname_deserialize(dataStart, &qname, offset);
dataPtr = (dataStart + *offset);
/* == Parse QTYPE == */
qtype = (tnet_dns_qtype_t)tnet_ntohs_2(dataPtr);
dataPtr += 2, *offset += 2;
/* == Parse QCLASS == */
qclass = (tnet_dns_qclass_t)tnet_ntohs_2(dataPtr);
dataPtr += 2, *offset += 2;
/* == Parse TTL == */
ttl = tnet_htonl_2(dataPtr);
dataPtr += 4, *offset += 4;
/* == Parse RDLENGTH == */
rdlength = tnet_ntohs_2(dataPtr);
dataPtr += 2, *offset += 2;
switch(qtype){
case qtype_a:
{
rr = (tnet_dns_rr_t *)tnet_dns_a_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_aaaa:
{
rr = (tnet_dns_rr_t *)tnet_dns_aaaa_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_cname:
{
rr = (tnet_dns_rr_t *)tnet_dns_cname_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_mx:
{
rr = (tnet_dns_rr_t *)tnet_dns_mx_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_naptr:
{
rr = (tnet_dns_rr_t *)tnet_dns_naptr_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_ns:
{
rr = (tnet_dns_rr_t *)tnet_dns_ns_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_opt:
{
unsigned payload_size = qclass;
rr = (tnet_dns_rr_t *)tnet_dns_opt_create(payload_size);
break;
}
case qtype_ptr:
{
rr = (tnet_dns_rr_t *)tnet_dns_ptr_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_soa:
{
rr = (tnet_dns_rr_t *)tnet_dns_soa_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_srv:
{
rr = (tnet_dns_rr_t *)tnet_dns_srv_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
case qtype_txt:
{
rr = (tnet_dns_rr_t *)tnet_dns_txt_create(qname, qclass, ttl, rdlength, dataStart, *offset);
break;
}
default:
{
TSK_DEBUG_ERROR("NOT IMPLEMENTED");
break;
}
}
bail:
TSK_FREE(qname);
*offset += rdlength;
return rr;
}
