nua_glib.c

this is simple sip stack.

  g_signal_emit(self, signals[NGSIG_INCOMING_INFO], 0, op, to->a_display, url, subject?subject->g_value:NULL, message); 
  su_free(self->priv->home, url);
  g_string_free(message, TRUE);

  if (op == NULL)
    op = nua_glib_op_create2(self, SIP_METHOD_INFO, nh, from);
  if (op == NULL)
    nua_handle_destroy(nh);

}

/*=======================================*/
/**
 * nua_glib_refer:
 * @op: operation representing existing call
 * @destination: destination to REFER them to
 *
 * refer the recipent of an existing call to a new address
 */
void
nua_glib_refer (NuaGlib *self, NuaGlibOp *op, const char* destination)
{
  /*TODO, here or elsewhere?
    if (op == NULL) 
    op = nua_glib_op_create(self, SIP_METHOD_REFER, destination, TAG_END());
  */
  nua_refer(op->op_handle,
            SIPTAG_REFER_TO_STR(destination),
            TAG_END());
}


static void 
sof_r_refer (int status, char const *phrase,
             nua_t *nua, NuaGlib *self,
             nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
             tagi_t tags[])
{

  g_signal_emit(self, signals[NGSIG_REFER_ANSWERED], 0, op, status, phrase );

  if (status < 200)
    return;

  priv_oper_check_response_for_auth(self, op, status, sip, tags);
}

/*---------------------------------------*/
static void 
sof_i_refer (nua_t *nua, NuaGlib *self,
             nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
             tagi_t tags[])
{
  /* Incoming refer */
  sip_from_t const *from;
  sip_to_t const *to;
  sip_refer_to_t const *refer_to;
  NuaGlibOp *op2;
  char *refer_to_str;

  assert(sip);

  from = sip->sip_from;
  to = sip->sip_to;
  refer_to = sip->sip_refer_to;

  assert(from && to);

  char *url = url_as_string(self->priv->home, to->a_url);
  char *refer_url = url_as_string(self->priv->home, refer_to->r_url);

   if(refer_to->r_url->url_type == url_sip) {
      refer_to_str = sip_header_as_string(self->priv->home, (sip_header_t*)refer_to);
      op2 = nua_glib_op_create(self, SIP_METHOD_INVITE, refer_to_str,
                            NUTAG_NOTIFY_REFER(nh), TAG_END());
      su_free(self->priv->home, refer_to_str);
      
      g_signal_emit(self, signals[NGSIG_INCOMING_REFER], 0, op, to->a_display, url,refer_url, op2);
   }
   else {
      g_signal_emit(self, signals[NGSIG_INCOMING_REFER], 0, op, to->a_display, url, refer_url, NULL);
   }

  su_free(self->priv->home, url);
  su_free(self->priv->home, refer_url);
 }

/**
 * nua_glib_follow_refer:
 * @op: operation returned in incoming-refer signal
 *
 * Follow a received REFER
 */
void 
nua_glib_follow_refer(NuaGlib *self, NuaGlibOp *op)
{

}


/**
 * nua_glib_hold:
 * @op: operation representing the call
 * @hold: TRUE to hold, FALSE to take off hold
 * 
 * Change the hold status of a call
 */
void 
nua_glib_hold(NuaGlib *self, NuaGlibOp *op, int hold)
{
  nua_invite(op->op_handle, NUTAG_HOLD(hold), TAG_END());
      
  op->op_callstate = opc_sent2;
}

/**
 * nua_glib_subscribe:
 * @uri: URI to subscribe to
 * @eventlist: request eventlists
 *
 * Subscribe to presence notifications for a given URI
 * Return value: operation representing this presence notifcation channel
 */

NuaGlibOp *
nua_glib_subscribe(NuaGlib *self, const char *uri, gboolean eventlist)
{
  NuaGlibOp *op;
  char const *event = "presence";
  char const *supported = NULL;

  if (eventlist)
    supported="eventlist";
  
  op = nua_glib_op_create(self, SIP_METHOD_SUBSCRIBE, uri, TAG_END());

  if (op) {
    nua_subscribe(op->op_handle, 
                  SIPTAG_EXPIRES_STR("3600"),
                  SIPTAG_ACCEPT_STR("application/cpim-pidf+xml;q=0.5, "
                                    "application/pidf-partial+xml"),
                  TAG_IF(supported, 
                         SIPTAG_ACCEPT_STR("multipart/related, "
                                           "application/rlmi+xml")),
                  SIPTAG_SUPPORTED_STR(supported),
                  SIPTAG_EVENT_STR(event),
                  TAG_END());
      return op;
  }
  else
      return NULL;
}

