diff --git a/.idea/modules.xml b/.idea/modules.xml index b72431c..1e93087 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -2,7 +2,7 @@ - + \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index e79316e..7836cbe 100644 --- a/CMakeLists.txt +++ b/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} ) diff --git a/client.c b/client.c index a295e2c..c50b621 100644 --- a/client.c +++ b/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)); - if(NULL == handler) { - 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; -} + size_t servaddr_len = 0; + int connfd = 0; -int client_connect(client_t *client, char *ip_str, int16_t port) { - struct sockaddr_in servaddr; - unsigned int servaddr_len = 0; - - if(client == NULL) { + connfd = socket(AF_INET, SOCK_STREAM, 0); + if (-1 == connfd) { + printf("client_listen: failed to create endpoint.\n"); 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 err = 0; - if (NULL == client) { - return 0; +int client_connect(conn_handler handler, char *servip, int16_t port) { + struct sockaddr_in servaddr; + unsigned int servaddr_len = 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"); - err = -1; + + if (0 != close(connfd)) { + printf("client_connect: failed to close server connection properly\n"); + ret = -1; } - free(client); - return err; + + return ret; } diff --git a/client.h b/client.h index 77ba2fb..03e2109 100644 --- a/client.h +++ b/client.h @@ -8,23 +8,10 @@ #include #include #include -#include #include -//#include #include -#include "connection.h" +#include "common.h" -#define MAX_BUFSIZE 1024 - -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); +int client_connect(conn_handler handler, char *ip_str, int16_t port); #endif //ECDAA_ISSUER_CLIENT_H diff --git a/common.h b/common.h new file mode 100644 index 0000000..646bffb --- /dev/null +++ b/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 diff --git a/connection.c b/connection.c deleted file mode 100644 index e599a45..0000000 --- a/connection.c +++ /dev/null @@ -1,29 +0,0 @@ -#include -#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; -} diff --git a/connection.h b/connection.h deleted file mode 100644 index c8bdc04..0000000 --- a/connection.h +++ /dev/null @@ -1,26 +0,0 @@ -// -// Created by root on 10/30/19. -// - -#ifndef ECDAA_ISSUER_CONNECTION_H -#define ECDAA_ISSUER_CONNECTION_H - -#include -#include - -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 diff --git a/issuer.c b/issuer.c index 7baa22f..1219a12 100644 --- a/issuer.c +++ b/issuer.c @@ -1,156 +1,125 @@ -#include -#include -#include -#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; +#include "issuer.h" 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;) { - err = server_accept(server); - if (1 == err) { - printf("graceful shutdown...\n"); - } else if (err) { - printf("accept failed, closing...\n"); - } + if (2 != server_start(&process_issuer, ISSUERPORT)) { + printf("server failed\n"); } - printf("shut down server\n"); - server_close(server); return 0; } -int process_issuer(int connfd) { - char inbuf[MAX_BUFSIZE]; - char outbuf[MAX_BUFSIZE]; - int ret = 2; - issuerstate_e state = ON; +int process_issuer(char *buffer) { + ssize_t len = 0; + int ret = 0; - while (ret == 2) { - bzero(inbuf, MAX_BUFSIZE); - bzero(outbuf, MAX_BUFSIZE); + printf("> ISSUER: %s\n", buffer); - if (0 >= read(connfd, inbuf, sizeof(inbuf))) { - printf("process_member: cannot read from socket\n"); - ret = -1; + if (0 == strncasecmp("OK", buffer, 2)) { + switch (issuer.state) { + case JOINPROCEED: + issuer.state = READY; + break; + default: + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "ERR\n", 4); + break; } - printf("> ISSUER: %s\n", inbuf); - - - if (0 == strncmp("OK", inbuf, 2)) { - switch (state) { - case SETUPDONE: - case JOINPROCEED: - case PUBLISH: - state = READY; - 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("ERR", buffer, 3)) { + switch (issuer.state) { + case JOINPROCEED: + printf("command failed at client\n"); + issuer.state = READY; + break; + default: + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "ERR\n", 4); + break; } - - printf("< ISSUER: %s\n", outbuf); - write(connfd, outbuf, sizeof(outbuf)); + } else if (0 == strncasecmp("SETUP", buffer, 5)) { + switch (issuer.state) { + 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 - ret; + printf("< ISSUER: %s", buffer); + return ret; } diff --git a/issuer.h b/issuer.h new file mode 100644 index 0000000..fca10a3 --- /dev/null +++ b/issuer.h @@ -0,0 +1,16 @@ +// +// Created by root on 11/5/19. +// + +#ifndef ECDAA_ISSUER_ISSUER_H +#define ECDAA_ISSUER_ISSUER_H +#include +#include +#include +#include "server.h" +#include "client.h" +#include "common.h" + +int process_issuer(char *buffer); + +#endif //ECDAA_ISSUER_ISSUER_H diff --git a/member.c b/member.c index d157fff..1c69a3f 100644 --- a/member.c +++ b/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, - SHUTDOWN -}memberstate_t; + 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; -int process_member(int connfd); -int member_join(int connfd); +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; - server_t *server; - server = server_open(&process_member, MEMBERPORT); - if (NULL == server) { - 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"); - } + if (2 != server_start(&process_member, MEMBERPORT)) { + printf("server failed\n"); } - printf("shut down server\n"); - server_close(server); - - return 0; + return 0; } -int process_member(int connfd) { - char inbuf[MAX_BUFSIZE]; - char outbuf[MAX_BUFSIZE]; - int ret = 2; - - while (ret == 2) { - bzero(inbuf, MAX_BUFSIZE); - bzero(outbuf, MAX_BUFSIZE); +int process_member(char *buffer) { + int ret = 0; - if (0 >= read(connfd, inbuf, sizeof(inbuf))) { - printf("process_member: cannot read from socket\n"); - ret = -1; - } - printf("> MEMBER: %s\n", inbuf); + printf("> MEMBER: %s\n", buffer); - if (0 == strncmp("ATTEST", inbuf, 6)) { + if (0 == strncasecmp("ATTEST", buffer, 6)) { printf("attest()\n"); - strncpy(outbuf, "OK\n", 3); - } - else if (0 == strncmp("PUBLISH", inbuf, 7)) { + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "ATTEST ", 7); + member_attest(buffer); + } else if (0 == strncasecmp("PUBLISH", buffer, 7)) { printf("publish()\n"); - strncpy(outbuf, "OK\n", 3); - } - else if (0 == strncmp("JOIN", inbuf, 4)) { + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "PUBLISH ", 8); + member_publish(buffer); + } else if (0 == strncasecmp("JOIN", buffer, 4)) { printf("join()\n"); - client_t *client; - client = client_open(&member_join); - if(0 != client_connect(client, ISSUERIP, ISSUERPORT)) { - strncpy(outbuf, "ERR\n", 4); - ret = -1; + 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 { - if(0 != client_close(client)) { - strncpy(outbuf, "ERR\n", 4); - } - strncpy(outbuf, "OK\n", 3); + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "OK\n", 3); } - } - 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); + } else if (0 == strncasecmp("EXIT", buffer, 4)) { + printf("exit()\n"); + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "OK\n", 3); ret = 1; - } - else { + } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) { + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "OK\n", 3); + ret = 2; + } else { printf("error()\n"); - strncpy(outbuf, "ERR\n", 4); - ret = -1; + bzero(buffer, MAX_BUFSIZE); + strncpy(buffer, "ERR\n", 4); + ret = 0; } - printf("< MEMBER: %s\n", outbuf); - write(connfd, outbuf, sizeof(outbuf)); - } + printf("< MEMBER: %s\n", buffer); return ret; } -int member_join(int connfd) { - char inbuf[MAX_BUFSIZE]; - char outbuf[MAX_BUFSIZE]; - int n = 0; - memberstate_t state = JOIN; - - for (;;) { - switch(state) { - case JOIN: - strncpy(outbuf, "JOIN", 4); - state = APPEND; - break; - case APPEND: - if (0 == strncmp("JOINSTART", inbuf, 9)) { - strncpy(outbuf, "APPEND\n", 7); - state = JOINED; - } - break; - case JOINED: - if (0 == strncmp("JOINPROCEED", inbuf, 11)) { - strncpy(outbuf, "OK\n", 3); - return 0; - } - break; - default: - return -1; - } +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; +} - bzero(outbuf, MAX_BUFSIZE); - printf("ISSUER < MEMBER: %s\n", outbuf); - write(connfd, outbuf, sizeof(outbuf)); +int member_attest(char* buffer) { + strncat(buffer, "\n", 13); + return 0; +} - bzero(inbuf, MAX_BUFSIZE); - if (0 >= read(connfd, inbuf, sizeof(inbuf))) { - printf("process_issuer: cannot read from socket\n"); - return -1; - } - } +int member_publish(char* buffer) { + strncat(buffer, "\n", 12); + return 0; } \ No newline at end of file diff --git a/member.h b/member.h new file mode 100644 index 0000000..5c2e4e9 --- /dev/null +++ b/member.h @@ -0,0 +1,16 @@ +// +// Created by root on 11/5/19. +// + +#ifndef ECDAA_ISSUER_MEMBER_H +#define ECDAA_ISSUER_MEMBER_H +#include +#include +#include +#include "server.h" +#include "client.h" +#include "common.h" + +int process_member(char *buffer); + +#endif //ECDAA_ISSUER_ISSUER_H diff --git a/server.c b/server.c index 581838f..2d07c05 100644 --- a/server.c +++ b/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)); - if(NULL == handler) { - printf("server_open: received empty handler, stopping"); - return NULL; - } - if (NULL == server) { - 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; + int connfd = 0; + + connfd = socket(AF_INET, SOCK_STREAM, 0); + if (-1 == connfd) { + printf("server_open: failed to create endpoint.\n"); + return -1; } 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))) { - printf("server_listen: failed to bind socket\n"); - return NULL; + if (0 != bind(connfd, (const struct sockaddr *) &servaddr, sizeof(servaddr))) { + printf("server_open: failed to bind socket\n"); + 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 ret = 0; + int connfd = 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)) { - printf("server_accept: listen failed\n"); + if(NULL == handler) { + printf("server_start: received empty handler, stopping\n"); return -1; } - printf("server_accept: listening\n"); - client_len = sizeof(client); - connfd = accept(server->conn->fd, (struct sockaddr *) &client, &client_len); - if(0 >= connfd) { - printf("server_accept: connection to client failed, "); + connfd = server_open(port); + if(-1 == connfd) { + printf("server_start: could not open port, stopping\n"); 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 (NULL == server) { - return 0; + } + if (0 != close(clientfd)) { + printf("server_start: failed to close client connection properly\n"); + ret = -1; + } + } } - if (0 != connection_destroy(server->conn)) { - printf("server_close: closing socket failed\n"); - err = -1; + printf("server_start: closing connection\n"); + if (0 != close(connfd)) { + printf("server_start: failed to close server port properly\n"); + ret = -1; } - free(server); - return err; + return ret; } diff --git a/server.h b/server.h index 9da802a..d40477f 100644 --- a/server.h +++ b/server.h @@ -4,23 +4,14 @@ #ifndef ECDAA_ISSUER_SERVER_H #define ECDAA_ISSUER_SERVER_H +#include +#include +#include #include #include #include -#include "connection.h" +#include "common.h" -#define MAX_CLIENTS 10 -#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); +int server_start(conn_handler handler, int16_t port); #endif //ECDAA_ISSUER_SERVER_H diff --git a/verifier.c b/verifier.c new file mode 100644 index 0000000..1c69a3f --- /dev/null +++ b/verifier.c @@ -0,0 +1,129 @@ +#include +#include +#include +#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, "\n", 13); + return 0; +} + +int member_publish(char* buffer) { + strncat(buffer, "\n", 12); + return 0; +} \ No newline at end of file