Protocol: switched files to C++ and did minor fixes.

The code has a chance to compile now. No changes to actual build files
yet.

1 files changed, 153 insertions, 0 deletions

diff --git a/src/common/protocol.cpp b/src/common/protocol.cpp
new file mode 100644
index 0000000..dc0f532
--- /dev/null
+++ b/src/common/protocol.cpp
@@ -0,0 +1,153 @@
+/*
+ * Usurpataion --- clinet-server protocol implementation.
+ *
+ * Copyright (C) 2019 Ramūnas Mažeikis
+ *
+ * This program 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; version 2.1
+ * of the License.
+ *
+ * This program 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 program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/**
+ * Common parts of protocol implementation. Handling of anything that actually
+ * deals with connection descriptor has to be implemented by device and daemon
+ * separately.
+ */
+
+#include "protocol.h"
+#include "protocol_private.h"
+#include "net.h"
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define READ_AS(from, type)	(*(type*)(from))
+
+int push_data(cd_t connection, const char *data, enum tlv_type type)
+{
+	int ret = E_UNKNOWN_TYPE;
+	switch (type) {
+	case TEXT:
+		ret = push_string(connection, data);
+		break;
+	case FPI1:
+		ret = push_fpi1(connection, data);
+		break;
+	case TIMESTAMP:
+		ret = push_timestamp(connection, data);
+		break;
+	case REQUEST:
+		ret = push_request(connection, data);
+		break;
+	case REPLY:
+		ret = push_reply(connection, data);
+		break;
+	case UUID:
+		ret = push_uuid(connection, data);
+		break;
+	}
+	return ret;
+}
+
+static int push_string(cd_t connection, char *str)
+{
+	int ret = 0;
+	size_t size = strlen(str);
+
+	ret |= push_tlv_header(connection, TEXT, size);
+	ret |= push_bytes(connection, str, size);
+	return ret;
+}
+
+static int push_fpi1(cd_t connection, char *num)
+{
+	return		push_tlv_header(connection, FPI1, sizeof(fpi1_t))
+		|	push_bytes(connection, num, sizeof(fpi1_t));
+}
+
+static int push_timestamp(cd_t connection, char *data)
+{
+	return		push_tlv_header(connection, TIMESTAMP, sizeof(time_t))
+		|	push_bytes(connection, data, sizeof(time_t));
+}
+
+static int push_request(cd_t connection, char *data)
+{
+	return          push_tlv_header(connection, REQUEST, sizeof(msg_idx_t))
+		|       push_bytes(connection, data, sizeof(msg_idx_t));
+}
+
+static int push_reply(cd_t connection, char *data)
+{
+	int ret = 0;
+	size_t msglen = strlen(data + sizeof(msg_idx_t));
+	ret |= push_tlv_header(connection, REPLY, msglen + sizeof(msg_idx_t));
+	ret |= push_bytes(connection, data, msglen);
+	return ret;
+}
+
+static int push_uuid(cd_t connection, char *data)
+{
+	return		push_tlv_header(connection, UUID, sizeof(uuid_t))
+		|	push_bytes(connection, data, sizeof(uuid_t));
+}
+
+size_t tlv_count(const struct packet_data * const packet)
+{
+	size_t cursor = 0;
+	size_t length = 0;
+	size_t ret = 0;
+
+	while (cursor < packet->packet_size) {
+		cursor += sizeof(enum tlv_type);
+		length = READ_AS(packet->data + cursor, enum tlv_type);
+		cursor += sizeof(size_t) + length;
+		ret++;
+	}
+	if (cursor != packet->packet_size) {
+		errno = E_TLV_OVERFLOW;
+	}
+	return ret;
+}
+
+size_t get_tlvs(        const struct packet_data * const data,
+			const struct tlv *buf,
+			size_t buf_size)
+{
+	size_t tlvs_read = 0;
+	size_t cursor = 0;
+
+	while (cursor < data->packet_size && tlvs_read <= buf_size) {
+		cursor += parse_tlv(data->data, cursor, buf + tlvs_read);
+		tlvs_read++;
+	}
+
+	if (cursor > data->packet_size) {
+		errno = E_TLV_OVERFLOW;
+	}
+
+	return tlvs_read;
+}
+
+size_t parse_tlv(char *data, size_t cursor, struct tlv *t)
+{
+	char *begin = data + cursor;
+
+	t->type = READ_TLV_TYPE(data + cursor);
+	cursor += sizeof(enum tlv_type);
+	t->length += READ_SIZE_T(data + cursor);
+	data += sizeof(size_t);
+	t->data = data + cursor;
+
+	return data + cursor - begin + 1UL;
+}