network protocol skeleton of issuer and member finished, missing verifier

.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/ecdaa_issuer.iml" filepath="$PROJECT_DIR$/.idea/ecdaa_issuer.iml" />
+      <module fileurl="file://$PROJECT_DIR$/../ecdaa_net/.idea/ecdaa_issuer.iml" filepath="$PROJECT_DIR$/../ecdaa_net/.idea/ecdaa_issuer.iml" />
     </modules>
   </component>
 </project>

CMakeLists.txt

@@ -4,12 +4,12 @@ project(ecdaa_issuer C)
 set(CMAKE_C_STANDARD 11)
 set(ECDAA_AMCL "/opt/amcl")
 
-add_executable(ecdaa_issuer issuer.c connection.h connection.c server.h server.c)
+add_executable(ecdaa_issuer issuer.c common.h server.h server.c)
 target_include_directories(ecdaa_issuer PUBLIC
         ${ECDAA_AMCL}
         )
 target_link_libraries(ecdaa_issuer /usr/local/lib/libecdaa.so)
-add_executable(ecdaa_member member.c connection.h connection.c client.h client.c server.h server.c)
+add_executable(ecdaa_member member.c common.h client.h client.c server.h server.c issuer.h)
 target_include_directories(ecdaa_member PUBLIC
         ${ECDAA_AMCL}
         )

client.c

@@ -1,61 +1,67 @@
 #include "client.h"
 
