dialog.h File Reference

sip dialog management header file More...

#include "sip.h"

Include dependency graph for dialog.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	dialog_ref(dialog, tag)   ao2_t_bump(dialog, tag)
	when we create or delete references, make sure to use these functions so we keep track of the refcounts. To simplify the code, we allow a NULL to be passed to dialog_unref(). More...
#define	dialog_unref(dialog, tag)   ({ ao2_t_cleanup(dialog, tag); (NULL); })
#define	sip_alloc(callid, addr, useglobal_nat, intended_method, req, logger_callid)   __sip_alloc(callid, addr, useglobal_nat, intended_method, req, logger_callid, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Functions
int	__sip_ack (struct sip_pvt *p, uint32_t seqno, int resp, int sipmethod)
	Acknowledges receipt of a packet and stops retransmission called with p locked. More...
struct sip_pvt *	__sip_alloc (ast_string_field callid, struct ast_sockaddr *sin, int useglobal_nat, const int intended_method, struct sip_request *req, ast_callid logger_callid, const char *file, int line, const char *func)
	Allocate sip_pvt structure, set defaults and link in the container. Returns a reference to the object so whoever uses it later must remember to release the reference. More...
void	__sip_pretend_ack (struct sip_pvt *p)
	Pretend to ack all packets called with p locked. More...
int	__sip_semi_ack (struct sip_pvt *p, uint32_t seqno, int resp, int sipmethod)
	Acks receipt of packet, keep it around (used for provisional responses) More...
void	dialog_unlink_all (struct sip_pvt *dialog)
	Unlink a dialog from the dialogs container, as well as any other places that it may be currently stored. More...
void	sip_cancel_destroy (struct sip_pvt *pvt)
	Cancel destruction of SIP dialog. More...
void	sip_scheddestroy (struct sip_pvt *p, int ms)
	Schedule destruction of SIP dialog. More...
void	sip_scheddestroy_final (struct sip_pvt *p, int ms)
	Schedule final destruction of SIP dialog. More...

Detailed Description

sip dialog management header file

Definition in file dialog.h.

Macro Definition Documentation

dialog_ref

#define dialog_ref	(		dialog,
			tag
	)		ao2_t_bump(dialog, tag)

when we create or delete references, make sure to use these functions so we keep track of the refcounts. To simplify the code, we allow a NULL to be passed to dialog_unref().

Definition at line 32 of file dialog.h.

Referenced by __find_call(), __sip_reliable_xmit(), __sip_scheddestroy(), __start_session_timer(), __start_t38_abort_timer(), __update_provisional_keepalive_full(), AST_TEST_DEFINE(), dialog_unlink_all(), handle_cc_subscribe(), handle_request_subscribe(), handle_response_invite(), sched_check_pendings(), sip_call(), sip_cancel_destroy(), sip_hangup(), sip_new(), sip_poke_peer(), sip_scheddestroy_full(), sip_send_mwi_to_peer(), start_session_timer(), start_t38_abort_timer(), stop_provisional_keepalive(), stop_reinvite_retry(), stop_reinviteid(), stop_session_timer(), stop_t38_abort_timer(), transmit_register(), and update_provisional_keepalive().

dialog_unref

#define dialog_unref	(		dialog,
			tag
	)		({ ao2_t_cleanup(dialog, tag); (NULL); })

Definition at line 33 of file dialog.h.

