uri.h File Reference

Uniform Resource Identifiers. More...

#include <stddef.h>
#include <stdlib.h>
#include <ipxe/refcnt.h>
#include <ipxe/in.h>

Go to the source code of this file.

Data Structures
struct	uri
	A Uniform Resource Identifier. More...

Macros
#define	uri_field(uri, field)   (&uri->scheme)[field]
	Access URI field. More...
#define	URI_FIELD(name)
	Calculate index of a URI field. More...

Enumerations
enum	uri_fields {   URI_SCHEME = URI_FIELD ( scheme ), URI_OPAQUE = URI_FIELD ( opaque ), URI_USER = URI_FIELD ( user ), URI_PASSWORD = URI_FIELD ( password ),   URI_HOST = URI_FIELD ( host ), URI_PORT = URI_FIELD ( port ), URI_PATH = URI_FIELD ( path ), URI_EPATH = URI_FIELD ( epath ),   URI_EQUERY = URI_FIELD ( equery ), URI_EFRAGMENT = URI_FIELD ( efragment ), URI_FIELDS }
	URI fields. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	uri_is_absolute (const struct uri *uri)
	URI is an absolute URI. More...
static int	uri_has_opaque (const struct uri *uri)
	URI has an opaque part. More...
static int	uri_has_path (const struct uri *uri)
	URI has a path. More...
static int	uri_has_absolute_path (const struct uri *uri)
	URI has an absolute path. More...
static int	uri_has_relative_path (const struct uri *uri)
	URI has a relative path. More...
static struct uri *	uri_get (struct uri *uri)
	Increment URI reference count. More...
static void	uri_put (struct uri *uri)
	Decrement URI reference count. More...
size_t	uri_decode (const char *encoded, void *buf, size_t len)
	Decode URI field. More...
size_t	uri_encode (unsigned int field, const void *raw, size_t raw_len, char *buf, ssize_t len)
	Encode URI field. More...
size_t	uri_encode_string (unsigned int field, const char *string, char *buf, ssize_t len)
	Encode URI field string. More...
struct uri *	parse_uri (const char *uri_string)
	Parse URI. More...
size_t	format_uri (const struct uri *uri, char *buf, size_t len)
	Format URI. More...
char *	format_uri_alloc (const struct uri *uri)
	Format URI. More...
unsigned int	uri_port (const struct uri *uri, unsigned int default_port)
	Get port from URI. More...
struct uri *	uri_dup (const struct uri *uri)
	Duplicate URI. More...
char *	resolve_path (const char *base_path, const char *relative_path)
	Resolve base+relative path. More...
struct uri *	resolve_uri (const struct uri *base_uri, struct uri *relative_uri)
	Resolve base+relative URI. More...
struct uri *	pxe_uri (struct sockaddr *sa_server, const char *filename)
	Construct URI from server address and filename. More...
void	churi (struct uri *uri)
	Change working URI. More...

Variables
struct uri *	cwuri
	Current working URI. More...

Detailed Description

Uniform Resource Identifiers.

Definition in file uri.h.

Macro Definition Documentation

uri_field

#define uri_field	(		uri,
			field
	)		(&uri->scheme)[field]

Access URI field.

Parameters

uri	URI
field	URI field index

Return values

field

URI field (as an lvalue)

Definition at line 99 of file uri.h.

URI_FIELD

#define URI_FIELD

(

name

)

Value:

( ( offsetof ( struct uri, name ) -                             \
            offsetof ( struct uri, scheme ) ) / sizeof ( void * ) )

Calculate index of a URI field.

Parameters

name	URI field name

Return values

field

URI field index

Definition at line 107 of file uri.h.

Enumeration Type Documentation

uri_fields

enum uri_fields

URI fields.

Enumerator
URI_SCHEME
URI_OPAQUE
URI_USER
URI_PASSWORD
URI_HOST
URI_PORT
URI_PATH
URI_EPATH
URI_EQUERY
URI_EFRAGMENT
URI_FIELDS

