/*

 * 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 "s5b.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, gconstpointer data);

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

static gchar *info(gconstpointer data);

static void connect_candidate(JingleS5B *js5b, S5BCandidate *cand);

static void connect_next_candidate(JingleS5B *js5b, S5BCandidate *cand);

static void

handle_listener_accept(GObject *_listener, GAsyncResult *res, gpointer data);

static void

handle_client_connect(GObject *_client, GAsyncResult *res, gpointer 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           = _send,

  .init           = init,

  .end            = end,

  .info           = info

};

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[] = {

  "direct",

  "assisted",

  "tunnel",

  "proxy",

  NULL

};

static const gchar *jingle_s5b_modes[] = {

  "tcp",

  "udp",

  NULL

};

typedef struct {

  GInetAddress *address;

  guint32       priority;

  JingleS5BType type;

} LocalIP;

/**

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

 */

static GSList *local_ips = NULL;

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;

  GSList *list = NULL;

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

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

        continue;

    const gchar *hoststr, *portstr, *prioritystr, *typestr;

    S5BCandidate *cand = g_new0(S5BCandidate, 1);

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

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

    hoststr      = lm_message_node_get_attribute(node2, "host");

    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 || !hoststr || !cand->jid || !prioritystr) {

      g_free(cand);

      continue;

    }

    cand->host     = g_inet_address_new_from_string(hoststr);

    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 || cand->host == NULL) {

      g_free(cand);

      continue;

    }

    list = g_slist_prepend(list, cand);

  }

  list = g_slist_sort(list, prioritycmp);

  return list;

}

static GSList *get_our_candidates(guint16 port)

{

  GSList *our_candidates = NULL, *entry;

  for (entry = local_ips; entry; entry = entry->next) {

    LocalIP *lcand = (LocalIP *)entry->data;

    S5BCandidate *cand = g_new0(S5BCandidate, 1);

    cand->cid      = gen_random_cid();

    cand->host     = g_object_ref(lcand->address);

    cand->jid      = g_strdup(lm_connection_get_jid(lconnection));

    cand->port     = port;

    cand->priority = lcand->priority;

    our_candidates = g_slist_prepend(our_candidates, cand);

  }

  our_candidates = g_slist_sort(our_candidates, prioritycmp);

  return our_candidates;

}

/**

 * @brief Get a port number by settings or randomly

 * @return A guint16 containing the port number

 * */

static guint16 get_port(void)

{

  // TODO: find a way to make sure the port is not already used

  guint64 portstart, portend;

  guint16 port;

  const gchar *port_range = settings_opt_get("js5b_portrange");

  if (port_range != NULL) {

    sscanf(port_range, "%" G_GUINT64_FORMAT "-%" G_GUINT64_FORMAT, &portstart, &portend);

    if ((portstart >= 1024 && portstart <= (guint16)~0) &&

        (portend >= 1024 && portend <= (guint16)~0) && portstart <= portend) {

      port = g_random_int_range(portstart, portend);

    } else {

      scr_LogPrint(LPRINT_LOGNORM, "Jingle S5B: Invalid port range specified");

      port = g_random_int_range(1024, (guint16)~0);

    }

  } else {

    port = g_random_int_range(1024, (guint16)~0);

  }

  return port;

}

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

{

  JingleS5B *js5b;

  LmMessageNode *node = cn->transport;

  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);

  js5b->ourcandidates = get_our_candidates(get_port());

  return (gconstpointer) js5b;

}

static gconstpointer new(void)

{

  JingleS5B *js5b = g_new0(JingleS5B, 1);

  js5b->mode = JINGLE_S5B_TCP;

  js5b->sid  = gen_random_sid();

  js5b->ourcandidates = get_our_candidates(get_port());

  return js5b;

}

static JingleHandleStatus handle(JingleAction action, gconstpointer data,

                                 LmMessageNode *node, GError **err)

{

  JingleS5B *js5b = (JingleS5B *)data;

  if (action == JINGLE_SESSION_ACCEPT) {

    js5b->candidates = parse_candidates(node);

    return JINGLE_STATUS_HANDLED;

  } else if (action == JINGLE_TRANSPORT_INFO) {

    LmMessageNode *errorn, *usedn;

    if (g_strcmp0(lm_message_node_get_attribute(node, "sid"), js5b->sid))

      return JINGLE_STATUS_HANDLED; // huh.. not the same socks5 sid ?

    errorn = lm_message_node_get_child(node, "candidate-error");

    usedn = lm_message_node_get_child(node, "candidate-used");

    if (errorn != FALSE) {

      //got_candidate_error

    } else if (usedn != FALSE) {

      //got_candidate_used

    }

    return JINGLE_STATUS_HANDLED;

  }

  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", g_inet_address_to_string(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, gconstpointer data)

{

  JingleS5B *js5b = (JingleS5B *)data;

  GSocketAddress *saddr;

  guint numlistening = 0; // number of addresses we are listening to

  GSList *entry;

  GError *err = NULL;

  GSocket *sock;

  // First, we listen on all ips

  js5b->listener = g_socket_listener_new();

  for (entry = js5b->ourcandidates; entry; entry = entry->next) {

    S5BCandidate *cand = (S5BCandidate *)entry->data;

    sock = g_socket_new(g_inet_address_get_family(cand->host),

                        G_SOCKET_TYPE_STREAM,

                        G_SOCKET_PROTOCOL_TCP, &err);

    if (sock == NULL) {

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

                   err->message ? err->message : "(no message)");

      continue;

    }

    g_socket_set_blocking(sock, FALSE);

    saddr = g_inet_socket_address_new(cand->host, cand->port);

    if (!g_socket_bind(sock, saddr, TRUE, &err)) {

      scr_LogPrint(LPRINT_LOGNORM, "Jingle S5B: Unable to bind a socket on %s port %u: %s",

                   g_inet_address_to_string(cand->host),

                   cand->port,

                   err->message ? err->message : "(no message)");

      goto cleancontinue;

    }

    if (!g_socket_listen(sock, &err)) {

      scr_LogPrint(LPRINT_LOGNORM, "Jingle S5B: Unable to listen on %s port %u: %s",

                   g_inet_address_to_string(cand->host),

                   cand->port,

                   err->message ? err->message : "(no message)");

      goto cleancontinue;

    }

    if (!g_socket_listener_add_socket(js5b->listener, sock, NULL, &err)) {

      scr_LogPrint(LPRINT_LOGNORM, "Jingle S5B: Unable to add our socket to the"

                   " GSocketListener: %s",

                   err->message ? err->message : "(no message)");

      goto cleancontinue;

    }

    scr_LogPrint(LPRINT_LOGNORM, "Jingle S5B: Listening on %s:%u",

                 g_inet_address_to_string(cand->host),

                 cand->port);

    ++numlistening;

cleancontinue:

      if (err != NULL) g_clear_error(&err);

      g_object_unref(saddr);

      g_object_unref(sock);

  }

  if (numlistening > 0) {

    g_socket_listener_accept_async(js5b->listener, NULL, handle_listener_accept, NULL);

  } else {

      g_object_unref(js5b->listener);

  }

  // Then, we start connecting to the other entity's candidates, if any.

  if (js5b->candidates) {

    js5b->client = g_socket_client_new();

    S5BCandidate *cand = (S5BCandidate *)js5b->candidates->data;

    connect_candidate(js5b, cand);

  }

}