2 files changed, 87 insertions, 16 deletions

diff --git a/proto/puzbusv1.c b/proto/puzbusv1.c
index 3ff7c63..73deda5 100644
--- a/proto/puzbusv1.c
+++ b/proto/puzbusv1.c
@@ -1,25 +1,48 @@
 #include <mpack.h>
 #include <stdio.h>
 
+// MIN() macro
+#include <sys/param.h>
+// TODO: check if this works on pico as well
+
 #include "puzbusv1.h"
 
-int pb_read(struct pb_msg* target, char* buf, size_t buf_sz) {
+int pb_read(struct pb_msg * target, const char * buf, size_t buf_sz) {
+	// a new reader is used per buffer block passed to this function
 	mpack_reader_t reader;
-	printf("read %lu bytes...\n", buf_sz);
-
 	mpack_reader_init_data(&reader, buf, buf_sz);
 
-	uint16_t address = mpack_expect_u16(&reader);
-	char data_buf[80];
-	size_t data_size = mpack_expect_bin_buf(&reader, data_buf, sizeof(data_buf));
-
-	printf("0x%02x\n", address);
-	printf("\"%.*s\"\n", data_size, data_buf);
+	// at start of message
+	if (target->_rdata == 0) {
+		// NOTE: The entire start of a message needs to be readable from the buffer
+		// at this point. When target->addr can be read and target->length is past
+		// the end of the current buffer block, this function will crash and burn.
+		// This is a highly unlikely scenario, as pb_read is called for each chunk
+		// of a TCP frame, and frames (should) include only one puzzle bus message.
+		// The check here is kind of optional.
+		if (buf_sz < 4) return -1;
+
+		target->addr = mpack_expect_u16(&reader);
+		target->length = target->_rdata = mpack_expect_bin(&reader);
+		target->data = (char *) malloc(target->length);
+	}
+
+	// continue reading chunks of target->data until the amount of bytes
+	// specified in target->length
+	size_t to_read = MIN(mpack_reader_remaining(&reader, NULL), target->_rdata);
+	char * data = target->data + target->length - target->_rdata;
+	mpack_read_bytes(&reader, data, to_read);
+	target->_rdata -= to_read;
+
+	// if rdata = 0, the message was completely read
+	return target->_rdata;
+}
 
-	return 0;
+void pb_read_reset(struct pb_msg * target) {
+	target->_rdata = 0;
 }
 
-int pb_write(struct pb_msg* target, char** buf, size_t* buf_sz) {
+bool pb_write(const struct pb_msg * target, char ** buf, size_t * buf_sz) {
 	mpack_writer_t writer;
 	mpack_writer_init_growable(&writer, buf, buf_sz);
 
diff --git a/proto/puzbusv1.h b/proto/puzbusv1.h
index 116dbf9..0985b2b 100644
--- a/proto/puzbusv1.h
+++ b/proto/puzbusv1.h
@@ -7,14 +7,62 @@
 extern "C" {
 #endif
 
+/** \brief Puzzle bus message (v1) */
 struct pb_msg {
-	uint16_t addr;
-	char* data;
-	size_t length;
+	uint16_t addr; //!< I^2^C address
+	char * data;   //!< message content
+	size_t length; //!< message size
+	size_t _rdata; //!< \private remaining bytes to read until message is complete
 };
 
-int pb_read(struct pb_msg* target, char* buf, size_t buf_sz);
-int pb_write(struct pb_msg* target, char** buf, size_t* buf_sz);
+/**
+ * \brief Read chunk of input stream, and store resulting message in \p target
+ *
+ * This function is called for each chunk of data from an input stream, and
+ * will parse the next puzzle bus message into \p target. The input stream is
+ * assumed to only contain messages encoded by \p pb_write()
+ *
+ * \param target  pointer to struct that will contain the finished message data
+ * \param buf     pointer to input stream data chunk
+ * \param buf_sz  size of \p buf
+ *
+ * \returns Integer representing amount of bytes required to finish message, or
+ * -1 if the message header could not be read. If this function returns 0, the
+ *  message in \p target is complete.
+ *
+ * \note target->data will automatically be allocated by this function, even if
+ * the message is not fully parsed. This variable must be `free()`d by the
+ * caller after each complete message to prevent memory leaks.
+ */
+int pb_read(struct pb_msg * target, const char * buf, size_t buf_sz);
+
+/**
+ * \brief reset the remaining message data counter
+ *
+ * Calling this function has the effect of forcing \c pb_read() to parse the
+ * next buffer chunk as the start of a new message. This function may be called
+ * before reading a TCP frame's data to mitigate any synchronization issues
+ * arising from earlier corrupt or otherwise malformed messages.
+ */
+void pb_read_reset(struct pb_msg * target);
+
+/**
+ * \brief Allocate and write a msgpack-formatted message to \p buf
+ *
+ * This function allocates a buffer large enough to fit the message specified
+ * in \p target, and encodes the data in \p target in a format that can be
+ * decoded later using \p pb_read()
+ *
+ * \param target  pointer to struct that contains the message data
+ * \param buf     pointer to \c char* that will contain the formatted message
+ * \param buf_sz  pointer to \c size_t that will represent the final size of \p buf
+ *
+ * \returns boolean true if a the message could be encoded successfully, false
+ * if there was some kind of error
+ *
+ * \note the pointer stored in \p buf must be `free()`d by the caller afterwards
+ */
+bool pb_write(const struct pb_msg * target, char ** buf, size_t * buf_sz);
 
 #ifdef __cplusplus
 }