settingsdialog.cxx

MiniSip Client with DomainKeys Authentication, Sip, Audio communications, Echo Cancel

	refXml->get_widget( "secureCheck", secureCheck );
	
//	refXml->get_widget( "secureTable", secureTable );
	
//	refXml->get_widget( "kaEntry", kaEntry );
//	refXml->get_widget( "kaCombo", kaCombo );

//	refXml->get_widget( "pskBox", pskBox );
	refXml->get_widget( "pskRadio", pskRadio );
	refXml->get_widget( "dhRadio", dhRadio );
	refXml->get_widget( "dkRadio", dkRadio );
	
	refXml->get_widget( "kaTypeLabel", kaTypeLabel );

	refXml->get_widget( "pskLabel", pskLabel );

	refXml->get_widget( "dkSettingsButton", dkSettingsButton );
	dkSettingsButton->signal_clicked().connect( SLOT( *dkDialog, &DkSettingsDialog::run ) );
	
	dhCheck->signal_toggled().connect( SLOT( 
		*this, &SecuritySettings::kaChange ) );
	
	dkCheck->signal_toggled().connect( SLOT( 
		*this, &SecuritySettings::kaChange ) );
	
	pskCheck->signal_toggled().connect( SLOT( 
		*this, &SecuritySettings::kaChange ) );

	secureCheck->signal_toggled().connect( SLOT( 
		*this, &SecuritySettings::secureChange ) );

	
	//kaCombo->set_value_in_list( true );
//	kaEntry->set_editable( false );
	
}

SecuritySettings::~SecuritySettings() {
	delete dkDialog;
}

void SecuritySettings::setConfig( MRef<SipSoftPhoneConfiguration *> config ){ 
	this->config = config;
	dkDialog->setConfig( config );

	dhCheck->set_active( config->securityConfig.dh_enabled );
	dkCheck->set_active( config->securityConfig.dk_enabled );
	pskCheck->set_active( config->securityConfig.psk_enabled );

	string psk( (const char *)config->securityConfig.psk, config->securityConfig.psk_length );
	pskEntry->set_text( psk );


	if( config->securityConfig.ka_type == KEY_MGMT_METHOD_MIKEY_DH ){
		dhRadio->set_active( true );
	}

	else if( config->securityConfig.ka_type == KEY_MGMT_METHOD_MIKEY_DK ){
		dkRadio->set_active( true );
	}

	else if( config->securityConfig.ka_type == KEY_MGMT_METHOD_MIKEY_PSK ){
		pskRadio->set_active( true );
	}

	secureCheck->set_active( config->securityConfig.secured );
	
	kaChange();
	secureChange();

}

void SecuritySettings::kaChange(){

	pskEntry->set_sensitive( pskCheck->get_active() );
	
	pskLabel->set_sensitive( pskCheck->get_active() );

	secureCheck->set_sensitive( pskCheck->get_active() 
			|| dhCheck->get_active() || dkCheck->get_active() );

	if( !( pskCheck->get_active() || dhCheck->get_active() || dkCheck->get_active() ) ){
		secureCheck->set_active( false );
	}

	pskRadio->set_sensitive( secureCheck->get_active() && 
			         pskCheck->get_active() );
	dhRadio->set_sensitive( secureCheck->get_active() && 
			        dhCheck->get_active() );
	dkRadio->set_sensitive( secureCheck->get_active() && 
			        dkCheck->get_active() );

	if( dhCheck->get_active() && ! dkCheck->get_active() && ! pskCheck->get_active() ){
		dhRadio->set_active( true );
	}

	if( dkCheck->get_active() && ! dhCheck->get_active() && ! pskCheck->get_active() ){
		dkRadio->set_active( true );
	}

	if( pskCheck->get_active() && ! dhCheck->get_active() && ! dkCheck->get_active() ){
		pskRadio->set_active( true );
	}
}

void SecuritySettings::secureChange(){
//	secureTable->set_sensitive( secureCheck->get_active() );
	kaTypeLabel->set_sensitive( secureCheck->get_active() );
	pskRadio->set_sensitive( secureCheck->get_active() && 
			         pskCheck->get_active() );
	dhRadio->set_sensitive( secureCheck->get_active() && 
			        dhCheck->get_active() );
	dkRadio->set_sensitive( secureCheck->get_active() && 
			        dkCheck->get_active() );

}


