messages.c 10.3 KB
Newer Older
1
/*****************************************************************************
2 3
 * messages.c: messages interface
 * 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
 *****************************************************************************
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
6
 * Copyright (C) 1998-2005 VLC authors and VideoLAN
zorglub's avatar
zorglub committed
7
 * $Id$
8
 *
Sam Hocevar's avatar
 
Sam Hocevar committed
9
 * Authors: Vincent Seguin <seguin@via.ecp.fr>
10
 *          Samuel Hocevar <sam@zoy.org>
11
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
12 13 14
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
15
 * (at your option) any later version.
16
 *
17 18
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
19 20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
21
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
22 23 24
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
26

27
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
28
 * Preamble
29
 *****************************************************************************/
30

31 32 33 34
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

35
#include <stdlib.h>
36
#include <stdarg.h>                                       /* va_list for BSD */
37
#ifdef __APPLE__
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
38
# include <xlocale.h>
39
#elif defined(HAVE_LOCALE_H)
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
40
# include <locale.h>
41
#endif
42
#include <errno.h>                                                  /* errno */
43
#include <assert.h>
44
#include <unistd.h>
45

46 47
#include <vlc_common.h>
#include <vlc_interface.h>
48
#ifdef _WIN32
49 50
#   include <vlc_network.h>          /* 'net_strerror' and 'WSAGetLastError' */
#endif
zorglub's avatar
zorglub committed
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 58 59 60 61 62 63
 * \param type VLC_MSG_* message type (info, error, warning or debug)
 * \param module name of module from which the message come
 *               (normally MODULE_STRING)
 * \param format printf-like message format
 */
void vlc_Log (vlc_object_t *obj, int type, const char *module,
              const char *format, ... )
Michel Kaempf's avatar
Michel Kaempf committed
64
{
65
    va_list args;
Michel Kaempf's avatar
Michel Kaempf committed
66

67 68 69
    va_start (args, format);
    vlc_vaLog (obj, type, module, format, args);
    va_end (args);
Michel Kaempf's avatar
Michel Kaempf committed
70
}
71

72
#ifdef _WIN32
73
static void Win32DebugOutputMsg (void *, int , const vlc_log_t *,
74 75
                                 const char *, va_list);
#endif
76

sigmunau's avatar
all:  
sigmunau committed
77
/**
78 79
 * Emit a log message. This function is the variable argument list equivalent
 * to vlc_Log().
sigmunau's avatar
all:  
sigmunau committed
80
 */
81 82
void vlc_vaLog (vlc_object_t *obj, int type, const char *module,
                const char *format, va_list args)
Michel Kaempf's avatar
Michel Kaempf committed
83
{
84
    if (obj != NULL && obj->i_flags & OBJECT_FLAGS_QUIET)
85
        return;
86

87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
    /* Get basename from the module filename */
    char *p = strrchr(module, '/');
    if (p != NULL)
        module = p;
    p = strchr(module, '.');

    size_t modlen = (p != NULL) ? (p - module) : 1;
    char modulebuf[modlen];
    if (p != NULL)
    {
        memcpy(modulebuf, module, modlen);
        modulebuf[modlen] = '\0';
        module = modulebuf;
    }

102 103 104
    /* C locale to get error messages in English in the logs */
    locale_t c = newlocale (LC_MESSAGES_MASK, "C", (locale_t)0);
    locale_t locale = uselocale (c);
105

106 107
#ifndef __GLIBC__
    /* Expand %m to strerror(errno) - only once */
108 109
    char buf[strlen(format) + 2001], *ptr;
    strcpy (buf, format);
Rafaël Carré's avatar
Rafaël Carré committed
110
    ptr = (char*)buf;
111
    format = (const char*) buf;
112 113 114 115 116 117 118 119 120 121 122 123

    for( ;; )
    {
        ptr = strchr( ptr, '%' );
        if( ptr == NULL )
            break;

        if( ptr[1] == 'm' )
        {
            char errbuf[2001];
            size_t errlen;

124
#ifndef _WIN32
125
            strerror_r( errno, errbuf, 1001 );
126 127 128 129 130 131 132
#else
            int sockerr = WSAGetLastError( );
            if( sockerr )
            {
                strncpy( errbuf, net_strerror( sockerr ), 1001 );
                WSASetLastError( sockerr );
            }
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
133 134
            if ((sockerr == 0)
             || (strcmp ("Unknown network stack error", errbuf) == 0))
135 136
                strncpy( errbuf, strerror( errno ), 1001 );
#endif
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
            errbuf[1000] = 0;

            /* Escape '%' from the error string */
            for( char *percent = strchr( errbuf, '%' );
                 percent != NULL;
                 percent = strchr( percent + 2, '%' ) )
            {
                memmove( percent + 1, percent, strlen( percent ) + 1 );
            }

            errlen = strlen( errbuf );
            memmove( ptr + errlen, ptr + 2, strlen( ptr + 2 ) + 1 );
            memcpy( ptr, errbuf, errlen );
            break; /* Only once, so we don't overflow */
        }

        /* Looks for conversion specifier... */
        do
            ptr++;
        while( *ptr && ( strchr( "diouxXeEfFgGaAcspn%", *ptr ) == NULL ) );
        if( *ptr )
            ptr++; /* ...and skip it */
    }
#endif

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 182
    va_list ap;

Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
183
    va_copy (ap, args);
184
    Win32DebugOutputMsg (priv ? &priv->log.verbose : NULL, type, &msg, format, ap);
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
185
    va_end (ap);
186 187
#endif

188 189 190 191 192
    if (priv) {
        vlc_rwlock_rdlock (&priv->log.lock);
        priv->log.cb (priv->log.opaque, type, &msg, format, args);
        vlc_rwlock_unlock (&priv->log.lock);
    }
193

194 195
    uselocale (locale);
    freelocale (c);
Michel Kaempf's avatar
Michel Kaempf committed
196 197
}

