1 files changed, 203 insertions, 0 deletions

diff --git a/components/wisp_relay/handlers.c b/components/wisp_relay/handlers.c
new file mode 100644
index 0000000..2164725
--- /dev/null
+++ b/components/wisp_relay/handlers.c
@@ -0,0 +1,203 @@
+#include "handlers.h"
+#include "router.h"
+#include "storage_engine.h"
+#include "sub_manager.h"
+#include "relay_validator.h"
+#include "broadcaster.h"
+#include "deletion.h"
+#include "rate_limiter.h"
+#include "relay_types.h"
+#include "cJSON.h"
+#include "esp_log.h"
+#include <string.h>
+
+static const char *TAG = "handlers";
+
+int handle_event(relay_ctx_t *ctx, int conn_fd, const char *event_json, size_t event_len)
+{
+    if (!ctx || !event_json) return -1;
+
+    if (ctx->rate_limiter) {
+        if (!rate_limiter_check(ctx->rate_limiter, conn_fd, RATE_TYPE_EVENT)) {
+            router_send_ok(ctx, conn_fd, "", false, "rate limited");
+            return -1;
+        }
+    }
+
+    cJSON *obj = cJSON_ParseWithLength(event_json, event_len);
+    if (!obj) {
+        router_send_ok(ctx, conn_fd, "", false, "invalid JSON");
+        return -1;
+    }
+
+    cJSON *id_item = cJSON_GetObjectItem(obj, "id");
+    cJSON *pubkey_item = cJSON_GetObjectItem(obj, "pubkey");
+    cJSON *kind_item = cJSON_GetObjectItem(obj, "kind");
+    cJSON *ca_item = cJSON_GetObjectItem(obj, "created_at");
+
+    if (!id_item || !pubkey_item || !kind_item || !ca_item) {
+        cJSON_Delete(obj);
+        router_send_ok(ctx, conn_fd, "", false, "missing required fields");
+        return -1;
+    }
+
+    const char *id_hex = id_item->valuestring;
+    const char *pubkey_hex = pubkey_item->valuestring;
+    int kind = kind_item->valueint;
+    uint64_t created_at = (uint64_t)ca_item->valuedouble;
+
+    if (ctx->config.max_future_sec > 0) {
+        int64_t now = (int64_t)(xTaskGetTickCount() / configTICK_RATE_HZ);
+        if ((int64_t)created_at > now + ctx->config.max_future_sec) {
+            cJSON_Delete(obj);
+            router_send_ok(ctx, conn_fd, id_hex, false, "created_at too far in future");
+            return -1;
+        }
+    }
+
+    uint8_t event_id[32];
+    if (relay_hex_to_bytes(id_hex, 64, event_id, 32) != 0) {
+        cJSON_Delete(obj);
+        router_send_ok(ctx, conn_fd, "", false, "invalid event id");
+        return -1;
+    }
+
+    if (storage_event_exists(ctx->storage, event_id)) {
+        cJSON_Delete(obj);
+        router_send_ok(ctx, conn_fd, id_hex, true, "duplicate");
+        return 0;
+    }
+
+    if (!relay_validator_verify_event(event_json, event_len)) {
+        cJSON_Delete(obj);
+        router_send_ok(ctx, conn_fd, id_hex, false, "invalid signature");
+        return -1;
+    }
+
+    cJSON_Delete(obj);
+
+    storage_error_t err = storage_save_event_json(ctx->storage, event_json, event_len);
+    if (err != STORAGE_OK) {
+        const char *msg = (err == STORAGE_ERR_FULL) ? "relay full" :
+                          (err == STORAGE_ERR_DUPLICATE) ? "duplicate" : "storage error";
+        router_send_ok(ctx, conn_fd, id_hex, false, msg);
+        return -1;
+    }
+
+    router_send_ok(ctx, conn_fd, id_hex, true, "");
+
+    if (kind == NOSTR_KIND_DELETION) {
+        deletion_process_json(ctx->storage, event_json, event_len);
+    }
+
+    broadcaster_fanout_json(ctx, event_json, event_len, kind, pubkey_hex, created_at);
+
+    return 0;
+}
+
+static void parse_filter_json(const char *json, sub_filter_t *filter)
+{
+    memset(filter, 0, sizeof(sub_filter_t));
+    cJSON *obj = cJSON_Parse(json);
+    if (!obj) return;
+
+    cJSON *arr;
+
+    arr = cJSON_GetObjectItem(obj, "ids");
+    if (arr && cJSON_IsArray(arr)) {
+        filter->ids_count = cJSON_GetArraySize(arr);
+        if (filter->ids_count > SUB_MAX_FILTER_IDS) filter->ids_count = SUB_MAX_FILTER_IDS;
+        for (size_t i = 0; i < filter->ids_count; i++)
+            filter->ids[i] = strdup(cJSON_GetArrayItem(arr, i)->valuestring);
+    }
+
+    arr = cJSON_GetObjectItem(obj, "authors");
+    if (arr && cJSON_IsArray(arr)) {
+        filter->authors_count = cJSON_GetArraySize(arr);
+        if (filter->authors_count > SUB_MAX_FILTER_AUTHORS) filter->authors_count = SUB_MAX_FILTER_AUTHORS;
+        for (size_t i = 0; i < filter->authors_count; i++)
+            filter->authors[i] = strdup(cJSON_GetArrayItem(arr, i)->valuestring);
+    }
+
+    arr = cJSON_GetObjectItem(obj, "kinds");
+    if (arr && cJSON_IsArray(arr)) {
+        filter->kinds_count = cJSON_GetArraySize(arr);
+        if (filter->kinds_count > SUB_MAX_FILTER_KINDS) filter->kinds_count = SUB_MAX_FILTER_KINDS;
+        for (size_t i = 0; i < filter->kinds_count; i++)
+            filter->kinds[i] = cJSON_GetArrayItem(arr, i)->valueint;
+    }
+
+    arr = cJSON_GetObjectItem(obj, "#e");
+    if (arr && cJSON_IsArray(arr)) {
+        filter->e_tags_count = cJSON_GetArraySize(arr);
+        if (filter->e_tags_count > SUB_MAX_FILTER_ETAGS) filter->e_tags_count = SUB_MAX_FILTER_ETAGS;
+        for (size_t i = 0; i < filter->e_tags_count; i++)
+            filter->e_tags[i] = strdup(cJSON_GetArrayItem(arr, i)->valuestring);
+    }
+
+    arr = cJSON_GetObjectItem(obj, "#p");
+    if (arr && cJSON_IsArray(arr)) {
+        filter->p_tags_count = cJSON_GetArraySize(arr);
+        if (filter->p_tags_count > SUB_MAX_FILTER_PTAGS) filter->p_tags_count = SUB_MAX_FILTER_PTAGS;
+        for (size_t i = 0; i < filter->p_tags_count; i++)
+            filter->p_tags[i] = strdup(cJSON_GetArrayItem(arr, i)->valuestring);
+    }
+
+    cJSON *since = cJSON_GetObjectItem(obj, "since");
+    if (since) filter->since = (int64_t)since->valuedouble;
+    cJSON *until = cJSON_GetObjectItem(obj, "until");
+    if (until) filter->until = (int64_t)until->valuedouble;
+    cJSON *limit = cJSON_GetObjectItem(obj, "limit");
+    if (limit) filter->limit = limit->valueint;
+
+    cJSON_Delete(obj);
+}
+
+void handle_req(relay_ctx_t *ctx, int conn_fd, const char *sub_id, const char *filters_json)
+{
+    if (!ctx || !sub_id) return;
+
+    if (ctx->rate_limiter) {
+        if (!rate_limiter_check(ctx->rate_limiter, conn_fd, RATE_TYPE_REQ)) {
+            router_send_closed(ctx, conn_fd, sub_id, "rate limited");
+            return;
+        }
+    }
+
+    sub_filter_t filter;
+    parse_filter_json(filters_json, &filter);
+
+    int query_kind = -1;
+    const char *query_author = NULL;
+    int query_limit = filter.limit > 0 ? filter.limit : 100;
+
+    if (filter.kinds_count > 0) query_kind = filter.kinds[0];
+    if (filter.authors_count > 0) query_author = filter.authors[0];
+
+    char **results = NULL;
+    uint16_t count = 0;
+    storage_query_events_json(ctx->storage, query_kind, query_author,
+                              query_limit, &results, &count);
+
+    for (uint16_t i = 0; i < count; i++) {
+        router_send_event(ctx, conn_fd, sub_id, results[i], strlen(results[i]));
+    }
+    storage_free_query_results(results, count);
+
+    router_send_eose(ctx, conn_fd, sub_id);
+
+    sub_manager_add(ctx->sub_manager, conn_fd, sub_id, &filter, 1);
+
+    sub_filter_t *f = &filter;
+    for (size_t i = 0; i < f->ids_count; i++) free(f->ids[i]);
+    for (size_t i = 0; i < f->authors_count; i++) free(f->authors[i]);
+    for (size_t i = 0; i < f->e_tags_count; i++) free(f->e_tags[i]);
+    for (size_t i = 0; i < f->p_tags_count; i++) free(f->p_tags[i]);
+}
+
+int handle_close(relay_ctx_t *ctx, int conn_fd, const char *sub_id)
+{
+    if (!ctx || !sub_id) return -1;
+    sub_manager_remove(ctx->sub_manager, conn_fd, sub_id);
+    return 0;
+}