Referenced by __cleanup_registration(), __dialog_unlink_sched_items(), __find_call(), __sched_check_pendings(), __sip_autodestruct(), __sip_cancel_destroy(), __sip_scheddestroy(), __sip_subscribe_mwi_do(), __start_session_timer(), __start_t38_abort_timer(), __stop_provisional_keepalive(), __stop_reinvite_retry(), __stop_reinviteid(), __stop_session_timer(), __stop_t38_abort_timer(), __update_provisional_keepalive_full(), AST_TEST_DEFINE(), auto_congest(), cb_extensionstate_destroy(), complete_sipch(), dialog_unlink_all(), do_cancel_destroy(), do_dialog_unlink_sched_items(), do_stop_session_timer(), forked_invite_init(), handle_request_subscribe(), handle_response_invite(), handle_response_peerpoke(), handle_response_register(), manager_sipnotify(), proc_session_timer(), reinvite_timeout(), sched_check_pendings(), send_provisional_keepalive_full(), sip_call(), sip_cancel_destroy(), sip_cc_agent_destructor(), sip_cli_notify(), sip_destroy_peer(), sip_hangup(), sip_monitor_instance_destructor(), sip_msg_send(), sip_pkt_dtor(), sip_poke_noanswer(), sip_poke_peer(), sip_pvt_dtor(), sip_reg_timeout(), sip_registry_destroy(), sip_reinvite_retry(), sip_request_call(), sip_scheddestroy_full(), sip_send_mwi_to_peer(), sip_subscribe_mwi_destroy(), sip_t38_abort(), start_session_timer(), start_t38_abort_timer(), stop_provisional_keepalive(), stop_reinvite_retry(), stop_reinviteid(), stop_session_timer(), stop_t38_abort_timer(), transmit_publish(), transmit_register(), and update_provisional_keepalive().

sip_alloc

#define sip_alloc	(		callid,
			addr,
			useglobal_nat,
			intended_method,
			req,
			logger_callid
	)		__sip_alloc(callid, addr, useglobal_nat, intended_method, req, logger_callid, __FILE__, __LINE__, __PRETTY_FUNCTION__)

Definition at line 39 of file dialog.h.

Referenced by __find_call(), __sip_subscribe_mwi_do(), AST_TEST_DEFINE(), forked_invite_init(), manager_sipnotify(), sip_cc_monitor_request_cc(), sip_cli_notify(), sip_msg_send(), sip_poke_peer(), sip_request_call(), sip_send_mwi_to_peer(), transmit_publish(), and transmit_register().

Function Documentation

__sip_ack()

int __sip_ack	(	struct sip_pvt *	p,
		uint32_t	seqno,
		int	resp,
		int	sipmethod
	)

Acknowledges receipt of a packet and stops retransmission called with p locked.

Definition at line 4570 of file chan_sip.c.

References ao2_t_ref, ast_debug, sip_pvt::callid, FALSE, sip_proxy::force, sip_pkt::is_resp, sip_pkt::method, sip_pkt::next, NULL, sip_pvt::outboundproxy, sip_pvt::packets, sip_pvt::pendinginvite, ref_proxy(), sip_pkt::retransid, sip_pkt::seqno, sipdebug, stop_retrans_pkt(), TRUE, and UNLINK.

Referenced by __sip_pretend_ack(), handle_incoming(), handle_request_invite(), handle_request_publish(), and handle_response().

{
   struct sip_pkt *cur, *prev = NULL;
   const char *msg = "Not Found";   /* used only for debugging */
   int res = FALSE;

   /* If we have an outbound proxy for this dialog, then delete it now since
     the rest of the requests in this dialog needs to follow the routing.
     If obforcing is set, we will keep the outbound proxy during the whole
     dialog, regardless of what the SIP rfc says
   */
   if (p->outboundproxy && !p->outboundproxy->force) {
      ref_proxy(p, NULL);
   }

   for (cur = p->packets; cur; prev = cur, cur = cur->next) {
      if (cur->seqno != seqno || cur->is_resp != resp) {
         continue;
      }
      if (cur->is_resp || cur->method == sipmethod) {
         res = TRUE;
         msg = "Found";
         if (!resp && (seqno == p->pendinginvite)) {
            ast_debug(1, "Acked pending invite %u\n", p->pendinginvite);
            p->pendinginvite = 0;
         }
         if (cur->retransid > -1) {
            if (sipdebug)
               ast_debug(4, "** SIP TIMER: Cancelling retransmit of packet (reply received) Retransid #%d\n", cur->retransid);
         }

         /* Unlink and destroy the packet object. */
         UNLINK(cur, p->packets, prev);
         stop_retrans_pkt(cur);
         ao2_t_ref(cur, -1, "Packet retransmission list");
         break;
      }
   }
   ast_debug(1, "Stopping retransmission on '%s' of %s %u: Match %s\n",
      p->callid, resp ? "Response" : "Request", seqno, msg);
   return res;
}

