git.sesse.net Git - vlc/blob - src/modules/configuration.c

   1 /*****************************************************************************
   2  * configuration.c management of the modules configuration
   3  *****************************************************************************
   4  * Copyright (C) 2001-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #include <vlc/vlc.h>
  25 #include "vlc_keys.h"
  26 #include "vlc_charset.h"
  27
  28 #include <stdio.h>                                              /* sprintf() */
  29 #include <stdlib.h>                                      /* free(), strtol() */
  30 #include <string.h>                                              /* strdup() */
  31 #include <errno.h>                                                  /* errno */
  32
  33 #ifdef HAVE_LIMITS_H
  34 #   include <limits.h>
  35 #endif
  36
  37 #ifdef HAVE_UNISTD_H
  38 #    include <unistd.h>                                          /* getuid() */
  39 #endif
  40
  41 #ifdef HAVE_GETOPT_LONG
  42 #   ifdef HAVE_GETOPT_H
  43 #       include <getopt.h>                                       /* getopt() */
  44 #   endif
  45 #else
  46 #   include "../extras/getopt.h"
  47 #endif
  48
  49 #if defined(HAVE_GETPWUID)
  50 #   include <pwd.h>                                            /* getpwuid() */
  51 #endif
  52
  53 #if defined( HAVE_SYS_STAT_H )
  54 #   include <sys/stat.h>
  55 #endif
  56 #if defined( HAVE_SYS_TYPES_H )
  57 #   include <sys/types.h>
  58 #endif
  59 #if defined( WIN32 )
  60 #   if !defined( UNDER_CE )
  61 #       include <direct.h>
  62 #   endif
  63 #include <tchar.h>
  64 #endif
  65
  66 #include "configuration.h"
  67 #include "modules/modules.h"
  68
  69 static int ConfigStringToKey( const char * );
  70 static char *ConfigKeyToString( int );
  71
  72 static inline void freenull (const void *p)
  73 {
  74     if (p != NULL)
  75         free ((void *)p);
  76 }
  77
  78 static inline char *strdupnull (const char *src)
  79 {
  80     if (src == NULL)
  81         return NULL;
  82     return strdup (src);
  83 }
  84
  85 static inline char *_strdupnull (const char *src)
  86 {
  87     if (src == NULL)
  88         return NULL;
  89     return strdup (_(src));
  90 }
  91
  92
  93 /*****************************************************************************
  94  * config_GetType: get the type of a variable (bool, int, float, string)
  95  *****************************************************************************
  96  * This function is used to get the type of a variable from its name.
  97  * Beware, this is quite slow.
  98  *****************************************************************************/
  99 int __config_GetType( vlc_object_t *p_this, const char *psz_name )
 100 {
 101     module_config_t *p_config;
 102     int i_type;
 103
 104     p_config = config_FindConfig( p_this, psz_name );
 105
 106     /* sanity checks */
 107     if( !p_config )
 108     {
 109         return 0;
 110     }
 111
 112     switch( p_config->i_type )
 113     {
 114     case CONFIG_ITEM_BOOL:
 115         i_type = VLC_VAR_BOOL;
 116         break;
 117
 118     case CONFIG_ITEM_INTEGER:
 119         i_type = VLC_VAR_INTEGER;
 120         break;
 121
 122     case CONFIG_ITEM_FLOAT:
 123         i_type = VLC_VAR_FLOAT;
 124         break;
 125
 126     case CONFIG_ITEM_MODULE:
 127     case CONFIG_ITEM_MODULE_CAT:
 128     case CONFIG_ITEM_MODULE_LIST:
 129     case CONFIG_ITEM_MODULE_LIST_CAT:
 130         i_type = VLC_VAR_MODULE;
 131         break;
 132
 133     case CONFIG_ITEM_STRING:
 134         i_type = VLC_VAR_STRING;
 135         break;
 136
 137     case CONFIG_ITEM_FILE:
 138         i_type = VLC_VAR_FILE;
 139         break;
 140
 141     case CONFIG_ITEM_DIRECTORY:
 142         i_type = VLC_VAR_DIRECTORY;
 143         break;
 144
 145     default:
 146         i_type = 0;
 147         break;
 148     }
 149
 150     return i_type;
 151 }
 152
 153 /*****************************************************************************
 154  * config_GetInt: get the value of an int variable
 155  *****************************************************************************
 156  * This function is used to get the value of variables which are internally
 157  * represented by an integer (CONFIG_ITEM_INTEGER and
 158  * CONFIG_ITEM_BOOL).
 159  *****************************************************************************/
 160 int __config_GetInt( vlc_object_t *p_this, const char *psz_name )
 161 {
 162     module_config_t *p_config;
 163
 164     p_config = config_FindConfig( p_this, psz_name );
 165
 166     /* sanity checks */
 167     if( !p_config )
 168     {
 169         msg_Err( p_this, "option %s does not exist", psz_name );
 170         return -1;
 171     }
 172
 173     if (!IsConfigIntegerType (p_config->i_type))
 174     {
 175         msg_Err( p_this, "option %s does not refer to an int", psz_name );
 176         return -1;
 177     }
 178
 179     return p_config->value.i;
 180 }
 181
 182 /*****************************************************************************
 183  * config_GetFloat: get the value of a float variable
 184  *****************************************************************************
 185  * This function is used to get the value of variables which are internally
 186  * represented by a float (CONFIG_ITEM_FLOAT).
 187  *****************************************************************************/
 188 float __config_GetFloat( vlc_object_t *p_this, const char *psz_name )
 189 {
 190     module_config_t *p_config;
 191
 192     p_config = config_FindConfig( p_this, psz_name );
 193
 194     /* sanity checks */
 195     if( !p_config )
 196     {
 197         msg_Err( p_this, "option %s does not exist", psz_name );
 198         return -1;
 199     }
 200
 201     if (!IsConfigFloatType (p_config->i_type))
 202     {
 203         msg_Err( p_this, "option %s does not refer to a float", psz_name );
 204         return -1;
 205     }
 206
 207     return p_config->value.f;
 208 }
 209
 210 /*****************************************************************************
 211  * config_GetPsz: get the string value of a string variable
 212  *****************************************************************************
 213  * This function is used to get the value of variables which are internally
 214  * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE,
 215  * CONFIG_ITEM_DIRECTORY, and CONFIG_ITEM_MODULE).
 216  *
 217  * Important note: remember to free() the returned char* because it's a
 218  *   duplicate of the actual value. It isn't safe to return a pointer to the
 219  *   actual value as it can be modified at any time.
 220  *****************************************************************************/
 221 char * __config_GetPsz( vlc_object_t *p_this, const char *psz_name )
 222 {
 223     module_config_t *p_config;
 224
 225     p_config = config_FindConfig( p_this, psz_name );
 226
 227     /* sanity checks */
 228     if( !p_config )
 229     {
 230         msg_Err( p_this, "option %s does not exist", psz_name );
 231         return NULL;
 232     }
 233
 234     if (!IsConfigStringType (p_config->i_type))
 235     {
 236         msg_Err( p_this, "option %s does not refer to a string", psz_name );
 237         return NULL;
 238     }
 239
 240     /* return a copy of the string */
 241     vlc_mutex_lock( p_config->p_lock );
 242     char *psz_value = strdupnull (p_config->value.psz);
 243     vlc_mutex_unlock( p_config->p_lock );
 244
 245     return psz_value;
 246 }
 247
 248 /*****************************************************************************
 249  * config_PutPsz: set the string value of a string variable
 250  *****************************************************************************
 251  * This function is used to set the value of variables which are internally
 252  * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE,
 253  * CONFIG_ITEM_DIRECTORY, and CONFIG_ITEM_MODULE).
 254  *****************************************************************************/
 255 void __config_PutPsz( vlc_object_t *p_this,
 256                       const char *psz_name, const char *psz_value )
 257 {
 258     module_config_t *p_config;
 259     vlc_value_t oldval, val;
 260
 261     p_config = config_FindConfig( p_this, psz_name );
 262
 263
 264     /* sanity checks */
 265     if( !p_config )
 266     {
 267         msg_Warn( p_this, "option %s does not exist", psz_name );
 268         return;
 269     }
 270
 271     if (!IsConfigStringType (p_config->i_type))
 272     {
 273         msg_Err( p_this, "option %s does not refer to a string", psz_name );
 274         return;
 275     }
 276
 277     vlc_mutex_lock( p_config->p_lock );
 278
 279     /* backup old value */
 280     oldval.psz_string = (char *)p_config->value.psz;
 281
 282     if ((psz_value != NULL) && *psz_value)
 283         p_config->value.psz = strdup (psz_value);
 284     else
 285         p_config->value.psz = NULL;
 286
 287     p_config->b_dirty = VLC_TRUE;
 288
 289     val.psz_string = (char *)p_config->value.psz;
 290
 291     vlc_mutex_unlock( p_config->p_lock );
 292
 293     if( p_config->pf_callback )
 294     {
 295         p_config->pf_callback( p_this, psz_name, oldval, val,
 296                                p_config->p_callback_data );
 297     }
 298
 299     /* free old string */
 300     if( oldval.psz_string ) free( oldval.psz_string );
 301 }
 302
 303 /*****************************************************************************
 304  * config_PutInt: set the integer value of an int variable
 305  *****************************************************************************
 306  * This function is used to set the value of variables which are internally
 307  * represented by an integer (CONFIG_ITEM_INTEGER and
 308  * CONFIG_ITEM_BOOL).
 309  *****************************************************************************/
 310 void __config_PutInt( vlc_object_t *p_this, const char *psz_name, int i_value )
 311 {
 312     module_config_t *p_config;
 313     vlc_value_t oldval, val;
 314
 315     p_config = config_FindConfig( p_this, psz_name );
 316
 317     /* sanity checks */
 318     if( !p_config )
 319     {
 320         msg_Warn( p_this, "option %s does not exist", psz_name );
 321         return;
 322     }
 323
 324     if (!IsConfigIntegerType (p_config->i_type))
 325     {
 326         msg_Err( p_this, "option %s does not refer to an int", psz_name );
 327         return;
 328     }
 329
 330     /* backup old value */
 331     oldval.i_int = p_config->value.i;
 332
 333     /* if i_min == i_max == 0, then do not use them */
 334     if ((p_config->min.i == 0) && (p_config->max.i == 0))
 335     {
 336         p_config->value.i = i_value;
 337     }
 338     else if (i_value < p_config->min.i)
 339     {
 340         p_config->value.i = p_config->min.i;
 341     }
 342     else if (i_value > p_config->max.i)
 343     {
 344         p_config->value.i = p_config->max.i;
 345     }
 346     else
 347     {
 348         p_config->value.i = i_value;
 349     }
 350
 351     p_config->b_dirty = VLC_TRUE;
 352
 353     val.i_int = p_config->value.i;
 354
 355     if( p_config->pf_callback )
 356     {
 357         p_config->pf_callback( p_this, psz_name, oldval, val,
 358                                p_config->p_callback_data );
 359     }
 360 }
 361
 362 /*****************************************************************************
 363  * config_PutFloat: set the value of a float variable
 364  *****************************************************************************
 365  * This function is used to set the value of variables which are internally
 366  * represented by a float (CONFIG_ITEM_FLOAT).
 367  *****************************************************************************/
 368 void __config_PutFloat( vlc_object_t *p_this,
 369                         const char *psz_name, float f_value )
 370 {
 371     module_config_t *p_config;
 372     vlc_value_t oldval, val;
 373
 374     p_config = config_FindConfig( p_this, psz_name );
 375
 376     /* sanity checks */
 377     if( !p_config )
 378     {
 379         msg_Warn( p_this, "option %s does not exist", psz_name );
 380         return;
 381     }
 382
 383     if (!IsConfigFloatType (p_config->i_type))
 384     {
 385         msg_Err( p_this, "option %s does not refer to a float", psz_name );
 386         return;
 387     }
 388
 389     /* backup old value */
 390     oldval.f_float = p_config->value.f;
 391
 392     /* if f_min == f_max == 0, then do not use them */
 393     if ((p_config->min.f == 0) && (p_config->max.f == 0))
 394     {
 395         p_config->value.f = f_value;
 396     }
 397     else if (f_value < p_config->min.f)
 398     {
 399         p_config->value.f = p_config->min.f;
 400     }
 401     else if (f_value > p_config->max.f)
 402     {
 403         p_config->value.f = p_config->max.f;
 404     }
 405     else
 406     {
 407         p_config->value.f = f_value;
 408     }
 409
 410     p_config->b_dirty = VLC_TRUE;
 411
 412     val.f_float = p_config->value.f;
 413
 414     if( p_config->pf_callback )
 415     {
 416         p_config->pf_callback( p_this, psz_name, oldval, val,
 417                                p_config->p_callback_data );
 418     }
 419 }
 420
 421 /*****************************************************************************
 422  * config_FindConfig: find the config structure associated with an option.
 423  *****************************************************************************
 424  * FIXME: This function really needs to be optimized.
 425  * FIXME: And now even more.
 426  *****************************************************************************/
 427 module_config_t *config_FindConfig( vlc_object_t *p_this, const char *psz_name )
 428 {
 429     vlc_list_t *p_list;
 430     int i_index;
 431
 432     if( !psz_name ) return NULL;
 433
 434     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
 435
 436     for( i_index = 0; i_index < p_list->i_count; i_index++ )
 437     {
 438         module_config_t *p_item, *p_end;
 439         module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object;
 440
 441         if( !p_parser->i_config_items )
 442             continue;
 443
 444         for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
 445              p_item < p_end;
 446              p_item++ )
 447         {
 448             if( p_item->i_type & CONFIG_HINT )
 449                 /* ignore hints */
 450                 continue;
 451             if( !strcmp( psz_name, p_item->psz_name ) )
 452             {
 453                 vlc_list_release( p_list );
 454                 return p_item;
 455             }
 456         }
 457     }
 458
 459     vlc_list_release( p_list );
 460
 461     return NULL;
 462 }
 463
 464 /*****************************************************************************
 465  * config_FindModule: find a specific module structure.
 466  *****************************************************************************/
 467 module_t *config_FindModule( vlc_object_t *p_this, const char *psz_name )
 468 {
 469     vlc_list_t *p_list;
 470     module_t *p_module, *p_result = NULL;
 471     int i_index;
 472
 473     if( !psz_name ) return NULL;
 474
 475     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
 476
 477     for( i_index = 0; i_index < p_list->i_count; i_index++ )
 478     {
 479         p_module = (module_t *)p_list->p_values[i_index].p_object;
 480         if( !strcmp( p_module->psz_object_name, psz_name ) )
 481         {
 482              p_result = p_module;
 483              break;
 484         }
 485     }
 486
 487     vlc_list_release( p_list );
 488
 489     return p_result;
 490 }
 491
 492 /*****************************************************************************
 493  * config_Duplicate: creates a duplicate of a module's configuration data.
 494  *****************************************************************************
 495  * Unfortunatly we cannot work directly with the module's config data as
 496  * this module might be unloaded from memory at any time (remember HideModule).
 497  * This is why we need to create an exact copy of the config data.
 498  *****************************************************************************/
 499 int config_Duplicate( module_t *p_module, const module_config_t *p_orig,
 500                       size_t n )
 501 {
 502     int j;
 503     const module_config_t *p_item, *p_end = p_orig + n;
 504
 505     /* Calculate the structure length */
 506     p_module->i_config_items = 0;
 507     p_module->i_bool_items = 0;
 508
 509     for( p_item = p_orig; p_item < p_end; p_item++ )
 510     {
 511         if( p_item->i_type & CONFIG_ITEM )
 512         {
 513             p_module->i_config_items++;
 514         }
 515
 516         if( p_item->i_type == CONFIG_ITEM_BOOL )
 517         {
 518             p_module->i_bool_items++;
 519         }
 520     }
 521
 522     /* Allocate memory */
 523     p_module->p_config = (module_config_t *)calloc( n, sizeof(*p_orig) );
 524     if( p_module->p_config == NULL )
 525     {
 526         msg_Err( p_module, "config error: can't duplicate p_config" );
 527         return VLC_ENOMEM;
 528     }
 529     p_module->confsize = n;
 530
 531     /* Do the duplication job */
 532     for( size_t i = 0; i < n ; i++ )
 533     {
 534         p_module->p_config[i] = p_orig[i];
 535
 536         if (IsConfigIntegerType (p_module->p_config[i].i_type))
 537         {
 538             p_module->p_config[i].orig.i = p_orig[i].value.i;
 539             p_module->p_config[i].saved.i = p_orig[i].value.i;
 540         }
 541         else
 542         if (IsConfigFloatType (p_module->p_config[i].i_type))
 543         {
 544             p_module->p_config[i].orig.f = p_orig[i].value.f;
 545             p_module->p_config[i].saved.f = p_orig[i].value.f;
 546         }
 547         else
 548         if (IsConfigStringType (p_module->p_config[i].i_type))
 549         {
 550             p_module->p_config[i].value.psz = strdupnull (p_orig[i].value.psz);
 551             p_module->p_config[i].orig.psz = strdupnull (p_orig[i].value.psz);
 552             p_module->p_config[i].saved.psz = NULL;
 553         }
 554
 555         p_module->p_config[i].psz_type = strdupnull (p_orig[i].psz_type);
 556         p_module->p_config[i].psz_name = strdupnull (p_orig[i].psz_name);
 557         p_module->p_config[i].psz_current = strdupnull (p_orig[i].psz_current);
 558         p_module->p_config[i].psz_text = _strdupnull (p_orig[i].psz_text);
 559         p_module->p_config[i].psz_longtext = _strdupnull (p_orig[i].psz_longtext);
 560
 561         p_module->p_config[i].p_lock = &p_module->object_lock;
 562
 563         /* duplicate the string list */
 564         if( p_orig[i].i_list )
 565         {
 566             if( p_orig[i].ppsz_list )
 567             {
 568                 p_module->p_config[i].ppsz_list =
 569                     malloc( (p_orig[i].i_list + 1) * sizeof(char *) );
 570                 if( p_module->p_config[i].ppsz_list )
 571                 {
 572                     for( j = 0; j < p_orig[i].i_list; j++ )
 573                         p_module->p_config[i].ppsz_list[j] =
 574                                 strdupnull (p_orig[i].ppsz_list[j]);
 575                     p_module->p_config[i].ppsz_list[j] = NULL;
 576                 }
 577             }
 578             if( p_orig[i].ppsz_list_text )
 579             {
 580                 p_module->p_config[i].ppsz_list_text =
 581                     calloc( (p_orig[i].i_list + 1), sizeof(char *) );
 582                 if( p_module->p_config[i].ppsz_list_text )
 583                 {
 584                     for( j = 0; j < p_orig[i].i_list; j++ )
 585                         p_module->p_config[i].ppsz_list_text[j] =
 586                                 strdupnull (_(p_orig[i].ppsz_list_text[j]));
 587                     p_module->p_config[i].ppsz_list_text[j] = NULL;
 588                 }
 589             }
 590             if( p_orig[i].pi_list )
 591             {
 592                 p_module->p_config[i].pi_list =
 593                     malloc( (p_orig[i].i_list + 1) * sizeof(int) );
 594                 if( p_module->p_config[i].pi_list )
 595                 {
 596                     for( j = 0; j < p_orig[i].i_list; j++ )
 597                         p_module->p_config[i].pi_list[j] =
 598                             p_orig[i].pi_list[j];
 599                 }
 600             }
 601         }
 602
 603         /* duplicate the actions list */
 604         if( p_orig[i].i_action )
 605         {
 606             int j;
 607
 608             p_module->p_config[i].ppf_action =
 609                 malloc( p_orig[i].i_action * sizeof(void *) );
 610             p_module->p_config[i].ppsz_action_text =
 611                 malloc( p_orig[i].i_action * sizeof(char *) );
 612
 613             for( j = 0; j < p_orig[i].i_action; j++ )
 614             {
 615                 p_module->p_config[i].ppf_action[j] =
 616                     p_orig[i].ppf_action[j];
 617                 p_module->p_config[i].ppsz_action_text[j] =
 618                     strdupnull (p_orig[i].ppsz_action_text[j]);
 619             }
 620         }
 621
 622         p_module->p_config[i].pf_callback = p_orig[i].pf_callback;
 623     }
 624     return VLC_SUCCESS;
 625 }
 626
 627
 628 /*****************************************************************************
 629  * config_Free: frees a duplicated module's configuration data.
 630  *****************************************************************************
 631  * This function frees all the data duplicated by config_Duplicate.
 632  *****************************************************************************/
 633 void config_Free( module_t *p_module )
 634 {
 635     int i;
 636
 637     for (size_t j = 0; j < p_module->confsize; j++)
 638     {
 639         module_config_t *p_item = p_module->p_config + j;
 640
 641         free( (char*) p_item->psz_type );
 642         free( (char*) p_item->psz_name );
 643         free( (char*) p_item->psz_current );
 644         free( (char*) p_item->psz_text );
 645         free( (char*) p_item->psz_longtext );
 646
 647         if (IsConfigStringType (p_item->i_type))
 648         {
 649             freenull (p_item->value.psz);
 650             freenull (p_item->orig.psz);
 651             freenull (p_item->saved.psz);
 652         }
 653
 654         if( p_item->i_list )
 655         {
 656             for( i = 0; i < p_item->i_list; i++ )
 657             {
 658                 if( p_item->ppsz_list && p_item->ppsz_list[i] )
 659                     free( (char*) p_item->ppsz_list[i] );
 660                 if( p_item->ppsz_list_text && p_item->ppsz_list_text[i] )
 661                     free( (char*) p_item->ppsz_list_text[i] );
 662             }
 663             if( p_item->ppsz_list ) free( p_item->ppsz_list );
 664             if( p_item->ppsz_list_text ) free( p_item->ppsz_list_text );
 665             if( p_item->pi_list ) free( p_item->pi_list );
 666         }
 667
 668         if( p_item->i_action )
 669         {
 670             for( i = 0; i < p_item->i_action; i++ )
 671             {
 672                 free( (char*) p_item->ppsz_action_text[i] );
 673             }
 674             if( p_item->ppf_action ) free( p_item->ppf_action );
 675             if( p_item->ppsz_action_text ) free( p_item->ppsz_action_text );
 676         }
 677     }
 678
 679     if (p_module->p_config != NULL)
 680     {
 681         free (p_module->p_config);
 682         p_module->p_config = NULL;
 683     }
 684 }
 685
 686 /*****************************************************************************
 687  * config_SetCallbacks: sets callback functions in the duplicate p_config.
 688  *****************************************************************************
 689  * Unfortunatly we cannot work directly with the module's config data as
 690  * this module might be unloaded from memory at any time (remember HideModule).
 691  * This is why we need to duplicate callbacks each time we reload the module.
 692  *****************************************************************************/
 693 void config_SetCallbacks( module_config_t *p_new, module_config_t *p_orig,
 694                           size_t n )
 695 {
 696     for (size_t i = 0; i < n; i++)
 697     {
 698         p_new->pf_callback = p_orig->pf_callback;
 699         p_new++;
 700         p_orig++;
 701     }
 702 }
 703
 704 /*****************************************************************************
 705  * config_UnsetCallbacks: unsets callback functions in the duplicate p_config.
 706  *****************************************************************************
 707  * We simply undo what we did in config_SetCallbacks.
 708  *****************************************************************************/
 709 void config_UnsetCallbacks( module_config_t *p_new, size_t n )
 710 {
 711     for (size_t i = 0; i < n; i++)
 712     {
 713         p_new->pf_callback = NULL;
 714         p_new++;
 715     }
 716 }
 717
 718 /*****************************************************************************
 719  * config_ResetAll: reset the configuration data for all the modules.
 720  *****************************************************************************/
 721 void __config_ResetAll( vlc_object_t *p_this )
 722 {
 723     int i_index;
 724     vlc_list_t *p_list;
 725     module_t *p_module;
 726
 727     /* Acquire config file lock */
 728     vlc_mutex_lock( &p_this->p_libvlc->config_lock );
 729
 730     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
 731
 732     for( i_index = 0; i_index < p_list->i_count; i_index++ )
 733     {
 734         p_module = (module_t *)p_list->p_values[i_index].p_object ;
 735         if( p_module->b_submodule ) continue;
 736
 737         for (size_t i = 0; i < p_module->confsize; i++ )
 738         {
 739             if (IsConfigIntegerType (p_module->p_config[i].i_type))
 740                 p_module->p_config[i].value.i = p_module->p_config[i].orig.i;
 741             else
 742             if (IsConfigFloatType (p_module->p_config[i].i_type))
 743                 p_module->p_config[i].value.f = p_module->p_config[i].orig.f;
 744             else
 745             if (IsConfigStringType (p_module->p_config[i].i_type))
 746             {
 747                 freenull (p_module->p_config[i].value.psz);
 748                 p_module->p_config[i].value.psz =
 749                         strdupnull (p_module->p_config[i].orig.psz);
 750             }
 751         }
 752     }
 753
 754     vlc_list_release( p_list );
 755     vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
 756 }
 757
 758
 759 static FILE *config_OpenConfigFile( vlc_object_t *p_obj, const char *mode )
 760 {
 761     static const char psz_subpath[] = DIR_SEP CONFIG_DIR DIR_SEP CONFIG_FILE;
 762     const char *psz_filename = p_obj->p_libvlc->psz_configfile;
 763     const char *psz_homedir;
 764     size_t i_buflen = 0;
 765     FILE *p_stream;
 766
 767     if( psz_filename == NULL )
 768     {
 769         psz_homedir = p_obj->p_libvlc->psz_homedir;
 770         if( psz_homedir == NULL )
 771         {
 772             msg_Err( p_obj, "no home directory defined" );
 773             return NULL;
 774         }
 775
 776         i_buflen = strlen(psz_homedir) + sizeof(psz_subpath) + 1;
 777     }
 778
 779     char buf[i_buflen];
 780     if( psz_filename == NULL )
 781     {
 782         sprintf( buf, "%s%s", psz_homedir, psz_subpath );
 783         psz_filename = buf;
 784     }
 785
 786     msg_Dbg( p_obj, "opening config file (%s)", psz_filename );
 787     p_stream = utf8_fopen( psz_filename, mode );
 788     if( p_stream == NULL && errno != ENOENT )
 789         msg_Err( p_obj, "cannot open config file (%s): %s", psz_filename, strerror(errno) );
 790
 791     return p_stream;
 792 }
 793
 794
 795 /*****************************************************************************
 796  * config_LoadConfigFile: loads the configuration file.
 797  *****************************************************************************
 798  * This function is called to load the config options stored in the config
 799  * file.
 800  *****************************************************************************/
 801 int __config_LoadConfigFile( vlc_object_t *p_this, const char *psz_module_name )
 802 {
 803     vlc_list_t *p_list;
 804     FILE *file;
 805
 806     file = config_OpenConfigFile (p_this, "rt");
 807     if (file == NULL)
 808         return VLC_EGENERIC;
 809
 810     /* Acquire config file lock */
 811     vlc_mutex_lock( &p_this->p_libvlc->config_lock );
 812
 813     /* Look for the selected module, if NULL then save everything */
 814     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
 815
 816     /* Look for UTF-8 Byte Order Mark */
 817     char * (*convert) (const char *) = strdupnull;
 818     char bom[3];
 819
 820     if ((fread (bom, 1, 3, file) != 3)
 821      || memcmp (bom, "\xEF\xBB\xBF", 3))
 822     {
 823         convert = FromLocaleDup;
 824         rewind (file); /* no BOM, rewind */
 825     }
 826
 827     module_t *module = NULL;
 828     char line[1024], section[1022];
 829     section[0] = '\0';
 830
 831     while (fgets (line, 1024, file) != NULL)
 832     {
 833         /* Ignore comments and empty lines */
 834         switch (line[0])
 835         {
 836             case '#':
 837             case '\n':
 838             case '\0':
 839                 continue;
 840         }
 841
 842         if (line[0] == '[')
 843         {
 844             char *ptr = strchr (line, ']');
 845             if (ptr == NULL)
 846                 continue; /* syntax error; */
 847             *ptr = '\0';
 848
 849             /* New section ( = a given module) */
 850             strcpy (section, line + 1);
 851             module = NULL;
 852
 853             if ((psz_module_name == NULL)
 854              || (strcmp (psz_module_name, section) == 0))
 855             {
 856                 for (int i = 0; i < p_list->i_count; i++)
 857                 {
 858                     module_t *m = (module_t *)p_list->p_values[i].p_object;
 859
 860                     if ((strcmp (section, m->psz_object_name) == 0)
 861                      && (m->i_config_items > 0)) /* ignore config-less modules */
 862                     {
 863                         module = m;
 864                         if (psz_module_name != NULL)
 865                             msg_Dbg (p_this,
 866                                      "loading config for module \"%s\"",
 867                                      section);
 868                         break;
 869                     }
 870                 }
 871             }
 872
 873             continue;
 874         }
 875
 876         if (module == NULL)
 877             continue; /* no need to parse if there is no matching module */
 878
 879         char *ptr = strchr (line, '\n');
 880         if (ptr != NULL)
 881             *ptr = '\0';
 882
 883         /* look for option name */
 884         const char *psz_option_name = line;
 885
 886         ptr = strchr (line, '=');
 887         if (ptr == NULL)
 888             continue; /* syntax error */
 889
 890         *ptr = '\0';
 891         const char *psz_option_value = ptr + 1;
 892
 893         /* try to match this option with one of the module's options */
 894         for (size_t i = 0; i < module->confsize; i++)
 895         {
 896             module_config_t *p_item = module->p_config + i;
 897
 898             if ((p_item->i_type & CONFIG_HINT)
 899              || strcmp (p_item->psz_name, psz_option_name))
 900                 continue;
 901
 902             /* We found it */
 903             switch( p_item->i_type )
 904             {
 905                 case CONFIG_ITEM_BOOL:
 906                 case CONFIG_ITEM_INTEGER:
 907                     if( !*psz_option_value )
 908                         break;                    /* ignore empty option */
 909                     p_item->value.i = strtol( psz_option_value, 0, 0 );
 910                     p_item->saved.i = p_item->value.i;
 911
 912                     /*msg_Dbg (p_this, "option \"%s\", value %i",
 913                              psz_option_name, p_item->value.i);*/
 914                     break;
 915
 916                 case CONFIG_ITEM_FLOAT:
 917                     if( !*psz_option_value )
 918                         break;                    /* ignore empty option */
 919                     p_item->value.f = (float)i18n_atof( psz_option_value);
 920                     p_item->saved.f = p_item->value.f;
 921
 922                     /*msg_Dbg (p_this, "option \"%s\", value %f",
 923                              psz_option_name, (double)p_item->value.f);*/
 924                     break;
 925
 926                 case CONFIG_ITEM_KEY:
 927                     if( !*psz_option_value )
 928                         break;                    /* ignore empty option */
 929                     p_item->value.i = ConfigStringToKey(psz_option_value);
 930                     p_item->saved.i = p_item->value.i;
 931                     break;
 932
 933                 default:
 934                     vlc_mutex_lock( p_item->p_lock );
 935
 936                     /* free old string */
 937                     free( (char*) p_item->value.psz );
 938                     free( (char*) p_item->saved.psz );
 939
 940                     p_item->value.psz = convert (psz_option_value);
 941                     p_item->saved.psz = strdupnull (p_item->value.psz);
 942
 943                     vlc_mutex_unlock( p_item->p_lock );
 944
 945                     /*msg_Dbg (p_this, "option \"%s\", value \"%s\"",
 946                              psz_option_name, psz_option_value ?: "");*/
 947                     break;
 948             }
 949
 950             break;
 951         }
 952     }
 953
 954     vlc_list_release( p_list );
 955
 956     fclose( file );
 957
 958     vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
 959     return 0;
 960 }
 961
 962 /*****************************************************************************
 963  * config_CreateDir: Create configuration directory if it doesn't exist.
 964  *****************************************************************************/
 965 int config_CreateDir( vlc_object_t *p_this, const char *psz_dirname )
 966 {
 967     if( !psz_dirname && !*psz_dirname ) return -1;
 968
 969     if( utf8_mkdir( psz_dirname ) && ( errno != EEXIST ) )
 970     {
 971         msg_Err( p_this, "could not create %s (%s)",
 972                  psz_dirname, strerror(errno) );
 973         return -1;
 974     }
 975
 976     return 0;
 977 }
 978
 979 /*****************************************************************************
 980  * config_SaveConfigFile: Save a module's config options.
 981  *****************************************************************************
 982  * This will save the specified module's config options to the config file.
 983  * If psz_module_name is NULL then we save all the modules config options.
 984  * It's no use to save the config options that kept their default values, so
 985  * we'll try to be a bit clever here.
 986  *
 987  * When we save we mustn't delete the config options of the modules that
 988  * haven't been loaded. So we cannot just create a new config file with the
 989  * config structures we've got in memory.
 990  * I don't really know how to deal with this nicely, so I will use a completly
 991  * dumb method ;-)
 992  * I will load the config file in memory, but skipping all the sections of the
 993  * modules we want to save. Then I will create a brand new file, dump the file
 994  * loaded in memory and then append the sections of the modules we want to
 995  * save.
 996  * Really stupid no ?
 997  *****************************************************************************/
 998 static int SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name,
 999                            vlc_bool_t b_autosave )
