/*

 * xmpp_iqrequest.c -- Jabber IQ request handling

 *

 * Copyright (C) 2008-2010 Frank Zschockelt <mcabber@freakysoft.de>

 * Copyright (C) 2005-2014 Mikael Berthe <mikael@lilotux.net>

 *

 * 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, see <http://www.gnu.org/licenses/>.

 */

#include <string.h>

#include <stdlib.h>

#include <sys/time.h>

#include "xmpp_helper.h"

#include "xmpp_iq.h"

#include "screen.h"

#include "utils.h"

#include "settings.h"

#include "hooks.h"

#include "hbuf.h"

#include "carbons.h"

extern LmMessageNode *bookmarks;

extern LmMessageNode *rosternotes;

static LmHandlerResult cb_roster(LmMessageHandler *h, LmConnection *c,

                                 LmMessage *m, gpointer user_data);

static LmHandlerResult cb_version(LmMessageHandler *h, LmConnection *c,

                                  LmMessage *m, gpointer user_data);

static LmHandlerResult cb_time(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data);

static LmHandlerResult cb_last(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data);

static LmHandlerResult cb_ping(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data);

static LmHandlerResult cb_vcard(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data);

static LmHandlerResult cb_disco_info(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data);

static struct IqRequestHandlers

{

  const gchar *xmlns;

  const gchar *querytag;

  LmHandleMessageFunction handler;

} iq_request_handlers[] = {

  {NS_ROSTER,   "query", &cb_roster},

  {NS_VERSION,  "query", &cb_version},

  {NS_XMPP_TIME,"time",  &cb_time},

  {NS_LAST,     "query", &cb_last},

  {NS_PING,     "ping",  &cb_ping},

  {NS_VCARD,    "vCard", &cb_vcard},

  {NS_DISCO_INFO, "query", &cb_disco_info},

  {NULL, NULL, NULL}

};

// Enum for vCard attributes

enum vcard_attr {

  vcard_home    = 1<<0,

  vcard_work    = 1<<1,

  vcard_postal  = 1<<2,

  vcard_voice   = 1<<3,

  vcard_fax     = 1<<4,

  vcard_cell    = 1<<5,

  vcard_inet    = 1<<6,

  vcard_pref    = 1<<7,

};

static LmHandlerResult cb_disco_info(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data)

