mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-18 10:35:55 +00:00
4705e3668d
components: apr-1.4.6 -> 1.4.8 and apr-util-1.4.1 -> 1.5.2. This is a post point-zero bug-fix / fix-sharp-edges release, including some workarounds for UTF-8 for people who haven't yet turned on WITH_ICONV.
963 lines
39 KiB
C
963 lines
39 KiB
C
/* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/*
|
|
* apr_uri.c: URI related utility things
|
|
*
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include "apu.h"
|
|
#include "apr.h"
|
|
#include "apr_general.h"
|
|
#include "apr_strings.h"
|
|
|
|
#define APR_WANT_STRFUNC
|
|
#include "apr_want.h"
|
|
|
|
#include "apr_uri.h"
|
|
|
|
typedef struct schemes_t schemes_t;
|
|
|
|
/** Structure to store various schemes and their default ports */
|
|
struct schemes_t {
|
|
/** The name of the scheme */
|
|
const char *name;
|
|
/** The default port for the scheme */
|
|
apr_port_t default_port;
|
|
};
|
|
|
|
/* Some WWW schemes and their default ports; this is basically /etc/services */
|
|
/* This will become global when the protocol abstraction comes */
|
|
/* As the schemes are searched by a linear search, */
|
|
/* they are sorted by their expected frequency */
|
|
static schemes_t schemes[] =
|
|
{
|
|
{"http", APR_URI_HTTP_DEFAULT_PORT},
|
|
{"ftp", APR_URI_FTP_DEFAULT_PORT},
|
|
{"https", APR_URI_HTTPS_DEFAULT_PORT},
|
|
{"gopher", APR_URI_GOPHER_DEFAULT_PORT},
|
|
{"ldap", APR_URI_LDAP_DEFAULT_PORT},
|
|
{"nntp", APR_URI_NNTP_DEFAULT_PORT},
|
|
{"snews", APR_URI_SNEWS_DEFAULT_PORT},
|
|
{"imap", APR_URI_IMAP_DEFAULT_PORT},
|
|
{"pop", APR_URI_POP_DEFAULT_PORT},
|
|
{"sip", APR_URI_SIP_DEFAULT_PORT},
|
|
{"rtsp", APR_URI_RTSP_DEFAULT_PORT},
|
|
{"wais", APR_URI_WAIS_DEFAULT_PORT},
|
|
{"z39.50r", APR_URI_WAIS_DEFAULT_PORT},
|
|
{"z39.50s", APR_URI_WAIS_DEFAULT_PORT},
|
|
{"prospero", APR_URI_PROSPERO_DEFAULT_PORT},
|
|
{"nfs", APR_URI_NFS_DEFAULT_PORT},
|
|
{"tip", APR_URI_TIP_DEFAULT_PORT},
|
|
{"acap", APR_URI_ACAP_DEFAULT_PORT},
|
|
{"telnet", APR_URI_TELNET_DEFAULT_PORT},
|
|
{"ssh", APR_URI_SSH_DEFAULT_PORT},
|
|
{ NULL, 0xFFFF } /* unknown port */
|
|
};
|
|
|
|
APU_DECLARE(apr_port_t) apr_uri_port_of_scheme(const char *scheme_str)
|
|
{
|
|
schemes_t *scheme;
|
|
|
|
if (scheme_str) {
|
|
for (scheme = schemes; scheme->name != NULL; ++scheme) {
|
|
if (strcasecmp(scheme_str, scheme->name) == 0) {
|
|
return scheme->default_port;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Unparse a apr_uri_t structure to an URI string.
|
|
* Optionally suppress the password for security reasons.
|
|
*/
|
|
APU_DECLARE(char *) apr_uri_unparse(apr_pool_t *p,
|
|
const apr_uri_t *uptr,
|
|
unsigned flags)
|
|
{
|
|
char *ret = "";
|
|
|
|
/* If suppressing the site part, omit both user name & scheme://hostname */
|
|
if (!(flags & APR_URI_UNP_OMITSITEPART)) {
|
|
|
|
/* Construct a "user:password@" string, honoring the passed
|
|
* APR_URI_UNP_ flags: */
|
|
if (uptr->user || uptr->password) {
|
|
ret = apr_pstrcat(p,
|
|
(uptr->user && !(flags & APR_URI_UNP_OMITUSER))
|
|
? uptr->user : "",
|
|
(uptr->password && !(flags & APR_URI_UNP_OMITPASSWORD))
|
|
? ":" : "",
|
|
(uptr->password && !(flags & APR_URI_UNP_OMITPASSWORD))
|
|
? ((flags & APR_URI_UNP_REVEALPASSWORD)
|
|
? uptr->password : "XXXXXXXX")
|
|
: "",
|
|
((uptr->user && !(flags & APR_URI_UNP_OMITUSER)) ||
|
|
(uptr->password && !(flags & APR_URI_UNP_OMITPASSWORD)))
|
|
? "@" : "",
|
|
NULL);
|
|
}
|
|
|
|
/* Construct scheme://site string */
|
|
if (uptr->hostname) {
|
|
int is_default_port;
|
|
const char *lbrk = "", *rbrk = "";
|
|
|
|
if (strchr(uptr->hostname, ':')) { /* v6 literal */
|
|
lbrk = "[";
|
|
rbrk = "]";
|
|
}
|
|
|
|
is_default_port =
|
|
(uptr->port_str == NULL ||
|
|
uptr->port == 0 ||
|
|
uptr->port == apr_uri_port_of_scheme(uptr->scheme));
|
|
|
|
ret = apr_pstrcat(p, "//", ret, lbrk, uptr->hostname, rbrk,
|
|
is_default_port ? "" : ":",
|
|
is_default_port ? "" : uptr->port_str,
|
|
NULL);
|
|
}
|
|
if (uptr->scheme) {
|
|
ret = apr_pstrcat(p, uptr->scheme, ":", ret, NULL);
|
|
}
|
|
}
|
|
|
|
/* Should we suppress all path info? */
|
|
if (!(flags & APR_URI_UNP_OMITPATHINFO)) {
|
|
/* Append path, query and fragment strings: */
|
|
ret = apr_pstrcat(p,
|
|
ret,
|
|
(uptr->path)
|
|
? uptr->path : "",
|
|
(uptr->query && !(flags & APR_URI_UNP_OMITQUERY))
|
|
? "?" : "",
|
|
(uptr->query && !(flags & APR_URI_UNP_OMITQUERY))
|
|
? uptr->query : "",
|
|
(uptr->fragment && !(flags & APR_URI_UNP_OMITQUERY))
|
|
? "#" : NULL,
|
|
(uptr->fragment && !(flags & APR_URI_UNP_OMITQUERY))
|
|
? uptr->fragment : NULL,
|
|
NULL);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* Here is the hand-optimized parse_uri_components(). There are some wild
|
|
* tricks we could pull in assembly language that we don't pull here... like we
|
|
* can do word-at-time scans for delimiter characters using the same technique
|
|
* that fast memchr()s use. But that would be way non-portable. -djg
|
|
*/
|
|
|
|
/* We have a apr_table_t that we can index by character and it tells us if the
|
|
* character is one of the interesting delimiters. Note that we even get
|
|
* compares for NUL for free -- it's just another delimiter.
|
|
*/
|
|
|
|
#define T_SLASH 0x01 /* '/' */
|
|
#define T_QUESTION 0x02 /* '?' */
|
|
#define T_HASH 0x04 /* '#' */
|
|
#define T_ALPHA 0x08 /* 'A' ... 'Z', 'a' ... 'z' */
|
|
#define T_SCHEME 0x10 /* '0' ... '9', '-', '+', '.'
|
|
* (allowed in scheme except first char)
|
|
*/
|
|
#define T_NUL 0x80 /* '\0' */
|
|
|
|
#if APR_CHARSET_EBCDIC
|
|
/* Delimiter table for the EBCDIC character set */
|
|
static const unsigned char uri_delims[256] = {
|
|
T_NUL, /* 0x00 */
|
|
0, /* 0x01 */
|
|
0, /* 0x02 */
|
|
0, /* 0x03 */
|
|
0, /* 0x04 */
|
|
0, /* 0x05 */
|
|
0, /* 0x06 */
|
|
0, /* 0x07 */
|
|
0, /* 0x08 */
|
|
0, /* 0x09 */
|
|
0, /* 0x0a */
|
|
0, /* 0x0b */
|
|
0, /* 0x0c */
|
|
0, /* 0x0d */
|
|
0, /* 0x0e */
|
|
0, /* 0x0f */
|
|
0, /* 0x10 */
|
|
0, /* 0x11 */
|
|
0, /* 0x12 */
|
|
0, /* 0x13 */
|
|
0, /* 0x14 */
|
|
0, /* 0x15 */
|
|
0, /* 0x16 */
|
|
0, /* 0x17 */
|
|
0, /* 0x18 */
|
|
0, /* 0x19 */
|
|
0, /* 0x1a */
|
|
0, /* 0x1b */
|
|
0, /* 0x1c */
|
|
0, /* 0x1d */
|
|
0, /* 0x1e */
|
|
0, /* 0x1f */
|
|
0, /* 0x20 */
|
|
0, /* 0x21 */
|
|
0, /* 0x22 */
|
|
0, /* 0x23 */
|
|
0, /* 0x24 */
|
|
0, /* 0x25 */
|
|
0, /* 0x26 */
|
|
0, /* 0x27 */
|
|
0, /* 0x28 */
|
|
0, /* 0x29 */
|
|
0, /* 0x2a */
|
|
0, /* 0x2b */
|
|
0, /* 0x2c */
|
|
0, /* 0x2d */
|
|
0, /* 0x2e */
|
|
0, /* 0x2f */
|
|
0, /* 0x30 */
|
|
0, /* 0x31 */
|
|
0, /* 0x32 */
|
|
0, /* 0x33 */
|
|
0, /* 0x34 */
|
|
0, /* 0x35 */
|
|
0, /* 0x36 */
|
|
0, /* 0x37 */
|
|
0, /* 0x38 */
|
|
0, /* 0x39 */
|
|
0, /* 0x3a */
|
|
0, /* 0x3b */
|
|
0, /* 0x3c */
|
|
0, /* 0x3d */
|
|
0, /* 0x3e */
|
|
0, /* 0x3f */
|
|
0, /* 0x40 ' ' */
|
|
0, /* 0x41 */
|
|
0, /* 0x42 */
|
|
0, /* 0x43 */
|
|
0, /* 0x44 */
|
|
0, /* 0x45 */
|
|
0, /* 0x46 */
|
|
0, /* 0x47 */
|
|
0, /* 0x48 */
|
|
0, /* 0x49 */
|
|
0, /* 0x4a '[' */
|
|
T_SCHEME, /* 0x4b '.' */
|
|
0, /* 0x4c '<' */
|
|
0, /* 0x4d '(' */
|
|
T_SCHEME, /* 0x4e '+' */
|
|
0, /* 0x4f '!' */
|
|
0, /* 0x50 '&' */
|
|
0, /* 0x51 */
|
|
0, /* 0x52 */
|
|
0, /* 0x53 */
|
|
0, /* 0x54 */
|
|
0, /* 0x55 */
|
|
0, /* 0x56 */
|
|
0, /* 0x57 */
|
|
0, /* 0x58 */
|
|
0, /* 0x59 */
|
|
0, /* 0x5a ']' */
|
|
0, /* 0x5b '$' */
|
|
0, /* 0x5c '*' */
|
|
0, /* 0x5d ')' */
|
|
0, /* 0x5e ';' */
|
|
0, /* 0x5f '^' */
|
|
T_SCHEME, /* 0x60 '-' */
|
|
T_SLASH, /* 0x61 '/' */
|
|
0, /* 0x62 */
|
|
0, /* 0x63 */
|
|
0, /* 0x64 */
|
|
0, /* 0x65 */
|
|
0, /* 0x66 */
|
|
0, /* 0x67 */
|
|
0, /* 0x68 */
|
|
0, /* 0x69 */
|
|
0, /* 0x6a '|' */
|
|
0, /* 0x6b ',' */
|
|
0, /* 0x6c '%' */
|
|
0, /* 0x6d '_' */
|
|
0, /* 0x6e '>' */
|
|
T_QUESTION, /* 0x6f '?' */
|
|
0, /* 0x70 */
|
|
0, /* 0x71 */
|
|
0, /* 0x72 */
|
|
0, /* 0x73 */
|
|
0, /* 0x74 */
|
|
0, /* 0x75 */
|
|
0, /* 0x76 */
|
|
0, /* 0x77 */
|
|
0, /* 0x78 */
|
|
0, /* 0x79 '`' */
|
|
0, /* 0x7a ':' */
|
|
T_HASH, /* 0x7b '#' */
|
|
0, /* 0x7c '@' */
|
|
0, /* 0x7d ''' */
|
|
0, /* 0x7e '=' */
|
|
0, /* 0x7f '"' */
|
|
0, /* 0x80 */
|
|
T_ALPHA, /* 0x81 'a' */
|
|
T_ALPHA, /* 0x82 'b' */
|
|
T_ALPHA, /* 0x83 'c' */
|
|
T_ALPHA, /* 0x84 'd' */
|
|
T_ALPHA, /* 0x85 'e' */
|
|
T_ALPHA, /* 0x86 'f' */
|
|
T_ALPHA, /* 0x87 'g' */
|
|
T_ALPHA, /* 0x88 'h' */
|
|
T_ALPHA, /* 0x89 'i' */
|
|
0, /* 0x8a */
|
|
0, /* 0x8b */
|
|
0, /* 0x8c */
|
|
0, /* 0x8d */
|
|
0, /* 0x8e */
|
|
0, /* 0x8f */
|
|
0, /* 0x90 */
|
|
T_ALPHA, /* 0x91 'j' */
|
|
T_ALPHA, /* 0x92 'k' */
|
|
T_ALPHA, /* 0x93 'l' */
|
|
T_ALPHA, /* 0x94 'm' */
|
|
T_ALPHA, /* 0x95 'n' */
|
|
T_ALPHA, /* 0x96 'o' */
|
|
T_ALPHA, /* 0x97 'p' */
|
|
T_ALPHA, /* 0x98 'q' */
|
|
T_ALPHA, /* 0x99 'r' */
|
|
0, /* 0x9a */
|
|
0, /* 0x9b */
|
|
0, /* 0x9c */
|
|
0, /* 0x9d */
|
|
0, /* 0x9e */
|
|
0, /* 0x9f */
|
|
0, /* 0xa0 */
|
|
0, /* 0xa1 '~' */
|
|
T_ALPHA, /* 0xa2 's' */
|
|
T_ALPHA, /* 0xa3 't' */
|
|
T_ALPHA, /* 0xa4 'u' */
|
|
T_ALPHA, /* 0xa5 'v' */
|
|
T_ALPHA, /* 0xa6 'w' */
|
|
T_ALPHA, /* 0xa7 'x' */
|
|
T_ALPHA, /* 0xa8 'y' */
|
|
T_ALPHA, /* 0xa9 'z' */
|
|
0, /* 0xaa */
|
|
0, /* 0xab */
|
|
0, /* 0xac */
|
|
0, /* 0xad */
|
|
0, /* 0xae */
|
|
0, /* 0xaf */
|
|
0, /* 0xb0 */
|
|
0, /* 0xb1 */
|
|
0, /* 0xb2 */
|
|
0, /* 0xb3 */
|
|
0, /* 0xb4 */
|
|
0, /* 0xb5 */
|
|
0, /* 0xb6 */
|
|
0, /* 0xb7 */
|
|
0, /* 0xb8 */
|
|
0, /* 0xb9 */
|
|
0, /* 0xba */
|
|
0, /* 0xbb */
|
|
0, /* 0xbc */
|
|
0, /* 0xbd */
|
|
0, /* 0xbe */
|
|
0, /* 0xbf */
|
|
0, /* 0xc0 '{' */
|
|
T_ALPHA, /* 0xc1 'A' */
|
|
T_ALPHA, /* 0xc2 'B' */
|
|
T_ALPHA, /* 0xc3 'C' */
|
|
T_ALPHA, /* 0xc4 'D' */
|
|
T_ALPHA, /* 0xc5 'E' */
|
|
T_ALPHA, /* 0xc6 'F' */
|
|
T_ALPHA, /* 0xc7 'G' */
|
|
T_ALPHA, /* 0xc8 'H' */
|
|
T_ALPHA, /* 0xc9 'I' */
|
|
0, /* 0xca */
|
|
0, /* 0xcb */
|
|
0, /* 0xcc */
|
|
0, /* 0xcd */
|
|
0, /* 0xce */
|
|
0, /* 0xcf */
|
|
0, /* 0xd0 '}' */
|
|
T_ALPHA, /* 0xd1 'J' */
|
|
T_ALPHA, /* 0xd2 'K' */
|
|
T_ALPHA, /* 0xd3 'L' */
|
|
T_ALPHA, /* 0xd4 'M' */
|
|
T_ALPHA, /* 0xd5 'N' */
|
|
T_ALPHA, /* 0xd6 'O' */
|
|
T_ALPHA, /* 0xd7 'P' */
|
|
T_ALPHA, /* 0xd8 'Q' */
|
|
T_ALPHA, /* 0xd9 'R' */
|
|
0, /* 0xda */
|
|
0, /* 0xdb */
|
|
0, /* 0xdc */
|
|
0, /* 0xdd */
|
|
0, /* 0xde */
|
|
0, /* 0xdf */
|
|
0, /* 0xe0 '\' */
|
|
0, /* 0xe1 */
|
|
T_ALPHA, /* 0xe2 'S' */
|
|
T_ALPHA, /* 0xe3 'T' */
|
|
T_ALPHA, /* 0xe4 'U' */
|
|
T_ALPHA, /* 0xe5 'V' */
|
|
T_ALPHA, /* 0xe6 'W' */
|
|
T_ALPHA, /* 0xe7 'X' */
|
|
T_ALPHA, /* 0xe8 'Y' */
|
|
T_ALPHA, /* 0xe9 'Z' */
|
|
0, /* 0xea */
|
|
0, /* 0xeb */
|
|
0, /* 0xec */
|
|
0, /* 0xed */
|
|
0, /* 0xee */
|
|
0, /* 0xef */
|
|
T_SCHEME, /* 0xf0 '0' */
|
|
T_SCHEME, /* 0xf1 '1' */
|
|
T_SCHEME, /* 0xf2 '2' */
|
|
T_SCHEME, /* 0xf3 '3' */
|
|
T_SCHEME, /* 0xf4 '4' */
|
|
T_SCHEME, /* 0xf5 '5' */
|
|
T_SCHEME, /* 0xf6 '6' */
|
|
T_SCHEME, /* 0xf7 '7' */
|
|
T_SCHEME, /* 0xf8 '8' */
|
|
T_SCHEME, /* 0xf9 '9' */
|
|
0, /* 0xfa */
|
|
0, /* 0xfb */
|
|
0, /* 0xfc */
|
|
0, /* 0xfd */
|
|
0, /* 0xfe */
|
|
0 /* 0xff */
|
|
};
|
|
#else
|
|
/* Delimiter table for the ASCII character set */
|
|
static const unsigned char uri_delims[256] = {
|
|
T_NUL, /* 0x00 */
|
|
0, /* 0x01 */
|
|
0, /* 0x02 */
|
|
0, /* 0x03 */
|
|
0, /* 0x04 */
|
|
0, /* 0x05 */
|
|
0, /* 0x06 */
|
|
0, /* 0x07 */
|
|
0, /* 0x08 */
|
|
0, /* 0x09 */
|
|
0, /* 0x0a */
|
|
0, /* 0x0b */
|
|
0, /* 0x0c */
|
|
0, /* 0x0d */
|
|
0, /* 0x0e */
|
|
0, /* 0x0f */
|
|
0, /* 0x10 */
|
|
0, /* 0x11 */
|
|
0, /* 0x12 */
|
|
0, /* 0x13 */
|
|
0, /* 0x14 */
|
|
0, /* 0x15 */
|
|
0, /* 0x16 */
|
|
0, /* 0x17 */
|
|
0, /* 0x18 */
|
|
0, /* 0x19 */
|
|
0, /* 0x1a */
|
|
0, /* 0x1b */
|
|
0, /* 0x1c */
|
|
0, /* 0x1d */
|
|
0, /* 0x1e */
|
|
0, /* 0x1f */
|
|
0, /* 0x20 ' ' */
|
|
0, /* 0x21 '!' */
|
|
0, /* 0x22 '"' */
|
|
T_HASH, /* 0x23 '#' */
|
|
0, /* 0x24 '$' */
|
|
0, /* 0x25 '%' */
|
|
0, /* 0x26 '&' */
|
|
0, /* 0x27 ''' */
|
|
0, /* 0x28 '(' */
|
|
0, /* 0x29 ')' */
|
|
0, /* 0x2a '*' */
|
|
T_SCHEME, /* 0x2b '+' */
|
|
0, /* 0x2c ',' */
|
|
T_SCHEME, /* 0x2d '-' */
|
|
T_SCHEME, /* 0x2e '.' */
|
|
T_SLASH, /* 0x2f '/' */
|
|
T_SCHEME, /* 0x30 '0' */
|
|
T_SCHEME, /* 0x31 '1' */
|
|
T_SCHEME, /* 0x32 '2' */
|
|
T_SCHEME, /* 0x33 '3' */
|
|
T_SCHEME, /* 0x34 '4' */
|
|
T_SCHEME, /* 0x35 '5' */
|
|
T_SCHEME, /* 0x36 '6' */
|
|
T_SCHEME, /* 0x37 '7' */
|
|
T_SCHEME, /* 0x38 '8' */
|
|
T_SCHEME, /* 0x39 '9' */
|
|
0, /* 0x3a ':' */
|
|
0, /* 0x3b ';' */
|
|
0, /* 0x3c '<' */
|
|
0, /* 0x3d '=' */
|
|
0, /* 0x3e '>' */
|
|
T_QUESTION, /* 0x3f '?' */
|
|
0, /* 0x40 '@' */
|
|
T_ALPHA, /* 0x41 'A' */
|
|
T_ALPHA, /* 0x42 'B' */
|
|
T_ALPHA, /* 0x43 'C' */
|
|
T_ALPHA, /* 0x44 'D' */
|
|
T_ALPHA, /* 0x45 'E' */
|
|
T_ALPHA, /* 0x46 'F' */
|
|
T_ALPHA, /* 0x47 'G' */
|
|
T_ALPHA, /* 0x48 'H' */
|
|
T_ALPHA, /* 0x49 'I' */
|
|
T_ALPHA, /* 0x4a 'J' */
|
|
T_ALPHA, /* 0x4b 'K' */
|
|
T_ALPHA, /* 0x4c 'L' */
|
|
T_ALPHA, /* 0x4d 'M' */
|
|
T_ALPHA, /* 0x4e 'N' */
|
|
T_ALPHA, /* 0x4f 'O' */
|
|
T_ALPHA, /* 0x50 'P' */
|
|
T_ALPHA, /* 0x51 'Q' */
|
|
T_ALPHA, /* 0x52 'R' */
|
|
T_ALPHA, /* 0x53 'S' */
|
|
T_ALPHA, /* 0x54 'T' */
|
|
T_ALPHA, /* 0x55 'U' */
|
|
T_ALPHA, /* 0x56 'V' */
|
|
T_ALPHA, /* 0x57 'W' */
|
|
T_ALPHA, /* 0x58 'X' */
|
|
T_ALPHA, /* 0x59 'Y' */
|
|
T_ALPHA, /* 0x5a 'Z' */
|
|
0, /* 0x5b '[' */
|
|
0, /* 0x5c '\' */
|
|
0, /* 0x5d ']' */
|
|
0, /* 0x5e '^' */
|
|
0, /* 0x5f '_' */
|
|
0, /* 0x60 '`' */
|
|
T_ALPHA, /* 0x61 'a' */
|
|
T_ALPHA, /* 0x62 'b' */
|
|
T_ALPHA, /* 0x63 'c' */
|
|
T_ALPHA, /* 0x64 'd' */
|
|
T_ALPHA, /* 0x65 'e' */
|
|
T_ALPHA, /* 0x66 'f' */
|
|
T_ALPHA, /* 0x67 'g' */
|
|
T_ALPHA, /* 0x68 'h' */
|
|
T_ALPHA, /* 0x69 'i' */
|
|
T_ALPHA, /* 0x6a 'j' */
|
|
T_ALPHA, /* 0x6b 'k' */
|
|
T_ALPHA, /* 0x6c 'l' */
|
|
T_ALPHA, /* 0x6d 'm' */
|
|
T_ALPHA, /* 0x6e 'n' */
|
|
T_ALPHA, /* 0x6f 'o' */
|
|
T_ALPHA, /* 0x70 'p' */
|
|
T_ALPHA, /* 0x71 'q' */
|
|
T_ALPHA, /* 0x72 'r' */
|
|
T_ALPHA, /* 0x73 's' */
|
|
T_ALPHA, /* 0x74 't' */
|
|
T_ALPHA, /* 0x75 'u' */
|
|
T_ALPHA, /* 0x76 'v' */
|
|
T_ALPHA, /* 0x77 'w' */
|
|
T_ALPHA, /* 0x78 'x' */
|
|
T_ALPHA, /* 0x79 'y' */
|
|
T_ALPHA, /* 0x7a 'z' */
|
|
0, /* 0x7b '{' */
|
|
0, /* 0x7c '|' */
|
|
0, /* 0x7d '}' */
|
|
0, /* 0x7e '~' */
|
|
0, /* 0x7f */
|
|
0, /* 0x80 */
|
|
0, /* 0x81 */
|
|
0, /* 0x82 */
|
|
0, /* 0x83 */
|
|
0, /* 0x84 */
|
|
0, /* 0x85 */
|
|
0, /* 0x86 */
|
|
0, /* 0x87 */
|
|
0, /* 0x88 */
|
|
0, /* 0x89 */
|
|
0, /* 0x8a */
|
|
0, /* 0x8b */
|
|
0, /* 0x8c */
|
|
0, /* 0x8d */
|
|
0, /* 0x8e */
|
|
0, /* 0x8f */
|
|
0, /* 0x90 */
|
|
0, /* 0x91 */
|
|
0, /* 0x92 */
|
|
0, /* 0x93 */
|
|
0, /* 0x94 */
|
|
0, /* 0x95 */
|
|
0, /* 0x96 */
|
|
0, /* 0x97 */
|
|
0, /* 0x98 */
|
|
0, /* 0x99 */
|
|
0, /* 0x9a */
|
|
0, /* 0x9b */
|
|
0, /* 0x9c */
|
|
0, /* 0x9d */
|
|
0, /* 0x9e */
|
|
0, /* 0x9f */
|
|
0, /* 0xa0 */
|
|
0, /* 0xa1 */
|
|
0, /* 0xa2 */
|
|
0, /* 0xa3 */
|
|
0, /* 0xa4 */
|
|
0, /* 0xa5 */
|
|
0, /* 0xa6 */
|
|
0, /* 0xa7 */
|
|
0, /* 0xa8 */
|
|
0, /* 0xa9 */
|
|
0, /* 0xaa */
|
|
0, /* 0xab */
|
|
0, /* 0xac */
|
|
0, /* 0xad */
|
|
0, /* 0xae */
|
|
0, /* 0xaf */
|
|
0, /* 0xb0 */
|
|
0, /* 0xb1 */
|
|
0, /* 0xb2 */
|
|
0, /* 0xb3 */
|
|
0, /* 0xb4 */
|
|
0, /* 0xb5 */
|
|
0, /* 0xb6 */
|
|
0, /* 0xb7 */
|
|
0, /* 0xb8 */
|
|
0, /* 0xb9 */
|
|
0, /* 0xba */
|
|
0, /* 0xbb */
|
|
0, /* 0xbc */
|
|
0, /* 0xbd */
|
|
0, /* 0xbe */
|
|
0, /* 0xbf */
|
|
0, /* 0xc0 */
|
|
0, /* 0xc1 */
|
|
0, /* 0xc2 */
|
|
0, /* 0xc3 */
|
|
0, /* 0xc4 */
|
|
0, /* 0xc5 */
|
|
0, /* 0xc6 */
|
|
0, /* 0xc7 */
|
|
0, /* 0xc8 */
|
|
0, /* 0xc9 */
|
|
0, /* 0xca */
|
|
0, /* 0xcb */
|
|
0, /* 0xcc */
|
|
0, /* 0xcd */
|
|
0, /* 0xce */
|
|
0, /* 0xcf */
|
|
0, /* 0xd0 */
|
|
0, /* 0xd1 */
|
|
0, /* 0xd2 */
|
|
0, /* 0xd3 */
|
|
0, /* 0xd4 */
|
|
0, /* 0xd5 */
|
|
0, /* 0xd6 */
|
|
0, /* 0xd7 */
|
|
0, /* 0xd8 */
|
|
0, /* 0xd9 */
|
|
0, /* 0xda */
|
|
0, /* 0xdb */
|
|
0, /* 0xdc */
|
|
0, /* 0xdd */
|
|
0, /* 0xde */
|
|
0, /* 0xdf */
|
|
0, /* 0xe0 */
|
|
0, /* 0xe1 */
|
|
0, /* 0xe2 */
|
|
0, /* 0xe3 */
|
|
0, /* 0xe4 */
|
|
0, /* 0xe5 */
|
|
0, /* 0xe6 */
|
|
0, /* 0xe7 */
|
|
0, /* 0xe8 */
|
|
0, /* 0xe9 */
|
|
0, /* 0xea */
|
|
0, /* 0xeb */
|
|
0, /* 0xec */
|
|
0, /* 0xed */
|
|
0, /* 0xee */
|
|
0, /* 0xef */
|
|
0, /* 0xf0 */
|
|
0, /* 0xf1 */
|
|
0, /* 0xf2 */
|
|
0, /* 0xf3 */
|
|
0, /* 0xf4 */
|
|
0, /* 0xf5 */
|
|
0, /* 0xf6 */
|
|
0, /* 0xf7 */
|
|
0, /* 0xf8 */
|
|
0, /* 0xf9 */
|
|
0, /* 0xfa */
|
|
0, /* 0xfb */
|
|
0, /* 0xfc */
|
|
0, /* 0xfd */
|
|
0, /* 0xfe */
|
|
0 /* 0xff */
|
|
};
|
|
#endif
|
|
|
|
|
|
/* it works like this:
|
|
if (uri_delims[ch] & NOTEND_foobar) {
|
|
then we're not at a delimiter for foobar
|
|
}
|
|
*/
|
|
|
|
#define NOTEND_HOSTINFO (T_SLASH | T_QUESTION | T_HASH | T_NUL)
|
|
#define NOTEND_PATH (T_QUESTION | T_HASH | T_NUL)
|
|
|
|
/* parse_uri_components():
|
|
* Parse a given URI, fill in all supplied fields of a uri_components
|
|
* structure. This eliminates the necessity of extracting host, port,
|
|
* path, query info repeatedly in the modules.
|
|
* Side effects:
|
|
* - fills in fields of uri_components *uptr
|
|
* - none on any of the r->* fields
|
|
*/
|
|
APU_DECLARE(apr_status_t) apr_uri_parse(apr_pool_t *p, const char *uri,
|
|
apr_uri_t *uptr)
|
|
{
|
|
const char *s;
|
|
const char *s1;
|
|
const char *hostinfo;
|
|
char *endstr;
|
|
int port;
|
|
int v6_offset1 = 0, v6_offset2 = 0;
|
|
|
|
/* Initialize the structure. parse_uri() and parse_uri_components()
|
|
* can be called more than once per request.
|
|
*/
|
|
memset (uptr, '\0', sizeof(*uptr));
|
|
uptr->is_initialized = 1;
|
|
|
|
/* We assume the processor has a branch predictor like most --
|
|
* it assumes forward branches are untaken and backwards are taken. That's
|
|
* the reason for the gotos. -djg
|
|
*/
|
|
if (uri[0] == '/') {
|
|
/* RFC2396 #4.3 says that two leading slashes mean we have an
|
|
* authority component, not a path! Fixing this looks scary
|
|
* with the gotos here. But if the existing logic is valid,
|
|
* then presumably a goto pointing to deal_with_authority works.
|
|
*
|
|
* RFC2396 describes this as resolving an ambiguity. In the
|
|
* case of three or more slashes there would seem to be no
|
|
* ambiguity, so it is a path after all.
|
|
*/
|
|
if (uri[1] == '/' && uri[2] != '/') {
|
|
s = uri + 2 ;
|
|
goto deal_with_authority ;
|
|
}
|
|
|
|
deal_with_path:
|
|
/* we expect uri to point to first character of path ... remember
|
|
* that the path could be empty -- http://foobar?query for example
|
|
*/
|
|
s = uri;
|
|
while ((uri_delims[*(unsigned char *)s] & NOTEND_PATH) == 0) {
|
|
++s;
|
|
}
|
|
if (s != uri) {
|
|
uptr->path = apr_pstrmemdup(p, uri, s - uri);
|
|
}
|
|
if (*s == 0) {
|
|
return APR_SUCCESS;
|
|
}
|
|
if (*s == '?') {
|
|
++s;
|
|
s1 = strchr(s, '#');
|
|
if (s1) {
|
|
uptr->fragment = apr_pstrdup(p, s1 + 1);
|
|
uptr->query = apr_pstrmemdup(p, s, s1 - s);
|
|
}
|
|
else {
|
|
uptr->query = apr_pstrdup(p, s);
|
|
}
|
|
return APR_SUCCESS;
|
|
}
|
|
/* otherwise it's a fragment */
|
|
uptr->fragment = apr_pstrdup(p, s + 1);
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
/* find the scheme: */
|
|
s = uri;
|
|
/* first char must be letter */
|
|
if (uri_delims[*(unsigned char *)s] & T_ALPHA) {
|
|
++s;
|
|
while ((uri_delims[*(unsigned char *)s] & (T_ALPHA|T_SCHEME)))
|
|
++s;
|
|
}
|
|
/* scheme must be non-empty and followed by : */
|
|
if (s != uri && s[0] == ':') {
|
|
uptr->scheme = apr_pstrmemdup(p, uri, s - uri);
|
|
s++;
|
|
}
|
|
else {
|
|
/* No valid scheme, restart from the beginning */
|
|
s = uri;
|
|
}
|
|
|
|
if (s[0] != '/' || s[1] != '/') {
|
|
if (uri == s) {
|
|
/*
|
|
* RFC 3986 3.3: If we have no scheme and no authority,
|
|
* the leading segment of a relative path must not contain a ':'.
|
|
*/
|
|
char *first_slash = strchr(uri, '/');
|
|
if (first_slash) {
|
|
while (s < first_slash) {
|
|
if (s[0] == ':')
|
|
return APR_EGENERAL;
|
|
++s;
|
|
}
|
|
/* no scheme but relative path, e.g. '../image.jpg' */
|
|
}
|
|
else {
|
|
if (strchr(uri, ':') != NULL)
|
|
return APR_EGENERAL;
|
|
/* no scheme, no slash, but relative path, e.g. 'image.jpg' */
|
|
}
|
|
goto deal_with_path;
|
|
}
|
|
/* scheme and relative path */
|
|
uri = s;
|
|
goto deal_with_path;
|
|
}
|
|
|
|
s += 2;
|
|
|
|
deal_with_authority:
|
|
hostinfo = s;
|
|
while ((uri_delims[*(unsigned char *)s] & NOTEND_HOSTINFO) == 0) {
|
|
++s;
|
|
}
|
|
uri = s; /* whatever follows hostinfo is start of uri */
|
|
uptr->hostinfo = apr_pstrmemdup(p, hostinfo, uri - hostinfo);
|
|
|
|
/* If there's a username:password@host:port, the @ we want is the last @...
|
|
* too bad there's no memrchr()... For the C purists, note that hostinfo
|
|
* is definitely not the first character of the original uri so therefore
|
|
* &hostinfo[-1] < &hostinfo[0] ... and this loop is valid C.
|
|
*/
|
|
do {
|
|
--s;
|
|
} while (s >= hostinfo && *s != '@');
|
|
if (s < hostinfo) {
|
|
/* again we want the common case to be fall through */
|
|
deal_with_host:
|
|
/* We expect hostinfo to point to the first character of
|
|
* the hostname. If there's a port it is the first colon,
|
|
* except with IPv6.
|
|
*/
|
|
if (*hostinfo == '[') {
|
|
v6_offset1 = 1;
|
|
v6_offset2 = 2;
|
|
s = memchr(hostinfo, ']', uri - hostinfo);
|
|
if (s == NULL) {
|
|
return APR_EGENERAL;
|
|
}
|
|
if (*++s != ':') {
|
|
s = NULL; /* no port */
|
|
}
|
|
}
|
|
else {
|
|
s = memchr(hostinfo, ':', uri - hostinfo);
|
|
}
|
|
if (s == NULL) {
|
|
/* we expect the common case to have no port */
|
|
uptr->hostname = apr_pstrmemdup(p,
|
|
hostinfo + v6_offset1,
|
|
uri - hostinfo - v6_offset2);
|
|
goto deal_with_path;
|
|
}
|
|
uptr->hostname = apr_pstrmemdup(p,
|
|
hostinfo + v6_offset1,
|
|
s - hostinfo - v6_offset2);
|
|
++s;
|
|
uptr->port_str = apr_pstrmemdup(p, s, uri - s);
|
|
if (uri != s) {
|
|
port = strtol(uptr->port_str, &endstr, 10);
|
|
uptr->port = port;
|
|
if (*endstr == '\0') {
|
|
goto deal_with_path;
|
|
}
|
|
/* Invalid characters after ':' found */
|
|
return APR_EGENERAL;
|
|
}
|
|
uptr->port = apr_uri_port_of_scheme(uptr->scheme);
|
|
goto deal_with_path;
|
|
}
|
|
|
|
/* first colon delimits username:password */
|
|
s1 = memchr(hostinfo, ':', s - hostinfo);
|
|
if (s1) {
|
|
uptr->user = apr_pstrmemdup(p, hostinfo, s1 - hostinfo);
|
|
++s1;
|
|
uptr->password = apr_pstrmemdup(p, s1, s - s1);
|
|
}
|
|
else {
|
|
uptr->user = apr_pstrmemdup(p, hostinfo, s - hostinfo);
|
|
}
|
|
hostinfo = s + 1;
|
|
goto deal_with_host;
|
|
}
|
|
|
|
/* Special case for CONNECT parsing: it comes with the hostinfo part only */
|
|
/* See the INTERNET-DRAFT document "Tunneling SSL Through a WWW Proxy"
|
|
* currently at http://www.mcom.com/newsref/std/tunneling_ssl.html
|
|
* for the format of the "CONNECT host:port HTTP/1.0" request
|
|
*/
|
|
APU_DECLARE(apr_status_t) apr_uri_parse_hostinfo(apr_pool_t *p,
|
|
const char *hostinfo,
|
|
apr_uri_t *uptr)
|
|
{
|
|
const char *s;
|
|
char *endstr;
|
|
const char *rsb;
|
|
int v6_offset1 = 0;
|
|
|
|
/* Initialize the structure. parse_uri() and parse_uri_components()
|
|
* can be called more than once per request.
|
|
*/
|
|
memset(uptr, '\0', sizeof(*uptr));
|
|
uptr->is_initialized = 1;
|
|
uptr->hostinfo = apr_pstrdup(p, hostinfo);
|
|
|
|
/* We expect hostinfo to point to the first character of
|
|
* the hostname. There must be a port, separated by a colon
|
|
*/
|
|
if (*hostinfo == '[') {
|
|
if ((rsb = strchr(hostinfo, ']')) == NULL ||
|
|
*(rsb + 1) != ':') {
|
|
return APR_EGENERAL;
|
|
}
|
|
/* literal IPv6 address */
|
|
s = rsb + 1;
|
|
++hostinfo;
|
|
v6_offset1 = 1;
|
|
}
|
|
else {
|
|
s = strchr(hostinfo, ':');
|
|
}
|
|
if (s == NULL) {
|
|
return APR_EGENERAL;
|
|
}
|
|
uptr->hostname = apr_pstrndup(p, hostinfo, s - hostinfo - v6_offset1);
|
|
++s;
|
|
uptr->port_str = apr_pstrdup(p, s);
|
|
if (*s != '\0') {
|
|
uptr->port = (unsigned short) strtol(uptr->port_str, &endstr, 10);
|
|
if (*endstr == '\0') {
|
|
return APR_SUCCESS;
|
|
}
|
|
/* Invalid characters after ':' found */
|
|
}
|
|
return APR_EGENERAL;
|
|
}
|