/* 
 * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 * Copyright (C) 2005-2011, Anthony Minessale II <anthm@freeswitch.org>
 *
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 *
 * The Initial Developer of the Original Code is
 * Anthony Minessale II <anthm@freeswitch.org>
 * Portions created by the Initial Developer are Copyright (C)
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 * 
 * Anthony Minessale II <anthm@freeswitch.org>
 * Ken Rice, Asteria Solutions Group, Inc <ken@asteriasgi.com>
 * Paul D. Tinsley <pdt at jackhammer.org>
 * Bret McDanel <trixter AT 0xdecafbad.com>
 *
 *
 * sofia_presence.c -- SOFIA SIP Endpoint (presence code)
 *
 */
#include "mod_sofia.h"
#include "switch_stun.h"

#define SUB_OVERLAP 300
struct state_helper {
	switch_hash_t *hash;
	sofia_profile_t *profile;
	switch_memory_pool_t *pool;
	int total;
};


static int sofia_presence_mwi_callback(void *pArg, int argc, char **argv, char **columnNames);
static int sofia_presence_mwi_callback2(void *pArg, int argc, char **argv, char **columnNames);
static int sofia_presence_sub_reg_callback(void *pArg, int argc, char **argv, char **columnNames);
static int sofia_presence_resub_callback(void *pArg, int argc, char **argv, char **columnNames);
static int sofia_presence_sub_callback(void *pArg, int argc, char **argv, char **columnNames);
static int broadsoft_sla_gather_state_callback(void *pArg, int argc, char **argv, char **columnNames);
static int broadsoft_sla_notify_callback(void *pArg, int argc, char **argv, char **columnNames);
static int sync_sla(sofia_profile_t *profile, const char *to_user, const char *to_host, switch_bool_t clear, switch_bool_t unseize, const char *call_id);
static int sofia_dialog_probe_callback(void *pArg, int argc, char **argv, char **columnNames);
static int sofia_dialog_probe_notify_callback(void *pArg, int argc, char **argv, char **columnNames);

struct dialog_helper {
	char status[512];
	char rpid[512];
	char presence_id[1024];
	int hits;
};

struct resub_helper {
	sofia_profile_t *profile;
	switch_event_t *event;
	int rowcount;
	int noreg;
};

struct rfc4235_helper {
	switch_hash_t *hash;
	sofia_profile_t *profile;
	switch_memory_pool_t *pool;
	switch_event_t *event;
	int rowcount;
};

struct presence_helper {
	sofia_profile_t *profile;
	switch_event_t *event;
	switch_stream_handle_t stream;
	char last_uuid[512];
};

switch_status_t sofia_presence_chat_send(switch_event_t *message_event)
										 
{
	char *prof = NULL, *user = NULL, *host = NULL;
	sofia_profile_t *profile = NULL;
	char *ffrom = NULL;
	nua_handle_t *msg_nh;
	char *contact = NULL;
	char *dup = NULL;
	switch_status_t status = SWITCH_STATUS_FALSE;
	const char *ct = "text/html";
	sofia_destination_t *dst = NULL;
	char *to_uri = NULL;
	switch_console_callback_match_t *list = NULL;
	switch_console_callback_match_node_t *m;
	char *remote_ip = NULL;
	char *user_via = NULL;
	//char *contact_str = NULL;
	char *dup_dest = NULL;
	char *p = NULL;
	char *remote_host = NULL;
	const char *proto;
	const char *from; 
	const char *to;
	//const char *subject;
	const char *body;
	const char *type;
	const char *from_full;
	char header[256] = "";
	char *route_uri = NULL;
	const char *network_ip = NULL, *network_port = NULL, *from_proto;
	
	proto = switch_event_get_header(message_event, "proto");
	from_proto = switch_event_get_header(message_event, "from_proto");
	from = switch_event_get_header(message_event, "from");
	to = switch_event_get_header(message_event, "to");
	//subject = switch_event_get_header(message_event, "subject");
	body = switch_event_get_body(message_event);
	type = switch_event_get_header(message_event, "type");
	from_full = switch_event_get_header(message_event, "from_full");
	
	network_ip = switch_event_get_header(message_event, "to_sip_ip");
	network_port = switch_event_get_header(message_event, "to_sip_port");

	if (!to) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing To: header.\n");
		goto end;
	}

	if (!zstr(type)) {
		ct = type;
	}

	dup = strdup(to);
	switch_assert(dup);
	prof = dup;

	/* Do we have a user of the form profile/user[@host]? */
	if ((user = strchr(prof, '/'))) {
		*user++ = '\0';
	} else {
		user = prof;
		prof = NULL;
	}

	if (!prof) {
		prof = switch_event_get_header(message_event, "sip_profile");
	}
	
	if (!strncasecmp(user, "sip:", 4)) {
		to_uri = user;
	}

	if ((host = strchr(user, '@'))) {
		if (!to_uri) {
			*host++ = '\0';	
		} else {
			host++;
		}
		if (!prof) {
			prof = host;
		}
	}

	if (!prof || !(profile = sofia_glue_find_profile(prof))) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
		"Chat proto [%s]\nfrom [%s]\nto [%s]\n%s\nInvalid Profile %s\n", proto, from, to,
						  body ? body : "[no body]", prof ? prof : "NULL");
		goto end;
	}

	if (zstr(host)) {
		host = profile->domain_name;
		if (zstr(host)) {
			host = prof;
		}
	}


	if (to_uri) {
		switch_console_push_match(&list, to_uri);
	}  else if (!(list = sofia_reg_find_reg_url_multi(profile, user, host))) {
		sofia_profile_t *test;

		if ((test = sofia_glue_find_profile(host))) {
			sofia_glue_release_profile(test);
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Not sending to local box for %s@%s\n", user, host);
			/* our box let's not send it */
		} else {
			char *tmp;
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Can't find registered user %s@%s\n", user, host);
			tmp = switch_mprintf("sip:%s@%s", user, host);
			switch_console_push_match(&list, tmp);
			free(tmp);
		}

	}
	
	if (!strcasecmp(proto, SOFIA_CHAT_PROTO)) {
		from = from_full;
	} else {
		char *fp, *p = NULL;
		

		fp = strdup(from);
		switch_assert(fp);


		if ((p = strchr(fp, '@'))) {
			*p++ = '\0';
		}

		if (zstr(p)) {
			p = profile->domain_name;
			if (zstr(p)) {
				p = host;
			}
		}

		if (switch_stristr("global", proto)) {
			if (!from_proto || !strcasecmp(from_proto, SOFIA_CHAT_PROTO)) {
				ffrom = switch_mprintf("\"%s\" <sip:%s@%s>", fp, fp, p);
			} else {
				ffrom = switch_mprintf("\"%s\" <sip:%s+%s@%s>", fp, from_proto, fp, p);
			}

		} else {
			ffrom = switch_mprintf("\"%s\" <sip:%s+%s@%s>", fp, from_proto ? from_proto : proto, fp, p);
		}

		from = ffrom;
		switch_safe_free(fp);
	}

	if (!list) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
		"Chat proto [%s]\nfrom [%s]\nto [%s]\n%s\nNobody to send to: Profile %s\n", proto, from, to,
						  body ? body : "[no body]", prof ? prof : "NULL");
		goto end;
	}

	for (m = list->head; m; m = m->next) {

		if (!(dst = sofia_glue_get_destination(m->val))) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
			break;
		}
	
		/* sofia_glue is running sofia_overcome_sip_uri_weakness we do not, not sure if it matters */

		if (dst->route_uri) {
			dup_dest = strdup(dst->route_uri);
		} else  {
			dup_dest = strdup(dst->to);
		}


		remote_host = strdup(dup_dest);
		if (!zstr(remote_host)) {
			switch_split_user_domain(remote_host, NULL, &remote_ip);
		}

		if (!zstr(remote_ip) && sofia_glue_check_nat(profile, remote_ip)) {
			char *ptr = NULL;
			//const char *transport_str = NULL;
			if ((ptr = sofia_glue_find_parameter(dst->contact, "transport="))) {
				sofia_transport_t transport = sofia_glue_str2transport(ptr);
				//transport_str = sofia_glue_transport2str(transport);
				switch (transport) {
				case SOFIA_TRANSPORT_TCP:
					break;
				case SOFIA_TRANSPORT_TCP_TLS:
					break;
				default:
					break;
				}
				user_via = sofia_glue_create_external_via(NULL, profile, transport);
			} else {
				user_via = sofia_glue_create_external_via(NULL, profile, SOFIA_TRANSPORT_UDP);
			}
		}

		status = SWITCH_STATUS_SUCCESS;

		if (dup_dest && (p = strstr(dup_dest, ";fs_"))) {
			*p = '\0';
		}
		
		/* if this cries, add contact here too, change the 1 to 0 and omit the safe_free */

		//printf("DEBUG To: [%s] From: [%s] Contact: [%s] RURI [%s] ip [%s] port [%s]\n", to, from, contact, dst->route_uri, network_ip, network_port);

		//DUMP_EVENT(message_event);

		if (zstr(dst->route_uri) && !zstr(user) && !zstr(network_ip) && (zstr(host) || strcmp(network_ip, host))) {
			route_uri = switch_mprintf("sip:%s@%s:%s", user, network_ip, network_port);
		}

		msg_nh = nua_handle(profile->nua, NULL,
							TAG_END());

		nua_handle_bind(msg_nh, &mod_sofia_globals.destroy_private);
		
		switch_snprintf(header, sizeof(header), "X-FS-Sending-Message: %s", switch_core_get_uuid());

		nua_message(msg_nh,
					TAG_IF(dst->route_uri, NUTAG_PROXY(dst->route_uri)),
					TAG_IF(route_uri, NUTAG_PROXY(route_uri)),
					TAG_IF(dst->route, SIPTAG_ROUTE_STR(dst->route)),
					SIPTAG_FROM_STR(from),
					TAG_IF(contact, NUTAG_URL(contact)),
					SIPTAG_TO_STR(dup_dest),

					TAG_IF(user_via, SIPTAG_VIA_STR(user_via)),
					SIPTAG_CONTENT_TYPE_STR(ct),
					SIPTAG_PAYLOAD_STR(body),
					SIPTAG_HEADER_STR(header),
					TAG_END());

		sofia_glue_free_destination(dst);
		switch_safe_free(dup_dest);
		switch_safe_free(remote_host);
	}		
	
	switch_console_free_matches(&list);

  end:
	
	switch_safe_free(contact);
	switch_safe_free(route_uri);
	switch_safe_free(ffrom);
	switch_safe_free(dup);

	if (profile) {
		switch_thread_rwlock_unlock(profile->rwlock);
	}

	return status;
}

void sofia_presence_cancel(void)
{
	char *sql;
	sofia_profile_t *profile;
	struct presence_helper helper = { 0 };
	switch_console_callback_match_t *matches;

	if (!mod_sofia_globals.profile_hash) {
		return;
	}
	
	if (list_profiles_full(NULL, NULL, &matches, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
		switch_console_callback_match_node_t *m;
		
		sql = switch_mprintf("select proto,sip_user,sip_host,sub_to_user,sub_to_host,event,contact,call_id,full_from,"
							 "full_via,expires,user_agent,accept,profile_name,network_ip"
							 ",-1,'unavailable','unavailable' from sip_subscriptions where "
							 "event='presence' and hostname='%q'",
							 mod_sofia_globals.hostname);
	

		for (m = matches->head; m; m = m->next) {
			if ((profile = sofia_glue_find_profile(m->val))) {
				if (profile->pres_type == PRES_TYPE_FULL) {
					helper.profile = profile;
					helper.event = NULL;
					if (sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_sub_callback, &helper) != SWITCH_TRUE) {
						sofia_glue_release_profile(profile);
						continue;
					}
				}
				sofia_glue_release_profile(profile);
			}
		}

		switch_safe_free(sql);
		switch_console_free_matches(&matches);

	}
}

char *sofia_presence_translate_rpid(char *in, char *ext)
{
	char *r = in;

	if (in && (switch_stristr("null", in))) {
		in = NULL;
	}

	if (!in) {
		in = ext;
	}

	if (!in) {
		return NULL;
	}

	if (!strcasecmp(in, "dnd") || !strcasecmp(in, "idle")) {
		r = "busy";
	}

	return r;
}

struct mwi_helper {
	sofia_profile_t *profile;
	int total;
};

static void actual_sofia_presence_mwi_event_handler(switch_event_t *event)
{
	char *account, *dup_account, *yn, *host, *user;
	char *sql;
	sofia_profile_t *profile = NULL;
	switch_stream_handle_t stream = { 0 };
	switch_event_header_t *hp;
	struct mwi_helper h = { 0 };
	const char *pname = NULL;
	const char *call_id;
	const char *sub_call_id;
	int for_everyone = 0;

	switch_assert(event != NULL);

	if (!(account = switch_event_get_header(event, "mwi-message-account"))) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing required Header 'MWI-Message-Account'\n");
		return;
	}

	if (!(yn = switch_event_get_header(event, "mwi-messages-waiting"))) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing required Header 'MWI-Messages-Waiting'\n");
		return;
	}

	call_id = switch_event_get_header(event, "call-id");
	sub_call_id = switch_event_get_header(event, "sub-call-id");

	if (!call_id && !sub_call_id) {
		for_everyone = 1;
	}


	dup_account = strdup(account);
	switch_assert(dup_account != NULL);
	switch_split_user_domain(dup_account, &user, &host);


	if ((pname = switch_event_get_header(event, "sofia-profile"))) {
		profile = sofia_glue_find_profile(pname);
	}

	if (!profile) {
		if (!host || !(profile = sofia_glue_find_profile(host))) {
			char *sql;
			char buf[512] = "";
			switch_console_callback_match_t *matches;

			sql = switch_mprintf("select profile_name from sip_registrations where hostname='%q' and (sip_host='%s' or mwi_host='%s')", 
								 mod_sofia_globals.hostname, host, host);

			if (list_profiles_full(NULL, NULL, &matches, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
				switch_console_callback_match_node_t *m;

				for (m = matches->head; m; m = m->next) {
					if ((profile = sofia_glue_find_profile(m->val))) {

						sofia_glue_execute_sql2str(profile, profile->ireg_mutex, sql, buf, sizeof(buf));
						if (!zstr(buf)) {
							break;
						}
						sofia_glue_release_profile(profile);
					}
				}

				switch_console_free_matches(&matches);
			}

			switch_safe_free(sql);

			if (!(profile = sofia_glue_find_profile(buf))) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot find profile %s\n", switch_str_nil(host));
				switch_safe_free(dup_account);
				return;
			}
		}
	}

	if (profile->domain_name && strcasecmp(profile->domain_name, host)) {
		host = profile->domain_name;
	}

	h.profile = profile;
	h.total = 0;

	SWITCH_STANDARD_STREAM(stream);

	for (hp = event->headers; hp; hp = hp->next) {
		if (!strncasecmp(hp->name, "mwi-", 4)) {
			char *tmp = NULL;
			char *value = hp->value;
			if (!strcasecmp(hp->name, "mwi-message-account") && strncasecmp(hp->value, "sip:", 4)) {
				tmp = switch_mprintf("sip:%s", hp->value);
				value = tmp;
			}
			stream.write_function(&stream, "%s: %s\r\n", hp->name + 4, value);
			switch_safe_free(tmp);
		}
	}

	stream.write_function(&stream, "\r\n");

	sql = NULL;

	if (for_everyone) {
		sql = switch_mprintf("select proto,sip_user,sip_host,sub_to_user,sub_to_host,event,contact,call_id,full_from,"
							 "full_via,expires,user_agent,accept,profile_name,network_ip"
							 ",'%q',full_to,network_ip,network_port from sip_subscriptions "
							 "where hostname='%q' and profile_name='%q' and event='message-summary' "
							 "and sub_to_user='%q' and (sub_to_host='%q' or presence_hosts like '%%%q%%')", 
							 stream.data, mod_sofia_globals.hostname, profile->name, user, host, host);
	} else if (sub_call_id) {
		sql = switch_mprintf("select proto,sip_user,sip_host,sub_to_user,sub_to_host,event,contact,call_id,full_from,"
							 "full_via,expires,user_agent,accept,profile_name,network_ip"
							 ",'%q',full_to,network_ip,network_port from sip_subscriptions where "
							 "hostname='%q' and profile_name='%q' and event='message-summary' "
							 "and sub_to_user='%q' and (sub_to_host='%q' or presence_hosts like '%%%q%%') and call_id='%q'",
							 stream.data, mod_sofia_globals.hostname, profile->name, user, host, host, sub_call_id);
	}


	if (sql) {
		sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_mwi_callback, &h);
		free(sql);
		sql = NULL;

	}

	if (for_everyone) {
		sql = switch_mprintf("select sip_user,sip_host,contact,profile_name,network_ip,'%q' "
							 "from sip_registrations where hostname='%q' and profile_name='%q' and mwi_user='%q' and mwi_host='%q'", 
							 stream.data, mod_sofia_globals.hostname, profile->name, user, host);
	} else if (call_id) {
		sql = switch_mprintf("select sip_user,sip_host,contact,profile_name,network_ip,'%q' "
							 "from sip_registrations where hostname='%q' and profile_name='%q' and mwi_user='%q' and mwi_host='%q' and call_id='%q'", 
							 mod_sofia_globals.hostname, profile->name, stream.data, user, host, call_id);
	}

	if (sql) {
		switch_assert(sql != NULL);
		sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_mwi_callback2, &h);
		free(sql);
		sql = NULL;
	}

	switch_safe_free(stream.data);
	switch_safe_free(dup_account);

	if (profile) {
		sofia_glue_release_profile(profile);
	}
}

