source: verona/phapi/phapi.c @ 93:352243f5dc95

/*
 * phapi   phone api
 *
 * Copyright (C) 2004        Vadim Lebedev <vadim@mbdsys.com>
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as
 * published by the Free Software F undation; either version 2,
 * or (at your option) any later version.
 *
 * This is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with dpkg; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/**
 * @file phapi.c
 * @brief softphone  API
 *
 * phapi is a library providing simplified api to create VOIP sessions
 * using eXosip library oSIP stack and oRTP stcak 
 * <P>
 */

#include "phglobal.h"
#ifdef OS_WIN32
#include <winsock2.h>
#include <windows.h>
#endif
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <limits.h>
#include <ctype.h>
#include <assert.h>
#include <time.h>

#if !defined(OS_WIN32) && !defined(_WIN32_WCE)
//#include "config.h"
#include <sys/wait.h>
#include <unistd.h>
#include <dirent.h>
#ifndef OS_MACOSX
#include <sys/soundcard.h>
#endif
#include <sys/ioctl.h>
#include <fcntl.h>
#else  /* WIN32 */
#define snprintf _snprintf
#ifndef _WIN32_WCE
#define strncasecmp strnicmp
#endif /* !_WIN32_WCE */
#define strcasecmp stricmp
#define usleep(usecs) Sleep((usecs)/1000)
#define random rand
#endif

#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#include <osip2/osip_dialog.h>
#include <osip2/osip_mt.h>
#include <osip2/osip.h>
#include <eXosip2/eXosip.h>
#include <ortp/stun.h>
#include <ortp/ortp.h>
#include <ortp/payloadtype.h>

#include "phdebug.h"
#include "phapi.h"
#include "phcall.h"
#include "phrpc.h"
#ifdef OLDOSIP
# include "phmedia.h"
#else
# include "phms.h"
#endif
#include "sdphandler.h"

#ifdef USE_HTTP_TUNNEL
#include "httptunnel.h"
#endif
/*
#define G711_ONLY
 */

#if  1

#define DBG(x)  printf(x)
#define DBG2(x,y)  printf(x,y)

#define SKIP(x)

#ifdef PHAPI_VIDEO_SUPPORT
#include <avcodec.h>
#endif

static struct osip_thread *phapithread = NULL;

phcall_t *ph_locate_call(eXosip_event_t *je, int creatit);
phcall_t *ph_allocate_call(int cid);
phcall_t *ph_locate_call_for_refer(eXosip_event_t *je);

void ph_wegot_dtmf(void  *ctx, int dtmfEvent);
static int ph_event_get();


static char *ph_get_call_contact(phcall_t *ca);

#define MEDIA_SUSPEND

#ifndef PH_STREAM_AUDIO
#define PH_STREAM_AUDIO (1 << 0)
#define PH_STREAM_VIDEO_RX (1 << 1)
#define PH_STREAM_VIDEO_TX (1 << 2)
#endif

#define PH_STREAM_CNG (1 << 30)


static int ph_call_retrieve_payloads(phcall_t *ca, eXosip_event_t *je, int flags);
static int ph_call_media_start(phcall_t *ca, eXosip_event_t *je, int flags, int resumeflag);
static char *ph_ipv4tostr(char *buf, const StunAddress4 addr);


void ph_release_call(phcall_t *ca);
static  int timeout = 500;

static int ph_resend_offset = 30;

#define PORT_STRING_LEN 16
static char ph_nat_router_addr[32];
static char ph_nat_type_str[32];
static char ph_nat_port_str[PORT_STRING_LEN];
static char ph_nat_video_port_str[16];

static char ph_nat_sip_port_str[16];

static char vcontact[256];

static NatType ph_nat_type = StunTypeOpen;

static char * _get_local_sip_port();
static void  _get_local_video_sdp_port(char buf[]);
static void  _get_local_audio_sdp_port(char buf[]);

static char*  _get_public_sip_port();




void ph_message_progress(eXosip_event_t *je);
static void ph_keep_refreshing();
static void  ph_call_requestfailure(eXosip_event_t *je);

static void ph_frame_display_cbk(void *ctx, void *event);

static int ph_call_media_stop(phcall_t * ca);
static int ph_call_media_suspend(phcall_t *ca, int localhold);

#define nonempty(x)  ((x) && (x)[0])


#define USE_VLINES 1
#ifndef PH_MAX_VLINES
#define PH_MAX_VLINES 16
#endif


struct vline
{
  char  *displayname;
  char  *username;
  char  *server;
  int    port;
  char  *proxy;
  char  *contact;
  time_t   regTimeout;
  time_t   lastRegTime;
  int   rid;
#define VL_USED 1
#define VL_DELETING 2
  int   used;
  int   busy;
  char  *followme;
  int    mobility;
  struct
  {
    time_t  timeout;
    time_t  last;
    char    *etag;
    char    *uri;
    char    *evt;
    char    *ctt;
    char    *body;
  } pub;
};


struct vline ph_vlines[PH_MAX_VLINES];

static void
ph_build_cname(char *buf, int n, struct vline *vl);

static const char *
ph_get_event_type_str(int winfo)
{
  // FIXME:
  return winfo ? "presence.winfo" : "presence";
} 

static int 
ph_req_set_body(osip_message_t *msg, const char *body, const char *mime);


static 
void ph_msession_free(struct ph_msession_s *s);
static 
void ph_msession_use(struct ph_msession_s *s);

static struct vline *vline_alloc();
static void vline_free(struct vline *vl);
#define PHM_IGNORE_PORT 1
#define PHM_IGNORE_HOST 2
static struct vline *ph_find_matching_vline(const char *userid, int ignore);
static struct vline *ph_find_matching_vline2(const char *username, const char* host, int ignore);
static struct vline *ph_find_matching_vline3(const char *username, const char* host, int port, int ignore);  
static struct vline *ph_find_vline_by_rid(int rid);

static char *ph_get_proxy(const char *from);
static int   ph_get_vline_id(const char *userid, const char *altid);
static const char *ph_get_nat_type() { return ph_nat_type_str; }

int getPublicPort(char *local_voice_port, char *local_video_port, char *public_voice_port, char *public_video_port);



#define ph_vlid2vline(vlid) (ph_vlines + (vlid) - 1)
#define ph_vline2vlid(vl) ((vl) - ph_vlines + 1)

#define clear(x) memset(&x, 0, sizeof(x))

static struct vline *
ph_valid_vlid(int vlid)
{
  struct vline *vl = 0;

  if (vlid > 0 && vlid <= PH_MAX_VLINES)
    {
    vl = ph_vlid2vline(vlid);
    if (!vl->used || vl->used == VL_DELETING)
      vl = 0;
    }
  return vl;
}

PHAPI_EXPORT phCallbacks_t *phcb;

PHAPI_EXPORT int phIsInitialized;

PHAPI_EXPORT int phDebugLevel = 0;
PHAPI_EXPORT char *phLogFileName = 0;

static char ph_follow_me_addr[256];

unsigned short phCallBackPort = PH_CALLBACK_PORT; 
PHAPI_EXPORT  unsigned short phServerPort = PH_SERVER_PORT;

static int ph_busyFlag;


static FILE *ph_log_file;

#define ph_printf printf

void *
ph_api_thread(void *arg);

// mutex for ph_start_call
ph_mutex_t  *ph_media_start_mutex;

// mutex for ph_release_call
ph_mutex_t  *ph_media_stop_mutex;


#define name(x) #x

static char *evtnames[] =
    {
        name(EXOSIP_REGISTRATION_NEW),           /**< announce new registration.       */
        name(EXOSIP_REGISTRATION_SUCCESS),       /**< user is successfully registred.  */
        name(EXOSIP_REGISTRATION_FAILURE),       /**< user is not registred.           */
        name(EXOSIP_REGISTRATION_REFRESHED),     /**< registration has been refreshed. */
        name(EXOSIP_REGISTRATION_TERMINATED),    /**< UA is not registred any more.    */

        /* INVITE related events within calls */
        name(EXOSIP_CALL_INVITE),            /**< announce a new call                   */
        name(EXOSIP_CALL_REINVITE),          /**< announce a new INVITE within call     */

        name(EXOSIP_CALL_NOANSWER),          /**< announce no answer within the timeout */
        name(EXOSIP_CALL_PROCEEDING),        /**< announce processing by a remote app   */
        name(EXOSIP_CALL_RINGING),           /**< announce ringback                     */
        name(EXOSIP_CALL_ANSWERED),          /**< announce start of call                */
        name(EXOSIP_CALL_REDIRECTED),        /**< announce a redirection                */
        name(EXOSIP_CALL_REQUESTFAILURE),    /**< announce a request failure            */
        name(EXOSIP_CALL_SERVERFAILURE),     /**< announce a server failure             */
        name(EXOSIP_CALL_GLOBALFAILURE),     /**< announce a global failure             */
        name(EXOSIP_CALL_ACK),               /**< ACK received for 200ok to INVITE      */

        name(EXOSIP_CALL_CANCELLED),         /**< announce that call has been cancelled */
        name(EXOSIP_CALL_TIMEOUT),           /**< announce that call has failed         */

        /* request related events within calls (except INVITE) */
        name(EXOSIP_CALL_MESSAGE_NEW),              /**< announce new incoming request. */
        name(EXOSIP_CALL_MESSAGE_PROCEEDING),       /**< announce a 1xx for request. */
        name(EXOSIP_CALL_MESSAGE_ANSWERED),         /**< announce a 200ok  */
        name(EXOSIP_CALL_MESSAGE_REDIRECTED),       /**< announce a failure. */
        name(EXOSIP_CALL_MESSAGE_REQUESTFAILURE),   /**< announce a failure. */
        name(EXOSIP_CALL_MESSAGE_SERVERFAILURE),    /**< announce a failure. */
        name(EXOSIP_CALL_MESSAGE_GLOBALFAILURE),    /**< announce a failure. */

        name(EXOSIP_CALL_CLOSED),            /**< a BYE was received for this call      */

        /* for both UAS & UAC events */
        name(EXOSIP_CALL_RELEASED),             /**< call context is cleared.            */

        /* response received for request outside calls */
        name(EXOSIP_MESSAGE_NEW),              /**< announce new incoming request. */
        name(EXOSIP_MESSAGE_PROCEEDING),       /**< announce a 1xx for request. */
        name(EXOSIP_MESSAGE_ANSWERED),         /**< announce a 200ok  */
        name(EXOSIP_MESSAGE_REDIRECTED),       /**< announce a failure. */
        name(EXOSIP_MESSAGE_REQUESTFAILURE),   /**< announce a failure. */
        name(EXOSIP_MESSAGE_SERVERFAILURE),    /**< announce a failure. */
        name(EXOSIP_MESSAGE_GLOBALFAILURE),    /**< announce a failure. */

        /* Presence and Instant Messaging */
        name(EXOSIP_SUBSCRIPTION_UPDATE),         /**< announce incoming SUBSCRIBE.      */
        name(EXOSIP_SUBSCRIPTION_CLOSED),         /**< announce end of subscription.     */

        name(EXOSIP_SUBSCRIPTION_NOANSWER),          /**< announce no answer              */
        name(EXOSIP_SUBSCRIPTION_PROCEEDING),        /**< announce a 1xx                  */
        name(EXOSIP_SUBSCRIPTION_ANSWERED),          /**< announce a 200ok                */
        name(EXOSIP_SUBSCRIPTION_REDIRECTED),        /**< announce a redirection          */
        name(EXOSIP_SUBSCRIPTION_REQUESTFAILURE),    /**< announce a request failure      */
        name(EXOSIP_SUBSCRIPTION_SERVERFAILURE),     /**< announce a server failure       */
        name(EXOSIP_SUBSCRIPTION_GLOBALFAILURE),     /**< announce a global failure       */
        name(EXOSIP_SUBSCRIPTION_NOTIFY),            /**< announce new NOTIFY request     */

        name(EXOSIP_SUBSCRIPTION_RELEASED),          /**< call context is cleared.        */

        name(EXOSIP_IN_SUBSCRIPTION_NEW),            /**< announce new incoming SUBSCRIBE.*/
        name(EXOSIP_IN_SUBSCRIPTION_RELEASED),       /**< announce end of subscription.   */

        name(EXOSIP_NOTIFICATION_NOANSWER),          /**< announce no answer              */
        name(EXOSIP_NOTIFICATION_PROCEEDING),        /**< announce a 1xx                  */
        name(EXOSIP_NOTIFICATION_ANSWERED),          /**< announce a 200ok                */
        name(EXOSIP_NOTIFICATION_REDIRECTED),        /**< announce a redirection          */
        name(EXOSIP_NOTIFICATION_REQUESTFAILURE),    /**< announce a request failure      */
        name(EXOSIP_NOTIFICATION_SERVERFAILURE),     /**< announce a server failure       */
        name(EXOSIP_NOTIFICATION_GLOBALFAILURE)     /**< announce a global failure       */

    };

#undef name



phcall_t ph_calls[PH_MAX_CALLS];


/* 
//#define FORCE_VAD   1
#define FORCE_CNG   1
 */


ph_config_t phcfg = { "", "10600", "", "10700", "",
    /* sipport  */ "5060",
    /* nattype */  "" ,
    /* codecs */   "" ,"",
    /* asyncmode */ 0,
    /* audio_dev */   "" ,
    /* softboost */ 0,0,0,
    /* vad */ 0,0,0, 0,
    0,0,0,
    /* stunserver */  "80.118.132.74",
    0
};


PHAPI_EXPORT ph_config_t *ph_get_config()
{
  return &phcfg;
}

static int _is_video_enabled(int streams) 
{
  return (streams & (PH_STREAM_VIDEO_RX | PH_STREAM_VIDEO_TX));
}


static int _is_audio_enabled(int streams) 
{
  return (streams & PH_STREAM_AUDIO);
}

static char *ph_ipv4tostr(char *buf, const StunAddress4 addr)
{
  uint32_t ip = addr.addr;

  sprintf(buf, "%d.%d.%d.%d", (ip >> 24) & 255,  (ip >> 16) & 255, (ip >> 8) & 255, ip & 255);

  return buf;

}

static int 
ph_port_inuse(int port)
{
  int i;
  phcall_t *ca;

  /* scan all active calls and check that the given port is inuse */
  for(i=0; i<PH_MAX_CALLS;  i++)
    {
    ca = &ph_calls[i];
    if (ca->cid != -1)
      {
      /* active call */
      if(ca->local_sdp_audio_port == port || port == ca->local_sdp_video_port)
        return 1;
      }
    }

  return 0;
}

static void 
_get_local_audio_sdp_port(char buf[])
{

  /* <MINHPQ>
   * To get arround the problem of connect in winsock ( connect returns
   * an error: 10048: Address already in use connect is called an the local address is in used
   * within the last 2 or 4 minutes), we should not bind the rtp socket to a specific local port. Hence,
   * we should return "0" here to let the system choose a random port number.
   */

  /* base port number*/
  int port = atoi(phcfg.local_rtp_port);

  buf[0] = 0;

  if (port == -1)
    port = 10600 + random() % 4096;

  while(1)
    {
    if (!ph_port_inuse(port))
      {
      sprintf(buf, "%d", port);
      return;
      }
    else
      port += 2;    /* try next pair */
    }
}

static void 
_get_local_video_sdp_port(char buf[]) 
{
  int port = atoi(phcfg.local_rtp_port);

  buf[0] = 0;

  if (port == -1)
    port = 10600 + random() % 4096;
  else
    port += 2;

  while(1)
    {
    if (!ph_port_inuse(port))
      {
      sprintf(buf, "%d", port);
      return;
      }
    else
      port += 2;    /* try next pair */
    }
}



static char *
_get_local_sip_port()
{
  return phcfg.sipport;
}

static char *
_get_public_sip_port()
{
  if (ph_nat_sip_port_str[0])
    return ph_nat_sip_port_str;
  return _get_local_sip_port();
}

phcall_t *
ph_locate_call_by_cid(int cid)
{
  phcall_t *ca;

  for(ca = ph_calls; ca < &ph_calls[PH_MAX_CALLS];  ca++)
    {
    if (ca->cid == cid)
      return ca;
    }
  return 0;
}

#if 0
void phReleaseTerminatedCalls()
{
  phcall_t *ca;
  for(ca = ph_calls; ca < &ph_calls[PH_MAX_CALLS];  ca++)
    {
    if ((ca->cid != -1) && (ph_media_is_stream_stopped(ca) == 1))
      ph_release_call(ca);
    }
}
#endif

phcall_t *
ph_locate_call_by_rcid(int cid)
{
  phcall_t *ca;


  for(ca = ph_calls; ca < &ph_calls[PH_MAX_CALLS];  ca++)
    {
    if (ca->rcid == cid)
      return ca;
    }

  return 0;
}

phcall_t *
ph_locate_call_by_rdid(int did)
{
  phcall_t *ca;


  for(ca = ph_calls; ca < &ph_calls[PH_MAX_CALLS];  ca++)
    {
    if (ca->rdid == did)
      return ca;
    }

  return 0;
}


phcall_t *
ph_allocate_call(int cid)
{
  phcall_t *ca = ph_locate_call_by_cid(-1);

  if (!ca)
    return 0;

  ca->redirs = 0;
  ca->cid = cid;
  return ca;
}


phcall_t *
ph_locate_call(eXosip_event_t *je, int creatit)
{
  phcall_t *ca, *found = 0, *newca = 0;
  osip_header_t *hdr = 0;


  /* lookup matching call descriptor */
  for (ca = ph_calls; ca < &ph_calls[PH_MAX_CALLS]; ca++)
    {
    if (ca->cid == -1 && !newca)
      newca = ca;

    if (ca->cid == je->cid)
      {
      found = ca;
      break;
      }
    }

  ca = found;

  if (!ca) /* we didn't find a matching call descriptor */
    {
    if (creatit)
      {
      /* allocate a new one */
      if (!newca)
        return 0; /* !!! BUG !!! */
      ca = newca;
      memset(ca, 0, sizeof(*ca));
      ca->cid = -2;
      }
    }

  if (!ca)
    return 0;


  /* update the call information */

  if (!ca->localrefer)
    {
    ca->cid = je->cid;
    ca->did = je->did;
    ca->tid = je->tid;
    }

  osip_message_header_get_byname(je->response, "Accept-Contact", 0, &hdr);
  if (hdr && !strcmp(hdr->hvalue, "*;+g.oma.sip-im"))
    ca->nego_mflags = PH_STREAM_DATA;

  return ca;
}

static void 
ph_free_stream(struct ph_stream_params *sp)
{
  int i;

  if (sp->streamtype)
    free((void *) sp->streamtype);
  if (sp->payloads)
    free((void *) sp->payloads);
  if (sp->streamaddr)
    free((void *) sp->streamaddr);

  for(i = 0; (i < PH_STREAM_MAX_ATTRS) && sp->attrs[i]; i++)
    free((void *) sp->attrs[i]);
}


