Changeset - 3f29cad42ba7
[Not reviewed]
Merge
! ! !
Jan Kaluza - 13 years ago 2012-08-07 07:33:25
hanzz.k@gmail.com
Merge pull request #11 from sarangbh/twitter-backend

Twitter backend
58 files changed:
Changeset was too big and was cut off... Show full diff anyway
0 comments (0 inline, 0 general)
backends/CMakeLists.txt
Show inline comments
 
@@ -16,6 +16,8 @@ if (PROTOBUF_FOUND)
 
# 	endif()
 

	
 
	ADD_SUBDIRECTORY(template)
 
	
 
	ADD_SUBDIRECTORY(twitter)
 

	
 
if (NOT WIN32)
 
	ADD_SUBDIRECTORY(frotz)
backends/twitter/CMakeLists.txt
Show inline comments
 
new file 100644
 
include_directories (${libtransport_SOURCE_DIR}/backends/twitter/libtwitcurl) 
 
FILE(GLOB SRC *.cpp libtwitcurl/*.cpp Requests/*.cpp)
 
add_executable(spectrum_twitter_backend ${SRC})
 
#add_executable(parser TwitterResponseParser.cpp test.cpp)
 
target_link_libraries(spectrum_twitter_backend curl transport pthread sqlite3 ${Boost_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES})
 
#target_link_libraries(parser curl transport pthread sqlite3 ${Boost_LIBRARIES} ${SWIFTEN_LIBRARY} ${LOG4CXX_LIBRARIES})
backends/twitter/HTTPRequest.cpp
Show inline comments
 
new file 100644
 
#include "HTTPRequest.h"
 
DEFINE_LOGGER(logger, "HTTPRequest")
 

	
 
bool HTTPRequest::init()
 
{
 
	curlhandle = curl_easy_init();
 
	if(curlhandle) {
 
		curlhandle = curl_easy_init();
 
		curl_easy_setopt(curlhandle, CURLOPT_PROXY, NULL);
 
		curl_easy_setopt(curlhandle, CURLOPT_PROXYUSERPWD, NULL);
 
		curl_easy_setopt(curlhandle, CURLOPT_PROXYAUTH, (long)CURLAUTH_ANY);
 
		return true;
 
	}
 
	LOG4CXX_ERROR(logger, "Couldn't Initialize curl!")
 
	return false;
 
}
 

	
 
void HTTPRequest::setProxy(std::string IP, std::string port, std::string username, std::string password)
 
{
 
	if(curlhandle) {
 
		std::string proxyIpPort = IP + ":" + port;
 
		curl_easy_setopt(curlhandle, CURLOPT_PROXY, proxyIpPort.c_str());
 
		if(username.length() && password.length()) {
 
			std::string proxyUserPass = username + ":" + password;
 
			curl_easy_setopt(curlhandle, CURLOPT_PROXYUSERPWD, proxyUserPass.c_str());
 
		}
 
	} else {
 
		LOG4CXX_ERROR(logger, "Trying to set proxy while CURL isn't initialized")
 
	}
 
}
 

	
 
int HTTPRequest::curlCallBack(char* data, size_t size, size_t nmemb, HTTPRequest* obj)
 
{
 
    int writtenSize = 0;
 
    if(obj && data) {
 
       obj->callbackdata.append(data, size*nmemb);
 
	   writtenSize = (int)(size*nmemb);
 
    }
 
    return writtenSize;
 
}
 

	
 

	
 
bool HTTPRequest::GET(std::string url, 	std::string &data)
 
{
 
	if(curlhandle) {
 
		curl_easy_setopt(curlhandle, CURLOPT_CUSTOMREQUEST, NULL);
 
		curl_easy_setopt(curlhandle, CURLOPT_ENCODING, "");
 
		
 
		data = "";
 
		callbackdata = "";
 
		memset(curl_errorbuffer, 0, 1024);
 
		
 
		curl_easy_setopt(curlhandle, CURLOPT_ERRORBUFFER, curl_errorbuffer);
 
		curl_easy_setopt(curlhandle, CURLOPT_WRITEFUNCTION, curlCallBack);
 
		curl_easy_setopt(curlhandle, CURLOPT_WRITEDATA, this);
 
			
 
		/* Set http request and url */
 
		curl_easy_setopt(curlhandle, CURLOPT_HTTPGET, 1);
 
		curl_easy_setopt(curlhandle, CURLOPT_VERBOSE, 1);
 
		curl_easy_setopt(curlhandle, CURLOPT_URL, url.c_str());
 
		
 
		/* Send http request and return status*/
 
		if(CURLE_OK == curl_easy_perform(curlhandle)) {
 
			data = callbackdata;
 
			return true;
 
		}
 
	} else {
 
		LOG4CXX_ERROR(logger, "CURL not initialized!")
 
		strcpy(curl_errorbuffer, "CURL not initialized!");
 
	}
 
	return false;
 
}
backends/twitter/HTTPRequest.h
Show inline comments
 
new file 100644
 
#ifndef HTTPREQ_H
 
#define HTTPREQ_H
 

	
 
#include "libtwitcurl/curl/curl.h"
 
#include "transport/logging.h"
 
#include <iostream>
 
#include <sstream>
 
#include <string.h>
 

	
 
class HTTPRequest
 
{
 
	CURL *curlhandle;
 
	char curl_errorbuffer[1024];
 
	std::string error;
 
	std::string callbackdata;
 

	
 
    static int curlCallBack(char* data, size_t size, size_t nmemb, HTTPRequest *obj);
 

	
 
	public:
 
	HTTPRequest() {
 
		curlhandle = NULL;
 
	}
 

	
 
	~HTTPRequest() {
 
		if(curlhandle) {
 
			curl_easy_cleanup(curlhandle);
 
			curlhandle = NULL;
 
		}
 
	}
 

	
 
	bool init();
 
	void setProxy(std::string, std::string, std::string, std::string);
 
	bool GET(std::string, std::string &);
 
	std::string getCurlError() {return std::string(curl_errorbuffer);}
 
};
 

	
 
#endif
backends/twitter/Requests/CreateFriendRequest.cpp
Show inline comments
 
new file 100644
 
#include "CreateFriendRequest.h"
 
#include "../HTTPRequest.h"
 
DEFINE_LOGGER(logger, "CreateFriendRequest")
 

	
 
void CreateFriendRequest::run()
 
{
 
	LOG4CXX_INFO(logger, user << " - Sending follow request for " << frnd)
 
	replyMsg = "";
 
	success = twitObj->friendshipCreate(frnd, false);
 
	if(success) {
 
		twitObj->getLastWebResponse(replyMsg);
 

	
 
		LOG4CXX_INFO(logger, user << replyMsg)		
 

	
 
	   	friendInfo = getUser(replyMsg);
 
		if(friendInfo.getScreenName() == "") {LOG4CXX_INFO(logger, user << " - Was unable to fetch user info for " << frnd)}
 
		
 
		HTTPRequest req;
 
		std::string img;
 
		
 
		req.init();
 
		req.setProxy(twitObj->getProxyServerIp(), twitObj->getProxyServerPort(), twitObj->getProxyUserName(), twitObj->getProxyPassword());
 

	
 
		profileImg = "";
 
		if(req.GET(friendInfo.getProfileImgURL(), img)) profileImg = img;
 
		else {
 
			LOG4CXX_INFO(logger, user << " - Was unable to fetch profile image of user " << frnd);
 
		}
 

	
 
	}
 
}
 

	
 
void CreateFriendRequest::finalize()
 
{
 
	if(!success) {
 
		std::string error;
 
		twitObj->getLastCurlError(error);
 
		LOG4CXX_ERROR(logger, user << " - Curl error: " << error)
 
		callBack(user, friendInfo, profileImg, error);
 
	} else {
 
		std::string error;
 
		error = getErrorMessage(replyMsg);
 
		if(error.length()) {
 
			LOG4CXX_ERROR(logger, user << " - " << error)
 
		}
 
		else LOG4CXX_INFO(logger, user << ": Now following " << frnd)
 
		callBack(user, friendInfo, profileImg, error);
 
	}
 
}
backends/twitter/Requests/CreateFriendRequest.h
Show inline comments
 
new file 100644
 
#ifndef CREATE_FRIEND
 
#define CREATE_FRIEND
 

	
 
#include "../ThreadPool.h"
 
#include "../TwitterResponseParser.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "transport/logging.h"
 
#include <string>
 
#include <boost/function.hpp>
 
#include <iostream>
 
#include <vector>
 

	
 
using namespace Transport;
 

	
 
class CreateFriendRequest : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string user;
 
	std::string frnd;
 
	std::string replyMsg;
 
	boost::function< void (std::string&, User&, std::string &, std::string&) > callBack;
 
	User friendInfo;
 
	std::string profileImg;	
 
	bool success;
 

	
 
	public:
 
	CreateFriendRequest(twitCurl *obj, const std::string &_user, const std::string & _frnd,
 
			     		 boost::function< void (std::string&, User&, std::string &, std::string&) >  cb) {
 
		twitObj = obj->clone();
 
		user = _user;
 
		frnd = _frnd;
 
		callBack = cb;
 
	}
 

	
 
	~CreateFriendRequest() {
 
		delete twitObj;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/DestroyFriendRequest.cpp
Show inline comments
 
new file 100644
 
#include "DestroyFriendRequest.h"
 
DEFINE_LOGGER(logger, "DestroyFriendRequest")
 

	
 
void DestroyFriendRequest::run()
 
{
 
	replyMsg = "";
 
	success = twitObj->friendshipDestroy(frnd, false);
 
	if(success) {
 
		twitObj->getLastWebResponse(replyMsg);
 
		
 
		LOG4CXX_INFO(logger, user << replyMsg)		
 
		
 

	
 
	   	friendInfo = getUser(replyMsg);
 
		if(friendInfo.getScreenName() == "") LOG4CXX_INFO(logger, user << " - Was unable to fetch user info for " << frnd);
 
	}
 
}
 

	
 
void DestroyFriendRequest::finalize()
 
{
 
	if(!success) {
 
		std::string error;
 
		twitObj->getLastCurlError(error);
 
		LOG4CXX_ERROR(logger, user << " Curl error: " << error)
 
		callBack(user, friendInfo, error);
 
	} else {
 
		std::string error;
 
		error = getErrorMessage(replyMsg);
 
		if(error.length()) LOG4CXX_ERROR(logger, user << " - " << error)
 
		callBack(user, friendInfo, error);
 
	}
 
}
backends/twitter/Requests/DestroyFriendRequest.h
Show inline comments
 
new file 100644
 
#ifndef DESTROY_FRIEND
 
#define DESTROY_FRIEND
 

	
 
#include "../ThreadPool.h"
 
#include "../TwitterResponseParser.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "transport/logging.h"
 
#include <string>
 
#include <boost/function.hpp>
 
#include <iostream>
 
#include <vector>
 

	
 
using namespace Transport;
 

	
 
class DestroyFriendRequest : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string user;
 
	std::string frnd;
 
	std::string replyMsg;
 
	boost::function< void (std::string&, User&, std::string&) > callBack;
 
	User friendInfo;	
 
	bool success;
 

	
 
	public:
 
	DestroyFriendRequest(twitCurl *obj, const std::string &_user, const std::string & _frnd,
 
			     		 boost::function< void (std::string&, User&, std::string&) >  cb) {
 
		twitObj = obj->clone();
 
		user = _user;
 
		frnd = _frnd;
 
		callBack = cb;
 
	}
 

	
 
	~DestroyFriendRequest() {
 
		delete twitObj;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/DirectMessageRequest.cpp
Show inline comments
 
new file 100644
 
#include "DirectMessageRequest.h"
 

	
 
DEFINE_LOGGER(logger, "DirectMessageRequest")
 

	
 
void DirectMessageRequest::run() 
 
{
 
	replyMsg = "";
 
	if(username != "") success = twitObj->directMessageSend(username, data, false);
 
	else success = twitObj->directMessageGet(data); /* data will contain sinceId */
 

	
 
	if(success) {
 
		twitObj->getLastWebResponse( replyMsg );
 
		if(username == "" ) messages = getDirectMessages( replyMsg );
 
	}
 
}
 

	
 
void DirectMessageRequest::finalize()
 
{
 
	if(!success) {
 
		twitObj->getLastCurlError( replyMsg );
 
		LOG4CXX_ERROR(logger, user << " Curl error: " << replyMsg);
 
		callBack(user, username, messages, replyMsg);
 
	} else {
 
		std::string error = getErrorMessage(replyMsg);
 
		if(error.length()) LOG4CXX_ERROR(logger,  user << " - " << error)
 
		else LOG4CXX_INFO(logger, user << " - " << replyMsg)
 
		callBack(user, username, messages, error);	
 
	}
 
}
backends/twitter/Requests/DirectMessageRequest.h
Show inline comments
 
new file 100644
 
#ifndef DIRECT_MESSAGE
 
#define DIRECT_MESSAGE
 

	
 
#include "../ThreadPool.h"
 
#include "../TwitterResponseParser.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "transport/logging.h"
 
#include <string>
 
#include <boost/function.hpp>
 
#include <iostream>
 

	
 
using namespace Transport;
 

	
 
class DirectMessageRequest : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string data;
 
	std::string user;
 
	std::string username;
 
	std::string replyMsg;
 
	boost::function< void (std::string&, std::string &, std::vector<DirectMessage>&, std::string&) > callBack;
 
	std::vector<DirectMessage> messages;
 
	bool success;
 

	
 
	public:
 
	DirectMessageRequest(twitCurl *obj, const std::string &_user, const std::string & _username, const std::string &_data,
 
			     		boost::function< void (std::string&, std::string &, std::vector<DirectMessage>&, std::string&) >  cb) {
 
		twitObj = obj->clone();
 
		data = _data;
 
		user = _user;
 
		username = _username;
 
		callBack = cb;
 
	}
 

	
 
	~DirectMessageRequest() {
 
		delete twitObj;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/FetchFriends.cpp
Show inline comments
 
new file 100644
 
#include "FetchFriends.h"
 
#include "../HTTPRequest.h"
 

	
 
DEFINE_LOGGER(logger, "FetchFriends")
 

	
 
void FetchFriends::run() 
 
{	
 
	replyMsg = ""; 
 

	
 
	success = twitObj->friendsIdsGet(twitObj->getTwitterUsername());
 
	if(!success) return;	
 

	
 
	twitObj->getLastWebResponse( replyMsg );
 
	std::vector<std::string> IDs = getIDs( replyMsg );
 
	
 
	success = twitObj->userLookup(IDs, true);
 
	if(!success) return;
 

	
 
	twitObj->getLastWebResponse( replyMsg );
 
	friends = getUsers( replyMsg );
 

	
 
	HTTPRequest req;
 
	req.init();
 
	req.setProxy(twitObj->getProxyServerIp(), twitObj->getProxyServerPort(), twitObj->getProxyUserName(), twitObj->getProxyPassword());
 
	
 
	for(int i=0 ; i<friends.size() ; i++) {
 
		std::string img;
 
		friendAvatars.push_back("");
 
		if(req.GET(friends[i].getProfileImgURL(), img)) friendAvatars[i] = img;
 
		else {
 
			LOG4CXX_INFO(logger, "Warning: Couldn't fetch Profile Image for " << user << "'s friend " << friends[i].getScreenName())
 
		}
 
	}
 
}
 

	
 
void FetchFriends::finalize()
 
{
 
	if(!success) {
 
		twitObj->getLastCurlError( replyMsg );
 
		LOG4CXX_ERROR(logger,  user << " - " << replyMsg)
 
		callBack(user, friends, friendAvatars, replyMsg);
 
	} else {
 
		std::string error = getErrorMessage(replyMsg);
 
		if(error.length()) LOG4CXX_ERROR(logger,  user << " - " << error)
 
		callBack(user, friends, friendAvatars, error);	
 
	} 
 
}
backends/twitter/Requests/FetchFriends.h
Show inline comments
 
new file 100644
 
#ifndef FRIENDS_H
 
#define FRIENDS_H
 

	
 
#include "../ThreadPool.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "../TwitterResponseParser.h"
 
#include "transport/logging.h"
 
#include <string>
 
#include <boost/signals.hpp>
 
#include <boost/function.hpp>
 
#include <boost/bind.hpp>
 
#include <iostream>
 

	
 
using namespace Transport;
 

	
 
class FetchFriends : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string user;
 
	std::string replyMsg;
 
	std::vector<User> friends;
 
	std::vector<std::string> friendAvatars;
 
	bool success;
 
	boost::function< void (std::string, std::vector<User> &, std::vector<std::string> &, std::string) > callBack;
 

	
 
	public:
 
	FetchFriends(twitCurl *obj, const std::string &_user, 
 
			     boost::function< void (std::string, std::vector<User> &, std::vector<std::string> &, std::string) >  cb) {
 
		twitObj = obj->clone();
 
		user = _user;
 
		callBack = cb;
 
	}
 

	
 
	~FetchFriends() {
 
		delete twitObj;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 
#endif
backends/twitter/Requests/HelpMessageRequest.cpp
Show inline comments
 
new file 100644
 
#include "HelpMessageRequest.h"
 
DEFINE_LOGGER(logger, "HelpMessageRequest")
 
void HelpMessageRequest::run() 
 
{
 
	helpMsg = helpMsg
 
			+ "\n******************************HELP************************************\n"
 
			+ "#status <your status>      ==> Update your status\n"
 
			+ "#timeline [username]       ==> Retrieve <username>'s timeline; Default - own timeline\n"
 
			+ "@<username> <message>      ==> Send a directed message to the user <username>\n"
 
			+ "#retweet <unique_tweet_id> ==> Retweet the tweet having id <unique_tweet_id> \n"
 
			+ "#follow <username>         ==> Follow user <username>\n"
 
			+ "#unfollow <username>       ==> Stop Following user <username>\n"
 
			+ "#mode [012]                ==> Switch mode to 0(single), 1(multiple) or 2(chatroom)\n"
 
			+ "#help                      ==> Print this help message\n"
 
			+ "************************************************************************\n";
 
}
 

	
 
void HelpMessageRequest::finalize()
 
{
 
	callBack(user, helpMsg);
 
}
backends/twitter/Requests/HelpMessageRequest.h
Show inline comments
 
new file 100644
 
#ifndef HELPMESSAGE_H
 
#define HELPMESSAGE_H
 

	
 
#include "../ThreadPool.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "transport/networkplugin.h"
 
#include "transport/logging.h"
 
#include <string>
 
#include <boost/function.hpp>
 
#include <iostream>
 

	
 
using namespace Transport;
 

	
 
class HelpMessageRequest : public Thread
 
{
 
	std::string user;
 
	std::string helpMsg;
 
	boost::function<void (std::string &, std::string &)> callBack;
 
	
 
	public:
 
	HelpMessageRequest(const std::string &_user, boost::function<void (std::string &, std::string &)> cb) {
 
		user = _user;
 
		callBack = cb;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/OAuthFlow.cpp
Show inline comments
 
new file 100644
 
#include "OAuthFlow.h"
 
DEFINE_LOGGER(logger, "OAuthFlow")
 
void OAuthFlow::run()
 
{
 
	success = twitObj->oAuthRequestToken( authUrl );
 
}
 

	
 
void OAuthFlow::finalize()
 
{
 
	if (!success) {
 
		LOG4CXX_ERROR(logger, "Error creating twitter authorization url!");
 
		np->handleMessage(user, "twitter-account", "Error creating twitter authorization url!");
 
		np->handleLogoutRequest(user, username);
 
	} else {
 
		np->handleMessage(user, "twitter-account", std::string("Please visit the following link and authorize this application: ") + authUrl);
 
		np->handleMessage(user, "twitter-account", std::string("Please reply with the PIN provided by twitter. Prefix the pin with '#pin'. Ex. '#pin 1234'"));
 
		np->OAuthFlowComplete(user, twitObj);
 
	}	
 
}
backends/twitter/Requests/OAuthFlow.h
Show inline comments
 
new file 100644
 
#ifndef OAUTH_FLOW
 
#define OAUTH_FLOW
 

	
 
#include "../ThreadPool.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "../TwitterPlugin.h"
 
#include "transport/logging.h"
 

	
 
#include <string>
 
#include <iostream>
 

	
 
//class TwitterPlugin;
 
using namespace Transport;
 
class OAuthFlow : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string username;
 
	std::string user;
 
	std::string authUrl;
 
	TwitterPlugin *np;
 
	bool success;
 
	
 
	public:
 
	OAuthFlow(TwitterPlugin *_np, twitCurl *obj, const std::string &_user, const std::string &_username) {
 
		twitObj = obj->clone();
 
		username = _username;
 
		user = _user;
 
		np = _np;
 
	}
 

	
 
	~OAuthFlow() {
 
		delete twitObj;
 
	}	
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/PINExchangeProcess.cpp
Show inline comments
 
new file 100644
 
#include "PINExchangeProcess.h"
 
DEFINE_LOGGER(logger, "PINExchangeProcess")
 
void PINExchangeProcess::run()
 
{
 
	LOG4CXX_INFO(logger, user << ": Sending PIN " << data) 
 
	LOG4CXX_INFO(logger, user << " " << twitObj->getProxyServerIp() << " " << twitObj->getProxyServerPort())
 
	twitObj->getOAuth().setOAuthPin( data );
 
	success = twitObj->oAuthAccessToken();
 
}
 

	
 
void PINExchangeProcess::finalize()
 
{
 
	if(!success) {
 
		LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token!")
 
		np->handleMessage(user, "twitter-account", "Error while exchanging PIN for Access Token!");
 
		np->handleLogoutRequest(user, "");
 
	} else {
 
		std::string replyMsg;
 
		while(replyMsg.length() == 0) {
 
			twitObj->getLastWebResponse(replyMsg);
 
		}
 

	
 
		std::string error = getErrorMessage(replyMsg);
 
		if(error.length()) {
 
			LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token! " << error)
 
			np->handleMessage(user, "twitter-account", error);
 
			np->handleLogoutRequest(user, "");
 
			return;
 
		}
 

	
 

	
 
		std::string OAuthAccessTokenKey, OAuthAccessTokenSecret;
 
		twitObj->getOAuth().getOAuthTokenKey( OAuthAccessTokenKey );
 
		twitObj->getOAuth().getOAuthTokenSecret( OAuthAccessTokenSecret );
 

	
 
		if(np->storeUserOAuthKeyAndSecret(user, OAuthAccessTokenKey, OAuthAccessTokenSecret) == false) {
 
			np->handleLogoutRequest(user, "");
 
			return;
 
		}
 
		np->pinExchangeComplete(user, OAuthAccessTokenKey, OAuthAccessTokenSecret);
 
		LOG4CXX_INFO(logger, user << ": Sent PIN " << data << " and obtained Access Token");
 
	}
 
}
 

	
 
/*void handlePINExchange(const std::string &user, std::string &data) {
 
	sessions[user]->getOAuth().setOAuthPin( data );
 
	if (sessions[user]->oAuthAccessToken() == false) {
 
		LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token!")
 
		handleLogoutRequest(user, "");
 
		return;
 
	}
 
	
 
	std::string OAuthAccessTokenKey, OAuthAccessTokenSecret;
 
	sessions[user]->getOAuth().getOAuthTokenKey( OAuthAccessTokenKey );
 
	sessions[user]->getOAuth().getOAuthTokenSecret( OAuthAccessTokenSecret );
 

	
 
	UserInfo info;
 
	if(storagebackend->getUser(user, info) == false) {
 
		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 
		handleLogoutRequest(user, "");
 
		return;
 
	}
 

	
 
	storagebackend->updateUserSetting((long)info.id, OAUTH_KEY, OAuthAccessTokenKey);	
 
	storagebackend->updateUserSetting((long)info.id, OAUTH_SECRET, OAuthAccessTokenSecret);	
 

	
 
	connectionState[user] = CONNECTED;
 
	LOG4CXX_INFO(logger, user << ": Sent PIN " << data << " and obtained Access Token");
 
}*/
backends/twitter/Requests/PINExchangeProcess.h
Show inline comments
 
new file 100644
 
#ifndef PIN_EXCHANGE
 
#define PIN_EXCHANGE
 

	
 
#include "../ThreadPool.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "../TwitterPlugin.h"
 
#include "transport/networkplugin.h"
 
#include "transport/logging.h"
 

	
 
#include <string>
 
#include <iostream>
 

	
 
//class TwitterPlugin;
 
using namespace Transport;
 
class PINExchangeProcess : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string data;
 
	std::string user;
 
	TwitterPlugin *np;
 
	bool success;
 
	
 
	public:
 
	PINExchangeProcess(TwitterPlugin *_np, twitCurl *obj, const std::string &_user, const std::string &_data) {
 
		twitObj = obj->clone();
 
		data = _data;
 
		user = _user;
 
		np = _np;
 
	}
 

	
 
	~PINExchangeProcess() {
 
		delete twitObj;
 
	}	
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/ProfileImageRequest.cpp
Show inline comments
 
new file 100644
 
#include "ProfileImageRequest.h"
 
#include "../HTTPRequest.h"
 
DEFINE_LOGGER(logger, "ProfileImageRequest")
 
void ProfileImageRequest::run() 
 
{	
 
	HTTPRequest req;
 
	req.init();
 
	req.setProxy(ip, port, puser, ppasswd);
 
	success = req.GET(url, callbackdata);
 
	if(!success) error.assign(req.getCurlError());
 
}
 

	
 
void ProfileImageRequest::finalize()
 
{
 
	if(!success) {
 
		LOG4CXX_ERROR(logger,  user << " - " << error)
 
		img = "";
 
		callBack(user, buddy, img, reqID, error);
 
	} else {
 
		LOG4CXX_INFO(logger, user << " - " << callbackdata);
 
		img = callbackdata;
 
		callBack(user, buddy, img, reqID, error);	
 
	} 
 
}
backends/twitter/Requests/ProfileImageRequest.h
Show inline comments
 
new file 100644
 
#ifndef PROFILEIMAGE_H
 
#define PROFILEIMAGE_H
 

	
 
#include "../ThreadPool.h"
 
#include "../TwitterResponseParser.h"
 
#include "transport/logging.h"
 
#include "transport/config.h"
 
#include <string>
 
#include <boost/signals.hpp>
 
#include <boost/function.hpp>
 
#include <boost/bind.hpp>
 
#include <iostream>
 
#include <sstream>
 

	
 
using namespace Transport;
 
using namespace boost::program_options;
 

	
 
class ProfileImageRequest : public Thread
 
{
 
	std::string user;
 
	std::string buddy;
 
	std::string url;
 
	std::string img;
 
	unsigned int reqID;
 
	boost::function< void (std::string&, std::string&, std::string&, int, std::string&) > callBack;
 

	
 
	std::string ip, port, puser, ppasswd;
 

	
 
	bool success;
 

	
 
	std::string error;
 
	std::string callbackdata;
 

	
 
	public:
 
	ProfileImageRequest(Config *config, const std::string &_user, const std::string &_buddy, const std::string &_url, unsigned int _reqID,
 
			     boost::function< void (std::string&, std::string&, std::string&, int, std::string&) >  cb) {
 

	
 
		if(CONFIG_HAS_KEY(config,"proxy.server")) {
 
			ip = CONFIG_STRING(config,"proxy.server");
 

	
 
			std::ostringstream out; 
 
			out << CONFIG_INT(config,"proxy.port");
 
			port = out.str();
 

	
 
			puser = CONFIG_STRING(config,"proxy.user");
 
			ppasswd = CONFIG_STRING(config,"proxy.password");
 
		}
 

	
 
		user = _user;
 
		buddy = _buddy;
 
		url = _url;
 
		reqID = _reqID;
 
		callBack = cb;
 
	}
 

	
 
	~ProfileImageRequest() {
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 
#endif
backends/twitter/Requests/RetweetRequest.cpp
Show inline comments
 
new file 100644
 
#include "RetweetRequest.h"
 
DEFINE_LOGGER(logger, "RetweetRequest")
 
void RetweetRequest::run()
 
{
 
	LOG4CXX_INFO(logger, user << " Retweeting " << data)
 
	success = twitObj->retweetById( data );
 
}
 

	
 
void RetweetRequest::finalize()
 
{
 
	replyMsg = "";
 
	if(!success) {
 
		twitObj->getLastCurlError( replyMsg );
 
		LOG4CXX_ERROR(logger, user << " Curl error: " << replyMsg)
 
		callBack(user, replyMsg);
 
	} else {
 
		twitObj->getLastWebResponse( replyMsg );
 
		std::string error = getErrorMessage( replyMsg );
 
		if(error.length()) LOG4CXX_ERROR(logger, user << " - " << error)
 
		else LOG4CXX_INFO(logger, user << " " << replyMsg);
 
		callBack(user, error);
 
	}
 
}
backends/twitter/Requests/RetweetRequest.h
Show inline comments
 
new file 100644
 
#ifndef RETWEET_H
 
#define RETWEET_H
 

	
 
#include "../ThreadPool.h"
 
#include "../TwitterResponseParser.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "transport/networkplugin.h"
 
#include "transport/logging.h"
 
#include <boost/function.hpp>
 
#include <string>
 
#include <iostream>
 

	
 
using namespace Transport;
 
class RetweetRequest : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string data;
 
	std::string user;
 
	std::string replyMsg;
 
	bool success;
 
	boost::function < void (std::string&, std::string &) > callBack;
 

	
 
	public:
 
	RetweetRequest(twitCurl *obj, const std::string &_user, const std::string &_data,
 
			       boost::function < void (std::string &, std::string &) > _cb) {
 
		twitObj = obj->clone();
 
		data = _data;
 
		user = _user;
 
		callBack = _cb;
 
	}
 

	
 
	~RetweetRequest() {
 
		delete twitObj;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/StatusUpdateRequest.cpp
Show inline comments
 
new file 100644
 
#include "StatusUpdateRequest.h"
 
#include "../TwitterResponseParser.h"
 

	
 
DEFINE_LOGGER(logger, "StatusUpdateRequest")
 
void StatusUpdateRequest::run() 
 
{
 
	replyMsg = "";
 
	success = twitObj->statusUpdate(data);
 
	if(success) {
 
		twitObj->getLastWebResponse( replyMsg );
 
		LOG4CXX_INFO(logger, user << "StatusUpdateRequest response " << replyMsg );
 
	}
 
}
 

	
 
void StatusUpdateRequest::finalize()
 
{
 
	if(!success) {
 
		twitObj->getLastCurlError( replyMsg );
 
		LOG4CXX_ERROR(logger, user << " - Curl error: " << replyMsg );
 
		callBack(user, replyMsg);
 
	} else {
 
		std::string error = getErrorMessage(replyMsg);
 
		if(error.length()) LOG4CXX_ERROR(logger, user << " - " << error)
 
		else LOG4CXX_INFO(logger, "Updated status for " << user << ": " << data);
 
		callBack(user, error);
 
	}
 
}
backends/twitter/Requests/StatusUpdateRequest.h
Show inline comments
 
new file 100644
 
#ifndef STATUS_UPDATE
 
#define STATUS_UPDATE
 

	
 
#include "../ThreadPool.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "transport/networkplugin.h"
 
#include "transport/logging.h"
 
#include <boost/function.hpp>
 
#include <string>
 
#include <iostream>
 

	
 
using namespace Transport;
 
class StatusUpdateRequest : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string data;
 
	std::string user;
 
	std::string replyMsg;
 
	boost::function<void (std::string& user, std::string& errMsg)> callBack;
 
	bool success;
 

	
 
	public:
 
	StatusUpdateRequest(twitCurl *obj, const std::string &_user, const std::string &_data,
 
						boost::function<void (std::string& user, std::string& errMsg)> cb) {
 
		twitObj = obj->clone();
 
		data = _data;
 
		user = _user;
 
		callBack = cb;
 
	}
 

	
 
	~StatusUpdateRequest() {
 
		delete twitObj;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 

	
 
#endif
backends/twitter/Requests/TimelineRequest.cpp
Show inline comments
 
new file 100644
 
#include "TimelineRequest.h"
 
DEFINE_LOGGER(logger, "TimelineRequest")
 
void TimelineRequest::run()
 
{	
 
	LOG4CXX_INFO(logger, "Sending timeline request for user " << userRequested)
 
	
 
	if(userRequested != "") success = twitObj->timelineUserGet(false, false, 20, userRequested, false);
 
	else success = twitObj->timelineHomeGet(since_id);
 
	
 
	if(!success) return;
 
	
 
	replyMsg = ""; 
 
	twitObj->getLastWebResponse( replyMsg );
 
	//LOG4CXX_INFO(logger, user << " - " << replyMsg.length() << " " << replyMsg << "\n" );
 
	tweets = getTimeline(replyMsg);
 
}
 

	
 
void TimelineRequest::finalize()
 
{
 
	if(!success) {
 
		twitObj->getLastCurlError( replyMsg );
 
		LOG4CXX_ERROR(logger,  user << " - Curl error: " << replyMsg)
 
		callBack(user, userRequested, tweets, replyMsg);
 
	} else {
 
		std::string error = getErrorMessage(replyMsg);
 
		if(error.length()) LOG4CXX_ERROR(logger,  user << " - " << error)
 
		callBack(user, userRequested, tweets, error);
 
	} 
 
}
backends/twitter/Requests/TimelineRequest.h
Show inline comments
 
new file 100644
 
#ifndef TIMELINE_H
 
#define TIMELINE_H
 

	
 
#include "../ThreadPool.h"
 
#include "../libtwitcurl/twitcurl.h"
 
#include "../TwitterResponseParser.h"
 
#include "transport/logging.h"
 
#include <string>
 
#include <iostream>
 
#include <boost/function.hpp>
 

	
 
using namespace Transport;
 

	
 
class TimelineRequest : public Thread
 
{
 
	twitCurl *twitObj;
 
	std::string user;
 
	std::string userRequested;
 
	std::string replyMsg;
 
	std::string since_id;
 
	bool success;
 
	boost::function< void (std::string&, std::string&, std::vector<Status> &, std::string&) > callBack;
 
	std::vector<Status> tweets;
 

	
 
	public:
 
	TimelineRequest(twitCurl *obj, const std::string &_user, const std::string &_user2, const std::string &_since_id,
 
					boost::function< void (std::string&, std::string&, std::vector<Status> &, std::string&) > cb) {
 
		twitObj = obj->clone();
 
		user = _user;
 
		userRequested = _user2;
 
		since_id = _since_id;
 
		callBack = cb;
 
	}
 

	
 
	~TimelineRequest() {
 
		//std::cerr << "*****Timeline request: DESTROYING twitObj****" << std::endl;
 
		delete twitObj;
 
	}
 

	
 
	void run();
 
	void finalize();
 
};
 
#endif
backends/twitter/ThreadPool.cpp
Show inline comments
 
new file 100644
 
#include "ThreadPool.h"
 
DEFINE_LOGGER(logger, "ThreadPool")
 
boost::signals2::signal< void (Thread*, int) > onWorkCompleted;
 

	
 
static void Worker(Thread *t, int wid, Swift::EventLoop *loop)
 
{
 
	LOG4CXX_INFO(logger, "Starting thread " << wid)
 
	t->run();
 
	loop->postEvent(boost::bind(boost::ref(onWorkCompleted), t, wid), boost::shared_ptr<Swift::EventOwner>());
 
}
 

	
 

	
 
ThreadPool::ThreadPool(Swift::EventLoop *loop, int maxthreads) : MAX_THREADS(maxthreads)
 
{
 
	this->loop = loop;
 
	activeThreads = 0;
 
	worker = new boost::thread*[MAX_THREADS];
 
	for(int i=0 ; i<MAX_THREADS ; i++) {
 
		worker[i] = NULL;
 
		freeThreads.push(i);
 
	}
 
	onWorkCompleted.connect(boost::bind(&ThreadPool::cleandUp, this, _1, _2));
 
	onWorkerAvailable.connect(boost::bind(&ThreadPool::scheduleFromQueue, this));
 
}
 

	
 
ThreadPool::~ThreadPool()
 
{
 
	for(int i=0; i<MAX_THREADS ; i++) {
 
		if(worker[i]) {
 
			delete worker[i];
 
		}
 
	}
 
	delete worker;
 

	
 
	while(!requestQueue.empty()) {
 
		Thread *t = requestQueue.front(); requestQueue.pop();
 
		delete t;
 
	}
 
}
 

	
 
int ThreadPool::getActiveThreadCount()
 
{	
 
	int res;
 
	count_lock.lock(); 
 
	res = activeThreads;
 
	count_lock.unlock();
 
	return res;
 
}
 

	
 
void ThreadPool::updateActiveThreadCount(int k)
 
{
 
	count_lock.lock();
 
	activeThreads += k;
 
	count_lock.unlock();
 
}
 

	
 
int ThreadPool::getFreeThread()
 
{
 
	int res = -1;
 
	pool_lock.lock();
 
	if(!freeThreads.empty()){
 
		res = freeThreads.front();
 
		freeThreads.pop();
 
		updateActiveThreadCount(-1);
 
	}
 
	pool_lock.unlock();
 
	return res;
 
}
 

	
 
void ThreadPool::releaseThread(int i)
 
{
 
	if(i < 0 || i > MAX_THREADS) return;
 
	pool_lock.lock();
 

	
 
	delete worker[i];
 
	worker[i] = NULL;
 
	freeThreads.push(i);
 
	
 
	updateActiveThreadCount(1);
 
	
 
	pool_lock.unlock();
 
}
 

	
 
void ThreadPool::cleandUp(Thread *t, int wid)
 
{
 
	LOG4CXX_INFO(logger, "Cleaning up thread #" << t->getThreadID())
 
	t->finalize();
 
	delete t;
 
	releaseThread(wid);
 
	onWorkerAvailable();	
 
}
 

	
 
void ThreadPool::scheduleFromQueue()
 
{
 
	criticalregion.lock();	
 
	while(!requestQueue.empty()) {
 
		int  w = getFreeThread();
 
		if(w == -1) break;
 

	
 
		LOG4CXX_INFO(logger, "Worker Available. Creating thread #" << w)
 
		Thread *t = requestQueue.front(); requestQueue.pop();
 
		t->setThreadID(w);
 
		worker[w] = new boost::thread(Worker, t, w, loop);
 
		updateActiveThreadCount(-1);
 
	}
 
	criticalregion.unlock();
 
}
 

	
 

	
 
void ThreadPool::runAsThread(Thread *t)
 
{
 
	int w;
 
	if((w = getFreeThread()) != -1) {
 
		LOG4CXX_INFO(logger, "Creating thread #" << w)
 
		t->setThreadID(w);
 
		worker[w] = new boost::thread(Worker, t, w, loop);
 
		updateActiveThreadCount(-1);
 
	}
 
	else {
 
		LOG4CXX_INFO(logger, "No workers available! adding to queue.")
 
		requestQueue.push(t);
 
	}
 
}
backends/twitter/ThreadPool.h
Show inline comments
 
new file 100644
 
#ifndef THREAD_POOL
 
#define THREAD_POOL
 

	
 
#include <boost/thread.hpp>
 
#include <boost/thread/mutex.hpp>
 
#include <boost/signals2/signal.hpp>
 
#include <queue>
 
#include <iostream>
 
#include "transport/logging.h"
 
#include "Swiften/Swiften.h"
 

	
 

	
 
/*
 
 * Thread serves as a base class for any code that has to be excuted as a thread
 
 * by the ThreadPool class. The run method defines the code that has to be run
 
 * as a theard. For example, code in run could be sendinga request to a server
 
 * waiting for the response and storing the response. When the thread finishes
 
 * execution, the ThreadPool invokes finalize where one could have the code necessary
 
 * to collect all the responses and release any resources. 
 
 *
 
 * NOTE: The object of the Thread class must be valid (in scope) throughout the 
 
 * execution of the thread.
 
 */
 

	
 
class Thread
 
{
 
	int threadID;
 

	
 
	public:
 
	
 
	Thread() {}
 
	virtual ~Thread() {}
 
	virtual void run() = 0;
 
	virtual void finalize() {}
 
	int getThreadID() {return threadID;}
 
	void setThreadID(int tid) {threadID = tid;}
 
};
 

	
 
/*
 
 * ThreadPool provides the interface to manage a pool of threads. It schedules jobs
 
 * on free threads and when the thread completes it automatically deletes the object
 
 * corresponding to a Thread. If free threads are not available, the requests are 
 
 * added to a queue and scheduled later when threads become available.
 
 */
 

	
 
class ThreadPool
 
{
 
	const int MAX_THREADS;
 
	int activeThreads;
 
	std::queue<int> freeThreads;
 
	
 
	std::queue<Thread*> requestQueue;
 
	boost::thread **worker;
 

	
 
	boost::mutex count_lock;
 
	boost::mutex pool_lock;
 
	boost::mutex criticalregion;
 
	Swift::EventLoop *loop;
 

	
 
	boost::signals2::signal  < void () > onWorkerAvailable;
 

	
 
	public:
 
	ThreadPool(Swift::EventLoop *loop, int maxthreads);
 
	~ThreadPool();
 
	void runAsThread(Thread *t);
 
	int getActiveThreadCount(); 
 
	void updateActiveThreadCount(int k);
 
	void cleandUp(Thread *, int);
 
	void scheduleFromQueue();
 
	int getFreeThread();
 
	void releaseThread(int i);
 
};
 

	
 
#endif
backends/twitter/TwitterPlugin.cpp
Show inline comments
 
new file 100644
 
#include "TwitterPlugin.h"
 
#include "Requests/StatusUpdateRequest.h"
 
#include "Requests/DirectMessageRequest.h"
 
#include "Requests/TimelineRequest.h"
 
#include "Requests/FetchFriends.h"
 
#include "Requests/HelpMessageRequest.h"
 
#include "Requests/PINExchangeProcess.h"
 
#include "Requests/OAuthFlow.h"
 
#include "Requests/CreateFriendRequest.h"
 
#include "Requests/DestroyFriendRequest.h"
 
#include "Requests/RetweetRequest.h"
 
#include "Requests/ProfileImageRequest.h"
 
#include "Swiften/StringCodecs/Hexify.h"
 

	
 
DEFINE_LOGGER(logger, "Twitter Backend");
 

	
 
TwitterPlugin *np = NULL;
 
Swift::SimpleEventLoop *loop_; // Event Loop
 

	
 
const std::string OLD_APP_KEY = "PCWAdQpyyR12ezp2fVwEhw";
 
const std::string OLD_APP_SECRET = "EveLmCXJIg2R7BTCpm6OWV8YyX49nI0pxnYXh7JMvDg";
 

	
 
#define abs(x) ((x)<0?-(x):(x))
 
#define SHA(x) (Swift::Hexify::hexify(Swift::SHA1::getHash(Swift::createByteArray((x)))))
 

	
 
//Compares two +ve intergers 'a' and 'b' represented as strings 
 
static int cmp(std::string a, std::string b)
 
{
 
	int diff = abs((int)a.size() - (int)b.size());
 
	if(a.size() < b.size()) a = std::string(diff,'0') + a;
 
	else b = std::string(diff,'0') + b;
 
	
 
	if(a == b) return 0;
 
	if(a < b) return -1;
 
	return 1;
 
}
 

	
 

	
 
TwitterPlugin::TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port) : NetworkPlugin() 
 
{
 
	this->config = config;
 
	this->storagebackend = storagebackend;
 

	
 
	if(CONFIG_HAS_KEY(config, "twitter.consumer_key") == false ||
 
	   CONFIG_HAS_KEY(config, "twitter.consumer_secret") == false) {
 
		LOG4CXX_ERROR(logger, "Couldn't find consumer key and/or secret. Please check config file.");
 
		exit(0);
 
	}
 
	
 
	adminLegacyName = "twitter-account"; 
 
	adminChatRoom = "twitter-chatroom"; 
 
	adminNickName = "twitter"; 
 
	adminAlias = "twitter";
 

	
 
	consumerKey = CONFIG_STRING(config, "twitter.consumer_key");
 
	consumerSecret = CONFIG_STRING(config, "twitter.consumer_secret");
 

	
 
	OAUTH_KEY = "twitter_oauth_token";
 
	OAUTH_SECRET = "twitter_oauth_secret";
 
	MODE = "mode";
 

	
 
	m_factories = new Swift::BoostNetworkFactories(loop);
 
	m_conn = m_factories->getConnectionFactory()->createConnection();
 
	m_conn->onDataRead.connect(boost::bind(&TwitterPlugin::_handleDataRead, this, _1));
 
	m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));
 

	
 
	tp = new ThreadPool(loop_, 10);
 
		
 
	tweet_timer = m_factories->getTimerFactory()->createTimer(60000);
 
	message_timer = m_factories->getTimerFactory()->createTimer(60000);
 

	
 
	tweet_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForTweets, this));
 
	message_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForDirectMessages, this));
 

	
 
	tweet_timer->start();
 
	message_timer->start();
 
	
 
	LOG4CXX_INFO(logger, "Starting the plugin.");
 
}
 

	
 
TwitterPlugin::~TwitterPlugin() 
 
{
 
	delete storagebackend;
 
	std::set<std::string>::iterator it;
 
	for(it = onlineUsers.begin() ; it != onlineUsers.end() ; it++) delete userdb[*it].sessions;
 
	delete tp;
 
}
 

	
 
// Send data to NetworkPlugin server
 
void TwitterPlugin::sendData(const std::string &string) 
 
{
 
	m_conn->write(Swift::createSafeByteArray(string));
 
}
 

	
 
// Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)
 
void TwitterPlugin::_handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) 
 
{
 
	std::string d(data->begin(), data->end());
 
	handleDataRead(d);
 
}
 

	
 
// User trying to login into his twitter account
 
void TwitterPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) 
 
{
 
	if(userdb.count(user) && (userdb[user].connectionState == NEW || 
 
										userdb[user].connectionState == CONNECTED || 
 
										userdb[user].connectionState == WAITING_FOR_PIN)) {
 
		LOG4CXX_INFO(logger, std::string("A session corresponding to ") + user + std::string(" is already active"))
 
		return;
 
	}
 
	
 
	LOG4CXX_INFO(logger, std::string("Received login request for ") + user)	
 
	initUserSession(user, legacyName, password);
 
	handleConnected(user);
 
	
 
	LOG4CXX_INFO(logger, "SPECTRUM 1 USER? - " << (userdb[user].spectrum1User? "true" : "false")) 
 
	
 
	LOG4CXX_INFO(logger, user << ": Adding Buddy " << adminLegacyName << " " << adminAlias)
 
	handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
 
	userdb[user].nickName = "";
 
	
 
	LOG4CXX_INFO(logger, "Querying database for usersettings of " << user)
 
	std::string key, secret;
 
	getUserOAuthKeyAndSecret(user, key, secret);
 

	
 
	if(key == "" || secret == "") {			
 
		LOG4CXX_INFO(logger, "Intiating OAuth Flow for user " << user)
 
		setTwitterMode(user, 0);
 
		tp->runAsThread(new OAuthFlow(np, userdb[user].sessions, user, userdb[user].sessions->getTwitterUsername()));
 
	} else {
 
		LOG4CXX_INFO(logger, user << " is already registerd. Using the stored oauth key and secret")
 
		LOG4CXX_INFO(logger, key << " " << secret)	
 
		pinExchangeComplete(user, key, secret);
 
	}
 
}
 

	
 
// User logging out
 
void TwitterPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) 
 
