Sat Nov 1 06:28:36 2008

Asterisk developer's documentation

---

res_jabber.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Matt O'Gorman <mogorman@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 * \brief A resource for interfacing asterisk directly as a client
 * or a component to a jabber compliant server.
 *
 * \todo If you unload this module, chan_gtalk/jingle will be dead. How do we handle that?
 * \todo If you have TLS, you can't unload this module. See bug #9738. This needs to be fixed,
 *       but the bug is in the unmantained Iksemel library
 *
 */

/*** MODULEINFO
   <depend>iksemel</depend>
   <use>gnutls</use>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 120675 $")

#include <stdlib.h>
#include <stdio.h>
#include <iksemel.h>

#include "asterisk/channel.h"
#include "asterisk/jabber.h"
#include "asterisk/file.h"
#include "asterisk/config.h"
#include "asterisk/callerid.h"
#include "asterisk/lock.h"
#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/pbx.h"
#include "asterisk/md5.h"
#include "asterisk/acl.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/astobj.h"
#include "asterisk/astdb.h"
#include "asterisk/manager.h"

#define JABBER_CONFIG "jabber.conf"

#ifndef FALSE
#define FALSE 0
#endif

#ifndef TRUE
#define TRUE 1
#endif

/*-- Forward declarations */
static int aji_highest_bit(int number);
static void aji_buddy_destroy(struct aji_buddy *obj);
static void aji_client_destroy(struct aji_client *obj);
static int aji_send_exec(struct ast_channel *chan, void *data);
static int aji_status_exec(struct ast_channel *chan, void *data);
static void aji_log_hook(void *data, const char *xmpp, size_t size, int is_incoming);
static int aji_act_hook(void *data, int type, iks *node);
static void aji_handle_iq(struct aji_client *client, iks *node);
static void aji_handle_message(struct aji_client *client, ikspak *pak);
static void aji_handle_presence(struct aji_client *client, ikspak *pak);
static void aji_handle_subscribe(struct aji_client *client, ikspak *pak);
static void *aji_recv_loop(void *data);
static int aji_component_initialize(struct aji_client *client);
static int aji_client_initialize(struct aji_client *client);
static int aji_client_connect(void *data, ikspak *pak);
static void aji_set_presence(struct aji_client *client, char *to, char *from, int level, char *desc);
static int aji_do_debug(int fd, int argc, char *argv[]);
static int aji_do_reload(int fd, int argc, char *argv[]);
static int aji_no_debug(int fd, int argc, char *argv[]);
static int aji_test(int fd, int argc, char *argv[]);
static int aji_show_clients(int fd, int argc, char *argv[]);
static int aji_create_client(char *label, struct ast_variable *var, int debug);
static int aji_create_buddy(char *label, struct aji_client *client);
static int aji_reload(void);
static int aji_load_config(void);
static void aji_pruneregister(struct aji_client *client);
static int aji_filter_roster(void *data, ikspak *pak);
static int aji_get_roster(struct aji_client *client);
static int aji_client_info_handler(void *data, ikspak *pak);
static int aji_dinfo_handler(void *data, ikspak *pak);
static int aji_ditems_handler(void *data, ikspak *pak);
static int aji_register_query_handler(void *data, ikspak *pak);
static int aji_register_approve_handler(void *data, ikspak *pak);
static int aji_reconnect(struct aji_client *client);
static iks *jabber_make_auth(iksid * id, const char *pass, const char *sid);
/* No transports in this version */
/*
static int aji_create_transport(char *label, struct aji_client *client);
static int aji_register_transport(void *data, ikspak *pak);
static int aji_register_transport2(void *data, ikspak *pak);
*/

static char debug_usage[] = 
"Usage: jabber debug\n" 
"       Enables dumping of Jabber packets for debugging purposes.\n";

static char no_debug_usage[] = 
"Usage: jabber debug off\n" 
"       Disables dumping of Jabber packets for debugging purposes.\n";

static char reload_usage[] = 
"Usage: jabber reload\n" 
"       Enables reloading of Jabber module.\n";

static char test_usage[] = 
"Usage: jabber test [client]\n" 
"       Sends test message for debugging purposes.  A specific client\n"
"       as configured in jabber.conf can be optionally specified.\n";

static struct ast_cli_entry aji_cli[] = {
   { { "jabber", "debug", NULL},
   aji_do_debug, "Enable Jabber debugging",
   debug_usage },

   { { "jabber", "reload", NULL},
   aji_do_reload, "Reload Jabber configuration",
   reload_usage },