static void 
ph_copy_stream(struct ph_stream_params *dp, const struct ph_stream_params *sp)
{
  int i;

  *dp = *sp;
  if (dp->streamtype)
    dp->streamtype = strdup(dp->streamtype);
  if (dp->payloads)
    dp->payloads = strdup(dp->payloads);
  if (dp->streamaddr)
    dp->streamaddr = strdup(dp->streamaddr);

  for(i = 0; (i < PH_STREAM_MAX_ATTRS) && dp->attrs[i]; i++)
    dp->attrs[i] = strdup(dp->attrs[i]);

}

static void 
ph_deep_copy_streams(struct ph_stream_params **dp, struct ph_stream_params **sp)
{
  int i;

  for( i = 0; i < PH_MAX_STREAMS && sp[i]; i++)
    {
    dp[i] = malloc(sizeof(*sp[i]));
    ph_copy_stream(dp[i], sp[i]);
    }

  if (i < PH_MAX_STREAMS)
    dp[i] = 0;
}


static void 
ph_free_all_streams(struct ph_stream_params *sp[])
{
  int i;

  for( i = 0; i < PH_MAX_STREAMS && sp[i]; i++)
    {
    ph_free_stream(sp[i]);
    }
}

int ph_call_hasaudio(phcall_t *ca)
{
  if (ca->mses && (ca->mses->activestreams & (1 << PH_MSTREAM_AUDIO1)))
    return 1;

  return 0;
}

static struct ph_stream_params *
ph_find_stream(struct ph_stream_params  **streams, const char *strtype, int maxstrs);

void ph_release_call(phcall_t *ca)
{

  DBG4_SIP_NEGO("SIP_NEGO: ph_release_call\n", 0, 0, 0);

  if (ph_call_hasaudio(ca))
    {
    ph_call_media_stop(ca);
    }

  if (ca->audiodev != phcfg.audio_dev)
    if (ca->audiodev)
      free(ca->audiodev);

  ph_free_all_streams(ca->streams);
  if (ca->sdpctx)
    sdp_context_free(ca->sdpctx);
  if (ca->remote_sdp)
    sdp_message_free(ca->remote_sdp);

  memset(ca, 0, sizeof(phcall_t));
  ca->cid = -1;
}

int ph_has_active_calls()
{
  phcall_t *ca;
  int count = 0;

  for(ca = ph_calls; ca < &ph_calls[PH_MAX_CALLS];  ca++)
    {
    if (ca->cid != -1 && ph_call_hasaudio(ca))
      {
      if (!ca->remotehold && !ca->localhold)
        count++;
      }
    }

  return count;
}

void ph_stream_ended(void *ctx, int event)
{
  phcall_t *ca = (phcall_t *)ctx;

  ca->closereq = 1;
}

void ph_wegot_dtmf(void *ctx, int dtmfEvent)
{
  phCallStateInfo_t info;
  phcall_t *ca = (phcall_t *)ctx;

  clear(info);

  info.event = phDTMF;
  info.u.dtmfDigit = dtmfEvent;
  info.vlid = ca->vlid;
  phcb->callProgress(ca->cid, &info);

}

void ph_frame_display_cbk(void *ctx, void *event)
{
  phcall_t *ca = (phcall_t *) ctx;

  phcb->onFrameReady(ca->cid, event);
}

int ph_same_str(const char *str1, const char *str2)
{
  if (str1 == 0)
    return str2 == 0;

  if (str2 == 0)
    return str1 == 0;

  return (0 == strcasecmp(str1, str2));
}

int ph_same_uri(const char *uristr1, const char *uristr2)
{
  osip_contact_t *uri1, *uri2;
  int ret;

  osip_contact_init(&uri1);
  osip_contact_init(&uri2);

  osip_contact_parse(uri1, uristr1);
  osip_contact_parse(uri2, uristr2);

  /* if we've got and invalid URI return TRUE */
  if (!uri1 || !uri2 || !uri1->url || !uri2->url)
    ret = 1;
  else
    ret = ph_same_str(uri1->url->username, uri2->url->username) &&
    ph_same_str(uri1->url->host, uri2->url->host) &&
    ph_same_str(uri1->url->port, uri2->url->port);

  osip_contact_free(uri1);
  osip_contact_free(uri2);

  return ret;
}



static int 
ph_req_set_body(osip_message_t *msg, const char *body, const char *mime)
{
  char clen[10];

  snprintf(clen, 10, "%li", strlen(body));
  if (mime)
    osip_message_set_content_type(msg, mime);
  osip_message_set_body(msg, body, strlen(body));
  osip_message_set_content_length(msg, clen);

  return 0;
}

int ph_call_support_payload(phcall_t *ca, sdp_payload_t *payload)
{
  RtpProfile *prof = &av_profile;
  PayloadType *ptype;

  if (payload->a_rtpmap)
    ptype = rtp_profile_get_payload_from_rtpmap(prof, payload->a_rtpmap);
  else
    {
    if (0 <= payload->pt && payload->pt < RTP_PROFILE_MAX_PAYLOADS)
      ptype = prof->payload[payload->pt];
    }
  return ptype != 0;
}

int ph_accept_audio_offer(sdp_context_t *ctx, sdp_payload_t *payload)
{
  phcall_t *ca =(phcall_t*)sdp_context_get_user_pointer(ctx);
  char local_voice_port[16];
  struct ph_stream_params *si;

  if (!_is_audio_enabled(ca->user_mflags))
    {
    ph_printf("Refusing audio codec %i (%s)",payload->pt,payload->a_rtpmap);
    return -1;
    }

  if (!ph_call_support_payload(ca, payload))
    {
    ph_printf("Refusing audio codec %i (%s)",payload->pt,payload->a_rtpmap);
    return -1;
    }

  ca->remote_sdp_audio_port = payload->remoteport;
  strncpy(ca->remote_sdp_audio_ip, payload->c_addr, sizeof(ca->remote_sdp_audio_ip));

  {
    si  = ph_find_stream(ca->streams, "audio", 16);
    if (!si->streamaddr && si->streamport == -1)
      {
      _get_local_audio_sdp_port(local_voice_port);
      si->streamport = atoi(local_voice_port);
      }
    else
      {
      sprintf(local_voice_port, "%d", si->streamport);
      }
  }


  payload->localport = si->streamport;

  return 0;
}

int ph_accept_video_offer(sdp_context_t *ctx, sdp_payload_t *payload)
{
  return -1;
}

int ph_set_audio_offer(sdp_context_t *ctx)
{
  phcall_t *ca =(phcall_t*)sdp_context_get_user_pointer(ctx);
  ph_config_t *cfg=ca->cfg;

  sdp_payload_t payload;
  RtpProfile *profile = &av_profile;

  char *clist = strdup(cfg->audio_codecs);
  char *pname = strtok(clist, ",");
  while(pname) {
    sdp_payload_init(&payload);
    payload.a_rtpmap=pname;
    payload.pt=rtp_profile_get_payload_number_from_rtpmap(profile,pname);
    payload.localport=ca->local_sdp_audio_port;

    if (strncasecmp(pname,"iLBC",4)==0) {
      /* prefer the 30 ms mode */
      payload.a_fmtp="ptime=30";
    }
    sdp_context_add_audio_payload(ctx,&payload);
    pname = strtok(0, ",");
  }

  free(clist);
  /* add telephone-event payload*/
  sdp_payload_init(&payload);
  payload.pt=rtp_profile_get_payload_number_from_mime(profile,"telephone-event");
  payload.a_rtpmap="telephone-event/8000";
  payload.a_fmtp="0-11";

  sdp_context_add_audio_payload(ctx,&payload);
  return 0;
}

int ph_set_video_offer(sdp_context_t *ctx)
{
  return -1;
}


int ph_read_audio_answer(sdp_context_t *ctx, sdp_payload_t *payload)
{
  phcall_t *ca =(phcall_t*)sdp_context_get_user_pointer(ctx);

  if (!ph_call_support_payload(ca, payload))
    return -1;

  if (!ca->remote_sdp_audio_port) {
    strncpy(ca->remote_sdp_audio_ip, payload->c_addr, sizeof(ca->remote_sdp_audio_ip));
    ca->remote_sdp_audio_port = payload->remoteport;
  }
  return 0;
}

int ph_read_video_answer(sdp_context_t *ctx, sdp_payload_t *payload)
{
  return -1;
}


sdp_handler_t ph_sdp_handler={
    ph_accept_audio_offer,   /*from remote sdp */
    ph_accept_video_offer,   /*from remote sdp */
    ph_set_audio_offer, /*to local sdp */
    ph_set_video_offer, /*to local sdp */
    ph_read_audio_answer,       /*from incoming answer  */
    ph_read_video_answer        /*from incoming answer  */
};

int
phGetVersion()
{
  static char version[] = PHAPI_VERSION_STRING;
  char *subv = strstr(version, ".");
  int v,s,r;

  v = atoi(version);
  s = atoi(subv+1);
  r = atoi(strstr(subv+1, ".")+1);

  return (v << 16) | (s << 8) | r;
}
#undef stringize


PHAPI_EXPORT int
phGetAudioVersion()
{
  int fd, ret=-1;
#if !defined(WIN32) && !defined(__APPLE__) && !defined(__FreeBSD__)
#ifndef EMBED
  fd = open("/dev/dsp", O_RDWR, O_NONBLOCK);
#else
  fd = open("/dev/sound/mixer0", O_RDWR, O_NONBLOCK);
#endif
  if (fd>=0)
    {
#if defined(EMBED)
    if(0>ioctl(fd, SOUND_MIXER_PRIVATE5, &ret))
#else
      if(0>ioctl(fd, OSS_GETVERSION, &ret))
#endif
        ret = -1;
    close(fd);
    }
  return ret;
#else
  return 0;
#endif
} 

PHAPI_EXPORT int
phGetNatInfo(char *ntstr, int ntlen, char *fwip, int fwiplen)
{
  assert(ntstr);
  assert(fwip);

  strncpy(ntstr, ph_nat_type_str, ntlen);
  strncpy(fwip, ph_nat_router_addr, fwiplen);
  return 0;
}




PHAPI_EXPORT int
phSetUaString(const char *uastr)
{
  eXosip_set_user_agent(uastr);
  return 0;
}


PHAPI_EXPORT int
phAddCustomHeader(const char *reqnames, const char *hdrname,  const char *hdrval)
{
  eXosip_lock();
#ifdef OLDOSIP
  ret = eXosip_add_customization(reqnames, hdrname, hdrval);
#endif
  eXosip_unlock();
  return 0;
}

#define FROM_DISPLAYNAME 1
#define FROM_PORT 2
#define FROM_FORCEPORT 4

static void
ph_build_from2(char *buf, int n, struct vline *vl, int flags)
{
  char *un, *s;
  char port[32]={0};

  assert(buf);
  assert(vl);

  un = nonempty(vl->username) ? vl->username : "unknown";
  s = nonempty(vl->server) ? vl->server : "localhost";
  if ((flags & FROM_PORT) && vl->port && ((flags & FROM_FORCEPORT) && (vl->port != 5060)))
    snprintf(port, sizeof(port), ":%d", vl->port);


  if ((flags & FROM_DISPLAYNAME) && nonempty(vl->displayname))
    {
    if (!strchr(vl->displayname, ' '))
      {
      snprintf(buf, n, "%s <sip:%s@%s%s>", vl->displayname, un, s, port);
      }
    else
      {
      snprintf(buf, n, "\"%s\" <sip:%s@%s%s>", vl->displayname, un, s, port);
      }

    }
  else
    {
    snprintf(buf, n, "<sip:%s@%s%s>", un, s, port);
    }
}


static void
ph_build_from(char *buf, int n, struct vline *vl)
{
  ph_build_from2(buf, n, vl, FROM_DISPLAYNAME);
}


static void
ph_build_cname(char *buf, int n, struct vline *vl)
{
  char *un, *s;
  assert(buf);
  assert(vl);

  un = nonempty(vl->username) ? vl->username : "unknown";
  s = nonempty(vl->server) ? vl->server : "localhost";

  snprintf(buf, n, "%s@%s", un, s);

}

//

static int 
ph_retrieve_from(int did, char **from)
{
  osip_dialog_t *dlg = eXosip_call_get_osip_dialog(did);

  if (did)
    return -1;

  return osip_from_to_str(dlg->remote_uri, from);

}

#define optional(x) (x[0] ? x : 0)

int
phLinePlaceCall_withCa(int vlid, const char *uri, void *userdata, int rcid, int streams, phcall_t *ca0, const char *adev, const char *audio_addr, const char *video_addr)
{
  int i;
  osip_message_t *invite;
  phcall_t *ca = 0;
  char *proxy = 0;
  struct vline *vl;
  char from[512];
  char  local_voice_port[16];
  char  local_video_port[16];
#ifdef STUN_ENABLE
  char  public_voice_port[16];
  char  public_video_port[16];

  public_video_port[0] = 0;
  public_voice_port[0] = 0;
#endif

  DBG4_SIP_NEGO("phLinePlaceCall_withCa: a new call has been placed\n",0,0,0);


  local_video_port[0] = 0;
  local_voice_port[0] = 0;


  if (!nonempty(uri))
    return -PH_BADARG;

  vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  if (rcid)
    {
    ca = ph_locate_call_by_cid(rcid);
    if (!ca)
      return -PH_BADCID;
    }

  eXosip_lock();
  if (!ca0)
    ca0 = ph_allocate_call(-2);
  else
    ca0->cid = -2;

  eXosip_unlock();

  if (!ca0)
    return -PH_NORESOURCES;

  if (adev)
    ca0->audiodev = strdup(adev);
  else if (phcfg.audio_dev) {
    ca0->audiodev = strdup(phcfg.audio_dev);
  }

  ca0->user_mflags = streams;
  ca0->nego_mflags = streams;

  if (rcid)
    ca0->rcid = rcid;

  ca0->vlid = ph_vline2vlid(vl);

  ph_build_from(from, sizeof(from), vl);

  proxy = vl->proxy;

  eXosip_lock();
  i = eXosip_call_build_initial_invite(&invite,
      uri,
      from,
      proxy,
      "");
  eXosip_unlock();
  if (i!=0)
    return -1;

  if (_is_video_enabled(streams))
    _get_local_video_sdp_port(local_video_port);

  if (_is_audio_enabled(streams))
    _get_local_audio_sdp_port(local_voice_port);

  ca0->local_sdp_audio_port = atoi(local_voice_port);
  if (_is_video_enabled(streams))
    ca0->local_sdp_video_port = atoi(local_video_port);

  if (streams == PH_STREAM_DATA)
    {
    osip_message_set_header(invite, "Accept-Contact", "*;g.oma.sip-im");
    eXosip_lock();
    i = eXosip_call_send_initial_invite(invite); //  userdata, NULL, 0,  0,  0, 0, 0, 0);
    }
  else
    {
#ifdef STUN_ENABLE

    if (0!=strncasecmp(ph_get_nattype(), "none", 4) && (0!=strncasecmp(ph_get_nattype(), "sym", 3) ))
      {

      int ret = 0;

      ret = getPublicPort(local_voice_port, local_video_port, public_voice_port, public_video_port );


      if (ret <1)
        {
        DBG4_SIP_NEGO("unable to alocate public port ...",0,0,0);
        return;
        }

      if (!ca0->sdpctx) {
        ca0->sdpctx = sdp_handler_create_context(&ph_sdp_handler, audio_addr, uri, proxy);
        ca0->cfg =  &phcfg;
        sdp_context_set_user-pointer(ca0->sdpctx, ca0);
      }
      sdp_context_build_offer(ca0->sdpctx);
      ph_req_set_body(invite, ca0->sdpctx->offerstr, "application/sdp")

      eXosip_lock();
      i = eXosip_call_send_initial_invite(invite);  // FIXME: build SDP

      //          i = eXosip_initiate_call(invite, userdata, NULL,  local_voice_port,  optional(local_video_port), optional(public_voice_port),
      //                                   optional(public_video_port), audio_addr, video_addr);
      }
    else
      {
#endif
      if (!ca0->sdpctx) {
        ca0->sdpctx = sdp_handler_create_context(&ph_sdp_handler, audio_addr, uri, proxy);
        ca0->cfg =  &phcfg;
        sdp_context_set_user_pointer(ca0->sdpctx, ca0);
      }
      sdp_context_build_offer(ca0->sdpctx);
      ph_req_set_body(invite, ca0->sdpctx->offerstr, "application/sdp");

      eXosip_lock();
      i = eXosip_call_send_initial_invite(invite);  // FIXME:  build sdp
      //          i = eXosip_initiate_call(invite, userdata, NULL, local_voice_port, optional(local_video_port), 0, 0, 0, 0);

#ifdef STUN_ENABLE
      }
#endif
    }


  eXosip_call_set_reference(i, userdata);
  ca0->cid = i;

  eXosip_unlock();
  return i;

}

PHAPI_EXPORT int
phLinePlaceCall2(int vlid, const char *uri, void *userdata, int rcid, int streams)
{
  return phLinePlaceCall_withCa(vlid, uri, userdata, rcid, streams, 0, 0, 0, 0);
}


PHAPI_EXPORT int
phLinePlaceCall3(int vlid, const char *uri, void *userdata, int rcid, int streams, const char *adev)
{
  return phLinePlaceCall_withCa(vlid, uri, userdata, rcid, streams, 0, adev, 0, 0);
}

PHAPI_EXPORT int
phLinePlaceCall4(int vlid, const char *uri, void *userdata, int rcid, int streams, const char *adev, const char *audio_addr, const char *video_addr)
{
  return phLinePlaceCall_withCa(vlid, uri, userdata, rcid, streams, 0, adev, audio_addr, video_addr);
}

PHAPI_EXPORT int
phLinePlaceMcCall(int vlid, const char *uri, void *userdata, int streams, const char *adev)
{
  if (!streams)
    streams = PH_STREAM_AUDIO;

  return phLinePlaceCall_withCa(vlid, uri, userdata, 0,
      streams|PH_STREAM_MCRECV, 0, adev, 0, 0);
}

PHAPI_EXPORT int
phLinePlaceCall(int vlid, const char *uri, void *userdata, int rcid)
{
  return phLinePlaceCall_withCa(vlid, uri, userdata, rcid, PH_STREAM_AUDIO, 0, 0, 0, 0);
}

PHAPI_EXPORT int
phLineSendMessage(int vlid, const char *uri, const char *buff, const char *mime)
{
  return phLineSendMessage2(vlid, uri, uri, buff, mime, 0);
}





PHAPI_EXPORT int
phLineSendMessage2(int vlid, const char *target, const char *uri,
    const char *buff, const char *mime, const char *sipcid)
{
  int i;
  struct vline *vl;
  char from[512];
  osip_message_t *msg;


  vl = ph_valid_vlid(vlid);
  if (!vl) {
    return -PH_BADVLID;
  }

  if ( !nonempty(uri)) {
    return -PH_BADARG;
  }

  ph_build_from(from, sizeof(from), vl);



  eXosip_lock();
  i = eXosip_message_build_request(&msg, "MESSAGE", (char *)uri,
      from, vl->proxy);


  ph_req_set_body(msg, buff, mime);
  osip_message_set_contact(msg, vl->contact);

  if (sipcid)
    osip_message_set_call_id(msg, sipcid);

  i = eXosip_message_send_request(msg);

  eXosip_unlock();
  return i;
}

