iPXE
Data Structures | Macros | Enumerations | Functions | Variables
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_QUERY = URI_FIELD ( query ),
  URI_FRAGMENT = URI_FIELD ( fragment ), URI_FIELDS
}
 URI fields. More...
 

Functions

 FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
 
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 uriuri_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 uriparse_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 uriuri_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 uriresolve_uri (const struct uri *base_uri, struct uri *relative_uri)
 Resolve base+relative URI. More...
 
struct uripxe_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 uricwuri
 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
uriURI
fieldURI field index
Return values
fieldURI field (as an lvalue)

Definition at line 82 of file uri.h.

◆ URI_FIELD

#define URI_FIELD (   name)
Value:
( ( offsetof ( struct uri, name ) - \
offsetof ( struct uri, scheme ) ) / sizeof ( void * ) )
const char * name
Definition: ath9k_hw.c:1984
#define offsetof(type, field)
Get offset of a field within a structure.
Definition: stddef.h:24
A Uniform Resource Identifier.
Definition: uri.h:50

Calculate index of a URI field.

Parameters
nameURI field name
Return values
fieldURI field index

Definition at line 90 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_QUERY 
URI_FRAGMENT 
URI_FIELDS 

Definition at line 95 of file uri.h.

95  {
96  URI_SCHEME = URI_FIELD ( scheme ),
97  URI_OPAQUE = URI_FIELD ( opaque ),
98  URI_USER = URI_FIELD ( user ),
99  URI_PASSWORD = URI_FIELD ( password ),
100  URI_HOST = URI_FIELD ( host ),
101  URI_PORT = URI_FIELD ( port ),
102  URI_PATH = URI_FIELD ( path ),
103  URI_QUERY = URI_FIELD ( query ),
105  URI_FIELDS
106 };
Definition: uri.h:100
Definition: uri.h:96
#define URI_FIELD(name)
Calculate index of a URI field.
Definition: uri.h:90
A fragment reassembly buffer.
Definition: fragment.h:21
Definition: uri.h:101
Definition: uri.h:102
u8 port
Port number.
Definition: CIB_PRM.h:31
struct ntlm_data user
User name.
Definition: ntlm.h:20
Definition: uri.h:97
Definition: uri.h:98
Definition: uri.h:103

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL  )

◆ uri_is_absolute()

static int uri_is_absolute ( const struct uri uri)
inlinestatic

URI is an absolute URI.

Parameters
uriURI
Return values
is_absoluteURI 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 118 of file uri.h.

118  {
119  return ( uri->scheme != NULL );
120 }
const char * scheme
Scheme.
Definition: uri.h:54
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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
uriURI
Return values
has_opaqueURI has an opaque part

Definition at line 128 of file uri.h.

128  {
129  return ( uri->opaque && ( uri->opaque[0] != '\0' ) );
130 }
const char * opaque
Opaque part.
Definition: uri.h:56
A Uniform Resource Identifier.
Definition: uri.h:50

References uri::opaque.

◆ uri_has_path()

static int uri_has_path ( const struct uri uri)
inlinestatic

URI has a path.

Parameters
uriURI
Return values
has_pathURI has a path

Definition at line 138 of file uri.h.

138  {
139  return ( uri->path && ( uri->path[0] != '\0' ) );
140 }
const char * path
Path.
Definition: uri.h:66
A Uniform Resource Identifier.
Definition: uri.h:50

References uri::path.

◆ uri_has_absolute_path()

static int uri_has_absolute_path ( const struct uri uri)
inlinestatic

URI has an absolute path.

Parameters
uriURI
Return values
has_absolute_pathURI 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 152 of file uri.h.

152  {
153  return ( uri->path && ( uri->path[0] == '/' ) );
154 }
const char * path
Path.
Definition: uri.h:66
A Uniform Resource Identifier.
Definition: uri.h:50

References uri::path.

◆ uri_has_relative_path()

static int uri_has_relative_path ( const struct uri uri)
inlinestatic

URI has a relative path.

Parameters
uriURI
Return values
has_relative_pathURI 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 166 of file uri.h.

