extract buffer, tcp_package

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

CMakeLists.txt

@@ -6,7 +6,7 @@ set(CMAKE_C_STANDARD 99)
 include_directories(c:/Users/nicol/dev/thirdparty/protobuf-c)
 link_directories(c:/Users/nicol/dev/thirdparty/protobuf-c/protobuf-c/.libs)
 
-add_executable(esc main.c mutex.c mutex.h thread.c thread.h socket.c socket.h esc.c esc.h ClientMessageDtos.pb-c.c ClientMessageDtos.pb-c.h uuid.c uuid.h)
+add_executable(esc main.c mutex.c mutex.h thread.c thread.h socket.c socket.h esc.c esc.h ClientMessageDtos.pb-c.c ClientMessageDtos.pb-c.h uuid.c uuid.h buffer.c buffer.h tcp_package.c tcp_package.h)
 
 if(WIN32)
     target_link_libraries(esc wsock32 ws2_32 libprotobuf-c.a)

buffer.c

@@ -0,0 +1,20 @@
+//
+// Created by nicol on 2018-03-18.
+//
+
+#include <stdlib.h>
+#include "buffer.h"
+
+const buffer_t buffer_create(uint32_t size) {
+    buffer_t buf = {size, malloc(size)};
+    return buf;
+}
+
+const buffer_t buffer_from(uint8_t* data, uint32_t size) {
+    buffer_t buf = {size, data};
+    return buf;
+}
+
+void buffer_free(buffer_t buffer) {
+    free(buffer.data);
+}

buffer.h

@@ -0,0 +1,20 @@
+//
+// Created by nicol on 2018-03-18.
+//
+
+#ifndef ESC_BUFFER_H
+#define ESC_BUFFER_H
+
+#include <stdint.h>
+
+struct st_buffer {
+    uint32_t size;
+    uint8_t* data;
+};
+typedef struct st_buffer buffer_t;
+
+const buffer_t buffer_create(uint32_t size);
+const buffer_t buffer_from(uint8_t* data, uint32_t size);
+void buffer_free(buffer_t buffer);
+
+#endif //ESC_BUFFER_H

esc.c

@@ -8,112 +8,9 @@
 #include <winsock2.h>
 #include "esc.h"
 #include "socket.h"
-#include "uuid.h"
+#include "buffer.h"
 #include "ClientMessageDtos.pb-c.h"
