GURI

typedef struct {
  gchar* scheme;
  gchar* userinfo;
  gchar* hostname;
  gint   port;
  gchar* path;
  gchar* query;
  gchar* fragment;
} GURI;

The GURI structure represents a URI. All fields in this structure are publicly readable.

gnet_uri_new ()

GURI*               gnet_uri_new                        (const gchar *uri);

Creates a GURI from a string. Empty fields are set to NULL. The parser does not validate the URI -- it will accept some malformed URI. URIs are usually in the form scheme://userinfohostname:port/path?queryfragment

URIs created from user input are typically unescaped. URIs created from machine input (e.g. received over the internet) are typically escaped.

gnet_uri_new_fields ()

GURI*               gnet_uri_new_fields                 (const gchar *scheme,
                                                         const gchar *hostname,
                                                         const gint port,
                                                         const gchar *path);

Creates a GURI from the fields. This function uses the most common fields. Use gnet_uri_new_fields_all() to specify all fields.

gnet_uri_new_fields_all ()

GURI*               gnet_uri_new_fields_all             (const gchar *scheme,
                                                         const gchar *userinfo,
                                                         const gchar *hostname,
                                                         const gint port,
                                                         const gchar *path,
                                                         const gchar *query,
                                                         const gchar *fragment);

Creates a GURI from all fields.

gnet_uri_clone ()

GURI*               gnet_uri_clone                      (const GURI *uri);

Copies a GURI.

gnet_uri_delete ()

void                gnet_uri_delete                     (GURI *uri);

Deletes a GURI.

gnet_uri_escape ()

void                gnet_uri_escape                     (GURI *uri);

Escapes the fields in a GURI. Network protocols use escaped URIs. People use unescaped URIs.

gnet_uri_unescape ()

void                gnet_uri_unescape                   (GURI *uri);

Unescapes the fields in the URI. Network protocols use escaped URIs. People use unescaped URIs.

gnet_uri_get_string ()

gchar*              gnet_uri_get_string                 (const GURI *uri);

Gets a string representation of a GURI. This function does not escape or unescape the fields first. Call gnet_uri_escape() or gnet_uri_unescape first if necessary.

gnet_uri_set_scheme ()

void                gnet_uri_set_scheme                 (GURI *uri,
                                                         const gchar *scheme);

Sets a GURI's scheme.

gnet_uri_set_userinfo ()

void                gnet_uri_set_userinfo               (GURI *uri,
                                                         const gchar *userinfo);

Sets a GURI's user info.

gnet_uri_set_hostname ()

void                gnet_uri_set_hostname               (GURI *uri,
                                                         const gchar *hostname);

Sets a GURI's host name.

gnet_uri_set_port ()

void                gnet_uri_set_port                   (GURI *uri,
                                                         gint port);

Set a GURI's port.

gnet_uri_set_path ()

void                gnet_uri_set_path                   (GURI *uri,
                                                         const gchar *path);

Set a GURI's path.

gnet_uri_set_query ()

void                gnet_uri_set_query                  (GURI *uri,
                                                         const gchar *query);

Set a GURI's query.

gnet_uri_set_fragment ()

void                gnet_uri_set_fragment               (GURI *uri,
                                                         const gchar *fragment);

Set a GURI's fragment.

gnet_uri_hash ()

guint               gnet_uri_hash                       (gconstpointer p);

Creates a hash code for p for use with GHashTable.

gnet_uri_equal ()

gboolean            gnet_uri_equal                      (gconstpointer p1,
                                                         gconstpointer p2);

Compares two GURI's for equality.

gnet_uri_parse_inplace ()

gboolean            gnet_uri_parse_inplace              (GURI *guri,
                                                         gchar *uri,
                                                         gchar *hostname,
                                                         gsize len);

This function parses an URI string very efficiently and without allocating any memory on the heap. It does this by modifying the passed-in string uri and changing field separators into string terminators in place. The result will then be put into the already-allocated and usually uninitialised, GURI structure guri.

Because the slash (') which separates the hostname from the path in an URI is needed as the first character of the path, it cannot be turned into a string terminator for the hostname. This makes it necessary for the caller (ie. you) to pass in an array where the hostname can be put.

If the URI has been parsed successfully, the fields of the GURI structure will either point into the given string uri (or to hostname in case of the hostname field), or be NULL. No freeing or de-initialising of the GURI structure is required.

The only gnet_uri_*() functions you are allowed to call with this URI structure are gnet_uri_clone(), gnet_uri_equal(), gnet_uri_hash(), gnet_uri_get_string() and gnet_uri_unescape() (the latter unescapes the string fragments in place, so is safe to use here).

You must not call any other gnet_uri_*() functions with this GURI, especially not any gnet_uri_set() functions.

Under normal circumstances, you should never need to use this function. Use gnet_uri_new() instead.

Since 2.0.8