string SecuritySettings::apply(){
	string err;
	if( dhCheck->get_active() ){
		config->securityConfig.cert->lock();
		if( config->securityConfig.cert->is_empty() ){
			err += "You have selected the Diffie-Hellman key agreement\n"
		       "but have not selected a certificate file.\n"
		       "The D-H key agreement has been disabled.";
			dhCheck->set_active( false );
		}
		
		else if( !config->securityConfig.cert->get_first()->get_openssl_private_key() ){
			err += "You have selected the Diffie-Hellman key agreement\n"
		       "but have not selected a private key file.\n"
		       "The D-H key agreement has been disabled.";
			dhCheck->set_active( false );
		}
		config->securityConfig.cert->unlock();
	}

	if( dkCheck->get_active() && config->securityConfig.dk_pkey.length() == 0 ) {
		err += "You have selected the DomainKey key agreement\n"
		       "but have not selected a private key file.\n"
		       "The DK key agreement has been disabled.";
			dkCheck->set_active( false );
	}

	config->securityConfig.dh_enabled = dhCheck->get_active();
	config->securityConfig.dk_enabled = dkCheck->get_active();
	config->securityConfig.psk_enabled = pskCheck->get_active();


	string s = pskEntry->get_text();
        const unsigned char * psk = (const unsigned char *)s.c_str();
        unsigned int psk_length = s.size();
        if( config->securityConfig.psk != NULL )
                delete [] config->securityConfig.psk;
        config->securityConfig.psk = new unsigned char[psk_length];
        memcpy( config->securityConfig.psk, psk, psk_length );
        config->securityConfig.psk_length = psk_length;

	config->securityConfig.secured = secureCheck->get_active();
	if( config->inherited->sipIdentity ){
		config->inherited->sipIdentity->securitySupport = secureCheck->get_active();
	}

	if( config->securityConfig.secured ){
		if( pskRadio->get_active() ){
			config->securityConfig.ka_type = KEY_MGMT_METHOD_MIKEY_PSK;
		}
		else if( dhRadio->get_active() ){
			config->securityConfig.ka_type = KEY_MGMT_METHOD_MIKEY_DH;
		}
		else if( dkRadio->get_active() ){
			config->securityConfig.ka_type = KEY_MGMT_METHOD_MIKEY_DK;
		}
	}

	return err;

}

AdvancedSettings::AdvancedSettings( Glib::RefPtr<Gnome::Glade::Xml>  refXml ){
	refXml->get_widget( "networkInterfacesCombo", networkInterfacesCombo );
	refXml->get_widget( "networkInterfacesEntry", networkInterfacesEntry );
		
	refXml->get_widget( "udpSpin", udpSpin );
	refXml->get_widget( "tcpSpin", tcpSpin );
	refXml->get_widget( "tlsSpin", tlsSpin );
	
	refXml->get_widget( "tcpCheck", tcpCheck );
	refXml->get_widget( "tlsCheck", tlsCheck );
	
	refXml->get_widget( "stunCheck", stunCheck );
	refXml->get_widget( "stunAutodetectCheck", stunAutodetectCheck );
	refXml->get_widget( "stunEntry", stunEntry );
	
	tcpCheck->signal_toggled().connect( SLOT( 
		*this, &AdvancedSettings::transportChange ) );
	tlsCheck->signal_toggled().connect( SLOT( 
		*this, &AdvancedSettings::transportChange ) );
	
	stunAutodetectCheck->signal_toggled().connect( SLOT( 
		*this, &AdvancedSettings::stunAutodetectChange ) );
	
}

