git.sesse.net Git - vlc/blob - modules/control/rc.c

   1 /*****************************************************************************
   2  * rc.c : remote control stdin/stdout module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2004 - 2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Author: Peter Surda <shurdeek@panorama.sth.ac.at>
   8  *         Jean-Paul Saman <jpsaman #_at_# m2x _replaceWith#dot_ nl>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <stdlib.h>                                      /* malloc(), free() */
  29 #include <string.h>
  30
  31 #include <errno.h>                                                 /* ENOMEM */
  32 #include <stdio.h>
  33 #include <ctype.h>
  34 #include <signal.h>
  35
  36 #include <vlc/vlc.h>
  37 #include <vlc/intf.h>
  38 #include <vlc/aout.h>
  39 #include <vlc/vout.h>
  40 #include <vlc_video.h>
  41 #include <vlc_osd.h>
  42 #include <vlc_update.h>
  43
  44 #ifdef HAVE_UNISTD_H
  45 #    include <unistd.h>
  46 #endif
  47
  48 #ifdef HAVE_SYS_TIME_H
  49 #    include <sys/time.h>
  50 #endif
  51 #include <sys/types.h>
  52
  53 #include "vlc_error.h"
  54 #include "network.h"
  55 #include "vlc_url.h"
  56
  57 #if defined(AF_UNIX) && !defined(AF_LOCAL)
  58 #    define AF_LOCAL AF_UNIX
  59 #endif
  60
  61 #if defined(AF_LOCAL) && ! defined(WIN32)
  62 #    include <sys/un.h>
  63 #endif
  64
  65 #define MAX_LINE_LENGTH 256
  66 #define STATUS_CHANGE "status change: "
  67
  68 /*****************************************************************************
  69  * Local prototypes
  70  *****************************************************************************/
  71 static int  Activate     ( vlc_object_t * );
  72 static void Deactivate   ( vlc_object_t * );
  73 static void Run          ( intf_thread_t * );
  74
  75 static void Help         ( intf_thread_t *, vlc_bool_t );
  76 static void RegisterCallbacks( intf_thread_t * );
  77
  78 static vlc_bool_t ReadCommand( intf_thread_t *, char *, int * );
  79
  80 static playlist_item_t *parse_MRL( intf_thread_t *, char * );
  81
  82 static int  Input        ( vlc_object_t *, char const *,
  83                            vlc_value_t, vlc_value_t, void * );
  84 static int  Playlist     ( vlc_object_t *, char const *,
  85                            vlc_value_t, vlc_value_t, void * );
  86 static int  Other        ( vlc_object_t *, char const *,
  87                            vlc_value_t, vlc_value_t, void * );
  88 static int  Quit         ( vlc_object_t *, char const *,
  89                            vlc_value_t, vlc_value_t, void * );
  90 static int  Intf         ( vlc_object_t *, char const *,
  91                            vlc_value_t, vlc_value_t, void * );
  92 static int  Volume       ( vlc_object_t *, char const *,
  93                            vlc_value_t, vlc_value_t, void * );
  94 static int  VolumeMove   ( vlc_object_t *, char const *,
  95                            vlc_value_t, vlc_value_t, void * );
  96 static int  AudioConfig  ( vlc_object_t *, char const *,
  97                            vlc_value_t, vlc_value_t, void * );
  98 static int  Menu         ( vlc_object_t *, char const *,
  99                            vlc_value_t, vlc_value_t, void * );
 100 static void checkUpdates( intf_thread_t *p_intf, char *psz_arg );
 101
 102 /* Status Callbacks */
 103 static int TimeOffsetChanged( vlc_object_t *, char const *,
 104                               vlc_value_t, vlc_value_t , void * );
 105 static int VolumeChanged    ( vlc_object_t *, char const *,
 106                               vlc_value_t, vlc_value_t, void * );
 107 static int StateChanged     ( vlc_object_t *, char const *,
 108                               vlc_value_t, vlc_value_t, void * );
 109 static int RateChanged      ( vlc_object_t *, char const *,
 110                               vlc_value_t, vlc_value_t, void * );
 111
 112 struct intf_sys_t
 113 {
 114     int *pi_socket_listen;
 115     int i_socket;
 116     char *psz_unix_path;
 117
 118     /* status changes */
 119     vlc_mutex_t       status_lock;
 120     playlist_status_t i_last_state;
 121
 122 #ifdef WIN32
 123     HANDLE hConsoleIn;
 124     vlc_bool_t b_quiet;
 125 #endif
 126 };
 127
 128 #ifdef HAVE_VARIADIC_MACROS
 129 #   define msg_rc( psz_format, args... ) \
 130       __msg_rc( p_intf, psz_format, ## args )
 131 #endif
 132
 133 void __msg_rc( intf_thread_t *p_intf, const char *psz_fmt, ... )
 134 {
 135     va_list args;
 136     va_start( args, psz_fmt );
 137
 138     if( p_intf->p_sys->i_socket == -1 )
 139     {
 140         vprintf( psz_fmt, args );
 141         printf( "\r\n" );
 142     }
 143     else
 144     {
 145         net_vaPrintf( p_intf, p_intf->p_sys->i_socket, NULL, psz_fmt, args );
 146         net_Write( p_intf, p_intf->p_sys->i_socket, NULL, (uint8_t*)"\r\n", 2 );
 147     }
 148     va_end( args );
 149 }
 150
 151 /*****************************************************************************
 152  * Module descriptor
 153  *****************************************************************************/
 154 #define POS_TEXT N_("Show stream position")
 155 #define POS_LONGTEXT N_("Show the current position in seconds within the " \
 156                         "stream from time to time." )
 157
 158 #define TTY_TEXT N_("Fake TTY")
 159 #define TTY_LONGTEXT N_("Force the rc module to use stdin as if it was a TTY.")
 160
 161 #define UNIX_TEXT N_("UNIX socket command input")
 162 #define UNIX_LONGTEXT N_("Accept commands over a Unix socket rather than " \
 163                          "stdin." )
 164
 165 #define HOST_TEXT N_("TCP command input")
 166 #define HOST_LONGTEXT N_("Accept commands over a socket rather than stdin. " \
 167             "You can set the address and port the interface will bind to." )
 168
 169 #ifdef WIN32
 170 #define QUIET_TEXT N_("Do not open a DOS command box interface")
 171 #define QUIET_LONGTEXT N_( \
 172     "By default the rc interface plugin will start a DOS command box. " \
 173     "Enabling the quiet mode will not bring this command box but can also " \
 174     "be pretty annoying when you want to stop VLC and no video window is " \
 175     "open." )
 176 #endif
 177
 178 vlc_module_begin();
 179     set_shortname( _("RC"));
 180     set_category( CAT_INTERFACE );
 181     set_subcategory( SUBCAT_INTERFACE_MAIN );
 182     set_description( _("Remote control interface") );
 183     add_bool( "rc-show-pos", 0, NULL, POS_TEXT, POS_LONGTEXT, VLC_TRUE );
 184 #ifdef HAVE_ISATTY
 185     add_bool( "rc-fake-tty", 0, NULL, TTY_TEXT, TTY_LONGTEXT, VLC_TRUE );
 186 #endif
 187     add_string( "rc-unix", 0, NULL, UNIX_TEXT, UNIX_LONGTEXT, VLC_TRUE );
 188     add_string( "rc-host", 0, NULL, HOST_TEXT, HOST_LONGTEXT, VLC_TRUE );
 189
 190 #ifdef WIN32
 191     add_bool( "rc-quiet", 0, NULL, QUIET_TEXT, QUIET_LONGTEXT, VLC_FALSE );
 192 #endif
 193
 194     set_capability( "interface", 20 );
 195     set_callbacks( Activate, Deactivate );
 196 vlc_module_end();
 197
 198 /*****************************************************************************
 199  * Activate: initialize and create stuff
 200  *****************************************************************************/
 201 static int Activate( vlc_object_t *p_this )
 202 {
 203     intf_thread_t *p_intf = (intf_thread_t*)p_this;
 204     playlist_t *p_playlist;
 205     char *psz_host, *psz_unix_path;
 206     int  *pi_socket = NULL;
 207
 208 #if defined(HAVE_ISATTY) && !defined(WIN32)
 209     /* Check that stdin is a TTY */
 210     if( !config_GetInt( p_intf, "rc-fake-tty" ) && !isatty( 0 ) )
 211     {
 212         msg_Warn( p_intf, "fd 0 is not a TTY" );
 213         return VLC_EGENERIC;
 214     }
 215 #endif
 216
 217     psz_unix_path = config_GetPsz( p_intf, "rc-unix" );
 218     if( psz_unix_path )
 219     {
 220         int i_socket;
 221
 222 #if !defined(AF_LOCAL) || defined(WIN32)
 223         msg_Warn( p_intf, "your OS doesn't support filesystem sockets" );
 224         free( psz_unix_path );
 225         return VLC_EGENERIC;
 226 #else
 227         struct sockaddr_un addr;
 228         int i_ret;
 229
 230         memset( &addr, 0, sizeof(struct sockaddr_un) );
 231
 232         msg_Dbg( p_intf, "trying UNIX socket" );
 233
 234         if( (i_socket = socket( AF_LOCAL, SOCK_STREAM, 0 ) ) < 0 )
 235         {
 236             msg_Warn( p_intf, "can't open socket: %s", strerror(errno) );
 237             free( psz_unix_path );
 238             return VLC_EGENERIC;
 239         }
 240
 241         addr.sun_family = AF_LOCAL;
 242         strncpy( addr.sun_path, psz_unix_path, sizeof( addr.sun_path ) );
 243         addr.sun_path[sizeof( addr.sun_path ) - 1] = '\0';
 244
 245         if( (i_ret = bind( i_socket, (struct sockaddr*)&addr,
 246                            sizeof(struct sockaddr_un) ) ) < 0 )
 247         {
 248             msg_Warn( p_intf, "couldn't bind socket to address: %s",
 249                       strerror(errno) );
 250             free( psz_unix_path );
 251             net_Close( i_socket );
 252             return VLC_EGENERIC;
 253         }
 254
 255         if( ( i_ret = listen( i_socket, 1 ) ) < 0 )
 256         {
 257             msg_Warn( p_intf, "can't listen on socket: %s", strerror(errno));
 258             free( psz_unix_path );
 259             net_Close( i_socket );
 260             return VLC_EGENERIC;
 261         }
 262
 263         /* FIXME: we need a core function to merge listening sockets sets */
 264         pi_socket = calloc( 2, sizeof( int ) );
 265         if( pi_socket == NULL )
 266         {
 267             free( psz_unix_path );
 268             net_Close( i_socket );
 269             return VLC_ENOMEM;
 270         }
 271         pi_socket[0] = i_socket;
 272         pi_socket[1] = -1;
 273 #endif
 274     }
 275
 276     if( ( pi_socket == NULL ) &&
 277         ( psz_host = config_GetPsz( p_intf, "rc-host" ) ) != NULL )
 278     {
 279         vlc_url_t url;
 280
 281         vlc_UrlParse( &url, psz_host, 0 );
 282
 283         msg_Dbg( p_intf, "base: %s, port: %d", url.psz_host, url.i_port );
 284
 285         pi_socket = net_ListenTCP(p_this, url.psz_host, url.i_port);
 286         if( pi_socket == NULL )
 287         {
 288             msg_Warn( p_intf, "can't listen to %s port %i",
 289                       url.psz_host, url.i_port );
 290             vlc_UrlClean( &url );
 291             free( psz_host );
 292             return VLC_EGENERIC;
 293         }
 294
 295         vlc_UrlClean( &url );
 296         free( psz_host );
 297     }
 298
 299     p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
 300     if( !p_intf->p_sys )
 301     {
 302         msg_Err( p_intf, "no memory" );
 303         return VLC_ENOMEM;
 304     }
 305
 306     p_intf->p_sys->pi_socket_listen = pi_socket;
 307     p_intf->p_sys->i_socket = -1;
 308     p_intf->p_sys->psz_unix_path = psz_unix_path;
 309     vlc_mutex_init( p_intf, &p_intf->p_sys->status_lock );
 310     p_intf->p_sys->i_last_state = PLAYLIST_STOPPED;
 311
 312     /* Non-buffered stdout */
 313     setvbuf( stdout, (char *)NULL, _IOLBF, 0 );
 314
 315     p_intf->pf_run = Run;
 316
 317 #ifdef WIN32
 318     p_intf->p_sys->b_quiet = config_GetInt( p_intf, "rc-quiet" );
 319     if( !p_intf->p_sys->b_quiet ) { CONSOLE_INTRO_MSG; }
 320 #else
 321     CONSOLE_INTRO_MSG;
 322 #endif
 323
 324     /* Force "no-view" mode */
 325     p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
 326                                                  FIND_ANYWHERE );
 327     if( p_playlist )
 328     {
 329         vlc_mutex_lock( &p_playlist->object_lock );
 330         p_playlist->status.i_view = -1;
 331         vlc_mutex_unlock( &p_playlist->object_lock );
 332         vlc_object_release( p_playlist );
 333     }
 334
 335     msg_rc( _("Remote control interface initialized. Type `help' for help.") );
 336     return VLC_SUCCESS;
 337 }
 338
 339 /*****************************************************************************
 340  * Deactivate: uninitialize and cleanup
 341  *****************************************************************************/
 342 static void Deactivate( vlc_object_t *p_this )
 343 {
 344     intf_thread_t *p_intf = (intf_thread_t*)p_this;
 345
 346     net_ListenClose( p_intf->p_sys->pi_socket_listen );
 347     if( p_intf->p_sys->i_socket != -1 )
 348         net_Close( p_intf->p_sys->i_socket );
 349     if( p_intf->p_sys->psz_unix_path != NULL )
 350     {
 351 #if defined(AF_LOCAL) && !defined(WIN32)
 352         unlink( p_intf->p_sys->psz_unix_path );
 353 #endif
 354         free( p_intf->p_sys->psz_unix_path );
 355     }
 356     vlc_mutex_destroy( &p_intf->p_sys->status_lock );
 357     free( p_intf->p_sys );
 358 }
 359
 360 /*****************************************************************************
 361  * RegisterCallbacks: Register callbacks to dynamic variables
 362  *****************************************************************************/
 363 static void RegisterCallbacks( intf_thread_t *p_intf )
 364 {
 365     /* Register commands that will be cleaned up upon object destruction */
 366     var_Create( p_intf, "quit", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 367     var_AddCallback( p_intf, "quit", Quit, NULL );
 368     var_Create( p_intf, "intf", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 369     var_AddCallback( p_intf, "intf", Intf, NULL );
 370
 371     var_Create( p_intf, "add", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 372     var_AddCallback( p_intf, "add", Playlist, NULL );
 373     var_Create( p_intf, "playlist", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 374     var_AddCallback( p_intf, "playlist", Playlist, NULL );
 375     var_Create( p_intf, "play", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 376     var_AddCallback( p_intf, "play", Playlist, NULL );
 377     var_Create( p_intf, "stop", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 378     var_AddCallback( p_intf, "stop", Playlist, NULL );
 379     var_Create( p_intf, "clear", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 380     var_AddCallback( p_intf, "clear", Playlist, NULL );
 381     var_Create( p_intf, "prev", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 382     var_AddCallback( p_intf, "prev", Playlist, NULL );
 383     var_Create( p_intf, "next", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 384     var_AddCallback( p_intf, "next", Playlist, NULL );
 385     var_Create( p_intf, "goto", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 386     var_AddCallback( p_intf, "goto", Playlist, NULL );
 387     var_Create( p_intf, "status", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 388     var_AddCallback( p_intf, "status", Playlist, NULL );
 389
 390     /* marquee on the fly items */
 391     var_Create( p_intf, "marq-marquee", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 392     var_AddCallback( p_intf, "marq-marquee", Other, NULL );
 393     var_Create( p_intf, "marq-x", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 394     var_AddCallback( p_intf, "marq-x", Other, NULL );
 395     var_Create( p_intf, "marq-y", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 396     var_AddCallback( p_intf, "marq-y", Other, NULL );
 397     var_Create( p_intf, "marq-position", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 398     var_AddCallback( p_intf, "marq-position", Other, NULL );
 399     var_Create( p_intf, "marq-color", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 400     var_AddCallback( p_intf, "marq-color", Other, NULL );
 401     var_Create( p_intf, "marq-opacity", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 402     var_AddCallback( p_intf, "marq-opacity", Other, NULL );
 403     var_Create( p_intf, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 404     var_AddCallback( p_intf, "marq-timeout", Other, NULL );
 405     var_Create( p_intf, "marq-size", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 406     var_AddCallback( p_intf, "marq-size", Other, NULL );
 407
 408     var_Create( p_intf, "mosaic-alpha", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 409     var_AddCallback( p_intf, "mosaic-alpha", Other, NULL );
 410     var_Create( p_intf, "mosaic-height", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 411     var_AddCallback( p_intf, "mosaic-height", Other, NULL );
 412     var_Create( p_intf, "mosaic-width", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 413     var_AddCallback( p_intf, "mosaic-width", Other, NULL );
 414     var_Create( p_intf, "mosaic-xoffset", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 415     var_AddCallback( p_intf, "mosaic-xoffset", Other, NULL );
 416     var_Create( p_intf, "mosaic-yoffset", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 417     var_AddCallback( p_intf, "mosaic-yoffset", Other, NULL );
 418     var_Create( p_intf, "mosaic-align", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 419     var_AddCallback( p_intf, "mosaic-align", Other, NULL );
 420     var_Create( p_intf, "mosaic-vborder", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 421     var_AddCallback( p_intf, "mosaic-vborder", Other, NULL );
 422     var_Create( p_intf, "mosaic-hborder", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 423     var_AddCallback( p_intf, "mosaic-hborder", Other, NULL );
 424     var_Create( p_intf, "mosaic-position",
 425                      VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 426     var_AddCallback( p_intf, "mosaic-position", Other, NULL );
 427     var_Create( p_intf, "mosaic-rows", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 428     var_AddCallback( p_intf, "mosaic-rows", Other, NULL );
 429     var_Create( p_intf, "mosaic-cols", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 430     var_AddCallback( p_intf, "mosaic-cols", Other, NULL );
 431     var_Create( p_intf, "mosaic-keep-aspect-ratio",
 432                      VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 433     var_AddCallback( p_intf, "mosaic-keep-aspect-ratio", Other, NULL );
 434
 435     /* time on the fly items */
 436     var_Create( p_intf, "time-format", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 437     var_AddCallback( p_intf, "time-format", Other, NULL );
 438     var_Create( p_intf, "time-x", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 439     var_AddCallback( p_intf, "time-x", Other, NULL );
 440     var_Create( p_intf, "time-y", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 441     var_AddCallback( p_intf, "time-y", Other, NULL );
 442     var_Create( p_intf, "time-position", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 443     var_AddCallback( p_intf, "time-position", Other, NULL );
 444     var_Create( p_intf, "time-color", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 445     var_AddCallback( p_intf, "time-color", Other, NULL );
 446     var_Create( p_intf, "time-opacity", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 447     var_AddCallback( p_intf, "time-opacity", Other, NULL );
 448     var_Create( p_intf, "time-size", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 449     var_AddCallback( p_intf, "time-size", Other, NULL );
 450
 451     /* logo on the fly items */
 452     var_Create( p_intf, "logo-file", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 453     var_AddCallback( p_intf, "logo-file", Other, NULL );
 454     var_Create( p_intf, "logo-x", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 455     var_AddCallback( p_intf, "logo-x", Other, NULL );
 456     var_Create( p_intf, "logo-y", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 457     var_AddCallback( p_intf, "logo-y", Other, NULL );
 458     var_Create( p_intf, "logo-position", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 459     var_AddCallback( p_intf, "logo-position", Other, NULL );
 460     var_Create( p_intf, "logo-transparency", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 461     var_AddCallback( p_intf, "logo-transparency", Other, NULL );
 462
 463     /* OSD menu commands */
 464     var_Create( p_intf, "menu", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 465     var_AddCallback( p_intf, "menu", Menu, NULL );
 466
 467     /* DVD commands */
 468     var_Create( p_intf, "pause", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 469     var_AddCallback( p_intf, "pause", Input, NULL );
 470     var_Create( p_intf, "seek", VLC_VAR_INTEGER | VLC_VAR_ISCOMMAND );
 471     var_AddCallback( p_intf, "seek", Input, NULL );
 472     var_Create( p_intf, "title", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 473     var_AddCallback( p_intf, "title", Input, NULL );
 474     var_Create( p_intf, "title_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 475     var_AddCallback( p_intf, "title_n", Input, NULL );
 476     var_Create( p_intf, "title_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 477     var_AddCallback( p_intf, "title_p", Input, NULL );
 478     var_Create( p_intf, "chapter", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 479     var_AddCallback( p_intf, "chapter", Input, NULL );
 480     var_Create( p_intf, "chapter_n", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 481     var_AddCallback( p_intf, "chapter_n", Input, NULL );
 482     var_Create( p_intf, "chapter_p", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 483     var_AddCallback( p_intf, "chapter_p", Input, NULL );
 484
 485     var_Create( p_intf, "fastforward", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 486     var_AddCallback( p_intf, "fastforward", Input, NULL );
 487     var_Create( p_intf, "rewind", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 488     var_AddCallback( p_intf, "rewind", Input, NULL );
 489     var_Create( p_intf, "faster", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 490     var_AddCallback( p_intf, "faster", Input, NULL );
 491     var_Create( p_intf, "slower", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 492     var_AddCallback( p_intf, "slower", Input, NULL );
 493     var_Create( p_intf, "normal", VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
 494     var_AddCallback( p_intf, "normal", Input, NULL );
 495
 496     /* audio commands */
 497     var_Create( p_intf, "volume", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 498     var_AddCallback( p_intf, "volume", Volume, NULL );
 499     var_Create( p_intf, "volup", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 500     var_AddCallback( p_intf, "volup", VolumeMove, NULL );
 501     var_Create( p_intf, "voldown", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 502     var_AddCallback( p_intf, "voldown", VolumeMove, NULL );
 503     var_Create( p_intf, "adev", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 504     var_AddCallback( p_intf, "adev", AudioConfig, NULL );
 505     var_Create( p_intf, "achan", VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
 506     var_AddCallback( p_intf, "achan", AudioConfig, NULL );
 507 }
 508
 509 /*****************************************************************************
 510  * Run: rc thread
 511  *****************************************************************************
 512  * This part of the interface is in a separate thread so that we can call
 513  * exec() from within it without annoying the rest of the program.
 514  *****************************************************************************/
 515 static void Run( intf_thread_t *p_intf )
 516 {
 517     input_thread_t * p_input;
 518     playlist_t *     p_playlist;
 519
 520     char       p_buffer[ MAX_LINE_LENGTH + 1 ];
 521     vlc_bool_t b_showpos = config_GetInt( p_intf, "rc-show-pos" );
 522     vlc_bool_t b_longhelp = VLC_FALSE;
 523
 524     int        i_size = 0;
 525     int        i_oldpos = 0;
 526     int        i_newpos;
 527
 528     p_buffer[0] = 0;
 529     p_input = NULL;
 530     p_playlist = NULL;
 531
 532     /* Register commands that will be cleaned up upon object destruction */
 533     RegisterCallbacks( p_intf );
 534
 535     /* status callbacks */
 536     /* Listen to audio volume updates */
 537     var_AddCallback( p_intf->p_vlc, "volume-change", VolumeChanged, p_intf );
 538
 539 #ifdef WIN32
 540     /* Get the file descriptor of the console input */
 541     p_intf->p_sys->hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);
 542     if( p_intf->p_sys->hConsoleIn == INVALID_HANDLE_VALUE )
 543     {
 544         msg_Err( p_intf, "couldn't find user input handle" );
 545         p_intf->b_die = VLC_TRUE;
 546     }
 547 #endif
 548
 549     while( !p_intf->b_die )
 550     {
 551         char *psz_cmd, *psz_arg;
 552         vlc_bool_t b_complete;
 553
 554         if( p_intf->p_sys->pi_socket_listen != NULL &&
 555             p_intf->p_sys->i_socket == -1 )
 556         {
 557             p_intf->p_sys->i_socket =
 558                 net_Accept( p_intf, p_intf->p_sys->pi_socket_listen, 0 );
 559         }
 560
 561         b_complete = ReadCommand( p_intf, p_buffer, &i_size );
 562
 563         /* Manage the input part */
 564         if( p_input == NULL )
 565         {
 566             if( p_playlist )
 567             {
 568                 p_input = vlc_object_find( p_playlist, VLC_OBJECT_INPUT,
 569                                                        FIND_CHILD );
 570             }
 571             else
 572             {
 573                 p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT,
 574                                                    FIND_ANYWHERE );
 575                 if( p_input )
 576                 {
 577                     p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
 578                                                            FIND_PARENT );
 579                 }
 580             }
 581             /* New input has been registered */
 582             if( p_input )
 583             {
 584                 if( !p_input->b_dead || !p_input->b_die )
 585                 {
 586                     msg_rc( STATUS_CHANGE "( new input: %s )", p_input->input.p_item->psz_uri );
 587                     msg_rc( STATUS_CHANGE "( audio volume: %d )", config_GetInt( p_intf, "volume" ));
 588                 }
 589                 var_AddCallback( p_input, "state", StateChanged, p_intf );
 590                 var_AddCallback( p_input, "rate-faster", RateChanged, p_intf );
 591                 var_AddCallback( p_input, "rate-slower", RateChanged, p_intf );
 592                 var_AddCallback( p_input, "rate", RateChanged, p_intf );
 593                 var_AddCallback( p_input, "time-offset", TimeOffsetChanged, p_intf );
 594             }
 595         }
 596         else if( p_input->b_dead )
 597         {
 598             var_DelCallback( p_input, "state", StateChanged, p_intf );
 599             var_DelCallback( p_input, "rate-faster", RateChanged, p_intf );
 600             var_DelCallback( p_input, "rate-slower", RateChanged, p_intf );
 601             var_DelCallback( p_input, "rate", RateChanged, p_intf );
 602             var_DelCallback( p_input, "time-offset", TimeOffsetChanged, p_intf );
 603             vlc_object_release( p_input );
 604             p_input = NULL;
 605
 606             if( p_playlist )
 607             {
 608                 vlc_mutex_lock( &p_playlist->object_lock );
 609                 p_intf->p_sys->i_last_state = (int) PLAYLIST_STOPPED;
 610                 msg_rc( STATUS_CHANGE "( stop state: 0 )" );
 611                 vlc_mutex_unlock( &p_playlist->object_lock );
 612             }
 613         }
 614
 615         if( (p_input != NULL) && !p_input->b_dead && !p_input->b_die &&
 616             (p_playlist != NULL) )
 617         {
 618             vlc_mutex_lock( &p_playlist->object_lock );
 619             if( (p_intf->p_sys->i_last_state != p_playlist->status.i_status) &&
 620                 (p_playlist->status.i_status == PLAYLIST_STOPPED) )
 621             {
 622                 p_intf->p_sys->i_last_state = PLAYLIST_STOPPED;
 623                 msg_rc( STATUS_CHANGE "( stop state: 0 )" );
 624             }
 625             else if( (p_intf->p_sys->i_last_state != p_playlist->status.i_status) &&
 626                 (p_playlist->status.i_status == PLAYLIST_RUNNING) )
 627             {
 628                 p_intf->p_sys->i_last_state = p_playlist->status.i_status;
 629                 msg_rc( STATUS_CHANGE "( play state: 1 )" );
 630             }
 631             else if( (p_intf->p_sys->i_last_state != p_playlist->status.i_status) &&
 632                 (p_playlist->status.i_status == PLAYLIST_PAUSED) )
 633             {
 634                 p_intf->p_sys->i_last_state = p_playlist->status.i_status;
 635                 msg_rc( STATUS_CHANGE "( pause state: 2 )" );
 636             }
 637             vlc_mutex_unlock( &p_playlist->object_lock );
 638         }
 639
 640         if( p_input && b_showpos )
 641         {
 642             i_newpos = 100 * var_GetFloat( p_input, "position" );
 643             if( i_oldpos != i_newpos )
 644             {
 645                 i_oldpos = i_newpos;
 646                 msg_rc( "pos: %d%%", i_newpos );
 647             }
 648         }
 649
 650         /* Is there something to do? */
 651         if( !b_complete ) continue;
 652
 653
 654         /* Skip heading spaces */
 655         psz_cmd = p_buffer;
 656         while( *psz_cmd == ' ' )
 657         {
 658             psz_cmd++;
 659         }
 660
 661         /* Split psz_cmd at the first space and make sure that
 662          * psz_arg is valid */
 663         psz_arg = strchr( psz_cmd, ' ' );
 664         if( psz_arg )
 665         {
 666             *psz_arg++ = 0;
 667             while( *psz_arg == ' ' )
 668             {
 669                 psz_arg++;
 670             }
 671         }
 672         else
 673         {
 674             psz_arg = "";
 675         }
 676
 677         /* If the user typed a registered local command, try it */
 678         if( var_Type( p_intf, psz_cmd ) & VLC_VAR_ISCOMMAND )
 679         {
 680             vlc_value_t val;
 681             int i_ret;
 682
 683             val.psz_string = psz_arg;
 684             i_ret = var_Set( p_intf, psz_cmd, val );
 685             msg_rc( "%s: returned %i (%s)",
 686                     psz_cmd, i_ret, vlc_error( i_ret ) );
 687         }
 688         /* Or maybe it's a global command */
 689         else if( var_Type( p_intf->p_libvlc, psz_cmd ) & VLC_VAR_ISCOMMAND )
 690         {
 691             vlc_value_t val;
 692             int i_ret;
 693
 694             val.psz_string = psz_arg;
 695             /* FIXME: it's a global command, but we should pass the
 696              * local object as an argument, not p_intf->p_libvlc. */
 697             i_ret = var_Set( p_intf->p_libvlc, psz_cmd, val );
 698             if( i_ret != 0 )
 699             {
 700                 msg_rc( "%s: returned %i (%s)",
 701                          psz_cmd, i_ret, vlc_error( i_ret ) );
 702             }
 703         }
 704         else if( !strcmp( psz_cmd, "logout" ) )
 705         {
 706             /* Close connection */
 707             if( p_intf->p_sys->i_socket != -1 )
 708             {
 709                 net_Close( p_intf->p_sys->i_socket );
 710             }
 711             p_intf->p_sys->i_socket = -1;
 712         }
 713         else if( !strcmp( psz_cmd, "info" ) )
 714         {
 715             if( p_input )
 716             {
 717                 int i, j;
 718                 vlc_mutex_lock( &p_input->input.p_item->lock );
 719                 for ( i = 0; i < p_input->input.p_item->i_categories; i++ )
 720                 {
 721                     info_category_t *p_category =
 722                         p_input->input.p_item->pp_categories[i];
 723
 724                     msg_rc( "+----[ %s ]", p_category->psz_name );
 725                     msg_rc( "| " );
 726                     for ( j = 0; j < p_category->i_infos; j++ )
 727                     {
 728                         info_t *p_info = p_category->pp_infos[j];
 729                         msg_rc( "| %s: %s", p_info->psz_name,
 730                                 p_info->psz_value );
 731                     }
 732                     msg_rc( "| " );
 733                 }
 734                 msg_rc( "+----[ end of stream info ]" );
 735                 vlc_mutex_unlock( &p_input->input.p_item->lock );
 736             }
 737             else
 738             {
 739                 msg_rc( "no input" );
 740             }
 741         }
 742         else if( !strcmp( psz_cmd, "is_playing" ) )
 743         {
 744             if( ! p_input )
 745             {
 746                 msg_rc( "0" );
 747             }
 748             else
 749             {
 750                 msg_rc( "1" );
 751             }
 752         }
 753         else if( !strcmp( psz_cmd, "get_time" ) )
 754         {
 755             if( ! p_input )
 756             {
 757                 msg_rc("0");
 758             }
 759             else
 760             {
 761                 vlc_value_t time;
 762                 var_Get( p_input, "time", &time );
 763                 msg_rc( "%i", time.i_time / 1000000);
 764             }
 765         }
 766         else if( !strcmp( psz_cmd, "get_length" ) )
 767         {
 768             if( ! p_input )
 769             {
 770                 msg_rc("0");
 771             }
 772             else
 773             {
 774                 vlc_value_t time;
 775                 var_Get( p_input, "length", &time );
 776                 msg_rc( "%i", time.i_time / 1000000);
 777             }
 778         }
 779         else if( !strcmp( psz_cmd, "get_title" ) )
 780         {
 781             if( ! p_input )
 782             {
 783                 msg_rc("");
 784             }
 785             else
 786             {
 787                 msg_rc( "%s", p_input->input.p_item->psz_name );
 788             }
 789         }
 790         else if( !strcmp( psz_cmd, "longhelp" ) || !strncmp( psz_cmd, "h", 1 )
 791                  || !strncmp( psz_cmd, "H", 1 ) || !strncmp( psz_cmd, "?", 1 ) )
 792         {
 793             if( !strcmp( psz_cmd, "longhelp" ) || !strncmp( psz_cmd, "H", 1 ) )
 794                  b_longhelp = VLC_TRUE;
 795             else b_longhelp = VLC_FALSE;
 796
 797             Help( p_intf, b_longhelp );
 798         }
 799         else if( !strcmp( psz_cmd, "check-updates" ) )
 800         {
 801             checkUpdates( p_intf, psz_arg );
 802         }
 803         else switch( psz_cmd[0] )
 804         {
 805         case 'f':
 806         case 'F':
 807             if( p_input )
 808             {
 809                 vout_thread_t *p_vout;
 810                 p_vout = vlc_object_find( p_input,
 811                                           VLC_OBJECT_VOUT, FIND_CHILD );
 812
 813                 if( p_vout )
 814                 {
 815                     vlc_value_t val;
 816                     vlc_bool_t b_update = VLC_FALSE;
 817                     var_Get( p_vout, "fullscreen", &val );
 818                     val.b_bool = !val.b_bool;
 819                     if( !strncmp(psz_arg, "on", 2) && (val.b_bool == VLC_TRUE) )
 820                     {
 821                         b_update = VLC_TRUE;
 822                         val.b_bool = VLC_TRUE;
 823                     }
 824                     else if( !strncmp(psz_arg, "off", 3)  && (val.b_bool == VLC_FALSE) )
 825                     {
 826                         b_update = VLC_TRUE;
 827                         val.b_bool = VLC_FALSE;
 828                     }
 829                     else if( strncmp(psz_arg, "off", 3) && strncmp(psz_arg, "on", 2) )
 830                         b_update = VLC_TRUE;
 831                     if( b_update ) var_Set( p_vout, "fullscreen", val );
 832                     vlc_object_release( p_vout );
 833                 }
 834             }
 835             break;
 836
 837         case 's':
 838         case 'S':
 839             ;
 840             break;
 841
 842         case '\0':
 843             /* Ignore empty lines */
 844             break;
 845
 846         default:
 847             msg_rc(_("Unknown command `%s'. Type `help' for help."), psz_cmd);
 848             break;
 849         }
 850
 851         /* Command processed */
 852         i_size = 0; p_buffer[0] = 0;
 853     }
 854
 855     msg_rc( STATUS_CHANGE "( stop state: 0 )" );
 856     msg_rc( STATUS_CHANGE "( quit )" );
 857
 858     if( p_input )
 859     {
 860         var_DelCallback( p_input, "state", StateChanged, p_intf );
 861         var_DelCallback( p_input, "rate-faster", RateChanged, p_intf );
 862         var_DelCallback( p_input, "rate-slower", RateChanged, p_intf );
 863         var_DelCallback( p_input, "rate", RateChanged, p_intf );
 864         var_DelCallback( p_input, "time-offset", TimeOffsetChanged, p_intf );
 865         vlc_object_release( p_input );
 866         p_input = NULL;
 867     }
 868
 869     if( p_playlist )
 870     {
 871         vlc_object_release( p_playlist );
 872         p_playlist = NULL;
 873     }
 874
 875     var_DelCallback( p_intf->p_vlc, "volume-change", VolumeChanged, p_intf );
 876 }
 877
 878 static void Help( intf_thread_t *p_intf, vlc_bool_t b_longhelp)
 879 {
 880     msg_rc(_("+----[ Remote control commands ]"));
 881     msg_rc(  "| ");
 882     msg_rc(_("| add XYZ  . . . . . . . . . . add XYZ to playlist"));
 883     msg_rc(_("| playlist . . .  show items currently in playlist"));
 884     msg_rc(_("| play . . . . . . . . . . . . . . . . play stream"));
 885     msg_rc(_("| stop . . . . . . . . . . . . . . . . stop stream"));
 886     msg_rc(_("| next . . . . . . . . . . . .  next playlist item"));
 887     msg_rc(_("| prev . . . . . . . . . .  previous playlist item"));
 888     msg_rc(_("| goto . . . . . . . . . . . .  goto item at index"));
 889     msg_rc(_("| clear . . . . . . . . . . .   clear the playlist"));
 890     msg_rc(_("| status . . . . . . . . . current playlist status"));
 891     msg_rc(_("| title [X]  . . . . set/get title in current item"));
 892     msg_rc(_("| title_n  . . . . . .  next title in current item"));
 893     msg_rc(_("| title_p  . . . .  previous title in current item"));
 894     msg_rc(_("| chapter [X]  . . set/get chapter in current item"));
 895     msg_rc(_("| chapter_n  . . . .  next chapter in current item"));
 896     msg_rc(_("| chapter_p  . .  previous chapter in current item"));
 897     msg_rc(  "| ");
 898     msg_rc(_("| seek X . seek in seconds, for instance `seek 12'"));
 899     msg_rc(_("| pause  . . . . . . . . . . . . . .  toggle pause"));
 900     msg_rc(_("| fastforward  . . . . . .  .  set to maximum rate"));
 901     msg_rc(_("| rewind  . . . . . . . . . .  set to minimum rate"));
 902     msg_rc(_("| faster . . . . . . . .  faster playing of stream"));
 903     msg_rc(_("| slower . . . . . . . .  slower playing of stream"));
 904     msg_rc(_("| normal . . . . . . . .  normal playing of stream"));
 905     msg_rc(_("| f [on|off] . . . . . . . . . . toggle fullscreen"));
 906     msg_rc(_("| info . . .  information about the current stream"));
 907     msg_rc(_("| get_time . . seconds elapsed since stream's beginning"));
 908     msg_rc(_("| is_playing . .  1 if a stream plays, 0 otherwise"));
 909     msg_rc(_("| get_title . . .  the title of the current stream"));
 910     msg_rc(_("| get_length . .  the length of the current stream"));
 911     msg_rc(  "| ");
 912     msg_rc(_("| volume [X] . . . . . . . .  set/get audio volume"));
 913     msg_rc(_("| volup [X]  . . . . .  raise audio volume X steps"));
 914     msg_rc(_("| voldown [X]  . . . .  lower audio volume X steps"));
 915     msg_rc(_("| adev [X] . . . . . . . . .  set/get audio device"));
 916     msg_rc(_("| achan [X]. . . . . . . .  set/get audio channels"));
 917     msg_rc(_("| menu [on|off|up|down|left|right|select] use menu"));
 918     msg_rc(  "| ");
 919
 920     if (b_longhelp)
 921     {
 922         msg_rc(_("| marq-marquee STRING  . . overlay STRING in video"));
 923         msg_rc(_("| marq-x X . . . . . . . . . . . .offset from left"));
 924         msg_rc(_("| marq-y Y . . . . . . . . . . . . offset from top"));
 925         msg_rc(_("| marq-position #. . .  .relative position control"));
 926         msg_rc(_("| marq-color # . . . . . . . . . . font color, RGB"));
 927         msg_rc(_("| marq-opacity # . . . . . . . . . . . . . opacity"));
 928         msg_rc(_("| marq-timeout T. . . . . . . . . . timeout, in ms"));
 929         msg_rc(_("| marq-size # . . . . . . . . font size, in pixels"));
 930         msg_rc(  "| ");
 931         msg_rc(_("| time-format STRING . . . overlay STRING in video"));
 932         msg_rc(_("| time-x X . . . . . . . . . . . .offset from left"));
 933         msg_rc(_("| time-y Y . . . . . . . . . . . . offset from top"));
 934         msg_rc(_("| time-position #. . . . . . . . relative position"));
 935         msg_rc(_("| time-color # . . . . . . . . . . font color, RGB"));
 936         msg_rc(_("| time-opacity # . . . . . . . . . . . . . opacity"));
 937         msg_rc(_("| time-size # . . . . . . . . font size, in pixels"));
 938         msg_rc(  "| ");
 939         msg_rc(_("| logo-file STRING . . .the overlay file path/name"));
 940         msg_rc(_("| logo-x X . . . . . . . . . . . .offset from left"));
 941         msg_rc(_("| logo-y Y . . . . . . . . . . . . offset from top"));
 942         msg_rc(_("| logo-position #. . . . . . . . relative position"));
 943         msg_rc(_("| logo-transparency #. . . . . . . . .transparency"));
 944         msg_rc(  "| ");
 945         msg_rc(_("| mosaic-alpha # . . . . . . . . . . . . . . alpha"));
 946         msg_rc(_("| mosaic-height #. . . . . . . . . . . . . .height"));
 947         msg_rc(_("| mosaic-width # . . . . . . . . . . . . . . width"));
 948         msg_rc(_("| mosaic-xoffset # . . . .top left corner position"));
 949         msg_rc(_("| mosaic-yoffset # . . . .top left corner position"));
 950         msg_rc(_("| mosaic-align 0..2,4..6,8..10. . .mosaic alignment"));
 951         msg_rc(_("| mosaic-vborder # . . . . . . . . vertical border"));
 952         msg_rc(_("| mosaic-hborder # . . . . . . . horizontal border"));
 953         msg_rc(_("| mosaic-position {0=auto,1=fixed} . . . .position"));
 954         msg_rc(_("| mosaic-rows #. . . . . . . . . . .number of rows"));
 955         msg_rc(_("| mosaic-cols #. . . . . . . . . . .number of cols"));
 956         msg_rc(_("| mosaic-keep-aspect-ratio {0,1} . . .aspect ratio"));
 957         msg_rc(  "| ");
 958         msg_rc(_("| check-updates [newer] [equal] [older]\n"
 959                  "|               [undef] [info] [source] [binary] [plugin]"));
 960         msg_rc(  "| ");
 961     }
 962     msg_rc(_("| help . . . . . . . . . . . . . this help message"));
 963     msg_rc(_("| longhelp . . . . . . . . . a longer help message"));
 964     msg_rc(_("| logout . . . . .  exit (if in socket connection)"));
 965     msg_rc(_("| quit . . . . . . . . . . . . . . . . .  quit vlc"));
 966     msg_rc(  "| ");
 967     msg_rc(_("+----[ end of help ]"));
 968 }
 969
 970 /********************************************************************
 971  * Status callback routines
 972  ********************************************************************/
 973 static int TimeOffsetChanged( vlc_object_t *p_this, char const *psz_cmd,
 974     vlc_value_t oldval, vlc_value_t newval, void *p_data )
 975 {
 976     intf_thread_t *p_intf = (intf_thread_t*)p_data;
 977     input_thread_t *p_input = NULL;
 978
 979     vlc_mutex_lock( &p_intf->p_sys->status_lock );
 980     p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
 981     if( p_input )
 982     {
 983         msg_rc( STATUS_CHANGE "( time-offset: %d )", var_GetInteger( p_input, "time-offset" ) );
 984         vlc_object_release( p_input );
 985     }
 986     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
 987     return VLC_SUCCESS;
 988 }
 989
 990 static int VolumeChanged( vlc_object_t *p_this, char const *psz_cmd,
 991     vlc_value_t oldval, vlc_value_t newval, void *p_data )
 992 {
 993     intf_thread_t *p_intf = (intf_thread_t*)p_data;
 994
 995     vlc_mutex_lock( &p_intf->p_sys->status_lock );
 996     msg_rc( STATUS_CHANGE "( audio volume: %d )", config_GetInt( p_this, "volume") );
 997     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
 998     return VLC_SUCCESS;
 999 }
1000
1001 static int StateChanged( vlc_object_t *p_this, char const *psz_cmd,
1002     vlc_value_t oldval, vlc_value_t newval, void *p_data )
1003 {
1004     intf_thread_t *p_intf = (intf_thread_t*)p_data;
1005     playlist_t    *p_playlist = NULL;
1006     input_thread_t *p_input = NULL;
1007
1008     vlc_mutex_lock( &p_intf->p_sys->status_lock );
1009     p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1010     if( p_input )
1011     {
1012         p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST, FIND_PARENT );
1013         if( p_playlist )
1014         {
1015             char cmd[5] = "";
1016             switch( p_playlist->status.i_status )
1017             {
1018             case PLAYLIST_STOPPED:
1019                 strncpy( &cmd[0], "stop", 4);
1020                 cmd[4] = '\0';
1021                 break;
1022             case PLAYLIST_RUNNING:
1023                 strncpy( &cmd[0], "play", 4);
1024                 cmd[4] = '\0';
1025                 break;
1026             case PLAYLIST_PAUSED:
1027                 strncpy( &cmd[0], "pause", 5);
1028                 cmd[5] = '\0';
1029                 break;
1030             } /* var_GetInteger( p_input, "state" )  */
1031             msg_rc( STATUS_CHANGE "( %s state: %d )", &cmd[0], newval.i_int );
1032             vlc_object_release( p_playlist );
1033         }
1034         vlc_object_release( p_input );
1035     }
1036     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
1037     return VLC_SUCCESS;
1038 }
1039
1040 static int RateChanged( vlc_object_t *p_this, char const *psz_cmd,
1041     vlc_value_t oldval, vlc_value_t newval, void *p_data )
1042 {
1043     intf_thread_t *p_intf = (intf_thread_t*)p_data;
1044     input_thread_t *p_input = NULL;
1045
1046     vlc_mutex_lock( &p_intf->p_sys->status_lock );
1047     p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1048     if( p_input )
1049     {
1050         msg_rc( STATUS_CHANGE "( new rate: %d )", var_GetInteger( p_input, "rate" ) );
1051         vlc_object_release( p_input );
1052     }
1053     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
1054     return VLC_SUCCESS;
1055 }
1056
1057 /********************************************************************
1058  * Command routines
1059  ********************************************************************/
1060 static int Input( vlc_object_t *p_this, char const *psz_cmd,
1061                   vlc_value_t oldval, vlc_value_t newval, void *p_data )
1062 {
1063     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1064     input_thread_t *p_input;
1065     vlc_value_t     val;
1066
1067     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1068     if( !p_input ) return VLC_ENOOBJ;
1069
1070     var_Get( p_input, "state", &val );
1071     if( ( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) ) &&
1072         ( strcmp( psz_cmd, "pause" ) != 0 ) )
1073     {
1074         msg_rc( _("Press menu select or pause to continue.") );
1075         vlc_object_release( p_input );
1076         return VLC_EGENERIC;
1077     }
1078
1079     /* Parse commands that only require an input */
1080     if( !strcmp( psz_cmd, "pause" ) )
1081     {
1082         val.i_int = config_GetInt( p_intf, "key-play-pause" );
1083         var_Set( p_intf->p_vlc, "key-pressed", val );
1084         vlc_object_release( p_input );
1085         return VLC_SUCCESS;
1086     }
1087     else if( !strcmp( psz_cmd, "seek" ) )
1088     {
1089         if( strlen( newval.psz_string ) > 0 &&
1090             newval.psz_string[strlen( newval.psz_string ) - 1] == '%' )
1091         {
1092             val.f_float = (float)atoi( newval.psz_string ) / 100.0;
1093             var_Set( p_input, "position", val );
1094         }
1095         else
1096         {
1097             val.i_time = ((int64_t)atoi( newval.psz_string )) * 1000000;
1098             var_Set( p_input, "time", val );
1099         }
1100         vlc_object_release( p_input );
1101         return VLC_SUCCESS;
1102     }
1103     else if ( !strcmp( psz_cmd, "fastforward" ) )
1104     {
1105         val.i_int = config_GetInt( p_intf, "key-jump+extrashort" );
1106         var_Set( p_intf->p_vlc, "key-pressed", val );
1107         vlc_object_release( p_input );
1108         return VLC_SUCCESS;
1109     }
1110     else if ( !strcmp( psz_cmd, "rewind" ) )
1111     {
1112         val.i_int = config_GetInt( p_intf, "key-jump-extrashort" );
1113         var_Set( p_intf->p_vlc, "key-pressed", val );
1114         vlc_object_release( p_input );
1115         return VLC_SUCCESS;
1116     }
1117     else if ( !strcmp( psz_cmd, "faster" ) )
1118     {
1119         val.b_bool = VLC_TRUE;
1120         var_Set( p_input, "rate-faster", val );
1121         vlc_object_release( p_input );
1122         return VLC_SUCCESS;
1123     }
1124     else if ( !strcmp( psz_cmd, "slower" ) )
1125     {
1126         val.b_bool = VLC_TRUE;
1127         var_Set( p_input, "rate-slower", val );
1128         vlc_object_release( p_input );
1129         return VLC_SUCCESS;
1130     }
1131     else if ( !strcmp( psz_cmd, "normal" ) )
1132     {
1133         val.i_int = INPUT_RATE_DEFAULT;
1134         var_Set( p_input, "rate", val );
1135         vlc_object_release( p_input );
1136         return VLC_SUCCESS;
1137     }
1138     else if( !strcmp( psz_cmd, "chapter" ) ||
1139              !strcmp( psz_cmd, "chapter_n" ) ||
1140              !strcmp( psz_cmd, "chapter_p" ) )
1141     {
1142         if( !strcmp( psz_cmd, "chapter" ) )
1143         {
1144             if ( *newval.psz_string )
1145             {
1146                 /* Set. */
1147                 val.i_int = atoi( newval.psz_string );
1148                 var_Set( p_input, "chapter", val );
1149             }
1150             else
1151             {
1152                 vlc_value_t val_list;
1153
1154                 /* Get. */
1155                 var_Get( p_input, "chapter", &val );
1156                 var_Change( p_input, "chapter", VLC_VAR_GETCHOICES,
1157                             &val_list, NULL );
1158                 msg_rc( "Currently playing chapter %d/%d.",
1159                         val.i_int, val_list.p_list->i_count );
1160                 var_Change( p_this, "chapter", VLC_VAR_FREELIST,
1161                             &val_list, NULL );
1162             }
1163         }
1164         else if( !strcmp( psz_cmd, "chapter_n" ) )
1165         {
1166             val.b_bool = VLC_TRUE;
1167             var_Set( p_input, "next-chapter", val );
1168         }
1169         else if( !strcmp( psz_cmd, "chapter_p" ) )
1170         {
1171             val.b_bool = VLC_TRUE;
1172             var_Set( p_input, "prev-chapter", val );
1173         }
1174         vlc_object_release( p_input );
1175         return VLC_SUCCESS;
1176     }
1177     else if( !strcmp( psz_cmd, "title" ) ||
1178              !strcmp( psz_cmd, "title_n" ) ||
1179              !strcmp( psz_cmd, "title_p" ) )
1180     {
1181         if( !strcmp( psz_cmd, "title" ) )
1182         {
1183             if ( *newval.psz_string )
1184             {
1185                 /* Set. */
1186                 val.i_int = atoi( newval.psz_string );
1187                 var_Set( p_input, "title", val );
1188             }
1189             else
1190             {
1191                 vlc_value_t val_list;
1192
1193                 /* Get. */
1194                 var_Get( p_input, "title", &val );
1195                 var_Change( p_input, "title", VLC_VAR_GETCHOICES,
1196                             &val_list, NULL );
1197                 msg_rc( "Currently playing title %d/%d.",
1198                         val.i_int, val_list.p_list->i_count );
1199                 var_Change( p_this, "title", VLC_VAR_FREELIST,
1200                             &val_list, NULL );
1201             }
1202         }
1203         else if( !strcmp( psz_cmd, "title_n" ) )
1204         {
1205             val.b_bool = VLC_TRUE;
1206             var_Set( p_input, "next-title", val );
1207         }
1208         else if( !strcmp( psz_cmd, "title_p" ) )
1209         {
1210             val.b_bool = VLC_TRUE;
1211             var_Set( p_input, "prev-title", val );
1212         }
1213
1214         vlc_object_release( p_input );
1215         return VLC_SUCCESS;
1216     }
1217
1218     /* Never reached. */
1219     vlc_object_release( p_input );
1220     return VLC_EGENERIC;
1221 }
1222
1223 static int Playlist( vlc_object_t *p_this, char const *psz_cmd,
1224                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
1225 {
1226     vlc_value_t val;
1227     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1228     playlist_t *p_playlist;
1229
1230     p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST,
1231                                            FIND_ANYWHERE );
1232     if( !p_playlist )
1233     {
1234         return VLC_ENOOBJ;
1235     }
1236
1237     if( p_playlist->p_input )
1238     {
1239         vlc_value_t val;
1240         var_Get( p_playlist->p_input, "state", &val );
1241         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )        {
1242             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1243             vlc_object_release( p_playlist );
1244             return VLC_EGENERIC;
1245         }
1246     }
1247
1248     /* Parse commands that require a playlist */
1249     if( !strcmp( psz_cmd, "prev" ) )
1250     {
1251         playlist_Prev( p_playlist );
1252     }
1253     else if( !strcmp( psz_cmd, "next" ) )
1254     {
1255         playlist_Next( p_playlist );
1256     }
1257     else if( !strcmp( psz_cmd, "play" ) )
1258     {
1259         if( p_playlist->p_input )
1260         {
1261             vlc_value_t val;
1262
1263             var_Get( p_playlist->p_input, "rate", &val );
1264             if( val.i_int != INPUT_RATE_DEFAULT )
1265             {
1266                 val.i_int = INPUT_RATE_DEFAULT;
1267                 var_Set( p_playlist->p_input, "rate", val );
1268             }
1269             else
1270             {
1271                 playlist_Play( p_playlist );
1272             }
1273         }
1274     }
1275     else if (!strcmp( psz_cmd, "goto" ) )
1276     {
1277         if( strlen( newval.psz_string ) > 0)
1278         {
1279             val.i_int = atoi( newval.psz_string );
1280             playlist_Goto( p_playlist, val.i_int);
1281         }
1282     }
1283     else if( !strcmp( psz_cmd, "stop" ) )
1284     {
1285         playlist_Stop( p_playlist );
1286     }
1287     else if( !strcmp( psz_cmd, "clear" ) )
1288     {
1289         playlist_Stop( p_playlist );
1290         vlc_mutex_lock( &p_playlist->object_lock );
1291         playlist_Clear( p_playlist );
1292         vlc_mutex_unlock( &p_playlist->object_lock );
1293     }
1294     else if( !strcmp( psz_cmd, "add" ) &&
1295              newval.psz_string && *newval.psz_string )
1296     {
1297         playlist_item_t *p_item = parse_MRL( p_intf, newval.psz_string );
1298
1299         if( p_item )
1300         {
1301             msg_rc( "Trying to add %s to playlist.", newval.psz_string );
1302             playlist_AddItem( p_playlist, p_item,
1303                               PLAYLIST_GO|PLAYLIST_APPEND, PLAYLIST_END );
1304         }
1305     }
1306     else if( !strcmp( psz_cmd, "playlist" ) )
1307     {
1308         int i;
1309
1310         for ( i = 0; i < p_playlist->i_size; i++ )
1311         {
1312             msg_rc( "|%s%s   %s|%s|", i == p_playlist->i_index ? "*" : " ",
1313                     p_playlist->pp_items[i]->input.psz_name,
1314                     p_playlist->pp_items[i]->input.psz_uri,
1315                     p_playlist->pp_items[i]->i_parents > 0 ?
1316                     p_playlist->pp_items[i]->pp_parents[0]->p_parent->input.psz_name : "" );
1317         }
1318         if ( i == 0 )
1319         {
1320             msg_rc( "| no entries" );
1321         }
1322     }
1323     else if( !strcmp( psz_cmd, "status" ) )
1324     {
1325         if( p_playlist->p_input )
1326         {
1327             /* Replay the current state of the system. */
1328             msg_rc( STATUS_CHANGE "( new input: %s )", p_playlist->p_input->input.p_item->psz_uri );
1329             msg_rc( STATUS_CHANGE "( audio volume: %d )", config_GetInt( p_intf, "volume" ));
1330
1331             vlc_mutex_lock( &p_playlist->object_lock );
1332             switch( p_playlist->status.i_status )
1333             {
1334                 case PLAYLIST_STOPPED:
1335                     msg_rc( STATUS_CHANGE "( stop state: 0 )" );
1336                     break;
1337                 case PLAYLIST_RUNNING:
1338                     msg_rc( STATUS_CHANGE "( play state: 1 )" );
1339                     break;
1340                 case PLAYLIST_PAUSED:
1341                     msg_rc( STATUS_CHANGE "( pause state: 2 )" );
1342                     break;
1343                 default:
1344                     msg_rc( STATUS_CHANGE "( state unknown )" );
1345                     break;
1346             }
1347             vlc_mutex_unlock( &p_playlist->object_lock );
1348         }
1349     }
1350
1351     /*
1352      * sanity check
1353      */
1354     else
1355     {
1356         msg_rc( "unknown command!" );
1357     }
1358
1359     vlc_object_release( p_playlist );
1360     return VLC_SUCCESS;
1361 }
1362
1363 static int Other( vlc_object_t *p_this, char const *psz_cmd,
1364                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
1365 {
1366     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1367     vlc_object_t  *p_playlist;
1368     vlc_value_t    val;
1369     vlc_object_t  *p_input;
1370
1371     p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1372     if( !p_playlist )
1373     {
1374         return VLC_ENOOBJ;
1375     }
1376
1377     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1378     if( !p_input )
1379     {
1380         vlc_object_release( p_playlist );
1381         return VLC_ENOOBJ;
1382     }
1383
1384     if( p_input )
1385     {
1386         var_Get( p_input, "state", &val );
1387         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )
1388         {
1389             msg_rc( _("Type 'pause' to continue.") );
1390             vlc_object_release( p_playlist );
1391             vlc_object_release( p_input );
1392             return VLC_EGENERIC;
1393         }
1394     }
1395
1396     /* Parse miscellaneous commands */
1397     if( !strcmp( psz_cmd, "marq-marquee" ) )
1398     {
1399         if( strlen( newval.psz_string ) > 0 )
1400         {
1401             val.psz_string = newval.psz_string;
1402             var_Set( p_input->p_libvlc, "marq-marquee", val );
1403         }
1404         else
1405         {
1406                 val.psz_string = "";
1407                 var_Set( p_input->p_libvlc, "marq-marquee", val);
1408         }
1409     }
1410     else if( !strcmp( psz_cmd, "marq-x" ) )
1411     {
1412         if( strlen( newval.psz_string ) > 0)
1413         {
1414             val.i_int = atoi( newval.psz_string );
1415             var_Set( p_input->p_libvlc, "marq-x", val );
1416         }
1417     }
1418     else if( !strcmp( psz_cmd, "marq-y" ) )
1419     {
1420         if( strlen( newval.psz_string ) > 0)
1421         {
1422             val.i_int = atoi( newval.psz_string );
1423             var_Set( p_input->p_libvlc, "marq-y", val );
1424         }
1425     }
1426     else if( !strcmp( psz_cmd, "marq-position" ) )
1427     {
1428         if( strlen( newval.psz_string ) > 0)
1429         {
1430             val.i_int = atoi( newval.psz_string );
1431             var_Set( p_input->p_libvlc, "marq-position", val );
1432         }
1433     }
1434     else if( !strcmp( psz_cmd, "marq-color" ) )
1435     {
1436         if( strlen( newval.psz_string ) > 0)
1437         {
1438             val.i_int = strtol( newval.psz_string, NULL, 0 );
1439             var_Set( p_input->p_libvlc, "marq-color", val );
1440         }
1441     }
1442     else if( !strcmp( psz_cmd, "marq-opacity" ) )
1443     {
1444         if( strlen( newval.psz_string ) > 0)
1445         {
1446             val.i_int = strtol( newval.psz_string, NULL, 0 );
1447             var_Set( p_input->p_libvlc, "marq-opacity", val );
1448         }
1449     }
1450     else if( !strcmp( psz_cmd, "marq-size" ) )
1451     {
1452         if( strlen( newval.psz_string ) > 0)
1453         {
1454             val.i_int = atoi( newval.psz_string );
1455             var_Set( p_input->p_libvlc, "marq-size", val );
1456         }
1457     }
1458     else if( !strcmp( psz_cmd, "marq-timeout" ) )
1459     {
1460         if( strlen( newval.psz_string ) > 0)
1461         {
1462             val.i_int = atoi( newval.psz_string );
1463             var_Set( p_input, "marq-timeout", val );
1464         }
1465     }
1466     else if( !strcmp( psz_cmd, "mosaic-alpha" ) )
1467     {
1468         if( strlen( newval.psz_string ) > 0)
1469         {
1470             val.i_int = atoi( newval.psz_string );
1471             var_Set( p_input->p_libvlc, "mosaic-alpha", val );
1472         }
1473     }
1474     else if( !strcmp( psz_cmd, "mosaic-height" ) )
1475     {
1476         if( strlen( newval.psz_string ) > 0)
1477         {
1478             val.i_int = atoi( newval.psz_string );
1479             var_Set( p_input->p_libvlc, "mosaic-height", val );
1480         }
1481     }
1482     else if( !strcmp( psz_cmd, "mosaic-width" ) )
1483     {
1484         if( strlen( newval.psz_string ) > 0)
1485         {
1486             val.i_int = atoi( newval.psz_string );
1487             var_Set( p_input->p_libvlc, "mosaic-width", val );
1488         }
1489     }
1490     else if( !strcmp( psz_cmd, "mosaic-xoffset" ) )
1491     {
1492         if( strlen( newval.psz_string ) > 0)
1493         {
1494             val.i_int = atoi( newval.psz_string );
1495             var_Set( p_input->p_libvlc, "mosaic-xoffset", val );
1496         }
1497     }
1498     else if( !strcmp( psz_cmd, "mosaic-yoffset" ) )
1499     {
1500         if( strlen( newval.psz_string ) > 0)
1501         {
1502             val.i_int = atoi( newval.psz_string );
1503             var_Set( p_input->p_libvlc, "mosaic-yoffset", val );
1504         }
1505     }
1506     else if( !strcmp( psz_cmd, "mosaic-align" ) )
1507     {
1508         if( strlen( newval.psz_string ) > 0 )
1509         {
1510             val.i_int = atoi( newval.psz_string );
1511             var_Set( p_input->p_libvlc, "mosaic-align", val );
1512         }
1513     }
1514     else if( !strcmp( psz_cmd, "mosaic-vborder" ) )
1515     {
1516         if( strlen( newval.psz_string ) > 0)
1517         {
1518             val.i_int = atoi( newval.psz_string );
1519             var_Set( p_input->p_libvlc, "mosaic-vborder", val );
1520         }
1521     }
1522     else if( !strcmp( psz_cmd, "mosaic-hborder" ) )
1523     {
1524         if( strlen( newval.psz_string ) > 0)
1525         {
1526             val.i_int = atoi( newval.psz_string );
1527             var_Set( p_input->p_libvlc, "mosaic-hborder", val );
1528         }
1529     }
1530     else if( !strcmp( psz_cmd, "mosaic-position" ) )
1531     {
1532         if( strlen( newval.psz_string ) > 0)
1533         {
1534             val.i_int = atoi( newval.psz_string );
1535             var_Set( p_input->p_libvlc, "mosaic-position", val );
1536         }
1537     }
1538     else if( !strcmp( psz_cmd, "mosaic-rows" ) )
1539     {
1540         if( strlen( newval.psz_string ) > 0)
1541         {
1542             val.i_int = atoi( newval.psz_string );
1543             var_Set( p_input->p_libvlc, "mosaic-rows", val );
1544         }
1545     }
1546     else if( !strcmp( psz_cmd, "mosaic-cols" ) )
1547     {
1548         if( strlen( newval.psz_string ) > 0)
1549         {
1550             val.i_int = atoi( newval.psz_string );
1551             var_Set( p_input->p_libvlc, "mosaic-cols", val );
1552         }
1553     }
1554     else if( !strcmp( psz_cmd, "mosaic-keep-aspect-ratio" ) )
1555     {
1556         if( strlen( newval.psz_string ) > 0)
1557         {
1558             val.i_int = atoi( newval.psz_string );
1559             var_Set( p_input->p_libvlc, "mosaic-keep-aspect-ratio", val );
1560         }
1561     }
1562     else if( !strcmp( psz_cmd, "time-format" ) )
1563     {
1564         if( strlen( newval.psz_string ) > 0 )
1565         {
1566             val.psz_string = newval.psz_string;
1567             var_Set( p_input->p_libvlc, "time-format", val );
1568         }
1569         else
1570         {
1571             val.psz_string = "";
1572             var_Set( p_input->p_libvlc, "time-format", val);
1573         }
1574     }
1575     else if( !strcmp( psz_cmd, "time-x" ) )
1576     {
1577         if( strlen( newval.psz_string ) > 0)
1578         {
1579             val.i_int = atoi( newval.psz_string );
1580             var_Set( p_input->p_libvlc, "time-x", val );
1581         }
1582     }
1583     else if( !strcmp( psz_cmd, "time-y" ) )
1584     {
1585         if( strlen( newval.psz_string ) > 0)
1586         {
1587             val.i_int = atoi( newval.psz_string );
1588             var_Set( p_input->p_libvlc, "time-y", val );
1589         }
1590     }
1591     else if( !strcmp( psz_cmd, "time-position" ) )
1592     {
1593         if( strlen( newval.psz_string ) > 0)
1594         {
1595             val.i_int = atoi( newval.psz_string );
1596             var_Set( p_input->p_libvlc, "time-position", val );
1597         }
1598     }
1599     else if( !strcmp( psz_cmd, "time-color" ) )
1600     {
1601         if( strlen( newval.psz_string ) > 0)
1602         {
1603             val.i_int = strtol( newval.psz_string, NULL, 0 );
1604             var_Set( p_input->p_libvlc, "time-color", val );
1605         }
1606     }
1607     else if( !strcmp( psz_cmd, "time-opacity" ) )
1608     {
1609         if( strlen( newval.psz_string ) > 0)
1610         {
1611             val.i_int = strtol( newval.psz_string, NULL, 0 );
1612             var_Set( p_input->p_libvlc, "time-opacity", val );
1613         }
1614     }
1615     else if( !strcmp( psz_cmd, "time-size" ) )
1616     {
1617         if( strlen( newval.psz_string ) > 0)
1618         {
1619             val.i_int = atoi( newval.psz_string );
1620             var_Set( p_input->p_libvlc, "time-size", val );
1621         }
1622     }
1623     else if( !strcmp( psz_cmd, "logo-file" ) )
1624     {
1625         if( strlen( newval.psz_string ) > 0 )
1626         {
1627             val.psz_string = newval.psz_string;
1628             var_Set( p_input->p_libvlc, "logo-file", val );
1629         }
1630     }
1631     else if( !strcmp( psz_cmd, "logo-x" ) )
1632     {
1633         if( strlen( newval.psz_string ) > 0)
1634         {
1635             val.i_int = atoi( newval.psz_string );
1636             var_Set( p_input->p_libvlc, "logo-x", val );
1637         }
1638     }
1639     else if( !strcmp( psz_cmd, "logo-y" ) )
1640     {
1641         if( strlen( newval.psz_string ) > 0)
1642         {
1643             val.i_int = atoi( newval.psz_string );
1644             var_Set( p_input->p_libvlc, "logo-y", val );
1645         }
1646     }
1647     else if( !strcmp( psz_cmd, "logo-position" ) )
1648     {
1649         if( strlen( newval.psz_string ) > 0)
1650         {
1651             val.i_int = atoi( newval.psz_string );
1652             var_Set( p_input->p_libvlc, "logo-position", val );
1653         }
1654     }
1655     else if( !strcmp( psz_cmd, "logo-transparency" ) )
1656     {
1657         if( strlen( newval.psz_string ) > 0)
1658         {
1659             val.i_int = strtol( newval.psz_string, NULL, 0 );
1660             var_Set( p_input->p_libvlc, "logo-transparency", val );
1661         }
1662     }
1663
1664     /*
1665      * sanity check
1666      */
1667     else
1668     {
1669         msg_rc( "Unknown command!" );
1670     }
1671
1672     vlc_object_release( p_playlist );
1673     vlc_object_release( p_input );
1674     return VLC_SUCCESS;
1675 }
1676
1677 static int Quit( vlc_object_t *p_this, char const *psz_cmd,
1678                  vlc_value_t oldval, vlc_value_t newval, void *p_data )
1679 {
1680     playlist_t *p_playlist;
1681
1682     p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1683     if( p_playlist )
1684     {
1685         playlist_Stop( p_playlist );
1686         vlc_object_release( p_playlist );
1687     }
1688     p_this->p_vlc->b_die = VLC_TRUE;
1689     return VLC_SUCCESS;
1690 }
1691
1692 static int Intf( vlc_object_t *p_this, char const *psz_cmd,
1693                  vlc_value_t oldval, vlc_value_t newval, void *p_data )
1694 {
1695     intf_thread_t *p_newintf = NULL;
1696
1697     p_newintf = intf_Create( p_this->p_vlc, newval.psz_string, 0, NULL );
1698     if( p_newintf )
1699     {
1700         p_newintf->b_block = VLC_FALSE;
1701         if( intf_RunThread( p_newintf ) )
1702         {
1703             vlc_object_detach( p_newintf );
1704             intf_Destroy( p_newintf );
1705         }
1706     }
1707
1708     return VLC_SUCCESS;
1709 }
1710
1711 static int Volume( vlc_object_t *p_this, char const *psz_cmd,
1712                    vlc_value_t oldval, vlc_value_t newval, void *p_data )
1713 {
1714     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1715     input_thread_t *p_input = NULL;
1716     int i_error = VLC_EGENERIC;
1717
1718     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1719     if( !p_input )
1720         return VLC_ENOOBJ;
1721
1722     if( p_input )
1723     {
1724         vlc_value_t val;
1725
1726         var_Get( p_input, "state", &val );
1727         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )
1728         {
1729             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1730             vlc_object_release( p_input );
1731             return VLC_EGENERIC;
1732         }
1733         vlc_object_release( p_input );
1734     }
1735
1736     if ( *newval.psz_string )
1737     {
1738         /* Set. */
1739         audio_volume_t i_volume = atoi( newval.psz_string );
1740         if ( (i_volume > (audio_volume_t)AOUT_VOLUME_MAX) )
1741         {
1742             msg_rc( "Volume must be in the range %d-%d.", AOUT_VOLUME_MIN,
1743                     AOUT_VOLUME_MAX );
1744             i_error = VLC_EBADVAR;
1745         }
1746         else
1747         {
1748             if( i_volume == AOUT_VOLUME_MIN )
1749             {
1750                 vlc_value_t keyval;
1751
1752                 keyval.i_int = config_GetInt( p_intf, "key-vol-mute" );
1753                 var_Set( p_intf->p_vlc, "key-pressed", keyval );
1754             }
1755             i_error = aout_VolumeSet( p_this, i_volume );
1756             osd_Volume( p_this );
1757             msg_rc( STATUS_CHANGE "( audio volume: %d )", i_volume );
1758         }
1759     }
1760     else
1761     {
1762         /* Get. */
1763         audio_volume_t i_volume;
1764         if ( aout_VolumeGet( p_this, &i_volume ) < 0 )
1765         {
1766             i_error = VLC_EGENERIC;
1767         }
1768         else
1769         {
1770             msg_rc( STATUS_CHANGE "( audio volume: %d )", i_volume );
1771             i_error = VLC_SUCCESS;
1772         }
1773     }
1774
1775     return i_error;
1776 }
1777
1778 static int VolumeMove( vlc_object_t *p_this, char const *psz_cmd,
1779                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1780 {
1781     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1782     audio_volume_t i_volume;
1783     input_thread_t *p_input = NULL;
1784     int i_nb_steps = atoi(newval.psz_string);
1785     int i_error = VLC_SUCCESS;
1786     int i_volume_step = 0;
1787
1788     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1789     if( !p_input )
1790         return VLC_ENOOBJ;
1791
1792     if( p_input )
1793     {
1794         vlc_value_t val;
1795
1796         var_Get( p_input, "state", &val );
1797         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )
1798         {
1799             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1800             vlc_object_release( p_input );
1801             return VLC_EGENERIC;
1802         }
1803         vlc_object_release( p_input );
1804     }
1805
1806     i_volume_step = config_GetInt( p_intf->p_vlc, "volume-step" );
1807     if ( i_nb_steps <= 0 || i_nb_steps > (AOUT_VOLUME_MAX/i_volume_step) )
1808     {
1809         i_nb_steps = 1;
1810     }
1811
1812     if ( !strcmp(psz_cmd, "volup") )
1813     {
1814         if ( aout_VolumeUp( p_this, i_nb_steps, &i_volume ) < 0 )
1815             i_error = VLC_EGENERIC;
1816     }
1817     else
1818     {
1819         if ( aout_VolumeDown( p_this, i_nb_steps, &i_volume ) < 0 )
1820             i_error = VLC_EGENERIC;
1821     }
1822     osd_Volume( p_this );
1823
1824     if ( !i_error ) msg_rc( STATUS_CHANGE "( audio volume: %d )", i_volume );
1825     return i_error;
1826 }
1827
1828 static int AudioConfig( vlc_object_t *p_this, char const *psz_cmd,
1829                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
1830 {
1831     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1832     input_thread_t *p_input = NULL;
1833     aout_instance_t * p_aout;
1834     const char * psz_variable;
1835     vlc_value_t val_name;
1836     int i_error;
1837
1838     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1839     if( !p_input )
1840         return VLC_ENOOBJ;
1841
1842     if( p_input )
1843     {
1844         vlc_value_t val;
1845
1846         var_Get( p_input, "state", &val );
1847         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )        {
1848             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1849             vlc_object_release( p_input );
1850             return VLC_EGENERIC;
1851         }
1852         vlc_object_release( p_input );
1853     }
1854
1855     p_aout = vlc_object_find( p_this, VLC_OBJECT_AOUT, FIND_ANYWHERE );
1856     if ( p_aout == NULL ) return VLC_ENOOBJ;
1857
1858     if ( !strcmp( psz_cmd, "adev" ) )
1859     {
1860         psz_variable = "audio-device";
1861     }
1862     else
1863     {
1864         psz_variable = "audio-channels";
1865     }
1866
1867     /* Get the descriptive name of the variable */
1868     var_Change( (vlc_object_t *)p_aout, psz_variable, VLC_VAR_GETTEXT,
1869                  &val_name, NULL );
1870     if( !val_name.psz_string ) val_name.psz_string = strdup(psz_variable);
1871
1872     if ( !*newval.psz_string )
1873     {
1874         /* Retrieve all registered ***. */
1875         vlc_value_t val, text;
1876         int i, i_value;
1877
1878         if ( var_Get( (vlc_object_t *)p_aout, psz_variable, &val ) < 0 )
1879         {
1880             vlc_object_release( (vlc_object_t *)p_aout );
1881             return VLC_EGENERIC;
1882         }
1883         i_value = val.i_int;
1884
1885         if ( var_Change( (vlc_object_t *)p_aout, psz_variable,
1886                          VLC_VAR_GETLIST, &val, &text ) < 0 )
1887         {
1888             vlc_object_release( (vlc_object_t *)p_aout );
1889             return VLC_EGENERIC;
1890         }
1891
1892         msg_rc( "+----[ %s ]", val_name.psz_string );
1893         for ( i = 0; i < val.p_list->i_count; i++ )
1894         {
1895             if ( i_value == val.p_list->p_values[i].i_int )
1896                 msg_rc( "| %i - %s *", val.p_list->p_values[i].i_int,
1897                         text.p_list->p_values[i].psz_string );
1898             else
1899                 msg_rc( "| %i - %s", val.p_list->p_values[i].i_int,
1900                         text.p_list->p_values[i].psz_string );
1901         }
1902         var_Change( (vlc_object_t *)p_aout, psz_variable, VLC_VAR_FREELIST,
1903                     &val, &text );
1904         msg_rc( "+----[ end of %s ]", val_name.psz_string );
1905
1906         if( val_name.psz_string ) free( val_name.psz_string );
1907         i_error = VLC_SUCCESS;
1908     }
1909     else
1910     {
1911         vlc_value_t val;
1912         val.i_int = atoi( newval.psz_string );
1913
1914         i_error = var_Set( (vlc_object_t *)p_aout, psz_variable, val );
1915     }
1916     vlc_object_release( (vlc_object_t *)p_aout );
1917
1918     return i_error;
1919 }
1920
1921 /* OSD menu commands */
1922 static int Menu( vlc_object_t *p_this, char const *psz_cmd,
1923     vlc_value_t oldval, vlc_value_t newval, void *p_data )
1924 {
1925     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1926     playlist_t    *p_playlist = NULL;
1927     vlc_value_t val;
1928     int i_error = VLC_EGENERIC;
1929
1930     if ( !*newval.psz_string )
1931     {
1932         msg_rc( _("Please provide one of the following parameters:") );
1933         msg_rc( "[on|off|up|down|left|right|select]" );
1934         return i_error;
1935     }
1936
1937     p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1938     if( !p_playlist )
1939         return VLC_ENOOBJ;
1940
1941     if( p_playlist->p_input )
1942     {
1943         var_Get( p_playlist->p_input, "state", &val );
1944         if( ( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) ) &&
1945             ( strcmp( newval.psz_string, "select" ) != 0 ) )
1946         {
1947             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1948             vlc_object_release( p_playlist );
1949             return VLC_EGENERIC;
1950         }
1951     }
1952     vlc_object_release( p_playlist );
1953
1954     val.psz_string = strdup( newval.psz_string );
1955     if( !strcmp( val.psz_string, "on" ) || !strcmp( val.psz_string, "show" ))
1956         osd_MenuShow( p_this );
1957     else if( !strcmp( val.psz_string, "off" ) || !strcmp( val.psz_string, "hide" ) )
1958         osd_MenuHide( p_this );
1959     else if( !strcmp( val.psz_string, "up" ) )
1960         osd_MenuUp( p_this );
1961     else if( !strcmp( val.psz_string, "down" ) )
1962         osd_MenuDown( p_this );
1963     else if( !strcmp( val.psz_string, "left" ) )
1964         osd_MenuPrev( p_this );
1965     else if( !strcmp( val.psz_string, "right" ) )
1966         osd_MenuNext( p_this );
1967     else if( !strcmp( val.psz_string, "select" ) )
1968         osd_MenuActivate( p_this );
1969     else
1970     {
1971         msg_rc( _("Please provide one of the following parameters:") );
1972         msg_rc( "[on|off|up|down|left|right|select]" );
1973         if( val.psz_string ) free( val.psz_string );
1974             return i_error;
1975     }
1976
1977     i_error = VLC_SUCCESS;
1978     if( val.psz_string ) free( val.psz_string );
1979     return i_error;
1980 }
1981
1982 #ifdef WIN32
1983 vlc_bool_t ReadWin32( intf_thread_t *p_intf, char *p_buffer, int *pi_size )
1984 {
1985     INPUT_RECORD input_record;
1986     DWORD i_dw;
1987
1988     /* On Win32, select() only works on socket descriptors */
1989     while( WaitForSingleObject( p_intf->p_sys->hConsoleIn,
1990                                 INTF_IDLE_SLEEP/1000 ) == WAIT_OBJECT_0 )
1991     {
1992         while( !p_intf->b_die && *pi_size < MAX_LINE_LENGTH &&
1993                ReadConsoleInput( p_intf->p_sys->hConsoleIn, &input_record,
1994                                  1, &i_dw ) )
1995         {
1996             if( input_record.EventType != KEY_EVENT ||
1997                 !input_record.Event.KeyEvent.bKeyDown ||
1998                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT ||
1999                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL||
2000                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_MENU ||
2001                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_CAPITAL )
2002             {
2003                 /* nothing interesting */
2004                 continue;
2005             }
2006
2007             p_buffer[ *pi_size ] = input_record.Event.KeyEvent.uChar.AsciiChar;
2008
2009             /* Echo out the command */
2010             putc( p_buffer[ *pi_size ], stdout );
2011
2012             /* Handle special keys */
2013             if( p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
2014             {
2015                 putc( '\n', stdout );
2016                 break;
2017             }
2018             switch( p_buffer[ *pi_size ] )
2019             {
2020             case '\b':
2021                 if( *pi_size )
2022                 {
2023                     *pi_size -= 2;
2024                     putc( ' ', stdout );
2025                     putc( '\b', stdout );
2026                 }
2027                 break;
2028             case '\r':
2029                 (*pi_size) --;
2030                 break;
2031             }
2032
2033             (*pi_size)++;
2034         }
2035
2036         if( *pi_size == MAX_LINE_LENGTH ||
2037             p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
2038         {
2039             p_buffer[ *pi_size ] = 0;
2040             return VLC_TRUE;
2041         }
2042     }
2043
2044     return VLC_FALSE;
2045 }
2046 #endif
2047
2048 vlc_bool_t ReadCommand( intf_thread_t *p_intf, char *p_buffer, int *pi_size )
2049 {
2050     int i_read = 0;
2051
2052 #ifdef WIN32
2053     if( p_intf->p_sys->i_socket == -1 && !p_intf->p_sys->b_quiet )
2054         return ReadWin32( p_intf, p_buffer, pi_size );
2055     else if( p_intf->p_sys->i_socket == -1 )
2056     {
2057         msleep( INTF_IDLE_SLEEP );
2058         return VLC_FALSE;
2059     }
2060 #endif
2061
2062     while( !p_intf->b_die && *pi_size < MAX_LINE_LENGTH &&
2063            (i_read = net_ReadNonBlock( p_intf, p_intf->p_sys->i_socket == -1 ?
2064                        0 /*STDIN_FILENO*/ : p_intf->p_sys->i_socket, NULL,
2065                   (uint8_t *)p_buffer + *pi_size, 1, INTF_IDLE_SLEEP ) ) > 0 )
2066     {
2067         if( p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
2068             break;
2069
2070         (*pi_size)++;
2071     }
2072
2073     /* Connection closed */
2074     if( i_read == -1 )
2075     {
2076         p_intf->p_sys->i_socket = -1;
2077         p_buffer[ *pi_size ] = 0;
2078         return VLC_TRUE;
2079     }
2080
2081     if( *pi_size == MAX_LINE_LENGTH ||
2082         p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
2083     {
2084         p_buffer[ *pi_size ] = 0;
2085         return VLC_TRUE;
2086     }
2087
2088     return VLC_FALSE;
2089 }
2090
2091 /*****************************************************************************
2092  * parse_MRL: build a playlist item from a full mrl
2093  *****************************************************************************
2094  * MRL format: "simplified-mrl [:option-name[=option-value]]"
2095  * We don't check for '"' or '\'', we just assume that a ':' that follows a
2096  * space is a new option. Should be good enough for our purpose.
2097  *****************************************************************************/
2098 static playlist_item_t *parse_MRL( intf_thread_t *p_intf, char *psz_mrl )
2099 {
2100 #define SKIPSPACE( p ) { while( *p && ( *p == ' ' || *p == '\t' ) ) p++; }
2101 #define SKIPTRAILINGSPACE( p, d ) \
2102     { char *e=d; while( e > p && (*(e-1)==' ' || *(e-1)=='\t') ){e--;*e=0;} }
2103
2104     playlist_item_t *p_item = NULL;
2105     char *psz_item = NULL, *psz_item_mrl = NULL, *psz_orig;
2106     char **ppsz_options = NULL;
2107     int i, i_options = 0;
2108
2109     if( !psz_mrl ) return 0;
2110
2111     psz_mrl = psz_orig = strdup( psz_mrl );
2112     while( *psz_mrl )
2113     {
2114         SKIPSPACE( psz_mrl );
2115         psz_item = psz_mrl;
2116
2117         for( ; *psz_mrl; psz_mrl++ )
2118         {
2119             if( (*psz_mrl == ' ' || *psz_mrl == '\t') && psz_mrl[1] == ':' )
2120             {
2121                 /* We have a complete item */
2122                 break;
2123             }
2124             if( (*psz_mrl == ' ' || *psz_mrl == '\t') &&
2125                 (psz_mrl[1] == '"' || psz_mrl[1] == '\'') && psz_mrl[2] == ':')
2126             {
2127                 /* We have a complete item */
2128                 break;
2129             }
2130         }
2131
2132         if( *psz_mrl ) { *psz_mrl = 0; psz_mrl++; }
2133         SKIPTRAILINGSPACE( psz_item, psz_item + strlen( psz_item ) );
2134
2135         /* Remove '"' and '\'' if necessary */
2136         if( *psz_item == '"' && psz_item[strlen(psz_item)-1] == '"' )
2137         { psz_item++; psz_item[strlen(psz_item)-1] = 0; }
2138         if( *psz_item == '\'' && psz_item[strlen(psz_item)-1] == '\'' )
2139         { psz_item++; psz_item[strlen(psz_item)-1] = 0; }
2140
2141         if( !psz_item_mrl ) psz_item_mrl = psz_item;
2142         else if( *psz_item )
2143         {
2144             i_options++;
2145             ppsz_options = realloc( ppsz_options, i_options * sizeof(char *) );
2146             ppsz_options[i_options - 1] = &psz_item[1];
2147         }
2148
2149         if( *psz_mrl ) SKIPSPACE( psz_mrl );
2150     }
2151
2152     /* Now create a playlist item */
2153     if( psz_item_mrl )
2154     {
2155         p_item = playlist_ItemNew( p_intf, psz_item_mrl, psz_item_mrl );
2156         for( i = 0; i < i_options; i++ )
2157         {
2158             playlist_ItemAddOption( p_item, ppsz_options[i] );
2159         }
2160     }
2161
2162     if( i_options ) free( ppsz_options );
2163     free( psz_orig );
2164
2165     return p_item;
2166 }
2167
2168 /*****************************************************************************
2169  * checkUpdates : check for updates
2170  ****************************************************************************/
2171 static void checkUpdates( intf_thread_t *p_intf, char *psz_arg )
2172 {
2173     update_iterator_t *p_uit;
2174     update_t *p_u = update_New( p_intf );
2175     if( p_u == NULL ) return;
2176     p_uit = update_iterator_New( p_u );
2177     if( p_uit )
2178     {
2179         int s = 0, t = 0;
2180
2181         if( strstr( psz_arg, "newer" ) )
2182             s |= UPDATE_RELEASE_STATUS_NEWER;
2183         if( strstr( psz_arg, "equal" ) )
2184             s |= UPDATE_RELEASE_STATUS_EQUAL;
2185         if( strstr( psz_arg, "older" ) )
2186             s |= UPDATE_RELEASE_STATUS_OLDER;
2187         if( s ) p_uit->i_rs = s;
2188         else p_uit->i_rs = UPDATE_RELEASE_STATUS_NEWER;
2189
2190         if( strstr( psz_arg, "undef" ) )
2191             t |= UPDATE_FILE_TYPE_UNDEF;
2192         if( strstr( psz_arg, "info" ) )
2193             t |= UPDATE_FILE_TYPE_INFO;
2194         if( strstr( psz_arg, "source" ) )
2195             t |= UPDATE_FILE_TYPE_SOURCE;
2196         if( strstr( psz_arg, "binary" ) )
2197             t |= UPDATE_FILE_TYPE_BINARY;
2198         if( strstr( psz_arg, "plugin" ) )
2199             t |= UPDATE_FILE_TYPE_PLUGIN;
2200         if( t ) p_uit->i_t = t;
2201
2202         update_Check( p_u, VLC_FALSE );
2203         update_iterator_Action( p_uit, UPDATE_MIRROR );
2204         msg_rc( "\nUsing mirror: %s (%s) [%s]",
2205                 p_uit->mirror.psz_name,
2206                 p_uit->mirror.psz_location,
2207                 p_uit->mirror.psz_type );
2208         while( (s = update_iterator_Action( p_uit, UPDATE_FILE )) != UPDATE_FAIL )
2209         {
2210             char *psz_tmp;
2211             if( s & UPDATE_RELEASE )
2212             {
2213                 switch( p_uit->release.i_status )
2214                 {
2215                     case UPDATE_RELEASE_STATUS_OLDER:
2216                         psz_tmp = strdup( "older" );
2217                         break;
2218                     case UPDATE_RELEASE_STATUS_EQUAL:
2219                         psz_tmp = strdup( "equal" );
2220                         break;
2221                     case UPDATE_RELEASE_STATUS_NEWER:
2222                         psz_tmp = strdup( "newer" );
2223                         break;
2224                     default:
2225                         psz_tmp = strdup( "?!?" );
2226                         break;
2227                 }
2228                 msg_rc( "\n+----[ VLC %s %s (%s) ] ",
2229                         p_uit->release.psz_version,
2230                         p_uit->release.psz_svn_revision,
2231                         psz_tmp );
2232                 free( psz_tmp );
2233             }
2234             switch( p_uit->file.i_type )
2235             {
2236                 case UPDATE_FILE_TYPE_UNDEF:
2237                     psz_tmp = strdup( "undef" );
2238                     break;
2239                 case UPDATE_FILE_TYPE_INFO:
2240                     psz_tmp = strdup( "info" );
2241                     break;
2242                 case UPDATE_FILE_TYPE_SOURCE:
2243                     psz_tmp = strdup( "source" );
2244                     break;
2245                 case UPDATE_FILE_TYPE_BINARY:
2246                     psz_tmp = strdup( "binary" );
2247                     break;
2248                 case UPDATE_FILE_TYPE_PLUGIN:
2249                     psz_tmp = strdup( "plugin" );
2250                     break;
2251                 default:
2252                     psz_tmp = strdup( "?!?" );
2253                     break;
2254             }
2255             msg_rc( "| %s (%s)", p_uit->file.psz_description, psz_tmp );
2256             free( psz_tmp );
2257             if( p_uit->file.l_size )
2258             {
2259                 if( p_uit->file.l_size > 1024 * 1024 * 1024 )
2260                     asprintf( &psz_tmp, "(%ld GB)",
2261                               p_uit->file.l_size / (1024*1024*1024) );
2262                 if( p_uit->file.l_size > 1024 * 1024 )
2263                     asprintf( &psz_tmp, "(%ld MB)",
2264                               p_uit->file.l_size / (1024*1024) );
2265                 else if( p_uit->file.l_size > 1024 )
2266                     asprintf( &psz_tmp, "(%ld kB)",
2267                               p_uit->file.l_size / 1024 );
2268                 else
2269                     asprintf( &psz_tmp, "(%ld B)", p_uit->file.l_size );
2270             }
2271             else
2272             {
2273                 psz_tmp = strdup( "" );
2274             }
2275             msg_rc( "| %s %s", p_uit->file.psz_url, psz_tmp );
2276             msg_rc( "+----" );
2277             free( psz_tmp );
2278         }
2279         msg_rc( "" );
2280         update_iterator_Delete( p_uit );
2281     }
2282     update_Delete( p_u );
2283 }