proxy_socket.c

NAT打洞

#include <stdlib.h>
#include <stdio.h>
#include "common.h"
#include "proxy_socket.h"
#include "protocol.h"
#include "error_handler.h"
#include "vect.h"

#if defined(WIN32) || defined(__WIN32__)
	#include <process.h>
#endif

char *username = NULL;

#include "authenticating.h"


#define TEST_BUFFER_SIZE_TIMEOUT 1
#define MAX_DATAGRAM_SIZE 32707
#define TEST_DATAGRAM_SIZE 1024

typedef struct proxy_sock {
	unsigned real_socket;
	unsigned proxy_socket;
	unsigned short proxy_port;
  	int type;
  	int protocol;
  	int bound;
} PROXY_SOCKET;

unsigned proxy_ping_period = 10;
FILE *debug = NULL;

unsigned proxy_socket_functions = 1;

void set_proxy_socket_functions(unsigned proxy_socket_func){
	proxy_socket_functions  = proxy_socket_func;
}

unsigned get_proxy_socket_functions(void){
	return proxy_socket_functions;
}

#ifdef PROXY_SOCKET_FUNCTIONS

//unsigned short listen_port;
void __cdecl ping_proxy(void*, unsigned, unsigned, void*);
SOCKET connectToServer(void);
#define INITIAL_POOL_CAPACITY 1

VECTOR *pool = NULL;

char *proxy_address = NULL;
unsigned short proxy_port;
int behind_firewall = 0;
struct sockaddr_in server_address;

struct sockaddr_in proxy_sa;
unsigned proxy_over_tcp = 0;

SOCKET proxy = -1;
int started = 0;

#if !defined(WIN32) && !defined(__WIN32__)
void *proxy_pinger(LPVOID data){
	struct timeval timeout;
	fd_set rset, eset;
  	int maxs;
	char buff[BUFFER_SIZE];
  	int nsize;

  	while(1){
    	sleep(proxy_ping_period);
    	vector_walk(pool, &ping_proxy, NULL);
  	}
  	return 0;
}
#endif //!defined(WIN32) && !defined(__WIN32__)

#if defined(WIN32) || defined(__WIN32__)
unsigned __stdcall proxy_pinger(LPVOID data){
	struct timeval timeout;
	fd_set rset, eset;
  	int maxs;
	char buff[BUFFER_SIZE];
  	int nsize;

  	while(1){
    	sleep(proxy_ping_period);
    	vector_walk(pool, &ping_proxy, NULL);
  	}
  	return 0;
}
#endif //#if defined(WIN32) || defined(__WIN32__)

int __cdecl compare_proxy_socket(const void *_pd1, const void *_pd2){
	PROXY_SOCKET *pd1 = (PROXY_SOCKET*)_pd1;
	PROXY_SOCKET *pd2 = (PROXY_SOCKET*)_pd2;
  	return (pd1->real_socket < pd2->real_socket ? -1 :
  	(pd1->real_socket > pd2->real_socket ? 1 : 0)
  );
}

void __cdecl proxy_stop(void){
  	delete_vector(pool);
}

int proxy_start(void){
	if(debug == NULL){
    	debug = stdout;
  	}
	atexit(&proxy_stop);
  	pool = create_vector(INITIAL_POOL_CAPACITY, sizeof(PROXY_SOCKET), &compare_proxy_socket);
	started  = 1;
  	return 0;
}

PROXY_SOCKET find_socket(int sockfd){
  	PROXY_SOCKET ps, bf;
  	ps.real_socket = sockfd;
	if(vector_bsearch(pool, &ps, &bf, NULL, NULL, NULL, 0) == 0){
  		return bf;
  	}
  	bf.real_socket = -1;
  	return bf;
}

int __cdecl set_socket_fields(void* _old, void* _new){
	PROXY_SOCKET *o = (PROXY_SOCKET *)_old;
	PROXY_SOCKET *n = (PROXY_SOCKET *)_new;
  	o->proxy_socket = n->proxy_socket;
  	o->proxy_port = n->proxy_port;
  	o->real_socket = n->real_socket;
  	o->bound = n->bound;
  	return 0;
}

int connect_to_proxy(void){
  	int nsize;
  	char buff[BUFFER_SIZE];
	if(!behind_firewall){
		return 0;
  	}
  	if((proxy_port == 0) || (proxy_address == NULL)){
  		return 1;
  	}
  	if(proxy == -1){
  		proxy = socket(AF_INET, SOCK_STREAM, 0);
    	if (
        	SOCKET_IS_INVALID(
        		proxy
        	)
	    ){
      		handle_error(__FILE__, __LINE__);
	    	proxy = -1;
      		return 1;
    	}
  	}
  	sprintf(buff, "%s:\n", proxyPing);
  	if(
    	!HAS_SOCKET_ERROR(
    		(nsize = send(proxy, &buff[0], strlen(buff), 0))
    	)
  	){
//fprintf(debug, "[%s,%d]\n", __FILE__, __LINE__);fflush(debug);

    	if(
	    	HAS_SOCKET_ERROR(
    		    (nsize=recv(proxy,&buff[0],
                      BUFFER_SIZE-1,0))
    		)
    	){
//fprintf(debug, "[%s,%d]\n", __FILE__, __LINE__);fflush(debug);
      		handle_error(__FILE__, __LINE__);
      		closesocket(proxy);
	    	proxy = -1;
      		return 1;
    	}
    	return 0;
  	}

  	proxy_sa.sin_family=AF_INET;
  	proxy_sa.sin_port=htons(proxy_port);

  	proxy_sa.sin_addr.s_addr=inet_addr(proxy_address);

  	if (connect(proxy,(struct sockaddr *)&proxy_sa,
              sizeof(proxy_sa))){
	    handle_error(__FILE__, __LINE__);
    	closesocket(proxy);
    	proxy = -1;
    	return 1;
  	}

  	if(
    	HAS_SOCKET_ERROR(
		    (nsize=recv(proxy,&buff[0],
                    BUFFER_SIZE-1,0))
    	)
  	){
    	handle_error(__FILE__, __LINE__);
    	closesocket(proxy);
    	proxy = -1;
    	return 1;
  	}
  	// 耱噔桁 玎忮瘌帼