166  {
167  return ( uri->path && ( uri->path[0] != '/' ) );
168 }
const char * path
Path.
Definition: uri.h:66
A Uniform Resource Identifier.
Definition: uri.h:50

References uri::path.

◆ uri_get()

static struct uri* uri_get ( struct uri uri)
inlinestatic

Increment URI reference count.

Parameters
uriURI, or NULL
Return values
uriURI as passed in

Definition at line 177 of file uri.h.

177  {
178  ref_get ( &uri->refcnt );
179  return uri;
180 }
#define ref_get(refcnt)
Get additional reference to object.
Definition: refcnt.h:92
struct refcnt refcnt
Reference count.
Definition: uri.h:52
A Uniform Resource Identifier.
Definition: uri.h:50

References ref_get, and uri::refcnt.

Referenced by alloc_sandev(), 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
uriURI, or NULL

Definition at line 188 of file uri.h.

188  {
189  ref_put ( &uri->refcnt );
190 }
struct refcnt refcnt
Reference count.
Definition: uri.h:52
A Uniform Resource Identifier.
Definition: uri.h:50
#define ref_put(refcnt)
Drop reference to object.
Definition: refcnt.h:106

References ref_put, and uri::refcnt.

Referenced by churi(), 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
encodedEncoded field
bufData buffer
lenLength
Return values
lenLength of data

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

Definition at line 53 of file uri.c.

53  {
54  uint8_t *out = buf;
55  unsigned int count = 0;
56  char hexbuf[3];
57  char *hexbuf_end;
58  char c;
59  char decoded;
60  unsigned int skip;
61 
62  /* Copy string, decoding escaped characters as necessary */
63  while ( ( c = *(encoded++) ) ) {
64  if ( c == '%' ) {
65  snprintf ( hexbuf, sizeof ( hexbuf ), "%s", encoded );
66  decoded = strtoul ( hexbuf, &hexbuf_end, 16 );
67  skip = ( hexbuf_end - hexbuf );
68  encoded += skip;
69  if ( skip )
70  c = decoded;
71  }
72  if ( count < len )
73  out[count] = c;
74  count++;
75  }
76  return count;
77 }
unsigned long strtoul(const char *string, char **endp, int base)
Convert string to numeric value.
Definition: string.c:441
static __always_inline void off_t int c
Definition: efi_uaccess.h:87
__be32 out[4]
Definition: CIB_PRM.h:36
unsigned char uint8_t
Definition: stdint.h:10
uint32_t len
Length.
Definition: ena.h:14
uint16_t count
Number of entries.
Definition: ena.h:22
int snprintf(char *buf, size_t size, const char *fmt,...)
Write a formatted string to a buffer.
Definition: vsprintf.c:382

References c, 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
fieldURI field index
rawRaw data
raw_lenLength of raw data
bufBuffer
lenLength of buffer
Return values
lenLength of encoded string (excluding NUL)

Definition at line 201 of file uri.c.

202  {
203  const uint8_t *raw_bytes = ( ( const uint8_t * ) raw );
204  ssize_t remaining = len;
205  size_t used;
206  char c;
207 
208  /* Ensure encoded string is NUL-terminated even if empty */
209  if ( len > 0 )
210  buf[0] = '\0';
211 
212  /* Copy string, escaping as necessary */
213  while ( raw_len-- ) {
214  c = *(raw_bytes++);
215  if ( uri_character_escaped ( c, field ) ) {
216  used = ssnprintf ( buf, remaining, "%%%02X", c );
217  } else {
218  used = ssnprintf ( buf, remaining, "%c", c );
219  }
220  buf += used;
221  remaining -= used;
222  }
223 
224  return ( len - remaining );
225 }
static __always_inline void off_t int c
Definition: efi_uaccess.h:87
int ssnprintf(char *buf, ssize_t ssize, const char *fmt,...)
Version of vsnprintf() that accepts a signed buffer size.
Definition: vsprintf.c:420
static size_t raw_len
Definition: base16.h:50
static int uri_character_escaped(char c, unsigned int field)
Check if character should be escaped within a URI field.
Definition: uri.c:108
unsigned char uint8_t
Definition: stdint.h:10
uint32_t len
Length.
Definition: ena.h:14
__be32 raw[7]
Definition: CIB_PRM.h:28
signed long ssize_t
Definition: stdint.h:7

