osip.c

libosip2-3.0.3最新版本

    osip_via_param_get_byname (nict->topvia, "branch", &b_request);
    if (b_request != NULL && b_request->gvalue != NULL)
      rv = dict_insert (osip->osip_nict_hastable,
                        b_request->gvalue, (void *) nict, FALSE);
#if 0
    else
      rv = dict_insert (osip->osip_nict_hastable,
                        b_request->gvalue, (void *) nict, FALSE);
#endif

    if (rv == 0)
      {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "New key inserted in nict hastable `%s'\n",
                     b_request->gvalue));
    } else if (rv != -99)
      {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "already inserted `%s'\n", b_request->gvalue));
      }
  }
#endif
  osip_list_add (&osip->osip_nict_transactions, nict, -1);
#ifdef OSIP_MT
  osip_mutex_unlock (nict_fastmutex);
#endif
  return 0;
}

int
__osip_add_nist (osip_t * osip, osip_transaction_t * nist)
{
#ifdef OSIP_MT
  osip_mutex_lock (nist_fastmutex);
#endif
#if defined(HAVE_DICT_DICT_H)
  {
    osip_generic_param_t *b_request = NULL;
    int rv = -99;

    osip_via_param_get_byname (nist->topvia, "branch", &b_request);
    if (b_request != NULL && b_request->gvalue != NULL)
      rv = dict_insert (osip->osip_nist_hastable,
                        b_request->gvalue, (void *) nist, FALSE);
#if 0
    else
      rv = dict_insert (osip->osip_nist_hastable,
                        b_request->gvalue, (void *) nist, FALSE);
#endif
    if (rv == 0)
      {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_INFO1, NULL,
                     "New key inserted in ict hastable `%s'\n",
                     b_request->gvalue));
    } else if (rv != -99)
      {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "already inserted `%s'\n", b_request->gvalue));
      }
  }
#endif
  osip_list_add (&osip->osip_nist_transactions, nist, -1);
#ifdef OSIP_MT
  osip_mutex_unlock (nist_fastmutex);
#endif
  return 0;
}

int
osip_remove_transaction (osip_t * osip, osip_transaction_t * tr)
{
  int i = -1;

  if (tr == NULL)
    return -1;
  if (tr->ctx_type == ICT)
    i = __osip_remove_ict_transaction (osip, tr);
  else if (tr->ctx_type == IST)
    i = __osip_remove_ist_transaction (osip, tr);
  else if (tr->ctx_type == NICT)
    i = __osip_remove_nict_transaction (osip, tr);
  else if (tr->ctx_type == NIST)
    i = __osip_remove_nist_transaction (osip, tr);
  else
    return -1;
  return i;
}

int
__osip_remove_ict_transaction (osip_t * osip, osip_transaction_t * ict)
{
  osip_list_iterator_t iterator;
  osip_transaction_t *tmp;

#ifdef OSIP_MT
  osip_mutex_lock (ict_fastmutex);
#endif

#if defined(HAVE_DICT_DICT_H)
  {
    osip_generic_param_t *b_request = NULL;
    int rv;

    osip_via_param_get_byname (ict->topvia, "branch", &b_request);
    if (b_request != NULL && b_request->gvalue != NULL)
      {
        rv = dict_remove (osip->osip_ict_hastable, b_request->gvalue, TRUE);
        if (rv == 0)
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_INFO1, NULL,
                         "New key deleted in ict hastable `%s'\n",
                         b_request->gvalue));
        } else
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_WARNING, NULL,
                         "key not removed `%s'\n", b_request->gvalue));
          }
      }
  }
#endif

  tmp =
    (osip_transaction_t *) osip_list_get_first (&osip->osip_ict_transactions,
                                                &iterator);
  while (osip_list_iterator_has_elem (iterator))
    {
      if (tmp->transactionid == ict->transactionid)
        {
          osip_list_iterator_remove (&iterator);
#ifdef OSIP_MT
          osip_mutex_unlock (ict_fastmutex);
#endif
          return 0;
        }
      tmp = (osip_transaction_t *) osip_list_get_next (&iterator);
    }