1000 {
1001     module_t *p_parser;
1002     vlc_list_t *p_list;
1003     FILE *file;
1004     char p_line[1024], *p_index2;
1005     int i_sizebuf = 0;
1006     char *p_bigbuffer, *p_index;
1007     vlc_bool_t b_backup;
1008     int i_index;
1009
1010     /* Acquire config file lock */
1011     vlc_mutex_lock( &p_this->p_libvlc->config_lock );
1012
1013     if (p_this->p_libvlc->psz_configfile == NULL)
1014     {
1015         const char *psz_homedir = p_this->p_libvlc->psz_homedir;
1016         if( !psz_homedir )
1017         {
1018             msg_Err( p_this, "no home directory defined" );
1019             vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
1020             return -1;
1021         }
1022
1023         char dirname[strlen (psz_homedir) + sizeof (DIR_SEP CONFIG_DIR)];
1024         sprintf (dirname, "%s" DIR_SEP CONFIG_DIR, psz_homedir);
1025         config_CreateDir (p_this, dirname);
1026     }
1027
1028     file = config_OpenConfigFile (p_this, "rt");
1029     if (file != NULL)
1030     {
1031         /* look for file size */
1032         fseek( file, 0L, SEEK_END );
1033         i_sizebuf = ftell( file );
1034         fseek( file, 0L, SEEK_SET );
1035     }
1036
1037     p_bigbuffer = p_index = malloc( i_sizebuf+1 );
1038     if( !p_bigbuffer )
1039     {
1040         msg_Err( p_this, "out of memory" );
1041         if( file ) fclose( file );
1042         vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
1043         return -1;
1044     }
1045     p_bigbuffer[0] = 0;
1046
1047     /* List all available modules */
1048     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1049
1050     /* backup file into memory, we only need to backup the sections we won't
1051      * save later on */
1052     b_backup = 0;
1053     while( file && fgets( p_line, 1024, file ) )
1054     {
1055         if( (p_line[0] == '[') && (p_index2 = strchr(p_line,']')))
1056         {
1057
1058             /* we found a section, check if we need to do a backup */
1059             for( i_index = 0; i_index < p_list->i_count; i_index++ )
1060             {
1061                 p_parser = (module_t *)p_list->p_values[i_index].p_object ;
1062
1063                 if( ((p_index2 - &p_line[1])
1064                        == (int)strlen(p_parser->psz_object_name) )
1065                     && !memcmp( &p_line[1], p_parser->psz_object_name,
1066                                 strlen(p_parser->psz_object_name) ) )
1067                 {
1068                     if( !psz_module_name )
1069                         break;
1070                     else if( !strcmp( psz_module_name,
1071                                       p_parser->psz_object_name ) )
1072                         break;
1073                 }
1074             }
1075
1076             if( i_index == p_list->i_count )
1077             {
1078                 /* we don't have this section in our list so we need to back
1079                  * it up */
1080                 *p_index2 = 0;
1081 #if 0
1082                 msg_Dbg( p_this, "backing up config for unknown module \"%s\"",
1083                                  &p_line[1] );
1084 #endif
1085                 *p_index2 = ']';
1086
1087                 b_backup = 1;
1088             }
1089             else
1090             {
1091                 b_backup = 0;
1092             }
1093         }
1094
1095         /* save line if requested and line is valid (doesn't begin with a
1096          * space, tab, or eol) */
1097         if( b_backup && (p_line[0] != '\n') && (p_line[0] != ' ')
1098             && (p_line[0] != '\t') )
1099         {
1100             strcpy( p_index, p_line );
1101             p_index += strlen( p_line );
1102         }
1103     }
1104     if( file ) fclose( file );
1105
1106
1107     /*
1108      * Save module config in file
1109      */
1110
1111     file = config_OpenConfigFile (p_this, "wt");
1112     if( !file )
1113     {
1114         vlc_list_release( p_list );
1115         free( p_bigbuffer );
1116         vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
1117         return -1;
1118     }
1119
1120     fprintf( file, "\xEF\xBB\xBF###\n###  " COPYRIGHT_MESSAGE "\n###\n\n"
1121        "###\n### lines begining with a '#' character are comments\n###\n\n" );
1122
1123     /* Look for the selected module, if NULL then save everything */
1124     for( i_index = 0; i_index < p_list->i_count; i_index++ )
1125     {
1126         module_config_t *p_item, *p_end;
1127         p_parser = (module_t *)p_list->p_values[i_index].p_object ;
1128
1129         if( psz_module_name && strcmp( psz_module_name,
1130                                        p_parser->psz_object_name ) )
1131             continue;
1132
1133         if( !p_parser->i_config_items )
1134             continue;
1135
1136         if( psz_module_name )
1137             msg_Dbg( p_this, "saving config for module \"%s\"",
1138                      p_parser->psz_object_name );
1139
1140         fprintf( file, "[%s]", p_parser->psz_object_name );
1141         if( p_parser->psz_longname )
1142             fprintf( file, " # %s\n\n", p_parser->psz_longname );
1143         else
1144             fprintf( file, "\n\n" );
1145
1146         for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
1147              p_item < p_end;
1148              p_item++ )
1149         {
1150             char  *psz_key;
1151             int   i_value = p_item->value.i;
1152             float f_value = p_item->value.f;
1153             const char  *psz_value = p_item->value.psz;
1154
1155             if( p_item->i_type & CONFIG_HINT )
1156                 /* ignore hints */
1157                 continue;
1158             /* Ignore deprecated options */
1159             if( p_item->psz_current )
1160                 continue;
1161             if( p_item->b_unsaveable )
1162                 /*obvious*/
1163                 continue;
1164
1165             if( b_autosave && !p_item->b_autosave )
1166             {
1167                 i_value = p_item->saved.i;
1168                 f_value = p_item->saved.f;
1169                 psz_value = p_item->saved.psz;
1170                 if( !psz_value ) psz_value = p_item->orig.psz;
1171             }
1172             else
1173             {
1174                 p_item->b_dirty = VLC_FALSE;
1175             }
1176
1177             switch( p_item->i_type )
1178             {
1179             case CONFIG_ITEM_BOOL:
1180             case CONFIG_ITEM_INTEGER:
1181                 if( p_item->psz_text )
1182                     fprintf( file, "# %s (%s)\n", p_item->psz_text,
1183                              (p_item->i_type == CONFIG_ITEM_BOOL) ?
1184                              _("boolean") : _("integer") );
1185                 if( i_value == p_item->orig.i )
1186                     fputc ('#', file);
1187                 fprintf( file, "%s=%i\n", p_item->psz_name, i_value );
1188
1189                 p_item->saved.i = i_value;
1190                 break;
1191
1192             case CONFIG_ITEM_KEY:
1193                 if( p_item->psz_text )
1194                     fprintf( file, "# %s (%s)\n", p_item->psz_text,
1195                              _("key") );
1196                 if( i_value == p_item->orig.i )
1197                     fputc ('#', file);
1198                 psz_key = ConfigKeyToString( i_value );
1199                 fprintf( file, "%s=%s\n", p_item->psz_name,
1200                          psz_key ? psz_key : "" );
1201                 freenull (psz_key);
1202
1203                 p_item->saved.i = i_value;
1204                 break;
1205
1206             case CONFIG_ITEM_FLOAT:
1207                 if( p_item->psz_text )
1208                     fprintf( file, "# %s (%s)\n", p_item->psz_text,
1209                              _("float") );
1210                 if( f_value == p_item->orig.f )
1211                     fputc ('#', file);
1212                 fprintf( file, "%s=%f\n", p_item->psz_name, (double)f_value );
1213
1214                 p_item->saved.f = f_value;
1215                 break;
1216
1217             default:
1218                 if( p_item->psz_text )
1219                     fprintf( file, "# %s (%s)\n", p_item->psz_text,
1220                              _("string") );
1221                 if( (!psz_value && !p_item->orig.psz) ||
1222                     (psz_value && p_item->orig.psz &&
1223                      !strcmp( psz_value, p_item->orig.psz )) )
1224                     fputc ('#', file);
1225                 fprintf( file, "%s=%s\n", p_item->psz_name,
1226                          psz_value ?: "" );
1227
1228                 if( b_autosave && !p_item->b_autosave ) break;
1229
1230                 freenull (p_item->saved.psz);
1231                 if( (psz_value && p_item->orig.psz &&
1232                      strcmp( psz_value, p_item->orig.psz )) ||
1233                     !psz_value || !p_item->orig.psz)
1234                     p_item->saved.psz = strdupnull (psz_value);
1235                 else
1236                     p_item->saved.psz = NULL;
1237             }
1238         }
1239
1240         fputc ('\n', file);
1241     }
1242
1243     vlc_list_release( p_list );
1244
1245     /*
1246      * Restore old settings from the config in file
1247      */
1248     fputs( p_bigbuffer, file );
1249     free( p_bigbuffer );
1250
1251     fclose( file );
1252     vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
1253
1254     return 0;
1255 }
1256
1257 int config_AutoSaveConfigFile( vlc_object_t *p_this )
1258 {
1259     vlc_list_t *p_list;
1260     int i_index, i_count;
1261
1262     if( !p_this ) return -1;
1263
1264     /* Check if there's anything to save */
1265     vlc_mutex_lock( &p_this->p_libvlc->config_lock );
1266     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1267     i_count = p_list->i_count;
1268     for( i_index = 0; i_index < i_count; i_index++ )
1269     {
1270         module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object ;
1271         module_config_t *p_item, *p_end;
1272
1273         if( !p_parser->i_config_items ) continue;
1274
1275         for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
1276              p_item < p_end;
1277              p_item++ )
1278         {
1279             if( p_item->b_autosave && p_item->b_dirty ) break;
1280         }
1281         break;
1282     }
1283     vlc_list_release( p_list );
1284     vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
1285
1286     if( i_index == i_count ) return VLC_SUCCESS;
1287     return SaveConfigFile( p_this, 0, VLC_TRUE );
1288 }
1289
1290 int __config_SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name )
1291 {
1292     return SaveConfigFile( p_this, psz_module_name, VLC_FALSE );
1293 }
1294
1295 /*****************************************************************************
1296  * config_LoadCmdLine: parse command line
1297  *****************************************************************************
1298  * Parse command line for configuration options.
1299  * Now that the module_bank has been initialized, we can dynamically
1300  * generate the longopts structure used by getops. We have to do it this way
1301  * because we don't know (and don't want to know) in advance the configuration
1302  * options used (ie. exported) by each module.
1303  *****************************************************************************/
1304 int __config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, char *ppsz_argv[],
1305                           vlc_bool_t b_ignore_errors )
1306 {
1307     int i_cmd, i_index, i_opts, i_shortopts, flag, i_verbose = 0;
1308     module_t *p_parser;
1309     vlc_list_t *p_list;
1310     struct option *p_longopts;
1311     int i_modules_index;
1312
1313     /* Short options */
1314     module_config_t *pp_shortopts[256];
1315     char *psz_shortopts;
1316
1317     /* Set default configuration and copy arguments */
1318     p_this->p_libvlc->i_argc    = *pi_argc;
1319     p_this->p_libvlc->ppsz_argv = ppsz_argv;
1320
1321 #ifdef __APPLE__
1322     /* When VLC.app is run by double clicking in Mac OS X, the 2nd arg
1323      * is the PSN - process serial number (a unique PID-ish thingie)
1324      * still ok for real Darwin & when run from command line */
1325     if ( (*pi_argc > 1) && (strncmp( ppsz_argv[ 1 ] , "-psn" , 4 ) == 0) )
1326                                         /* for example -psn_0_9306113 */
1327     {
1328         /* GDMF!... I can't do this or else the MacOSX window server will
1329          * not pick up the PSN and not register the app and we crash...
1330          * hence the following kludge otherwise we'll get confused w/ argv[1]
1331          * being an input file name */
1332 #if 0
1333         ppsz_argv[ 1 ] = NULL;
1334 #endif
1335         *pi_argc = *pi_argc - 1;
1336         pi_argc--;
1337         return 0;
1338     }
1339 #endif
1340
1341     /* List all modules */
1342     p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
1343
1344     /*
1345      * Generate the longopts and shortopts structures used by getopt_long
1346      */
1347
1348     i_opts = 0;
1349     for( i_modules_index = 0; i_modules_index < p_list->i_count;
1350          i_modules_index++ )
1351     {
1352         p_parser = (module_t *)p_list->p_values[i_modules_index].p_object ;
1353
1354         /* count the number of exported configuration options (to allocate
1355          * longopts). We also need to allocate space for two options when
1356          * dealing with boolean to allow for --foo and --no-foo */
1357         i_opts += p_parser->i_config_items
1358                      + 2 * p_parser->i_bool_items;
1359     }
1360
1361     p_longopts = malloc( sizeof(struct option) * (i_opts + 1) );
1362     if( p_longopts == NULL )
1363     {
1364         msg_Err( p_this, "out of memory" );
1365         vlc_list_release( p_list );
1366         return -1;
1367     }
1368
1369     psz_shortopts = malloc( sizeof( char ) * (2 * i_opts + 1) );
1370     if( psz_shortopts == NULL )
1371     {
1372         msg_Err( p_this, "out of memory" );
1373         free( p_longopts );
1374         vlc_list_release( p_list );
1375         return -1;
1376     }
1377
1378     /* If we are requested to ignore errors, then we must work on a copy
1379      * of the ppsz_argv array, otherwise getopt_long will reorder it for
1380      * us, ignoring the arity of the options */
1381     if( b_ignore_errors )
1382     {
1383         ppsz_argv = (char**)malloc( *pi_argc * sizeof(char *) );
1384         if( ppsz_argv == NULL )
1385         {
1386             msg_Err( p_this, "out of memory" );
1387             free( psz_shortopts );
1388             free( p_longopts );
1389             vlc_list_release( p_list );
1390             return -1;
1391         }
1392         memcpy( ppsz_argv, p_this->p_libvlc->ppsz_argv,
1393                 *pi_argc * sizeof(char *) );
1394     }
1395
1396     i_shortopts = 0;
1397     for( i_index = 0; i_index < 256; i_index++ )
1398     {
1399         pp_shortopts[i_index] = NULL;
1400     }
1401
1402     /* Fill the p_longopts and psz_shortopts structures */
1403     i_index = 0;
1404     for( i_modules_index = 0; i_modules_index < p_list->i_count;
1405          i_modules_index++ )
1406     {
1407         module_config_t *p_item, *p_end;
1408         p_parser = (module_t *)p_list->p_values[i_modules_index].p_object ;
1409
1410         if( !p_parser->i_config_items )
1411             continue;
1412
1413         for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
1414              p_item < p_end;
1415              p_item++ )
1416         {
1417             /* Ignore hints */
1418             if( p_item->i_type & CONFIG_HINT )
1419                 continue;
1420
1421             /* Add item to long options */
1422             p_longopts[i_index].name = strdup( p_item->psz_name );
1423             if( p_longopts[i_index].name == NULL ) continue;
1424             p_longopts[i_index].has_arg =
1425                 (p_item->i_type == CONFIG_ITEM_BOOL)?
1426                                                no_argument : required_argument;
1427             p_longopts[i_index].flag = &flag;
1428             p_longopts[i_index].val = 0;
1429             i_index++;
1430
1431             /* When dealing with bools we also need to add the --no-foo
1432              * option */
1433             if( p_item->i_type == CONFIG_ITEM_BOOL )
1434             {
1435                 char *psz_name = malloc( strlen(p_item->psz_name) + 3 );
1436                 if( psz_name == NULL ) continue;
1437                 strcpy( psz_name, "no" );
1438                 strcat( psz_name, p_item->psz_name );
1439
1440                 p_longopts[i_index].name = psz_name;
1441                 p_longopts[i_index].has_arg = no_argument;
1442                 p_longopts[i_index].flag = &flag;
1443                 p_longopts[i_index].val = 1;
1444                 i_index++;
1445
1446                 psz_name = malloc( strlen(p_item->psz_name) + 4 );
1447                 if( psz_name == NULL ) continue;
1448                 strcpy( psz_name, "no-" );
1449                 strcat( psz_name, p_item->psz_name );
1450
1451                 p_longopts[i_index].name = psz_name;
1452                 p_longopts[i_index].has_arg = no_argument;
1453                 p_longopts[i_index].flag = &flag;
1454                 p_longopts[i_index].val = 1;
1455                 i_index++;
1456             }
1457
1458             /* If item also has a short option, add it */
1459             if( p_item->i_short )
1460             {
1461                 pp_shortopts[(int)p_item->i_short] = p_item;
1462                 psz_shortopts[i_shortopts] = p_item->i_short;
1463                 i_shortopts++;
1464                 if( p_item->i_type != CONFIG_ITEM_BOOL )
1465                 {
1466                     psz_shortopts[i_shortopts] = ':';
1467                     i_shortopts++;
1468
1469                     if( p_item->i_short == 'v' )
1470                     {
1471                         psz_shortopts[i_shortopts] = ':';
1472                         i_shortopts++;
1473                     }
1474                 }
1475             }
1476         }
1477     }
1478
1479     /* We don't need the module list anymore */
1480     vlc_list_release( p_list );
1481
1482     /* Close the longopts and shortopts structures */
1483     memset( &p_longopts[i_index], 0, sizeof(struct option) );
1484     psz_shortopts[i_shortopts] = '\0';
1485
1486     /*
1487      * Parse the command line options
1488      */
1489     opterr = 0;
1490     optind = 0; /* set to 0 to tell GNU getopt to reinitialize */
1491     while( ( i_cmd = getopt_long( *pi_argc, ppsz_argv, psz_shortopts,
1492                                   p_longopts, &i_index ) ) != -1 )
1493     {
1494         /* A long option has been recognized */
1495         if( i_cmd == 0 )
1496         {
1497             module_config_t *p_conf;
1498             char *psz_name = (char *)p_longopts[i_index].name;
1499
1500             /* Check if we deal with a --nofoo or --no-foo long option */
1501             if( flag ) psz_name += psz_name[2] == '-' ? 3 : 2;
1502
1503             /* Store the configuration option */
1504             p_conf = config_FindConfig( p_this, psz_name );
1505             if( p_conf )
1506             {
1507                 /* Check if the option is deprecated */
1508                 if( p_conf->psz_current )
1509                 {
1510                     if( !strcmp(p_conf->psz_current,"SUPPRESSED") )
1511                     {
1512                         if( !b_ignore_errors )
1513                         {
1514                             fprintf(stderr,
1515                                     "Warning: option --%s is no longer used.\n",
1516                                     p_conf->psz_name);
1517                         }
1518                        continue;
1519                     }
1520                     if( !b_ignore_errors )
1521                     {
1522                         if( p_conf->b_strict )
1523                         {
1524                             fprintf( stderr,
1525                                      "Error: option --%s is deprecated. "
1526                                      "Use --%s instead.\n",
1527                                      p_conf->psz_name, p_conf->psz_current);
1528                             /*free */
1529                             for( i_index = 0; p_longopts[i_index].name; i_index++ )
1530                                 free( (char *)p_longopts[i_index].name );
1531
1532                             free( p_longopts );
1533                             free( psz_shortopts );
1534                             return -1;
1535                         }
1536                         fprintf(stderr,
1537                                 "Warning: option --%s is deprecated. "
1538                                 "You should use --%s instead.\n",
1539                                 p_conf->psz_name, p_conf->psz_current);
1540                     }
1541                     psz_name = (char *)p_conf->psz_current;
1542                     p_conf = config_FindConfig( p_this, psz_name );
1543                 }
1544
1545                 switch( p_conf->i_type )
1546                 {
1547                     case CONFIG_ITEM_STRING:
1548                     case CONFIG_ITEM_FILE:
1549                     case CONFIG_ITEM_DIRECTORY:
1550                     case CONFIG_ITEM_MODULE:
1551                     case CONFIG_ITEM_MODULE_LIST:
1552                     case CONFIG_ITEM_MODULE_LIST_CAT:
1553                     case CONFIG_ITEM_MODULE_CAT:
1554                         config_PutPsz( p_this, psz_name, optarg );
1555                         break;
1556                     case CONFIG_ITEM_INTEGER:
1557                         config_PutInt( p_this, psz_name, strtol(optarg, 0, 0));
1558                         break;
1559                     case CONFIG_ITEM_FLOAT:
1560                         config_PutFloat( p_this, psz_name, (float)atof(optarg) );
1561                         break;
1562                     case CONFIG_ITEM_KEY:
1563                         config_PutInt( p_this, psz_name, ConfigStringToKey( optarg ) );
1564                         break;
1565                     case CONFIG_ITEM_BOOL:
1566                         config_PutInt( p_this, psz_name, !flag );
1567                         break;
1568                 }
1569                 continue;
1570             }
1571         }
1572
1573         /* A short option has been recognized */
1574         if( pp_shortopts[i_cmd] != NULL )
1575         {
1576             switch( pp_shortopts[i_cmd]->i_type )
1577             {
1578                 case CONFIG_ITEM_STRING:
1579                 case CONFIG_ITEM_FILE:
1580                 case CONFIG_ITEM_DIRECTORY:
1581                 case CONFIG_ITEM_MODULE:
1582                 case CONFIG_ITEM_MODULE_CAT:
1583                 case CONFIG_ITEM_MODULE_LIST:
1584                 case CONFIG_ITEM_MODULE_LIST_CAT:
1585                     config_PutPsz( p_this, pp_shortopts[i_cmd]->psz_name, optarg );
1586                     break;
1587                 case CONFIG_ITEM_INTEGER:
1588                     if( i_cmd == 'v' )
1589                     {
1590                         if( optarg )
1591                         {
1592                             if( *optarg == 'v' ) /* eg. -vvv */
1593                             {
1594                                 i_verbose++;
1595                                 while( *optarg == 'v' )
1596                                 {
1597                                     i_verbose++;
1598                                     optarg++;
1599                                 }
1600                             }
1601                             else
1602                             {
1603                                 i_verbose += atoi( optarg ); /* eg. -v2 */
1604                             }
1605                         }
1606                         else
1607                         {
1608                             i_verbose++; /* -v */
1609                         }
1610                         config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name,
1611                                                i_verbose );
1612                     }
1613                     else
1614                     {
1615                         config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name,
1616                                                strtol(optarg, 0, 0) );
1617                     }
1618                     break;
1619                 case CONFIG_ITEM_BOOL:
1620                     config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name, 1 );
1621                     break;
1622             }
1623
1624             continue;
1625         }
1626
1627         /* Internal error: unknown option */
1628         if( !b_ignore_errors )
1629         {
1630             fprintf( stderr, "%s: unknown option"
1631                      " or missing mandatory argument ",
1632                      p_this->p_libvlc->psz_object_name );
1633             if( optopt )
1634             {
1635                 fprintf( stderr, "`-%c'\n", optopt );
1636             }
1637             else
1638             {
1639                 fprintf( stderr, "`%s'\n", ppsz_argv[optind-1] );
1640             }
1641             fprintf( stderr, "Try `%s --help' for more information.\n",
1642                              p_this->p_libvlc->psz_object_name );
1643
1644             for( i_index = 0; p_longopts[i_index].name; i_index++ )
1645                 free( (char *)p_longopts[i_index].name );
1646             free( p_longopts );
1647             free( psz_shortopts );
1648             return -1;
1649         }
1650     }
1651
1652     /* Free allocated resources */
1653     for( i_index = 0; p_longopts[i_index].name; i_index++ )
1654         free( (char *)p_longopts[i_index].name );
1655     free( p_longopts );
1656     free( psz_shortopts );
1657     if( b_ignore_errors ) free( ppsz_argv );
1658
1659     return 0;
1660 }
1661
1662 /**
1663  * config_GetDataDir: find directory where shared data is installed
1664  *
1665  * @return a string (always succeeds).
1666  */
1667 const char *config_GetDataDir( const vlc_object_t *p_this )
1668 {
1669 #if defined (WIN32) || defined (UNDER_CE)
1670     return p_this->p_libvlc_global->psz_vlcpath;
1671 #elif defined(__APPLE__) || defined (SYS_BEOS)
1672     static char path[PATH_MAX] = "";
1673
1674     if( *path == '\0' )
1675     {
1676         snprintf( path, sizeof( path ), "%s/share",
1677                   p_this->p_libvlc_global->psz_vlcpath );
1678         path[sizeof( path ) - 1] = '\0';
1679     }
1680     return path;
1681 #else
1682     (void)p_this;
1683     return DATA_PATH;
1684 #endif
1685 }
1686
1687 /*****************************************************************************
1688  * config_GetHomeDir, config_GetUserDir: find the user's home directory.
1689  *****************************************************************************
1690  * This function will try by different ways to find the user's home path.
1691  * Note that this function is not reentrant, it should be called only once
1692  * at the beginning of main where the result will be stored for later use.
1693  *****************************************************************************/
1694 static char *GetDir( vlc_bool_t b_appdata )
1695 {
1696     const char *psz_localhome = NULL;
1697
1698 #if defined(WIN32) && !defined(UNDER_CE)
1699     typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,
1700                                                LPWSTR );
1701 #ifndef CSIDL_FLAG_CREATE
1702 #   define CSIDL_FLAG_CREATE 0x8000
1703 #endif
1704 #ifndef CSIDL_APPDATA
1705 #   define CSIDL_APPDATA 0x1A
1706 #endif
1707 #ifndef CSIDL_PROFILE
1708 #   define CSIDL_PROFILE 0x28
1709 #endif
1710 #ifndef SHGFP_TYPE_CURRENT
1711 #   define SHGFP_TYPE_CURRENT 0
1712 #endif
1713
1714     HINSTANCE shfolder_dll;
1715     SHGETFOLDERPATH SHGetFolderPath ;
1716
1717     /* load the shfolder dll to retrieve SHGetFolderPath */
1718     if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )
1719     {
1720         SHGetFolderPath = (void *)GetProcAddress( shfolder_dll,
1721                                                   _T("SHGetFolderPathW") );
1722         if ( SHGetFolderPath != NULL )
1723         {
1724             wchar_t whomedir[MAX_PATH];
1725
1726             /* get the "Application Data" folder for the current user */
1727             if( S_OK == SHGetFolderPath( NULL,
1728                                          (b_appdata ? CSIDL_APPDATA :
1729                                            CSIDL_PROFILE) | CSIDL_FLAG_CREATE,
1730                                          NULL, SHGFP_TYPE_CURRENT,
1731                                          whomedir ) )
1732             {
1733                 FreeLibrary( shfolder_dll );
1734                 return FromWide( whomedir );
1735             }
1736         }
1737         FreeLibrary( shfolder_dll );
1738     }
1739
1740 #elif defined(UNDER_CE)
1741
1742 #ifndef CSIDL_APPDATA
1743 #   define CSIDL_APPDATA 0x1A
1744 #endif
1745
1746     wchar_t whomedir[MAX_PATH];
1747
1748     /* get the "Application Data" folder for the current user */
1749     if( SHGetSpecialFolderPath( NULL, whomedir, CSIDL_APPDATA, 1 ) )
1750         return FromWide( whomedir );
1751 #endif
1752
1753 #if defined(HAVE_GETPWUID)
1754     struct passwd *p_pw;
1755     (void)b_appdata;
1756
1757     if( ( p_pw = getpwuid( getuid() ) ) == NULL )
1758 #endif
1759     {
1760         psz_localhome = getenv( "HOME" );
1761         if( psz_localhome == NULL )
1762         {
1763             psz_localhome = getenv( "TMP" );
1764             if( psz_localhome == NULL )
1765                 psz_localhome = "/tmp";
1766         }
1767     }
1768 #if defined(HAVE_GETPWUID)
1769     else
1770         psz_localhome = p_pw->pw_dir;
1771 #endif
1772
1773     return FromLocaleDup( psz_localhome );
1774 }
1775
1776 char *config_GetHomeDir( void )
1777 {
1778     return GetDir( VLC_TRUE );
1779 }
1780
1781 char *config_GetUserDir( void )
1782 {
1783     return GetDir( VLC_FALSE );
1784 }
1785
1786
1787 static int ConfigStringToKey( const char *psz_key )
1788 {
1789     int i_key = 0;
1790     unsigned int i;
1791     const char *psz_parser = strchr( psz_key, '-' );
1792     while( psz_parser && psz_parser != psz_key )
1793     {
1794         for( i = 0; i < sizeof(vlc_modifiers) / sizeof(key_descriptor_t); i++ )
1795         {
1796             if( !strncasecmp( vlc_modifiers[i].psz_key_string, psz_key,
1797                               strlen( vlc_modifiers[i].psz_key_string ) ) )
1798             {
1799                 i_key |= vlc_modifiers[i].i_key_code;
1800             }
1801         }
1802         psz_key = psz_parser + 1;
1803         psz_parser = strchr( psz_key, '-' );
1804     }
1805     for( i = 0; i < sizeof(vlc_keys) / sizeof( key_descriptor_t ); i++ )
1806     {
1807         if( !strcasecmp( vlc_keys[i].psz_key_string, psz_key ) )
1808         {
1809             i_key |= vlc_keys[i].i_key_code;
1810             break;
1811         }
1812     }
1813     return i_key;
1814 }
1815
1816 static char *ConfigKeyToString( int i_key )
1817 {
1818     char *psz_key = malloc( 100 );
1819     char *p;
1820     size_t index;
1821
1822     if ( !psz_key )
1823     {
1824         return NULL;
1825     }
1826     *psz_key = '\0';
1827     p = psz_key;
1828     for( index = 0; index < (sizeof(vlc_modifiers) / sizeof(key_descriptor_t));
1829          index++ )
1830     {
1831         if( i_key & vlc_modifiers[index].i_key_code )
1832         {
1833             p += sprintf( p, "%s-", vlc_modifiers[index].psz_key_string );
1834         }
1835     }
1836     for( index = 0; index < (sizeof(vlc_keys) / sizeof( key_descriptor_t));
1837          index++)
1838     {
1839         if( (int)( i_key & ~KEY_MODIFIER ) == vlc_keys[index].i_key_code )
1840         {
1841             p += sprintf( p, "%s", vlc_keys[index].psz_key_string );
1842             break;
1843         }
1844     }
1845     return psz_key;
1846 }