diff --git a/sflphone-common/src/sip/sipaccount.cpp b/sflphone-common/src/sip/sipaccount.cpp
index 04d647c9c80f4e912fb59a5d244ee929cbb29773..f63fd0bfff073098e79556fcc172a95a8767b1ab 100644
--- a/sflphone-common/src/sip/sipaccount.cpp
+++ b/sflphone-common/src/sip/sipaccount.cpp
@@ -252,17 +252,13 @@ bool SIPAccount::hostnameMatch (const std::string& hostname)
     return (hostname == getHostname());
 }
 
-pj_str_t SIPAccount::getFromUri(void) 
+std::string SIPAccount::getFromUri(void) 
 {
     char uri[PJSIP_MAX_URL_SIZE];
-    const char * beginquote, * endquote;
     
     std::string scheme;
     std::string transport;
     
-    // if IPV6, should be set to []
-    beginquote = endquote = "";
-    
     // UDP does not require the transport specification
     if (_transportType != PJSIP_TRANSPORT_UDP) {
         scheme = "sips";
@@ -271,20 +267,17 @@ pj_str_t SIPAccount::getFromUri(void)
         scheme = "sip";
     }
     
-    pj_ansi_snprintf(uri, PJSIP_MAX_URL_SIZE, 
-                     "<%s:%s%s%s%s:%s%s>",
+    int len = pj_ansi_snprintf(uri, PJSIP_MAX_URL_SIZE, 
+                     "<%s:%s@%s%s>",
                      scheme.c_str(), 
-                     beginquote,
                      _username.c_str(),
                      _hostname.c_str(),
-                     endquote,
-                     _port.c_str(),
                      transport.c_str());  
                      
-    return pj_str(uri);
+    return std::string(uri, len);
 }
 
-pj_str_t SIPAccount::getToUri(const std::string& username) 
+std::string SIPAccount::getToUri(const std::string& username) 
 {
     char uri[PJSIP_MAX_URL_SIZE];
     
@@ -299,17 +292,17 @@ pj_str_t SIPAccount::getToUri(const std::string& username)
         scheme = "sip";
     }
     
-    pj_ansi_snprintf(uri, PJSIP_MAX_URL_SIZE, 
+    int len = pj_ansi_snprintf(uri, PJSIP_MAX_URL_SIZE, 
                      "<%s:%s@%s%s>",
                      scheme.c_str(), 
                      username.c_str(),
                      _hostname.c_str(),
                      transport.c_str());  
                      
-    return pj_str(uri);
+    return std::string(uri, len);
 }
 
-pj_str_t SIPAccount::getServerUri(void) 
+std::string SIPAccount::getServerUri(void) 
 {
     char uri[PJSIP_MAX_URL_SIZE];
     
@@ -324,16 +317,16 @@ pj_str_t SIPAccount::getServerUri(void)
         scheme = "sip";
     }
     
-    pj_ansi_snprintf(uri, PJSIP_MAX_URL_SIZE, 
+    int len = pj_ansi_snprintf(uri, PJSIP_MAX_URL_SIZE, 
                      "<%s:%s%s>",
                      scheme.c_str(), 
                      _hostname.c_str(),
                      transport.c_str());  
                      
-    return pj_str(uri);
+    return std::string(uri, len);
 }
 
-pj_str_t SIPAccount::getContactHeader(const std::string& address, const std::string& port)
+std::string SIPAccount::getContactHeader(const std::string& address, const std::string& port)
 {
     char contact[PJSIP_MAX_URL_SIZE];
     const char * beginquote, * endquote;
@@ -351,7 +344,7 @@ pj_str_t SIPAccount::getContactHeader(const std::string& address, const std::str
         scheme = "sip";
     }
     
-    pj_ansi_snprintf(contact, PJSIP_MAX_URL_SIZE,
+    int len = pj_ansi_snprintf(contact, PJSIP_MAX_URL_SIZE,
                     "%s%s<%s:%s%s%s%s%s:%d%s>",
                     _displayName.c_str(),
                     (_displayName.empty() ? "" : " "),
@@ -364,7 +357,7 @@ pj_str_t SIPAccount::getContactHeader(const std::string& address, const std::str
                     atoi(port.c_str()),
                     transport.c_str());
                     
-    return pj_str(contact);
+    return std::string(contact, len);
 }
 
 
diff --git a/sflphone-common/src/sip/sipaccount.h b/sflphone-common/src/sip/sipaccount.h
index c493b0ee3f40f065508df7b0979b51254d340ea3..aee8c0e4badbbe372a9377183e2ecc4d160c29b4 100644
--- a/sflphone-common/src/sip/sipaccount.h
+++ b/sflphone-common/src/sip/sipaccount.h
@@ -109,7 +109,7 @@ class SIPAccount : public Account
          * of the host on which the UA is running, since these are not logical
          * names."
          */
-        pj_str_t getFromUri(void);
+        std::string getFromUri(void);
         
         /*
          * This method adds the correct scheme, hostname and append
@@ -119,7 +119,7 @@ class SIPAccount : public Account
          * @return pj_str_t "To" uri based on @param username
          * @param username A string formatted as : "username"
          */
-        pj_str_t getToUri(const std::string& username);
+        std::string getToUri(const std::string& username);
 
         /*
          * In the current version of SFLPhone, "srv" uri is obtained in the preformated 
@@ -129,14 +129,14 @@ class SIPAccount : public Account
          * @return pj_str_t "server" uri based on @param hostPort
          * @param hostPort A string formatted as : "hostname:port"
          */
-        pj_str_t getServerUri(void);
+        std::string getServerUri(void);
                
         /*
          * @param port Optional port. Otherwise set to the port defined for that account.
          * @param hostname Optional local address. Otherwise set to the hostname defined for that account.
          * @return pj_str_t The contact header based on account information
          */
-        pj_str_t getContactHeader(const std::string& address, const std::string& port);
+        std::string getContactHeader(const std::string& address, const std::string& port);
         
     private:
         /* Maps a string description of the SSL method 
diff --git a/sflphone-common/src/sip/sipvoiplink.cpp b/sflphone-common/src/sip/sipvoiplink.cpp
index a7ab83c9f689d801fc2811e17cc52920a7f842bf..e7587790ed55ff4c4f822e76dddc8e6f0a7e3c70 100644
--- a/sflphone-common/src/sip/sipvoiplink.cpp
+++ b/sflphone-common/src/sip/sipvoiplink.cpp
@@ -464,31 +464,38 @@ int SIPVoIPLink::sendRegister (AccountID id)
     }
 
     // Creates URI
-    pj_str_t fromUri;
-    pj_str_t contactUri;
-    pj_str_t srvUri;
-    
+    std::string fromUri;
+    std::string contactUri;
+    std::string srvUri;
+    std::string address;
+       
     fromUri = account->getFromUri();
     srvUri = account->getServerUri();
-    
-    pj_str_t address = findLocalAddressFromUri(&srvUri);
-    int port = findLocalPortFromUri(&srvUri);
+    address = findLocalAddressFromUri(srvUri);
+          
+    int port = findLocalPortFromUri(srvUri);
     std::stringstream ss;
     std::string portStr;
     ss << port;
     ss >> portStr;
-    contactUri = account->getContactHeader(std::string(address.ptr, address.slen), portStr);
+    contactUri = account->getContactHeader(address, portStr);
+ 
+    _debug("sendRegister: fromUri: %s serverUri: %s contactUri: %s\n",
+            fromUri.c_str(),
+            srvUri.c_str(),
+            contactUri.c_str());
     
-    _debug("sendRegister: fromUri: %.*s serverUri: %.*s contactUri: %.*s\n",
-            (int)fromUri.slen,
-            fromUri.ptr,
-            (int)srvUri.slen,
-            srvUri.ptr,
-            (int)contactUri.slen,
-            contactUri.ptr);
+    pj_str_t pjFrom;
+    pj_cstr(&pjFrom, fromUri.c_str());
+    
+    pj_str_t pjContact;
+    pj_cstr(&pjContact, contactUri.c_str());
+    
+    pj_str_t pjSrv; 
+    pj_cstr(&pjSrv, srvUri.c_str());
                   
     // Initializes registration 
-    status = pjsip_regc_init (regc, &srvUri, &fromUri, &fromUri, 1, &contactUri, expire_value);   
+    status = pjsip_regc_init (regc, &pjSrv, &pjFrom, &pjFrom, 1, &pjContact, expire_value);   
 
     if (status != PJ_SUCCESS) {
         _debug ("UserAgent: Unable to initialize regc. %d\n", status);
@@ -596,8 +603,8 @@ SIPVoIPLink::newOutgoingCall (const CallID& id, const std::string& toUrl)
             return call;
         }
 
-        pj_str_t toUri = account->getToUri(toUrl);
-        call->setPeerNumber(std::string(toUri.ptr, toUri.slen));
+        std::string toUri = account->getToUri(toUrl);
+        call->setPeerNumber(toUri);
 
         setCallAudioLocal (call, getLocalIPAddress(), useStun(), getStunServer());
 
@@ -921,10 +928,8 @@ SIPVoIPLink::transfer (const CallID& id, const std::string& to)
     std::string tmp_to;
     pjsip_evsub *sub;
     pjsip_tx_data *tdata;
-
     struct pjsip_evsub_user xfer_cb;
     pj_status_t status;
-    pj_str_t dest;
     AccountID account_id;
     SIPAccount * account = NULL;
 
@@ -943,11 +948,14 @@ SIPVoIPLink::transfer (const CallID& id, const std::string& to)
         return false;
     }
 
+    std::string dest;
+    pj_str_t pjDest;
     if (to.find ("@") == std::string::npos) {
-        dest = account->getToUri(to);            
+        dest = account->getToUri(to);   
+        pj_cstr(&pjDest, dest.c_str());      
     }
 
-    _debug ("Transfering to %.*s\n", (int)dest.slen, dest.ptr);
+    _debug ("Transfering to %s\n", dest.c_str());
 
     /* Create xfer client subscription. */
     pj_bzero (&xfer_cb, sizeof (xfer_cb));
@@ -972,7 +980,7 @@ SIPVoIPLink::transfer (const CallID& id, const std::string& to)
     /*
      * Create REFER request.
      */
-    status = pjsip_xfer_initiate (sub, &dest, &tdata);
+    status = pjsip_xfer_initiate (sub, &pjDest, &tdata);
 
     if (status != PJ_SUCCESS) {
         _debug ("UserAgent: Unable to create REFER request -- %d\n", status);
@@ -1177,30 +1185,39 @@ SIPVoIPLink::SIPStartCall (SIPCall* call, const std::string& subject UNUSED)
     }
     
     // Creates URI
-    pj_str_t fromUri, toUri, contactUri;
+    std::string fromUri;
+    std::string toUri;
+    std::string contactUri;
+    
     fromUri = account->getFromUri();
-    toUri = account->getToUri(call->getPeerNumber()); // expecting number@hostname
+    toUri = call->getPeerNumber(); // expecting a fully well formed sip uri
         
-    pj_str_t address = findLocalAddressFromUri(&toUri);
-    int port = findLocalPortFromUri(&toUri);
+    std::string address = findLocalAddressFromUri(toUri);
+    int port = findLocalPortFromUri(toUri);
     std::stringstream ss;
     std::string portStr;
     ss << port;
     ss >> portStr;
-    contactUri = account->getContactHeader(std::string(address.ptr, address.slen), portStr);
+    contactUri = account->getContactHeader(address, portStr);
     
-    _debug("SIPStartCall: fromUri: %.*s toUri: %.*s contactUri: %.*s\n",
-            (int)fromUri.slen,
-            fromUri.ptr,
-            (int)toUri.slen,
-            toUri.ptr,
-            (int)contactUri.slen,
-            contactUri.ptr);
-            
+    _debug("SIPStartCall: fromUri: %s toUri: %s contactUri: %s\n",
+            fromUri.c_str(),
+            toUri.c_str(),
+            contactUri.c_str());
+     
+    pj_str_t pjFrom;
+    pj_cstr(&pjFrom, fromUri.c_str());     
+
+    pj_str_t pjContact;
+    pj_cstr(&pjContact, contactUri.c_str());
+
+    pj_str_t pjTo;
+    pj_cstr(&pjTo, toUri.c_str());
+           
     // Create the dialog (UAC)
-    status = pjsip_dlg_create_uac (pjsip_ua_instance(), &fromUri,
-                                   &contactUri,
-                                   &toUri,
+    status = pjsip_dlg_create_uac (pjsip_ua_instance(), &pjFrom,
+                                   &pjContact,
+                                   &pjTo,
                                    NULL,
                                    &dialog);
 
@@ -1351,7 +1368,6 @@ bool SIPVoIPLink::new_ip_to_ip_call (const CallID& id, const std::string& to)
     call = new SIPCall (id, Call::Outgoing, _pool);
 
     if (call) {
-
         call->setCallConfiguration (Call::IPtoIP);
         setCallAudioLocal (call, getLocalIPAddress(), useStun(), getStunServer());
         call->initRecFileName();
@@ -1363,8 +1379,8 @@ bool SIPVoIPLink::new_ip_to_ip_call (const CallID& id, const std::string& to)
             return !PJ_SUCCESS;
         }
     
-        pj_str_t toUri = account->getToUri(to);
-        call->setPeerNumber(std::string(toUri.ptr, toUri.slen));
+        std::string toUri = account->getToUri(to);
+        call->setPeerNumber(toUri);
 
         // Building the local SDP offer
         call->getLocalSDP()->set_ip_address (getLocalIP());
@@ -1376,28 +1392,36 @@ bool SIPVoIPLink::new_ip_to_ip_call (const CallID& id, const std::string& to)
             _debug ("! SIP Failure: Unable to create RTP Session  in SIPVoIPLink::new_ip_to_ip_call (%s:%d)\n", __FILE__, __LINE__);
         }
         
-        pj_str_t fromUri, contactUri;
+        // Create URI
+        std::string fromUri;
+        std::string contactUri;
         fromUri = account->getFromUri();
         
-        pj_str_t address = findLocalAddressFromUri(&toUri);
-        int port = findLocalPortFromUri(&toUri);
+        std::string address = findLocalAddressFromUri(toUri);
+        int port = findLocalPortFromUri(toUri);
         std::stringstream ss;
         std::string portStr;
         ss << port;
         ss >> portStr;
-        contactUri = account->getContactHeader(std::string(address.ptr, address.slen), portStr);
+        contactUri = account->getContactHeader(address, portStr);
         
-        _debug("New_ip_to_ip_call: fromUri: %.*s toUri: %.*s contactUri: %.*s\n",
-                (int)fromUri.slen,
-                fromUri.ptr,
-                (int)toUri.slen,
-                toUri.ptr,
-                (int)contactUri.slen,
-                contactUri.ptr);
-                
+        _debug("new_ip_to_ip_call: fromUri: %s toUri: %s contactUri: %s\n",
+                fromUri.c_str(),
+                toUri.c_str(),
+                contactUri.c_str());
+        
+        pj_str_t pjFrom;
+        pj_cstr(&pjFrom, fromUri.c_str());
 
-        // create the dialog (UAC)
-        status = pjsip_dlg_create_uac (pjsip_ua_instance(), &fromUri, &contactUri, &toUri, NULL, &dialog);
+        pj_str_t pjTo;
+        pj_cstr(&pjTo, toUri.c_str());
+
+        pj_str_t pjContact;
+        pj_cstr(&pjContact, contactUri.c_str());
+                
+        // Create the dialog (UAC)
+        // (Parameters are "strduped" inside the function)
+        status = pjsip_dlg_create_uac (pjsip_ua_instance(), &pjFrom, &pjContact, &pjTo, NULL, &dialog);
 
         PJ_ASSERT_RETURN (status == PJ_SUCCESS, false);
 
@@ -1780,22 +1804,31 @@ int SIPVoIPLink::createUDPServer (void)
     return PJ_SUCCESS;
 }
 
-pj_str_t SIPVoIPLink::findLocalAddressFromUri(const pj_str_t * uri)
+std::string SIPVoIPLink::findLocalAddressFromUri(const std::string& uri)
 {
     pj_str_t localAddress;
     pjsip_transport_type_e transportType;
 
     // Find the transport that must be used with the given uri
     pj_str_t tmp;
-    pj_strdup_with_null(_pool, &tmp, uri);
-    pjsip_uri * genericUri;
+    pj_strdup2_with_null(_pool, &tmp, uri.c_str());
+    pjsip_uri * genericUri = NULL;
     genericUri = pjsip_parse_uri(_pool, tmp.ptr, tmp.slen, 0);
+
+    pj_str_t pjMachineName;
+    pj_strdup(_pool, &pjMachineName, pj_gethostname());
+    std::string machineName(pjMachineName.ptr, pjMachineName.slen);
+    
+    if (genericUri == NULL) {
+        _debug("genericUri is NULL in findLocalPortFromUri\n");
+        return machineName;        
+    }
     
     pjsip_sip_uri * sip_uri = NULL;
     sip_uri = (pjsip_sip_uri*)pjsip_uri_get_uri(genericUri);  
     if (sip_uri == NULL) {
         _debug("Invalid uri in findLocalAddressFromTransport\n");
-        return *pj_gethostname();
+        return machineName;
     }
  
     if (PJSIP_URI_SCHEME_IS_SIPS(sip_uri)) {
@@ -1808,9 +1841,9 @@ pj_str_t SIPVoIPLink::findLocalAddressFromUri(const pj_str_t * uri)
     // this endpoint
     pjsip_tpmgr * tpmgr = NULL;
     tpmgr = pjsip_endpt_get_tpmgr(_endpt);
-    if (tpmgr) {
+    if (tpmgr == NULL) {
         _debug("Unexpected: Cannot get tpmgr from endpoint.\n");
-        return *pj_gethostname();
+        return machineName;
     }
   
     // Find the local address (and port) based on the registered
@@ -1820,13 +1853,13 @@ pj_str_t SIPVoIPLink::findLocalAddressFromUri(const pj_str_t * uri)
     status = pjsip_tpmgr_find_local_addr(tpmgr, _pool, transportType, NULL, &localAddress, &port);
     if (status != PJ_SUCCESS) {
         _debug("Failed to find local address from transport\n");
-        return *pj_gethostname();
+        return machineName;        
     }	
     
-    return localAddress;
+    return std::string(localAddress.ptr, localAddress.slen);
 }
 
-int SIPVoIPLink::findLocalPortFromUri(const pj_str_t * uri)
+int SIPVoIPLink::findLocalPortFromUri(const std::string& uri)
 {
     pj_str_t localAddress;
     pjsip_transport_type_e transportType;
@@ -1834,17 +1867,21 @@ int SIPVoIPLink::findLocalPortFromUri(const pj_str_t * uri)
     
     // Find the transport that must be used with the given uri
     pj_str_t tmp;
-    pj_strdup_with_null(_pool, &tmp, uri);
-    pjsip_uri * genericUri;
+    pj_strdup2_with_null(_pool, &tmp, uri.c_str());
+    pjsip_uri * genericUri = NULL;
     genericUri = pjsip_parse_uri(_pool, tmp.ptr, tmp.slen, 0);
-    
+    if (genericUri == NULL) {
+        _debug("genericUri is NULL in findLocalPortFromUri\n");
+        return atoi(DEFAULT_SIP_PORT);        
+    }
+
     pjsip_sip_uri * sip_uri = NULL;
     sip_uri = (pjsip_sip_uri*)pjsip_uri_get_uri(genericUri);  
     if (sip_uri == NULL) {
         _debug("Invalid uri in findLocalAddressFromTransport\n");
         return atoi(DEFAULT_SIP_PORT);
     }
- 
+    
     if (PJSIP_URI_SCHEME_IS_SIPS(sip_uri)) {
         transportType = PJSIP_TRANSPORT_TLS;
         port = atoi(DEFAULT_SIP_TLS_PORT);
@@ -1857,7 +1894,7 @@ int SIPVoIPLink::findLocalPortFromUri(const pj_str_t * uri)
     // this endpoint
     pjsip_tpmgr * tpmgr = NULL;
     tpmgr = pjsip_endpt_get_tpmgr(_endpt);
-    if (tpmgr) {
+    if (tpmgr == NULL) {
         _debug("Unexpected: Cannot get tpmgr from endpoint.\n");
         return port;
     }
diff --git a/sflphone-common/src/sip/sipvoiplink.h b/sflphone-common/src/sip/sipvoiplink.h
index 68ce2ce433f8ebd3bc13d9c0c91f7170c9501d3a..14311d65bbc497644d4cf8ddc20b3cce9c8c249e 100644
--- a/sflphone-common/src/sip/sipvoiplink.h
+++ b/sflphone-common/src/sip/sipvoiplink.h
@@ -382,14 +382,14 @@ class SIPVoIPLink : public VoIPLink
          * @param uri The uri from which we want to discover the address to use
          * @return pj_str_t The extern (public) address
          */
-        pj_str_t findLocalAddressFromUri(const pj_str_t * uri);
+        std::string findLocalAddressFromUri(const std::string& uri);
         
         /* 
          * Does the same as findLocalAddressFromUri but returns a port.
          * @param uri The uri from which we want to discover the address to use
          * @return int The extern (public) port
          */
-        int findLocalPortFromUri(const pj_str_t * uri);
+        int findLocalPortFromUri(const std::string& uri);
 };