C++ osip_trace函数代码示例

int
osip_dialog_update_route_set_as_uac (osip_dialog_t * dialog, osip_message_t * response)
{
    /* only the remote target URI is updated here... */
    osip_contact_t *contact;
    int i;

    if (osip_list_eol (response->contacts, 0))
    {   /* no contact header in response? */
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "missing a contact in response!\n"));
    }
    else
    {
        /* I personally think it's a bad idea to keep the old
        value in case the new one is broken... */
        if (dialog->remote_contact_uri != NULL)
        {
            osip_contact_free (dialog->remote_contact_uri);
        }
        dialog->remote_contact_uri = NULL;
        contact = osip_list_get (response->contacts, 0);
        i = osip_contact_clone (contact, &(dialog->remote_contact_uri));
        if (i != 0)
            return -1;
    }

    if (dialog->state == DIALOG_EARLY && osip_list_size (dialog->route_set) == 0)
    {   /* update the route set */
        int pos = 0;

        while (!osip_list_eol (response->record_routes, pos))
        {
            osip_record_route_t *rr;
            osip_record_route_t *rr2;

            rr = (osip_record_route_t *) osip_list_get (response->record_routes, pos);
            i = osip_record_route_clone (rr, &rr2);
            if (i != 0)
                return -1;
            osip_list_add (dialog->route_set, rr2, -1);
            pos++;
        }
    }

    if (MSG_IS_STATUS_2XX (response))
        dialog->state = DIALOG_CONFIRMED;
    return 0;
}

PPL_DECLARE (ppl_pipe_t *) ppl_pipe ()
{
	ppl_pipe_t *my_pipe;
	int i;

	my_pipe = (ppl_pipe_t *) osip_malloc (sizeof (ppl_pipe_t));
	if (my_pipe==NULL)
	{
		OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL,
			"Failed to allocate pipe!\n"));
		return NULL;
	}

	i = CreatePipe(my_pipe->pipes[0], my_pipe->pipes[1], NULL, 0);
	if (i!=0)
	{
	  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL,
				  "Failed to create pipe!\n"));
      osip_free (my_pipe);
	  return NULL;
	}
	return my_pipe;
}

static int
__osip_message_startline_to_str (osip_message_t * sip, char **dest)
{

  if (sip->sip_method != NULL)
    return __osip_message_startline_to_strreq (sip, dest);
  if (sip->status_code != 0)
    return __osip_message_startline_to_strresp (sip, dest);

  OSIP_TRACE (osip_trace
              (__FILE__, __LINE__, TRACE_LEVEL1, NULL,
               "ERROR method has no value or status code is 0!\n"));
  return -1;                    /* should never come here */
}

void
eXosip_reg_free (eXosip_reg_t * jreg)
{

  osip_free (jreg->r_aor);
  osip_free (jreg->r_contact);
  osip_free (jreg->r_registrar);

  if (jreg->r_last_tr != NULL)
    {
	  if (jreg->r_last_tr!=NULL && jreg->r_last_tr->orig_request!=NULL
		  && jreg->r_last_tr->orig_request->call_id!=NULL
		  && jreg->r_last_tr->orig_request->call_id->number!=NULL)
		  _eXosip_delete_nonce(jreg->r_last_tr->orig_request->call_id->number);

      if (jreg->r_last_tr->state == IST_TERMINATED ||
          jreg->r_last_tr->state == ICT_TERMINATED ||
          jreg->r_last_tr->state == NICT_TERMINATED ||
          jreg->r_last_tr->state == NIST_TERMINATED)
        {
          OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO1, NULL,
                                  "Release a terminated transaction\n"));
          __eXosip_delete_jinfo (jreg->r_last_tr);
          if (jreg->r_last_tr != NULL)
            osip_list_add (eXosip.j_transactions, jreg->r_last_tr, 0);
      } else
        {
          OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO1, NULL,
                                  "Release a non-terminated transaction\n"));
          __eXosip_delete_jinfo (jreg->r_last_tr);
          if (jreg->r_last_tr != NULL)
            osip_list_add (eXosip.j_transactions, jreg->r_last_tr, 0);
        }
    }

  osip_free (jreg);
}

