Fix test client error cheecking on result types

[user/henk/code/inspircd.git] / src / modules / m_httpd.cpp

diff --git a/src/modules/m_httpd.cpp b/src/modules/m_httpd.cpp
index 8150a6b5f52f4afab8566ab852b790d219527f21..58dece3233b4423f2b0f1efb0d701533b4ba001f 100644 (file)
--- a/src/modules/m_httpd.cpp
+++ b/src/modules/m_httpd.cpp
@@ -22,11 +22,16 @@ using namespace std;
 #include "modules.h"
 #include "inspsocket.h"
 #include "helperfuncs.h"
+#include "httpd.h"
 
 /* $ModDesc: Provides HTTP serving facilities to modules */
 
+class ModuleHttp;
+
 static Server *Srv;
+static ModuleHttp* HttpModule;
 extern time_t TIME;
+static bool claimed;
 
 enum HttpState
 {
@@ -68,18 +73,121 @@ class HttpSocket : public InspSocket
        {
        }
 
-       void SendHeaders()
+       std::string Response(int response)
+       {
+               switch (response)
+               {
+                       case 100:
+                               return "CONTINUE";
+                       case 101:
+                               return "SWITCHING PROTOCOLS";
+                       case 200:
+                               return "OK";
+                       case 201:
+                               return "CREATED";
+                       case 202:
+                               return "ACCEPTED";
+                       case 203:
+                               return "NON-AUTHORITATIVE INFORMATION";
+                       case 204:
+                               return "NO CONTENT";
+                       case 205:
+                               return "RESET CONTENT";
+                       case 206:
+                               return "PARTIAL CONTENT";
+                       case 300:
+                               return "MULTIPLE CHOICES";
+                       case 301:
+                               return "MOVED PERMENANTLY";
+                       case 302:
+                               return "FOUND";
+                       case 303:
+                               return "SEE OTHER";
+                       case 304:
+                               return "NOT MODIFIED";
+                       case 305:
+                               return "USE PROXY";
+                       case 307:
+                               return "TEMPORARY REDIRECT";
+                       case 400:
+                               return "BAD REQUEST";
+                       case 401:
+                               return "UNAUTHORIZED";
+                       case 402:
+                               return "PAYMENT REQUIRED";
+                       case 403:
+                               return "FORBIDDEN";
+                       case 404:
+                               return "NOT FOUND";
+                       case 405:
+                               return "METHOD NOT ALLOWED";
+                       case 406:
+                               return "NOT ACCEPTABLE";
+                       case 407:
+                               return "PROXY AUTHENTICATION REQUIRED";
+                       case 408:
+                               return "REQUEST TIMEOUT";
+                       case 409:
+                               return "CONFLICT";
+                       case 410:
+                               return "GONE";
+                       case 411:
+                               return "LENGTH REQUIRED";
+                       case 412:
+                               return "PRECONDITION FAILED";
+                       case 413:
+                               return "REQUEST ENTITY TOO LARGE";
+                       case 414:
+                               return "REQUEST-URI TOO LONG";
+                       case 415:
+                               return "UNSUPPORTED MEDIA TYPE";
+                       case 416:
+                               return "REQUESTED RANGE NOT SATISFIABLE";
+                       case 417:
+                               return "EXPECTATION FAILED";
+                       case 500:
+                               return "INTERNAL SERVER ERROR";
+                       case 501:
+                               return "NOT IMPLEMENTED";
+                       case 502:
+                               return "BAD GATEWAY";
+                       case 503:
+                               return "SERVICE UNAVAILABLE";
+                       case 504:
+                               return "GATEWAY TIMEOUT";
+                       case 505:
+                               return "HTTP VERSION NOT SUPPORTED";
+                       default:
+                               return "WTF";
+                       break;
+                               
+               }
+       }
+
+       void SendHeaders(unsigned long size, int response, const std::string &extraheaders)
        {
                struct tm *timeinfo = localtime(&TIME);
-               this->Write("HTTP/1.1 200 OK\r\nDate: ");
+               this->Write("HTTP/1.1 "+ConvToStr(response)+" "+Response(response)+"\r\nDate: ");
                this->Write(asctime(timeinfo));
-               this->Write("Server: InspIRCd/m_httpd.so/1.1\r\nContent-Length: "+ConvToStr(index->ContentSize())+
-                               "\r\nConnection: close\r\nContent-Type: text/html\r\n\r\n");
+               if (extraheaders.empty())
+               {
+                       this->Write("Content-Type: text/html\r\n");
+               }
+               else
+               {
+                       this->Write(extraheaders);
+               }
+               this->Write("Server: InspIRCd/m_httpd.so/1.1\r\nContent-Length: "+ConvToStr(size)+
+                               "\r\nConnection: close\r\n\r\n");
        }
 
        virtual bool OnDataReady()
        {
                char* data = this->Read();
+               std::string request_type;
+               std::string uri;
+               std::string http_version;
+
                /* Check that the data read is a valid pointer and it has some content */
                if (data && *data)
                {
@@ -89,9 +197,36 @@ class HttpSocket : public InspSocket
                        {
                                /* Headers are complete */
                                InternalState = HTTP_SERVE_SEND_DATA;
-                               SendHeaders();
 
-                               this->Write(index->Contents());
+                               headers >> request_type;
+                               headers >> uri;
+                               headers >> http_version;
+
+                               if ((http_version != "HTTP/1.1") && (http_version != "HTTP/1.0"))
+                               {
+                                       SendHeaders(0, 505, "");
+                               }
+                               else
+                               {
+                                       if ((request_type == "GET") && (uri == "/"))
+                                       {
+                                               SendHeaders(index->ContentSize(), 200, "");
+                                               this->Write(index->Contents());
+                                       }
+                                       else
+                                       {
+                                               claimed = false;
+                                               HTTPRequest httpr(request_type,uri,&headers,this,this->GetIP());
+                                               Event e((char*)&httpr, (Module*)HttpModule, "httpd_url");
+                                               e.Send();
+
+                                               if (!claimed)
+                                               {
+                                                       SendHeaders(0, 404, "");
+                                                       log(DEBUG,"Page not claimed, 404");
+                                               }
+                                       }
+                               }
 
                                return false;
                        }
@@ -105,6 +240,13 @@ class HttpSocket : public InspSocket
                        return false;
                }
        }
+
+       void Page(std::stringstream* n, int response, std::string& extraheaders)
+       {
+               log(DEBUG,"Sending page");
+               SendHeaders(n->str().length(), response, extraheaders);
+               this->Write(n->str());
+       }
 };
 
 class ModuleHttp : public Module
@@ -147,6 +289,20 @@ class ModuleHttp : public Module
                CreateListener();
        }
 
+       void OnEvent(Event* event)
+       {
+       }
+
+       char* OnRequest(Request* request)
+       {
+               log(DEBUG,"Got HTTPDocument object");
+               claimed = true;
+               HTTPDocument* doc = (HTTPDocument*)request->GetData();
+               HttpSocket* sock = (HttpSocket*)doc->sock;
+               sock->Page(doc->GetDocument(), doc->GetResponseCode(), doc->GetExtraHeaders());
+               return NULL;
+       }
+
        void Implements(char* List)
        {
                List[I_OnEvent] = List[I_OnRequest] = 1;
@@ -177,7 +333,8 @@ class ModuleHttpFactory : public ModuleFactory
        
        virtual Module * CreateModule(Server* Me)
        {
-               return new ModuleHttp(Me);
+               HttpModule = new ModuleHttp(Me);
+               return HttpModule;
        }
 };