diff --git a/dap_chain_net_srv_vpn.c b/dap_chain_net_srv_vpn.c
index 873cd02d798057416bc2a4ea0fc1344632a66112..80c776a5b60f4ad302dbac7233bc903cd6ecd422 100755
--- a/dap_chain_net_srv_vpn.c
+++ b/dap_chain_net_srv_vpn.c
@@ -63,6 +63,7 @@
#include "dap_chain_net.h"
#include "dap_chain_net_srv_vpn.h"
+#include "dap_chain_net_vpn_client.h"
#include "dap_chain_ledger.h"
#define LOG_TAG "dap_chain_net_srv_vpn"
@@ -142,7 +143,7 @@ int dap_chain_net_srv_vpn_init(dap_config_t * g_config)
pthread_cond_init(&s_sf_socks_cond, NULL);
pthread_create(&srv_sf_socks_raw_pid, NULL, srv_ch_sf_thread_raw, NULL);
pthread_create(&srv_sf_socks_pid, NULL, srv_ch_sf_thread, NULL);
- dap_stream_ch_proc_add(SERVICE_CHANNEL_ID, s_new, srv_ch_sf_delete, srv_ch_sf_packet_in,
+ dap_stream_ch_proc_add(DAP_STREAM_CH_ID_NET_SRV_VPN, s_new, srv_ch_sf_delete, srv_ch_sf_packet_in,
srv_ch_sf_packet_out);
return 0;
}
@@ -400,140 +401,176 @@ void srv_ch_sf_packet_in(dap_stream_ch_t* ch, void* arg)
{
dap_stream_ch_pkt_t * pkt = (dap_stream_ch_pkt_t *) arg;
- static bool client_connected = false;
- ch_vpn_pkt_t * sf_pkt = (ch_vpn_pkt_t *) pkt->data;
+ if ( pkt->hdr.type == DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_CLIENT )
+ dap_chain_net_vpn_client_pkt_in( ch, pkt);
+ else {
+ static bool client_connected = false;
+ ch_vpn_pkt_t * sf_pkt = (ch_vpn_pkt_t *) pkt->data;
- int remote_sock_id = sf_pkt->header.sock_id;
+ int remote_sock_id = sf_pkt->header.sock_id;
- //log_it(L_DEBUG, "Got SF packet with id %d op_code 0x%02x", remote_sock_id, sf_pkt->header.op_code);
- if(sf_pkt->header.op_code >= 0xb0) { // Raw packets
- switch (sf_pkt->header.op_code) {
- case VPN_PACKET_OP_CODE_VPN_ADDR_REQUEST: { // Client request after L3 connection the new IP address
- log_it(L_DEBUG, "Got SF packet with id %d op_code 0x%02x", remote_sock_id, sf_pkt->header.op_code);
- struct in_addr n_addr = { 0 };
+ //log_it(L_DEBUG, "Got SF packet with id %d op_code 0x%02x", remote_sock_id, sf_pkt->header.op_code);
+ if(sf_pkt->header.op_code >= 0xb0) { // Raw packets
+ switch (sf_pkt->header.op_code) {
+ case VPN_PACKET_OP_CODE_VPN_ADDR_REQUEST: { // Client request after L3 connection the new IP address
+ log_it(L_DEBUG, "Got SF packet with id %d op_code 0x%02x", remote_sock_id, sf_pkt->header.op_code);
+ struct in_addr n_addr = { 0 };
- if(n_addr.s_addr == 0) { // If the addres still in the network
+ if(n_addr.s_addr == 0) { // If the addres still in the network
- pthread_mutex_lock(&s_raw_server->clients_mutex);
+ pthread_mutex_lock(&s_raw_server->clients_mutex);
+
+ int count_free_addr = -1;
+ list_addr_element *el;
+ LL_COUNT(list_addr_head, el, count_free_addr);
+
+ dap_stream_ch_vpn_remote_single_t * n_client = (dap_stream_ch_vpn_remote_single_t*) calloc(1,
+ sizeof(dap_stream_ch_vpn_remote_single_t));
+ n_client->ch = ch;
+
+ if(count_free_addr > 0) {
+ n_addr.s_addr = list_addr_head->addr.s_addr;
+ LL_DELETE(list_addr_head, list_addr_head);
+ }
+ else
+ {
+ n_addr.s_addr = ntohl(s_raw_server->client_addr_last.s_addr);
+ n_addr.s_addr++;
+ n_addr.s_addr = ntohl(n_addr.s_addr);
+ }
- int count_free_addr = -1;
- list_addr_element *el;
- LL_COUNT(list_addr_head, el, count_free_addr);
+ n_client->addr = n_addr.s_addr;
+ s_raw_server->client_addr_last.s_addr = n_addr.s_addr;
+ ch->stream->session->tun_client_addr.s_addr = n_addr.s_addr;
+ HASH_ADD_INT(s_raw_server->clients, addr, n_client);
- dap_stream_ch_vpn_remote_single_t * n_client = (dap_stream_ch_vpn_remote_single_t*) calloc(1,
- sizeof(dap_stream_ch_vpn_remote_single_t));
- n_client->ch = ch;
+ pthread_mutex_unlock(&s_raw_server->clients_mutex);
- if(count_free_addr > 0) {
- n_addr.s_addr = list_addr_head->addr.s_addr;
- LL_DELETE(list_addr_head, list_addr_head);
+ log_it(L_NOTICE, "VPN client address %s leased", inet_ntoa(n_addr));
+ log_it(L_INFO, "\tgateway %s", inet_ntoa(s_raw_server->client_addr_host));
+ log_it(L_INFO, "\tmask %s", inet_ntoa(s_raw_server->client_addr_mask));
+ log_it(L_INFO, "\taddr %s", inet_ntoa(s_raw_server->client_addr));
+ log_it(L_INFO, "\tlast_addr %s", inet_ntoa(s_raw_server->client_addr_last));
+
+ ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1,
+ sizeof(pkt_out->header) + sizeof(n_addr) + sizeof(s_raw_server->client_addr_host));
+ pkt_out->header.sock_id = s_raw_server->tun_fd;
+ pkt_out->header.op_code = VPN_PACKET_OP_CODE_VPN_ADDR_REPLY;
+ pkt_out->header.op_data.data_size = sizeof(n_addr) + sizeof(s_raw_server->client_addr_host);
+
+ memcpy(pkt_out->data, &n_addr, sizeof(n_addr));
+ memcpy(pkt_out->data + sizeof(n_addr), &s_raw_server->client_addr_host,
+ sizeof(s_raw_server->client_addr_host));
+ dap_stream_ch_pkt_write(ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pkt_out,
+ pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
+ stream_sf_socket_ready_to_write(ch, true);
+
+ //ch_sf_raw_write(n_addr.s_addr,STREAM_SF_PACKET_OP_CODE_RAW_L3_ADDR_REPLY,&n_addr,sizeof(n_addr));
+ } else { // All the network is filled with clients, can't lease a new address
+ log_it(L_WARNING, "All the network is filled with clients, can't lease a new address");
+ ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
+ pkt_out->header.sock_id = s_raw_server->tun_fd;
+ pkt_out->header.op_code = VPN_PACKET_OP_CODE_PROBLEM;
+ pkt_out->header.op_problem.code = VPN_PROBLEM_CODE_NO_FREE_ADDR;
+ dap_stream_ch_pkt_write(ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pkt_out,
+ pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
+ stream_sf_socket_ready_to_write(ch, true);
}
- else
- {
- n_addr.s_addr = ntohl(s_raw_server->client_addr_last.s_addr);
- n_addr.s_addr++;
- n_addr.s_addr = ntohl(n_addr.s_addr);
+ }
+ break;
+ case VPN_PACKET_OP_CODE_VPN_SEND: {
+ struct in_addr in_saddr, in_daddr;
+ in_saddr.s_addr = ((struct iphdr*) sf_pkt->data)->saddr;
+ in_daddr.s_addr = ((struct iphdr*) sf_pkt->data)->daddr;
+
+ char str_daddr[42], str_saddr[42];
+ strncpy(str_saddr, inet_ntoa(in_saddr), sizeof(str_saddr));
+ strncpy(str_daddr, inet_ntoa(in_daddr), sizeof(str_daddr));
+ int ret;
+ //if( ch_sf_raw_write(STREAM_SF_PACKET_OP_CODE_RAW_SEND, sf_pkt->data, sf_pkt->op_data.data_size)<0){
+ struct sockaddr_in sin = { 0 };
+ sin.sin_family = AF_INET;
+ sin.sin_port = 0;
+ sin.sin_addr.s_addr = in_daddr.s_addr;
+
+ //if((ret=sendto(CH_SF(ch)->raw_l3_sock , sf_pkt->data,sf_pkt->header.op_data.data_size,0,(struct sockaddr *) &sin, sizeof (sin)))<0){
+ if((ret = write(s_raw_server->tun_fd, sf_pkt->data, sf_pkt->header.op_data.data_size)) < 0) {
+ log_it(L_ERROR, "write() returned error %d : '%s'", ret, strerror(errno));
+ //log_it(L_ERROR,"raw socket ring buffer overflowed");
+ ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
+ pkt_out->header.op_code = VPN_PACKET_OP_CODE_PROBLEM;
+ pkt_out->header.op_problem.code = VPN_PROBLEM_CODE_PACKET_LOST;
+ pkt_out->header.sock_id = s_raw_server->tun_fd;
+ dap_stream_ch_pkt_write(ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pkt_out,
+ pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
+ stream_sf_socket_ready_to_write(ch, true);
+ } else {
+ //log_it(L_DEBUG, "Raw IP packet daddr:%s saddr:%s %u from %d bytes sent to tun/tap interface",
+ // str_saddr, str_daddr, sf_pkt->header.op_data.data_size, ret);
+ //log_it(L_DEBUG, "Raw IP sent %u bytes ", ret);
}
-
- n_client->addr = n_addr.s_addr;
- s_raw_server->client_addr_last.s_addr = n_addr.s_addr;
- ch->stream->session->tun_client_addr.s_addr = n_addr.s_addr;
- HASH_ADD_INT(s_raw_server->clients, addr, n_client);
-
- pthread_mutex_unlock(&s_raw_server->clients_mutex);
-
- log_it(L_NOTICE, "VPN client address %s leased", inet_ntoa(n_addr));
- log_it(L_INFO, "\tgateway %s", inet_ntoa(s_raw_server->client_addr_host));
- log_it(L_INFO, "\tmask %s", inet_ntoa(s_raw_server->client_addr_mask));
- log_it(L_INFO, "\taddr %s", inet_ntoa(s_raw_server->client_addr));
- log_it(L_INFO, "\tlast_addr %s", inet_ntoa(s_raw_server->client_addr_last));
-
- ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1,
- sizeof(pkt_out->header) + sizeof(n_addr) + sizeof(s_raw_server->client_addr_host));
- pkt_out->header.sock_id = s_raw_server->tun_fd;
- pkt_out->header.op_code = VPN_PACKET_OP_CODE_VPN_ADDR_REPLY;
- pkt_out->header.op_data.data_size = sizeof(n_addr) + sizeof(s_raw_server->client_addr_host);
- memcpy(pkt_out->data, &n_addr, sizeof(n_addr));
- memcpy(pkt_out->data + sizeof(n_addr), &s_raw_server->client_addr_host,
- sizeof(s_raw_server->client_addr_host));
- dap_stream_ch_pkt_write(ch, DATA_CHANNEL_ID, pkt_out,
- pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
- stream_sf_socket_ready_to_write(ch, true);
-
- //ch_sf_raw_write(n_addr.s_addr,STREAM_SF_PACKET_OP_CODE_RAW_L3_ADDR_REPLY,&n_addr,sizeof(n_addr));
- } else { // All the network is filled with clients, can't lease a new address
- log_it(L_WARNING, "All the network is filled with clients, can't lease a new address");
- ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
- pkt_out->header.sock_id = s_raw_server->tun_fd;
- pkt_out->header.op_code = VPN_PACKET_OP_CODE_PROBLEM;
- pkt_out->header.op_problem.code = VPN_PROBLEM_CODE_NO_FREE_ADDR;
- dap_stream_ch_pkt_write(ch, DATA_CHANNEL_ID, pkt_out,
- pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
- stream_sf_socket_ready_to_write(ch, true);
+ //}
}
- }
- break;
- case VPN_PACKET_OP_CODE_VPN_SEND: {
- struct in_addr in_saddr, in_daddr;
- in_saddr.s_addr = ((struct iphdr*) sf_pkt->data)->saddr;
- in_daddr.s_addr = ((struct iphdr*) sf_pkt->data)->daddr;
-
- char str_daddr[42], str_saddr[42];
- strncpy(str_saddr, inet_ntoa(in_saddr), sizeof(str_saddr));
- strncpy(str_daddr, inet_ntoa(in_daddr), sizeof(str_daddr));
- int ret;
- //if( ch_sf_raw_write(STREAM_SF_PACKET_OP_CODE_RAW_SEND, sf_pkt->data, sf_pkt->op_data.data_size)<0){
- struct sockaddr_in sin = { 0 };
- sin.sin_family = AF_INET;
- sin.sin_port = 0;
- sin.sin_addr.s_addr = in_daddr.s_addr;
-
- //if((ret=sendto(CH_SF(ch)->raw_l3_sock , sf_pkt->data,sf_pkt->header.op_data.data_size,0,(struct sockaddr *) &sin, sizeof (sin)))<0){
- if((ret = write(s_raw_server->tun_fd, sf_pkt->data, sf_pkt->header.op_data.data_size)) < 0) {
- log_it(L_ERROR, "write() returned error %d : '%s'", ret, strerror(errno));
- //log_it(L_ERROR,"raw socket ring buffer overflowed");
- ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
- pkt_out->header.op_code = VPN_PACKET_OP_CODE_PROBLEM;
- pkt_out->header.op_problem.code = VPN_PROBLEM_CODE_PACKET_LOST;
- pkt_out->header.sock_id = s_raw_server->tun_fd;
- dap_stream_ch_pkt_write(ch, DATA_CHANNEL_ID, pkt_out,
- pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
- stream_sf_socket_ready_to_write(ch, true);
- } else {
- //log_it(L_DEBUG, "Raw IP packet daddr:%s saddr:%s %u from %d bytes sent to tun/tap interface",
- // str_saddr, str_daddr, sf_pkt->header.op_data.data_size, ret);
- //log_it(L_DEBUG, "Raw IP sent %u bytes ", ret);
+ break;
+ default:
+ log_it(L_WARNING, "Can't process SF type 0x%02x", sf_pkt->header.op_code);
}
- //}
- }
- break;
- default:
- log_it(L_WARNING, "Can't process SF type 0x%02x", sf_pkt->header.op_code);
- }
- } else { // All except CONNECT
- ch_vpn_socket_proxy_t * sf_sock = NULL;
- if(sf_pkt->header.op_code != VPN_PACKET_OP_CODE_CONNECT) {
+ } else { // All except CONNECT
+ ch_vpn_socket_proxy_t * sf_sock = NULL;
+ if(sf_pkt->header.op_code != VPN_PACKET_OP_CODE_CONNECT) {
+
+ pthread_mutex_lock(&( CH_VPN(ch)->mutex));
+ // log_it(L_DEBUG,"Looking in hash table with %d",remote_sock_id);
+ HASH_FIND_INT((CH_VPN(ch)->socks), &remote_sock_id, sf_sock);
+ pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
+
+ if(sf_sock != NULL) {
+ pthread_mutex_lock(&sf_sock->mutex); // Unlock it in your case as soon as possible to reduce lock time
+ sf_sock->time_lastused = time(NULL);
+ switch (sf_pkt->header.op_code) {
+ case VPN_PACKET_OP_CODE_SEND: {
+ if(client_connected == false)
+ {
+ log_it(L_WARNING, "Drop Packet! User not connected!"); // Client need send
+ pthread_mutex_unlock(&s_sf_socks_mutex);
+ break;
+ }
+ int ret;
+ if((ret = send(sf_sock->sock, sf_pkt->data, sf_pkt->header.op_data.data_size, 0)) < 0) {
+ log_it(L_INFO, "Disconnected from the remote host");
+ pthread_mutex_unlock(&sf_sock->mutex);
+ pthread_mutex_lock(&( CH_VPN(ch)->mutex));
+ HASH_DEL(CH_VPN(ch)->socks, sf_sock);
+ pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
- pthread_mutex_lock(&( CH_VPN(ch)->mutex));
- // log_it(L_DEBUG,"Looking in hash table with %d",remote_sock_id);
- HASH_FIND_INT((CH_VPN(ch)->socks), &remote_sock_id, sf_sock);
- pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
+ pthread_mutex_lock(&s_sf_socks_mutex);
+ HASH_DELETE(hh2, sf_socks, sf_sock);
+ HASH_DELETE(hh_sock, sf_socks_client, sf_sock);
- if(sf_sock != NULL) {
- pthread_mutex_lock(&sf_sock->mutex); // Unlock it in your case as soon as possible to reduce lock time
- sf_sock->time_lastused = time(NULL);
- switch (sf_pkt->header.op_code) {
- case VPN_PACKET_OP_CODE_SEND: {
- if(client_connected == false)
- {
- log_it(L_WARNING, "Drop Packet! User not connected!"); // Client need send
- pthread_mutex_unlock(&s_sf_socks_mutex);
- break;
+ struct epoll_event ev;
+ ev.data.fd = sf_sock->sock;
+ ev.events = EPOLLIN;
+ if(epoll_ctl(sf_socks_epoll_fd, EPOLL_CTL_DEL, sf_sock->sock, &ev) < 0) {
+ log_it(L_ERROR, "Can't remove sock_id %d from the epoll fd", remote_sock_id);
+ //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=0x%02x result=-2",sf_pkt->sock_id, sf_pkt->op_code);
+ } else {
+ log_it(L_NOTICE, "Removed sock_id %d from the the epoll fd", remote_sock_id);
+ //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=0x%02x result=0",sf_pkt->sock_id, sf_pkt->op_code);
+ }
+ pthread_mutex_unlock(&s_sf_socks_mutex);
+
+ stream_sf_socket_delete(sf_sock);
+ } else {
+ sf_sock->bytes_sent += ret;
+ pthread_mutex_unlock(&sf_sock->mutex);
+ }
+ //log_it(L_INFO, "Send action from %d sock_id (sf_packet size %lu, ch packet size %lu, have sent %d)"
+ // , sf_sock->id, sf_pkt->header.op_data.data_size, pkt->hdr.size, ret);
}
- int ret;
- if((ret = send(sf_sock->sock, sf_pkt->data, sf_pkt->header.op_data.data_size, 0)) < 0) {
- log_it(L_INFO, "Disconnected from the remote host");
- pthread_mutex_unlock(&sf_sock->mutex);
+ break;
+ case VPN_PACKET_OP_CODE_DISCONNECT: {
+ log_it(L_INFO, "Disconnect action from %d sock_id", sf_sock->id);
+
pthread_mutex_lock(&( CH_VPN(ch)->mutex));
HASH_DEL(CH_VPN(ch)->socks, sf_sock);
pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
@@ -541,139 +578,108 @@ void srv_ch_sf_packet_in(dap_stream_ch_t* ch, void* arg)
pthread_mutex_lock(&s_sf_socks_mutex);
HASH_DELETE(hh2, sf_socks, sf_sock);
HASH_DELETE(hh_sock, sf_socks_client, sf_sock);
-
struct epoll_event ev;
ev.data.fd = sf_sock->sock;
ev.events = EPOLLIN;
if(epoll_ctl(sf_socks_epoll_fd, EPOLL_CTL_DEL, sf_sock->sock, &ev) < 0) {
- log_it(L_ERROR, "Can't remove sock_id %d from the epoll fd", remote_sock_id);
- //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=0x%02x result=-2",sf_pkt->sock_id, sf_pkt->op_code);
+ log_it(L_ERROR, "Can't remove sock_id %d to the epoll fd", remote_sock_id);
+ //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=%uc result=-2",sf_pkt->sock_id, sf_pkt->op_code);
} else {
- log_it(L_NOTICE, "Removed sock_id %d from the the epoll fd", remote_sock_id);
- //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=0x%02x result=0",sf_pkt->sock_id, sf_pkt->op_code);
+ log_it(L_NOTICE, "Removed sock_id %d from the epoll fd", remote_sock_id);
+ //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=%uc result=0",sf_pkt->sock_id, sf_pkt->op_code);
}
pthread_mutex_unlock(&s_sf_socks_mutex);
+ pthread_mutex_unlock(&sf_sock->mutex);
stream_sf_socket_delete(sf_sock);
- } else {
- sf_sock->bytes_sent += ret;
+ }
+ break;
+ default: {
+ log_it(L_WARNING, "Unprocessed op code 0x%02x", sf_pkt->header.op_code);
pthread_mutex_unlock(&sf_sock->mutex);
}
- //log_it(L_INFO, "Send action from %d sock_id (sf_packet size %lu, ch packet size %lu, have sent %d)"
- // , sf_sock->id, sf_pkt->header.op_data.data_size, pkt->hdr.size, ret);
- }
- break;
- case VPN_PACKET_OP_CODE_DISCONNECT: {
- log_it(L_INFO, "Disconnect action from %d sock_id", sf_sock->id);
-
- pthread_mutex_lock(&( CH_VPN(ch)->mutex));
- HASH_DEL(CH_VPN(ch)->socks, sf_sock);
- pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
-
- pthread_mutex_lock(&s_sf_socks_mutex);
- HASH_DELETE(hh2, sf_socks, sf_sock);
- HASH_DELETE(hh_sock, sf_socks_client, sf_sock);
- struct epoll_event ev;
- ev.data.fd = sf_sock->sock;
- ev.events = EPOLLIN;
- if(epoll_ctl(sf_socks_epoll_fd, EPOLL_CTL_DEL, sf_sock->sock, &ev) < 0) {
- log_it(L_ERROR, "Can't remove sock_id %d to the epoll fd", remote_sock_id);
- //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=%uc result=-2",sf_pkt->sock_id, sf_pkt->op_code);
- } else {
- log_it(L_NOTICE, "Removed sock_id %d from the epoll fd", remote_sock_id);
- //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=%uc result=0",sf_pkt->sock_id, sf_pkt->op_code);
}
- pthread_mutex_unlock(&s_sf_socks_mutex);
-
- pthread_mutex_unlock(&sf_sock->mutex);
- stream_sf_socket_delete(sf_sock);
- }
- break;
- default: {
- log_it(L_WARNING, "Unprocessed op code 0x%02x", sf_pkt->header.op_code);
- pthread_mutex_unlock(&sf_sock->mutex);
- }
- }
- } //else
- // log_it(L_WARNING, "Packet input: packet with sock_id %d thats not present in current stream channel",
- // remote_sock_id);
- } else {
- HASH_FIND_INT(CH_VPN(ch)->socks, &remote_sock_id, sf_sock);
- if(sf_sock) {
- log_it(L_WARNING, "Socket id %d is already used, take another number for socket id", remote_sock_id);
- } else { // Connect action
- struct sockaddr_in remote_addr;
- char addr_str[1024];
- size_t addr_str_size =
- (sf_pkt->header.op_connect.addr_size > (sizeof(addr_str) - 1)) ?
- (sizeof(addr_str) - 1) :
- sf_pkt->header.op_connect.addr_size;
- memset(&remote_addr, 0, sizeof(remote_addr));
- remote_addr.sin_family = AF_INET;
- remote_addr.sin_port = htons(sf_pkt->header.op_connect.port);
-
- memcpy(addr_str, sf_pkt->data, addr_str_size);
- addr_str[addr_str_size] = 0;
-
- log_it(L_DEBUG, "Connect action to %s:%u (addr_size %lu)", addr_str, sf_pkt->header.op_connect.port,
- sf_pkt->header.op_connect.addr_size);
- if(inet_pton(AF_INET, addr_str, &(remote_addr.sin_addr)) < 0) {
- log_it(L_ERROR, "Wrong remote address '%s:%u'", addr_str, sf_pkt->header.op_connect.port);
- } else {
- int s;
- if((s = socket(AF_INET, SOCK_STREAM, 0)) >= 0) {
- log_it(L_DEBUG, "Socket is created (%d)", s);
- if(connect(s, (struct sockaddr *) &remote_addr, sizeof(remote_addr)) >= 0) {
- fcntl(s, F_SETFL, O_NONBLOCK);
- log_it(L_INFO, "Remote address connected (%s:%u) with sock_id %d", addr_str,
- sf_pkt->header.op_connect.port, remote_sock_id);
- ch_vpn_socket_proxy_t * sf_sock = NULL;
- sf_sock = DAP_NEW_Z(ch_vpn_socket_proxy_t);
- sf_sock->id = remote_sock_id;
- sf_sock->sock = s;
- sf_sock->ch = ch;
- pthread_mutex_init(&sf_sock->mutex, NULL);
-
- pthread_mutex_lock(&s_sf_socks_mutex);
- pthread_mutex_lock(&( CH_VPN(ch)->mutex));
- HASH_ADD_INT(CH_VPN(ch)->socks, id, sf_sock);
- log_it(L_DEBUG, "Added %d sock_id with sock %d to the hash table", sf_sock->id,
- sf_sock->sock);
- HASH_ADD(hh2, sf_socks, id, sizeof(sf_sock->id), sf_sock);
- log_it(L_DEBUG, "Added %d sock_id with sock %d to the hash table", sf_sock->id,
- sf_sock->sock);
- HASH_ADD(hh_sock, sf_socks_client, sock, sizeof(int), sf_sock);
- //log_it(L_DEBUG,"Added %d sock_id with sock %d to the socks hash table",sf->id,sf->sock);
- pthread_mutex_unlock(&s_sf_socks_mutex);
- pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
-
- struct epoll_event ev;
- ev.data.fd = s;
- ev.events = EPOLLIN | EPOLLERR;
-
- if(epoll_ctl(sf_socks_epoll_fd, EPOLL_CTL_ADD, s, &ev) == -1) {
- log_it(L_ERROR, "Can't add sock_id %d to the epoll fd", remote_sock_id);
- //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=%uc result=-2",sf_pkt->sock_id, sf_pkt->op_code);
+ } //else
+ // log_it(L_WARNING, "Packet input: packet with sock_id %d thats not present in current stream channel",
+ // remote_sock_id);
+ } else {
+ HASH_FIND_INT(CH_VPN(ch)->socks, &remote_sock_id, sf_sock);
+ if(sf_sock) {
+ log_it(L_WARNING, "Socket id %d is already used, take another number for socket id", remote_sock_id);
+ } else { // Connect action
+ struct sockaddr_in remote_addr;
+ char addr_str[1024];
+ size_t addr_str_size =
+ (sf_pkt->header.op_connect.addr_size > (sizeof(addr_str) - 1)) ?
+ (sizeof(addr_str) - 1) :
+ sf_pkt->header.op_connect.addr_size;
+ memset(&remote_addr, 0, sizeof(remote_addr));
+ remote_addr.sin_family = AF_INET;
+ remote_addr.sin_port = htons(sf_pkt->header.op_connect.port);
+
+ memcpy(addr_str, sf_pkt->data, addr_str_size);
+ addr_str[addr_str_size] = 0;
+
+ log_it(L_DEBUG, "Connect action to %s:%u (addr_size %lu)", addr_str, sf_pkt->header.op_connect.port,
+ sf_pkt->header.op_connect.addr_size);
+ if(inet_pton(AF_INET, addr_str, &(remote_addr.sin_addr)) < 0) {
+ log_it(L_ERROR, "Wrong remote address '%s:%u'", addr_str, sf_pkt->header.op_connect.port);
+ } else {
+ int s;
+ if((s = socket(AF_INET, SOCK_STREAM, 0)) >= 0) {
+ log_it(L_DEBUG, "Socket is created (%d)", s);
+ if(connect(s, (struct sockaddr *) &remote_addr, sizeof(remote_addr)) >= 0) {
+ fcntl(s, F_SETFL, O_NONBLOCK);
+ log_it(L_INFO, "Remote address connected (%s:%u) with sock_id %d", addr_str,
+ sf_pkt->header.op_connect.port, remote_sock_id);
+ ch_vpn_socket_proxy_t * sf_sock = NULL;
+ sf_sock = DAP_NEW_Z(ch_vpn_socket_proxy_t);
+ sf_sock->id = remote_sock_id;
+ sf_sock->sock = s;
+ sf_sock->ch = ch;
+ pthread_mutex_init(&sf_sock->mutex, NULL);
+
+ pthread_mutex_lock(&s_sf_socks_mutex);
+ pthread_mutex_lock(&( CH_VPN(ch)->mutex));
+ HASH_ADD_INT(CH_VPN(ch)->socks, id, sf_sock);
+ log_it(L_DEBUG, "Added %d sock_id with sock %d to the hash table", sf_sock->id,
+ sf_sock->sock);
+ HASH_ADD(hh2, sf_socks, id, sizeof(sf_sock->id), sf_sock);
+ log_it(L_DEBUG, "Added %d sock_id with sock %d to the hash table", sf_sock->id,
+ sf_sock->sock);
+ HASH_ADD(hh_sock, sf_socks_client, sock, sizeof(int), sf_sock);
+ //log_it(L_DEBUG,"Added %d sock_id with sock %d to the socks hash table",sf->id,sf->sock);
+ pthread_mutex_unlock(&s_sf_socks_mutex);
+ pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
+
+ struct epoll_event ev;
+ ev.data.fd = s;
+ ev.events = EPOLLIN | EPOLLERR;
+
+ if(epoll_ctl(sf_socks_epoll_fd, EPOLL_CTL_ADD, s, &ev) == -1) {
+ log_it(L_ERROR, "Can't add sock_id %d to the epoll fd", remote_sock_id);
+ //stream_ch_pkt_write_f(ch,'i',"sock_id=%d op_code=%uc result=-2",sf_pkt->sock_id, sf_pkt->op_code);
+ } else {
+ log_it(L_NOTICE, "Added sock_id %d with sock %d to the epoll fd", remote_sock_id, s);
+ log_it(L_NOTICE, "Send Connected packet to User");
+ ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
+ pkt_out->header.sock_id = remote_sock_id;
+ pkt_out->header.op_code = VPN_PACKET_OP_CODE_CONNECTED;
+ dap_stream_ch_pkt_write(ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_CLIENT, pkt_out,
+ pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
+ free(pkt_out);
+ client_connected = true;
+ }
+ stream_sf_socket_ready_to_write(ch, true);
} else {
- log_it(L_NOTICE, "Added sock_id %d with sock %d to the epoll fd", remote_sock_id, s);
- log_it(L_NOTICE, "Send Connected packet to User");
- ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header));
- pkt_out->header.sock_id = remote_sock_id;
- pkt_out->header.op_code = VPN_PACKET_OP_CODE_CONNECTED;
- dap_stream_ch_pkt_write(ch, SERVICE_CHANNEL_ID, pkt_out,
- pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
- free(pkt_out);
- client_connected = true;
+ log_it(L_INFO, "Can't connect to the remote server %s", addr_str);
+ dap_stream_ch_pkt_write_f(ch, 'i', "sock_id=%d op_code=%c result=-1",
+ sf_pkt->header.sock_id, sf_pkt->header.op_code);
+ stream_sf_socket_ready_to_write(ch, true);
}
- stream_sf_socket_ready_to_write(ch, true);
} else {
- log_it(L_INFO, "Can't connect to the remote server %s", addr_str);
- dap_stream_ch_pkt_write_f(ch, 'i', "sock_id=%d op_code=%c result=-1",
- sf_pkt->header.sock_id, sf_pkt->header.op_code);
- stream_sf_socket_ready_to_write(ch, true);
+ log_it(L_ERROR, "Can't create the socket");
}
- } else {
- log_it(L_ERROR, "Can't create the socket");
}
}
}
@@ -871,7 +877,7 @@ void* srv_ch_sf_thread_raw(void *arg)
pkt_out->header.sock_id = s_raw_server->tun_fd;
pkt_out->header.op_data.data_size = read_ret;
memcpy(pkt_out->data, tmp_buf, read_ret);
- dap_stream_ch_pkt_write(raw_client->ch, DATA_CHANNEL_ID, pkt_out,
+ dap_stream_ch_pkt_write(raw_client->ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pkt_out,
pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
stream_sf_socket_ready_to_write(raw_client->ch, true);
}
@@ -912,7 +918,7 @@ void srv_ch_sf_packet_out(dap_stream_ch_t* ch, void* arg)
for(i = 0; i < cur->pkt_out_size; i++) {
ch_vpn_pkt_t * pout = cur->pkt_out[i];
if(pout) {
- if(dap_stream_ch_pkt_write(ch, DATA_CHANNEL_ID, pout,
+ if(dap_stream_ch_pkt_write(ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pout,
pout->header.op_data.data_size + sizeof(pout->header))) {
isSmthOut = true;
free(pout);
diff --git a/dap_chain_net_srv_vpn.h b/dap_chain_net_srv_vpn.h
index 477455f1688990c23f4be5e9b5e82a3e91f62fbd..115faaaec4390e2a22d93591ef4871189c2feac8 100755
--- a/dap_chain_net_srv_vpn.h
+++ b/dap_chain_net_srv_vpn.h
@@ -28,6 +28,12 @@
#include "dap_config.h"
#include "dap_chain_net_srv.h"
+
+#define DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_CLIENT 0x01
+#define DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA 0x02
+
+#define DAP_STREAM_CH_ID_NET_SRV_VPN 'S'
+
#define DAP_CHAIN_NET_SRV_VPN_ID 0x0000000000000001
#define VPN_PACKET_OP_CODE_CONNECTED 0x000000a9
diff --git a/dap_chain_net_vpn_client.c b/dap_chain_net_vpn_client.c
index d5aea4b84e458773c5df6ea35cef9de5f916b1b3..6ffa1cf15aa45c33d5fba3202e315c2edb701a21 100644
--- a/dap_chain_net_vpn_client.c
+++ b/dap_chain_net_vpn_client.c
@@ -68,14 +68,49 @@ static pthread_mutex_t sf_socks_mutex;
static dap_chain_node_info_t *s_node_info = NULL;
static dap_chain_node_client_t *s_vpn_client = NULL;
-dap_stream_ch_t* dap_chain_net_vpn_client_get_stream(void)
+dap_stream_ch_t* dap_chain_net_vpn_client_get_stream_ch(void)
{
if(!s_vpn_client)
return NULL;
- dap_stream_ch_t *l_stream = dap_client_get_stream_ch(s_vpn_client->client, VPN_CLIENT_ID);
+ dap_stream_ch_t *l_stream = dap_client_get_stream_ch(s_vpn_client->client, DAP_STREAM_CH_ID_NET_SRV_VPN );
return l_stream;
}
+
+
+/// TODO convert below callback to processor of stage
+/*
+void s_stage_callback()
+{
+ char* l_full_path = NULL;
+ const char * l_path = "stream";
+ const char *l_suburl = "globaldb";
+ int l_full_path_size = snprintf(l_full_path, 0, "%s/%s?session_id=%s", DAP_UPLINK_PATH_STREAM, l_suburl,
+ dap_client_get_stream_id(a_client_pvt->client));
+ l_full_path = DAP_NEW_Z_SIZE(char, l_full_path_size + 1);
+ snprintf(l_full_path, l_full_path_size + 1, "%s/%s?session_id=%s", DAP_UPLINK_PATH_STREAM, l_suburl,
+ dap_client_get_stream_id(a_client_pvt->client));
+
+ //dap_client_request(a_client_pvt->client, l_full_path, "12345", 0, m_stream_response, m_stream_error);
+
+ const char *l_add_str = "";
+ // if connect to vpn server
+ const char l_active_vpn_channels[] = { VPN_CLIENT_ID, 0 };
+ if(!dap_strcmp(a_client_pvt->active_channels, l_active_vpn_channels))
+ l_add_str = "\r\nService-Key: test";
+
+ {
+ char *l_message = dap_strdup_printf("GET /%s HTTP/1.1\r\nHost: %s:%d%s\r\n\r\n",
+ l_full_path, a_client_pvt->uplink_addr, a_client_pvt->uplink_port, l_add_str);
+ size_t l_message_size = dap_strlen(l_message);
+ int count = send(a_client_pvt->stream_socket, l_message, l_message_size, 0);
+ DAP_DELETE(l_message);
+ }
+ DAP_DELETE(l_full_path);
+
+}*/
+
+
/**
* Start VPN client
*
@@ -101,11 +136,14 @@ int dap_chain_net_vpn_client_start(dap_chain_net_t *a_net, const char *a_ipv4_st
s_node_info->hdr.ext_port = a_port;
dap_client_stage_t l_stage_target = STAGE_STREAM_STREAMING; //DAP_CLIENT_STAGE_STREAM_CTL;//STAGE_STREAM_STREAMING;
- const char l_active_channels[] = { VPN_CLIENT_ID, 0 };
+ const char l_active_channels[] = { DAP_STREAM_CH_ID_NET_SRV_VPN , 0 };
if(a_ipv4_str)
inet_pton(AF_INET, a_ipv4_str, &(s_node_info->hdr.ext_addr_v4));
if(a_ipv6_str)
inet_pton(AF_INET6, a_ipv6_str, &(s_node_info->hdr.ext_addr_v6));
+
+
+
s_vpn_client = dap_chain_client_connect(s_node_info, l_stage_target, l_active_channels);
if(!s_vpn_client) {
log_it(L_ERROR, "Can't connect to VPN server=%s:%d", a_ipv4_str, a_port);
@@ -132,8 +170,8 @@ int dap_chain_net_vpn_client_start(dap_chain_net_t *a_net, const char *a_ipv4_st
// send first packet to server
// if(0)
{
- dap_stream_ch_t *l_stream = dap_chain_net_vpn_client_get_stream();
- if(l_stream) { // Is present in hash table such destination address
+ dap_stream_ch_t *l_ch = dap_chain_net_vpn_client_get_stream_ch();
+ if(l_ch) { // Is present in hash table such destination address
size_t l_ipv4_str_len = 0; //dap_strlen(a_ipv4_str);
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header) + l_ipv4_str_len);
@@ -142,9 +180,9 @@ int dap_chain_net_vpn_client_start(dap_chain_net_t *a_net, const char *a_ipv4_st
//pkt_out->header.op_connect.addr_size = l_ipv4_str_len; //remoteAddrBA.length();
//pkt_out->header.op_connect.port = a_port;
//memcpy(pkt_out->data, a_ipv4_str, l_ipv4_str_len);
- dap_stream_ch_pkt_write(l_stream, DATA_CHANNEL_ID, pkt_out,
+ dap_stream_ch_pkt_write(l_ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pkt_out,
pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
- dap_stream_ch_set_ready_to_write(l_stream, true);
+ dap_stream_ch_set_ready_to_write(l_ch, true);
DAP_DELETE(pkt_out);
}
}
@@ -240,62 +278,16 @@ static void send_pong_pkt(dap_stream_ch_t* a_ch)
}
/**
- * @brief ch_sf_new Callback to constructor of object of Ch
- * @param ch
- * @param arg
- */
-static void ch_sf_new(dap_stream_ch_t* a_ch, void* arg)
-{
- log_it(L_INFO, "SF channel created");
-
- a_ch->internal = DAP_NEW_Z(dap_chain_net_srv_vpn_t);
- dap_chain_net_srv_vpn_t * l_sf = CH_VPN(a_ch);
- l_sf->ch = a_ch;
- pthread_mutex_init(&l_sf->mutex, NULL);
-
- pthread_mutex_lock(&( CH_VPN(a_ch)->mutex));
- pthread_mutex_unlock(&( CH_VPN(a_ch)->mutex));
-
- l_sf->raw_l3_sock = socket(PF_INET, SOCK_RAW, IPPROTO_RAW);
- //a_ch->stream->events_socket->is_pingable = true; //set up connection to be pingable by main loop
-
-}
-
-/**
- * @brief ch_sf_delete
- * @param ch
- * @param arg
- */
-static void ch_sf_delete(dap_stream_ch_t* a_ch, void* arg)
-{
-
- log_it(L_DEBUG, "ch_sf_delete()");
- /* ch_vpn_socket_proxy_t * cur, *tmp;
- ch_sf_tun_delete(CH_SF(a_ch));
- HASH_ITER(hh, CH_SF(a_ch)->socks , cur, tmp) {
- log_it(L_DEBUG,"delete socket: %i", cur->sock);
- HASH_DEL(CH_SF(a_ch)->socks,cur);
- if (cur)
- free(cur);
- }*/
- pthread_mutex_unlock(&( CH_VPN(a_ch)->mutex));
- if(CH_VPN(a_ch)->raw_l3_sock)
- close(CH_VPN(a_ch)->raw_l3_sock);
-}
-
-/**
- * @brief ch_sf_packet_in
- * @param ch
- * @param arg
+ * @brief dap_chain_net_vpn_client_pkt_in
+ * @param a_ch
+ * @param a_arg
*/
-static void ch_sf_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
+void dap_chain_net_vpn_client_pkt_in(dap_stream_ch_t* a_ch, dap_stream_ch_pkt_t* a_pkt)
{
- dap_stream_ch_pkt_t * l_pkt = (dap_stream_ch_pkt_t *) a_arg;
-
- ch_vpn_pkt_t * l_sf_pkt = (ch_vpn_pkt_t *) l_pkt->data;
- size_t l_sf_pkt_data_size = l_pkt->hdr.size - sizeof(l_sf_pkt->header);
+ ch_vpn_pkt_t * l_sf_pkt = (ch_vpn_pkt_t *) a_pkt->data;
+ size_t l_sf_pkt_data_size = a_pkt->hdr.size - sizeof(l_sf_pkt->header);
- if(!l_pkt->hdr.size) {
+ if(!a_pkt->hdr.size) {
log_it(L_WARNING, "Bad input packet");
return;
}
@@ -381,7 +373,7 @@ static void ch_sf_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
pthread_mutex_unlock(&sf_sock->mutex);
}
log_it(L_INFO, "Send action from %d sock_id (sf_packet size %lu, ch packet size %lu, have sent %d)"
- , sf_sock->id, l_sf_pkt->header.op_data.data_size, l_pkt->hdr.size, ret);
+ , sf_sock->id, l_sf_pkt->header.op_data.data_size, a_pkt->hdr.size, ret);
}
break;
case VPN_PACKET_OP_CODE_DISCONNECT: {
@@ -530,61 +522,60 @@ static void ch_sf_packet_in(dap_stream_ch_t* a_ch, void* a_arg)
}
/**
- * @brief stream_sf_packet_out Packet Out Ch callback
- * @param ch
- * @param arg
+ * @brief dap_chain_net_vpn_client_pkt_out
+ * @param a_ch
*/
-static void ch_sf_packet_out(dap_stream_ch_t* ch, void* arg)
+void dap_chain_net_vpn_client_pkt_out(dap_stream_ch_t* a_ch)
{
- ch_vpn_socket_proxy_t * cur = NULL, *tmp;
- bool isSmthOut = false;
+ ch_vpn_socket_proxy_t * l_cur = NULL, *l_tmp;
+ bool l_is_smth_out = false;
// log_it(L_DEBUG,"Socket forwarding packet out callback: %u sockets in hashtable", HASH_COUNT(CH_VPN(ch)->socks) );
- HASH_ITER(hh, CH_VPN(ch)->socks , cur, tmp)
+ HASH_ITER(hh, CH_VPN(a_ch)->socks , l_cur, l_tmp)
{
- bool signalToBreak = false;
- pthread_mutex_lock(&(cur->mutex));
+ bool l_signal_to_break = false;
+ pthread_mutex_lock(&(l_cur->mutex));
int i;
// log_it(L_DEBUG,"Socket with id %d has %u packets in output buffer", cur->id, cur->pkt_out_size );
- if(cur->pkt_out_size) {
- for(i = 0; i < cur->pkt_out_size; i++) {
- ch_vpn_pkt_t * pout = cur->pkt_out[i];
+ if(l_cur->pkt_out_size) {
+ for(i = 0; i < l_cur->pkt_out_size; i++) {
+ ch_vpn_pkt_t * pout = l_cur->pkt_out[i];
if(pout) {
- if(dap_stream_ch_pkt_write(ch, 'd', pout, pout->header.op_data.data_size + sizeof(pout->header))) {
- isSmthOut = true;
+ if(dap_stream_ch_pkt_write(a_ch, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pout, pout->header.op_data.data_size + sizeof(pout->header))) {
+ l_is_smth_out = true;
if(pout)
free(pout);
- cur->pkt_out[i] = NULL;
+ l_cur->pkt_out[i] = NULL;
} else {
log_it(L_WARNING,
"Buffer is overflowed, breaking cycle to let the upper level cycle drop data to the output socket");
- isSmthOut = true;
- signalToBreak = true;
+ l_is_smth_out = true;
+ l_signal_to_break = true;
break;
}
}
}
}
- if(signalToBreak) {
- pthread_mutex_unlock(&(cur->mutex));
+ if(l_signal_to_break) {
+ pthread_mutex_unlock(&(l_cur->mutex));
break;
}
- cur->pkt_out_size = 0;
- if(cur->signal_to_delete) {
- log_it(L_NOTICE, "Socket id %d got signal to be deleted", cur->id);
- pthread_mutex_lock(&( CH_VPN(ch)->mutex));
- HASH_DEL(CH_VPN(ch)->socks, cur);
- pthread_mutex_unlock(&( CH_VPN(ch)->mutex));
+ l_cur->pkt_out_size = 0;
+ if(l_cur->signal_to_delete) {
+ log_it(L_NOTICE, "Socket id %d got signal to be deleted", l_cur->id);
+ pthread_mutex_lock(&( CH_VPN(a_ch)->mutex));
+ HASH_DEL(CH_VPN(a_ch)->socks, l_cur);
+ pthread_mutex_unlock(&( CH_VPN(a_ch)->mutex));
pthread_mutex_lock(&(sf_socks_mutex));
- HASH_DELETE(hh2, sf_socks, cur);
- HASH_DELETE(hh_sock, sf_socks_client, cur);
+ HASH_DELETE(hh2, sf_socks, l_cur);
+ HASH_DELETE(hh_sock, sf_socks_client, l_cur);
pthread_mutex_unlock(&(sf_socks_mutex));
- pthread_mutex_unlock(&(cur->mutex));
- vpn_socket_delete(cur);
+ pthread_mutex_unlock(&(l_cur->mutex));
+ vpn_socket_delete(l_cur);
} else
- pthread_mutex_unlock(&(cur->mutex));
+ pthread_mutex_unlock(&(l_cur->mutex));
}
/* ch->writable = isSmthOut;
if(isSmthOut) {
@@ -597,8 +588,6 @@ int dap_chain_net_vpn_client_init(dap_config_t * g_config)
{
pthread_mutex_init(&sf_socks_mutex, NULL);
- dap_stream_ch_proc_add(VPN_CLIENT_ID, ch_sf_new, ch_sf_delete, ch_sf_packet_in,
- ch_sf_packet_out);
return 0;
}
diff --git a/dap_chain_net_vpn_client.h b/dap_chain_net_vpn_client.h
index e31a0b9cef417bdb581b9e680e6a1b2bb2d48fe2..a75a307f737ace6e859c22fe88ee3bd58e9719b8 100644
--- a/dap_chain_net_vpn_client.h
+++ b/dap_chain_net_vpn_client.h
@@ -25,9 +25,11 @@
#pragma once
#include "dap_stream_ch.h"
+#include "dap_stream_ch_pkt.h"
#include "dap_chain_net.h"
+#include "dap_chain_net_srv_vpn.h"
-dap_stream_ch_t* dap_chain_net_vpn_client_get_stream(void);
+dap_stream_ch_t* dap_chain_net_vpn_client_get_stream_ch(void);
int dap_chain_net_vpn_client_start(dap_chain_net_t *a_net, const char *a_ipv4_str, const char *a_ipv6_str, int a_port);
int dap_chain_net_vpn_client_stop(void);
@@ -35,3 +37,7 @@ int dap_chain_net_vpn_client_status(void);
int dap_chain_net_vpn_client_init(dap_config_t * g_config);
void dap_chain_net_vpn_client_deinit();
+
+
+void dap_chain_net_vpn_client_pkt_out(dap_stream_ch_t* a_ch);
+void dap_chain_net_vpn_client_pkt_in(dap_stream_ch_t* a_ch, dap_stream_ch_pkt_t* a_pkt);
diff --git a/dap_chain_net_vpn_client_tun.c b/dap_chain_net_vpn_client_tun.c
index 68ad35486d3f76597720a88d93014a1bd0b78668..d77b8c35b50867dde707b4e95c1563a9a2a8bbe5 100644
--- a/dap_chain_net_vpn_client_tun.c
+++ b/dap_chain_net_vpn_client_tun.c
@@ -310,7 +310,7 @@ static void* thread_read_tun(void *arg)
// HASH_ADD_INT(CH_SF(ch)->socks, id, sf_sock );
// HASH_DEL(CH_SF(ch)->socks,sf_sock);
// if(l_stream) { // Is present in hash table such destination address
- dap_stream_ch_t *l_stream = dap_chain_net_vpn_client_get_stream();
+ dap_stream_ch_t *l_stream = dap_chain_net_vpn_client_get_stream_ch();
if(l_stream) {
// form packet to vpn-server
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1, sizeof(pkt_out->header) + read_ret);
@@ -321,7 +321,7 @@ static void* thread_read_tun(void *arg)
pthread_mutex_lock(&s_clients_mutex);
// sent packet to vpn server
- dap_stream_ch_pkt_write(l_stream, DATA_CHANNEL_ID, pkt_out,
+ dap_stream_ch_pkt_write(l_stream, DAP_STREAM_CH_PKT_TYPE_NET_SRV_VPN_DATA, pkt_out,
pkt_out->header.op_data.data_size + sizeof(pkt_out->header));
dap_stream_ch_set_ready_to_write(l_stream, true);
pthread_mutex_unlock(&s_clients_mutex);