Purism-Calls/plugins/provider/sip/calls-sip-origin.c

/*
 * Copyright (C) 2021-2022 Purism SPC
 *
 * This file is part of Calls.
 *
 * Calls is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Calls is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Calls.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Evangelos Ribeiro Tzaras <evangelos.tzaras@puri.sm>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 */

#define WAIT_FOR_SHUTDOWN_MS 100
#define WAIT_FOR_OFFLINE_MS 100
#define WAIT_FOR_OFFLINE_RETRIES 5

#define G_LOG_DOMAIN "CallsSipOrigin"


#include "calls-account.h"
#include "calls-message-source.h"
#include "calls-origin.h"
#include "calls-sip-call.h"
#include "calls-sip-enums.h"
#include "calls-sip-origin.h"
#include "calls-sip-util.h"
#include "calls-sip-media-manager.h"
#include "calls-network-watch.h"
#include "calls-config.h"
#include "enum-types.h"

#include <glib/gi18n.h>
#include <glib-object.h>

#include <sofia-sip/sofia_features.h>
#include <sofia-sip/nua.h>
#include <sofia-sip/su_tag.h>
#include <sofia-sip/su_tag_io.h>
#include <sofia-sip/sip_util.h>
#include <sofia-sip/sdp.h>

/**
 * SECTION:sip-origin
 * @short_description: A #CallsOrigin for the SIP protocol
 * @Title: CallsSipOrigin
 *
 * #CallsSipOrigin implements the #CallsOriginInterface and is mainly
 * responsible for managing the sofia-sip callbacks, keeping track of #CallsSipCall
 * objects and coordinating with #CallsSipMediaManager.
 */

enum {
  PROP_0,
  PROP_NAME,
  PROP_ID,
  PROP_EMERGENCY_NUMBERS,
  PROP_ACC_HOST,
  PROP_ACC_USER,
  PROP_ACC_PASSWORD,
  PROP_ACC_DISPLAY_NAME,
  PROP_ACC_PORT,
  PROP_ACC_PROTOCOL,
  PROP_ACC_AUTO_CONNECT,
  PROP_ACC_DIRECT,
  PROP_ACC_LOCAL_PORT,
  PROP_SIP_CONTEXT,
  PROP_ACC_STATE,
  PROP_ACC_ADDRESS,
  PROP_CALLS,
  PROP_COUNTRY_CODE,
  PROP_CAN_TEL,
  PROP_MEDIA_ENCRYPTION,
  PROP_LAST_PROP,
};
static GParamSpec *props[PROP_LAST_PROP];

static gboolean set_contact_header = FALSE;

struct _CallsSipOrigin {
  GObject               parent_instance;

  CallsSipContext      *ctx;
  nua_t                *nua;
  CallsSipHandles      *oper;
  char                 *contact_header; /* Needed for sofia SIP >= 1.13 */

  /* Direct connection mode is useful for debugging purposes */
  gboolean              use_direct_connection;

  /* Needed to handle shutdown correctly. See sip_callback and dispose method */
  gboolean              is_nua_shutdown;
  gboolean              is_shutdown_success;

  CallsAccountState     state;

  CallsSipMediaManager *media_manager;

  /* Account information */
  char                 *host;
  char                 *user;
  char                 *password;
  char                 *display_name;
  gint                  port;
  char                 *transport_protocol;
  gboolean              auto_connect;
  gboolean              direct_mode;
  gboolean              can_tel;
  SipMediaEncryption    media_encryption;

  char                 *own_ip;
  gint                  local_port;

  const char           *protocol_prefix;
  char                 *address;
  char                 *name;
  char                 *id;

  GList                *calls;
  GHashTable           *call_handles;
};

static void calls_sip_origin_message_source_interface_init (CallsOriginInterface *iface);
static void calls_sip_origin_origin_interface_init (CallsOriginInterface *iface);
static void calls_sip_origin_accounts_interface_init (CallsAccountInterface *iface);

G_DEFINE_TYPE_WITH_CODE (CallsSipOrigin, calls_sip_origin, G_TYPE_OBJECT,
                         G_IMPLEMENT_INTERFACE (CALLS_TYPE_MESSAGE_SOURCE,
                                                calls_sip_origin_message_source_interface_init)
                         G_IMPLEMENT_INTERFACE (CALLS_TYPE_ORIGIN,
                                                calls_sip_origin_origin_interface_init)
                         G_IMPLEMENT_INTERFACE (CALLS_TYPE_ACCOUNT,
                                                calls_sip_origin_accounts_interface_init))

static void
change_state (CallsSipOrigin         *self,
              CallsAccountState       new_state,
              CallsAccountStateReason reason)
{
  CallsAccountState old_state;

  g_assert (CALLS_SIP_ORIGIN (self));

  if (self->state == new_state &&
      new_state != CALLS_ACCOUNT_STATE_ERROR &&
      !calls_account_state_reason_is_for_ui (reason))
    return;

  old_state = self->state;
  self->state = new_state;

  g_object_notify_by_pspec (G_OBJECT (self), props[PROP_ACC_STATE]);

  g_signal_emit_by_name (self, "account-state-changed", old_state, new_state, reason);
  calls_account_emit_message_for_state_change (CALLS_ACCOUNT (self), new_state, reason);
}


static void
remove_call (CallsSipOrigin *self,
             CallsCall      *call,
             const char     *reason)
{
  CallsOrigin *origin;
  CallsSipCall *sip_call;
  gboolean inbound;
  nua_handle_t *nh;

  origin = CALLS_ORIGIN (self);
  sip_call = CALLS_SIP_CALL (call);

  self->calls = g_list_remove (self->calls, call);

  g_object_get (sip_call,
                "inbound", &inbound,
                "nua-handle", &nh,
                NULL);

  /* TODO support multiple simultaneous calls */
  if (self->oper->call_handle == nh)
    self->oper->call_handle = NULL;

  g_signal_emit_by_name (origin, "call-removed", call, reason);
  g_object_unref (call);
}


static void
remove_calls (CallsSipOrigin *self,
              const char     *reason)
{
  CallsCall *call;
  GList *next;

  while (self->calls != NULL) {
    call = self->calls->data;
    next = self->calls->next;

    calls_call_hang_up (call);

    g_list_free_1 (self->calls);
    self->calls = next;

    g_signal_emit_by_name (self, "call-removed", call, reason);
    g_object_unref (call);
  }

  g_hash_table_remove_all (self->call_handles);

  g_clear_pointer (&self->oper->call_handle, nua_handle_unref);
}


static void
on_call_state_changed (CallsSipCall   *call,
                       GParamSpec     *pspec,
                       CallsSipOrigin *self)
{
  g_assert (CALLS_IS_SIP_ORIGIN (self));
  g_assert (CALLS_IS_CALL (call));

  if (calls_call_get_state (CALLS_CALL (call)) != CALLS_CALL_STATE_DISCONNECTED)
    return;

  remove_call (self, CALLS_CALL (call), "Disconnected");
}