/**
 * nua_glib_watch:
 * @event string descriptor of event to watch for
 * TODO: needs some funky signal registering, i *think*
 *
 * Subscribe to watch
 * Returns: Operation representing this watch, NULL if failure
 */
NuaGlibOp *
nua_glib_watch(NuaGlib *self, char *event)
{
  NuaGlibOp *op;
  char *destination;

  destination = strchr(event, ' ');
  while (destination && *destination == ' ')
    *destination++ = '\0';

  op = nua_glib_op_create(self, SIP_METHOD_SUBSCRIBE, destination, TAG_END());

  if (op) {
    nua_subscribe(op->op_handle, 
                  SIPTAG_EVENT_STR(event),
                  TAG_END());
  }
  return op;
}

static void 
sof_r_subscribe (int status, char const *phrase,
                 nua_t *nua, NuaGlib *self,
                 nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
                 tagi_t tags[])
{
  g_signal_emit(self, signals[NGSIG_SUBSCRIBE_ANSWERED], 0, op, status, phrase);

  if (status < 200)
    return;
  if (status >= 300)
    op->op_persistent = 0;

  priv_oper_check_response_for_auth(self, op, status, sip, tags);
}
/**
 * nua_glib_notify:
 * @op: operation returned in refer-incoming signal
 *
 * send a NOTIFY in response to a REFER
 *
 * This cancels the REFER
 * You should remove any refernces you hold to @op after calling this function
 */
void
nua_glib_notify(NuaGlib *self, NuaGlibOp* op)
{
  SU_DEBUG_1(("%s: not follow refer, NOTIFY(503)\n", self->priv->name));

  nua_cancel(op->op_handle, TAG_END());
  nua_glib_op_destroy(self, op);
}

static void 
sof_i_notify(nua_t *nua, NuaGlib *self,
                  nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
                  tagi_t tags[])
{
  sip_event_t const *event = sip->sip_event;
  sip_content_type_t const *content_type = sip->sip_content_type;
  GString *message;
  assert(sip);

  if (sip->sip_payload)
    message=g_string_new_len(sip->sip_payload->pl_data, sip->sip_payload->pl_len);
  else
    message=NULL;

  g_signal_emit(self, signals[NGSIG_INCOMING_NOTIFY], 0, op, (event?event->o_type:NULL), (content_type?content_type->c_type:NULL),  message); 
  g_string_free(message, TRUE);
}
/*---------------------------------------*/
static void 
sof_r_notify(int status, char const *phrase,
             nua_t *nua, NuaGlib *self,
             nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
             tagi_t tags[])
{
  g_signal_emit(self, signals[NGSIG_NOTIFY_ANSWERED], 0, op, status, phrase);

  if (status < 200)
    return;

  priv_oper_check_response_for_auth(self, op, status, sip, tags);
}

/*---------------------------------------*/

/**
 * nua_glib_unsubscribe:
 * @op: operation representing subscribtion to unsubscribe
 *
 * Unsubscribe a subscription
 */

void 
nua_glib_unsubscribe(NuaGlib *self, NuaGlibOp *op)
{
  nua_unsubscribe(op->op_handle, TAG_END());
}

static void 
sof_r_unsubscribe(int status, char const *phrase,
                  nua_t *nua, NuaGlib *self,
                  nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
                  tagi_t tags[])
{
  g_signal_emit(self, signals[NGSIG_UNSUBSCRIBE_ANSWERED], 0, op, status, phrase);

  if (status < 200)
    return;

  nua_glib_op_destroy(self, op);
}

/**
 * nua_glib_reregister:
 * @op: op from original register.  
 *
 * reregister to the current registrar with same contact
 */

void
nua_glib_reregister(NuaGlib *self, NuaGlibOp *op)
{

  nua_register(op->op_handle, TAG_NULL());
  return;
}

/**
 * nua_glib_register:
 * @registrar: registrar to use,NULL to use current registrar set for this stack
 *
 * send a REGISTER
 * Returns: REGISTER operation
 */
NuaGlibOp*
nua_glib_register(NuaGlib *self, const char *registrar)
{
  NuaGlibOp *op = NULL;
  char *address;
  address = su_strdup(self->priv->home, self->priv->address);

  if ((op = nua_glib_op_create(self, SIP_METHOD_REGISTER, address, TAG_END()))) {
    SU_DEBUG_3(("%s: REGISTER %s\n", self->priv->name, op->op_ident));
    nua_register(op->op_handle, 
		 SIPTAG_FROM_STR(self->priv->address),
                 TAG_IF(registrar, NUTAG_REGISTRAR(registrar)), 
                 TAG_NULL());
  }
  su_free(self->priv->home, address);
  return op;
}

