static void test_decodev(dAT)
{
char src1[] = "%2540%2";
char src2[] = "0%u0";
char src3[] = "041";
struct iovec iovec1[] = {
{ src1, sizeof(src1) - 1 },
{ src2, sizeof(src2) - 1 },
{ src3, sizeof(src3) - 1 },
};
struct iovec iovec2[] = {
{ src1, sizeof(src1) - 1 },
{ src2, sizeof(src2) - 1 },
};
const char expect1[] = "%40 A";
const char expect2[] = "%40 ";
char dest[sizeof(src1) + sizeof(src2) + sizeof(src3)];
apr_size_t dest_len;
apr_status_t status;
status = apreq_decodev(dest, &dest_len, iovec1, 3);
AT_int_eq(status, APR_SUCCESS);
AT_int_eq(dest_len, sizeof(expect1) - 1);
AT_mem_eq(dest, expect1, sizeof(expect1) - 1);
status = apreq_decodev(dest, &dest_len, iovec2, 2);
AT_int_eq(status, APR_INCOMPLETE);
AT_int_eq(dest_len, sizeof(expect2) - 1);
AT_mem_eq(dest, expect2, sizeof(expect2) - 1);
}
static void quote_strings(dAT)
{
apr_size_t exp_len, res_len, res_quote_len;
char *res = apr_palloc(p,24);
char *res_quote = apr_palloc(p,24);
const char *expr;
int i;
const char * arr[] = {"cest", "\"cest", "ce\"st", "\"cest\""};
const char * arr_quote[] =
{"\"cest\"", "\"\\\"cest\"", "\"ce\\\"st\"", "\"\\\"cest\\\"\""};
apr_size_t arr_len[] = {4, 5, 5, 6};
apr_size_t arr_quote_len[] = {6, 8, 8, 10};
for (i=0; i<4; i++) {
res_len = apreq_quote(res, arr[i], arr_len[i]);
AT_int_eq(res_len, arr_quote_len[i]);
AT_mem_eq(res, arr_quote[i], res_len);
res_quote_len = apreq_quote_once(res_quote, res, res_len);
AT_int_eq(res_quote_len, res_len);
AT_mem_eq(res_quote, res, res_len);
res_len = apreq_quote_once(res, arr[i], arr_len[i]);
exp_len = (i == 3) ? arr_len[i] : arr_quote_len[i];
expr = (i == 3) ? arr[i] : arr_quote[i];
AT_int_eq(res_len, exp_len);
AT_mem_eq(res, expr, exp_len);
}
}
static void make_param(dAT)
{
apreq_param_t *param, *decode;
apr_status_t s;
apr_size_t nlen = 3, vlen = 11;
char *name = apr_palloc(p,nlen+1);
char *val = apr_palloc(p,vlen+1);
char *encode;
strcpy(name, "foo");
strcpy(val, "bar > alpha");
param = apreq_param_make(p, name, nlen, val, vlen);
AT_str_eq(param->v.name, name);
AT_int_eq(param->v.dlen, vlen);
AT_str_eq(param->v.data, val);
encode = apreq_param_encode(p, param);
AT_str_eq(encode, "foo=bar+%3E+alpha");
s = apreq_param_decode(&decode, p, encode, nlen, vlen+2);
AT_int_eq(s, APR_SUCCESS);
AT_str_eq(decode->v.name, name);
AT_int_eq(decode->v.dlen, vlen);
AT_str_eq(decode->v.data, val);
}
static void request_make(dAT)
{
apr_status_t s;
args = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(args);
s = apreq_parse_query_string(p, args, query_string);
AT_int_eq(s, APR_SUCCESS);
AT_int_eq(apr_table_elts(args)->nelts, 9);
}
static void jar_make(dAT)
{
jar = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar);
AT_int_eq(apreq_parse_cookie_header(p, jar, nscookies), APREQ_ERROR_NOTOKEN);
jar2 = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar2);
AT_int_eq(apreq_parse_cookie_header(p, jar2, rfccookies), APR_SUCCESS);
}
static void version_type(dAT)
{
apr_version_t v;
apreq_version(&v);
AT_int_eq(v.major, APREQ_MAJOR_VERSION);
AT_int_eq(v.minor, APREQ_MINOR_VERSION);
AT_int_eq(v.patch, APREQ_PATCH_VERSION);
#ifdef APREQ_IS_DEV_VERSION
AT_int_eq(v.is_dev, 1);
#else
AT_int_eq(v.is_dev, 0);
#endif
}
static void netscape_cookie(dAT)
{
char expires[APR_RFC822_DATE_LEN];
char *val;
apreq_cookie_t *c;
*(const char **)&val = apr_table_get(jar, "foo");
AT_not_null(val);
c = apreq_value_to_cookie(val);
AT_str_eq(c->v.data, "bar");
AT_int_eq(apreq_cookie_version(c), 0);
AT_str_eq(apreq_cookie_as_string(c, p), "foo=bar");
c->domain = apr_pstrdup(p, "example.com");
AT_str_eq(apreq_cookie_as_string(c, p), "foo=bar; domain=example.com");
c->path = apr_pstrdup(p, "/quux");
AT_str_eq(apreq_cookie_as_string(c, p),
"foo=bar; path=/quux; domain=example.com");
apreq_cookie_expires(c, "+1y");
apr_rfc822_date(expires, apr_time_now()
+ apr_time_from_sec(apreq_atoi64t("+1y")));
expires[7] = '-';
expires[11] = '-';
val = apr_pstrcat(p, "foo=bar; path=/quux; domain=example.com; expires=",
expires, NULL);
AT_str_eq(apreq_cookie_as_string(c, p), val);
}
static void test_atoi64t(dAT)
{
AT_int_eq(apreq_atoi64t("0"), 0);
AT_int_eq(apreq_atoi64t("-1"), -1);
AT_int_eq(apreq_atoi64t("-g088l3dyg00k"), 0);
AT_int_eq(apreq_atoi64t("5s"), 5);
AT_int_eq(apreq_atoi64t("3.333"), 3);
AT_int_eq(apreq_atoi64t("33d"), 33 * 60 * 60 * 24);
AT_int_eq(apreq_atoi64t(" +8M "), 8 * 60 * 60 * 24 * 30);
AT_int_eq(apreq_atoi64t("+9m"), 9 * 60);
AT_int_eq(apreq_atoi64t("6h"), 6 * 60 * 60);
}
static void test_header_attribute(dAT)
{
const char hdr[] = "filename=\"filename=foo\" filename=\"quux.txt\"";
const char *val;
apr_size_t vlen;
AT_int_eq(apreq_header_attribute(hdr+4, "name", 4, &val, &vlen),
APR_SUCCESS);
AT_int_eq(vlen, 12);
AT_mem_eq("filename=foo", val, 12);
AT_int_eq(apreq_header_attribute(hdr+4, "filename", 8, &val, &vlen),
APR_SUCCESS);
AT_int_eq(vlen, 8);
AT_mem_eq("quux.txt", val, 8);
}
static void params_as(dAT)
{
const char *val;
apr_array_header_t *arr;
arr = apreq_params_as_array(p,args,"a");
AT_int_eq(arr->nelts, 2);
val = apreq_params_as_string(p,args,"a",APREQ_JOIN_AS_IS);
AT_str_eq(val, "1, 2");
val = apreq_params_as_string(p,args,"does_not_exist",APREQ_JOIN_AS_IS);
AT_str_eq(val, "");
}
static void test_quote(dAT)
{
size_t len;
char dst[64];
len = apreq_quote(dst, "foo", 3);
AT_int_eq(len, 5);
AT_str_eq(dst, "\"foo\"");
len = apreq_quote(dst, "\"foo", 4);
AT_int_eq(len, 7);
AT_str_eq(dst, "\"\\\"foo\"");
len = apreq_quote(dst, "foo\\bar", 7);
AT_int_eq(len, 10);
AT_str_eq(dst, "\"foo\\\\bar\"");
len = apreq_quote(dst, "foo\0bar", 7);
AT_int_eq(len, 10);
AT_str_eq(dst, "\"foo\\0bar\"");
}
static void test_quote_once(dAT)
{
size_t len;
char dst[64];
len = apreq_quote_once(dst, "foo", 3);
AT_int_eq(len, 5);
AT_str_eq(dst, "\"foo\"");
len = apreq_quote_once(dst, "\"foo", 4);
AT_int_eq(len, 7);
AT_str_eq(dst, "\"\\\"foo\"");
len = apreq_quote_once(dst, "foo\"", 4);
AT_int_eq(len, 7);
AT_str_eq(dst, "\"foo\\\"\"");
len = apreq_quote_once(dst, "foo\0bar", 7);
AT_int_eq(len, 10);
AT_str_eq(dst, "\"foo\\0bar\"");
/* null byte must be escaped, even when there are already double
quotes */
len = apreq_quote_once(dst, "\"foo\0bar\"", 9);
AT_int_eq(len, 14);
AT_str_eq(dst, "\"\\\"foo\\0bar\\\"\"");
len = apreq_quote_once(dst, "\"foo\"", 5);
AT_int_eq(len, 5);
AT_str_eq(dst, "\"foo\"");
len = apreq_quote_once(dst, "'foo'", 5);
AT_int_eq(len, 7);
AT_str_eq(dst, "\"'foo'\"");
len = apreq_quote_once(dst, "\"fo\\o\"", 6);
AT_int_eq(len, 6);
AT_str_eq(dst, "\"fo\\o\"");
len = apreq_quote_once(dst, "\"foo\"bar\"", 9);
AT_int_eq(len, 14);
AT_str_eq(dst, "\"\\\"foo\\\"bar\\\"\"");
}
static void header_attributes(dAT)
{
const char *hdr = "text/plain; boundary=\"-foo-\", charset=ISO-8859-1";
const char *val;
apr_size_t vlen;
apr_status_t s;
s = apreq_header_attribute(hdr, "none", 4, &val, &vlen);
AT_int_eq(s, APREQ_ERROR_NOATTR);
s = apreq_header_attribute(hdr, "set", 3, &val, &vlen);
AT_int_eq(s, APREQ_ERROR_NOATTR);
s = apreq_header_attribute(hdr, "boundary", 8, &val, &vlen);
AT_int_eq(s, APR_SUCCESS);
AT_int_eq(vlen, 5);
AT_mem_eq(val, "-foo-", 5);
s = apreq_header_attribute(hdr, "charset", 7, &val, &vlen);
AT_int_eq(s, APR_SUCCESS);
AT_int_eq(vlen, 10);
AT_mem_eq(val, "ISO-8859-1", 10);
hdr = "max-age=20; no-quote=\"...";
s = apreq_header_attribute(hdr, "max-age", 7, &val, &vlen);
AT_int_eq(s, APR_SUCCESS);
AT_int_eq(vlen, 2);
AT_mem_eq(val, "20", 2);
s = apreq_header_attribute(hdr, "age", 3, &val, &vlen);
AT_int_eq(s, APREQ_ERROR_BADSEQ);
s = apreq_header_attribute(hdr, "no-quote", 8, &val, &vlen);
AT_int_eq(s, APREQ_ERROR_BADSEQ);
}
static void rfc_cookie(dAT)
{
apreq_cookie_t *c = apreq_cookie_make(p,"rfc",3,"out",3);
const char *expected;
long expires;
AT_str_eq(c->v.data, "out");
apreq_cookie_version_set(c, 1);
AT_int_eq(apreq_cookie_version(c), 1);
AT_str_eq(apreq_cookie_as_string(c,p),"rfc=out; Version=1");
c->domain = apr_pstrdup(p, "example.com");
#ifndef WIN32
AT_str_eq(apreq_cookie_as_string(c,p),
"rfc=out; Version=1; domain=\"example.com\"");
c->path = apr_pstrdup(p, "/quux");
AT_str_eq(apreq_cookie_as_string(c,p),
"rfc=out; Version=1; path=\"/quux\"; domain=\"example.com\"");
apreq_cookie_expires(c, "+3m");
expires = apreq_atoi64t("+3m");
expected = apr_psprintf(p, "rfc=out; Version=1; path=\"/quux\"; "
"domain=\"example.com\"; max-age=%ld",
expires);
AT_str_eq(apreq_cookie_as_string(c,p), expected);
#else
expected = "rfc=out; Version=1; domain=\"example.com\"";
AT_str_eq(apreq_cookie_as_string(c,p), expected);
c->path = apr_pstrdup(p, "/quux");
expected = "rfc=out; Version=1; path=\"/quux\"; domain=\"example.com\"";
AT_str_eq(apreq_cookie_as_string(c,p), expected);
apreq_cookie_expires(c, "+3m");
expires = apreq_atoi64t("+3m");
expected = apr_psprintf(p, "rfc=out; Version=1; path=\"/quux\"; "
"domain=\"example.com\"; max-age=%ld",
expires);
AT_str_eq(apreq_cookie_as_string(c,p), expected);
#endif
}
static void test_atoi64f(dAT)
{
AT_int_eq(apreq_atoi64f("0"), 0);
AT_int_eq(apreq_atoi64f("-1"), -1);
AT_int_eq(apreq_atoi64f("-"), 0);
AT_int_eq(apreq_atoi64f("5"), 5);
AT_int_eq(apreq_atoi64f("3.333"), 3);
AT_int_eq(apreq_atoi64f("33k"), 33 * 1024);
AT_int_eq(apreq_atoi64f(" +8M "), 8 * 1024 * 1024);
AT_ok(apreq_atoi64f("44GB") == (apr_int64_t)44 * 1024 * 1024 * 1024,
"44GB test");
AT_ok(apreq_atoi64f("0xaBcDefg") == (apr_int64_t)11259375 * 1024 * 1024 * 1024,
"hex test");
}
static void test_decode(dAT)
{
apr_size_t elen;
char src1[] = "%C3%80%E3%82%a2"; /* A_GRAVE KATAKANA_A as utf8 */
unsigned char expect[6];
AT_int_eq(apreq_decode((char *)expect, &elen, src1, sizeof(src1) -1),
APR_SUCCESS);
AT_int_eq(elen, 5);
AT_int_eq(expect[0], 0xC3);
AT_int_eq(expect[1], 0x80);
AT_int_eq(expect[2], 0xE3);
AT_int_eq(expect[3], 0x82);
AT_int_eq(expect[4], 0xA2);
}
static void request_args_get(dAT)
{
const char *val;
const apreq_param_t *param;
AT_str_eq(apr_table_get(args,"a"), "1");
val = apr_table_get(args,"quux");
AT_str_eq(val, "foo bar");
param = apreq_value_to_param(val);
AT_int_eq(param->v.dlen, 7);
AT_str_eq(apr_table_get(args,"plus"), "+");
AT_str_eq(apr_table_get(args,"uplus"), "+");
AT_str_eq(apr_table_get(args,"okie"), "dokie");
AT_str_eq(apr_table_get(args,"novalue1"), "");
AT_str_eq(apr_table_get(args,"novalue2"),"");
}
static void test_index(dAT)
{
const char haystack[] = "Four score and seven years ago";
apr_size_t hlen = sizeof haystack - 1;
AT_int_eq(apreq_index(haystack, hlen, "Four", 4, APREQ_MATCH_FULL),
0);
AT_int_eq(apreq_index(haystack, hlen, "Four", 4, APREQ_MATCH_PARTIAL),
0);
AT_int_eq(apreq_index(haystack, hlen, "Fourteen", 8, APREQ_MATCH_FULL),
-1);
AT_int_eq(apreq_index(haystack, hlen, "Fourteen", 8, APREQ_MATCH_PARTIAL),
-1);
AT_int_eq(apreq_index(haystack, hlen, "agoraphobia", 11, APREQ_MATCH_FULL),
-1);
AT_int_eq(apreq_index(haystack, hlen, "agoraphobia", 11, APREQ_MATCH_PARTIAL),
hlen - 3);
}
static void test_cp1252_to_utf8(dAT)
{
char src1[] = "%C3%80%E3%82%a2"; /* A_GRAVE KATAKANA_A as utf8 */
char src2[5];
unsigned char expect[16];
apr_size_t slen;
AT_int_eq(apreq_decode((char *)src2, &slen, src1, sizeof(src1) -1),
APR_SUCCESS);
AT_int_eq(apreq_cp1252_to_utf8((char *)expect, src2, 5),
12);
/* 0xC3 */
AT_int_eq(expect[0], 0xC0 | (0xC3 >> 6));
AT_int_eq(expect[1], 0xC3 - 0x40);
/* 0x20AC */
AT_int_eq(expect[2], 0xE0 | (0x20AC >> 12));
AT_int_eq(expect[3], 0x80 | ((0x20AC >> 6) & 0x3F));
AT_int_eq(expect[4], 0x80 | (0x20AC & 0x3F));
/* 0xE3 */
AT_int_eq(expect[5], 0xC3);
AT_int_eq(expect[6], 0xE3 - 0x40);
/* 0x201A */
AT_int_eq(expect[7], 0xE0 | (0x201A >> 12));
AT_int_eq(expect[8], 0x80 | ((0x201A >> 6) & 0x3F));
AT_int_eq(expect[9], 0x80 | (0x201A & 0x3F));
/* 0xA2 */
AT_int_eq(expect[10], 0xC0 | (0xA2 >> 6));
AT_int_eq(expect[11], 0xA2);
}
static void jar_make(dAT)
{
jar = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar);
AT_int_eq(apreq_parse_cookie_header(p, jar, nscookies), APREQ_ERROR_NOTOKEN);
jar2 = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar2);
AT_int_eq(apreq_parse_cookie_header(p, jar2, rfccookies), APR_SUCCESS);
jar3 = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar3);
AT_int_eq(apreq_parse_cookie_header(p, jar3, wpcookies), APREQ_ERROR_NOTOKEN);
jar4 = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar4);
AT_int_eq(apreq_parse_cookie_header(p, jar4, cgcookies1), APREQ_ERROR_MISMATCH);
jar5 = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar5);
AT_int_eq(apreq_parse_cookie_header(p, jar5, cgcookies2), APREQ_ERROR_MISMATCH);
jar6 = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar6);
AT_int_eq(apreq_parse_cookie_header(p, jar6, cgcookies3), APREQ_ERROR_MISMATCH);
jar7 = apr_table_make(p, APREQ_DEFAULT_NELTS);
AT_not_null(jar7);
AT_int_eq(apreq_parse_cookie_header(p, jar7, cgcookies4), APR_SUCCESS);
}
static void test_charset_divine(dAT)
{
apr_size_t elen;
char src1[] = "%C3%80%E3%82%a2"; /* A_GRAVE KATAKANA_A as utf8 */
char src2[] = "pound%A3";/* latin-1 */
char src3[] = "euro%80";/* cp-1252 */
char expect[7];
AT_int_eq(apreq_decode(expect, &elen, src1, sizeof(src1) -1),
APR_SUCCESS);
AT_int_eq(apreq_charset_divine(expect, elen), APREQ_CHARSET_UTF8);
AT_int_eq(apreq_decode(expect, &elen, src2, sizeof(src2) -1),
APR_SUCCESS);
AT_int_eq(apreq_charset_divine(expect, elen), APREQ_CHARSET_LATIN1);
AT_int_eq(apreq_decode(expect, &elen, src3, sizeof(src3) -1),
APR_SUCCESS);
AT_int_eq(apreq_charset_divine(expect, elen), APREQ_CHARSET_CP1252);
}
