/*

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

#include "caps.h"

#include "commands.h"

#include "events.h"

#include "histolog.h"

#include "hooks.h"

#include "logprint.h"

#include "otr.h"

#include "roster.h"

#include "screen.h"

#include "settings.h"

#include "utils.h"

#include "xmpp.h"

#include "xmpp_helper.h"

#include "xmpp_defines.h"

#define RECONNECTION_TIMEOUT    60L

LmConnection* lconnection;

static guint AutoConnection;

inline void update_last_use(void);

inline gboolean xmpp_reconnect();

static enum imstatus mystatus = offline;

static enum imstatus mywantedstatus = available;

static gchar *mystatusmsg;

char imstatus2char[imstatus_size+1] = {

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

};

static char *imstatus_showmap[] = {

  "",

  "",

  "chat",

  "dnd",

  "xa",

  "away",

  ""

};

static LmMessageNode *bookmarks = NULL;

static LmMessageNode *rosternotes = NULL;

struct xmpp_error {

  guint code;

  const char *code_str;

  const char *meaning;

  const char *condition;

  const char *type;

} xmpp_errors[] = {

  {XMPP_ERROR_REDIRECT,              "302",

    "Redirect",              "redirect",                "modify"},

  {XMPP_ERROR_BAD_REQUEST,           "400",

    "Bad Request",           "bad-request",             "modify"},

  {XMPP_ERROR_NOT_AUTHORIZED,        "401",

    "Not Authorized",        "not-authorized",          "auth"},

  {XMPP_ERROR_PAYMENT_REQUIRED,      "402",

    "Payment Required",      "payment-required",        "auth"},

  {XMPP_ERROR_FORBIDDEN,             "403",

    "Forbidden",             "forbidden",               "auth"},

  {XMPP_ERROR_NOT_FOUND,             "404",

    "Not Found",             "item-not-found",          "cancel"},

  {XMPP_ERROR_NOT_ALLOWED,           "405",

    "Not Allowed",           "not-allowed",             "cancel"},

  {XMPP_ERROR_NOT_ACCEPTABLE,        "406",

    "Not Acceptable",        "not-acceptable",          "modify"},

  {XMPP_ERROR_REGISTRATION_REQUIRED, "407",

    "Registration required", "registration-required",   "auth"},

  {XMPP_ERROR_REQUEST_TIMEOUT,       "408",

    "Request Timeout",       "remote-server-timeout",   "wait"},

  {XMPP_ERROR_CONFLICT,              "409",

    "Conflict",               "conflict",               "cancel"},

  {XMPP_ERROR_INTERNAL_SERVER_ERROR, "500",

    "Internal Server Error", "internal-server-error",   "wait"},

  {XMPP_ERROR_NOT_IMPLEMENTED,       "501",

    "Not Implemented",       "feature-not-implemented", "cancel"},

  {XMPP_ERROR_REMOTE_SERVER_ERROR,   "502",

    "Remote Server Error",   "service-unavailable",     "wait"},

  {XMPP_ERROR_SERVICE_UNAVAILABLE,   "503",

    "Service Unavailable",   "service-unavailable",     "cancel"},

  {XMPP_ERROR_REMOTE_SERVER_TIMEOUT, "504",

    "Remote Server Timeout", "remote-server-timeout",   "wait"},

  {XMPP_ERROR_DISCONNECTED,          "510",

    "Disconnected",          "service-unavailable",     "cancel"},

  {0, NULL, NULL, NULL, NULL}

};

#include "xmpp_helper.c"

#include "xmpp_iq.c"

#include "xmpp_iqrequest.c"

#include "xmpp_muc.c"

#include "xmpp_s10n.c"

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},

  {NULL, NULL}

};

void update_last_use(void)

{

  iqlast = time(NULL);

}

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

  char *cleanjid;

  if (!lm_connection_is_authenticated(lconnection)) 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);

  lm_connection_send(lconnection, iq, NULL);

  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;

  LmMessageNode *x;

  char *cleanjid;

  if (!lm_connection_is_authenticated(lconnection)) 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);

  lm_connection_send(lconnection, iq, NULL);

  lm_message_unref(iq);

  g_free(cleanjid);

}

void xmpp_delbuddy(const char *bjid)

{

  LmMessageNode *y, *z;

  LmMessage *iq;

  char *cleanjid;

  if (!lm_connection_is_authenticated(lconnection)) 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);

  lm_connection_send(lconnection, iq, NULL);

  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_vcard) {

    xmlns = NS_VCARD;

    strreqtype = "vCard";

    // Special case

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

}

//  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,

{

  LmMessage *x;

  LmMessageSubType subtype;

#ifdef HAVE_LIBOTR

  int otr_msg = 0;

#endif

#if defined HAVE_GPGME || defined JEP0022 || defined JEP0085

  char *rname, *barejid;

  GSList *sl_buddy;

#endif

#if defined JEP0022 || defined JEP0085

  LmMessageNode *event;

  guint use_jep85 = 0;

  struct jep0085 *jep85 = NULL;

#endif

  gchar *enc = NULL;

  if (encrypted)

    *encrypted = 0;

  if (!lm_connection_is_authenticated(lconnection))

    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 JEP0022 || defined JEP0085

  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)