cami.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/* --- 1. PLATFORM-SPECIFIC CONFIGURATION AND HEADERS --- */
#if defined(__AMIGA__) || defined(__amigaos__)
    #include <proto/bsdsocket.h>
    struct Library *SocketBase = NULL;
    #define CLOSE_SOCKET(s) sclose(s)
    #define MUTEX_LOCK()
    #define MUTEX_UNLOCK()
#elif defined(_WIN32)
    #include <winsock2.h>
    #include <ws2tcpip.h>
    #include <windows.h>
    #pragma comment(lib, "ws2_32.lib")
    #define CLOSE_SOCKET(s) closesocket(s)
    typedef int socklen_t;
    CRITICAL_SECTION win_mutex;
    #define MUTEX_LOCK() EnterCriticalSection(&win_mutex)
    #define MUTEX_UNLOCK() LeaveCriticalSection(&win_mutex)
#else
    /* macOS, Linux, BSD, s390x, Cosmopolitan */
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <unistd.h>
    #include <pthread.h>
    #define CLOSE_SOCKET(s) close(s)
    static pthread_mutex_t posix_mutex = PTHREAD_MUTEX_INITIALIZER;
    #define MUTEX_LOCK() pthread_mutex_lock(&posix_mutex)
    #define MUTEX_UNLOCK() pthread_mutex_unlock(&posix_mutex)
#endif

/* Thread and type specifications */
#ifdef _WIN32
    typedef HANDLE pthread_t;
    #define THREAD_FUNC DWORD WINAPI
#else
    #define THREAD_FUNC void*
#endif

/* --- 2. MEMORY POOL --- */
#define POOL_SIZE 64
#define BUFFER_SIZE 2048

typedef struct {
    char data[BUFFER_SIZE];
    int in_use;
} MemoryBuffer;

MemoryBuffer pool[POOL_SIZE];

MemoryBuffer* get_buffer() {
    MUTEX_LOCK();
    for (int i = 0; i < POOL_SIZE; i++) {
        if (!pool[i].in_use) {
            pool[i].in_use = 1;
            MUTEX_UNLOCK();
            return &pool[i];
        }
    }
    MUTEX_UNLOCK();
    return NULL;
}

void release_buffer(MemoryBuffer* buf) {
    if (buf) {
        MUTEX_LOCK();
        buf->in_use = 0;
        MUTEX_UNLOCK();
    }
}

/* --- 3. JSON AND ANSWERS --- */

void build_json_response(char* buffer) {
    const char* json_body = "{\"message\":\"Hello, World!\"}";
    sprintf(buffer, 
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: application/json\r\n"
        "Content-Length: %lu\r\n"
        "Connection: close\r\n"
        "\r\n"
        "%s", (unsigned long)strlen(json_body), json_body);
}

void build_plaintext_response(char* buffer) {
    const char* body = "Hello, World!";
    sprintf(buffer, 
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: text/plain\r\n"
        "Content-Length: %lu\r\n"
        "Connection: close\r\n"
        "\r\n"
        "%s", (unsigned long)strlen(body), body);
}

void build_db_response(char* buffer, int id, const char* random_text) {
    char json_body[256];
    sprintf(json_body, "{\"id\":%d,\"randomNumber\":\"%s\"}", id, random_text);
    sprintf(buffer, 
        "HTTP/1.1 200 OK\r\n"
        "Content-Type: application/json\r\n"
        "Content-Length: %lu\r\n"
        "Connection: close\r\n"
        "\r\n"
        "%s", (unsigned long)strlen(json_body), json_body);
}

/* --- 4. CLIENT HANDLING --- */
THREAD_FUNC handle_client(void *arg) {
    long client_fd = (long)arg;
    char request_buf[1024];
    
    // Luetaan pyyntö
    int received = recv(client_fd, request_buf, sizeof(request_buf) - 1, 0);
    
    MemoryBuffer* buf = get_buffer();
    if (buf && received > 0) {
        request_buf[received] = '\0';
        
        if (strstr(request_buf, "GET /db")) {
            build_db_response(buf->data, 123, "AmigaMagic");
        } else if (strstr(request_buf, "GET /json")) {
            build_json_response(buf->data);
        } else {
            build_plaintext_response(buf->data);
        }
        
        send(client_fd, buf->data, (int)strlen(buf->data), 0);
        release_buffer(buf);
    } else if (!buf) {
        const char *error = "HTTP/1.1 503 Service Unavailable\r\n\r\n";
        send(client_fd, error, (int)strlen(error), 0);
    }

    CLOSE_SOCKET(client_fd);
#ifdef _WIN32
    return 0;
#else
    return NULL;
#endif
}

/* --- 5. MAIN PROGRAM --- */
int main() {
    memset(pool, 0, sizeof(pool));

#if defined(_WIN32)
    WSADATA wsaData; WSAStartup(MAKEWORD(2, 2), &wsaData);
    InitializeCriticalSection(&win_mutex);
#elif defined(__AMIGA__) || defined(__amigaos__)
    SocketBase = OpenLibrary("bsdsocket.library", 4);
#endif

    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0) return 1;

    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8080);
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(server_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) return 1;

    listen(server_fd, 128);
    printf("Universal JSON Server running on port 8080...\n");

    while(1) {
        struct sockaddr_in client_addr;
        socklen_t addr_len = sizeof(client_addr);
        long client_fd = (long)accept(server_fd, (struct sockaddr *)&client_addr, &addr_len);
        
        if (client_fd >= 0) {
#ifdef _WIN32
            CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)handle_client, (void*)client_fd, 0, NULL);
#elif defined(__AMIGA__) || defined(__amigaos__)
            handle_client((void*)client_fd);
#else
            pthread_t thread;
            if (pthread_create(&thread, NULL, handle_client, (void*)client_fd) == 0) {
                pthread_detach(thread);
            } else {
                CLOSE_SOCKET(client_fd);
            }
#endif
        }
    }
    return 0;
}