]> git.sesse.net Git - vlc/blob - include/vlc_url.h
Separate socket/resolv stuff (network.h) from url stuff (vlc_url.h)
[vlc] / include / vlc_url.h
1 /*****************************************************************************
2  * vlc_url.h: URL related macros
3  *****************************************************************************
4  * Copyright (C) 2002-2005 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
8  *          RĂ©mi Denis-Courmont <rem # videolan.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 #ifndef __VLC_URL_H
26 # define __VLC_URL_H
27
28 typedef struct
29 {
30     char *psz_protocol;
31     char *psz_username;
32     char *psz_password;
33     char *psz_host;
34     int  i_port;
35
36     char *psz_path;
37
38     char *psz_option;
39
40     char *psz_buffer; /* to be freed */
41 } vlc_url_t;
42
43 /*****************************************************************************
44  * vlc_UrlParse:
45  *****************************************************************************
46  * option : if != 0 then path is split at this char
47  *
48  * format [protocol://[login[:password]@]][host[:port]]/path[OPTIONoption]
49  *****************************************************************************/
50 static inline void vlc_UrlParse( vlc_url_t *url, const char *psz_url,
51                                  char option )
52 {
53     char *psz_dup;
54     char *psz_parse;
55     char *p;
56
57     url->psz_protocol = NULL;
58     url->psz_username = NULL;
59     url->psz_password = NULL;
60     url->psz_host     = NULL;
61     url->i_port       = 0;
62     url->psz_path     = NULL;
63     url->psz_option   = NULL;
64
65     if( psz_url == NULL )
66     {
67         url->psz_buffer = NULL;
68         return;
69     }
70     url->psz_buffer = psz_parse = psz_dup = strdup( psz_url );
71
72     p  = strstr( psz_parse, ":/" );
73     if( p != NULL )
74     {
75         /* we have a protocol */
76
77         /* skip :// */
78         *p++ = '\0';
79         if( p[1] == '/' )
80             p += 2;
81         url->psz_protocol = psz_parse;
82         psz_parse = p;
83     }
84     p = strchr( psz_parse, '@' );
85     if( p != NULL )
86     {
87         /* We have a login */
88         url->psz_username = psz_parse;
89         *p++ = '\0';
90
91         psz_parse = strchr( psz_parse, ':' );
92         if( psz_parse != NULL )
93         {
94             /* We have a password */
95             *psz_parse++ = '\0';
96             url->psz_password = psz_parse;
97         }
98
99         psz_parse = p;
100     }
101
102     p = strchr( psz_parse, '/' );
103     if( !p || psz_parse < p )
104     {
105         char *p2;
106
107         /* We have a host[:port] */
108         url->psz_host = strdup( psz_parse );
109         if( p )
110         {
111             url->psz_host[p - psz_parse] = '\0';
112         }
113
114         if( *url->psz_host == '[' )
115         {
116             /* Ipv6 address */
117             p2 = strchr( url->psz_host, ']' );
118             if( p2 )
119             {
120                 p2 = strchr( p2, ':' );
121             }
122         }
123         else
124         {
125             p2 = strchr( url->psz_host, ':' );
126         }
127         if( p2 )
128         {
129             *p2++ = '\0';
130             url->i_port = atoi( p2 );
131         }
132     }
133     psz_parse = p;
134
135     /* Now parse psz_path and psz_option */
136     if( psz_parse )
137     {
138         url->psz_path = psz_parse;
139         if( option != '\0' )
140         {
141             p = strchr( url->psz_path, option );
142             if( p )
143             {
144                 *p++ = '\0';
145                 url->psz_option = p;
146             }
147         }
148     }
149 }
150
151 /*****************************************************************************
152  * vlc_UrlClean:
153  *****************************************************************************
154  *
155  *****************************************************************************/
156 static inline void vlc_UrlClean( vlc_url_t *url )
157 {
158     if( url->psz_buffer ) free( url->psz_buffer );
159     if( url->psz_host )   free( url->psz_host );
160
161     url->psz_protocol = NULL;
162     url->psz_username = NULL;
163     url->psz_password = NULL;
164     url->psz_host     = NULL;
165     url->i_port       = 0;
166     url->psz_path     = NULL;
167     url->psz_option   = NULL;
168
169     url->psz_buffer   = NULL;
170 }
171
172 static inline int isurlsafe( int c )
173 {
174     return ( (unsigned char)( c - 'a' ) < 26 )
175         || ( (unsigned char)( c - 'A' ) < 26 )
176         || ( (unsigned char)( c - '0' ) < 10 )
177         /* Hmm, we should not encode character that are allowed in URLs
178          * (even if they are not URL-safe), nor URL-safe characters.
179          * We still encode some of them because of Microsoft's crap browser.
180          */
181         || ( strchr( "-_.", c ) != NULL );
182 }
183
184 /*****************************************************************************
185  * vlc_UrlEncode:
186  *****************************************************************************
187  * perform URL encoding
188  * (you do NOT want to do URL decoding - it is not reversible - do NOT do it)
189  *****************************************************************************/
190 static inline char *vlc_UrlEncode( const char *psz_url )
191 {
192     char *psz_enc, *out;
193     const unsigned char *in;
194
195     psz_enc = (char *)malloc( 3 * strlen( psz_url ) + 1 );
196     if( psz_enc == NULL )
197         return NULL;
198
199     out = psz_enc;
200     for( in = (const unsigned char *)psz_url; *in; in++ )
201     {
202         unsigned char c = *in;
203
204         if( isurlsafe( c ) )
205             *out++ = (char)c;
206         else
207         {
208             *out++ = '%';
209             *out++ = ( ( c >> 4 ) >= 0xA ) ? 'A' + ( c >> 4 ) - 0xA
210                                            : '0' + ( c >> 4 );
211             *out++ = ( ( c & 0xf ) >= 0xA ) ? 'A' + ( c & 0xf ) - 0xA
212                                            : '0' + ( c & 0xf );
213         }
214     }
215     *out++ = '\0';
216
217     return (char *)realloc( psz_enc, out - psz_enc );
218 }
219
220 /*****************************************************************************
221  * vlc_UrlIsNotEncoded:
222  *****************************************************************************
223  * check if given string is not a valid URL and must hence be encoded
224  *****************************************************************************/
225 #include <ctype.h>
226
227 static inline int vlc_UrlIsNotEncoded( const char *psz_url )
228 {
229     const char *ptr;
230
231     for( ptr = psz_url; *ptr; ptr++ )
232     {
233         char c = *ptr;
234
235         if( c == '%' )
236         {
237             if( !isxdigit( ptr[1] ) || !isxdigit( ptr[2] ) )
238                 return 1; /* not encoded */
239             ptr += 2;
240         }
241         else
242         if( !isurlsafe( c ) )
243             return 1;
244     }
245     return 0; /* looks fine - but maybe it is not encoded */
246 }
247
248 /*****************************************************************************
249  * vlc_b64_encode:
250  *****************************************************************************
251  *
252  *****************************************************************************/
253 static inline char *vlc_b64_encode( char *src )
254 {
255     static const char b64[] =
256            "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
257     size_t len = strlen( src );
258
259     char *ret;
260     char *dst = (char *)malloc( ( len + 4 ) * 4 / 3 );
261     if( dst == NULL )
262         return NULL;
263
264     ret = dst;
265
266     while( len > 0 )
267     {
268         /* pops (up to) 3 bytes of input */
269         uint32_t v = *src++ << 24;
270
271         if( len >= 2 )
272         {
273             v |= *src++ << 16;
274             if( len >= 3 )
275                 v |= *src++ << 8;
276         }
277
278         /* pushes (up to) 4 bytes of output */
279         while( v )
280         {
281             *dst++ = b64[v >> 26];
282             v = v << 6;
283         }
284
285         switch( len )
286         {
287             case 1:
288                 *dst++ = '=';
289                 *dst++ = '=';
290                 len--;
291                 break;
292
293             case 2:
294                 *dst++ = '=';
295                 len -= 2;
296                 break;
297
298             default:
299                 len -= 3;
300         }
301     }
302
303     *dst = '\0';
304
305     return ret;
306 }
307 #endif