add helper functions for buffer read & write

src/util/inc/tbuffer.h

+/*
+ * Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <setjmp.h>
+
+#ifndef TDENGINE_TBUFFER_H
+#define TDENGINE_TBUFFER_H
+
+
+/*
+SBuffer can be used to read or write a buffer, but cannot be used for both
+read & write at a same time.
+Read example:
+   SBuffer rbuf;
+   if (tbufBeginOperation(&rbuf) != 0) {
+      // handling errors
+   }
+   tbufInitRead(&rbuf, data, 1024);
+   int32_t a = tbufReadInt32(&rbuf);
+   // other read functions
+
+Write example:
+   SBuffer wbuf;
+   if (tbufBeginOperation(&wbuf) != 0) {
+      // handling errors
+   }
+   tbufInitWrite(&wbuf, 1024);
+   tbufWriteInt32(&wbuf, 10);
+   // other write functions
+   size_t size = tbufGetSize(&wbuf);
+   char* data = tbufGetBuffer(&wbuf, true);
+   tbufUninitWrite(&wbuf);
+*/
+typedef struct {
+  jmp_buf jb;
+  char* buf;
+  size_t pos;
+  size_t size;
+} SBuffer;
+
+
+// common functions can be used in both read & write
+#define tbufBeginOperation(buf) setjmp((buf)->jb)
+size_t tbufTell(SBuffer* buf);
+size_t tbufSeekTo(SBuffer* buf, size_t pos);
+size_t tbufSkip(SBuffer* buf, size_t size);
+
+
+// basic read functions
+void tbufInitRead(SBuffer* buf, void* data, size_t size);
+char* tbufRead(SBuffer* buf, size_t size);
+void tbufReadToBuffer(SBuffer* buf, void* dst, size_t size);
+const char* tbufReadString(SBuffer* buf, size_t* len);
+size_t tbufReadToString(SBuffer* buf, char* dst, size_t size);
+
+
+// basic write functions
+void tbufInitWrite(SBuffer* buf, size_t size);
+void tbufEnsureCapacity(SBuffer* buf, size_t size);
+char* tbufGetResult(SBuffer* buf, bool takeOver);
+void tbufUninitWrite(SBuffer* buf);
+void tbufWrite(SBuffer* buf, const void* data, size_t size);
+void tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size);
+void tbufWriteStringLen(SBuffer* buf, const char* str, size_t len);
+void tbufWriteString(SBuffer* buf, const char* str);
+
+
+// read & write function for primitive types
+#ifndef TBUFFER_DEFINE_OPERATION
+#define TBUFFER_DEFINE_OPERATION(type, name) \
+  type tbufRead##name(SBuffer* buf); \
+  void tbufWrite##name(SBuffer* buf, type data); \
+  void tbufWrite##name##At(SBuffer* buf, size_t pos, type data);
+#endif
+
+TBUFFER_DEFINE_OPERATION( bool, Bool )
+TBUFFER_DEFINE_OPERATION( char, Char )
+TBUFFER_DEFINE_OPERATION( int8_t, Int8 )
+TBUFFER_DEFINE_OPERATION( uint8_t, Unt8 )
+TBUFFER_DEFINE_OPERATION( int16_t, Int16 )
+TBUFFER_DEFINE_OPERATION( uint16_t, Uint16 )
+TBUFFER_DEFINE_OPERATION( int32_t, Int32 )
+TBUFFER_DEFINE_OPERATION( uint32_t, Uint32 )
+TBUFFER_DEFINE_OPERATION( int64_t, Int64 )
+TBUFFER_DEFINE_OPERATION( uint64_t, Uint64 )
+TBUFFER_DEFINE_OPERATION( float, Float )
+TBUFFER_DEFINE_OPERATION( double, Double )
+
+#endif
\ No newline at end of file

src/util/src/tbuffer.c

