710 lines
20 KiB
C
710 lines
20 KiB
C
#include <Efl_Net.h>
|
|
#include <Ecore_Getopt.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
|
|
static char *address = NULL;
|
|
static char *agent = "efl_net_dialer_websocket";
|
|
static unsigned int start_index = 0;
|
|
static unsigned int end_index = UINT32_MAX;
|
|
static unsigned int current_index = 0;
|
|
static Eina_Bool no_report_update = EINA_FALSE;
|
|
static Eina_List *case_tuples = NULL;
|
|
static Eina_Bool verbose = 0;
|
|
|
|
static Eo *pending = NULL;
|
|
|
|
/* https://www.w3.org/International/questions/qa-forms-utf-8 */
|
|
static Eina_Bool
|
|
_utf8_check(const char *text)
|
|
{
|
|
const unsigned char * bytes = (const unsigned char *)text;
|
|
while (*bytes)
|
|
{
|
|
const unsigned char c = bytes[0];
|
|
|
|
/* ascii: [\x09\x0A\x0D\x20-\x7E] */
|
|
if (((c >= 0x20) && (c <= 0x7e)) ||
|
|
(c == 0x09) || (c == 0x0a) || (c == 0x0d))
|
|
{
|
|
bytes += 1;
|
|
continue;
|
|
}
|
|
|
|
/* autobahnsuite says 0x7f is valid */
|
|
if (c == 0x7f)
|
|
{
|
|
bytes += 1;
|
|
continue;
|
|
}
|
|
|
|
#define VALUE_BYTE_CHECK(x) ((x >= 0x80) && (x <= 0xbf))
|
|
|
|
/* non-overlong 2-byte: [\xC2-\xDF][\x80-\xBF] */
|
|
if ((c >= 0xc2) && (c <= 0xdf))
|
|
{
|
|
if (VALUE_BYTE_CHECK(bytes[1]))
|
|
{
|
|
bytes += 2;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* excluding overlongs: \xE0[\xA0-\xBF][\x80-\xBF] */
|
|
if (c == 0xe0)
|
|
{
|
|
const unsigned char d = bytes[1];
|
|
if ((d >= 0xa0) && (d <= 0xbf))
|
|
{
|
|
if (VALUE_BYTE_CHECK(bytes[2]))
|
|
{
|
|
bytes += 3;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* straight 3-byte: [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} */
|
|
if (((c >= 0xe1) && (c <= 0xec)) ||
|
|
(c == 0xee) || (c == 0xef))
|
|
{
|
|
if (VALUE_BYTE_CHECK(bytes[1]) && VALUE_BYTE_CHECK(bytes[2]))
|
|
{
|
|
bytes += 3;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* excluding surrogates: \xED[\x80-\x9F][\x80-\xBF] */
|
|
if (c == 0xed)
|
|
{
|
|
const unsigned char d = bytes[1];
|
|
if ((d >= 0x80) && (d <= 0x9f))
|
|
{
|
|
if (VALUE_BYTE_CHECK(bytes[2]))
|
|
{
|
|
bytes += 3;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* planes 1-3: \xF0[\x90-\xBF][\x80-\xBF]{2} */
|
|
if (c == 0xf0)
|
|
{
|
|
const unsigned char d = bytes[1];
|
|
if ((d >= 0x90) && (d <= 0xbf))
|
|
{
|
|
if (VALUE_BYTE_CHECK(bytes[2]) && VALUE_BYTE_CHECK(bytes[3]))
|
|
{
|
|
bytes += 4;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
/* planes 4-15: [\xF1-\xF3][\x80-\xBF]{3} */
|
|
if ((c >= 0xf1) && (c <= 0xf3))
|
|
{
|
|
if (VALUE_BYTE_CHECK(bytes[1]) && VALUE_BYTE_CHECK(bytes[2]) && VALUE_BYTE_CHECK(bytes[3]))
|
|
{
|
|
bytes += 4;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* plane 16: \xF4[\x80-\x8F][\x80-\xBF]{2} */
|
|
if (c == 0xf4)
|
|
{
|
|
const unsigned char d = bytes[1];
|
|
if ((d >= 0x80) && (d <= 0x8f))
|
|
{
|
|
if (VALUE_BYTE_CHECK(bytes[2]) && VALUE_BYTE_CHECK(bytes[3]))
|
|
{
|
|
bytes += 4;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (verbose) fprintf(stderr, "INFO: failed unicode byte #%zd '%s'\n", (const char*)bytes - text, text);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
static void
|
|
_ws_pong(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
const char *text = event->info;
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s got PONG: %s\n",
|
|
efl_name_get(dialer), text);
|
|
}
|
|
|
|
static void
|
|
_ws_closed_reason(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
Efl_Net_Dialer_Websocket_Closed_Reason *reason = event->info;
|
|
|
|
if (!_utf8_check(reason->message))
|
|
{
|
|
efl_net_dialer_websocket_close_request(dialer, EFL_NET_DIALER_WEBSOCKET_CLOSE_REASON_PROTOCOL_ERROR, "invalid UTF-8");
|
|
if (verbose) fprintf(stderr, "INFO: %s got CLOSE with invalid UTF-8\n", efl_name_get(dialer));
|
|
}
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s got CLOSE: %4d '%s'\n",
|
|
efl_name_get(dialer), reason->reason, reason->message);
|
|
}
|
|
|
|
static void
|
|
_ws_message_text(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
const char *text = event->info;
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s got TEXT %zd bytes:\n%s\n",
|
|
efl_name_get(dialer), strlen(text), text);
|
|
}
|
|
|
|
static void
|
|
_ws_message_binary(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
const Eina_Slice *slice = event->info;
|
|
size_t i;
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s got BINARY %zd bytes\n",
|
|
efl_name_get(dialer), slice->len);
|
|
|
|
for (i = 0; i < slice->len; i++)
|
|
{
|
|
const int c = slice->bytes[i];
|
|
if (isprint(c))
|
|
fprintf(stderr, " %#4x(%c)", c, c);
|
|
else
|
|
fprintf(stderr, " %#4x", c);
|
|
}
|
|
|
|
fprintf(stderr, "\n");
|
|
}
|
|
|
|
static void
|
|
_closed(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s closed\n", efl_name_get(dialer));
|
|
}
|
|
|
|
static void
|
|
_eos(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s eos\n", efl_name_get(dialer));
|
|
}
|
|
|
|
static void
|
|
_connected(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s connected %s\n",
|
|
efl_name_get(dialer),
|
|
efl_net_dialer_address_dial_get(dialer));
|
|
}
|
|
|
|
static void
|
|
_error(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
const Eina_Error *perr = event->info;
|
|
fprintf(stderr, "ERROR: %s error: %d '%s'\n",
|
|
efl_name_get(dialer), *perr, eina_error_msg_get(*perr));
|
|
efl_loop_quit(efl_loop_get(event->object), eina_value_int_init(EXIT_FAILURE));
|
|
}
|
|
|
|
static void
|
|
_del(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
if (pending == dialer)
|
|
pending = NULL;
|
|
}
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(dialer_cbs,
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_PONG, _ws_pong },
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_CLOSED_REASON, _ws_closed_reason },
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _ws_message_text },
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _ws_message_binary },
|
|
{ EFL_NET_DIALER_EVENT_DIALER_CONNECTED, _connected },
|
|
{ EFL_NET_DIALER_EVENT_ERROR, _error },
|
|
{ EFL_IO_CLOSER_EVENT_CLOSED, _closed },
|
|
{ EFL_IO_READER_EVENT_EOS, _eos },
|
|
{ EFL_EVENT_DEL, _del });
|
|
|
|
static Eo *
|
|
_websocket_new(const char *name, Eo *loop)
|
|
{
|
|
Eo *dialer;
|
|
|
|
dialer = efl_add(EFL_NET_DIALER_WEBSOCKET_CLASS, loop,
|
|
efl_name_set(efl_added, name),
|
|
efl_event_callback_array_add(efl_added, dialer_cbs(), NULL));
|
|
if (!dialer)
|
|
{
|
|
efl_loop_quit(loop, eina_value_int_init(EXIT_FAILURE));
|
|
fprintf(stderr, "ERROR: could not create WebSockets dialer '%s'\n", name);
|
|
return NULL;
|
|
}
|
|
|
|
pending = dialer;
|
|
|
|
return dialer;
|
|
}
|
|
|
|
static void
|
|
_closed_quit(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
efl_del(dialer);
|
|
ecore_main_loop_quit();
|
|
}
|
|
|
|
static void
|
|
_tests_finished(Eo *loop)
|
|
{
|
|
Eo *dialer;
|
|
char url[4096];
|
|
int len;
|
|
Eina_Error err;
|
|
|
|
if (no_report_update)
|
|
{
|
|
if (verbose)
|
|
fprintf(stderr, "INFO: tests finished, user required to not update the reports\n");
|
|
ecore_main_loop_quit();
|
|
return;
|
|
}
|
|
|
|
case_tuples = eina_list_remove(case_tuples, case_tuples);
|
|
len = snprintf(url, sizeof(url), "%s/updateReports?agent=%s",
|
|
address, agent);
|
|
if (len < 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL "
|
|
"'%s/updateReports?agent=%s': %s",
|
|
address, agent, strerror(errno));
|
|
ecore_main_loop_quit();
|
|
return;
|
|
}
|
|
else if ((size_t)len > sizeof(url))
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL "
|
|
"'%s/updateReports?agent=%s': no space.",
|
|
address, agent);
|
|
ecore_main_loop_quit();
|
|
return;
|
|
}
|
|
|
|
dialer = _websocket_new("update-reports", loop);
|
|
if (!dialer)
|
|
{
|
|
ecore_main_loop_quit();
|
|
return;
|
|
}
|
|
|
|
efl_event_callback_add(dialer, EFL_IO_CLOSER_EVENT_CLOSED, _closed_quit, NULL);
|
|
|
|
err = efl_net_dialer_dial(dialer, url);
|
|
if (err != 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not dial '%s': %s",
|
|
url, eina_error_msg_get(err));
|
|
efl_del(dialer);
|
|
efl_loop_quit(loop, eina_value_int_init(EXIT_FAILURE));
|
|
return;
|
|
}
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: %s '%s'\n",
|
|
efl_name_get(dialer), efl_net_dialer_address_dial_get(dialer));
|
|
}
|
|
|
|
static void
|
|
_echo_text(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
const char *text = event->info;
|
|
|
|
if (!_utf8_check(text))
|
|
{
|
|
if (verbose) fprintf(stderr, "INFO: invalid UTF-8 sequence '%s'. Close the connection.\n", text);
|
|
efl_net_dialer_websocket_close_request(dialer, EFL_NET_DIALER_WEBSOCKET_CLOSE_REASON_INCONSISTENT_DATA, "invalid UTF-8");
|
|
return;
|
|
}
|
|
|
|
efl_net_dialer_websocket_text_send(dialer, text);
|
|
}
|
|
|
|
static void
|
|
_echo_binary(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
const Eina_Slice *slice = event->info;
|
|
efl_net_dialer_websocket_binary_send(dialer, *slice);
|
|
}
|
|
|
|
static Eina_Bool _websocket_test_next_case_tuple(Eo *loop);
|
|
|
|
static void
|
|
_test_next_case_closed(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
efl_del(dialer);
|
|
|
|
if (!_websocket_test_next_case_tuple(efl_loop_get(event->object)))
|
|
_tests_finished(efl_loop_get(event->object));
|
|
}
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(_test_next_case_tuple_cbs,
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _echo_text },
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _echo_binary },
|
|
{ EFL_IO_CLOSER_EVENT_CLOSED, _test_next_case_closed });
|
|
|
|
static Eina_Bool
|
|
_websocket_test_next_case_tuple(Eo *loop)
|
|
{
|
|
Eo *dialer;
|
|
char url[4096];
|
|
char name[256];
|
|
char *str;
|
|
int len;
|
|
Eina_Error err;
|
|
|
|
if (!case_tuples)
|
|
return EINA_FALSE;
|
|
|
|
str = case_tuples->data;
|
|
case_tuples = eina_list_remove_list(case_tuples, case_tuples);
|
|
len = snprintf(url, sizeof(url), "%s/runCase?casetuple=%s&agent=%s",
|
|
address, str, agent);
|
|
if (len < 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL "
|
|
"'%s/runCase?casetuple=%s&agent=%s': %s",
|
|
address, str, agent, strerror(errno));
|
|
free(str);
|
|
return EINA_FALSE;
|
|
}
|
|
else if ((size_t)len > sizeof(url))
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL "
|
|
"'%s/runCase?casetuple=%s&agent=%s': no space.",
|
|
address, str, agent);
|
|
free(str);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
snprintf(name, sizeof(name), "test_case=%s", str);
|
|
free(str);
|
|
|
|
dialer = _websocket_new(name, loop);
|
|
if (!dialer) return EINA_FALSE;
|
|
|
|
efl_event_callback_array_add(dialer, _test_next_case_tuple_cbs(), NULL);
|
|
|
|
err = efl_net_dialer_dial(dialer, url);
|
|
if (err != 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not dial '%s': %s",
|
|
url, eina_error_msg_get(err));
|
|
efl_del(dialer);
|
|
efl_loop_quit(loop, eina_value_int_init(EXIT_FAILURE));
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
fprintf(stderr, "TEST: %s '%s'\n", efl_name_get(dialer), efl_net_dialer_address_dial_get(dialer));
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
static Eina_Bool _websocket_test_index(unsigned int idx, Eo *loop);
|
|
|
|
static void
|
|
_test_index_closed(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
efl_del(dialer);
|
|
|
|
if (!_websocket_test_index(current_index + 1, efl_loop_get(event->object)))
|
|
_tests_finished(efl_loop_get(event->object));
|
|
}
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(_test_index_cbs,
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _echo_text },
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_BINARY, _echo_binary },
|
|
{ EFL_IO_CLOSER_EVENT_CLOSED, _test_index_closed });
|
|
|
|
static Eina_Bool
|
|
_websocket_test_index(unsigned int idx, Eo *loop)
|
|
{
|
|
Eo *dialer;
|
|
char url[4096];
|
|
char name[64];
|
|
int len;
|
|
Eina_Error err;
|
|
|
|
if (idx > end_index)
|
|
return EINA_FALSE;
|
|
|
|
len = snprintf(url, sizeof(url), "%s/runCase?case=%u&agent=%s",
|
|
address, idx, agent);
|
|
if (len < 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL "
|
|
"'%s/runCase?case=%u&agent=%s': %s",
|
|
address, idx, agent, strerror(errno));
|
|
return EINA_FALSE;
|
|
}
|
|
else if ((size_t)len > sizeof(url))
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL "
|
|
"'%s/runCase?case=%u&agent=%s': no space.",
|
|
address, idx, agent);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
snprintf(name, sizeof(name), "test_case=%u", idx);
|
|
|
|
dialer = _websocket_new(name, loop);
|
|
if (!dialer) return EINA_FALSE;
|
|
|
|
efl_event_callback_array_add(dialer, _test_index_cbs(), NULL);
|
|
|
|
err = efl_net_dialer_dial(dialer, url);
|
|
if (err != 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not dial '%s': %s",
|
|
url, eina_error_msg_get(err));
|
|
efl_del(dialer);
|
|
efl_loop_quit(loop, eina_value_int_init(EXIT_FAILURE));
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
current_index = idx;
|
|
|
|
fprintf(stderr, "TEST: %s '%s'\n", efl_name_get(dialer), efl_net_dialer_address_dial_get(dialer));
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
static void
|
|
_load_tests_text(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
const char *text = event->info;
|
|
unsigned int n = strtoul(text, NULL, 10);
|
|
|
|
if (start_index == 0)
|
|
start_index = 1;
|
|
else if (start_index > n)
|
|
start_index = n;
|
|
|
|
if (end_index == 0 || end_index > n)
|
|
end_index = n;
|
|
|
|
if (!verbose) return;
|
|
fprintf(stderr, "INFO: test count: %u, start_index=%u, end_index=%u\n",
|
|
n, start_index, end_index);
|
|
}
|
|
|
|
static void
|
|
_load_tests_closed(void *data EINA_UNUSED, const Efl_Event *event)
|
|
{
|
|
Eo *dialer = event->object;
|
|
efl_del(dialer);
|
|
|
|
if (!_websocket_test_index(start_index, efl_loop_get(event->object)))
|
|
_tests_finished(efl_loop_get(event->object));
|
|
}
|
|
|
|
EFL_CALLBACKS_ARRAY_DEFINE(_load_tests_cbs,
|
|
{ EFL_NET_DIALER_WEBSOCKET_EVENT_MESSAGE_TEXT, _load_tests_text },
|
|
{ EFL_IO_CLOSER_EVENT_CLOSED, _load_tests_closed });
|
|
|
|
static Eina_Bool
|
|
_websocket_load_tests(Eo *loop)
|
|
{
|
|
Eo *dialer;
|
|
char url[4096];
|
|
int len;
|
|
Eina_Error err;
|
|
|
|
len = snprintf(url, sizeof(url), "%s/getCaseCount", address);
|
|
if (len < 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL '%s/getCaseCount': %s",
|
|
address, strerror(errno));
|
|
return EINA_FALSE;
|
|
}
|
|
else if ((size_t)len > sizeof(url))
|
|
{
|
|
fprintf(stderr, "ERROR: could not create URL '%s/getCaseCount': no space.",
|
|
address);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
dialer = _websocket_new("get-case-count", loop);
|
|
if (!dialer) return EINA_FALSE;
|
|
|
|
efl_event_callback_array_add(dialer, _load_tests_cbs(), NULL);
|
|
|
|
err = efl_net_dialer_dial(dialer, url);
|
|
if (err != 0)
|
|
{
|
|
fprintf(stderr, "ERROR: could not dial '%s': %s",
|
|
url, eina_error_msg_get(err));
|
|
efl_del(dialer);
|
|
efl_loop_quit(loop, eina_value_int_init(EXIT_FAILURE));
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
if (verbose) fprintf(stderr, "INFO: %s '%s'\n", efl_name_get(dialer), efl_net_dialer_address_dial_get(dialer));
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
static const Ecore_Getopt options = {
|
|
"efl_net_dialer_websocket_autobahntestee", /* program name */
|
|
NULL, /* usage line */
|
|
"1", /* version */
|
|
"(C) 2016 Enlightenment Project", /* copyright */
|
|
"BSD 2-Clause", /* license */
|
|
/* long description, may be multiline and contain \n */
|
|
"Use Efl_Net_Dialer_Websocket to implement a testee client for the Autobahn Test Suite."
|
|
"\n"
|
|
"Autobahn Test Suite http://autobahn.ws/testsuite provides a fully automated test suite to verify client and server implementations of the WebSocket Protocol for specification conformance and implementation robustness."
|
|
"\n"
|
|
"This is a client to talk to their test server, that should be executed as:\n"
|
|
" wstest -m fuzzingserver\n"
|
|
"\n",
|
|
EINA_FALSE,
|
|
{
|
|
ECORE_GETOPT_STORE_UINT('s', "start-index", "when running batch, specifies the start (first) index"),
|
|
ECORE_GETOPT_STORE_UINT('e', "end-index", "when running batch, specifies the end (last) index"),
|
|
ECORE_GETOPT_STORE_TRUE('n', "no-report-update", "do not trigger autobahn to update report"),
|
|
ECORE_GETOPT_STORE_TRUE('v', "verbose", "print messages"),
|
|
ECORE_GETOPT_APPEND('t', "test-case", "the test-case tuple such as '1.2.8'", ECORE_GETOPT_TYPE_STR),
|
|
ECORE_GETOPT_STORE_STR('a', "agent", "the agent identifier"),
|
|
ECORE_GETOPT_VERSION('V', "version"),
|
|
ECORE_GETOPT_COPYRIGHT('C', "copyright"),
|
|
ECORE_GETOPT_LICENSE('L', "license"),
|
|
ECORE_GETOPT_HELP('h', "help"),
|
|
ECORE_GETOPT_STORE_METAVAR_STR(0, NULL,
|
|
"The address (URL) to dial, such as ws://127.0.0.1:9001", "address"),
|
|
ECORE_GETOPT_SENTINEL
|
|
}
|
|
};
|
|
|
|
EAPI_MAIN void
|
|
efl_pause(void *data EINA_UNUSED,
|
|
const Efl_Event *ev EINA_UNUSED)
|
|
{
|
|
}
|
|
|
|
EAPI_MAIN void
|
|
efl_resume(void *data EINA_UNUSED,
|
|
const Efl_Event *ev EINA_UNUSED)
|
|
{
|
|
}
|
|
|
|
EAPI_MAIN void
|
|
efl_terminate(void *data EINA_UNUSED,
|
|
const Efl_Event *ev EINA_UNUSED)
|
|
{
|
|
/* FIXME: For the moment the main loop doesn't get
|
|
properly destroyed on shutdown which disallow
|
|
relying on parent destroying their children */
|
|
if (pending)
|
|
{
|
|
efl_del(pending);
|
|
pending = NULL;
|
|
}
|
|
if (verbose) fprintf(stderr, "INFO: main loop finished.\n");
|
|
}
|
|
|
|
EAPI_MAIN void
|
|
efl_main(void *data EINA_UNUSED,
|
|
const Efl_Event *ev)
|
|
{
|
|
Eina_Bool quit_option = EINA_FALSE;
|
|
Ecore_Getopt_Value values[] = {
|
|
ECORE_GETOPT_VALUE_UINT(start_index),
|
|
ECORE_GETOPT_VALUE_UINT(end_index),
|
|
ECORE_GETOPT_VALUE_BOOL(no_report_update),
|
|
ECORE_GETOPT_VALUE_BOOL(verbose),
|
|
ECORE_GETOPT_VALUE_LIST(case_tuples),
|
|
ECORE_GETOPT_VALUE_STR(agent),
|
|
|
|
/* standard block to provide version, copyright, license and help */
|
|
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -V/--version quits */
|
|
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -C/--copyright quits */
|
|
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -L/--license quits */
|
|
ECORE_GETOPT_VALUE_BOOL(quit_option), /* -h/--help quits */
|
|
|
|
/* positional argument */
|
|
ECORE_GETOPT_VALUE_STR(address),
|
|
|
|
ECORE_GETOPT_VALUE_NONE /* sentinel */
|
|
};
|
|
int args;
|
|
Eina_Bool r;
|
|
|
|
args = ecore_getopt_parse(&options, values, 0, NULL);
|
|
if (args < 0)
|
|
{
|
|
fputs("ERROR: Could not parse command line options.\n", stderr);
|
|
goto end;
|
|
}
|
|
|
|
if (quit_option) goto end;
|
|
|
|
args = ecore_getopt_parse_positional(&options, values, 0, NULL, args);
|
|
if (args < 0)
|
|
{
|
|
fputs("ERROR: Could not parse positional arguments.\n", stderr);
|
|
goto end;
|
|
}
|
|
|
|
if (case_tuples)
|
|
r = _websocket_test_next_case_tuple(ev->object);
|
|
else if (start_index == end_index)
|
|
r = _websocket_test_index(start_index, ev->object);
|
|
else
|
|
r = _websocket_load_tests(ev->object);
|
|
|
|
if (r)
|
|
{
|
|
ecore_main_loop_begin();
|
|
}
|
|
|
|
if (pending)
|
|
efl_del(pending);
|
|
|
|
return ;
|
|
|
|
end:
|
|
efl_loop_quit(efl_loop_get(ev->object), eina_value_int_init(EXIT_FAILURE));
|
|
}
|
|
|
|
EFL_MAIN_EX();
|