Merge the pimp_my_sip branch into trunk.

The pimp_my_sip branch is being merged at this point because
it offers basic functionality, and from an API standpoint, things
are complete.

SIP work is *not* feature-complete; however, with the completion
of the SUBSCRIBE/NOTIFY API, all APIs (except a PUBLISH API) have
been created, and thus it is possible for developers to attempt
to create new SIP work.

API documentation can be found in the doxygen in the code, but
usability documentation is still lacking.



git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@386540 65c4cc65-6c06-0410-ace0-fbb531ad65f3

9 files changed, 1977 insertions, 0 deletions

diff --git a/res/res_sip/config_auth.c b/res/res_sip/config_auth.c
new file mode 100644
index 000000000..9881dd8c6
--- /dev/null
+++ b/res/res_sip/config_auth.c
@@ -0,0 +1,120 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2013, Digium, Inc.
+ *
+ * Mark Michelson <mmichelson@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#include "asterisk.h"
+
+#include <pjsip.h>
+#include <pjlib.h>
+#include "asterisk/res_sip.h"
+#include "asterisk/logger.h"
+#include "asterisk/sorcery.h"
+
+static void auth_destroy(void *obj)
+{
+	struct ast_sip_auth *auth = obj;
+	ast_string_field_free_memory(auth);
+}
+
+static void *auth_alloc(const char *name)
+{
+	struct ast_sip_auth *auth = ao2_alloc(sizeof(*auth), auth_destroy);
+
+	if (!auth) {
+		return NULL;
+	}
+
+	if (ast_string_field_init(auth, 64)) {
+		ao2_cleanup(auth);
+		return NULL;
+	}
+
+	return auth;
+}
+
+static int auth_type_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_auth *auth = obj;
+	if (!strcasecmp(var->value, "userpass")) {
+		auth->type = AST_SIP_AUTH_TYPE_USER_PASS;
+	} else if (!strcasecmp(var->value, "md5")) {
+		auth->type = AST_SIP_AUTH_TYPE_MD5;
+	} else {
+		ast_log(LOG_WARNING, "Unknown authentication storage type '%s' specified for %s\n",
+				var->value, var->name);
+		return -1;
+	}
+	return 0;
+}
+
+static int auth_apply(const struct ast_sorcery *sorcery, void *obj)
+{
+	struct ast_sip_auth *auth = obj;
+	int res = 0;
+
+	if (ast_strlen_zero(auth->auth_user)) {
+		ast_log(LOG_ERROR, "No authentication username for auth '%s'\n",
+				ast_sorcery_object_get_id(auth));
+		return -1;
+	}
+
+	switch (auth->type) {
+	case AST_SIP_AUTH_TYPE_USER_PASS:
+		if (ast_strlen_zero(auth->auth_pass)) {
+			ast_log(LOG_ERROR, "'userpass' authentication specified but no"
+					"password specified for auth '%s'\n", ast_sorcery_object_get_id(auth));
+			res = -1;
+		}
+		break;
+	case AST_SIP_AUTH_TYPE_MD5:
+		if (ast_strlen_zero(auth->md5_creds)) {
+			ast_log(LOG_ERROR, "'md5' authentication specified but no md5_cred"
+					"specified for auth '%s'\n", ast_sorcery_object_get_id(auth));
+			res = -1;
+		}
+		break;
+	}
+
+	return res;
+}
+
+/*! \brief Initialize sorcery with auth support */
+int ast_sip_initialize_sorcery_auth(struct ast_sorcery *sorcery)
+{
+	ast_sorcery_apply_default(sorcery, SIP_SORCERY_AUTH_TYPE, "config", "res_sip.conf,criteria=type=auth");
+
+	if (ast_sorcery_object_register(sorcery, SIP_SORCERY_AUTH_TYPE, auth_alloc, NULL, auth_apply)) {
+		return -1;
+	}
+
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_AUTH_TYPE, "type", "",
+			OPT_NOOP_T, 0, 0);
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_AUTH_TYPE, "username",
+			"", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_auth, auth_user));
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_AUTH_TYPE, "password",
+			"", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_auth, auth_pass));
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_AUTH_TYPE, "md5_cred",
+			"", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_auth, md5_creds));
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_AUTH_TYPE, "realm",
+			"asterisk", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_auth, realm));
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_AUTH_TYPE, "nonce_lifetime",
+			"32", OPT_UINT_T, 0, FLDSET(struct ast_sip_auth, nonce_lifetime));
+	ast_sorcery_object_field_register_custom(sorcery, SIP_SORCERY_AUTH_TYPE, "auth_type",
+			"userpass", auth_type_handler, NULL, 0, 0);
+
+	return 0;
+}
diff --git a/res/res_sip/config_domain_aliases.c b/res/res_sip/config_domain_aliases.c
new file mode 100644
index 000000000..86b4636ea
--- /dev/null
+++ b/res/res_sip/config_domain_aliases.c
@@ -0,0 +1,65 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#include "asterisk.h"
+
+#include "pjsip.h"
+#include "pjlib.h"
+#include "asterisk/res_sip.h"
+#include "asterisk/logger.h"
+#include "asterisk/sorcery.h"
+
+static void domain_alias_destroy(void *obj)
+{
+	struct ast_sip_domain_alias *alias = obj;
+
+	ast_string_field_free_memory(alias);
+}
+
+static void *domain_alias_alloc(const char *name)
+{
+	struct ast_sip_domain_alias *alias = ao2_alloc(sizeof(*alias), domain_alias_destroy);
+
+	if (!alias) {
+		return NULL;
+	}
+
+	if (ast_string_field_init(alias, 256)) {
+		ao2_cleanup(alias);
+		return NULL;
+	}
+
+	return alias;
+}
+
+/*! \brief Initialize sorcery with domain alias support */
+int ast_sip_initialize_sorcery_domain_alias(struct ast_sorcery *sorcery)
+{
+	ast_sorcery_apply_default(sorcery, SIP_SORCERY_DOMAIN_ALIAS_TYPE, "config", "res_sip.conf,criteria=type=domain_alias");
+
+	if (ast_sorcery_object_register(sorcery, SIP_SORCERY_DOMAIN_ALIAS_TYPE, domain_alias_alloc, NULL, NULL)) {
+		return -1;
+	}
+
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_DOMAIN_ALIAS_TYPE, "type", "",
+			OPT_NOOP_T, 0, 0);
+	ast_sorcery_object_field_register(sorcery, SIP_SORCERY_DOMAIN_ALIAS_TYPE, "domain",
+			"", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_domain_alias, domain));
+
+	return 0;
+}
diff --git a/res/res_sip/config_transport.c b/res/res_sip/config_transport.c
new file mode 100644
index 000000000..eb89ee44e
--- /dev/null
+++ b/res/res_sip/config_transport.c
@@ -0,0 +1,299 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#include "asterisk.h"
+
+#include <pjsip.h>
+#include <pjlib.h>
+
+#include "asterisk/res_sip.h"
+#include "asterisk/logger.h"
+#include "asterisk/astobj2.h"
+#include "asterisk/sorcery.h"
+#include "asterisk/acl.h"
+
+static int destroy_transport_state(void *data)
+{
+	pjsip_transport *transport = data;
+	pjsip_transport_shutdown(transport);
+	return 0;
+}
+
+/*! \brief Destructor for transport state information */
+static void transport_state_destroy(void *obj)
+{
+	struct ast_sip_transport_state *state = obj;
+
+	if (state->transport) {
+		ast_sip_push_task_synchronous(NULL, destroy_transport_state, state->transport);
+	}
+}
+
+/*! \brief Destructor for transport */
+static void transport_destroy(void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+
+	ast_string_field_free_memory(transport);
+	ast_free_ha(transport->localnet);
+
+	if (transport->external_address_refresher) {
+		ast_dnsmgr_release(transport->external_address_refresher);
+	}
+
+	ao2_cleanup(transport->state);
+}
+
+/*! \brief Allocator for transport */
+static void *transport_alloc(const char *name)
+{
+	struct ast_sip_transport *transport = ao2_alloc(sizeof(*transport), transport_destroy);
+
+	if (!transport) {
+		return NULL;
+	}
+
+	if (ast_string_field_init(transport, 256)) {
+		ao2_cleanup(transport);
+		return NULL;
+	}
+
+	pjsip_tls_setting_default(&transport->tls);
+	transport->tls.ciphers = transport->ciphers;
+
+	return transport;
+}
+
+/*! \brief Apply handler for transports */
+static int transport_apply(const struct ast_sorcery *sorcery, void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+	RAII_VAR(struct ast_sip_transport *, existing, ast_sorcery_retrieve_by_id(sorcery, "transport", ast_sorcery_object_get_id(obj)), ao2_cleanup);
+	pj_status_t res = -1;
+
+	if (!existing || !existing->state) {
+		if (!(transport->state = ao2_alloc(sizeof(*transport->state), transport_state_destroy))) {
+			ast_log(LOG_ERROR, "Transport state for '%s' could not be allocated\n", ast_sorcery_object_get_id(obj));
+			return -1;
+		}
+	} else {
+		transport->state = existing->state;
+		ao2_ref(transport->state, +1);
+	}
+
+	/* Once active a transport can not be reconfigured */
+	if (transport->state->transport || transport->state->factory) {
+		return -1;
+	}
+
+	/* Set default port if not present */
+	if (!pj_sockaddr_get_port(&transport->host)) {
+		pj_sockaddr_set_port(&transport->host, (transport->type == AST_SIP_TRANSPORT_TLS) ? 5061 : 5060);
+	}
+
+	/* Now that we know what address family we can set up a dnsmgr refresh for the external media address if present */
+	if (!ast_strlen_zero(transport->external_signaling_address)) {
+		if (transport->host.addr.sa_family == pj_AF_INET()) {
+			transport->external_address.ss.ss_family = AF_INET;
+		} else if (transport->host.addr.sa_family == pj_AF_INET6()) {
+			transport->external_address.ss.ss_family = AF_INET6;
+		} else {
+			ast_log(LOG_ERROR, "Unknown address family for transport '%s', could not get external signaling address\n",
+					ast_sorcery_object_get_id(obj));
+			return -1;
+		}
+
+		if (ast_dnsmgr_lookup(transport->external_signaling_address, &transport->external_address, &transport->external_address_refresher, NULL) < 0) {
+			ast_log(LOG_ERROR, "Could not create dnsmgr for external signaling address on '%s'\n", ast_sorcery_object_get_id(obj));
+			return -1;
+		}
+	}
+
+	if (transport->type == AST_SIP_TRANSPORT_UDP) {
+		if (transport->host.addr.sa_family == pj_AF_INET()) {
+			res = pjsip_udp_transport_start(ast_sip_get_pjsip_endpoint(), &transport->host.ipv4, NULL, transport->async_operations, &transport->state->transport);
+		} else if (transport->host.addr.sa_family == pj_AF_INET6()) {
+			res = pjsip_udp_transport_start6(ast_sip_get_pjsip_endpoint(), &transport->host.ipv6, NULL, transport->async_operations, &transport->state->transport);
+		}
+	} else if (transport->type == AST_SIP_TRANSPORT_TCP) {
+		pjsip_tcp_transport_cfg cfg;
+
+		pjsip_tcp_transport_cfg_default(&cfg, transport->host.addr.sa_family);
+		cfg.bind_addr = transport->host;
+		cfg.async_cnt = transport->async_operations;
+
+		res = pjsip_tcp_transport_start3(ast_sip_get_pjsip_endpoint(), &cfg, &transport->state->factory);
+	} else if (transport->type == AST_SIP_TRANSPORT_TLS) {
+		transport->tls.ca_list_file = pj_str((char*)transport->ca_list_file);
+		transport->tls.cert_file = pj_str((char*)transport->cert_file);
+		transport->tls.privkey_file = pj_str((char*)transport->privkey_file);
+		transport->tls.password = pj_str((char*)transport->password);
+
+		res = pjsip_tls_transport_start2(ast_sip_get_pjsip_endpoint(), &transport->tls, &transport->host, NULL, transport->async_operations, &transport->state->factory);
+	}
+
+	if (res != PJ_SUCCESS) {
+		char msg[PJ_ERR_MSG_SIZE];
+
+		pjsip_strerror(res, msg, sizeof(msg));
+		ast_log(LOG_ERROR, "Transport '%s' could not be started: %s\n", ast_sorcery_object_get_id(obj), msg);
+		return -1;
+	}
+	return 0;
+}
+
+/*! \brief Custom handler for turning a string protocol into an enum */
+static int transport_protocol_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+
+	if (!strcasecmp(var->value, "udp")) {
+		transport->type = AST_SIP_TRANSPORT_UDP;
+	} else if (!strcasecmp(var->value, "tcp")) {
+		transport->type = AST_SIP_TRANSPORT_TCP;
+	} else if (!strcasecmp(var->value, "tls")) {
+		transport->type = AST_SIP_TRANSPORT_TLS;
+	} else {
+		/* TODO: Implement websockets */
+		return -1;
+	}
+
+	return 0;
+}
+
+/*! \brief Custom handler for turning a string bind into a pj_sockaddr */
+static int transport_bind_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+	pj_str_t buf;
+
+	return (pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, var->value), &transport->host) != PJ_SUCCESS) ? -1 : 0;
+}
+
+/*! \brief Custom handler for TLS boolean settings */
+static int transport_tls_bool_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+
+	if (!strcasecmp(var->name, "verify_server")) {
+		transport->tls.verify_server = ast_true(var->value) ? PJ_TRUE : PJ_FALSE;
+	} else if (!strcasecmp(var->name, "verify_client")) {
+		transport->tls.verify_client = ast_true(var->value) ? PJ_TRUE : PJ_FALSE;
+	} else if (!strcasecmp(var->name, "require_client_cert")) {
+		transport->tls.require_client_cert = ast_true(var->value) ? PJ_TRUE : PJ_FALSE;
+	} else {
+		return -1;
+	}
+
+	return 0;
+}
+
+/*! \brief Custom handler for TLS method setting */
+static int transport_tls_method_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+
+	if (!strcasecmp(var->value, "default")) {
+		transport->tls.method = PJSIP_SSL_DEFAULT_METHOD;
+	} else if (!strcasecmp(var->value, "unspecified")) {
+		transport->tls.method = PJSIP_SSL_UNSPECIFIED_METHOD;
+	} else if (!strcasecmp(var->value, "tlsv1")) {
+		transport->tls.method = PJSIP_TLSV1_METHOD;
+	} else if (!strcasecmp(var->value, "sslv2")) {
+		transport->tls.method = PJSIP_SSLV2_METHOD;
+	} else if (!strcasecmp(var->value, "sslv3")) {
+		transport->tls.method = PJSIP_SSLV3_METHOD;
+	} else if (!strcasecmp(var->value, "sslv23")) {
+		transport->tls.method = PJSIP_SSLV23_METHOD;
+	} else {
+		return -1;
+	}
+
+	return 0;
+}
+
+/*! \brief Custom handler for TLS cipher setting */
+static int transport_tls_cipher_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+	pj_ssl_cipher cipher;
+
+	if (transport->tls.ciphers_num == (SIP_TLS_MAX_CIPHERS - 1)) {
+		return -1;
+	}
+
+	/* TODO: Check this over/tweak - it's taken from pjsua for now */
+	if (!strnicmp(var->value, "0x", 2)) {
+		pj_str_t cipher_st = pj_str((char*)var->value + 2);
+		cipher = pj_strtoul2(&cipher_st, NULL, 16);
+	} else {
+		cipher = atoi(var->value);
+	}
+
+	if (pj_ssl_cipher_is_supported(cipher)) {
+		transport->ciphers[transport->tls.ciphers_num++] = cipher;
+		return 0;
+	} else {
+		ast_log(LOG_ERROR, "Cipher '%s' is unsupported\n", var->value);
+		return -1;
+	}
+}
+
+/*! \brief Custom handler for localnet setting */
+static int transport_localnet_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_transport *transport = obj;
+	int error = 0;
+
+	if (!(transport->localnet = ast_append_ha("d", var->value, transport->localnet, &error))) {
+		return -1;
+	}
+
+	return error;
+}
+
+/*! \brief Initialize sorcery with transport support */
+int ast_sip_initialize_sorcery_transport(struct ast_sorcery *sorcery)
+{
+	ast_sorcery_apply_default(sorcery, "transport", "config", "res_sip.conf,criteria=type=transport");
+
+	if (ast_sorcery_object_register(sorcery, "transport", transport_alloc, NULL, transport_apply)) {
+		return -1;
+	}
+
+	ast_sorcery_object_field_register(sorcery, "transport", "type", "", OPT_NOOP_T, 0, 0);
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "protocol", "udp", transport_protocol_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "bind", "", transport_bind_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sorcery, "transport", "async_operations", "1", OPT_UINT_T, 0, FLDSET(struct ast_sip_transport, async_operations));
+	ast_sorcery_object_field_register(sorcery, "transport", "ca_list_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, ca_list_file));
+	ast_sorcery_object_field_register(sorcery, "transport", "cert_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, cert_file));
+	ast_sorcery_object_field_register(sorcery, "transport", "privkey_file", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, privkey_file));
+	ast_sorcery_object_field_register(sorcery, "transport", "password", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, password));
+	ast_sorcery_object_field_register(sorcery, "transport", "external_signaling_address", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, external_signaling_address));
+	ast_sorcery_object_field_register(sorcery, "transport", "external_signaling_port", "0", OPT_UINT_T, PARSE_IN_RANGE, FLDSET(struct ast_sip_transport, external_signaling_port), 0, 65535);
+	ast_sorcery_object_field_register(sorcery, "transport", "external_media_address", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, external_media_address));
+	ast_sorcery_object_field_register(sorcery, "transport", "domain", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_transport, domain));
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "verify_server", "", transport_tls_bool_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "verify_client", "", transport_tls_bool_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "require_client_cert", "", transport_tls_bool_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "method", "", transport_tls_method_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "cipher", "", transport_tls_cipher_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sorcery, "transport", "localnet", "", transport_localnet_handler, NULL, 0, 0);
+
+	return 0;
+}
diff --git a/res/res_sip/include/res_sip_private.h b/res/res_sip/include/res_sip_private.h
new file mode 100644
index 000000000..318510aae
--- /dev/null
+++ b/res/res_sip/include/res_sip_private.h
@@ -0,0 +1,57 @@
+/*
+ * res_sip.h
+ *
+ *  Created on: Jan 25, 2013
+ *      Author: mjordan
+ */
+
+#ifndef RES_SIP_PRIVATE_H_
+#define RES_SIP_PRIVATE_H_
+
+struct ao2_container;
+
+/*!
+ * \brief Initialize the configuration for res_sip
+ */
+int ast_res_sip_initialize_configuration(void);
+
+/*!
+ * \brief Annihilate the configuration objects
+ */
+void ast_res_sip_destroy_configuration(void);
+
+/*!
+ * \brief Reload the configuration
+ */
+int ast_res_sip_reload_configuration(void);
+
+/*!
+ * \brief Initialize OPTIONS request handling.
+ *
+ * XXX This currently includes qualifying peers. It shouldn't.
+ * That should go into a registrar. When that occurs, we won't
+ * need the reload stuff.
+ *
+ * \param reload Reload options handling
+ *
+ * \retval 0 on success
+ * \retval other on failure
+ */
+int ast_res_sip_init_options_handling(int reload);
+
+/*!
+ * \brief Initialize outbound authentication support
+ *
+ * \retval 0 Success
+ * \retval non-zero Failure
+ */
+int ast_sip_initialize_outbound_authentication(void);
+
+/*!
+ * \brief Get the current defined endpoints
+ *
+ * \retval The current endpoints loaded by res_sip
+ */
+struct ao2_container *ast_res_sip_get_endpoints(void);
+
+#endif /* RES_SIP_PRIVATE_H_ */
diff --git a/res/res_sip/location.c b/res/res_sip/location.c
new file mode 100644
index 000000000..91521c813
--- /dev/null
+++ b/res/res_sip/location.c
@@ -0,0 +1,262 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2013, Digium, Inc.
+ *
+ * Joshua Colp <jcolp@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#include "asterisk.h"
+#include "pjsip.h"
+#include "pjlib.h"
+
+#include "asterisk/res_sip.h"
+#include "asterisk/logger.h"
+#include "asterisk/astobj2.h"
+#include "asterisk/sorcery.h"
+
+/*! \brief Destructor for AOR */
+static void aor_destroy(void *obj)
+{
+	struct ast_sip_aor *aor = obj;
+
+	ao2_cleanup(aor->permanent_contacts);
+	ast_string_field_free_memory(aor);
+}
+
+/*! \brief Allocator for AOR */
+static void *aor_alloc(const char *name)
+{
+	struct ast_sip_aor *aor = ao2_alloc_options(sizeof(struct ast_sip_aor), aor_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
+	if (!aor) {
+		return NULL;
+	}
+	ast_string_field_init(aor, 128);
+	return aor;
+}
+
+/*! \brief Destructor for contact */
+static void contact_destroy(void *obj)
+{
+	struct ast_sip_contact *contact = obj;
+
+	ast_string_field_free_memory(contact);
+}
+
+/*! \brief Allocator for contact */
+static void *contact_alloc(const char *name)
+{
+	struct ast_sip_contact *contact = ao2_alloc_options(sizeof(*contact), contact_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
+
+	if (!contact) {
+		return NULL;
+	}
+
+	if (ast_string_field_init(contact, 256)) {
+		ao2_cleanup(contact);
+		return NULL;
+	}
+
+	return contact;
+}
+
+struct ast_sip_aor *ast_sip_location_retrieve_aor(const char *aor_name)
+{
+	return ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "aor", aor_name);
+}
+
+/*! \brief Internal callback function which deletes and unlinks any expired contacts */
+static int contact_expire(void *obj, void *arg, int flags)
+{
+	struct ast_sip_contact *contact = obj;
+
+	/* If the contact has not yet expired it is valid */
+	if (ast_tvdiff_ms(contact->expiration_time, ast_tvnow()) > 0) {
+		return 0;
+	}
+
+	ast_sip_location_delete_contact(contact);
+
+	return CMP_MATCH;
+}
+
+/*! \brief Internal callback function which links static contacts into another container */
+static int contact_link_static(void *obj, void *arg, int flags)
+{
+	struct ao2_container *dest = arg;
+
+	ao2_link_flags(dest, obj, OBJ_NOLOCK);
+	return 0;
+}
+
+/*! \brief Simple callback function which returns immediately, used to grab the first contact of an AOR */
+static int contact_find_first(void *obj, void *arg, int flags)
+{
+	return CMP_MATCH | CMP_STOP;
+}
+
+struct ast_sip_contact *ast_sip_location_retrieve_first_aor_contact(const struct ast_sip_aor *aor)
+{
+	RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
+	struct ast_sip_contact *contact;
+
+	contacts = ast_sip_location_retrieve_aor_contacts(aor);
+	if (!contacts || (ao2_container_count(contacts) == 0)) {
+		return NULL;
+	}
+
+	contact = ao2_callback(contacts, OBJ_NOLOCK, contact_find_first, NULL);
+	return contact;
+}
+
+struct ao2_container *ast_sip_location_retrieve_aor_contacts(const struct ast_sip_aor *aor)
+{
+	/* Give enough space for ^ at the beginning and ;@ at the end, since that is our object naming scheme */
+	char regex[strlen(ast_sorcery_object_get_id(aor)) + 4];
+	struct ao2_container *contacts;
+
+	snprintf(regex, sizeof(regex), "^%s;@", ast_sorcery_object_get_id(aor));
+
+	if (!(contacts = ast_sorcery_retrieve_by_regex(ast_sip_get_sorcery(), "contact", regex))) {
+		return NULL;
+	}
+
+	/* Prune any expired contacts and delete them, we do this first because static contacts can never expire */
+	ao2_callback(contacts, OBJ_NOLOCK | OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK, contact_expire, NULL);
+
+	/* Add any permanent contacts from the AOR */
+	if (aor->permanent_contacts) {
+		ao2_callback(aor->permanent_contacts, OBJ_NOLOCK | OBJ_NODATA, contact_link_static, contacts);
+	}
+
+	return contacts;
+}
+
+struct ast_sip_contact *ast_sip_location_retrieve_contact_from_aor_list(const char *aor_list)
+{
+	char *aor_name;
+	char *rest;
+	struct ast_sip_contact *contact = NULL;
+
+	/* If the location is still empty we have nowhere to go */
+	if (ast_strlen_zero(aor_list) || !(rest = ast_strdupa(aor_list))) {
+		ast_log(LOG_WARNING, "Unable to determine contacts from empty aor list\n");
+		return NULL;
+	}
+
+	while ((aor_name = strsep(&rest, ","))) {
+		RAII_VAR(struct ast_sip_aor *, aor, ast_sip_location_retrieve_aor(aor_name), ao2_cleanup);
+		RAII_VAR(struct ao2_container *, contacts, NULL, ao2_cleanup);
+
+		if (!aor) {
+			continue;
+		}
+		contact = ast_sip_location_retrieve_first_aor_contact(aor);
+		/* If a valid contact is available use its URI for dialing */
+		if (contact) {
+			break;
+		}
+	}
+
+	return contact;
+}
+
+struct ast_sip_contact *ast_sip_location_retrieve_contact(const char *contact_name)
+{
+	return ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "contact", contact_name);
+}
+
+int ast_sip_location_add_contact(struct ast_sip_aor *aor, const char *uri, struct timeval expiration_time)
+{
+	char name[AST_UUID_STR_LEN];
+	RAII_VAR(struct ast_sip_contact *, contact, NULL, ao2_cleanup);
+
+	snprintf(name, sizeof(name), "%s;@%s", ast_sorcery_object_get_id(aor), uri);
+
+	if (!(contact = ast_sorcery_alloc(ast_sip_get_sorcery(), "contact", name))) {
+		return -1;
+	}
+
+	ast_string_field_set(contact, uri, uri);
+	contact->expiration_time = expiration_time;
+
+	return ast_sorcery_create(ast_sip_get_sorcery(), contact);
+}
+
+int ast_sip_location_update_contact(struct ast_sip_contact *contact)
+{
+	return ast_sorcery_update(ast_sip_get_sorcery(), contact);
+}
+
+int ast_sip_location_delete_contact(struct ast_sip_contact *contact)
+{
+	return ast_sorcery_delete(ast_sip_get_sorcery(), contact);
+}
+
+/*! \brief Custom handler for translating from a string timeval to actual structure */
+static int expiration_str2struct(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_contact *contact = obj;
+	return ast_get_timeval(var->value, &contact->expiration_time, ast_tv(0, 0), NULL);
+}
+
+/*! \brief Custom handler for translating from an actual structure timeval to string */
+static int expiration_struct2str(const void *obj, const intptr_t *args, char **buf)
+{
+	const struct ast_sip_contact *contact = obj;
+	return (ast_asprintf(buf, "%lu", contact->expiration_time.tv_sec) < 0) ? -1 : 0;
+}
+
+/*! \brief Custom handler for permanent URIs */
+static int permanent_uri_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_aor *aor = obj;
+	RAII_VAR(struct ast_sip_contact *, contact, NULL, ao2_cleanup);
+
+	if ((!aor->permanent_contacts && !(aor->permanent_contacts = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1, NULL, NULL))) ||
+		!(contact = ast_sorcery_alloc(ast_sip_get_sorcery(), "contact", NULL))) {
+		return -1;
+	}
+
+	ast_string_field_set(contact, uri, var->value);
+	ao2_link_flags(aor->permanent_contacts, contact, OBJ_NOLOCK);
+
+	return 0;
+}
+
+/*! \brief Initialize sorcery with location support */
+int ast_sip_initialize_sorcery_location(struct ast_sorcery *sorcery)
+{
+	ast_sorcery_apply_default(sorcery, "contact", "astdb", "registrar");
+	ast_sorcery_apply_default(sorcery, "aor", "config", "res_sip.conf,criteria=type=aor");
+
+	if (ast_sorcery_object_register(sorcery, "contact", contact_alloc, NULL, NULL) ||
+		ast_sorcery_object_register(sorcery, "aor", aor_alloc, NULL, NULL)) {
+		return -1;
+	}
+
+	ast_sorcery_object_field_register(sorcery, "contact", "type", "", OPT_NOOP_T, 0, 0);
+	ast_sorcery_object_field_register(sorcery, "contact", "uri", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_contact, uri));
+	ast_sorcery_object_field_register_custom(sorcery, "contact", "expiration_time", "", expiration_str2struct, expiration_struct2str, 0, 0);
+
+	ast_sorcery_object_field_register(sorcery, "aor", "type", "", OPT_NOOP_T, 0, 0);
+	ast_sorcery_object_field_register(sorcery, "aor", "minimum_expiration", "60", OPT_UINT_T, 0, FLDSET(struct ast_sip_aor, minimum_expiration));
+	ast_sorcery_object_field_register(sorcery, "aor", "maximum_expiration", "7200", OPT_UINT_T, 0, FLDSET(struct ast_sip_aor, maximum_expiration));
+	ast_sorcery_object_field_register(sorcery, "aor", "default_expiration", "3600", OPT_UINT_T, 0, FLDSET(struct ast_sip_aor, default_expiration));
+	ast_sorcery_object_field_register(sorcery, "aor", "max_contacts", "0", OPT_UINT_T, 0, FLDSET(struct ast_sip_aor, max_contacts));
+	ast_sorcery_object_field_register(sorcery, "aor", "remove_existing", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_aor, remove_existing));
+	ast_sorcery_object_field_register_custom(sorcery, "aor", "contact", "", permanent_uri_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sorcery, "aor", "mailboxes", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_aor, mailboxes));
+
+	return 0;
+}
diff --git a/res/res_sip/sip_configuration.c b/res/res_sip/sip_configuration.c
new file mode 100644
index 000000000..489ba6aec
--- /dev/null
+++ b/res/res_sip/sip_configuration.c
@@ -0,0 +1,463 @@
+/*
+ * sip_cli_commands.c
+ *
+ *  Created on: Jan 25, 2013
+ *      Author: mjordan
+ */
+
+#include "asterisk.h"
+
+#include <pjsip.h>
+#include <pjsip_ua.h>
+
+#include "asterisk/res_sip.h"
+#include "include/res_sip_private.h"
+#include "asterisk/cli.h"
+#include "asterisk/astobj2.h"
+#include "asterisk/utils.h"
+#include "asterisk/sorcery.h"
+#include "asterisk/callerid.h"
+
+static struct ast_sorcery *sip_sorcery;
+
+static char *handle_cli_show_endpoints(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	RAII_VAR(struct ao2_container *, endpoints, NULL, ao2_cleanup);
+	struct ao2_iterator it_endpoints;
+	struct ast_sip_endpoint *endpoint;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "sip show endpoints";
+		e->usage =
+			"Usage: sip show endpoints\n"
+			"       Show the registered SIP endpoints\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	endpoints = ast_res_sip_get_endpoints();
+	if (!endpoints) {
+		return CLI_FAILURE;
+	}
+
+	if (!ao2_container_count(endpoints)) {
+		ast_cli(a->fd, "No endpoints found\n");
+		return CLI_SUCCESS;
+	}
+
+	ast_cli(a->fd, "Endpoints:\n");
+	it_endpoints = ao2_iterator_init(endpoints, 0);
+	while ((endpoint = ao2_iterator_next(&it_endpoints))) {
+		ast_cli(a->fd, "%s\n", ast_sorcery_object_get_id(endpoint));
+		ao2_ref(endpoint, -1);
+	}
+	ao2_iterator_destroy(&it_endpoints);
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cli_commands[] = {
+	AST_CLI_DEFINE(handle_cli_show_endpoints, "Show SIP Endpoints"),
+};
+
+static int dtmf_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	if (!strcasecmp(var->value, "rfc4733")) {
+		endpoint->dtmf = AST_SIP_DTMF_RFC_4733;
+	} else if (!strcasecmp(var->value, "inband")) {
+		endpoint->dtmf = AST_SIP_DTMF_INBAND;
+	} else if (!strcasecmp(var->value, "info")) {
+		endpoint->dtmf = AST_SIP_DTMF_INFO;
+	} else if (!strcasecmp(var->value, "none")) {
+		endpoint->dtmf = AST_SIP_DTMF_NONE;
+	} else {
+		return -1;
+	}
+
+	return 0;
+}
+
+static int prack_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	if (ast_true(var->value)) {
+		endpoint->extensions |= PJSIP_INV_SUPPORT_100REL;
+	} else if (ast_false(var->value)) {
+		endpoint->extensions &= PJSIP_INV_SUPPORT_100REL;
+	} else if (!strcasecmp(var->value, "required")) {
+		endpoint->extensions |= PJSIP_INV_REQUIRE_100REL;
+	} else {
+		return -1;
+	}
+
+	return 0;
+}
+
+static int timers_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	if (ast_true(var->value)) {
+		endpoint->extensions |= PJSIP_INV_SUPPORT_TIMER;
+	} else if (ast_false(var->value)) {
+		endpoint->extensions &= PJSIP_INV_SUPPORT_TIMER;
+	} else if (!strcasecmp(var->value, "required")) {
+		endpoint->extensions |= PJSIP_INV_REQUIRE_TIMER;
+	} else if (!strcasecmp(var->value, "always")) {
+		endpoint->extensions |= PJSIP_INV_ALWAYS_USE_TIMER;
+	} else {
+		return -1;
+	}
+
+	return 0;
+}
+
+static void destroy_auths(const char **auths, size_t num_auths)
+{
+	int i;
+	for (i = 0; i < num_auths; ++i) {
+		ast_free((char *) auths[i]);
+	}
+	ast_free(auths);
+}
+
+#define AUTH_INCREMENT 4
+
+static const char **auth_alloc(const char *value, size_t *num_auths)
+{
+	char *auths = ast_strdupa(value);
+	char *val;
+	int num_alloced = 0;
+	const char **alloced_auths = NULL;
+
+	while ((val = strsep(&auths, ","))) {
+		if (*num_auths >= num_alloced) {
+			size_t size;
+			num_alloced += AUTH_INCREMENT;
+			size = num_alloced * sizeof(char *);
+			alloced_auths = ast_realloc(alloced_auths, size);
+			if (!alloced_auths) {
+				goto failure;
+			}
+		}
+		alloced_auths[*num_auths] = ast_strdup(val);
+		if (!alloced_auths[*num_auths]) {
+			goto failure;
+		}
+		++(*num_auths);
+	}
+	return alloced_auths;
+
+failure:
+	destroy_auths(alloced_auths, *num_auths);
+	return NULL;
+}
+
+static int inbound_auth_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	endpoint->sip_inbound_auths = auth_alloc(var->value, &endpoint->num_inbound_auths);
+	if (!endpoint->sip_inbound_auths) {
+		return -1;
+	}
+	return 0;
+}
+static int outbound_auth_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	endpoint->sip_outbound_auths = auth_alloc(var->value, &endpoint->num_outbound_auths);
+	if (!endpoint->sip_outbound_auths) {
+		return -1;
+	}
+	return 0;
+}
+
+static int ident_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+	char *idents = ast_strdupa(var->value);
+	char *val;
+
+	while ((val = strsep(&idents, ","))) {
+		if (!strcasecmp(val, "username")) {
+			endpoint->ident_method |= AST_SIP_ENDPOINT_IDENTIFY_BY_USERNAME;
+		} else if (!strcasecmp(val, "location")) {
+			endpoint->ident_method |= AST_SIP_ENDPOINT_IDENTIFY_BY_LOCATION;
+		} else {
+			ast_log(LOG_ERROR, "Unrecognized identification method %s specified for endpoint %s\n",
+					val, ast_sorcery_object_get_id(endpoint));
+			return -1;
+		}
+	}
+	return 0;
+}
+
+static int direct_media_method_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	if (!strcasecmp(var->value, "invite") || !strcasecmp(var->value, "reinvite")) {
+		endpoint->direct_media_method = AST_SIP_SESSION_REFRESH_METHOD_INVITE;
+	} else if (!strcasecmp(var->value, "update")) {
+		endpoint->direct_media_method = AST_SIP_SESSION_REFRESH_METHOD_UPDATE;
+	} else {
+		ast_log(LOG_NOTICE, "Unrecognized option value %s for %s on endpoint %s\n",
+				var->value, var->name, ast_sorcery_object_get_id(endpoint));
+		return -1;
+	}
+	return 0;
+}
+
+static int direct_media_glare_mitigation_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	if (!strcasecmp(var->value, "none")) {
+		endpoint->direct_media_glare_mitigation = AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_NONE;
+	} else if (!strcasecmp(var->value, "outgoing")) {
+		endpoint->direct_media_glare_mitigation = AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_OUTGOING;
+	} else if (!strcasecmp(var->value, "incoming")) {
+		endpoint->direct_media_glare_mitigation = AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_INCOMING;
+	} else {
+		ast_log(LOG_NOTICE, "Unrecognized option value %s for %s on endpoint %s\n",
+				var->value, var->name, ast_sorcery_object_get_id(endpoint));
+		return -1;
+	}
+
+	return 0;
+}
+
+static int caller_id_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+	char cid_name[80] = { '\0' };
+	char cid_num[80] = { '\0' };
+
+	ast_callerid_split(var->value, cid_name, sizeof(cid_name), cid_num, sizeof(cid_num));
+	if (!ast_strlen_zero(cid_name)) {
+		endpoint->id.name.str = ast_strdup(cid_name);
+		if (!endpoint->id.name.str) {
+			return -1;
+		}
+		endpoint->id.name.valid = 1;
+	}
+	if (!ast_strlen_zero(cid_num)) {
+		endpoint->id.number.str = ast_strdup(cid_num);
+		if (!endpoint->id.number.str) {
+			return -1;
+		}
+		endpoint->id.number.valid = 1;
+	}
+	return 0;
+}
+
+static int caller_id_privacy_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+	int callingpres = ast_parse_caller_presentation(var->value);
+	if (callingpres == -1 && sscanf(var->value, "%d", &callingpres) != 1) {
+		return -1;
+	}
+	endpoint->id.number.presentation = callingpres;
+	endpoint->id.name.presentation = callingpres;
+	return 0;
+}
+
+static int caller_id_tag_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+	endpoint->id.tag = ast_strdup(var->value);
+	return endpoint->id.tag ? 0 : -1;
+}
+
+static void *sip_nat_hook_alloc(const char *name)
+{
+	return ao2_alloc(sizeof(struct ast_sip_nat_hook), NULL);
+}
+
+int ast_res_sip_initialize_configuration(void)
+{
+	if (ast_cli_register_multiple(cli_commands, ARRAY_LEN(cli_commands))) {
+		return -1;
+	}
+
+	if (!(sip_sorcery = ast_sorcery_open())) {
+		ast_log(LOG_ERROR, "Failed to open SIP sorcery failed to open\n");
+		return -1;
+	}
+
+	ast_sorcery_apply_config(sip_sorcery, "res_sip");
+
+	if (ast_sip_initialize_sorcery_auth(sip_sorcery)) {
+		ast_log(LOG_ERROR, "Failed to register SIP authentication support\n");
+		ast_sorcery_unref(sip_sorcery);
+		sip_sorcery = NULL;
+		return -1;
+	}
+
+	ast_sorcery_apply_default(sip_sorcery, "endpoint", "config", "res_sip.conf,criteria=type=endpoint");
+
+	ast_sorcery_apply_default(sip_sorcery, "nat_hook", "memory", NULL);
+
+	if (ast_sorcery_object_register(sip_sorcery, "endpoint", ast_sip_endpoint_alloc, NULL, NULL)) {
+		ast_log(LOG_ERROR, "Failed to register SIP endpoint object with sorcery\n");
+		ast_sorcery_unref(sip_sorcery);
+		sip_sorcery = NULL;
+		return -1;
+	}
+
+	ast_sorcery_object_register(sip_sorcery, "nat_hook", sip_nat_hook_alloc, NULL, NULL);
+
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "type", "", OPT_NOOP_T, 0, 0);
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "context", "default", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, context));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "disallow", "", OPT_CODEC_T, 0, FLDSET(struct ast_sip_endpoint, prefs, codecs));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "allow", "", OPT_CODEC_T, 1, FLDSET(struct ast_sip_endpoint, prefs, codecs));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "qualify_frequency", 0, OPT_UINT_T, PARSE_IN_RANGE, FLDSET(struct ast_sip_endpoint, qualify_frequency), 0, 86400);
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "dtmfmode", "rfc4733", dtmf_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "rtp_ipv6", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, rtp_ipv6));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "rtp_symmetric", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, rtp_symmetric));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "ice_support", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, ice_support));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "use_ptime", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, use_ptime));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "force_rport", "yes", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, force_rport));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "rewrite_contact", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, rewrite_contact));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "transport", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, transport));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "outbound_proxy", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, outbound_proxy));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "mohsuggest", "default", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, mohsuggest));
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "100rel", "yes", prack_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "timers", "yes", timers_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "timers_min_se", "90", OPT_UINT_T, 0, FLDSET(struct ast_sip_endpoint, min_se));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "timers_sess_expires", "1800", OPT_UINT_T, 0, FLDSET(struct ast_sip_endpoint, sess_expires));
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "auth", "", inbound_auth_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "outbound_auth", "", outbound_auth_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "aors", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, aors));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "external_media_address", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, external_media_address));
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "identify_by", "username,location", ident_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "direct_media", "yes", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, direct_media));
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "direct_media_method", "invite", direct_media_method_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "direct_media_glare_mitigation", "none", direct_media_glare_mitigation_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "disable_direct_media_on_nat", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, disable_direct_media_on_nat));
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "callerid", "", caller_id_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "callerid_privacy", "", caller_id_privacy_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "callerid_tag", "", caller_id_tag_handler, NULL, 0, 0);
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "trust_id_inbound", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, trust_id_inbound));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "trust_id_outbound", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, trust_id_outbound));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "send_pai", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, send_pai));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "send_rpid", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, send_rpid));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "mailboxes", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, mailboxes));
+	ast_sorcery_object_field_register(sip_sorcery, "endpoint", "aggregate_mwi", "yes", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, aggregate_mwi));
+
+	if (ast_sip_initialize_sorcery_transport(sip_sorcery)) {
+		ast_log(LOG_ERROR, "Failed to register SIP transport support with sorcery\n");
+		ast_sorcery_unref(sip_sorcery);
+		sip_sorcery = NULL;
+		return -1;
+	}
+
+	if (ast_sip_initialize_sorcery_location(sip_sorcery)) {
+		ast_log(LOG_ERROR, "Failed to register SIP location support with sorcery\n");
+		ast_sorcery_unref(sip_sorcery);
+		sip_sorcery = NULL;
+		return -1;
+	}
+
+	if (ast_sip_initialize_sorcery_domain_alias(sip_sorcery)) {
+		ast_log(LOG_ERROR, "Failed to register SIP domain aliases support with sorcery\n");
+		ast_sorcery_unref(sip_sorcery);
+		sip_sorcery = NULL;
+		return -1;
+	}
+
+	ast_sorcery_load(sip_sorcery);
+
+	return 0;
+}
+
+void ast_res_sip_destroy_configuration(void)
+{
+	ast_cli_unregister_multiple(cli_commands, ARRAY_LEN(cli_commands));
+	ast_sorcery_unref(sip_sorcery);
+}
+
+int ast_res_sip_reload_configuration(void)
+{
+	if (sip_sorcery) {
+		ast_sorcery_reload(sip_sorcery);
+	}
+	return 0;
+}
+
+static void endpoint_destructor(void* obj)
+{
+	struct ast_sip_endpoint *endpoint = obj;
+
+	ast_string_field_free_memory(endpoint);
+
+	if (endpoint->codecs) {
+		ast_format_cap_destroy(endpoint->codecs);
+	}
+	destroy_auths(endpoint->sip_inbound_auths, endpoint->num_inbound_auths);
+	destroy_auths(endpoint->sip_outbound_auths, endpoint->num_outbound_auths);
+	ast_party_id_free(&endpoint->id);
+}
+
+void *ast_sip_endpoint_alloc(const char *name)
+{
+	struct ast_sip_endpoint *endpoint = ao2_alloc(sizeof(*endpoint), endpoint_destructor);
+	if (!endpoint) {
+		return NULL;
+	}
+	if (ast_string_field_init(endpoint, 64)) {
+		ao2_cleanup(endpoint);
+		return NULL;
+	}
+	if (!(endpoint->codecs = ast_format_cap_alloc_nolock())) {
+		ao2_cleanup(endpoint);
+		return NULL;
+	}
+	ast_party_id_init(&endpoint->id);
+	return endpoint;
+}
+
+struct ao2_container *ast_res_sip_get_endpoints(void)
+{
+	struct ao2_container *endpoints;
+
+	endpoints = ast_sorcery_retrieve_by_fields(sip_sorcery, "endpoint", AST_RETRIEVE_FLAG_MULTIPLE | AST_RETRIEVE_FLAG_ALL, NULL);
+
+	return endpoints;
+}
+
+int ast_sip_retrieve_auths(const char *auth_names[], size_t num_auths, struct ast_sip_auth **out)
+{
+	int i;
+
+	for (i = 0; i < num_auths; ++i) {
+		out[i] = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), SIP_SORCERY_AUTH_TYPE, auth_names[i]);
+		if (!out[i]) {
+			ast_log(LOG_NOTICE, "Couldn't find auth '%s'. Cannot authenticate\n", auth_names[i]);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+
+void ast_sip_cleanup_auths(struct ast_sip_auth *auths[], size_t num_auths)
+{
+	int i;
+	for (i = 0; i < num_auths; ++i) {
+		ao2_cleanup(auths[i]);
+	}
+}
+
+struct ast_sorcery *ast_sip_get_sorcery(void)
+{
+	return sip_sorcery;
+}
+
diff --git a/res/res_sip/sip_distributor.c b/res/res_sip/sip_distributor.c
new file mode 100644
index 000000000..766261089
--- /dev/null
+++ b/res/res_sip/sip_distributor.c
@@ -0,0 +1,239 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2013, Digium, Inc.
+ *
+ * Mark Michelson <mmichelson@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#include "asterisk.h"
+
+#include <pjsip.h>
+
+#include "asterisk/res_sip.h"
+
+static int distribute(void *data);
+static pj_bool_t distributor(pjsip_rx_data *rdata);
+
+static pjsip_module distributor_mod = {
+	.name = {"Request Distributor", 19},
+	.priority = PJSIP_MOD_PRIORITY_TSX_LAYER - 6,
+	.on_rx_request = distributor,
+	.on_rx_response = distributor,
+};
+
+/*! Dialog-specific information the distributor uses */
+struct distributor_dialog_data {
+	/* Serializer to distribute tasks to for this dialog */
+	struct ast_taskprocessor *serializer;
+	/* Endpoint associated with this dialog */
+	struct ast_sip_endpoint *endpoint;
+};
+
+/*!
+ * \internal
+ *
+ * \note Call this with the dialog locked
+ */
+static struct distributor_dialog_data *distributor_dialog_data_alloc(pjsip_dialog *dlg)
+{
+	struct distributor_dialog_data *dist;
+
+	dist = PJ_POOL_ZALLOC_T(dlg->pool, struct distributor_dialog_data);
+	pjsip_dlg_set_mod_data(dlg, distributor_mod.id, dist);
+
+	return dist;
+}
+
+void ast_sip_dialog_set_serializer(pjsip_dialog *dlg, struct ast_taskprocessor *serializer)
+{
+	struct distributor_dialog_data *dist;
+	SCOPED_LOCK(lock, dlg, pjsip_dlg_inc_lock, pjsip_dlg_dec_lock);
+	
+	dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
+	if (!dist) {
+		dist = distributor_dialog_data_alloc(dlg);
+	}
+	dist->serializer = serializer;
+}
+
+void ast_sip_dialog_set_endpoint(pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint)
+{
+	struct distributor_dialog_data *dist;
+	SCOPED_LOCK(lock, dlg, pjsip_dlg_inc_lock, pjsip_dlg_dec_lock);
+	
+	dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
+	if (!dist) {
+		dist = distributor_dialog_data_alloc(dlg);
+	}
+	dist->endpoint = endpoint;
+}
+
+struct ast_sip_endpoint *ast_sip_dialog_get_endpoint(pjsip_dialog *dlg)
+{
+	struct distributor_dialog_data *dist;
+	SCOPED_LOCK(lock, dlg, pjsip_dlg_inc_lock, pjsip_dlg_dec_lock);
+
+	dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
+	if (!dist || !dist->endpoint) {
+		return NULL;
+	}
+	ao2_ref(dist->endpoint, +1);
+	return dist->endpoint;
+}
+
+static pj_bool_t distributor(pjsip_rx_data *rdata)
+{
+	pjsip_dialog *dlg = pjsip_ua_find_dialog(&rdata->msg_info.cid->id, &rdata->msg_info.to->tag, &rdata->msg_info.from->tag, PJ_TRUE);
+	struct distributor_dialog_data *dist = NULL;
+	struct ast_taskprocessor *serializer = NULL;
+	pjsip_rx_data *clone;
+
+	pjsip_rx_data_clone(rdata, 0, &clone);
+	if (dlg) {
+		dist = pjsip_dlg_get_mod_data(dlg, distributor_mod.id);
+		if (dist) {
+			serializer = dist->serializer;
+			clone->endpt_info.mod_data[distributor_mod.id] = dist->endpoint;
+		}
+	}
+
+	ast_sip_push_task(serializer, distribute, clone);
+
+	if (dlg) {
+		pjsip_dlg_dec_lock(dlg);
+	}
+
+	return PJ_TRUE;
+}
+
+static pj_bool_t endpoint_lookup(pjsip_rx_data *rdata);
+
+static pjsip_module endpoint_mod = {
+	.name = {"Endpoint Identifier", 19},
+	.priority = PJSIP_MOD_PRIORITY_TSX_LAYER - 3,
+	.on_rx_request = endpoint_lookup,
+};
+
+static pj_bool_t endpoint_lookup(pjsip_rx_data *rdata)
+{
+	struct ast_sip_endpoint *endpoint;
+	int is_ack = rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD;
+
+	endpoint = rdata->endpt_info.mod_data[distributor_mod.id];
+	if (endpoint) {
+		/* Bumping the refcount makes refcounting consistent whether an endpoint
+		 * is looked up or not */
+		ao2_ref(endpoint, +1);
+	} else {
+		endpoint = ast_sip_identify_endpoint(rdata);
+	}
+
+	if (!endpoint && !is_ack) {
+		/* XXX When we do an alwaysauthreject-like option, we'll need to take that into account
+		 * for this response. Either that, or have a pseudo-endpoint to pass along so that authentication
+		 * will fail
+		 */
+		pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 403, NULL, NULL, NULL);
+		return PJ_TRUE;
+	}
+	rdata->endpt_info.mod_data[endpoint_mod.id] = endpoint;
+	return PJ_FALSE;
+}
+
+static pj_bool_t authenticate(pjsip_rx_data *rdata)
+{
+	RAII_VAR(struct ast_sip_endpoint *, endpoint, ast_pjsip_rdata_get_endpoint(rdata), ao2_cleanup);
+	int is_ack = rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD;
+
+	ast_assert(endpoint != NULL);
+
+	if (!is_ack && ast_sip_requires_authentication(endpoint, rdata)) {
+		pjsip_tx_data *tdata;
+		pjsip_endpt_create_response(ast_sip_get_pjsip_endpoint(), rdata, 401, NULL, &tdata);
+		switch (ast_sip_check_authentication(endpoint, rdata, tdata)) {
+		case AST_SIP_AUTHENTICATION_CHALLENGE:
+			/* Send the 401 we created for them */
+			pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL);
+			return PJ_TRUE;
+		case AST_SIP_AUTHENTICATION_SUCCESS:
+			pjsip_tx_data_dec_ref(tdata);
+			return PJ_FALSE;
+		case AST_SIP_AUTHENTICATION_FAILED:
+			pjsip_tx_data_dec_ref(tdata);
+			pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 403, NULL, NULL, NULL);
+			return PJ_TRUE;
+		case AST_SIP_AUTHENTICATION_ERROR:
+			pjsip_tx_data_dec_ref(tdata);
+			pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 500, NULL, NULL, NULL);
+			return PJ_TRUE;
+		}
+	}
+
+	return PJ_FALSE;
+}
+
+static pjsip_module auth_mod = {
+	.name = {"Request Authenticator", 21},
+	.priority = PJSIP_MOD_PRIORITY_APPLICATION - 1,
+	.on_rx_request = authenticate,
+};
+
+static int distribute(void *data)
+{
+	static pjsip_process_rdata_param param = {
+		.start_mod = &distributor_mod,
+		.idx_after_start = 1,
+	};
+	pj_bool_t handled;
+	pjsip_rx_data *rdata = data;
+	int is_request = rdata->msg_info.msg->type == PJSIP_REQUEST_MSG;
+	int is_ack = is_request ? rdata->msg_info.msg->line.req.method.id == PJSIP_ACK_METHOD : 0;
+	struct ast_sip_endpoint *endpoint;
+
+	pjsip_endpt_process_rx_data(ast_sip_get_pjsip_endpoint(), rdata, &param, &handled);
+	if (!handled && is_request && !is_ack) {
+		pjsip_endpt_respond_stateless(ast_sip_get_pjsip_endpoint(), rdata, 501, NULL, NULL, NULL);
+	}
+
+	/* The endpoint_mod stores an endpoint reference in the mod_data of rdata. This
+	 * is the only appropriate spot to actually decrement the reference.
+	 */
+	endpoint = rdata->endpt_info.mod_data[endpoint_mod.id];
+	ao2_cleanup(endpoint);
+	pjsip_rx_data_free_cloned(rdata);
+	return 0;
+}
+
+struct ast_sip_endpoint *ast_pjsip_rdata_get_endpoint(pjsip_rx_data *rdata)
+{
+	struct ast_sip_endpoint *endpoint = rdata->endpt_info.mod_data[endpoint_mod.id];
+	if (endpoint) {
+		ao2_ref(endpoint, +1);
+	}
+	return endpoint;
+}
+
+int ast_sip_initialize_distributor(void)
+{
+	if (ast_sip_register_service(&distributor_mod)) {
+		return -1;
+	}
+	if (ast_sip_register_service(&endpoint_mod)) {
+		return -1;
+	}
+	if (ast_sip_register_service(&auth_mod)) {
+		return -1;
+	}
+	return 0;
+}
diff --git a/res/res_sip/sip_options.c b/res/res_sip/sip_options.c
new file mode 100644
index 000000000..5e3f8edca
--- /dev/null
+++ b/res/res_sip/sip_options.c
@@ -0,0 +1,378 @@
+/*
+ * sip_options.c
+ *
+ *  Created on: Jan 25, 2013
+ *      Author: mjordan
+ */
+
+#include "asterisk.h"
+
+#include <pjsip.h>
+#include <pjsip_ua.h>
+#include <pjlib.h>
+
+#include "asterisk/res_sip.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/astobj2.h"
+#include "asterisk/cli.h"
+#include "include/res_sip_private.h"
+
+#define DEFAULT_LANGUAGE "en"
+#define DEFAULT_ENCODING "text/plain"
+#define QUALIFIED_BUCKETS 211
+
+/*! \brief Scheduling context for qualifies */
+static struct ast_sched_context *sched; /* XXX move this to registrar */
+
+struct ao2_container *scheduled_qualifies;
+
+struct qualify_info {
+	AST_DECLARE_STRING_FIELDS(
+		AST_STRING_FIELD(endpoint_id);
+	);
+	char *scheduler_data;
+	int scheduler_id;
+};
+
+static pj_bool_t options_module_start(void);
+static pj_bool_t options_module_stop(void);
+static pj_bool_t options_module_on_rx_request(pjsip_rx_data *rdata);
+static pj_bool_t options_module_on_rx_response(pjsip_rx_data *rdata);
+
+static pjsip_module options_module = {
+	.name = {"Options Module", 14},
+	.id = -1,
+	.priority = PJSIP_MOD_PRIORITY_APPLICATION,
+	.start = options_module_start,
+	.stop = options_module_stop,
+	.on_rx_request = options_module_on_rx_request,
+	.on_rx_response = options_module_on_rx_response,
+};
+
+static pj_bool_t options_module_start(void)
+{
+	if (!(sched = ast_sched_context_create()) ||
+	    ast_sched_start_thread(sched)) {
+		return -1;
+	}
+
+	return PJ_SUCCESS;
+}
+
+static pj_bool_t options_module_stop(void)
+{
+	ao2_t_ref(scheduled_qualifies, -1, "Remove scheduled qualifies on module stop");
+
+	if (sched) {
+		ast_sched_context_destroy(sched);
+	}
+
+	return PJ_SUCCESS;
+}
+
+static pj_status_t send_options_response(pjsip_rx_data *rdata, pjsip_dialog *pj_dlg, int code)
+{
+	pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
+	pjsip_transaction *pj_trans = pjsip_rdata_get_tsx(rdata);
+	pjsip_tx_data *tdata;
+	const pjsip_hdr *hdr;
+	pjsip_response_addr res_addr;
+	pj_status_t status;
+
+	/* Make the response object */
+	status = pjsip_endpt_create_response(endpt, rdata, code, NULL, &tdata);
+	if (status != PJ_SUCCESS) {
+		return status;
+	}
+
+	/* Add appropriate headers */
+	if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ACCEPT, NULL))) {
+		pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
+	}
+	if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_ALLOW, NULL))) {
+		pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
+	}
+	if ((hdr = pjsip_endpt_get_capability(endpt, PJSIP_H_SUPPORTED, NULL))) {
+		pjsip_msg_add_hdr(tdata->msg, (pjsip_hdr*)pjsip_hdr_clone(tdata->pool, hdr));
+	}
+
+	/*
+	 * XXX TODO: pjsip doesn't care a lot about either of these headers -
+	 * while it provides specific methods to create them, they are defined
+	 * to be the standard string header creation. We never did add them
+	 * in chan_sip, although RFC 3261 says they SHOULD. Hard coded here.
+	 */
+	ast_sip_add_header(tdata, "Accept-Encoding", DEFAULT_ENCODING);
+	ast_sip_add_header(tdata, "Accept-Language", DEFAULT_LANGUAGE);
+
+	if (pj_dlg && pj_trans) {
+		status = pjsip_dlg_send_response(pj_dlg, pj_trans, tdata);
+	} else {
+		/* Get where to send request. */
+		status = pjsip_get_response_addr(tdata->pool, rdata, &res_addr);
+		if (status != PJ_SUCCESS) {
+			pjsip_tx_data_dec_ref(tdata);
+			return status;
+		}
+		status = pjsip_endpt_send_response(endpt, &res_addr, tdata, NULL, NULL);
+	}
+
+	return status;
+}
+
+static pj_bool_t options_module_on_rx_request(pjsip_rx_data *rdata)
+{
+	RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
+	pjsip_dialog *dlg = pjsip_rdata_get_dlg(rdata);
+	pjsip_uri *ruri;
+	pjsip_sip_uri *sip_ruri;
+	char exten[AST_MAX_EXTENSION];
+
+	if (pjsip_method_cmp(&rdata->msg_info.msg->line.req.method, &pjsip_options_method)) {
+		return PJ_FALSE;
+	}
+	endpoint = ast_pjsip_rdata_get_endpoint(rdata);
+	ast_assert(endpoint != NULL);
+
+	ruri = rdata->msg_info.msg->line.req.uri;
+	if (!PJSIP_URI_SCHEME_IS_SIP(ruri) && !PJSIP_URI_SCHEME_IS_SIPS(ruri)) {
+		send_options_response(rdata, dlg, 416);
+		return -1;
+	}
+	
+	sip_ruri = pjsip_uri_get_uri(ruri);
+	ast_copy_pj_str(exten, &sip_ruri->user, sizeof(exten));
+
+	if (ast_shutting_down()) {
+		send_options_response(rdata, dlg, 503);
+	} else if (!ast_exists_extension(NULL, endpoint->context, exten, 1, NULL)) {
+		send_options_response(rdata, dlg, 404);
+	} else {
+		send_options_response(rdata, dlg, 200);
+	}
+	return PJ_TRUE;
+}
+
+static pj_bool_t options_module_on_rx_response(pjsip_rx_data *rdata)
+{
+
+	return PJ_SUCCESS;
+}
+
+static int qualify_info_hash_fn(const void *obj, int flags)
+{
+	const struct qualify_info *info = obj;
+	const char *endpoint_id = flags & OBJ_KEY ? obj : info->endpoint_id;
+
+	return ast_str_hash(endpoint_id);
+}
+
+static int qualify_info_cmp_fn(void *obj, void *arg, int flags)
+{
+	struct qualify_info *left = obj;
+	struct qualify_info *right = arg;
+	const char *right_endpoint_id = flags & OBJ_KEY ? arg : right->endpoint_id;
+
+	return strcmp(left->endpoint_id, right_endpoint_id) ? 0 : CMP_MATCH | CMP_STOP;
+}
+
+
+static void qualify_info_destructor(void *obj)
+{
+	struct qualify_info *info = obj;
+	if (!info) {
+		return;
+	}
+	ast_string_field_free_memory(info);
+	/* Cancel the qualify */
+	if (!AST_SCHED_DEL(sched, info->scheduler_id)) {
+		/* If we successfully deleted the qualify, we got it before it
+		 * fired. We can safely delete the data that was passed to it.
+		 * Otherwise, we're getting deleted while this is firing - don't
+		 * touch that memory!
+		 */
+		ast_free(info->scheduler_data);
+	}
+}
+
+static struct qualify_info *create_qualify_info(struct ast_sip_endpoint *endpoint)
+{
+	struct qualify_info *info;
+
+	info = ao2_alloc(sizeof(*info), qualify_info_destructor);
+	if (!info) {
+		return NULL;
+	}
+
+	if (ast_string_field_init(info, 64)) {
+		ao2_ref(info, -1);
+		return NULL;
+	}
+	ast_string_field_set(info, endpoint_id, ast_sorcery_object_get_id(endpoint));
+
+	return info;
+}
+
+static int send_qualify_request(void *data)
+{
+	struct ast_sip_endpoint *endpoint = data;
+	pjsip_tx_data *tdata;
+	/* YAY! Send an OPTIONS request. */
+
+	ast_sip_create_request("OPTIONS", NULL, endpoint, NULL, &tdata);
+	ast_sip_send_request(tdata, NULL, endpoint);
+
+	ao2_cleanup(endpoint);
+	return 0;
+}
+
+static int qualify_endpoint_scheduler_cb(const void *data)
+{
+	RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
+	struct ast_sorcery *sorcery;
+	char *endpoint_id = (char *)data;
+
+	sorcery = ast_sip_get_sorcery();
+	if (!sorcery) {
+		ast_free(endpoint_id);
+		return 0;
+	}
+
+	endpoint = ast_sorcery_retrieve_by_id(sorcery, "endpoint", endpoint_id);
+	if (!endpoint) {
+		/* Whoops, endpoint went away */
+		ast_free(endpoint_id);
+		return 0;
+	}
+
+	ast_sip_push_task(NULL, send_qualify_request, endpoint);
+
+	return 1;
+}
+
+static void schedule_qualifies(void)
+{
+	RAII_VAR(struct ao2_container *, endpoints, NULL, ao2_cleanup);
+	struct ao2_iterator it_endpoints;
+	struct ast_sip_endpoint *endpoint;
+	struct qualify_info *info;
+	char *endpoint_id;
+
+	endpoints = ast_res_sip_get_endpoints();
+	if (!endpoints) {
+		return;
+	}
+
+	it_endpoints = ao2_iterator_init(endpoints, 0);
+	while ((endpoint = ao2_iterator_next(&it_endpoints))) {
+		if (endpoint->qualify_frequency) {
+			/* XXX TODO: This really should only qualify registered peers,
+			 * which means we need a registrar. We should check the
+			 * registrar to see if this endpoint has registered and, if
+			 * not, pass on it.
+			 *
+			 * Actually, all of this should just get moved into the registrar.
+			 * Otherwise, the registar will have to kick this off when a
+			 * new endpoint registers, so it just makes sense to have it
+			 * all live there.
+			 */
+			info = create_qualify_info(endpoint);
+			if (!info) {
+				ao2_ref(endpoint, -1);
+				break;
+			}
+			endpoint_id = ast_strdup(info->endpoint_id);
+			if (!endpoint_id) {
+				ao2_t_ref(info, -1, "Dispose of info on off nominal");
+				ao2_ref(endpoint, -1);
+				break;
+			}
+			info->scheduler_data = endpoint_id;
+			info->scheduler_id = ast_sched_add_variable(sched, endpoint->qualify_frequency * 1000, qualify_endpoint_scheduler_cb, endpoint_id, 1);
+			ao2_t_link(scheduled_qualifies, info, "Link scheduled qualify information into container");
+			ao2_t_ref(info, -1, "Dispose of creation ref");
+		}
+		ao2_t_ref(endpoint, -1, "Dispose of iterator ref");
+	}
+	ao2_iterator_destroy(&it_endpoints);
+}
+
+static char *send_options(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
+	const char *endpoint_name;
+	pjsip_tx_data *tdata;
+
+	switch (cmd) {
+	case CLI_INIT:
+		e->command = "sip send options";
+		e->usage =
+			"Usage: sip send options <endpoint>\n"
+			"       Send a SIP OPTIONS request to the specified endpoint.\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	if (a->argc != 4) {
+		return CLI_SHOWUSAGE;
+	}
+
+	endpoint_name = a->argv[3];
+
+	endpoint = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "endpoint", endpoint_name);
+	if (!endpoint) {
+		ast_log(LOG_ERROR, "Unable to retrieve endpoint %s\n", endpoint_name);
+		return CLI_FAILURE;
+	}
+
+	if (ast_sip_create_request("OPTIONS", NULL, endpoint, NULL, &tdata)) {
+		ast_log(LOG_ERROR, "Unable to create OPTIONS request to endpoint %s\n", endpoint_name);
+		return CLI_FAILURE;
+	}
+
+	if (ast_sip_send_request(tdata, NULL, endpoint)) {
+		ast_log(LOG_ERROR, "Unable to send OPTIONS request to endpoint %s\n", endpoint_name);
+		return CLI_FAILURE;
+	}
+
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cli_options[] = {
+	AST_CLI_DEFINE(send_options, "Send an OPTIONS requst to an arbitrary SIP URI"),
+};
+
+int ast_res_sip_init_options_handling(int reload)
+{
+	const pj_str_t STR_OPTIONS = { "OPTIONS", 7 };
+
+	if (scheduled_qualifies) {
+		ao2_t_ref(scheduled_qualifies, -1, "Remove old scheduled qualifies");
+	}
+	scheduled_qualifies = ao2_t_container_alloc(QUALIFIED_BUCKETS, qualify_info_hash_fn, qualify_info_cmp_fn, "Create container for scheduled qualifies");
+	if (!scheduled_qualifies) {
+		return -1;
+	}
+
+	if (reload) {
+		return 0;
+	}
+
+	if (pjsip_endpt_register_module(ast_sip_get_pjsip_endpoint(), &options_module) != PJ_SUCCESS) {
+		options_module_stop();
+		return -1;
+	}
+
+	if (pjsip_endpt_add_capability(ast_sip_get_pjsip_endpoint(), NULL, PJSIP_H_ALLOW, NULL, 1, &STR_OPTIONS) != PJ_SUCCESS) {
+		pjsip_endpt_unregister_module(ast_sip_get_pjsip_endpoint(), &options_module);
+		return -1;
+	}
+
+	ast_cli_register_multiple(cli_options, ARRAY_LEN(cli_options));
+
+	schedule_qualifies();
+
+	return 0;
+}
diff --git a/res/res_sip/sip_outbound_auth.c b/res/res_sip/sip_outbound_auth.c
new file mode 100644
index 000000000..94352a521
--- /dev/null
+++ b/res/res_sip/sip_outbound_auth.c
@@ -0,0 +1,94 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2013, Digium, Inc.
+ *
+ * Mark Michelson <mmichelson@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+#include "asterisk.h"
+#undef bzero
+#define bzero bzero
+#include "pjsip.h"
+
+#include "asterisk/res_sip.h"
+#include "asterisk/module.h"
+#include "include/res_sip_private.h"
+
+static pj_bool_t outbound_auth(pjsip_rx_data *rdata);
+
+static pjsip_module outbound_auth_mod = {
+	.name = {"Outbound Authentication", 19},
+	.priority = PJSIP_MOD_PRIORITY_DIALOG_USAGE,
+	.on_rx_response = outbound_auth,
+};
+
+struct outbound_auth_cb_data {
+	ast_sip_dialog_outbound_auth_cb cb;
+	void *user_data;
+};
+
+static pj_bool_t outbound_auth(pjsip_rx_data *rdata)
+{
+	RAII_VAR(struct ast_sip_endpoint *, endpoint, NULL, ao2_cleanup);
+	pjsip_transaction *tsx;
+	pjsip_dialog *dlg;
+	struct outbound_auth_cb_data *cb_data;
+	pjsip_tx_data *tdata;
+
+	if (rdata->msg_info.msg->line.status.code != 401 &&
+			rdata->msg_info.msg->line.status.code != 407) {
+		/* Doesn't pertain to us. Move on */
+		return PJ_FALSE;
+	}
+
+	tsx = pjsip_rdata_get_tsx(rdata);
+	dlg = pjsip_rdata_get_dlg(rdata);
+	ast_assert(dlg != NULL && tsx != NULL);
+	endpoint = ast_sip_dialog_get_endpoint(dlg);
+
+	if (!endpoint) {
+		return PJ_FALSE;
+	}
+
+	if (ast_sip_create_request_with_auth(endpoint->sip_outbound_auths, endpoint->num_outbound_auths, rdata, tsx, &tdata)) {
+		return PJ_FALSE;
+	}
+
+	cb_data = dlg->mod_data[outbound_auth_mod.id];
+	if (cb_data) {
+		cb_data->cb(dlg, tdata, cb_data->user_data);
+		return PJ_TRUE;
+	}
+
+	pjsip_dlg_send_request(dlg, tdata, -1, NULL);
+	return PJ_TRUE;
+}
+
+int ast_sip_dialog_setup_outbound_authentication(pjsip_dialog *dlg, const struct ast_sip_endpoint *endpoint,
+		ast_sip_dialog_outbound_auth_cb cb, void *user_data)
+{
+	struct outbound_auth_cb_data *cb_data = PJ_POOL_ZALLOC_T(dlg->pool, struct outbound_auth_cb_data);
+	cb_data->cb = cb;
+	cb_data->user_data = user_data;
+
+	dlg->sess_count++;
+	pjsip_dlg_add_usage(dlg, &outbound_auth_mod, cb_data);
+	dlg->sess_count--;
+
+	return 0;
+}
+
+int ast_sip_initialize_outbound_authentication(void) {
+	return ast_sip_register_service(&outbound_auth_mod);
+}