uri.c File Reference

Uniform Resource Identifiers. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <libgen.h>
#include <ctype.h>
#include <gpxe/vsprintf.h>
#include <gpxe/uri.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
static void	dump_uri (struct uri *uri)
	Dump URI for debugging.
struct uri *	parse_uri (const char *uri_string)
	Parse URI.
unsigned int	uri_port (struct uri *uri, unsigned int default_port)
	Get port from URI.
int	unparse_uri (char *buf, size_t size, struct uri *uri, unsigned int fields)
	Unparse URI.
struct uri *	uri_dup (struct uri *uri)
	Duplicate URI.
char *	resolve_path (const char *base_path, const char *relative_path)
	Resolve base+relative path.
struct uri *	resolve_uri (struct uri *base_uri, struct uri *relative_uri)
	Resolve base+relative URI.
static int	is_unreserved_uri_char (int c, int field)
	Test for unreserved URI characters.
size_t	uri_encode (const char *raw_string, char *buf, ssize_t len, int field)
	URI-encode string.
size_t	uri_decode (const char *encoded_string, char *buf, ssize_t len)
	Decode URI-encoded string.

---

Detailed Description

Uniform Resource Identifiers.

Definition in file uri.c.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

static void dump_uri

(

struct uri *

uri

)

[static]

Dump URI for debugging.

Parameters:

uri

URI

Definition at line 40 of file uri.c.

References DBG, uri::fragment, uri::host, uri::opaque, uri::password, uri::path, uri::port, uri::query, uri::scheme, and uri::user.

Referenced by parse_uri(), and unparse_uri().

                                         {
        if ( ! uri )
                return;
        if ( uri->scheme )
                DBG ( " scheme \"%s\"", uri->scheme );
        if ( uri->opaque )
                DBG ( " opaque \"%s\"", uri->opaque );
        if ( uri->user )
                DBG ( " user \"%s\"", uri->user );
        if ( uri->password )
                DBG ( " password \"%s\"", uri->password );
        if ( uri->host )
                DBG ( " host \"%s\"", uri->host );
        if ( uri->port )
                DBG ( " port \"%s\"", uri->port );
        if ( uri->path )
                DBG ( " path \"%s\"", uri->path );
        if ( uri->query )
                DBG ( " query \"%s\"", uri->query );
        if ( uri->fragment )
                DBG ( " fragment \"%s\"", uri->fragment );
}

struct uri* parse_uri

(

const char *

uri_string

)

[read]

Parse URI.

Parameters:

uri_string

URI as a string

Return values:

uri

URI

Splits a URI into its component parts. The return URI structure is dynamically allocated and must eventually be freed by calling uri_put().

Definition at line 73 of file uri.c.

References DBG, dump_uri(), uri::fragment, uri::host, memcpy, memmove(), NULL, uri::opaque, uri::password, uri::path, uri::port, uri::query, raw(), uri::scheme, strchr(), strlen(), strncmp(), uri_decode(), URI_ENCODED, URI_FIRST_FIELD, uri_get_field, URI_LAST_FIELD, uri::user, and zalloc().