static void
add_call (CallsSipOrigin *self,
          const char     *address,
          gboolean        inbound,
          nua_handle_t   *handle)
{
  CallsSipCall *sip_call;
  CallsCall *call;
  CallsSipMediaPipeline *pipeline;
  const char *call_address = address;
  gint rtp_port, rtcp_port;

  g_auto (GStrv) address_split = NULL;
  g_autofree char *local_sdp = NULL;

  pipeline = calls_sip_media_manager_get_pipeline (self->media_manager);
  rtp_port = calls_sip_media_pipeline_get_rtp_port (pipeline);
  rtcp_port = calls_sip_media_pipeline_get_rtcp_port (pipeline);

  if (self->can_tel) {
    address_split = g_strsplit_set (address, ":@;", -1);

    if (g_strv_length (address_split) >=2 &&
        g_strcmp0 (address_split[2], self->host) == 0)
      call_address = address_split[1];
  }

  sip_call = calls_sip_call_new (call_address,
                                 inbound,
                                 self->own_ip,
                                 pipeline,
                                 self->media_encryption,
                                 handle);
  g_assert (sip_call != NULL);

  if (self->oper->call_handle)
    nua_handle_unref (self->oper->call_handle);

  self->oper->call_handle = handle;

  self->calls = g_list_append (self->calls, sip_call);
  g_hash_table_insert (self->call_handles, handle, sip_call);

  call = CALLS_CALL (sip_call);

  g_signal_emit_by_name (CALLS_ORIGIN (self), "call-added", call);
  g_signal_connect (call, "notify::state",
                    G_CALLBACK (on_call_state_changed),
                    self);

  if (!inbound) {
    g_autoptr (GList) crypto_attributes = NULL;
    g_autoptr (CallsSdpCryptoContext) ctx =
      calls_sip_call_get_sdp_crypto_context (sip_call);

    if (self->media_encryption == SIP_MEDIA_ENCRYPTION_FORCED) {
      if (!calls_sdp_crypto_context_generate_offer (ctx)) {
        g_warning ("Media encryption must be used, but could not generate offer. Aborting");
        calls_call_set_state (CALLS_CALL (sip_call), CALLS_CALL_STATE_DISCONNECTED);
        return;
      }
    }

    if (self->media_encryption == SIP_MEDIA_ENCRYPTION_PREFERRED) {
      if (!calls_sdp_crypto_context_generate_offer (ctx))
        g_debug ("Media encryption optional, but could not generate offer. Continuing unencrypted");
    }

    crypto_attributes = calls_sdp_crypto_context_get_crypto_candidates (ctx, FALSE);

    local_sdp = calls_sip_media_manager_static_capabilities (self->media_manager,
                                                             self->own_ip,
                                                             rtp_port,
                                                             rtcp_port,
                                                             crypto_attributes);

    g_assert (local_sdp);

    g_debug ("Setting local SDP for outgoing call to %s:\n%s", address, local_sdp);

    /* TODO handle IPv4 vs IPv6 for nua_invite (SOATAG_TAG) */
    nua_invite (self->oper->call_handle,
                SOATAG_AF (SOA_AF_IP4_IP6),
                SOATAG_USER_SDP_STR (local_sdp),
                SIPTAG_TO_STR (address),
                TAG_IF (!!self->contact_header, SIPTAG_CONTACT_STR (self->contact_header)),
                SOATAG_RTP_SORT (SOA_RTP_SORT_REMOTE),
                SOATAG_RTP_SELECT (SOA_RTP_SELECT_ALL),
                TAG_END ());
  }
}


static void
dial (CallsOrigin *origin,
      const char  *address)
{
  CallsSipOrigin *self;
  nua_handle_t *nh;
  g_autofree char *name = NULL;
  g_autofree char *dial_target = NULL;

  g_assert (CALLS_ORIGIN (origin));
  g_assert (CALLS_IS_SIP_ORIGIN (origin));

  name = calls_origin_get_name (origin);

  if (!address || !*address) {
    g_warning ("Tried dialing on origin '%s' without an address",
               name);
    return;
  }

  if (calls_account_get_state (CALLS_ACCOUNT (origin)) !=
      CALLS_ACCOUNT_STATE_ONLINE) {

    g_warning ("Tried dialing '%s' on origin '%s', but it's not online",
               address, name);
    return;
  }

  self = CALLS_SIP_ORIGIN (origin);

  nh = nua_handle (self->nua, self->oper,
                   NUTAG_MEDIA_ENABLE (1),
                   SOATAG_ACTIVE_AUDIO (SOA_ACTIVE_SENDRECV),
                   TAG_END ());

  /* Make sure @host is in the dial target */
  if (g_strstr_len (address, -1, "@")) {
    dial_target = g_strdup (address);
  } else {
    if (self->port > 0)
      dial_target = g_strdup_printf ("%s@%s:%d", address, self->host, self->port);
    else
      dial_target = g_strconcat (address, "@", self->host, NULL);
  }

  g_debug ("Calling `%s' from origin '%s'", address, name);

  /* We don't require the user to input the prefix */
  if (!g_str_has_prefix (address, "sip:") &&
      !g_str_has_prefix (address, "sips:")) {
    g_autofree char * target_with_prefix =
      g_strconcat (self->protocol_prefix, ":", dial_target, NULL);

    add_call (CALLS_SIP_ORIGIN (origin), target_with_prefix, FALSE, nh);
  } else {
    add_call (CALLS_SIP_ORIGIN (origin), dial_target, FALSE, nh);
  }
}

static void
create_inbound (CallsSipOrigin *self,
                const char     *address,
                nua_handle_t   *handle)
{
  g_assert (CALLS_IS_SIP_ORIGIN (self));
  g_assert (address != NULL);

  /* TODO support multiple calls */
  if (self->oper->call_handle)
    nua_handle_unref (self->oper->call_handle);

  self->oper->call_handle = handle;

  add_call (self, address, TRUE, handle);
}


static void
sip_authenticate (CallsSipOrigin *self,
                  nua_handle_t   *nh,
                  sip_t const    *sip)
{
  const char *scheme = NULL;
  const char *realm = NULL;
  g_autofree char *auth = NULL;
  sip_www_authenticate_t *www_auth = sip->sip_www_authenticate;
  sip_proxy_authenticate_t *proxy_auth = sip->sip_proxy_authenticate;

  if (www_auth) {
    scheme = www_auth->au_scheme;
    realm = msg_params_find (www_auth->au_params, "realm=");
  } else if (proxy_auth) {
    scheme = proxy_auth->au_scheme;
    realm = msg_params_find (proxy_auth->au_params, "realm=");
  } else {
    g_warning ("No authentication context found");
    return;
  }
  g_debug ("need to authenticate to realm %s", realm);

  /* TODO handle authentication to different realms
   * https://source.puri.sm/Librem5/calls/-/issues/266
   */
  auth = g_strdup_printf ("%s:%s:%s:%s",
                          scheme, realm, self->user, self->password);
  nua_authenticate (nh, NUTAG_AUTH (auth), TAG_END ());
}


