void SequenceNode::deleteChildNodes()
{
Sequence::iterator it;
for (it = seq.begin(); it != seq.end(); ++it) {
YamlNode *yamlNode = static_cast<YamlNode *> (*it);
switch (yamlNode->getType()) {
case DOCUMENT:
break;
case SEQUENCE: {
SequenceNode *sequence = static_cast<SequenceNode *> (yamlNode);
sequence->deleteChildNodes();
delete sequence;
}
break;
case MAPPING: {
MappingNode *mapping = static_cast<MappingNode *> (yamlNode);
mapping->deleteChildNodes();
delete mapping;
}
break;
case SCALAR: {
ScalarNode *scalar = static_cast<ScalarNode *> (yamlNode);
delete scalar;
}
break;
default:
break;
}
}
}
void YamlDocument::deleteChildNodes()
{
Sequence::iterator it = doc.begin();
while (it != doc.end()) {
YamlNode *yamlNode = static_cast<YamlNode *> (*it);
switch (yamlNode->getType()) {
case DOCUMENT:
break;
case SEQUENCE: {
SequenceNode *sequence = static_cast<SequenceNode *> (yamlNode);
sequence->deleteChildNodes();
delete sequence;
sequence = NULL;
}
break;
case MAPPING: {
MappingNode *mapping = static_cast<MappingNode *> (yamlNode);
mapping->deleteChildNodes();
delete mapping;
mapping = NULL;
}
break;
case SCALAR: {
ScalarNode *scalar = static_cast<ScalarNode *> (yamlNode);
delete scalar;
scalar = NULL;
}
break;
default:
break;
}
it++;
}
}
void MappingNode::deleteChildNodes()
{
Mapping::iterator it;
for (it = map.begin(); it != map.end(); ++it) {
YamlNode *yamlNode = static_cast<YamlNode *> (it->second);
if (!yamlNode)
continue;
switch (yamlNode->getType()) {
case DOCUMENT:
break;
case SEQUENCE: {
SequenceNode *sequence = static_cast<SequenceNode *> (yamlNode);
sequence->deleteChildNodes();
delete sequence;
sequence = NULL;
}
break;
case MAPPING: {
MappingNode *mapping = static_cast<MappingNode *> (yamlNode);
mapping->deleteChildNodes();
delete mapping;
mapping = NULL;
}
break;
case SCALAR: {
ScalarNode *scalar = static_cast<ScalarNode *> (yamlNode);
delete scalar;
scalar = NULL;
}
break;
default:
break;
}
}
}
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_);
}
}