/*
 * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 * Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
 *
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 *
 * The Initial Developer of the Original Code is
 * Anthony Minessale II <anthmct@yahoo.com>
 * Portions created by the Initial Developer are Copyright (C)
 * the Initial Developer. All Rights Reserved.
 *
 * This module (mod_skypiax) has been contributed by:
 *
 * Giovanni Maruzzelli (gmaruzz@gmail.com)
 *
 *
 * Further Contributors:
 *
 *
 *
 * mod_skypiax.c -- Skype compatible Endpoint Module
 *
 */

#include "skypiax.h"

SWITCH_MODULE_LOAD_FUNCTION(mod_skypiax_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_skypiax_shutdown);
SWITCH_MODULE_DEFINITION(mod_skypiax, mod_skypiax_load, mod_skypiax_shutdown, NULL);

static struct {
  int debug;
  char *ip;
  int port;
  char *dialplan;
  char *destination;
  char *context;
  char *codec_string;
  char *codec_order[SWITCH_MAX_CODECS];
  int codec_order_last;
  char *codec_rates_string;
  char *codec_rates[SWITCH_MAX_CODECS];
  int codec_rates_last;
  unsigned int flags;
  int fd;
  int calls;
  char hold_music[256];
  private_t SKYPIAX_INTERFACES[SKYPIAX_MAX_INTERFACES];
  switch_mutex_t *mutex;
} globals;

switch_endpoint_interface_t *skypiax_endpoint_interface;
switch_memory_pool_t *skypiax_module_pool = NULL;
int running = 0;

SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_dialplan, globals.dialplan);
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_context, globals.context);
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_destination, globals.destination);
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_codec_string, globals.codec_string);
SWITCH_DECLARE_GLOBAL_STRING_FUNC(set_global_codec_rates_string,
                                  globals.codec_rates_string);

static switch_status_t channel_on_init(switch_core_session_t * session);
static switch_status_t channel_on_hangup(switch_core_session_t * session);
static switch_status_t channel_on_routing(switch_core_session_t * session);
static switch_status_t channel_on_exchange_media(switch_core_session_t * session);
static switch_status_t channel_on_soft_execute(switch_core_session_t * session);
static switch_call_cause_t channel_outgoing_channel(switch_core_session_t * session,
                                                    switch_event_t * var_event,
                                                    switch_caller_profile_t *
                                                    outbound_profile,
                                                    switch_core_session_t ** new_session,
                                                    switch_memory_pool_t ** pool,
                                                    switch_originate_flag_t flags);
static switch_status_t channel_read_frame(switch_core_session_t * session,
                                          switch_frame_t ** frame, switch_io_flag_t flags,
                                          int stream_id);
static switch_status_t channel_write_frame(switch_core_session_t * session,
                                           switch_frame_t * frame, switch_io_flag_t flags,
                                           int stream_id);
static switch_status_t channel_kill_channel(switch_core_session_t * session, int sig);

static switch_status_t skypiax_codec(private_t * tech_pvt, int sample_rate, int codec_ms)
{
  switch_core_session_t *session = NULL;

  if (switch_core_codec_init
      (&tech_pvt->read_codec, "L16", NULL, sample_rate, codec_ms, 1,
       SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
       NULL) != SWITCH_STATUS_SUCCESS) {
    ERRORA("Can't load codec?\n", SKYPIAX_P_LOG);
    return SWITCH_STATUS_FALSE;
  }

  if (switch_core_codec_init
      (&tech_pvt->write_codec, "L16", NULL, sample_rate, codec_ms, 1,
       SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
       NULL) != SWITCH_STATUS_SUCCESS) {
    ERRORA("Can't load codec?\n", SKYPIAX_P_LOG);
    switch_core_codec_destroy(&tech_pvt->read_codec);
    return SWITCH_STATUS_FALSE;
  }

  tech_pvt->read_frame.rate = sample_rate;
  tech_pvt->read_frame.codec = &tech_pvt->read_codec;

  session = switch_core_session_locate(tech_pvt->session_uuid_str);

  switch_core_session_set_read_codec(session, &tech_pvt->read_codec);
  switch_core_session_set_write_codec(session, &tech_pvt->write_codec);

  switch_core_session_rwunlock(session);

  return SWITCH_STATUS_SUCCESS;

}

void skypiax_tech_init(private_t * tech_pvt, switch_core_session_t * session)
{

  tech_pvt->read_frame.data = tech_pvt->databuf;
  tech_pvt->read_frame.buflen = sizeof(tech_pvt->databuf);
  switch_mutex_init(&tech_pvt->mutex, SWITCH_MUTEX_NESTED,
                    switch_core_session_get_pool(session));
  switch_mutex_init(&tech_pvt->flag_mutex, SWITCH_MUTEX_NESTED,
                    switch_core_session_get_pool(session));
  switch_core_session_set_private(session, tech_pvt);
  switch_copy_string(tech_pvt->session_uuid_str, switch_core_session_get_uuid(session),
                     sizeof(tech_pvt->session_uuid_str));
  if (skypiax_codec(tech_pvt, SAMPLERATE_SKYPIAX, 20) != SWITCH_STATUS_SUCCESS) {
    ERRORA("skypiax_codec FAILED\n", SKYPIAX_P_LOG);
  } else {
    DEBUGA_SKYPE("skypiax_codec SUCCESS\n", SKYPIAX_P_LOG);
  }

}

