Merge pull request #11 from sarangbh/twitter-backend

Twitter backend

backends/CMakeLists.txt

@@ -16,6 +16,8 @@ if (PROTOBUF_FOUND)
 # 	endif()
 
 	ADD_SUBDIRECTORY(template)
+	
+	ADD_SUBDIRECTORY(twitter)
 
 if (NOT WIN32)
 	ADD_SUBDIRECTORY(frotz)

backends/twitter/CMakeLists.txt

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,72 @@
+#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

@@ -0,0 +1,37 @@
+#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

@@ -0,0 +1,49 @@
+#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

@@ -0,0 +1,43 @@
+#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

@@ -0,0 +1,32 @@
+#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

@@ -0,0 +1,42 @@
+#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

@@ -0,0 +1,29 @@
+#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

@@ -0,0 +1,43 @@
+#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

@@ -0,0 +1,47 @@
+#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

@@ -0,0 +1,41 @@
+#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

@@ -0,0 +1,21 @@
+#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

@@ -0,0 +1,30 @@
+#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

@@ -0,0 +1,19 @@
+#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

@@ -0,0 +1,39 @@
+#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

@@ -0,0 +1,69 @@
+#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

@@ -0,0 +1,39 @@
+#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

@@ -0,0 +1,24 @@
+#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

@@ -0,0 +1,62 @@
+#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

@@ -0,0 +1,23 @@
+#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

@@ -0,0 +1,40 @@
+#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

@@ -0,0 +1,27 @@
+#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

@@ -0,0 +1,39 @@
+#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

@@ -0,0 +1,29 @@
+#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

@@ -0,0 +1,43 @@
+#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

@@ -0,0 +1,123 @@
+#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

@@ -0,0 +1,74 @@
+#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

@@ -0,0 +1,768 @@
+#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

@@ -0,0 +1,175 @@
+#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

@@ -0,0 +1,230 @@
+#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

@@ -0,0 +1,205 @@
+#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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,748 @@
+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

@@ -0,0 +1,5 @@
+K 13
+svn:mime-type
+V 24
+application/octet-stream
+END

backends/twitter/libtwitcurl/.svn/text-base/CMakeLists.txt.svn-base

@@ -0,0 +1,16 @@
+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) 
+ 

backends/twitter/libtwitcurl/.svn/text-base/COPYING.svn-base

@@ -0,0 +1,19 @@
+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.

backends/twitter/libtwitcurl/.svn/text-base/HMAC_SHA1.cpp.svn-base

@@ -0,0 +1,64 @@
+//******************************************************************************
+//* 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

@@ -0,0 +1,53 @@
+/*
+	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

@@ -0,0 +1,57 @@
+# 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

@@ -0,0 +1,274 @@
+/*
+	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

@@ -0,0 +1,148 @@
+/*
+	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

@@ -0,0 +1,123 @@
+/* 
+   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;
+}

backends/twitter/libtwitcurl/.svn/text-base/base64.h.svn-base

@@ -0,0 +1,4 @@
+#include <string>
+
+std::string base64_encode(unsigned char const* , unsigned int len);
+std::string base64_decode(std::string const& s);

backends/twitter/libtwitcurl/.svn/text-base/oauthlib.cpp.svn-base

@@ -0,0 +1,647 @@
+#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

@@ -0,0 +1,127 @@
+#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__

backends/twitter/libtwitcurl/.svn/text-base/twitcurl.dsp.svn-base

@@ -0,0 +1,140 @@
+# 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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,278 @@
+#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.plg.svn-base

@@ -0,0 +1,37 @@
+<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

@@ -0,0 +1,20 @@
+
+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

@@ -0,0 +1,343 @@
+<?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

@@ -0,0 +1,40 @@
+#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;
+}

backends/twitter/libtwitcurl/.svn/text-base/urlencode.h.svn-base

@@ -0,0 +1,10 @@
+#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__

backends/twitter/libtwitcurl/CMakeLists.txt

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,19 @@
+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.

backends/twitter/libtwitcurl/HMAC_SHA1.cpp

@@ -0,0 +1,64 @@
+//******************************************************************************
+//* 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/HMAC_SHA1.h

@@ -0,0 +1,53 @@
+/*
+	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/SHA1.cpp

@@ -0,0 +1,274 @@
+/*
+	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/SHA1.h

@@ -0,0 +1,148 @@
+/*
+	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/base64.cpp

@@ -0,0 +1,123 @@
+/* 
+   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;
+}

backends/twitter/libtwitcurl/base64.h

@@ -0,0 +1,4 @@
+#include <string>
+
+std::string base64_encode(unsigned char const* , unsigned int len);
+std::string base64_decode(std::string const& s);

backends/twitter/libtwitcurl/curl/.svn/all-wcprops

@@ -0,0 +1,89 @@
+K 25
+svn:wc:ra_dav:version-url
+V 39
+/svn/!svn/ver/69/trunk/libtwitcurl/curl
+END
+stdcheaders.h
+K 25
+svn:wc:ra_dav:version-url
+V 53
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/stdcheaders.h
+END
+typecheck-gcc.h
+K 25
+svn:wc:ra_dav:version-url
+V 55
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/typecheck-gcc.h
+END
+multi.h
+K 25
+svn:wc:ra_dav:version-url
+V 47
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/multi.h
+END
+curlbuild.h.in
+K 25
+svn:wc:ra_dav:version-url
+V 54
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/curlbuild.h.in
+END
+Makefile.in
+K 25
+svn:wc:ra_dav:version-url
+V 51
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/Makefile.in
+END
+mprintf.h
+K 25
+svn:wc:ra_dav:version-url
+V 49
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/mprintf.h
+END
+curlrules.h
+K 25
+svn:wc:ra_dav:version-url
+V 51
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/curlrules.h
+END
+easy.h
+K 25
+svn:wc:ra_dav:version-url
+V 46
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/easy.h
+END
+curlver.h
+K 25
+svn:wc:ra_dav:version-url
+V 49
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/curlver.h
+END
+COPYING
+K 25
+svn:wc:ra_dav:version-url
+V 47
+/svn/!svn/ver/69/trunk/libtwitcurl/curl/COPYING
+END
+Makefile.am
+K 25
+svn:wc:ra_dav:version-url
+V 51
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/Makefile.am
+END
+curlbuild.h.cmake
+K 25
+svn:wc:ra_dav:version-url
+V 57
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/curlbuild.h.cmake
+END
+curl.h
+K 25
+svn:wc:ra_dav:version-url
+V 46
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/curl.h
+END
+curlbuild.h
+K 25
+svn:wc:ra_dav:version-url
+V 51
+/svn/!svn/ver/47/trunk/libtwitcurl/curl/curlbuild.h
+END

backends/twitter/libtwitcurl/curl/.svn/dir-prop-base

@@ -0,0 +1,5 @@
+K 14
+bugtraq:number
+V 4
+true
+END

backends/twitter/libtwitcurl/curl/.svn/entries

@@ -0,0 +1,504 @@
+10
+
+dir
+89
+http://twitcurl.googlecode.com/svn/trunk/libtwitcurl/curl
+http://twitcurl.googlecode.com/svn
+
+
+
+2011-10-21T12:56:45.537942Z
+69
+swatkat.thinkdigit@gmail.com
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+4714a580-958b-11de-ad41-3fcdc5e0e42d
+
+stdcheaders.h
+file
+
+
+
+
+2012-08-04T17:27:11.764011Z
+18c029ed6fdad0ce85ac094ca2841515
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1330
+
+typecheck-gcc.h
+file
+
+
+
+
+2012-08-04T17:27:11.764011Z
+4fcad0343efc2422c8680b961908bce2
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+36048
+
+multi.h
+file
+
+
+
+
+2012-08-04T17:27:11.764011Z
+63dd390e82a97e3115abc2795d9e77ab
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+12981
+
+curlbuild.h.in
+file
+
+
+
+
+2012-08-04T17:27:11.764011Z
+b92790509c83424cee5a386817cf6740
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+6909
+
+Makefile.in
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+43e4606a3ac0c69c38cce656ae34a197
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+17736
+
+mprintf.h
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+aa358cbaa44e19f43cc05ea772d037af
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2790
+
+curlrules.h
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+9e7f8b768255827f9bac344297a1d51f
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+8901
+
+easy.h
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+0bacb9036436a91bf66c007a56a2f9b9
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+3472
+
+curlver.h
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+bc4938b1f18a46bb7acfebd817612564
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2741
+
+COPYING
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+cd35f63043503be099c905fbd7909616
+2011-10-21T12:56:45.537942Z
+69
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1044
+
+Makefile.am
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+c59eb2a9343fbe8a2ec7a112338a70e0
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2181
+
+curlbuild.h.cmake
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+727affc900a378ad3770941e16e262e4
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+6913
+
+curl.h
+file
+
+
+
+
+2012-08-04T17:27:11.766968Z
+4d7a46c03f405ac7c5b08f0e8d2f4d0e
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+81186
+
+curlbuild.h
+file
+
+
+
+
+2012-08-04T17:27:11.770968Z
+b30a8dd73f03df1349ee3098463fe166
+2011-09-12T16:36:56.779736Z
+44
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+22192
+

backends/twitter/libtwitcurl/curl/.svn/text-base/COPYING.svn-base

@@ -0,0 +1,21 @@
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright (c) 1996 - 2011, Daniel Stenberg, <daniel@haxx.se>.
+
+All rights reserved.
+
+Permission to use, copy, modify, and distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright
+notice and this permission notice appear in all copies.
+
+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 OF THIRD PARTY RIGHTS. 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.
+
+Except as contained in this notice, the name of a copyright holder shall not
+be used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization of the copyright holder.

backends/twitter/libtwitcurl/curl/.svn/text-base/Makefile.am.svn-base

@@ -0,0 +1,53 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://curl.haxx.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+###########################################################################
+pkginclude_HEADERS = \
+	curl.h curlver.h easy.h mprintf.h stdcheaders.h multi.h \
+	typecheck-gcc.h curlbuild.h curlrules.h
+
+pkgincludedir= $(includedir)/curl
+
+# curlbuild.h does not exist in the git tree. When the original libcurl
+# source code distribution archive file is created, curlbuild.h.dist is
+# renamed to curlbuild.h and included in the tarball so that it can be
+# used directly on non-configure systems.
+#
+# The distributed curlbuild.h will be overwritten on configure systems
+# when the configure script runs, with one that is suitable and specific
+# to the library being configured and built.
+#
+# curlbuild.h.in is the distributed template file from which the configure
+# script creates curlbuild.h at library configuration time, overwiting the
+# one included in the distribution archive.
+#
+# curlbuild.h.dist is not included in the source code distribution archive.
+
+EXTRA_DIST = curlbuild.h.in
+
+DISTCLEANFILES = curlbuild.h
+
+checksrc:
+	@@PERL@ $(top_srcdir)/lib/checksrc.pl -Wcurlbuild.h -D$(top_srcdir)/include/curl $(pkginclude_HEADERS) $(EXTRA_DIST)
+
+if CURLDEBUG
+# for debug builds, we scan the sources on all regular make invokes
+all-local: checksrc
+endif

backends/twitter/libtwitcurl/curl/.svn/text-base/Makefile.in.svn-base

@@ -0,0 +1,560 @@
+# Makefile.in generated by automake 1.9.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+top_builddir = ../..
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = include/curl
+DIST_COMMON = $(pkginclude_HEADERS) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in $(srcdir)/curlbuild.h.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/curl-compilers.m4 \
+	$(top_srcdir)/m4/curl-confopts.m4 \
+	$(top_srcdir)/m4/curl-functions.m4 \
+	$(top_srcdir)/m4/curl-openssl.m4 \
+	$(top_srcdir)/m4/curl-override.m4 \
+	$(top_srcdir)/m4/curl-reentrant.m4 \
+	$(top_srcdir)/m4/curl-system.m4 $(top_srcdir)/m4/libtool.m4 \
+	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
+	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/lib/curl_config.h \
+	$(top_builddir)/src/curl_config.h curlbuild.h
+CONFIG_CLEAN_FILES =
+SOURCES =
+DIST_SOURCES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
+am__installdirs = "$(DESTDIR)$(pkgincludedir)"
+pkgincludeHEADERS_INSTALL = $(INSTALL_HEADER)
+HEADERS = $(pkginclude_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+pkgincludedir = $(includedir)/curl
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_LIBHOSTNAME_FALSE = @BUILD_LIBHOSTNAME_FALSE@
+BUILD_LIBHOSTNAME_TRUE = @BUILD_LIBHOSTNAME_TRUE@
+BUILD_UNITTESTS_FALSE = @BUILD_UNITTESTS_FALSE@
+BUILD_UNITTESTS_TRUE = @BUILD_UNITTESTS_TRUE@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CONFIGURE_OPTIONS = @CONFIGURE_OPTIONS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CROSSCOMPILING_FALSE = @CROSSCOMPILING_FALSE@
+CROSSCOMPILING_TRUE = @CROSSCOMPILING_TRUE@
+CURLDEBUG_FALSE = @CURLDEBUG_FALSE@
+CURLDEBUG_TRUE = @CURLDEBUG_TRUE@
+CURLVERSION = @CURLVERSION@
+CURL_CA_BUNDLE = @CURL_CA_BUNDLE@
+CURL_CFLAG_EXTRAS = @CURL_CFLAG_EXTRAS@
+CURL_DISABLE_DICT = @CURL_DISABLE_DICT@
+CURL_DISABLE_FILE = @CURL_DISABLE_FILE@
+CURL_DISABLE_FTP = @CURL_DISABLE_FTP@
+CURL_DISABLE_GOPHER = @CURL_DISABLE_GOPHER@
+CURL_DISABLE_HTTP = @CURL_DISABLE_HTTP@
+CURL_DISABLE_IMAP = @CURL_DISABLE_IMAP@
+CURL_DISABLE_LDAP = @CURL_DISABLE_LDAP@
+CURL_DISABLE_LDAPS = @CURL_DISABLE_LDAPS@
+CURL_DISABLE_POP3 = @CURL_DISABLE_POP3@
+CURL_DISABLE_PROXY = @CURL_DISABLE_PROXY@
+CURL_DISABLE_RTSP = @CURL_DISABLE_RTSP@
+CURL_DISABLE_SMTP = @CURL_DISABLE_SMTP@
+CURL_DISABLE_TELNET = @CURL_DISABLE_TELNET@
+CURL_DISABLE_TFTP = @CURL_DISABLE_TFTP@
+CURL_LIBS = @CURL_LIBS@
+CURL_NETWORK_LIBS = @CURL_NETWORK_LIBS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ENABLE_SHARED = @ENABLE_SHARED@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+HAVE_GNUTLS_SRP = @HAVE_GNUTLS_SRP@
+HAVE_LDAP_SSL = @HAVE_LDAP_SSL@
+HAVE_LIBZ = @HAVE_LIBZ@
+HAVE_LIBZ_FALSE = @HAVE_LIBZ_FALSE@
+HAVE_LIBZ_TRUE = @HAVE_LIBZ_TRUE@
+HAVE_PK11_CREATEGENERICOBJECT = @HAVE_PK11_CREATEGENERICOBJECT@
+HAVE_SSLEAY_SRP = @HAVE_SSLEAY_SRP@
+IDN_ENABLED = @IDN_ENABLED@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+IPV6_ENABLED = @IPV6_ENABLED@
+KRB4_ENABLED = @KRB4_ENABLED@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBCURL_LIBS = @LIBCURL_LIBS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MANOPT = @MANOPT@
+MIMPURE_FALSE = @MIMPURE_FALSE@
+MIMPURE_TRUE = @MIMPURE_TRUE@
+NM = @NM@
+NMEDIT = @NMEDIT@
+NO_UNDEFINED_FALSE = @NO_UNDEFINED_FALSE@
+NO_UNDEFINED_TRUE = @NO_UNDEFINED_TRUE@
+NROFF = @NROFF@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH = @PATH@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PERL = @PERL@
+PKGADD_NAME = @PKGADD_NAME@
+PKGADD_PKG = @PKGADD_PKG@
+PKGADD_VENDOR = @PKGADD_VENDOR@
+PKGCONFIG = @PKGCONFIG@
+RANDOM_FILE = @RANDOM_FILE@
+RANLIB = @RANLIB@
+REQUIRE_LIB_DEPS = @REQUIRE_LIB_DEPS@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SONAME_BUMP_FALSE = @SONAME_BUMP_FALSE@
+SONAME_BUMP_TRUE = @SONAME_BUMP_TRUE@
+SSL_ENABLED = @SSL_ENABLED@
+STATICLIB_FALSE = @STATICLIB_FALSE@
+STATICLIB_TRUE = @STATICLIB_TRUE@
+STRIP = @STRIP@
+SUPPORT_FEATURES = @SUPPORT_FEATURES@
+SUPPORT_PROTOCOLS = @SUPPORT_PROTOCOLS@
+TEST_SERVER_LIBS = @TEST_SERVER_LIBS@
+USE_ARES = @USE_ARES@
+USE_AXTLS = @USE_AXTLS@
+USE_CYASSL = @USE_CYASSL@
+USE_EMBEDDED_ARES_FALSE = @USE_EMBEDDED_ARES_FALSE@
+USE_EMBEDDED_ARES_TRUE = @USE_EMBEDDED_ARES_TRUE@
+USE_GNUTLS = @USE_GNUTLS@
+USE_LIBRTMP = @USE_LIBRTMP@
+USE_LIBSSH2 = @USE_LIBSSH2@
+USE_MANUAL_FALSE = @USE_MANUAL_FALSE@
+USE_MANUAL_TRUE = @USE_MANUAL_TRUE@
+USE_NSS = @USE_NSS@
+USE_OPENLDAP = @USE_OPENLDAP@
+USE_POLARSSL = @USE_POLARSSL@
+USE_SSLEAY = @USE_SSLEAY@
+USE_WINDOWS_SSPI = @USE_WINDOWS_SSPI@
+VERSION = @VERSION@
+VERSIONNUM = @VERSIONNUM@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libext = @libext@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://curl.haxx.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+###########################################################################
+pkginclude_HEADERS = \
+	curl.h curlver.h easy.h mprintf.h stdcheaders.h multi.h \
+	typecheck-gcc.h curlbuild.h curlrules.h
+
+
+# curlbuild.h does not exist in the git tree. When the original libcurl
+# source code distribution archive file is created, curlbuild.h.dist is
+# renamed to curlbuild.h and included in the tarball so that it can be
+# used directly on non-configure systems.
+#
+# The distributed curlbuild.h will be overwritten on configure systems
+# when the configure script runs, with one that is suitable and specific
+# to the library being configured and built.
+#
+# curlbuild.h.in is the distributed template file from which the configure
+# script creates curlbuild.h at library configuration time, overwiting the
+# one included in the distribution archive.
+#
+# curlbuild.h.dist is not included in the source code distribution archive.
+EXTRA_DIST = curlbuild.h.in
+DISTCLEANFILES = curlbuild.h
+all: curlbuild.h
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  include/curl/Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign  include/curl/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+curlbuild.h: stamp-h3
+	@if test ! -f $@; then \
+	  rm -f stamp-h3; \
+	  $(MAKE) stamp-h3; \
+	else :; fi
+
+stamp-h3: $(srcdir)/curlbuild.h.in $(top_builddir)/config.status
+	@rm -f stamp-h3
+	cd $(top_builddir) && $(SHELL) ./config.status include/curl/curlbuild.h
+$(srcdir)/curlbuild.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) 
+	cd $(top_srcdir) && $(AUTOHEADER)
+	rm -f stamp-h3
+	touch $@
+
+distclean-hdr:
+	-rm -f curlbuild.h stamp-h3
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+install-pkgincludeHEADERS: $(pkginclude_HEADERS)
+	@$(NORMAL_INSTALL)
+	test -z "$(pkgincludedir)" || $(mkdir_p) "$(DESTDIR)$(pkgincludedir)"
+	@list='$(pkginclude_HEADERS)'; for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  f=$(am__strip_dir) \
+	  echo " $(pkgincludeHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(pkgincludedir)/$$f'"; \
+	  $(pkgincludeHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(pkgincludedir)/$$f"; \
+	done
+
+uninstall-pkgincludeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkginclude_HEADERS)'; for p in $$list; do \
+	  f=$(am__strip_dir) \
+	  echo " rm -f '$(DESTDIR)$(pkgincludedir)/$$f'"; \
+	  rm -f "$(DESTDIR)$(pkgincludedir)/$$f"; \
+	done
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES) curlbuild.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS) curlbuild.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	    $$tags $$unique; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES) curlbuild.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS) curlbuild.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkdir_p) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+@CURLDEBUG_FALSE@all-local:
+all-am: Makefile $(HEADERS) curlbuild.h all-local
+installdirs:
+	for dir in "$(DESTDIR)$(pkgincludedir)"; do \
+	  test -z "$$dir" || $(mkdir_p) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-hdr \
+	distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am: install-pkgincludeHEADERS
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am uninstall-pkgincludeHEADERS
+
+.PHONY: CTAGS GTAGS all all-am all-local check check-am clean \
+	clean-generic clean-libtool ctags distclean distclean-generic \
+	distclean-hdr distclean-libtool distclean-tags distdir dvi \
+	dvi-am html html-am info info-am install install-am \
+	install-data install-data-am install-exec install-exec-am \
+	install-info install-info-am install-man \
+	install-pkgincludeHEADERS install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \
+	uninstall-am uninstall-info-am uninstall-pkgincludeHEADERS
+
+
+checksrc:
+	@@PERL@ $(top_srcdir)/lib/checksrc.pl -Wcurlbuild.h -D$(top_srcdir)/include/curl $(pkginclude_HEADERS) $(EXTRA_DIST)
+
+# for debug builds, we scan the sources on all regular make invokes
+@CURLDEBUG_TRUE@all-local: checksrc
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

backends/twitter/libtwitcurl/curl/.svn/text-base/curlbuild.h.cmake.svn-base

@@ -0,0 +1,180 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.in or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system   */
+/* header file sys/types.h must be included by the external interface. */
+#cmakedefine CURL_PULL_SYS_TYPES_H ${CURL_PULL_SYS_TYPES_H}
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file stdint.h must be included by the external interface.  */
+#cmakedefine CURL_PULL_STDINT_H ${CURL_PULL_STDINT_H}
+#ifdef CURL_PULL_STDINT_H
+#  include <stdint.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file inttypes.h must be included by the external interface. */
+#cmakedefine CURL_PULL_INTTYPES_H ${CURL_PULL_INTTYPES_H}
+#ifdef CURL_PULL_INTTYPES_H
+#  include <inttypes.h>
+#endif
+
+/* The size of `long', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_LONG ${CURL_SIZEOF_LONG}
+
+/* Integral data type used for curl_socklen_t. */
+#cmakedefine CURL_TYPEOF_CURL_SOCKLEN_T ${CURL_TYPEOF_CURL_SOCKLEN_T}
+
+/* on windows socklen_t is in here */
+#ifdef _WIN32
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+
+/* The size of `curl_socklen_t', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_CURL_SOCKLEN_T ${CURL_SIZEOF_CURL_SOCKLEN_T}
+
+/* Signed integral data type used for curl_off_t. */
+#cmakedefine CURL_TYPEOF_CURL_OFF_T ${CURL_TYPEOF_CURL_OFF_T}
+
+/* Data type definition of curl_off_t. */
+typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+
+/* curl_off_t formatting string directive without "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_CURL_OFF_T "${CURL_FORMAT_CURL_OFF_T}"
+
+/* unsigned curl_off_t formatting string without "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_CURL_OFF_TU "${CURL_FORMAT_CURL_OFF_TU}"
+
+/* curl_off_t formatting string directive with "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_OFF_T "${CURL_FORMAT_OFF_T}"
+
+/* The size of `curl_off_t', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_CURL_OFF_T ${CURL_SIZEOF_CURL_OFF_T}
+
+/* curl_off_t constant suffix. */
+#cmakedefine CURL_SUFFIX_CURL_OFF_T ${CURL_SUFFIX_CURL_OFF_T}
+
+/* unsigned curl_off_t constant suffix. */
+#cmakedefine CURL_SUFFIX_CURL_OFF_TU ${CURL_SUFFIX_CURL_OFF_TU}
+
+#endif /* __CURL_CURLBUILD_H */