static int sofia_presence_dialog_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	struct dialog_helper *helper = (struct dialog_helper *) pArg;

	if (argc == 3) {
		switch_set_string(helper->status, argv[0]);
		switch_set_string(helper->rpid, argv[1]);
		switch_set_string(helper->presence_id, argv[2]);
		helper->hits++;
	}

	return -1;
}


static void do_normal_probe(switch_event_t *event)
{
	char *sql;
	struct resub_helper h = { 0 };
	char *to = switch_event_get_header(event, "to");
	char *proto = switch_event_get_header(event, "proto");
	char *probe_user = NULL, *probe_euser, *probe_host, *p;
	struct dialog_helper dh = { { 0 } };
	char *sub_call_id = switch_event_get_header(event, "sub-call-id");
	sofia_profile_t *profile;

	//DUMP_EVENT(event);
	
	if (!proto || strcasecmp(proto, SOFIA_CHAT_PROTO) != 0) {
		return;
	}

	if (!to || !(probe_user = strdup(to))) {
		return;
	}

	if ((probe_host = strchr(probe_user, '@'))) {
		*probe_host++ = '\0';
	}
	probe_euser = probe_user;
	if ((p = strchr(probe_euser, '+'))) {
		probe_euser = (p + 1);
	}

	if (probe_euser && probe_host && (profile = sofia_glue_find_profile(probe_host))) {
		sql = switch_mprintf("select status,rpid,presence_id from sip_dialogs "
							 "where hostname='%q' and profile_name='%q' and "
							 "((sip_from_user='%q' and sip_from_host='%q') or presence_id='%q@%q') order by rcd desc", 
							 mod_sofia_globals.hostname, profile->name, probe_euser, probe_host, probe_euser, probe_host);
		
		
		sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_dialog_callback, &dh);

		h.profile = profile;

		switch_safe_free(sql);

		sql = switch_mprintf("select sip_registrations.sip_user, "
							 "sip_registrations.sub_host, "
							 "sip_registrations.status, "
							 "sip_registrations.rpid, "
							 "'', "
							 "sip_dialogs.uuid, "
							 "sip_dialogs.state, "
							 "sip_dialogs.direction, "
							 "sip_dialogs.sip_to_user, "
							 "sip_dialogs.sip_to_host, "

							 "sip_presence.status,"
							 "sip_presence.rpid,"
							 "sip_dialogs.presence_id, "
							 "sip_presence.open_closed,"
							 "'%q','%q','%q' "
							 "from sip_registrations "

							 "left join sip_dialogs on "
							 "sip_dialogs.hostname = sip_registration.hostname and sip_dialogs.profile_name = sip_registration.profile_name and ("
							 "sip_dialogs.presence_id = sip_registrations.sip_user %q '@' %q sip_registrations.sub_host "
							 "or (sip_dialogs.sip_from_user = sip_registrations.sip_user "
							 "and sip_dialogs.sip_from_host = sip_registrations.sip_host)) "
 
							 "left join sip_presence on "
							 "sip_presence.hostname=sip_registrations.hostname and "
							 "(sip_registrations.sip_user=sip_presence.sip_user and sip_registrations.orig_server_host=sip_presence.sip_host and "
							 "sip_registrations.profile_name=sip_presence.profile_name) "
							 "where sip_registrations.hostname='%q' and sip_registrations.profile_name='%q' and sip_dialogs.call_info_state != 'seized' "
							 "and sip_dialogs.presence_id='%q@%q' or (sip_registrations.sip_user='%q' and "
							 "(sip_registrations.orig_server_host='%q' or sip_registrations.sub_host='%q' "
							 "))",
							 dh.status, dh.rpid, switch_str_nil(sub_call_id),
							 switch_sql_concat(), switch_sql_concat(),
							 mod_sofia_globals.hostname, profile->name, probe_euser, probe_host,  probe_euser, probe_host, probe_host);
		
		

		switch_assert(sql);
				
		if (mod_sofia_globals.debug_presence > 0) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s START_PRESENCE_PROBE_SQL\n", profile->name);
		}

		if (mod_sofia_globals.debug_presence > 1) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s DUMP PRESENCE_PROBE_SQL:\n%s\n", profile->name, sql);
		}

		sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_resub_callback, &h);
		

		if (!h.rowcount) {
			h.noreg++;
			switch_safe_free(sql);

			/* find ones with presence_id defined that are not registred */
			sql = switch_mprintf("select sip_from_user, sip_from_host, 'Registered', '', '', "
								 "uuid, state, direction, "
								 "sip_to_user, sip_to_host,"
								 "'%q','%q',presence_id, '','','' "
										 
								 "from sip_dialogs "
										 
								 "where hostname='%q' and profile_name='%q' and (presence_id='%q@%q' or "
								 "(sip_from_user='%q' and (sip_from_host='%q' or sip_to_host='%q')))",
								 mod_sofia_globals.hostname, profile->name,
								 dh.status, dh.rpid, probe_euser, probe_host,  probe_euser, probe_host, probe_host);

			if (mod_sofia_globals.debug_presence > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s START_PRESENCE_PROBE_SQL\n", profile->name);
			}

			if (mod_sofia_globals.debug_presence > 1) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s DUMP PRESENCE_PROBE_SQL:\n%s\n", profile->name, sql);
			}

			sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_resub_callback, &h);

			if (mod_sofia_globals.debug_presence > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s END_PRESENCE_PROBE_SQL\n\n", profile->name);
			}
		}

		if (!h.rowcount) {
			switch_event_t *sevent;
			if (switch_event_create(&sevent, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "proto", SOFIA_CHAT_PROTO);
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "login", profile->name);
				switch_event_add_header(sevent, SWITCH_STACK_BOTTOM, "from", "%s@%s", probe_euser, probe_host);
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "status", "Unregistered");
				switch_event_fire(&sevent);
			}					
		}


		sofia_glue_release_profile(profile);
		switch_safe_free(sql);
	}
						 

	switch_safe_free(probe_user);
}

static void do_dialog_probe(switch_event_t *event)
{
	// Received SUBSCRIBE for "dialog" events.
	// Return a complete list of dialogs for the monitored entity.
	char *sql;
	char *to = switch_event_get_header(event, "to");
	char *probe_user = NULL, *probe_euser, *probe_host, *p;
	sofia_profile_t *profile;

	if (!to || !(probe_user = strdup(to))) {
		return;
	}

	if ((probe_host = strchr(probe_user, '@'))) {
		*probe_host++ = '\0';
	}
	probe_euser = probe_user;
	if ((p = strchr(probe_euser, '+'))) {
		probe_euser = (p + 1);
	}

	if (probe_euser && probe_host && (profile = sofia_glue_find_profile(probe_host))) {
		char *sub_call_id = switch_event_get_header(event, "sub-call-id");
		struct rfc4235_helper *h4235 = {0};
		switch_memory_pool_t *pool;

		// We need all dialogs with presence_id matching the subscription entity,
		// or from a registered set matching the subscription entity.
		// We need the "proto" of the subscription in case it is for the special "conf" or "park".
		sql = switch_mprintf(
							 "select sip_subscriptions.proto, '%q','%q',"
							 "sip_dialogs.uuid, sip_dialogs.call_id, sip_dialogs.state, sip_dialogs.direction, "
							 "sip_dialogs.sip_to_user, sip_dialogs.sip_to_host, "
							 "sip_dialogs.sip_from_user, sip_dialogs.sip_from_host, "
							 "sip_dialogs.contact, sip_dialogs.contact_user, sip_dialogs.contact_host, "
							 "sip_dialogs.sip_to_tag, sip_dialogs.sip_from_tag, sip_subscriptions.orig_proto "
							 "from sip_dialogs "
							 "left join sip_subscriptions on sip_subscriptions.hostname=sip_dialogs.hostname and "
							 "sip_subscriptions.profile_name=sip_dialogs.profile_name and "
							 "sip_subscriptions.call_id='%q' "
							 "left join sip_registrations on sip_registrations.hostname=sip_dialogs.hostname and "
							 "sip_registrations.profile_name=sip_dialogs.profile_name and "
							 "(sip_dialogs.sip_from_user = sip_registrations.sip_user "
							 "and (sip_dialogs.sip_from_host = sip_registrations.orig_server_host or "
							 "sip_dialogs.sip_from_host = sip_registrations.sip_host) ) "
							 "where sip_dialogs.hostname='%q' and sip_dialogs.profile_name='%q' and "
							 "sip_dialogs.call_info_state != 'seized' and sip_dialogs.presence_id='%q@%q' or (sip_registrations.sip_user='%q' and "
							 "(sip_registrations.orig_server_host='%q' or sip_registrations.sub_host='%q' "
							 "or sip_registrations.presence_hosts like '%%%q%%'))",
							 probe_euser, probe_host,
							 sub_call_id, mod_sofia_globals.hostname, profile->name,
							 probe_euser, probe_host,
							 probe_euser, probe_host, probe_host, probe_host);
		switch_assert(sql);

		if (mod_sofia_globals.debug_presence > 0) {
			switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_INFO, "%s START DIALOG_PROBE_SQL %s@%s\n", profile->name,probe_euser, probe_host);
		}

		if (mod_sofia_globals.debug_presence > 1) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s DUMP DIALOG_PROBE_SQL:\n%s\n", profile->name, sql);
		}

		switch_core_new_memory_pool(&pool);
		h4235 = switch_core_alloc(pool, sizeof(*h4235));
		h4235->pool = pool;
		h4235->profile = profile;
		switch_core_hash_init(&h4235->hash, h4235->pool);
		sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_dialog_probe_callback, h4235);
		switch_safe_free(sql);
		if (mod_sofia_globals.debug_presence > 0) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s END DIALOG_PROBE_SQL\n\n", profile->name);
		}


		sql = switch_mprintf("update sip_subscriptions set version=version+1 "
							 "where hostname='%q' and profile_name='%q' and sub_to_user='%q' and sub_to_host='%q' and call_id='%q'",
							 mod_sofia_globals.hostname, profile->name, probe_euser, probe_host, sub_call_id);

		if (mod_sofia_globals.debug_presence > 1) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s DUMP DIALOG_PROBE set version sql:\n%s\n", profile->name, sql);
		}
		sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
		switch_safe_free(sql);


		// The dialog_probe_callback has built up the dialogs to be included in the NOTIFY.
		// Now send the "full" dialog event to the triggering subscription.
		sql = switch_mprintf("select call_id,expires,sub_to_user,sub_to_host,event,version, "
							 "'full',full_to,full_from,contact,network_ip,network_port "
							 "from sip_subscriptions "
							 "where hostname='%q' and profile_name='%q' and sub_to_user='%q' and sub_to_host='%q' and call_id='%q'",
							 mod_sofia_globals.hostname, profile->name, probe_euser, probe_host, sub_call_id);

		if (mod_sofia_globals.debug_presence > 1) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s DUMP DIALOG_PROBE subscription sql:\n%s\n", profile->name, sql);
		}

		sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_dialog_probe_notify_callback, h4235);
		switch_safe_free(sql);

		sofia_glue_release_profile(profile);
		switch_core_hash_destroy(&h4235->hash);
		h4235 = NULL;
		switch_core_destroy_memory_pool(&pool);
	}

	switch_safe_free(probe_user);
}