static void
sip_r_invite (int              status,
              char const      *phrase,
              nua_t           *nua,
              CallsSipOrigin  *origin,
              nua_handle_t    *nh,
              CallsSipHandles *op,
              sip_t const     *sip,
              tagi_t           tags[])
{
  g_debug ("response to outgoing INVITE: %03d %s", status, phrase);

  /* TODO call states (see i_state) */
  if (status == 401 || status == 407) {
    sip_authenticate (origin, nh, sip);
  } else if (status == 403) {
    g_warning ("Response to outgoing INVITE: 403 wrong credentials?");
  } else if (status == 904) {
    g_warning ("Response to outgoing INVITE: 904 unmatched challenge."
               "Possibly the challenge was already answered?");
  } else if (status == 180) {
  } else if (status == 100) {
  } else if (status == 200) {
  }
}


static void
sip_r_register (int              status,
                char const      *phrase,
                nua_t           *nua,
                CallsSipOrigin  *origin,
                nua_handle_t    *nh,
                CallsSipHandles *op,
                sip_t const     *sip,
                tagi_t           tags[])
{
  if (status == 200) {
    if (origin->state == CALLS_ACCOUNT_STATE_ONLINE)
      return;

    g_debug ("REGISTER successful");
    change_state (origin,
                  CALLS_ACCOUNT_STATE_ONLINE,
                  CALLS_ACCOUNT_STATE_REASON_CONNECTED);

    /* Fix for https://github.com/freeswitch/sofia-sip/issues/25 */
    if (!origin->contact_header)
      nua_get_params (nua, TAG_ANY (), TAG_END ());

    if (sip->sip_contact && sip->sip_contact->m_url->url_host) {
      if (g_strcmp0 (origin->own_ip, sip->sip_contact->m_url->url_host) == 0)
        return;

      g_free (origin->own_ip);
      origin->own_ip = g_strdup (sip->sip_contact->m_url->url_host);
      g_debug ("Own IP as reported by the registrar: %s", origin->own_ip);
    }

  } else if (status == 100) {
    /* nothing to do; request authorized by cache */
  } else if (status == 401 || status == 407) {
    sip_authenticate (origin, nh, sip);

  } else if (status == 403) {
    g_debug ("REGISTER denied: Probably using wrong credentials");
    change_state (origin,
                  CALLS_ACCOUNT_STATE_OFFLINE,
                  CALLS_ACCOUNT_STATE_REASON_AUTHENTICATION_FAILURE);
  } else if (status == 503) {
    change_state (origin,
                  CALLS_ACCOUNT_STATE_OFFLINE,
                  CALLS_ACCOUNT_STATE_REASON_CONNECTION_DNS_ERROR);
  } else if (status == 904) {
    g_warning ("REGISTER: unmatched challenge");
    change_state (origin,
                  CALLS_ACCOUNT_STATE_ERROR,
                  CALLS_ACCOUNT_STATE_REASON_INTERNAL_ERROR);
  } else {
    g_warning ("REGISTER: %d %s", status, phrase);
    change_state (origin,
                  CALLS_ACCOUNT_STATE_ERROR,
                  CALLS_ACCOUNT_STATE_REASON_INTERNAL_ERROR);
  }
}


static void
sip_r_unregister (int              status,
                  char const      *phrase,
                  nua_t           *nua,
                  CallsSipOrigin  *origin,
                  nua_handle_t    *nh,
                  CallsSipHandles *op,
                  sip_t const     *sip,
                  tagi_t           tags[])
{
  g_debug ("response to unregistering: %03d %s", status, phrase);

  if (status == 200) {
    g_debug ("Unregistering successful");
    change_state (origin,
                  CALLS_ACCOUNT_STATE_OFFLINE,
                  CALLS_ACCOUNT_STATE_REASON_DISCONNECTED);
  } else if (status == 100) {
    /* nothing to do; request authorized by cache */
  } else if (status == 503) {
    change_state (origin,
                  CALLS_ACCOUNT_STATE_OFFLINE,
                  CALLS_ACCOUNT_STATE_REASON_CONNECTION_DNS_ERROR);
  } else {
    g_warning ("Unregisterung unsuccessful: %03d %s", status, phrase);
    change_state (origin,
                  CALLS_ACCOUNT_STATE_ERROR,
                  CALLS_ACCOUNT_STATE_REASON_UNKNOWN);
  }
}