Definition at line 112 of file uri.h.

                {
        URI_SCHEME = URI_FIELD ( scheme ),
        URI_OPAQUE = URI_FIELD ( opaque ),
        URI_USER = URI_FIELD ( user ),
        URI_PASSWORD = URI_FIELD ( password ),
        URI_HOST = URI_FIELD ( host ),
        URI_PORT = URI_FIELD ( port ),
        URI_PATH = URI_FIELD ( path ),
        URI_EPATH = URI_FIELD ( epath ),
        URI_EQUERY = URI_FIELD ( equery ),
        URI_EFRAGMENT = URI_FIELD ( efragment ),
        URI_FIELDS
};

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

uri_is_absolute()

static int uri_is_absolute ( const struct uri *  uri )

inlinestatic

URI is an absolute URI.

Parameters

uri

URI

Return values

is_absolute

URI is absolute

An absolute URI begins with a scheme, e.g. "http:" or "mailto:". Note that this is a separate concept from a URI with an absolute path.

Definition at line 136 of file uri.h.

                                                            {
        return ( uri->scheme != NULL );
}

References NULL, and uri::scheme.

Referenced by netboot(), pxe_uri(), and resolve_uri().

uri_has_opaque()

static int uri_has_opaque ( const struct uri *  uri )

inlinestatic

URI has an opaque part.

Parameters

uri

URI

Return values

has_opaque

URI has an opaque part

Definition at line 146 of file uri.h.

                                                           {
        return ( uri->opaque && ( uri->opaque[0] != '\0' ) );
}

References uri::opaque.

uri_has_path()

static int uri_has_path ( const struct uri *  uri )

inlinestatic

URI has a path.

Parameters

uri

URI

Return values

has_path

URI has a path

Definition at line 156 of file uri.h.

                                                         {
        return ( uri->path && ( uri->path[0] != '\0' ) );
}

References uri::path.

uri_has_absolute_path()

static int uri_has_absolute_path ( const struct uri *  uri )

inlinestatic

URI has an absolute path.

Parameters

uri

URI

Return values

has_absolute_path

URI has an absolute path

An absolute path begins with a '/'. Note that this is a separate concept from an absolute URI. Note also that a URI may not have a path at all.

Definition at line 170 of file uri.h.

                                                                  {
        return ( uri->path && ( uri->path[0] == '/' ) );
}

References uri::path.

uri_has_relative_path()

static int uri_has_relative_path ( const struct uri *  uri )

inlinestatic

URI has a relative path.

Parameters

uri

URI

Return values

has_relative_path

URI has a relative path

A relative path begins with something other than a '/'. Note that this is a separate concept from a relative URI. Note also that a URI may not have a path at all.

Definition at line 184 of file uri.h.

                                                                  {
        return ( uri->path && ( uri->path[0] != '/' ) );
}

References uri::path.

uri_get()

static struct uri* uri_get ( struct uri *  uri )

inlinestatic

Increment URI reference count.

Parameters

uri	URI, or NULL

Return values

uri	URI as passed in

Definition at line 195 of file uri.h.

                            {
        ref_get ( &uri->refcnt );
        return uri;
}

References ref_get, and uri::refcnt.

Referenced by alloc_sandev(), efi_local_open(), ftp_open(), http_connect(), http_open(), image_exec(), image_set_uri(), peerblk_open(), peermux_filter(), resolve_uri(), tftp_core_open(), and uri_churi_okx().

uri_put()

static void uri_put ( struct uri *  uri )

inlinestatic

Decrement URI reference count.

Parameters

uri	URI, or NULL

Definition at line 206 of file uri.h.

                            {
        ref_put ( &uri->refcnt );
}

References ref_put, and uri::refcnt.

Referenced by churi(), cwuri_fetch_uri(), efi_init_application(), efi_local_free(), efi_pxe_tftp_open(), free_image(), ftp_free(), http_conn_free(), http_free(), http_redirect(), image_exec(), image_set_uri(), imgdownload(), imgdownload_string(), netboot(), peerblk_free(), peerblk_retrieval_open(), peermux_free(), pxe_menu_boot(), pxe_uri(), sanboot_core_exec(), sandev_free(), tftp_apply_settings(), tftp_free(), uri_churi_okx(), uri_dup_okx(), uri_params_okx(), uri_parse_okx(), uri_port_okx(), uri_pxe_okx(), uri_resolve_okx(), xfer_open_uri(), and xfer_open_uri_string().

