static apr_status_t trigger_pollcb_cb(void* baton, apr_pollfd_t *descriptor)
{
pollcb_baton_t* pcb = (pollcb_baton_t*) baton;
ABTS_PTR_EQUAL(pcb->tc, s[0], descriptor->desc.s);
ABTS_PTR_EQUAL(pcb->tc, s[0], descriptor->client_data);
pcb->count++;
return APR_SUCCESS;
}
static void test_casptr_notequal(abts_case *tc, void *data)
{
int a, b;
volatile void *target_ptr = &a;
void *old_ptr;
old_ptr = apr_atomic_casptr(&target_ptr, &a, &b);
ABTS_PTR_EQUAL(tc, &a, old_ptr);
ABTS_PTR_EQUAL(tc, &a, (void *) target_ptr);
}
static void test_casptr_equal(abts_case *tc, void *data)
{
int a;
volatile void *target_ptr = NULL;
void *old_ptr;
old_ptr = apr_atomic_casptr(&target_ptr, &a, NULL);
ABTS_PTR_EQUAL(tc, NULL, old_ptr);
ABTS_PTR_EQUAL(tc, &a, (void *) target_ptr);
}
static void test_xchgptr(abts_case *tc, void *data)
{
int a;
void *ref = "little piggy";
volatile void *target_ptr = ref;
void *old_ptr;
old_ptr = apr_atomic_xchgptr(&target_ptr, &a);
ABTS_PTR_EQUAL(tc, ref, old_ptr);
ABTS_PTR_EQUAL(tc, &a, (void *) target_ptr);
}
static void test_str(abts_case *tc, void *data)
{
apr_pool_t *pool = p;
const apr_strmatch_pattern *pattern;
const apr_strmatch_pattern *pattern_nocase;
const apr_strmatch_pattern *pattern_onechar;
const apr_strmatch_pattern *pattern_zero;
const char *match = NULL;
const char *input1 = "string that contains a patterN...";
const char *input2 = "string that contains a pattern...";
const char *input3 = "pattern at the start of a string";
const char *input4 = "string that ends with a pattern";
const char *input5 = "patter\200n not found, negative chars in input";
const char *input6 = "patter\200n, negative chars, contains pattern...";
pattern = apr_strmatch_precompile(pool, "pattern", 1);
ABTS_PTR_NOTNULL(tc, pattern);
pattern_nocase = apr_strmatch_precompile(pool, "pattern", 0);
ABTS_PTR_NOTNULL(tc, pattern_nocase);
pattern_onechar = apr_strmatch_precompile(pool, "g", 0);
ABTS_PTR_NOTNULL(tc, pattern_onechar);
pattern_zero = apr_strmatch_precompile(pool, "", 0);
ABTS_PTR_NOTNULL(tc, pattern_zero);
match = apr_strmatch(pattern, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, NULL);
match = apr_strmatch(pattern, input2, strlen(input2));
ABTS_PTR_EQUAL(tc, match, input2 + 23);
match = apr_strmatch(pattern_onechar, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, input1 + 5);
match = apr_strmatch(pattern_zero, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, input1);
match = apr_strmatch(pattern_nocase, input1, strlen(input1));
ABTS_PTR_EQUAL(tc, match, input1 + 23);
match = apr_strmatch(pattern, input3, strlen(input3));
ABTS_PTR_EQUAL(tc, match, input3);
match = apr_strmatch(pattern, input4, strlen(input4));
ABTS_PTR_EQUAL(tc, match, input4 + 24);
match = apr_strmatch(pattern, input5, strlen(input5));
ABTS_PTR_EQUAL(tc, match, NULL);
match = apr_strmatch(pattern, input6, strlen(input6));
ABTS_PTR_EQUAL(tc, match, input6 + 35);
}
static void send_last_pollset(abts_case *tc, void *data)
{
apr_status_t rv;
const apr_pollfd_t *descs = NULL;
int num;
send_msg(s, sa, LARGE_NUM_SOCKETS - 1, tc);
rv = apr_pollset_poll(pollset, -1, &num, &descs);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, 1, num);
ABTS_PTR_NOTNULL(tc, descs);
ABTS_PTR_EQUAL(tc, s[LARGE_NUM_SOCKETS - 1], descs[0].desc.s);
ABTS_PTR_EQUAL(tc, s[LARGE_NUM_SOCKETS - 1], descs[0].client_data);
}
static void delete_key(abts_case *tc, void *data)
{
apr_hash_t *h = NULL;
char *result = NULL;
h = apr_hash_make(p);
ABTS_PTR_NOTNULL(tc, h);
apr_hash_set(h, "key", APR_HASH_KEY_STRING, "value");
apr_hash_set(h, "key2", APR_HASH_KEY_STRING, "value2");
result = apr_hash_get(h, "key", APR_HASH_KEY_STRING);
ABTS_STR_EQUAL(tc, "value", result);
result = apr_hash_get(h, "key2", APR_HASH_KEY_STRING);
ABTS_STR_EQUAL(tc, "value2", result);
apr_hash_set(h, "key", APR_HASH_KEY_STRING, NULL);
result = apr_hash_get(h, "key", APR_HASH_KEY_STRING);
ABTS_PTR_EQUAL(tc, NULL, result);
result = apr_hash_get(h, "key2", APR_HASH_KEY_STRING);
ABTS_STR_EQUAL(tc, "value2", result);
}
static void table_getnotthere(abts_case *tc, void *data)
{
const char *val;
val = apr_table_get(t1, "keynotthere");
ABTS_PTR_EQUAL(tc, NULL, (void *)val);
}
static void post_pool_clear(abts_case *tc, void *data)
{
apr_status_t rv;
void *retdata;
rv = apr_pool_userdata_get(&retdata, "DOESNTEXIST", pool);
ABTS_INT_EQUAL(tc, rv, APR_SUCCESS);
ABTS_PTR_EQUAL(tc, retdata, NULL);
}
static void multi_event_pollset(abts_case *tc, void *data)
{
apr_status_t rv;
apr_pollfd_t socket_pollfd;
int lrv;
const apr_pollfd_t *descs = NULL;
ABTS_PTR_NOTNULL(tc, s[0]);
socket_pollfd.desc_type = APR_POLL_SOCKET;
socket_pollfd.reqevents = APR_POLLIN | APR_POLLOUT;
socket_pollfd.desc.s = s[0];
socket_pollfd.client_data = s[0];
rv = apr_pollset_add(pollset, &socket_pollfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
send_msg(s, sa, 0, tc);
rv = apr_pollset_poll(pollset, -1, &lrv, &descs);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
if (lrv == 1) {
int ev = descs[0].rtnevents;
ABTS_PTR_EQUAL(tc, s[0], descs[0].desc.s);
ABTS_PTR_EQUAL(tc, s[0], descs[0].client_data);
ABTS_ASSERT(tc, "either or both of APR_POLLIN, APR_POLLOUT returned",
((ev & APR_POLLIN) != 0) || ((ev & APR_POLLOUT) != 0));
}
else if (lrv == 2) {
ABTS_PTR_EQUAL(tc, s[0], descs[0].desc.s);
ABTS_PTR_EQUAL(tc, s[0], descs[0].client_data);
ABTS_PTR_EQUAL(tc, s[0], descs[1].desc.s);
ABTS_PTR_EQUAL(tc, s[0], descs[1].client_data);
ABTS_ASSERT(tc, "returned events incorrect",
((descs[0].rtnevents | descs[1].rtnevents)
== (APR_POLLIN | APR_POLLOUT))
&& descs[0].rtnevents != descs[1].rtnevents);
}
else {
ABTS_ASSERT(tc, "either one or two events returned",
lrv == 1 || lrv == 2);
}
recv_msg(s, 0, p, tc);
rv = apr_pollset_poll(pollset, 0, &lrv, &descs);
ABTS_INT_EQUAL(tc, 0, APR_STATUS_IS_TIMEUP(rv));
ABTS_INT_EQUAL(tc, 1, lrv);
ABTS_PTR_EQUAL(tc, s[0], descs[0].desc.s);
ABTS_INT_EQUAL(tc, APR_POLLOUT, descs[0].rtnevents);
ABTS_PTR_EQUAL(tc, s[0], descs[0].client_data);
rv = apr_pollset_remove(pollset, &socket_pollfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
}
static void string_error(abts_case *tc, void *data)
{
char buf[128], *rv;
apr_status_t n;
buf[0] = '\0';
rv = apr_strerror(APR_ENOENT, buf, sizeof buf);
ABTS_PTR_EQUAL(tc, buf, rv);
ABTS_TRUE(tc, strlen(buf) > 0);
rv = apr_strerror(APR_TIMEUP, buf, sizeof buf);
ABTS_PTR_EQUAL(tc, buf, rv);
ABTS_STR_EQUAL(tc, "The timeout specified has expired", buf);
/* throw some randomish numbers at it to check for robustness */
for (n = 1; n < 1000000; n *= 2) {
apr_strerror(n, buf, sizeof buf);
}
}
static void nomessage_pollset(abts_case *tc, void *data)
{
apr_status_t rv;
int lrv;
const apr_pollfd_t *descs = NULL;
rv = apr_pollset_poll(pollset, 0, &lrv, &descs);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
ABTS_INT_EQUAL(tc, 0, lrv);
ABTS_PTR_EQUAL(tc, NULL, descs);
}
static void test_open_excl(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *thefile = NULL;
rv = apr_file_open(&thefile, FILENAME,
APR_CREATE | APR_EXCL | APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_TRUE(tc, rv != APR_SUCCESS);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EEXIST(rv));
ABTS_PTR_EQUAL(tc, NULL, thefile);
}
static void test_open_noreadwrite(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *thefile = NULL;
rv = apr_file_open(&thefile, FILENAME,
APR_FOPEN_CREATE | APR_FOPEN_EXCL,
APR_FPROT_UREAD | APR_FPROT_UWRITE | APR_FPROT_GREAD, p);
ABTS_TRUE(tc, rv != APR_SUCCESS);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EACCES(rv));
ABTS_PTR_EQUAL(tc, NULL, thefile);
}
static void test_open_write(abts_case *tc, void *data)
{
apr_status_t rv;
apr_file_t *filetest = NULL;
filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ENOENT(rv));
ABTS_PTR_EQUAL(tc, NULL, filetest);
}
static void string_cpystrn(abts_case *tc, void *data)
{
char buf[6], *ret;
buf[5] = 'Z';
ret = apr_cpystrn(buf, "123456", 5);
ABTS_STR_EQUAL(tc, "1234", buf);
ABTS_PTR_EQUAL(tc, buf + 4, ret);
ABTS_TRUE(tc, *ret == '\0');
ABTS_TRUE(tc, ret[1] == 'Z');
}
static void merge_aboveroot(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
char errmsg[256];
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo", ABS_ROOT"bar", APR_FILEPATH_NOTABOVEROOT,
p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EABOVEROOT(rv));
ABTS_PTR_EQUAL(tc, NULL, dstpath);
ABTS_STR_EQUAL(tc, "The given path was above the root path", errmsg);
}
/* It would be great if we could stress this stuff more, and make the test
* more granular.
*/
static void test_child_kill(abts_case *tc, void *data)
{
apr_file_t *std = NULL;
apr_proc_t newproc;
apr_procattr_t *procattr = NULL;
const char *args[3];
apr_status_t rv;
args[0] = apr_pstrdup(p, "occhild" EXTENSION);
args[1] = apr_pstrdup(p, "-X");
args[2] = NULL;
rv = apr_procattr_create(&procattr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_procattr_io_set(procattr, APR_FULL_BLOCK, APR_NO_PIPE,
APR_NO_PIPE);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_proc_create(&newproc, "./occhild" EXTENSION, args, NULL, procattr, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_NOTNULL(tc, newproc.in);
ABTS_PTR_EQUAL(tc, NULL, newproc.out);
ABTS_PTR_EQUAL(tc, NULL, newproc.err);
std = newproc.in;
apr_proc_other_child_register(&newproc, ocmaint, NULL, std, p);
apr_sleep(apr_time_from_sec(1));
rv = apr_proc_kill(&newproc, SIGKILL);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* allow time for things to settle... */
apr_sleep(apr_time_from_sec(3));
apr_proc_other_child_refresh_all(APR_OC_REASON_RUNNING);
ABTS_STR_EQUAL(tc, "APR_OC_REASON_DEATH", reasonstr);
}
static void clear_last_pollset(abts_case *tc, void *data)
{
apr_status_t rv;
int lrv;
const apr_pollfd_t *descs = NULL;
recv_msg(s, LARGE_NUM_SOCKETS - 1, p, tc);
rv = apr_pollset_poll(pollset, 0, &lrv, &descs);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv));
ABTS_INT_EQUAL(tc, 0, lrv);
ABTS_PTR_EQUAL(tc, NULL, descs);
}
static void root_relative(abts_case *tc, void *data)
{
apr_status_t rv;
const char *root = NULL;
const char *path = "foo/bar";
char errmsg[256];
rv = apr_filepath_root(&root, &path, 0, p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_PTR_EQUAL(tc, NULL, root);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ERELATIVE(rv));
ABTS_STR_EQUAL(tc, "The given path is relative", errmsg);
}
static void merge_notabsfail(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
char errmsg[256];
rv = apr_filepath_merge(&dstpath, ABS_ROOT"foo/bar", "../baz",
APR_FILEPATH_NOTABSOLUTE, p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_PTR_EQUAL(tc, NULL, dstpath);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_EABSOLUTE(rv));
ABTS_STR_EQUAL(tc, "The given path is absolute", errmsg);
}
static void merge_notrelfail(abts_case *tc, void *data)
{
apr_status_t rv;
char *dstpath = NULL;
char errmsg[256];
rv = apr_filepath_merge(&dstpath, "foo/bar", "../baz",
APR_FILEPATH_NOTRELATIVE, p);
apr_strerror(rv, errmsg, sizeof(errmsg));
ABTS_PTR_EQUAL(tc, NULL, dstpath);
ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_ERELATIVE(rv));
ABTS_STR_EQUAL(tc, "The given path is relative", errmsg);
}
static void table_unset(abts_case *tc, void *data)
{
const char *val;
apr_table_t *t = apr_table_make(p, 1);
apr_table_set(t, "a", "1");
apr_table_set(t, "b", "2");
apr_table_unset(t, "b");
ABTS_INT_EQUAL(tc, 1, apr_table_elts(t)->nelts);
val = apr_table_get(t, "a");
ABTS_STR_EQUAL(tc, "1", val);
val = apr_table_get(t, "b");
ABTS_PTR_EQUAL(tc, (void *)NULL, (void *)val);
}
static void test_userdata_getnokey(abts_case *tc, void *data)
{
apr_status_t rv;
void *teststr;
apr_file_t *filetest = NULL;
rv = apr_file_open(&filetest, FILENAME,
APR_WRITE,
APR_UREAD | APR_UWRITE | APR_GREAD, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_file_data_get(&teststr, "nokey", filetest);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_EQUAL(tc, NULL, teststr);
apr_file_close(filetest);
}
static void setup_large_poll(abts_case *tc, void *data)
{
apr_status_t rv;
int i;
rv = apr_poll_setup(&pollarray_large, LARGE_NUM_SOCKETS, p);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
for (i = 0; i < LARGE_NUM_SOCKETS;i++){
ABTS_INT_EQUAL(tc, 0, pollarray_large[i].reqevents);
ABTS_INT_EQUAL(tc, 0, pollarray_large[i].rtnevents);
rv = apr_poll_socket_add(pollarray_large, s[i], APR_POLLIN);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_PTR_EQUAL(tc, s[i], pollarray_large[i].desc.s);
}
}
static void table_getm(abts_case *tc, void *data)
{
const char *orig, *val;
apr_pool_t *subp;
apr_pool_create(&subp, p);
orig = "bar";
apr_table_setn(t1, "foo", orig);
val = apr_table_getm(subp, t1, "foo");
ABTS_PTR_EQUAL(tc, orig, val);
ABTS_STR_EQUAL(tc, "bar", val);
apr_table_add(t1, "foo", "baz");
val = apr_table_getm(subp, t1, "foo");
ABTS_STR_EQUAL(tc, "bar,baz", val);
apr_pool_destroy(subp);
}
static void list_merge_single(abts_case *tc, void *data)
{
int i;
char *liststr;
apr_status_t rv;
apr_array_header_t *pathelts;
pathelts = apr_array_make(p, 1, sizeof(const char*));
apr_array_push(pathelts);
for (i = 0; i < parts_in_count; ++i)
{
*(const char**)pathelts->elts = parts_in[i];
liststr = NULL;
rv = apr_filepath_list_merge(&liststr, pathelts, p);
if (parts_in[i][0] == '\0')
ABTS_PTR_EQUAL(tc, NULL, liststr);
else
{
ABTS_PTR_NOTNULL(tc, liststr);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_STR_EQUAL(tc, liststr, parts_in[i]);
}
}
}
static void pollset_remove(abts_case *tc, void *data)
{
apr_status_t rv;
apr_pollset_t *pollset;
const apr_pollfd_t *hot_files;
apr_pollfd_t pfd;
apr_int32_t num;
rv = apr_pollset_create(&pollset, 5, p, 0);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
pfd.p = p;
pfd.desc_type = APR_POLL_SOCKET;
pfd.reqevents = APR_POLLOUT;
pfd.desc.s = s[0];
pfd.client_data = (void *)1;
rv = apr_pollset_add(pollset, &pfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
pfd.desc.s = s[1];
pfd.client_data = (void *)2;
rv = apr_pollset_add(pollset, &pfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
pfd.desc.s = s[2];
pfd.client_data = (void *)3;
rv = apr_pollset_add(pollset, &pfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
pfd.desc.s = s[3];
pfd.client_data = (void *)4;
rv = apr_pollset_add(pollset, &pfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, 4, num);
/* now remove the pollset element referring to desc s[1] */
pfd.desc.s = s[1];
pfd.client_data = (void *)999; /* not used on this call */
rv = apr_pollset_remove(pollset, &pfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* this time only three should match */
rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, 3, num);
ABTS_PTR_EQUAL(tc, (void *)1, hot_files[0].client_data);
ABTS_PTR_EQUAL(tc, s[0], hot_files[0].desc.s);
ABTS_PTR_EQUAL(tc, (void *)3, hot_files[1].client_data);
ABTS_PTR_EQUAL(tc, s[2], hot_files[1].desc.s);
ABTS_PTR_EQUAL(tc, (void *)4, hot_files[2].client_data);
ABTS_PTR_EQUAL(tc, s[3], hot_files[2].desc.s);
/* now remove the pollset elements referring to desc s[2] */
pfd.desc.s = s[2];
pfd.client_data = (void *)999; /* not used on this call */
rv = apr_pollset_remove(pollset, &pfd);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
/* this time only two should match */
rv = apr_pollset_poll(pollset, 1000, &num, &hot_files);
ABTS_INT_EQUAL(tc, APR_SUCCESS, rv);
ABTS_INT_EQUAL(tc, 2, num);
ABTS_ASSERT(tc, "Incorrect socket in result set",
((hot_files[0].desc.s == s[0]) && (hot_files[1].desc.s == s[3])) ||
((hot_files[0].desc.s == s[3]) && (hot_files[1].desc.s == s[0])));
ABTS_ASSERT(tc, "Incorrect client data in result set",
((hot_files[0].client_data == (void *)1) &&
(hot_files[1].client_data == (void *)4)) ||
((hot_files[0].client_data == (void *)4) &&
(hot_files[1].client_data == (void *)1)));
}
static void test_get_addr(abts_case *tc, void *data)
{
apr_status_t rv;
apr_socket_t *ld, *sd, *cd;
apr_sockaddr_t *sa, *ca;
apr_pool_t *subp;
char *a, *b;
APR_ASSERT_SUCCESS(tc, "create subpool", apr_pool_create(&subp, p));
if ((ld = setup_socket(tc)) != APR_SUCCESS)
return;
APR_ASSERT_SUCCESS(tc,
"get local address of bound socket",
apr_socket_addr_get(&sa, APR_LOCAL, ld));
rv = apr_socket_create(&cd, sa->family, SOCK_STREAM,
APR_PROTO_TCP, subp);
APR_ASSERT_SUCCESS(tc, "create client socket", rv);
APR_ASSERT_SUCCESS(tc, "enable non-block mode",
apr_socket_opt_set(cd, APR_SO_NONBLOCK, 1));
/* It is valid for a connect() on a socket with NONBLOCK set to
* succeed (if the connection can be established synchronously),
* but if it does, this test cannot proceed. */
rv = apr_socket_connect(cd, sa);
if (rv == APR_SUCCESS) {
apr_socket_close(ld);
apr_socket_close(cd);
ABTS_NOT_IMPL(tc, "Cannot test if connect completes "
"synchronously");
return;
}
if (!APR_STATUS_IS_EINPROGRESS(rv)) {
apr_socket_close(ld);
apr_socket_close(cd);
APR_ASSERT_SUCCESS(tc, "connect to listener", rv);
return;
}
APR_ASSERT_SUCCESS(tc, "accept connection",
apr_socket_accept(&sd, ld, subp));
{
/* wait for writability */
apr_pollfd_t pfd;
int n;
pfd.p = p;
pfd.desc_type = APR_POLL_SOCKET;
pfd.reqevents = APR_POLLOUT|APR_POLLHUP;
pfd.desc.s = cd;
pfd.client_data = NULL;
APR_ASSERT_SUCCESS(tc, "poll for connect completion",
apr_poll(&pfd, 1, &n, 5 * APR_USEC_PER_SEC));
}
APR_ASSERT_SUCCESS(tc, "get local address of server socket",
apr_socket_addr_get(&sa, APR_LOCAL, sd));
APR_ASSERT_SUCCESS(tc, "get remote address of client socket",
apr_socket_addr_get(&ca, APR_REMOTE, cd));
/* Test that the pool of the returned sockaddr objects exactly
* match the socket. */
ABTS_PTR_EQUAL(tc, subp, sa->pool);
ABTS_PTR_EQUAL(tc, subp, ca->pool);
/* Check equivalence. */
a = apr_psprintf(p, "%pI fam=%d", sa, sa->family);
b = apr_psprintf(p, "%pI fam=%d", ca, ca->family);
ABTS_STR_EQUAL(tc, a, b);
/* Check pool of returned sockaddr, as above. */
APR_ASSERT_SUCCESS(tc, "get local address of client socket",
apr_socket_addr_get(&sa, APR_LOCAL, cd));
APR_ASSERT_SUCCESS(tc, "get remote address of server socket",
apr_socket_addr_get(&ca, APR_REMOTE, sd));
/* Check equivalence. */
a = apr_psprintf(p, "%pI fam=%d", sa, sa->family);
b = apr_psprintf(p, "%pI fam=%d", ca, ca->family);
ABTS_STR_EQUAL(tc, a, b);
ABTS_PTR_EQUAL(tc, subp, sa->pool);
ABTS_PTR_EQUAL(tc, subp, ca->pool);
apr_socket_close(cd);
apr_socket_close(sd);
apr_socket_close(ld);
apr_pool_destroy(subp);
}
static void test_escape(abts_case *tc, void *data)
{
apr_pool_t *pool;
const char *src, *target;
const char *dest;
const void *vdest;
apr_size_t len, vlen;
apr_pool_create(&pool, NULL);
src = "Hello World &;`'\"|*?~<>^()[]{}$\\";
target = "Hello World \\&\\;\\`\\'\\\"\\|\\*\\?\\~\\<\\>\\^\\(\\)\\[\\]\\{\\}\\$\\\\";
dest = apr_pescape_shell(pool, src);
ABTS_ASSERT(tc,
apr_psprintf(pool, "shell escaped (%s) does not match expected output (%s)",
dest, target),
(strcmp(dest, target) == 0));
apr_escape_shell(NULL, src, APR_ESCAPE_STRING, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
#if !(defined(OS2) || defined(WIN32))
/* Now try with newline, which is converted to a space on OS/2 and Windows.
*/
src = "Hello World &;`'\"|*?~<>^()[]{}$\\\n";
target = "Hello World \\&\\;\\`\\'\\\"\\|\\*\\?\\~\\<\\>\\^\\(\\)\\[\\]\\{\\}\\$\\\\\\\n";
dest = apr_pescape_shell(pool, src);
ABTS_ASSERT(tc,
apr_psprintf(pool, "shell escaped (%s) does not match expected output (%s)",
dest, target),
(strcmp(dest, target) == 0));
apr_escape_shell(NULL, src, APR_ESCAPE_STRING, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
#endif
src = "Hello";
dest = apr_punescape_url(pool, src, NULL, NULL, 0);
ABTS_PTR_EQUAL(tc, src, dest);
src = "Hello";
dest = apr_punescape_url(pool, src, NULL, NULL, 1);
ABTS_PTR_EQUAL(tc, src, dest);
src = "Hello%20";
dest = apr_punescape_url(pool, src, " ", NULL, 0);
ABTS_PTR_EQUAL(tc, NULL, dest);
src = "Hello%20World";
target = "Hello World";
dest = apr_punescape_url(pool, src, NULL, NULL, 0);
ABTS_STR_EQUAL(tc, target, dest);
apr_unescape_url(NULL, src, APR_ESCAPE_STRING, NULL, NULL, 0, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello+World";
target = "Hello World";
dest = apr_punescape_url(pool, src, NULL, NULL, 1);
ABTS_STR_EQUAL(tc, target, dest);
apr_unescape_url(NULL, src, APR_ESCAPE_STRING, NULL, NULL, 1, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello%20World";
target = "Hello%20World";
dest = apr_punescape_url(pool, src, NULL, " ", 0);
ABTS_STR_EQUAL(tc, target, dest);
apr_unescape_url(NULL, src, APR_ESCAPE_STRING, NULL, " ", 0, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello";
dest = apr_pescape_path_segment(pool, src);
ABTS_PTR_EQUAL(tc, src, dest);
src = "$-_.+!*'(),:@&=/~Hello World";
target = "$-_.+!*'(),:@&=%2f~Hello%20World";
dest = apr_pescape_path_segment(pool, src);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_path_segment(NULL, src, APR_ESCAPE_STRING, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello";
dest = apr_pescape_path(pool, src, 0);
ABTS_PTR_EQUAL(tc, src, dest);
src = "$-_.+!*'(),:@&=/~Hello World";
target = "./$-_.+!*'(),:@&=/~Hello%20World";
dest = apr_pescape_path(pool, src, 0);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_path(NULL, src, APR_ESCAPE_STRING, 0, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello";
dest = apr_pescape_path(pool, src, 1);
ABTS_PTR_EQUAL(tc, src, dest);
src = "$-_.+!*'(),:@&=/~Hello World";
target = "$-_.+!*'(),:@&=/~Hello%20World";
dest = apr_pescape_path(pool, src, 1);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_path(NULL, src, APR_ESCAPE_STRING, 1, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello";
dest = apr_pescape_urlencoded(pool, src);
ABTS_PTR_EQUAL(tc, src, dest);
src = "$-_.+!*'(),:@&=/~Hello World";
target = "%24-_.%2b%21*%27%28%29%2c%3a%40%26%3d%2f%7eHello+World";
dest = apr_pescape_urlencoded(pool, src);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_urlencoded(NULL, src, APR_ESCAPE_STRING, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello";
dest = apr_pescape_entity(pool, src, 0);
ABTS_PTR_EQUAL(tc, src, dest);
src = "\xFF<>&\'\"Hello World";
target = "\xFF<>&'"Hello World";
dest = apr_pescape_entity(pool, src, 0);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_entity(NULL, src, APR_ESCAPE_STRING, 0, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
#if !APR_CHARSET_EBCDIC
src = "Hello";
dest = apr_pescape_entity(pool, src, 1);
ABTS_PTR_EQUAL(tc, src, dest);
src = "\xFF<>&\'\"Hello World";
target = "ÿ<>&'"Hello World";
dest = apr_pescape_entity(pool, src, 1);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_entity(NULL, src, APR_ESCAPE_STRING, 1, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "Hello";
dest = apr_punescape_entity(pool, src);
ABTS_PTR_EQUAL(tc, src, dest);
src = "\xFF<>&'"Hello World";
target = "\xFF<>&\'\"Hello World";
dest = apr_punescape_entity(pool, src);
ABTS_STR_EQUAL(tc, target, dest);
apr_unescape_entity(NULL, src, APR_ESCAPE_STRING, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "ÿ<>&'"Hello World";
target = "\xFF<>&\'\"Hello World";
dest = apr_punescape_entity(pool, src);
ABTS_STR_EQUAL(tc, target, dest);
apr_unescape_entity(NULL, src, APR_ESCAPE_STRING, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = " <>&'"Hello World";
target = " <>&\'\"Hello World";
dest = apr_punescape_entity(pool, src);
ABTS_STR_EQUAL(tc, target, dest);
apr_unescape_entity(NULL, src, APR_ESCAPE_STRING, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
#endif
src = "Hello";
dest = apr_pescape_echo(pool, src, 0);
ABTS_PTR_EQUAL(tc, src, dest);
src = "\a\b\f\\n\r\t\v\"Hello World\"";
target = "\\a\\b\\f\\\\n\\r\\t\\v\"Hello World\"";
dest = apr_pescape_echo(pool, src, 0);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_echo(NULL, src, APR_ESCAPE_STRING, 0, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "\a\b\f\\n\r\t\v\"Hello World\"";
target = "\\a\\b\\f\\\\n\\r\\t\\v\\\"Hello World\\\"";
dest = apr_pescape_echo(pool, src, 1);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_echo(NULL, src, APR_ESCAPE_STRING, 1, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "\xFF\x00\xFF\x00";
target = "ff00ff00";
dest = apr_pescape_hex(pool, src, 4, 0);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_hex(NULL, src, 4, 0, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "\xFF\x00\xFF\x00";
target = "ff:00:ff:00";
dest = apr_pescape_hex(pool, src, 4, 1);
ABTS_STR_EQUAL(tc, target, dest);
apr_escape_hex(NULL, src, 4, 1, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, strlen(dest) + 1),
(len == strlen(dest) + 1));
src = "ff:00:ff:00";
target = "\xFF\x00\xFF\x00";
vdest = apr_punescape_hex(pool, src, 1, &vlen);
ABTS_ASSERT(tc, "apr_punescape_hex target!=dest", memcmp(target, vdest, 4) == 0);
ABTS_INT_EQUAL(tc, (int)vlen, 4);
apr_unescape_hex(NULL, src, APR_ESCAPE_STRING, 1, &len);
ABTS_ASSERT(tc,
apr_psprintf(pool, "size mismatch (%" APR_SIZE_T_FMT "!=%" APR_SIZE_T_FMT ")", len, (apr_size_t)4),
(len == 4));
apr_pool_destroy(pool);
}
