/*

 * jab_iq.c     -- Jabber protocol IQ-related fonctions

 *

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

 * Some parts initially came from the centericq project:

 * Copyright (C) 2002-2005 by Konstantin Klyagin <konst@konst.org.ua>

 * Some small parts come from the Pidgin project <http://pidgin.im/>

 *

 * 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 <sys/utsname.h>

#include <glib.h>

#include "jabglue.h"

#include "jab_priv.h"

#include "roster.h"

#include "utils.h"

#include "screen.h"

#include "settings.h"

#include "hbuf.h"

#include "commands.h"

#include "hooks.h"

#ifdef ENABLE_HGCSET

# include "hgcset.h"

#endif

// Bookmarks for IQ:private storage

xmlnode bookmarks;

// Roster notes for IQ:private storage

xmlnode rosternotes;

static GSList *iqs_list;

time_t iqlast; // last message/status change time

// 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 void handle_iq_command_set_status(jconn conn, char *from,

                                         const char *id, xmlnode xmldata);

static void handle_iq_command_leave_groupchats(jconn conn, char *from,

                                               const char *id, xmlnode xmldata);

typedef void (*adhoc_command_callback)(jconn, char*, const char*, xmlnode);

struct adhoc_command {

  char *name;

  char *description;

  bool only_for_self;

  adhoc_command_callback callback;

};

const struct adhoc_command adhoc_command_list[] = {

  { "http://jabber.org/protocol/rc#set-status",

    "Change client status",

    1,

    &handle_iq_command_set_status },

  { "http://jabber.org/protocol/rc#leave-groupchats",

    "Leave groupchat(s)",

    1,

    &handle_iq_command_leave_groupchats },

  { NULL, NULL, 0, NULL },

};

struct adhoc_status {

  char *name;   // the name used by adhoc

  char *description;

  char *status; // the string, used by setstus

};

const struct adhoc_status adhoc_status_list[] = {

  {"online", "Online", "avail"},

  {"chat", "Chat", "free"},

  {"away", "Away", "away"},

  {"xd", "Extended away", "notavail"},

  {"dnd", "Do not disturb", "dnd"},

  {"invisible", "Invisible", "invisible"},

  {"offline", "Offline", "offline"},

  {NULL, NULL, NULL},

};

//  entity_version()

// Return a static version string for Entity Capabilities.

// It should be specific to the client version, please change the id

// if you alter mcabber's disco support (or add something to the version

// number) so that it doesn't conflict with the official client.

const char *entity_version(void)

{

  static char *ver;

  const char *PVERSION = PACKAGE_VERSION; // "+xxx";

  if (ver)

    return ver;

#ifdef HGCSET

  ver = g_strdup_printf("%s-%s", PVERSION, HGCSET);

#else

  ver = g_strdup(PVERSION);

#endif

  return ver;

}

//  iqs_new(type, namespace, prefix, timeout)

// Create a query (GET, SET) IQ structure.  This function should not be used

// for RESULT packets.

eviqs *iqs_new(guint8 type, const char *ns, const char *prefix, time_t tmout)

{

  static guint iqs_idn;

  eviqs *new_iqs;

  time_t now_t;

  iqs_idn++;

  new_iqs = g_new0(eviqs, 1);

  time(&now_t);

  new_iqs->ts_create = now_t;

  if (tmout)

    new_iqs->ts_expire = now_t + tmout;

  new_iqs->type = type;

  new_iqs->xmldata = jutil_iqnew(type, (char*)ns);

  if (prefix)

    new_iqs->id = g_strdup_printf("%s_%d", prefix, iqs_idn);

  else

    new_iqs->id = g_strdup_printf("%d", iqs_idn);

  xmlnode_put_attrib(new_iqs->xmldata, "id", new_iqs->id);

  iqs_list = g_slist_append(iqs_list, new_iqs);

  return new_iqs;

}

int iqs_del(const char *iqid)

{

  GSList *p;

  eviqs *i;

  if (!iqid) return 1;

  for (p = iqs_list; p; p = g_slist_next(p)) {

    i = p->data;

    if (!strcmp(iqid, i->id))

      break;

  }

  if (p) {

    g_free(i->id);

    xmlnode_free(i->xmldata);

    g_free(i->data);

    g_free(i);

    iqs_list = g_slist_remove(iqs_list, p->data);

    return 0; // Ok, deleted

  }

  return -1;  // Not found

}

static eviqs *iqs_find(const char *iqid)

{

  GSList *p;

  eviqs *i;

  if (!iqid) return NULL;

  for (p = iqs_list; p; p = g_slist_next(p)) {

    i = p->data;

    if (!strcmp(iqid, i->id))

      return i;

  }

  return NULL;

}

//  iqs_callback(iqid, xml_result, iqcontext)

// Callback processing for the iqid message.

// If we've received an answer, xml_result should point to the xmldata packet.

// If this is a timeout, xml_result should be NULL.

// Return 0 in case of success, -1 if the iqid hasn't been found.

int iqs_callback(const char *iqid, xmlnode xml_result, guint iqcontext)

{

  eviqs *i;

  int retval = 0;

  i = iqs_find(iqid);

  if (!i) return -1;

  // IQ processing

  // Note: If xml_result is NULL, this is a timeout

  if (i->callback)

    retval = (*i->callback)(i, xml_result, iqcontext);

  iqs_del(iqid);

  return retval;

}

void iqs_check_timeout(time_t now_t)

{

  GSList *p;

  eviqs *i;

  p = iqs_list;

  while (p) {

    i = p->data;

    // We must get next IQ eviqs element now because the current one

    // could be freed.

    p = g_slist_next(p);

    if ((!i->ts_expire && now_t > i->ts_create + (time_t)IQS_MAX_TIMEOUT) ||

        (i->ts_expire && now_t > i->ts_expire)) {

      iqs_callback(i->id, NULL, IQS_CONTEXT_TIMEOUT);

    }

  }

}

void jb_iqs_display_list(void)

{

  GSList *p;

  eviqs *i;

  scr_LogPrint(LPRINT_LOGNORM, "IQ list:");

  for (p = iqs_list; p; p = g_slist_next(p)) {

    i = p->data;

    scr_LogPrint(LPRINT_LOGNORM, "Id [%s]", i->id);

  }

  scr_LogPrint(LPRINT_LOGNORM, "End of IQ list.");

}

static void handle_iq_roster(xmlnode x)

{

  xmlnode y;

  const char *fjid, *name, *group, *sub, *ask;

  char *cleanalias;

  enum subscr esub;

  int need_refresh = FALSE;

  guint roster_type;

  for (y = xmlnode_get_tag(x, "item"); y; y = xmlnode_get_nextsibling(y)) {

    char *name_tmp = NULL;

    fjid = xmlnode_get_attrib(y, "jid");

    name = xmlnode_get_attrib(y, "name");

    sub = xmlnode_get_attrib(y, "subscription");

    ask = xmlnode_get_attrib(y, "ask");

    group = xmlnode_get_tag_data(y, "group");

    if (!fjid)

      continue;

    cleanalias = jidtodisp(fjid);

    esub = sub_none;

    if (sub) {

      if (!strcmp(sub, "to"))          esub = sub_to;

      else if (!strcmp(sub, "from"))   esub = sub_from;

      else if (!strcmp(sub, "both"))   esub = sub_both;

      else if (!strcmp(sub, "remove")) esub = sub_remove;

    }

    if (esub == sub_remove) {

      roster_del_user(cleanalias);

      scr_LogPrint(LPRINT_LOGNORM, "Buddy <%s> has been removed "

                   "from the roster", cleanalias);

      g_free(cleanalias);

      need_refresh = TRUE;

      continue;

    }

    if (ask && !strcmp(ask, "subscribe"))

      esub |= sub_pending;

    if (!name) {

      if (!settings_opt_get_int("roster_hide_domain")) {

        name = cleanalias;

      } else {

        char *p;

        name = name_tmp = g_strdup(cleanalias);

        p = strchr(name_tmp, JID_DOMAIN_SEPARATOR);

        if (p)  *p = '\0';

      }

    }

    // Tricky... :-\  My guess is that if there is no JID_DOMAIN_SEPARATOR,

    // this is an agent.

    if (strchr(cleanalias, JID_DOMAIN_SEPARATOR))

      roster_type = ROSTER_TYPE_USER;

    else

      roster_type = ROSTER_TYPE_AGENT;

    roster_add_user(cleanalias, name, group, roster_type, esub, 1);

    g_free(name_tmp);

    g_free(cleanalias);

  }

  buddylist_build();

  update_roster = TRUE;

  if (need_refresh)

    scr_UpdateBuddyWindow();

}

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

// after the connection.

static int iqscallback_gotroster(eviqs *iqp, xmlnode xml_result, guint iqcontext)

{

  xmlnode x;

  char *ns;

  // Leave now if we cannot process xml_result

  if (!xml_result || iqcontext) return -1;

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

  if (iqcontext != IQS_CONTEXT_RESULT)

    return 0;

  x = xmlnode_get_tag(xml_result, "query");

  if (!x)

    return -1;

  ns = xmlnode_get_attrib(x, "xmlns");

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

    handle_iq_roster(x);

  // Post-login stuff

  jb_setprevstatus();

  hook_execute_internal("hook-post-connect");

  return 0;

}

static void request_roster(void)

{

  eviqs *iqn = iqs_new(JPACKET__GET, NS_ROSTER, "Roster", IQS_DEFAULT_TIMEOUT);

  iqn->callback = &iqscallback_gotroster;

  jab_send(jc, iqn->xmldata);

}

static int iqscallback_version(eviqs *iqp, xmlnode xml_result, guint iqcontext)

{

  xmlnode ansqry;

  char *p;

  char *bjid;

  char *buf;

  // Leave now if we cannot process xml_result

  if (!xml_result || iqcontext) return -1;

  ansqry = xmlnode_get_tag(xml_result, "query");

  if (!ansqry) {

    scr_LogPrint(LPRINT_LOGNORM, "Invalid IQ:version result!");

    return 0;

  }

  // Display IQ result sender...

  p = xmlnode_get_attrib(xml_result, "from");

  if (!p) {

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

    return 0;

  }

  bjid = p;

  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

  p = strchr(bjid, JID_RESOURCE_SEPARATOR);

  if (p) *p = '\0';

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

  g_free(buf);

  // Get result data...