int
main(int argc, char **argv)
{
double interval = 0.3; // tick each 0.3 seconds
Ecore_Poller *poller1, *poller2;
char *str1 = "poller1";
char *str2 = "poller2";
if (!ecore_init())
{
printf("ERROR: Cannot init Ecore!\n");
return -1;
}
_initial_time = ecore_time_get();
ecore_poller_poll_interval_set(ECORE_POLLER_CORE, interval);
poller1 = ecore_poller_add(ECORE_POLLER_CORE, 4, _poller_print_cb, str1);
poller2 = ecore_poller_add(ECORE_POLLER_CORE, 8, _poller_print_cb, str2);
ecore_main_loop_begin();
printf("changing poller2 interval to 16\n");
ecore_poller_poller_interval_set(poller2, 16);
ecore_main_loop_begin();
ecore_poller_del(poller1);
ecore_poller_del(poller2);
ecore_shutdown();
}
int
main(void)
{
double start;
Eina_Hash *headers;
eina_init();
ecore_init();
ecore_file_init();
if (ecore_file_exists(DST))
ecore_file_unlink(DST);
start = ecore_time_get();
if (ecore_file_download(URL, DST, completion_cb, progress_cb, NULL, NULL))
{
printf("Download started successfully:\n URL: %s\n DEST: %s\n", URL, DST);
ecore_main_loop_begin();
printf("\nTime elapsed: %f seconds\n", ecore_time_get() - start);
printf("Downloaded %lld bytes\n", ecore_file_size(DST));
}
else
{
printf("Error, can't start download\n");
goto done;
}
headers = eina_hash_string_small_new(NULL);
eina_hash_add(headers, "Content-type", "application/x-gzip");
if (ecore_file_download_full(URL, DST_MIME, completion_cb, progress_cb, NULL, NULL, headers))
{
printf("Download started successfully:\n URL: %s\n DEST: %s\n", URL, DST_MIME);
ecore_main_loop_begin();
printf("\nTime elapsed: %f seconds\n", ecore_time_get() - start);
printf("Downloaded %lld bytes\n", ecore_file_size(DST));
}
else
{
printf("Error, can't start download\n");
goto done;
}
done:
if (headers) eina_hash_free(headers);
ecore_file_shutdown();
ecore_shutdown();
eina_shutdown();
return 0;
}
int
main(int argc, char **argv)
{
double interval = 0.3; // tick each 0.3 seconds
Ecore_Poller *poller1, *poller2, *poller3;
char *str1 = "poller1";
char *str2 = "poller2";
char *str3 = "poller3";
if (!ecore_init())
{
printf("ERROR: Cannot init Ecore!\n");
return -1;
}
_initial_time = ecore_time_get();
ecore_poller_poll_interval_set(ECORE_POLLER_CORE, interval);
// poller1 = ecore_poller_add(ECORE_POLLER_CORE, 4, _poller_print_cb, str1);
// poller2 = ecore_poller_add(ECORE_POLLER_CORE, 8, _poller_print_cb, str2);
// poller3 = ecore_poller_add(ECORE_POLLER_CORE, 30, _poller_quit_cb, str3);
poller1 = eo_add_custom(ECORE_POLLER_CLASS, NULL,
ecore_poller_constructor(ECORE_POLLER_CORE, 4, _poller_print_cb, str1));
poller2 = eo_add_custom(ECORE_POLLER_CLASS, NULL,
ecore_poller_constructor(ECORE_POLLER_CORE, 8, _poller_print_cb, str2));
poller3 = eo_add_custom(ECORE_POLLER_CLASS, NULL,
ecore_poller_constructor(ECORE_POLLER_CORE, 20, _poller_quit_cb, str3));
ecore_main_loop_begin();
printf("changing poller2 interval to 16\n");
// ecore_poller_poller_interval_set(poller2, 16);
eo_do(poller2, ecore_poller_interval_set(16, NULL));
ecore_main_loop_begin();
eo_unref(poller1);
eo_unref(poller2);
eo_unref(poller3);
// ecore_poller_del(poller1);
// ecore_poller_del(poller2);
// ecore_poller_del(poller3);
ecore_shutdown();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_file_copy(argv[1], argv[2],
NULL,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
int
ecore_config_ipc_send(Ecore_Config_Ipc_Server_List ** srv_list, int major,
int minor, void *data, int size)
{
Ecore_Config_Ipc_Server_List *tmp = *srv_list;
static int ref = 0;
int ret;
if (!srv_list)
return ECORE_CONFIG_ERR_FAIL;
if (!*srv_list)
return ECORE_CONFIG_ERR_NODATA;
ret = ECORE_CONFIG_ERR_NODATA;
if (size < 0)
size = data ? strlen(data) + 1 : 0;
while (tmp) {
ret =
ecore_ipc_server_send(tmp->srv, major, minor, ++ref, 0, 0, data, size);
tmp = tmp->next;
}
E(2, "exsh: we sent: %2d.%02d #%03d \"%s\".%d => %d\n",
major, minor, ref, (char *) data, size, ret);
if ((debug >= 2) && (size > 0))
print_data(data, size);
#ifdef EXSH
ecore_main_loop_begin();
#endif
return ECORE_CONFIG_ERR_SUCC;
}
int
main(void)
{
double done;
eina_init();
ecore_init();
ecore_con_init();
eina_log_domain_level_set("ecore_con", EINA_LOG_LEVEL_ERR);
eina_log_domain_level_set("eina", EINA_LOG_LEVEL_ERR);
counter = eina_counter_new("client");
eina_counter_start(counter);
done = ecore_time_get();
ecore_job_add(_spawn, NULL);
/* set event handler for server connect */
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_add, NULL);
ecore_event_handler_add(ECORE_CON_EVENT_SERVER_ADD, (Ecore_Event_Handler_Cb)_del, NULL);
/* start client */
ecore_main_loop_begin();
eina_counter_stop(counter, 1);
printf("\nTime elapsed for %i connections: %f seconds\n%s", NUM_CLIENTS, ecore_time_get() - done, eina_counter_dump(counter));
return 0;
}
int
main(int argc, char **argv)
{
ecore_dbus_init();
svr = ecore_dbus_server_system_connect(NULL);
if (!svr)
{
printf("Couldn't connect to dbus system server!\n");
}
else
{
int i = 0;
Ecore_Event_Handler *handler[3];
printf("Connected!\n");
handler[i++] = ecore_event_handler_add(ECORE_DBUS_EVENT_SERVER_ADD,
ecore_dbus_event_server_add, NULL);
handler[i++] = ecore_event_handler_add(ECORE_DBUS_EVENT_SERVER_DEL,
ecore_dbus_event_server_del, NULL);
handler[i++] = ecore_event_handler_add(ECORE_DBUS_EVENT_SIGNAL,
ecore_dbus_event_server_signal, NULL);
ecore_main_loop_begin();
for (i = 0; i < 3; i++)
ecore_event_handler_del(handler[i]);
if (svr) ecore_dbus_server_del(svr);
}
ecore_dbus_shutdown();
return 0;
}
int
main(void)
{
Ecore_Evas *ee;
ecore_evas_init();
ee = ecore_evas_new(NULL, 0, 0, 200, 100, NULL);
ecore_evas_title_set(ee, "Ecore Evas Callbacks Example");
ecore_evas_show(ee);
//callbacks
ecore_evas_callback_delete_request_set(ee, _delete);
ecore_evas_callback_destroy_set(ee, _destroy);
ecore_evas_callback_focus_in_set(ee, _focus_in);
ecore_evas_callback_focus_out_set(ee, _focus_out);
ecore_evas_callback_hide_set(ee, _hide);
ecore_evas_callback_mouse_in_set(ee, _mouse_in);
ecore_evas_callback_mouse_out_set(ee, _mouse_out);
ecore_evas_callback_move_set(ee, _move);
ecore_evas_callback_post_render_set(ee, _post_render);
ecore_evas_callback_pre_free_set(ee, _pre_free);
ecore_evas_callback_pre_render_set(ee, _pre_render);
ecore_evas_callback_resize_set(ee, _resize);
ecore_evas_callback_show_set (ee, _show);
ecore_main_loop_begin();
ecore_evas_free(ee);
ecore_evas_shutdown();
return 0;
}
int
main()
{
Ecore_Con_Server *svr;
eina_init();
ecore_init();
ecore_con_init();
/* comment if not using gnutls */
gnutls_global_set_log_level(9);
gnutls_global_set_log_function(tls_log_func);
/* to use a PEM certificate with TLS and SSL3, uncomment the lines below */
if (!(svr = ecore_con_server_add(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_TLS | ECORE_CON_USE_SSL3 | ECORE_CON_LOAD_CERT, "127.0.0.1", 8080, NULL)))
/* to use simple tcp with ssl/tls, use this line */
// if (!ecore_con_server_add(ECORE_CON_REMOTE_TCP | ECORE_CON_USE_SSL3, "127.0.0.1", 8080, NULL))
exit(1);
ecore_con_ssl_server_cert_add(svr, "server.pem");
ecore_con_ssl_server_privkey_add(svr, "server.pem");
/* set event handler for client connect */
ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_add, NULL);
/* set event handler for client disconnect */
ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_del, NULL);
/* set event handler for receiving client data */
ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_data, NULL);
/* start server */
ecore_main_loop_begin();
}
int
main(int argc, char **argv)
{
struct context ctxt = {0};
if (!ecore_init())
{
printf("ERROR: Cannot init Ecore!\n");
return -1;
}
_event_type = ecore_event_type_new();
ctxt.enterer = ecore_idle_enterer_add(_enterer_cb, &ctxt);
ctxt.exiter = ecore_idle_exiter_add(_exiter_cb, &ctxt);
// ctxt.idler = ecore_idler_add(_idler_cb, &ctxt);
ctxt.idler = eo_add_custom(ECORE_IDLER_CLASS, NULL, ecore_idler_constructor(_idler_cb, &ctxt));
ctxt.handler = ecore_event_handler_add(_event_type,
_event_handler_cb,
&ctxt);
ctxt.timer = ecore_timer_add(0.0005, _timer_cb, &ctxt);
ecore_main_loop_begin();
ecore_shutdown();
return 0;
}
int main()
{
eina_init();
ecore_con_init();
/*no new function because there's no free function*/
static zrpc_con zcon;
/*set up host/port*/
// zcon.host = "www.domain.com";
// zcon.port = 4444;
zcon.host = "10.10.10.6";
zcon.port = 65534;
// char *username = "******";
// char *password = "******";
char *username = "******";
char *password = "******";
/*all zrpc functions take a minimum of 3 arguments:
* 1) a zcon handle
* 2) a zrpc_network_cb function
* 3) a (void*) to pass to the callback
*/
zrpc_User_login(username, password, &zcon, (void*)post, &zcon);
/*start the ecore job server*/
ecore_main_loop_begin();
return 0;
}
int main(int argc, char *argv[])
{
const char *url;
int args = 1;
if (!ecore_evas_init())
return EXIT_FAILURE;
if (args < argc)
url = argv[args];
else
url = DEFAULT_URL;
MiniBrowser *browser = browserCreate(url);
Ecore_Event_Handler *handle = ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, main_signal_exit, 0);
ecore_main_loop_begin();
ecore_event_handler_del(handle);
ecore_evas_free(browser->ee);
free(browser);
ecore_evas_shutdown();
return 0;
}
int
main (int argc, char *argv[])
{
Ecore_Pipe *pipe;
pid_t child_pid;
ecore_init();
pipe = ecore_pipe_add(handler, NULL);
child_pid = fork();
if(!child_pid)
{
ecore_pipe_read_close(pipe);
do_lengthy_task(pipe);
}
else
{
ecore_pipe_write_close(pipe);
ecore_main_loop_begin();
}
ecore_pipe_del(pipe);
ecore_shutdown();
return 0;
}
int main(int argc, char *argv[])
{
Ecore_Evas *window;
Evas *canvas;
Evas_Object *edje;
const char *text;
ecore_evas_init();
edje_init();
window = ecore_evas_new(NULL, 0, 0, WIDTH, HEIGHT, NULL);
if (!window)
{
EINA_LOG_CRIT("could not create window.");
return -1;
}
canvas = ecore_evas_get(window);
text = (argc > 1) ? argv[1] : NULL;
edje = create_my_group(canvas, text);
if (!edje)
return -2;
ecore_evas_show(window);
ecore_main_loop_begin();
evas_object_del(edje);
ecore_evas_free(window);
edje_shutdown();
ecore_evas_shutdown();
return 0;
}
int main(int argc, char **argv) {
init_efl();
char *theme = find_theme();
if (!theme)
fatal("Could not find theme");
Ecore_Evas *ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, 400, 400);
if (!ee) {
fprintf(stderr, "FATAL: Could not get an ee...\n");
exit(1);
}
Ecore_X_Screen_Size sz = get_screen_size(ee);
ecore_evas_resize(ee, sz.width, sz.height);
ecore_evas_title_set(ee, "Launcher");
ecore_evas_borderless_set(ee, 1);
ecore_evas_fullscreen_set(ee, 1);
Evas *evas = ecore_evas_get(ee);
Evas_Object *edje = edje_object_add(evas);
edje_object_file_set(edje, theme, "main");
evas_object_move(edje, 0, 0);
evas_object_resize(edje, sz.width, sz.height);
evas_object_show(edje);
ecore_evas_show(ee);
ecore_main_loop_begin();
shutdown_efl();
return 0;
}
int
main(void)
{
Esql *e;
struct ctx ctx = {0, 0, 0};
ecore_init();
esql_init();
eina_log_domain_level_set("esskyuehl", EINA_LOG_LEVEL_DBG);
e = esql_new(ESQL_TYPE_SQLITE);
assert(e != NULL);
ecore_event_handler_add(ESQL_EVENT_CONNECT, on_connect, &ctx);
ecore_event_handler_add(ESQL_EVENT_ERROR, on_error, &ctx);
assert(esql_connect(e, ":memory:", NULL, NULL));
ecore_main_loop_begin();
esql_disconnect(e);
esql_shutdown();
ecore_shutdown();
assert(ctx.conns == 1);
assert(ctx.errors == 0);
assert(ctx.res == 2 + INSERTED_ROWS);
return 0;
}
int main(void) {
Evas_Object *o;
Ecore_Evas *ee;
int r;
evas_init();
ecore_init();
ecore_evas_init();
edje_init();
ee = ecore_evas_new(NULL, 0, 0, 320, 240, NULL);
if (!ee)
return -1;
o = edje_object_add(ecore_evas_get(ee));
if (!edje_object_file_set(o, "test.edj", "main")) {
fprintf(stderr, "could not load edje: %d\n",
edje_object_load_error_get(o));
return -2;
}
evas_object_resize(o, 320, 240);
evas_object_show(o);
ecore_evas_alpha_set(ee, 1);
ecore_evas_borderless_set(ee, 1);
ecore_evas_show(ee);
ecore_main_loop_begin();
return 0;
}
int main(int argc, char **argv)
{
Eon_Window *win;
Ender_Element *layout;
Eon_Backend *backend;
Ender_Element *e;
int i;
eon_init();
ecore_init();
//backend = eon_ecore_remote_new();
backend = eon_ecore_sdl_new();
layout = eon_stack_new();
win = eon_window_new(backend, layout, 320, 240);
eon_stack_orientation_set(layout, EON_STACK_ORIENTATION_VERTICAL);
e = eon_color_new();
eon_layout_child_add(layout, e);
e = eon_color_new();
eon_layout_child_add(layout, e);
ecore_main_loop_begin();
ecore_shutdown();
eon_shutdown();
return 0;
}
// return 0 for normal case
int daemonLoop(void)
{
int return_value = 0;
ecore_init();
if (init_input_events() == -1) {
return_value = -1;
goto END_EVENT;
}
if (!initialize_events()) {
return_value = -1;
goto END_EFD;
}
if (launch_timer_start() < 0) {
LOGE("Launch timer start failed\n");
return_value = -1;
goto END_EFD;
}
init_prof_session(&prof_session);
ecore_main_loop_begin();
ecore_shutdown();
END_EFD:
LOGI("close efd\n");
close(manager.efd);
END_EVENT:
return return_value;
}
/* externally accessible functions */
int
main(int argc,
char **argv)
{
int i;
for (i = 1; i < argc; i++)
{
if ((!strcmp(argv[i], "-h")) ||
(!strcmp(argv[i], "-help")) ||
(!strcmp(argv[i], "--help")))
{
printf(
"This is an internal tool for Enlightenment.\n"
"do not use it.\n"
);
exit(0);
}
else if (!strncmp(argv[i], "--nice=", 7))
{
const char *val;
int ret = 0;
val = argv[i] + 7;
if (*val)
ret = nice(atoi(val));
}
}
ecore_init();
ecore_app_args_set(argc, (const char **)argv);
eet_init();
evas_init();
ecore_evas_init();
edje_init();
ecore_file_init();
ecore_ipc_init();
e_user_dir_concat_static(_thumbdir, "fileman/thumbnails");
ecore_file_mkpath(_thumbdir);
if (_e_ipc_init()) ecore_main_loop_begin();
if (_e_ipc_server)
{
ecore_ipc_server_del(_e_ipc_server);
_e_ipc_server = NULL;
}
ecore_ipc_shutdown();
ecore_file_shutdown();
ecore_evas_shutdown();
edje_shutdown();
evas_shutdown();
eet_shutdown();
ecore_shutdown();
return 0;
}
/**
* @brief Runs the Etk's main loop until etk_main_quit() is called.
* @note It calls ecore_main_loop_begin() so you should not call ecore_main_loop_begin() or ecore_main_loop_quit()
* if you are using etk_main() in your program.
*/
void etk_main(void)
{
if (_etk_main_init_count <= 0 || _etk_main_running)
return;
_etk_main_running = ETK_TRUE;
ecore_main_loop_begin();
}
int
main(int argc, char **argv)
{
ecore_init();
ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, _quitter, NULL);
ecore_main_loop_begin();
return 0;
}
/**
* @return Returns no value.
* @brief The main execution loop of EWL
*
* This is the main execution loop of ewl. It dispatches
* incoming events and renders updates to the evas's used by ewl.
*/
void
ewl_main(void)
{
DENTER_FUNCTION(DLEVEL_STABLE);
ecore_main_loop_begin();
ewl_shutdown();
DLEAVE_FUNCTION(DLEVEL_STABLE);
}
int
main (void)
{
/* credentials */
gnutls_anon_client_credentials_t c_anoncred;
gnutls_certificate_credentials_t c_certcred;
gnutls_session_t client;
int sd, i;
/* General init. */
gnutls_global_init ();
ecore_init();
// gnutls_global_set_log_function (tls_log_func);
// gnutls_global_set_log_level (2);
/* Init client */
gnutls_anon_allocate_client_credentials (&c_anoncred);
gnutls_certificate_allocate_credentials (&c_certcred);
for (i=0;i<5;i++)
{
gnutls_init (&client, GNUTLS_CLIENT);
/* set very specific priorities */
gnutls_priority_set_direct(client, "NORMAL:+ANON-DH", NULL);
gnutls_credentials_set (client, GNUTLS_CRD_ANON, c_anoncred);
gnutls_credentials_set (client, GNUTLS_CRD_CERTIFICATE, c_certcred);
gnutls_server_name_set(client, GNUTLS_NAME_DNS, "localhost", strlen("localhost"));
/* connect to the peer
*/
sd = tcp_connect ();
/* associate gnutls with socket */
gnutls_transport_set_ptr (client, (gnutls_transport_ptr_t) sd);
/* add a callback for data being available for send/receive on socket */
if (!ecore_main_fd_handler_add(sd, ECORE_FD_READ | ECORE_FD_WRITE, (Ecore_Fd_Cb)_process_data, client, NULL, NULL))
{
print("could not create fd handler!");
exit(1);
}
/* begin main loop */
ecore_main_loop_begin();
gnutls_bye (client, GNUTLS_SHUT_RDWR);
gnutls_deinit (client);
tcp_close (sd);
}
return 0;
}
int
main(int argc, char **argv)
{
ecore_init();
timer1 = ecore_timer_add(5.0, timer1_tick, data1);
fprintf(stdout, "This is an output message from the main function.\n");
fprintf(stderr, "This is an error message from the main function.\n");
ecore_main_loop_begin();
ecore_shutdown();
return 123;
}
int
main(int argc, char *argv[])
{
GstElement *pipeline;
char *filename;
Ecore_Pipe *pipe;
gst_init(&argc, &argv);
if (!ecore_init())
{
gst_deinit();
return 0;
}
pipe = ecore_pipe_add(handler);
if (!pipe)
{
ecore_shutdown();
gst_deinit();
return 0;
}
if (argc < 2)
{
g_print("usage: %s file.avi\n", argv[0]);
ecore_pipe_del(pipe);
ecore_shutdown();
gst_deinit();
return 0;
}
filename = argv[1];
pipeline = _buid_pipeline(filename, pipe);
if (!pipeline)
{
g_print("Error during the pipeline building\n");
ecore_pipe_del(pipe);
ecore_shutdown();
gst_deinit();
return -1;
}
gst_element_set_state(pipeline, GST_STATE_PLAYING);
ecore_main_loop_begin();
ecore_pipe_del(pipe);
ecore_shutdown();
gst_deinit();
return 0;
}
void TestController::platformRunUntil(bool& condition, double timeout)
{
if (timeout == m_noTimeout) {
// Never timeout if we are debugging or not meant to timeout.
while (!condition)
ecore_main_loop_iterate();
return;
}
timer = ecore_timer_loop_add(timeout, timerFired, 0);
ecore_main_loop_begin();
}
int main(int argc, const char **argv)
{
Ecore_X_Window win;
ecore_init();
ecore_app_args_set(argc, argv);
if (!ecore_evas_init())
return -1;
ee = ecore_evas_software_x11_new(NULL, 0, 0, 0, win_w, win_h);
if (!ee)
return 1;
win = ecore_evas_software_x11_window_get(ee);
ecore_evas_title_set(ee, "Etox Selection Test");
ecore_evas_show(ee);
/* setup callbacks for events */
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_MOVE, e_mouse_move, NULL);
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_BUTTON_DOWN, e_mouse_down,
NULL);
ecore_event_handler_add(ECORE_X_EVENT_MOUSE_BUTTON_UP, e_mouse_up,
NULL);
ecore_event_handler_add(ECORE_EVENT_SIGNAL_EXIT, sig_exit, NULL);
evas = ecore_evas_get(ee);
evas_font_path_append(evas, FONT_DIRECTORY);
/* program does its data setup here */
setup();
ecore_evas_callback_resize_set(ee, window_resize);
/* and now loop forever handling events */
ecore_main_loop_begin();
evas_object_del(e_msg);
evas_object_del(e_test);
while (pbuttons) {
panel_button_free(pbuttons->data);
pbuttons = eina_list_remove(pbuttons, pbuttons->data);
}
evas_free(evas);
return 0;
argc = 0;
argv = NULL;
}
int main(int argc, char **argv)
{
eina_init();
ecore_init();
e_mod_gauche_init("./test-main.scm");
ecore_x_init(NULL);
printf("start\n");
ecore_main_loop_begin();
return 0;
}
int
main (void)
{
/* credentials */
gnutls_anon_client_credentials_t c_anoncred;
gnutls_certificate_credentials_t c_certcred;
gnutls_session_t client;
int sd;
/* General init. */
gnutls_global_init ();
ecore_init();
gnutls_global_set_log_function (tls_log_func);
gnutls_global_set_log_level (6);
/* Init client */
gnutls_anon_allocate_client_credentials (&c_anoncred);
gnutls_certificate_allocate_credentials (&c_certcred);
gnutls_init (&client, GNUTLS_CLIENT);
/* set very specific priorities */
gnutls_priority_set_direct(client, "NONE:%VERIFY_ALLOW_X509_V1_CA_CRT:+RSA:+DHE-RSA:+DHE-DSS:+ANON-DH:+COMP-DEFLATE:+COMP-NULL:+CTYPE-X509:+SHA1:+SHA256:+SHA384:+SHA512:+AES-256-CBC:+AES-128-CBC:+3DES-CBC:+VERS-TLS1.2:+VERS-TLS1.1:+VERS-TLS1.0:+VERS-SSL3.0", NULL);
gnutls_credentials_set (client, GNUTLS_CRD_ANON, c_anoncred);
gnutls_credentials_set (client, GNUTLS_CRD_CERTIFICATE, c_certcred);
gnutls_server_name_set(client, GNUTLS_NAME_DNS, "www.verisign.com", strlen("www.verisign.com"));
/* connect to the peer
*/
sd = tcp_connect ();
/* associate gnutls with socket */
gnutls_transport_set_ptr (client, (gnutls_transport_ptr_t) sd);
/* add a callback for data being available for send/receive on socket */
if (!ecore_main_fd_handler_add(sd, ECORE_FD_READ | ECORE_FD_WRITE, (Ecore_Fd_Cb)_process_data, client, NULL, NULL))
{
print("could not create fd handler!");
exit(1);
}
/* begin main loop */
ecore_main_loop_begin();
gnutls_bye (client, GNUTLS_SHUT_RDWR);
gnutls_deinit (client);
tcp_close (sd);
return 0;
}
