diff --git a/daemon/src/account.h b/daemon/src/account.h
index 7d3216ee32d4724f567820dc89a7490eea728cbc..349c3ec89d4d796d6d7054a969295f43edeaf38d 100644
--- a/daemon/src/account.h
+++ b/daemon/src/account.h
@@ -64,69 +64,70 @@ enum RegistrationState {
 };
 
 // Account identifier
-static const char *const ACCOUNT_ID                          = "Account.id";
+static const char *const CONFIG_ACCOUNT_ID                   = "Account.id";
 
 // Common account parameters
 static const char *const CONFIG_ACCOUNT_TYPE                 = "Account.type";
 static const char *const CONFIG_ACCOUNT_ALIAS                = "Account.alias";
 static const char *const CONFIG_ACCOUNT_MAILBOX	             = "Account.mailbox";
 static const char *const CONFIG_ACCOUNT_ENABLE               = "Account.enable";
+static const char *const CONFIG_ACCOUNT_RESOLVE_ONCE         = "Account.resolveOnce";
 static const char *const CONFIG_ACCOUNT_REGISTRATION_EXPIRE  = "Account.registrationExpire";
 static const char *const CONFIG_CREDENTIAL_NUMBER            = "Credential.count";
-static const char *const ACCOUNT_DTMF_TYPE                   = "Account.dtmfType";
+static const char *const CONFIG_ACCOUNT_DTMF_TYPE            = "Account.dtmfType";
 static const char *const CONFIG_RINGTONE_PATH                = "Account.ringtonePath";
 static const char *const CONFIG_RINGTONE_ENABLED             = "Account.ringtoneEnabled";
 
-static const char *const HOSTNAME                            = "hostname";
-static const char *const USERNAME                            = "username";
-static const char *const ROUTESET                            = "routeset";
-static const char *const PASSWORD                            = "password";
-static const char *const REALM                               = "realm";
-static const char *const DEFAULT_REALM                       = "*";
-static const char *const USERAGENT							 = "useragent";
+static const char *const CONFIG_ACCOUNT_HOSTNAME             = "Account.hostname";
+static const char *const CONFIG_ACCOUNT_USERNAME             = "Account.username";
+static const char *const CONFIG_ACCOUNT_ROUTESET             = "Account.routeset";
+static const char *const CONFIG_ACCOUNT_PASSWORD             = "Account.password";
+static const char *const CONFIG_ACCOUNT_REALM                = "Account.realm";
+static const char *const CONFIG_ACCOUNT_DEFAULT_REALM        = "*";
+static const char *const CONFIG_ACCOUNT_USERAGENT            = "Account.useragent";
 
-static const char *const LOCAL_INTERFACE                     = "Account.localInterface";
-static const char *const PUBLISHED_SAMEAS_LOCAL              = "Account.publishedSameAsLocal";
-static const char *const LOCAL_PORT                          = "Account.localPort";
-static const char *const PUBLISHED_PORT                      = "Account.publishedPort";
-static const char *const PUBLISHED_ADDRESS                   = "Account.publishedAddress";
+static const char *const CONFIG_LOCAL_INTERFACE              = "Account.localInterface";
+static const char *const CONFIG_PUBLISHED_SAMEAS_LOCAL       = "Account.publishedSameAsLocal";
+static const char *const CONFIG_LOCAL_PORT                   = "Account.localPort";
+static const char *const CONFIG_PUBLISHED_PORT               = "Account.publishedPort";
+static const char *const CONFIG_PUBLISHED_ADDRESS            = "Account.publishedAddress";
 
-static const char *const DISPLAY_NAME                        = "Account.displayName";
-static const char *const DEFAULT_ADDRESS                     = "0.0.0.0";
+static const char *const CONFIG_DISPLAY_NAME                 = "Account.displayName";
+static const char *const CONFIG_DEFAULT_ADDRESS              = "0.0.0.0";
 
 // SIP specific parameters
-static const char *const SIP_PROXY                           = "SIP.proxy";
-static const char *const STUN_SERVER						 = "STUN.server";
-static const char *const STUN_ENABLE						 = "STUN.enable";
+static const char *const CONFIG_SIP_PROXY                    = "SIP.proxy";
+static const char *const CONFIG_STUN_SERVER                  = "STUN.server";
+static const char *const CONFIG_STUN_ENABLE                  = "STUN.enable";
 
 // SRTP specific parameters