__sip_alloc()

struct sip_pvt* __sip_alloc	(	ast_string_field	callid,
		struct ast_sockaddr *	sin,
		int	useglobal_nat,
		const int	intended_method,
		struct sip_request *	req,
		ast_callid	logger_callid,
		const char *	file,
		int	line,
		const char *	func
	)

Allocate sip_pvt structure, set defaults and link in the container. Returns a reference to the object so whoever uses it later must remember to release the reference.

Definition at line 8942 of file chan_sip.c.

References __ao2_alloc(), sip_pvt::allowed_methods, sip_settings::allowtransfer, sip_pvt::allowtransfer, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_t_link, ao2_t_ref, ast_cc_config_params_init, ast_copy_flags, ast_copy_string(), ast_debug, ast_format_cap_alloc, ast_format_cap_append_from_cap(), AST_FORMAT_CAP_FLAG_DEFAULT, AST_LIST_HEAD_INIT_NOLOCK, AST_MEDIA_TYPE_UNKNOWN, ast_random(), AST_RTP_DTMF, ast_sip_ouraddrfor(), ast_sockaddr_copy(), ast_string_field_init, ast_string_field_set, ast_strlen_zero, ast_test_flag, AST_TRANSPORT_UDP, sip_pvt::autoframing, sip_pvt::autokillid, sip_via::branch, sip_pvt::branch, build_callid_pvt(), build_via(), sip_pvt::callid, sip_settings::caps, sip_pvt::caps, sip_pvt::cc_params, check_via(), context, sip_settings::default_context, default_engine, default_fromdomain, default_fromdomainport, sip_settings::default_max_forwards, default_maxcallbitrate, default_mohinterpret, default_mohsuggest, default_parkinglot, default_zone, sip_pvt::do_history, do_setnat(), sip_socket::fd, sip_pvt::flags, free_via(), sip_pvt::fromdomainport, global_autoframing, global_t1, global_timer_b, sip_pvt::init_icseq, INITIAL_CSEQ, sip_pvt::initid, internip, sip_pvt::jointcaps, make_our_tag(), sip_pvt::maxcallbitrate, sip_pvt::maxforwards, sip_pvt::method, mohinterpret, mohsuggest, sip_pvt::noncodeccapability, NONE, NULL, sip_pvt::ocseq, sip_pvt::offered_media, sip_pvt::ourip, parkinglot, parse_via(), sip_pvt::peercaps, sip_pvt::prefcaps, sip_pvt::provisional_keepalive_sched_id, recordhistory, sip_pvt::recv, sip_pvt::redircaps, sip_pvt::reinviteid, sip_pvt::request_queue, sip_pvt::request_queue_sched_id, sip_pvt::rtp, sip_pvt::sa, sip_via::sent_by, sip_pvt::session_modify, sip_pvt::sessionversion_remote, set_socket_transport(), sip_cfg, SIP_DTMF, SIP_DTMF_AUTO, SIP_DTMF_RFC2833, SIP_FLAGS_TO_COPY, sip_get_header(), sip_methods, SIP_OPTIONS, SIP_PAGE2_FLAGS_TO_COPY, SIP_PAGE3_FLAGS_TO_COPY, sip_pvt_callid_set(), sip_pvt_dtor(), SIP_REGISTER, sip_request::socket, sip_pvt::socket, sip_pvt::stateid, sip_pvt::stimer, sip_pvt::subscribed, sip_pvt::t38id, cfsip_methods::text, sip_pvt::timer_b, sip_pvt::timer_t1, TRUE, sip_socket::type, sip_pvt::waitid, and sip_pvt::zone.

