1 /*
2  * COPYRIGHT:   See COPYING in the top level directory
3  * PROJECT:     ReactOS HTTP Daemon
4  * FILE:        httpd.cpp
5  * PURPOSE:     HTTP daemon
6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7  * REVISIONS:
8  *   CSH  01/09/2000 Created
9  */
10 #include <debug.h>
11 #include <new>
12 #include <malloc.h>
13 #include <string.h>
14 #include <config.h>
15 #include <httpd.h>
16 #include <error.h>
17 
18 using namespace std;
19 
20 CHAR HttpMsg400[] = "<HEAD><TITLE>400 Bad Request</TITLE></HEAD>\n\r<BODY><H1>400 Bad Request</H1>\n\rThe request had bad syntax.<BR>\n\r</BODY>\n\r\n\r";
21 CHAR HttpMsg404[] = "<HEAD><TITLE>404 Not Found</TITLE></HEAD>\n\r<BODY><H1>404 Not Found</H1>\n\rThe requested URL was not found on this server.<BR>\n\r</BODY>\n\r\n\r";
22 CHAR HttpMsg405[] = "<HEAD><TITLE>405 Method Not Allowed</TITLE></HEAD>\n\r<BODY><H1>405 Method Not Allowed</H1>\n\rThe requested method is not supported on this server.<BR>\n\r</BODY>\n\r\n\r";
23 CHAR HttpMsg500[] = "<HEAD><TITLE>500 Internal Server Error</TITLE></HEAD>\n\r<BODY><H1>500 Internal Server Error</H1>\n\rAn internal error occurred.<BR>\n\r</BODY>\n\r\n\r";
24 CHAR HttpMsg501[] = "<HEAD><TITLE>501 Not Implemented</TITLE></HEAD>\n\r<BODY><H1>501 Not Implemented</H1>\n\rThe feature is not implemented.<BR>\n\r</BODY>\n\r\n\r";
25 
26 
27 // *************************** CHttpClient ***************************
28 
29 // Default constructor
30 CHttpClient::CHttpClient()
31 {
32 }
33 
34 // Constructor with server socket as starter value
35 CHttpClient::CHttpClient(CServerSocket *serversocket)
36 {
37 	ServerSocket = serversocket;
38 }
39 
40 // Split URIs into its parts (ie. |http://|www.host.com|/resource|?parameters|)
41 VOID CHttpClient::SplitUri(LPSTR lpsUri, LPSTR lpsHost, LPSTR lpsResource, LPSTR lpsParams)
42 {
43     LPSTR lpsPos;
44     LPSTR lpsStr;
45     UINT i;
46 
47 	strcpy(lpsHost, "");
48 	strcpy(lpsResource, "");
49 	strcpy(lpsParams, "");
50 
51     lpsPos = strstr(lpsUri, "://");
52     if (lpsPos != NULL)
53         lpsStr = &lpsPos[3];
54 	else
55 		lpsStr = lpsUri;
56 
57     lpsPos = strstr(lpsStr, "/");
58     if (lpsPos != NULL) {
59         strncat(lpsHost, lpsPos, lpsPos - lpsStr);
60         lpsStr = &lpsPos[1];
61 
62         lpsPos = strstr(lpsStr, "?");
63         if (lpsPos != NULL) {
64             strncat(lpsResource, lpsStr, lpsPos - lpsStr);
65             strcpy(lpsParams, &lpsPos[1]);
66         } else {
67             strcpy(lpsResource, lpsStr);
68             strcpy(lpsParams, "");
69         }
70 
71         // Replace "/" with "\"
72 		for (i = 0; i < strlen(lpsResource); i++) {
73             if (lpsResource[i] == '/')
74                 lpsResource[i] = '\\';
75         }
76     }
77 }
78 
79 // Split resource into its parts (ie. |/path/|filename|.extension|)
80 VOID CHttpClient::SplitResource(LPSTR lpsResource, LPSTR lpsPath, LPSTR lpsFilename, LPSTR lpsExtension)
81 {
82     INT i,len,fileptr,extptr;
83 
84 	strcpy(lpsPath, "");
85 	strcpy(lpsFilename, "");
86 	strcpy(lpsExtension, "");
87 
88 	len = strlen(lpsResource);
89 	if (len != 0) {
90 		if (lpsResource[len - 1] == '/') {
91 			// There is only a path
92 			strcpy(lpsPath, lpsResource);
93 		} else {
94 			// Find extension
95 			i = len - 1;
96 			while ((i >= 0) && (lpsResource[i] != '.')) i--;
97 			extptr = i;
98 			while ((i >= 0) && (lpsResource[i] != '/')) i--;
99 			if (i > 0) {
100 				// There is at least one directory in the path (besides root directory)
101 				fileptr = i + 1;
102 				strncat(lpsPath, lpsResource, fileptr);
103 			} else
104 				fileptr = 1;
105 
106 			// Get filename and possibly extension
107 			if (extptr != 0) {
108 				strncat(lpsFilename, &lpsResource[fileptr], extptr - fileptr);
109 				// Get extension
110 				strncat(lpsExtension, &lpsResource[extptr + 1], len - extptr - 1);
111 			} else
112 				strncat(lpsFilename, &lpsResource[fileptr], len - fileptr);
113 		}
114 	}
115 }
116 
117 // Process HTTP request
118 VOID CHttpClient::ProcessRequest()
119 {
120     CHAR sStr[255];
121     CHAR sHost[255];
122     CHAR sResource[255];
123     CHAR sParams[255];
124 
125     // Which method?
126     switch (Parser.nMethodNo) {
127 		case hmGET: {
128 			SplitUri(Parser.sUri, sHost, sResource, sParams);
129 
130 			// Default resource?
131 			if (strlen(sResource) == 0) {
132 				CIterator<LPSTR> *i = pConfiguration->GetDefaultResources()->CreateIterator();
133 
134 				// FIXME: All default resources should be tried
135 				// Iterate through all strings
136 				//for (i->First(); !i->IsDone(); i->Next())
137 				i->First();
138 				if (!i->IsDone()) {
139 					strcat(sResource, i->CurrentItem());
140 					delete i;
141 				} else {
142 					// File not found
143 					Report("404 Not Found", HttpMsg404);
144 					break;
145 				}
146 			}
147 			strcpy(sStr, pConfiguration->GetHttpBase());
148 			strcat(sStr, sResource);
149 			SendFile(sStr);
150 			break;
151 		}
152 		default: {
153 			// Method is not implemented
154 			Report("501 Not Implemented", HttpMsg501);
155 		}
156 	}
157 }
158 
159 // Send a file to socket
160 VOID CHttpClient::SendFile(LPSTR lpsFilename)
161 {
162     CHAR str[255];
163     CHAR str2[32];
164     union BigNum {
165       //        unsigned __int64 Big;
166       unsigned long long Big;
167         struct {
168             DWORD Low;
169             DWORD High;
170         } u;
171     } nTotalBytes;
172 	DWORD nBytesToRead;
173 	DWORD nBytesRead;
174 	BOOL bStatus;
175 
176 	// Try to open file
177     hFile = CreateFileA(lpsFilename,
178         GENERIC_READ,               // Open for reading
179         FILE_SHARE_READ,            // Share for reading
180         NULL,                       // No security
181         OPEN_EXISTING,              // Existing file only
182         FILE_ATTRIBUTE_NORMAL,      // Normal file
183         NULL);                      // No attr. template
184     if (hFile == INVALID_HANDLE_VALUE) {
185         // File not found
186         Report("404 Not Found", HttpMsg404);
187         return;
188     }
189     // Get file size
190     nTotalBytes.u.Low = GetFileSize(hFile, &nTotalBytes.u.High);
191     if ((nTotalBytes.u.Low == 0xFFFFFFFF) && ((GetLastError()) != NO_ERROR)) {
192         // Internal server error
193 		Report("500 Internal Server Error", HttpMsg500);
194 		// Close file
195 		CloseHandle(hFile);
196         return;
197     }
198 
199 	// Determine buffer size
200 	if (nTotalBytes.Big < 65536)
201 		nBufferSize = 1024;
202 	else
203 		nBufferSize = 32768;
204 	// Allocate memory on heap
205 	lpsBuffer = (PCHAR) malloc(nBufferSize);
206 
207 	if (lpsBuffer == NULL) {
208 		// Internal server error
209 		Report("500 Internal Server Error", HttpMsg500);
210 		// Close file
211 		CloseHandle(hFile);
212 		return;
213 	}
214 
215     SendText("HTTP/1.1 200 OK");
216     SendText("Server: ROSHTTPD");
217     SendText("MIME-version: 1.0");
218     SendText("Content-Type: text/plain");
219     SendText("Accept-Ranges: bytes");
220     strcpy(str, "Content-Length: ");
221     _itoa(nTotalBytes.u.Low, str2, 10);
222     strcat(str, str2);
223     SendText(str);
224     SendText("");
225 	// Read and transmit file
226 	nTotalRead = 0;
227 	nFileSize = nTotalBytes.Big;
228 	bStop = FALSE;
229 
230 	fd_set wfds;
231 	FD_ZERO(&wfds);
232 	FD_SET(Socket, &wfds);
233 	do {
234 		MessageLoop();
235 
236 		if (nTotalRead + nBufferSize < nFileSize)
237 			nBytesToRead = nBufferSize;
238 		else nBytesToRead = nFileSize - nTotalRead;
239 
240 		bStatus = ReadFile(hFile, lpsBuffer, nBytesToRead, &nBytesRead, NULL);
241 		if (bStatus) {
242 			select(0, NULL, &wfds, NULL, NULL);
243 			bStatus = (Transmit(lpsBuffer, nBytesRead) == (INT)nBytesRead);
244 			nTotalRead += nBytesRead;
245 		}
246     } while ((!bStop) && (bStatus) && (nTotalRead < nFileSize));
247 
248 	if (bStatus)
249 		SendText("");
250 	else
251 		// We can't send an error message here as we are in the process of sending a file.
252 		// We have to terminate the connection instead
253 		Close();
254 
255 	// Free allocated memory
256 	free(lpsBuffer);
257 
258 	// Close file
259     CloseHandle(hFile);
260 }
261 
262 // Report something to client
263 VOID CHttpClient::Report(LPCSTR lpsCode, LPSTR lpsStr)
264 {
265     CHAR sTmp[128];
266     CHAR sTmp2[16];
267 
268     strcpy(sTmp, "HTTP/1.1 ");
269     strcat(sTmp, lpsCode);
270     SendText(sTmp);
271     SendText("Server: ROSHTTPD");
272     SendText("MIME-version: 1.0");
273     SendText("Content-Type: text/html");
274     SendText("Accept-Ranges: bytes");
275     strcpy(sTmp, "Content-Length: ");
276     if (lpsStr != NULL) {
277         _itoa(strlen(lpsStr), sTmp2, 10);
278         strcat(sTmp,  sTmp2);
279     } else
280         strcat(sTmp, "0");
281     SendText(sTmp);
282     SendText("");
283     if (lpsStr != NULL)
284         SendText(lpsStr);
285     SendText("");
286 }
287 
288 // OnRead event handler
289 VOID CHttpClient::OnRead()
290 {
291 	LONG nCount;
292 
293 	nCount = Receive((LPSTR) &Parser.sBuffer[Parser.nHead],
294         sizeof(Parser.sBuffer) - Parser.nHead);
295 
296     Parser.nHead += nCount;
297 	if (Parser.nHead >= sizeof(Parser.sBuffer))
298 		Parser.nHead = 0;
299 
300     if (Parser.Complete()) {
301 		ProcessRequest();
302     }
303 
304 	if (Parser.bUnknownMethod) {
305 		// Method Not Allowed
306 		Report("405 Method Not Allowed", HttpMsg405);
307 		// Terminate connection
308 		Close();
309 	}
310 }
311 /*
312 // OnWrite event handler
313 VOID CHttpClient::OnWrite()
314 {
315 	DWORD nBytesToRead;
316 	DWORD nBytesRead;
317 
318 	OutputDebugString(TS("Can write\n"));
319 
320 	if (bSendingFile) {
321 		if (nTotalRead + nBufferSize < nFileSize)
322 			nBytesToRead = nBufferSize;
323 		else nBytesToRead = nFileSize - nTotalRead;
324 
325 		bError = ReadFile(hFile, Buffer, nBytesToRead, &nBytesRead, NULL);
326 		if (!bError) {
327 			Transmit(Buffer, nBytesRead);
328 			nTotalRead += nBytesRead;
329 		}
330 	}
331 }
332 */
333 // OnClose event handler
334 VOID CHttpClient::OnClose()
335 {
336 	// Stop sending file if we are doing that now
337 	bStop = TRUE;
338 }
339 
340 
341 // ************************ CHttpClientThread ************************
342 
343 // Constructor with client socket as starter value
344 CHttpClientThread::CHttpClientThread(LPCServerClientSocket lpSocket)
345 {
346 	ClientSocket = lpSocket;
347 }
348 
349 // Execute client thread code
350 VOID CHttpClientThread::Execute()
351 {
352     MSG Msg;
353 
354 	while (!Terminated()) {
355 		((  CHttpClient *) ClientSocket)->MessageLoop();
356         if (PeekMessage(&Msg, 0, 0, 0, PM_REMOVE) != 0) {
357             switch (Msg.message) {
358                 case HTTPD_START: {
359 					// TODO: Start thread
360                     break;
361                 }
362                 case HTTPD_STOP: {
363 					// TODO: Stop thread
364                     break;
365                 }
366                 default:
367                     DispatchMessage(&Msg);
368             }
369 
370         }
371     }
372 
373 	if (ClientSocket != NULL) {
374 		delete ClientSocket;
375 		ClientSocket = NULL;
376 	}
377 }
378 
379 
380 // *************************** CHttpDaemon ***************************
381 
382 // Default constructor
383 CHttpDaemon::CHttpDaemon()
384 {
385     State = hsStopped;
386 	Start();
387 }
388 
389 // Default destructor
390 CHttpDaemon::~CHttpDaemon()
391 {
392 	if (State==hsRunning)
393 		Stop();
394 }
395 
396 // Return daemon state
397 HTTPdState CHttpDaemon::GetState() const
398 {
399 	return State;
400 }
401 
402 // Start HTTP daemon
403 BOOL CHttpDaemon::Start()
404 {
405 	assert(State==hsStopped);
406 
407 	SetPort(pConfiguration->GetPort());
408 
409 	Open();
410 
411 	State = hsRunning;
412 
413     return TRUE;
414 }
415 
416 // Stop HTTP daemon
417 BOOL CHttpDaemon::Stop()
418 {
419 	assert(State==hsRunning);
420 
421 	Close();
422 
423 	State = hsStopped;
424 
425     return TRUE;
426 }
427 
428 // OnGetSocket event handler
429 LPCServerClientSocket CHttpDaemon::OnGetSocket(LPCServerSocket lpServerSocket)
430 {
431 	return new CHttpClient(lpServerSocket);
432 }
433 
434 // OnGetThread event handler
435 LPCServerClientThread CHttpDaemon::OnGetThread(LPCServerClientSocket lpSocket)
436 {
437 	return new CHttpClientThread(lpSocket);
438 }
439 
440 // OnAccept event handler
441 VOID CHttpDaemon::OnAccept(LPCServerClientThread lpThread)
442 {
443 }
444 
445 
446 // ************************ CHttpDaemonThread ************************
447 
448 // Execute daemon thread code
449 VOID CHttpDaemonThread::Execute()
450 {
451 	MSG Msg;
452 
453 	try {
454 		Daemon = NULL;
455 		Daemon = new CHttpDaemon;
456 
457 		while (!Terminated()) {
458 			Daemon->MessageLoop();
459 			if (PeekMessage(&Msg, 0, 0, 0, PM_REMOVE) != 0) {
460 	            switch (Msg.message) {
461 		            case HTTPD_START: {
462 			            if (Daemon->GetState() == hsStopped)
463 				            Daemon->Start();
464                     break;
465 					}
466 					case HTTPD_STOP: {
467 	                    if (Daemon->GetState() == hsRunning)
468 							Daemon->Stop();
469                     break;
470 					}
471 					case HTTPD_SUSPEND: {
472 						if (Daemon->GetState() == hsRunning){}
473 							// FIXME: Suspend service
474                     break;
475 					}
476 					case HTTPD_RESUME: {
477 						if (Daemon->GetState() != hsSuspended){}
478 							// FIXME: Resume service
479                     break;
480 					}
481 					default:
482                         DispatchMessage(&Msg);
483 				}
484 			}
485 	    }
486 		delete Daemon;
487 	} catch (ESocket e) {
488 		ReportErrorStr(e.what());
489 	} catch	(bad_alloc&) {
490 		ReportErrorStr(TS("Insufficient resources."));
491 	}
492 }
493