int
get_system_env(void)
{
int env = get_common_env();
unsigned char *term = getenv("TERM");
if (!term || (c_toupper(term[0]) == 'B' && c_toupper(term[1]) == 'E'))
env |= ENV_BE;
return env;
}
/* Parse string param="value", return value as new string or NULL if any
* error. */
unsigned char *
get_header_param(unsigned char *e, unsigned char *name)
{
unsigned char *n, *start;
again:
while (*e && c_toupper(*e++) != c_toupper(*name));
if (!*e) return NULL;
n = name + 1;
while (*n && c_toupper(*e) == c_toupper(*n)) e++, n++;
if (*n) goto again;
skip_space(e);
if (*e++ != '=') return NULL;
skip_space(e);
start = e;
if (!isquote(*e)) {
skip_nonspace(e);
} else {
unsigned char uu = *e++;
start++;
while (*e != uu) {
if (!*e) return NULL;
e++;
}
}
while (start < e && *start == ' ') start++;
while (start < e && *(e - 1) == ' ') e--;
if (start == e) return NULL;
n = mem_alloc(e - start + 1);
if (n) {
int i = 0;
while (start < e) {
n[i++] = (*start < ' ') ? '.' : *start;
start++;
}
n[i] = '\0';
}
return n;
}
long
strtolx(unsigned char *str, unsigned char **end)
{
long num;
unsigned char postfix;
errno = 0;
num = strtol((const char *)str, (char **) end, 10);
if (errno) return 0;
if (!*end) return num;
postfix = c_toupper(**end);
if (postfix == 'K') {
(*end)++;
if (num < -INT_MAX / 1024) return -INT_MAX;
if (num > INT_MAX / 1024) return INT_MAX;
return num * 1024;
}
if (postfix == 'M') {
(*end)++;
if (num < -INT_MAX / (1024 * 1024)) return -INT_MAX;
if (num > INT_MAX / (1024 * 1024)) return INT_MAX;
return num * (1024 * 1024);
}
return num;
}
static char
virshGetEscapeChar(const char *s)
{
if (*s == '^')
return CONTROL(c_toupper(s[1]));
return *s;
}
/**
* oath_base32_decode:
* @in: input string with base32 encoded data of length @inlen
* @inlen: length of input base32 string @in
* @out: pointer to output variable for binary data of length @outlen, or NULL
* @outlen: pointer to output variable holding length of @out, or NULL
*
* Decode a base32 encoded string into binary data.
*
* Space characters are ignored and pad characters are added if
* needed. Non-base32 data are not ignored but instead will lead to
* an %OATH_INVALID_BASE32 error.
*
* The @in parameter should contain @inlen bytes of base32 encoded
* data. The function allocates a new string in *@out to hold the
* decoded data, and sets *@outlen to the length of the data.
*
* If @out is NULL, then *@outlen will be set to what would have been
* the length of *@out on successful encoding.
*
* If the caller is not interested in knowing the length of the output
* data @out, then @outlen may be set to NULL.
*
* It is permitted but useless to have both @out and @outlen NULL.
*
* Returns: On success %OATH_OK (zero) is returned,
* %OATH_INVALID_BASE32 is returned if the input contains non-base32
* characters, and %OATH_MALLOC_ERROR is returned on memory allocation
* errors.
*
* Since: 1.12.0
**/
int
oath_base32_decode (const char *in, size_t inlen, char **out, size_t * outlen)
{
size_t i, j, tmplen = 0;
char *in_upcase;
char *tmp;
bool ok;
in_upcase = malloc (inlen + 6); /* leave room for up to 6 '=' */
if (!in_upcase)
return OATH_MALLOC_ERROR;
for (i = 0, j = 0; i < inlen; i++)
{
if (in[i] != ' ')
in_upcase[j++] = c_toupper (in[i]);
}
/* add pad characters if needed */
switch (j % 8)
{
case 2:
in_upcase[j++] = '=';
in_upcase[j++] = '=';
case 4:
in_upcase[j++] = '=';
case 5:
in_upcase[j++] = '=';
in_upcase[j++] = '=';
case 7:
in_upcase[j++] = '=';
default:
case 0:
break;
}
ok = base32_decode_alloc (in_upcase, j, &tmp, &tmplen);
free (in_upcase);
if (ok && !tmp)
return OATH_MALLOC_ERROR;
else if (!ok)
return OATH_INVALID_BASE32;
if (outlen)
*outlen = tmplen;
if (out)
*out = tmp;
else
free (tmp);
return OATH_OK;
}
/* compare hostname against certificate, taking account of wildcards
* return 1 on success or 0 on error
*
* note: certnamesize is required as X509 certs can contain embedded NULs in
* the strings such as CN or subjectAltName.
*
* @level: is used for recursion. Use 0 when you call this function.
*/
int
_gnutls_hostname_compare (const char *certname,
size_t certnamesize, const char *hostname, int level)
{
if (level > 5)
return 0;
/* find the first different character */
for (; *certname && *hostname && c_toupper (*certname) == c_toupper (*hostname);
certname++, hostname++, certnamesize--)
;
/* the strings are the same */
if (certnamesize == 0 && *hostname == '\0')
return 1;
if (*certname == '*')
{
/* a wildcard certificate */
certname++;
certnamesize--;
while (1)
{
/* Use a recursive call to allow multiple wildcards */
if (_gnutls_hostname_compare (certname, certnamesize, hostname, level+1))
return 1;
/* wildcards are only allowed to match a single domain
component or component fragment */
if (*hostname == '\0' || *hostname == '.')
break;
hostname++;
}
return 0;
}
return 0;
}
const char *
_cdk_memistr (const char *buf, size_t buflen, const char *sub)
{
const byte *t, *s;
size_t n;
for (t = (byte *) buf, n = buflen, s = (byte *) sub; n; t++, n--)
{
if (c_toupper (*t) == c_toupper (*s))
{
for (buf = t++, buflen = n--, s++;
n && c_toupper (*t) == c_toupper ((byte) * s); t++, s++, n--)
;
if (!*s)
return buf;
t = (byte *) buf;
n = buflen;
s = (byte *) sub;
}
}
return NULL;
}
/* Calculate the hash for a lf or lh record offset.
*/
static void
calc_hash (const char *type, const char *name, void *ret)
{
size_t len = strlen (name);
if (STRPREFIX (type, "lf"))
/* Old-style, not used in current registries. */
memcpy (ret, name, len < 4 ? len : 4);
else {
/* New-style for lh-records. */
size_t i, c;
uint32_t h = 0;
for (i = 0; i < len; ++i) {
c = c_toupper (name[i]);
h *= 37;
h += c;
}
*((uint32_t *) ret) = htole32 (h);
}
}
static void
done_read (void *data_read, size_t num_bytes_read, void *private_data)
{
struct locals *l = (struct locals *) private_data;
const char *p = l->input + l->nread;
const char *q = (const char *) data_read;
size_t i;
for (i = 0; i < num_bytes_read; i++, q++)
{
/* Handle conversion NL -> CRLF possibly done by the child process. */
if (!(O_BINARY && *q == '\r'))
{
char orig = *p;
char expected = c_toupper (orig);
ASSERT (*q == expected);
p++;
}
}
l->nread = p - l->input;
}
/**
* virStringToUpper:
* @str: string to capitalize
* @dst: where to store the new capitalized string
*
* Capitalize the string with replacement of all '-' characters for '_'
* characters. Caller frees the result.
*
* Returns 0 if src is NULL, 1 if capitalization was successful, -1 on failure.
*/
int
virStringToUpper(char **dst, const char *src)
{
char *cap = NULL;
size_t i;
if (!src)
return 0;
if (VIR_ALLOC_N(cap, strlen(src) + 1) < 0)
return -1;
for (i = 0; src[i]; i++) {
cap[i] = c_toupper(src[i]);
if (cap[i] == '-')
cap[i] = '_';
}
*dst = cap;
return 1;
}
static void
test_all (void)
{
int c;
for (c = -0x80; c < 0x100; c++)
{
ASSERT (c_isascii (c) == (c >= 0 && c < 0x80));
switch (c)
{
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
case 'Y': case 'Z':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
case 'y': case 'z':
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
ASSERT (c_isalnum (c) == 1);
break;
default:
ASSERT (c_isalnum (c) == 0);
break;
}
switch (c)
{
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
case 'Y': case 'Z':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
case 'y': case 'z':
ASSERT (c_isalpha (c) == 1);
break;
default:
ASSERT (c_isalpha (c) == 0);
break;
}
switch (c)
{
case '\t': case ' ':
ASSERT (c_isblank (c) == 1);
break;
default:
ASSERT (c_isblank (c) == 0);
break;
}
ASSERT (c_iscntrl (c) == ((c >= 0 && c < 0x20) || c == 0x7f));
switch (c)
{
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
ASSERT (c_isdigit (c) == 1);
break;
default:
ASSERT (c_isdigit (c) == 0);
break;
}
switch (c)
{
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
case 's': case 't': case 'u': case 'v': case 'w': case 'x':
case 'y': case 'z':
ASSERT (c_islower (c) == 1);
break;
default:
ASSERT (c_islower (c) == 0);
break;
}
ASSERT (c_isgraph (c) == ((c >= 0x20 && c < 0x7f) && c != ' '));
ASSERT (c_isprint (c) == (c >= 0x20 && c < 0x7f));
ASSERT (c_ispunct (c) == (c_isgraph (c) && !c_isalnum (c)));
switch (c)
{
case ' ': case '\t': case '\n': case '\v': case '\f': case '\r':
ASSERT (c_isspace (c) == 1);
break;
default:
ASSERT (c_isspace (c) == 0);
break;
}
switch (c)
{
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
case 'Y': case 'Z':
ASSERT (c_isupper (c) == 1);
break;
default:
ASSERT (c_isupper (c) == 0);
break;
}
switch (c)
{
case '0': case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
ASSERT (c_isxdigit (c) == 1);
break;
default:
ASSERT (c_isxdigit (c) == 0);
break;
}
switch (c)
{
case 'A':
ASSERT (c_tolower (c) == 'a');
ASSERT (c_toupper (c) == c);
break;
case 'B':
ASSERT (c_tolower (c) == 'b');
ASSERT (c_toupper (c) == c);
break;
case 'C':
ASSERT (c_tolower (c) == 'c');
ASSERT (c_toupper (c) == c);
break;
case 'D':
ASSERT (c_tolower (c) == 'd');
ASSERT (c_toupper (c) == c);
break;
case 'E':
ASSERT (c_tolower (c) == 'e');
ASSERT (c_toupper (c) == c);
break;
case 'F':
ASSERT (c_tolower (c) == 'f');
ASSERT (c_toupper (c) == c);
break;
case 'G':
ASSERT (c_tolower (c) == 'g');
ASSERT (c_toupper (c) == c);
break;
case 'H':
ASSERT (c_tolower (c) == 'h');
ASSERT (c_toupper (c) == c);
break;
case 'I':
ASSERT (c_tolower (c) == 'i');
ASSERT (c_toupper (c) == c);
break;
case 'J':
ASSERT (c_tolower (c) == 'j');
ASSERT (c_toupper (c) == c);
break;
case 'K':
ASSERT (c_tolower (c) == 'k');
ASSERT (c_toupper (c) == c);
break;
case 'L':
ASSERT (c_tolower (c) == 'l');
ASSERT (c_toupper (c) == c);
break;
case 'M':
ASSERT (c_tolower (c) == 'm');
ASSERT (c_toupper (c) == c);
break;
case 'N':
ASSERT (c_tolower (c) == 'n');
ASSERT (c_toupper (c) == c);
break;
case 'O':
ASSERT (c_tolower (c) == 'o');
ASSERT (c_toupper (c) == c);
break;
case 'P':
ASSERT (c_tolower (c) == 'p');
ASSERT (c_toupper (c) == c);
break;
case 'Q':
ASSERT (c_tolower (c) == 'q');
ASSERT (c_toupper (c) == c);
break;
case 'R':
ASSERT (c_tolower (c) == 'r');
ASSERT (c_toupper (c) == c);
break;
case 'S':
ASSERT (c_tolower (c) == 's');
ASSERT (c_toupper (c) == c);
break;
case 'T':
ASSERT (c_tolower (c) == 't');
ASSERT (c_toupper (c) == c);
break;
case 'U':
ASSERT (c_tolower (c) == 'u');
ASSERT (c_toupper (c) == c);
break;
case 'V':
ASSERT (c_tolower (c) == 'v');
ASSERT (c_toupper (c) == c);
break;
case 'W':
ASSERT (c_tolower (c) == 'w');
ASSERT (c_toupper (c) == c);
break;
case 'X':
ASSERT (c_tolower (c) == 'x');
ASSERT (c_toupper (c) == c);
break;
case 'Y':
ASSERT (c_tolower (c) == 'y');
ASSERT (c_toupper (c) == c);
break;
case 'Z':
ASSERT (c_tolower (c) == 'z');
ASSERT (c_toupper (c) == c);
break;
case 'a':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'A');
break;
case 'b':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'B');
break;
case 'c':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'C');
break;
case 'd':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'D');
break;
case 'e':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'E');
break;
case 'f':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'F');
break;
case 'g':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'G');
break;
case 'h':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'H');
break;
case 'i':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'I');
break;
case 'j':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'J');
break;
case 'k':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'K');
break;
case 'l':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'L');
break;
case 'm':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'M');
break;
case 'n':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'N');
break;
case 'o':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'O');
break;
case 'p':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'P');
break;
case 'q':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'Q');
break;
case 'r':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'R');
break;
case 's':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'S');
break;
case 't':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'T');
break;
case 'u':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'U');
break;
case 'v':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'V');
break;
case 'w':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'W');
break;
case 'x':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'X');
break;
case 'y':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'Y');
break;
case 'z':
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == 'Z');
break;
default:
ASSERT (c_tolower (c) == c);
ASSERT (c_toupper (c) == c);
break;
}
}
}
void *
virDriverLoadModule(const char *name)
{
char *modfile = NULL, *regfunc = NULL, *fixedname = NULL;
char *tmp;
void *handle = NULL;
int (*regsym)(void);
VIR_DEBUG("Module load %s", name);
if (!(modfile = virFileFindResourceFull(name,
"libvirt_driver_",
".so",
abs_topbuilddir "/src/.libs",
DEFAULT_DRIVER_DIR,
"LIBVIRT_DRIVER_DIR")))
return NULL;
if (access(modfile, R_OK) < 0) {
VIR_INFO("Module %s not accessible", modfile);
goto cleanup;
}
virUpdateSelfLastChanged(modfile);
handle = dlopen(modfile, RTLD_NOW | RTLD_GLOBAL);
if (!handle) {
VIR_ERROR(_("failed to load module %s %s"), modfile, dlerror());
goto cleanup;
}
if (VIR_STRDUP_QUIET(fixedname, name) < 0) {
VIR_ERROR(_("out of memory"));
goto cleanup;
}
/* convert something_like_this into somethingLikeThis */
while ((tmp = strchr(fixedname, '_'))) {
memmove(tmp, tmp + 1, strlen(tmp));
*tmp = c_toupper(*tmp);
}
if (virAsprintfQuiet(®func, "%sRegister", fixedname) < 0)
goto cleanup;
regsym = dlsym(handle, regfunc);
if (!regsym) {
VIR_ERROR(_("Missing module registration symbol %s"), regfunc);
goto cleanup;
}
if ((*regsym)() < 0) {
VIR_ERROR(_("Failed module registration %s"), regfunc);
goto cleanup;
}
VIR_FREE(modfile);
VIR_FREE(regfunc);
VIR_FREE(fixedname);
return handle;
cleanup:
VIR_FREE(modfile);
VIR_FREE(regfunc);
VIR_FREE(fixedname);
if (handle)
dlclose(handle);
return NULL;
}
/** Searches for a message-header with the specified field-name.
*
* @param[in] head
* Where to start searching in the message received from the server.
* This function actually ignores the line to which @a head points,
* and starts searching from the next line. Therefore, when parsing
* an HTTP message, @a head should initially point to the start-line,
* e.g. "HTTP/1.1 200 OK". Alternatively, if the caller has already
* found a message-header and wants to know if there are any more
* message-headers with the same field-name, then @a head can be the
* pointer that a previous call stored in *@a ptr.
* @param[in] item
* The field-name for which this function searches.
* @param[out] ptr
* If @a ptr is not NULL, and this function finds a message-header,
* then this function stores in *@a ptr the address at which the
* field-content begins; the caller may pass that as @a head in a
* later call. Otherwise, this function does not modify *@a ptr.
* @returns
* NULL if not found or out of memory. Otherwise, a copy of the
* field-content of the message-header; the caller must eventually
* mem_free() it.
*
* The terms message-header, field-name, start-line, and field-content
* are defined in RFC 2616 sections 4.1 and 4.2. */
unsigned char *
parse_header(unsigned char *head, const unsigned char *item, unsigned char **ptr)
{
unsigned char *pos = head;
if (!pos) return NULL;
while (*pos) {
unsigned char *end, *value;
const unsigned char *itempos;
int len;
/* Go for a newline. */
while (*pos && *pos != ASCII_LF) pos++;
if (!*pos) break;
pos++; /* Start of line now. */
/* Does item match header line ? */
for (itempos = item; *itempos && *pos; itempos++, pos++)
if (c_toupper(*itempos) != c_toupper(*pos))
break;
if (!*pos) break; /* Nothing left to parse. */
if (*itempos) continue; /* Do not match. */
/* Be tolerant: we accept headers with
* weird syntax, since most browsers does it
* anyway, ie:
* name value
* name :value
* name = value
* name[TAB]:[TAB]value */
end = pos;
/* Skip leading whitespaces if any. */
while (LWS(*pos)) pos++;
if (!*pos) break; /* Nothing left to parse. */
/* Eat ':' or '=' if any. */
if (*pos == ':' || *pos == '=') pos++;
if (!*pos) break; /* Nothing left to parse. */
/* Skip whitespaces after separator if any. */
while (LWS(*pos)) pos++;
if (!*pos) break; /* Nothing left to parse. */
if (pos == end) continue; /* Not an exact match (substring). */
/* Find the end of line/string.
* We fail on control chars and DEL char. */
end = pos;
while (*end != ASCII_DEL && (*end > ' ' || LWS(*end))) end++;
if (!*end) break; /* No end of line, nothing left to parse. */
/* Ignore line if we encountered an unexpected char. */
if (*end != ASCII_CR && *end != ASCII_LF) continue;
/* Strip trailing whitespaces. */
while (end > pos && LWS(end[-1])) end--;
len = end - pos;
assert(len >= 0);
if_assert_failed break;
if (!len) continue; /* Empty value. */
value = memacpy(pos, len);
if (!value) break; /* Allocation failure, stop here. */
if (ptr) *ptr = pos;
return value;
}
return NULL;
}
/** Checks whether a host name matches a pattern that may contain
* wildcards.
*
* @param[in] hostname
* The host name to which the user wanted to connect.
* Should be in UTF-8 and need not be null-terminated.
* @param[in] hostname_length
* The length of @a hostname, in bytes.
* @param[in] pattern
* A pattern that the host name might match.
* Should be in UTF-8 and need not be null-terminated.
* The pattern may contain wildcards, as specified in
* RFC 2818 section 3.1.
* @param[in] pattern_length
* The length of @a pattern, in bytes.
*
* @return
* Nonzero if the host name matches. Zero if it doesn't.
*
* According to RFC 2818 section 3.1, '*' matches any number of
* characters except '.'. For example, "*r*.example.org" matches
* "random.example.org" or "history.example.org" but not
* "frozen.fruit.example.org".
*
* This function does not allocate memory, and consumes at most
* O(@a hostname_length * @a pattern_length) time. */
int
match_hostname_pattern(const unsigned char *hostname,
size_t hostname_length,
const unsigned char *pattern,
size_t pattern_length)
{
const unsigned char *const hostname_end = hostname + hostname_length;
const unsigned char *const pattern_end = pattern + pattern_length;
assert(hostname <= hostname_end);
assert(pattern <= pattern_end);
if_assert_failed return 0;
while (pattern < pattern_end) {
if (*pattern == '*') {
const unsigned char *next_wildcard;
size_t literal_length;
++pattern;
next_wildcard = memchr(pattern, '*',
pattern_end - pattern);
if (next_wildcard == NULL)
literal_length = pattern_end - pattern;
else
literal_length = next_wildcard - pattern;
for (;;) {
size_t hostname_left = hostname_end - hostname;
unicode_val_T uni;
if (hostname_left < literal_length)
return 0;
/* If next_wildcard == NULL, then the
* literal string is at the end of the
* pattern, so anchor the match to the
* end of the hostname. The end of
* this function can then easily
* verify that the whole hostname was
* matched.
*
* But do not jump directly there;
* first verify that there are no '.'
* characters in between. */
if ((next_wildcard != NULL
|| hostname_left == literal_length)
&& !c_strlcasecmp(pattern, literal_length,
hostname, literal_length))
break;
/* The literal string doesn't match here.
* Skip one character of the hostname and
* retry. If the skipped character is '.'
* or one of the equivalent characters
* listed in RFC 3490 section 3.1
* requirement 1, then return 0, because
* '*' must not match such characters.
* Do the same if invalid UTF-8 is found.
* Cast away const. */
uni = utf8_to_unicode((unsigned char **) hostname,
hostname_end);
if (uni == 0x002E
|| uni == 0x3002
|| uni == 0xFF0E
|| uni == 0xFF61
|| uni == UCS_NO_CHAR)
return 0;
}
pattern += literal_length;
hostname += literal_length;
} else {
if (hostname == hostname_end)
return 0;
if (c_toupper(*pattern) != c_toupper(*hostname))
return 0;
++pattern;
++hostname;
}
}
return hostname == hostname_end;
}
// Convert token to i-code
// Return byte length or 0
unsigned char toktoi() {
unsigned char i; // Loop counter(i-code sometime)
unsigned char len = 0; //byte counter
char* pkw = 0; // Temporary keyword pointer
char* ptok; // Temporary token pointer
char* s = lbuf; // Pointer to charactor at line buffer
char c; // Surround the string character, " or '
short value; //numeric
short tmp; //numeric for overflow check
while (*s) {
while (c_isspace(*s)) s++; // Skip space
//Try keyword conversion
for (i = 0; i < SIZE_KWTBL; i++) {
pkw = (char *)kwtbl[i]; // Point keyword
ptok = s; // Point top of command line
// Compare 1 keyword
while ((*pkw != 0) && (*pkw == c_toupper(*ptok))) {
pkw++;
ptok++;
}
if (*pkw == 0) {// Case success
if (len >= SIZE_IBUF - 1) {// List area full
err = ERR_IBUFOF;
return 0;
}
// i have i-code
ibuf[len++] = i;
s = ptok;
break;
}
}
// Case statement needs an argument except numeric, valiable, or strings
if(i == I_REM) {
while (c_isspace(*s)) s++; // Skip space
ptok = s;
for (i = 0; *ptok++; i++); // Get length
if (len >= SIZE_IBUF - 2 - i) {
err = ERR_IBUFOF;
return 0;
}
ibuf[len++] = i; // Put length
while (i--) { // Copy strings
ibuf[len++] = *s++;
}
break;
}
if (*pkw == 0)
continue;
ptok = s; // Point top of command line
// Try numeric conversion
if (c_isdigit(*ptok)) {
value = 0;
tmp = 0;
do {
tmp = 10 * value + *ptok++ - '0';
if (value > tmp) {
err = ERR_VOF;
return 0;
}
value = tmp;
} while (c_isdigit(*ptok));
if (len >= SIZE_IBUF - 3) {
err = ERR_IBUFOF;
return 0;
}
ibuf[len++] = I_NUM;
ibuf[len++] = value & 255;
ibuf[len++] = value >> 8;
s = ptok;
}
else
// Try string conversion
if (*s == '\"' || *s == '\'') {// If start of string
static void
tag_handle_meta (int tagid, struct taginfo *tag, struct map_context *ctx)
{
char *name = find_attr (tag, "name", NULL);
char *http_equiv = find_attr (tag, "http-equiv", NULL);
if (http_equiv && 0 == strcasecmp (http_equiv, "refresh"))
{
/* Some pages use a META tag to specify that the page be
refreshed by a new page after a given number of seconds. The
general format for this is:
<meta http-equiv=Refresh content="NUMBER; URL=index2.html">
So we just need to skip past the "NUMBER; URL=" garbage to
get to the URL. */
struct urlpos *entry;
int attrind;
int timeout = 0;
char *p;
char *refresh = find_attr (tag, "content", &attrind);
if (!refresh)
return;
for (p = refresh; c_isdigit (*p); p++)
timeout = 10 * timeout + *p - '0';
if (*p++ != ';')
return;
while (c_isspace (*p))
++p;
if (!( c_toupper (*p) == 'U'
&& c_toupper (*(p + 1)) == 'R'
&& c_toupper (*(p + 2)) == 'L'
&& *(p + 3) == '='))
return;
p += 4;
while (c_isspace (*p))
++p;
entry = append_url (p, ATTR_POS(tag,attrind,ctx),
ATTR_SIZE(tag,attrind), ctx);
if (entry)
{
entry->link_refresh_p = 1;
entry->refresh_timeout = timeout;
entry->link_expect_html = 1;
}
}
else if (http_equiv && 0 == strcasecmp (http_equiv, "content-type"))
{
/* Handle stuff like:
<meta http-equiv="Content-Type" content="text/html; charset=CHARSET"> */
char *mcharset;
char *content = find_attr (tag, "content", NULL);
if (!content)
return;
mcharset = parse_charset (content);
if (!mcharset)
return;
xfree_null (meta_charset);
meta_charset = mcharset;
}
else if (name && 0 == strcasecmp (name, "robots"))
{
/* Handle stuff like:
<meta name="robots" content="index,nofollow"> */
char *content = find_attr (tag, "content", NULL);
if (!content)
return;
if (!strcasecmp (content, "none"))
ctx->nofollow = true;
else
{
while (*content)
{
char *end;
/* Skip any initial whitespace. */
content += strspn (content, " \f\n\r\t\v");
/* Find the next occurrence of ',' or whitespace,
* or the end of the string. */
end = content + strcspn (content, ", \f\n\r\t\v");
if (!strncasecmp (content, "nofollow", end - content))
ctx->nofollow = true;
/* Skip past the next comma, if any. */
if (*end == ',')
++end;
else
{
end = strchr (end, ',');
if (end)
++end;
else
end = content + strlen (content);
}
content = end;
}
}
}
}
iconv_t
rpl_iconv_open (const char *tocode, const char *fromcode)
#undef iconv_open
{
char fromcode_upper[32];
char tocode_upper[32];
char *fromcode_upper_end;
char *tocode_upper_end;
#if REPLACE_ICONV_UTF
/* Special handling of conversion between UTF-8 and UTF-{16,32}{BE,LE}.
Do this here, before calling the real iconv_open(), because OSF/1 5.1
iconv() to these encoding inserts a BOM, which is wrong.
We do not need to handle conversion between arbitrary encodings and
UTF-{16,32}{BE,LE}, because the 'striconveh' module implements two-step
conversion through UTF-8.
The _ICONV_* constants are chosen to be disjoint from any iconv_t
returned by the system's iconv_open() functions. Recall that iconv_t
is a scalar type. */
if (c_toupper (fromcode[0]) == 'U'
&& c_toupper (fromcode[1]) == 'T'
&& c_toupper (fromcode[2]) == 'F'
&& fromcode[3] == '-')
{
if (c_toupper (tocode[0]) == 'U'
&& c_toupper (tocode[1]) == 'T'
&& c_toupper (tocode[2]) == 'F'
&& tocode[3] == '-')
{
if (strcmp (fromcode + 4, "8") == 0)
{
if (c_strcasecmp (tocode + 4, "16BE") == 0)
return _ICONV_UTF8_UTF16BE;
if (c_strcasecmp (tocode + 4, "16LE") == 0)
return _ICONV_UTF8_UTF16LE;
if (c_strcasecmp (tocode + 4, "32BE") == 0)
return _ICONV_UTF8_UTF32BE;
if (c_strcasecmp (tocode + 4, "32LE") == 0)
return _ICONV_UTF8_UTF32LE;
}
else if (strcmp (tocode + 4, "8") == 0)
{
if (c_strcasecmp (fromcode + 4, "16BE") == 0)
return _ICONV_UTF16BE_UTF8;
if (c_strcasecmp (fromcode + 4, "16LE") == 0)
return _ICONV_UTF16LE_UTF8;
if (c_strcasecmp (fromcode + 4, "32BE") == 0)
return _ICONV_UTF32BE_UTF8;
if (c_strcasecmp (fromcode + 4, "32LE") == 0)
return _ICONV_UTF32LE_UTF8;
}
}
}
#endif
/* Do *not* add special support for 8-bit encodings like ASCII or ISO-8859-1
here. This would lead to programs that work in some locales (such as the
"C" or "en_US" locales) but do not work in East Asian locales. It is
better if programmers make their programs depend on GNU libiconv (except
on glibc systems), e.g. by using the AM_ICONV macro and documenting the
dependency in an INSTALL or DEPENDENCIES file. */
/* Try with the original names first.
This covers the case when fromcode or tocode is a lowercase encoding name
that is understood by the system's iconv_open but not listed in our
mappings table. */
{
iconv_t cd = iconv_open (tocode, fromcode);
if (cd != (iconv_t)(-1))
return cd;
}
/* Convert the encodings to upper case, because
1. in the arguments of iconv_open() on AIX, HP-UX, and OSF/1 the case
matters,
2. it makes searching in the table faster. */
{
const char *p = fromcode;
char *q = fromcode_upper;
while ((*q = c_toupper (*p)) != '\0')
{
p++;
q++;
if (q == &fromcode_upper[SIZEOF (fromcode_upper)])
{
errno = EINVAL;
return (iconv_t)(-1);
}
}
fromcode_upper_end = q;
}
{
const char *p = tocode;
char *q = tocode_upper;
while ((*q = c_toupper (*p)) != '\0')
{
p++;
q++;
if (q == &tocode_upper[SIZEOF (tocode_upper)])
{
errno = EINVAL;
return (iconv_t)(-1);
}
}
tocode_upper_end = q;
}
#ifdef ICONV_FLAVOR
/* Apply the mappings. */
{
const struct mapping *m =
mapping_lookup (fromcode_upper, fromcode_upper_end - fromcode_upper);
fromcode = (m != NULL ? m->vendor_name : fromcode_upper);
}
{
const struct mapping *m =
mapping_lookup (tocode_upper, tocode_upper_end - tocode_upper);
tocode = (m != NULL ? m->vendor_name : tocode_upper);
}
#else
fromcode = fromcode_upper;
tocode = tocode_upper;
#endif
return iconv_open (tocode, fromcode);
}
void
html_li(struct html_context *html_context, unsigned char *a,
unsigned char *xxx3, unsigned char *xxx4, unsigned char **xxx5)
{
int t = par_format.flags & P_LISTMASK;
/* When handling the code <li><li> @was_li will be 1 and it means we
* have to insert a line break since no list item content has done it
* for us. */
if (html_context->was_li) {
html_context->line_breax = 0;
ln_break(html_context, 1);
}
/*kill_html_stack_until(html_context, 0
"", "UL", "OL", NULL);*/
if (t == P_NO_BULLET) {
/* Print nothing. */
} else if (!par_format.list_number) {
if (t == P_O) /* Print U+25E6 WHITE BULLET. */
put_chrs(html_context, (unsigned char *)"◦", 7);
else if (t == P_SQUARE) /* Print U+25AA BLACK SMALL SQUARE. */
put_chrs(html_context, (unsigned char *)"▪", 7);
else /* Print U+2022 BULLET. */
put_chrs(html_context, (unsigned char *)"•", 7);
put_chrs(html_context, (unsigned char *)" ", 6);
par_format.leftmargin += 2;
par_format.align = ALIGN_LEFT;
} else {
unsigned char c = 0;
int nlen;
int t = par_format.flags & P_LISTMASK;
int s = get_num(a, (unsigned char *)"value", html_context->doc_cp);
struct string n;
if (!init_string(&n)) return;
if (s != -1) par_format.list_number = s;
if (t == P_ALPHA || t == P_alpha) {
unsigned char n0;
put_chrs(html_context, (unsigned char *)" ", 6);
c = 1;
n0 = par_format.list_number
? (par_format.list_number - 1) % 26
+ (t == P_ALPHA ? 'A' : 'a')
: 0;
if (n0) add_char_to_string(&n, n0);
} else if (t == P_ROMAN || t == P_roman) {
roman(&n, par_format.list_number);
if (t == P_ROMAN) {
unsigned char *x;
for (x = n.source; *x; x++) *x = c_toupper(*x);
}
} else {
unsigned char n0[64];
if (par_format.list_number < 10) {
put_chrs(html_context, (unsigned char *)" ", 6);
c = 1;
}
ulongcat(n0, NULL, par_format.list_number, (sizeof(n) - 1), 0);
add_to_string(&n, n0);
}
nlen = n.length;
put_chrs(html_context, n.source, nlen);
put_chrs(html_context, (unsigned char *)". ", 7);
par_format.leftmargin += nlen + c + 2;
par_format.align = ALIGN_LEFT;
done_string(&n);
{
struct html_element *element;
element = search_html_stack(html_context, (unsigned char *)"ol");
if (element)
element->parattr.list_number = par_format.list_number + 1;
}
par_format.list_number = 0;
}
html_context->putsp = HTML_SPACE_SUPPRESS;
html_context->line_breax = 2;
html_context->was_li = 1;
}