PHAPI_EXPORT int
phCallSendMessage(int cid, const char *buff, const char *mime)
{
  int i;
  phcall_t *ca = ph_locate_call_by_cid(cid);
  osip_message_t *msg;

  if (!ca)
    return -PH_BADCID;


  eXosip_lock();

  i = eXosip_call_build_request(ca->did, "MESSAGE", &msg);
  ph_req_set_body(msg, buff, mime);
  osip_message_set_contact(msg, ph_get_call_contact(ca));
  i = eXosip_call_send_request(ca->did, msg);

  eXosip_unlock();
  return i;
}




PHAPI_EXPORT int
phSendMessage(const char *from, const char *uri,
    const char *buff, const char *mime)
{
  int i;
  osip_message_t *msg;

  if (!nonempty(from) || !nonempty(uri))
    return -PH_BADARG;

  eXosip_lock();
  i = eXosip_message_build_request(&msg, "MESSAGE", uri, from, ph_get_proxy(from));
  ph_req_set_body(msg, buff, mime);
  i = eXosip_message_send_request(msg);
  eXosip_unlock();
  return i;
}


PHAPI_EXPORT int
phLineSubscribe(int vlid, const char *uri, const int winfo)
{
  int i;
  struct vline *vl;
  char from[512];
  osip_message_t *msg;

  vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  ph_build_from(from, sizeof(from), vl);


  if ( !nonempty(uri))
    return -PH_BADARG;


  eXosip_lock();
  i = eXosip_subscribe_build_initial_request(&msg, uri, from, vl->proxy, ph_get_event_type_str(winfo), 600);
  if (!i)
    i = eXosip_subscribe_send_initial_request(msg);

  eXosip_unlock();
  return i;
}


PHAPI_EXPORT int
phLineUnsubscribe(int vlid, const char *uri, const int winfo)
{
  int i = -PH_BADVLID;
#ifdef OLDOSIP
  int  sid;
  struct vline *vl;
  char from[512];

  vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  ph_build_from(from, sizeof(from), vl);


  if ( !nonempty(uri))
    return -PH_BADARG;


  eXosip_lock();
  i = eXosip_get_subscribe_id2(uri, winfo, &sid);
  if(i == 0)
    i = eXosip_subscribe_close(sid);
  eXosip_unlock();
#endif
  return i;

}



PHAPI_EXPORT int
phSubscribe(const char *from, const char *to, const int winfo)
{
  int i;
  osip_message_t *msg;

  if (!nonempty(to) || !nonempty(from))
    return -PH_BADARG;

  eXosip_lock();
  i = eXosip_subscribe_build_initial_request(&msg, to, from, ph_get_proxy(from), ph_get_event_type_str(winfo), 600);
  if (!i)
    i = eXosip_subscribe_send_initial_request(msg);

  eXosip_unlock();
  return i;
}



PHAPI_EXPORT int
phLinePublish(int vlid, const char *uri, int winfo, const char * content_type, const char * content)
{
  return phLinePublish2(vlid, uri, winfo ? "presence.winfo" : "presence", content_type, content, 600);
}



PHAPI_EXPORT int
phLinePublish2(int vlid, const char *uri, const char *evt, const char *ctt, const char *body, int expires)
{
  int i;
  struct vline *vl;
  char from[512];
  char expstr[16];
  osip_message_t *publish;


  if ( !nonempty(uri))
    return -PH_BADARG;

  vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  ph_build_from(from, sizeof(from), vl);

  snprintf(expstr, sizeof(expstr), "%d", expires);

  eXosip_lock();
  i = eXosip_build_publish(&publish,  uri, from,  vl->proxy, evt, expstr, ctt, body);
  if (!i)
    i = eXosip_publish(publish, uri);

  eXosip_unlock();


  if (i)
    return -PH_ERROR;

  return i;
}




static const char  *ph_get_expires_str()
{
  // FIXME:
  return "1200";
} 

PHAPI_EXPORT int
phPublish(const char *from, const char *to, const int winfo, const char * content_type, const char * content)
{
  int i;
  osip_message_t *msg;


  if (!nonempty(to) || !nonempty(from) || !nonempty(content_type) || !nonempty(content))
    return -PH_BADARG;


  eXosip_lock();
  i = eXosip_build_publish(&msg, to, from, ph_get_proxy(from), ph_get_event_type_str(winfo), ph_get_expires_str(), content_type, content);
  if (!i)
    i = eXosip_publish(msg, to);

  eXosip_unlock();
  return i;
}

PHAPI_EXPORT void
phRefresh()
{
  if (!phIsInitialized)
    return;
  eXosip_lock();
  eXosip_update();
  eXosip_unlock();
}


PHAPI_EXPORT int
phLineSendOptions(int vlid, const char *to)
{
  int i;
  struct vline *vl;
  char from[512];
  osip_message_t *msg;

  vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  ph_build_from(from, sizeof(from), vl);


  if (!nonempty(to))
    return -PH_BADARG;


  eXosip_lock();
  i = eXosip_options_build_request(&msg, to, from, vl->proxy);
  if (!i)
    i = eXosip_options_send_request(msg);

  eXosip_unlock();

  if (i && (msg!=0))
    osip_message_free(msg);

  return i ? PH_ERROR : i;

}



PHAPI_EXPORT int
phSendOptions(const char *from, const char *uri)
{
  int i;
  osip_message_t *req = 0;

  if (!nonempty(from) || !nonempty(uri))
    return -PH_BADARG;

  eXosip_lock();
  i = eXosip_options_build_request(&req, (char *)uri, (char*) from, ph_get_proxy(from));
  if (!i)
    i = eXosip_options_send_request(req);
  eXosip_unlock();

  if (i && (req!=0))
    osip_message_free(req);


  return i ? PH_ERROR : i;
}


PHAPI_EXPORT int
phAcceptCall2(int cid, void *userData)
{
  return phAcceptCall3(cid, userData, PH_STREAM_AUDIO);
}

PHAPI_EXPORT int
phAcceptCall3(int cid, void *userData, int streams)
{
  return phAcceptCall4(cid, userData, streams, 0, 0);
}


static int 
ph_answer_call(int cid, int tid, int status, const char *laport, const char *ctct,
    const char *lvport, const char  *paport, const char *pvport,
    const char *audio_addr, const char *video_addr)
{
  int i;
  osip_message_t *msg = 0;
  struct vline *vl;
  phcall_t *ca = ph_locate_call_by_cid(cid);

  if (!ca)
    return -PH_BADCID;

  vl = ph_valid_vlid(ca->vlid);

  if (!vl)
    return -PH_BADVLID;

  i = eXosip_call_build_answer(tid, status, &msg);
  if (!i) {
    if (!ca->sdpctx) {
      printf("build sdp ctx\n");
      ca->sdpctx = sdp_handler_create_context(&ph_sdp_handler, audio_addr, ctct, vl->proxy);
      ca->cfg =  &phcfg;
      sdp_context_set_user_pointer(ca->sdpctx, ca);
    }
    sdp_context_build_answer(ca->sdpctx, ca->remote_sdp);

    ph_req_set_body(msg, ca->sdpctx->offerstr, "application/sdp");
    if (ctct)
      osip_message_set_contact(msg, ctct);

    i = eXosip_call_send_answer(tid, status, msg);
  }

  return i;
}


PHAPI_EXPORT int
phAcceptCall4(int cid, void *userData, int streams, const char *audio_addr, const char *video_addr)
{
  int i;
  phcall_t *ca = ph_locate_call_by_cid(cid);
  char  local_video_port[16] = "0";
  char  local_voice_port[16] = "0";
#ifdef STUN_ENABLE
  char  public_voice_port[16] = "0";
  char  public_video_port[16] = "0";
#endif
  phCallStateInfo_t info;
  char *remoteUri = 0;


  DBG4_SIP_NEGO("SIP NEGO: phAcceptCall4\n", 0, 0, 0);
  if (!ca) {
    return -PH_BADCID;
  }

  ca->user_mflags = streams; // trace of what the user decided
  ca->nego_mflags = ca->user_mflags; // current negociated media flags

  if (_is_video_enabled(streams))
    _get_local_video_sdp_port(local_video_port);


  if (_is_audio_enabled(streams))
    _get_local_audio_sdp_port(local_voice_port);


  if (streams == PH_STREAM_DATA)
    {
    eXosip_lock();
    i = ph_answer_call(ca->cid, ca->tid, 200, 0, 0, 0, 0, 0, 0, 0);
    }
  else
    {

#ifdef STUN_ENABLE
    DBG4_SIP_NEGO(" phAcceptCall4 nattype: %s \n", eXosip_get_nattype(), 0, 0);

    if (0!=strncasecmp(eXosip_get_nattype(), "none", 4) && (0!=strncasecmp(eXosip_get_nattype(), "sym", 3) ))
      {
      int ret = getPublicPort(local_voice_port, local_video_port, public_voice_port , public_video_port );
      if (ret <1)
        {
        DBG4_SIP_NEGO("unable to alocate public port ...",0,0,0);
        return;
        }

      eXosip_lock();
      i = ph_answer_call(ca->tid, 200, local_voice_port, ph_get_call_contact(ca), local_video_port , public_voice_port , public_video_port,
          audio_addr, video_addr);
      }
    else
      { // start ifdef'ed else clause
#endif


      eXosip_lock();
      i = ph_answer_call(ca->cid, ca->tid, 200, local_voice_port, ph_get_call_contact(ca), local_video_port, local_voice_port, local_video_port,
          audio_addr, video_addr);


#ifdef STUN_ENABLE
      } // end ifdef'ed else clause
#endif
    }

  if (i == 0 && streams != PH_STREAM_DATA)
    {
    i = ph_call_retrieve_payloads(ca, NULL, streams | PH_STREAM_CNG );

    ca->local_sdp_audio_port = atoi(local_voice_port);
    if (_is_video_enabled(streams))
      {
      ca->local_sdp_video_port = atoi(local_video_port);
      }

    }

  eXosip_unlock();

  if (!i && !(streams == PH_STREAM_DATA))
    i = ph_call_media_start(ca, NULL, streams, 0);

  if (i)
    return i;

  eXosip_lock();
  ph_retrieve_from(ca->did, &remoteUri);
  eXosip_unlock();

  clear(info);

  info.u.remoteUri = remoteUri;
  info.event = phCALLOK;
  phcb->callProgress(cid, &info);

  if (remoteUri)
    osip_free(remoteUri);

  return 0;
}

PHAPI_EXPORT int
phAcceptMcCall(int cid, const char *adev, const char *audioaddr, int port)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);
  char  local_voice_port[16] = "0";
  int streams = PH_STREAM_AUDIO;
  phCallStateInfo_t info;
  int i;
  char *remoteUri;

  if (!ca)
    return -PH_BADCID;

  snprintf(local_voice_port,16, "%d", port);
  eXosip_lock();

  i = ph_answer_call(ca->cid, ca->did, 200, local_voice_port, ph_get_call_contact(ca),
      NULL,NULL,NULL,
      audioaddr, NULL);



  if (i == 0)
    {
    char tmp[16];

    i = ph_call_retrieve_payloads(ca, NULL, streams);

    _get_local_audio_sdp_port(tmp);
    ca->local_sdp_audio_port = atoi(tmp);
    ca->remote_sdp_audio_port = port;
    strncpy(ca->remote_sdp_audio_ip, audioaddr, sizeof(ca->remote_sdp_audio_ip));

    }

  eXosip_unlock();

  if (adev)
    {
    if (ca->audiodev) free(ca->audiodev);
    ca->audiodev = strdup(adev);
    }

  ph_call_media_start(ca, NULL, streams|PH_STREAM_MCSEND, 0);

  eXosip_lock();
  ph_retrieve_from(ca->did, &remoteUri);
  eXosip_unlock();

  clear(info);

  info.u.remoteUri = remoteUri;
  info.event = phCALLOK;
  phcb->callProgress(cid, &info);

  if (remoteUri)
    osip_free(remoteUri);

  return 0;


}

PHAPI_EXPORT int
phAcceptMcCall2(int cid, int mcid)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);
  phcall_t *mca = ph_locate_call_by_cid(mcid);
  char  local_voice_port[16] = "0";
  int streams = PH_STREAM_AUDIO;
  phCallStateInfo_t info;
  int i;
  char *remoteUri;

  if (!ca || !mca)
    return -PH_BADCID;


  i = ph_call_retrieve_payloads(ca, NULL, streams);

  ca->local_sdp_audio_port = mca->local_sdp_audio_port;
  ca->remote_sdp_audio_port =  mca->remote_sdp_audio_port;
  strncpy(ca->remote_sdp_audio_ip, mca->remote_sdp_audio_ip, sizeof(ca->remote_sdp_audio_ip));
  if (mca->audiodev)
    ca->audiodev = strdup(mca->audiodev);


  ph_msession_use(mca->mses);
  ca->mses = mca->mses;

  ca->user_mflags = mca->user_mflags;
  ca->nego_mflags = mca->nego_mflags;

  snprintf(local_voice_port,16, "%d", ca->remote_sdp_audio_port);



  eXosip_lock();
  i = ph_answer_call(ca->cid, ca->did, 200, local_voice_port, ph_get_call_contact(ca),
      NULL,NULL,NULL,
      ca->remote_sdp_audio_ip, NULL);

  ph_retrieve_from(ca->did, &remoteUri);

  eXosip_unlock();



  clear(info);

  info.u.remoteUri = remoteUri;
  info.event = phCALLOK;
  phcb->callProgress(cid, &info);

  if (remoteUri)
    osip_free(remoteUri);

  return 0;
}


static void 
add_contact_param(struct vline *vl,  const char *param, const char *value)
{
  osip_contact_t *ctct;


  if (!vl->contact)
    return;

  osip_contact_init(&ctct);

  osip_contact_parse(ctct, vl->contact);
  osip_contact_param_add(ctct, osip_strdup(param), osip_strdup(value));

  osip_free(vl->contact);
  osip_contact_to_str(ctct, &vl->contact);
  osip_contact_free(ctct);
}


PHAPI_EXPORT int
phLineGetMobility(int vlid)
{
  struct vline *vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  return vl->mobility;

}


/*
  find and return a  stream of the given type in the 'streams'.
  if the stream is not found allocate a new one if there is space                       int j;
   in the table
  maxtsr specifices the size of the table
 */
static struct ph_stream_params *
ph_find_stream(struct ph_stream_params  **streams, const char *strtype, int maxstrs)
{

  struct ph_stream_params *si, **strs = streams;

  while(si = *strs++)
    {
    if (!strcmp(si->streamtype, strtype))
      return si;
    }

  if (!maxstrs)
    return 0;

  if (strs - streams < (maxstrs - 1))
    {
    si = calloc(sizeof(*si), 1);
    si->streamtype = strdup(strtype);
    si->streamport = -1;
    strs[-1] = si;
    strs[0] = 0;
    return si;
    }

  return 0;
}


static void 
ph_copy_streams_from_args(struct ph_stream_params **streams, va_list args)
{
  struct ph_stream_params *psi;
  int i = 0;

  while(0 != (psi = va_arg(args, struct ph_stream_params *))) {
    struct ph_stream_params *esi= calloc(sizeof(*psi), 1);
    if (!esi)
      return;
    streams[i] = esi;
    ph_copy_stream(esi, psi);
  }

  if (i < PH_MAX_STREAMS)
    streams[i] = 0;

}


static int
ph_accept_call(int cid, void *userData, int streams, struct ph_stream_params *params[])
{
#ifdef OLDOSIP
  int i;
  phcall_t *ca = ph_locate_call_by_cid(cid);
  char  local_video_port[16] = "0";
  char  local_voice_port[16] = "0";
#ifdef STUN_ENABLE
  char  public_voice_port[16] = "0";
  char  public_video_port[16] = "0";
#endif
  phCallStateInfo_t info;
  char *remoteUri = 0;

  ph_deep_copy_streams(ca->streams, params);



  DBG4_SIP_NEGO("SIP NEGO: phAcceptCall5\n", 0, 0, 0);
  if (!ca) {
    return -PH_BADCID;
  }

  ca->user_mflags = streams; // trace of what the user decided
  ca->nego_mflags = ca->user_mflags; // current negociated media flags

  if (_is_video_enabled(streams))
    {
    si = ph_find_stream(esi, "video", 16);
    if (!si->streamaddr && si->streamport == -1)
      {
      _get_local_video_sdp_port(local_video_port);

      si->streamport = atoi(local_video_port);
      }
    else
      {
      sprintf(local_video_port, "%d", si->streamport);
      }

    }

  if (_is_audio_enabled(streams))
    {
    si  = ph_find_stream(esi, "audio", 16);
    if (!si->streamaddr && si->streamport == -1)
      {
      _get_local_audio_sdp_port(local_voice_port);
      si->streamport = atoi(local_voice_port);
      }
    else
      {
      sprintf(local_voice_port, "%d", si->streamport);
      }
    }



  if (streams == PH_STREAM_DATA)
    {
    eXosip_lock();
    i = eXosip_answer_call_with_body(ca->did, 200, "", "");
    }
  else
    {
#ifdef STUN_ENABLE
    DBG4_SIP_NEGO(" phAcceptCall5 nattype: %s \n", eXosip_get_nattype(), 0, 0);

    if (0!=strncasecmp(eXosip_get_nattype(), "none", 4) && (0!=strncasecmp(eXosip_get_nattype(), "sym", 3) ))
      {

      int ret = getPublicPort(local_voice_port, local_video_port, public_voice_port , public_video_port );
      if (ret <1)
        {
        DBG4_SIP_NEGO("unable to alocate public port ...",0,0,0);
        ph_free_ex_streams(esi);

        return;
        }

      if (_is_video_enabled(streams))
        {
        si = ph_find_stream(esi, "video", 0);
        if (!si->streamaddr)
          si->streamport = atoi(public_video_port);
        }

      si  = ph_find_stream(esi, "audio", 0);
      if (!si->streamaddr)
        si->streamport = atoi(public_audio_port);

      }
#endif

    eXosip_lock();
    i = eXosip_answer_callv(ca->did, 200,  ph_get_call_contact(ca), esi);
    }

  if (i == 0 && streams != PH_STREAM_DATA)
    {
    i = ph_call_retrieve_payloads(ca, NULL, streams | PH_STREAM_CNG );

    ca->local_sdp_audio_port = atoi(local_voice_port);
    if (_is_video_enabled(streams)) {
      ca->local_sdp_video_port = atoi(local_video_port);
    }

    }

  eXosip_unlock();

  if (!i && streams != PH_STREAM_DATA)
    i = ph_call_media_start(ca, NULL, streams, 0);

  if (i)
    return i;



  eXosip_lock();
  ph_retrieve_from(ca->did, &remoteUri);
  eXosip_unlock();

  clear(info);

  info.u.remoteUri = remoteUri;
  info.event = phCALLOK;
  phcb->callProgress(cid, &info);

  if (remoteUri)
    osip_free(remoteUri);

  ph_free_ex_streams(esi);
#endif    
  return 0;
}