static void
sip_i_state (int              status,
             char const      *phrase,
             nua_t           *nua,
             CallsSipOrigin  *origin,
             nua_handle_t    *nh,
             CallsSipHandles *op,
             sip_t const     *sip,
             tagi_t           tags[])
{
  const sdp_session_t *r_sdp = NULL;
  const sdp_session_t *l_sdp = NULL;
  const char *r_sdp_str = NULL;
  gint call_state = nua_callstate_init;
  CallsCallState state;
  CallsSipCall *call;
  int offer_sent = 0;
  int offer_recv = 0;
  int answer_sent = 0;
  int answer_recv = 0;

  g_assert (CALLS_IS_SIP_ORIGIN (origin));

  g_debug ("The call state has changed: %03d %s", status, phrase);

  call = g_hash_table_lookup (origin->call_handles, nh);

  if (call == NULL) {
    g_warning ("No call found for the current handle");
    return;
  }

  tl_gets (tags,
           SOATAG_LOCAL_SDP_REF (l_sdp),
           SOATAG_REMOTE_SDP_REF (r_sdp),
           SOATAG_REMOTE_SDP_STR_REF (r_sdp_str),
           NUTAG_CALLSTATE_REF (call_state),
           NUTAG_OFFER_SENT_REF (offer_sent),
           NUTAG_OFFER_RECV_REF (offer_recv),
           NUTAG_ANSWER_SENT_REF (answer_sent),
           NUTAG_ANSWER_RECV_REF (answer_recv),
           TAG_END ());

  if (status == 503) {
    CALLS_EMIT_MESSAGE (origin, "DNS error", GTK_MESSAGE_ERROR);
  }

  if (r_sdp) {
    g_autoptr (CallsSdpCryptoContext) ctx = NULL;
    g_autoptr (GList) remote_codecs =
      calls_sip_media_manager_get_codecs_from_sdp (origin->media_manager,
                                                   r_sdp->sdp_media);
    g_autoptr (GList) codecs = NULL;
    GList *node;
    GList *preferred_codecs = calls_sip_media_manager_codec_candidates (origin->media_manager);
    const char *session_ip = NULL;
    const char *media_ip = NULL;
    int rtp_port;
    int rtcp_port = 0;

    for (node = remote_codecs; node != NULL; node = node->next) {
      MediaCodecInfo *codec = node->data;
      if (g_list_find (preferred_codecs, codec)) {
        g_debug ("Found common codec: %s", codec->name);
        codecs = g_list_append (codecs, codec);
      }
    }

    g_debug ("Remote SDP was set to:\n%s", r_sdp_str);

    if (!codecs) {
      g_warning ("No common codecs in SDP. Hanging up. Remote SDP:\n%s", r_sdp_str);
      calls_call_hang_up (CALLS_CALL (call));
      return;
    }

    ctx = calls_sip_call_get_sdp_crypto_context (call);
    if (origin->media_encryption == SIP_MEDIA_ENCRYPTION_FORCED) {

      if (!calls_sdp_crypto_context_set_remote_media (ctx, r_sdp->sdp_media)) {
        g_warning ("Media encryption is enforced, but remote didn't set crypto attributes.\n"
                   "Remote SDP: %s", r_sdp_str);
        calls_call_hang_up (CALLS_CALL (call));
        return;
      }
    }

    if (origin->media_encryption == SIP_MEDIA_ENCRYPTION_PREFERRED) {
      if (!calls_sdp_crypto_context_set_remote_media (ctx, r_sdp->sdp_media))
        g_debug ("Remote didn't set crypto attributes. Continuing unencrypted");
    }

    if (origin->media_encryption == SIP_MEDIA_ENCRYPTION_NONE) {
      gboolean got_crypto = FALSE;

      for (sdp_attribute_t *attr = r_sdp->sdp_media->m_attributes; attr; attr = attr->a_next) {
        if (g_strcmp0 (attr->a_name, "crypto") == 0) {
          got_crypto = TRUE;
          break;
        }
      }

      if (got_crypto) {
        g_debug ("Remote peer %s wants to talk using encryption, but not allowed by local policy",
                 calls_call_get_id (CALLS_CALL (call)));
        calls_call_hang_up (CALLS_CALL (call));
        return;
      }
    }

    if (r_sdp->sdp_connection && r_sdp->sdp_connection->c_address)
      session_ip = r_sdp->sdp_connection->c_address;

    if (r_sdp->sdp_media && r_sdp->sdp_media->m_connections &&
        r_sdp->sdp_media->m_connections->c_address)
      media_ip = r_sdp->sdp_media->m_connections->c_address;

    if (!session_ip && !media_ip) {
      g_warning ("Could not determine IP of remote peer. Hanging up");
      calls_call_hang_up (CALLS_CALL (call));
      return;
    }

    calls_sip_call_set_codecs (call, codecs);

    /* TODO This needs to adapt for the ICE case */
    rtp_port = r_sdp->sdp_media->m_port;
    for (sdp_attribute_t *attr = r_sdp->sdp_media->m_attributes; attr; attr = attr->a_next) {
      if (g_strcmp0 (attr->a_name, "rtcp") == 0) {
        rtcp_port = atoi (attr->a_value);
        break;
      }
    }

    /* Legacy fallback */
    if (rtcp_port == 0)
      rtcp_port = rtp_port + 1;

    calls_sip_call_setup_remote_media_connection (call,
                                                  media_ip ?: session_ip,
                                                  rtp_port,
                                                  rtcp_port);
  }

  switch (call_state) {
  case nua_callstate_init:
    return;

  case nua_callstate_calling:
    state = CALLS_CALL_STATE_DIALING;
    break;

  case nua_callstate_received:
    state = CALLS_CALL_STATE_INCOMING;
    g_debug ("Call incoming");
    break;

  case nua_callstate_ready:
    g_debug ("Call ready. Activating media pipeline");

    calls_sip_call_activate_media (call, TRUE);
    state = CALLS_CALL_STATE_ACTIVE;
    break;

  case nua_callstate_terminated:
    g_debug ("Call terminated. Deactivating media pipeline");

    calls_sip_call_activate_media (call, FALSE);
    state = CALLS_CALL_STATE_DISCONNECTED;

    g_hash_table_remove (origin->call_handles, nh);
    break;

  default:
    return;
  }

  calls_call_set_state (CALLS_CALL (call), state);
}


static void
sip_r_get_params (int              status,
                  char const      *phrase,
                  nua_t           *nua,
                  CallsSipOrigin  *origin,
                  nua_handle_t    *nh,
                  CallsSipHandles *op,
                  sip_t const     *sip,
                  tagi_t           tags[])
{
  tagi_t *from = NULL;
  const char *from_str = NULL;

  g_debug ("response to get_params: %03d %s", status, phrase);

  if (!set_contact_header)
    return;

  if ((status != 200) || ((from = tl_find (tags, siptag_from_str)) == NULL)) {
    g_warning ("Could not find 'siptag_from_tag' among the tags");
    return;
  }

  from_str = (const char *) from->t_value;
  g_free (origin->contact_header);
  origin->contact_header = g_strdup (from_str);
}


static void
sip_callback (nua_event_t   event,
              int           status,
              char const   *phrase,
              nua_t        *nua,
              nua_magic_t  *magic,
              nua_handle_t *nh,
              nua_hmagic_t *hmagic,
              sip_t const  *sip,
              tagi_t        tags[])
{
  CallsSipOrigin *origin = CALLS_SIP_ORIGIN (magic);
  CallsSipHandles *op = origin->oper;
  g_autofree char *from = NULL;

  switch (event) {
  case nua_i_invite:
    if (sip->sip_from &&
        sip->sip_from->a_url->url_scheme &&
        sip->sip_from->a_url->url_user &&
        sip->sip_from->a_url->url_host)
      from = g_strconcat (sip->sip_from->a_url->url_scheme, ":",
                          sip->sip_from->a_url->url_user, "@",
                          sip->sip_from->a_url->url_host, NULL);
    else {
      nua_respond (nh, 400, NULL, TAG_END ());
      g_warning ("invalid incoming INVITE request");
      break;
    }

    g_debug ("incoming call INVITE: %03d %s from %s", status, phrase, from);

    /* reject if there already is a ongoing call */
    if (op->call_handle) {
      nua_respond (nh, 486, NULL, TAG_END ());
      g_debug ("Cannot handle more than one call. Rejecting");
    } else {
      create_inbound (origin, from, nh);
    }
    break;

  case nua_r_invite:
    sip_r_invite (status,
                  phrase,
                  nua,
                  origin,
                  nh,
                  op,
                  sip,
                  tags);
    break;

  case nua_i_ack:
    g_debug ("incoming ACK: %03d %s", status, phrase);
    break;

  case nua_i_bye:
    g_debug ("incoming BYE: %03d %s", status, phrase);
    break;

  case nua_r_bye:
    g_debug ("response to BYE: %03d %s", status, phrase);
    if (status == 200) {
      CallsSipCall *call =
        CALLS_SIP_CALL (g_hash_table_lookup (origin->call_handles, nh));

      if (call == NULL) {
        g_warning ("BYE response from an unknown call");
        return;
      }
    }
    break;

  case nua_r_register:
    sip_r_register (status,
                    phrase,
                    nua,
                    origin,
                    nh,
                    op,
                    sip,
                    tags);
    break;

  case nua_r_unregister:
    sip_r_unregister (status,
                      phrase,
                      nua,
                      origin,
                      nh,
                      op,
                      sip,
                      tags);
    break;

  case nua_r_get_params:
    sip_r_get_params (status,
                      phrase,
                      nua,
                      origin,
                      nh,
                      op,
                      sip,
                      tags);
    break;

  case nua_r_set_params:
    g_debug ("response to set_params: %03d %s", status, phrase);
    break;

  case nua_i_outbound:
    g_debug ("status of outbound engine has changed: %03d %s", status, phrase);

    if (status == 404) {
      CALLS_EMIT_MESSAGE (origin, "contact not found", GTK_MESSAGE_ERROR);

      g_warning ("outbound engine changed state to %03d %s", status, phrase);
    }

    break;

  case nua_i_state:
    sip_i_state (status,
                 phrase,
                 nua,
                 origin,
                 nh,
                 op,
                 sip,
                 tags);
    break;

  case nua_r_cancel:
    g_debug ("response to CANCEL: %03d %s", status, phrase);
    break;

  case nua_r_terminate:
    break;

  case nua_r_shutdown:
    /* see also deinit_sip () */
    g_debug ("response to nua_shutdown: %03d %s", status, phrase);
    if (status == 200) {
      origin->is_nua_shutdown = TRUE;
      origin->is_shutdown_success = TRUE;
    } else if (status == 500) {
      origin->is_nua_shutdown = TRUE;
      origin->is_shutdown_success = FALSE;
    }
    break;

  /* Deprecated events */
  case nua_i_active:
    break;
  case nua_i_terminated:
    break;

  default:
    /* unknown event */
    g_debug ("unknown event %d: %03d %s",
             event,
             status,
             phrase);
    if (tags && tags[0].t_tag != NULL) {
      g_debug ("printing tags");
      tl_print (stdout, "", tags);
    }
    break;
  }
}


