END_TEST
START_TEST(bus_open)
{
char spath[128];
struct wpas *w, *s;
int r;
sprintf(spath, "/tmp/miracle-test-sock-%d", getpid());
/* test client connection */
s = TEST_INVALID_PTR;
w = TEST_INVALID_PTR;
r = wpas_create(spath, &s);
ck_assert_int_ge(r, 0);
ck_assert_int_ge(access(spath, F_OK), 0);
r = wpas_open(spath, &w);
ck_assert_int_ge(r, 0);
wpas_unref(w);
wpas_unref(s);
ck_assert_int_lt(access(spath, F_OK), 0);
}
END_TEST
START_TEST(udev_double_resume)
{
struct libinput *li;
struct libinput_event *event;
struct udev *udev;
int fd;
udev = udev_new();
ck_assert(udev != NULL);
li = libinput_create_from_udev(&simple_interface, NULL, udev, "seat0");
ck_assert(li != NULL);
fd = libinput_get_fd(li);
ck_assert_int_ge(fd, 0);
/* expect at least one event */
ck_assert_int_ge(libinput_dispatch(li), 0);
event = libinput_get_event(li);
ck_assert(event != NULL);
libinput_suspend(li);
libinput_resume(li);
libinput_resume(li);
libinput_event_destroy(event);
libinput_destroy(li);
udev_unref(udev);
}
END_TEST
START_TEST(test_tcpv4_inet)
{
int server_root_socket, server_client_socket, client_socket;
char buffer[BUFFERSIZE];
char *msg;
char ipbuffer[BUFFERSIZE];
ck_assert_int_ge((server_root_socket = OS_Bindporttcp(PORT, NULL, 0)), 0);
ck_assert_int_ge((client_socket = OS_ConnectTCP(PORT, IPV4, 0, NULL)) , 0);
ck_assert_int_ge((server_client_socket = OS_AcceptTCP(server_root_socket, ipbuffer, BUFFERSIZE)), 0);
ck_assert_str_eq(ipbuffer, IPV4);
ck_assert_int_eq(OS_SendTCP(client_socket, SENDSTRING), 0);
ck_assert_int_eq(OS_RecvTCPBuffer(server_client_socket, buffer, BUFFERSIZE), 0);
ck_assert_str_eq(buffer, SENDSTRING);
ck_assert_int_eq(OS_SendTCPbySize(server_client_socket, 5, SENDSTRING), 0);
ck_assert_ptr_ne((msg = OS_RecvTCP(client_socket, BUFFERSIZE)), NULL);
ck_assert_str_eq(msg, "Hello"); /* only 5 bytes send */
free(msg);
OS_CloseSocket(client_socket);
OS_CloseSocket(server_client_socket);
OS_CloseSocket(server_root_socket);
}
END_TEST
START_TEST(test_udpv6)
{
int server_socket, client_socket;
char buffer[BUFFERSIZE];
char *msg;
ck_assert_int_ge((server_socket = OS_Bindportudp(PORT, IPV6, 1)), 0);
ck_assert_int_ge((client_socket = OS_ConnectUDP(PORT, IPV6, 1, NULL)) , 0);
//TODO: ck_assert_int_eq(OS_SendUDP(client_socket, SENDSTRING), 0);
ck_assert_int_eq(OS_SendUDPbySize(client_socket, strlen(SENDSTRING), SENDSTRING), 0);
//TODO: not null-terminated
ck_assert_int_eq(OS_RecvConnUDP(server_socket, buffer, BUFFERSIZE), strlen(SENDSTRING));
ck_assert_str_eq(buffer, SENDSTRING);
ck_assert_int_eq(OS_SendUDPbySize(client_socket, 5, SENDSTRING), 0);
ck_assert_ptr_ne((msg = OS_RecvUDP(server_socket, BUFFERSIZE)), NULL);
ck_assert_str_eq(msg, "Hello"); /* only 5 bytes send */
free(msg);
OS_CloseSocket(client_socket);
OS_CloseSocket(server_socket);
}
END_TEST
START_TEST(bus_open)
{
const char *spath = "/tmp/miracle-test-sock";
struct wpas *w, *s;
int r;
/* test client connection */
s = TEST_INVALID_PTR;
w = TEST_INVALID_PTR;
r = wpas_create(spath, &s);
ck_assert_int_ge(r, 0);
ck_assert_int_ge(access(spath, F_OK), 0);
r = wpas_open(spath, &w);
ck_assert_int_ge(r, 0);
wpas_unref(w);
wpas_unref(s);
ck_assert_int_lt(access(spath, F_OK), 0);
}
END_TEST
START_TEST(test_clx_hid_write)
{
check_init();
res = clx_hid_write(handle, buf, 17);
ck_assert_int_ge(res, 0);
buf[0] = 0x01;
buf[1] = 0x81;
res = clx_hid_write(handle, buf, 17);
ck_assert_int_ge(res, 0);
res = 0;
while (res == 0) {
res = clx_hid_read(handle, buf, sizeof(buf));
if (res == 0) {
printf("Waiting...\n");
}
if (res < 0) {
printf("Unable to read()\n");
}
usleep(500 * 1000);
}
printf("Data read:\n");
int i;
for (i = 0; i < res; i++) {
printf("%02hhx ", buf[i]);
}
printf("\n");
}
END_TEST
START_TEST(test_ck_assert_int_ge)
{
int x = 2;
int y = 3;
ck_assert_int_ge(y, x);
ck_assert_int_ge(y, x);
ck_assert_int_ge(x, y);
#define LINENO_ck_assert_int_ge _STR(__LINE__)
}
static struct rtsp *start_test_client(void)
{
int r, fds[2] = { };
r = sd_event_default(&event);
ck_assert_int_ge(r, 0);
r = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
ck_assert_int_ge(r, 0);
ck_assert_int_ge(fds[0], 0);
ck_assert_int_ge(fds[1], 0);
r = rtsp_open(&server, fds[0]);
ck_assert_int_ge(r, 0);
r = rtsp_attach_event(server, event, 0);
ck_assert_int_ge(r, 0);
r = rtsp_open(&client, fds[1]);
ck_assert_int_ge(r, 0);
r = rtsp_attach_event(client, event, 0);
ck_assert_int_ge(r, 0);
return client;
}
END_TEST
START_TEST(msg_new_reply)
{
struct wpas_message *m;
struct wpas *w;
int r;
w = start_test_client();
m = TEST_INVALID_PTR;
r = wpas_message_new_reply(w, &m);
ck_assert_int_ge(r, 0);
ck_assert(m != TEST_INVALID_PTR);
ck_assert(m != NULL);
ck_assert_int_eq(wpas_message_is_reply(m), 1);
ck_assert_int_eq(wpas_message_is_event(m, NULL), 0);
ck_assert_int_eq(wpas_message_is_request(m, NULL), 0);
ck_assert_int_eq(wpas_message_get_cookie(m), 0);
ck_assert_ptr_eq(wpas_message_get_bus(m), w);
ck_assert_int_eq(wpas_message_get_type(m), WPAS_MESSAGE_REPLY);
ck_assert_int_eq(wpas_message_get_level(m), 0);
ck_assert_ptr_eq((void*)wpas_message_get_name(m), NULL);
ck_assert_ptr_eq((void*)wpas_message_get_raw(m), NULL);
wpas_message_unref(m);
stop_test_client();
}
static void
test_bt_value_group_range_randomize_column (BT_TEST_ARGS)
{
BT_TEST_START;
GST_INFO ("-- arrange --");
BtValueGroup *vg = get_mono_value_group ();
bt_value_group_set_event (vg, 0, 0, "5");
bt_value_group_set_event (vg, 3, 0, "50");
GST_INFO ("-- act --");
bt_value_group_transform_colum (vg, BT_VALUE_GROUP_OP_RANGE_RANDOMIZE, 0, 3,
0);
GST_INFO ("-- assert --");
gchar *str;
gint v, i;
for (i = 0; i < 4; i++) {
GST_DEBUG ("value[%d]", i);
str = bt_value_group_get_event (vg, i, 0);
fail_unless (str != NULL, NULL);
v = atoi (str);
ck_assert_int_ge (v, 5);
ck_assert_int_le (v, 50);
g_free (str);
}
GST_INFO ("-- cleanup --");
BT_TEST_END;
}
END_TEST
START_TEST(udev_create_seat0)
{
struct libinput *li;
struct libinput_event *event;
struct udev *udev;
int fd;
udev = udev_new();
ck_assert(udev != NULL);
li = libinput_udev_create_context(&simple_interface, NULL, udev);
ck_assert(li != NULL);
ck_assert_int_eq(libinput_udev_assign_seat(li, "seat0"), 0);
fd = libinput_get_fd(li);
ck_assert_int_ge(fd, 0);
/* expect at least one event */
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert(event != NULL);
libinput_event_destroy(event);
libinput_unref(li);
udev_unref(udev);
}
END_TEST
START_TEST(udev_create_empty_seat)
{
struct libinput *li;
struct libinput_event *event;
struct udev *udev;
int fd;
udev = udev_new();
ck_assert(udev != NULL);
/* expect a libinput reference, but no events */
li = libinput_create_from_udev(&simple_interface, NULL, udev, "seatdoesntexist");
ck_assert(li != NULL);
fd = libinput_get_fd(li);
ck_assert_int_ge(fd, 0);
libinput_dispatch(li);
event = libinput_get_event(li);
ck_assert(event == NULL);
libinput_event_destroy(event);
libinput_destroy(li);
udev_unref(udev);
}
END_TEST
START_TEST(path_create_invalid_file)
{
struct libinput *li;
struct libinput_device *device;
char path[] = "/tmp/litest_path_XXXXXX";
int fd;
umask(002);
fd = mkstemp(path);
ck_assert_int_ge(fd, 0);
close(fd);
open_func_count = 0;
close_func_count = 0;
li = libinput_path_create_context(&simple_interface, NULL);
unlink(path);
ck_assert(li != NULL);
device = libinput_path_add_device(li, path);
ck_assert(device == NULL);
ck_assert_int_eq(open_func_count, 0);
ck_assert_int_eq(close_func_count, 0);
libinput_unref(li);
ck_assert_int_eq(close_func_count, 0);
open_func_count = 0;
close_func_count = 0;
}
static struct rtsp_message *create_from_recipe_and_verify(struct rtsp *bus,
struct recipe *rec)
{
struct rtsp_message *m, *eq;
const void *e;
size_t i;
int r;
m = create_from_recipe(bus, rec);
for (i = 0; i < SHL_ARRAY_LENGTH(rec->equivalents); ++i) {
e = rec->equivalents[i];
if (!e)
break;
r = rtsp_message_new_from_raw(bus,
&eq,
e,
rec->eq_sizes[i] ? : strlen(e));
ck_assert_int_ge(r, 0);
verify_recipe(rec, eq);
rtsp_message_unref(eq);
}
return m;
}
END_TEST
START_TEST(test_serialize_sender_key_record_with_states)
{
int result = 0;
sender_key_record *record = 0;
axolotl_buffer *buffer = 0;
ec_key_pair *key_pair = 0;
/* Create the record */
result = sender_key_record_create(&record, global_context);
ck_assert_int_eq(result, 0);
/* Create and set state id=1000, iteration=1 */
result = axolotl_key_helper_generate_sender_key(&buffer, global_context);
ck_assert_int_eq(result, 0);
result = axolotl_key_helper_generate_sender_signing_key(&key_pair, global_context);
ck_assert_int_eq(result, 0);
result = sender_key_record_set_sender_key_state(record, 1000, 1, buffer, key_pair);
ck_assert_int_eq(result, 0);
axolotl_buffer_free(buffer);
AXOLOTL_UNREF(key_pair);
/* Create and add state id=1001, iteration=2 */
result = axolotl_key_helper_generate_sender_key(&buffer, global_context);
ck_assert_int_eq(result, 0);
result = axolotl_key_helper_generate_sender_signing_key(&key_pair, global_context);
ck_assert_int_eq(result, 0);
sender_key_record_add_sender_key_state(record, 1001, 2, buffer, ec_key_pair_get_public(key_pair));
ck_assert_int_eq(result, 0);
axolotl_buffer_free(buffer);
AXOLOTL_UNREF(key_pair);
/* Serialize the record */
result = sender_key_record_serialize(&buffer, record);
ck_assert_int_ge(result, 0);
/* Deserialize the record */
uint8_t *data = axolotl_buffer_data(buffer);
int len = axolotl_buffer_len(buffer);
sender_key_record *record_deserialized = 0;
result = sender_key_record_deserialize(&record_deserialized, data, len, global_context);
ck_assert_int_eq(result, 0);
/* Verify that the initial and deserialized records match */
compare_sender_key_records(record, record_deserialized);
compare_sender_key_record_states(record, record_deserialized, 1000);
compare_sender_key_record_states(record, record_deserialized, 1001);
/* Cleanup */
AXOLOTL_UNREF(record);
axolotl_buffer_free(buffer);
AXOLOTL_UNREF(record_deserialized);
}
static struct wpas *start_test_client(void)
{
const char *spath = "/tmp/miracle-test-sock";
int r;
r = sd_event_default(&event);
ck_assert_int_ge(r, 0);
r = wpas_create(spath, &server);
ck_assert_int_ge(r, 0);
r = wpas_attach_event(server, NULL, 0);
ck_assert_int_ge(r, 0);
r = wpas_open(spath, &client);
ck_assert_int_ge(r, 0);
r = wpas_attach_event(client, NULL, 0);
ck_assert_int_ge(r, 0);
return client;
}
static struct wpas *start_test_client(void)
{
char spath[128];
int r;
sprintf(spath, "/tmp/miracle-test-sock-%d", getpid());
r = sd_event_default(&event);
ck_assert_int_ge(r, 0);
r = wpas_create(spath, &server);
ck_assert_int_ge(r, 0);
r = wpas_attach_event(server, NULL, 0);
ck_assert_int_ge(r, 0);
r = wpas_open(spath, &client);
ck_assert_int_ge(r, 0);
r = wpas_attach_event(client, NULL, 0);
ck_assert_int_ge(r, 0);
return client;
}
END_TEST
START_TEST(test_unix)
{
int fd;
/* create socket path */
char socket_path[256];
strncpy(socket_path, "/tmp/tmp_file-XXXXXX", 256);
fd = mkstemp(socket_path);
close(fd);
int server_socket, client_socket;
const int msg_size = 2048;
char buffer[BUFFERSIZE];
ck_assert_int_ge((server_socket = OS_BindUnixDomain(socket_path, 0660, msg_size)), 0);
ck_assert_int_ge(OS_getsocketsize(server_socket), msg_size);
ck_assert_int_ge((client_socket = OS_ConnectUnixDomain(socket_path, msg_size)), 0);
ck_assert_int_eq(OS_SendUnix(client_socket, SENDSTRING, 5), 0);
ck_assert_int_eq(OS_RecvUnix(server_socket, BUFFERSIZE, buffer), 5);
ck_assert_str_eq(buffer, "Hello");
ck_assert_int_eq(OS_SendUnix(client_socket, SENDSTRING, 0), 0);
ck_assert_int_eq(OS_RecvUnix(server_socket, BUFFERSIZE, buffer), strlen(SENDSTRING) + 1);
ck_assert_str_eq(buffer, SENDSTRING);
OS_CloseSocket(client_socket);
OS_CloseSocket(server_socket);
unlink(socket_path);
}
END_TEST
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wused-but-marked-unused"
#endif
START_TEST(dmonth_return_within_range)
{
int m;
m = dmonth(_i);
ck_assert_int_ge(m, 28);
ck_assert_int_le(m, 31);
}
END_TEST
START_TEST(bus_create)
{
char spath[128];
struct wpas *w, *s;
int r;
sprintf(spath, "/tmp/miracle-test-sock-%d", getpid());
/* test server creation */
s = TEST_INVALID_PTR;
w = TEST_INVALID_PTR;
unlink(spath);
ck_assert_int_lt(access(spath, F_OK), 0);
r = wpas_create(spath, &s);
ck_assert_int_ge(r, 0);
ck_assert(s != TEST_INVALID_PTR);
ck_assert(s != NULL);
ck_assert_int_ge(access(spath, F_OK), 0);
r = wpas_create(spath, &w);
ck_assert_int_eq(r, -EADDRINUSE);
ck_assert(w == TEST_INVALID_PTR);
ck_assert_int_ge(access(spath, F_OK), 0);
wpas_unref(s);
s = TEST_INVALID_PTR;
ck_assert_int_lt(access(spath, F_OK), 0);
/* test again with pre-existing but unused file */
ck_assert_int_ge(open(spath, O_RDWR | O_CREAT | O_CLOEXEC, S_IRWXU), 0);
ck_assert_int_ge(access(spath, F_OK), 0);
r = wpas_create(spath, &s);
ck_assert_int_ge(r, 0);
ck_assert(s != TEST_INVALID_PTR);
ck_assert(s != NULL);
ck_assert_int_ge(access(spath, F_OK), 0);
wpas_unref(s);
s = TEST_INVALID_PTR;
ck_assert_int_lt(access(spath, F_OK), 0);
}
END_TEST
START_TEST(test_clx_hid_read)
{
int i;
clx_hid_set_nonblocking(handle, 1);
res = clx_hid_read(handle, buf, 17);
ck_assert_int_ge(res, 0);
printf("Feature Report\n ");
for (i = 0; i < res; i++) {
printf("%02hhx ", buf[i]);
}
printf("\n");
}
END_TEST
START_TEST(msg_peer)
{
struct wpas_message *m;
struct wpas *w;
char *t;
int r;
w = start_test_client();
r = wpas_message_new_event(w, "name", 5, &m);
ck_assert_int_ge(r, 0);
ck_assert_ptr_eq((void*)wpas_message_get_peer(m), NULL);
t = wpas_message_get_escaped_peer(m);
ck_assert_str_eq(t, "<none>");
free(t);
wpas_message_set_peer(m, "/some/path");
ck_assert_str_eq(wpas_message_get_peer(m), "/some/path");
t = wpas_message_get_escaped_peer(m);
ck_assert_str_eq(t, "/some/path");
free(t);
wpas_message_set_peer(m, "\0/some/path");
ck_assert_str_eq(wpas_message_get_peer(m), "");
ck_assert_str_eq(wpas_message_get_peer(m) + 1, "/some/path");
t = wpas_message_get_escaped_peer(m);
ck_assert_str_eq(t, "@abstract:/some/path");
free(t);
wpas_message_set_peer(m, NULL);
ck_assert_ptr_eq((void*)wpas_message_get_peer(m), NULL);
t = wpas_message_get_escaped_peer(m);
ck_assert_str_eq(t, "<none>");
free(t);
wpas_message_unref(m);
stop_test_client();
}
END_TEST
START_TEST (test_get_chains)
{
// Test a non PDB file
FILE *pdb = fopen(DATADIR "err.config", "r");
struct file_range whole_file = freesasa_whole_file(pdb), *it = NULL;
int nc = freesasa_pdb_get_chains(pdb, whole_file, &it, 0);
fclose(pdb);
ck_assert_int_eq(nc,0);
ck_assert_ptr_eq(it,NULL);
// This file only has one chain
pdb = fopen(DATADIR "1ubq.pdb", "r");
whole_file = freesasa_whole_file(pdb);
nc = freesasa_pdb_get_chains(pdb,whole_file,&it,0);
fclose(pdb);
ck_assert_int_eq(nc,1);
ck_assert_ptr_ne(it,NULL);
free(it);
// This file has 4 chains
pdb = fopen(DATADIR "2jo4.pdb","r");
int nm = freesasa_pdb_get_models(pdb,&it);
ck_assert_int_eq(nm,10);
ck_assert_ptr_ne(it,NULL);
for (int i = 0; i < nm; ++i) {
struct file_range *jt = NULL;
nc = freesasa_pdb_get_chains(pdb,it[i],&jt,0);
ck_assert_int_eq(nc,4);
ck_assert_ptr_ne(jt,NULL);
for (int j = 1; j < nc; ++j) {
ck_assert_int_ge(jt[j].begin, jt[j-1].end);
}
free(jt);
}
free(it);
}
END_TEST
START_TEST(msg_append)
{
struct wpas_message *m;
struct wpas *w;
int r;
w = start_test_client();
r = wpas_message_new_event(w, "name", 5, &m);
ck_assert_int_ge(r, 0);
r = wpas_message_seal(m);
ck_assert_int_ge(r, 0);
ck_assert_str_eq(wpas_message_get_raw(m), "<5>name");
wpas_message_unref(m);
r = wpas_message_new_event(w, "name", 5, &m);
ck_assert_int_ge(r, 0);
r = wpas_message_append(m,
"suie",
"string",
(uint32_t)5,
(int32_t)1,
"key",
"value");
ck_assert_int_ge(r, 0);
r = wpas_message_seal(m);
ck_assert_int_ge(r, 0);
ck_assert_str_eq(wpas_message_get_raw(m),
"<5>name string 5 1 key=value");
r = wpas_message_skip(m, "suie");
ck_assert_int_ge(r, 0);
wpas_message_unref(m);
stop_test_client();
}
END_TEST
START_TEST(test_mg_server_and_client_tls)
{
#ifndef NO_SSL
struct mg_context *ctx;
int ports_cnt;
struct mg_server_ports ports[16];
struct mg_callbacks callbacks;
char errmsg[256];
struct mg_connection *client_conn;
char client_err[256];
const struct mg_request_info *client_ri;
int client_res;
struct mg_client_options client_options;
const char *OPTIONS[32]; /* initializer list here is rejected by CI test */
int opt_idx = 0;
char server_cert[256];
char client_cert[256];
const char *res_dir = locate_resources();
ck_assert(res_dir != NULL);
strcpy(server_cert, res_dir);
strcpy(client_cert, res_dir);
#ifdef _WIN32
strcat(server_cert, "cert\\server.pem");
strcat(client_cert, "cert\\client.pem");
#else
strcat(server_cert, "cert/server.pem");
strcat(client_cert, "cert/client.pem");
#endif
memset((void *)OPTIONS, 0, sizeof(OPTIONS));
#if !defined(NO_FILES)
OPTIONS[opt_idx++] = "document_root";
OPTIONS[opt_idx++] = ".";
#endif
OPTIONS[opt_idx++] = "listening_ports";
OPTIONS[opt_idx++] = "8080r,8443s";
OPTIONS[opt_idx++] = "ssl_certificate";
OPTIONS[opt_idx++] = server_cert;
OPTIONS[opt_idx++] = "ssl_verify_peer";
OPTIONS[opt_idx++] = "yes";
OPTIONS[opt_idx++] = "ssl_ca_file";
OPTIONS[opt_idx++] = client_cert;
ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
memset(ports, 0, sizeof(ports));
memset(&callbacks, 0, sizeof(callbacks));
memset(errmsg, 0, sizeof(errmsg));
callbacks.log_message = log_msg_func;
ctx = mg_start(&callbacks, (void *)errmsg, OPTIONS);
mark_point();
test_sleep(1);
ck_assert_str_eq(errmsg, "");
ck_assert(ctx != NULL);
ports_cnt = mg_get_server_ports(ctx, 16, ports);
ck_assert_int_eq(ports_cnt, 2);
ck_assert_int_eq(ports[0].protocol, 1);
ck_assert_int_eq(ports[0].port, 8080);
ck_assert_int_eq(ports[0].is_ssl, 0);
ck_assert_int_eq(ports[0].is_redirect, 1);
ck_assert_int_eq(ports[1].protocol, 1);
ck_assert_int_eq(ports[1].port, 8443);
ck_assert_int_eq(ports[1].is_ssl, 1);
ck_assert_int_eq(ports[1].is_redirect, 0);
ck_assert_int_eq(ports[2].protocol, 0);
ck_assert_int_eq(ports[2].port, 0);
ck_assert_int_eq(ports[2].is_ssl, 0);
ck_assert_int_eq(ports[2].is_redirect, 0);
test_sleep(1);
mark_point();
memset(client_err, 0, sizeof(client_err));
client_conn =
mg_connect_client("127.0.0.1", 8443, 1, client_err, sizeof(client_err));
ck_assert(client_conn == NULL);
ck_assert_str_ne(client_err, "");
memset(client_err, 0, sizeof(client_err));
memset(&client_options, 0, sizeof(client_options));
client_options.host = "127.0.0.1";
client_options.port = 8443;
client_options.client_cert = client_cert;
client_options.server_cert = server_cert;
client_conn = mg_connect_client_secure(&client_options,
client_err,
sizeof(client_err));
ck_assert(client_conn != NULL);
ck_assert_str_eq(client_err, "");
mg_printf(client_conn, "GET / HTTP/1.0\r\n\r\n");
client_res =
mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
ck_assert_int_ge(client_res, 0);
ck_assert_str_eq(client_err, "");
client_ri = mg_get_request_info(client_conn);
ck_assert(client_ri != NULL);
#if defined(NO_FILES)
ck_assert_str_eq(client_ri->uri, "404");
#else
ck_assert_str_eq(client_ri->uri, "200");
/* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
ck_assert_int_gt(client_res, 0);
ck_assert_int_le(client_res, sizeof(client_err));
#endif
mg_close_connection(client_conn);
/* TODO: A client API using a client certificate is missing */
mark_point();
test_sleep(1);
mark_point();
mg_stop(ctx);
#endif
}
END_TEST
START_TEST(test_mg_start_stop_https_server)
{
#ifndef NO_SSL
struct mg_context *ctx;
size_t ports_cnt;
int ports[16];
int ssl[16];
struct mg_callbacks callbacks;
char errmsg[256];
const char *OPTIONS[8]; /* initializer list here is rejected by CI test */
int opt_idx = 0;
const char *ssl_cert = locate_ssl_cert();
struct mg_connection *client_conn;
char client_err[256];
const struct mg_request_info *client_ri;
int client_res;
ck_assert(ssl_cert != NULL);
memset((void *)OPTIONS, 0, sizeof(OPTIONS));
#if !defined(NO_FILES)
OPTIONS[opt_idx++] = "document_root";
OPTIONS[opt_idx++] = ".";
#endif
OPTIONS[opt_idx++] = "listening_ports";
OPTIONS[opt_idx++] = "8080r,8443s";
OPTIONS[opt_idx++] = "ssl_certificate";
OPTIONS[opt_idx++] = ssl_cert;
ck_assert_int_le(opt_idx, (int)(sizeof(OPTIONS) / sizeof(OPTIONS[0])));
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 1] == NULL);
ck_assert(OPTIONS[sizeof(OPTIONS) / sizeof(OPTIONS[0]) - 2] == NULL);
memset(ports, 0, sizeof(ports));
memset(ssl, 0, sizeof(ssl));
memset(&callbacks, 0, sizeof(callbacks));
memset(errmsg, 0, sizeof(errmsg));
callbacks.log_message = log_msg_func;
ctx = mg_start(&callbacks, (void *)errmsg, OPTIONS);
mark_point();
test_sleep(1);
ck_assert_str_eq(errmsg, "");
ck_assert(ctx != NULL);
ports_cnt = mg_get_ports(ctx, 16, ports, ssl);
ck_assert_uint_eq(ports_cnt, 2);
ck_assert_int_eq(ports[0], 8080);
ck_assert_int_eq(ssl[0], 0);
ck_assert_int_eq(ports[1], 8443);
ck_assert_int_eq(ssl[1], 1);
ck_assert_int_eq(ports[2], 0);
ck_assert_int_eq(ssl[2], 0);
test_sleep(1);
mark_point();
memset(client_err, 0, sizeof(client_err));
client_conn =
mg_connect_client("127.0.0.1", 8443, 1, client_err, sizeof(client_err));
ck_assert(client_conn != NULL);
ck_assert_str_eq(client_err, "");
mg_printf(client_conn, "GET / HTTP/1.0\r\n\r\n");
client_res =
mg_get_response(client_conn, client_err, sizeof(client_err), 10000);
ck_assert_int_ge(client_res, 0);
ck_assert_str_eq(client_err, "");
client_ri = mg_get_request_info(client_conn);
ck_assert(client_ri != NULL);
#if defined(NO_FILES)
ck_assert_str_eq(client_ri->uri, "404");
#else
ck_assert_str_eq(client_ri->uri, "200");
/* TODO: ck_assert_str_eq(client_ri->request_method, "HTTP/1.0"); */
client_res = (int)mg_read(client_conn, client_err, sizeof(client_err));
ck_assert_int_gt(client_res, 0);
ck_assert_int_le(client_res, sizeof(client_err));
#endif
mg_close_connection(client_conn);
mark_point();
test_sleep(1);
mark_point();
mg_stop(ctx);
#endif
}
static struct rtsp_message *create_from_recipe(struct rtsp *bus,
struct recipe *rec)
{
struct rtsp_message *m;
void *raw;
size_t i, rawlen;
char t;
int r;
ck_assert(!!rec);
switch (rec->type) {
case RTSP_MESSAGE_REQUEST:
r = rtsp_message_new_request(bus,
&m,
rec->request.method,
rec->request.uri);
ck_assert_int_ge(r, 0);
break;
case RTSP_MESSAGE_REPLY:
r = rtsp_message_new_reply(bus,
&m,
rec->reply.cookie ? : 1,
rec->reply.code,
rec->reply.phrase);
ck_assert_int_ge(r, 0);
break;
case RTSP_MESSAGE_DATA:
r = rtsp_message_new_data(bus,
&m,
rec->data.channel,
rec->data.payload,
rec->data.size);
ck_assert_int_ge(r, 0);
break;
default:
ck_assert(false);
abort();
}
for (i = 0; rec->types && rec->types[i]; ++i) {
t = rec->types[i];
switch (t) {
case RTSP_TYPE_INT32:
r = rtsp_message_append_basic(m,
t,
rec->args[i].i32);
break;
case RTSP_TYPE_UINT32:
r = rtsp_message_append_basic(m,
t,
rec->args[i].u32);
break;
default:
r = rtsp_message_append_basic(m,
t,
rec->args[i].ptr);
break;
}
ck_assert_int_ge(r, 0);
}
r = rtsp_message_set_cookie(m, 1);
ck_assert_int_ge(r, 0);
r = rtsp_message_seal(m);
ck_assert_int_ge(r, 0);
/* compare to @raw */
raw = rtsp_message_get_raw(m);
ck_assert(!!raw);
rawlen = rtsp_message_get_raw_size(m);
if (debug)
fprintf(stderr, "---------EXPECT---------\n%s\n----------GOT-----------\n%s\n-----------END----------\n", (char*)rec->raw, (char*)raw);
ck_assert_int_eq(rawlen, rec->rawlen ? : strlen(rec->raw));
ck_assert(!memcmp(raw, rec->raw, rawlen));
return m;
}
static void verify_recipe(struct recipe *rec, struct rtsp_message *m)
{
size_t i;
int32_t i32;
uint32_t u32;
const char *str;
char t;
int r;
bool in_header = false;
ck_assert_int_eq(rtsp_message_get_type(m), rec->type);
switch (rec->type) {
case RTSP_MESSAGE_REQUEST:
ck_assert_str_eq(rtsp_message_get_method(m),
rec->request.method);
ck_assert_str_eq(rtsp_message_get_uri(m),
rec->request.uri);
break;
case RTSP_MESSAGE_REPLY:
ck_assert_int_eq(rtsp_message_get_code(m), rec->reply.code);
ck_assert_str_eq(rtsp_message_get_phrase(m), rec->reply.phrase);
break;
case RTSP_MESSAGE_DATA:
ck_assert_int_eq(rtsp_message_get_channel(m),
rec->data.channel);
ck_assert_int_eq(rtsp_message_get_payload_size(m),
rec->data.size);
ck_assert(!memcmp(rtsp_message_get_payload(m),
rec->data.payload,
rec->data.size));
break;
default:
ck_assert(false);
abort();
}
for (i = 0; rec->types && rec->types[i]; ++i) {
t = rec->types[i];
switch (t) {
case RTSP_TYPE_STRING:
r = rtsp_message_read_basic(m, t, &str);
ck_assert_int_ge(r, 0);
ck_assert(!!str);
ck_assert_str_eq(str, rec->args[i].ptr);
break;
case RTSP_TYPE_INT32:
r = rtsp_message_read_basic(m, t, &i32);
ck_assert_int_ge(r, 0);
ck_assert_int_eq(i32, rec->args[i].i32);
break;
case RTSP_TYPE_UINT32:
r = rtsp_message_read_basic(m, t, &u32);
ck_assert_int_ge(r, 0);
ck_assert_int_eq(u32, rec->args[i].u32);
break;
case RTSP_TYPE_RAW:
/* we cannot read TYPE_RAW outside headers */
if (in_header) {
r = rtsp_message_read_basic(m, t, &str);
ck_assert_int_ge(r, 0);
ck_assert(!!str);
ck_assert_str_eq(str, rec->args[i].ptr);
}
break;
case RTSP_TYPE_HEADER_START:
in_header = true;
r = rtsp_message_read_basic(m, t, rec->args[i].ptr);
ck_assert_int_ge(r, 0);
break;
case RTSP_TYPE_HEADER_END:
in_header = false;
/* fallthrough */
case RTSP_TYPE_BODY_START:
case RTSP_TYPE_BODY_END:
r = rtsp_message_read_basic(m, t, NULL);
ck_assert_int_ge(r, 0);
break;
default:
ck_assert(false);
abort();
}
}
}
TEST_END_CASE
START_TEST(msg_new_invalid)
{
char data[128] = { };
struct rtsp *bus;
struct rtsp_message *m;
int r, fd;
fd = dup(0);
ck_assert_int_ge(fd, 0);
r = rtsp_open(&bus, fd);
ck_assert_int_ge(r, 0);
/* request messages */
m = TEST_INVALID_PTR;
r = rtsp_message_new_request(NULL, &m, "method", "uri");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_request(bus, NULL, "method", "uri");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_request(bus, &m, "", "uri");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_request(bus, &m, NULL, "uri");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_request(bus, &m, "method", "");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_request(bus, &m, "method", NULL);
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_request(bus, &m, "method", "uri");
ck_assert_int_ge(r, 0);
ck_assert(m != TEST_INVALID_PTR);
rtsp_message_unref(m);
/* reply-for messages */
m = TEST_INVALID_PTR;
r = rtsp_message_new_reply(NULL, &m, 1, 200, "OK");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_reply(bus, NULL, 1, 200, "OK");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_reply(bus, &m, 0, 200, "OK");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_reply(bus, &m, 1, RTSP_ANY_CODE, "OK");
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_reply(bus, &m, 1, 200, "OK");
ck_assert_int_ge(r, 0);
ck_assert(m != TEST_INVALID_PTR);
rtsp_message_unref(m);
/* data messages */
m = TEST_INVALID_PTR;
r = rtsp_message_new_data(NULL, &m, 0, data, sizeof(data));
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_data(bus, NULL, 0, data, sizeof(data));
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_data(bus, &m, RTSP_ANY_CHANNEL, data, sizeof(data));
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_data(bus, &m, 0, NULL, sizeof(data));
ck_assert_int_lt(r, 0);
ck_assert(m == TEST_INVALID_PTR);
r = rtsp_message_new_data(bus, &m, 0, data, sizeof(data));
ck_assert_int_ge(r, 0);
ck_assert(m != TEST_INVALID_PTR);
rtsp_message_unref(m);
/* invalid ops */
rtsp_message_ref(NULL);
rtsp_message_unref(NULL);
ck_assert_int_eq(rtsp_message_get_type(NULL), 0);
ck_assert(!rtsp_message_get_method(NULL));
ck_assert(!rtsp_message_get_uri(NULL));
ck_assert_int_eq(rtsp_message_get_code(NULL), RTSP_ANY_CODE);
ck_assert(!rtsp_message_get_phrase(NULL));
ck_assert_int_eq(rtsp_message_get_channel(NULL), RTSP_ANY_CHANNEL);
ck_assert(!rtsp_message_get_payload(NULL));
ck_assert_int_eq(rtsp_message_get_payload_size(NULL), 0);
ck_assert(!rtsp_message_is_request(NULL, NULL, NULL));
ck_assert(!rtsp_message_is_reply(NULL, RTSP_ANY_CODE, NULL));
ck_assert(!rtsp_message_is_data(NULL, RTSP_ANY_CHANNEL));
ck_assert(!rtsp_message_get_bus(NULL));
ck_assert(!rtsp_message_get_cookie(NULL));
ck_assert(!rtsp_message_is_sealed(NULL));
rtsp_unref(bus);
}
END_TEST
START_TEST(run_msg)
{
struct wpas_message *m;
int r;
start_test_client();
r = wpas_message_new_reply(client, &m);
ck_assert_int_ge(r, 0);
r = wpas_send(client, m, 0);
ck_assert_int_ge(r, 0);
r = wpas_send(client, m, 0);
ck_assert_int_lt(r, 0);
wpas_message_unref(m);
r = wpas_message_new_reply(client, &m);
ck_assert_int_ge(r, 0);
wpas_message_set_peer(m, "/some/peer");
r = wpas_send(client, m, 0);
ck_assert_int_ge(r, 0);
r = wpas_send(client, m, 0);
ck_assert_int_lt(r, 0);
wpas_message_unref(m);
r = wpas_message_new_reply(server, &m);
ck_assert_int_ge(r, 0);
r = wpas_send(server, m, 0);
ck_assert_int_lt(r, 0);
wpas_message_set_peer(m, "/some/peer");
r = wpas_send(server, m, 0);
ck_assert_int_ge(r, 0);
r = wpas_send(server, m, 0);
ck_assert_int_lt(r, 0);
wpas_message_unref(m);
r = wpas_message_new_request(server, "sth", &m);
ck_assert_int_ge(r, 0);
r = wpas_call_async(server, m, NULL, NULL, 0, NULL);
ck_assert_int_lt(r, 0);
r = wpas_send(server, m, 0);
ck_assert_int_lt(r, 0);
wpas_message_set_peer(m, "/some/peer");
r = wpas_call_async(server, m, NULL, NULL, 0, NULL);
ck_assert_int_lt(r, 0);
r = wpas_send(server, m, 0);
ck_assert_int_ge(r, 0);
r = wpas_send(server, m, 0);
ck_assert_int_lt(r, 0);
wpas_message_unref(m);
r = wpas_message_new_request(client, "sth", &m);
ck_assert_int_ge(r, 0);
r = wpas_call_async(client, m, NULL, NULL, 0, NULL);
ck_assert_int_ge(r, 0);
r = wpas_call_async(client, m, NULL, NULL, 0, NULL);
ck_assert_int_lt(r, 0);
wpas_message_unref(m);
stop_test_client();
}