   { { "jabber", "show", "connected", NULL},
   aji_show_clients, "Show state of clients and components",
   debug_usage },

   { { "jabber", "debug", "off", NULL},
   aji_no_debug, "Disable Jabber debug",
   no_debug_usage },

   { { "jabber", "test", NULL},
   aji_test, "Shows roster, but is generally used for mog's debugging.",
   test_usage },
};

static char *app_ajisend = "JabberSend";

static char *ajisend_synopsis = "JabberSend(jabber,screenname,message)";

static char *ajisend_descrip =
"JabberSend(Jabber,ScreenName,Message)\n"
"  Jabber - Client or transport Asterisk uses to connect to Jabber\n" 
"  ScreenName - User Name to message.\n" 
"  Message - Message to be sent to the buddy\n";

static char *app_ajistatus = "JabberStatus";

static char *ajistatus_synopsis = "JabberStatus(Jabber,ScreenName,Variable)";

static char *ajistatus_descrip =
"JabberStatus(Jabber,ScreenName,Variable)\n"
"  Jabber - Client or transport Asterisk uses to connect to Jabber\n"
"  ScreenName - User Name to retrieve status from.\n"
"  Variable - Variable to store presence in will be 1-6.\n" 
"             In order, Online, Chatty, Away, XAway, DND, Offline\n" 
"             If not in roster variable will = 7\n";

struct aji_client_container clients;
struct aji_capabilities *capabilities = NULL;

/*! \brief Global flags, initialized to default values */
static struct ast_flags globalflags = { AJI_AUTOPRUNE | AJI_AUTOREGISTER };
static int tls_initialized = FALSE;

/*!
 * \brief Deletes the aji_client data structure.
 * \param obj is the structure we will delete.
 * \return void.
 */
static void aji_client_destroy(struct aji_client *obj)
{
   struct aji_message *tmp;
   ASTOBJ_CONTAINER_DESTROYALL(&obj->buddies, aji_buddy_destroy);
   ASTOBJ_CONTAINER_DESTROY(&obj->buddies);
   iks_filter_delete(obj->f);
   iks_parser_delete(obj->p);
   iks_stack_delete(obj->stack);
   AST_LIST_LOCK(&obj->messages);
   while ((tmp = AST_LIST_REMOVE_HEAD(&obj->messages, list))) {
      if (tmp->from)
         free(tmp->from);
      if (tmp->message)
         free(tmp->message);
   }
   AST_LIST_HEAD_DESTROY(&obj->messages);
   free(obj);
}

/*!
 * \brief Deletes the aji_buddy data structure.
 * \param obj is the structure we will delete.
 * \return void.
 */
static void aji_buddy_destroy(struct aji_buddy *obj)
{
   struct aji_resource *tmp;

   while ((tmp = obj->resources)) {
      obj->resources = obj->resources->next;
      free(tmp->description);
      free(tmp);
   }

   free(obj);
}

/*!
 * \brief Find version in XML stream and populate our capabilities list
 * \param node the node attribute in the caps element we'll look for or add to 
 * our list
 * \param version the version attribute in the caps element we'll look for or 
 * add to our list
 * \param pak the XML stanza we're processing
 * \return a pointer to the added or found aji_version structure
 */ 
static struct aji_version *aji_find_version(char *node, char *version, ikspak *pak)
{
   struct aji_capabilities *list = NULL;
   struct aji_version *res = NULL;

   list = capabilities;

   if(!node)
      node = pak->from->full;
   if(!version)
      version = "none supplied.";
   while(list) {
      if(!strcasecmp(list->node, node)) {
         res = list->versions;
         while(res) {
             if(!strcasecmp(res->version, version))
                return res;
             res = res->next;
         }
         /* Specified version not found. Let's add it to 
            this node in our capabilities list */
         if(!res) {
            res = (struct aji_version *)malloc(sizeof(struct aji_version));
            if(!res) {
               ast_log(LOG_ERROR, "Out of memory!\n");
               return NULL;
            }
            res->jingle = 0;
            res->parent = list;
            ast_copy_string(res->version, version, sizeof(res->version));
            res->next = list->versions;
            list->versions = res;
            return res;
         }
      }
      list = list->next;
   }
   /* Specified node not found. Let's add it our capabilities list */
   if(!list) {
      list = (struct aji_capabilities *)malloc(sizeof(struct aji_capabilities));
      if(!list) {
         ast_log(LOG_ERROR, "Out of memory!\n");
         return NULL;
      }
      res = (struct aji_version *)malloc(sizeof(struct aji_version));
      if(!res) {
         ast_log(LOG_ERROR, "Out of memory!\n");
         ast_free(list);
         return NULL;
      }
      ast_copy_string(list->node, node, sizeof(list->node));
      ast_copy_string(res->version, version, sizeof(res->version));
      res->jingle = 0;
      res->parent = list;
      res->next = NULL;
      list->versions = res;
      list->next = capabilities;
      capabilities = list;
   }
   return res;
}