{
 
	if(onlineUsers.count(user)) {
 
		delete userdb[user].sessions;
 
		userdb[user].sessions = NULL;
 
		userdb[user].connectionState = DISCONNECTED;
 
		onlineUsers.erase(user);
 
	}
 
}
 

	
 
// User joining a Chatroom
 
void TwitterPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password)
 
{
 
	if(room == adminChatRoom) {	
 
		LOG4CXX_INFO(logger, "Received Join Twitter room request for " << user)
 

	
 
		setTwitterMode(user, 2);
 
		handleParticipantChanged(user, adminNickName, room, 0, pbnetwork::STATUS_ONLINE);
 
		userdb[user].nickName = nickname;
 
		handleMessage(user, adminChatRoom, "Connected to Twitter room! Populating your followers list", adminNickName);
 
		tp->runAsThread(new FetchFriends(userdb[user].sessions, user,
 
										 boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
 
	} else {
 
		setTwitterMode(user, 0);
 
		LOG4CXX_ERROR(logger, "Couldn't connect to chatroom - " << room <<"! Try twitter-chatroom as the chatroom to access Twitter account")
 
		handleMessage(user, adminLegacyName, "Couldn't connect to chatroom! Try twitter-chatroom as the chatroom to access Twitter account");
 
	}	
 
}
 

	
 
// User leaving a Chatroom
 
void TwitterPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room)
 
{
 
	if(room == adminChatRoom && onlineUsers.count(user)) {
 
		LOG4CXX_INFO(logger, "Leaving chatroom! Switching back to default mode 0")
 
		setTwitterMode(user, 0);
 
		handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);
 
	}
 
}
 

	
 
// Messages to be sent to Twitter 
 
void TwitterPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml) 
 
{
 

	
 
	LOG4CXX_INFO(logger, "Received " << user << " --> " << legacyName << " - " << message)
 
	
 
	if(legacyName == adminLegacyName || legacyName == adminChatRoom)  {
 
		std::string cmd = "", data = "";
 
	 
 
		/** Parsing the message - Assuming message format to be <cmd>[ ]*<data>**/	
 
		int i;
 
		for(i=0 ; i<message.size() && message[i] != ' '; i++) cmd += message[i];
 
		while(i<message.size() && message[i] == ' ') i++;
 
		data = message.substr(i);
 
		/***********************************************************************/
 
		
 
		if(cmd == "#pin") 
 
			tp->runAsThread(new PINExchangeProcess(np, userdb[user].sessions, user, data));
 
		else if(cmd == "#help") 
 
			tp->runAsThread(new HelpMessageRequest(user, boost::bind(&TwitterPlugin::helpMessageResponse, this, _1, _2)));
 
		else if(cmd[0] == '@') {
 
			std::string username = cmd.substr(1); 
 
			tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, username, data,
 
												     boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
 
		}
 
		else if(cmd == "#status") 
 
			tp->runAsThread(new StatusUpdateRequest(userdb[user].sessions, user, data,
 
														boost::bind(&TwitterPlugin::statusUpdateResponse, this, _1, _2)));
 
		else if(cmd == "#timeline") 
 
			tp->runAsThread(new TimelineRequest(userdb[user].sessions, user, data, "",
 
														boost::bind(&TwitterPlugin::displayTweets, this, _1, _2, _3, _4)));
 
		else if(cmd == "#friends") 
 
			tp->runAsThread(new FetchFriends(userdb[user].sessions, user,
 
													   boost::bind(&TwitterPlugin::displayFriendlist, this, _1, _2, _3, _4)));
 
		else if(cmd == "#follow") 
 
			tp->runAsThread(new CreateFriendRequest(userdb[user].sessions, user, data.substr(0,data.find('@')),
 
													   boost::bind(&TwitterPlugin::createFriendResponse, this, _1, _2, _3, _4)));
 
		else if(cmd == "#unfollow") 
 
			tp->runAsThread(new DestroyFriendRequest(userdb[user].sessions, user, data.substr(0,data.find('@')),
 
													   boost::bind(&TwitterPlugin::deleteFriendResponse, this, _1, _2, _3)));
 
		else if(cmd == "#retweet") 
 
			tp->runAsThread(new RetweetRequest(userdb[user].sessions, user, data,
 
													   boost::bind(&TwitterPlugin::RetweetResponse, this, _1, _2)));
 
		else if(cmd == "#mode") {
 
			int m = 0;
 
			m = atoi(data.c_str());
 
			mode prevm = userdb[user].twitterMode;
 

	
 
			if((mode)m == userdb[user].twitterMode) return; //If same as current mode return
 
			if(m < 0 || m > 2) { // Invalid modes
 
				handleMessage(user, adminLegacyName, std::string("Error! Unknown mode ") + data + ". Allowed values 0,1,2." );
 
				return;
 
			}
 

	
 
			setTwitterMode(user, m);
 
			if((userdb[user].twitterMode == SINGLECONTACT || userdb[user].twitterMode == CHATROOM) && prevm == MULTIPLECONTACT) clearRoster(user);
 
			else if(userdb[user].twitterMode == MULTIPLECONTACT) 
 
				tp->runAsThread(new FetchFriends(userdb[user].sessions, user, boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
 

	
 
			handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
								std::string("Changed mode to ") + data, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 

	
 
			LOG4CXX_INFO(logger, user << ": Changed mode to " << data  << " <" << (userdb[user].twitterMode == CHATROOM ? adminNickName : "") << ">" )
 
		}
 

	
 
		else if(userdb[user].twitterMode == CHATROOM) {
 
			std::string buddy = message.substr(0, message.find(":"));
 
			if(userdb[user].buddies.count(buddy) == 0) {
 
				tp->runAsThread(new StatusUpdateRequest(userdb[user].sessions, user, message,
 
														boost::bind(&TwitterPlugin::statusUpdateResponse, this, _1, _2)));
 
			} else {
 
				data = message.substr(message.find(":")+1); //Can parse better??:P
 
				tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, buddy, data,
 
												 		 boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
 
			}
 
		}
 
		else handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
				                 "Unknown command! Type #help for a list of available commands.", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	} 
 

	
 
	else {	
 
		std::string buddy;
 
		if(userdb[user].twitterMode == CHATROOM) buddy = legacyName.substr(legacyName.find("/") + 1);
 
		if(legacyName != "twitter") {
 
			tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, buddy, message,
 
												 boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
 
		}
 
	}
 
}
 

	
 
void TwitterPlugin::handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) 
 
{
 
	if(userdb[user].connectionState != CONNECTED) {
 
		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")
 
		return;
 
	}
 

	
 
	LOG4CXX_INFO(logger, user << " - Adding Twitter contact " << buddyName)
 
	tp->runAsThread(new CreateFriendRequest(userdb[user].sessions, user, buddyName, 
 
											boost::bind(&TwitterPlugin::createFriendResponse, this, _1, _2, _3, _4)));
 
}
 

	
 
void TwitterPlugin::handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) 
 
{
 
	if(userdb[user].connectionState != CONNECTED) {
 
		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")
 
		return;
 
	}
 
	
 
	LOG4CXX_INFO(logger, user << " - Removing Twitter contact " << buddyName)
 
	tp->runAsThread(new DestroyFriendRequest(userdb[user].sessions, user, buddyName, 
 
											 boost::bind(&TwitterPlugin::deleteFriendResponse, this, _1, _2, _3)));
 
}
 

	
 
void TwitterPlugin::handleVCardRequest(const std::string &user, const std::string &legacyName, unsigned int id)
 
{
 
	if(userdb[user].connectionState != CONNECTED) {
 
		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")
 
		return;
 
	}
 
	
 
	LOG4CXX_INFO(logger, user << " - VCardRequest for " << legacyName << ", " << userdb[user].buddiesInfo[legacyName].getProfileImgURL())
 

	
 
	if(getTwitterMode(user) != SINGLECONTACT && userdb[user].buddies.count(legacyName) 
 
		&& userdb[user].buddiesInfo[legacyName].getProfileImgURL().length()) {
 
		if(userdb[user].buddiesImgs.count(legacyName) == 0) {
 
			tp->runAsThread(new ProfileImageRequest(config, user, legacyName, userdb[user].buddiesInfo[legacyName].getProfileImgURL(), id,
 
													boost::bind(&TwitterPlugin::profileImageResponse, this, _1, _2, _3, _4, _5)));
 
		}
 
		handleVCard(user, id, legacyName, legacyName, "", userdb[user].buddiesImgs[legacyName]);
 
	}
 
}
 

	
 
void TwitterPlugin::pollForTweets()
 
{
 
	boost::mutex::scoped_lock lock(userlock);
 
	std::set<std::string>::iterator it = onlineUsers.begin();
 
	while(it != onlineUsers.end()) {
 
		std::string user = *it;
 
		tp->runAsThread(new TimelineRequest(userdb[user].sessions, user, "", userdb[user].mostRecentTweetID,
 
											boost::bind(&TwitterPlugin::displayTweets, this, _1, _2, _3, _4)));
 
		it++;
 
	}
 
	tweet_timer->start();
 
}
 

	
 
void TwitterPlugin::pollForDirectMessages()
 
{
 
	boost::mutex::scoped_lock lock(userlock);
 
	std::set<std::string>::iterator it = onlineUsers.begin();
 
	while(it != onlineUsers.end()) {
 
		std::string user = *it;
 
		tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, "", userdb[user].mostRecentDirectMessageID,
 
											boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));
 
		it++;
 
	}
 
	message_timer->start();
 
}
 

	
 

	
 
bool TwitterPlugin::getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret) 
 
{
 
	boost::mutex::scoped_lock lock(dblock);
 
	
 
	UserInfo info;
 
	if(storagebackend->getUser(user, info) == false) {
 
		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 
		return false;
 
	}
 

	
 
	key="", secret=""; int type;
 
	storagebackend->getUserSetting((long)info.id, OAUTH_KEY, type, key);
 
	storagebackend->getUserSetting((long)info.id, OAUTH_SECRET, type, secret);
 
	return true;
 
}
 

	
 
bool TwitterPlugin::checkSpectrum1User(const std::string user) 
 
{
 
	boost::mutex::scoped_lock lock(dblock);
 
	
 
	UserInfo info;
 
	if(storagebackend->getUser(user, info) == false) {
 
		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 
		return false;
 
	}
 

	
 
	std::string first_synchronization_done = "";
 
	int type;
 
	storagebackend->getUserSetting((long)info.id, "first_synchronization_done", type, first_synchronization_done);
 

	
 
	LOG4CXX_INFO(logger, "first_synchronization_done: " << first_synchronization_done)
 

	
 
	if(first_synchronization_done.length()) return true;
 
	return false;
 
}
 

	
 
int TwitterPlugin::getTwitterMode(const std::string user) 
 
{
 
	boost::mutex::scoped_lock lock(dblock);
 
	
 
	UserInfo info;
 
	if(storagebackend->getUser(user, info) == false) {
 
		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 
		return -1;
 
	}
 

	
 
	int type; int m;
 
	std::string s_m;
 
	storagebackend->getUserSetting((long)info.id, MODE, type, s_m);
 
	if(s_m == "") {
 
		s_m  = "0";
 
		storagebackend->updateUserSetting((long)info.id, MODE, s_m);
 
	}
 
	m = atoi(s_m.c_str());
 
	return m;
 
}
 

	
 
bool TwitterPlugin::setTwitterMode(const std::string user, int m) 
 
{
 
	boost::mutex::scoped_lock lock(dblock);
 
	
 
	UserInfo info;
 
	if(storagebackend->getUser(user, info) == false) {
 
		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 
		return false;
 
	}
 

	
 
	if(m < 0 || m > 2) {
 
		LOG4CXX_ERROR(logger, "Unknown mode " << m <<". Using default mode 0")
 
		m = 0;
 
	}
 

	
 
	userdb[user].twitterMode = (mode)m;
 

	
 
	//int type;
 
	std::string s_m = std::string(1,m+'0');
 
	LOG4CXX_ERROR(logger, "Storing mode " << m <<" for user " << user)
 
	storagebackend->updateUserSetting((long)info.id, MODE, s_m);
 
	return true;
 
}
 

	
 
bool TwitterPlugin::storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret) 
 
{
 

	
 
	boost::mutex::scoped_lock lock(dblock);
 

	
 
	UserInfo info;
 
	if(storagebackend->getUser(user, info) == false) {
 
		LOG4CXX_ERROR(logger, "Didn't find entry for " << user << " in the database!")
 
		return false;
 
	}
 

	
 
	storagebackend->updateUserSetting((long)info.id, OAUTH_KEY, OAuthKey);	
 
	storagebackend->updateUserSetting((long)info.id, OAUTH_SECRET, OAuthSecret);
 
	return true;
 
}
 

	
 
void TwitterPlugin::initUserSession(const std::string user, const std::string legacyName, const std::string password)
 
{
 
	boost::mutex::scoped_lock lock(userlock);
 

	
 
	std::string username = legacyName;
 
	std::string passwd = password;
 
	LOG4CXX_INFO(logger, username + "  " + passwd)
 

	
 
	userdb[user].sessions = new twitCurl();	
 
	if(CONFIG_HAS_KEY(config,"proxy.server")) {			
 
		std::string ip = CONFIG_STRING(config,"proxy.server");
 

	
 
		std::ostringstream out; 
 
		out << CONFIG_INT(config,"proxy.port");
 
		std::string port = out.str();
 

	
 
		std::string puser = CONFIG_STRING(config,"proxy.user");
 
		std::string ppasswd = CONFIG_STRING(config,"proxy.password");
 

	
 
		LOG4CXX_INFO(logger, ip << " " << port << " " << puser << " " << ppasswd)
 
		
 
		if(ip != "localhost" && port != "0") {
 
			userdb[user].sessions->setProxyServerIp(ip);
 
			userdb[user].sessions->setProxyServerPort(port);
 
			userdb[user].sessions->setProxyUserName(puser);
 
			userdb[user].sessions->setProxyPassword(ppasswd);
 
		}
 
	}
 

	
 
	//Check if the user is spectrum1 user
 
	userdb[user].spectrum1User = checkSpectrum1User(user);
 

	
 
	userdb[user].connectionState = NEW;
 
	userdb[user].legacyName = username;	
 
	userdb[user].sessions->setTwitterUsername(username);
 
	userdb[user].sessions->setTwitterPassword(passwd);
 

	
 
	if(!userdb[user].spectrum1User) {
 
		userdb[user].sessions->getOAuth().setConsumerKey(consumerKey);
 
		userdb[user].sessions->getOAuth().setConsumerSecret(consumerSecret);
 
	} else {
 
		userdb[user].sessions->getOAuth().setConsumerKey(OLD_APP_KEY);
 
		userdb[user].sessions->getOAuth().setConsumerSecret(OLD_APP_SECRET);
 
	}
 
}
 

	
 
void TwitterPlugin::OAuthFlowComplete(const std::string user, twitCurl *obj) 
 
{
 
	boost::mutex::scoped_lock lock(userlock);	
 

	
 
	delete userdb[user].sessions;
 
	userdb[user].sessions = obj->clone();	
 
	userdb[user].connectionState = WAITING_FOR_PIN;
 
}	
 

	
 
void TwitterPlugin::pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret) 
 