-static const char *const SRTP_ENABLE                         = "SRTP.enable";
-static const char *const SRTP_KEY_EXCHANGE                   = "SRTP.keyExchange";
-static const char *const SRTP_ENCRYPTION_ALGO                = "SRTP.encryptionAlgorithm";  // Provided by ccRTP,0=NULL,1=AESCM,2=AESF8
-static const char *const SRTP_RTP_FALLBACK                   = "SRTP.rtpFallback";
-static const char *const ZRTP_HELLO_HASH                     = "ZRTP.helloHashEnable";
-static const char *const ZRTP_DISPLAY_SAS                    = "ZRTP.displaySAS";
-static const char *const ZRTP_NOT_SUPP_WARNING               = "ZRTP.notSuppWarning";
-static const char *const ZRTP_DISPLAY_SAS_ONCE               = "ZRTP.displaySasOnce";
-
-static const char *const TLS_LISTENER_PORT                   = "TLS.listenerPort";
-static const char *const TLS_ENABLE                          = "TLS.enable";
-static const char *const TLS_CA_LIST_FILE                    = "TLS.certificateListFile";
-static const char *const TLS_CERTIFICATE_FILE                = "TLS.certificateFile";
-static const char *const TLS_PRIVATE_KEY_FILE                = "TLS.privateKeyFile";
-static const char *const TLS_PASSWORD                        = "TLS.password";
-static const char *const TLS_METHOD                          = "TLS.method";
-static const char *const TLS_CIPHERS                         = "TLS.ciphers";
-static const char *const TLS_SERVER_NAME                     = "TLS.serverName";
-static const char *const TLS_VERIFY_SERVER                   = "TLS.verifyServer";
-static const char *const TLS_VERIFY_CLIENT                   = "TLS.verifyClient";
-static const char *const TLS_REQUIRE_CLIENT_CERTIFICATE      = "TLS.requireClientCertificate";
-static const char *const TLS_NEGOTIATION_TIMEOUT_SEC         = "TLS.negotiationTimeoutSec";
-static const char *const TLS_NEGOTIATION_TIMEOUT_MSEC        = "TLS.negotiationTimemoutMsec";
-
-static const char *const REGISTRATION_STATUS                 = "Status";
-static const char *const REGISTRATION_STATE_CODE             = "Registration.code";
-static const char *const REGISTRATION_STATE_DESCRIPTION      = "Registration.description";
+static const char *const CONFIG_SRTP_ENABLE                  = "SRTP.enable";
+static const char *const CONFIG_SRTP_KEY_EXCHANGE            = "SRTP.keyExchange";
+static const char *const CONFIG_SRTP_ENCRYPTION_ALGO         = "SRTP.encryptionAlgorithm";  // Provided by ccRTP,0=NULL,1=AESCM,2=AESF8
+static const char *const CONFIG_SRTP_RTP_FALLBACK            = "SRTP.rtpFallback";
+static const char *const CONFIG_ZRTP_HELLO_HASH              = "ZRTP.helloHashEnable";
+static const char *const CONFIG_ZRTP_DISPLAY_SAS             = "ZRTP.displaySAS";
+static const char *const CONFIG_ZRTP_NOT_SUPP_WARNING        = "ZRTP.notSuppWarning";
+static const char *const CONFIG_ZRTP_DISPLAY_SAS_ONCE        = "ZRTP.displaySasOnce";
+
+static const char *const CONFIG_TLS_LISTENER_PORT            = "TLS.listenerPort";
+static const char *const CONFIG_TLS_ENABLE                   = "TLS.enable";
+static const char *const CONFIG_TLS_CA_LIST_FILE             = "TLS.certificateListFile";
+static const char *const CONFIG_TLS_CERTIFICATE_FILE         = "TLS.certificateFile";
+static const char *const CONFIG_TLS_PRIVATE_KEY_FILE         = "TLS.privateKeyFile";
+static const char *const CONFIG_TLS_PASSWORD                 = "TLS.password";
+static const char *const CONFIG_TLS_METHOD                   = "TLS.method";
+static const char *const CONFIG_TLS_CIPHERS                  = "TLS.ciphers";
+static const char *const CONFIG_TLS_SERVER_NAME              = "TLS.serverName";
+static const char *const CONFIG_TLS_VERIFY_SERVER            = "TLS.verifyServer";
+static const char *const CONFIG_TLS_VERIFY_CLIENT            = "TLS.verifyClient";
+static const char *const CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE = "TLS.requireClientCertificate";
+static const char *const CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC  = "TLS.negotiationTimeoutSec";
+static const char *const CONFIG_TLS_NEGOTIATION_TIMEOUT_MSEC = "TLS.negotiationTimemoutMsec";
+
+static const char *const CONFIG_REGISTRATION_STATUS                 = "Registration.Status";
+static const char *const CONFIG_REGISTRATION_STATE_CODE             = "Registration.code";
+static const char *const CONFIG_REGISTRATION_STATE_DESCRIPTION      = "Registration.description";
 
 // General configuration keys for accounts
 static const char * const aliasKey = "alias";
diff --git a/daemon/src/dbus/configurationmanager.cpp b/daemon/src/dbus/configurationmanager.cpp
index 08e0c6ebdace35b4d5e72acb27e457ff5d7f76b2..3e0d06106fa1cd55321635855691178cf9f2a603 100644
--- a/daemon/src/dbus/configurationmanager.cpp
+++ b/daemon/src/dbus/configurationmanager.cpp
@@ -79,19 +79,19 @@ ConfigurationManager::getTlsSettingsDefault()
     portstr << DEFAULT_SIP_TLS_PORT;
 
     std::map<std::string, std::string> tlsSettingsDefault;
-    tlsSettingsDefault[TLS_LISTENER_PORT] = portstr.str();
-    tlsSettingsDefault[TLS_CA_LIST_FILE] = "";
-    tlsSettingsDefault[TLS_CERTIFICATE_FILE] = "";
-    tlsSettingsDefault[TLS_PRIVATE_KEY_FILE] = "";
-    tlsSettingsDefault[TLS_PASSWORD] = "";
-    tlsSettingsDefault[TLS_METHOD] = "TLSv1";
-    tlsSettingsDefault[TLS_CIPHERS] = "";
-    tlsSettingsDefault[TLS_SERVER_NAME] = "";
-    tlsSettingsDefault[TLS_VERIFY_SERVER] = "true";
-    tlsSettingsDefault[TLS_VERIFY_CLIENT] = "true";
-    tlsSettingsDefault[TLS_REQUIRE_CLIENT_CERTIFICATE] = "true";
-    tlsSettingsDefault[TLS_NEGOTIATION_TIMEOUT_SEC] = "2";
-    tlsSettingsDefault[TLS_NEGOTIATION_TIMEOUT_MSEC] = "0";
+    tlsSettingsDefault[CONFIG_TLS_LISTENER_PORT] = portstr.str();
+    tlsSettingsDefault[CONFIG_TLS_CA_LIST_FILE] = "";
+    tlsSettingsDefault[CONFIG_TLS_CERTIFICATE_FILE] = "";
+    tlsSettingsDefault[CONFIG_TLS_PRIVATE_KEY_FILE] = "";
+    tlsSettingsDefault[CONFIG_TLS_PASSWORD] = "";
+    tlsSettingsDefault[CONFIG_TLS_METHOD] = "TLSv1";
+    tlsSettingsDefault[CONFIG_TLS_CIPHERS] = "";
+    tlsSettingsDefault[CONFIG_TLS_SERVER_NAME] = "";
+    tlsSettingsDefault[CONFIG_TLS_VERIFY_SERVER] = "true";
+    tlsSettingsDefault[CONFIG_TLS_VERIFY_CLIENT] = "true";
+    tlsSettingsDefault[CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE] = "true";
+    tlsSettingsDefault[CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC] = "2";
+    tlsSettingsDefault[CONFIG_TLS_NEGOTIATION_TIMEOUT_MSEC] = "0";
 
     return tlsSettingsDefault;
 }
diff --git a/daemon/src/iax/iaxaccount.cpp b/daemon/src/iax/iaxaccount.cpp
index 5c653c037a5dee506c1df23e2cf296f55013e1b0..4e975ce5e840ff571c7c73cd949f087f9d87d87f 100644
--- a/daemon/src/iax/iaxaccount.cpp
+++ b/daemon/src/iax/iaxaccount.cpp
@@ -114,32 +114,32 @@ void IAXAccount::setAccountDetails(std::map<std::string, std::string> details)
     // Account setting common to SIP and IAX
     alias_ = details[CONFIG_ACCOUNT_ALIAS];
     type_ = details[CONFIG_ACCOUNT_TYPE];
-    username_ = details[USERNAME];
-    hostname_ = details[HOSTNAME];
-    password_ = details[PASSWORD];
+    username_ = details[CONFIG_ACCOUNT_USERNAME];
+    hostname_ = details[CONFIG_ACCOUNT_HOSTNAME];
+    password_ = details[CONFIG_ACCOUNT_PASSWORD];
     enabled_ = details[CONFIG_ACCOUNT_ENABLE] == "true";
     mailBox_ = details[CONFIG_ACCOUNT_MAILBOX];
