]> git.sesse.net Git - vlc/blobdiff - src/extras/libc.c
Clean up vlc_iconv prototype
[vlc] / src / extras / libc.c
index 09a57d2e1501de836666899a75bc51900b88134d..01a180b2aef295695ed853db5e10618c91b40cbc 100644 (file)
@@ -7,6 +7,8 @@
  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
  *          Samuel Hocevar <sam@zoy.org>
  *          Gildas Bazin <gbazin@videolan.org>
+ *          Derk-Jan Hartman <hartman at videolan dot org>
+ *          Christophe Massiot <massiot@via.ecp.fr>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,7 +22,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 #include <string.h>                                              /* strdup() */
 #include <stdlib.h>
 #   include <iconv.h>
 #endif
 
+#ifdef HAVE_DIRENT_H
+#   include <dirent.h>
+#endif
+
+#ifdef HAVE_FORK
+#   include <sys/time.h>
+#   include <unistd.h>
+#   include <errno.h>
+#   include <sys/wait.h>
+#endif
+
+#if defined(WIN32) || defined(UNDER_CE)
+#   define WIN32_LEAN_AND_MEAN
+#   include <windows.h>
+#endif
+
+#ifdef UNDER_CE
+#   define strcoll strcmp
+#endif
+
 /*****************************************************************************
  * getenv: just in case, but it should never be called
  *****************************************************************************/
@@ -160,7 +182,7 @@ char * vlc_strcasestr( const char *psz_big, const char *psz_little )
 /*****************************************************************************
  * vasprintf:
  *****************************************************************************/
