added member and client functionality, targeting issuer-member client-server connection

CMakeLists.txt

@@ -5,8 +5,13 @@ set(CMAKE_C_STANDARD 11)
 set(ECDAA_AMCL "/opt/amcl")
 
 add_executable(ecdaa_issuer issuer.c connection.h connection.c 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)
+target_include_directories(ecdaa_member PUBLIC
+        ${ECDAA_AMCL}
+        )
+target_link_libraries(ecdaa_member /usr/local/lib/libecdaa.so)
+target_link_libraries(ecdaa_member /usr/local/lib/libecdaa-tpm.so)

client.c

@@ -25,27 +25,21 @@ client_t* client_open(conn_handler handler) {
     return client;
 }
 
-int client_connect(client_t *client) {
+int client_connect(client_t *client, int16_t port, char *ip_str) {
     struct sockaddr_in servaddr;
-    int servaddr_len = 0;
+    unsigned int servaddr_len = 0;
 
     if(client == NULL) {
         return -1;
     }
 
     servaddr.sin_family = AF_INET;
-    servaddr.sin_addr.s_addr = inet_addr(SERVERIP);
+    servaddr.sin_addr.s_addr = inet_addr(ip_str);
-    servaddr.sin_port = htons(PORT);
+    servaddr.sin_port = htons(port);
 
-    if (0 != connect(, MAX_CLIENTS)) {
-        printf("client_accept: listen failed\n");
-        return -1;
-    }
-    printf("client_accept: listening\n");
     servaddr_len = sizeof(servaddr);
-    connfd = connect(client->conn->fd, &servaddr, &servaddr_len);
+    if(0 >= connect(client->conn->fd, (const struct sockaddr *) &servaddr, servaddr_len)) {
-    if(0 >= connfd) {
+        printf("client_accept: connection to server failed\n");
-        printf("client_accept: connection to client failed, ");
         return -1;
     } else {
         client->handler(client->conn->fd);

client.h

@@ -2,16 +2,19 @@
 // Created by root on 10/30/19.
 //
 
-#ifndef ECDAA_ISSUER_SERVER_H
+#ifndef ECDAA_ISSUER_CLIENT_H
-#define ECDAA_ISSUER_SERVER_H
+#define ECDAA_ISSUER_CLIENT_H
+#include <stdlib.h>
+#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"
 
-#define PORT 6590
 #define MAX_BUFSIZE 1024
-#define SERVERIP "127.0.0.1"
 
 typedef struct client {
     connection_t* conn;
@@ -20,8 +23,8 @@ typedef struct client {
 
 client_t* client_open(conn_handler handler);
 
-int client_connect(client_t* client);
+int client_connect(client_t *client, int16_t port, char *ip_str);
 
 int client_close(client_t* client);
 
-#endif //ECDAA_ISSUER_SERVER_H
+#endif //ECDAA_ISSUER_CLIENT_H

issuer.c

@@ -4,6 +4,13 @@
 #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;
@@ -15,7 +22,7 @@ int main() {
     int err = 0;
     server_t *server;
 
-    server = server_open(&process_issuer);
+    server = server_open(&process_issuer, ISSUERPORT);
     if (NULL == server) {
         printf("listen failed, closing...\n");
     }

member.c

@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <string.h>
+#include <ecdaa-tpm.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 member {
+    struct ecdaa_member_public_key_FP256BN mpk;
+} member_t;
+
+typedef enum memberstate {
+    ON,
+    JOIN,
+    APPEND,
+    JOINED,
+    ATTEST,
+    PUBLISH
+}memberstate_t;
+
+int process_member_client(int connfd);
+
+int main() {
+    int err = 0;
+    client_t *client;
+
+    client = client_open(&process_member_client);
+    if (NULL == client) {
+        printf("listen failed, closing...\n");
+    }
+
+    for (; !err;) {
+        err = client_connect(client, ISSUERPORT, ISSUERIP);
+        if (1 == err) {
+            printf("graceful shutdown...\n");
+        } else if (err) {
+            printf("accept failed, closing...\n");
+        }
+    }
+    printf("shut down client\n");
+    client_close(client);
+    return 0;
+}
+
+int process_member_client(int connfd) {
+    char inbuf[MAX_BUFSIZE];
+    char outbuf[MAX_BUFSIZE];
+    int n = 0;
+    memberstate_t state = JOIN;
+
+    strncpy(outbuf, "JOIN", 4);
+    printf("< MEMBER: %s\n", outbuf);
+    write(connfd, outbuf, sizeof(outbuf));
+    for (;;) {
+        bzero(inbuf, MAX_BUFSIZE);
+        bzero(outbuf, MAX_BUFSIZE);
+
+        if (0 >= read(connfd, inbuf, sizeof(inbuf))) {
+            printf("process_issuer: cannot read from socket\n");
+            return -1;
+        }
+
+        switch(state) {
+            case JOIN:
+                state = APPEND;
+                break;
+            case APPEND:
+                state = JOINED;
+                break;
+            case JOINED:
+                state = ATTEST;
+                state = PUBLISH;
+                break;
+            case ATTEST:
+                state = JOINED;
+                break;
+            case PUBLISH:
+                break;
+        }
+
+        printf("> MEMBER: %s\n", inbuf);
+        strncpy(outbuf, "OK", 2);
+        printf("< MEMBER: %s\n", outbuf);
+        write(connfd, outbuf, sizeof(outbuf));
+        if (0 == strncmp("exit", inbuf, 4)) {
+            printf("process_issuer: exiting gracefully\n");
+            return 0;
+        }
+        if (0 == strncmp("shutdown", inbuf, 8)) {
+            printf("process_issuer: shutting down gracefully\n");
+            return 1;
+        }
+    }
+}

server.c

@@ -1,6 +1,6 @@
 #include "server.h"
 
-server_t* server_open(conn_handler handler) {
+server_t *server_open(conn_handler handler, int16_t port) {
     struct sockaddr_in servaddr;
     server_t *server = malloc(sizeof(server_t));
     if(NULL == handler) {
@@ -24,7 +24,7 @@ server_t* server_open(conn_handler handler) {
     }
     servaddr.sin_family = AF_INET;
     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
-    servaddr.sin_port = htons(PORT);
+    servaddr.sin_port = htons(port);
 
     if (0 != bind(server->conn->fd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) {
         printf("server_listen: failed to bind socket\n");
@@ -35,7 +35,7 @@ server_t* server_open(conn_handler handler) {
 
 int server_accept(server_t *server) {
     struct sockaddr_in client;
-    int client_len = 0;
+    unsigned int client_len = 0;
     int connfd = -1;
     if (NULL == server || 0 != listen(server->conn->fd, MAX_CLIENTS)) {
         printf("server_accept: listen failed\n");
@@ -43,7 +43,7 @@ int server_accept(server_t *server) {
     }
     printf("server_accept: listening\n");
     client_len = sizeof(client);
-    connfd = accept(server->conn->fd, &client, &client_len);
+    connfd = accept(server->conn->fd, (struct sockaddr *) &client, &client_len);
     if(0 >= connfd) {
         printf("server_accept: connection to client failed, ");
         return -1;

server.h

@@ -9,7 +9,6 @@
 #include <unistd.h>
 #include "connection.h"
 
-#define PORT 6590
 #define MAX_CLIENTS 10
 #define MAX_BUFSIZE 1024
 
@@ -18,7 +17,7 @@ typedef struct server {
     conn_handler handler;
 }server_t;
 
-server_t* server_open(conn_handler handler);
+server_t *server_open(conn_handler handler, int16_t port);
 
 int server_accept(server_t *server);