backends/twitter/libtwitcurl/curl/.svn/text-base/curlbuild.h.in.svn-base

@@ -0,0 +1,190 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.in or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file ws2tcpip.h must be included by the external interface. */
+#undef CURL_PULL_WS2TCPIP_H
+#ifdef CURL_PULL_WS2TCPIP_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system   */
+/* header file sys/types.h must be included by the external interface. */
+#undef CURL_PULL_SYS_TYPES_H
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file stdint.h must be included by the external interface.  */
+#undef CURL_PULL_STDINT_H
+#ifdef CURL_PULL_STDINT_H
+#  include <stdint.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file inttypes.h must be included by the external interface. */
+#undef CURL_PULL_INTTYPES_H
+#ifdef CURL_PULL_INTTYPES_H
+#  include <inttypes.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system    */
+/* header file sys/socket.h must be included by the external interface. */
+#undef CURL_PULL_SYS_SOCKET_H
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* The size of `long', as computed by sizeof. */
+#undef CURL_SIZEOF_LONG
+
+/* Integral data type used for curl_socklen_t. */
+#undef CURL_TYPEOF_CURL_SOCKLEN_T
+
+/* The size of `curl_socklen_t', as computed by sizeof. */
+#undef CURL_SIZEOF_CURL_SOCKLEN_T
+
+/* Data type definition of curl_socklen_t. */
+typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+
+/* Signed integral data type used for curl_off_t. */
+#undef CURL_TYPEOF_CURL_OFF_T
+
+/* Data type definition of curl_off_t. */
+typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+
+/* curl_off_t formatting string directive without "%" conversion specifier. */
+#undef CURL_FORMAT_CURL_OFF_T
+
+/* unsigned curl_off_t formatting string without "%" conversion specifier. */
+#undef CURL_FORMAT_CURL_OFF_TU
+
+/* curl_off_t formatting string directive with "%" conversion specifier. */
+#undef CURL_FORMAT_OFF_T
+
+/* The size of `curl_off_t', as computed by sizeof. */
+#undef CURL_SIZEOF_CURL_OFF_T
+
+/* curl_off_t constant suffix. */
+#undef CURL_SUFFIX_CURL_OFF_T
+
+/* unsigned curl_off_t constant suffix. */
+#undef CURL_SUFFIX_CURL_OFF_TU
+
+#endif /* __CURL_CURLBUILD_H */

backends/twitter/libtwitcurl/curl/.svn/text-base/curlbuild.h.svn-base

@@ -0,0 +1,583 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * See file include/curl/curlbuild.h.in, run configure, and forget
+ * that this file exists it is only used for non-configure systems.
+ * But you can keep reading if you want ;-)
+ *
+ */
+
+/* ================================================================ */
+/*                 NOTES FOR NON-CONFIGURE SYSTEMS                  */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * Try to keep one section per platform, compiler and architecture,
+ * otherwise, if an existing section is reused for a different one and
+ * later on the original is adjusted, probably the piggybacking one can
+ * be adversely changed.
+ *
+ * In order to differentiate between platforms/compilers/architectures
+ * use only compiler built in predefined preprocessor symbols.
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * For any given platform/compiler curl_off_t must be typedef'ed to a
+ * 64-bit wide signed integral data type. The width of this data type
+ * must remain constant and independent of any possible large file
+ * support settings.
+ *
+ * As an exception to the above, curl_off_t shall be typedef'ed to a
+ * 32-bit wide signed integral data type if there is no 64-bit type.
+ *
+ * As a general rule, curl_off_t shall not be mapped to off_t. This
+ * rule shall only be violated if off_t is the only 64-bit data type
+ * available and the size of off_t is independent of large file support
+ * settings. Keep your build on the safe side avoiding an off_t gating.
+ * If you have a 64-bit off_t then take for sure that another 64-bit
+ * data type exists, dig deeper and you will find it.
+ *
+ * NOTE 3:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.dist or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ * file include/curl/curlbuild.h.dist is renamed to include/curl/curlbuild.h
+ * when the libcurl source code distribution archive file is created.
+ *
+ * File include/curl/curlbuild.h.dist is not included in the distribution
+ * archive. File include/curl/curlbuild.h is not present in the git tree.
+ *
+ * The distributed include/curl/curlbuild.h file is only intended to be used
+ * on systems which can not run the also distributed configure script.
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ * If you check out from git on a non-configure platform, you must run the
+ * appropriate buildconf* script to set up curlbuild.h and other local files.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*    EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY    */
+/* ================================================================ */
+
+#if defined(__DJGPP__) || defined(__GO32__)
+#  if defined(__DJGPP__) && (__DJGPP__ > 1)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SALFORDC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__BORLANDC__)
+#  if (__BORLANDC__ < 0x520)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__TURBOC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__WATCOMC__)
+#  if defined(__386__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__POCC__)
+#  if (__POCC__ < 280)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  elif defined(_MSC_VER)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__LCC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SYMBIAN32__)
+#  if defined(__EABI__)  /* Treat all ARM compilers equally */
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__CW32__)
+#    pragma longlong on
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__VC32__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MWERKS__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_FORMAT_OFF_T          "%lld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(_WIN32_WCE)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MINGW32__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__VMS)
+#  if defined(__VAX)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__OS400__)
+#  if defined(__ILEC400__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__MVS__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURL_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURL_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__370__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURL_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURL_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(TPF)
+#  define CURL_SIZEOF_LONG           8
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP MSVC THE PENULTIMATE ENTRY    */
+/* ===================================== */
+
+#elif defined(_MSC_VER)
+#  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP GENERIC GCC THE LAST ENTRY    */
+/* ===================================== */
+
+#elif defined(__GNUC__)
+#  if defined(__i386__) || defined(__ppc__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__x86_64__) || defined(__ppc64__)
+#    define CURL_SIZEOF_LONG           8
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#else
+#  error "Unknown non-configure build target!"
+   Error Compilation_aborted_Unknown_non_configure_build_target
+#endif
+
+/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+  typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+#endif
+
+/* Data type definition of curl_off_t. */
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+  typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+#endif
+
+#endif /* __CURL_CURLBUILD_H */

backends/twitter/libtwitcurl/curl/.svn/text-base/curlrules.h.svn-base

@@ -0,0 +1,261 @@
+#ifndef __CURL_CURLRULES_H
+#define __CURL_CURLRULES_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*                    COMPILE TIME SANITY CHECKS                    */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * All checks done in this file are intentionally placed in a public
+ * header file which is pulled by curl/curl.h when an application is
+ * being built using an already built libcurl library. Additionally
+ * this file is also included and used when building the library.
+ *
+ * If compilation fails on this file it is certainly sure that the
+ * problem is elsewhere. It could be a problem in the curlbuild.h
+ * header file, or simply that you are using different compilation
+ * settings than those used to build the library.
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * Do not deactivate any check, these are done to make sure that the
+ * library is properly built and used.
+ *
+ * You can find further help on the libcurl development mailing list:
+ * http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * NOTE 2
+ * ------
+ *
+ * Some of the following compile time checks are based on the fact
+ * that the dimension of a constant array can not be a negative one.
+ * In this way if the compile time verification fails, the compilation
+ * will fail issuing an error. The error description wording is compiler
+ * dependent but it will be quite similar to one of the following:
+ *
+ *   "negative subscript or subscript is too large"
+ *   "array must have at least one element"
+ *   "-1 is an illegal array size"
+ *   "size of array is negative"
+ *
+ * If you are building an application which tries to use an already
+ * built libcurl library and you are getting this kind of errors on
+ * this file, it is a clear indication that there is a mismatch between
+ * how the library was built and how you are trying to use it for your
+ * application. Your already compiled or binary library provider is the
+ * only one who can give you the details you need to properly use it.
+ */
+
+/*
+ * Verify that some macros are actually defined.
+ */
+
+#ifndef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing
+#endif
+
+#ifndef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU definition is missing!"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing
+#endif
+
+/*
+ * Macros private to this header file.
+ */
+
+#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1
+
+#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
+
+/*
+ * Verify that the size previously defined and expected for long
+ * is the same as the one reported by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_01__
+    [CurlchkszEQ(long, CURL_SIZEOF_LONG)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_off_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_02__
+    [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)];
+
+/*
+ * Verify at compile time that the size of curl_off_t as reported
+ * by sizeof() is greater or equal than the one reported for long
+ * for the current compilation.
+ */
+
+typedef char
+  __curl_rule_03__
+    [CurlchkszGE(curl_off_t, long)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_socklen_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_04__
+    [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)];
+
+/*
+ * Verify at compile time that the size of curl_socklen_t as reported
+ * by sizeof() is greater or equal than the one reported for int for
+ * the current compilation.
+ */
+
+typedef char
+  __curl_rule_05__
+    [CurlchkszGE(curl_socklen_t, int)];
+
+/* ================================================================ */
+/*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
+/* ================================================================ */
+
+/*
+ * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow
+ * these to be visible and exported by the external libcurl interface API,
+ * while also making them visible to the library internals, simply including
+ * setup.h, without actually needing to include curl.h internally.
+ * If some day this section would grow big enough, all this should be moved
+ * to its own header file.
+ */
+
+/*
+ * Figure out if we can use the ## preprocessor operator, which is supported
+ * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__
+ * or  __cplusplus so we need to carefully check for them too.
+ */
+
+#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \
+  defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \
+  defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \
+  defined(__ILEC400__)
+  /* This compiler is believed to have an ISO compatible preprocessor */
+#define CURL_ISOCPP
+#else
+  /* This compiler is believed NOT to have an ISO compatible preprocessor */
+#undef CURL_ISOCPP
+#endif
+
+/*
+ * Macros for minimum-width signed and unsigned curl_off_t integer constants.
+ */
+
+#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551)
+#  define __CURL_OFF_T_C_HLPR2(x) x
+#  define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x)
+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val) ## \
+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \
+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU)
+#else
+#  ifdef CURL_ISOCPP
+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix
+#  else
+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix
+#  endif
+#  define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix)
+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU)
+#endif
+
+/*
+ * Get rid of macros private to this header file.
+ */
+
+#undef CurlchkszEQ
+#undef CurlchkszGE
+
+/*
+ * Get rid of macros not intended to exist beyond this point.
+ */
+
+#undef CURL_PULL_WS2TCPIP_H
+#undef CURL_PULL_SYS_TYPES_H
+#undef CURL_PULL_SYS_SOCKET_H
+#undef CURL_PULL_STDINT_H
+#undef CURL_PULL_INTTYPES_H
+
+#undef CURL_TYPEOF_CURL_SOCKLEN_T
+#undef CURL_TYPEOF_CURL_OFF_T
+
+#ifdef CURL_NO_OLDIES
+#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */
+#endif
+
+#endif /* __CURL_CURLRULES_H */

backends/twitter/libtwitcurl/curl/.svn/text-base/curlver.h.svn-base

@@ -0,0 +1,69 @@
+#ifndef __CURL_CURLVER_H
+#define __CURL_CURLVER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* This header file contains nothing but libcurl version info, generated by
+   a script at release-time. This was made its own header file in 7.11.2 */
+
+/* This is the global package copyright */
+#define LIBCURL_COPYRIGHT "1996 - 2011 Daniel Stenberg, <daniel@haxx.se>."
+
+/* This is the version number of the libcurl package from which this header
+   file origins: */
+#define LIBCURL_VERSION "7.21.7"
+
+/* The numeric version number is also available "in parts" by using these
+   defines: */
+#define LIBCURL_VERSION_MAJOR 7
+#define LIBCURL_VERSION_MINOR 21
+#define LIBCURL_VERSION_PATCH 7
+
+/* This is the numeric version of the libcurl version number, meant for easier
+   parsing and comparions by programs. The LIBCURL_VERSION_NUM define will
+   always follow this syntax:
+
+         0xXXYYZZ
+
+   Where XX, YY and ZZ are the main version, release and patch numbers in
+   hexadecimal (using 8 bits each). All three numbers are always represented
+   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
+   appears as "0x090b07".
+
+   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+   and it is always a greater number in a more recent release. It makes
+   comparisons with greater than and less than work.
+*/
+#define LIBCURL_VERSION_NUM 0x071507
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in git, as the timestamp is properly set in the
+ * tarballs by the maketgz script.
+ *
+ * The format of the date should follow this template:
+ *
+ * "Mon Feb 12 11:35:33 UTC 2007"
+ */
+#define LIBCURL_TIMESTAMP "Thu Jun 23 08:25:34 UTC 2011"
+
+#endif /* __CURL_CURLVER_H */

backends/twitter/libtwitcurl/curl/.svn/text-base/easy.h.svn-base

@@ -0,0 +1,102 @@
+#ifndef __CURL_EASY_H
+#define __CURL_EASY_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN CURL *curl_easy_init(void);
+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
+CURL_EXTERN void curl_easy_cleanup(CURL *curl);
+
+/*
+ * NAME curl_easy_getinfo()
+ *
+ * DESCRIPTION
+ *
+ * Request internal information from the curl session with this function.  The
+ * third argument MUST be a pointer to a long, a pointer to a char * or a
+ * pointer to a double (as the documentation describes elsewhere).  The data
+ * pointed to will be filled in accordingly and can be relied upon only if the
+ * function returns CURLE_OK.  This function is intended to get used *AFTER* a
+ * performed transfer, all results from this function are undefined until the
+ * transfer is completed.
+ */
+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
+
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistent connections cannot
+ * be transferred. It is useful in multithreaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl);
+
+/*
+ * NAME curl_easy_reset()
+ *
+ * DESCRIPTION
+ *
+ * Re-initializes a CURL handle to the default values. This puts back the
+ * handle to the same state as it was in when it was just created.
+ *
+ * It does keep: live connections, the Session ID cache, the DNS cache and the
+ * cookies.
+ */
+CURL_EXTERN void curl_easy_reset(CURL *curl);
+
+/*
+ * NAME curl_easy_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
+                                    size_t *n);
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
+                                    size_t buflen, size_t *n);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

backends/twitter/libtwitcurl/curl/.svn/text-base/mprintf.h.svn-base

@@ -0,0 +1,81 @@
+#ifndef __CURL_MPRINTF_H
+#define __CURL_MPRINTF_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h> /* needed for FILE */
+
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN int curl_mprintf(const char *format, ...);
+CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...);
+CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...);
+CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
+                               const char *format, ...);
+CURL_EXTERN int curl_mvprintf(const char *format, va_list args);
+CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args);
+CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args);
+CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
+                                const char *format, va_list args);
+CURL_EXTERN char *curl_maprintf(const char *format, ...);
+CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
+
+#ifdef _MPRINTF_REPLACE
+# undef printf
+# undef fprintf
+# undef sprintf
+# undef vsprintf
+# undef snprintf
+# undef vprintf
+# undef vfprintf
+# undef vsnprintf
+# undef aprintf
+# undef vaprintf
+# define printf curl_mprintf
+# define fprintf curl_mfprintf
+#ifdef CURLDEBUG
+/* When built with CURLDEBUG we define away the sprintf() functions since we
+   don't want internal code to be using them */
+# define sprintf sprintf_was_used
+# define vsprintf vsprintf_was_used
+#else
+# define sprintf curl_msprintf
+# define vsprintf curl_mvsprintf
+#endif
+# define snprintf curl_msnprintf
+# define vprintf curl_mvprintf
+# define vfprintf curl_mvfprintf
+# define vsnprintf curl_mvsnprintf
+# define aprintf curl_maprintf
+# define vaprintf curl_mvaprintf
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* __CURL_MPRINTF_H */

backends/twitter/libtwitcurl/curl/.svn/text-base/multi.h.svn-base