static struct aji_resource *aji_find_resource(struct aji_buddy *buddy, char *name)
{
   struct aji_resource *res = NULL;
   if (!buddy || !name)
      return res;
   res = buddy->resources;
   while (res) {
      if (!strcasecmp(res->resource, name)) {
         break;
      }
      res = res->next;
   }
   return res;
}

static int gtalk_yuck(iks *node)
{
   if (iks_find_with_attrib(node, "c", "node", "http://www.google.com/xmpp/client/caps"))
      return 1;
   return 0;
}

/*!
 * \brief Detects the highest bit in a number.
 * \param Number you want to have evaluated.
 * \return the highest power of 2 that can go into the number.
 */
static int aji_highest_bit(int number)
{
   int x = sizeof(number) * 8 - 1;
   if (!number)
      return 0;
   for (; x > 0; x--) {
      if (number & (1 << x))
         break;
   }
   return (1 << x);
}

static iks *jabber_make_auth(iksid * id, const char *pass, const char *sid)
{
   iks *x, *y;
   x = iks_new("iq");
   iks_insert_attrib(x, "type", "set");
   y = iks_insert(x, "query");
   iks_insert_attrib(y, "xmlns", IKS_NS_AUTH);
   iks_insert_cdata(iks_insert(y, "username"), id->user, 0);
   iks_insert_cdata(iks_insert(y, "resource"), id->resource, 0);
   if (sid) {
      char buf[41];
      char sidpass[100];
      snprintf(sidpass, sizeof(sidpass), "%s%s", sid, pass);
      ast_sha1_hash(buf, sidpass);
      iks_insert_cdata(iks_insert(y, "digest"), buf, 0);
   } else {
      iks_insert_cdata(iks_insert(y, "password"), pass, 0);
   }
   return x;
}

/*!
 * \brief Dial plan function status(). puts the status of watched user 
   into a channel variable.
 * \param channel, and username,watched user, status var
 * \return 0.
 */
static int aji_status_exec(struct ast_channel *chan, void *data)
{
   struct aji_client *client = NULL;
   struct aji_buddy *buddy = NULL;
   struct aji_resource *r = NULL;
   char *s = NULL, *sender = NULL, *jid = NULL, *screenname = NULL, *resource = NULL, *variable = NULL;
   int stat = 7;
   char status[2];

   if (!data) {
      ast_log(LOG_ERROR, "This application requires arguments.\n");
      return 0;
   }
   s = ast_strdupa(data);
   if (s) {
      sender = strsep(&s, "|");
      if (sender && (sender[0] != '\0')) {
         jid = strsep(&s, "|");
         if (jid && (jid[0] != '\0')) {
            variable = s;
         } else {
            ast_log(LOG_ERROR, "Bad arguments\n");
            return -1;
         }
      }
   }

   if(!strchr(jid, '/')) {
      resource = NULL;
   } else {
      screenname = strsep(&jid, "/");
      resource = jid;
   }
   client = ast_aji_get_client(sender);
   if (!client) {
      ast_log(LOG_WARNING, "Could not find sender connection: %s\n", sender);
      return -1;
   }
   if(!&client->buddies) {
      ast_log(LOG_WARNING, "No buddies for connection : %s\n", sender);
      return -1;
   }
   buddy = ASTOBJ_CONTAINER_FIND(&client->buddies, resource ? screenname: jid);
   if (!buddy) {
      ast_log(LOG_WARNING, "Could not find buddy in list : %s\n", resource ? screenname : jid);
      return -1;
   }
   r = aji_find_resource(buddy, resource);
   if(!r && buddy->resources) 
      r = buddy->resources;
   if(!r)
      ast_log(LOG_NOTICE, "Resource %s of buddy %s not found \n", resource, screenname);
   else
      stat = r->status;
   sprintf(status, "%d", stat);
   pbx_builtin_setvar_helper(chan, variable, status);
   return 0;
}