static nua_t *
setup_nua (CallsSipOrigin *self)
{
  const char *sip_test_env = g_getenv ("CALLS_SIP_TEST");
  nua_t *nua;
  gboolean use_sips = FALSE;
  gboolean use_ipv6 = FALSE; /* TODO make configurable or use DNS to figure out if ipv6 is supported*/
  const char *ipv6_bind = "*";
  const char *ipv4_bind = "0.0.0.0";
  const char *uuid = NULL;
  g_autofree char *urn_uuid = NULL;
  g_autofree char *sip_url = NULL;
  g_autofree char *sips_url = NULL;
  g_autofree char *from_str = NULL;

  if (!sip_test_env || sip_test_env[0] == '\0') {
    CallsNetworkWatch *nw = calls_network_watch_get_default ();
    if (nw) {
      ipv4_bind = calls_network_watch_get_ipv4 (nw);
      ipv6_bind = calls_network_watch_get_ipv6 (nw);
    }
  }

  uuid = nua_generate_instance_identifier (self->ctx->home);
  urn_uuid = g_strdup_printf ("urn:uuid:%s", uuid);

  self->protocol_prefix = get_protocol_prefix (self->transport_protocol);

  self->address = g_strconcat (self->user, "@", self->host, NULL);
  from_str = g_strconcat (self->protocol_prefix, ":", self->address, NULL);

  g_object_notify_by_pspec (G_OBJECT (self), props[PROP_ACC_ADDRESS]);

  use_sips = check_sips (from_str);
  use_ipv6 = check_ipv6 (self->host);

  if (self->local_port > 0) {
    sip_url = g_strdup_printf ("sip:%s:%d",
                               use_ipv6 ? ipv6_bind : ipv4_bind,
                               self->local_port);
    sips_url = g_strdup_printf ("sips:%s:%d",
                                use_ipv6 ? ipv6_bind : ipv4_bind,
                                self->local_port);
  } else {
    sip_url = g_strdup_printf ("sip:%s:*",
                               use_ipv6 ? ipv6_bind : ipv4_bind);
    sips_url = g_strdup_printf ("sips:%s:*",
                                use_ipv6 ? ipv6_bind : ipv4_bind);
  }

  /** For TLS nua_create() will error if NUTAG_URL includes ";transport=tls"
   *  In that case NUTAG_SIPS_URL should be used and NUTAG_URL should be as usual
   *  Since UDP is the default we only need to append the suffix in the TCP case
   */
  if (g_ascii_strcasecmp (self->transport_protocol, "TCP") == 0) {
    char *temp = sip_url;

    sip_url = g_strdup_printf ("%s;transport=%s", temp, self->transport_protocol);
    g_free (temp);
  }

  nua = nua_create (self->ctx->root,
                    sip_callback,
                    self,
                    NUTAG_USER_AGENT (APP_DATA_NAME),
                    NUTAG_URL (sip_url),
                    TAG_IF (use_sips, NUTAG_SIPS_URL (sips_url)),
                    SIPTAG_FROM_STR (from_str),
                    NUTAG_ALLOW ("INVITE, ACK, BYE, CANCEL, OPTIONS, UPDATE"),
                    NUTAG_SUPPORTED ("replaces, gruu, outbound"),
                    NTATAG_MAX_FORWARDS (70),
                    NUTAG_ENABLEINVITE (1),
                    NUTAG_AUTOANSWER (0),
                    NUTAG_AUTOACK (1),
                    NUTAG_PATH_ENABLE (0),
                    NUTAG_MEDIA_ENABLE (1),
                    NUTAG_INSTANCE (urn_uuid),
                    TAG_NULL ());

  return nua;
}


static char *
get_registrar_url (CallsSipOrigin *self)
{
  g_assert (CALLS_IS_SIP_ORIGIN (self));

  if (self->port > 0 && self->port <= 65535)
    return g_strdup_printf ("%s:%s:%d", self->protocol_prefix, self->host, self->port);
  else
    return g_strconcat (self->protocol_prefix, ":", self->host, NULL);
}


static CallsSipHandles *
setup_sip_handles (CallsSipOrigin *self)
{
  CallsSipHandles *oper;
  g_autofree char *registrar_url = NULL;

  g_assert (CALLS_IS_SIP_ORIGIN (self));

  if (!(oper = su_zalloc (self->ctx->home, sizeof(CallsSipHandles)))) {
    g_warning ("cannot create handle");
    return NULL;
  }

  oper->context = self->ctx;
  oper->register_handle = nua_handle (self->nua, self->oper,
                                      SIPTAG_EXPIRES_STR ("180"),
                                      NUTAG_SUPPORTED ("replaces, outbound, gruu"),
                                      NUTAG_OUTBOUND ("outbound natify gruuize validate"), // <- janus uses "no-validate"
                                      NUTAG_M_PARAMS ("user=phone"),
                                      NUTAG_CALLEE_CAPS (1), /* header parameters based on SDP capabilities and Allow header */
                                      TAG_END ());
  oper->call_handle = NULL;
  return oper;
}