uri_decode()

size_t uri_decode	(	const char *	encoded,
		void *	buf,
		size_t	len
	)

Decode URI field.

Parameters

encoded	Encoded field
buf	Data buffer
len	Length

Return values

len	Length of data

URI decoding can never increase the length of a string; we can therefore safely decode in place.

Definition at line 54 of file uri.c.

                                                                 {
        uint8_t *out = buf;
        unsigned int count = 0;
        char hexbuf[3];
        char *hexbuf_end;
        char c;
        char decoded;
        unsigned int skip;

        /* Copy string, decoding escaped characters as necessary */
        while ( ( c = *(encoded++) ) ) {
                if ( c == '%' ) {
                        snprintf ( hexbuf, sizeof ( hexbuf ), "%s", encoded );
                        decoded = strtoul ( hexbuf, &hexbuf_end, 16 );
                        skip = ( hexbuf_end - hexbuf );
                        encoded += skip;
                        if ( skip )
                                c = decoded;
                }
                if ( count < len )
                        out[count] = c;
                count++;
        }
        return count;
}

References count, len, out, snprintf(), and strtoul().

Referenced by parse_uristring_setting(), and uri_decode_inplace().

uri_encode()

size_t uri_encode	(	unsigned int	field,
		const void *	raw,
		size_t	raw_len,
		char *	buf,
		ssize_t	len
	)

Encode URI field.

Parameters

field	URI field index
raw	Raw data
raw_len	Length of raw data
buf	Buffer
len	Length of buffer

Return values

len	Length of encoded string (excluding NUL)

Definition at line 201 of file uri.c.

                                             {
        const uint8_t *raw_bytes = ( ( const uint8_t * ) raw );
        ssize_t remaining = len;
        size_t used;
        char c;

        /* Ensure encoded string is NUL-terminated even if empty */
        if ( len > 0 )
                buf[0] = '\0';

        /* Copy string, escaping as necessary */
        while ( raw_len-- ) {
                c = *(raw_bytes++);
                if ( uri_character_escaped ( c, field ) ) {
                        used = ssnprintf ( buf, remaining, "%%%02X", c );
                } else {
                        used = ssnprintf ( buf, remaining, "%c", c );
                }
                buf += used;
                remaining -= used;
        }

        return ( len - remaining );
}

References len, raw, raw_len, ssnprintf(), and uri_character_escaped().

Referenced by format_uristring_setting(), ocsp_uri_string(), and uri_encode_string().

uri_encode_string()

size_t uri_encode_string	(	unsigned int	field,
		const char *	string,
		char *	buf,
		ssize_t	len
	)

Encode URI field string.

Parameters

field	URI field index
string	String
buf	Buffer
len	Length of buffer

Return values

len	Length of encoded string (excluding NUL)

Definition at line 236 of file uri.c.

                                                    {

        return uri_encode ( field, string, strlen ( string ), buf, len );
}

References len, strlen(), and uri_encode().

Referenced by format_uri(), and http_form_params().

parse_uri()

struct uri* parse_uri

