summaryrefslogtreecommitdiff
path: root/libbuf/buf.c
diff options
context:
space:
mode:
Diffstat (limited to 'libbuf/buf.c')
-rw-r--r--libbuf/buf.c534
1 files changed, 534 insertions, 0 deletions
diff --git a/libbuf/buf.c b/libbuf/buf.c
new file mode 100644
index 0000000..83457e9
--- /dev/null
+++ b/libbuf/buf.c
@@ -0,0 +1,534 @@
+#include "buf.h"
+
+/*
+bbuf* bbuf_new(int size)
+{
+ bbuf *ret = NULL;
+ ret = malloc(sizeof(bbuf));
+ if (!ret)
+ {
+ return NULL;
+ }
+ ret->buf = malloc(size);
+ if (!ret->buf)
+ {
+ free(ret);
+ return NULL;
+ }
+ ret->buf_size = size;
+ ret->size = 0;
+ return ret;
+}
+
+//set buffer value
+int bbuf_set(bbuf *a, char *val, int size)
+{
+ if (!a)
+ return -1;
+
+ if (!a->buf)
+ return -1;
+
+ if (size<0)
+ return -1;
+
+ if (size > a->buf_size)
+ {
+ a->size = a->buf_size;
+ } else
+ {
+ a->size = size;
+ }
+ memcpy(a->buf, val, a->size);
+
+ return a->size;
+}
+
+
+//get copy of buffer
+bbuf *bbuf_copy(bbuf *buf)
+{
+ bbuf *ret = NULL;
+
+ if (!buf)
+ {
+ return NULL;
+ }
+
+ ret = malloc(sizeof(bbuf));
+ memcpy(ret, buf, sizeof(bbuf));
+ ret->buf = malloc(buf->buf_size);
+ if (!ret->buf)
+ {
+ free(ret);
+ return NULL;
+ }
+ memcpy(ret->buf, buf->buf, buf->buf_size);
+ ret->size = buf->size;
+ ret->buf_size = buf->buf_size;
+
+ return ret;
+}
+
+
+//get buffer from buffer, mapped pointer, plz dont modify
+int bbuf_get(bbuf *buf, char **val, int *size)
+{
+ if (!buf)
+ {
+ return -1;
+ }
+
+ if (!val)
+ {
+ return -1;
+ }
+
+ *size = buf->size;
+ *val = buf->buf;
+
+ return 0;
+}
+
+
+//resize buffer
+int bbuf_realloc(bbuf *buf, int size)
+{
+ int ret = -1;
+ char *ptr=NULL;
+ if (!buf)
+ return -1;
+ if (size < 0)
+ return -1;
+ if (buf->buf_size == size)
+ return size;
+
+ ret = buf->buf_size;
+ ptr = realloc(buf->buf, size);
+ if (ptr != NULL)
+ {
+ buf->buf = ptr;
+ ret = size;
+ }
+
+ return ret;
+}
+
+int bbuf_reduce(bbuf *buf)
+{
+ printf("Not implemented\n");
+ return -1;
+}
+
+
+//increase buffer for size
+int bbuf_inc(bbuf *a, char *b, int size)
+{
+ printf("Not implemented\n");
+ return -1;
+}
+
+
+//decrease buffer for size
+int bbuf_dec(bbuf *a, char *b, int size)
+{
+ printf("Not implemented\n");
+ return -1;
+}
+
+int bbuf_set_max(bbuf *buf)
+{
+ if (buf == NULL)
+ {
+ return -1;
+ }
+
+ buf->buf_size = buf->size;
+ return 0;
+}
+
+
+int bbuf_memset(bbuf *buf, char c)
+{
+ if (buf == NULL)
+ {
+ return -1;
+ }
+ memset(buf->buf, c, buf->size);
+ return 0;
+}
+
+int bbuf_concat(bbuf *a, bbuf *b)
+{
+ printf("Not implemented\n");
+ return -1;
+}
+
+int bbuf_size(bbuf *a)
+{
+ if (a == NULL)
+ {
+ return -1;
+ }
+
+ //return used size
+ return a->buf_size;
+}
+
+int bbuf_print(bbuf *a)
+{
+ int i;
+
+ if (NULL == a)
+ {
+ return -1;
+ }
+
+ for (i=0;i<a->buf_size;i++)
+ {
+ char ch = a->buf[i];
+ if (isalpha(ch))
+ {
+ printf("%c",ch);
+ } else
+ {
+ printf(".");
+ }
+ }
+
+ return 0;
+}
+
+//free buffer
+void bbuf_free(bbuf *buf)
+{
+ if (buf == NULL)
+ {
+ return;
+ }
+ if (buf->buf != NULL)
+ {
+ memset(buf->buf, 0, buf->buf_size);
+ free(buf->buf);
+ buf->buf = NULL;
+ memset(buf, 0, sizeof(bbuf));
+ free(buf);
+ buf = NULL;
+ }
+}
+*/
+
+Buf::Buf(int size)
+{
+ this->buf = (char *)malloc(size);
+ if (!this->buf)
+ {
+ //put error here
+ }
+
+ this->buf_size = size;
+ this->cur_size = 0;
+}
+
+Buf::~Buf()
+{
+ if (this->buf != NULL)
+ {
+ ::memset(this->buf, 0, this->buf_size);
+ free(this->buf);
+ this->buf = NULL;
+ }
+}
+
+int Buf::set(char *val, int size)
+{
+ if (!val)
+ {
+ return -1;
+ }
+
+ if (size<0)
+ {
+ return -1;
+ }
+
+ if (size > this->buf_size)
+ {
+ this->cur_size = this->buf_size;
+ } else
+ {
+ this->cur_size = size;
+ }
+ memcpy(this->buf, val, this->cur_size);
+
+ return this->cur_size;
+}
+
+int Buf::set(char *val)
+{
+ int size = strlen(val);
+ if (size > this->buf_size)
+ {
+ this->cur_size = this->buf_size;
+ } else
+ {
+ this->cur_size = size;
+ }
+ memcpy(this->buf, val, this->cur_size);
+ return this->cur_size;
+}
+
+Buf* Buf::copy()
+{
+ Buf *ret = new Buf(this->buf_size);
+ char *data=NULL;
+ int data_size=0;
+
+ this->get_ptr(&data, &data_size);
+ ret->set(data, data_size);
+ data=NULL;
+ return ret;
+}
+
+int Buf::get_ptr(char **val, int *size)
+{
+ if (!val)
+ {
+ return -1;
+ }
+
+ *val = this->buf;
+ *size = this->cur_size;
+
+ return 0;
+}
+
+int Buf::realloc(int size)
+{
+ char *ptr=NULL;
+ if (size < 0)
+ {
+ return -1;
+ }
+ if (this->buf_size == size)
+ {
+ return this->buf_size;
+ }
+
+ ptr = (char *)::realloc(this->buf, size);
+ if (ptr != NULL)
+ {
+ this->buf = ptr;
+ this->buf_size = size;
+ }
+
+ return this->buf_size;
+}
+
+int Buf::reduce()
+{
+ printf("Not implemented\n");
+ return -1;
+}
+
+int Buf::inc(int size)
+{
+ printf("Not implemented\n");
+ return -1;
+}
+
+int Buf::dec(int size)
+{
+ printf("Not implemented\n");
+ return -1;
+}
+
+int Buf::set_max()
+{
+ this->cur_size = this->buf_size;
+ return 0;
+}
+
+int Buf::memset(char c)
+{
+ ::memset(this->buf, c, this->cur_size);
+ return 0;
+}
+
+int Buf::concat(Buf *b)
+{
+
+ int i=0,j=this->cur_size;
+ int get_size=b->cursize();
+
+ for (i=0;i<get_size;i++)
+ {
+ char tc;
+ int r = b->getc(i,&tc);
+ if (r==0)
+ {
+ this->pushc(tc);
+ if (j+1>=this->buf_size)
+ {
+ break;
+ }
+ }
+ }
+
+ return i;
+}
+
+int Buf::size()
+{
+ return this->buf_size;
+}
+
+int Buf::cursize()
+{
+ return this->cur_size;
+}
+
+int Buf::print()
+{
+ int i;
+
+ for (i=0;i<this->buf_size;i++)
+ {
+ char ch = this->buf[i];
+ if (isalpha(ch))
+ {
+ printf("%c",ch);
+ } else
+ {
+ printf(".");
+ }
+ }
+
+ return 0;
+}
+
+int Buf::setc(int idx, char c)
+{
+ if ((idx < 0) || (idx > this->cur_size))
+ {
+ return -1;
+ }
+
+ buf[idx] = c;
+
+ return 0;
+}
+
+int Buf::pushc(char c)
+{
+ if (this->cur_size<this->buf_size)
+ {
+ this->buf[this->cur_size] = c;
+ this->cur_size+=1;
+ return 0;
+ }
+ return -1;
+}
+
+int Buf::getc(int idx, char *c)
+{
+ if ((idx < 0) || (idx > this->cur_size))
+ {
+ return -1;
+ }
+
+ *c = buf[idx];
+
+ return 0;
+}
+
+int Buf::findc(char c, int *idx)
+{
+ int i=0;
+
+ for (i=0;i<this->cur_size;i++)
+ {
+ if (buf[i] == c)
+ {
+ //found
+ *idx = i;
+ return 1;
+ }
+ }
+
+ //not found
+ return 0;
+}
+
+int Buf::popsubstring(int sz, char **val, int *size)
+{
+ int ret=-1;
+
+ if (sz>this->cur_size)
+ {
+ sz = this->cur_size;
+ }
+
+ *val = (char *)malloc(sz);
+ memcpy(*val,buf,sz);
+ *size = sz;
+ shiftleft(sz);
+ ret = sz;
+
+ return ret;
+}
+
+int Buf::shiftleft(int n)
+{
+ int i=0;
+
+ if ((n>this->cur_size) || (n<0))
+ {
+ //cant shift
+ return -1;
+ }
+ int mvsz = cur_size-n;
+ for (i=0;i<mvsz;i++)
+ {
+ char c = buf[n+i];
+ //printf("%c",c);
+ buf[i] = c;
+ }
+ this->cur_size -= n;
+
+ //amount of shifted bytes
+ return n;
+}
+
+int Buf::zero()
+{
+ this->memset(0);
+ return 0;
+}
+
+bool Buf::isempty()
+{
+ if (this->buf == NULL)
+ return true;
+ if (this->cur_size <= 0)
+ return true;
+ if (this->buf_size <= 0)
+ return true;
+ return true;
+}
+
+int Buf::empty()
+{
+ this->cur_size = 0;
+ return 0;
+}
+
+int Buf::set_size(int size)
+{
+ if (size < 0)
+ return -1;
+ if (size > this->buf_size)
+ return -1;
+ this->cur_size = size;
+ return 0;
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-15 12:49:59 +0000