Fixed Crashes.

The server now doesn't crash if multiple clients send millions of requests per second.

Author: nosehad

Client.c

@@ -11,7 +11,6 @@ void fallback(void)
 void main(void)
 {
     memclient = memc_open();
-    printf("%d\n", *(char*)memclient->socket);
     atexit(&fallback);
     signal(SIGINT, exit);
 
@@ -21,12 +20,12 @@ void main(void)
         printf("Send Message: ");
         scanf("%[^\n]", &message);
         memc_send(memclient, &message, strlen(&message));
-        printf("%d\n", *(char*)memclient->socket);
-        printf("Recieved Answer: %s\n", memclient->socket+3);
+        printf("%d\n", *(char*)memclient->con.socket);
+        printf("Recieved Answer: %s\n", memclient->con.socket);
         memc_accept(memclient);
-        printf("%d\n", *(char*)memclient->socket);
+        printf("%d\n", *(char*)memclient->con.socket);
     #elif defined(performance)
-        for(unsigned long long l = 0;l < 1000001; ++l)
+        for(unsigned long long l = 0;l < 1000000; ++l)
         {
             memc_send(memclient, &l, 8);
             memc_accept(memclient);
@@ -39,11 +38,12 @@ void main(void)
             char answer[DEFAULT_CONNECTION_BUFFER_SIZE];
             sprintf(&message, "cli: %lld", l);
             memc_send(memclient, &message, strlen(&message)+1);
-            strcpy(&answer, memclient->socket+3);
+            //strcpy(&answer, memclient->con.socket);
             //sleep(1);
+            printf("Recieved Answer: %s\n", memclient->con.socket);
             memc_accept(memclient);
             printf("Sent message: %s\n", &message);
-            printf("Recieved Answer: %s\n", &answer);
+            //printf("Recieved Answer: %s\n", &answer);
         }
     #endif
 }

Client.h

@@ -2,5 +2,6 @@
 
 #include <signal.h>
 #include <stdio.h>
+#include "MemoryConnection.h"
 
 void main();

MemClient.c

