427 lines
14 KiB
C++
427 lines
14 KiB
C++
#include "twitcurl.h"
|
|
#include <cstdio>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
|
|
void printUsage()
|
|
{
|
|
printf( "\nUsage:\ntwitterClient -u username -p password\n" );
|
|
}
|
|
|
|
int main( int argc, char* argv[] )
|
|
{
|
|
std::string userName( "" );
|
|
std::string passWord( "" );
|
|
if( argc > 4 )
|
|
{
|
|
for( int i = 1; i < argc; i += 2 )
|
|
{
|
|
if( 0 == strncmp( argv[i], "-u", strlen("-u") ) )
|
|
{
|
|
userName = argv[i+1];
|
|
}
|
|
else if( 0 == strncmp( argv[i], "-p", strlen("-p") ) )
|
|
{
|
|
passWord = argv[i+1];
|
|
}
|
|
}
|
|
if( ( 0 == userName.length() ) || ( 0 == passWord.length() ) )
|
|
{
|
|
printUsage();
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printUsage();
|
|
return 0;
|
|
}
|
|
|
|
twitCurl twitterObj;
|
|
std::string tmpStr;
|
|
std::string replyMsg;
|
|
char tmpBuf[1024];
|
|
|
|
/* Set twitter username and password */
|
|
twitterObj.setTwitterUsername( userName );
|
|
twitterObj.setTwitterPassword( passWord );
|
|
|
|
/* Set proxy server usename, password, IP and port (if present) */
|
|
memset( tmpBuf, 0, 1024 );
|
|
printf( "\nDo you have a proxy server configured (0 for no; 1 for yes): " );
|
|
gets( tmpBuf );
|
|
tmpStr = tmpBuf;
|
|
|
|
if( std::string::npos != tmpStr.find( "1" ) )
|
|
{
|
|
char proxyIp[1024];
|
|
char proxyPort[1024];
|
|
char proxyUsername[1024];
|
|
char proxyPassword[1024];
|
|
|
|
memset( proxyIp, 0, 1024 );
|
|
memset( proxyPort, 0, 1024 );
|
|
memset( proxyUsername, 0, 1024 );
|
|
memset( proxyPassword, 0, 1024 );
|
|
|
|
printf( "\nEnter proxy server IP: " );
|
|
gets( proxyIp );
|
|
printf( "\nEnter proxy server port: " );
|
|
gets( proxyPort );
|
|
printf( "\nEnter proxy server username: " );
|
|
gets( proxyUsername );
|
|
printf( "\nEnter proxy server password: " );
|
|
gets( proxyPassword );
|
|
|
|
tmpStr = proxyIp;
|
|
twitterObj.setProxyServerIp( tmpStr );
|
|
tmpStr = proxyPort;
|
|
twitterObj.setProxyServerPort( tmpStr );
|
|
tmpStr = proxyUsername;
|
|
twitterObj.setProxyUserName( tmpStr );
|
|
tmpStr = proxyPassword;
|
|
twitterObj.setProxyPassword( tmpStr );
|
|
}
|
|
|
|
/* OAuth flow begins */
|
|
/* Step 0: Set OAuth related params. These are got by registering your app at twitter.com */
|
|
twitterObj.getOAuth().setConsumerKey( std::string( "qxfSCX7WN7SZl7dshqGZA" ) );
|
|
twitterObj.getOAuth().setConsumerSecret( std::string( "ypWapSj87lswvnksZ46hMAoAZvST4ePGPxAQw6S2o" ) );
|
|
|
|
// twitterObj.getOAuth().setConsumerKey( std::string( "vlC5S1NCMHHg8mD1ghPRkA" ) );
|
|
// twitterObj.getOAuth().setConsumerSecret( std::string( "3w4cIrHyI3IYUZW5O2ppcFXmsACDaENzFdLIKmEU84" ) );
|
|
|
|
/* Step 1: Check if we alredy have OAuth access token from a previous run */
|
|
std::string myOAuthAccessTokenKey("");
|
|
std::string myOAuthAccessTokenSecret("");
|
|
std::ifstream oAuthTokenKeyIn;
|
|
std::ifstream oAuthTokenSecretIn;
|
|
|
|
oAuthTokenKeyIn.open( "twitterClient_token_key.txt" );
|
|
oAuthTokenSecretIn.open( "twitterClient_token_secret.txt" );
|
|
|
|
memset( tmpBuf, 0, 1024 );
|
|
oAuthTokenKeyIn >> tmpBuf;
|
|
myOAuthAccessTokenKey = tmpBuf;
|
|
|
|
memset( tmpBuf, 0, 1024 );
|
|
oAuthTokenSecretIn >> tmpBuf;
|
|
myOAuthAccessTokenSecret = tmpBuf;
|
|
|
|
oAuthTokenKeyIn.close();
|
|
oAuthTokenSecretIn.close();
|
|
|
|
if( myOAuthAccessTokenKey.size() && myOAuthAccessTokenSecret.size() )
|
|
{
|
|
/* If we already have these keys, then no need to go through auth again */
|
|
printf( "\nUsing:\nKey: %s\nSecret: %s\n\n", myOAuthAccessTokenKey.c_str(), myOAuthAccessTokenSecret.c_str() );
|
|
|
|
twitterObj.getOAuth().setOAuthTokenKey( myOAuthAccessTokenKey );
|
|
twitterObj.getOAuth().setOAuthTokenSecret( myOAuthAccessTokenSecret );
|
|
}
|
|
else
|
|
{
|
|
/* Step 2: Get request token key and secret */
|
|
std::string authUrl;
|
|
twitterObj.oAuthRequestToken( authUrl );
|
|
|
|
/* Step 3: Get PIN */
|
|
memset( tmpBuf, 0, 1024 );
|
|
printf( "\nDo you want to visit twitter.com for PIN (0 for no; 1 for yes): " );
|
|
gets( tmpBuf );
|
|
tmpStr = tmpBuf;
|
|
if( std::string::npos != tmpStr.find( "1" ) )
|
|
{
|
|
/* Ask user to visit twitter.com auth page and get PIN */
|
|
memset( tmpBuf, 0, 1024 );
|
|
printf( "\nPlease visit this link in web browser and authorize this application:\n%s", authUrl.c_str() );
|
|
printf( "\nEnter the PIN provided by twitter: " );
|
|
gets( tmpBuf );
|
|
tmpStr = tmpBuf;
|
|
twitterObj.getOAuth().setOAuthPin( tmpStr );
|
|
}
|
|
else
|
|
{
|
|
/* Else, pass auth url to twitCurl and get it via twitCurl PIN handling */
|
|
twitterObj.oAuthHandlePIN( authUrl );
|
|
}
|
|
|
|
/* Step 4: Exchange request token with access token */
|
|
twitterObj.oAuthAccessToken();
|
|
|
|
/* Step 5: Now, save this access token key and secret for future use without PIN */
|
|
twitterObj.getOAuth().getOAuthTokenKey( myOAuthAccessTokenKey );
|
|
twitterObj.getOAuth().getOAuthTokenSecret( myOAuthAccessTokenSecret );
|
|
|
|
/* Step 6: Save these keys in a file or wherever */
|
|
std::ofstream oAuthTokenKeyOut;
|
|
std::ofstream oAuthTokenSecretOut;
|
|
|
|
oAuthTokenKeyOut.open( "twitterClient_token_key.txt" );
|
|
oAuthTokenSecretOut.open( "twitterClient_token_secret.txt" );
|
|
|
|
oAuthTokenKeyOut.clear();
|
|
oAuthTokenSecretOut.clear();
|
|
|
|
oAuthTokenKeyOut << myOAuthAccessTokenKey.c_str();
|
|
oAuthTokenSecretOut << myOAuthAccessTokenSecret.c_str();
|
|
|
|
oAuthTokenKeyOut.close();
|
|
oAuthTokenSecretOut.close();
|
|
}
|
|
/* OAuth flow ends */
|
|
|
|
/* Post a new status message */
|
|
memset( tmpBuf, 0, 1024 );
|
|
printf( "\nEnter a new status message: " );
|
|
gets( tmpBuf );
|
|
tmpStr = tmpBuf;
|
|
replyMsg = "";
|
|
if( twitterObj.statusUpdate( tmpStr ) )
|
|
{
|
|
twitterObj.getLastWebResponse( replyMsg );
|
|
printf( "\ntwitterClient:: twitCurl::statusUpdate web response:\n%s\n", replyMsg.c_str() );
|
|
}
|
|
else
|
|
{
|
|
twitterObj.getLastCurlError( replyMsg );
|
|
printf( "\ntwitterClient:: twitCurl::statusUpdate error:\n%s\n", replyMsg.c_str() );
|
|
}
|
|
|
|
// /* Search a string */
|
|
// twitterObj.setTwitterApiType( twitCurlTypes::eTwitCurlApiFormatJson );
|
|
// printf( "\nEnter string to search: " );
|
|
// memset( tmpBuf, 0, 1024 );
|
|
// gets( tmpBuf );
|
|
// tmpStr = tmpBuf;
|
|
// replyMsg = "";
|
|
// if( twitterObj.search( tmpStr ) )
|
|
// {
|
|
// twitterObj.getLastWebResponse( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::search web response:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
// else
|
|
// {
|
|
// twitterObj.getLastCurlError( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::search error:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
//
|
|
// /* Get user timeline */
|
|
// replyMsg = "";
|
|
// printf( "\nGetting user timeline\n" );
|
|
// if( twitterObj.timelineUserGet( false, false, 0 ) )
|
|
// {
|
|
// twitterObj.getLastWebResponse( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::timelineUserGet web response:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
// else
|
|
// {
|
|
// twitterObj.getLastCurlError( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::timelineUserGet error:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
|
|
#ifdef _TWITCURL_TEST_
|
|
// /* Destroy a status message */
|
|
// memset( statusMsg, 0, 1024 );
|
|
// printf( "\nEnter status message id to delete: " );
|
|
// gets( statusMsg );
|
|
// tmpStr = statusMsg;
|
|
// replyMsg = "";
|
|
// if( twitterObj.statusDestroyById( tmpStr ) )
|
|
// {
|
|
// twitterObj.getLastWebResponse( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::statusDestroyById web response:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
// else
|
|
// {
|
|
// twitterObj.getLastCurlError( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::statusDestroyById error:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
//
|
|
// /* Get public timeline */
|
|
// replyMsg = "";
|
|
// printf( "\nGetting public timeline\n" );
|
|
// if( twitterObj.timelinePublicGet() )
|
|
// {
|
|
// twitterObj.getLastWebResponse( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::timelinePublicGet web response:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
// else
|
|
// {
|
|
// twitterObj.getLastCurlError( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::timelinePublicGet error:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
//
|
|
// /* Get friend ids */
|
|
// replyMsg = "";
|
|
// printf( "\nGetting friend ids\n" );
|
|
// tmpStr = "techcrunch";
|
|
// if( twitterObj.friendsIdsGet( tmpStr, false ) )
|
|
// {
|
|
// twitterObj.getLastWebResponse( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::friendsIdsGet web response:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
// else
|
|
// {
|
|
// twitterObj.getLastCurlError( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::friendsIdsGet error:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
//
|
|
// /* Get trends */
|
|
// if( twitterObj.trendsDailyGet() )
|
|
// {
|
|
// twitterObj.getLastWebResponse( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::trendsDailyGet web response:\n%s\n", replyMsg.c_str() );
|
|
// }
|
|
// else
|
|
// {
|
|
// twitterObj.getLastCurlError( replyMsg );
|
|
// printf( "\ntwitterClient:: twitCurl::trendsDailyGet error:\n%s\n", replyMsg.c_str() );
|
|
}
|
|
#endif // _TWITCURL_TEST_
|
|
|
|
return 0;
|
|
}
|
|
//#include "transport/config.h"
|
|
//#include "transport/networkplugin.h"
|
|
//#include "transport/logging.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 "twitcurl.h"
|
|
//
|
|
//using namespace boost::filesystem;
|
|
//using namespace boost::program_options;
|
|
//using namespace Transport;
|
|
//
|
|
//DEFINE_LOGGER(logger, "Twitter Backend");
|
|
//Swift::SimpleEventLoop *loop_; // Event Loop
|
|
//class TwitterPlugin; // The plugin
|
|
//TwitterPlugin * np = NULL;
|
|
//
|
|
//class TwitterPlugin : public NetworkPlugin {
|
|
// public:
|
|
// Swift::BoostNetworkFactories *m_factories;
|
|
// Swift::BoostIOServiceThread m_boostIOServiceThread;
|
|
// boost::shared_ptr<Swift::Connection> m_conn;
|
|
//
|
|
// TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, const std::string &host, int port) : NetworkPlugin() {
|
|
// this->config = config;
|
|
// 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));
|
|
//
|
|
// LOG4CXX_INFO(logger, "Starting the plugin.");
|
|
// }
|
|
//
|
|
// // Send data to NetworkPlugin server
|
|
// void 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 _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 handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
|
|
// handleConnected(user);
|
|
// }
|
|
//
|
|
// // User logging out
|
|
// void handleLogoutRequest(const std::string &user, const std::string &legacyName) {
|
|
// }
|
|
//
|
|
//
|
|
// void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "") {
|
|
// LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ".");
|
|
// }
|
|
//
|
|
// void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups) {
|
|
// LOG4CXX_INFO(logger, user << ": Added buddy " << buddyName << ".");
|
|
// handleBuddyChanged(user, buddyName, alias, groups, pbnetwork::STATUS_ONLINE);
|
|
// }
|
|
//
|
|
// void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups) {
|
|
//
|
|
// }
|
|
//
|
|
// private:
|
|
// Config *config;
|
|
// map< std::string, twitCurl > sessions;
|
|
//};
|
|
//
|
|
//static void spectrum_sigchld_handler(int sig)
|
|
//{
|
|
// int status;
|
|
// pid_t pid;
|
|
//
|
|
// do {
|
|
// pid = waitpid(-1, &status, WNOHANG);
|
|
// } while (pid != 0 && pid != (pid_t)-1);
|
|
//
|
|
// if ((pid == (pid_t) - 1) && (errno != ECHILD)) {
|
|
// char errmsg[BUFSIZ];
|
|
// snprintf(errmsg, BUFSIZ, "Warning: waitpid() returned %d", pid);
|
|
// perror(errmsg);
|
|
// }
|
|
//}
|
|
//
|
|
//
|
|
//int main (int argc, char* argv[]) {
|
|
// std::string host;
|
|
// int port;
|
|
//
|
|
// if (signal(SIGCHLD, spectrum_sigchld_handler) == SIG_ERR) {
|
|
// std::cout << "SIGCHLD handler can't be set\n";
|
|
// return -1;
|
|
// }
|
|
//
|
|
// boost::program_options::options_description desc("Usage: spectrum [OPTIONS] <config_file.cfg>\nAllowed options");
|
|
// desc.add_options()
|
|
// ("host,h", value<std::string>(&host), "host")
|
|
// ("port,p", value<int>(&port), "port")
|
|
// ;
|
|
// try
|
|
// {
|
|
// boost::program_options::variables_map vm;
|
|
// boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);
|
|
// boost::program_options::notify(vm);
|
|
// }
|
|
// catch (std::runtime_error& e)
|
|
// {
|
|
// std::cout << desc << "\n";
|
|
// exit(1);
|
|
// }
|
|
// catch (...)
|
|
// {
|
|
// std::cout << desc << "\n";
|
|
// exit(1);
|
|
// }
|
|
//
|
|
//
|
|
// if (argc < 5) {
|
|
// return 1;
|
|
// }
|
|
//
|
|
// Config config;
|
|
// if (!config.load(argv[5])) {
|
|
// std::cerr << "Can't open " << argv[1] << " configuration file.\n";
|
|
// return 1;
|
|
// }
|
|
//
|
|
// Logging::initBackendLogging(&config);
|
|
//
|
|
// Swift::SimpleEventLoop eventLoop;
|
|
// loop_ = &eventLoop;
|
|
// np = new TwitterPlugin(&config, &eventLoop, host, port);
|
|
// loop_->run();
|
|
//
|
|
// return 0;
|
|
//}
|