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::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 servicePermissionToStream(StreamBase& stream, RsServicePermissions& perm) { stream << makeKeyValueReference("service_id", perm.mServiceId) << makeKeyValueReference("service_name", perm.mServiceName) << makeKeyValueReference("default_allowed", perm.mDefaultAllowed) ; setToStream(stream.getStreamToMember("peers_allowed"), perm.mPeersAllowed); setToStream(stream.getStreamToMember("peers_denied"), perm.mPeersDenied); }
void ServiceControlHandler::handleUser(Request& req, Response& resp){ // no get, only put (post) to allow user or delete to remove user std::string serviceidtext; std::string peeridtext; bool enabled; bool ok; req.mStream << makeKeyValueReference("service_id", serviceidtext) << makeKeyValueReference("peer_id", peeridtext) << makeKeyValueReference("enabled", enabled); RsPeerId peer_id(peeridtext); if (peer_id.isNull()) { resp.setFail("peer_id missing or not found"); return; } RsServicePermissions serv_perms ; uint32_t serviceid = atoi(serviceidtext.c_str()); if (serviceid == 0) { resp.setFail("service_id missed"); return; } if(!rsServiceControl->getServicePermissions(serviceid, serv_perms)){ resp.setFail("service_id " + serviceidtext + " is invalid"); return; } if(req.isPut()) { if (enabled && !serv_perms.peerHasPermission(peer_id)) { serv_perms.setPermission(peer_id); } else if (!enabled && serv_perms.peerHasPermission(peer_id)){ serv_perms.resetPermission(peer_id); } else { //nothing todo resp.setOk(); return; } } else { resp.setFail("only POST supported."); return; } ok = rsServiceControl->updateServicePermissions(serviceid,serv_perms); if (!ok) { resp.setFail("updateServicePermissions failed"); return; } resp.setOk(); }
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(); }
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 GxsResponseTask::streamGxsId(RsGxsId id, StreamBase &stream) { // will see if this works or if we have to use an index for(std::vector<RsIdentityDetails>::iterator vit = mIdentityDetails.begin(); vit != mIdentityDetails.end(); ++vit) { if(vit->mId == id) { stream << makeKeyValueReference("id", id) << makeKeyValueReference("gxs_id", id) << makeKeyValueReference("flags", vit->mFlags) << makeKeyValueReference("name", vit->mNickname); return; } } }
void ChatHandler::handleSendMessage(Request &req, Response &resp) { std::string chat_id; std::string msg; req.mStream << makeKeyValueReference("chat_id", chat_id) << makeKeyValueReference("msg", msg); ChatId id(chat_id); if(id.isNotSet()) { resp.setFail("chat_id is invalid"); return; } if(mRsMsgs->sendChat(id, msg)) resp.setOk(); else resp.setFail("failed to send message"); }
StreamBase& operator <<(StreamBase& left, KeyValueReference<uint32_t> ref) { if(left.serialise()) { uint32_t num = ref.value; uint8_t digit; std::string str; while(num >= 10) { digit = num % 10; num = num / 10; str = (char)(digit + '0') + str; } str = (char)(num + '0') + str; left << makeKeyValueReference(ref.key, str); } else { std::string str; left << makeKeyValueReference(ref.key, str); uint32_t num = 0; for(std::string::iterator sit = str.begin(); sit != str.end(); sit++) { uint32_t numbefore = num; num = num * 10; if(num < numbefore) { left.addErrorMsg("operator for uint32_t to std::string: oveflow"); left.setError(); } else if((*sit)<'0' || (*sit)>'9') { left.addErrorMsg("operator for uint32_t to std::string: invalid characters"); left.setError(); } else { // everything ok, can add value num += (*sit) - '0'; } } } return left; }
void RsControlModule::handlePassword(Request &req, Response &resp) { RsStackMutex stack(mDataMtx); // ********** LOCKED ********** std::string passwd; req.mStream << makeKeyValueReference("password", passwd); if(passwd != "" && mWantPassword) { // client sends password mPassword = passwd; mWantPassword = false; mStateTokenServer->replaceToken(mStateToken); } resp.mDataStream << makeKeyValueReference("want_password", mWantPassword) << makeKeyValueReference("key_name", mKeyName); resp.mStateToken = mStateToken; resp.setOk(); }
void ChatHandler::handleSubscribeLobby(Request &req, Response &resp) { ChatLobbyId id = 0; RsGxsId gxs_id; req.mStream << makeKeyValueReference("id", id) << makeKeyValueReference("gxs_id", gxs_id); if(id == 0) { resp.setFail("Error: id must not be null"); return; } if(gxs_id.isNull()) { resp.setFail("Error: gxs_id must not be null"); return; } if(mRsMsgs->joinVisibleChatLobby(id, gxs_id)) resp.setOk(); else resp.setFail("lobby join failed. (See console for more info)"); }
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 RsControlModule::handleImportPgp(Request &req, Response &resp) { std::string key_string; req.mStream << makeKeyValueReference("key_string", key_string); if(key_string.empty()) { resp.setFail("required field key_string is empty"); return; } RsPgpId pgp_id; std::string error_string; if(RsAccounts::ImportIdentityFromString(key_string, pgp_id, error_string)) { resp.mDataStream << makeKeyValueReference("pgp_id", pgp_id); resp.setOk(); return; } resp.setFail("Failed to import key: " + error_string); }
StreamBase& operator << (StreamBase& left, ChatHandler::Lobby& l) { ChatId chatId(l.id); if (l.is_broadcast) chatId = ChatId::makeBroadcastId(); left << makeKeyValueReference("id", l.id) << makeKeyValue("chat_id", chatId.toStdString()) << makeKeyValueReference("name",l.name) << makeKeyValueReference("topic", l.topic) << makeKeyValueReference("subscribed", l.subscribed) << makeKeyValueReference("auto_subscribe", l.auto_subscribe) << makeKeyValueReference("is_private", l.is_private) << makeKeyValueReference("is_broadcast", l.is_broadcast) << makeKeyValueReference("gxs_id", l.gxs_id); return left; }
StreamBase& operator << (StreamBase& left, ChatHandler::ChatInfo& info) { left << makeKeyValueReference("remote_author_id", info.remote_author_id) << makeKeyValueReference("remote_author_name", info.remote_author_name) << makeKeyValueReference("is_broadcast", info.is_broadcast) << makeKeyValueReference("is_gxs_id", info.is_gxs_id) << makeKeyValueReference("is_lobby", info.is_lobby) << makeKeyValueReference("is_peer", info.is_peer); return left; }
StreamBase& operator <<(StreamBase& left, KeyValueReference<ChatLobbyId> kv) { if(left.serialise()) { std::stringstream ss; ss << kv.value; left << makeKeyValue(kv.key, ss.str()); } else { std::string val; left << makeKeyValueReference(kv.key, val); std::stringstream ss(val); ss >> kv.value; } return left; }
// return MHD_NO or MHD_YES virtual int handleRequest( struct MHD_Connection *connection, const char */*url*/, const char *method, const char */*version*/, const char *upload_data, size_t *upload_data_size) { // new request if(mState == BEGIN) { if(strcmp(method, "POST") == 0) { mState = WAITING_DATA; // first time there is no data, do nothing and return return MHD_YES; } } if(mState == WAITING_DATA) { if(upload_data && *upload_data_size) { mRequesString += std::string(upload_data, *upload_data_size); *upload_data_size = 0; return MHD_YES; } } std::vector<uint8_t> bytes(mRequesString.begin(), mRequesString.end()); int id = mApiServer->getTmpBlobStore()->storeBlob(bytes); resource_api::JsonStream responseStream; if(id) responseStream << makeKeyValue("ok", true); else responseStream << makeKeyValue("ok", false); responseStream << makeKeyValueReference("id", id); std::string result = responseStream.getJsonString(); struct MHD_Response* resp = MHD_create_response_from_data(result.size(), (void*)result.data(), 0, 1); MHD_add_response_header(resp, "Content-Type", "application/json"); secure_queue_response(connection, MHD_HTTP_OK, resp); MHD_destroy_response(resp); return MHD_YES; }
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; }
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 ServiceControlHandler::handleWildcard(Request &req, Response &resp) { bool ok = false; if(!req.mPath.empty()) { } else { // no more path element if(req.isGet()) { // list all peers ok = true; RsPeerServiceInfo psi; ok &= mRsServiceControl->getOwnServices(psi); for(std::map<uint32_t, RsServiceInfo>::iterator mit = psi.mServiceList.begin(); mit != psi.mServiceList.end(); mit++) { RsServicePermissions perms; ok &= mRsServiceControl->getServicePermissions(mit->first, perms); if(ok) { servicePermissionToStream(resp.mDataStream.getStreamToMember(), perms); } } } else if(req.isPut()) { // change service default std::string serviceidtext; bool enabled; req.mStream << makeKeyValueReference("service_id", serviceidtext) << makeKeyValueReference("default_allowed", enabled); RsServicePermissions serv_perms ; //uint32_t serviceid = fromString<uint32_t>(serviceidtext); uint32_t serviceid = atoi(serviceidtext.c_str()); if (serviceid == 0) { resp.setFail("service_id missed"); return; } if(!rsServiceControl->getServicePermissions(serviceid, serv_perms)){ resp.setFail("service_id " + serviceidtext + " is invalid"); return; } serv_perms.mDefaultAllowed = enabled; if(serv_perms.mDefaultAllowed) { serv_perms.mPeersDenied.clear() ; } else { serv_perms.mPeersAllowed.clear() ; } ok = rsServiceControl->updateServicePermissions(serviceid,serv_perms); if (!ok) { resp.setFail("updateServicePermissions failed"); return; } } } if(ok) { resp.setOk(); } else { resp.setFail(); } }
StreamBase& operator << (StreamBase& left, ChatHandler::Msg& m) { left << makeKeyValueReference("incoming", m.incoming) << makeKeyValueReference("was_send", m.was_send) << makeKeyValueReference("author_id", m.author_id) << makeKeyValueReference("author_name", m.author_name) << makeKeyValueReference("msg", m.msg) << makeKeyValueReference("recv_time", m.recv_time) << makeKeyValueReference("send_time", m.send_time) << makeKeyValueReference("id", m.id); StreamBase& ls = left.getStreamToMember("links"); ls.getStreamToMember(); for(std::vector<ChatHandler::Triple>::iterator vit = m.links.begin(); vit != m.links.end(); ++vit) { ls.getStreamToMember() << makeKeyValueReference("first", vit->first) << makeKeyValueReference("second", vit->second) << makeKeyValueReference("third", vit->third); } return left; }
void ChatHandler::handleUnsubscribeLobby(Request &req, Response &/*resp*/) { ChatLobbyId id = 0; req.mStream << makeKeyValueReference("id", id); mRsMsgs->unsubscribeChatLobby(id); }
void TerminalApiClient::data_tick() { // values in milliseconds const int MIN_WAIT_TIME = 20; // sleep time must be smaller or equal than the smallest period const int IO_POLL_PERIOD = 20; const int API_EVENT_POLL_PERIOD = 1000; int last_io_poll = 0; int last_event_api_poll = 0; int last_char = 0; std::string inbuf; bool enter_was_pressed = false; StateToken runstate_state_token; std::string runstate; std::vector<std::string> accounts; StateToken password_state_token; bool ask_for_password = false; std::string key_name; TerminalInput term; while(!shouldStop()) { // assuming sleep_time >> work_time // so we don't have to check the absolute time, just sleep every cycle usleep(MIN_WAIT_TIME * 1000); last_io_poll += MIN_WAIT_TIME; last_event_api_poll += MIN_WAIT_TIME; if(last_io_poll >= IO_POLL_PERIOD) { last_io_poll = 0; last_char = 0; if(term.kbhit()) { enter_was_pressed = false; last_char = term.getch(); if(last_char > 127) std::cout << "Warning: non ASCII characters probably won't work." << std::endl; if(last_char >= ' ')// space is the first printable ascii character inbuf += (char) last_char; if(last_char == '\r' || last_char == '\n') enter_was_pressed = true; else enter_was_pressed = false; // send echo if(ask_for_password) std::cout << "*"; else std::cout << (char) last_char; //std::cout << "you pressed key " << (char) last_char << " as integer: " << last_char << std::endl; } } if(last_event_api_poll >= API_EVENT_POLL_PERIOD) { last_event_api_poll = 0; if(!runstate_state_token.isNull() && !isTokenValid(runstate_state_token)) runstate_state_token = StateToken(); // must get new state with new token if(!password_state_token.isNull() && !isTokenValid(password_state_token)) password_state_token = StateToken(); } bool edge = false; if(runstate_state_token.isNull()) { edge = true; JsonStream reqs; JsonStream resps; Request req(reqs); std::stringstream ss; Response resp(resps, ss); req.mPath.push("runstate"); req.mPath.push("control"); reqs.switchToDeserialisation(); ApiServer::RequestId id = mApiServer->handleRequest(req, resp); waitForResponse(id); resps.switchToDeserialisation(); resps << makeKeyValueReference("runstate", runstate); runstate_state_token = resp.mStateToken; } if(password_state_token.isNull()) { edge = true; JsonStream reqs; JsonStream resps; Request req(reqs); std::stringstream ss; Response resp(resps, ss); req.mPath.push("password"); req.mPath.push("control"); reqs.switchToDeserialisation(); ApiServer::RequestId id = mApiServer->handleRequest(req, resp); waitForResponse(id); resps.switchToDeserialisation(); resps << makeKeyValueReference("want_password", ask_for_password); resps << makeKeyValueReference("key_name", key_name); password_state_token = resp.mStateToken; } if(!ask_for_password && edge && runstate == "waiting_account_select") { JsonStream reqs; JsonStream resps; Request req(reqs); std::stringstream ss; Response resp(resps, ss); req.mPath.push("locations"); req.mPath.push("control"); reqs.switchToDeserialisation(); ApiServer::RequestId id = mApiServer->handleRequest(req, resp); waitForResponse(id); resps.switchToDeserialisation(); std::cout << "Type a number to select an account" << std::endl; if(!resps.hasMore()) std::cout << "Error: No Accounts. Use the Qt-GUI or the webinterface to create an account." << std::endl; int i = 0; accounts.clear(); while(resps.hasMore()) { std::string id; std::string name; std::string location; resps.getStreamToMember() << makeKeyValueReference("id", id) << makeKeyValueReference("name", name) << makeKeyValueReference("location", location); std::cout << "[" << i << "] " << name << "(" << location << ")" << std::endl; accounts.push_back(id); i++; } } if(!ask_for_password && runstate == "waiting_account_select" && last_char >= '0' && last_char <= '9' && (last_char-'0') < accounts.size()) { std::string acc = accounts[last_char-'0']; JsonStream reqs; JsonStream resps; Request req(reqs); std::stringstream ss; Response resp(resps, ss); req.mPath.push("login"); req.mPath.push("control"); reqs << makeKeyValueReference("id", acc); reqs.switchToDeserialisation(); ApiServer::RequestId id = mApiServer->handleRequest(req, resp); waitForResponse(id); inbuf.clear(); } if(edge && ask_for_password) { std::cout << "Enter the password for key " << key_name << std::endl; } if(ask_for_password && enter_was_pressed && !inbuf.empty()) { std::cout << "TerminalApiClient: got a password" << std::endl; JsonStream reqs; JsonStream resps; Request req(reqs); std::stringstream ss; Response resp(resps, ss); req.mPath.push("password"); req.mPath.push("control"); reqs << makeKeyValueReference("password", inbuf); reqs.switchToDeserialisation(); ApiServer::RequestId id = mApiServer->handleRequest(req, resp); waitForResponse(id); inbuf.clear(); } } }
void IdentityHandler::handleWildcard(Request &req, Response &resp) { bool ok = true; if(req.isPut()) { RsIdentityParameters params; req.mStream << makeKeyValueReference("name", params.nickname); if(req.mStream.isOK()) { uint32_t token; mRsIdentity->createIdentity(token, params); // not sure if should acknowledge the token // for now go the easier way } else { ok = false; } } else { RsTokReqOptions opts; opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA; uint32_t token; mRsIdentity->getTokenService()->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts); time_t start = time(NULL); while((mRsIdentity->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE) &&(mRsIdentity->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED) &&((time(NULL) < (start+10))) ) { #ifdef WINDOWS_SYS Sleep(500); #else usleep(500*1000) ; #endif } if(mRsIdentity->getTokenService()->requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE) { std::vector<RsGxsIdGroup> grps; ok &= mRsIdentity->getGroupData(token, grps); for(std::vector<RsGxsIdGroup>::iterator vit = grps.begin(); vit != grps.end(); vit++) { RsGxsIdGroup& grp = *vit; KeyValueReference<RsGxsGroupId> id("id", grp.mMeta.mGroupId); KeyValueReference<RsPgpId> pgp_id("pgp_id",grp.mPgpId ); // not very happy about this, i think the flags should stay hidden in rsidentities bool own = (grp.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN); bool pgp_linked = (grp.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID); resp.mDataStream.getStreamToMember() << id << pgp_id << makeKeyValueReference("name", grp.mMeta.mGroupName) << makeKeyValueReference("own", own) << makeKeyValueReference("pgp_linked", pgp_linked); } } else { ok = false; } } if(ok) { resp.setOk(); } else { resp.setFail(); } }
void ForumHandler::handleWildcard(Request &req, Response &resp) { bool ok = true; if(!req.mPath.empty()) { std::string str = req.mPath.top(); req.mPath.pop(); if(str != "") { //assume we have a groupID RsGxsGroupId grpId(str); std::list<RsGxsGroupId> groupIds; groupIds.push_back(grpId); uint32_t token; RsTokReqOptions opts; opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA; mRsGxsForums->getTokenService()->requestMsgInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, groupIds); time_t start = time(NULL); while((mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE) &&(mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED) &&((time(NULL) < (start+10))) ) { #ifdef WINDOWS_SYS Sleep(500); #else usleep(500*1000) ; #endif } if(mRsGxsForums->getTokenService()->requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE) { std::vector<RsGxsForumMsg> grps; ok &= mRsGxsForums->getMsgData(token, grps); for(std::vector<RsGxsForumMsg>::iterator vit = grps.begin(); vit != grps.end(); vit++) { RsGxsForumMsg& grp = *vit; KeyValueReference<RsGxsGroupId> group_id("group_id", grp.mMeta.mGroupId); resp.mDataStream.getStreamToMember() << group_id << makeKeyValueReference("name", grp.mMeta.mMsgName) << makeKeyValueReference("id", grp.mMeta.mMsgId) << makeKeyValueReference("parent_id", grp.mMeta.mParentId) << makeKeyValueReference("author_id", grp.mMeta.mAuthorId) << makeKeyValueReference("orig_msg_id", grp.mMeta.mOrigMsgId) << makeKeyValueReference("thread_id", grp.mMeta.mThreadId) << makeKeyValueReference("message", grp.mMsg); } } else { ok = false; } } } else { // no more path element RsTokReqOptions opts; opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA; uint32_t token; mRsGxsForums->getTokenService()->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts); time_t start = time(NULL); while((mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE) &&(mRsGxsForums->getTokenService()->requestStatus(token) != RsTokenService::GXS_REQUEST_V2_STATUS_FAILED) &&((time(NULL) < (start+10))) ) { #ifdef WINDOWS_SYS Sleep(500); #else usleep(500*1000) ; #endif } if(mRsGxsForums->getTokenService()->requestStatus(token) == RsTokenService::GXS_REQUEST_V2_STATUS_COMPLETE) { std::vector<RsGxsForumGroup> grps; ok &= mRsGxsForums->getGroupData(token, grps); for(std::vector<RsGxsForumGroup>::iterator vit = grps.begin(); vit != grps.end(); vit++) { RsGxsForumGroup& grp = *vit; KeyValueReference<RsGxsGroupId> id("id", grp.mMeta.mGroupId); KeyValueReference<uint32_t> vis_msg("visible_msg_count", grp.mMeta.mVisibleMsgCount); //KeyValueReference<RsPgpId> pgp_id("pgp_id",grp.mPgpId ); // not very happy about this, i think the flags should stay hidden in rsidentities bool own = (grp.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN); bool pgp_linked = (grp.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID); bool subscribed = IS_GROUP_SUBSCRIBED(grp.mMeta.mSubscribeFlags); resp.mDataStream.getStreamToMember() << id //<< pgp_id << makeKeyValueReference("name", grp.mMeta.mGroupName) //<< makeKeyValueReference("last_post", grp.mMeta.mLastPost) << makeKeyValueReference("pop", grp.mMeta.mPop) //<< makeKeyValueReference("publish_ts", grp.mMeta.mPublishTs) << vis_msg << makeKeyValueReference("group_status", grp.mMeta.mGroupStatus) << makeKeyValueReference("author_id", grp.mMeta.mAuthorId) << makeKeyValueReference("parent_grp_id", grp.mMeta.mParentGrpId) << makeKeyValueReference("description", grp.mDescription) << makeKeyValueReference("own", own) << makeKeyValueReference("subscribed", subscribed) << makeKeyValueReference("pgp_linked", pgp_linked); } } else { ok = false; } } if(ok) { resp.setOk(); } else { resp.setFail(); } }