Classes/NetWork/Server.cpp

#include "Server.h"
#include "../Program/WebServer/WebServer.h"
#include "../String/String.h"
#include "../System/SystemDefine.h"
#include "../String/ConfigInput.h"
#include "../System/System.h"
#include "../Array/ObjectArray.h"
#include "../NetWork/MutexHandler.h"
#include "../LinkedList/IntLinkedList.h"
#include "../Binary/BinaryInput.h"
#include "../Files/FileTools.h"
#include "NetWorkTools.h"
#include <iostream>

Server::Server(){}
Server::~Server(){}

bool quit=false;

#define SD_SEND 1

#ifdef sun
#define INADDR_NONE -1
#define INVALID_SOCKET -1
void *echoHandler(void *iSd);
#endif

#ifdef linux
#define INVALID_SOCKET -1
void *echoHandler(void *iSd);
#endif

#ifdef WIN32 
DWORD WINAPI echoHandler(void* iSd);
DWORD nThreadID=0;
#endif

bool closeConnection(int sd);
bool echoIncomingPackets(PacketInfo *packetInfo);
void acceptConnections(int listeningSocket);
int kDefaultServerPort = 80;
String *ipNumber=null;
bool inputHttpProtocol(PacketInfo *packetInfo, char *ip, int port, int socket);
int handleConnection(void *iSd);
ObjectArray<PacketInfo> *packetInfoArray = new ObjectArray<PacketInfo>(4);
void *socketHandler(void *arg);
StringInput *stringInput=null;
ConfigInput *configInput=null;
sockaddr_in sinRemote;
int nAddrSize = sizeof(sinRemote);

void Server::start()
{

        configInput = new ConfigInput();
        configInput->readFile("data/webServerConfig.txt");

        int size=packetInfoArray->size;

        for ( int i=0; i<size ; i++ )
        {
                PacketInfo *packetInfo=new PacketInfo();
                packetInfoArray->setObject(packetInfo,i);               
                
                pthread_t *thread = new pthread_t();
                
                if(pthread_create(thread, null, &echoHandler, packetInfo)>=0)
                {
                        System::println("Sucessful creation of thread...");
                }
                else
                {
                        System::println("Failed to create a thread...");
                }
        }
}

//// DoWinsock /////////////////////////////////////////////////////////
// The module's driver function -- we just call other functions and
// interpret their results.

int Server::DoWinsock()
{
        stringInput = new StringInput();

        System::println("Establishing the listener...");

        int listeningSocket = SetUpListener("194.47.143.2", htons(6666));

        if (listeningSocket == INVALID_SOCKET) 
        {
                System::println("Faild to establishing the listener...");
        return 3;
    }

        System::println("Waiting for connections...");

//      while (!quit) 
//      {
    acceptConnections(listeningSocket);
//              System::println("Acceptor restarting...");
//    }

        if (stringInput!=null)
        {
                delete stringInput;
        }

        if (configInput!=null)
        {
                delete configInput;
        }

        if (packetInfoArray!=null)
        {
                delete packetInfoArray;
        }

    return null;   // warning eater
}


//// SetUpListener /////////////////////////////////////////////////////
// Sets up a listener on the given interface and port, returning the
// listening socket if successful; if not, returns INVALID_SOCKET.

int Server::SetUpListener(const char* pcAddress, int nPort)
{
        int recSize=16384;
        int sd = socket(AF_INET, SOCK_STREAM, 0);
        
        if (sd != INVALID_SOCKET) 
        {

                if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char*)&recSize, sizeof(recSize)))
                {
                        //cerr<<"Error when calling setsockopt"<<endl;
                        //exit(-1);
                }
            
                sockaddr_in sinInterface;
        sinInterface.sin_family = AF_INET;
        sinInterface.sin_addr.s_addr = htonl(INADDR_ANY);
        sinInterface.sin_port = nPort;
            
                if (bind(sd, (sockaddr*)&sinInterface, sizeof(sockaddr_in)) != SOCKET_ERROR) 
                {
                        listen(sd, SOMAXCONN);
            return sd;
        }
        else 
                {
                        System::println("Error binding socket");
                }
    }
 
    return INVALID_SOCKET;
}

