Rework the message stuff again to be easier on the frontend.

gtk/main.c

@@ -183,7 +183,6 @@ main(int argc, char **argv) {
   gboolean didinit, didlock;
 
   safepipe();
-  msgwin_init();
 
   argfiles = readargs(argc, argv);
 

gtk/msgwin.c

@@ -37,22 +37,9 @@
 
 static void
 changelevel( GtkToggleButton * button, gpointer data );
-static void
-addmsg( int level, const char * msg );
 
-
-static GMutex * listmutex = NULL;
-static GSList * messages = NULL;
 static GtkTextBuffer * textbuf = NULL;
 
-void
-msgwin_init( void ) {
-  if( !g_thread_supported() )
-    g_thread_init( NULL );
-  listmutex = g_mutex_new();
-  tr_setMessageFunction( addmsg );
-}
-
 GtkWidget *
 msgwin_create( void ) {
   GtkWidget * win, * vbox, * scroll, * text;
@@ -146,6 +133,7 @@ void
 msgwin_loadpref( void ) {
   const char * pref;
 
+  tr_setMessageQueuing( 1 );
   pref = cf_getpref( PREF_MSGLEVEL );
   if( NULL == pref )
     return;
@@ -160,51 +148,34 @@ msgwin_loadpref( void ) {
 
 void
 msgwin_update( void ) {
-  GSList    * ii;
-  GtkTextIter iter;
+  tr_msg_list_t * msgs, * ii;
+  GtkTextIter     iter;
+  char          * label;
 
   if( NULL == textbuf )
     return;
 
-  g_mutex_lock( listmutex );
-
-  if( NULL != messages ) {
-    for( ii = messages; NULL != ii; ii = ii->next ) {
-      gtk_text_buffer_get_end_iter( textbuf, &iter );
-      gtk_text_buffer_insert( textbuf, &iter, ii->data, -1 );
-      g_free( ii->data );
+  msgs = tr_getQueuedMessages();
+  for( ii = msgs; NULL != ii; ii = ii->next ) {
+    switch( ii->level )
+    {
+      case TR_MSG_ERR:
+        label = _( "ERR " );
+        break;
+      case TR_MSG_INF:
+        label = _( "INF " );
+        break;
+      case TR_MSG_DBG:
+        label = _( "DBG " );
+        break;
+      default:
+        label = _( "??? " );
+        break;
     }
-    g_slist_free( messages );
-    messages = NULL;
+    gtk_text_buffer_get_end_iter( textbuf, &iter );
+    gtk_text_buffer_insert( textbuf, &iter, label, -1 );
+    gtk_text_buffer_insert( textbuf, &iter, ii->message, -1 );
+    gtk_text_buffer_insert( textbuf, &iter, "\n", -1 );
   }
-
-  g_mutex_unlock( listmutex );
-}
-
-static void
-addmsg( int level, const char * msg ) {
-  char * str;
-
-  g_mutex_lock( listmutex );
-
-  switch( level )
-  {
-    case TR_MSG_ERR:
-      str = _( "ERR" );
-      break;
-    case TR_MSG_INF:
-      str = _( "INF" );
-      break;
-    case TR_MSG_DBG:
-      str = _( "DBG" );
-      break;
-    default:
-      str = _( "???" );
-      break;
-  }
-
-  str = g_strdup_printf( "%s: %s\n", str, msg );
-  messages = g_slist_append( messages, str );
-
-  g_mutex_unlock( listmutex );
+  tr_freeMessageList( msgs );
 }

libtransmission/transmission.c

@@ -44,6 +44,7 @@ tr_handle_t * tr_init()
     tr_handle_t * h;
     int           i, r;
 
+    tr_msgInit();
     tr_netResolveThreadInit();
 
     h = calloc( sizeof( tr_handle_t ), 1 );

libtransmission/transmission.h

@@ -60,20 +60,10 @@ extern "C" {
 typedef struct tr_handle_s tr_handle_t;
 tr_handle_t * tr_init();
 
-/***********************************************************************
- * tr_setMessageFunction
- ***********************************************************************
- * Sets the function used to display libtransmission messages.  This
- * function must be reentrant, it may be called from different threads.
- * A NULL argument means to print messages to stderr.  The function's
- * prototype should look like this: void myMsgFunc( int, const char * );
- **********************************************************************/
-void tr_setMessageFunction( void (*func)( int, const char * ) );
-
 /***********************************************************************
  * tr_setMessageLevel
  ***********************************************************************
- * Set the level of messages to be output
+ * Set the level of messages to be output or queued
  **********************************************************************/
 #define TR_MSG_ERR 1
 #define TR_MSG_INF 2
@@ -81,6 +71,22 @@ void tr_setMessageFunction( void (*func)( int, const char * ) );
 void tr_setMessageLevel( int );
 int tr_getMessageLevel( void );
 
+/***********************************************************************
+ * tr_setMessageQueuing
+ ***********************************************************************
+ * Enable or disable message queuing
+ **********************************************************************/
+typedef struct tr_msg_list_s tr_msg_list_t;
+void tr_setMessageQueuing( int );
+
+/***********************************************************************
+ * tr_getQueuedMessages
+ ***********************************************************************
+ * Return a list of queued messages
+ **********************************************************************/
+tr_msg_list_t * tr_getQueuedMessages( void );
+void tr_freeMessageList( tr_msg_list_t * list );
+
 /***********************************************************************
  * tr_getPrefsDirectory
  ***********************************************************************
@@ -344,6 +350,13 @@ struct tr_peer_stat_s
     int     isUploading;
 };
 
+struct tr_msg_list_s
+{
+    int                    level;
+    char                 * message;
+    struct tr_msg_list_s * next;
+};
+
 #ifdef __TRANSMISSION__
 #  include "internal.h"
 #endif

libtransmission/utils.c

@@ -24,55 +24,117 @@
 
 #include "transmission.h"
 
-static void (*messageFunc)( int, const char * );
+static tr_lock_t      * messageLock = NULL;
+static int              messageLevel = 0;
+static int              messageQueuing = 0;
+static tr_msg_list_t *  messageQueue = NULL;
+static tr_msg_list_t ** messageQueueTail = &messageQueue;
 
-static int verboseLevel = 0;
-
-void tr_setMessageFunction( void (*func)( int, const char * ) )
+void tr_msgInit( void )
 {
-    messageFunc = func;
+    if( NULL == messageLock )
+    {
+        messageLock = calloc( 1, sizeof( *messageLock ) );
+        tr_lockInit( messageLock );
+    }
 }
 
 void tr_setMessageLevel( int level )
 {
-    verboseLevel = MAX( 0, level );
+    tr_lockLock( messageLock );
+    messageLevel = MAX( 0, level );
+    tr_lockUnlock( messageLock );
 }
 
 int tr_getMessageLevel( void )
 {
-    return verboseLevel;
+    int ret;
+
+    tr_lockLock( messageLock );
+    ret = messageLevel;
+    tr_lockUnlock( messageLock );
+
+    return ret;
+}
+
+void tr_setMessageQueuing( int enabled )
+{
+    tr_lockLock( messageLock );
+    messageQueuing = enabled;
+    tr_lockUnlock( messageLock );
+}
+
+tr_msg_list_t * tr_getQueuedMessages( void )
+{
+    tr_msg_list_t * ret;
+
+    tr_lockLock( messageLock );
+    ret = messageQueue;
+    messageQueue = NULL;
+    messageQueueTail = &messageQueue;
+    tr_lockUnlock( messageLock );
+
+    return ret;
+}
+
+void tr_freeMessageList( tr_msg_list_t * list )
+{
+    tr_msg_list_t * next;
+
+    while( NULL != list )
+    {
+        next = list->next;
+        free( list->message );
+        free( list );
+        list = next;
+    }
 }
 
 void tr_msg( int level, char * msg, ... )
 {
-    char         string[256];
-    va_list      args;
+    va_list          args;
+    tr_msg_list_t * newmsg;
 
-    if( !verboseLevel )
+    tr_lockLock( messageLock );
+
+    if( !messageLevel )
     {
         char * env;
         env          = getenv( "TR_DEBUG" );
-        verboseLevel = ( env ? atoi( env ) : 0 ) + 1;
-        verboseLevel = MAX( 1, verboseLevel );
+        messageLevel = ( env ? atoi( env ) : 0 ) + 1;
+        messageLevel = MAX( 1, messageLevel );
     }
 
-    if( verboseLevel < level )
+    if( messageLevel >= level )
     {
-        return;
+        va_start( args, msg );
+        if( messageQueuing )
+        {
+            newmsg = calloc( 1, sizeof( *newmsg ) );
+            if( NULL != newmsg )
+            {
+                newmsg->level = level;
+                vasprintf( &newmsg->message, msg, args );
+                if( NULL == newmsg->message )
+                {
+                    free( newmsg );
+                }
+                else
+                {
+                    *messageQueueTail = newmsg;
+                    messageQueueTail = &newmsg->next;
+                }
+            }
+        }
+        else
+        {
+            vfprintf( stderr, msg, args );
+            fputc( '\n', stderr );
+        }
+        va_end( args );
     }
 
-    va_start( args, msg );
-    vsnprintf( string, sizeof( string ), msg, args );
-    va_end( args );
-
-    if( NULL == messageFunc )
-    {
-        fprintf( stderr, "%s\n", string );
-    }
-    else
-    {
-        messageFunc( level, string );
-    }
+    tr_lockUnlock( messageLock );
 }
 
 int tr_rand( int sup )

libtransmission/utils.h

@@ -25,6 +25,8 @@
 #ifndef TR_UTILS_H
 #define TR_UTILS_H 1
 
+void tr_msgInit( void );
+
 #define tr_err( a... ) tr_msg( TR_MSG_ERR, ## a )
 #define tr_inf( a... ) tr_msg( TR_MSG_INF, ## a )
 #define tr_dbg( a... ) tr_msg( TR_MSG_DBG, ## a )