/*

 * socks5.c

 *

 * Copyrigth (C) 2010 Nicolas Cornu <nicolas.cornu@ensi-bourges.fr>

 *

 * This program 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 Foundation; either version 2 of the License, or (at

 * your option) any later version.

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#include "config.h"

#include <glib.h>

#include <gio/gio.h>

#include <sys/types.h>

#include <ifaddrs.h>

#include <net/if.h>

#include <netinet/in.h>

#include <mcabber/xmpp.h>

#include <mcabber/modules.h>

#include <mcabber/utils.h>

#include <mcabber/xmpp_helper.h>

#include <mcabber/settings.h>

#include <mcabber/logprint.h>

#include <mcabber/hooks.h>

#include <jingle/jingle.h>

#include <jingle/check.h>

#include <jingle/register.h>

#include "socks5.h"

static gconstpointer newfrommessage(JingleContent *cn, GError **err);

static JingleHandleStatus handle(JingleAction action, gconstpointer data,

                                 LmMessageNode *node, GError **err);

static void tomessage(gconstpointer data, LmMessageNode *node);

static gconstpointer new(void);

// static void _send(session_content *sc, gconstpointer data, gchar *buf, gsize size);

static void init(session_content *sc);

static void end(session_content *sc, gconstpointer data);

static void handle_sock_io(GSocket *sock, GIOCondition cond, gpointer data);

static GSList *get_all_local_ips();

static gchar *gen_random_sid(void);

static gchar *gen_random_cid(void);

static void jingle_socks5_init(void);

static void jingle_socks5_uninit(void);

const gchar *deps[] = { "jingle", NULL };

static JingleTransportFuncs funcs = {

  .newfrommessage = newfrommessage,

  .handle         = handle,

  .tomessage      = tomessage,

  .new            = new,

  .send           = NULL,

  .init           = init,

  .end            = end

};

module_info_t  info_jingle_s5b = {

  .branch          = MCABBER_BRANCH,

  .api             = MCABBER_API_VERSION,

  .version         = PROJECT_VERSION,

  .description     = "Jingle SOCKS5 Bytestream (XEP-0260)\n",

  .requires        = deps,

  .init            = jingle_socks5_init,

  .uninit          = jingle_socks5_uninit,

  .next            = NULL,

};

static const gchar *jingle_s5b_types[] = {

  "assisted",

  "direct",

  "proxy",

  "tunnel",

  NULL

};

static const gchar *jingle_s5b_modes[] = {

  "tcp",

  "udp",

  NULL

};

typedef struct {

  GInetAddress *address;

  guint32       priority;

/**

 * @brief Linked list of candidates to send on session-initiate

 */

static gint index_in_array(const gchar *str, const gchar **array)

{

  gint i;

  for (i = 0; array[i]; i++) {

    if (!g_strcmp0(array[i], str)) {

      return i;

    }

  }

  return -1;

}

static gint prioritycmp(gconstpointer a, gconstpointer b)

{

  S5BCandidate *s1 = (S5BCandidate *)a, *s2 = (S5BCandidate *)b;

  if (s1->priority < s2->priority) {

    return 1;

  } else if (s1->priority > s2->priority) {

    return -1;

  } else {

    return 0;

  }

}

/**

 * @brief Parse a list of <candidate> elements

 * @return a list of S5BCandidate

 */

static GSList *parse_candidates(LmMessageNode *node)

{

  LmMessageNode *node2;

  for (node2 = node->children; node2; node2 = node2->next) {

    if (g_strcmp0(node->name, "candidate"))

        continue;

    const gchar *portstr, *prioritystr, *typestr;

    S5BCandidate *cand = g_new0(S5BCandidate, 1);

    cand->cid    = g_strdup(lm_message_node_get_attribute(node2, "cid"));

    cand->host   = g_strdup(lm_message_node_get_attribute(node2, "host"));

    cand->jid    = g_strdup(lm_message_node_get_attribute(node2, "jid"));

    portstr      = lm_message_node_get_attribute(node2, "port");

    prioritystr  = lm_message_node_get_attribute(node2, "priority");

    typestr      = lm_message_node_get_attribute(node2, "type");

    if (!cand->cid || !cand->host || !cand->jid || !prioritystr) {

      g_free(cand);

      continue;

    }

    cand->port     = g_ascii_strtoull(portstr, NULL, 10);

    cand->priority = g_ascii_strtoull(prioritystr, NULL, 10);

    cand->type     = index_in_array(typestr, jingle_s5b_types);

    if (cand->type == -1) {

      g_free(cand);

      continue;

    }

    list = g_slist_prepend(list, cand);

  }

  list = g_slist_sort(list, prioritycmp);

  return list;

}

static gconstpointer newfrommessage(JingleContent *cn, GError **err)

{

  JingleS5B *js5b;

  const gchar *modestr;

  js5b = g_new0(JingleS5B, 1);

  modestr    = lm_message_node_get_attribute(node, "mode");

  js5b->mode = index_in_array(modestr, jingle_s5b_modes);

  js5b->sid  = g_strdup(lm_message_node_get_attribute(node, "sid"));

  if (!js5b->sid) {

    g_set_error(err, JINGLE_CHECK_ERROR, JINGLE_CHECK_ERROR_MISSING,

                "an attribute of the transport element is missing");

    g_free(js5b);

    return NULL;

  }

  js5b->candidates = parse_candidates(node);

  return (gconstpointer) js5b;

}

