4. Proxy Switch

Proxy Switch

  • ?

    hi,

    aehm ich hab mal ne Frage. Ich bin dabei einen Proxy Switch zu entwickeln. Das Printip funktioniert auch schon ganz gut (bin auch Grad mit Hilfe meines Programmes im Netz). Mein Problem dabei besteht in nur kleinen aber nervigen Dingen. Vielleicht könnt Ihr Euch mal meinen Code anschauen und mir helfen?

    Die Probleme bestehen darin, daß wenn ich eine Seite geladen hab am Ende oft, aber nicht immer die Fehlermeldung "Document contains no data" kommt. Fehler in der Funktionsweise der Seiten hab ich aber bisher noch nicht wirklich feststellen können. 😕 Ich benutze Mozilla 1.6

    Weiterhin kann ich mich zwar auf der GMX-Webseite zwar einloggen, doch dann wird der Seiteninhalt verschoben dargestellt und ich kann mich nicht wieder ausloggen. Da kommt ebenfalls die Meldung "Document contains no data". Das kann irgendwie nur an meinen Programm liegen, da bei einer direkten Verbindung ins Netz diese Fehler nicht auftreten. 😕

    BIG THX for help

    #include <winsock.h>
#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <iostream.h>
#define PORT 8888
#define HOST localhost

#pragma comment(lib,"ws2_32.lib") // Um Betriebssystemfunktionen ausführen zu können
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct inetproxy
	{	struct sockaddr_in proxy;
		bool user_proxy;
		bool proxy_server;
		HANDLE connection_ok;//Zur Synchronisation so irgendwie
		SOCKET browser_proxy_sock;
		SOCKET inet_socket;
		bool datalog;
		bool _handle;
		};

DWORD WINAPI server_to_proxy_to_browser(LPVOID lpParam);
DWORD WINAPI browser_to_proxy_to_server(LPVOID lpParam);

