/* return 1 on success
* return 0 on failure
*/
static int accept_connection(TCP_Server *TCP_server, sock_t sock)
{
if (!sock_valid(sock))
return 0;
if (!set_socket_nonblock(sock)) {
kill_sock(sock);
return 0;
}
if (!set_socket_nosigpipe(sock)) {
kill_sock(sock);
return 0;
}
TCP_Secure_Connection *conn =
&TCP_server->incomming_connection_queue[TCP_server->incomming_connection_queue_index % MAX_INCOMMING_CONNECTIONS];
if (conn->status != TCP_STATUS_NO_STATUS)
kill_TCP_connection(conn);
conn->status = TCP_STATUS_CONNECTED;
conn->sock = sock;
conn->next_packet_length = 0;
++TCP_server->incomming_connection_queue_index;
return 1;
}
/* return index on success
* return -1 on failure
*/
static int accept_connection(TCP_Server *TCP_server, Socket sock)
{
if (!sock_valid(sock)) {
return -1;
}
if (!set_socket_nonblock(sock)) {
kill_sock(sock);
return -1;
}
if (!set_socket_nosigpipe(sock)) {
kill_sock(sock);
return -1;
}
uint16_t index = TCP_server->incoming_connection_queue_index % MAX_INCOMING_CONNECTIONS;
TCP_Secure_Connection *conn = &TCP_server->incoming_connection_queue[index];
if (conn->status != TCP_STATUS_NO_STATUS) {
kill_TCP_secure_connection(conn);
}
conn->status = TCP_STATUS_CONNECTED;
conn->sock = sock;
conn->next_packet_length = 0;
++TCP_server->incoming_connection_queue_index;
return index;
}
static sock_t new_listening_TCP_socket(int family, uint16_t port)
{
sock_t sock = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (!sock_valid(sock)) {
return ~0;
}
#ifndef TCP_SERVER_USE_EPOLL
int ok = set_socket_nonblock(sock);
#else
int ok = 1;
#endif
if (ok && family == AF_INET6) {
ok = set_socket_dualstack(sock);
}
ok = ok && bind_to_port(sock, family, port) && (listen(sock, TCP_MAX_BACKLOG) == 0);
if (!ok) {
kill_sock(sock);
return ~0;
}
return sock;
}
static sock_t new_listening_TCP_socket(int family, uint16_t port)
{
sock_t sock = socket(family, SOCK_STREAM, IPPROTO_TCP);
if (!sock_valid(sock)) {
return ~0;
}
int ok = set_socket_nonblock(sock);
if (ok && family == AF_INET6) {
ok = set_socket_dualstack(sock);
}
if (ok) {
ok = set_socket_reuseaddr(sock);
}
ok = ok && bind_to_port(sock, family, port) && (listen(sock, TCP_MAX_BACKLOG) == 0);
if (!ok) {
kill_sock(sock);
return ~0;
}
return sock;
}
void kill_TCP_server(TCP_Server *TCP_server)
{
uint32_t i;
for (i = 0; i < TCP_server->num_listening_socks; ++i) {
kill_sock(TCP_server->socks_listening[i]);
}
free(TCP_server->socks_listening);
free(TCP_server);
}
/* Kill the TCP connection
*/
void kill_TCP_connection(TCP_Client_Connection *TCP_connection)
{
if (TCP_connection == NULL) {
return;
}
wipe_priority_list(TCP_connection);
kill_sock(TCP_connection->sock);
crypto_memzero(TCP_connection, sizeof(TCP_Client_Connection));
free(TCP_connection);
}
void kill_TCP_server(TCP_Server *TCP_server)
{
uint32_t i;
for (i = 0; i < TCP_server->num_listening_socks; ++i) {
kill_sock(TCP_server->socks_listening[i]);
}
if (TCP_server->onion) {
set_callback_handle_recv_1(TCP_server->onion, NULL, NULL);
}
free(TCP_server->socks_listening);
free(TCP_server);
}
/* Kill an accepted TCP_Secure_Connection
*
* return -1 on failure.
* return 0 on success.
*/
static int kill_accepted(TCP_Server *TCP_server, int index)
{
if ((uint32_t)index >= TCP_server->size_accepted_connections)
return -1;
uint32_t i;
for (i = 0; i < NUM_CLIENT_CONNECTIONS; ++i) {
rm_connection_index(TCP_server, &TCP_server->accepted_connection_array[index], i);
}
sock_t sock = TCP_server->accepted_connection_array[index].sock;
if (del_accepted(TCP_server, index) != 0)
return -1;
kill_sock(sock);
return 0;
}
void kill_TCP_server(TCP_Server *TCP_server)
{
uint32_t i;
for (i = 0; i < TCP_server->num_listening_socks; ++i) {
kill_sock(TCP_server->socks_listening[i]);
}
if (TCP_server->onion) {
set_callback_handle_recv_1(TCP_server->onion, NULL, NULL);
}
bs_list_free(&TCP_server->accepted_key_list);
#ifdef TCP_SERVER_USE_EPOLL
close(TCP_server->efd);
#endif
free(TCP_server->socks_listening);
free(TCP_server);
}
/* Kill a TCP_Secure_Connection
*/
static void kill_TCP_connection(TCP_Secure_Connection *con)
{
kill_sock(con->sock);
memset(con, 0, sizeof(TCP_Secure_Connection));
}
/* Kill a TCP_Secure_Connection
*/
static void kill_TCP_connection(TCP_Secure_Connection *con)
{
kill_sock(con->sock);
sodium_memzero(con, sizeof(TCP_Secure_Connection));
}
/* Kill a TCP_Secure_Connection
*/
static void kill_TCP_secure_connection(TCP_Secure_Connection *con)
{
kill_sock(con->sock);
crypto_memzero(con, sizeof(TCP_Secure_Connection));
}
/* Create new TCP connection to ip_port/public_key
*/
TCP_Client_Connection *new_TCP_connection(IP_Port ip_port, const uint8_t *public_key, const uint8_t *self_public_key,
const uint8_t *self_secret_key, TCP_Proxy_Info *proxy_info)
{
if (networking_at_startup() != 0) {
return NULL;
}
if (ip_port.ip.family != AF_INET && ip_port.ip.family != AF_INET6) {
return NULL;
}
uint8_t family = ip_port.ip.family;
TCP_Proxy_Info default_proxyinfo;
if (proxy_info == NULL) {
default_proxyinfo.proxy_type = TCP_PROXY_NONE;
proxy_info = &default_proxyinfo;
}
if (proxy_info->proxy_type != TCP_PROXY_NONE) {
family = proxy_info->ip_port.ip.family;
}
Socket sock = net_socket(family, TOX_SOCK_STREAM, TOX_PROTO_TCP);
if (!sock_valid(sock)) {
return NULL;
}
if (!set_socket_nosigpipe(sock)) {
kill_sock(sock);
return 0;
}
if (!(set_socket_nonblock(sock) && connect_sock_to(sock, ip_port, proxy_info))) {
kill_sock(sock);
return NULL;
}
TCP_Client_Connection *temp = (TCP_Client_Connection *)calloc(sizeof(TCP_Client_Connection), 1);
if (temp == NULL) {
kill_sock(sock);
return NULL;
}
temp->sock = sock;
memcpy(temp->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
memcpy(temp->self_public_key, self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
encrypt_precompute(temp->public_key, self_secret_key, temp->shared_key);
temp->ip_port = ip_port;
temp->proxy_info = *proxy_info;
switch (proxy_info->proxy_type) {
case TCP_PROXY_HTTP:
temp->status = TCP_CLIENT_PROXY_HTTP_CONNECTING;
proxy_http_generate_connection_request(temp);
break;
case TCP_PROXY_SOCKS5:
temp->status = TCP_CLIENT_PROXY_SOCKS5_CONNECTING;
proxy_socks5_generate_handshake(temp);
break;
case TCP_PROXY_NONE:
temp->status = TCP_CLIENT_CONNECTING;
if (generate_handshake(temp) == -1) {
kill_sock(sock);
free(temp);
return NULL;
}
break;
}
temp->kill_at = unix_time() + TCP_CONNECTION_TIMEOUT;
return temp;
}