Referenced by boot_next_server_and_filename(), imgfetch(), test_parse_unparse(), test_resolve(), tftp_apply_settings(), uri_dup(), and xfer_open_uri_string().

                                                  {
        struct uri *uri;
        char *raw;
        char *tmp;
        char *path = NULL;
        char *authority = NULL;
        int i;
        size_t raw_len;

        /* Allocate space for URI struct and a copy of the string */
        raw_len = ( strlen ( uri_string ) + 1 /* NUL */ );
        uri = zalloc ( sizeof ( *uri ) + raw_len );
        if ( ! uri )
                return NULL;
        raw = ( ( ( char * ) uri ) + sizeof ( *uri ) );

        /* Copy in the raw string */
        memcpy ( raw, uri_string, raw_len );

        /* Start by chopping off the fragment, if it exists */
        if ( ( tmp = strchr ( raw, '#' ) ) ) {
                *(tmp++) = '\0';
                uri->fragment = tmp;
        }

        /* Identify absolute/relative URI.  We ignore schemes that are
         * apparently only a single character long, since otherwise we
         * misinterpret a DOS-style path name ("C:\path\to\file") as a
         * URI with scheme="C",opaque="\path\to\file".
         */
        if ( ( tmp = strchr ( raw, ':' ) ) && ( tmp > ( raw + 1 ) ) ) {
                /* Absolute URI: identify hierarchical/opaque */
                uri->scheme = raw;
                *(tmp++) = '\0';
                if ( *tmp == '/' ) {
                        /* Absolute URI with hierarchical part */
                        path = tmp;
                } else {
                        /* Absolute URI with opaque part */
                        uri->opaque = tmp;
                }
        } else {
                /* Relative URI */
                path = raw;
        }

        /* If we don't have a path (i.e. we have an absolute URI with
         * an opaque portion, we're already finished processing
         */
        if ( ! path )
                goto done;

        /* Chop off the query, if it exists */
        if ( ( tmp = strchr ( path, '?' ) ) ) {
                *(tmp++) = '\0';
                uri->query = tmp;
        }

        /* Identify net/absolute/relative path */
        if ( strncmp ( path, "//", 2 ) == 0 ) {
                /* Net path.  If this is terminated by the first '/'
                 * of an absolute path, then we have no space for a
                 * terminator after the authority field, so shuffle
                 * the authority down by one byte, overwriting one of
                 * the two slashes.
                 */
                authority = ( path + 2 );
                if ( ( tmp = strchr ( authority, '/' ) ) ) {
                        /* Shuffle down */
                        uri->path = tmp;
                        memmove ( ( authority - 1 ), authority,
                                  ( tmp - authority ) );
                        authority--;
                        *(--tmp) = '\0';
                }
        } else {
                /* Absolute/relative path */
                uri->path = path;
        }

        /* Split authority into user[:password] and host[:port] portions */
        if ( ( tmp = strchr ( authority, '@' ) ) ) {
                /* Has user[:password] */
                *(tmp++) = '\0';
                uri->host = tmp;
                uri->user = authority;
                if ( ( tmp = strchr ( authority, ':' ) ) ) {
                        /* Has password */
                        *(tmp++) = '\0';
                        uri->password = tmp;
                }
        } else {
                /* No user:password */
                uri->host = authority;
        }

        /* Split host into host[:port] */
        if ( ( tmp = strchr ( uri->host, ':' ) ) ) {
                *(tmp++) = '\0';
                uri->port = tmp;
        }

        /* Decode fields that should be decoded */
        for ( i = URI_FIRST_FIELD; i <= URI_LAST_FIELD; i++ ) {
                const char *field = uri_get_field ( uri, i );
                if ( field && ( URI_ENCODED & ( 1 << i ) ) )
                        uri_decode ( field, ( char * ) field,
                                     strlen ( field ) + 1 /* NUL */ );
        }

 done:
        DBG ( "URI \"%s\" split into", uri_string );
        dump_uri ( uri );
        DBG ( "\n" );

        return uri;
}

unsigned int uri_port	(	struct uri *	uri,
		unsigned int	default_port
	)

Get port from URI.

Parameters:

	uri	URI, or NULL
	default_port	Default port to use if none specified in URI

Return values:

port

Port

Definition at line 198 of file uri.c.

References NULL, uri::port, and strtoul().

Referenced by ftp_open(), http_open_filter(), slam_open(), tcp_open_uri(), tftp_core_open(), and udp_open_uri().

                                                                     {
        if ( ( ! uri ) || ( ! uri->port ) )
                return default_port;
        return ( strtoul ( uri->port, NULL, 0 ) );
}

int unparse_uri	(	char *	buf,
		size_t	size,
		struct uri *	uri,
		unsigned int	fields
	)

Unparse URI.

Parameters:

	buf	Buffer to fill with URI string
	size	Size of buffer
	uri	URI to write into buffer, or NULL
	fields	Bitmask of fields to include in URI string, or URI_ALL

Return values:

len

Length of URI string

Definition at line 213 of file uri.c.

References DBG, dump_uri(), ssnprintf(), uri_encode(), URI_ENCODED, URI_FIRST_FIELD, uri_get_field, URI_LAST_FIELD, URI_OPAQUE, and URI_SCHEME_BIT.