static void actual_sofia_presence_event_handler(switch_event_t *event)
{
	sofia_profile_t *profile = NULL;
	char *from = switch_event_get_header(event, "from");
	char *proto = switch_event_get_header(event, "proto");
	char *rpid = switch_event_get_header(event, "rpid");
	char *status = switch_event_get_header(event, "status");
	char *event_type = switch_event_get_header(event, "event_type");
	char *alt_event_type = switch_event_get_header(event, "alt_event_type");
	//char *event_subtype = switch_event_get_header(event, "event_subtype");
	char *sql = NULL;
	char *euser = NULL, *user = NULL, *host = NULL;
	char *call_info = switch_event_get_header(event, "presence-call-info");
	char *call_id = switch_event_get_header(event, "call-id");
	char *presence_source = switch_event_get_header(event, "presence-source");
	char *call_info_state = switch_event_get_header(event, "presence-call-info-state");
	switch_console_callback_match_t *matches;
	struct presence_helper helper = { 0 };			

	if (!mod_sofia_globals.running) {
		return;
	}

	if (zstr(proto) || !strcasecmp(proto, "any")) {
		proto = SOFIA_CHAT_PROTO;
	}

	//DUMP_EVENT(event);

	if (rpid && !strcasecmp(rpid, "n/a")) {
		rpid = NULL;
	}

	if (status && !strcasecmp(status, "n/a")) {
		status = NULL;
	}

	if (status && switch_stristr("CS_HANGUP", status)) {
		status = "Available";
	}

	if (rpid) {
		rpid = sofia_presence_translate_rpid(rpid, status);
	}

	if (event->event_id == SWITCH_EVENT_ROSTER) {
		struct presence_helper helper = { 0 };
		
		if (!mod_sofia_globals.profile_hash) {
			return;
		}

		if (from) {

			sql = switch_mprintf("update sip_subscriptions set version=version+1 where hostname='%q' and profile_name='%q' and "
								 "sip_subscriptions.event='presence' and sip_subscriptions.full_from like '%%%q%%'",
								 mod_sofia_globals.hostname, profile->name, from);
			
			if (mod_sofia_globals.debug_presence > 1) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "PRES SQL %s\n", sql);
			}
			
			sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
			

			sql = switch_mprintf("select sip_subscriptions.proto,sip_subscriptions.sip_user,sip_subscriptions.sip_host,"
								 "sip_subscriptions.sub_to_user,sip_subscriptions.sub_to_host,sip_subscriptions.event,"
								 "sip_subscriptions.contact,sip_subscriptions.call_id,sip_subscriptions.full_from,"
								 "sip_subscriptions.full_via,sip_subscriptions.expires,sip_subscriptions.user_agent,"
								 "sip_subscriptions.accept,sip_subscriptions.profile_name,sip_subscriptions.network_ip"
								 ",1,'%q','%q',sip_presence.status,sip_presence.rpid,sip_presence.open_closed,'','','','','sip',"
								 " sip_subscriptions.full_to,sip_subscriptions.network_ip,sip_subscriptions.network_port "
								 "from sip_subscriptions left join sip_presence on "
								 "(sip_subscriptions.sub_to_user=sip_presence.sip_user and sip_subscriptions.sub_to_host=sip_presence.sip_host and "
								 "sip_subscriptions.profile_name=sip_presence.profile_name and sip_presence.profile_name=sip_subscriptions.profile_name) "
								 "where sip_subscriptions.hostname='%q' and sip_subscriptions.profile_name='%q' and "
								 "sip_subscriptions.event='presence' and sip_subscriptions.full_from like '%%%q%%'",
								 switch_str_nil(status), switch_str_nil(rpid), mod_sofia_globals.hostname, profile->name, from);
		} else {

			sql = switch_mprintf("update sip_subscriptions set version=version+1 where hostname='%q' and profile_name='%q' and "
								 "sip_subscriptions.event='presence'", mod_sofia_globals.hostname, profile->name);
			
			if (mod_sofia_globals.debug_presence > 1) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "PRES SQL %s\n", sql);
			}
			
			sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);

			sql = switch_mprintf("select sip_subscriptions.proto,sip_subscriptions.sip_user,sip_subscriptions.sip_host,"
								 "sip_subscriptions.sub_to_user,sip_subscriptions.sub_to_host,sip_subscriptions.event,"
								 "sip_subscriptions.contact,sip_subscriptions.call_id,sip_subscriptions.full_from,"
								 "sip_subscriptions.full_via,sip_subscriptions.expires,sip_subscriptions.user_agent,"
								 "sip_subscriptions.accept,sip_subscriptions.profile_name,sip_subscriptions.network_ip"
								 ",1,'%q','%q',sip_presence.status,sip_presence.rpid,sip_presence.open_closed,'','','','','sip',"
								 "sip_subscriptions.full_to,sip_subscriptions.network_ip,sip_subscriptions.network_port "
								 "from sip_subscriptions left join sip_presence on "
								 "(sip_subscriptions.sub_to_user=sip_presence.sip_user and sip_subscriptions.sub_to_host=sip_presence.sip_host and "
								 "sip_subscriptions.profile_name=sip_presence.profile_name and sip_subscriptions.hostname = sip_presence.hostname) "
								 "where sip_subscriptions.hostname='%q' and sip_subscriptions.profile_name='%q' and "
								 "sip_subscriptions.event='presence'", switch_str_nil(status),
								 switch_str_nil(rpid), mod_sofia_globals.hostname, profile->name);
		}

		switch_assert(sql != NULL);
		
		if (list_profiles_full(NULL, NULL, &matches, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
			switch_console_callback_match_node_t *m;

			for (m = matches->head; m; m = m->next) {
				if ((profile = sofia_glue_find_profile(m->val))) {
					if (profile->pres_type != PRES_TYPE_FULL) {
						if (mod_sofia_globals.debug_presence > 0) {
							switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "%s is passive, skipping\n", (char *) profile->name);
						}
						sofia_glue_release_profile(profile);
						continue;
					}
					helper.profile = profile;
					helper.event = NULL;
					sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_sub_callback, &helper);

					sofia_glue_release_profile(profile);
				}
			}
			switch_console_free_matches(&matches);
		}
		
		free(sql);
		return;
	}

	if (zstr(event_type)) {
		event_type = "presence";
	}

	if (zstr(alt_event_type)) {
		if (!strcasecmp(event_type, "presence")) {
			alt_event_type = "dialog";
		} else {
			alt_event_type = "presence";
		}
	}

	if (from && (user = strdup(from))) {
		if ((host = strchr(user, '@'))) {
			char *p;
			*host++ = '\0';
			if ((p = strchr(host, '/'))) {
				*p = '\0';
			}
		} else {
			switch_safe_free(user);
			return;
		}
		if ((euser = strchr(user, '+'))) {
			euser++;
		} else {
			euser = user;
		}
	} else {
		return;
	}

	switch (event->event_id) {
	case SWITCH_EVENT_PRESENCE_PROBE:
		{
			char *probe_type = switch_event_get_header(event, "probe-type");

			if (!probe_type || strcasecmp(probe_type, "dialog")) { 
				/* NORMAL PROBE */
				do_normal_probe(event);
			} else { 
				/* DIALOG PROBE */
				do_dialog_probe(event);
			}
		}
		goto done;

	default:
		break;
	}	

	if (!mod_sofia_globals.profile_hash) {
		goto done;
	}

	if (list_profiles_full(NULL, NULL, &matches, SWITCH_FALSE) == SWITCH_STATUS_SUCCESS) {
		switch_console_callback_match_node_t *m;

		for (m = matches->head; m; m = m->next) {
			struct dialog_helper dh = { { 0 } };

			if ((profile = sofia_glue_find_profile(m->val))) {
				if (profile->pres_type != PRES_TYPE_FULL) {
					if (mod_sofia_globals.debug_presence > 0) {
						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "%s is passive, skipping\n", (char *) profile->name);
					}
					sofia_glue_release_profile(profile);
					continue;
				}

				if (call_info) {
					const char *uuid = switch_event_get_header(event, "unique-id");

					
#if 0
					if (mod_sofia_globals.debug_sla > 1) {
						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SLA EVENT:\n");
						DUMP_EVENT(event);
					}
#endif

					if (uuid) {
						sql = switch_mprintf("update sip_dialogs set call_info='%q',call_info_state='%q' where "
											 "hostname='%q' and profile_name='%q' and uuid='%q'",
											 call_info, call_info_state, mod_sofia_globals.hostname, profile->name, uuid);
					} else {
						sql = switch_mprintf("update sip_dialogs set call_info='%q', call_info_state='%q' where hostname='%q' and profile_name='%q' and "
											 "((sip_dialogs.sip_from_user='%q' and sip_dialogs.sip_from_host='%q') or presence_id='%q@%q') and call_info='%q'",
											 
											 call_info, call_info_state, mod_sofia_globals.hostname, profile->name, euser, host, euser, host, call_info);
						
					}
					
					if (mod_sofia_globals.debug_sla > 1) {
						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "STATE SQL %s\n", sql);
					}
					sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
					


					if (mod_sofia_globals.debug_sla > 1) {
						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "PROCESS PRESENCE EVENT\n");
					}
					
					sync_sla(profile, euser, host, SWITCH_TRUE, SWITCH_TRUE, call_id);
				}
				
				if (!strcmp(proto, "dp")) {
					sql = switch_mprintf("update sip_presence set rpid='%q',status='%q' where hostname='%q' nad profile_name='%q' and "
										 "sip_user='%q' and sip_host='%q'",
										 rpid, status, mod_sofia_globals.hostname, profile->name, euser, host);
					sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
				}
				
				sql = switch_mprintf("select status,rpid,presence_id from sip_dialogs "
									 "where hostname='%q' and profile_name='%q' and "
									 "((sip_from_user='%q' and sip_from_host='%q') or presence_id='%q@%q') order by rcd desc", 
									 mod_sofia_globals.hostname, profile->name, euser, host, euser, host);
				sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_dialog_callback, &dh);
				switch_safe_free(sql);


				if (zstr(call_id) && (dh.hits && presence_source && (!strcasecmp(presence_source, "register") || switch_stristr("register", status)))) {
					goto done;
				}

				if (zstr(call_id)) {
					
					sql = switch_mprintf("update sip_subscriptions set version=version+1 where hostname='%q' and profile_name='%q' and "
										 "sip_subscriptions.event != 'line-seize' "
										 "and sip_subscriptions.proto='%q' and (event='%q' or event='%q') and sub_to_user='%q' and "
										 "(sub_to_host='%q' or sub_to_host='%q' or sub_to_host='%q' or "
										 "presence_hosts like '%%%q%%') and "
										 "(sip_subscriptions.profile_name = '%q' or presence_hosts like '%%%q%%')", 
										 mod_sofia_globals.hostname, profile->name,
										 proto, event_type, alt_event_type, euser, host, profile->sipip,
										 profile->extsipip ? profile->extsipip : "N/A", host, profile->name, host);
					

					if (mod_sofia_globals.debug_presence > 1) {
						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "PRES SQL %s\n", sql);
					}

					sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
					

				
					sql = switch_mprintf("select distinct sip_subscriptions.proto,sip_subscriptions.sip_user,sip_subscriptions.sip_host,"
										 "sip_subscriptions.sub_to_user,sip_subscriptions.sub_to_host,sip_subscriptions.event,"
										 "sip_subscriptions.contact,sip_subscriptions.call_id,sip_subscriptions.full_from,"
										 "sip_subscriptions.full_via,sip_subscriptions.expires,sip_subscriptions.user_agent,"
										 "sip_subscriptions.accept,sip_subscriptions.profile_name"
										 ",'%q','%q','%q',sip_presence.status,sip_presence.rpid,sip_presence.open_closed,'%q','%q',"
										 "sip_subscriptions.version, '%q',sip_subscriptions.orig_proto,sip_subscriptions.full_to,"
										 "sip_subscriptions.network_ip, sip_subscriptions.network_port "
										 "from sip_subscriptions "
										 "left join sip_presence on "
										 "(sip_subscriptions.sub_to_user=sip_presence.sip_user and sip_subscriptions.sub_to_host=sip_presence.sip_host and "
										 "sip_subscriptions.profile_name=sip_presence.profile_name and sip_subscriptions.hostname=sip_presence.hostname) "
										  
										 "where sip_subscriptions.hostname='%q' and sip_subscriptions.profile_name='%q' and "
										 "sip_subscriptions.event != 'line-seize' and "
										 "sip_subscriptions.proto='%q' and "
										 "(event='%q' or event='%q') and sub_to_user='%q' "
										 "and (sub_to_host='%q' or sub_to_host='%q' or sub_to_host='%q' or presence_hosts like '%%%q%%') ",
										 
										  
										 switch_str_nil(status), switch_str_nil(rpid), host,
										 dh.status,dh.rpid,dh.presence_id, mod_sofia_globals.hostname, profile->name, proto,
										 event_type, alt_event_type, euser, host, profile->sipip, 
										 profile->extsipip ? profile->extsipip : "N/A", host);
				} else {
					sql = switch_mprintf("update sip_subscriptions set version=version+1 where sip_subscriptions.event != 'line-seize' and "
										 "hostname='%q' and profile_name = '%q' and sip_subscriptions.call_id='%q'",
										 mod_sofia_globals.hostname, profile->name, call_id);


					if (mod_sofia_globals.debug_presence > 1) {
						switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "PRES SQL %s\n", sql);
					}

					sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);


					sql = switch_mprintf("select distinct sip_subscriptions.proto,sip_subscriptions.sip_user,sip_subscriptions.sip_host,"
										 "sip_subscriptions.sub_to_user,sip_subscriptions.sub_to_host,sip_subscriptions.event,"
										 "sip_subscriptions.contact,sip_subscriptions.call_id,sip_subscriptions.full_from,"
										 "sip_subscriptions.full_via,sip_subscriptions.expires,sip_subscriptions.user_agent,"
										 "sip_subscriptions.accept,sip_subscriptions.profile_name"
										 ",'%q','%q','%q',sip_presence.status,sip_presence.rpid,sip_presence.open_closed,'%q','%q',"
										 "sip_subscriptions.version, '%q',sip_subscriptions.orig_proto,sip_subscriptions.full_to,"
										 "sip_subscriptions.network_ip, sip_subscriptions.network_port "
										 "from sip_subscriptions "
										 "left join sip_presence on "
										 "(sip_subscriptions.sub_to_user=sip_presence.sip_user and sip_subscriptions.sub_to_host=sip_presence.sip_host and "
										 "sip_subscriptions.profile_name=sip_presence.profile_name and sip_subscriptions.hostname=sip_presence.hostname) "
										  
										 "where sip_subscriptions.hostname='%q' and sip_subscriptions.profile_name='%q' and "
										 "sip_subscriptions.event != 'line-seize' and "
										 "sip_subscriptions.call_id='%q'",
										  
										 switch_str_nil(status), switch_str_nil(rpid), host,
										 dh.status,dh.rpid,dh.presence_id, mod_sofia_globals.hostname, profile->name, call_id);

			}
			

			helper.profile = profile;
			helper.event = event;
			SWITCH_STANDARD_STREAM(helper.stream);
			switch_assert(helper.stream.data);
					
			if (mod_sofia_globals.debug_presence > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s START_PRESENCE_SQL (%s)\n",
								  event->event_id == SWITCH_EVENT_PRESENCE_IN ? "IN" : "OUT", profile->name);
			}

			if (mod_sofia_globals.debug_presence) {
				char *buf;
				switch_event_serialize(event, &buf, SWITCH_FALSE);
				switch_assert(buf);
				if (mod_sofia_globals.debug_presence > 1) {
					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DUMP PRESENCE SQL:\n%s\nEVENT DUMP:\n%s\n", sql, buf);
				} else {
					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "EVENT DUMP:\n%s\n", buf);
				}
				free(buf);
			}

			sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_sub_callback, &helper);
			switch_safe_free(sql);
			
			if (mod_sofia_globals.debug_presence > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s END_PRESENCE_SQL (%s)\n",
								  event->event_id == SWITCH_EVENT_PRESENCE_IN ? "IN" : "OUT", profile->name);
			}

#if 0
			if (event) {
				const char *refresh = switch_event_get_header(event, "refresh");
				if (switch_true(refresh)) {
					switch_event_t *s_event;
							
					if (switch_event_create(&s_event, SWITCH_EVENT_PRESENCE_PROBE) == SWITCH_STATUS_SUCCESS) {
						switch_event_add_header_string(s_event, SWITCH_STACK_BOTTOM, "proto", SOFIA_CHAT_PROTO);
						switch_event_add_header_string(s_event, SWITCH_STACK_BOTTOM, "login", profile->name);
						switch_event_add_header(s_event, SWITCH_STACK_BOTTOM, "from", "%s@%s", euser, host);
						switch_event_add_header(s_event, SWITCH_STACK_BOTTOM, "to", "%s@%s", euser, host);
						switch_event_add_header_string(s_event, SWITCH_STACK_BOTTOM, "event_type", "presence");
						switch_event_add_header_string(s_event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
						switch_event_fire(&s_event);
					}
				}
			}
#endif

			if (!zstr((char *) helper.stream.data)) {
				char *this_sql = (char *) helper.stream.data;
				char *next = NULL;
				char *last = NULL;
						
				do {
					if ((next = strchr(this_sql, ';'))) {
						*next++ = '\0';
						while (*next == '\n' || *next == ' ' || *next == '\r') {
							*next++ = '\0';
						}
					}
							
					if (!zstr(this_sql) && (!last || strcmp(last, this_sql))) {
						sofia_glue_execute_sql(profile, &this_sql, SWITCH_FALSE);
						last = this_sql;
					}
					this_sql = next;
				} while (this_sql);
			}
			switch_safe_free(helper.stream.data);
			helper.stream.data = NULL;
				
			sofia_glue_release_profile(profile);
		}
	}
	switch_console_free_matches(&matches);
}

done:
switch_safe_free(sql);
switch_safe_free(user);
}

static int EVENT_THREAD_RUNNING = 0;
static int EVENT_THREAD_STARTED = 0;

void *SWITCH_THREAD_FUNC sofia_presence_event_thread_run(switch_thread_t *thread, void *obj)
{
	void *pop;
	int done = 0;

	switch_mutex_lock(mod_sofia_globals.mutex);
	if (!EVENT_THREAD_RUNNING) {
		EVENT_THREAD_RUNNING++;
		mod_sofia_globals.threads++;
	} else {
		done = 1;
	}
	switch_mutex_unlock(mod_sofia_globals.mutex);

	if (done) {
		return NULL;
	}

	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Event Thread Started\n");

	while (mod_sofia_globals.running == 1) {
		int count = 0;

		if (switch_queue_trypop(mod_sofia_globals.presence_queue, &pop) == SWITCH_STATUS_SUCCESS) {
			switch_event_t *event = (switch_event_t *) pop;

			if (!pop) {
				break;
			}
			actual_sofia_presence_event_handler(event);
			switch_event_destroy(&event);
			count++;
		}

		if (switch_queue_trypop(mod_sofia_globals.mwi_queue, &pop) == SWITCH_STATUS_SUCCESS) {
			switch_event_t *event = (switch_event_t *) pop;

			if (!pop) {
				break;
			}

			actual_sofia_presence_mwi_event_handler(event);
			switch_event_destroy(&event);
			count++;
		}

		if (!count) {
			switch_yield(100000);
		}
	}

	while (switch_queue_trypop(mod_sofia_globals.presence_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {
		switch_event_t *event = (switch_event_t *) pop;
		switch_event_destroy(&event);
	}

	while (switch_queue_trypop(mod_sofia_globals.mwi_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {
		switch_event_t *event = (switch_event_t *) pop;
		switch_event_destroy(&event);
	}

	switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "Event Thread Ended\n");

	switch_mutex_lock(mod_sofia_globals.mutex);
	mod_sofia_globals.threads--;
	EVENT_THREAD_RUNNING = EVENT_THREAD_STARTED = 0;
	switch_mutex_unlock(mod_sofia_globals.mutex);

	return NULL;
}

void sofia_presence_event_thread_start(void)
{
	switch_thread_t *thread;
	switch_threadattr_t *thd_attr = NULL;
	int done = 0;

	switch_mutex_lock(mod_sofia_globals.mutex);
	if (!EVENT_THREAD_STARTED) {
		EVENT_THREAD_STARTED++;
	} else {
		done = 1;
	}
	switch_mutex_unlock(mod_sofia_globals.mutex);

	if (done) {
		return;
	}

	switch_threadattr_create(&thd_attr, mod_sofia_globals.pool);
	switch_threadattr_detach_set(thd_attr, 1);
	switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
	switch_threadattr_priority_increase(thd_attr);
	switch_thread_create(&thread, thd_attr, sofia_presence_event_thread_run, NULL, mod_sofia_globals.pool);
}


void sofia_presence_event_handler(switch_event_t *event)
{
	switch_event_t *cloned_event;

	switch_event_dup(&cloned_event, event);
	switch_assert(cloned_event);
	switch_queue_push(mod_sofia_globals.presence_queue, cloned_event);

	if (!EVENT_THREAD_STARTED) {
		sofia_presence_event_thread_start();
	}
}

void sofia_presence_mwi_event_handler(switch_event_t *event)
{
	switch_event_t *cloned_event;

	switch_event_dup(&cloned_event, event);
	switch_assert(cloned_event);
	switch_queue_push(mod_sofia_globals.mwi_queue, cloned_event);

	if (!EVENT_THREAD_STARTED) {
		sofia_presence_event_thread_start();
	}
}


static int sofia_presence_sub_reg_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	sofia_profile_t *profile = (sofia_profile_t *) pArg;
	char *user = argv[1];
	char *host = argv[2];
	switch_event_t *event;
	char *event_name = argv[5];
	char *expires = argv[10];

	if (!strcasecmp(event_name, "message-summary")) {
		if (switch_event_create(&event, SWITCH_EVENT_MESSAGE_QUERY) == SWITCH_STATUS_SUCCESS) {
			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Message-Account", "sip:%s@%s", user, host);
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "VM-Sofia-Profile", profile->name);
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "VM-sub-call-id", argv[7]);
			switch_event_fire(&event);
		}
		return 0;
	}

	if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_PROBE) == SWITCH_STATUS_SUCCESS) {
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", SOFIA_CHAT_PROTO);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", profile->url);
		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", user, host);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_subtype", "probe");
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto-specific-event-name", event_name);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "expires", expires);
		switch_event_fire(&event);
	}

	return 0;
}

