uri

uri —

Synopsis




struct      xmlURI;
typedef     xmlURIPtr;
xmlURIPtr   xmlCreateURI                    (void);
xmlChar*    xmlBuildURI                     (const xmlChar *URI,
                                             const xmlChar *base);
xmlURIPtr   xmlParseURI                     (const char *str);
int         xmlParseURIReference            (xmlURIPtr uri,
                                             const char *str);
xmlChar*    xmlSaveUri                      (xmlURIPtr uri);
void        xmlPrintURI                     (FILE *stream,
                                             xmlURIPtr uri);
xmlChar*    xmlURIEscapeStr                 (const xmlChar *str,
                                             const xmlChar *list);
char*       xmlURIUnescapeString            (const char *str,
                                             int len,
                                             char *target);
int         xmlNormalizeURIPath             (char *path);
xmlChar*    xmlURIEscape                    (const xmlChar *str);
void        xmlFreeURI                      (xmlURIPtr uri);
xmlChar*    xmlCanonicPath                  (const xmlChar *path);

Description

Details

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

Returns :

the new structure or NULL in case of error

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

`URI` :	the URI instance found in the document
`base` :	the base value
Returns :	a new URI string (to be freed by the caller) or NULL in case of error.

xmlParseURI ()

xmlURIPtr   xmlParseURI                     (const char *str);

Parse an URI

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

`str` :	the URI string to analyze
Returns :	a newly build xmlURIPtr or NULL in case of error

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 ]

`uri` :	pointer to an URI structure
`str` :	the string to analyze
Returns :	0 or the error code

xmlSaveUri ()

xmlChar*    xmlSaveUri                      (xmlURIPtr uri);

Save the URI as an escaped string

`uri` :	pointer to an xmlURI
Returns :	a new string (to be deallocated by caller)

xmlPrintURI ()

void        xmlPrintURI                     (FILE *stream,
                                             xmlURIPtr uri);

Prints the URI in the stream steam.

`stream` :	a FILE* for the output
`uri` :	pointer to an xmlURI

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.

`str` :	string to escape
`list` :	exception list string of chars not to escape
Returns :	a new escaped string or NULL in case of error.

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)

`str` :	the string to unescape
`len` :	the length in bytes to unescape (or <= 0 to indicate full string)
`target` :	optional destination buffer
Returns :	an copy of the string, but unescaped

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

`path` :	pointer to the path string
Returns :	0 or an error code

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.

`str` :	the string of the URI to escape
Returns :	an copy of the string, but escaped 25 May 2001 Uses xmlParseURI and xmlURIEscapeStr to try to escape correctly according to RFC2396. - Carl Douglas

xmlFreeURI ()

void        xmlFreeURI                      (xmlURIPtr uri);

Free up the xmlURI struct

uri : pointer to an xmlURI

xmlCanonicPath ()

xmlChar*    xmlCanonicPath                  (const xmlChar *path);

Constructs a canonic path from the specified path.

`path` :	the resource locator in a filesystem notation
Returns :	a new canonic path, or a duplicate of the path parameter if the construction fails. The caller is responsible for freeing the memory occupied by the returned string. If there is insufficient memory available, or the argument is NULL, the function returns NULL.