-client_t* client_open(conn_handler handler) {
+int client_open(char *servip, int16_t port) {
     struct sockaddr_in servaddr;
-    client_t *client = malloc(sizeof(client_t));
+    size_t servaddr_len = 0;
-    if(NULL == handler) {
+    int connfd = 0;
-        printf("client_open: received empty handler, stopping");
-        return NULL;
-    }
-    if (NULL == client) {
-        printf("client_open: malloc failed");
-        return NULL;
-    }
-    client->conn = connection_create(CONN_TYPE_CLIENT);
-    if (NULL == client->conn) {
-        free(client);
-        return NULL;
-    }
-    client->handler = handler;
-    client->conn->fd = socket(AF_INET, SOCK_STREAM, 0);
-    if (-1 == client->conn->fd) {
-        printf("client_listen: failed to create endpoint.\n");
-        return NULL;
-    }
-    return client;
-}
 
-int client_connect(client_t *client, char *ip_str, int16_t port) {
+    connfd = socket(AF_INET, SOCK_STREAM, 0);
-    struct sockaddr_in servaddr;
+    if (-1 == connfd) {
-    unsigned int servaddr_len = 0;
+        printf("client_listen: failed to create endpoint.\n");
-
-    if(client == NULL) {
         return -1;
     }
+    bzero(&servaddr, sizeof(servaddr));
 
     servaddr.sin_family = AF_INET;
-    servaddr.sin_addr.s_addr = inet_addr(ip_str);
+    servaddr.sin_addr.s_addr = inet_addr(servip);
     servaddr.sin_port = htons(port);
-
     servaddr_len = sizeof(servaddr);
-    if(0 >= connect(client->conn->fd, (const struct sockaddr *) &servaddr, servaddr_len)) {
+    if (0 != connect(connfd, (const struct sockaddr *) &servaddr, servaddr_len)) {
         printf("client_accept: connection to server failed\n");
+        close(connfd);
         return -1;
-    } else {
-        client->handler(client->conn->fd);
     }
-    return 0;
+    return connfd;
 }
 
-int client_close(client_t *client) {
+int client_connect(conn_handler handler, char *servip, int16_t port) {
-    int err = 0;
+    struct sockaddr_in servaddr;
-    if (NULL == client) {
+    unsigned int servaddr_len = 0;
-        return 0;
+    int connfd = 0;
+    char buffer[MAX_BUFSIZE];
+    int ret = 0;
+    int len = 0;
+
+    connfd = client_open(servip, port);
+    if(0 >= connfd) {
+        return -1;
+    }
+    bzero(buffer, MAX_BUFSIZE);
+    for (ret = 0; 0 == ret;) {
+        ret = handler(buffer);
+        if(0 != ret)
+            break;
+
+        if (0 >= write(connfd, buffer, sizeof(buffer))) {
+            printf("client_connect: cannot write to socket\n");
+            ret = -1;
+        }
+
+        bzero(buffer, MAX_BUFSIZE);
+        len = read(connfd, buffer, sizeof(buffer));
+        if (0 > len) {
+            printf("client_connect: cannot read from socket\n");
+            ret = -1;
+        } else if (0 == len) {
+            printf("client_connect: server closed connection\n");
+            ret = 1;
+        }
     }
-    if (0 != connection_destroy(client->conn)) {
+
-        printf("client_close: closing socket failed\n");
+    if (0 != close(connfd)) {
-        err = -1;
+        printf("client_connect: failed to close server connection properly\n");
+        ret = -1;
     }
-    free(client);
+
-    return err;
+    return ret;
 }

client.h

@@ -8,23 +8,10 @@
 #include <string.h>
 #include <stdio.h>
 #include <sys/socket.h>
-#include <netinet/in.h>
 #include <unistd.h>
-//#include <netinet/in.h>
 #include <arpa/inet.h>
-#include "connection.h"
+#include "common.h"
 
-#define MAX_BUFSIZE 1024
+int client_connect(conn_handler handler, char *ip_str, int16_t port);
-
-typedef struct client {
-    connection_t* conn;
-    conn_handler handler;
-}client_t;
-
-client_t* client_open(conn_handler handler);
-
-int client_connect(client_t *client, char *ip_str, int16_t port);
-
-int client_close(client_t* client);
 
 #endif //ECDAA_ISSUER_CLIENT_H

common.h

@@ -0,0 +1,21 @@
+//
+// Created by root on 10/30/19.
+//
+
+#ifndef ECDAA_ISSUER_COMMON_H
+#define ECDAA_ISSUER_COMMON_H
+
+#define ISSUERIP "127.0.0.1"
+#define ISSUERPORT 6590
+#define MEMBERIP "127.0.0.1"
+#define MEMBERPORT 6591
+#define VERIFIERIP "127.0.0.1"
+#define VERIFIERPORT 6592
+
+#define MAX_CLIENTS 10
+#define MAX_BUFSIZE 1024
+
+typedef int (*conn_handler)(char* buffer);
+
+
+#endif //ECDAA_ISSUER_COMMON_H

connection.c

@@ -1,29 +0,0 @@
-#include <unistd.h>
-#include "connection.h"
-
-connection_t* connection_create(conntype_e type){
-    connection_t* conn = malloc(sizeof(connection_t));
-    if(NULL == conn) {
-        printf("connection_create: malloc failed\n");
-    } else {
-        conn->type = type;
-        conn->fd = -1;
-    }
-
-    return conn;
-}
-
-int connection_destroy(connection_t* conn) {
-    int err = 0;
-
-    if(NULL != conn) {
-        if(-1 != conn->fd) {
-            err = close(conn->fd);
-            if(-1 == err) {
-                printf("connection_destroy: close connection failed");
-            }
-        }
-        free(conn);
-    }
-    return err;
-}

connection.h

@@ -1,26 +0,0 @@
-//
-// Created by root on 10/30/19.
-//
-
-#ifndef ECDAA_ISSUER_CONNECTION_H
-#define ECDAA_ISSUER_CONNECTION_H
-
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef enum conntype {
-    CONN_TYPE_SERVER,
-    CONN_TYPE_CLIENT
-}conntype_e;
-
-typedef struct connection {
-    int fd;
-    conntype_e type;
-} connection_t;
-
-typedef int (*conn_handler)(int fd);
-
-connection_t* connection_create(conntype_e type);
-int connection_destroy(connection_t* conn);
-
-#endif //ECDAA_ISSUER_CONNECTION_H

issuer.c

@@ -1,156 +1,125 @@
-#include <stdio.h>
+#include "issuer.h"
-#include <string.h>
-#include <ecdaa.h>
-#include "server.h"
-#include "client.h"
-
-#define ISSUERIP "127.0.0.1"
-#define ISSUERPORT 6590
-#define MEMBERIP "127.0.0.1"
-#define MEMBERPORT 6591
-#define VERIFIERIP "127.0.0.1"
-#define VERIFIERPORT 6592
-
-typedef struct issuer {
-    struct ecdaa_issuer_public_key_FP256BN ipk;
-    struct ecdaa_issuer_secret_key_FP256BN isk;
-} issuer_t;
 
 typedef enum issuer_state {
     ON,
-    SETUPDONE,
     JOINSTART,
     JOINPROCEED,
-    PUBLISH,
     READY
 } issuerstate_e;
 
-int process_issuer(int connfd);
+typedef struct issuer {
+    struct ecdaa_issuer_public_key_FP256BN ipk;
+    struct ecdaa_issuer_secret_key_FP256BN isk;
+    issuerstate_e state;
+} issuer_t;
+
+issuer_t issuer;
+
 
 int main() {
     int err = 0;
-    server_t *server;
-
-    server = server_open(&process_issuer, ISSUERPORT);
-    if (NULL == server) {
-        printf("listen failed, closing...\n");
-    }
 
-    for (; !err;) {
+    if (2 != server_start(&process_issuer, ISSUERPORT)) {
-        err = server_accept(server);
+        printf("server failed\n");
-        if (1 == err) {
-            printf("graceful shutdown...\n");
-        } else if (err) {
-            printf("accept failed, closing...\n");
-        }
     }
-    printf("shut down server\n");
-    server_close(server);
     return 0;
 }
 
-int process_issuer(int connfd) {
+int process_issuer(char *buffer) {
-    char inbuf[MAX_BUFSIZE];
+    ssize_t len = 0;
-    char outbuf[MAX_BUFSIZE];
+    int ret = 0;
-    int ret = 2;
-    issuerstate_e state = ON;
 
-    while (ret == 2) {
+    printf("> ISSUER: %s\n", buffer);
-        bzero(inbuf, MAX_BUFSIZE);
-        bzero(outbuf, MAX_BUFSIZE);
 
-        if (0 >= read(connfd, inbuf, sizeof(inbuf))) {
+    if (0 == strncasecmp("OK", buffer, 2)) {
-            printf("process_member: cannot read from socket\n");
+        switch (issuer.state) {
-            ret = -1;
+            case JOINPROCEED:
+                issuer.state = READY;
+                break;
+            default:
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "ERR\n", 4);
+                break;
         }
-        printf("> ISSUER: %s\n", inbuf);
+    } else if (0 == strncasecmp("ERR", buffer, 3)) {
-
+        switch (issuer.state) {
-
+            case JOINPROCEED:
-        if (0 == strncmp("OK", inbuf, 2)) {
+                printf("command failed at client\n");
-            switch (state) {
+                issuer.state = READY;
-                case SETUPDONE:
+                break;
-                case JOINPROCEED:
+            default:
-                case PUBLISH:
+                bzero(buffer, MAX_BUFSIZE);
-                    state = READY;
+                strncpy(buffer, "ERR\n", 4);
-                    break;
+                break;
-                default:
-                    strncpy(outbuf, "ERR\n", 4);
-                    break;
-            }
-        } else if (0 == strncmp("ERR", inbuf, 3)) {
-            switch (state) {
-                case SETUPDONE:
-                case JOINPROCEED:
-                case PUBLISH:
-                    printf("command failed at client\n");
-                    state = READY;
-                    break;
-                default:
-                    printf("invalid instruction\n");
-                    strncpy(outbuf, "ERR\n", 4);
-                    break;
-            }
-        } else if (0 == strncmp("SETUP", inbuf, 5)) {
-            switch (state) {
-                case ON:
-                    printf("setup()\n");
-                    strncpy(outbuf, "SETUPDONE\n", 10);
-                    state = SETUPDONE;
-                    break;
-                default:
-                    strncpy(outbuf, "ERR\n", 4);
-                    break;
-            }
-        } else if (0 == strncmp("JOIN", inbuf, 4)) {
-            switch (state) {
-                case READY:
-                    printf("join()\n");
-                    strncpy(outbuf, "JOINSTART\n", 10);
-                    state = JOINSTART;
-                    break;
-                default:
-                    strncpy(outbuf, "ERR\n", 4);
-                    break;
-            }
-        } else if (0 == strncmp("APPEND", inbuf, 6)) {
-            switch (state) {
-                case JOINSTART:
-                    printf("append()\n");
-                    strncpy(outbuf, "JOINPROCEED\n", 12);
-                    state = JOINPROCEED;
-                    break;
-                default:
-                    strncpy(outbuf, "ERR\n", 4);
-                    break;
-            }
-        } else if (0 == strncmp("PUBLISH", inbuf, 7)) {
-            switch (state) {
-                case READY:
-                    printf("publish()\n");
-                    strncpy(outbuf, "PUBLISH\n", 8);
-                    state = PUBLISH;
-                    break;
-                default:
-                    strncpy(outbuf, "ERR\n", 4);
-                    break;
-            }
-        } else if (0 == strncmp("EXIT", inbuf, 4)) {
-            printf("exit()\n");
-            strncpy(outbuf, "OK\n", 3);
-            ret = 0;
-        } else if (0 == strncmp("SHUTDOWN", inbuf, 8)) {
-            strncpy(outbuf, "OK\n", 3);
-            ret = 1;
-        } else {
-            printf("error()\n");
-            strncpy(outbuf, "ERR\n", 4);
-            ret = 0;
         }
-
+    } else if (0 == strncasecmp("SETUP", buffer, 5)) {
-        printf("< ISSUER: %s\n", outbuf);
+        switch (issuer.state) {
-        write(connfd, outbuf, sizeof(outbuf));
+            case ON:
+                printf("setup()\n");
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "SETUPDONE\n", 10);
+                issuer.state = READY;
+                break;
+            default:
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "ERR\n", 4);
+                break;
+        }
+    } else if (0 == strncasecmp("JOIN", buffer, 4)) {
+        switch (issuer.state) {
+            case READY:
+                printf("join()\n");
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "JOINSTART\n", 10);
+                issuer.state = JOINSTART;
+                break;
+            default:
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "ERR\n", 4);
+                break;
+        }
+    } else if (0 == strncasecmp("APPEND", buffer, 6)) {
+        switch (issuer.state) {
+            case JOINSTART:
+                printf("append()\n");
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "JOINPROCEED\n", 12);
+                issuer.state = READY;
+                break;
+            default:
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "ERR\n", 4);
+                break;
+        }
+    } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
+        switch (issuer.state) {
+            case READY:
+                printf("publish()\n");
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "PUBLISH\n", 8);
+                issuer.state = READY;
+                break;
+            default:
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "ERR\n", 4);
+                break;
+        }
+    } else if (0 == strncasecmp("EXIT", buffer, 4)) {
+        printf("exit()\n");
+        bzero(buffer, MAX_BUFSIZE);
+        strncpy(buffer, "OK\n", 3);
+        ret = 1;
+    } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
+        bzero(buffer, MAX_BUFSIZE);
+        strncpy(buffer, "OK\n", 3);
+        ret = 2;
+    } else {
+        printf("error()\n");
+        bzero(buffer, MAX_BUFSIZE);
+        strncpy(buffer, "ERR\n", 4);
+        ret = 0;
     }
 
-    return
+    printf("< ISSUER: %s", buffer);
-            ret;
+    return ret;
 }