{
 
	boost::mutex::scoped_lock lock(userlock);	
 
		
 
	userdb[user].sessions->getOAuth().setOAuthTokenKey( OAuthAccessTokenKey );
 
	userdb[user].sessions->getOAuth().setOAuthTokenSecret( OAuthAccessTokenSecret );
 
	userdb[user].connectionState = CONNECTED;
 
	userdb[user].twitterMode = (mode)getTwitterMode(user);
 
	
 
	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 
		tp->runAsThread(new FetchFriends(userdb[user].sessions, user, boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));
 
	}
 

	
 
	onlineUsers.insert(user);
 
	userdb[user].mostRecentTweetID = "";
 
	userdb[user].mostRecentDirectMessageID = "";
 
}	
 

	
 
void TwitterPlugin::updateLastTweetID(const std::string user, const std::string ID)
 
{
 
	boost::mutex::scoped_lock lock(userlock);	
 
	userdb[user].mostRecentTweetID = ID;
 
}
 

	
 
std::string TwitterPlugin::getMostRecentTweetID(const std::string user)
 
{
 
	boost::mutex::scoped_lock lock(userlock);	
 
	std::string ID = "-1";
 
	if(onlineUsers.count(user)) ID = userdb[user].mostRecentTweetID;
 
	return ID;
 
}
 

	
 
void TwitterPlugin::updateLastDMID(const std::string user, const std::string ID)
 
{
 
	boost::mutex::scoped_lock lock(userlock);	
 
	userdb[user].mostRecentDirectMessageID = ID;
 
}
 

	
 
std::string TwitterPlugin::getMostRecentDMID(const std::string user)
 
{
 
	boost::mutex::scoped_lock lock(userlock);	
 
	std::string ID = "";
 
	if(onlineUsers.count(user)) ID = userdb[user].mostRecentDirectMessageID;
 
	return ID;
 
}
 

	
 
/************************************** Twitter response functions **********************************/
 
void TwitterPlugin::statusUpdateResponse(std::string &user, std::string &errMsg)
 
{
 
	if(errMsg.length()) {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	} else {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							"Status Update successful", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	}
 
}
 

	
 
void TwitterPlugin::helpMessageResponse(std::string &user, std::string &msg)
 
{
 
	handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
						msg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
}
 

	
 
void TwitterPlugin::clearRoster(const std::string user)
 
{
 
	if(userdb[user].buddies.size() == 0) return;
 
	std::set<std::string>::iterator it = userdb[user].buddies.begin();
 
	while(it != userdb[user].buddies.end()) {
 
		handleBuddyRemoved(user, *it);
 
		it++;
 
	}
 
	userdb[user].buddies.clear();
 
}
 

	
 
void TwitterPlugin::populateRoster(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, std::string &errMsg) 
 
{
 
	if(errMsg.length() == 0) 
 
	{
 
		for(int i=0 ; i<friends.size() ; i++) {
 
			userdb[user].buddies.insert(friends[i].getScreenName());
 
			userdb[user].buddiesInfo[friends[i].getScreenName()] = friends[i];
 
			userdb[user].buddiesImgs[friends[i].getScreenName()] = friendAvatars[i];
 
			
 
			if(userdb[user].twitterMode == MULTIPLECONTACT) {
 
				std::string lastTweet = friends[i].getLastStatus().getTweet();
 
				//LOG4CXX_INFO(logger, user << " - " << SHA(friendAvatars[i]))
 
				handleBuddyChanged(user, friends[i].getScreenName(), friends[i].getUserName(), std::vector<std::string>(), 
 
								   pbnetwork::STATUS_ONLINE, lastTweet, SHA(friendAvatars[i]));
 
			}
 
			else if(userdb[user].twitterMode == CHATROOM)
 
				handleParticipantChanged(user, friends[i].getScreenName(), adminChatRoom, 0, pbnetwork::STATUS_ONLINE);
 
			
 
			/*handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							   	friends[i].getScreenName() + " - " + friends[i].getLastStatus().getTweet(), 
 
								userdb[user].twitterMode == CHATROOM ? adminNickName : "");*/
 
		}
 
	} else handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							   std::string("Error populating roster - ") + errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");	
 

	
 
	if(userdb[user].twitterMode == CHATROOM) handleParticipantChanged(user, userdb[user].nickName, adminChatRoom, 0, pbnetwork::STATUS_ONLINE);
 
}
 

	
 
void TwitterPlugin::displayFriendlist(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, std::string &errMsg)
 
{
 
	if(errMsg.length() == 0) 
 
	{
 
		std::string userlist = "\n***************USER LIST****************\n";
 
		for(int i=0 ; i < friends.size() ; i++) {
 
			userlist += " - " + friends[i].getUserName() + " (" + friends[i].getScreenName() + ")\n";
 
		}	
 
		userlist += "***************************************\n";
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							userlist, userdb[user].twitterMode == CHATROOM ? adminNickName : "");	
 
	} else handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName, 
 
							   errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");	
 
 
 
}
 

	
 
void TwitterPlugin::displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , std::string &errMsg)
 
{
 
	if(errMsg.length() == 0) {
 
		
 
		std::string timeline = "";
 
		std::map<std::string, int> lastTweet;
 
		std::map<std::string, int>::iterator it;
 

	
 
		for(int i=0 ; i<tweets.size() ; i++) {
 
			if(userdb[user].twitterMode != CHATROOM) {
 
				timeline += " - " + tweets[i].getUserData().getScreenName() + ": " + tweets[i].getTweet() + " (MsgId: " + tweets[i].getID() + ")\n";
 

	
 
				std::string scrname = tweets[i].getUserData().getScreenName();
 
				if(lastTweet.count(scrname) == 0 || cmp(tweets[lastTweet[scrname]].getID(), tweets[i].getID()) <= 0) lastTweet[scrname] = i;
 

	
 
			} else {
 
				handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
									tweets[i].getTweet() + " (MsgId: " + tweets[i].getID() + ")", tweets[i].getUserData().getScreenName());
 
			}
 
		}
 
		
 
		if(userdb[user].twitterMode == MULTIPLECONTACT) {
 
			//Set as status user's last tweet
 
			for(it=lastTweet.begin() ; it!=lastTweet.end() ; it++) {
 
				int t =  it->second;
 
				handleBuddyChanged(user, tweets[t].getUserData().getScreenName(), tweets[t].getUserData().getUserName(), 
 
								   std::vector<std::string>(), pbnetwork::STATUS_ONLINE, tweets[t].getTweet());
 
			}
 
		}
 

	
 
		if((userRequested == "" || userRequested == user) && tweets.size()) {
 
			std::string tweetID = getMostRecentTweetID(user);
 
			if(tweetID != tweets[0].getID()) updateLastTweetID(user, tweets[0].getID());
 
		}
 

	
 
		if(timeline.length()) handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
												  timeline, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	} else handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							   errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");	
 
}
 

	
 
void TwitterPlugin::directMessageResponse(std::string &user, std::string &username, std::vector<DirectMessage> &messages, std::string &errMsg)
 
{
 
	if(errMsg.length()) {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							std::string("Error while sending direct message! - ") + errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");	
 
		return;
 
	}
 

	
 
	if(username != "") {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
						   "Message delivered!", userdb[user].twitterMode == CHATROOM ? adminNickName : "");	
 
		return;
 
	}
 
	
 
	if(!messages.size()) return;
 
	
 
	if(userdb[user].twitterMode == SINGLECONTACT) {
 

	
 
		std::string msglist = "";
 
		std::string msgID = getMostRecentDMID(user);
 
		std::string maxID = msgID;
 
		
 
		for(int i=0 ; i < messages.size() ; i++) {
 
			if(cmp(msgID, messages[i].getID()) == -1) {
 
				msglist += " - " + messages[i].getSenderData().getScreenName() + ": " + messages[i].getMessage() + "\n";
 
				if(cmp(maxID, messages[i].getID()) == -1) maxID = messages[i].getID();
 
			}
 
		}	
 

	
 
		if(msglist.length()) handleMessage(user, adminLegacyName, msglist, "");	
 
		updateLastDMID(user, maxID);
 

	
 
	} else {
 
		
 
		std::string msgID = getMostRecentDMID(user);
 
		std::string maxID = msgID;
 

	
 
		for(int i=0 ; i < messages.size() ; i++) {
 
			if(cmp(msgID, messages[i].getID()) == -1) {
 
				if(userdb[user].twitterMode == MULTIPLECONTACT)
 
					handleMessage(user, messages[i].getSenderData().getScreenName(), messages[i].getMessage(), "");
 
				else
 
					handleMessage(user, adminChatRoom, messages[i].getMessage() + " - <Direct Message>", messages[i].getSenderData().getScreenName());
 
				if(cmp(maxID, messages[i].getID()) == -1) maxID = messages[i].getID();
 
			}
 
		}	
 
		
 
		if(maxID == getMostRecentDMID(user)) LOG4CXX_INFO(logger, "No new direct messages for " << user)
 
		updateLastDMID(user, maxID);
 
	}
 
}
 

	
 
void TwitterPlugin::createFriendResponse(std::string &user, User &frnd, std::string &img, std::string &errMsg)
 
{
 
	if(errMsg.length()) {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
		return;
 
	}
 

	
 
	handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
						std::string("You are now following ") + frnd.getScreenName(), userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	
 
	userdb[user].buddies.insert(frnd.getScreenName());
 
	userdb[user].buddiesInfo[frnd.getScreenName()] = frnd;
 
	userdb[user].buddiesImgs[frnd.getScreenName()] = img;
 
	
 
	LOG4CXX_INFO(logger, user << " - " << frnd.getScreenName() << ", " << frnd.getProfileImgURL())
 
	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 
		handleBuddyChanged(user, frnd.getScreenName(), frnd.getUserName(), std::vector<std::string>(), pbnetwork::STATUS_ONLINE, "", SHA(img));
 
	} else if(userdb[user].twitterMode == CHATROOM) {
 
		handleParticipantChanged(user, frnd.getScreenName(), adminChatRoom, 0, pbnetwork::STATUS_ONLINE);
 
	}
 
}
 

	
 
void TwitterPlugin::deleteFriendResponse(std::string &user, User &frnd, std::string &errMsg)
 
{
 
	if(errMsg.length()) {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName, 
 
							errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
		return;
 
	} 
 
	
 
	LOG4CXX_INFO(logger, user << " - " << frnd.getScreenName() << ", " << frnd.getProfileImgURL())
 
	userdb[user].buddies.erase(frnd.getScreenName());
 
	
 
	handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
						std::string("You are not following ") + frnd.getScreenName() + " anymore", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	
 
	if (userdb[user].twitterMode == CHATROOM) {
 
		handleParticipantChanged(user, frnd.getScreenName(), adminLegacyName, 0, pbnetwork::STATUS_NONE);
 
	}
 
	
 
	if(userdb[user].twitterMode == MULTIPLECONTACT) {
 
		handleBuddyRemoved(user, frnd.getScreenName());
 
	} 
 
}
 

	
 

	
 
void TwitterPlugin::RetweetResponse(std::string &user, std::string &errMsg)
 
{
 
	if(errMsg.length()) {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	} else {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							"Retweet successful", userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	}
 
}
 

	
 
void TwitterPlugin::profileImageResponse(std::string &user, std::string &buddy, std::string &img, unsigned int reqID, std::string &errMsg)
 
{
 
	if(errMsg.length()) {
 
		handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,
 
							errMsg, userdb[user].twitterMode == CHATROOM ? adminNickName : "");
 
	} else {
 
		LOG4CXX_INFO(logger, user << " - Sending VCard for " << buddy)
 
		handleVCard(user, reqID, buddy, buddy, "", img);
 
	}
 
}
backends/twitter/TwitterPlugin.h
Show inline comments
 
new file 100644
 
#ifndef TWITTER_PLUGIN
 
#define TWITTER_PLUGIN
 

	
 
#include "transport/config.h"
 
#include "transport/networkplugin.h"
 
#include "transport/logging.h"
 
#include "transport/sqlite3backend.h"
 
#include "transport/mysqlbackend.h"
 
#include "transport/pqxxbackend.h"
 
#include "transport/storagebackend.h"
 

	
 
#include "Swiften/Swiften.h"
 
#include "unistd.h"
 
#include "signal.h"
 
#include "sys/wait.h"
 
#include "sys/signal.h"
 

	
 
#include <boost/algorithm/string.hpp>
 
#include <boost/signal.hpp>
 
#include <boost/thread.hpp>
 
#include <boost/thread/mutex.hpp>
 

	
 
#include "twitcurl.h"
 
#include "TwitterResponseParser.h"
 

	
 
#include <iostream>
 
#include <sstream>
 
#include <map>
 
#include <vector>
 
#include <queue>
 
#include <set>
 
#include <cstdio>
 

	
 
#include "ThreadPool.h"
 
#include "Swiften/StringCodecs/SHA1.h"
 

	
 
using namespace boost::filesystem;
 
using namespace boost::program_options;
 
using namespace Transport;
 

	
 
#define STR(x) (std::string("(") + x.from + ", " + x.to + ", " + x.message + ")")
 

	
 
class TwitterPlugin;
 
extern TwitterPlugin *np;
 
extern Swift::SimpleEventLoop *loop_; // Event Loop
 

	
 
class TwitterPlugin : public NetworkPlugin {
 
	public:
 
		Swift::BoostNetworkFactories *m_factories;
 
		Swift::BoostIOServiceThread m_boostIOServiceThread;
 
		boost::shared_ptr<Swift::Connection> m_conn;
 
		Swift::Timer::ref tweet_timer;
 
		Swift::Timer::ref message_timer;
 
		StorageBackend *storagebackend;
 

	
 
		TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port);
 
		~TwitterPlugin();
 

	
 
		// Send data to NetworkPlugin server
 
		void sendData(const std::string &string);
 

	
 
		// Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)
 
		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data);
 
	
 
		// User trying to login into his twitter account
 
		void handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password);
 
		
 
		// User logging out
 
		void handleLogoutRequest(const std::string &user, const std::string &legacyName);
 
		
 
		void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/);
 

	
 
		void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/);
 

	
 
		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "");
 

	
 
		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups);
 

	
 
		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups);
 
		
 
		void handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/);
 
		
 
		void pollForTweets();
 

	
 
		void pollForDirectMessages();
 
		
 
		bool getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret);
 
		
 
		bool checkSpectrum1User(const std::string user);
 
		
 
		bool storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret);
 
		
 
		void initUserSession(const std::string user, const std::string legacyName, const std::string password);
 
		
 
		void OAuthFlowComplete(const std::string user, twitCurl *obj);
 
		
 
		void pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret);
 
		
 
		void updateLastTweetID(const std::string user, const std::string ID);
 

	
 
		std::string getMostRecentTweetID(const std::string user);
 

	
 
		void updateLastDMID(const std::string user, const std::string ID);
 
		
 
		std::string getMostRecentDMID(const std::string user);
 

	
 
		void clearRoster(const std::string user);
 

	
 
		int getTwitterMode(const std::string user);
 

	
 
		bool setTwitterMode(const std::string user, int m);
 

	
 
		/****************** Twitter response handlers **************************************/
 
		void statusUpdateResponse(std::string &user, std::string &errMsg);
 
		
 
		void helpMessageResponse(std::string &user, std::string &msg);
 
		
 
		void populateRoster(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, std::string &errMsg);
 
		
 
		void displayFriendlist(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, std::string &errMsg);
 
		
 
		void displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , std::string &errMsg);
 
		
 
		void directMessageResponse(std::string &user, std::string &username, std::vector<DirectMessage> &messages, std::string &errMsg);
 
		
 
		void createFriendResponse(std::string &user, User &frnd, std::string &img, std::string &errMsg);
 
		
 
		void deleteFriendResponse(std::string &user, User &frnd, std::string &errMsg);
 
		
 
		void RetweetResponse(std::string &user, std::string &errMsg);
 
		
 
		void profileImageResponse(std::string &user, std::string &buddy, std::string &img, unsigned int reqID, std::string &errMsg);
 
		/***********************************************************************************/
 

	
 
	private:
 
		enum status {NEW, WAITING_FOR_PIN, CONNECTED, DISCONNECTED};
 
		enum mode {SINGLECONTACT, MULTIPLECONTACT, CHATROOM};
 

	
 
		Config *config;
 
		std::string adminLegacyName;
 
		std::string adminChatRoom;
 
		std::string adminNickName;
 
		std::string adminAlias;
 

	
 
		std::string consumerKey;
 
		std::string consumerSecret;
 
		std::string OAUTH_KEY;
 
		std::string OAUTH_SECRET;
 
		std::string MODE;
 

	
 
		boost::mutex dblock, userlock;
 

	
 
		ThreadPool *tp;
 
		std::set<std::string> onlineUsers;
 
		struct UserData
 
		{
 
			std::string legacyName;
 
			bool spectrum1User; //Legacy support
 
			User userTwitterObj;
 
			std::string userImg;
 
			twitCurl* sessions;		
 
			status connectionState;
 
			std::string mostRecentTweetID;
 
			std::string mostRecentDirectMessageID;
 
			std::string nickName;
 
			std::set<std::string> buddies;
 
			std::map<std::string, User> buddiesInfo;
 
			std::map<std::string, std::string> buddiesImgs;
 
			mode twitterMode;
 

	
 
			UserData() { sessions = NULL; }
 
		};
 
		std::map<std::string, UserData> userdb;
 
};
 
#endif
backends/twitter/TwitterResponseParser.cpp
Show inline comments
 
new file 100644
 
#include "TwitterResponseParser.h"
 
#include "transport/logging.h"
 
#include <cctype>
 

	
 
DEFINE_LOGGER(logger, "TwitterResponseParser")
 

	
 
static std::string tolowercase(std::string inp)
 
{
 
	std::string out = inp;
 
	for(int i=0 ; i<out.size() ; i++) out[i] = tolower(out[i]);
 
	return out;
 
}
 

	
 
EmbeddedStatus getEmbeddedStatus(const Swift::ParserElement::ref &element, const std::string xmlns)
 
{
 
	EmbeddedStatus status;
 
	if(element->getName() != TwitterReponseTypes::status) {
 
		LOG4CXX_ERROR(logger, "Not a status element!")
 
		return status;
 
	}
 

	
 
	status.setCreationTime( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) );
 
	status.setID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 
	status.setTweet( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) );
 
	status.setTruncated( std::string( element->getChild(TwitterReponseTypes::truncated, xmlns)->getText() )=="true" );
 
	status.setReplyToStatusID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_status_id, xmlns)->getText() ) );
 
	status.setReplyToUserID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_user_id, xmlns)->getText() ) );
 
	status.setReplyToScreenName( std::string( element->getChild(TwitterReponseTypes::in_reply_to_screen_name, xmlns)->getText() ) );
 
	status.setRetweetCount( atoi( element->getChild(TwitterReponseTypes::retweet_count, xmlns)->getText().c_str() ) );
 
	status.setFavorited( std::string( element->getChild(TwitterReponseTypes::favorited, xmlns)->getText() )=="true" );
 
	status.setRetweeted( std::string( element->getChild(TwitterReponseTypes::retweeted, xmlns)->getText() )=="true" );
 
	return status;
 
}
 

	
 
User getUser(const Swift::ParserElement::ref &element, const std::string xmlns) 
 
{
 
	User user;
 
	if(element->getName() != TwitterReponseTypes::user 
 
	   && element->getName() != TwitterReponseTypes::sender
 
	   && element->getName() != TwitterReponseTypes::recipient) {
 
		LOG4CXX_ERROR(logger, "Not a user element!")
 
		return user;
 
	}
 

	
 
	user.setUserID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 
	user.setScreenName( tolowercase( std::string( element->getChild(TwitterReponseTypes::screen_name, xmlns)->getText() ) ) );
 
	user.setUserName( std::string( element->getChild(TwitterReponseTypes::name, xmlns)->getText() ) );
 
	user.setProfileImgURL( std::string( element->getChild(TwitterReponseTypes::profile_image_url, xmlns)->getText() ) );
 
	user.setNumberOfTweets( atoi(element->getChild(TwitterReponseTypes::statuses_count, xmlns)->getText().c_str()) );
 
	if(element->getChild(TwitterReponseTypes::status, xmlns)) 
 
		user.setLastStatus(getEmbeddedStatus(element->getChild(TwitterReponseTypes::status, xmlns),  xmlns));
 
	return user;
 
}
 

	
 
Status getStatus(const Swift::ParserElement::ref &element, const std::string xmlns) 
 
{
 
	Status status;
 
	if(element->getName() != "status") {
 
		LOG4CXX_ERROR(logger, "Not a status element!")
 
		return status;
 
	}
 

	
 
	status.setCreationTime( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) );
 
	status.setID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 
	status.setTweet( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) );
 
	status.setTruncated( std::string( element->getChild(TwitterReponseTypes::truncated, xmlns)->getText() )=="true" );
 
	status.setReplyToStatusID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_status_id, xmlns)->getText() ) );
 
	status.setReplyToUserID( std::string( element->getChild(TwitterReponseTypes::in_reply_to_user_id, xmlns)->getText() ) );
 
	status.setReplyToScreenName( std::string( element->getChild(TwitterReponseTypes::in_reply_to_screen_name, xmlns)->getText() ) );
 
	status.setUserData( getUser(element->getChild(TwitterReponseTypes::user, xmlns), xmlns) );
 
	status.setRetweetCount( atoi( element->getChild(TwitterReponseTypes::retweet_count, xmlns)->getText().c_str() ) );
 
	status.setFavorited( std::string( element->getChild(TwitterReponseTypes::favorited, xmlns)->getText() )=="true" );
 
	status.setRetweeted( std::string( element->getChild(TwitterReponseTypes::retweeted, xmlns)->getText() )=="true" );
 
	return status;
 
}
 

	
 
DirectMessage getDirectMessage(const Swift::ParserElement::ref &element, const std::string xmlns) 
 
{
 
	DirectMessage DM;
 
	if(element->getName() != TwitterReponseTypes::direct_message) {
 
		LOG4CXX_ERROR(logger, "Not a direct_message element!")
 
		return DM;
 
	}
 

	
 
	DM.setCreationTime( std::string( element->getChild(TwitterReponseTypes::created_at, xmlns)->getText() ) );
 
	DM.setID( std::string( element->getChild(TwitterReponseTypes::id, xmlns)->getText() ) );
 
	DM.setMessage( std::string( element->getChild(TwitterReponseTypes::text, xmlns)->getText() ) );
 
	DM.setSenderID( std::string( element->getChild(TwitterReponseTypes::sender_id, xmlns)->getText() ) );
 
	DM.setRecipientID( std::string( element->getChild(TwitterReponseTypes::recipient_id, xmlns)->getText() ) );
 
	DM.setSenderScreenName( std::string( element->getChild(TwitterReponseTypes::sender_screen_name, xmlns)->getText() ) );
 
	DM.setRecipientScreenName( std::string( element->getChild(TwitterReponseTypes::recipient_screen_name, xmlns)->getText() ) );
 
	DM.setSenderData( getUser(element->getChild(TwitterReponseTypes::sender, xmlns), xmlns) );
 
	DM.setRecipientData( getUser(element->getChild(TwitterReponseTypes::recipient, xmlns), xmlns) );
 
	return DM;
 
}
 

	
 
std::vector<Status> getTimeline(std::string &xml)
 
{
 
	std::vector<Status> statuses;
 
	Swift::ParserElement::ref rootElement = Swift::StringTreeParser::parse(xml);
 
	
 
	if(rootElement == NULL) {
 
		LOG4CXX_ERROR(logger, "Error while parsing XML")
 
		return statuses;
 
	}
 

	
 
	if(rootElement->getName() != "statuses") {
 
		LOG4CXX_ERROR(logger, "XML doesn't correspond to timeline")
 
		return statuses;
 
	}
 

	
 
	const std::string xmlns = rootElement->getNamespace();
 
	const std::vector<Swift::ParserElement::ref> children = rootElement->getChildren(TwitterReponseTypes::status, xmlns);
 

	
 
	for(int i = 0; i <  children.size() ; i++) {
 
		const Swift::ParserElement::ref status = children[i];
 
		statuses.push_back(getStatus(status, xmlns));
 
	}
 
	return statuses;
 
}
 

	
 
std::vector<DirectMessage> getDirectMessages(std::string &xml)
 
{
 
	std::vector<DirectMessage> DMs;
 
	Swift::ParserElement::ref rootElement = Swift::StringTreeParser::parse(xml);
 
	
 
	if(rootElement == NULL) {
 
		LOG4CXX_ERROR(logger, "Error while parsing XML")
 
		return DMs;
 
	}
 
	
 
	if(rootElement->getName() != TwitterReponseTypes::directmessages) {
 
		LOG4CXX_ERROR(logger, "XML doesn't correspond to direct-messages")
 
		return DMs;
 
	}
 

	
 
	const std::string xmlns = rootElement->getNamespace();
 
	const std::vector<Swift::ParserElement::ref> children = rootElement->getChildren(TwitterReponseTypes::direct_message, xmlns);
 

	
 
	for(int i = 0; i <  children.size() ; i++) {
 
		const Swift::ParserElement::ref dm = children[i];
 
		DMs.push_back(getDirectMessage(dm, xmlns));
 
	}
 
	return DMs;
 
}
 

	
 
std::vector<User> getUsers(std::string &xml)
 
{
 
	std::vector<User> users;
 
	Swift::ParserElement::ref rootElement = Swift::StringTreeParser::parse(xml);
 
	
 
	if(rootElement == NULL) {
 
		LOG4CXX_ERROR(logger, "Error while parsing XML")
 
		return users;
 
	}
 

	
 
	if(rootElement->getName() != TwitterReponseTypes::users) {
 
		LOG4CXX_ERROR(logger, "XML doesn't correspond to user list")
 
		return users;
 
	}
 

	
 
	const std::string xmlns = rootElement->getNamespace();
 
	const std::vector<Swift::ParserElement::ref> children = rootElement->getChildren(TwitterReponseTypes::user, xmlns);
 

	
 
	for(int i = 0 ; i < children.size() ; i++) {
 
		const Swift::ParserElement::ref user = children[i];
 
		users.push_back(getUser(user, xmlns));
 
	}
 
	return users;
 
}
 

	
 
User getUser(std::string &xml)
 
{
 
	User user;
 
	Swift::ParserElement::ref rootElement = Swift::StringTreeParser::parse(xml);
 
	
 
	if(rootElement == NULL) {
 
		LOG4CXX_ERROR(logger, "Error while parsing XML")
 
		return user;
 
	}
 

	
 
	if(rootElement->getName() != TwitterReponseTypes::user) {
 
		LOG4CXX_ERROR(logger, "XML doesn't correspond to user object")
 
		return user;
 
	}
 

	
 
	const std::string xmlns = rootElement->getNamespace();
 
	return user = getUser(rootElement, xmlns);
 
}
 

	
 
std::vector<std::string> getIDs(std::string &xml)
 
{
 
	std::vector<std::string> IDs;
 
	Swift::ParserElement::ref rootElement = Swift::StringTreeParser::parse(xml);
 

	
 
	if(rootElement == NULL) {
 
		LOG4CXX_ERROR(logger, "Error while parsing XML")
 
		return IDs;
 
	}
 

	
 
	if(rootElement->getName() != TwitterReponseTypes::id_list) {
 
		LOG4CXX_ERROR(logger, "XML doesn't correspond to id_list");
 
		return IDs;
 
	}
 

	
 
	const std::string xmlns = rootElement->getNamespace();
 
	const std::vector<Swift::ParserElement::ref> ids = rootElement->getChild(TwitterReponseTypes::ids, xmlns)->getChildren(TwitterReponseTypes::id, xmlns);
 
	
 
	for(int i=0 ; i<ids.size() ; i++) {
 
		IDs.push_back(std::string( ids[i]->getText() ));
 
	}
 
	return IDs;
 
}
 

	
 
std::string getErrorMessage(std::string &xml)
 
{
 
	std::string error;
 
	Swift::ParserElement::ref rootElement = Swift::StringTreeParser::parse(xml);
 

	
 
	if(rootElement == NULL) {
 
		LOG4CXX_ERROR(logger, "Error while parsing XML");
 
		return "";
 
	}
 

	
 
	const std::string xmlns = rootElement->getNamespace();
 
	const Swift::ParserElement::ref errorElement = rootElement->getChild(TwitterReponseTypes::error, xmlns);
 
	
 
	if(errorElement != NULL) error = errorElement->getText();
 
	return error;
 
}
backends/twitter/TwitterResponseParser.h
Show inline comments
 
new file 100644
 
#ifndef TWITTERRESPOSNSEPARSER_H
 
#define TWITTERRESPOSNSEPARSER_H
 

	
 
#include "Swiften/Parser/StringTreeParser.h"
 
#include <iostream>
 
#include <vector>
 

	
 
namespace TwitterReponseTypes
 
{
 
	const std::string id = "id";
 
	const std::string id_list = "id_list";
 
	const std::string ids = "ids";
 
	const std::string name = "name";
 
	const std::string screen_name = "screen_name";
 
	const std::string statuses_count = "statuses_count";
 
	const std::string created_at = "created_at";
 
	const std::string text = "text";
 
	const std::string truncated = "truncated";
 
	const std::string in_reply_to_status_id = "in_reply_to_user_id";
 
	const std::string in_reply_to_user_id = "in_reply_to_user_id";
 
	const std::string in_reply_to_screen_name = "in_reply_to_screen_name";
 
	const std::string retweet_count = "retweet_count";
 
	const std::string favorited = "favorited";
 
	const std::string retweeted = "retweeted";
 
	const std::string user = "user";
 
	const std::string users = "users";
 
	const std::string status = "status";
 
	const std::string error = "error";
 
	const std::string direct_message = "direct_message";
 
	const std::string directmessages = "direct-messages";
 
	const std::string sender_id = "sender_id";
 
	const std::string recipient_id = "recipient_id";
 
	const std::string sender_screen_name = "sender_screen_name";
 
	const std::string recipient_screen_name = "recipient_screen_name";
 
	const std::string sender = "sender";
 
   	const std::string recipient = "recipient";
 
	const std::string profile_image_url = "profile_image_url";
 
};
 

	
 
//Class representing an embedded status object within other objects such as the User object.
 
//Note: Not possible to user Status due to circular dependency
 
class EmbeddedStatus
 
{
 
	std::string created_at;
 
	std::string ID;
 
	std::string text;
 
	bool truncated;
 
	std::string in_reply_to_status_id;
 
	std::string in_reply_to_user_id;
 
	std::string in_reply_to_screen_name;
 
	unsigned int retweet_count;
 
	bool favorited;
 
	bool retweeted;
 
	
 
	public:
 
	EmbeddedStatus():created_at(""),ID(""),text(""),truncated(false),in_reply_to_status_id(""),
 
	         in_reply_to_user_id(""),in_reply_to_screen_name(""),retweet_count(0),
 
	         favorited(false),retweeted(0){}
 
	
 
	std::string getCreationTime() {return created_at;}
 
	std::string getID() {return ID;}
 
	std::string getTweet() {return text;}
 
	bool isTruncated() {return truncated;}
 
	std::string getReplyToStatusID() {return in_reply_to_status_id;}
 
	std::string getReplyToUserID() {return in_reply_to_user_id;}
 
	std::string getReplyToScreenName() {return in_reply_to_screen_name;}
 