@@ -3,44 +3,34 @@
 MemClient* memc_open()
 {
     MemClient* ret = (MemClient*)malloc(sizeof(MemClient));
-    /* create semaphore */
-    ret->socket_lock_server = sem_open(DEFAULT_SERVER_SEMAPHORE_NAME, O_CREAT /* only open if it exists*/, 0644, 1);
-    if (ret->socket_lock_server == SEM_FAILED) {
-        perror("sem_open");
-        exit(-1);
-    }
     /* create shared memory */
-    ret->shm_id = shmget(ftok(DEFAULT_CONNECTION_SHM, 0), DEFAULT_CONNECTION_BUFFER_SIZE, 0666); // create shared memory
+    ret->con.shm_id = shmget(ftok(DEFAULT_CONNECTION_SHM, 0), DEFAULT_CONNECTION_BUFFER_SIZE, 0666); // create shared memory
 
     /* check if shared memory was created successfully */
-    if (ret->shm_id == -1)
+    if (ret->con.shm_id == -1)
     {
         perror("Check if server is running, Error creating shared memory");
-        if (sem_unlink(DEFAULT_SERVER_SEMAPHORE_NAME) == -1)
-            perror("sem_unlink");
         _Exit(-1);
     }
 
     /* attach shared memory to the process's address space */
-    ret->socket = shmat(ret->shm_id, (void*) 0, 0);
-    if (ret->socket == (char*) -1)
+    ret->con.socket = shmat(ret->con.shm_id, (void*) 0, 0);
+    if (ret->con.socket == (char*) -1)
     {
         perror("Error attaching shared memory");
         return 1;
     }
 
-    ret->socket+=3;
+    ret->con.socket+=3;
 
     if(memcon_getState(ret) == MCON_UNVAIL)
     {
         printf("Error: Server not running.\n");
-        /* unlink, since no server running and shared memory not needed */
-        if (sem_unlink(DEFAULT_SERVER_SEMAPHORE_NAME) == -1)
-            perror("sem_unlink");
-        if (shmdt(ret->socket) == -1)
+
+        if (shmdt(ret->con.socket) == -1)
             perror("Error detaching shared memory");
         /* mark shared memory for removal */
-        if (shmctl(ret->shm_id, IPC_RMID, NULL) == -1)
+        if (shmctl(ret->con.shm_id, IPC_RMID, NULL) == -1)
             perror("Error removing shared memory");
         free(ret);
         _Exit(-1);
@@ -50,31 +40,33 @@ MemClient* memc_open()
 
 void memc_send(MemClient* client, void* data, _nmap_size size)
 {
+    client->active = CLIENT_ACTIVE;
     // printf("MemClient.c:53 wait\n");
-    memcon_awaitAndSetState(MCON_EMPTY, MCON_TRANSFER, client);
-    memcpy(client->socket+3, data, size);
-    memcon_updateState(MCON_WAITING, client);
-    sem_post(client->socket_lock_server);
+    memcon_awaitAndSetState(MCON_EMPTY, MCON_TRANSFER, &client->con);
+    memcpy(client->con.socket, data, size);
+    memcon_updateState(MCON_WAITING, &client->con);
     // printf("MemClient.c:58 wait\n");
-    memcon_awaitState(MCON_RESPONSED, client);
+    memcon_awaitState(MCON_RESPONSED, &client->con);
     // printf("MemClient.c:60 done\n");
 }
 
 extern inline void memc_cleanbuf(MemClient* client)
 {
-    memset(client->socket + 3, 0, DEFAULT_CONNECTION_BUFFER_SIZE);
+    memset(client->con.socket, 0, DEFAULT_CONNECTION_BUFFER_SIZE);
 }
 
 extern inline void memc_accept(MemClient* client)
 {
-    memcon_updateState(MCON_EMPTY, client);
+    memcon_updateState(MCON_EMPTY, &client->con);
+    client->active = CLIENT_INACTIVE;
 }
 
 void memc_close(MemClient* client)
 {
-    sem_close(client->socket_lock_server);
+    if(client->active == CLIENT_ACTIVE)
+        memcon_updateState(MCON_EMPTY, &client->con);
     /* detach shared memory */
-    if (shmdt(client->socket - 3) == -1)
+    if (shmdt(client->con.socket - 3) == -1)
     {
         perror("Error detaching shared memory");
         _Exit(-1);

MemClient.h

@@ -16,7 +16,13 @@
     #include "null.h"
     #include "NMap_types.h"
 
-    typedef struct _MemCon MemClient;
+    typedef struct _MemClient MemClient;
+
+    struct _MemClient
+    {
+        struct _MemCon con;
+        unsigned char active;
+    };
 
     MemClient* memc_open();
     /* waits until a message is sent to socket 

MemServer.c

@@ -3,75 +3,67 @@
 MemServer* mems_open()
 {
     MemServer* ret = (MemServer*)malloc(sizeof(MemServer));
-    /* create semaphore */
-    ret->socket_lock_server = sem_open(DEFAULT_SERVER_SEMAPHORE_NAME, O_CREAT, 0644, 1);
-    if (ret->socket_lock_server == SEM_FAILED) {
-        perror("sem_open");
-        exit(-1);
-    }
     /* create shared memory */
-    ret->shm_id = shmget(ftok(DEFAULT_CONNECTION_SHM, 0), DEFAULT_CONNECTION_BUFFER_SIZE, IPC_CREAT | 0666); // create shared memory
+    ret->con.shm_id = shmget(ftok(DEFAULT_CONNECTION_SHM, 0), DEFAULT_CONNECTION_BUFFER_SIZE, IPC_CREAT | 0666); // create shared memory
 
     /* check if shared memory was created successfully */
-    if (ret->shm_id == -1)
+    if (ret->con.shm_id == -1)
     {
         perror("Error creating shared memory");
-        return 1;
+        _Exit(-1);
     }
 
     /* attach shared memory to the process's address space */
-    ret->socket = shmat(ret->shm_id, (void*) 0, 0);
-    if (ret->socket == (char*) -1)
+    ret->con.socket = shmat(ret->con.shm_id, (void*) 0, 0);
+    if (ret->con.socket == (char*) -1)
     {
         perror("Error attaching shared memory");
-        return 1;
+        _Exit(-1);
     }
 
-    memset(ret->socket, 0, DEFAULT_CONNECTION_BUFFER_SIZE);
-    ret->socket+=3;
-    memcon_updateState(MCON_EMPTY, ret);
-    *((char*)ret->update1) = UPDATE_NONE;
+    memset(ret->con.socket, 0, DEFAULT_CONNECTION_BUFFER_SIZE);
+    ret->con.socket+=3;
+    memcon_updateState(MCON_EMPTY, &ret->con);
+    *((char*)ret->con.update1) = UPDATE_NONE;
     return ret;
 }
 
 void mems_wait(MemServer* server)
 {
     // printf("MemServer.c:42 wait\n");
-    memcon_awaitState(MCON_WAITING, server);
+    memcon_awaitState(MCON_WAITING, &server->con);
     // printf("MemServer.c:44 done\n");
 }
 
 extern inline void mems_cleanbuf(MemServer* server)
 {
-    memset(server->socket +3, 0, DEFAULT_CONNECTION_BUFFER_SIZE);
+    memset(server->con.socket, 0, DEFAULT_CONNECTION_BUFFER_SIZE);
 }
 
 extern inline void mems_answer(MemServer* server, void* data, _nmap_size size)
 {
     // printf("answering\n");
-    memcpy(server->socket+3, data, size);
+    memcpy(server->con.socket, data, size);
     // printf("answered\n");
-    memcon_updateState(MCON_RESPONSED, server);
+    memcon_updateState(MCON_RESPONSED, &server->con);
 }
 
 void mems_close(MemServer* server)
 {
-    *((char*)server->socket) = MCON_UNVAIL;
-    sem_close(server->socket_lock_server);
-    sem_unlink(DEFAULT_SERVER_SEMAPHORE_NAME);
+    memcon_updateState(MCON_UNVAIL, &server->con);
 
-    // detach shared memory from process's address space
-    if (shmdt(server->socket-3) == -1)
+    /* detach shared memory from process's address space*/
+    if (shmdt(server->con.socket-3) == -1)
     {
         perror("Error detaching shared memory");
-        return 1;
+        _Exit(-1);
     }
 
-    // mark shared memory for removal
-    if (shmctl(server->shm_id, IPC_RMID, NULL) == -1)
+    /* mark shared memory for removal*/
+    if (shmctl(server->con.shm_id, IPC_RMID, NULL) == -1)
     {
         perror("Error removing shared memory");
-        return 1;
+        _Exit(-1);
     }
     free(server);
 }

MemServer.h

@@ -16,7 +16,12 @@
     #include "null.h"
     #include "NMap_types.h"
 
-    typedef struct _MemCon MemServer;
+    typedef struct _MemServer MemServer;
+
+    struct _MemServer
+    {
+        struct _MemCon con;
+    };
 
     MemServer* mems_open();
     extern inline void mems_answer(MemServer* server, void* data, _nmap_size size);

MemoryConnection.c

@@ -36,8 +36,7 @@ extern inline void memcon_awaitState(enum _ConnectionState state_wait, struct _M
     for(int w = 0;;)
     {
         for(;w < 5; ++w)
-        {
-                            //printf("%d\n", *((char*)con->state1));
+        {;
             if(*((char*)con->state1) == state_wait)
             {
                 if(*((char*)con->update1) != UPDATE)
@@ -46,7 +45,6 @@ extern inline void memcon_awaitState(enum _ConnectionState state_wait, struct _M
         }
         for(;w > -1; --w)
         {
-                            //printf("%d\n", *((char*)con->state2));
             if(*((char*)con->state2) == state_wait)
             {
                 if(*((char*)con->update1) != UPDATE)
@@ -58,9 +56,12 @@ extern inline void memcon_awaitState(enum _ConnectionState state_wait, struct _M
 
 extern inline void memcon_updateState(enum _ConnectionState state_new, struct _MemCon* con)
 {
+    // critical change, didnt found a fix except for waiting
     memcon_setUpdate(UPDATE,con);
+    // usleep(10000);
     *((char*)con->state1) = state_new;
     *((char*)con->state2) = state_new;
+    // usleep(10000);
     memcon_setUpdate(UPDATE_NONE,con);
 }
 

MemoryConnection.h

@@ -40,11 +40,16 @@ typedef void* _mem_socket;
         UPDATE_NONE
     };
 
+    enum _ClientState
+    {
+        CLIENT_INACTIVE,
+        CLIENT_ACTIVE
+    };
+
     struct _MemCon
     {
         _mem_socket socket;
         int shm_id;
-        sem_t*socket_lock_server;
     };
 
     extern inline void memcon_awaitAndSetState(enum _ConnectionState state_wait, enum _ConnectionState state_new, struct _MemCon* con);

Server.c

@@ -16,32 +16,31 @@ void main(void)
     memserver = mems_open();
     #ifdef messanger
         mems_wait(memserver);
-        printf("Recieved Message: %s\n", memserver->socket+1);
+        printf("Recieved Message: %s\n", memserver->con.socket);
         printf("Send answer: ");
         char answer[DEFAULT_CONNECTION_BUFFER_SIZE];
         scanf("%[^\n]", &answer);
-        mems_answer(memserver, &answer, strlen(&answer));
+        mems_answer(memserver, &answer, strlen(&answer)+1);
         exit(0);
     #elif defined(performance)
         long long l;
         long long answer = 1;
         for(;;)
         {
             mems_wait(memserver);
-            l = *(long long*)(((char*)memserver->socket) + 3);
+            l = *(long long*)(((char*)memserver->con.socket));
             mems_answer(memserver, &answer, 8);
             if(l % 10000 == 0)
                 printf("%lld\n", l);
         }
     #else
+        char answer[DEFAULT_CONNECTION_BUFFER_SIZE];
         for(long long l;++l;)
         {
             mems_wait(memserver);
-            //printf("Recieved Message: %s\n", memserver->socket+1);
-            char answer[DEFAULT_CONNECTION_BUFFER_SIZE];
+            printf("Recieved Message: %s\n", memserver->con.socket);
             sprintf(&answer, "ser: %d", l);
-            //sleep(1);
-            mems_answer(memserver, &answer, strlen(&answer) +1 );
+            mems_answer(memserver, &answer, strlen(&answer)+1);
         }
     #endif
 }

server.sh

@@ -1,9 +1,9 @@
 # check if GCC is installed
 if command -v gcc >/dev/null 2>&1; then
 if [ $# -gt 0 ]; then
-    c99 Server.c MemoryConnection.c MemServer.c -D$1 -w -O3 -o /tmp/ndbs-out && /tmp/ndbs-out
+    c99 Server.c SString.c MemoryConnection.c MemServer.c -D$1 -w -O3 -o /tmp/ndbs-out && /tmp/ndbs-out
 else
-    c99 Server.c MemoryConnection.c MemServer.c -w -O3 -o /tmp/ndbs-out && /tmp/ndbs-out
+    c99 Server.c SString.c MemoryConnection.c MemServer.c -w -O3 -o /tmp/ndbs-out && /tmp/ndbs-out
 fi
 else
     echo -e "\033[1m\033[31mError\033[0m: The GNU Compiler Colection GCC isn't installed on your system."