{
   struct sip_pvt *p;

   p = __ao2_alloc(sizeof(*p), sip_pvt_dtor,
      AO2_ALLOC_OPT_LOCK_MUTEX, "allocate a dialog(pvt) struct",
      file, line, func);
   if (!p) {
      return NULL;
   }

   if (ast_string_field_init(p, 512)) {
      ao2_t_ref(p, -1, "failed to string_field_init, drop p");
      return NULL;
   }

   if (!(p->cc_params = ast_cc_config_params_init())) {
      ao2_t_ref(p, -1, "Yuck, couldn't allocate cc_params struct. Get rid o' p");
      return NULL;
   }

   if (logger_callid) {
      sip_pvt_callid_set(p, logger_callid);
   }

   p->caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   p->jointcaps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   p->peercaps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   p->redircaps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   p->prefcaps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);

   if (!p->caps|| !p->jointcaps || !p->peercaps || !p->redircaps || !p->prefcaps) {
      ao2_cleanup(p->caps);
      ao2_cleanup(p->jointcaps);
      ao2_cleanup(p->peercaps);
      ao2_cleanup(p->redircaps);
      ao2_cleanup(p->prefcaps);
      ao2_t_ref(p, -1, "Yuck, couldn't allocate format capabilities. Get rid o' p");
      return NULL;
   }


   /* If this dialog is created as a result of a request or response, lets store
    * some information about it in the dialog. */
   if (req) {
      struct sip_via *via;
      const char *cseq = sip_get_header(req, "Cseq");
      uint32_t seqno;

      /* get branch parameter from initial Request that started this dialog */
      via = parse_via(sip_get_header(req, "Via"));
      if (via) {
         /* only store the branch if it begins with the magic prefix "z9hG4bK", otherwise
          * it is not useful to us to have it */
         if (!ast_strlen_zero(via->branch) && !strncasecmp(via->branch, "z9hG4bK", 7)) {
            ast_string_field_set(p, initviabranch, via->branch);
            ast_string_field_set(p, initviasentby, via->sent_by);
         }
         free_via(via);
      }

      /* Store initial incoming cseq. An error in sscanf here is ignored.  There is no approperiate
       * except not storing the number.  CSeq validation must take place before dialog creation in find_call */
      if (!ast_strlen_zero(cseq) && (sscanf(cseq, "%30u", &seqno) == 1)) {
         p->init_icseq = seqno;
      }
      /* Later in ast_sip_ouraddrfor we need this to choose the right ip and port for the specific transport */
      set_socket_transport(&p->socket, req->socket.type);
   } else {
      set_socket_transport(&p->socket, AST_TRANSPORT_UDP);
   }

   p->socket.fd = -1;
   p->method = intended_method;
   p->initid = -1;
   p->waitid = -1;
   p->reinviteid = -1;
   p->autokillid = -1;
   p->request_queue_sched_id = -1;
   p->provisional_keepalive_sched_id = -1;
   p->t38id = -1;
   p->subscribed = NONE;
   p->stateid = -1;
   p->sessionversion_remote = -1;
   p->session_modify = TRUE;
   p->stimer = NULL;
   ast_copy_string(p->zone, default_zone, sizeof(p->zone));
   p->maxforwards = sip_cfg.default_max_forwards;

   if (intended_method != SIP_OPTIONS) {  /* Peerpoke has it's own system */
      p->timer_t1 = global_t1;   /* Default SIP retransmission timer T1 (RFC 3261) */
      p->timer_b = global_timer_b;  /* Default SIP transaction timer B (RFC 3261) */
   }

   if (!addr) {
      p->ourip = internip;
   } else {
      ast_sockaddr_copy(&p->sa, addr);
      ast_sip_ouraddrfor(&p->sa, &p->ourip, p);
   }

   /* Copy global flags to this PVT at setup. */
   ast_copy_flags(&p->flags[0], &global_flags[0], SIP_FLAGS_TO_COPY);
   ast_copy_flags(&p->flags[1], &global_flags[1], SIP_PAGE2_FLAGS_TO_COPY);
   ast_copy_flags(&p->flags[2], &global_flags[2], SIP_PAGE3_FLAGS_TO_COPY);

   p->do_history = recordhistory;

   p->branch = ast_random();
   make_our_tag(p);
   p->ocseq = INITIAL_CSEQ;
   p->allowed_methods = UINT_MAX;

   if (sip_methods[intended_method].need_rtp) {
      p->maxcallbitrate = default_maxcallbitrate;
      p->autoframing = global_autoframing;
   }

   if (useglobal_nat && addr) {
      /* Setup NAT structure according to global settings if we have an address */
      ast_sockaddr_copy(&p->recv, addr);
      check_via(p, req);
      do_setnat(p);
   }

   if (p->method != SIP_REGISTER) {
      ast_string_field_set(p, fromdomain, default_fromdomain);
      p->fromdomainport = default_fromdomainport;
   }
   build_via(p);
   if (!callid)
      build_callid_pvt(p);
   else
      ast_string_field_set(p, callid, callid);
   /* Assign default music on hold class */
   ast_string_field_set(p, mohinterpret, default_mohinterpret);
   ast_string_field_set(p, mohsuggest, default_mohsuggest);
   ast_format_cap_append_from_cap(p->caps, sip_cfg.caps, AST_MEDIA_TYPE_UNKNOWN);
   p->allowtransfer = sip_cfg.allowtransfer;
   if ((ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_RFC2833) ||
       (ast_test_flag(&p->flags[0], SIP_DTMF) == SIP_DTMF_AUTO)) {
      p->noncodeccapability |= AST_RTP_DTMF;
   }
   ast_string_field_set(p, context, sip_cfg.default_context);
   ast_string_field_set(p, parkinglot, default_parkinglot);
   ast_string_field_set(p, engine, default_engine);

   AST_LIST_HEAD_INIT_NOLOCK(&p->request_queue);
   AST_LIST_HEAD_INIT_NOLOCK(&p->offered_media);

   /* Add to active dialog list */

   ao2_t_link(dialogs, p, "link pvt into dialogs table");

   ast_debug(1, "Allocating new SIP dialog for %s - %s (%s)\n", callid ? callid : p->callid, sip_methods[intended_method].text, p->rtp ? "With RTP" : "No RTP");
   return p;
}

