public:
HTTPResolver(HTTPSocket *s, InspIRCd *Instance, const std::string &hostname, bool &cached, Module* me) : Resolver(Instance, hostname, DNS_QUERY_FORWARD, cached, me), socket(s)
{
- ServerInstance->Log(DEBUG,">>>>>>>>>>>>>>>>>> HTTPResolver::HTTPResolver <<<<<<<<<<<<<<<");
+ ServerInstance->Logs->Log("m_http_client",DEBUG,">>>>>>>>>>>>>>>>>> HTTPResolver::HTTPResolver <<<<<<<<<<<<<<<");
orig = hostname;
}
void OnLookupComplete(const std::string &result, unsigned int ttl, bool cached, int resultnum = 0)
{
- ServerInstance->Log(DEBUG,"************* HTTPResolver::OnLookupComplete ***************");
+ ServerInstance->Logs->Log("m_http_client",DEBUG,"************* HTTPResolver::OnLookupComplete ***************");
if (!resultnum)
socket->Connect(result);
else
void OnError(ResolverError e, const std::string &errmsg)
{
- ServerInstance->Log(DEBUG,"!!!!!!!!!!!!!!!! HTTPResolver::OnError: %s", errmsg.c_str());
+ ServerInstance->Logs->Log("m_http_client",DEBUG,"!!!!!!!!!!!!!!!! HTTPResolver::OnError: %s", errmsg.c_str());
socket->OnClose();
}
};
}
- char* OnRequest(Request *req)
+ virtual const char* OnRequest(Request *req)
{
HTTPClientRequest *httpreq = (HTTPClientRequest *)req;
if (!strcmp(httpreq->GetId(), HTTP_CLIENT_REQUEST))
}
};
-HTTPSocket::HTTPSocket(InspIRCd *Instance, ModuleHTTPClient *Mod)
- : BufferedSocket(Instance), Server(Instance), Mod(Mod), status(HTTP_CLOSED)
+HTTPSocket::HTTPSocket(InspIRCd *SI, ModuleHTTPClient *m)
+ : BufferedSocket(SI), Server(SI), Mod(m), status(HTTP_CLOSED)
{
- Instance->Log(DEBUG,"HTTPSocket::HTTPSocket");
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::HTTPSocket");
this->port = 80;
response = NULL;
closed = false;
}
}
-bool HTTPSocket::DoRequest(HTTPClientRequest *req)
+bool HTTPSocket::DoRequest(HTTPClientRequest *request)
{
- Instance->Log(DEBUG,"HTTPSocket::DoRequest");
+ 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 = *req;
+ this->req = *request;
if (!ParseURL(this->req.GetURL()))
return false;
this->port = url.port;
strlcpy(this->host, url.domain.c_str(), MAXBUF);
- Instance->Log(DEBUG,"Doing request for %s", url.url.c_str());
+ Instance->Logs->Log("m_http_client",DEBUG,"Doing request for %s", url.url.c_str());
in6_addr s6;
in_addr s4;
bool cached;
HTTPResolver* r = new HTTPResolver(this, Server, url.domain, cached, (Module*)Mod);
Instance->AddResolver(r, cached);
- Instance->Log(DEBUG,"Resolver added, cached=%d", cached);
+ Instance->Logs->Log("m_http_client",DEBUG,"Resolver added, cached=%d", cached);
}
else
Connect(url.domain);
bool HTTPSocket::ParseURL(const std::string &iurl)
{
- Instance->Log(DEBUG,"HTTPSocket::ParseURL %s", iurl.c_str());
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::ParseURL %s", iurl.c_str());
url.url = iurl;
url.port = 80;
url.protocol = "http";
if ((url.domain.empty()) || (!url.port) || (url.protocol.empty()))
{
- Instance->Log(DEFAULT, "Invalid URL (%s): Missing required value", iurl.c_str());
+ Instance->Logs->Log("m_http_client",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());
+ Instance->Logs->Log("m_http_client",DEFAULT, "Invalid URL (%s): Unsupported protocol '%s'", iurl.c_str(), url.protocol.c_str());
return false;
}
{
this->response = new HTTPClientResponse((Module*)Mod, req.GetSource() , url.url, 0, "");
- Instance->Log(DEBUG,"HTTPSocket::Connect(%s) response=%08lx", ip.c_str(), response);
+ 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())
{
- Instance->Log(DEBUG,"DoConnect failed, bailing");
+ Instance->Logs->Log("m_http_client",DEBUG,"DoConnect failed, bailing");
this->Close();
}
}
bool HTTPSocket::OnConnected()
{
- Instance->Log(DEBUG,"HTTPSocket::OnConnected");
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::OnConnected");
std::string request = "GET " + url.request + " HTTP/1.1\r\n";
bool HTTPSocket::OnDataReady()
{
- Instance->Log(DEBUG,"HTTPSocket::OnDataReady() for %s", url.url.c_str());
- 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)
+ if (!sdata)
return false;
if (this->status < HTTP_DATA)
std::string line;
std::string::size_type pos;
- this->buffer += data;
+ this->buffer += sdata;
while ((pos = buffer.find("\r\n")) != std::string::npos)
{
line = buffer.substr(0, pos);
if (this->status == HTTP_REQSENT)
{
// HTTP reply (HTTP/1.1 200 msg)
- char const* data = line.c_str();
- data += 9;
- response->SetResponse(data);
- response->SetData(data + 4);
+ char const* sdata2 = line.c_str();
+ sdata2 += 9;
+ response->SetResponse(sdata2);
+ response->SetData(sdata2 + 4);
this->status = HTTP_HEADERS;
continue;
}
if (!closed)
{
closed = true;
- Instance->Log(DEBUG,"HTTPSocket::OnClose response=%08lx", response);
+ Instance->Logs->Log("m_http_client",DEBUG,"HTTPSocket::OnClose response=%08lx", response);
std::string e;
if (data.empty())
{
- Instance->Log(DEBUG,"Send error");
+ 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;
}
- Instance->Log(DEBUG,"Set data and send, %s", response->GetURL().c_str());
+ Instance->Logs->Log("m_http_client",DEBUG,"Set data and send, %s", response->GetURL().c_str());
response->SetData(data);
response->Send();
delete response;