src/modules/m_http_client.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15 #include "httpclient.h"
  16
  17 /* $ModDesc: HTTP client service provider */
  18
  19 class URL
  20 {
  21  public:
  22         std::string url;
  23         std::string protocol, username, password, domain, request;
  24         int port;
  25 };
  26
  27 class HTTPSocket : public BufferedSocket
  28 {
  29  private:
  30         InspIRCd *Server;
  31         class ModuleHTTPClient *Mod;
  32         HTTPClientRequest req;
  33         HTTPClientResponse *response;
  34         URL url;
  35         enum { HTTP_CLOSED, HTTP_REQSENT, HTTP_HEADERS, HTTP_DATA } status;
  36         std::string data;
  37         std::string buffer;
  38
  39  public:
  40         HTTPSocket(InspIRCd *Instance, class ModuleHTTPClient *Mod);
  41         virtual ~HTTPSocket();
  42         virtual bool DoRequest(HTTPClientRequest *req);
  43         virtual bool ParseURL(const std::string &url);
  44         virtual void Connect(const std::string &ip);
  45         virtual bool OnConnected();
  46         virtual bool OnDataReady();
  47         virtual void OnClose();
  48 };
  49
  50 class HTTPResolver : public Resolver
  51 {
  52  private:
  53         HTTPSocket *socket;
  54  public:
  55         HTTPResolver(HTTPSocket *socket, InspIRCd *Instance, const string &hostname, bool &cached, Module* me) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, cached, me), socket(socket)
  56         {
  57         }
  58
  59         void OnLookupComplete(const string &result, unsigned int ttl, bool cached, int resultnum = 0)
  60         {
  61                 if (!resultnum)
  62                         socket->Connect(result);
  63         }
  64
  65         void OnError(ResolverError e, const string &errmsg)
  66         {
  67                 if (ServerInstance->SocketCull.find(socket) == ServerInstance->SocketCull.end())
  68                         ServerInstance->SocketCull[socket] = socket;
  69         }
  70 };
  71
  72 typedef vector<HTTPSocket*> HTTPList;
  73
  74 class ModuleHTTPClient : public Module
  75 {
  76  public:
  77         HTTPList sockets;
  78
  79         ModuleHTTPClient(InspIRCd *Me)
  80                 : Module(Me)
  81         {
  82                 Implementation eventlist[] = { I_OnRequest };
  83                 ServerInstance->Modules->Attach(eventlist, this, 1);
  84         }
  85
  86         virtual ~ModuleHTTPClient()
  87         {
  88                 for (HTTPList::iterator i = sockets.begin(); i != sockets.end(); i++)
  89                         delete *i;
  90         }
  91
  92         virtual Version GetVersion()
  93         {
  94                 return Version(1, 0, 0, 0, VF_SERVICEPROVIDER | VF_VENDOR, API_VERSION);
  95         }
  96
  97         void Implements(char* List)
  98         {
  99                 List[I_OnRequest] = 1;
 100         }
 101
 102         char* OnRequest(Request *req)
 103         {
 104                 HTTPClientRequest *httpreq = (HTTPClientRequest *)req;
 105                 if (!strcmp(httpreq->GetId(), HTTP_CLIENT_REQUEST))
 106                 {
 107                         HTTPSocket *sock = new HTTPSocket(ServerInstance, this);
 108                         sock->DoRequest(httpreq);
 109                         // No return value
 110                 }
 111                 return NULL;
 112         }
 113 };
 114
 115 HTTPSocket::HTTPSocket(InspIRCd *Instance, ModuleHTTPClient *Mod)
 116                 : BufferedSocket(Instance), Server(Instance), Mod(Mod), status(HTTP_CLOSED)
 117 {
 118         this->ClosePending = false;
 119         this->port = 80;
 120 }
 121
 122 HTTPSocket::~HTTPSocket()
 123 {
 124         Close();
 125         for (HTTPList::iterator i = Mod->sockets.begin(); i != Mod->sockets.end(); i++)
 126         {
 127                 if (*i == this)
 128                 {
 129                         Mod->sockets.erase(i);
 130                         break;
 131                 }
 132         }
 133 }
 134
 135 bool HTTPSocket::DoRequest(HTTPClientRequest *req)
 136 {
 137         /* Tweak by brain - we take a copy of this,
 138          * so that the caller doesnt need to leave
 139          * pointers knocking around, less chance of
 140          * a memory leak.
 141          */
 142         this->req = *req;
 143
 144         if (!ParseURL(this->req.GetURL()))
 145                 return false;
 146
 147         this->port = url.port;
 148         strlcpy(this->host, url.domain.c_str(), MAXBUF);
 149
 150         in_addr addy1;
 151 #ifdef IPV6
 152         in6_addr addy2;
 153         if ((inet_aton(this->host, &addy1) > 0) || (inet_pton(AF_INET6, this->host, &addy2) > 0))
 154 #else
 155         if (inet_aton(this->host, &addy1) > 0)
 156 #endif
 157         {
 158                 bool cached;
 159                 HTTPResolver* r = new HTTPResolver(this, Server, url.domain, cached, (Module*)Mod);
 160                 Instance->AddResolver(r, cached);
 161                 return true;
 162         }
 163         else
 164         {
 165                 this->Connect(url.domain);
 166         }
 167
 168         return true;
 169 }
 170
 171 bool HTTPSocket::ParseURL(const std::string &iurl)
 172 {
 173         url.url = iurl;
 174         url.port = 80;
 175         url.protocol = "http";
 176
 177         irc::sepstream tokenizer(iurl, '/');
 178
 179         for (int p = 0;; p++)
 180         {
 181                 std::string part;
 182                 if (!tokenizer.GetToken(part))
 183                         break;
 184
 185                 if ((p == 0) && (part[part.length() - 1] == ':'))
 186                 {
 187                         // Protocol ('http:')
 188                         url.protocol = part.substr(0, part.length() - 1);
 189                 }
 190                 else if ((p == 1) && (part.empty()))
 191                 {
 192                         continue;
 193                 }
 194                 else if (url.domain.empty())
 195                 {
 196                         // Domain part: [user[:pass]@]domain[:port]
 197                         std::string::size_type usrpos = part.find('@');
 198                         if (usrpos != std::string::npos)
 199                         {
 200                                 // Have a user (and possibly password) part
 201                                 std::string::size_type ppos = part.find(':');
 202                                 if ((ppos != std::string::npos) && (ppos < usrpos))
 203                                 {
 204                                         // Have password too
 205                                         url.password = part.substr(ppos + 1, usrpos - ppos - 1);
 206                                         url.username = part.substr(0, ppos);
 207                                 }
 208                                 else
 209                                 {
 210                                         url.username = part.substr(0, usrpos);
 211                                 }
 212
 213                                 part = part.substr(usrpos + 1);
 214                         }
 215
 216                         std::string::size_type popos = part.rfind(':');
 217                         if (popos != std::string::npos)
 218                         {
 219                                 url.port = atoi(part.substr(popos + 1).c_str());
 220                                 url.domain = part.substr(0, popos);
 221                         }
 222                         else
 223                         {
 224                                 url.domain = part;
 225                         }
 226                 }
 227                 else
 228                 {
 229                         // Request (part of it)..
 230                         url.request.append("/");
 231                         url.request.append(part);
 232                 }
 233         }
 234
 235         if (url.request.empty())
 236                 url.request = "/";
 237
 238         if ((url.domain.empty()) || (!url.port) || (url.protocol.empty()))
 239         {
 240                 Instance->Log(DEFAULT, "Invalid URL (%s): Missing required value", iurl.c_str());
 241                 return false;
 242         }
 243
 244         if (url.protocol != "http")
 245         {
 246                 Instance->Log(DEFAULT, "Invalid URL (%s): Unsupported protocol '%s'", iurl.c_str(), url.protocol.c_str());
 247                 return false;
 248         }
 249
 250         return true;
 251 }
 252
 253 void HTTPSocket::Connect(const string &ip)
 254 {
 255         strlcpy(this->IP, ip.c_str(), MAXBUF);
 256
 257         if (!this->DoConnect())
 258         {
 259                 delete this;
 260         }
 261 }
 262
 263 bool HTTPSocket::OnConnected()
 264 {
 265         std::string request = "GET " + url.request + " HTTP/1.1\r\n";
 266
 267         // Dump headers into the request
 268         HeaderMap headers = req.GetHeaders();
 269
 270         for (HeaderMap::iterator i = headers.begin(); i != headers.end(); i++)
 271                 request += i->first + ": " + i->second + "\r\n";
 272
 273         // The Host header is required for HTTP 1.1 and isn't known when the request is created; if they didn't overload it
 274         // manually, add it here
 275         if (headers.find("Host") == headers.end())
 276                 request += "Host: " + url.domain + "\r\n";
 277
 278         request += "\r\n";
 279
 280         this->status = HTTP_REQSENT;
 281
 282         return this->Write(request);
 283 }
 284
 285 bool HTTPSocket::OnDataReady()
 286 {
 287         char *data = this->Read();
 288
 289         if (!data)
 290         {
 291                 this->Close();
 292                 return false;
 293         }
 294
 295         if (this->status < HTTP_DATA)
 296         {
 297                 std::string line;
 298                 std::string::size_type pos;
 299
 300                 this->buffer += data;
 301                 while ((pos = buffer.find("\r\n")) != std::string::npos)
 302                 {
 303                         line = buffer.substr(0, pos);
 304                         buffer = buffer.substr(pos + 2);
 305                         if (line.empty())
 306                         {
 307                                 this->status = HTTP_DATA;
 308                                 this->data += this->buffer;
 309                                 this->buffer.clear();
 310                                 break;
 311                         }
 312
 313                         if (this->status == HTTP_REQSENT)
 314                         {
 315                                 // HTTP reply (HTTP/1.1 200 msg)
 316                                 char const* data = line.c_str();
 317                                 data += 9;
 318                                 response = new HTTPClientResponse((Module*)Mod, req.GetSource() , url.url, atoi(data), data + 4);
 319                                 this->status = HTTP_HEADERS;
 320                                 continue;
 321                         }
 322
 323                         if ((pos = line.find(':')) != std::string::npos)
 324                         {
 325                                 response->AddHeader(line.substr(0, pos), line.substr(pos + 1));
 326                         }
 327                         else
 328                         {
 329                                 continue;
 330                         }
 331                 }
 332         }
 333         else
 334         {
 335                 this->data += data;
 336         }
 337         return true;
 338 }
 339
 340 void HTTPSocket::OnClose()
 341 {
 342         if (data.empty())
 343                 return; // notification that request failed?
 344
 345         response->data = data;
 346         response->Send();
 347         delete response;
 348 }
 349
 350 MODULE_INIT(ModuleHTTPClient)