__sip_pretend_ack()

void __sip_pretend_ack

(

struct sip_pvt *

p

)

Pretend to ack all packets called with p locked.

Definition at line 4615 of file chan_sip.c.

References __sip_ack(), ast_log, ast_str_buffer(), sip_pkt::data, find_sip_method(), sip_pkt::is_resp, LOG_WARNING, sip_pkt::method, method, NULL, sip_pvt::packets, sip_pkt::seqno, sip_methods, and cfsip_methods::text.

Referenced by __sip_autodestruct(), handle_request_bye(), handle_request_cancel(), and sip_reg_timeout().

{
   struct sip_pkt *cur = NULL;

   while (p->packets) {
      int method;
      if (cur == p->packets) {
         ast_log(LOG_WARNING, "Have a packet that doesn't want to give up! %s\n", sip_methods[cur->method].text);
         return;
      }
      cur = p->packets;
      method = (cur->method) ? cur->method : find_sip_method(ast_str_buffer(cur->data));
      __sip_ack(p, cur->seqno, cur->is_resp, method);
   }
}

__sip_semi_ack()

int __sip_semi_ack	(	struct sip_pvt *	p,
		uint32_t	seqno,
		int	resp,
		int	sipmethod
	)

Acks receipt of packet, keep it around (used for provisional responses)

Definition at line 4632 of file chan_sip.c.

References ast_debug, ast_str_buffer(), sip_pvt::callid, sip_pkt::data, FALSE, sip_pkt::is_resp, method_match(), sip_pkt::next, sip_pvt::packets, sip_pkt::retransid, sip_pkt::seqno, sip_methods, sipdebug, stop_retrans_pkt(), cfsip_methods::text, and TRUE.