@@ -0,0 +1,345 @@
+#ifndef __CURL_MULTI_H
+#define __CURL_MULTI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+/*
+  This is an "external" header file. Don't give away any internals here!
+
+  GOALS
+
+  o Enable a "pull" interface. The application that uses libcurl decides where
+    and when to ask libcurl to get/send data.
+
+  o Enable multiple simultaneous transfers in the same thread without making it
+    complicated for the application.
+
+  o Enable the application to select() on its own file descriptors and curl's
+    file descriptors simultaneous easily.
+
+*/
+
+/*
+ * This header file should not really need to include "curl.h" since curl.h
+ * itself includes this file and we expect user applications to do #include
+ * <curl/curl.h> without the need for especially including multi.h.
+ *
+ * For some reason we added this include here at one point, and rather than to
+ * break existing (wrongly written) libcurl applications, we leave it as-is
+ * but with this warning attached.
+ */
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef void CURLM;
+
+typedef enum {
+  CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or
+                                    curl_multi_socket*() soon */
+  CURLM_OK,
+  CURLM_BAD_HANDLE,      /* the passed-in handle is not a valid CURLM handle */
+  CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
+  CURLM_OUT_OF_MEMORY,   /* if you ever get this, you're in deep sh*t */
+  CURLM_INTERNAL_ERROR,  /* this is a libcurl bug */
+  CURLM_BAD_SOCKET,      /* the passed in socket argument did not match */
+  CURLM_UNKNOWN_OPTION,  /* curl_multi_setopt() with unsupported option */
+  CURLM_LAST
+} CURLMcode;
+
+/* just to make code nicer when using curl_multi_socket() you can now check
+   for CURLM_CALL_MULTI_SOCKET too in the same style it works for
+   curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */
+#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM
+
+typedef enum {
+  CURLMSG_NONE, /* first, not used */
+  CURLMSG_DONE, /* This easy handle has completed. 'result' contains
+                   the CURLcode of the transfer */
+  CURLMSG_LAST /* last, not used */
+} CURLMSG;
+
+struct CURLMsg {
+  CURLMSG msg;       /* what this message means */
+  CURL *easy_handle; /* the handle it concerns */
+  union {
+    void *whatever;    /* message-specific data */
+    CURLcode result;   /* return code for transfer */
+  } data;
+};
+typedef struct CURLMsg CURLMsg;
+
+/*
+ * Name:    curl_multi_init()
+ *
+ * Desc:    inititalize multi-style curl usage
+ *
+ * Returns: a new CURLM handle to use in all 'curl_multi' functions.
+ */
+CURL_EXTERN CURLM *curl_multi_init(void);
+
+/*
+ * Name:    curl_multi_add_handle()
+ *
+ * Desc:    add a standard curl handle to the multi stack
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+                                            CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_remove_handle()
+  *
+  * Desc:    removes a curl handle from the multi stack again
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+                                               CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_fdset()
+  *
+  * Desc:    Ask curl for its fd_set sets. The app can use these to select() or
+  *          poll() on. We want curl_multi_perform() called as soon as one of
+  *          them are ready.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
+                                       fd_set *read_fd_set,
+                                       fd_set *write_fd_set,
+                                       fd_set *exc_fd_set,
+                                       int *max_fd);
+
+ /*
+  * Name:    curl_multi_perform()
+  *
+  * Desc:    When the app thinks there's data available for curl it calls this
+  *          function to read/write whatever there is right now. This returns
+  *          as soon as the reads and writes are done. This function does not
+  *          require that there actually is data available for reading or that
+  *          data can be written, it can be called just in case. It returns
+  *          the number of handles that still transfer data in the second
+  *          argument's integer-pointer.
+  *
+  * Returns: CURLMcode type, general multi error code. *NOTE* that this only
+  *          returns errors etc regarding the whole multi stack. There might
+  *          still have occurred problems on invidual transfers even when this
+  *          returns OK.
+  */
+CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
+                                         int *running_handles);
+
+ /*
+  * Name:    curl_multi_cleanup()
+  *
+  * Desc:    Cleans up and removes a whole multi stack. It does not free or
+  *          touch any individual easy handles in any way. We need to define
+  *          in what state those handles will be if this function is called
+  *          in the middle of a transfer.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
+
+/*
+ * Name:    curl_multi_info_read()
+ *
+ * Desc:    Ask the multi handle if there's any messages/informationals from
+ *          the individual transfers. Messages include informationals such as
+ *          error code from the transfer or just the fact that a transfer is
+ *          completed. More details on these should be written down as well.
+ *
+ *          Repeated calls to this function will return a new struct each
+ *          time, until a special "end of msgs" struct is returned as a signal
+ *          that there is no more to get at this point.
+ *
+ *          The data the returned pointer points to will not survive calling
+ *          curl_multi_cleanup().
+ *
+ *          The 'CURLMsg' struct is meant to be very simple and only contain
+ *          very basic informations. If more involved information is wanted,
+ *          we will provide the particular "transfer handle" in that struct
+ *          and that should/could/would be used in subsequent
+ *          curl_easy_getinfo() calls (or similar). The point being that we
+ *          must never expose complex structs to applications, as then we'll
+ *          undoubtably get backwards compatibility problems in the future.
+ *
+ * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
+ *          of structs. It also writes the number of messages left in the
+ *          queue (after this read) in the integer the second argument points
+ *          to.
+ */
+CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
+                                          int *msgs_in_queue);
+
+/*
+ * Name:    curl_multi_strerror()
+ *
+ * Desc:    The curl_multi_strerror function may be used to turn a CURLMcode
+ *          value into the equivalent human readable error string.  This is
+ *          useful for printing meaningful error messages.
+ *
+ * Returns: A pointer to a zero-terminated error message.
+ */
+CURL_EXTERN const char *curl_multi_strerror(CURLMcode);
+
+/*
+ * Name:    curl_multi_socket() and
+ *          curl_multi_socket_all()
+ *
+ * Desc:    An alternative version of curl_multi_perform() that allows the
+ *          application to pass in one of the file descriptors that have been
+ *          detected to have "action" on them and let libcurl perform.
+ *          See man page for details.
+ */
+#define CURL_POLL_NONE   0
+#define CURL_POLL_IN     1
+#define CURL_POLL_OUT    2
+#define CURL_POLL_INOUT  3
+#define CURL_POLL_REMOVE 4
+
+#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD
+
+#define CURL_CSELECT_IN   0x01
+#define CURL_CSELECT_OUT  0x02
+#define CURL_CSELECT_ERR  0x04
+
+typedef int (*curl_socket_callback)(CURL *easy,      /* easy handle */
+                                    curl_socket_t s, /* socket */
+                                    int what,        /* see above */
+                                    void *userp,     /* private callback
+                                                        pointer */
+                                    void *socketp);  /* private socket
+                                                        pointer */
+/*
+ * Name:    curl_multi_timer_callback
+ *
+ * Desc:    Called by libcurl whenever the library detects a change in the
+ *          maximum number of milliseconds the app is allowed to wait before
+ *          curl_multi_socket() or curl_multi_perform() must be called
+ *          (to allow libcurl's timed events to take place).
+ *
+ * Returns: The callback should return zero.
+ */
+typedef int (*curl_multi_timer_callback)(CURLM *multi,    /* multi handle */
+                                         long timeout_ms, /* see above */
+                                         void *userp);    /* private callback
+                                                             pointer */
+
+CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s,
+                                        int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
+                                               curl_socket_t s,
+                                               int ev_bitmask,
+                                               int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle,
+                                            int *running_handles);
+
+#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
+/* This macro below was added in 7.16.3 to push users who recompile to use
+   the new curl_multi_socket_action() instead of the old curl_multi_socket()
+*/
+#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z)
+#endif
+
+/*
+ * Name:    curl_multi_timeout()
+ *
+ * Desc:    Returns the maximum number of milliseconds the app is allowed to
+ *          wait before curl_multi_socket() or curl_multi_perform() must be
+ *          called (to allow libcurl's timed events to take place).
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
+                                         long *milliseconds);
+
+#undef CINIT /* re-using the same name as in curl.h */
+
+#ifdef CURL_ISOCPP
+#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define LONG          CURLOPTTYPE_LONG
+#define OBJECTPOINT   CURLOPTTYPE_OBJECTPOINT
+#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
+#define OFF_T         CURLOPTTYPE_OFF_T
+#define CINIT(name,type,number) CURLMOPT_/**/name = type + number
+#endif
+
+typedef enum {
+  /* This is the socket callback function pointer */
+  CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1),
+
+  /* This is the argument passed to the socket callback */
+  CINIT(SOCKETDATA, OBJECTPOINT, 2),
+
+    /* set to 1 to enable pipelining for this multi handle */
+  CINIT(PIPELINING, LONG, 3),
+
+   /* This is the timer callback function pointer */
+  CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4),
+
+  /* This is the argument passed to the timer callback */
+  CINIT(TIMERDATA, OBJECTPOINT, 5),
+
+  /* maximum number of entries in the connection cache */
+  CINIT(MAXCONNECTS, LONG, 6),
+
+  CURLMOPT_LASTENTRY /* the last unused */
+} CURLMoption;
+
+
+/*
+ * Name:    curl_multi_setopt()
+ *
+ * Desc:    Sets options for the multi handle.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
+                                        CURLMoption option, ...);
+
+
+/*
+ * Name:    curl_multi_assign()
+ *
+ * Desc:    This function sets an association in the multi handle between the
+ *          given socket and a private pointer of the application. This is
+ *          (only) useful for curl_multi_socket uses.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
+                                        curl_socket_t sockfd, void *sockp);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif

backends/twitter/libtwitcurl/curl/.svn/text-base/stdcheaders.h.svn-base

@@ -0,0 +1,33 @@
+#ifndef __STDC_HEADERS_H
+#define __STDC_HEADERS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include <sys/types.h>
+
+size_t fread (void *, size_t, size_t, FILE *);
+size_t fwrite (const void *, size_t, size_t, FILE *);
+
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, size_t);
+
+#endif /* __STDC_HEADERS_H */

backends/twitter/libtwitcurl/curl/.svn/text-base/typecheck-gcc.h.svn-base

