1 files changed, 249 insertions, 0 deletions

diff --git a/libraries/eet/src/lib/eet_connection.c b/libraries/eet/src/lib/eet_connection.c
new file mode 100644
index 0000000..6171b7e
--- /dev/null
+++ b/libraries/eet/src/lib/eet_connection.c
@@ -0,0 +1,249 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif /* ifdef HAVE_CONFIG_H */
+
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#elif defined __GNUC__
+# define alloca __builtin_alloca
+#elif defined _AIX
+# define alloca __alloca
+#elif defined _MSC_VER
+# include <malloc.h>
+# define alloca _alloca
+#else /* ifdef HAVE_ALLOCA_H */
+# include <stddef.h>
+# ifdef  __cplusplus
+extern "C"
+# endif /* ifdef  __cplusplus */
+void *alloca(size_t);
+#endif /* ifdef HAVE_ALLOCA_H */
+
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#endif /* ifdef HAVE_NETINET_IN_H */
+
+#ifdef _WIN32
+# include <winsock2.h>
+#endif /* ifdef _WIN32 */
+
+#include <Eina.h>
+
+#include "Eet.h"
+#include "Eet_private.h"
+
+#define MAGIC_EET_DATA_PACKET 0x4270ACE1
+
+struct _Eet_Connection
+{
+   Eet_Read_Cb  *eet_read_cb;
+   Eet_Write_Cb *eet_write_cb;
+   void         *user_data;
+
+   size_t        allocated;
+   size_t        size;
+   size_t        received;
+
+   void         *buffer;
+};
+
+EAPI Eet_Connection *
+eet_connection_new(Eet_Read_Cb  *eet_read_cb,
+                   Eet_Write_Cb *eet_write_cb,
+                   const void   *user_data)
+{
+   Eet_Connection *conn;
+
+   if (!eet_read_cb || !eet_write_cb)
+     return NULL;
+
+   conn = calloc(1, sizeof (Eet_Connection));
+   if (!conn)
+     return NULL;
+
+   conn->eet_read_cb = eet_read_cb;
+   conn->eet_write_cb = eet_write_cb;
+   conn->user_data = (void *)user_data;
+
+   return conn;
+} /* eet_connection_new */
+
+EAPI int
+eet_connection_received(Eet_Connection *conn,
+                        const void     *data,
+                        size_t          size)
+{
+   if ((!conn) || (!data) || (!size))
+     return size;
+
+   do {
+        size_t copy_size;
+
+        if (conn->size == 0)
+          {
+             const int *msg;
+             size_t packet_size;
+
+             if (size < sizeof (int) * 2)
+               break;
+
+             msg = data;
+             /* Check the magic */
+             if (ntohl(msg[0]) != MAGIC_EET_DATA_PACKET)
+               break;
+
+             packet_size = ntohl(msg[1]);
+             /* Message should always be under 64K */
+             if (packet_size > 64 * 1024)
+               break;
+
+             data = (void *)(msg + 2);
+             size -= sizeof (int) * 2;
+             if ((size_t)packet_size <= size)
+               {
+     /* Not a partial receive, go the quick way. */
+                   if (!conn->eet_read_cb(data, packet_size, conn->user_data))
+                     break;
+
+                   data = (void *)((char *)data + packet_size);
+                   size -= packet_size;
+
+                   conn->received = 0;
+                   continue;
+               }
+
+             conn->size = packet_size;
+             if (conn->allocated < conn->size)
+               {
+                  void *tmp;
+
+                  tmp = realloc(conn->buffer, conn->size);
+                  if (!tmp)
+                    break;
+
+                  conn->buffer = tmp;
+                  conn->allocated = conn->size;
+               }
+          }
+
+        /* Partial receive */
+        copy_size =
+          (conn->size - conn->received >=
+           size) ? size : conn->size - conn->received;
+        memcpy((char *)conn->buffer + conn->received, data, copy_size);
+
+        conn->received += copy_size;
+        data = (void *)((char *)data + copy_size);
+        size -= copy_size;
+
+        if (conn->received == conn->size)
+          {
+             size_t data_size;
+
+             data_size = conn->size;
+             conn->size = 0;
+             conn->received = 0;
+
+             /* Completed a packet. */
+             if (!conn->eet_read_cb(conn->buffer, data_size, conn->user_data))
+               {
+     /* Something goes wrong. Stop now. */
+                   size += data_size;
+                   break;
+               }
+          }
+     } while (size > 0);
+
+   return size;
+} /* eet_connection_received */
+
+static Eina_Bool
+_eet_connection_raw_send(Eet_Connection *conn,
+                         void           *data,
+                         int             data_size)
+{
+   int *message;
+
+   /* Message should never be above 64K */
+   if (data_size > 64 * 1024)
+     return EINA_FALSE;
+
+   message = alloca(data_size + sizeof (int) * 2);
+   message[0] = htonl(MAGIC_EET_DATA_PACKET);
+   message[1] = htonl(data_size);
+
+   memcpy(message + 2, data, data_size);
+
+   conn->eet_write_cb(message,
+                      data_size + sizeof (int) * 2,
+                      conn->user_data);
+   return EINA_TRUE;
+} /* _eet_connection_raw_send */
+
+EAPI Eina_Bool
+eet_connection_send(Eet_Connection      *conn,
+                    Eet_Data_Descriptor *edd,
+                    const void          *data_in,
+                    const char          *cipher_key)
+{
+   void *flat_data;
+   int data_size;
+   Eina_Bool ret = EINA_FALSE;
+
+   flat_data = eet_data_descriptor_encode_cipher(edd,
+                                                 data_in,
+                                                 cipher_key,
+                                                 &data_size);
+   if (!flat_data)
+     return EINA_FALSE;
+
+   if (_eet_connection_raw_send(conn, flat_data, data_size))
+     ret = EINA_TRUE;
+
+   free(flat_data);
+   return ret;
+} /* eet_connection_send */
+
+EAPI Eina_Bool
+eet_connection_node_send(Eet_Connection *conn,
+                         Eet_Node       *node,
+                         const char     *cipher_key)
+{
+   void *data;
+   int data_size;
+   Eina_Bool ret = EINA_FALSE;
+
+   data = eet_data_node_encode_cipher(node, cipher_key, &data_size);
+   if (!data)
+     return EINA_FALSE;
+
+   if (_eet_connection_raw_send(conn, data, data_size))
+     ret = EINA_TRUE;
+
+   free(data);
+   return ret;
+} /* eet_connection_node_send */
+
+EAPI void *
+eet_connection_close(Eet_Connection *conn,
+                     Eina_Bool      *on_going)
+{
+   void *user_data;
+
+   if (!conn)
+     return NULL;
+
+   if (on_going)
+     *on_going = conn->received == 0 ? EINA_FALSE : EINA_TRUE;
+
+   user_data = conn->user_data;
+
+   free(conn->buffer);
+   free(conn);
+
+   return user_data;
+} /* eet_connection_close */
+