	unsigned int getRetweetCount() {return retweet_count;}
 
	bool isFavorited() {return favorited;}
 
	bool isRetweeted() {return retweeted;}
 
	
 
	void setCreationTime(std::string _created) {created_at = _created;}
 
	void setID(std::string _id) {ID = _id;}
 
	void setTweet(std::string _text) {text = _text;}
 
	void setTruncated(bool val) {truncated = val;}
 
	void setReplyToStatusID(std::string _id) {in_reply_to_status_id = _id;}
 
	void setReplyToUserID(std::string _id) {in_reply_to_user_id = _id;}
 
	void setReplyToScreenName(std::string _name) {in_reply_to_screen_name = _name;}
 
	void setRetweetCount(unsigned int rc) {retweet_count = rc;}
 
	void setFavorited(bool val) {favorited = val;}
 
	void setRetweeted(bool val) {retweeted = val;}
 
};
 

	
 
//Class holding user data
 
class User
 
{
 
	std::string ID;
 
	std::string name;
 
	std::string screen_name;
 
	std::string profile_image_url;
 
	unsigned int statuses_count;
 
	EmbeddedStatus last_status;
 

	
 
	public:
 
	User():ID(""),name(""),screen_name(""),statuses_count(0){}
 

	
 
	std::string getUserID() {return ID;}
 
	std::string getUserName() {return name;}
 
	std::string getScreenName() {return screen_name;}
 
	std::string getProfileImgURL() {return profile_image_url;}
 
	unsigned int getNumberOfTweets() {return statuses_count;}
 
	EmbeddedStatus getLastStatus() {return last_status;}
 
	
 
	
 
	void setUserID(std::string _id) {ID = _id;}
 
	void setUserName(std::string _name) {name = _name;}
 
	void setScreenName(std::string _screen) {screen_name = _screen;}
 
	void setProfileImgURL(std::string _url) {profile_image_url = _url;}
 
	void setNumberOfTweets(unsigned int sc) {statuses_count  = sc;}
 
	void setLastStatus(EmbeddedStatus _last_status) {last_status = _last_status;}
 
};
 

	
 

	
 
//Class representing a status (tweet)
 
class Status
 
{
 
	std::string created_at;
 
	std::string ID;
 
	std::string text;
 
	bool truncated;
 
	std::string in_reply_to_status_id;
 
	std::string in_reply_to_user_id;
 
	std::string in_reply_to_screen_name;
 
	User user;
 
	unsigned int retweet_count;
 
	bool favorited;
 
	bool retweeted;
 

	
 
	public:
 
	Status():created_at(""),ID(""),text(""),truncated(false),in_reply_to_status_id(""),
 
	         in_reply_to_user_id(""),in_reply_to_screen_name(""),user(User()),retweet_count(0),
 
	         favorited(false),retweeted(0){}
 
	
 
	std::string getCreationTime() {return created_at;}
 
	std::string getID() {return ID;}
 
	std::string getTweet() {return text;}
 
	bool isTruncated() {return truncated;}
 
	std::string getReplyToStatusID() {return in_reply_to_status_id;}
 
	std::string getReplyToUserID() {return in_reply_to_user_id;}
 
	std::string getReplyToScreenName() {return in_reply_to_screen_name;}
 
	User getUserData() {return user;}
 
	unsigned int getRetweetCount() {return retweet_count;}
 
	bool isFavorited() {return favorited;}
 
	bool isRetweeted() {return retweeted;}
 
	
 
	void setCreationTime(std::string _created) {created_at = _created;}
 
	void setID(std::string _id) {ID = _id;}
 
	void setTweet(std::string _text) {text = _text;}
 
	void setTruncated(bool val) {truncated = val;}
 
	void setReplyToStatusID(std::string _id) {in_reply_to_status_id = _id;}
 
	void setReplyToUserID(std::string _id) {in_reply_to_user_id = _id;}
 
	void setReplyToScreenName(std::string _name) {in_reply_to_screen_name = _name;}
 
	void setUserData(User u) {user = u;}
 
	void setRetweetCount(unsigned int rc) {retweet_count = rc;}
 
	void setFavorited(bool val) {favorited = val;}
 
	void setRetweeted(bool val) {retweeted = val;}
 
};
 

	
 
//Class representing a Direct Message
 
class DirectMessage
 
{
 
	std::string created_at;
 
	std::string ID;
 
	std::string text;
 
	std::string sender_id;
 
	std::string recipient_id;
 
	std::string sender_screen_name;
 
	std::string recipient_screen_name;
 
	User sender, recipient;
 

	
 
	public:
 
	DirectMessage():created_at(""),ID(""),text(""),sender_id(""),recipient_id(""),
 
			 sender_screen_name(""),recipient_screen_name(""),sender(User()),recipient(User()){}
 
	
 
	std::string getCreationTime() {return created_at;}
 
	std::string getID() {return ID;}
 
	std::string getMessage() {return text;}
 
	std::string getSenderID() {return sender_id;}
 
	std::string getRecipientID() {return recipient_id;}
 
	std::string getSenderScreenName() {return sender_screen_name;}
 
	std::string getRecipientScreenName() {return recipient_screen_name;}
 
	User getSenderData() {return sender;}
 
	User getRecipientData() {return recipient;}
 
	
 
	void setCreationTime(std::string _created) {created_at = _created;}
 
	void setID(std::string _id) {ID = _id;}
 
	void setMessage(std::string _text) {text = _text;}
 
	void setSenderID(std::string _id) {sender_id = _id;}
 
	void setRecipientID(std::string _id) {recipient_id = _id;}
 
	void setSenderScreenName(std::string _name) {sender_screen_name = _name;}
 
	void setRecipientScreenName(std::string _name) {recipient_screen_name = _name;}
 
	void setSenderData(User u) {sender = u;}
 
	void setRecipientData(User u) {recipient = u;}
 
};
 

	
 
std::vector<Status> getTimeline(std::string &xml);
 
std::vector<DirectMessage> getDirectMessages(std::string &xml);
 
std::vector<std::string> getIDs(std::string &xml);
 
std::vector<User> getUsers(std::string &xml);
 
User getUser(std::string &xml);
 
std::string getErrorMessage(std::string &xml);
 

	
 
Status getStatus(const Swift::ParserElement::ref &element, const std::string xmlns);
 
DirectMessage getDirectMessage(const Swift::ParserElement::ref &element, const std::string xmlns);
 
User getUser(const Swift::ParserElement::ref &element, const std::string xmlns);
 
#endif
backends/twitter/libtwitcurl/.svn/all-wcprops
Show inline comments
 
new file 100644
 
K 25
 
svn:wc:ra_dav:version-url
 
V 34
 
/svn/!svn/ver/89/trunk/libtwitcurl
 
END
 
twitcurl.vcproj
 
K 25
 
svn:wc:ra_dav:version-url
 
V 50
 
/svn/!svn/ver/55/trunk/libtwitcurl/twitcurl.vcproj
 
END
 
SHA1.h
 
K 25
 
svn:wc:ra_dav:version-url
 
V 41
 
/svn/!svn/ver/47/trunk/libtwitcurl/SHA1.h
 
END
 
oauthlib.cpp
 
K 25
 
svn:wc:ra_dav:version-url
 
V 47
 
/svn/!svn/ver/89/trunk/libtwitcurl/oauthlib.cpp
 
END
 
oauthlib.h
 
K 25
 
svn:wc:ra_dav:version-url
 
V 45
 
/svn/!svn/ver/89/trunk/libtwitcurl/oauthlib.h
 
END
 
twitcurl.plg
 
K 25
 
svn:wc:ra_dav:version-url
 
V 47
 
/svn/!svn/ver/47/trunk/libtwitcurl/twitcurl.plg
 
END
 
twitcurl.cpp
 
K 25
 
svn:wc:ra_dav:version-url
 
V 47
 
/svn/!svn/ver/87/trunk/libtwitcurl/twitcurl.cpp
 
END
 
urlencode.cpp
 
K 25
 
svn:wc:ra_dav:version-url
 
V 48
 
/svn/!svn/ver/47/trunk/libtwitcurl/urlencode.cpp
 
END
 
twitcurl.dsp
 
K 25
 
svn:wc:ra_dav:version-url
 
V 47
 
/svn/!svn/ver/47/trunk/libtwitcurl/twitcurl.dsp
 
END
 
twitcurl.h
 
K 25
 
svn:wc:ra_dav:version-url
 
V 45
 
/svn/!svn/ver/87/trunk/libtwitcurl/twitcurl.h
 
END
 
HMAC_SHA1.cpp
 
K 25
 
svn:wc:ra_dav:version-url
 
V 48
 
/svn/!svn/ver/79/trunk/libtwitcurl/HMAC_SHA1.cpp
 
END
 
base64.cpp
 
K 25
 
svn:wc:ra_dav:version-url
 
V 45
 
/svn/!svn/ver/47/trunk/libtwitcurl/base64.cpp
 
END
 
urlencode.h
 
K 25
 
svn:wc:ra_dav:version-url
 
V 46
 
/svn/!svn/ver/47/trunk/libtwitcurl/urlencode.h
 
END
 
COPYING
 
K 25
 
svn:wc:ra_dav:version-url
 
V 42
 
/svn/!svn/ver/65/trunk/libtwitcurl/COPYING
 
END
 
twitcurl.sln
 
K 25
 
svn:wc:ra_dav:version-url
 
V 47
 
/svn/!svn/ver/47/trunk/libtwitcurl/twitcurl.sln
 
END
 
twitcurl.dsw
 
K 25
 
svn:wc:ra_dav:version-url
 
V 47
 
/svn/!svn/ver/47/trunk/libtwitcurl/twitcurl.dsw
 
END
 
base64.h
 
K 25
 
svn:wc:ra_dav:version-url
 
V 43
 
/svn/!svn/ver/47/trunk/libtwitcurl/base64.h
 
END
 
HMAC_SHA1.h
 
K 25
 
svn:wc:ra_dav:version-url
 
V 46
 
/svn/!svn/ver/79/trunk/libtwitcurl/HMAC_SHA1.h
 
END
 
SHA1.cpp
 
K 25
 
svn:wc:ra_dav:version-url
 
V 43
 
/svn/!svn/ver/47/trunk/libtwitcurl/SHA1.cpp
 
END
 
CMakeLists.txt
 
K 25
 
svn:wc:ra_dav:version-url
 
V 49
 
/svn/!svn/ver/47/trunk/libtwitcurl/CMakeLists.txt
 
END
 
Makefile
 
K 25
 
svn:wc:ra_dav:version-url
 
V 43
 
/svn/!svn/ver/81/trunk/libtwitcurl/Makefile
 
END
 
twitcurl.opt
 
K 25
 
svn:wc:ra_dav:version-url
 
V 47
 
/svn/!svn/ver/47/trunk/libtwitcurl/twitcurl.opt
 
END
backends/twitter/libtwitcurl/.svn/entries
Show inline comments
 
new file 100644
 
10
 

	
 
dir
 
89
 
http://twitcurl.googlecode.com/svn/trunk/libtwitcurl
 
http://twitcurl.googlecode.com/svn
 

	
 

	
 

	
 
2012-07-21T07:38:48.554435Z
 
89
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
4714a580-958b-11de-ad41-3fcdc5e0e42d
 

 
twitcurl.vcproj
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.286968Z
 
4bd65d0283824fc74c2f6051b8e07776
 
2011-09-12T19:28:25.614324Z
 
55
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
7434
 

 
SHA1.h
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.286968Z
 
3e6264ad43d1070aae2a29349c56c9cc
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
3793
 

 
oauthlib.cpp
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.286968Z
 
0952e80b192c5a453732c6a4a4ba937c
 
2012-07-21T07:38:48.554435Z
 
89
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
18582
 

 
oauthlib.h
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.286968Z
 
2a41db8667c9f1d735041672a4a8f0ce
 
2012-07-21T07:38:48.554435Z
 
89
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
5387
 

 
twitcurl.plg
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.286968Z
 
27b1201e052363c6a0c58d907066d74a
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
1136
 

 
twitcurl.cpp
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.286968Z
 
a8959426e8a890965049fb620413c117
 
2012-06-03T15:11:03.334716Z
 
87
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
60750
 

 
urlencode.cpp
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.286968Z
 
6fee0a296ccbe0235a1b32468f8336d5
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
908
 

 
twitcurl.dsp
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
3d5dc2fdeea286408f9c0e8a9eb6e011
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
3571
 

 
twitcurl.h
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
42f24b664799b8b1a394dfa3f0e51813
 
2012-06-03T15:11:03.334716Z
 
87
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
11774
 

 
HMAC_SHA1.cpp
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
7f04808b83824ab2a318470601f84dd2
 
2012-04-28T15:24:29.877388Z
 
79
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
1601
 

 
base64.cpp
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
91aaa43b9e4890495a6f736625199f4f
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
3857
 

 
curl
 
dir
 

 
urlencode.h
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
2ad501c16a14e6ed0616d139de66595d
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
204
 

 
lib
 
dir
 

 
twitcurl.sln
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
49dc7abe44deb368fd788b3fbc5f1fa5
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
890
 

 
COPYING
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
c75e20d7cf9fdeffe56535e17f12b35d
 
2011-10-20T12:45:00.933609Z
 
65
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
1087
 

 
twitcurl.dsw
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
b0211575457694f45a6353f864e1f8c2
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
539
 

 
base64.h
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
0460713f8efdfb3a5d1a97c860d289e8
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
138
 

 
HMAC_SHA1.h
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.290968Z
 
e1f7964c76fe86ee35ee3bdea6ace44a
 
2012-04-28T15:24:29.877388Z
 
79
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
1070
 

 
SHA1.cpp
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.294968Z
 
25c20a8b1351cc20b19850cc96c92ec0
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
7580
 

 
CMakeLists.txt
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.294968Z
 
4173b9d6da7d014a782d92b266ae9055
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
656
 

 
Makefile
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.294968Z
 
c8f5bce48a007345fb8bf89778311fc9
 
2012-06-03T08:51:10.455158Z
 
81
 
swatkat.thinkdigit@gmail.com
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
1798
 

 
twitcurl.opt
 
file
 

	
 

	
 

	
 

	
 
2012-08-04T17:27:29.294968Z
 
a164218ef0fadc31afcbb5d3a2a3f1dd
 
2011-09-12T17:56:21.927956Z
 
47
 
swatkat.thinkdigit@gmail.com
 
has-props
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 

	
 
50688
 

backends/twitter/libtwitcurl/.svn/prop-base/twitcurl.opt.svn-base
Show inline comments
 
new file 100644
 
K 13
 
svn:mime-type
 
V 24
 
application/octet-stream
 
END
backends/twitter/libtwitcurl/.svn/text-base/CMakeLists.txt.svn-base
Show inline comments
 
new file 100644
 
cmake_minimum_required(VERSION 2.5)
 
project(libtwit)
 
set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake_modules/")
 
set(twitSrcs base64.cpp HMAC_SHA1.cpp oauthlib.cpp SHA1.cpp urlencode.cpp twitcurl.cpp)
 
FIND_PACKAGE(PkgConfig)
 
#pkg_check_modules (PKGS)
 
include_directories (${PKGS_INCLUDE_DIRS}) 
 
add_library(twit STATIC ${twitSrcs})
 
SET_TARGET_PROPERTIES(twit PROPERTIES CLEAN_DIRECT_OUTPUT "wcode")
 
target_link_libraries(twit)
 
SET(CMAKE_INSTALL_LIBDIR libtwit CACHE PATH "Output directory for libraries")
 
 
 
install(TARGETS twit DESTINATION lib)
 
INSTALL(FILES twitcurl.h DESTINATION include/libtwit) 
 
INSTALL(FILES oauthlib.h DESTINATION include/libtwit) 
 
 
 
\ No newline at end of file
backends/twitter/libtwitcurl/.svn/text-base/COPYING.svn-base
Show inline comments
 
new file 100644
 
Copyright (C) 2011 by swatkat (swatkat.thinkdigitATgmailDOTcom)
 

	
 
Permission is hereby granted, free of charge, to any person obtaining a copy
 
of this software and associated documentation files (the "Software"), to deal
 
in the Software without restriction, including without limitation the rights
 
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
copies of the Software, and to permit persons to whom the Software is
 
furnished to do so, subject to the following conditions:
 

	
 
The above copyright notice and this permission notice shall be included in
 
all copies or substantial portions of the Software.
 

	
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
THE SOFTWARE.
 
\ No newline at end of file
backends/twitter/libtwitcurl/.svn/text-base/HMAC_SHA1.cpp.svn-base
Show inline comments
 
new file 100644
 
//******************************************************************************
 
//* HMAC_SHA1.cpp : Implementation of HMAC SHA1 algorithm
 
//*                 Comfort to RFC 2104
 
//*
 
//******************************************************************************
 
#include "HMAC_SHA1.h"
 
#include <iostream>
 
#include <memory>
 
 
 
void CHMAC_SHA1::HMAC_SHA1(BYTE *text, int text_len, BYTE *key, int key_len, BYTE *digest)
 
{
 
	memset(SHA1_Key, 0, SHA1_BLOCK_SIZE);
 
 
	/* repeated 64 times for values in ipad and opad */
 
	memset(m_ipad, 0x36, sizeof(m_ipad));
 
	memset(m_opad, 0x5c, sizeof(m_opad));
 
 
	/* STEP 1 */
 
	if (key_len > SHA1_BLOCK_SIZE)
 
	{
 
		CSHA1::Reset();
 
		CSHA1::Update((UINT_8 *)key, key_len);
 
		CSHA1::Final();
 
 
		CSHA1::GetHash((UINT_8 *)SHA1_Key);
 
	}
 
	else
 
		memcpy(SHA1_Key, key, key_len);
 
 
	/* STEP 2 */
 
	for (size_t i=0; i<sizeof(m_ipad); i++)
 
	{
 
		m_ipad[i] ^= SHA1_Key[i];		
 
	}
 
 
	/* STEP 3 */
 
	memcpy(AppendBuf1, m_ipad, sizeof(m_ipad));
 
	memcpy(AppendBuf1 + sizeof(m_ipad), text, text_len);
 
 
	/* STEP 4 */
 
	CSHA1::Reset();
 
	CSHA1::Update((UINT_8 *)AppendBuf1, sizeof(m_ipad) + text_len);
 
	CSHA1::Final();
 
 
	CSHA1::GetHash((UINT_8 *)szReport);
 
 
	/* STEP 5 */
 
	for (size_t j=0; j<sizeof(m_opad); j++)
 
	{
 
		m_opad[j] ^= SHA1_Key[j];
 
	}
 
 
	/* STEP 6 */
 
	memcpy(AppendBuf2, m_opad, sizeof(m_opad));
 
	memcpy(AppendBuf2 + sizeof(m_opad), szReport, SHA1_DIGEST_LENGTH);
 
 
	/*STEP 7 */
 
	CSHA1::Reset();
 
	CSHA1::Update((UINT_8 *)AppendBuf2, sizeof(m_opad) + SHA1_DIGEST_LENGTH);
 
	CSHA1::Final();
 
 
	CSHA1::GetHash((UINT_8 *)digest);
 
}
backends/twitter/libtwitcurl/.svn/text-base/HMAC_SHA1.h.svn-base
Show inline comments
 
new file 100644
 
/*
 
	100% free public domain implementation of the HMAC-SHA1 algorithm
 
	by Chien-Chung, Chung (Jim Chung) <jimchung1221@gmail.com>
 
*/
 
 
 
#ifndef __HMAC_SHA1_H__
 
#define __HMAC_SHA1_H__
 
 
#include "SHA1.h"
 
 
typedef unsigned char BYTE ;
 
 
class CHMAC_SHA1 : public CSHA1
 
{
 
    private:
 
		BYTE m_ipad[64];
 
        BYTE m_opad[64];
 
 
		char * szReport ;
 
		char * SHA1_Key ;
 
		char * AppendBuf1 ;
 
		char * AppendBuf2 ;
 
 
 
	public:
 
		
 
		enum {
 
			SHA1_DIGEST_LENGTH	= 20,
 
			SHA1_BLOCK_SIZE		= 64,
 
			HMAC_BUF_LEN		= 4096
 
		} ;
 
 
		CHMAC_SHA1()
 
			:szReport(new char[HMAC_BUF_LEN]),
 
             SHA1_Key(new char[HMAC_BUF_LEN]),
 
             AppendBuf1(new char[HMAC_BUF_LEN]),
 
             AppendBuf2(new char[HMAC_BUF_LEN])
 
		{}
 
 
        ~CHMAC_SHA1()
 
        {
 
            delete[] szReport ;
 
            delete[] AppendBuf1 ;
 
            delete[] AppendBuf2 ;
 
            delete[] SHA1_Key ;
 
        }
 
 
        void HMAC_SHA1(BYTE *text, int text_len, BYTE *key, int key_len, BYTE *digest);
 
};
 
 
 
#endif /* __HMAC_SHA1_H__ */
backends/twitter/libtwitcurl/.svn/text-base/Makefile.svn-base
Show inline comments
 
new file 100644
 
# Hey Emacs, this is a -*- makefile -*-
 
# The twitcurl library.. a Makefile for OpenWRT
 
# Makefile-fu by John Boiles
 
# 28 September 2009
 

	
 
LIBNAME = twitcurl
 
SRC = $(LIBNAME).cpp
 
STAGING_DIR = 
 
INCLUDE_DIR = $(STAGING_DIR)/usr/include
 
LINCLUDE_DIR = $(STAGING_DIR)/usr/local/include
 
LIBRARY_DIR = $(STAGING_DIR)/usr/lib
 
LLIBRARY_DIR = $(STAGING_DIR)/usr/local/lib
 
LDFLAGS += -Wl,-rpath-link=$(STAGING_DIR)/usr/lib
 
CC = g++
 
REMOVE = rm -f
 
COPY = cp
 
REMOTEIP = 192.168.1.30
 

	
 
# Compiler flag to set the C Standard level.
 
# c89   - "ANSI" C
 
# gnu89 - c89 plus GCC extensions
 
# c99   - ISO C99 standard (not yet fully implemented)
 
# gnu99 - c99 plus GCC extensions
 
# CSTANDARD = -std=gnu99
 

	
 
# Place -D or -U options here
 
CDEFS =
 

	
 
# Place -I options here
 
CINCS = 
 

	
 
CFLAGS =$(CDEFS) $(CINCS) $(CSTANDARD)
 

	
 
all: target
 

	
 
target: $(SRC) $(LIBNAME).h
 
	$(CC) -Wall -fPIC -c -I$(INCLUDE_DIR) $(SRC) oauthlib.cpp urlencode.cpp base64.cpp HMAC_SHA1.cpp SHA1.cpp
 
	$(CC) -shared -Wl,-soname,lib$(LIBNAME).so.1 $(LDFLAGS) -o lib$(LIBNAME).so.1.0 *.o -L$(LIBRARY_DIR) -lcurl
 

	
 
#clean project.
 
clean:
 
	$(REMOVE) $(LIBNAME)*.so.1.0
 
	$(REMOVE) $(LIBNAME).o
 
	$(REMOVE) $(LIBRARY_DIR)/lib$(LIBNAME).so*
 
	
 
# Install library to local openwrt library directory
 
install: all
 
	$(COPY) lib$(LIBNAME).so.1.0 $(LIBRARY_DIR)
 
	$(COPY) lib$(LIBNAME).so.1.0 $(LLIBRARY_DIR)
 
	$(COPY) $(LIBNAME).h $(INCLUDE_DIR)/
 
	$(COPY) $(LIBNAME).h $(LINCLUDE_DIR)/
 
	$(COPY) oauthlib.h $(INCLUDE_DIR)/
 
	$(COPY) oauthlib.h $(LINCLUDE_DIR)/
 
	ln -sf $(LIBRARY_DIR)/lib$(LIBNAME).so.1.0 $(LIBRARY_DIR)/lib$(LIBNAME).so
 
	ln -sf $(LIBRARY_DIR)/lib$(LIBNAME).so.1.0 $(LIBRARY_DIR)/lib$(LIBNAME).so.1
 
	ln -sf $(LLIBRARY_DIR)/lib$(LIBNAME).so.1.0 $(LLIBRARY_DIR)/lib$(LIBNAME).so
 
	ln -sf $(LLIBRARY_DIR)/lib$(LIBNAME).so.1.0 $(LLIBRARY_DIR)/lib$(LIBNAME).so.1
backends/twitter/libtwitcurl/.svn/text-base/SHA1.cpp.svn-base
Show inline comments
 
new file 100644
 
/*
 
	100% free public domain implementation of the SHA-1 algorithm
 
	by Dominik Reichl <dominik.reichl@t-online.de>
 
	Web: http://www.dominik-reichl.de/
 
 
	Version 1.6 - 2005-02-07 (thanks to Howard Kapustein for patches)
 
	- You can set the endianness in your files, no need to modify the
 
	  header file of the CSHA1 class any more
 
	- Aligned data support
 
	- Made support/compilation of the utility functions (ReportHash
 
	  and HashFile) optional (useful, if bytes count, for example in
 
	  embedded environments)
 
 
	Version 1.5 - 2005-01-01
 
	- 64-bit compiler compatibility added
 
	- Made variable wiping optional (define SHA1_WIPE_VARIABLES)
 
	- Removed unnecessary variable initializations
 
	- ROL32 improvement for the Microsoft compiler (using _rotl)
 
 
	======== Test Vectors (from FIPS PUB 180-1) ========
 
 
	SHA1("abc") =
 
		A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
 
 
	SHA1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") =
 
		84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
 
 
	SHA1(A million repetitions of "a") =
 
		34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
 
*/
 
 
#include "SHA1.h"
 
 
#ifdef SHA1_UTILITY_FUNCTIONS
 
#define SHA1_MAX_FILE_BUFFER 8000
 
#endif
 
 
// Rotate x bits to the left
 
#ifndef ROL32
 
#ifdef _MSC_VER
 
#define ROL32(_val32, _nBits) _rotl(_val32, _nBits)
 
#else
 
#define ROL32(_val32, _nBits) (((_val32)<<(_nBits))|((_val32)>>(32-(_nBits))))
 
#endif
 
#endif
 
 
#ifdef SHA1_LITTLE_ENDIAN
 
#define SHABLK0(i) (m_block->l[i] = \
 
	(ROL32(m_block->l[i],24) & 0xFF00FF00) | (ROL32(m_block->l[i],8) & 0x00FF00FF))
 
#else
 
#define SHABLK0(i) (m_block->l[i])
 
#endif
 
 
#define SHABLK(i) (m_block->l[i&15] = ROL32(m_block->l[(i+13)&15] ^ m_block->l[(i+8)&15] \
 
	^ m_block->l[(i+2)&15] ^ m_block->l[i&15],1))
 
 
// SHA-1 rounds
 
#define _R0(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK0(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
 
#define _R1(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
 
#define _R2(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0x6ED9EBA1+ROL32(v,5); w=ROL32(w,30); }
 
#define _R3(v,w,x,y,z,i) { z+=(((w|x)&y)|(w&x))+SHABLK(i)+0x8F1BBCDC+ROL32(v,5); w=ROL32(w,30); }
 
#define _R4(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0xCA62C1D6+ROL32(v,5); w=ROL32(w,30); }
 
 
CSHA1::CSHA1()
 
{
 
	m_block = (SHA1_WORKSPACE_BLOCK *)m_workspace;
 
 
	Reset();
 
}
 
 
CSHA1::~CSHA1()
 
{
 
	Reset();
 
}
 
 
void CSHA1::Reset()
 
{
 
	// SHA1 initialization constants
 
	m_state[0] = 0x67452301;
 
	m_state[1] = 0xEFCDAB89;
 
	m_state[2] = 0x98BADCFE;
 
	m_state[3] = 0x10325476;
 
	m_state[4] = 0xC3D2E1F0;
 
 
	m_count[0] = 0;
 
	m_count[1] = 0;
 
}
 
 
void CSHA1::Transform(UINT_32 *state, UINT_8 *buffer)
 
{
 
	// Copy state[] to working vars
 
	UINT_32 a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];
 
 
	memcpy(m_block, buffer, 64);
 
 
	// 4 rounds of 20 operations each. Loop unrolled.
 
	_R0(a,b,c,d,e, 0); _R0(e,a,b,c,d, 1); _R0(d,e,a,b,c, 2); _R0(c,d,e,a,b, 3);
 
	_R0(b,c,d,e,a, 4); _R0(a,b,c,d,e, 5); _R0(e,a,b,c,d, 6); _R0(d,e,a,b,c, 7);
 
	_R0(c,d,e,a,b, 8); _R0(b,c,d,e,a, 9); _R0(a,b,c,d,e,10); _R0(e,a,b,c,d,11);
 
	_R0(d,e,a,b,c,12); _R0(c,d,e,a,b,13); _R0(b,c,d,e,a,14); _R0(a,b,c,d,e,15);
 
	_R1(e,a,b,c,d,16); _R1(d,e,a,b,c,17); _R1(c,d,e,a,b,18); _R1(b,c,d,e,a,19);
 
	_R2(a,b,c,d,e,20); _R2(e,a,b,c,d,21); _R2(d,e,a,b,c,22); _R2(c,d,e,a,b,23);
 
	_R2(b,c,d,e,a,24); _R2(a,b,c,d,e,25); _R2(e,a,b,c,d,26); _R2(d,e,a,b,c,27);
 
	_R2(c,d,e,a,b,28); _R2(b,c,d,e,a,29); _R2(a,b,c,d,e,30); _R2(e,a,b,c,d,31);
 
	_R2(d,e,a,b,c,32); _R2(c,d,e,a,b,33); _R2(b,c,d,e,a,34); _R2(a,b,c,d,e,35);
 
	_R2(e,a,b,c,d,36); _R2(d,e,a,b,c,37); _R2(c,d,e,a,b,38); _R2(b,c,d,e,a,39);
 
	_R3(a,b,c,d,e,40); _R3(e,a,b,c,d,41); _R3(d,e,a,b,c,42); _R3(c,d,e,a,b,43);
 
	_R3(b,c,d,e,a,44); _R3(a,b,c,d,e,45); _R3(e,a,b,c,d,46); _R3(d,e,a,b,c,47);
 
	_R3(c,d,e,a,b,48); _R3(b,c,d,e,a,49); _R3(a,b,c,d,e,50); _R3(e,a,b,c,d,51);
 
	_R3(d,e,a,b,c,52); _R3(c,d,e,a,b,53); _R3(b,c,d,e,a,54); _R3(a,b,c,d,e,55);
 
	_R3(e,a,b,c,d,56); _R3(d,e,a,b,c,57); _R3(c,d,e,a,b,58); _R3(b,c,d,e,a,59);
 
	_R4(a,b,c,d,e,60); _R4(e,a,b,c,d,61); _R4(d,e,a,b,c,62); _R4(c,d,e,a,b,63);
 
	_R4(b,c,d,e,a,64); _R4(a,b,c,d,e,65); _R4(e,a,b,c,d,66); _R4(d,e,a,b,c,67);
 
	_R4(c,d,e,a,b,68); _R4(b,c,d,e,a,69); _R4(a,b,c,d,e,70); _R4(e,a,b,c,d,71);
 
	_R4(d,e,a,b,c,72); _R4(c,d,e,a,b,73); _R4(b,c,d,e,a,74); _R4(a,b,c,d,e,75);
 
	_R4(e,a,b,c,d,76); _R4(d,e,a,b,c,77); _R4(c,d,e,a,b,78); _R4(b,c,d,e,a,79);
 
 
	// Add the working vars back into state
 
	state[0] += a;
 
	state[1] += b;
 
	state[2] += c;
 
	state[3] += d;
 
	state[4] += e;
 
 
	// Wipe variables
 