-    displayName_ = details[DISPLAY_NAME];
-    userAgent_ = details[USERAGENT];
+    displayName_ = details[CONFIG_DISPLAY_NAME];
+    userAgent_ = details[CONFIG_ACCOUNT_USERAGENT];
 }
 
 std::map<std::string, std::string> IAXAccount::getAccountDetails() const
 {
     std::map<std::string, std::string> a;
 
-    a[ACCOUNT_ID] = accountID_;
+    a[CONFIG_ACCOUNT_ID] = accountID_;
     a[CONFIG_ACCOUNT_ALIAS] = alias_;
     a[CONFIG_ACCOUNT_ENABLE] = enabled_ ? "true" : "false";
     a[CONFIG_ACCOUNT_TYPE] = type_;
-    a[HOSTNAME] = hostname_;
-    a[USERNAME] = username_;
-    a[PASSWORD] = password_;
+    a[CONFIG_ACCOUNT_HOSTNAME] = hostname_;
+    a[CONFIG_ACCOUNT_USERNAME] = username_;
+    a[CONFIG_ACCOUNT_PASSWORD] = password_;
     a[CONFIG_ACCOUNT_MAILBOX] = mailBox_;
 
     RegistrationState state(registrationState_);
 
-    a[REGISTRATION_STATUS] = mapStateNumberToString(state);
-    a[USERAGENT] = userAgent_;
+    a[CONFIG_REGISTRATION_STATUS] = mapStateNumberToString(state);
+    a[CONFIG_ACCOUNT_USERAGENT] = userAgent_;
 
     return a;
 }
diff --git a/daemon/src/managerimpl.cpp b/daemon/src/managerimpl.cpp
index 499f5ee8aadebc6a73c84960f17f39af4689720e..264f0e623e479f995f8186526c019ab014bfaa6f 100644
--- a/daemon/src/managerimpl.cpp
+++ b/daemon/src/managerimpl.cpp
@@ -2386,7 +2386,7 @@ std::map<std::string, std::string> ManagerImpl::getAccountDetails(
     }
 
     AccountMap::const_iterator iter = accountMap_.find(accountID);
-    Account * account = 0;
+    Account * account = NULL;
 
     if (iter != accountMap_.end())
         account = iter->second;
diff --git a/daemon/src/preferences.h b/daemon/src/preferences.h
index b056527825de51bd6728ec758bfc04173cdfe4c1..e4e99a4e11cdd6d02e94fad55cdd1c935e3823e6 100644
--- a/daemon/src/preferences.h
+++ b/daemon/src/preferences.h
@@ -40,7 +40,7 @@ static const char * const historyLimitKey = "historyLimit";
 static const char * const historyMaxCallsKey = "historyMaxCalls";
 static const char * const  notifyMailsKey = "notifyMails";
 static const char * const zoneToneChoiceKey = "zoneToneChoice";
-static const char * const registrationExpireKey = "registrationExpire";
+static const char * const registrationExpireKey = "registrationexpire";
 static const char * const portNumKey = "portNum";
 static const char * const searchBarDisplayKey = "searchBarDisplay";
 static const char * const zeroConfenableKey = "zeroConfenable";
diff --git a/daemon/src/sip/sipaccount.cpp b/daemon/src/sip/sipaccount.cpp
index bd57505637c48fc32e8bcd72bbac48e64266e28e..b5f2275f89d0653cb932ea2c6440958a4d93c043 100644
--- a/daemon/src/sip/sipaccount.cpp
+++ b/daemon/src/sip/sipaccount.cpp
@@ -116,7 +116,7 @@ void SIPAccount::serialize(Conf::YamlEmitter *emitter)
     ScalarNode type(Account::type_);
     std::stringstream registrationExpireStr;
     registrationExpireStr << registrationExpire_;
-    ScalarNode expire(registrationExpireStr);
+    ScalarNode expire(registrationExpireStr.str());
     ScalarNode interface(interface_);
     std::stringstream portstr;
     portstr << localPort_;
@@ -209,9 +209,9 @@ void SIPAccount::serialize(Conf::YamlEmitter *emitter)
     for (it = credentials_.begin(); it != credentials_.end(); ++it) {
         std::map<std::string, std::string> cred = *it;
         MappingNode *map = new MappingNode(NULL);
-        map->setKeyValue(USERNAME, new ScalarNode(cred[USERNAME]));
-        map->setKeyValue(PASSWORD, new ScalarNode(cred[PASSWORD]));
-        map->setKeyValue(REALM, new ScalarNode(cred[REALM]));
+        map->setKeyValue(CONFIG_ACCOUNT_USERNAME, new ScalarNode(cred[CONFIG_ACCOUNT_USERNAME]));
+        map->setKeyValue(CONFIG_ACCOUNT_PASSWORD, new ScalarNode(cred[CONFIG_ACCOUNT_PASSWORD]));
+        map->setKeyValue(CONFIG_ACCOUNT_REALM, new ScalarNode(cred[CONFIG_ACCOUNT_REALM]));
         credentialseq.addNode(map);
     }
 
@@ -241,9 +241,9 @@ void SIPAccount::serialize(Conf::YamlEmitter *emitter)
 
     for (seqit = seq->begin(); seqit != seq->end(); ++seqit) {
         MappingNode *node = (MappingNode*)*seqit;
-        delete node->getValue(USERNAME);
-        delete node->getValue(PASSWORD);
-        delete node->getValue(REALM);
+        delete node->getValue(CONFIG_ACCOUNT_USERNAME);
+        delete node->getValue(CONFIG_ACCOUNT_PASSWORD);
+        delete node->getValue(CONFIG_ACCOUNT_REALM);
         delete node;
     }
 
@@ -315,13 +315,13 @@ void SIPAccount::unserialize(Conf::MappingNode *map)
             std::string user;
             std::string pass;
             std::string realm;
-            cred->getValue(USERNAME, &user);
-            cred->getValue(PASSWORD, &pass);
-            cred->getValue(REALM, &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[USERNAME] = user;
-            credentialMap[PASSWORD] = pass;
-            credentialMap[REALM] = realm;
+            credentialMap[CONFIG_ACCOUNT_USERNAME] = user;
+            credentialMap[CONFIG_ACCOUNT_PASSWORD] = pass;
+            credentialMap[CONFIG_ACCOUNT_REALM] = realm;
             creds.push_back(credentialMap);
         }
     }
@@ -332,9 +332,9 @@ void SIPAccount::unserialize(Conf::MappingNode *map)
         std::string password;
         map->getValue(passwordKey, &password);
 
-        credmap[USERNAME] = username_;
-        credmap[PASSWORD] = password;
-        credmap[REALM] = "*";
+        credmap[CONFIG_ACCOUNT_USERNAME] = username_;
+        credmap[CONFIG_ACCOUNT_PASSWORD] = password;
+        credmap[CONFIG_ACCOUNT_REALM] = "*";
         creds.push_back(credmap);
     }
 