PHAPI_EXPORT int
phAcceptCall5(int cid, void *userData, int streams, ...)
{
  va_list args;
  struct ph_stream_params *params[PH_MAX_STREAMS];

  va_start(args, streams);

  ph_copy_streams_from_args(params, args);

  va_end(args);

  return ph_accept_call(cid, userData, streams, params);
}



static int
ph_answer_request(int cid, int tid, int reason, char *ctct)
{
  int i;

  eXosip_lock();
  i = ph_answer_call(cid, tid, reason, 0, ctct, 0, 0, 0, 0, 0);
  eXosip_unlock();

  return i;
}


PHAPI_EXPORT int
phRejectCall(int cid, int reason)
{
  int i;
  phcall_t *ca = ph_locate_call_by_cid(cid);
  phCallStateInfo_t info;

  if (!ca)
    return -PH_BADCID;

  i = ph_answer_request(ca->cid, ca->tid, reason, ph_get_call_contact(ca));

  ph_release_call(ca);

  clear(info);
  info.event = phCALLCLOSED;
  phcb->callProgress(cid, &info);


  return i;

}

PHAPI_EXPORT int
phRejectCall2(int cid, const char *uri,int reason)
{
  int i;
  phcall_t *ca = ph_locate_call_by_cid(cid);
  phCallStateInfo_t info;
  if(!reason)
    reason = 302;
  if (!ca)
    return -PH_BADCID;

  i = ph_answer_request(ca->cid, ca->tid, reason, uri);

  ph_release_call(ca);

  clear(info);
  info.event = phCALLCLOSED;
  phcb->callProgress(cid, &info);


  return i;

}


PHAPI_EXPORT int
phRingingCall(int cid)
{
  int i;
  phcall_t *ca = ph_locate_call_by_cid(cid);

  if (!ca)
    return -PH_BADCID;

  i = ph_answer_request(ca->cid, ca->tid, 180, ph_get_call_contact(ca));

  return i;

}



PHAPI_EXPORT int
phCloseCall(int cid)
{
  int i;
  phcall_t *ca;
  phCallStateInfo_t info;
  int did;

  DBG4_SIP_NEGO("phCloseCall %d\n", cid,0,0);

  eXosip_lock();
  ca = ph_locate_call_by_cid(cid);

  if (!ca)
    {
    eXosip_unlock();
    return -PH_BADCID;
    }


  clear(info);
  info.event = phCALLCLOSED;

  if (ca->isringing)
    {
    info.event = phCALLCLOSEDandSTOPRING;
    ca->isringing = 0;
    }


  info.vlid = ca->vlid;
  did = ca->did;


  i = eXosip_call_terminate(cid, did);

  ph_release_call(ca);

  eXosip_unlock();



  if (i)
    return i;

  info.userData = 0;

  info.u.errorCode = 0;
  phcb->callProgress(cid, &info);


  return i;

}



PHAPI_EXPORT int phCallStartMedia(int cid, int streamFlags)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);


  if (!ca)
    return -PH_BADCID;


  ca->user_mflags &= ~(PH_NOMEDIA_STREAMS|PH_STREAM_AUDIO|PH_STREAM_VIDEO_TX|PH_STREAM_VIDEO_RX);
  ca->user_mflags |= streamFlags;
  ca->nego_mflags = ca->user_mflags;

  return ph_call_media_start(ca, 0, 0, 0);

}

PHAPI_EXPORT int
phBlindTransferCall(int cid, const char *uri)
{
  int i;
  phcall_t *ca = ph_locate_call_by_cid(cid);
  osip_message_t* refer;

  if (!ca)
    return -PH_BADCID;

  if (!nonempty(uri))
    return -PH_BADARG;

  if (ph_find_matching_vline(uri, PHM_IGNORE_PORT))
    return -PH_REDIRLOOP;


  ca->localrefer = 1;
  phHoldCall(cid);

  eXosip_lock();
  i = eXosip_call_build_refer(ca->did, (char *)uri, &refer);
  if (!i)
    i = eXosip_call_send_request(ca->did, refer);
  eXosip_unlock();

  return i;

}


PHAPI_EXPORT int
phTransferCall(int cid, int tcid)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);
  phcall_t *txca = ph_locate_call_by_cid(tcid);
  char uri[512];
  osip_message_t *refer = 0;
  int i;

  if (!ca || !txca)
    return -PH_BADCID;


  eXosip_lock();
  i = eXosip_call_get_referto(tcid, uri, sizeof(uri));
  if (i) goto err;
  i = eXosip_call_build_refer(ca->did, uri, &refer);
  if (i) goto err;
  i = eXosip_call_send_request(ca->did, refer);
  if (i)  goto err;

  ca->localrefer = 1;
  ca->txcid = tcid;


  eXosip_unlock();


  return 0;

  err:
  eXosip_unlock();

  if (refer)
    osip_message_free(refer);

  if (i == OSIP_NOMEM)
    return -PH_NORESOURCES;

  return -PH_ERROR;

}


PHAPI_EXPORT  int
phSetContact(int vlid, const char *uri)
{
  return phSetContact2(vlid, uri, 1);
}

PHAPI_EXPORT  int
phSetContact2(int vlid, const char *uri, int translate)
{
  struct vline *vl;


  if (!vlid)
    {
    /* set contact for all VL */
    strncpy(vcontact, uri, sizeof(vcontact));
    return 0;
    }


  vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  if (vl->contact)
    osip_free(vl->contact);

#if OLDOSIP
  if (translate)
    {
    char contact[256];
    eXosip_guess_contact_uri(uri, contact, sizeof(contact), 1);
    vl->contact = osip_strdup(contact);
    }
  else
#endif
    vl->contact = osip_strdup(uri);
  return 0;

}



PHAPI_EXPORT int
phConf(int cid1, int cid2)
{
  phcall_t *ca1 = ph_locate_call_by_cid(cid1);
  phcall_t *ca2 = ph_locate_call_by_cid(cid2);

  if(!ca1 || !ca2)
    return -PH_BADCFID;

  if (0 > ph_msession_conf_start(ca1->mses, ca2->mses, ca1->audiodev))
    return -PH_NORESOURCES;
  else
    return 0;
}

PHAPI_EXPORT int
phStopConf(int cid1, int cid2)
{
  phcall_t *ca1 = ph_locate_call_by_cid(cid1);
  phcall_t *ca2 = ph_locate_call_by_cid(cid2);

  if(!ca1 || !ca2)
    return -PH_BADCFID;

  if( 0 > ph_msession_conf_stop(ca1->mses, ca2->mses))
    return -PH_NORESOURCES;
  else
    return 0;
}

#define CONF_MODE 1


PHAPI_EXPORT int
phResumeCall(int cid)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);
  int i;
  osip_message_t *msg;

  if (!ca)
    return -PH_BADCID;

  if (!ca->localhold)
    return -PH_HOLDERR;

#ifndef CONF_MODE
  if (ph_has_active_calls())
    return -PH_NORESOURCES;
#endif

  ca->localhold = 0;
  ca->localresume = 1;

  eXosip_lock();
  i = eXosip_call_build_request(ca->did, "INVITE", &msg);
  if (!i) {
#ifdef OLDOSIP
    char clen[10];
    int sdplen = strlen(sdpmesg);
    snprintf(clen,sizeof(clen),"%i",sdplen);

    osip_message_set_body(msg,sdpmesg,sdplen);
    osip_message_set_content_type(msg,"application/sdp");
    osip_message_set_content_length(sip,clen);
#endif
    i = eXosip_call_send_request(ca->did, msg);
  }

  eXosip_unlock();

  return i;
}


PHAPI_EXPORT int
phHoldCall(int cid)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);
  int i;

  DBG4_SIP_NEGO("SIP_NEGO: phHoldCall\n", 0, 0, 0);

  if (!ca)
    return -PH_BADCID;

  if (ca->localhold)
    return -PH_HOLDERR;

  ca->localhold = 1;
#ifdef OLDOSIP
  eXosip_lock();
  i = eXosip_on_hold_call(ca->did);
  eXosip_unlock();
#else
  osip_mutex_lock(ph_media_stop_mutex);
  // FIXME hold call
  i = 1;
  osip_mutex_unlock(ph_media_stop_mutex);
#endif

  if (!i && ph_call_hasaudio(ca))
    {
#ifndef MEDIA_SUSPEND
    ph_call_media_stop(ca);
#else
    ph_call_media_suspend(ca, 1);
#endif
    }
  return i;
}


PHAPI_EXPORT int
phSetFollowMe(const char *uri)
{
  if (!uri)
    ph_follow_me_addr[0] = 0;

  if (ph_find_matching_vline(uri, PHM_IGNORE_PORT))
    return -PH_REDIRLOOP;

  strncpy(ph_follow_me_addr, uri, sizeof(ph_follow_me_addr));
  return 0;


}




PHAPI_EXPORT int
phSetBusy(int busyFlag)
{
  ph_busyFlag = busyFlag;
  return 0;
}


PHAPI_EXPORT int
phLineSetFollowMe(int vlid, const char *uri)
{
  struct vline *vl = ph_valid_vlid(vlid);

  if (!vl)
    return -PH_BADVLID;

  if (ph_find_matching_vline(uri, PHM_IGNORE_PORT))
    return -PH_REDIRLOOP;

  if (vl->followme)
    osip_free(vl->followme);

  vl->followme = osip_strdup(uri);

  return 0;

}






PHAPI_EXPORT int
phLineSetBusy(int vlid, int busyFlag)
{
  struct vline *vl = ph_valid_vlid(vlid);


  if (!vl)
    return -PH_BADVLID;

  vl->busy = busyFlag;
  return 0;
}






PHAPI_EXPORT int
phAddAuthInfo(const char *username, const char *userid,
    const char *passwd, const char *ha1,
    const char *realm)
{
  int ret;

  if (!username)
    return -PH_BADARG;

  if (!userid)
    return -PH_BADARG;

  if (!passwd)
    return -PH_BADARG;


  eXosip_lock();

  ret = eXosip_add_authentication_info(username, userid, passwd, ha1, realm);

  eXosip_unlock();

  return ret;
}

PHAPI_EXPORT int
phvlRegister(int vlid)
{
  struct vline *vl = ph_vlid2vline(vlid);
  int ret = -1;
  char utmp[256];
  char stmp[256];
  char *server;
  osip_message_t *msg;

  assert(vl);
  assert(vl->username);
  assert(vl->server);

  snprintf(utmp, sizeof(utmp), "sip:%s@%s", vl->username, vl->server);

  server = stmp;
  if (vl->port && vl->port != 5060)
    {
    /*     snprintf(stmp, sizeof(stmp), "sip:%s@%s:%d", vl->username, vl->server, vl->port); */
    snprintf(stmp, sizeof(stmp), "sip:%s:%d", vl->server, vl->port);
    }
  else
    {
    /*     snprintf(stmp, sizeof(stmp), "sip:%s@%s:%d", vl->username, vl->server, vl->port); */
    snprintf(stmp, sizeof(stmp), "sip:%s", vl->server);
    }

  eXosip_lock();

  if (vl->rid > 0) {
    ret = eXosip_register_build_register(vl->rid, vl->regTimeout, &msg);
    if (ret)
      vl->rid = -2;
  }  else {

    vl->rid = eXosip_register_build_initial_register(utmp, vl->proxy, vl->contact, vl->regTimeout, &msg);

  }

  if (vl->rid >= 0)
    {
    ret = eXosip_register_send_register(vl->rid, msg);

    if (ret == 0)
      {
      ret = vl->rid;
      vl->lastRegTime = time(0);
      }
    }

  eXosip_unlock();

  return ret;

}

PHAPI_EXPORT int
phSendDtmf(int cid, int dtmfEvent, int mode)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);
  char buf[64];
  char *ctt;
  int i = -1;
  osip_message_t *msg;

  if (!ca)
    return -PH_BADCID;

  if (mode & (PH_DTMF_MODE_SIP|PH_DTMF_MODE_SIPRELAY))
    {
    if (mode & PH_DTMF_MODE_SIP)
      {
      ctt = "application/dtmf";
      snprintf(buf, sizeof(buf), "%c", dtmfEvent);
      }
    else
      {
      char sipEvent[3] = { 0, 0, 0 };
      ctt = "application/dtmf-relay";
      if (dtmfEvent == '!')
        {
        sipEvent[0] = '1';
        sipEvent[1] = '6';
        }
      else
        sipEvent[0] = dtmfEvent;

      snprintf(buf, sizeof(buf), "Signal=%s\r\nDuration=250\r\n", sipEvent);
      }

    eXosip_lock();

    i = eXosip_call_build_info(ca->did, &msg),
        ph_req_set_body(msg, buf, ctt);
    osip_message_set_contact(msg, ph_get_call_contact(ca));
    i = eXosip_call_send_request(ca->did, msg);

    eXosip_unlock();

    if (!(mode & PH_DTMF_MODE_ALLRTP)) /* do we need to send DTMF in RTP stream? */
      return i;

    }

  if (!ph_call_hasaudio(ca))
    {
    if (!i)
      return ;   /*  we've managed to send using SIP INFO request */

    return -PH_NOMEDIA;
    }

  return ph_msession_send_dtmf(ca->mses, dtmfEvent, mode);

}


PHAPI_EXPORT int
phPlaySoundFile(const char *fileName , int loop)
{
  return -1;
}

PHAPI_EXPORT int
phSendSoundFile(int cid, const char *fileName)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);

  if (!ca)
    return -PH_BADCID;

  if (!ph_call_hasaudio(ca))
    return -PH_NOMEDIA;

  return ph_msession_send_sound_file(ca->mses, fileName);
}

PHAPI_EXPORT int
phStopSoundFile()
{
  return -1;
}

PHAPI_EXPORT int
phSetSpeakerVolume(int cid,  int volume)
{
#if 0
  phcall_t *ca = ph_locate_call_by_cid(cid);

  if (!ca)
    return -PH_BADCID;

  return(ph_media_set_spkvol(ca, volume));
#else
  return 0;
#endif
}


PHAPI_EXPORT int
phSetRecLevel(int cid,  int level)
{
#if 0
  phcall_t *ca = ph_locate_call_by_cid(cid);

  if (!ca)
    return -PH_BADCID;

  return(ph_media_set_recvol(ca, level));
#else
  return 0;
#endif
}




PHAPI_EXPORT int
phAddVline(const char* username, const char *server, const char*  proxy,  int regTimeout)
{
  return phAddVline2(NULL, username, server, proxy,  regTimeout);
}

/*
  scrap the :port part from the host uri
 */
static char *
ph_scrap_port(char *buf, int bufsize, const char *host, int *port)
{

  assert(buf != 0);
  assert(port != 0);

  *port = 0;

  if (!host)
    return 0;

  if (!strchr(host, ':'))
    return host;

  strncpy(buf, host, bufsize);
  host = strchr(buf, ':');
  if (host)
    {
    *( char *) host = 0;
    *port = atoi(host+1);
    }

  return buf;

}

static const char emptystr[] = { 0 };
#define nonull(x) ((x) ? (x) : emptystr)

PHAPI_EXPORT int
phAddVline2(const char *displayname, const char* username, const char *server, const char*  proxy,  int regTimeout)
{
  return phAddVline3(displayname, username, server, proxy, regTimeout, 0);
}
PHAPI_EXPORT int
phAddVline3(const char *displayname, const char* username, const char *server, const char*  proxy,  int regTimeout, int mobility)

{
  struct vline *vl;
  int oldTimeout = 0;
  char srvbuf[256];
  char *srv2;
  int port;


  if (phDebugLevel)
    {
    DBG8_SIP_NEGO("AddVline2(dn = %s, un=%s, srv=%s pxy=%s regT=%d)\n", nonull(displayname), nonull(username), nonull(server), nonull(proxy), regTimeout,0,0);
    }

  srv2 = ph_scrap_port(srvbuf, sizeof(srvbuf), server, &port);

  if (!port)
    port = 5060;

  if (!username)
    username = "";


  vl  = ph_find_matching_vline3(username, srv2, port, 0);

  if (0 < regTimeout && regTimeout < 200)
    regTimeout = 200;



  if (!vl)
    {
    vl = vline_alloc();
    if (!vl)
      return -PH_NORESOURCES;

    vl->username = osip_strdup(username);
    }
  else
    {
    if (vl->proxy)
      {
      osip_free(vl->proxy);
      vl->proxy = 0;
      }

    if (vl->displayname)
      {
      osip_free(vl->displayname);
      vl->displayname = 0;
      }

    if (vl->contact)
      {
      osip_free(vl->contact);
      vl->contact = 0;
      }
    oldTimeout = vl->regTimeout;

    }

  vl->port = port;

  if (nonempty(proxy))
    {
    if (0 == strstr(proxy, "sip:"))
      {
      int l = 15 + strlen(proxy);
      vl->proxy = osip_malloc(l);
      snprintf(vl->proxy, l, "sip:%s", proxy);
      }
    else
      vl->proxy = osip_strdup(proxy);
    }



  if (nonempty(srv2) && !vl->server)
    vl->server = osip_strdup(srv2);

  if (nonempty(displayname))
    vl->displayname = osip_strdup(displayname);

  vl->regTimeout = regTimeout;


  if(vcontact[0])
    vl->contact = osip_strdup(vcontact);
  else
    {
#ifdef OLDOSIP
    char contact[512];
    char from[512];

    ph_build_from(from, sizeof(from), vl);
    eXosip_guess_contact_uri(from, contact, sizeof(contact), 1);
    vl->contact = osip_strdup(contact);
#endif

    }

  if (mobility == PH_LINE_MOBILITY_FIXED)
    add_contact_param(vl, "mobility", "fixed");
  else if (mobility == PH_LINE_MOBILITY_MOBILE)
    add_contact_param(vl, "mobility", "mobile");

  vl->mobility = mobility;

  if (nonempty(srv2) && (oldTimeout > 0 || regTimeout > 0))
    phvlRegister(ph_vline2vlid(vl));

  return ph_vline2vlid(vl);
}


PHAPI_EXPORT int
phDelVline(int vlid)
{
  struct vline *vl;
  phcall_t *ca;

  if (!(vl = ph_valid_vlid(vlid)))
    return -PH_BADVLID;


  /* forbid deletion of the lines which have pending calls */
  for(ca = ph_calls; ca < &ph_calls[PH_MAX_CALLS]; ca++)
    {
    if (ca->vlid == vlid && ca->cid > 0)
      return -PH_VLBUSY;
    }


  if (vl->pub.timeout)
    phLinePublish2(vlid, vl->pub.uri, 0, 0, 0, 0);

  /*
     if the line has an associatied timeout, 
     it means it is regsitered on some server,
     so we need to unregister 
   */
  if (vl->regTimeout)
    {
    osip_message_t *msg;

    eXosip_lock();
    eXosip_register_build_register(vl->rid, 0, &msg);
    eXosip_register_send_register(vl->rid, msg);
    vl->regTimeout = 0;
    vl->used = VL_DELETING;
    eXosip_unlock();

    }

  if (vl->used != VL_DELETING)
    return 0;

  return 0;
}