References c, 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
fieldURI field index
stringString
bufBuffer
lenLength of buffer
Return values
lenLength of encoded string (excluding NUL)

Definition at line 236 of file uri.c.

237  {
238 
239  return uri_encode ( field, string, strlen ( string ), buf, len );
240 }
size_t uri_encode(unsigned int field, const void *raw, size_t raw_len, char *buf, ssize_t len)
Encode URI field.
Definition: uri.c:201
size_t strlen(const char *src)
Get length of string.
Definition: string.c:213
uint32_t len
Length.
Definition: ena.h:14

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

Referenced by format_uri(), and http_params().

◆ parse_uri()

struct uri* parse_uri ( const char *  uri_string)

Parse URI.

Parameters
uri_stringURI as a string
Return values
uriURI

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

295  {
296  struct uri *uri;
297  struct parameters *params;
298  char *raw;
299  char *tmp;
300  char *path;
301  char *authority;
302  size_t raw_len;
303  unsigned int field;
304 
305  /* Allocate space for URI struct and a copy of the string */
306  raw_len = ( strlen ( uri_string ) + 1 /* NUL */ );
307  uri = zalloc ( sizeof ( *uri ) + raw_len );
308  if ( ! uri )
309  return NULL;
310  ref_init ( &uri->refcnt, uri_free );
311  raw = ( ( ( void * ) uri ) + sizeof ( *uri ) );
312 
313  /* Copy in the raw string */
314  memcpy ( raw, uri_string, raw_len );
315 
316  /* Identify the parameter list, if present */
317  if ( ( tmp = strstr ( raw, "##params" ) ) ) {
318  *tmp = '\0';
319  tmp += 8 /* "##params" */;
320  params = find_parameters ( *tmp ? ( tmp + 1 ) : NULL );
321  if ( params ) {
322  uri->params = claim_parameters ( params );
323  } else {
324  /* Ignore non-existent submission blocks */
325  }
326  }
327 
328  /* Chop off the fragment, if it exists */
329  if ( ( tmp = strchr ( raw, '#' ) ) ) {
330  *(tmp++) = '\0';
331  uri->fragment = tmp;
332  }
333 
334  /* Identify absolute/relative URI */
335  if ( ( tmp = strchr ( raw, ':' ) ) ) {
336  /* Absolute URI: identify hierarchical/opaque */
337  uri->scheme = raw;
338  *(tmp++) = '\0';
339  if ( *tmp == '/' ) {
340  /* Absolute URI with hierarchical part */
341  path = tmp;
342  } else {
343  /* Absolute URI with opaque part */
344  uri->opaque = tmp;
345  path = NULL;
346  }
347  } else {
348  /* Relative URI */
349  path = raw;
350  }
351 
352  /* If we don't have a path (i.e. we have an absolute URI with
353  * an opaque portion, we're already finished processing
354  */
355  if ( ! path )
356  goto done;
357 
358  /* Chop off the query, if it exists */
359  if ( ( tmp = strchr ( path, '?' ) ) ) {
360  *(tmp++) = '\0';
361  uri->query = tmp;
362  }
363 
364  /* If we have no path remaining, then we're already finished
365  * processing.
366  */
367  if ( ! path[0] )
368  goto done;
369 
370  /* Identify net/absolute/relative path */
371  if ( uri->scheme && ( strncmp ( path, "//", 2 ) == 0 ) ) {
372  /* Net path. If this is terminated by the first '/'
373  * of an absolute path, then we have no space for a
374  * terminator after the authority field, so shuffle
375  * the authority down by one byte, overwriting one of
376  * the two slashes.
377  */
378  authority = ( path + 2 );
379  if ( ( tmp = strchr ( authority, '/' ) ) ) {
380  /* Shuffle down */
381  uri->path = tmp;
382  memmove ( ( authority - 1 ), authority,
383  ( tmp - authority ) );
384  authority--;
385  *(--tmp) = '\0';
386  }
387  } else {
388  /* Absolute/relative path */
389  uri->path = path;
390  authority = NULL;
391  }
392 
393  /* If we don't have an authority (i.e. we have a non-net
394  * path), we're already finished processing
395  */
396  if ( ! authority )
397  goto done;
398 
399  /* Split authority into user[:password] and host[:port] portions */
400  if ( ( tmp = strchr ( authority, '@' ) ) ) {
401  /* Has user[:password] */
402  *(tmp++) = '\0';
403  uri->host = tmp;
404  uri->user = authority;
405  if ( ( tmp = strchr ( authority, ':' ) ) ) {
406  /* Has password */
407  *(tmp++) = '\0';
408  uri->password = tmp;
409  }
410  } else {
411  /* No user:password */
412  uri->host = authority;
413  }
414 
415  /* Split host into host[:port] */
416  if ( ( uri->host[ strlen ( uri->host ) - 1 ] != ']' ) &&
417  ( tmp = strrchr ( uri->host, ':' ) ) ) {
418  *(tmp++) = '\0';
419  uri->port = tmp;
420  }
421 
422  done:
423  /* Decode fields in-place */
424  for ( field = 0 ; field < URI_FIELDS ; field++ )
425  uri_decode_inplace ( uri, field );
426 
427  DBGC ( uri, "URI parsed \"%s\" to", uri_string );
428  uri_dump ( uri );
429  DBGC ( uri, "\n" );
430 
431  return uri;
432 }
static void uri_dump(const struct uri *uri)
Dump URI for debugging.
Definition: uri.c:247
char * strrchr(const char *src, int character)
Find rightmost character within a string.
Definition: string.c:259
#define ref_init(refcnt, free)
Initialise a reference counter.
Definition: refcnt.h:64
A form parameter list.
Definition: params.h:16
#define DBGC(...)
Definition: compiler.h:505
struct parameters * find_parameters(const char *name)
Find form parameter list by name.
Definition: params.c:68
int strncmp(const char *first, const char *second, size_t max)
Compare strings.
Definition: string.c:170
const char * port
Port number.
Definition: uri.h:64
char * strstr(const char *haystack, const char *needle)
Find substring.
Definition: string.c:279
const char * scheme
Scheme.
Definition: uri.h:54
void * memcpy(void *dest, const void *src, size_t len) __nonnull
const char * path
Path.
Definition: uri.h:66
struct parameters * params
Form parameters.
Definition: uri.h:72
static size_t raw_len
Definition: base16.h:50
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
char * strchr(const char *src, int character)
Find character within a string.
Definition: string.c:241
uint8_t * tmp
Definition: entropy.h:156
size_t strlen(const char *src)
Get length of string.
Definition: string.c:213
const char * host
Host name.
Definition: uri.h:62
void * memmove(void *dest, const void *src, size_t len) __nonnull
static void uri_decode_inplace(struct uri *uri, unsigned int field)
Decode URI field in-place.
Definition: uri.c:85
const char * query
Query.
Definition: uri.h:68
const char * opaque
Opaque part.
Definition: uri.h:56
const char * fragment
Fragment.
Definition: uri.h:70
struct refcnt refcnt
Reference count.
Definition: uri.h:52
static void uri_free(struct refcnt *refcnt)
Free URI.
Definition: uri.c:278
const char * password
Password.
Definition: uri.h:60
__be32 raw[7]
Definition: CIB_PRM.h:28
const char * user
User name.
Definition: uri.h:58
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
struct bofm_section_header done
Definition: bofm_test.c:46

