[uri] Decode/encode URIs when parsing/unparsing
[people/mcb30/gpxe.git] / src / core / uri.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 FILE_LICENCE ( GPL2_OR_LATER );
20
21 /** @file
22  *
23  * Uniform Resource Identifiers
24  *
25  */
26
27 #include <stdint.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <libgen.h>
31 #include <ctype.h>
32 #include <gpxe/vsprintf.h>
33 #include <gpxe/uri.h>
34
35 /**
36  * Dump URI for debugging
37  *
38  * @v uri               URI
39  */
40 static void dump_uri ( struct uri *uri ) {
41         if ( ! uri )
42                 return;
43         if ( uri->scheme )
44                 DBG ( " scheme \"%s\"", uri->scheme );
45         if ( uri->opaque )
46                 DBG ( " opaque \"%s\"", uri->opaque );
47         if ( uri->user )
48                 DBG ( " user \"%s\"", uri->user );
49         if ( uri->password )
50                 DBG ( " password \"%s\"", uri->password );
51         if ( uri->host )
52                 DBG ( " host \"%s\"", uri->host );
53         if ( uri->port )
54                 DBG ( " port \"%s\"", uri->port );
55         if ( uri->path )
56                 DBG ( " path \"%s\"", uri->path );
57         if ( uri->query )
58                 DBG ( " query \"%s\"", uri->query );
59         if ( uri->fragment )
60                 DBG ( " fragment \"%s\"", uri->fragment );
61 }
62
63 /**
64  * Parse URI
65  *
66  * @v uri_string        URI as a string
67  * @ret uri             URI
68  *
69  * Splits a URI into its component parts.  The return URI structure is
70  * dynamically allocated and must eventually be freed by calling
71  * uri_put().
72  */
73 struct uri * parse_uri ( const char *uri_string ) {
74         struct uri *uri;
75         char *raw;
76         char *tmp;
77         char *path = NULL;
78         char *authority = NULL;
79         int i;
80         size_t raw_len;
81
82         /* Allocate space for URI struct and a copy of the string */
83         raw_len = ( strlen ( uri_string ) + 1 /* NUL */ );
84         uri = zalloc ( sizeof ( *uri ) + raw_len );
85         if ( ! uri )
86                 return NULL;
87         raw = ( ( ( char * ) uri ) + sizeof ( *uri ) );
88
89         /* Copy in the raw string */
90         memcpy ( raw, uri_string, raw_len );
91
92         /* Start by chopping off the fragment, if it exists */
93         if ( ( tmp = strchr ( raw, '#' ) ) ) {
94                 *(tmp++) = '\0';
95                 uri->fragment = tmp;
96         }
97
98         /* Identify absolute/relative URI.  We ignore schemes that are
99          * apparently only a single character long, since otherwise we
100          * misinterpret a DOS-style path name ("C:\path\to\file") as a
101          * URI with scheme="C",opaque="\path\to\file".
102          */
103         if ( ( tmp = strchr ( raw, ':' ) ) && ( tmp > ( raw + 1 ) ) ) {
104                 /* Absolute URI: identify hierarchical/opaque */
105                 uri->scheme = raw;
106                 *(tmp++) = '\0';
107                 if ( *tmp == '/' ) {
108                         /* Absolute URI with hierarchical part */
109                         path = tmp;
110                 } else {
111                         /* Absolute URI with opaque part */
112                         uri->opaque = tmp;
113                 }
114         } else {
115                 /* Relative URI */
116                 path = raw;
117         }
118
119         /* If we don't have a path (i.e. we have an absolute URI with
120          * an opaque portion, we're already finished processing
121          */
122         if ( ! path )
123                 goto done;
124
125         /* Chop off the query, if it exists */
126         if ( ( tmp = strchr ( path, '?' ) ) ) {
127                 *(tmp++) = '\0';
128                 uri->query = tmp;
129         }
130
131         /* Identify net/absolute/relative path */
132         if ( strncmp ( path, "//", 2 ) == 0 ) {
133                 /* Net path.  If this is terminated by the first '/'
134                  * of an absolute path, then we have no space for a
135                  * terminator after the authority field, so shuffle
136                  * the authority down by one byte, overwriting one of
137                  * the two slashes.
138                  */
139                 authority = ( path + 2 );
140                 if ( ( tmp = strchr ( authority, '/' ) ) ) {
141                         /* Shuffle down */
142                         uri->path = tmp;
143                         memmove ( ( authority - 1 ), authority,
144                                   ( tmp - authority ) );
145                         authority--;
146                         *(--tmp) = '\0';
147                 }
148         } else {
149                 /* Absolute/relative path */
150                 uri->path = path;
151         }
152
153         /* Split authority into user[:password] and host[:port] portions */
154         if ( ( tmp = strchr ( authority, '@' ) ) ) {
155                 /* Has user[:password] */
156                 *(tmp++) = '\0';
157                 uri->host = tmp;
158                 uri->user = authority;
159                 if ( ( tmp = strchr ( authority, ':' ) ) ) {
160                         /* Has password */
161                         *(tmp++) = '\0';
162                         uri->password = tmp;
163                 }
164         } else {
165                 /* No user:password */
166                 uri->host = authority;
167         }
168
169         /* Split host into host[:port] */
170         if ( ( tmp = strchr ( uri->host, ':' ) ) ) {
171                 *(tmp++) = '\0';
172                 uri->port = tmp;
173         }
174
175         /* Decode fields that should be decoded */
176         for ( i = URI_FIRST_FIELD; i <= URI_LAST_FIELD; i++ ) {
177                 const char *field = uri_get_field ( uri, i );
178                 if ( field && ( URI_ENCODED & ( 1 << i ) ) )
179                         uri_decode ( field, ( char * ) field,
180                                      strlen ( field ) + 1 /* NUL */ );
181         }
182
183  done:
184         DBG ( "URI \"%s\" split into", uri_string );
185         dump_uri ( uri );
186         DBG ( "\n" );
187
188         return uri;
189 }
190
191 /**
192  * Get port from URI
193  *
194  * @v uri               URI, or NULL
195  * @v default_port      Default port to use if none specified in URI
196  * @ret port            Port
197  */
198 unsigned int uri_port ( struct uri *uri, unsigned int default_port ) {
199         if ( ( ! uri ) || ( ! uri->port ) )
200                 return default_port;
201         return ( strtoul ( uri->port, NULL, 0 ) );
202 }
203
204 /**
205  * Unparse URI
206  *
207  * @v buf               Buffer to fill with URI string
208  * @v size              Size of buffer
209  * @v uri               URI to write into buffer, or NULL
210  * @v fields            Bitmask of fields to include in URI string, or URI_ALL
211  * @ret len             Length of URI string
212  */
213 int unparse_uri ( char *buf, size_t size, struct uri *uri,
214                   unsigned int fields ) {
215         /* List of characters that typically go before certain fields */
216         static char separators[] = { /* scheme */ 0, /* opaque */ ':',
217                                      /* user */ 0, /* password */ ':',
218                                      /* host */ '@', /* port */ ':',
219                                      /* path */ 0, /* query */ '?',
220                                      /* fragment */ '#' };
221         int used = 0;
222         int i;
223
224         DBG ( "URI unparsing" );
225         dump_uri ( uri );
226         DBG ( "\n" );
227
228         /* Special-case NULL URI */
229         if ( ! uri ) {
230                 if ( size )
231                         buf[0] = '\0';
232                 return 0;
233         }
234
235         /* Iterate through requested fields */
236         for ( i = URI_FIRST_FIELD; i <= URI_LAST_FIELD; i++ ) {
237                 const char *field = uri_get_field ( uri, i );
238                 char sep = separators[i];
239
240                 /* Ensure `fields' only contains bits for fields that exist */
241                 if ( ! field )
242                         fields &= ~( 1 << i );
243
244                 /* Store this field if we were asked to */
245                 if ( fields & ( 1 << i ) ) {
246                         /* Print :// if we're non-opaque and had a scheme */
247                         if ( ( fields & URI_SCHEME_BIT ) &&
248                              ( i > URI_OPAQUE ) ) {
249                                 used += ssnprintf ( buf + used, size - used,
250                                                     "://" );
251                                 /* Only print :// once */
252                                 fields &= ~URI_SCHEME_BIT;
253                         }
254
255                         /* Only print separator if an earlier field exists */
256                         if ( sep && ( fields & ( ( 1 << i ) - 1 ) ) )
257                                 used += ssnprintf ( buf + used, size - used,
258                                                     "%c", sep );
259
260                         /* Print contents of field, possibly encoded */
261                         if ( URI_ENCODED & ( 1 << i ) )
262                                 used += uri_encode ( field, buf + used,
263                                                      size - used, i );
264                         else
265                                 used += ssnprintf ( buf + used, size - used,
266                                                     "%s", field );
267                 }
268         }
269
270         return used;
271 }
272
273 /**
274  * Duplicate URI
275  *
276  * @v uri               URI
277  * @ret uri             Duplicate URI
278  *
279  * Creates a modifiable copy of a URI.
280  */
281 struct uri * uri_dup ( struct uri *uri ) {
282         size_t len = ( unparse_uri ( NULL, 0, uri, URI_ALL ) + 1 );
283         char buf[len];
284
285         unparse_uri ( buf, len, uri, URI_ALL );
286         return parse_uri ( buf );
287 }
288
289 /**
290  * Resolve base+relative path
291  *
292  * @v base_uri          Base path
293  * @v relative_uri      Relative path
294  * @ret resolved_uri    Resolved path
295  *
296  * Takes a base path (e.g. "/var/lib/tftpboot/vmlinuz" and a relative
297  * path (e.g. "initrd.gz") and produces a new path
298  * (e.g. "/var/lib/tftpboot/initrd.gz").  Note that any non-directory
299  * portion of the base path will automatically be stripped; this
300  * matches the semantics used when resolving the path component of
301  * URIs.
302  */
303 char * resolve_path ( const char *base_path,
304                       const char *relative_path ) {
305         size_t base_len = ( strlen ( base_path ) + 1 );
306         char base_path_copy[base_len];
307         char *base_tmp = base_path_copy;
308         char *resolved;
309
310         /* If relative path is absolute, just re-use it */
311         if ( relative_path[0] == '/' )
312                 return strdup ( relative_path );
313
314         /* Create modifiable copy of path for dirname() */
315         memcpy ( base_tmp, base_path, base_len );
316         base_tmp = dirname ( base_tmp );
317
318         /* Process "./" and "../" elements */
319         while ( *relative_path == '.' ) {
320                 relative_path++;
321                 if ( *relative_path == 0 ) {
322                         /* Do nothing */
323                 } else if ( *relative_path == '/' ) {
324                         relative_path++;
325                 } else if ( *relative_path == '.' ) {
326                         relative_path++;
327                         if ( *relative_path == 0 ) {
328                                 base_tmp = dirname ( base_tmp );
329                         } else if ( *relative_path == '/' ) {
330                                 base_tmp = dirname ( base_tmp );
331                                 relative_path++;
332                         } else {
333                                 relative_path -= 2;
334                                 break;
335                         }
336                 } else {
337                         relative_path--;
338                         break;
339                 }
340         }
341
342         /* Create and return new path */
343         if ( asprintf ( &resolved, "%s%s%s", base_tmp,
344                         ( ( base_tmp[ strlen ( base_tmp ) - 1 ] == '/' ) ?
345                           "" : "/" ), relative_path ) < 0 )
346                 return NULL;
347
348         return resolved;
349 }
350
351 /**
352  * Resolve base+relative URI
353  *
354  * @v base_uri          Base URI, or NULL
355  * @v relative_uri      Relative URI
356  * @ret resolved_uri    Resolved URI
357  *
358  * Takes a base URI (e.g. "http://etherboot.org/kernels/vmlinuz" and a
359  * relative URI (e.g. "../initrds/initrd.gz") and produces a new URI
360  * (e.g. "http://etherboot.org/initrds/initrd.gz").
361  */
362 struct uri * resolve_uri ( struct uri *base_uri,
363                            struct uri *relative_uri ) {
364         struct uri tmp_uri;
365         char *tmp_path = NULL;
366         struct uri *new_uri;
367
368         /* If relative URI is absolute, just re-use it */
369         if ( uri_is_absolute ( relative_uri ) || ( ! base_uri ) )
370                 return uri_get ( relative_uri );
371
372         /* Mangle URI */
373         memcpy ( &tmp_uri, base_uri, sizeof ( tmp_uri ) );
374         if ( relative_uri->path ) {
375                 tmp_path = resolve_path ( ( base_uri->path ?
376                                             base_uri->path : "/" ),
377                                           relative_uri->path );
378                 tmp_uri.path = tmp_path;
379                 tmp_uri.query = relative_uri->query;
380                 tmp_uri.fragment = relative_uri->fragment;
381         } else if ( relative_uri->query ) {
382                 tmp_uri.query = relative_uri->query;
383                 tmp_uri.fragment = relative_uri->fragment;
384         } else if ( relative_uri->fragment ) {
385                 tmp_uri.fragment = relative_uri->fragment;
386         }
387
388         /* Create demangled URI */
389         new_uri = uri_dup ( &tmp_uri );
390         free ( tmp_path );
391         return new_uri;
392 }
393
394 /**
395  * Test for unreserved URI characters
396  *
397  * @v c                 Character to test
398  * @v field             Field of URI in which character lies
399  * @ret is_unreserved   Character is an unreserved character
400  */
401 static int is_unreserved_uri_char ( int c, int field ) {
402         /* According to RFC3986, the unreserved character set is
403          *
404          * A-Z a-z 0-9 - _ . ~
405          *
406          * but we also pass & ; = in queries, / in paths,
407          * and everything in opaques
408          */
409         int ok = ( isupper ( c ) || islower ( c ) || isdigit ( c ) ||
410                     ( c == '-' ) || ( c == '_' ) ||
411                     ( c == '.' ) || ( c == '~' ) );
412
413         if ( field == URI_QUERY )
414                 ok = ok || ( c == ';' ) || ( c == '&' ) || ( c == '=' );
415
416         if ( field == URI_PATH )
417                 ok = ok || ( c == '/' );
418
419         if ( field == URI_OPAQUE )
420                 ok = 1;
421
422         return ok;
423 }
424
425 /**
426  * URI-encode string
427  *
428  * @v raw_string        String to be URI-encoded
429  * @v buf               Buffer to contain encoded string
430  * @v len               Length of buffer
431  * @v field             Field of URI in which string lies
432  * @ret len             Length of encoded string (excluding NUL)
433  */
434 size_t uri_encode ( const char *raw_string, char *buf, ssize_t len,
435                     int field ) {
436         ssize_t remaining = len;
437         size_t used;
438         unsigned char c;
439
440         if ( len > 0 )
441                 buf[0] = '\0';
442
443         while ( ( c = *(raw_string++) ) ) {
444                 if ( is_unreserved_uri_char ( c, field ) ) {
445                         used = ssnprintf ( buf, remaining, "%c", c );
446                 } else {
447                         used = ssnprintf ( buf, remaining, "%%%02X", c );
448                 }
449                 buf += used;
450                 remaining -= used;
451         }
452
453         return ( len - remaining );
454 }
455
456 /**
457  * Decode URI-encoded string
458  *
459  * @v encoded_string    URI-encoded string
460  * @v buf               Buffer to contain decoded string
461  * @v len               Length of buffer
462  * @ret len             Length of decoded string (excluding NUL)
463  *
464  * This function may be used in-place, with @a buf the same as
465  * @a encoded_string.
466  */
467 size_t uri_decode ( const char *encoded_string, char *buf, ssize_t len ) {
468         ssize_t remaining;
469         char hexbuf[3];
470         char *hexbuf_end;
471         unsigned char c;
472
473         for ( remaining = len; *encoded_string; remaining-- ) {
474                 if ( *encoded_string == '%' ) {
475                         encoded_string++;
476                         snprintf ( hexbuf, sizeof ( hexbuf ), "%s",
477                                    encoded_string );
478                         c = strtoul ( hexbuf, &hexbuf_end, 16 );
479                         encoded_string += ( hexbuf_end - hexbuf );
480                 } else {
481                         c = *(encoded_string++);
482                 }
483                 if ( remaining > 1 )
484                         *buf++ = c;
485         }
486
487         if ( len )
488                 *buf = 0;
489
490         return ( len - remaining );
491 }