From ad6188f911af896c9c77e9215bea3c5c2a4e6cc3 Mon Sep 17 00:00:00 2001
From: Aleksey Veresov <aleksey@veresov.pro>
Date: Fri, 13 Sep 2019 18:50:34 +0300
Subject: Project name and license are added. Minor changes.

---
 src/urlencoded.c | 180 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 180 insertions(+)
 create mode 100644 src/urlencoded.c

(limited to 'src/urlencoded.c')

diff --git a/src/urlencoded.c b/src/urlencoded.c
new file mode 100644
index 0000000..e3d4e56
--- /dev/null
+++ b/src/urlencoded.c
@@ -0,0 +1,180 @@
+#include "urlencoded.h"
+
+#include "field.h"
+#include "log.h"
+#include <ctype.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Shortcuts
+ */
+/* Shouldn't be called with 'c' as not hex digit. */
+static char from_hex(char c)
+{
+    char num;
+    if (isdigit(c)) {
+        num = c - '0';
+    } else {
+        num = toupper(c) - 'A' + 10;
+    }
+    return num;
+}
+
+static int is_hex(char c)
+{
+    return isdigit(c) || strchr("ABCDEF", toupper(c));
+}
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * URL Decoding
+ */
+static int deurl(char *data)
+{
+    int ok = 1;
+    int ti = 0;
+    int ci;
+    for (ci = 0; ok && data[ci]; ++ti, ++ci) {
+        if (data[ci] == '%') {
+            if (is_hex(data[ci + 1]) && is_hex(data[ci + 2])) {
+                /* Since chars can be signed, arithmetics are not safe. */
+                data[ti]  = from_hex(data[ci + 2]);       /* 00xx */
+                data[ti] |= from_hex(data[ci + 1]) << 4;  /* XXxx */
+                ci       += 2;
+            } else {
+                ok = 0;
+                magi_log(
+                    "[urlencoded] Waiting for two hex digits after '%%', "
+                    "readed: \\%o\\%o (render: %c%c)",
+                    data[ci + 1], data[ci + 2], data[ci + 1], data[ci + 2]
+                );
+            }
+        } else if (data[ci] == '+') {
+            data[ti] = ' ';
+        } else {
+            data[ti] = data[ci];
+        }
+    }
+    data[ti++] = 0;
+    return ok;
+}
+
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Urlencoded Automata
+ */
+enum st {
+    st_error = 0,
+    st_name,
+    st_data
+};
+
+struct automata {
+    struct magi_field_list **list;
+    struct magi_field      field;
+    int                    size;
+    int                    len;
+};
+
+
+static enum st parse_name(struct automata *a, char c)
+{
+    enum st state;
+    if (c != '&' && c != ';') {
+        if (c == '=') {
+            state   = st_data;
+            a->size = 1;
+            a->len  = 0;
+        } else {
+            if (a->len == a->size - 1) {
+                a->size      *= 2;
+                a->field.name = realloc(a->field.name, a->size);
+            }
+            if (!a->field.name) {
+                state = st_error;
+                magi_log("[urlencoded] Cannot allocate field name.");
+            } else {
+                state = st_name;
+                a->len++;
+                a->field.name[a->len - 1] = c;
+                a->field.name[a->len]     = 0;
+            }
+        }
+    } else {
+        state = st_error;
+        magi_log("[urlencoded] Reading name, readed: \\%o (render: %c).", c, c);
+    }
+    return state;
+}
+
+static enum st end_data(struct automata *a)
+{
+    enum st state = st_error;
+    if (deurl(a->field.name) && deurl(a->field.data)) {
+        a->field.len = strlen(a->field.data);
+        if (magi_field_list_add(a->list, &a->field)) {
+            state         = st_name;
+            a->size       = 1;
+            a->len        = 0;
+            a->field.name = 0;
+            a->field.data = 0;
+        }
+    }
+    return state;
+}
+
+static enum st parse_data(struct automata *a, char c)
+{
+    enum st state;
+    if (c != '=') {
+        if (c == '&' || c == ';') {
+            state = end_data(a);
+        } else {
+            if (a->len == a->size - 1) {
+                a->size      *= 2;
+                a->field.data = realloc(a->field.data, a->size);
+            }
+            if (!a->field.data) {
+                state = st_error;
+                magi_log("[urlencoded] Cannot allocate field data.");
+            } else {
+                state = st_data;
+                a->len++;
+                a->field.data[a->len - 1] = c;
+                a->field.data[a->len]     = 0;
+            }
+        }
+    } else {
+        state = st_error;
+        magi_log("[urlencoded] Reading data, readed: \\%o (render: %c).", c, c);
+    }
+    return state;
+}
+
+int magi_parse_urlencoded(struct magi_field_list **list, const char *input)
+{
+    enum st state = st_name;
+    struct automata a = { 0, { 0, 0, 0 }, 1, 0 };
+    if (input && *input) {
+        a.list = list;
+        while (state && *input) {
+            switch (state) {
+            case st_name: state = parse_name(&a, *input); break;
+            case st_data: state = parse_data(&a, *input);
+            default:      break;
+            }
+            ++input;
+        }
+        if (state == st_data) {
+            state = end_data(&a);
+        } else if (state == st_name) {
+            state = st_error;
+            magi_log("[urlencoded] Input ended while reading name.");
+        }
+        free(a.field.name);
+        free(a.field.data);
+    }
+    return state != st_error;
+}
-- 
cgit v1.2.3