static int sofia_presence_resub_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	struct resub_helper *h = (struct resub_helper *) pArg;
	sofia_profile_t *profile = h->profile;
	char *user = argv[0];
	char *host = argv[1];
	char *status = argv[2];
	char *rpid = argv[3];
	char *proto = argv[4];
	char *call_id = NULL;
	char *presence_id = NULL;
	char *to_user = NULL;
	char *uuid = NULL;
	char *state = NULL;
	char *direction = NULL;
	switch_event_t *event;
	char to_buf[128] = "";
	switch_event_header_t *hp;
	char *free_me = NULL;
	int do_event = 1, i;


	if (mod_sofia_globals.debug_presence > 1) {
		for (i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_WARNING,  "sofia_presence_resub_callback: %d [%s]=[%s]\n", i, columnNames[i], argv[i]);
		}
	}

	if (argc > 5) {
		uuid = argv[5];
		state = switch_str_nil(argv[6]);
		direction = switch_str_nil(argv[7]);
		if (argc > 8) {
			switch_set_string(to_buf, argv[8]);
			switch_url_decode(to_buf);
			to_user = to_buf;
		}
		if (argc > 10 && !zstr(argv[10]) && !zstr(argv[11])) {
			status = argv[10];
			rpid = argv[11];
		}

		if (argc > 12 && !zstr(argv[12]) && strchr(argv[12], '@')) {
			char *p;

			presence_id = argv[12];
			free_me = strdup(presence_id);
			if ((p = strchr(free_me, '@'))) *p = '\0';
			user = free_me;
		}

		if (argc > 16) {
			call_id = argv[16];
		}

	}

	if (!zstr(uuid) && !switch_ivr_uuid_exists(uuid)) {
		if (mod_sofia_globals.debug_presence > 0) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "%s SKIPPING NOT FOUND UUID %s\n", profile->name, uuid);
		}
		do_event = 0;
	}

	if (zstr(proto)) {
		proto = NULL;
	}

	if (mod_sofia_globals.debug_presence > 0) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "%s PRESENCE_PROBE %s@%s\n", profile->name, user, host);
	}

	if (do_event && switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", proto ? proto : SOFIA_CHAT_PROTO);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", profile->url);

		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", user, host);

		if (h->noreg) {
			switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Force-Direction", "inbound");
		}

		if (!zstr(call_id)) {
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "call-id", call_id);
		}

		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "resub", "true");
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "status", status);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", rpid);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
		switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", 0);

		if (!zstr(to_user)) {
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "to-user", to_user);
		}

		if (zstr(state)) {
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_HANGUP");
			//switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", "resubscribe");
		} else {
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "channel-state", "CS_ROUTING");
			if (uuid) {
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "unique-id", uuid);
			}
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "answer-state", state);
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "astate", state);
			switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-direction", direction);
		}

		if (h->event) {
			for (hp = h->event->headers; hp; hp = hp->next) {
				if (!strncasecmp(hp->name, "fwd-", 4)) {
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, hp->name + 4, hp->value);
				}
			}
		}


		switch_event_fire(&event);
	}



	switch_safe_free(free_me);


	h->rowcount++;


	return 0;
}

char *get_display_name_from_contact(const char *in, char* dst)
{
	// name-addr      =  [ display-name ] LAQUOT addr-spec RAQUOT
	// display-name   =  *(token LWS)/ quoted-string
	// return whatever comes before the left angle bracket, stripped of whitespace and quotes
	char *p;
	char *buf;

	strcpy(dst, "");
	if (strchr(in, '<') && strchr(in, '>')) {
		buf = strdup(in);
		p = strchr(buf, '<');
		*p = '\0';
		if (!zstr(buf)) {
			p = switch_strip_whitespace(buf);
			if (p) {
				if (*p == '"') {
					if (end_of(p+1) == '"') {
						char *q = strdup(p + 1);
						end_of(q) = '\0';
						strcpy(dst, q);
						switch_safe_free(q);
					}
				} else {
					strcpy(dst, p);
				}
				switch_safe_free(p);
			}
		}
		switch_safe_free(buf);
	}
	return dst;
}

static int sofia_dialog_probe_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	struct rfc4235_helper *h = (struct rfc4235_helper *) pArg;

	char *proto = argv[0];
	char *user = argv[1];
	char *host = argv[2];
	char *uuid = argv[3];
	char *call_id = argv[4];
	char *state = argv[5];
	char *direction = argv[6];
	char *to_user = argv[7];
	char *to_host = argv[8];
	char *from_user = argv[9];
	//    char *from_host = argv[10];
	char *contact = switch_str_nil(argv[11]);
	char *contact_user = switch_str_nil(argv[12]);
	char *contact_host = switch_str_nil(argv[13]);
	char *to_tag = switch_str_nil(argv[14]);
	char *from_tag = switch_str_nil(argv[15]);
	char *orig_proto = switch_str_nil(argv[16]);

	const char *event_status = "";
	char *data = NULL, *tmp;
	char key[256] = "";
	char *local_user;
	char *local_host;
	char *remote_user;
	char *remote_host;
	char *remote_uri;
	char *local_user_param = "";
	char remote_display_buf[512];
	char *buf_to_free = NULL;
	int bInternal = 0;
	int i;
	int skip_proto = 0;

	if (mod_sofia_globals.debug_presence > 1) {
		for (i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG,SWITCH_LOG_WARNING,  "sofia_dialog_probe_callback: %d [%s]=[%s]\n", i, columnNames[i], argv[i]);
		}
	}

	if (zstr(to_user) || zstr(contact_user)) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "sofia_dialog_probe_callback: not enough info to generate a dialog entry\n");
		return 0;
	}

	// Usually we report the dialogs FROM the probed user.  The exception is when the monitored endpoint is internal,
	// and its presence_id is set in the dialplan.  Reverse the direction if this is not a registered entity.
	if (!strcmp(direction, "inbound") && strcmp(user, from_user) ) {
		// If inbound and the entity is not the caller (i.e. internal to FS), then the direction is reversed
		// because it is not going through the B2BUA
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "sofia_dialog_probe_callback: endpt is internal\n");
		direction = !strcasecmp(direction, "outbound") ? "inbound" : "outbound";
		bInternal = 1;
	}

	if (!strcasecmp(direction, "outbound")) {
		direction = "recipient";
	}
	else {
		direction = "initiator";
	}

	if (!zstr(orig_proto) && !strcmp(orig_proto, SOFIA_CHAT_PROTO)) {
		skip_proto = 1;
	}

	local_host = to_host;
	if (proto && !strcasecmp(proto, "queue")) {
		local_user = to_user;
		local_user_param = switch_mprintf(";proto=%s", proto);
		event_status = "hold";
		if (skip_proto) {
			buf_to_free = switch_mprintf("sip:%s", to_user);
		} else {
			buf_to_free = switch_mprintf("sip:queue+%s", to_user);
		}
		remote_uri = buf_to_free;
		strcpy(remote_display_buf, "queue");
		remote_user = to_user;
		remote_host = local_host;
	}
	else if (proto && !strcasecmp(proto, "park")) {
		local_user = to_user;
		local_user_param = switch_mprintf(";proto=%s", proto);
		event_status = "hold";
		if (skip_proto) {
			buf_to_free = switch_mprintf("sip:%s", to_user);
		} else {
			buf_to_free = switch_mprintf("sip:park+%s", to_user);
		}
		remote_uri = buf_to_free;
		strcpy(remote_display_buf, "park");
		remote_user = to_user;
		remote_host = local_host;
	}
	else if (proto && !strcasecmp(proto, "conf")) {
		local_user = to_user;
		local_user_param = switch_mprintf(";proto=%s", proto);
		if (skip_proto) { 
			buf_to_free = switch_mprintf("sip:%s@%s", to_user, host);
		} else {
			buf_to_free = switch_mprintf("sip:conf+%s@%s", to_user, host);
		}
		remote_uri = buf_to_free;
		strcpy(remote_display_buf, "conference");
		remote_user = to_user;
		remote_host = local_host;
	}
	else if (bInternal) {
		local_user = to_user;
		get_display_name_from_contact(contact, remote_display_buf);
		buf_to_free = sofia_glue_strip_uri(contact);
		remote_uri = buf_to_free;
		remote_user = contact_user;
		remote_host = contact_host;
	} else {
		local_user = from_user;
		buf_to_free = switch_mprintf("**%s@%s", from_user, local_host);
		remote_uri = buf_to_free;
		strcpy(remote_display_buf, to_user);
		remote_user = to_user;
		remote_host = local_host;
	}

	switch_snprintf(key, sizeof(key), "%s%s", user, host);
	data = switch_core_hash_find(h->hash, key);
	if (!data) {
		data = "";
	}
	tmp = switch_core_sprintf(h->pool, "%s"
							  "<dialog id=\"%s\" call-id=\"%s\" local-tag=\"%s\" remote-tag=\"%s\" direction=\"%s\">\n"
							  " <state>%s</state>\n"
							  " <local>\n"
							  "  <identity display=\"%s\">sip:%s@%s%s</identity>\n"
							  "  <target uri=\"sip:%s@%s\">\n"
							  "   <param pname=\"+sip.rendering\" pvalue=\"%s\"/>\n"
							  "  </target>\n"
							  " </local>\n"
							  " <remote>\n"
							  "  <identity display=\"%s\">sip:%s@%s</identity>\n"
							  "  <target uri=\"%s\"/>\n"
							  " </remote>\n"
							  "</dialog>\n",
							  data,
							  uuid, call_id, to_tag, from_tag, direction,
							  state,
							  local_user, local_user, local_host, local_user_param,
							  local_user, local_host,
							  !strcasecmp(event_status, "hold") ? "no" : "yes",
							  remote_display_buf, remote_user, remote_host,
							  remote_uri
							  );
	switch_core_hash_insert(h->hash, key, tmp);
	switch_safe_free(buf_to_free);

	h->rowcount++;

	return 0;
}

#define send_presence_notify(_a,_b,_c,_d,_e,_f,_g,_h,_i,_j,_k,_l) \
_send_presence_notify(_a,_b,_c,_d,_e,_f,_g,_h,_i,_j,_k,_l,__FILE__, __SWITCH_FUNC__, __LINE__)

static void _send_presence_notify(sofia_profile_t *profile, 
								  const char *full_to, 
								  const char *full_from, 
								  const char *o_contact,
								  const char *expires,
								  const char *call_id,
								  const char *event,
								  const char *remote_ip,
								  const char *remote_port,
								  const char *ct,
								  const char *pl,
								  const char *call_info,
								  const char *file, const char *func, int line
								 )
{
	char sstr[128] = "";
	nua_handle_t *nh;
	int exptime = 0;
	char expires_str[10] = "";
	sip_cseq_t *cseq = NULL;
	uint32_t callsequence;
	uint32_t now = (uint32_t) switch_epoch_time_now(NULL);
	char *our_contact = profile->url, *our_contact_dup = NULL;

	sofia_destination_t *dst = NULL;
	char *contact_str, *contact, *user_via = NULL;
	char *route_uri = NULL, *o_contact_dup = NULL, *tmp;
	const char *tp;
	
    tmp = (char *)o_contact;
	o_contact_dup = sofia_glue_get_url_from_contact(tmp, 1);

	
	if ((tp = switch_stristr("transport=", o_contact_dup))) {
		tp += 10;
	}

	if (zstr(tp)) {
		tp = "udp";
	}

	if (!switch_stristr("transport=", our_contact)) {
		our_contact_dup = switch_mprintf("<%s;transport=%s>", our_contact, tp);
		our_contact = our_contact_dup;
	}

	
   	if (!zstr(remote_ip) && sofia_glue_check_nat(profile, remote_ip)) {
		char *ptr = NULL;
		
		if ((ptr = sofia_glue_find_parameter(o_contact, "transport="))) {
			sofia_transport_t transport = sofia_glue_str2transport(ptr);

			switch (transport) {
			case SOFIA_TRANSPORT_TCP:
				contact_str = profile->tcp_public_contact;
				break;
			case SOFIA_TRANSPORT_TCP_TLS:
				contact_str = profile->tls_public_contact;
				break;
			default:
				contact_str = profile->public_url;
				break;
			}
			user_via = sofia_glue_create_external_via(NULL, profile, transport);
		} else {
			user_via = sofia_glue_create_external_via(NULL, profile, SOFIA_TRANSPORT_UDP);
			contact_str = profile->public_url;
		}

	} else {
		contact_str = our_contact;
	}

	dst = sofia_glue_get_destination((char *) o_contact);
	switch_assert(dst);

	if (!zstr(dst->contact)) {
		contact = sofia_glue_get_url_from_contact(dst->contact, 1);
	} else {
		contact = strdup(o_contact);
	}
		
	if (dst->route_uri) {
		route_uri = sofia_glue_strip_uri(dst->route_uri);
	} else {
		if (remote_ip && remote_port) {
			route_uri = switch_mprintf("sip:%s:%s;transport=%s", remote_ip, remote_port, tp);
		}
	}

	if (expires) {
		long ltmp = atol(expires);
		
		if (ltmp > 0) {
			exptime = (ltmp - now);
		} else {
			exptime = 0;
		}
	}


	
	if (exptime <= 0) {
		switch_snprintf(sstr, sizeof(sstr), "terminated;reason=noresource");
	} else {
		switch_snprintf(sstr, sizeof(sstr), "active;expires=%u", (unsigned) exptime);
	}

	if (mod_sofia_globals.debug_presence > 1) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SEND PRES NOTIFY:\n"
						  "file[%s]\nfunc[%s]\nline[%d]\n"
						  "profile[%s]\nvia[%s]\nip[%s]\nport[%s]\nroute[%s]\ncontact[%s]\nto[%s]\nfrom[%s]\nurl[%s]\ncall_id[%s]\nexpires_str[%s]\n"
						  "event[%s]\nct[%s]\npl[%s]\ncall_info[%s]\nexptime[%ld]\n",
						  file, func, line,
						  profile->name,
						  switch_str_nil(user_via),
						  remote_ip,
						  remote_port,
						  route_uri,
						  o_contact,
						  full_to,
						  full_from,
						  contact,
						  call_id,
						  expires_str,
						  event,
						  switch_str_nil(ct),
						  switch_str_nil(pl),
						  switch_str_nil(call_info),
						  (long)exptime
						  );
	}

	
	switch_mutex_lock(profile->ireg_mutex);
	if (!profile->cseq_base) {
		profile->cseq_base = (now - 1312693200) * 10;
	}
	callsequence = ++profile->cseq_base;
	switch_mutex_unlock(profile->ireg_mutex);
	

	nh = nua_handle(profile->nua, NULL, NUTAG_URL(contact), SIPTAG_CONTACT_STR(contact_str), TAG_END());
	cseq = sip_cseq_create(nh->nh_home, callsequence, SIP_METHOD_NOTIFY);
	nua_handle_bind(nh, &mod_sofia_globals.destroy_private);


	nua_notify(nh,
			   NUTAG_NEWSUB(1),
			   TAG_IF(dst->route_uri, NUTAG_PROXY(route_uri)), TAG_IF(dst->route, SIPTAG_ROUTE_STR(dst->route)),
			   TAG_IF(user_via, SIPTAG_VIA_STR(user_via)),

			   
			   SIPTAG_FROM_STR(full_to),
			   SIPTAG_TO_STR(full_from),
			   
			   SIPTAG_CALL_ID_STR(call_id),
			   TAG_IF(*expires_str, SIPTAG_EXPIRES_STR(expires_str)),
			   SIPTAG_SUBSCRIPTION_STATE_STR(sstr), 
			   SIPTAG_EVENT_STR(event), 
			   TAG_IF(!zstr(ct), SIPTAG_CONTENT_TYPE_STR(ct)),
			   TAG_IF(!zstr(pl), SIPTAG_PAYLOAD_STR(pl)),
			   TAG_IF(!zstr(call_info), SIPTAG_CALL_INFO_STR(call_info)),
			   TAG_IF(!exptime, SIPTAG_EXPIRES_STR("0")),
			   SIPTAG_CSEQ(cseq),
			   TAG_END());
	

	
	switch_safe_free(route_uri);
	switch_safe_free(contact);

	sofia_glue_free_destination(dst);
	switch_safe_free(user_via);
	switch_safe_free(o_contact_dup);


}


static int sofia_dialog_probe_notify_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	struct rfc4235_helper *sh = (struct rfc4235_helper *) pArg;
	char key[256] = "";
	char *data = NULL;
	char *call_id = argv[0];
	char *expires = argv[1];
	char *user = argv[2];
	char *host = argv[3];
	char *event = argv[4];
	char *version = argv[5];
	char *notify_state = argv[6];
	char *full_to = argv[7];
	char *full_from = argv[8];
	char *contact = argv[9];
	char *remote_ip = argv[10];
	char *remote_port = argv[11];
	
	switch_stream_handle_t stream = { 0 };
	char *to;
	const char *pl = NULL;
	const char *ct = "application/dialog-info+xml";

	if (mod_sofia_globals.debug_presence > 0) {
		int i;	
		for(i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "arg %d[%s] = [%s]\n", i, columnNames[i], argv[i]);
		}
	}

						 
	if (mod_sofia_globals.debug_presence > 0) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
						  "SEND DIALOG\nTo:      \t%s@%s\nFrom:    \t%s@%s\nCall-ID:  \t%s\n",
						  user, host, user, host, call_id);
	}

	to = switch_mprintf("sip:%s@%s", user, host);

	SWITCH_STANDARD_STREAM(stream);

	if (zstr(version)) {
		version = "0";
	}

	stream.write_function(&stream,
						  "<?xml version=\"1.0\"?>\n"
						  "<dialog-info xmlns=\"urn:ietf:params:xml:ns:dialog-info\" "
						  "version=\"%s\" state=\"%s\" entity=\"%s\">\n",
						  version,
						  notify_state, to);

	switch_snprintf(key, sizeof(key), "%s%s", user, host);

	data = switch_core_hash_find(sh->hash, key);

	if (data) {
		stream.write_function(&stream, "%s\n", data);
	}

	stream.write_function(&stream, "</dialog-info>\n");
	pl = stream.data;
	ct = "application/dialog-info+xml";

	if (mod_sofia_globals.debug_presence > 0 && pl) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "send payload:\n%s\n", pl);
	}


	send_presence_notify(sh->profile, 
						 full_to, 
						 full_from, 
						 contact,
						 expires,
						 call_id,
						 event,
						 remote_ip,
						 remote_port,
						 ct,
						 pl,
						 NULL
						 );


	switch_safe_free(to);
	switch_safe_free(stream.data);

	return 0;
}