@@ -0,0 +1,590 @@
+#ifndef __CURL_TYPECHECK_GCC_H
+#define __CURL_TYPECHECK_GCC_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* wraps curl_easy_setopt() with typechecking */
+
+/* To add a new kind of warning, add an
+ *   if(_curl_is_sometype_option(_curl_opt))
+ *     if(!_curl_is_sometype(value))
+ *       _curl_easy_setopt_err_sometype();
+ * block and define _curl_is_sometype_option, _curl_is_sometype and
+ * _curl_easy_setopt_err_sometype below
+ *
+ * NOTE: We use two nested 'if' statements here instead of the && operator, in
+ *       order to work around gcc bug #32061.  It affects only gcc 4.3.x/4.4.x
+ *       when compiling with -Wlogical-op.
+ *
+ * To add an option that uses the same type as an existing option, you'll just
+ * need to extend the appropriate _curl_*_option macro
+ */
+#define curl_easy_setopt(handle, option, value)                               \
+__extension__ ({                                                              \
+  __typeof__ (option) _curl_opt = option;                                     \
+  if(__builtin_constant_p(_curl_opt)) {                                       \
+    if(_curl_is_long_option(_curl_opt))                                       \
+      if(!_curl_is_long(value))                                               \
+        _curl_easy_setopt_err_long();                                         \
+    if(_curl_is_off_t_option(_curl_opt))                                      \
+      if(!_curl_is_off_t(value))                                              \
+        _curl_easy_setopt_err_curl_off_t();                                   \
+    if(_curl_is_string_option(_curl_opt))                                     \
+      if(!_curl_is_string(value))                                             \
+        _curl_easy_setopt_err_string();                                       \
+    if(_curl_is_write_cb_option(_curl_opt))                                   \
+      if(!_curl_is_write_cb(value))                                           \
+        _curl_easy_setopt_err_write_callback();                               \
+    if((_curl_opt) == CURLOPT_READFUNCTION)                                   \
+      if(!_curl_is_read_cb(value))                                            \
+        _curl_easy_setopt_err_read_cb();                                      \
+    if((_curl_opt) == CURLOPT_IOCTLFUNCTION)                                  \
+      if(!_curl_is_ioctl_cb(value))                                           \
+        _curl_easy_setopt_err_ioctl_cb();                                     \
+    if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION)                                \
+      if(!_curl_is_sockopt_cb(value))                                         \
+        _curl_easy_setopt_err_sockopt_cb();                                   \
+    if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION)                             \
+      if(!_curl_is_opensocket_cb(value))                                      \
+        _curl_easy_setopt_err_opensocket_cb();                                \
+    if((_curl_opt) == CURLOPT_PROGRESSFUNCTION)                               \
+      if(!_curl_is_progress_cb(value))                                        \
+        _curl_easy_setopt_err_progress_cb();                                  \
+    if((_curl_opt) == CURLOPT_DEBUGFUNCTION)                                  \
+      if(!_curl_is_debug_cb(value))                                           \
+        _curl_easy_setopt_err_debug_cb();                                     \
+    if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION)                               \
+      if(!_curl_is_ssl_ctx_cb(value))                                         \
+        _curl_easy_setopt_err_ssl_ctx_cb();                                   \
+    if(_curl_is_conv_cb_option(_curl_opt))                                    \
+      if(!_curl_is_conv_cb(value))                                            \
+        _curl_easy_setopt_err_conv_cb();                                      \
+    if((_curl_opt) == CURLOPT_SEEKFUNCTION)                                   \
+      if(!_curl_is_seek_cb(value))                                            \
+        _curl_easy_setopt_err_seek_cb();                                      \
+    if(_curl_is_cb_data_option(_curl_opt))                                    \
+      if(!_curl_is_cb_data(value))                                            \
+        _curl_easy_setopt_err_cb_data();                                      \
+    if((_curl_opt) == CURLOPT_ERRORBUFFER)                                    \
+      if(!_curl_is_error_buffer(value))                                       \
+        _curl_easy_setopt_err_error_buffer();                                 \
+    if((_curl_opt) == CURLOPT_STDERR)                                         \
+      if(!_curl_is_FILE(value))                                               \
+        _curl_easy_setopt_err_FILE();                                         \
+    if(_curl_is_postfields_option(_curl_opt))                                 \
+      if(!_curl_is_postfields(value))                                         \
+        _curl_easy_setopt_err_postfields();                                   \
+    if((_curl_opt) == CURLOPT_HTTPPOST)                                       \
+      if(!_curl_is_arr((value), struct curl_httppost))                        \
+        _curl_easy_setopt_err_curl_httpost();                                 \
+    if(_curl_is_slist_option(_curl_opt))                                      \
+      if(!_curl_is_arr((value), struct curl_slist))                           \
+        _curl_easy_setopt_err_curl_slist();                                   \
+    if((_curl_opt) == CURLOPT_SHARE)                                          \
+      if(!_curl_is_ptr((value), CURLSH))                                      \
+        _curl_easy_setopt_err_CURLSH();                                       \
+  }                                                                           \
+  curl_easy_setopt(handle, _curl_opt, value);                                 \
+})
+
+/* wraps curl_easy_getinfo() with typechecking */
+/* FIXME: don't allow const pointers */
+#define curl_easy_getinfo(handle, info, arg)                                  \
+__extension__ ({                                                              \
+  __typeof__ (info) _curl_info = info;                                        \
+  if(__builtin_constant_p(_curl_info)) {                                      \
+    if(_curl_is_string_info(_curl_info))                                      \
+      if(!_curl_is_arr((arg), char *))                                        \
+        _curl_easy_getinfo_err_string();                                      \
+    if(_curl_is_long_info(_curl_info))                                        \
+      if(!_curl_is_arr((arg), long))                                          \
+        _curl_easy_getinfo_err_long();                                        \
+    if(_curl_is_double_info(_curl_info))                                      \
+      if(!_curl_is_arr((arg), double))                                        \
+        _curl_easy_getinfo_err_double();                                      \
+    if(_curl_is_slist_info(_curl_info))                                       \
+      if(!_curl_is_arr((arg), struct curl_slist *))                           \
+        _curl_easy_getinfo_err_curl_slist();                                  \
+  }                                                                           \
+  curl_easy_getinfo(handle, _curl_info, arg);                                 \
+})
+
+/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(),
+ * for now just make sure that the functions are called with three
+ * arguments
+ */
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
+
+
+/* the actual warnings, triggered by calling the _curl_easy_setopt_err*
+ * functions */
+
+/* To define a new warning, use _CURL_WARNING(identifier, "message") */
+#define _CURL_WARNING(id, message)                                            \
+  static void __attribute__((warning(message))) __attribute__((unused))       \
+  __attribute__((noinline)) id(void) { __asm__(""); }
+
+_CURL_WARNING(_curl_easy_setopt_err_long,
+  "curl_easy_setopt expects a long argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_off_t,
+  "curl_easy_setopt expects a curl_off_t argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_string,
+              "curl_easy_setopt expects a "
+              "string (char* or char[]) argument for this option"
+  )
+_CURL_WARNING(_curl_easy_setopt_err_write_callback,
+  "curl_easy_setopt expects a curl_write_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_read_cb,
+  "curl_easy_setopt expects a curl_read_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb,
+  "curl_easy_setopt expects a curl_ioctl_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb,
+  "curl_easy_setopt expects a curl_sockopt_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb,
+              "curl_easy_setopt expects a "
+              "curl_opensocket_callback argument for this option"
+  )
+_CURL_WARNING(_curl_easy_setopt_err_progress_cb,
+  "curl_easy_setopt expects a curl_progress_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_debug_cb,
+  "curl_easy_setopt expects a curl_debug_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb,
+  "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_conv_cb,
+  "curl_easy_setopt expects a curl_conv_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_seek_cb,
+  "curl_easy_setopt expects a curl_seek_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_cb_data,
+              "curl_easy_setopt expects a "
+              "private data pointer as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_error_buffer,
+              "curl_easy_setopt expects a "
+              "char buffer of CURL_ERROR_SIZE as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_FILE,
+  "curl_easy_setopt expects a FILE* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_postfields,
+  "curl_easy_setopt expects a void* or char* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_httpost,
+  "curl_easy_setopt expects a struct curl_httppost* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_slist,
+  "curl_easy_setopt expects a struct curl_slist* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_CURLSH,
+  "curl_easy_setopt expects a CURLSH* argument for this option")
+
+_CURL_WARNING(_curl_easy_getinfo_err_string,
+  "curl_easy_getinfo expects a pointer to char * for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_long,
+  "curl_easy_getinfo expects a pointer to long for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_double,
+  "curl_easy_getinfo expects a pointer to double for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_curl_slist,
+  "curl_easy_getinfo expects a pointer to struct curl_slist * for this info")
+
+/* groups of curl_easy_setops options that take the same type of argument */
+
+/* To add a new option to one of the groups, just add
+ *   (option) == CURLOPT_SOMETHING
+ * to the or-expression. If the option takes a long or curl_off_t, you don't
+ * have to do anything
+ */
+
+/* evaluates to true if option takes a long argument */
+#define _curl_is_long_option(option)                                          \
+  (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
+
+#define _curl_is_off_t_option(option)                                         \
+  ((option) > CURLOPTTYPE_OFF_T)
+
+/* evaluates to true if option takes a char* argument */
+#define _curl_is_string_option(option)                                        \
+  ((option) == CURLOPT_URL ||                                                 \
+   (option) == CURLOPT_PROXY ||                                               \
+   (option) == CURLOPT_INTERFACE ||                                           \
+   (option) == CURLOPT_NETRC_FILE ||                                          \
+   (option) == CURLOPT_USERPWD ||                                             \
+   (option) == CURLOPT_USERNAME ||                                            \
+   (option) == CURLOPT_PASSWORD ||                                            \
+   (option) == CURLOPT_PROXYUSERPWD ||                                        \
+   (option) == CURLOPT_PROXYUSERNAME ||                                       \
+   (option) == CURLOPT_PROXYPASSWORD ||                                       \
+   (option) == CURLOPT_NOPROXY ||                                             \
+   (option) == CURLOPT_ACCEPT_ENCODING ||                                     \
+   (option) == CURLOPT_REFERER ||                                             \
+   (option) == CURLOPT_USERAGENT ||                                           \
+   (option) == CURLOPT_COOKIE ||                                              \
+   (option) == CURLOPT_COOKIEFILE ||                                          \
+   (option) == CURLOPT_COOKIEJAR ||                                           \
+   (option) == CURLOPT_COOKIELIST ||                                          \
+   (option) == CURLOPT_FTPPORT ||                                             \
+   (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER ||                             \
+   (option) == CURLOPT_FTP_ACCOUNT ||                                         \
+   (option) == CURLOPT_RANGE ||                                               \
+   (option) == CURLOPT_CUSTOMREQUEST ||                                       \
+   (option) == CURLOPT_SSLCERT ||                                             \
+   (option) == CURLOPT_SSLCERTTYPE ||                                         \
+   (option) == CURLOPT_SSLKEY ||                                              \
+   (option) == CURLOPT_SSLKEYTYPE ||                                          \
+   (option) == CURLOPT_KEYPASSWD ||                                           \
+   (option) == CURLOPT_SSLENGINE ||                                           \
+   (option) == CURLOPT_CAINFO ||                                              \
+   (option) == CURLOPT_CAPATH ||                                              \
+   (option) == CURLOPT_RANDOM_FILE ||                                         \
+   (option) == CURLOPT_EGDSOCKET ||                                           \
+   (option) == CURLOPT_SSL_CIPHER_LIST ||                                     \
+   (option) == CURLOPT_KRBLEVEL ||                                            \
+   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 ||                             \
+   (option) == CURLOPT_SSH_PUBLIC_KEYFILE ||                                  \
+   (option) == CURLOPT_SSH_PRIVATE_KEYFILE ||                                 \
+   (option) == CURLOPT_CRLFILE ||                                             \
+   (option) == CURLOPT_ISSUERCERT ||                                          \
+   (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE ||                               \
+   (option) == CURLOPT_SSH_KNOWNHOSTS ||                                      \
+   (option) == CURLOPT_MAIL_FROM ||                                           \
+   (option) == CURLOPT_RTSP_SESSION_ID ||                                     \
+   (option) == CURLOPT_RTSP_STREAM_URI ||                                     \
+   (option) == CURLOPT_RTSP_TRANSPORT ||                                      \
+   0)
+
+/* evaluates to true if option takes a curl_write_callback argument */
+#define _curl_is_write_cb_option(option)                                      \
+  ((option) == CURLOPT_HEADERFUNCTION ||                                      \
+   (option) == CURLOPT_WRITEFUNCTION)
+
+/* evaluates to true if option takes a curl_conv_callback argument */
+#define _curl_is_conv_cb_option(option)                                       \
+  ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION ||                            \
+   (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION ||                          \
+   (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION)
+
+/* evaluates to true if option takes a data argument to pass to a callback */
+#define _curl_is_cb_data_option(option)                                       \
+  ((option) == CURLOPT_WRITEDATA ||                                           \
+   (option) == CURLOPT_READDATA ||                                            \
+   (option) == CURLOPT_IOCTLDATA ||                                           \
+   (option) == CURLOPT_SOCKOPTDATA ||                                         \
+   (option) == CURLOPT_OPENSOCKETDATA ||                                      \
+   (option) == CURLOPT_PROGRESSDATA ||                                        \
+   (option) == CURLOPT_WRITEHEADER ||                                         \
+   (option) == CURLOPT_DEBUGDATA ||                                           \
+   (option) == CURLOPT_SSL_CTX_DATA ||                                        \
+   (option) == CURLOPT_SEEKDATA ||                                            \
+   (option) == CURLOPT_PRIVATE ||                                             \
+   (option) == CURLOPT_SSH_KEYDATA ||                                         \
+   (option) == CURLOPT_INTERLEAVEDATA ||                                      \
+   (option) == CURLOPT_CHUNK_DATA ||                                          \
+   (option) == CURLOPT_FNMATCH_DATA ||                                        \
+   0)
+
+/* evaluates to true if option takes a POST data argument (void* or char*) */
+#define _curl_is_postfields_option(option)                                    \
+  ((option) == CURLOPT_POSTFIELDS ||                                          \
+   (option) == CURLOPT_COPYPOSTFIELDS ||                                      \
+   0)
+
+/* evaluates to true if option takes a struct curl_slist * argument */
+#define _curl_is_slist_option(option)                                         \
+  ((option) == CURLOPT_HTTPHEADER ||                                          \
+   (option) == CURLOPT_HTTP200ALIASES ||                                      \
+   (option) == CURLOPT_QUOTE ||                                               \
+   (option) == CURLOPT_POSTQUOTE ||                                           \
+   (option) == CURLOPT_PREQUOTE ||                                            \
+   (option) == CURLOPT_TELNETOPTIONS ||                                       \
+   (option) == CURLOPT_MAIL_RCPT ||                                           \
+   0)
+
+/* groups of curl_easy_getinfo infos that take the same type of argument */
+
+/* evaluates to true if info expects a pointer to char * argument */
+#define _curl_is_string_info(info)                                            \
+  (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG)
+
+/* evaluates to true if info expects a pointer to long argument */
+#define _curl_is_long_info(info)                                              \
+  (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE)
+
+/* evaluates to true if info expects a pointer to double argument */
+#define _curl_is_double_info(info)                                            \
+  (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST)
+
+/* true if info expects a pointer to struct curl_slist * argument */
+#define _curl_is_slist_info(info)                                             \
+  (CURLINFO_SLIST < (info))
+
+
+/* typecheck helpers -- check whether given expression has requested type*/
+
+/* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros,
+ * otherwise define a new macro. Search for __builtin_types_compatible_p
+ * in the GCC manual.
+ * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is
+ * the actual expression passed to the curl_easy_setopt macro. This
+ * means that you can only apply the sizeof and __typeof__ operators, no
+ * == or whatsoever.
+ */
+
+/* XXX: should evaluate to true iff expr is a pointer */
+#define _curl_is_any_ptr(expr)                                                \
+  (sizeof(expr) == sizeof(void*))
+
+/* evaluates to true if expr is NULL */
+/* XXX: must not evaluate expr, so this check is not accurate */
+#define _curl_is_NULL(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL)))
+
+/* evaluates to true if expr is type*, const type* or NULL */
+#define _curl_is_ptr(expr, type)                                              \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), type *) ||                  \
+   __builtin_types_compatible_p(__typeof__(expr), const type *))
+
+/* evaluates to true if expr is one of type[], type*, NULL or const type* */
+#define _curl_is_arr(expr, type)                                              \
+  (_curl_is_ptr((expr), type) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), type []))
+
+/* evaluates to true if expr is a string */
+#define _curl_is_string(expr)                                                 \
+  (_curl_is_arr((expr), char) ||                                              \
+   _curl_is_arr((expr), signed char) ||                                       \
+   _curl_is_arr((expr), unsigned char))
+
+/* evaluates to true if expr is a long (no matter the signedness)
+ * XXX: for now, int is also accepted (and therefore short and char, which
+ * are promoted to int when passed to a variadic function) */
+#define _curl_is_long(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), long) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed long) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned long) ||           \
+   __builtin_types_compatible_p(__typeof__(expr), int) ||                     \
+   __builtin_types_compatible_p(__typeof__(expr), signed int) ||              \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned int) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), short) ||                   \
+   __builtin_types_compatible_p(__typeof__(expr), signed short) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned short) ||          \
+   __builtin_types_compatible_p(__typeof__(expr), char) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed char) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned char))
+
+/* evaluates to true if expr is of type curl_off_t */
+#define _curl_is_off_t(expr)                                                  \
+  (__builtin_types_compatible_p(__typeof__(expr), curl_off_t))
+
+/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */
+/* XXX: also check size of an char[] array? */
+#define _curl_is_error_buffer(expr)                                           \
+  (__builtin_types_compatible_p(__typeof__(expr), char *) ||                  \
+   __builtin_types_compatible_p(__typeof__(expr), char[]))
+
+/* evaluates to true if expr is of type (const) void* or (const) FILE* */
+#if 0
+#define _curl_is_cb_data(expr)                                                \
+  (_curl_is_ptr((expr), void) ||                                              \
+   _curl_is_ptr((expr), FILE))
+#else /* be less strict */
+#define _curl_is_cb_data(expr)                                                \
+  _curl_is_any_ptr(expr)
+#endif
+
+/* evaluates to true if expr is of type FILE* */
+#define _curl_is_FILE(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), FILE *))
+
+/* evaluates to true if expr can be passed as POST data (void* or char*) */
+#define _curl_is_postfields(expr)                                             \
+  (_curl_is_ptr((expr), void) ||                                              \
+   _curl_is_arr((expr), char))
+
+/* FIXME: the whole callback checking is messy...
+ * The idea is to tolerate char vs. void and const vs. not const
+ * pointers in arguments at least
+ */
+/* helper: __builtin_types_compatible_p distinguishes between functions and
+ * function pointers, hide it */
+#define _curl_callback_compatible(func, type)                                 \
+  (__builtin_types_compatible_p(__typeof__(func), type) ||                    \
+   __builtin_types_compatible_p(__typeof__(func), type*))
+
+/* evaluates to true if expr is of type curl_read_callback or "similar" */
+#define _curl_is_read_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) ||       \
+   __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) ||      \
+   _curl_callback_compatible((expr), _curl_read_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback2) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback3) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback4) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback5) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback6))
+typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void*);
+typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void*);
+typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE*);
+typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void*);
+typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void*);
+typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE*);
+
+/* evaluates to true if expr is of type curl_write_callback or "similar" */
+#define _curl_is_write_cb(expr)                                               \
+  (_curl_is_read_cb(expr) ||                                            \
+   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) ||      \
+   __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) ||     \
+   _curl_callback_compatible((expr), _curl_write_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback4) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback5) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback6))
+typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void*);
+typedef size_t (_curl_write_callback2)(const char *, size_t, size_t,
+                                       const void*);
+typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE*);
+typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void*);
+typedef size_t (_curl_write_callback5)(const void *, size_t, size_t,
+                                       const void*);
+typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE*);
+
+/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */
+#define _curl_is_ioctl_cb(expr)                                         \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) ||     \
+   _curl_callback_compatible((expr), _curl_ioctl_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback4))
+typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void*);
+typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void*);
+typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void*);
+typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void*);
+
+/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */
+#define _curl_is_sockopt_cb(expr)                                       \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) ||   \
+   _curl_callback_compatible((expr), _curl_sockopt_callback1) ||              \
+   _curl_callback_compatible((expr), _curl_sockopt_callback2))
+typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype);
+typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t,
+                                      curlsocktype);
+
+/* evaluates to true if expr is of type curl_opensocket_callback or
+   "similar" */
+#define _curl_is_opensocket_cb(expr)                                    \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\
+   _curl_callback_compatible((expr), _curl_opensocket_callback1) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback2) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback3) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback4))
+typedef curl_socket_t (_curl_opensocket_callback1)
+  (void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback2)
+  (void *, curlsocktype, const struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback3)
+  (const void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback4)
+  (const void *, curlsocktype, const struct curl_sockaddr *);
+
+/* evaluates to true if expr is of type curl_progress_callback or "similar" */
+#define _curl_is_progress_cb(expr)                                      \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) ||  \
+   _curl_callback_compatible((expr), _curl_progress_callback1) ||             \
+   _curl_callback_compatible((expr), _curl_progress_callback2))
+typedef int (_curl_progress_callback1)(void *,
+    double, double, double, double);
+typedef int (_curl_progress_callback2)(const void *,
+    double, double, double, double);
+
+/* evaluates to true if expr is of type curl_debug_callback or "similar" */
+#define _curl_is_debug_cb(expr)                                         \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) ||     \
+   _curl_callback_compatible((expr), _curl_debug_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback4))
+typedef int (_curl_debug_callback1) (CURL *,
+    curl_infotype, char *, size_t, void *);
+typedef int (_curl_debug_callback2) (CURL *,
+    curl_infotype, char *, size_t, const void *);
+typedef int (_curl_debug_callback3) (CURL *,
+    curl_infotype, const char *, size_t, void *);
+typedef int (_curl_debug_callback4) (CURL *,
+    curl_infotype, const char *, size_t, const void *);
+
+/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */
+/* this is getting even messier... */
+#define _curl_is_ssl_ctx_cb(expr)                                       \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) ||   \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback8))
+typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *);
+#ifdef HEADER_SSL_H
+/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX
+ * this will of course break if we're included before OpenSSL headers...
+ */
+typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX,
+                                           const void *);
+#else
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8;
+#endif
+
+/* evaluates to true if expr is of type curl_conv_callback or "similar" */
+#define _curl_is_conv_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) ||      \
+   _curl_callback_compatible((expr), _curl_conv_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback2) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback3) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback4))
+typedef CURLcode (*_curl_conv_callback1)(char *, size_t length);
+typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length);
+typedef CURLcode (*_curl_conv_callback3)(void *, size_t length);
+typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length);
+
+/* evaluates to true if expr is of type curl_seek_callback or "similar" */
+#define _curl_is_seek_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) ||      \
+   _curl_callback_compatible((expr), _curl_seek_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_seek_callback2))
+typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int);
+typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int);
+
+
+#endif /* __CURL_TYPECHECK_GCC_H */

backends/twitter/libtwitcurl/curl/COPYING

@@ -0,0 +1,21 @@
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright (c) 1996 - 2011, Daniel Stenberg, <daniel@haxx.se>.
+
+All rights reserved.
+
+Permission to use, copy, modify, and distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright
+notice and this permission notice appear in all copies.
+
+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 OF THIRD PARTY RIGHTS. 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.
+
+Except as contained in this notice, the name of a copyright holder shall not
+be used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization of the copyright holder.

backends/twitter/libtwitcurl/curl/Makefile.am

@@ -0,0 +1,53 @@
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://curl.haxx.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+###########################################################################
+pkginclude_HEADERS = \
+	curl.h curlver.h easy.h mprintf.h stdcheaders.h multi.h \
+	typecheck-gcc.h curlbuild.h curlrules.h
+
+pkgincludedir= $(includedir)/curl
+
+# curlbuild.h does not exist in the git tree. When the original libcurl
+# source code distribution archive file is created, curlbuild.h.dist is
+# renamed to curlbuild.h and included in the tarball so that it can be
+# used directly on non-configure systems.
+#
+# The distributed curlbuild.h will be overwritten on configure systems
+# when the configure script runs, with one that is suitable and specific
+# to the library being configured and built.
+#
+# curlbuild.h.in is the distributed template file from which the configure
+# script creates curlbuild.h at library configuration time, overwiting the
+# one included in the distribution archive.
+#
+# curlbuild.h.dist is not included in the source code distribution archive.
+
+EXTRA_DIST = curlbuild.h.in
+
+DISTCLEANFILES = curlbuild.h
+
+checksrc:
+	@@PERL@ $(top_srcdir)/lib/checksrc.pl -Wcurlbuild.h -D$(top_srcdir)/include/curl $(pkginclude_HEADERS) $(EXTRA_DIST)
+
+if CURLDEBUG
+# for debug builds, we scan the sources on all regular make invokes
+all-local: checksrc
+endif

backends/twitter/libtwitcurl/curl/Makefile.in