#ifdef SHA1_WIPE_VARIABLES
 
	a = b = c = d = e = 0;
 
#endif
 
}
 
 
// Use this function to hash in binary data and strings
 
void CSHA1::Update(UINT_8 *data, UINT_32 len)
 
{
 
	UINT_32 i, j;
 
 
	j = (m_count[0] >> 3) & 63;
 
 
	if((m_count[0] += len << 3) < (len << 3)) m_count[1]++;
 
 
	m_count[1] += (len >> 29);
 
 
	if((j + len) > 63)
 
	{
 
		i = 64 - j;
 
		memcpy(&m_buffer[j], data, i);
 
		Transform(m_state, m_buffer);
 
 
		for(; i + 63 < len; i += 64) Transform(m_state, &data[i]);
 
 
		j = 0;
 
	}
 
	else i = 0;
 
 
	memcpy(&m_buffer[j], &data[i], len - i);
 
}
 
 
#ifdef SHA1_UTILITY_FUNCTIONS
 
// Hash in file contents
 
bool CSHA1::HashFile(char *szFileName)
 
{
 
	unsigned long ulFileSize, ulRest, ulBlocks;
 
	unsigned long i;
 
	UINT_8 uData[SHA1_MAX_FILE_BUFFER];
 
	FILE *fIn;
 
 
	if(szFileName == NULL) return false;
 
 
	fIn = fopen(szFileName, "rb");
 
	if(fIn == NULL) return false;
 
 
	fseek(fIn, 0, SEEK_END);
 
	ulFileSize = (unsigned long)ftell(fIn);
 
	fseek(fIn, 0, SEEK_SET);
 
 
	if(ulFileSize != 0)
 
	{
 
		ulBlocks = ulFileSize / SHA1_MAX_FILE_BUFFER;
 
		ulRest = ulFileSize % SHA1_MAX_FILE_BUFFER;
 
	}
 
	else
 
	{
 
		ulBlocks = 0;
 
		ulRest = 0;
 
	}
 
 
	for(i = 0; i < ulBlocks; i++)
 
	{
 
		fread(uData, 1, SHA1_MAX_FILE_BUFFER, fIn);
 
		Update((UINT_8 *)uData, SHA1_MAX_FILE_BUFFER);
 
	}
 
 
	if(ulRest != 0)
 
	{
 
		fread(uData, 1, ulRest, fIn);
 
		Update((UINT_8 *)uData, ulRest);
 
	}
 
 
	fclose(fIn); fIn = NULL;
 
	return true;
 
}
 
#endif
 
 
void CSHA1::Final()
 
{
 
	UINT_32 i;
 
	UINT_8 finalcount[8];
 
 
	for(i = 0; i < 8; i++)
 
		finalcount[i] = (UINT_8)((m_count[((i >= 4) ? 0 : 1)]
 
			>> ((3 - (i & 3)) * 8) ) & 255); // Endian independent
 
 
	Update((UINT_8 *)"\200", 1);
 
 
	while ((m_count[0] & 504) != 448)
 
		Update((UINT_8 *)"\0", 1);
 
 
	Update(finalcount, 8); // Cause a SHA1Transform()
 
 
	for(i = 0; i < 20; i++)
 
	{
 
		m_digest[i] = (UINT_8)((m_state[i >> 2] >> ((3 - (i & 3)) * 8) ) & 255);
 
	}
 
 
	// Wipe variables for security reasons
 
#ifdef SHA1_WIPE_VARIABLES
 
	i = 0;
 
	memset(m_buffer, 0, 64);
 
	memset(m_state, 0, 20);
 
	memset(m_count, 0, 8);
 
	memset(finalcount, 0, 8);
 
	Transform(m_state, m_buffer);
 
#endif
 
}
 
 
#ifdef SHA1_UTILITY_FUNCTIONS
 
// Get the final hash as a pre-formatted string
 
void CSHA1::ReportHash(char *szReport, unsigned char uReportType)
 
{
 
	unsigned char i;
 
	char szTemp[16];
 
 
	if(szReport == NULL) return;
 
 
	if(uReportType == REPORT_HEX)
 
	{
 
		sprintf(szTemp, "%02X", m_digest[0]);
 
		strcat(szReport, szTemp);
 
 
		for(i = 1; i < 20; i++)
 
		{
 
			sprintf(szTemp, " %02X", m_digest[i]);
 
			strcat(szReport, szTemp);
 
		}
 
	}
 
	else if(uReportType == REPORT_DIGIT)
 
	{
 
		sprintf(szTemp, "%u", m_digest[0]);
 
		strcat(szReport, szTemp);
 
 
		for(i = 1; i < 20; i++)
 
		{
 
			sprintf(szTemp, " %u", m_digest[i]);
 
			strcat(szReport, szTemp);
 
		}
 
	}
 
	else strcpy(szReport, "Error: Unknown report type!");
 
}
 
#endif
 
 
// Get the raw message digest
 
void CSHA1::GetHash(UINT_8 *puDest)
 
{
 
	memcpy(puDest, m_digest, 20);
 
}
backends/twitter/libtwitcurl/.svn/text-base/SHA1.h.svn-base
Show inline comments
 
new file 100644
 
/*
 
	100% free public domain implementation of the SHA-1 algorithm
 
	by Dominik Reichl <dominik.reichl@t-online.de>
 
	Web: http://www.dominik-reichl.de/
 
 
	Version 1.6 - 2005-02-07 (thanks to Howard Kapustein for patches)
 
	- You can set the endianness in your files, no need to modify the
 
	  header file of the CSHA1 class any more
 
	- Aligned data support
 
	- Made support/compilation of the utility functions (ReportHash
 
	  and HashFile) optional (useful, if bytes count, for example in
 
	  embedded environments)
 
 
	Version 1.5 - 2005-01-01
 
	- 64-bit compiler compatibility added
 
	- Made variable wiping optional (define SHA1_WIPE_VARIABLES)
 
	- Removed unnecessary variable initializations
 
	- ROL32 improvement for the Microsoft compiler (using _rotl)
 
 
	======== Test Vectors (from FIPS PUB 180-1) ========
 
 
	SHA1("abc") =
 
		A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
 
 
	SHA1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") =
 
		84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
 
 
	SHA1(A million repetitions of "a") =
 
		34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
 
*/
 
 
#ifndef ___SHA1_HDR___
 
#define ___SHA1_HDR___
 
 
#if !defined(SHA1_UTILITY_FUNCTIONS) && !defined(SHA1_NO_UTILITY_FUNCTIONS)
 
#define SHA1_UTILITY_FUNCTIONS
 
#endif
 
 
#include <memory.h> // Needed for memset and memcpy
 
 
#ifdef SHA1_UTILITY_FUNCTIONS
 
#include <stdio.h>  // Needed for file access and sprintf
 
#include <string.h> // Needed for strcat and strcpy
 
#endif
 
 
#ifdef _MSC_VER
 
#include <stdlib.h>
 
#endif
 
 
// You can define the endian mode in your files, without modifying the SHA1
 
// source files. Just #define SHA1_LITTLE_ENDIAN or #define SHA1_BIG_ENDIAN
 
// in your files, before including the SHA1.h header file. If you don't
 
// define anything, the class defaults to little endian.
 
 
#if !defined(SHA1_LITTLE_ENDIAN) && !defined(SHA1_BIG_ENDIAN)
 
#define SHA1_LITTLE_ENDIAN
 
#endif
 
 
// Same here. If you want variable wiping, #define SHA1_WIPE_VARIABLES, if
 
// not, #define SHA1_NO_WIPE_VARIABLES. If you don't define anything, it
 
// defaults to wiping.
 
 
#if !defined(SHA1_WIPE_VARIABLES) && !defined(SHA1_NO_WIPE_VARIABLES)
 
#define SHA1_WIPE_VARIABLES
 
#endif
 
 
/////////////////////////////////////////////////////////////////////////////
 
// Define 8- and 32-bit variables
 
 
#ifndef UINT_32
 
 
#ifdef _MSC_VER
 
 
#define UINT_8  unsigned __int8
 
#define UINT_32 unsigned __int32
 
 
#else
 
 
#define UINT_8 unsigned char
 
 
#if (ULONG_MAX == 0xFFFFFFFF)
 
#define UINT_32 unsigned long
 
#else
 
#define UINT_32 unsigned int
 
#endif
 
 
#endif
 
#endif
 
 
/////////////////////////////////////////////////////////////////////////////
 
// Declare SHA1 workspace
 
 
typedef union
 
{
 
	UINT_8  c[64];
 
	UINT_32 l[16];
 
} SHA1_WORKSPACE_BLOCK;
 
 
class CSHA1
 
{
 
public:
 
#ifdef SHA1_UTILITY_FUNCTIONS
 
	// Two different formats for ReportHash(...)
 
	enum
 
	{
 
		REPORT_HEX = 0,
 
		REPORT_DIGIT = 1
 
	};
 
#endif
 
 
	// Constructor and Destructor
 
	CSHA1();
 
	~CSHA1();
 
 
	UINT_32 m_state[5];
 
	UINT_32 m_count[2];
 
	UINT_32 __reserved1[1];
 
	UINT_8  m_buffer[64];
 
	UINT_8  m_digest[20];
 
	UINT_32 __reserved2[3];
 
 
	void Reset();
 
 
	// Update the hash value
 
	void Update(UINT_8 *data, UINT_32 len);
 
#ifdef SHA1_UTILITY_FUNCTIONS
 
	bool HashFile(char *szFileName);
 
#endif
 
 
	// Finalize hash and report
 
	void Final();
 
 
	// Report functions: as pre-formatted and raw data
 
#ifdef SHA1_UTILITY_FUNCTIONS
 
	void ReportHash(char *szReport, unsigned char uReportType = REPORT_HEX);
 
#endif
 
	void GetHash(UINT_8 *puDest);
 
 
private:
 
	// Private SHA-1 transformation
 
	void Transform(UINT_32 *state, UINT_8 *buffer);
 
 
	// Member variables
 
	UINT_8 m_workspace[64];
 
	SHA1_WORKSPACE_BLOCK *m_block; // SHA1 pointer to the byte array above
 
};
 
 
#endif
backends/twitter/libtwitcurl/.svn/text-base/base64.cpp.svn-base
Show inline comments
 
new file 100644
 
/* 
 
   base64.cpp and base64.h
 
 
   Copyright (C) 2004-2008 René Nyffenegger
 
 
   This source code is provided 'as-is', without any express or implied
 
   warranty. In no event will the author be held liable for any damages
 
   arising from the use of this software.
 
 
   Permission is granted to anyone to use this software for any purpose,
 
   including commercial applications, and to alter it and redistribute it
 
   freely, subject to the following restrictions:
 
 
   1. The origin of this source code must not be misrepresented; you must not
 
      claim that you wrote the original source code. If you use this source code
 
      in a product, an acknowledgment in the product documentation would be
 
      appreciated but is not required.
 
 
   2. Altered source versions must be plainly marked as such, and must not be
 
      misrepresented as being the original source code.
 
 
   3. This notice may not be removed or altered from any source distribution.
 
 
   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
 
 
*/
 
 
#include "base64.h"
 
#include <iostream>
 
 
static const std::string base64_chars = 
 
             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
             "abcdefghijklmnopqrstuvwxyz"
 
             "0123456789+/";
 
 
 
static inline bool is_base64(unsigned char c) {
 
  return (isalnum(c) || (c == '+') || (c == '/'));
 
}
 
 
std::string base64_encode(unsigned char const* bytes_to_encode, unsigned int in_len) {
 
  std::string ret;
 
  int i = 0;
 
  int j = 0;
 
  unsigned char char_array_3[3];
 
  unsigned char char_array_4[4];
 
 
  while (in_len--) {
 
    char_array_3[i++] = *(bytes_to_encode++);
 
    if (i == 3) {
 
      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
 
      char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
 
      char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
 
      char_array_4[3] = char_array_3[2] & 0x3f;
 
 
      for(i = 0; (i <4) ; i++)
 
        ret += base64_chars[char_array_4[i]];
 
      i = 0;
 
    }
 
  }
 
 
  if (i)
 
  {
 
    for(j = i; j < 3; j++)
 
      char_array_3[j] = '\0';
 
 
    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
 
    char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
 
    char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
 
    char_array_4[3] = char_array_3[2] & 0x3f;
 
 
    for (j = 0; (j < i + 1); j++)
 
      ret += base64_chars[char_array_4[j]];
 
 
    while((i++ < 3))
 
      ret += '=';
 
 
  }
 
 
  return ret;
 
 
}
 
 
std::string base64_decode(std::string const& encoded_string) {
 
  int in_len = encoded_string.size();
 
  int i = 0;
 
  int j = 0;
 
  int in_ = 0;
 
  unsigned char char_array_4[4], char_array_3[3];
 
  std::string ret;
 
 
  while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
 
    char_array_4[i++] = encoded_string[in_]; in_++;
 
    if (i ==4) {
 
      for (i = 0; i <4; i++)
 
        char_array_4[i] = base64_chars.find(char_array_4[i]);
 
 
      char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
 
      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
 
      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
 
      for (i = 0; (i < 3); i++)
 
        ret += char_array_3[i];
 
      i = 0;
 
    }
 
  }
 
 
  if (i) {
 
    for (j = i; j <4; j++)
 
      char_array_4[j] = 0;
 
 
    for (j = 0; j <4; j++)
 
      char_array_4[j] = base64_chars.find(char_array_4[j]);
 
 
    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
 
    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
 
    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
 
 
    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
 
  }
 
 
  return ret;
 
}
 
\ No newline at end of file
backends/twitter/libtwitcurl/.svn/text-base/base64.h.svn-base
Show inline comments
 
new file 100644
 
#include <string>
 
 
std::string base64_encode(unsigned char const* , unsigned int len);
 
std::string base64_decode(std::string const& s);
 
\ No newline at end of file
backends/twitter/libtwitcurl/.svn/text-base/oauthlib.cpp.svn-base
Show inline comments
 
new file 100644
 
#include "oauthlib.h"
 
#include "HMAC_SHA1.h"
 
#include "base64.h"
 
#include "urlencode.h"
 
 
/*++
 
* @method: oAuth::oAuth
 
*
 
* @description: constructor
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
*--*/
 
oAuth::oAuth()
 
{
 
}
 
 
/*++
 
* @method: oAuth::~oAuth
 
*
 
* @description: destructor
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
*--*/
 
oAuth::~oAuth()
 
{
 
}
 
 
/*++
 
* @method: oAuth::getConsumerKey
 
*
 
* @description: this method gives consumer key that is being used currently
 
*
 
* @input: none
 
*
 
* @output: consumer key
 
*
 
*--*/
 
void oAuth::getConsumerKey( std::string& consumerKey )
 
{
 
    consumerKey = m_consumerKey;
 
}
 
 
/*++
 
* @method: oAuth::setConsumerKey
 
*
 
* @description: this method saves consumer key that should be used
 
*
 
* @input: consumer key
 
*
 
* @output: none
 
*
 
*--*/
 
void oAuth::setConsumerKey( const std::string& consumerKey )
 
{
 
    m_consumerKey.assign( consumerKey );
 
}
 
 
/*++
 
* @method: oAuth::getConsumerSecret
 
*
 
* @description: this method gives consumer secret that is being used currently
 
*
 
* @input: none
 
*
 
* @output: consumer secret
 
*
 
*--*/
 
void oAuth::getConsumerSecret( std::string& consumerSecret )
 
{
 
    consumerSecret = m_consumerSecret;
 
}
 
 
/*++
 
* @method: oAuth::setConsumerSecret
 
*
 
* @description: this method saves consumer secret that should be used
 
*
 
* @input: consumer secret
 
*
 
* @output: none
 
*
 
*--*/
 
void oAuth::setConsumerSecret( const std::string& consumerSecret )
 
{
 
    m_consumerSecret = consumerSecret;
 
}
 
 
/*++
 
* @method: oAuth::getOAuthTokenKey
 
*
 
* @description: this method gives OAuth token (also called access token) that is being used currently
 
*
 
* @input: none
 
*
 
* @output: OAuth token
 
*
 
*--*/
 
void oAuth::getOAuthTokenKey( std::string& oAuthTokenKey )
 
{
 
    oAuthTokenKey = m_oAuthTokenKey;
 
}
 
 
/*++
 
* @method: oAuth::setOAuthTokenKey
 
*
 
* @description: this method saves OAuth token that should be used
 
*
 
* @input: OAuth token
 
*
 
* @output: none
 
*
 
*--*/
 
void oAuth::setOAuthTokenKey( const std::string& oAuthTokenKey )
 
{
 
    m_oAuthTokenKey = oAuthTokenKey;
 
}
 
 
/*++
 
* @method: oAuth::getOAuthTokenSecret
 
*
 
* @description: this method gives OAuth token secret that is being used currently
 
*
 
* @input: none
 
*
 
* @output: OAuth token secret
 
*
 
*--*/
 
void oAuth::getOAuthTokenSecret( std::string& oAuthTokenSecret )
 
{
 
    oAuthTokenSecret = m_oAuthTokenSecret;
 
}
 
 
/*++
 
* @method: oAuth::setOAuthTokenSecret
 
*
 
* @description: this method saves OAuth token that should be used
 
*
 
* @input: OAuth token secret
 
*
 
* @output: none
 
*
 
*--*/
 
void oAuth::setOAuthTokenSecret( const std::string& oAuthTokenSecret )
 
{
 
    m_oAuthTokenSecret = oAuthTokenSecret;
 
}
 
 
/*++
 
* @method: oAuth::getOAuthScreenName
 
*
 
* @description: this method gives authorized user's screenname
 
*
 
* @input: none
 
*
 
* @output: screen name
 
*
 
*--*/
 
void oAuth::getOAuthScreenName( std::string& oAuthScreenName )
 
{
 
    oAuthScreenName = m_oAuthScreenName;
 
}
 
 
/*++
 
* @method: oAuth::setOAuthScreenName
 
*
 
* @description: this method sets authorized user's screenname
 
*
 
* @input: screen name
 
*
 
* @output: none
 
*
 
*--*/
 
void oAuth::setOAuthScreenName( const std::string& oAuthScreenName )
 
{
 
    m_oAuthScreenName = oAuthScreenName;
 
}
 
 
/*++
 
* @method: oAuth::getOAuthPin
 
*
 
* @description: this method gives OAuth verifier PIN
 
*
 
* @input: none
 
*
 
* @output: OAuth verifier PIN
 
*
 
*--*/
 
void oAuth::getOAuthPin( std::string& oAuthPin )
 
{
 
    oAuthPin = m_oAuthPin;
 
}
 
 
/*++
 
* @method: oAuth::setOAuthPin
 
*
 
* @description: this method sets OAuth verifier PIN
 
*
 
* @input: OAuth verifier PIN
 
*
 
* @output: none
 
*
 
*--*/
 
void oAuth::setOAuthPin( const std::string& oAuthPin )
 
{
 
    m_oAuthPin = oAuthPin;
 
}
 
 
/*++
 
* @method: oAuth::generateNonceTimeStamp
 
*
 
* @description: this method generates nonce and timestamp for OAuth header
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void oAuth::generateNonceTimeStamp()
 
{
 
    char szTime[oAuthLibDefaults::OAUTHLIB_BUFFSIZE];
 
    char szRand[oAuthLibDefaults::OAUTHLIB_BUFFSIZE];
 
    memset( szTime, 0, oAuthLibDefaults::OAUTHLIB_BUFFSIZE );
 
    memset( szRand, 0, oAuthLibDefaults::OAUTHLIB_BUFFSIZE );
 
    srand( time( NULL ) );
 
    sprintf( szRand, "%x", rand()%1000 );
 
    sprintf( szTime, "%ld", time( NULL ) );
 
 
    m_nonce.assign( szTime );
 
    m_nonce.append( szRand );
 
    m_timeStamp.assign( szTime );
 
}
 
 
/*++
 
* @method: oAuth::buildOAuthRawDataKeyValPairs
 
*
 
* @description: this method prepares key-value pairs from the data part of the URL
 
*               or from the URL post fields data, as required by OAuth header
 
*               and signature generation.
 
*
 
* @input: rawData - Raw data either from the URL itself or from post fields.
 
*                   Should already be url encoded.
 
*         urlencodeData - If true, string will be urlencoded before converting
 
*                         to key value pairs.
 
*
 
* @output: rawDataKeyValuePairs - Map in which key-value pairs are populated
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void oAuth::buildOAuthRawDataKeyValPairs( const std::string& rawData,
 
                                          bool urlencodeData,
 
                                          oAuthKeyValuePairs& rawDataKeyValuePairs )
 
{
 
    /* Raw data if it's present. Data should already be urlencoded once */
 
    if( rawData.length() )
 
    {
 
        size_t nSep = std::string::npos;
 
        size_t nPos = std::string::npos;
 
        std::string dataKeyVal;
 
        std::string dataKey;
 
        std::string dataVal;
 
 
        /* This raw data part can contain many key value pairs: key1=value1&key2=value2&key3=value3 */
 
        std::string dataPart = rawData;
 
        while( std::string::npos != ( nSep = dataPart.find_first_of("&") ) )
 
        {
 
            /* Extract first key=value pair */
 
            dataKeyVal = dataPart.substr( 0, nSep );
 
 
            /* Split them */
 
            nPos = dataKeyVal.find_first_of( "=" );
 
            if( std::string::npos != nPos )
 
            {
 
                dataKey = dataKeyVal.substr( 0, nPos );
 
                dataVal = dataKeyVal.substr( nPos + 1 );
 
 
                /* Put this key=value pair in map */
 
                rawDataKeyValuePairs[dataKey] = urlencodeData ? urlencode( dataVal ) : dataVal;
 
            }
 
            dataPart = dataPart.substr( nSep + 1 );
 
        }
 
 
        /* For the last key=value */
 
        dataKeyVal = dataPart.substr( 0, nSep );
 
 
        /* Split them */
 
        nPos = dataKeyVal.find_first_of( "=" );
 
        if( std::string::npos != nPos )
 
        {
 
            dataKey = dataKeyVal.substr( 0, nPos );
 
            dataVal = dataKeyVal.substr( nPos + 1 );
 
 
            /* Put this key=value pair in map */
 
            rawDataKeyValuePairs[dataKey] = urlencodeData ? urlencode( dataVal ) : dataVal;
 
        }
 
    }
 
}
 
 
/*++
 
* @method: oAuth::buildOAuthTokenKeyValuePairs
 
*
 
* @description: this method prepares key-value pairs required for OAuth header
 
*               and signature generation.
 
*
 
* @input: includeOAuthVerifierPin - flag to indicate whether oauth_verifer key-value
 
*                                   pair needs to be included. oauth_verifer is only
 
*                                   used during exchanging request token with access token.
 
*         oauthSignature - base64 and url encoded OAuth signature.
 
*         generateTimestamp - If true, then generate new timestamp for nonce.
 
*
 
* @output: keyValueMap - map in which key-value pairs are populated
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
bool oAuth::buildOAuthTokenKeyValuePairs( const bool includeOAuthVerifierPin,
 
                                          const std::string& oauthSignature,
 
                                          oAuthKeyValuePairs& keyValueMap,
 
                                          const bool generateTimestamp )
 
{
 
    /* Generate nonce and timestamp if required */
 
    if( generateTimestamp )
 
    {
 
        generateNonceTimeStamp();
 
    }
 
 
    /* Consumer key and its value */
 
    keyValueMap[oAuthLibDefaults::OAUTHLIB_CONSUMERKEY_KEY] = m_consumerKey;
 
 
    /* Nonce key and its value */
 
    keyValueMap[oAuthLibDefaults::OAUTHLIB_NONCE_KEY] = m_nonce;
 
 
    /* Signature if supplied */
 
    if( oauthSignature.length() )
 
    {
 
        keyValueMap[oAuthLibDefaults::OAUTHLIB_SIGNATURE_KEY] = oauthSignature;
 
    }
 
 
    /* Signature method, only HMAC-SHA1 as of now */
 
    keyValueMap[oAuthLibDefaults::OAUTHLIB_SIGNATUREMETHOD_KEY] = std::string( "HMAC-SHA1" );
 
 
    /* Timestamp */
 
    keyValueMap[oAuthLibDefaults::OAUTHLIB_TIMESTAMP_KEY] = m_timeStamp;
 
 
    /* Token */
 
    if( m_oAuthTokenKey.length() )
 
    {
 
        keyValueMap[oAuthLibDefaults::OAUTHLIB_TOKEN_KEY] = m_oAuthTokenKey;
 
    }
 
 
    /* Verifier */
 
    if( includeOAuthVerifierPin && m_oAuthPin.length() )
 
    {
 
        keyValueMap[oAuthLibDefaults::OAUTHLIB_VERIFIER_KEY] = m_oAuthPin;
 
    }
 
 
    /* Version */
 
    keyValueMap[oAuthLibDefaults::OAUTHLIB_VERSION_KEY] = std::string( "1.0" );
 
 
    return ( keyValueMap.size() ) ? true : false;
 
}
 
 
/*++
 
* @method: oAuth::getSignature
 
*
 
* @description: this method calculates HMAC-SHA1 signature of OAuth header
 
*
 
* @input: eType - HTTP request type
 
*         rawUrl - raw url of the HTTP request
 
*         rawKeyValuePairs - key-value pairs containing OAuth headers and HTTP data
 
*
 
* @output: oAuthSignature - base64 and url encoded signature
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
bool oAuth::getSignature( const eOAuthHttpRequestType eType,
 
                          const std::string& rawUrl,
 
                          const oAuthKeyValuePairs& rawKeyValuePairs,
 
                          std::string& oAuthSignature )
 
{
 
    std::string rawParams;
 
    std::string paramsSeperator;
 
    std::string sigBase;
 
 
    /* Initially empty signature */
 
    oAuthSignature.assign( "" );
 
 
    /* Build a string using key-value pairs */
 
    paramsSeperator = "&";
 
    getStringFromOAuthKeyValuePairs( rawKeyValuePairs, rawParams, paramsSeperator );
 
 
    /* Start constructing base signature string. Refer http://dev.twitter.com/auth#intro */
 
    switch( eType )
 
    {
 
    case eOAuthHttpGet:
 
        {
 
            sigBase.assign( "GET&" );
 
        }
 
        break;
 
 
    case eOAuthHttpPost:
 
        {
 
            sigBase.assign( "POST&" );
 
        }
 
        break;
 
 
    case eOAuthHttpDelete:
 
        {
 
            sigBase.assign( "DELETE&" );
 
        }
 
        break;
 
 
    default:
 
        {
 
            return false;
 
        }
 
        break;
 
    }
 
    sigBase.append( urlencode( rawUrl ) );
 
    sigBase.append( "&" );
 
    sigBase.append( urlencode( rawParams ) );
 
 
    /* Now, hash the signature base string using HMAC_SHA1 class */
 
    CHMAC_SHA1 objHMACSHA1;
 
    std::string secretSigningKey;
 
    unsigned char strDigest[oAuthLibDefaults::OAUTHLIB_BUFFSIZE_LARGE];
 
 
    memset( strDigest, 0, oAuthLibDefaults::OAUTHLIB_BUFFSIZE_LARGE );
 
 
    /* Signing key is composed of consumer_secret&token_secret */
 
    secretSigningKey.assign( m_consumerSecret );
 
    secretSigningKey.append( "&" );
 
    if( m_oAuthTokenSecret.length() )
 
    {
 
        secretSigningKey.append( m_oAuthTokenSecret );
 
    }
 
  
 
    objHMACSHA1.HMAC_SHA1( (unsigned char*)sigBase.c_str(),
 
                           sigBase.length(),
 
                           (unsigned char*)secretSigningKey.c_str(),
 
                           secretSigningKey.length(),
 
                           strDigest ); 
 
 
    /* Do a base64 encode of signature */
 
    std::string base64Str = base64_encode( strDigest, 20 /* SHA 1 digest is 160 bits */ );
 
 
    /* Do an url encode */
 
    oAuthSignature = urlencode( base64Str );
 
 
    return ( oAuthSignature.length() ) ? true : false;
 
}
 
 
/*++
 
* @method: oAuth::getOAuthHeader
 
*
 
* @description: this method builds OAuth header that should be used in HTTP requests to twitter
 
*
 
* @input: eType - HTTP request type
 
*         rawUrl - raw url of the HTTP request
 
*         rawData - HTTP data (post fields)
 
*         includeOAuthVerifierPin - flag to indicate whether or not oauth_verifier needs to included
 
*                                   in OAuth header
 
*
 
* @output: oAuthHttpHeader - OAuth header
 
*
 
*--*/
 
bool oAuth::getOAuthHeader( const eOAuthHttpRequestType eType,
 
                            const std::string& rawUrl,
 
                            const std::string& rawData,
 
                            std::string& oAuthHttpHeader,
 
                            const bool includeOAuthVerifierPin )
 