Referenced by handle_response(), and sip_hangup().

{
   struct sip_pkt *cur;
   int res = FALSE;

   for (cur = p->packets; cur; cur = cur->next) {
      if (cur->seqno == seqno && cur->is_resp == resp &&
         (cur->is_resp || method_match(sipmethod, ast_str_buffer(cur->data)))) {
         /* this is our baby */
         if (cur->retransid > -1) {
            if (sipdebug)
               ast_debug(4, "*** SIP TIMER: Cancelling retransmission #%d - %s (got response)\n", cur->retransid, sip_methods[sipmethod].text);
         }
         stop_retrans_pkt(cur);
         res = TRUE;
         break;
      }
   }
   ast_debug(1, "(Provisional) Stopping retransmission (but retaining packet) on '%s' %s %u: %s\n", p->callid, resp ? "Response" : "Request", seqno, res == -1 ? "Not Found" : "Found");
   return res;
}

dialog_unlink_all()

void dialog_unlink_all

(

struct sip_pvt *

dialog

)

Unlink a dialog from the dialogs container, as well as any other places that it may be currently stored.

Note

A reference to the dialog must be held before calling this function, and this function does not release that reference.

The dialog must not be locked when called.

A reference to the dialog must be held before calling this function, and this function does not release that reference.

Definition at line 3367 of file chan_sip.c.

References __dialog_unlink_sched_items(), ao2_t_replace, ao2_t_unlink, append_history_full(), ast_channel_name(), ast_channel_tech_pvt(), ast_channel_tech_pvt_set(), ast_channel_unlock, ast_channel_unref, ast_debug, ast_extension_state_del(), ast_sched_add(), sip_peer::call, sip_registry::call, cb_extensionstate(), dialog_ref, dialog_unref, do_dialog_unlink_sched_items(), format, sip_peer::mwipvt, NULL, sip_pvt::registry, sip_pvt::relatedpeer, sip_pvt_lock_full(), sip_pvt_unlock, sip_set_owner(), and sip_pvt::stateid.

Referenced by __cleanup_registration(), __sip_autodestruct(), __sip_subscribe_mwi_do(), AST_TEST_DEFINE(), dialog_needdestroy(), handle_request_subscribe(), manager_sipnotify(), sip_cli_notify(), sip_destroy_peer(), sip_msg_send(), sip_poke_noanswer(), sip_poke_peer(), sip_registry_destroy(), sip_request_call(), sip_send_mwi_to_peer(), transmit_publish(), transmit_register(), and unload_module().

{
   struct ast_channel *owner;

   dialog_ref(dialog, "Let's bump the count in the unlink so it doesn't accidentally become dead before we are done");

   ao2_t_unlink(dialogs, dialog, "unlinking dialog via ao2_unlink");
   ao2_t_unlink(dialogs_needdestroy, dialog, "unlinking dialog_needdestroy via ao2_unlink");
   ao2_t_unlink(dialogs_rtpcheck, dialog, "unlinking dialog_rtpcheck via ao2_unlink");

   /* Unlink us from the owner (channel) if we have one */
   owner = sip_pvt_lock_full(dialog);
   if (owner) {
      ast_debug(1, "Detaching from channel %s\n", ast_channel_name(owner));
      ast_channel_tech_pvt_set(owner, dialog_unref(ast_channel_tech_pvt(owner), "resetting channel dialog ptr in unlink_all"));
      ast_channel_unlock(owner);
      ast_channel_unref(owner);
      sip_set_owner(dialog, NULL);
   }
   sip_pvt_unlock(dialog);

   if (dialog->registry) {
      if (dialog->registry->call == dialog) {
         dialog->registry->call = dialog_unref(dialog->registry->call, "nulling out the registry's call dialog field in unlink_all");
      }
      ao2_t_replace(dialog->registry, NULL, "delete dialog->registry");
   }
   if (dialog->stateid != -1) {
      ast_extension_state_del(dialog->stateid, cb_extensionstate);
      dialog->stateid = -1;
   }
   /* Remove link from peer to subscription of MWI */
   if (dialog->relatedpeer && dialog->relatedpeer->mwipvt == dialog) {
      dialog->relatedpeer->mwipvt = dialog_unref(dialog->relatedpeer->mwipvt, "delete ->relatedpeer->mwipvt");
   }
   if (dialog->relatedpeer && dialog->relatedpeer->call == dialog) {
      dialog->relatedpeer->call = dialog_unref(dialog->relatedpeer->call, "unset the relatedpeer->call field in tandem with relatedpeer field itself");
   }

   dialog_ref(dialog, "Stop scheduled items for unlink action");
   if (ast_sched_add(sched, 0, __dialog_unlink_sched_items, dialog) < 0) {
      /*
       * Uh Oh.  Fall back to unscheduling things immediately
       * despite the potential deadlock risk.
       */
      dialog_unref(dialog, "Failed to schedule stop scheduled items for unlink action");
      do_dialog_unlink_sched_items(dialog);
   }

   dialog_unref(dialog, "Let's unbump the count in the unlink so the poor pvt can disappear if it is time");
}