static void 
sof_r_register (int status, char const *phrase, 
                nua_t *nua, NuaGlib *self,
                nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
                tagi_t tags[])
{
  g_signal_emit(self, signals[NGSIG_REGISTER_ANSWERED], 0, op, status, phrase);

  if (status < 200)
    return;

  priv_oper_check_response_for_auth(self, op, status, sip, tags);

  if (status >= 300 && status != 401 && status != 407)
    nua_glib_op_destroy(self, op);
}

/**
 * nua_glib_unregister:
 * @op: operation returned from register
 *
 * unregister
 */
void 
nua_glib_unregister(NuaGlib *self, NuaGlibOp *op)
{
  SU_DEBUG_3(("%s: un-REGISTER %s\n", self->priv->name, op->op_ident));
  nua_unregister(op->op_handle, TAG_NULL());
}

/**
 * nua_glib_unregister_direct:
 * @op: operation returned from register
 *
 * unregister
 * Returns: operation used for this UNREGISTER
 */
NuaGlibOp *
nua_glib_unregister_direct(NuaGlib *self, const char *registrar)
{
  NuaGlibOp *op;
  char *address = su_strdup(self->priv->home, self->priv->address);

  op = nua_glib_op_create(self, SIP_METHOD_REGISTER, address, TAG_END());
  su_free(self->priv->home, address);

  if (op) {
    nua_unregister(op->op_handle,
                   TAG_IF(registrar, NUTAG_REGISTRAR(registrar)),
                   SIPTAG_CONTACT_STR("*"),
                   SIPTAG_EXPIRES_STR("0"),
                   TAG_NULL());
    return op;
  }
  else
    return NULL;
}


static void 
sof_r_unregister (int status, char const *phrase, 
                  nua_t *nua, NuaGlib *self,
                  nua_handle_t *nh, NuaGlibOp *op, sip_t const *sip,
                  tagi_t tags[])
{
  sip_contact_t *m;

  g_signal_emit(self, signals[NGSIG_UNREGISTER_ANSWERED], 0, op, status, phrase);

  if (status < 200)
    return;

  if (status == 200)
    for (m = sip ? sip->sip_contact : NULL; m; m = m->m_next)
      sl_header_print(stdout, "\tContact: %s\n", (sip_header_t *)m);

  priv_oper_check_response_for_auth(self, op, status, sip, tags);

  if (status >= 300 && status != 401 && status != 407)
    nua_glib_op_destroy(self, op);
}

/**
 * nua_glib_republish:
 * @op: call to publish info in
 * @note: note to publish
 *
 * Publish information in an existing channel
 */
void 
nua_glib_republish(NuaGlib *self, NuaGlibOp *op, const char *note)
{
  sip_payload_t *pl = NULL;
  char *xmlnote = NULL;
  int open;

  open = ((note == NULL) || note[0] != '-');

  if (note && strcmp(note, "-") != 0)
    xmlnote = su_sprintf(self->priv->home, "<note>%s</note>\n", 
                         open ? note : note + 1);

  pl = sip_payload_format
    (self->priv->home, 
     "<?xml version='1.0' encoding='UTF-8'?>\n"
     "<presence xmlns='urn:ietf:params:xml:ns:cpim-pidf'\n"
     "          entity='%s'>\n"
     "  <tuple id='%s'>\n"
     "    <status><basic>%s</basic></status>\n"
     "%s"
     "  </tuple>\n"
     "</presence>\n",
     self->priv->address, self->priv->name, 
     open ? "open" : "closed", 
     xmlnote ? xmlnote : "");

  nua_publish(op->op_handle, 
              SIPTAG_PAYLOAD(pl),
              TAG_IF(pl, SIPTAG_CONTENT_TYPE_STR("application/cpim-pidf+xml")),
              TAG_NULL());

  su_free(self->priv->home, pl);
}

/**
 * nua_glib_publish:
 * @note: note to publish
 *
 * Publish information
 */
NuaGlibOp *
nua_glib_publish(NuaGlib *self, const char *note)
{
  NuaGlibOp *op = NULL;
  sip_payload_t *pl = NULL;
  char *xmlnote = NULL;
  int open;
  char *address;

  open = ((note == NULL) || note[0] != '-');

  if (note && strcmp(note, "-") != 0)
    xmlnote = su_sprintf(self->priv->home, "<note>%s</note>\n", 
                         open ? note :