Referenced by http_step(), imgfetch(), test_parse_unparse(), test_resolve(), and uri_dup().

                                        {
        /* List of characters that typically go before certain fields */
        static char separators[] = { /* scheme */ 0, /* opaque */ ':',
                                     /* user */ 0, /* password */ ':',
                                     /* host */ '@', /* port */ ':',
                                     /* path */ 0, /* query */ '?',
                                     /* fragment */ '#' };
        int used = 0;
        int i;

        DBG ( "URI unparsing" );
        dump_uri ( uri );
        DBG ( "\n" );

        /* Ensure buffer is NUL-terminated */
        if ( size )
                buf[0] = '\0';

        /* Special-case NULL URI */
        if ( ! uri )
                return 0;

        /* Iterate through requested fields */
        for ( i = URI_FIRST_FIELD; i <= URI_LAST_FIELD; i++ ) {
                const char *field = uri_get_field ( uri, i );
                char sep = separators[i];

                /* Ensure `fields' only contains bits for fields that exist */
                if ( ! field )
                        fields &= ~( 1 << i );

                /* Store this field if we were asked to */
                if ( fields & ( 1 << i ) ) {
                        /* Print :// if we're non-opaque and had a scheme */
                        if ( ( fields & URI_SCHEME_BIT ) &&
                             ( i > URI_OPAQUE ) ) {
                                used += ssnprintf ( buf + used, size - used,
                                                    "://" );
                                /* Only print :// once */
                                fields &= ~URI_SCHEME_BIT;
                        }

                        /* Only print separator if an earlier field exists */
                        if ( sep && ( fields & ( ( 1 << i ) - 1 ) ) )
                                used += ssnprintf ( buf + used, size - used,
                                                    "%c", sep );

                        /* Print contents of field, possibly encoded */
                        if ( URI_ENCODED & ( 1 << i ) )
                                used += uri_encode ( field, buf + used,
                                                     size - used, i );
                        else
                                used += ssnprintf ( buf + used, size - used,
                                                    "%s", field );
                }
        }

        return used;
}

struct uri* uri_dup

(

struct uri *

uri

)

[read]

Duplicate URI.

Parameters:

uri

URI

Return values:

uri

Duplicate URI

Creates a modifiable copy of a URI.

Definition at line 282 of file uri.c.

References NULL, parse_uri(), unparse_uri(), and URI_ALL.

Referenced by resolve_uri().

                                         {
        size_t len = ( unparse_uri ( NULL, 0, uri, URI_ALL ) + 1 );
        char buf[len];

        unparse_uri ( buf, len, uri, URI_ALL );
        return parse_uri ( buf );
}

char* resolve_path	(	const char *	base_path,
		const char *	relative_path
	)

Resolve base+relative path.

Parameters:

	base_uri	Base path
	relative_uri	Relative path

Return values:

resolved_uri

Resolved path