/* 
   State methods they get called when the state changes to the specific state 
   returning SWITCH_STATUS_SUCCESS tells the core to execute the standard state method next
   so if you fully implement the state you can return SWITCH_STATUS_FALSE to skip it.
*/
static switch_status_t channel_on_init(switch_core_session_t * session)
{
  switch_channel_t *channel;
  private_t *tech_pvt = NULL;

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);
  switch_set_flag_locked(tech_pvt, TFLAG_IO);

  /* Move channel's state machine to ROUTING. This means the call is trying
     to get from the initial start where the call because, to the point
     where a destination has been identified. If the channel is simply
     left in the initial state, nothing will happen. */
  switch_channel_set_state(channel, CS_ROUTING);
  switch_mutex_lock(globals.mutex);
  globals.calls++;
  switch_mutex_unlock(globals.mutex);

  DEBUGA_SKYPE("%s CHANNEL INIT\n", SKYPIAX_P_LOG, switch_channel_get_name(channel));
  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_on_hangup(switch_core_session_t * session)
{
  switch_channel_t *channel = NULL;
  private_t *tech_pvt = NULL;
  char msg_to_skype[256];

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  switch_clear_flag_locked(tech_pvt, TFLAG_IO);
  switch_clear_flag_locked(tech_pvt, TFLAG_VOICE);
  //switch_set_flag_locked(tech_pvt, TFLAG_HANGUP);

  if (strlen(tech_pvt->skype_call_id)) {
    //switch_thread_cond_signal(tech_pvt->cond);
    DEBUGA_SKYPE("hanging up skype call: %s\n", SKYPIAX_P_LOG, tech_pvt->skype_call_id);
    sprintf(msg_to_skype, "ALTER CALL %s HANGUP", tech_pvt->skype_call_id);
    skypiax_signaling_write(tech_pvt, msg_to_skype);
  }

  if (tech_pvt->read_codec.implementation) {
    switch_core_codec_destroy(&tech_pvt->read_codec);
  }

  if (tech_pvt->write_codec.implementation) {
    switch_core_codec_destroy(&tech_pvt->write_codec);
  }

  memset(tech_pvt->session_uuid_str, '\0', sizeof(tech_pvt->session_uuid_str));
  DEBUGA_SKYPE("%s CHANNEL HANGUP\n", SKYPIAX_P_LOG, switch_channel_get_name(channel));
  switch_mutex_lock(globals.mutex);
  globals.calls--;
  if (globals.calls < 0) {
    globals.calls = 0;
  }
  switch_mutex_unlock(globals.mutex);

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_on_routing(switch_core_session_t * session)
{
  switch_channel_t *channel = NULL;
  private_t *tech_pvt = NULL;

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  DEBUGA_SKYPE("%s CHANNEL ROUTING\n", SKYPIAX_P_LOG, switch_channel_get_name(channel));

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_on_execute(switch_core_session_t * session)
{

  switch_channel_t *channel = NULL;
  private_t *tech_pvt = NULL;

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  DEBUGA_SKYPE("%s CHANNEL EXECUTE\n", SKYPIAX_P_LOG, switch_channel_get_name(channel));

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_kill_channel(switch_core_session_t * session, int sig)
{
  switch_channel_t *channel = NULL;
  private_t *tech_pvt = NULL;

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  switch (sig) {
  case SWITCH_SIG_KILL:
    DEBUGA_SKYPE("%s CHANNEL got SWITCH_SIG_KILL\n", SKYPIAX_P_LOG,
                 switch_channel_get_name(channel));
    switch_clear_flag_locked(tech_pvt, TFLAG_IO);
    switch_clear_flag_locked(tech_pvt, TFLAG_VOICE);
    switch_set_flag_locked(tech_pvt, TFLAG_HANGUP);
    break;
  case SWITCH_SIG_BREAK:
    DEBUGA_SKYPE("%s CHANNEL got SWITCH_SIG_BREAK\n", SKYPIAX_P_LOG,
                 switch_channel_get_name(channel));
    switch_set_flag_locked(tech_pvt, TFLAG_BREAK);
    break;
  default:
    break;
  }

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_on_exchange_media(switch_core_session_t * session)
{
  private_t *tech_pvt = NULL;
  DEBUGA_SKYPE("CHANNEL LOOPBACK\n", SKYPIAX_P_LOG);
  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_on_soft_execute(switch_core_session_t * session)
{
  private_t *tech_pvt = NULL;
  DEBUGA_SKYPE("CHANNEL TRANSMIT\n", SKYPIAX_P_LOG);
  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_send_dtmf(switch_core_session_t * session,
                                         const switch_dtmf_t * dtmf)
{
  private_t *tech_pvt = switch_core_session_get_private(session);
  switch_assert(tech_pvt != NULL);

  DEBUGA_SKYPE("DTMF: %c\n", SKYPIAX_P_LOG, dtmf->digit);

  skypiax_senddigit(tech_pvt, dtmf->digit);

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_read_frame(switch_core_session_t * session,
                                          switch_frame_t ** frame, switch_io_flag_t flags,
                                          int stream_id)
{
  switch_channel_t *channel = NULL;
  private_t *tech_pvt = NULL;
  switch_byte_t *data;

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);
  tech_pvt->read_frame.flags = SFF_NONE;
  *frame = NULL;

  if (!skypiax_audio_read(tech_pvt)) {

    ERRORA("skypiax_audio_read ERROR\n", SKYPIAX_P_LOG);

  } else {
    switch_set_flag_locked(tech_pvt, TFLAG_VOICE);
  }

  while (switch_test_flag(tech_pvt, TFLAG_IO)) {
    if (switch_test_flag(tech_pvt, TFLAG_BREAK)) {
      switch_clear_flag(tech_pvt, TFLAG_BREAK);
      DEBUGA_SKYPE("CHANNEL READ FRAME goto CNG\n", SKYPIAX_P_LOG);
      goto cng;
    }

    if (!switch_test_flag(tech_pvt, TFLAG_IO)) {
      DEBUGA_SKYPE("CHANNEL READ FRAME not IO\n", SKYPIAX_P_LOG);
      return SWITCH_STATUS_FALSE;
    }

    if (switch_test_flag(tech_pvt, TFLAG_IO) && switch_test_flag(tech_pvt, TFLAG_VOICE)) {
      switch_clear_flag_locked(tech_pvt, TFLAG_VOICE);
      if (!tech_pvt->read_frame.datalen) {
        DEBUGA_SKYPE("CHANNEL READ CONTINUE\n", SKYPIAX_P_LOG);
        continue;
      }
      *frame = &tech_pvt->read_frame;
#ifdef BIGENDIAN
      if (switch_test_flag(tech_pvt, TFLAG_LINEAR)) {
        switch_swap_linear((*frame)->data, (int) (*frame)->datalen / 2);
      }
#endif
      return SWITCH_STATUS_SUCCESS;
    }

    DEBUGA_SKYPE("CHANNEL READ no TFLAG_IO\n", SKYPIAX_P_LOG);
    return SWITCH_STATUS_FALSE;

  }

  DEBUGA_SKYPE("CHANNEL READ FALSE\n", SKYPIAX_P_LOG);
  return SWITCH_STATUS_FALSE;

cng:
  data = (switch_byte_t *) tech_pvt->read_frame.data;
  data[0] = 65;
  data[1] = 0;
  tech_pvt->read_frame.datalen = 2;
  tech_pvt->read_frame.flags = SFF_CNG;
  *frame = &tech_pvt->read_frame;
  return SWITCH_STATUS_SUCCESS;

}

static switch_status_t channel_write_frame(switch_core_session_t * session,
                                           switch_frame_t * frame, switch_io_flag_t flags,
                                           int stream_id)
{
  switch_channel_t *channel = NULL;
  private_t *tech_pvt = NULL;
  unsigned int sent;

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  if (!switch_test_flag(tech_pvt, TFLAG_IO)) {
    ERRORA("CIAPA \n", SKYPIAX_P_LOG);
    return SWITCH_STATUS_FALSE;
  }
#ifdef BIGENDIAN
  if (switch_test_flag(tech_pvt, TFLAG_LINEAR)) {
    switch_swap_linear(frame->data, (int) frame->datalen / 2);
  }
#endif

  sent = frame->datalen;
#ifdef WIN32
  switch_file_write(tech_pvt->audioskypepipe[1], frame->data, &sent);
#else /* WIN32 */
  sent = write(tech_pvt->audioskypepipe[1], frame->data, sent);
#endif /* WIN32 */
  if (sent != frame->datalen && sent != -1) {
    DEBUGA_SKYPE("CLI PIPE write %d\n", SKYPIAX_P_LOG, sent);
  }

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_answer_channel(switch_core_session_t * session)
{
  private_t *tech_pvt;
  switch_channel_t *channel = NULL;

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  DEBUGA_SKYPE("ANSWERED! \n", SKYPIAX_P_LOG);

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_receive_message(switch_core_session_t * session,
                                               switch_core_session_message_t * msg)
{
  switch_channel_t *channel;
  private_t *tech_pvt;

  channel = switch_core_session_get_channel(session);
  assert(channel != NULL);

  tech_pvt = (private_t *) switch_core_session_get_private(session);
  assert(tech_pvt != NULL);

  switch (msg->message_id) {
  case SWITCH_MESSAGE_INDICATE_ANSWER:
    {
      DEBUGA_SKYPE("MSG_ID=%d, TO BE ANSWERED!\n", SKYPIAX_P_LOG, msg->message_id);
      channel_answer_channel(session);
    }
    break;
  default:
    {
      DEBUGA_SKYPE("MSG_ID=%d\n", SKYPIAX_P_LOG, msg->message_id);
    }
    break;
  }

  return SWITCH_STATUS_SUCCESS;
}

static switch_status_t channel_receive_event(switch_core_session_t * session,
                                             switch_event_t * event)
{
  struct private_object *tech_pvt = switch_core_session_get_private(session);
  char *body = switch_event_get_body(event);
  switch_assert(tech_pvt != NULL);

  if (!body) {
    body = "";
  }

  WARNINGA("event: |||%s|||\n", SKYPIAX_P_LOG, body);

  return SWITCH_STATUS_SUCCESS;
}

switch_state_handler_table_t skypiax_state_handlers = {
  /*.on_init */ channel_on_init,
  /*.on_routing */ channel_on_routing,
  /*.on_execute */ channel_on_execute,
  /*.on_hangup */ channel_on_hangup,
  /*.on_exchange_media */ channel_on_exchange_media,
  /*.on_soft_execute */ channel_on_soft_execute
};

switch_io_routines_t skypiax_io_routines = {
  /*.outgoing_channel */ channel_outgoing_channel,
  /*.read_frame */ channel_read_frame,
  /*.write_frame */ channel_write_frame,
  /*.kill_channel */ channel_kill_channel,
  /*.send_dtmf */ channel_send_dtmf,
  /*.receive_message */ channel_receive_message,
  /*.receive_event */ channel_receive_event
};

static switch_call_cause_t channel_outgoing_channel(switch_core_session_t * session,
                                                    switch_event_t * var_event,
                                                    switch_caller_profile_t *
                                                    outbound_profile,
                                                    switch_core_session_t ** new_session,
                                                    switch_memory_pool_t ** pool,
                                                    switch_originate_flag_t flags)
{
	if ((*new_session = switch_core_session_request(skypiax_endpoint_interface, SWITCH_CALL_DIRECTION_OUTBOUND, pool)) != 0) {
    private_t *tech_pvt;
    switch_channel_t *channel;
    switch_caller_profile_t *caller_profile;
    char *rdest;

    switch_core_session_add_stream(*new_session, NULL);

    if ((tech_pvt =
         (private_t *) switch_core_session_alloc(*new_session, sizeof(private_t))) != 0) {
      int found = 0;
      char interface_name[256];

      if (strlen(outbound_profile->destination_number)) {
        int i;
        char *slash;

        strncpy(interface_name, outbound_profile->destination_number, 255);
        slash = strrchr(interface_name, '/');
        *slash = '\0';

        if (strncmp("ANY", interface_name, strlen(interface_name)) == 0) {
          /* we've been asked for the "ANY" interface, let's find the first idle interface */
          DEBUGA_SKYPE("Finding one available skype interface\n", SKYPIAX_P_LOG);
          tech_pvt = find_available_skypiax_interface();
          if (tech_pvt)
            found = 1;
        }
        for (i = 0; !found && i < SKYPIAX_MAX_INTERFACES; i++) {
          /* we've been asked for a normal interface name, or we have not found idle interfaces to serve as the "ANY" interface */
          if (strlen(globals.SKYPIAX_INTERFACES[i].name)
              &&
              (strncmp
               (globals.SKYPIAX_INTERFACES[i].name, interface_name,
                strlen(interface_name)) == 0)) {
            if (strlen(globals.SKYPIAX_INTERFACES[i].session_uuid_str)) {
              DEBUGA_SKYPE
                ("globals.SKYPIAX_INTERFACES[%d].name=|||%s||| session_uuid_str=|||%s||| is BUSY\n",
                 SKYPIAX_P_LOG, i, globals.SKYPIAX_INTERFACES[i].name,
                 globals.SKYPIAX_INTERFACES[i].session_uuid_str);
              switch_core_session_destroy(new_session);
              return SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE;
            }

            DEBUGA_SKYPE("globals.SKYPIAX_INTERFACES[%d].name=|||%s|||?\n", SKYPIAX_P_LOG,
                         i, globals.SKYPIAX_INTERFACES[i].name);
            tech_pvt = &globals.SKYPIAX_INTERFACES[i];
            found = 1;
            break;
          }

        }

      } else {
        ERRORA("Doh! no destination number?\n", SKYPIAX_P_LOG);
        switch_core_session_destroy(new_session);
        return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
      }

      if (!found) {
        ERRORA("Doh! no matching interface for |||%s|||?\n", SKYPIAX_P_LOG,
               interface_name);
        switch_core_session_destroy(new_session);
        return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;

      }
      channel = switch_core_session_get_channel(*new_session);
      skypiax_tech_init(tech_pvt, *new_session);
    } else {
      ERRORA("Hey where is my memory pool?\n", SKYPIAX_P_LOG);
      switch_core_session_destroy(new_session);
      return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
    }

    if (outbound_profile) {
      char name[128];

      snprintf(name, sizeof(name), "skypiax/%s", outbound_profile->destination_number);
      //snprintf(name, sizeof(name), "skypiax/%s", tech_pvt->name);
      switch_channel_set_name(channel, name);
      caller_profile = switch_caller_profile_clone(*new_session, outbound_profile);
      switch_channel_set_caller_profile(channel, caller_profile);
      tech_pvt->caller_profile = caller_profile;
    } else {
      ERRORA("Doh! no caller profile\n", SKYPIAX_P_LOG);
      switch_core_session_destroy(new_session);
      return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
    }

    rdest = strchr(caller_profile->destination_number, '/');
    *rdest++ = '\0';

    skypiax_call(tech_pvt, rdest, 30);

    switch_copy_string(tech_pvt->session_uuid_str,
                       switch_core_session_get_uuid(*new_session),
                       sizeof(tech_pvt->session_uuid_str));
    caller_profile = tech_pvt->caller_profile;
    caller_profile->destination_number = rdest;

    switch_channel_set_flag(channel, CF_OUTBOUND);
    switch_set_flag_locked(tech_pvt, TFLAG_OUTBOUND);
    switch_channel_set_state(channel, CS_INIT);
    return SWITCH_CAUSE_SUCCESS;
  }

  return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
}

/*!
 * \brief This thread runs during a call, and monitor the interface for signaling, like hangup, caller id, etc most of signaling is handled inside the skypiax_signaling_read function
 *
 */
static void *SWITCH_THREAD_FUNC skypiax_signaling_thread_func(switch_thread_t * thread,
                                                              void *obj)
{
  private_t *tech_pvt = obj;
  int res;
  int forever = 1;

  DEBUGA_SKYPE("In skypiax_signaling_thread_func: started, p=%p\n", SKYPIAX_P_LOG,
               (void *) tech_pvt);

  while (forever) {
    if (!running)
      break;
    res = skypiax_signaling_read(tech_pvt);
    if (res == CALLFLOW_INCOMING_HANGUP) {
      switch_core_session_t *session = NULL;
      //private_t *tech_pvt = NULL;
      switch_channel_t *channel = NULL;

      DEBUGA_SKYPE("skype call ended\n", SKYPIAX_P_LOG);

      if (tech_pvt) {
        session = switch_core_session_locate(tech_pvt->session_uuid_str);

        if (session) {
          channel = switch_core_session_get_channel(session);
          if (channel) {
            switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
            switch_core_session_rwunlock(session);
          } else {
            ERRORA("no channel?\n", SKYPIAX_P_LOG);
            switch_core_session_rwunlock(session);
          }
        } else {
          DEBUGA_SKYPE("no session\n", SKYPIAX_P_LOG);
        }
      } else {
        ERRORA("no tech_pvt?\n", SKYPIAX_P_LOG);
      }
      tech_pvt->interface_state = SKYPIAX_STATE_DOWN;
      memset(tech_pvt->session_uuid_str, '\0', sizeof(tech_pvt->session_uuid_str));
    }
  }
  return NULL;
}

static switch_status_t load_config(void)
{
  char *cf = "skypiax.conf";
  switch_xml_t cfg, xml, global_settings, param, interfaces, myinterface;
  private_t *tech_pvt = NULL;

  switch_mutex_init(&globals.mutex, SWITCH_MUTEX_NESTED, skypiax_module_pool);
  if (!(xml = switch_xml_open_cfg(cf, &cfg, NULL))) {
    ERRORA("open of %s failed\n", SKYPIAX_P_LOG, cf);
    running = 0;
    return SWITCH_STATUS_TERM;
  }

  if ((global_settings = switch_xml_child(cfg, "global_settings"))) {
    for (param = switch_xml_child(global_settings, "param"); param; param = param->next) {
      char *var = (char *) switch_xml_attr_soft(param, "name");
      char *val = (char *) switch_xml_attr_soft(param, "value");

      if (!strcasecmp(var, "debug")) {
        DEBUGA_SKYPE("globals.debug=%d\n", SKYPIAX_P_LOG, globals.debug);
        globals.debug = atoi(val);
        DEBUGA_SKYPE("globals.debug=%d\n", SKYPIAX_P_LOG, globals.debug);
      } else if (!strcasecmp(var, "hold-music")) {
        switch_set_string(globals.hold_music, val);
        DEBUGA_SKYPE("globals.hold_music=%s\n", SKYPIAX_P_LOG, globals.hold_music);
      } else if (!strcmp(var, "port")) {
        globals.port = atoi(val);
        DEBUGA_SKYPE("globals.port=%d\n", SKYPIAX_P_LOG, globals.port);
      } else if (!strcmp(var, "codec-master")) {
        if (!strcasecmp(val, "us")) {
          switch_set_flag(&globals, GFLAG_MY_CODEC_PREFS);
        }
        DEBUGA_SKYPE("codec-master globals.debug=%d\n", SKYPIAX_P_LOG, globals.debug);
      } else if (!strcmp(var, "dialplan")) {
        set_global_dialplan(val);
        DEBUGA_SKYPE("globals.dialplan=%s\n", SKYPIAX_P_LOG, globals.dialplan);
      } else if (!strcmp(var, "destination")) {
        set_global_destination(val);
        DEBUGA_SKYPE("globals.destination=%s\n", SKYPIAX_P_LOG, globals.destination);
      } else if (!strcmp(var, "context")) {
        set_global_context(val);
        DEBUGA_SKYPE("globals.context=%s\n", SKYPIAX_P_LOG, globals.context);
      } else if (!strcmp(var, "codec-prefs")) {
        set_global_codec_string(val);
        DEBUGA_SKYPE("globals.codec_string=%s\n", SKYPIAX_P_LOG, globals.codec_string);
        globals.codec_order_last =
          switch_separate_string(globals.codec_string, ',', globals.codec_order,
                                 SWITCH_MAX_CODECS);
      } else if (!strcmp(var, "codec-rates")) {
        set_global_codec_rates_string(val);
        DEBUGA_SKYPE("globals.codec_rates_string=%s\n", SKYPIAX_P_LOG,
                     globals.codec_rates_string);
        globals.codec_rates_last =
          switch_separate_string(globals.codec_rates_string, ',', globals.codec_rates,
                                 SWITCH_MAX_CODECS);
      }

    }
  }

  if ((interfaces = switch_xml_child(cfg, "per_interface_settings"))) {
    int i = 0;

    for (myinterface = switch_xml_child(interfaces, "interface"); myinterface;
         myinterface = myinterface->next) {
      char *id = (char *) switch_xml_attr(myinterface, "id");
      char *name = (char *) switch_xml_attr(myinterface, "name");
      char *context = "default";
      char *dialplan = "XML";
      char *destination = "5000";
      char *tonegroup = NULL;
      char *digit_timeout = NULL;
      char *max_digits = NULL;
      char *hotline = NULL;
      char *dial_regex = NULL;
      char *hold_music = NULL;
      char *fail_dial_regex = NULL;
      char *enable_callerid = "true";
      char *X11_display = NULL;
      char *tcp_cli_port = NULL;
      char *tcp_srv_port = NULL;
      char *skype_user = NULL;

      uint32_t interface_id = 0, to = 0, max = 0;

      tech_pvt = NULL;

      for (param = switch_xml_child(myinterface, "param"); param; param = param->next) {
        char *var = (char *) switch_xml_attr_soft(param, "name");
        char *val = (char *) switch_xml_attr_soft(param, "value");

        if (!strcasecmp(var, "tonegroup")) {
          tonegroup = val;
        } else if (!strcasecmp(var, "digit_timeout") || !strcasecmp(var, "digit-timeout")) {
          digit_timeout = val;
        } else if (!strcasecmp(var, "context")) {
          context = val;
        } else if (!strcasecmp(var, "dialplan")) {
          dialplan = val;
        } else if (!strcasecmp(var, "destination")) {
          destination = val;
        } else if (!strcasecmp(var, "dial-regex")) {
          dial_regex = val;
        } else if (!strcasecmp(var, "enable-callerid")) {
          enable_callerid = val;
        } else if (!strcasecmp(var, "fail-dial-regex")) {
          fail_dial_regex = val;
        } else if (!strcasecmp(var, "hold-music")) {
          hold_music = val;
        } else if (!strcasecmp(var, "skype_user")) {
          skype_user = val;
        } else if (!strcasecmp(var, "tcp_cli_port")) {
          tcp_cli_port = val;
        } else if (!strcasecmp(var, "tcp_srv_port")) {
          tcp_srv_port = val;
        } else if (!strcasecmp(var, "X11-display") || !strcasecmp(var, "X11_display")) {
          X11_display = val;
        } else if (!strcasecmp(var, "max_digits") || !strcasecmp(var, "max-digits")) {
          max_digits = val;
        } else if (!strcasecmp(var, "hotline")) {
          hotline = val;
        }

      }
      if (!skype_user) {
        ERRORA("interface missing REQUIRED param 'skype_user'\n", SKYPIAX_P_LOG);
        continue;
      }

      if (!X11_display) {
        ERRORA("interface missing REQUIRED param 'X11_display'\n", SKYPIAX_P_LOG);
        continue;
      }
      if (!tcp_cli_port) {
        ERRORA("interface missing REQUIRED param 'tcp_cli_port'\n", SKYPIAX_P_LOG);
        continue;
      }

      if (!tcp_srv_port) {
        ERRORA("interface missing REQUIRED param 'tcp_srv_port'\n", SKYPIAX_P_LOG);
        continue;
      }
      if (!id) {
        ERRORA("interface missing REQUIRED param 'id'\n", SKYPIAX_P_LOG);
        continue;
      }
      if (switch_is_number(id)) {
        interface_id = atoi(id);
        DEBUGA_SKYPE("interface_id=%d\n", SKYPIAX_P_LOG, interface_id);
      } else {
        ERRORA("interface param 'id' MUST be a number, now id='%s'\n", SKYPIAX_P_LOG, id);
        continue;
      }

      if (!name) {
        WARNINGA("interface missing param 'name', not nice, but works\n", SKYPIAX_P_LOG);
      }

      if (!tonegroup) {
        tonegroup = "us";
      }

      if (digit_timeout) {
        to = atoi(digit_timeout);
      }

      if (max_digits) {
        max = atoi(max_digits);
      }

      if (name) {
        DEBUGA_SKYPE("name=%s\n", SKYPIAX_P_LOG, name);
      }
#ifndef WIN32
      if (!XInitThreads()) {
        ERRORA("Not initialized XInitThreads!\n", SKYPIAX_P_LOG);
      } else {
        DEBUGA_SKYPE("Initialized XInitThreads!\n", SKYPIAX_P_LOG);
      }
      switch_sleep(100);
#endif /* WIN32 */

      if (interface_id && interface_id < SKYPIAX_MAX_INTERFACES) {
        private_t newconf;
        switch_threadattr_t *skypiax_api_thread_attr = NULL;
        switch_threadattr_t *skypiax_signaling_thread_attr = NULL;

        memset(&newconf, '\0', sizeof(newconf));
        globals.SKYPIAX_INTERFACES[interface_id] = newconf;

        tech_pvt = &globals.SKYPIAX_INTERFACES[interface_id];

        switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].interface_id, id);
        if (name) {
          switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].name, name);
        } else {
          switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].name, "N/A");
        }
        DEBUGA_SKYPE("CONFIGURING interface_id=%d\n", SKYPIAX_P_LOG, interface_id);
#ifdef WIN32
        globals.SKYPIAX_INTERFACES[interface_id].tcp_cli_port =
          (unsigned short) atoi(tcp_cli_port);
        globals.SKYPIAX_INTERFACES[interface_id].tcp_srv_port =
          (unsigned short) atoi(tcp_srv_port);
#else /* WIN32 */
        globals.SKYPIAX_INTERFACES[interface_id].tcp_cli_port = atoi(tcp_cli_port);
        globals.SKYPIAX_INTERFACES[interface_id].tcp_srv_port = atoi(tcp_srv_port);
#endif /* WIN32 */
        switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].X11_display,
                          X11_display);
        switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].skype_user,
                          skype_user);
        switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].context, context);
        switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].dialplan, dialplan);
        switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].destination,
                          destination);
        switch_set_string(globals.SKYPIAX_INTERFACES[interface_id].context, context);

        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].X11_display=%s\n",
           SKYPIAX_P_LOG, interface_id,
           globals.SKYPIAX_INTERFACES[interface_id].X11_display);
        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].skype_user=%s\n",
           SKYPIAX_P_LOG, interface_id,
           globals.SKYPIAX_INTERFACES[interface_id].skype_user);
        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].tcp_cli_port=%d\n",
           SKYPIAX_P_LOG, interface_id,
           globals.SKYPIAX_INTERFACES[interface_id].tcp_cli_port);
        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].tcp_srv_port=%d\n",
           SKYPIAX_P_LOG, interface_id,
           globals.SKYPIAX_INTERFACES[interface_id].tcp_srv_port);
        DEBUGA_SKYPE("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].name=%s\n",
                     SKYPIAX_P_LOG, interface_id,
                     globals.SKYPIAX_INTERFACES[interface_id].name);
        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].context=%s\n",
           SKYPIAX_P_LOG, interface_id, globals.SKYPIAX_INTERFACES[interface_id].context);
        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].dialplan=%s\n",
           SKYPIAX_P_LOG, interface_id,
           globals.SKYPIAX_INTERFACES[interface_id].dialplan);
        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].destination=%s\n",
           SKYPIAX_P_LOG, interface_id,
           globals.SKYPIAX_INTERFACES[interface_id].destination);
        DEBUGA_SKYPE
          ("interface_id=%d globals.SKYPIAX_INTERFACES[interface_id].context=%s\n",
           SKYPIAX_P_LOG, interface_id, globals.SKYPIAX_INTERFACES[interface_id].context);
        NOTICA("STARTING interface_id=%d\n", SKYPIAX_P_LOG, interface_id);

        switch_threadattr_create(&skypiax_api_thread_attr, skypiax_module_pool);
        switch_threadattr_stacksize_set(skypiax_api_thread_attr, SWITCH_THREAD_STACKSIZE);
        switch_thread_create(&globals.SKYPIAX_INTERFACES[interface_id].skypiax_api_thread,
                             skypiax_api_thread_attr, skypiax_do_skypeapi_thread,
                             &globals.SKYPIAX_INTERFACES[interface_id],
                             skypiax_module_pool);

        switch_sleep(100000);

        switch_threadattr_create(&skypiax_signaling_thread_attr, skypiax_module_pool);
        switch_threadattr_stacksize_set(skypiax_signaling_thread_attr,
                                        SWITCH_THREAD_STACKSIZE);
        switch_thread_create(&globals.SKYPIAX_INTERFACES[interface_id].
                             skypiax_signaling_thread, skypiax_signaling_thread_attr,
                             skypiax_signaling_thread_func,
                             &globals.SKYPIAX_INTERFACES[interface_id],
                             skypiax_module_pool);

        switch_sleep(100000);

        skypiax_audio_init(&globals.SKYPIAX_INTERFACES[interface_id]);

        i = 0;
        while (globals.SKYPIAX_INTERFACES[interface_id].SkypiaxHandles.api_connected == 0 && running && i < 60000) {    // 60sec FIXME
          switch_sleep(1000);
          i++;
        }
        if (globals.SKYPIAX_INTERFACES[interface_id].SkypiaxHandles.api_connected) {
          NOTICA("STARTED interface_id=%d\n", SKYPIAX_P_LOG, interface_id);
        } else {
          ERRORA("FAILED to start interface_id=%d\n", SKYPIAX_P_LOG, interface_id);
          return SWITCH_STATUS_FALSE;
        }

      } else {
        ERRORA("interface id %d is higher than SKYPIAX_MAX_INTERFACES (%d)\n",
               SKYPIAX_P_LOG, interface_id, SKYPIAX_MAX_INTERFACES);
        continue;
      }

    }

    for (i = 0; i < SKYPIAX_MAX_INTERFACES; i++) {
      if (strlen(globals.SKYPIAX_INTERFACES[i].name)) {
        tech_pvt = &globals.SKYPIAX_INTERFACES[i];

        DEBUGA_SKYPE("i=%d globals.SKYPIAX_INTERFACES[%d].interface_id=%s\n",
                     SKYPIAX_P_LOG, i, i, globals.SKYPIAX_INTERFACES[i].interface_id);
        DEBUGA_SKYPE("i=%d globals.SKYPIAX_INTERFACES[%d].X11_display=%s\n",
                     SKYPIAX_P_LOG, i, i, globals.SKYPIAX_INTERFACES[i].X11_display);
        DEBUGA_SKYPE("i=%d globals.SKYPIAX_INTERFACES[%d].name=%s\n", SKYPIAX_P_LOG, i, i,
                     globals.SKYPIAX_INTERFACES[i].name);
        DEBUGA_SKYPE("i=%d globals.SKYPIAX_INTERFACES[%d].context=%s\n", SKYPIAX_P_LOG, i,
                     i, globals.SKYPIAX_INTERFACES[i].context);
        DEBUGA_SKYPE("i=%d globals.SKYPIAX_INTERFACES[%d].dialplan=%s\n", SKYPIAX_P_LOG,
                     i, i, globals.SKYPIAX_INTERFACES[i].dialplan);
        DEBUGA_SKYPE("i=%d globals.SKYPIAX_INTERFACES[%d].destination=%s\n",
                     SKYPIAX_P_LOG, i, i, globals.SKYPIAX_INTERFACES[i].destination);
        DEBUGA_SKYPE("i=%d globals.SKYPIAX_INTERFACES[%d].context=%s\n", SKYPIAX_P_LOG, i,
                     i, globals.SKYPIAX_INTERFACES[i].context);
      }
    }
  }

  switch_xml_free(xml);

  return SWITCH_STATUS_SUCCESS;
}