issuer.h

@@ -0,0 +1,16 @@
+//
+// Created by root on 11/5/19.
+//
+
+#ifndef ECDAA_ISSUER_ISSUER_H
+#define ECDAA_ISSUER_ISSUER_H
+#include <stdio.h>
+#include <string.h>
+#include <ecdaa.h>
+#include "server.h"
+#include "client.h"
+#include "common.h"
+
+int process_issuer(char *buffer);
+
+#endif //ECDAA_ISSUER_ISSUER_H

member.c

@@ -4,148 +4,126 @@
 #include "client.h"
 #include "server.h"
 
-#define ISSUERIP "127.0.0.1"
-#define ISSUERPORT 6590
-#define MEMBERIP "127.0.0.1"
-#define MEMBERPORT 6591
-#define VERIFIERIP "127.0.0.1"
-#define VERIFIERPORT 6592
-
-
-typedef struct member {
-    struct ecdaa_member_public_key_FP256BN mpk;
-} member_t;
-
 typedef enum memberstate {
     ON,
     JOIN,
     APPEND,
+    JOINPROCEED,
     JOINED,
     ATTEST,
-    PUBLISH,
+    PUBLISH
-    SHUTDOWN
+} memberstate_e;
-}memberstate_t;
+
+typedef struct member {
+    struct ecdaa_member_public_key_FP256BN mpk;
+    struct ecdaa_member_public_key_FP256BN msk;
+    memberstate_e state;
+} member_t;
 