@@ -0,0 +1,560 @@
+# Makefile.in generated by automake 1.9.6 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005  Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+top_builddir = ../..
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+INSTALL = @INSTALL@
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = include/curl
+DIST_COMMON = $(pkginclude_HEADERS) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in $(srcdir)/curlbuild.h.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/curl-compilers.m4 \
+	$(top_srcdir)/m4/curl-confopts.m4 \
+	$(top_srcdir)/m4/curl-functions.m4 \
+	$(top_srcdir)/m4/curl-openssl.m4 \
+	$(top_srcdir)/m4/curl-override.m4 \
+	$(top_srcdir)/m4/curl-reentrant.m4 \
+	$(top_srcdir)/m4/curl-system.m4 $(top_srcdir)/m4/libtool.m4 \
+	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
+	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/m4/xc-translit.m4 $(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/lib/curl_config.h \
+	$(top_builddir)/src/curl_config.h curlbuild.h
+CONFIG_CLEAN_FILES =
+SOURCES =
+DIST_SOURCES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
+am__installdirs = "$(DESTDIR)$(pkgincludedir)"
+pkgincludeHEADERS_INSTALL = $(INSTALL_HEADER)
+HEADERS = $(pkginclude_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+pkgincludedir = $(includedir)/curl
+ACLOCAL = @ACLOCAL@
+AMDEP_FALSE = @AMDEP_FALSE@
+AMDEP_TRUE = @AMDEP_TRUE@
+AMTAR = @AMTAR@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+BUILD_LIBHOSTNAME_FALSE = @BUILD_LIBHOSTNAME_FALSE@
+BUILD_LIBHOSTNAME_TRUE = @BUILD_LIBHOSTNAME_TRUE@
+BUILD_UNITTESTS_FALSE = @BUILD_UNITTESTS_FALSE@
+BUILD_UNITTESTS_TRUE = @BUILD_UNITTESTS_TRUE@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CONFIGURE_OPTIONS = @CONFIGURE_OPTIONS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CROSSCOMPILING_FALSE = @CROSSCOMPILING_FALSE@
+CROSSCOMPILING_TRUE = @CROSSCOMPILING_TRUE@
+CURLDEBUG_FALSE = @CURLDEBUG_FALSE@
+CURLDEBUG_TRUE = @CURLDEBUG_TRUE@
+CURLVERSION = @CURLVERSION@
+CURL_CA_BUNDLE = @CURL_CA_BUNDLE@
+CURL_CFLAG_EXTRAS = @CURL_CFLAG_EXTRAS@
+CURL_DISABLE_DICT = @CURL_DISABLE_DICT@
+CURL_DISABLE_FILE = @CURL_DISABLE_FILE@
+CURL_DISABLE_FTP = @CURL_DISABLE_FTP@
+CURL_DISABLE_GOPHER = @CURL_DISABLE_GOPHER@
+CURL_DISABLE_HTTP = @CURL_DISABLE_HTTP@
+CURL_DISABLE_IMAP = @CURL_DISABLE_IMAP@
+CURL_DISABLE_LDAP = @CURL_DISABLE_LDAP@
+CURL_DISABLE_LDAPS = @CURL_DISABLE_LDAPS@
+CURL_DISABLE_POP3 = @CURL_DISABLE_POP3@
+CURL_DISABLE_PROXY = @CURL_DISABLE_PROXY@
+CURL_DISABLE_RTSP = @CURL_DISABLE_RTSP@
+CURL_DISABLE_SMTP = @CURL_DISABLE_SMTP@
+CURL_DISABLE_TELNET = @CURL_DISABLE_TELNET@
+CURL_DISABLE_TFTP = @CURL_DISABLE_TFTP@
+CURL_LIBS = @CURL_LIBS@
+CURL_NETWORK_LIBS = @CURL_NETWORK_LIBS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+ENABLE_SHARED = @ENABLE_SHARED@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GREP = @GREP@
+HAVE_GNUTLS_SRP = @HAVE_GNUTLS_SRP@
+HAVE_LDAP_SSL = @HAVE_LDAP_SSL@
+HAVE_LIBZ = @HAVE_LIBZ@
+HAVE_LIBZ_FALSE = @HAVE_LIBZ_FALSE@
+HAVE_LIBZ_TRUE = @HAVE_LIBZ_TRUE@
+HAVE_PK11_CREATEGENERICOBJECT = @HAVE_PK11_CREATEGENERICOBJECT@
+HAVE_SSLEAY_SRP = @HAVE_SSLEAY_SRP@
+IDN_ENABLED = @IDN_ENABLED@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+IPV6_ENABLED = @IPV6_ENABLED@
+KRB4_ENABLED = @KRB4_ENABLED@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBCURL_LIBS = @LIBCURL_LIBS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBOBJS = @LTLIBOBJS@
+MAINT = @MAINT@
+MAINTAINER_MODE_FALSE = @MAINTAINER_MODE_FALSE@
+MAINTAINER_MODE_TRUE = @MAINTAINER_MODE_TRUE@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MANOPT = @MANOPT@
+MIMPURE_FALSE = @MIMPURE_FALSE@
+MIMPURE_TRUE = @MIMPURE_TRUE@
+NM = @NM@
+NMEDIT = @NMEDIT@
+NO_UNDEFINED_FALSE = @NO_UNDEFINED_FALSE@
+NO_UNDEFINED_TRUE = @NO_UNDEFINED_TRUE@
+NROFF = @NROFF@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH = @PATH@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PERL = @PERL@
+PKGADD_NAME = @PKGADD_NAME@
+PKGADD_PKG = @PKGADD_PKG@
+PKGADD_VENDOR = @PKGADD_VENDOR@
+PKGCONFIG = @PKGCONFIG@
+RANDOM_FILE = @RANDOM_FILE@
+RANLIB = @RANLIB@
+REQUIRE_LIB_DEPS = @REQUIRE_LIB_DEPS@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SONAME_BUMP_FALSE = @SONAME_BUMP_FALSE@
+SONAME_BUMP_TRUE = @SONAME_BUMP_TRUE@
+SSL_ENABLED = @SSL_ENABLED@
+STATICLIB_FALSE = @STATICLIB_FALSE@
+STATICLIB_TRUE = @STATICLIB_TRUE@
+STRIP = @STRIP@
+SUPPORT_FEATURES = @SUPPORT_FEATURES@
+SUPPORT_PROTOCOLS = @SUPPORT_PROTOCOLS@
+TEST_SERVER_LIBS = @TEST_SERVER_LIBS@
+USE_ARES = @USE_ARES@
+USE_AXTLS = @USE_AXTLS@
+USE_CYASSL = @USE_CYASSL@
+USE_EMBEDDED_ARES_FALSE = @USE_EMBEDDED_ARES_FALSE@
+USE_EMBEDDED_ARES_TRUE = @USE_EMBEDDED_ARES_TRUE@
+USE_GNUTLS = @USE_GNUTLS@
+USE_LIBRTMP = @USE_LIBRTMP@
+USE_LIBSSH2 = @USE_LIBSSH2@
+USE_MANUAL_FALSE = @USE_MANUAL_FALSE@
+USE_MANUAL_TRUE = @USE_MANUAL_TRUE@
+USE_NSS = @USE_NSS@
+USE_OPENLDAP = @USE_OPENLDAP@
+USE_POLARSSL = @USE_POLARSSL@
+USE_SSLEAY = @USE_SSLEAY@
+USE_WINDOWS_SSPI = @USE_WINDOWS_SSPI@
+VERSION = @VERSION@
+VERSIONNUM = @VERSIONNUM@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
+am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+libext = @libext@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+subdirs = @subdirs@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+
+#***************************************************************************
+#                                  _   _ ____  _
+#  Project                     ___| | | |  _ \| |
+#                             / __| | | | |_) | |
+#                            | (__| |_| |  _ <| |___
+#                             \___|\___/|_| \_\_____|
+#
+# Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+#
+# This software is licensed as described in the file COPYING, which
+# you should have received as part of this distribution. The terms
+# are also available at http://curl.haxx.se/docs/copyright.html.
+#
+# You may opt to use, copy, modify, merge, publish, distribute and/or sell
+# copies of the Software, and permit persons to whom the Software is
+# furnished to do so, under the terms of the COPYING file.
+#
+# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+# KIND, either express or implied.
+#
+###########################################################################
+pkginclude_HEADERS = \
+	curl.h curlver.h easy.h mprintf.h stdcheaders.h multi.h \
+	typecheck-gcc.h curlbuild.h curlrules.h
+
+
+# curlbuild.h does not exist in the git tree. When the original libcurl
+# source code distribution archive file is created, curlbuild.h.dist is
+# renamed to curlbuild.h and included in the tarball so that it can be
+# used directly on non-configure systems.
+#
+# The distributed curlbuild.h will be overwritten on configure systems
+# when the configure script runs, with one that is suitable and specific
+# to the library being configured and built.
+#
+# curlbuild.h.in is the distributed template file from which the configure
+# script creates curlbuild.h at library configuration time, overwiting the
+# one included in the distribution archive.
+#
+# curlbuild.h.dist is not included in the source code distribution archive.
+EXTRA_DIST = curlbuild.h.in
+DISTCLEANFILES = curlbuild.h
+all: curlbuild.h
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
+		&& exit 0; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign  include/curl/Makefile'; \
+	cd $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign  include/curl/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+curlbuild.h: stamp-h3
+	@if test ! -f $@; then \
+	  rm -f stamp-h3; \
+	  $(MAKE) stamp-h3; \
+	else :; fi
+
+stamp-h3: $(srcdir)/curlbuild.h.in $(top_builddir)/config.status
+	@rm -f stamp-h3
+	cd $(top_builddir) && $(SHELL) ./config.status include/curl/curlbuild.h
+$(srcdir)/curlbuild.h.in: @MAINTAINER_MODE_TRUE@ $(am__configure_deps) 
+	cd $(top_srcdir) && $(AUTOHEADER)
+	rm -f stamp-h3
+	touch $@
+
+distclean-hdr:
+	-rm -f curlbuild.h stamp-h3
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+	-rm -f libtool
+uninstall-info-am:
+install-pkgincludeHEADERS: $(pkginclude_HEADERS)
+	@$(NORMAL_INSTALL)
+	test -z "$(pkgincludedir)" || $(mkdir_p) "$(DESTDIR)$(pkgincludedir)"
+	@list='$(pkginclude_HEADERS)'; for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  f=$(am__strip_dir) \
+	  echo " $(pkgincludeHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(pkgincludedir)/$$f'"; \
+	  $(pkgincludeHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(pkgincludedir)/$$f"; \
+	done
+
+uninstall-pkgincludeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(pkginclude_HEADERS)'; for p in $$list; do \
+	  f=$(am__strip_dir) \
+	  echo " rm -f '$(DESTDIR)$(pkgincludedir)/$$f'"; \
+	  rm -f "$(DESTDIR)$(pkgincludedir)/$$f"; \
+	done
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES) curlbuild.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS) curlbuild.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	    $$tags $$unique; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES) curlbuild.h.in $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS) curlbuild.h.in $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(CTAGS_ARGS)$$tags$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$tags $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && cd $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) $$here
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
+	list='$(DISTFILES)'; for file in $$list; do \
+	  case $$file in \
+	    $(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
+	    $(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
+	  esac; \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
+	  if test "$$dir" != "$$file" && test "$$dir" != "."; then \
+	    dir="/$$dir"; \
+	    $(mkdir_p) "$(distdir)$$dir"; \
+	  else \
+	    dir=''; \
+	  fi; \
+	  if test -d $$d/$$file; then \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
+	    fi; \
+	    cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || cp -p $$d/$$file $(distdir)/$$file \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+@CURLDEBUG_FALSE@all-local:
+all-am: Makefile $(HEADERS) curlbuild.h all-local
+installdirs:
+	for dir in "$(DESTDIR)$(pkgincludedir)"; do \
+	  test -z "$$dir" || $(mkdir_p) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic clean-libtool mostlyclean-am
+
+distclean: distclean-am
+	-rm -f Makefile
+distclean-am: clean-am distclean-generic distclean-hdr \
+	distclean-libtool distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+info: info-am
+
+info-am:
+
+install-data-am: install-pkgincludeHEADERS
+
+install-exec-am:
+
+install-info: install-info-am
+
+install-man:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-info-am uninstall-pkgincludeHEADERS
+
+.PHONY: CTAGS GTAGS all all-am all-local check check-am clean \
+	clean-generic clean-libtool ctags distclean distclean-generic \
+	distclean-hdr distclean-libtool distclean-tags distdir dvi \
+	dvi-am html html-am info info-am install install-am \
+	install-data install-data-am install-exec install-exec-am \
+	install-info install-info-am install-man \
+	install-pkgincludeHEADERS install-strip installcheck \
+	installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags uninstall \
+	uninstall-am uninstall-info-am uninstall-pkgincludeHEADERS
+
+
+checksrc:
+	@@PERL@ $(top_srcdir)/lib/checksrc.pl -Wcurlbuild.h -D$(top_srcdir)/include/curl $(pkginclude_HEADERS) $(EXTRA_DIST)
+
+# for debug builds, we scan the sources on all regular make invokes
+@CURLDEBUG_TRUE@all-local: checksrc
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

backends/twitter/libtwitcurl/curl/curlbuild.h

@@ -0,0 +1,583 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * See file include/curl/curlbuild.h.in, run configure, and forget
+ * that this file exists it is only used for non-configure systems.
+ * But you can keep reading if you want ;-)
+ *
+ */
+
+/* ================================================================ */
+/*                 NOTES FOR NON-CONFIGURE SYSTEMS                  */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * Try to keep one section per platform, compiler and architecture,
+ * otherwise, if an existing section is reused for a different one and
+ * later on the original is adjusted, probably the piggybacking one can
+ * be adversely changed.
+ *
+ * In order to differentiate between platforms/compilers/architectures
+ * use only compiler built in predefined preprocessor symbols.
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * For any given platform/compiler curl_off_t must be typedef'ed to a
+ * 64-bit wide signed integral data type. The width of this data type
+ * must remain constant and independent of any possible large file
+ * support settings.
+ *
+ * As an exception to the above, curl_off_t shall be typedef'ed to a
+ * 32-bit wide signed integral data type if there is no 64-bit type.
+ *
+ * As a general rule, curl_off_t shall not be mapped to off_t. This
+ * rule shall only be violated if off_t is the only 64-bit data type
+ * available and the size of off_t is independent of large file support
+ * settings. Keep your build on the safe side avoiding an off_t gating.
+ * If you have a 64-bit off_t then take for sure that another 64-bit
+ * data type exists, dig deeper and you will find it.
+ *
+ * NOTE 3:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.dist or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ * file include/curl/curlbuild.h.dist is renamed to include/curl/curlbuild.h
+ * when the libcurl source code distribution archive file is created.
+ *
+ * File include/curl/curlbuild.h.dist is not included in the distribution
+ * archive. File include/curl/curlbuild.h is not present in the git tree.
+ *
+ * The distributed include/curl/curlbuild.h file is only intended to be used
+ * on systems which can not run the also distributed configure script.
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ * If you check out from git on a non-configure platform, you must run the
+ * appropriate buildconf* script to set up curlbuild.h and other local files.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*    EXTERNAL INTERFACE SETTINGS FOR NON-CONFIGURE SYSTEMS ONLY    */
+/* ================================================================ */
+
+#if defined(__DJGPP__) || defined(__GO32__)
+#  if defined(__DJGPP__) && (__DJGPP__ > 1)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SALFORDC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__BORLANDC__)
+#  if (__BORLANDC__ < 0x520)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__TURBOC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__WATCOMC__)
+#  if defined(__386__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__POCC__)
+#  if (__POCC__ < 280)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  elif defined(_MSC_VER)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__LCC__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     4
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__SYMBIAN32__)
+#  if defined(__EABI__)  /* Treat all ARM compilers equally */
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__CW32__)
+#    pragma longlong on
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__VC32__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MWERKS__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "lld"
+#  define CURL_FORMAT_CURL_OFF_TU    "llu"
+#  define CURL_FORMAT_OFF_T          "%lld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(_WIN32_WCE)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     __int64
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     i64
+#  define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__MINGW32__)
+#  define CURL_SIZEOF_LONG           4
+#  define CURL_TYPEOF_CURL_OFF_T     long long
+#  define CURL_FORMAT_CURL_OFF_T     "I64d"
+#  define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#  define CURL_FORMAT_OFF_T          "%I64d"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     LL
+#  define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__VMS)
+#  if defined(__VAX)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T unsigned int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+#elif defined(__OS400__)
+#  if defined(__ILEC400__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__MVS__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURL_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURL_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(__370__)
+#  if defined(__IBMC__) || defined(__IBMCPP__)
+#    if defined(_ILP32)
+#      define CURL_SIZEOF_LONG           4
+#    elif defined(_LP64)
+#      define CURL_SIZEOF_LONG           8
+#    endif
+#    if defined(_LONG_LONG)
+#      define CURL_TYPEOF_CURL_OFF_T     long long
+#      define CURL_FORMAT_CURL_OFF_T     "lld"
+#      define CURL_FORMAT_CURL_OFF_TU    "llu"
+#      define CURL_FORMAT_OFF_T          "%lld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     LL
+#      define CURL_SUFFIX_CURL_OFF_TU    ULL
+#    elif defined(_LP64)
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     8
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    else
+#      define CURL_TYPEOF_CURL_OFF_T     long
+#      define CURL_FORMAT_CURL_OFF_T     "ld"
+#      define CURL_FORMAT_CURL_OFF_TU    "lu"
+#      define CURL_FORMAT_OFF_T          "%ld"
+#      define CURL_SIZEOF_CURL_OFF_T     4
+#      define CURL_SUFFIX_CURL_OFF_T     L
+#      define CURL_SUFFIX_CURL_OFF_TU    UL
+#    endif
+#    define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#    define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#    define CURL_PULL_SYS_TYPES_H      1
+#    define CURL_PULL_SYS_SOCKET_H     1
+#  endif
+
+#elif defined(TPF)
+#  define CURL_SIZEOF_LONG           8
+#  define CURL_TYPEOF_CURL_OFF_T     long
+#  define CURL_FORMAT_CURL_OFF_T     "ld"
+#  define CURL_FORMAT_CURL_OFF_TU    "lu"
+#  define CURL_FORMAT_OFF_T          "%ld"
+#  define CURL_SIZEOF_CURL_OFF_T     8
+#  define CURL_SUFFIX_CURL_OFF_T     L
+#  define CURL_SUFFIX_CURL_OFF_TU    UL
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP MSVC THE PENULTIMATE ENTRY    */
+/* ===================================== */
+
+#elif defined(_MSC_VER)
+#  if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     __int64
+#    define CURL_FORMAT_CURL_OFF_T     "I64d"
+#    define CURL_FORMAT_CURL_OFF_TU    "I64u"
+#    define CURL_FORMAT_OFF_T          "%I64d"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     i64
+#    define CURL_SUFFIX_CURL_OFF_TU    ui64
+#  else
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     4
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T int
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+
+/* ===================================== */
+/*    KEEP GENERIC GCC THE LAST ENTRY    */
+/* ===================================== */
+
+#elif defined(__GNUC__)
+#  if defined(__i386__) || defined(__ppc__)
+#    define CURL_SIZEOF_LONG           4
+#    define CURL_TYPEOF_CURL_OFF_T     long long
+#    define CURL_FORMAT_CURL_OFF_T     "lld"
+#    define CURL_FORMAT_CURL_OFF_TU    "llu"
+#    define CURL_FORMAT_OFF_T          "%lld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     LL
+#    define CURL_SUFFIX_CURL_OFF_TU    ULL
+#  elif defined(__x86_64__) || defined(__ppc64__)
+#    define CURL_SIZEOF_LONG           8
+#    define CURL_TYPEOF_CURL_OFF_T     long
+#    define CURL_FORMAT_CURL_OFF_T     "ld"
+#    define CURL_FORMAT_CURL_OFF_TU    "lu"
+#    define CURL_FORMAT_OFF_T          "%ld"
+#    define CURL_SIZEOF_CURL_OFF_T     8
+#    define CURL_SUFFIX_CURL_OFF_T     L
+#    define CURL_SUFFIX_CURL_OFF_TU    UL
+#  endif
+#  define CURL_TYPEOF_CURL_SOCKLEN_T socklen_t
+#  define CURL_SIZEOF_CURL_SOCKLEN_T 4
+#  define CURL_PULL_SYS_TYPES_H      1
+#  define CURL_PULL_SYS_SOCKET_H     1
+
+#else
+#  error "Unknown non-configure build target!"
+   Error Compilation_aborted_Unknown_non_configure_build_target
+#endif
+
+/* CURL_PULL_SYS_TYPES_H is defined above when inclusion of header file  */
+/* sys/types.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* CURL_PULL_SYS_SOCKET_H is defined above when inclusion of header file  */
+/* sys/socket.h is required here to properly make type definitions below. */
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+  typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+#endif
+
+/* Data type definition of curl_off_t. */
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+  typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+#endif
+
+#endif /* __CURL_CURLBUILD_H */

backends/twitter/libtwitcurl/curl/curlbuild.h.cmake

@@ -0,0 +1,180 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.in or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system   */
+/* header file sys/types.h must be included by the external interface. */
+#cmakedefine CURL_PULL_SYS_TYPES_H ${CURL_PULL_SYS_TYPES_H}
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file stdint.h must be included by the external interface.  */
+#cmakedefine CURL_PULL_STDINT_H ${CURL_PULL_STDINT_H}
+#ifdef CURL_PULL_STDINT_H
+#  include <stdint.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file inttypes.h must be included by the external interface. */
+#cmakedefine CURL_PULL_INTTYPES_H ${CURL_PULL_INTTYPES_H}
+#ifdef CURL_PULL_INTTYPES_H
+#  include <inttypes.h>
+#endif
+
+/* The size of `long', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_LONG ${CURL_SIZEOF_LONG}
+
+/* Integral data type used for curl_socklen_t. */
+#cmakedefine CURL_TYPEOF_CURL_SOCKLEN_T ${CURL_TYPEOF_CURL_SOCKLEN_T}
+
+/* on windows socklen_t is in here */
+#ifdef _WIN32
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* Data type definition of curl_socklen_t. */
+typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+
+/* The size of `curl_socklen_t', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_CURL_SOCKLEN_T ${CURL_SIZEOF_CURL_SOCKLEN_T}
+
+/* Signed integral data type used for curl_off_t. */
+#cmakedefine CURL_TYPEOF_CURL_OFF_T ${CURL_TYPEOF_CURL_OFF_T}
+
+/* Data type definition of curl_off_t. */
+typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+
+/* curl_off_t formatting string directive without "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_CURL_OFF_T "${CURL_FORMAT_CURL_OFF_T}"
+
+/* unsigned curl_off_t formatting string without "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_CURL_OFF_TU "${CURL_FORMAT_CURL_OFF_TU}"
+
+/* curl_off_t formatting string directive with "%" conversion specifier. */
+#cmakedefine CURL_FORMAT_OFF_T "${CURL_FORMAT_OFF_T}"
+
+/* The size of `curl_off_t', as computed by sizeof. */
+#cmakedefine CURL_SIZEOF_CURL_OFF_T ${CURL_SIZEOF_CURL_OFF_T}
+
+/* curl_off_t constant suffix. */
+#cmakedefine CURL_SUFFIX_CURL_OFF_T ${CURL_SUFFIX_CURL_OFF_T}
+
+/* unsigned curl_off_t constant suffix. */
+#cmakedefine CURL_SUFFIX_CURL_OFF_TU ${CURL_SUFFIX_CURL_OFF_TU}
+
+#endif /* __CURL_CURLBUILD_H */

backends/twitter/libtwitcurl/curl/curlbuild.h.in

