← RESP mini-server (Redis) networkingmedium ready

Problem

RESP mini-server (Redis) — C

Topics: wire-protocol parsing, RESP, in-memory store

Problem

Parse one client command in the RESP wire format, run it against an in-memory store, and write the RESP reply. (Connection framing is out of scope — see message-framing / line-protocol.)

typedef struct { /* fixed-size key/val store */ } Store;
void   store_init(Store *s);
size_t resp_handle(Store *s, const unsigned char *req, size_t reqlen, char *out, size_t outcap);

Clients send a command as an array of bulk strings: *2\r\n$3\r\nGET\r\n$3\r\nfoo\r\n. Replies: +OK\r\n, $<len>\r\n<v>\r\n (or null $-1\r\n), :<n>\r\n, -ERR <msg>\r\n.

Commands (case-insensitive): PING (→ +PONG, or echo its arg), SET k v, GET k, INCR k (error on a non-integer value), DEL k... (→ count removed). Unknown/malformed → -ERR.

The fixed-size store and its helpers (store_init/find/set/get/del) are provided; you implement resp_handle — walk the array (each $<len> bulk string), then dispatch and format the reply.

Run

cc -std=c11 -O2 -Wall tests.c -o /tmp/resp && /tmp/resp

Sign in to submit your solution.

Leaderboard score: lower is better, 1.0 ≈ reference

#	Name	score	ns/op	allocs

Output

No submission yet.

#include <stddef.h>
#include <stdio.h>
#include <string.h>

// A tiny Redis-protocol (RESP) server core: parse one client command (a RESP
// array of bulk strings), run it against the in-memory store, and write the RESP
// reply. Supports PING, SET, GET, INCR, DEL. The fixed-size store and its helpers
// are provided; implement resp_handle (parse + dispatch).
//
// RESP: array `*<count>\r\n` then each `$<len>\r\n<bytes>\r\n`.
// Replies: +OK\r\n | $<len>\r\n<v>\r\n | $-1\r\n (null) | :<n>\r\n | -ERR ...\r\n

typedef struct {
    char key[64];
    char val[64];
    int used;
} Entry;

typedef struct {
    Entry items[64];
} Store;

void store_init(Store *s) { memset(s, 0, sizeof *s); }

static int store_find(Store *s, const char *key) {
    for (int i = 0; i < 64; i++) {
        if (s->items[i].used && strcmp(s->items[i].key, key) == 0) return i;
    }
    return -1;
}

static void store_set(Store *s, const char *key, const char *val) {
    int i = store_find(s, key);
    if (i < 0) {
        for (int k = 0; k < 64; k++) if (!s->items[k].used) { i = k; break; }
    }
    if (i < 0) return;
    s->items[i].used = 1;
    snprintf(s->items[i].key, sizeof s->items[i].key, "%s", key);
    snprintf(s->items[i].val, sizeof s->items[i].val, "%s", val);
}

static const char *store_get(Store *s, const char *key) {
    int i = store_find(s, key);
    return i < 0 ? NULL : s->items[i].val;
}

static int store_del(Store *s, const char *key) {
    int i = store_find(s, key);
    if (i < 0) return 0;
    s->items[i].used = 0;
    return 1;
}

// resp_handle parses one command from req[0..reqlen), runs it against s, writes
// the RESP reply into out (cap bytes), and returns the reply length.
size_t resp_handle(Store *s, const unsigned char *req, size_t reqlen, char *out, size_t outcap) {
    (void)req;
    (void)reqlen;
    (void)out;
    (void)outcap;
    (void)store_set;
    (void)store_get;
    (void)store_del;
    (void)s;
    return 0; // TODO
}