Move logging to a callback.

This removes the global logger (which by the way was deleted when the first tox
was killed, so other toxes would then stop logging). Various bits of the code
now carry a logger or pass it around. It's a bit less transparent now, but now
there is no need to have a global logger, and clients can decide what to log and
where.

1 files changed, 64 insertions, 59 deletions

diff --git a/toxav/msi.c b/toxav/msi.c
index 2115a2d0..b98c58de 100644
--- a/toxav/msi.c
+++ b/toxav/msi.c
@@ -77,7 +77,7 @@ typedef struct {
 
 
 void msg_init (MSIMessage *dest, MSIRequest request);
-int msg_parse_in (MSIMessage *dest, const uint8_t *data, uint16_t length);
+int msg_parse_in (Logger *log, MSIMessage *dest, const uint8_t *data, uint16_t length);
 uint8_t *msg_parse_header_out (MSIHeaderID id, uint8_t *dest, const void *value, uint8_t value_len, uint16_t *length);
 static int send_message (Messenger *m, uint32_t friend_number, const MSIMessage *msg);
 int send_error (Messenger *m, uint32_t friend_number, MSIError error);
@@ -107,19 +107,18 @@ void msi_register_callback (MSISession *session, msi_action_cb *callback, MSICal
 MSISession *msi_new (Messenger *m)
 {
     if (m == NULL) {
-        LOGGER_ERROR("Could not init session on empty messenger!");
         return NULL;
     }
 
     MSISession *retu = calloc (sizeof (MSISession), 1);
 
     if (retu == NULL) {
-        LOGGER_ERROR("Allocation failed! Program might misbehave!");
+        LOGGER_ERROR(m->log, "Allocation failed! Program might misbehave!");
         return NULL;
     }
 
     if (create_recursive_mutex(retu->mutex) != 0) {
-        LOGGER_ERROR("Failed to init mutex! Program might misbehave");
+        LOGGER_ERROR(m->log, "Failed to init mutex! Program might misbehave");
         free(retu);
         return NULL;
     }
@@ -131,20 +130,20 @@ MSISession *msi_new (Messenger *m)
     /* This is called when remote terminates session */
     m_callback_connectionstatus_internal_av(m, on_peer_status, retu);
 
-    LOGGER_DEBUG("New msi session: %p ", retu);
+    LOGGER_DEBUG(m->log, "New msi session: %p ", retu);
     return retu;
 }
 int msi_kill (MSISession *session)
 {
     if (session == NULL) {
-        LOGGER_ERROR("Tried to terminate non-existing session");
+        LOGGER_ERROR(session->messenger->log, "Tried to terminate non-existing session");
         return -1;
     }
 
     m_callback_msi_packet((struct Messenger *) session->messenger, NULL, NULL);
 
     if (pthread_mutex_trylock(session->mutex) != 0) {
-        LOGGER_ERROR ("Failed to aquire lock on msi mutex");
+        LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex");
         return -1;
     }
 
@@ -165,7 +164,7 @@ int msi_kill (MSISession *session)
     pthread_mutex_unlock(session->mutex);
     pthread_mutex_destroy(session->mutex);
 
-    LOGGER_DEBUG("Terminated session: %p", session);
+    LOGGER_DEBUG(session->messenger->log, "Terminated session: %p", session);
     free (session);
     return 0;
 }
@@ -174,15 +173,15 @@ int msi_invite (MSISession *session, MSICall **call, uint32_t friend_number, uin
     if (!session)
         return -1;
 
-    LOGGER_DEBUG("Session: %p Inviting friend: %u", session, friend_number);
+    LOGGER_DEBUG(session->messenger->log, "Session: %p Inviting friend: %u", session, friend_number);
 
     if (pthread_mutex_trylock(session->mutex) != 0) {
-        LOGGER_ERROR ("Failed to aquire lock on msi mutex");
+        LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex");
         return -1;
     }
 
     if (get_call(session, friend_number) != NULL) {
-        LOGGER_ERROR("Already in a call");
+        LOGGER_ERROR(session->messenger->log, "Already in a call");
         pthread_mutex_unlock(session->mutex);
         return -1;
     }
@@ -206,7 +205,7 @@ int msi_invite (MSISession *session, MSICall **call, uint32_t friend_number, uin
 
     (*call)->state = msi_CallRequesting;
 
-    LOGGER_DEBUG("Invite sent");
+    LOGGER_DEBUG(session->messenger->log, "Invite sent");
     pthread_mutex_unlock(session->mutex);
     return 0;
 }
@@ -215,17 +214,18 @@ int msi_hangup (MSICall *call)
     if (!call || !call->session)
         return -1;
 
-    LOGGER_DEBUG("Session: %p Hanging up call with friend: %u", call->session, call->friend_number);
-
     MSISession *session = call->session;
 
+    LOGGER_DEBUG(session->messenger->log, "Session: %p Hanging up call with friend: %u", call->session,
+                 call->friend_number);
+
     if (pthread_mutex_trylock(session->mutex) != 0) {
-        LOGGER_ERROR ("Failed to aquire lock on msi mutex");
+        LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex");
         return -1;
     }
 
     if (call->state == msi_CallInactive) {
-        LOGGER_ERROR("Call is in invalid state!");
+        LOGGER_ERROR(session->messenger->log, "Call is in invalid state!");
         pthread_mutex_unlock(session->mutex);
         return -1;
     }
@@ -244,19 +244,19 @@ int msi_answer (MSICall *call, uint8_t capabilities)
     if (!call || !call->session)
         return -1;
 
-    LOGGER_DEBUG("Session: %p Answering call from: %u", call->session, call->friend_number);
-
     MSISession *session = call->session;
 
+    LOGGER_DEBUG(session->messenger->log, "Session: %p Answering call from: %u", call->session, call->friend_number);
+
     if (pthread_mutex_trylock(session->mutex) != 0) {
-        LOGGER_ERROR ("Failed to aquire lock on msi mutex");
+        LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex");
         return -1;
     }
 
     if (call->state != msi_CallRequested) {
         /* Though sending in invalid state will not cause anything wierd
          * Its better to not do it like a maniac */
-        LOGGER_ERROR("Call is in invalid state!");
+        LOGGER_ERROR(session->messenger->log, "Call is in invalid state!");
         pthread_mutex_unlock(session->mutex);
         return -1;
     }
@@ -281,17 +281,18 @@ int msi_change_capabilities(MSICall *call, uint8_t capabilities)
     if (!call || !call->session)
         return -1;
 
-    LOGGER_DEBUG("Session: %p Trying to change capabilities to friend %u", call->session, call->friend_number);
-
     MSISession *session = call->session;
 
+    LOGGER_DEBUG(session->messenger->log, "Session: %p Trying to change capabilities to friend %u", call->session,
+                 call->friend_number);
+
     if (pthread_mutex_trylock(session->mutex) != 0) {
-        LOGGER_ERROR ("Failed to aquire lock on msi mutex");
+        LOGGER_ERROR(session->messenger->log, "Failed to aquire lock on msi mutex");
         return -1;
     }
 
     if (call->state != msi_CallActive) {
-        LOGGER_ERROR("Call is in invalid state!");
+        LOGGER_ERROR(session->messenger->log, "Call is in invalid state!");
         pthread_mutex_unlock(session->mutex);
         return -1;
     }
@@ -320,16 +321,16 @@ void msg_init(MSIMessage *dest, MSIRequest request)
     dest->request.exists = true;
     dest->request.value = request;
 }
-int msg_parse_in (MSIMessage *dest, const uint8_t *data, uint16_t length)
+int msg_parse_in (Logger *log, MSIMessage *dest, const uint8_t *data, uint16_t length)
 {
     /* Parse raw data received from socket into MSIMessage struct */
 
 #define CHECK_SIZE(bytes, constraint, size) \
-    if ((constraint -= (2 + size)) < 1) { LOGGER_ERROR("Read over length!"); return -1; } \
-    if (bytes[1] != size) { LOGGER_ERROR("Invalid data size!"); return -1; }
+    if ((constraint -= (2 + size)) < 1) { LOGGER_ERROR(log, "Read over length!"); return -1; } \
+    if (bytes[1] != size) { LOGGER_ERROR(log, "Invalid data size!"); return -1; }
 
 #define CHECK_ENUM_HIGH(bytes, enum_high) /* Assumes size == 1 */ \
-    if (bytes[2] > enum_high) { LOGGER_ERROR("Failed enum high limit!"); return -1; }
+    if (bytes[2] > enum_high) { LOGGER_ERROR(log, "Failed enum high limit!"); return -1; }
 
 #define SET_UINT8(bytes, header) do { \
         header.value = bytes[2]; \
@@ -347,7 +348,7 @@ int msg_parse_in (MSIMessage *dest, const uint8_t *data, uint16_t length)
     assert(dest);
 
     if (length == 0 || data[length - 1]) { /* End byte must have value 0 */
-        LOGGER_ERROR("Invalid end byte");
+        LOGGER_ERROR(log, "Invalid end byte");
         return -1;
     }
 
@@ -376,14 +377,14 @@ int msg_parse_in (MSIMessage *dest, const uint8_t *data, uint16_t length)
                 break;
 
             default:
-                LOGGER_ERROR("Invalid id byte");
+                LOGGER_ERROR(log, "Invalid id byte");
                 return -1;
                 break;
         }
     }
 
     if (dest->request.exists == false) {
-        LOGGER_ERROR("Invalid request field!");
+        LOGGER_ERROR(log, "Invalid request field!");
         return -1;
     }
 
@@ -427,7 +428,7 @@ int send_message (Messenger *m, uint32_t friend_number, const MSIMessage *msg)
         it = msg_parse_header_out(IDRequest, it, &cast,
                                   sizeof(cast), &size);
     } else {
-        LOGGER_DEBUG("Must have request field");
+        LOGGER_DEBUG(m->log, "Must have request field");
         return -1;
     }
 