@@ -0,0 +1,190 @@
+#ifndef __CURL_CURLBUILD_H
+#define __CURL_CURLBUILD_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*               NOTES FOR CONFIGURE CAPABLE SYSTEMS                */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * If you think that something actually needs to be changed, adjusted
+ * or fixed in this file, then, report it on the libcurl development
+ * mailing list: http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * This header file shall only export symbols which are 'curl' or 'CURL'
+ * prefixed, otherwise public name space would be polluted.
+ *
+ * NOTE 2:
+ * -------
+ *
+ * Right now you might be staring at file include/curl/curlbuild.h.in or
+ * at file include/curl/curlbuild.h, this is due to the following reason:
+ *
+ * On systems capable of running the configure script, the configure process
+ * will overwrite the distributed include/curl/curlbuild.h file with one that
+ * is suitable and specific to the library being configured and built, which
+ * is generated from the include/curl/curlbuild.h.in template file.
+ *
+ */
+
+/* ================================================================ */
+/*  DEFINITION OF THESE SYMBOLS SHALL NOT TAKE PLACE ANYWHERE ELSE  */
+/* ================================================================ */
+
+#ifdef CURL_SIZEOF_LONG
+#error "CURL_SIZEOF_LONG shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_SOCKLEN_T
+#error "CURL_TYPEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_SOCKLEN_T
+#error "CURL_SIZEOF_CURL_SOCKLEN_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_already_defined
+#endif
+
+#ifdef CURL_TYPEOF_CURL_OFF_T
+#error "CURL_TYPEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_T
+#error "CURL_FORMAT_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_FORMAT_CURL_OFF_TU
+#error "CURL_FORMAT_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_already_defined
+#endif
+
+#ifdef CURL_FORMAT_OFF_T
+#error "CURL_FORMAT_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SIZEOF_CURL_OFF_T
+#error "CURL_SIZEOF_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_T
+#error "CURL_SUFFIX_CURL_OFF_T shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_already_defined
+#endif
+
+#ifdef CURL_SUFFIX_CURL_OFF_TU
+#error "CURL_SUFFIX_CURL_OFF_TU shall not be defined except in curlbuild.h"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_already_defined
+#endif
+
+/* ================================================================ */
+/*  EXTERNAL INTERFACE SETTINGS FOR CONFIGURE CAPABLE SYSTEMS ONLY  */
+/* ================================================================ */
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file ws2tcpip.h must be included by the external interface. */
+#undef CURL_PULL_WS2TCPIP_H
+#ifdef CURL_PULL_WS2TCPIP_H
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system   */
+/* header file sys/types.h must be included by the external interface. */
+#undef CURL_PULL_SYS_TYPES_H
+#ifdef CURL_PULL_SYS_TYPES_H
+#  include <sys/types.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system */
+/* header file stdint.h must be included by the external interface.  */
+#undef CURL_PULL_STDINT_H
+#ifdef CURL_PULL_STDINT_H
+#  include <stdint.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system  */
+/* header file inttypes.h must be included by the external interface. */
+#undef CURL_PULL_INTTYPES_H
+#ifdef CURL_PULL_INTTYPES_H
+#  include <inttypes.h>
+#endif
+
+/* Configure process defines this to 1 when it finds out that system    */
+/* header file sys/socket.h must be included by the external interface. */
+#undef CURL_PULL_SYS_SOCKET_H
+#ifdef CURL_PULL_SYS_SOCKET_H
+#  include <sys/socket.h>
+#endif
+
+/* The size of `long', as computed by sizeof. */
+#undef CURL_SIZEOF_LONG
+
+/* Integral data type used for curl_socklen_t. */
+#undef CURL_TYPEOF_CURL_SOCKLEN_T
+
+/* The size of `curl_socklen_t', as computed by sizeof. */
+#undef CURL_SIZEOF_CURL_SOCKLEN_T
+
+/* Data type definition of curl_socklen_t. */
+typedef CURL_TYPEOF_CURL_SOCKLEN_T curl_socklen_t;
+
+/* Signed integral data type used for curl_off_t. */
+#undef CURL_TYPEOF_CURL_OFF_T
+
+/* Data type definition of curl_off_t. */
+typedef CURL_TYPEOF_CURL_OFF_T curl_off_t;
+
+/* curl_off_t formatting string directive without "%" conversion specifier. */
+#undef CURL_FORMAT_CURL_OFF_T
+
+/* unsigned curl_off_t formatting string without "%" conversion specifier. */
+#undef CURL_FORMAT_CURL_OFF_TU
+
+/* curl_off_t formatting string directive with "%" conversion specifier. */
+#undef CURL_FORMAT_OFF_T
+
+/* The size of `curl_off_t', as computed by sizeof. */
+#undef CURL_SIZEOF_CURL_OFF_T
+
+/* curl_off_t constant suffix. */
+#undef CURL_SUFFIX_CURL_OFF_T
+
+/* unsigned curl_off_t constant suffix. */
+#undef CURL_SUFFIX_CURL_OFF_TU
+
+#endif /* __CURL_CURLBUILD_H */

backends/twitter/libtwitcurl/curl/curlrules.h

@@ -0,0 +1,261 @@
+#ifndef __CURL_CURLRULES_H
+#define __CURL_CURLRULES_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* ================================================================ */
+/*                    COMPILE TIME SANITY CHECKS                    */
+/* ================================================================ */
+
+/*
+ * NOTE 1:
+ * -------
+ *
+ * All checks done in this file are intentionally placed in a public
+ * header file which is pulled by curl/curl.h when an application is
+ * being built using an already built libcurl library. Additionally
+ * this file is also included and used when building the library.
+ *
+ * If compilation fails on this file it is certainly sure that the
+ * problem is elsewhere. It could be a problem in the curlbuild.h
+ * header file, or simply that you are using different compilation
+ * settings than those used to build the library.
+ *
+ * Nothing in this file is intended to be modified or adjusted by the
+ * curl library user nor by the curl library builder.
+ *
+ * Do not deactivate any check, these are done to make sure that the
+ * library is properly built and used.
+ *
+ * You can find further help on the libcurl development mailing list:
+ * http://cool.haxx.se/mailman/listinfo/curl-library/
+ *
+ * NOTE 2
+ * ------
+ *
+ * Some of the following compile time checks are based on the fact
+ * that the dimension of a constant array can not be a negative one.
+ * In this way if the compile time verification fails, the compilation
+ * will fail issuing an error. The error description wording is compiler
+ * dependent but it will be quite similar to one of the following:
+ *
+ *   "negative subscript or subscript is too large"
+ *   "array must have at least one element"
+ *   "-1 is an illegal array size"
+ *   "size of array is negative"
+ *
+ * If you are building an application which tries to use an already
+ * built libcurl library and you are getting this kind of errors on
+ * this file, it is a clear indication that there is a mismatch between
+ * how the library was built and how you are trying to use it for your
+ * application. Your already compiled or binary library provider is the
+ * only one who can give you the details you need to properly use it.
+ */
+
+/*
+ * Verify that some macros are actually defined.
+ */
+
+#ifndef CURL_SIZEOF_LONG
+#  error "CURL_SIZEOF_LONG definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_LONG_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_SOCKLEN_T
+#  error "CURL_TYPEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_SOCKLEN_T
+#  error "CURL_SIZEOF_CURL_SOCKLEN_T definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_SOCKLEN_T_is_missing
+#endif
+
+#ifndef CURL_TYPEOF_CURL_OFF_T
+#  error "CURL_TYPEOF_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_TYPEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_T
+#  error "CURL_FORMAT_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_FORMAT_CURL_OFF_TU
+#  error "CURL_FORMAT_CURL_OFF_TU definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_CURL_OFF_TU_is_missing
+#endif
+
+#ifndef CURL_FORMAT_OFF_T
+#  error "CURL_FORMAT_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_FORMAT_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SIZEOF_CURL_OFF_T
+#  error "CURL_SIZEOF_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_SIZEOF_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_T
+#  error "CURL_SUFFIX_CURL_OFF_T definition is missing!"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_T_is_missing
+#endif
+
+#ifndef CURL_SUFFIX_CURL_OFF_TU
+#  error "CURL_SUFFIX_CURL_OFF_TU definition is missing!"
+   Error Compilation_aborted_CURL_SUFFIX_CURL_OFF_TU_is_missing
+#endif
+
+/*
+ * Macros private to this header file.
+ */
+
+#define CurlchkszEQ(t, s) sizeof(t) == s ? 1 : -1
+
+#define CurlchkszGE(t1, t2) sizeof(t1) >= sizeof(t2) ? 1 : -1
+
+/*
+ * Verify that the size previously defined and expected for long
+ * is the same as the one reported by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_01__
+    [CurlchkszEQ(long, CURL_SIZEOF_LONG)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_off_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_02__
+    [CurlchkszEQ(curl_off_t, CURL_SIZEOF_CURL_OFF_T)];
+
+/*
+ * Verify at compile time that the size of curl_off_t as reported
+ * by sizeof() is greater or equal than the one reported for long
+ * for the current compilation.
+ */
+
+typedef char
+  __curl_rule_03__
+    [CurlchkszGE(curl_off_t, long)];
+
+/*
+ * Verify that the size previously defined and expected for
+ * curl_socklen_t is actually the the same as the one reported
+ * by sizeof() at compile time.
+ */
+
+typedef char
+  __curl_rule_04__
+    [CurlchkszEQ(curl_socklen_t, CURL_SIZEOF_CURL_SOCKLEN_T)];
+
+/*
+ * Verify at compile time that the size of curl_socklen_t as reported
+ * by sizeof() is greater or equal than the one reported for int for
+ * the current compilation.
+ */
+
+typedef char
+  __curl_rule_05__
+    [CurlchkszGE(curl_socklen_t, int)];
+
+/* ================================================================ */
+/*          EXTERNALLY AND INTERNALLY VISIBLE DEFINITIONS           */
+/* ================================================================ */
+
+/*
+ * CURL_ISOCPP and CURL_OFF_T_C definitions are done here in order to allow
+ * these to be visible and exported by the external libcurl interface API,
+ * while also making them visible to the library internals, simply including
+ * setup.h, without actually needing to include curl.h internally.
+ * If some day this section would grow big enough, all this should be moved
+ * to its own header file.
+ */
+
+/*
+ * Figure out if we can use the ## preprocessor operator, which is supported
+ * by ISO/ANSI C and C++. Some compilers support it without setting __STDC__
+ * or  __cplusplus so we need to carefully check for them too.
+ */
+
+#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) || \
+  defined(__HP_aCC) || defined(__BORLANDC__) || defined(__LCC__) || \
+  defined(__POCC__) || defined(__SALFORDC__) || defined(__HIGHC__) || \
+  defined(__ILEC400__)
+  /* This compiler is believed to have an ISO compatible preprocessor */
+#define CURL_ISOCPP
+#else
+  /* This compiler is believed NOT to have an ISO compatible preprocessor */
+#undef CURL_ISOCPP
+#endif
+
+/*
+ * Macros for minimum-width signed and unsigned curl_off_t integer constants.
+ */
+
+#if defined(__BORLANDC__) && (__BORLANDC__ == 0x0551)
+#  define __CURL_OFF_T_C_HLPR2(x) x
+#  define __CURL_OFF_T_C_HLPR1(x) __CURL_OFF_T_C_HLPR2(x)
+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val) ## \
+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val) ## \
+                             __CURL_OFF_T_C_HLPR1(CURL_SUFFIX_CURL_OFF_TU)
+#else
+#  ifdef CURL_ISOCPP
+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val ## Suffix
+#  else
+#    define __CURL_OFF_T_C_HLPR2(Val,Suffix) Val/**/Suffix
+#  endif
+#  define __CURL_OFF_T_C_HLPR1(Val,Suffix) __CURL_OFF_T_C_HLPR2(Val,Suffix)
+#  define CURL_OFF_T_C(Val)  __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_T)
+#  define CURL_OFF_TU_C(Val) __CURL_OFF_T_C_HLPR1(Val,CURL_SUFFIX_CURL_OFF_TU)
+#endif
+
+/*
+ * Get rid of macros private to this header file.
+ */
+
+#undef CurlchkszEQ
+#undef CurlchkszGE
+
+/*
+ * Get rid of macros not intended to exist beyond this point.
+ */
+
+#undef CURL_PULL_WS2TCPIP_H
+#undef CURL_PULL_SYS_TYPES_H
+#undef CURL_PULL_SYS_SOCKET_H
+#undef CURL_PULL_STDINT_H
+#undef CURL_PULL_INTTYPES_H
+
+#undef CURL_TYPEOF_CURL_SOCKLEN_T
+#undef CURL_TYPEOF_CURL_OFF_T
+
+#ifdef CURL_NO_OLDIES
+#undef CURL_FORMAT_OFF_T /* not required since 7.19.0 - obsoleted in 7.20.0 */
+#endif
+
+#endif /* __CURL_CURLRULES_H */

backends/twitter/libtwitcurl/curl/curlver.h

@@ -0,0 +1,69 @@
+#ifndef __CURL_CURLVER_H
+#define __CURL_CURLVER_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* This header file contains nothing but libcurl version info, generated by
+   a script at release-time. This was made its own header file in 7.11.2 */
+
+/* This is the global package copyright */
+#define LIBCURL_COPYRIGHT "1996 - 2011 Daniel Stenberg, <daniel@haxx.se>."
+
+/* This is the version number of the libcurl package from which this header
+   file origins: */
+#define LIBCURL_VERSION "7.21.7"
+
+/* The numeric version number is also available "in parts" by using these
+   defines: */
+#define LIBCURL_VERSION_MAJOR 7
+#define LIBCURL_VERSION_MINOR 21
+#define LIBCURL_VERSION_PATCH 7
+
+/* This is the numeric version of the libcurl version number, meant for easier
+   parsing and comparions by programs. The LIBCURL_VERSION_NUM define will
+   always follow this syntax:
+
+         0xXXYYZZ
+
+   Where XX, YY and ZZ are the main version, release and patch numbers in
+   hexadecimal (using 8 bits each). All three numbers are always represented
+   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
+   appears as "0x090b07".
+
+   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+   and it is always a greater number in a more recent release. It makes
+   comparisons with greater than and less than work.
+*/
+#define LIBCURL_VERSION_NUM 0x071507
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in git, as the timestamp is properly set in the
+ * tarballs by the maketgz script.
+ *
+ * The format of the date should follow this template:
+ *
+ * "Mon Feb 12 11:35:33 UTC 2007"
+ */
+#define LIBCURL_TIMESTAMP "Thu Jun 23 08:25:34 UTC 2011"
+
+#endif /* __CURL_CURLVER_H */

backends/twitter/libtwitcurl/curl/easy.h

@@ -0,0 +1,102 @@
+#ifndef __CURL_EASY_H
+#define __CURL_EASY_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN CURL *curl_easy_init(void);
+CURL_EXTERN CURLcode curl_easy_setopt(CURL *curl, CURLoption option, ...);
+CURL_EXTERN CURLcode curl_easy_perform(CURL *curl);
+CURL_EXTERN void curl_easy_cleanup(CURL *curl);
+
+/*
+ * NAME curl_easy_getinfo()
+ *
+ * DESCRIPTION
+ *
+ * Request internal information from the curl session with this function.  The
+ * third argument MUST be a pointer to a long, a pointer to a char * or a
+ * pointer to a double (as the documentation describes elsewhere).  The data
+ * pointed to will be filled in accordingly and can be relied upon only if the
+ * function returns CURLE_OK.  This function is intended to get used *AFTER* a
+ * performed transfer, all results from this function are undefined until the
+ * transfer is completed.
+ */
+CURL_EXTERN CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...);
+
+
+/*
+ * NAME curl_easy_duphandle()
+ *
+ * DESCRIPTION
+ *
+ * Creates a new curl session handle with the same options set for the handle
+ * passed in. Duplicating a handle could only be a matter of cloning data and
+ * options, internal state info and things like persistent connections cannot
+ * be transferred. It is useful in multithreaded applications when you can run
+ * curl_easy_duphandle() for each new thread to avoid a series of identical
+ * curl_easy_setopt() invokes in every thread.
+ */
+CURL_EXTERN CURL* curl_easy_duphandle(CURL *curl);
+
+/*
+ * NAME curl_easy_reset()
+ *
+ * DESCRIPTION
+ *
+ * Re-initializes a CURL handle to the default values. This puts back the
+ * handle to the same state as it was in when it was just created.
+ *
+ * It does keep: live connections, the Session ID cache, the DNS cache and the
+ * cookies.
+ */
+CURL_EXTERN void curl_easy_reset(CURL *curl);
+
+/*
+ * NAME curl_easy_recv()
+ *
+ * DESCRIPTION
+ *
+ * Receives data from the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_recv(CURL *curl, void *buffer, size_t buflen,
+                                    size_t *n);
+
+/*
+ * NAME curl_easy_send()
+ *
+ * DESCRIPTION
+ *
+ * Sends data over the connected socket. Use after successful
+ * curl_easy_perform() with CURLOPT_CONNECT_ONLY option.
+ */
+CURL_EXTERN CURLcode curl_easy_send(CURL *curl, const void *buffer,
+                                    size_t buflen, size_t *n);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

backends/twitter/libtwitcurl/curl/mprintf.h

@@ -0,0 +1,81 @@
+#ifndef __CURL_MPRINTF_H
+#define __CURL_MPRINTF_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include <stdarg.h>
+#include <stdio.h> /* needed for FILE */
+
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+CURL_EXTERN int curl_mprintf(const char *format, ...);
+CURL_EXTERN int curl_mfprintf(FILE *fd, const char *format, ...);
+CURL_EXTERN int curl_msprintf(char *buffer, const char *format, ...);
+CURL_EXTERN int curl_msnprintf(char *buffer, size_t maxlength,
+                               const char *format, ...);
+CURL_EXTERN int curl_mvprintf(const char *format, va_list args);
+CURL_EXTERN int curl_mvfprintf(FILE *fd, const char *format, va_list args);
+CURL_EXTERN int curl_mvsprintf(char *buffer, const char *format, va_list args);
+CURL_EXTERN int curl_mvsnprintf(char *buffer, size_t maxlength,
+                                const char *format, va_list args);
+CURL_EXTERN char *curl_maprintf(const char *format, ...);
+CURL_EXTERN char *curl_mvaprintf(const char *format, va_list args);
+
+#ifdef _MPRINTF_REPLACE
+# undef printf
+# undef fprintf
+# undef sprintf
+# undef vsprintf
+# undef snprintf
+# undef vprintf
+# undef vfprintf
+# undef vsnprintf
+# undef aprintf
+# undef vaprintf
+# define printf curl_mprintf
+# define fprintf curl_mfprintf
+#ifdef CURLDEBUG
+/* When built with CURLDEBUG we define away the sprintf() functions since we
+   don't want internal code to be using them */
+# define sprintf sprintf_was_used
+# define vsprintf vsprintf_was_used
+#else
+# define sprintf curl_msprintf
+# define vsprintf curl_mvsprintf
+#endif
+# define snprintf curl_msnprintf
+# define vprintf curl_mvprintf
+# define vfprintf curl_mvfprintf
+# define vsnprintf curl_mvsnprintf
+# define aprintf curl_maprintf
+# define vaprintf curl_mvaprintf
+#endif
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif /* __CURL_MPRINTF_H */

backends/twitter/libtwitcurl/curl/multi.h

