This needs some general QA-ing. Add support to new parser (introduced in 1.1) for...

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

diff --git a/src/modules/m_http_client.cpp b/src/modules/m_http_client.cpp
index 0034aa246091368925a8042de3b54f0c3da397d5..5ddd6ddbd92a849f770e92fde85dff01c21a63c2 100644 (file)
--- a/src/modules/m_http_client.cpp
+++ b/src/modules/m_http_client.cpp
@@ -1,4 +1,4 @@
-/*       +------------------------------------+
+;/*       +------------------------------------+
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
@@ -59,15 +59,18 @@ class HTTPResolver : public Resolver
  public:
        HTTPResolver(HTTPSocket *socket, InspIRCd *Instance, const string &hostname, bool &cached, Module* me) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, cached, me), socket(socket)
        {
+               ServerInstance->Log(DEBUG,"Resolving "+hostname);
        }
        
        void OnLookupComplete(const string &result, unsigned int ttl, bool cached)
        {
+               ServerInstance->Log(DEBUG,"Resolver done");
                socket->Connect(result);
        }
        
        void OnError(ResolverError e, const string &errmsg)
        {
+               ServerInstance->Log(DEBUG,"Resolver error");
                delete socket;
        }
 };
@@ -142,13 +145,24 @@ bool HTTPSocket::DoRequest(HTTPClientRequest *req)
         */
        this->req = *req;
 
+       Instance->Log(DEBUG,"Request in progress");
+
        if (!ParseURL(this->req.GetURL()))
+       {
+               Instance->Log(DEBUG,"Parse failed");
                return false;
+       }
        
        this->port = url.port;
        strlcpy(this->host, url.domain.c_str(), MAXBUF);
 
-       if (!insp_aton(this->host, &this->addy))
+       in_addr addy1;
+#ifdef IPV6
+       in6_addr addy2;
+       if ((inet_aton(this->host, &addy1) > 0) || (inet_pton(AF_INET6, this->host, &addy2) > 0))
+#else
+       if (inet_aton(this->host, &addy1) > 0)
+#endif
        {
                bool cached;
                HTTPResolver* r = new HTTPResolver(this, Server, url.domain, cached, (Module*)Mod);
@@ -167,60 +181,79 @@ bool HTTPSocket::ParseURL(const std::string &iurl)
 {
        url.url = iurl;
        url.port = 80;
+       url.protocol = "http";
+
+       irc::sepstream tokenizer(iurl, '/');
        
-       // Tokenize by slashes (protocol:, blank, domain, request..)
-       int pos = 0, pstart = 0, pend = 0;
-       
-       for (; ; pend = url.url.find('/', pstart))
+       for (int p = 0;; p++)
        {
-               string part = url.url.substr(pstart, pend);
-
-               switch (pos)
+               std::string part = tokenizer.GetToken();
+               if (part.empty() && tokenizer.StreamEnd())
+                       break;
+               
+               if ((p == 0) && (part[part.length() - 1] == ':'))
                {
-                       case 0:
-                               // Protocol
-                               if (part[part.length()-1] != ':')
-                                       return false;
-                               url.protocol = part.substr(0, part.length() - 1);
-                               break;
-                       case 1:
-                               // Empty, skip
-                               break;
-                       case 2:
-                               // User and password (user:pass@)
-                               string::size_type aend = part.find('@', 0);
-                               if (aend != string::npos)
+                       // Protocol ('http:')
+                       url.protocol = part.substr(0, part.length() - 1);
+               }
+               else if ((p == 1) && (part.empty()))
+               {
+                       continue;
+               }
+               else if (url.domain.empty())
+               {
+                       // Domain part: [user[:pass]@]domain[:port]
+                       std::string::size_type usrpos = part.find('@');
+                       if (usrpos != std::string::npos)
+                       {
+                               // Have a user (and possibly password) part
+                               std::string::size_type ppos = part.find(':');
+                               if ((ppos != std::string::npos) && (ppos < usrpos))
                                {
-                                       // Technically, it is valid to not have a password (username@domain)
-                                       string::size_type usrend = part.find(':', 0);
-                                       
-                                       if ((usrend != string::npos) && (usrend < aend))
-                                               url.password = part.substr(usrend + 1, aend);
-                                       else
-                                               usrend = aend;
-                                       
-                                       url.username = part.substr(0, usrend);
+                                       // Have password too
+                                       url.password = part.substr(ppos + 1, usrpos - ppos - 1);
+                                       url.username = part.substr(0, ppos);
                                }
                                else
-                                       aend = 0;
-                               
-                               // Port (:port)
-                               string::size_type dend = part.find(':', aend);
-                               if (dend != string::npos)
-                                       url.port = atoi(part.substr(dend + 1).c_str());
-
-                               // Domain
-                               url.domain = part.substr(aend + 1, dend);
+                               {
+                                       url.username = part.substr(0, usrpos);
+                               }
                                
-                               // The rest of the string is the request
-                               url.request = url.url.substr(pend);
-                               break;
+                               part = part.substr(usrpos + 1);
+                       }
+                       
+                       std::string::size_type popos = part.rfind(':');
+                       if (popos != std::string::npos)
+                       {
+                               url.port = atoi(part.substr(popos + 1).c_str());
+                               url.domain = part.substr(0, popos);
+                       }
+                       else
+                       {
+                               url.domain = part;
+                       }
                }
-               
-               if (pos++ == 2)
-                       break;
+               else
+               {
+                       // Request (part of it)..
+                       url.request.append("/");
+                       url.request.append(part);
+               }
+       }
+       
+       if (url.request.empty())
+               url.request = "/";
 
-               pstart = pend + 1;
+       if ((url.domain.empty()) || (!url.port) || (url.protocol.empty()))
+       {
+               Instance->Log(DEFAULT, "Invalid URL (%s): Missing required value", iurl.c_str());
+               return false;
+       }
+       
+       if (url.protocol != "http")
+       {
+               Instance->Log(DEFAULT, "Invalid URL (%s): Unsupported protocol '%s'", iurl.c_str(), url.protocol.c_str());
+               return false;
        }
        
        return true;