uri

struct xmlURI

struct xmlURI {
    char *scheme;	/* the URI scheme */
    char *opaque;	/* opaque part */
    char *authority;	/* the authority part */
    char *server;	/* the server part */
    char *user;		/* the user part */
    int port;		/* the port number */
    char *path;		/* the path string */
    char *query;	/* the query string */
    char *fragment;	/* the fragment identifier */
    int  cleanup;	/* parsing potentially unclean URI */
};

A parsed URI reference. This is a struct containing the various fields as described in RFC 2396 but separated for further processing.

xmlURIPtr

typedef xmlURI *xmlURIPtr;

xmlCreateURI ()

xmlURIPtr   xmlCreateURI                    (void);

Simply creates an empty xmlURI

xmlBuildURI ()

xmlChar*    xmlBuildURI                     (const xmlChar *URI,
                                             const xmlChar *base);

Computes he final URI of the reference done by checking that the given URI is valid, and building the final URI using the base URI. This is processed according to section 5.2 of the RFC 2396

5.2. Resolving Relative References to Absolute Form

xmlParseURI ()

xmlURIPtr   xmlParseURI                     (const char *str);

Parse an URI

URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]

xmlParseURIReference ()

int         xmlParseURIReference            (xmlURIPtr uri,
                                             const char *str);

Parse an URI reference string and fills in the appropriate fields of the uri structure

URI-reference = [ absoluteURI | relativeURI ] [ "#" fragment ]

xmlSaveUri ()

xmlChar*    xmlSaveUri                      (xmlURIPtr uri);

Save the URI as an escaped string

xmlPrintURI ()

void        xmlPrintURI                     (FILE *stream,
                                             xmlURIPtr uri);

Prints the URI in the stream steam.

xmlURIEscapeStr ()

xmlChar*    xmlURIEscapeStr                 (const xmlChar *str,
                                             const xmlChar *list);

This routine escapes a string to hex, ignoring reserved characters (a-z) and the characters in the exception list.

xmlURIUnescapeString ()

char*       xmlURIUnescapeString            (const char *str,
                                             int len,
                                             char *target);

Unescaping routine, does not do validity checks ! Output is direct unsigned char translation of XX values (no encoding)

xmlNormalizeURIPath ()

int         xmlNormalizeURIPath             (char *path);

Applies the 5 normalization steps to a path string--that is, RFC 2396 Section 5.2, steps 6.c through 6.g.

Normalization occurs directly on the string, no new allocation is done

xmlURIEscape ()

xmlChar*    xmlURIEscape                    (const xmlChar *str);

Escaping routine, does not do validity checks ! It will try to escape the chars needing this, but this is heuristic based it's impossible to be sure.

xmlFreeURI ()

void        xmlFreeURI                      (xmlURIPtr uri);

Free up the xmlURI struct