@@ -387,8 +387,8 @@ void SIPAccount::setAccountDetails(std::map<std::string, std::string> details)
     // Account setting common to SIP and IAX
     alias_ = details[CONFIG_ACCOUNT_ALIAS];
     type_ = details[CONFIG_ACCOUNT_TYPE];
-    username_ = details[USERNAME];
-    hostname_ = details[HOSTNAME];
+    username_ = details[CONFIG_ACCOUNT_USERNAME];
+    hostname_ = details[CONFIG_ACCOUNT_HOSTNAME];
     enabled_ = details[CONFIG_ACCOUNT_ENABLE] == "true";
     ringtonePath_ = details[CONFIG_RINGTONE_PATH];
     ringtoneEnabled_ = details[CONFIG_RINGTONE_ENABLED] == "true";
@@ -397,54 +397,54 @@ void SIPAccount::setAccountDetails(std::map<std::string, std::string> details)
     // SIP specific account settings
 
     // general sip settings
-    displayName_ = details[DISPLAY_NAME];
-    serviceRoute_ = details[ROUTESET];
-    interface_ = details[LOCAL_INTERFACE];
-    publishedSameasLocal_ = details[PUBLISHED_SAMEAS_LOCAL] == "true";
-    publishedIpAddress_ = details[PUBLISHED_ADDRESS];
-    localPort_ = atoi(details[LOCAL_PORT].c_str());
-    publishedPort_ = atoi(details[PUBLISHED_PORT].c_str());
-    stunServer_ = details[STUN_SERVER];
-    stunEnabled_ = details[STUN_ENABLE] == "true";
-    dtmfType_ = details[ACCOUNT_DTMF_TYPE];
+    displayName_ = details[CONFIG_DISPLAY_NAME];
+    serviceRoute_ = details[CONFIG_ACCOUNT_ROUTESET];
+    interface_ = details[CONFIG_LOCAL_INTERFACE];
+    publishedSameasLocal_ = details[CONFIG_PUBLISHED_SAMEAS_LOCAL] == "true";
+    publishedIpAddress_ = details[CONFIG_PUBLISHED_ADDRESS];
+    localPort_ = atoi(details[CONFIG_LOCAL_PORT].c_str());
+    publishedPort_ = atoi(details[CONFIG_PUBLISHED_PORT].c_str());
+    stunServer_ = details[CONFIG_STUN_SERVER];
+    stunEnabled_ = details[CONFIG_STUN_ENABLE] == "true";
+    dtmfType_ = details[CONFIG_ACCOUNT_DTMF_TYPE];
     registrationExpire_ = atoi(details[CONFIG_ACCOUNT_REGISTRATION_EXPIRE].c_str());
 
-    userAgent_ = details[USERAGENT];
+    userAgent_ = details[CONFIG_ACCOUNT_USERAGENT];
 
     // srtp settings
-    srtpEnabled_ = details[SRTP_ENABLE] == "true";
-    srtpFallback_ = details[SRTP_RTP_FALLBACK] == "true";
-    zrtpDisplaySas_ = details[ZRTP_DISPLAY_SAS] == "true";
-    zrtpDisplaySasOnce_ = details[ZRTP_DISPLAY_SAS_ONCE] == "true";
-    zrtpNotSuppWarning_ = details[ZRTP_NOT_SUPP_WARNING] == "true";
-    zrtpHelloHash_ = details[ZRTP_HELLO_HASH] == "true";
-    srtpKeyExchange_ = details[SRTP_KEY_EXCHANGE];
+    srtpEnabled_ = details[CONFIG_SRTP_ENABLE] == "true";
+    srtpFallback_ = details[CONFIG_SRTP_RTP_FALLBACK] == "true";
+    zrtpDisplaySas_ = details[CONFIG_ZRTP_DISPLAY_SAS] == "true";
+    zrtpDisplaySasOnce_ = details[CONFIG_ZRTP_DISPLAY_SAS_ONCE] == "true";
+    zrtpNotSuppWarning_ = details[CONFIG_ZRTP_NOT_SUPP_WARNING] == "true";
+    zrtpHelloHash_ = details[CONFIG_ZRTP_HELLO_HASH] == "true";
+    srtpKeyExchange_ = details[CONFIG_SRTP_KEY_EXCHANGE];
 
     // TLS settings
     // The TLS listener is unique and globally defined through IP2IP_PROFILE
     if (accountID_ == IP2IP_PROFILE)
-        tlsListenerPort_ = atoi(details[TLS_LISTENER_PORT].c_str());
-
-    tlsEnable_ = details[TLS_ENABLE];
-    tlsCaListFile_ = details[TLS_CA_LIST_FILE];
-    tlsCertificateFile_ = details[TLS_CERTIFICATE_FILE];
-    tlsPrivateKeyFile_ = details[TLS_PRIVATE_KEY_FILE];
-    tlsPassword_ = details[TLS_PASSWORD];
-    tlsMethod_ = details[TLS_METHOD];
-    tlsCiphers_ = details[TLS_CIPHERS];
-    tlsServerName_ = details[TLS_SERVER_NAME];
-    tlsVerifyServer_ = details[TLS_VERIFY_SERVER] == "true";
-    tlsVerifyClient_ = details[TLS_VERIFY_CLIENT] == "true";
-    tlsRequireClientCertificate_ = details[TLS_REQUIRE_CLIENT_CERTIFICATE] == "true";
-    tlsNegotiationTimeoutSec_ = details[TLS_NEGOTIATION_TIMEOUT_SEC];
-    tlsNegotiationTimeoutMsec_ = details[TLS_NEGOTIATION_TIMEOUT_MSEC];
+        tlsListenerPort_ = atoi(details[CONFIG_TLS_LISTENER_PORT].c_str());
+
+    tlsEnable_ = details[CONFIG_TLS_ENABLE];
+    tlsCaListFile_ = details[CONFIG_TLS_CA_LIST_FILE];
+    tlsCertificateFile_ = details[CONFIG_TLS_CERTIFICATE_FILE];
+    tlsPrivateKeyFile_ = details[CONFIG_TLS_PRIVATE_KEY_FILE];
+    tlsPassword_ = details[CONFIG_TLS_PASSWORD];
+    tlsMethod_ = details[CONFIG_TLS_METHOD];
+    tlsCiphers_ = details[CONFIG_TLS_CIPHERS];
+    tlsServerName_ = details[CONFIG_TLS_SERVER_NAME];
+    tlsVerifyServer_ = details[CONFIG_TLS_VERIFY_SERVER] == "true";
+    tlsVerifyClient_ = details[CONFIG_TLS_VERIFY_CLIENT] == "true";
+    tlsRequireClientCertificate_ = details[CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE] == "true";
+    tlsNegotiationTimeoutSec_ = details[CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC];
+    tlsNegotiationTimeoutMsec_ = details[CONFIG_TLS_NEGOTIATION_TIMEOUT_MSEC];
 
     if (credentials_.empty()) { // credentials not set, construct 1 entry
         std::vector<std::map<std::string, std::string> > v;
         std::map<std::string, std::string> map;
-        map[USERNAME] = username_;
-        map[PASSWORD] = details[PASSWORD];
-        map[REALM]    = "*";
+        map[CONFIG_ACCOUNT_USERNAME] = username_;
+        map[CONFIG_ACCOUNT_PASSWORD] = details[CONFIG_ACCOUNT_PASSWORD];
+        map[CONFIG_ACCOUNT_REALM]    = "*";
         v.push_back(map);
         setCredentials(v);
     }