/*!
 * \brief Dial plan function to send a message.
 * \param channel, and data, data is sender, reciever, message.
 * \return 0.
 */
static int aji_send_exec(struct ast_channel *chan, void *data)
{
   struct aji_client *client = NULL;

   char *s = NULL, *sender = NULL, *recipient = NULL, *message = NULL;

   if (!data) {
      ast_log(LOG_ERROR, "This application requires arguments.\n");
      return 0;
   }
   s = ast_strdupa(data);
   if (s) {
      sender = strsep(&s, "|");
      if (sender && (sender[0] != '\0')) {
         recipient = strsep(&s, "|");
         if (recipient && (recipient[0] != '\0')) {
            message = s;
         } else {
            ast_log(LOG_ERROR, "Bad arguments: %s\n", (char *) data);
            return -1;
         }
      }
   }
   if (!(client = ast_aji_get_client(sender))) {
      ast_log(LOG_WARNING, "Could not find sender connection: %s\n", sender);
      return -1;
   }
   if (strchr(recipient, '@') && message)
      ast_aji_send(client, recipient, message);
   return 0;
}

/*!
 * \brief the debug loop.
 * \param aji_client structure, xml data as string, size of string, direction of packet, 1 for inbound 0 for outbound.
 */
static void aji_log_hook(void *data, const char *xmpp, size_t size, int is_incoming)
{
   struct aji_client *client = ASTOBJ_REF((struct aji_client *) data);
   manager_event(EVENT_FLAG_USER, "JabberEvent", "Account: %s\r\nPacket: %s\r\n", client->name, xmpp);

   if (client->debug) {
      if (is_incoming)
         ast_verbose("\nJABBER: %s INCOMING: %s\n", client->name, xmpp);
      else {
         if( strlen(xmpp) == 1) {
            if(option_debug > 2  && xmpp[0] == ' ')
            ast_verbose("\nJABBER: Keep alive packet\n");
         } else
            ast_verbose("\nJABBER: %s OUTGOING: %s\n", client->name, xmpp);
      }

   }
   ASTOBJ_UNREF(client, aji_client_destroy);
}

/*!
 * \brief The action hook parses the inbound packets, constantly running.
 * \param data aji client structure 
 * \param type type of packet 
 * \param node the actual packet.
 * \return IKS_OK or IKS_HOOK .
 */
