feat: cJSON, Gerätenamen und HTTP-Parser

src/net/nl_http.c

@@ -0,0 +1,128 @@
+#include "net/nl_http.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+
+static const char *find(const char *buf, size_t len, const char *pat)
+{
+    size_t n = strlen(pat);
+    for (size_t i = 0; i + n <= len; i++)
+        if (memcmp(buf + i, pat, n) == 0)
+            return buf + i;
+    return NULL;
+}
+
+/* Case-insensitive "name:" match at the start of a header line; returns the value start. */
+static const char *header_value(const char *line, const char *line_end, const char *name)
+{
+    size_t n = strlen(name);
+    if ((size_t)(line_end - line) <= n || line[n] != ':')
+        return NULL;
+    for (size_t i = 0; i < n; i++)
+        if (tolower((unsigned char)line[i]) != name[i])
+            return NULL;
+    line += n + 1;
+    while (line < line_end && (*line == ' ' || *line == '\t'))
+        line++;
+    return line;
+}
+
+nl_http_parse_t nl_http_parse(const char *buf, size_t len, nl_http_request_t *req)
+{
+    const char *hdr_end = find(buf, len, "\r\n\r\n");
+    const char *p, *line_end, *sp1, *sp2;
+    size_t header_len, content_length = 0, plen;
+
+    if (!hdr_end)
+        return len >= NL_HTTP_MAX_REQUEST ? NL_HTTP_TOO_LARGE : NL_HTTP_INCOMPLETE;
+
+    memset(req, 0, sizeof *req);
+    header_len = (size_t)(hdr_end + 4 - buf);
+
+    /* request line: METHOD SP PATH SP HTTP/1.x */
+    line_end = find(buf, header_len, "\r\n");
+    sp1 = memchr(buf, ' ', (size_t)(line_end - buf));
+    if (!sp1)
+        return NL_HTTP_BAD_REQUEST;
+    sp2 = memchr(sp1 + 1, ' ', (size_t)(line_end - sp1 - 1));
+    if (!sp2 || (size_t)(line_end - sp2 - 1) < 8 || memcmp(sp2 + 1, "HTTP/1.", 7) != 0)
+        return NL_HTTP_BAD_REQUEST;
+
+    if (sp1 - buf == 3 && memcmp(buf, "GET", 3) == 0)
+        req->method = NL_HTTP_GET;
+    else if (sp1 - buf == 4 && memcmp(buf, "POST", 4) == 0)
+        req->method = NL_HTTP_POST;
+    else if (sp1 - buf == 3 && memcmp(buf, "PUT", 3) == 0)
+        req->method = NL_HTTP_PUT;
+    else
+        req->method = NL_HTTP_OTHER;
+
+    p = memchr(sp1 + 1, '?', (size_t)(sp2 - sp1 - 1));
+    plen = (size_t)((p ? p : sp2) - (sp1 + 1));
+    if (plen == 0 || plen >= sizeof req->path || sp1[1] != '/')
+        return NL_HTTP_BAD_REQUEST;
+    memcpy(req->path, sp1 + 1, plen);
+
+    /* headers */
+    for (p = line_end + 2; p < hdr_end; p = line_end + 2) {
+        const char *v;
+        line_end = find(p, (size_t)(hdr_end + 2 - p), "\r\n");
+        if ((v = header_value(p, line_end, "content-length")) != NULL) {
+            if (v == line_end)
+                return NL_HTTP_BAD_REQUEST;
+            content_length = 0;
+            for (; v < line_end; v++) {
+                if (!isdigit((unsigned char)*v))
+                    return NL_HTTP_BAD_REQUEST;
+                content_length = content_length * 10u + (size_t)(*v - '0');
+                if (content_length > NL_HTTP_MAX_BODY)
+                    return NL_HTTP_TOO_LARGE;
+            }
+        } else if ((v = header_value(p, line_end, "authorization")) != NULL) {
+            size_t n;
+            if (line_end - v > 7 && strncasecmp(v, "Bearer ", 7) == 0)
+                v += 7;
+            n = (size_t)(line_end - v);
+            if (n >= sizeof req->auth)
+                n = sizeof req->auth - 1;
+            memcpy(req->auth, v, n);
+            req->auth[n] = '\0';
+        }
+    }
+
+    if (header_len + content_length > NL_HTTP_MAX_REQUEST)
+        return NL_HTTP_TOO_LARGE;
+    if (len < header_len + content_length)
+        return NL_HTTP_INCOMPLETE;
+    req->body = buf + header_len;
+    req->body_len = content_length;
+    return NL_HTTP_COMPLETE;
+}
+
+const char *nl_http_reason(int status)
+{
+    switch (status) {
+    case 200: return "OK";
+    case 202: return "Accepted";
+    case 400: return "Bad Request";
+    case 401: return "Unauthorized";
+    case 404: return "Not Found";
+    case 405: return "Method Not Allowed";
+    case 413: return "Payload Too Large";
+    case 500: return "Internal Server Error";
+    case 501: return "Not Implemented";
+    case 503: return "Service Unavailable";
+    default: return "Unknown";
+    }
+}
+
+size_t nl_http_response(char *out, size_t cap, int status, const char *json_body)
+{
+    int n = snprintf(out, cap,
+                     "HTTP/1.1 %d %s\r\nContent-Type: application/json\r\nContent-Length: %u\r\n"
+                     "Connection: close\r\n\r\n%s",
+                     status, nl_http_reason(status), (unsigned)strlen(json_body), json_body);
+    return (n < 0 || (size_t)n >= cap) ? 0 : (size_t)n;
+}