void assertPutFileRequest(const Poco::Net::HTTPRequest& request) override
{
if (_savingPhase == SavingPhase::Unmodified)
{
// the document is not modified
CPPUNIT_ASSERT_EQUAL(std::string("false"), request.get("X-LOOL-WOPI-IsModifiedByUser"));
// but the save action is an explicit user's request
CPPUNIT_ASSERT_EQUAL(std::string("false"), request.get("X-LOOL-WOPI-IsAutosave"));
_finishedSaveUnmodified = true;
}
else if (_savingPhase == SavingPhase::Modified)
{
// the document is modified
CPPUNIT_ASSERT_EQUAL(std::string("true"), request.get("X-LOOL-WOPI-IsModifiedByUser"));
// and this test fakes that it's an autosave
CPPUNIT_ASSERT_EQUAL(std::string("true"), request.get("X-LOOL-WOPI-IsAutosave"));
_finishedSaveModified = true;
}
if (_finishedSaveUnmodified && _finishedSaveModified)
exitTest(TestResult::Ok);
}
std::istream &RemoteJobManager::httpGet(const std::string &path,
const std::string &query_str,
const std::string &username,
const std::string &password) {
Poco::Net::HTTPRequest req;
initGetRequest(req, path, query_str);
if (username.length() > 0) {
// Set the Authorization header (base64 encoded)
std::ostringstream encodedAuth;
Poco::Base64Encoder encoder(encodedAuth);
encoder << username << ":" << password;
encoder.close();
req.setCredentials("Basic", encodedAuth.str());
}
m_session->sendRequest(req);
std::istream &respStream = m_session->receiveResponse(m_response);
// For as yet unknown reasons, we don't always get a session cookie back from
// the
// server. In that case, we don't want to overwrite the cookie we're currently
// using...
// Note: This won't work properly if we ever use cookies other than a
// session cookie.
std::vector<Poco::Net::HTTPCookie> newCookies;
m_response.getCookies(newCookies);
if (!newCookies.empty()) {
m_cookies = newCookies;
}
return respStream;
}
void HttpAssetTransfer::SendHttpGetAssetRequest(const std::string &resource_uri)
{
if (http_session_.connected())
{
http_session_.abort();
http_session_.detachSocket();
}
received_count_ = 0;
Poco::URI uri(resource_uri);
std::string path(uri.getPathAndQuery());
if (path.empty())
path = "/";
http_session_.setHost(uri.getHost());
http_session_.setPort(uri.getPort());
Poco::Timespan time_out(HTTP_TIMEOUT_MS*1000);
http_session_.setTimeout(time_out);
Poco::Net::HTTPRequest request;
request.setMethod(Poco::Net::HTTPRequest::HTTP_GET);
request.setURI(path);
request.setVersion(Poco::Net::HTTPMessage::HTTP_1_1);
try
{
http_session_.sendRequest(request);
std::istream &s = http_session_.receiveResponse(http_response_);
Poco::Net::HTTPResponse::HTTPStatus status = http_response_.getStatus();
switch (status)
{
case Poco::Net::HTTPResponse::HTTP_OK:
response_stream_ = &s;
response_size_ = http_response_.getContentLength();
break;
default:
std::string reason = http_response_.getReasonForStatus(status);
std::stringstream error;
error << "Http GET failed for: ";
error << resource_uri << std::endl;
error << "Reason: " << reason;
AssetModule::LogError(error.str());
failed_ = true;
return;
}
}
catch (Poco::Exception e)
{
std::stringstream error;
error << "Http GET failed for: ";
error << resource_uri << std::endl;
error << "Reason: " << e.displayText();
AssetModule::LogError(error.str());
failed_ = true;
return;
}
}
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 FileServerRequestHandler::sendError(int errorCode, const Poco::Net::HTTPRequest& request,
const std::shared_ptr<StreamSocket>& socket,
const std::string& shortMessage, const std::string& longMessage,
const std::string& extraHeader)
{
Poco::URI requestUri(request.getURI());
const std::string& path = requestUri.getPath();
std::ostringstream oss;
oss << "HTTP/1.1 " << errorCode << "\r\n"
<< "Content-Type: text/html charset=UTF-8\r\n"
<< "Date: " << Poco::DateTimeFormatter::format(Poco::Timestamp(), Poco::DateTimeFormat::HTTP_FORMAT) << "\r\n"
<< "User-Agent: " << WOPI_AGENT_STRING << "\r\n"
<< extraHeader
<< "\r\n";
if (!shortMessage.empty())
{
oss << "<h1>Error: " << shortMessage << "</h1>"
<< "<p>" << longMessage << " " << path << "</p>"
<< "<p>Please contact your system administrator.</p>";
}
socket->send(oss.str());
}
std::istream &RemoteJobManager::httpPost(const std::string &path,
const PostDataMap &postData,
const PostDataMap &fileData,
const std::string &username,
const std::string &password) {
Poco::Net::HTTPRequest req;
initPostRequest(req, path);
if (username.length() > 0) {
// Set the Authorization header (base64 encoded)
std::ostringstream encodedAuth;
Poco::Base64Encoder encoder(encodedAuth);
encoder << username << ":" << password;
encoder.close();
req.setCredentials("Basic", encodedAuth.str());
}
// We have to do a POST with multipart MIME encoding. MIME is rather picky
// about
// how the parts are delimited. See RFC 2045 & 2046 for details.
char httpLineEnd[3] = {0x0d, 0x0a,
0x00}; // HTTP uses CRLF for its line endings
// boundary can be almost anything (again, see RFC 2046). The important part
// is that it
// cannot appear anywhere in the actual data
std::string boundary = "112233MantidHTTPBoundary44556677";
std::string boundaryLine = "--" + boundary + httpLineEnd;
std::string finalBoundaryLine = "--" + boundary + "--" + httpLineEnd;
req.setContentType("multipart/form-data; boundary=" + boundary);
// Need to be able to specify the content length, so build up the post body
// here.
std::ostringstream postBody;
auto it = postData.cbegin();
while (it != postData.cend()) {
postBody << boundaryLine;
postBody << "Content-Disposition: form-data; name=\"" << (*it).first
<< "\"";
postBody << httpLineEnd << httpLineEnd;
postBody << (*it).second;
postBody << httpLineEnd;
++it;
}
// file data is treated the same as post data, except that we set the filename
// field
// in the Content-Disposition header and add the Content-Type header
it = fileData.begin();
while (it != fileData.end()) {
postBody << boundaryLine;
postBody << "Content-Disposition: form-data; name=\"" << (*it).first
<< "\"; filename=\"" << (*it).first << "\"";
postBody << httpLineEnd;
postBody << "Content-Type: application/octet-stream";
postBody << httpLineEnd << httpLineEnd;
postBody << (*it).second;
postBody << httpLineEnd;
++it;
}
postBody << finalBoundaryLine;
req.setContentLength(static_cast<int>(postBody.str().size()));
std::ostream &postStream = m_session->sendRequest(req);
// upload the actual HTTP body
postStream << postBody.str() << std::flush;
std::istream &respStream = m_session->receiveResponse(m_response);
// For as yet unknown reasons, we don't always get a session cookie back from
// the
// server. In that case, we don't want to overwrite the cookie we're currently
// using...
// Note: This won't work properly if we ever use cookies other than a
// session cookie.
std::vector<Poco::Net::HTTPCookie> newCookies;
m_response.getCookies(newCookies);
if (!newCookies.empty()) {
m_cookies = newCookies;
}
return respStream;
}
void HttpAssetTransfer::SendHttpPostAssetRequest(const std::string &host, const std::string &json_data)
{
std::string ASSET_UPLOADING_CONTENT_TYPE = "application/json";
int content_length = json_data.length();
std::istringstream stream(json_data);
int send_count = 0; //\todo make member var
Poco::URI uri(host);
std::string path(uri.getPathAndQuery());
if (path.empty())
path = "/";
http_session_.setHost(uri.getHost());
http_session_.setPort(uri.getPort());
Poco::Timespan time_out(HTTP_TIMEOUT_MS*1000);
Poco::Net::HTTPRequest request;
request.setMethod(Poco::Net::HTTPRequest::HTTP_POST);
std::string t = uri.toString();
request.setURI(uri.getPath());
request.setVersion(Poco::Net::HTTPMessage::HTTP_1_1);
request.setContentType(ASSET_UPLOADING_CONTENT_TYPE);
request.setContentLength(content_length);
request.setKeepAlive(false);
try
{
std::ostream &request_body = http_session_.sendRequest(request);
request_body.write(json_data.c_str(), json_data.length());
std::istream &s = http_session_.receiveResponse(http_response_);
Poco::Net::HTTPResponse::HTTPStatus status = http_response_.getStatus();
switch (status)
{
case Poco::Net::HTTPResponse::HTTP_OK:
response_stream_ = &s;
response_size_ = http_response_.getContentLength();
break;
default:
std::string reason = http_response_.getReasonForStatus(status);
std::stringstream error;
error << "Http POST failed for: ";
error << host << std::endl;
error << "Reason: " << reason;
AssetModule::LogError(error.str());
failed_ = true;
return;
}
}
catch (Poco::Net::MessageException &e)
{
std::string u = request.getURI();
std::string m = request.getMethod();
std::string error = e.message();
}
catch (Poco::Exception &e)
{
std::stringstream error;
error << "Http POST failed for: ";
error << host << std::endl;
error << "Reason: " << e.displayText();
AssetModule::LogError(error.str());
failed_ = true;
return;
}
}
void RemoteJobManager::initHTTPRequest(Poco::Net::HTTPRequest &req,
const std::string &method,
std::string extraPath,
std::string queryString) {
// Set up the session object
if (m_session) {
delete m_session;
m_session = nullptr;
}
if (Poco::URI(m_serviceBaseUrl).getScheme() == "https") {
// Create an HTTPS session
// TODO: Notice that we've set the context to VERIFY_NONE. I think that
// means we're not checking the SSL certificate that the server
// sends to us. That's BAD!!
Poco::Net::Context::Ptr context =
new Poco::Net::Context(Poco::Net::Context::CLIENT_USE, "", "", "",
Poco::Net::Context::VERIFY_NONE, 9, false,
"ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
m_session = new Poco::Net::HTTPSClientSession(
Poco::URI(m_serviceBaseUrl).getHost(),
Poco::URI(m_serviceBaseUrl).getPort(), context);
} else {
// Create a regular HTTP client session. (NOTE: Using unencrypted HTTP is a
// really bad idea! We'll be sending passwords in the clear!)
m_session =
new Poco::Net::HTTPClientSession(Poco::URI(m_serviceBaseUrl).getHost(),
Poco::URI(m_serviceBaseUrl).getPort());
}
Poco::URI uri(m_serviceBaseUrl);
std::string path = uri.getPath();
// Path should be something like "/mws/rest", append extraPath to it.
path += extraPath;
uri.setPath(path);
if (method == Poco::Net::HTTPRequest::HTTP_GET && !queryString.empty()) {
uri.setQuery(queryString);
}
req.setVersion(Poco::Net::HTTPRequest::HTTP_1_1);
req.setMethod(method);
req.setURI(uri.toString());
// Attach any cookies we've got from previous responses
req.setCookies(getCookies());
}
