void YamlEmitter::addMappingItem(int mappingid, const std::string &key, YamlNode *node)
{
if (node->getType() == SCALAR) {
ScalarNode *sclr = static_cast<ScalarNode *>(node);
int temp1;
if ((temp1 = yaml_document_add_scalar(&document_, NULL, (yaml_char_t *) key.c_str(), -1, YAML_PLAIN_SCALAR_STYLE)) == 0)
throw YamlEmitterException("Could not add scalar to document");
int temp2;
if ((temp2 = yaml_document_add_scalar(&document_, NULL, (yaml_char_t *) sclr->getValue().c_str(), -1, YAML_PLAIN_SCALAR_STYLE)) == 0)
throw YamlEmitterException("Could not add scalar to document");
if (yaml_document_append_mapping_pair(&document_, mappingid, temp1, temp2) == 0)
throw YamlEmitterException("Could not append mapping pair to mapping");
} else if (node->getType() == MAPPING) {
MappingNode *map = static_cast<MappingNode *>(node);
int temp1;
if ((temp1 = yaml_document_add_scalar(&document_, NULL, (yaml_char_t *) key.c_str(), -1, YAML_PLAIN_SCALAR_STYLE)) == 0)
throw YamlEmitterException("Could not add scalar to document");
int temp2;
if ((temp2 = yaml_document_add_mapping(&document_, NULL, YAML_BLOCK_MAPPING_STYLE)) == 0)
throw YamlEmitterException("Could not add scalar to document");
if (yaml_document_append_mapping_pair(&document_, mappingid, temp1, temp2) == 0)
throw YamlEmitterException("Could not add mapping pair to mapping");
addMappingItems(temp2, map->getMapping());
} else if (node->getType() == SEQUENCE) {
SequenceNode *seqnode = static_cast<SequenceNode *>(node);
int temp1;
if ((temp1 = yaml_document_add_scalar(&document_, NULL, (yaml_char_t *) key.c_str(), -1, YAML_PLAIN_SCALAR_STYLE)) == 0)
throw YamlEmitterException("Could not add scalar to document");
int temp2;
if ((temp2 = yaml_document_add_sequence(&document_, NULL, YAML_BLOCK_SEQUENCE_STYLE)) == 0)
throw YamlEmitterException("Could not add scalar to document");
if (yaml_document_append_mapping_pair(&document_, mappingid, temp1, temp2) == 0)
throw YamlEmitterException("Could not append mapping pair to mapping");
Sequence *seq = seqnode->getSequence();
for (const auto &it : *seq) {
YamlNode *yamlNode = it;
int id;
if ((id = yaml_document_add_mapping(&document_, NULL, YAML_BLOCK_MAPPING_STYLE)) == 0)
throw YamlEmitterException("Could not add account mapping to document");
if (yaml_document_append_sequence_item(&document_, temp2, id) == 0)
throw YamlEmitterException("Could not append account mapping to sequence");
MappingNode *mapnode = static_cast<MappingNode*>(yamlNode);
addMappingItems(id, mapnode->getMapping());
}
} else
throw YamlEmitterException("Unknown node type while adding mapping node");
}
void SIPAccount::unserialize(const Conf::MappingNode &map)
{
using namespace Conf;
map.getValue(ALIAS_KEY, &alias_);
map.getValue(TYPE_KEY, &type_);
map.getValue(USERNAME_KEY, &username_);
map.getValue(HOSTNAME_KEY, &hostname_);
map.getValue(ACCOUNT_ENABLE_KEY, &enabled_);
map.getValue(MAILBOX_KEY, &mailBox_);
map.getValue(CODECS_KEY, &codecStr_);
// Update codec list which one is used for SDP offer
setActiveCodecs(ManagerImpl::split_string(codecStr_));
map.getValue(RINGTONE_PATH_KEY, &ringtonePath_);
map.getValue(RINGTONE_ENABLED_KEY, &ringtoneEnabled_);
map.getValue(Preferences::REGISTRATION_EXPIRE_KEY, ®istrationExpire_);
map.getValue(INTERFACE_KEY, &interface_);
int port = DEFAULT_SIP_PORT;
map.getValue(PORT_KEY, &port);
localPort_ = port;
map.getValue(PUBLISH_ADDR_KEY, &publishedIpAddress_);
map.getValue(PUBLISH_PORT_KEY, &port);
publishedPort_ = port;
map.getValue(SAME_AS_LOCAL_KEY, &publishedSameasLocal_);
map.getValue(KEEP_ALIVE_ENABLED, &keepAliveEnabled_);
std::string dtmfType;
map.getValue(DTMF_TYPE_KEY, &dtmfType);
dtmfType_ = dtmfType;
map.getValue(SERVICE_ROUTE_KEY, &serviceRoute_);
map.getValue(UPDATE_CONTACT_HEADER_KEY, &contactUpdateEnabled_);
// stun enabled
map.getValue(STUN_ENABLED_KEY, &stunEnabled_);
map.getValue(STUN_SERVER_KEY, &stunServer_);
// Init stun server name with default server name
stunServerName_ = pj_str((char*) stunServer_.data());
map.getValue(DISPLAY_NAME_KEY, &displayName_);
std::vector<std::map<std::string, std::string> > creds;
YamlNode *credNode = map.getValue(CRED_KEY);
/* We check if the credential key is a sequence
* because it was a mapping in a previous version of
* the configuration file.
*/
if (credNode && credNode->getType() == SEQUENCE) {
SequenceNode *credSeq = static_cast<SequenceNode *>(credNode);
Sequence::iterator it;
Sequence *seq = credSeq->getSequence();
for (it = seq->begin(); it != seq->end(); ++it) {
MappingNode *cred = static_cast<MappingNode *>(*it);
std::string user;
std::string pass;
std::string realm;
cred->getValue(CONFIG_ACCOUNT_USERNAME, &user);
cred->getValue(CONFIG_ACCOUNT_PASSWORD, &pass);
cred->getValue(CONFIG_ACCOUNT_REALM, &realm);
std::map<std::string, std::string> credentialMap;
credentialMap[CONFIG_ACCOUNT_USERNAME] = user;
credentialMap[CONFIG_ACCOUNT_PASSWORD] = pass;
credentialMap[CONFIG_ACCOUNT_REALM] = realm;
creds.push_back(credentialMap);
}
}
if (creds.empty()) {
// migration from old file format
std::map<std::string, std::string> credmap;
std::string password;
map.getValue(PASSWORD_KEY, &password);
credmap[CONFIG_ACCOUNT_USERNAME] = username_;
credmap[CONFIG_ACCOUNT_PASSWORD] = password;
credmap[CONFIG_ACCOUNT_REALM] = "*";
creds.push_back(credmap);
}
setCredentials(creds);
// get srtp submap
MappingNode *srtpMap = static_cast<MappingNode *>(map.getValue(SRTP_KEY));
if (srtpMap) {
srtpMap->getValue(SRTP_ENABLE_KEY, &srtpEnabled_);
srtpMap->getValue(KEY_EXCHANGE_KEY, &srtpKeyExchange_);
srtpMap->getValue(RTP_FALLBACK_KEY, &srtpFallback_);
}
// get zrtp submap
MappingNode *zrtpMap = static_cast<MappingNode *>(map.getValue(ZRTP_KEY));
if (zrtpMap) {
zrtpMap->getValue(DISPLAY_SAS_KEY, &zrtpDisplaySas_);
zrtpMap->getValue(DISPLAY_SAS_ONCE_KEY, &zrtpDisplaySasOnce_);
zrtpMap->getValue(HELLO_HASH_ENABLED_KEY, &zrtpHelloHash_);
zrtpMap->getValue(NOT_SUPP_WARNING_KEY, &zrtpNotSuppWarning_);
}
// get tls submap
MappingNode *tlsMap = static_cast<MappingNode *>(map.getValue(TLS_KEY));
if (tlsMap) {
tlsMap->getValue(TLS_ENABLE_KEY, &tlsEnable_);
std::string tlsPort;
tlsMap->getValue(TLS_PORT_KEY, &tlsPort);
tlsListenerPort_ = atoi(tlsPort.c_str());
tlsMap->getValue(CERTIFICATE_KEY, &tlsCertificateFile_);
tlsMap->getValue(CALIST_KEY, &tlsCaListFile_);
tlsMap->getValue(CIPHERS_KEY, &tlsCiphers_);
tlsMap->getValue(METHOD_KEY, &tlsMethod_);
tlsMap->getValue(TLS_PASSWORD_KEY, &tlsPassword_);
tlsMap->getValue(PRIVATE_KEY_KEY, &tlsPrivateKeyFile_);
tlsMap->getValue(REQUIRE_CERTIF_KEY, &tlsRequireClientCertificate_);
tlsMap->getValue(SERVER_KEY, &tlsServerName_);
tlsMap->getValue(VERIFY_CLIENT_KEY, &tlsVerifyServer_);
tlsMap->getValue(VERIFY_SERVER_KEY, &tlsVerifyClient_);
// FIXME
tlsMap->getValue(TIMEOUT_KEY, &tlsNegotiationTimeoutSec_);
tlsMap->getValue(TIMEOUT_KEY, &tlsNegotiationTimeoutMsec_);
}
}