Takes a base path (e.g. "/var/lib/tftpboot/vmlinuz" and a relative path (e.g. "initrd.gz") and produces a new path (e.g. "/var/lib/tftpboot/initrd.gz"). Note that any non-directory portion of the base path will automatically be stripped; this matches the semantics used when resolving the path component of URIs.

Definition at line 304 of file uri.c.

References asprintf(), dirname(), memcpy, NULL, strdup(), and strlen().

Referenced by resolve_uri().

                                                  {
        size_t base_len = ( strlen ( base_path ) + 1 );
        char base_path_copy[base_len];
        char *base_tmp = base_path_copy;
        char *resolved;

        /* If relative path is absolute, just re-use it */
        if ( relative_path[0] == '/' )
                return strdup ( relative_path );

        /* Create modifiable copy of path for dirname() */
        memcpy ( base_tmp, base_path, base_len );
        base_tmp = dirname ( base_tmp );

        /* Process "./" and "../" elements */
        while ( *relative_path == '.' ) {
                relative_path++;
                if ( *relative_path == 0 ) {
                        /* Do nothing */
                } else if ( *relative_path == '/' ) {
                        relative_path++;
                } else if ( *relative_path == '.' ) {
                        relative_path++;
                        if ( *relative_path == 0 ) {
                                base_tmp = dirname ( base_tmp );
                        } else if ( *relative_path == '/' ) {
                                base_tmp = dirname ( base_tmp );
                                relative_path++;
                        } else {
                                relative_path -= 2;
                                break;
                        }
                } else {
                        relative_path--;
                        break;
                }
        }

        /* Create and return new path */
        if ( asprintf ( &resolved, "%s%s%s", base_tmp,
                        ( ( base_tmp[ strlen ( base_tmp ) - 1 ] == '/' ) ?
                          "" : "/" ), relative_path ) < 0 )
                return NULL;

        return resolved;
}

struct uri* resolve_uri	(	struct uri *	base_uri,
		struct uri *	relative_uri
	)			[read]

Resolve base+relative URI.

Parameters:

	base_uri	Base URI, or NULL
	relative_uri	Relative URI

Return values:

resolved_uri

Resolved URI

Takes a base URI (e.g. "http://etherboot.org/kernels/vmlinuz" and a relative URI (e.g. "../initrds/initrd.gz") and produces a new URI (e.g. "http://etherboot.org/initrds/initrd.gz").

Definition at line 363 of file uri.c.

References uri::fragment, free(), memcpy, NULL, uri::path, uri::query, resolve_path(), uri_dup(), and uri_is_absolute().

Referenced by churi(), test_resolve(), and xfer_open_uri().

                                                      {
        struct uri tmp_uri;
        char *tmp_path = NULL;
        struct uri *new_uri;

        /* If relative URI is absolute, just re-use it */
        if ( uri_is_absolute ( relative_uri ) || ( ! base_uri ) )
                return uri_get ( relative_uri );

        /* Mangle URI */
        memcpy ( &tmp_uri, base_uri, sizeof ( tmp_uri ) );
        if ( relative_uri->path ) {
                tmp_path = resolve_path ( ( base_uri->path ?
                                            base_uri->path : "/" ),
                                          relative_uri->path );
                tmp_uri.path = tmp_path;
                tmp_uri.query = relative_uri->query;
                tmp_uri.fragment = relative_uri->fragment;
        } else if ( relative_uri->query ) {
                tmp_uri.query = relative_uri->query;
                tmp_uri.fragment = relative_uri->fragment;
        } else if ( relative_uri->fragment ) {
                tmp_uri.fragment = relative_uri->fragment;
        }

        /* Create demangled URI */
        new_uri = uri_dup ( &tmp_uri );
        free ( tmp_path );
        return new_uri;
}

static int is_unreserved_uri_char	(	int	c,
		int	field
	)			[static]

Test for unreserved URI characters.

Parameters:

	c	Character to test
	field	Field of URI in which character lies

Return values:

is_unreserved

Character is an unreserved character

Definition at line 402 of file uri.c.

References isdigit, islower, isupper, URI_OPAQUE, URI_PATH, and URI_QUERY.

Referenced by uri_encode().

                                                       {
        /* According to RFC3986, the unreserved character set is
         *
         * A-Z a-z 0-9 - _ . ~
         *
         * but we also pass & ; = in queries, / in paths,
         * and everything in opaques
         */
        int ok = ( isupper ( c ) || islower ( c ) || isdigit ( c ) ||
                    ( c == '-' ) || ( c == '_' ) ||
                    ( c == '.' ) || ( c == '~' ) );

        if ( field == URI_QUERY )
                ok = ok || ( c == ';' ) || ( c == '&' ) || ( c == '=' );

        if ( field == URI_PATH )
                ok = ok || ( c == '/' );

        if ( field == URI_OPAQUE )
                ok = 1;

        return ok;
}

size_t uri_encode	(	const char *	raw_string,
		char *	buf,
		ssize_t	len,
		int	field
	)

URI-encode string.

Parameters:

	raw_string	String to be URI-encoded
	buf	Buffer to contain encoded string
	len	Length of buffer
	field	Field of URI in which string lies

Return values:

len

Length of encoded string (excluding NUL)

Definition at line 435 of file uri.c.

References is_unreserved_uri_char(), and ssnprintf().

Referenced by boot_next_server_and_filename(), fetchf_uristring(), and unparse_uri().

                                {
        ssize_t remaining = len;
        size_t used;
        unsigned char c;

        if ( len > 0 )
                buf[0] = '\0';

        while ( ( c = *(raw_string++) ) ) {
                if ( is_unreserved_uri_char ( c, field ) ) {
                        used = ssnprintf ( buf, remaining, "%c", c );
                } else {
                        used = ssnprintf ( buf, remaining, "%%%02X", c );
                }
                buf += used;
                remaining -= used;
        }

        return ( len - remaining );
}

size_t uri_decode	(	const char *	encoded_string,
		char *	buf,
		ssize_t	len
	)

Decode URI-encoded string.

Parameters:

	encoded_string	URI-encoded string
	buf	Buffer to contain decoded string
	len	Length of buffer

Return values:

len

Length of decoded string (excluding NUL)

This function may be used in-place, with buf the same as encoded_string.

Definition at line 468 of file uri.c.

References snprintf(), and strtoul().

Referenced by parse_uri(), and storef_uristring().

                                                                         {
        ssize_t remaining;
        char hexbuf[3];
        char *hexbuf_end;
        unsigned char c;

        for ( remaining = len; *encoded_string; remaining-- ) {
                if ( *encoded_string == '%' ) {
                        encoded_string++;
                        snprintf ( hexbuf, sizeof ( hexbuf ), "%s",
                                   encoded_string );
                        c = strtoul ( hexbuf, &hexbuf_end, 16 );
                        encoded_string += ( hexbuf_end - hexbuf );
                } else {
                        c = *(encoded_string++);
                }
                if ( remaining > 1 )
                        *buf++ = c;
        }

        if ( len )
                *buf = 0;

        return ( len - remaining );
}