Protocol: implementation of device-side protocol.

Parts of protocol specific for device are implementepd to reflect the
fact that the device is a client. This effectively means that device
gets a single connection only and severe memory restrictions about
which the daemon might get informed about in the future.

Signed-off-by: Ramūnas Mažeikis <ramunasnezinomas@gmail.com>

3 files changed, 111 insertions, 40 deletions

diff --git a/src/device/protocol_device.c b/src/device/protocol_device.c
new file mode 100755
index 0000000..3b3d8c8
--- /dev/null
+++ b/src/device/protocol_device.c
@@ -0,0 +1,86 @@
+#include "net.h"
+#include "protocol.h"
+#include "protocol_private.h"
+#include "protocol_device_private.h"
+#include "settings.h"
+#include <time.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define READ_AS(type, from)	(*((type*)(from)))
+
+static struct connection_t connection;
+
+cd_t protocol_init(void)
+{
+	connection.is_live = 1;
+	connection.nd = net_init(setting_port());
+	return 0;
+}
+
+static int push_bytes(cd_t cd, char *data, size_t size)
+{
+	int ret = 0;
+
+	if (cd >= MAX_CONNECTIONS) {
+		ret = E_IVALID_DESCRIPTOR;
+	} else if (connection.outp_crs + size >= sizeof(connection.outp_buf)) {
+		ret = E_PACKET_OVERFLOW;
+	} else {
+		memcpy(connection.outp_buf, data, size);
+		connection.outp_crs += size;
+	}
+	return ret;
+}
+
+static int push_tlv_header(cd_t cd, enum tlv_type type, size_t size)
+{
+	int ret = 0;
+
+	if (cd >= MAX_CONNECTIONS) {
+		errno = E_IVALID_DESCRIPTOR;
+		ret = NULL;
+	} else if (connection.outp_crs >= MAX_PACKET_SIZE_IN) {
+		errno = E_TLV_OVERFLOW;
+		ret = NULL;
+	} else {
+		READ_AS(enum tlv_type, connection.outp_buf + connection.outp_crs)
+			= type;
+		connection.outp_crs += sizeof(enum tlv_type);
+		READ_AS(size_t, connection.outp_buf + connection.outp_crs) = size;
+		connection.outp_crs += sizeof(size_t);
+	}
+	return ret;
+}
+
+struct tlv * get_tlv(cd_t cd)
+{
+	struct tlv *ret = &connection.next_tlv;
+	size_t offset = connection.inp_crs;
+	char *data = connection.inp_buf;
+
+	if (cd >= MAX_CONNECTIONS) {
+		errno = E_IVALID_DESCRIPTOR;
+		ret = NULL;
+	} else if (offset >= MAX_PACKET_SIZE_IN) {
+		errno = E_TLV_OVERFLOW;
+		ret = NULL;
+	} else {
+		ret->type = READ_AS(enum tlv_type, data + offset);
+		offset += sizeof(enum tlv_type);
+		ret->length = READ_AS(size_t, data + offset);
+		offset += sizeof(size_t);
+		ret->data = data + offset;
+		connection.inp_crs = offset;
+	}
+	return ret;
+}
+
+
+int get_last_data(cd_t cd)
+{
+	if (cd >= MAX_CONNECTIONS) {
+		return E_IVALID_DESCRIPTOR;
+	}
+	net_getlastdata(connection.nd, connection.inp_buf);
+}
diff --git a/src/device/protocol_device.ino b/src/device/protocol_device.ino
deleted file mode 100755
index 778196d..0000000
--- a/src/device/protocol_device.ino
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "protocol.h"
-#include "protocol_private.h"
-#include "protocol_device_private.h"
-#include <ESP8266WiFi.h>
-#include <time.h>
-#include <stdlib.h>
-
-static struct connection_t connection;
-
-static int push_bytes(cd_t cd, char *data, size_t size)
-{
-        int ret = 0;
-
-        if (cd >= MAX_CONNECTIONS) {
-                ret = E_IVALID_DESCRIPTOR;
-        } else if (connection.outp_crs + size >= sizeof(connection.outp_buf)) {
-                ret = E_PACKET_OVERFLOW;
-        } else {
-
-        }
-        return ret;
-}
-
-static int push_tlv_header(cd_t connection, enum tlv_type type, size_t size)
-{
-        return 0;
-}
-
-struct tlv * get_tlv()
-{
-        return NULL;
-}
-
-
-void get_last_data(cd_t connection)
-{
-
-}
diff --git a/src/device/protocol_device_private.h b/src/device/protocol_device_private.h
index 0fb46c7..29ff567 100755
--- a/src/device/protocol_device_private.h
+++ b/src/device/protocol_device_private.h
@@ -1,11 +1,28 @@
 #ifndef PROTOCOL_DEVICE_PRIVATE_H
 #define PROTOCOL_DEVICE_PRIVATE_H
 
+#include "net.h"
+
 #define MAX_PACKET_SIZE_OUT     (64)
+
+/* Maximum size of packet that can fit into the packet buffer. UDP can carry
+ * bigger packets but memory is hard to come by and more won't be needed
+ * anyway.
+ * */
 #define MAX_PACKET_SIZE_IN	(512)
+
+/**
+ * Device only gets one connection. Because daemon.
+ */
 #define MAX_CONNECTIONS		(1UL)
 
 /**
+ * Error which says that writing any more to packet buffer will overflow
+ * outgoing buffer.
+ */
+#define E_PACKET_OVERFLOW	(1 << 0)
+
+/**
  * Device's view of connection to daemon.
  */
 struct connection_t {
@@ -15,8 +32,8 @@ struct connection_t {
 	 */
         int is_live;
 
-        /** Daemon IP adress */
-        IPAddress address;
+	/** Network descriptor that maps to daemon */
+	int nd;
 
         /** Time last packet was reveived */
         time_t last_packet_sec;
@@ -32,6 +49,12 @@ struct connection_t {
 
         /** Outgoing packet cursor */
         size_t outp_crs;
+
+	/**
+	 * Next tlv to be returned via get_tlv. NULL initially and after last
+	 * element.
+	 * */
+	struct tlv next_tlv;
 };
 
 #endif /* PROTOCOL_DEVICE_PRIVATE_H */
\ No newline at end of file