Skip to content
Snippets Groups Projects
Commit 0eb5fff7 authored by Dmitriy A. Gerasimov's avatar Dmitriy A. Gerasimov
Browse files

[+] Init files

parent de2ef369
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 113 additions and 92 deletions
dap_stream_ch_vpn.c
+ 113
− 92
View file @ 0eb5fff7
......@@ -36,30 +36,30 @@
#include "stream_ch_proc.h"
#include "stream_ch_pkt.h"
#define LOG_TAG "ch_sf"
#define LOG_TAG "stream_ch_vpn"
#define STREAM_SF_PACKET_OP_CODE_CONNECTED 0x000000a9
#define STREAM_SF_PACKET_OP_CODE_CONNECT 0x000000aa
#define STREAM_SF_PACKET_OP_CODE_DISCONNECT 0x000000ab
#define STREAM_SF_PACKET_OP_CODE_SEND 0x000000ac
#define STREAM_SF_PACKET_OP_CODE_RECV 0x000000ad
#define STREAM_SF_PACKET_OP_CODE_PROBLEM 0x000000ae
#define VPN_PACKET_OP_CODE_CONNECTED 0x000000a9
#define VPN_PACKET_OP_CODE_CONNECT 0x000000aa
#define VPN_PACKET_OP_CODE_DISCONNECT 0x000000ab
#define VPN_PACKET_OP_CODE_SEND 0x000000ac
#define VPN_PACKET_OP_CODE_RECV 0x000000ad
#define VPN_PACKET_OP_CODE_PROBLEM 0x000000ae
#define STREAM_SF_PROBLEM_CODE_NO_FREE_ADDR 0x00000001
#define STREAM_SF_PROBLEM_CODE_TUNNEL_DOWN 0x00000002
#define STREAM_SF_PROBLEM_CODE_PACKET_LOST 0x00000003
#define VPN_PROBLEM_CODE_NO_FREE_ADDR 0x00000001
#define VPN_PROBLEM_CODE_TUNNEL_DOWN 0x00000002
#define VPN_PROBLEM_CODE_PACKET_LOST 0x00000003
#define STREAM_SF_PACKET_OP_CODE_RAW_L3 0x000000b0
#define STREAM_SF_PACKET_OP_CODE_RAW_L2 0x000000b1
#define STREAM_SF_PACKET_OP_CODE_RAW_L3_ADDR_REQUEST 0x000000b2
#define STREAM_SF_PACKET_OP_CODE_RAW_L3_ADDR_REPLY 0x000000b3
#define VPN_PACKET_OP_CODE_VPN_METADATA 0x000000b0
#define VPN_PACKET_OP_CODE_VPN_RESERVED 0x000000b1
#define VPN_PACKET_OP_CODE_VPN_ADDR_REQUEST 0x000000b2
#define VPN_PACKET_OP_CODE_VPN_ADDR_REPLY 0x000000b3
#define STREAM_SF_PACKET_OP_CODE_RAW_SEND 0x000000bc
#define STREAM_SF_PACKET_OP_CODE_RAW_RECV 0x000000bd
#define VPN_PACKET_OP_CODE_VPN_SEND 0x000000bc
#define VPN_PACKET_OP_CODE_VPN_RECV 0x000000bd
#define SF_MAX_EVENTS 256
typedef struct ch_sf_pkt{
typedef struct ch_vpn_pkt{
struct{
int sock_id; // Client's socket id
uint32_t op_code; // Operation code
......@@ -84,9 +84,16 @@ typedef struct ch_sf_pkt{
};
} __attribute__((packed)) header;
uint8_t data[]; // Binary data nested by packet
} __attribute__((packed)) ch_sf_pkt_t;
} __attribute__((packed)) ch_vpn_pkt_t;
typedef struct ch_sf_socket{
/**
* @struct ch_vpn_socket_proxy
* @brief Internal data storage for single socket proxy functions. Usualy helpfull for\
* port forwarding or for protecting single application's connection
*
**/
typedef struct ch_vpn_socket_proxy{
int id;
int sock;
struct in_addr client_addr; // Used in raw L3 connections
......@@ -94,7 +101,7 @@ typedef struct ch_sf_socket{
stream_ch_t * ch;
bool signal_to_delete;
ch_sf_pkt_t * pkt_out[100];
ch_vpn_pkt_t * pkt_out[100];
size_t pkt_out_size;
uint64_t bytes_sent;
......@@ -106,16 +113,23 @@ typedef struct ch_sf_socket{
UT_hash_handle hh;
UT_hash_handle hh2;
UT_hash_handle hh_sock;
} ch_sf_socket_t;
} ch_vpn_socket_proxy_t;
typedef struct ch_sf
/**
* @struct dap_stream_ch_vpn
* @brief Object that creates for every remote channel client
*
*
**/
typedef struct dap_stream_ch_vpn
{
pthread_mutex_t mutex;
ch_sf_socket_t * socks;
ch_vpn_socket_proxy_t * socks;
int raw_l3_sock;
} ch_sf_t;
typedef struct ch_sf_raw_client{ //
} dap_stream_ch_vpn_t;
typedef struct dap_stream_ch_vpn_remote_single{ //
in_addr_t addr;
// pthread_mutex_t mutex;
stream_ch_t * ch;
......@@ -124,9 +138,10 @@ typedef struct ch_sf_raw_client{ //
uint64_t bytes_recieved;
UT_hash_handle hh;
} ch_sf_raw_client_t;
} dap_stream_ch_vpn_remote_single_t;
typedef struct ch_sf_raw_server{
typedef struct vpn_local_network{
struct in_addr client_addr_last;
struct in_addr client_addr_mask;
struct in_addr client_addr_host;
......@@ -134,16 +149,16 @@ typedef struct ch_sf_raw_server{
int tun_ctl_fd;
int tun_fd;
struct ifreq ifr;
ch_sf_raw_client_t * clients; // Remote clients identified by destination address
dap_stream_ch_vpn_remote_single_t * clients; // Remote clients identified by destination address
ch_sf_pkt_t * pkt_out[400];
ch_vpn_pkt_t * pkt_out[400];
size_t pkt_out_size;
size_t pkt_out_rindex;
size_t pkt_out_windex;
pthread_mutex_t pkt_out_mutex;
pthread_mutex_t clients_mutex;
} ch_sf_raw_server_t;
} vpn_local_network_t;
typedef struct list_addr_element {
struct in_addr addr;
......@@ -151,15 +166,15 @@ typedef struct list_addr_element {
} list_addr_element;
list_addr_element *list_addr_head = NULL;
ch_sf_socket_t * sf_socks=NULL;
ch_sf_socket_t * sf_socks_client=NULL;
ch_vpn_socket_proxy_t * sf_socks=NULL;
ch_vpn_socket_proxy_t * sf_socks_client=NULL;
pthread_mutex_t sf_socks_mutex;
pthread_cond_t sf_socks_cond;
int sf_socks_epoll_fd;
pthread_t sf_socks_pid;
pthread_t sf_socks_raw_pid;
ch_sf_raw_server_t *raw_server;
vpn_local_network_t *raw_server;
#define CH_SF(a) ((ch_sf_t *) ((a)->internal) )
......@@ -175,27 +190,33 @@ void ch_sf_packet_out(stream_ch_t* ch , void* arg);
int ch_sf_raw_write(uint8_t op_code, const void * data, size_t data_size);
void stream_sf_disconnect(ch_sf_socket_t * sf_sock);
void stream_sf_disconnect(ch_vpn_socket_proxy_t * sf_sock);
static const char *l_vpn_addr, *l_vpn_mask;
/**
* @brief ch_sf_init
* @return
* @brief ch_sf_init Init actions for VPN stream channel
* @param vpn_addr Zero if only client mode. Address if the node shares its local VPN
* @param vpn_mask Zero if only client mode. Mask if the node shares its local VPN
* @return 0 if everything is okay, lesser then zero if errors
*/
int ch_sf_init(const char* vpn_addr, const char* vpn_mask)
{
l_vpn_addr = strdup(vpn_addr);
l_vpn_mask = strdup(vpn_mask);
raw_server=calloc(1,sizeof(ch_sf_raw_server_t));
pthread_mutex_init(&raw_server->clients_mutex,NULL);
pthread_mutex_init(&raw_server->pkt_out_mutex,NULL);
pthread_mutex_init(&sf_socks_mutex,NULL);
pthread_cond_init(&sf_socks_cond,NULL);
pthread_create(&sf_socks_raw_pid,NULL,ch_sf_thread_raw,NULL);
pthread_create(&sf_socks_pid,NULL,ch_sf_thread,NULL);
stream_ch_proc_add('s',ch_sf_new,ch_sf_delete,ch_sf_packet_in,ch_sf_packet_out);
if (vpn_addr && vpn_mask) {
l_vpn_addr = strdup(vpn_addr);
l_vpn_mask = strdup(vpn_mask);
raw_server=calloc(1,sizeof(vpn_local_network_t));
pthread_mutex_init(&raw_server->clients_mutex,NULL);
pthread_mutex_init(&raw_server->pkt_out_mutex,NULL);
pthread_mutex_init(&sf_socks_mutex,NULL);
pthread_cond_init(&sf_socks_cond,NULL);
pthread_create(&sf_socks_raw_pid,NULL,ch_sf_thread_raw,NULL);
pthread_create(&sf_socks_pid,NULL,ch_sf_thread,NULL);
stream_ch_proc_add('s',ch_sf_new,ch_sf_delete,ch_sf_packet_in,ch_sf_packet_out);
return 0;
}
return 0;
}
......@@ -256,8 +277,8 @@ void ch_sf_tun_destroy()
*/
void ch_sf_new(stream_ch_t* ch , void* arg)
{
ch->internal=calloc(1,sizeof(ch_sf_t));
ch_sf_t * sf = CH_SF(ch);
ch->internal=calloc(1,sizeof(dap_stream_ch_vpn_t));
dap_stream_ch_vpn_t * sf = CH_SF(ch);
pthread_mutex_init(& sf->mutex,NULL);
sf->raw_l3_sock = socket (PF_INET, SOCK_RAW, IPPROTO_RAW);
}
......@@ -270,8 +291,8 @@ void ch_sf_new(stream_ch_t* ch , void* arg)
void ch_sf_delete(stream_ch_t* ch , void* arg)
{
log_it(L_DEBUG,"ch_sf_delete() for %s", ch->stream->conn->hostaddr);
ch_sf_socket_t * cur, *tmp;
ch_sf_raw_client_t * raw_client=0;
ch_vpn_socket_proxy_t * cur, *tmp;
dap_stream_ch_vpn_remote_single_t * raw_client=0;
// in_addr_t raw_client_addr = CH_SF(ch)->tun_client_addr.s_addr;
in_addr_t raw_client_addr = ch->stream->session->tun_client_addr.s_addr;
......@@ -310,7 +331,7 @@ void ch_sf_delete(stream_ch_t* ch , void* arg)
}
void stream_sf_socket_delete(ch_sf_socket_t * sf)
void stream_sf_socket_delete(ch_vpn_socket_proxy_t * sf)
{
close(sf->sock);
pthread_mutex_destroy(& (sf->mutex) );
......@@ -330,9 +351,9 @@ void stream_sf_socket_ready_to_write(stream_ch_t * ch, bool is_ready)
}
ch_sf_pkt_t* ch_sf_raw_read()
ch_vpn_pkt_t* ch_sf_raw_read()
{
ch_sf_pkt_t*ret=NULL;
ch_vpn_pkt_t*ret=NULL;
pthread_mutex_lock(&raw_server->pkt_out_mutex);
if(raw_server->pkt_out_rindex== ( sizeof(raw_server->pkt_out)/sizeof(raw_server->pkt_out[0]) ) ){
raw_server->pkt_out_rindex=0; // ring the buffer!
......@@ -353,7 +374,7 @@ int ch_sf_raw_write(uint8_t op_code,const void * data, size_t data_size)
if(raw_server->pkt_out_windex== ( sizeof(raw_server->pkt_out)/sizeof(raw_server->pkt_out[0]) ) )
raw_server->pkt_out_windex=0; // ring the buffer!
if( (raw_server->pkt_out_windex<raw_server->pkt_out_rindex)|| (raw_server->pkt_out_size==0) ){
ch_sf_pkt_t * pkt =(ch_sf_pkt_t *) calloc(1,data_size+sizeof(pkt->header));
ch_vpn_pkt_t * pkt =(ch_vpn_pkt_t *) calloc(1,data_size+sizeof(pkt->header));
pkt->header.op_code=op_code;
pkt->header.sock_id=raw_server->tun_fd;
if(data_size>0){
......@@ -375,15 +396,15 @@ int ch_sf_raw_write(uint8_t op_code,const void * data, size_t data_size)
}
int stream_sf_socket_write(ch_sf_socket_t * sf, uint8_t op_code, const void * data, size_t data_size)
int stream_sf_socket_write(ch_vpn_socket_proxy_t * sf, uint8_t op_code, const void * data, size_t data_size)
{
if(sf->pkt_out_size< ( sizeof(sf->pkt_out)/sizeof(sf->pkt_out[0]) ) ) {
ch_sf_pkt_t * pkt =(ch_sf_pkt_t *) calloc(1,data_size+sizeof(pkt->header));
ch_vpn_pkt_t * pkt =(ch_vpn_pkt_t *) calloc(1,data_size+sizeof(pkt->header));
pkt->header.op_code=op_code;
pkt->header.sock_id=sf->id;
switch(op_code){
case STREAM_SF_PACKET_OP_CODE_RECV:{
case VPN_PACKET_OP_CODE_RECV:{
pkt->header.op_data.data_size=data_size;
memcpy(pkt->data,data,data_size);
}break;
......@@ -414,14 +435,14 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
// );
static bool client_connected = false;
ch_sf_pkt_t * sf_pkt =(ch_sf_pkt_t *) pkt->data;
ch_vpn_pkt_t * sf_pkt =(ch_vpn_pkt_t *) pkt->data;
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 STREAM_SF_PACKET_OP_CODE_RAW_L3_ADDR_REQUEST:{ // Client request after L3 connection the new IP address
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};
......@@ -433,7 +454,7 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
list_addr_element *el;
LL_COUNT(list_addr_head, el, count_free_addr);
ch_sf_raw_client_t * n_client = (ch_sf_raw_client_t*) calloc(1,sizeof(ch_sf_raw_client_t));
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)
......@@ -460,9 +481,9 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
log_it(L_INFO,"\taddr %s", inet_ntoa(raw_server->client_addr));
log_it(L_INFO,"\tlast_addr %s", inet_ntoa(raw_server->client_addr_last));
ch_sf_pkt_t *pkt_out = (ch_sf_pkt_t*) calloc(1,sizeof(pkt_out->header)+sizeof(n_addr)+sizeof(raw_server->client_addr_host));
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1,sizeof(pkt_out->header)+sizeof(n_addr)+sizeof(raw_server->client_addr_host));
pkt_out->header.sock_id=raw_server->tun_fd;
pkt_out->header.op_code=STREAM_SF_PACKET_OP_CODE_RAW_L3_ADDR_REPLY;
pkt_out->header.op_code=VPN_PACKET_OP_CODE_VPN_ADDR_REPLY;
pkt_out->header.op_data.data_size=sizeof(n_addr)+sizeof(raw_server->client_addr_host);
memcpy(pkt_out->data,&n_addr,sizeof(n_addr));
memcpy(pkt_out->data+sizeof(n_addr),&raw_server->client_addr_host,sizeof(raw_server->client_addr_host));
......@@ -472,15 +493,15 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
//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_sf_pkt_t *pkt_out = (ch_sf_pkt_t*) calloc(1,sizeof(pkt_out->header));
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1,sizeof(pkt_out->header));
pkt_out->header.sock_id=raw_server->tun_fd;
pkt_out->header.op_code=STREAM_SF_PACKET_OP_CODE_PROBLEM;
pkt_out->header.op_problem.code=STREAM_SF_PROBLEM_CODE_NO_FREE_ADDR;
pkt_out->header.op_code=VPN_PACKET_OP_CODE_PROBLEM;
pkt_out->header.op_problem.code=VPN_PROBLEM_CODE_NO_FREE_ADDR;
stream_ch_pkt_write(ch,'d',pkt_out,pkt_out->header.op_data.data_size+sizeof(pkt_out->header));
stream_sf_socket_ready_to_write(ch,true);
}
}break;
case STREAM_SF_PACKET_OP_CODE_RAW_SEND:{
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;
......@@ -499,9 +520,9 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
if((ret = write(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_sf_pkt_t *pkt_out = (ch_sf_pkt_t*) calloc(1,sizeof(pkt_out->header));
pkt_out->header.op_code=STREAM_SF_PACKET_OP_CODE_PROBLEM;
pkt_out->header.op_problem.code=STREAM_SF_PROBLEM_CODE_PACKET_LOST;
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=raw_server->tun_fd;
stream_ch_pkt_write(ch,'d',pkt_out,pkt_out->header.op_data.data_size+sizeof(pkt_out->header));
stream_sf_socket_ready_to_write(ch,true);
......@@ -515,8 +536,8 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
default: log_it(L_WARNING,"Can't process SF type 0x%02x", sf_pkt->header.op_code);
}
}else{ // All except CONNECT
ch_sf_socket_t * sf_sock=NULL;
if(sf_pkt->header.op_code != STREAM_SF_PACKET_OP_CODE_CONNECT ){
ch_vpn_socket_proxy_t * sf_sock=NULL;
if(sf_pkt->header.op_code != VPN_PACKET_OP_CODE_CONNECT ){
pthread_mutex_lock(& ( CH_SF(ch)->mutex ));
// log_it(L_DEBUG,"Looking in hash table with %d",remote_sock_id);
HASH_FIND_INT( (CH_SF(ch)->socks) ,&remote_sock_id,sf_sock );
......@@ -525,7 +546,7 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
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 STREAM_SF_PACKET_OP_CODE_SEND:{
case VPN_PACKET_OP_CODE_SEND:{
if(client_connected == false)
{
log_it(L_WARNING, "Drop Packet! User not connected!"); // Client need send
......@@ -564,7 +585,7 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
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 STREAM_SF_PACKET_OP_CODE_DISCONNECT:{
case VPN_PACKET_OP_CODE_DISCONNECT:{
log_it(L_INFO, "Disconnect action from %d sock_id",sf_sock->id);
pthread_mutex_lock(& ( CH_SF(ch)->mutex ));
......@@ -623,8 +644,8 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
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_sf_socket_t * sf_sock=NULL;
sf_sock=DAP_NEW_Z(ch_sf_socket_t);
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;
......@@ -651,9 +672,9 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
}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_sf_pkt_t *pkt_out = (ch_sf_pkt_t*) calloc(1,sizeof(pkt_out->header));
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 = STREAM_SF_PACKET_OP_CODE_CONNECTED;
pkt_out->header.op_code = VPN_PACKET_OP_CODE_CONNECTED;
stream_ch_pkt_write(ch,'s',pkt_out,pkt_out->header.op_data.data_size+sizeof(pkt_out->header));
free(pkt_out);
client_connected = true;
......@@ -677,7 +698,7 @@ void ch_sf_packet_in(stream_ch_t* ch , void* arg)
* @brief stream_sf_disconnect
* @param sf
*/
void stream_sf_disconnect(ch_sf_socket_t * sf_sock)
void stream_sf_disconnect(ch_vpn_socket_proxy_t * sf_sock)
{
struct epoll_event ev;
ev.data.fd=sf_sock->sock;
......@@ -691,9 +712,9 @@ void stream_sf_disconnect(ch_sf_socket_t * sf_sock)
}
// Compise signal to disconnect to another side, with special opcode STREAM_SF_PACKET_OP_CODE_DISCONNECT
ch_sf_pkt_t * pkt_out;
pkt_out = (ch_sf_pkt_t*) calloc(1,sizeof(pkt_out->header)+1);
pkt_out->header.op_code=STREAM_SF_PACKET_OP_CODE_DISCONNECT;
ch_vpn_pkt_t * pkt_out;
pkt_out = (ch_vpn_pkt_t*) calloc(1,sizeof(pkt_out->header)+1);
pkt_out->header.op_code=VPN_PACKET_OP_CODE_DISCONNECT;
pkt_out->header.sock_id=sf_sock->id;
sf_sock->pkt_out[sf_sock->pkt_out_size]=pkt_out;
sf_sock->pkt_out_size++;
......@@ -734,7 +755,7 @@ void * ch_sf_thread(void * arg)
for (n = 0; n < nfds; ++n) {
int s=events[n].data.fd;
ch_sf_socket_t * sf=NULL;
ch_vpn_socket_proxy_t * sf=NULL;
pthread_mutex_lock(&sf_socks_mutex);
HASH_FIND(hh_sock, sf_socks_client ,&s, sizeof(s), sf);
pthread_mutex_unlock(&sf_socks_mutex);
......@@ -754,9 +775,9 @@ void * ch_sf_thread(void * arg)
//log_it(L_DEBUG,"recv() returned %d",ret);
if(ret>0){
buf_size=ret;
ch_sf_pkt_t * pout;
pout=sf->pkt_out[sf->pkt_out_size]=(ch_sf_pkt_t *) calloc(1,buf_size+sizeof(pout->header));
pout->header.op_code=STREAM_SF_PACKET_OP_CODE_RECV;
ch_vpn_pkt_t * pout;
pout=sf->pkt_out[sf->pkt_out_size]=(ch_vpn_pkt_t *) calloc(1,buf_size+sizeof(pout->header));
pout->header.op_code=VPN_PACKET_OP_CODE_RECV;
pout->header.sock_id=sf->id;
pout->header.op_data.data_size=buf_size;
memcpy(pout->data,buf,buf_size);
......@@ -829,7 +850,7 @@ void* ch_sf_thread_raw(void *arg)
//
if(ret > 0){
if (FD_ISSET (get_select_breaker(), &fds_read_active)){ // Smth to send
ch_sf_pkt_t* pkt = ch_sf_raw_read();
ch_vpn_pkt_t* pkt = ch_sf_raw_read();
if(pkt){
int write_ret=write(raw_server->tun_fd,pkt->data,pkt->header.op_data.data_size);
if(write_ret>0){
......@@ -863,14 +884,14 @@ void* ch_sf_thread_raw(void *arg)
//log_it(L_DEBUG,"Read IP packet from tun/tap interface daddr=%s saddr=%s total_size = %d "
// ,str_daddr,str_saddr,read_ret);
ch_sf_raw_client_t * raw_client=NULL;
dap_stream_ch_vpn_remote_single_t * raw_client=NULL;
pthread_mutex_lock(& raw_server->clients_mutex );
HASH_FIND_INT( raw_server->clients,&in_daddr.s_addr,raw_client );
// HASH_ADD_INT(CH_SF(ch)->socks, id, sf_sock );
// HASH_DEL(CH_SF(ch)->socks,sf_sock);
if( raw_client){ // Is present in hash table such destination address
ch_sf_pkt_t *pkt_out = (ch_sf_pkt_t*) calloc(1,sizeof(pkt_out->header)+read_ret);
pkt_out->header.op_code=STREAM_SF_PACKET_OP_CODE_RAW_RECV;
ch_vpn_pkt_t *pkt_out = (ch_vpn_pkt_t*) calloc(1,sizeof(pkt_out->header)+read_ret);
pkt_out->header.op_code=VPN_PACKET_OP_CODE_VPN_RECV;
pkt_out->header.sock_id=raw_server->tun_fd;
pkt_out->header.op_data.data_size=read_ret;
memcpy(pkt_out->data,tmp_buf,read_ret);
......@@ -905,7 +926,7 @@ void* ch_sf_thread_raw(void *arg)
*/
void ch_sf_packet_out(stream_ch_t* ch , void* arg)
{
ch_sf_socket_t * cur, *tmp;
ch_vpn_socket_proxy_t * cur, *tmp;
bool isSmthOut=false;
// log_it(L_DEBUG,"Socket forwarding packet out callback: %u sockets in hashtable", HASH_COUNT(CH_SF(ch)->socks) );
HASH_ITER(hh, CH_SF(ch)->socks , cur, tmp) {
......@@ -915,7 +936,7 @@ void ch_sf_packet_out(stream_ch_t* ch , void* arg)
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_sf_pkt_t * pout =cur->pkt_out[i];
ch_vpn_pkt_t * pout =cur->pkt_out[i];
if(pout) {
if(stream_ch_pkt_write(ch,'d',pout,pout->header.op_data.data_size+sizeof(pout->header))){
isSmthOut=true;
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment