/* ==================== on_connection() ==================== */
static void on_connection(uv_stream_t *stream, int status)
{
server_t *server= (server_t*)stream->data;
/* -------- create_session -------- */
session_callbacks_t callbacks = {
session_idle_cb,
session_timer_cb,
session_async_cb,
session_is_idle,
session_handle_message,
session_init,
session_destroy
};
session_t *session = session_new((void*)server, callbacks);
if ( session == NULL ){
error_log("session_new() failed. session == NULL.");
return;
}
int ret = session_accept(session, &server->connection.handle.tcp);
if ( ret != 0 ) {
error_log("session_accept() failed. ret=%d", ret);
return;
}
info_log("Connected. (server_fd = %d, session_fd = %d)", server_fd(server), session_fd(session));
}
void
test_session_tcp6(void) {
lagopus_result_t ret;
char cbuf[256] = {0};
char sbuf[256] = {0};
lagopus_session_t sesc, sess, sesa;
struct addrunion dst, src;
ret = session_create(SESSION_TCP6|SESSION_PASSIVE, &sess);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv6_set(&src, "::0");
ret = session_bind(sess, &src, 10023);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = session_create(SESSION_TCP6|SESSION_ACTIVE, &sesc);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv6_set(&dst, "::1");
ret = session_connect(sesc, &dst, 10023, NULL, 0);
if (ret == 0 || errno == EINPROGRESS) {
TEST_ASSERT(true);
} else {
TEST_ASSERT(false);
}
ret = session_accept(sess, &sesa);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_NOT_NULL(sesa);
TEST_ASSERT_TRUE(session_is_alive(sess));
TEST_ASSERT_TRUE(session_is_alive(sesc));
TEST_ASSERT_TRUE(session_is_alive(sesa));
snprintf(cbuf, sizeof(cbuf), "hogehoge\n");
ret = session_write(sesc, cbuf, strlen(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
ret = session_read(sesa, sbuf, sizeof(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_write(sesa, sbuf, strlen(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_read(sesc, cbuf, sizeof(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
session_destroy(sesc);
session_destroy(sesa);
session_destroy(sess);
}
int connect_accept(client_data *fd_array, int *num_clients, fd_set *readfds, char *msg, waitList *waitlist) {
/* Fonction qui permet à un client d'accepter une connextion d'un utilisateur distant. */
char client_name[MAX_SIZE_USERNAME];
int client_sockfd;
int i, bchar;
char *posSpace = NULL;
if(strlen(msg) < MIN_SIZE_USERNAME+8 || strlen(msg) > MAX_SIZE_USERNAME+8) { // "/accept " = 8
printf(BLUE"[PROGRAM] Error command : Username too short or too long.\n[PROGRAM] Please use \"/accept username\" as described previously."RESET"\n\n");
return -1;
}
if((posSpace = strchr(msg, ' ')) == NULL) {
printf(BLUE"[PROGRAM] Error command. Please use \"/accept username\" as described previously."RESET"\n\n");
return -1;
}
if(strcpy(client_name, posSpace+1) == NULL) {
printf(BLUE"[PROGRAM] Error command. Please use \"/accept username\" as described previously."RESET"\n\n");
return -1;
}
client_name[strlen(client_name)-1] = '\0';
for(i=0 ; i < strlen(client_name) ; i++) {
bchar = (isalnum((unsigned char) client_name[i])) ? 0 : 1;
if(bchar) {break;}
}
if (bchar) {
printf(BLUE"[PROGRAM] Error command : Username must only be composed of alphanumeric characters.\n[PROGRAM] Please use \"/accept username\" as described previously.\n"RESET"\n\n");
return -1;
}
if((client_sockfd = search_client_waiting_fd_by_name(client_name, fd_array, num_clients, *waitlist)) == -1) {
printf(BLUE"[PROGRAM] This user is not in your waiting list."RESET"\n\n");
return -1;
}
/* Fin de l'initialisation / gestion d'erreurs : on alloue de la mémoire */
message *msg_send = (message *) malloc(sizeof(message));
//On lui demande de se logger
if (login_client(msg_send, &client_sockfd, fd_array, num_clients, readfds, waitlist) != -1) {
//On confirme la connection du client
session_accept(msg_send); //on crée le message de session-accept-1
send_msg(msg_send, &client_sockfd, readfds, fd_array, num_clients);
free((*msg_send).msg_content);
free(msg_send);
}
return 0;
}
void
test_session_tcp(void) {
lagopus_result_t ret;
char cbuf[256] = {0};
char sbuf[256] = {0};
bool b;
lagopus_session_t sesc, sess, sesa, sesp[3];
struct addrunion dst, src;
ret = session_create(SESSION_TCP|SESSION_PASSIVE, &sess);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv4_set(&src, "0.0.0.0");
ret = session_bind(sess, &src, 10022);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = session_create(SESSION_TCP|SESSION_ACTIVE, &sesc);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv4_set(&dst, "127.0.0.1");
ret = session_connect(sesc, &dst, 10022, NULL, 0);
if (ret == 0 || errno == EINPROGRESS) {
TEST_ASSERT(true);
} else {
TEST_ASSERT(false);
}
session_write_event_set(sesc);
session_read_event_set(sess);
sesp[0] = sesc;
sesp[1] = sess;
ret = session_poll(sesp, 2, 1);
TEST_ASSERT_EQUAL(2, ret);
ret = session_is_writable(sesc, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_TRUE(b);
ret = session_is_readable(sess, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_TRUE(b);
ret = session_accept(sess, &sesa);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_NOT_NULL(sesa);
TEST_ASSERT_TRUE(session_is_alive(sess));
TEST_ASSERT_TRUE(session_is_alive(sesc));
TEST_ASSERT_TRUE(session_is_alive(sesa));
session_write_event_set(sesc);
session_read_event_set(sess);
session_read_event_set(sesa);
sesp[0] = sesc;
sesp[1] = sess;
sesp[2] = sesa;
ret = session_poll(sesp, 3, 1);
TEST_ASSERT_EQUAL(1, ret);
ret = session_is_writable(sesc, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_TRUE(b);
ret = session_is_readable(sess, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_FALSE(b);
ret = session_is_readable(sesa, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_FALSE(b);
snprintf(cbuf, sizeof(cbuf), "hogehoge\n");
ret = session_write(sesc, cbuf, strlen(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
session_read_event_set(sesa);
sesp[0] = sesa;
ret = session_poll(sesp, 1, 1);
TEST_ASSERT_EQUAL(1, ret);
ret = session_is_readable(sesa, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_TRUE(b);
ret = session_read(sesa, sbuf, sizeof(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_write(sesa, sbuf, strlen(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_read(sesc, cbuf, sizeof(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
session_close(sesc);
TEST_ASSERT_FALSE(session_is_alive(sesc));
session_close(sesa);
TEST_ASSERT_FALSE(session_is_alive(sesa));
session_close(sess);
TEST_ASSERT_FALSE(session_is_alive(sesa));
session_write_event_set(sesc);
session_read_event_set(sess);
session_read_event_set(sesa);
sesp[0] = sesc;
sesp[1] = sess;
sesp[2] = sesa;
ret = session_poll(sesp, 3, 1);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_TIMEDOUT, ret);
ret = session_is_writable(sesc, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_FALSE(b);
ret = session_is_readable(sess, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_FALSE(b);
ret = session_is_readable(sesa, &b);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_FALSE(b);
session_destroy(sesc);
session_destroy(sesa);
session_destroy(sess);
}
void
test_session_fgets(void) {
ssize_t ret;
char *c;
#if 0
char cbuf[256] = {0};
#endif
char sbuf[256] = {0};
lagopus_session_t sesc, sess, sesa, sesp[1];
struct addrunion dst, src;
ret = session_create(SESSION_TCP|SESSION_PASSIVE, &sess);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv4_set(&src, "0.0.0.0");
ret = session_bind(sess, &src, 10022);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = session_create(SESSION_TCP|SESSION_ACTIVE, &sesc);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv4_set(&dst, "127.0.0.1");
ret = session_connect(sesc, &dst, 10022, NULL, 0);
if (ret == 0 || errno == EINPROGRESS) {
TEST_ASSERT(true);
} else {
TEST_ASSERT(false);
}
ret = session_accept(sess, &sesa);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_NOT_NULL(sesa);
TEST_ASSERT_TRUE(session_is_alive(sess));
TEST_ASSERT_TRUE(session_is_alive(sesc));
TEST_ASSERT_TRUE(session_is_alive(sesa));
ret = session_printf(sesc, "%s", "hogehoge\n\nhoge");
TEST_ASSERT_EQUAL(ret, strlen("hogehoge\n\nhoge"));
session_read_event_set(sesa);
sesp[0] = sesa;
ret = session_poll(sesp, 1, 1);
TEST_ASSERT_EQUAL(ret, 1);
c = session_fgets(sbuf, 5, sesa);
fprintf(stderr, "1.%s\n", sbuf);
TEST_ASSERT_NOT_NULL(c);
TEST_ASSERT_EQUAL(0, strncmp(sbuf, "hoge", 5));
c = session_fgets(sbuf, 10, sesa);
fprintf(stderr, "2.%s\n", sbuf);
TEST_ASSERT_NOT_NULL(c);
TEST_ASSERT_EQUAL(0, strncmp(sbuf, "hoge\n", 5));
c = session_fgets(sbuf, 10, sesa);
fprintf(stderr, "3.%s\n", sbuf);
TEST_ASSERT_NOT_NULL(c);
TEST_ASSERT_EQUAL(0, strncmp(sbuf, "\n", 1));
c = session_fgets(sbuf, 5, sesa);
fprintf(stderr, "4.%s\n", sbuf);
TEST_ASSERT_NOT_NULL(c);
TEST_ASSERT_EQUAL(0, strncmp(sbuf, "hoge", 5));
#if 0
do {
fprintf(stderr, "out:%s", sbuf);
fgets(cbuf, sizeof(cbuf), stdin);
fprintf(stderr, "in :%s", cbuf);
session_write(sesc, cbuf, strlen(cbuf));
} while (session_fgets(sbuf, sizeof(sbuf), sesa) != NULL);
#endif
session_close(sesc);
TEST_ASSERT_FALSE(session_is_alive(sesc));
session_close(sesa);
TEST_ASSERT_FALSE(session_is_alive(sesa));
session_close(sess);
TEST_ASSERT_FALSE(session_is_alive(sesa));
session_destroy(sesc);
session_destroy(sesa);
session_destroy(sess);
}
void
test_session_tls(void) {
#if 0 /* this test code is not work, use openssl s_server/s_client commands for tls session tests. */
lagopus_result_t ret;
char cbuf[256] = {0};
char sbuf[256] = {0};
lagopus_session_t sesc, sess, sesa;
struct addrunion src, dst;
session_tls_set_ca_dir("ca");
session_tls_set_server_cert("./server1.pem");
session_tls_set_server_key("./server1_key_nopass.pem");
session_tls_set_client_key("./client1_key_nopass.pem");
ret = session_create(SESSION_TCP|SESSION_PASSIVE|SESSION_TLS, &sess);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
addrunion_ipv4_set(&src, "0.0.0.0");
ret = session_bind(sess, &src, 10024);
addrunion_ipv4_set(&dst, "127.0.0.1");
ret = session_create(SESSION_TCP|SESSION_TLS|SESSION_ACTIVE, &sesc);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
ret = session_connect(sesc, &dst, 10024, &dst, 0);
if (ret == 0 || errno == EINPROGRESS) {
TEST_ASSERT(true);
} else {
TEST_ASSERT(false);
}
ret = session_accept(sess, &sesa);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
TEST_ASSERT_NOT_NULL(sesa);
TEST_ASSERT_TRUE(session_is_alive(sess));
TEST_ASSERT_TRUE(session_is_alive(sesa));
ret = session_read(sesa, sbuf, sizeof(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_write(sesa, sbuf, strlen(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
TEST_ASSERT_TRUE(session_is_alive(sesc));
snprintf(cbuf, sizeof(cbuf), "hogehoge\n");
ret = session_write(sesc, cbuf, strlen(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
ret = session_read(sesa, sbuf, sizeof(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_write(sesa, sbuf, strlen(sbuf));
TEST_ASSERT_EQUAL(ret, strlen(sbuf));
ret = session_read(sesc, cbuf, sizeof(cbuf));
TEST_ASSERT_EQUAL(ret, strlen(cbuf));
session_destroy(sesc);
session_destroy(sesa);
session_destroy(sess);
#endif
}