void acceptConnections(int listeningSocket)
{
        pthread_mutex_t mut=MutexHandler::getMutex();

    while (true) 
        {       
                pthread_mutex_lock(&mut);

                PacketInfo *freePacketInfo=null;
                int size=packetInfoArray->size;

                for ( int i=0; i<size ; i++ )
                {
                        PacketInfo *packetInfo=packetInfoArray->getObject(i);   
        
                        if (!packetInfo->inUse)
                        {
                                freePacketInfo=packetInfo;
                                i=size;
                        }
                }

                pthread_mutex_unlock(&mut);

                if (freePacketInfo!=null)
                {
                        int so = accept(listeningSocket, (sockaddr*)&sinRemote,(socklen_t*)&nAddrSize);

                        if (so != 0)
                        {
                                if (inputHttpProtocol(freePacketInfo, inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port), so))
                                {
                                        System::println("sucessful connections....");
                                }
                        }
                }

  }
}

void* echoHandler(void *iSd) 
{
//      pthread_mutex_t mut=MutexHandler::getMutex();

        PacketInfo *packetInfo=(PacketInfo*)iSd;
        WebServer *webServer = new WebServer(configInput);

        while (true)
        {
                if (packetInfo->inUse)
                {
                        webServer->init(packetInfo);

//                      pthread_mutex_lock(&mut);
                        
                        if (close(packetInfo->socket)!=-1)
                        {
                                String socketInfo="close Socket";
                                System::println(socketInfo + packetInfo->socket);       
                        }

                        packetInfo->inUse=false;

//                      pthread_mutex_unlock(&mut);
                
                }
        }
        
        if (webServer!=null)
        {
                delete webServer;
        }

        pthread_exit((void *)0);
}


bool inputHttpProtocol(PacketInfo *packetInfo, char *ip, int port, int socket)
{
        if (!stringInput->socketGetHttp(socket))
        {
                if (close(socket)!=-1)
                {
                        System::println("closed Socket");       
                }
                
                System::println("socketErrorInBegining");
                return false;
        }
        else
        {
                String request=stringInput->scanWord();

                String filePath=stringInput->scanWord();
        
                String protocolType=stringInput->scanWord();

                if (filePath.equals("/quit"))
                {
                        quit=true;
                }

                packetInfo->ip->setString(ip);
                packetInfo->port->setString(port);
                packetInfo->socket=socket;;
                packetInfo->request->setString(request);
                packetInfo->filePath->setString(filePath);
                packetInfo->protocolType->setString(protocolType);
        
                String acceptInfo="Accepted connection from ";
                String date=DateTime(date_);
                String time=DateTime(time_);
                String requestInfo="The request was ";

                System::println(acceptInfo + ip + ":" + port);

                String logFileOutPut=acceptInfo + packetInfo->ip + ":" + packetInfo->port + " at the time " + time + NewRow() + requestInfo + request + " " + filePath + " " + protocolType + NewRow(); 
                String logPath=configInput->getData("log","logPath");

//              if (logFileOutPut.writelnToFileEnd(logPath + date + ".txt")==FileExist)
//              {
//                      System::println("logged to file..");
//              }


                packetInfo->inUse=true;
        }

        return true;
}


//// AcceptConnections /////////////////////////////////////////////////
// Spins forever waiting for connections.  For each one that comes in, 
// we create a thread to handle it and go back to waiting for
// connections.  If an error occurs, we return.
//                      PacketInfo *packetInfo=inputHttpProtocol(inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port), sd);
//                      echoHandler((void*)packetInfo);

//                  pthread_attr_t *attr=(pthread_attr_t*)malloc(sizeof(pthread_attr_t));

//                  pthread_attr_setdetachstate(attr,PTHREAD_CREATE_JOINABLE);

/*
                

                        pthread_t *thread = new pthread_t();
                
                        if(pthread_create(thread, null, &echoHandler, packetInfo)>=0)
                        {
                                System::println("Sucessful creation of thread...");
                        }
                        else
                        {
                                System::println("Failed to create a thread...");
                        }
*/
/*
#ifndef linux

                int socket = accept(listeningSocket, (sockaddr*)&sinRemote,&nAddrSize);
#endif

#ifdef WIN32


                        echoHandler((void*)packetInfo);
                        
//                      LPSECURITY_ATTRIBUTES *pThreadAttributes =(LPSECURITY_ATTRIBUTES*)malloc(sizeof(LPSECURITY_ATTRIBUTES));

//                      HANDLE handle=CreateThread(0, 0,echoHandler, (void*)packetInfo, 0, &nThreadID);

//                      if (handle>=0)
//                      {
//                      //      SetThreadPriority(handle,0);
//                              System::println("Sucessful creation of thread...");
//                      }
//                      else
//                      {
//                              System::println("Failed to create a thread...");
//                      }


//#endif
*/