@@ -0,0 +1,345 @@
+#ifndef __CURL_MULTI_H
+#define __CURL_MULTI_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+/*
+  This is an "external" header file. Don't give away any internals here!
+
+  GOALS
+
+  o Enable a "pull" interface. The application that uses libcurl decides where
+    and when to ask libcurl to get/send data.
+
+  o Enable multiple simultaneous transfers in the same thread without making it
+    complicated for the application.
+
+  o Enable the application to select() on its own file descriptors and curl's
+    file descriptors simultaneous easily.
+
+*/
+
+/*
+ * This header file should not really need to include "curl.h" since curl.h
+ * itself includes this file and we expect user applications to do #include
+ * <curl/curl.h> without the need for especially including multi.h.
+ *
+ * For some reason we added this include here at one point, and rather than to
+ * break existing (wrongly written) libcurl applications, we leave it as-is
+ * but with this warning attached.
+ */
+#include "curl.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef void CURLM;
+
+typedef enum {
+  CURLM_CALL_MULTI_PERFORM = -1, /* please call curl_multi_perform() or
+                                    curl_multi_socket*() soon */
+  CURLM_OK,
+  CURLM_BAD_HANDLE,      /* the passed-in handle is not a valid CURLM handle */
+  CURLM_BAD_EASY_HANDLE, /* an easy handle was not good/valid */
+  CURLM_OUT_OF_MEMORY,   /* if you ever get this, you're in deep sh*t */
+  CURLM_INTERNAL_ERROR,  /* this is a libcurl bug */
+  CURLM_BAD_SOCKET,      /* the passed in socket argument did not match */
+  CURLM_UNKNOWN_OPTION,  /* curl_multi_setopt() with unsupported option */
+  CURLM_LAST
+} CURLMcode;
+
+/* just to make code nicer when using curl_multi_socket() you can now check
+   for CURLM_CALL_MULTI_SOCKET too in the same style it works for
+   curl_multi_perform() and CURLM_CALL_MULTI_PERFORM */
+#define CURLM_CALL_MULTI_SOCKET CURLM_CALL_MULTI_PERFORM
+
+typedef enum {
+  CURLMSG_NONE, /* first, not used */
+  CURLMSG_DONE, /* This easy handle has completed. 'result' contains
+                   the CURLcode of the transfer */
+  CURLMSG_LAST /* last, not used */
+} CURLMSG;
+
+struct CURLMsg {
+  CURLMSG msg;       /* what this message means */
+  CURL *easy_handle; /* the handle it concerns */
+  union {
+    void *whatever;    /* message-specific data */
+    CURLcode result;   /* return code for transfer */
+  } data;
+};
+typedef struct CURLMsg CURLMsg;
+
+/*
+ * Name:    curl_multi_init()
+ *
+ * Desc:    inititalize multi-style curl usage
+ *
+ * Returns: a new CURLM handle to use in all 'curl_multi' functions.
+ */
+CURL_EXTERN CURLM *curl_multi_init(void);
+
+/*
+ * Name:    curl_multi_add_handle()
+ *
+ * Desc:    add a standard curl handle to the multi stack
+ *
+ * Returns: CURLMcode type, general multi error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_add_handle(CURLM *multi_handle,
+                                            CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_remove_handle()
+  *
+  * Desc:    removes a curl handle from the multi stack again
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_remove_handle(CURLM *multi_handle,
+                                               CURL *curl_handle);
+
+ /*
+  * Name:    curl_multi_fdset()
+  *
+  * Desc:    Ask curl for its fd_set sets. The app can use these to select() or
+  *          poll() on. We want curl_multi_perform() called as soon as one of
+  *          them are ready.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_fdset(CURLM *multi_handle,
+                                       fd_set *read_fd_set,
+                                       fd_set *write_fd_set,
+                                       fd_set *exc_fd_set,
+                                       int *max_fd);
+
+ /*
+  * Name:    curl_multi_perform()
+  *
+  * Desc:    When the app thinks there's data available for curl it calls this
+  *          function to read/write whatever there is right now. This returns
+  *          as soon as the reads and writes are done. This function does not
+  *          require that there actually is data available for reading or that
+  *          data can be written, it can be called just in case. It returns
+  *          the number of handles that still transfer data in the second
+  *          argument's integer-pointer.
+  *
+  * Returns: CURLMcode type, general multi error code. *NOTE* that this only
+  *          returns errors etc regarding the whole multi stack. There might
+  *          still have occurred problems on invidual transfers even when this
+  *          returns OK.
+  */
+CURL_EXTERN CURLMcode curl_multi_perform(CURLM *multi_handle,
+                                         int *running_handles);
+
+ /*
+  * Name:    curl_multi_cleanup()
+  *
+  * Desc:    Cleans up and removes a whole multi stack. It does not free or
+  *          touch any individual easy handles in any way. We need to define
+  *          in what state those handles will be if this function is called
+  *          in the middle of a transfer.
+  *
+  * Returns: CURLMcode type, general multi error code.
+  */
+CURL_EXTERN CURLMcode curl_multi_cleanup(CURLM *multi_handle);
+
+/*
+ * Name:    curl_multi_info_read()
+ *
+ * Desc:    Ask the multi handle if there's any messages/informationals from
+ *          the individual transfers. Messages include informationals such as
+ *          error code from the transfer or just the fact that a transfer is
+ *          completed. More details on these should be written down as well.
+ *
+ *          Repeated calls to this function will return a new struct each
+ *          time, until a special "end of msgs" struct is returned as a signal
+ *          that there is no more to get at this point.
+ *
+ *          The data the returned pointer points to will not survive calling
+ *          curl_multi_cleanup().
+ *
+ *          The 'CURLMsg' struct is meant to be very simple and only contain
+ *          very basic informations. If more involved information is wanted,
+ *          we will provide the particular "transfer handle" in that struct
+ *          and that should/could/would be used in subsequent
+ *          curl_easy_getinfo() calls (or similar). The point being that we
+ *          must never expose complex structs to applications, as then we'll
+ *          undoubtably get backwards compatibility problems in the future.
+ *
+ * Returns: A pointer to a filled-in struct, or NULL if it failed or ran out
+ *          of structs. It also writes the number of messages left in the
+ *          queue (after this read) in the integer the second argument points
+ *          to.
+ */
+CURL_EXTERN CURLMsg *curl_multi_info_read(CURLM *multi_handle,
+                                          int *msgs_in_queue);
+
+/*
+ * Name:    curl_multi_strerror()
+ *
+ * Desc:    The curl_multi_strerror function may be used to turn a CURLMcode
+ *          value into the equivalent human readable error string.  This is
+ *          useful for printing meaningful error messages.
+ *
+ * Returns: A pointer to a zero-terminated error message.
+ */
+CURL_EXTERN const char *curl_multi_strerror(CURLMcode);
+
+/*
+ * Name:    curl_multi_socket() and
+ *          curl_multi_socket_all()
+ *
+ * Desc:    An alternative version of curl_multi_perform() that allows the
+ *          application to pass in one of the file descriptors that have been
+ *          detected to have "action" on them and let libcurl perform.
+ *          See man page for details.
+ */
+#define CURL_POLL_NONE   0
+#define CURL_POLL_IN     1
+#define CURL_POLL_OUT    2
+#define CURL_POLL_INOUT  3
+#define CURL_POLL_REMOVE 4
+
+#define CURL_SOCKET_TIMEOUT CURL_SOCKET_BAD
+
+#define CURL_CSELECT_IN   0x01
+#define CURL_CSELECT_OUT  0x02
+#define CURL_CSELECT_ERR  0x04
+
+typedef int (*curl_socket_callback)(CURL *easy,      /* easy handle */
+                                    curl_socket_t s, /* socket */
+                                    int what,        /* see above */
+                                    void *userp,     /* private callback
+                                                        pointer */
+                                    void *socketp);  /* private socket
+                                                        pointer */
+/*
+ * Name:    curl_multi_timer_callback
+ *
+ * Desc:    Called by libcurl whenever the library detects a change in the
+ *          maximum number of milliseconds the app is allowed to wait before
+ *          curl_multi_socket() or curl_multi_perform() must be called
+ *          (to allow libcurl's timed events to take place).
+ *
+ * Returns: The callback should return zero.
+ */
+typedef int (*curl_multi_timer_callback)(CURLM *multi,    /* multi handle */
+                                         long timeout_ms, /* see above */
+                                         void *userp);    /* private callback
+                                                             pointer */
+
+CURL_EXTERN CURLMcode curl_multi_socket(CURLM *multi_handle, curl_socket_t s,
+                                        int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_action(CURLM *multi_handle,
+                                               curl_socket_t s,
+                                               int ev_bitmask,
+                                               int *running_handles);
+
+CURL_EXTERN CURLMcode curl_multi_socket_all(CURLM *multi_handle,
+                                            int *running_handles);
+
+#ifndef CURL_ALLOW_OLD_MULTI_SOCKET
+/* This macro below was added in 7.16.3 to push users who recompile to use
+   the new curl_multi_socket_action() instead of the old curl_multi_socket()
+*/
+#define curl_multi_socket(x,y,z) curl_multi_socket_action(x,y,0,z)
+#endif
+
+/*
+ * Name:    curl_multi_timeout()
+ *
+ * Desc:    Returns the maximum number of milliseconds the app is allowed to
+ *          wait before curl_multi_socket() or curl_multi_perform() must be
+ *          called (to allow libcurl's timed events to take place).
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_timeout(CURLM *multi_handle,
+                                         long *milliseconds);
+
+#undef CINIT /* re-using the same name as in curl.h */
+
+#ifdef CURL_ISOCPP
+#define CINIT(name,type,num) CURLMOPT_ ## name = CURLOPTTYPE_ ## type + num
+#else
+/* The macro "##" is ISO C, we assume pre-ISO C doesn't support it. */
+#define LONG          CURLOPTTYPE_LONG
+#define OBJECTPOINT   CURLOPTTYPE_OBJECTPOINT
+#define FUNCTIONPOINT CURLOPTTYPE_FUNCTIONPOINT
+#define OFF_T         CURLOPTTYPE_OFF_T
+#define CINIT(name,type,number) CURLMOPT_/**/name = type + number
+#endif
+
+typedef enum {
+  /* This is the socket callback function pointer */
+  CINIT(SOCKETFUNCTION, FUNCTIONPOINT, 1),
+
+  /* This is the argument passed to the socket callback */
+  CINIT(SOCKETDATA, OBJECTPOINT, 2),
+
+    /* set to 1 to enable pipelining for this multi handle */
+  CINIT(PIPELINING, LONG, 3),
+
+   /* This is the timer callback function pointer */
+  CINIT(TIMERFUNCTION, FUNCTIONPOINT, 4),
+
+  /* This is the argument passed to the timer callback */
+  CINIT(TIMERDATA, OBJECTPOINT, 5),
+
+  /* maximum number of entries in the connection cache */
+  CINIT(MAXCONNECTS, LONG, 6),
+
+  CURLMOPT_LASTENTRY /* the last unused */
+} CURLMoption;
+
+
+/*
+ * Name:    curl_multi_setopt()
+ *
+ * Desc:    Sets options for the multi handle.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_setopt(CURLM *multi_handle,
+                                        CURLMoption option, ...);
+
+
+/*
+ * Name:    curl_multi_assign()
+ *
+ * Desc:    This function sets an association in the multi handle between the
+ *          given socket and a private pointer of the application. This is
+ *          (only) useful for curl_multi_socket uses.
+ *
+ * Returns: CURLM error code.
+ */
+CURL_EXTERN CURLMcode curl_multi_assign(CURLM *multi_handle,
+                                        curl_socket_t sockfd, void *sockp);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif

backends/twitter/libtwitcurl/curl/stdcheaders.h

@@ -0,0 +1,33 @@
+#ifndef __STDC_HEADERS_H
+#define __STDC_HEADERS_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2010, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+#include <sys/types.h>
+
+size_t fread (void *, size_t, size_t, FILE *);
+size_t fwrite (const void *, size_t, size_t, FILE *);
+
+int strcasecmp(const char *, const char *);
+int strncasecmp(const char *, const char *, size_t);
+
+#endif /* __STDC_HEADERS_H */

backends/twitter/libtwitcurl/curl/typecheck-gcc.h

@@ -0,0 +1,590 @@
+#ifndef __CURL_TYPECHECK_GCC_H
+#define __CURL_TYPECHECK_GCC_H
+/***************************************************************************
+ *                                  _   _ ____  _
+ *  Project                     ___| | | |  _ \| |
+ *                             / __| | | | |_) | |
+ *                            | (__| |_| |  _ <| |___
+ *                             \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2011, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at http://curl.haxx.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ***************************************************************************/
+
+/* wraps curl_easy_setopt() with typechecking */
+
+/* To add a new kind of warning, add an
+ *   if(_curl_is_sometype_option(_curl_opt))
+ *     if(!_curl_is_sometype(value))
+ *       _curl_easy_setopt_err_sometype();
+ * block and define _curl_is_sometype_option, _curl_is_sometype and
+ * _curl_easy_setopt_err_sometype below
+ *
+ * NOTE: We use two nested 'if' statements here instead of the && operator, in
+ *       order to work around gcc bug #32061.  It affects only gcc 4.3.x/4.4.x
+ *       when compiling with -Wlogical-op.
+ *
+ * To add an option that uses the same type as an existing option, you'll just
+ * need to extend the appropriate _curl_*_option macro
+ */
+#define curl_easy_setopt(handle, option, value)                               \
+__extension__ ({                                                              \
+  __typeof__ (option) _curl_opt = option;                                     \
+  if(__builtin_constant_p(_curl_opt)) {                                       \
+    if(_curl_is_long_option(_curl_opt))                                       \
+      if(!_curl_is_long(value))                                               \
+        _curl_easy_setopt_err_long();                                         \
+    if(_curl_is_off_t_option(_curl_opt))                                      \
+      if(!_curl_is_off_t(value))                                              \
+        _curl_easy_setopt_err_curl_off_t();                                   \
+    if(_curl_is_string_option(_curl_opt))                                     \
+      if(!_curl_is_string(value))                                             \
+        _curl_easy_setopt_err_string();                                       \
+    if(_curl_is_write_cb_option(_curl_opt))                                   \
+      if(!_curl_is_write_cb(value))                                           \
+        _curl_easy_setopt_err_write_callback();                               \
+    if((_curl_opt) == CURLOPT_READFUNCTION)                                   \
+      if(!_curl_is_read_cb(value))                                            \
+        _curl_easy_setopt_err_read_cb();                                      \
+    if((_curl_opt) == CURLOPT_IOCTLFUNCTION)                                  \
+      if(!_curl_is_ioctl_cb(value))                                           \
+        _curl_easy_setopt_err_ioctl_cb();                                     \
+    if((_curl_opt) == CURLOPT_SOCKOPTFUNCTION)                                \
+      if(!_curl_is_sockopt_cb(value))                                         \
+        _curl_easy_setopt_err_sockopt_cb();                                   \
+    if((_curl_opt) == CURLOPT_OPENSOCKETFUNCTION)                             \
+      if(!_curl_is_opensocket_cb(value))                                      \
+        _curl_easy_setopt_err_opensocket_cb();                                \
+    if((_curl_opt) == CURLOPT_PROGRESSFUNCTION)                               \
+      if(!_curl_is_progress_cb(value))                                        \
+        _curl_easy_setopt_err_progress_cb();                                  \
+    if((_curl_opt) == CURLOPT_DEBUGFUNCTION)                                  \
+      if(!_curl_is_debug_cb(value))                                           \
+        _curl_easy_setopt_err_debug_cb();                                     \
+    if((_curl_opt) == CURLOPT_SSL_CTX_FUNCTION)                               \
+      if(!_curl_is_ssl_ctx_cb(value))                                         \
+        _curl_easy_setopt_err_ssl_ctx_cb();                                   \
+    if(_curl_is_conv_cb_option(_curl_opt))                                    \
+      if(!_curl_is_conv_cb(value))                                            \
+        _curl_easy_setopt_err_conv_cb();                                      \
+    if((_curl_opt) == CURLOPT_SEEKFUNCTION)                                   \
+      if(!_curl_is_seek_cb(value))                                            \
+        _curl_easy_setopt_err_seek_cb();                                      \
+    if(_curl_is_cb_data_option(_curl_opt))                                    \
+      if(!_curl_is_cb_data(value))                                            \
+        _curl_easy_setopt_err_cb_data();                                      \
+    if((_curl_opt) == CURLOPT_ERRORBUFFER)                                    \
+      if(!_curl_is_error_buffer(value))                                       \
+        _curl_easy_setopt_err_error_buffer();                                 \
+    if((_curl_opt) == CURLOPT_STDERR)                                         \
+      if(!_curl_is_FILE(value))                                               \
+        _curl_easy_setopt_err_FILE();                                         \
+    if(_curl_is_postfields_option(_curl_opt))                                 \
+      if(!_curl_is_postfields(value))                                         \
+        _curl_easy_setopt_err_postfields();                                   \
+    if((_curl_opt) == CURLOPT_HTTPPOST)                                       \
+      if(!_curl_is_arr((value), struct curl_httppost))                        \
+        _curl_easy_setopt_err_curl_httpost();                                 \
+    if(_curl_is_slist_option(_curl_opt))                                      \
+      if(!_curl_is_arr((value), struct curl_slist))                           \
+        _curl_easy_setopt_err_curl_slist();                                   \
+    if((_curl_opt) == CURLOPT_SHARE)                                          \
+      if(!_curl_is_ptr((value), CURLSH))                                      \
+        _curl_easy_setopt_err_CURLSH();                                       \
+  }                                                                           \
+  curl_easy_setopt(handle, _curl_opt, value);                                 \
+})
+
+/* wraps curl_easy_getinfo() with typechecking */
+/* FIXME: don't allow const pointers */
+#define curl_easy_getinfo(handle, info, arg)                                  \
+__extension__ ({                                                              \
+  __typeof__ (info) _curl_info = info;                                        \
+  if(__builtin_constant_p(_curl_info)) {                                      \
+    if(_curl_is_string_info(_curl_info))                                      \
+      if(!_curl_is_arr((arg), char *))                                        \
+        _curl_easy_getinfo_err_string();                                      \
+    if(_curl_is_long_info(_curl_info))                                        \
+      if(!_curl_is_arr((arg), long))                                          \
+        _curl_easy_getinfo_err_long();                                        \
+    if(_curl_is_double_info(_curl_info))                                      \
+      if(!_curl_is_arr((arg), double))                                        \
+        _curl_easy_getinfo_err_double();                                      \
+    if(_curl_is_slist_info(_curl_info))                                       \
+      if(!_curl_is_arr((arg), struct curl_slist *))                           \
+        _curl_easy_getinfo_err_curl_slist();                                  \
+  }                                                                           \
+  curl_easy_getinfo(handle, _curl_info, arg);                                 \
+})
+
+/* TODO: typechecking for curl_share_setopt() and curl_multi_setopt(),
+ * for now just make sure that the functions are called with three
+ * arguments
+ */
+#define curl_share_setopt(share,opt,param) curl_share_setopt(share,opt,param)
+#define curl_multi_setopt(handle,opt,param) curl_multi_setopt(handle,opt,param)
+
+
+/* the actual warnings, triggered by calling the _curl_easy_setopt_err*
+ * functions */
+
+/* To define a new warning, use _CURL_WARNING(identifier, "message") */
+#define _CURL_WARNING(id, message)                                            \
+  static void __attribute__((warning(message))) __attribute__((unused))       \
+  __attribute__((noinline)) id(void) { __asm__(""); }
+
+_CURL_WARNING(_curl_easy_setopt_err_long,
+  "curl_easy_setopt expects a long argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_off_t,
+  "curl_easy_setopt expects a curl_off_t argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_string,
+              "curl_easy_setopt expects a "
+              "string (char* or char[]) argument for this option"
+  )
+_CURL_WARNING(_curl_easy_setopt_err_write_callback,
+  "curl_easy_setopt expects a curl_write_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_read_cb,
+  "curl_easy_setopt expects a curl_read_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ioctl_cb,
+  "curl_easy_setopt expects a curl_ioctl_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_sockopt_cb,
+  "curl_easy_setopt expects a curl_sockopt_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_opensocket_cb,
+              "curl_easy_setopt expects a "
+              "curl_opensocket_callback argument for this option"
+  )
+_CURL_WARNING(_curl_easy_setopt_err_progress_cb,
+  "curl_easy_setopt expects a curl_progress_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_debug_cb,
+  "curl_easy_setopt expects a curl_debug_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_ssl_ctx_cb,
+  "curl_easy_setopt expects a curl_ssl_ctx_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_conv_cb,
+  "curl_easy_setopt expects a curl_conv_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_seek_cb,
+  "curl_easy_setopt expects a curl_seek_callback argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_cb_data,
+              "curl_easy_setopt expects a "
+              "private data pointer as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_error_buffer,
+              "curl_easy_setopt expects a "
+              "char buffer of CURL_ERROR_SIZE as argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_FILE,
+  "curl_easy_setopt expects a FILE* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_postfields,
+  "curl_easy_setopt expects a void* or char* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_httpost,
+  "curl_easy_setopt expects a struct curl_httppost* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_curl_slist,
+  "curl_easy_setopt expects a struct curl_slist* argument for this option")
+_CURL_WARNING(_curl_easy_setopt_err_CURLSH,
+  "curl_easy_setopt expects a CURLSH* argument for this option")
+
+_CURL_WARNING(_curl_easy_getinfo_err_string,
+  "curl_easy_getinfo expects a pointer to char * for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_long,
+  "curl_easy_getinfo expects a pointer to long for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_double,
+  "curl_easy_getinfo expects a pointer to double for this info")
+_CURL_WARNING(_curl_easy_getinfo_err_curl_slist,
+  "curl_easy_getinfo expects a pointer to struct curl_slist * for this info")
+
+/* groups of curl_easy_setops options that take the same type of argument */
+
+/* To add a new option to one of the groups, just add
+ *   (option) == CURLOPT_SOMETHING
+ * to the or-expression. If the option takes a long or curl_off_t, you don't
+ * have to do anything
+ */
+
+/* evaluates to true if option takes a long argument */
+#define _curl_is_long_option(option)                                          \
+  (0 < (option) && (option) < CURLOPTTYPE_OBJECTPOINT)
+
+#define _curl_is_off_t_option(option)                                         \
+  ((option) > CURLOPTTYPE_OFF_T)
+
+/* evaluates to true if option takes a char* argument */
+#define _curl_is_string_option(option)                                        \
+  ((option) == CURLOPT_URL ||                                                 \
+   (option) == CURLOPT_PROXY ||                                               \
+   (option) == CURLOPT_INTERFACE ||                                           \
+   (option) == CURLOPT_NETRC_FILE ||                                          \
+   (option) == CURLOPT_USERPWD ||                                             \
+   (option) == CURLOPT_USERNAME ||                                            \
+   (option) == CURLOPT_PASSWORD ||                                            \
+   (option) == CURLOPT_PROXYUSERPWD ||                                        \
+   (option) == CURLOPT_PROXYUSERNAME ||                                       \
+   (option) == CURLOPT_PROXYPASSWORD ||                                       \
+   (option) == CURLOPT_NOPROXY ||                                             \
+   (option) == CURLOPT_ACCEPT_ENCODING ||                                     \
+   (option) == CURLOPT_REFERER ||                                             \
+   (option) == CURLOPT_USERAGENT ||                                           \
+   (option) == CURLOPT_COOKIE ||                                              \
+   (option) == CURLOPT_COOKIEFILE ||                                          \
+   (option) == CURLOPT_COOKIEJAR ||                                           \
+   (option) == CURLOPT_COOKIELIST ||                                          \
+   (option) == CURLOPT_FTPPORT ||                                             \
+   (option) == CURLOPT_FTP_ALTERNATIVE_TO_USER ||                             \
+   (option) == CURLOPT_FTP_ACCOUNT ||                                         \
+   (option) == CURLOPT_RANGE ||                                               \
+   (option) == CURLOPT_CUSTOMREQUEST ||                                       \
+   (option) == CURLOPT_SSLCERT ||                                             \
+   (option) == CURLOPT_SSLCERTTYPE ||                                         \
+   (option) == CURLOPT_SSLKEY ||                                              \
+   (option) == CURLOPT_SSLKEYTYPE ||                                          \
+   (option) == CURLOPT_KEYPASSWD ||                                           \
+   (option) == CURLOPT_SSLENGINE ||                                           \
+   (option) == CURLOPT_CAINFO ||                                              \
+   (option) == CURLOPT_CAPATH ||                                              \
+   (option) == CURLOPT_RANDOM_FILE ||                                         \
+   (option) == CURLOPT_EGDSOCKET ||                                           \
+   (option) == CURLOPT_SSL_CIPHER_LIST ||                                     \
+   (option) == CURLOPT_KRBLEVEL ||                                            \
+   (option) == CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 ||                             \
+   (option) == CURLOPT_SSH_PUBLIC_KEYFILE ||                                  \
+   (option) == CURLOPT_SSH_PRIVATE_KEYFILE ||                                 \
+   (option) == CURLOPT_CRLFILE ||                                             \
+   (option) == CURLOPT_ISSUERCERT ||                                          \
+   (option) == CURLOPT_SOCKS5_GSSAPI_SERVICE ||                               \
+   (option) == CURLOPT_SSH_KNOWNHOSTS ||                                      \
+   (option) == CURLOPT_MAIL_FROM ||                                           \
+   (option) == CURLOPT_RTSP_SESSION_ID ||                                     \
+   (option) == CURLOPT_RTSP_STREAM_URI ||                                     \
+   (option) == CURLOPT_RTSP_TRANSPORT ||                                      \
+   0)
+
+/* evaluates to true if option takes a curl_write_callback argument */
+#define _curl_is_write_cb_option(option)                                      \
+  ((option) == CURLOPT_HEADERFUNCTION ||                                      \
+   (option) == CURLOPT_WRITEFUNCTION)
+
+/* evaluates to true if option takes a curl_conv_callback argument */
+#define _curl_is_conv_cb_option(option)                                       \
+  ((option) == CURLOPT_CONV_TO_NETWORK_FUNCTION ||                            \
+   (option) == CURLOPT_CONV_FROM_NETWORK_FUNCTION ||                          \
+   (option) == CURLOPT_CONV_FROM_UTF8_FUNCTION)
+
+/* evaluates to true if option takes a data argument to pass to a callback */
+#define _curl_is_cb_data_option(option)                                       \
+  ((option) == CURLOPT_WRITEDATA ||                                           \
+   (option) == CURLOPT_READDATA ||                                            \
+   (option) == CURLOPT_IOCTLDATA ||                                           \
+   (option) == CURLOPT_SOCKOPTDATA ||                                         \
+   (option) == CURLOPT_OPENSOCKETDATA ||                                      \
+   (option) == CURLOPT_PROGRESSDATA ||                                        \
+   (option) == CURLOPT_WRITEHEADER ||                                         \
+   (option) == CURLOPT_DEBUGDATA ||                                           \
+   (option) == CURLOPT_SSL_CTX_DATA ||                                        \
+   (option) == CURLOPT_SEEKDATA ||                                            \
+   (option) == CURLOPT_PRIVATE ||                                             \
+   (option) == CURLOPT_SSH_KEYDATA ||                                         \
+   (option) == CURLOPT_INTERLEAVEDATA ||                                      \
+   (option) == CURLOPT_CHUNK_DATA ||                                          \
+   (option) == CURLOPT_FNMATCH_DATA ||                                        \
+   0)
+
+/* evaluates to true if option takes a POST data argument (void* or char*) */
+#define _curl_is_postfields_option(option)                                    \
+  ((option) == CURLOPT_POSTFIELDS ||                                          \
+   (option) == CURLOPT_COPYPOSTFIELDS ||                                      \
+   0)
+
+/* evaluates to true if option takes a struct curl_slist * argument */
+#define _curl_is_slist_option(option)                                         \
+  ((option) == CURLOPT_HTTPHEADER ||                                          \
+   (option) == CURLOPT_HTTP200ALIASES ||                                      \
+   (option) == CURLOPT_QUOTE ||                                               \
+   (option) == CURLOPT_POSTQUOTE ||                                           \
+   (option) == CURLOPT_PREQUOTE ||                                            \
+   (option) == CURLOPT_TELNETOPTIONS ||                                       \
+   (option) == CURLOPT_MAIL_RCPT ||                                           \
+   0)
+
+/* groups of curl_easy_getinfo infos that take the same type of argument */
+
+/* evaluates to true if info expects a pointer to char * argument */
+#define _curl_is_string_info(info)                                            \
+  (CURLINFO_STRING < (info) && (info) < CURLINFO_LONG)
+
+/* evaluates to true if info expects a pointer to long argument */
+#define _curl_is_long_info(info)                                              \
+  (CURLINFO_LONG < (info) && (info) < CURLINFO_DOUBLE)
+
+/* evaluates to true if info expects a pointer to double argument */
+#define _curl_is_double_info(info)                                            \
+  (CURLINFO_DOUBLE < (info) && (info) < CURLINFO_SLIST)
+
+/* true if info expects a pointer to struct curl_slist * argument */
+#define _curl_is_slist_info(info)                                             \
+  (CURLINFO_SLIST < (info))
+
+
+/* typecheck helpers -- check whether given expression has requested type*/
+
+/* For pointers, you can use the _curl_is_ptr/_curl_is_arr macros,
+ * otherwise define a new macro. Search for __builtin_types_compatible_p
+ * in the GCC manual.
+ * NOTE: these macros MUST NOT EVALUATE their arguments! The argument is
+ * the actual expression passed to the curl_easy_setopt macro. This
+ * means that you can only apply the sizeof and __typeof__ operators, no
+ * == or whatsoever.
+ */
+
+/* XXX: should evaluate to true iff expr is a pointer */
+#define _curl_is_any_ptr(expr)                                                \
+  (sizeof(expr) == sizeof(void*))
+
+/* evaluates to true if expr is NULL */
+/* XXX: must not evaluate expr, so this check is not accurate */
+#define _curl_is_NULL(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), __typeof__(NULL)))
+
+/* evaluates to true if expr is type*, const type* or NULL */
+#define _curl_is_ptr(expr, type)                                              \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), type *) ||                  \
+   __builtin_types_compatible_p(__typeof__(expr), const type *))
+
+/* evaluates to true if expr is one of type[], type*, NULL or const type* */
+#define _curl_is_arr(expr, type)                                              \
+  (_curl_is_ptr((expr), type) ||                                              \
+   __builtin_types_compatible_p(__typeof__(expr), type []))
+
+/* evaluates to true if expr is a string */
+#define _curl_is_string(expr)                                                 \
+  (_curl_is_arr((expr), char) ||                                              \
+   _curl_is_arr((expr), signed char) ||                                       \
+   _curl_is_arr((expr), unsigned char))
+
+/* evaluates to true if expr is a long (no matter the signedness)
+ * XXX: for now, int is also accepted (and therefore short and char, which
+ * are promoted to int when passed to a variadic function) */
+#define _curl_is_long(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), long) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed long) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned long) ||           \
+   __builtin_types_compatible_p(__typeof__(expr), int) ||                     \
+   __builtin_types_compatible_p(__typeof__(expr), signed int) ||              \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned int) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), short) ||                   \
+   __builtin_types_compatible_p(__typeof__(expr), signed short) ||            \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned short) ||          \
+   __builtin_types_compatible_p(__typeof__(expr), char) ||                    \
+   __builtin_types_compatible_p(__typeof__(expr), signed char) ||             \
+   __builtin_types_compatible_p(__typeof__(expr), unsigned char))
+
+/* evaluates to true if expr is of type curl_off_t */
+#define _curl_is_off_t(expr)                                                  \
+  (__builtin_types_compatible_p(__typeof__(expr), curl_off_t))
+
+/* evaluates to true if expr is abuffer suitable for CURLOPT_ERRORBUFFER */
+/* XXX: also check size of an char[] array? */
+#define _curl_is_error_buffer(expr)                                           \
+  (__builtin_types_compatible_p(__typeof__(expr), char *) ||                  \
+   __builtin_types_compatible_p(__typeof__(expr), char[]))
+
+/* evaluates to true if expr is of type (const) void* or (const) FILE* */
+#if 0
+#define _curl_is_cb_data(expr)                                                \
+  (_curl_is_ptr((expr), void) ||                                              \
+   _curl_is_ptr((expr), FILE))
+#else /* be less strict */
+#define _curl_is_cb_data(expr)                                                \
+  _curl_is_any_ptr(expr)
+#endif
+
+/* evaluates to true if expr is of type FILE* */
+#define _curl_is_FILE(expr)                                                   \
+  (__builtin_types_compatible_p(__typeof__(expr), FILE *))
+
+/* evaluates to true if expr can be passed as POST data (void* or char*) */
+#define _curl_is_postfields(expr)                                             \
+  (_curl_is_ptr((expr), void) ||                                              \
+   _curl_is_arr((expr), char))
+
+/* FIXME: the whole callback checking is messy...
+ * The idea is to tolerate char vs. void and const vs. not const
+ * pointers in arguments at least
+ */
+/* helper: __builtin_types_compatible_p distinguishes between functions and
+ * function pointers, hide it */
+#define _curl_callback_compatible(func, type)                                 \
+  (__builtin_types_compatible_p(__typeof__(func), type) ||                    \
+   __builtin_types_compatible_p(__typeof__(func), type*))
+
+/* evaluates to true if expr is of type curl_read_callback or "similar" */
+#define _curl_is_read_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fread)) ||       \
+   __builtin_types_compatible_p(__typeof__(expr), curl_read_callback) ||      \
+   _curl_callback_compatible((expr), _curl_read_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback2) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback3) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback4) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback5) ||                 \
+   _curl_callback_compatible((expr), _curl_read_callback6))
+typedef size_t (_curl_read_callback1)(char *, size_t, size_t, void*);
+typedef size_t (_curl_read_callback2)(char *, size_t, size_t, const void*);
+typedef size_t (_curl_read_callback3)(char *, size_t, size_t, FILE*);
+typedef size_t (_curl_read_callback4)(void *, size_t, size_t, void*);
+typedef size_t (_curl_read_callback5)(void *, size_t, size_t, const void*);
+typedef size_t (_curl_read_callback6)(void *, size_t, size_t, FILE*);
+
+/* evaluates to true if expr is of type curl_write_callback or "similar" */
+#define _curl_is_write_cb(expr)                                               \
+  (_curl_is_read_cb(expr) ||                                            \
+   __builtin_types_compatible_p(__typeof__(expr), __typeof__(fwrite)) ||      \
+   __builtin_types_compatible_p(__typeof__(expr), curl_write_callback) ||     \
+   _curl_callback_compatible((expr), _curl_write_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback4) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback5) ||                \
+   _curl_callback_compatible((expr), _curl_write_callback6))
+typedef size_t (_curl_write_callback1)(const char *, size_t, size_t, void*);
+typedef size_t (_curl_write_callback2)(const char *, size_t, size_t,
+                                       const void*);
+typedef size_t (_curl_write_callback3)(const char *, size_t, size_t, FILE*);
+typedef size_t (_curl_write_callback4)(const void *, size_t, size_t, void*);
+typedef size_t (_curl_write_callback5)(const void *, size_t, size_t,
+                                       const void*);
+typedef size_t (_curl_write_callback6)(const void *, size_t, size_t, FILE*);
+
+/* evaluates to true if expr is of type curl_ioctl_callback or "similar" */
+#define _curl_is_ioctl_cb(expr)                                         \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_ioctl_callback) ||     \
+   _curl_callback_compatible((expr), _curl_ioctl_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_ioctl_callback4))
+typedef curlioerr (_curl_ioctl_callback1)(CURL *, int, void*);
+typedef curlioerr (_curl_ioctl_callback2)(CURL *, int, const void*);
+typedef curlioerr (_curl_ioctl_callback3)(CURL *, curliocmd, void*);
+typedef curlioerr (_curl_ioctl_callback4)(CURL *, curliocmd, const void*);
+
+/* evaluates to true if expr is of type curl_sockopt_callback or "similar" */
+#define _curl_is_sockopt_cb(expr)                                       \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_sockopt_callback) ||   \
+   _curl_callback_compatible((expr), _curl_sockopt_callback1) ||              \
+   _curl_callback_compatible((expr), _curl_sockopt_callback2))
+typedef int (_curl_sockopt_callback1)(void *, curl_socket_t, curlsocktype);
+typedef int (_curl_sockopt_callback2)(const void *, curl_socket_t,
+                                      curlsocktype);
+
+/* evaluates to true if expr is of type curl_opensocket_callback or
+   "similar" */
+#define _curl_is_opensocket_cb(expr)                                    \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_opensocket_callback) ||\
+   _curl_callback_compatible((expr), _curl_opensocket_callback1) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback2) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback3) ||           \
+   _curl_callback_compatible((expr), _curl_opensocket_callback4))
+typedef curl_socket_t (_curl_opensocket_callback1)
+  (void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback2)
+  (void *, curlsocktype, const struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback3)
+  (const void *, curlsocktype, struct curl_sockaddr *);
+typedef curl_socket_t (_curl_opensocket_callback4)
+  (const void *, curlsocktype, const struct curl_sockaddr *);
+
+/* evaluates to true if expr is of type curl_progress_callback or "similar" */
+#define _curl_is_progress_cb(expr)                                      \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_progress_callback) ||  \
+   _curl_callback_compatible((expr), _curl_progress_callback1) ||             \
+   _curl_callback_compatible((expr), _curl_progress_callback2))
+typedef int (_curl_progress_callback1)(void *,
+    double, double, double, double);
+typedef int (_curl_progress_callback2)(const void *,
+    double, double, double, double);
+
+/* evaluates to true if expr is of type curl_debug_callback or "similar" */
+#define _curl_is_debug_cb(expr)                                         \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_debug_callback) ||     \
+   _curl_callback_compatible((expr), _curl_debug_callback1) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback2) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback3) ||                \
+   _curl_callback_compatible((expr), _curl_debug_callback4))
+typedef int (_curl_debug_callback1) (CURL *,
+    curl_infotype, char *, size_t, void *);
+typedef int (_curl_debug_callback2) (CURL *,
+    curl_infotype, char *, size_t, const void *);
+typedef int (_curl_debug_callback3) (CURL *,
+    curl_infotype, const char *, size_t, void *);
+typedef int (_curl_debug_callback4) (CURL *,
+    curl_infotype, const char *, size_t, const void *);
+
+/* evaluates to true if expr is of type curl_ssl_ctx_callback or "similar" */
+/* this is getting even messier... */
+#define _curl_is_ssl_ctx_cb(expr)                                       \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_ssl_ctx_callback) ||   \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback1) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback2) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback3) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback4) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback5) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback6) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback7) ||              \
+   _curl_callback_compatible((expr), _curl_ssl_ctx_callback8))
+typedef CURLcode (_curl_ssl_ctx_callback1)(CURL *, void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback2)(CURL *, void *, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback3)(CURL *, const void *, void *);
+typedef CURLcode (_curl_ssl_ctx_callback4)(CURL *, const void *, const void *);
+#ifdef HEADER_SSL_H
+/* hack: if we included OpenSSL's ssl.h, we know about SSL_CTX
+ * this will of course break if we're included before OpenSSL headers...
+ */
+typedef CURLcode (_curl_ssl_ctx_callback5)(CURL *, SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback6)(CURL *, SSL_CTX, const void *);
+typedef CURLcode (_curl_ssl_ctx_callback7)(CURL *, const SSL_CTX, void *);
+typedef CURLcode (_curl_ssl_ctx_callback8)(CURL *, const SSL_CTX,
+                                           const void *);
+#else
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback5;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback6;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback7;
+typedef _curl_ssl_ctx_callback1 _curl_ssl_ctx_callback8;
+#endif
+
+/* evaluates to true if expr is of type curl_conv_callback or "similar" */
+#define _curl_is_conv_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_conv_callback) ||      \
+   _curl_callback_compatible((expr), _curl_conv_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback2) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback3) ||                 \
+   _curl_callback_compatible((expr), _curl_conv_callback4))
+typedef CURLcode (*_curl_conv_callback1)(char *, size_t length);
+typedef CURLcode (*_curl_conv_callback2)(const char *, size_t length);
+typedef CURLcode (*_curl_conv_callback3)(void *, size_t length);
+typedef CURLcode (*_curl_conv_callback4)(const void *, size_t length);
+
+/* evaluates to true if expr is of type curl_seek_callback or "similar" */
+#define _curl_is_seek_cb(expr)                                          \
+  (_curl_is_NULL(expr) ||                                                     \
+   __builtin_types_compatible_p(__typeof__(expr), curl_seek_callback) ||      \
+   _curl_callback_compatible((expr), _curl_seek_callback1) ||                 \
+   _curl_callback_compatible((expr), _curl_seek_callback2))
+typedef CURLcode (*_curl_seek_callback1)(void *, curl_off_t, int);
+typedef CURLcode (*_curl_seek_callback2)(const void *, curl_off_t, int);
+
+
+#endif /* __CURL_TYPECHECK_GCC_H */