void AdvancedSettings::setConfig( MRef<SipSoftPhoneConfiguration *> config ){ 
	this->config = config;

	//Set the choosen network interface ...
	vector<string> ifaces = NetworkFunctions::getAllInterfaces();
	list<string> ifaceIP;
	for(unsigned int i=0; i<ifaces.size(); i++ ){
		string ip = NetworkFunctions::getInterfaceIPStr(ifaces[i]);
		#ifdef DEBUG_OUTPUT
		cout << "AdvancedSettings::setConfig - Network Interface: name = " << ifaces[i] << "; IP=" << ip << endl;
		#endif
		ifaceIP.push_back( ip );
		
	}	
	networkInterfacesCombo->set_popdown_strings( ifaceIP );
	networkInterfacesCombo->set_sensitive( ifaceIP.size() > 1 );
	//set the preferred's IP as selected ...
	if( config ) {
		string preferredIfaceIP = NetworkFunctions::getInterfaceIPStr( config->networkInterfaceName );
		networkInterfacesEntry->set_text( preferredIfaceIP );
	}
	
	udpSpin->set_value( config->inherited->localUdpPort );
	tcpSpin->set_value( config->inherited->localTcpPort );
	tlsSpin->set_value( config->inherited->localTlsPort );

	tcpCheck->set_active( config->tcp_server );
	tlsCheck->set_active( config->tls_server );

	transportChange();

	stunCheck->set_active( config->useSTUN );
	stunAutodetectCheck->set_active( config->useUserDefinedStunServer );
	stunEntry->set_text( config->userDefinedStunServer );

}

void AdvancedSettings::transportChange(){

	tlsSpin->set_sensitive( tlsCheck->get_active() );
	tcpSpin->set_sensitive( tcpCheck->get_active() );
	
	stunAutodetectChange();
}

void AdvancedSettings::stunAutodetectChange(){
	stunEntry->set_sensitive( !stunAutodetectCheck->get_active() );
	if( stunAutodetectCheck->get_active() ){
		stunEntry->set_text( "" );
	}
}

string AdvancedSettings::apply(){
	//config->networkInterfaceName = networkInterfacesCombo->
	string ipSelected = networkInterfacesEntry->get_text();
	string ifaceSel = NetworkFunctions::getInterfaceOf( ipSelected );
	#ifdef DEBUG_OUTPUT
	cout << "AdvancedSettings::apply - ip = " << ipSelected << "; iface = " << ifaceSel << endl;
	#endif
	if( ifaceSel != "" ) {
		config->networkInterfaceName = ifaceSel;
	}

	config->inherited->localUdpPort = udpSpin->get_value_as_int();
	config->inherited->localTcpPort = tcpSpin->get_value_as_int();
	config->inherited->localTlsPort = tlsSpin->get_value_as_int();

	config->tcp_server = tcpCheck->get_active();
	config->tls_server = tlsCheck->get_active();

	config->useSTUN = stunCheck->get_active();
	config->useUserDefinedStunServer = stunAutodetectCheck->get_active()
		&& stunEntry->get_text() != "";
	config->userDefinedStunServer = stunEntry->get_text();

	return "";

}

// added by pmaurer
DkSettingsDialog::DkSettingsDialog( Glib::RefPtr<Gnome::Glade::Xml>  refXml ){

	// dk settings dialog
	refXml->get_widget("dkDialog", dkDialog);

	// private key label
	refXml->get_widget("dkPkeyLabel", dkPkeyLabel);

	// private key browse button
	refXml->get_widget("dkPkeyButton", dkPkeyButton);
	dkPkeyButton->signal_clicked().connect(SLOT(*this, &DkSettingsDialog::choosePrivateKey));

	// DomainKeys cache list
	refXml->get_widget("dkCacheView", dkCacheView);
	dkCacheColumns.add(sipColumn);
	dkCacheTreeStore = Gtk::TreeStore::create(dkCacheColumns);
	dkCacheView->set_model(dkCacheTreeStore);
	dkCacheView->append_column("SIP-URI", sipColumn);

	// DomainKeys remove selected button
	refXml->get_widget("dkRemoveButton", dkRemoveButton);
	dkRemoveButton->signal_clicked().connect(SLOT(*this, &DkSettingsDialog::removeSelectedKey));

	// DomainKeys remove all button
	refXml->get_widget("dkRemoveAllButton", dkRemoveAllButton);
	dkRemoveAllButton->signal_clicked().connect(SLOT(*this, &DkSettingsDialog::removeAllKeys));

	// close button
	refXml->get_widget("dkCloseButton", dkCloseButton);
	dkCloseButton->signal_clicked().connect(SLOT(*dkDialog, &Gtk::Dialog::hide));

	// password dialog
	refXml->get_widget("dkPasswdDialog", dkPasswdDialog);

	// password text field
	refXml->get_widget("dkPasswd", dkPasswd);
}

