Main::~Main()
{
// Remove any watchers
for (EcoreFdHandlerList::iterator iterator = m_readWatchersList.begin(); iterator != m_readWatchersList.end(); ++iterator)
ecore_main_fd_handler_del(*iterator);
m_readWatchersList.clear();
for (EcoreFdHandlerList::iterator iterator = m_writeWatchersList.begin(); iterator != m_writeWatchersList.end(); ++iterator)
ecore_main_fd_handler_del(*iterator);
m_writeWatchersList.clear();
// Remove event invoker
ecore_main_fd_handler_del(m_invokerHandler);
m_invokerHandler = NULL;
//set old ecore select function, because after ecore_shutdown() call,
//it is being called once again and it may crash.
ecore_main_loop_select_func_set(m_oldEcoreSelect);
// Decrement ECORE init count
// We do not need ecore routines any more
ecore_shutdown();
// Late EFL event handling
Assert(g_lateMain == this);
g_lateMain = NULL;
}
SH_API int _read_stdin_entry(void *data, Ecore_Fd_Handler *fd_handler)
{
char *buffer;
char *s;
char c;
int i = 0;
Evas_Object *obj = data;
if (!_stdin_prepare(fd_handler)) return 0;
// allocate initial buffer
buffer = malloc(sizeof(char));
// get the buffer
do {
c = getc(stdin);
buffer[i] = c;
buffer = realloc(buffer, i + sizeof(buffer));
i++;
} while (c != EOF);
// terminate the string.
buffer[i - 1] = '\0';
// add into entry, but before convert to html markup
s = elm_entry_utf8_to_markup(buffer);
elm_entry_entry_set(obj, s);
// free the the pointers, delete handler when we don't need it
E_FREE(buffer);
E_FREE(s);
ecore_main_fd_handler_del(fd_handler);
return 0;
}
/**
* @brief Disconnect from the currently connected server
* This function calls all necessary functions to cleanly disconnect from the server
* previously connected to by @p e.
* @note Disconnecting is immediate, but an ESQL_EVENT_DISCONNECT is still emitted.
* @param e The #Esql object (NOT NULL)
*/
void
esql_disconnect(Esql *e)
{
DBG("(e=%p)", e);
EINA_SAFETY_ON_NULL_RETURN(e);
if (e->pool)
{
esql_pool_disconnect((Esql_Pool *)e);
return;
}
EINA_SAFETY_ON_NULL_RETURN(e->backend.db);
e->backend.disconnect(e);
if (e->fdh) ecore_main_fd_handler_del(e->fdh);
e->fdh = NULL;
if (e->connected)
{
if (e->pool_member)
e->pool_struct->e_connected--;
if ((!e->pool_member) || (!e->pool_struct->e_connected))
{
INFO("Disconnected");
if (e->pool_member)
ecore_event_add(ESQL_EVENT_DISCONNECT, e->pool_struct, (Ecore_End_Cb)esql_fake_free, NULL);
else
ecore_event_add(ESQL_EVENT_DISCONNECT, e, (Ecore_End_Cb)esql_fake_free, NULL);
e->event_count++;
}
}
e->connected = EINA_FALSE;
}
static int target_event_stop_handler(struct target *target)
{
int cnt;
enum app_type_t app_type = target->app_type;
LOGI("target[%p] close, pid(%d) : (remaining %d target)\n",
target, target_get_pid(target), target_cnt_get() - 1);
ecore_main_fd_handler_del(target->handler);
target_wait(target);
target_dtor(target);
// all target client are closed
cnt = target_cnt_sub_and_fetch();
if (0 == cnt) {
switch (app_type) {
case APP_TYPE_TIZEN:
case APP_TYPE_COMMON:
LOGI("all targets are stopped\n");
if (stop_all() != ERR_NO)
LOGE("Stop failed\n");
return -11;
}
}
return 0;
}
static void
_ecore_con_dns_free(Ecore_Con_DNS *dns)
{
if (dns->svr->infos) dns->svr->infos = eina_list_remove(dns->svr->infos, dns);
if (dns->timer) ecore_timer_del(dns->timer);
if (dns->fdh) ecore_main_fd_handler_del(dns->fdh);
dns_res_close(dns_res_mortal(dns->resolv));
free(dns);
}
EAPI void
ecore_fb_ts_shutdown(void)
{
if (_ecore_fb_ts_fd_handler_handle)
ecore_main_fd_handler_del(_ecore_fb_ts_fd_handler_handle);
if (_ecore_fb_ts_fd >= 0) close(_ecore_fb_ts_fd);
_ecore_fb_ts_fd = -1;
_ecore_fb_ts_fd_handler_handle = NULL;
}
/**
* Destroys a Ecore_Con_Url connection object.
*
* @ingroup Ecore_Con_Url_Group
*
* @see ecore_con_url_new()
*/
EAPI void
ecore_con_url_destroy(Ecore_Con_Url *url_con)
{
#ifdef HAVE_CURL
char *s;
if (!url_con) return;
if (!ECORE_MAGIC_CHECK(url_con, ECORE_MAGIC_CON_URL))
{
ECORE_MAGIC_FAIL(url_con, ECORE_MAGIC_CON_URL, "ecore_con_url_destroy");
return;
}
ECORE_MAGIC_SET(url_con, ECORE_MAGIC_NONE);
if(url_con->fd != -1)
{
FD_CLR(url_con->fd, &_current_fd_set);
if (url_con->fd_handler)
ecore_main_fd_handler_del(url_con->fd_handler);
url_con->fd = -1;
url_con->fd_handler = NULL;
}
if (url_con->post)
curl_formfree(url_con->post);
url_con->post = NULL;
if (url_con->curl_easy)
{
// FIXME: For an unknown reason, progress continue to arrive after destruction
// this prevent any further call to the callback.
curl_easy_setopt(url_con->curl_easy, CURLOPT_PROGRESSFUNCTION, NULL);
if (url_con->active)
{
url_con->active = 0;
curl_multi_remove_handle(curlm, url_con->curl_easy);
}
curl_easy_cleanup(url_con->curl_easy);
}
_url_con_list = eina_list_remove(_url_con_list, url_con);
curl_slist_free_all(url_con->headers);
EINA_LIST_FREE(url_con->additional_headers, s)
free(s);
EINA_LIST_FREE(url_con->response_headers, s)
free(s);
free(url_con->url);
free(url_con);
#else
return;
url_con = NULL;
#endif
}
static void
_ecore_con_info_slave_free(CB_Data *cbdata)
{
info_slaves = (CB_Data *)eina_inlist_remove(EINA_INLIST_GET(info_slaves),
EINA_INLIST_GET(cbdata));
ecore_main_fd_handler_del(cbdata->fdh);
ecore_event_handler_del(cbdata->handler);
close(ecore_main_fd_handler_fd_get(cbdata->fdh));
if (cbdata->data) ecore_con_server_infos_del(cbdata->data, cbdata);
free(cbdata);
}
CalaosEcoreFdHandler::~CalaosEcoreFdHandler()
{
//disconnect the sigc slot
if (!fdhandler_data)
connection.disconnect();
else
connection_data.disconnect();
//delete the ecore fdhandler
if (fdhandler) ecore_main_fd_handler_del(fdhandler);
}
/**
* Close the read end of an Ecore_Pipe object created with ecore_pipe_add().
*
* @param p The Ecore_Pipe object.
* @ingroup Ecore_Pipe_Group
*/
EAPI void ecore_pipe_read_close(Ecore_Pipe * p)
{
if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE)) {
ECORE_MAGIC_FAIL(p, ECORE_MAGIC_PIPE,
"ecore_pipe_read_close");
return;
}
ecore_main_fd_handler_del(p->fd_handler);
p->fd_handler = NULL;
pipe_close(p->fd_read);
p->fd_read = PIPE_FD_INVALID;
}
static void
module_shutdown(Enna_Module *em)
{
#if 0
enna_config_panel_unregister(_config_panel);
#endif
if (mod->fd_handler)
{
lirc_freeconfig(mod->lirc_config);
ecore_main_fd_handler_del(mod->fd_handler);
lirc_deinit();
}
}
static void watch_handler_free(void *data)
{
struct watch_handler *io_handler = data;
if (io_handler == NULL)
return;
if (io_handler->e_handler != NULL)
ecore_main_fd_handler_del(io_handler->e_handler);
dbus_connection_unref(io_handler->dbus_cnx);
free(io_handler);
}
static int
em_shutdown(void *ef)
{
Emotion_Xine_Video *ev;
ev = (Emotion_Xine_Video *)ef;
ev->closing = 1;
ev->delete_me = 1;
DBG("del fds %p", ev);
ecore_main_fd_handler_del(ev->fd_handler);
ev->fd_handler = NULL;
ecore_main_fd_handler_del(ev->fd_ev_handler);
ev->fd_ev_handler = NULL;
if (ev->anim)
{
ecore_animator_del(ev->anim);
ev->anim = NULL;
}
ev->closing = 1;
_em_slave_event(ev, 3, NULL);
DBG("done %p", ev);
return 1;
}
static int
_mixer_callback_del(E_Mixer_System *self,
struct e_mixer_callback_desc *desc)
{
Ecore_Fd_Handler *handler;
EINA_LIST_FREE(desc->handlers, handler)
ecore_main_fd_handler_del(handler);
snd_mixer_set_callback_private(self, NULL);
memset(desc, 0, sizeof(*desc));
free(desc);
return 1;
}
int
ecore_file_monitor_inotify_shutdown(void)
{
int fd;
while(_monitors)
ecore_file_monitor_inotify_del(_monitors);
if (_fdh)
{
fd = ecore_main_fd_handler_fd_get(_fdh);
ecore_main_fd_handler_del(_fdh);
close(fd);
}
return 1;
}
/**
* Free an Ecore_Pipe object created with ecore_pipe_add().
*
* @param p The Ecore_Pipe object to be freed.
* @return The pointer to the private data
* @ingroup Ecore_Pipe_Group
*/
EAPI void *ecore_pipe_del(Ecore_Pipe * p)
{
void *data;
if (!ECORE_MAGIC_CHECK(p, ECORE_MAGIC_PIPE)) {
ECORE_MAGIC_FAIL(p, ECORE_MAGIC_PIPE, "ecore_pipe_del");
return NULL;
}
if (p->fd_handler)
ecore_main_fd_handler_del(p->fd_handler);
if (p->fd_read != PIPE_FD_INVALID)
pipe_close(p->fd_read);
if (p->fd_write != PIPE_FD_INVALID)
pipe_close(p->fd_write);
data = (void *) p->data;
free(p);
return data;
}
static Eina_Bool host_data_cb(void *data, Ecore_Fd_Handler *fd_handler)
{
ssize_t recvLen;
char recvBuf[32];
recvLen = recv(manager.host.data_socket, recvBuf, 32, MSG_DONTWAIT);
if (recvLen == 0) {
// close data socket
ecore_main_fd_handler_del(host_data_handler);
close(manager.host.data_socket);
manager.host.data_socket = -1;
// TODO: finish transfer thread
}
LOGI("host message from data socket %d\n", recvLen);
return ECORE_CALLBACK_RENEW;
}
//stop application launch timer
static int stop_app_launch_timer()
{
int res = 0;
launch_timer_lock();
if (manager.app_launch_timerfd > 0) {
ecore_main_fd_handler_del(launch_timer_handler);
if (close(manager.app_launch_timerfd)) {
LOGE("close app_launch_timerfd failed\n");
res = 1;
}
manager.app_launch_timerfd = -1;
} else {
LOGW("trying to stop app launch timer when it stoped\n");
}
launch_timer_unlock();
return res;
}
/**
* @brief Disconnect from the currently connected server
* This function calls all necessary functions to cleanly disconnect from the server
* previously connected to by @p e.
* @note Disconnecting is immediate, but an ESQL_EVENT_DISCONNECT is still emitted.
* @param e The #Esql object (NOT NULL)
*/
void
esql_disconnect(Esql *e)
{
DBG("(e=%p)", e);
EINA_SAFETY_ON_NULL_RETURN(e);
e->connected = EINA_FALSE;
if (e->pool)
{
esql_pool_disconnect((Esql_Pool *)e);
return;
}
EINA_SAFETY_ON_NULL_RETURN(e->backend.db);
e->backend.disconnect(e);
if (e->fdh) ecore_main_fd_handler_del(e->fdh);
e->fdh = NULL;
INFO("Disconnected");
ecore_event_add(ESQL_EVENT_DISCONNECT, e, (Ecore_End_Cb)esql_fake_free, NULL);
}
SH_API Eina_Bool _read_stdin_list(void *data, Ecore_Fd_Handler *fd_handler)
{
char **splitted;
char *buffer;
char c;
int i = 0;
int len = 0;
Evas_Object *obj = data;
if (!_stdin_prepare(fd_handler)) return 0;
// allocate initial buffer
buffer = malloc(sizeof(char));
// get the buffer
do {
c = getc(stdin);
buffer[i] = c;
buffer = realloc(buffer, i + sizeof(buffer));
i++;
} while (c != EOF);
// terminate the string.
buffer[i - 1] = '\0';
// split and append
splitted = eina_str_split_full(buffer, "\n", 0, &len);
for (i = 0; i < len; i++)
elm_list_item_append(obj, splitted[i], NULL, NULL, NULL, NULL);
elm_object_item_del(eina_list_data_get(eina_list_last(elm_list_items_get(obj))));
elm_list_go(obj);
// free the the pointers, delete handler when we don't need it
E_FREE(splitted);
E_FREE(buffer);
ecore_main_fd_handler_del(fd_handler);
return 0;
}
static int
_ecore_con_url_suspend_fd_handler(void)
{
Eina_List *l;
Ecore_Con_Url *url_con;
int deleted = 0;
if (!_url_con_list) return 0;
EINA_LIST_FOREACH(_url_con_list, l, url_con)
{
if (url_con->active && url_con->fd_handler)
{
ecore_main_fd_handler_del(url_con->fd_handler);
url_con->fd_handler = NULL;
deleted++;
}
}
return deleted;
}
EAPI int
ecore_con_url_shutdown(void)
{
Ecore_Con_Url *url_con;
Ecore_Fd_Handler *fd_handler;
if (_init_count == 0) return 0;
--_init_count;
if (_init_count) return _init_count;
if (_curl_timer)
{
ecore_timer_del(_curl_timer);
_curl_timer = NULL;
}
EINA_LIST_FREE(_url_con_list, url_con)
ecore_con_url_free(url_con);
EINA_LIST_FREE(_fd_hd_list, fd_handler)
ecore_main_fd_handler_del(fd_handler);
_c_shutdown();
ecore_shutdown();
return 0;
}
/**
* Deletes a watch.
*
* @param watch An Eeze_Udev_Watch object
* @return The data originally associated with the watch, or NULL
*
* Deletes a watch, closing file descriptors and freeing related udev memory.
*/
EAPI void *
eeze_udev_watch_del(Eeze_Udev_Watch *watch)
{
struct _store_data *sdata;
void *ret = NULL;
if ((!watch) || (!watch->mon) || (!watch->handler))
return NULL;
sdata = ecore_main_fd_handler_del(watch->handler);
udev_monitor_unref(watch->mon);
if (sdata)
{
ret = sdata->data;
free(sdata);
}
free(watch);
return ret;
}
static void
_joystick_unregister(const char *syspath)
{
int fd;
Eina_List *l, *l2;
Joystick_Info *ji;
EINA_LIST_FOREACH_SAFE(joystick_list, l, l2, ji)
{
if (syspath == ji->system_path)
{
fd = ecore_main_fd_handler_fd_get(ji->fd_handler);
if (fd < 0) continue;
close(fd);
ecore_main_fd_handler_del(ji->fd_handler);
joystick_list = eina_list_remove(joystick_list, ji);
_joystick_connected_event_add(ji->index, EINA_FALSE);
eina_stringshare_del(ji->system_path);
free(ji);
break;
}
}
}
static Eina_Bool
_cb_exe_exit(void *data, int type EINA_UNUSED, void *event)
{
Ecore_Exe_Event_Del *ev = event;
Termpty *ty = data;
if (ev->pid != ty->pid) return ECORE_CALLBACK_PASS_ON;
ty->exit_code = ev->exit_code;
ty->pid = -1;
if (ty->hand_exe_exit) ecore_event_handler_del(ty->hand_exe_exit);
ty->hand_exe_exit = NULL;
if (ty->hand_fd) ecore_main_fd_handler_del(ty->hand_fd);
ty->hand_fd = NULL;
if (ty->fd >= 0) close(ty->fd);
ty->fd = -1;
if (ty->slavefd >= 0) close(ty->slavefd);
ty->slavefd = -1;
if (ty->cb.exited.func) ty->cb.exited.func(ty->cb.exited.data);
return ECORE_CALLBACK_PASS_ON;
}
static void
_ecore_pa_io_free(pa_io_event *event)
{
ecore_main_fd_handler_del(event->handler);
free(event);
}
EAPI int
ecore_con_info_get(Ecore_Con_Server *svr,
Ecore_Con_Info_Cb done_cb,
void *data,
struct addrinfo *hints)
{
CB_Data *cbdata;
int fd[2];
if (pipe(fd) < 0)
{
ecore_con_event_server_error(svr, strerror(errno));
return 0;
}
_ecore_con_fd_close_on_exec(fd[0]);
_ecore_con_fd_close_on_exec(fd[1]);
cbdata = calloc(1, sizeof(CB_Data));
if (!cbdata)
{
close(fd[0]);
close(fd[1]);
return 0;
}
cbdata->cb_done = done_cb;
cbdata->data = data;
cbdata->fd2 = fd[1];
if (!(cbdata->fdh = ecore_main_fd_handler_add(fd[0], ECORE_FD_READ,
_ecore_con_info_data_handler,
cbdata,
NULL, NULL)))
{
ecore_con_event_server_error(svr, "Memory allocation failure");
free(cbdata);
close(fd[0]);
close(fd[1]);
return 0;
}
if ((cbdata->pid = fork()) == 0)
{
Ecore_Con_Info *container;
struct addrinfo *result = NULL;
char service[NI_MAXSERV] = {0};
char hbuf[NI_MAXHOST] = {0};
char sbuf[NI_MAXSERV] = {0};
unsigned char *tosend = NULL;
int tosend_len;
int canonname_len = 0;
eina_convert_itoa(svr->ecs ? svr->ecs->port : svr->port, service);
/* CHILD */
if (!getaddrinfo(svr->ecs ? svr->ecs->ip : svr->name, service, hints, &result) && result)
{
if (result->ai_canonname)
canonname_len = strlen(result->ai_canonname) + 1;
tosend_len = sizeof(Ecore_Con_Info) + result->ai_addrlen +
canonname_len;
tosend = alloca(tosend_len);
memset(tosend, 0, tosend_len);
container = (Ecore_Con_Info *)tosend;
container->size = tosend_len;
memcpy(&container->info,
result,
sizeof(struct addrinfo));
memcpy(tosend + sizeof(Ecore_Con_Info),
result->ai_addr,
result->ai_addrlen);
if (result->ai_canonname) /* FIXME: else... */
memcpy(tosend + sizeof(Ecore_Con_Info) + result->ai_addrlen,
result->ai_canonname,
canonname_len);
if (!getnameinfo(result->ai_addr, result->ai_addrlen,
hbuf, sizeof(hbuf), sbuf, sizeof(sbuf),
NI_NUMERICHOST | NI_NUMERICSERV))
{
memcpy(container->ip, hbuf, sizeof(container->ip));
memcpy(container->service, sbuf, sizeof(container->service));
}
if (write(fd[1], tosend, tosend_len) < 0) perror("write");
}
if (result)
freeaddrinfo(result);
if (write(fd[1], "", 1) < 0) perror("write");
close(fd[1]);
#if defined(__USE_ISOC99) && !defined(__UCLIBC__)
_Exit(0);
#else
_exit(0);
#endif
}
/* PARENT */
cbdata->handler =
ecore_event_handler_add(ECORE_EXE_EVENT_DEL, _ecore_con_info_exit_handler,
cbdata);
close(fd[1]);
if (!cbdata->handler)
{
ecore_main_fd_handler_del(cbdata->fdh);
free(cbdata);
close(fd[0]);
return 0;
}
info_slaves = (CB_Data *)eina_inlist_append(EINA_INLIST_GET(
info_slaves),
EINA_INLIST_GET(cbdata));
svr->infos = eina_list_append(svr->infos, cbdata);
return 1;
}
static int
_ecore_con_url_perform(Ecore_Con_Url *url_con)
{
fd_set read_set, write_set, exc_set;
int fd_max, fd;
int flags, still_running;
int completed_immediately = 0;
_url_con_list = eina_list_append(_url_con_list, url_con);
url_con->active = 1;
curl_multi_add_handle(curlm, url_con->curl_easy);
/* This one can't be stopped, or the download never start. */
while (curl_multi_perform(curlm, &still_running) == CURLM_CALL_MULTI_PERFORM);
completed_immediately = _ecore_con_url_process_completed_jobs(url_con);
if (!completed_immediately)
{
if (url_con->fd_handler)
ecore_main_fd_handler_del(url_con->fd_handler);
url_con->fd_handler = NULL;
/* url_con still active -- set up an fd_handler */
FD_ZERO(&read_set);
FD_ZERO(&write_set);
FD_ZERO(&exc_set);
/* Stupid curl, why can't I get the fd to the current added job? */
curl_multi_fdset(curlm, &read_set, &write_set, &exc_set, &fd_max);
for (fd = 0; fd <= fd_max; fd++)
{
if (!FD_ISSET(fd, &_current_fd_set))
{
flags = 0;
if (FD_ISSET(fd, &read_set)) flags |= ECORE_FD_READ;
if (FD_ISSET(fd, &write_set)) flags |= ECORE_FD_WRITE;
if (FD_ISSET(fd, &exc_set)) flags |= ECORE_FD_ERROR;
if (flags)
{
long ms = 0;
curl_multi_timeout(curlm, &ms);
if (ms == 0) ms = 1000;
FD_SET(fd, &_current_fd_set);
url_con->fd = fd;
url_con->flags = flags;
url_con->fd_handler =
ecore_main_fd_handler_add(fd, flags,
_ecore_con_url_fd_handler,
NULL, NULL, NULL);
break;
}
}
}
if (!url_con->fd_handler)
{
/* Failed to set up an fd_handler */
ecore_timer_freeze(_curl_timeout);
curl_multi_remove_handle(curlm, url_con->curl_easy);
url_con->active = 0;
url_con->fd = -1;
return 0;
}
ecore_timer_thaw(_curl_timeout);
}
return 1;
}
static int
_ecore_con_dns_check(Ecore_Con_DNS *dns)
{
struct addrinfo *ent = NULL;
int error = 0;
error = dns_ai_nextent(&ent, dns->ai);
switch (error)
{
case 0:
break;
case EAGAIN:
return 1;
default:
ERR("resolve failed: %s", dns_strerror(error));
goto error;
}
{
Ecore_Con_Info result = {0, .ip = {0}, .service = {0}};
#if 0
char pretty[512];
dns_ai_print(pretty, sizeof(pretty), ent, dns->ai);
printf("%s\n", pretty);
#endif
result.size = 0;
dns_inet_ntop(dns_sa_family(ent->ai_addr), dns_sa_addr(dns_sa_family(ent->ai_addr), ent->ai_addr), result.ip, sizeof(result.ip));
snprintf(result.service, sizeof(result.service), "%u", ntohs(*dns_sa_port(dns_sa_family(ent->ai_addr), ent->ai_addr)));
memcpy(&result.info, ent, sizeof(result.info));
if (dns->fdh) ecore_main_fd_handler_del(dns->fdh);
dns->fdh = NULL;
dns->done_cb(dns->data, &result);
free(ent);
_ecore_con_dns_free(dns);
}
return 0;
error:
dns->done_cb(dns->data, NULL);
_ecore_con_dns_free(dns);
return -1;
}
static Eina_Bool
_dns_fd_cb(Ecore_Con_DNS *dns, Ecore_Fd_Handler *fdh __UNUSED__)
{
if (_ecore_con_dns_check(dns) != 1) return ECORE_CALLBACK_RENEW;
if (ecore_main_fd_handler_fd_get(dns->fdh) != dns_ai_pollfd(dns->ai))
{
ecore_main_fd_handler_del(dns->fdh);
dns->fdh = ecore_main_fd_handler_add(dns_ai_pollfd(dns->ai), dns_ai_events(dns->ai), (Ecore_Fd_Cb)_dns_fd_cb, dns, NULL, NULL);
}
else
ecore_main_fd_handler_active_set(dns->fdh, dns_ai_events(dns->ai));
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_dns_timer_cb(Ecore_Con_DNS *dns)
{
dns->done_cb(dns->data, NULL);
_ecore_con_dns_free(dns);
dns->timer = NULL;
return EINA_FALSE;
}
/**
* return 0 if normal case
* return plus value if non critical error occur
* return minus value if critical error occur
*/
static int targetServerHandler(void)
{
int err;
struct msg_target_t log;
struct target *target;
target = target_ctor();
if (target == NULL) {
LOGW("(target == NULL) no more target can connected\n");
return 1;
}
err = target_accept(target, manager.target_server_socket);
if (err == 0) {
/* send config message to target process */
log.type = MSG_OPTION;
log.length = snprintf(log.data, sizeof(log.data), "%llu",
prof_session.conf.use_features0) + 1;
if (target_send_msg(target, &log) != 0)
LOGE("fail to send data to target %p\n", target);
/* send current instrument maps */
send_maps_inst_msg_to(target);
// make event fd
target->event_fd = eventfd(EFD_CLOEXEC, EFD_NONBLOCK);
if (target->event_fd == -1) {
// fail to make event fd
LOGE("fail to make event fd for target[%p]\n", target);
goto TARGET_CONNECT_FAIL;
}
target->handler =
ecore_main_fd_handler_add(target->event_fd,
ECORE_FD_READ,
target_event_cb,
(void *)target,
NULL, NULL);
if (!target->handler) {
LOGE("fail to add event fd for target[%p]\n", target);
goto TARGET_CONNECT_FAIL;
}
// make recv thread for target
if (makeRecvThread(target) != 0) {
// fail to make recv thread
LOGE("fail to make recv thread for target[%p]\n",
target);
ecore_main_fd_handler_del(target->handler);
goto TARGET_CONNECT_FAIL;
}
dec_apps_to_run();
if ((manager.app_launch_timerfd > 0) && (get_apps_to_run() == 0)) {
if (stop_app_launch_timer())
LOGE("cannot stop app launch timer\n");
}
LOGI("target connected target[%p](running %d target)\n",
target, target_cnt_get() + 1);
target_cnt_set(target_cnt_get() + 1);
return 0;
} else {
// accept error
LOGE("Failed to accept at target server socket\n");
}
TARGET_CONNECT_FAIL:
if (target_cnt_get() == 0) {
// if this connection is main connection
return -1;
} else {
// if this connection is not main connection then ignore process by error
target_dtor(target);
return 1;
}
}
