client app

client.cpp

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h> 
#include <pthread.h>
#include "Client.h"
#include <iostream>

using namespace std;

Client::Client(char* h, int p, ClientListener* l) {
	WSADATA wsaData;
	WORD version;

	version = MAKEWORD( 2, 0 );

	WSAStartup( version, &wsaData );
	listener = l;
	struct sockaddr_in serv_addr;
	struct hostent *server;	

	server = gethostbyname(h);
	sck = socket(AF_INET, SOCK_STREAM, 0);

	memset((char *) &serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	memcpy((char *)server->h_addr, 
		(char *)&serv_addr.sin_addr.s_addr,
		server->h_length);
	serv_addr.sin_port = htons(p);
	connect(sck, (struct sockaddr *) &serv_addr,sizeof(serv_addr));

	pthread_create(&thread, NULL, Worker, this);
};

void Client::sendData(char *s) {
	send(sck, s, strlen(s) + 1, 0);
}


void *Client::Worker(void* x) {
	Client* c = (Client*)x;
	char buffer[10240];
	int bufp = 0;
	while (1) {
		bufp += recv(c->sck, (buffer + bufp), 10240, 0);
		for (int i = 0; i < bufp; i++) {
			if (buffer[i] == 0) {
				char* s = new char[i+1];
				memcpy(s, buffer, i+1);
				c->listener->OnNewData(s);
				memcpy(buffer, buffer + i+1, bufp - i-1);
				bufp -= i+1;
				i = 0;
			}
		}
	}
}

client.h

#include "stdafx.h"
#include <winsock2.h>
#include <Windows.h>

class ClientListener {
public:
	virtual void OnNewData(char* data) = 0;
};


class Client {
public:	
	Client(char* h, int p, ClientListener* l);
	void sendData(char* c);
private:
	static void *Worker(void* x);
	SOCKET sck;
	pthread_t thread;
	ClientListener* listener;	
};

discovery.cpp

#include "stdafx.h"
#include "Discovery.h"

Discovery::Discovery(char* addr, int port, DiscoveryListener* l) {
	WSADATA wsaData;
	WORD version;
	version = MAKEWORD( 2, 0 );
	WSAStartup( version, &wsaData );
	listener = l;
	int n;
	unsigned int length;
	struct sockaddr_in server, from;
	struct hostent *hp;
	char buffer[256];
   
	sock= socket(AF_INET, SOCK_DGRAM, 0);
	server.sin_family = AF_INET;

	//DWORD a = inet_addr(addr);

	//hp = gethostbyaddr((char*)&a, 4, AF_INET); 

	hp = gethostbyname(addr);
	memcpy((char *)hp->h_addr, 
		(char *)&server.sin_addr,
		 hp->h_length);
	server.sin_port = htons(port+1);
	length=sizeof(struct sockaddr_in);
	memset(buffer, 0, 256);
	sendto(sock,"REQ",4,0,(const struct sockaddr *)&server,length);

	pthread_create(&thread, NULL, worker, this);
}

void* Discovery::worker(void* x) {
	Discovery* d = (Discovery*)x;

	char buf[1024];
	int fromlen = sizeof(struct sockaddr_in);

	struct sockaddr_in from;       
	while (1) {
		int n = recvfrom(d->sock, buf, 1024, 0, (struct sockaddr *)&from, &fromlen);
		char* s = new char[n+1];
		memcpy(s, buf, n+1);
		d->listener->OnNewServer(&from, s);
	}
}

discovery.h

#include <pthread.h>
#include <winsock2.h>
#include <Windows.h>

class DiscoveryListener {
public:
	virtual void OnNewServer(struct sockaddr_in* addr, char* name) = 0;
};

class Discovery {
public:
	Discovery(char* addr, int port, DiscoveryListener* l);
	static void* worker(void*);
	SOCKET sock;
private:
	DiscoveryListener* listener;
	pthread_t thread;
};

main.cpp

// Sockets2.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <pthread.h>
#include "Client.h"
#include "Discovery.h"
#include <iostream>

using namespace std;

class Listener : public ClientListener {
	public:
		void OnNewData(char* data) {
			cout << "<< " << data << "\n";
		}
};

class DListener : public DiscoveryListener {
	public:
		void OnNewServer(struct sockaddr_in* addr, char* name) {
			cout << "Server found: s_addr=" << addr->sin_addr.s_addr << "\n";
		}
};

int _tmain(int argc, _TCHAR* argv[])
{

	Listener* l = new Listener();
	DListener* dl = new DListener();

	Discovery d("0.0.0.0", 1234, dl);

	Client c("localhost", 1234, l);
	c.sendData("Hello to server \n");
	while(1);


	return 0;
}

server.cpp

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h> 
#include "Server.h"

#include <pthread.h>


Server::Server(int port, ServerListener *l, char* name) {
	WSADATA wsaData;
	WORD version;
	version = MAKEWORD( 2, 0 );
	WSAStartup( version, &wsaData );
	lastId = 0;
	listener = l;
	this->name = name;
	int clilen;
	struct sockaddr_in serv_addr;

	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	memset((char *) &serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = INADDR_ANY;
	serv_addr.sin_port = htons(port);
	bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

	discfd = socket(AF_INET, SOCK_DGRAM, 0);
	memset((char *) &serv_addr, 0, sizeof(serv_addr));
	serv_addr.sin_family = AF_INET;
	serv_addr.sin_addr.s_addr = INADDR_ANY;
	serv_addr.sin_port = htons(port+1);
	bind(discfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

	pthread_create(&discThread, NULL, discovery, this);
}

void Server::serve() {
	listen(sockfd,5);
	struct sockaddr_in cli_addr;
	int clilen = sizeof(cli_addr);
	while (1) {
		int newsockfd = accept(sockfd, 
			   (struct sockaddr *) &cli_addr, &clilen);
		Worker* w = new Worker(newsockfd, lastId++, this);
		workers[w->id] = w;
		pthread_create(&(w->thread), NULL, newClient, w);
	}
}

void *Server::discovery(void* x) {
	Server* s = (Server*)x;
	int fd = s->discfd;
	char buf[1024];
	int fromlen = sizeof(struct sockaddr_in);

	struct sockaddr_in from;       
	while (1) {
		int n = recvfrom(fd, buf, 1024, 0, (struct sockaddr *)&from, &fromlen);
		sendto(fd, s->name, strlen(s->name)+1, 0, (struct sockaddr *)&from, fromlen);
	}
}


void *Server::newClient(void* w) {
	((Worker*)w)->work();
	return NULL;
}

void Server::sendData(int id, char* s) {
	send(workers[id]->socket, s, strlen(s) + 1, 0);
}


void Server::stop() {
	closesocket(sockfd);
}


Worker::Worker(int fd, int i, Server* s) {
	server = s;
	socket = fd;
	bufp = 0;
	id = i;
}

void Worker::work() {
	server->listener->OnNewClient(id);
	while (1) {
		bufp += recv(socket, (buffer + bufp), 10240, 0);
		for (int i = 0; i < bufp; i++) {
			if (buffer[i] == 0) {
				char* s = new char[i+1];
				memcpy(s, buffer, i+1);
				server->listener->OnNewData(id, s);
				memcpy(buffer, buffer + i+1, bufp - i-1);
				bufp -= i+1;
				i = 0;
			}
		}
	}
}

server.h

#include <pthread.h>
#include <winsock2.h>
#include <Windows.h>

class ServerListener {
public:
	virtual void OnNewClient(int id) = 0;
	virtual void OnNewData(int id, char* data) = 0;
};

class Server;

class Worker {
public:
	Worker(int fd, int i, Server* s);
	void work();
	pthread_t thread;
	int id;
	SOCKET socket;
private:
	Server* server;
	char buffer[10240];
	int bufp;
};

class Server {
public:
	Server(int port, ServerListener* l, char* name);
	void serve();
	void stop();
	void sendData(int id, char* s);
	ServerListener* listener;		
	char* name;	
private:
	Worker* workers[1024];
	static void *newClient(void* w);
	static void *discovery(void* x);
	SOCKET sockfd;
	int lastId;
	SOCKET discfd;
	pthread_t discThread;
};