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