static void
go_online (CallsAccount *account,
           gboolean      online)
{
  CallsSipOrigin *self;

  g_assert (CALLS_IS_ACCOUNT (account));
  g_assert (CALLS_IS_SIP_ORIGIN (account));

  self = CALLS_SIP_ORIGIN (account);

  if (self->use_direct_connection)
    return;

  if (!self->nua) {
    g_warning ("Cannot go online: nua handle not initialized");
    g_object_notify_by_pspec (G_OBJECT (self), props[PROP_ACC_STATE]);
    return;
  }

  if (online) {
    g_autofree char *registrar_url = NULL;

    if (self->state == CALLS_ACCOUNT_STATE_ONLINE)
      return;

    registrar_url = get_registrar_url (self);

    nua_register (self->oper->register_handle,
                  NUTAG_M_USERNAME (self->user),
                  TAG_IF (self->display_name, NUTAG_M_DISPLAY (self->display_name)),
                  NUTAG_REGISTRAR (registrar_url),
                  TAG_END ());

  } else {
    if (self->state == CALLS_ACCOUNT_STATE_OFFLINE)
      return;

    nua_unregister (self->oper->register_handle,
                    TAG_END ());
  }
}


static const char *
get_address (CallsAccount *account)
{
  CallsSipOrigin *self;

  g_assert (CALLS_IS_ACCOUNT (account));
  g_assert (CALLS_IS_SIP_ORIGIN (account));

  self = CALLS_SIP_ORIGIN (account);

  return self->address;
}


static void
setup_account_for_direct_connection (CallsSipOrigin *self)
{
  g_assert (CALLS_IS_SIP_ORIGIN (self));

  /* honour username, if previously set */
  if (self->user == NULL)
    self->user = g_strdup (g_get_user_name ());

  g_free (self->host);
  self->host = g_strdup (g_get_host_name ());

  g_clear_pointer (&self->password, g_free);

  g_free (self->transport_protocol);
  self->transport_protocol = g_strdup ("UDP");

  self->protocol_prefix = get_protocol_prefix ("UDP");

  g_debug ("Account changed:\nuser: %s\nhost: %s",
           self->user, self->host);
}


static gboolean
is_account_complete (CallsSipOrigin *self)
{
  /* we need only need to check for password if needing to authenticate over a proxy/UAS */
  if (self->user == NULL ||
      (!self->use_direct_connection && self->password == NULL) ||
      self->host == NULL ||
      self->transport_protocol == NULL)
    return FALSE;

  return TRUE;
}


static gboolean
init_sip_account (CallsSipOrigin *self,
                  GError        **error)
{
  g_assert (CALLS_IS_SIP_ORIGIN (self));

  change_state (self,
                CALLS_ACCOUNT_STATE_INITIALIZING,
                CALLS_ACCOUNT_STATE_REASON_INITIALIZATION_STARTED);

  if (self->use_direct_connection) {
    g_debug ("Direct connection case. Using user and hostname");
    setup_account_for_direct_connection (self);
  }

  if (!is_account_complete (self)) {
    g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                 "Must have completed account setup before calling "
                 "init_sip_account (). "
                 "Try again when account is setup");

    change_state (self,
                  CALLS_ACCOUNT_STATE_ERROR,
                  CALLS_ACCOUNT_STATE_REASON_NO_CREDENTIALS);
    return FALSE;
  }

  /* setup_nua() and setup_sip_handles() only after account data has been set */
  self->nua = setup_nua (self);
  if (self->nua == NULL) {
    g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                 "Failed setting up nua context");

    change_state (self,
                  CALLS_ACCOUNT_STATE_ERROR,
                  CALLS_ACCOUNT_STATE_REASON_INTERNAL_ERROR);
    return FALSE;
  }

  self->oper = setup_sip_handles (self);
  if (self->oper == NULL) {
    g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
                 "Failed setting operation handles");

    change_state (self,
                  CALLS_ACCOUNT_STATE_ERROR,
                  CALLS_ACCOUNT_STATE_REASON_INTERNAL_ERROR);
    return FALSE;
  }

  /* In the case of a direct connection we're immediately good to go */
  change_state (self,
                self->use_direct_connection ? CALLS_ACCOUNT_STATE_ONLINE : CALLS_ACCOUNT_STATE_OFFLINE,
                CALLS_ACCOUNT_STATE_REASON_INITIALIZED);

  if (self->auto_connect)
    go_online (CALLS_ACCOUNT (self), TRUE);

  return TRUE;
}


static gboolean
deinit_sip_account (CallsSipOrigin *self)
{
  g_assert (CALLS_IS_SIP_ORIGIN (self));

  if (self->state == CALLS_ACCOUNT_STATE_UNKNOWN)
    return TRUE;

  change_state (self,
                CALLS_ACCOUNT_STATE_DEINITIALIZING,
                CALLS_ACCOUNT_STATE_REASON_DEINITIALIZATION_STARTED);

  remove_calls (self, NULL);

  if (self->nua) {
    g_debug ("Clearing any handles for account '%s'", self->address);
    g_clear_pointer (&self->oper->register_handle, nua_handle_destroy);
    g_debug ("Requesting nua_shutdown ()");
    self->is_nua_shutdown = FALSE;
    self->is_shutdown_success = FALSE;
    nua_shutdown (self->nua);
    // need to wait for nua_r_shutdown event before calling nua_destroy ()
    while (!self->is_nua_shutdown)
      su_root_step (self->ctx->root, WAIT_FOR_SHUTDOWN_MS);

    if (!self->is_shutdown_success) {
      g_warning ("nua_shutdown() timed out. Cannot proceed");
      change_state (self,
                    CALLS_ACCOUNT_STATE_ERROR,
                    CALLS_ACCOUNT_STATE_REASON_INTERNAL_ERROR);
      return FALSE;
    }
    g_debug ("nua_shutdown() complete. Destroying nua handle");
    g_clear_pointer (&self->nua, nua_destroy);
  }

  g_clear_pointer (&self->own_ip, g_free);
  change_state (self,
                CALLS_ACCOUNT_STATE_UNKNOWN,
                CALLS_ACCOUNT_STATE_REASON_DEINITIALIZED);
  return TRUE;
}


static void
recreate_sip (CallsSipOrigin *self)
{
  if (deinit_sip_account (self))
    init_sip_account (self, NULL);
}


static gboolean
supports_protocol (CallsOrigin *origin,
                   const char  *protocol)
{
  CallsSipOrigin *self;

  g_assert (protocol);
  g_assert (CALLS_IS_SIP_ORIGIN (origin));

  self = CALLS_SIP_ORIGIN (origin);

  if (g_strcmp0 (protocol, "sip") == 0)
    return TRUE;

  if (g_strcmp0 (protocol, "sips") == 0)
    return g_strcmp0 (self->protocol_prefix, "sips") == 0;

  if (g_strcmp0 (protocol, "tel") == 0)
    return self->can_tel;

  return FALSE;
}