PHAPI_EXPORT int phChangeAudioDevices(const char *devstr)
{
  if (devstr)
    strncpy(phcfg.audio_dev, devstr, sizeof(phcfg.audio_dev));

  return 0;
}




static struct vline *
vline_alloc()
{
  int i;

  for(i = 0; i < PH_MAX_VLINES; i++)
    {
    struct vline *vl = ph_vlines + i;

    if (!vl->used)
      {
      memset(vl, 0, sizeof(*vl));
      vl->used = 1;
      vl->port = 0;
      return vl;
      }

    }
  return 0;
}

static void
vline_free(struct vline *vl)
{
  if (vl->used)
    {
    osip_free(vl->username);
    if (vl->server)
      osip_free(vl->server);
    if (vl->proxy)
      osip_free(vl->proxy);
    if (vl->displayname)
      osip_free(vl->displayname);
    if (vl->followme)
      osip_free(vl->followme);
    if (vl->contact)
      osip_free(vl->contact);
    if (vl->pub.etag)
      osip_free(vl->pub.etag);
    if (vl->pub.uri)
      osip_free(vl->pub.uri);
    if (vl->pub.evt)
      osip_free(vl->pub.evt);
    if (vl->pub.ctt)
      osip_free(vl->pub.ctt);
    if (vl->pub.body)
      osip_free(vl->pub.body);



    vl->used = 0;
    }
}




static struct vline *
ph_find_vline_by_rid(int rid)
{
  int i;

  for(i = 0; i < PH_MAX_VLINES; i++)
    {
    struct vline *vl = ph_vlines + i;

    if (vl->used && rid == vl->rid)
      return vl;
    }
  return 0;
}


static osip_from_t *
ph_parse_from(const char *userid)
{
  osip_from_t *from;

  osip_from_init(&from);
  if (!from)
    return 0;

  osip_from_parse(from, userid);
  if (from->url && from->url->port && !strcmp(from->url->port, "5060"))
    {
    osip_free(from->url->port);
    from->url->port = NULL;
    }

  return from;

}

static struct vline *
ph_find_matching_vline(const char *userid, int ignore)
{
  osip_from_t *from;
  struct vline *vl;
  char *host;
  char hostport[256];
  char *uname;

  hostport[0] = 0;
  from = ph_parse_from(userid);

  if (!from)
    return 0;

  if (from->url)
    uname = from->url->username;
  else
    uname = hostport;


  if (!(ignore & PHM_IGNORE_PORT) && from->url && from->url->port)
    {
    snprintf(hostport, sizeof(hostport), "%s:%s", from->url->host, from->url->port);
    host = hostport;
    }
  else if (ignore & PHM_IGNORE_HOST)
    host = 0;
  else if (from->url)
    {
    host = from->url->host;
    }
  else
    host = hostport;

  vl = ph_find_matching_vline2(uname, host, ignore);

  osip_from_free(from);

  return vl;

}


static struct vline *
ph_find_matching_vline2(const char *username, const char* host, int ignore)
{
  return ph_find_matching_vline3(username, host, 0, ignore);
}

static struct vline *
ph_find_matching_vline3(const char *username, const char* host, int port, int ignore)
{
  int i;
  int   hostlen;
  int   unamelen;
  struct vline *vl, *defaultvl = 0;

  if (!username)
    username = "";

  hostlen = host ? strlen(host) : 0;
  unamelen =  strlen(username);

  if (port == 0)
    port = 5060;

  for( i = 0; i < PH_MAX_VLINES; i++)
    {
    int len;
    vl = ph_vlines + i;

    if (!vl->used)
      continue;

    if (!vl->server)
      {
      defaultvl = vl;
      continue;
      }

    len = strlen(vl->server);

    if ((ignore & PHM_IGNORE_HOST) || ((len == hostlen) && !strcasecmp(host, vl->server)))
      {
      len = strlen(vl->username);

      if ((len == unamelen) && !strcasecmp(username, vl->username))
        {
        if (ignore & PHM_IGNORE_PORT)
          {
          defaultvl = vl;
          break;
          }
        if (port == vl->port)
          {
          defaultvl = vl;
          break;
          }
        }
      }
    }



  return defaultvl;
}



static void
ph_nat_refresh(struct vline *vl)
{
  char buf[128];
  char to[128];
  assert(vl);

  ph_build_from(buf, sizeof(buf), vl);
  snprintf(to, sizeof(to), "sip:ping@%s", vl->server);
  phSendOptions(buf, to);

#if 0
  int port;


  osip_uri_init(&uri);
  osip_uri_parse(uri,  (vl->proxy && vl->proxy[0]) ? vl->proxy : vl->server);

  port = atoi((uri->port && uri->port[0]) ? uri->port : "5060");
  phPing(uri->host, port, 30);

  osip_uri_free(uri);
#endif

}

static time_t last_vline_refresh, last_nat_refresh;
static void 
ph_refresh_vlines()
{
  time_t now = time(NULL);

  if (now - last_vline_refresh > 5)
    {
    int i;
    struct vline *vl;

    for( i = 0; i < PH_MAX_VLINES; i++)
      {
      vl = ph_vlines + i;
      if (!vl->used)
        continue;

      if (vl->server && vl->server[0] && vl->regTimeout > 0)
        {
        if ((now - vl->lastRegTime) > (vl->regTimeout - 10))
          phvlRegister(ph_vline2vlid(vl));
        }
      if (vl->pub.timeout && (now - vl->pub.last) > (vl->pub.timeout - ph_resend_offset))
        {
        phLinePublish2(ph_vline2vlid(vl), vl->pub.uri, 0, 0, 0, vl->pub.timeout);
        }
      }
    last_vline_refresh = time(0);
    }

  //if (!phcfg.use_tunnel && phcfg.nat_refresh_time > 0)
  if (phcfg.nat_refresh_time > 0)
    {
    int i;
    struct vline *vl;

    if (now - last_nat_refresh > phcfg.nat_refresh_time)
      {
      for( i = 0; i < PH_MAX_VLINES; i++)
        {
        vl = ph_vlines + i;
        if (!vl->used)
          continue;

        if (vl->server && vl->server[0] && vl->regTimeout > ph_resend_offset)
          {
          ph_nat_refresh(vl);
          }
        }

      last_nat_refresh = time(0);
      }
    }


}


/*
  scan call marked for close and close them while delivering phCALLCLOSED to phApi client
 */
static void
ph_scan_calls()
{
  int i;
  phcall_t *ca;

  ca = ph_calls;
  for(i = PH_MAX_CALLS; i; i--, ca++)
    {
    if (ca->cid > 0 && ca->closereq)
      {
      phCallStateInfo_t info;
      int cid = ca->cid;

      memset(&info, 0, sizeof(info));
      info.vlid = ca->vlid;
      info.event = phCALLCLOSED;

      ph_release_call(ca);



      phcb->callProgress(cid, &info);
      }
    }

}

static char *
ph_get_proxy(const char *userid)
{
  struct vline *vl = ph_find_matching_vline(userid, PHM_IGNORE_PORT);

  if (!vl)
    return "";

  return vl->proxy ? vl->proxy : "";
}


static char *
ph_get_call_contact(phcall_t *ca)
{
  struct vline *vl;
  assert(ca);

  vl = ph_vlid2vline(ca->vlid);
  if (!vl)
    return 0;

  return vl->contact;
}


static int
ph_get_vline_id(const char *userid, const char *altid)
{

  struct vline *vl = ph_find_matching_vline(userid, PHM_IGNORE_PORT);

  if (vl)
    return ph_vline2vlid(vl);

  if (nonempty(altid))
    {
    vl = ph_find_matching_vline(altid, PHM_IGNORE_PORT);
    if (vl)
      return ph_vline2vlid(vl);
    }

  vl = ph_find_matching_vline(userid, PHM_IGNORE_HOST|PHM_IGNORE_PORT);
  if (vl)
    return ph_vline2vlid(vl);


  if (nonempty(altid))
    {
    vl = ph_find_matching_vline(altid, PHM_IGNORE_HOST|PHM_IGNORE_PORT);
    if (vl)
      return ph_vline2vlid(vl);
    }

  return 0;

}

static void setup_payload(const char *ptstring)
{
  char  tmp[64];
  char  num[8];
  ph_media_payload_t  pt;
  int g722hack = 0;

  DBG_CODEC_LOOKUP("trying to setup codec in eXosip: %s\n", ptstring, 0, 0);
  if(!strncasecmp(ptstring, "G722", 4))
    {
    g722hack = 1;
    ptstring = "G722/16000";
    }

  if (ph_media_supported_payload(&pt, ptstring))
    {
    if (g722hack)
      pt.rate = 8000;


    DBG_CODEC_LOOKUP("...setup accepted : %d - %s/%d\n", pt.number, pt.string, pt.rate);
    snprintf(num, sizeof(num), "%d", pt.number);
    snprintf(tmp, sizeof(tmp), "%d %s/%d/1", pt.number, pt.string, pt.rate);

#ifdef OLDOSIP
    eXosip_sdp_negotiation_add_codec(
        osip_strdup(num),
        NULL,
        osip_strdup("RTP/AVP"),
        NULL, NULL, NULL,
        NULL,NULL,
        osip_strdup(tmp));
#else
    sdp_payload_list_add(pt.number, osip_strdup(tmp));
#endif
    return;
    }
  DBG_CODEC_LOOKUP("...setup refused - not found in ortp profile", 0, 0, 0);

}

static void setup_video_payload(const char *ptsring)
{
  char  tmp[64];
  char  num[8];
  ph_media_payload_t  pt;

  if (ph_media_supported_payload(&pt, ptsring))
    {
    snprintf(num, sizeof(num), "%d", pt.number);
    snprintf(tmp, sizeof(tmp), "%d %s/%d/1", pt.number, pt.string, pt.rate);

#ifdef OLDOSIP
    eXosip_sdp_negotiation_add_videocodec(osip_strdup(num),
        NULL,
        osip_strdup("RTP/AVP"),
        NULL, NULL, NULL,
        NULL,NULL,
        osip_strdup(tmp));
#else
    sdp_payload_list_add(pt.number, osip_strdup(tmp));
#endif
    }
  else
    {
    DBG("unsupported payload");
    }
}


/**
 * Initialize the phoneapi module
 */
#ifdef OLDOSIP
static eXosip_tunnel_t *phTunnel;
#endif

#ifdef OS_WIN32

static int
wsock_init()
{
  WORD wVersionRequested;
  WSADATA wsaData;
  int i;

  wVersionRequested = MAKEWORD(1,1);
  if(i = WSAStartup(wVersionRequested,  &wsaData))
    {
    return -1;
    }
  return 0;
}
#else
#define wsock_init() 0
#endif


static int
ph_debug_init()
{
  const char *dbgstr;

  dbgstr = getenv("PH_DEBUG_LEVEL");
  if (dbgstr)
    phDebugLevel = atoi(dbgstr);

  if (phDebugLevel > 0)
    {
    if (!phLogFileName)
      phLogFileName = getenv("PH_LOG_FILENAME");


    ph_log_file = phLogFileName ? fopen (phLogFileName, "w+") : stdout;


    if (!ph_log_file)
      {
      perror ("phapi: log file");
      return -1;
      }
    TRACE_INITIALIZE (phDebugLevel, ph_log_file);
    }

  return 0;

}


static void 
ph_avcodec_init()
{
#ifdef PHAPI_VIDEO_SUPPORT
  avcodec_init();
  avcodec_register_all();
  phcfg.video_config.video_line_configuration = PHAPI_VIDEO_LINE_128KBPS;
#endif

}


static void
ph_calls_init()
{
  int i;

  for( i = 0; i < PH_MAX_CALLS; i++)
    ph_calls[i].cid = -1;

}

static int
ph_tunnel_init()
{
#ifdef USE_HTTP_TUNNEL
  eXosip_tunnel_t *tunnel = NULL;
  int port;
  char *c;
  char buf[256];
  int tunerr;

  if (!(phcfg.use_tunnel & PH_TUNNEL_USE))
    return 0;

  http_tunnel_init_host(phcfg.httpt_server, phcfg.httpt_server_port, phcfg.use_tunnel & PH_TUNNEL_SSL);
  http_tunnel_init_proxy(phcfg.http_proxy,phcfg.http_proxy_port,
      phcfg.http_proxy_user, phcfg.http_proxy_passwd);

  tunnel = malloc(sizeof(eXosip_tunnel_t));
  if (tunnel)
    {
    strncpy(buf, phcfg.proxy, sizeof(buf));
    c = strstr(buf, ":");

    port = 5060;
    if (c)
      {
      *c++ = 0;
      port = atoi(c);
      }
    tunnel->h_tunnel = http_tunnel_open(buf, port, HTTP_TUNNEL_VAR_MODE, &tunerr, -1);
    if (!tunnel->h_tunnel)
      {
      if (!tunnel->h_tunnel)
        {
        free(tunnel);
        return -PH_NOTUNNEL;
        }
      }

    tunnel->tunnel_recv = http_tunnel_recv;
    tunnel->tunnel_send = http_tunnel_send;
    tunnel->get_tunnel_socket = http_tunnel_get_socket;
    phTunnel = tunnel;
    return 0;
    }




  return -PH_NORESOURCES;
#else
  return 0;
#endif
}

static void
ph_nat_init()
{
  char *ntstr = 0;

  ph_nat_router_addr[0] = 0;
  ph_nat_port_str[0] = 0;
  ph_nat_type_str[0] = 0;

  if (!phcfg.use_tunnel && phcfg.nattype[0])
    {
    if (!strncasecmp(phcfg.nattype, "auto", 4))
      {
      NatType ntype;
      bool_t resPort = 0, hairpin = 0;
      int needMappedAddress = 0;
      StunAddress4 stunServerAddr;

      ntstr = "sym";

      stunParseServerName(phcfg.stunserver, &stunServerAddr);
      ph_nat_type = ntype = stunNatType( &stunServerAddr, &resPort, &hairpin,
          0, 0);


      switch (ntype)
      {


      case StunTypeOpen:
        ntstr = 0;
        break;

      case StunTypeConeNat:
        ntstr = "fcone";
        needMappedAddress = 1;
        break;

      case StunTypeRestrictedNat:
        ntstr = "rcone";
        needMappedAddress = 1;
        break;

      case StunTypePortRestrictedNat:
        ntstr = "prcone";
        needMappedAddress = 1;
        break;

      case StunTypeSymFirewall:
      case StunTypeSymNat:
        needMappedAddress = 1;
        break;


      case StunTypeFailure:
      case StunTypeUnknown:
      case StunTypeBlocked:
      default:
        break;

      }

      if (needMappedAddress)
        {
        StunAddress4 mappedAddr;
        Socket  sock;

        sock = stunOpenSocket(&stunServerAddr, &mappedAddr, atoi(_get_local_sip_port()), 0);

        if (-1 !=  (int) sock)
          {
          ph_ipv4tostr(ph_nat_router_addr, mappedAddr);
          snprintf(ph_nat_sip_port_str, sizeof(ph_nat_sip_port_str), "%d", mappedAddr.port);
          closesocket(sock);
          }
        }
      }
    else if (!strncasecmp(phcfg.nattype, "fcone", 5) ||
        !strncasecmp(phcfg.nattype, "rcone", 5) ||
        !strncasecmp(phcfg.nattype, "prcone", 6) ||
        !strncasecmp(phcfg.nattype, "sym", 3))

      ntstr = phcfg.nattype;
    }
  else if (phcfg.use_tunnel)
    {
    ntstr = "open";
    }

  if (ntstr)
    {
    // FIXME: eXosip_set_nattype(ntstr);
    if (!phcfg.nat_refresh_time)
      phcfg.nat_refresh_time = 15;

    strncpy(ph_nat_type_str, ntstr, sizeof(ph_nat_type_str));
    if (ph_nat_router_addr[0] && strcmp(ntstr, "sym"))
      {
      //eXosip_set_mediaip(ph_nat_router_addr);
      eXosip_masquerade_contact(ph_nat_router_addr, atoi(ph_nat_sip_port_str));

      }

    }
  else
    {
    phcfg.nat_refresh_time = 0;
    strcpy(ph_nat_type_str, "open");
    }

}

/**
 * @brief initialize the payload/codecs that are allowed to be handled by the SIP stack
 */
PHAPI_EXPORT void
ph_payloads_init()
{
  // init payload/codecs for VIDEO
  sdp_payload_list_init();
#ifdef PHAPI_VIDEO_SUPPORT
  setup_video_payload("H263/90000");

#if 0
  if (!phcfg.video_codecs[0]) {
    setup_video_payload("H263/90000");
    setup_video_payload("H264/90000");
  } else {
    char tmp[32];
    char *tok = strtok(phcfg.video_codecs, ",");

    while(tok) {
      snprintf(tmp, sizeof(tmp), "%s/90000", tok);
      setup_video_payload(tmp);
      DBG2("phapi: added video codec: %s\n",tmp);
      tok = strtok(0, ",");
    }
  }
#endif
#endif

  // init payload/codecs for AUDIO

  // add codecs out of an ENV var
  {
    char *aclist = getenv("PH_AUDIO_CODECS");
    if (aclist) {
      strncpy(phcfg.audio_codecs, aclist, sizeof(phcfg.audio_codecs));
    }

  }


  // limit codecs to G711 codecs according to compile time DEFINE
#ifdef G711_ONLY
  strcpy(phcfg.audio_codecs, "PCMU/8000,PCMA/8000");
#endif

  // if at this stage, no codecs are required, fix a default list
  if (!phcfg.audio_codecs[0])
    {
    setup_payload("PCMU/8000");
    setup_payload("PCMA/8000");
    setup_payload("GSM/8000");
    setup_payload("ILBC/8000");
    setup_payload("SPEEX/16000");
    setup_payload("SPEEX/8000");
    setup_payload("AMR/8000");
    setup_payload("AMR-WB/16000");
    setup_payload("G722/8000");
    setup_payload("G726-32/8000");

    }
  // phapi.h client has required a specific list of codecs
  else
    {

    /*
        The list is "," separated
        some hacks are present to allow for :
        - payload usurpation
        - default /8000 clockrate when not specified
        - ... look at the code
     */


    char tmp[32];
    char *tok = strtok(phcfg.audio_codecs, ",");

    while(tok)
      {
      if(!strcasecmp(tok, "G722/8000"))
        strcpy(tmp, "G722/16000");
      else if(!strcmp(tok, "AMR-WB"))
        {
#ifdef AMR_OVER_G729_HACK
        snprintf(tmp, sizeof(tmp), "G729/8000");
#else
        snprintf(tmp, sizeof(tmp), "%s/16000", tok);
#endif
        }
#ifdef SPEEX_OVER_G729_HACK
      else if(!strcmp(tok, "SPEEX/16000"))
        {
        snprintf(tmp, sizeof(tmp), "G729/8000");
        }
#endif
      else if (strchr(tok, '/'))
        strncpy(tmp, tok, sizeof(tmp));
      else
        snprintf(tmp, sizeof(tmp), "%s/8000", tok);

      if (ph_media_can_handle_payload(tmp))
        {
        setup_payload(tmp);
        }

      tok = strtok(0, ",");
      }
    }

  // set codec in sip stack for CNG (confort noise generator=
  if(phcfg.cng)
    setup_payload("CN/8000");

  // set codec in sip stack for DTMF
  setup_payload("telephone-event/8000");
}