References DBGC, done, find_parameters(), uri::fragment, uri::host, memcpy(), memmove(), NULL, uri::opaque, uri::params, uri::password, uri::path, uri::port, uri::query, raw, raw_len, ref_init, uri::refcnt, uri::scheme, strchr(), strlen(), strncmp(), strrchr(), strstr(), tmp, uri_decode_inplace(), uri_dump(), URI_FIELDS, uri_free(), uri::user, and zalloc().

Referenced by 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
uriURI
bufBuffer to fill with URI string
sizeSize of buffer
Return values
lenLength of URI string

Definition at line 457 of file uri.c.

457  {
458  static const char prefixes[URI_FIELDS] = {
459  [URI_PASSWORD] = ':',
460  [URI_PORT] = ':',
461  [URI_QUERY] = '?',
462  [URI_FRAGMENT] = '#',
463  };
464  char prefix;
465  size_t used = 0;
466  unsigned int field;
467 
468  /* Ensure buffer is NUL-terminated */
469  if ( len )
470  buf[0] = '\0';
471 
472  /* Special-case NULL URI */
473  if ( ! uri )
474  return 0;
475 
476  /* Generate fields */
477  for ( field = 0 ; field < URI_FIELDS ; field++ ) {
478 
479  /* Skip non-existent fields */
480  if ( ! uri_field ( uri, field ) )
481  continue;
482 
483  /* Prefix this field, if applicable */
484  prefix = prefixes[field];
485  if ( ( field == URI_HOST ) && ( uri->user != NULL ) )
486  prefix = '@';
487  if ( prefix ) {
488  used += ssnprintf ( ( buf + used ), ( len - used ),
489  "%c", prefix );
490  }
491 
492  /* Encode this field */
493  used += uri_encode_string ( field, uri_field ( uri, field ),
494  ( buf + used ), ( len - used ) );
495 
496  /* Suffix this field, if applicable */
497  if ( field == URI_SCHEME ) {
498  used += ssnprintf ( ( buf + used ), ( len - used ),
499  ":%s", ( uri->host ? "//" : "" ) );
500  }
501  }
502 
503  if ( len ) {
504  DBGC ( uri, "URI formatted" );
505  uri_dump ( uri );
506  DBGC ( uri, " to \"%s%s\"\n", buf,
507  ( ( used > len ) ? "<TRUNCATED>" : "" ) );
508  }
509 
510  return used;
511 }
Definition: uri.h:100
Definition: uri.h:96
size_t uri_encode_string(unsigned int field, const char *string, char *buf, ssize_t len)
Encode URI field string.
Definition: uri.c:236
static void uri_dump(const struct uri *uri)
Dump URI for debugging.
Definition: uri.c:247
#define DBGC(...)
Definition: compiler.h:505
char prefix[4]
Definition: vmconsole.c:53
Definition: uri.h:101
int ssnprintf(char *buf, ssize_t ssize, const char *fmt,...)
Version of vsnprintf() that accepts a signed buffer size.
Definition: vsprintf.c:420
const char * host
Host name.
Definition: uri.h:62
Definition: uri.h:103
uint32_t len
Length.
Definition: ena.h:14
#define uri_field(uri, field)
Access URI field.
Definition: uri.h:82
const char * user
User name.
Definition: uri.h:58
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