static int aji_act_hook(void *data, int type, iks *node)
{
   struct aji_client *client = ASTOBJ_REF((struct aji_client *) data);
   ikspak *pak = NULL;
   iks *auth = NULL;

   if(!node) {
      ast_log(LOG_ERROR, "aji_act_hook was called with out a packet\n"); /* most likely cause type is IKS_NODE_ERROR lost connection */
      ASTOBJ_UNREF(client, aji_client_destroy);
      return IKS_HOOK;
   }

   if (client->state == AJI_DISCONNECTING) {
      ASTOBJ_UNREF(client, aji_client_destroy);
      return IKS_HOOK;
   }

   pak = iks_packet(node);

   if (!client->component) { /*client */
      switch (type) {
      case IKS_NODE_START:
         if (client->usetls && !iks_is_secure(client->p)) {
            if (iks_has_tls()) {
               iks_start_tls(client->p);
               tls_initialized = TRUE;
            } else
               ast_log(LOG_ERROR, "gnuTLS not installed. You need to recompile the Iksemel library with gnuTLS support\n");
            break;
         }
         if (!client->usesasl) {
            iks_filter_add_rule(client->f, aji_client_connect, client, IKS_RULE_TYPE, IKS_PAK_IQ, IKS_RULE_SUBTYPE, IKS_TYPE_RESULT, IKS_RULE_ID, client->mid, IKS_RULE_DONE);
            auth = jabber_make_auth(client->jid, client->password, iks_find_attrib(node, "id"));
            if (auth) {
               iks_insert_attrib(auth, "id", client->mid);
               iks_insert_attrib(auth, "to", client->jid->server);
               ast_aji_increment_mid(client->mid);
               iks_send(client->p, auth);
               iks_delete(auth);
            } else
               ast_log(LOG_ERROR, "Out of memory.\n");
         }
         break;

      case IKS_NODE_NORMAL:
         if (!strcmp("stream:features", iks_name(node))) {
            int features = 0;
            features = iks_stream_features(node);
            if (client->usesasl) {
               if (client->usetls && !iks_is_secure(client->p))
                  break;
               if (client->authorized) {
                  if (features & IKS_STREAM_BIND) {
                     iks_filter_add_rule (client->f, aji_client_connect, client, IKS_RULE_TYPE, IKS_PAK_IQ, IKS_RULE_SUBTYPE, IKS_TYPE_RESULT, IKS_RULE_DONE);
                     auth = iks_make_resource_bind(client->jid);
                     if (auth) {
                        iks_insert_attrib(auth, "id", client->mid);
                        ast_aji_increment_mid(client->mid);
                        iks_send(client->p, auth);
                        iks_delete(auth);
                     } else {
                        ast_log(LOG_ERROR, "Out of memory.\n");
                        break;
                     }
                  }
                  if (features & IKS_STREAM_SESSION) {
                     iks_filter_add_rule (client->f, aji_client_connect, client, IKS_RULE_TYPE, IKS_PAK_IQ, IKS_RULE_SUBTYPE, IKS_TYPE_RESULT, IKS_RULE_ID, "auth", IKS_RULE_DONE);
                     auth = iks_make_session();
                     if (auth) {
                        iks_insert_attrib(auth, "id", "auth");
                        ast_aji_increment_mid(client->mid);
                        iks_send(client->p, auth);
                        iks_delete(auth);
                     } else {
                        ast_log(LOG_ERROR, "Out of memory.\n");
                     }
                  }
               } else {
                  if (!client->jid->user) {
                     ast_log(LOG_ERROR, "Malformed Jabber ID : %s (domain missing?)\n", client->jid->full);
                     break;
                  }
                  features = aji_highest_bit(features);
                  if (features == IKS_STREAM_SASL_MD5)
                     iks_start_sasl(client->p, IKS_SASL_DIGEST_MD5, client->jid->user, client->password);
                  else {
                     if (features == IKS_STREAM_SASL_PLAIN) {
                        iks *x = NULL;
                        x = iks_new("auth");
                        if (x) {
                           int len = strlen(client->jid->user) + strlen(client->password) + 3;
                           /* XXX Check return values XXX */
                           char *s = ast_malloc(80 + len);
                           char *base64 = ast_malloc(80 + len * 2);
                           iks_insert_attrib(x, "xmlns", IKS_NS_XMPP_SASL);
                           iks_insert_attrib(x, "mechanism", "PLAIN");
                           sprintf(s, "%c%s%c%s", 0, client->jid->user, 0, client->password);
                              
                           /* exclude the NULL training byte from the base64 encoding operation
                              as some XMPP servers will refuse it.
                              The format for authentication is [authzid]\0authcid\0password
                              not [authzid]\0authcid\0password\0 */
                           ast_base64encode(base64, (const unsigned char *) s, len - 1, len * 2);
                           iks_insert_cdata(x, base64, 0);
                           iks_send(client->p, x);
                           iks_delete(x);
                           if (base64)
                              free(base64);
                           if (s)
                              free(s);
                        } else {
                           ast_log(LOG_ERROR, "Out of memory.\n");
                        }
                     }
                  }
               }
            }
         } else if (!strcmp("failure", iks_name(node))) {
            ast_log(LOG_ERROR, "JABBER: encryption failure. possible bad password.\n");
         } else if (!strcmp("success", iks_name(node))) {
            client->authorized = 1;
            iks_send_header(client->p, client->jid->server);
         }
         break;
      case IKS_NODE_ERROR: 
            ast_log(LOG_ERROR, "JABBER: Node Error\n");
            ASTOBJ_UNREF(client, aji_client_destroy);
            return IKS_HOOK;
            break;
      case IKS_NODE_STOP: 
            ast_log(LOG_WARNING, "JABBER: Disconnected\n");
            ASTOBJ_UNREF(client, aji_client_destroy);
            return IKS_HOOK;
            break;
      }
   } else if (client->state != AJI_CONNECTED && client->component) {
      switch (type) {
      case IKS_NODE_START:
         if (client->state == AJI_DISCONNECTED) {
            char secret[160], shasum[320], *handshake;

            sprintf(secret, "%s%s", pak->id, client->password);
            ast_sha1_hash(shasum, secret);
            handshake = NULL;
            asprintf(&handshake, "<handshake>%s</handshake>", shasum);
            if (handshake) {
               iks_send_raw(client->p, handshake);
               free(handshake);
               handshake = NULL;
            }
            client->state = AJI_CONNECTING;
            if(iks_recv(client->p,1) == 2) /*XXX proper result for iksemel library on iks_recv of <handshake/> XXX*/
               client->state = AJI_CONNECTED;
            else
               ast_log(LOG_WARNING,"Jabber didn't seem to handshake, failed to authenicate.\n");
            break;
         }
         break;

      case IKS_NODE_NORMAL:
         break;

      case IKS_NODE_ERROR:
         ast_log(LOG_ERROR, "JABBER: Node Error\n");
         ASTOBJ_UNREF(client, aji_client_destroy);
         return IKS_HOOK;

      case IKS_NODE_STOP:
         ast_log(LOG_WARNING, "JABBER: Disconnected\n");
         ASTOBJ_UNREF(client, aji_client_destroy);
         return IKS_HOOK;
      }
   }

   switch (pak->type) {
   case IKS_PAK_NONE:
      if (option_debug)
         ast_log(LOG_DEBUG, "JABBER: I Don't know what to do with you NONE\n");
      break;
   case IKS_PAK_MESSAGE:
      aji_handle_message(client, pak);
      if (option_debug)
         ast_log(LOG_DEBUG, "JABBER: I Don't know what to do with you MESSAGE\n");
      break;
   case IKS_PAK_PRESENCE:
      aji_handle_presence(client, pak);
      if (option_debug)
         ast_log(LOG_DEBUG, "JABBER: I Do know how to handle presence!!\n");
      break;
   case IKS_PAK_S10N:
      aji_handle_subscribe(client, pak);
      if (option_debug)
         ast_log(LOG_DEBUG, "JABBER: I Dont know S10N subscribe!!\n");
      break;
   case IKS_PAK_IQ:
      if (option_debug)
         ast_log(LOG_DEBUG, "JABBER: I Dont have an IQ!!!\n");
      aji_handle_iq(client, node);
      break;
   default:
      if (option_debug)
         ast_log(LOG_DEBUG, "JABBER: I Dont know %i\n", pak->type);
      break;
   }
   
   iks_filter_packet(client->f, pak);

   if (node)
      iks_delete(node);

   ASTOBJ_UNREF(client, aji_client_destroy);
   return IKS_OK;
}