-int process_member(int connfd);
+member_t member;
-int member_join(int connfd);
+
+int process_member(char *buffer);
+
+int member_join(char* buffer);
+int member_attest(char* buffer);
+int member_publish(char* buffer);
 
 int main() {
     int err = 0;
-    server_t *server;
 
-    server = server_open(&process_member, MEMBERPORT);
+    if (2 != server_start(&process_member, MEMBERPORT)) {
-    if (NULL == server) {
+        printf("server failed\n");
-        printf("listen failed, closing...\n");
-    }
-
-    for (; !err;) {
-        err = server_accept(server);
-        if (1 == err) {
-            printf("graceful shutdown...\n");
-        } else if (err) {
-            printf("accept failed, closing...\n");
-        }
     }
-    printf("shut down server\n");
+    return 0;
-    server_close(server);
-
-   return 0;
 }
 
-int process_member(int connfd) {
+int process_member(char *buffer) {
-    char inbuf[MAX_BUFSIZE];
+    int ret = 0;
-    char outbuf[MAX_BUFSIZE];
-    int ret = 2;
-
-    while (ret == 2) {
-        bzero(inbuf, MAX_BUFSIZE);
-        bzero(outbuf, MAX_BUFSIZE);
 
-        if (0 >= read(connfd, inbuf, sizeof(inbuf))) {
+        printf("> MEMBER: %s\n", buffer);
-            printf("process_member: cannot read from socket\n");
-            ret = -1;
-        }
-        printf("> MEMBER: %s\n", inbuf);
 
-        if (0 == strncmp("ATTEST", inbuf, 6)) {
+        if (0 == strncasecmp("ATTEST", buffer, 6)) {
             printf("attest()\n");
-            strncpy(outbuf, "OK\n", 3);
+            bzero(buffer, MAX_BUFSIZE);
-        }
+            strncpy(buffer, "ATTEST ", 7);
-        else if (0 == strncmp("PUBLISH", inbuf, 7)) {
+            member_attest(buffer);
+        } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
             printf("publish()\n");
-            strncpy(outbuf, "OK\n", 3);
+            bzero(buffer, MAX_BUFSIZE);
-        }
+            strncpy(buffer, "PUBLISH ", 8);
-        else if (0 == strncmp("JOIN", inbuf, 4)) {
+            member_publish(buffer);
+        } else if (0 == strncasecmp("JOIN", buffer, 4)) {
             printf("join()\n");
-            client_t *client;
+            member.state = JOIN;
-            client = client_open(&member_join);
+            ret = client_connect(&member_join, ISSUERIP, ISSUERPORT);
-            if(0 != client_connect(client, ISSUERIP, ISSUERPORT)) {
+            if (0 >= ret || JOINED != member.state) {
-                strncpy(outbuf, "ERR\n", 4);
+                printf("process_member: issuer connection failed\n");
-                ret = -1;
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "ERR\n", 4);
             } else {
-                if(0 != client_close(client)) {
+                bzero(buffer, MAX_BUFSIZE);
-                    strncpy(outbuf, "ERR\n", 4);
+                strncpy(buffer, "OK\n", 3);
-                }
-                strncpy(outbuf, "OK\n", 3);
             }
-        }
-        else if (0 == strncmp("EXIT", inbuf, 4)) {
-            printf("exit()\n");
-            strncpy(outbuf, "OK\n", 3);
             ret = 0;
-        }
+        } else if (0 == strncasecmp("EXIT", buffer, 4)) {
-        else if (0 == strncmp("SHUTDOWN", inbuf, 8)) {
+            printf("exit()\n");
-            strncpy(outbuf, "OK\n", 3);
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "OK\n", 3);
             ret = 1;
-        }
+        } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
-        else {
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "OK\n", 3);
+            ret = 2;
+        } else {
             printf("error()\n");
-            strncpy(outbuf, "ERR\n", 4);
+            bzero(buffer, MAX_BUFSIZE);
-            ret = -1;
+            strncpy(buffer, "ERR\n", 4);
+            ret = 0;
         }
 
-        printf("< MEMBER: %s\n", outbuf);
+        printf("< MEMBER: %s\n", buffer);
-        write(connfd, outbuf, sizeof(outbuf));
-    }
     return ret;
 }
 