static gconstpointer new(void)

{

  JingleS5B *js5b = g_new0(JingleS5B, 1);

  js5b->mode = JINGLE_S5B_TCP;

  js5b->sid  = gen_random_sid();

  return js5b;

}

static JingleHandleStatus

handle_session_accept(JingleS5B *js5b, LmMessageNode *node, GError **err)

{

  js5b->candidates = parse_candidates(node);

  return JINGLE_STATUS_HANDLED;

}

static JingleHandleStatus handle(JingleAction action, gconstpointer data,

                                 LmMessageNode *node, GError **err)

{

  JingleS5B *js5b = (JingleS5B *)data;

  if (action == JINGLE_SESSION_ACCEPT) {

    return handle_session_accept(js5b, node, err);

  }

  return JINGLE_STATUS_NOT_HANDLED;

}

static void tomessage(gconstpointer data, LmMessageNode *node)

{

  JingleS5B *js5 = (JingleS5B *)data;

  S5BCandidate *js5c;

  LmMessageNode *node2, *node3;

  gchar *port;

  gchar *priority;

  GSList *el;

  if (lm_message_node_get_child(node, "transport") != NULL)

    return;

  node2 = lm_message_node_add_child(node, "transport", NULL);

  lm_message_node_set_attributes(node2, "xmlns", NS_JINGLE_TRANSPORT_SOCKS5,

                                 "sid", js5->sid,

                                 "mode", jingle_s5b_modes[js5->mode],

                                 NULL);

  for (el = js5->ourcandidates; el; el = el->next) {

    js5c = (S5BCandidate*) el->data;

    node3 = lm_message_node_add_child(node2, "candidate", NULL);

    port = g_strdup_printf("%" G_GUINT16_FORMAT, js5c->port);

    priority = g_strdup_printf("%" G_GUINT64_FORMAT, js5c->priority);

    lm_message_node_set_attributes(node3, "cid", js5c->cid,

                                   "host", js5c->host,

                                   "jid", js5c->jid,

                                   "port", port,

                                   "priority", priority,

                                   "type", jingle_s5b_types[js5c->type],

                                   NULL);

    g_free(port);

    g_free(priority);

  }

}

static void init(session_content *sc)

{

  JingleS5B *js5 = NULL;

  GInetAddress *addr;

  GSocketAddress *saddr;

  GSource *socksource;

  GError *err = NULL;

  g_assert(js5->sock == NULL);

  addr = g_inet_address_new_from_string("127.0.0.1");

  js5->sock = g_socket_new(g_inet_address_get_family(addr), G_SOCKET_TYPE_STREAM,

                           G_SOCKET_PROTOCOL_TCP, &err);

  if (js5->sock == NULL) {

    scr_LogPrint(LPRINT_LOGNORM, "Jingle SOCKS5: Error while creating a new socket: %s",

                 err->message != NULL ? err->message : "(no message)");

    return; // TODO: we need a way to return errors...

  }

  g_socket_set_blocking(js5->sock, FALSE);

  socksource = g_socket_create_source(js5->sock, ~0, NULL);

  g_source_set_callback(socksource, (GSourceFunc)handle_sock_io, NULL, NULL);

  g_source_attach(socksource, NULL);

  g_source_unref(socksource);

  saddr = g_inet_socket_address_new(addr, 31337);

  if (!g_socket_connect(js5->sock, saddr, NULL, &err)) {

    scr_LogPrint(LPRINT_LOGNORM, "Jingle SOCKS5: Error while connecting to the host: %s",

                 err->message != NULL ? err->message : "(no message)");

    return;

  }

}

static void end(session_content *sc, gconstpointer data) {

  return;

}

/**

 * Handle any event on a sock

 */

static void handle_sock_io(GSocket *sock, GIOCondition cond, gpointer data)

{

  switch (cond) {

    case G_IO_IN:

      break;

    case G_IO_OUT:

      break;

    case G_IO_ERR:

      break;

    case G_IO_HUP:

      break;

    default:

      ;

      // ?!

  }

}

/**

 * @brief Discover all IPs of this computer

 * @return A linked list of GInetAddress

 */

  GSList *addresses = NULL;

  GInetAddress *thisaddr;

  GSocketFamily family;

  struct ifaddrs *first, *ifaddr;

  struct sockaddr_in *native;

  struct sockaddr_in6 *native6;

  const guint8 *addrdata;

  guint16 ifacecounter = 0; // for lack of a better method

  gint rval = getifaddrs(&first);

  if (!rval)

    return NULL;

  for (ifaddr = first; ifaddr; ifaddr = ifaddr->ifa_next) {

    if (!(ifaddr->ifa_flags & IFF_UP) || ifaddr->ifa_flags & IFF_LOOPBACK)

      continue;

    if (ifaddr->ifa_addr->sa_family == AF_INET) {