-#if !defined(HAVE_VASPRINTF) || defined(SYS_DARWIN) || defined(SYS_BEOS)
+#if !defined(HAVE_VASPRINTF) || defined(__APPLE__) || defined(SYS_BEOS)
 int vlc_vasprintf(char **strp, const char *fmt, va_list ap)
 {
     /* Guess we need no more than 100 bytes. */
@@ -206,7 +228,7 @@ int vlc_vasprintf(char **strp, const char *fmt, va_list ap)
 /*****************************************************************************
  * asprintf:
  *****************************************************************************/
-#if !defined(HAVE_ASPRINTF) || defined(SYS_DARWIN) || defined(SYS_BEOS)
+#if !defined(HAVE_ASPRINTF) || defined(__APPLE__) || defined(SYS_BEOS)
 int vlc_asprintf( char **strp, const char *fmt, ... )
 {
     va_list args;
@@ -321,6 +343,175 @@ int64_t vlc_atoll( const char *nptr )
 }
 #endif
 
+/*****************************************************************************
+ * lldiv: returns quotient and remainder
+ *****************************************************************************/
+#if defined(SYS_BEOS)
+lldiv_t vlc_lldiv( long long numer, long long denom )
+{
+    lldiv_t d;
+    d.quot = numer / denom;
+    d.rem  = numer % denom;
+    return d;
+}
+#endif
+
+/*****************************************************************************
+ * vlc_*dir_wrapper: wrapper under Windows to return the list of drive letters
+ * when called with an empty argument or just '\'
+ *****************************************************************************/
+#if defined(WIN32) && !defined(UNDER_CE)
+typedef struct vlc_DIR
+{
+    DIR *p_real_dir;
+    int i_drives;
+    struct dirent dd_dir;
+    vlc_bool_t b_insert_back;
+} vlc_DIR;
+
+void *vlc_opendir_wrapper( const char *psz_path )
+{
+    vlc_DIR *p_dir;
+    DIR *p_real_dir;
+
+    if ( psz_path == NULL || psz_path[0] == '\0'
+          || (psz_path[0] == '\\' && psz_path[1] == '\0') )
+    {
+        /* Special mode to list drive letters */
+        p_dir = malloc( sizeof(vlc_DIR) );
+        p_dir->p_real_dir = NULL;
+        p_dir->i_drives = GetLogicalDrives();
+        return (void *)p_dir;
+    }
+
+    p_real_dir = opendir( psz_path );
+    if ( p_real_dir == NULL )
+        return NULL;
+
+    p_dir = malloc( sizeof(vlc_DIR) );
+    p_dir->p_real_dir = p_real_dir;
+    p_dir->b_insert_back = ( psz_path[1] == ':' && psz_path[2] == '\\'
+                              && psz_path[3] =='\0' );
+    return (void *)p_dir;
+}
+
+struct dirent *vlc_readdir_wrapper( void *_p_dir )
+{
+    vlc_DIR *p_dir = (vlc_DIR *)_p_dir;
+    unsigned int i;
+    DWORD i_drives;
+
+    if ( p_dir->p_real_dir != NULL )
+    {
+        if ( p_dir->b_insert_back )
+        {
+            p_dir->dd_dir.d_ino = 0;
+            p_dir->dd_dir.d_reclen = 0;
+            p_dir->dd_dir.d_namlen = 2;
+            strcpy( p_dir->dd_dir.d_name, ".." );
+            p_dir->b_insert_back = VLC_FALSE;
+            return &p_dir->dd_dir;
+        }
+
+        return readdir( p_dir->p_real_dir );
+    }
+
+    /* Drive letters mode */
+    i_drives = p_dir->i_drives;
+    if ( !i_drives )
+        return NULL; /* end */
+
+    for ( i = 0; i < sizeof(DWORD)*8; i++, i_drives >>= 1 )
+        if ( i_drives & 1 ) break;
+
+    if ( i >= 26 )
+        return NULL; /* this should not happen */
+
+    sprintf( p_dir->dd_dir.d_name, "%c:\\", 'A' + i );
+    p_dir->dd_dir.d_namlen = strlen(p_dir->dd_dir.d_name);
+    p_dir->i_drives &= ~(1UL << i);
+    return &p_dir->dd_dir;
+}
+
+int vlc_closedir_wrapper( void *_p_dir )
+{
+    vlc_DIR *p_dir = (vlc_DIR *)_p_dir;
+
+    if ( p_dir->p_real_dir != NULL )
+    {
+        int i_ret = closedir( p_dir->p_real_dir );
+        free( p_dir );
+        return i_ret;
+    }
+
+    free( p_dir );
+    return 0;
+}
+#else
+void *vlc_opendir_wrapper( const char *psz_path )
+{
+    return (void *)opendir( psz_path );
+}
+struct dirent *vlc_readdir_wrapper( void *_p_dir )
+{
+    return readdir( (DIR *)_p_dir );
+}
+int vlc_closedir_wrapper( void *_p_dir )
+{
+    return closedir( (DIR *)_p_dir );
+}
+#endif
+
+/*****************************************************************************
+ * scandir: scan a directory alpha-sorted
+ *****************************************************************************/
+#if !defined( HAVE_SCANDIR )
+int vlc_alphasort( const struct dirent **a, const struct dirent **b )
+{
+    return strcoll( (*a)->d_name, (*b)->d_name );
+}
+
+int vlc_scandir( const char *name, struct dirent ***namelist,
+                    int (*filter) ( const struct dirent * ),
+                    int (*compar) ( const struct dirent **,
+                                    const struct dirent ** ) )
+{
+    DIR            * p_dir;
+    struct dirent  * p_content;
+    struct dirent ** pp_list;
+    int              ret, size;
+
+    if( !namelist || !( p_dir = vlc_opendir_wrapper( name ) ) ) return -1;
+
+    ret     = 0;
+    pp_list = NULL;
+    while( ( p_content = vlc_readdir_wrapper( p_dir ) ) )
+    {
+        if( filter && !filter( p_content ) )
+        {
+            continue;
+        }
+        pp_list = realloc( pp_list, ( ret + 1 ) * sizeof( struct dirent * ) );
+        size = sizeof( struct dirent ) + strlen( p_content->d_name ) + 1;
+        pp_list[ret] = malloc( size );
+        memcpy( pp_list[ret], p_content, size );
+        ret++;
+    }
+
+    vlc_closedir_wrapper( p_dir );
+
+    if( compar )
+    {
+        qsort( pp_list, ret, sizeof( struct dirent * ),
+               (int (*)(const void *, const void *)) compar );
+    }
+
+    *namelist = pp_list;
+    return ret;
+}
+#endif
+
+#if defined (WIN32) || !defined (HAVE_SHARED_LIBVLC)
 /*****************************************************************************
  * dgettext: gettext for plugins.
  *****************************************************************************/
@@ -333,6 +524,7 @@ char *vlc_dgettext( const char *package, const char *msgid )
     return (char *)msgid;
 #endif
 }
+#endif
 
 /*****************************************************************************
  * count_utf8_string: returns the number of characters in the string.
@@ -352,17 +544,14 @@ static int count_utf8_string( const char *psz_string )
  * wraptext: inserts \n at convenient places to wrap the text.
  *           Returns the modified string in a new buffer.
  *****************************************************************************/