int
__osip_find_next_crlf (const char *start_of_header, const char **end_of_header)
{
  const char *soh = start_of_header;

  *end_of_header = NULL;        /* AMD fix */

  while (('\r' != *soh) && ('\n' != *soh)) {
    if (*soh)
      soh++;
    else {
      OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "Final CRLF is missing\n"));
      return OSIP_SYNTAXERROR;
    }
  }

  if (('\r' == soh[0]) && ('\n' == soh[1]))
    /* case 1: CRLF is the separator
       case 2 or 3: CR or LF is the separator */
    soh = soh + 1;


  /* VERIFY if TMP is the end of header or LWS.            */
  /* LWS are extra SP, HT, CR and LF contained in headers. */
  if ((' ' == soh[1]) || ('\t' == soh[1])) {
    /* From now on, incoming message that potentially
       contains LWS must be processed with
       -> void osip_util_replace_all_lws(char *)
       This is because the parser methods does not
       support detection of LWS inside. */
    OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_BUG, NULL, "Message that contains LWS must be processed with osip_util_replace_all_lws(char *tmp) before being parsed.\n"));
    return -2;
  }

  *end_of_header = soh + 1;
  return OSIP_SUCCESS;
}

int
msg_set_header (sip_t * sip, char *hname, char *hvalue)
{
  int my_index;

  if (hname == NULL)
    return -1;
  stolowercase (hname);

  /* some headers are analysed completely      */
  /* this method is used for selective parsing */
  my_index = parser_isknownheader (hname);
  if (my_index >= 0)		/* ok */
    {
      int ret;

      ret = parser_callmethod (my_index, sip, hvalue);
      if (ret == -1)
	{
	  OSIP_TRACE (osip_trace
		      (__FILE__, __LINE__, OSIP_ERROR, NULL,
		       "Could not set header: \"%s\" %s\n", hname, hvalue));
	  return -1;
	}
      return 0;
    }
  /* unknownheader */
  if (msg_setheader (sip, hname, hvalue) == -1)
    {
      OSIP_TRACE (osip_trace
		  (__FILE__, __LINE__, OSIP_ERROR, NULL,
		   "Could not set unknown header\n"));
      return -1;
    }

  return 0;
}

int
__osip_ist_init (osip_ist_t ** ist, osip_t * osip, osip_message_t * invite)
{
  int i;

  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO2, NULL, "allocating IST context\n"));

  *ist = (osip_ist_t *) osip_malloc (sizeof (osip_ist_t));
  if (*ist == NULL)
    return OSIP_NOMEM;
  memset (*ist, 0, sizeof (osip_ist_t));
  /* for INVITE retransmissions */
  {
    osip_via_t *via;
    char *proto;

    i = osip_message_get_via (invite, 0, &via); /* get top via */
    if (i < 0) {
      osip_free (*ist);
      *ist = NULL;
      return i;
    }
    proto = via_get_protocol (via);
    if (proto == NULL) {
      osip_free (*ist);
      *ist = NULL;
      return OSIP_UNDEFINED_ERROR;
    }

    if (osip_strcasecmp (proto, "TCP") != 0 && osip_strcasecmp (proto, "TLS") != 0 && osip_strcasecmp (proto, "SCTP") != 0) {   /* for other reliable protocol than TCP, the timer
                                                                                                                                   must be desactived by the external application */
      (*ist)->timer_g_length = DEFAULT_T1;
      (*ist)->timer_i_length = DEFAULT_T4;
      (*ist)->timer_g_start.tv_sec = -1;        /* not started */
      (*ist)->timer_i_start.tv_sec = -1;        /* not started */
    }
    else {                      /* reliable protocol is used: */
      (*ist)->timer_g_length = -1;      /* A is not ACTIVE */
      (*ist)->timer_i_length = 0;       /* MUST do the transition immediatly */
      (*ist)->timer_g_start.tv_sec = -1;        /* not started */
      (*ist)->timer_i_start.tv_sec = -1;        /* not started */
    }
  }

  (*ist)->timer_h_length = 64 * DEFAULT_T1;
  (*ist)->timer_h_start.tv_sec = -1;    /* not started */

  return OSIP_SUCCESS;
}