{
 
    oAuthKeyValuePairs rawKeyValuePairs;
 
    std::string rawParams;
 
    std::string oauthSignature;
 
    std::string paramsSeperator;
 
    std::string pureUrl( rawUrl );
 
 
    /* Clear header string initially */
 
    oAuthHttpHeader.assign( "" );
 
    rawKeyValuePairs.clear();
 
 
    /* If URL itself contains ?key=value, then extract and put them in map */
 
    size_t nPos = rawUrl.find_first_of( "?" );
 
    if( std::string::npos != nPos )
 
    {
 
        /* Get only URL */
 
        pureUrl = rawUrl.substr( 0, nPos );
 
 
        /* Get only key=value data part */
 
        std::string dataPart = rawUrl.substr( nPos + 1 );
 
 
        /* Split the data in URL as key=value pairs */
 
        buildOAuthRawDataKeyValPairs( dataPart, true, rawKeyValuePairs );
 
    }
 
 
    /* Split the raw data if it's present, as key=value pairs. Data should already be urlencoded once */
 
    buildOAuthRawDataKeyValPairs( rawData, false, rawKeyValuePairs );
 
 
    /* Build key-value pairs needed for OAuth request token, without signature */
 
    buildOAuthTokenKeyValuePairs( includeOAuthVerifierPin, std::string( "" ), rawKeyValuePairs, true );
 
 
    /* Get url encoded base64 signature using request type, url and parameters */
 
    getSignature( eType, pureUrl, rawKeyValuePairs, oauthSignature );
 
 
    /* Clear map so that the parameters themselves are not sent along with the OAuth values */
 
    rawKeyValuePairs.clear();
 
 
    /* Now, again build key-value pairs with signature this time */
 
    buildOAuthTokenKeyValuePairs( includeOAuthVerifierPin, oauthSignature, rawKeyValuePairs, false );
 
 
    /* Get OAuth header in string format */
 
    paramsSeperator = ",";
 
    getStringFromOAuthKeyValuePairs( rawKeyValuePairs, rawParams, paramsSeperator );
 
 
    /* Build authorization header */
 
    oAuthHttpHeader.assign( oAuthLibDefaults::OAUTHLIB_AUTHHEADER_STRING );
 
    oAuthHttpHeader.append( rawParams );
 
 
    return ( oAuthHttpHeader.length() ) ? true : false;
 
}
 
 
/*++
 
* @method: oAuth::getStringFromOAuthKeyValuePairs
 
*
 
* @description: this method builds a sorted string from key-value pairs
 
*
 
* @input: rawParamMap - key-value pairs map
 
*         paramsSeperator - sepearator, either & or ,
 
*
 
* @output: rawParams - sorted string of OAuth parameters
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
bool oAuth::getStringFromOAuthKeyValuePairs( const oAuthKeyValuePairs& rawParamMap,
 
                                             std::string& rawParams,
 
                                             const std::string& paramsSeperator )
 
{
 
    rawParams.assign( "" );
 
    if( rawParamMap.size() )
 
    {
 
        oAuthKeyValueList keyValueList;
 
        std::string dummyStr;
 
 
        /* Push key-value pairs to a list of strings */
 
        keyValueList.clear();
 
        oAuthKeyValuePairs::const_iterator itMap = rawParamMap.begin();
 
        for( ; itMap != rawParamMap.end(); itMap++ )
 
        {
 
            dummyStr.assign( itMap->first );
 
            dummyStr.append( "=" );
 
            if( paramsSeperator == "," )
 
            {
 
                dummyStr.append( "\"" );
 
            }
 
            dummyStr.append( itMap->second );
 
            if( paramsSeperator == "," )
 
            {
 
                dummyStr.append( "\"" );
 
            }
 
            keyValueList.push_back( dummyStr );
 
        }
 
 
        /* Sort key-value pairs based on key name */
 
        keyValueList.sort();
 
 
        /* Now, form a string */
 
        dummyStr.assign( "" );
 
        oAuthKeyValueList::iterator itKeyValue = keyValueList.begin();
 
        for( ; itKeyValue != keyValueList.end(); itKeyValue++ )
 
        {
 
            if( dummyStr.length() )
 
            {
 
                dummyStr.append( paramsSeperator );
 
            }
 
            dummyStr.append( itKeyValue->c_str() );
 
        }
 
        rawParams.assign( dummyStr );
 
    }
 
    return ( rawParams.length() ) ? true : false;
 
}
 
 
/*++
 
* @method: oAuth::extractOAuthTokenKeySecret
 
*
 
* @description: this method extracts oauth token key and secret from
 
*               twitter's HTTP response
 
*
 
* @input: requestTokenResponse - response from twitter
 
*
 
* @output: none
 
*
 
*--*/
 
bool oAuth::extractOAuthTokenKeySecret( const std::string& requestTokenResponse )
 
{
 
    if( requestTokenResponse.length() )
 
    {
 
        size_t nPos = std::string::npos;
 
        std::string strDummy;
 
 
        /* Get oauth_token key */
 
        nPos = requestTokenResponse.find( oAuthLibDefaults::OAUTHLIB_TOKEN_KEY );
 
        if( std::string::npos != nPos )
 
        {
 
            nPos = nPos + oAuthLibDefaults::OAUTHLIB_TOKEN_KEY.length() + strlen( "=" );
 
            strDummy = requestTokenResponse.substr( nPos );
 
            nPos = strDummy.find( "&" );
 
            if( std::string::npos != nPos )
 
            {
 
                m_oAuthTokenKey = strDummy.substr( 0, nPos );
 
            }
 
        }
 
 
        /* Get oauth_token_secret */
 
        nPos = requestTokenResponse.find( oAuthLibDefaults::OAUTHLIB_TOKENSECRET_KEY );
 
        if( std::string::npos != nPos )
 
        {
 
            nPos = nPos + oAuthLibDefaults::OAUTHLIB_TOKENSECRET_KEY.length() + strlen( "=" );
 
            strDummy = requestTokenResponse.substr( nPos );
 
            nPos = strDummy.find( "&" );
 
            if( std::string::npos != nPos )
 
            {
 
                m_oAuthTokenSecret = strDummy.substr( 0, nPos );
 
            }
 
        }
 
 
        /* Get screen_name */
 
        nPos = requestTokenResponse.find( oAuthLibDefaults::OAUTHLIB_SCREENNAME_KEY );
 
        if( std::string::npos != nPos )
 
        {
 
            nPos = nPos + oAuthLibDefaults::OAUTHLIB_SCREENNAME_KEY.length() + strlen( "=" );
 
            strDummy = requestTokenResponse.substr( nPos );
 
            m_oAuthScreenName = strDummy;
 
        }
 
    }
 
    return true;
 
}
backends/twitter/libtwitcurl/.svn/text-base/oauthlib.h.svn-base
Show inline comments
 
new file 100644
 
#ifndef __OAUTHLIB_H__
 
#define __OAUTHLIB_H__
 
 
#include "time.h"
 
#include <cstdlib>
 
#include <sstream>
 
#include <iostream>
 
#include <fstream>
 
#include <string>
 
#include <list>
 
#include <map>
 
 
namespace oAuthLibDefaults
 
{
 
    /* Constants */
 
    const int OAUTHLIB_BUFFSIZE = 1024;
 
    const int OAUTHLIB_BUFFSIZE_LARGE = 1024;
 
    const std::string OAUTHLIB_CONSUMERKEY_KEY = "oauth_consumer_key";
 
    const std::string OAUTHLIB_CALLBACK_KEY = "oauth_callback";
 
    const std::string OAUTHLIB_VERSION_KEY = "oauth_version";
 
    const std::string OAUTHLIB_SIGNATUREMETHOD_KEY = "oauth_signature_method";
 
    const std::string OAUTHLIB_SIGNATURE_KEY = "oauth_signature";
 
    const std::string OAUTHLIB_TIMESTAMP_KEY = "oauth_timestamp";
 
    const std::string OAUTHLIB_NONCE_KEY = "oauth_nonce";
 
    const std::string OAUTHLIB_TOKEN_KEY = "oauth_token";
 
    const std::string OAUTHLIB_TOKENSECRET_KEY = "oauth_token_secret";
 
    const std::string OAUTHLIB_VERIFIER_KEY = "oauth_verifier";
 
    const std::string OAUTHLIB_SCREENNAME_KEY = "screen_name";
 
    const std::string OAUTHLIB_AUTHENTICITY_TOKEN_KEY = "authenticity_token";
 
    const std::string OAUTHLIB_SESSIONUSERNAME_KEY = "session[username_or_email]";
 
    const std::string OAUTHLIB_SESSIONPASSWORD_KEY = "session[password]";
 
    const std::string OAUTHLIB_AUTHENTICITY_TOKEN_TWITTER_RESP_KEY = "authenticity_token\" type=\"hidden\" value=\"";
 
    const std::string OAUTHLIB_TOKEN_TWITTER_RESP_KEY = "oauth_token\" type=\"hidden\" value=\"";
 
    const std::string OAUTHLIB_PIN_TWITTER_RESP_KEY = "code-desc\"><code>";
 
    const std::string OAUTHLIB_TOKEN_END_TAG_TWITTER_RESP = "\" />";
 
    const std::string OAUTHLIB_PIN_END_TAG_TWITTER_RESP = "</code>";
 
 
    const std::string OAUTHLIB_AUTHHEADER_STRING = "Authorization: OAuth ";
 
};
 
 
namespace oAuthTwitterApiUrls
 
{
 
    /* Twitter OAuth API URLs */
 
    const std::string OAUTHLIB_TWITTER_REQUEST_TOKEN_URL = "twitter.com/oauth/request_token";
 
    const std::string OAUTHLIB_TWITTER_AUTHORIZE_URL = "twitter.com/oauth/authorize?oauth_token=";
 
    const std::string OAUTHLIB_TWITTER_ACCESS_TOKEN_URL = "twitter.com/oauth/access_token";
 
};
 
 
typedef enum _eOAuthHttpRequestType
 
{
 
    eOAuthHttpInvalid = 0,
 
    eOAuthHttpGet,
 
    eOAuthHttpPost,
 
    eOAuthHttpDelete
 
} eOAuthHttpRequestType;
 
 
typedef std::list<std::string> oAuthKeyValueList;
 
typedef std::map<std::string, std::string> oAuthKeyValuePairs;
 
 
class oAuth
 
{
 
public:
 
    oAuth();
 
    ~oAuth();
 
 
    /* OAuth public methods used by twitCurl */
 
    void getConsumerKey( std::string& consumerKey /* out */ );
 
    void setConsumerKey( const std::string& consumerKey /* in */ );
 
 
    void getConsumerSecret( std::string& consumerSecret /* out */ );
 
    void setConsumerSecret( const std::string& consumerSecret /* in */ );
 
 
    void getOAuthTokenKey( std::string& oAuthTokenKey /* out */ );
 
    void setOAuthTokenKey( const std::string& oAuthTokenKey /* in */ );
 
 
    void getOAuthTokenSecret( std::string& oAuthTokenSecret /* out */ );
 
    void setOAuthTokenSecret( const std::string& oAuthTokenSecret /* in */ );
 
 
    void getOAuthScreenName( std::string& oAuthScreenName /* out */ );
 
    void setOAuthScreenName( const std::string& oAuthScreenName /* in */ );
 
 
    void getOAuthPin( std::string& oAuthPin /* out */ );
 
    void setOAuthPin( const std::string& oAuthPin /* in */ );
 
 
    bool getOAuthHeader( const eOAuthHttpRequestType eType, /* in */
 
                         const std::string& rawUrl, /* in */
 
                         const std::string& rawData, /* in */
 
                         std::string& oAuthHttpHeader, /* out */
 
                         const bool includeOAuthVerifierPin = false /* in */ );
 
 
    bool extractOAuthTokenKeySecret( const std::string& requestTokenResponse /* in */ );
 
 
private:
 
 
    /* OAuth data */
 
    std::string m_consumerKey;
 
    std::string m_consumerSecret;
 
    std::string m_oAuthTokenKey;
 
    std::string m_oAuthTokenSecret;
 
    std::string m_oAuthPin;
 
    std::string m_nonce;
 
    std::string m_timeStamp;
 
    std::string m_oAuthScreenName;
 
 
    /* OAuth twitter related utility methods */
 
    void buildOAuthRawDataKeyValPairs( const std::string& rawData, /* in */
 
                                       bool urlencodeData, /* in */
 
                                       oAuthKeyValuePairs& rawDataKeyValuePairs /* out */ );
 
 
    bool buildOAuthTokenKeyValuePairs( const bool includeOAuthVerifierPin, /* in */
 
                                       const std::string& oauthSignature, /* in */
 
                                       oAuthKeyValuePairs& keyValueMap /* out */,
 
                                       const bool generateTimestamp /* in */ );
 
 
    bool getStringFromOAuthKeyValuePairs( const oAuthKeyValuePairs& rawParamMap, /* in */
 
                                          std::string& rawParams, /* out */
 
                                          const std::string& paramsSeperator /* in */ );
 
 
    bool getSignature( const eOAuthHttpRequestType eType, /* in */
 
                       const std::string& rawUrl, /* in */
 
                       const oAuthKeyValuePairs& rawKeyValuePairs, /* in */
 
                       std::string& oAuthSignature /* out */ );
 
 
    void generateNonceTimeStamp();
 
};
 
 
#endif // __OAUTHLIB_H__
 
\ No newline at end of file
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.cpp.svn-base
Show inline comments
 
new file 100644
 
#include <memory.h>
 
#include "twitcurl.h"
 
#include "urlencode.h"
 
 
/*++
 
* @method: twitCurl::twitCurl
 
*
 
* @description: constructor
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
*--*/
 
twitCurl::twitCurl():
 
m_curlHandle( NULL ),
 
m_curlProxyParamsSet( false ),
 
m_curlLoginParamsSet( false ),
 
m_curlCallbackParamsSet( false ),
 
m_eApiFormatType( twitCurlTypes::eTwitCurlApiFormatXml ),
 
m_eProtocolType( twitCurlTypes::eTwitCurlProtocolHttp )
 
