add: auth, join

diff --git a/cmd/cli/main.c b/cmd/cli/main.c
index 80cdfd19e720546e9cd5970df5b57da23a722341..9346dd9cfb18d3b4b7bb4cbd5816c689c8ea41cd 100644 (file)
--- a/cmd/cli/main.c
+++ b/cmd/cli/main.c
@@ -2,6 +2,8 @@
 #include "rat-chat/utils.h"
 
 int cli_done = 0;
+int TEST_CASE = -1;
+
 
 static void signal_handler(int sig){
 
@@ -32,12 +34,15 @@ int main(int argc, char **argv){
 
         if(strcmp(argv[2], "1") == 0){
 
+            TEST_CASE = 1;
 
-            run_cli_test(argv[1], 1);
+            run_cli(argv[1]);
 
         } else if (strcmp(argv[2], "2") == 0){
 
-            run_cli_test(argv[1], 2);
+            TEST_CASE = 2;
+
+            run_cli(argv[1]);
 
         } else {
 

diff --git a/include/rat-chat/cli/cli.h b/include/rat-chat/cli/cli.h
index 0abeaf8b091e831bf21f2b9db515cb52a420b678..f24c0260a42acb01f6492124adad1ab6103271bd 100644 (file)
--- a/include/rat-chat/cli/cli.h
+++ b/include/rat-chat/cli/cli.h
@@ -27,6 +27,11 @@ void run_cli_test(char* addr, int tc);
 
 int connect_to_engine(char* addr, long timeout);
 
+int auth();
+
+int join();
+
+void chat();
 
 void* reader();
 
@@ -43,4 +48,14 @@ extern int cli_done;
 extern char* PREFERRED_CIPHERS;
 
 
+extern int TEST_CASE;
+
+extern SSL_CTX* ctx;
+extern SSL *ssl ;
+
+extern uint8_t header[HUB_HEADER_BYTELEN];
+extern uint8_t body_len[HUB_BODY_BYTELEN];
+extern uint64_t body_len_new;
+extern uint8_t *body;
+
 #endif 

diff --git a/include/rat-chat/core.h b/include/rat-chat/core.h
index b3054ab21a22aed7ae124b285fab95b07d956a8b..e06668f65c6fc02eb52d75dd2c843a6b6e05578a 100644 (file)
--- a/include/rat-chat/core.h
+++ b/include/rat-chat/core.h
@@ -198,6 +198,7 @@ struct SOCK_CONTEXT {
     int sockfd;
     SSL *ssl;
     SSL_CTX *ctx;
+    int auth;
     char id[MAX_ID_LEN];
     int chan_idx;
 };

diff --git a/src/cli/cli.c b/src/cli/cli.c
index c46628fb02910cf40bf98cee8e08ecc47df18295..5238c01101bdc2626e9fa85a0626770b3b598f0f 100644 (file)
--- a/src/cli/cli.c
+++ b/src/cli/cli.c
@@ -3,16 +3,17 @@
 
 extern char* PREFERRED_CIPHERS = "HIGH:!aNULL:!kRSA:!SRP:!PSK:!CAMELLIA:!RC4:!MD5:!DSS";
 
+SSL_CTX* ctx = NULL;
+SSL *ssl = NULL;
 
-
-void run_cli(char* addr){
+uint8_t header[HUB_HEADER_BYTELEN] = {0};
+uint8_t body_len[HUB_BODY_BYTELEN] = {0};
+uint64_t body_len_new = 0;
+uint8_t *body = NULL;
 
 
 
-}
-
-
-void run_cli_test(char* addr, int tc){
+void run_cli(char* addr){
 
     long res = 1;
     int ret = 1;
@@ -20,8 +21,7 @@ void run_cli_test(char* addr, int tc){
     
     int fd = 0;
     SSL_METHOD *method = NULL;
-    SSL_CTX* ctx = NULL;
-    SSL *ssl = NULL;
+
     
 
     char hostname[MAX_ID_LEN] = {0};
@@ -86,6 +86,7 @@ void run_cli_test(char* addr, int tc){
 
     SSL_set_fd(ssl, fd);
 
+    
     res = SSL_connect(ssl);
 
     if(res != 1){
@@ -95,6 +96,7 @@ void run_cli_test(char* addr, int tc){
         return -6;
     }
 
+    
     X509* cert = SSL_get_peer_certificate(ssl);
     
     if(cert == NULL){
@@ -114,16 +116,25 @@ void run_cli_test(char* addr, int tc){
         return -8;
     }
 
+    res = auth();
 
-    do {
+    if (res < 0){
 
-        sleep(1);
+        printf("failed to do auth\n");
 
-        printf("sleeping\n");
+        return res;
+    }
 
+    res = join();
 
-    } while(cli_done == 0);
+    if (res < 0){
+
+        printf("failed to do join\n");
 
+        return res;
+    }
+
+    chat();
 
     if(NULL != ctx){
         SSL_CTX_free(ctx);
@@ -301,6 +312,335 @@ int connect_to_engine(char* addr, long timeout){
 }
 
 
+int auth(){
+
+    char cert[MAX_PW_LEN] = {0};
+
+    int result = 0;
+
+    if(TEST_CASE == 1){
+
+        result = read_file_to_buffer(cert, MAX_PW_LEN, SUB1_CERT);
+
+    }
+
+
+    if(TEST_CASE == 2){
+
+        result = read_file_to_buffer(cert, MAX_PW_LEN, SUB2_CERT);
+
+    }
+
+
+    if (result < 0){
+
+        printf("failed to get cert\n");
+
+        return result;
+    }
+
+    uint64_t result64 = (uint64_t)result;
+
+    strcpy(header, HUB_HEADER_AUTHSOCK);
+
+    body_len_new = htonll(result64);
+
+    memcpy(body_len, &body_len_new, HUB_BODY_BYTELEN);
+
+    body = (uint8_t*)malloc(result * sizeof(uint8_t));
+
+    memset(body, 0, result * sizeof(uint8_t));
+
+    memcpy(body, cert, result * sizeof(uint8_t));
+
+    result = SSL_write(ssl, header, HUB_HEADER_BYTELEN);
+
+    if (result < 0){
+
+        printf("write auth header failed\n");
+
+        free(body);
+
+        return result;
+    }
+
+    result = SSL_write(ssl, body_len, HUB_BODY_BYTELEN);
+
+    if (result < 0){
+
+        printf("write auth body len failed\n");
+
+        free(body);
+
+        return result;
+    }
+
+    result = SSL_write(ssl, body, result64 * sizeof(uint8_t));
+
+    if (result < 0){
+
+        printf("write auth body failed\n");
+
+        free(body);
+
+        return result;
+    }
+
+
+    free(body);
+
+    int recvlen = 0;
+
+    int n = 0;
+
+    while(recvlen != HUB_HEADER_BYTELEN){
+
+        n = SSL_read(ssl, header + recvlen, HUB_HEADER_BYTELEN - recvlen);
+
+        if(n <= 0){
+
+            printf("read header failed\n");
+
+            return -1;
+        }
+
+        recvlen += n;
+
+    }
+
+    recvlen = 0;
+
+    while(recvlen != HUB_BODY_BYTELEN){
+
+        n = SSL_read(ssl, body_len + recvlen, HUB_BODY_BYTELEN - recvlen);
+
+        if(n <= 0){
+
+            printf("read body len failed\n");
+
+            return -1;
+        }
+
+        recvlen += n;
+
+    }
+
+    memcpy(&body_len_new, body_len, HUB_BODY_BYTELEN);
+
+    uint64_t body_len_n = ntohll(body_len_new);
+
+    body = (uint8_t*)malloc(body_len_n * sizeof(uint8_t));
+
+    recvlen = 0;
+
+    while(recvlen != body_len_n){
+
+        n = SSL_read(ssl, body + recvlen, body_len_n - (uint64_t)recvlen);
+
+        if(n <= 0){
+
+            printf("read body failed\n");
+
+            free(body);
+
+            return -1;
+        }
+
+        recvlen += n;
+
+    }
+
+    printf("auth: %s\n", body);
+
+    free(body);
+
+    return 0;
+
+}
+
+int join(){
+
+    char action[16] = {0};
+    char roomid[MAX_ID_LEN] = {0};
+
+    printf("[ create | join ]:  ");
+
+    fgets(action, 16, stdin);
+
+    for(int i = 0 ; i < 16; i++){
+
+        if(action[i] == '\n'){
+
+            action[i] = 0;
+
+            break;
+        }
+    }
+
+    memset(header, 0, HUB_HEADER_BYTELEN);
+
+    if(strncmp(action, "create", 16) == 0){
+
+        strcpy(header, HUB_HEADER_REGSOCK_CREATE);
+
+    } else if(strncmp(action, "join", 16) == 0){
+
+        strcpy(header, HUB_HEADER_REGSOCK_JOIN);
+
+    } else {
+
+        printf("wrong action: %s\n", action);
+
+        return -1;
+    }
+
+    printf("roomid?: ");
+
+    fgets(roomid, MAX_ID_LEN, stdin);
+
+    int idlen = 0;
+
+    for(int i = 0 ; i < MAX_ID_LEN; i++){
+
+        if(roomid[i] == '\n'){
+
+            roomid[i] = 0;
+
+            break;
+        }
+
+        idlen += 1;
+    }
+
+    uint64_t result64 = (uint64_t)idlen;
+
+    body_len_new = htonll(result64);
+
+    memcpy(body_len, &body_len_new, HUB_BODY_BYTELEN);
+
+    body = (uint8_t*)malloc(result64 * sizeof(uint8_t));
+
+    memset(body, 0, result64 * sizeof(uint8_t));
+
+    memcpy(body, roomid, result64 * sizeof(uint8_t));
+
+
+
+    int result = SSL_write(ssl, header, HUB_HEADER_BYTELEN);
+
+    if (result < 0){
+
+        printf("write join header failed\n");
+
+        free(body);
+
+        return result;
+    }
+
+    result = SSL_write(ssl, body_len, HUB_BODY_BYTELEN);
+
+    if (result < 0){
+
+        printf("write join body len failed\n");
+
+        free(body);
+
+        return result;
+    }
+ 
+    result = SSL_write(ssl, body, result64 * sizeof(uint8_t));
+
+    if (result < 0){
+
+        printf("write join body failed\n");
+
+        free(body);
+
+        return result;
+    }
+
+    free(body);
+
+    int recvlen = 0;
+
+    int n = 0;
+
+    while(recvlen != HUB_HEADER_BYTELEN){
+
+        n = SSL_read(ssl, header + recvlen, HUB_HEADER_BYTELEN - recvlen);
+
+        if(n <= 0){
+
+            printf("read header failed\n");
+
+            return -1;
+        }
+
+        recvlen += n;
+
+    }
+
+    recvlen = 0;
+
+    while(recvlen != HUB_BODY_BYTELEN){
+
+        n = SSL_read(ssl, body_len + recvlen, HUB_BODY_BYTELEN - recvlen);
+
+        if(n <= 0){
+
+            printf("read body len failed\n");
+
+            return -1;
+        }
+
+        recvlen += n;
+
+    }
+
+    memcpy(&body_len_new, body_len, HUB_BODY_BYTELEN);
+
+    uint64_t body_len_n = ntohll(body_len_new);
+
+    body = (uint8_t*)malloc(body_len_n * sizeof(uint8_t));
+
+    recvlen = 0;
+
+    while(recvlen != body_len_n){
+
+        n = SSL_read(ssl, body + recvlen, body_len_n - (uint64_t)recvlen);
+
+        if(n <= 0){
+
+            printf("read body failed\n");
+
+            free(body);
+
+            return -1;
+        }
+
+        recvlen += n;
+
+    }
+
+    printf("join: %s\n", body);
+
+    free(body);
+
+    return 0;
+
+}
+
+
+void chat(){
+
+    printf("start the chat!\n");
+
+    sleep(5);
+
+
+
+}
+
 void* reader(){
 
 
@@ -462,11 +802,8 @@ int verify_callback(int preverify, X509_STORE_CTX* x509_ctx)
             fprintf(stdout, "  Error = %d\n", err);
     }
 
-#if !defined(NDEBUG)
-    return 1;
-#else
+
     return preverify;
-#endif
 }
 
 void print_error_string(unsigned long err, const char* const label)

diff --git a/src/sock/sock.c b/src/sock/sock.c
index 23ee1ab0f502901e392e3dde6b70ce92cb30857e..a8d50d63f8fff8a84c2abc26949d3eae9715e2bc 100644 (file)
--- a/src/sock/sock.c
+++ b/src/sock/sock.c
@@ -298,6 +298,7 @@ void sock_handle_conn(){
 
         SOCK_CTX[sock_idx].ctx = ctx;
         SOCK_CTX[sock_idx].ssl = ssl;
+        SOCK_CTX[sock_idx].auth = 0;
 
 
         SOCK_EVENT.data.fd = infd;
@@ -336,6 +337,13 @@ void sock_handle_client(int cfd){
 
     if(sock_idx < 0){
         
+        pthread_mutex_unlock(&G_MTX);
+
+        return;
+    }
+
+    if(SOCK_CTX[sock_idx].auth == 0){
+
         sock_authenticate(cfd);
 
         pthread_mutex_unlock(&G_MTX);
@@ -343,6 +351,7 @@ void sock_handle_client(int cfd){
         return;
     }
 
+
     int chan_idx = get_sockctx_chan_id_by_fd(cfd);
 
     if(chan_idx < 0){
@@ -464,6 +473,8 @@ void sock_authenticate(int cfd){
 
     }
 
+    SOCK_CTX[sock_idx].auth = 1;
+
     /*
 
     int chan_idx = update_chanctx_from_sockctx(cfd, id);
@@ -486,7 +497,7 @@ void sock_authenticate(int cfd){
 
     memset(hp.wbuff, 0, MAX_BUFF);
 
-    hp.ctx_type = CHAN_ISSOCK;
+    hp.ctx_type = ISSOCK;
 
     strcpy(hp.header, HUB_HEADER_AUTHSOCK);
 
@@ -533,7 +544,7 @@ void sock_register(int cfd){
 
     int sock_idx = get_sockctx_by_fd(cfd);
 
-    fmt_logln(LOGFP,"not registered to sock ctx, auth"); 
+    fmt_logln(LOGFP,"not registered to sock ctx, register"); 
 
     if(sock_idx < 0){
 
@@ -603,7 +614,7 @@ void sock_register(int cfd){
 
     memset(hp.wbuff, 0, MAX_BUFF);
 
-    hp.ctx_type = CHAN_ISSOCK;
+    hp.ctx_type = ISSOCK;
 
     if(is_create == 1){