@@ -454,14 +454,14 @@ std::map<std::string, std::string> SIPAccount::getAccountDetails() const
 {
     std::map<std::string, std::string> a;
 
-    a[ACCOUNT_ID] = accountID_;
+    a[CONFIG_ACCOUNT_ID] = accountID_;
     // The IP profile does not allow to set an alias
     a[CONFIG_ACCOUNT_ALIAS] = (accountID_ == IP2IP_PROFILE) ? IP2IP_PROFILE : alias_;
 
     a[CONFIG_ACCOUNT_ENABLE] = enabled_ ? "true" : "false";
     a[CONFIG_ACCOUNT_TYPE] = type_;
-    a[HOSTNAME] = hostname_;
-    a[USERNAME] = username_;
+    a[CONFIG_ACCOUNT_HOSTNAME] = hostname_;
+    a[CONFIG_ACCOUNT_USERNAME] = username_;
 
     a[CONFIG_RINGTONE_PATH] = ringtonePath_;
     a[CONFIG_RINGTONE_ENABLED] = ringtoneEnabled_ ? "true" : "false";
@@ -482,57 +482,58 @@ std::map<std::string, std::string> SIPAccount::getAccountDetails() const
         registrationStateDescription = registrationStateDetailed_.second;
     }
 
-    a[REGISTRATION_STATUS] = (accountID_ == IP2IP_PROFILE) ? "READY": mapStateNumberToString(state);
-    a[REGISTRATION_STATE_CODE] = registrationStateCode;
-    a[REGISTRATION_STATE_DESCRIPTION] = registrationStateDescription;
+    a[CONFIG_REGISTRATION_STATUS] = (accountID_ == IP2IP_PROFILE) ? "READY": mapStateNumberToString(state);
+    a[CONFIG_REGISTRATION_STATE_CODE] = registrationStateCode;
+    a[CONFIG_REGISTRATION_STATE_DESCRIPTION] = registrationStateDescription;
 
     // Add sip specific details
-    a[ROUTESET] = serviceRoute_;
-    a[USERAGENT] = userAgent_;
+    a[CONFIG_ACCOUNT_ROUTESET] = serviceRoute_;
+    a[CONFIG_ACCOUNT_USERAGENT] = userAgent_;
 
     std::stringstream registrationExpireStr;
     registrationExpireStr << registrationExpire_;
+    DEBUG("Registration expire %s, %s, %s", accountID_.c_str(), registrationExpireStr.str().c_str(), CONFIG_ACCOUNT_REGISTRATION_EXPIRE);
     a[CONFIG_ACCOUNT_REGISTRATION_EXPIRE] = registrationExpireStr.str();
-    a[LOCAL_INTERFACE] = interface_;
-    a[PUBLISHED_SAMEAS_LOCAL] = publishedSameasLocal_ ? "true" : "false";
-    a[PUBLISHED_ADDRESS] = publishedIpAddress_;
+    a[CONFIG_LOCAL_INTERFACE] = interface_;
+    a[CONFIG_PUBLISHED_SAMEAS_LOCAL] = publishedSameasLocal_ ? "true" : "false";
+    a[CONFIG_PUBLISHED_ADDRESS] = publishedIpAddress_;
 
     std::stringstream localport;
     localport << localPort_;
-    a[LOCAL_PORT] = localport.str();
+    a[CONFIG_LOCAL_PORT] = localport.str();
     std::stringstream publishedport;
     publishedport << publishedPort_;
-    a[PUBLISHED_PORT] = publishedport.str();
-    a[STUN_ENABLE] = stunEnabled_ ? "true" : "false";
-    a[STUN_SERVER] = stunServer_;
-    a[ACCOUNT_DTMF_TYPE] = dtmfType_;
+    a[CONFIG_PUBLISHED_PORT] = publishedport.str();
+    a[CONFIG_STUN_ENABLE] = stunEnabled_ ? "true" : "false";
+    a[CONFIG_STUN_SERVER] = stunServer_;
+    a[CONFIG_ACCOUNT_DTMF_TYPE] = dtmfType_;
 
-    a[SRTP_KEY_EXCHANGE] = srtpKeyExchange_;
-    a[SRTP_ENABLE] = srtpEnabled_ ? "true" : "false";
-    a[SRTP_RTP_FALLBACK] = srtpFallback_ ? "true" : "false";
+    a[CONFIG_SRTP_KEY_EXCHANGE] = srtpKeyExchange_;
+    a[CONFIG_SRTP_ENABLE] = srtpEnabled_ ? "true" : "false";
+    a[CONFIG_SRTP_RTP_FALLBACK] = srtpFallback_ ? "true" : "false";
 
-    a[ZRTP_DISPLAY_SAS] = zrtpDisplaySas_ ? "true" : "false";
-    a[ZRTP_DISPLAY_SAS_ONCE] = zrtpDisplaySasOnce_ ? "true" : "false";
-    a[ZRTP_HELLO_HASH] = zrtpHelloHash_ ? "true" : "false";
-    a[ZRTP_NOT_SUPP_WARNING] = zrtpNotSuppWarning_ ? "true" : "false";
+    a[CONFIG_ZRTP_DISPLAY_SAS] = zrtpDisplaySas_ ? "true" : "false";
+    a[CONFIG_ZRTP_DISPLAY_SAS_ONCE] = zrtpDisplaySasOnce_ ? "true" : "false";
+    a[CONFIG_ZRTP_HELLO_HASH] = zrtpHelloHash_ ? "true" : "false";
+    a[CONFIG_ZRTP_NOT_SUPP_WARNING] = zrtpNotSuppWarning_ ? "true" : "false";
 
     // TLS listener is unique and parameters are modified through IP2IP_PROFILE
     std::stringstream tlslistenerport;
     tlslistenerport << tlsListenerPort_;