static int aji_register_approve_handler(void *data, ikspak *pak)
{
   struct aji_client *client = ASTOBJ_REF((struct aji_client *) data);
   iks *iq = NULL, *presence = NULL, *x = NULL;

   iq = iks_new("iq");
   presence = iks_new("presence");
   x = iks_new("x");
   if (client && iq && presence && x) {
      if (!iks_find(pak->query, "remove")) {
         iks_insert_attrib(iq, "from", client->jid->full);
         iks_insert_attrib(iq, "to", pak->from->full);
         iks_insert_attrib(iq, "id", pak->id);
         iks_insert_attrib(iq, "type", "result");
         iks_send(client->p, iq);

         iks_insert_attrib(presence, "from", client->jid->full);
         iks_insert_attrib(presence, "to", pak->from->partial);
         iks_insert_attrib(presence, "id", client->mid);
         ast_aji_increment_mid(client->mid);
         iks_insert_attrib(presence, "type", "subscribe");
         iks_insert_attrib(x, "xmlns", "vcard-temp:x:update");
         iks_insert_node(presence, x);
         iks_send(client->p, presence); 
      }
   } else {
      ast_log(LOG_ERROR, "Out of memory.\n");
   }

   if (iq)
      iks_delete(iq);
   if(presence)
      iks_delete(presence);
   if (x)
      iks_delete(x);
   ASTOBJ_UNREF(client, aji_client_destroy);
   return IKS_FILTER_EAT;
}