static int
startline_parseresp (startline_t * dest, char *buf, char **headers)
{
  char *statuscode;
  char *reasonphrase;

  dest->rquri = NULL;
  dest->sipmethod = NULL;

  *headers = buf;

  statuscode = strchr (buf, ' ');	/* search for first SPACE */
  if (statuscode == NULL)
    return -1;
  dest->sipversion = (char *) smalloc (statuscode - (*headers) + 1);
  sstrncpy (dest->sipversion, *headers, statuscode - (*headers));

  reasonphrase = strchr (statuscode + 1, ' ');
  dest->statuscode = (char *) smalloc (reasonphrase - statuscode);
  sstrncpy (dest->statuscode, statuscode + 1, reasonphrase - statuscode - 1);

  {
    char *hp = reasonphrase;

    while ((*hp != '\r') && (*hp != '\n'))
      {
	if (*hp)
	  hp++;
	else
	  {
	    OSIP_TRACE (osip_trace
			(__FILE__, __LINE__, OSIP_ERROR, NULL,
			 "No crlf found\n"));
	    return -1;
	  }
      }
    dest->reasonphrase = (char *) smalloc (hp - reasonphrase);
    sstrncpy (dest->reasonphrase, reasonphrase + 1, hp - reasonphrase - 1);

    hp++;
    if ((*hp) && ('\r' == hp[-1]) && ('\n' == hp[0]))
      hp++;
    (*headers) = hp;
  }
  return 0;
}

struct osip_thread *
osip_thread_create (int stacksize, void *(*func) (void *), void *arg)
{
  int i;
  osip_thread_t *thread = (osip_thread_t *) osip_malloc (sizeof (osip_thread_t));
  if (thread==NULL) return NULL;

  i = pthread_create (thread, NULL, func, (void *) arg);
  if (i != 0)
    {
      OSIP_TRACE (osip_trace
		  (__FILE__, __LINE__, OSIP_ERROR, NULL,
		   "Error while creating a new thread\n"));
      return NULL;
    }
  return (struct osip_thread*)thread;
}

int
eXosip_build_publish (struct eXosip_t *excontext, osip_message_t ** message, const char *to, const char *from, const char *route, const char *event, const char *expires, const char *ctype, const char *body)
{
  int i;

  *message = NULL;

  if (to == NULL || to[0] == '\0')
    return OSIP_BADPARAMETER;
  if (from == NULL || from[0] == '\0')
    return OSIP_BADPARAMETER;
  if (event == NULL || event[0] == '\0')
    return OSIP_BADPARAMETER;
  if (ctype == NULL || ctype[0] == '\0') {
    if (body != NULL && body[0] != '\0')
      return OSIP_BADPARAMETER;
  }
  else {
    if (body == NULL || body[0] == '\0')
      return OSIP_BADPARAMETER;
  }

  i = _eXosip_generating_publish (excontext, message, to, from, route);
  if (i != 0) {
    OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_ERROR, NULL, "eXosip: cannot send message (cannot build PUBLISH)! "));
    return i;
  }

  if (body != NULL && body[0] != '\0' && ctype != NULL && ctype[0] != '\0') {
    osip_message_set_content_type (*message, ctype);
    osip_message_set_body (*message, body, strlen (body));
    /*
       osip_message_set_header (*message, "Content-Disposition",
       "render;handling=required");
     */
  }
  if (expires != NULL && expires[0] != '\0')
    osip_message_set_expires (*message, expires);
  else
    osip_message_set_expires (*message, "3600");

  osip_message_set_header (*message, "Event", event);

  return OSIP_SUCCESS;
}

int
_eXosip_remove_transaction_from_call (osip_transaction_t * tr, eXosip_call_t * jc)
{
  osip_transaction_t *inc_tr;
  osip_transaction_t *out_tr;
  eXosip_dialog_t *jd;
  int pos = 0;

  if (jc->c_inc_tr == tr) {
    jc->c_inc_tr = NULL;        /* can be NULL */
    return OSIP_SUCCESS;
  }

  for (jd = jc->c_dialogs; jd != NULL; jd = jd->next) {
    pos = 0;
    while (!osip_list_eol (jd->d_inc_trs, pos)) {
      inc_tr = osip_list_get (jd->d_inc_trs, pos);
      if (inc_tr == tr) {
        osip_list_remove (jd->d_inc_trs, pos);
        return OSIP_SUCCESS;
      }
      pos++;
    }
  }

  if (jc->c_out_tr == tr) {
    jc->c_out_tr = NULL;        /* can be NULL */
    return OSIP_SUCCESS;
  }

  for (jd = jc->c_dialogs; jd != NULL; jd = jd->next) {
    pos = 0;
    while (!osip_list_eol (jd->d_out_trs, pos)) {
      out_tr = osip_list_get (jd->d_out_trs, pos);
      if (out_tr == tr) {
        osip_list_remove (jd->d_out_trs, pos);
        return OSIP_SUCCESS;
      }
      pos++;
    }
  }

  OSIP_TRACE (osip_trace (__FILE__, __LINE__, OSIP_INFO1, NULL, "eXosip: No information.\n"));
  return OSIP_NOTFOUND;
}