@@ -443,7 +444,7 @@ int send_message (Messenger *m, uint32_t friend_number, const MSIMessage *msg)
     }
 
     if (it == parsed) {
-        LOGGER_WARNING("Parsing message failed; empty message");
+        LOGGER_WARNING(m->log, "Parsing message failed; empty message");
         return -1;
     }
 
@@ -451,7 +452,7 @@ int send_message (Messenger *m, uint32_t friend_number, const MSIMessage *msg)
     size ++;
 
     if (m_msi_packet(m, friend_number, parsed, size)) {
-        LOGGER_DEBUG("Sent message");
+        LOGGER_DEBUG(m->log, "Sent message");
         return 0;
     }
 
@@ -462,7 +463,7 @@ int send_error (Messenger *m, uint32_t friend_number, MSIError error)
     /* Send error message */
     assert(m);
 
-    LOGGER_DEBUG("Sending error: %d to friend: %d", error, friend_number);
+    LOGGER_DEBUG(m->log, "Sending error: %d to friend: %d", error, friend_number);
 
     MSIMessage msg;
     msg_init(&msg, requ_pop);
@@ -478,10 +479,11 @@ int invoke_callback(MSICall *call, MSICallbackID cb)
     assert(call);
 
     if (call->session->callbacks[cb]) {
-        LOGGER_DEBUG("Invoking callback function: %d", cb);
+        LOGGER_DEBUG(call->session->messenger->log, "Invoking callback function: %d", cb);
 
         if (call->session->callbacks[cb] (call->session->av, call) != 0) {
-            LOGGER_WARNING("Callback state handling failed, sending error");
+            LOGGER_WARNING(call->session->messenger->log,
+                           "Callback state handling failed, sending error");
             goto FAILURE;
         }
 
@@ -565,10 +567,10 @@ void kill_call (MSICall *call)
     if (call == NULL)
         return;
 
-    LOGGER_DEBUG("Killing call: %p", call);
-
     MSISession *session = call->session;
 
+    LOGGER_DEBUG(session->messenger->log, "Killing call: %p", call);
+
     MSICall *prev = call->prev;
     MSICall *next = call->next;
 
@@ -601,7 +603,7 @@ void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *
 
     switch (status) {
         case 0: { /* Friend is now offline */
-            LOGGER_DEBUG("Friend %d is now offline", friend_number);
+            LOGGER_DEBUG(m->log, "Friend %d is now offline", friend_number);
 
             pthread_mutex_lock(session->mutex);
             MSICall *call = get_call(session, friend_number);
@@ -624,10 +626,11 @@ void on_peer_status(Messenger *m, uint32_t friend_number, uint8_t status, void *
 void handle_init (MSICall *call, const MSIMessage *msg)
 {
     assert(call);
-    LOGGER_DEBUG("Session: %p Handling 'init' friend: %d", call->session, call->friend_number);
+    LOGGER_DEBUG(call->session->messenger->log,
+                 "Session: %p Handling 'init' friend: %d", call->session, call->friend_number);
 
     if (!msg->capabilities.exists) {
-        LOGGER_WARNING("Session: %p Invalid capabilities on 'init'");
+        LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid capabilities on 'init'");
         call->error = msi_EInvalidMessage;
         goto FAILURE;
     }
@@ -651,7 +654,7 @@ void handle_init (MSICall *call, const MSIMessage *msg)
              * we can automatically answer the re-call.
              */
 
-            LOGGER_INFO("Friend is recalling us");
+            LOGGER_INFO(call->session->messenger->log, "Friend is recalling us");
 
             MSIMessage msg;
             msg_init(&msg, requ_push);
@@ -668,7 +671,7 @@ void handle_init (MSICall *call, const MSIMessage *msg)
         break;
 
         default: {
-            LOGGER_WARNING("Session: %p Invalid state on 'init'");
+            LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid state on 'init'");
             call->error = msi_EInvalidState;
             goto FAILURE;
         }
@@ -684,10 +687,11 @@ void handle_push (MSICall *call, const MSIMessage *msg)
 {
     assert(call);
 
-    LOGGER_DEBUG("Session: %p Handling 'push' friend: %d", call->session, call->friend_number);
+    LOGGER_DEBUG(call->session->messenger->log, "Session: %p Handling 'push' friend: %d", call->session,
+                 call->friend_number);
 
     if (!msg->capabilities.exists) {
-        LOGGER_WARNING("Session: %p Invalid capabilities on 'push'");
+        LOGGER_WARNING(call->session->messenger->log, "Session: %p Invalid capabilities on 'push'");
         call->error = msi_EInvalidMessage;
         goto FAILURE;
     }
@@ -696,7 +700,7 @@ void handle_push (MSICall *call, const MSIMessage *msg)
         case msi_CallActive: {
             /* Only act if capabilities changed */
             if (call->peer_capabilities != msg->capabilities.value) {
-                LOGGER_INFO("Friend is changing capabilities to: %u", msg->capabilities.value);
+                LOGGER_INFO(call->session->messenger->log, "Friend is changing capabilities to: %u", msg->capabilities.value);
 
                 call->peer_capabilities = msg->capabilities.value;
 
@@ -707,7 +711,7 @@ void handle_push (MSICall *call, const MSIMessage *msg)
         break;
 
         case msi_CallRequesting: {
-            LOGGER_INFO("Friend answered our call");
+            LOGGER_INFO(call->session->messenger->log, "Friend answered our call");
 
             /* Call started */
             call->peer_capabilities = msg->capabilities.value;
@@ -722,7 +726,7 @@ void handle_push (MSICall *call, const MSIMessage *msg)
         /* Pushes during initialization state are ignored */
         case msi_CallInactive:
         case msi_CallRequested: {
-            LOGGER_WARNING("Ignoring invalid push");
+            LOGGER_WARNING(call->session->messenger->log, "Ignoring invalid push");
         }
         break;
     }
@@ -737,39 +741,40 @@ void handle_pop (MSICall *call, const MSIMessage *msg)
 {
     assert(call);
 
-    LOGGER_DEBUG("Session: %p Handling 'pop', friend id: %d", call->session, call->friend_number);
+    LOGGER_DEBUG(call->session->messenger->log, "Session: %p Handling 'pop', friend id: %d", call->session,
+                 call->friend_number);
 
     /* callback errors are ignored */
 
     if (msg->error.exists) {
-        LOGGER_WARNING("Friend detected an error: %d", msg->error.value);
+        LOGGER_WARNING(call->session->messenger->log, "Friend detected an error: %d", msg->error.value);
         call->error = msg->error.value;
         invoke_callback(call, msi_OnError);
 
     } else switch (call->state) {
             case msi_CallInactive: {
-                LOGGER_ERROR("Handling what should be impossible case");
+                LOGGER_ERROR(call->session->messenger->log, "Handling what should be impossible case");
                 abort();
             }
             break;
 
             case msi_CallActive: {
                 /* Hangup */
-                LOGGER_INFO("Friend hung up on us");
+                LOGGER_INFO(call->session->messenger->log, "Friend hung up on us");
                 invoke_callback(call, msi_OnEnd);
             }
             break;
 
             case msi_CallRequesting: {
                 /* Reject */
-                LOGGER_INFO("Friend rejected our call");
+                LOGGER_INFO(call->session->messenger->log, "Friend rejected our call");
                 invoke_callback(call, msi_OnEnd);
             }
             break;
 
             case msi_CallRequested: {
                 /* Cancel */
-                LOGGER_INFO("Friend canceled call invite");
+                LOGGER_INFO(call->session->messenger->log, "Friend canceled call invite");
                 invoke_callback(call, msi_OnEnd);
             }
             break;
@@ -779,17 +784,17 @@ void handle_pop (MSICall *call, const MSIMessage *msg)
 }
 void handle_msi_packet (Messenger *m, uint32_t friend_number, const uint8_t *data, uint16_t length, void *object)
 {
-    LOGGER_DEBUG("Got msi message");
+    LOGGER_DEBUG(m->log, "Got msi message");
 
     MSISession *session = object;
     MSIMessage msg;
 
-    if (msg_parse_in (&msg, data, length) == -1) {
-        LOGGER_WARNING("Error parsing message");
+    if (msg_parse_in (m->log, &msg, data, length) == -1) {
+        LOGGER_WARNING(m->log, "Error parsing message");
         send_error(m, friend_number, msi_EInvalidMessage);
         return;
     } else {
-        LOGGER_DEBUG("Successfully parsed message");
+        LOGGER_DEBUG(m->log, "Successfully parsed message");
     }
 
     pthread_mutex_lock(session->mutex);