enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity
efl/src/bin/efl/efl_debugd.c

691 lines
19 KiB
C
Raw Permalink Blame History

/* EINA - EFL data type library
* Copyright (C) 2015 Carsten Haitzler
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library;
* if not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#define EFL_BETA_API_SUPPORT 1
#include <fcntl.h>
#include "eina_debug_private.h"
#ifdef _WIN32
# include <evil_private.h> /* mkdir */
#endif
#include <Eina.h>
#include <Ecore.h>
#include <Ecore_Con.h>
static int _log_dom = -1;
#ifdef ERR
# undef ERR
#endif
#define ERR(...) EINA_LOG_DOM_ERR(_log_dom, __VA_ARGS__)
#ifdef DBG
# undef DBG
#endif
#define DBG(...) EINA_LOG_DOM_DBG(_log_dom, __VA_ARGS__)
#ifdef INF
# undef INF
#endif
#define INF(...) EINA_LOG_DOM_INFO(_log_dom, __VA_ARGS__)
#ifdef WRN
# undef WRN
#endif
#define WRN(...) EINA_LOG_DOM_WARN(_log_dom, __VA_ARGS__)
#ifdef CRI
# undef CRI
#endif
#define CRI(...) EINA_LOG_DOM_CRIT(_log_dom, __VA_ARGS__)
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define SWAP_64(x) x
#define SWAP_32(x) x
#define SWAP_16(x) x
#else
#define SWAP_64(x) eina_swap64(x)
#define SWAP_32(x) eina_swap32(x)
#define SWAP_16(x) eina_swap16(x)
#endif
#define STORE(_buf, pval, sz) \
{ \
memcpy(_buf, pval, sz); \
_buf += sz; \
}
#define EXTRACT(_buf, pval, sz) \
{ \
memcpy(pval, _buf, sz); \
_buf += sz; \
}
typedef struct _Client Client;
struct _Client
{
Eo * client;
Eina_Stringshare *app_name;
int version;
int cid;
pid_t pid;
Eina_Bool cl_stat_obs : 1;
Eina_Bool is_master : 1;
};
static Eina_List *_clients = NULL;
static int _retval;
static Eo *_local_server = NULL, *_remote_server = NULL;
typedef Eina_Bool (*Opcode_Cb)(Client *client, void *buffer, int size);
static Eina_Hash *_string_to_opcode_hash = NULL;
static int _free_cid = 1;
static int _clients_stat_register_opcode = EINA_DEBUG_OPCODE_INVALID;
static int _slave_added_opcode = EINA_DEBUG_OPCODE_INVALID;
static int _slave_deleted_opcode = EINA_DEBUG_OPCODE_INVALID;
static int _cid_from_pid_opcode = EINA_DEBUG_OPCODE_INVALID;
static int _test_loop_opcode = EINA_DEBUG_OPCODE_INVALID;
typedef struct
{
int opcode;
Eina_Stringshare *opcode_string;
Opcode_Cb cb;
} Opcode_Information;
#define MAX_OPCODES 1000
Opcode_Information *_opcodes[MAX_OPCODES];
static Client *
_client_find_by_cid(int cid)
{
Client *c;
Eina_List *l;
EINA_LIST_FOREACH(_clients, l, c)
if (c->cid == cid) return c;
return NULL;
}
static Client *
_client_find_by_pid(int pid)
{
Client *c;
Eina_List *l;
EINA_LIST_FOREACH(_clients, l, c)
if (c->pid == pid) return c;
return NULL;
}
static void
_send(Client *dest, int opcode, void *payload, int payload_size)
{
Eina_Error err;
Eina_Slice s, r;
Eina_Debug_Packet_Header hdr;
int size = sizeof(Eina_Debug_Packet_Header) + payload_size;
hdr.size = SWAP_32(size);
hdr.cid = 0;
hdr.opcode = SWAP_32(opcode);
s.mem = &hdr;
s.len = sizeof(hdr);
err = efl_io_writer_write(dest->client, &s, &r);
if (err || r.len) goto end;
if (!payload_size) goto end;
s.mem = payload;
s.len = payload_size;
err = efl_io_writer_write(dest->client, &s, &r);
INF("Send packet (size = %d, opcode %s) to %s", size,
_opcodes[opcode]->opcode_string,
dest->app_name);
end:
if (err)
{
fprintf(stderr, "ERROR: could not queue message '%d': %s\n", opcode, eina_error_msg_get(err));
}
if (r.len)
{
fprintf(stderr, "ERROR: could not queue message '%d': out of memory\n", opcode);
}
}
static Eina_Bool
_dispatch(Client *src, void *buffer)
{
Eina_Debug_Packet_Header *hdr = (Eina_Debug_Packet_Header *)buffer;
if (hdr->cid)
{
/* If the client id is given, we forward */
Client *dest = _client_find_by_cid(hdr->cid);
if (dest)
{
if (dest->is_master != src->is_master)
{
Eina_Slice s;
s.mem = buffer;
s.len = hdr->size;
hdr->cid = SWAP_32(src->cid);
hdr->size = SWAP_32(hdr->size);
hdr->opcode = SWAP_32(hdr->opcode);
if (efl_io_writer_write(dest->client, &s, NULL) !=
EINA_ERROR_NO_ERROR)
ERR("Cannot write to client [%s:%i]", dest->app_name, (int)dest->pid);
INF("Transfer of %d bytes from %s(%d) to %s(%d): operation %s\n",
hdr->size,
src->app_name, src->pid,
dest->app_name, dest->pid,
_opcodes[hdr->opcode]->opcode_string);
}
else
{
/*
* Packets Master -> Master or Slave -> Slave are forbidden
* Only Master <-> Slave packets are allowed.
*/
ERR("Packet from %d to %d: denied (same type)\n", hdr->cid, dest->cid);
}
}
}
else
{
INF("Invoke %s\n", _opcodes[hdr->opcode]->opcode_string);
if (_opcodes[hdr->opcode]->cb)
return _opcodes[hdr->opcode]->cb(src,
(char *)buffer + sizeof(Eina_Debug_Packet_Header),
hdr->size - sizeof(Eina_Debug_Packet_Header));
}
return EINA_TRUE;
}
static int
_opcode_register(const char *op_name, int op_id, Opcode_Cb cb)
{
static int free_opcode = 0;
Opcode_Information *op_info = eina_hash_find(_string_to_opcode_hash, op_name);
if (!op_info)
{
op_info = calloc(1, sizeof(*op_info));
if (op_id == EINA_DEBUG_OPCODE_INVALID)
{
do
{
free_opcode = (free_opcode + 1) % MAX_OPCODES;
op_id = free_opcode;
}
while(_opcodes[op_id]);
}
op_info->opcode = op_id;
op_info->opcode_string = eina_stringshare_add(op_name);
op_info->cb = cb;
eina_hash_add(_string_to_opcode_hash, op_name, op_info);
_opcodes[op_id] = op_info;
}
INF("Register %s -> opcode %d\n", op_name, op_info->opcode);
return op_info->opcode;
}
static Eina_Bool
_hello_cb(Client *c, void *buffer, int size)
{
Eina_List *itr;
char *buf = (char *)buffer, *tmp;
int version, pid, cid;
EXTRACT(buf, &version, 4);
EXTRACT(buf, &pid, 4);
c->version = SWAP_32(version);
c->pid = SWAP_32(pid);
size -= 8;
c->cid = _free_cid++;
cid = SWAP_32(c->cid);
if (size > 1)
{
c->app_name = eina_stringshare_add_length(buf, size);
}
INF("Connection of %s: pid %d - name %s -> cid %d\n",
c->is_master ? "Master" : "Slave",
c->pid, c->app_name, c->cid);
if (c->is_master) return EINA_TRUE;
/* Update the observers */
size = 2 * sizeof(int) + (c->app_name ? strlen(c->app_name) : 0) + 1; /* cid + pid + name + \0 */
buf = alloca(size);
tmp = buf;
STORE(tmp, &cid, sizeof(int));
STORE(tmp, &pid, sizeof(int));
if (c->app_name)
{
STORE(tmp, c->app_name, strlen(c->app_name) + 1);
}
else
{
char end = '\0';
STORE(tmp, &end, 1);
}
EINA_LIST_FOREACH(_clients, itr, c)
{
if (c->cl_stat_obs) _send(c, _slave_added_opcode, buf, size);
}
return EINA_TRUE;
}
static Eina_Bool
_cid_get_cb(Client *src, void *buffer, int size EINA_UNUSED)
{
int pid = SWAP_32(*(int *)buffer);
Client *c = _client_find_by_pid(pid);
int cid = c ? SWAP_32(c->cid) : 0;
_send(src, _cid_from_pid_opcode, &cid, sizeof(int));
return EINA_TRUE;
}
static Eina_Bool
_data_test_cb(Client *src, void *buffer, int size)
{
DBG("Data test: loop packet of %d bytes\n", size);
_send(src, _test_loop_opcode, buffer, size);
return EINA_TRUE;
}
static Eina_Bool
_cl_stat_obs_register_cb(Client *src, void *buffer, int size)
{
Client *c;
if (!src) return EINA_FALSE;
if (!src->is_master) return EINA_FALSE;
if (!src->cl_stat_obs)
{
Eina_List *itr;
src->cl_stat_obs = EINA_TRUE;
size = 0;
EINA_LIST_FOREACH(_clients, itr, c)
{
char *tmp;
int cid, pid;
if (c->is_master) continue;
size = 2 * sizeof(int) + (c->app_name ? strlen(c->app_name) : 0) + 1;
buffer = alloca(size);
tmp = buffer;
cid = SWAP_32(c->cid);
pid = SWAP_32(c->pid);
STORE(tmp, &cid, sizeof(int));
STORE(tmp, &pid, sizeof(int));
if (c->app_name)
{
STORE(tmp, c->app_name, strlen(c->app_name) + 1);
}
else
{
char end = '\0';
STORE(tmp, &end, 1);
}
_send(src, _slave_added_opcode, buffer, size);
}
}
return EINA_TRUE;
}
static Eina_Bool
_opcode_register_cb(Client *src, void *buffer, int size)
{
char *buf = (char *)buffer;
char *ops_buf = buf;
int ops_size = size;
ops_buf += sizeof(uint64_t);
ops_size -= sizeof(uint64_t);
int *opcodes = (int *)ops_buf;
while (ops_size > 0)
{
int len = strlen(ops_buf) + 1;
*opcodes++ = SWAP_32(_opcode_register(ops_buf, EINA_DEBUG_OPCODE_INVALID, NULL));
ops_buf += len;
ops_size -= len;
}
_send(src, EINA_DEBUG_OPCODE_REGISTER, buf, (char *)opcodes - (char *)buf);
return EINA_TRUE;
}
static void
_client_data(void *data, const Efl_Event *event)
{
static unsigned char *buffer = NULL;
unsigned int size = 0;
Eina_Debug_Packet_Header *hdr;
Client *c = data;
Eina_Slice slice;
if (!c) return;
if (!buffer) buffer = malloc(EINA_DEBUG_MAX_PACKET_SIZE);
slice = efl_io_buffered_stream_slice_get(c->client);
if (slice.len < sizeof(*hdr)) return;
hdr = (Eina_Debug_Packet_Header *)slice.mem;
size = SWAP_32(hdr->size);
if (size < sizeof(*hdr)) /* must contain at least the header */
{
fprintf(stderr, "ERROR: invalid message header, size=%u\n", hdr->size);
goto err;
}
if (size > EINA_DEBUG_MAX_PACKET_SIZE)
{
fprintf(stderr, "ERROR: packet too big (max: %d), size=%u\n",
EINA_DEBUG_MAX_PACKET_SIZE, hdr->size);
goto err;
}
/* Incomplete packet: need to wait */
if (size > slice.len) return;
memcpy(buffer, slice.mem, size);
hdr = (Eina_Debug_Packet_Header *)buffer;
hdr->size = SWAP_32(hdr->size);
hdr->opcode = SWAP_32(hdr->opcode);
hdr->cid = SWAP_32(hdr->cid);
if(!_dispatch(c, buffer))
{
// something we don't understand
fprintf(stderr, "Dispatch: unknown command: %d\n", hdr->opcode);
}
efl_io_buffered_stream_discard(c->client, size);
return;
err:
if (!efl_io_closer_closed_get(event->object))
efl_io_closer_close(event->object);
fprintf(stderr, "INFO: client %p [pid: %d] sent invalid data\n", c, (int)c->pid);
}
static void
_client_error(void *data, const Efl_Event *event)
{
Client *c = data;
Eina_Error *perr = event->info;
WRN("client %p [pid: %d] error: %s",
c, (int)c->pid, eina_error_msg_get(*perr));
fprintf(stderr, "INFO: client %p [pid: %d] error: %s\n",
c, (int)c->pid, eina_error_msg_get(*perr));
}
static void
_client_eos(void *data, const Efl_Event *event EINA_UNUSED)
{
Client *c = data;
DBG("client %p (%p) [pid: %d] closed, pending read %zu, write %zu",
c, c->client, (int)c->pid,
efl_io_buffered_stream_pending_read_get(c->client),
efl_io_buffered_stream_pending_write_get(c->client));
efl_io_closer_close(c->client);
}
static void
_client_write_finished(void *data, const Efl_Event *event EINA_UNUSED)
{
Client *c = data;
DBG("client %p (%p) [pid: %d] finished writing, pending read %zu",
c, c->client, (int)c->pid, efl_io_buffered_stream_pending_read_get(c->client));
}
static void
_client_read_finished(void *data, const Efl_Event *event EINA_UNUSED)
{
Client *c = data;
DBG("client %p (%p) [pid: %d] finished reading, pending write %zu",
c, c->client, (int)c->pid, efl_io_buffered_stream_pending_write_get(c->client));
}
static Efl_Callback_Array_Item *_client_cbs(void);
static void
_client_finished(void *data, const Efl_Event *event EINA_UNUSED)
{
Eina_List *itr;
Client *c = data, *c2;
int cid = SWAP_32(c->cid);
efl_event_callback_array_del(c->client, _client_cbs(), c);
INF("finished client %p (%p) [pid:%d]", c, c->client, c->pid);
_clients = eina_list_remove(_clients, c);
efl_unref(c->client);
/* Don't update the observers if the client is a master */
if (c->is_master) return;
EINA_LIST_FOREACH(_clients, itr, c2)
{
if (c2->cl_stat_obs) _send(c2, _slave_deleted_opcode, &cid, sizeof(int));
}
free(c);
}
EFL_CALLBACKS_ARRAY_DEFINE(_client_cbs,
{ EFL_IO_READER_EVENT_EOS, _client_eos },
{ EFL_IO_BUFFERED_STREAM_EVENT_ERROR, _client_error },
{ EFL_IO_BUFFERED_STREAM_EVENT_READ_FINISHED, _client_read_finished },
{ EFL_IO_BUFFERED_STREAM_EVENT_WRITE_FINISHED, _client_write_finished },
{ EFL_IO_BUFFERED_STREAM_EVENT_FINISHED, _client_finished },
{ EFL_IO_BUFFERED_STREAM_EVENT_SLICE_CHANGED, _client_data });
static void
_client_add(void *data EINA_UNUSED, const Efl_Event *event)
{
Client *c = calloc(1, sizeof(Client));
EINA_SAFETY_ON_NULL_RETURN(c);
c->client = efl_ref(event->info);
c->is_master = (event->object == _remote_server);
_clients = eina_list_append(_clients, c);
efl_event_callback_array_add(c->client, _client_cbs(), c);
INF("server %p new client %p (%p)", event->object, c, c->client);
}
static void
_error(void *data EINA_UNUSED, const Efl_Event *event)
{
Eina_Error *perr = event->info;
ERR("server %p error: %s", event->object, eina_error_msg_get(*perr));
fprintf(stderr, "ERROR: %s\n", eina_error_msg_get(*perr));
ecore_main_loop_quit();
_retval = EXIT_FAILURE;
}
static Eina_Bool
_local_server_create(void)
{
Eo *loop;
Eina_Error err;
mode_t mask = 0;
char path[512];
Eina_Bool ret = EINA_FALSE;
eina_vpath_resolve_snprintf(path, sizeof(path), "(:usr.run:)/%s", LOCAL_SERVER_PATH);
if (mkdir(path, S_IRWXU) < 0 && errno != EEXIST)
{
perror("mkdir SERVER_PATH");
goto end;
}
eina_vpath_resolve_snprintf(path, sizeof(path), "(:usr.run:)/%s/%s", LOCAL_SERVER_PATH, LOCAL_SERVER_NAME);
if (mkdir(path, S_IRWXU) < 0 && errno != EEXIST)
{
perror("mkdir SERVER_NAME");
goto end;
}
mask = umask(S_IRWXG | S_IRWXO);
eina_vpath_resolve_snprintf(path, sizeof(path) - 1, "(:usr.run:)/%s/%s/%i",
LOCAL_SERVER_PATH, LOCAL_SERVER_NAME, LOCAL_SERVER_PORT);
loop = efl_main_loop_get();
#ifdef EFL_NET_SERVER_UNIX_CLASS
_local_server = efl_add(EFL_NET_SERVER_SIMPLE_CLASS, loop,
efl_net_server_simple_inner_class_set(efl_added, EFL_NET_SERVER_UNIX_CLASS));
#else
/* TODO: maybe start a TCP using locahost:12345?
* Right now eina_debug_monitor is only for AF_UNIX, so not an issue.
*/
fprintf(stderr, "ERROR: your platform doesn't support Efl.Net.Server.Unix\n");
#endif
if (!_local_server)
{
fprintf(stderr, "ERROR: could not create communication server\n");
goto end;
}
efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
efl_event_callback_add(_local_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
#ifdef EFL_NET_SERVER_UNIX_CLASS
{
Eo *inner_server = efl_net_server_simple_inner_server_get(_local_server);
efl_net_server_unix_leading_directories_create_set(inner_server, EINA_TRUE, 0700);
}
#endif
err = efl_net_server_serve(_local_server, path);
if (err)
{
fprintf(stderr, "ERROR: could not serve '%s': %s\n", path, eina_error_msg_get(err));
goto end;
}
ret = EINA_TRUE;
end:
umask(mask);
if (!ret)
{
efl_del(_local_server);
_local_server = NULL;
}
return ret;
}
static Eina_Bool
_remote_server_create(void)
{
Eo *loop;
Eina_Error err;
mode_t mask = 0;
Eina_Bool ret = EINA_FALSE;
char address[256];
loop = efl_main_loop_get();
_remote_server = efl_add(EFL_NET_SERVER_SIMPLE_CLASS, loop,
efl_net_server_simple_inner_class_set(efl_added, EFL_NET_SERVER_TCP_CLASS));
if (!_remote_server)
{
fprintf(stderr, "ERROR: could not create communication server\n");
goto end;
}
{
Eo *inner_server = efl_net_server_simple_inner_server_get(_remote_server);
efl_net_server_fd_reuse_address_set(inner_server, EINA_TRUE);
}
efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
efl_event_callback_add(_remote_server, EFL_NET_SERVER_EVENT_SERVER_ERROR, _error, NULL);
sprintf(address, "127.0.0.1:%d", REMOTE_SERVER_PORT);
err = efl_net_server_serve(_remote_server, address);
if (err)
{
fprintf(stderr, "ERROR: could not serve port '%d': %s\n",
REMOTE_SERVER_PORT, eina_error_msg_get(err));
goto end;
}
ret = EINA_TRUE;
end:
umask(mask);
if (!ret)
{
efl_del(_remote_server);
_remote_server = NULL;
}
return ret;
}
static Eina_Bool
_server_launch(void)
{
if (_local_server_create() <= 0) goto err;
if (_remote_server_create() <= 0) goto err;
return EINA_TRUE;
err:
efl_del(_local_server);
efl_del(_remote_server);
return EINA_FALSE;
}
int
main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
{
eina_debug_disable();
ecore_app_no_system_modules();
eina_init();
_log_dom = eina_log_domain_register("efl_debugd", EINA_COLOR_CYAN);
ecore_init();
ecore_con_init();
_retval = EXIT_SUCCESS;
_string_to_opcode_hash = eina_hash_string_superfast_new(NULL);
_opcode_register("Daemon/opcode_register", EINA_DEBUG_OPCODE_REGISTER, _opcode_register_cb);
_opcode_register("Daemon/greet", EINA_DEBUG_OPCODE_HELLO, _hello_cb);
_clients_stat_register_opcode = _opcode_register("Daemon/Client/register_observer", EINA_DEBUG_OPCODE_INVALID, _cl_stat_obs_register_cb);
_slave_added_opcode = _opcode_register("Daemon/Client/added", EINA_DEBUG_OPCODE_INVALID, NULL);
_slave_deleted_opcode = _opcode_register("Daemon/Client/deleted", EINA_DEBUG_OPCODE_INVALID, NULL);
_cid_from_pid_opcode = _opcode_register("Daemon/Client/cid_from_pid", EINA_DEBUG_OPCODE_INVALID, _cid_get_cb);
_test_loop_opcode = _opcode_register("Test/data_loop", EINA_DEBUG_OPCODE_INVALID, _data_test_cb);
if (_server_launch()) ecore_main_loop_begin();
else _retval = EXIT_FAILURE;
ecore_con_shutdown();
ecore_shutdown();
eina_log_domain_unregister(_log_dom);
eina_shutdown();
return _retval;
}
Reference in New Issue View Git Blame Copy Permalink