git.sesse.net Git - vlc/blob - src/extras/libc.c

   1 /*****************************************************************************
   2  * libc.c: Extra libc function for some systems.
   3  *****************************************************************************
   4  * Copyright (C) 2002-2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
   8  *          Samuel Hocevar <sam@zoy.org>
   9  *          Gildas Bazin <gbazin@videolan.org>
  10  *          Derk-Jan Hartman <hartman at videolan dot org>
  11  *          Christophe Massiot <massiot@via.ecp.fr>
  12  *          Rémi Denis-Courmont <rem à videolan.org>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  27  *****************************************************************************/
  28 #include <vlc/vlc.h>
  29
  30 #include <string.h>                                              /* strdup() */
  31 #include <stdlib.h>
  32 #include <ctype.h>
  33
  34
  35 #undef iconv_t
  36 #undef iconv_open
  37 #undef iconv
  38 #undef iconv_close
  39
  40 #if defined(HAVE_ICONV)
  41 #   include <iconv.h>
  42 #endif
  43
  44 #ifdef HAVE_DIRENT_H
  45 #   include <dirent.h>
  46 #endif
  47
  48 #ifdef HAVE_FORK
  49 #   include <sys/time.h>
  50 #   include <unistd.h>
  51 #   include <errno.h>
  52 #   include <sys/wait.h>
  53 #   include <fcntl.h>
  54 #   include <sys/socket.h>
  55 #   include <sys/poll.h>
  56 #endif
  57
  58 #if defined(WIN32) || defined(UNDER_CE)
  59 #   undef _wopendir
  60 #   undef _wreaddir
  61 #   undef _wclosedir
  62 #   undef rewinddir
  63 #   undef seekdir
  64 #   undef telldir
  65 #   define WIN32_LEAN_AND_MEAN
  66 #   include <windows.h>
  67 #endif
  68
  69 #ifdef UNDER_CE
  70 #   define strcoll strcmp
  71 #endif
  72
  73 /*****************************************************************************
  74  * getenv: just in case, but it should never be called
  75  *****************************************************************************/
  76 #if !defined( HAVE_GETENV )
  77 char *vlc_getenv( const char *name )
  78 {
  79     return NULL;
  80 }
  81 #endif
  82
  83 /*****************************************************************************
  84  * strdup: returns a malloc'd copy of a string
  85  *****************************************************************************/
  86 #if !defined( HAVE_STRDUP )
  87 char *vlc_strdup( const char *string )
  88 {
  89     return strndup( string, strlen( string ) );
  90 }
  91 #endif
  92
  93 /*****************************************************************************
  94  * strndup: returns a malloc'd copy of at most n bytes of string
  95  * Does anyone know whether or not it will be present in Jaguar?
  96  *****************************************************************************/
  97 #if !defined( HAVE_STRNDUP )
  98 char *vlc_strndup( const char *string, size_t n )
  99 {
 100     char *psz;
 101     size_t len = strlen( string );
 102
 103     len = __MIN( len, n );
 104     psz = (char*)malloc( len + 1 );
 105     if( psz != NULL )
 106     {
 107         memcpy( (void*)psz, (const void*)string, len );
 108         psz[ len ] = 0;
 109     }
 110
 111     return psz;
 112 }
 113 #endif
 114
 115 /*****************************************************************************
 116  * strnlen:
 117  *****************************************************************************/
 118 #if !defined( HAVE_STRNLEN )
 119 size_t vlc_strnlen( const char *psz, size_t n )
 120 {
 121     const char *psz_end = memchr( psz, 0, n );
 122     return psz_end ? ( psz_end - psz ) : n;
 123 }
 124 #endif
 125
 126 /*****************************************************************************
 127  * strcasecmp: compare two strings ignoring case
 128  *****************************************************************************/
 129 #if !defined( HAVE_STRCASECMP ) && !defined( HAVE_STRICMP )
 130 int vlc_strcasecmp( const char *s1, const char *s2 )
 131 {
 132     int c1, c2;
 133     if( !s1 || !s2 ) return  -1;
 134
 135     while( *s1 && *s2 )
 136     {
 137         c1 = tolower(*s1);
 138         c2 = tolower(*s2);
 139
 140         if( c1 != c2 ) return (c1 < c2 ? -1 : 1);
 141         s1++; s2++;
 142     }
 143
 144     if( !*s1 && !*s2 ) return 0;
 145     else return (*s1 ? 1 : -1);
 146 }
 147 #endif
 148
 149 /*****************************************************************************
 150  * strncasecmp: compare n chars from two strings ignoring case
 151  *****************************************************************************/
 152 #if !defined( HAVE_STRNCASECMP ) && !defined( HAVE_STRNICMP )
 153 int vlc_strncasecmp( const char *s1, const char *s2, size_t n )
 154 {
 155     int c1, c2;
 156     if( !s1 || !s2 ) return  -1;
 157
 158     while( n > 0 && *s1 && *s2 )
 159     {
 160         c1 = tolower(*s1);
 161         c2 = tolower(*s2);
 162
 163         if( c1 != c2 ) return (c1 < c2 ? -1 : 1);
 164         s1++; s2++; n--;
 165     }
 166
 167     if( !n || (!*s1 && !*s2) ) return 0;
 168     else return (*s1 ? 1 : -1);
 169 }
 170 #endif
 171
 172 /******************************************************************************
 173  * strcasestr: find a substring (little) in another substring (big)
 174  * Case sensitive. Return NULL if not found, return big if little == null
 175  *****************************************************************************/
 176 #if !defined( HAVE_STRCASESTR ) && !defined( HAVE_STRISTR )
 177 char * vlc_strcasestr( const char *psz_big, const char *psz_little )
 178 {
 179     char *p_pos = (char *)psz_big;
 180
 181     if( !psz_big || !psz_little || !*psz_little ) return p_pos;
 182
 183     while( *p_pos )
 184     {
 185         if( toupper( *p_pos ) == toupper( *psz_little ) )
 186         {
 187             char * psz_cur1 = p_pos + 1;
 188             char * psz_cur2 = (char *)psz_little + 1;
 189             while( *psz_cur1 && *psz_cur2 &&
 190                    toupper( *psz_cur1 ) == toupper( *psz_cur2 ) )
 191             {
 192                 psz_cur1++;
 193                 psz_cur2++;
 194             }
 195             if( !*psz_cur2 ) return p_pos;
 196         }
 197         p_pos++;
 198     }
 199     return NULL;
 200 }
 201 #endif
 202
 203 /*****************************************************************************
 204  * vasprintf:
 205  *****************************************************************************/
 206 #if !defined(HAVE_VASPRINTF) || defined(__APPLE__) || defined(SYS_BEOS)
 207 int vlc_vasprintf(char **strp, const char *fmt, va_list ap)
 208 {
 209     /* Guess we need no more than 100 bytes. */
 210     int     i_size = 100;
 211     char    *p = malloc( i_size );
 212     int     n;
 213
 214     if( p == NULL )
 215     {
 216         *strp = NULL;
 217         return -1;
 218     }
 219
 220     for( ;; )
 221     {
 222         /* Try to print in the allocated space. */
 223         n = vsnprintf( p, i_size, fmt, ap );
 224
 225         /* If that worked, return the string. */
 226         if (n > -1 && n < i_size)
 227         {
 228             *strp = p;
 229             return strlen( p );
 230         }
 231         /* Else try again with more space. */
 232         if (n > -1)    /* glibc 2.1 */
 233         {
 234            i_size = n+1; /* precisely what is needed */
 235         }
 236         else           /* glibc 2.0 */
 237         {
 238            i_size *= 2;  /* twice the old size */
 239         }
 240         if( (p = realloc( p, i_size ) ) == NULL)
 241         {
 242             *strp = NULL;
 243             return -1;
 244         }
 245     }
 246 }
 247 #endif
 248
 249 /*****************************************************************************
 250  * asprintf:
 251  *****************************************************************************/
 252 #if !defined(HAVE_ASPRINTF) || defined(__APPLE__) || defined(SYS_BEOS)
 253 int vlc_asprintf( char **strp, const char *fmt, ... )
 254 {
 255     va_list args;
 256     int i_ret;
 257
 258     va_start( args, fmt );
 259     i_ret = vasprintf( strp, fmt, args );
 260     va_end( args );
 261
 262     return i_ret;
 263 }
 264 #endif
 265
 266 /*****************************************************************************
 267  * atof: convert a string to a double.
 268  *****************************************************************************/
 269 #if !defined( HAVE_ATOF )
 270 double vlc_atof( const char *nptr )
 271 {
 272     double f_result;
 273     wchar_t *psz_tmp = NULL;
 274     int i_len = strlen( nptr ) + 1;
 275
 276     psz_tmp = malloc( i_len * sizeof(wchar_t) );
 277     if( !psz_tmp )
 278         return NULL;
 279     MultiByteToWideChar( CP_ACP, 0, nptr, -1, psz_tmp, i_len );
 280     f_result = wcstod( psz_tmp, NULL );
 281     free( psz_tmp );
 282
 283     return f_result;
 284 }
 285 #endif
 286
 287 /*****************************************************************************
 288  * strtoll: convert a string to a 64 bits int.
 289  *****************************************************************************/
 290 #if !defined( HAVE_STRTOLL )
 291 int64_t vlc_strtoll( const char *nptr, char **endptr, int base )
 292 {
 293     int64_t i_value = 0;
 294     int sign = 1, newbase = base ? base : 10;
 295
 296     while( isspace(*nptr) ) nptr++;
 297
 298     if( *nptr == '-' )
 299     {
 300         sign = -1;
 301         nptr++;
 302     }
 303
 304     /* Try to detect base */
 305     if( *nptr == '0' )
 306     {
 307         newbase = 8;
 308         nptr++;
 309
 310         if( *nptr == 'x' )
 311         {
 312             newbase = 16;
 313             nptr++;
 314         }
 315     }
 316
 317     if( base && newbase != base )
 318     {
 319         if( endptr ) *endptr = (char *)nptr;
 320         return i_value;
 321     }
 322
 323     switch( newbase )
 324     {
 325         case 10:
 326             while( *nptr >= '0' && *nptr <= '9' )
 327             {
 328                 i_value *= 10;
 329                 i_value += ( *nptr++ - '0' );
 330             }
 331             if( endptr ) *endptr = (char *)nptr;
 332             break;
 333
 334         case 16:
 335             while( (*nptr >= '0' && *nptr <= '9') ||
 336                    (*nptr >= 'a' && *nptr <= 'f') ||
 337                    (*nptr >= 'A' && *nptr <= 'F') )
 338             {
 339                 int i_valc = 0;
 340                 if(*nptr >= '0' && *nptr <= '9') i_valc = *nptr - '0';
 341                 else if(*nptr >= 'a' && *nptr <= 'f') i_valc = *nptr - 'a' +10;
 342                 else if(*nptr >= 'A' && *nptr <= 'F') i_valc = *nptr - 'A' +10;
 343                 i_value *= 16;
 344                 i_value += i_valc;
 345                 nptr++;
 346             }
 347             if( endptr ) *endptr = (char *)nptr;
 348             break;
 349
 350         default:
 351             i_value = strtol( nptr, endptr, newbase );
 352             break;
 353     }
 354
 355     return i_value * sign;
 356 }
 357 #endif
 358
 359 /*****************************************************************************
 360  * atoll: convert a string to a 64 bits int.
 361  *****************************************************************************/
 362 #if !defined( HAVE_ATOLL )
 363 int64_t vlc_atoll( const char *nptr )
 364 {
 365     return strtoll( nptr, (char **)NULL, 10 );
 366 }
 367 #endif
 368
 369 /*****************************************************************************
 370  * lldiv: returns quotient and remainder
 371  *****************************************************************************/
 372 #if defined(SYS_BEOS) \
 373  || (defined (__FreeBSD__) && (__FreeBSD__ < 5))
 374 lldiv_t vlc_lldiv( long long numer, long long denom )
 375 {
 376     lldiv_t d;
 377     d.quot = numer / denom;
 378     d.rem  = numer % denom;
 379     return d;
 380 }
 381 #endif
 382
 383
 384 /**
 385  * Copy a string to a sized buffer. The result is always nul-terminated
 386  * (contrary to strncpy()).
 387  *
 388  * @param dest destination buffer
 389  * @param src string to be copied
 390  * @param len maximum number of characters to be copied plus one for the
 391  * terminating nul.
 392  *
 393  * @return strlen(src)
 394  */
 395 #ifndef HAVE_STRLCPY
 396 extern size_t vlc_strlcpy (char *tgt, const char *src, size_t bufsize)
 397 {
 398     size_t length;
 399
 400     for (length = 1; (length < bufsize) && *src; length++)
 401         *tgt++ = *src++;
 402
 403     if (bufsize)
 404         *tgt = '\0';
 405
 406     while (*src++)
 407         length++;
 408
 409     return length - 1;
 410 }
 411 #endif
 412
 413 /*****************************************************************************
 414  * vlc_*dir_wrapper: wrapper under Windows to return the list of drive letters
 415  * when called with an empty argument or just '\'
 416  *****************************************************************************/
 417 #if defined(WIN32) && !defined(UNDER_CE)
 418 #   include <assert.h>
 419
 420 typedef struct vlc_DIR
 421 {
 422     _WDIR *p_real_dir;
 423     int i_drives;
 424     struct _wdirent dd_dir;
 425     vlc_bool_t b_insert_back;
 426 } vlc_DIR;
 427
 428 void *vlc_wopendir( const wchar_t *wpath )
 429 {
 430     vlc_DIR *p_dir = NULL;
 431     _WDIR *p_real_dir = NULL;
 432
 433     if ( wpath == NULL || wpath[0] == '\0'
 434           || (wcscmp (wpath, L"\\") == 0) )
 435     {
 436         /* Special mode to list drive letters */
 437         p_dir = malloc( sizeof(vlc_DIR) );
 438         if( !p_dir )
 439             return NULL;
 440         p_dir->p_real_dir = NULL;
 441         p_dir->i_drives = GetLogicalDrives();
 442         return (void *)p_dir;
 443     }
 444
 445     p_real_dir = _wopendir( wpath );
 446     if ( p_real_dir == NULL )
 447         return NULL;
 448
 449     p_dir = malloc( sizeof(vlc_DIR) );
 450     if( !p_dir )
 451     {
 452         _wclosedir( p_real_dir );
 453         return NULL;
 454     }
 455     p_dir->p_real_dir = p_real_dir;
 456
 457     assert (wpath[0]); // wpath[1] is defined
 458     p_dir->b_insert_back = !wcscmp (wpath + 1, L":\\");
 459     return (void *)p_dir;
 460 }
 461
 462 struct _wdirent *vlc_wreaddir( void *_p_dir )
 463 {
 464     vlc_DIR *p_dir = (vlc_DIR *)_p_dir;
 465     unsigned int i;
 466     DWORD i_drives;
 467
 468     if ( p_dir->p_real_dir != NULL )
 469     {
 470         if ( p_dir->b_insert_back )
 471         {
 472             /* Adds "..", gruik! */
 473             p_dir->dd_dir.d_ino = 0;
 474             p_dir->dd_dir.d_reclen = 0;
 475             p_dir->dd_dir.d_namlen = 2;
 476             wcscpy( p_dir->dd_dir.d_name, L".." );
 477             p_dir->b_insert_back = VLC_FALSE;
 478             return &p_dir->dd_dir;
 479         }
 480
 481         return _wreaddir( p_dir->p_real_dir );
 482     }
 483
 484     /* Drive letters mode */
 485     i_drives = p_dir->i_drives;
 486     if ( !i_drives )
 487         return NULL; /* end */
 488
 489     for ( i = 0; i < sizeof(DWORD)*8; i++, i_drives >>= 1 )
 490         if ( i_drives & 1 ) break;
 491
 492     if ( i >= 26 )
 493         return NULL; /* this should not happen */
 494
 495     swprintf( p_dir->dd_dir.d_name, L"%c:\\", 'A' + i );
 496     p_dir->dd_dir.d_namlen = wcslen(p_dir->dd_dir.d_name);
 497     p_dir->i_drives &= ~(1UL << i);
 498     return &p_dir->dd_dir;
 499 }
 500
 501 int vlc_wclosedir( void *_p_dir )
 502 {
 503     vlc_DIR *p_dir = (vlc_DIR *)_p_dir;
 504     int i_ret = 0;
 505
 506     if ( p_dir->p_real_dir != NULL )
 507         i_ret = _wclosedir( p_dir->p_real_dir );
 508
 509     free( p_dir );
 510     return i_ret;
 511 }
 512
 513 void vlc_rewinddir( void *_p_dir )
 514 {
 515     vlc_DIR *p_dir = (vlc_DIR *)_p_dir;
 516
 517     if ( p_dir->p_real_dir != NULL )
 518         _wrewinddir( p_dir->p_real_dir );
 519 }
 520
 521 void vlc_seekdir( void *_p_dir, long loc)
 522 {
 523     vlc_DIR *p_dir = (vlc_DIR *)_p_dir;
 524
 525     if ( p_dir->p_real_dir != NULL )
 526         _wseekdir( p_dir->p_real_dir, loc );
 527 }
 528
 529 long vlc_telldir( void *_p_dir )
 530 {
 531     vlc_DIR *p_dir = (vlc_DIR *)_p_dir;
 532
 533     if ( p_dir->p_real_dir != NULL )
 534         return _wtelldir( p_dir->p_real_dir );
 535     return 0;
 536 }
 537 #endif
 538
 539 /*****************************************************************************
 540  * scandir: scan a directory alpha-sorted
 541  *****************************************************************************/
 542 #if !defined( HAVE_SCANDIR )
 543 /* FIXME: I suspect this is dead code -> utf8_scandir */
 544 #ifdef WIN32
 545 # undef opendir
 546 # undef readdir
 547 # undef closedir
 548 #endif
 549 int vlc_alphasort( const struct dirent **a, const struct dirent **b )
 550 {
 551     return strcoll( (*a)->d_name, (*b)->d_name );
 552 }
 553
 554 int vlc_scandir( const char *name, struct dirent ***namelist,
 555                     int (*filter) ( const struct dirent * ),
 556                     int (*compar) ( const struct dirent **,
 557                                     const struct dirent ** ) )
 558 {
 559     DIR            * p_dir;
 560     struct dirent  * p_content;
 561     struct dirent ** pp_list;
 562     int              ret, size;
 563
 564     if( !namelist || !( p_dir = opendir( name ) ) ) return -1;
 565
 566     ret     = 0;
 567     pp_list = NULL;
 568     while( ( p_content = readdir( p_dir ) ) )
 569     {
 570         if( filter && !filter( p_content ) )
 571         {
 572             continue;
 573         }
 574         pp_list = realloc( pp_list, ( ret + 1 ) * sizeof( struct dirent * ) );
 575         size = sizeof( struct dirent ) + strlen( p_content->d_name ) + 1;
 576         pp_list[ret] = malloc( size );
 577         if( pp_list[ret] )
 578         {
 579             memcpy( pp_list[ret], p_content, size );
 580             ret++;
 581         }
 582         else
 583         {
 584             /* Continuing is useless when no more memory can be allocted,
 585              * so better return what we have found.
 586              */
 587             ret = -1;
 588             break;
 589         }
 590     }
 591
 592     closedir( p_dir );
 593
 594     if( compar )
 595     {
 596         qsort( pp_list, ret, sizeof( struct dirent * ),
 597                (int (*)(const void *, const void *)) compar );
 598     }
 599
 600     *namelist = pp_list;
 601     return ret;
 602 }
 603 #endif
 604
 605 #if defined (WIN32) || !defined (HAVE_SHARED_LIBVLC)
 606 /*****************************************************************************
 607  * dgettext: gettext for plugins.
 608  *****************************************************************************/
 609 char *vlc_dgettext( const char *package, const char *msgid )
 610 {
 611 #if defined( ENABLE_NLS ) \
 612      && ( defined(HAVE_GETTEXT) || defined(HAVE_INCLUDED_GETTEXT) )
 613     return dgettext( package, msgid );
 614 #else
 615     return (char *)msgid;
 616 #endif
 617 }
 618 #endif
 619
 620 /*****************************************************************************
 621  * count_utf8_string: returns the number of characters in the string.
 622  *****************************************************************************/
 623 static int count_utf8_string( const char *psz_string )
 624 {
 625     int i = 0, i_count = 0;
 626     while( psz_string[ i ] != 0 )
 627     {
 628         if( ((unsigned char *)psz_string)[ i ] <  0x80UL ) i_count++;
 629         i++;
 630     }
 631     return i_count;
 632 }
 633
 634 /*****************************************************************************
 635  * wraptext: inserts \n at convenient places to wrap the text.
 636  *           Returns the modified string in a new buffer.
 637  *****************************************************************************/
 638 char *vlc_wraptext( const char *psz_text, int i_line )
 639 {
 640     int i_len;
 641     char *psz_line, *psz_new_text;
 642
 643     psz_line = psz_new_text = strdup( psz_text );
 644
 645     i_len = count_utf8_string( psz_text );
 646
 647     while( i_len > i_line )
 648     {
 649         /* Look if there is a newline somewhere. */
 650         char *psz_parser = psz_line;
 651         int i_count = 0;
 652         while( i_count <= i_line && *psz_parser != '\n' )
 653         {
 654             while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
 655             psz_parser++;
 656             i_count++;
 657         }
 658         if( *psz_parser == '\n' )
 659         {
 660             i_len -= (i_count + 1);
 661             psz_line = psz_parser + 1;
 662             continue;
 663         }
 664
 665         /* Find the furthest space. */
 666         while( psz_parser > psz_line && *psz_parser != ' ' )
 667         {
 668             while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser--;
 669             psz_parser--;
 670             i_count--;
 671         }
 672         if( *psz_parser == ' ' )
 673         {
 674             *psz_parser = '\n';
 675             i_len -= (i_count + 1);
 676             psz_line = psz_parser + 1;
 677             continue;
 678         }
 679
 680         /* Wrapping has failed. Find the first space or newline */
 681         while( i_count < i_len && *psz_parser != ' ' && *psz_parser != '\n' )
 682         {
 683             while( *((unsigned char *)psz_parser) >= 0x80UL ) psz_parser++;
 684             psz_parser++;
 685             i_count++;
 686         }
 687         if( i_count < i_len ) *psz_parser = '\n';
 688         i_len -= (i_count + 1);
 689         psz_line = psz_parser + 1;
 690     }
 691
 692     return psz_new_text;
 693 }
 694
 695 /*****************************************************************************
 696  * iconv wrapper
 697  *****************************************************************************/
 698 vlc_iconv_t vlc_iconv_open( const char *tocode, const char *fromcode )
 699 {
 700 #if defined(HAVE_ICONV)
 701     return iconv_open( tocode, fromcode );
 702 #else
 703     return NULL;
 704 #endif
 705 }
 706
 707 size_t vlc_iconv( vlc_iconv_t cd, const char **inbuf, size_t *inbytesleft,
 708                   char **outbuf, size_t *outbytesleft )
 709 {
 710 #if defined(HAVE_ICONV)
 711     return iconv( cd, (ICONV_CONST char **)inbuf, inbytesleft,
 712                   outbuf, outbytesleft );
 713 #else
 714     int i_bytes;
 715
 716     if (inbytesleft == NULL || outbytesleft == NULL)
 717     {
 718         return 0;
 719     }
 720
 721     i_bytes = __MIN(*inbytesleft, *outbytesleft);
 722     if( !inbuf || !outbuf || !i_bytes ) return (size_t)(-1);
 723     memcpy( *outbuf, *inbuf, i_bytes );
 724     inbuf += i_bytes;
 725     outbuf += i_bytes;
 726     inbytesleft -= i_bytes;
 727     outbytesleft -= i_bytes;
 728     return i_bytes;
 729 #endif
 730 }
 731
 732 int vlc_iconv_close( vlc_iconv_t cd )
 733 {
 734 #if defined(HAVE_ICONV)
 735     return iconv_close( cd );
 736 #else
 737     return 0;
 738 #endif
 739 }
 740
 741 /*****************************************************************************
 742  * reduce a fraction
 743  *   (adapted from libavcodec, author Michael Niedermayer <michaelni@gmx.at>)
 744  *****************************************************************************/
 745 vlc_bool_t vlc_ureduce( unsigned *pi_dst_nom, unsigned *pi_dst_den,
 746                         uint64_t i_nom, uint64_t i_den, uint64_t i_max )
 747 {
 748     vlc_bool_t b_exact = 1;
 749     uint64_t i_gcd;
 750
 751     if( i_den == 0 )
 752     {
 753         *pi_dst_nom = 0;
 754         *pi_dst_den = 1;
 755         return 1;
 756     }
 757
 758     i_gcd = GCD( i_nom, i_den );
 759     i_nom /= i_gcd;
 760     i_den /= i_gcd;
 761
 762     if( i_max == 0 ) i_max = I64C(0xFFFFFFFF);
 763
 764     if( i_nom > i_max || i_den > i_max )
 765     {
 766         uint64_t i_a0_num = 0, i_a0_den = 1, i_a1_num = 1, i_a1_den = 0;
 767         b_exact = 0;
 768
 769         for( ; ; )
 770         {
 771             uint64_t i_x = i_nom / i_den;
 772             uint64_t i_a2n = i_x * i_a1_num + i_a0_num;
 773             uint64_t i_a2d = i_x * i_a1_den + i_a0_den;
 774
 775             if( i_a2n > i_max || i_a2d > i_max ) break;
 776
 777             i_nom %= i_den;
 778
 779             i_a0_num = i_a1_num; i_a0_den = i_a1_den;
 780             i_a1_num = i_a2n; i_a1_den = i_a2d;
 781             if( i_nom == 0 ) break;
 782             i_x = i_nom; i_nom = i_den; i_den = i_x;
 783         }
 784         i_nom = i_a1_num;
 785         i_den = i_a1_den;
 786     }
 787
 788     *pi_dst_nom = i_nom;
 789     *pi_dst_den = i_den;
 790
 791     return b_exact;
 792 }
 793
 794 /*************************************************************************
 795  * vlc_parse_cmdline: Command line parsing into elements.
 796  *
 797  * The command line is composed of space/tab separated arguments.
 798  * Quotes can be used as argument delimiters and a backslash can be used to
 799  * escape a quote.
 800  *************************************************************************/
 801 static void find_end_quote( char **s, char **ppsz_parser, int i_quote )
 802 {
 803     int i_bcount = 0;
 804
 805     while( **s )
 806     {
 807         if( **s == '\\' )
 808         {
 809             **ppsz_parser = **s;
 810             (*ppsz_parser)++; (*s)++;
 811             i_bcount++;
 812         }
 813         else if( **s == '"' || **s == '\'' )
 814         {
 815             /* Preceeded by a number of '\' which we erase. */
 816             *ppsz_parser -= i_bcount / 2;
 817             if( i_bcount & 1 )
 818             {
 819                 /* '\\' followed by a '"' or '\'' */
 820                 *ppsz_parser -= 1;
 821                 **ppsz_parser = **s;
 822                 (*ppsz_parser)++; (*s)++;
 823                 i_bcount = 0;
 824                 continue;
 825             }
 826
 827             if( **s == i_quote )
 828             {
 829                 /* End */
 830                 return;
 831             }
 832             else
 833             {
 834                 /* Different quoting */
 835                 int i_quote = **s;
 836                 **ppsz_parser = **s;
 837                 (*ppsz_parser)++; (*s)++;
 838                 find_end_quote( s, ppsz_parser, i_quote );
 839                 **ppsz_parser = **s;
 840                 (*ppsz_parser)++; (*s)++;
 841             }
 842
 843             i_bcount = 0;
 844         }
 845         else
 846         {
 847             /* A regular character */
 848             **ppsz_parser = **s;
 849             (*ppsz_parser)++; (*s)++;
 850             i_bcount = 0;
 851         }
 852     }
 853 }
 854
 855 char **vlc_parse_cmdline( const char *psz_cmdline, int *i_args )
 856 {
 857     int argc = 0;
 858     char **argv = 0;
 859     char *s, *psz_parser, *psz_arg, *psz_orig;
 860     int i_bcount = 0;
 861
 862     if( !psz_cmdline ) return 0;
 863     psz_orig = strdup( psz_cmdline );
 864     psz_arg = psz_parser = s = psz_orig;
 865
 866     while( *s )
 867     {
 868         if( *s == '\t' || *s == ' ' )
 869         {
 870             /* We have a complete argument */
 871             *psz_parser = 0;
 872             TAB_APPEND( argc, argv, strdup(psz_arg) );
 873
 874             /* Skip trailing spaces/tabs */
 875             do{ s++; } while( *s == '\t' || *s == ' ' );
 876
 877             /* New argument */
 878             psz_arg = psz_parser = s;
 879             i_bcount = 0;
 880         }
 881         else if( *s == '\\' )
 882         {
 883             *psz_parser++ = *s++;
 884             i_bcount++;
 885         }
 886         else if( *s == '"' || *s == '\'' )
 887         {
 888             if( ( i_bcount & 1 ) == 0 )
 889             {
 890                 /* Preceeded by an even number of '\', this is half that
 891                  * number of '\', plus a quote which we erase. */
 892                 int i_quote = *s;
 893                 psz_parser -= i_bcount / 2;
 894                 s++;
 895                 find_end_quote( &s, &psz_parser, i_quote );
 896                 s++;
 897             }
 898             else
 899             {
 900                 /* Preceeded by an odd number of '\', this is half that
 901                  * number of '\' followed by a '"' */
 902                 psz_parser = psz_parser - i_bcount/2 - 1;
 903                 *psz_parser++ = '"';
 904                 s++;
 905             }
 906             i_bcount = 0;
 907         }
 908         else
 909         {
 910             /* A regular character */
 911             *psz_parser++ = *s++;
 912             i_bcount = 0;
 913         }
 914     }
 915
 916     /* Take care of the last arg */
 917     if( *psz_arg )
 918     {
 919         *psz_parser = '\0';
 920         TAB_APPEND( argc, argv, strdup(psz_arg) );
 921     }
 922
 923     if( i_args ) *i_args = argc;
 924     free( psz_orig );
 925     return argv;
 926 }
 927
 928 /*************************************************************************
 929  * vlc_execve: Execute an external program with a given environment,
 930  * wait until it finishes and return its standard output
 931  *************************************************************************/
 932 int __vlc_execve( vlc_object_t *p_object, int i_argc, char *const *ppsz_argv,
 933                   char *const *ppsz_env, const char *psz_cwd,
 934                   const char *p_in, size_t i_in,
 935                   char **pp_data, size_t *pi_data )
 936 {
 937     (void)i_argc; // <-- hmph
 938 #ifdef HAVE_FORK
 939 # define BUFSIZE 1024
 940     int fds[2], i_status;
 941
 942     if (socketpair (AF_LOCAL, SOCK_STREAM, 0, fds))
 943         return -1;
 944
 945     pid_t pid = -1;
 946     if ((fds[0] > 2) && (fds[1] > 2))
 947         pid = fork ();
 948
 949     switch (pid)
 950     {
 951         case -1:
 952             msg_Err (p_object, "unable to fork (%s)", strerror (errno));
 953             close (fds[0]);
 954             close (fds[1]);
 955             return -1;
 956
 957         case 0:
 958             /* NOTE:
 959              * Like it or not, close can fail (and not only with EBADF)
 960              */
 961             if ((close (0) == 0) && (close (1) == 0) && (close (2) == 0)
 962              && (dup (fds[1]) == 0) && (dup (fds[1]) == 1)
 963              && (open ("/dev/null", O_RDONLY) == 2)
 964              && ((psz_cwd == NULL) || (chdir (psz_cwd) == 0)))
 965                 execve (ppsz_argv[0], ppsz_argv, ppsz_env);
 966
 967             exit (1);
 968     }
 969
 970     close (fds[1]);
 971
 972     *pi_data = 0;
 973     if (*pp_data)
 974         free (*pp_data);
 975     *pp_data = NULL;
 976
 977     if (i_in == 0)
 978         shutdown (fds[0], SHUT_WR);
 979
 980     while (!p_object->b_die)
 981     {
 982         struct pollfd ufd[1];
 983         memset (ufd, 0, sizeof (ufd));
 984         ufd[0].fd = fds[0];
 985         ufd[0].events = POLLIN;
 986
 987         if (i_in > 0)
 988             ufd[0].events |= POLLOUT;
 989
 990         if (poll (ufd, 1, 10) <= 0)
 991             continue;
 992
 993         if (ufd[0].revents & ~POLLOUT)
 994         {
 995             char *ptr = realloc (*pp_data, *pi_data + BUFSIZE + 1);
 996             if (ptr == NULL)
 997                 break; /* safely abort */
 998
 999             *pp_data = ptr;
1000
1001             ssize_t val = read (fds[0], ptr + *pi_data, BUFSIZE);
1002             switch (val)
1003             {
1004                 case -1:
1005                 case 0:
1006                     shutdown (fds[0], SHUT_RD);
1007                     break;
1008
1009                 default:
1010                     *pi_data += val;
1011             }
1012         }
1013
1014         if (ufd[0].revents & POLLOUT)
1015         {
1016             ssize_t val = write (fds[0], p_in, i_in);
1017             switch (val)
1018             {
1019                 case -1:
1020                 case 0:
1021                     i_in = 0;
1022                     shutdown (fds[0], SHUT_WR);
1023                     break;
1024
1025                 default:
1026                     i_in -= val;
1027                     p_in += val;
1028             }
1029         }
1030     }
1031
1032     close (fds[0]);
1033
1034     while (waitpid (pid, &i_status, 0) == -1);
1035
1036     if (WIFEXITED (i_status))
1037     {
1038         i_status = WEXITSTATUS (i_status);
1039         if (i_status)
1040             msg_Warn (p_object,  "child %s (PID %d) exited with error code %d",
1041                       ppsz_argv[0], (int)pid, i_status);
1042     }
1043     else
1044     if (WIFSIGNALED (i_status)) // <-- this should be redumdant a check
1045     {
1046         i_status = WTERMSIG (i_status);
1047         msg_Warn (p_object, "child %s (PID %d) exited on signal %d (%s)",
1048                   ppsz_argv[0], (int)pid, i_status, strsignal (i_status));
1049     }
1050
1051 #elif defined( WIN32 ) && !defined( UNDER_CE )
1052     SECURITY_ATTRIBUTES saAttr;
1053     PROCESS_INFORMATION piProcInfo;
1054     STARTUPINFO siStartInfo;
1055     BOOL bFuncRetn = FALSE;
1056     HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr;
1057     DWORD i_status;
1058     char *psz_cmd = NULL, *p_env = NULL, *p = NULL;
1059     char **ppsz_parser;
1060     int i_size;
1061
1062     /* Set the bInheritHandle flag so pipe handles are inherited. */
1063     saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
1064     saAttr.bInheritHandle = TRUE;
1065     saAttr.lpSecurityDescriptor = NULL;
1066
1067     /* Create a pipe for the child process's STDOUT. */
1068     if ( !CreatePipe( &hChildStdoutRd, &hChildStdoutWr, &saAttr, 0 ) )
1069     {
1070         msg_Err( p_object, "stdout pipe creation failed" );
1071         return -1;
1072     }
1073
1074     /* Ensure the read handle to the pipe for STDOUT is not inherited. */
1075     SetHandleInformation( hChildStdoutRd, HANDLE_FLAG_INHERIT, 0 );
1076
1077     /* Create a pipe for the child process's STDIN. */
1078     if ( !CreatePipe( &hChildStdinRd, &hChildStdinWr, &saAttr, 0 ) )
1079     {
1080         msg_Err( p_object, "stdin pipe creation failed" );
1081         return -1;
1082     }
1083
1084     /* Ensure the write handle to the pipe for STDIN is not inherited. */
1085     SetHandleInformation( hChildStdinWr, HANDLE_FLAG_INHERIT, 0 );
1086
1087     /* Set up members of the PROCESS_INFORMATION structure. */
1088     ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
1089
1090     /* Set up members of the STARTUPINFO structure. */
1091     ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
1092     siStartInfo.cb = sizeof(STARTUPINFO);
1093     siStartInfo.hStdError = hChildStdoutWr;
1094     siStartInfo.hStdOutput = hChildStdoutWr;
1095     siStartInfo.hStdInput = hChildStdinRd;
1096     siStartInfo.wShowWindow = SW_HIDE;
1097     siStartInfo.dwFlags |= STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
1098
1099     /* Set up the command line. */
1100     psz_cmd = malloc(32768);
1101     if( !psz_cmd )
1102         return -1;
1103     psz_cmd[0] = '\0';
1104     i_size = 32768;
1105     ppsz_parser = &ppsz_argv[0];
1106     while ( ppsz_parser[0] != NULL && i_size > 0 )
1107     {
1108         /* Protect the last argument with quotes ; the other arguments
1109          * are supposed to be already protected because they have been
1110          * passed as a command-line option. */
1111         if ( ppsz_parser[1] == NULL )
1112         {
1113             strncat( psz_cmd, "\"", i_size );
1114             i_size--;
1115         }
1116         strncat( psz_cmd, *ppsz_parser, i_size );
1117         i_size -= strlen( *ppsz_parser );
1118         if ( ppsz_parser[1] == NULL )
1119         {
1120             strncat( psz_cmd, "\"", i_size );
1121             i_size--;
1122         }
1123         strncat( psz_cmd, " ", i_size );
1124         i_size--;
1125         ppsz_parser++;
1126     }
1127
1128     /* Set up the environment. */
1129     p = p_env = malloc(32768);
1130     if( !p )
1131     {
1132         free( psz_cmd );
1133         return -1;
1134     }
1135
1136     i_size = 32768;
1137     ppsz_parser = &ppsz_env[0];
1138     while ( *ppsz_parser != NULL && i_size > 0 )
1139     {
1140         memcpy( p, *ppsz_parser,
1141                 __MIN((int)(strlen(*ppsz_parser) + 1), i_size) );
1142         p += strlen(*ppsz_parser) + 1;
1143         i_size -= strlen(*ppsz_parser) + 1;
1144         ppsz_parser++;
1145     }
1146     *p = '\0';
1147
1148     /* Create the child process. */
1149     bFuncRetn = CreateProcess( NULL,
1150           psz_cmd,       // command line
1151           NULL,          // process security attributes
1152           NULL,          // primary thread security attributes
1153           TRUE,          // handles are inherited
1154           0,             // creation flags
1155           p_env,
1156           psz_cwd,
1157           &siStartInfo,  // STARTUPINFO pointer
1158           &piProcInfo ); // receives PROCESS_INFORMATION
1159
1160     free( psz_cmd );
1161     free( p_env );
1162
1163     if ( bFuncRetn == 0 )
1164     {
1165         msg_Err( p_object, "child creation failed" );
1166         return -1;
1167     }
1168
1169     /* Read from a file and write its contents to a pipe. */
1170     while ( i_in > 0 && !p_object->b_die )
1171     {
1172         DWORD i_written;
1173         if ( !WriteFile( hChildStdinWr, p_in, i_in, &i_written, NULL ) )
1174             break;
1175         i_in -= i_written;
1176         p_in += i_written;
1177     }
1178
1179     /* Close the pipe handle so the child process stops reading. */
1180     CloseHandle(hChildStdinWr);
1181
1182     /* Close the write end of the pipe before reading from the
1183      * read end of the pipe. */
1184     CloseHandle(hChildStdoutWr);
1185
1186     /* Read output from the child process. */
1187     *pi_data = 0;
1188     if( *pp_data )
1189         free( pp_data );
1190     *pp_data = NULL;
1191     *pp_data = malloc( 1025 );  /* +1 for \0 */
1192
1193     while ( !p_object->b_die )
1194     {
1195         DWORD i_read;
1196         if ( !ReadFile( hChildStdoutRd, &(*pp_data)[*pi_data], 1024, &i_read,
1197                         NULL )
1198               || i_read == 0 )
1199             break;
1200         *pi_data += i_read;
1201         *pp_data = realloc( *pp_data, *pi_data + 1025 );
1202     }
1203
1204     while ( !p_object->b_die
1205              && !GetExitCodeProcess( piProcInfo.hProcess, &i_status )
1206              && i_status != STILL_ACTIVE )
1207         msleep( 10000 );
1208
1209     CloseHandle(piProcInfo.hProcess);
1210     CloseHandle(piProcInfo.hThread);
1211
1212     if ( i_status )
1213         msg_Warn( p_object,
1214                   "child %s returned with error code %ld",
1215                   ppsz_argv[0], i_status );
1216
1217 #else
1218     msg_Err( p_object, "vlc_execve called but no implementation is available" );
1219     return -1;
1220
1221 #endif
1222
1223     if (*pp_data == NULL)
1224         return -1;
1225
1226     (*pp_data)[*pi_data] = '\0';
1227     return 0;
1228 }