-    a[TLS_LISTENER_PORT] = tlslistenerport.str();
-    a[TLS_ENABLE] = tlsEnable_;
-    a[TLS_CA_LIST_FILE] = tlsCaListFile_;
-    a[TLS_CERTIFICATE_FILE] = tlsCertificateFile_;
-    a[TLS_PRIVATE_KEY_FILE] = tlsPrivateKeyFile_;
-    a[TLS_PASSWORD] = tlsPassword_;
-    a[TLS_METHOD] = tlsMethod_;
-    a[TLS_CIPHERS] = tlsCiphers_;
-    a[TLS_SERVER_NAME] = tlsServerName_;
-    a[TLS_VERIFY_SERVER] = tlsVerifyServer_ ? "true" : "false";
-    a[TLS_VERIFY_CLIENT] = tlsVerifyClient_ ? "true" : "false";
-    a[TLS_REQUIRE_CLIENT_CERTIFICATE] = tlsRequireClientCertificate_ ? "true" : "false";
-    a[TLS_NEGOTIATION_TIMEOUT_SEC] = tlsNegotiationTimeoutSec_;
-    a[TLS_NEGOTIATION_TIMEOUT_MSEC] = tlsNegotiationTimeoutMsec_;
+    a[CONFIG_TLS_LISTENER_PORT] = tlslistenerport.str();
+    a[CONFIG_TLS_ENABLE] = tlsEnable_;
+    a[CONFIG_TLS_CA_LIST_FILE] = tlsCaListFile_;
+    a[CONFIG_TLS_CERTIFICATE_FILE] = tlsCertificateFile_;
+    a[CONFIG_TLS_PRIVATE_KEY_FILE] = tlsPrivateKeyFile_;
+    a[CONFIG_TLS_PASSWORD] = tlsPassword_;
+    a[CONFIG_TLS_METHOD] = tlsMethod_;
+    a[CONFIG_TLS_CIPHERS] = tlsCiphers_;
+    a[CONFIG_TLS_SERVER_NAME] = tlsServerName_;
+    a[CONFIG_TLS_VERIFY_SERVER] = tlsVerifyServer_ ? "true" : "false";
+    a[CONFIG_TLS_VERIFY_CLIENT] = tlsVerifyClient_ ? "true" : "false";
+    a[CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE] = tlsRequireClientCertificate_ ? "true" : "false";
+    a[CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC] = tlsNegotiationTimeoutSec_;
+    a[CONFIG_TLS_NEGOTIATION_TIMEOUT_MSEC] = tlsNegotiationTimeoutMsec_;
 
     return a;
 }
