Poco::AutoPtr<Poco::XML::Document> Twitter::invoke(const std::string& httpMethod, const std::string& twitterMethod, Poco::Net::HTMLForm& form)
{
// Create the request URI.
// We use the XML version of the Twitter API.
Poco::URI uri(_uri + twitterMethod + ".xml");
std::string path(uri.getPath());
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
Poco::Net::HTTPRequest req(httpMethod, path, Poco::Net::HTTPMessage::HTTP_1_1);
// Add username and password (HTTP basic authentication) to the request.
Poco::Net::HTTPBasicCredentials cred(_username, _password);
cred.authenticate(req);
// Send the request.
form.prepareSubmit(req);
std::ostream& ostr = session.sendRequest(req);
form.write(ostr);
// Receive the response.
Poco::Net::HTTPResponse res;
std::istream& rs = session.receiveResponse(res);
// Create a DOM document from the response.
Poco::XML::DOMParser parser;
parser.setFeature(Poco::XML::DOMParser::FEATURE_FILTER_WHITESPACE, true);
parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
Poco::XML::InputSource source(rs);
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&source);
// If everything went fine, return the XML document.
// Otherwise look for an error message in the XML document.
if (res.getStatus() == Poco::Net::HTTPResponse::HTTP_OK)
{
return pDoc;
}
else
{
std::string error(res.getReason());
Poco::AutoPtr<Poco::XML::NodeList> pList = pDoc->getElementsByTagName("error");
if (pList->length() > 0)
{
error += ": ";
error += pList->item(0)->innerText();
}
throw Poco::ApplicationException("Twitter Error", error);
}
}
void HTTPServerTest::testLoleafletPost()
{
std::unique_ptr<Poco::Net::HTTPClientSession> session(helpers::createSession(_uri));
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_POST, "/loleaflet/dist/loleaflet.html");
Poco::Net::HTMLForm form;
form.set("access_token", "2222222222");
form.prepareSubmit(request);
std::ostream& ostr = session->sendRequest(request);
form.write(ostr);
Poco::Net::HTTPResponse response;
std::istream& rs = session->receiveResponse(response);
CPPUNIT_ASSERT_EQUAL(Poco::Net::HTTPResponse::HTTP_OK, response.getStatus());
std::string html;
Poco::StreamCopier::copyToString(rs, html);
CPPUNIT_ASSERT(html.find(form["access_token"]) != std::string::npos);
CPPUNIT_ASSERT(html.find(_uri.getHost()) != std::string::npos);
}
void HTTPWSTest::testBadRequest()
{
try
{
// Load a document and get its status.
const std::string documentURL = "file:///fake.doc";
Poco::Net::HTTPResponse response;
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, documentURL);
#if ENABLE_SSL
Poco::Net::HTTPSClientSession session(_uri.getHost(), _uri.getPort());
#else
Poco::Net::HTTPClientSession session(_uri.getHost(), _uri.getPort());
#endif
// This should result in Bad Request, but results in:
// WebSocket Exception: Missing Sec-WebSocket-Key in handshake request
// So Service Unavailable is returned.
request.set("Connection", "Upgrade");
request.set("Upgrade", "websocket");
request.set("Sec-WebSocket-Version", "13");
request.set("Sec-WebSocket-Key", "");
request.setChunkedTransferEncoding(false);
session.setKeepAlive(true);
session.sendRequest(request);
session.receiveResponse(response);
CPPUNIT_ASSERT(response.getStatus() == Poco::Net::HTTPResponse::HTTPResponse::HTTP_SERVICE_UNAVAILABLE);
}
catch (const Poco::Exception& exc)
{
CPPUNIT_FAIL(exc.displayText());
}
}
/**
* Stream the contents of a file to a given URL.
* @param fileContents :: The contents of the file to publish.
* @param uploadURL :: The REST URL to stream the data from the file to.
*/
void CatalogPublish::publish(std::istream &fileContents,
const std::string &uploadURL) {
try {
Poco::URI uri(uploadURL);
std::string path(uri.getPathAndQuery());
Poco::SharedPtr<Poco::Net::InvalidCertificateHandler> certificateHandler =
new Poco::Net::AcceptCertificateHandler(true);
// Currently do not use any means of authentication. This should be updated
// IDS has signed certificate.
const Poco::Net::Context::Ptr context =
new Poco::Net::Context(Poco::Net::Context::CLIENT_USE, "", "", "",
Poco::Net::Context::VERIFY_NONE);
// Create a singleton for holding the default context. E.g. any future
// requests to publish are made to this certificate and context.
Poco::Net::SSLManager::instance().initializeClient(NULL, certificateHandler,
context);
Poco::Net::HTTPSClientSession session(uri.getHost(), uri.getPort(),
context);
// Send the HTTP request, and obtain the output stream to write to. E.g. the
// data to publish to the server.
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_PUT, path,
Poco::Net::HTTPMessage::HTTP_1_1);
// Sets the encoding type of the request. This enables us to stream data to
// the server.
request.setChunkedTransferEncoding(true);
std::ostream &os = session.sendRequest(request);
// Copy data from the input stream to the server (request) output stream.
Poco::StreamCopier::copyStream(fileContents, os);
// Close the request by requesting a response.
Poco::Net::HTTPResponse response;
// Store the response for use IF an error occurs (e.g. 404).
std::istream &responseStream = session.receiveResponse(response);
// Obtain the status returned by the server to verify if it was a success.
Poco::Net::HTTPResponse::HTTPStatus HTTPStatus = response.getStatus();
// The error message returned by the IDS (if one exists).
std::string IDSError =
CatalogAlgorithmHelper().getIDSError(HTTPStatus, responseStream);
// Cancel the algorithm and display the message if it exists.
if (!IDSError.empty()) {
// As an error occurred we must cancel the algorithm.
// We cannot throw an exception here otherwise it is caught below as
// Poco::Exception catches runtimes,
// and then the I/O error is thrown as it is generated above first.
this->cancel();
// Output an appropriate error message from the JSON object returned by
// the IDS.
g_log.error(IDSError);
}
} catch (Poco::Net::SSLException &error) {
throw std::runtime_error(error.displayText());
}
// This is bad, but is needed to catch a POCO I/O error.
// For more info see comments (of I/O error) in CatalogDownloadDataFiles.cpp
catch (Poco::Exception &) {
}
}
void ServerAccess::masksReady(std::string uuid, std::string message)
{
Poco::URI uri(server_address + "/api/calibrations/" + uuid + "/masksReady");
//std::string url = server_address + "/api/screens";
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
//prepare path
std::string path(uri.getPath());
//prepare and send request
std::string reqBody(message);
Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_POST, path, Poco::Net::HTTPMessage::HTTP_1_1);
req.setContentType("application/json");
req.setContentLength(reqBody.length());
req.setKeepAlive(true);
std::ostream& oustr = session.sendRequest(req);
//oustr << results;
oustr << reqBody;
req.write(std::cout);
//get response
Poco::Net::HTTPResponse res;
std::cout << res.getStatus() << res.getReason() << std::endl;
std::istream &is = session.receiveResponse(res);
Poco::StreamCopier::copyStream(is, std::cout);
}
void LocalPortForwarder::forward(Poco::Net::StreamSocket& socket)
{
if (_logger.debug())
{
_logger.debug(Poco::format("Local connection accepted, creating forwarding connection to %s, remote port %hu", _remoteURI.toString(), _remotePort));
}
try
{
std::string path(_remoteURI.getPathEtc());
if (path.empty()) path = "/";
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_POST, path, Poco::Net::HTTPRequest::HTTP_1_1);
request.set(SEC_WEBSOCKET_PROTOCOL, WEBTUNNEL_PROTOCOL);
request.set(X_WEBTUNNEL_REMOTEPORT, Poco::NumberFormatter::format(_remotePort));
Poco::Net::HTTPResponse response;
Poco::SharedPtr<Poco::Net::WebSocket> pWebSocket = _pWebSocketFactory->createWebSocket(_remoteURI, request, response);
if (response.get(SEC_WEBSOCKET_PROTOCOL, "") != WEBTUNNEL_PROTOCOL)
{
_logger.error("The remote host does not support the WebTunnel protocol.");
pWebSocket->shutdown(Poco::Net::WebSocket::WS_PROTOCOL_ERROR);
pWebSocket->close();
socket.close();
return;
}
_pDispatcher->addSocket(socket, new StreamSocketToWebSocketForwarder(_pDispatcher, pWebSocket), _localTimeout);
_pDispatcher->addSocket(*pWebSocket, new WebSocketToStreamSocketForwarder(_pDispatcher, socket), _remoteTimeout);
}
catch (Poco::Exception& exc)
{
_logger.error(Poco::format("Failed to open forwarding connection: %s", exc.displayText()));
socket.close();
}
}
bool verify(const std::string& token) override
{
const std::string url = _authVerifyUrl + token;
Log::debug("Verifying authorization token from: " + url);
Poco::URI uri(url);
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, url, Poco::Net::HTTPMessage::HTTP_1_1);
Poco::Net::HTTPResponse response;
session.sendRequest(request);
std::istream& rs = session.receiveResponse(response);
Log::info() << "Status: " << response.getStatus() << " " << response.getReason() << Log::end;
std::string reply(std::istreambuf_iterator<char>(rs), {});
Log::info("Response: " + reply);
//TODO: Parse the response.
/*
// This is used for the demo site.
const auto lastLogTime = std::strtoul(reply.c_str(), nullptr, 0);
if (lastLogTime < 1)
{
//TODO: Redirect to login page.
return;
}
*/
return true;
}
void STEAMGET::run()
{
response = 0;
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, path, Poco::Net::HTTPMessage::HTTP_1_1);
session->sendRequest(request);
#ifdef TESTING
extension_ptr->console->info("{0}", path);
#endif
#ifdef DEBUG_LOGGING
extension_ptr->logger->info("{0}", path);
#endif
Poco::Net::HTTPResponse res;
if (res.getStatus() == Poco::Net::HTTPResponse::HTTP_OK)
{
try
{
std::istream &is = session->receiveResponse(res);
boost::property_tree::read_json(is, *pt);
response = 1;
}
catch (boost::property_tree::json_parser::json_parser_error &e)
{
#ifdef TESTING
extension_ptr->console->error("extDB2: Steam: Parsing Error Message: {0}, URI: {1}", e.message(), path);
#endif
extension_ptr->logger->error("extDB2: Steam: Parsing Error Message: {0}, URI: {1}", e.message(), path);
response = -1;
}
}
}
bool myClientInteractor::sendRequest(Poco::Net::HTTPClientSession& session, Poco::Net::HTTPRequest& request, Poco::Net::HTTPResponse& response){
//tracker->stringify(std::cout, 0);
try{
str.clear();
tracker->stringify(str, 0);
str >> json;
//std::cout << "Sending: " << json << std::endl;
std::cout << response.getStatus() << " " << response.getReason() << std::endl;
if (response.getStatus() != Poco::Net::HTTPResponse::HTTP_UNAUTHORIZED)
{
std::ostream& os = session.sendRequest(request);
//std::cout << "HERE NO PROBLEMS!!" << std::endl;
os << json;
return true;
}
else
{
//std::cout << "NULL!!!!" << std::endl;
Poco::NullOutputStream null;
//StreamCopier::copyStream(rs, null);
return false;
}
}catch(Exception& exc)
{
std::cerr << exc.displayText() << std::endl;
return 1;
}
}
void HTTPServerTest::testDiscovery()
{
std::unique_ptr<Poco::Net::HTTPClientSession> session(helpers::createSession(_uri));
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, "/hosting/discovery");
session->sendRequest(request);
Poco::Net::HTTPResponse response;
session->receiveResponse(response);
CPPUNIT_ASSERT_EQUAL(Poco::Net::HTTPResponse::HTTP_OK, response.getStatus());
CPPUNIT_ASSERT_EQUAL(std::string("text/xml"), response.getContentType());
}
bool sendCommandJSON(const std::string & method, Poco::Dynamic::Var & output, const std::vector<Poco::Dynamic::Var> & params = std::vector<Poco::Dynamic::Var>())
{
// Create request
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_POST, "/jsonrpc");
// Authorization
request.set("Authorization", "Basic bnpiZ2V0OnRlZ2J6bg==");
// Create body
Poco::Dynamic::Var body = Poco::Dynamic::Struct<std::string>();
body["method"] = method;
body["id"] = "sendCommandJSON";
std::vector<Poco::Dynamic::Var> params_;
params_.push_back("callback");
for (std::vector<Poco::Dynamic::Var>::const_iterator it = params.begin(); it != params.end(); ++it)
{
params_.push_back(*it);
}
body["params"] = params_;
std::string body_ = MyVideoCollection::JSON::stringify(body);
request.setContentLength(body_.length());
// Send request
Poco::Net::HTTPClientSession session("127.0.0.1", port_);
session.sendRequest(request) << body_ << std::flush;
// Receive response
Poco::Net::HTTPResponse response;
std::istream & responseStream = session.receiveResponse(response);
std::size_t bytes = response.getContentLength();
std::stringstream response_;
while (bytes > 0 && responseStream.good())
{
char buf[4096];
responseStream.read(buf, std::min(bytes, (std::size_t)4096));
std::size_t gcount = responseStream.gcount();
bytes -= gcount;
response_ << std::string(buf, gcount);
}
// Parse JSON
output = MyVideoCollection::JSON::parse(response_);
// Result?
if (!output.isStruct())
{
output.empty();
return false;
}
output = output["result"];
return true;
}
void ForecastSensor::parse() {
r.clear();
try {
std::cout << "get url: " << url << std::endl;
//http://www.yr.no/place/Czech_Republic/Central_Bohemia/%C4%8Cerven%C3%A9_Pe%C4%8Dky/forecast_hour_by_hour.xml
Poco::URI uri(url);
std::string path(uri.getPathAndQuery());
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, path, Poco::Net::HTTPMessage::HTTP_1_0);
Poco::Net::HTTPResponse response;
session.sendRequest(request);
std::istream& rs = session.receiveResponse(response);
std::cout << response.getStatus() << " " << response.getReason() << std::endl;
if (response.getStatus() != Poco::Net::HTTPResponse::HTTP_OK) {
throw Poco::Exception("Cannot get remote data");
}
//Poco::StreamCopier::copyStream(rs, std::cout);
Poco::XML::InputSource src(rs);
ForecastParser handler;
handler.Forecast += Poco::delegate(this, &ForecastSensor::onData);
Poco::XML::SAXParser parser;
parser.setContentHandler(&handler);
try {
std::cout << "parse" << std::endl;
parser.parse(&src);
} catch (Poco::Exception& e) {
std::cerr << e.displayText() << std::endl;
}
handler.Forecast -= Poco::delegate(this, &ForecastSensor::onData);
} catch (Poco::Exception& exc) {
std::cerr << exc.displayText() << std::endl;
}
}
void FileServerRequestHandler::preprocessAdminFile(const HTTPRequest& request,const std::shared_ptr<StreamSocket>& socket)
{
Poco::Net::HTTPResponse response;
if (!LOOLWSD::AdminEnabled)
throw Poco::FileAccessDeniedException("Admin console disabled");
if (!FileServerRequestHandler::isAdminLoggedIn(request, response))
throw Poco::Net::NotAuthenticatedException("Invalid admin login");
static const std::string scriptJS("<script src=\"%s/loleaflet/" LOOLWSD_VERSION_HASH "/%s.js\"></script>");
static const std::string footerPage("<div class=\"footer navbar-fixed-bottom text-info text-center\"><strong>Key:</strong> %s <strong>Expiry Date:</strong> %s</div>");
const std::string relPath = getRequestPathname(request);
LOG_DBG("Preprocessing file: " << relPath);
std::string adminFile = *getUncompressedFile(relPath);
std::string brandJS(Poco::format(scriptJS, LOOLWSD::ServiceRoot, std::string(BRANDING)));
std::string brandFooter;
#if ENABLE_SUPPORT_KEY
const auto& config = Application::instance().config();
const std::string keyString = config.getString("support_key", "");
SupportKey key(keyString);
if (!key.verify() || key.validDaysRemaining() <= 0)
{
brandJS = Poco::format(scriptJS, std::string(BRANDING_UNSUPPORTED));
brandFooter = Poco::format(footerPage, key.data(), Poco::DateTimeFormatter::format(key.expiry(), Poco::DateTimeFormat::RFC822_FORMAT));
}
#endif
Poco::replaceInPlace(adminFile, std::string("<!--%BRANDING_JS%-->"), brandJS);
Poco::replaceInPlace(adminFile, std::string("<!--%FOOTER%-->"), brandFooter);
Poco::replaceInPlace(adminFile, std::string("%VERSION%"), std::string(LOOLWSD_VERSION_HASH));
Poco::replaceInPlace(adminFile, std::string("%SERVICE_ROOT%"), LOOLWSD::ServiceRoot);
// Ask UAs to block if they detect any XSS attempt
response.add("X-XSS-Protection", "1; mode=block");
// No referrer-policy
response.add("Referrer-Policy", "no-referrer");
response.add("X-Content-Type-Options", "nosniff");
response.set("User-Agent", HTTP_AGENT_STRING);
response.set("Date", Poco::DateTimeFormatter::format(Poco::Timestamp(), Poco::DateTimeFormat::HTTP_FORMAT));
response.setContentType("text/html");
response.setChunkedTransferEncoding(false);
std::ostringstream oss;
response.write(oss);
oss << adminFile;
socket->send(oss.str());
}
void HTTPServerTest::testScriptsAndLinksGet()
{
std::unique_ptr<Poco::Net::HTTPClientSession> session(helpers::createSession(_uri));
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, "/loleaflet/dist/loleaflet.html");
session->sendRequest(request);
Poco::Net::HTTPResponse response;
std::istream& rs = session->receiveResponse(response);
CPPUNIT_ASSERT_EQUAL(Poco::Net::HTTPResponse::HTTP_OK, response.getStatus());
std::string html;
Poco::StreamCopier::copyToString(rs, html);
Poco::RegularExpression script("<script.*?src=\"(.*?)\"");
assertHTTPFilesExist(_uri, script, html, "application/javascript");
Poco::RegularExpression link("<link.*?href=\"(.*?)\"");
assertHTTPFilesExist(_uri, link, html);
}
void HTTPServerTest::testLoleafletGet()
{
std::unique_ptr<Poco::Net::HTTPClientSession> session(helpers::createSession(_uri));
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, "/loleaflet/dist/loleaflet.html?access_token=111111111");
Poco::Net::HTMLForm param(request);
session->sendRequest(request);
Poco::Net::HTTPResponse response;
std::istream& rs = session->receiveResponse(response);
CPPUNIT_ASSERT_EQUAL(Poco::Net::HTTPResponse::HTTP_OK, response.getStatus());
CPPUNIT_ASSERT_EQUAL(std::string("text/html"), response.getContentType());
std::string html;
Poco::StreamCopier::copyToString(rs, html);
CPPUNIT_ASSERT(html.find(param["access_token"]) != std::string::npos);
CPPUNIT_ASSERT(html.find(_uri.getHost()) != std::string::npos);
CPPUNIT_ASSERT(html.find(std::string(LOOLWSD_VERSION_HASH)) != std::string::npos);
}
vector<string> ofxLoadStrings(string url) {
using Poco::URI;
URI uri(url);
if (uri.isRelative()) {
string filename = uri.getPathAndQuery();
vector<string> lines;
filename = ofToDataPath(filename);
if (!ofxFileExists(filename)) { ofLogError() << "ofxLoadStrings: File not found: " << filename; return lines; }
ifstream f(filename.c_str(),ios::in);
string line;
while (getline(f,line)) lines.push_back(ofxTrimStringRight(line));
f.close();
return lines;
} else {
try {
string str;
Poco::Net::HTTPClientSession session(uri.getHost());
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, uri.getPathAndQuery(), Poco::Net::HTTPMessage::HTTP_1_1);
vector<string> usernamePassword = ofSplitString(uri.getUserInfo(),":");
if (usernamePassword.size()==2) {
Poco::Net::HTTPBasicCredentials auth(usernamePassword[0],usernamePassword[1]);
auth.authenticate(request);
}
session.sendRequest(request);
Poco::Net::HTTPResponse response;
istream& rs = session.receiveResponse(response);
if (response.getStatus() == 200) {
Poco::StreamCopier::copyToString(rs, str);
return ofSplitString(str,"\n",true,true);
} else {
ofLogError() << ("ofxLoadStrings: HTTP Error " + ofxToString(response.getStatus()));
vector<string> lines;
return lines;
}
} catch (Poco::Exception &e) {
ofxExit("ofxLoadStrings: Problem loading data: " + e.displayText());
}
}
}
bool doRequest(Poco::Net::HTTPClientSession & session, Poco::Net::HTTPRequest & request, Poco::Net::HTTPResponse & response)
{
session.sendRequest(request);
std::istream& rs = session.receiveResponse(response);
std::cout << response.getStatus() << " " << response.getReason() << std::endl;
if (response.getStatus() != Poco::Net::HTTPResponse::HTTP_UNAUTHORIZED)
{
//std::ofstream ofs("Poco_banner.jpg", std::fstream::binary);
//StreamCopier::copyStream(rs, ofs);
// Print to standard output
cout << "RECEIVED:" << endl;
std::copy(std::istream_iterator<char>(rs), std::istream_iterator<char>(), std::ostream_iterator<char>(std::cout) );
cout << endl;
return true;
}
else
{
//it went wrong ?
return false;
}
}
int GitHubApiHelper::processAnonymousRequest(
const Poco::Net::HTTPResponse &response, Poco::URI &uri,
std::ostream &responseStream) {
if (isAuthenticated()) {
g_log.debug("Repeating API call anonymously\n");
removeHeader("Authorization");
return this->sendRequest(uri.toString(), responseStream);
} else {
g_log.warning("Authentication failed and anonymous access refused\n");
return response.getStatus();
}
}
std::vector <std::string> ServerAccess::getScreenIds()
{
std::vector<std::string> screenIds;
Poco::URI uri(server_address + "/api/screens");
//std::string url = server_address + "/api/screens";
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
//prepare path
std::string path(uri.getPath());
//prepare and send request
Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, path, Poco::Net::HTTPMessage::HTTP_1_1);
session.sendRequest(req);
//get response
Poco::Net::HTTPResponse res;
std::cout << res.getStatus() << res.getReason() << std::endl;
std::istream &is = session.receiveResponse(res);
std::string response_body;
Poco::StreamCopier::copyToString(is, response_body);
//Parsing
rapidjson::Document d;
d.Parse(response_body.c_str());
assert(d.IsObject());
assert(d.HasMember("screens"));
{
const rapidjson::Value& screens = d["screens"];
assert(screens.IsArray());
for (rapidjson::Value::ConstValueIterator itr = screens.Begin(); itr != screens.End(); ++itr) {
screenIds.push_back(itr->GetString());
}
}
return screenIds;
}
//TODO: This MUST be done over TLS to protect the token.
bool getAccessToken(const std::string& authorizationCode) override
{
std::string url = _tokenEndPoint
+ "?client_id=" + _clientId
+ "&client_secret=" + _clientSecret
+ "&grant_type=authorization_code"
+ "&code=" + authorizationCode;
// + "&redirect_uri="
Poco::URI uri(url);
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_POST, url, Poco::Net::HTTPMessage::HTTP_1_1);
Poco::Net::HTTPResponse response;
session.sendRequest(request);
std::istream& rs = session.receiveResponse(response);
Log::info() << "Status: " << response.getStatus() << " " << response.getReason() << Log::end;
std::string reply(std::istreambuf_iterator<char>(rs), {});
Log::info("Response: " + reply);
//TODO: Parse the token.
return true;
}
void GitHubApiHelper::processResponseHeaders(
const Poco::Net::HTTPResponse &res) {
// get github api rate limit information if available;
int rateLimitRemaining = 0;
int rateLimitLimit;
DateAndTime rateLimitReset;
try {
rateLimitLimit =
boost::lexical_cast<int>(res.get("X-RateLimit-Limit", "-1"));
rateLimitRemaining =
boost::lexical_cast<int>(res.get("X-RateLimit-Remaining", "-1"));
rateLimitReset.set_from_time_t(
boost::lexical_cast<int>(res.get("X-RateLimit-Reset", "0")));
} catch (boost::bad_lexical_cast const &) {
rateLimitLimit = -1;
}
if (rateLimitLimit > -1) {
g_log.debug() << "GitHub API " << rateLimitRemaining << " of "
<< rateLimitLimit << " calls left. Resets at "
<< rateLimitReset.toSimpleString() << " GMT\n";
}
}
/** Process any HTTP errors states.
@param res : The http response
@param rs : The iutput stream from the response
@param url : The url originally called
@exception Mantid::Kernel::Exception::InternetError : Coded for the failure
state.
*/
int InternetHelper::processErrorStates(const Poco::Net::HTTPResponse &res,
std::istream &rs,
const std::string &url) {
int retStatus = res.getStatus();
g_log.debug() << "Answer from web: " << res.getStatus() << " "
<< res.getReason() << std::endl;
// get github api rate limit information if available;
int rateLimitRemaining;
DateAndTime rateLimitReset;
try {
rateLimitRemaining =
boost::lexical_cast<int>(res.get("X-RateLimit-Remaining", "-1"));
rateLimitReset.set_from_time_t(
boost::lexical_cast<int>(res.get("X-RateLimit-Reset", "0")));
} catch (boost::bad_lexical_cast const &) {
rateLimitRemaining = -1;
}
if (retStatus == HTTP_OK) {
throw Exception::InternetError("Response was ok, processing should never "
"have entered processErrorStates",
retStatus);
} else if (retStatus == HTTP_FOUND) {
throw Exception::InternetError("Response was HTTP_FOUND, processing should "
"never have entered processErrorStates",
retStatus);
} else if (retStatus == HTTP_MOVED_PERMANENTLY) {
throw Exception::InternetError("Response was HTTP_MOVED_PERMANENTLY, "
"processing should never have entered "
"processErrorStates",
retStatus);
} else if (retStatus == HTTP_NOT_MODIFIED) {
throw Exception::InternetError("Not modified since provided date" +
rateLimitReset.toSimpleString(),
retStatus);
} else if ((retStatus == HTTP_FORBIDDEN) && (rateLimitRemaining == 0)) {
throw Exception::InternetError(
"The Github API rate limit has been reached, try again after " +
rateLimitReset.toSimpleString(),
retStatus);
} else {
std::stringstream info;
std::stringstream ss;
Poco::StreamCopier::copyStream(rs, ss);
if (retStatus == HTTP_NOT_FOUND)
info << "Failed to download " << url << " with the link "
<< "<a href=\"" << url << "\">.\n"
<< "Hint. Check that link is correct</a>";
else {
// show the error
info << res.getReason();
info << ss.str();
g_log.debug() << ss.str();
}
throw Exception::InternetError(info.str() + ss.str(), retStatus);
}
}
bool doRequest(Poco::Net::HTTPClientSession & session, string requestBody, Poco::Net::HTTPRequest & request, Poco::Net::HTTPResponse & response)
{
session.setKeepAlive(true);
request.setKeepAlive(true);
request.setContentType("application/x-www-form-urlencoded");
request.setContentLength(requestBody.length());
session.sendRequest(request) << requestBody;
std::istream& rs = session.receiveResponse(response);
std::cout << response.getStatus() << " " << response.getReason() << std::endl;
if (response.getStatus() != Poco::Net::HTTPResponse::HTTP_UNAUTHORIZED)
{
//std::ofstream ofs("Poco_banner.jpg", std::fstream::binary);
//StreamCopier::copyStream(rs, ofs);
// Print to standard output
cout << "RECEIVED:" << endl;
//std::copy(std::istream_iterator<char>(rs), std::istream_iterator<char>(), std::ostream_iterator<char>(std::cout));
string received = "";
string temp;
//rec << rs.rdbuf();
while (std::getline(rs, temp))
{
received += temp + "\n";
}
cout << received << endl;
return true;
}
else
{
//it went wrong ?
return false;
}
}
void
Engine::setUriEngine(const std::string& uri, const ProtocolInfo& protInfo)
{
Poco::URI uriParsed(uri);
_playlist.clear();
_duration = 0.0;
if (protInfo.getMimeString() == Mime::PLAYLIST) {
LOG(upnpav, debug, "renderer engine got playlist");
Poco::Net::HTTPClientSession session(uriParsed.getHost(), uriParsed.getPort());
Poco::Net::HTTPRequest request("GET", uriParsed.getPath());
session.sendRequest(request);
std::stringstream requestHeader;
request.write(requestHeader);
LOG(upnpav, debug, "request header:\n" + requestHeader.str());
Poco::Net::HTTPResponse response;
std::istream& istr = session.receiveResponse(response);
LOG(upnpav, information, "HTTP " + Poco::NumberFormatter::format(response.getStatus()) + " " + response.getReason());
std::stringstream responseHeader;
response.write(responseHeader);
LOG(upnpav, debug, "response header:\n" + responseHeader.str());
std::string line;
while(std::getline(istr, line)) {
_playlist.push_back(line);
}
setAtomicUriEngine(_playlist[_trackNumberInPlaylist]);
}
else if (preferStdStream()) {
Poco::Net::HTTPClientSession session(uriParsed.getHost(), uriParsed.getPort());
Poco::Net::HTTPRequest request("GET", uriParsed.getPath());
session.sendRequest(request);
std::stringstream requestHeader;
request.write(requestHeader);
LOG(upnpav, debug, "request header:\n" + requestHeader.str());
Poco::Net::HTTPResponse response;
std::istream& istr = session.receiveResponse(response);
LOG(upnpav, information, "HTTP " + Poco::NumberFormatter::format(response.getStatus()) + " " + response.getReason());
std::stringstream responseHeader;
response.write(responseHeader);
LOG(upnpav, debug, "response header:\n" + responseHeader.str());
setUri(istr, protInfo);
}
else {
setAtomicUriEngine(uri, protInfo);
}
}
/**
* Downloads datafiles from the archives, and saves to the users save default directory.
* @param URL :: The URL of the file to download.
* @param fileName :: The name of the file to save to disk.
* @return The full path to the saved file.
*/
std::string CatalogDownloadDataFiles::doDownloadandSavetoLocalDrive(const std::string& URL,const std::string& fileName)
{
std::string pathToDownloadedDatafile;
clock_t start;
try
{
Poco::URI uri(URL);
std::string path(uri.getPathAndQuery());
start=clock();
Poco::SharedPtr<Poco::Net::InvalidCertificateHandler> certificateHandler = new Poco::Net::AcceptCertificateHandler(true);
// Currently do not use any means of authentication. This should be updated IDS has signed certificate.
const Poco::Net::Context::Ptr context = new Poco::Net::Context(Poco::Net::Context::CLIENT_USE, "", "", "", Poco::Net::Context::VERIFY_NONE);
// Create a singleton for holding the default context. E.g. any future requests to publish are made to this certificate and context.
Poco::Net::SSLManager::instance().initializeClient(NULL, certificateHandler,context);
Poco::Net::HTTPSClientSession session(uri.getHost(), uri.getPort(), context);
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, path, Poco::Net::HTTPMessage::HTTP_1_1);
session.sendRequest(request);
// Close the request by requesting a response.
Poco::Net::HTTPResponse response;
// Store the response for use IF an error occurs (e.g. 404).
std::istream& responseStream = session.receiveResponse(response);
// Obtain the status returned by the server to verify if it was a success.
Poco::Net::HTTPResponse::HTTPStatus HTTPStatus = response.getStatus();
// The error message returned by the IDS (if one exists).
std::string IDSError = CatalogAlgorithmHelper().getIDSError(HTTPStatus, responseStream);
// Cancel the algorithm and display the message if it exists.
if(!IDSError.empty())
{
// As an error occurred we must cancel the algorithm to prevent success message.
this->cancel();
// Output an appropriate error message from the JSON object returned by the IDS.
g_log.error(IDSError);
return "";
}
// Save the file to local disk if no errors occurred on the IDS.
pathToDownloadedDatafile = saveFiletoDisk(responseStream,fileName);
clock_t end=clock();
float diff = float(end - start)/CLOCKS_PER_SEC;
g_log.information()<<"Time taken to download file "<< fileName<<" is "<<std::fixed << std::setprecision(2) << diff <<" seconds" << std::endl;
}
catch(Poco::Net::SSLException& error)
{
throw std::runtime_error(error.displayText());
}
// A strange error occurs (what returns: {I/O error}, while message returns: { 9: The BIO reported an error }.
// This bug has been fixed in POCO 1.4 and is noted - http://sourceforge.net/p/poco/bugs/403/
// I have opted to catch the exception and do nothing as this allows the load/download functionality to work.
// However, the port the user used to download the file will be left open.
catch(Poco::Exception&) {}
return pathToDownloadedDatafile;
}
/**
* @param filenames : List of files to search
* @param exts : List of extensions to check against
* @return list of archive locations
*/
std::string SNSDataArchive::getArchivePath(const std::set<std::string>& filenames, const std::vector<std::string>& exts) const
{
std::set<std::string>::const_iterator iter = filenames.begin();
std::string filename = *iter;
//ICAT4 web service take upper case filename such as HYSA_2662
std::transform(filename.begin(),filename.end(),filename.begin(),toupper);
std::vector<std::string>::const_iterator iter2 = exts.begin();
for(; iter2!=exts.end(); ++iter2)
{
g_log.debug() << *iter2 << ";";
}
g_log.debug() << "\n";
std::string baseURL("http://icat.sns.gov:8080/icat-rest-ws/datafile/filename/");
std::string URL(baseURL + filename);
g_log.debug() << "URL: " << URL << "\n";
Poco::URI uri(URL);
std::string path(uri.getPathAndQuery());
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, path, Poco::Net::HTTPMessage::HTTP_1_1);
session.sendRequest(req);
Poco::Net::HTTPResponse res;
std::istream& rs = session.receiveResponse(res);
g_log.debug() << "res.getStatus(): " << res.getStatus() << "\n";
// Create a DOM document from the response.
Poco::XML::DOMParser parser;
Poco::XML::InputSource source(rs);
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&source);
std::vector<std::string> locations;
// If everything went fine, return the XML document.
// Otherwise look for an error message in the XML document.
if (res.getStatus() == Poco::Net::HTTPResponse::HTTP_OK)
{
std::string location;
Poco::AutoPtr<Poco::XML::NodeList> pList = pDoc->getElementsByTagName("location");
for(unsigned long i = 0 ; i < pList->length(); i++)
{
location = pList->item(i)->innerText();
g_log.debug() << "location: " << location << "\n";
locations.push_back(location);
}
}
else
{
std::string error(res.getReason());
throw Poco::ApplicationException("HTTPRequest Error", error);
}
std::vector<std::string>::const_iterator ext = exts.begin();
for (; ext != exts.end(); ++ext)
{
std::string datafile = filename + *ext;
std::vector<std::string>::const_iterator iter = locations.begin();
for(; iter!=locations.end(); ++iter)
{
if (boost::algorithm::ends_with((*iter), datafile))
{
return *iter;
} // end if
} // end for iter
} // end for ext
return "";
}
void FileServerRequestHandler::handleRequest(const HTTPRequest& request, Poco::MemoryInputStream& message,
const std::shared_ptr<StreamSocket>& socket)
{
try
{
bool noCache = false;
#if ENABLE_DEBUG
noCache = true;
#endif
Poco::Net::HTTPResponse response;
Poco::URI requestUri(request.getURI());
LOG_TRC("Fileserver request: " << requestUri.toString());
requestUri.normalize(); // avoid .'s and ..'s
std::string path(requestUri.getPath());
if (path.find("loleaflet/" LOOLWSD_VERSION_HASH "/") == std::string::npos)
{
LOG_WRN("client - server version mismatch, disabling browser cache.");
noCache = true;
}
std::vector<std::string> requestSegments;
requestUri.getPathSegments(requestSegments);
const std::string relPath = getRequestPathname(request);
// Is this a file we read at startup - if not; its not for serving.
if (requestSegments.size() < 1 || FileHash.find(relPath) == FileHash.end())
throw Poco::FileNotFoundException("Invalid URI request: [" + requestUri.toString() + "].");
const auto& config = Application::instance().config();
const std::string loleafletHtml = config.getString("loleaflet_html", "loleaflet.html");
const std::string endPoint = requestSegments[requestSegments.size() - 1];
if (endPoint == loleafletHtml)
{
preprocessFile(request, message, socket);
return;
}
if (request.getMethod() == HTTPRequest::HTTP_GET)
{
if (endPoint == "admin.html" ||
endPoint == "adminSettings.html" ||
endPoint == "adminHistory.html" ||
endPoint == "adminAnalytics.html")
{
preprocessAdminFile(request, socket);
return;
}
if (endPoint == "admin-bundle.js" ||
endPoint == "admin-localizations.js")
{
noCache = true;
if (!LOOLWSD::AdminEnabled)
throw Poco::FileAccessDeniedException("Admin console disabled");
if (!FileServerRequestHandler::isAdminLoggedIn(request, response))
throw Poco::Net::NotAuthenticatedException("Invalid admin login");
// Ask UAs to block if they detect any XSS attempt
response.add("X-XSS-Protection", "1; mode=block");
// No referrer-policy
response.add("Referrer-Policy", "no-referrer");
}
// Do we have an extension.
const std::size_t extPoint = endPoint.find_last_of('.');
if (extPoint == std::string::npos)
throw Poco::FileNotFoundException("Invalid file.");
const std::string fileType = endPoint.substr(extPoint + 1);
std::string mimeType;
if (fileType == "js")
mimeType = "application/javascript";
else if (fileType == "css")
mimeType = "text/css";
else if (fileType == "html")
mimeType = "text/html";
else if (fileType == "png")
mimeType = "image/png";
else if (fileType == "svg")
mimeType = "image/svg+xml";
else
mimeType = "text/plain";
auto it = request.find("If-None-Match");
if (it != request.end())
{
// if ETags match avoid re-sending the file.
if (!noCache && it->second == "\"" LOOLWSD_VERSION_HASH "\"")
{
// TESTME: harder ... - do we even want ETag support ?
std::ostringstream oss;
Poco::DateTime now;
Poco::DateTime later(now.utcTime(), int64_t(1000)*1000 * 60 * 60 * 24 * 128);
oss << "HTTP/1.1 304 Not Modified\r\n"
<< "Date: " << Poco::DateTimeFormatter::format(
now, Poco::DateTimeFormat::HTTP_FORMAT) << "\r\n"
<< "Expires: " << Poco::DateTimeFormatter::format(
later, Poco::DateTimeFormat::HTTP_FORMAT) << "\r\n"
<< "User-Agent: " << WOPI_AGENT_STRING << "\r\n"
<< "Cache-Control: max-age=11059200\r\n"
<< "\r\n";
socket->send(oss.str());
socket->shutdown();
return;
}
}
response.set("User-Agent", HTTP_AGENT_STRING);
response.set("Date", Poco::DateTimeFormatter::format(Poco::Timestamp(), Poco::DateTimeFormat::HTTP_FORMAT));
bool gzip = request.hasToken("Accept-Encoding", "gzip");
const std::string *content;
#if ENABLE_DEBUG
if (std::getenv("LOOL_SERVE_FROM_FS"))
{
// Useful to not serve from memory sometimes especially during loleaflet development
// Avoids having to restart loolwsd everytime you make a change in loleaflet
const std::string filePath = Poco::Path(LOOLWSD::FileServerRoot, relPath).absolute().toString();
HttpHelper::sendFile(socket, filePath, mimeType, response, noCache);
return;
}
#endif
if (gzip)
{
response.set("Content-Encoding", "gzip");
content = getCompressedFile(relPath);
}
else
content = getUncompressedFile(relPath);
if (!noCache)
{
// 60 * 60 * 24 * 128 (days) = 11059200
response.set("Cache-Control", "max-age=11059200");
response.set("ETag", "\"" LOOLWSD_VERSION_HASH "\"");
}
response.setContentType(mimeType);
response.add("X-Content-Type-Options", "nosniff");
std::ostringstream oss;
response.write(oss);
const std::string header = oss.str();
LOG_TRC("#" << socket->getFD() << ": Sending " <<
(!gzip ? "un":"") << "compressed : file [" << relPath << "]: " << header);
socket->send(header);
socket->send(*content);
}
}
catch (const Poco::Net::NotAuthenticatedException& exc)
{
LOG_ERR("FileServerRequestHandler::NotAuthenticated: " << exc.displayText());
sendError(401, request, socket, "", "", "WWW-authenticate: Basic realm=\"online\"\r\n");
}
catch (const Poco::FileAccessDeniedException& exc)
{
LOG_ERR("FileServerRequestHandler: " << exc.displayText());
sendError(403, request, socket, "403 - Access denied!",
"You are unable to access");
}
catch (const Poco::FileNotFoundException& exc)
{
LOG_WRN("FileServerRequestHandler: " << exc.displayText());
sendError(404, request, socket, "404 - file not found!",
"There seems to be a problem locating");
}
}
void EventConnection::internalProcess()
{
try
{
Poco::URI uri(_eventReceiverURI);
// prepare session
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
session.setKeepAlive(false);
if(_soapAction.find("ErrorEvent") != std::string::npos)
{
session.setTimeout(Poco::Timespan(10,0,0,0,0));
}
// prepare request
std::string path (uri.getPathAndQuery());
if(path.empty())
{
path = "/";
}
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_POST, path, Poco::Net::HTTPMessage::HTTP_1_1);
request.setContentLength(_content.length());
request.setContentType("text/xml; charset=utf-8");
request.setKeepAlive(false);
request.set("SOAPAction","\"" + _soapAction + "\"");
// send request
std::ostream& outStream = session.sendRequest(request);
outStream << _content;
// get response
Poco::Net::HTTPResponse response;
std::istream& inStream = session.receiveResponse(response);
std::ostringstream responseContentStream;
Poco::StreamCopier::copyStream(inStream, responseContentStream);
_responseContent = responseContentStream.str();
if(response.getStatus() != 200)
{
std::ostringstream strout;
strout << "EventConnection HTTP-Error: " << response.getStatus() << " - " << response.getReason();
_errorMessage = strout.str();
_error = true;
}
while(session.connected())
{
session.abort();
}
_finished = true;
}
catch (std::exception e)
{
std::ostringstream strout;
strout << "EventConnection Exception: " << e.what();
_errorMessage = strout.str();
_error = true;
_finished = true;
}
}