#ifdef OSIP_MT
  osip_mutex_unlock (ict_fastmutex);
#endif
  return -1;
}

int
__osip_remove_ist_transaction (osip_t * osip, osip_transaction_t * ist)
{
  osip_list_iterator_t iterator;
  osip_transaction_t *tmp;

#ifdef OSIP_MT
  osip_mutex_lock (ist_fastmutex);
#endif

#if defined(HAVE_DICT_DICT_H)
  {
    osip_generic_param_t *b_request = NULL;
    int rv;

    osip_via_param_get_byname (ist->topvia, "branch", &b_request);
    if (b_request != NULL && b_request->gvalue != NULL)
      {
        rv = dict_remove (osip->osip_ist_hastable, b_request->gvalue, TRUE);

        if (rv == 0)
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_INFO1, NULL,
                         "New key deleted in ist hastable `%s'\n",
                         b_request->gvalue));
        } else
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_WARNING, NULL,
                         "key not removed `%s'\n", b_request->gvalue));
          }
      }
  }
#endif

  tmp =
    (osip_transaction_t *) osip_list_get_first (&osip->osip_ist_transactions,
                                                &iterator);
  while (osip_list_iterator_has_elem (iterator))
    {
      if (tmp->transactionid == ist->transactionid)
        {
          osip_list_iterator_remove (&iterator);
#ifdef OSIP_MT
          osip_mutex_unlock (ist_fastmutex);
#endif
          return 0;
        }
      tmp = (osip_transaction_t *) osip_list_get_next (&iterator);
    }
#ifdef OSIP_MT
  osip_mutex_unlock (ist_fastmutex);
#endif
  return -1;
}

int
__osip_remove_nict_transaction (osip_t * osip, osip_transaction_t * nict)
{
  osip_list_iterator_t iterator;
  osip_transaction_t *tmp;

#ifdef OSIP_MT
  osip_mutex_lock (nict_fastmutex);
#endif

#if defined(HAVE_DICT_DICT_H)
  {
    osip_generic_param_t *b_request = NULL;
    int rv;

    osip_via_param_get_byname (nict->topvia, "branch", &b_request);
    if (b_request != NULL && b_request->gvalue != NULL)
      {
        rv = dict_remove (osip->osip_nict_hastable, b_request->gvalue, TRUE);

        if (rv == 0)
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_INFO1, NULL,
                         "New key deleted in nict hastable `%s'\n",
                         b_request->gvalue));
        } else
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_WARNING, NULL,
                         "key not removed `%s'\n", b_request->gvalue));
          }
      }
  }
#endif

  tmp =
    (osip_transaction_t *) osip_list_get_first (&osip->osip_nict_transactions,
                                                &iterator);
  while (osip_list_iterator_has_elem (iterator))
    {
      if (tmp->transactionid == nict->transactionid)
        {
          osip_list_iterator_remove (&iterator);
#ifdef OSIP_MT
          osip_mutex_unlock (nict_fastmutex);
#endif
          return 0;
        }
      tmp = (osip_transaction_t *) osip_list_get_next (&iterator);
    }
#ifdef OSIP_MT
  osip_mutex_unlock (nict_fastmutex);
#endif
  return -1;
}

