server06 start

CMakeLists.txt

@@ -15,6 +15,7 @@ add_executable(server00 server00.c
 target_link_libraries(server00 wsock32 ws2_32)
 
 find_package(json-c CONFIG REQUIRED)
+find_package(PCRE2 CONFIG REQUIRED 8BIT)
 
 
 add_executable(server01 server01.c
@@ -31,4 +32,8 @@ add_executable(server03 server03.c server03.h ${COMMON_SOURCES})
 target_link_libraries(server03 wsock32 ws2_32)
 
 add_executable(server04 server04.c server04.h ${COMMON_SOURCES})
-target_link_libraries(server04 wsock32 ws2_32)
+target_link_libraries(server04 wsock32 ws2_32)
+add_executable(server05 server05.c server05.h ${COMMON_SOURCES})
+target_link_libraries(server05 wsock32 ws2_32 PCRE2::8BIT)
+add_executable(server06 server06.c server06.h ${COMMON_SOURCES})
+target_link_libraries(server06 wsock32 ws2_32 PCRE2::8BIT)

server04.c

@@ -20,28 +20,41 @@ int main() {
     int connection_number = 1;
     char *request = malloc(BUF_SIZE);
     char buffer[BUF_SIZE] = {0};
-    int bytesReceived;
     data_map_t *data = data_map_create(1024);
     printf("Listening for incoming connections...\n");
-    while ((bytesReceived = recvfrom(server, buffer, sizeof(buffer), 0, (SOCKADDR *) &clientAddr, &clientAddrSize)) > 0) {
+    while (true) {
+        int bytesReceived = recvfrom(server, buffer, sizeof(buffer), 0, (SOCKADDR *) &clientAddr, &clientAddrSize);
         const char *equals = "=";
         size_t pos;
         // IN_ADDR addr = clientAddr.sin_addr;
         // printf("{%d} Client ip: |%d.%d.%d.%d| \n", connection_number, addr.S_un.S_un_b.s_b1, addr.S_un.S_un_b.s_b2, addr.S_un.S_un_b.s_b3, addr.S_un.S_un_b.s_b4);
         // printf("{%d} Client port: |%d| \n", connection_number, clientAddr.sin_port);
-        if ((pos = strcspn(buffer, equals)) >= 0) {
+        printf("{%d} Client sent: |%s| \n", connection_number, buffer);
+        if ((pos = strcspn(buffer, equals)) != strlen(buffer)) {
             key_value_t *kv = malloc(sizeof(key_value_t));
+            kv->key = malloc(sizeof(char)*1024);
+            kv->value = malloc(sizeof(char)*1024);
             strncpy_s(kv->key, BUF_SIZE, buffer, pos);
             strncpy_s(kv->value, BUF_SIZE, buffer + sizeof(char)*(pos+1), sizeof(buffer) - pos - 1);
             data_map_insert_kv(data, kv);
             printf("{%d} Key: |%s| Value: |%s| \n", connection_number, kv->key, kv->value);
         } else {
-            printf("{%d} Client sent: |%s| \n", connection_number, buffer);
+            printf("{%d} Client query: |%s| \n", connection_number, buffer);
+            char *value = data_map_get(data, buffer);
+            if (strcmp(buffer, "version") == 0) {
+                const char *version = "version=Ken's Key-Value Store 1.0";
+                sendto(server, version, strlen(version), 0, (SOCKADDR *) &clientAddr, clientAddrSize);
+            } else {
+                sprintf(buffer, "%s=%s", buffer, value);
+                sendto(server, buffer, strlen(buffer), 0, (SOCKADDR *) &clientAddr, clientAddrSize);
+            }
+
         }
-        sendto(server, buffer, bytesReceived, 0, (SOCKADDR *) &clientAddr, clientAddrSize);
+        // sendto(server, buffer, bytesReceived, 0, (SOCKADDR *) &clientAddr, clientAddrSize);
-        strncpy_s(request, BUF_SIZE, buffer, bytesReceived);
+        // strncpy_s(request, BUF_SIZE, buffer, bytesReceived);
-        printf("{%d} Client sent: |%s| \n", connection_number, request);
+        // printf("{%d} Client sent: |%s| \n", connection_number, request);
         connection_number++;
+        memset(buffer, 0, sizeof(buffer));
     }
     data_map_free(data);
     free(request);
@@ -64,7 +77,7 @@ void data_map_free(data_map_t *map) {
     free(map);
 }
 void data_map_insert_kv(data_map_t *map, key_value_t *kv) {
-    if (map->data == NULL) {
+    if (map==NULL || map->data == NULL) {
         exit(1);
     }
     for (int i = 0; i < map->count; i++) {
@@ -79,8 +92,7 @@ void data_map_insert_kv(data_map_t *map, key_value_t *kv) {
         key_value_t *new_array = realloc(map->data, map->capacity * sizeof(key_value_t));
         map->data = new_array;
     }
-    map->data[map->count].key = kv->key;
+    map->data[map->count] = *kv;
-    map->data[map->count].value = kv->value;
     map->count = new_size;
 }
 
@@ -115,11 +127,11 @@ void data_map_insert(data_map_t *map, char *key, char *value) {
     data_map_append(map, key, value);
 }
 
-char *data_map_get(data_map_t *map, const char *key) {
+char *data_map_get(const data_map_t *map, const char *key) {
     for (int i = 0; i < map->count; i++) {
         if (strcmp(map->data[i].key, key) == 0) {
             return map->data[i].value;
         }
     }
-    return NULL;
+    return "";
 }

server04.h

@@ -25,4 +25,4 @@ void data_map_free(data_map_t *map);
 void data_map_append(data_map_t *map, char *key, char *value);
 void data_map_insert(data_map_t *map, char *key, char *value);
 void data_map_insert_kv(data_map_t *map, key_value_t *kv);
-char *data_map_get(data_map_t *map, const char *key);
+char *data_map_get(const data_map_t *map, const char *key);

server04_database_client_test_suite.py

@@ -4,16 +4,18 @@ import time
 import random
 from typing import Optional, Dict, List, Tuple
 
+
 class DatabaseTestClient:
     def __init__(self, host: str = 'localhost', server_port: int = 40000):
         self.host = host
         self.server_port = server_port
-        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM )
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         # Bind to any available interface (empty string) on an ephemeral port (0)
-        self.sock.bind(('', 0))
+        self.sock.bind(('0.0.0.0', 50000))
         # Get the actual port assigned
         self.client_port = self.sock.getsockname()[1]
-        self.sock.settimeout(1.0)  # 1 second timeout for receives
+        self.sock.settimeout(5.0)  # 1 second timeout for receives
         print(f"Client bound to port {self.client_port}")
 
     def send_insert(self, key: str, value: str) -> None:
@@ -30,7 +32,7 @@ class DatabaseTestClient:
         self.sock.sendto(key.encode(), (self.host, self.server_port))
         
         try:
-            data, addr = self.sock.recvfrom(1000)  # Changed from recvmsg to recvfrom
+            data, addr = self.sock.recvfrom(1024)  # Changed from recvmsg to recvfrom
             return data.decode()
         except socket.timeout:
             return None

server05.c

@@ -0,0 +1,182 @@
+//
+// Created by Ajurna on 30/07/2025.
+//
+
+#include "server05.h"
+#include <pthread.h>
+#include <winsock2.h>
+#include <stdio.h>
+#include "data.h"
+#include <ctype.h>
+#include <stdint.h>
+#include <windows.h>
+#define PCRE2_CODE_UNIT_WIDTH 8
+#include <pcre2.h>
+
+
+const char *newline = "\n";
+const char *bogus_address = "7YWHMfk9JZe0LM0g1ZauHuiSxhI";
+
+int main() {
+    SOCKET server = get_listen_socket();
+    SOCKADDR_IN clientAddr;
+    SOCKET client;
+    int clientAddrSize = sizeof(clientAddr);
+    int connection_number = 1;
+
+    char *message = "Please pay the ticket price of 15 Boguscoins to one of these addresses: 7ABnYzozPt2cyDHQqDq2ExIMz53xXVcErn 7z6kM0VlNJpZiqTEHmRjxW9FbVCkv2flb 7qReHdk11Ai67nRvvfTQXFjPZH3X";
+    char *new_message = replace_bogus_coin(message);
+    // replace_bogus_coin(message);
+    printf("%s\n", new_message);
+    // exit(0);
+    printf("Listening for incoming connections...\n");
+    while((client = accept(server, (SOCKADDR *)&clientAddr, &clientAddrSize)) != INVALID_SOCKET)
+    {
+        handle_args_t *args = malloc(sizeof(handle_args_t));
+        args->client = client;
+        args->server = get_chat_socket();
+        args->connection = connection_number++;
+        pthread_t thread;
+        pthread_create(&thread, nullptr, handle_server, args);
+        pthread_create(&thread, nullptr, handle_client, args);
+    }
+    return 0;
+}
+
+void *handle_server(void *args) {
+    handle_args_t *handleArgs = args;
+    char buffer[1024] = {};
+    int bytesReceived;
+    printf("{%d} Server connected\n", handleArgs->connection);
+    char_array_t *data = char_array_create(1024);
+    while ((bytesReceived = recv(handleArgs->server, buffer, sizeof(buffer), 0)) > 0) {
+        printf("server sent {%d}: |%d| \n", handleArgs->connection, bytesReceived);
+        char_array_append(data, buffer, bytesReceived);
+        char *request;
+        while ((request = char_array_get_until_char(data, '\n')) != NULL) {
+            printf("{%d} server Said: %s\n", handleArgs->connection, request);
+            request = replace_bogus_coin(request);
+            send(handleArgs->client, request, strlen(request), 0);
+            send(handleArgs->client, newline, strlen(newline), 0);
+            free(request);
+        }
+        memset(buffer, 0, sizeof(buffer));
+    }
+    // closesocket(handleArgs->server);
+    return nullptr;
+}
+
+char *replace_bogus_coin(char *message) {
+    pcre2_code *re;
+    PCRE2_SPTR pattern = (PCRE2_SPTR)"\\b7\\w{25,34}\\b";
+    PCRE2_SPTR subject = (PCRE2_SPTR)message;
+    size_t subject_length = strlen((char *)subject);
+    int errornumber;
+    PCRE2_SIZE erroroffset;
+    PCRE2_SIZE *ovector;
+    int rc;
+    size_t offset = 0;  // Keep track of where we are in the string
+
+    // Compile the pattern
+    re = pcre2_compile(
+        pattern,
+        PCRE2_ZERO_TERMINATED,
+        0,
+        &errornumber,
+        &erroroffset,
+        NULL);
+
+    if (re == NULL) {
+        PCRE2_UCHAR buff[256];
+        pcre2_get_error_message(errornumber, buff, sizeof(buff));
+        printf("PCRE2 compilation failed at offset %d: %s\n", (int)erroroffset, buff);
+        return message;
+    }
+
+    // Create match data block
+    pcre2_match_data *match_data = pcre2_match_data_create_from_pattern(re, NULL);
+    char *result = strdup(message);  // Create a copy of the original message
+    
+    // Loop until no more matches are found
+    while (offset < subject_length) {
+        rc = pcre2_match(
+            re,
+            subject,
+            subject_length,
+            offset,     // Start from last match position
+            0,
+            match_data,
+            NULL);
+
+        if (rc < 0) {
+            break;  // No more matches
+        }
+
+        ovector = pcre2_get_ovector_pointer(match_data);
+        PCRE2_SIZE start = ovector[0];
+        PCRE2_SIZE end = ovector[1];
+        
+        // Replace the matched text with bogus_address
+        char *temp = calloc(strlen(result) + strlen(bogus_address) + 1, sizeof(char));
+        strncpy(temp, result, start);
+        strcat(temp, bogus_address);
+        strcat(temp, result + end);
+        
+        free(result);
+        result = temp;
+        
+        // Update the subject and length for next iteration
+        subject = (PCRE2_SPTR)result;
+        subject_length = strlen(result);
+        offset = start + strlen(bogus_address);
+    }
+
+    // Clean up
+    pcre2_match_data_free(match_data);
+    pcre2_code_free(re);
+
+    return result;
+}
+
+void *handle_client(void *args) {
+    handle_args_t *handleArgs = args;
+    char buffer[1024] = {};
+    int bytesReceived;
+    printf("{%d} Client connected\n", handleArgs->connection);
+    char_array_t *data = char_array_create(1024);
+    while ((bytesReceived = recv(handleArgs->client, buffer, sizeof(buffer), 0)) > 0) {
+        printf("server sent {%d}: |%d| \n", handleArgs->connection, bytesReceived);
+        char_array_append(data, buffer, bytesReceived);
+        char *request;
+
+        while ((request = char_array_get_until_char(data, '\n')) != NULL) {
+            printf("{%d} client Said: %s\n", handleArgs->connection, request);
+            request = replace_bogus_coin(request);
+            send(handleArgs->server, request, strlen(request), 0);
+            send(handleArgs->server, newline, strlen(newline), 0);
+            free(request);
+        }
+        memset(buffer, 0, sizeof(buffer));
+    }
+    // closesocket(handleArgs->client);
+    return nullptr;
+}
+
+
+
+SOCKET get_chat_socket() {
+    WSADATA WSAData;
+
+    SOCKADDR_IN serverAddr;
+    struct hostent * host = gethostbyname("chat.protohackers.com");
+    WSAStartup(MAKEWORD(2,0), &WSAData);
+    SOCKET server = socket(AF_INET, SOCK_STREAM, 0 );
+    serverAddr.sin_addr.s_addr = AF_INET;
+    serverAddr.sin_family = AF_INET;
+    memcpy(&serverAddr.sin_addr.s_addr, host->h_addr_list[0], host->h_length);
+
+    serverAddr.sin_port = htons(16963);
+
+    connect(server, (SOCKADDR *) & serverAddr, sizeof (serverAddr));
+    return server;
+}

server05.h

@@ -0,0 +1,31 @@
+//
+// Created by Ajurna on 30/07/2025.
+//
+
+#ifndef SERVER05_H
+#define SERVER05_H
+#include <winsock2.h>
+
+#endif //SERVER05_H
+
+typedef struct HandleArgs {
+    int connection;
+    SOCKET client;
+    SOCKET server;
+}handle_args_t;
+
+typedef struct BogusLocation {
+    size_t start;
+    size_t end;
+} bogus_location_t;
+
+typedef enum SearchState {
+    START,
+    END
+} search_state_t;
+
+void *handle_server(void *args);
+void *handle_client(void *args);
+void send_message(SOCKET dest, const char *message);
+char *replace_bogus_coin(char *message);
+SOCKET get_chat_socket();

server06.c

@@ -0,0 +1,43 @@
+//
+// Created by Ajurna on 01/08/2025.
+//
+
+#include "server06.h"
+#include <winsock2.h>
+#include <pthread.h>
+#include "data.h"
+#include <stdio.h>
+
+int main() {
+    SOCKET server = get_listen_socket();
+    SOCKADDR_IN clientAddr;
+    SOCKET client;
+    int clientAddrSize = sizeof(clientAddr);
+    int connection_number = 1;
+    printf("Listening for incoming connections...\n");
+    while((client = accept(server, (SOCKADDR *)&clientAddr, &clientAddrSize)) != INVALID_SOCKET)
+    {
+        handle_args_t *args = malloc(sizeof(handle_args_t));
+        args->client = client;
+        args->connection = connection_number++;
+        pthread_t thread;
+        pthread_create(&thread, nullptr, handle_connection, args);
+    }
+    return 0;
+}
+
+void *handle_connection(void *args) {
+    handle_args_t *handleArgs = args;
+    char buffer[1024] = {0};
+    int bytesReceived;
+    connection_type_t connection_type = UNKNOWN;
+    byte_array_t *data = byte_array_create(1024);
+    while ((bytesReceived = recv(handleArgs->client, buffer, sizeof(buffer), 0)) > 0) {
+        printf("Client sent {%d}: |%d| \n", handleArgs->connection, bytesReceived);
+        byte_array_append(data, buffer, bytesReceived);
+        char *request;
+        while ((request = byte_array_get_bytes(data, 1)) != NULL) {
+            parse_request(handleArgs, request, data);
+        }
+    }
+}

server06.h

@@ -0,0 +1,70 @@
+//
+// Created by Ajurna on 01/08/2025.
+//
+
+#ifndef SERVER06_H
+#define SERVER06_H
+#include <stdint.h>
+#include <winsock2.h>
+
+#endif //SERVER06_H
+
+typedef struct handleArgs {
+    int connection;
+    SOCKET client;
+}handle_args_t;
+
+typedef enum ConnectionType {
+    UNKNOWN,
+    CAMERA,
+    DISPATCHER,
+} connection_type_t;
+
+typedef enum MessageType {
+    ERROR_MSG = 0x10,
+    PLATE_MSG = 0x20,
+    TICKET_MSG = 0x21,
+    WANT_HEARTBEAT_MSG = 0x40,
+    HEARTBEAT_MSG = 0x41,
+    I_AM_CAMERA_MSG = 0x80,
+    I_AM_DISPATCHER_MSG = 0x81,
+}message_type_t;
+
+typedef struct ErrorMsg {
+    char *message;
+} error_msg_t;
+
+typedef struct PlateMsg {
+    char *plate;
+    uint32_t timestamp;
+} plate_msg_t;
+
+typedef struct TicketMsg {
+    char *plate;
+    uint16_t road;
+    uint16_t mile1;
+    uint32_t timestamp1;
+    uint16_t mile2;
+    uint32_t timestamp2;
+    uint16_t speed;
+} ticket_msg_t;
+
+typedef struct WantHeartbeatMsg {
+    uint32_t timestamp;
+} want_heartbeat_msg_t;
+
+typedef struct HeartbeatMsg {
+
+} heartbeat_msg_t;
+
+typedef struct IAmCameraMsg {
+    uint16_t road;
+    uint16_t mile;
+    uint16_t limit;
+} i_am_camera_msg_t;
+
+typedef struct IAmDispatcherMsg {
+    uint16_t *road;
+} i_am_dispatcher_msg_t;
+
+void *handle_connection(void *args);

speed_ticket_monitoring_system.py

@@ -0,0 +1,141 @@
+import socket
+import struct
+import time
+from threading import Thread
+from typing import List, Optional
+
+class MessageType:
+    ERROR = 0x10
+    PLATE = 0x20
+    TICKET = 0x21
+    WANT_HEARTBEAT = 0x40
+    HEARTBEAT = 0x41
+    I_AM_CAMERA = 0x80
+    I_AM_DISPATCHER = 0x81
+
+class SpeedDaemonClient:
+    def __init__(self, host: str = 'localhost', port: int = 12345):
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.connect((host, port))
+        self.running = True
+        self.received_tickets = []
+        
+    def send_bytes(self, data: bytes):
+        self.socket.send(data)
+        
+    def receive_message(self) -> Optional[tuple]:
+        try:
+            msg_type = self.socket.recv(1)
+            if not msg_type:
+                return None
+                
+            msg_type = msg_type[0]
+            
+            if msg_type == MessageType.ERROR:
+                length = struct.unpack('!B', self.socket.recv(1))[0]
+                message = self.socket.recv(length).decode('ascii')
+                return (MessageType.ERROR, message)
+                
+            elif msg_type == MessageType.TICKET:
+                # Read plate length
+                plate_len = struct.unpack('!B', self.socket.recv(1))[0]
+                plate = self.socket.recv(plate_len).decode('ascii')
+                
+                # Read other fields
+                data = self.socket.recv(16)
+                road, mile1, timestamp1, mile2, timestamp2, speed = struct.unpack('!HHIHHI', data)
+                return (MessageType.TICKET, {
+                    'plate': plate,
+                    'road': road,
+                    'mile1': mile1,
+                    'timestamp1': timestamp1,
+                    'mile2': mile2,
+                    'timestamp2': timestamp2,
+                    'speed': speed
+                })
+                
+            elif msg_type == MessageType.HEARTBEAT:
+                return (MessageType.HEARTBEAT, None)
+                
+        except Exception as e:
+            print(f"Error receiving message: {e}")
+            return None
+            
+    def close(self):
+        self.running = False
+        self.socket.close()
+
+class Camera(SpeedDaemonClient):
+    def __init__(self, road: int, mile: int, limit: int, host: str = 'localhost', port: int = 12345):
+        super().__init__(host, port)
+        self.road = road
+        self.mile = mile
+        self.limit = limit
+        self.register()
+        
+    def register(self):
+        # Send IAmCamera message
+        msg = struct.pack('!BHHH', MessageType.I_AM_CAMERA, self.road, self.mile, self.limit)
+        self.send_bytes(msg)
+        
+    def report_plate(self, plate: str, timestamp: int):
+        # Send Plate message
+        msg = struct.pack(f'!BB{len(plate)}sI', MessageType.PLATE, len(plate), 
+                         plate.encode('ascii'), timestamp)
+        self.send_bytes(msg)
+
+class Dispatcher(SpeedDaemonClient):
+    def __init__(self, roads: List[int], host: str = 'localhost', port: int = 12345):
+        super().__init__(host, port)
+        self.roads = roads
+        self.register()
+        # Start listening for tickets
+        self.listener_thread = Thread(target=self._listen_for_tickets)
+        self.listener_thread.start()
+        
+    def register(self):
+        # Send IAmDispatcher message
+        roads_data = struct.pack(f'!{len(self.roads)}H', *self.roads)
+        msg = struct.pack('!BB', MessageType.I_AM_DISPATCHER, len(self.roads)) + roads_data
+        self.send_bytes(msg)
+        
+    def _listen_for_tickets(self):
+        while self.running:
+            message = self.receive_message()
+            if message and message[0] == MessageType.TICKET:
+                self.received_tickets.append(message[1])
+
+def run_speed_test():
+    # Create a dispatcher for road 123
+    dispatcher = Dispatcher([123])
+    time.sleep(0.1)  # Give dispatcher time to register
+    
+    # Create two cameras on road 123
+    camera1 = Camera(123, 8, 60)  # Camera at mile 8, 60mph limit
+    camera2 = Camera(123, 9, 60)  # Camera at mile 9, same limit
+    time.sleep(0.1)  # Give cameras time to register
+    
+    # Report a speeding car (same as in example session)
+    camera1.report_plate("UN1X", 0)
+    camera2.report_plate("UN1X", 45)  # 1 mile in 45 seconds = 80mph
+    
+    # Wait for ticket processing
+    time.sleep(1)
+    
+    # Check received tickets
+    if dispatcher.received_tickets:
+        print("Test passed! Received tickets:")
+        for ticket in dispatcher.received_tickets:
+            print(f"Plate: {ticket['plate']}")
+            print(f"Road: {ticket['road']}")
+            print(f"Speed: {ticket['speed']/100.0} mph")
+    else:
+        print("Test failed: No tickets received")
+    
+    # Cleanup
+    dispatcher.close()
+    camera1.close()
+    camera2.close()
+
+if __name__ == "__main__":
+    run_speed_test()