#define fstat _fstati64
#endif
-/* You should otherwise use utf8_stat and utf8_lstat. */
+/* You should otherwise use vlc_stat and utf8_lstat. */
#else
struct stat;
#endif
#ifdef WIN32
# include <dirent.h>
-# define opendir Use_utf8_opendir_or_vlc_wopendir_instead!
-# define readdir Use_utf8_readdir_or_vlc_wreaddir_instead!
+# define opendir Use_vlc_opendir_or_vlc_wopendir_instead!
+# define readdir Use_vlc_readdir_or_vlc_wreaddir_instead!
# define closedir vlc_wclosedir
#endif
#include <sys/types.h>
#include <dirent.h>
-VLC_EXPORT( int, utf8_open, ( const char *filename, int flags, ... ) LIBVLC_USED );
-VLC_EXPORT( FILE *, utf8_fopen, ( const char *filename, const char *mode ) LIBVLC_USED );
+VLC_EXPORT( int, vlc_open, ( const char *filename, int flags, ... ) LIBVLC_USED );
+VLC_EXPORT( FILE *, vlc_fopen, ( const char *filename, const char *mode ) LIBVLC_USED );
-VLC_EXPORT( DIR *, utf8_opendir, ( const char *dirname ) LIBVLC_USED );
-VLC_EXPORT( char *, utf8_readdir, ( DIR *dir ) LIBVLC_USED );
-VLC_EXPORT( int, utf8_loaddir, ( DIR *dir, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) ) );
-VLC_EXPORT( int, utf8_scandir, ( const char *dirname, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) ) );
-VLC_EXPORT( int, utf8_mkdir, ( const char *filename, mode_t mode ) );
+VLC_EXPORT( DIR *, vlc_opendir, ( const char *dirname ) LIBVLC_USED );
+VLC_EXPORT( char *, vlc_readdir, ( DIR *dir ) LIBVLC_USED );
+VLC_EXPORT( int, vlc_loaddir, ( DIR *dir, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) ) );
+VLC_EXPORT( int, vlc_scandir, ( const char *dirname, char ***namelist, int (*select)( const char * ), int (*compar)( const char **, const char ** ) ) );
+VLC_EXPORT( int, vlc_mkdir, ( const char *filename, mode_t mode ) );
-VLC_EXPORT( int, utf8_unlink, ( const char *filename ) );
+VLC_EXPORT( int, vlc_unlink, ( const char *filename ) );
/* Not exported */
-int utf8_rename( const char *, const char * );
+int vlc_rename( const char *, const char * );
#if defined( WIN32 ) && !defined( UNDER_CE )
# define stat _stati64
#endif
-VLC_EXPORT( int, utf8_stat, ( const char *filename, struct stat *buf ) );
+VLC_EXPORT( int, vlc_stat, ( const char *filename, struct stat *buf ) );
VLC_EXPORT( int, utf8_lstat, ( const char *filename, struct stat *buf ) );
-VLC_EXPORT( int, utf8_mkstemp, ( char * ) );
+VLC_EXPORT( int, vlc_mkstemp, ( char * ) );
#endif
if( asprintf( &psz_tmp, "%s/%s", psz_base, ppsz_name[i] ) < 0 )
return VLC_EGENERIC;
- bool b_ok = utf8_stat( psz_tmp, &s ) == 0 && S_ISREG( s.st_mode );
+ bool b_ok = vlc_stat( psz_tmp, &s ) == 0 && S_ISREG( s.st_mode );
free( psz_tmp );
if( !b_ok )
psz_base[strlen(psz_base)-1] = '\0';
/* */
- if( utf8_stat( psz_base, &s ) || !S_ISDIR( s.st_mode ) )
+ if( vlc_stat( psz_base, &s ) || !S_ISDIR( s.st_mode ) )
goto error;
/* Check BDMV */
if( asprintf( &psz_tmp, "%s/BDMV", psz_base ) < 0 )
goto error;
- if( !utf8_stat( psz_tmp, &s ) && S_ISDIR( s.st_mode ) )
+ if( !vlc_stat( psz_tmp, &s ) && S_ISDIR( s.st_mode ) )
{
free( psz_base );
psz_base = psz_tmp;
char **ppsz_list;
- int i_list = utf8_scandir( psz_playlist, &ppsz_list, pf_filter, ScanSort );
+ int i_list = vlc_scandir( psz_playlist, &ppsz_list, pf_filter, ScanSort );
for( int i = 0; i < i_list; i++ )
{
int i_format = AFMT_S16_LE;
int result;
- p_sys->fd_audio = utf8_open( psz_device, O_RDONLY | O_NONBLOCK );
+ p_sys->fd_audio = vlc_open( psz_device, O_RDONLY | O_NONBLOCK );
if( p_sys->fd_audio < 0 )
{
msg_Err( p_demux, "Cannot open audio device (%s)", psz_device );
if( !p_access->psz_path )
return VLC_EGENERIC;
- DIR *handle = utf8_opendir (p_access->psz_path);
+ DIR *handle = vlc_opendir (p_access->psz_path);
if (handle == NULL)
return VLC_EGENERIC;
return block;
}
- char *entry = utf8_readdir (current->handle);
+ char *entry = vlc_readdir (current->handle);
if (entry == NULL)
{ /* End of directory, go back to parent */
closedir (current->handle);
}
sprintf (sub->path, "%s/%s", current->path, entry);
- DIR *handle = utf8_opendir (sub->path);
+ DIR *handle = vlc_opendir (sub->path);
if (handle != NULL)
{
sub->parent = current;
return VLC_ENOMEM;
msg_Dbg( p_access, "Opening device %s", frontend );
- if( (p_sys->i_frontend_handle = utf8_open(frontend, O_RDWR | O_NONBLOCK)) < 0 )
+ if( (p_sys->i_frontend_handle = vlc_open(frontend, O_RDWR | O_NONBLOCK)) < 0 )
{
msg_Err( p_access, "FrontEndOpen: opening device failed (%m)" );
free( p_frontend );
}
msg_Dbg( p_access, "Opening device %s", dmx );
- if( (*pi_fd = utf8_open(dmx, O_RDWR)) < 0 )
+ if( (*pi_fd = vlc_open(dmx, O_RDWR)) < 0 )
{
msg_Err( p_access, "DMXSetFilter: opening device failed (%m)" );
return VLC_EGENERIC;
}
msg_Dbg( p_access, "Opening device %s", dvr );
- if( (p_sys->i_handle = utf8_open(dvr, O_RDONLY)) < 0 )
+ if( (p_sys->i_handle = vlc_open(dvr, O_RDONLY)) < 0 )
{
msg_Err( p_access, "DVROpen: opening device failed (%m)" );
return VLC_EGENERIC;
memset( &caps, 0, sizeof( ca_caps_t ));
msg_Dbg( p_access, "Opening device %s", ca );
- if( (p_sys->i_ca_handle = utf8_open(ca, O_RDWR | O_NONBLOCK)) < 0 )
+ if( (p_sys->i_ca_handle = vlc_open(ca, O_RDWR | O_NONBLOCK)) < 0 )
{
msg_Warn( p_access, "CAMInit: opening CAM device failed (%m)" );
p_sys->i_ca_handle = 0;
return VLC_SUCCESS;
}
- if( (i_fd = utf8_open( psz_name, O_RDONLY |O_NONBLOCK )) == -1 )
+ if( (i_fd = vlc_open( psz_name, O_RDONLY |O_NONBLOCK )) == -1 )
{
return VLC_SUCCESS; /* Let dvdnav_open() do the probing */
}
else
{
msg_Dbg (p_access, "opening file `%s'", path);
- fd = utf8_open (path, O_RDONLY | O_NONBLOCK);
+ fd = vlc_open (path, O_RDONLY | O_NONBLOCK);
if (fd == -1)
{
msg_Err (p_access, "cannot open file %s (%m)", path);
STANDARD_BLOCK_ACCESS_INIT;
msg_Dbg (p_access, "opening file %s", path);
- fd = utf8_open (path, O_RDONLY | O_NOCTTY);
+ fd = vlc_open (path, O_RDONLY | O_NOCTTY);
if (fd == -1)
{
access_sys_t *p_sys = p_access->p_sys;
close ( p_sys->fd );
- if( utf8_unlink( p_access->psz_path ) != 0 )
+ if( vlc_unlink( p_access->psz_path ) != 0 )
msg_Err( p_access, "Error deleting file %s, %m", p_access->psz_path );
free( p_sys );
}
*****************************************************************************/
static int open_file( access_t *p_access, const char *path )
{
- int fd = utf8_open( path, O_RDONLY | O_NONBLOCK );
+ int fd = vlc_open( path, O_RDONLY | O_NONBLOCK );
if( fd == -1 )
{
msg_Err( p_access, "cannot open file %s (%m)", path );
int i_fd;
int i_format;
- i_fd = utf8_open( p_demux->p_sys->psz_device, O_RDONLY | O_NONBLOCK );
+ i_fd = vlc_open( p_demux->p_sys->psz_device, O_RDONLY | O_NONBLOCK );
if( i_fd < 0 )
{
static bool ProbeAudioDevOss( demux_t *p_demux, const char *psz_device )
{
int i_caps;
- int i_fd = utf8_open( psz_device, O_RDONLY | O_NONBLOCK );
+ int i_fd = vlc_open( psz_device, O_RDONLY | O_NONBLOCK );
if( i_fd < 0 )
{
free( psz_tofree );
/* open the device */
- p_sys->i_fd = utf8_open( p_sys->psz_videodev, O_RDWR );
+ p_sys->i_fd = vlc_open( p_sys->psz_videodev, O_RDWR );
if( p_sys->i_fd < 0 )
{
msg_Err( p_access, "Cannot open device %s (%m).",
if ( (p_sys->i_frequency >= pi_radio_range[0])
&& (p_sys->i_frequency <= pi_radio_range[1]) )
{
- p_sys->i_radio_fd = utf8_open( p_sys->psz_radiodev, O_RDWR );
+ p_sys->i_radio_fd = vlc_open( p_sys->psz_radiodev, O_RDWR );
if( p_sys->i_radio_fd < 0 )
{
msg_Err( p_access, "Cannot open radio device (%m)." );
# include <sys/stat.h>
# endif
# include <io.h>
-# define smbc_open(a,b,c) utf8_open(a,b,c)
+# define smbc_open(a,b,c) vlc_open(a,b,c)
# define smbc_fstat(a,b) _fstati64(a,b)
# define smbc_read read
# define smbc_lseek _lseeki64
# define v4l1_ioctl ioctl
# define v4l1_mmap mmap
# define v4l1_munmap munmap
-# define v4l1_open utf8_open
+# define v4l1_open vlc_open
#endif
/*****************************************************************************
#ifdef HAVE_LIBV4L2
static void use_kernel_v4l2( demux_sys_t *p_sys )
{
- p_sys->pf_open = utf8_open;
+ p_sys->pf_open = vlc_open;
p_sys->pf_close = close;
p_sys->pf_dup = dup;
p_sys->pf_ioctl = ioctl;
# define v4l2_mmap (p_sys->pf_mmap)
# define v4l2_munmap (p_sys->pf_munmap)
#else
-# define v4l2_open utf8_open
+# define v4l2_open vlc_open
# define v4l2_close close
# define v4l2_dup dup
# define v4l2_ioctl ioctl
}
#else
- if( utf8_stat( psz_dev, &fileinfo ) < 0 )
+ if( vlc_stat( psz_dev, &fileinfo ) < 0 )
{
free( p_vcddev );
return NULL;
i_ret = win32_vcd_open( p_this, psz_dev, p_vcddev );
#else
p_vcddev->i_device_handle = -1;
- p_vcddev->i_device_handle = utf8_open( psz_dev, O_RDONLY | O_NONBLOCK );
+ p_vcddev->i_device_handle = vlc_open( psz_dev, O_RDONLY | O_NONBLOCK );
i_ret = (p_vcddev->i_device_handle == -1) ? -1 : 0;
#endif
}
/* Open the cue file and try to parse it */
msg_Dbg( p_this,"trying .cue file: %s", psz_cuefile );
- cuefile = utf8_fopen( psz_cuefile, "rt" );
+ cuefile = vlc_fopen( psz_cuefile, "rt" );
if( cuefile == NULL )
{
msg_Dbg( p_this, "could not find .cue file" );
}
msg_Dbg( p_this,"guessing vcd image file: %s", psz_vcdfile );
- p_vcddev->i_vcdimage_handle = utf8_open( psz_vcdfile,
+ p_vcddev->i_vcdimage_handle = vlc_open( psz_vcdfile,
O_RDONLY | O_NONBLOCK | O_BINARY );
while( fgets( line, 1024, cuefile ) && !b_found )
strcpy( psz_vcdfile + (p_pos - psz_cuefile + 1), filename );
} else psz_vcdfile = strdup( filename );
msg_Dbg( p_this,"using vcd image file: %s", psz_vcdfile );
- p_vcddev->i_vcdimage_handle = utf8_open( psz_vcdfile,
+ p_vcddev->i_vcdimage_handle = vlc_open( psz_vcdfile,
O_RDONLY | O_NONBLOCK | O_BINARY );
}
b_found = true;
char *psz_tmp = str_format( p_access, p_access->psz_path );
path_sanitize( psz_tmp );
- fd = utf8_open( psz_tmp, O_RDWR | O_CREAT | O_LARGEFILE |
+ fd = vlc_open( psz_tmp, O_RDWR | O_CREAT | O_LARGEFILE |
(append ? 0 : O_TRUNC), 0666 );
free( psz_tmp );
}
if( !strcmp( psz_name, "-" ) )
p_aout->output.p_sys->p_file = stdout;
else
- p_aout->output.p_sys->p_file = utf8_fopen( psz_name, "wb" );
+ p_aout->output.p_sys->p_file = vlc_fopen( psz_name, "wb" );
free( psz_name );
if ( p_aout->output.p_sys->p_file == NULL )
* wait forever until the device is available. Since this breaks the
* OSS spec, we immediately put it back to blocking mode if the
* operation was successful. */
- p_sys->i_fd = utf8_open( psz_device, O_WRONLY | O_NDELAY );
+ p_sys->i_fd = vlc_open( psz_device, O_WRONLY | O_NDELAY );
if( p_sys->i_fd < 0 )
{
msg_Err( p_aout, "cannot open audio device (%s)", psz_device );
char **pp_data = (char **)_pp_data;
FILE *f;
- if( ( f = utf8_fopen( p_args->file, "r" ) ) == NULL )
+ if( ( f = vlc_fopen( p_args->file, "r" ) ) == NULL )
{
Callback404( p_args, pp_data, pi_data );
return VLC_SUCCESS;
char *p_data = NULL;
int i_header_size, i_data;
- if( ( f = utf8_fopen( psz_art + strlen( "file://" ), "r" ) ) == NULL )
+ if( ( f = vlc_fopen( psz_art + strlen( "file://" ), "r" ) ) == NULL )
{
msg_Dbg( p_intf, "Couldn't open album art file %s",
psz_art + strlen( "file://" ) );
psz_dir = RealPath( psz_dir );
/* parse psz_src dir */
- if( ( i_dir_content = utf8_scandir( psz_dir, &ppsz_dir_content, Filter,
+ if( ( i_dir_content = vlc_scandir( psz_dir, &ppsz_dir_content, Filter,
InsensitiveAlphasort ) ) == -1 )
{
if( errno != ENOENT && errno != ENOTDIR )
sprintf( psz_tmp, "%s"DIR_SEP"%s", psz_dir, psz_name );
#ifdef HAVE_SYS_STAT_H
- if( utf8_stat( psz_tmp, &stat_info ) == -1 )
+ if( vlc_stat( psz_tmp, &stat_info ) == -1 )
{
free( psz_name );
continue;
int i_dirlen;
- if( ( p_dir = utf8_opendir( psz_dir ) ) == NULL )
+ if( ( p_dir = vlc_opendir( psz_dir ) ) == NULL )
{
if( errno != ENOENT && errno != ENOTDIR )
msg_Err( p_intf, "cannot open directory (%s)", psz_dir );
msg_Dbg( p_intf, "dir=%s", psz_dir );
snprintf( dir, sizeof( dir ), "%s"DIR_SEP".access", psz_dir );
- if( ( file = utf8_fopen( dir, "r" ) ) != NULL )
+ if( ( file = vlc_fopen( dir, "r" ) ) != NULL )
{
char line[1024];
int i_size;
ACL_Destroy( p_acl );
struct stat st;
- if( utf8_stat( dir, &st ) == 0 )
+ if( vlc_stat( dir, &st ) == 0 )
{
free( user );
free( password );
{
char *psz_filename;
/* parse psz_src dir */
- if( ( psz_filename = utf8_readdir( p_dir ) ) == NULL )
+ if( ( psz_filename = vlc_readdir( p_dir ) ) == NULL )
{
break;
}
msg_Info( p_demux, "dumping raw stream to standard output" );
p_sys->p_file = stdout;
}
- else if( ( p_sys->p_file = utf8_fopen( p_sys->psz_file, psz_mode ) ) == NULL )
+ else if( ( p_sys->p_file = vlc_fopen( p_sys->psz_file, psz_mode ) ) == NULL )
{
msg_Err( p_demux, "cannot create `%s' for writing", p_sys->psz_file );
free( p_sys->psz_file );
}
}
- DIR *p_src_dir = utf8_opendir(s_path.c_str());
+ DIR *p_src_dir = vlc_opendir(s_path.c_str());
if (p_src_dir != NULL)
{
char *psz_file;
- while ((psz_file = utf8_readdir(p_src_dir)) != NULL)
+ while ((psz_file = vlc_readdir(p_src_dir)) != NULL)
{
if (strlen(psz_file) > 4)
{
snprintf( psz_path, PATH_MAX - 1, "%s/" DRMS_DIRNAME "/%08X.%03d",
p_drms->psz_homedir, p_drms->i_user, p_drms->i_key );
- file = utf8_fopen( psz_path, "wb" );
+ file = vlc_fopen( psz_path, "wb" );
if( file != NULL )
{
i_ret = fwrite( p_user_key, sizeof(uint32_t),
"%s/" DRMS_DIRNAME "/%08X.%03d", p_drms->psz_homedir,
p_drms->i_user, p_drms->i_key );
- file = utf8_fopen( psz_path, "rb" );
+ file = vlc_fopen( psz_path, "rb" );
if( file != NULL )
{
i_ret = fread( p_user_key, sizeof(uint32_t),
return -1;
}
- file = utf8_fopen( psz_path, "rb" );
+ file = vlc_fopen( psz_path, "rb" );
if( file != NULL )
{
struct stat st;
msg_Info( p_demux, "dumping raw stream to standard output" );
p_sys->p_file = stdout;
}
- else if( ( p_sys->p_file = utf8_fopen( p_sys->psz_file, psz_mode ) ) == NULL )
+ else if( ( p_sys->p_file = vlc_fopen( p_sys->psz_file, psz_mode ) ) == NULL )
{
msg_Err( p_demux, "cannot create `%s' for writing", p_sys->psz_file );
p_sys->b_file_out = false;
return VLC_EGENERIC;
}
- p_sys->i_fd = utf8_open( psz_device, O_RDWR );
+ p_sys->i_fd = vlc_open( psz_device, O_RDWR );
if( p_sys->i_fd == -1 )
{
msg_Err( p_intf, "cannot open %s (%m)", psz_device );
char *psz_entry;
/* Open the dir */
- p_current_dir = utf8_opendir( p_sys->psz_current_dir );
+ p_current_dir = vlc_opendir( p_sys->psz_current_dir );
if( p_current_dir == NULL )
{
p_sys->i_dir_entries = 0;
/* while we still have entries in the directory */
- while( ( psz_entry = utf8_readdir( p_current_dir ) ) != NULL )
+ while( ( psz_entry = vlc_readdir( p_current_dir ) ) != NULL )
{
#if defined( S_ISDIR )
struct stat stat_data;
}
#if defined( S_ISDIR )
- if( !utf8_stat( psz_uri, &stat_data )
+ if( !vlc_stat( psz_uri, &stat_data )
&& S_ISDIR(stat_data.st_mode) )
/*#elif defined( DT_DIR )
if( p_dir_content->d_type & DT_DIR )*/
//Before all, let's see if the file is present
struct stat p_stat;
- if( utf8_stat( path.c_str(), &p_stat ) )
+ if( vlc_stat( path.c_str(), &p_stat ) )
return false;
// First, we try to un-targz the file, and if it fails we hope it's a XML
char *pszDirContent;
// Open the dir
- pCurrDir = utf8_opendir( rootDir.c_str() );
+ pCurrDir = vlc_opendir( rootDir.c_str() );
if( pCurrDir == NULL )
{
}
// While we still have entries in the directory
- while( ( pszDirContent = utf8_readdir( pCurrDir ) ) != NULL )
+ while( ( pszDirContent = vlc_readdir( pCurrDir ) ) != NULL )
{
string newURI = rootDir + sep + pszDirContent;
#if defined( S_ISDIR )
struct stat stat_data;
- if( ( utf8_stat( newURI.c_str(), &stat_data ) == 0 )
+ if( ( vlc_stat( newURI.c_str(), &stat_data ) == 0 )
&& S_ISDIR(stat_data.st_mode) )
#elif defined( DT_DIR )
if( pDirContent->d_type & DT_DIR )
// Open the dir
// FIXME: parseDirectory should be invoked with UTF-8 input instead!!
string rDir = sFromLocale( rDir_locale );
- pDir = utf8_opendir( rDir.c_str() );
+ pDir = vlc_opendir( rDir.c_str() );
if( pDir == NULL )
{
}
// While we still have entries in the directory
- while( ( pszDirContent = utf8_readdir( pDir ) ) != NULL )
+ while( ( pszDirContent = vlc_readdir( pDir ) ) != NULL )
{
string name = pszDirContent;
string extension;
else
snprintf( psz_filename, MAX_PATH, "%s%s", psz_path, cover_files[i] );
- if( utf8_stat( psz_filename, &a ) != -1 )
+ if( vlc_stat( psz_filename, &a ) != -1 )
{
char *psz_uri = make_URI( psz_filename );
if( psz_uri )
}
if( b_force_dump )
{
- p_sys->i_fd = utf8_open( psz_file, O_WRONLY | O_CREAT | O_TRUNC, 00644 );
+ p_sys->i_fd = vlc_open( psz_file, O_WRONLY | O_CREAT | O_TRUNC, 00644 );
if( p_sys->i_fd == -1 )
{
if( *psz_dirname == '\0' )
psz_dirname = ".";
- dir = utf8_opendir( psz_dirname );
+ dir = vlc_opendir( psz_dirname );
if( dir == NULL )
{
if (errno != ENOENT)
msg_Dbg (p_this, "creating empty certificate directory: %s",
psz_dirname);
- utf8_mkdir (psz_dirname, b_priv ? 0700 : 0755);
+ vlc_mkdir (psz_dirname, b_priv ? 0700 : 0755);
return VLC_SUCCESS;
}
#ifdef S_ISLNK
for (;;)
{
- char *ent = utf8_readdir (dir);
+ char *ent = vlc_readdir (dir);
if (ent == NULL)
break;
{
struct stat st;
- int fd = utf8_open (psz_path, O_RDONLY);
+ int fd = vlc_open (psz_path, O_RDONLY);
if (fd == -1)
goto error;
{
char path[strlen (userdir) + sizeof ("/ssl/private")];
sprintf (path, "%s/ssl", userdir);
- utf8_mkdir (path, 0755);
+ vlc_mkdir (path, 0755);
sprintf (path, "%s/ssl/certs", userdir);
gnutls_Addx509Directory (VLC_OBJECT (p_session),
/* 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 = utf8_fopen( psz_file, "at" );
+ 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 );
#ifdef HAVE_SYS_STAT_H
const char *psz_path = luaL_checkstring( L, 1 );
struct stat s;
- if( utf8_stat( psz_path, &s ) )
+ if( vlc_stat( psz_path, &s ) )
return 0;
//return luaL_error( L, "Couldn't stat %s.", psz_path );
lua_newtable( L );
DIR *p_dir;
int i = 0;
- if( ( p_dir = utf8_opendir( psz_dir ) ) == NULL )
+ if( ( p_dir = vlc_opendir( psz_dir ) ) == NULL )
return luaL_error( L, "cannot open directory `%s'.", psz_dir );
lua_newtable( L );
for( ;; )
{
- char *psz_filename = utf8_readdir( p_dir );
+ char *psz_filename = vlc_readdir( p_dir );
if( !psz_filename ) break;
i++;
lua_pushstring( L, psz_filename );
int i_files;
msg_Dbg( p_this, "Trying Lua scripts in %s", *ppsz_dir );
- i_files = utf8_scandir( *ppsz_dir, &ppsz_filelist, file_select,
+ i_files = vlc_scandir( *ppsz_dir, &ppsz_filelist, file_select,
file_compare );
if( i_files < 0 )
continue;
return NULL;
}
- if( utf8_stat( psz_filename, &st ) == 0
+ if( vlc_stat( psz_filename, &st ) == 0
&& S_ISREG( st.st_mode ) )
{
vlclua_dir_list_free( ppsz_dir_list );
free( ppsz_filelist );
ppsz_filelist = NULL;
}
- i_files = utf8_scandir( *ppsz_dir, &ppsz_filelist, file_select,
+ i_files = vlc_scandir( *ppsz_dir, &ppsz_filelist, file_select,
file_compare );
if( i_files < 1 ) continue;
ppsz_fileend = ppsz_filelist + i_files;
{
goto error;
}
- FILE *fd = utf8_fopen( psz_filename, "r" );
+ FILE *fd = vlc_fopen( psz_filename, "r" );
if( fd )
{
char description[256];
if( !p_menu ) return VLC_ENOOBJ;
msg_Dbg( p_this, "opening osdmenu definition file %s", p_menu->psz_file );
- fd = utf8_fopen( p_menu->psz_file, "r" );
+ fd = vlc_fopen( p_menu->psz_file, "r" );
if( !fd )
{
msg_Err( p_this, "failed to open osdmenu definition file %s",
}
p_ih->inhibit = Inhibit;
- int fd = utf8_open ("/dev/null", O_WRONLY);
+ int fd = vlc_open ("/dev/null", O_WRONLY);
posix_spawn_file_actions_init (&p_sys->actions);
if (fd != -1)
{
else
{
/* Read the template */
- file = utf8_fopen( psz_filename, "rt" );
+ file = vlc_fopen( psz_filename, "rt" );
if( !file )
{
msg_Warn( p_this, "SVG template file %s does not exist.",
/* make sure the directory exists */
struct stat st;
if( psz_dir == NULL ||
- utf8_stat( psz_dir, &st ) ||
+ vlc_stat( psz_dir, &st ) ||
!S_ISDIR( st.st_mode ) )
continue;
if( !psz_file )
return VLC_ENOMEM;
- f = utf8_fopen( psz_file, "wb" );
+ f = vlc_fopen( psz_file, "wb" );
if( !f )
{
free( psz_file );
char *psz_newline;
char ps_buffer[256];
- p_file = utf8_fopen( psz_path, "rt" );
+ p_file = vlc_fopen( psz_path, "rt" );
if ( p_file == NULL )
{
msg_Err( p_this, "Unable to open password file '%s': %m", psz_path );
if( i_es < 0 )
{
- utf8_unlink( psz_file );
+ vlc_unlink( psz_file );
free( psz_file );
continue;
}
if( i_best_es >= p_sys->i_id )
break;
}
- utf8_unlink( psz_file );
+ vlc_unlink( psz_file );
free( psz_file );
}
if( p_sys->psz_sdp == NULL )
return VLC_EGENERIC; /* too early */
- if( ( f = utf8_fopen( p_sys->psz_sdp_file, "wt" ) ) == NULL )
+ if( ( f = vlc_fopen( p_sys->psz_sdp_file, "wt" ) ) == NULL )
{
msg_Err( p_stream, "cannot open file '%s' (%m)",
p_sys->psz_sdp_file );
picture_t *p_pic )
{
int i, j;
- FILE *p_file = utf8_fopen( psz_file, "r" );
+ FILE *p_file = vlc_fopen( psz_file, "r" );
if ( p_file == NULL )
{
vlc_mutex_lock( &p_sys->lock );
if( p_sys->i_inputfd == -1 )
{
- p_sys->i_inputfd = utf8_open( p_sys->psz_inputfile, O_RDONLY | O_NONBLOCK );
+ p_sys->i_inputfd = vlc_open( p_sys->psz_inputfile, O_RDONLY | O_NONBLOCK );
if( p_sys->i_inputfd == -1 )
{
msg_Warn( p_filter, "Failed to grab input file: %s (%m)",
if( p_sys->i_outputfd == -1 )
{
- p_sys->i_outputfd = utf8_open( p_sys->psz_outputfile,
+ p_sys->i_outputfd = vlc_open( p_sys->psz_outputfile,
O_WRONLY | O_NONBLOCK );
if( p_sys->i_outputfd == -1 )
{
return VLC_EGENERIC;
}
- sys->fd = utf8_open(psz_device, O_RDWR);
+ sys->fd = vlc_open(psz_device, O_RDWR);
if (sys->fd == -1) {
msg_Err(vd, "cannot open %s (%m)", psz_device);
free(psz_device);
return VLC_EGENERIC;
}
- p_sys->i_fd = utf8_open( psz_device, O_RDWR );
+ p_sys->i_fd = vlc_open( psz_device, O_RDWR );
if( p_sys->i_fd == -1 )
{
msg_Err( p_vout, "cannot open %s (%m)", psz_device );
p_sys->p_display = XOpenDisplay( NULL );
/* Open /dev/null and map it */
- p_sys->i_null_fd = utf8_open( "/dev/zero", O_RDWR );
+ p_sys->i_null_fd = vlc_open( "/dev/zero", O_RDWR );
if( p_sys->i_null_fd == -1 )
{
msg_Err( p_vout, "cannot open /dev/zero (%m)" );
free(sys);
return VLC_EGENERIC;
}
- sys->f = utf8_fopen(name, "wb");
+ sys->f = vlc_fopen(name, "wb");
if (!sys->f) {
msg_Err(vd, "Failed to open %s", name);
msg_Dbg( p_obj, "opening config file (%s)", psz_filename );
- FILE *p_stream = utf8_fopen( psz_filename, "rt" );
+ FILE *p_stream = vlc_fopen( psz_filename, "rt" );
if( p_stream == NULL && errno != ENOENT )
{
msg_Err( p_obj, "cannot open config file (%s): %m",
&& asprintf( &psz_old, "%s/.vlc/" CONFIG_FILE,
home ) != -1 )
{
- p_stream = utf8_fopen( psz_old, "rt" );
+ p_stream = vlc_fopen( psz_old, "rt" );
if( p_stream )
{
/* Old config file found. We want to write it at the
if( asprintf(&psz_readme,"%s/.vlc/README",
home ) != -1 )
{
- FILE *p_readme = utf8_fopen( psz_readme, "wt" );
+ FILE *p_readme = vlc_fopen( psz_readme, "wt" );
if( p_readme )
{
fprintf( p_readme, "The VLC media player "
{
if( !psz_dirname || !*psz_dirname ) return -1;
- if( utf8_mkdir( psz_dirname, 0700 ) == 0 )
+ if( vlc_mkdir( psz_dirname, 0700 ) == 0 )
return 0;
switch( errno )
*psz_end = '\0';
if( config_CreateDir( p_this, psz_parent ) == 0 )
{
- if( !utf8_mkdir( psz_dirname, 0700 ) )
+ if( !vlc_mkdir( psz_dirname, 0700 ) )
return 0;
}
}
static vlc_mutex_t lock = VLC_STATIC_MUTEX;
vlc_mutex_lock (&lock);
- int fd = utf8_open (temporary, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR);
+ int fd = vlc_open (temporary, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR);
if (fd == -1)
{
vlc_rwlock_unlock (&config_lock);
fdatasync (fd); /* Flush from OS */
#endif
/* Atomically replace the file... */
- if (utf8_rename (temporary, permanent))
- utf8_unlink (temporary);
+ if (vlc_rename (temporary, permanent))
+ vlc_unlink (temporary);
/* (...then synchronize the directory, err, TODO...) */
/* ...and finally close the file */
vlc_mutex_unlock (&lock);
fclose (file);
#ifdef WIN32
/* Windows cannot remove open files nor overwrite existing ones */
- utf8_unlink (permanent);
- if (utf8_rename (temporary, permanent))
- utf8_unlink (temporary);
+ vlc_unlink (permanent);
+ if (vlc_rename (temporary, permanent))
+ vlc_unlink (temporary);
vlc_mutex_unlock (&lock);
#endif
p_storage->i_file_size = 0;
p_storage->p_filew = GetTmpFile( &p_storage->psz_file, psz_tmp_path );
if( p_storage->psz_file )
- p_storage->p_filer = utf8_fopen( p_storage->psz_file, "rb" );
+ p_storage->p_filer = vlc_fopen( p_storage->psz_file, "rb" );
/* */
p_storage->i_cmd_w = 0;
if( p_storage->psz_file )
{
- utf8_unlink( p_storage->psz_file );
+ vlc_unlink( p_storage->psz_file );
free( p_storage->psz_file );
}
{
/* Make sure that the path exists and is a directory */
struct stat s;
- const int i_ret = utf8_stat( psz_path, &s );
+ const int i_ret = vlc_stat( psz_path, &s );
- if( i_ret < 0 && !utf8_mkdir( psz_path, 0600 ) )
+ if( i_ret < 0 && !vlc_mkdir( psz_path, 0600 ) )
return psz_path;
else if( i_ret == 0 && ( s.st_mode & S_IFDIR ) )
return psz_path;
return NULL;
/* */
- fd = utf8_mkstemp( psz_name );
+ fd = vlc_mkstemp( psz_name );
*ppsz_file = psz_name;
if( fd < 0 )
if( asprintf( &psz_file, psz_format, psz_base, i ) < 0 )
break;
- if( utf8_stat( psz_file, &st ) || !S_ISREG( st.st_mode ) || !st.st_size )
+ if( vlc_stat( psz_file, &st ) || !S_ISREG( st.st_mode ) || !st.st_size )
{
free( psz_file );
break;
strcpy( psz_extension, ".idx" );
- if( !utf8_stat( psz_path, &st ) && S_ISREG( st.st_mode ) )
+ if( !vlc_stat( psz_path, &st ) && S_ISREG( st.st_mode ) )
{
msg_Dbg( p_input, "using %s subtitles file instead of %s",
psz_path, psz_subtitle );
char *psz_file;
DIR *path;
- path = utf8_opendir( psz_path );
+ path = vlc_opendir( psz_path );
if( path )
{
closedir( path );
continue;
/* parse psz_src dir */
- i_dir_content = utf8_scandir( psz_dir, &ppsz_dir_content,
+ i_dir_content = vlc_scandir( psz_dir, &ppsz_dir_content,
subtitles_Filter, NULL );
if( i_dir_content < 0 )
continue;
if( !strcmp( psz_path, psz_fname ) )
continue;
- if( !utf8_stat( psz_path, &st ) && S_ISREG( st.st_mode ) && result )
+ if( !vlc_stat( psz_path, &st ) && S_ISREG( st.st_mode ) && result )
{
msg_Dbg( p_this,
"autodetected subtitle: %s with priority %d",
static int ExecuteSave( vlm_t *p_vlm, const char *psz_file, vlm_message_t **pp_status )
{
- FILE *f = utf8_fopen( psz_file, "wt" );
+ FILE *f = vlc_fopen( psz_file, "wt" );
char *psz_save = NULL;
if( !f )
pid_t i_pid = getpid ();
msg_Dbg( p_libvlc, "PID is %d, writing it to %s",
i_pid, psz_pidfile );
- pidfile = utf8_fopen( psz_pidfile,"w" );
+ pidfile = vlc_fopen( psz_pidfile,"w" );
if( pidfile != NULL )
{
utf8_fprintf( pidfile, "%d", (int)i_pid );
us_atof
us_strtod
us_strtof
-utf8_fopen
+vlc_fopen
utf8_fprintf
-utf8_loaddir
+vlc_loaddir
utf8_lstat
-utf8_mkdir
-utf8_mkstemp
-utf8_open
-utf8_opendir
-utf8_readdir
-utf8_scandir
-utf8_stat
-utf8_unlink
+vlc_mkdir
+vlc_mkstemp
+vlc_open
+vlc_opendir
+vlc_readdir
+vlc_scandir
+vlc_stat
+vlc_unlink
utf8_vfprintf
var_AddCallback
var_Change
p_fmt_out->i_chroma = image_Ext2Fourcc( psz_url );
}
- file = utf8_fopen( psz_url, "wb" );
+ file = vlc_fopen( psz_url, "wb" );
if( !file )
{
msg_Err( p_image->p_parent, "%s: %m", psz_url );
uint8_t key[BLOCK_SIZE];
/* Get non-predictible value as key for HMAC */
- int fd = utf8_open (randfile, O_RDONLY);
+ int fd = vlc_open (randfile, O_RDONLY);
if (fd == -1)
return; /* Uho! */
if( asprintf( &psz_destfile, "%s%s", psz_destdir, psz_tmpdestfile ) == -1 )
goto end;
- p_file = utf8_fopen( psz_destfile, "w" );
+ p_file = vlc_fopen( psz_destfile, "w" );
if( !p_file )
{
msg_Err( p_udt, "Failed to open %s for writing", psz_destfile );
}
else
{
- utf8_unlink( psz_destfile );
+ vlc_unlink( psz_destfile );
goto end;
}
if( download_signature( VLC_OBJECT( p_udt ), &sign,
p_update->release.psz_url ) != VLC_SUCCESS )
{
- utf8_unlink( psz_destfile );
+ vlc_unlink( psz_destfile );
dialog_FatalWait( p_udt, _("File could not be verified"),
_("It was not possible to download a cryptographic signature for "
if( memcmp( sign.issuer_longid, p_update->p_pkey->longid, 8 ) )
{
- utf8_unlink( psz_destfile );
+ vlc_unlink( psz_destfile );
msg_Err( p_udt, "Invalid signature issuer" );
dialog_FatalWait( p_udt, _("Invalid signature"),
_("The cryptographic signature for the downloaded file \"%s\" was "
if( sign.type != BINARY_SIGNATURE )
{
- utf8_unlink( psz_destfile );
+ vlc_unlink( psz_destfile );
msg_Err( p_udt, "Invalid signature type" );
dialog_FatalWait( p_udt, _("Invalid signature"),
_("The cryptographic signature for the downloaded file \"%s\" was "
if( !p_hash )
{
msg_Err( p_udt, "Unable to hash %s", psz_destfile );
- utf8_unlink( psz_destfile );
+ vlc_unlink( psz_destfile );
dialog_FatalWait( p_udt, _("File not verifiable"),
_("It was not possible to securely verify the downloaded file"
" \"%s\". Thus, it was deleted."),
if( p_hash[0] != sign.hash_verification[0] ||
p_hash[1] != sign.hash_verification[1] )
{
- utf8_unlink( psz_destfile );
+ vlc_unlink( psz_destfile );
dialog_FatalWait( p_udt, _("File corrupted"),
_("Downloaded file \"%s\" was corrupted. Thus, it was deleted."),
psz_destfile );
if( verify_signature( sign.r, sign.s, &p_update->p_pkey->key, p_hash )
!= VLC_SUCCESS )
{
- utf8_unlink( psz_destfile );
+ vlc_unlink( psz_destfile );
dialog_FatalWait( p_udt, _("File corrupted"),
_("Downloaded file \"%s\" was corrupted. Thus, it was deleted."),
psz_destfile );
uint8_t buffer[4096];
size_t i_read;
- FILE *f = utf8_fopen( psz_file, "r" );
+ FILE *f = vlc_fopen( psz_file, "r" );
if( !f )
return -1;
dir, CACHENAME_VALUES ) == -1 )
return;
msg_Dbg( obj, "removing plugins cache file %s", path );
- utf8_unlink( path );
+ vlc_unlink( path );
free( path );
}
msg_Dbg( p_this, "loading plugins cache file %s", psz_filename );
- file = utf8_fopen( psz_filename, "rb" );
+ file = vlc_fopen( psz_filename, "rb" );
if( !file )
{
msg_Warn( p_this, "cannot read %s (%m)",
}
msg_Dbg (p_this, "saving plugins cache %s", filename);
- FILE *file = utf8_fopen (tmpname, "wb");
+ FILE *file = vlc_fopen (tmpname, "wb");
if (file == NULL)
{
if (errno != EACCES && errno != ENOENT)
msg_Warn (p_this, "cannot write %s (%m)", tmpname);
clearerr (file);
fclose (file);
- utf8_unlink (tmpname);
+ vlc_unlink (tmpname);
goto out;
}
#ifndef WIN32
- utf8_rename (tmpname, filename); /* atomically replace old cache */
+ vlc_rename (tmpname, filename); /* atomically replace old cache */
fclose (file);
#else
- utf8_unlink (filename);
+ vlc_unlink (filename);
fclose (file);
- utf8_rename (tmpname, filename);
+ vlc_rename (tmpname, filename);
#endif
out:
free (filename);
if( i_maxdepth == 0 )
return;
- DIR *dh = utf8_opendir (psz_dir);
+ DIR *dh = vlc_opendir (psz_dir);
if (dh == NULL)
return;
/* Parse the directory and try to load all files it contains. */
for (;;)
{
- char *file = utf8_readdir (dh), *path;
+ char *file = vlc_readdir (dh), *path;
struct stat st;
if (file == NULL)
const int pathlen = asprintf (&path, "%s"DIR_SEP"%s", psz_dir, file);
free (file);
- if (pathlen == -1 || utf8_stat (path, &st))
+ if (pathlen == -1 || vlc_stat (path, &st))
continue;
if (S_ISDIR (st.st_mode))
if( p_acl == NULL )
return -1;
- file = utf8_fopen( psz_path, "r" );
+ file = vlc_fopen( psz_path, "r" );
if( file == NULL )
return -1;
if( !*psz ) break;
*psz = 0;
if( !EMPTY_STR( psz_newdir ) )
- utf8_mkdir( psz_newdir, 0700 );
+ vlc_mkdir( psz_newdir, 0700 );
*psz = DIR_SEP_CHAR;
psz++;
}
- utf8_mkdir( psz_dir, 0700 );
+ vlc_mkdir( psz_dir, 0700 );
}
static char* ArtCacheGetDirPath( const char *psz_title, const char *psz_artist,
return VLC_EGENERIC;
/* Check if file exists */
- DIR *p_dir = utf8_opendir( psz_path );
+ DIR *p_dir = vlc_opendir( psz_path );
if( !p_dir )
{
free( psz_path );
bool b_found = false;
char *psz_filename;
- while( !b_found && (psz_filename = utf8_readdir( p_dir )) )
+ while( !b_found && (psz_filename = vlc_readdir( p_dir )) )
{
if( !strncmp( psz_filename, "art", 3 ) )
{
/* Check if we already dumped it */
struct stat s;
- if( !utf8_stat( psz_filename, &s ) )
+ if( !vlc_stat( psz_filename, &s ) )
{
input_item_SetArtURL( p_item, psz_uri );
free( psz_filename );
}
/* Dump it otherwise */
- FILE *f = utf8_fopen( psz_filename, "wb" );
+ FILE *f = vlc_fopen( psz_filename, "wb" );
if( f )
{
if( fwrite( p_buffer, i_buffer, 1, f ) != 1 )
/* Prepare the playlist_export_t structure */
p_export->p_root = p_export_root;
p_export->psz_filename = psz_filename;
- p_export->p_file = utf8_fopen( psz_filename, "wt" );
+ p_export->p_file = vlc_fopen( psz_filename, "wt" );
if( p_export->p_file == NULL )
msg_Err( p_export, "could not create playlist file %s (%m)",
psz_filename );
if( asprintf( &psz_uri, "%s" DIR_SEP "ml.xspf", psz_datadir ) != -1 )
{ /* loosy check for media library file */
struct stat st;
- int ret = utf8_stat( psz_uri , &st );
+ int ret = vlc_stat( psz_uri , &st );
free( psz_uri );
if( ret )
{
#include <vlc_common.h>
#include <vlc_charset.h>
#include <vlc_fs.h>
-#include "libvlc.h" /* utf8_mkdir */
+#include "libvlc.h" /* vlc_mkdir */
#include <vlc_rand.h>
#include <assert.h>
* @note Contrary to standard open(), this function returns file handles
* with the close-on-exec flag enabled.
*/
-int utf8_open (const char *filename, int flags, ...)
+int vlc_open (const char *filename, int flags, ...)
{
unsigned int mode = 0;
va_list ap;
* @param mode fopen file open mode
* @return NULL on error, an open FILE pointer on success.
*/
-FILE *utf8_fopen (const char *filename, const char *mode)
+FILE *vlc_fopen (const char *filename, const char *mode)
{
int rwflags = 0, oflags = 0;
bool append = false;
}
}
- int fd = utf8_open (filename, rwflags | oflags, 0666);
+ int fd = vlc_open (filename, rwflags | oflags, 0666);
if (fd == -1)
return NULL;
* @param mode directory permissions
* @return 0 on success, -1 on error (see errno).
*/
-int utf8_mkdir( const char *dirname, mode_t mode )
+int vlc_mkdir( const char *dirname, mode_t mode )
{
#if defined (UNDER_CE)
(void) mode;
* @return a pointer to the DIR struct, or NULL in case of error.
* Release with standard closedir().
*/
-DIR *utf8_opendir( const char *dirname )
+DIR *vlc_opendir( const char *dirname )
{
#ifdef WIN32
CONVERT_PATH (dirname, wpath, NULL);
* @return a UTF-8 string of the directory entry.
* Use free() to free this memory.
*/
-char *utf8_readdir( DIR *dir )
+char *vlc_readdir( DIR *dir )
{
#ifdef WIN32
struct _wdirent *ent = vlc_wreaddir (dir);
}
/**
- * Does the same as utf8_scandir(), but takes an open directory pointer
+ * Does the same as vlc_scandir(), but takes an open directory pointer
* instead of a directory path.
*/
-int utf8_loaddir( DIR *dir, char ***namelist,
+int vlc_loaddir( DIR *dir, char ***namelist,
int (*select)( const char * ),
int (*compar)( const char **, const char ** ) )
{
rewinddir( dir );
- while( ( entry = utf8_readdir( dir ) ) != NULL )
+ while( ( entry = vlc_readdir( dir ) ) != NULL )
{
char **newtab;
* @return How many file names were selected (possibly 0),
* or -1 in case of error.
*/
-int utf8_scandir( const char *dirname, char ***namelist,
+int vlc_scandir( const char *dirname, char ***namelist,
int (*select)( const char * ),
int (*compar)( const char **, const char ** ) )
{
- DIR *dir = utf8_opendir (dirname);
+ DIR *dir = vlc_opendir (dirname);
int val = -1;
if (dir != NULL)
{
- val = utf8_loaddir (dir, namelist, select, compar);
+ val = vlc_loaddir (dir, namelist, select, compar);
closedir (dir);
}
return val;
}
-static int utf8_statEx( const char *filename, struct stat *buf,
+static int vlc_statEx( const char *filename, struct stat *buf,
bool deref )
{
#ifdef UNDER_CE
*
* @param filename UTF-8 file path
*/
-int utf8_stat( const char *filename, struct stat *buf)
+int vlc_stat( const char *filename, struct stat *buf)
{
- return utf8_statEx( filename, buf, true );
+ return vlc_statEx( filename, buf, true );
}
/**
*/
int utf8_lstat( const char *filename, struct stat *buf)
{
- return utf8_statEx( filename, buf, false );
+ return vlc_statEx( filename, buf, false );
}
/**
* @return A 0 return value indicates success. A -1 return value indicates an
* error, and an error code is stored in errno
*/
-int utf8_unlink( const char *filename )
+int vlc_unlink( const char *filename )
{
#ifdef UNDER_CE
/*_open translates to wchar internally on WinCE*/
* @return A 0 return value indicates success. A -1 return value indicates an
* error, and an error code is stored in errno
*/
-int utf8_rename (const char *oldpath, const char *newpath)
+int vlc_rename (const char *oldpath, const char *newpath)
{
#if defined (WIN32)
CONVERT_PATH (oldpath, wold, -1);
return ret;
}
-int utf8_mkstemp( char *template )
+int vlc_mkstemp( char *template )
{
static const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static const int i_digits = sizeof(digits)/sizeof(*digits) - 1;
psz_rand[j] = digits[pi_rand[j] % i_digits];
/* */
- int fd = utf8_open( template, O_CREAT | O_EXCL | O_RDWR, 0600 );
+ int fd = vlc_open( template, O_CREAT | O_EXCL | O_RDWR, 0600 );
if( fd >= 0 )
return fd;
if( errno != EEXIST )
{
/* */
char *filename;
- DIR *pathdir = utf8_opendir(cfg->path);
+ DIR *pathdir = vlc_opendir(cfg->path);
if (pathdir != NULL) {
/* The use specified a directory path */
closedir(pathdir);
free(prefix);
goto error;
}
- if (utf8_stat(filename, &st)) {
+ if (vlc_stat(filename, &st)) {
*sequential = num;
break;
}
goto error;
/* Save the snapshot */
- FILE *file = utf8_fopen(filename, "wb");
+ FILE *file = vlc_fopen(filename, "wb");
if (!file) {
msg_Err(object, "Failed to open '%s'", filename);
free(filename);
projects / vlc / commitdiff