-char *vlc_wraptext( const char *psz_text, int i_line, vlc_bool_t b_utf8 )
+char *vlc_wraptext( const char *psz_text, int i_line )
 {
     int i_len;
     char *psz_line, *psz_new_text;
 
     psz_line = psz_new_text = strdup( psz_text );
 
-    if( b_utf8 )
-        i_len = count_utf8_string( psz_text );
-    else
-        i_len = strlen( psz_text );
+    i_len = count_utf8_string( psz_text );
 
     while( i_len > i_line )
     {
@@ -371,10 +560,7 @@ char *vlc_wraptext( const char *psz_text, int i_line, vlc_bool_t b_utf8 )
         int i_count = 0;
         while( i_count <= i_line && *psz_parser != '\n' )
         {
-            if( b_utf8 )
-            {
-                while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
-            }
+            while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
             psz_parser++;
             i_count++;
         }
@@ -388,10 +574,7 @@ char *vlc_wraptext( const char *psz_text, int i_line, vlc_bool_t b_utf8 )
         /* Find the furthest space. */
         while( psz_parser > psz_line && *psz_parser != ' ' )
         {
-            if( b_utf8 )
-            {
-                while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser--;
-            }
+            while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser--;
             psz_parser--;
             i_count--;
         }
@@ -406,10 +589,7 @@ char *vlc_wraptext( const char *psz_text, int i_line, vlc_bool_t b_utf8 )
         /* Wrapping has failed. Find the first space or newline */
         while( i_count < i_len && *psz_parser != ' ' && *psz_parser != '\n' )
         {
-            if( b_utf8 )
-            {
-                while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
-            }
+            while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
             psz_parser++;
             i_count++;
         }
@@ -433,13 +613,21 @@ vlc_iconv_t vlc_iconv_open( const char *tocode, const char *fromcode )
 #endif
 }
 
-size_t vlc_iconv( vlc_iconv_t cd, char **inbuf, size_t *inbytesleft,
+size_t vlc_iconv( vlc_iconv_t cd, const char **inbuf, size_t *inbytesleft,
                   char **outbuf, size_t *outbytesleft )
 {
 #if defined(HAVE_ICONV)
-    return iconv( cd, inbuf, inbytesleft, outbuf, outbytesleft );
+    return iconv( cd, (ICONV_CONST char **)inbuf, inbytesleft,
+                  outbuf, outbytesleft );
 #else
-    int i_bytes = __MIN(*inbytesleft, *outbytesleft);
+    int i_bytes;
+
+    if (inbytesleft == NULL || outbytesleft == NULL)
+    {
+        return 0;
+    }
+
+    i_bytes = __MIN(*inbytesleft, *outbytesleft);
     if( !inbuf || !outbuf || !i_bytes ) return (size_t)(-1);
     memcpy( *outbuf, *inbuf, i_bytes );
     inbuf += i_bytes;
@@ -463,8 +651,8 @@ int vlc_iconv_close( vlc_iconv_t cd )
  * reduce a fraction
  *   (adapted from libavcodec, author Michael Niedermayer <michaelni@gmx.at>)
  *****************************************************************************/
-vlc_bool_t vlc_reduce( unsigned *pi_dst_nom, unsigned *pi_dst_den,
-                       uint64_t i_nom, uint64_t i_den, uint64_t i_max )
+vlc_bool_t vlc_ureduce( unsigned *pi_dst_nom, unsigned *pi_dst_den,
+                        uint64_t i_nom, uint64_t i_den, uint64_t i_max )
 {
     vlc_bool_t b_exact = 1;
     uint64_t i_gcd;
@@ -645,3 +833,292 @@ char **vlc_parse_cmdline( const char *psz_cmdline, int *i_args )
     free( psz_orig );
     return argv;
 }
+
+/*************************************************************************
+ * vlc_execve: Execute an external program with a given environment,
+ * wait until it finishes and return its standard output
+ *************************************************************************/
+int __vlc_execve( vlc_object_t *p_object, int i_argc, char **ppsz_argv,
+                  char **ppsz_env, char *psz_cwd, char *p_in, int i_in,
+                  char **pp_data, int *pi_data )
+{
+#ifdef HAVE_FORK
+    int pi_stdin[2];
+    int pi_stdout[2];
+    pid_t i_child_pid;
+
+    pipe( pi_stdin );
+    pipe( pi_stdout );
+
+    if ( (i_child_pid = fork()) == -1 )
+    {
+        msg_Err( p_object, "unable to fork (%s)", strerror(errno) );
+        return -1;
+    }
+
+    if ( i_child_pid == 0 )
+    {
+        close(0);
+        dup(pi_stdin[1]);
+        close(pi_stdin[0]);
+
+        close(1);
+        dup(pi_stdout[1]);
+        close(pi_stdout[0]);
+
+        close(2);
+
+        if ( psz_cwd != NULL )
+            chdir( psz_cwd );
+        execve( ppsz_argv[0], ppsz_argv, ppsz_env );
+        exit(1);
+    }
+
+    close(pi_stdin[1]);
+    close(pi_stdout[1]);
+    if ( !i_in )
+        close( pi_stdin[0] );
+
+    *pi_data = 0;
+    *pp_data = malloc( 1025 );  /* +1 for \0 */
+
+    while ( !p_object->b_die )
+    {
+        int i_ret, i_status;
+        fd_set readfds, writefds;
+        struct timeval tv;
+
+        FD_ZERO( &readfds );
+        FD_ZERO( &writefds );
+        FD_SET( pi_stdout[0], &readfds );
+        if ( i_in )
+            FD_SET( pi_stdin[0], &writefds );
+
+        tv.tv_sec = 0;
+        tv.tv_usec = 10000;
+        
+        i_ret = select( pi_stdin[0] > pi_stdout[0] ? pi_stdin[0] + 1 :
+                        pi_stdout[0] + 1, &readfds, &writefds, NULL, &tv );
+        if ( i_ret > 0 )
+        {
+            if ( FD_ISSET( pi_stdout[0], &readfds ) )
+            {
+                ssize_t i_read = read( pi_stdout[0], &(*pp_data)[*pi_data],
+                                       1024 );
+                if ( i_read > 0 )
+                {
+                    *pi_data += i_read;
+                    *pp_data = realloc( *pp_data, *pi_data + 1025 );
+                }
+            }
+            if ( FD_ISSET( pi_stdin[0], &writefds ) )
+            {
+                ssize_t i_write = write( pi_stdin[0], p_in, __MIN(i_in, 1024) );
+
+                if ( i_write > 0 )
+                {
+                    p_in += i_write;
+                    i_in -= i_write;
+                }
+                if ( !i_in )
+                    close( pi_stdin[0] );
+            }
+        }
+
+        if ( waitpid( i_child_pid, &i_status, WNOHANG ) == i_child_pid )
+        {
+            if ( WIFEXITED( i_status ) )
+            {
+                if ( WEXITSTATUS( i_status ) )
+                {
+                    msg_Warn( p_object,
+                              "child %s returned with error code %d",
+                              ppsz_argv[0], WEXITSTATUS( i_status ) );
+                }
+            }
+            else
+            {
+                if ( WIFSIGNALED( i_status ) )
+                {
+                    msg_Warn( p_object,
+                              "child %s quit on signal %d", ppsz_argv[0],
+                              WTERMSIG( i_status ) );
+                }
+            }
+            if ( i_in )
+                close( pi_stdin[0] );
+            close( pi_stdout[0] );
+            break;
+        }
+
+        if ( i_ret < 0 && errno != EINTR )
+        {
+            msg_Warn( p_object, "select failed (%s)", strerror(errno) );
+        }
+    }
+
+#elif defined( WIN32 ) && !defined( UNDER_CE )
+    SECURITY_ATTRIBUTES saAttr; 
+    PROCESS_INFORMATION piProcInfo; 
+    STARTUPINFO siStartInfo;
+    BOOL bFuncRetn = FALSE; 
+    HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr;
+    DWORD i_status;
+    char *psz_cmd, *p_env, *p;
+    char **ppsz_parser;
+    int i_size;
+
+    /* Set the bInheritHandle flag so pipe handles are inherited. */
+    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
+    saAttr.bInheritHandle = TRUE; 
+    saAttr.lpSecurityDescriptor = NULL; 
+
+    /* Create a pipe for the child process's STDOUT. */
+    if ( !CreatePipe( &hChildStdoutRd, &hChildStdoutWr, &saAttr, 0 ) ) 
+    {
+        msg_Err( p_object, "stdout pipe creation failed" ); 
+        return -1;
+    }
+
+    /* Ensure the read handle to the pipe for STDOUT is not inherited. */
+    SetHandleInformation( hChildStdoutRd, HANDLE_FLAG_INHERIT, 0 );
+
+    /* Create a pipe for the child process's STDIN. */
+    if ( !CreatePipe( &hChildStdinRd, &hChildStdinWr, &saAttr, 0 ) ) 
+    {
+        msg_Err( p_object, "stdin pipe creation failed" ); 
+        return -1;
+    }
+
+    /* Ensure the write handle to the pipe for STDIN is not inherited. */
+    SetHandleInformation( hChildStdinWr, HANDLE_FLAG_INHERIT, 0 );
+
+    /* Set up members of the PROCESS_INFORMATION structure. */
+    ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
+    /* Set up members of the STARTUPINFO structure. */
+    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
+    siStartInfo.cb = sizeof(STARTUPINFO); 
+    siStartInfo.hStdError = hChildStdoutWr;
+    siStartInfo.hStdOutput = hChildStdoutWr;
+    siStartInfo.hStdInput = hChildStdinRd;
+    siStartInfo.wShowWindow = SW_HIDE;
+    siStartInfo.dwFlags |= STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
+
+    /* Set up the command line. */
+    psz_cmd = malloc(32768);
+    psz_cmd[0] = '\0';
+    i_size = 32768;
+    ppsz_parser = &ppsz_argv[0];
+    while ( ppsz_parser[0] != NULL && i_size > 0 )
+    {
+        /* Protect the last argument with quotes ; the other arguments
+         * are supposed to be already protected because they have been
+         * passed as a command-line option. */
+        if ( ppsz_parser[1] == NULL )
+        {
+            strncat( psz_cmd, "\"", i_size );
+            i_size--;
+        }
+        strncat( psz_cmd, *ppsz_parser, i_size );
+        i_size -= strlen( *ppsz_parser );
+        if ( ppsz_parser[1] == NULL )
+        {
+            strncat( psz_cmd, "\"", i_size );
+            i_size--;
+        }
+        strncat( psz_cmd, " ", i_size );
+        i_size--;
+        ppsz_parser++;
+    }
+
+    /* Set up the environment. */
+    p = p_env = malloc(32768);
+    i_size = 32768;
+    ppsz_parser = &ppsz_env[0];
+    while ( *ppsz_parser != NULL && i_size > 0 )
+    {
+        memcpy( p, *ppsz_parser,
+                __MIN((int)(strlen(*ppsz_parser) + 1), i_size) );
+        p += strlen(*ppsz_parser) + 1;
+        i_size -= strlen(*ppsz_parser) + 1;
+        ppsz_parser++;
+    }
+    *p = '\0';
+    /* Create the child process. */
+    bFuncRetn = CreateProcess( NULL,
+          psz_cmd,       // command line 
+          NULL,          // process security attributes 
+          NULL,          // primary thread security attributes 
+          TRUE,          // handles are inherited 
+          0,             // creation flags 
+          p_env,
+          psz_cwd,
+          &siStartInfo,  // STARTUPINFO pointer 
+          &piProcInfo ); // receives PROCESS_INFORMATION 
+
+    free( psz_cmd );
+    free( p_env );
+   
+    if ( bFuncRetn == 0 ) 
+    {
+        msg_Err( p_object, "child creation failed" ); 
+        return -1;
+    }
+
+    /* Read from a file and write its contents to a pipe. */
+    while ( i_in > 0 && !p_object->b_die )
+    {
+        DWORD i_written;
+        if ( !WriteFile( hChildStdinWr, p_in, i_in, &i_written, NULL ) )
+            break;
+        i_in -= i_written;
+        p_in += i_written;
+    }
+
+    /* Close the pipe handle so the child process stops reading. */
+    CloseHandle(hChildStdinWr);
+
+    /* Close the write end of the pipe before reading from the
+     * read end of the pipe. */
+    CloseHandle(hChildStdoutWr);
+    /* Read output from the child process. */
+    *pi_data = 0;
+    *pp_data = malloc( 1025 );  /* +1 for \0 */
+
+    while ( !p_object->b_die )
+    {
+        DWORD i_read;
+        if ( !ReadFile( hChildStdoutRd, &(*pp_data)[*pi_data], 1024, &i_read, 
+                        NULL )
+              || i_read == 0 )
+            break; 
+        *pi_data += i_read;
+        *pp_data = realloc( *pp_data, *pi_data + 1025 );
+    }
+
+    while ( !p_object->b_die
+             && !GetExitCodeProcess( piProcInfo.hProcess, &i_status )
+             && i_status != STILL_ACTIVE )
+        msleep( 10000 );
+
+    CloseHandle(piProcInfo.hProcess);
+    CloseHandle(piProcInfo.hThread);
+
+    if ( i_status )
+        msg_Warn( p_object,
+                  "child %s returned with error code %ld",
+                  ppsz_argv[0], i_status );
+
+#else
+    msg_Err( p_object, "vlc_execve called but no implementation is available" );
+    return -1;
+
+#endif
+
+    (*pp_data)[*pi_data] = '\0';
+
+    return 0;
+}