#if HAVE_CRT
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#endif //HAVE_CRT
///*
//* Copyright (C) 2010-2011 Mamadou Diop.
//*
//* Contact: Mamadou Diop <diopmamadou(at)doubango[dot]org>
//*
//* This file is part of Open Source Doubango Framework.
//*
//* DOUBANGO is free software: you can redistribute it and/or modify
//* it under the terms of the GNU General Public License as published by
//* the Free Software Foundation, either version 3 of the License, or
//* (at your option) any later version.
//*
//* DOUBANGO is distributed in the hope that it will be useful,
//* but WITHOUT ANY WARRANTY; without even the implied warranty of
//* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//* GNU General Public License for more details.
//*
//* You should have received a copy of the GNU General Public License
//* along with DOUBANGO.
//*
//*/
//
///**@file tnet_stun_message.c
// * @brief STUN2 (RFC 5389) message parser.
// *
// * @author Mamadou Diop <diopmamadou(at)doubango[dot]org>
// *
//
// */
//#include "tnet_stun_message.h"
//
//#include "tnet_stun.h"
//
//#include "../tnet_types.h"
//#include "../tnet_endianness.h"
//#include "../turn/tnet_turn_attribute.h"
//#include "stun/tnet_stun_types.h"
//
//#include "tsk_memory.h"
//#include "tsk_hmac.h"
//#include "tsk_string.h"
//#include "tsk_ppfcs32.h"
//
//#include <string.h>
//
//static int __pred_find_attribute_by_type(const tsk_list_item_t *item, const void *att_type)
//{
// if(item && item->data) {
// tnet_stun_attr_t *att = item->data;
// tnet_stun_attr_type_t type = *((tnet_stun_attr_type_t*)att_type);
// return (att->type - type);
// }
// return -1;
//}
//
///**@ingroup tnet_stun_group
//* Creates new STUN message.
//* @retval @ref tnet_stun_pkt_t object.
//* @sa tnet_stun_message_create_null.
//*/
//
//tnet_stun_pkt_t* tnet_stun_message_create(const char* username, const char* password)
//{
// return tsk_object_new(tnet_stun_message_def_t, username, password);
//}
//
///**@ingroup tnet_stun_group
//* Creates new STUN message.
//* @retval @ref tnet_stun_pkt_t object.
//* @sa tnet_stun_message_create.
//*/
//tnet_stun_pkt_t* tnet_stun_message_create_null()
//{
// return tnet_stun_message_create(tsk_null, tsk_null);
//}
//
//#define SERIALIZE_N_ADD_ATTRIBUTE(att_name, payload, payload_size) \
// attribute = (tnet_stun_attr_t *)tnet_stun_attribute_##att_name##_create(payload, payload_size); \
// tnet_stun_attribute_serialize(attribute, output); \
// tnet_stun_attribute_pad(attribute, output); \
// TSK_OBJECT_SAFE_FREE(attribute);
//
///**@ingroup tnet_stun_group
// * Serializes a STUN message as binary data.
// * @param [in,out] self The STUN message to serialize.
// * @retval A buffer holding the binary data (result) if serialization succeed and zero otherwise.
//**/
//tsk_buffer_t* tnet_stun_pkt_serialize(const tnet_stun_pkt_t *self)
//{
// tsk_buffer_t *output = 0;
// tnet_stun_attr_t *attribute;
// unsigned compute_integrity = self->integrity;
//
// if(!self) {
// goto bail;
// }
//
// output = tsk_buffer_create_null();
//
// /* RFC 5389 - 6. STUN Message Structure
// 0 1 2 3
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |0 0| STUN Message Type | Message Length |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Magic Cookie |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | |
// | Transaction ID (96 bits) |
// | |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// */
//
// /* STUN Message Type
// */
// {
// uint16_t type = tnet_htons(self->type);
// tsk_buffer_append(output, &(type), 2);
// }
//
// /* Message Length ==> Will be updated after attributes have been added. */
// {
// static const uint16_t length = 0;
// tsk_buffer_append(output, &(length), 2);
// }
//
// /* Magic Cookie
// */
// {
// uint32_t cookie = tnet_htonl(self->cookie);
// tsk_buffer_append(output, &(cookie), 4);
// }
//
//
// /* Transaction ID (96 bits==>16bytes)
// */
// tsk_buffer_append(output, self->transac_id, TNET_STUN_TRANSACID_SIZE);
//
// /* DONT-FRAGMENT
// */
// if(self->dontfrag) {
// /*attribute = (tnet_stun_attr_t *)tnet_turn_attribute_dontfrag_create();
// tnet_stun_attribute_serialize(attribute, output);
// TSK_OBJECT_SAFE_FREE(attribute);*/
// }
//
// /* AUTHENTICATION */
// if(self->realm && self->nonce) { // long term
// SERIALIZE_N_ADD_ATTRIBUTE(realm, self->realm, tsk_strlen(self->realm));
// SERIALIZE_N_ADD_ATTRIBUTE(nonce, self->nonce, tsk_strlen(self->nonce));
//
// compute_integrity = !self->nointegrity;
// }
// else if(self->password) { // short term
// compute_integrity = !self->nointegrity;
// }
//
// if(compute_integrity && self->username) {
// SERIALIZE_N_ADD_ATTRIBUTE(username, self->username, tsk_strlen(self->username));
// }
//
// /*=== Attributes === */
// {
// tsk_list_item_t *item;
// tsk_list_foreach(item, self->attributes) {
// attribute = item->data;
// tnet_stun_attribute_serialize(attribute, output);
// tnet_stun_attribute_pad(attribute, output);
// }
// }
//
// /* Message Length: The message length MUST contain the size, in bytes, of the message
// not including the 20-byte STUN header.
// */
// {
// // compute length for 'MESSAGE-INTEGRITY'
// // will be computed again to store the correct value
// uint16_t length = (output->size) - kStunAttrHdrSizeInOctets;
// if(self->fingerprint) {
// length += (2/* Type */ + 2 /* Length */+ 4 /* FINGERPRINT VALUE*/);
// }
//
// if(compute_integrity) {
// length += (2/* Type */ + 2 /* Length */+ TSK_SHA1_DIGEST_SIZE /* INTEGRITY VALUE*/);
// }
//
// *(((uint16_t*)output->data)+1) = tnet_htons(length);
// }
//
// /* MESSAGE-INTEGRITY */
// if(compute_integrity) {
// /* RFC 5389 - 15.4. MESSAGE-INTEGRITY
// The MESSAGE-INTEGRITY attribute contains an HMAC-SHA1 [RFC2104] of the STUN message.
//
// For long-term credentials ==> key = MD5(username ":" realm ":" SASLprep(password))
// For short-term credentials ==> key = SASLprep(password)
// */
//
// tsk_sha1digest_t hmac;
//
// if(self->username && self->realm && self->password) { // long term
// char* keystr = tsk_null;
// tsk_md5digest_t md5;
// tsk_sprintf(&keystr, "%s:%s:%s", self->username, self->realm, self->password);
// TSK_MD5_DIGEST_CALC(keystr, tsk_strlen(keystr), md5);
// hmac_sha1digest_compute(output->data, output->size, (const char*)md5, TSK_MD5_DIGEST_SIZE, hmac);
//
// TSK_FREE(keystr);
// }
// else { // short term
// hmac_sha1digest_compute(output->data, output->size, self->password, tsk_strlen(self->password), hmac);
// }
//
// SERIALIZE_N_ADD_ATTRIBUTE(integrity, hmac, TSK_SHA1_DIGEST_SIZE);
// }
//
// // LENGTH
// *(((uint16_t*)output->data) + 1) = tnet_htons((output->size - kStunAttrHdrSizeInOctets + (self->fingerprint ? 8 : 0)));
//
// /* FINGERPRINT */
// if(self->fingerprint) { //JINGLE_ICE
// /* RFC 5389 - 15.5. FINGERPRINT
// The FINGERPRINT attribute MAY be present in all STUN messages. The
// value of the attribute is computed as the CRC-32 of the STUN message
// up to (but excluding) the FINGERPRINT attribute itself, XOR'ed with
// the 32-bit value 0x5354554e
// */
// uint32_t fingerprint = tsk_pppfcs32(TSK_PPPINITFCS32, output->data, output->size);
// fingerprint ^= 0x5354554e;
// fingerprint = tnet_htonl(fingerprint);
//
// attribute = (tnet_stun_attr_t *)tnet_stun_attribute_fingerprint_create(fingerprint);
// tnet_stun_attribute_serialize(attribute, output);
// TSK_OBJECT_SAFE_FREE(attribute);
// }
//
//bail:
// return output;
//}
//
//
///**@ingroup tnet_stun_group
// *
// * Deserializes a STUN message from binary data.
// *
// * @param [in,out] data A pointer to the binary data.
// * @param size The size of the binary data.
// *
// * @retval A STUN message if deserialization succeed or NULL otherwise.
//**/
//tnet_stun_pkt_t* tnet_stun_message_deserialize(const uint8_t *data, tsk_size_t size)
//{
// tnet_stun_pkt_t *message = 0;
// uint8_t* dataPtr, *dataEnd;
//
//
// if(!data || (size < kStunAttrHdrSizeInOctets) || !TNET_STUN_BUFF_IS_STUN2(data, size)) {
// goto bail;
// }
//
// dataPtr = (uint8_t*)data;
// dataEnd = (dataPtr + size);
//
// message = tnet_stun_message_create_null();
//
// /* Message Type
// */
// message->type = (tnet_stun_pkt_type_t)tnet_ntohs_2(dataPtr);
// dataPtr += 2;
//
// /* Message Length
// */
// message->length = tnet_ntohs_2(dataPtr);
// dataPtr += 2;
//
// /* Check message validity
// */
// if((message->length + kStunAttrHdrSizeInOctets) != size) {
// TSK_OBJECT_SAFE_FREE(message);
// goto bail;
// }
//
// /* Magic Cookie
// ==> already set by the constructor and checked by @ref TNET_IS_STUN2
// */
// dataPtr += 4;
//
// /* Transaction ID
// */
// memcpy(message->transac_id, dataPtr, TNET_STUN_TRANSACID_SIZE);
// dataPtr += TNET_STUN_TRANSACID_SIZE;
//
// /* == Parse attributes
// */
// while(dataPtr < dataEnd) {
// tnet_stun_attr_t *attribute = tnet_stun_attribute_deserialize(dataPtr, (dataEnd - dataPtr));
// if(attribute) {
// tsk_size_t att_size = (attribute->length + 2 /* Type*/ + 2/* Length */);
// att_size += (att_size & 0x03) ? 4-(att_size & 0x03) : 0; // Skip zero bytes used to pad the attribute.
//
// dataPtr += att_size;
// tsk_list_push_back_data(message->attributes, (void**)&attribute);
//
// continue;
// }
// else {
// continue;
// }
// }
//
//bail:
// return message;
//}
//
///**@ingroup tnet_stun_group
//*/
//tsk_bool_t tnet_stun_message_has_attribute(const tnet_stun_pkt_t *self, tnet_stun_attr_type_t type)
//{
// return (tnet_stun_message_get_attribute(self, type) != tsk_null);
//}
//
///**@ingroup tnet_stun_group
//* Adds an attribute to a STUN message.
//* @param self The STUN message into which to add the attribute.
//* @param attribute The attribute to add.
//* @retval Zero if succeed and non-zero error code otherwise.
//*/
//int tnet_stun_message_add_attribute(tnet_stun_pkt_t *self, tnet_stun_attr_t** attribute)
//{
// if(self && attribute && *attribute) {
// tsk_list_push_back_data(self->attributes, (void**)attribute);
// return 0;
// }
// return -1;
//}
//
///**@ingroup tnet_stun_group
//*/
//int tnet_stun_message_remove_attribute(tnet_stun_pkt_t *self, tnet_stun_attr_type_t type)
//{
// if(self && self->attributes) {
// tsk_list_remove_item_by_pred(self->attributes, __pred_find_attribute_by_type, &type);
// }
// return 0;
//}
//
//
///**@ingroup tnet_stun_group
//* Gets a STUN attribute from a message.
//* @param self The message from which to get the attribute.
//* @param type The type of the attribute to retrieve.
//* @retval @ref tnet_stun_attr_t object if found and NULL otherwise.
//*/
//const tnet_stun_attr_t* tnet_stun_message_get_attribute(const tnet_stun_pkt_t *self, tnet_stun_attr_type_t type)
//{
// tnet_stun_attr_t* attribute;
//
// if(self && !TSK_LIST_IS_EMPTY(self->attributes)) {
// tsk_list_item_t *item;
// tsk_list_foreach(item, self->attributes) {
// if((attribute = item->data) && attribute->type == type) {
// return attribute;
// }
// }
// }
// return 0;
//}
//
///**@ingroup tnet_stun_group
//* Gets the STUN error-code attribute value from the message.
//* @param self The STUN message from which to get the error code.
//* @retval The error code if the message contain such attribute or -1 otherwise.
//*/
//short tnet_stun_message_get_errorcode(const tnet_stun_pkt_t *self)
//{
// const tnet_stun_attribute_errorcode_t* error = (const tnet_stun_attribute_errorcode_t*)tnet_stun_message_get_attribute(self, stun_error_code);
// if(error) {
// return ((error->_class*100) + error->number);
// }
// return -1;
//}
//
///**@ingroup tnet_stun_group
//* Gets the STUN @b realm attribute value from the message.
//* @param self The STUN message from which to get the @b realm.
//* @retval The @b realm as a string pointer code if the message contain such attribute or NULL otherwise.
//*/
//const char* tnet_stun_message_get_realm(const tnet_stun_pkt_t *self)
//{
// const tnet_stun_attribute_realm_t* realm = (const tnet_stun_attribute_realm_t*)tnet_stun_message_get_attribute(self, stun_realm);
// if(realm) {
// return realm->value;
// }
// return 0;
//}
//
///**@ingroup tnet_stun_group
//* Gets the STUN @b nonce attribute value from the message.
//* @param self The STUN message from which to get the @b nonce.
//* @retval The @b nonce as a string pointer code if the message contain such attribute or NULL otherwise.
//*/
//const char* tnet_stun_message_get_nonce(const tnet_stun_pkt_t *self)
//{
// const tnet_stun_attribute_nonce_t* nonce = (const tnet_stun_attribute_nonce_t*)tnet_stun_message_get_attribute(self, stun_nonce);
// if(nonce) {
// return nonce->value;
// }
// return 0;
//}
//
///**@ingroup tnet_stun_group
//* Gets the STUN @b lifetime attribute value from the message.
//* @param self The STUN message from which to get the @b lifetime.
//* @retval The @b lifetime (any positive value) if the message contain such attribute or -1 otherwise.
//*/
//int32_t tnet_stun_message_get_lifetime(const tnet_stun_pkt_t *self)
//{
// /*const tnet_turn_attribute_lifetime_t* lifetime = (const tnet_turn_attribute_lifetime_t*)tnet_stun_message_get_attribute(self, stun_lifetime);
// if(lifetime) {
// return lifetime->value;
// }*/
// return -1;
//}
//
///**@ingroup tnet_stun_group
//*/
//tsk_bool_t tnet_stun_utils_transac_id_equals(const tnet_stun_transac_id_t id1, const tnet_stun_transac_id_t id2)
//{
// tsk_size_t i;
// static const tsk_size_t size = sizeof(tnet_stun_transac_id_t);
// for(i = 0; i < size; i++) {
// if(id1[i] != id2[i]) {
// return tsk_false;
// }
// }
// return tsk_true;
//}
//
//
//
//
//
//
////=================================================================================================
//// STUN2 MESSAGE object definition
////
//static tsk_object_t* tnet_stun_message_ctor(tsk_object_t * self, va_list * app)
//{
// tnet_stun_pkt_t *message = self;
// if(message) {
// message->username = tsk_strdup(va_arg(*app, const char*));
// message->password = tsk_strdup(va_arg(*app, const char*));
//
// message->cookie = kStunMagicCookieLong;
// message->attributes = tsk_list_create();
//
// message->fingerprint = 1;
// message->integrity = 0;
//
// {
// // Create random transaction id
// int i;
// for(i = 0; i < sizeof(message->transac_id)/sizeof(message->transac_id[0]); ++i) {
// message->transac_id[i] = rand();
// }
// }
// }
// return self;
//}
//
//static tsk_object_t* tnet_stun_message_dtor(tsk_object_t * self)
//{
// tnet_stun_pkt_t *message = self;
// if(message) {
// TSK_FREE(message->username);
// TSK_FREE(message->password);
// TSK_FREE(message->realm);
// TSK_FREE(message->nonce);
//
// TSK_OBJECT_SAFE_FREE(message->attributes);
// }
//
// return self;
//}
//
//static const tsk_object_def_t tnet_stun_message_def_s = {
// sizeof(tnet_stun_pkt_t),
// tnet_stun_message_ctor,
// tnet_stun_message_dtor,
// tsk_null,
//};
//const tsk_object_def_t *tnet_stun_message_def_t = &tnet_stun_message_def_s;
//