{
 
    /* Clear callback buffers */
 
    clearCurlCallbackBuffers();
 
 
    /* Initialize cURL */
 
    m_curlHandle = curl_easy_init();
 
    if( NULL == m_curlHandle )
 
    {
 
        std::string dummyStr;
 
        getLastCurlError( dummyStr );
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::~twitCurl
 
*
 
* @description: destructor
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
*--*/
 
twitCurl::~twitCurl()
 
{
 
    /* Cleanup cURL */
 
    if( m_curlHandle )
 
    {
 
        curl_easy_cleanup( m_curlHandle );
 
        m_curlHandle = NULL;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::setTwitterApiType
 
*
 
* @description: method to set API type
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setTwitterApiType( twitCurlTypes::eTwitCurlApiFormatType eType )
 
{
 
    m_eApiFormatType = ( eType < twitCurlTypes::eTwitCurlApiFormatMax ) ?
 
                        eType : twitCurlTypes::eTwitCurlApiFormatXml;
 
}
 
 
/*++
 
* @method: twitCurl::setTwitterProcotolType
 
*
 
* @description: method to set protocol
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setTwitterProcotolType( twitCurlTypes::eTwitCurlProtocolType eType )
 
{
 
    m_eProtocolType = ( eType < twitCurlTypes::eTwitCurlProtocolMax ) ?
 
                        eType : twitCurlTypes::eTwitCurlProtocolHttp;
 
}
 
 
/*++
 
* @method: twitCurl::isCurlInit
 
*
 
* @description: method to check if cURL is initialized properly
 
*
 
* @input: none
 
*
 
* @output: true if cURL is intialized, otherwise false
 
*
 
*--*/
 
bool twitCurl::isCurlInit()
 
{
 
    return ( NULL != m_curlHandle ) ? true : false;
 
}
 
 
/*++
 
* @method: twitCurl::getTwitterUsername
 
*
 
* @description: method to get stored Twitter username
 
*
 
* @input: none
 
*
 
* @output: twitter username
 
*
 
*--*/
 
std::string& twitCurl::getTwitterUsername()
 
{
 
    return m_twitterUsername;
 
}
 
 
/*++
 
* @method: twitCurl::getTwitterPassword
 
*
 
* @description: method to get stored Twitter password
 
*
 
* @input: none
 
*
 
* @output: twitter password
 
*
 
*--*/
 
std::string& twitCurl::getTwitterPassword()
 
{
 
    return m_twitterPassword;
 
}
 
 
/*++
 
* @method: twitCurl::setTwitterUsername
 
*
 
* @description: method to set username
 
*
 
* @input: userName
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setTwitterUsername( std::string& userName )
 
{
 
    if( userName.length() )
 
    {
 
        m_twitterUsername = userName;
 
        m_curlLoginParamsSet = false;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::setTwitterPassword
 
*
 
* @description: method to set password
 
*
 
* @input: passWord
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setTwitterPassword( std::string& passWord )
 
{
 
    if( passWord.length() )
 
    {
 
        m_twitterPassword = passWord;
 
        m_curlLoginParamsSet = false;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::getProxyServerIp
 
*
 
* @description: method to get proxy server IP address
 
*
 
* @input: none
 
*
 
* @output: proxy server IP address
 
*
 
*--*/
 
std::string& twitCurl::getProxyServerIp()
 
{
 
    return m_proxyServerIp;
 
}
 
 
/*++
 
* @method: twitCurl::getProxyServerPort
 
*
 
* @description: method to get proxy server port
 
*
 
* @input: none
 
*
 
* @output: proxy server port
 
*
 
*--*/
 
std::string& twitCurl::getProxyServerPort()
 
{
 
    return m_proxyServerPort;
 
}
 
 
/*++
 
* @method: twitCurl::getProxyUserName
 
*
 
* @description: method to get proxy user name
 
*
 
* @input: none
 
*
 
* @output: proxy server user name
 
*
 
*--*/
 
std::string& twitCurl::getProxyUserName()
 
{
 
    return m_proxyUserName;
 
}
 
 
/*++
 
* @method: twitCurl::getProxyPassword
 
*
 
* @description: method to get proxy server password
 
*
 
* @input: none
 
*
 
* @output: proxy server password
 
*
 
*--*/
 
std::string& twitCurl::getProxyPassword()
 
{
 
    return m_proxyPassword;
 
}
 
 
/*++
 
* @method: twitCurl::setProxyServerIp
 
*
 
* @description: method to set proxy server IP address
 
*
 
* @input: proxyServerIp
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setProxyServerIp( std::string& proxyServerIp )
 
{
 
    if( proxyServerIp.length() )
 
    {
 
        m_proxyServerIp = proxyServerIp;
 
        /*
 
         * Reset the flag so that next cURL http request
 
         * would set proxy details again into cURL.
 
         */
 
        m_curlProxyParamsSet = false;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::setProxyServerPort
 
*
 
* @description: method to set proxy server port
 
*
 
* @input: proxyServerPort
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setProxyServerPort( std::string& proxyServerPort )
 
{
 
    if( proxyServerPort.length() )
 
    {
 
        m_proxyServerPort = proxyServerPort;
 
        /*
 
         * Reset the flag so that next cURL http request
 
         * would set proxy details again into cURL.
 
         */
 
        m_curlProxyParamsSet = false;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::setProxyUserName
 
*
 
* @description: method to set proxy server username
 
*
 
* @input: proxyUserName
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setProxyUserName( std::string& proxyUserName )
 
{
 
    if( proxyUserName.length() )
 
    {
 
        m_proxyUserName = proxyUserName;
 
        /*
 
         * Reset the flag so that next cURL http request
 
         * would set proxy details again into cURL.
 
         */
 
        m_curlProxyParamsSet = false;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::setProxyPassword
 
*
 
* @description: method to set proxy server password
 
*
 
* @input: proxyPassword
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::setProxyPassword( std::string& proxyPassword )
 
{
 
    if( proxyPassword.length() )
 
    {
 
        m_proxyPassword = proxyPassword;
 
        /*
 
         * Reset the flag so that next cURL http request
 
         * would set proxy details again into cURL.
 
         */
 
        m_curlProxyParamsSet = false;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::search
 
*
 
* @description: method to return tweets that match a specified query.
 
*
 
* @input: searchQuery - search query in string format
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
* @note: Only ATOM and JSON format supported.
 
*
 
*--*/
 
bool twitCurl::search( std::string& searchQuery )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_SEARCH_URL +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[twitCurlTypes::eTwitCurlApiFormatJson] +
 
                           twitCurlDefaults::TWITCURL_URL_SEP_QUES + twitCurlDefaults::TWITCURL_SEARCHQUERYSTRING +
 
                           searchQuery;
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::statusUpdate
 
*
 
* @description: method to update new status message in twitter profile
 
*
 
* @input: newStatus
 
*
 
* @output: true if POST is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::statusUpdate( std::string& newStatus )
 
{
 
    bool retVal = false;
 
    if( newStatus.length() )
 
    {
 
        /* Prepare new status message */
 
        std::string newStatusMsg = twitCurlDefaults::TWITCURL_STATUSSTRING + urlencode( newStatus );
 
 
        /* Perform POST */
 
        retVal = performPost( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                              twitterDefaults::TWITCURL_STATUSUPDATE_URL +
 
                              twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                              newStatusMsg );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::statusShowById
 
*
 
* @description: method to get a status message by its id
 
*
 
* @input: statusId - a number in std::string format
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::statusShowById( std::string& statusId )
 
{
 
    bool retVal = false;
 
    if( statusId.length() )
 
    {
 
        /* Prepare URL */
 
        std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                               twitterDefaults::TWITCURL_STATUSSHOW_URL + statusId +
 
                               twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
        /* Perform GET */
 
        retVal = performGet( buildUrl );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::statusDestroyById
 
*
 
* @description: method to delete a status message by its id
 
*
 
* @input: statusId - a number in std::string format
 
*
 
* @output: true if DELETE is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::statusDestroyById( std::string& statusId )
 
{
 
    bool retVal = false;
 
    if( statusId.length() )
 
    {
 
        /* Prepare URL */
 
        std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                               twitterDefaults::TWITCURL_STATUDESTROY_URL + statusId +
 
                               twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
        /* Perform DELETE */
 
        retVal = performDelete( buildUrl );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::timelinePublicGet
 
*
 
* @description: method to get public timeline
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::timelinePublicGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_PUBLIC_TIMELINE_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::featuredUsersGet
 
*
 
* @description: method to get featured users
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::featuredUsersGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_FEATURED_USERS_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::timelineFriendsGet
 
*
 
* @description: method to get friends timeline
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::timelineFriendsGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_FRIENDS_TIMELINE_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::mentionsGet
 
*
 
* @description: method to get mentions
 
*
 
* @input: sinceId - String specifying since id parameter
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::mentionsGet( std::string sinceId )
 
{
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_MENTIONS_URL +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
    if( sinceId.length() )
 
    {
 
        buildUrl += twitCurlDefaults::TWITCURL_URL_SEP_QUES + twitCurlDefaults::TWITCURL_SINCEID + sinceId;
 
    }
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::timelineUserGet
 
*
 
* @description: method to get mentions
 
*
 
* @input: trimUser - Trim user name if true
 
*         tweetCount - Number of tweets to get. Max 200.
 
*         userInfo - screen name or user id in string format,
 
*         isUserId - true if userInfo contains an id
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::timelineUserGet( bool trimUser, bool includeRetweets, unsigned int tweetCount, std::string userInfo, bool isUserId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl;
 
 
    utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                        twitterDefaults::TWITCURL_USERTIMELINE_URL +
 
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                        userInfo, isUserId );
 
 
    if( !userInfo.length() )
 
    {
 
        buildUrl += twitCurlDefaults::TWITCURL_URL_SEP_QUES;
 
    }
 
 
    if( tweetCount )
 
    {
 
        if( tweetCount > twitCurlDefaults::MAX_TIMELINE_TWEET_COUNT )
 
        {
 
            tweetCount = twitCurlDefaults::MAX_TIMELINE_TWEET_COUNT;
 
        }
 
        std::stringstream tmpStrm;
 
        tmpStrm << twitCurlDefaults::TWITCURL_URL_SEP_AMP + twitCurlDefaults::TWITCURL_COUNT << tweetCount;
 
        buildUrl += tmpStrm.str();
 
        tmpStrm.str().clear();
 
    }
 
 
    if( includeRetweets )
 
    {
 
        buildUrl += twitCurlDefaults::TWITCURL_URL_SEP_AMP + twitCurlDefaults::TWITCURL_INCRETWEETS;
 
    }
 
 
    if( trimUser )
 
    {
 
        buildUrl += twitCurlDefaults::TWITCURL_URL_SEP_AMP + twitCurlDefaults::TWITCURL_TRIMUSER;
 
    }
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::userGet
 
*
 
* @description: method to get a user's profile
 
*
 
* @input: userInfo - screen name or user id in string format,
 
*         isUserId - true if userInfo contains an id
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::userGet( std::string& userInfo, bool isUserId )
 
{
 
    bool retVal = false;
 
    if( userInfo.length() )
 
    {
 
        /* Set URL */
 
        std::string buildUrl;
 
        utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                            twitterDefaults::TWITCURL_SHOWUSERS_URL +
 
                            twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                            userInfo, isUserId );
 
 
        /* Perform GET */
 
        retVal = performGet( buildUrl );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::friendsGet
 
*
 
* @description: method to get a user's friends
 
*
 
* @input: userInfo - screen name or user id in string format,
 
*         isUserId - true if userInfo contains an id
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::friendsGet( std::string userInfo, bool isUserId )
 
{
 
    /* Set URL */
 
    std::string buildUrl;
 
    utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                        twitterDefaults::TWITCURL_SHOWFRIENDS_URL +
 
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                        userInfo, isUserId );
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::followersGet
 
*
 
* @description: method to get a user's followers
 
*
 
* @input: userInfo - screen name or user id in string format,
 
*         isUserId - true if userInfo contains an id
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::followersGet( std::string userInfo, bool isUserId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl;
 
    utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                        twitterDefaults::TWITCURL_SHOWFOLLOWERS_URL +
 
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                        userInfo, isUserId );
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::directMessageGet
 
*
 
* @description: method to get direct messages
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::directMessageGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_DIRECTMESSAGES_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::directMessageSend
 
*
 
* @description: method to send direct message to a user
 
*
 
* @input: userInfo - screen name or user id of a user to whom message needs to be sent,
 
*         dMsg - message
 
*         isUserId - true if userInfo contains target user's id
 
*
 
* @output: true if POST is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::directMessageSend( std::string& userInfo, std::string& dMsg, bool isUserId )
 
{
 
    bool retVal = false;
 
    if( userInfo.length() && dMsg.length() )
 
    {
 
        /* Prepare new direct message */
 
        std::string newDm = twitCurlDefaults::TWITCURL_TEXTSTRING + urlencode( dMsg );
 
 
        /* Prepare URL */
 
        std::string buildUrl;
 
        utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                            twitterDefaults::TWITCURL_DIRECTMESSAGENEW_URL +
 
                            twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                            userInfo, isUserId );
 
 
        /* Perform POST */
 
        retVal = performPost( buildUrl, newDm );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::directMessageGetSent
 
*
 
* @description: method to get sent direct messages
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::directMessageGetSent()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_DIRECTMESSAGESSENT_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::directMessageDestroyById
 
*
 
* @description: method to delete direct messages by its id
 
*
 
* @input: dMsgId - id of direct message in string format
 
*
 
* @output: true if DELETE is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::directMessageDestroyById( std::string& dMsgId )
 
{
 
    bool retVal = false;
 
    if( dMsgId.length() )
 
    {
 
        /* Prepare URL */
 
        std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                               twitterDefaults::TWITCURL_DIRECTMESSAGEDESTROY_URL + dMsgId +
 
                               twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
        /* Perform DELETE */
 
        retVal = performDelete( buildUrl );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::friendshipCreate
 
*
 
* @description: method to add a twitter user as friend (follow a user)
 
*
 
* @input: userInfo - user id or screen name of a user
 
*         isUserId - true if userInfo contains a user id instead of screen name
 
*
 
* @output: true if POST is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::friendshipCreate( std::string& userInfo, bool isUserId )
 
{
 
    bool retVal = false;
 
    if( userInfo.length() )
 
    {
 
        /* Prepare URL */
 
        std::string buildUrl;
 
        utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                            twitterDefaults::TWITCURL_FRIENDSHIPSCREATE_URL +
 
                            twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                            userInfo, isUserId );
 
 
        /* Send some dummy data in POST */
 
        std::string dummyData = twitCurlDefaults::TWITCURL_TEXTSTRING +
 
                                urlencode( std::string( "dummy" ) );
 
 
        /* Perform POST */
 
        retVal = performPost( buildUrl, dummyData );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::friendshipDestroy
 
*
 
* @description: method to delete a twitter user from friend list (unfollow a user)
 
*
 
* @input: userInfo - user id or screen name of a user
 
*         isUserId - true if userInfo contains a user id instead of screen name
 
*
 
* @output: true if DELETE is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::friendshipDestroy( std::string& userInfo, bool isUserId )
 
{
 
    bool retVal = false;
 
    if( userInfo.length() )
 
    {
 
        /* Prepare URL */
 
        std::string buildUrl;
 
        utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                            twitterDefaults::TWITCURL_FRIENDSHIPSDESTROY_URL +
 
                            twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                            userInfo, isUserId );
 
 
        /* Perform DELETE */
 
        retVal = performDelete( buildUrl );
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::friendshipShow
 
*
 
* @description: method to show all friends
 
*
 
* @input: userInfo - user id or screen name of a user of whom friends need to be shown
 
*         isUserId - true if userInfo contains a user id instead of screen name
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::friendshipShow( std::string& userInfo, bool isUserId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_FRIENDSHIPSSHOW_URL +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
    if( userInfo.length() )
 
    {
 
        /* Append username to the URL */
 
        buildUrl += twitCurlDefaults::TWITCURL_URL_SEP_QUES;
 
        if( isUserId )
 
        {
 
            buildUrl += twitCurlDefaults::TWITCURL_TARGETUSERID;
 
        }
 
        else
 
        {
 
            buildUrl += twitCurlDefaults::TWITCURL_TARGETSCREENNAME;
 
        }
 
        buildUrl += userInfo;
 
    }
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::friendsIdsGet
 
*
 
* @description: method to show IDs of all friends of a twitter user
 
*
 
* @input: userInfo - user id or screen name of a user
 
*         isUserId - true if userInfo contains a user id instead of screen name
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::friendsIdsGet( std::string& userInfo, bool isUserId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl;
 
    utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                        twitterDefaults::TWITCURL_FRIENDSIDS_URL +
 
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                        userInfo, isUserId );
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::followersIdsGet
 
*
 
* @description: method to show IDs of all followers of a twitter user
 
*
 
* @input: userInfo - user id or screen name of a user
 
*         isUserId - true if userInfo contains a user id instead of screen name
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::followersIdsGet( std::string& userInfo, bool isUserId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl;
 
    utilMakeUrlForUser( buildUrl, twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                        twitterDefaults::TWITCURL_FOLLOWERSIDS_URL +
 
                        twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType],
 
                        userInfo, isUserId );
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::accountRateLimitGet
 
*
 
* @description: method to get API rate limit of current user
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::accountRateLimitGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_ACCOUNTRATELIMIT_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::accountVerifyCredGet
 
*
 
* @description: method to get information on user identified by given credentials
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::accountVerifyCredGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_ACCOUNTVERIFYCRED_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::favoriteGet
 
*
 
* @description: method to get favorite users' statuses
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::favoriteGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_FAVORITESGET_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::favoriteCreate
 
*
 
* @description: method to favorite a status message
 
*
 
* @input: statusId - id in string format of the status to be favorited
 
*
 
* @output: true if POST is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::favoriteCreate( std::string& statusId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_FAVORITECREATE_URL + statusId +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
    /* Send some dummy data in POST */
 
    std::string dummyData = twitCurlDefaults::TWITCURL_TEXTSTRING +
 
                            urlencode( std::string( "dummy" ) );
 
 
    /* Perform POST */
 
    return performPost( buildUrl, dummyData );
 
}
 
 
/*++
 
* @method: twitCurl::favoriteDestroy
 
*
 
* @description: method to delete a favorited the status
 
*
 
* @input: statusId - id in string format of the favorite status to be deleted
 
*
 
* @output: true if DELETE is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::favoriteDestroy( std::string& statusId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_FAVORITEDESTROY_URL + statusId +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
    /* Perform DELETE */
 
    return performDelete( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::blockCreate
 
*
 
* @description: method to block a user
 
*
 
* @input: userInfo - user id or screen name
 
*
 
* @output: true if POST is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::blockCreate( std::string& userInfo )
 
{
 
        /* Prepare URL */
 
        std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                               twitterDefaults::TWITCURL_BLOCKSCREATE_URL + userInfo +
 
                               twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
        /* Send some dummy data in POST */
 
        std::string dummyData = twitCurlDefaults::TWITCURL_TEXTSTRING +
 
                                urlencode( std::string( "dummy" ) );
 
 
        /* Perform POST */
 
        return performPost( buildUrl, dummyData );
 
}
 
 
/*++
 
* @method: twitCurl::blockDestroy
 
*
 
* @description: method to unblock a user
 
*
 
* @input: userInfo - user id or screen name
 
*
 
* @output: true if DELETE is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::blockDestroy( std::string& userInfo )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_BLOCKSDESTROY_URL + userInfo +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
    /* Perform DELETE */
 
    return performDelete( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::savedSearchGet
 
*
 
* @description: gets authenticated user's saved search queries.
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::savedSearchGet( )
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_SAVEDSEARCHGET_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::savedSearchShow
 
*
 
* @description: method to retrieve the data for a saved search owned by the authenticating user
 
*               specified by the given id.
 
*
 
* @input: searchId - id in string format of the search to be displayed
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::savedSearchShow( std::string& searchId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_SAVEDSEARCHSHOW_URL + searchId +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
    /* Perform GET */
 
    return performGet( buildUrl );
 
}
 
 
/*++
 
* @method: twitCurl::savedSearchCreate
 
*
 
* @description: creates a saved search for the authenticated user
 
*
 
* @input: query - the query of the search the user would like to save
 
*
 
* @output: true if POST is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::savedSearchCreate( std::string& query )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_SAVEDSEARCHCREATE_URL +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
    /* Send some dummy data in POST */
 
    std::string queryStr = twitCurlDefaults::TWITCURL_QUERYSTRING + urlencode( query );
 
 
    /* Perform POST */
 
    return performPost( buildUrl, queryStr );
 
}
 
 
 
/*++
 
* @method: twitCurl::savedSearchDestroy
 
*
 
* @description: method to destroy a saved search for the authenticated user. The search specified
 
*               by id must be owned by the authenticating user.
 
*
 
* @input: searchId - search id of item to be deleted
 
*
 
* @output: true if DELETE is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::savedSearchDestroy( std::string& searchId )
 
{
 
    /* Prepare URL */
 
    std::string buildUrl = twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                           twitterDefaults::TWITCURL_SAVEDSEARCHDESTROY_URL + searchId +
 
                           twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType];
 
 
    /* Perform DELETE */
 
    return performDelete( buildUrl );
 
}
 
 
 
/*++
 
* @method: twitCurl::trendsGet()
 
*
 
* @description: gets trends.
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::trendsGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_TRENDS_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
 
/*++
 
* @method: twitCurl::trendsDailyGet()
 
*
 
* @description: gets daily trends.
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::trendsDailyGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_TRENDSDAILY_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::trendsWeeklyGet()
 
*
 
* @description: gets weekly trends.
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::trendsWeeklyGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_TRENDSWEEKLY_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::trendsCurrentGet()
 
*
 
* @description: gets current trends.
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::trendsCurrentGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_TRENDSCURRENT_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::trendsAvailableGet()
 
*
 
* @description: gets available trends.
 
*
 
* @input: none
 
*
 
* @output: true if GET is success, otherwise false. This does not check http
 
*          response by twitter. Use getLastWebResponse() for that.
 
*
 
*--*/
 
bool twitCurl::trendsAvailableGet()
 
{
 
    /* Perform GET */
 
    return performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                       twitterDefaults::TWITCURL_TRENDSAVAILABLE_URL +
 
                       twitCurlDefaults::TWITCURL_EXTENSIONFORMATS[m_eApiFormatType] );
 
}
 
 
/*++
 
* @method: twitCurl::getLastWebResponse
 
*
 
* @description: method to get http response for the most recent request sent.
 
*               twitcurl users need to call this method and parse the XML
 
*               data returned by twitter to see what has happened.
 
*
 
* @input: outWebResp - string in which twitter's response is supplied back to caller
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::getLastWebResponse( std::string& outWebResp )
 
{
 
    outWebResp = "";
 
    if( m_callbackData.length() )
 
    {
 
        outWebResp = m_callbackData;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::getLastCurlError
 
*
 
* @description: method to get cURL error response for most recent http request.
 
*               twitcurl users can call this method if any of the APIs return
 
*               false.
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
*--*/
 
void twitCurl::getLastCurlError( std::string& outErrResp )
 
{
 
    m_errorBuffer[twitCurlDefaults::TWITCURL_DEFAULT_BUFFSIZE-1] = twitCurlDefaults::TWITCURL_EOS;
 
    outErrResp.assign( m_errorBuffer );
 
}
 
 
/*++
 
* @method: twitCurl::curlCallback
 
*
 
* @description: static method to get http response back from cURL.
 
*               this is an internal method, users of twitcurl need not
 
*               use this.
 
*
 
* @input: as per cURL convention.
 
*
 
* @output: size of data stored in our buffer
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
int twitCurl::curlCallback( char* data, size_t size, size_t nmemb, twitCurl* pTwitCurlObj )
 
{
 
    int writtenSize = 0;
 
    if( ( NULL != pTwitCurlObj ) && ( NULL != data ) )
 
    {
 
        /* Save http response in twitcurl object's buffer */
 
        writtenSize = pTwitCurlObj->saveLastWebResponse( data, ( size*nmemb ) );
 
    }
 
    return writtenSize;
 
}
 
 
/*++
 
* @method: twitCurl::saveLastWebResponse
 
*
 
* @description: method to save http responses. this is an internal method
 
*               and twitcurl users need not use this.
 
*
 
* @input: data - character buffer from cURL,
 
*         size - size of character buffer
 
*
 
* @output: size of data stored in our buffer
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
int twitCurl::saveLastWebResponse(  char*& data, size_t size )
 
{
 
    int bytesWritten = 0;
 
    if( data && size )
 
    {
 
        /* Append data in our internal buffer */
 
        m_callbackData.append( data, size );
 
        bytesWritten = (int)size;
 
    }
 
    return bytesWritten;
 
}
 
 
/*++
 
* @method: twitCurl::clearCurlCallbackBuffers
 
*
 
* @description: method to clear callback buffers used by cURL. this is an
 
*               internal method and twitcurl users need not use this.
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void twitCurl::clearCurlCallbackBuffers()
 
{
 
    m_callbackData = "";
 
    memset( m_errorBuffer, 0, twitCurlDefaults::TWITCURL_DEFAULT_BUFFSIZE );
 
}
 
 
/*++
 
* @method: twitCurl::prepareCurlProxy
 
*
 
* @description: method to set proxy details into cURL. this is an internal method.
 
*               twitcurl users should not use this method, instead use setProxyXxx
 
*               methods to set proxy server information.
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void twitCurl::prepareCurlProxy()
 
{
 
    if( !m_curlProxyParamsSet )
 
    {
 
        /* Reset existing proxy details in cURL */
 
        curl_easy_setopt( m_curlHandle, CURLOPT_PROXY, NULL );
 
        curl_easy_setopt( m_curlHandle, CURLOPT_PROXYUSERPWD, NULL );
 
        curl_easy_setopt( m_curlHandle, CURLOPT_PROXYAUTH, (long)CURLAUTH_ANY );
 
 
        /* Set proxy details in cURL */
 
        std::string proxyIpPort("");
 
        if( getProxyServerIp().size() )
 
        {
 
            utilMakeCurlParams( proxyIpPort, getProxyServerIp(), getProxyServerPort() );
 
        }
 
        curl_easy_setopt( m_curlHandle, CURLOPT_PROXY, proxyIpPort.c_str() );
 
 
        /* Prepare username and password for proxy server */
 
        if( m_proxyUserName.length() && m_proxyPassword.length() )
 
        {
 
            std::string proxyUserPass;
 
            utilMakeCurlParams( proxyUserPass, getProxyUserName(), getProxyPassword() );
 
            curl_easy_setopt( m_curlHandle, CURLOPT_PROXYUSERPWD, proxyUserPass.c_str() );
 
        }
 
 
        /* Set the flag to true indicating that proxy info is set in cURL */
 
        m_curlProxyParamsSet = true;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::prepareCurlCallback
 
*
 
* @description: method to set callback details into cURL. this is an internal method.
 
*               twitcurl users should not use this method.
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void twitCurl::prepareCurlCallback()
 
{
 
    if( !m_curlCallbackParamsSet )
 
    {
 
        /* Set buffer to get error */
 
        curl_easy_setopt( m_curlHandle, CURLOPT_ERRORBUFFER, m_errorBuffer );
 
 
        /* Set callback function to get response */
 
        curl_easy_setopt( m_curlHandle, CURLOPT_WRITEFUNCTION, curlCallback );
 
        curl_easy_setopt( m_curlHandle, CURLOPT_WRITEDATA, this );
 
 
        /* Set the flag to true indicating that callback info is set in cURL */
 
        m_curlCallbackParamsSet = true;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::prepareCurlUserPass
 
*
 
* @description: method to set twitter credentials into cURL. this is an internal method.
 
*               twitcurl users should not use this method, instead use setTwitterXxx
 
*               methods to set twitter username and password.
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void twitCurl::prepareCurlUserPass()
 
{
 
    if( !m_curlLoginParamsSet )
 
    {
 
        /* Reset existing username and password stored in cURL */
 
        curl_easy_setopt( m_curlHandle, CURLOPT_USERPWD, "" );
 
 
        if( getTwitterUsername().size() )
 
        {
 
            /* Prepare username:password */
 
            std::string userNamePassword;
 
            utilMakeCurlParams( userNamePassword, getTwitterUsername(), getTwitterPassword() );
 
 
            /* Set username and password */
 
            curl_easy_setopt( m_curlHandle, CURLOPT_USERPWD, userNamePassword.c_str() );
 
        }
 
 
        /* Set the flag to true indicating that twitter credentials are set in cURL */
 
        m_curlLoginParamsSet = true;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::prepareStandardParams
 
*
 
* @description: method to set standard params into cURL. this is an internal method.
 
*               twitcurl users should not use this method.
 
*
 
* @input: none
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void twitCurl::prepareStandardParams()
 
{
 
    /* Restore any custom request we may have */
 
    curl_easy_setopt( m_curlHandle, CURLOPT_CUSTOMREQUEST, NULL );
 
 
    /* Clear callback and error buffers */
 
    clearCurlCallbackBuffers();
 
 
    /* Prepare proxy */
 
    prepareCurlProxy();
 
 
    /* Prepare cURL callback data and error buffer */
 
    prepareCurlCallback();
 
 
    /* Prepare username and password for twitter */
 
    prepareCurlUserPass();
 
}
 
 
/*++
 
* @method: twitCurl::performGet
 
*
 
* @description: method to send http GET request. this is an internal method.
 
*               twitcurl users should not use this method.
 
*
 
* @input: getUrl - url
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
bool twitCurl::performGet( const std::string& getUrl )
 
{
 
    /* Return if cURL is not initialized */
 
    if( !isCurlInit() )
 
    {
 
        return false;
 
    }
 
 
    std::string dataStrDummy;
 
    std::string oAuthHttpHeader;
 
    struct curl_slist* pOAuthHeaderList = NULL;
 
 
    /* Prepare standard params */
 
    prepareStandardParams();
 
 
    /* Set OAuth header */
 
    m_oAuth.getOAuthHeader( eOAuthHttpGet, getUrl, dataStrDummy, oAuthHttpHeader );
 
    if( oAuthHttpHeader.length() )
 
    {
 
        pOAuthHeaderList = curl_slist_append( pOAuthHeaderList, oAuthHttpHeader.c_str() );
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_setopt( m_curlHandle, CURLOPT_HTTPHEADER, pOAuthHeaderList );
 
        }
 
    }
 
 
    /* Set http request and url */
 
    curl_easy_setopt( m_curlHandle, CURLOPT_HTTPGET, 1 );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_URL, getUrl.c_str() );
 
 
    /* Send http request */
 
    if( CURLE_OK == curl_easy_perform( m_curlHandle ) )
 
    {
 
        if( pOAuthHeaderList )
 
        {
 
            curl_slist_free_all( pOAuthHeaderList );
 
        }
 
        return true;
 
    }
 
    if( pOAuthHeaderList )
 
    {
 
        curl_slist_free_all( pOAuthHeaderList );
 
    }
 
    return false;
 
}
 
 
/*++
 
* @method: twitCurl::performGet
 
*
 
* @description: method to send http GET request. this is an internal method.
 
*               twitcurl users should not use this method.
 
*
 
* @input: const std::string& getUrl, const std::string& oAuthHttpHeader
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
bool twitCurl::performGet( const std::string& getUrl, const std::string& oAuthHttpHeader )
 
{
 
    /* Return if cURL is not initialized */
 
    if( !isCurlInit() )
 
    {
 
        return false;
 
    }
 
 
    struct curl_slist* pOAuthHeaderList = NULL;
 
 
    /* Prepare standard params */
 
    prepareStandardParams();
 
 
    /* Set http request and url */
 
    curl_easy_setopt( m_curlHandle, CURLOPT_HTTPGET, 1 );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_URL, getUrl.c_str() );
 
 
    /* Set header */
 
    if( oAuthHttpHeader.length() )
 
    {
 
        pOAuthHeaderList = curl_slist_append( pOAuthHeaderList, oAuthHttpHeader.c_str() );
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_setopt( m_curlHandle, CURLOPT_HTTPHEADER, pOAuthHeaderList );
 
        }
 
    }
 
 
    /* Send http request */
 
    if( CURLE_OK == curl_easy_perform( m_curlHandle ) )
 
    {
 
        if( pOAuthHeaderList )
 
        {
 
            curl_slist_free_all( pOAuthHeaderList );
 
        }
 
        return true;
 
    }
 
    if( pOAuthHeaderList )
 
    {
 
        curl_slist_free_all( pOAuthHeaderList );
 
    }
 
    return false;
 
}
 
 
/*++
 
* @method: twitCurl::performDelete
 
*
 
* @description: method to send http DELETE request. this is an internal method.
 
*               twitcurl users should not use this method.
 
*
 
* @input: deleteUrl - url
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
bool twitCurl::performDelete( const std::string& deleteUrl )
 
{
 
    /* Return if cURL is not initialized */
 
    if( !isCurlInit() )
 
    {
 
        return false;
 
    }
 
 
    std::string dataStrDummy;
 
    std::string oAuthHttpHeader;
 
    struct curl_slist* pOAuthHeaderList = NULL;
 
 
    /* Prepare standard params */
 
    prepareStandardParams();
 
 
    /* Set OAuth header */
 
    m_oAuth.getOAuthHeader( eOAuthHttpDelete, deleteUrl, dataStrDummy, oAuthHttpHeader );
 
    if( oAuthHttpHeader.length() )
 
    {
 
        pOAuthHeaderList = curl_slist_append( pOAuthHeaderList, oAuthHttpHeader.c_str() );
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_setopt( m_curlHandle, CURLOPT_HTTPHEADER, pOAuthHeaderList );
 
        }
 
    }
 
 
    /* Set http request and url */
 
    curl_easy_setopt( m_curlHandle, CURLOPT_CUSTOMREQUEST, "DELETE" );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_URL, deleteUrl.c_str() );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_COPYPOSTFIELDS, dataStrDummy.c_str() );
 
 
    /* Send http request */
 
    if( CURLE_OK == curl_easy_perform( m_curlHandle ) )
 
    {
 
        if( pOAuthHeaderList )
 
        {
 
            curl_slist_free_all( pOAuthHeaderList );
 
        }
 
        return true;
 
    }
 
    if( pOAuthHeaderList )
 
    {
 
        curl_slist_free_all( pOAuthHeaderList );
 
    }
 
    return false;
 
}
 
 
/*++
 
* @method: twitCurl::performPost
 
*
 
* @description: method to send http POST request. this is an internal method.
 
*               twitcurl users should not use this method.
 
*
 
* @input: postUrl - url,
 
*         dataStr - url encoded data to be posted
 
*
 
* @output: none
 
*
 
* @remarks: internal method
 
*           data value in dataStr must already be url encoded.
 
*           ex: dataStr = "key=urlencode(value)"
 
*
 
*--*/
 
bool twitCurl::performPost( const std::string& postUrl, std::string dataStr )
 
{
 
    /* Return if cURL is not initialized */
 
    if( !isCurlInit() )
 
    {
 
        return false;
 
    }
 
 
    std::string oAuthHttpHeader;
 
    struct curl_slist* pOAuthHeaderList = NULL;
 
 
    /* Prepare standard params */
 
    prepareStandardParams();
 
 
    /* Set OAuth header */
 
    m_oAuth.getOAuthHeader( eOAuthHttpPost, postUrl, dataStr, oAuthHttpHeader );
 
    if( oAuthHttpHeader.length() )
 
    {
 
        pOAuthHeaderList = curl_slist_append( pOAuthHeaderList, oAuthHttpHeader.c_str() );
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_setopt( m_curlHandle, CURLOPT_HTTPHEADER, pOAuthHeaderList );
 
        }
 
    }
 
 
    /* Set http request, url and data */
 
    curl_easy_setopt( m_curlHandle, CURLOPT_POST, 1 );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_URL, postUrl.c_str() );
 
    if( dataStr.length() )
 
    {
 
        curl_easy_setopt( m_curlHandle, CURLOPT_COPYPOSTFIELDS, dataStr.c_str() );
 
    }
 
 
    /* Send http request */
 
    if( CURLE_OK == curl_easy_perform( m_curlHandle ) )
 
    {
 
        if( pOAuthHeaderList )
 
        {
 
            curl_slist_free_all( pOAuthHeaderList );
 
        }
 
        return true;
 
    }
 
    if( pOAuthHeaderList )
 
    {
 
        curl_slist_free_all( pOAuthHeaderList );
 
    }
 
    return false;
 
}
 
 
/*++
 
* @method: utilMakeCurlParams
 
*
 
* @description: utility function to build parameter strings in the format
 
*               required by cURL ("param1:param2"). twitcurl users should
 
*               not use this function.
 
*
 
* @input: inParam1 - first parameter,
 
*         inParam2 - second parameter
 
*
 
* @output: outStr - built parameter
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void utilMakeCurlParams( std::string& outStr, std::string& inParam1, std::string& inParam2 )
 
{
 
    outStr = inParam1;
 
    outStr += twitCurlDefaults::TWITCURL_COLON + inParam2;
 
}
 
 
/*++
 
* @method: utilMakeUrlForUser
 
*
 
* @description: utility function to build url compatible to twitter. twitcurl
 
*               users should not use this function.
 
*
 
* @input: baseUrl - base twitter url,
 
*         userInfo - user name,
 
*         isUserId - indicates if userInfo contains a user id or scree name
 
*
 
* @output: outUrl - built url
 
*
 
* @remarks: internal method
 
*
 
*--*/
 
void utilMakeUrlForUser( std::string& outUrl, const std::string& baseUrl, std::string& userInfo, bool isUserId )
 
{
 
    /* Copy base URL */
 
    outUrl = baseUrl;
 
 
    if( userInfo.length() )
 
    {
 
        /* Append username to the URL */
 
        outUrl += twitCurlDefaults::TWITCURL_URL_SEP_QUES;
 
        if( isUserId )
 
        {
 
            outUrl += twitCurlDefaults::TWITCURL_USERID;
 
        }
 
        else
 
        {
 
            outUrl += twitCurlDefaults::TWITCURL_SCREENNAME;
 
        }
 
        outUrl += userInfo;
 
    }
 
}
 
 
/*++
 
* @method: twitCurl::getOAuth
 
*
 
* @description: method to get a reference to oAuth object.
 
*
 
* @input: none
 
*
 
* @output: reference to oAuth object
 
*
 
*--*/
 
oAuth& twitCurl::getOAuth()
 
{
 
    return m_oAuth;
 
}
 
 
/*++
 
* @method: twitCurl::oAuthRequestToken
 
*
 
* @description: method to get a request token key and secret. this token
 
*               will be used to get authorize user and get PIN from twitter
 
*
 
* @input: authorizeUrl is an output parameter. this method will set the url
 
*         in this string. user should visit this link and get PIN from that page.
 
*
 
* @output: true if everything went sucessfully, otherwise false
 
*
 
*--*/
 
bool twitCurl::oAuthRequestToken( std::string& authorizeUrl /* out */ )
 
{
 
    /* Return if cURL is not initialized */
 
    if( !isCurlInit() )
 
    {
 
        return false;
 
    }
 
 
    /* Get OAuth header for request token */
 
    bool retVal = false;
 
    std::string oAuthHeader;
 
    authorizeUrl = "";
 
    if( m_oAuth.getOAuthHeader( eOAuthHttpGet,
 
                                twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                                oAuthTwitterApiUrls::OAUTHLIB_TWITTER_REQUEST_TOKEN_URL,
 
                                std::string( "" ),
 
                                oAuthHeader ) )
 
    {
 
        if( performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                        oAuthTwitterApiUrls::OAUTHLIB_TWITTER_REQUEST_TOKEN_URL, oAuthHeader ) )
 
        {
 
            /* Tell OAuth object to save access token and secret from web response */
 
            std::string twitterResp;
 
            getLastWebResponse( twitterResp );
 
            m_oAuth.extractOAuthTokenKeySecret( twitterResp );
 
 
            /* Get access token and secret from OAuth object */
 
            std::string oAuthTokenKey;
 
            m_oAuth.getOAuthTokenKey( oAuthTokenKey );
 
 
            /* Build authorize url so that user can visit in browser and get PIN */
 
            authorizeUrl.assign(twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                                oAuthTwitterApiUrls::OAUTHLIB_TWITTER_AUTHORIZE_URL );
 
            authorizeUrl.append( oAuthTokenKey.c_str() );
 
 
            retVal = true;
 
        }
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* @method: twitCurl::oAuthAccessToken
 
*
 
* @description: method to exchange request token with access token
 
*
 
* @input: none
 
*
 
* @output: true if everything went sucessfully, otherwise false
 
*
 
*--*/
 
bool twitCurl::oAuthAccessToken()
 
{
 
    /* Return if cURL is not initialized */
 
    if( !isCurlInit() )
 
    {
 
        return false;
 
    }
 
    /* Get OAuth header for access token */
 
    bool retVal = false;
 
    std::string oAuthHeader;
 
    if( m_oAuth.getOAuthHeader( eOAuthHttpGet,
 
                                twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                                oAuthTwitterApiUrls::OAUTHLIB_TWITTER_ACCESS_TOKEN_URL,
 
                                std::string( "" ),
 
                                oAuthHeader, true ) )
 
    {
 
        if( performGet( twitCurlDefaults::TWITCURL_PROTOCOLS[m_eProtocolType] +
 
                        oAuthTwitterApiUrls::OAUTHLIB_TWITTER_ACCESS_TOKEN_URL, oAuthHeader ) )
 
        {
 
            /* Tell OAuth object to save access token and secret from web response */
 
            std::string twitterResp;
 
            getLastWebResponse( twitterResp );
 
            m_oAuth.extractOAuthTokenKeySecret( twitterResp );
 
 
            retVal = true;
 
        }
 
    }
 
    return retVal;
 
}
 
 
/*++
 
* ADDED BY ANTIROOT
 
*
 
* @method: twitCurl::oAuthHandlePIN
 
*
 
* @description: method to handle user's PIN code from the authentiation URLs
 
*
 
* @input: none
 
*
 
* @output: true if everything went sucessfully, otherwise false
 
*
 
*--*/
 
bool twitCurl::oAuthHandlePIN( const std::string& authorizeUrl /* in */ )
 
{
 
    /* Return if cURL is not initialized */
 
    if( !isCurlInit() )
 
    {
 
        return false;
 
    }
 
 
    std::string dataStr;
 
    std::string oAuthHttpHeader;
 
    std::string authenticityTokenVal;
 
    std::string oauthTokenVal;
 
    std::string pinCodeVal;
 
    unsigned long httpStatusCode = 0;
 
    size_t nPosStart, nPosEnd;
 
    struct curl_slist* pOAuthHeaderList = NULL;
 
 
    /* Prepare standard params */
 
    prepareStandardParams();
 
 
    /* Set OAuth header */
 
    m_oAuth.getOAuthHeader( eOAuthHttpGet, authorizeUrl, dataStr, oAuthHttpHeader );
 
    if( oAuthHttpHeader.length() )
 
    {
 
        pOAuthHeaderList = curl_slist_append( pOAuthHeaderList, oAuthHttpHeader.c_str() );
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_setopt( m_curlHandle, CURLOPT_HTTPHEADER, pOAuthHeaderList );
 
        }
 
    }
 
 
    /* Set http request and url */
 
    curl_easy_setopt( m_curlHandle, CURLOPT_HTTPGET, 1 );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_URL, authorizeUrl.c_str() );
 
 
    /* Send http request */
 
    if( CURLE_OK == curl_easy_perform( m_curlHandle ) )
 
    {
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_getinfo( m_curlHandle, CURLINFO_HTTP_CODE, &httpStatusCode );
 
            curl_slist_free_all( pOAuthHeaderList );
 
 
            // Now, let's find the authenticity token and oauth token
 
            nPosStart = m_callbackData.find( oAuthLibDefaults::OAUTHLIB_AUTHENTICITY_TOKEN_TWITTER_RESP_KEY );
 
            if( std::string::npos == nPosStart )
 
            {
 
                return false;
 
            }
 
            nPosStart += oAuthLibDefaults::OAUTHLIB_AUTHENTICITY_TOKEN_TWITTER_RESP_KEY.length();
 
            nPosEnd = m_callbackData.substr( nPosStart ).find( oAuthLibDefaults::OAUTHLIB_TOKEN_END_TAG_TWITTER_RESP );
 
            if( std::string::npos == nPosEnd )
 
            {
 
                return false;
 
            }
 
            authenticityTokenVal = m_callbackData.substr( nPosStart, nPosEnd );
 
 
            nPosStart = m_callbackData.find( oAuthLibDefaults::OAUTHLIB_TOKEN_TWITTER_RESP_KEY );
 
            if( std::string::npos == nPosStart )
 
            {
 
                return false;
 
            }
 
            nPosStart += oAuthLibDefaults::OAUTHLIB_TOKEN_TWITTER_RESP_KEY.length();
 
            nPosEnd = m_callbackData.substr( nPosStart ).find( oAuthLibDefaults::OAUTHLIB_TOKEN_END_TAG_TWITTER_RESP );
 
            if( std::string::npos == nPosEnd )
 
            {
 
                return false;
 
            }
 
            oauthTokenVal = m_callbackData.substr( nPosStart, nPosEnd );
 
        }
 
    }
 
    else if( pOAuthHeaderList )
 
    {
 
        curl_slist_free_all( pOAuthHeaderList );
 
        return false;
 
    }
 
 
    // Second phase for the authorization
 
    pOAuthHeaderList = NULL;
 
    oAuthHttpHeader.clear();
 
 
    /* Prepare standard params */
 
    prepareStandardParams();
 
 
    /*
 
    Now, we need to make a data string for POST operation
 
    which includes oauth token, authenticity token, username, password.
 
    */
 
    dataStr = oAuthLibDefaults::OAUTHLIB_TOKEN_KEY + "=" + oauthTokenVal + "&" +                      \
 
              oAuthLibDefaults::OAUTHLIB_AUTHENTICITY_TOKEN_KEY + "=" + authenticityTokenVal + "&" +  \
 
              oAuthLibDefaults::OAUTHLIB_SESSIONUSERNAME_KEY + "=" + getTwitterUsername() + "&" +     \
 
              oAuthLibDefaults::OAUTHLIB_SESSIONPASSWORD_KEY + "=" + getTwitterPassword();
 
 
    /* Set OAuth header */
 
    m_oAuth.getOAuthHeader( eOAuthHttpPost, authorizeUrl, dataStr, oAuthHttpHeader );
 
    if( oAuthHttpHeader.length() )
 
    {
 
        pOAuthHeaderList = curl_slist_append( pOAuthHeaderList, oAuthHttpHeader.c_str() );
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_setopt( m_curlHandle, CURLOPT_HTTPHEADER, pOAuthHeaderList );
 
        }
 
    }
 
 
    /* Set http request and url */
 
    curl_easy_setopt( m_curlHandle, CURLOPT_POST, 1 );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_URL, authorizeUrl.c_str() );
 
    curl_easy_setopt( m_curlHandle, CURLOPT_COPYPOSTFIELDS, dataStr.c_str() );
 
 
    /* Send http request */
 
    if( CURLE_OK == curl_easy_perform( m_curlHandle ) )
 
    {
 
        if( pOAuthHeaderList )
 
        {
 
            curl_easy_getinfo( m_curlHandle, CURLINFO_HTTP_CODE, &httpStatusCode );
 
            curl_slist_free_all( pOAuthHeaderList );
 
 
            // Now, let's find the PIN CODE
 
            nPosStart = m_callbackData.find( oAuthLibDefaults::OAUTHLIB_PIN_TWITTER_RESP_KEY );
 
            if( std::string::npos == nPosStart )
 
            {
 
                return false;
 
            }
 
            nPosStart += oAuthLibDefaults::OAUTHLIB_PIN_TWITTER_RESP_KEY.length();
 
            nPosEnd = m_callbackData.substr( nPosStart ).find( oAuthLibDefaults::OAUTHLIB_PIN_END_TAG_TWITTER_RESP );
 
            if( std::string::npos == nPosEnd )
 
            {
 
                return false;
 
            }
 
            pinCodeVal = m_callbackData.substr( nPosStart, nPosEnd );
 
            getOAuth().setOAuthPin( pinCodeVal );
 
            return true;
 
        }
 
    }
 
    else if( pOAuthHeaderList )
 
    {
 
        curl_slist_free_all( pOAuthHeaderList );
 
    }
 
    return false;
 
}
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.dsp.svn-base
Show inline comments
 
new file 100644
 
# Microsoft Developer Studio Project File - Name="twitcurl" - Package Owner=<4>
 
# Microsoft Developer Studio Generated Build File, Format Version 6.00
 
# ** DO NOT EDIT **
 
 
# TARGTYPE "Win32 (x86) Static Library" 0x0104
 
 
CFG=twitcurl - Win32 Debug
 
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
 
!MESSAGE use the Export Makefile command and run
 
!MESSAGE 
 
!MESSAGE NMAKE /f "twitcurl.mak".
 
!MESSAGE 
 
!MESSAGE You can specify a configuration when running NMAKE
 
!MESSAGE by defining the macro CFG on the command line. For example:
 
!MESSAGE 
 
!MESSAGE NMAKE /f "twitcurl.mak" CFG="twitcurl - Win32 Debug"
 
!MESSAGE 
 
!MESSAGE Possible choices for configuration are:
 
!MESSAGE 
 
!MESSAGE "twitcurl - Win32 Release" (based on "Win32 (x86) Static Library")
 
!MESSAGE "twitcurl - Win32 Debug" (based on "Win32 (x86) Static Library")
 
!MESSAGE 
 
 
# Begin Project
 
# PROP AllowPerConfigDependencies 0
 
# PROP Scc_ProjName ""
 
# PROP Scc_LocalPath ""
 
CPP=cl.exe
 
RSC=rc.exe
 
 
!IF  "$(CFG)" == "twitcurl - Win32 Release"
 
 
# PROP BASE Use_MFC 0
 
# PROP BASE Use_Debug_Libraries 0
 
# PROP BASE Output_Dir "Release"
 
# PROP BASE Intermediate_Dir "Release"
 
# PROP BASE Target_Dir ""
 
# PROP Use_MFC 0
 
# PROP Use_Debug_Libraries 0
 
# PROP Output_Dir "Release"
 
# PROP Intermediate_Dir "Release"
 
# PROP Target_Dir ""
 
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
 
# ADD CPP /nologo /W3 /GX /O2 /I "./curl" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
 
# ADD BASE RSC /l 0x409 /d "NDEBUG"
 
# ADD RSC /l 0x409 /d "NDEBUG"
 
BSC32=bscmake.exe
 
# ADD BASE BSC32 /nologo
 
# ADD BSC32 /nologo
 
LIB32=link.exe -lib
 
# ADD BASE LIB32 /nologo
 
# ADD LIB32 /nologo
 
 
!ELSEIF  "$(CFG)" == "twitcurl - Win32 Debug"
 
 
# PROP BASE Use_MFC 0
 
# PROP BASE Use_Debug_Libraries 1
 
# PROP BASE Output_Dir "Debug"
 
# PROP BASE Intermediate_Dir "Debug"
 
# PROP BASE Target_Dir ""
 
# PROP Use_MFC 0
 
# PROP Use_Debug_Libraries 1
 
# PROP Output_Dir "Debug"
 
# PROP Intermediate_Dir "Debug"
 
# PROP Target_Dir ""
 
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
 
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "./curl" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
 
# ADD BASE RSC /l 0x409 /d "_DEBUG"
 
# ADD RSC /l 0x409 /d "_DEBUG"
 
BSC32=bscmake.exe
 
# ADD BASE BSC32 /nologo
 
# ADD BSC32 /nologo
 
LIB32=link.exe -lib
 
# ADD BASE LIB32 /nologo
 
# ADD LIB32 /nologo
 
 
!ENDIF 
 
 
# Begin Target
 
 
# Name "twitcurl - Win32 Release"
 
# Name "twitcurl - Win32 Debug"
 
# Begin Group "Source Files"
 
 
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 
# Begin Source File
 
 
SOURCE=.\base64.cpp
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\HMAC_SHA1.cpp
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\oauthlib.cpp
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\SHA1.cpp
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\twitcurl.cpp
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\urlencode.cpp
 
# End Source File
 
# End Group
 
# Begin Group "Header Files"
 
 
# PROP Default_Filter "h;hpp;hxx;hm;inl"
 
# Begin Source File
 
 
SOURCE=.\base64.h
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\HMAC_SHA1.h
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\oauthlib.h
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\SHA1.h
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\twitcurl.h
 
# End Source File
 
# Begin Source File
 
 
SOURCE=.\urlencode.h
 
# End Source File
 
# End Group
 
# End Target
 
# End Project
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.dsw.svn-base
Show inline comments
 
new file 100644
 
Microsoft Developer Studio Workspace File, Format Version 6.00
 
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
 
 
###############################################################################
 
 
Project: "twitcurl"=.\twitcurl.dsp - Package Owner=<4>
 
 
Package=<5>
 
{{{
 
}}}
 
 
Package=<4>
 
{{{
 
}}}
 
 
###############################################################################
 
 
Global:
 
 
Package=<5>
 
{{{
 
}}}
 
 
Package=<3>
 
{{{
 
}}}
 
 
###############################################################################
 
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.h.svn-base
Show inline comments
 
new file 100644
 
#ifndef _TWITCURL_H_
 
#define _TWITCURL_H_
 
 
#include <string>
 
#include <sstream>
 
#include <cstring>
 
#include "oauthlib.h"
 
#include "curl/curl.h"
 
 
namespace twitCurlTypes
 
{
 
    typedef enum _eTwitCurlApiFormatType
 
    {
 
        eTwitCurlApiFormatXml = 0,
 
        eTwitCurlApiFormatJson,
 
        eTwitCurlApiFormatMax
 
    } eTwitCurlApiFormatType;
 
 
    typedef enum _eTwitCurlProtocolType
 
    {
 
        eTwitCurlProtocolHttp = 0,
 
        eTwitCurlProtocolHttps,
 
        eTwitCurlProtocolMax
 
    } eTwitCurlProtocolType;
 
};
 
 
/* Default values used in twitcurl */
 
namespace twitCurlDefaults
 
{
 
    /* Constants */
 
    const int TWITCURL_DEFAULT_BUFFSIZE = 1024;
 
    const std::string TWITCURL_COLON = ":";
 
    const char TWITCURL_EOS = '\0';
 
    const unsigned int MAX_TIMELINE_TWEET_COUNT = 200;
 
 
    /* Miscellaneous data used to build twitter URLs*/
 
    const std::string TWITCURL_STATUSSTRING = "status=";
 
    const std::string TWITCURL_TEXTSTRING = "text=";
 
    const std::string TWITCURL_QUERYSTRING = "query=";
 
    const std::string TWITCURL_SEARCHQUERYSTRING = "q=";
 
    const std::string TWITCURL_SCREENNAME = "screen_name=";
 
    const std::string TWITCURL_USERID = "user_id=";
 
    const std::string TWITCURL_EXTENSIONFORMATS[2] = { ".xml",
 
                                                       ".json"
 
                                                     };
 
    const std::string TWITCURL_PROTOCOLS[2] =        { "http://",
 
                                                       "https://"
 
                                                     };
 
    const std::string TWITCURL_TARGETSCREENNAME = "target_screen_name=";
 
    const std::string TWITCURL_TARGETUSERID = "target_id=";
 
    const std::string TWITCURL_SINCEID = "since_id=";
 
    const std::string TWITCURL_TRIMUSER = "trim_user=true";
 
    const std::string TWITCURL_INCRETWEETS = "include_rts=true";
 
    const std::string TWITCURL_COUNT = "count=";
 
 
    /* URL separators */
 
    const std::string TWITCURL_URL_SEP_AMP = "&";
 
    const std::string TWITCURL_URL_SEP_QUES = "?";
 
};
 
 
/* Default twitter URLs */
 
namespace twitterDefaults
 
{
 
 
    /* Search URLs */
 
    const std::string TWITCURL_SEARCH_URL = "search.twitter.com/search";
 
 
    /* Status URLs */
 
    const std::string TWITCURL_STATUSUPDATE_URL = "api.twitter.com/1/statuses/update";
 
    const std::string TWITCURL_STATUSSHOW_URL = "api.twitter.com/1/statuses/show/";
 
    const std::string TWITCURL_STATUDESTROY_URL = "api.twitter.com/1/statuses/destroy/";
 
 
    /* Timeline URLs */
 
    const std::string TWITCURL_HOME_TIMELINE_URL = "api.twitter.com/1/statuses/home_timeline";
 
    const std::string TWITCURL_PUBLIC_TIMELINE_URL = "api.twitter.com/1/statuses/public_timeline";
 
    const std::string TWITCURL_FEATURED_USERS_URL = "api.twitter.com/1/statuses/featured";
 
    const std::string TWITCURL_FRIENDS_TIMELINE_URL = "api.twitter.com/1/statuses/friends_timeline";
 
    const std::string TWITCURL_MENTIONS_URL = "api.twitter.com/1/statuses/mentions";
 
    const std::string TWITCURL_USERTIMELINE_URL = "api.twitter.com/1/statuses/user_timeline";
 
 
    /* Users URLs */
 
    const std::string TWITCURL_SHOWUSERS_URL = "api.twitter.com/1/users/show";
 
    const std::string TWITCURL_SHOWFRIENDS_URL = "api.twitter.com/1/statuses/friends";
 
    const std::string TWITCURL_SHOWFOLLOWERS_URL = "api.twitter.com/1/statuses/followers";
 
 
    /* Direct messages URLs */
 
    const std::string TWITCURL_DIRECTMESSAGES_URL = "api.twitter.com/1/direct_messages";
 
    const std::string TWITCURL_DIRECTMESSAGENEW_URL = "api.twitter.com/1/direct_messages/new";
 
    const std::string TWITCURL_DIRECTMESSAGESSENT_URL = "api.twitter.com/1/direct_messages/sent";
 
    const std::string TWITCURL_DIRECTMESSAGEDESTROY_URL = "api.twitter.com/1/direct_messages/destroy/";
 
 
    /* Friendships URLs */
 
    const std::string TWITCURL_FRIENDSHIPSCREATE_URL = "api.twitter.com/1/friendships/create";
 
    const std::string TWITCURL_FRIENDSHIPSDESTROY_URL = "api.twitter.com/1/friendships/destroy";
 
    const std::string TWITCURL_FRIENDSHIPSSHOW_URL = "api.twitter.com/1/friendships/show";
 
 
    /* Social graphs URLs */
 
    const std::string TWITCURL_FRIENDSIDS_URL = "api.twitter.com/1/friends/ids";
 
    const std::string TWITCURL_FOLLOWERSIDS_URL = "api.twitter.com/1/followers/ids";
 
 
    /* Account URLs */
 
    const std::string TWITCURL_ACCOUNTRATELIMIT_URL = "api.twitter.com/1/account/rate_limit_status";
 
    const std::string TWITCURL_ACCOUNTVERIFYCRED_URL = "api.twitter.com/1/account/verify_credentials";
 
 
    /* Favorites URLs */
 
    const std::string TWITCURL_FAVORITESGET_URL = "api.twitter.com/1/favorites";
 
    const std::string TWITCURL_FAVORITECREATE_URL = "api.twitter.com/1/favorites/create/";
 
    const std::string TWITCURL_FAVORITEDESTROY_URL = "api.twitter.com/1/favorites/destroy/";
 
 
    /* Block URLs */
 
    const std::string TWITCURL_BLOCKSCREATE_URL = "api.twitter.com/1/blocks/create/";
 
    const std::string TWITCURL_BLOCKSDESTROY_URL = "api.twitter.com/1/blocks/destroy/";
 
 
    /* Saved Search URLs */
 
    const std::string TWITCURL_SAVEDSEARCHGET_URL = "api.twitter.com/1/saved_searches";
 
    const std::string TWITCURL_SAVEDSEARCHSHOW_URL = "api.twitter.com/1/saved_searches/show/";
 
    const std::string TWITCURL_SAVEDSEARCHCREATE_URL = "api.twitter.com/1/saved_searches/create";
 
    const std::string TWITCURL_SAVEDSEARCHDESTROY_URL = "api.twitter.com/1/saved_searches/destroy/";
 
 
    /* Trends URLs */
 
    const std::string TWITCURL_TRENDS_URL = "api.twitter.com/1/trends";
 
    const std::string TWITCURL_TRENDSDAILY_URL = "api.twitter.com/1/trends/daily";
 
    const std::string TWITCURL_TRENDSCURRENT_URL = "api.twitter.com/1/trends/current";
 
    const std::string TWITCURL_TRENDSWEEKLY_URL = "api.twitter.com/1/trends/weekly";
 
    const std::string TWITCURL_TRENDSAVAILABLE_URL = "api.twitter.com/1/trends/available";
 
 
};
 
 
/* twitCurl class */
 
class twitCurl
 
{
 
public:
 
    twitCurl();
 
    ~twitCurl();
 
 
    /* Twitter OAuth authorization methods */
 
    oAuth& getOAuth();
 
    bool oAuthRequestToken( std::string& authorizeUrl /* out */ );
 
    bool oAuthAccessToken();
 
    bool oAuthHandlePIN( const std::string& authorizeUrl /* in */ );
 
 
    /* Twitter login APIs, set once and forget */
 
    std::string& getTwitterUsername();
 
    std::string& getTwitterPassword();
 
    void setTwitterUsername( std::string& userName /* in */ );
 
    void setTwitterPassword( std::string& passWord /* in */ );
 
 
    /* Twitter API type */
 
    void setTwitterApiType( twitCurlTypes::eTwitCurlApiFormatType eType );
 
    void setTwitterProcotolType( twitCurlTypes::eTwitCurlProtocolType eType );
 
 
    /* Twitter search APIs */
 
    bool search( std::string& searchQuery /* in */ );
 
 
    /* Twitter status APIs */
 
    bool statusUpdate( std::string& newStatus /* in */ );
 
    bool statusShowById( std::string& statusId /* in */ );
 
    bool statusDestroyById( std::string& statusId /* in */ );
 
 
    /* Twitter timeline APIs */
 
    bool timelinePublicGet();
 
    bool timelineFriendsGet();
 
    bool timelineUserGet( bool trimUser /* in */, bool includeRetweets /* in */, unsigned int tweetCount /* in */, std::string userInfo = "" /* in */, bool isUserId = false /* in */ );
 
    bool featuredUsersGet();
 
    bool mentionsGet( std::string sinceId = "" /* in */ );
 
 
    /* Twitter user APIs */
 
    bool userGet( std::string& userInfo /* in */, bool isUserId = false /* in */ );
 
    bool friendsGet( std::string userInfo = "" /* in */, bool isUserId = false /* in */ );
 
    bool followersGet( std::string userInfo = "" /* in */, bool isUserId = false /* in */ );
 
 
    /* Twitter direct message APIs */
 
    bool directMessageGet();
 
    bool directMessageSend( std::string& userInfo /* in */, std::string& dMsg /* in */, bool isUserId = false /* in */ );
 
    bool directMessageGetSent();
 
    bool directMessageDestroyById( std::string& dMsgId /* in */ );
 
 
    /* Twitter friendships APIs */
 
    bool friendshipCreate( std::string& userInfo /* in */, bool isUserId = false /* in */ );
 
    bool friendshipDestroy( std::string& userInfo /* in */, bool isUserId = false /* in */ );
 
    bool friendshipShow( std::string& userInfo /* in */, bool isUserId = false /* in */ );
 
 
    /* Twitter social graphs APIs */
 
    bool friendsIdsGet( std::string& userInfo /* in */, bool isUserId = false /* in */ );
 
    bool followersIdsGet( std::string& userInfo /* in */, bool isUserId = false /* in */ );
 
 
    /* Twitter account APIs */
 
    bool accountRateLimitGet();
 
    bool accountVerifyCredGet();
 
    /* Twitter favorites APIs */
 
    bool favoriteGet();
 
    bool favoriteCreate( std::string& statusId /* in */ );
 
    bool favoriteDestroy( std::string& statusId /* in */ );
 
 
    /* Twitter block APIs */
 
    bool blockCreate( std::string& userInfo /* in */ );
 
    bool blockDestroy( std::string& userInfo /* in */ );
 
 
    /* Twitter search APIs */
 
    bool savedSearchGet();
 
    bool savedSearchCreate( std::string& query /* in */ );
 
    bool savedSearchShow( std::string& searchId /* in */ );
 
    bool savedSearchDestroy( std::string& searchId /* in */ );
 
 
    /* Twitter trends APIs (JSON) */
 
    bool trendsGet();
 
    bool trendsDailyGet();
 
    bool trendsWeeklyGet();
 
    bool trendsCurrentGet();
 
    bool trendsAvailableGet();
 
 
    /* cURL APIs */
 
    bool isCurlInit();
 
    void getLastWebResponse( std::string& outWebResp /* out */ );
 
    void getLastCurlError( std::string& outErrResp /* out */);
 
 
    /* Internal cURL related methods */
 
    int saveLastWebResponse( char*& data, size_t size );
 
 
    /* cURL proxy APIs */
 
    std::string& getProxyServerIp();
 
    std::string& getProxyServerPort();
 
    std::string& getProxyUserName();
 
    std::string& getProxyPassword();
 
    void setProxyServerIp( std::string& proxyServerIp /* in */ );
 
    void setProxyServerPort( std::string& proxyServerPort /* in */ );
 
    void setProxyUserName( std::string& proxyUserName /* in */ );
 
    void setProxyPassword( std::string& proxyPassword /* in */ );
 
 
private:
 
    /* cURL data */
 
    CURL* m_curlHandle;
 
    char m_errorBuffer[twitCurlDefaults::TWITCURL_DEFAULT_BUFFSIZE];
 
    std::string m_callbackData;
 
 
    /* cURL flags */
 
    bool m_curlProxyParamsSet;
 
    bool m_curlLoginParamsSet;
 
    bool m_curlCallbackParamsSet;
 
 
    /* cURL proxy data */
 
    std::string m_proxyServerIp;
 
    std::string m_proxyServerPort;
 
    std::string m_proxyUserName;
 
    std::string m_proxyPassword;
 
 
    /* Twitter data */
 
    std::string m_twitterUsername;
 
    std::string m_twitterPassword;
 
 
    /* Twitter API type */
 
    twitCurlTypes::eTwitCurlApiFormatType m_eApiFormatType;
 
    twitCurlTypes::eTwitCurlProtocolType m_eProtocolType;
 
 
    /* OAuth data */
 
    oAuth m_oAuth;
 
 
    /* Private methods */
 
    void clearCurlCallbackBuffers();
 
    void prepareCurlProxy();
 
    void prepareCurlCallback();
 
    void prepareCurlUserPass();
 
    void prepareStandardParams();
 
    bool performGet( const std::string& getUrl );
 
    bool performGet( const std::string& getUrl, const std::string& oAuthHttpHeader );
 
    bool performDelete( const std::string& deleteUrl );
 
    bool performPost( const std::string& postUrl, std::string dataStr = "" );
 
 
    /* Internal cURL related methods */
 
    static int curlCallback( char* data, size_t size, size_t nmemb, twitCurl* pTwitCurlObj );
 
};
 
 
 
/* Private functions */
 
void utilMakeCurlParams( std::string& outStr, std::string& inParam1, std::string& inParam2 );
 
void utilMakeUrlForUser( std::string& outUrl, const std::string& baseUrl, std::string& userInfo, bool isUserId );
 
 
#endif // _TWITCURL_H_
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.opt.svn-base
Show inline comments
 
new file 100644
 
binary diff not shown
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.plg.svn-base
Show inline comments
 
new file 100644
 
<html>
 
<body>
 
<pre>
 
<h1>Build Log</h1>
 
<h3>
 
--------------------Configuration: twitcurl - Win32 Release--------------------
 
</h3>
 
<h3>Command Lines</h3>
 
Creating temporary file "C:\DOCUME~1\Mahesh\LOCALS~1\Temp\RSP239.tmp" with contents
 
[
 
/nologo /ML /W3 /GX /O2 /I "./curl" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /Fp"Release/twitcurl.pch" /YX /Fo"Release/" /Fd"Release/" /FD /c 
 
"C:\Projects\twitcurl\base64.cpp"
 
"C:\Projects\twitcurl\HMAC_SHA1.cpp"
 
"C:\Projects\twitcurl\oauthlib.cpp"
 
"C:\Projects\twitcurl\SHA1.cpp"
 
"C:\Projects\twitcurl\twitcurl.cpp"
 
"C:\Projects\twitcurl\urlencode.cpp"
 
]
 
Creating command line "cl.exe @C:\DOCUME~1\Mahesh\LOCALS~1\Temp\RSP239.tmp" 
 
Creating command line "link.exe -lib /nologo /out:"Release\twitcurl.lib"  .\Release\base64.obj .\Release\HMAC_SHA1.obj .\Release\oauthlib.obj .\Release\SHA1.obj .\Release\twitcurl.obj .\Release\urlencode.obj "
 
<h3>Output Window</h3>
 
Compiling...
 
base64.cpp
 
HMAC_SHA1.cpp
 
oauthlib.cpp
 
SHA1.cpp
 
twitcurl.cpp
 
urlencode.cpp
 
Creating library...
 
 
 
 
<h3>Results</h3>
 
twitcurl.lib - 0 error(s), 0 warning(s)
 
</pre>
 
</body>
 
</html>
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.sln.svn-base
Show inline comments
 
new file 100644
 

 
Microsoft Visual Studio Solution File, Format Version 10.00
 
# Visual C++ Express 2008
 
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "twitcurl", "twitcurl.vcproj", "{00175D8C-EA44-48AE-AC59-B3B7BE04E65C}"
 
EndProject
 
Global
 
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 
		Debug|Win32 = Debug|Win32
 
		Release|Win32 = Release|Win32
 
	EndGlobalSection
 
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 
		{00175D8C-EA44-48AE-AC59-B3B7BE04E65C}.Debug|Win32.ActiveCfg = Release|Win32
 
		{00175D8C-EA44-48AE-AC59-B3B7BE04E65C}.Debug|Win32.Build.0 = Release|Win32
 
		{00175D8C-EA44-48AE-AC59-B3B7BE04E65C}.Release|Win32.ActiveCfg = Release|Win32
 
		{00175D8C-EA44-48AE-AC59-B3B7BE04E65C}.Release|Win32.Build.0 = Release|Win32
 
	EndGlobalSection
 
	GlobalSection(SolutionProperties) = preSolution
 
		HideSolutionNode = FALSE
 
	EndGlobalSection
 
EndGlobal
backends/twitter/libtwitcurl/.svn/text-base/twitcurl.vcproj.svn-base
Show inline comments
 
new file 100644
 
<?xml version="1.0" encoding="Windows-1252"?>
 
<VisualStudioProject
 
	ProjectType="Visual C++"
 
	Version="9.00"
 
	Name="twitcurl"
 
	ProjectGUID="{00175D8C-EA44-48AE-AC59-B3B7BE04E65C}"
 
	TargetFrameworkVersion="0"
 
	>
 
	<Platforms>
 
		<Platform
 
			Name="Win32"
 
		/>
 
	</Platforms>
 
	<ToolFiles>
 
	</ToolFiles>
 
	<Configurations>
 
		<Configuration
 
			Name="Debug|Win32"
 
			OutputDirectory=".\Debug"
 
			IntermediateDirectory=".\Debug"
 
			ConfigurationType="4"
 
			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
 
			UseOfMFC="0"
 
			ATLMinimizesCRunTimeLibraryUsage="false"
 
			CharacterSet="2"
 
			>
 
			<Tool
 
				Name="VCPreBuildEventTool"
 
			/>
 
			<Tool
 
				Name="VCCustomBuildTool"
 
			/>
 
			<Tool
 
				Name="VCXMLDataGeneratorTool"
 
			/>
 
			<Tool
 
				Name="VCWebServiceProxyGeneratorTool"
 
			/>
 
			<Tool
 
				Name="VCMIDLTool"
 
			/>
 
			<Tool
 
				Name="VCCLCompilerTool"
 
				Optimization="0"
 
				AdditionalIncludeDirectories="./curl"
 
				PreprocessorDefinitions="WIN32;_DEBUG;_LIB"
 
				MinimalRebuild="true"
 
				BasicRuntimeChecks="3"
 
				RuntimeLibrary="1"
 
				PrecompiledHeaderFile=".\Debug/twitcurl.pch"
 
				AssemblerListingLocation=".\Debug/"
 
				ObjectFile=".\Debug/"
 
				ProgramDataBaseFileName=".\Debug/"
 
				WarningLevel="3"
 
				SuppressStartupBanner="true"
 
				DebugInformationFormat="4"
 
			/>
 
			<Tool
 
				Name="VCManagedResourceCompilerTool"
 
			/>
 
			<Tool
 
				Name="VCResourceCompilerTool"
 
				PreprocessorDefinitions="_DEBUG"
 
				Culture="1033"
 
			/>
 
			<Tool
 
				Name="VCPreLinkEventTool"
 
			/>
 
			<Tool
 
				Name="VCLibrarianTool"
 
				OutputFile=".\Debug\twitcurl.lib"
 
				SuppressStartupBanner="true"
 
			/>
 
			<Tool
 
				Name="VCALinkTool"
 
			/>
 
			<Tool
 
				Name="VCXDCMakeTool"
 
			/>
 
			<Tool
 
				Name="VCBscMakeTool"
 
				SuppressStartupBanner="true"
 
				OutputFile=".\Debug/twitcurl.bsc"
 
			/>
 
			<Tool
 
				Name="VCFxCopTool"
 
			/>
 
			<Tool
 
				Name="VCPostBuildEventTool"
 
			/>
 
		</Configuration>
 
		<Configuration
 
			Name="Release|Win32"
 
			OutputDirectory=".\Release"
 
			IntermediateDirectory=".\Release"
 
			ConfigurationType="4"
 
			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
 
			UseOfMFC="0"
 
			ATLMinimizesCRunTimeLibraryUsage="false"
 
			CharacterSet="2"
 
			>
 
			<Tool
 
				Name="VCPreBuildEventTool"
 
			/>
 
			<Tool
 
				Name="VCCustomBuildTool"
 
			/>
 
			<Tool
 
				Name="VCXMLDataGeneratorTool"
 
			/>
 
			<Tool
 
				Name="VCWebServiceProxyGeneratorTool"
 
			/>
 
			<Tool
 
				Name="VCMIDLTool"
 
			/>
 
			<Tool
 
				Name="VCCLCompilerTool"
 
				Optimization="2"
 
				InlineFunctionExpansion="1"
 
				AdditionalIncludeDirectories="./curl"
 
				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;CURL_STATICLIB"
 
				StringPooling="true"
 
				RuntimeLibrary="2"
 
				EnableFunctionLevelLinking="true"
 
				PrecompiledHeaderFile=".\Release/twitcurl.pch"
 
				AssemblerListingLocation=".\Release/"
 
				ObjectFile=".\Release/"
 
				ProgramDataBaseFileName=".\Release/"
 
				WarningLevel="3"
 
				SuppressStartupBanner="true"
 
			/>
 
			<Tool
 
				Name="VCManagedResourceCompilerTool"
 
			/>
 
			<Tool
 
				Name="VCResourceCompilerTool"
 
				PreprocessorDefinitions="NDEBUG"
 
				Culture="1033"
 
			/>
 
			<Tool
 
				Name="VCPreLinkEventTool"
 
			/>
 
			<Tool
 
				Name="VCLibrarianTool"
 
				LinkLibraryDependencies="true"
 
				AdditionalDependencies="libcurl.lib ws2_32.lib wldap32.lib"
 
				OutputFile=".\Release\twitcurl.lib"
 
				AdditionalLibraryDirectories="./lib"
 
				SuppressStartupBanner="true"
 
			/>
 
			<Tool
 
				Name="VCALinkTool"
 
			/>
 
			<Tool
 
				Name="VCXDCMakeTool"
 
			/>
 
			<Tool
 
				Name="VCBscMakeTool"
 
				SuppressStartupBanner="true"
 
				OutputFile=".\Release/twitcurl.bsc"
 
			/>
 
			<Tool
 
				Name="VCFxCopTool"
 
			/>
 
			<Tool
 
				Name="VCPostBuildEventTool"
 
			/>
 
		</Configuration>
 
	</Configurations>
 
	<References>
 
	</References>
 
	<Files>
 
		<Filter
 
			Name="Source Files"
 
			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
 
			>
 
			<File
 
				RelativePath="base64.cpp"
 
				>
 
				<FileConfiguration
 
					Name="Debug|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
				<FileConfiguration
 
					Name="Release|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
			</File>
 
			<File
 
				RelativePath="HMAC_SHA1.cpp"
 
				>
 
				<FileConfiguration
 
					Name="Debug|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
				<FileConfiguration
 
					Name="Release|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
			</File>
 
			<File
 
				RelativePath="oauthlib.cpp"
 
				>
 
				<FileConfiguration
 
					Name="Debug|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
				<FileConfiguration
 
					Name="Release|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
			</File>
 
			<File
 
				RelativePath="SHA1.cpp"
 
				>
 
				<FileConfiguration
 
					Name="Debug|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
				<FileConfiguration
 
					Name="Release|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
			</File>
 
			<File
 
				RelativePath="twitcurl.cpp"
 
				>
 
				<FileConfiguration
 
					Name="Debug|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
				<FileConfiguration
 
					Name="Release|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
			</File>
 
			<File
 
				RelativePath="urlencode.cpp"
 
				>
 
				<FileConfiguration
 
					Name="Debug|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
				<FileConfiguration
 
					Name="Release|Win32"
 
					>
 
					<Tool
 
						Name="VCCLCompilerTool"
 
						AdditionalIncludeDirectories=""
 
						PreprocessorDefinitions=""
 
					/>
 
				</FileConfiguration>
 
			</File>
 
		</Filter>
 
		<Filter
 
			Name="Header Files"
 
			Filter="h;hpp;hxx;hm;inl"
 
			>
 
			<File
 
				RelativePath="base64.h"
 
				>
 
			</File>
 
			<File
 
				RelativePath="HMAC_SHA1.h"
 
				>
 
			</File>
 
			<File
 
				RelativePath="oauthlib.h"
 
				>
 
			</File>
 
			<File
 
				RelativePath="SHA1.h"
 
				>
 
			</File>
 
			<File
 
				RelativePath="twitcurl.h"
 
				>
 
			</File>
 
			<File
 
				RelativePath="urlencode.h"
 
				>
 
			</File>
 
		</Filter>
 
	</Files>
 
	<Globals>
 
	</Globals>
 
</VisualStudioProject>
backends/twitter/libtwitcurl/.svn/text-base/urlencode.cpp.svn-base
Show inline comments
 
new file 100644
 
#include "urlencode.h"
 
 
std::string char2hex( char dec )
 
{
 
	char dig1 = (dec&0xF0)>>4;
 
	char dig2 = (dec&0x0F);
 
	if ( 0<= dig1 && dig1<= 9) dig1+=48;    //0,48 in ascii
 
	if (10<= dig1 && dig1<=15) dig1+=65-10; //A,65 in ascii
 
	if ( 0<= dig2 && dig2<= 9) dig2+=48;
 
	if (10<= dig2 && dig2<=15) dig2+=65-10;
 
 
    std::string r;
 
	r.append( &dig1, 1);
 
	r.append( &dig2, 1);
 
	return r;
 
}
 
 
std::string urlencode( const std::string &c )
 
{
 
 
    std::string escaped;
 
	int max = c.length();
 
	for(int i=0; i<max; i++)
 
	{
 
		if ( (48 <= c[i] && c[i] <= 57) ||//0-9
 
			(65 <= c[i] && c[i] <= 90) ||//ABC...XYZ
 
			(97 <= c[i] && c[i] <= 122) || //abc...xyz
 
			(c[i]=='~' || c[i]=='-' || c[i]=='_' || c[i]=='.')
 
			)
 
		{
 
			escaped.append( &c[i], 1);
 
		}
 
		else
 
		{
 
			escaped.append("%");
 
			escaped.append( char2hex(c[i]) );//converts char 255 to string "FF"
 
		}
 
	}
 
	return escaped;
 
}
 
\ No newline at end of file
backends/twitter/libtwitcurl/.svn/text-base/urlencode.h.svn-base
Show inline comments
 
new file 100644
 
#ifndef __URLENCODE_H__
 
#define __URLENCODE_H__
 
 
#include <iostream>
 
#include <string>
 
 
std::string char2hex( char dec );
 
std::string urlencode( const std::string &c );
 
 
#endif // __URLENCODE_H__
 
\ No newline at end of file
backends/twitter/libtwitcurl/CMakeLists.txt
Show inline comments
 
new file 100644
 
set(twitSrcs base64.cpp HMAC_SHA1.cpp oauthlib.cpp SHA1.cpp urlencode.cpp twitcurl.cpp)
 
FIND_PACKAGE(PkgConfig)
 
include_directories (${PKGS_INCLUDE_DIRS}) 
 
add_library(twitcurl STATIC ${twitSrcs})
backends/twitter/libtwitcurl/COPYING
Show inline comments
 
new file 100644
 
Copyright (C) 2011 by swatkat (swatkat.thinkdigitATgmailDOTcom)
 

	
 
Permission is hereby granted, free of charge, to any person obtaining a copy
 
of this software and associated documentation files (the "Software"), to deal
 
in the Software without restriction, including without limitation the rights
 
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
copies of the Software, and to permit persons to whom the Software is
 
furnished to do so, subject to the following conditions:
 

	
 
The above copyright notice and this permission notice shall be included in
 
all copies or substantial portions of the Software.
 

	
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
THE SOFTWARE.
 
\ No newline at end of file

Changeset was too big and was cut off... Show full diff anyway

0 comments (0 inline, 0 general)