From 13015f9a8d2b6b982d7d84e62943fbba15aee05a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ram=C5=ABnas=20Ma=C5=BEeikis?= Date: Wed, 22 May 2019 10:49:08 +0300 Subject: Protocol: switched files to C++ and did minor fixes. The code has a chance to compile now. No changes to actual build files yet. --- src/common/protocol.c | 153 ------------------------------------------------ src/common/protocol.cpp | 153 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 153 insertions(+), 153 deletions(-) delete mode 100644 src/common/protocol.c create mode 100644 src/common/protocol.cpp (limited to 'src/common') diff --git a/src/common/protocol.c b/src/common/protocol.c deleted file mode 100644 index dc0f532..0000000 --- a/src/common/protocol.c +++ /dev/null @@ -1,153 +0,0 @@ -/* - * 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 -#include -#include - -#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; -} 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 +#include +#include + +#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; +} -- cgit v1.2.3 From 3fa7dd642af57b8b138e9a0d674c2d9960ebedf4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ram=C5=ABnas=20Ma=C5=BEeikis?= Date: Wed, 22 May 2019 11:33:51 +0300 Subject: Protocol: fixed type errors. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Added const where appropriate to satisfy stricter type checking of C++. Signed-off-by: Ramūnas Mažeikis --- src/common/protocol.cpp | 28 ++++++++++++++-------------- src/common/protocol_private.h | 8 ++++++++ 2 files changed, 22 insertions(+), 14 deletions(-) (limited to 'src/common') diff --git a/src/common/protocol.cpp b/src/common/protocol.cpp index dc0f532..135be37 100644 --- a/src/common/protocol.cpp +++ b/src/common/protocol.cpp @@ -31,7 +31,7 @@ #include #include -#define READ_AS(from, type) (*(type*)(from)) +#define READ_AS(type, from) (*((type*)(from))) int push_data(cd_t connection, const char *data, enum tlv_type type) { @@ -59,7 +59,7 @@ int push_data(cd_t connection, const char *data, enum tlv_type type) return ret; } -static int push_string(cd_t connection, char *str) +static int push_string(cd_t connection, const char *str) { int ret = 0; size_t size = strlen(str); @@ -69,25 +69,25 @@ static int push_string(cd_t connection, char *str) return ret; } -static int push_fpi1(cd_t connection, char *num) +static int push_fpi1(cd_t connection, const 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) +static int push_timestamp(cd_t connection, const 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) +static int push_request(cd_t connection, const 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) +static int push_reply(cd_t connection, const char *data) { int ret = 0; size_t msglen = strlen(data + sizeof(msg_idx_t)); @@ -96,7 +96,7 @@ static int push_reply(cd_t connection, char *data) return ret; } -static int push_uuid(cd_t connection, char *data) +static int push_uuid(cd_t connection, const char *data) { return push_tlv_header(connection, UUID, sizeof(uuid_t)) | push_bytes(connection, data, sizeof(uuid_t)); @@ -110,7 +110,7 @@ size_t tlv_count(const struct packet_data * const packet) while (cursor < packet->packet_size) { cursor += sizeof(enum tlv_type); - length = READ_AS(packet->data + cursor, enum tlv_type); + length = READ_AS(enum tlv_type, packet->data + cursor); cursor += sizeof(size_t) + length; ret++; } @@ -121,7 +121,7 @@ size_t tlv_count(const struct packet_data * const packet) } size_t get_tlvs( const struct packet_data * const data, - const struct tlv *buf, + struct tlv *buf, size_t buf_size) { size_t tlvs_read = 0; @@ -139,15 +139,15 @@ size_t get_tlvs( const struct packet_data * const data, return tlvs_read; } -size_t parse_tlv(char *data, size_t cursor, struct tlv *t) +size_t parse_tlv(const char *data, size_t cursor, struct tlv *t) { - char *begin = data + cursor; + const char *begin = data + cursor; - t->type = READ_TLV_TYPE(data + cursor); + t->type = READ_AS(enum tlv_type, data + cursor); cursor += sizeof(enum tlv_type); - t->length += READ_SIZE_T(data + cursor); + t->length += READ_AS(enum tlv_type ,data + cursor); data += sizeof(size_t); - t->data = data + cursor; + t->data = (void*)data + cursor; return data + cursor - begin + 1UL; } diff --git a/src/common/protocol_private.h b/src/common/protocol_private.h index 7433ff0..d50a314 100644 --- a/src/common/protocol_private.h +++ b/src/common/protocol_private.h @@ -35,6 +35,14 @@ * */ 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. * -- cgit v1.2.3 From 27992079c057ea068a355e01365800d77b7ace13 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ram=C5=ABnas=20Ma=C5=BEeikis?= Date: Wed, 22 May 2019 14:56:59 +0300 Subject: Protocol: attempted to fix stupids. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Ramūnas Mažeikis --- src/common/protocol.c | 153 ++++++++++++++++++++++++++++++++++++++++++++++++ src/common/protocol.cpp | 153 ------------------------------------------------ 2 files changed, 153 insertions(+), 153 deletions(-) create mode 100644 src/common/protocol.c delete mode 100644 src/common/protocol.cpp (limited to 'src/common') diff --git a/src/common/protocol.c b/src/common/protocol.c new file mode 100644 index 0000000..43ff6a5 --- /dev/null +++ b/src/common/protocol.c @@ -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 +#include +#include + +#define READ_AS(type, from) (*((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, 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; +} + +static int push_fpi1(cd_t connection, const 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, const 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, const 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, 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; +} + +static int push_uuid(cd_t connection, const 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(enum tlv_type, packet->data + cursor); + 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, + 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(const char *data, size_t cursor, struct tlv *t) +{ + const char *begin = data + cursor; + + 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; + + return data + cursor - begin + 1UL; +} diff --git a/src/common/protocol.cpp b/src/common/protocol.cpp deleted file mode 100644 index 135be37..0000000 --- a/src/common/protocol.cpp +++ /dev/null @@ -1,153 +0,0 @@ -/* - * 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 -#include -#include - -#define READ_AS(type, from) (*((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, 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; -} - -static int push_fpi1(cd_t connection, const 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, const 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, const 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, 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; -} - -static int push_uuid(cd_t connection, const 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(enum tlv_type, packet->data + cursor); - 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, - 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(const char *data, size_t cursor, struct tlv *t) -{ - const char *begin = data + cursor; - - 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 = (void*)data + cursor; - - return data + cursor - begin + 1UL; -} -- cgit v1.2.3