-
+#include "tcp_package.h"
-struct st_buffer {
-    uint32_t size;
-    uint8_t* data;
-};
-typedef struct st_buffer buffer_t;
-
-const buffer_t buffer_create(uint32_t size) {
-    buffer_t buf = {size, malloc(size)};
-    return buf;
-}
-
-const buffer_t buffer_from(uint8_t* data, uint32_t size) {
-    buffer_t buf = {size, data};
-    return buf;
-}
-
-void buffer_free(buffer_t buffer) {
-    free(buffer.data);
-}
-
-struct st_tcp_package {
-    uint8_t command;
-    uint8_t flags;
-    esc_uuid_t correlation_id;
-    const char* login;
-    const char* password;
-    buffer_t data;
-};
-typedef struct st_tcp_package tcp_package_t;
-
-const uint32_t CommandOffset = 0;
-const uint32_t FlagsOffset = 1;
-const uint32_t CorrelationOffset = 2;
-const uint32_t AuthOffset = 18;
-const uint32_t MandatorySize = 18;
-
-const tcp_package_t* tcp_package_create(uint8_t command, const esc_uuid_t* correlation_id, buffer_t data) {
-    tcp_package_t* pkg = malloc(sizeof(tcp_package_t));
-    pkg->command = command;
-    pkg->flags = 0;
-    pkg->correlation_id = *correlation_id;
-    pkg->login = 0;
-    pkg->password = 0;
-    pkg->data = data;
-    return pkg;
-}
-
-const tcp_package_t* tcp_package_create_authenticated(uint8_t command, const esc_uuid_t* correlation_id, buffer_t data, const char* username, const char* password) {
-    tcp_package_t* pkg = malloc(sizeof(tcp_package_t));
-    pkg->command = command;
-    pkg->flags = 1;
-    pkg->correlation_id = *correlation_id;
-    pkg->login = username;
-    pkg->password = password;
-    pkg->data = data;
-    return pkg;
-}
-
-void tcp_package_free(const tcp_package_t* pkg) {
-    buffer_free(pkg->data);
-    free((void*)pkg);
-}
-
-buffer_t tcp_package_to_buffer(const tcp_package_t* pkg) {
-    uint8_t* _dst = malloc(MandatorySize + pkg->data.size + (pkg->flags ? 257*2 : 0));
-    _dst[CommandOffset] = pkg->command;
-    _dst[FlagsOffset] = pkg->flags;
-    memcpy(&_dst[CorrelationOffset], &pkg->correlation_id, sizeof(esc_uuid_t));
-    size_t size = MandatorySize;
-    if (pkg->flags) {
-        size_t l_len = strlen(pkg->login);
-        _dst[AuthOffset] = l_len;
-        strcpy(&_dst[AuthOffset+1], pkg->login);
-        size_t p_len = strlen(pkg->password);
-        _dst[AuthOffset+1+l_len] = p_len;
-        strcpy(&_dst[AuthOffset+2+l_len], pkg->password);
-        memcpy(&_dst[AuthOffset+2+l_len+p_len], pkg->data.data, pkg->data.size);
-        size += 2 + l_len + p_len + pkg->data.size;
-    } else {
-        memcpy(&_dst[AuthOffset], pkg->data.data, pkg->data.size);
-        size += pkg->data.size;
-    }
-    return buffer_from(_dst, size);
-}
-
-const tcp_package_t* tcp_package_from_buffer(buffer_t buffer) {
-    tcp_package_t* pkg = malloc(sizeof(tcp_package_t));
-    pkg->command = buffer.data[CommandOffset];
-    pkg->flags = buffer.data[FlagsOffset];
-    memcpy(&pkg->correlation_id, &buffer.data[CorrelationOffset], sizeof(esc_uuid_t));
-    if (pkg->flags) {
-        size_t l_len = buffer.data[AuthOffset];
-        size_t p_len = buffer.data[AuthOffset+1+l_len];
-        pkg->data = buffer_create(buffer.size - MandatorySize - 2 - l_len - p_len);
-        memcpy(pkg->data.data, &buffer.data[MandatorySize + 2 + l_len + p_len], buffer.size - MandatorySize - 2 - l_len - p_len);
-    } else {
-        pkg->login = 0;
-        pkg->password = 0;
-        pkg->data = buffer_create(buffer.size - MandatorySize);
-        memcpy(pkg->data.data, &buffer.data[MandatorySize], buffer.size - MandatorySize);
-    }
-    return pkg;
-}
 
 struct st_connection_settings {
     unsigned char use_ssl_connection;
@@ -283,10 +180,17 @@ const esc_credentials_t* esc_credentials_create(const char* username, const char
     return creds;
 }
 
+const char* string_clone(const char* src) {
+    char* dst = malloc(strlen(src)+1);
+    strcpy(dst, src);
+    return dst;
+}
+
 const esc_recorded_event_t* recorded_event_create(EventStore__Client__Messages__EventRecord* msg) {
     if (msg == 0) return 0;
     esc_recorded_event_t* ev = malloc(sizeof(esc_recorded_event_t));
     ev->event_id = esc_uuid_from(msg->event_id.data, msg->event_id.len);
+    ev->event_type = string_clone(msg->event_type);
     return ev;
 }
 
@@ -338,6 +242,7 @@ const esc_all_events_slice_t* esc_connection_read_all_forward(const esc_connecti
     for (size_t i = 0; i < recv_msg->n_events; i++) {
         result->events[i] = resolved_event_create(recv_msg->events[i]);
     }
+    event_store__client__messages__read_all_events_completed__free_unpacked(recv_msg, &conn->protobuf_c_allocator);
 
     return result;
 }

esc.h

@@ -27,6 +27,7 @@ typedef struct st_esc_position esc_position_t;
 
 struct st_recorded_event {
     const esc_uuid_t* event_id;
+    const char* event_type;
 };
 typedef struct st_recorded_event esc_recorded_event_t;
 

main.c

@@ -1,29 +1,8 @@
 #include <stdio.h>
 
 #include "mutex.h"
-#include "thread.h"
-#include "socket.h"
 #include "esc.h"
 
-
-/*
-unsigned long my_first_thread(void* arg) {
-    mutex_t mut = arg;
-    mutex_lock(mut);
-    printf("1\n");
-    mutex_unlock(mut);
-    return 0;
-}
-
-unsigned long my_second_thread(void* arg) {
-    mutex_t mut = arg;
-    mutex_lock(mut);
-    printf("2\n");
-    mutex_unlock(mut);
-    return 0;
-}
-*/
-
 int main() {
 #ifdef _WIN32
     WSADATA wsaData;
@@ -38,45 +17,26 @@ int main() {
         return -2;
     }
     const esc_credentials_t* credentials = esc_credentials_create("admin", "changeit");
-    const esc_all_events_slice_t* result = esc_connection_read_all_forward(conn, NULL, 1024, credentials);
-    if (result == 0) {
-        return -3;
-    }
-    char posbuf1[44];
-    char posbuf2[44];
-    printf("%s %s %s %u\n", result->read_direction,
-            esc_position_format(&result->from_position, posbuf1, 44),
-            esc_position_format(&result->next_position, posbuf2, 44),
-            result->is_end_of_stream);
-    char uuid_buf[37];
-    for(size_t i = 0; i < result->n_events; i++) {
-        printf("%s\n", esc_uuid_format(result->events[i]->event->event_id, uuid_buf, 37));
-    }
 
-/*
+    const esc_all_events_slice_t *result = 0;
-    socket_t s = socket_create(IPPROTO_TCP);
+    do {
-    socket_connect(s, "www.google.ca", 80);
+        result = esc_connection_read_all_forward(conn, result ? &result->next_position : NULL, 1024, credentials);
-    char* req = "GET / HTTP/1.1\r\nHost: www.google.ca\r\nConnection: close\r\n\r\n";
+        if (result == 0) {
-    socket_send(s, req, strlen(req));
+            return -3;
-    char buffer[4096];
+        }
-    memset(buffer, 0, 4096);
+        char posbuf1[44];
-    int rc;
+        char posbuf2[44];
-    while ((rc = socket_recv(s, buffer, 4096)) > 0) {
+        printf("%s %s %s %u\n", result->read_direction,
-        printf_s("%s", buffer);
+               esc_position_format(&result->from_position, posbuf1, 44),
-        memset(buffer, 0, 4096);
+               esc_position_format(&result->next_position, posbuf2, 44),
-    }
+               result->is_end_of_stream);
-    socket_close(s);
+        char uuid_buf[37];
+        for (size_t i = 0; i < result->n_events; i++) {
+            printf("%s %s\n", esc_uuid_format(result->events[i]->event->event_id, uuid_buf, 37),
+                   result->events[i]->event->event_type);
+        }
+    } while(result->is_end_of_stream == 0);
 
-    mutex_t sync = mutex_create();
-    thread_t one = thread_create(my_first_thread, sync);
-    thread_t two = thread_create(my_second_thread, sync);
-    thread_start(one);
-    thread_start(two);
-    printf("Hello, World!\n");
-    thread_destroy(one);
-    thread_destroy(two);
-    mutex_destroy(sync);
-*/
 #ifdef _WIN32
     WSACleanup();
 #endif

tcp_package.c

@@ -0,0 +1,82 @@
+//
+// Created by nicol on 2018-03-18.
+//
+
+#include <memory.h>
+#include <stdlib.h>
+#include <mem.h>
+#include "tcp_package.h"
+
+const uint32_t CommandOffset = 0;
+const uint32_t FlagsOffset = 1;
+const uint32_t CorrelationOffset = 2;
+const uint32_t AuthOffset = 18;
+const uint32_t MandatorySize = 18;
+
+const tcp_package_t* tcp_package_create(uint8_t command, const esc_uuid_t* correlation_id, buffer_t data) {
+    tcp_package_t* pkg = malloc(sizeof(tcp_package_t));
+    pkg->command = command;
+    pkg->flags = 0;
+    pkg->correlation_id = *correlation_id;
+    pkg->login = 0;
+    pkg->password = 0;
+    pkg->data = data;
+    return pkg;
+}
+
+const tcp_package_t* tcp_package_create_authenticated(uint8_t command, const esc_uuid_t* correlation_id, buffer_t data, const char* username, const char* password) {
+    tcp_package_t* pkg = malloc(sizeof(tcp_package_t));
+    pkg->command = command;
+    pkg->flags = 1;
+    pkg->correlation_id = *correlation_id;
+    pkg->login = username;
+    pkg->password = password;
+    pkg->data = data;
+    return pkg;
+}
+
+void tcp_package_free(const tcp_package_t* pkg) {
+    buffer_free(pkg->data);
+    free((void*)pkg);
+}
+
+buffer_t tcp_package_to_buffer(const tcp_package_t* pkg) {
+    uint8_t* _dst = malloc(MandatorySize + pkg->data.size + (pkg->flags ? 257*2 : 0));
+    _dst[CommandOffset] = pkg->command;
+    _dst[FlagsOffset] = pkg->flags;
+    memcpy(&_dst[CorrelationOffset], &pkg->correlation_id, sizeof(esc_uuid_t));
+    size_t size = MandatorySize;
+    if (pkg->flags) {
+        size_t l_len = strlen(pkg->login);
+        _dst[AuthOffset] = l_len;
+        strcpy(&_dst[AuthOffset+1], pkg->login);
+        size_t p_len = strlen(pkg->password);
+        _dst[AuthOffset+1+l_len] = p_len;
+        strcpy(&_dst[AuthOffset+2+l_len], pkg->password);
+        memcpy(&_dst[AuthOffset+2+l_len+p_len], pkg->data.data, pkg->data.size);
+        size += 2 + l_len + p_len + pkg->data.size;
+    } else {
+        memcpy(&_dst[AuthOffset], pkg->data.data, pkg->data.size);
+        size += pkg->data.size;
+    }
+    return buffer_from(_dst, size);
+}
+
+const tcp_package_t* tcp_package_from_buffer(buffer_t buffer) {
+    tcp_package_t* pkg = malloc(sizeof(tcp_package_t));
+    pkg->command = buffer.data[CommandOffset];
+    pkg->flags = buffer.data[FlagsOffset];
+    memcpy(&pkg->correlation_id, &buffer.data[CorrelationOffset], sizeof(esc_uuid_t));
+    if (pkg->flags) {
+        size_t l_len = buffer.data[AuthOffset];
+        size_t p_len = buffer.data[AuthOffset+1+l_len];
+        pkg->data = buffer_create(buffer.size - MandatorySize - 2 - l_len - p_len);
+        memcpy(pkg->data.data, &buffer.data[MandatorySize + 2 + l_len + p_len], buffer.size - MandatorySize - 2 - l_len - p_len);
+    } else {
+        pkg->login = 0;
+        pkg->password = 0;
+        pkg->data = buffer_create(buffer.size - MandatorySize);
+        memcpy(pkg->data.data, &buffer.data[MandatorySize], buffer.size - MandatorySize);
+    }
+    return pkg;
+}

tcp_package.h

@@ -0,0 +1,27 @@
+//
+// Created by nicol on 2018-03-18.
+//
+
+#ifndef ESC_TCP_PACKAGE_H
+#define ESC_TCP_PACKAGE_H
+
+#include "buffer.h"
+#include "uuid.h"
+
+struct st_tcp_package {
+    uint8_t command;
+    uint8_t flags;
+    esc_uuid_t correlation_id;
+    const char* login;
+    const char* password;
+    buffer_t data;
+};
+typedef struct st_tcp_package tcp_package_t;
+
+const tcp_package_t* tcp_package_create(uint8_t command, const esc_uuid_t* correlation_id, buffer_t data);
+const tcp_package_t* tcp_package_create_authenticated(uint8_t command, const esc_uuid_t* correlation_id, buffer_t data, const char* username, const char* password);
+void tcp_package_free(const tcp_package_t* pkg);
+buffer_t tcp_package_to_buffer(const tcp_package_t* pkg);
+const tcp_package_t* tcp_package_from_buffer(buffer_t buffer);
+
+#endif //ESC_TCP_PACKAGE_H