diff --git a/sipsimple/core/_core.helper.pxi b/sipsimple/core/_core.helper.pxi
index 7eb9d9f7..21184dd9 100644
--- a/sipsimple/core/_core.helper.pxi
+++ b/sipsimple/core/_core.helper.pxi
@@ -1,356 +1,355 @@
 
 import re
 import urllib
 
 
 # Classes
 #
 
 cdef class BaseCredentials:
     def __cinit__(self, *args, **kwargs):
         global _Credentials_scheme_digest, _Credentials_realm_wildcard
         self._credentials.scheme = _Credentials_scheme_digest.pj_str
 
     def __init__(self, object username not None, object password not None, object realm=b'*', bint digest=False):
         if self.__class__ is BaseCredentials:
             raise TypeError("BaseCredentials cannot be instantiated directly")
         self.username = username
         self.realm = realm
         self.password = password
         self.digest = digest
 
     def __repr__(self):
         return "%s(username=%r, password=%r, realm=%r, digest=%r)" % (self.__class__.__name__, self.username, self.password, self.realm, self.digest)
 
     def __str__(self):
         return '<%s for "%s@%s">' % (self.__class__.__name__, self.username, self.realm)
 
     cdef pjsip_cred_info* get_cred_info(self):
         return &self._credentials
 
 
 cdef class Credentials(BaseCredentials):
     property username:
         def __get__(self):
             return self._username
 
         def __set__(self, object username not None):
             _str_to_pj_str(username, &self._credentials.username)
             self._username = username
 
     property realm:
         def __get__(self):
             return self._realm
 
         def __set__(self, object realm not None):
             _str_to_pj_str(realm, &self._credentials.realm)
             self._realm = realm
 
     property password:
         def __get__(self):
             return self._password
 
         def __set__(self, object password not None):
             _str_to_pj_str(password, &self._credentials.data)
             self._password = password
 
     property digest:
         def __get__(self):
             return self._digest
 
         def __set__(self, bint digest):
             self._credentials.data_type = PJSIP_CRED_DATA_DIGEST if digest else PJSIP_CRED_DATA_PLAIN_PASSWD
             self._digest = digest
 
     @classmethod
     def new(cls, BaseCredentials credentials):
         return cls(credentials.username, credentials.password, credentials.realm, credentials.digest)
 
 
 cdef class FrozenCredentials(BaseCredentials):
     def __init__(self, object username not None, object password not None, object realm=b'*', bint digest=False):
         if not self.initialized:
             self.username = username
             self.realm = realm
             self.password = password
             self.digest = digest
             _str_to_pj_str(self.username, &self._credentials.username)
             _str_to_pj_str(self.realm, &self._credentials.realm)
             _str_to_pj_str(self.password, &self._credentials.data)
             self._credentials.data_type = PJSIP_CRED_DATA_DIGEST if digest else PJSIP_CRED_DATA_PLAIN_PASSWD
             self.initialized = 1
         else:
             raise TypeError("{0.__class__.__name__} is read-only".format(self))
 
     def __hash__(self):
         return hash((self.username, self.realm, self.password, self.digest))
 
     @classmethod
     def new(cls, BaseCredentials credentials):
         if isinstance(credentials, FrozenCredentials):
             return credentials
         return cls(credentials.username, credentials.password, credentials.realm, credentials.digest)
 
 
 cdef class BaseSIPURI:
     def __init__(self, object host not None, object user=None, object password=None, object port=None, bint secure=False, dict parameters=None, dict headers=None):
         if self.__class__ is BaseSIPURI:
             raise TypeError("BaseSIPURI cannot be instantiated directly")
         self.host = host.encode() if isinstance(host, str) else host
         self.user = user.encode() if user and isinstance(user, str) else user
         self.password = password.encode() if password else None
         self.port = port
         self.secure = secure
         self.parameters = parameters if parameters is not None else {}
         self.headers = headers if headers is not None else {}
 
     property transport:
         def __get__(self):
             return self.parameters.get('transport', b'udp')
 
         def __set__(self, object transport not None):