SWITCH_MODULE_LOAD_FUNCTION(mod_skypiax_load)
{
  skypiax_module_pool = pool;

  memset(&globals, '\0', sizeof(globals));

  running = 1;

  if (load_config() != SWITCH_STATUS_SUCCESS)
    return SWITCH_STATUS_FALSE;

  *module_interface = switch_loadable_module_create_module_interface(pool, modname);
  skypiax_endpoint_interface =
    switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE);
  skypiax_endpoint_interface->interface_name = "skypiax";
  skypiax_endpoint_interface->io_routines = &skypiax_io_routines;
  skypiax_endpoint_interface->state_handler = &skypiax_state_handlers;

  if (running)
    /* indicate that the module should continue to be loaded */
    return SWITCH_STATUS_SUCCESS;
  else
    return SWITCH_STATUS_FALSE;
}

SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_skypiax_shutdown)
{
  int x = 100;
  private_t *tech_pvt = NULL;
  switch_status_t status;
  unsigned int howmany = 8;
  int interface_id;

  running = 0;

  for (interface_id = 0; interface_id < SKYPIAX_MAX_INTERFACES; interface_id++) {
    tech_pvt = &globals.SKYPIAX_INTERFACES[interface_id];

    if (globals.SKYPIAX_INTERFACES[interface_id].skypiax_signaling_thread) {
#ifdef WIN32
      switch_file_write(tech_pvt->SkypiaxHandles.fdesc[1], "sciutati", &howmany);   // let's the controldev_thread die
#else /* WIN32 */
      howmany = write(tech_pvt->SkypiaxHandles.fdesc[1], "sciutati", howmany);
#endif /* WIN32 */
    }

    if (globals.SKYPIAX_INTERFACES[interface_id].skypiax_api_thread) {
#ifdef WIN32
      if (SendMessage(tech_pvt->SkypiaxHandles.win32_hInit_MainWindowHandle, WM_DESTROY, 0, 0) == FALSE) {  // let's the skypiax_api_thread_func die
        DEBUGA_SKYPE
          ("got FALSE here, thread probably was already dead. GetLastError returned: %d\n",
           SKYPIAX_P_LOG, GetLastError());
      }
#else
      XEvent e;
      Atom atom1 =
        XInternAtom(tech_pvt->SkypiaxHandles.disp, "SKYPECONTROLAPI_MESSAGE_BEGIN",
                    False);
      memset(&e, 0, sizeof(e));
      e.xclient.type = ClientMessage;
      e.xclient.message_type = atom1;   /*  leading message */
      e.xclient.display = tech_pvt->SkypiaxHandles.disp;
      e.xclient.window = tech_pvt->SkypiaxHandles.skype_win;
      e.xclient.format = 8;

      XSendEvent(tech_pvt->SkypiaxHandles.disp, tech_pvt->SkypiaxHandles.win, False, 0,
                 &e);
      XSync(tech_pvt->SkypiaxHandles.disp, False);
#endif
    }
    while (x) {
      x--;
      switch_yield(20000);
    }
    if (globals.SKYPIAX_INTERFACES[interface_id].skypiax_signaling_thread) {
      switch_thread_join(&status,
                         globals.SKYPIAX_INTERFACES[interface_id].
                         skypiax_signaling_thread);
    }
    if (globals.SKYPIAX_INTERFACES[interface_id].skypiax_api_thread) {
      switch_thread_join(&status,
                         globals.SKYPIAX_INTERFACES[interface_id].skypiax_api_thread);
    }
  }

  switch_safe_free(globals.dialplan);
  switch_safe_free(globals.context);
  switch_safe_free(globals.destination);
  switch_safe_free(globals.codec_string);
  switch_safe_free(globals.codec_rates_string);

  return SWITCH_STATUS_SUCCESS;
}

