1
0
mirror of https://github.com/rkd77/elinks.git synced 2024-12-04 14:46:47 -05:00
elinks/src/protocol/uri.h
2022-02-21 17:13:14 +01:00

373 lines
13 KiB
C

#ifndef EL__PROTOCOL_URI_H
#define EL__PROTOCOL_URI_H
#include "main/object.h"
#include "protocol/protocol.h"
#ifdef __cplusplus
extern "C" {
#endif
struct string;
#define POST_CHAR 1
#define POST_CHAR_S "\001"
#define FILE_CHAR '\002'
/* The uri structure is used to store the start position and length of commonly
* used uri fields. It is initialized by parse_uri(). It is possible that the
* start of a field is set but that the length is zero so instead of testing
* *uri-><fieldname> always use uri-><fieldname>len. */
/* XXX: Lots of places in the code assume that the string members point into
* the same string. That means if you need to use a NUL terminated uri field
* either temporary modify the string, allocated a copy or change the function
* used to take a length parameter (in the reverse precedence - modifying the
* string should not be done since you never know what kind of memory actually
* contains the string --pasky). */
/* TODO: We should probably add path+query members instead of data. */
struct uri {
/** The start of the URI (and thus start of the protocol %string).
* The format of the whole %string is like:
* "http6://elinks.cz/dir/file?query#frag" ::POST_CHAR post_data "\0"
*
* The post_data is not really %part of the URI but ELinks keeps it
* in the same %string and can then distinguish between cache entries
* for different POST requests. See uri.post for its syntax. */
char *string;
/* The internal type of protocol. Can _never_ be PROTOCOL_UNKNOWN. */
protocol_T protocol; /* protocol_T */
/* A special ELinks extension allows i.e. 'http4' or 'ftp6' protocols,
* forcing the given IP family. 0 means the IP family is not forced. */
int ip_family;
char *user;
char *password;
char *host;
char *port;
/* @data can contain both the path and query uri fields.
* It can never be NULL but can have zero length. */
char *data;
char *fragment;
/** POST data attached to the URI. If uri.string contains a
* ::POST_CHAR, then @c post points to the following
* character. Otherwise NULL. The syntax of the POST data
* is:
*
* [content-type '\\n']
* (hexadecimal-byte | ::FILE_CHAR file-name ::FILE_CHAR)*
*
* - If content-type is present, ELinks sends "Content-Type: ",
* content-type, and CRLF in the head of the POST request.
*
* - Each hexadecimal-byte is a byte for the body of the POST
* request. It is encoded as two lower-case hexadecimal
* digits, most significant first. For example, "0a" for
* ::ASCII_LF.
*
* - file-name is the name of a file that ELinks should send
* to the server. It is in the charset accepted by open(),
* and some characters (especially ::FILE_CHAR) are
* percent-encoded. */
char *post;
/* @protocollen should only be usable if @protocol is either
* PROTOCOL_USER or an uri string should be composed. */
unsigned int protocollen:16;
unsigned int userlen:16;
unsigned int passwordlen:16;
unsigned int hostlen:16;
unsigned int portlen:8;
unsigned int datalen;
unsigned int fragmentlen:16;
/* Flags */
unsigned int ipv6:1; /* URI contains IPv6 host */
unsigned int form:1; /* URI originated from form */
/* Usage count object. */
struct object object;
};
enum uri_errno {
URI_ERRNO_OK, /* Parsing went well */
URI_ERRNO_EMPTY, /* The URI string was empty */
URI_ERRNO_INVALID_PROTOCOL, /* No protocol was found */
URI_ERRNO_NO_SLASHES, /* Slashes after protocol missing */
URI_ERRNO_TOO_MANY_SLASHES, /* Too many slashes after protocol */
URI_ERRNO_TRAILING_DOTS, /* '.' after host */
URI_ERRNO_NO_HOST, /* Host part is missing */
URI_ERRNO_NO_PORT_COLON, /* ':' after host without port */
URI_ERRNO_NO_HOST_SLASH, /* Slash after host missing */
URI_ERRNO_IPV6_SECURITY, /* IPv6 security bug detected */
URI_ERRNO_INVALID_PORT, /* Port number is bad */
URI_ERRNO_INVALID_PORT_RANGE, /* Port number is not within 0-65535 */
};
typedef int uri_errno_T;
/* Initializes the members of the uri struct, as they are encountered.
* If an uri component is recognized both it's length and starting point is
* set. */
/* Returns what error was encountered or URI_ERRNO_OK if parsing went well. */
uri_errno_T parse_uri(struct uri *uri, char *uristring);
/* Returns the raw zero-terminated URI string the (struct uri) is associated
* with. Thus, chances are high that it is the original URI received, not any
* cheap reconstruction. */
#define struri(uri) ((uri)->string)
enum uri_component {
/**** The "raw" URI components */
URI_NONE = 0,
URI_PROTOCOL = (1 << 0),
URI_IP_FAMILY = (1 << 1),
URI_USER = (1 << 2),
URI_PASSWORD = (1 << 3),
URI_HOST = (1 << 4),
URI_PORT = (1 << 5),
URI_DEFAULT_PORT = (1 << 6),
URI_DATA = (1 << 7),
URI_FRAGMENT = (1 << 8),
URI_POST = (1 << 9),
URI_POST_INFO = (1 << 10),
/**** Flags affecting appearance of the components above, or special
* mutations of mixups of some of the raw components. */
/* Control for ``encoding'' URIs into Internationalized Domain Names.
* Hopefully only a few lowlevel places should have to use it and it
* should never be exposed to the user. */
URI_IDN = (1 << 11),
/* Add stuff from uri->data and up and prefixes a '/' */
URI_PATH = (1 << 12),
/* Add filename from last direcory separator in uri->data to end of
* path. */
URI_FILENAME = (1 << 13),
/* Add query part from uri->data not including the '?' */
URI_QUERY = (1 << 14),
/**** Some predefined classes for formatting of URIs */
/* Special flags */
URI_SPECIAL = URI_DEFAULT_PORT | URI_PATH | URI_FILENAME | URI_QUERY,
/* The usual suspects */
URI_RARE = URI_SPECIAL | URI_POST | URI_POST_INFO | URI_IDN,
/* Used _only_ for displaying URIs in dialogs or document titles. */
URI_PUBLIC = ~(URI_PASSWORD | URI_RARE) | URI_POST_INFO,
/* Used for getting the original URI with no internal post encoding */
URI_ORIGINAL = ~URI_RARE,
/* Used for getting the URI with no #fragment */
URI_BASE = ~(URI_RARE | URI_FRAGMENT) | URI_POST,
URI_BASE_FRAGMENT = URI_BASE | URI_FRAGMENT,
/* Used for getting data-less URI (stuff only up to the slash). */
URI_SERVER = ~(URI_RARE | URI_DATA | URI_FRAGMENT),
/* Used in the HTTP Auth code */
URI_HTTP_AUTH = ~(URI_RARE | URI_USER | URI_PASSWORD | URI_DATA | URI_FRAGMENT),
/* Used for the value of HTTP "Host" header info */
URI_HTTP_HOST = URI_HOST | URI_PORT | URI_IDN,
/* Used for the host part of HTTP referrer. Stripped from user info. */
URI_HTTP_REFERRER_HOST = URI_PROTOCOL | URI_HOST | URI_PORT,
/* Used for the whole HTTP referrer. Contains no user/passwd info. */
URI_HTTP_REFERRER = URI_HTTP_REFERRER_HOST | URI_DATA,
/* Used for HTTP CONNECT method info */
URI_HTTP_CONNECT = URI_HOST | URI_PORT | URI_DEFAULT_PORT,
/* Used for adding directory listing HTML header, */
URI_DIR_LOCATION = URI_PROTOCOL | URI_HOST | URI_PORT | URI_IDN,
/* Used for getting the host of a DNS query. As a hidden bonus we get
* IPv6 hostnames without the brackets because we don't ask for
* URI_PORT. */
URI_DNS_HOST = URI_HOST | URI_IDN,
URI_HOST_PORT = URI_HOST | URI_PORT,
/* Used for adding the unproxied URI and encode it using IDN to string */
URI_PROXY = ~(URI_RARE | URI_FRAGMENT) | URI_IDN,
/* Used for comparing keepalive connection URIs */
/* (We don't need to bother by explicit IP family, we don't care
* whether the actual query goes over IPv4 or IPv6 but only about
* new connections. Of course another thing is what the user expects
* us to care about... ;-) --pasky */
URI_KEEPALIVE = URI_PROTOCOL | URI_USER | URI_PASSWORD | URI_HOST | URI_PORT,
/* Used for the form action URI using the GET method */
URI_FORM_GET = URI_SERVER | URI_PATH,
};
typedef unsigned int uri_component_T;
/* List for maintaining multiple URIs. Free it with mem_free() */
struct uri_list {
int size;
struct uri **uris;
};
#define foreach_uri(uri, index, list) \
for (index = 0; index < (list)->size; index++) \
if ((uri = (list)->uris[index]))
/* Adds @uri to the URI list */
struct uri *add_to_uri_list(struct uri_list *list, struct uri *uri);
/* Free all entries in the URI list */
void free_uri_list(struct uri_list *list);
/* A small URI struct cache to increase reusability. */
/* XXX: Now there are a few rules to abide.
*
* Any URI string that should be registered in the cache has to have lowercased
* both the protocol and hostname parts. This is strictly checked and will
* otherwise cause an assertion failure.
*
* However this will not be a problem if you either first call join_urls()
* which you want to do anyway to resolve relative references or use the
* get_translated_uri() interface.
*
* The remaining support for RFC 2396 section 3.1 is done through get_protocol()
* and get_user_program() which will treat upper case letters
* as equivalent to lower case in protocol names. */
/* Register a new URI in the cache where @components controls which parts are
* added to the returned URI. */
struct uri *get_uri(char *string, uri_component_T components);
/* Dereference an URI from the cache */
void done_uri(struct uri *uri);
/* Take a reference of an URI already registered in the cache. */
static inline struct uri *
get_uri_reference(struct uri *uri)
{
object_lock(uri);
return uri;
}
/* Get URI using the string returned by get_uri_string(@uri, @components) */
struct uri *get_composed_uri(struct uri *uri, uri_component_T components);
/* Resolves an URI relative to a current working directory (CWD) and possibly
* extracts the fragment. It is possible to just use it to extract fragment
* and get the resulting URI from the cache.
* @uristring is the URI to resolve or translate.
* @cwd if non NULL @uristring will be translated using this CWD. */
struct uri *get_translated_uri(char *uristring, char *cwd);
/* Normalizes the directory structure given in uristring. XXX: The function
* modifies the uristring and returns it. The uri argument should be NULL
* if the uri is not the parsed uristring. */
char *normalize_uri(struct uri *uri, char *uristring);
/* Check if two URIs are equal. If @components are 0 simply compare the whole
* URI else only compare the specific parts. */
int compare_uri(const struct uri *uri1, const struct uri *uri2,
uri_component_T components);
/* These functions recreate the URI string part by part. */
/* The @components bitmask describes the set of URI components used for
* construction of the URI string. */
/* Adds the components to an already initialized string. */
struct string *add_uri_to_string(struct string *string, const struct uri *uri,
uri_component_T components);
/* Takes an uri string, parses it and adds the desired components. Useful if
* there is no struct uri around. */
struct string *add_string_uri_to_string(struct string *string, char *uristring, uri_component_T components);
/* Returns the new URI string or NULL upon an error. */
char *get_uri_string(const struct uri *uri,
uri_component_T components);
/* Returns either the uri's port number if available or the protocol's
* default port. It is zarro for user protocols. */
int get_uri_port(const struct uri *uri);
/* Tcp port range */
#define LOWEST_PORT 0
#define HIGHEST_PORT 65535
#define uri_port_is_valid(port) \
(LOWEST_PORT <= (port) && (port) <= HIGHEST_PORT)
/* Encode and add @namelen bytes from @name to @string. If @namelen is -1 it is
* set to strlen(@name). If the boolean convert_slashes is zero '/'-chars will
* not be encoded. */
void encode_uri_string(struct string *string, const char *name, int namelen,
int convert_slashes);
/* special version for Windows directory listing */
void encode_win32_uri_string(struct string *string, char *name, int namelen);
void decode_uri_string(struct string *string);
void decode_uri(char *uristring);
/* Decodes and replaces illicit screen chars with '*'. */
void decode_uri_string_for_display(struct string *string);
void decode_uri_for_display(char *uristring);
/* Returns allocated string containing the biggest possible extension.
* If url is 'jabadaba.1.foo.gz' the returned extension is '1.foo.gz' */
char *get_extension_from_uri(struct uri *uri);
/* Resolves a @relative URI to absolute form using @base URI.
* Example: if @base is http://elinks.cz/ and @relative is #news
* the outcome would be http://elinks.cz/#news */
char *join_urls(struct uri *base, const char *relative);
/* Return position if end of string @s matches a known tld or -1 if not.
* If @slen < 0, then string length will be obtained by a strlen() call,
* else @slen is used as @s length. */
int end_with_known_tld(const char *s, int slen);
static inline int
get_real_uri_length(struct uri *uri)
{
return uri->post ? uri->post - struri(uri) - 1 : strlen(struri(uri));
}
/* Checks if @address contains a valid IP address. */
int is_ip_address(const char *address, int addresslen);
/* Check whether domain is matching server
* Ie.
* example.com matches www.example.com/
* example.com doesn't match www.example.com.org/
* example.com doesn't match www.example.comm/
* example.com doesn't match example.co
*/
int is_in_domain(char *domain, char *server, int server_len);
#ifdef __cplusplus
}
#endif
#endif