#include "tbaseserver.h"

#ifndef WIN32

#include <sys types.h=""></sys>

#include <sys socket.h=""></sys>

#include <netinet in.h=""></netinet>

#include <netdb.h></netdb.h>

#include <stdio.h></stdio.h>

#include <unistd.h></unistd.h>

#endif

//#include "tcommon.h"

#include <string></string>

#include <vector></vector>

using namespace std;

//-----------------------------------------------------------------------------

TBaseServer::TBaseServer(int port)

	: m_port(port), m_socketId(-1), m_stopped(false)

{

}

//-----------------------------------------------------------------------------

TBaseServer::~TBaseServer()

{

	if (m_socketId != -1)

		stop();

}

//-----------------------------------------------------------------------------

void TBaseServer::start()

{

#ifdef WIN32

	// Windows Socket startup

	WSADATA wsaData;

	WORD wVersionRequested = MAKEWORD(1, 1);

	int irc = WSAStartup(wVersionRequested, &wsaData);

	if (irc != 0)

		throw("Windows Socket Startup failed");

#else

	int c;

	FILE *fp;

	register int ns;

#endif

	if ((m_socketId = socket(AF_INET, SOCK_STREAM, 0)) < 0) {

#ifdef WIN32

		char szError[1024];

		wsprintf(szError, TEXT("Allocating socket failed. Error: %d"), WSAGetLastError());

		throw(szError);

#else

		throw("Allocating socket failed.");

#endif

	}

	struct sockaddr_in myname;

	myname.sin_family = AF_INET;

	myname.sin_port = htons(m_port);

	myname.sin_addr.s_addr = INADDR_ANY;

	if (bind(m_socketId, (sockaddr *)&myname, sizeof myname) < 0) {

		throw("Unable to bind to connection");

	}

#ifdef TRACE

	cout << "Listening ..." << endl;

#endif

	// length of the queue of pending connections

	int maxPendingConnections = 5;

	if (listen(m_socketId, maxPendingConnections) < 0) {

		throw("Unable to start listening");

	}

	while (true) {

		register int clientSocket;

		if ((clientSocket = accept(m_socketId, 0, 0)) < 0) {

			if (m_stopped)

				return;

			else

				throw("Error accepting from client");

		}

		printf("ho accettato\n");

		char msgFromClient[1024];

		memset(msgFromClient, 0, sizeof(msgFromClient));

#ifdef WIN32

		// Receive data from the client.

		int iReturn = recv(clientSocket, msgFromClient, sizeof(msgFromClient), 0);

		// Verify that data was received. If yes, use it.

		if (iReturn == SOCKET_ERROR) {

			char szError[1024];

			wsprintf(szError, TEXT("No data is received, receive failed.")

								  TEXT(" Error: %d"),

					 WSAGetLastError());

			throw(szError);

		}

#else

		fp = fdopen(clientSocket, "r");

		printf("Partito!\n");

		int i = 0;

		while ((int)(c = fgetc(fp)) != EOF) {

			putchar(c);

			msgFromClient[i] = c;

		}

#endif

		printf("msg finito\n");

		char *argv[128];

		int argc = extractArgs(msgFromClient, argv);

		string reply = exec(argc, argv);

		reply += "\n";

		for (int i = 0; i < argc; ++i)

			delete[] argv[i];

		// Send the reply string from the server to the client.

		if (send(clientSocket, reply.c_str(), reply.length() + 1, 0) < 0) {

			char szError[1024];

#ifdef WIN32

			wsprintf(szError,

					 TEXT("Sending data to the client failed. Error: %d"),

					 WSAGetLastError());

#endif

			throw(szError);

		}

#ifndef WIN32

		close(clientSocket);

#endif

	}

}

//-----------------------------------------------------------------------------

void TBaseServer::stop()

{

	//  TThread::ScopedLock sl(m_mutex);

	if (!m_stopped) {

		m_stopped = true;

#ifdef WIN32

		if (closesocket(m_socketId) != 0) {

			char szError[1024];

			wsprintf(szError, TEXT(" Error: %d"), WSAGetLastError());

			throw(szError);

		}

#else

		close(m_socketId);

#endif

		m_socketId = -1;

	}

}

//-----------------------------------------------------------------------------

int TBaseServer::extractArgs(char *s, char *argv[])

{

	string ss(s);

	string::size_type pos1 = 0;

	string::size_type pos2 = ss.find(",");

	vector<string> args;</string>

	while (pos2 != string::npos) {

		string arg = ss.substr(pos1, pos2 - pos1);

		args.push_back(arg);

		pos1 = pos2 + 1;

		pos2 = ss.find(",", pos1);

	}

	string arg = ss.substr(pos1, ss.length() - pos1);

	args.push_back(arg);

	vector<string>::iterator it = args.begin();</string>

	for (int i = 0; it != args.end(); ++it, ++i) {

		string arg = *it;

		argv[i] = new char[arg.size() + 1];

		strcpy(argv[i], arg.c_str());

	}

	return args.size();

}