void *SWITCH_THREAD_FUNC skypiax_do_tcp_srv_thread(switch_thread_t * thread, void *obj)
{
  return skypiax_do_tcp_srv_thread_func(obj);
}
void *SWITCH_THREAD_FUNC skypiax_do_tcp_cli_thread(switch_thread_t * thread, void *obj)
{
  return skypiax_do_tcp_cli_thread_func(obj);
}
void *SWITCH_THREAD_FUNC skypiax_do_skypeapi_thread(switch_thread_t * thread, void *obj)
{
  return skypiax_do_skypeapi_thread_func(obj);
}

int dtmf_received(private_t * tech_pvt, char *value)
{
  switch_core_session_t *session = NULL;
  switch_channel_t *channel = NULL;

  session = switch_core_session_locate(tech_pvt->session_uuid_str);
  channel = switch_core_session_get_channel(session);

  if (channel) {
    switch_dtmf_t dtmf = { (char) value[0], switch_core_default_dtmf_duration(0) };
    DEBUGA_SKYPE("received DTMF %c on channel %s\n", SKYPIAX_P_LOG, dtmf.digit,
                 switch_channel_get_name(channel));
    switch_mutex_lock(tech_pvt->flag_mutex);
    //FIXME: why sometimes DTMFs from here do not seems to be get by FS?
    switch_channel_queue_dtmf(channel, &dtmf);
    switch_set_flag(tech_pvt, TFLAG_DTMF);
    switch_mutex_unlock(tech_pvt->flag_mutex);
  } else {
    WARNINGA("received %c DTMF, but no channel?\n", SKYPIAX_P_LOG, value[0]);
  }
  switch_core_session_rwunlock(session);

  return 0;
}