int
osip_dialog_update_tag_as_uac (osip_dialog_t * dialog, osip_message_t * response)
{
    osip_generic_param_t *tag;
    int i;

    i = osip_to_get_tag (response->to, &tag);
    if (i != 0)
    {
        OSIP_TRACE (osip_trace
                    (__FILE__, __LINE__, OSIP_WARNING, NULL,
                     "Remote UA is not compliant: missing a tag in response!\n"));
        dialog->remote_tag = NULL;
    }
    else
        dialog->remote_tag = osip_strdup (tag->gvalue);
    return 0;
}

int main()
{
	int i,result;
	fd_set readfds;
	struct timeval tv;
	printf("Initializing OSIP\n");
	TRACE_INITIALIZE(END_TRACE_LEVEL,NULL);
	if(networkInit() < 0){
		printf("ERROR Initializing NETWORK\n");
		return -1;
	}
	i=osip_init(&osip);
	if (i!=0)
		return -1;
	printf("Setting Callbacks\n");
	setCallbacks(osip);
	printf("Entering Main loop 1\n");
	OSIP_TRACE(osip_trace(__FILE__,__LINE__,OSIP_BUG,NULL,"Check OSIP_TRACE init\n"));
	bSipRegister("This is Test Cookie");
	while(1){
		FD_ZERO(&readfds);
		FD_SET(sipSock,&readfds);
		tv.tv_sec = 0;
		tv.tv_usec = 100000;
		result = select(FD_SETSIZE,&readfds,0,0,&tv);
		if(result < 0){
			perror("main: select error");
			exit(1);
		}
		if(FD_ISSET(sipSock,&readfds)){
			printf("main: Received SIP message\n");
			processSipMsg();
		}
		osip_ict_execute(osip);
		osip_ist_execute(osip);
		osip_nict_execute(osip);
		osip_nist_execute(osip);
		osip_timers_ict_execute(osip);
		osip_timers_ist_execute(osip);
		osip_timers_nict_execute(osip);
		osip_timers_nist_execute(osip);
	}
	return 0;
}

void *
osip_fifo_tryget (osip_fifo_t * ff)
{
  void *el;

#ifdef OSIP_MT
  if (0 != osip_sem_trywait (ff->qisempty))
    {				/* no elements... */
      return NULL;
    }
  osip_mutex_lock (ff->qislocked);
#else
  if (ff->etat == vide)
    return NULL;
#endif

  if (ff->etat != vide)
    {
      el = osip_list_get (ff->queue, 0);
      osip_list_remove (ff->queue, 0);
      /* ff->nb_elt--; */
    }
#ifdef OSIP_MT
  else
    {				/* this case MUST never happen... */
      OSIP_TRACE (osip_trace
		  (__FILE__, __LINE__, OSIP_INFO4, NULL,
		   "no element in fifo.\n"));
      osip_mutex_unlock (ff->qislocked);
      return 0;
    }
#endif

  /* if (ff->nb_elt <= 0) */
  if (osip_list_size (ff->queue) <= 0)
    ff->etat = vide;
  else
    ff->etat = ok;

#ifdef OSIP_MT
  osip_mutex_unlock (ff->qislocked);
#endif
  return el;
}

int
eXosip_register_build_register (int rid, int expires, osip_message_t ** reg)
{
  eXosip_reg_t *jr;
  int i;

  *reg = NULL;

  if (rid <= 0)
    return OSIP_BADPARAMETER;

  jr = eXosip_reg_find (rid);
  if (jr == NULL)
    return OSIP_NOTFOUND;
  jr->r_reg_period = expires;
  if (jr->r_reg_period == 0)
    {
    } /* unregistration */
  else if (jr->r_reg_period > 3600)
    jr->r_reg_period = 3600;
  else if (jr->r_reg_period < 100)      /* too low */
    jr->r_reg_period = 100;

  if (jr->r_last_tr != NULL)
    {
      if (jr->r_last_tr->state != NICT_TERMINATED
          && jr->r_last_tr->state != NICT_COMPLETED)
        {
          return OSIP_WRONG_STATE;
        }
    }

  i = _eXosip_register_build_register (jr, reg);
  if (i != 0)
    {
      OSIP_TRACE (osip_trace
                  (__FILE__, __LINE__, OSIP_ERROR, NULL,
                   "eXosip: cannot build REGISTER!"));
      *reg = NULL;
      return i;
    }
  return OSIP_SUCCESS;
}