sip_cancel_destroy()

void sip_cancel_destroy

(

struct sip_pvt *

pvt

)

Cancel destruction of SIP dialog.

Definition at line 4464 of file chan_sip.c.

References __sip_cancel_destroy(), ast_log, ast_sched_add(), dialog_ref, dialog_unref, sip_pvt::final_destruction_scheduled, and LOG_WARNING.

Referenced by handle_request_invite(), handle_request_subscribe(), handle_response(), handle_response_invite(), register_verify(), and sip_hangup().

{
   if (pvt->final_destruction_scheduled) {
      return;
   }

   dialog_ref(pvt, "Cancel destroy action");
   if (ast_sched_add(sched, 0, __sip_cancel_destroy, pvt) < 0) {
      /* Uh Oh.  Expect bad behavior. */
      dialog_unref(pvt, "Failed to schedule cancel destroy action");
      ast_log(LOG_WARNING, "Unable to cancel SIP destruction.  Expect bad things.\n");
   }
}

sip_scheddestroy()

void sip_scheddestroy	(	struct sip_pvt *	p,
		int	ms
	)

Schedule destruction of SIP dialog.

Definition at line 4549 of file chan_sip.c.

References sip_pvt::final_destruction_scheduled, and sip_scheddestroy_full().

Referenced by __sip_autodestruct(), auto_congest(), check_auth(), check_pendings(), extensionstate_update(), handle_incoming(), handle_invite_replaces(), handle_request_cancel(), handle_request_info(), handle_request_invite(), handle_request_notify(), handle_request_options(), handle_request_publish(), handle_request_register(), handle_request_subscribe(), handle_response_invite(), manager_sipnotify(), receive_message(), sip_cli_notify(), sip_hangup(), sip_msg_send(), sip_send_mwi_to_peer(), sip_sipredirect(), transmit_fake_auth_response(), and transmit_publish().

{
   if (p->final_destruction_scheduled) {
      return; /* already set final destruction */
   }
   sip_scheddestroy_full(p, ms);
}

sip_scheddestroy_final()

void sip_scheddestroy_final	(	struct sip_pvt *	p,
		int	ms
	)

Schedule final destruction of SIP dialog.

Note

This cannot be canceled.

This function is used to keep a dialog around for a period of time in order to properly respond to any retransmits.

Definition at line 4557 of file chan_sip.c.

References sip_pvt::final_destruction_scheduled, and sip_scheddestroy_full().

Referenced by handle_request_bye().

{
   if (p->final_destruction_scheduled) {
      return; /* already set final destruction */
   }

   if (!sip_scheddestroy_full(p, ms)) {
      p->final_destruction_scheduled = 1;
   }
}