void WirelessPage::initNetSelector( const QtopiaNetworkProperties& prop )
{
changedSettings.clear();
ui.netSelector->clear();
const QList<QString> keys = prop.keys();
const int numKnownNetworks = prop.value( QLatin1String("WirelessNetworks/size"), 0).toInt();
if ( numKnownNetworks == 0 ) {
ui.advanced_frame->setEnabled( false );
ui.netSelector->setEnabled( false );
ui.newButton->setFocus();
}
disconnect( ui.netSelector, 0, this, 0 );
foreach( QString key, keys ) {
if ( !key.startsWith( "WirelessNetworks" ) )
continue;
int idx = key.mid(17 /*strlen("WirelessNetworks/")*/, key.indexOf(QChar('/'), 17)-17).toInt();
if ( idx <= numKnownNetworks ) {
//copy all values into changedSettings where we keep track of changes
changedSettings.insert( key, prop.value( key ) );
if ( key.endsWith( "ESSID" ) ) {
QString text = prop.value( key ).toString();
if ( text.isEmpty() )
text = tr("Unnamed network");
ui.netSelector->addItem( text );
}
}
}
lastIndex = 0;
ui.netSelector->setCurrentIndex( 0 );
readConfig();
connect( ui.netSelector, SIGNAL(currentIndexChanged(int)), this, SLOT(newNetSelected(int)) );
}
QtopiaNetworkProperties DialingPage::properties()
{
QtopiaNetworkProperties props;
if (ui.timeout->value() == 0)
props.insert("Serial/Timeout", QString("none"));
else
props.insert("Serial/Timeout", ui.timeout->value());
props.insert("Serial/UsePeerDNS",
ui.usepeerdns->checkState()==Qt::Checked ? QString("y"): QString("n"));
props.insert("Properties/DNS_1", ui.dns1->text());
props.insert("Properties/DNS_2", ui.dns2->text());
return props;
}
void DialingPage::readConfig( const QtopiaNetworkProperties& prop )
{
QVariant v = prop.value("Serial/Timeout");
if (!v.isValid()) {
ui.timeout->setValue(120);
} else if (v.toString() == "none") {
ui.timeout->setValue( 0 );
} else if (v.canConvert(QVariant::Int)) {
ui.timeout->setValue( v.toInt() );
}
v = prop.value("Serial/UsePeerDNS");
if ( v.toString() != "n" )
ui.usepeerdns->setCheckState(Qt::Checked);
else
ui.usepeerdns->setCheckState(Qt::Unchecked);
manualDNS( ui.usepeerdns->checkState() );
ui.dns1->setText( prop.value("Properties/DNS_1").toString() );
ui.dns2->setText( prop.value("Properties/DNS_2").toString() );
}
QtopiaNetworkProperties WirelessPage::properties()
{
saveConfig();
//has a new entry been added?
const int size = ui.netSelector->count();
QList<QString> allKeys = changedSettings.keys();
QtopiaNetworkProperties result;
//delete all networks with empty essid
int newSize = 0;
for ( int i = 1; i <= size; i++ ) {
QString entryKey = "WirelessNetworks/"+QString::number( i );
QString essid = changedSettings.value(entryKey+"/ESSID").toString();
if ( !essid.isEmpty() ) {
newSize++;
QString newEntryKey = "WirelessNetworks/"+QString::number( newSize );
foreach( QString k, allKeys )
if ( k.startsWith( entryKey ) ) {
QString key = k.mid(k.lastIndexOf( QChar('/') )+1 );
result.insert( newEntryKey+QChar('/')+key, changedSettings.value(k).toString());
}
}
}
QtopiaNetworkProperties ProxiesPage::properties( )
{
QtopiaNetworkProperties prop;
prop.insert("Proxy/Type",d->type->currentIndex());
prop.insert("Proxy/AutoConfig", d->autoconfig->currentText());
prop.insert("Proxy/HttpHost", d->http_host->text());
prop.insert("Proxy/HttpPort", d->http_port->text());
prop.insert("Proxy/FtpHost", d->ftp_host->text());
prop.insert("Proxy/FtpPort", d->ftp_port->text());
prop.insert("Proxy/NoProxies", d->noproxies->text());
return prop;
}
void IPPage::readConfig( const QtopiaNetworkProperties& prop )
{
if (prop.value("Properties/DHCP").toString() != "n")
autoIp->setCheckState( Qt::Checked);
else {
autoIp->setCheckState( Qt::Unchecked );
ipAddress->setText( prop.value("Properties/IPADDR").toString() );
dnsAddress1->setText( prop.value("Properties/DNS_1").toString() );
dnsAddress2->setText( prop.value("Properties/DNS_2").toString() );
broadcast->setText( prop.value("Properties/BROADCAST").toString() );
gateway->setText( prop.value("Properties/GATEWAY").toString() );
subnet->setText( prop.value("Properties/SUBNET").toString() );
}
connectWdgts();
}
bool LanImpl::start( const QVariant options )
{
const QtopiaNetworkProperties prop = configIface->getProperties();
const bool dhcp = prop.value("Properties/DHCP").toString() != "n";
bool writeToSystem = prop.value("Info/WriteToSystem").toBool();
#ifndef NO_WIRELESS_LAN
int netIndex = 0;
QtopiaNetwork::Type t = type();
if ( t & QtopiaNetwork::WirelessLAN ) {
QString essid = options.toString();
netIndex = roaming->selectWLAN( essid );
if (netIndex <= 0) {
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("No WLAN found in sourrounding area") );
qLog(Network) << "Invalid WLAN selected";
return false;
}
writeToSystem = true; //we always have to update the config since we change it very often
roaming->activeNotification( true );
}
#else
Q_UNUSED( options );
#endif
if ( ifaceStatus != QtopiaNetworkInterface::Down || deviceName.isEmpty() ) {
switch ( ifaceStatus )
{
case QtopiaNetworkInterface::Unknown:
updateTrigger( QtopiaNetworkInterface::NotInitialized,
tr("Interface hasn't been initialized yet.") );
break;
case QtopiaNetworkInterface::Unavailable:
updateTrigger( QtopiaNetworkInterface::NotAvailable,
tr("Interface is not available.") );
break;
case QtopiaNetworkInterface::Up:
case QtopiaNetworkInterface::Pending:
case QtopiaNetworkInterface::Demand:
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Interface already started/active.") );
break;
default:
break;
}
qLog(Network) << "LAN interface cannot be started "
<< configIface->configFile();
return false;
}
if ( writeToSystem ) {
qLog(Network) << "Installing new set of configuration for " << deviceName;
QStringList params;
params << "install";
params << deviceName;
if ( dhcp ) {
// ### install <iface> dhcp
// dhcp takes care of everything
params << "dhcp";
} else {
// ### install <iface> static <ip> <netmask> <broadcast> <gateway>
params << "static";
bool missingOption = false;
QString temp = prop.value("Properties/IPADDR").toString();
if ( temp.isEmpty() ) {
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("IP address missing.") );
qLog(Network) << "IP address missing";
missingOption = true;
} else {
params << temp;
}
if ( missingOption )
return false;
temp = prop.value("Properties/SUBNET").toString();
if ( temp.isEmpty() ) {
qLog(Network) << "Subnet mask missing";
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Subnet mask missing.") );
missingOption = true;
} else {
params << temp;
}
if ( missingOption )
return false;
QString ip = temp; //save ip in case we need it as gateway address
temp = prop.value("Properties/BROADCAST").toString();
if ( temp.isEmpty() ) {
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Broadcast address missing.") );
qLog(Network) << "Broadcast address missing";
missingOption = true;
} else {
params << temp;
}
if ( missingOption )
return false;
temp = prop.value("Properties/GATEWAY").toString();
if ( temp.isEmpty() ) {
qLog(Network) << "Gateway address missing. Using IP address.";
params << ip;
} else {
params << temp;
}
}
thread.addScriptToRun( lanScript, params );
#ifndef NO_WIRELESS_LAN
if ( t & QtopiaNetwork::WirelessLAN ) {
// ### install <iface> wireless
// ### [-essid <ESSID>] [-mode <Master|Managed|Ad-Hoc>]
// ### [-ap <AP>] [-bitrate <value>] [-nick <nickname>] [-channel <CHANNEL>]
// ### [-authmode <open|shared> -multikey <defaultKey> <key1> <key2> <key3> <key4>]
// ### [-authmode <open|shared> -phrase <passphrase> ]
// ### [-authmode <none> -nokey ]
// ### [-authmode <WPA-PSK> <password> <AES|TKIP>
// ### [-authmode <WPA-EAP> <TTLS|PEAP> <client cert> <server cert> ]
// ### [-authmode <WPA-EAP> <TLS> <identity> <password> ]
// ### [-keylength <128|64> ]
const QString keyPrefix = QString("WirelessNetworks/%1/").arg(netIndex);
params.clear();
params << "install";
params << deviceName;
params << "wireless";
QString temp = prop.value(keyPrefix+"WirelessMode").toString();
if ( !temp.isEmpty() ) {
params << "-mode";
params << temp;
}
temp = prop.value(keyPrefix+"ESSID").toString();
if ( !temp.isEmpty() ) {
params << "-essid";
params << Qtopia::shellQuote(temp);
if ( t & QtopiaNetwork::WirelessLAN ) {
wlanRegProvider->setAccessPoint( temp );
}
}
params << "-ap";
params << Qtopia::shellQuote( prop.value(keyPrefix+"AccessPoint").toString() );
temp = prop.value(keyPrefix+"BitRate").toString();
if ( !temp.isEmpty() ) {
params << "-bitrate";
params << temp;
}
temp = prop.value(keyPrefix+"Nickname").toString();
if ( !temp.isEmpty() ) {
params << "-nick";
params << Qtopia::shellQuote(temp);
}
temp = prop.value(keyPrefix+"CHANNEL").toString();
if ( !temp.isEmpty() ) {
params << "-channel";
params << temp;
}
temp = prop.value(keyPrefix+"KeyLength", QString("128")).toString();
params << "-keylength";
params << temp;
QString encryptMode = prop.value(keyPrefix+"Encryption", QString("open")).toString();
params << "-authmode";
params << encryptMode;
if ( encryptMode == "open" || encryptMode == "shared" ) {
const QString defaultKey = prop.value(keyPrefix+"SelectedKey").toString();
const QString pw = prop.value(keyPrefix+"PRIV_GENSTR").toString();
const bool isPassPhrase = defaultKey == "PP";
if ( isPassPhrase ) {
params << "-phrase";
params << Qtopia::shellQuote(pw);
} else {
params << "-multikey";
params << defaultKey.right(1);
for ( int i = 1; i<5; i++ ) {
params << Qtopia::shellQuote(
prop.value(keyPrefix+"WirelessKey_"+QString::number(i)).toString());
}
}
} else if ( encryptMode == QLatin1String("none") ) {
params << "-nokey";
} else if ( encryptMode == QLatin1String("WPA-PSK") ) {
params << Qtopia::shellQuote(prop.value(keyPrefix+QLatin1String("PRIV_GENSTR"), QLatin1String("")).toString());
params << prop.value(keyPrefix+QLatin1String("PSKAlgorithm"), QLatin1String("TKIP")).toString();
} else if ( encryptMode == QLatin1String("WPA-EAP") ) {
temp = prop.value(keyPrefix+QLatin1String("WPAEnterprise"), QLatin1String("TLS")).toString();
params << temp;
if ( temp == QLatin1String("TLS") ) {
params << prop.value(keyPrefix+QLatin1String("EAPIdentity")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPClientKeyPassword")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPClientKey")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPClientCert")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPServerCert")).toString();
} else if ( temp == QLatin1String("TTLS") || temp == QLatin1String("PEAP") ) {
params << prop.value(keyPrefix+QLatin1String("EAPIdentity")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPIdentityPassword")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPServerCert")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPAuthentication")).toString();
params << prop.value(keyPrefix+QLatin1String("EAPAnonIdentity")).toString();
} else {
qLog(Network) << QLatin1String("Unknown encryption algorithm for WPA Enterprise");
return false;
}
} else {
qLog(Network) << QLatin1String("Invalid encryption for WLAN:") << encryptMode;
return false;
}
thread.addScriptToRun( lanScript, params );
}
#endif
//Remove WriteToSystem value
QtopiaNetworkProperties p;
p.insert("Info/WriteToSystem", false);
configIface->writeProperties( p );
}
QStringList args;
// ### start <iface>
args << "start";
args << deviceName;
thread.addScriptToRun( lanScript, args );
//we have to wait a bit until this interface is actually online
//->then it can become the default gateway ->installs dns details as well
ifaceStatus = QtopiaNetworkInterface::Pending;
netSpace->setAttribute( "State", ifaceStatus );
updateTrigger();
delayedGatewayInstall = true;
return true;
}
QtopiaNetworkProperties IPPage::properties()
{
QtopiaNetworkProperties props;
if (autoIp->checkState() == Qt::Checked ) {
props.insert("Properties/DHCP", "y");
props.insert("Properties/IPADDR", QString());
props.insert("Properties/DNS_1", QString());
props.insert("Properties/DNS_2", QString());
props.insert("Properties/BROADCAST", QString());
props.insert("Properties/GATEWAY", QString());
props.insert("Properties/SUBNET", QString());
} else {
props.insert("Properties/DHCP", "n");
props.insert("Properties/IPADDR", ipAddress->text());
props.insert("Properties/DNS_1", dnsAddress1->text());
props.insert("Properties/DNS_2", dnsAddress2->text());
props.insert("Properties/BROADCAST", broadcast->text());
props.insert("Properties/GATEWAY", gateway->text());
props.insert("Properties/SUBNET", subnet->text());
}
return props;
}
void ProxiesPage::readConfig(const QtopiaNetworkProperties& prop)
{
int index = 0;
if (prop.contains("Proxy/Type"))
index = prop.value("Proxy/Type").toInt();
d->type->setCurrentIndex(index);
typeChanged(index);
if (prop.contains("Proxy/AutoConfig"))
d->autoconfig->addItem( prop.value("Proxy/AutoConfig").toString() );
if (prop.contains("Proxy/HttpHost"))
d->http_host->setText( prop.value("Proxy/HttpHost").toString() );
if (prop.contains("Proxy/HttpPort"))
d->http_port->setValue( prop.value("Proxy/HttpPort").toInt() );
if (prop.contains("Proxy/FtpHost"))
d->ftp_host->setText( prop.value("Proxy/FtpHost").toString() );
if (prop.contains("Proxy/FtpPort"))
d->ftp_port->setValue( prop.value("Proxy/FtpPort").toInt() );
if (prop.contains("Proxy/NoProxies")) {
d->noproxies->setValidator(new ProxyValidator(this));
d->noproxies->setText(prop.value("Proxy/NoProxies").toString());
}
}
bool DialupImpl::start( const QVariant /*options*/ )
{
if ( ifaceStatus != QtopiaNetworkInterface::Down ) {
switch ( ifaceStatus )
{
case QtopiaNetworkInterface::Unknown:
updateTrigger( QtopiaNetworkInterface::NotInitialized,
tr("Interface hasn't been initialized yet.") );
break;
case QtopiaNetworkInterface::Unavailable:
updateTrigger( QtopiaNetworkInterface::NotAvailable,
tr("Interface is not available.") );
break;
case QtopiaNetworkInterface::Up:
case QtopiaNetworkInterface::Pending:
case QtopiaNetworkInterface::Demand:
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Interface already started/active.") );
break;
default:
break;
}
qLog(Network) << "ppp interface cannot be started "
<<configIface->configFile();
return false;
}
QtopiaNetworkProperties prop = configIface->getProperties();
QStringList args;
const bool demand = prop.value("Properties/Autostart").toString() == "y";
const QtopiaNetwork::Type t = type();
#ifdef QTOPIA_CELL
if ( t & QtopiaNetwork::PhoneModem ) {
if ( regState != QTelephony::RegistrationHome &&
regState != QTelephony::RegistrationRoaming ) {
//we want to start the network but we don't have a network
//registration yet. wait till registration is done then go ahead
//and start iface
qLog(Network) << "Cannot start dialup yet due to missing"
<< "network registration. try again later";
registrationStateChanged(); //ask for first update
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Missing network registration. Try again later.") );
return false;
}
}
#endif
if ( t & QtopiaNetwork::NamedModem || t & QtopiaNetwork::PCMCIA ) {
QString dev = device();
if ( dev.isEmpty() || dev == "internal") {
qLog(Network) << "No external device";
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Missing external serial device.") );
return false;
}
if ( dev.startsWith("/dev/") )
dev = dev.mid(5);
args << dev;
args << "updetach";
}
#ifdef QTOPIA_CELL
else {
args << "nodetach";
}
#endif
args << "debug";
args << "call";
const QString peerID = prop.value("Serial/PeerID").toString();
if ( peerID.isEmpty() ) {
qLog(Network) << "Missing peer ID";
updateTrigger( QtopiaNetworkInterface::NotConnected,
tr("Missing peer ID. Please reconfigure device.") );
return false;
}
args << peerID;
QString password = prop.value("Properties/Password").toString();
if (!password.isEmpty()) {
args << "password";
args << password;
}
const QString logfile = Qtopia::tempDir() + "qpe-pppd-log-"+peerID;
args << "logfile";
args << logfile;
QFile::remove( logfile ) ;
if ( t & QtopiaNetwork::NamedModem || t & QtopiaNetwork::PCMCIA ) {
qLog(Network) << "###################################";
qLog(Network) << "Starting ppp using external modem: " <<
args.join(" ");
args.prepend("start"); //cmd for network script
thread.addScriptToRun( pppScript, args );
} else { //QtopiaNetwork::PhoneModem
#ifdef QTOPIA_CELL
const QString path = Qtopia::applicationFileName("Network", "chat");
const QString connectF = path+"/connect-"+peerID;
const QString disconnectF = path+"/disconnect-"+peerID;
//Create a data call
qLog(Network) << "###################################";
qLog(Network) << "Starting ppp using internal modem: " <<
args.join(" ");
qLog(Network) << "connect: " << connectF;
qLog(Network) << "disconnect: " << disconnectF;
qLog(Network) << "demand dialing: " << (demand ? "yes" : "no");
QDialOptions pppd;
pppd.setUseIpModule( true );
pppd.setIpProgramName( PPPD_BINARY );
pppd.setIpConnectScript( connectF );
pppd.setIpDisconnectScript( disconnectF );
pppd.setIpDemandDialing( demand );
pppd.setIpArgs( args );
//Make sure that an existing call is stopped.
if ( !dataCall.isNull() ) {
dataCall.hangup();
}
if ( !callManager )
callManager = new QPhoneCallManager( this );
//Dial the new call.
if ( callManager ) {
dataCall = callManager->create( "IP" );
dataCall.connectNotification( this,
SLOT(connectNotification(QPhoneCall,QPhoneCall::Notification,QString)));
dataCall.connectStateChanged( this, SLOT(phoneCallStateChanged(QPhoneCall)) );
dataCall.dial( pppd );
} else {
qLog(Network) << "No call manager created";
}
#endif
}
state = Initialize;
logIndex = 0;
tidStateUpdate = startTimer( 1000 );
if ( demand )
ifaceStatus = QtopiaNetworkInterface::Demand;
else
ifaceStatus = QtopiaNetworkInterface::Pending;
netSpace->setAttribute( "State", ifaceStatus );
updateTrigger();
delayedGatewayInstall = true;
return true;
}
void QOtaCharacteristicList::add
( QtopiaNetworkProperties& cfg, const QString& name, const QString& value )
{
if ( !value.isEmpty() )
cfg.insert( name, value );
}