static char *translate_rpid(char *in)
{
	char *r = in;

	if (in && (strstr(in, "null") || strstr(in, "NULL"))) {
		in = NULL;
	}

	if (zstr(in)) {
		return NULL;
	}

	if (!strcasecmp(in, "unknown")) {
		r = NULL;
		goto end;
	}

	if (!strcasecmp(in, "busy")) {
		r = in;
		goto end;
	}

	if (!strcasecmp(in, "unavailable")) {
		r = "away";
		goto end;
	}

	if (!strcasecmp(in, "idle")) {
		r = "busy";
	}

 end:
	return r;
}


static char *gen_pidf(char *user_agent, char *id, char *url, char *open, char *rpid, char *prpid, char *status, const char **ct)
{
	char *ret = NULL;

	if (switch_stristr("polycom", user_agent)) {
		*ct = "application/xpidf+xml";

		/* If unknown/none prpid is provided, just show the user as online. */
		if (!prpid || !strcasecmp(prpid, "unknown")) {
			prpid = "online";
		}

		/* of course!, lets make a big deal over dashes. Now the stupidity is complete. */
		if (!strcmp(prpid, "on-the-phone")) {
			prpid = "onthephone";
		}

		ret = switch_mprintf("<?xml version=\"1.0\"?>\n"
							 "<!DOCTYPE presence PUBLIC \"-//IETF//DTD RFCxxxx XPIDF 1.0//EN\" \"xpidf.dtd\">\n"
							 "<presence>\n"
							 " <status>\n"
							 "  <note>%s</note>\n"
							 " </status>\n"
							 " <presentity uri=\"%s;method=SUBSCRIBE\" />\n"
							 " <atom id=\"%s\">\n"
							 "  <address uri=\"%s;user=ip\" priority=\"0.800000\">\n"
							 "   <status status=\"%s\" />\n"
							 "   <msnsubstatus substatus=\"%s\" />\n" 
							 "  </address>\n" 
							 " </atom>\n" 
							 "</presence>\n", status, id, id, url, open, prpid);
	} else {
		char *xml_rpid = NULL;
		
		*ct = "application/pidf+xml";

		if (!strcasecmp(open, "closed")) {
			status = "Unregistered";
			prpid = NULL;
		}

		if (!strncasecmp(status, "Registered", 10)) {
			status = "Available";
		}
		
		if (!strcasecmp(status, "Available")) {
			prpid = NULL;
		}


		if (!strcasecmp(status, "Unregistered")) {
			prpid = NULL;
			open = "closed";
		}

		if (zstr(rpid)) {
			prpid = NULL;
		}


		if (zstr(status) && !zstr(prpid)) {
			status = "Available";
			prpid = NULL;
		}
		
		if (prpid) {
			xml_rpid = switch_mprintf("  <rpid:activities>\r\n"
									  "   <rpid:%s/>\n"
									  "  </rpid:activities>\n", prpid);
		}

		ret = switch_mprintf("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?> \n"
							 "<presence xmlns='urn:ietf:params:xml:ns:pidf' \n"
							 "xmlns:dm='urn:ietf:params:xml:ns:pidf:data-model' \n"
							 "xmlns:rpid='urn:ietf:params:xml:ns:pidf:rpid' \n"
							 "xmlns:c='urn:ietf:params:xml:ns:pidf:cipid' entity='%s'>\n"
							 " <tuple id='t6a5ed77e'>\n"
							 "  <status>\r\n"
							 "   <basic>%s</basic>\n"
							 "  </status>\n"
							 " </tuple>\n"
							 " <dm:person id='p06360c4a'>\n"
							 "%s"
							 "  <dm:note>%s</dm:note>\n"
							 " </dm:person>\n" 
							 "</presence>", id, open, switch_str_nil(xml_rpid), status);
		

		switch_safe_free(xml_rpid);
	}


	return ret;
}



static int sofia_presence_sub_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	struct presence_helper *helper = (struct presence_helper *) pArg;
	char *pl = NULL;
	char *clean_id = NULL, *id = NULL;

	char *proto = argv[0];
	char *user = argv[1];
	char *host = argv[2];
	char *sub_to_user = argv[3];
	char *event = argv[5];
	char *contact = argv[6];
	char *call_id = argv[7];
	char *full_from = argv[8];
	//char *full_via = argv[9];

	char *expires = argv[10];
	char *user_agent = argv[11];
	char *profile_name = argv[13];
	uint32_t in = 0;
	char *status = argv[14];
	char *rpid = argv[15];
	char *sub_to_host = argv[16];
	char *open_closed = NULL;
	char *dialog_status = NULL;
	char *dialog_rpid = NULL;

	const char *ct = "no/idea";

	char *to = NULL;
	char *open;
	char *prpid;

	int is_dialog = 0;
	sofia_profile_t *ext_profile = NULL, *profile = helper->profile;

	char status_line[256] = "";
	char *version = "0";
	char *presence_id = NULL;
	char *free_me = NULL;
	int holding = 0;
	char *orig_proto = NULL;
	int skip_proto = 0;
	char *full_to = NULL;
	char *ip = NULL;
	char *port = 0;

	if (mod_sofia_globals.debug_presence > 0) {
		int i;	
		for(i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "arg %d[%s] = [%s]\n", i, columnNames[i], argv[i]);
		}
		DUMP_EVENT(helper->event);
	}

	if (argc > 18) {
		if (!zstr(argv[17])) {
			status = argv[17];
		}
		if (!zstr(argv[18])) {
			rpid = argv[18];
		}
		open_closed = argv[19];
	}

	if (argc > 20) {
		dialog_status = argv[20];
		dialog_rpid = argv[21];
		version = argv[22];
		presence_id = argv[23];
		orig_proto = argv[24];
		full_to = argv[25];
		ip = argv[26];
		port = argv[27];
	}


	if (!zstr(presence_id) && strchr(presence_id, '@')) {
		char *p;
		 
		free_me = strdup(presence_id);

		if ((p = strchr(free_me, '@'))) {
			*p = '\0';
		}

		user = free_me;
	}
	

	if (!zstr(orig_proto) && !strcmp(orig_proto, SOFIA_CHAT_PROTO)) {
		skip_proto = 1;
	}

	in = helper->event && helper->event->event_id == SWITCH_EVENT_PRESENCE_IN;

	if (zstr(rpid)) {
		rpid = "unknown";
	}

	if (zstr(status)) {
		if (!strcasecmp(rpid, "busy")) {
			status = "Busy";
		} else if (!strcasecmp(rpid, "unavailable")) {
			status = "Idle";
		} else if (!strcasecmp(rpid, "away")) {
			status = "Idle";
		} else {
			status = "Available";
		}
	}

	if (status && !strncasecmp(status, "hold", 4)) {
		holding = 1;
	}

	if (profile_name && strcasecmp(profile_name, helper->profile->name)) {
		if ((ext_profile = sofia_glue_find_profile(profile_name))) {
			profile = ext_profile;
		}
	}


	if (!strcasecmp(proto, SOFIA_CHAT_PROTO) || skip_proto) {
		clean_id = switch_mprintf("sip:%s@%s", sub_to_user, sub_to_host);
	} else {
		clean_id = switch_mprintf("sip:%s+%s@%s", proto, sub_to_user, sub_to_host);
	}



	if (!rpid) {
		rpid = "unknown";
	}
	
	//	if (!strcasecmp(proto, SOFIA_CHAT_PROTO) || skip_proto) {
	//		clean_id = switch_mprintf("sip:%s@%s", sub_to_user, sub_to_host);
	//} else {
	//		clean_id = switch_mprintf("sip:%s+%s@%s", proto, sub_to_user, sub_to_host);
	//}

	if (mod_sofia_globals.debug_presence > 0) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
						  "SEND PRESENCE\nTo:      \t%s@%s\nFrom:    \t%s@%s\nCall-ID:  \t%s\nProfile:\t%s [%s]\n\n",
						  user, host, sub_to_user, sub_to_host, call_id, profile_name, helper->profile->name);
	}

	if (!strcasecmp(sub_to_host, host) && !skip_proto) {
		/* same host */
		id = switch_mprintf("sip:%s+%s@%s", proto, sub_to_user, sub_to_host);
	} else if (strcasecmp(proto, SOFIA_CHAT_PROTO) && !skip_proto) {
		/*encapsulate */
		id = switch_mprintf("sip:%s+%s+%s@%s", proto, sub_to_user, sub_to_host, host);
	} else {
		id = switch_mprintf("sip:%s@%s", sub_to_user, sub_to_host);
	}

	to = switch_mprintf("sip:%s@%s", user, host);

	is_dialog = !strcmp(event, "dialog");

	if (helper->event) {
		switch_stream_handle_t stream = { 0 };
		const char *direction = switch_str_nil(switch_event_get_header(helper->event, "presence-call-direction"));
		//const char *force_direction = switch_str_nil(switch_event_get_header(helper->event, "force-direction"));
		const char *uuid = switch_str_nil(switch_event_get_header(helper->event, "unique-id"));
		const char *event_status = switch_str_nil(switch_event_get_header(helper->event, "status"));
		const char *resub = switch_str_nil(switch_event_get_header(helper->event, "resub"));
		const char *force_event_status = switch_str_nil(switch_event_get_header(helper->event, "force-status"));
		const char *astate = switch_str_nil(switch_event_get_header(helper->event, "astate"));
		const char *answer_state = switch_str_nil(switch_event_get_header(helper->event, "answer-state"));
		const char *dft_state;
		const char *from_id;
		const char *to_user = switch_str_nil(switch_event_get_header(helper->event, "variable_sip_to_user"));
		const char *from_user = switch_str_nil(switch_event_get_header(helper->event, "variable_sip_from_user"));
		char *clean_to_user = NULL;
		char *clean_from_user = NULL;
		int force_status = 0;
		const char *call_state = switch_event_get_header(helper->event, "channel-state");


		if (call_state && !strcasecmp(call_state, "cs_hangup")) {
			astate = "hangup";
		}

		if (event_status && !strncasecmp(event_status, "hold", 4)) {
			holding = 1;
		}

		if (force_event_status && !event_status) {
			event_status = force_event_status;
		}

		if (event_status && !strncasecmp(event_status, "hold", 4)) {
			holding = 1;
		}

		if (!strcasecmp(direction, "inbound")) {
			from_id = switch_str_nil(switch_event_get_header(helper->event, "Caller-Destination-Number"));
		} else {
			from_id = switch_str_nil(switch_event_get_header(helper->event, "Other-Leg-Caller-ID-Number"));
		}
#if 0
		char *buf;
		switch_event_serialize(helper->event, &buf, SWITCH_FALSE);
		switch_assert(buf);
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "CHANNEL_DATA:\n%s\n", buf);
		free(buf);
#endif

		if (is_dialog) {
			SWITCH_STANDARD_STREAM(stream);
		}
		
		if (is_dialog) {
			// Usually we report the dialogs FROM the probed user.  The exception is when the monitored endpoint is internal,
			// and its presence_id is set in the dialplan.  Reverse the direction if this is not a registered entity.
			const char *caller = switch_str_nil(switch_event_get_header(helper->event, "caller-username"));
			if (!strcmp(direction, "inbound") && strcmp(sub_to_user,  caller)) {
				// If inbound and the entity is not the caller (i.e. internal to FS), then the direction is reversed
				// because it is not going through the B2BUA
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "sofia_presence_sub_callback: endpt is internal\n");
				direction = !strcasecmp(direction, "outbound") ? "inbound" : "outbound";
			}

		}

		if (!strcasecmp(direction, "outbound")) {
			direction = "recipient";
			dft_state = "early";
		} else {
			direction = "initiator";
			dft_state = "confirmed";
		}

		if (is_dialog) {
			if (zstr(version)) {
				version = "0";
			}

			stream.write_function(&stream,
								  "<?xml version=\"1.0\"?>\n"
								  "<dialog-info xmlns=\"urn:ietf:params:xml:ns:dialog-info\" "
								  "version=\"%s\" state=\"partial\" entity=\"%s\">\n", version, clean_id);
								  
								  
		}

		if (!zstr(uuid)) {
			if (!zstr(answer_state)) {
				astate = answer_state;
			}
			
			if (zstr(astate)) {
				if (is_dialog) {
					astate = dft_state;
				} else {
					astate = "terminated";
				}
			}

			if (!strcasecmp(astate, "answered")) {
				astate = "confirmed";
			}

			if (!strcasecmp(astate, "hangup")) {
				astate = "terminated";
			}

			if (is_dialog) {

				if (!strcasecmp(astate, "ringing")) {
					if (!strcasecmp(direction, "recipient")) {
						astate = "early";
					} else {
						astate = "confirmed";
					}
				}

				if (holding) {
					astate = "early";
				}
				
				stream.write_function(&stream, "<dialog id=\"%s\" direction=\"%s\">\n", uuid, direction);
				stream.write_function(&stream, "<state>%s</state>\n", astate);
			} else {
				if (!strcasecmp(astate, "ringing")) {
					astate = "early";
				}
			}
			

			if (!strcasecmp(astate, "early") || !strcasecmp(astate, "confirmed")) {

				clean_to_user = switch_mprintf("%s", sub_to_user ? sub_to_user : to_user);
				clean_from_user = switch_mprintf("%s", from_id ? from_id : from_user);

				if (is_dialog) {
					if (!zstr(clean_to_user) && !zstr(clean_from_user)) {
						stream.write_function(&stream, "<local>\n<identity display=\"%s\">sip:%s@%s</identity>\n", clean_to_user, clean_to_user, host);
						stream.write_function(&stream, "<target uri=\"sip:%s@%s\">\n", clean_to_user, host);
						stream.write_function(&stream, "<param pname=\"+sip.rendering\" pvalue=\"%s\"/>\n", holding ? "no" : "yes");
											  
						stream.write_function(&stream, "</target>\n</local>\n");
						if (switch_true(switch_event_get_header(helper->event, "Presence-Privacy"))) {
							stream.write_function(&stream, "<remote>\n<identity display=\"Anonymous\">sip:anonymous@anonymous.invalid</identity>\n");
						} else {
							stream.write_function(&stream, "<remote>\n<identity display=\"%s\">sip:%s@%s</identity>\n", clean_from_user, clean_from_user,
												  host);
						}
						stream.write_function(&stream, "<target uri=\"sip:**%s@%s\"/>\n", clean_to_user, host);
						stream.write_function(&stream, "</remote>\n");
					} else if (!strcasecmp(proto, "queue")) {
						stream.write_function(&stream, "<local>\n<identity display=\"queue\">sip:%s@%s;proto=queue</identity>\n",
											  !zstr(clean_to_user) ? clean_to_user : "unknown", host);
						stream.write_function(&stream, "<target uri=\"sip:%s@%s;proto=fifo\">\n", !zstr(clean_to_user) ? clean_to_user : "unknown", host);
						stream.write_function(&stream, "<param pname=\"+sip.rendering\" pvalue=\"no\"/>\n</target>\n</local>\n");
						stream.write_function(&stream, "<remote>\n<identity display=\"queue\">sip:%s</identity>\n", uuid);
						if (skip_proto) {
							stream.write_function(&stream, "<target uri=\"sip:%s\"/>\n", uuid);
						} else {
							stream.write_function(&stream, "<target uri=\"sip:queue+%s\"/>\n", uuid);
						}

						stream.write_function(&stream, "</remote>\n");
					} else if (!strcasecmp(proto, "park")) {
						stream.write_function(&stream, "<local>\n<identity display=\"park\">sip:%s@%s;proto=park</identity>\n",
											  !zstr(clean_to_user) ? clean_to_user : "unknown", host);
						stream.write_function(&stream, "<target uri=\"sip:%s@%s;proto=park\">\n", !zstr(clean_to_user) ? clean_to_user : "unknown", host);
						stream.write_function(&stream, "<param pname=\"+sip.rendering\" pvalue=\"no\"/>\n</target>\n</local>\n");
						stream.write_function(&stream, "<remote>\n<identity display=\"park\">sip:%s</identity>\n", uuid);
						if (skip_proto) {
							stream.write_function(&stream, "<target uri=\"sip:%s\"/>\n", uuid);
						} else {
							stream.write_function(&stream, "<target uri=\"sip:park+%s\"/>\n", uuid);
						}
						stream.write_function(&stream, "</remote>\n");
					} else if (!strcasecmp(proto, "conf")) {
						stream.write_function(&stream, "<local>\n<identity display=\"conference\">sip:%s@%s;proto=conference</identity>\n",
											  !zstr(clean_to_user) ? clean_to_user : "unknown", host);
						stream.write_function(&stream, "<target uri=\"sip:%s@%s;proto=conference\">\n", 
											  !zstr(clean_to_user) ? clean_to_user : "unknown", host);
						stream.write_function(&stream, "<param pname=\"+sip.rendering\" pvalue=\"yes\"/>\n</target>\n</local>\n");
						stream.write_function(&stream, "<remote>\n<identity display=\"conference\">sip:%s@%s</identity>\n", uuid, host);
						if (skip_proto) {
							stream.write_function(&stream, "<target uri=\"sip:%s@%s\"/>\n", uuid, host);
						} else {
							stream.write_function(&stream, "<target uri=\"sip:conf+%s@%s\"/>\n", uuid, host);
						}
						stream.write_function(&stream, "</remote>\n");
					}
				}

				switch_safe_free(clean_to_user);
				switch_safe_free(clean_from_user);
			}
			if (is_dialog) {
				stream.write_function(&stream, "</dialog>\n");
			}
		}

		if (is_dialog) {
			stream.write_function(&stream, "</dialog-info>\n");
			pl = stream.data;
			ct = "application/dialog-info+xml";
		}

		if (!zstr(astate) && !zstr(uuid) && 
			helper && helper->stream.data && strcmp(helper->last_uuid, uuid) && strcasecmp(astate, "terminated") && strchr(uuid, '-')) {
			helper->stream.write_function(&helper->stream, "update sip_dialogs set state='%s' where hostname='%q' and profile_name='%q' and uuid='%s';", 
										  mod_sofia_globals.hostname, profile->name, astate, uuid);
			switch_copy_string(helper->last_uuid, uuid, sizeof(helper->last_uuid));
		}

		if (zstr(astate)) astate = "";

		if (!is_dialog) {
			switch_set_string(status_line, status);

			if (in) {
				open = "open";

				if (switch_false(resub)) {
					int term;

					const char *direction = switch_event_get_header(helper->event, "Caller-Direction");
					const char *op, *what = "Ring";
				
					if (direction && !strcasecmp(direction, "outbound")) {
						op = switch_event_get_header(helper->event, "Other-Leg-Caller-ID-Number");
					} else {
						op = switch_event_get_header(helper->event, "Caller-Callee-ID-Number");
					}

					if (zstr(op)) {
						op = switch_event_get_header(helper->event, "Caller-Destination-Number");
					}

					if (direction) {
						what = strcasecmp(direction, "outbound") ? "Call" : "Ring";
					}

					if (!strcmp(astate, "early")) {
						if (!zstr(op)) {
							//switch_snprintf(status_line, sizeof(status_line), "%sing", what);
							//} else {
							switch_snprintf(status_line, sizeof(status_line), "%s %s", what, op);
						}

						rpid = "on-the-phone";
						force_status = 1;

					} else if (!strcmp(astate, "confirmed")) {
						if (!zstr(op)) {
							if (sofia_test_pflag(profile, PFLAG_PRESENCE_PRIVACY)) {
								switch_snprintf(status_line, sizeof(status_line), "On The Phone");
							} else {
								switch_snprintf(status_line, sizeof(status_line), "Talk %s", op);
							}
						} else {
							switch_snprintf(status_line, sizeof(status_line), "On The Phone");
						}

						rpid = "on-the-phone";
						force_status = 1;
					} else if (!strcmp(astate, "terminated")) {
						rpid = "online";
						dialog_rpid = "";
						force_event_status = "Available";
						term = 1;
					}
						
					if (!term && !strcmp(status, "hold")) {
						rpid = "on-the-phone";
						if (!zstr(op)) {
							switch_snprintf(status_line, sizeof(status_line), "Hold %s", op);
							force_status = 1;
						}
					}
				}
			} else {
				open = "closed";
			}

			if (open_closed) {
				open = open_closed;
			}
			
			prpid = translate_rpid(rpid);

			if (!zstr(dialog_status) && !force_status) {
				status = dialog_status;
				switch_set_string(status_line, status);
			}



			if (!zstr(force_event_status)) {
				switch_set_string(status_line, force_event_status);
			}

			
			if (!zstr(dialog_rpid)) {
				prpid = rpid = dialog_rpid;
			}
						
			pl = gen_pidf(user_agent, clean_id, profile->url, open, rpid, prpid, status_line, &ct);
		}

	} else {
		if (in) {
			open = "open";
		} else {
			open = "closed";
		}

		if (open_closed) {
			open = open_closed;
		}

		prpid = translate_rpid(rpid);

		if (!zstr(dialog_status)) {
			status = dialog_status;
		}
		
		if (!zstr(dialog_rpid)) {
			prpid = rpid = dialog_rpid;
		}

		
		pl = gen_pidf(user_agent, clean_id, profile->url, open, rpid, prpid, status, &ct);
	}


	if (!is_dialog && helper->event && !switch_stristr("registered", status_line)){ 
		const char *uuid = switch_event_get_header_nil(helper->event, "unique-id");
		const char *register_source = switch_event_get_header_nil(helper->event, "register-source");
		
		if (!zstr(uuid) && strchr(uuid, '-') && !zstr(status_line) && !zstr(rpid) && (zstr(register_source) || strcasecmp(register_source, "register"))) {
		    char *sql = switch_mprintf("update sip_dialogs set rpid='%q',status='%q' where hostname='%q' and profile_name='%q' and uuid='%q'", 
									   mod_sofia_globals.hostname, profile->name,
									   rpid, status_line, uuid);
			sofia_glue_execute_sql(profile, &sql, SWITCH_TRUE);
		}
	}

	send_presence_notify(profile, full_to, full_from, contact, expires, call_id, event, ip, port, ct, pl, NULL);

	switch_safe_free(free_me);

	if (ext_profile) {
		sofia_glue_release_profile(ext_profile);
	}

	switch_safe_free(id);
	switch_safe_free(clean_id);
	switch_safe_free(pl);
	switch_safe_free(to);

	return 0;
}