@@ -586,15 +587,22 @@ void SIPAccount::startKeepAliveTimer() {
     if (isTlsEnabled())
         return;
 
+    DEBUG("SIP ACCOUNT: start keep alive timer");
+
     pj_time_val keepAliveDelay_;
     keepAliveTimer_.cb = &SIPAccount::keepAliveRegistrationCb;
     keepAliveTimer_.user_data = this;
 
     // expiration may be undetermined during the first registration request
-    if (registrationExpire_ == 0)
+    if (registrationExpire_ == 0) {
+        DEBUG("Registration Expire == 0, take 60");
         keepAliveDelay_.sec = 60;
-    else
+    }
+    else {
+        DEBUG("Regsitration Expire == %d", registrationExpire_);
         keepAliveDelay_.sec = registrationExpire_;
+    }
+
 
     keepAliveDelay_.msec = 0;
 
@@ -874,11 +882,11 @@ void SIPAccount::setCredentials(const std::vector<std::map<std::string, std::str
 
     /* md5 hashing */
     for (vector<map<string, string> >::iterator it = credentials_.begin(); it != credentials_.end(); ++it) {
-        map<string, string>::const_iterator val = (*it).find(USERNAME);
+        map<string, string>::const_iterator val = (*it).find(CONFIG_ACCOUNT_USERNAME);
         const std::string username = val != (*it).end() ? val->second : "";
-        val = (*it).find(REALM);
+        val = (*it).find(CONFIG_ACCOUNT_REALM);
         const std::string realm(val != (*it).end() ? val->second : "");
-        val = (*it).find(PASSWORD);
+        val = (*it).find(CONFIG_ACCOUNT_PASSWORD);
         const std::string password(val != (*it).end() ? val->second : "");
 
         if (md5HashingEnabled) {
@@ -892,7 +900,7 @@ void SIPAccount::setCredentials(const std::vector<std::map<std::string, std::str
             // re-hash a hashed password.
 
             if (password.length() != 32)
-                (*it)[PASSWORD] = computeMd5HashFromCredential(username, password, realm);
+                (*it)[CONFIG_ACCOUNT_PASSWORD] = computeMd5HashFromCredential(username, password, realm);
         }
     }
 
@@ -904,20 +912,20 @@ void SIPAccount::setCredentials(const std::vector<std::map<std::string, std::str
 
     for (vector<map<string, string > >::const_iterator iter = credentials_.begin();
             iter != credentials_.end(); ++iter) {
-        map<string, string>::const_iterator val = (*iter).find(PASSWORD);
+        map<string, string>::const_iterator val = (*iter).find(CONFIG_ACCOUNT_PASSWORD);
         const std::string password = val != (*iter).end() ? val->second : "";
         int dataType = (md5HashingEnabled and password.length() == 32)
                        ? PJSIP_CRED_DATA_DIGEST
                        : PJSIP_CRED_DATA_PLAIN_PASSWD;
 
-        val = (*iter).find(USERNAME);
+        val = (*iter).find(CONFIG_ACCOUNT_USERNAME);
 
         if (val != (*iter).end())
             cred_[i].username = pj_str((char*) val->second.c_str());
 
         cred_[i].data = pj_str((char*) password.c_str());
 
-        val = (*iter).find(REALM);
+        val = (*iter).find(CONFIG_ACCOUNT_REALM);
 
         if (val != (*iter).end())
             cred_[i].realm = pj_str((char*) val->second.c_str());
@@ -947,18 +955,18 @@ std::map<std::string, std::string> SIPAccount::getIp2IpDetails() const
 {
     assert(accountID_ == IP2IP_PROFILE);
     std::map<std::string, std::string> ip2ipAccountDetails;
-    ip2ipAccountDetails[ACCOUNT_ID] = IP2IP_PROFILE;
-    ip2ipAccountDetails[SRTP_KEY_EXCHANGE] = srtpKeyExchange_;
-    ip2ipAccountDetails[SRTP_ENABLE] = srtpEnabled_ ? "true" : "false";
-    ip2ipAccountDetails[SRTP_RTP_FALLBACK] = srtpFallback_ ? "true" : "false";
-    ip2ipAccountDetails[ZRTP_DISPLAY_SAS] = zrtpDisplaySas_ ? "true" : "false";
-    ip2ipAccountDetails[ZRTP_HELLO_HASH] = zrtpHelloHash_ ? "true" : "false";
-    ip2ipAccountDetails[ZRTP_NOT_SUPP_WARNING] = zrtpNotSuppWarning_ ? "true" : "false";
-    ip2ipAccountDetails[ZRTP_DISPLAY_SAS_ONCE] = zrtpDisplaySasOnce_ ? "true" : "false";
-    ip2ipAccountDetails[LOCAL_INTERFACE] = interface_;
+    ip2ipAccountDetails[CONFIG_ACCOUNT_ID] = IP2IP_PROFILE;
+    ip2ipAccountDetails[CONFIG_SRTP_KEY_EXCHANGE] = srtpKeyExchange_;
+    ip2ipAccountDetails[CONFIG_SRTP_ENABLE] = srtpEnabled_ ? "true" : "false";
+    ip2ipAccountDetails[CONFIG_SRTP_RTP_FALLBACK] = srtpFallback_ ? "true" : "false";
+    ip2ipAccountDetails[CONFIG_ZRTP_DISPLAY_SAS] = zrtpDisplaySas_ ? "true" : "false";
+    ip2ipAccountDetails[CONFIG_ZRTP_HELLO_HASH] = zrtpHelloHash_ ? "true" : "false";
+    ip2ipAccountDetails[CONFIG_ZRTP_NOT_SUPP_WARNING] = zrtpNotSuppWarning_ ? "true" : "false";
+    ip2ipAccountDetails[CONFIG_ZRTP_DISPLAY_SAS_ONCE] = zrtpDisplaySasOnce_ ? "true" : "false";
+    ip2ipAccountDetails[CONFIG_LOCAL_INTERFACE] = interface_;
     std::stringstream portstr;
     portstr << localPort_;
-    ip2ipAccountDetails[LOCAL_PORT] = portstr.str();
+    ip2ipAccountDetails[CONFIG_LOCAL_PORT] = portstr.str();
 
     std::map<std::string, std::string> tlsSettings;
     tlsSettings = getTlsSettings();
@@ -975,20 +983,20 @@ std::map<std::string, std::string> SIPAccount::getTlsSettings() const
 
     std::stringstream portstr;
     portstr << tlsListenerPort_;
-    tlsSettings[TLS_LISTENER_PORT] = portstr.str();
-    tlsSettings[TLS_ENABLE] = tlsEnable_;
-    tlsSettings[TLS_CA_LIST_FILE] = tlsCaListFile_;
-    tlsSettings[TLS_CERTIFICATE_FILE] = tlsCertificateFile_;
-    tlsSettings[TLS_PRIVATE_KEY_FILE] = tlsPrivateKeyFile_;
-    tlsSettings[TLS_PASSWORD] = tlsPassword_;
-    tlsSettings[TLS_METHOD] = tlsMethod_;
-    tlsSettings[TLS_CIPHERS] = tlsCiphers_;
-    tlsSettings[TLS_SERVER_NAME] = tlsServerName_;
-    tlsSettings[TLS_VERIFY_SERVER] = tlsVerifyServer_ ? "true" : "false";
-    tlsSettings[TLS_VERIFY_CLIENT] = tlsVerifyClient_ ? "true" : "false";
-    tlsSettings[TLS_REQUIRE_CLIENT_CERTIFICATE] = tlsRequireClientCertificate_ ? "true" : "false";
-    tlsSettings[TLS_NEGOTIATION_TIMEOUT_SEC] = tlsNegotiationTimeoutSec_;
-    tlsSettings[TLS_NEGOTIATION_TIMEOUT_MSEC] = tlsNegotiationTimeoutMsec_;
+    tlsSettings[CONFIG_TLS_LISTENER_PORT] = portstr.str();
+    tlsSettings[CONFIG_TLS_ENABLE] = tlsEnable_;
+    tlsSettings[CONFIG_TLS_CA_LIST_FILE] = tlsCaListFile_;
+    tlsSettings[CONFIG_TLS_CERTIFICATE_FILE] = tlsCertificateFile_;
+    tlsSettings[CONFIG_TLS_PRIVATE_KEY_FILE] = tlsPrivateKeyFile_;
+    tlsSettings[CONFIG_TLS_PASSWORD] = tlsPassword_;
+    tlsSettings[CONFIG_TLS_METHOD] = tlsMethod_;
+    tlsSettings[CONFIG_TLS_CIPHERS] = tlsCiphers_;
+    tlsSettings[CONFIG_TLS_SERVER_NAME] = tlsServerName_;
+    tlsSettings[CONFIG_TLS_VERIFY_SERVER] = tlsVerifyServer_ ? "true" : "false";
+    tlsSettings[CONFIG_TLS_VERIFY_CLIENT] = tlsVerifyClient_ ? "true" : "false";
+    tlsSettings[CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE] = tlsRequireClientCertificate_ ? "true" : "false";
+    tlsSettings[CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC] = tlsNegotiationTimeoutSec_;
+    tlsSettings[CONFIG_TLS_NEGOTIATION_TIMEOUT_MSEC] = tlsNegotiationTimeoutMsec_;
 
     return tlsSettings;
 }
@@ -1022,19 +1030,19 @@ void set_opt(const std::map<std::string, std::string> &details, const char *key,
 void SIPAccount::setTlsSettings(const std::map<std::string, std::string>& details)
 {
     assert(accountID_ == IP2IP_PROFILE);
-    set_opt(details, TLS_LISTENER_PORT, tlsListenerPort_);
-    set_opt(details, TLS_ENABLE, tlsEnable_);
-    set_opt(details, TLS_CA_LIST_FILE, tlsCaListFile_);
-    set_opt(details, TLS_CERTIFICATE_FILE, tlsCertificateFile_);
-    set_opt(details, TLS_PRIVATE_KEY_FILE, tlsPrivateKeyFile_);
-    set_opt(details, TLS_PASSWORD, tlsPassword_);
-    set_opt(details, TLS_METHOD, tlsMethod_);
-    set_opt(details, TLS_CIPHERS, tlsCiphers_);
-    set_opt(details, TLS_SERVER_NAME, tlsServerName_);
-    set_opt(details, TLS_VERIFY_CLIENT, tlsVerifyClient_);
-    set_opt(details, TLS_REQUIRE_CLIENT_CERTIFICATE, tlsRequireClientCertificate_);
-    set_opt(details, TLS_NEGOTIATION_TIMEOUT_SEC, tlsNegotiationTimeoutSec_);
-    set_opt(details, TLS_NEGOTIATION_TIMEOUT_MSEC, tlsNegotiationTimeoutMsec_);
+    set_opt(details, CONFIG_TLS_LISTENER_PORT, tlsListenerPort_);
+    set_opt(details, CONFIG_TLS_ENABLE, tlsEnable_);
+    set_opt(details, CONFIG_TLS_CA_LIST_FILE, tlsCaListFile_);
+    set_opt(details, CONFIG_TLS_CERTIFICATE_FILE, tlsCertificateFile_);
+    set_opt(details, CONFIG_TLS_PRIVATE_KEY_FILE, tlsPrivateKeyFile_);
+    set_opt(details, CONFIG_TLS_PASSWORD, tlsPassword_);
+    set_opt(details, CONFIG_TLS_METHOD, tlsMethod_);
+    set_opt(details, CONFIG_TLS_CIPHERS, tlsCiphers_);
+    set_opt(details, CONFIG_TLS_SERVER_NAME, tlsServerName_);
+    set_opt(details, CONFIG_TLS_VERIFY_CLIENT, tlsVerifyClient_);
+    set_opt(details, CONFIG_TLS_REQUIRE_CLIENT_CERTIFICATE, tlsRequireClientCertificate_);
+    set_opt(details, CONFIG_TLS_NEGOTIATION_TIMEOUT_SEC, tlsNegotiationTimeoutSec_);
+    set_opt(details, CONFIG_TLS_NEGOTIATION_TIMEOUT_MSEC, tlsNegotiationTimeoutMsec_);
 }
 
 VoIPLink* SIPAccount::getVoIPLink()
diff --git a/daemon/src/sip/sipvoiplink.cpp b/daemon/src/sip/sipvoiplink.cpp
index 16dc0bf124ed79ca74e8a1c391cd593695695e0e..e943434d93fab8ecc8e50efd38a8261a41a159a0 100644
--- a/daemon/src/sip/sipvoiplink.cpp
+++ b/daemon/src/sip/sipvoiplink.cpp
@@ -655,6 +655,8 @@ void SIPVoIPLink::registerKeepAliveTimer(pj_timer_entry& timer, pj_time_val& del
 {
     pj_status_t status;
 
+    DEBUG("UserAgent: Registering keep alive timer");
+
     status = pjsip_endpt_schedule_timer(endpt_, &timer, &delay);
     if (status != PJ_SUCCESS)
         ERROR("Could not schedule new timer in pjsip endpoint");
diff --git a/gnome/src/config/accountconfigdialog.c b/gnome/src/config/accountconfigdialog.c
index ef55ea27cdb81afe93b780576a42d3f60aeb9af0..c6235957ad83ce9bfa297ecd9d9f292a07744c0a 100644
--- a/gnome/src/config/accountconfigdialog.c
+++ b/gnome/src/config/accountconfigdialog.c
@@ -834,11 +834,19 @@ static GtkWidget* create_registration_expire(account_t *a)
     GtkWidget *table, *frame, *label;
 
     gchar *resolve_once=NULL, *account_expire=NULL;
-
+    gchar *orig_key = NULL;
     if (a) {
-        resolve_once = g_hash_table_lookup(a->properties, ACCOUNT_RESOLVE_ONCE);
-        account_expire = g_hash_table_lookup(a->properties, ACCOUNT_REGISTRATION_EXPIRE);
+        gboolean gotkey = FALSE;
+        gotkey = g_hash_table_lookup_extended(a->properties, ACCOUNT_RESOLVE_ONCE, (gpointer)&orig_key, (gpointer)&resolve_once);
+        if(gotkey == FALSE) {
+            ERROR("could not retreive resolve_once from account properties");
+        } 
+        gotkey = g_hash_table_lookup_extended(a->properties, ACCOUNT_REGISTRATION_EXPIRE, (gpointer)&orig_key, (gpointer)&account_expire);
+        if(gotkey == FALSE) {
+            ERROR("could not retreive %s from account properties", ACCOUNT_REGISTRATION_EXPIRE);
+        }
     }
+    
 
     gnome_main_section_new_with_table(_("Registration"), &frame, &table, 2, 3);
     gtk_container_set_border_width(GTK_CONTAINER(table), 10);
@@ -852,7 +860,6 @@ static GtkWidget* create_registration_expire(account_t *a)
     gtk_spin_button_set_value(GTK_SPIN_BUTTON(expireSpinBox), g_ascii_strtod(account_expire, NULL));
     gtk_table_attach_defaults(GTK_TABLE(table), expireSpinBox, 1, 2, 0, 1);
 
-
     entryResolveNameOnlyOnce = gtk_check_button_new_with_mnemonic(_("_Comply with RFC 3263"));
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(entryResolveNameOnlyOnce),
                                  g_strcasecmp(resolve_once,"false") == 0 ? TRUE: FALSE);
diff --git a/gnome/src/sflphone_const.h b/gnome/src/sflphone_const.h
index fd7cec91d20a169620047955d07a11c3451d739d..3766562a008cfa4fe6d2534ffd97808d42f5d5de 100644
--- a/gnome/src/sflphone_const.h
+++ b/gnome/src/sflphone_const.h
@@ -62,17 +62,17 @@
 #define ACCOUNT_ALIAS		           "Account.alias"
 #define ACCOUNT_ENABLED		           "Account.enable"
 #define ACCOUNT_MAILBOX		           "Account.mailbox"
-#define ACCOUNT_USERAGENT	           "useragent"
+#define ACCOUNT_USERAGENT	           "Account.useragent"
 #define ACCOUNT_RESOLVE_ONCE               "Account.resolveOnce"
-#define ACCOUNT_REGISTRATION_EXPIRE        "Account.expire"
+#define ACCOUNT_REGISTRATION_EXPIRE        "Account.registrationExpire"
 #define ACCOUNT_SIP_STUN_SERVER	           "STUN.server"
 #define ACCOUNT_SIP_STUN_ENABLED           "STUN.enable"
 #define ACCOUNT_DTMF_TYPE                  "Account.dtmfType"
-#define ACCOUNT_HOSTNAME                   "hostname"
-#define ACCOUNT_USERNAME                   "username"
-#define ACCOUNT_ROUTE                      "routeset"
-#define ACCOUNT_PASSWORD                   "password"
-#define ACCOUNT_REALM                      "realm"
+#define ACCOUNT_HOSTNAME                   "Account.hostname"
+#define ACCOUNT_USERNAME                   "Account.username"
+#define ACCOUNT_ROUTE                      "Account.routeset"
+#define ACCOUNT_PASSWORD                   "Account.password"
+#define ACCOUNT_REALM                      "Account.realm"
 #define ACCOUNT_KEY_EXCHANGE               "SRTP.keyExchange"
 #define ACCOUNT_SRTP_ENABLED               "SRTP.enable"
 #define ACCOUNT_SRTP_RTP_FALLBACK          "SRTP.rtpFallback"
@@ -109,7 +109,7 @@
 #define PUBLISHED_PORT                      "Account.publishedPort"
 #define PUBLISHED_ADDRESS                   "Account.publishedAddress"
 
-#define REGISTRATION_STATUS                 "Status"
+#define REGISTRATION_STATUS                 "Registration.Status"
 #define REGISTRATION_STATE_CODE             "Registration.code"
 #define REGISTRATION_STATE_DESCRIPTION      "Registration.description"