8 files changed, 256 insertions, 205 deletions

diff --git a/auto_tests/toxav_basic_test.c b/auto_tests/toxav_basic_test.c
index 0dc330e0..5fe17b40 100644
--- a/auto_tests/toxav_basic_test.c
+++ b/auto_tests/toxav_basic_test.c
@@ -126,7 +126,7 @@ void callback_call_rejected ( void *av, int32_t call_index, void *_arg )
 void callback_call_ended ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
-    
+
     printf ( "Call ended for Bob!\n" );
     cast->Bob.status = Ended;
 }
@@ -134,7 +134,7 @@ void callback_call_ended ( void *av, int32_t call_index, void *_arg )
 void callback_call_type_change ( void *av, int32_t call_index, void *_arg )
 {
     printf("Call type changed; new type: %s!\n", toxav_get_peer_transmission_type
-          (av, call_index, 0) == TypeAudio ? "audio" : "video");
+           (av, call_index, 0) == TypeAudio ? "audio" : "video");
 }
 
 void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
@@ -152,22 +152,22 @@ static void callback_video(ToxAv *av, int32_t call_index, vpx_image_t *img)
 {
 }
 
-void register_callbacks(ToxAv* av, void* data)
+void register_callbacks(ToxAv *av, void *data)
 {
     toxav_register_callstate_callback(av, callback_call_started, av_OnStart, data);
     toxav_register_callstate_callback(av, callback_call_canceled, av_OnCancel, data);
     toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data);
     toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data);
     toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data);
-    
+
     toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data);
     toxav_register_callstate_callback(av, callback_recv_starting, av_OnStarting, data);
     toxav_register_callstate_callback(av, callback_recv_ending, av_OnEnding, data);
-    
+
     toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data);
     toxav_register_callstate_callback(av, callback_call_type_change, av_OnMediaChange, data);
-    
-    
+
+
     toxav_register_audio_recv_callback(av, callback_audio);
     toxav_register_video_recv_callback(av, callback_video);
 }
@@ -378,49 +378,49 @@ START_TEST(test_AV_flows)
     }
     TERMINATE_SCOPE()
 
-    
+
     uint64_t times_they_are_a_changin = time(NULL);
     /* Media change */
     CALL_AND_START_LOOP(TypeAudio, TypeAudio) {
         /* Both send */
         payload_size = toxav_prepare_audio_frame(status_control.Alice.av, status_control.Alice.call_index, prepared_payload,
-                                                 1000, sample_payload, frame_size);
-        
+                       1000, sample_payload, frame_size);
+
         if ( payload_size < 0 ) {
             ck_assert_msg ( 0, "Failed to encode payload" );
         }
-        
+
         toxav_send_audio(status_control.Alice.av, status_control.Alice.call_index, prepared_payload, payload_size);
-        
+
         payload_size = toxav_prepare_audio_frame(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, 1000,
-                                                 sample_payload, frame_size);
-        
+                       sample_payload, frame_size);
+
         if ( payload_size < 0 ) {
             ck_assert_msg ( 0, "Failed to encode payload" );
         }
-        
+
         toxav_send_audio(status_control.Bob.av, status_control.Bob.call_index, prepared_payload, payload_size);
-        
+
         /* Wait 2 seconds and change transmission type */
         if (time(NULL) - times_they_are_a_changin > 2) {
             times_they_are_a_changin = time(NULL);
-            toxav_change_type(status_control.Alice.av, status_control.Alice.call_index, 
+            toxav_change_type(status_control.Alice.av, status_control.Alice.call_index,
                               toxav_get_peer_transmission_type(status_control.Bob.av, status_control.Bob.call_index, 0)
                               == TypeAudio ? TypeVideo : TypeAudio);
         }
-        
+
         if (time(NULL) - cur_time > 10) { /* Transmit for 10 seconds */
             step++; /* This terminates the loop */
             toxav_kill_transmission(status_control.Alice.av, status_control.Alice.call_index);
             toxav_kill_transmission(status_control.Bob.av, status_control.Bob.call_index);
-            
+
             /* Call over Alice hangs up */
             toxav_hangup(status_control.Alice.av, status_control.Alice.call_index);
         }
     }
     TERMINATE_SCOPE()
 
-    
+
     /*************************************************************************************************
      * Other flows
      */
@@ -465,78 +465,80 @@ START_TEST(test_AV_flows)
         printf("\n");
     }
 
-    
+
     /*
      * Call and cancel
      */
     {
         int step = 0;
         int running = 1;
-        
+
         while (running) {
             tox_do(bootstrap_node);
             tox_do(Alice);
             tox_do(Bob);
-            
+
             switch ( step ) {
                 case 0: /* Alice */
                     printf("Alice is calling...\n");
                     toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, TypeAudio, 10);
                     step++;
                     break;
-                    
-                    
+
+
                 case 1: /* Alice again */
                     if (status_control.Bob.status == Ringing) {
                         printf("Alice cancels...\n");
                         toxav_cancel(status_control.Alice.av, status_control.Alice.call_index, 0, "Who likes D's anyway?");
                         step++;
                     }
-                    
+
                     break;
-                    
+
                 case 2:  /* Wait for Both to have status ended */
                     if (status_control.Bob.status == Cancel) running = 0;
-                    
+
                     break;
             }
-            
+
             c_sleep(20);
         }
