Uniform Resource Identifiers. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <libgen.h>
#include <ctype.h>
#include <ipxe/vsprintf.h>
#include <ipxe/params.h>
#include <ipxe/tcpip.h>
#include <ipxe/uri.h>

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)

	FILE_SECBOOT (PERMITTED)

size_t	uri_decode (const char encoded, void buf, size_t len)
	Decode URI field. More...

static void	uri_decode_inplace (char *encoded)
	Decode URI field in-place. More...

static int	uri_character_escaped (char c, unsigned int field)
	Check if character should be escaped within a 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...

static void	uri_dump (const struct uri *uri)
	Dump URI for debugging. More...

static void	uri_free (struct refcnt *refcnt)
	Free URI. More...

struct uri *	parse_uri (const char *uri_string)
	Parse URI. More...

unsigned int	uri_port (const struct uri *uri, unsigned int default_port)
	Get port from 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...

static size_t	uri_copy_fields (const struct uri src, struct uri dest)
	Copy URI fields. 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...

static struct uri *	tftp_uri (struct sockaddr sa_server, const char filename)
	Construct TFTP URI from server address and filename. More...

struct uri *	pxe_uri (struct sockaddr sa_server, const char filename)
	Construct URI from server address and filename. More...

Detailed Description

Uniform Resource Identifiers.

Definition in file uri.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ 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_decode_inplace()

static void uri_decode_inplace ( char * encoded )

static

Decode URI field in-place.

Parameters

encoded Encoded field, or NULL

Definition at line 85 of file uri.c.

                                                  {
         char *decoded = encoded;
         size_t len;
 
         /* Do nothing if field is not present */
         if ( ! encoded )
                 return;
 
         /* Decode field in place */
         len = uri_decode ( encoded, decoded, strlen ( encoded ) );
 
         /* Terminate decoded string */
         decoded[len] = '\0';
 }

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

Referenced by parse_uri(), and resolve_uri().

◆ uri_character_escaped()

static int uri_character_escaped	(	char	c,
		unsigned int	field
	)

static

Check if character should be escaped within a URI field.

Parameters

c	Character
field	URI field index

Return values

escaped Character should be escaped

Definition at line 107 of file uri.c.

                                                                 {
 
         /* Non-printing characters and whitespace should always be
          * escaped, since they cannot sensibly be displayed as part of
          * a coherent URL string.  (This test also catches control
          * characters such as CR and LF, which could affect the
          * operation of line-based protocols such as HTTP.)
          *
          * We should also escape characters which would alter the
          * interpretation of the URL if not escaped, i.e. characters
          * which have significance to the URL parser.  We should not
          * blindly escape all such characters, because this would lead
          * to some very strange-looking URLs (e.g. if we were to
          * always escape '/' as "%2F" even within the URI path).
          *
          * We do not need to be perfect.  Our primary role is as a
          * consumer of URIs rather than a producer; the main situation
          * in which we produce a URI string is for display to a human
          * user, who can probably tolerate some variance from the
          * formal specification.  The only situation in which we
          * currently produce a URI string to be consumed by a computer
          * is when constructing an HTTP request URI, which contains
          * only the path and query fields.
          *
          * We can therefore sacrifice some correctness for the sake of
          * code size.  For example, colons within the URI host should
          * be escaped unless they form part of an IPv6 literal
          * address; doing this correctly would require the URI
          * formatter to be aware of whether or not the URI host
          * contained an IPv4 address, an IPv6 address, or a host name.
          * We choose to simplify and never escape colons within the
          * URI host field: in the event of a pathological hostname
          * containing colons, this could potentially produce a URI
          * string which could not be reparsed.
          *
          * After excluding non-printing characters, whitespace, and
          * '%', the full set of characters with significance to the
          * URL parser is "/#:@?".  We choose for each URI field which
          * of these require escaping in our use cases.
          *
          * For the scheme field (equivalently, if field is zero), we
          * escape anything that has significance not just for our URI
          * parser but for any other URI parsers (e.g. HTTP query
          * string parsers, which care about '=' and '&').
          */
         static const char *escaped[URI_EPATH] = {
                 /* Scheme or default: escape everything */
                 [URI_SCHEME]    = "/#:@?=&",
                 /* Opaque part: escape characters which would affect
                  * the reparsing of the URI, allowing everything else
                  * (e.g. ':', which will appear in iSCSI URIs).
                  */
                 [URI_OPAQUE]    = "#",
                 /* User name: escape everything */
                 [URI_USER]      = "/#:@?",
                 /* Password: escape everything */
                 [URI_PASSWORD]  = "/#:@?",
                 /* Host name: escape everything except ':', which may
                  * appear as part of an IPv6 literal address.
                  */
                 [URI_HOST]      = "/#@?",
                 /* Port number: escape everything */
                 [URI_PORT]      = "/#:@?",
                 /* Path: escape everything except '/', which usually
                  * appears within paths.
                  */
                 [URI_PATH]      = "#:@?",
         };
 
         /* Always escape non-printing characters and whitespace */
         if ( ( ! isprint ( c ) ) || ( c == ' ' ) )
                 return 1;
 
         /* Escape nothing else in already-escaped fields */
         if ( field >= URI_EPATH )
                 return 0;
 
         /* Escape '%' and any field-specific characters */
         if ( ( c == '%' ) || strchr ( escaped[field], c ) )
                 return 1;
 
         return 0;
 }

References isprint(), strchr(), URI_EPATH, URI_HOST, URI_OPAQUE, URI_PASSWORD, URI_PATH, URI_PORT, URI_SCHEME, and URI_USER.