References DBGC, uri::host, len, NULL, prefix, ssnprintf(), uri_dump(), uri_encode_string(), uri_field, URI_FIELDS, URI_FRAGMENT, URI_HOST, URI_PASSWORD, URI_PORT, URI_QUERY, URI_SCHEME, and uri::user.

Referenced by efi_block_hook(), 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
uriURI
Return values
stringURI string, or NULL on failure

The caller is responsible for eventually freeing the allocated memory.

Definition at line 522 of file uri.c.

522  {
523  size_t len;
524  char *string;
525 
526  len = ( format_uri ( uri, NULL, 0 ) + 1 /* NUL */ );
527  string = malloc ( len );
528  if ( string )
529  format_uri ( uri, string, len );
530  return string;
531 }
uint32_t string
Definition: multiboot.h:14
size_t format_uri(const struct uri *uri, char *buf, size_t len)
Format URI.
Definition: uri.c:457
void * malloc(size_t size)
Allocate memory.
Definition: malloc.c:583
uint32_t len
Length.
Definition: ena.h:14
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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

Referenced by 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
uriURI, or NULL
default_portDefault port to use if none specified in URI
Return values
portPort

Definition at line 441 of file uri.c.

441  {
442 
443  if ( ( ! uri ) || ( ! uri->port ) )
444  return default_port;
445 
446  return ( strtoul ( uri->port, NULL, 0 ) );
447 }
unsigned long strtoul(const char *string, char **endp, int base)
Convert string to numeric value.
Definition: string.c:441
const char * port
Port number.
Definition: uri.h:64
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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
uriURI
Return values
uriDuplicate URI

