#ifdef INFORMATION

We have these threads :

1. HandleTCPClient which runs on a thread to service a particular client(as many threads as clients)

2. AcceptSockets, which is a simnple thread waiting for user connections

3. ChatbotServer, which is the sole server to be the chatbot

4. main thread, which is a simple thread that creates ChatbotServer threads as needed(if ones crash in LINUX, it can spawn a new one)

chatLock - either chatbot engine or a client controls it.It is how a client gets started and then the server is summoned

While processing chat, the client holds the clientlock and the server holds the chatlock and donelock.

The client is waiting for the donelock.

When the server finishes, he releases the donelock and waits for the clientlock.

If the client exists, server gets the donelock, then releases it and waits for the clientlock.

If the client doesnt exist anymore, he has released clientlock.

It releases the clientlock and the chatlock and tries to reacquire chatlock with flag on.

when it succeeds, it has a new client.

We have these variables :

chatbotExists - the chatbot engine is now initialized.

serverFinishedBy is what time the answer must be delivered(1 second before the memory will disappear)

#endif

#include "common.h"

#ifndef WIN32

#include <ifaddrs.h>

#include <net/if.h>

#endif

static int servertransfersize;

bool echoServer = false;

char serverIP[100];

static int pass = 0;

static int fail = 0;

typedef unsigned int (*initsystem)(int, char* [], char*, char*, char*, USERFILESYSTEM*, DEBUGAPI, DEBUGAPI);

typedef unsigned int (*performchat)(char*, char*, char*, char*, char*) ;

void GetPrimaryIP(char* buffer)

}

#ifndef DISCARDSERVER

#ifdef EVSERVER

#include "cs_ev.h"

#include "evserver.h"

#endif

#define DOSOCKETS 1

#endif

#ifndef DISCARDCLIENT

#define DOSOCKETS 1

#endif

#ifndef DISCARDTCPOPEN

#define DOSOCKETS 1

#endif

#ifdef DOSOCKETS

SocketException::SocketException(const string &message, bool inclSysMsg)

}

SocketException::~SocketException() throw() {}

const char *SocketException::what() const throw() { return userMessage.c_str(); }

static void fillAddr(const string &address, unsigned short myport, sockaddr_in &addr) {

}

#define MAKEWORDX(a, b) ((unsigned short)(((BYTE)(((DWORD_PTR)(a)) & 0xff)) | (((unsigned short)((BYTE)(((DWORD_PTR)(b)) & 0xff))) << 8)))

CSocket::CSocket(int type, int protocol) throw(SocketException) {

}

CSocket::CSocket(int sockDesc) { this->sockDesc = sockDesc; }

CSocket::~CSocket() {

#ifdef WIN32

::closesocket(sockDesc);

#else

::close(sockDesc);

#endif

sockDesc = -1;

}

string CSocket::getLocalAddress() throw(SocketException) {

}

unsigned short CSocket::getLocalPort() throw(SocketException) {

}

void CSocket::setLocalPort(unsigned short localPort) throw(SocketException) {

}

void CSocket::setLocalAddressAndPort(const string &localAddress,

}

void CSocket::cleanUp() throw(SocketException) {

}

unsigned short CSocket::resolveService(const string &service,

}

CommunicatingSocket::CommunicatingSocket(int type, int protocol) throw(SocketException) : CSocket(type, protocol) {

}

CommunicatingSocket::CommunicatingSocket(int newConnSD) : CSocket(newConnSD) {

}

void CommunicatingSocket::connect(const string &foreignAddress, unsigned short foreignPort) throw(SocketException) {

}

void CommunicatingSocket::send(const void *buffer, int bufferLen) throw(SocketException) {

if (::send(sockDesc, (raw_type *)buffer, bufferLen, 0) < 0) throw SocketException((char*)"Send failed (send())", true);

}

int CommunicatingSocket::recv(void *buffer, int bufferLen) throw(SocketException) {

}

string CommunicatingSocket::getForeignAddress() throw(SocketException) {

}

unsigned short CommunicatingSocket::getForeignPort() throw(SocketException) {

}

TCPSocket::TCPSocket() throw(SocketException) : CommunicatingSocket(SOCK_STREAM, IPPROTO_TCP) {

}

TCPSocket::TCPSocket(const string &foreignAddress, unsigned short foreignPort) throw(SocketException) : CommunicatingSocket(SOCK_STREAM, IPPROTO_TCP) {

connect(foreignAddress, foreignPort);

}

TCPSocket::TCPSocket(int newConnSD) : CommunicatingSocket(newConnSD) {

}

TCPServerSocket::TCPServerSocket(unsigned short localPort, int queueLen) throw(SocketException) : CSocket(SOCK_STREAM, IPPROTO_TCP) {

setLocalPort(localPort);

setListen(queueLen);

}

TCPServerSocket::TCPServerSocket(const string &localAddress, unsigned short localPort, int queueLen) throw(SocketException) : CSocket(SOCK_STREAM, IPPROTO_TCP) {

setLocalAddressAndPort(localAddress, localPort);

setListen(queueLen);

}

TCPSocket *TCPServerSocket::accept() throw(SocketException) {

int newConnSD;

if ((newConnSD = ::accept(sockDesc, NULL, 0)) < 0) throw SocketException((char*)"Accept failed (accept())", true);

return new TCPSocket(newConnSD);

}