{

  LmMessageNode *ansqry;

  LmMessageNode *feature;

  ansqry = lm_message_node_get_child(m->node, "query");

  feature = lm_message_node_get_child(ansqry, "feature");

  for (; feature; feature = feature->next) {

    const char *v = lm_message_node_get_attribute(feature, "var");

    if (!g_strcmp0(v, NS_CARBONS_2)) {

      carbons_available();

    }

  }

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static LmHandlerResult cb_ping(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data)

{

  struct timeval *timestamp = (struct timeval *)user_data;

  struct timeval now;

  time_t         dsec;

  suseconds_t    dusec;

  const gchar    *fjid;

  gchar          *bjid, *mesg = NULL;

  gettimeofday(&now, NULL);

  dsec = now.tv_sec - timestamp->tv_sec;

  if (now.tv_usec < timestamp->tv_usec) {

    dusec = now.tv_usec + 1000000 - timestamp->tv_usec;

    --dsec;

  } else

    dusec = now.tv_usec - timestamp->tv_usec;

  // Check IQ result sender

  fjid = lm_message_get_from(m);

  if (!fjid)

    fjid = lm_connection_get_jid(lconnection); // No from means our JID...

  if (!fjid) {

    scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:version result (no sender name).");

    return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  }

  bjid  = jidtodisp(fjid);

  switch (lm_message_get_sub_type(m)) {

    case LM_MESSAGE_SUB_TYPE_RESULT:

        mesg = g_strdup_printf("Pong from <%s>: %d second%s %d ms.", fjid,

                               (int)dsec, dsec > 1 ? "s" : "",

                               (int)(dusec/1000L));

        break;

    case LM_MESSAGE_SUB_TYPE_ERROR:

        display_server_error(lm_message_node_get_child(m->node, "error"),

                             fjid);

        mesg = g_strdup_printf("Ping to <%s> failed.  "

                               "Response time: %d second%s %d ms.",

                               fjid, (int)dsec, dsec > 1 ? "s" : "",

                               (int)(dusec/1000L));

        break;

    default:

        g_free(bjid);

        return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

        break;

  }

  if (mesg)

    scr_WriteIncomingMessage(bjid, mesg, 0, HBB_PREFIX_INFO, 0);

  g_free(mesg);

  g_free(bjid);

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

// Warning!! xmlns has to be a namespace from iq_request_handlers[].xmlns

void xmpp_iq_request(const char *fulljid, const char *xmlns)

{

  LmMessage *iq;

  LmMessageNode *query;

  LmMessageHandler *handler;

  gpointer data = NULL;

  GDestroyNotify notifier = NULL;

  GError *error = NULL;

  int i;

  iq = lm_message_new_with_sub_type(fulljid, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_GET);

  for (i = 0; iq_request_handlers[i].xmlns &&

              strcmp(iq_request_handlers[i].xmlns, xmlns) != 0 ; ++i)

       ;

  query = lm_message_node_add_child(iq->node,

                                    iq_request_handlers[i].querytag,

                                    NULL);

  lm_message_node_set_attribute(query, "xmlns", xmlns);

  if (!g_strcmp0(xmlns, NS_PING)) {     // Create handler for ping queries

    struct timeval *now = g_new(struct timeval, 1);

    gettimeofday(now, NULL);

    data = (gpointer)now;

    notifier = g_free;

  } else if (!g_strcmp0(xmlns, NS_DISCO_INFO)) {

    gchar *servername = get_servername(settings_opt_get("jid"),

                                       settings_opt_get("server"));

    lm_message_node_set_attribute(iq->node, "to", servername);

    g_free(servername);

  }

  handler = lm_message_handler_new(iq_request_handlers[i].handler,

                                   data, notifier);

  lm_connection_send_with_reply(lconnection, iq, handler, &error);

  lm_message_handler_unref(handler);

  lm_message_unref(iq);

  if (error) {

    scr_LogPrint(LPRINT_LOGNORM, "Error sending IQ request: %s.", error->message);

    g_error_free(error);

  }

}

//  This callback is reached when mcabber receives the first roster update

// after the connection.

static LmHandlerResult cb_roster(LmMessageHandler *h, LmConnection *c,

                                 LmMessage *m, gpointer user_data)

{

  LmMessageNode *x;

  const char *ns;

  // Only execute the hook if the roster has been successfully retrieved

  if (lm_message_get_sub_type(m) != LM_MESSAGE_SUB_TYPE_RESULT)

    return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

  x = lm_message_node_get_child(m->node, "query");

  if (!x)

    return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

  ns = lm_message_node_get_attribute(x, "xmlns");

  if (ns && !strcmp(ns, NS_ROSTER))

    handle_iq_roster(NULL, c, m, user_data);

  // Post-login stuff

  hk_postconnect();

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static LmHandlerResult cb_version(LmMessageHandler *h, LmConnection *c,

                                  LmMessage *m, gpointer user_data)

{

  LmMessageNode *ansqry;

  const char *p, *bjid;

  // Check IQ result sender

  bjid = lm_message_get_from(m);

  if (!bjid)

    bjid = lm_connection_get_jid(lconnection); // No from means our JID...

  if (!bjid) {

    scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:version result (no sender name).");

    return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  }

  // Check for error message

  if (lm_message_get_sub_type(m) == LM_MESSAGE_SUB_TYPE_ERROR) {

    scr_LogPrint(LPRINT_LOGNORM, "Received error IQ message (%s)", bjid);

    display_server_error(lm_message_node_get_child(m->node, "error"), NULL);

    return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  }

  // Check message contents

  ansqry = lm_message_node_get_child(m->node, "query");

  if (!ansqry) {

    scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:version result from <%s>!", bjid);

    return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  }

  buf = g_strdup_printf("Received IQ:version result from <%s>", bjid);

  scr_LogPrint(LPRINT_LOGNORM, "%s", buf);

  // bjid should now really be the "bare JID", let's strip the resource

  g_free(buf);

  // Get result data...

  p = lm_message_node_get_child_value(ansqry, "name");

  if (p && *p) {

    buf = g_strdup_printf("Name:    %s", p);

                             0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);

    g_free(buf);

  }

  p = lm_message_node_get_child_value(ansqry, "version");

  if (p && *p) {

    buf = g_strdup_printf("Version: %s", p);

                             0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);

    g_free(buf);

  }

  p = lm_message_node_get_child_value(ansqry, "os");

  if (p && *p) {

    buf = g_strdup_printf("OS:      %s", p);

                             0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);

    g_free(buf);

  }

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static LmHandlerResult cb_time(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data)

{

  LmMessageNode *ansqry;

  const char *p, *bjid;

  // Check IQ result sender

  bjid = lm_message_get_from(m);

  if (!bjid)

    bjid = lm_connection_get_jid(lconnection); // No from means our JID...

  if (!bjid) {

    scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:time result (no sender name).");

    return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  }

  // Check for error message

  if (lm_message_get_sub_type(m) == LM_MESSAGE_SUB_TYPE_ERROR) {

    scr_LogPrint(LPRINT_LOGNORM, "Received error IQ message (%s)", bjid);

    display_server_error(lm_message_node_get_child(m->node, "error"), NULL);

    return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  }

  // Check message contents

  ansqry = lm_message_node_get_child(m->node, "time");

  if (!ansqry) {

    scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:time result from <%s>!", bjid);

    return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  }

  buf = g_strdup_printf("Received IQ:time result from <%s>", bjid);

  scr_LogPrint(LPRINT_LOGNORM, "%s", buf);

  // bjid should now really be the "bare JID", let's strip the resource

  g_free(buf);

  // Get result data...

  p = lm_message_node_get_child_value(ansqry, "utc");

  if (p && *p) {

    buf = g_strdup_printf("UTC:  %s", p);

                             0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);

    g_free(buf);

  }

  p = lm_message_node_get_child_value(ansqry, "tzo");

  if (p && *p) {

    buf = g_strdup_printf("TZ:   %s", p);

                             0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);

    g_free(buf);

  }

  p = lm_message_node_get_child_value(ansqry, "display");

  if (p && *p) {

    buf = g_strdup_printf("Time: %s", p);

                             0, HBB_PREFIX_INFO | HBB_PREFIX_CONT, 0);

    g_free(buf);

  }

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

static LmHandlerResult cb_last(LmMessageHandler *h, LmConnection *c,

                               LmMessage *m, gpointer user_data)

{

  LmMessageNode *ansqry;

  const char *p, *bjid;

  // Check IQ result sender

  bjid = lm_message_get_from(m);

  if (!bjid)

    bjid = lm_connection_get_jid(lconnection); // No from means our JID...

  if (!bjid) {