static int 
ph_get_call_id(int did, char **cid)
{
  char referto[512];
  char *cp, *semi;
  int i;

  i = eXosip_call_get_referto(did, referto, sizeof(referto));
  if (i)
    return -PH_ERROR;
  cp = strstr(referto, "Replaces");
  if (!cp)
    return -PH_ERROR;
  cp += 9;
  semi = strchr(cp, ';');
  if (semi)
    *semi = 0;

  *cid = osip_strdup(cp);

  return *cid ? 0 : -PH_NORESOURCES;
}






PHAPI_EXPORT int
phCallGetSipCallID(int cid, char* buf, int bufsize) 
{
  phcall_t *ca = ph_locate_call_by_cid(cid);
  char *callid;
  int i;

  if (!ca)
    return -PH_BADCID;

  if( bufsize  <= 0 || !buf)
    return -PH_BADARG;


  eXosip_lock();
  i = ph_get_call_id(ca->did, &callid);
  eXosip_unlock();

  if(!i)
    {
    strncpy(buf, callid, bufsize);
    osip_free(callid);
    return 0;
    }

  return -PH_ERROR;
}



PHAPI_EXPORT int
phInit(phCallbacks_t *cbk, char * server, int asyncmode)
{
  int i;
  const char *tmp;

  memset(vcontact, 0, sizeof(vcontact));

  i = ph_debug_init();

  if (i)
    return i;

  tmp = getenv("EXOSIP_RESEND_OFFSET");
  if (tmp && strlen(tmp))
    ph_resend_offset = atoi(tmp);

  ph_avcodec_init();
  ph_calls_init();

  if (phcfg.use_tunnel)
    {
    i = ph_tunnel_init();
    if (i)
      return i;
    }

#ifdef FORCE_VAD
  /* HACK for test */
#ifdef EMBED
  phcfg.vad = VAD_VALID_MASK | (500 & VAD_THRESHOLD_MASK);
#else
  phcfg.vad = VAD_VALID_MASK | (1000 & VAD_THRESHOLD_MASK);
#endif
#endif

#ifdef FORCE_CNG
  /* HACK for test */
  phcfg.cng = 1;
#endif

#ifdef OLDOSIP
  ph_media_init(phcfg.use_tunnel, phcfg.plugin_path);
#else
  ph_media_init(phcfg.plugin_path);
#endif
  if (phcfg.use_tunnel) {

    // ph_setup_tunnel();

  }

  i = eXosip_init();
  eXosip_listen_addr(IPPROTO_UDP, 0, atoi(phcfg.sipport), AF_INET, 0);


  if (i)
    return -1;

  {
    const char * ua  = "phapi/eXosip/" PHAPI_VERSION_STRING;
    eXosip_set_user_agent(ua);
  }

  ph_nat_init();

  DBG_SIP_NEGO("NAT type: %s fw=%s \n", ph_nat_type_str, ph_nat_router_addr,0);

#ifdef OLDOSIP
  if (phcfg.force_proxy)
    eXosip_force_proxy(phcfg.proxy);

  {
    char contact[512];

    eXosip_guess_contact_uri(phcfg.identity, contact, sizeof(contact), 1);
    eXosip_set_answer_contact(contact);
  }
#endif

  memset(ph_vlines, 0, sizeof(ph_vlines));

  ph_payloads_init();

  /* register callbacks? */
  //  eXosip_set_mode(EVENT_MODE);
  phcb = cbk;
  phcfg.asyncmode = asyncmode;
  if (!asyncmode)
    timeout = 1;
  else
    timeout = 500;

  ph_media_start_mutex = osip_mutex_init();
  ph_media_stop_mutex = osip_mutex_init();

  if (asyncmode)
    phapithread = osip_thread_create(20000, ph_api_thread, (void*)0);

  phIsInitialized = 1;

  return 0;
}



int phTunnelConfig(const char* http_proxy, const int http_proxy_port,
    const char* httpt_server, const int httpt_server_port,
    const char *proxy_user, const char* proxy_passwd,
    int use_ssl, int autoconf)
{
  phcfg.httpt_server[0] = 0;
  phcfg.http_proxy[0] = 0;
  phcfg.use_tunnel = 0;

  if (!httpt_server) {
    return -1;
  }

  phcfg.http_proxy_port = http_proxy_port;
  if (!httpt_server_port)
    if (!http_proxy) {
      phcfg.httpt_server_port = 80;
    }
    else {
      phcfg.httpt_server_port = 443;
    }
  else
    phcfg.httpt_server_port = httpt_server_port;

  if (httpt_server)
    strncpy(phcfg.httpt_server, httpt_server, sizeof(phcfg.httpt_server));
  if (http_proxy)
    strncpy(phcfg.http_proxy, http_proxy, sizeof(phcfg.http_proxy));

  if (proxy_user)
    strncpy(phcfg.http_proxy_user, proxy_user, sizeof(phcfg.http_proxy_user));
  if (proxy_passwd)
    strncpy(phcfg.http_proxy_passwd, proxy_passwd, sizeof(phcfg.http_proxy_passwd));

  phcfg.use_tunnel = PH_TUNNEL_USE;
  if (use_ssl)
    phcfg.use_tunnel |= PH_TUNNEL_SSL;

  if (autoconf)
    phcfg.use_tunnel |= PH_TUNNEL_AUTOCONF;
  return 0;
}



/**
 * terminate ph api
 */
PHAPI_EXPORT void
phTerminate()
{
  int i;

  DBG4_SIP_NEGO("SIP NEGO: phTerminate\n",0,0,0);
  if (!phIsInitialized)
    return;


  for(i = 0; i < PH_MAX_CALLS; i++)
    if (ph_calls[i].cid != -1)
      ph_release_call(&ph_calls[i]);



  for(i = 0; i < PH_MAX_VLINES; i++)
    {
    phDelVline(i+1);
    }



  usleep(200000);

  phPoll();

  phIsInitialized = 0;

  eXosip_quit();
  osip_free(phapithread);

  for(i = 0; i < PH_MAX_VLINES; i++)
    {
    struct vline *vl = ph_vlid2vline(i+1);
    if (vl)
      vline_free(vl);
    }


#ifdef USE_HTTP_TUNNEL
  if (phTunnel)
    {
    http_tunnel_close(phTunnel->h_tunnel);
    http_tunnel_clean_up();
    free(phTunnel);
    phTunnel = 0;
    }
#endif

  ph_media_cleanup();




  if (phLogFileName && phDebugLevel > 0)
    fclose(ph_log_file);
  if (phDebugLevel > 0)
    for (i = 0; i <= phDebugLevel && i < END_TRACE_LEVEL; ++i)
      TRACE_DISABLE_LEVEL(i);

  if (phLogFileName)
    free(phLogFileName);


  phLogFileName = 0;

}



/**
 * poll for phApi events.c 
 */
PHAPI_EXPORT int
phPoll()
{
  if (!phIsInitialized)
    return -1;

  if (!phcfg.asyncmode)
    {
    if (ph_event_get() == -2)
      return -2;

    ph_keep_refreshing();
    }
  return 0;
}



void ph_refer_notify(int did, int status, const char* msg, int final)
{
  char  statusmsg[128];
  osip_message_t *notify = 0;
  int i;

  snprintf(statusmsg, sizeof(statusmsg), "SIP/2.0 %d %s", status, msg);

  eXosip_lock();

  i = eXosip_call_build_notify(did, final ? EXOSIP_SUBCRSTATE_TERMINATED : EXOSIP_SUBCRSTATE_ACTIVE, &notify);
  if (i)
    goto err;

  osip_message_set_body(notify, statusmsg, strlen(statusmsg));
  osip_message_set_content_type(notify, "message/sipfrag");

  i = eXosip_call_send_request(did, notify);

  err:
  eXosip_unlock();
  if (i && (notify != 0))
    osip_message_free(notify);


}

static int
ph_call_retrieve_payloads(phcall_t *ca, eXosip_event_t *je, int flags)
{
#if 0
  int  i = 0;
  DBG4_SIP_NEGO("looking for payloads...\n", 0, 0, 0);
  DBG4_SIP_NEGO("audio...\n", 0, 0, 0);
  if (_is_audio_enabled(flags))
    {
    i = eXosip_retrieve_negotiated_audio_payload(ca->did, &ca->audio_payload, ca->audio_payload_name, sizeof(ca->audio_payload_name));
    DBG4_SIP_NEGO("remote_audio=%s payload=%s(%d)\n", ca->remote_sdp_audio_ip, ca->audio_payload_name, ca->audio_payload);
    }

  DBG4_SIP_NEGO("video...\n", 0, 0, 0);
  ca->video_payload = 0;
  if (ca->remote_sdp_video_ip[0] && (_is_video_enabled(flags)))
    {
    i = eXosip_retrieve_negotiated_video_payload(ca->did, &ca->video_payload, ca->video_payload_name, sizeof(ca->video_payload_name));
    DBG4_SIP_NEGO("remote_video=%s payload=%s(%d)\n", ca->remote_sdp_video_ip, ca->video_payload_name, ca->video_payload);
    }

  DBG4_SIP_NEGO("cng...\n", 0, 0, 0);
  if(!i && phcfg.cng && (flags & PH_STREAM_CNG)) {
    ca->cng = !eXosip_retrieve_negotiated_specific_payload(ca->did, PH_MEDIA_CN_PT_STR, strlen(PH_MEDIA_CN_PT_STR));
    DBG4_SIP_NEGO("cng: %d", ca->cng, 0, 0);
  }
  return i;
#endif
}


PHAPI_EXPORT int phCallGetCodecs(int cid, char *audioCodecBuf, int aBufLen, char *videoCodecBuf, int vBufLen)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);


  if (!ca)
    return -PH_BADCID;


  if (audioCodecBuf)
    strncpy(audioCodecBuf, ca->audio_payload_name, aBufLen);


  if (videoCodecBuf)
    strncpy(videoCodecBuf, ca->video_payload_name, vBufLen);


  return 0;


}

PHAPI_EXPORT int
phCallGetMediaInfo(int cid, struct ph_confirmed_media_info *mi)
{
  phcall_t *ca = ph_locate_call_by_cid(cid);


  if (!ca)
    return -PH_BADCID;

  mi->audio.localport = ca->local_sdp_audio_port;
  mi->audio.remoteport = ca->remote_sdp_audio_port;
  strncpy(mi->audio.remoteip, ca->remote_sdp_audio_ip, sizeof(mi->audio.remoteip));
  mi->video.localport = ca->local_sdp_video_port;
  mi->video.remoteport = ca->remote_sdp_video_port;
  strncpy(mi->video.remoteip, ca->remote_sdp_video_ip, sizeof(mi->video.remoteip));

  return 0;

}

static void
ph_parse_payload_mime(struct ph_media_payload_s *pt, const char *mime, int rate, int chans)
{
  const char *rp;
  const char *cp;

  rp = strchr(mime, '/');
  strncpy(pt->string, mime, sizeof(pt->string));
  pt->rate = rate;
  pt->chans = chans;


  if (!rp)
    return;

  rp++;
  if (!*rp)
    return;

  pt->rate = atol(rp);

  cp = strchr(rp, '/');
  if (!cp)
    return;

  cp++;
  if (!*cp)
    return;

  pt->chans = atol(cp);
}



static int 
ph_call_media_stop(phcall_t *ca)
{
  DBG4_SIP_NEGO("SIP_NEGO: ph_call_media_stop\n", 0, 0, 0);

  if (ca->mses)
    {
    if (ca->mses->refcnt == 1)
      {
      if (!ca->audiodev)
        ca->audiodev = phcfg.audio_dev;

      if (!ph_msession_stopped(ca->mses))
        {
        ph_msession_stop(ca->mses, ca->audiodev);
        }
      }
    ph_msession_free(ca->mses);
    ca->mses = 0;
    }

  return 0;

}

static int
ph_call_media_suspend(phcall_t *ca, int localhold)
{
  if (ca->mses)
    {
    if (!ca->audiodev)
      ca->audiodev = phcfg.audio_dev;

    ph_msession_suspend(ca->mses, PH_MSTREAM_TRAFFIC_IO, ca->audiodev);
    }

  return 0;
}


static int
ph_call_media_resume(phcall_t *ca, int localhold)
{
  if (ca->mses)
    {
    if (!ca->audiodev)
      ca->audiodev = phcfg.audio_dev;
    ph_msession_resume(ca->mses, PH_MSTREAM_TRAFFIC_IO, ca->audiodev);
    }

  return 0;
}



static 
struct ph_msession_s *ph_msession_new()
{
  struct ph_msession_s *s  = (struct ph_msession_s *)calloc(sizeof(struct ph_msession_s), 1);
  s->critsec_mstream_init = osip_mutex_init();
  s->refcnt = 1;
  return s;
}


static 
void ph_msession_use(struct ph_msession_s *s)
{
  if (s)
    {
    osip_mutex_lock(s->critsec_mstream_init);
    s->refcnt++;
    osip_mutex_unlock(s->critsec_mstream_init);
    }
}

static 
void ph_msession_free(struct ph_msession_s *s)
{
  if (s)
    {
    osip_mutex_lock(s->critsec_mstream_init);
    if (s->refcnt-- == 1)
      {
      osip_mutex_unlock(s->critsec_mstream_init);
      osip_mutex_destroy(s->critsec_mstream_init);
      free(s);
      return;
      }
    osip_mutex_unlock(s->critsec_mstream_init);
    }
}

static int
ph_call_media_start(phcall_t *ca, eXosip_event_t *je, int flags, int resumeflag)
{
  int i = 0;
  struct ph_msession_s *s = NULL;
  const char* ptime = getenv("EXOSIP_FORCE_PTIME");
  if (!ptime || !*ptime)
    ptime = "20";


  // cases when the invocation is ignored
  if (phcfg.nomedia || ca->localhold || ca->remotehold)
    {
    return 0;
    }

  // we will work on the media sessions of the given phcall_t
  s = ca->mses;

  osip_mutex_lock(ph_media_start_mutex);

  // init the ph_msession_s for the call if the call doesn't have one yet
  if (!s)
    {
    s = ca->mses = ph_msession_new();
    if (!s)
      {
      osip_mutex_unlock(ph_media_start_mutex);
      return -PH_NORESOURCES;
      }
    s->confflags = 0;
    s->confsession = NULL;
    s->audio_conf = NULL;
    s->activestreams = 0;
    }
  else
    {
    if(resumeflag == 0)
      {
      if(s->activestreams)
        {
        osip_mutex_lock(ph_media_stop_mutex);
        ph_msession_stop(s, phcfg.audio_dev);
        osip_mutex_unlock(ph_media_stop_mutex);
        }
      s->confflags = 0;
      s->confsession = NULL;
      s->audio_conf = NULL;
      s->activestreams = 0;
      }
    }
  s->cbkInfo = ca;

  // we need to understand what is required from the function call
  // by default, nothing to do
  s->newstreams = 0;

  if ( // user accepts video and network accepts video
      (_is_video_enabled(ca->user_mflags))
      && ca->video_payload
      && ca->remote_sdp_video_ip[0]
  )
    {
    // negociated flags (user+SDP) need to be IO
    ca->nego_mflags = ca->nego_mflags | PH_STREAM_VIDEO_RX;
    ca->nego_mflags = ca->nego_mflags | PH_STREAM_VIDEO_TX;

    DBG_SIP_NEGO("will have video stream ip: %s payload=%d\n", ca->remote_sdp_video_ip, ca->video_payload);
    DBG_SIP_NEGO("media flags may have changed: user= %d nego=%d\n", ca->user_mflags, ca->nego_mflags);
    }
  else
    {
    // video is not negociated
    // it is necessary to remove VIDEO IO flags
    ca->nego_mflags = ca->nego_mflags & ~PH_STREAM_VIDEO_RX;
    ca->nego_mflags = ca->nego_mflags & ~PH_STREAM_VIDEO_TX;

    DBG_SIP_NEGO("media flags may have changed: user= %d nego=%d\n", ca->user_mflags, ca->nego_mflags);
    }

  if ( _is_video_enabled(ca->nego_mflags) )
    {
    struct ph_mstream_params_s *msp = &s->streams[PH_MSTREAM_VIDEO1];
    int ttype;

    // program activation of VIDEO1
    s->newstreams |= (1 << PH_MSTREAM_VIDEO1);

    // define the traffic type of the stream
    ttype = _is_video_enabled(ca->user_mflags);
    if (ttype == (PH_STREAM_VIDEO_RX | PH_STREAM_VIDEO_TX))
      {
      msp->traffictype = PH_MSTREAM_TRAFFIC_IO;
      }
    else if (ttype == PH_STREAM_VIDEO_RX)
      {
      msp->traffictype = PH_MSTREAM_TRAFFIC_IN;
      }
    else if (ttype == PH_STREAM_VIDEO_TX)
      {
      msp->traffictype = PH_MSTREAM_TRAFFIC_OUT;
      }

    msp->localport = ca->local_sdp_video_port;
    msp->remoteport = ca->remote_sdp_video_port;
    strncpy(msp->remoteaddr,
        ca->remote_sdp_video_ip,
        sizeof(msp->remoteaddr));

    // define the negociated codec payload on the stream
    msp->ipayloads[0].number = ca->video_payload;
    ph_parse_payload_mime(&msp->ipayloads[0], ca->video_payload_name, 90000, 1);
    msp->opayloads[0] = msp->ipayloads[0];

    // define the video callback
    s->frameDisplayCbk =  ph_frame_display_cbk;

    // additional configuration for video

    /* if(sdp_message_bandwidth_get(ca->remote_sdp,  ) && !phcfg.video_config.force_high_speed)
      {
      msp->video_quality = ph_get_quality_from_bitrate(ca->max_bandwidth);
      }
    else
    msp->video_quality = phcfg.video_config.video_line_configuration;*/
    }

  if ( // audio is enabled
      _is_audio_enabled(ca->nego_mflags)
      && (!ca || ca->remote_sdp_audio_ip[0])
  )
    {
    struct ph_mstream_params_s *msp = &s->streams[PH_MSTREAM_AUDIO1];
    if(!strncmp(ca->audio_payload_name, "GSM", 3))
      {
      if(30 == atoi(ptime))
        {
        // for GSM reset ptime to 20ms
        ptime = "20";
        }
      }
    // Set to this stream the correct ptime negociated in the SDP
    // If there is no ptime negociated, use the default value (20 ms)
    //msp->ptime = (ca && ca->ptime > 0 ? ca->ptime : atoi(ptime));
    msp->ptime = atoi(ptime);

    // program activation of AUDIO1
    s->newstreams |= (1 << PH_MSTREAM_AUDIO1);

    s->dtmfCallback = ph_wegot_dtmf;
    s->endCallback = ph_stream_ended;

    if (phcfg.vad & 0x80000000)
      {
      msp->flags |= PH_MSTREAM_FLAG_VAD;
      msp->vadthreshold = phcfg.vad & 0x7fff;
      }

    if (phcfg.cng)
      {
      msp->flags |= PH_MSTREAM_FLAG_CNG;
      }

    msp->jitter = phcfg.jitterdepth;

    if (!phcfg.noaec)
      {
      msp->flags |= PH_MSTREAM_FLAG_AEC;
      }

    msp->traffictype = PH_MSTREAM_TRAFFIC_IO;

    msp->localport = ca->local_sdp_audio_port;
    msp->remoteport = ca->remote_sdp_audio_port;
    strncpy(msp->remoteaddr,
        ca->remote_sdp_audio_ip,
        sizeof(msp->remoteaddr));

    // SPIKE_HDX
    if (phcfg.hdxmode == PH_HDX_MODE_MIC)
      {
      msp->flags |= PH_MSTREAM_FLAG_MICHDX;
      msp->vadthreshold = phcfg.vad & 0x7fff;
      }

    if (phcfg.hdxmode == PH_HDX_MODE_SPK)
      {
      msp->flags |= PH_MSTREAM_FLAG_SPKHDX;
      msp->vadthreshold = phcfg.vad & 0x7fff;
      }

    msp->ipayloads[0].number = ca->audio_payload;
    ph_parse_payload_mime(&msp->ipayloads[0], ca->audio_payload_name, 8000, 1);
    if (!strcasecmp(msp->ipayloads[0].string, "g722"))
      msp->ipayloads[0].rate = 16000;
    msp->opayloads[0] = msp->ipayloads[0];

    } // end        if ( // audio is enabled

  // take action depending on the streaming configuration
  if (s->newstreams | s->activestreams)
    {
    if (resumeflag)
      {
      if (ph_msession_resume(s, PH_MSTREAM_TRAFFIC_IO, phcfg.audio_dev))
        {
        DBG_SIP_NEGO("SIP_NEGO:ph_call_media_start: just called ph_msession_resume\n");
        i = -PH_NOMEDIA;
        }
      }
    else if (ph_msession_start(s, phcfg.audio_dev))
      {
      DBG_SIP_NEGO("SIP_NEGO:ph_call_media_start: just called ph_msession_start\n");
      i = -PH_NOMEDIA;
      }
    }
  else
    {
    DBG_SIP_NEGO("SIP_NEGO:ph_call_media_start: nothing to start\n");
    i = -PH_NOMEDIA;
    }

  osip_mutex_unlock(ph_media_start_mutex);

  return i;
}

