Ejemplo n.º 1
0
void SIPAccount::unserialize (Conf::MappingNode *map)
{
    Conf::MappingNode *srtpMap;
    Conf::MappingNode *tlsMap;
    Conf::MappingNode *zrtpMap;

    assert(map);

    map->getValue(aliasKey, &_alias);
    map->getValue(typeKey, &_type);
    map->getValue(usernameKey, &_username);
    map->getValue(hostnameKey, &_hostname);
    map->getValue(accountEnableKey, &_enabled);
    map->getValue(mailboxKey, &_mailBox);
    map->getValue(codecsKey, &_codecStr);
    // Update codec list which one is used for SDP offer
    setActiveCodecs (ManagerImpl::unserialize (_codecStr));

    map->getValue(ringtonePathKey, &_ringtonePath);
    map->getValue(ringtoneEnabledKey, &_ringtoneEnabled);
    map->getValue(expireKey, &_registrationExpire);
    map->getValue(interfaceKey, &_interface);
    int port;
    map->getValue(portKey, &port);
    _localPort = port;
    map->getValue(publishAddrKey, &_publishedIpAddress);
    map->getValue(publishPortKey, &port);
    _publishedPort = port;
    map->getValue(sameasLocalKey, &_publishedSameasLocal);
    map->getValue(resolveOnceKey, &_resolveOnce);

    std::string dtmfType;
    map->getValue(dtmfTypeKey, &dtmfType);
    _dtmfType = (dtmfType == "overrtp") ? OVERRTP : SIPINFO;

    map->getValue(serviceRouteKey, &_serviceRoute);
    // stun enabled
    map->getValue(stunEnabledKey, &_stunEnabled);
    map->getValue(stunServerKey, &_stunServer);

    // Init stun server name with default server name
    _stunServerName = pj_str ( (char*) _stunServer.data());

    map->getValue(displayNameKey, &_displayName);

	std::vector<std::map<std::string, std::string> > creds;

	Conf::YamlNode *credNode = map->getValue (credKey);

	/* 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() == Conf::SEQUENCE) {
	    Conf::SequenceNode *credSeq = (Conf::SequenceNode *) credNode;
		Conf::Sequence::iterator it;
		Conf::Sequence *seq = credSeq->getSequence();
		for(it = seq->begin(); it != seq->end(); ++it) {
			Conf::MappingNode *cred = (Conf::MappingNode *) (*it);
			std::string user;
			std::string pass;
			std::string realm;
			cred->getValue(USERNAME, &user);
			cred->getValue(PASSWORD, &pass);
			cred->getValue(REALM, &realm);
			std::map<std::string, std::string> map;
			map[USERNAME] = user;
			map[PASSWORD] = pass;
			map[REALM] = realm;
			creds.push_back(map);
		}
	}
    if (creds.empty()) {
    	// migration from old file format
		std::map<std::string, std::string> credmap;
		std::string password;
	    map->getValue(passwordKey, &password);

		credmap[USERNAME] = _username;
		credmap[PASSWORD] = password;
		credmap[REALM] = "*";
		creds.push_back(credmap);
    }
    setCredentials (creds);

    // get srtp submap
    srtpMap = (Conf::MappingNode *) (map->getValue (srtpKey));
    if (srtpMap) {
        srtpMap->getValue(srtpEnableKey, &_srtpEnabled);
        srtpMap->getValue(keyExchangeKey, &_srtpKeyExchange);
        srtpMap->getValue(rtpFallbackKey, &_srtpFallback);
    }

    // get zrtp submap
    zrtpMap = (Conf::MappingNode *) (map->getValue (zrtpKey));
    if (zrtpMap) {
        zrtpMap->getValue(displaySasKey, &_zrtpDisplaySas);
        zrtpMap->getValue(displaySasOnceKey, &_zrtpDisplaySasOnce);
        zrtpMap->getValue(helloHashEnabledKey, &_zrtpHelloHash);
        zrtpMap->getValue(notSuppWarningKey, &_zrtpNotSuppWarning);
    }

    // get tls submap
    tlsMap = (Conf::MappingNode *) (map->getValue (tlsKey));
    if (tlsMap) {
        tlsMap->getValue(tlsEnableKey, &_tlsEnable);
        tlsMap->getValue(tlsPortKey, &_tlsPortStr);
        tlsMap->getValue(certificateKey, &_tlsCertificateFile);
        tlsMap->getValue(calistKey, &_tlsCaListFile);
        tlsMap->getValue(ciphersKey, &_tlsCiphers);
        tlsMap->getValue(methodKey, &_tlsMethod);
        tlsMap->getValue(tlsPasswordKey, &_tlsPassword);
        tlsMap->getValue(privateKeyKey, &_tlsPrivateKeyFile);
        tlsMap->getValue(requireCertifKey, &_tlsRequireClientCertificate);
        tlsMap->getValue(serverKey, &_tlsServerName);
        tlsMap->getValue(verifyClientKey, &_tlsVerifyServer);
        tlsMap->getValue(verifyServerKey, &_tlsVerifyClient);
        // FIXME
        tlsMap->getValue(timeoutKey, &_tlsNegotiationTimeoutSec);
        tlsMap->getValue(timeoutKey, &_tlsNegotiationTimeoutMsec);
    }
}
Ejemplo n.º 2
0
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, &registrationExpire_);
    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_);
    }
}
Ejemplo n.º 3
0
void SIPAccount::serialize (Conf::YamlEmitter *emitter)
{
	if(emitter == NULL) {
		_error("SIPAccount: Error: emitter is NULL in serialize");
		return;
	}

    Conf::MappingNode accountmap (NULL);
    Conf::MappingNode srtpmap (NULL);
    Conf::MappingNode zrtpmap (NULL);
    Conf::MappingNode tlsmap (NULL);

    Conf::ScalarNode id (Account::_accountID);
    Conf::ScalarNode username (Account::_username);
    Conf::ScalarNode alias (Account::_alias);
    Conf::ScalarNode hostname (Account::_hostname);
    Conf::ScalarNode enable (_enabled);
    Conf::ScalarNode type (Account::_type);
    Conf::ScalarNode expire (_registrationExpire);
    Conf::ScalarNode interface (_interface);
    std::stringstream portstr;
    portstr << _localPort;
    Conf::ScalarNode port (portstr.str());
    Conf::ScalarNode serviceRoute (_serviceRoute);

    Conf::ScalarNode mailbox (_mailBox);
    Conf::ScalarNode publishAddr (_publishedIpAddress);
    std::stringstream publicportstr;
    publicportstr << _publishedPort;
    Conf::ScalarNode publishPort (publicportstr.str());
    Conf::ScalarNode sameasLocal (_publishedSameasLocal);
    Conf::ScalarNode resolveOnce (_resolveOnce);
    Conf::ScalarNode codecs (_codecStr);
    Conf::ScalarNode ringtonePath (_ringtonePath);
    Conf::ScalarNode ringtoneEnabled (_ringtoneEnabled);
    Conf::ScalarNode stunServer (_stunServer);
    Conf::ScalarNode stunEnabled (_stunEnabled);
    Conf::ScalarNode displayName (_displayName);
    Conf::ScalarNode dtmfType (_dtmfType==OVERRTP ? "overrtp" : "sipinfo");

    std::stringstream countstr;
    countstr << 0;
    Conf::ScalarNode count (countstr.str());

    Conf::ScalarNode srtpenabled (_srtpEnabled);
    Conf::ScalarNode keyExchange (_srtpKeyExchange);
    Conf::ScalarNode rtpFallback (_srtpFallback);

    Conf::ScalarNode displaySas (_zrtpDisplaySas);
    Conf::ScalarNode displaySasOnce (_zrtpDisplaySasOnce);
    Conf::ScalarNode helloHashEnabled (_zrtpHelloHash);
    Conf::ScalarNode notSuppWarning (_zrtpNotSuppWarning);

    Conf::ScalarNode tlsport (_tlsPortStr);
    Conf::ScalarNode certificate (_tlsCertificateFile);
    Conf::ScalarNode calist (_tlsCaListFile);
    Conf::ScalarNode ciphers (_tlsCiphers);
    Conf::ScalarNode tlsenabled (_tlsEnable);
    Conf::ScalarNode tlsmethod (_tlsMethod);
    Conf::ScalarNode timeout (_tlsNegotiationTimeoutSec);
    Conf::ScalarNode tlspassword (_tlsPassword);
    Conf::ScalarNode privatekey (_tlsPrivateKeyFile);
    Conf::ScalarNode requirecertif (_tlsRequireClientCertificate);
    Conf::ScalarNode server (_tlsServerName);
    Conf::ScalarNode verifyclient (_tlsVerifyServer);
    Conf::ScalarNode verifyserver (_tlsVerifyClient);

    accountmap.setKeyValue (aliasKey, &alias);
    accountmap.setKeyValue (typeKey, &type);
    accountmap.setKeyValue (idKey, &id);
    accountmap.setKeyValue (usernameKey, &username);
    accountmap.setKeyValue (hostnameKey, &hostname);
    accountmap.setKeyValue (accountEnableKey, &enable);
    accountmap.setKeyValue (mailboxKey, &mailbox);
    accountmap.setKeyValue (expireKey, &expire);
    accountmap.setKeyValue (interfaceKey, &interface);
    accountmap.setKeyValue (portKey, &port);
    accountmap.setKeyValue (stunServerKey, &stunServer);
    accountmap.setKeyValue (stunEnabledKey, &stunEnabled);
    accountmap.setKeyValue (publishAddrKey, &publishAddr);
    accountmap.setKeyValue (publishPortKey, &publishPort);
    accountmap.setKeyValue (sameasLocalKey, &sameasLocal);
    accountmap.setKeyValue (resolveOnceKey, &resolveOnce);
    accountmap.setKeyValue (serviceRouteKey, &serviceRoute);
    accountmap.setKeyValue (dtmfTypeKey, &dtmfType);
    accountmap.setKeyValue (displayNameKey, &displayName);
    accountmap.setKeyValue (codecsKey, &codecs);
    accountmap.setKeyValue (ringtonePathKey, &ringtonePath);
    accountmap.setKeyValue (ringtoneEnabledKey, &ringtoneEnabled);

    accountmap.setKeyValue (srtpKey, &srtpmap);
    srtpmap.setKeyValue (srtpEnableKey, &srtpenabled);
    srtpmap.setKeyValue (keyExchangeKey, &keyExchange);
    srtpmap.setKeyValue (rtpFallbackKey, &rtpFallback);

    accountmap.setKeyValue (zrtpKey, &zrtpmap);
    zrtpmap.setKeyValue (displaySasKey, &displaySas);
    zrtpmap.setKeyValue (displaySasOnceKey, &displaySasOnce);
    zrtpmap.setKeyValue (helloHashEnabledKey, &helloHashEnabled);
    zrtpmap.setKeyValue (notSuppWarningKey, &notSuppWarning);

    Conf::SequenceNode credentialseq (NULL);
    accountmap.setKeyValue (credKey, &credentialseq);

	std::vector<std::map<std::string, std::string> >::const_iterator it;
	for (it = credentials_.begin(); it != credentials_.end(); ++it) {
		std::map<std::string, std::string> cred = *it;
		Conf::MappingNode *map = new Conf::MappingNode(NULL);
		map->setKeyValue(USERNAME, new Conf::ScalarNode(cred[USERNAME]));
		map->setKeyValue(PASSWORD, new Conf::ScalarNode(cred[PASSWORD]));
		map->setKeyValue(REALM, new Conf::ScalarNode(cred[REALM]));
		credentialseq.addNode(map);
	}

	accountmap.setKeyValue (tlsKey, &tlsmap);
    tlsmap.setKeyValue (tlsPortKey, &tlsport);
    tlsmap.setKeyValue (certificateKey, &certificate);
    tlsmap.setKeyValue (calistKey, &calist);
    tlsmap.setKeyValue (ciphersKey, &ciphers);
    tlsmap.setKeyValue (tlsEnableKey, &tlsenabled);
    tlsmap.setKeyValue (methodKey, &tlsmethod);
    tlsmap.setKeyValue (timeoutKey, &timeout);
    tlsmap.setKeyValue (tlsPasswordKey, &tlspassword);
    tlsmap.setKeyValue (privateKeyKey, &privatekey);
    tlsmap.setKeyValue (requireCertifKey, &requirecertif);
    tlsmap.setKeyValue (serverKey, &server);
    tlsmap.setKeyValue (verifyClientKey, &verifyclient);
    tlsmap.setKeyValue (verifyServerKey, &verifyserver);

    try {
        emitter->serializeAccount (&accountmap);
    } catch (Conf::YamlEmitterException &e) {
        _error ("ConfigTree: %s", e.what());
    }

    Conf::Sequence *seq = credentialseq.getSequence();
    Conf::Sequence::iterator seqit;
    for (seqit = seq->begin(); seqit != seq->end(); ++seqit) {
    	Conf::MappingNode *node = (Conf::MappingNode*)*seqit;
    	delete node->getValue(USERNAME);
		delete node->getValue(PASSWORD);
		delete node->getValue(REALM);
    	delete node;
    }
}