void HTMLFormTest::testSubmit2()
{
HTMLForm form;
form.set("field1", "value1");
form.set("field2", "value 2");
form.set("field3", "value=3");
form.set("field4", "value&4");
HTTPRequest req("POST", "/form.cgi");
form.prepareSubmit(req);
assert (req.getContentType() == HTMLForm::ENCODING_URL);
}
void HTMLFormTest::testSubmit1()
{
HTMLForm form;
form.set("field1", "value1");
form.set("field2", "value 2");
form.set("field3", "value=3");
form.set("field4", "value&4");
HTTPRequest req("GET", "/form.cgi");
form.prepareSubmit(req);
assert (req.getURI() == "/form.cgi?field1=value1&field2=value%202&field3=value%3D3&field4=value%264");
}
void HTMLFormTest::testWriteUrl()
{
HTMLForm form;
form.set("field1", "value1");
form.set("field2", "value 2");
form.set("field3", "value=3");
form.set("field4", "value&4");
form.set("field5", "value+5");
std::ostringstream ostr;
form.write(ostr);
std::string s = ostr.str();
assert (s == "field1=value1&field2=value%202&field3=value%3D3&field4=value%264&field5=value%2B5");
}
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;
}
//-------------------------------------------------------------
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;
}
// ----------------------------------------------------------------------
ofxHttpResponse ofxHttpUtils::doPostForm(ofxHttpForm & form){
ofxHttpResponse response;
try{
URI uri( form.action.c_str() );
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
//HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1);
if(auth.getUsername()!="") auth.authenticate(req);
if(sendCookies){
for(unsigned i=0; i<cookies.size(); i++){
NameValueCollection reqCookies;
reqCookies.add(cookies[i].getName(),cookies[i].getValue());
req.setCookies(reqCookies);
}
}
for (unsigned int i = 0; i < form.headerIds.size(); ++i) {
const std::string name = form.headerIds[i].c_str();
const std::string val = form.headerValues[i].c_str();
req.set(name, val);
}
HTTPResponse res;
HTMLForm pocoForm;
// create the form data to send
if(form.formFiles.size()>0) {
pocoForm.setEncoding(HTMLForm::ENCODING_MULTIPART);
}
else {
pocoForm.setEncoding(HTMLForm::ENCODING_URL);
}
// form values
for(unsigned i=0; i<form.formIds.size(); i++){
const std::string name = form.formIds[i].c_str();
const std::string val = form.formValues[i].c_str();
pocoForm.set(name, val);
}
map<string,string>::iterator it;
for(it = form.formFiles.begin(); it!=form.formFiles.end(); it++){
string fileName = it->second.substr(it->second.find_last_of('/')+1);
ofLogVerbose("ofxHttpUtils") << "adding file: " << fileName << " path: " << it->second;
pocoForm.addPart(it->first,new FilePartSource(it->second));
}
pocoForm.prepareSubmit(req);
ofPtr<HTTPSession> session;
istream * rs;
if(uri.getScheme()=="https"){
HTTPSClientSession * httpsSession = new HTTPSClientSession(uri.getHost(), uri.getPort());//,context);
httpsSession->setTimeout(Poco::Timespan(20,0));
pocoForm.write(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));
pocoForm.write(httpSession->sendRequest(req));
rs = &httpSession->receiveResponse(res);
session = ofPtr<HTTPSession>(httpSession);
}
response = ofxHttpResponse(res, *rs, form.action);
if(sendCookies){
cookies.insert(cookies.begin(),response.cookies.begin(),response.cookies.end());
}
if(response.status>=300 && response.status<400){
Poco::URI uri(req.getURI());
uri.resolve(res.get("Location"));
response.location = uri.toString();
}
ofNotifyEvent(newResponseEvent, response, this);
}catch (Exception& exc){
ofLogError("ofxHttpUtils") << "ofxHttpUtils error doPostForm -- " << form.action.c_str();
//ofNotifyEvent(notifyNewError, "time out", this);
// for now print error, need to broadcast a response
ofLogError("ofxHttpUtils") << exc.displayText();
response.status = -1;
response.reasonForStatus = exc.displayText();
ofNotifyEvent(newResponseEvent, response, this);
}
return response;
}
// ----------------------------------------------------------------------
int ofxHttpUtils::doPostForm(ofxHttpForm & form){
int ret = -1;
try{
URI uri( form.action.c_str() );
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1);
if(auth.getUsername()!="") auth.authenticate(req);
if(sendCookies){
for(unsigned i=0; i<cookies.size(); i++){
NameValueCollection reqCookies;
reqCookies.add(cookies[i].getName(),cookies[i].getValue());
req.setCookies(reqCookies);
}
}
HTMLForm pocoForm;
// create the form data to send
if(form.formFiles.size()>0)
pocoForm.setEncoding(HTMLForm::ENCODING_MULTIPART);
else
pocoForm.setEncoding(HTMLForm::ENCODING_URL);
// form values
for(unsigned i=0; i<form.formIds.size(); i++){
const std::string name = form.formIds[i].c_str();
const std::string val = form.formValues[i].c_str();
pocoForm.set(name, val);
}
map<string,string>::iterator it;
for(it = form.formFiles.begin(); it!=form.formFiles.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);
ofxHttpResponse response = ofxHttpResponse(res, rs, path);
if(sendCookies){
cookies.insert(cookies.begin(),response.cookies.begin(),response.cookies.end());
}
ofNotifyEvent(newResponseEvent, response, this);
ret = 0;
}catch (Exception& exc){
printf("ofxHttpUtils error--\n");
//ofNotifyEvent(notifyNewError, "time out", this);
// for now print error, need to broadcast a response
std::cerr << exc.displayText() << std::endl;
}
return ret;
}
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());
}
}