static Eina_Bool watch_handler_dispatch(void *data,
Ecore_Fd_Handler *e_handler)
{
struct watch_handler *io_handler = data;
DBusDispatchStatus status;
unsigned int flags = 0;
if (ecore_main_fd_handler_active_get(e_handler, ECORE_FD_ERROR)
== EINA_TRUE)
flags |= DBUS_WATCH_ERROR;
if (ecore_main_fd_handler_active_get(e_handler, ECORE_FD_READ)
== EINA_TRUE)
flags |= DBUS_WATCH_READABLE;
if (ecore_main_fd_handler_active_get(e_handler, ECORE_FD_WRITE)
== EINA_TRUE)
flags |= DBUS_WATCH_WRITABLE;
dbus_watch_handle(io_handler->watch, flags);
status = dbus_connection_get_dispatch_status(io_handler->dbus_cnx);
if (status == DBUS_DISPATCH_DATA_REMAINS)
ecore_timer_add(0, efl_dispatch_dbus, io_handler->dbus_cnx);
dbus_connection_unref(io_handler->dbus_cnx);
return TRUE;
}
static Eina_Bool
_ecore_io_wrapper(void *data, Ecore_Fd_Handler *handler)
{
char buf[64];
pa_io_event_flags_t flags = 0;
pa_io_event *event = (pa_io_event *)data;
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_READ))
{
flags |= PA_IO_EVENT_INPUT;
/* Check for HUP and report */
if (recv(ecore_main_fd_handler_fd_get(handler), buf, 64, MSG_PEEK))
{
if (errno == ESHUTDOWN || errno == ECONNRESET || errno == ECONNABORTED || errno == ENETRESET)
{
DBG("HUP condition detected");
flags |= PA_IO_EVENT_HANGUP;
}
}
}
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_WRITE))
flags |= PA_IO_EVENT_OUTPUT;
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_ERROR))
flags |= PA_IO_EVENT_ERROR;
event->callback(&event->mainloop->api, event, ecore_main_fd_handler_fd_get(handler), flags, event->userdata);
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool
_ecore_con_info_data_handler(void *data,
Ecore_Fd_Handler *fd_handler)
{
CB_Data *cbdata;
cbdata = data;
if (cbdata->cb_done)
{
if (ecore_main_fd_handler_active_get(fd_handler,
ECORE_FD_READ))
_ecore_con_info_readdata(cbdata);
else
{
if (cbdata->data)
{
cbdata->cb_done(cbdata->data, NULL);
cbdata->cb_done = NULL;
ecore_con_server_infos_del(cbdata->data, cbdata);
}
}
}
_ecore_con_info_slave_free(cbdata);
return ECORE_CALLBACK_CANCEL;
}
static Eina_Bool
_cb_fd_handler(void *data,
Ecore_Fd_Handler *fd_handler)
{
struct e_mixer_callback_desc *desc;
desc = data;
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_ERROR))
{
desc->handlers = eina_list_remove(desc->handlers, fd_handler);
if (!desc->handlers)
{
E_Mixer_System *s;
int (*f)(void *,
E_Mixer_System *);
void *d;
s = desc->self;
f = desc->func;
d = desc->data;
_mixer_callback_del(s, desc);
_mixer_callback_add(s, f, d);
}
return ECORE_CALLBACK_CANCEL;
}
if (!desc->idler)
desc->idler = ecore_idler_add(_cb_dispatch, desc);
return ECORE_CALLBACK_RENEW;
}
static int
on_fd_data (void *udata, Ecore_Fd_Handler *handler)
{
xmmsc_connection_t *c = udata;
int ret = 0;
if (ecore_main_fd_handler_active_get (handler, ECORE_FD_ERROR)) {
xmmsc_io_disconnect (c);
return ret;
}
if (ecore_main_fd_handler_active_get (handler, ECORE_FD_READ))
ret = xmmsc_io_in_handle (c);
if (ecore_main_fd_handler_active_get (handler, ECORE_FD_WRITE))
ret = xmmsc_io_out_handle (c);
return ret;
}
static Eina_Bool
_ecore_io_wrapper(void *data, Ecore_Fd_Handler *handler)
{
char buf[64];
pa_io_event_flags_t flags = 0;
pa_io_event *event = (pa_io_event *)data;
int fd = 0;
char *disp = NULL;
fd = ecore_main_fd_handler_fd_get(handler);
if (fd < 0) return ECORE_CALLBACK_RENEW;
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_READ))
{
flags |= PA_IO_EVENT_INPUT;
/* Check for HUP and report */
if (recv(fd, buf, 64, MSG_PEEK))
{
if (errno == ESHUTDOWN || errno == ECONNRESET || errno == ECONNABORTED || errno == ENETRESET)
{
DBG("HUP condition detected");
flags |= PA_IO_EVENT_HANGUP;
}
}
}
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_WRITE))
flags |= PA_IO_EVENT_OUTPUT;
if (ecore_main_fd_handler_active_get(handler, ECORE_FD_ERROR))
flags |= PA_IO_EVENT_ERROR;
if (getenv("WAYLAND_DISPLAY"))
{
disp = eina_strdup(getenv("DISPLAY"));
unsetenv("DISPLAY");
}
event->callback(event->mainloop, event, fd, flags, event->userdata);
if (disp) setenv("DISPLAY", disp, 1);
free(disp);
return ECORE_CALLBACK_RENEW;
}
static Eina_Bool _stdin_prepare(Ecore_Fd_Handler *fd_handler)
{
int flags;
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_ERROR))
{
perror(_("fd error, exit."));
ecore_main_loop_quit();
return EINA_FALSE;
}
else if (!ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ)) {
perror(_("nothing to read?"));
return EINA_FALSE;
}
// nonblocking :)
flags = fcntl(0, F_GETFL, 0);
flags |= O_NONBLOCK;
fcntl(0, F_SETFL, flags);
return EINA_TRUE;
}
static int custom_cb(void *data, Ecore_Fd_Handler * fd_handler)
{
int fd;
struct message_data *msg; //-------
PRT_ERR("[gandan] %s: socket data received\n", __FUNCTION__);
struct sockaddr_un client_address;
int client_sockfd;
int client_len;
if (!ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ)) {
PRT_TRACE_ERR
("ecore_main_fd_handler_active_get error , return\n");
return 1;
}
fd = ecore_main_fd_handler_fd_get(fd_handler);
msg = malloc(sizeof(struct message_data)); //-------
if (msg == NULL) {
PRT_TRACE_ERR("%s : Not enough memory", __FUNCTION__);
return 1;
}
client_len = sizeof(client_address);
client_sockfd = accept(fd, (struct sockaddr *)&client_address, (socklen_t *)&client_len);
if (client_sockfd == -1) {
PRT_TRACE_ERR("socket accept error");
free(msg);
return -1;
}
read_message(client_sockfd, msg);
PRT_ERR("[gandan] received data : %d\n", msg->val);
PRT_ERR("[gandan] %s: socket data receive end\n", __FUNCTION__);
free(msg);
return 1;
}
static Eina_Bool
fifo_input(void *data, Ecore_Fd_Handler *fd_handler)
{
char buf[4096], buf2[4096], *p, *q;
int size;
int fd;
fd = ecore_main_fd_handler_fd_get(fd_handler);
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ))
{
for (;;)
{
size = read(fd, buf, sizeof(buf) - 1);
if (size <= 0) break;
buf[size] = 0;
q = buf2;
for (p = buf; *p; p++)
{
if (*p == '\n')
{
*q = 0;
if (strlen(buf2) > 0) parse_cmd(buf2);
q = buf2;
}
else
{
*q = *p;
q++;
}
}
*q = 0;
if (strlen(buf2) > 0) parse_cmd(buf2);
}
}
return ECORE_CALLBACK_RENEW;
}
static int pmon_cb(void *data, Ecore_Fd_Handler * fd_handler)
{
int fd;
struct ss_main_data *ad = (struct ss_main_data *)data;
int dead_pid;
if (!ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ)) {
PRT_TRACE_ERR
("ecore_main_fd_handler_active_get error , return\n");
return 1;
}
fd = ecore_main_fd_handler_fd_get(fd_handler);
if ((read(fd, &dead_pid, sizeof(dead_pid))) < 0) {
PRT_TRACE_ERR("Reading DEAD_PID failed, Return");
return 1;
}
print_pmon_state(dead_pid);
pmon_process(dead_pid, ad);
return 1;
}
/* private function to further filter watch results based on Eeze_Udev_Type
* specified; helpful for new udev versions, but absolutely required for
* old udev, which does not implement filtering in device monitors.
*/
static Eina_Bool
_get_syspath_from_watch(void *data,
Ecore_Fd_Handler *fd_handler)
{
struct _store_data *store = data;
_udev_device *device = NULL, *parent, *tmpdev;
const char *ret, *test;
Eeze_Udev_Watch_Cb func = store->func;
void *sdata = store->data;
Eeze_Udev_Watch *watch = store->watch;
int event = 0;
if (!ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ))
return EINA_TRUE;
device = udev_monitor_receive_device(store->mon);
if (!device)
return EINA_TRUE;
if ((!(test = udev_device_get_action(device)))
|| (!(ret = udev_device_get_syspath(device))))
goto error;
if (store->event)
{
if (!strcmp(test, "add"))
{
if ((store->event != EEZE_UDEV_EVENT_NONE) &&
((store->event & EEZE_UDEV_EVENT_ADD) != EEZE_UDEV_EVENT_ADD))
goto error;
event |= EEZE_UDEV_EVENT_ADD;
}
else if (!strcmp(test, "remove"))
{
if ((store->event != EEZE_UDEV_EVENT_NONE) &&
((store->event & EEZE_UDEV_EVENT_REMOVE) != EEZE_UDEV_EVENT_REMOVE))
goto error;
event |= EEZE_UDEV_EVENT_REMOVE;
}
else if (!strcmp(test, "change"))
{
if ((store->event != EEZE_UDEV_EVENT_NONE) &&
((store->event & EEZE_UDEV_EVENT_CHANGE) != EEZE_UDEV_EVENT_CHANGE))
goto error;
event |= EEZE_UDEV_EVENT_CHANGE;
}
else if (!strcmp(test, "online"))
{
if ((store->event != EEZE_UDEV_EVENT_NONE) &&
((store->event & EEZE_UDEV_EVENT_ONLINE) != EEZE_UDEV_EVENT_ONLINE))
goto error;
event |= EEZE_UDEV_EVENT_ONLINE;
}
else
{
if ((store->event != EEZE_UDEV_EVENT_NONE) &&
((store->event & EEZE_UDEV_EVENT_OFFLINE) != EEZE_UDEV_EVENT_OFFLINE))
goto error;
event |= EEZE_UDEV_EVENT_OFFLINE;
}
}
if ((event & EEZE_UDEV_EVENT_OFFLINE) || (event & EEZE_UDEV_EVENT_REMOVE))
goto out;
switch (store->type)
{
case EEZE_UDEV_TYPE_KEYBOARD:
#ifdef OLD_UDEV_RRRRRRRRRRRRRR
if ((!(test = udev_device_get_subsystem(device)))
|| (strcmp(test, "input")))
goto error;
test = udev_device_get_property_value(device, "ID_CLASS");
if ((_walk_parents_test_attr(device, "bInterfaceProtocol", "01"))
|| ((test) && (!strcmp(test, "kbd"))))
break;
goto error;
#endif
if ((!udev_device_get_property_value(device, "ID_INPUT_KEYBOARD")) &&
(!udev_device_get_property_value(device, "ID_INPUT_KEY")))
goto error;
break;
case EEZE_UDEV_TYPE_MOUSE:
#ifdef OLD_UDEV_RRRRRRRRRRRRRR
if ((!(test = udev_device_get_subsystem(device)))
|| (strcmp(test, "input")))
goto error;
test = udev_device_get_property_value(device, "ID_CLASS");
if ((_walk_parents_test_attr(device, "bInterfaceProtocol", "02"))
|| ((test) && (!strcmp(test, "mouse"))))
break;
goto error;
#endif
if (!udev_device_get_property_value(device, "ID_INPUT_MOUSE"))
goto error;
break;
case EEZE_UDEV_TYPE_TOUCHPAD:
#ifdef OLD_UDEV_RRRRRRRRRRRRRR
if ((!(test = udev_device_get_subsystem(device)))
|| (strcmp(test, "input")))
goto error;
if (_walk_parents_test_attr(device, "resolution", NULL))
break;
goto error;
#endif
if (!udev_device_get_property_value(device, "ID_INPUT_TOUCHPAD"))
goto error;
break;
case EEZE_UDEV_TYPE_DRIVE_MOUNTABLE:
#ifdef OLD_UDEV_RRRRRRRRRRRRRR
if ((!(test = udev_device_get_subsystem(device)))
|| (strcmp(test, "block")))
goto error;
#endif
if (!(test = (udev_device_get_property_value(device, "ID_FS_USAGE"))) ||
(strcmp("filesystem", test)))
goto error;
{
int devcheck;
devcheck = open(udev_device_get_devnode(device), O_RDONLY);
if (devcheck < 0) goto error;
close(devcheck);
}
break;
case EEZE_UDEV_TYPE_DRIVE_INTERNAL:
if (udev_device_get_property_value(device, "ID_FS_USAGE")) goto error;
test = udev_device_get_sysattr_value(device, "removable");
if (test && test[0] == '1') goto error;
test = udev_device_get_property_value(device, "ID_BUS");
if ((!test) || strcmp(test, "ata")) goto error;
test = udev_device_get_property_value(device, "ID_TYPE");
if ((!test) || strcmp(test, "disk")) goto error;
break;
case EEZE_UDEV_TYPE_DRIVE_REMOVABLE:
if (udev_device_get_sysattr_value(device, "partition")) goto error;
test = udev_device_get_sysattr_value(device, "removable");
if ((!test) || (test[0] == '0')) goto error;
test = udev_device_get_property_value(device, "ID_TYPE");
if ((!test) || strcmp(test, "disk")) goto error;
break;
case EEZE_UDEV_TYPE_DRIVE_CDROM:
if (!udev_device_get_property_value(device, "ID_CDROM"))
goto error;
break;
case EEZE_UDEV_TYPE_POWER_AC:
#ifdef OLD_UDEV_RRRRRRRRRRRRRR
if ((!(test = udev_device_get_subsystem(device)))
|| (strcmp(test, "power_supply")))
goto error;
#endif
test = udev_device_get_property_value(device, "POWER_SUPPLY_ONLINE");
if (!test) goto error;
break;
case EEZE_UDEV_TYPE_POWER_BAT:
#ifdef OLD_UDEV_RRRRRRRRRRRRRR
if ((!(test = udev_device_get_subsystem(device)))
|| (strcmp(test, "power_supply")))
goto error;
#endif
test = udev_device_get_property_value(device, "POWER_SUPPLY_PRESENT");
if (!test) goto error;
break;
case EEZE_UDEV_TYPE_IS_IT_HOT_OR_IS_IT_COLD_SENSOR:
#ifdef OLD_UDEV_RRRRRRRRRRRRRR
if ((!(test = udev_device_get_subsystem(device)))
|| (strcmp(test, "hwmon")))
goto error;
#endif /* have to do stuff up here since we need info from the parent */
if (!_walk_parents_test_attr(device, "temp1_input", NULL))
goto error;
/* if device is not the one which has the temp input, we must go up the chain */
if (!udev_device_get_sysattr_value(device, "temp1_input"))
{
for (parent = udev_device_get_parent(device); parent; parent = udev_device_get_parent(parent)) /*check for parent */
if (udev_device_get_sysattr_value(parent, "temp1_input"))
{
tmpdev = device;
if (!(device = _copy_device(parent)))
goto error;
udev_device_unref(tmpdev);
break;
}
}
break;
default:
break;
}
out:
(*func)(eina_stringshare_add(ret), event, sdata, watch);
error:
if (device)
udev_device_unref(device);
return EINA_TRUE;
}
static Eina_Bool
_on_input(__UNUSED__ void *data, Ecore_Fd_Handler *fd_handler)
{
char buf[256];
char *cmd, *args;
const struct {
const char *cmd;
Eina_Bool (*cb)(char *cmd, char *args);
} *itr, maps[] = {
{"quit", _on_cmd_quit},
{"sync", _on_cmd_sync},
{"get_all", _on_cmd_get_all},
{"print", _on_cmd_print},
{"get_properties", _on_cmd_get_properties},
{"set_property", _on_cmd_property_set},
{"manager_get", _on_cmd_manager_get},
{"manager_default_adapter", _on_cmd_manager_default_adapter},
{"adapter_register_agent", _on_cmd_adapter_register_agent},
{"adapter_unregister_agent", _on_cmd_adapter_unregister_agent},
{"adapter_get_address", _on_cmd_adapter_get_address},
{"adapter_get_name", _on_cmd_adapter_get_name},
{"adapter_set_name", _on_cmd_adapter_set_name},
{"adapter_get_powered", _on_cmd_adapter_get_powered},
{"adapter_set_powered", _on_cmd_adapter_set_powered},
{"adapter_get_discoverable", _on_cmd_adapter_get_discoverable},
{"adapter_set_discoverable", _on_cmd_adapter_set_discoverable},
{"adapter_get_discoverable_timeout", _on_cmd_adapter_get_discoverable_timeout},
{"adapter_set_discoverable_timeout", _on_cmd_adapter_set_discoverable_timeout},
{"adapter_get_discovering", _on_cmd_adapter_get_discovering},
{"adapter_start_discovery", _on_cmd_adapter_start_discovery},
{"adapter_stop_discovery", _on_cmd_adapter_stop_discovery},
{"adapter_create_paired_device", _on_cmd_adapter_create_paired_device},
{"device_get_name", _on_cmd_device_get_name},
{NULL, NULL}
};
if (ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_ERROR))
{
fputs("ERROR: reading from stdin, exit\n", stderr);
return EINA_FALSE;
}
if (!ecore_main_fd_handler_active_get(fd_handler, ECORE_FD_READ))
{
fputs("ERROR: nothing to read?\n", stderr);
return EINA_FALSE;
}
if (!fgets(buf, sizeof(buf), stdin))
{
fprintf(stderr, "ERROR: could not read command: %s\n", strerror(errno));
ecore_main_loop_quit();
return EINA_FALSE;
}
cmd = buf;
while (isspace(*cmd))
cmd++;
args = strchr(cmd, ' ');
if (args)
{
char *p;
*args = '\0';
args++;
while (isspace(*args))
args++;
p = args + strlen(args) - 1;
if (*p == '\n')
*p = '\0';
}
else
{
char *p;
p = cmd + strlen(cmd) - 1;
if (*p == '\n')
*p = '\0';
}
if (strcmp(cmd, "help") == 0)
{
if (args)
{
printf("Commands with '%s' in the name:\n", args);
for (itr = maps; itr->cmd; itr++)
if (strstr(itr->cmd, args))
printf("\t%s\n", itr->cmd);
}
else
{
fputs("Commands:\n", stdout);
for (itr = maps; itr->cmd; itr++)
printf("\t%s\n", itr->cmd);
}
fputc('\n', stdout);
return ECORE_CALLBACK_RENEW;
}
for (itr = maps; itr->cmd; itr++)
if (strcmp(itr->cmd, cmd) == 0)
return itr->cb(cmd, args);
printf("unknown command \"%s\", args=%s\n", cmd, args);
return ECORE_CALLBACK_RENEW;
}
void
esql_event_error(Esql *e)
{
Esql *ev;
DBG("(e=%p)", e);
ev = e->pool_member ? (Esql *)e->pool_struct : e; /* use pool struct for events */
e->error = e->backend.error_get(e);
e->query_end = ecore_time_get();
if (e->pool_member)
{
e->pool_struct->error = e->error;
e->pool_struct->cur_query = e->cur_query;
e->pool_struct->cur_id = e->cur_id;
}
if (e->current == ESQL_CONNECT_TYPE_QUERY)
{
Esql_Query_Cb qcb;
qcb = eina_hash_find(esql_query_callbacks, &e->cur_id);
if (qcb)
{
Esql_Res *res;
res = esql_res_calloc(1);
EINA_SAFETY_ON_NULL_RETURN(res);
res->refcount = 1;
res->e = ev;
res->data = e->cur_data;
res->qid = e->cur_id;
ev->res = res;
res->query = e->cur_query;
e->cur_query = NULL;
res->error = e->error;
e->error = NULL;
if (e->pool_member)
ERR("Pool member %u: Connection error: %s", e->pool_id, res->error);
else
ERR("Connection error: %s", res->error);
INFO("Executing callback for current query (%u)", res->qid);
qcb(res, e->cur_data);
e->query_start = e->query_end = 0.0;
eina_hash_del_by_key(esql_query_callbacks, &e->cur_id);
esql_res_free(NULL, res);
}
if (!ecore_main_fd_handler_active_get(e->fdh, ECORE_FD_ERROR))
{
esql_next(e);
return;
}
}
else
{
if (ev->connect_cb)
ev->connect_cb(ev, ev->connect_cb_data);
}
ecore_event_add(ESQL_EVENT_ERROR, ev, (Ecore_End_Cb)esql_fake_free, NULL);
e->event_count++;
esql_disconnect(e);
if (e->reconnect) e->reconnect_timer = ecore_timer_add(1.0, (Ecore_Task_Cb)esql_reconnect_handler, e);
}
