static FILE *config_OpenConfigFile( vlc_object_t *p_obj )
{
char *psz_filename = config_GetConfigFile( p_obj );
if( psz_filename == NULL )
return NULL;
msg_Dbg( p_obj, "opening config file (%s)", psz_filename );
FILE *p_stream = vlc_fopen( psz_filename, "rt" );
if( p_stream == NULL && errno != ENOENT )
{
msg_Err( p_obj, "cannot open config file (%s): %m",
psz_filename );
}
#if !( defined(WIN32) || defined(__APPLE__) || defined(__OS2__) )
else if( p_stream == NULL && errno == ENOENT )
{
/* This is the fallback for pre XDG Base Directory
* Specification configs */
char *home = config_GetUserDir(VLC_HOME_DIR);
char *psz_old;
if( home != NULL
&& asprintf( &psz_old, "%s/.vlc/" CONFIG_FILE,
home ) != -1 )
{
p_stream = vlc_fopen( psz_old, "rt" );
if( p_stream )
{
/* Old config file found. We want to write it at the
* new location now. */
msg_Info( p_obj->p_libvlc, "Found old config file at %s. "
"VLC will now use %s.", psz_old, psz_filename );
char *psz_readme;
if( asprintf(&psz_readme,"%s/.vlc/README",
home ) != -1 )
{
FILE *p_readme = vlc_fopen( psz_readme, "wt" );
if( p_readme )
{
fprintf( p_readme, "The VLC media player "
"configuration folder has moved to comply\n"
"with the XDG Base Directory Specification "
"version 0.6. Your\nconfiguration has been "
"copied to the new location:\n%s\nYou can "
"delete this directory and all its contents.",
psz_filename);
fclose( p_readme );
}
free( psz_readme );
}
/* Remove the old configuration file so that --reset-config
* can work properly. Fortunately, Linux allows removing
* open files - with most filesystems. */
unlink( psz_old );
}
free( psz_old );
}
free( home );
}
#endif
free( psz_filename );
return p_stream;
}
static int LoadCatalog( addons_finder_t *p_finder )
{
char *psz_path;
char * psz_userdir = config_GetUserDir( VLC_DATA_DIR );
if ( !psz_userdir ) return VLC_ENOMEM;
if ( asprintf( &psz_path, "file://%s%s", psz_userdir, ADDONS_CATALOG ) < 1 )
{
free( psz_userdir );
return VLC_ENOMEM;
}
free( psz_userdir );
addon_entry_t *p_entry = NULL;
const char *p_node;
int i_current_node_type;
int i_ret = VLC_SUCCESS;
/* attr */
const char *attr, *value;
/* temp reading */
char *psz_filename = NULL;
int i_filetype = -1;
struct stat stat_;
if ( vlc_stat( psz_path, &stat_ ) )
{
free( psz_path );
return VLC_EGENERIC;
}
stream_t *p_stream = stream_UrlNew( p_finder, psz_path );
free( psz_path );
if (! p_stream ) return VLC_EGENERIC;
xml_reader_t *p_xml_reader = xml_ReaderCreate( p_finder, p_stream );
if( !p_xml_reader )
{
stream_Delete( p_stream );
return VLC_EGENERIC;
}
if( xml_ReaderNextNode( p_xml_reader, &p_node ) != XML_READER_STARTELEM )
{
msg_Err( p_finder, "invalid catalog" );
i_ret = VLC_EGENERIC;
goto end;
}
if ( strcmp( p_node, "videolan") )
{
msg_Err( p_finder, "unsupported catalog data format" );
i_ret = VLC_EGENERIC;
goto end;
}
while( (i_current_node_type = xml_ReaderNextNode( p_xml_reader, &p_node )) > 0 )
{
switch( i_current_node_type )
{
case XML_READER_STARTELEM:
{
if ( ! strcmp( p_node, "addon" ) )
{
p_entry = addon_entry_New();
//p_entry->psz_source_module = strdup( ADDONS_MODULE_SHORTCUT );
p_entry->e_flags = ADDON_MANAGEABLE;
p_entry->e_state = ADDON_INSTALLED;
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) )
{
if ( !strcmp( attr, "type" ) )
{
p_entry->e_type = ReadType( value );
}
else if ( !strcmp( attr, "id" ) )
{
addons_uuid_read( value, & p_entry->uuid );
}
else if ( !strcmp( attr, "downloads" ) )
{
p_entry->i_downloads = atoi( value );
}
else if ( !strcmp( attr, "score" ) )
{
p_entry->i_score = atol( value );
}
else if ( !strcmp( attr, "source" ) )
{
p_entry->psz_source_module = strdup( value );
}
else if ( !strcmp( attr, "version" ) )
{
p_entry->psz_version = strdup( value );
}
}
break;
}
if ( !p_entry ) break;
BINDNODE("name", p_entry->psz_name, TYPE_STRING)
BINDNODE("archive", p_entry->psz_archive_uri, TYPE_STRING)
BINDNODE("summary", p_entry->psz_summary, TYPE_STRING)
BINDNODE("description", p_entry->psz_description, TYPE_STRING)
BINDNODE("image", p_entry->psz_image_data, TYPE_STRING)
BINDNODE("resource", psz_filename, TYPE_STRING)
BINDNODE("creator", p_entry->psz_author, TYPE_STRING)
BINDNODE("sourceurl", p_entry->psz_source_uri, TYPE_STRING)
data_pointer.e_type = TYPE_NONE;
if ( ! strcmp( p_node, "resource" ) )
{
while( (attr = xml_ReaderNextAttr( p_xml_reader, &value )) )
{
if ( !strcmp( attr, "type" ) )
{
i_filetype = ReadType( value );
}
}
}
break;
}
case XML_READER_TEXT:
if ( data_pointer.e_type == TYPE_NONE || !p_entry ) break;
if ( data_pointer.e_type == TYPE_STRING )
*data_pointer.u_data.ppsz = strdup( p_node );
else
if ( data_pointer.e_type == TYPE_LONG )
*data_pointer.u_data.pl = atol( p_node );
else
if ( data_pointer.e_type == TYPE_INTEGER )
*data_pointer.u_data.pi = atoi( p_node );
break;
case XML_READER_ENDELEM:
if ( !p_entry ) break;
if ( ! strcmp( p_node, "addon" ) )
{
/* then append entry */
ARRAY_APPEND( p_finder->entries, p_entry );
p_entry = NULL;
}
if ( ! strcmp( p_node, "resource" ) )
{
if ( p_entry && psz_filename && i_filetype >= 0 )
{
addon_file_t *p_file = malloc( sizeof(addon_file_t) );
p_file->e_filetype = i_filetype;
p_file->psz_filename = psz_filename;
p_file->psz_download_uri = NULL;
ARRAY_APPEND( p_entry->files, p_file );
}
/* reset temp */
psz_filename = NULL;
i_filetype = -1;
}
data_pointer.e_type = TYPE_NONE;
break;
default:
break;
}
}
end:
xml_ReaderDelete( p_xml_reader );
stream_Delete( p_stream );
return i_ret;
}
char *vout_snapshot_GetDirectory(void)
{
return config_GetUserDir(VLC_PICTURES_DIR);
}
static int WriteCatalog( addons_storage_t *p_storage,
addon_entry_t **pp_entries, int i_entries )
{
addon_entry_t *p_entry;
char *psz_file;
char *psz_tempstring = NULL;
char *psz_userdir = config_GetUserDir( VLC_DATA_DIR );
if ( !psz_userdir ) return VLC_ENOMEM;
if ( asprintf( &psz_file, "%s%s", psz_userdir, ADDONS_CATALOG ) < 1 )
{
free( psz_userdir );
return VLC_ENOMEM;
}
free( psz_userdir );
char *psz_path = strdup( psz_file );
if ( !psz_path )
{
free( psz_file );
return VLC_ENOMEM;
}
char *psz_buf = strrchr( psz_path, DIR_SEP_CHAR );
if( psz_buf )
{
*++psz_buf = '\0';
/* ensure directory exists */
if( !EMPTY_STR( psz_path ) ) recursive_mkdir( VLC_OBJECT(p_storage), psz_path );
free( psz_path );
}
FILE *p_catalog = vlc_fopen( psz_file, "wt" );
free( psz_file );
if ( !p_catalog )
return VLC_EGENERIC;
/* write XML header */
fprintf( p_catalog, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" );
fprintf( p_catalog, "<videolan xmlns=\"http://videolan.org/ns/vlc/addons/1.0\">\n" );
fprintf( p_catalog, "\t<addons>\n" );
for ( int i=0; i<i_entries; i++ )
{
p_entry = pp_entries[i];
vlc_mutex_lock( &p_entry->lock );
if ( ( p_entry->e_state != ADDON_INSTALLED ) ||
!( p_entry->e_flags & ADDON_MANAGEABLE ) )
{
vlc_mutex_unlock( &p_entry->lock );
continue;
}
if ( p_entry->psz_source_module )
psz_tempstring = convert_xml_special_chars( p_entry->psz_source_module );
char *psz_uuid = addons_uuid_to_psz( ( const addon_uuid_t * ) & p_entry->uuid );
fprintf( p_catalog, "\t\t<addon source=\"%s\" type=\"%s\" id=\"%s\" "
"downloads=\"%ld\" score=\"%ld\"",
( psz_tempstring ) ? psz_tempstring : "",
getTypePsz( p_entry->e_type ),
psz_uuid,
p_entry->i_downloads,
p_entry->i_score );
free( psz_uuid );
free( psz_tempstring );
WRITE_WITH_ENTITIES( " version=\"%s\">\n", p_entry->psz_version )
WRITE_WITH_ENTITIES( "\t\t\t<name>%s</name>\n", p_entry->psz_name )
WRITE_WITH_ENTITIES( "\t\t\t<summary>%s</summary>\n", p_entry->psz_summary )
if ( p_entry->psz_description )
{
psz_tempstring = p_entry->psz_description;
/* FIXME: do real escaping */
while( ( psz_tempstring = strstr( psz_tempstring, "]]>" ) ) )
*psz_tempstring = ' ';
fprintf( p_catalog, "\t\t\t<description><![CDATA[%s]]></description>\n", p_entry->psz_description );
}
WRITE_WITH_ENTITIES( "\t\t\t<image>%s</image>\n", p_entry->psz_image_data )
WRITE_WITH_ENTITIES( "\t\t\t<archive>%s</archive>\n", p_entry->psz_archive_uri )
fprintf( p_catalog, "\t\t\t<authorship>\n" );
WRITE_WITH_ENTITIES( "\t\t\t\t<creator>%s</creator>\n", p_entry->psz_author )
WRITE_WITH_ENTITIES( "\t\t\t\t<sourceurl>%s</sourceurl>\n", p_entry->psz_source_uri )
fprintf( p_catalog, "\t\t\t</authorship>\n" );
FOREACH_ARRAY( addon_file_t *p_file, p_entry->files )
psz_tempstring = convert_xml_special_chars( p_file->psz_filename );
fprintf( p_catalog, "\t\t\t<resource type=\"%s\">%s</resource>\n",
getTypePsz( p_file->e_filetype ), psz_tempstring );
free( psz_tempstring );
FOREACH_END();
fprintf( p_catalog, "\t\t</addon>\n" );
vlc_mutex_unlock( &p_entry->lock );
}
fprintf( p_catalog, "\t</addons>\n" );
fprintf( p_catalog, "</videolan>\n" );
fclose( p_catalog );
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: initialize and create stuff
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
intf_thread_t *p_intf = (intf_thread_t *)p_this;
intf_sys_t *p_sys;
char *psz_mode;
CONSOLE_INTRO_MSG;
msg_Info( p_intf, "using logger." );
/* Allocate instance and initialize some members */
p_sys = p_intf->p_sys = (intf_sys_t *)malloc( sizeof( intf_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
p_sys->msg.p_intf = p_intf;
p_sys->msg.i_mode = MODE_TEXT;
psz_mode = var_InheritString( p_intf, "logmode" );
if( psz_mode )
{
if( !strcmp( psz_mode, "text" ) )
;
else if( !strcmp( psz_mode, "html" ) )
{
p_sys->msg.i_mode = MODE_HTML;
}
#ifdef HAVE_SYSLOG_H
else if( !strcmp( psz_mode, "syslog" ) )
{
p_sys->msg.i_mode = MODE_SYSLOG;
}
#endif
else
{
msg_Warn( p_intf, "invalid log mode `%s', using `text'", psz_mode );
p_sys->msg.i_mode = MODE_TEXT;
}
free( psz_mode );
}
else
{
msg_Warn( p_intf, "no log mode specified, using `text'" );
}
if( p_sys->msg.i_mode != MODE_SYSLOG )
{
char *psz_file = var_InheritString( p_intf, "logfile" );
if( !psz_file )
{
#ifdef __APPLE__
char *home = config_GetUserDir(VLC_DOCUMENTS_DIR);
if( home == NULL
|| asprintf( &psz_file, "%s/"LOG_DIR"/%s", home,
(p_sys->msg.i_mode == MODE_HTML) ? LOG_FILE_HTML
: LOG_FILE_TEXT ) == -1 )
psz_file = NULL;
free(home);
#else
switch( p_sys->msg.i_mode )
{
case MODE_HTML:
psz_file = strdup( LOG_FILE_HTML );
break;
case MODE_TEXT:
default:
psz_file = strdup( LOG_FILE_TEXT );
break;
}
#endif
msg_Warn( p_intf, "no log filename provided, using `%s'",
psz_file );
}
/* Open the log file and remove any buffering for the stream */
msg_Dbg( p_intf, "opening logfile `%s'", psz_file );
p_sys->msg.p_file = vlc_fopen( psz_file, "at" );
if( p_sys->msg.p_file == NULL )
{
msg_Err( p_intf, "error opening logfile `%s'", psz_file );
free( p_sys );
free( psz_file );
return -1;
}
setvbuf( p_sys->msg.p_file, NULL, _IONBF, 0 );
free( psz_file );
switch( p_sys->msg.i_mode )
{
case MODE_HTML:
fputs( HTML_HEADER, p_sys->msg.p_file );
break;
case MODE_TEXT:
default:
fputs( TEXT_HEADER, p_sys->msg.p_file );
break;
}
}
else
{
p_sys->msg.p_file = NULL;
#ifdef HAVE_SYSLOG_H
int i_facility;
char *psz_facility = var_InheritString( p_intf, "syslog-facility" );
if( psz_facility )
{
bool b_valid = 0;
for( size_t i = 0; i < fac_entries; ++i )
{
if( !strcmp( psz_facility, fac_name[i] ) )
{
i_facility = fac_number[i];
b_valid = 1;
break;
}
}
if( !b_valid )
{
msg_Warn( p_intf, "invalid syslog facility `%s', using `%s'",
psz_facility, fac_name[0] );
i_facility = fac_number[0];
}
free( psz_facility );
}
else
{
msg_Warn( p_intf, "no syslog facility specified, using `%s'",
fac_name[0] );
i_facility = fac_number[0];
}
openlog( "vlc", LOG_PID|LOG_NDELAY, i_facility );
#endif
}
p_sys->p_sub = msg_Subscribe( p_intf->p_libvlc, Overflow, &p_sys->msg );
return 0;
}