#include <iostream>
#include <ws2tcpip.h>
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#include <string>
using namespace std;
 
void initWinSock(void)  /*throw(const anException) */
{
   WORD wVersionRequested;
   WSADATA wsaData;
   int err;
 
   wVersionRequested = MAKEWORD( 1, 1 );
   err = WSAStartup( wVersionRequested, &wsaData );
   if ( err != 0 )
      throw string("WSA_STARTUP_FAILED");
 
   /* Confirm that the WinSock DLL really supports 1.1. */
   /* Note that if the DLL supports versions greater    */
   /* than 1.1 in addition to 1.1, it will still return */
   /* 1.1 in wVersion since that is the version we      */
   /* requested.                                        */
   if ( (LOBYTE(wsaData.wVersion) != 1)  ||
        (HIBYTE(wsaData.wVersion) != 1)
      )
      throw string("WSA_VERSION_FAILED");
}
 
class brauchtHilfe {};
 
int main(int argc, char* const argv[])
{
 
	sockaddr_in server_addr; // srv adresse (Sende spaeter alles dahin...)
	addrinfo * t_addr; // ziel-Adresse (fuer Hostname-Gedoens)
	int check_addr; // zur Fehlerbehandlung
	int port; // srv port
	int sfd;
	int sendToS;
	int connectTo;
	int recvFromS;
	char nachricht[] = "Knock Knock Neo";
	char send_buffer[1024];
 
	try
	{
		initWinSock();
		if(argc != 3)
			throw brauchtHilfe();
 
		// eingabe
		for(int i = 0; i < argc; i++)
		{
			cout << "argv[" <<  i << "] = " << argv[i] << endl;
		}
 
		// IP und PORT aus Kommandozeile auslesen
		check_addr = getaddrinfo(argv[1], NULL, NULL, &t_addr);
 
		if(check_addr != 0)
			throw string("Falsche Adresse");
 
		port = atoi(argv[2]);
 
		// Init
		server_addr.sin_family = AF_INET;
		server_addr.sin_addr = ((sockaddr_in*)(t_addr->ai_addr))->sin_addr;
		server_addr.sin_port = htons(port);
 
		// mach Socket
		sfd = socket(AF_INET, SOCK_STREAM, 0);
		if(sfd == INVALID_SOCKET)
			throw string("Socket Fehler");
 
		//connect to
		connectTo = connect(sfd, (sockaddr*)&server_addr,(socklen_t)sizeof(server_addr));
		if(connectTo == -1)
			throw string("Fehler beim Verbindungsaufbau");
 
		// sende ab
		sendToS = send(sfd, nachricht, strlen(nachricht) + 1, 0);
 
		if(sendToS == -1)
			throw string("Sendefehler");
 
		// erhalte Antwort
		socklen_t size = sizeof(server_addr);
		recvFromS = recv(sfd, send_buffer, sizeof(send_buffer), 0);
 
		if(recvFromS == -1)
			throw string("Empfangsfehler");
 
		// und ausgeben
 
		cout << "Antwort erhalten von: " << inet_ntoa(server_addr.sin_addr) << endl;
		cout << "Nachricht: " << send_buffer << endl;
 
		// tschuess
		closesocket(sfd);
		WSACleanup();
 
	}
	catch(brauchtHilfe)
	{
		cout << "nix verstehe... benutze: " << argv[0] << " IP[,HOSTNAME] PORT " << endl;
	}
 
	catch(string ex)
	{
		cout << ex;
	}
 
	catch(...)
	{
		cout << "Fehler!";
	}
}

#include <iostream>
#include <ws2tcpip.h>
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")
#include <string>
using namespace std;
 
void initWinSock(void)  /*throw(const anException) */
{
   WORD wVersionRequested;
   WSADATA wsaData;
   int err;
 
   wVersionRequested = MAKEWORD( 1, 1 );
   err = WSAStartup( wVersionRequested, &wsaData );
   if ( err != 0 )
      throw string("WSA_STARTUP_FAILED");
 
   /* Confirm that the WinSock DLL really supports 1.1. */
   /* Note that if the DLL supports versions greater    */
   /* than 1.1 in addition to 1.1, it will still return */
   /* 1.1 in wVersion since that is the version we      */
   /* requested.                                        */
   if ( (LOBYTE(wsaData.wVersion) != 1)  ||
        (HIBYTE(wsaData.wVersion) != 1)
      )
      throw string("WSA_VERSION_FAILED");
}
 
const int server_port = 1337;
 
int main(int argc, char* argv[])
{
	try
	{
		initWinSock();
		//Defines
		sockaddr_in own_addr; // Serveradresse
		sockaddr_in other_addr; // Clientadresse
		int sfd; //Socked Descriptor
		int sfd2; //Kopie
		int listenOn; //Listen-Variable (-1)
		int bindTo; // Bind-Variable-laenge (-1err)
		int sendToC; // Sende-Variable-laenge (-1)
		int recvFromC; // Empfangene-Variable-laenge (-1)
		char recv_buffer[1024]; // CHAR* Empfangspuffer
		unsigned long  test = inet_addr("127.0.0.1"); // Lokaler Test
 
 
		// Init
		own_addr.sin_family = AF_INET;
		own_addr.sin_port = htons(server_port);
		own_addr.sin_addr.s_addr = htonl(INADDR_ANY); // remote
 
		// Ausgabe Port
		cout << "Server-Port: " << server_port << endl;
 
		// mach Socket
		sfd = socket(AF_INET,SOCK_STREAM, 0);
		if(sfd == INVALID_SOCKET)
			throw string("Fehler beim Socket erstellen");
 
		bindTo = bind(sfd, (sockaddr*)&own_addr, sizeof(own_addr));
 
		if(bindTo == -1)
			throw string("Fehler beim binding");
 
		// listen Queue
		listenOn = listen(sfd, 5);
 
		if(listenOn == -1)
			throw string("Fehler bei Erstellung der listening Queue");
 
		// accept
		int size = sizeof(other_addr);
		sfd2 = accept(sfd, (sockaddr*)&other_addr, &size);
 
		if(sfd2 == INVALID_SOCKET)
			throw string("Accept-Fehler");
 
		// recv-call.. warte auf anfrage
 
		recvFromC = recv(sfd2, recv_buffer, sizeof(recv_buffer), 0);
 
		if(recvFromC == -1)
			throw string("Empfangs-Fehler");
 
		// Ausgabe
		cout << "IP-Adresse des Request: " << inet_ntoa(other_addr.sin_addr) << endl;
		cout << "Portnummer des Request: " << ntohs(other_addr.sin_port) << endl;
		cout << "Nachricht im Request: " << recv_buffer << endl;
		cout << "Nachricht zuruecksenden...! " << endl;
 
		// Antwort senden...
		sendToC = send(sfd2, recv_buffer, strlen(recv_buffer) + 1, 0);
 
		if(sendToC == -1)
			throw string("Sende-Fehler");
 
		// tschuess
		closesocket(sfd);
		closesocket(sfd2);
		WSACleanup();
	}
 
	catch(string ex)
	{
		cout << ex;
	}
 
	catch(...)
	{
		cout << "A20 Hardwarefehler!";
	}
}