Creates a modifiable copy of a URI.

Definition at line 576 of file uri.c.

576  {
577  struct uri *dup;
578  size_t len;
579 
580  /* Allocate new URI */
581  len = uri_copy_fields ( uri, NULL );
582  dup = zalloc ( len );
583  if ( ! dup )
584  return NULL;
585  ref_init ( &dup->refcnt, uri_free );
586 
587  /* Copy fields */
588  uri_copy_fields ( uri, dup );
589 
590  /* Copy parameters */
591  dup->params = params_get ( uri->params );
592 
593  DBGC ( uri, "URI duplicated" );
594  uri_dump ( uri );
595  DBGC ( uri, "\n" );
596 
597  return dup;
598 }
static void uri_dump(const struct uri *uri)
Dump URI for debugging.
Definition: uri.c:247
#define ref_init(refcnt, free)
Initialise a reference counter.
Definition: refcnt.h:64
#define DBGC(...)
Definition: compiler.h:505
static size_t uri_copy_fields(const struct uri *src, struct uri *dest)
Copy URI fields.
Definition: uri.c:540
struct parameters * params
Form parameters.
Definition: uri.h:72
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
uint32_t len
Length.
Definition: ena.h:14
struct refcnt refcnt
Reference count.
Definition: uri.h:52
static void uri_free(struct refcnt *refcnt)
Free URI.
Definition: uri.c:278
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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_uriBase path
relative_uriRelative path
Return values
resolved_uriResolved 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 614 of file uri.c.

615  {
616  char *base_copy;
617  char *base_tmp;
618  char *resolved;
619 
620  /* If relative path is absolute, just re-use it */
621  if ( relative_path[0] == '/' )
622  return strdup ( relative_path );
623 
624  /* Create modifiable copy of path for dirname() */
625  base_copy = strdup ( base_path );
626  if ( ! base_copy )
627  return NULL;
628 
629  /* Strip filename portion of base path */
630  base_tmp = dirname ( base_copy );
631 
632  /* Process "./" and "../" elements */
633  while ( *relative_path == '.' ) {
634  relative_path++;
635  if ( *relative_path == 0 ) {
636  /* Do nothing */
637  } else if ( *relative_path == '/' ) {
638  relative_path++;
639  } else if ( *relative_path == '.' ) {
640  relative_path++;
641  if ( *relative_path == 0 ) {
642  base_tmp = dirname ( base_tmp );
643  } else if ( *relative_path == '/' ) {
644  base_tmp = dirname ( base_tmp );
645  relative_path++;
646  } else {
647  relative_path -= 2;
648  break;
649  }
650  } else {
651  relative_path--;
652  break;
653  }
654  }
655 
656  /* Create and return new path */
657  if ( asprintf ( &resolved, "%s%s%s", base_tmp,
658  ( ( base_tmp[ strlen ( base_tmp ) - 1 ] == '/' ) ?
659  "" : "/" ), relative_path ) < 0 )
660  resolved = NULL;
661  free ( base_copy );
662  return resolved;
663 }
char * dirname(char *path)
Return directory name from path.
Definition: basename.c:57
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
int asprintf(char **strp, const char *fmt,...)
Write a formatted string to newly allocated memory.
Definition: asprintf.c:41
char * strdup(const char *src)
Duplicate string.
Definition: string.c:350
size_t strlen(const char *src)
Get length of string.
Definition: string.c:213
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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_uriBase URI, or NULL
relative_uriRelative URI
Return values
resolved_uriResolved 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 676 of file uri.c.