static int sofia_presence_mwi_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	//char *sub_to_user = argv[3];
	//char *sub_to_host = argv[4];
	char *event = argv[5];
	char *contact = argv[6];
	char *call_id = argv[7];
	char *full_from = argv[8];
	char *expires = argv[10];
	char *profile_name = argv[13];
	char *body = argv[15];
	char *full_to = argv[16];
	char *remote_ip = argv[17];
	char *remote_port = argv[18];
	
	struct mwi_helper *h = (struct mwi_helper *) pArg;
	sofia_profile_t *ext_profile = NULL, *profile = h->profile;


	if (mod_sofia_globals.debug_presence > 0) {
		int i;	
		for(i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "arg %d[%s] = [%s]\n", i, columnNames[i], argv[i]);
		}
	}

	if (profile_name && strcasecmp(profile_name, h->profile->name)) {
		if ((ext_profile = sofia_glue_find_profile(profile_name))) {
			profile = ext_profile;
		}
	}

	send_presence_notify(profile, 
						 full_to, 
						 full_from, 
						 contact,
						 expires,
						 call_id,
						 event,
						 remote_ip,
						 remote_port,
						 "application/simple-message-summary",
						 body,
						 NULL
						 );


	h->total++;

	if (ext_profile) {
		sofia_glue_release_profile(ext_profile);
	}

	return 0;
}

static int sofia_presence_mwi_callback2(void *pArg, int argc, char **argv, char **columnNames)
{
	const char *user = argv[0];
	const char *host = argv[1];
	const char *event = "message-summary";
	const char *contenttype = "application/simple-message-summary";
	const char *body = argv[5];
	const char *o_contact = argv[2];
	const char *network_ip = argv[4];

	char *profile_name = argv[3];
	struct mwi_helper *h = (struct mwi_helper *) pArg;
	sofia_profile_t *ext_profile = NULL, *profile = h->profile;

	if (profile_name && strcasecmp(profile_name, h->profile->name)) {
		if ((ext_profile = sofia_glue_find_profile(profile_name))) {
			profile = ext_profile;
		}
	}

	sofia_glue_send_notify(profile, user, host, event, contenttype, body, o_contact, network_ip);

	if (ext_profile) {
		sofia_glue_release_profile(ext_profile);
	}

	return 0;
}

static int broadsoft_sla_notify_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	struct state_helper *sh = (struct state_helper *) pArg;
	char key[256] = "";
	char *data = NULL, *tmp;
	char *call_id = argv[0];
	//char *expires = argv[1];
	char *user = argv[2];
	char *host = argv[3];
	char *event = argv[4];
	int i;


	if (mod_sofia_globals.debug_sla > 1) {
		for (i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SLA3: %d [%s]=[%s]\n", i, columnNames[i], argv[i]);
		}
	}

	switch_snprintf(key, sizeof(key), "%s%s", user, host);
	data = switch_core_hash_find(sh->hash, key);
	

	data = switch_core_hash_find(sh->hash, key);

	if (data) {
		tmp = switch_core_sprintf(sh->pool, "%s,<sip:%s>;appearance-index=*;appearance-state=idle", data, host);
	} else {
		tmp = switch_core_sprintf(sh->pool, "<sip:%s>;appearance-index=*;appearance-state=idle", host);
	}

	
	if (!strcasecmp(event, "line-seize")) {
		char *hack;

		if ((hack = (char *) switch_stristr("=seized", tmp))) {
			switch_snprintf(hack, 7, "=idle  ");
		}
	}

	if (mod_sofia_globals.debug_sla > 1) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DB PRES NOTIFY: [%s]\n[%s]\n[%s]\n[%s]\n[%s]\n[%s]\n[%s]\n[%s]\n[%s]\n",
						  argv[5], argv[6], argv[7], argv[8], call_id, event, argv[9], argv[10], tmp);
		
	}
	
	send_presence_notify(sh->profile, argv[5], argv[6], argv[7], argv[8], call_id, event, argv[9], argv[10], NULL, NULL, tmp);

	sh->total++;
	
	return 0;
}

static int broadsoft_sla_gather_state_callback(void *pArg, int argc, char **argv, char **columnNames)
{
	struct state_helper *sh = (struct state_helper *) pArg;
	char key[256] = "";
	switch_core_session_t *session;
	const char *callee_name = NULL, *callee_number = NULL;
	char *data = NULL, *tmp;
	char *user = argv[0];
	char *host = argv[1];
	char *info = argv[2];
	char *state = argv[3];
	char *uuid = argv[4];
	int i;

	if (mod_sofia_globals.debug_sla > 1) {
		for (i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SLA2: %d [%s]=[%s]\n", i, columnNames[i], argv[i]);
		}
	}

	if (zstr(info)) {
		return 0;
	}

	if (zstr(state)) {
		state = "idle";
	}

	switch_snprintf(key, sizeof(key), "%s%s", user, host);

	data = switch_core_hash_find(sh->hash, key);

	if (uuid && (session = switch_core_session_locate(uuid))) {
		switch_channel_t *channel = switch_core_session_get_channel(session);

		if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {

			if (zstr((callee_name = switch_channel_get_variable(channel, "effective_callee_id_name"))) &&
				zstr((callee_name = switch_channel_get_variable(channel, "sip_callee_id_name")))) {
				callee_name = switch_channel_get_variable(channel, "callee_id_name");
			}
			
			if (zstr((callee_number = switch_channel_get_variable(channel, "effective_callee_id_number"))) &&
				zstr((callee_number = switch_channel_get_variable(channel, "sip_callee_id_number"))) &&
				zstr((callee_number = switch_channel_get_variable(channel, "callee_id_number")))) {
				callee_number = switch_channel_get_variable(channel, "destination_number");
			}
		} else {
			callee_name = switch_channel_get_variable(channel, "caller_id_name");
			callee_number = switch_channel_get_variable(channel, "caller_id_number");
		}
		
		if (zstr(callee_name) && !zstr(callee_number)) {
			callee_name = callee_number;
		}

		if (!zstr(callee_number)) {
			callee_number = switch_sanitize_number(switch_core_session_strdup(session, callee_number));
		}

		if (!zstr(callee_name)) {
			callee_name = switch_sanitize_number(switch_core_session_strdup(session, callee_name));
		}
		switch_core_session_rwunlock(session);
	}

	if (!zstr(callee_number)) {
		if (zstr(callee_name)) {
			callee_name = "unknown";
		}
		
		if (data) {
			tmp = switch_core_sprintf(sh->pool,
									  "%s,<sip:%s>;%s;appearance-state=%s;appearance-uri=\"\\\"%s\\\" <sip:%s@%s>\"",
									  data, host, info, state, callee_name, callee_number, host);
		} else {
			tmp = switch_core_sprintf(sh->pool,
									  "<sip:%s>;%s;appearance-state=%s;appearance-uri=\"\\\"%s\\\" <sip:%s@%s>\"",
									  host, info, state, callee_name, callee_number, host);
		}
	} else {
		if (data) {
			tmp = switch_core_sprintf(sh->pool, "%s,<sip:%s>;%s;appearance-state=%s", data, host, info, state);
		} else {
			tmp = switch_core_sprintf(sh->pool, "<sip:%s>;%s;appearance-state=%s", host, info, state);
		}
	}

	switch_core_hash_insert(sh->hash, key, tmp);

	return 0;
}

static int sync_sla(sofia_profile_t *profile, const char *to_user, const char *to_host, switch_bool_t clear, switch_bool_t unseize, const char *call_id)
{
	struct state_helper *sh;
	switch_memory_pool_t *pool;
	char *sql;
	int total = 0;

	switch_core_new_memory_pool(&pool);
	sh = switch_core_alloc(pool, sizeof(*sh));
	sh->pool = pool;
	switch_core_hash_init(&sh->hash, sh->pool);

	sql = switch_mprintf("select sip_from_user,sip_from_host,call_info,call_info_state,uuid from sip_dialogs "
						 "where call_info_state is not null and hostname='%q' and profile_name='%q' "
						 "and ((sip_from_user='%q' and sip_from_host='%q') or presence_id='%q@%q') "
						 "and profile_name='%q'", 
						 mod_sofia_globals.hostname, profile->name, to_user, to_host, to_user, to_host, profile->name);


	if (mod_sofia_globals.debug_sla > 1) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "PRES SQL %s\n", sql);
	}
	sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, broadsoft_sla_gather_state_callback, sh);
	switch_safe_free(sql);


	if (!zstr(call_id)) {

		if (unseize) {
			sql = switch_mprintf("select call_id,expires,sub_to_user,sub_to_host,event,full_to,full_from,contact,expires,network_ip,network_port "
								 "from sip_subscriptions where call_id='%q' and hostname='%q' and profile_name='%q')", 
								 mod_sofia_globals.hostname, call_id, profile->name);

		} else {
			sql = switch_mprintf("select call_id,expires,sub_to_user,sub_to_host,event,full_to,full_from,contact,expires,network_ip,network_port "
								 "from sip_subscriptions where call_id='%q' and hostname='%q' and profile_name='%q'",
								 mod_sofia_globals.hostname, call_id, profile->name);
		}

	} else {

		if (unseize) {
			sql = switch_mprintf("select call_id,expires,sub_to_user,sub_to_host,event,full_to,full_from,contact,expires,network_ip,network_port "
								 "from sip_subscriptions "
								 "where hostname='%q' and profile_name='%q' "
								 "and sub_to_user='%q' and sub_to_host='%q' "
								 "and (event='call-info' or event='line-seize') and (profile_name='%q' or presence_hosts like '%%%q%%')", 
								 mod_sofia_globals.hostname, profile->name, to_user, to_host, profile->name, to_host);
		} else {
			sql = switch_mprintf("select call_id,expires,sub_to_user,sub_to_host,event,full_to,full_from,contact,expires,network_ip,network_port "
								 "from sip_subscriptions "
								 "where hostname='%q' and profile_name='%q' "
								 "and sub_to_user='%q' and sub_to_host='%q' " "and (event='call-info') and "
								 "(profile_name='%q' or presence_hosts like '%%%q%%')", 
								 mod_sofia_globals.hostname, profile->name, to_user, to_host, profile->name, to_host);
		}
	}

	if (mod_sofia_globals.debug_sla > 1) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "PRES SQL %s\n", sql);
	}

	sh->profile = profile;
	sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, broadsoft_sla_notify_callback, sh);
	switch_safe_free(sql);
	total = sh->total;
	sh = NULL;
	switch_core_destroy_memory_pool(&pool);



	if (clear) {
		sql = switch_mprintf("delete from sip_dialogs where hostname='%q' and profile_name='%q' and "
							 "((sip_from_user='%q' and sip_from_host='%q') or presence_id='%q@%q') "
							 "and call_info_state='seized'", mod_sofia_globals.hostname, profile->name, to_user, to_host, to_user, to_host);


		if (mod_sofia_globals.debug_sla > 1) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "CLEAR SQL %s\n", sql);
		}
		sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
	}

	return total;

}