-        
+
         printf("\n");
     }
-        
+
     /*
         * Timeout
         */
     {
         int step = 0;
         int running = 1;
+
         while (running) {
             tox_do(bootstrap_node);
             tox_do(Alice);
             tox_do(Bob);
-            
+
             switch ( step ) {
                 case 0:
                     printf("Alice is calling...\n");
                     toxav_call(status_control.Alice.av, &status_control.Alice.call_index, 0, TypeAudio, 10);
                     step++;
                     break;
-                    
+
                 case 1:
                     if (status_control.Alice.status == TimedOut) running = 0;
+
                     break;
             }
-            
+
             c_sleep(20);
-        }            
-        
+        }
+
         printf("\n");
     }
-        
-    
+
+
 
 
     printf("Calls ended!\n");
diff --git a/auto_tests/toxav_many_test.c b/auto_tests/toxav_many_test.c
index ee4c812c..5276c2f9 100644
--- a/auto_tests/toxav_many_test.c
+++ b/auto_tests/toxav_many_test.c
@@ -65,49 +65,49 @@ void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *dat
 
 
 /******************************************************************************/
-void callback_recv_invite ( void* av, int32_t call_index, void *_arg )
+void callback_recv_invite ( void *av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
 
        cast->calls[call_index].Callee.status = Ringing;*/
 }
-void callback_recv_ringing ( void* av, int32_t call_index, void *_arg )
+void callback_recv_ringing ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
     cast->calls[call_index].Caller.status = Ringing;
 }
-void callback_recv_starting ( void* av, int32_t call_index, void *_arg )
+void callback_recv_starting ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
     cast->calls[call_index].Caller.status = InCall;
 }
-void callback_recv_ending ( void* av, int32_t call_index, void *_arg )
+void callback_recv_ending ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
     cast->calls[call_index].Caller.status = Ended;
 }
 
-void callback_call_started ( void* av, int32_t call_index, void *_arg )
+void callback_call_started ( void *av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
 
        cast->calls[call_index].Callee.status = InCall;*/
 }
-void callback_call_canceled ( void* av, int32_t call_index, void *_arg )
+void callback_call_canceled ( void *av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
 
        cast->calls[call_index].Callee.status = Cancel;*/
 }
-void callback_call_rejected ( void* av, int32_t call_index, void *_arg )
+void callback_call_rejected ( void *av, int32_t call_index, void *_arg )
 {
     Status *cast = _arg;
     cast->calls[call_index].Caller.status = Rejected;
 }
-void callback_call_ended ( void* av, int32_t call_index, void *_arg )
+void callback_call_ended ( void *av, int32_t call_index, void *_arg )
 {
     /*
        Status *cast = _arg;
@@ -115,7 +115,7 @@ void callback_call_ended ( void* av, int32_t call_index, void *_arg )
        cast->calls[call_index].Callee.status = Ended;*/
 }
 
-void callback_requ_timeout ( void* av, int32_t call_index, void *_arg )
+void callback_requ_timeout ( void *av, int32_t call_index, void *_arg )
 {
     ck_assert_msg(0, "No answer!");
 }