198 199 200 201 202 203 204 205 206
static const char msg_type[4][9] = { "", " error", " warning", " debug" };
#define COL(x,y)  "\033[" #x ";" #y "m"
#define RED     COL(31,1)
#define GREEN   COL(32,1)
#define YELLOW  COL(0,33)
#define WHITE   COL(0,1)
#define GRAY    "\033[0m"
static const char msg_color[4][8] = { WHITE, RED, YELLOW, GRAY };

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 217 218 219 220 221
    int canc = vlc_savecancel ();

    flockfile (stream);
    fprintf (stream, "["GREEN"%p"GRAY"] ", (void *)p_item->i_object_id);
    if (p_item->psz_header != NULL)
        utf8_fprintf (stream, "[%s] ", p_item->psz_header);
222 223 224 225
    utf8_fprintf (stream, "%s %s%s: %s", p_item->psz_module,
                  p_item->psz_object_type, msg_type[type], msg_color[type]);
    utf8_vfprintf (stream, format, ap);
    fputs (GRAY"\n", stream);
226
#if defined (_WIN32) || defined (__OS2__)
227 228 229 230 231 232
    fflush (stream);
#endif
    funlockfile (stream);
    vlc_restorecancel (canc);
}

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 241
        return;

242 243 244
    int canc = vlc_savecancel ();

    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 249 250
    utf8_fprintf (stream, "%s %s%s: ", p_item->psz_module,
                  p_item->psz_object_type, msg_type[type]);
    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 262
                                 const char *format, va_list dol)
{
263 264
    VLC_UNUSED(p_item);

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
    const signed char *pverbose = d;
    if (pverbose && (*pverbose < 0 || *pverbose < (type - VLC_MSG_ERR)))
        return;

    va_list dol2;
    va_copy (dol2, dol);
    int msg_len = vsnprintf(NULL, 0, format, dol2);
    va_end (dol2);

    if(msg_len <= 0)
        return;

    char *msg = malloc(msg_len + 1 + 1);
    if (!msg)
        return;

    msg_len = vsnprintf(msg, msg_len+1, format, dol);
    if (msg_len > 0){
        if(msg[msg_len-1] != '\n'){
            msg[msg_len] = '\n';
            msg[msg_len + 1] = '\0';
        }
287 288 289 290 291 292 293 294
        char* psz_msg = NULL;
        if(asprintf(&psz_msg, "%s %s%s: %s", p_item->psz_module,
                    p_item->psz_object_type, msg_type[type], msg) > 0) {
            wchar_t* wmsg = ToWide(psz_msg);
            OutputDebugStringW(wmsg);
            free(wmsg);
            free(psz_msg);
        }
295 296 297 298
    }
    free(msg);
}
#endif
299 300 301 302 303 304 305 306 307 308 309 310

/**
 * Sets the message logging callback.
 * \param cb message callback, or NULL to reset
 * \param data data pointer for the message callback
 */
void vlc_LogSet (libvlc_int_t *vlc, vlc_log_cb cb, void *opaque)
{
    libvlc_priv_t *priv = libvlc_priv (vlc);

    if (cb == NULL)
    {
311
#if defined (HAVE_ISATTY) && !defined (_WIN32)
312 313 314 315 316 317
        if (isatty (STDERR_FILENO) && var_InheritBool (vlc, "color"))
            cb = PrintColorMsg;
        else
#endif
            cb = PrintMsg;
        opaque = (void *)(intptr_t)priv->log.verbose;
318 319 320 321 322 323
    }

    vlc_rwlock_wrlock (&priv->log.lock);
    priv->log.cb = cb;
    priv->log.opaque = opaque;
    vlc_rwlock_unlock (&priv->log.lock);
324 325 326 327 328 329

    /* Announce who we are */
    msg_Dbg (vlc, "VLC media player - %s", VERSION_MESSAGE);
    msg_Dbg (vlc, "%s", COPYRIGHT_MESSAGE);
    msg_Dbg (vlc, "revision %s", psz_vlc_changeset);
    msg_Dbg (vlc, "configured with %s", CONFIGURE_LINE);
330 331 332 333 334
}

void vlc_LogInit (libvlc_int_t *vlc)
{
    libvlc_priv_t *priv = libvlc_priv (vlc);
335 336 337 338 339 340 341 342 343
    const char *str;

    if (var_InheritBool (vlc, "quiet"))
        priv->log.verbose = -1;
    else
    if ((str = getenv ("VLC_VERBOSE")) != NULL)
        priv->log.verbose = atoi (str);
    else
        priv->log.verbose = var_InheritInteger (vlc, "verbose");
344 345 346 347 348 349 350 351 352 353 354

    vlc_rwlock_init (&priv->log.lock);
    vlc_LogSet (vlc, NULL, NULL);
}

void vlc_LogDeinit (libvlc_int_t *vlc)
{
    libvlc_priv_t *priv = libvlc_priv (vlc);

    vlc_rwlock_destroy (&priv->log.lock);
}