(

const char *

uri_string

)

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 297 of file uri.c.

                                                  {
        struct uri *uri;
        struct parameters *params;
        char *raw;
        char *tmp;
        char *path;
        char *epath;
        char *authority;
        size_t raw_len;
        unsigned int field;

        /* Allocate space for URI struct and two copies of the string */
        raw_len = ( strlen ( uri_string ) + 1 /* NUL */ );
        uri = zalloc ( sizeof ( *uri ) + ( 2 * raw_len ) );
        if ( ! uri )
                return NULL;
        ref_init ( &uri->refcnt, uri_free );
        raw = ( ( ( void * ) uri ) + sizeof ( *uri ) );
        path = ( raw + raw_len );

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

        /* Identify the parameter list, if present */
        if ( ( tmp = strstr ( raw, "##params" ) ) ) {
                *tmp = '\0';
                tmp += 8 /* "##params" */;
                params = find_parameters ( *tmp ? ( tmp + 1 ) : NULL );
                if ( params ) {
                        uri->params = claim_parameters ( params );
                } else {
                        /* Ignore non-existent submission blocks */
                }
        }

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

        /* Identify absolute URIs */
        epath = raw;
        for ( tmp = raw ; ; tmp++ ) {
                /* Possible scheme character (for our URI schemes) */
                if ( isalpha ( *tmp ) || ( *tmp == '-' ) || ( *tmp == '_' ) )
                        continue;
                /* Invalid scheme character or NUL: is a relative URI */
                if ( *tmp != ':' )
                        break;
                /* Absolute URI: identify hierarchical/opaque */
                uri->scheme = raw;
                *(tmp++) = '\0';
                if ( *tmp == '/' ) {
                        /* Absolute URI with hierarchical part */
                        epath = tmp;
                } else {
                        /* Absolute URI with opaque part */
                        uri->opaque = tmp;
                        epath = NULL;
                }
                break;
        }

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

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

        /* If we have no path remaining, then we're already finished
         * processing.
         */
        if ( ! epath[0] )
                goto done;

        /* Identify net/absolute/relative path */
        if ( uri->scheme && ( strncmp ( epath, "//", 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 = ( epath + 2 );
                if ( ( tmp = strchr ( authority, '/' ) ) ) {
                        /* Shuffle down */
                        uri->epath = tmp;
                        memmove ( ( authority - 1 ), authority,
                                  ( tmp - authority ) );
                        authority--;
                        *(--tmp) = '\0';
                }
        } else {
                /* Absolute/relative path */
                uri->epath = epath;
                authority = NULL;
        }

        /* Create copy of path for decoding */
        if ( uri->epath ) {
                strcpy ( path, uri->epath );
                uri->path = path;
        }

        /* If we don't have an authority (i.e. we have a non-net
         * path), we're already finished processing
         */
        if ( ! authority )
                goto done;

        /* 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 = strrchr ( uri->host, ':' ) ) &&
             ( uri->host[ strlen ( uri->host ) - 1 ] != ']' ) ) {
                *(tmp++) = '\0';
                uri->port = tmp;
        }

 done:
        /* Decode fields in-place */
        for ( field = 0 ; field < URI_EPATH ; field++ )
                uri_decode_inplace ( ( char * ) uri_field ( uri, field ) );

        DBGC ( uri, "URI parsed \"%s\" to", uri_string );
        uri_dump ( uri );
        DBGC ( uri, "\n" );

        return uri;
}

References DBGC, done, uri::efragment, uri::epath, uri::equery, find_parameters(), uri::host, isalpha(), memcpy(), memmove(), NULL, uri::opaque, uri::params, uri::password, uri::path, uri::port, raw, raw_len, ref_init, uri::refcnt, uri::scheme, strchr(), strcpy(), strlen(), strncmp(), strrchr(), strstr(), tmp, uri_decode_inplace(), uri_dump(), URI_EPATH, uri_field, uri_free(), uri::user, and zalloc().

Referenced by cwuri_fetch_uri(), efi_path_uri(), fetch_root_path(), http_redirect(), imgdownload_string(), peerblk_retrieval_uri(), pxe_uri(), sanboot_core_exec(), tftp_apply_settings(), uri_churi_okx(), uri_params_okx(), uri_parse_okx(), uri_port_okx(), uri_resolve_okx(), and xfer_open_uri_string().

format_uri()

size_t format_uri	(	const struct uri *	uri,
		char *	buf,
		size_t	len
	)

Format URI.

Parameters

uri	URI
buf	Buffer to fill with URI string
size	Size of buffer

Return values

len	Length of URI string

Definition at line 472 of file uri.c.

                                                                   {
        static const char prefixes[URI_FIELDS] = {
                [URI_PASSWORD] = ':',
                [URI_PORT] = ':',
                [URI_EQUERY] = '?',
                [URI_EFRAGMENT] = '#',
        };
        char prefix;
        size_t used = 0;
        unsigned int field;

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

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

        /* Generate fields */
        for ( field = 0 ; field < URI_FIELDS ; field++ ) {

                /* Skip non-existent fields */
                if ( ! uri_field ( uri, field ) )
                        continue;

                /* Skip path field if encoded path is present */
                if ( ( field == URI_PATH ) && uri->epath )
                        continue;

                /* Prefix this field, if applicable */
                prefix = prefixes[field];
                if ( ( field == URI_HOST ) && ( uri->user != NULL ) )
                        prefix = '@';
                if ( prefix ) {
                        used += ssnprintf ( ( buf + used ), ( len - used ),
                                            "%c", prefix );
                }

                /* Encode this field */
                used += uri_encode_string ( field, uri_field ( uri, field ),
                                            ( buf + used ), ( len - used ) );

                /* Suffix this field, if applicable */
                if ( field == URI_SCHEME ) {
                        used += ssnprintf ( ( buf + used ), ( len - used ),
                                            ":%s", ( uri->host ? "//" : "" ) );
                }
        }

        if ( len ) {
                DBGC ( uri, "URI formatted" );
                uri_dump ( uri );
                DBGC ( uri, " to \"%s%s\"\n", buf,
                       ( ( used > len ) ? "<TRUNCATED>" : "" ) );
        }

        return used;
}

References DBGC, uri::epath, uri::host, len, NULL, prefix, ssnprintf(), uri_dump(), URI_EFRAGMENT, uri_encode_string(), URI_EQUERY, uri_field, URI_FIELDS, URI_HOST, URI_PASSWORD, URI_PATH, URI_PORT, URI_SCHEME, and uri::user.

Referenced by efi_uri_path(), format_uri_alloc(), http_open(), multiboot_add_cmdline(), uri_format_okx(), and uri_pxe_okx().

format_uri_alloc()

char* format_uri_alloc

(

const struct uri *

uri

)

Format URI.

Parameters

uri

URI

Return values

string

URI string, or NULL on failure

The caller is responsible for eventually freeing the allocated memory.

Definition at line 541 of file uri.c.

                                                  {
        size_t len;
        char *string;

        len = ( format_uri ( uri, NULL, 0 ) + 1 /* NUL */ );
        string = malloc ( len );
        if ( string )
                format_uri ( uri, string, len );
        return string;
}

References format_uri(), len, malloc(), NULL, and string.

Referenced by cwuri_fetch_uri(), imgdownload(), uri_churi_okx(), uri_format_okx(), and uri_resolve_okx().

uri_port()

unsigned int uri_port	(	const 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 456 of file uri.c.

                                                                           {

        if ( ( ! uri ) || ( ! uri->port ) )
                return default_port;

        return ( strtoul ( uri->port, NULL, 0 ) );
}

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

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

uri_dup()

struct uri* uri_dup

(

const struct uri *

uri

)

Duplicate URI.

Parameters

uri

URI

Return values

uri	Duplicate URI

Creates a modifiable copy of a URI.

Definition at line 595 of file uri.c.

                                               {
        struct uri *dup;
        size_t len;

        /* Allocate new URI */
        len = uri_copy_fields ( uri, NULL );
        dup = zalloc ( len );
        if ( ! dup )
                return NULL;
        ref_init ( &dup->refcnt, uri_free );

        /* Copy fields */
        uri_copy_fields ( uri, dup );

        /* Copy parameters */
        dup->params = params_get ( uri->params );

        DBGC ( uri, "URI duplicated" );
        uri_dump ( uri );
        DBGC ( uri, "\n" );

        return dup;
}

References DBGC, len, NULL, uri::params, ref_init, uri::refcnt, uri_copy_fields(), uri_dump(), uri_free(), and zalloc().

Referenced by resolve_uri(), tftp_uri(), uri_dup_okx(), and uri_params_okx().

resolve_path()

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, or NULL on failure

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 633 of file uri.c.

                                                  {
        char *base_copy;
        char *base_tmp;
        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() */
        base_copy = strdup ( base_path );
        if ( ! base_copy )
                return NULL;

        /* Strip filename portion of base path */
        base_tmp = dirname ( base_copy );

        /* 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 )
                resolved = NULL;
        free ( base_copy );
        return resolved;
}

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

Referenced by efi_local_open_path(), resolve_uri(), and uri_resolve_path_okx().

resolve_uri()

struct uri* resolve_uri	(	const struct uri *	base_uri,
		struct uri *	relative_uri
	)

Resolve base+relative URI.

Parameters

base_uri	Base URI, or NULL
relative_uri	Relative URI

Return values

resolved_uri

Resolved URI, or NULL on failure

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

Definition at line 695 of file uri.c.

                                                      {
        struct uri tmp_uri;
        char *tmp_epath = NULL;
        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->epath ) {
                tmp_epath = resolve_path ( ( base_uri->epath ?
                                             base_uri->epath : "/" ),
                                           relative_uri->epath );
                if ( ! tmp_epath )
                        goto err_epath;
                tmp_path = strdup ( tmp_epath );
                if ( ! tmp_path )
                        goto err_path;
                uri_decode_inplace ( tmp_path );
                tmp_uri.epath = tmp_epath;
                tmp_uri.path = tmp_path;
                tmp_uri.equery = relative_uri->equery;
                tmp_uri.efragment = relative_uri->efragment;
                tmp_uri.params = relative_uri->params;
        } else if ( relative_uri->equery ) {
                tmp_uri.equery = relative_uri->equery;
                tmp_uri.efragment = relative_uri->efragment;
                tmp_uri.params = relative_uri->params;
        } else if ( relative_uri->efragment ) {
                tmp_uri.efragment = relative_uri->efragment;
                tmp_uri.params = relative_uri->params;
        } else if ( relative_uri->params ) {
                tmp_uri.params = relative_uri->params;
        }

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

        free ( tmp_path );
 err_path:
        free ( tmp_epath );
 err_epath:
        return NULL;
}

References uri::efragment, uri::epath, uri::equery, free, memcpy(), NULL, uri::params, uri::path, resolve_path(), strdup(), uri_decode_inplace(), uri_dup(), uri_get(), and uri_is_absolute().

Referenced by churi(), cwuri_fetch_uri(), http_redirect(), imgdownload(), uri_resolve_okx(), and xfer_open_uri().

pxe_uri()

struct uri* pxe_uri	(	struct sockaddr *	sa_server,
		const char *	filename
	)

Construct URI from server address and filename.

Parameters

sa_server	Server address
filename	Filename

Return values

uri	URI, or NULL on failure

PXE TFTP filenames specified via the DHCP next-server field often contain characters such as ':' or '#' which would confuse the generic URI parser. We provide a mechanism for directly constructing a TFTP URI from the next-server and filename.

Definition at line 809 of file uri.c.

                                                                          {
        struct uri *uri;

        /* Fail if filename is empty */
        if ( ! ( filename && filename[0] ) )
                return NULL;

        /* If filename is a hierarchical absolute URI, then use that
         * URI.  (We accept only hierarchical absolute URIs, since PXE
         * filenames sometimes start with DOS drive letters such as
         * "C:\", which get misinterpreted as opaque absolute URIs.)
         */
        uri = parse_uri ( filename );
        if ( uri && uri_is_absolute ( uri ) && ( ! uri->opaque ) )
                return uri;
        uri_put ( uri );

        /* Otherwise, construct a TFTP URI directly */
        return tftp_uri ( sa_server, filename );
}

References NULL, uri::opaque, parse_uri(), tftp_uri(), uri_is_absolute(), and uri_put().

Referenced by efi_pxe_tftp_open(), fetch_next_server_and_filename(), pxe_tftp_open(), and uri_pxe_okx().

churi()

void churi

(

struct uri *

uri

)

Change working URI.

Parameters

uri	New working URI, or NULL

Definition at line 46 of file cwuri.c.

                               {
        struct uri *new_uri = NULL;

        if ( uri )
                new_uri = resolve_uri ( cwuri, uri );

        uri_put ( cwuri );
        cwuri = new_uri;
}

References cwuri, NULL, resolve_uri(), and uri_put().

Referenced by efi_init_application(), image_exec(), tftp_apply_settings(), and uri_churi_okx().

Variable Documentation

cwuri

struct uri* cwuri

Current working URI.

Definition at line 39 of file cwuri.c.

Referenced by churi(), cwuri_fetch_uri(), efi_autoexec_network(), image_exec(), imgdownload(), uri_churi_okx(), and xfer_open_uri().