SOCKET descriptor;
FILE *Datei;		// DATENFLUSS-Log-Datei
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI browser_to_proxy_to_server(LPVOID lpParam)
{

		inetproxy *helper = new inetproxy;
		// lokale Variablen
		int sin_size;
		SOCKET new_sock=0;
		SOCKET sockel_descriptor=descriptor;
		sin_size=sizeof(struct sockaddr_in);
		struct sockaddr_in test1;

		DWORD dwThreadId;

		//SOCKET accepten
		new_sock=accept(sockel_descriptor,(struct sockaddr*)&test1,&sin_size );

		// Initialisierungen
		helper->user_proxy=TRUE;
		helper->proxy_server=FALSE;
		helper->_handle = FALSE;

		//für Senden an Browser
		helper->browser_proxy_sock=new_sock;

		//neuen Thread zum weiteren listen
		CreateThread(NULL,0,browser_to_proxy_to_server,&sockel_descriptor,0,&dwThreadId);

		//accept()-ERROR Checking
		if (new_sock	==-1) {	printf("Fehler: Accept fehlgeschlagen: %d\n",WSAGetLastError());
		}
		else
			{
				// Daten vom lokalen Socket empfangen
				char buffer[600];
				int	recive_value;
				int send_value;

				// 1. Anfrage von Browser
				recive_value=recv(new_sock,buffer,sizeof(buffer),0); 

				// DATENFLUSS-Log-Datei
				//	Datei = fopen("data.txt","r+");
				//	fseek(Datei,0,SEEK_END);
				//	fprintf(Datei,"\n\n BROWSER ANFRAGE AN PROXY START (UsertoProxytoServer) \n\n",0);
				//	fwrite(buffer,sizeof(char),recive_value+2,Datei);	
				//	fprintf(Datei,"\n\n BROWSER ANFRAGE AN PROXY ENDE (UsertoProxytoServer) \n\n",0);
				//	fclose(Datei);}

				//ERROR Checking
				if (recive_value== SOCKET_ERROR) {	printf("Fehler: Empfangsfehler der Browser-Anfrage: %d \n",WSAGetLastError());
													closesocket(helper->browser_proxy_sock);
													helper->user_proxy=FALSE;}

				if (recive_value == 0) {	printf("Fehler: Verbindung zu Browser unterbrochen: %d \n",WSAGetLastError());
											closesocket(helper->browser_proxy_sock);
											helper->user_proxy=FALSE;}

//# ifdef _DEBUG
//				printf("\n %d bytes Daten von Browser empfangen:\n [%s]\n",recive_value,buffer);
//# endif				

		DWORD dwThread1Id; 
		HANDLE hThread1;

		hThread1 = CreateThread(NULL,0,server_to_proxy_to_browser,helper,0,&dwThread1Id);

			if (hThread1 == NULL)
			{
				printf("Thread-Erstellung Fehlgeschlagen!");
			}

		helper->connection_ok=CreateEvent(NULL,TRUE,FALSE,NULL);

		//Warten auf die Verbindung zum Proxy-Server (60 sec)
		if(WaitForSingleObject(helper->connection_ok,60000)==WAIT_OBJECT_0)
			{	helper->_handle=TRUE;}

		if (helper->_handle==TRUE)
			{	CloseHandle(helper->connection_ok);
				helper->_handle=FALSE;} //Access Violation ntnet.dll

		while(helper->user_proxy && helper->proxy_server)
			{	

				// Senden zu Proxy-Server über SOCKET inet_socket (aufgebaut in server_to_proxy_to_user)
				send_value=send(helper->inet_socket,buffer,recive_value,0);		

				// DATENFLUSS-Log-Datei
				//	Datei = fopen("data.txt","r+");
				//	fseek(Datei,0,SEEK_END);
				//	fprintf(Datei,"\n\n BROWSER ANFRAGE AN SERVER GESENDET START (UsertoProxytoServer / in while-Schleife) \n\n",0);
				//	fwrite(buffer,sizeof(char),send_value+2,Datei);
				//	fprintf(Datei,"\n\n BROWSER ANFRAGE AN SERVER GESENDET ENDE (UsertoProxytoServer / in while-Schleife) \n\n",0);
				//	fclose(Datei);}

				// send()-Funktion ERROR-Checking
				if (send_value == SOCKET_ERROR) {	printf("Senden der www-Anfrage fehlgeschlagen: %d \n",WSAGetLastError());
													helper->proxy_server=FALSE;
													closesocket(helper->inet_socket);
													continue;}

				//Empfangen weiterer Browser-Anfragen
				recive_value = recv(helper->browser_proxy_sock,buffer,sizeof(buffer),0);

				// DATENFLUSS-Log-Datei
				//	Datei = fopen("data.txt","r+");
				//	fseek(Datei,0,SEEK_END);
				//	fprintf(Datei,"\n\n BROWSER ANFRAGE AN PROXY START (UsertoProxytoServer / in while-Schleife) \n\n",0);
				//	fwrite(buffer,sizeof(char),recive_value+2,Datei);
				//	fprintf(Datei,"\n\n BROWSER ANFRAGE AN PROXY ENDE (UsertoProxytoServer / in while-Schleife) \n\n",0);
				//	fclose(Datei);}

				// recv()-Funktion ERROR-Checking
				if (recive_value== SOCKET_ERROR) {	printf("Fehler: Empfangsfehler der Browser-Anfrage: %d \n",WSAGetLastError());
													closesocket(helper->browser_proxy_sock);
													helper->user_proxy=FALSE;
													continue;}

				if (recive_value == 0) {	printf("Fehler: Verbindung zu Browser unterbrochen: %d \n",WSAGetLastError());
											closesocket(helper->browser_proxy_sock);
											helper->user_proxy=FALSE;
											break;}

//# ifdef _DEBUG
//				printf("\n %d bytes Daten von Browser empfangen:\n [%s]\n",recive_value,buffer);
//# endif				

			}  // END WHILE

		// Aufräumen
		if (helper->proxy_server==TRUE) {	helper->proxy_server=FALSE;
											closesocket(helper->inet_socket);}

		if (helper->user_proxy==TRUE)	{	helper->user_proxy=FALSE;
											closesocket(helper->browser_proxy_sock);}

		}
	return 0;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DWORD WINAPI server_to_proxy_to_browser(LPVOID lpParam)
{

	inetproxy *helper = (inetproxy*) lpParam;

	// USER INTERFACE
	int inetport=8080;
	const char *inetproxy_addr="82.185.182.115";

	helper->proxy.sin_family=AF_INET;
	helper->proxy.sin_addr.S_un.S_addr=inet_addr(inetproxy_addr);
	helper->proxy.sin_port=htons(inetport);
	memcpy(&(helper->proxy.sin_zero),"\0",8);

	// !!!!!!!!!USER INETRFACE!!!!!!!!!!!!!
	/*CHECK
	printf("S_Addresse %d ",helper->proxy.sin_addr.S_un.S_addr);
	printf("Sin_Family %d ",helper->proxy.sin_family);
	printf("Sin_Port   %d ",helper->proxy.sin_port);
	printf("Sin_zero   %d ",helper->proxy.sin_zero);
	*/
	struct sockaddr_in server;
	int recive_value,send_value;
	char buffer[10000];

	server.sin_addr.S_un.S_addr = helper->proxy.sin_addr.S_un.S_addr;
	server.sin_family = helper->proxy.sin_family;
	server.sin_port = helper->proxy.sin_port;
	memcpy(&(server.sin_zero),helper->proxy.sin_zero,8);

	helper->proxy_server=TRUE;			// Verbindung erfolgreich

	//SOCKET aufbauen + ERROR Checking
	helper->inet_socket=socket(helper->proxy.sin_family,SOCK_STREAM,0);	
	if (helper->inet_socket==INVALID_SOCKET)	{	printf("Fehler: SOCKET-Aufbau zu Inet-Proxy fehlgeschlagen: %d \n",WSAGetLastError());
													helper->proxy_server=FALSE;			// Verbindung nicht erfolgreich
													SetEvent(helper->connection_ok);}	// Startsignal setzen
	// SOCKET connect + ERROR Checking
	if (connect(helper->inet_socket,(struct sockaddr *)&server,sizeof(struct sockaddr)) !=0)
		{	printf("Fehler: SOCKET-Connect fehlgeschlagen: %d \n",WSAGetLastError());
			helper->proxy_server=FALSE;			// Verbindung nicht erfolgreich
			SetEvent(helper->connection_ok);}	// Startsignal setzen

	SetEvent(helper->connection_ok);	// Startsignal setzen

 	while(helper->user_proxy&&helper->proxy_server)
	{
		// Daten von Server empfangen
		recive_value = recv(helper->inet_socket,buffer,sizeof(buffer),0);

		// DATENFLUSS-Log-Datei
		//	Datei = fopen("data.txt","r+");
		//	fseek(Datei,0,SEEK_END);
		//	fprintf(Datei,"\n\n SERVER ANWORT AN PROXY START (ServertoProxytoUser) \n\n",0);
		//	fwrite(buffer,sizeof(char),recive_value+2,Datei);
		//	fprintf(Datei,"\n\n SERVER ANWORT AN PROXY ENDE (ServertoProxytoUser) \n\n",0);
		//	fclose(Datei);

		// recv()-Funktion ERROR Checking
		if (recive_value==SOCKET_ERROR)	{	printf("Fehler: Empfangen der Daten von Server fehlgeschlagen: %d \n",WSAGetLastError());
											closesocket(helper->inet_socket);
											helper->proxy_server=FALSE;
											break;}

		if (recive_value==0)			{	printf("Server hat Verbindung geschlossen: %d \n",WSAGetLastError());
											closesocket(helper->inet_socket);
											helper->proxy_server=FALSE;
											break;}

		// Senden der vom Server empfangenen Daten an Browser

		send_value = send(helper->browser_proxy_sock,buffer,recive_value,0);

		// DATENFLUSS-Log-Datei
		//	Datei = fopen("data.txt","r+");
		//	fseek(Datei,0,SEEK_END);
		//	fprintf(Datei,"\n\n SERVER ANTWORT AN BROWSER gesendet START (ServertoProxytoUser) \n\n",0);
		//	fwrite(buffer,sizeof(char),send_value+2,Datei);
		//	fprintf(Datei,"\n\n SERVER ANTWORT AN BROWSER gesendet ENDE (ServertoProxytoUser) \n\n",0);
		//	fclose(Datei);}

		// ERROR Checking
		if (send_value == SOCKET_ERROR) {	printf("Fehler: SOCKET_ERROR Senden an Browser fehlgeschlagen: %d \n",WSAGetLastError());
											closesocket(helper->browser_proxy_sock);
											helper->user_proxy=FALSE;
											break;}

# ifdef _DEBUG
				printf("\n %d bytes Daten von Server empfangen:\n [%s]\n",recive_value,buffer);
# endif				

	}	// END WHILE

	// Aufräumen
	if (helper->proxy_server==TRUE) {	helper->proxy_server=FALSE;
										closesocket(helper->inet_socket);}

	if (helper->user_proxy==TRUE)	{	helper->user_proxy=FALSE;
										closesocket(helper->browser_proxy_sock);}	
	return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int startserver()
{
		/*	Start:
			Verbindung zwischen Browser und Proxy-Switch herstellen
			dazu:

				1. SOCKET aufbauen
				2. Struktur sockaddr_in beschreiben
					- Adresse egal
					- Port 8888 ->(muss als Port bei Proxyeinstellungen im Browser verwendet werden
				3. SOCKET binden -> bind()
				4. SOCKET abhören (nach ankommenden Daten / Browser-Anfragen)-> listen()
		*/
		// lokale Variablen definieren
		struct sockaddr_in local; //Structur mit Socketadresse und Portangaben 
		SOCKET socket_descriptor=0;	

		// WINDOWS-SOCKET-FUNCTIONS initialisieren + ERROR Checking
		WSADATA wsaData;
        if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) 
			{	fprintf(stderr, "WSAStartup failed.\n");
				exit(1);} 

	  	// Struktur beschreiben
		local.sin_family=AF_INET;
		local.sin_addr.S_un.S_addr=INADDR_ANY; //Adresse egal da nur Port abgehört werden muss um Anfragen des Browsers zu holen
		local.sin_port=htons(PORT);
		memcpy(&(local.sin_zero),"\0",8);

		// SOCKET aufbauen
		socket_descriptor = socket (AF_INET,SOCK_STREAM,0);

		// ERROR Checking!!
		if (socket_descriptor ==INVALID_SOCKET) 
				{	printf("Fehler: SOCKET-Aufbau fehlgeschlagen: %d \n ",WSAGetLastError());
					WSACleanup();
				}

		// SOCKET binden + ERROR Checking
		if (bind(socket_descriptor,(struct sockaddr *)&local,sizeof(struct sockaddr))!=0)
				{	printf("Fehler: SOCKET-Binding fehlgeschlagen: %d \n ",WSAGetLastError());
					WSACleanup( );
				}

		// SOCKET listen + ERROR Checking
		if (listen(socket_descriptor, 10)!=0)
				{	printf("Fehler: SOCKET-Listen fehlgeschlagen: %d \n ",WSAGetLastError());
					WSACleanup( );}
		else
				{	printf("Socket-Listen fuer 1. Browser Request\n");}

	return socket_descriptor;//für globale Variable für den Browser-Listen-SOCKET
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
main()
{
		//startserver
		// DATENFLUSS-Log-Datei erstellen;

		//inetproxy *helper = new inetproxy;
		//char frage;
		descriptor=startserver();
		//helper->datalog=FALSE;

		//printf("Soll der Datenfluss aufgezeichnet werden (j/n)?");
		//while(1)
		//	{	scanf("%c",&frage);
		//		if (frage == 'j') {	helper->datalog=TRUE;
		//							break;}
		//		if (frage == 'n') {	helper->datalog=FALSE;
		//							break;}
		//	}

		//if (helper->datalog==TRUE)
		//	{	Datei = fopen("data.txt","w+");
		//		fclose(Datei);}

		//Thread für Browser_to_Proxy_to_Server
		DWORD dwThreadId;
		HANDLE hThread;

		// Thread Erstellung + ERROR Checking
		hThread = CreateThread(NULL,0,browser_to_proxy_to_server,NULL,0,&dwThreadId);
		if (hThread == NULL)
			{	printf("Fehler: Thread-Erstellung Fehlgeschlagen!");}
		else
			{
			// Programm kann mit der Eingabe von "q" beendet werden
			while(1)
				if(getchar()=='q')
					{	printf("Programm gestoppt");
						closesocket(descriptor);
						break;
					}
			}
	  return 0;
}
    0
  • R

    Hallo zusammen!

    Hab mich gleich erstmal registriert.

    Ich hab das Problem nur auf WinXP und/oder Win2k

    Auf Win98SE funzt das Programm (inzwischen leicht abgeändert, aber Funktionsweise immernoch die selbe) ohne Probleme 😕

    Hat irgendjemand eine Vermutung woran das liegen könnte (irgendetwas das direkt mit dem Quellcode zusammenhängt)? Ich hab nämlich keine! Das das 2 bzw. 3 unterschiedliche Betriebssysteme sind weiß ich selber.

    0
Anmelden zum Antworten