void DSMFactory::loadDSMWithPaths(const AmArg& args, AmArg& ret) {
string dsm_name = args.get(0).asCStr();
string diag_path = args.get(1).asCStr();
string mod_path = args.get(2).asCStr();
string res = "OK";
ScriptConfigs_mut.lock();
try {
if (MainScriptConfig.diags->hasDiagram(dsm_name)) {
ret.push(400);
ret.push("DSM named '" + dsm_name + "' already loaded (use reloadDSMs to reload all)");
} else {
if (!MainScriptConfig.diags->loadFile(diag_path+dsm_name+".dsm", dsm_name, mod_path, DebugDSM)) {
ret.push(500);
ret.push("error loading "+dsm_name+" from "+ diag_path+dsm_name+".dsm");
} else {
ret.push(200);
ret.push("loaded "+dsm_name+" from "+ diag_path+dsm_name+".dsm");
}
}
} catch(...) {
ScriptConfigs_mut.unlock();
throw;
}
ScriptConfigs_mut.unlock();
}
void DSMFactory::registerApplication(const AmArg& args, AmArg& ret) {
string diag_name = args.get(0).asCStr();
string conf_name;
if (args.size()>1 && isArgCStr(args.get(1)))
conf_name = args.get(1).asCStr();
bool has_diag;
ScriptConfigs_mut.lock();
try {
has_diag = hasDSM(diag_name, conf_name);
} catch(...) {
ScriptConfigs_mut.unlock();
throw;
}
ScriptConfigs_mut.unlock();
if (!has_diag) {
ret.push(400);
ret.push("unknown application (DSM)");
return;
}
bool res = AmPlugIn::instance()->registerFactory4App(diag_name,this);
if(res) {
INFO("DSM state machine registered: %s.\n",diag_name.c_str());
ret.push(200);
ret.push("registered DSM application");
} else {
ret.push(500);
ret.push("Error registering DSM application (already registered?)");
}
}
void DSMFactory::listDSMs(const AmArg& args, AmArg& ret) {
vector<string> names;
ScriptConfigs_mut.lock();
try {
if (isArgUndef(args) || !args.size())
names = MainScriptConfig.diags->getDiagramNames();
else {
if (isArgCStr(args.get(0))) {
map<string, DSMScriptConfig>::iterator i=
ScriptConfigs.find(args.get(0).asCStr());
if (i!= ScriptConfigs.end())
names = i->second.diags->getDiagramNames();
}
}
} catch (...) {
ScriptConfigs_mut.unlock();
throw;
}
ScriptConfigs_mut.unlock();
for (vector<string>::iterator it=
names.begin(); it != names.end(); it++) {
ret.push(*it);
}
}
void WebConferenceFactory::roomCreate(const AmArg& args, AmArg& ret) {
assertArgCStr(args.get(0));
string room = args.get(0).asCStr();
rooms_mut.lock();
// sweep rooms (if necessary)
sweepRooms();
map<string, ConferenceRoom>::iterator it = rooms.find(room);
if (it == rooms.end()) {
rooms[room] = ConferenceRoom();
rooms[room].adminpin = getRandomPin();
ret.push(0);
ret.push("OK");
ret.push(rooms[room].adminpin.c_str());
} else {
if (rooms[room].adminpin.empty()) {
rooms[room].adminpin = getRandomPin();
ret.push(0);
ret.push("OK");
ret.push(rooms[room].adminpin.c_str());
} else {
ret.push(1);
ret.push("room already opened");
ret.push("");
}
}
rooms_mut.unlock();
}
void DIDial::invoke(const string& method, const AmArg& args, AmArg& ret)
{
if(method == "dial"){
ret.push(dialout(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
args.get(3).asCStr()).c_str());
} else if(method == "dial_auth"){
ret.push(dialout_auth(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
args.get(3).asCStr(),
args.get(4).asCStr(),
args.get(5).asCStr(),
args.get(6).asCStr()
).c_str());
} else if(method == "dial_pin"){
ret.push(dialout_pin(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
args.get(3).asCStr()
).c_str());
} else if(method == "help"){
ret.push("dial <application> <user> <from> <to>");
ret.push("dial_auth <application> <user> <from> <to> <realm> <auth_user> <auth_pwd>");
ret.push("dial_pin <application> <dialout pin> <local_user> <to_user>");
} else if(method == "_list"){
ret.push(AmArg("dial"));
ret.push(AmArg("dial_auth"));
ret.push(AmArg("dial_pin"));
ret.push(AmArg("help"));
} else
throw AmDynInvoke::NotImplemented(method);
}
void UACAuthFactory::invoke(const string& method, const AmArg& args, AmArg& ret)
{
if (method == "getHandler") {
CredentialHolder* c = dynamic_cast<CredentialHolder*>(args.get(0).asObject());
DialogControl* cc = dynamic_cast<DialogControl*>(args.get(1).asObject());
if ((c!=NULL)&&(cc!=NULL)) {
AmArg handler;
handler.setBorrowedPointer(getHandler(cc->getDlg(), c));
ret.push(handler);
} else {
ERROR("wrong types in call to getHandler. (c=%ld, cc= %ld)\n",
(unsigned long)c, (unsigned long)cc);
}
} else if (method == "checkAuth") {
// params: Request realm user pwd
if (args.size() < 4) {
ERROR("missing arguments to uac_auth checkAuth function, expected Request realm user pwd\n");
throw AmArg::TypeMismatchException();
}
AmSipRequest* req = dynamic_cast<AmSipRequest*>(args.get(0).asObject());
if (NULL == req)
throw AmArg::TypeMismatchException();
UACAuth::checkAuthentication(req, args.get(1).asCStr(),
args.get(2).asCStr(),
args.get(3).asCStr(), ret);
} else
throw AmDynInvoke::NotImplemented(method);
}
void WebConferenceFactory::postConfEvent(const AmArg& args, AmArg& ret,
int id, int mute) {
for (int i=0;i<2;i++)
assertArgCStr(args.get(1));
string room = args.get(0).asCStr();
string adminpin = args.get(1).asCStr();
string call_tag = args.get(2).asCStr();
// check adminpin
rooms_mut.lock();
ConferenceRoom* r = getRoom(room, adminpin);
if (NULL == r) {
ret.push(1);
ret.push("wrong adminpin");
rooms_mut.unlock();
return;
}
bool p_exists = r->hasParticipant(call_tag);
if (p_exists && (mute >= 0))
r->setMuted(call_tag, mute);
rooms_mut.unlock();
if (p_exists) {
AmSessionContainer::instance()->postEvent(call_tag,
new WebConferenceEvent(id));
ret.push(0);
ret.push("OK");
} else {
ret.push(2);
ret.push("call does not exist");
}
}
void DSMFactory::invoke(const string& method, const AmArg& args,
AmArg& ret)
{
if (method == "postDSMEvent"){
assertArgCStr(args.get(0))
DSMEvent* ev = new DSMEvent();
for (size_t i=0;i<args[1].size();i++)
ev->params[args[1][i][0].asCStr()] = args[1][i][1].asCStr();
if (AmSessionContainer::instance()->postEvent(args.get(0).asCStr(), ev)) {
ret.push(AmArg(200));
ret.push(AmArg("OK"));
} else {
ret.push(AmArg(404));
ret.push(AmArg("Session not found"));
}
} else if (method == "reloadDSMs"){
reloadDSMs(args,ret);
} else if (method == "loadDSM"){
args.assertArrayFmt("s");
loadDSM(args,ret);
} else if (method == "loadDSMWithPath"){
args.assertArrayFmt("sss");
loadDSMWithPaths(args,ret);
} else if (method == "preloadModules"){
preloadModules(args,ret);
} else if (method == "preloadModule"){
args.assertArrayFmt("ss");
preloadModule(args,ret);
} else if (method == "hasDSM"){
args.assertArrayFmt("s");
hasDSM(args,ret);
} else if (method == "listDSMs"){
listDSMs(args,ret);
} else if (method == "registerApplication"){
args.assertArrayFmt("s");
registerApplication(args,ret);
} else if (method == "loadConfig"){
args.assertArrayFmt("ss");
loadConfig(args,ret);
} else if(method == "_list"){
ret.push(AmArg("postDSMEvent"));
ret.push(AmArg("reloadDSMs"));
ret.push(AmArg("loadDSM"));
ret.push(AmArg("loadDSMWithPaths"));
ret.push(AmArg("preloadModules"));
ret.push(AmArg("preloadModule"));
ret.push(AmArg("loadConfig"));
ret.push(AmArg("hasDSM"));
ret.push(AmArg("listDSMs"));
ret.push(AmArg("registerApplication"));
} else
throw AmDynInvoke::NotImplemented(method);
}
void WebConferenceFactory::dialout(const AmArg& args, AmArg& ret) {
for (int i=0;i<6;i++)
assertArgCStr(args.get(1));
string room = args.get(0).asCStr();
string adminpin = args.get(1).asCStr();
string callee = args.get(2).asCStr();
string from_user = args.get(3).asCStr();
string domain = args.get(4).asCStr();
string auth_user = args.get(5).asCStr();
string auth_pwd = args.get(6).asCStr();
string from = "sip:" + from_user + "@" + domain;
string to = "sip:" + callee + "@" + domain;
// check adminpin
rooms_mut.lock();
ConferenceRoom* r = getRoom(room, adminpin);
rooms_mut.unlock();
if (NULL == r) {
ret.push(1);
ret.push("wrong adminpin");
ret.push("");
return;
}
DBG("dialout webconference room '%s', from '%s', to '%s'",
room.c_str(), from.c_str(), to.c_str());
AmArg* a = new AmArg();
a->setBorrowedPointer(new UACAuthCred("", auth_user, auth_pwd));
AmSession* s = AmUAC::dialout(room.c_str(), APP_NAME, to,
"<" + from + ">", from, "<" + to + ">",
string(""), // local tag
string(""), // hdrs
a);
if (s) {
string localtag = s->getLocalTag();
ret.push(0);
ret.push("OK");
ret.push(localtag.c_str());
newParticipant(room, localtag, to);
updateStatus(room, localtag,
ConferenceRoomParticipant::Connecting,
"INVITE");
}
else {
ret.push(1);
ret.push("internal error");
ret.push("");
}
}
void MWI::invoke(const string& method, const AmArg& args, AmArg& ret)
{
if (method == "publish") {
string user, domain;
user = args.get(1).asCStr();
domain = args.get(0).asCStr();
publish(user, domain);
ret.push(0);
}
else
throw AmDynInvoke::NotImplemented(method);
};
void XMLRPC2DI::newConnection(const AmArg& args, AmArg& ret) {
string app_name = args.get(0).asCStr();
string server_name = args.get(1).asCStr();
int port = args.get(2).asInt();
string uri = args.get(3).asCStr();
DBG("adding XMLRPC server http://%s:%d%s for application '%s'\n",
server_name.c_str(), port, uri.c_str(), app_name.c_str());
XMLRPCServerEntry* sc = new XMLRPCServerEntry(server_name, port, uri);
server_mut.lock();
servers.insert(std::make_pair(app_name, sc));
server_mut.unlock();
}
void WebConferenceFactory::listRooms(const AmArg& args, AmArg& ret) {
string pwd = args.get(0).asCStr();
if ((!MasterPassword.length()) ||
pwd != MasterPassword) {
ret.push(407);
AmArg res;
res.push("Wrong Master Password.\n");
ret.push(res);
return;
}
AmArg room_list;
rooms_mut.lock();
for (map<string, ConferenceRoom>::iterator it =
rooms.begin(); it != rooms.end(); it++) {
room_list.push(it->first.c_str());
}
rooms_mut.unlock();
ret.push(200);
ret.push(room_list);
}
void WebConferenceFactory::vqRoomFeedback(const AmArg& args, AmArg& ret) {
assertArgCStr(args.get(0));
assertArgCStr(args.get(1));
assertArgInt(args.get(2));
string room = args.get(0).asCStr();
string adminpin = args.get(1).asCStr();
int opinion = args.get(2).asInt();
saveFeedback(string("RO "+ room + "|||" + adminpin + "|||" +
int2str(opinion) + "|||" + int2str(time(NULL)) + "|||\n"));
ret.push(0);
ret.push("OK");
}
void DSMFactory::hasDSM(const AmArg& args, AmArg& ret) {
string conf_name;
if (args.size()>1 && isArgCStr(args.get(1)))
conf_name = args.get(1).asCStr();
bool res;
ScriptConfigs_mut.lock();
try {
res = hasDSM(args.get(0).asCStr(), conf_name);
} catch(...) {
ScriptConfigs_mut.unlock();
throw;
}
ScriptConfigs_mut.unlock();
if (res)
ret.push("1");
else
ret.push("0");
}
void DILog::invoke(const string& method, const AmArg& args, AmArg& ret) {
if(method == "dumplog") {
ret.push(dumpLog().c_str());
} else if(method == "dumplogtodisk") {
dumpLog(args.get(0).asCStr());
ret.push("dumped to disk.\n");
} else if(method == "help") {
ret.push("dumplog\n"
"dumplogtodisk <path>\n"
);
} else throw AmDynInvoke::NotImplemented(method);
}
// DI interface function
void DSMFactory::loadConfig(const AmArg& args, AmArg& ret) {
string file_name = args.get(0).asCStr();
string diag_name = args.get(1).asCStr();
if (loadConfig(file_name, diag_name, true, NULL)) {
ret.push(200);
ret.push("OK");
} else {
ret.push(500);
ret.push("reload config failed");
}
}
void SIPRegistrarClient::invoke(const string& method, const AmArg& args,
AmArg& ret)
{
if(method == "createRegistration"){
ret.push(createRegistration(args.get(0).asCStr(),
args.get(1).asCStr(),
args.get(2).asCStr(),
args.get(3).asCStr(),
args.get(4).asCStr(),
args.get(5).asCStr()
).c_str());
}
else if(method == "removeRegistration"){
removeRegistration(args.get(0).asCStr());
}
else if(method == "getRegistrationState"){
unsigned int state;
unsigned int expires;
if (instance()->getRegistrationState(args.get(0).asCStr(),
state, expires)){
ret.push(1);
ret.push((int)state);
ret.push((int)expires);
} else {
ret.push(AmArg((int)0));
}
} else if(method == "_list"){
ret.push(AmArg("createRegistration"));
ret.push(AmArg("removeRegistration"));
ret.push(AmArg("getRegistrationState"));
} else
throw AmDynInvoke::NotImplemented(method);
}
void WebConferenceFactory::roomInfo(const AmArg& args, AmArg& ret) {
assertArgCStr(args.get(0));
assertArgCStr(args.get(1));
string room = args.get(0).asCStr();
string adminpin = args.get(1).asCStr();;
rooms_mut.lock();
ConferenceRoom* r = getRoom(room, adminpin);
if (NULL == r) {
ret.push(1);
ret.push("wrong adminpin");
// for consistency, add an empty array
AmArg a;
a.assertArray(0);
ret.push(a);
} else {
ret.push(0);
ret.push("OK");
ret.push(r->asArgArray());
}
rooms_mut.unlock();
}
void WebConferenceFactory::resetFeedback(const AmArg& args, AmArg& ret) {
assertArgCStr(args.get(0));
string feedback_filename = args.get(0).asCStr();
feedback_file.close();
if (!feedback_filename.empty()) {
feedback_file.open(feedback_filename.c_str(), std::ios::out);
if (!feedback_file.good()) {
ERROR("opening new feedback file '%s'\n",
feedback_filename.c_str());
ret.push(-1);
ret.push("error opening new feedback file");
} else {
DBG("successfully opened new feedback file '%s'\n",
feedback_filename.c_str());
ret.push(0);
ret.push("OK");
}
} else {
ret.push(-2);
ret.push("no filename given");
}
}
void XMLRPC2DI::sendRequest(const AmArg& args, AmArg& ret) {
string app_name = args.get(0).asCStr();
string method = args.get(1).asCStr();
AmArg& params = args.get(2);
while (true) {
XMLRPCServerEntry* srv = getServer(app_name);
if (NULL == srv) {
ret.push(-1);
ret.push("no active connections");
return;
}
XmlRpcClient c((const char*)srv->server.c_str(), (int)srv->port,
(const char*)srv->uri.empty()?NULL:srv->uri.c_str()
#ifdef HAVE_XMLRPCPP_SSL
, false
#endif
);
XmlRpcValue x_args, x_result;
XMLRPC2DIServer::amarg2xmlrpcval(params, x_args);
if (c.execute(method.c_str(), x_args, x_result) && !c.isFault()) {
DBG("successfully executed method %s on server %s:%d\n",
method.c_str(), srv->server.c_str(), srv->port);
ret.push(0);
ret.push("OK");
ret.assertArray(3);
XMLRPC2DIServer::xmlrpcval2amarg(x_result, ret[2]);
return;
} else {
DBG("executing method %s failed on server %s:%d\n",
method.c_str(), srv->server.c_str(), srv->port);
srv->set_failed();
}
}
}
void WebConferenceFactory::vqConferenceFeedback(const AmArg& args, AmArg& ret) {
assertArgCStr(args.get(0));
assertArgCStr(args.get(1));
assertArgCStr(args.get(2));
assertArgCStr(args.get(3));
assertArgInt(args.get(4));
string room = args.get(0).asCStr();
string adminpin = args.get(1).asCStr();
string sender = args.get(2).asCStr();
string comment = args.get(3).asCStr();
int opinion = args.get(4).asInt();
saveFeedback("CO|||"+ room + "|||" + adminpin + "|||" + int2str(opinion) + "|||" +
sender + "|||" + comment +"|||" + int2str(time(NULL)) + "|||\n");
ret.push(0);
ret.push("OK");
}
void JsonRPCServerModule::execRpc(const AmArg& args, AmArg& ret) {
AmArg none_params;
AmArg& params = none_params;
if (args.size()>7)
params = args.get(7);
AmArg u_none_params;
AmArg& udata = u_none_params;
if (args.size()>8)
udata = args.get(8);
JsonRPCServerLoop::execRpc(// evq_link, notification_link, request_link
args.get(0).asCStr(), args.get(1).asCStr(),
args.get(2).asCStr(),
// flags
args.get(3).asInt(),
// host, port, method
args.get(4).asCStr(),
args.get(5).asInt(), args.get(6).asCStr(),
params, udata, ret);
}
void DSMFactory::preloadModule(const AmArg& args, AmArg& ret) {
string mod_name = args.get(0).asCStr();
string mod_path = args.get(1).asCStr();
if (!preload_reader.importModule("import("+mod_name+")", mod_path)) {
ret.push(500);
ret.push("importing module '"+mod_name+"' for preload");
return;
}
DSMModule* last_loaded = preload_reader.mods.back();
if (last_loaded) {
if (last_loaded->preload()) {
ret.push(500);
ret.push("Error while preloading '"+mod_name+"'");
return;
}
}
ret.push(200);
ret.push("module preloaded.");
return;
}
void DSMFactory::loadDSM(const AmArg& args, AmArg& ret) {
string dsm_name = args.get(0).asCStr();
AmConfigReader cfg;
if(cfg.loadFile(AmConfig::ModConfigPath + string(MOD_NAME ".conf"))) {
ret.push(500);
ret.push("loading config file " +AmConfig::ModConfigPath + string(MOD_NAME ".conf"));
return;
}
string DiagPath = cfg.getParameter("diag_path");
if (DiagPath.length() && DiagPath[DiagPath.length()-1] != '/')
DiagPath += '/';
string ModPath = cfg.getParameter("mod_path");
string dsm_file_name = DiagPath+dsm_name+".dsm";
string res = "OK";
ScriptConfigs_mut.lock();
try {
if (MainScriptConfig.diags->hasDiagram(dsm_name)) {
ret.push(400);
ret.push("DSM named '" + dsm_name + "' already loaded (use reloadDSMs to reload all)");
} else {
if (!MainScriptConfig.diags->loadFile(dsm_file_name, dsm_name, ModPath, DebugDSM)) {
ret.push(500);
ret.push("error loading "+dsm_name+" from "+ dsm_file_name);
} else {
ret.push(200);
ret.push("loaded "+dsm_name+" from "+ dsm_file_name);
}
}
} catch(...) {
ScriptConfigs_mut.unlock();
throw;
}
ScriptConfigs_mut.unlock();
}
void JsonRPCServerModule::invoke(const string& method,
const AmArg& args, AmArg& ret) {
if (method == "execRpc"){
// todo: add connection id
args.assertArrayFmt("sssisis"); // evq_link, notificationReceiver, requestReceiver,
// flags(i), host, port (i), method, [params]
if (args.size() > 7) {
if (!isArgArray(args.get(7)) && !isArgStruct(args.get(7))) {
ERROR("internal error: params to JSON-RPC must be struct or array\n");
throw AmArg::TypeMismatchException();
}
}
execRpc(args, ret);
// sendRequestList(args, ret);
} else if (method == "sendMessage"){
args.assertArrayFmt("sisss"); // conn_id, type, method, id, reply_sink, [params]
if (args.size() > 5) {
if (!isArgArray(args.get(5)) && !isArgStruct(args.get(5))) {
ERROR("internal error: params to JSON-RPC must be struct or array\n");
throw AmArg::TypeMismatchException();
}
}
sendMessage(args, ret);
} else if (method == "execServerFunction"){
args.assertArrayFmt("ss"); // method, id, params
JsonRpcServer::execRpc(args.get(0).asCStr(), args.get(1).asCStr(), args.get(2), ret);
// JsonRpcServer::execRpc(args, ret);
} else if (method == "getServerPort"){
ret.push(port);
} else if(method == "_list"){
ret.push(AmArg("execRpc"));
ret.push(AmArg("sendMessage"));
ret.push(AmArg("getServerPort"));
ret.push(AmArg("execServerFunction"));
// ret.push(AmArg("newConnection"));
// ret.push(AmArg("sendRequest"));
// ret.push(AmArg("sendRequestList"));
} else
throw AmDynInvoke::NotImplemented(method);
}
void JsonRPCServerModule::sendMessage(const AmArg& args, AmArg& ret) {
AmArg none_params;
AmArg& params = none_params;
if (args.size()>5)
params = args.get(5);
AmArg u_none_params;
AmArg& udata = u_none_params;
if (args.size()>6)
udata = args.get(6);
JsonRPCServerLoop::sendMessage(args.get(0).asCStr(), // conn_id,
args.get(1).asInt(), // type, (0 == reply)
args.get(2).asCStr(), // method,
args.get(3).asCStr(), // id
args.get(4).asCStr(), // reply_sink
params, udata, ret);
}
void UserTimer::invoke(const string& method, const AmArg& args, AmArg& ret)
{
if(method == "setTimer"){
setTimer(args.get(0).asInt(),
args.get(1).asInt(),
args.get(2).asCStr());
}
else if(method == "removeTimer"){
removeTimer(args.get(0).asInt(),
args.get(1).asCStr());
}
else if(method == "removeUserTimers"){
removeUserTimers(args.get(0).asCStr());
}
else
throw AmDynInvoke::NotImplemented(method);
}
void XMLRPC2DIServer::amarg2xmlrpcval(AmArg& a,
XmlRpcValue& result) {
switch (a.getType()) {
case AmArg::CStr:
result = string(a.asCStr()); break;
case AmArg::Int:
result=a.asInt(); break;
case AmArg::Double:
result=a.asDouble(); break;
case AmArg::Array:
result.setSize(a.size());
for (size_t i=0;i<a.size();i++) {
// duh... recursion...
amarg2xmlrpcval(a.get(i), result[i]);
}
break;
default: { WARN("unsupported return value type %d\n", a.getType()); } break;
// TODO: do sth with the data here ?
}
}
void XMLRPC2DIServer::amarg2xmlrpcval(const AmArg& a,
XmlRpcValue& result) {
switch (a.getType()) {
case AmArg::CStr:
// DBG("a->X CSTR\n");
result = string(a.asCStr()); break;
case AmArg::Int:
// DBG("a->X INT\n");
result=a.asInt(); break;
case AmArg::Double:
// DBG("a->X DOUBLE\n");
result=a.asDouble(); break;
case AmArg::Array:
// DBG("a->X ARRAY size %u\n", a.size());
result.setSize(a.size());
for (size_t i=0;i<a.size();i++) {
// duh... recursion...
amarg2xmlrpcval(a.get(i), result[i]);
}
break;
case AmArg::Struct:
// DBG("a->X STRUCT size %u\n", a.size());
for (AmArg::ValueStruct::const_iterator it =
a.begin(); it != a.end(); it++) {
// duh... recursion...
amarg2xmlrpcval(it->second, result[it->first]);
}
break;
default: { WARN("unsupported return value type %d\n", a.getType()); } break;
// TODO: do sth with the data here ?
}
}
void WebConferenceFactory::getRoomPassword(const AmArg& args, AmArg& ret) {
string pwd = args.get(0).asCStr();
string room = args.get(1).asCStr();
if ((!MasterPassword.length()) ||
pwd != MasterPassword) {
ret.push(403);
ret.push("Wrong Master Password.\n");
return;
}
int res_code = 404;
string res = "Room does not exist.";
rooms_mut.lock();
map<string, ConferenceRoom>::iterator it = rooms.find(room);
if (it != rooms.end()) {
res = it->second.adminpin;
res_code = 0;
}
rooms_mut.unlock();
ret.push(res_code);
ret.push(res.c_str());
}