-            print('Set BaseSIPURI transport to %s' % transport)
             if transport.decode().lower() == 'udp':
                 self.parameters.pop('transport', None)
             else:
                 self.parameters['transport'] = transport.encode()
 
     def __reduce__(self):
         return self.__class__, (self.host, self.user, self.password, self.port, self.secure, self.parameters, self.headers), None
 
     def __repr__(self):
         return "%s(%r, %r, %r, %r, %r, %r, %r)" % (self.__class__.__name__, self.host, self.user, self.password, self.port, self.secure, self.parameters, self.headers)
 
     def __str__(self):
         cdef object string = self.host.decode() if isinstance(self.host, bytes) else self.host
 
         if self.port:
             string = "%s:%d" % (string, self.port)
 
         if self.user is not None:
             if self.password is not None:
                 string = "%s:%s@%s" % (self.user.decode() if isinstance(self.user, bytes) else self.user, self.password.decode() if isinstance(self.password, bytes) else self.password, string)
             else:
                 string = "%s@%s" % (self.user.decode() if isinstance(self.user, bytes) else self.user, string)
 
         if self.parameters:
             string += ";" + ";".join(["%s%s" % (name, ("" if val is None else "="+urllib.parse.quote(val, safe="()[]-_.!~*'/:&+$")))
                                       for name, val in list(self.parameters.items())])
         if self.headers:
             string += "?" + "&".join(["%s%s" % (name, ("" if val is None else "="+urllib.parse.quote(val, safe="()[]-_.!~*'/:?+$")))
                                       for name, val in self.headers.items()])
         if self.secure:
             string = "sips:" + string
         else:
             string = "sip:" + string
         return string
 
     def __richcmp__(self, other, op):
         if not isinstance(other, BaseSIPURI):
             return NotImplemented
         if op == 2:    # 2 is ==
             return all(getattr(self, name) == getattr(other, name) for name in ("user", "password", "host", "port", "secure", "parameters", "headers"))
         elif op == 3:  # 3 is !=
             return any(getattr(self, name) != getattr(other, name) for name in ("user", "password", "host", "port", "secure", "parameters", "headers"))
         else:
             operator_map = {0: '<', 1: '<=', 2: '==', 3: '!=', 4: '>', 5: '>='}
             raise TypeError("unorderable types: {0.__class__.__name__}() {2} {1.__class__.__name__}()".format(self, other, operator_map[op]))
 
     def matches(self, address):
         address = address.decode() if isinstance(address, bytes) else address
         match = re.match(r'^((?P<scheme>sip|sips):)?(?P<username>.+?)(@(?P<domain>.+?)(:(?P<port>\d+?))?)?(;(?P<parameters>.+?))?(\?(?P<headers>.+?))?$', address)
         if match is None:
             return False
         components = match.groupdict()
         if components['scheme'] is not None:
             expected_scheme = 'sips' if self.secure else 'sip'
             if components['scheme'] != expected_scheme:
                 return False
         user = self.user.decode() if self.user else None
         if components['username'] != user:
             return False
         if components['domain'] is not None and components['domain'] != self.host.decode():
             return False
         if components['port'] is not None and int(components['port']) != self.port:
             return False
         if components['parameters']:
             parameters = dict([(name, value) for name, sep, value in [param.partition('=') for param in components['parameters'].split(';')]])
             expected_parameters = dict([(name, str(value) if value is not None else None) for name, value in list(self.parameters.items()) if name in parameters])
             if parameters != expected_parameters:
                 return False
         if components['headers']:
             headers = dict([(name, value) for name, sep, value in [header.partition('=') for header in components['headers'].split('&')]])
             expected_headers = dict([(name, str(value) if value is not None else None) for name, value in self.headers.items() if name in headers])
             if headers != expected_headers:
                 return False
         return True
 
 
 cdef class SIPURI(BaseSIPURI):
     property port:
         def __get__(self):
             return self._port
 
         def __set__(self, object port):
             if port is not None:
                 port = int(port)
                 if not (0 < port <= 65535):
                     raise ValueError("Invalid port: %d" % port)
             self._port = port
 
     @classmethod
     def new(cls, BaseSIPURI sipuri):
         return cls(user=sipuri.user, password=sipuri.password, host=sipuri.host, port=sipuri.port, secure=sipuri.secure, parameters=dict(sipuri.parameters), headers=dict(sipuri.headers))
 
     @classmethod
     def parse(cls, object uri_str):
         cdef bytes uri_bytes = uri_str.encode() if isinstance(uri_str, str) else uri_str
         cdef pjsip_uri *uri = NULL
         cdef pj_pool_t *pool = NULL
         cdef pj_str_t tmp
         cdef char buffer[4096]
         pool = pj_pool_create_on_buf("SIPURI_parse", buffer, sizeof(buffer))
         if pool == NULL:
             raise SIPCoreError("Could not allocate memory pool")
         pj_strdup2_with_null(pool, &tmp, uri_bytes)
         uri = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0)
         if uri == NULL:
             raise SIPCoreError("Not a valid SIP URI: %s" % uri_str)
         return SIPURI_create(<pjsip_sip_uri *>pjsip_uri_get_uri(uri))
 
 
 cdef class FrozenSIPURI(BaseSIPURI):
     def __init__(self, object host not None, object user=None, object password=None, object port=None, bint secure=False, frozendict parameters not None=frozendict(), frozendict headers not None=frozendict()):
         if not self.initialized:
             if port is not None:
                 port = int(port)
                 if not (0 < port <= 65535):
                     raise ValueError("Invalid port: %d" % port)
             self.host = host
             self.user = user
             self.password = password
             self.port = port
             self.secure = secure
             self.parameters = parameters
             self.headers = headers
             self.initialized = 1
         else:
             raise TypeError("{0.__class__.__name__} is read-only".format(self))
 
     property transport:
         def __get__(self):
             return self.parameters.get('transport', 'udp')
 
     def __hash__(self):
         return hash((self.user, self.password, self.host, self.port, self.secure, self.parameters, self.headers))
 
     def __richcmp__(self, other, op):  # since we define __hash__, __richcmp__ is not inherited (see https://docs.python.org/2/c-api/typeobj.html#c.PyTypeObject.tp_richcompare)
         if not isinstance(other, BaseSIPURI):
             return NotImplemented
         if op == 2:    # 2 is ==
             return all(getattr(self, name) == getattr(other, name) for name in ("user", "password", "host", "port", "secure", "parameters", "headers"))
         elif op == 3:  # 3 is !=
             return any(getattr(self, name) != getattr(other, name) for name in ("user", "password", "host", "port", "secure", "parameters", "headers"))
         else:
             operator_map = {0: '<', 1: '<=', 2: '==', 3: '!=', 4: '>', 5: '>='}
             raise TypeError("unorderable types: {0.__class__.__name__}() {2} {1.__class__.__name__}()".format(self, other, operator_map[op]))
 
     @classmethod
     def new(cls, BaseSIPURI sipuri):
         if isinstance(sipuri, FrozenSIPURI):
             return sipuri
         return cls(user=sipuri.user, password=sipuri.password, host=sipuri.host, port=sipuri.port, secure=sipuri.secure, parameters=frozendict(sipuri.parameters), headers=frozendict(sipuri.headers))
 
     @classmethod
     def parse(cls, object uri_str):
         cdef bytes uri_bytes = uri_str.encode() if isinstance(uri_str, str) else uri_str
         cdef pjsip_uri *uri = NULL
         cdef pj_pool_t *pool = NULL
         cdef pj_str_t tmp
         cdef char buffer[4096]
         pool = pj_pool_create_on_buf("FrozenSIPURI_parse", buffer, sizeof(buffer))
         if pool == NULL:
             raise SIPCoreError("Could not allocate memory pool")
         pj_strdup2_with_null(pool, &tmp, uri_bytes)
         uri = pjsip_parse_uri(pool, tmp.ptr, tmp.slen, 0)
         if uri == NULL:
             raise SIPCoreError("Not a valid SIP URI: %s" % uri_str)
         return FrozenSIPURI_create(<pjsip_sip_uri *>pjsip_uri_get_uri(uri))
 
 
 # Factory functions
 #
 
 cdef dict _pj_sipuri_to_dict(pjsip_sip_uri *uri):
     cdef object scheme
     cdef pj_str_t *scheme_str
     cdef pjsip_param *param
     cdef object parameters = {}
     cdef object headers = {}
     cdef object kwargs = dict(parameters=parameters, headers=headers)
 
     scheme = _pj_str_to_str(pjsip_uri_get_scheme(<pjsip_uri *>uri)[0])
     if scheme == "sip":
         kwargs["secure"] = False
     elif scheme == "sips":
         kwargs["secure"] = True
     else:
         raise SIPCoreError("Not a valid SIP URI")
 
     kwargs["host"] = _pj_str_to_str(uri.host)
 
     if uri.user.slen > 0:
         kwargs["user"] = _pj_str_to_str(uri.user)
     if uri.passwd.slen > 0:
         kwargs["password"] = _pj_str_to_str(uri.passwd)
     if uri.port > 0:
         kwargs["port"] = uri.port
     if uri.user_param.slen > 0:
         parameters["user"] = _pj_str_to_str(uri.user_param)
     if uri.method_param.slen > 0:
         parameters["method"] = _pj_str_to_str(uri.method_param)
     if uri.transport_param.slen > 0:
         parameters["transport"] = _pj_str_to_str(uri.transport_param)
     if uri.ttl_param != -1:
         parameters["ttl"] = uri.ttl_param
     if uri.lr_param != 0:
         parameters["lr"] = None
     if uri.maddr_param.slen > 0:
         parameters["maddr"] = _pj_str_to_str(uri.maddr_param)
     param = <pjsip_param *> (<pj_list *> &uri.other_param).next
 
     while param != &uri.other_param:
         if param.value.slen == 0:
             parameters[_pj_str_to_str(param.name)] = None
         else:
             parameters[_pj_str_to_str(param.name)] = _pj_str_to_str(param.value)
         param = <pjsip_param *> (<pj_list *> param).next
     param = <pjsip_param *> (<pj_list *> &uri.header_param).next
 
     while param != &uri.header_param:
         if param.value.slen == 0:
             headers[_pj_str_to_str(param.name)] = None
         else:
             headers[_pj_str_to_str(param.name)] = _pj_str_to_str(param.value)
         param = <pjsip_param *> (<pj_list *> param).next
     return kwargs
 
 
 cdef SIPURI SIPURI_create(pjsip_sip_uri *uri):
     cdef dict kwargs = _pj_sipuri_to_dict(uri)
     return SIPURI(**kwargs)
 
 
 cdef FrozenSIPURI FrozenSIPURI_create(pjsip_sip_uri *uri):
     cdef dict kwargs = _pj_sipuri_to_dict(uri)
     kwargs["parameters"] = frozendict(kwargs["parameters"])
     kwargs["headers"] = frozendict(kwargs["headers"])
     return FrozenSIPURI(**kwargs)
 
 
 # Globals
 #
 
 cdef PJSTR _Credentials_scheme_digest = PJSTR(b"digest")