int start_audio_threads(private_t * tech_pvt)
{
  switch_threadattr_t *thd_attr = NULL;

  switch_threadattr_create(&thd_attr, skypiax_module_pool);
  switch_threadattr_detach_set(thd_attr, 1);
  switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
  switch_thread_create(&tech_pvt->tcp_srv_thread, thd_attr, skypiax_do_tcp_srv_thread,
                       tech_pvt, skypiax_module_pool);
  DEBUGA_SKYPE("started tcp_srv_thread thread.\n", SKYPIAX_P_LOG);

  switch_threadattr_create(&thd_attr, skypiax_module_pool);
  switch_threadattr_detach_set(thd_attr, 1);
  switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
  switch_thread_create(&tech_pvt->tcp_cli_thread, thd_attr, skypiax_do_tcp_cli_thread,
                       tech_pvt, skypiax_module_pool);
  DEBUGA_SKYPE("started tcp_cli_thread thread.\n", SKYPIAX_P_LOG);
  switch_sleep(100000);

  return 0;
}

int new_inbound_channel(private_t * tech_pvt)
{
  switch_core_session_t *session = NULL;
  switch_channel_t *channel = NULL;

  if ((session = switch_core_session_request(skypiax_endpoint_interface, SWITCH_CALL_DIRECTION_INBOUND, NULL)) != 0) {
    switch_core_session_add_stream(session, NULL);
    channel = switch_core_session_get_channel(session);
    skypiax_tech_init(tech_pvt, session);

    if ((tech_pvt->caller_profile =
         switch_caller_profile_new(switch_core_session_get_pool(session), "skypiax",
                                   tech_pvt->dialplan, tech_pvt->callid_name,
                                   tech_pvt->callid_number, NULL, NULL, NULL, NULL,
                                   "mod_skypiax", tech_pvt->context,
                                   tech_pvt->destination)) != 0) {
      char name[128];
      //switch_snprintf(name, sizeof(name), "skypiax/%s/%s", tech_pvt->name, tech_pvt->caller_profile->destination_number);
      switch_snprintf(name, sizeof(name), "skypiax/%s", tech_pvt->name);
      switch_channel_set_name(channel, name);
      switch_channel_set_caller_profile(channel, tech_pvt->caller_profile);
    }
    switch_channel_set_state(channel, CS_INIT);
    if (switch_core_session_thread_launch(session) != SWITCH_STATUS_SUCCESS) {
      ERRORA("Error spawning thread\n", SKYPIAX_P_LOG);
      switch_core_session_destroy(&session);
    }
  }
  switch_channel_mark_answered(channel);

  DEBUGA_SKYPE("Here\n", SKYPIAX_P_LOG);

  return 0;
}

