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