From 28b26ca86cf18947d6d9543ad753ef112ff4da89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ram=C5=ABnas=20Ma=C5=BEeikis?= Date: Wed, 22 May 2019 20:33:08 +0300 Subject: Protocol: interface redesign. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Every function is a stub now. Reimplementaion coming up. Signed-off-by: Ramūnas Mažeikis --- src/common/protocol.c | 102 ++++++++++------------------- src/common/protocol_private.h | 122 +++-------------------------------- src/device/protocol_device.c | 121 ---------------------------------- src/device/protocol_device_private.h | 59 ----------------- 4 files changed, 42 insertions(+), 362 deletions(-) delete mode 100644 src/device/protocol_device.c delete mode 100644 src/device/protocol_device_private.h (limited to 'src') diff --git a/src/common/protocol.c b/src/common/protocol.c index 54d51f6..58a70f6 100644 --- a/src/common/protocol.c +++ b/src/common/protocol.c @@ -33,121 +33,85 @@ #define READ_AS(type, from) (*((type*)(from))) -int push_data(cd_t connection, const char *data, enum tlv_type type) +int push_data(enum tlv_type type) { - int ret = E_UNKNOWN_TYPE; + int ret = 0; 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; + default: + ret = E_UNKNOWN_TYPE; } return ret; } -static int push_string(cd_t connection, const char *str) +static int push_string(const 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; + return 0; } -static int push_fpi1(cd_t connection, const char *num) +static int push_fpi1(const char *num) { - return push_tlv_header(connection, FPI1, sizeof(fpi1_t)) - | push_bytes(connection, num, sizeof(fpi1_t)); + return 0; } -static int push_timestamp(cd_t connection, const char *data) +static int push_timestamp(const char *data) { - return push_tlv_header(connection, TIMESTAMP, sizeof(time_t)) - | push_bytes(connection, data, sizeof(time_t)); + return 0; } -static int push_request(cd_t connection, const char *data) +static int push_request(const char *data) { - return push_tlv_header(connection, REQUEST, sizeof(msg_idx_t)) - | push_bytes(connection, data, sizeof(msg_idx_t)); + return 0; } -static int push_reply(cd_t connection, const char *data) +static int push_reply(const 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; + return 0; } -static int push_uuid(cd_t connection, const char *data) +static int push_uuid(const char *data) { - return push_tlv_header(connection, UUID, sizeof(uuid_t)) - | push_bytes(connection, data, sizeof(uuid_t)); + return 0; } 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(enum tlv_type, packet->data + cursor); - cursor += sizeof(size_t) + length; - ret++; - } - if (cursor != packet->packet_size) { - errno = E_TLV_OVERFLOW; - } - return ret; + return 0; } -size_t get_tlvs( const struct packet_data * const data, - struct tlv *buf, - size_t buf_size) +size_t parse_tlv(const char *data, size_t cursor, struct tlv *t) { - size_t tlvs_read = 0; - size_t cursor = 0; + return 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; +int clear_data() +{ + return 0; } -size_t parse_tlv(const char *data, size_t cursor, struct tlv *t) +static int push_bytes(const char *data, size_t size) { - const char *begin = data + cursor; + return 0; +} - t->type = READ_AS(enum tlv_type, data + cursor); - cursor += sizeof(enum tlv_type); - t->length += READ_AS(enum tlv_type ,data + cursor); - data += sizeof(size_t); - t->data = data + cursor; +static int push_tlv_header(enum tlv_type type, size_t size) +{ + return 0; +} - return data + cursor - begin + 1UL; +int get_tlv(struct tlv_parser *parser, struct tlv *ret) +{ + return 0; } diff --git a/src/common/protocol_private.h b/src/common/protocol_private.h index d50a314..5228afd 100644 --- a/src/common/protocol_private.h +++ b/src/common/protocol_private.h @@ -1,115 +1,11 @@ -/* - * Usurpataion --- server-client protocol private interface. - * - * 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 - */ +#ifndef PROTOCOL_PRIVATE_H +#define PROTOCOL_PRIVATE_H -#ifndef PROTOCOL_H_PRIVATE -#define PROTOCOL_H_PRIVATE +static int push_string(const char *str); +static int push_fpi1(const char *num); +static int push_timestamp(const char *data); +static int push_request(const char *data); +static int push_reply(const char *data); +static int push_uuid(const char *data); -#include "utils.h" - -/** - * Returns the amount of tlv's int a packet. - * - * If a tlv reports length that goes beyond the end of a packet, errno is set - * to TLV_OVERFLOW. To check this, set errno to 0 first. - * - * @param packet data parsed from a packet. Function cannot use raw packets. - * - * @return Amount of tlv's in a packet. - * */ -size_t tlv_count(const struct packet_data * const packet_data); - -/** - * Pushes bytes to outgoing packet and adjusts the offset accordingly. - * - * Returns E_PACKET_OVERFLOW, if no more bytes can fit into the packet. - */ - -int push_bytes(cd_t cd, const char *data, size_t size); - -/** - * Parses tlv's from packet data and writes them to a buffer of given size. - * - * Returns how many tlv's were actually parsed. - * - * To check for errors, set errno to 0 and check after calling. - * - * Not yet implemented. - * - * @param data Data from network packet - * @param buf Buffer to store parsed tlv's - * @param buf_size Size of buffer used to store tlv's - * - * @return Number of tlv's actually parsed. Greter than or equal to buffer - * size, if an error occurs. - * */ -size_t get_tlvs( const struct packet_data * const data, - const struct tlv *buf, - size_t buf_size); - -/** Takes a null-terminated string and appends it to the next outgoing packet. - * - * @return Returns 0 on success. Otherwise: E_PACKET_OVERFLOW. - * - * */ -int push_string(cd_t connection, char *str); - -/** Reinterprets char * as fpi1_t * and appends it to the outgoing packet as a - * tlv. - */ -int push_fpi1(cd_t connection, char *num); - -/** Reinterprets char * as time_t * and appends it to the outgoing packet as a - * tlv. - */ -int push_timestamp(cd_t connection, char *data); - -/** - * Pushes a request for daemon to repeat a message identified by a msg_index_t. - * - * @param data Pointer to a msg_index_t. - * - * @return 0 on success or E_PACKET_OVERFLOW, if not enough space is available - * to push all the data. - */ -int push_request(cd_t connection, char *data); - -/** - * Pushes a message to the outgoing packet buffer as a reply. A reply is just - * a null terminated string. - * - * @param data msg_idx_t representing sequence number since beggining of - * connection and a null-terminated string. - * - * @return On success --- 0 or E_PACKET_OVERFLOW, if not enough buffer is - * available. - */ -int push_reply(cd_t connection, char *data); - -/** Reinterprets char * as uuid_t * and appends it to the outgoing packet as a - * tlv. - */ -int push_uuid(cd_t connection, char *data); - -/* Appends tlv_type and size of data to a packet effectively creating a tlv - * header. - */ -int push_tlv_header(cd_t connection, enum tlv_type type, size_t size); - -#endif /* PROTOCOL_H_PRIVATE */ +#endif /* PROTOCOL_PRIVATE_H */ \ No newline at end of file diff --git a/src/device/protocol_device.c b/src/device/protocol_device.c deleted file mode 100644 index d5ec62d..0000000 --- a/src/device/protocol_device.c +++ /dev/null @@ -1,121 +0,0 @@ -/* - * Usurpation – wearable device udp packet handling - * - * 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 - */ - -#include -#include -#include -#include "net.h" -#include "protocol.h" -#include "protocol_private.h" -#include "protocol_device_private.h" -#include "settings.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; -} - -int clear_data(cd_t cd) -{ - int ret = 0; - if (cd >= MAX_CONNECTIONS) { - ret = E_IVALID_DESCRIPTOR; - } else { - connection.inp_crs = 0; - } - return ret; -} - -static int push_bytes(cd_t cd, const 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 flush_data(cd_t cd) -{ - return 0; -} - -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_private.h b/src/device/protocol_device_private.h deleted file mode 100644 index 6754ecf..0000000 --- a/src/device/protocol_device_private.h +++ /dev/null @@ -1,59 +0,0 @@ -#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 { - /** - * Initially 0, non-zero when connection is open, 0 when connection - * is closed again. - */ - int is_live; - - /** Network descriptor that maps to daemon */ - int nd; - - /** Time last packet was reveived */ - time_t last_packet_sec; - - /** Incoming packet buffer */ - char inp_buf[MAX_PACKET_SIZE_IN]; - - /** Incoming packet cursor */ - size_t inp_crs; - - /** Outgoing packet buffer */ - char outp_buf[MAX_PACKET_SIZE_OUT]; - - /** 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 -- cgit v1.2.3