//      pthread_mutex_t mut=MutexHandler::getMutex();

        /*              PacketInfo *freePacketInfo=null;

//              mainLoopSemaphore->wait();
                
                pthread_mutex_lock(&mut);

                int size=packetInfoArray->size;

                for ( int i=0; i<size ; i++ )
                {
                        PacketInfo *packetInfo=packetInfoArray->getObject(i);   
        
                        if (!packetInfo->inUse)
                        {
                                freePacketInfo=packetInfo;
                                i=size;
                        }
                }

 //             mainLoopSemaphore->signal();
*/
/*
                if (freePacketInfo!=null)
                {
                        //System::println("1");
*/

/*                      String socketInfo="socket ";
                        String kalle=socketInfo + so;

                        System::println(kalle);

                        {
                                
                                WebServer *webServer = new WebServer(configInput);

                                PacketInfo *packetInfo=inputHttpProtocol(inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port),so);

                                webServer->init(packetInfo);
                                
                                delete webServer;
                                */


/*
                        //      System::println("3");
//                              mainLoopSemaphore->wait();
                        //      System::println("4");
                                if (inputHttpProtocol(freePacketInfo, inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port), so))
                                {
                                        freePacketInfo->inUse=true;
                                }

                        //      System::println("5");
//                              mainLoopSemaphore->signal();
//                      }

                        //System::println("6");
                
                        
        else 
                        {
//                              System::println("accept failed");
//                  return;     
                        }
*/
/*
                        }
//                     pthread_mutex_unlock(&mut);
  
        }
*/

//// EchoHandler ///////////////////////////////////////////////////////
// Handles the incoming data by reflecting it back to the sender.

//int handleConnection(void *iSd)
/*
void* echoHandler(void *iSd) 
{
//      Semaphore *threadSemaphore = new Semaphore();

//      threadSemaphore->attach("mainKey", 'a', 0666);

    int status=1;
        PacketInfo *packetInfo=(PacketInfo*)iSd;

        WebServer *webServer=new WebServer(configInput);

        pthread_mutex_t mut=MutexHandler::getMutex();

        while(!quit)
        {
//              threadSemaphore->wait();

                if (packetInfo->inUse)
                {
                        int sd=packetInfo->socket;

//                      threadSemaphore->signal();

                        if (webServer->init(packetInfo)) 
                        {
                            status=0;
                        }
*/
//                      System::println("Shutting connection down");
/*    
                        if (closeConnection(sd)) 
                        {
//                              System::println("Connection is down.");
                        }
                        else 
                        {
                            status=0;
                        }
*/
/*
                        pthread_mutex_lock(&mut);

                    if (close(sd) == SOCKET_ERROR) 
                        {
//                              System::println("shutdown failed 3...");
//                      return false;
                        }
                        else
                        {
                                String info="closeSocketFinal ";
                                System::println(info + sd);
                        }
                        
                        pthread_mutex_unlock(&mut);

//                      threadSemaphore->wait();
                        packetInfo->inUse=false;
//                      threadSemaphore->signal();
                }
                else
                {
//                      threadSemaphore->signal();
                }
        }

        if (webServer!=null)
        {
                delete webServer;
        }

  pthread_exit((void *)0);

//      return status;
}
*/

/*
#ifdef WIN32 

DWORD WINAPI echoHandler(void *iSd) 
{
        return handleConnection(iSd);
}

#endif

#ifndef WIN32 


void* echoHandler(void *iSd) 
{
    handleConnection(iSd);
        pthread_exit((void *)0);
}

#endif
*/


/*

//// ShutdownConnection ////////////////////////////////////////////////
// Gracefully shuts the connection sd down.  Returns true if we're
// successful, false otherwise.

bool closeConnection(int sd)
{
*/
   // Disallow any further data sends.  This will tell the other side
    // that we want to go away now.  If we skip this step, we don't
    // shut the connection down nicely.