static int aji_register_query_handler(void *data, ikspak *pak)
{
   struct aji_client *client = ASTOBJ_REF((struct aji_client *) data);
   struct aji_buddy *buddy = NULL; 
   char *node = NULL;

   client = (struct aji_client *) data;

   buddy = ASTOBJ_CONTAINER_FIND(&client->buddies, pak->from->partial);
   if (!buddy) {
      iks *iq = NULL, *query = NULL, *error = NULL, *notacceptable = NULL;
      ast_verbose("Someone.... %s tried to register but they aren't allowed\n", pak->from->partial);
      iq = iks_new("iq");
      query = iks_new("query");
      error = iks_new("error");
      notacceptable = iks_new("not-acceptable");
      if(iq && query && error && notacceptable) {
         iks_insert_attrib(iq, "type", "error");
         iks_insert_attrib(iq, "from", client->user);
         iks_insert_attrib(iq, "to", pak->from->full);
         iks_insert_attrib(iq, "id", pak->id);
         iks_insert_attrib(query, "xmlns", "jabber:iq:register");
         iks_insert_attrib(error, "code" , "406");
         iks_insert_attrib(error, "type", "modify");
         iks_insert_attrib(notacceptable, "xmlns", "urn:ietf:params:xml:ns:xmpp-stanzas");
         iks_insert_node(iq, query);
         iks_insert_node(iq, error);
         iks_insert_node(error, notacceptable);
         iks_send(client->p, iq);
      } else {
         ast_log(LOG_ERROR, "Out of memory.\n");
      }
      if (iq)
         iks_delete(iq);
      if (query)
         iks_delete(query);
      if (error)
         iks_delete(error);
      if (notacceptable)
         iks_delete(notacceptable);
   } else   if (!(node = iks_find_attrib(pak->query, "node"))) {
      iks *iq = NULL, *query = NULL, *instructions = NULL;
      char *explain = "Welcome to Asterisk - the Open Source PBX.\n";
      iq = iks_new("iq");
      query = iks_new("query");
      instructions = iks_new("instructions");
      if (iq && query && instructions && client) {
         iks_insert_attrib(iq, "from", client->user);
         iks_insert_attrib(iq, "to", pak->from->full);
         iks_insert_attrib(iq, "id", pak->id);
         iks_insert_attrib(iq, "type", "result");
         iks_insert_attrib(query, "xmlns", "jabber:iq:register");
         iks_insert_cdata(instructions, explain, 0);
         iks_insert_node(iq, query);
         iks_insert_node(query, instructions);
         iks_send(client->p, iq);
      } else {
         ast_log(LOG_ERROR, "Out of memory.\n");
      }
      if (iq)
         iks_delete(iq);
      if (query)
         iks_delete(query);
      if (instructions)
         iks_delete(instructions);
   }
   ASTOBJ_UNREF(client, aji_client_destroy);
   return IKS_FILTER_EAT;
}

static int aji_ditems_handler(void *data, ikspak *pak)
{
   struct aji_client *client = ASTOBJ_REF((struct aji_client *) data);
   char *node = NULL;

   if (!(node = iks_find_attrib(pak->query, "node"))) {
      iks *iq = NULL, *query = NULL, *item = NULL;
      iq = iks_new("iq");
      query = iks_new("query");
      item = iks_new("item");

      if (iq && query && item) {
         iks_insert_attrib(iq, "from", client->user);
         iks_insert_attrib(iq, "to", pak->from->full);
         iks_insert_attrib(iq, "id", pak->id);
         iks_insert_attrib(iq, "type", "result");
         iks_insert_attrib(query, "xmlns", "http://jabber.org/protocol/disco#items");
         iks_insert_attrib(item, "node", "http://jabber.org/protocol/commands");
         iks_insert_attrib(item, "name", "Million Dollar Asterisk Commands");
         iks_insert_attrib(item, "jid", client->user);

         iks_insert_node(iq, query);
         iks_insert_node(query, item);
         iks_send(client->p, iq);
      } else {
         ast_log(LOG_ERROR, "Out of memory.\n");
      }
      if (iq)
         iks_delete(iq);
      if (query)
         iks_delete(query);
      if (item)
         iks_delete(item);

   } else if (!strcasecmp(node, "http://jabber.org/protocol/commands")) {
      iks *iq, *query, *confirm;
      iq = iks_new("iq");
      query = iks_new("query");
      confirm = iks_new("item");
      if (iq && query && confirm && client) {
         iks_insert_attrib(iq, "from", client->user);
         iks_insert_attrib(iq, "to", pak->from->full);
         iks_insert_attrib(iq, "id", pak->id);
         iks_insert_attrib(iq, "type", "result");
         iks_insert_attrib(query, "xmlns", "http://jabber.org/protocol/disco#items");
         iks_insert_attrib(query, "node", "http://jabber.org/protocol/commands");
         iks_insert_attrib(confirm, "node", "confirmaccount");
         iks_insert_attrib(confirm, "name", "Confirm AIM account");
         iks_insert_attrib(confirm, "jid", "blog.astjab.org");

         iks_insert_node(iq, query);
         iks_insert_node(query, confirm);
         iks_send(client->p, iq);
      } else {
         ast_log(LOG_ERROR, "Out of memory.\n");
      }
      if (iq)
         iks_delete(iq);
      if (query)
         iks_delete(query);
      if (confirm)
         iks_delete(confirm);

   } else if (!strcasecmp(node, "confirmaccount")) {
      iks *iq = NULL, *query = NULL, *feature = NULL;

      iq = iks_new("iq");
      query = iks_new("query");
      feature = iks_new("feature");

      if (iq && query && feature && client) {
         iks_insert_attrib(iq, "from", client->user);
         iks_insert_attrib(iq, "to", pak->from->full);
         iks_insert_attrib(iq, "id", pak->id);
         iks_insert_attrib(iq, "type", "result");
         iks_insert_attrib(query, "xmlns", "http://jabber.org/protocol/disco#items");
         iks_insert_attrib(feature, "var", "http://jabber.org/protocol/commands");
         iks_insert_node(iq, query);
         iks_insert_node(query, feature);
         iks_send(client->p, iq);
      } else {
         ast_log(LOG_ERROR, "Out of memory.\n");
      }
      if (iq)
         iks_delete(iq);
      if (query)
         iks_delete(query);
      if (feature)
         iks_delete(feature);
   }

   ASTOBJ_UNREF(client, aji_client_destroy);
   return IKS_FILTER_EAT;

}