void
ph_call_new(eXosip_event_t *je)
{
#ifdef OLDOSIP
  phCallStateInfo_t info;
  phcall_t *ca;
  struct vline *vl;

  clear(info);
  if (ph_busyFlag)
    {
    ph_answer_request(je->tid, 486, 0);
    return;
    }


  if (ph_follow_me_addr[0])
    {
    ph_answer_request(je->tid, 302, ph_follow_me_addr);
    return;
    }


  info.vlid = ph_get_vline_id(je->local_uri, je->req_uri);

  if (!info.vlid)
    {
    ph_answer_request(je->tid, 404, 0);
    return;
    }

  vl = ph_vlid2vline(info.vlid);

  assert(vl);

  if (vl->busy)
    {
    ph_answer_request(je->tid, 486, vl->contact);
    return;
    }


  if (vl->followme && vl->followme[0])
    {
    ph_answer_request(je->tid, 302, vl->followme);
    return;
    }


  ca = ph_locate_call(je, 1);
  if (ca)
    {
    ca->vlid = info.vlid;
    ph_build_cname(ca->cname, sizeof(ca->cname), ph_vlid2vline(ca->vlid));

    info.userData = je->external_reference;
    info.event = phINCALL;
    info.u.remoteUri = je->remote_uri;
    info.localUri = je->local_uri;
    info.streams = ca->nego_mflags;
    info.callinfo = je->call_info;

    ph_retrieve_remote_sdp_text(je->did, (char **)&info.remoteSdp);

    phcb->callProgress(ca->cid, &info);
    }
  else
    {
    ph_answer_request(je->tid, 500, vl->contact);
    }
#endif

}

void
ph_call_replaces(eXosip_event_t *je)
{
#ifdef OLDOSIP
  phCallStateInfo_t info;
  phcall_t *ca, *oldca;

  DBG4_SIP_NEGO("SIP_NEGO: ph_call_replaces\n", 0, 0, 0);

  clear(info);


  ca = ph_locate_call(je, 1);

  if (ca)
    {
    oldca = ph_locate_call_by_cid(je->replacedcid);

    if (oldca)
      {
      struct ph_stream_params *params[PH_MAX_STREAMS];
      int flags = oldca->nego_mflags;
      int i;

      info.userData = je->external_reference;
      info.event = phCALLREPLACED;
      info.u.remoteUri = je->remote_uri;
      info.localUri = je->local_uri;
      info.newcid =  je->cid;
      info.callinfo = optional(je->call_info);
      info.streams = flags;
      info.vlid = oldca->vlid;

      if (!ca->vlid)
        ca->vlid = info.vlid;

      ph_deep_copy_streams(params, oldca->streams);

      info.remoteSdp = je->msg_body;

      phcb->callProgress(oldca->cid, &info);

      ph_call_media_stop(oldca);

      ph_accept_call(je->cid, 0,  flags,  params);

      ph_free_all_streams(params);


      }
    }
#endif

}

#define ph_req_get_status(x) osip_message_get_status_code(x)

static char *
ph_req_get_to(osip_message_t *msg)
{
  char *str = 0;

  osip_to_to_str(msg->to, &str);
  return str;
}

static char *
ph_req_get_from(osip_message_t *msg)
{
  char *str = 0;

  osip_from_to_str(msg->from, &str);
  return str;
}

static char *
ph_req_get_body(osip_message_t *msg)
{
  char *str = 0;
  osip_body_t *body;
  size_t len;


  body = osip_list_get(&msg->bodies, 0);
  if (!body)
    return 0;

  osip_body_to_str(body, &str, &len);

  return str;
}

static osip_header_t *
ph_req_find_header(osip_message_t *msg, const char *hname)
{
  osip_header_t *hdr = 0;

  osip_message_header_get_byname(msg, hname, 0, &hdr);
  return hdr;

}

static char *
ph_req_get_event(osip_message_t *msg)
{
  osip_header_t *hdr = 0;

  osip_message_header_get_byname(msg, "Event", 0, &hdr);

  if (hdr)
    return osip_strdup(hdr->hvalue);

  return 0;
}



void
ph_call_answered(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;
  int rdid;
  char *from = 0, *to = 0, *sdp = 0;

  DBG4_SIP_NEGO("SIP NEGO: ph_call_answered\n", 0, 0, 0);
  clear(info);

  ca = ph_locate_call(je, 1);
  info.remoteSdp = sdp = ph_req_get_body(je->response);
  if (ca)
    {
    rca = ph_locate_call_by_cid(ca->rcid);
    }

  if (!ca->localhold)
    {
    const int mflags =  -1 & ~(PH_STREAM_MCSEND|PH_STREAM_MCRECV);

    //FIXME: maybe not the best place ?
    eXosip_call_build_ack(ca->did, &je->ack);
    eXosip_call_send_ack(ca->did, je->ack);

    ph_call_retrieve_payloads(ca, je, -1);
    sdp_message_init(&ca->remote_sdp);
    sdp_message_parse(ca->remote_sdp, sdp);
    sdp_context_process_answer(ca->sdpctx, ca->remote_sdp);
    ph_call_media_start(ca, je, mflags, ca->localresume);
    }

  info.localUri = from = ph_req_get_from(je->response);
  info.userData = je->external_reference;
  if (ca->localhold)
    {
    info.event = phHOLDOK;
    }
  else if (ca->localresume)
    {
    info.event = phRESUMEOK;
    ca->localresume = 0;
    }
  else {
    info.event = phCALLOK;
  }

  info.u.remoteUri = to = ph_req_get_to(je->response);
  info.vlid = ca->vlid;
  if (rca)
    {
    info.oldcid = rca->cid;
    rdid = rca->rdid;
    }

  info.streams = PH_STREAM_AUDIO;
  if (ca->video_payload)
    {
    info.streams |= PH_STREAM_VIDEO_RX;
    }

  if (!ca->localrefer)
    {
    /*
     * the call back can call phCloseCall(odlcid)...  but we have rdid in
     * the local var
     */
    phcb->callProgress(ca->cid, &info);
    }

  if (rca)
    {
    ph_refer_notify(rdid, ph_req_get_status(je->response), "OK", 1);
    }

  if (sdp)
    osip_free(sdp);

  if (to)
    osip_free(to);

  if (from)
    osip_free(from);

}


void
ph_call_proceeding(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;
  char *to = 0;
  int s = 0;

  DBG4_SIP_NEGO("SIP NEGO: ph_call_proceeding\n", 0, 0, 0);
  clear(info);

  ca = ph_locate_call(je, 1);
  if (ca)
    {
    rca = ph_locate_call_by_cid(ca->rcid);
    }

  if (!ca->localrefer)
    {
    ph_call_retrieve_payloads(ca, je, PH_STREAM_CNG);
    ph_call_media_start(ca, je, -1, 0);

    info.userData = je->external_reference;
    info.event = phDIALING;
    info.u.remoteUri = to = ph_req_get_to(je->response);
    info.vlid = ca->vlid;

    info.streams = ca->nego_mflags;

    phcb->callProgress(ca->cid, &info);
    }

  if (rca)
    {
    ph_refer_notify(rca->rdid, s, "Proceeding", 0);
    }

  if (to)
    free(to);

}

void
ph_call_redirected(eXosip_event_t *je)
{
#ifdef OLDOSIP
  phCallStateInfo_t info;
  phcall_t *ca;
  int validUris;


  ca = ph_locate_call(je, 1);

  if (!ca)
    return;

  validUris = nonempty(je->remote_contact) && nonempty(je->remote_uri);

  if ((ca->redirs > 8) || !validUris || ph_find_matching_vline(je->remote_contact, PHM_IGNORE_PORT) || ph_same_uri(je->remote_contact, je->remote_uri))
    {
    ph_call_requestfailure(je);
    return;
    }


  clear(info);


  info.localUri = je->local_uri;
  info.userData = je->external_reference;
  info.event = phCALLREDIRECTED;
  info.u.remoteUri = je->remote_contact;
  info.vlid = ca->vlid;
  info.newcid = 0;

  if (phcfg.autoredir)
    {
    phcall_t *newca;

    newca = ph_allocate_call(-2);
    newca->redirs = ca->redirs + 1;
    info.newcid = phLinePlaceCall_withCa(info.vlid, je->remote_contact, 0, 0, ca->user_mflags, newca, ca->audiodev, 0, 0);
    }

  ph_release_call(ca);

  phcb->callProgress(je->cid, &info);
#endif
}


void ph_callStopRinging(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca;
  char *from = 0, *to = 0;

  clear(info);

  ca = ph_locate_call(je, 1);
  if (ca && ca->isringing)
    {
    ca->isringing = 0;
    info.event = phRINGandSTOP;

    info.localUri = from = ph_req_get_from(je->request);
    info.userData = je->external_reference;

    info.u.remoteUri = to = ph_req_get_to(je->request);
    info.vlid = ca->vlid;

    phcb->callProgress(je->cid, &info);
    }

  if (to)
    osip_free(to);
  if (from)
    osip_free(from);
}

void
ph_call_ringing(eXosip_event_t *je)
{
  int ret = 0;
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;
  char *from = 0, *to = 0;


  DBG4_SIP_NEGO("SIP NEGO: ph_call_ringing\n", 0, 0, 0);

  clear(info);

  ca = ph_locate_call(je, 1);
  if (ca)
    {
    rca = ph_locate_call_by_cid(ca->rcid);
    }

  ph_call_retrieve_payloads(ca, je, PH_STREAM_CNG);

  ret = ph_call_media_start(ca, je, -1, 0);

  info.event = phRINGING;
  if (ret == -PH_NOMEDIA && !ph_call_hasaudio(ca) && !ca->isringing) /*  no audio and softPhone is now not ringing and has no sound */
    {
    ca->isringing = 1;
    info.event = phRINGandSTART;
    }
  else if (ca->isringing )
    {
    ca->isringing = 0;
    info.event = phRINGandSTOP;
    }

  info.localUri = from = ph_req_get_from(je->response);
  info.userData = je->external_reference;

  info.u.remoteUri = to = ph_req_get_to(je->response);
  info.vlid = ca->vlid;

  info.streams = ca->nego_mflags;

  phcb->callProgress(je->cid, &info);

  if (rca)
    {
    ph_refer_notify(rca->rdid, 180, "Ringing", 0);
    }

  if (to)
    osip_free(to);
  if (from)
    osip_free(from);
}


static void
ph_call_requestfailure(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;
  int s;
  char *from = 0, *to = 0;


  clear(info);

  ca = ph_locate_call(je, 0);
  if (!ca)
    return;

  rca = ph_locate_call_by_cid(ca->rcid);
  info.vlid = ca->vlid;
  ph_release_call(ca);

  s = ph_req_get_status(je->response);
  info.localUri = from = ph_req_get_from(je->response);
  info.userData = je->external_reference;
  if (s == 486)
    {
    info.event = phCALLBUSY;
    info.u.remoteUri = to = ph_req_get_to(je->response);
    }
  else
    {
    info.event = phCALLERROR;
    info.u.errorCode = s;
    }

  phcb->callProgress(je->cid, &info);
  if (rca)
    {
    ph_refer_notify(rca->rdid, s, s == 486 ? "Busy" : "Request failure", 1);
    }

  if (to)
    osip_free(to);
  if (from)
    osip_free(from);
}


void
ph_call_serverfailure(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;
  char *from = 0, *to = 0;
  int s;

  clear(info);

  ca = ph_locate_call(je, 0);
  if (ca)
    {
    rca = ph_locate_call_by_cid(ca->rcid);
    info.vlid = ca->vlid;
    ph_release_call(ca);
    }

  s = ph_req_get_status(je->response);
  info.localUri = from = ph_req_get_from(je->response);
  info.userData = je->external_reference;
  info.event = phCALLERROR;
  info.u.errorCode = s;


  phcb->callProgress(je->cid, &info);

  if (rca)
    {
    ph_refer_notify(rca->rdid, s, "Server failure", 1);
    }

  if (to)
    osip_free(to);
  if (from)
    osip_free(from);
}

void
ph_call_globalfailure(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;
  char *from = 0, *to = 0;
  int s;

  clear(info);

  ca = ph_locate_call(je, 0);
  if (ca)
    {
    rca = ph_locate_call_by_cid(ca->rcid);
    info.vlid = ca->vlid;
    ph_release_call(ca);
    }

  s = ph_req_get_status(je->response);
  info.userData = je->external_reference;
  info.localUri = from = ph_req_get_from(je->response);

  if (s == 600)
    {
    info.event = phCALLBUSY;
    info.u.remoteUri = to = ph_req_get_to(je->response);
    }
  else
    {
    info.event = phCALLERROR;
    info.u.errorCode = s;
    }

  phcb->callProgress(je->cid, &info);

  if (rca)
    {
    ph_refer_notify(rca->rdid, s, "Global failure", 1);
    }

  if (to)
    osip_free(to);
  if (from)
    osip_free(from);
}

void
ph_call_noanswer(eXosip_event_t *je, int alloc)
{
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;
  char *from = 0, *to = 0;


  clear(info);

  ca = ph_locate_call(je, alloc);
  if (ca)
    {
    rca = ph_locate_call_by_cid(ca->rcid);
    info.vlid = ca->vlid;
    ph_release_call(ca);
    }

  if (!ca && !alloc)
    return;

  info.userData = je->external_reference;
  info.event = phNOANSWER;
  info.u.remoteUri = to = ph_req_get_to(je->response);
  info.localUri = from = ph_req_get_to(je->response);

  phcb->callProgress(je->cid, &info);

  if (rca)
    {
    ph_refer_notify(rca->rdid, ph_req_get_status(je->response), "No answer", 1);
    }

  if (to)
    osip_free(to);
  if (from)
    osip_free(from);
}



void
ph_call_closed(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca, *rca=0;

  clear(info);

  ca = ph_locate_call(je, 0);
  if (ca)
    {
    rca = ph_locate_call_by_cid(ca->rcid);
    info.vlid = ca->vlid;
    ph_release_call(ca);

    info.userData = je->external_reference;
    info.event = phCALLCLOSED;
    info.u.errorCode = 0;
    phcb->callProgress(je->cid, &info);
    }

  if (rca)
    {
    ph_refer_notify(rca->rdid, ph_req_get_status(je->response), "Closed", 1);
    }
}


void
ph_call_onhold(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca;

  DBG4_SIP_NEGO("SIP_NEGO: ph_call_onhold\n", 0, 0, 0);

  clear(info);

  ca = ph_locate_call(je, 0);

  if (!ca)
    return;

  info.vlid = ca->vlid;
  if (ph_call_hasaudio(ca))
    {
#ifndef MEDIA_SUSPEND      
    ph_call_media_stop(ca);
#else
    ph_call_media_suspend(ca, 0);
#endif
    }

  ca->remotehold = 1;
  info.userData = je->external_reference;
  info.event = phCALLHELD;
  phcb->callProgress(je->cid, &info);
}

void
ph_call_offhold(eXosip_event_t *je)
{
  phCallStateInfo_t info;
  phcall_t *ca;
  int remhold;

  DBG4_SIP_NEGO("SIP NEGO: ph_call_offhold\n", 0, 0, 0);

  ca = ph_locate_call(je, 0);
  if (!ca)
    {
    return;
    }

  clear(info);

  info.vlid = ca->vlid;

#ifdef OLDOSIP
  ph_media_resume(ca);

  if (ph_call_hasaudio(ca))
    ph_media_stop(ca);
#endif

  remhold = ca->remotehold;
  ca->remotehold = 0;

  ph_call_retrieve_payloads(ca, je, -1);
  ph_call_media_start(ca, je, -1, remhold);

  if (remhold)
    {
    info.userData = je->external_reference;
    info.event = phCALLRESUMED;
    info.streams = ca->nego_mflags;

    phcb->callProgress(je->cid, &info);
    }

  ca->remotehold = 0;

}

static int ph_find_expires_for_vl(int vlid, osip_message_t *msg)
{
#ifdef OLDOSIP
  ....
#else
  return 600;
#endif 

}

