Ignore:
Timestamp:
Aug 22, 2006, 2:12:58 AM (15 years ago)
Author:
joshe
Message:

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/utils.c

    r803 r815  
    2525#include "transmission.h"
    2626
    27 static void (*messageFunc)( int, const char * );
    28 
    29 static int verboseLevel = 0;
    30 
    31 void tr_setMessageFunction( void (*func)( int, const char * ) )
    32 {
    33     messageFunc = func;
     27static tr_lock_t      * messageLock = NULL;
     28static int              messageLevel = 0;
     29static int              messageQueuing = 0;
     30static tr_msg_list_t *  messageQueue = NULL;
     31static tr_msg_list_t ** messageQueueTail = &messageQueue;
     32
     33void tr_msgInit( void )
     34{
     35    if( NULL == messageLock )
     36    {
     37        messageLock = calloc( 1, sizeof( *messageLock ) );
     38        tr_lockInit( messageLock );
     39    }
    3440}
    3541
    3642void tr_setMessageLevel( int level )
    3743{
    38     verboseLevel = MAX( 0, level );
     44    tr_lockLock( messageLock );
     45    messageLevel = MAX( 0, level );
     46    tr_lockUnlock( messageLock );
    3947}
    4048
    4149int tr_getMessageLevel( void )
    4250{
    43     return verboseLevel;
     51    int ret;
     52
     53    tr_lockLock( messageLock );
     54    ret = messageLevel;
     55    tr_lockUnlock( messageLock );
     56
     57    return ret;
     58}
     59
     60void tr_setMessageQueuing( int enabled )
     61{
     62    tr_lockLock( messageLock );
     63    messageQueuing = enabled;
     64    tr_lockUnlock( messageLock );
     65}
     66
     67tr_msg_list_t * tr_getQueuedMessages( void )
     68{
     69    tr_msg_list_t * ret;
     70
     71    tr_lockLock( messageLock );
     72    ret = messageQueue;
     73    messageQueue = NULL;
     74    messageQueueTail = &messageQueue;
     75    tr_lockUnlock( messageLock );
     76
     77    return ret;
     78}
     79
     80void tr_freeMessageList( tr_msg_list_t * list )
     81{
     82    tr_msg_list_t * next;
     83
     84    while( NULL != list )
     85    {
     86        next = list->next;
     87        free( list->message );
     88        free( list );
     89        list = next;
     90    }
    4491}
    4592
    4693void tr_msg( int level, char * msg, ... )
    4794{
    48     char         string[256];
    49     va_list      args;
    50 
    51     if( !verboseLevel )
     95    va_list          args;
     96    tr_msg_list_t * newmsg;
     97
     98    tr_lockLock( messageLock );
     99
     100    if( !messageLevel )
    52101    {
    53102        char * env;
    54103        env          = getenv( "TR_DEBUG" );
    55         verboseLevel = ( env ? atoi( env ) : 0 ) + 1;
    56         verboseLevel = MAX( 1, verboseLevel );
    57     }
    58 
    59     if( verboseLevel < level )
    60     {
    61         return;
    62     }
    63 
    64     va_start( args, msg );
    65     vsnprintf( string, sizeof( string ), msg, args );
    66     va_end( args );
    67 
    68     if( NULL == messageFunc )
    69     {
    70         fprintf( stderr, "%s\n", string );
    71     }
    72     else
    73     {
    74         messageFunc( level, string );
    75     }
     104        messageLevel = ( env ? atoi( env ) : 0 ) + 1;
     105        messageLevel = MAX( 1, messageLevel );
     106    }
     107
     108    if( messageLevel >= level )
     109    {
     110        va_start( args, msg );
     111        if( messageQueuing )
     112        {
     113            newmsg = calloc( 1, sizeof( *newmsg ) );
     114            if( NULL != newmsg )
     115            {
     116                newmsg->level = level;
     117                vasprintf( &newmsg->message, msg, args );
     118                if( NULL == newmsg->message )
     119                {
     120                    free( newmsg );
     121                }
     122                else
     123                {
     124                    *messageQueueTail = newmsg;
     125                    messageQueueTail = &newmsg->next;
     126                }
     127            }
     128        }
     129        else
     130        {
     131            vfprintf( stderr, msg, args );
     132            fputc( '\n', stderr );
     133        }
     134        va_end( args );
     135    }
     136
     137    tr_lockUnlock( messageLock );
    76138}
    77139
Note: See TracChangeset for help on using the changeset viewer.