static void
update_name (CallsSipOrigin *self)
{
  g_assert (CALLS_IS_SIP_ORIGIN (self));

  if (self->display_name && self->display_name[0] != '\0')
    self->name = self->display_name;
  else
    self->name = self->user;

  g_object_notify_by_pspec (G_OBJECT (self), props[PROP_NAME]);
}


static void
calls_sip_origin_set_property (GObject      *object,
                               guint         property_id,
                               const GValue *value,
                               GParamSpec   *pspec)
{
  CallsSipOrigin *self = CALLS_SIP_ORIGIN (object);

  switch (property_id) {
  case PROP_ID: /* contruct only */
    self->id = g_value_dup_string (value);
    break;

  case PROP_ACC_HOST:
    g_free (self->host);
    self->host = g_value_dup_string (value);
    break;

  case PROP_ACC_DISPLAY_NAME:
    g_free (self->display_name);
    self->display_name = g_value_dup_string (value);
    break;

  case PROP_ACC_USER:
    g_free (self->user);
    self->user = g_value_dup_string (value);
    break;

  case PROP_ACC_PASSWORD:
    g_free (self->password);
    self->password = g_value_dup_string (value);
    break;

  case PROP_ACC_PORT:
    self->port = g_value_get_int (value);
    break;

  case PROP_ACC_PROTOCOL:
    g_free (self->transport_protocol);
    self->transport_protocol = g_value_dup_string (value);
    break;

  case PROP_ACC_AUTO_CONNECT:
    self->auto_connect = g_value_get_boolean (value);
    break;

  case PROP_ACC_DIRECT:
    self->use_direct_connection = g_value_get_boolean (value);
    break;

  case PROP_SIP_CONTEXT:
    self->ctx = g_value_get_pointer (value);
    break;

  case PROP_ACC_LOCAL_PORT:
    if (g_value_get_int (value) > 0 && g_value_get_int (value) < 1025) {
      g_warning ("Tried setting a privileged port as the local port to bind to: %d\n"
                 "Continue using old 'local-port' value: %d (using 0 let's the OS decide)",
                 g_value_get_int (value), self->local_port);
      return;
    }
    self->local_port = g_value_get_int (value);
    break;

  case PROP_CAN_TEL:
    self->can_tel = g_value_get_boolean (value);
    break;

  case PROP_MEDIA_ENCRYPTION:
    self->media_encryption = g_value_get_enum (value);
    break;

  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    break;
  }
}


static void
calls_sip_origin_get_property (GObject    *object,
                               guint       property_id,
                               GValue     *value,
                               GParamSpec *pspec)
{
  CallsSipOrigin *self = CALLS_SIP_ORIGIN (object);

  switch (property_id) {
  case PROP_NAME:
    g_value_set_string (value, self->name);
    break;

  case PROP_ID:
    g_value_set_string (value, self->id);
    break;

  case PROP_EMERGENCY_NUMBERS:
    g_value_set_boxed (value, NULL);
    break;

  case PROP_ACC_HOST:
    g_value_set_string (value, self->host);
    break;

  case PROP_ACC_DISPLAY_NAME:
    g_value_set_string (value, self->display_name);
    break;

  case PROP_ACC_USER:
    g_value_set_string (value, self->user);
    break;

  case PROP_ACC_PASSWORD:
    g_value_set_string (value, self->password);
    break;

  case PROP_ACC_PORT:
    g_value_set_int (value, self->port);
    break;

  case PROP_ACC_PROTOCOL:
    g_value_set_string (value, self->transport_protocol);
    break;

  case PROP_ACC_AUTO_CONNECT:
    g_value_set_boolean (value, self->auto_connect);
    break;

  case PROP_ACC_DIRECT:
    g_value_set_boolean (value, self->direct_mode);
    break;

  case PROP_ACC_LOCAL_PORT:
    g_value_set_int (value, self->local_port);
    break;

  case PROP_CALLS:
    g_value_set_pointer (value, g_list_copy (self->calls));
    break;

  case PROP_ACC_STATE:
    g_value_set_enum (value, self->state);
    break;

  case PROP_ACC_ADDRESS:
    g_value_set_string (value, get_address (CALLS_ACCOUNT (self)));
    break;

  case PROP_COUNTRY_CODE:
    g_value_set_string (value, NULL);
    break;

  case PROP_CAN_TEL:
    g_value_set_boolean (value, self->can_tel);
    break;

  case PROP_MEDIA_ENCRYPTION:
    g_value_set_enum (value, self->media_encryption);
    break;

  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
    break;
  }
}


static void
calls_sip_origin_constructed (GObject *object)
{
  CallsSipOrigin *self = CALLS_SIP_ORIGIN (object);

  g_autoptr (GError) error = NULL;
  int major = 0;
  int minor = 0;
  int patch = 0;

  if (sscanf (SOFIA_SIP_VERSION, "%d.%d.%d", &major, &minor, &patch) == 3) {
    if (major > 2 || (major == 1 && minor >= 13)) {
      /* Sofia 1.13 does no longer include the contact header by default, see #304 */
      set_contact_header = TRUE;
    }
  }

  if (!init_sip_account (self, &error)) {
    g_warning ("Error initializing the SIP account: %s", error->message);
  }

  update_name (self);

  self->media_manager = calls_sip_media_manager_default ();

  G_OBJECT_CLASS (calls_sip_origin_parent_class)->constructed (object);
}


static void
calls_sip_origin_dispose (GObject *object)
{
  CallsSipOrigin *self = CALLS_SIP_ORIGIN (object);
  gboolean su_step_timeout = FALSE;
  guint i = 0;

  if (!self->use_direct_connection && self->state == CALLS_ACCOUNT_STATE_ONLINE) {
    go_online (CALLS_ACCOUNT (self), FALSE);

    while (self->state != CALLS_ACCOUNT_STATE_OFFLINE && !su_step_timeout) {
      su_root_step (self->ctx->root, WAIT_FOR_OFFLINE_MS);

      if (i++ > WAIT_FOR_OFFLINE_RETRIES)
        su_step_timeout = TRUE;
    }
  }

  deinit_sip_account (self);

  g_clear_pointer (&self->id, g_free);
  g_clear_pointer (&self->own_ip, g_free);
  g_clear_pointer (&self->transport_protocol, g_free);
  g_clear_pointer (&self->display_name, g_free);
  g_clear_pointer (&self->host, g_free);
  g_clear_pointer (&self->user, g_free);
  g_clear_pointer (&self->password, g_free);
  g_clear_pointer (&self->address, g_free);

  G_OBJECT_CLASS (calls_sip_origin_parent_class)->dispose (object);
}