@@ -127,21 +127,21 @@ static void callback_audio(ToxAv *av, int32_t call_index, int16_t *data, int len
 static void callback_video(ToxAv *av, int32_t call_index, vpx_image_t *img)
 {
 }
-void register_callbacks(ToxAv* av, void* data)
+void register_callbacks(ToxAv *av, void *data)
 {
     toxav_register_callstate_callback(av, callback_call_started, av_OnStart, data);
     toxav_register_callstate_callback(av, callback_call_canceled, av_OnCancel, data);
     toxav_register_callstate_callback(av, callback_call_rejected, av_OnReject, data);
     toxav_register_callstate_callback(av, callback_call_ended, av_OnEnd, data);
     toxav_register_callstate_callback(av, callback_recv_invite, av_OnInvite, data);
-    
+
     toxav_register_callstate_callback(av, callback_recv_ringing, av_OnRinging, data);
     toxav_register_callstate_callback(av, callback_recv_starting, av_OnStarting, data);
     toxav_register_callstate_callback(av, callback_recv_ending, av_OnEnding, data);
-    
+
     toxav_register_callstate_callback(av, callback_requ_timeout, av_OnRequestTimeout, data);
-    
-    
+
+
     toxav_register_audio_recv_callback(av, callback_audio);
     toxav_register_video_recv_callback(av, callback_video);
 }
@@ -157,9 +157,9 @@ void *in_thread_call (void *arg)
     uint64_t start = 0;
     int step = 0;
     int call_idx;
-    
+
     call_running[this_call->idx] = 1;
-    
+
     const int frame_size = (av_DefaultSettings.audio_sample_rate * av_DefaultSettings.audio_frame_duration / 1000);
     int16_t sample_payload[frame_size];
     randombytes((uint8_t *)sample_payload, sizeof(int16_t) * frame_size);
@@ -168,7 +168,7 @@ void *in_thread_call (void *arg)
 
     register_callbacks(this_call->Caller.av, &status_control);
     register_callbacks(this_call->Callee.av, arg);
-    
+
     /* NOTE: CALLEE WILL ALWAHYS NEED CALL_IDX == 0 */
     while (call_running[this_call->idx]) {
 
@@ -322,19 +322,19 @@ START_TEST(test_AV_three_calls)
 
     for (i = 0; i < 3; i ++) {
         status_control.calls[i].idx = i;
-        
+
         status_control.calls[i].Caller.av = uniqcallerav;
         status_control.calls[i].Caller.id = 0;
-        status_control.calls[i].Caller.status= none;
-        
+        status_control.calls[i].Caller.status = none;
+
         status_control.calls[i].Callee.av = toxav_new(callees[i], 1);
         status_control.calls[i].Callee.id = i;
-        status_control.calls[i].Callee.status= none;
+        status_control.calls[i].Callee.status = none;
     }
-        
+
     pthread_mutex_init(&muhmutex, NULL);
 
-    for ( i = 0; i < 3; i++ ) 
+    for ( i = 0; i < 3; i++ )
         pthread_create(&status_control.calls[i].tid, NULL, in_thread_call, &status_control.calls[i]);
 
     /* Now start 3 calls and they'll run for 10 s */
diff --git a/toxav/msi.c b/toxav/msi.c
index 7dc12d4d..b300ca75 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -55,13 +55,13 @@ typedef enum {
     IDReason,
     IDCallType,
     IDCallId,
-    
+
 } MSIHeaderID;
 
 typedef enum {
     TypeRequest,
     TypeResponse,
-    
+
 } MSIMessageType;
 
 typedef enum {
@@ -70,7 +70,7 @@ typedef enum {
     cancel,
     reject,
     end,
-    
+
 } MSIRequest;
 
 typedef enum {
@@ -78,7 +78,7 @@ typedef enum {
     starting,
     ending,
     error
-    
+
 } MSIResponse;
 
 
@@ -114,7 +114,7 @@ typedef struct _MSIMessage {
 } MSIMessage;
 
 
-inline__ void invoke_callback(MSISession* session, int32_t call_index, MSICallbackID id)
+inline__ void invoke_callback(MSISession *session, int32_t call_index, MSICallbackID id)
 {
     if ( session->callbacks[id].function ) {
         LOGGER_DEBUG("Invoking callback function: %d", id);
@@ -135,63 +135,73 @@ inline__ void invoke_callback(MSISession* session, int32_t call_index, MSICallba
  */
 static int parse_raw_data ( MSIMessage *msg, const uint8_t *data, uint16_t length )
 {
-    
+
 #define FAIL_CONSTRAINT(constraint, wanted) if ((constraint -= wanted) < 1) { LOGGER_ERROR("Read over length!"); return -1; }
 #define FAIL_SIZE(byte, valid) if ( byte != valid ) { LOGGER_ERROR("Invalid data size!"); return -1; }
 #define FAIL_LIMITS(byte, low, high) if ( byte < low || byte > high ) { LOGGER_ERROR("Invalid data!"); return -1; }
-    
+
     if ( msg == NULL ) {
         LOGGER_ERROR("Could not parse message: no storage!");
         return -1;
     }
-    
+
     if ( data[length - 1] ) { /* End byte must have value 0 */
         LOGGER_ERROR("Invalid end byte");
         return -1;
     }
-        
+
     const uint8_t *it = data;
     int size_constraint = length;
-    
+
     while ( *it ) {/* until end byte is hit */
         switch (*it) {
-        case IDRequest:
-            FAIL_CONSTRAINT(size_constraint, 3);
-            FAIL_SIZE(it[1], 1);
-            FAIL_LIMITS(it[2], invite, end);
-            msg->request.value = it[2]; it += 3;
-            msg->request.exists = 1;
-            break;
-        case IDResponse:
-            FAIL_CONSTRAINT(size_constraint, 3);
-            FAIL_SIZE(it[1], 1);
-            FAIL_LIMITS(it[2], ringing, error);
-            msg->response.value = it[2]; it += 3;
-            msg->response.exists = 1;
-            break;
-        case IDCallType:
-            FAIL_CONSTRAINT(size_constraint, 3);
-            FAIL_SIZE(it[1], 1);
-            FAIL_LIMITS(it[2], type_audio, type_video);
-            msg->calltype.value = it[2]; it += 3;
-            msg->calltype.exists = 1;
-            break;
-        case IDCallId:
-            FAIL_CONSTRAINT(size_constraint, sizeof(MSICallIDType) + 2);
-            FAIL_SIZE(it[1], sizeof(MSICallIDType));
-            memcpy(msg->callid.value, it + 2, sizeof(MSICallIDType)); it += sizeof(MSICallIDType) + 2;
-            msg->callid.exists = 1;
-            break;
-        case IDReason:
-            FAIL_CONSTRAINT(size_constraint, sizeof(MSIReasonStrType) + 2);
-            FAIL_SIZE(it[1], sizeof(MSIReasonStrType));
-            memcpy(msg->reason.value, it + 2, sizeof(MSIReasonStrType)); it += sizeof(MSIReasonStrType) + 2;
-            msg->reason.exists = 1;
-            break;
-        default:
-            LOGGER_ERROR("Invalid id byte");
-            return -1;
-            break;
+            case IDRequest:
+                FAIL_CONSTRAINT(size_constraint, 3);
+                FAIL_SIZE(it[1], 1);
+                FAIL_LIMITS(it[2], invite, end);
+                msg->request.value = it[2];
+                it += 3;
+                msg->request.exists = 1;
+                break;
+
+            case IDResponse:
+                FAIL_CONSTRAINT(size_constraint, 3);
+                FAIL_SIZE(it[1], 1);
+                FAIL_LIMITS(it[2], ringing, error);
+                msg->response.value = it[2];
+                it += 3;
+                msg->response.exists = 1;
+                break;
+
+            case IDCallType:
+                FAIL_CONSTRAINT(size_constraint, 3);
+                FAIL_SIZE(it[1], 1);
+                FAIL_LIMITS(it[2], type_audio, type_video);
+                msg->calltype.value = it[2];
+                it += 3;
+                msg->calltype.exists = 1;
+                break;
+
+            case IDCallId:
+                FAIL_CONSTRAINT(size_constraint, sizeof(MSICallIDType) + 2);
+                FAIL_SIZE(it[1], sizeof(MSICallIDType));
+                memcpy(msg->callid.value, it + 2, sizeof(MSICallIDType));
+                it += sizeof(MSICallIDType) + 2;
+                msg->callid.exists = 1;
+                break;
+
+            case IDReason:
+                FAIL_CONSTRAINT(size_constraint, sizeof(MSIReasonStrType) + 2);
+                FAIL_SIZE(it[1], sizeof(MSIReasonStrType));
+                memcpy(msg->reason.value, it + 2, sizeof(MSIReasonStrType));
+                it += sizeof(MSIReasonStrType) + 2;
+                msg->reason.exists = 1;
+                break;
+
+            default:
+                LOGGER_ERROR("Invalid id byte");
+                return -1;
+                break;
         }
     }
 
@@ -214,7 +224,7 @@ MSIMessage *msi_new_message ( MSIMessageType type, const uint8_t type_value )
         LOGGER_WARNING("Allocation failed! Program might misbehave!");
         return NULL;
     }
-    
+
     if ( type == TypeRequest ) {
         retu->request.exists = 1;
         retu->request.value = type_value;
@@ -281,13 +291,15 @@ uint8_t *format_output ( uint8_t *dest, MSIHeaderID id, const void *value, uint8
         return NULL;
     }
 
-    *dest = id; dest ++;
-    *dest = value_len; dest ++;
-    
+    *dest = id;
+    dest ++;
+    *dest = value_len;
+    dest ++;
+
     memcpy(dest, value, value_len);
-    
+
     *length += (2 + value_len);
-    
+
     return dest + value_len; /* Set to next position ready to be written */
 }
 
@@ -313,30 +325,30 @@ uint16_t parse_send ( MSIMessage *msg, uint8_t *dest )
 
     uint8_t *it = dest;
     uint16_t size = 0;
-    
+
     if (msg->request.exists) {
         uint8_t cast = msg->request.value;
         it = format_output(it, IDRequest, &cast, 1, &size);
     }
-    
+
     if (msg->response.exists) {
         uint8_t cast = msg->response.value;
         it = format_output(it, IDResponse, &cast, 1, &size);
     }
-    
+
     if (msg->calltype.exists) {
         uint8_t cast = msg->calltype.value;
         it = format_output(it, IDCallType, &cast, 1, &size);
     }
-    
+
     if (msg->callid.exists) {
         it = format_output(it, IDCallId, &msg->callid.value, sizeof(msg->callid.value), &size);
     }
-    
+
     if (msg->reason.exists) {
         it = format_output(it, IDReason, &msg->reason.value, sizeof(msg->reason.value), &size);
     }
-    
+
     *it = 0;
     size ++;
 
@@ -344,24 +356,27 @@ uint16_t parse_send ( MSIMessage *msg, uint8_t *dest )
 }
 
 
-void msi_msg_set_calltype ( MSIMessage* msg, const MSICallType value ) 
-{ 
-    if ( !msg ) return; 
-    msg->calltype.exists = 1; 
-    msg->calltype.value = value; 
+void msi_msg_set_calltype ( MSIMessage *msg, const MSICallType value )
+{
+    if ( !msg ) return;
+
+    msg->calltype.exists = 1;
+    msg->calltype.value = value;
 }
 
-void msi_msg_set_reason ( MSIMessage* msg, const MSIReasonStrType value ) 
-{ 
-    if ( !msg ) return; 
+void msi_msg_set_reason ( MSIMessage *msg, const MSIReasonStrType value )
+{
+    if ( !msg ) return;
+
     msg->reason.exists = 1;
     memcpy(msg->reason.value, value, sizeof(MSIReasonStrType));
 }
 
-void msi_msg_set_callid ( MSIMessage* msg, const MSICallIDType value ) 
-{ 
-    if ( !msg ) return; 
-    msg->callid.exists = 1; 
+void msi_msg_set_callid ( MSIMessage *msg, const MSICallIDType value )
+{
+    if ( !msg ) return;
+
+    msg->callid.exists = 1;
     memcpy(msg->callid.value, value, sizeof(MSICallIDType));
 }
 
@@ -528,7 +543,7 @@ static void *timer_poll( void *arg )
                 args->arg2 = handler->timers[0]->func_arg2;
 
                 if ( 0 != pthread_create(&tid, NULL, handler->timers[0]->func, args) ||
-                     0 != pthread_detach(tid) ) {
+                        0 != pthread_detach(tid) ) {
                     LOGGER_ERROR("Failed to execute timer at: %d!", handler->timers[0]->timeout);
                     free(args);
                 } else {
@@ -662,9 +677,9 @@ typedef enum {
  * @param error_code The code.
  * @return const uint8_t* The string.
  */
-static inline__ const uint8_t* stringify_error ( MSICallError error_code )
+static inline__ const uint8_t *stringify_error ( MSICallError error_code )
 {
-    static const uint8_t* strings[] = {
+    static const uint8_t *strings[] = {
         ( uint8_t *) "",
         ( uint8_t *) "Using dead call",
         ( uint8_t *) "Call id not set to any call",
@@ -739,7 +754,7 @@ static int call_id_bigger( const uint8_t *first, const uint8_t *second)
  */
 static int flush_peer_type ( MSICall *call, MSIMessage *msg, int peer_id )
 {
-    if ( msg->calltype.exists ) {        
+    if ( msg->calltype.exists ) {
         call->type_peer[peer_id] = msg->calltype.value;
         return 0;
     }
@@ -995,10 +1010,10 @@ static int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *
     LOGGER_DEBUG("Session: %p Handling 'invite' on call: %d", session, call ? call->call_idx : -1);
 
     pthread_mutex_lock(&session->mutex);
-    
+
     if (!msg->calltype.exists) {/**/
         LOGGER_WARNING("Peer sent invalid call type!");
-        send_error ( session, call, error_no_callid, msg->friend_id ); 
+        send_error ( session, call, error_no_callid, msg->friend_id );
         pthread_mutex_unlock(&session->mutex);
         return 0;
     }
@@ -1013,7 +1028,7 @@ static int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *
                  * as in he will wait the response from the other.
                  */
                 LOGGER_DEBUG("Glare case; Peer: %d", call->peers[0]);
-                
+
                 if ( call_id_bigger (call->id, msg->callid.value) == 1 ) { /* Peer has advantage */
 
                     /* Terminate call; peer will timeout(call) if call initialization fails */
@@ -1035,11 +1050,11 @@ static int handle_recv_invite ( MSISession *session, MSICall *call, MSIMessage *
                 /* Request for media change; call callback and send starting response */
                 if (flush_peer_type(call, msg, 0) != 0) { /**/
                     LOGGER_WARNING("Peer sent invalid call type!");
-                    send_error ( session, call, error_no_callid, msg->friend_id ); 
+                    send_error ( session, call, error_no_callid, msg->friend_id );
                     pthread_mutex_unlock(&session->mutex);
                     return 0;
                 }
-                
+
                 LOGGER_DEBUG("Set new call type: %s", call->type_peer[0] == type_audio ? "audio" : "video");
                 send_reponse(session, call, starting, msg->friend_id);
                 pthread_mutex_unlock(&session->mutex);
@@ -1114,7 +1129,7 @@ static int handle_recv_reject ( MSISession *session, MSICall *call, MSIMessage *
     LOGGER_DEBUG("Session: %p Handling 'reject' on call: %s", session, call->call_idx);
 
     invoke_callback(session, call->call_idx, MSI_OnReject);
-    
+
     pthread_mutex_lock(&session->mutex);
 
     send_reponse(session, call, ending, msg->friend_id);
@@ -1137,11 +1152,11 @@ static int handle_recv_cancel ( MSISession *session, MSICall *call, MSIMessage *
     invoke_callback(session, call->call_idx, MSI_OnCancel);
 
     pthread_mutex_lock(&session->mutex);
-    
+
     terminate_call ( session, call );
-    
+
     pthread_mutex_unlock(&session->mutex);
-    
+
     return 1;
 }
 
@@ -1159,7 +1174,7 @@ static int handle_recv_end ( MSISession *session, MSICall *call, MSIMessage *msg
 
     send_reponse(session, call, ending, msg->friend_id);
     terminate_call ( session, call );
-    
+
     pthread_mutex_unlock(&session->mutex);
 
 
@@ -1202,12 +1217,12 @@ static int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage
     pthread_mutex_lock(&session->mutex);
 
     if ( call->state == call_active ) { /* Change media */
-        
+
         LOGGER_DEBUG("Session: %p Changing media on call: %d", session, call->call_idx );
         pthread_mutex_unlock(&session->mutex);
-        
+
         invoke_callback(session, call->call_idx, MSI_OnMediaChange);
-        
+
     } else if ( call->state == call_inviting ) {
         LOGGER_DEBUG("Session: %p Handling 'starting' on call: %d", session, call->call_idx );
 
@@ -1217,22 +1232,22 @@ static int handle_recv_starting ( MSISession *session, MSICall *call, MSIMessage
         send_message ( session, call, msg_start, msg->friend_id );
         free ( msg_start );
 
-        
+
         flush_peer_type ( call, msg, 0 );
 
         /* This is here in case of glare */
         timer_release ( session->timer_handler, call->ringing_timer_id, 1 );
-        
+
         pthread_mutex_unlock(&session->mutex);
 
         invoke_callback(session, call->call_idx, MSI_OnStarting);
-    } else { 
+    } else {
         LOGGER_ERROR("Invalid call state");
         terminate_call(session, call );
         pthread_mutex_unlock(&session->mutex);
         return 0;
     }
-    
+
     return 1;
 }
 static int handle_recv_ending ( MSISession *session, MSICall *call, MSIMessage *msg )
@@ -1265,15 +1280,16 @@ static int handle_recv_error ( MSISession *session, MSICall *call, MSIMessage *m
     LOGGER_DEBUG("Session: %p Handling 'error' on call: %d", session, call->call_idx );
 
     invoke_callback(session, call->call_idx, MSI_OnEnding);
-    
+
     pthread_mutex_lock(&session->mutex);
+
     /* Handle error accordingly */
     if ( msg->reason.exists ) {
         /* TODO */
     }
 
     terminate_call ( session, call );
-    
+
     pthread_mutex_unlock(&session->mutex);
 
     return 1;
@@ -1344,27 +1360,52 @@ static void msi_handle_packet ( Messenger *messenger, int source, const uint8_t
     /* Now handle message */
 
     if ( msg->request.exists ) { /* Handle request */
-        
-        switch(msg->request.value) {
-            case invite: handle_recv_invite ( session, call, msg ); break;
-            case start: handle_recv_start ( session, call, msg ); break;
-            case cancel: handle_recv_cancel ( session, call, msg ); break;
-            case reject: handle_recv_reject ( session, call, msg ); break;
-            case end: handle_recv_end ( session, call, msg ); break;
+
+        switch (msg->request.value) {
+            case invite:
+                handle_recv_invite ( session, call, msg );
+                break;
+
+            case start:
+                handle_recv_start ( session, call, msg );
+                break;
+
+            case cancel:
+                handle_recv_cancel ( session, call, msg );
+                break;
+
+            case reject:
+                handle_recv_reject ( session, call, msg );
+                break;
+
+            case end:
+                handle_recv_end ( session, call, msg );
+                break;
         }
-        
+
     } else if ( msg->response.exists ) { /* Handle response */
 
         /* Got response so cancel timer */
         if ( call ) timer_release ( session->timer_handler, call->request_timer_id, 1 );
-        
-        switch(msg->response.value) {
-            case ringing: handle_recv_ringing ( session, call, msg ); break;
-            case starting: handle_recv_starting ( session, call, msg ); break;
-            case ending: handle_recv_ending ( session, call, msg ); break;
-            case error: handle_recv_error ( session, call, msg ); break;
+
+        switch (msg->response.value) {
+            case ringing:
+                handle_recv_ringing ( session, call, msg );
+                break;
+
+            case starting:
+                handle_recv_starting ( session, call, msg );
+                break;
+
+            case ending:
+                handle_recv_ending ( session, call, msg );
+                break;
+
+            case error:
+                handle_recv_error ( session, call, msg );
+                break;
         }
-        
+
     } else {
         LOGGER_WARNING("Invalid message: no resp nor requ headers");
     }
@@ -1431,7 +1472,7 @@ MSISession *msi_init_session ( Messenger *messenger, int32_t max_calls )
 
     retu->frequ = 10000; /* default value? */
     retu->call_timeout = 30000; /* default value? */
-    
+
 
     m_callback_msi_packet(messenger, msi_handle_packet, retu );
 
@@ -1503,14 +1544,15 @@ int msi_invite ( MSISession *session, int32_t *call_index, MSICallType call_type
 
 
     int i = 0;
-    for (; i < session->max_calls; i ++) 
+
+    for (; i < session->max_calls; i ++)
         if (session->calls[i] && session->calls[i]->peers[0] == friend_id) {
             LOGGER_ERROR("Already in a call with friend %d", friend_id);
             pthread_mutex_unlock(&session->mutex);
             return -1;
         }
-    
-    
+
+
     MSICall *call = init_call ( session, 1, rngsec ); /* Just one peer for now */
 
     if ( !call ) {
@@ -1575,6 +1617,7 @@ int msi_hangup ( MSISession *session, int32_t call_index )
 
     /* hangup for each peer */
     int it = 0;
+
     for ( ; it < session->calls[call_index]->peer_count; it ++ )
         send_message ( session, session->calls[call_index], msg_end, session->calls[call_index]->peers[it] );
 
@@ -1618,7 +1661,7 @@ int msi_answer ( MSISession *session, int32_t call_index, MSICallType call_type
     free ( msg_starting );
 
     session->calls[call_index]->state = call_active;
-    
+
     pthread_mutex_unlock(&session->mutex);
     return 0;
 }
@@ -1646,13 +1689,15 @@ int msi_cancel ( MSISession *session, int32_t call_index, uint32_t peer, const c
     MSIMessage *msg_cancel = msi_new_message ( TypeRequest, cancel );
 
     /* FIXME */
-#if 0 
+#if 0
+
     if ( reason && strlen(reason) < sizeof(MSIReasonStrType) ) {
         MSIReasonStrType reason_cast;
         memset(reason_cast, '\0', sizeof(MSIReasonStrType));
         memcpy(reason_cast, reason, strlen(reason));
         msi_msg_set_reason(msg_cancel, reason_cast);
     }
+
 #endif
 
     send_message ( session, session->calls[call_index], msg_cancel, peer );
@@ -1687,12 +1732,14 @@ int msi_reject ( MSISession *session, int32_t call_index, const char *reason )
 
     /* FIXME */
 #if 0
+
     if ( reason && strlen(reason) < sizeof(MSIReasonStrType) ) {
         MSIReasonStrType reason_cast;
         memset(reason_cast, '\0', sizeof(MSIReasonStrType));
         memcpy(reason_cast, reason, strlen(reason));
         msi_msg_set_reason(msg_reject, reason_cast);
     }
+
 #endif
 
     send_message ( session, session->calls[call_index], msg_reject,
@@ -1718,43 +1765,44 @@ int msi_reject ( MSISession *session, int32_t call_index, const char *reason )
  * @param friend_id The friend.
  * @return int
  */
-int msi_change_type(MSISession* session, int32_t call_index, MSICallType call_type)
+int msi_change_type(MSISession *session, int32_t call_index, MSICallType call_type)
 {
     pthread_mutex_lock(&session->mutex);
-    
+
     LOGGER_DEBUG("Changing media on call: %d", call_index);
-    
+
     if ( call_index < 0 || call_index >= session->max_calls || !session->calls[call_index] ) {
         LOGGER_ERROR("Invalid call index!");
         pthread_mutex_unlock(&session->mutex);
         return -1;
     }
-    
+
     MSICall *call = session->calls[call_index];
+
     if ( call->state != call_active ) {
         LOGGER_ERROR("Call is not active!");
         pthread_mutex_unlock(&session->mutex);
         return -1;
     }
-    
+
     if ( call->type_local == call_type ) {
         LOGGER_ERROR("Call is already set to the requested type!");
         pthread_mutex_unlock(&session->mutex);
         return -1;
     }
-    
+
     call->type_local = call_type;
-    
+
     MSIMessage *msg_invite = msi_new_message ( TypeRequest, invite );
-    
+
     msi_msg_set_calltype ( msg_invite, call_type );
     send_message ( session, call, msg_invite, call->peers[0] );
     free ( msg_invite );
-    
+
     LOGGER_DEBUG("Request for media change sent");
-    
+
     pthread_mutex_unlock(&session->mutex);
-    
+
     return 0;
 }
 
diff --git a/toxav/msi.h b/toxav/msi.h
index 4f73e58b..b99b2de8 100644
--- a/toxav/msi.h
+++ b/toxav/msi.h
@@ -29,7 +29,7 @@
 
 typedef uint8_t MSICallIDType[12];
 typedef uint8_t MSIReasonStrType[255];
-typedef void ( *MSICallbackType ) ( void* agent, int32_t call_idx, void *arg );
+typedef void ( *MSICallbackType ) ( void *agent, int32_t call_idx, void *arg );
 
 
 /**
@@ -65,12 +65,12 @@ typedef enum {
     MSI_OnCancel,
     MSI_OnReject,
     MSI_OnEnd,
-    
+
     /* Responses */
     MSI_OnRinging,
     MSI_OnStarting,
     MSI_OnEnding,
-    
+
     /* Protocol */
     MSI_OnRequestTimeout,
     MSI_OnPeerTimeout,
@@ -123,7 +123,7 @@ typedef struct _MSISession {
     MSICall       **calls;
     int32_t         max_calls;
 
-    void           *agent_handler;          
+    void           *agent_handler;
     Messenger      *messenger_handle;
 
     uint32_t        frequ;
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 0e9ef4c4..ebe32fe4 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -167,7 +167,7 @@ void toxav_kill ( ToxAv *av )
  * @param id One of the ToxAvCallbackID values
  * @return void
  */
-void toxav_register_callstate_callback ( ToxAv* av, ToxAVCallback callback, ToxAvCallbackID id, void* userdata )
+void toxav_register_callstate_callback ( ToxAv *av, ToxAVCallback callback, ToxAvCallbackID id, void *userdata )
 {
     msi_register_callback(av->msi_session, (MSICallbackType)callback, (MSICallbackID) id, userdata);
 }
@@ -307,12 +307,12 @@ int toxav_cancel ( ToxAv *av, int32_t call_index, int peer_id, const char *reaso
  * @retval 0 Success.
  * @retval ToxAvError On error.
  */
-int toxav_change_type(ToxAv* av, int32_t call_index, ToxAvCallType call_type)
+int toxav_change_type(ToxAv *av, int32_t call_index, ToxAvCallType call_type)
 {
     if ( cii(call_index, av->msi_session) || !av->msi_session->calls[call_index] ) {
         return ErrorNoCall;
     }
-    
+
     return msi_change_type(av->msi_session, call_index, call_type);
 }
 
@@ -777,7 +777,7 @@ void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg)
     CallSpecific *call = &av->calls[call_index];
 
     if (!call->call_active) return;
-    
+
     if (_session->payload_type == type_audio % 128) {
         queue(call->j_buf, _msg);
 
@@ -800,7 +800,7 @@ void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg)
 
             if ( av->audio_callback )
                 av->audio_callback(av, call_index, dest, frame_size);
-            else 
+            else
                 LOGGER_WARNING("Audio packet dropped due to missing callback!");
         }
     } else {
@@ -847,7 +847,8 @@ void toxav_handle_packet(RTPSession *_session, RTPMessage *_msg)
             LOGGER_DEBUG("Limit: %u\n", call->frame_limit);
         }
 
-end:;
+end:
+        ;
         vpx_codec_iter_t iter = NULL;
         vpx_image_t *img;
         img = vpx_codec_get_frame(&call->cs->v_decoder, &iter);
diff --git a/toxav/toxav.h b/toxav/toxav.h
index 6df9d300..8dda26cf 100644
--- a/toxav/toxav.h
+++ b/toxav/toxav.h
@@ -31,7 +31,7 @@ extern "C" {
 /* vpx_image_t */
 #include <vpx/vpx_image.h>
 
-typedef void ( *ToxAVCallback ) ( void* agent, int32_t call_idx, void *arg );
+typedef void ( *ToxAVCallback ) ( void *agent, int32_t call_idx, void *arg );
 typedef struct _ToxAv ToxAv;
 
 #ifndef __TOX_DEFINED__
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index ac2359ee..e67251f6 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -1094,6 +1094,11 @@ static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_i
             return -1;
     }
 
+    if (real_data[0] == PACKET_ID_KILL) {
+        conn->killed = 1;
+        return 0;
+    }
+
     if (conn->status == CRYPTO_CONN_NOT_CONFIRMED) {
         clear_temp_packet(c, crypt_connection_id);
         conn->status = CRYPTO_CONN_ESTABLISHED;
@@ -1112,9 +1117,6 @@ static int handle_data_packet_helper(const Net_Crypto *c, int crypt_connection_i
         }
 
         set_buffer_end(&conn->recv_array, num);
-    } else if (real_data[0] == PACKET_ID_KILL) {
-        conn->killed = 1;
-        return 0;
     } else if (real_data[0] >= CRYPTO_RESERVED_PACKETS && real_data[0] < PACKET_ID_LOSSY_RANGE_START) {
         Packet_Data dt;
         dt.time = current_time_monotonic();
@@ -1184,7 +1186,8 @@ static int handle_packet_connection(Net_Crypto *c, int crypt_connection_id, cons
         }
 
         case NET_PACKET_CRYPTO_HS: {
-            if (conn->status == CRYPTO_CONN_COOKIE_REQUESTING || conn->status == CRYPTO_CONN_HANDSHAKE_SENT) {
+            if (conn->status == CRYPTO_CONN_COOKIE_REQUESTING || conn->status == CRYPTO_CONN_HANDSHAKE_SENT
+                    || conn->status == CRYPTO_CONN_NOT_CONFIRMED) {
                 uint8_t peer_real_pk[crypto_box_PUBLICKEYBYTES];
                 uint8_t dht_public_key[crypto_box_PUBLICKEYBYTES];
                 uint8_t cookie[COOKIE_LENGTH];
diff --git a/toxcore/network.h b/toxcore/network.h
index b902a487..da175309 100644
--- a/toxcore/network.h
+++ b/toxcore/network.h
@@ -99,9 +99,6 @@ typedef int sock_t;
 #define NET_PACKET_GET_NODES       2   /* Get nodes request packet ID. */
 #define NET_PACKET_SEND_NODES      3   /* Send nodes response packet ID for IPv4 addresses. */
 #define NET_PACKET_SEND_NODES_IPV6 4   /* Send nodes response packet ID for other addresses. */
-#define NET_PACKET_HANDSHAKE       16  /* Handshake packet ID. */
-#define NET_PACKET_SYNC            17  /* SYNC packet ID. */
-#define NET_PACKET_DATA            18  /* Data packet ID. */
 #define NET_PACKET_COOKIE_REQUEST  24  /* Cookie request packet */
 #define NET_PACKET_COOKIE_RESPONSE 25  /* Cookie response packet */
 #define NET_PACKET_CRYPTO_HS       26  /* Crypto handshake packet */