void TCPServerSocket::setListen(int queueLen) throw(SocketException) {

if (listen(sockDesc, queueLen) < 0) throw SocketException((char*)"Set listening socket failed (listen())", true);

}

#endif

#ifndef DISCARDCLIENT

static void ReadSocket(TCPSocket* sock, char* response)

}

void NoBlankStart(char* ptr, char* where)

}

void Client(char* login)// test client for a server

}

#endif

#ifndef DISCARDSERVER

#define SERVERTRANSERSIZE (4 + 100 + fullInputLimit) // offset to output buffer

#ifdef WIN32

#pragma warning(push,1)

#pragma warning(disable: 4290)

#include <process.h>

#endif

#include <cstdio>

#include <errno.h>

using namespace std;

static TCPServerSocket* serverSocket = NULL;

unsigned int serverFinishedBy = 0; // server must complete by this or not bother

// buffers used to send in and out of chatbot

static char* clientBuffer; // current client spot input was and output goes

static bool chatWanted = false; // client is still expecting answer (has not timed out/canceled)

static bool chatbotExists = false; // has chatbot engine been set up and ready to go?

static int pendingClients = 0; // number of clients waiting for server to handle them

#ifndef EVSERVER

static void* MainChatbotServer();

static void* HandleTCPClient(void* sock1);

static void* AcceptSockets(void*);

static unsigned int errorCount = 0;

static time_t lastCrash = 0;

#endif

static int loadid = 0;

#ifndef WIN32 // for LINUX

#include <pthread.h>

#include <signal.h>

pthread_t chatThread;

static pthread_mutex_t chatLock = PTHREAD_MUTEX_INITIALIZER; // access lock to shared chatbot processor

static pthread_mutex_t testLock = PTHREAD_MUTEX_INITIALIZER; // right to use test memory

static pthread_cond_t server_var = PTHREAD_COND_INITIALIZER; // client ready for server to proceed

static pthread_cond_t server_done_var = PTHREAD_COND_INITIALIZER; // server ready for clint to take data

#else // for WINDOWS

#include <winsock2.h>

HANDLE hChatLockMutex;

CRITICAL_SECTION TestCriticalSection;

#endif

void CloseServer() {

}

void* RegressLoad(void* junk)// test load for a server

{

FILE* in = FopenReadOnly((char*)"REGRESS/bigregress.txt");

if (!in) return 0;

char buffer[8000];

(*printer)((char*)"\r\n\r\n** Load %d launched\r\n", ++loadid);

char data[MAX_WORD_SIZE];

char from[100];

sprintf(from, (char*)"%d", loadid);

const char* bot = "";

sprintf(logFilename, (char*)"log-%s.txt", from);

unsigned int msg = 0;

unsigned int volleys = 0;

unsigned int longVolleys = 0;

unsigned int xlongVolleys = 0;

int maxTime = 0;

int cycleTime = 0;

int currentCycleTime = 0;

int avgTime = 0;

// message to server is 3 strings- username, botname, null (start conversation) or message

echo = true;

char* ptr = data;

strcpy(ptr, from);

ptr += strlen(ptr) + 1;

strcpy(ptr, bot);

ptr += strlen(ptr) + 1;

*buffer = 0;

int counter = 0;

while (1)

{

if (ReadALine(revertBuffer + 1, in, maxBufferSize - 100) < 0) break; // end of input

// when reading from file, see if line is empty or comment

char word[MAX_WORD_SIZE];

ReadCompiledWord(revertBuffer + 1, word);

if (!*word || *word == '#' || *word == ':') continue;

strcpy(ptr, revertBuffer + 1);

try

{

size_t len = (ptr - data) + 1 + strlen(ptr);

++volleys;

uint64 start_time = ElapsedMilliseconds();

TCPSocket *sock = new TCPSocket(serverIP, port);

sock->send(data, len);

int bytesReceived = 1; // Bytes read on each recv()

int totalBytesReceived = 0; // Total bytes read

char* base = ptr;

while (bytesReceived > 0)

{

// Receive up to the buffer size bytes from the sender

bytesReceived = sock->recv(base, MAX_WORD_SIZE);

totalBytesReceived += bytesReceived;

base += bytesReceived;

}

uint64 end_time = ElapsedMilliseconds();

delete(sock);

*base = 0;

int diff = end_time - start_time;

if (diff > maxTime) maxTime = diff;

if (diff > 2000) ++longVolleys;

if (diff > 5000) ++xlongVolleys;

currentCycleTime += diff;

// chatbot replies this

// (*printer)((char*)"real:%d avg:%d max:%d volley:%d 2slong:%d 5slong:%d %s => %s\r\n",diff,avgTime,maxTime,volleys,longVolleys,xlongVolleys,ptr,base);

}

catch (SocketException e) { myexit((char*)"failed to connect to server"); }

if (++counter == 100)

{

counter = 0;

cycleTime = currentCycleTime;

currentCycleTime = 0;

avgTime = cycleTime / 100;

(*printer)((char*)"From: %s avg:%d max:%d volley:%d 2slong:%d 5slong:%d\r\n", from, avgTime, maxTime, volleys, longVolleys, xlongVolleys);

}

else msg++;

}

return 0;

}

#ifndef EVSERVER // til end of file

#ifdef __MACH__

int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abs_timeout)