DkSettingsDialog::~DkSettingsDialog() {
	delete dkDialog;
	delete dkPasswdDialog;
}

void DkSettingsDialog::run(){

	if (config->securityConfig.dk_pkey.length() != 0) {
		dkPkeyLabel->set_text(config->securityConfig.dk_pkey);
	}
	else {
		dkPkeyLabel->set_text("Choose your private key file...");
	}

	refreshCacheView();
	dkDialog->run();
}

void DkSettingsDialog::choosePrivateKey() {
	string result;

#ifdef OLDLIBGLADEMM
	Gtk::FileSelection dialog("Choose your private key file");
#else
	Gtk::FileChooserDialog dialog("Choose your private key file");
	dialog.add_button( Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL );
	dialog.add_button( Gtk::Stock::OPEN, Gtk::RESPONSE_OK );
#endif

	if( dialog.run() == Gtk::RESPONSE_OK ) {

		result = dialog.get_filename();

		string pw;
		if (PrivateKey::needsPasswd(result) && dkPasswdDialog->run() == Gtk::RESPONSE_OK) {
			pw = dkPasswd->get_text();
			dkPasswd->set_text("");
		}
		dkPasswdDialog->hide();

		try {
			config->securityConfig.dk_pkey_loaded = new PrivateKey(result, pw);
		}
		catch (PrivateKeyException& e) {
			Gtk::MessageDialog error(	"Minisip could not open the specified private key file. "
										"Please check that the file is a correct PEM-encoded file "
										"and the password is correct.",
										false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK, true);

			error.run();
			return;
		}

		config->securityConfig.dk_pkey = result;
		dkPkeyLabel->set_text(config->securityConfig.dk_pkey);
	}
}

void DkSettingsDialog::setConfig(MRef<SipSoftPhoneConfiguration*> config) {
	this->config = config;

	if (config->securityConfig.dk_enabled) {
		string pkey = config->securityConfig.dk_pkey;
		string passwd;
		if (PrivateKey::needsPasswd(pkey) && dkPasswdDialog->run() == Gtk::RESPONSE_OK) {
			passwd = dkPasswd->get_text();
			dkPasswd->set_text("");			
		}
		dkPasswdDialog->hide();

		try {
			config->securityConfig.dk_pkey_loaded = new PrivateKey(pkey, passwd);
		}
		catch (PrivateKeyException& e) {
			Gtk::MessageDialog error(	"Minisip could not open the specified private key file. "
										"Please check that the file is a correct PEM-encoded file "
										"and the password is correct. Secure calls are disabled, "
										"to enable them go to the settings.",
										false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK, true);

			error.run();
			config->securityConfig.dk_enabled = false;
		}
	}
}

void DkSettingsDialog::removeSelectedKey() {
	Glib::RefPtr<Gtk::TreeSelection> selection= dkCacheView->get_selection();
	if( selection->count_selected_rows () == 0 ) { return; }

	Gtk::TreeModel::iterator selectedItem = selection->get_selected();
	Glib::ustring selectedSip = (*selectedItem)[ sipColumn ];

	DomainKey::deleteCacheEntry(selectedSip.raw());
	refreshCacheView();
}

void DkSettingsDialog::removeAllKeys() {
	DomainKey::deleteCacheEntries();
	refreshCacheView();
}

void DkSettingsDialog::refreshCacheView() {
	dkCacheTreeStore->clear();
	list<string> cache = DomainKey::listCacheEntries();
	list<string>::iterator sip;
	for (sip = cache.begin(); sip != cache.end(); sip++) {
		Gtk::TreeModel::iterator newLine = dkCacheTreeStore->append();
		(*newLine)[ sipColumn ] = (*sip);
	}
}