/*

 * xmpp.c       -- Jabber protocol handling

 *

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

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

 * Parts come from the centericq project:

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

 *

 * 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 <stdlib.h>

#include <string.h>

#include "xmpp.h"

#include "xmpp_helper.h"

#include "xmpp_iq.h"

#include "xmpp_iqrequest.h"

#include "xmpp_muc.h"

#include "xmpp_s10n.h"

#include "caps.h"

#include "events.h"

#include "histolog.h"

#include "hooks.h"

#include "otr.h"

#include "roster.h"

#include "screen.h"

#include "settings.h"

#include "utils.h"

#include "main.h"

#define RECONNECTION_TIMEOUT    60L

LmConnection* lconnection = NULL;

static guint AutoConnection;

inline void update_last_use(void);

inline gboolean xmpp_reconnect();

enum imstatus mystatus = offline;

static enum imstatus mywantedstatus = available;

gchar *mystatusmsg;

char imstatus2char[imstatus_size+1] = {

    '_', 'o', 'f', 'd', 'n', 'a', 'i', '\0'

};

char *imstatus_showmap[] = {

  "",

  "",

  "chat",

  "dnd",

  "xa",

  "away",

  ""

};

LmMessageNode *bookmarks = NULL;

LmMessageNode *rosternotes = NULL;

static struct IqHandlers

{

  const gchar *xmlns;

  LmHandleMessageFunction handler;

} iq_handlers[] = {

  {NS_PING,       &handle_iq_ping},

  {NS_VERSION,    &handle_iq_version},

  {NS_TIME,       &handle_iq_time},

  {NS_ROSTER,     &handle_iq_roster},

  {NS_XMPP_TIME,  &handle_iq_time202},

  {NS_LAST,       &handle_iq_last},

  {NS_DISCO_INFO, &handle_iq_disco_info},

  {NS_DISCO_ITEMS,&handle_iq_disco_items},

  {NS_COMMANDS,   &handle_iq_commands},

  {NS_VCARD,      &handle_iq_vcard},

  {NULL, NULL}

};

void update_last_use(void)

{

  iqlast = time(NULL);

}

gboolean xmpp_is_online(void)

{

  if (lconnection && lm_connection_is_authenticated(lconnection))

    return TRUE;

  else

    return FALSE;

}

// Note: the caller should check the jid is correct

void xmpp_addbuddy(const char *bjid, const char *name, const char *group)

{

  LmMessageNode *query, *y;

  LmMessage *iq;

  LmMessageHandler *handler;

  char *cleanjid;

  if (!xmpp_is_online())

    return;

  cleanjid = jidtodisp(bjid); // Stripping resource, just in case...

  // We don't check if the jabber user already exists in the roster,

  // because it allows to re-ask for notification.

  iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  query = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(query, "xmlns", NS_ROSTER);

  y = lm_message_node_add_child(query, "item", NULL);

  lm_message_node_set_attribute(y, "jid", cleanjid);

  if (name)

    lm_message_node_set_attribute(y, "name", name);

  if (group)

    lm_message_node_add_child(y, "group", group);

  handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE);

  lm_connection_send_with_reply(lconnection, iq, handler, NULL);

  lm_message_handler_unref(handler);

  lm_message_unref(iq);

  xmpp_send_s10n(cleanjid, LM_MESSAGE_SUB_TYPE_SUBSCRIBE);

  roster_add_user(cleanjid, name, group, ROSTER_TYPE_USER, sub_pending, -1);

  g_free(cleanjid);

  buddylist_build();

  update_roster = TRUE;

}

void xmpp_updatebuddy(const char *bjid, const char *name, const char *group)

{

  LmMessage *iq;

  LmMessageHandler *handler;

  LmMessageNode *x;

  char *cleanjid;

  if (!xmpp_is_online())

    return;

  // XXX We should check name's and group's correctness

  cleanjid = jidtodisp(bjid); // Stripping resource, just in case...

  iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  x = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(x, "xmlns", NS_ROSTER);

  x = lm_message_node_add_child(x, "item", NULL);

  lm_message_node_set_attributes(x,

                                 "jid", cleanjid,

                                 "name", name,

                                 NULL);

  if (group)

    lm_message_node_add_child(x, "group", group);

  handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE);

  lm_connection_send_with_reply(lconnection, iq, handler, NULL);

  lm_message_handler_unref(handler);

  lm_message_unref(iq);

  g_free(cleanjid);

}

void xmpp_delbuddy(const char *bjid)

{

  LmMessageNode *y, *z;

  LmMessage *iq;

  LmMessageHandler *handler;

  char *cleanjid;

  if (!xmpp_is_online())

    return;

  cleanjid = jidtodisp(bjid); // Stripping resource, just in case...

  // If the current buddy is an agent, unsubscribe from it

  if (roster_gettype(cleanjid) == ROSTER_TYPE_AGENT) {

    scr_LogPrint(LPRINT_LOGNORM, "Unregistering from the %s agent", cleanjid);

    iq = lm_message_new_with_sub_type(cleanjid, LM_MESSAGE_TYPE_IQ,

                                      LM_MESSAGE_SUB_TYPE_SET);

    y = lm_message_node_add_child(iq->node, "query", NULL);

    lm_message_node_set_attribute(y, "xmlns", NS_REGISTER);

    lm_message_node_add_child(y, "remove", NULL);

    lm_connection_send(lconnection, iq, NULL);

    lm_message_unref(iq);

  }

  // Cancel the subscriptions

  xmpp_send_s10n(cleanjid, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED); //cancel "from"

  xmpp_send_s10n(cleanjid, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE);  //cancel "to"

  // Ask for removal from roster

  iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ,

                                    LM_MESSAGE_SUB_TYPE_SET);

  y = lm_message_node_add_child(iq->node, "query", NULL);

  lm_message_node_set_attribute(y, "xmlns", NS_ROSTER);

  z = lm_message_node_add_child(y, "item", NULL);

  lm_message_node_set_attributes(z,

                                 "jid", cleanjid,

                                 "subscription", "remove",

                                 NULL);

  handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE);

  lm_connection_send_with_reply(lconnection, iq, handler, NULL);

  lm_message_handler_unref(handler);

  lm_message_unref(iq);

  roster_del_user(cleanjid);

  g_free(cleanjid);

  buddylist_build();

  update_roster = TRUE;

}

void xmpp_request(const char *fjid, enum iqreq_type reqtype)

{

  GSList *resources, *p_res;

  GSList *roster_elt;

  const char *strreqtype, *xmlns;

  if (reqtype == iqreq_version) {

    xmlns = NS_VERSION;

    strreqtype = "version";

  } else if (reqtype == iqreq_time) {

    xmlns = NS_TIME;

    strreqtype = "time";

  } else if (reqtype == iqreq_last) {

    xmlns = NS_LAST;

    strreqtype = "last";

  } else if (reqtype == iqreq_ping) {

    xmlns = NS_PING;

    strreqtype = "ping";

  } else if (reqtype == iqreq_vcard) {

    xmlns = NS_VCARD;

    strreqtype = "vCard";

  } else

    return;

  if (strchr(fjid, JID_RESOURCE_SEPARATOR)) {

    // This is a full JID

    xmpp_iq_request(fjid, xmlns);

    scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fjid);

    return;

  }

  // The resource has not been specified

  roster_elt = roster_find(fjid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_ROOM);

  if (!roster_elt) {

    scr_LogPrint(LPRINT_NORMAL, "No known resource for <%s>...", fjid);

    xmpp_iq_request(fjid, xmlns); // Let's send a request anyway...

    scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fjid);

    return;

  }

  // Send a request to each resource

  resources = buddy_getresources(roster_elt->data);

  if (!resources) {

    scr_LogPrint(LPRINT_NORMAL, "No known resource for <%s>...", fjid);

    xmpp_iq_request(fjid, xmlns); // Let's send a request anyway...

    scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fjid);

  }

  for (p_res = resources ; p_res ; p_res = g_slist_next(p_res)) {

    gchar *fulljid;

    fulljid = g_strdup_printf("%s/%s", fjid, (char*)p_res->data);

    xmpp_iq_request(fulljid, xmlns);

    scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fulljid);

    g_free(fulljid);

    g_free(p_res->data);

  }

  g_slist_free(resources);

}

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

                                 LmMessage *m, gpointer user_data)

{

  char *from = jidtodisp(lm_message_get_from(m));

  scr_RemoveReceiptFlag(from, h);

  g_free(from);

  return LM_HANDLER_RESULT_REMOVE_MESSAGE;

}

//  xmpp_send_msg(jid, text, type, subject,

//                otrinject, *encrypted, type_overwrite)

// When encrypted is not NULL, the function set *encrypted to 1 if the

// message has been PGP-encrypted.  If encryption enforcement is set and

// encryption fails, *encrypted is set to -1.

void xmpp_send_msg(const char *fjid, const char *text, int type,

                   const char *subject, gboolean otrinject, gint *encrypted,

                   LmMessageSubType type_overwrite, gpointer *xep184)

{

  LmMessage *x;

  LmMessageSubType subtype;

#ifdef HAVE_LIBOTR

  int otr_msg = 0;

#endif

#if defined HAVE_GPGME || defined XEP0022 || defined XEP0085

  char *rname, *barejid;

  GSList *sl_buddy;

#endif

#if defined XEP0022 || defined XEP0085

  LmMessageNode *event;

  guint use_jep85 = 0;

  struct jep0085 *jep85 = NULL;

#endif

  gchar *enc = NULL;

  if (encrypted)

    *encrypted = 0;

  if (!xmpp_is_online())

    return;

  if (!text && type == ROSTER_TYPE_USER)

    return;

  if (type_overwrite != LM_MESSAGE_SUB_TYPE_NOT_SET)

    subtype = type_overwrite;

  else {

    if (type == ROSTER_TYPE_ROOM)

      subtype = LM_MESSAGE_SUB_TYPE_GROUPCHAT;

    else

      subtype = LM_MESSAGE_SUB_TYPE_CHAT;

  }

#if defined HAVE_GPGME || defined HAVE_LIBOTR || \

    defined XEP0022 || defined XEP0085

  rname = strchr(fjid, JID_RESOURCE_SEPARATOR);

  barejid = jidtodisp(fjid);

  sl_buddy = roster_find(barejid, jidsearch, ROSTER_TYPE_USER);

  // If we can get a resource name, we use it.  Else we use NULL,

  // which hopefully will give us the most likely resource.

  if (rname)

    rname++;

#ifdef HAVE_LIBOTR

  if (otr_enabled() && !otrinject) {

    if (type == ROSTER_TYPE_USER) {

      otr_msg = otr_send((char **)&text, barejid);

      if (!text) {

        g_free(barejid);

        if (encrypted)

          *encrypted = -1;

        return;

      }

    }

    if (otr_msg && encrypted)

      *encrypted = ENCRYPTED_OTR;

  }

#endif

#ifdef HAVE_GPGME

  if (type == ROSTER_TYPE_USER && sl_buddy && gpg_enabled()) {

    if (!settings_pgp_getdisabled(barejid)) { // not disabled for this contact?

      guint force;

      struct pgp_data *res_pgpdata;

      force = settings_pgp_getforce(barejid);

      res_pgpdata = buddy_resource_pgp(sl_buddy->data, rname);

      if (force || (res_pgpdata && res_pgpdata->sign_keyid)) {

        /* Remote client has PGP support (we have a signature)

         * OR encryption is enforced (force = TRUE).

         * If the contact has a specific KeyId, we'll use it;

         * if not, we'll use the key used for the signature.

         * Both keys should match, in theory (cf. XEP-0027). */

        const char *key;

        key = settings_pgp_getkeyid(barejid);

        if (!key && res_pgpdata)

          key = res_pgpdata->sign_keyid;

        if (key)

          enc = gpg_encrypt(text, key);

        if (!enc && force) {

          if (encrypted)