-int member_join(int connfd) {
+int member_join(char *buffer) {
-    char inbuf[MAX_BUFSIZE];
+    int ret = 0;
-    char outbuf[MAX_BUFSIZE];
+
-    int n = 0;
+    printf("ISSUER > MEMBER: %s", buffer);
-    memberstate_t state = JOIN;
+    switch (member.state) {
-
+        case JOIN:
-    for (;;) {
+            bzero(buffer, MAX_BUFSIZE);
-        switch(state) {
+            strncpy(buffer, "JOIN\n", 5);
-            case JOIN:
+            member.state = APPEND;
-                strncpy(outbuf, "JOIN", 4);
+            break;
-                state = APPEND;
+        case APPEND:
-                break;
+            if (0 == strncasecmp("JOINSTART", buffer, 9)) {
-            case APPEND:
+                bzero(buffer, MAX_BUFSIZE);
-                if (0 == strncmp("JOINSTART", inbuf, 9)) {
+                strncpy(buffer, "APPEND\n", 7);
-                    strncpy(outbuf, "APPEND\n", 7);
+                member.state = JOINPROCEED;
-                    state = JOINED;
+            }
-                }
+            break;
-                break;
+        case JOINPROCEED:
-            case JOINED:
+            if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
-                if (0 == strncmp("JOINPROCEED", inbuf, 11)) {
+                bzero(buffer, MAX_BUFSIZE);
-                    strncpy(outbuf, "OK\n", 3);
+                member.state = JOINED;
-                    return 0;
+                ret = 1;
-                }
+            }
-                break;
+            break;
-            default:
+        default:
-                return -1;
+            ret -1;
-        }
+    }
+    if(0 == ret) {
+        printf("ISSUER < MEMBER: %s", buffer);
+    }
+    return ret;
+}
 
-        bzero(outbuf, MAX_BUFSIZE);
+int member_attest(char* buffer) {
-        printf("ISSUER < MEMBER: %s\n", outbuf);
+    strncat(buffer, "<attestval>\n", 13);
-        write(connfd, outbuf, sizeof(outbuf));
+    return 0;
+}
 
-        bzero(inbuf, MAX_BUFSIZE);
+int member_publish(char* buffer) {
-        if (0 >= read(connfd, inbuf, sizeof(inbuf))) {
+    strncat(buffer, "<publicval>\n", 12);
-            printf("process_issuer: cannot read from socket\n");
+    return 0;
-            return -1;
-        }
-    }
 }

