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(); }