Referenced by uri_encode().

◆ 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().

◆ uri_dump()

static void uri_dump ( const struct uri * uri )

static

Dump URI for debugging.

Parameters

uri URI

Definition at line 247 of file uri.c.

                                                {
 
         if ( ! uri )
                 return;
         if ( uri->scheme )
                 DBGC ( uri, " scheme \"%s\"", uri->scheme );
         if ( uri->opaque )
                 DBGC ( uri, " opaque \"%s\"", uri->opaque );
         if ( uri->user )
                 DBGC ( uri, " user \"%s\"", uri->user );
         if ( uri->password )
                 DBGC ( uri, " password \"%s\"", uri->password );
         if ( uri->host )
                 DBGC ( uri, " host \"%s\"", uri->host );
         if ( uri->port )
                 DBGC ( uri, " port \"%s\"", uri->port );
         if ( uri->path )
                 DBGC ( uri, " path \"%s\"", uri->path );
         if ( uri->epath )
                 DBGC ( uri, " epath \"%s\"", uri->epath );
         if ( uri->equery )
                 DBGC ( uri, " equery \"%s\"", uri->equery );
         if ( uri->efragment )
                 DBGC ( uri, " efragment \"%s\"", uri->efragment );
         if ( uri->params )
                 DBGC ( uri, " params \"%s\"", uri->params->name );
 }

References DBGC, uri::efragment, uri::epath, uri::equery, uri::host, parameters::name, uri::opaque, uri::params, uri::password, uri::path, uri::port, uri::scheme, and uri::user.

Referenced by format_uri(), parse_uri(), and uri_dup().

◆ uri_free()

static void uri_free ( struct refcnt * refcnt )

static

Free URI.

Parameters

refcnt Reference count

Definition at line 280 of file uri.c.

                                                {
         struct uri *uri = container_of ( refcnt, struct uri, refcnt );
 
         params_put ( uri->params );
         free ( uri );
 }

References container_of, free, and uri::params.

Referenced by parse_uri(), and uri_dup().

◆ 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().

◆ 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().

◆ 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_copy_fields()

static size_t uri_copy_fields	(	const struct uri *	src,
		struct uri *	dest
	)

static

Copy URI fields.

Parameters

src	Source URI
dest	Destination URI, or NULL to calculate length

Return values

len	Length of raw URI

Definition at line 559 of file uri.c.

                                                                           {
         size_t len = sizeof ( *dest );
         char *out = ( ( void * ) dest + len );
         unsigned int field;
         size_t field_len;
 
         /* Copy existent fields */
         for ( field = 0 ; field < URI_FIELDS ; field++ ) {
 
                 /* Skip non-existent fields */
                 if ( ! uri_field ( src, field ) )
                         continue;
 
                 /* Calculate field length */
                 field_len = ( strlen ( uri_field ( src, field ) )
                               + 1 /* NUL */ );
                 len += field_len;
 
                 /* Copy field, if applicable */
                 if ( dest ) {
                         memcpy ( out, uri_field ( src, field ), field_len );
                         uri_field ( dest, field ) = out;
                         out += field_len;
                 }
         }
         return len;
 }

References dest, len, memcpy(), out, src, strlen(), uri_field, and URI_FIELDS.

Referenced by uri_dup().

◆ 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().

◆ tftp_uri()

static struct uri* tftp_uri	(	struct sockaddr *	sa_server,
		const char *	filename
	)

static

Construct TFTP URI from server address and filename.

Parameters

sa_server	Server address
filename	Filename

Return values

uri	URI, or NULL on failure

Definition at line 754 of file uri.c.

                                                       {
         struct sockaddr_tcpip *st_server =
                 ( ( struct sockaddr_tcpip * ) sa_server );
         char buf[ 6 /* "65535" + NUL */ ];
         char *path;
         struct uri tmp;
         struct uri *uri = NULL;
 
         /* Initialise TFTP URI */
         memset ( &tmp, 0, sizeof ( tmp ) );
         tmp.scheme = "tftp";
 
         /* Construct TFTP server address */
         tmp.host = sock_ntoa ( sa_server );
         if ( ! tmp.host )
                 goto err_host;
 
         /* Construct TFTP server port, if applicable */
         if ( st_server->st_port ) {
                 snprintf ( buf, sizeof ( buf ), "%d",
                            ntohs ( st_server->st_port ) );
                 tmp.port = buf;
         }
 
         /* Construct TFTP path */
         if ( asprintf ( &path, "/%s", filename ) < 0 )
                 goto err_path;
         tmp.path = path;
         tmp.epath = path;
 
         /* Demangle URI */
         uri = uri_dup ( &tmp );
         if ( ! uri )
                 goto err_uri;
 
  err_uri:
         free ( path );
  err_path:
  err_host:
         return uri;
 }

References asprintf(), free, memset(), ntohs, NULL, uri::path, snprintf(), sock_ntoa(), sockaddr_tcpip::st_port, tmp, and uri_dup().

Referenced by pxe_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().

Functions

Detailed Description

Function Documentation

◆ FILE_LICENCE()

◆ FILE_SECBOOT()

◆ uri_decode()

◆ uri_decode_inplace()

◆ uri_character_escaped()

◆ uri_encode()

◆ uri_encode_string()

◆ uri_dump()

◆ uri_free()

◆ parse_uri()

◆ uri_port()

◆ format_uri()

◆ format_uri_alloc()

◆ uri_copy_fields()

◆ uri_dup()

◆ resolve_path()

◆ resolve_uri()

◆ tftp_uri()

◆ pxe_uri()