convert_xml_special_chars: factor
[vlc.git] / src / text / strings.c
1 /*****************************************************************************
2  * strings.c: String related functions
3  *****************************************************************************
4  * Copyright (C) 2006 the VideoLAN team
5  * Copyright (C) 2008-2009 Rémi Denis-Courmont
6  * $Id$
7  *
8  * Authors: Antoine Cellerier <dionoea at videolan dot org>
9  *          Daniel Stranger <vlc at schmaller dot de>
10  *          Rémi Denis-Courmont <rem # videolan org>
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 2 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <vlc_common.h>
35 #include <assert.h>
36
37 /* Needed by str_format_time */
38 #include <time.h>
39 #include <limits.h>
40
41 /* Needed by str_format_meta */
42 #include <vlc_input.h>
43 #include <vlc_meta.h>
44 #include <vlc_playlist.h>
45 #include <vlc_aout.h>
46
47 #include <vlc_strings.h>
48 #include <vlc_url.h>
49 #include <vlc_charset.h>
50
51 /**
52  * Decode encoded URI component. See also decode_URI().
53  * \return decoded duplicated string
54  */
55 char *decode_URI_duplicate( const char *psz )
56 {
57     char *psz_dup = strdup( psz );
58     decode_URI( psz_dup );
59     return psz_dup;
60 }
61
62 /**
63  * Decode an encoded URI component in place.
64  * <b>This function does NOT decode entire URIs.</b>
65  * It decodes components (e.g. host name, directory, file name).
66  * Decoded URIs do not exist in the real world (see RFC3986 §2.4).
67  * Complete URIs are always "encoded" (or they are syntaxically invalid).
68  *
69  * Note that URI encoding is different from Javascript escaping. Especially,
70  * white spaces and Unicode non-ASCII code points are encoded differently.
71  *
72  * \return psz on success, NULL if it was not properly encoded
73  */
74 char *decode_URI( char *psz )
75 {
76     unsigned char *in = (unsigned char *)psz, *out = in, c;
77
78     if( psz == NULL )
79         return NULL;
80
81     while( ( c = *in++ ) != '\0' )
82     {
83         switch( c )
84         {
85             case '%':
86             {
87                 char hex[3];
88
89                 if( ( ( hex[0] = *in++ ) == 0 )
90                  || ( ( hex[1] = *in++ ) == 0 ) )
91                     return NULL;
92
93                 hex[2] = '\0';
94                 *out++ = (unsigned char)strtoul( hex, NULL, 0x10 );
95                 break;
96             }
97
98             case '+': /* This is HTTP forms, not URI decoding... */
99                 *out++ = ' ';
100                 break;
101
102             default:
103                 /* Inserting non-ASCII or non-printable characters is unsafe,
104                  * and no sane browser will send these unencoded */
105                 if( ( c < 32 ) || ( c > 127 ) )
106                     *out++ = '?';
107                 else
108                     *out++ = c;
109         }
110     }
111     *out = '\0';
112     EnsureUTF8( psz );
113     return psz;
114 }
115
116 static inline bool isurisafe( int c )
117 {
118     /* These are the _unreserved_ URI characters (RFC3986 §2.3) */
119     return ( (unsigned char)( c - 'a' ) < 26 )
120             || ( (unsigned char)( c - 'A' ) < 26 )
121             || ( (unsigned char)( c - '0' ) < 10 )
122             || ( strchr( "-._~", c ) != NULL );
123 }
124
125 static char *encode_URI_bytes (const char *psz_uri, size_t len)
126 {
127     char *psz_enc = malloc (3 * len + 1), *out = psz_enc;
128     if (psz_enc == NULL)
129         return NULL;
130
131     for (size_t i = 0; i < len; i++)
132     {
133         static const char hex[16] = "0123456789ABCDEF";
134         uint8_t c = *psz_uri;
135
136         if( isurisafe( c ) )
137             *out++ = c;
138         /* This is URI encoding, not HTTP forms:
139          * Space is encoded as '%20', not '+'. */
140         else
141         {
142             *out++ = '%';
143             *out++ = hex[c >> 4];
144             *out++ = hex[c & 0xf];
145         }
146         psz_uri++;
147     }
148     *out++ = '\0';
149
150     out = realloc (psz_enc, out - psz_enc);
151     return out ? out : psz_enc; /* realloc() can fail (safe) */
152 }
153
154 /**
155  * Encodes an URI component (RFC3986 §2).
156  *
157  * @param psz_uri nul-terminated UTF-8 representation of the component.
158  * Obviously, you can't pass an URI containing a nul character, but you don't
159  * want to do that, do you?
160  *
161  * @return encoded string (must be free()'d), or NULL for ENOMEM.
162  */
163 char *encode_URI_component( const char *psz_uri )
164 {
165     return encode_URI_bytes (psz_uri, strlen (psz_uri));
166 }
167
168
169 static const struct xml_entity_s
170 {
171     char    psz_entity[8];
172     char    psz_char[4];
173 } xml_entities[] = {
174     /* Important: this list has to be in alphabetical order (psz_entity-wise) */
175     { "AElig;",  "Æ" },
176     { "Aacute;", "Á" },
177     { "Acirc;",  "Â" },
178     { "Agrave;", "À" },
179     { "Aring;",  "Å" },
180     { "Atilde;", "Ã" },
181     { "Auml;",   "Ä" },
182     { "Ccedil;", "Ç" },
183     { "Dagger;", "‡" },
184     { "ETH;",    "Ð" },
185     { "Eacute;", "É" },
186     { "Ecirc;",  "Ê" },
187     { "Egrave;", "È" },
188     { "Euml;",   "Ë" },
189     { "Iacute;", "Í" },
190     { "Icirc;",  "Î" },
191     { "Igrave;", "Ì" },
192     { "Iuml;",   "Ï" },
193     { "Ntilde;", "Ñ" },
194     { "OElig;",  "Œ" },
195     { "Oacute;", "Ó" },
196     { "Ocirc;",  "Ô" },
197     { "Ograve;", "Ò" },
198     { "Oslash;", "Ø" },
199     { "Otilde;", "Õ" },
200     { "Ouml;",   "Ö" },
201     { "Scaron;", "Š" },
202     { "THORN;",  "Þ" },
203     { "Uacute;", "Ú" },
204     { "Ucirc;",  "Û" },
205     { "Ugrave;", "Ù" },
206     { "Uuml;",   "Ü" },
207     { "Yacute;", "Ý" },
208     { "Yuml;",   "Ÿ" },
209     { "aacute;", "á" },
210     { "acirc;",  "â" },
211     { "acute;",  "´" },
212     { "aelig;",  "æ" },
213     { "agrave;", "à" },
214     { "amp;",    "&" },
215     { "apos;",   "'" },
216     { "aring;",  "å" },
217     { "atilde;", "ã" },
218     { "auml;",   "ä" },
219     { "bdquo;",  "„" },
220     { "brvbar;", "¦" },
221     { "ccedil;", "ç" },
222     { "cedil;",  "¸" },
223     { "cent;",   "¢" },
224     { "circ;",   "ˆ" },
225     { "copy;",   "©" },
226     { "curren;", "¤" },
227     { "dagger;", "†" },
228     { "deg;",    "°" },
229     { "divide;", "÷" },
230     { "eacute;", "é" },
231     { "ecirc;",  "ê" },
232     { "egrave;", "è" },
233     { "eth;",    "ð" },
234     { "euml;",   "ë" },
235     { "euro;",   "€" },
236     { "frac12;", "½" },
237     { "frac14;", "¼" },
238     { "frac34;", "¾" },
239     { "gt;",     ">" },
240     { "hellip;", "…" },
241     { "iacute;", "í" },
242     { "icirc;",  "î" },
243     { "iexcl;",  "¡" },
244     { "igrave;", "ì" },
245     { "iquest;", "¿" },
246     { "iuml;",   "ï" },
247     { "laquo;",  "«" },
248     { "ldquo;",  "“" },
249     { "lsaquo;", "‹" },
250     { "lsquo;",  "‘" },
251     { "lt;",     "<" },
252     { "macr;",   "¯" },
253     { "mdash;",  "—" },
254     { "micro;",  "µ" },
255     { "middot;", "·" },
256     { "nbsp;",   "\xc2\xa0" },
257     { "ndash;",  "–" },
258     { "not;",    "¬" },
259     { "ntilde;", "ñ" },
260     { "oacute;", "ó" },
261     { "ocirc;",  "ô" },
262     { "oelig;",  "œ" },
263     { "ograve;", "ò" },
264     { "ordf;",   "ª" },
265     { "ordm;",   "º" },
266     { "oslash;", "ø" },
267     { "otilde;", "õ" },
268     { "ouml;",   "ö" },
269     { "para;",   "¶" },
270     { "permil;", "‰" },
271     { "plusmn;", "±" },
272     { "pound;",  "£" },
273     { "quot;",   "\"" },
274     { "raquo;",  "»" },
275     { "rdquo;",  "”" },
276     { "reg;",    "®" },
277     { "rsaquo;", "›" },
278     { "rsquo;",  "’" },
279     { "sbquo;",  "‚" },
280     { "scaron;", "š" },
281     { "sect;",   "§" },
282     { "shy;",    "­" },
283     { "sup1;",   "¹" },
284     { "sup2;",   "²" },
285     { "sup3;",   "³" },
286     { "szlig;",  "ß" },
287     { "thorn;",  "þ" },
288     { "tilde;",  "˜" },
289     { "times;",  "×" },
290     { "trade;",  "™" },
291     { "uacute;", "ú" },
292     { "ucirc;",  "û" },
293     { "ugrave;", "ù" },
294     { "uml;",    "¨" },
295     { "uuml;",   "ü" },
296     { "yacute;", "ý" },
297     { "yen;",    "¥" },
298     { "yuml;",   "ÿ" },
299 };
300
301 static int cmp_entity (const void *key, const void *elem)
302 {
303     const struct xml_entity_s *ent = elem;
304     const char *name = key;
305
306     return strncmp (name, ent->psz_entity, strlen (ent->psz_entity));
307 }
308
309 /**
310  * Converts "&lt;", "&gt;" and "&amp;" to "<", ">" and "&"
311  * \param string to convert
312  */
313 void resolve_xml_special_chars( char *psz_value )
314 {
315     char *p_pos = psz_value;
316
317     while ( *psz_value )
318     {
319         if( *psz_value == '&' )
320         {
321             if( psz_value[1] == '#' )
322             {   /* &#xxx; Unicode code point */
323                 char *psz_end;
324                 unsigned long cp = strtoul( psz_value+2, &psz_end, 10 );
325                 if( *psz_end == ';' )
326                 {
327                     psz_value = psz_end + 1;
328                     if( cp == 0 )
329                         (void)0; /* skip nuls */
330                     else
331                     if( cp <= 0x7F )
332                     {
333                         *p_pos =            cp;
334                     }
335                     else
336                     /* Unicode code point outside ASCII.
337                      * &#xxx; representation is longer than UTF-8 :) */
338                     if( cp <= 0x7FF )
339                     {
340                         *p_pos++ = 0xC0 |  (cp >>  6);
341                         *p_pos   = 0x80 |  (cp        & 0x3F);
342                     }
343                     else
344                     if( cp <= 0xFFFF )
345                     {
346                         *p_pos++ = 0xE0 |  (cp >> 12);
347                         *p_pos++ = 0x80 | ((cp >>  6) & 0x3F);
348                         *p_pos   = 0x80 |  (cp        & 0x3F);
349                     }
350                     else
351                     if( cp <= 0x1FFFFF ) /* Outside the BMP */
352                     {   /* Unicode stops at 10FFFF, but who cares? */
353                         *p_pos++ = 0xF0 |  (cp >> 18);
354                         *p_pos++ = 0x80 | ((cp >> 12) & 0x3F);
355                         *p_pos++ = 0x80 | ((cp >>  6) & 0x3F);
356                         *p_pos   = 0x80 |  (cp        & 0x3F);
357                     }
358                 }
359                 else
360                 {
361                     /* Invalid entity number */
362                     *p_pos = *psz_value;
363                     psz_value++;
364                 }
365             }
366             else
367             {   /* Well-known XML entity */
368                 const struct xml_entity_s *ent;
369
370                 ent = bsearch (psz_value + 1, xml_entities,
371                                sizeof (xml_entities) / sizeof (*ent),
372                                sizeof (*ent), cmp_entity);
373                 if (ent != NULL)
374                 {
375                     size_t olen = strlen (ent->psz_char);
376                     memcpy (p_pos, ent->psz_char, olen);
377                     p_pos += olen - 1;
378                     psz_value += strlen (ent->psz_entity) + 1;
379                 }
380                 else
381                 {   /* No match */
382                     *p_pos = *psz_value;
383                     psz_value++;
384                 }
385             }
386         }
387         else
388         {
389             *p_pos = *psz_value;
390             psz_value++;
391         }
392
393         p_pos++;
394     }
395
396     *p_pos = '\0';
397 }
398
399 /**
400  * Converts '<', '>', '\"', '\'' and '&' to their html entities
401  * \param psz_content simple element content that is to be converted
402  */
403 char *convert_xml_special_chars( const char *psz_content )
404 {
405     assert( psz_content );
406
407     const size_t len = strlen( psz_content );
408     char *const psz_temp = malloc( 6 * len + 1 );
409     char *p_to   = psz_temp;
410
411     if( psz_temp == NULL )
412         return NULL;
413     for( size_t i = 0; i < len; i++ )
414     {
415         const char *str;
416         char c = psz_content[i];
417
418         switch ( c )
419         {
420             case '\"': str = "quot"; break;
421             case '&':  str = "amp";  break;
422             case '\'': str = "#39";  break;
423             case '<':  str = "lt";   break;
424             case '>':  str = "gt";   break;
425             default:
426                 *(p_to++) = c;
427                 continue;
428         }
429         p_to += sprintf( p_to, "&%s;", str );
430     }
431     *(p_to++) = '\0';
432
433     p_to = realloc( psz_temp, p_to - psz_temp );
434     return p_to ? p_to : psz_temp; /* cannot fail */
435 }
436
437 /* Base64 encoding */
438 char *vlc_b64_encode_binary( const uint8_t *src, size_t i_src )
439 {
440     static const char b64[] =
441            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
442
443     char *ret = malloc( ( i_src + 4 ) * 4 / 3 );
444     char *dst = ret;
445
446     if( dst == NULL )
447         return NULL;
448
449     while( i_src > 0 )
450     {
451         /* pops (up to) 3 bytes of input, push 4 bytes */
452         uint32_t v;
453
454         /* 1/3 -> 1/4 */
455         v = *src++ << 24;
456         *dst++ = b64[v >> 26];
457         v = v << 6;
458
459         /* 2/3 -> 2/4 */
460         if( i_src >= 2 )
461             v |= *src++ << 22;
462         *dst++ = b64[v >> 26];
463         v = v << 6;
464
465         /* 3/3 -> 3/4 */
466         if( i_src >= 3 )
467             v |= *src++ << 20; // 3/3
468         *dst++ = ( i_src >= 2 ) ? b64[v >> 26] : '='; // 3/4
469         v = v << 6;
470
471         /* -> 4/4 */
472         *dst++ = ( i_src >= 3 ) ? b64[v >> 26] : '='; // 4/4
473
474         if( i_src <= 3 )
475             break;
476         i_src -= 3;
477     }
478
479     *dst = '\0';
480
481     return ret;
482 }
483
484 char *vlc_b64_encode( const char *src )
485 {
486     if( src )
487         return vlc_b64_encode_binary( (const uint8_t*)src, strlen(src) );
488     else
489         return vlc_b64_encode_binary( (const uint8_t*)"", 0 );
490 }
491
492 /* Base64 decoding */
493 size_t vlc_b64_decode_binary_to_buffer( uint8_t *p_dst, size_t i_dst, const char *p_src )
494 {
495     static const int b64[256] = {
496         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 00-0F */
497         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 10-1F */
498         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,  /* 20-2F */
499         52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,  /* 30-3F */
500         -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,  /* 40-4F */
501         15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,  /* 50-5F */
502         -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,  /* 60-6F */
503         41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,  /* 70-7F */
504         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 80-8F */
505         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* 90-9F */
506         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* A0-AF */
507         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* B0-BF */
508         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* C0-CF */
509         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* D0-DF */
510         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,  /* E0-EF */
511         -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1   /* F0-FF */
512     };
513     uint8_t *p_start = p_dst;
514     uint8_t *p = (uint8_t *)p_src;
515
516     int i_level;
517     int i_last;
518
519     for( i_level = 0, i_last = 0; (size_t)( p_dst - p_start ) < i_dst && *p != '\0'; p++ )
520     {
521         const int c = b64[(unsigned int)*p];
522         if( c == -1 )
523             continue;
524
525         switch( i_level )
526         {
527             case 0:
528                 i_level++;
529                 break;
530             case 1:
531                 *p_dst++ = ( i_last << 2 ) | ( ( c >> 4)&0x03 );
532                 i_level++;
533                 break;
534             case 2:
535                 *p_dst++ = ( ( i_last << 4 )&0xf0 ) | ( ( c >> 2 )&0x0f );
536                 i_level++;
537                 break;
538             case 3:
539                 *p_dst++ = ( ( i_last &0x03 ) << 6 ) | c;
540                 i_level = 0;
541         }
542         i_last = c;
543     }
544
545     return p_dst - p_start;
546 }
547 size_t vlc_b64_decode_binary( uint8_t **pp_dst, const char *psz_src )
548 {
549     const int i_src = strlen( psz_src );
550     uint8_t   *p_dst;
551
552     *pp_dst = p_dst = malloc( i_src );
553     if( !p_dst )
554         return 0;
555     return  vlc_b64_decode_binary_to_buffer( p_dst, i_src, psz_src );
556 }
557 char *vlc_b64_decode( const char *psz_src )
558 {
559     const int i_src = strlen( psz_src );
560     char *p_dst = malloc( i_src + 1 );
561     size_t i_dst;
562     if( !p_dst )
563         return NULL;
564
565     i_dst = vlc_b64_decode_binary_to_buffer( (uint8_t*)p_dst, i_src, psz_src );
566     p_dst[i_dst] = '\0';
567
568     return p_dst;
569 }
570
571 /**
572  * Formats current time into a heap-allocated string.
573  * @param tformat time format (as with C strftime())
574  * @return an allocated string (must be free()'d), or NULL on memory error.
575  */
576 char *str_format_time( const char *tformat )
577 {
578     time_t curtime;
579     struct tm loctime;
580
581     if (strcmp (tformat, "") == 0)
582         return strdup (""); /* corner case w.r.t. strftime() return value */
583
584     /* Get the current time.  */
585     time( &curtime );
586
587     /* Convert it to local time representation.  */
588     localtime_r( &curtime, &loctime );
589     for (size_t buflen = strlen (tformat) + 32;; buflen += 32)
590     {
591         char *str = malloc (buflen);
592         if (str == NULL)
593             return NULL;
594
595         size_t len = strftime (str, buflen, tformat, &loctime);
596         if (len > 0)
597         {
598             char *ret = realloc (str, len + 1);
599             return ret ? ret : str; /* <- this cannot fail */
600         }
601     }
602     assert (0);
603 }
604
605 #define INSERT_STRING( string )                                     \
606                     if( string != NULL )                            \
607                     {                                               \
608                         int len = strlen( string );                 \
609                         dst = realloc( dst, i_size = i_size + len );\
610                         memcpy( (dst+d), string, len );             \
611                         d += len;                                   \
612                         free( string );                             \
613                     }                                               \
614                     else if( !b_empty_if_na )                       \
615                     {                                               \
616                         *(dst+d) = '-';                             \
617                         d++;                                        \
618                     }                                               \
619
620 /* same than INSERT_STRING, except that string won't be freed */
621 #define INSERT_STRING_NO_FREE( string )                             \
622                     {                                               \
623                         int len = strlen( string );                 \
624                         dst = realloc( dst, i_size = i_size + len );\
625                         memcpy( dst+d, string, len );               \
626                         d += len;                                   \
627                     }
628 char *__str_format_meta( vlc_object_t *p_object, const char *string )
629 {
630     const char *s = string;
631     bool b_is_format = false;
632     bool b_empty_if_na = false;
633     char buf[10];
634     int i_size = strlen( string ) + 1; /* +1 to store '\0' */
635     char *dst = strdup( string );
636     if( !dst ) return NULL;
637     int d = 0;
638
639     playlist_t *p_playlist = pl_Hold( p_object );
640     input_thread_t *p_input = playlist_CurrentInput( p_playlist );
641     input_item_t *p_item = NULL;
642     pl_Release( p_object );
643     if( p_input )
644     {
645         p_item = input_GetItem(p_input);
646     }
647
648     while( *s )
649     {
650         if( b_is_format )
651         {
652             switch( *s )
653             {
654                 case 'a':
655                     if( p_item )
656                     {
657                         INSERT_STRING( input_item_GetArtist( p_item ) );
658                     }
659                     break;
660                 case 'b':
661                     if( p_item )
662                     {
663                         INSERT_STRING( input_item_GetAlbum( p_item ) );
664                     }
665                     break;
666                 case 'c':
667                     if( p_item )
668                     {
669                         INSERT_STRING( input_item_GetCopyright( p_item ) );
670                     }
671                     break;
672                 case 'd':
673                     if( p_item )
674                     {
675                         INSERT_STRING( input_item_GetDescription( p_item ) );
676                     }
677                     break;
678                 case 'e':
679                     if( p_item )
680                     {
681                         INSERT_STRING( input_item_GetEncodedBy( p_item ) );
682                     }
683                     break;
684                 case 'f':
685                     if( p_item && p_item->p_stats )
686                     {
687                         vlc_mutex_lock( &p_item->p_stats->lock );
688                         snprintf( buf, 10, "%d",
689                                   p_item->p_stats->i_displayed_pictures );
690                         vlc_mutex_unlock( &p_item->p_stats->lock );
691                     }
692                     else
693                     {
694                         sprintf( buf, b_empty_if_na ? "" : "-" );
695                     }
696                     INSERT_STRING_NO_FREE( buf );
697                     break;
698                 case 'g':
699                     if( p_item )
700                     {
701                         INSERT_STRING( input_item_GetGenre( p_item ) );
702                     }
703                     break;
704                 case 'l':
705                     if( p_item )
706                     {
707                         INSERT_STRING( input_item_GetLanguage( p_item ) );
708                     }
709                     break;
710                 case 'n':
711                     if( p_item )
712                     {
713                         INSERT_STRING( input_item_GetTrackNum( p_item ) );
714                     }
715                     break;
716                 case 'p':
717                     if( p_item )
718                     {
719                         INSERT_STRING( input_item_GetNowPlaying( p_item ) );
720                     }
721                     break;
722                 case 'r':
723                     if( p_item )
724                     {
725                         INSERT_STRING( input_item_GetRating( p_item ) );
726                     }
727                     break;
728                 case 's':
729                 {
730                     char *lang = NULL;
731                     if( p_input )
732                         lang = var_GetNonEmptyString( p_input, "sub-language" );
733                     if( lang == NULL )
734                         lang = strdup( b_empty_if_na ? "" : "-" );
735                     INSERT_STRING( lang );
736                     break;
737                 }
738                 case 't':
739                     if( p_item )
740                     {
741                         INSERT_STRING( input_item_GetTitle( p_item ) );
742                     }
743                     break;
744                 case 'u':
745                     if( p_item )
746                     {
747                         INSERT_STRING( input_item_GetURL( p_item ) );
748                     }
749                     break;
750                 case 'A':
751                     if( p_item )
752                     {
753                         INSERT_STRING( input_item_GetDate( p_item ) );
754                     }
755                     break;
756                 case 'B':
757                     if( p_input )
758                     {
759                         snprintf( buf, 10, "%d",
760                                   var_GetInteger( p_input, "bit-rate" )/1000 );
761                     }
762                     else
763                     {
764                         sprintf( buf, b_empty_if_na ? "" : "-" );
765                     }
766                     INSERT_STRING_NO_FREE( buf );
767                     break;
768                 case 'C':
769                     if( p_input )
770                     {
771                         snprintf( buf, 10, "%d",
772                                   var_GetInteger( p_input, "chapter" ) );
773                     }
774                     else
775                     {
776                         sprintf( buf, b_empty_if_na ? "" : "-" );
777                     }
778                     INSERT_STRING_NO_FREE( buf );
779                     break;
780                 case 'D':
781                     if( p_item )
782                     {
783                         mtime_t i_duration = input_item_GetDuration( p_item );
784                         snprintf( buf, 10, "%02d:%02d:%02d",
785                                  (int)(i_duration/(3600000000)),
786                                  (int)((i_duration/(60000000))%60),
787                                  (int)((i_duration/1000000)%60) );
788                     }
789                     else
790                     {
791                         snprintf( buf, 10, b_empty_if_na ? "" : "--:--:--" );
792                     }
793                     INSERT_STRING_NO_FREE( buf );
794                     break;
795                 case 'F':
796                     if( p_item )
797                     {
798                         INSERT_STRING( input_item_GetURI( p_item ) );
799                     }
800                     break;
801                 case 'I':
802                     if( p_input )
803                     {
804                         snprintf( buf, 10, "%d",
805                                   var_GetInteger( p_input, "title" ) );
806                     }
807                     else
808                     {
809                         sprintf( buf, b_empty_if_na ? "" : "-" );
810                     }
811                     INSERT_STRING_NO_FREE( buf );
812                     break;
813                 case 'L':
814                     if( p_item && p_input )
815                     {
816                         mtime_t i_duration = input_item_GetDuration( p_item );
817                         int64_t i_time = var_GetTime( p_input, "time" );
818                         snprintf( buf, 10, "%02d:%02d:%02d",
819                      (int)( ( i_duration - i_time ) / 3600000000 ),
820                      (int)( ( ( i_duration - i_time ) / 60000000 ) % 60 ),
821                      (int)( ( ( i_duration - i_time ) / 1000000 ) % 60 ) );
822                     }
823                     else
824                     {
825                         snprintf( buf, 10, b_empty_if_na ? "" : "--:--:--" );
826                     }
827                     INSERT_STRING_NO_FREE( buf );
828                     break;
829                 case 'N':
830                     if( p_item )
831                     {
832                         INSERT_STRING( input_item_GetName( p_item ) );
833                     }
834                     break;
835                 case 'O':
836                 {
837                     char *lang = NULL;
838                     if( p_input )
839                         lang = var_GetNonEmptyString( p_input,
840                                                       "audio-language" );
841                     if( lang == NULL )
842                         lang = strdup( b_empty_if_na ? "" : "-" );
843                     INSERT_STRING( lang );
844                     break;
845                 }
846                 case 'P':
847                     if( p_input )
848                     {
849                         snprintf( buf, 10, "%2.1lf",
850                                   var_GetFloat( p_input, "position" ) * 100. );
851                     }
852                     else
853                     {
854                         snprintf( buf, 10, b_empty_if_na ? "" : "--.-%%" );
855                     }
856                     INSERT_STRING_NO_FREE( buf );
857                     break;
858                 case 'R':
859                     if( p_input )
860                     {
861                         int r = var_GetInteger( p_input, "rate" );
862                         snprintf( buf, 10, "%d.%d", r/1000, r%1000 );
863                     }
864                     else
865                     {
866                         sprintf( buf, b_empty_if_na ? "" : "-" );
867                     }
868                     INSERT_STRING_NO_FREE( buf );
869                     break;
870                 case 'S':
871                     if( p_input )
872                     {
873                         int r = var_GetInteger( p_input, "sample-rate" );
874                         snprintf( buf, 10, "%d.%d", r/1000, (r/100)%10 );
875                     }
876                     else
877                     {
878                         sprintf( buf, b_empty_if_na ? "" : "-" );
879                     }
880                     INSERT_STRING_NO_FREE( buf );
881                     break;
882                 case 'T':
883                     if( p_input )
884                     {
885                         int64_t i_time = var_GetTime( p_input, "time" );
886                         snprintf( buf, 10, "%02d:%02d:%02d",
887                             (int)( i_time / ( 3600000000 ) ),
888                             (int)( ( i_time / ( 60000000 ) ) % 60 ),
889                             (int)( ( i_time / 1000000 ) % 60 ) );
890                     }
891                     else
892                     {
893                         snprintf( buf, 10, b_empty_if_na ? "" :  "--:--:--" );
894                     }
895                     INSERT_STRING_NO_FREE( buf );
896                     break;
897                 case 'U':
898                     if( p_item )
899                     {
900                         INSERT_STRING( input_item_GetPublisher( p_item ) );
901                     }
902                     break;
903                 case 'V':
904                 {
905                     audio_volume_t volume;
906                     aout_VolumeGet( p_object, &volume );
907                     snprintf( buf, 10, "%d", volume );
908                     INSERT_STRING_NO_FREE( buf );
909                     break;
910                 }
911                 case '_':
912                     *(dst+d) = '\n';
913                     d++;
914                     break;
915
916                 case ' ':
917                     b_empty_if_na = true;
918                     break;
919
920                 default:
921                     *(dst+d) = *s;
922                     d++;
923                     break;
924             }
925             if( *s != ' ' )
926                 b_is_format = false;
927         }
928         else if( *s == '$' )
929         {
930             b_is_format = true;
931             b_empty_if_na = false;
932         }
933         else
934         {
935             *(dst+d) = *s;
936             d++;
937         }
938         s++;
939     }
940     *(dst+d) = '\0';
941
942     if( p_input )
943         vlc_object_release( p_input );
944
945     return dst;
946 }
947 #undef INSERT_STRING
948 #undef INSERT_STRING_NO_FREE
949
950 /**
951  * Apply str format time and str format meta
952  */
953 char *__str_format( vlc_object_t *p_this, const char *psz_src )
954 {
955     char *psz_buf1, *psz_buf2;
956     psz_buf1 = str_format_time( psz_src );
957     psz_buf2 = str_format_meta( p_this, psz_buf1 );
958     free( psz_buf1 );
959     return psz_buf2;
960 }
961
962 /**
963  * Remove forbidden characters from filenames (including slashes)
964  */
965 char* filename_sanitize( const char *str_origin )
966 {
967     char *str = strdup( str_origin );
968     char *str_base = str;
969     if( *str == '.' && (str[1] == '\0' || (str[1] == '.' && str[2] == '\0' ) ) )
970     {
971         while( *str )
972         {
973             *str = '_';
974             str++;
975         }
976         return str_base;
977     }
978
979 #if defined( WIN32 )
980     // Change leading spaces into underscores
981     while( *str && *str == ' ' )
982         *str++ = '_';
983 #endif
984
985     while( *str )
986     {
987         switch( *str )
988         {
989             case '/':
990 #if defined( __APPLE__ )
991             case ':':
992 #elif defined( WIN32 )
993             case '\\':
994             case '*':
995             case '"':
996             case '?':
997             case ':':
998             case '|':
999             case '<':
1000             case '>':
1001 #endif
1002                 *str = '_';
1003         }
1004         str++;
1005     }
1006
1007 #if defined( WIN32 )
1008     // Change trailing spaces into underscores
1009     str--;
1010     while( str != str_base )
1011     {
1012         if( *str != ' ' )
1013             break;
1014         *str-- = '_';
1015     }
1016 #endif
1017
1018     return str_base;
1019 }
1020
1021 /**
1022  * Remove forbidden characters from full paths (leaves slashes)
1023  */
1024 void path_sanitize( char *str )
1025 {
1026 #ifdef WIN32
1027     /* check drive prefix if path is absolute */
1028     if( (((unsigned char)(str[0] - 'A') < 26)
1029       || ((unsigned char)(str[0] - 'a') < 26)) && (':' == str[1]) )
1030         str += 2;
1031 #endif
1032     while( *str )
1033     {
1034 #if defined( __APPLE__ )
1035         if( *str == ':' )
1036             *str = '_';
1037 #elif defined( WIN32 )
1038         if( strchr( "*\"?:|<>", *str ) )
1039             *str = '_';
1040         if( *str == '/' )
1041             *str = DIR_SEP_CHAR;
1042 #endif
1043         str++;
1044     }
1045 }
1046
1047 #include <vlc_url.h>
1048
1049 /**
1050  * Convert a file path to an URI. If already an URI, do nothing.
1051  */
1052 char *make_URI (const char *path)
1053 {
1054     if (path == NULL)
1055         return NULL;
1056     if (strstr (path, "://") != NULL)
1057         return strdup (path); /* Already an URI */
1058     /* Note: VLC cannot handle URI schemes without double slash after the
1059      * scheme name (such as mailto: or news:). */
1060
1061     char *buf;
1062 #ifdef WIN32
1063     if (isalpha (path[0]) && (path[1] == ':'))
1064     {
1065         if (asprintf (&buf, "file:///%c:", path[0]) == -1)
1066             buf = NULL;
1067         path += 2;
1068     }
1069     else
1070 #endif
1071     if (!strncmp (path, "\\\\", 2))
1072     {   /* Windows UNC paths */
1073 #ifndef WIN32
1074         /* \\host\share\path -> smb://host/share/path */
1075         if (strchr (path + 2, '\\') != NULL)
1076         {   /* Convert antislashes to slashes */
1077             char *dup = strdup (path);
1078             if (dup == NULL)
1079                 return NULL;
1080             for (size_t i = 2; dup[i]; i++)
1081                 if (dup[i] == '\\')
1082                     dup[i] = DIR_SEP_CHAR;
1083
1084             char *ret = make_URI (dup);
1085             free (dup);
1086             return ret;
1087         }
1088 # define SMB_SCHEME "smb"
1089 #else
1090         /* \\host\share\path -> file://host/share/path */
1091 # define SMB_SCHEME "file"
1092 #endif
1093         size_t hostlen = strcspn (path + 2, DIR_SEP);
1094
1095         buf = malloc (sizeof (SMB_SCHEME) + 3 + hostlen);
1096         if (buf != NULL)
1097             snprintf (buf, sizeof (SMB_SCHEME) + 3 + hostlen,
1098                       SMB_SCHEME"://%s", path + 2);
1099         path += 2 + hostlen;
1100     }
1101     else
1102     if (path[0] != DIR_SEP_CHAR)
1103     {   /* Relative path: prepend the current working directory */
1104         char cwd[PATH_MAX];
1105
1106         if (getcwd (cwd, sizeof (cwd)) == NULL) /* FIXME: UTF8? */
1107             return NULL;
1108         if (asprintf (&buf, "%s/%s", cwd, path) == -1)
1109             return NULL;
1110         char *ret = make_URI (buf);
1111         free (buf);
1112         return ret;
1113     }
1114     else
1115         buf = strdup ("file://");
1116     if (buf == NULL)
1117         return NULL;
1118
1119     assert (path[0] == DIR_SEP_CHAR);
1120
1121     /* Absolute file path */
1122     for (const char *ptr = path + 1;; ptr++)
1123     {
1124         size_t len = strcspn (ptr, DIR_SEP);
1125         char *component = encode_URI_bytes (ptr, len);
1126         if (component == NULL)
1127         {
1128             free (buf);
1129             return NULL;
1130         }
1131         char *uri;
1132         int val = asprintf (&uri, "%s/%s", buf, component);
1133         free (component);
1134         free (buf);
1135         if (val == -1)
1136             return NULL;
1137         buf = uri;
1138         ptr += len;
1139         if (*ptr == '\0')
1140             return buf;
1141     }
1142 }