int remote_party_is_ringing(private_t * tech_pvt)
{
  switch_core_session_t *session = NULL;
  switch_channel_t *channel = NULL;

  if (strlen(tech_pvt->session_uuid_str)) {
    session = switch_core_session_locate(tech_pvt->session_uuid_str);
  } else {
    ERRORA("No session???\n", SKYPIAX_P_LOG);
  }
  if (session) {
    channel = switch_core_session_get_channel(session);
  } else {
    ERRORA("No session???\n", SKYPIAX_P_LOG);
  }
  if (channel) {
    switch_channel_mark_ring_ready(channel);
    DEBUGA_SKYPE("skype_call: REMOTE PARTY RINGING\n", SKYPIAX_P_LOG);
  } else {
    ERRORA("No channel???\n", SKYPIAX_P_LOG);
  }

  switch_core_session_rwunlock(session);

  return 0;
}


int remote_party_is_early_media(private_t * tech_pvt)
{
  switch_core_session_t *session = NULL;
  switch_channel_t *channel = NULL;

  if (strlen(tech_pvt->session_uuid_str)) {
    session = switch_core_session_locate(tech_pvt->session_uuid_str);
  } else {
    ERRORA("No session???\n", SKYPIAX_P_LOG);
  }
  if (session) {
    channel = switch_core_session_get_channel(session);
    switch_core_session_add_stream(session, NULL);
  } else {
    ERRORA("No session???\n", SKYPIAX_P_LOG);
  }
  if (channel) {
    //switch_channel_mark_pre_answered(channel);
    NOTICA("skype_call: REMOTE PARTY EARLY MEDIA, we will pass you the audio, just the code is not yet written :-)\n", SKYPIAX_P_LOG);
  } else {
    ERRORA("No channel???\n", SKYPIAX_P_LOG);
  }

  switch_core_session_rwunlock(session);

  return 0;
}