+/*
+ * Copyright (c) 2020 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define TBUFFER_DEFINE_OPERATION(type, name) \
+  type tbufRead##name(SBuffer* buf) {            \
+    type ret;                                    \
+    tbufReadToBuffer(buf, &ret, sizeof(type));   \
+    return ret;                                  \
+  }\
+  void tbufWrite##name(SBuffer* buf, type data) {\
+    tbufWrite(buf, &data, sizeof(data));\
+  }\
+  void tbufWrite##name##At(SBuffer* buf, size_t pos, type data) {\
+    tbufWriteAt(buf, pos, &data, sizeof(data));\
+  }
+
+#include "../inc/tbuffer.h"
+
+
+////////////////////////////////////////////////////////////////////////////////
+// common functions
+
+size_t tbufTell(SBuffer* buf) {
+  return buf->pos;
+}
+
+size_t tbufSeekTo(SBuffer* buf, size_t pos) {
+  if (pos > buf->size) {
+    longjmp(buf->jb, 1);
+  }
+  size_t old = buf->pos;
+  buf->pos = pos;
+  return old;
+}
+
+size_t tbufSkip(SBuffer* buf, size_t size) {
+  return tbufSeekTo(buf, buf->pos + size);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// read functions
+
+void tbufInitRead(SBuffer* buf, void* data, size_t size) {
+  buf->buf = (char*)data;
+  buf->pos = 0;
+  // empty buffer is not an error, but read an empty buffer is
+  buf->size = (data == NULL) ? 0 : size;
+}
+
+char* tbufRead(SBuffer* buf, size_t size) {
+  char* ret = buf->buf + buf->pos;
+  tbufSkip(buf, size);
+  return ret;
+}
+
+void tbufReadToBuffer(SBuffer* buf, void* dst, size_t size) {
+  assert(dst != NULL);
+  // always using memcpy, leave optimization to compiler
+  memcpy(dst, tbufRead(buf, size), size);
+}
+
+const char* tbufReadString(SBuffer* buf, size_t* len) {
+  uint16_t l = tbufReadUint16();
+  char*    ret = buf->buf + buf->pos;
+  tbufSkip(buf, l + 1);
+  ret[l] = 0;  // ensure the string end with '\0'
+  if (len != NULL) {
+    *len = l;
+  }
+  return ret;
+}
+
+size_t tbufReadToString(SBuffer* buf, char* dst, size_t size) {
+  size_t      len;
+  const char* str = tbufReadString(buf, &len);
+  if (len >= size) len = size - 1;
+  memcpy(dst, str, len);
+  dst[len] = 0;
+  return len;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// write functions
+
+void tbufEnsureCapacity(SBuffer* buf, size_t size) {
+  size += buf->pos;
+  if (size > buf->size) {
+    char*  nbuf = NULL;
+    size_t nsize = size + buf->size;
+    nbuf = realloc(buf->buf, nsize);
+    if (nbuf == NULL) {
+      longjmp(buf->jb, 2);
+    }
+    buf->buf = nbuf;
+    buf->size = nsize;
+  }
+}
+
+void tbufInitWrite(SBuffer* buf, size_t size) {
+    buf->buf = NULL;
+    buf->pos = 0;
+    buf->size = 0;
+    tbufEnsureCapacity(buf, size);
+}
+
+char* tbufGetResult(SBuffer* buf, bool takeOver) {
+		char* ret = buf->buf;
+		if (takeOver) {
+      buf->pos = 0;
+      buf->size = 0;
+			buf->buf = NULL;
+    }
+		return ret;
+}
+
+void tbufUninitWrite(SBuffer* buf) {
+    free(buf->buf);
+}
+
+void tbufWrite(SBuffer* buf, const void* data, size_t size) {
+  tbufEnsureCapacity(size);
+  memcpy(buf->buf + buf->pos, data, size);
+  buf->pos += size;
+}
+
+void tbufWriteAt(SBuffer* buf, size_t pos, const void* data, size_t size) {
+  // this function can only be called to fill the gap on previous writes,
+  // so 'pos + size <= buf->pos' must be true
+  if (pos + size > buf->pos) {
+    longjmp(buf->jb, 3);
+  }
+  memcpy(buf->buf + pos, data, size);
+}
+
+void tbufWriteStringLen(SBuffer* buf, const char* str, size_t len) {
+  if (len > 0xffff) {
+    longjmp(buf->jb , 4);
+  }
+  tbufWriteUint16(buf, (uint16_t)len);
+  tbufWrite(buf, str, len + 1);
+}
+
+void tbufWriteString(SBuffer* buf, const char* str) {
+  tbufWriteStringLen(buf, str, strlen(str));
+}