efl_debug (client and server): now on top of efl_net_{server,dialer}_simple.

Much simpler! :-D

src/bin/efl/efl_debug.c

@@ -16,8 +16,6 @@
  * if not, see <http://www.gnu.org/licenses/>.
  */
 
-#define EFL_BETA_API_SUPPORT 1
-#define EFL_EO_API_SUPPORT 1
 #include "efl_debug_common.h"
 
 static Eo *dialer;
@@ -26,19 +24,15 @@ static Eina_List *waiting;
 
 static int retval = EXIT_SUCCESS;
 
-static const char CLST[4] = "CLST";
-
 static void
-_process_reply(const char op[static 4], const Eina_Slice payload)
+_process_reply(void *data EINA_UNUSED, const char op[static 4], const Eina_Slice payload)
 {
-#define IS_OP(x) memcmp(op, x, 4) == 0
-
    if (IS_OP(CLST))
      {
         int mypid = getpid();
         size_t offset;
 
-        waiting = eina_list_remove(waiting, CLST);
+        waiting = eina_list_remove(waiting, OP_CLST);
 
         for (offset = 0; offset + sizeof(int) <= payload.len; offset += sizeof(int))
           {
@@ -57,76 +51,23 @@ _process_reply(const char op[static 4], const Eina_Slice payload)
      }
 
    if (!waiting) ecore_main_loop_quit();
-
-#undef IS_OP
 }
 
 static void
 _on_data(void *data EINA_UNUSED, const Efl_Event *event EINA_UNUSED)
 {
-   Eina_Slice slice, payload;
+   if (!received_data(dialer, _process_reply, NULL))
-   Efl_Debug_Message_Header msgheader;
-
-   if (!efl_io_buffered_stream_slice_get(dialer, &slice))
-     return;
-
-   if (slice.len < sizeof(msgheader))
-     return;
-
-   memcpy(&msgheader, slice.mem, sizeof(msgheader));
-   if (msgheader.size < 4) /* must contain at last 4 byte opcode */
      {
-        fprintf(stderr, "ERROR: invalid message header, size=%u\n", msgheader.size);
         retval = EXIT_FAILURE;
         ecore_main_loop_quit();
-        return;
      }
-
-   if (msgheader.size + 4 > slice.len)
-     return;
-
-   payload.bytes = slice.bytes + sizeof(msgheader);
-   payload.len = msgheader.size - 4;
-
-   _process_reply(msgheader.op, payload);
-
-   efl_io_buffered_stream_discard(dialer, sizeof(msgheader) + payload.len);
 }
 
 static Eina_Bool
 _command_send(const char op[static 4], const void *data, unsigned int len)
 {
-   Eina_Error err;
+   if (!send_data(dialer, op, data, len))
-   Efl_Debug_Message_Header msghdr = {
-     .size = 4 + len,
-   };
-   Eina_Slice s, r;
-
-   memcpy(msghdr.op, op, 4);
-
-   s.mem = &msghdr;
-   s.len = sizeof(msghdr);
-
-   err = efl_io_writer_write(dialer, &s, &r);
-   if (err || r.len) goto end;
-
-   if (!len) goto end;
-
-   s.mem = data;
-   s.len = len;
-   err = efl_io_writer_write(dialer, &s, &r);
-
- end:
-   if (err)
      {
-        fprintf(stderr, "ERROR: could not queue message '%.4s': %s\n", op, eina_error_msg_get(err));
-        retval = EXIT_FAILURE;
-        return EINA_FALSE;
-     }
-
-   if (r.len)
-     {
-        fprintf(stderr, "ERROR: could not queue message '%.4s': out of memory\n", op);
         retval = EXIT_FAILURE;
         return EINA_FALSE;
      }
@@ -134,6 +75,8 @@ _command_send(const char op[static 4], const void *data, unsigned int len)
    return EINA_TRUE;
 }
 
+#define command_send(op, data, len) _command_send(OP_ ## op, data, len)
+
 static void
 _write_finished(void *data EINA_UNUSED, const Efl_Event *event EINA_UNUSED)
 {
@@ -234,9 +177,9 @@ main(int argc, char **argv)
 
         if (strcmp(cmd, "list") == 0)
           {
-             if (!_command_send("LIST", NULL, 0))
+             if (!command_send(LIST, NULL, 0))
                goto end;
-             waiting = eina_list_append(waiting, CLST);
+             waiting = eina_list_append(waiting, OP_CLST);
           }
         else if (strcmp(cmd, "pon") == 0)
           {
@@ -249,7 +192,7 @@ main(int argc, char **argv)
              else
                {
                   int data[2] = {atoi(argv[i + 1]), atoi(argv[1 + 2])};
-                  if (!_command_send("PLON", data, sizeof(data)))
+                  if (!command_send(PLON, data, sizeof(data)))
                     goto end;
                   i += 2;
                }
@@ -265,7 +208,7 @@ main(int argc, char **argv)
              else
                {
                   int data[1] = {atoi(argv[i + 1])};
-                  if (!_command_send("PLOFF", data, sizeof(data)))
+                  if (!command_send(PLOF, data, sizeof(data)))
                     goto end;
                   i++;
                }
@@ -281,7 +224,7 @@ main(int argc, char **argv)
              else
                {
                   int data[1] = {atoi(argv[i + 1])};
-                  if (!_command_send("EVON", data, sizeof(data)))
+                  if (!command_send(EVON, data, sizeof(data)))
                     goto end;
                   i++;
                }
@@ -297,7 +240,7 @@ main(int argc, char **argv)
              else
                {
                   int data[1] = {atoi(argv[i + 1])};
-                  if (!_command_send("EVOF", data, sizeof(data)))
+                  if (!command_send(EVOF, data, sizeof(data)))
                     goto end;
                   i++;
                }

src/bin/efl/efl_debug_common.c

@@ -111,3 +111,73 @@ _proto_read(unsigned char **buf, unsigned int *buf_size,
    *buf_size = new_buf_size;
    return (int)size;
 }
+
+Eina_Bool
+received_data(Eo *sock, void (*handle)(void *data, const char op[static 4], const Eina_Slice payload), const void *data)
+{
+   Eina_Slice slice, payload;
+   Efl_Debug_Message_Header msgheader;
+
+   if (!efl_io_buffered_stream_slice_get(sock, &slice))
+     return EINA_TRUE;
+
+   if (slice.len < sizeof(msgheader))
+     return EINA_TRUE;
+
+   memcpy(&msgheader, slice.mem, sizeof(msgheader));
+   if (msgheader.size < 4) /* must contain at last 4 byte opcode */
+     {
+        fprintf(stderr, "ERROR: invalid message header, size=%u\n", msgheader.size);
+        return EINA_FALSE;
+     }
+
+   if (msgheader.size + 4 > slice.len)
+     return EINA_TRUE;
+
+   payload.bytes = slice.bytes + sizeof(msgheader);
+   payload.len = msgheader.size - 4;
+
+   handle((void *)data, msgheader.op, payload);
+
+   efl_io_buffered_stream_discard(sock, sizeof(msgheader) + payload.len);
+   return EINA_TRUE;
+}
+
+Eina_Bool
+send_data(Eo *sock, const char op[static 4], const void *data, unsigned int len)
+{
+   Eina_Error err;
+   Efl_Debug_Message_Header msghdr = {
+     .size = 4 + len,
+   };
+   Eina_Slice s, r;
+
+   memcpy(msghdr.op, op, 4);
+
+   s.mem = &msghdr;
+   s.len = sizeof(msghdr);
+
+   err = efl_io_writer_write(sock, &s, &r);
+   if (err || r.len) goto end;
+
+   if (!len) goto end;
+
+   s.mem = data;
+   s.len = len;
+   err = efl_io_writer_write(sock, &s, &r);
+
+ end:
+   if (err)
+     {
+        fprintf(stderr, "ERROR: could not queue message '%.4s': %s\n", op, eina_error_msg_get(err));
+        return EINA_FALSE;
+     }
+
+   if (r.len)
+     {
+        fprintf(stderr, "ERROR: could not queue message '%.4s': out of memory\n", op);
+        return EINA_FALSE;
+     }
+
+   return EINA_TRUE;
+}

src/bin/efl/efl_debug_common.h

@@ -19,6 +19,9 @@
 #ifndef EFL_DEBUG_COMMON_H
 #define EFL_DEBUG_COMMON_H 1
 
+#define EFL_BETA_API_SUPPORT 1
+#define EFL_EO_API_SUPPORT 1
+
 #include <Eina.h>
 #include <Ecore.h>
 #include <Ecore_Con.h>
@@ -41,15 +44,20 @@ int _proto_read(unsigned char **buf, unsigned int *buf_size,
    memcpy(&dst, ((unsigned char *)buf) + off, sizeof(dst))
 #define store_val(buf, off, src) \
    memcpy(buf + off, &src, sizeof(src))
-#define send_cli(cli, op, data, size) \
+
-   do { \
+#define IS_OP(x) memcmp(op, OP_ ## x, 4) == 0
-      unsigned char head[8]; \
+
-      char *op2 = op; \
+#define DECLARE_OP(x) static char OP_ ## x[4] = #x
-      int size2 = size + 4; \
+DECLARE_OP(LIST);
-      memcpy(head + 0, &size2, 4); \
+DECLARE_OP(CLST);
-      memcpy(head + 4, op2, 4); \
+DECLARE_OP(PLON);
-      ecore_con_client_send(cli, head, 8); \
+DECLARE_OP(PLOF);
-      if (size > 0) ecore_con_client_send(cli, data, size); \
+DECLARE_OP(EVON);
-   } while (0)
+DECLARE_OP(EVOF);
+DECLARE_OP(EVLG);
+DECLARE_OP(HELO);
+
+Eina_Bool send_data(Eo *sock, const char op[static 4], const void *data, unsigned int len);
+Eina_Bool received_data(Eo *sock, void (*handle)(void *data, const char op[static 4], const Eina_Slice payload), const void *data);
 
 #endif

src/bin/efl/efl_debugd.c

@@ -22,7 +22,8 @@ typedef struct _Client Client;
 
 struct _Client
 {
-   Ecore_Con_Client *client;
+   Eo *client;
+
    unsigned char    *buf;
    unsigned int      buf_size;
 
@@ -34,9 +35,51 @@ struct _Client
    pid_t             pid;
 };
 
-static Ecore_Con_Server *svr = NULL;
+static Eo *server;
+
 static Eina_List *clients = NULL;
 
+static int retval;
+
+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__)
+
+
+#define send_cli(cl, op, data, len)                             \
+  do                                                            \
+    {                                                           \
+       if (!send_data(cl->client, OP_ ## op, data, len))        \
+         {                                                      \
+            if (!efl_io_closer_closed_get(cl->client))          \
+              efl_io_closer_close(cl->client);                  \
+         }                                                      \
+    }                                                           \
+  while (0)
+
 static Client *
 _client_pid_find(int pid)
 {
@@ -48,6 +91,8 @@ _client_pid_find(int pid)
      {
         if (c->pid == pid) return c;
      }
+
+   WRN("no client pid=%d", pid);
    return NULL;
 }
 
@@ -55,27 +100,35 @@ static Eina_Bool
 _cb_evlog(void *data)
 {
    Client *c = data;
-   send_cli(c->client, "EVLG", NULL, 0);
+   send_cli(c, EVLG, NULL, 0);
    return EINA_TRUE;
 }
 
 static void
-_do(Client *c, char *op, unsigned char *d, int size)
+_process_command(void *data, const char op[static 4], const Eina_Slice payload)
 {
+   Client *c = data;
    Client *c2;
    Eina_List *l;
 
-   if ((!strcmp(op, "HELO")) && (size >= 8))
+   DBG("client %p (%p) [pid:%d] op=%.4s payload=%zd", c, c->client, c->pid, op, payload.len);
-     {
-        int version;
-        int pid;
 
-        fetch_val(version, d, 0);
+   if (IS_OP(HELO))
-        fetch_val(pid, d, 4);
+     {
-        c->version = version;
+        if (payload.len < sizeof(int) * 2)
-        c->pid = pid;
+          {
+             fprintf(stderr, "INFO: client %p [pid: %d] sent invalid HELO\n", c, (int)c->pid);
+             if (!efl_io_closer_closed_get(c->client))
+               efl_io_closer_close(c->client);
           }
-   else if (!strcmp(op, "LIST"))
+        else
+          {
+             memcpy(&c->version, payload.bytes, sizeof(int));
+             memcpy(&c->pid, payload.bytes + sizeof(int), sizeof(int));
+             INF("client %p (%p) HELO version=%d, pid=%d", c, c->client, c->version, c->pid);
+          }
+     }
+   else if (IS_OP(LIST))
      {
         int n = eina_list_count(clients);
         unsigned int *pids = malloc(n * sizeof(int));
@@ -85,64 +138,118 @@ _do(Client *c, char *op, unsigned char *d, int size)
 
              EINA_LIST_FOREACH(clients, l, c2)
                {
+                  if (c2->pid == 0) continue; /* no HELO yet */
                   pids[i] = c2->pid;
                   i++;
                }
-             send_cli(c->client, "CLST", pids, n * sizeof(int));
+             send_cli(c, CLST, pids, i * sizeof(int));
              free(pids);
           }
      }
-   else if ((!strcmp(op, "PLON")) && (size >= 8))
+   else if (IS_OP(PLON))
+     {
+        if (payload.len < sizeof(int) * 2)
+          fprintf(stderr, "INFO: client %p [pid: %d] sent invalid PLON\n", c, (int)c->pid);
+        else
           {
              int pid;
-        unsigned int freq = 1000;
+             unsigned int freq;
-        fetch_val(pid, d, 0);
+             memcpy(&pid, payload.bytes, sizeof(int));
-        fetch_val(freq, d, 4);
+             memcpy(&freq, payload.bytes + sizeof(int), sizeof(int));
-        if ((c2 = _client_pid_find(pid)))
+             c2 = _client_pid_find(pid);
+             if (!c2)
                {
-             unsigned char buf[4];
+                  fprintf(stderr, "INFO: client %p [pid: %d] sent PLON %d: no such client\n", c, (int)c->pid, pid);
-             store_val(buf, 0, freq);
+               }
-             send_cli(c2->client, "PLON", buf, sizeof(buf));
+             else
+               {
+                  DBG("client %p (%p) [pid:%d] requested PLON on %p (%p) [pid:%d]",
+                      c, c->client, c->pid,
+                      c2, c2->client, c2->pid);
+                  send_cli(c2, PLON, &freq, sizeof(freq));
                }
           }
-   else if (!strcmp(op, "PLOF"))
+     }
+   else if (IS_OP(PLOF))
+     {
+        if (payload.len < sizeof(int))
+          fprintf(stderr, "INFO: client %p [pid: %d] sent invalid PLOF\n", c, (int)c->pid);
+        else
           {
              int pid;
-        fetch_val(pid, d, 0);
+             memcpy(&pid, payload.bytes, sizeof(int));
-        if ((c2 = _client_pid_find(pid)))
+             c2 = _client_pid_find(pid);
+             if (!c2)
                {
-             send_cli(c2->client, "PLOF", NULL, 0);
+                  fprintf(stderr, "INFO: client %p [pid: %d] sent PLOF %d: no such client\n", c, (int)c->pid, pid);
+               }
+             else
+               {
+                  DBG("client %p (%p) [pid:%d] requested PLOF on %p (%p) [pid:%d]",
+                      c, c->client, c->pid,
+                      c2, c2->client, c2->pid);
+                  send_cli(c2, PLOF, NULL, 0);
                }
           }
-   else if (!strcmp(op, "EVON"))
+     }
+   else if (IS_OP(EVON))
+     {
+        if (payload.len < sizeof(int))
+          fprintf(stderr, "INFO: client %p [pid: %d] sent invalid EVON\n", c, (int)c->pid);
+        else
           {
              int pid;
-        fetch_val(pid, d, 0);
+             memcpy(&pid, payload.bytes, sizeof(int));
-        if ((c2 = _client_pid_find(pid)))
+             c2 = _client_pid_find(pid);
+             if (!c2)
+               {
+                  fprintf(stderr, "INFO: client %p [pid: %d] sent EVON %d: no such client\n", c, (int)c->pid, pid);
+               }
+             else
                {
                   c2->evlog_on++;
+                  DBG("client %p (%p) [pid:%d] requested EVON (%d) on %p (%p) [pid:%d]",
+                      c, c->client, c->pid,
+                      c2->evlog_on,
+                      c2, c2->client, c2->pid);
                   if (c2->evlog_on == 1)
                     {
                        char buf[4096];
 
-                  send_cli(c2->client, "EVON", NULL, 0);
+                       send_cli(c2, EVON, NULL, 0);
                        c2->evlog_fetch_timer = ecore_timer_add(0.2, _cb_evlog, c2);
-                  snprintf(buf, sizeof(buf), "%s/efl_debug_evlog-%ld.log",
+                       snprintf(buf, sizeof(buf), "%s/efl_debug_evlog-%d.log",
-                           getenv("HOME"), (long)c2->pid);
+                                getenv("HOME"), c2->pid);
                        c2->evlog_file = fopen(buf, "wb");
+                       DBG("client %p (%p) [pid:%d] logging to %s [%p]",
+                           c2, c2->client, c2->pid, buf, c2->evlog_file);
                     }
                }
           }
-   else if (!strcmp(op, "EVOF"))
+     }
+   else if (IS_OP(EVOF))
+     {
+        if (payload.len < sizeof(int))
+          fprintf(stderr, "INFO: client %p [pid: %d] sent invalid EVOF\n", c, (int)c->pid);
+        else
           {
              int pid;
-        fetch_val(pid, d, 0);
+             memcpy(&pid, payload.bytes, sizeof(int));
-        if ((c2 = _client_pid_find(pid)))
+             c2 = _client_pid_find(pid);
+             if (!c2)
+               {
+                  fprintf(stderr, "INFO: client %p [pid: %d] sent EVOF %d: no such client\n", c, (int)c->pid, pid);
+               }
+             else
                {
                   c2->evlog_on--;
+                  DBG("client %p (%p) [pid:%d] requested EVOF (%d) on %p (%p) [pid:%d]",
+                      c, c->client, c->pid,
+                      c2->evlog_on,
+                      c2, c2->client, c2->pid);
                   if (c2->evlog_on == 0)
                     {
-                  send_cli(c2->client, "EVOF", NULL, 0);
+                       send_cli(c2, EVOF, NULL, 0);
                        if (c2->evlog_fetch_timer)
                          {
                             ecore_timer_del(c2->evlog_fetch_timer);
@@ -150,6 +257,8 @@ _do(Client *c, char *op, unsigned char *d, int size)
                          }
                        if (c2->evlog_file)
                          {
+                            DBG("client %p (%p) [pid:%d] finished logged to %p",
+                                c2, c2->client, c2->pid, c2->evlog_file);
                             fclose(c2->evlog_file);
                             c2->evlog_file = NULL;
                          }
@@ -158,44 +267,89 @@ _do(Client *c, char *op, unsigned char *d, int size)
                     c2->evlog_on = 0;
                }
           }
-   else if (!strcmp(op, "EVLG"))
+     }
+   else if (IS_OP(EVLG))
      {
-        unsigned int *overflow = (unsigned int *)(d + 0);
+        if (payload.len < sizeof(int))
-        unsigned char *p = d + 4;
+          fprintf(stderr, "INFO: client %p [pid: %d] sent invalid EVLG\n", c, (int)c->pid);
-        unsigned int blocksize = size - 4;
+        else if (!c->evlog_file)
-
+          fprintf(stderr, "INFO: client %p [pid: %d] no matching EVON\n", c, (int)c->pid);
-        if ((c->evlog_file) && (blocksize > 0))
+        else
+          {
+             unsigned int blocksize = payload.len - sizeof(int);
+             if (blocksize > 0)
                {
                   unsigned int header[3];
 
                   header[0] = 0xffee211;
                   header[1] = blocksize;
-             header[2] = *overflow;
+                  memcpy(header + 2, payload.mem, sizeof(int));
+
                   fwrite(header, 12, 1, c->evlog_file);
-             fwrite(p, blocksize, 1, c->evlog_file);
+                  fwrite(payload.bytes + sizeof(int), blocksize, 1, c->evlog_file);
+               }
           }
      }
 }
 
-static Eina_Bool
+static void
-_client_add(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Add *ev)
+_client_data(void *data, const Efl_Event *event)
 {
-   Client *c = calloc(1, sizeof(Client));
+   Client *c = data;
-   if (c)
+   if (!received_data(event->object, _process_command, c))
      {
-        c->client = ev->client;
+        fprintf(stderr, "INFO: client %p [pid: %d] sent invalid data\n", c, (int)c->pid);
-        clients = eina_list_append(clients, c);
+        if (!efl_io_closer_closed_get(event->object))
-        ecore_con_client_data_set(c->client, c);
+          efl_io_closer_close(event->object);
+        return;
      }
-   return ECORE_CALLBACK_RENEW;
 }
 
-static Eina_Bool
+static void
-_client_del(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Del *ev)
+_client_error(void *data, const Efl_Event *event)
 {
-   Client *c = ecore_con_client_data_get(ev->client);
+   Client *c = data;
-   if (c)
+   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)
+{
+   Client *c = data;
+
    clients = eina_list_remove(clients, c);
    if (c->evlog_fetch_timer)
      {
@@ -207,55 +361,111 @@ _client_del(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client
         fclose(c->evlog_file);
         c->evlog_file = NULL;
      }
+   efl_event_callback_array_del(c->client, _client_cbs(), c);
+   INF("finished client %p (%p) [pid:%d]", c, c->client, c->pid);
+   efl_unref(c->client);
    free(c);
-     }
-   return ECORE_CALLBACK_RENEW;
 }
 
-static Eina_Bool
+EFL_CALLBACKS_ARRAY_DEFINE(_client_cbs,
-_client_data(void *data EINA_UNUSED, int type EINA_UNUSED, Ecore_Con_Event_Client_Data *ev)
+                           { EFL_IO_READER_EVENT_EOS, _client_eos },
-{
+                           { EFL_IO_BUFFERED_STREAM_EVENT_ERROR, _client_error },
-   Client *c = ecore_con_client_data_get(ev->client);
+                           { EFL_IO_BUFFERED_STREAM_EVENT_READ_FINISHED, _client_read_finished },
-   if (c)
+                           { EFL_IO_BUFFERED_STREAM_EVENT_WRITE_FINISHED, _client_write_finished },
-     {
+                           { EFL_IO_BUFFERED_STREAM_EVENT_FINISHED, _client_finished },
-        char op[5];
+                           { EFL_IO_BUFFERED_STREAM_EVENT_SLICE_CHANGED, _client_data });
-        unsigned char *d = NULL;
-        int size;
 
-        _protocol_collect(&(c->buf), &(c->buf_size), ev->data, ev->size);
+static void
-        while ((size = _proto_read(&(c->buf), &(c->buf_size), op, &d)) >= 0)
+_client_add(void *data EINA_UNUSED, const Efl_Event *event)
-          {
+{
-             _do(c, op, d, size);
+   Client *c = calloc(1, sizeof(Client));
-             free(d);
+
-             d = NULL;
+   EINA_SAFETY_ON_NULL_RETURN(c);
-          }
+   c->client = efl_ref(event->info);
-     }
+   clients = eina_list_append(clients, c);
-   return ECORE_CALLBACK_RENEW;
+   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;
 }
 
 int
 main(int argc EINA_UNUSED, char **argv EINA_UNUSED)
 {
+   Eo *loop;
+   char *path;
+   Eina_Error err;
+
+   ecore_app_no_system_modules();
+
    eina_init();
    ecore_init();
    ecore_con_init();
 
-   svr = ecore_con_server_add(ECORE_CON_LOCAL_USER, "efl_debug", 0, NULL);
+   _log_dom = eina_log_domain_register("efl_debugd", EINA_COLOR_CYAN);
-   if (!svr)
+
+   path = ecore_con_local_path_new(EINA_FALSE, "efl_debug", 0);
+   if (!path)
      {
-        fprintf(stderr, "ERROR: Cannot create debug daemon.\n");
+        fprintf(stderr, "ERROR: could not get local communication path\n");
-        return -1;
+        retval = EXIT_FAILURE;
+        goto end;
      }
 
-   ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_ADD, (Ecore_Event_Handler_Cb)_client_add, NULL);
+   loop = ecore_main_loop_get();
-   ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DEL, (Ecore_Event_Handler_Cb)_client_del, NULL);
+
-   ecore_event_handler_add(ECORE_CON_EVENT_CLIENT_DATA, (Ecore_Event_Handler_Cb)_client_data, NULL);
+#ifdef EFL_NET_SERVER_UNIX_CLASS
+   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 (!server)
+     {
+        fprintf(stderr, "ERROR: could not create communication server\n");
+        retval = EXIT_FAILURE;
+        goto end;
+     }
+
+   efl_event_callback_add(server, EFL_NET_SERVER_EVENT_CLIENT_ADD, _client_add, NULL);
+   efl_event_callback_add(server, EFL_NET_SERVER_EVENT_ERROR, _error, NULL);
+
+#ifdef EFL_NET_SERVER_UNIX_CLASS
+   {
+      Eo *inner_server = efl_net_server_simple_inner_server_get(server);
+      efl_net_server_unix_unlink_before_bind_set(inner_server, EINA_TRUE);
+      efl_net_server_unix_leading_directories_create_set(inner_server, EINA_TRUE, 0700);
+   }
+#endif
+
+   err = efl_net_server_serve(server, path);
+   if (err)
+     {
+        fprintf(stderr, "ERROR: could not serve '%s': %s\n", path, eina_error_msg_get(err));
+        retval = EXIT_FAILURE;
+        goto end;
+     }
 
    ecore_main_loop_begin();
 
-   ecore_con_server_del(svr);
+ end:
+   efl_del(server);
+   free(path);
 
    ecore_con_shutdown();
    ecore_shutdown();
    eina_shutdown();
+
+   return retval;
 }