* xmpp.c    -- Jabber protocol handling

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

#include <stdlib.h>

#include <string.h>

#include <sys/utsname.h>

#include "commands.h"

#include "events.h"

#include "histolog.h"

#include "hooks.h"

#include "logprint.h"

#include "otr.h"

#include "settings.h"

#include "xmpp.h"

#include "xmpp_helper.h"

#include "xmpp_defines.h"

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;

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}

};

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

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

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

                   LmMessageSubType type_overwrite)

  LmMessage *x;

  LmMessageSubType subtype;

  LmMessageNode *event;

  if (!lm_connection_is_authenticated(lconnection))

  if (type_overwrite != LM_MESSAGE_SUB_TYPE_NOT_SET)

    subtype = type_overwrite;

      subtype = LM_MESSAGE_SUB_TYPE_GROUPCHAT;

      subtype = LM_MESSAGE_SUB_TYPE_CHAT;

#if defined HAVE_GPGME || defined HAVE_LIBOTR || \

    defined JEP0022 || defined JEP0085

  if (otr_enabled() && !otrinject) {

    if (type == ROSTER_TYPE_USER) {