backends/twitter/libtwitcurl/lib/.svn/all-wcprops

@@ -0,0 +1,11 @@
+K 25
+svn:wc:ra_dav:version-url
+V 38
+/svn/!svn/ver/55/trunk/libtwitcurl/lib
+END
+libcurl.lib
+K 25
+svn:wc:ra_dav:version-url
+V 50
+/svn/!svn/ver/55/trunk/libtwitcurl/lib/libcurl.lib
+END

backends/twitter/libtwitcurl/lib/.svn/entries

@@ -0,0 +1,62 @@
+10
+
+dir
+89
+http://twitcurl.googlecode.com/svn/trunk/libtwitcurl/lib
+http://twitcurl.googlecode.com/svn
+
+
+
+2011-09-12T19:28:25.614324Z
+55
+swatkat.thinkdigit@gmail.com
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4714a580-958b-11de-ad41-3fcdc5e0e42d
+
+libcurl.lib
+file
+
+
+
+
+2012-08-04T17:27:28.470970Z
+bf5f17f57618ef87a64883b9028014c8
+2011-09-12T19:28:25.614324Z
+55
+swatkat.thinkdigit@gmail.com
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+790868
+

backends/twitter/libtwitcurl/lib/.svn/prop-base/libcurl.lib.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:mime-type
+V 24
+application/octet-stream
+END