summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/bencoding.c259
-rw-r--r--src/utils.c4
2 files changed, 228 insertions, 35 deletions
diff --git a/src/bencoding.c b/src/bencoding.c
index 8c32399..d1324c7 100644
--- a/src/bencoding.c
+++ b/src/bencoding.c
@@ -21,11 +21,10 @@ struct bencoding {
struct bencoding * next; /**< NULL if element is not member of a list or dict */
struct bencoding * prev;
struct bencoding * child; /**< NULL if element is not a list or dict or if it has 0 children */
- struct bencoding * parent;
- enum benc type; /**< type of this element */
- struct bencoding * key; /**< the key element, string according to the spec, applicable for list and dict */
- char * value; /**< always set to the content of the element, value is not null terminated unless terminate opt is set */
- size_t valuelen; /**< length of string value, as value is not null terminated */
+ enum benc type; /**< type | opts of this element */
+ struct bencoding * key; /**< the key element, string according to the spec, applicable for dict */
+ char * value; /**< set to the content of the element, value is not null terminated unless terminate opt is set. NULL for dict and list. */
+ size_t valuelen; /**< length of string value, as value is not null terminated, internal value for list or dict. */
int intvalue;
int index;
char oldterminator; /**< when opts&terminate, the character that was replaced with \0 is stored here */
@@ -41,12 +40,10 @@ struct bencoding {
void free_bencoding (struct bencoding * b) {
if (!b)
return;
- struct bencoding * s = b;
- while (s) /* we free all siblings should they exist */
- free_bencoding(s = s->next);
free_bencoding(b->child); /* we free the child should it exist. it can be NULL. */
free_bencoding(b->key); /* should this be an element of a dict, free the key */
- free(b); /* we free the element */
+ free_bencoding(b->next);
+ free(b);
return;
}
@@ -58,6 +55,201 @@ void free_bencoding (struct bencoding * b) {
#define MIN(x, y) ((x) <= (y) ? (x) : (y))
/**
+ * return how much space a character in a string uses
+ *
+ * @param a [in] the character in question
+ */
+
+int b2json_charsize (char a) {
+ if (a == '"')
+ return 2;
+ if (a == '\\')
+ return 2;
+ if (a == '\b')
+ return 2;
+ if (a == '\f')
+ return 2;
+ if (a == '\n')
+ return 2;
+ if (a == '\r')
+ return 2;
+ if (a == '\t')
+ return 2;
+ if (a < ' ')
+ return 6;
+ return 1;
+}
+
+/**
+ * write a string representation of a character in a JSON string
+ *
+ * @param dest [out] destination
+ * @param a [in] the character in question
+ * @return the destination pointer, incremented for the number of bytes written
+ */
+
+char * b2json_charrepr (char * dest, char a) {
+ switch (a) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-truncation"
+ case '"':
+ strncpy(dest, "\\\"", 2);
+ return dest+2;
+ case '\\':
+ strncpy(dest, "\\\\", 2);
+ return dest+2;
+ case '\b':
+ strncpy(dest, "\\b", 2);
+ return dest+2;
+ case '\f':
+ strncpy(dest, "\\f", 2);
+ return dest+2;
+ case '\n':
+ strncpy(dest, "\\n", 2);
+ return dest+2;
+ case '\r':
+ strncpy(dest, "\\r", 2);
+ return dest+2;
+ case '\t':
+ strncpy(dest, "\\t", 2);
+ return dest+2;
+ default:
+ if (a < ' ') {
+ char buf[7];
+ sprintf(buf, "\\u00%02x", a);
+ strncpy(dest, buf, 6);
+ return dest+6;
+ } else {
+ *dest++ = a;
+ return dest;
+ }
+#pragma GCC diagnostic pop
+ }
+}
+
+
+/**
+ * get size required for JSON representation of a bencoding struct. terminating NULL byte is not counted, because b2json does not write it. write it yourself.
+ *
+ * @param b [in] bencoding structure of a bdecoded element
+ */
+
+int b2json_length (struct bencoding * b) {
+ if (!b)
+ return 4;
+ if (b->type & string) {
+ int size = 2;
+ if (b->oldterminatorls)
+ size += b2json_charsize(b->oldterminatorls) - b2json_charsize('\0');
+ for (size_t i = 0; i < b->valuelen; i++)
+ size += b2json_charsize(b->value[i]);
+ return size;
+ }
+ if (b->type & num) {
+ char buf[512];
+ sprintf(buf, "%d", b->intvalue);
+ return strlen(buf);
+ }
+ if (b->type & list) {
+ if (!b->child)
+ return 2;
+ struct bencoding * t = b->child;
+ int size = 2 + b2json_length(t);
+ while (t->next) {
+ t = t->next;
+ size += b2json_length(t) + 1;
+ }
+ return size;
+ }
+ if (b->type & dict) {
+ if (!b->child)
+ return 2;
+ struct bencoding * t = b->child;
+ int size = 3 + b2json_length(t) + b2json_length(t->key);
+ while (t->next) {
+ t = t->next;
+ size += 1 + b2json_length(t) + 1 + b2json_length(t->key);
+ }
+ return size;
+ }
+ return 5;
+}
+
+/**
+ * write json representation of a bencoding struct. does not write terminating nullbyte, b2json_length does not include it in count. add it yourself. should write exactly b2json_length bytes.
+ *
+ * writes false when struct has an incorrect type and null when NULL pointer is passed, this is in ordnung with b2json_length.
+ *
+ * @param dest [in] destination
+ * @param b [in] bencoding structure of a bdecoded element
+ * @return the destination pointer, incremented for the number of bytes written
+ */
+
+char * b2json (char * dest, struct bencoding * b) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-truncation"
+ if (!b) {
+ strncpy(dest, "null", 4);
+ return dest+4;
+ }
+ if (b->type & string) {
+ *dest++ = '"';
+ for (size_t i = 0; i < b->valuelen; i++)
+ if (i == b->valuelen-1 && b->oldterminatorls)
+ dest = b2json_charrepr(dest, b->oldterminatorls);
+ else
+ dest = b2json_charrepr(dest, b->value[i]);
+ *dest++ = '"';
+ return dest;
+ }
+ if (b->type & num) {
+ char buf[512];
+ sprintf(buf, "%d", b->intvalue);
+ strncpy(dest, buf, strlen(buf));
+ return dest+strlen(buf);
+ }
+ if (b->type & list) {
+ if (!b->child) {
+ strncpy(dest, "[]", 2);
+ return dest+2;
+ }
+ struct bencoding * t = b->child;
+ *dest++ = '[';
+ dest = b2json(dest, t);
+ while (t->next) {
+ t = t->next;
+ *dest++ = ',';
+ dest = b2json(dest, t);
+ }
+ *dest++ = ']';
+ return dest;
+ }
+ if (b->type & dict) {
+ if (!b->child) {
+ strncpy(dest, "{}", 2);
+ return dest+2;
+ }
+ *dest++ = '{';
+ struct bencoding * t = b->child;
+ dest = b2json(dest, t->key);
+ *dest++ = ':';
+ dest = b2json(dest, t);
+ while (t->next) {
+ t = t->next;
+ *dest++ = ',';
+ dest = b2json(dest, t->key);
+ *dest++ = ':';
+ dest = b2json(dest, t);
+ }
+ *dest++ = '}';
+ return dest;
+ }
+ strncpy(dest, "false", 4);
+ return dest+4;
+#pragma GCC diagnostic pop
+}
+
+/**
* macro that allocas a C string from a bencoding string or other element. non-string elements return their raw bencoded content.
* dereferences structure without checking.
* resulting C string is NULL terminated, cannot contain NULL, DO NOT dereference bytes after the NULL terminator.
@@ -108,7 +300,7 @@ struct bencoding * bdecode (char * s, int len, enum benc opts) {
b->value = s+1;
if (len == -1 || memchr(s, 'e', len)) { /* correct string or end found */
b->intvalue = strtol(b->value, &c, 10);
- b->valuelen = (c-1)-b->value;
+ b->valuelen = c-b->value;
}
break;
case 'd': /* dict */
@@ -117,49 +309,54 @@ struct bencoding * bdecode (char * s, int len, enum benc opts) {
case 'l': /* list */
if (!b->type)
b->type = list;
- c = s;
+ c = s+1;
struct bencoding * arbeit = NULL;
struct bencoding * oldarbeit = NULL;
struct bencoding * oldoldarbeit = NULL; /* for dicts, holds previous value */
int index = 0;
- b->value = s+1;
- char oldterminator = '\0';
- while (len == -1 || ++c <= s+len) { /* s+len is max we are allowed to read */
- if (opts&terminate && oldarbeit && oldarbeit->oldterminator)
- c[0] = oldterminator;
+ while (len == -1 || c <= s+len) { /* s+len is max we are allowed to read */
+ if (oldarbeit && oldarbeit->type & string && oldarbeit->type & terminate && oldarbeit->oldterminator)
+ c[0] = oldarbeit->oldterminator;
arbeit = bdecode(c, len == -1 ? -1 : len-(c-s), opts);
- if (opts&terminate && oldarbeit && oldarbeit->oldterminator)
+ if (oldarbeit && oldarbeit->type & string && oldarbeit->type & terminate && oldarbeit->oldterminator)
c[0] = '\0';
if (!arbeit) /* bdecoding failed or last element */
break;
-#define ISDICT (b->type == dict)
+#define ISDICT (b->type & dict)
#define ISLIST !ISDICT
-#define ISVAL (index % 2 == 1)
+#define ISVAL (index % 2)
#define ISKEY !ISVAL
if (ISDICT && ISVAL)
arbeit->key = oldarbeit;
- c = arbeit->value+arbeit->valuelen; /* this is safe, function's vallen should not be in forbidden */
- if (arbeit->type&(num|dict|list) && c <= s+len && c[0] == 'e') /* but vallen+1 may be */
- c++;
- c--; /* while cond will inc again */
+ if (arbeit->type & num)
+ c = arbeit->value+arbeit->valuelen+1;
+ else if (arbeit->type & string)
+ c = arbeit->value+arbeit->valuelen;
+ else if (arbeit->type & (list | dict))
+ c += arbeit->valuelen;
arbeit->prev = ISDICT ? ISVAL ? oldoldarbeit : oldarbeit : oldarbeit;
arbeit->index = ISDICT ? index/2 : index;
- if (ISLIST)
+ if (ISLIST) {
if (index)
oldarbeit->next = arbeit;
else
b->child = arbeit;
- if (ISDICT)
+ }
+ if (ISDICT) {
if (index == 1)
- b->child = oldarbeit;
+ b->child = arbeit;
else if (ISVAL)
oldoldarbeit->next = arbeit;
+ }
oldoldarbeit = oldarbeit;
oldarbeit = arbeit;
index++;
}
- b->valuelen = (c-1)-b->value; /* c-1 is the last character in list or last readable character if out of l */
- break;
+ b->valuelen = c-s + 1;
+ b->type = b->type | opts;
+ if (ISDICT && ISVAL) // e je torej value, če je prej samoten key
+ free_bencoding(oldarbeit); // this key would be otherwise leaked
+ return b;
case 'e': /* end of list/dict */
free(b);
return NULL;
@@ -170,15 +367,15 @@ struct bencoding * bdecode (char * s, int len, enum benc opts) {
}
b->type = string;
if (len == -1 || (b->value = memchr(s, ':', len))) {
- b->valuelen = strtol(s, NULL, 10);
- b->value++;
+ b->valuelen = strtol(s, &c, 10);
+ b->value = c+1;
if (len != -1 && (unsigned)len < b->valuelen + (b->value - s) /* len minus prefix; strlen & colon */)
b->valuelen = len - (b->value - s); /* malformed bencoded data, truncating string */
}
break;
}
if (opts & terminate) {
- if (len != -1 && b->valuelen+1+(b->value-s) < (unsigned) len) { /* no space for terminator, put it on last char */
+ if (len != -1 && b->valuelen+1+(b->value-s) > (unsigned) len) { /* no space for terminator, put it on last char */
b->oldterminatorls = b->value[b->valuelen-1];
b->value[b->valuelen-1] = '\0';
} else {
diff --git a/src/utils.c b/src/utils.c
deleted file mode 100644
index 237f701..0000000
--- a/src/utils.c
+++ /dev/null
@@ -1,4 +0,0 @@
-#define free_char_after __attribute__ ((__cleanup__ (free_char_pointer)))
-void free_char_pointer (char ** p) {
- free(*p);
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 11:11:44 +0100