static void
calls_sip_origin_finalize (GObject *object)
{
  CallsSipOrigin *self = CALLS_SIP_ORIGIN (object);

  g_hash_table_destroy (self->call_handles);

  G_OBJECT_CLASS (calls_sip_origin_parent_class)->finalize (object);
}


static void
calls_sip_origin_class_init (CallsSipOriginClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->constructed = calls_sip_origin_constructed;
  object_class->dispose = calls_sip_origin_dispose;
  object_class->finalize = calls_sip_origin_finalize;
  object_class->get_property = calls_sip_origin_get_property;
  object_class->set_property = calls_sip_origin_set_property;

  props[PROP_ACC_HOST] =
    g_param_spec_string ("host",
                         "Host",
                         "The host to connect to",
                         NULL,
                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_HOST, props[PROP_ACC_HOST]);

  props[PROP_ACC_USER] =
    g_param_spec_string ("user",
                         "User",
                         "The username",
                         NULL,
                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_USER, props[PROP_ACC_USER]);

  props[PROP_ACC_PASSWORD] =
    g_param_spec_string ("password",
                         "Password",
                         "The password",
                         NULL,
                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_PASSWORD, props[PROP_ACC_PASSWORD]);

  props[PROP_ACC_DISPLAY_NAME] =
    g_param_spec_string ("display-name",
                         "Display name",
                         "The display name",
                         NULL,
                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_DISPLAY_NAME, props[PROP_ACC_DISPLAY_NAME]);

  props[PROP_ACC_PORT] =
    g_param_spec_int ("port",
                      "Port",
                      "The port to connect to",
                      0, 65535, 0,
                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_PORT, props[PROP_ACC_PORT]);

  props[PROP_ACC_PROTOCOL] =
    g_param_spec_string ("transport-protocol",
                         "Transport protocol",
                         "The transport protocol to use for the connection",
                         NULL,
                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_PROTOCOL, props[PROP_ACC_PROTOCOL]);

  props[PROP_ACC_AUTO_CONNECT] =
    g_param_spec_boolean ("auto-connect",
                          "Auto connect",
                          "Whether to connect automatically",
                          TRUE,
                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_AUTO_CONNECT, props[PROP_ACC_AUTO_CONNECT]);


  props[PROP_ACC_DIRECT] =
    g_param_spec_boolean ("direct-mode",
                          "Direct mode",
                          "Whether to use a direct connection (no SIP server)",
                          FALSE,
                          G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_ACC_DIRECT, props[PROP_ACC_DIRECT]);

  props[PROP_ACC_LOCAL_PORT] =
    g_param_spec_int ("local-port",
                      "Local port",
                      "The local port to which the SIP stack binds to",
                      0, 65535, 0,
                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
  g_object_class_install_property (object_class, PROP_ACC_LOCAL_PORT, props[PROP_ACC_LOCAL_PORT]);

  props[PROP_SIP_CONTEXT] =
    g_param_spec_pointer ("sip-context",
                          "SIP context",
                          "The SIP context (sofia) used for our sip handles",
                          G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);
  g_object_class_install_property (object_class, PROP_SIP_CONTEXT, props[PROP_SIP_CONTEXT]);

  props[PROP_CAN_TEL] =
    g_param_spec_boolean ("can-tel",
                          "Can telephone",
                          "Whether to this account can be used for PSTN telephony",
                          FALSE,
                          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_CAN_TEL, props[PROP_CAN_TEL]);

  props[PROP_MEDIA_ENCRYPTION] =
    g_param_spec_enum ("media-encryption",
                       "Media encryption",
                       "The media encryption mode",
                       SIP_TYPE_MEDIA_ENCRYPTION,
                       SIP_MEDIA_ENCRYPTION_NONE,
                       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
  g_object_class_install_property (object_class, PROP_MEDIA_ENCRYPTION, props[PROP_MEDIA_ENCRYPTION]);

#define IMPLEMENTS(ID, NAME) \
  g_object_class_override_property (object_class, ID, NAME);    \
  props[ID] = g_object_class_find_property(object_class, NAME);

  IMPLEMENTS (PROP_ID, "id");
  IMPLEMENTS (PROP_NAME, "name");
  IMPLEMENTS (PROP_CALLS, "calls");
  IMPLEMENTS (PROP_COUNTRY_CODE, "country-code");
  IMPLEMENTS (PROP_ACC_STATE, "account-state");
  IMPLEMENTS (PROP_ACC_ADDRESS, "address");
  IMPLEMENTS (PROP_EMERGENCY_NUMBERS, "emergency-numbers");

#undef IMPLEMENTS
}


static void
calls_sip_origin_message_source_interface_init (CallsOriginInterface *iface)
{
}


static void
calls_sip_origin_origin_interface_init (CallsOriginInterface *iface)
{
  iface->dial = dial;
  iface->supports_protocol = supports_protocol;
}

static void
calls_sip_origin_accounts_interface_init (CallsAccountInterface *iface)
{
  iface->go_online = go_online;
  iface->get_address = get_address;
}


static void
calls_sip_origin_init (CallsSipOrigin *self)
{
  const char *sip_test_env = g_getenv ("CALLS_SIP_TEST");

  if (!sip_test_env || sip_test_env[0] == '\0') {
    CallsNetworkWatch *nw = calls_network_watch_get_default ();
    if (nw)
      g_signal_connect_swapped (calls_network_watch_get_default (), "network-changed",
                                G_CALLBACK (recreate_sip), self);
    else
      g_warning ("Network watch unavailable. Unable to detect network changes.");
  }

  self->call_handles = g_hash_table_new (NULL, NULL);

}

void
calls_sip_origin_set_credentials (CallsSipOrigin    *self,
                                  const char        *host,
                                  const char        *user,
                                  const char        *password,
                                  const char        *display_name,
                                  const char        *transport_protocol,
                                  gint               port,
                                  SipMediaEncryption media_encryption,
                                  gboolean           can_tel,
                                  gboolean           auto_connect)
{
  g_return_if_fail (CALLS_IS_SIP_ORIGIN (self));

  if (self->direct_mode) {
    g_warning ("Not allowed to update credentials when using direct mode");
    return;
  }

  g_return_if_fail (host);
  g_return_if_fail (user);
  g_return_if_fail (password);

  if (transport_protocol)
    g_return_if_fail (protocol_is_valid (transport_protocol));

  g_free (self->host);
  self->host = g_strdup (host);

  g_free (self->user);
  self->user = g_strdup (user);

  g_free (self->password);
  self->password = g_strdup (password);

  g_clear_pointer (&self->display_name, g_free);
  if (display_name)
    self->display_name = g_strdup (display_name);

  g_free (self->transport_protocol);
  if (transport_protocol)
    self->transport_protocol = g_strdup (transport_protocol);
  else
    self->transport_protocol = g_strdup ("UDP");

  self->port = port;
  self->can_tel = can_tel;
  self->media_encryption = media_encryption;
  self->auto_connect = auto_connect;

  update_name (self);

  recreate_sip (self);
}