void ph_reg_progress(eXosip_event_t *je)
{
  int i;
  struct vline *vl = 0;
  int vlid;
  int mask = 0;
  int status;

  vl =  ph_find_vline_by_rid(je->rid);

  if (!vl)
    return;

  if (vl->regTimeout == 0)
    mask = PH_UNREG_MASK;
  vlid = ph_vline2vlid(vl);

  status = ph_req_get_status(je->response);

  DBG4_SIP_NEGO("REGPROGRESS reg=%d for vlid=%d\n", je->rid, vlid,0);

  if (je->type == EXOSIP_REGISTRATION_SUCCESS)
    {
    int expires = ph_find_expires_for_vl(vlid, je->response);

    if (expires)
      vl->regTimeout = expires;
    phcb->regProgress(vlid, 0 | mask);
    if (vl->used == VL_DELETING)
      vline_free(vl);
    }
  else if (je->type == EXOSIP_REGISTRATION_FAILURE)
    {
    int newtimeout = -1;

    if (status == 423)  /* Interval to brief */
      {
      osip_header_t *hdr = ph_req_find_header(je->response, "Min-expires");

      if (hdr)
        {
        vl->regTimeout = newtimeout = atoi(hdr->hvalue);
        }
      }

    if (status == 401 || status == 407 || (newtimeout > 0))
      {
      eXosip_lock();
     // i = eXosip_default_action(je);
      eXosip_unlock();

      SKIP(printf("Retrying reg=%d for vlid=%d i=%d t=%d\n", je->rid, vlid, i, newtimeout))
      if (i == 0) return;
      }
    phcb->regProgress(vlid, mask | (status ? status : 500) );

    if (vl->used == VL_DELETING)
      vline_free(vl);

    }
}

void ph_notify_handler(eXosip_event_t *je)
{
  char *ctt = 0;
  char *evt = 0;
  char *from = 0;
  char *body = 0;

  if (phcb->onNotify)
    {
    if (je->request->content_type)
      osip_content_type_to_str(je->request->content_type, &ctt);

    evt = ph_req_get_event(je->request);
    from = ph_req_get_from(je->request);
    body = ph_req_get_body(je->request);

    phcb->onNotify(evt, from, ctt, body);

    if (body)
      osip_free(body);
    if (from)
      osip_free(from);
    if (evt)
      osip_free(evt);
    if (ctt)
      osip_free(ctt);
    }
}


void ph_call_refered(eXosip_event_t *je)
{
#ifdef OLDOSIP
  phcall_t *ca;
  phCallStateInfo_t info;
  int nCid;
  struct vline *vl = 0;

  DBG4_SIP_NEGO("SIP_NEGO: ph_call_refered\n", 0, 0, 0);

  ca = ph_locate_call_by_cid(je->cid);

  if (ca)
    vl = ph_valid_vlid(ca->vlid);


  /*
     we're rejecting the requests refering unxisting calls, vlines and
     if we detect URI loop
   */
  if (!ca || !vl || ph_find_matching_vline(je->refer_to, 0))
    {
    eXosip_lock();
    eXosip_answer_refer(je->did, (!ca) ? 481 : 488);
    eXosip_unlock();
    return;
    }


  eXosip_lock();
  eXosip_answer_refer(je->did, 202);
  eXosip_unlock();

  clear(info);
  ca->rdid = je->did;

  ph_call_media_stop(ca);


  info.newcid = phLinePlaceCall2(ca->vlid, je->refer_to,  0, je->cid, ca->user_mflags);


  info.event = phXFERREQ;
  info.u.remoteUri = je->refer_to;
  info.vlid = ca->vlid;

  phcb->callProgress(je->cid, &info);

#endif

}


void ph_call_refer_status(eXosip_event_t *je)
{
#ifdef OLDOSIP
  phcall_t *ca;
  phCallStateInfo_t info;
  int cheat = 0;
  const char *resultstr;
  int status = 0;
  int txcid;

  ca = ph_locate_call_by_cid(je->cid);

  if (!ca)
    return;

  clear(info);

  if (je->type == EXOSIP_CALL_REFER_STATUS)
    {
    if (phDebugLevel)
      ph_printf("refer_status sdp=%s\n", je->msg_body);

    if (je->ss_status == EXOSIP_SUBCRSTATE_TERMINATED)
      {
      /* cheat and suppose that the transfer succeeded */
      cheat  = 200;
      }

    resultstr = strchr(je->msg_body, ' ');

    if (resultstr)
      status = atoi(resultstr);


    }
  else
    status = je->status_code;


  if (!status)
    {
    if (!cheat)
      return;

    status = cheat;
    }

  if ((status < 200) && cheat)
    status = cheat;

  info.u.errorCode = status;
  info.vlid = ca->vlid;


  if (!ca->txcid && status == 180)
    {
    /* blind transfer:  RINGING is good enough for us */
    info.event = phXFEROK;
    }
  else if (status < 200 && status >= 100)
    {
    info.event = phXFERPROGRESS;
    }
  else if (status >= 200 && status < 300)
    {
    info.event = phXFEROK;
    }
  else
    info.event = phXFERFAIL;


  txcid = ca->txcid;

  phcb->callProgress(je->cid, &info);

  if (info.event == phXFEROK || info.event == phXFERFAIL)
    {
    if (txcid > 0)  /* assisted transfer, close both calls  */
      phCloseCall(txcid);
    if (ca->cid > 0)  /* assisted or blind transfer, close call  */
      phCloseCall(ca->cid);
    }

#endif
}

void ph_message_progress(eXosip_event_t *je)
{
  phMsgStateInfo_t info;
  char *rawCtt = 0;
  phcall_t *ca = ph_locate_call_by_cid(je->cid);
  char *from = 0, *to= 0, *body = 0;
  osip_content_type_t *ctt;

  memset(&info, 0, sizeof(info));

  if (je->response && (ctt = je->response->content_type))
    osip_content_type_to_str(ctt, &rawCtt);
  else if (je->request && (ctt = je->request->content_type))
    osip_content_type_to_str(ctt, &rawCtt);

  info.cid = ca ? je->cid : 0;

  if (je->type == EXOSIP_MESSAGE_NEW)
    {
    info.event = phMsgNew;
    info.content = body = ph_req_get_body(je->request);
    info.ctype = ctt->type;
    info.subtype = ctt->subtype;
    info.to = to = ph_req_get_to(je->request);
    info.from = from = ph_req_get_from(je->request);
    info.rawctt = rawCtt;

    if (phcb->msgProgress != NULL)
      phcb->msgProgress(je->tid, &info);
    }
  else if (je->type == EXOSIP_MESSAGE_ANSWERED)
    {
    info.event = phMsgOk;
    info.to = to = ph_req_get_to(je->response);
    info.from = from = ph_req_get_from(je->response);
    if (phcb->msgProgress != NULL)
      phcb->msgProgress(je->tid, &info);
    }
  else if (je->type == EXOSIP_MESSAGE_REQUESTFAILURE ||
      je->type == EXOSIP_MESSAGE_GLOBALFAILURE ||
      je->type == EXOSIP_MESSAGE_SERVERFAILURE
  )
    {
    info.to = to = ph_req_get_to(je->response);
    info.from = from = ph_req_get_from(je->response);
    info.event = phMsgError;
    if (phcb->msgProgress != NULL)
      phcb->msgProgress(je->tid, &info);
    }

  if (rawCtt)
    osip_free(rawCtt);

  if (to)
    osip_free(to);

  if (from)
    osip_free(from);

  if (body)
    osip_free(body);
}

void ph_info_progress(eXosip_event_t *je)
{
  phcall_t *ca;
  osip_content_type_t *ctt;

  ca = ph_locate_call_by_cid(je->cid);

  if (!ca)
    return;

  if (je->type == EXOSIP_CALL_MESSAGE_NEW)
    {
    if (!(ctt = je->request->content_type))
      goto ans;

    if (!strcasecmp(ctt->type, "application"))
      {
      osip_body_t *body;
      const char *data;
      int event;

      body = osip_list_get(&je->request->bodies, 0);
      if (!body)
        goto ans;

      data = body->body;

      if (!strcasecmp(ctt->subtype, "dtmf-relay"))
        {
        data = strstr(data,"=");
        if (!data)
          goto ans;
        event = *++data;
        }
      else if (!strcasecmp(ctt->subtype, "dtmf"))
        {
        event = atoi(data);
        if (event == 16)
          event = '!';
        else if (0 <= event && event <= 9)
          event += '0';
        else
          event = 'A' + (event - 10);
        }
      else
        goto ans;

      ph_wegot_dtmf(ca, event);
      }
    ans:
    ph_answer_request(je->cid, je->tid, 200, 0);

    }
}

void ph_subscription_progress(eXosip_event_t *je)
{
#ifdef OLDOSIP
  phSubscriptionStateInfo_t info;

  memset(&info, 0, sizeof(info));

  if (je->type == EXOSIP_SUBSCRIPTION_ANSWERED)
    {
    info.event = phSubscriptionOk;
    info.from = je->local_uri;
    info.to = je->remote_uri;

    if (phcb->subscriptionProgress != NULL)
      phcb->subscriptionProgress (je->sid, &info);
    }
  else if (je->type == EXOSIP_SUBSCRIPTION_REQUESTFAILURE)
    {
    info.event = phSubscriptionError;
    if (je->status_code == 404) {
      info.event = phSubscriptionErrNotFound;
    }
    info.from = je->local_uri;
    info.to = je->remote_uri;
    if (phcb->subscriptionProgress != NULL)
      phcb->subscriptionProgress (je->sid, &info);
    }
#endif
}

static void
ph_publish_progress(eXosip_event_t * je)
{
#ifdef OLDOSIP
  struct vline *vl = ph_find_matching_vline(je->local_uri, 0);

  if (!vl)
    return;

  if (je->type == EXOSIP_PUBLISH_SUCCESS)
    {
    char *old = vl->pub.etag;

    vl->pub.etag = 0;

    if (old)
      osip_free(old);

    if (je->etag[0])
      vl->pub.etag = osip_strdup(je->etag);
    }
  else if (je->status_code == 412)
    {
    /* we need to retransmit PUBLISH without "SIP-If-Match" header */
    if (vl->pub.etag)
      osip_free(vl->pub.etag);
    vl->pub.etag = 0;

    phLinePublish2(ph_vline2vlid(vl), vl->pub.uri, 0, vl->pub.ctt, vl->pub.body, vl->pub.timeout);
    }
#endif
}




static int
ph_event_get()
{
  int counter =0;
  /* use events to print some info */
  eXosip_event_t *je;

  //phReleaseTerminatedCalls();
  for (;;)
    {
    je = eXosip_event_wait(0,timeout);
    if (je==NULL)
      break;

    eXosip_lock();
    eXosip_automatic_action();
    eXosip_unlock();

    counter++;

    if (phDebugLevel > 0) {
      char *remote=0, *req=0;

      if (je->request)
        osip_uri_to_str(je->request->req_uri, &req);

      ph_printf("\n<- %s (%i %i) [%i %s] %s requri=%s\n",
          evtnames[je->type], je->cid, je->did,
          je->response ? ph_req_get_status(je->response) : 0,
              je->response ? osip_message_get_reason_phrase(je->response) : "",
                  (remote = (je->response ? ph_req_get_to(je->response) : ph_req_get_from(je->request))),
                  req ? req : "");

      if (remote)
        osip_free(remote);
      if (req)
        osip_free(req);
    }

    switch(je->type)
    {
    case EXOSIP_CALL_INVITE:
      ph_call_new(je);
      break;

    case EXOSIP_CALL_ANSWERED:
      ph_callStopRinging(je);
      ph_call_answered(je);
      break;

    case EXOSIP_CALL_PROCEEDING:
      ph_call_proceeding(je);
      break;

    case EXOSIP_CALL_RINGING:
      ph_call_ringing(je);
      break;

    case EXOSIP_CALL_REDIRECTED:
      ph_call_redirected(je);
      break;

#ifdef OLDOSIP
    case EXOSIP_CALL_REPLACES:
    case EXOSIP_CALL_REPLY:
      ph_call_replaces(je);
      break;
#endif

    case EXOSIP_CALL_REQUESTFAILURE:
      ph_call_requestfailure(je);
      break;


    case EXOSIP_CALL_SERVERFAILURE:
      ph_call_serverfailure(je);
      break;

    case EXOSIP_CALL_GLOBALFAILURE:
      ph_call_globalfailure(je);
      break;

    case EXOSIP_CALL_NOANSWER:
      ph_call_noanswer(je, 1);
      break;

    case EXOSIP_CALL_CLOSED:
      ph_call_closed(je);
      break;

#ifdef OLDOSIP
    case EXOSIP_CALL_HOLD:
      ph_call_onhold(je);
      break;

    case EXOSIP_CALL_OFFHOLD:
      ph_call_offhold(je);
      break;
#endif

    case EXOSIP_CALL_RELEASED:
      ph_call_noanswer(je, 0);
      break;



    case EXOSIP_REGISTRATION_SUCCESS:
    case EXOSIP_REGISTRATION_FAILURE:
      ph_reg_progress(je);
      break;



#ifdef OLDOSIP
    case EXOSIP_CALL_REFERED:
      ph_call_refered(je);
      break;

    case EXOSIP_CALL_REFER_STATUS:
    case EXOSIP_CALL_REFER_FAILURE:
      ph_call_refer_status(je);
      break;

#endif
    case EXOSIP_MESSAGE_NEW:
    case EXOSIP_MESSAGE_ANSWERED:        /* announce a 200ok to a previous sent */
    case EXOSIP_MESSAGE_PROCEEDING:
    case EXOSIP_MESSAGE_REQUESTFAILURE:
    case EXOSIP_MESSAGE_GLOBALFAILURE:
    case EXOSIP_MESSAGE_SERVERFAILURE:
      ph_message_progress(je);
      break;

#ifdef OLDOSIP
    case EXOSIP_INFO_NOANSWER:
    case EXOSIP_INFO_PROCEEDING:      /* announce processing by a remote app   */
    case EXOSIP_INFO_ANSWERED:
    case EXOSIP_INFO_REDIRECTED:
    case EXOSIP_INFO_REQUESTFAILURE:
    case EXOSIP_INFO_SERVERFAILURE:
    case EXOSIP_INFO_GLOBALFAILURE:
    case EXOSIP_INFO_NEW:
      ph_info_progress(je);
      break;

    case EXOSIP_SUBSCRIPTION_REQUESTFAILURE:
    case EXOSIP_SUBSCRIPTION_ANSWERED:
      ph_subscription_progress(je);
      break;

    case EXOSIP_SUBSCRIPTION_NOTIFY:
      ph_notify_handler(je);
      break;

    case EXOSIP_PUBLISH_SUCCESS:
    case EXOSIP_PUBLISH_REQUESTFAILURE:
      ph_publish_progress(je);
      break;

    case EXOSIP_ENGINE_STOPPED:
      return -2;


#endif

    default:
      if (phDebugLevel > 0)
        ph_printf("event(%i %i %i %i) text=%s\n", je->cid, je->sid, je->nid, je->did, je->textinfo);
      break;
    }

    eXosip_event_free(je);
    }


  ph_refresh_vlines();
  ph_scan_calls();

  if (counter>0)
    return 0;
  return -1;
}


static void
ph_keep_refreshing()
{
  time_t now;
  static time_t last_refresh;

  time(&now);
  if (now - last_refresh > PH_REFRESH_INTERVAL)
    {
    phRefresh();
    last_refresh = now;
    }
}



/**
 * eXosip event reader thread
 */
void *
ph_api_thread(void *arg)
{
  time_t t1;
  t1 = 0;
  phIsInitialized = 1;

  time(&t1);
  while(1)
    {
#ifdef WIN32
    Sleep(100);
#endif          
    if (!phIsInitialized)
      return 0;

    ph_keep_refreshing();

    if (ph_event_get() == -2)
      {
      phTerminate();
      break;
      }
    }

  return 0;
}

#ifdef QOS_DEBUG_ENABLE
PHAPI_EXPORT void phrtcp_QoS_enable_rtcp_report(int ToF)
{
  ortcp_enable_rtcp_report(ToF);
}
PHAPI_EXPORT void phrtcp_report_set_cb(jt_rtcpCallbacks_t *cbk)
{
  ortcp_report_set_cb(cbk);
}
PHAPI_EXPORT int phrtcp_report_begin()
{
  phrtcp_QoS_enable_rtcp_report(1);
  ortcp_report_begin();
}
PHAPI_EXPORT int phrtcp_report_end()
{
  ortcp_report_end();
}
#endif /* end of QOS_DEBUG_ENABLE */


int getPublicPort(char *  local_voice_port, char * local_video_port, char * public_voice_port, char * public_video_port)
{

  Socket  sock;
  Socket  sock1;
  Socket  sock2;
  Socket  sock3;
  StunAddress4 mappedAddr, rtcpAddr;
  StunAddress4 stunServerAddr;
  int res;
  int res2;
  int loop = 0;

  if (phcfg.use_tunnel)
    return 1;

  stunParseServerName(phcfg.stunserver, &stunServerAddr);

  do {

    printf("get pub video: %s", local_voice_port);
    res = stunOpenSocketPair(&stunServerAddr, &mappedAddr, &rtcpAddr, &sock, &sock1,atoi(local_voice_port), 0);

    if (-1 !=  res)
      {
      snprintf(local_voice_port, 9, "%i", res);
      snprintf(public_voice_port, 9, "%d", mappedAddr.port);
      closesocket(sock1);
      closesocket(sock);
      }
    else
      {
      closesocket(sock);
      closesocket(sock1);
      snprintf(local_voice_port, 9, "%i",atoi(local_voice_port)+5);
      loop++;
      }
  } while (res <0 && loop < 4 );

  if (res <0)
    {
    return -1;
    }

  loop = 0;

  do {
    printf("get pub video: %s", local_video_port);

    res2 = stunOpenSocketPair(&stunServerAddr, &mappedAddr, &rtcpAddr, &sock2, &sock3,atoi(local_video_port), 0);
    //sock2 = stunOpenSocket(&stunServerAddr, &mappedAddr, atoi(&local_video_port), NULL, 0);

    if (-1 !=  res2)
      {
      snprintf(local_video_port, 9, "%i", res2);
      snprintf(public_video_port, 9, "%d", mappedAddr.port);
      closesocket(sock2);
      closesocket(sock3);
      }
    else
      {
      closesocket(sock2);
      closesocket(sock3);
      snprintf(local_video_port, 9, "%i",atoi(local_video_port)+5);

      loop++;
      }
  } while(res2 <0 && loop < 4 );

  if (res2 <0)
    {
    return -1;
    }

  printf("get public port public voice_port: %s video: %s  ------ \n \n ",public_voice_port, public_video_port);
  return 1;


}

int phLineGetSipAddress(int vlid, char buf[], int bufsize) {
  struct vline *vl;

  vl = ph_valid_vlid(vlid);

  if (!vl) {
    return -PH_BADVLID;
  }

  ph_build_from2(buf, bufsize, vl, FROM_PORT);
  return 0;
}


int phCrash() {
  return *(int *)0 = 0;
}

void phSetDebugLevel(int level) {
  phDebugLevel = level;
}

int phGetDebugLevel() {
  return phDebugLevel;
}

void phSetLogFileName(const char *name)
{
  if (phLogFileName)
    free(phLogFileName);

  phLogFileName = name ? strdup(name) : 0;


}

#else

void dummy()
{
  eXosip_init();
}

#endif