void sofia_presence_handle_sip_i_subscribe(int status,
										   char const *phrase,
										   nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, sofia_private_t *sofia_private, sip_t const *sip,
										   sofia_dispatch_event_t *de,
										   tagi_t tags[])
{

	long exp_delta = 0;
	char exp_delta_str[30] = "";
	sip_to_t const *to;
	const char *from_user = NULL, *from_host = NULL;
	const char *to_user = NULL, *to_host = NULL;
	char *my_to_user = NULL;
	char *sql, *event = NULL;
	char *proto = "sip";
	char *orig_proto = "";
	char *alt_proto = NULL;
	char *d_user = NULL;
	char *contact_str = "";
	const char *call_id = NULL;
	char *to_str = NULL;
	char *full_from = NULL;
	char *full_to = NULL;
	char *full_via = NULL;
	char *full_agent = NULL;
	char *sstr;
	switch_event_t *sevent;
	int sub_state = nua_substate_pending;
	int sent_reply = 0;
	sip_contact_t const *contact;
	const char *ipv6;
	const char *contact_user;
	sofia_nat_parse_t np = { { 0 } };
	int found_proto = 0;
	char to_tag[13] = "";
	char buf[32] = "";
	int subbed = 0;

	if (!sip) {
		return;
	}

	to = sip->sip_to;
	contact = sip->sip_contact;

	np.fs_path = 1;
	if (!(contact_str = sofia_glue_gen_contact_str(profile, sip, nh, de, &np))) {
		nua_respond(nh, 481, "INVALID SUBSCRIPTION", TAG_END());
		return;
	}

	switch_stun_random_string(to_tag, 12, NULL);

	//contact_host = sip->sip_contact->m_url->url_host;
	contact_user = sip->sip_contact->m_url->url_user;

	//tl_gets(tags, NUTAG_SUBSTATE_REF(sub_state), TAG_END());

	//sip->sip_subscription_state->ss_substate

	if (sip->sip_subscription_state && sip->sip_subscription_state->ss_substate) {
		if (switch_stristr("terminated", sip->sip_subscription_state->ss_substate)) {
			sub_state = nua_substate_terminated;
		} else if (switch_stristr("active", sip->sip_subscription_state->ss_substate)) {
			sub_state = nua_substate_active;
		}
	}

	event = sip_header_as_string(nh->nh_home, (void *) sip->sip_event);

	if (to) {
		to_str = switch_mprintf("sip:%s@%s", to->a_url->url_user, to->a_url->url_host);
	}

	if (to) {
		to_user = to->a_url->url_user;
		to_host = to->a_url->url_host;
	}

	if (profile->sub_domain) {
		to_host = profile->sub_domain;
	}

	if (sip->sip_from) {
		from_user = sip->sip_from->a_url->url_user;
		from_host = sip->sip_from->a_url->url_host;
	} else {
		from_user = "n/a";
		from_host = "n/a";
	}

	if ((exp_delta = sip->sip_expires ? sip->sip_expires->ex_delta : 3600)) {
		if ((profile->force_subscription_expires > 0) && (profile->force_subscription_expires < (uint32_t)exp_delta)) {
			exp_delta = profile->force_subscription_expires;
		}
	}

	if (mod_sofia_globals.debug_presence > 0 || mod_sofia_globals.debug_sla > 0) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DELTA %ld\n", exp_delta);
	}

	if (!exp_delta) {
		sub_state = nua_substate_terminated;
	}

	switch_snprintf(exp_delta_str, sizeof(exp_delta_str), "%ld", exp_delta);

	if (to_user && strchr(to_user, '+')) {
		char *h;
		if ((proto = (d_user = strdup(to_user)))) {
			if ((my_to_user = strchr(d_user, '+'))) {
				*my_to_user++ = '\0';
				to_user = my_to_user;
				if ((h = strchr(to_user, '+')) || (h = strchr(to_user, '@'))) {
					*h++ = '\0';
					to_host = h;
				}
			}
		}

		if (!(proto && to_user && to_host)) {
			nua_respond(nh, SIP_404_NOT_FOUND, NUTAG_WITH_THIS_MSG(de->data->e_msg), TAG_END());
			goto end;
		}

		found_proto++;
	}

	call_id = sip->sip_call_id->i_id;
	full_from = sip_header_as_string(nh->nh_home, (void *) sip->sip_from);
	full_to = sip_header_as_string(nh->nh_home, (void *) sip->sip_to);
	full_via = sip_header_as_string(nh->nh_home, (void *) sip->sip_via);


	if (sip->sip_expires && sip->sip_expires->ex_delta > 31536000) {
		sip->sip_expires->ex_delta = 31536000;
	}

	if (sofia_test_pflag(profile, PFLAG_PRESENCE_MAP) && !found_proto && (alt_proto = switch_ivr_check_presence_mapping(to_user, to_host))) {
		orig_proto = proto;
		proto = alt_proto;
	}
	
	if ((sub_state != nua_substate_terminated)) {
		sql = switch_mprintf("select count(*) from sip_subscriptions where call_id='%q' and hostname='%q' and profile_name='%q'", 
							 call_id, mod_sofia_globals.hostname, profile->name);
		sofia_glue_execute_sql2str(profile, profile->ireg_mutex, sql, buf, sizeof(buf));


		if (mod_sofia_globals.debug_presence > 0 || mod_sofia_globals.debug_sla > 0) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
							  "check subs sql: %s [%s]\n", sql, buf);
		}

		switch_safe_free(sql);

		if ((subbed = atoi(buf)) > 0) {
			sub_state = nua_substate_active;
		}
	}

	if (sub_state == nua_substate_active) {
		
		sstr = switch_mprintf("active;expires=%ld", exp_delta);
		
		sql = switch_mprintf("update sip_subscriptions "
							 "set expires=%ld,contact='%q' "
							 "where hostname='%q' and profile_name='%q' and call_id='%q' and profile_name='%q'",
							 (long) switch_epoch_time_now(NULL) + exp_delta, contact_str, mod_sofia_globals.hostname, profile->name,
							 call_id, profile->name);

		if (mod_sofia_globals.debug_presence > 0 || mod_sofia_globals.debug_sla > 0) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
							  "re-subscribe event %s, sql: %s\n", event, sql);
		}
		
		sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
	} else {

		if (sub_state == nua_substate_terminated) {
			sql = switch_mprintf("delete from sip_subscriptions where call_id='%q' and profile_name='%q' and hostname='%q'", 
								 call_id, profile->name, mod_sofia_globals.hostname);
		
			if (mod_sofia_globals.debug_presence > 0 || mod_sofia_globals.debug_sla > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
								  "sub del sql: %s\n", sql);		
			}
			
			switch_mutex_lock(profile->ireg_mutex);
			switch_assert(sql != NULL);
			sofia_glue_actually_execute_sql(profile, sql, NULL);
			switch_safe_free(sql);
			
			sstr = switch_mprintf("terminated;reason=noresource");
		} else {
			sip_accept_t *ap = sip->sip_accept;
			char accept[256] = "";

			sub_state = nua_substate_active;
			
			full_agent = sip_header_as_string(nh->nh_home, (void *) sip->sip_user_agent);
			while (ap) {
				switch_snprintf(accept + strlen(accept), sizeof(accept) - strlen(accept), "%s%s ", ap->ac_type, ap->ac_next ? "," : "");
				ap = ap->ac_next;
			}
			
			sql = switch_mprintf("insert into sip_subscriptions "
								 "(proto,sip_user,sip_host,sub_to_user,sub_to_host,presence_hosts,event,contact,call_id,full_from,"
								 "full_via,expires,user_agent,accept,profile_name,hostname,network_port,network_ip,version,orig_proto, full_to) "
								 "values ('%q','%q','%q','%q','%q','%q','%q','%q','%q','%q','%q',%ld,'%q','%q','%q','%q','%d','%q',-1,'%q','%q;tag=%q')",
								 proto, from_user, from_host, to_user, to_host, profile->presence_hosts ? profile->presence_hosts : "",
								 event, contact_str, call_id, full_from, full_via,
								 (long) switch_epoch_time_now(NULL) + exp_delta,
								 full_agent, accept, profile->name, mod_sofia_globals.hostname, 
								 np.network_port, np.network_ip, orig_proto, full_to, to_tag);

			switch_assert(sql != NULL);


			if (mod_sofia_globals.debug_presence > 0 || mod_sofia_globals.debug_sla > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "%s SUBSCRIBE %s@%s %s@%s\n%s\n",
								  profile->name, from_user, from_host, to_user, to_host, sql);
			}


			sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
			sstr = switch_mprintf("active;expires=%ld", exp_delta);
		}
		
		switch_mutex_unlock(profile->ireg_mutex);
	}

	if (status < 200) {
		char *sticky = NULL;
		char *contactstr = profile->url, *cs = NULL;
		char *p = NULL, *new_contactstr = NULL;
		

		if (np.is_nat) {
			char params[128] = "";
			if (contact->m_url->url_params) {
				switch_snprintf(params, sizeof(params), ";%s", contact->m_url->url_params);
			}
			ipv6 = strchr(np.network_ip, ':');
			sticky = switch_mprintf("sip:%s@%s%s%s:%d%s", contact_user, ipv6 ? "[" : "", np.network_ip, ipv6 ? "]" : "", np.network_port, params);
		}

		if (np.is_auto_nat) {
			contactstr = profile->public_url;
		} else {
			contactstr = profile->url;
		}


		if (switch_stristr("port=tcp", contact->m_url->url_params)) {
			if (np.is_auto_nat) {
				cs = profile->tcp_public_contact;
			} else {
				cs = profile->tcp_contact;
			}
		} else if (switch_stristr("port=tls", contact->m_url->url_params)) {
			if (np.is_auto_nat) {
				cs = profile->tls_public_contact;
			} else {
				cs = profile->tls_contact;
			}
		}

		if (cs) {
			contactstr = cs;
		}

			
		if (nh && nh->nh_ds && nh->nh_ds->ds_usage) {
			/* nua_dialog_usage_set_refresh_range(nh->nh_ds->ds_usage, exp_delta + SUB_OVERLAP, exp_delta + SUB_OVERLAP); */
			nua_dialog_usage_set_refresh_range(nh->nh_ds->ds_usage, exp_delta, exp_delta);
		}

		if (contactstr && (p = strchr(contactstr, '@'))) {
			if (strrchr(p, '>')) {
				new_contactstr = switch_mprintf("<sip:%s%s", to_user, p);
			} else {
				new_contactstr = switch_mprintf("<sip:%s%s>", to_user, p);
			}
		}
		
		sip_to_tag(nh->nh_home, sip->sip_to, to_tag);
		
		nua_respond(nh, SIP_202_ACCEPTED,
					SIPTAG_TO(sip->sip_to),
					TAG_IF(new_contactstr, SIPTAG_CONTACT_STR(new_contactstr)),
					NUTAG_WITH_THIS_MSG(de->data->e_msg),
					SIPTAG_SUBSCRIPTION_STATE_STR(sstr), SIPTAG_EXPIRES_STR(exp_delta_str), TAG_IF(sticky, NUTAG_PROXY(sticky)), TAG_END());

		switch_safe_free(new_contactstr);
		switch_safe_free(sticky);
	}

	if (sub_state == nua_substate_terminated) {
		char *full_call_info = NULL;
		char *p = NULL;

		if (sip->sip_call_info) {
			full_call_info = sip_header_as_string(nh->nh_home, (void *) sip->sip_call_info);
			if ((p = strchr(full_call_info, ';'))) {
				p++;
			}

#if 0
			nua_notify(nh,
					   SIPTAG_EXPIRES_STR("0"),
					   SIPTAG_SUBSCRIPTION_STATE_STR(sstr), TAG_IF(full_call_info, SIPTAG_CALL_INFO_STR(full_call_info)), TAG_END());
#endif

			if (!strcasecmp(event, "line-seize")) {
				if (mod_sofia_globals.debug_sla > 1) {
					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "CANCEL LINE SEIZE\n");
				}

				sql = switch_mprintf("delete from sip_dialogs where hostname='%q' and profile_name='%q' and "
									 "((sip_from_user='%q' and sip_from_host='%q') or presence_id='%q@%q') "
									 "and call_info_state='seized'",
									 mod_sofia_globals.hostname, profile->name, to_user, to_host, to_user, to_host);


				if (mod_sofia_globals.debug_sla > 1) {
					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "CLEAR SQL %s\n", sql);
				}
				sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);

				sync_sla(profile, to_user, to_host, SWITCH_FALSE, SWITCH_FALSE, NULL);
			}

			su_free(nh->nh_home, full_call_info);

		}
			
	} else {
		if (!strcasecmp(event, "line-seize")) {
			char *full_call_info = NULL;
			char *p;
			switch_time_t now;

			if (sip->sip_call_info) {
				full_call_info = sip_header_as_string(nh->nh_home, (void *) sip->sip_call_info);
				if ((p = strchr(full_call_info, ';'))) {
					p++;
				}

				nua_notify(nh,
						   SIPTAG_EXPIRES_STR(exp_delta_str),
						   SIPTAG_SUBSCRIPTION_STATE_STR(sstr),
						   SIPTAG_EVENT_STR("line-seize"), TAG_IF(full_call_info, SIPTAG_CALL_INFO_STR(full_call_info)), TAG_END());



				sql = switch_mprintf("delete from sip_dialogs where hostname='%q' and profile_name='%q' and "
									 "((sip_from_user='%q' and sip_from_host='%q') or presence_id='%q@%q') "
									 "and call_info_state='seized' and profile_name='%q'",
									 mod_sofia_globals.hostname, profile->name, to_user, to_host, to_user, to_host, profile->name);


				if (mod_sofia_globals.debug_sla > 1) {
					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "CLEAR SQL %s\n", sql);
				}
				sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);

				now = switch_epoch_time_now(NULL);
				sql = switch_mprintf("insert into sip_dialogs (sip_from_user,sip_from_host,call_info,call_info_state,hostname,expires,rcd,profile_name) "
									 "values ('%q','%q','%q','seized','%q',%ld,%ld,'%q')",
									 to_user, to_host, switch_str_nil(p), mod_sofia_globals.hostname, 
									 switch_epoch_time_now(NULL) + exp_delta, (long)now, profile->name);

				if (mod_sofia_globals.debug_sla > 1) {
					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "SEIZE SQL %s\n", sql);
				}
				sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
				sync_sla(profile, to_user, to_host, SWITCH_FALSE, SWITCH_FALSE, NULL);

				su_free(nh->nh_home, full_call_info);
			}
		} else if (!strcasecmp(event, "call-info")) {
			sync_sla(profile, to_user, to_host, SWITCH_FALSE, SWITCH_FALSE, call_id);
		}
	}

	sent_reply++;

	switch_safe_free(sstr);

	if (!strcasecmp(event, "message-summary")) {
		if ((sql = switch_mprintf("select proto,sip_user,'%q',sub_to_user,sub_to_host,event,contact,call_id,full_from,"
								  "full_via,expires,user_agent,accept,profile_name,network_ip"
								  " from sip_subscriptions where hostname='%q' and profile_name='%q' and "
								  "event='message-summary' and sip_user='%q' "
								  "and (sip_host='%q' or presence_hosts like '%%%q%%')", 
								  mod_sofia_globals.hostname, profile->name,
								  to_host, to_user, to_host, to_host))) {
			sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_sub_reg_callback, profile);

			switch_safe_free(sql);
		}
	}

 end:

	if (strcasecmp(event, "call-info") && strcasecmp(event, "line-seize")) {

		if (to_user && (strstr(to_user, "ext+") || strstr(to_user, "user+"))) {
			char protocol[80];
			char *p;

			switch_copy_string(protocol, to_user, sizeof(protocol));
			if ((p = strchr(protocol, '+'))) {
				*p = '\0';
			}

			if (switch_event_create(&sevent, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "proto", protocol);
				if (!zstr(orig_proto)) {
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "orig_proto", orig_proto);
				}
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "login", profile->name);
				switch_event_add_header(sevent, SWITCH_STACK_BOTTOM, "from", "%s@%s", to_user, to_host);
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "rpid", "active");
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "status", "Click To Call");
				switch_event_fire(&sevent);
			}

		} else if (to_user && (strcasecmp(proto, SOFIA_CHAT_PROTO) != 0)) {
			if (switch_event_create(&sevent, SWITCH_EVENT_PRESENCE_PROBE) == SWITCH_STATUS_SUCCESS) {
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "proto", proto);
				if (!zstr(orig_proto)) {
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "orig_proto", orig_proto);
				}
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "login", profile->name);
				switch_event_add_header(sevent, SWITCH_STACK_BOTTOM, "from", "%s@%s", from_user, from_host);
				switch_event_add_header(sevent, SWITCH_STACK_BOTTOM, "to", "%s%s%s@%s", proto, "+", to_user, to_host);
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "proto-specific-event-name", event);
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "expires", exp_delta_str);
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "event_type", "presence");
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
				switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "expires", exp_delta_str);
				switch_event_fire(&sevent);
	
			}
		} else {

			if (!strcasecmp(event, "dialog")) {
				if (switch_event_create(&sevent, SWITCH_EVENT_PRESENCE_PROBE) == SWITCH_STATUS_SUCCESS) {
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "probe-type", "dialog");
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "proto", SOFIA_CHAT_PROTO);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "login", profile->name);
					switch_event_add_header(sevent, SWITCH_STACK_BOTTOM, "from", "%s@%s", from_user, from_host);
					switch_event_add_header(sevent, SWITCH_STACK_BOTTOM, "to", "%s@%s", to_user, to_host);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "proto-specific-event-name", event);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "expires", exp_delta_str);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "event_type", "presence");
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "expires", exp_delta_str);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "sub-call-id", call_id);
					switch_event_fire(&sevent);
				}
			} else {
				if (switch_event_create(&sevent, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "proto", SOFIA_CHAT_PROTO);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "login", profile->name);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "presence-source", "subscribe");
					switch_event_add_header(sevent, SWITCH_STACK_BOTTOM, "from", "%s@%s", from_user, from_host);
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "rpid", "unknown");
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "status", "Registered");
					switch_event_add_header_string(sevent, SWITCH_STACK_BOTTOM, "call-id", call_id);
					switch_event_fire(&sevent);
				}					
			}
		}
	}

	if (event) {
		su_free(nh->nh_home, event);
	}

	if (full_from) {
		su_free(nh->nh_home, full_from);
	}
	if (full_to) {
		su_free(nh->nh_home, full_to);
	}

	if (full_via) {
		su_free(nh->nh_home, full_via);
	}
	if (full_agent) {
		su_free(nh->nh_home, full_agent);
	}

	switch_safe_free(d_user);
	switch_safe_free(to_str);
	switch_safe_free(contact_str);
	switch_safe_free(alt_proto);

	if (!sent_reply) {
		nua_respond(nh, 481, "INVALID SUBSCRIPTION", TAG_END());
	}

	nua_handle_destroy(nh);
	
}


