ofHttpResponse ofURLFileLoader::handleRequest(ofHttpRequest request) {
try {
URI uri(request.url);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
HTTPResponse res;
ofPtr<HTTPSession> session;
istream * rs;
if(uri.getScheme()=="https"){
//const Poco::Net::Context::Ptr context( new Poco::Net::Context( Poco::Net::Context::CLIENT_USE, "", "", "rootcert.pem" ) );
HTTPSClientSession * httpsSession = new HTTPSClientSession(uri.getHost(), uri.getPort());//,context);
httpsSession->setTimeout(Poco::Timespan(20,0));
httpsSession->sendRequest(req);
rs = &httpsSession->receiveResponse(res);
session = ofPtr<HTTPSession>(httpsSession);
}else{
HTTPClientSession * httpSession = new HTTPClientSession(uri.getHost(), uri.getPort());
httpSession->setTimeout(Poco::Timespan(20,0));
httpSession->sendRequest(req);
rs = &httpSession->receiveResponse(res);
session = ofPtr<HTTPSession>(httpSession);
}
if(!request.saveTo){
return ofHttpResponse(request,*rs,res.getStatus(),res.getReason());
}else{
ofFile saveTo(request.name,ofFile::WriteOnly,true);
char aux_buffer[1024];
rs->read(aux_buffer, 1024);
std::streamsize n = rs->gcount();
while (n > 0){
// we resize to size+1 initialized to 0 to have a 0 at the end for strings
saveTo.write(aux_buffer,n);
if (rs->good()){
rs->read(aux_buffer, 1024);
n = rs->gcount();
}
else n = 0;
}
return ofHttpResponse(request,res.getStatus(),res.getReason());
}
} catch (const Exception& exc) {
ofLogError("ofURLFileLoader") << "handleRequest(): "+ exc.displayText();
return ofHttpResponse(request,-1,exc.displayText());
} catch (...) {
return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception");
}
return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception");
}
int main(int argc, char **argv) {
// using `web` as provider
URI uri("https://yboss.yahooapis.com/ysearch/web?q=cat");
// init the creds, I think the empty token and token secret are important
OAuth10Credentials creds(
"dj0yJmk9eGx5RzFQOVAwcDZpJmQ9WVdrOWVVUkhWamhwTkdVbWNHbzlNQS0tJnM9Y29uc3VtZXJzZWNyZXQmeD0wYw--",
"2bf8a4682c4948fb4f7add9598eef5f86b57cf93", "", "");
HTTPRequest request(HTTPRequest::HTTP_GET, uri.getPathEtc());
// put the `q` as param
HTMLForm params;
params.set("q", "cat");
creds.authenticate(request, uri, params);
std::string auth = request.get("Authorization");
std::cout << auth << std::endl;
const Context::Ptr context = new Context(Context::CLIENT_USE, "", "", "", Context::VERIFY_NONE, 9, false, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
HTTPSClientSession session(uri.getHost(), uri.getPort(), context);
session.sendRequest(request);
HTTPResponse response;
std::istream& rs = session.receiveResponse(response);
std::cout << response.getStatus() << " " << response.getReason() << std::endl;
StreamCopier::copyStream(rs, std::cout);
return 0;
}
int main(int argc, char** argv)
{
if (argc != 2)
{
Path p(argv[0]);
std::cout << "usage: " << p.getBaseName() << " <uri>" << std::endl;
std::cout << " fetches the resource identified by <uri> and print it to the standard output" << std::endl;
return 1;
}
try
{
URI uri(argv[1]);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
session.sendRequest(req);
HTTPResponse res;
std::istream& rs = session.receiveResponse(res);
std::cout << res.getStatus() << " " << res.getReason() << std::endl;
StreamCopier::copyStream(rs, std::cout);
}
catch (Exception& exc)
{
std::cerr << exc.displayText() << std::endl;
return 1;
}
return 0;
}
ofHttpResponse ofURLFileLoader::handleRequest(ofHttpRequest request) {
try {
URI uri(request.url);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
session.setTimeout(Poco::Timespan(20,0));
session.sendRequest(req);
HTTPResponse res;
istream& rs = session.receiveResponse(res);
if(!request.saveTo){
return ofHttpResponse(request,rs,res.getStatus(),res.getReason());
}else{
ofFile saveTo(request.name,ofFile::WriteOnly,true);
char aux_buffer[1024];
rs.read(aux_buffer, 1024);
std::streamsize n = rs.gcount();
while (n > 0){
// we resize to size+1 initialized to 0 to have a 0 at the end for strings
saveTo.write(aux_buffer,n);
if (rs){
rs.read(aux_buffer, 1024);
n = rs.gcount();
}
else n = 0;
}
return ofHttpResponse(request,res.getStatus(),res.getReason());
}
} catch (const Exception& exc) {
ofLog(OF_LOG_ERROR, "ofURLFileLoader " + exc.displayText());
return ofHttpResponse(request,-1,exc.displayText());
} catch (...) {
return ofHttpResponse(request,-1,"ofURLFileLoader fatal error, couldn't catch Exception");
}
}
void HTTPResponseTest::testRead1()
{
std::string s("HTTP/1.1 500 Internal Server Error\r\n\r\n");
std::istringstream istr(s);
HTTPResponse response;
response.read(istr);
assert (response.getStatus() == HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
assert (response.getReason() == "Internal Server Error");
assert (response.getVersion() == HTTPMessage::HTTP_1_1);
assert (response.empty());
assert (istr.get() == -1);
}
POCO_HttpClient_response POCO_HttpClient::POST_request(string param_uri)
{
_mutex.lock();
URI uri(param_uri);
string path(uri.getPath());
if (path.empty()) path = "/";
string requestBody = uri.getQuery();
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest request(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1);
HTTPResponse response;
session.setKeepAlive(true);
request.setKeepAlive(true);
request.setContentType("application/x-www-form-urlencoded");
request.setContentLength(requestBody.length());
string state = "";
string reason = "";
string received = "";
HTTPResponse::HTTPStatus status = HTTPResponse::HTTPStatus::HTTP_NOT_FOUND;
try
{
session.sendRequest(request) << requestBody;
std::istream& rs = session.receiveResponse(response);
status = response.getStatus();
reason = response.getReason();
received = "";
string temp;
while (getline(rs, temp))
{
received += temp + "\n";
}
state = "success";
}
catch (NetException e)
{
state = "exception";
received = e.displayText();
}
catch (...)
{
state = "exception";
received = "exception";
}
_mutex.unlock();
return POCO_HttpClient_response(state, received, status, reason);
}
void HTTPResponseTest::testRead3()
{
std::string s("HTTP/1.1 200 \r\nContent-Length: 0\r\n\r\n");
std::istringstream istr(s);
HTTPResponse response;
response.read(istr);
assert (response.getVersion() == HTTPMessage::HTTP_1_1);
assert (response.getStatus() == HTTPResponse::HTTP_OK);
assert (response.getReason() == "");
assert (response.size() == 1);
assert (response.getContentLength() == 0);
assert (istr.get() == -1);
}
void HTTPResponseTest::testRead2()
{
std::string s("HTTP/1.0 301 Moved Permanently\r\nLocation: http://www.appinf.com/index.html\r\nServer: Poco/1.0\r\n\r\n");
std::istringstream istr(s);
HTTPResponse response;
response.read(istr);
assert (response.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY);
assert (response.getReason() == "Moved Permanently");
assert (response.getVersion() == HTTPMessage::HTTP_1_0);
assert (response.size() == 2);
assert (response["Location"] == "http://www.appinf.com/index.html");
assert (response["Server"] == "Poco/1.0");
assert (istr.get() == -1);
}
StreamSocket HTTPClientSession::proxyConnect()
{
HTTPClientSession proxySession(getProxyHost(), getProxyPort());
proxySession.setTimeout(getTimeout());
SocketAddress targetAddress(getHost(), getPort());
HTTPRequest proxyRequest(HTTPRequest::HTTP_CONNECT, targetAddress.toString(), HTTPMessage::HTTP_1_1);
HTTPResponse proxyResponse;
proxyRequest.set("Proxy-Connection", "keep-alive");
proxyRequest.set("Host", getHost());
proxyAuthenticateImpl(proxyRequest);
proxySession.setKeepAlive(true);
proxySession.sendRequest(proxyRequest);
proxySession.receiveResponse(proxyResponse);
if (proxyResponse.getStatus() != HTTPResponse::HTTP_OK)
throw HTTPException("Cannot establish proxy connection", proxyResponse.getReason());
return proxySession.detachSocket();
}
/*
POCO_HttpClient_response POCO_HttpClient::GET_request(string param_uri)
{
URI uri(param_uri);
string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest request(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1);
HTTPResponse response;
session.sendRequest(request);
std::istream& rs = session.receiveResponse(response);
HTTPResponse::HTTPStatus status = response.getStatus();
string reason = response.getReason();
string received = "";
string temp;
while (getline(rs, temp))
{
received += temp + "\n";
}
return POCO_HttpClient_response(received, status, reason);
}
*/
POCO_HttpClient_response POCO_HttpClient::GET_request(string param_uri)
{
_mutex.lock();
URI uri(param_uri);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest request(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
HTTPResponse response;
string state = "";
string reason = "";
string received = "";
HTTPResponse::HTTPStatus status = HTTPResponse::HTTPStatus::HTTP_NOT_FOUND;
try
{
session.sendRequest(request);
std::istream& rs = session.receiveResponse(response);
status = response.getStatus();
reason = response.getReason();
received = "";
string temp;
while (getline(rs, temp))
{
received += temp + "\n";
}
state = "success";
}
catch (NetException e)
{
state = "exception";
received = e.displayText();
}
catch (...)
{
state = "exception";
received = "exception";
}
_mutex.unlock();
return POCO_HttpClient_response(state, received, status, reason);
}
void HTTPSClientSession::connect(const SocketAddress& address)
{
if (getProxyHost().empty())
{
SecureStreamSocket sss(socket());
if (_pContext->sessionCacheEnabled())
{
sss.useSession(_pSession);
}
HTTPSession::connect(address);
if (_pContext->sessionCacheEnabled())
{
_pSession = sss.currentSession();
}
}
else
{
HTTPClientSession proxySession(address);
proxySession.setHost(getProxyHost());
proxySession.setPort(getProxyPort());
proxySession.setTimeout(getTimeout());
SocketAddress targetAddress(getHost(), getPort());
HTTPRequest proxyRequest(HTTPRequest::HTTP_CONNECT, targetAddress.toString(), HTTPMessage::HTTP_1_1);
HTTPResponse proxyResponse;
proxyRequest.set("Proxy-Connection", "keep-alive");
proxyRequest.set("Host", getHost());
proxyAuthenticateImpl(proxyRequest);
proxySession.setKeepAlive(true);
proxySession.sendRequest(proxyRequest);
proxySession.receiveResponse(proxyResponse);
if (proxyResponse.getStatus() != HTTPResponse::HTTP_OK)
throw HTTPException("Cannot establish proxy connection", proxyResponse.getReason());
StreamSocket proxySocket(proxySession.detachSocket());
SecureStreamSocket secureSocket = SecureStreamSocket::attach(proxySocket, getHost(), _pContext, _pSession);
attachSocket(secureSocket);
if (_pContext->sessionCacheEnabled())
{
_pSession = secureSocket.currentSession();
}
}
}
ofHttpResponse ofURLFileLoader::handleRequest(ofHttpRequest request) {
try {
URI uri(request.url);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
session.setTimeout(Poco::Timespan(20,0));
session.sendRequest(req);
HTTPResponse res;
istream& rs = session.receiveResponse(res);
return ofHttpResponse(request,rs,res.getStatus(),res.getReason());
} catch (Exception& exc) {
ofLog(OF_LOG_ERROR, "ofURLFileLoader " + exc.displayText());
return ofHttpResponse(request,-1,exc.displayText());
}
}
void SimpleWebScraper::handleTextRequest(string url_) {
try {
URI uri(url_);
string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
session.sendRequest(req);
HTTPResponse res;
std::istream& rs = session.receiveResponse(res);
std::cout << res.getStatus() << " " << res.getReason() << std::endl;
StreamCopier::copyToString(rs, response);
} catch (Exception& exc) {
cerr << exc.displayText() << std::endl;
}
}
void OAuthPrivate::resourceFile(const std::string method, const std::string url, const std::string & filename, const std::string status){
std::string authStr = buildAuthHeader(method, url, Params());
authStr = "OAuth " + authStr;
URI uri(url);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
const Poco::Net::Context::Ptr context( new Poco::Net::Context(Poco::Net::Context::CLIENT_USE, "", "", "cacert.pem"));
HTTPSClientSession session(uri.getHost(), uri.getPort(), context);
HTTPRequest request(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1);
HTTPResponse response;
Poco::Net::HTMLForm form;
form.setEncoding(Poco::Net::HTMLForm::ENCODING_MULTIPART);
form.set("status", status);
form.addPart("media[]", new Poco::Net::FilePartSource(filename, filename, "application/octet-stream"));
form.prepareSubmit(request);
request.set("Authorization", authStr);
std::ostream & ostr = session.sendRequest(request);
form.write(ostr);
std::istream& rs = session.receiveResponse(response);
std::cout << response.getStatus() << " " << response.getReason() << std::endl;
if (response.getStatus() != Poco::Net::HTTPResponse::HTTP_UNAUTHORIZED)
{
StreamCopier::copyStream(rs, std::cout);
}
else
{
Poco::NullOutputStream null;
StreamCopier::copyStream(rs, null);
}
}
//-------------------------------------------------------------
string API::doUpload( string image ){
if ( !bAuthenticated ){
ofLogWarning( "Not authenticated! Please call authenticate() with proper api key and secret" );
return "";
} else if ( currentPerms != FLICKR_WRITE ){
ofLogWarning( "You do not have proper permissions to upload! Please call authenticate() with permissions of ofxFlickr::FLICKR_WRITE" );
return "";
}
map<string,string> args;
args["api_key"] = api_key;
args["auth_token"] = auth_token;
string result;
FilePartSource * fps = new FilePartSource(image, "image/jpeg");
try
{
// prepare session
const URI uri( "https://" + api_base );
HTTPSClientSession session( uri.getHost(), uri.getPort() );
HTTPRequest req(HTTPRequest::HTTP_POST, "/services/upload/", HTTPMessage::HTTP_1_0);
req.setContentType("multipart/form-data");
// setup form
HTMLForm form;
form.set("api_key", api_key);
form.set("auth_token", auth_token);
form.set("api_sig", apiSig( args ));
form.setEncoding(HTMLForm::ENCODING_MULTIPART);
form.addPart("photo", fps);
form.prepareSubmit(req);
std::ostringstream oszMessage;
form.write(oszMessage);
std::string szMessage = oszMessage.str();
req.setContentLength((int) szMessage.length() );
//session.setKeepAlive(true);
// send form
ostream & out = session.sendRequest(req) << szMessage;
// get response
HTTPResponse res;
cout << res.getStatus() << " " << res.getReason() << endl;
// print response
istream &is = session.receiveResponse(res);
StreamCopier::copyToString(is, result);
}
catch (Exception &ex)
{
cerr << "error? " + ex.displayText() <<endl;
}
string photoid;
ofxXmlSettings xml;
xml.loadFromBuffer(result);
xml.pushTag("rsp");{
photoid = xml.getValue("photoid", "");
}; xml.popTag();
return photoid;
}
ofHttpResponse ofURLFileLoaderImpl::handleRequest(const ofHttpRequest & request) {
try {
URI uri(request.url);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
std::string pocoMethod;
if(request.method==ofHttpRequest::GET){
pocoMethod = HTTPRequest::HTTP_GET;
}else{
pocoMethod = HTTPRequest::HTTP_POST;
}
HTTPRequest req(pocoMethod, path, HTTPMessage::HTTP_1_1);
for(map<string,string>::const_iterator it = request.headers.cbegin(); it!=request.headers.cend(); it++){
req.add(it->first,it->second);
}
HTTPResponse res;
std::unique_ptr<HTTPClientSession> session;
if(uri.getScheme()=="https"){
//const Poco::Net::Context::Ptr context( new Poco::Net::Context( Poco::Net::Context::CLIENT_USE, "", "", "rootcert.pem" ) );
session.reset(new HTTPSClientSession(uri.getHost(), uri.getPort()));//,context);
}else{
session.reset(new HTTPClientSession(uri.getHost(), uri.getPort()));
}
session->setTimeout(Poco::Timespan(120,0));
if(request.contentType!=""){
req.setContentType(request.contentType);
}
if(request.body!=""){
req.setContentLength( request.body.length() );
auto & send = session->sendRequest(req);
send.write(request.body.c_str(), request.body.size());
send << std::flush;
}else{
session->sendRequest(req);
}
auto & rs = session->receiveResponse(res);
if(!request.saveTo){
return ofHttpResponse(request,rs,res.getStatus(),res.getReason());
}else{
ofFile saveTo(request.name,ofFile::WriteOnly,true);
char aux_buffer[1024];
rs.read(aux_buffer, 1024);
std::streamsize n = rs.gcount();
while (n > 0){
// we resize to size+1 initialized to 0 to have a 0 at the end for strings
saveTo.write(aux_buffer,n);
if (rs.good()){
rs.read(aux_buffer, 1024);
n = rs.gcount();
}
else n = 0;
}
return ofHttpResponse(request,res.getStatus(),res.getReason());
}
} catch (const Exception& exc) {
ofLogError("ofURLFileLoader") << "handleRequest(): "+ exc.displayText();
return ofHttpResponse(request,-1,exc.displayText());
} catch (...) {
return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception");
}
return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception");
}
void run()
{
Stopwatch sw;
std::vector<HTTPCookie> cookies;
for (int i = 0; i < _repetitions; ++i)
{
try
{
int usec = 0;
std::string path(_uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(_uri.getHost(), _uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
if (_cookies)
{
NameValueCollection nvc;
std::vector<HTTPCookie>::iterator it = cookies.begin();
for(; it != cookies.end(); ++it)
nvc.add((*it).getName(), (*it).getValue());
req.setCookies(nvc);
}
HTTPResponse res;
sw.restart();
session.sendRequest(req);
std::istream& rs = session.receiveResponse(res);
NullOutputStream nos;
StreamCopier::copyStream(rs, nos);
sw.stop();
_success += HTTPResponse::HTTP_OK == res.getStatus() ? 1 : 0;
if (_cookies) res.getCookies(cookies);
usec = int(sw.elapsed());
if (_verbose)
{
FastMutex::ScopedLock lock(_mutex);
std::cout
<< _uri.toString() << ' ' << res.getStatus() << ' ' << res.getReason()
<< ' ' << usec/1000.0 << "ms" << std::endl;
}
_usec += usec;
}
catch (Exception& exc)
{
FastMutex::ScopedLock lock(_mutex);
std::cerr << exc.displayText() << std::endl;
}
}
{
FastMutex::ScopedLock lock(_mutex);
_gSuccess += _success;
_gUsec += _usec;
}
if (_verbose)
printStats(_uri.toString(), _repetitions, _success, _usec);
}
ofxHttpResponse ofxURLFileLoader::handleRequest(ofxHttpRequest request) {
try {
URI uri(request.url);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
string method;
switch (request.method) {
case HTTP_METHOD_GET:
method = HTTPRequest::HTTP_GET;
break;
case HTTP_METHOD_POST:
method = HTTPRequest::HTTP_POST;
break;
default:
method = HTTPRequest::HTTP_GET;
break;
}
HTTPRequest req(method, path, HTTPMessage::HTTP_1_1);
session.setTimeout(Poco::Timespan(20,0));
if (!request.cookies.empty()) {
NameValueCollection mvc;
// cout << "request cookies:" << endl;
for (vector<pair<string,string> >::iterator iter = request.cookies.begin();iter!=request.cookies.end();iter++) {
mvc.add(iter->first, iter->second);
// cout << iter->first << ": " << iter->second << endl;
}
req.setCookies(mvc);
}
if (request.nvc.empty() & request.files.empty()) {
session.sendRequest(req);
} else {
HTMLForm pocoForm;
// create the form data to send
if(request.files.size()>0)
pocoForm.setEncoding(HTMLForm::ENCODING_MULTIPART);
else
pocoForm.setEncoding(HTMLForm::ENCODING_URL);
// form values
for(unsigned i=0; i<request.nvc.size(); i++){
const std::string name = request.nvc[i].first.c_str();
const std::string val = request.nvc[i].second.c_str();
pocoForm.set(name, val);
}
map<string,string>::iterator it;
for(it = request.files.begin(); it!=request.files.end(); it++){
string fileName = it->second.substr(it->second.find_last_of('/')+1);
cout << "adding file: " << fileName << " path: " << it->second << endl;
pocoForm.addPart(it->first,new FilePartSource(it->second));
}
pocoForm.prepareSubmit(req);
pocoForm.write(session.sendRequest(req));
}
HTTPResponse res;
istream& rs = session.receiveResponse(res);
vector<HTTPCookie> pocoCookies;
res.getCookies(pocoCookies);
vector<pair<string,string> > cookies;
// res.write(cout);
for (vector<HTTPCookie>::iterator iter=pocoCookies.begin();iter!=pocoCookies.end();iter++) {
cookies.push_back(make_pair(iter->getName(), iter->getValue()));
}
if(!request.saveTo){
return ofxHttpResponse(request,cookies,rs,res.getStatus(),res.getReason());
}else{
ofFile saveTo(request.name,ofFile::WriteOnly);
char aux_buffer[1024];
rs.read(aux_buffer, 1024);
std::streamsize n = rs.gcount();
while (n > 0){
// we resize to size+1 initialized to 0 to have a 0 at the end for strings
saveTo.write(aux_buffer,n);
if (rs){
rs.read(aux_buffer, 1024);
n = rs.gcount();
}
else n = 0;
}
return ofxHttpResponse(request,cookies,res.getStatus(),res.getReason());
}
} catch (Exception& exc) {
ofLog(OF_LOG_ERROR, "ofxURLFileLoader " + exc.displayText());
return ofxHttpResponse(request,-1,exc.displayText());
}
}
std::istream* HTTPStreamFactory::open(const URI& uri)
{
poco_assert (uri.getScheme() == "http");
URI resolvedURI(uri);
URI proxyUri;
HTTPClientSession* pSession = 0;
HTTPResponse res;
bool retry = false;
bool authorize = false;
std::string username;
std::string password;
try
{
do
{
if (!pSession)
{
pSession = new HTTPClientSession(resolvedURI.getHost(), resolvedURI.getPort());
if (proxyUri.empty())
pSession->setProxy(_proxyHost, _proxyPort);
else
pSession->setProxy(proxyUri.getHost(), proxyUri.getPort());
pSession->setProxyCredentials(_proxyUsername, _proxyPassword);
}
std::string path = resolvedURI.getPathAndQuery();
if (path.empty()) path = "/";
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
if (authorize)
{
HTTPCredentials::extractCredentials(uri, username, password);
HTTPCredentials cred(username, password);
cred.authenticate(req, res);
}
pSession->sendRequest(req);
std::istream& rs = pSession->receiveResponse(res);
bool moved = (res.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY ||
res.getStatus() == HTTPResponse::HTTP_FOUND ||
res.getStatus() == HTTPResponse::HTTP_SEE_OTHER ||
res.getStatus() == HTTPResponse::HTTP_TEMPORARY_REDIRECT);
if (moved)
{
resolvedURI.resolve(res.get("Location"));
if (!username.empty())
{
resolvedURI.setUserInfo(username + ":" + password);
}
throw URIRedirection(resolvedURI.toString());
}
else if (res.getStatus() == HTTPResponse::HTTP_OK)
{
return new HTTPResponseStream(rs, pSession);
}
else if (res.getStatus() == HTTPResponse::HTTP_USEPROXY && !retry)
{
// The requested resource MUST be accessed through the proxy
// given by the Location field. The Location field gives the
// URI of the proxy. The recipient is expected to repeat this
// single request via the proxy. 305 responses MUST only be generated by origin servers.
// only use for one single request!
proxyUri.resolve(res.get("Location"));
delete pSession; pSession = 0;
retry = true; // only allow useproxy once
}
else if (res.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED && !authorize)
{
authorize = true;
retry = true;
Poco::NullOutputStream null;
Poco::StreamCopier::copyStream(rs, null);
}
else throw HTTPException(res.getReason(), uri.toString());
}
while (retry);
throw HTTPException("Too many redirects", uri.toString());
}
catch (...)
{
delete pSession;
throw;
}
}
int GetHeaderAndBodyNormalHttpSession(std::string &url, std::string type)
{
try
{
//printf("Complete URL (%s)\n", url.c_str());
URI uri(url);
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest request(HTTPRequest::HTTP_GET, uri.getPathAndQuery(), "HTTP/1.1");
// request.set("user-agent", "Poco HTTPClientSession");
//request.add("UDN-securelink", "true");
//request.add("X-client-token", "innermatch");
//request.add("X-seq-match", "seqtest1");
//Set session timeout to 10 minutes
//session.setTimeout(Poco::Timespan(1200L,0L));
session.sendRequest(request);
__sync_add_and_fetch(&(requestSent),1);
#if 0
Poco::Net::StreamSocket &str = session.socket();
str.setReceiveTimeout(Poco::Timespan(1200L,0L));
#endif
HTTPResponse response;
std::istream& rs = session.receiveResponse(response);
//printing response headers
#if 0
printf("\n\n\n");
cout << "RESPONSE HEADERS:" <<endl;
cout << response.getReason() <<endl;
cout << response.getStatus() <<endl;
cout << response.getVersion() <<endl;
#endif
if(response.getStatus() != 200)
{
printf("status is not 200 -- for(%s--%d) \n", url.c_str(), response.getStatus());
if(response.getStatus() == 400)
{
__sync_add_and_fetch(&(mo_400_response),1);
}
if(response.getStatus() == 500)
{
__sync_add_and_fetch(&(mo_500_response),1);
}
if(response.getStatus() == 503)
{
__sync_add_and_fetch(&(mo_503_response),1);
}
}
else
{
__sync_add_and_fetch(&(mo_200_response),1);
}
string name;
string lmtheader;
bool isLMTHeaderPresent = false;
string value;
NameValueCollection::ConstIterator i = response.begin();
while(i!=response.end())
{
name=i->first;
value=i->second;
if(name.compare("Last-Modified") == 0)
{
isLMTHeaderPresent = true;
//printf("Last Modified header:%s \n", value.c_str());
}
//cout << name << "=" << value << endl << flush;
++i;
}
if(!isLMTHeaderPresent)
{
__sync_add_and_fetch(&(noLMTHeaders),1);
printf("Last Modified header is not present (%s)\n", url.c_str());
}
#if 0
int ret;
remove("/home/MSD/POCO_LEARNING/poco_examples/pocossl/examples/vipin.mp4");
remove("/opt/universalcache/upload/.cache/*");
std::ofstream out("/home/MSD/POCO_LEARNING/poco_examples/pocossl/examples/vipin.mp4", std::ofstream::binary|std::ofstream::app);
//flush any previous ontent
//out.flush();
unsigned char ciphertext[INTERNAL_RSP_READ_BUFFER];
int totallength = 0;
while(!rs.eof())
{
rs.read ((char *)ciphertext, INTERNAL_RSP_READ_BUFFER);
int ciphertext_len = rs.gcount();
totallength +=ciphertext_len;
out.write ((char *)ciphertext,(size_t)ciphertext_len);
}
//printf("RECEIVED --------(%d) \n",totallength);
out.close();
#endif
}
catch (Exception& ex)
{
__sync_add_and_fetch(&(errors),1);
std::cout <<"ERROR(%s-%s):----"<<type <<"--" <<url <<"---" << ex.displayText() << std::endl;
return 1;
}
}
void ofURLFileLoaderImpl::threadedFunction() {
thread.setName("ofURLFileLoader " + thread.name());
while( isThreadRunning() ){
int cancelled;
while(cancelRequestQueue.tryReceive(cancelled)){
cancelledRequests.insert(cancelled);
}
ofHttpRequest request;
if(requests.receive(request)){
if(cancelledRequests.find(request.getID())==cancelledRequests.end()){
ofHttpResponse response(handleRequest(request));
int status = response.status;
#if __cplusplus>=201103
if(!responses.send(move(response))){
#else
if(!responses.send(response)){
#endif
break;
}
if(status==-1){
// retry
requests.send(request);
}
}else{
cancelledRequests.erase(cancelled);
}
}else{
break;
}
}
}
ofHttpResponse ofURLFileLoaderImpl::handleRequest(ofHttpRequest request) {
try {
URI uri(request.url);
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
HTTPResponse res;
shared_ptr<HTTPSession> session;
istream * rs;
if(uri.getScheme()=="https"){
//const Poco::Net::Context::Ptr context( new Poco::Net::Context( Poco::Net::Context::CLIENT_USE, "", "", "rootcert.pem" ) );
HTTPSClientSession * httpsSession = new HTTPSClientSession(uri.getHost(), uri.getPort());//,context);
httpsSession->setTimeout(Poco::Timespan(20,0));
httpsSession->sendRequest(req);
rs = &httpsSession->receiveResponse(res);
session = shared_ptr<HTTPSession>(httpsSession);
}else{
HTTPClientSession * httpSession = new HTTPClientSession(uri.getHost(), uri.getPort());
httpSession->setTimeout(Poco::Timespan(20,0));
httpSession->sendRequest(req);
rs = &httpSession->receiveResponse(res);
session = shared_ptr<HTTPSession>(httpSession);
}
if(!request.saveTo){
return ofHttpResponse(request,*rs,res.getStatus(),res.getReason());
}else{
ofFile saveTo(request.name,ofFile::WriteOnly,true);
char aux_buffer[1024];
rs->read(aux_buffer, 1024);
std::streamsize n = rs->gcount();
while (n > 0){
// we resize to size+1 initialized to 0 to have a 0 at the end for strings
saveTo.write(aux_buffer,n);
if (rs->good()){
rs->read(aux_buffer, 1024);
n = rs->gcount();
}
else n = 0;
}
return ofHttpResponse(request,res.getStatus(),res.getReason());
}
} catch (const Exception& exc) {
ofLogError("ofURLFileLoader") << "handleRequest(): "+ exc.displayText();
return ofHttpResponse(request,-1,exc.displayText());
} catch (...) {
return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception");
}
return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception");
}
void ofURLFileLoaderImpl::update(ofEventArgs & args){
ofHttpResponse response;
while(responses.tryReceive(response)){
ofNotifyEvent(ofURLResponseEvent(),response);
}
}
int main(int argc, char **argv)
{
string sha256("SHA256");
Poco::Crypto::DigestEngine engine(sha256);
engine.update("test");
//string paylod_hash(engine.digest());
Poco::DigestEngine::Digest paylod_hash = engine.digest();
string payload((Poco::Crypto::DigestEngine::digestToHex(paylod_hash)));
cout << payload << endl;
//cout << paylod_hash << endl;
Document doc;
doc.SetObject();
Document::AllocatorType & allocator = doc.GetAllocator();
doc.AddMember("TableName", "patent", allocator);
doc.AddMember("ProjectionExpression", "patent_id", allocator);
// doc.AddMember("")
string body = doc2str(doc);
string key_id("AKIAIDN3KXQXTMEGVLXA");
string secret("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");
{
string method("POST");
string service("dynamodb");
string host("dynamodb.us-east-1.amazonaws.com");
string uri("/");
string region("us-east-1");
string content_type("application/x-amz-json-1.0");
string amz_target("DynamoDB_20120810.Scan");
string query_string("");
string amz_date = getAmzDate();
string amz_stamp = getDateStamp(amz_date);
string cannocial_header("");
cannocial_header += "content-type:" + content_type + "\n" + \
"host:" + host + "\n" + \
"x-amz-date:" + amz_date + "\n" + \
"x-amz-target:" + amz_target + "\n";
string signed_headers("content-type;host;x-amz-date;x-amz-target");
}
//cout << body << endl;
//doc.AddMember("Limit", 1000, allocator);
string dbHost("192.168.6.170");
Poco::UInt16 dbPort(8000);
HTTPClientSession session;
setSession(session, dbHost, dbPort);
HTTPRequest request;
setRequestHeader(request);
request.setContentLength(body.length());
ostream & os = session.sendRequest(request);
os << body;
HTTPResponse res;
istream &is = session.receiveResponse(res);
int statusCode = (int)res.getStatus();
string status = res.getReason();
// cout << status << endl;
// cout << statusCode << endl;
string uuid_str;
is >> uuid_str;
// cout << uuid_str << endl;
//parse return
Document uuid_doc;
uuid_doc.Parse<0>(uuid_str.c_str());
Value& uuids = uuid_doc["Items"];
for(rapidjson::SizeType i = 0; i < uuids.Size();++i)
{
string id = uuids[i]["patent_id"]["S"].GetString();
//cout << id << endl;
}
// BSONBuilder buildObj;
// string requestHeader = string("host:") + dbHost + '\n';
// requestHeader += string("x-amz-date:") + getAmzDate() +'\n';
// requestHeader += string("x-amz-target:") + "DynamoDB_20120810.CreateTable" +"\n";
// string requestStr = string("AWS4-HMAC-SHA256") + string("GET") +
//HTTPRequest request(HTTPRequest::HTTP_POST, url.getPath(), HTTPRequest::HTTP_1_1);
}
SwiftResult<T>* doSwiftTransaction(Account *_account, std::string &_uriPath,
const std::string &_method, std::vector<HTTPHeader>* _uriParams,
std::vector<HTTPHeader>* _reqMap, std::vector<int> *_httpValidCodes,
const char *bodyReqBuffer, ulong size, std::string *contentType) {
//Start locking
lock_guard<recursive_mutex> guard(transactionMutex);
//Start of function
if (_account == nullptr)
return returnNullError<T>("account");
Endpoint* swiftEndpoint = _account->getSwiftService()->getFirstEndpoint();
if (swiftEndpoint == nullptr)
return returnNullError<T>("SWIFT Endpoint");
//Create parameter map
vector<HTTPHeader> reqParamMap;
//Add authentication token
string tokenID = _account->getToken()->getId();
HTTPHeader authHeader("X-Auth-Token", tokenID);
reqParamMap.push_back(authHeader);
//Add rest of request Parameters
if (_reqMap != nullptr && _reqMap->size() > 0) {
for (uint i = 0; i < _reqMap->size(); i++) {
reqParamMap.push_back(_reqMap->at(i));
}
}
URI uri(swiftEndpoint->getPublicUrl());
string encoded;
URI::encode(_uriPath,"",encoded);
_uriPath = encoded;
if (uri.getPath().size() > 0)
uri.setPath(uri.getPath() + "/" + _uriPath);
else
uri.setPath(_uriPath);
if (_uriParams != nullptr && _uriParams->size() > 0) {
//Create appropriate URI
ostringstream queryStream;
//queryStream << "?";
for (uint i = 0; i < _uriParams->size(); i++) {
if (i > 0)
queryStream << ",";
queryStream << _uriParams->at(i).getQueryValue();
}
uri.setQuery(queryStream.str());
}
//Creating HTTP Session
HTTPResponse *httpResponse = new HTTPResponse();
HTTPClientSession *httpSession = nullptr;
istream* resultStream = nullptr;
try {
/** This operation does not accept a request body. **/
if (bodyReqBuffer == nullptr)
httpSession = doHTTPIO(uri, _method, &reqParamMap);
else {
if (contentType != nullptr)
httpSession = doHTTPIO(uri, _method, &reqParamMap, bodyReqBuffer, size,
*contentType);
else
httpSession = doHTTPIO(uri, _method, &reqParamMap, bodyReqBuffer, size,"");
}
//Now we should increase number of calls to SWIFT API
_account->increaseCallCounter();
if (std::is_same<T, std::istream*>::value)
resultStream = &httpSession->receiveResponse(*httpResponse);
else
httpSession->receiveResponse(*httpResponse);
} catch (Exception &e) {
SwiftResult<T> *result = new SwiftResult<T>();
SwiftError error(SwiftError::SWIFT_EXCEPTION, e.displayText());
result->setError(error);
//Try to set HTTP Response as the payload
result->setSession(httpSession);
result->setResponse(httpResponse);
result->setPayload(nullptr);
return result;
}
/**
* Check HTTP return code
*/
bool valid = false;
for (uint i = 0; i < _httpValidCodes->size(); i++)
if (_httpValidCodes->at(i) == httpResponse->getStatus()) {
valid = true;
break;
}
if (!valid) {
cout<<"Invalid Return code:";
httpResponse->write(cout);
if(httpResponse->getStatus() == 200)
cerr<<"bullshit"<<endl;
if(httpResponse->getStatus() == HTTPResponse::HTTP_UNAUTHORIZED) {
if(_account->reAuthenticate()) {
delete httpSession;httpSession = nullptr;
delete httpResponse;httpResponse = nullptr;
return doSwiftTransaction<T>(_account, _uriPath,_method, _uriParams,
_reqMap, _httpValidCodes, bodyReqBuffer, size, contentType);
}
}
SwiftResult<T> *result = new SwiftResult<T>();
string errorText = "Code:";
errorText+= httpResponse->getStatus()+"\tReason:"+httpResponse->getReason();
SwiftError error(SwiftError::SWIFT_HTTP_ERROR, errorText);
result->setError(error);
result->setSession(httpSession);
result->setResponse(httpResponse);
result->setPayload(nullptr);
return result;
}
//Everything seems fine
SwiftResult<T> *result = new SwiftResult<T>();
result->setError(SWIFT_OK);
result->setSession(httpSession);
result->setResponse(httpResponse);
result->setPayload((T)resultStream);
//Cleanup
return result;
}
int main()
{
AutoPtr<XMLConfiguration> pConf(new XMLConfiguration("settings.xml")); // instantiating the XMLConfiguration and reading from setting.xml
char buffer[2048];
memset(buffer, 0, sizeof buffer);
int flags;
int n;
string payload;
string out;
int msg_cnt = 0;
pthread_t fifoReadThread; //indivudual thread for fifo so it doesn't block other stuff
int iret1 = pthread_create(&fifoReadThread, NULL, CreatePiSocketFifo, NULL);
//variables to be set in xml config file //
string signalr_service_url = pConf->getString("signalr_url");
string signalr_url_endpoint = pConf->getString("signalr_url_endpoint");
int signalr_service_port = pConf->getInt("signalr_port");
int timeout_seconds = pConf->getInt("timeout");
string api_endpoint_url = pConf->getString("api_endpoint_url"); // ""
//pipe_from_main = pConf->getString("pipe_from_main");
//string pipe_from_socket = pConf->getString("pipe_from_socket");
//--------------------------------------//
//cout << endl << "=============================================================" << endl;
//cout << "api_endpoint_url -> " << api_endpoint_url << endl;
//cout << "signalr_url_endpoint -> " << signalr_url_endpoint << endl;
//cout << "signalr_service_port -> " << signalr_service_port << endl;
//cout << "timeout_seconds -> " << timeout_seconds << endl;
//cout << "api_endpoint_url -> " << api_endpoint_url << endl;
//cout << "pipe_from_main -> " << pipe_from_main;
//cout << endl << "=============================================================" << endl << endl;
//cout << "Opening pipe: " << pipe_from_main << endl;
//fd = open(pipe_from_main.c_str(), O_WRONLY); // open pipe as readonly
//write(fd, "Hello World", sizeof("Hello World"));
//close(fd);
conn: //label for the goto's in the catches
try{
time_t seconds_past_epoch = time(0);
cout << "STARTING " << endl;
char port[100];
char id[100];
snprintf(port, sizeof(port), "%d", signalr_service_port); // converting int variables to char[]
snprintf(id, sizeof(id), "%ld", (seconds_past_epoch * 1000)); // converting int variables to char[]
string my_mac = getMACC(); //Get the mac address
//compose the URI for getting the token
URI uri("http://" + signalr_service_url + ":" + port + "/" + signalr_url_endpoint + "/negotiate?_" + id + "&UID=" + my_mac);
HTTPClientSession session(uri.getHost(), uri.getPort()); // instantiating a client session
//if there is a network problem between Pi and SignalR everything will break and the catch will point back to the goto label
//we set this in order to a lower minimise the retry period thus the downtime
session.setTimeout(timeout_seconds * 1e+6); // time in microseconds;
string path(uri.getPathAndQuery());
// send the request
HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
session.sendRequest(req);
StringTokenizer tokenizer(session.socket().address().toString(), ":", StringTokenizer::TOK_TRIM); // get the request originating address:ip from the session socket initiated by HTPP; tokenize it for IP extraction
//string my_mac = getMAC((tokenizer[0]).c_str()); // call IP to MAC converter
// get response
HTTPResponse res;
istream& is = session.receiveResponse(res); // stream the request
cout << res.getStatus() << " " << res.getReason() << endl; // get the status code of the transaction
// convert the istream to sting for further processing
istreambuf_iterator<char> eos;
string s(istreambuf_iterator<char>(is), eos);
const char * cc = s.c_str();
// instantiate a rapidjson document and fill it up with the response of the negotiation request
rapidjson::Document document;
document.Parse<0>(cc);
string token = document["ConnectionToken"].GetString(); // parse the response and get the connectionToken
//=============================================
//connect to signarR using the connectionToken got previously
HTTPClientSession cs(signalr_service_url, signalr_service_port); // instantiate simple webclient
string what = "/" + signalr_url_endpoint + "/connect?transport=webSockets&connectionToken=" + urlencode(token) + "&UID=" + my_mac + "&connectionData=%5B%7B%22name%22%3A%22myhub%22%7D%5D&tid=10"; // compose the request string
HTTPRequest request(HTTPRequest::HTTP_GET, what, "HTTP/1.1"); // the protocol MUST be HTTP/1.1, as described in RFC6455; else the UPGRADE to websocket request will fail
request.set("Host", signalr_service_url); // specify the Host header to be sent
HTTPResponse response; // instantiate a http response
cout << response.getStatus() << " " << response.getReason() << endl;
WebSocket * ws = new WebSocket(cs, request, response); // instantiate a WebSocket transaction to the 'cs' session, sending the 'request' and storing the 'response'
//sample of a message to be sent
payload = "{\"H\":\"myhub\",\"M\":\"Send\",\"A\":[\"" + my_mac + "\",\"invoked from " + replaceInPlace(my_mac, std::string(":"), std::string("-")) + " client\"],\"I\":0}";
// cout << endl << payload << endl ;
ws->sendFrame(payload.data(), payload.size(), WebSocket::FRAME_TEXT); // send the message to signalR using the payload and setting the type of frame to be sent as FRAME_TEXT
flags = 1;
// starting the receiving loop
while( (flags & WebSocket::FRAME_OP_BITMASK) != WebSocket::FRAME_OP_CLOSE ) // while websocket session open
{
n = ws->receiveFrame(buffer, sizeof(buffer), flags); // n is the received frame
// flags store the response flags of the frame
// 129 = single frame response
// 1 = start of multi-frame response
// 0 = continuation frame of a multi-frame response
// 128 = FIN frame os a multi-frame response
// signalR send data in JSON format, and it send empty messages (empty json document) on a regular basis
if( (n != 2) && flags !=1 ) // filter out empty jsons and multiframe responses (multiframe will be treated further on)
{
cout << "RCV[" << msg_cnt << "]=> " << buffer << " ===== " << unsigned(flags) << endl;
}
if(flags == 1){ // if I get a start frame of a multi-frame response means that I am getting something usefull from signalR
string str(buffer);
out += str;
// due to flag == 1, we are expecting several frames, until we got flag == 128
do{
n = ws->receiveFrame(buffer, sizeof(buffer), flags);
string str(buffer);
out += str; // we add the next frame/frames to the out variable, to construct the whole JSON message
str = "";
memset(buffer, 0, sizeof buffer); // be sure to empty the buffer to don't end up with junk
}while(flags != 128);
cout << endl << "=> " << out << endl;
//not as we got a valid response from signalR endpoint, lets process it
//convert the out variable and pass is as a Document to the JSON parser
const char * c = out.c_str();
rapidjson::Document document;
document.Parse<0>(c);
out = document["M"][rapidjson::SizeType(0)]["A"][rapidjson::SizeType(1)].GetString(); // get out only the actual sent message from the response message
SendMessageToMain(out.c_str());
cout << "Msg Received";
message_action(api_endpoint_url,out); // do something with the message in the message_action function
out = "";
}
msg_cnt++;
memset(buffer, 0, sizeof buffer); // we always cleanup
}
ws->shutdown();
}
// if something goes wrong with the connection, we try to recover
catch (WebSocketException& exc0)
{
cout <<"WebSocketException "<< exc0.displayText() << endl;
}
catch (Poco::TimeoutException& exc1) // handle webclient errors
{
goto conn; // lets try again from the top
cout <<"TimeoutException "<< exc1.displayText() << endl;
// return 1;
}
catch (ConnectionResetException& exc) // handle connec errors
{
goto conn; // lets try again from the top
cout << "!!!ConnectionResetException:" << exc.displayText() << endl;
// return 1;
}
cout << strerror(errno) << endl;
return 0;
}