/*    if (shutdown(sd, SD_SEND) == SOCKET_ERROR) 
        {
                if (close(sd) == SOCKET_ERROR) 
                {
                        return false;
                }
                else
                {
                        String info="closeSocketIN ";
                        System::println(info + sd);
                }

                return false;
    }
        else
        {
                String info="ShutDown ";
                System::println(info + sd);
        }

    // Receive any extra data still sitting on the socket.  After all
    // data is received, this call will block until the remote host
    // acknowledges the TCP control packet sent by the shutdown above.
    // Then we'll get a 0 back from recv, signalling that the remote
    // host has closed its side of the connection.
    const int kBufferSize = 4097;
        char acReadBuffer[kBufferSize];

        while (true) 
        {
        int nNewBytes = recv(sd, acReadBuffer, kBufferSize, 0);
        if (nNewBytes == SOCKET_ERROR) 
                {
                        System::println("newBytesError");
            return false;
        }
        else if (nNewBytes != 0) 
                {
                        String errorMessage="FYI, received ";
                        System::println(errorMessage + nNewBytes + " unexpected bytes during shutdown.");
                }
        else 
                {
                        System::println("Okay, we're done!");
            break;
        }
    }
*/
/*   
        // Close the socket.

#ifdef WIN32
    
        if (closesocket(sd) == SOCKET_ERROR) 
        {
        return false;
    }

#endif

        
#ifndef WIN32

    if (close(sd) == SOCKET_ERROR) 
        {
//              System::println("shutdown failed 3...");

        return false;
    }
        else
        {
                String info="closeSocketFinal ";
                System::println(info + sd);
        }

#endif

    return true;
}

*/