int
__osip_remove_nist_transaction (osip_t * osip, osip_transaction_t * nist)
{
  osip_list_iterator_t iterator;
  osip_transaction_t *tmp;

#ifdef OSIP_MT
  osip_mutex_lock (nist_fastmutex);
#endif

#if defined(HAVE_DICT_DICT_H)
  {
    osip_generic_param_t *b_request = NULL;
    int rv;

    osip_via_param_get_byname (nist->topvia, "branch", &b_request);
    if (b_request != NULL && b_request->gvalue != NULL)
      {
        rv = dict_remove (osip->osip_nist_hastable, b_request->gvalue, TRUE);

        if (rv == 0)
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_INFO1, NULL,
                         "New key deleted in ict hastable `%s'\n",
                         b_request->gvalue));
        } else
          {
            OSIP_TRACE (osip_trace
                        (__FILE__, __LINE__, OSIP_WARNING, NULL,
                         "key not removed `%s'\n", b_request->gvalue));
          }
      }
  }
#endif

  tmp =
    (osip_transaction_t *) osip_list_get_first (&osip->osip_nist_transactions,
                                                &iterator);
  while (osip_list_iterator_has_elem (iterator))
    {
      if (tmp->transactionid == nist->transactionid)
        {
          osip_list_iterator_remove (&iterator);
#ifdef OSIP_MT
          osip_mutex_unlock (nist_fastmutex);
#endif
          return 0;
        }
      tmp = (osip_transaction_t *) osip_list_get_next (&iterator);
    }
#ifdef OSIP_MT
  osip_mutex_unlock (nist_fastmutex);
#endif
  return -1;
}

#if 0
/* this method is made obsolete because it contains bugs and is also
   too much limited.
   any call to this method should be replace this way:

   //osip_distribute(osip, evt);
   int i = osip_find_transaction_and_add_event(osip, evt);

   if (i!=0) // in case it's a new request
     {
        if (evt is an ACK)
            evt could be an ACK for INVITE (not handled by oSIP)
        else if ( evt is a 200 for INVITE)
           evt could be a retransmission of a 200 for INVITE (not handled by oSIP)
        else if (evt is a new request)  == not a ACK and not a response
	  {
           transaction = osip_create_transaction(osip, evt);
           if (transaction==NULL)
             printf("failed to create a transaction\");
          }
    }
    else
    {
    // here, the message as been taken by the stack.
    }
*/


/* finds the transaction context and add the sipevent in its fifo. */
/* USED ONLY BY THE TRANSPORT LAYER.                               */
/* INPUT : osip_t *osip | osip. contains the list of tr. context*/
/* INPUT : osip_event_t* sipevent | event to dispatch.               */
osip_transaction_t *
osip_distribute_event (osip_t * osip, osip_event_t * evt)
{
  osip_transaction_t *transaction = NULL;
  int i;
  osip_fsm_type_t ctx_type;

  if (EVT_IS_INCOMINGMSG (evt))
    {
      /* event is for ict */
      if (MSG_IS_REQUEST (evt->sip))
        {
          if (0 == strcmp (evt->sip->cseq->method, "INVITE")
              || 0 == strcmp (evt->sip->cseq->method, "ACK"))
            {
#ifdef OSIP_MT
              osip_mutex_lock (ist_fastmutex);
#endif
              transaction =
                osip_transaction_find (osip->osip_ist_transactions, evt);
#ifdef OSIP_MT
              osip_mutex_unlock (ist_fastmutex);
#endif
          } else
            {
#ifdef OSIP_MT
              osip_mutex_lock (nist_fastmutex);
#endif
              transaction =
                osip_transaction_find (osip->osip_nist_transactions, evt);
#ifdef OSIP_MT
              osip_mutex_unlock (nist_fastmutex);
#endif
            }
      } else
        {
          if (0 == strcmp (evt->sip->cseq->method, "INVITE")
              || 0 == strcmp (evt->sip->cseq->method, "ACK"))
            {
#ifdef OSIP_MT
              osip_mutex_lock (ict_fastmutex);
#endif
              transaction =
                osip_transaction_find (osip->osip_ict_transactions, evt);
#ifdef OSIP_MT
              osip_mutex_unlock (ict_fastmutex);
#endif
          } else
            {
#ifdef OSIP_MT
              osip_mutex_lock (nict_fastmutex);
#endif
              transaction =
                osip_transaction_find (osip->osip_nict_transactions, evt);
#ifdef OSIP_MT
              osip_mutex_unlock (nict_fastmutex);
#endif
            }
        }
      if (transaction == NULL)
        {
          if (EVT_IS_RCV_STATUS_1XX (evt)
              || EVT_IS_RCV_STATUS_2XX (evt)
              || EVT_IS_RCV_STATUS_3456XX (evt) || EVT_IS_RCV_ACK (evt))
            {                   /* event MUST be ignored! */
              /* EXCEPT FOR 2XX THAT MUST BE GIVEN TO THE CORE LAYER!!! */

              /* TODO */

              OSIP_TRACE (osip_trace
                          (__FILE__, __LINE__, OSIP_WARNING, NULL,
                           "transaction does not yet exist... %x callid:%s\n",
                           evt, evt->sip->call_id->number));
              osip_message_free (evt->sip);
              osip_free (evt);  /* transaction thread will not delete it */
              return NULL;
            }

          /* we create a new context for this incoming request */
          if (0 == strcmp (evt->sip->cseq->method, "INVITE"))
            ctx_type = IST;
          else
            ctx_type = NIST;

          i = osip_transaction_init (&transaction, ctx_type, osip, evt->sip);
          if (i == -1)
            {
              osip_message_free (evt->sip);
              osip_free (evt);  /* transaction thread will not delete it */
              return NULL;
            }
        }
      evt->transactionid = transaction->transactionid;

      evt->transactionid = transaction->transactionid;
      osip_fifo_add (transaction->transactionff, evt);
      return transaction;
  } else
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_BUG, NULL,
                   "wrong event type %x\n", evt));
      return NULL;
    }
}
#endif

