1 files changed, 174 insertions, 126 deletions

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;
 }