member.h

@@ -0,0 +1,16 @@
+//
+// Created by root on 11/5/19.
+//
+
+#ifndef ECDAA_ISSUER_MEMBER_H
+#define ECDAA_ISSUER_MEMBER_H
+#include <stdio.h>
+#include <string.h>
+#include <ecdaa.h>
+#include "server.h"
+#include "client.h"
+#include "common.h"
+
+int process_member(char *buffer);
+
+#endif //ECDAA_ISSUER_ISSUER_H

server.c

@@ -1,73 +1,85 @@
 #include "server.h"
 
-server_t *server_open(conn_handler handler, int16_t port) {
+int server_open(int16_t port) {
     struct sockaddr_in servaddr;
-    server_t *server = malloc(sizeof(server_t));
+    int connfd = 0;
-    if(NULL == handler) {
+
-        printf("server_open: received empty handler, stopping");
+    connfd = socket(AF_INET, SOCK_STREAM, 0);
-        return NULL;
+    if (-1 == connfd) {
-    }
+        printf("server_open: failed to create endpoint.\n");
-    if (NULL == server) {
+        return -1;
-        printf("server_open: malloc failed");
-        return NULL;
-    }
-    server->conn = connection_create(CONN_TYPE_SERVER);
-    if (NULL == server->conn) {
-        free(server);
-        return NULL;
-    }
-    server->handler = handler;
-    server->conn->fd = socket(AF_INET, SOCK_STREAM, 0);
-    if (-1 == server->conn->fd) {
-        printf("server_listen: failed to create endpoint.\n");
-        return NULL;
     }
     servaddr.sin_family = AF_INET;
     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
     servaddr.sin_port = htons(port);
 
-    if (0 != bind(server->conn->fd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) {
+    if (0 != bind(connfd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) {
-        printf("server_listen: failed to bind socket\n");
+        printf("server_open: failed to bind socket\n");
-        return NULL;
+        close(connfd);
+        return -1;
     }
-    return server;
+    return connfd;
 }
 
-int server_accept(server_t *server) {
+int server_start(conn_handler handler, int16_t port) {
     struct sockaddr_in client;
     unsigned int client_len = 0;
-    int connfd = -1;
+    int connfd = 0;
-    int ret = 0;
+    int clientfd = 0;
+    int len = 0;
+    int ret = 0;    //<0 .. failure, 0 .. continue, 1 .. exit, 2 .. shutdown
+    char buffer[MAX_BUFSIZE];
 
-    if (NULL == server || 0 != listen(server->conn->fd, MAX_CLIENTS)) {
+    if(NULL == handler) {
-        printf("server_accept: listen failed\n");
+        printf("server_start: received empty handler, stopping\n");
         return -1;
     }
-    printf("server_accept: listening\n");
+    connfd = server_open(port);
-    client_len = sizeof(client);
+    if(-1 == connfd) {
-    connfd = accept(server->conn->fd, (struct sockaddr *) &client, &client_len);
+        printf("server_start: could not open port, stopping\n");
-    if(0 >= connfd) {
-        printf("server_accept: connection to client failed, ");
         return -1;
-    } else {
-        ret = server->handler(connfd);
-        if(0 != close(connfd)) {
-            printf("server_accept: failed to close client connection properly");
-            return -1;
-        }
     }
-    return ret;
+    if (0 != listen(connfd, MAX_CLIENTS)) {
-}
+        printf("server_start: listen failed, stopping\n");
+        return -1;
+    }
+    printf("server_start: listening\n");
+    for(ret = 1; 1 == ret;) {
+        client_len = sizeof(client);
+        clientfd = accept(connfd, (struct sockaddr *) &client, &client_len);
+        if (0 >= clientfd) {
+            printf("server_start: connection to client failed\n");
+            ret = -1;
+        } else {
+            for(ret = 0; 0 == ret;) {
+                bzero(buffer, MAX_BUFSIZE);
+                len = read(clientfd, buffer, sizeof(buffer));
+                if (0 > len) {
+                    printf("server_start: cannot read from socket\n");
+                    ret = -1;
+                } else if(0 == len) {
+                    printf("server_start: client closed connection\n");
+                    ret = 1;
+                } else {
+                    ret = handler(buffer);
+                }
+
+                if (0 <= ret && 0 >= write(clientfd, buffer, sizeof(buffer))) {
+                    printf("server_start: cannot write to socket\n");
+                    ret = -1;
+                }
 
-int server_close(server_t *server) {
+            }
-    int err = 0;
+            if (0 != close(clientfd)) {
-    if (NULL == server) {
+                printf("server_start: failed to close client connection properly\n");
-        return 0;
+                ret = -1;
+            }
+        }
     }
-    if (0 != connection_destroy(server->conn)) {
+    printf("server_start: closing connection\n");
-        printf("server_close: closing socket failed\n");
+    if (0 != close(connfd)) {
-        err = -1;
+        printf("server_start: failed to close server port properly\n");
+        ret = -1;
     }
-    free(server);
+    return ret;
-    return err;
 }

server.h

@@ -4,23 +4,14 @@
 
 #ifndef ECDAA_ISSUER_SERVER_H
 #define ECDAA_ISSUER_SERVER_H
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <unistd.h>
-#include "connection.h"
+#include "common.h"
 
-#define MAX_CLIENTS 10
+int server_start(conn_handler handler, int16_t port);
-#define MAX_BUFSIZE 1024
-
-typedef struct server {
-    connection_t* conn;
-    conn_handler handler;
-}server_t;
-
-server_t *server_open(conn_handler handler, int16_t port);
-
-int server_accept(server_t *server);
-
-int server_close(server_t* server);
 
 #endif //ECDAA_ISSUER_SERVER_H

verifier.c

@@ -0,0 +1,129 @@
+#include <stdio.h>
+#include <string.h>
+#include <ecdaa-tpm.h>
+#include "client.h"
+#include "server.h"
+
+typedef enum memberstate {
+    ON,
+    JOIN,
+    APPEND,
+    JOINPROCEED,
+    JOINED,
+    ATTEST,
+    PUBLISH
+} memberstate_e;
+
+typedef struct member {
+    struct ecdaa_member_public_key_FP256BN mpk;
+    struct ecdaa_member_public_key_FP256BN msk;
+    memberstate_e state;
+} member_t;
+
+member_t member;
+
+int process_member(char *buffer);
+
+int member_join(char* buffer);
+int member_attest(char* buffer);
+int member_publish(char* buffer);
+
+int main() {
+    int err = 0;
+
+    if (2 != server_start(&process_member, MEMBERPORT)) {
+        printf("server failed\n");
+    }
+    return 0;
+}
+
+int process_member(char *buffer) {
+    int ret = 0;
+
+        printf("> MEMBER: %s\n", buffer);
+
+        if (0 == strncasecmp("ATTEST", buffer, 6)) {
+            printf("attest()\n");
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "ATTEST ", 7);
+            member_attest(buffer);
+        } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
+            printf("publish()\n");
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "PUBLISH ", 8);
+            member_publish(buffer);
+        } else if (0 == strncasecmp("JOIN", buffer, 4)) {
+            printf("join()\n");
+            member.state = JOIN;
+            ret = client_connect(&member_join, ISSUERIP, ISSUERPORT);
+            if (0 >= ret || JOINED != member.state) {
+                printf("process_member: issuer connection failed\n");
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "ERR\n", 4);
+            } else {
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "OK\n", 3);
+            }
+            ret = 0;
+        } else if (0 == strncasecmp("EXIT", buffer, 4)) {
+            printf("exit()\n");
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "OK\n", 3);
+            ret = 1;
+        } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "OK\n", 3);
+            ret = 2;
+        } else {
+            printf("error()\n");
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "ERR\n", 4);
+            ret = 0;
+        }
+
+        printf("< MEMBER: %s\n", buffer);
+    return ret;
+}
+
+int member_join(char *buffer) {
+    int ret = 0;
+
+    printf("ISSUER > MEMBER: %s", buffer);
+    switch (member.state) {
+        case JOIN:
+            bzero(buffer, MAX_BUFSIZE);
+            strncpy(buffer, "JOIN\n", 5);
+            member.state = APPEND;
+            break;
+        case APPEND:
+            if (0 == strncasecmp("JOINSTART", buffer, 9)) {
+                bzero(buffer, MAX_BUFSIZE);
+                strncpy(buffer, "APPEND\n", 7);
+                member.state = JOINPROCEED;
+            }
+            break;
+        case JOINPROCEED:
+            if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
+                bzero(buffer, MAX_BUFSIZE);
+                member.state = JOINED;
+                ret = 1;
+            }
+            break;
+        default:
+            ret -1;
+    }
+    if(0 == ret) {
+        printf("ISSUER < MEMBER: %s", buffer);
+    }
+    return ret;
+}
+
+int member_attest(char* buffer) {
+    strncat(buffer, "<attestval>\n", 13);
+    return 0;
+}
+
+int member_publish(char* buffer) {
+    strncat(buffer, "<publicval>\n", 12);
+    return 0;
+}