git.sesse.net Git - vlc/blob - src/misc/messages.c

   1 /*****************************************************************************
   2  * messages.c: messages interface
   3  * This library provides an interface to the message queue to be used by other
   4  * modules, especially intf modules. See vlc_config.h for output configuration.
   5  *****************************************************************************
   6  * Copyright (C) 1998-2005 VLC authors and VideoLAN
   7  * $Id$
   8  *
   9  * Authors: Vincent Seguin <seguin@via.ecp.fr>
  10  *          Samuel Hocevar <sam@zoy.org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU Lesser General Public License as published by
  14  * the Free Software Foundation; either version 2.1 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * along with this program; if not, write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30
  31 #ifdef HAVE_CONFIG_H
  32 # include "config.h"
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <stdarg.h>                                       /* va_list for BSD */
  37 #ifdef __APPLE__
  38 # include <xlocale.h>
  39 #elif defined(HAVE_LOCALE_H)
  40 # include <locale.h>
  41 #endif
  42 #include <errno.h>                                                  /* errno */
  43 #include <assert.h>
  44 #include <unistd.h>
  45
  46 #include <vlc_common.h>
  47 #include <vlc_interface.h>
  48 #ifdef _WIN32
  49 #   include <vlc_network.h>          /* 'net_strerror' and 'WSAGetLastError' */
  50 #endif
  51 #include <vlc_charset.h>
  52 #include "../libvlc.h"
  53
  54 /**
  55  * Emit a log message.
  56  * \param obj VLC object emitting the message or NULL
  57  * \param type VLC_MSG_* message type (info, error, warning or debug)
  58  * \param module name of module from which the message come
  59  *               (normally MODULE_STRING)
  60  * \param format printf-like message format
  61  */
  62 void vlc_Log (vlc_object_t *obj, int type, const char *module,
  63               const char *format, ... )
  64 {
  65     va_list args;
  66
  67     va_start (args, format);
  68     vlc_vaLog (obj, type, module, format, args);
  69     va_end (args);
  70 }
  71
  72 #ifdef _WIN32
  73 static void Win32DebugOutputMsg (void *, int , const vlc_log_t *,
  74                                  const char *, va_list);
  75 #endif
  76
  77 /**
  78  * Emit a log message. This function is the variable argument list equivalent
  79  * to vlc_Log().
  80  */
  81 void vlc_vaLog (vlc_object_t *obj, int type, const char *module,
  82                 const char *format, va_list args)
  83 {
  84     if (obj != NULL && obj->i_flags & OBJECT_FLAGS_QUIET)
  85         return;
  86
  87     /* Get basename from the module filename */
  88     char *p = strrchr(module, '/');
  89     if (p != NULL)
  90         module = p;
  91     p = strchr(module, '.');
  92
  93     size_t modlen = (p != NULL) ? (p - module) : 1;
  94     char modulebuf[modlen];
  95     if (p != NULL)
  96     {
  97         memcpy(modulebuf, module, modlen);
  98         modulebuf[modlen] = '\0';
  99         module = modulebuf;
 100     }
 101
 102     /* C locale to get error messages in English in the logs */
 103     locale_t c = newlocale (LC_MESSAGES_MASK, "C", (locale_t)0);
 104     locale_t locale = uselocale (c);
 105
 106 #ifndef __GLIBC__
 107     /* Expand %m to strerror(errno) - only once */
 108     char buf[strlen(format) + 2001], *ptr;
 109     strcpy (buf, format);
 110     ptr = (char*)buf;
 111     format = (const char*) buf;
 112
 113     for( ;; )
 114     {
 115         ptr = strchr( ptr, '%' );
 116         if( ptr == NULL )
 117             break;
 118
 119         if( ptr[1] == 'm' )
 120         {
 121             char errbuf[2001];
 122             size_t errlen;
 123
 124 #ifndef _WIN32
 125             strerror_r( errno, errbuf, 1001 );
 126 #else
 127             int sockerr = WSAGetLastError( );
 128             if( sockerr )
 129             {
 130                 strncpy( errbuf, net_strerror( sockerr ), 1001 );
 131                 WSASetLastError( sockerr );
 132             }
 133             if ((sockerr == 0)
 134              || (strcmp ("Unknown network stack error", errbuf) == 0))
 135                 strncpy( errbuf, strerror( errno ), 1001 );
 136 #endif
 137             errbuf[1000] = 0;
 138
 139             /* Escape '%' from the error string */
 140             for( char *percent = strchr( errbuf, '%' );
 141                  percent != NULL;
 142                  percent = strchr( percent + 2, '%' ) )
 143             {
 144                 memmove( percent + 1, percent, strlen( percent ) + 1 );
 145             }
 146
 147             errlen = strlen( errbuf );
 148             memmove( ptr + errlen, ptr + 2, strlen( ptr + 2 ) + 1 );
 149             memcpy( ptr, errbuf, errlen );
 150             break; /* Only once, so we don't overflow */
 151         }
 152
 153         /* Looks for conversion specifier... */
 154         do
 155             ptr++;
 156         while( *ptr && ( strchr( "diouxXeEfFgGaAcspn%", *ptr ) == NULL ) );
 157         if( *ptr )
 158             ptr++; /* ...and skip it */
 159     }
 160 #endif
 161
 162     /* Fill message information fields */
 163     vlc_log_t msg;
 164
 165     msg.i_object_id = (uintptr_t)obj;
 166     msg.psz_object_type = (obj != NULL) ? obj->psz_object_type : "generic";
 167     msg.psz_module = module;
 168     msg.psz_header = NULL;
 169
 170     for (vlc_object_t *o = obj; o != NULL; o = o->p_parent)
 171         if (o->psz_header != NULL)
 172         {
 173             msg.psz_header = o->psz_header;
 174             break;
 175         }
 176
 177     /* Pass message to the callback */
 178     libvlc_priv_t *priv = obj ? libvlc_priv (obj->p_libvlc) : NULL;
 179
 180 #ifdef _WIN32
 181     va_list ap;
 182
 183     va_copy (ap, args);
 184     Win32DebugOutputMsg (priv ? &priv->log.verbose : NULL, type, &msg, format, ap);
 185     va_end (ap);
 186 #endif
 187
 188     if (priv) {
 189         vlc_rwlock_rdlock (&priv->log.lock);
 190         priv->log.cb (priv->log.opaque, type, &msg, format, args);
 191         vlc_rwlock_unlock (&priv->log.lock);
 192     }
 193
 194     uselocale (locale);
 195     freelocale (c);
 196 }
 197
 198 static const char msg_type[4][9] = { "", " error", " warning", " debug" };
 199 #define COL(x,y)  "\033[" #x ";" #y "m"
 200 #define RED     COL(31,1)
 201 #define GREEN   COL(32,1)
 202 #define YELLOW  COL(0,33)
 203 #define WHITE   COL(0,1)
 204 #define GRAY    "\033[0m"
 205 static const char msg_color[4][8] = { WHITE, RED, YELLOW, GRAY };
 206
 207 static void PrintColorMsg (void *d, int type, const vlc_log_t *p_item,
 208                            const char *format, va_list ap)
 209 {
 210     FILE *stream = stderr;
 211     int verbose = (intptr_t)d;
 212
 213     if (verbose < 0 || verbose < (type - VLC_MSG_ERR))
 214         return;
 215
 216     int canc = vlc_savecancel ();
 217
 218     flockfile (stream);
 219     fprintf (stream, "["GREEN"%p"GRAY"] ", (void *)p_item->i_object_id);
 220     if (p_item->psz_header != NULL)
 221         utf8_fprintf (stream, "[%s] ", p_item->psz_header);
 222     utf8_fprintf (stream, "%s %s%s: %s", p_item->psz_module,
 223                   p_item->psz_object_type, msg_type[type], msg_color[type]);
 224     utf8_vfprintf (stream, format, ap);
 225     fputs (GRAY"\n", stream);
 226 #if defined (_WIN32) || defined (__OS2__)
 227     fflush (stream);
 228 #endif
 229     funlockfile (stream);
 230     vlc_restorecancel (canc);
 231 }
 232
 233 static void PrintMsg (void *d, int type, const vlc_log_t *p_item,
 234                       const char *format, va_list ap)
 235 {
 236     FILE *stream = stderr;
 237     int verbose = (intptr_t)d;
 238
 239     if (verbose < 0 || verbose < (type - VLC_MSG_ERR))
 240         return;
 241
 242     int canc = vlc_savecancel ();
 243
 244     flockfile (stream);
 245     fprintf (stream, "[%p] ", (void *)p_item->i_object_id);
 246     if (p_item->psz_header != NULL)
 247         utf8_fprintf (stream, "[%s] ", p_item->psz_header);
 248     utf8_fprintf (stream, "%s %s%s: ", p_item->psz_module,
 249                   p_item->psz_object_type, msg_type[type]);
 250     utf8_vfprintf (stream, format, ap);
 251     putc_unlocked ('\n', stream);
 252 #if defined (_WIN32) || defined (__OS2__)
 253     fflush (stream);
 254 #endif
 255     funlockfile (stream);
 256     vlc_restorecancel (canc);
 257 }
 258
 259 #ifdef _WIN32
 260 static void Win32DebugOutputMsg (void* d, int type, const vlc_log_t *p_item,
 261                                  const char *format, va_list dol)
 262 {
 263     VLC_UNUSED(p_item);
 264
 265     const signed char *pverbose = d;
 266     if (pverbose && (*pverbose < 0 || *pverbose < (type - VLC_MSG_ERR)))
 267         return;
 268
 269     va_list dol2;
 270     va_copy (dol2, dol);
 271     int msg_len = vsnprintf(NULL, 0, format, dol2);
 272     va_end (dol2);
 273
 274     if(msg_len <= 0)
 275         return;
 276
 277     char *msg = malloc(msg_len + 1 + 1);
 278     if (!msg)
 279         return;
 280
 281     msg_len = vsnprintf(msg, msg_len+1, format, dol);
 282     if (msg_len > 0){
 283         if(msg[msg_len-1] != '\n'){
 284             msg[msg_len] = '\n';
 285             msg[msg_len + 1] = '\0';
 286         }
 287         char* psz_msg = NULL;
 288         if(asprintf(&psz_msg, "%s %s%s: %s", p_item->psz_module,
 289                     p_item->psz_object_type, msg_type[type], msg) > 0) {
 290             wchar_t* wmsg = ToWide(psz_msg);
 291             OutputDebugStringW(wmsg);
 292             free(wmsg);
 293             free(psz_msg);
 294         }
 295     }
 296     free(msg);
 297 }
 298 #endif
 299
 300 /**
 301  * Sets the message logging callback.
 302  * \param cb message callback, or NULL to reset
 303  * \param data data pointer for the message callback
 304  */
 305 void vlc_LogSet (libvlc_int_t *vlc, vlc_log_cb cb, void *opaque)
 306 {
 307     libvlc_priv_t *priv = libvlc_priv (vlc);
 308
 309     if (cb == NULL)
 310     {
 311 #if defined (HAVE_ISATTY) && !defined (_WIN32)
 312         if (isatty (STDERR_FILENO) && var_InheritBool (vlc, "color"))
 313             cb = PrintColorMsg;
 314         else
 315 #endif
 316             cb = PrintMsg;
 317         opaque = (void *)(intptr_t)priv->log.verbose;
 318     }
 319
 320     vlc_rwlock_wrlock (&priv->log.lock);
 321     priv->log.cb = cb;
 322     priv->log.opaque = opaque;
 323     vlc_rwlock_unlock (&priv->log.lock);
 324
 325     /* Announce who we are */
 326     msg_Dbg (vlc, "VLC media player - %s", VERSION_MESSAGE);
 327     msg_Dbg (vlc, "%s", COPYRIGHT_MESSAGE);
 328     msg_Dbg (vlc, "revision %s", psz_vlc_changeset);
 329     msg_Dbg (vlc, "configured with %s", CONFIGURE_LINE);
 330 }
 331
 332 void vlc_LogInit (libvlc_int_t *vlc)
 333 {
 334     libvlc_priv_t *priv = libvlc_priv (vlc);
 335     const char *str;
 336
 337     if (var_InheritBool (vlc, "quiet"))
 338         priv->log.verbose = -1;
 339     else
 340     if ((str = getenv ("VLC_VERBOSE")) != NULL)
 341         priv->log.verbose = atoi (str);
 342     else
 343         priv->log.verbose = var_InheritInteger (vlc, "verbose");
 344
 345     vlc_rwlock_init (&priv->log.lock);
 346     vlc_LogSet (vlc, NULL, NULL);
 347 }
 348
 349 void vlc_LogDeinit (libvlc_int_t *vlc)
 350 {
 351     libvlc_priv_t *priv = libvlc_priv (vlc);
 352
 353     vlc_rwlock_destroy (&priv->log.lock);
 354 }