int
osip_find_transaction_and_add_event (osip_t * osip, osip_event_t * evt)
{
  osip_transaction_t *transaction = __osip_find_transaction (osip, evt, 1);

  if (transaction == NULL)
    return -1;
  return 0;
}

#ifndef OSIP_MT
osip_transaction_t *
osip_find_transaction (osip_t * osip, osip_event_t * evt)
{
  return __osip_find_transaction (osip, evt, 0);
}
#endif

osip_transaction_t *
__osip_find_transaction (osip_t * osip, osip_event_t * evt, int consume)
{
  osip_transaction_t *transaction = NULL;
  osip_list_t *transactions = NULL;

#ifdef OSIP_MT
  struct osip_mutex *mut = NULL;
#endif

  if (evt == NULL || evt->sip == NULL || evt->sip->cseq == NULL)
    return NULL;

  if (EVT_IS_INCOMINGMSG (evt))
    {
      if (MSG_IS_REQUEST (evt->sip))
        {
          if (0 == strcmp (evt->sip->cseq->method, "INVITE")
              || 0 == strcmp (evt->sip->cseq->method, "ACK"))
            {
              transactions = &osip->osip_ist_transactions;
#ifdef OSIP_MT
              mut = ist_fastmutex;
#endif
          } else
            {
              transactions = &osip->osip_nist_transactions;
#ifdef OSIP_MT
              mut = nist_fastmutex;
#endif
            }
      } else
        {
          if (0 == strcmp (evt->sip->cseq->method, "INVITE"))
            {
              transactions = &osip->osip_ict_transactions;
#ifdef OSIP_MT
              mut = ict_fastmutex;
#endif
          } else
            {
              transactions = &osip->osip_nict_transactions;
#ifdef OSIP_MT
              mut = nict_fastmutex;
#endif
            }
        }
  } else if (EVT_IS_OUTGOINGMSG (evt))
    {
      if (MSG_IS_RESPONSE (evt->sip))
        {
          if (0 == strcmp (evt->sip->cseq->method, "INVITE"))
            {
              transactions = &osip->osip_ist_transactions;
#ifdef OSIP_MT
              mut = ist_fastmutex;
#endif
          } else