sofia_gateway_subscription_t *sofia_find_gateway_subscription(sofia_gateway_t *gateway_ptr, const char *event)
{
	sofia_gateway_subscription_t *gw_sub_ptr;
	for (gw_sub_ptr = gateway_ptr->subscriptions; gw_sub_ptr; gw_sub_ptr = gw_sub_ptr->next) {
		if (!strcasecmp(gw_sub_ptr->event, event)) {
			/* this is the gateway subscription we are interested in */
			return gw_sub_ptr;
		}
	}
	return NULL;
}

void sofia_presence_handle_sip_r_subscribe(int status,
										   char const *phrase,
										   nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, sofia_private_t *sofia_private, sip_t const *sip,
										   sofia_dispatch_event_t *de,
										   tagi_t tags[])
{
	sip_event_t const *o = NULL;
	sofia_gateway_subscription_t *gw_sub_ptr;

	if (!sip) {
		return;
	}

	tl_gets(tags, SIPTAG_EVENT_REF(o), TAG_END());
	/* o->o_type: message-summary (for example) */
	if (!o) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Event information not given\n");
		return;
	}

	if (!sofia_private || !sofia_private->gateway) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Gateway information missing\n");
		return;
	}

	/* Find the subscription if one exists */
	if (!(gw_sub_ptr = sofia_find_gateway_subscription(sofia_private->gateway, o->o_type))) {
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Could not find gateway subscription.  Gateway: %s.  Subscription Event: %s\n",
						  sofia_private->gateway->name, o->o_type);
		return;
	}

	/* Update the subscription status for the subscription */
	switch (status) {
	case 200:
	case 202:
		/* TODO: in the spec it is possible for the other side to change the original expiry time,
		 * this needs to be researched (eg, what sip header this information will be in) and implemented.
		 * Although, since it seems the sofia stack is pretty much handling the subscription expiration
		 * anyway, then maybe its not even worth bothering.
		 */
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "got 200 OK response, updated state to SUB_STATE_SUBSCRIBE.\n");
		gw_sub_ptr->state = SUB_STATE_SUBSCRIBE;
		break;
	case 100:
		break;
	default:
		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "status (%d) != 200, updated state to SUB_STATE_FAILED.\n", status);
		gw_sub_ptr->state = SUB_STATE_FAILED;

		if (sofia_private) {
			if (sofia_private->gateway->sub_nh) {
				nua_handle_bind(sofia_private->gateway->sub_nh, NULL);
				nua_handle_destroy(sofia_private->gateway->sub_nh);
				sofia_private->gateway->sub_nh = NULL;
			}
		} else {
			nua_handle_destroy(nh);
		}

		break;
	}
}

struct pres_sql_cb {
	sofia_profile_t *profile;
	int ttl;
};

static int sofia_presence_send_sql(void *pArg, int argc, char **argv, char **columnNames)
{
	struct pres_sql_cb *cb = (struct pres_sql_cb *) pArg;
	

	if (mod_sofia_globals.debug_presence > 0) {
		int i;	
		for(i = 0; i < argc; i++) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "arg %d[%s] = [%s]\n", i, columnNames[i], argv[i]);
		}
	}

	send_presence_notify(cb->profile, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], NULL);
	cb->ttl++;

	return 0;
}


uint32_t sofia_presence_contact_count(sofia_profile_t *profile, const char *contact_str)
{
	char buf[32] = "";
	char *sql;
	
	sql = switch_mprintf("select count(*) from sip_subscriptions where hostname='%q' and profile_name='%q' and contact='%q'", 
						 mod_sofia_globals.hostname, profile->name, contact_str);
	
	sofia_glue_execute_sql2str(profile, profile->ireg_mutex, sql, buf, sizeof(buf));
	switch_safe_free(sql);
	return atoi(buf);				
}

void sofia_presence_handle_sip_i_publish(nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, sofia_private_t *sofia_private, sip_t const *sip,
										 sofia_dispatch_event_t *de,
										 tagi_t tags[])
{
	
	sip_from_t const *from;
	char *from_user = NULL;
	char *from_host = NULL;
	char *rpid = "";
	sip_payload_t *payload;
	char *event_type = NULL;
	char etag[9] = "";
	char expstr[30] = "";
	long exp = 0, exp_delta = 3600;
	char *pd_dup = NULL;
	int count = 1, sub_count = 0;
	char *contact_str;
	int open = 1;

	if (!sip) {
		return;
	}

	from = sip->sip_from;
	payload = sip->sip_payload;

	contact_str = sofia_glue_gen_contact_str(profile, sip, nh, de, NULL);

	if (from) {
		from_user = (char *) from->a_url->url_user;
		from_host = (char *) from->a_url->url_host;
	}
		
	exp_delta = (sip->sip_expires ? sip->sip_expires->ex_delta : 3600);
	if ((profile->force_publish_expires > 0) && (profile->force_publish_expires < (uint32_t)exp_delta)) {
		exp_delta = profile->force_publish_expires;
	}

	if (exp_delta < 0) {
		exp = exp_delta;
	} else {
		exp = (long) switch_epoch_time_now(NULL) + exp_delta;
	}

	if (payload) {
		switch_xml_t xml, note, person, tuple, status, basic, act;
		switch_event_t *event;
		char *sql;
		char *full_agent = NULL;
			
		pd_dup = strdup(payload->pl_data);

		if ((xml = switch_xml_parse_str(pd_dup, strlen(pd_dup)))) {
			char *open_closed = "", *note_txt = "";

			if (sip->sip_user_agent) {
				full_agent = sip_header_as_string(nh->nh_home, (void *) sip->sip_user_agent);
			}

			if ((tuple = switch_xml_child(xml, "tuple")) && (status = switch_xml_child(tuple, "status"))
				&& (basic = switch_xml_child(status, "basic"))) {
				open_closed = basic->txt;
			}

			if ((person = switch_xml_child(xml, "dm:person")) && (note = switch_xml_child(person, "dm:note"))) {
				note_txt = note->txt;
			}

			if (person && (act = switch_xml_child(person, "rpid:activities")) && act->child && act->child->name) {
				if ((rpid = strchr(act->child->name, ':'))) {
					rpid++;
				} else {
					rpid = act->child->name;
				}
			}

			if (sofia_test_pflag(profile, PFLAG_MULTIREG) && !open) {
				count = sofia_reg_reg_count(profile, from_user, from_host);
			}
				
			sub_count = sofia_presence_contact_count(profile, contact_str);

			/* if (count > 1) let's not and say we did or all the clients who subscribe to their own presence will think they selves is offline */

			event_type = sip_header_as_string(nh->nh_home, (void *) sip->sip_event);

			if (count < 2) {
				if ((sql = switch_mprintf("delete from sip_presence where sip_user='%q' and sip_host='%q' "
										  " and profile_name='%q' and hostname='%q'", 
										  from_user, from_host, profile->name, mod_sofia_globals.hostname))) {
					sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
				}
					
				if (sub_count > 0 && (sql = switch_mprintf("insert into sip_presence (sip_user, sip_host, status, rpid, expires, user_agent,"
														   " profile_name, hostname, open_closed) "
														   "values ('%q','%q','%q','%q',%ld,'%q','%q','%q','%q')",
														   from_user, from_host, note_txt, rpid, exp, full_agent, profile->name, 
														   mod_sofia_globals.hostname, open_closed))) {
					
					sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
				}
				
			} else if (contact_str) {
				struct pres_sql_cb cb = {profile, 0};

				sql = switch_mprintf("select full_to, full_from, contact, expires, call_id, event, network_ip, network_port, "
									 "'application/pidf+xml' as ct,'%q' as pt "
									 " from sip_subscriptions where "
									 "hostname='%q' and profile_name='%q' and sub_to_user='%q' and sub_to_host='%q' and event='%q'"
									 "and contact = '%q' ", 
									 
									 switch_str_nil(payload->pl_data), 
									 mod_sofia_globals.hostname, profile->name,
									 from_user, from_host, event_type);
									 
				sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_send_sql, &cb);
				switch_safe_free(sql);
			}

			if (sub_count > 0) {
				if (switch_event_create(&event, SWITCH_EVENT_PRESENCE_IN) == SWITCH_STATUS_SUCCESS) {
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", SOFIA_CHAT_PROTO);
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", rpid);
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", profile->url);
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "user-agent", full_agent);
					switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from", "%s@%s", from_user, from_host);
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "status", note_txt);
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", event_type);
					switch_event_fire(&event);
				}
			}

			if (event_type) {
				su_free(nh->nh_home, event_type);
			}

			if (full_agent) {
				su_free(nh->nh_home, full_agent);
			}

			switch_xml_free(xml);
		}
	} else {
		char *sql = switch_mprintf("update sip_presence set expires=%ld where sip_user='%q' and sip_host='%q' and profile_name='%q' and hostname='%q'",
								   exp, from_user, from_host, profile->name, mod_sofia_globals.hostname);
		sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
	}

	switch_safe_free(pd_dup);

	switch_snprintf(expstr, sizeof(expstr), "%d", exp_delta);
	switch_stun_random_string(etag, 8, NULL);

	if (sub_count > 0) {
		nua_respond(nh, SIP_200_OK, NUTAG_WITH_THIS_MSG(de->data->e_msg), SIPTAG_ETAG_STR(etag), SIPTAG_EXPIRES_STR(expstr), TAG_END());
	} else {
		nua_respond(nh, SIP_404_NOT_FOUND, NUTAG_WITH_THIS_MSG(de->data->e_msg), TAG_END());
	}

	switch_safe_free(contact_str);
}

void sofia_presence_set_hash_key(char *hash_key, int32_t len, sip_t const *sip)
{
	url_t *to = sip->sip_to->a_url;
	url_t *from = sip->sip_from->a_url;
	switch_snprintf(hash_key, len, "%s%s%s", from->url_user, from->url_host, to->url_user);
}

void sofia_presence_handle_sip_i_message(int status,
										 char const *phrase,
										 nua_t *nua, sofia_profile_t *profile, nua_handle_t *nh, sofia_private_t *sofia_private, sip_t const *sip,
										 sofia_dispatch_event_t *de,
										 tagi_t tags[])
{
	if (sip) {
		sip_from_t const *from = sip->sip_from;
		const char *from_user = NULL;
		const char *from_host = NULL;
		sip_to_t const *to = sip->sip_to;
		const char *to_user = NULL;
		const char *to_host = NULL;
		sip_payload_t *payload = sip->sip_payload;
		char *msg = NULL;
		const char *us;
		char network_ip[80];
		int network_port = 0;

		if ((us = sofia_glue_get_unknown_header(sip, "X-FS-Sending-Message")) && !strcmp(us, switch_core_get_uuid())) {
			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Not sending message to ourselves!\n");
			goto end;
		}

		if (sip->sip_content_type && sip->sip_content_type->c_subtype) {
			if (strstr(sip->sip_content_type->c_subtype, "composing")) {
				goto end;
			}
		}


		sofia_glue_get_addr(de->data->e_msg, network_ip, sizeof(network_ip), &network_port);


		if (from) {
			from_user = from->a_url->url_user;
			from_host = from->a_url->url_host;
		}

		if (to) {
			to_user = to->a_url->url_user;
			to_host = to->a_url->url_host;
		}

		if (!to_user) {
			goto end;
		}

		if (payload) {
			msg = payload->pl_data;
		}

		if (nh) {
			char hash_key[512];
			private_object_t *tech_pvt;
			switch_event_t *event;
			char *to_addr;
			char *from_addr;
			char *p;
			char *full_from;
			char proto[512] = SOFIA_CHAT_PROTO;

			full_from = sip_header_as_string(nh->nh_home, (void *) sip->sip_from);

			if ((p = strchr(to_user, '+'))) {
				switch_copy_string(proto, to_user, sizeof(proto));
				p = strchr(proto, '+');
				*p++ = '\0';

				if ((to_addr = strdup(p))) {
					if ((p = strchr(to_addr, '+'))) {
						*p = '@';
					}
				}
			} else {
				to_addr = switch_mprintf("%s@%s", to_user, to_host);
			}

			from_addr = switch_mprintf("%s@%s", from_user, from_host);

			if (sofia_test_pflag(profile, PFLAG_IN_DIALOG_CHAT)) {
				sofia_presence_set_hash_key(hash_key, sizeof(hash_key), sip);
			}

			if (switch_event_create(&event, SWITCH_EVENT_MESSAGE) == SWITCH_STATUS_SUCCESS) {
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", profile->url);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", SOFIA_CHAT_PROTO);

				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "to_proto", proto);

				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from", from_addr);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from_user", from_user);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from_host", from_host);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "to_user", to_user);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "to_host", to_host);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from_sip_ip", network_ip);
				switch_event_add_header(event, SWITCH_STACK_BOTTOM, "from_sip_port", "%d", network_port);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "to", to_addr);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "subject", "SIMPLE MESSAGE");

				
				if (sip->sip_content_type && sip->sip_content_type->c_subtype) {
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", sip->sip_content_type->c_type);
				} else {
					switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "type", "text/plain");
				}

				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from_full", full_from);
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "sip_profile", profile->name);
				
				if (msg) {
					switch_event_add_body(event, "%s", msg);
				}
			} else {
				abort();
			}
			
			if (sofia_test_pflag(profile, PFLAG_IN_DIALOG_CHAT) && (tech_pvt = (private_object_t *) switch_core_hash_find(profile->chat_hash, hash_key))) {
				switch_core_session_queue_event(tech_pvt->session, &event);
			} else {
				switch_core_chat_send(proto, event);
				switch_event_destroy(&event);
			}

			switch_safe_free(to_addr);
			switch_safe_free(from_addr);

			if (full_from) {
				su_free(nh->nh_home, full_from);
			}
		}
	}

 end:

	nua_respond(nh, SIP_200_OK, NUTAG_WITH_THIS_MSG(de->data->e_msg), TAG_END());

}

void sofia_presence_set_chat_hash(private_object_t *tech_pvt, sip_t const *sip)
{
	char hash_key[256] = "";
	char buf[512];
	su_home_t *home = NULL;

	if (!tech_pvt || tech_pvt->hash_key || !sip || !sip->sip_from || !sip->sip_from->a_url ||
		!sip->sip_from->a_url->url_user || !sip->sip_from->a_url->url_host) {
		return;
	}

	if (sofia_reg_find_reg_url(tech_pvt->profile, sip->sip_from->a_url->url_user, sip->sip_from->a_url->url_host, buf, sizeof(buf))) {
		home = su_home_new(sizeof(*home));
		switch_assert(home != NULL);
		tech_pvt->chat_from = sip_header_as_string(home, (const sip_header_t *) sip->sip_to);
		tech_pvt->chat_to = switch_core_session_strdup(tech_pvt->session, buf);
		sofia_presence_set_hash_key(hash_key, sizeof(hash_key), sip);
		su_home_unref(home);
		home = NULL;
	} else {
		return;
	}

	switch_mutex_lock(tech_pvt->profile->flag_mutex);
	tech_pvt->hash_key = switch_core_session_strdup(tech_pvt->session, hash_key);
	switch_core_hash_insert(tech_pvt->profile->chat_hash, tech_pvt->hash_key, tech_pvt);
	switch_mutex_unlock(tech_pvt->profile->flag_mutex);
}


void sofia_presence_check_subscriptions(sofia_profile_t *profile, time_t now) 
{
	char *sql;

	if (now) {
		struct pres_sql_cb cb = {profile, 0};

		if (profile->pres_type != PRES_TYPE_FULL) {
			if (mod_sofia_globals.debug_presence > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "check_subs: %s is passive, skipping\n", (char *) profile->name);
			}
			return;
		}

		sql = switch_mprintf("update sip_subscriptions set version=version+1 where "
							 "((expires > 0 and expires <= %ld)) and profile_name='%q' and hostname='%q'", 
							 (long) now, profile->name, mod_sofia_globals.hostname);

		sofia_glue_execute_sql_now(profile, &sql, SWITCH_TRUE);
		switch_safe_free(sql);

		sql = switch_mprintf("select full_to, full_from, contact, -1, call_id, event, network_ip, network_port, "
							 "NULL as ct, NULL as pt "
							 " from sip_subscriptions where ((expires > 0 and expires <= %ld)) and profile_name='%q' and hostname='%q'",
							 (long) now, profile->name, mod_sofia_globals.hostname);

		sofia_glue_execute_sql_callback(profile, profile->ireg_mutex, sql, sofia_presence_send_sql, &cb);
		switch_safe_free(sql);

		if (cb.ttl) {
			sql = switch_mprintf("delete from sip_subscriptions where ((expires > 0 and expires <= %ld)) "
								 "and profile_name='%q' and hostname='%q'",
								 (long) now, profile->name, mod_sofia_globals.hostname);

			if (mod_sofia_globals.debug_presence > 0 || mod_sofia_globals.debug_sla > 0) {
				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
								  "sub del sql: %s\n", sql);		
			}

			sofia_glue_actually_execute_sql(profile, sql, profile->ireg_mutex);
			switch_safe_free(sql);
		}
	}



}


/* For Emacs:
 * Local Variables:
 * mode:c
 * indent-tabs-mode:t
 * tab-width:4
 * c-basic-offset:4
 * End:
 * For VIM:
 * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
 */