677  {
678  struct uri tmp_uri;
679  char *tmp_path = NULL;
680  struct uri *new_uri;
681 
682  /* If relative URI is absolute, just re-use it */
683  if ( uri_is_absolute ( relative_uri ) || ( ! base_uri ) )
684  return uri_get ( relative_uri );
685 
686  /* Mangle URI */
687  memcpy ( &tmp_uri, base_uri, sizeof ( tmp_uri ) );
688  if ( relative_uri->path ) {
689  tmp_path = resolve_path ( ( base_uri->path ?
690  base_uri->path : "/" ),
691  relative_uri->path );
692  tmp_uri.path = tmp_path;
693  tmp_uri.query = relative_uri->query;
694  tmp_uri.fragment = relative_uri->fragment;
695  tmp_uri.params = relative_uri->params;
696  } else if ( relative_uri->query ) {
697  tmp_uri.query = relative_uri->query;
698  tmp_uri.fragment = relative_uri->fragment;
699  tmp_uri.params = relative_uri->params;
700  } else if ( relative_uri->fragment ) {
701  tmp_uri.fragment = relative_uri->fragment;
702  tmp_uri.params = relative_uri->params;
703  } else if ( relative_uri->params ) {
704  tmp_uri.params = relative_uri->params;
705  }
706 
707  /* Create demangled URI */
708  new_uri = uri_dup ( &tmp_uri );
709  free ( tmp_path );
710  return new_uri;
711 }
static struct uri * uri_get(struct uri *uri)
Increment URI reference count.
Definition: uri.h:177
static int uri_is_absolute(const struct uri *uri)
URI is an absolute URI.
Definition: uri.h:118
void * memcpy(void *dest, const void *src, size_t len) __nonnull
const char * path
Path.
Definition: uri.h:66
char * resolve_path(const char *base_path, const char *relative_path)
Resolve base+relative path.
Definition: uri.c:614
struct parameters * params
Form parameters.
Definition: uri.h:72
static void(* free)(struct refcnt *refcnt))
Definition: refcnt.h:54
struct uri * uri_dup(const struct uri *uri)
Duplicate URI.
Definition: uri.c:576
const char * query
Query.
Definition: uri.h:68
const char * fragment
Fragment.
Definition: uri.h:70
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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

Referenced by churi(), 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_serverServer address
filenameFilename
Return values
uriURI, 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 774 of file uri.c.

774  {
775  struct uri *uri;
776 
777  /* Fail if filename is empty */
778  if ( ! ( filename && filename[0] ) )
779  return NULL;
780 
781  /* If filename is a hierarchical absolute URI, then use that
782  * URI. (We accept only hierarchical absolute URIs, since PXE
783  * filenames sometimes start with DOS drive letters such as
784  * "C:\", which get misinterpreted as opaque absolute URIs.)
785  */
786  uri = parse_uri ( filename );
787  if ( uri && uri_is_absolute ( uri ) && ( ! uri->opaque ) )
788  return uri;
789  uri_put ( uri );
790 
791  /* Otherwise, construct a TFTP URI directly */
792  return tftp_uri ( sa_server, filename );
793 }
static void uri_put(struct uri *uri)
Decrement URI reference count.
Definition: uri.h:188
static int uri_is_absolute(const struct uri *uri)
URI is an absolute URI.
Definition: uri.h:118
static struct uri * tftp_uri(struct sockaddr *sa_server, const char *filename)
Construct TFTP URI from server address and filename.
Definition: uri.c:720
const char * opaque
Opaque part.
Definition: uri.h:56
A Uniform Resource Identifier.
Definition: uri.h:50
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
struct uri * parse_uri(const char *uri_string)
Parse URI.
Definition: uri.c:295

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
uriNew working URI, or NULL

Definition at line 45 of file cwuri.c.

45  {
46  struct uri *new_uri = NULL;
47 
48  if ( uri )
49  new_uri = resolve_uri ( cwuri, uri );
50 
51  uri_put ( cwuri );
52  cwuri = new_uri;
53 }
static void uri_put(struct uri *uri)
Decrement URI reference count.
Definition: uri.h:188
A Uniform Resource Identifier.
Definition: uri.h:50
struct uri * resolve_uri(const struct uri *base_uri, struct uri *relative_uri)
Resolve base+relative URI.
Definition: uri.c:676
struct uri * cwuri
Current working URI.
Definition: cwuri.c:38
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362

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

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

Variable Documentation

◆ cwuri

struct uri* cwuri

Current working URI.

Definition at line 38 of file cwuri.c.

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