bool RsControlModule::askForPassword(const std::string &title, const std::string &key_details, bool prev_is_bad, std::string &password, bool& cancelled)
{
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::askForPassword(): current passwd is \"" << mPassword << "\"" << std::endl;
#endif
cancelled = false ;
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
mCountAttempts++;
if(mCountAttempts == 3)
{
mPrevIsBad = prev_is_bad;
mCountAttempts = 0;
}
else
mPrevIsBad = false;
if(mFixedPassword != "")
{
password = mFixedPassword;
return true;
}
mWantPassword = true;
mTitle = title;
mKeyName = key_details;
if(mPassword != "")
{
password = mPassword;
mWantPassword = false;
return true;
}
mStateTokenServer->replaceToken(mStateToken);
}
int i = 0;
while(i<100)
{
usleep(5*1000);
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
if(mPassword != "")
{
password = mPassword;
mWantPassword = false;
mStateTokenServer->replaceToken(mStateToken);
return true;
}
i++;
}
return false;
}
bool VideoProcessor::processImage(const QImage& img)
{
VideoCodec *codec ;
switch(_encoding_current_codec)
{
case VIDEO_PROCESSOR_CODEC_ID_JPEG_VIDEO: codec = &_jpeg_video_codec ;
break ;
case VIDEO_PROCESSOR_CODEC_ID_MPEG_VIDEO: codec = &_mpeg_video_codec ;
break ;
default:
codec = NULL ;
}
// std::cerr << "reducing to " << _frame_size.width() << " x " << _frame_size.height() << std::endl;
if(codec)
{
RsVOIPDataChunk chunk ;
if(codec->encodeData(img.scaled(_encoded_frame_size,Qt::IgnoreAspectRatio,Qt::SmoothTransformation),_target_bandwidth_out,chunk) && chunk.size > 0)
{
RS_STACK_MUTEX(vpMtx) ;
_encoded_out_queue.push_back(chunk) ;
_total_encoded_size_out += chunk.size ;
}
time_t now = time(NULL) ;
if(now > _last_bw_estimate_out_TS)
{
RS_STACK_MUTEX(vpMtx) ;
_estimated_bandwidth_out = uint32_t(0.75*_estimated_bandwidth_out + 0.25 * (_total_encoded_size_out / (float)(now - _last_bw_estimate_out_TS))) ;
_total_encoded_size_out = 0 ;
_last_bw_estimate_out_TS = now ;
#ifdef DEBUG_VIDEO_OUTPUT_DEVICE
std::cerr << "new bw estimate: " << _estimated_bw << std::endl;
#endif
}
return true ;
}
else
{
std::cerr << "No codec for codec ID = " << _encoding_current_codec << ". Please call VideoProcessor::setCurrentCodec()" << std::endl;
return false ;
}
}
void RsControlModule::handleRunState(Request &, Response &resp)
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
std::string state;
switch(mRunState)
{
case WAITING_INIT:
state = "waiting_init";
break;
case FATAL_ERROR:
state = "fatal_error";
break;
case WAITING_ACCOUNT_SELECT:
state = "waiting_account_select";
break;
case WAITING_STARTUP:
state = "waiting_startup";
break;
case RUNNING_OK:
state = "running_ok";
break;
case RUNNING_OK_NO_FULL_CONTROL:
state = "running_ok_no_full_control";
break;
default:
state = "error_should_not_happen_this_is_a_bug";
}
resp.mDataStream << makeKeyValueReference("runstate", state);
resp.mStateToken = mStateToken;
resp.setOk();
}
void RsControlModule::handleIdentities(Request &, Response &resp)
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
if(mRunState == WAITING_INIT || mRunState == FATAL_ERROR)
{
resp.setFail("Retroshare is not initialised. Operation not possible.");
return;
}
std::list<RsPgpId> pgp_ids;
RsAccounts::GetPGPLogins(pgp_ids);
resp.mDataStream.getStreamToMember();
for(std::list<RsPgpId>::iterator lit = pgp_ids.begin(); lit != pgp_ids.end(); ++lit)
{
std::string name;
std::string email;
if(RsAccounts::GetPGPLoginDetails(*lit, name, email))
resp.mDataStream.getStreamToMember()
<< makeKeyValueReference("id", *lit)
<< makeKeyValueReference("pgp_id", *lit)
<< makeKeyValueReference("name", name);
}
resp.mStateToken = mStateToken;
resp.setOk();
}
void RsControlModule::handleLocations(Request &, Response &resp)
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
if(mRunState == WAITING_INIT || mRunState == FATAL_ERROR)
{
resp.setFail("Retroshare is not initialised. Operation not possible.");
return;
}
RsPeerId preferedId;
RsAccounts::GetPreferredAccountId(preferedId);
std::list<RsPeerId> peer_ids;
RsAccounts::GetAccountIds(peer_ids);
resp.mDataStream.getStreamToMember();
for(std::list<RsPeerId>::iterator lit = peer_ids.begin(); lit != peer_ids.end(); ++lit)
{
bool preferred = preferedId==*lit;
RsPgpId pgp_id;
std::string pgp_name, pgp_mail, location_name;
if(RsAccounts::GetAccountDetails(*lit, pgp_id, pgp_name, pgp_mail, location_name))
resp.mDataStream.getStreamToMember()
<< makeKeyValueReference("id", *lit)
<< makeKeyValueReference("pgp_id", pgp_id)
<< makeKeyValueReference("peer_id", *lit)
<< makeKeyValueReference("name", pgp_name)
<< makeKeyValueReference("location", location_name)
<< makeKeyValueReference("preferred", preferred);
}
resp.mStateToken = mStateToken;
resp.setOk();
}
void ChatHandler::handleMarkChatAsRead(Request &req, Response &resp)
{
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
ChatId id(req.mPath.top());
if(id.isNotSet())
{
resp.setFail("\""+req.mPath.top()+"\" is not a valid chat id");
return;
}
std::map<ChatId, std::list<Msg> >::iterator mit = mMsgs.find(id);
if(mit == mMsgs.end())
{
resp.setFail("chat not found. Maybe this chat does not have messages yet?");
return;
}
std::list<Msg>& msgs = mit->second;
for(std::list<Msg>::iterator lit = msgs.begin(); lit != msgs.end(); ++lit)
{
lit->read = true;
}
// lobby list contains unread msgs, so update it
if(id.isLobbyId())
mStateTokenServer->replaceToken(mLobbiesStateToken);
if(id.isPeerId() && mUnreadMsgNotify)
mUnreadMsgNotify->notifyUnreadMsgCountChanged(id.toPeerId(), 0);
mStateTokenServer->replaceToken(mUnreadMsgsStateToken);
}
void RsControlModule::handlePassword(Request &req, Response &resp)
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
std::string passwd;
req.mStream << makeKeyValueReference("password", passwd);
if(passwd != "")// && mWantPassword)
{
// client sends password
mPassword = passwd;
mWantPassword = false;
mStateTokenServer->replaceToken(mStateToken);
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::handlePassword(): setting mPasswd=\"" << mPassword << "\"" << std::endl;
#endif
}
#ifdef DEBUG_CONTROL_MODULE
else
std::cerr << "RsControlModule::handlePassword(): not setting mPasswd=\"" << mPassword << "\"!!!" << std::endl;
#endif
resp.mDataStream
<< makeKeyValueReference("want_password", mWantPassword)
<< makeKeyValueReference("key_name", mKeyName)
<< makeKeyValueReference("prev_is_bad", mPrevIsBad);
resp.mStateToken = mStateToken;
resp.setOk();
}
void RsControlModule::setRunState(RunState s, std::string errstr)
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
mRunState = s;
mLastErrorString = errstr;
mStateTokenServer->replaceToken(mStateToken);
}
uint32_t TmpBlobStore::storeBlob(std::vector<uint8_t>& bytes)
{
if(bytes.size() > MAX_BLOBSIZE)
return 0;
RS_STACK_MUTEX(mMtx);
Blob* blob = new Blob();
blob->bytes.swap(bytes);
blob->timestamp = time(NULL);
blob->id = locked_make_id();
blob->next = 0;
if(!mBlobs)
{
mBlobs = blob;
return blob->id;
}
Blob* blob2 = mBlobs;
while(blob2->next)
blob2 = blob2->next;
blob2->next = blob;
return blob->id;
}
void ChatHandler::handleWildcard(Request &/*req*/, Response &resp)
{
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
resp.mDataStream.getStreamToMember();
for(std::map<ChatId, std::list<Msg> >::iterator mit = mMsgs.begin(); mit != mMsgs.end(); ++mit)
{
resp.mDataStream.getStreamToMember() << makeValue(mit->first.toStdString());
}
resp.setOk();
}
ApiServer::~ApiServer()
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
for(std::vector<RequestId>::iterator vit = mRequests.begin(); vit != mRequests.end(); ++vit)
delete vit->task;
mRequests.clear();
if(mMainModules)
delete mMainModules;
}
bool VideoProcessor::nextEncodedPacket(RsVOIPDataChunk& chunk)
{
RS_STACK_MUTEX(vpMtx) ;
if(_encoded_out_queue.empty())
return false ;
chunk = _encoded_out_queue.front() ;
_encoded_out_queue.pop_front() ;
return true ;
}
VideoProcessor::~VideoProcessor()
{
// clear encoding queue
RS_STACK_MUTEX(vpMtx) ;
while(!_encoded_out_queue.empty())
{
_encoded_out_queue.back().clear() ;
_encoded_out_queue.pop_back() ;
}
}
void RsControlModule::handleLogin(Request &req, Response &resp)
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
if(mRunState != WAITING_ACCOUNT_SELECT)
{
resp.setFail("Operation not allowed in this runstate. Login is only allowed rigth after initialisation.");
return;
}
req.mStream << makeKeyValueReference("id", mLoadPeerId)
<< makeKeyValueReference("autologin", mAutoLoginNextTime);
resp.setOk();
}
TmpBlobStore::~TmpBlobStore()
{
mStateTokenServer->unregisterTickClient(this);
RS_STACK_MUTEX(mMtx);
Blob* blob = mBlobs;
while(blob)
{
Blob* next = blob->next;
delete blob;
blob = next;
}
}
ApiServer::RequestId ApiServer::handleRequest(Request &request, Response &response)
{
RequestId id;
ResponseTask* task = 0;
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
task = mRouter.handleRequest(request, response);
}
if(task == 0)
{
id.done = true;
return id;
}
id.done = false,
id.task = task;
id.request = &request;
id.response = &response;
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
mRequests.push_back(id);
}
return id;
}
void ChatHandler::handleInfo(Request &req, Response &resp)
{
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
ChatId id(req.mPath.top());
if(id.isNotSet())
{
resp.setFail("\""+req.mPath.top()+"\" is not a valid chat id");
return;
}
std::map<ChatId, ChatInfo>::iterator mit = mChatInfo.find(id);
if(mit == mChatInfo.end())
{
resp.setFail("chat not found.");
return;
}
resp.mDataStream << mit->second;
resp.setOk();
}
void ChatHandler::handleMessages(Request &req, Response &resp)
{
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
ChatId id(req.mPath.top());
// make response a list
resp.mDataStream.getStreamToMember();
if(id.isNotSet())
{
resp.setFail("\""+req.mPath.top()+"\" is not a valid chat id");
return;
}
std::map<ChatId, std::list<Msg> >::iterator mit = mMsgs.find(id);
if(mit == mMsgs.end())
{
resp.mStateToken = mMsgStateToken; // even set state token, if not found yet, maybe later messages arrive and then the chat id will be found
resp.setFail("chat with id=\""+req.mPath.top()+"\" not found");
return;
}
resp.mStateToken = mMsgStateToken;
handlePaginationRequest(req, resp, mit->second);
}
bool TmpBlobStore::fetchBlob(uint32_t blobid, std::vector<uint8_t>& bytes)
{
RS_STACK_MUTEX(mMtx);
Blob* prev = 0;
Blob* current = mBlobs;
for(; current != 0; current = current->next)
{
if(current->id == blobid)
{
bytes.swap(current->bytes);
if(prev)
prev->next = current->next;
else
mBlobs = current->next;
delete current;
return true;
}
prev = current;
}
return false;
}
void TmpBlobStore::tick()
{
RS_STACK_MUTEX(mMtx);
Blob* prev = 0;
Blob* current = mBlobs;
time_t now = time(NULL);
for(; current != 0; current = current->next)
{
if(current->timestamp + BLOB_STORE_TIME_SECS < now)
{
if(prev)
prev->next = current->next;
else
mBlobs = current->next;
delete current;
return;
}
prev = current;
}
}
void ChatHandler::handleLobbies(Request &/*req*/, Response &resp)
{
tick();
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
resp.mDataStream.getStreamToMember();
for(std::vector<Lobby>::iterator vit = mLobbies.begin(); vit != mLobbies.end(); ++vit)
{
uint32_t unread_msgs = 0;
ChatId chat_id(vit->id);
std::map<ChatId, std::list<Msg> >::iterator mit = mMsgs.find(chat_id);
if(mit != mMsgs.end())
{
std::list<Msg>& msgs = mit->second;
for(std::list<Msg>::iterator lit = msgs.begin(); lit != msgs.end(); ++lit)
if(!lit->read)
unread_msgs++;
}
resp.mDataStream.getStreamToMember() << *vit << makeKeyValueReference("unread_msg_count", unread_msgs);
}
resp.mStateToken = mLobbiesStateToken;
resp.setOk();
}
void ChatHandler::handleUnreadMsgs(Request &/*req*/, Response &resp)
{
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
resp.mDataStream.getStreamToMember();
for(std::map<ChatId, std::list<Msg> >::const_iterator mit = mMsgs.begin(); mit != mMsgs.end(); ++mit)
{
uint32_t count = 0;
for(std::list<Msg>::const_iterator lit = mit->second.begin(); lit != mit->second.end(); ++lit)
if(!lit->read)
count++;
std::map<ChatId, ChatInfo>::iterator mit2 = mChatInfo.find(mit->first);
if(mit2 == mChatInfo.end())
std::cerr << "Error in ChatHandler::handleUnreadMsgs(): ChatInfo not found. It is weird if this happens. Normally it should not happen." << std::endl;
if(count && (mit2 != mChatInfo.end()))
{
resp.mDataStream.getStreamToMember()
<< makeKeyValue("id", mit->first.toStdString())
<< makeKeyValueReference("unread_count", count)
<< mit2->second;
}
}
resp.mStateToken = mUnreadMsgsStateToken;
}
bool ApiServer::isRequestDone(RequestId id)
{
if(id.done)
return true;
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
std::vector<RequestId>::iterator vit = std::find(mRequests.begin(), mRequests.end(), id);
// Request id not found, maybe the id is old and was removed from the list
if(vit == mRequests.end())
return true;
if(id.task->doWork(*id.request, *id.response))
return false;
// if we reach this point, the request is in the list and done
// remove the id from the list of valid ids
// delete the ResponseTask object
*vit = mRequests.back();
mRequests.pop_back();
delete id.task;
return true;
}
void ApiServer::loadMainModules(const RsPlugInInterfaces &ifaces)
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
if(mMainModules == 0)
mMainModules = new ApiServerMainModules(mRouter, &mStateTokenServer, ifaces);
}
bool RsControlModule::processShouldExit()
{
RS_STACK_MUTEX(mExitFlagMtx); // ********** LOCKED **********
return mProcessShouldExit;
}
void RsControlModule::handleCreateLocation(Request &req, Response &resp)
{
std::string hidden_address;
std::string hidden_port_str;
req.mStream << makeKeyValueReference("hidden_adress", hidden_address)
<< makeKeyValueReference("hidden_port", hidden_port_str);
uint16_t hidden_port = 0;
bool auto_tor = false ; // to be set by API, so disabled until then.
if(hidden_address.empty() != hidden_port_str.empty())
{
resp.setFail("you must both specify string hidden_adress and string hidden_port to create a hidden node.");
return;
}
if(!hidden_address.empty())
{
int p;
if(sscanf(hidden_port_str.c_str(), "%i", &p) != 1)
{
resp.setFail("failed to parse hidden_port, not a number. Must be a dec or hex number.");
return;
}
if(p < 0 || p > 0xFFFF)
{
resp.setFail("hidden_port out of range. It must fit into uint16!");
return;
}
hidden_port = p;
}
RsPgpId pgp_id;
std::string pgp_name;
std::string pgp_password;
std::string ssl_name;
req.mStream << makeKeyValueReference("pgp_id", pgp_id)
<< makeKeyValueReference("pgp_name", pgp_name)
<< makeKeyValueReference("pgp_password", pgp_password)
<< makeKeyValueReference("ssl_name", ssl_name);
if(pgp_password.empty())
{
resp.setFail("Error: pgp_password is empty.");
return;
}
// pgp_id is set: use existing pgp key
// pgp_name is set: attempt to create a new key
if(pgp_id.isNull() && (pgp_name.empty()||pgp_password.empty()))
{
resp.setFail("You have to set pgp_id to use an existing key, or pgp_name and pgp_password to create a new pgp key.");
return;
}
if(pgp_id.isNull())
{
std::string err_string;
if(!RsAccounts::GeneratePGPCertificate(pgp_name, "", pgp_password, pgp_id, 2048, err_string))
{
resp.setFail("could not create pgp key: "+err_string);
return;
}
}
if(hidden_port) {
/// TODO add bob to webui
RsInit::SetHiddenLocation(hidden_address, hidden_port, false);
}
std::string ssl_password = RSRandom::random_alphaNumericString(RsInit::getSslPwdLen()) ;
/* GenerateSSLCertificate - selects the PGP Account */
//RsInit::SelectGPGAccount(PGPId);
RsPeerId ssl_id;
std::string err_string;
// give the password to the password callback
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
mPassword = pgp_password;
mFixedPassword = pgp_password;
}
bool ssl_ok = RsAccounts::createNewAccount(pgp_id, "", ssl_name, "", hidden_port!=0, auto_tor!=0, ssl_password, ssl_id, err_string);
// clear fixed password to restore normal password operation
// {
// RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
// mFixedPassword = "";
// }
if (ssl_ok)
{
// load ssl password and load account
RsInit::LoadPassword(ssl_password);
// trigger login in init thread
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
mLoadPeerId = ssl_id;
}
resp.mDataStream << makeKeyValueReference("pgp_id", pgp_id)
<< makeKeyValueReference("pgp_name", pgp_name)
<< makeKeyValueReference("ssl_name", ssl_name)
<< makeKeyValueReference("ssl_id", ssl_id);
resp.setOk();
return;
}
resp.setFail("could not create a new location. Error: "+err_string);
}
void RsControlModule::handleShutdown(Request &, Response &resp)
{
RS_STACK_MUTEX(mExitFlagMtx); // ********** LOCKED **********
mProcessShouldExit = true;
resp.setOk();
}
void VideoProcessor::receiveEncodedData(const RsVOIPDataChunk& chunk)
{
static const int HEADER_SIZE = 4 ;
// read frame type. Use first 4 bytes to give info about content.
//
// Byte Meaning Values
// 00 Codec CODEC_ID_JPEG_VIDEO Basic Jpeg codec
// CODEC_ID_DDWT_VIDEO Differential wavelet compression
//
// 01 Unused Might be useful later
//
// 0203 Flags Codec specific flags.
//
if(chunk.size < HEADER_SIZE)
{
std::cerr << "JPEGVideoDecoder::decodeData(): Too small a data packet. size=" << chunk.size << std::endl;
return ;
}
uint32_t codid = ((unsigned char *)chunk.data)[0] + (((unsigned char *)chunk.data)[1] << 8) ;
//uint16_t flags = ((unsigned char *)chunk.data)[2] + (((unsigned char *)chunk.data)[3] << 8) ;
VideoCodec *codec ;
switch(codid)
{
case VIDEO_PROCESSOR_CODEC_ID_JPEG_VIDEO: codec = &_jpeg_video_codec ;
break ;
case VIDEO_PROCESSOR_CODEC_ID_MPEG_VIDEO: codec = &_mpeg_video_codec ;
break ;
default:
codec = NULL ;
}
if(codec == NULL)
{
std::cerr << "Unknown decoding codec: " << codid << std::endl;
return ;
}
{
RS_STACK_MUTEX(vpMtx) ;
_total_encoded_size_in += chunk.size ;
time_t now = time(NULL) ;
if(now > _last_bw_estimate_in_TS)
{
_estimated_bandwidth_in = uint32_t(0.75*_estimated_bandwidth_in + 0.25 * (_total_encoded_size_in / (float)(now - _last_bw_estimate_in_TS))) ;
_total_encoded_size_in = 0 ;
_last_bw_estimate_in_TS = now ;
#ifdef DEBUG_VIDEO_OUTPUT_DEVICE
std::cerr << "new bw estimate (in): " << _estimated_bandwidth_in << std::endl;
#endif
}
}
QImage img ;
if(!codec->decodeData(chunk,img))
{
std::cerr << "No image decoded. Probably in the middle of something..." << std::endl;
return ;
}
if(_decoded_output_device)
// if (time(NULL) > _lastTimeToShowFrame)
// {
_decoded_output_device->showFrame(img) ;
// _lastTimeToShowFrame = time(NULL) ;//+ 1000/25;
#warning \plugins\VOIP\gui\VideoProcessor.cpp:210 Phenom: TODO: Get CPU usage to pass image.
// }
}
void RsControlModule::run()
{
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule: initialising libretroshare..." << std::endl;
#endif
RsInit::InitRsConfig();
int initResult = RsInit::InitRetroShare(argc, argv, true);
if (initResult < 0) {
std::cerr << "RsControlModule: FATAL ERROR, initialising libretroshare FAILED." << std::endl;
/* Error occured */
std::stringstream ss;
switch (initResult) {
case RS_INIT_AUTH_FAILED:
ss << "RsControlModule::run() AuthGPG::InitAuth failed" << std::endl;
break;
default:
/* Unexpected return code */
ss << "ControlModule::run() unexpected return code " << initResult << std::endl;
break;
}
// FATAL ERROR, we can't recover from this. Just send the message to the user.
setRunState(FATAL_ERROR, ss.str());
return;
}
// This is needed to allocate rsNotify, so that it can be used to ask for PGP passphrase
RsControl::earlyInitNotificationSystem();
rsNotify->registerNotifyClient(this);
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() Entering login wait loop." << std::endl;
#endif
bool login_ok = false;
while(!login_ok)
{
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() reseting passwd." << std::endl;
#endif
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
mPassword = "";
}
// skip account selection if autologin is available
bool wait_for_account_select = (initResult != RS_INIT_HAVE_ACCOUNT);
// wait for login request
bool auto_login = false;
if(wait_for_account_select)
{
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() wait_for_account_select=true => setting run state to WAITING_ACCOUNT_SELECT." << std::endl;
#endif
setRunState(WAITING_ACCOUNT_SELECT);
}
while(wait_for_account_select && !processShouldExit())
{
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() while(wait_for_account_select) mLoadPeerId=" << mLoadPeerId << std::endl;
#endif
usleep(500*1000);
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
if(!mLoadPeerId.isNull())
{
wait_for_account_select = wait_for_account_select && !RsAccounts::SelectAccount(mLoadPeerId);
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() mLoadPeerId != NULL, account selection result: " << !wait_for_account_select << std::endl;
#endif
}
auto_login = mAutoLoginNextTime;
//if(!wait_for_account_select)
//{
// if(wait_for_account_select)
// setRunState(WAITING_ACCOUNT_SELECT);
//}
}
if(processShouldExit())
return;
bool autoLogin = (initResult == RS_INIT_HAVE_ACCOUNT) | auto_login;
std::string lockFile;
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() trying to load certificate..." << std::endl;
#endif
int retVal = RsInit::LockAndLoadCertificates(autoLogin, lockFile);
std::string error_string;
switch (retVal) {
case 0:
login_ok = true;
break;
case 1:
error_string = "Another RetroShare using the same profile is "
"already running on your system. Please close "
"that instance first\n Lock file:\n" + lockFile;
break;
case 2:
error_string = "An unexpected error occurred when Retroshare "
"tried to acquire the single instance lock\n Lock file:\n"
+ lockFile;
break;
case 3:
error_string = "Login Failure: Maybe password is wrong";
break;
default:
std::cerr << "RsControlModule::run() LockAndLoadCertificates failed. Unexpected switch value: " << retVal << std::endl;
break;
}
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() Error string: \"" << error_string << "\"" << std::endl;
#endif
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
mLoadPeerId.clear();
}
}
#ifdef DEBUG_CONTROL_MODULE
std::cerr << "RsControlModule::run() login is ok. Starting up..." << std::endl;
#endif
{
RS_STACK_MUTEX(mDataMtx); // ********** LOCKED **********
mFixedPassword = mPassword;
std::cerr << "***Reseting mPasswd " << std::endl;
mPassword = "";
}
setRunState(WAITING_STARTUP);
std::cerr << "RsControlModule: login ok, starting Retroshare worker threads..." << std::endl;
RsControl::instance() -> StartupRetroShare();
std::cerr << "RsControlModule: loading main resource api modules..." << std::endl;
RsPlugInInterfaces ifaces;
getPluginInterfaces(ifaces);
mApiServer->loadMainModules(ifaces);
std::cerr << "RsControlModule: Retroshare is up and running. Enjoy!" << std::endl;
setRunState(RUNNING_OK);
while(!processShouldExit())
{
usleep(5*1000);
}
std::cerr << "RsControlModule: stopping Retroshare..." << std::endl;
RsControl::instance() -> rsGlobalShutDown();
std::cerr << "RsControlModule: Retroshare stopped. Bye!" << std::endl;
}
std::string ApiServer::handleRequest(Request &request)
{
resource_api::JsonStream outstream;
std::stringstream debugString;
StreamBase& data = outstream.getStreamToMember("data");
resource_api::Response resp(data, debugString);
ResponseTask* task = 0;
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
task = mRouter.handleRequest(request, resp);
}
time_t start = time(NULL);
bool morework = true;
while(task && morework)
{
{
RS_STACK_MUTEX(mMtx); // ********** LOCKED **********
morework = task->doWork(request, resp);
}
if(morework)
usleep(10*1000);
/*if(time(NULL) > (start+5))
{
std::cerr << "ApiServer::handleRequest() Error: task timed out" << std::endl;
resp.mDebug << "Error: task timed out." << std::endl;
resp.mReturnCode = resource_api::Response::FAIL;
break;
}*/
}
if(task)
delete task;
std::string returncode;
switch(resp.mReturnCode){
case resource_api::Response::NOT_SET:
returncode = "not_set";
break;
case resource_api::Response::OK:
returncode = "ok";
break;
case resource_api::Response::WARNING:
returncode = "warning";
break;
case resource_api::Response::FAIL:
returncode = "fail";
break;
}
// evil HACK, remove this
if(data.isRawData())
return data.getRawData();
outstream << resource_api::makeKeyValue("debug_msg", debugString.str());
outstream << resource_api::makeKeyValueReference("returncode", returncode);
if(!resp.mStateToken.isNull())
outstream << resource_api::makeKeyValueReference("statetoken", resp.mStateToken);
return outstream.getJsonString();
}