static int aji_client_info_handler(void *data, ikspak *pak)
{
   struct aji_client *client = ASTOBJ_REF((struct aji_client *) data);
   struct aji_resource *resource = NULL;
   struct aji_buddy *buddy = ASTOBJ_CONTAINER_FIND(&client->buddies, pak->from->partial);

   resource = aji_find_resource(buddy, pak->from->resource);
   if (pak->subtype == IKS_TYPE_RESULT) {
      if (!resource) {
         ast_log(LOG_NOTICE,"JABBER: Received client info from %s when not requested.\n", pak->from->full);
         ASTOBJ_UNREF(client, aji_client_destroy);
         return IKS_FILTER_EAT;
      }
      if (iks_find_with_attrib(pak->query, "feature", "var", "http://www.google.com/xmpp/protocol/voice/v1")) {
         resource->cap->jingle = 1;
      } else
         resource->cap->jingle = 0;
   } else if (pak->subtype == IKS_TYPE_GET) {
      iks *iq, *disco, *ident, *google, *query;
      iq = iks_new("iq");
      query = iks_new("query");
      ident = iks_new("identity");
      disco = iks_new("feature");
      google = iks_new("feature");
      if (iq && ident && disco && google) {
         iks_insert_attrib(iq, "from", client->jid->full);
         iks_insert_attrib(iq, "to", pak->from->full);
         iks_insert_attrib(iq, "type", "result");
         iks_insert_attrib(iq, "id", pak->id);
         iks_insert_attrib(query, "xmlns", "http://jabber.org/protocol/disco#info");
         iks_insert_attrib(ident, "category", "client");
         iks_insert_attrib(ident, "type", "pc");
         iks_insert_attrib(ident, "name", "asterisk");
         iks_insert_attrib(disco, "var", "http://jabber.org/protocol/disco#info");
         iks_insert_attrib(google, "var", "http://www.google.com/xmpp/protocol/voice/v1");
         iks_insert_node(iq, query);
         iks_insert_node(query, ident);
         iks_insert_node(query, google);
         iks_insert_node(query, disco);
         iks_send(client->p, iq);
      } else
         ast_log(LOG_ERROR, "Out of Memory.\n");
      if (iq)
         iks_delete(iq);
      if (query)
         iks_delete(query);
      if (ident)
         iks_delete(ident);
      if (google)
         iks_delete(google);
      if (disco)
         iks_delete(disco);
   } else if (pak->subtype == IKS_TYPE_ERROR) {
      ast_log(LOG_NOTICE, "User %s does not support discovery.\n", pak->from->full);
   }
   ASTOBJ_UNREF(client, aji_client_destroy);
   return IKS_FILTER_EAT;
}

static int aji_dinfo_handler(void *data, ikspak *pak)
{
   struct aji_client *client = ASTOBJ_REF((struct aji_client *) data);
   char *node = NULL;
   struct aji_resource *resource = NULL;
   struct aji_buddy *buddy = ASTOBJ_CONTAINER_FIND(&client->buddies, pak->from->partial);

   resource = aji_find_resource(buddy, pak->from->resource);
   if (pak->subtype == IKS_TYPE_ERROR) {
      ast_log(LOG_WARNING, "Recieved error from a client, turn on jabber debug!\n");
      return IKS_FILTER_EAT;
   }
   if (pak->subtype == IKS_TYPE_RESULT) {
      if (!resource) {
         ast_log(LOG_NOTICE,"JABBER: Received client info from %s when not requested.\n", pak->from->full);