* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- * E-mail:
- * <brain@chatspike.net>
- * <Craig@chatspike.net>
- *
- * Written by Craig Edwards, Craig McLure, and others.
+ * InspIRCd: (C) 2002-2008 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
+ *
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
-/* Written by Special (john@yarbbles.com) */
-
#include "inspircd.h"
-#include "http.h"
+#include "httpclient.h"
/* $ModDesc: HTTP client service provider */
int port;
};
-class HTTPSocket : public InspSocket
+class HTTPSocket : public BufferedSocket
{
private:
InspIRCd *Server;
class ModuleHTTPClient *Mod;
- HTTPClientRequest *req;
+ HTTPClientRequest req;
HTTPClientResponse *response;
URL url;
enum { HTTP_CLOSED, HTTP_REQSENT, HTTP_HEADERS, HTTP_DATA } status;
std::string data;
+ std::string buffer;
+ bool closed;
public:
HTTPSocket(InspIRCd *Instance, class ModuleHTTPClient *Mod);
{
private:
HTTPSocket *socket;
+ std::string orig;
public:
- HTTPResolver(HTTPSocket *socket, InspIRCd *Instance, const string &hostname) : Resolver(Instance, hostname, DNS_QUERY_FORWARD), socket(socket)
+ HTTPResolver(HTTPSocket *s, InspIRCd *Instance, const std::string &hostname, bool &cached, Module* me) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, cached, me), socket(s)
{
+ ServerInstance->Logs->Log("m_http_client",DEBUG,">>>>>>>>>>>>>>>>>> HTTPResolver::HTTPResolver <<<<<<<<<<<<<<<");
+ orig = hostname;
}
- void OnLookupComplete(const string &result)
+ void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached, int resultnum = 0)
{
- socket->Connect(result);
+ ServerInstance->Logs->Log("m_http_client",DEBUG,"************* HTTPResolver::OnLookupComplete ***************");
+ if (!resultnum)
+ socket->Connect(result);
+ else
+ socket->OnClose();
}
- void OnError(ResolverError e, const string &errmsg)
+ void OnError(ResolverError e, const std::string &errmsg)
{
- delete socket;
+ ServerInstance->Logs->Log("m_http_client",DEBUG,"!!!!!!!!!!!!!!!! HTTPResolver::OnError: %s", errmsg.c_str());
+ socket->OnClose();
}
};
-typedef vector<HTTPSocket*> HTTPList;
+typedef std::vector<HTTPSocket*> HTTPList;
class ModuleHTTPClient : public Module
{
HTTPList sockets;
ModuleHTTPClient(InspIRCd *Me)
- : Module::Module(Me)
+ : Module(Me)
{
+ Implementation eventlist[] = { I_OnRequest };
+ ServerInstance->Modules->Attach(eventlist, this, 1);
}
virtual ~ModuleHTTPClient()
{
for (HTTPList::iterator i = sockets.begin(); i != sockets.end(); i++)
- delete *i;
+ (*i)->Close();
+ ServerInstance->BufferedSocketCull();
}
virtual Version GetVersion()
return Version(1, 0, 0, 0, VF_SERVICEPROVIDER | VF_VENDOR, API_VERSION);
}
- void Implements(char* List)
- {
- List[I_OnRequest] = 1;
- }
-
- char *OnRequest(Request *req)
+
+ virtual const char* OnRequest(Request *req)
{
- HTTPClientRequest *httpreq = (HTTPClientRequest *) req->GetData();
- HTTPSocket *sock = new HTTPSocket(ServerInstance, this);
- sock->DoRequest(httpreq);
- // No return value
+ HTTPClientRequest *httpreq = (HTTPClientRequest *)req;
+ if (!strcmp(httpreq->GetId(), HTTP_CLIENT_REQUEST))
+ {
+ HTTPSocket *sock = new HTTPSocket(ServerInstance, this);
+ sock->DoRequest(httpreq);
+ // No return value
+ }
return NULL;
}
-
- void SendReply(Module *to, HTTPClientResponse *data)
- {
- Request req((char *) data, this, to);
- req.Send();
- }
};
-HTTPSocket::HTTPSocket(InspIRCd *Instance, ModuleHTTPClient *Mod)
- : InspSocket(Instance), Server(Instance), Mod(Mod), status(HTTP_CLOSED)
+HTTPSocket::HTTPSocket(InspIRCd *SI, ModuleHTTPClient *m)
+ : BufferedSocket(SI), Server(SI), Mod(m), status(HTTP_CLOSED)
{
- this->ClosePending = false;
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::HTTPSocket");
this->port = 80;
+ response = NULL;
+ closed = false;
+ timeout_val = 10;
}
HTTPSocket::~HTTPSocket()
}
}
-bool HTTPSocket::DoRequest(HTTPClientRequest *req)
+bool HTTPSocket::DoRequest(HTTPClientRequest *request)
{
- this->req = req;
-
- if (!ParseURL(req->GetURL()))
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::DoRequest");
+ /* Tweak by brain - we take a copy of this,
+ * so that the caller doesnt need to leave
+ * pointers knocking around, less chance of
+ * a memory leak.
+ */
+ this->req = *request;
+
+ if (!ParseURL(this->req.GetURL()))
return false;
this->port = url.port;
strlcpy(this->host, url.domain.c_str(), MAXBUF);
- if (!inet_aton(this->host, &this->addy))
+ Instance->Logs->Log("m_http_client",DEBUG,"Doing request for %s", url.url.c_str());
+
+ in6_addr s6;
+ in_addr s4;
+ /* Doesnt look like an ipv4 or an ipv6 address */
+ if ((inet_pton(AF_INET6, url.domain.c_str(), &s6) < 1) && (inet_pton(AF_INET, url.domain.c_str(), &s4) < 1))
{
- new HTTPResolver(this, Server, url.domain);
- return true;
+ bool cached;
+ HTTPResolver* r = new HTTPResolver(this, Server, url.domain, cached, (Module*)Mod);
+ Instance->AddResolver(r, cached);
+ Instance->Logs->Log("m_http_client",DEBUG,"Resolver added, cached=%d", cached);
}
else
- {
- this->Connect(url.domain);
- }
+ Connect(url.domain);
return true;
}
bool HTTPSocket::ParseURL(const std::string &iurl)
{
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::ParseURL %s", iurl.c_str());
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);
+ std::string part;
+ if (!tokenizer.GetToken(part))
+ break;
- switch (pos)
+ 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->Logs->Log("m_http_client",DEFAULT, "Invalid URL (%s): Missing required value", iurl.c_str());
+ return false;
+ }
+
+ if (url.protocol != "http")
+ {
+ Instance->Logs->Log("m_http_client",DEFAULT, "Invalid URL (%s): Unsupported protocol '%s'", iurl.c_str(), url.protocol.c_str());
+ return false;
}
return true;
}
-void HTTPSocket::Connect(const string &ip)
+void HTTPSocket::Connect(const std::string &ip)
{
+ this->response = new HTTPClientResponse((Module*)Mod, req.GetSource() , url.url, 0, "");
+
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::Connect(%s) response=%08lx", ip.c_str(), response);
strlcpy(this->IP, ip.c_str(), MAXBUF);
-
+ strlcpy(this->host, ip.c_str(), MAXBUF);
+
if (!this->DoConnect())
{
- Server->Log(DEBUG, "Unable to connect HTTPSocket to %s", this->host);
- delete this;
+ Instance->Logs->Log("m_http_client",DEBUG,"DoConnect failed, bailing");
+ this->Close();
}
}
bool HTTPSocket::OnConnected()
{
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::OnConnected");
+
std::string request = "GET " + url.request + " HTTP/1.1\r\n";
// Dump headers into the request
- HeaderMap headers = req->GetHeaders();
+ HeaderMap headers = req.GetHeaders();
for (HeaderMap::iterator i = headers.begin(); i != headers.end(); i++)
request += i->first + ": " + i->second + "\r\n";
bool HTTPSocket::OnDataReady()
{
- char *data = this->Read();
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::OnDataReady() for %s", url.url.c_str());
+ const char *sdata = this->Read();
- if (!data)
- {
- this->Close();
+ if (!sdata)
return false;
- }
-
- // Needs buffering for incomplete reads..
- char *lend;
-
+
if (this->status < HTTP_DATA)
{
- while ((lend = strstr(data, "\r\n")) != NULL)
+ std::string line;
+ std::string::size_type pos;
+
+ this->buffer += sdata;
+ while ((pos = buffer.find("\r\n")) != std::string::npos)
{
- if (strncmp(data, "\r\n", 2) == 0)
+ line = buffer.substr(0, pos);
+ buffer = buffer.substr(pos + 2);
+ if (line.empty())
{
this->status = HTTP_DATA;
+ this->data += this->buffer;
+ this->buffer.clear();
break;
}
-
- *lend = '\0';
-
+
if (this->status == HTTP_REQSENT)
{
// HTTP reply (HTTP/1.1 200 msg)
- data += 9;
- response = new HTTPClientResponse(url.url, atoi(data), data + 4);
+ char const* sdata2 = line.c_str();
+ sdata2 += 9;
+ response->SetResponse(sdata2);
+ response->SetData(sdata2 + 4);
this->status = HTTP_HEADERS;
continue;
}
- char *hdata = strchr(data, ':');
-
- if (!hdata)
+ if ((pos = line.find(':')) != std::string::npos)
+ {
+ response->AddHeader(line.substr(0, pos), line.substr(pos + 1));
+ }
+ else
+ {
continue;
-
- *hdata = '\0';
-
- response->AddHeader(data, hdata + 2);
-
- data = lend + 2;
+ }
}
}
-
- this->data += data;
+ else
+ {
+ this->data += data;
+ }
return true;
}
void HTTPSocket::OnClose()
{
- if (!data.length())
+ if (!closed)
{
- Server->Log(DEBUG, "HTTP socket closed unexpectedly (no content recieved)");
- return;
- }
- Server->Log(DEBUG, "Got file from HTTP successfully");
- response->data = data;
- Mod->SendReply(req->GetSrc(), response);
-}
+ closed = true;
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::OnClose response=%08lx", response);
+ std::string e;
+ if (data.empty())
+ {
+ Instance->Logs->Log("m_http_client",DEBUG,"Send error");
+ HTTPClientError* err = new HTTPClientError((Module*)Mod, req.GetSource(), req.GetURL(), 0);
+ err->Send();
+ delete err;
+ return;
+ }
-class ModuleHTTPClientFactory : public ModuleFactory
-{
- public:
- ModuleHTTPClientFactory()
- {
- }
-
- ~ModuleHTTPClientFactory()
- {
+ Instance->Logs->Log("m_http_client",DEBUG,"Set data and send, %s", response->GetURL().c_str());
+ response->SetData(data);
+ response->Send();
+ delete response;
}
-
- Module *CreateModule(InspIRCd* Me)
- {
- return new ModuleHTTPClient(Me);
- }
-};
-
-extern "C" void *init_module(void)
-{
- return new ModuleHTTPClientFactory;
}
+MODULE_INIT(ModuleHTTPClient)