1	#include "Server.h"
2	#include "../Program/WebServer/WebServer.h"
3	#include "../String/String.h"
4	#include "../System/SystemDefine.h"
5	#include "../String/ConfigInput.h"
6	#include "../System/System.h"
7	#include "../Array/ObjectArray.h"
8	#include "../NetWork/MutexHandler.h"
9	#include "../LinkedList/IntLinkedList.h"
10	#include "../Binary/BinaryInput.h"
11	#include "../Files/FileTools.h"
12	#include "NetWorkTools.h"
13	#include <iostream>
14
15	Server::Server(){}
16	Server::~Server(){}
17
18	bool quit=false;
19
20	#define SD_SEND 1
21
22	#ifdef sun
23	#define INADDR_NONE -1
24	#define INVALID_SOCKET -1
25	void echoHandler(void iSd);
26	#endif
27
28	#ifdef linux
29	#define INVALID_SOCKET -1
30	void echoHandler(void iSd);
31	#endif
32
33	#ifdef WIN32
34	DWORD WINAPI echoHandler(void* iSd);
35	DWORD nThreadID=0;
36	#endif
37
38	bool closeConnection(int sd);
39	bool echoIncomingPackets(PacketInfo *packetInfo);
40	void acceptConnections(int listeningSocket);
41	int kDefaultServerPort = 80;
42	String *ipNumber=null;
43	bool inputHttpProtocol(PacketInfo packetInfo, char ip, int port, int socket);
44	int handleConnection(void *iSd);
45	ObjectArray<PacketInfo> *packetInfoArray = new ObjectArray<PacketInfo>(4);
46	void socketHandler(void arg);
47	StringInput *stringInput=null;
48	ConfigInput *configInput=null;
49	sockaddr_in sinRemote;
50	int nAddrSize = sizeof(sinRemote);
51
52	void Server::start()
53	{
54
55	configInput = new ConfigInput();
56	configInput->readFile("data/webServerConfig.txt");
57
58	int size=packetInfoArray->size;
59
60	for ( int i=0; i<size ; i++ )
61	{
62	PacketInfo *packetInfo=new PacketInfo();
63	packetInfoArray->setObject(packetInfo,i);
64
65	pthread_t *thread = new pthread_t();
66
67	if(pthread_create(thread, null, &echoHandler, packetInfo)>=0)
68	{
69	System::println("Sucessful creation of thread...");
70	}
71	else
72	{
73	System::println("Failed to create a thread...");
74	}
75	}
76	}
77
78	//// DoWinsock /////////////////////////////////////////////////////////
79	// The module's driver function -- we just call other functions and
80	// interpret their results.
81
82	int Server::DoWinsock()
83	{
84	stringInput = new StringInput();
85
86	System::println("Establishing the listener...");
87
88	int listeningSocket = SetUpListener("194.47.143.2", htons(6666));
89
90	if (listeningSocket == INVALID_SOCKET)
91	{
92	System::println("Faild to establishing the listener...");
93	return 3;
94	}
95
96	System::println("Waiting for connections...");
97
98	// while (!quit)
99	// {
100	acceptConnections(listeningSocket);
101	// System::println("Acceptor restarting...");
102	// }
103
104	if (stringInput!=null)
105	{
106	delete stringInput;
107	}
108
109	if (configInput!=null)
110	{
111	delete configInput;
112	}
113
114	if (packetInfoArray!=null)
115	{
116	delete packetInfoArray;
117	}
118
119	return null; // warning eater
120	}
121
122
123	//// SetUpListener /////////////////////////////////////////////////////
124	// Sets up a listener on the given interface and port, returning the
125	// listening socket if successful; if not, returns INVALID_SOCKET.
126
127	int Server::SetUpListener(const char* pcAddress, int nPort)
128	{
129	int recSize=16384;
130	int sd = socket(AF_INET, SOCK_STREAM, 0);
131
132	if (sd != INVALID_SOCKET)
133	{
134
135	if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, (char*)&recSize, sizeof(recSize)))
136	{
137	//cerr<<"Error when calling setsockopt"<<endl;
138	//exit(-1);
139	}
140
141	sockaddr_in sinInterface;
142	sinInterface.sin_family = AF_INET;
143	sinInterface.sin_addr.s_addr = htonl(INADDR_ANY);
144	sinInterface.sin_port = nPort;
145
146	if (bind(sd, (sockaddr*)&sinInterface, sizeof(sockaddr_in)) != SOCKET_ERROR)
147	{
148	listen(sd, SOMAXCONN);
149	return sd;
150	}
151	else
152	{
153	System::println("Error binding socket");
154	}
155	}
156
157	return INVALID_SOCKET;
158	}
159
160	void acceptConnections(int listeningSocket)
161	{
162	pthread_mutex_t mut=MutexHandler::getMutex();
163
164	while (true)
165	{
166	pthread_mutex_lock(&mut);
167
168	PacketInfo *freePacketInfo=null;
169	int size=packetInfoArray->size;
170
171	for ( int i=0; i<size ; i++ )
172	{
173	PacketInfo *packetInfo=packetInfoArray->getObject(i);
174
175	if (!packetInfo->inUse)
176	{
177	freePacketInfo=packetInfo;
178	i=size;
179	}
180	}
181
182	pthread_mutex_unlock(&mut);
183
184	if (freePacketInfo!=null)
185	{
186	int so = accept(listeningSocket, (sockaddr)&sinRemote,(socklen_t)&nAddrSize);
187
188	if (so != 0)
189	{
190	if (inputHttpProtocol(freePacketInfo, inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port), so))
191	{
192	System::println("sucessful connections....");
193	}
194	}
195	}
196
197	}
198	}
199
200	void* echoHandler(void *iSd)
201	{
202	// pthread_mutex_t mut=MutexHandler::getMutex();
203
204	PacketInfo packetInfo=(PacketInfo)iSd;
205	WebServer *webServer = new WebServer(configInput);
206
207	while (true)
208	{
209	if (packetInfo->inUse)
210	{
211	webServer->init(packetInfo);
212
213	// pthread_mutex_lock(&mut);
214
215	if (close(packetInfo->socket)!=-1)
216	{
217	String socketInfo="close Socket";
218	System::println(socketInfo + packetInfo->socket);
219	}
220
221	packetInfo->inUse=false;
222
223	// pthread_mutex_unlock(&mut);
224
225	}
226	}
227
228	if (webServer!=null)
229	{
230	delete webServer;
231	}
232
233	pthread_exit((void *)0);
234	}
235
236
237
238	bool inputHttpProtocol(PacketInfo packetInfo, char ip, int port, int socket)
239	{
240	if (!stringInput->socketGetHttp(socket))
241	{
242	if (close(socket)!=-1)
243	{
244	System::println("closed Socket");
245	}
246
247	System::println("socketErrorInBegining");
248	return false;
249	}
250	else
251	{
252	String request=stringInput->scanWord();
253
254	String filePath=stringInput->scanWord();
255
256	String protocolType=stringInput->scanWord();
257
258	if (filePath.equals("/quit"))
259	{
260	quit=true;
261	}
262
263	packetInfo->ip->setString(ip);
264	packetInfo->port->setString(port);
265	packetInfo->socket=socket;;
266	packetInfo->request->setString(request);
267	packetInfo->filePath->setString(filePath);
268	packetInfo->protocolType->setString(protocolType);
269
270	String acceptInfo="Accepted connection from ";
271	String date=DateTime(date_);
272	String time=DateTime(time_);
273	String requestInfo="The request was ";
274
275	System::println(acceptInfo + ip + ":" + port);
276
277	String logFileOutPut=acceptInfo + packetInfo->ip + ":" + packetInfo->port + " at the time " + time + NewRow() + requestInfo + request + " " + filePath + " " + protocolType + NewRow();
278	String logPath=configInput->getData("log","logPath");
279
280	// if (logFileOutPut.writelnToFileEnd(logPath + date + ".txt")==FileExist)
281	// {
282	// System::println("logged to file..");
283	// }
284
285
286	packetInfo->inUse=true;
287	}
288
289	return true;
290	}
291
292
293
294	//// AcceptConnections /////////////////////////////////////////////////
295	// Spins forever waiting for connections. For each one that comes in,
296	// we create a thread to handle it and go back to waiting for
297	// connections. If an error occurs, we return.
298	// PacketInfo *packetInfo=inputHttpProtocol(inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port), sd);
299	// echoHandler((void*)packetInfo);
300
301	// pthread_attr_t attr=(pthread_attr_t)malloc(sizeof(pthread_attr_t));
302
303	// pthread_attr_setdetachstate(attr,PTHREAD_CREATE_JOINABLE);
304
305	/*
306
307
308	pthread_t *thread = new pthread_t();
309
310	if(pthread_create(thread, null, &echoHandler, packetInfo)>=0)
311	{
312	System::println("Sucessful creation of thread...");
313	}
314	else
315	{
316	System::println("Failed to create a thread...");
317	}
318	*/
319	/*
320	#ifndef linux
321
322	int socket = accept(listeningSocket, (sockaddr*)&sinRemote,&nAddrSize);
323	#endif
324
325	#ifdef WIN32
326
327
328	echoHandler((void*)packetInfo);
329
330	// LPSECURITY_ATTRIBUTES pThreadAttributes =(LPSECURITY_ATTRIBUTES)malloc(sizeof(LPSECURITY_ATTRIBUTES));
331
332	// HANDLE handle=CreateThread(0, 0,echoHandler, (void*)packetInfo, 0, &nThreadID);
333
334	// if (handle>=0)
335	// {
336	// // SetThreadPriority(handle,0);
337	// System::println("Sucessful creation of thread...");
338	// }
339	// else
340	// {
341	// System::println("Failed to create a thread...");
342	// }
343
344
345	//#endif
346	*/
347
348
349
350
351	// pthread_mutex_t mut=MutexHandler::getMutex();
352
353	/* PacketInfo *freePacketInfo=null;
354
355	// mainLoopSemaphore->wait();
356
357	pthread_mutex_lock(&mut);
358
359	int size=packetInfoArray->size;
360
361	for ( int i=0; i<size ; i++ )
362	{
363	PacketInfo *packetInfo=packetInfoArray->getObject(i);
364
365	if (!packetInfo->inUse)
366	{
367	freePacketInfo=packetInfo;
368	i=size;
369	}
370	}
371
372	// mainLoopSemaphore->signal();
373	*/
374	/*
375	if (freePacketInfo!=null)
376	{
377	//System::println("1");
378	*/
379
380	/* String socketInfo="socket ";
381	String kalle=socketInfo + so;
382
383	System::println(kalle);
384
385	{
386
387	WebServer *webServer = new WebServer(configInput);
388
389	PacketInfo *packetInfo=inputHttpProtocol(inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port),so);
390
391	webServer->init(packetInfo);
392
393	delete webServer;
394	*/
395
396
397	/*
398	// System::println("3");
399	// mainLoopSemaphore->wait();
400	// System::println("4");
401	if (inputHttpProtocol(freePacketInfo, inet_ntoa(sinRemote.sin_addr), ntohs(sinRemote.sin_port), so))
402	{
403	freePacketInfo->inUse=true;
404	}
405
406	// System::println("5");
407	// mainLoopSemaphore->signal();
408	// }
409
410	//System::println("6");
411
412
413
414	else
415	{
416	// System::println("accept failed");
417	// return;
418	}
419	*/
420	/*
421	}
422	// pthread_mutex_unlock(&mut);
423
424	}
425	*/
426
427	//// EchoHandler ///////////////////////////////////////////////////////
428	// Handles the incoming data by reflecting it back to the sender.
429
430	//int handleConnection(void *iSd)
431	/*
432	void* echoHandler(void *iSd)
433	{
434	// Semaphore *threadSemaphore = new Semaphore();
435
436	// threadSemaphore->attach("mainKey", 'a', 0666);
437
438	int status=1;
439	PacketInfo packetInfo=(PacketInfo)iSd;
440
441	WebServer *webServer=new WebServer(configInput);
442
443	pthread_mutex_t mut=MutexHandler::getMutex();
444
445	while(!quit)
446	{
447	// threadSemaphore->wait();
448
449	if (packetInfo->inUse)
450	{
451	int sd=packetInfo->socket;
452
453	// threadSemaphore->signal();
454
455	if (webServer->init(packetInfo))
456	{
457	status=0;
458	}
459	*/
460	// System::println("Shutting connection down");
461	/*
462	if (closeConnection(sd))
463	{
464	// System::println("Connection is down.");
465	}
466	else
467	{
468	status=0;
469	}
470	*/
471	/*
472	pthread_mutex_lock(&mut);
473
474	if (close(sd) == SOCKET_ERROR)
475	{
476	// System::println("shutdown failed 3...");
477	// return false;
478	}
479	else
480	{
481	String info="closeSocketFinal ";
482	System::println(info + sd);
483	}
484
485	pthread_mutex_unlock(&mut);
486
487	// threadSemaphore->wait();
488	packetInfo->inUse=false;
489	// threadSemaphore->signal();
490	}
491	else
492	{
493	// threadSemaphore->signal();
494	}
495	}
496
497	if (webServer!=null)
498	{
499	delete webServer;
500	}
501
502	pthread_exit((void *)0);
503
504	// return status;
505	}
506	*/
507
508	/*
509	#ifdef WIN32
510
511	DWORD WINAPI echoHandler(void *iSd)
512	{
513	return handleConnection(iSd);
514	}
515
516	#endif
517
518	#ifndef WIN32
519
520
521	void* echoHandler(void *iSd)
522	{
523	handleConnection(iSd);
524	pthread_exit((void *)0);
525	}
526
527	#endif
528	*/
529
530
531
532
533
534
535
536	/*
537
538	//// ShutdownConnection ////////////////////////////////////////////////
539	// Gracefully shuts the connection sd down. Returns true if we're
540	// successful, false otherwise.
541
542	bool closeConnection(int sd)
543	{
544	*/
545	// Disallow any further data sends. This will tell the other side
546	// that we want to go away now. If we skip this step, we don't
547	// shut the connection down nicely.
548	/* if (shutdown(sd, SD_SEND) == SOCKET_ERROR)
549	{
550	if (close(sd) == SOCKET_ERROR)
551	{
552	return false;
553	}
554	else
555	{
556	String info="closeSocketIN ";
557	System::println(info + sd);
558	}
559
560	return false;
561	}
562	else
563	{
564	String info="ShutDown ";
565	System::println(info + sd);
566	}
567
568	// Receive any extra data still sitting on the socket. After all
569	// data is received, this call will block until the remote host
570	// acknowledges the TCP control packet sent by the shutdown above.
571	// Then we'll get a 0 back from recv, signalling that the remote
572	// host has closed its side of the connection.
573	const int kBufferSize = 4097;
574	char acReadBuffer[kBufferSize];
575
576	while (true)
577	{
578	int nNewBytes = recv(sd, acReadBuffer, kBufferSize, 0);
579	if (nNewBytes == SOCKET_ERROR)
580	{
581	System::println("newBytesError");
582	return false;
583	}
584	else if (nNewBytes != 0)
585	{
586	String errorMessage="FYI, received ";
587	System::println(errorMessage + nNewBytes + " unexpected bytes during shutdown.");
588	}
589	else
590	{
591	System::println("Okay, we're done!");
592	break;
593	}
594	}
595	*/
596	/*
597	// Close the socket.
598
599	#ifdef WIN32
600
601	if (closesocket(sd) == SOCKET_ERROR)
602	{
603	return false;
604	}
605
606	#endif
607
608
609	#ifndef WIN32
610
611	if (close(sd) == SOCKET_ERROR)
612	{
613	// System::println("shutdown failed 3...");
614
615	return false;
616	}
617	else
618	{
619	String info="closeSocketFinal ";
620	System::println(info + sd);
621	}
622
623	#endif
624
625	return true;
626	}
627
628	*/
629
630
631
632