int outbound_channel_answered(private_t * tech_pvt)
{
  switch_core_session_t *session = NULL;
  switch_channel_t *channel = NULL;

  if (strlen(tech_pvt->session_uuid_str)) {
    session = switch_core_session_locate(tech_pvt->session_uuid_str);
  } else {
    ERRORA("No session???\n", SKYPIAX_P_LOG);
  }
  if (session) {
    channel = switch_core_session_get_channel(session);
  } else {
    ERRORA("No session???\n", SKYPIAX_P_LOG);
  }
  if (channel) {
    switch_channel_mark_answered(channel);
    //DEBUGA_SKYPE("skype_call: %s, answered\n", SKYPIAX_P_LOG, id);
  } else {
    ERRORA("No channel???\n", SKYPIAX_P_LOG);
  }

  switch_core_session_rwunlock(session);
  DEBUGA_SKYPE("HERE!\n", SKYPIAX_P_LOG);

  return 0;
}

private_t *find_available_skypiax_interface(void)
{
  private_t *tech_pvt = NULL;
  int found = 0;
  int i;

  for (i = 0; !found && i < SKYPIAX_MAX_INTERFACES; i++) {
    if (strlen(globals.SKYPIAX_INTERFACES[i].name)) {
      int skype_state = 0;

      tech_pvt = &globals.SKYPIAX_INTERFACES[i];
      skype_state = tech_pvt->interface_state;
      DEBUGA_SKYPE("skype interface: %d, name: %s, state: %d\n", SKYPIAX_P_LOG, i,
                   globals.SKYPIAX_INTERFACES[i].name, skype_state);
      if (SKYPIAX_STATE_DOWN == skype_state || 0 == skype_state) {
        found = 1;
        break;
      }
    }
  }

  if (found)
    return tech_pvt;
  else
    return NULL;
}

/* For Emacs:
 * Local Variables:
 * mode:c
 * indent-tabs-mode:t
 * tab-width:4
 * c-basic-offset:4
 * End:
 * For VIM:
 * vim:set softtabstop=4 shiftwidth=4 tabstop=4 expandtab:
 */
