Home page | Mailing list | Docs

Last updated: Sat Feb 3 05:01:45 2007

Asterisk developer's documentation :: Codename Pineapple

---

res_jabber.c File Reference

---

Detailed Description

A resource for interfacing asterisk directly as a client or a component to a jabber compliant server.

Definition in file res_jabber.c.

#include "asterisk.h"
#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"

Include dependency graph for res_jabber.c:

Go to the source code of this file.

Defines
#define	JABBER_CONFIG   "jabber.conf"
Functions
static int	aji_act_hook (void *data, int type, iks *node)
	The action hook parses the inbound packets, constantly running.
static void	aji_buddy_destroy (struct aji_buddy *obj)
	Deletes the aji_buddy data structure.
static int	aji_client_connect (void *data, ikspak *pak)
	connects as a client to jabber server.
static void	aji_client_destroy (struct aji_client *obj)
	Deletes the aji_client data structure.
static int	aji_client_info_handler (void *data, ikspak *pak)
static int	aji_client_initialize (struct aji_client *client)
	prepares client for connect.
static int	aji_component_initialize (struct aji_client *client)
	prepares component for connect.
static int	aji_create_buddy (char *label, struct aji_client *client)
	creates transport. creates buddy.
static int	aji_create_client (char *label, struct ast_variable *var, int debug)
	creates aji_client structure.
static int	aji_dinfo_handler (void *data, ikspak *pak)
static int	aji_ditems_handler (void *data, ikspak *pak)
static int	aji_do_debug (int fd, int argc, char *argv[])
	turnon console debugging.
static int	aji_do_reload (int fd, int argc, char *argv[])
	reload jabber module.
static int	aji_filter_roster (void *data, ikspak *pak)
	filters the roster packet we get back from server.
static struct aji_resource *	aji_find_resource (struct aji_buddy *buddy, char *name)
static struct aji_version *	aji_find_version (char *node, char *version, ikspak *pak)
static int	aji_get_roster (struct aji_client *client)
static void	aji_handle_iq (struct aji_client *client, iks *node)
	Handles <iq> tags.
static void	aji_handle_message (struct aji_client *client, ikspak *pak)
	Handles presence packets.
static void	aji_handle_presence (struct aji_client *client, ikspak *pak)
static void	aji_handle_subscribe (struct aji_client *client, ikspak *pak)
	handles subscription requests.
static int	aji_highest_bit (int number)
	Detects the highest bit in a number.
static int	aji_load_config (void)
	load config file.
static void	aji_log_hook (void *data, const char *xmpp, size_t size, int is_incoming)
	the debug loop.
static int	aji_no_debug (int fd, int argc, char *argv[])
	turnoff console debugging.
static void	aji_pruneregister (struct aji_client *client)
	attempts to register to a transport. attempts to register to a transport step 2. goes through roster and prunes users not needed in list, or adds them accordingly.
static int	aji_reconnect (struct aji_client *client)
static void *	aji_recv_loop (void *data)
	receive message loop.
static int	aji_register_approve_handler (void *data, ikspak *pak)
static int	aji_register_query_handler (void *data, ikspak *pak)
static int	aji_reload (void)
static int	aji_send_exec (struct ast_channel *chan, void *data)
	Dial plan function to send a message.
static void	aji_set_presence (struct aji_client *client, char *to, char *from, int level, char *desc)
	set presence of client.
static int	aji_show_clients (int fd, int argc, char *argv[])
	show client status.
static int	aji_status_exec (struct ast_channel *chan, void *data)
	Dial plan function status(). puts the status of watched user into a channel variable.
static int	aji_test (int fd, int argc, char *argv[])
	send test message for debugging.
int	ast_aji_create_chat (struct aji_client *client, char *room, char *server, char *topic)
	create a chatroom.
int	ast_aji_disconnect (struct aji_client *client)
	disconnect from jabber server.
aji_client *	ast_aji_get_client (const char *name)
	grab a aji_client structure by label name.
aji_client_container *	ast_aji_get_clients (void)
void	ast_aji_increment_mid (char *mid)
	increments the mid field for messages and other events.
int	ast_aji_invite_chat (struct aji_client *client, char *user, char *room, char *message)
	invite to a chatroom.
int	ast_aji_join_chat (struct aji_client *client, char *room)
	join a chatroom.
int	ast_aji_send (struct aji_client *client, const char *address, const char *message)
	sends messages.
	AST_MODULE_INFO (ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS,"AJI - Asterisk Jabber Interface",.load=load_module,.unload=unload_module,.reload=reload,)
static int	gtalk_yuck (iks *node)
static iks *	jabber_make_auth (iksid *id, const char *pass, const char *sid)
static int	load_module (void)
static int	manager_jabber_send (struct mansession *s, const struct message *m)
	Send a Jabber Message via call from the Manager.
static int	reload (void)
static int	unload_module (void)
Variables
static struct ast_cli_entry	aji_cli []
static char *	ajisend_descrip
static char *	ajisend_synopsis = "JabberSend(jabber,screenname,message)"
static char *	ajistatus_descrip
static char *	ajistatus_synopsis = "JabberStatus(Jabber,ScreenName,Variable)"
static char *	app_ajisend = "JabberSend"
static char *	app_ajistatus = "JabberStatus"
aji_capabilities *	capabilities
aji_client_container	clients
static const char	debug_usage []
static struct ast_flags	globalflags = { AJI_AUTOPRUNE | AJI_AUTOREGISTER }
	Global flags, initialized to default values.
static char	mandescr_jabber_send []
static const char	no_debug_usage []
static const char	reload_usage []
static const char	test_usage []

---

Define Documentation

#define JABBER_CONFIG   "jabber.conf"

Definition at line 55 of file res_jabber.c. Referenced by aji_load_config().

---

Function Documentation

static int aji_act_hook (  void *  data, int  type, iks *  node )  [static]

The action hook parses the inbound packets, constantly running. Parameters: aji  client structure, type of packet, the actual packet. Returns: IKS_OK or IKS_HOOK . Definition at line 460 of file res_jabber.c. References aji_client_connect(), aji_client_destroy(), AJI_CONNECTED, AJI_CONNECTING, AJI_DISCONNECTED, aji_handle_iq(), aji_handle_message(), aji_handle_presence(), aji_handle_subscribe(), aji_highest_bit(), asprintf, ast_aji_increment_mid(), ast_base64encode(), ast_log(), ast_malloc, ast_sha1_hash(), ASTOBJ_REF, ASTOBJ_UNREF, aji_client::authorized, base64, aji_client::component, aji_client::f, free, jabber_make_auth(), aji_client::jid, len, LOG_DEBUG, LOG_ERROR, LOG_WARNING, aji_client::mid, option_debug, aji_client::p, aji_client::password, s, secret, aji_client::state, aji_client::usesasl, and aji_client::usetls. Referenced by aji_create_client(). { 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; } 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); else ast_log(LOG_ERROR, "gnuTLS not installed.\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: { int features = 0; if (!strcmp("stream:features", iks_name(node))) { 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 { 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); ast_base64encode(base64, (const unsigned char *) s, len, 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 void aji_buddy_destroy (  struct aji_buddy *  obj  )  [static]

Deletes the aji_buddy data structure. Parameters: obj  is the structure we will delete. Returns: void. Definition at line 197 of file res_jabber.c. References aji_resource::description, free, aji_resource::next, and aji_buddy::resources. Referenced by aji_client_destroy(), aji_create_buddy(), and aji_handle_presence(). { struct aji_resource *tmp; while ((tmp = obj->resources)) { obj->resources = obj->resources->next; free(tmp->description); free(tmp); } free(obj); }

static int aji_client_connect (  void *  data, ikspak *  pak )  [static]

connects as a client to jabber server. Parameters: aji_client  struct, and xml packet. Returns: res. Definition at line 1790 of file res_jabber.c. References aji_client_destroy(), AJI_CONNECTING, AJI_DISCONNECTED, aji_filter_roster(), aji_get_roster(), ast_log(), ASTOBJ_REF, ASTOBJ_UNREF, aji_client::component, aji_client::f, aji_client::jid, LOG_ERROR, aji_client::stack, and aji_client::state. Referenced by aji_act_hook(). { struct aji_client *client = ASTOBJ_REF((struct aji_client *) data); int res = 0; if (client) { if (client->state == AJI_DISCONNECTED) { iks_filter_add_rule(client->f, aji_filter_roster, client, IKS_RULE_TYPE, IKS_PAK_IQ, IKS_RULE_SUBTYPE, IKS_TYPE_RESULT, IKS_RULE_ID, "roster", IKS_RULE_DONE); client->state = AJI_CONNECTING; client->jid = (iks_find_cdata(pak->query, "jid")) ? iks_id_new(client->stack, iks_find_cdata(pak->query, "jid")) : client->jid; iks_filter_remove_hook(client->f, aji_client_connect); if(!client->component) /*client*/ aji_get_roster(client); } } else ast_log(LOG_ERROR, "Out of memory.\n"); ASTOBJ_UNREF(client, aji_client_destroy); return res; }

static void aji_client_destroy (  struct aji_client *  obj  )  [static]

Deletes the aji_client data structure. Parameters: obj  is the structure we will delete. Returns: void. Definition at line 173 of file res_jabber.c. References aji_buddy_destroy(), AST_LIST_HEAD_DESTROY, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, ASTOBJ_CONTAINER_DESTROY, ASTOBJ_CONTAINER_DESTROYALL, aji_client::buddies, aji_client::f, free, aji_message::from, aji_message::message, aji_client::p, and aji_client::stack. Referenced by aji_act_hook(), aji_client_connect(), aji_client_info_handler(), aji_create_client(), aji_dinfo_handler(), aji_ditems_handler(), aji_log_hook(), aji_recv_loop(), aji_register_approve_handler(), aji_register_query_handler(), aji_reload(), and ast_aji_disconnect(). { 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); }

static int aji_client_info_handler (  void *  data, ikspak *  pak )  [static]

Definition at line 868 of file res_jabber.c. References aji_client_destroy(), aji_find_resource(), ast_log(), ASTOBJ_CONTAINER_FIND, ASTOBJ_REF, ASTOBJ_UNREF, aji_client::buddies, aji_resource::cap, aji_client::jid, aji_version::jingle, LOG_ERROR, LOG_NOTICE, aji_client::p, and aji_resource::resource. Referenced by aji_create_client(). { 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_client_initialize (  struct aji_client *  client  )  [static]

prepares client for connect. Parameters: aji_client  struct. Returns: 1. Definition at line 1816 of file res_jabber.c. References ast_log(), aji_client::jid, LOG_ERROR, aji_client::p, aji_client::port, S_OR, and aji_client::serverhost. Referenced by aji_reconnect(). { int connected = 0; connected = iks_connect_via(client->p, S_OR(client->serverhost, client->jid->server), client->port, client->jid->server); if (connected == IKS_NET_NOCONN) { ast_log(LOG_ERROR, "JABBER ERROR: No Connection\n"); return IKS_HOOK; } else if (connected == IKS_NET_NODNS) { ast_log(LOG_ERROR, "JABBER ERROR: No DNS %s for client to %s\n", client->name, S_OR(client->serverhost, client->jid->server)); return IKS_HOOK; } else iks_recv(client->p, 30); return IKS_OK; }

static int aji_component_initialize (  struct aji_client *  client  )  [static]

prepares component for connect. Parameters: aji_client  struct. Returns: 1. Definition at line 1838 of file res_jabber.c. References ast_log(), aji_client::jid, LOG_ERROR, aji_client::p, aji_client::port, and aji_client::user. Referenced by aji_reconnect(). { int connected = 1; connected = iks_connect_via(client->p, client->jid->server, client->port, client->user); if (connected == IKS_NET_NOCONN) { ast_log(LOG_ERROR, "JABBER ERROR: No Connection\n"); return IKS_HOOK; } else if (connected == IKS_NET_NODNS) { ast_log(LOG_ERROR, "JABBER ERROR: No DNS\n"); return IKS_HOOK; } else if (!connected) iks_recv(client->p, 30); return IKS_OK; }

static int aji_create_buddy (  char *  label, struct aji_client *  client )  [static]

creates transport. creates buddy. Parameters: label,buddy  to dump it into. Returns: 0. Definition at line 2227 of file res_jabber.c. References aji_buddy_destroy(), ast_log(), ASTOBJ_CONTAINER_FIND, ASTOBJ_CONTAINER_LINK, ASTOBJ_INIT, ASTOBJ_UNLOCK, ASTOBJ_UNMARK, ASTOBJ_UNREF, ASTOBJ_WRLOCK, aji_client::buddies, LOG_WARNING, and malloc. Referenced by aji_create_client(), and aji_handle_presence(). { struct aji_buddy *buddy = NULL; int flag = 0; buddy = ASTOBJ_CONTAINER_FIND(&client->buddies,label); if (!buddy) { flag = 1; buddy = malloc(sizeof(struct aji_buddy)); if(!buddy) { ast_log(LOG_WARNING, "Out of memory\n"); return 0; } memset(buddy, 0, sizeof(struct aji_buddy)); ASTOBJ_INIT(buddy); } ASTOBJ_WRLOCK(buddy); ast_copy_string(buddy->name, label, sizeof(buddy->name)); ASTOBJ_UNLOCK(buddy); if(flag) ASTOBJ_CONTAINER_LINK(&client->buddies, buddy); else { ASTOBJ_UNMARK(buddy); ASTOBJ_UNREF(buddy, aji_buddy_destroy); } return 1; }

static int aji_create_client (  char *  label, struct ast_variable *  var, int  debug )  [static]

creates aji_client structure. Parameters: label,ast_variable,debug,pruneregister,component/client,aji_client  to dump into. Returns: 0. Definition at line 2037 of file res_jabber.c. References aji_act_hook(), AJI_AUTOPRUNE, AJI_AUTOREGISTER, aji_client_destroy(), aji_client_info_handler(), aji_create_buddy(), aji_dinfo_handler(), AJI_DISCONNECTED, aji_ditems_handler(), aji_log_hook(), aji_register_approve_handler(), aji_register_query_handler(), asprintf, ast_copy_flags, ast_false(), AST_FLAGS_ALL, AST_LIST_HEAD_INIT, ast_log(), ast_set2_flag, ast_true(), ASTOBJ_CONTAINER_FIND, ASTOBJ_CONTAINER_INIT, ASTOBJ_CONTAINER_LINK, ASTOBJ_CONTAINER_MARKALL, ASTOBJ_INIT, ASTOBJ_UNLOCK, ASTOBJ_UNMARK, ASTOBJ_UNREF, ASTOBJ_WRLOCK, aji_client::authorized, aji_client::buddies, clients, aji_client::component, aji_client::debug, aji_client::f, aji_client::forcessl, free, globalflags, aji_client::jid, aji_client::keepalive, LOG_ERROR, malloc, aji_client::message_timeout, aji_client::mid, aji_client::p, aji_client::password, aji_client::port, aji_client::serverhost, aji_client::stack, aji_client::state, aji_client::statusmessage, aji_client::timeout, aji_client::user, aji_client::usesasl, aji_client::usetls, and var. { char *resource; struct aji_client *client = NULL; int flag = 0; client = ASTOBJ_CONTAINER_FIND(&clients,label); if (!client) { flag = 1; client = (struct aji_client *) malloc(sizeof(struct aji_client)); if (!client) { ast_log(LOG_ERROR, "Out of memory!\n"); return 0; } memset(client, 0, sizeof(struct aji_client)); ASTOBJ_INIT(client); ASTOBJ_WRLOCK(client); ASTOBJ_CONTAINER_INIT(&client->buddies); } else { ASTOBJ_WRLOCK(client); ASTOBJ_UNMARK(client); } ASTOBJ_CONTAINER_MARKALL(&client->buddies); ast_copy_string(client->name, label, sizeof(client->name)); ast_copy_string(client->mid, "aaaaa", sizeof(client->mid)); client->debug = debug; ast_copy_flags(client, &globalflags, AST_FLAGS_ALL); client->port = 5222; client->usetls = 1; client->usesasl = 1; client->forcessl = 0; client->keepalive = 1; client->timeout = 50; client->message_timeout = 100; AST_LIST_HEAD_INIT(&client->messages); client->component = 0; ast_copy_string(client->statusmessage, "Online and Available", sizeof(client->statusmessage)); if (flag) { client->authorized = 0; client->state = AJI_DISCONNECTED; } while (var) { if (!strcasecmp(var->name, "username")) ast_copy_string(client->user, var->value, sizeof(client->user)); else if (!strcasecmp(var->name, "serverhost")) ast_copy_string(client->serverhost, var->value, sizeof(client->serverhost)); else if (!strcasecmp(var->name, "secret")) ast_copy_string(client->password, var->value, sizeof(client->password)); else if (!strcasecmp(var->name, "statusmessage")) ast_copy_string(client->statusmessage, var->value, sizeof(client->statusmessage)); else if (!strcasecmp(var->name, "port")) client->port = atoi(var->value); else if (!strcasecmp(var->name, "timeout")) client->message_timeout = atoi(var->value); else if (!strcasecmp(var->name, "debug")) client->debug = (ast_false(var->value)) ? 0 : 1; else if (!strcasecmp(var->name, "type")) { if (!strcasecmp(var->value, "component")) client->component = 1; } else if (!strcasecmp(var->name, "usetls")) { client->usetls = (ast_false(var->value)) ? 0 : 1; } else if (!strcasecmp(var->name, "usesasl")) { client->usesasl = (ast_false(var->value)) ? 0 : 1; } else if (!strcasecmp(var->name, "forceoldssl")) client->forcessl = (ast_false(var->value)) ? 0 : 1; else if (!strcasecmp(var->name, "keepalive")) client->keepalive = (ast_false(var->value)) ? 0 : 1; else if (!strcasecmp(var->name, "autoprune")) ast_set2_flag(client, ast_true(var->value), AJI_AUTOPRUNE); else if (!strcasecmp(var->name, "autoregister")) ast_set2_flag(client, ast_true(var->value), AJI_AUTOREGISTER); else if (!strcasecmp(var->name, "buddy")) aji_create_buddy(var->value, client); /* no transport support in this version */ /* else if (!strcasecmp(var->name, "transport")) aji_create_transport(var->value, client); */ var = var->next; } if (!flag) { ASTOBJ_UNLOCK(client); ASTOBJ_UNREF(client, aji_client_destroy); return 1; } client->p = iks_stream_new(((client->component) ? "jabber:component:accept" : "jabber:client"), client, aji_act_hook); if (!client->p) { ast_log(LOG_ERROR, "Failed to create stream for client '%s'!\n", client->name); return 0; } client->stack = iks_stack_new(8192, 8192); if (!client->stack) { ast_log(LOG_ERROR, "Failed to allocate stack for client '%s'\n", client->name); return 0; } client->f = iks_filter_new(); if (!client->f) { ast_log(LOG_ERROR, "Failed to create filter for client '%s'\n", client->name); return 0; } if (!strchr(client->user, '/') && !client->component) { /*client */ resource = NULL; asprintf(&resource, "%s/asterisk", client->user); if (resource) { client->jid = iks_id_new(client->stack, resource); free(resource); } } else client->jid = iks_id_new(client->stack, client->user); if (client->component) { iks_filter_add_rule(client->f, aji_dinfo_handler, client, IKS_RULE_NS, "http://jabber.org/protocol/disco#info", IKS_RULE_DONE); iks_filter_add_rule(client->f, aji_ditems_handler, client, IKS_RULE_NS, "http://jabber.org/protocol/disco#items", IKS_RULE_DONE); iks_filter_add_rule(client->f, aji_register_query_handler, client, IKS_RULE_SUBTYPE, IKS_TYPE_GET, IKS_RULE_NS, "jabber:iq:register", IKS_RULE_DONE); iks_filter_add_rule(client->f, aji_register_approve_handler, client, IKS_RULE_SUBTYPE, IKS_TYPE_SET, IKS_RULE_NS, "jabber:iq:register", IKS_RULE_DONE); } else { iks_filter_add_rule(client->f, aji_client_info_handler, client, IKS_RULE_NS, "http://jabber.org/protocol/disco#info", IKS_RULE_DONE); } if (!strchr(client->user, '/') && !client->component) { /*client */ resource = NULL; asprintf(&resource, "%s/asterisk", client->user); if (resource) { client->jid = iks_id_new(client->stack, resource); free(resource); } } else client->jid = iks_id_new(client->stack, client->user); iks_set_log_hook(client->p, aji_log_hook); ASTOBJ_UNLOCK(client); ASTOBJ_CONTAINER_LINK(&clients,client); return 1; }

static int aji_dinfo_handler (  void *  data, ikspak *  pak )  [static]

Definition at line 927 of file res_jabber.c. References aji_client_destroy(), aji_find_resource(), ast_log(), ASTOBJ_CONTAINER_FIND, ASTOBJ_REF, ASTOBJ_UNREF, aji_client::buddies, aji_resource::cap, commands, aji_version::jingle, LOG_ERROR, LOG_NOTICE, LOG_WARNING, aji_client::p, aji_resource::resource, and aji_client::user. Referenced by aji_create_client(). { 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); 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 && !(node = iks_find_attrib(pak->query, "node"))) { iks *iq, *query, *identity, *disco, *reg, *commands, *gateway, *version, *vcard, *search; iq = iks_new("iq"); query = iks_new("query"); identity = iks_new("identity"); disco = iks_new("feature"); reg = iks_new("feature"); commands = iks_new("feature"); gateway = iks_new("feature"); version = iks_new("feature"); vcard = iks_new("feature"); search = iks_new("feature"); if (iq && query && identity && disco && reg && commands && gateway && version && vcard && search && 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#info"); iks_insert_attrib(identity, "category", "gateway"); iks_insert_attrib(identity, "type", "pstn"); iks_insert_attrib(identity, "name", "Asterisk The Open Source PBX"); iks_insert_attrib(disco, "var", "http://jabber.org/protocol/disco"); iks_insert_attrib(reg, "var", "jabber:iq:register"); iks_insert_attrib(commands, "var", "http://jabber.org/protocol/commands"); iks_insert_attrib(gateway, "var", "jabber:iq:gateway"); iks_insert_attrib(version, "var", "jabber:iq:version"); iks_insert_attrib(vcard, "var", "vcard-temp"); iks_insert_attrib(search, "var", "jabber:iq:search"); iks_insert_node(iq, query); iks_insert_node(query, identity); iks_insert_node(query, disco); iks_insert_node(query, reg); iks_insert_node(query, commands); iks_insert_node(query, gateway); iks_insert_node(query, version); iks_insert_node(query, vcard); iks_insert_node(query, search); 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 (identity) iks_delete(identity); if (disco) iks_delete(disco); if (reg) iks_delete(reg); if (commands) iks_delete(commands); if (gateway) iks_delete(gateway); if (version) iks_delete(version); if (vcard) iks_delete(vcard); if (search) iks_delete(search); } else if (pak->subtype == IKS_TYPE_GET && !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", client->user); 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 (pak->subtype == IKS_TYPE_GET && !strcasecmp(node, "confirmaccount")) { iks *iq, *query, *feature; 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#info"); 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_ditems_handler (  void *  data, ikspak *  pak )  [static]

Definition at line 772 of file res_jabber.c. References aji_client_destroy(), ast_log(), ASTOBJ_REF, ASTOBJ_UNREF, LOG_ERROR, aji_client::p, and aji_client::user. Referenced by aji_create_client(). { 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_do_debug (  int  fd, int  argc, char *  argv[] )  [static]

turnon console debugging. Parameters: fd,number  of args, args. Returns: RESULT_SUCCESS. Definition at line 1908 of file res_jabber.c. References ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, and clients. { ASTOBJ_CONTAINER_TRAVERSE(&clients, 1, { ASTOBJ_RDLOCK(iterator); iterator->debug = 1; ASTOBJ_UNLOCK(iterator); }); ast_cli(fd, "Jabber Debugging Enabled.\n"); return RESULT_SUCCESS; }

static int aji_do_reload (  int  fd, int  argc, char *  argv[] )  [static]

reload jabber module. Parameters: fd,number  of args, args. Returns: RESULT_SUCCESS. Definition at line 1924 of file res_jabber.c. References aji_reload(), ast_cli(), and RESULT_SUCCESS. { aji_reload(); ast_cli(fd, "Jabber Reloaded.\n"); return RESULT_SUCCESS; }

static int aji_filter_roster (  void *  data, ikspak *  pak )  [static]

filters the roster packet we get back from server. Parameters: aji_client  struct, and xml packet. Returns: IKS_FILTER_EAT. Definition at line 1679 of file res_jabber.c. References AJI_AUTOPRUNE, AJI_AUTOREGISTER, AJI_CONNECTED, ast_clear_flag, ast_copy_flags, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_REF, ASTOBJ_UNLOCK, aji_client::buddies, and aji_client::state. Referenced by aji_client_connect(). { struct aji_client *client = ASTOBJ_REF((struct aji_client *) data); int flag = 0; iks *x = NULL; struct aji_buddy *buddy; client->state = AJI_CONNECTED; ASTOBJ_CONTAINER_TRAVERSE(&client->buddies, 1, { ASTOBJ_RDLOCK(iterator); x = iks_child(pak->query); flag = 0; while (x) { if (!iks_strcmp(iks_name(x), "item")) { if (!strcasecmp(iterator->name, iks_find_attrib(x, "jid"))) { flag = 1; ast_clear_flag(iterator, AJI_AUTOPRUNE | AJI_AUTOREGISTER); } } x = iks_next(x); } if (!flag) ast_copy_flags(iterator, client, AJI_AUTOREGISTER); if (x) iks_delete(x); ASTOBJ_UNLOCK(iterator); }); x = iks_child(pak->query); while (x) { flag = 0; if (iks_strcmp(iks_name(x), "item") == 0) { ASTOBJ_CONTAINER_TRAVERSE(&client->buddies, 1, { ASTOBJ_RDLOCK(iterator); if (!strcasecmp(iterator->name, iks_find_attrib(x, "jid"))) flag = 1; ASTOBJ_UNLOCK(iterator); }); if (!flag) { buddy = (struct aji_buddy *) malloc(sizeof(struct aji_buddy)); if (!buddy) { ast_log(LOG_WARNING, "Out of memory\n"); return 0; } memset(buddy, 0, sizeof(struct aji_buddy)); ASTOBJ_INIT(buddy); ASTOBJ_WRLOCK(buddy); ast_copy_string(buddy->name, iks_find_attrib(x, "jid"), sizeof(buddy->name)); ast_clear_flag(buddy, AST_FLAGS_ALL); if(ast_test_flag(client, AJI_AUTOPRUNE)) { ast_set_flag(buddy, AJI_AUTOPRUNE); buddy->objflags |= ASTOBJ_FLAG_MARKED; } else ast_set_flag(buddy, AJI_AUTOREGISTER); ASTOBJ_UNLOCK(buddy); if (buddy) { ASTOBJ_CONTAINER_LINK(&client->buddies, buddy); ASTOBJ_UNREF(buddy, aji_buddy_destroy); } } } x = iks_next(x); } if (x) iks_delete(x); aji_pruneregister(client); ASTOBJ_UNREF(client, aji_client_destroy); return IKS_FILTER_EAT; }

static struct aji_resource* aji_find_resource (  struct aji_buddy *  buddy, char *  name )  [static]

Definition at line 268 of file res_jabber.c. References aji_resource::next, aji_resource::resource, and aji_buddy::resources. Referenced by aji_client_info_handler(), aji_dinfo_handler(), and aji_status_exec(). { 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 struct aji_version* aji_find_version (  char *  node, char *  version, ikspak *  pak )  [static]

Definition at line 210 of file res_jabber.c. References ast_log(), capabilities, aji_version::jingle, LOG_ERROR, malloc, aji_capabilities::next, aji_version::next, aji_capabilities::node, aji_version::parent, aji_version::version, and aji_capabilities::versions. Referenced by aji_handle_presence(). { 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; } 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; } 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"); 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 = list->versions; list->versions = res; list->next = capabilities; capabilities = list; } return res; }

static int aji_get_roster (  struct aji_client *  client  )  [static]

Definition at line 1771 of file res_jabber.c. References aji_set_presence(), aji_client::jid, aji_client::p, and aji_client::statusmessage. Referenced by aji_client_connect(). { iks *roster = NULL; roster = iks_make_iq(IKS_TYPE_GET, IKS_NS_ROSTER); if(roster) { iks_insert_attrib(roster, "id", "roster"); aji_set_presence(client, NULL, client->jid->full, 1, client->statusmessage); iks_send(client->p, roster); } if (roster) iks_delete(roster); return 1; }

static void aji_handle_iq (  struct aji_client *  client, iks *  node )  [static]

Handles <iq> tags. Parameters: client  structure and the iq node. Returns: void. Definition at line 1081 of file res_jabber.c. Referenced by aji_act_hook(). { /*Nothing to see here */ }

static void aji_handle_message (  struct aji_client *  client, ikspak *  pak )  [static]

Handles presence packets. Parameters: client  structure and the node. Returns: void. Definition at line 1091 of file res_jabber.c. References aji_message::arrived, ast_calloc, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_strdup, free, aji_message::from, aji_message::id, aji_message::message, and aji_client::message_timeout. Referenced by aji_act_hook(). { struct aji_message *insert, *tmp; int flag = 0; if (!(insert = ast_calloc(1, sizeof(struct aji_message)))) return; time(&insert->arrived); if (iks_find_cdata(pak->x, "body")) insert->message = ast_strdup(iks_find_cdata(pak->x, "body")); if(pak->id) ast_copy_string(insert->id, pak->id, sizeof(insert->message)); if (pak->from) insert->from = ast_strdup(pak->from->full); AST_LIST_LOCK(&client->messages); AST_LIST_TRAVERSE_SAFE_BEGIN(&client->messages, tmp, list) { if (flag) { AST_LIST_REMOVE_CURRENT(&client->messages, list); if (tmp->from) free(tmp->from); if (tmp->message) free(tmp->message); } else if (difftime(time(NULL), tmp->arrived) >= client->message_timeout) { flag = 1; AST_LIST_REMOVE_CURRENT(&client->messages, list); if (tmp->from) free(tmp->from); if (tmp->message) free(tmp->message); } } AST_LIST_TRAVERSE_SAFE_END; AST_LIST_INSERT_HEAD(&client->messages, insert, list); AST_LIST_UNLOCK(&client->messages); }

static void aji_handle_presence (  struct aji_client *  client, ikspak *  pak )  [static]

Definition at line 1127 of file res_jabber.c. References aji_buddy_destroy(), AJI_CONNECTED, aji_create_buddy(), aji_find_version(), aji_set_presence(), ast_aji_increment_mid(), ast_log(), ast_strdup, ast_verbose(), ASTOBJ_CONTAINER_FIND, ASTOBJ_UNLOCK, ASTOBJ_UNREF, ASTOBJ_WRLOCK, aji_client::buddies, aji_client::component, descrip, aji_resource::description, free, gtalk_yuck(), last, LOG_DEBUG, LOG_ERROR, LOG_NOTICE, malloc, aji_client::mid, aji_resource::next, option_debug, option_verbose, aji_client::p, aji_resource::priority, aji_resource::resource, aji_buddy::resources, aji_client::state, aji_resource::status, aji_client::statusmessage, type, and VERBOSE_PREFIX_3. Referenced by aji_act_hook(). { int status, priority; struct aji_buddy *buddy; struct aji_resource *tmp = NULL, *last = NULL, *found = NULL; char *ver, *node, *descrip, *type; if(client->state != AJI_CONNECTED) aji_create_buddy(pak->from->partial, client); buddy = ASTOBJ_CONTAINER_FIND(&client->buddies, pak->from->partial); if (!buddy) { ast_log(LOG_NOTICE, "Got presence packet from %s, someone not in our roster!!!!\n", pak->from->partial); return; } type = iks_find_attrib(pak->x, "type"); if(client->component && type &&!strcasecmp("probe", type)) { aji_set_presence(client, pak->from->full, iks_find_attrib(pak->x, "to"), 1, client->statusmessage); ast_verbose("what i was looking for \n"); } ASTOBJ_WRLOCK(buddy); status = (pak->show) ? pak->show : 6; priority = atoi((iks_find_cdata(pak->x, "priority")) ? iks_find_cdata(pak->x, "priority") : "0"); tmp = buddy->resources; descrip = ast_strdup(iks_find_cdata(pak->x,"status")); while (tmp) { if (!strcasecmp(tmp->resource, pak->from->resource)) { tmp->status = status; if (tmp->description) free(tmp->description); tmp->description = descrip; found = tmp; if (status == 6) { /* Sign off Destroy resource */ if (last && found->next) { last->next = found->next; } else if (!last) { if (found->next) buddy->resources = found->next; else buddy->resources = NULL; } else if (!found->next) { if (last) last->next = NULL; else buddy->resources = NULL; } free(found); found = NULL; break; } if (tmp->priority != priority) { found->priority = priority; if (!last && !found->next) break; if (last) last->next = found->next; else buddy->resources = found->next; last = NULL; tmp = buddy->resources; if (!buddy->resources) buddy->resources = found; while (tmp) { if (found->priority > tmp->priority) { if (last) last->next = found; found->next = tmp; if (!last) buddy->resources = found; break; } if (!tmp->next) { tmp->next = found; break; } last = tmp; tmp = tmp->next; } } break; } last = tmp; tmp = tmp->next; } if (!found && status != 6) { found = (struct aji_resource *) malloc(sizeof(struct aji_resource)); memset(found, 0, sizeof(struct aji_resource)); if (!found) { ast_log(LOG_ERROR, "Out of memory!\n"); return; } ast_copy_string(found->resource, pak->from->resource, sizeof(found->resource)); found->status = status; found->description = descrip; found->priority = priority; found->next = NULL; last = NULL; tmp = buddy->resources; while (tmp) { if (found->priority > tmp->priority) { if (last) last->next = found; found->next = tmp; if (!last) buddy->resources = found; break; } if (!tmp->next) { tmp->next = found; break; } last = tmp; tmp = tmp->next; } if (!tmp) buddy->resources = found; } ASTOBJ_UNLOCK(buddy); ASTOBJ_UNREF(buddy, aji_buddy_destroy); node = iks_find_attrib(iks_find(pak->x, "c"), "node"); ver = iks_find_attrib(iks_find(pak->x, "c"), "ver"); if(status !=6 && !found->cap) { found->cap = aji_find_version(node, ver, pak); if(gtalk_yuck(pak->x)) /* gtalk should do discover */ found->cap->jingle = 1; if(found->cap->jingle && option_debug > 4) { if (option_debug) ast_log(LOG_DEBUG,"Special case for google till they support discover.\n"); } else { iks *iq, *query; iq = iks_new("iq"); query = iks_new("query"); if(query && iq) { iks_insert_attrib(iq, "type", "get"); iks_insert_attrib(iq, "to", pak->from->full); iks_insert_attrib(iq,"from",iks_find_attrib(pak->x,"to")); iks_insert_attrib(iq, "id", client->mid); ast_aji_increment_mid(client->mid); iks_insert_attrib(query, "xmlns", "http://jabber.org/protocol/disco#info"); iks_insert_node(iq, query); iks_send(client->p, iq); } else ast_log(LOG_ERROR, "Out of memory.\n"); if(query) iks_delete(query); if(iq) iks_delete(iq); } } if (option_verbose > 4) { switch (pak->subtype) { case IKS_TYPE_AVAILABLE: ast_verbose(VERBOSE_PREFIX_3 "JABBER: I am available ^_* %i\n", pak->subtype); break; case IKS_TYPE_UNAVAILABLE: ast_verbose(VERBOSE_PREFIX_3 "JABBER: I am unavailable ^_* %i\n", pak->subtype); break; default: ast_verbose(VERBOSE_PREFIX_3 "JABBER: Ohh sexy and the wrong type: %i\n", pak->subtype); } switch (pak->show) { case IKS_SHOW_UNAVAILABLE: ast_verbose(VERBOSE_PREFIX_3 "JABBER: type: %i subtype %i\n", pak->subtype, pak->show); break; case IKS_SHOW_AVAILABLE: ast_verbose(VERBOSE_PREFIX_3 "JABBER: type is available\n"); break; case IKS_SHOW_CHAT: ast_verbose(VERBOSE_PREFIX_3 "JABBER: type: %i subtype %i\n", pak->subtype, pak->show); break; case IKS_SHOW_AWAY: ast_verbose(VERBOSE_PREFIX_3 "JABBER: type is away\n"); break; case IKS_SHOW_XA: ast_verbose(VERBOSE_PREFIX_3 "JABBER: type: %i subtype %i\n", pak->subtype, pak->show); break; case IKS_SHOW_DND: ast_verbose(VERBOSE_PREFIX_3 "JABBER: type: %i subtype %i\n", pak->subtype, pak->show); break; default: ast_verbose(VERBOSE_PREFIX_3 "JABBER: Kinky! how did that happen %i\n", pak->show); } } }

static void aji_handle_subscribe (  struct aji_client *  client, ikspak *  pak )  [static]

handles subscription requests. Parameters: aji_client  struct and xml packet. Returns: void. Definition at line 1323 of file res_jabber.c. References aji_set_presence(), ast_log(), ast_verbose(), aji_client::component, LOG_ERROR, option_verbose, aji_client::p, aji_resource::status, aji_client::statusmessage, and VERBOSE_PREFIX_3. Referenced by aji_act_hook(). { if(pak->subtype == IKS_TYPE_SUBSCRIBE) { iks *presence = NULL, *status = NULL; presence = iks_new("presence"); status = iks_new("status"); if(presence && status) { iks_insert_attrib(presence, "type", "subscribed"); iks_insert_attrib(presence, "to", pak->from->full); iks_insert_attrib(presence, "from", iks_find_attrib(pak->x, "to")); if(pak->id) iks_insert_attrib(presence, "id", pak->id); iks_insert_cdata(status, "Asterisk has approved subscription", 0); iks_insert_node(presence, status); iks_send(client->p, presence); } else ast_log(LOG_ERROR, "Unable to allocate nodes\n"); if(presence) iks_delete(presence); if(status) iks_delete(status); if(client->component) aji_set_presence(client, pak->from->full, iks_find_attrib(pak->x, "to"), 1, client->statusmessage); } if (option_verbose > 4) { switch (pak->subtype) { case IKS_TYPE_SUBSCRIBE: ast_verbose(VERBOSE_PREFIX_3 "JABBER: This is a subcription of type %i\n", pak->subtype); break; case IKS_TYPE_SUBSCRIBED: ast_verbose(VERBOSE_PREFIX_3 "JABBER: This is a subcription of type %i\n", pak->subtype); break; case IKS_TYPE_UNSUBSCRIBE: ast_verbose(VERBOSE_PREFIX_3 "JABBER: This is a subcription of type %i\n", pak->subtype); break; case IKS_TYPE_UNSUBSCRIBED: ast_verbose(VERBOSE_PREFIX_3 "JABBER: This is a subcription of type %i\n", pak->subtype); break; default: /*IKS_TYPE_ERROR: */ ast_verbose(VERBOSE_PREFIX_3 "JABBER: This is a subcription of type %i\n", pak->subtype); break; } } }

static int aji_highest_bit (  int  number  )  [static]

Detects the highest bit in a number. Parameters: Number  you want to have evaluated. Returns: the highest power of 2 that can go into the number. Definition at line 295 of file res_jabber.c. Referenced by aji_act_hook(). { int x = sizeof(number) * 8 - 1; if (!number) return 0; for (; x > 0; x--) { if (number & (1 << x)) break; } return (1 << x); }

static int aji_load_config (  void   )  [static]

load config file. Parameters: void.  Returns: 1. Definition at line 2259 of file res_jabber.c. References AJI_AUTOPRUNE, AJI_AUTOREGISTER, ast_category_browse(), ast_config_load(), ast_false(), ast_log(), ast_set2_flag, ast_true(), ast_variable_browse(), ast_variable_retrieve(), debug(), globalflags, JABBER_CONFIG, LOG_WARNING, and var. Referenced by aji_reload(). { char *cat = NULL; int debug = 1; struct ast_config *cfg = NULL; struct ast_variable *var = NULL; cfg = ast_config_load(JABBER_CONFIG); if (!cfg) { ast_log(LOG_WARNING, "No such configuration file %s\n", JABBER_CONFIG); return 0; } cat = ast_category_browse(cfg, NULL); for (var = ast_variable_browse(cfg, "general"); var; var = var->next) { if (!strcasecmp(var->name, "debug")) debug = (ast_false(ast_variable_retrieve(cfg, "general", "debug"))) ? 0 : 1; else if (!strcasecmp(var->name, "autoprune")) ast_set2_flag(&globalflags, ast_true(var->value), AJI_AUTOPRUNE); else if (!strcasecmp(var->name, "autoregister")) ast_set2_flag(&globalflags, ast_true(var->value), AJI_AUTOREGISTER); } while (cat) { if (strcasecmp(cat, "general")) { var = ast_variable_browse(cfg, cat); aji_create_client(cat, var, debug); } cat = ast_category_browse(cfg, cat); } return 1; }

static void aji_log_hook (  void *  data, const char *  xmpp, size_t  size, int  is_incoming )  [static]

the debug loop. Parameters: aji_client  structure, xml data as string, size of string, direction of packet, 1 for inbound 0 for outbound. Definition at line 435 of file res_jabber.c. References aji_client_destroy(), ast_verbose(), ASTOBJ_REF, ASTOBJ_UNREF, aji_client::debug, EVENT_FLAG_USER, manager_event, and option_debug. Referenced by aji_create_client(). { struct aji_client *client = ASTOBJ_REF((struct aji_client *) data); manager_event(EVENT_FLAG_USER, "JabberEvent", "Account: %s\r\nPacket: %s", 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); }

static int aji_no_debug (  int  fd, int  argc, char *  argv[] )  [static]

turnoff console debugging. Parameters: fd,number  of args, args. Returns: RESULT_SUCCESS. Definition at line 1936 of file res_jabber.c. References ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, and clients. { ASTOBJ_CONTAINER_TRAVERSE(&clients, 1, { ASTOBJ_RDLOCK(iterator); iterator->debug = 0; ASTOBJ_UNLOCK(iterator); }); ast_cli(fd, "Jabber Debugging Disabled.\n"); return RESULT_SUCCESS; }

static void aji_pruneregister (  struct aji_client *  client  )  [static]

attempts to register to a transport. attempts to register to a transport step 2. goes through roster and prunes users not needed in list, or adds them accordingly. Parameters: aji_client  struct. Returns: void. Definition at line 1626 of file res_jabber.c. References AJI_AUTOPRUNE, AJI_AUTOREGISTER, ast_clear_flag, ast_test_flag, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, aji_client::buddies, aji_client::jid, and aji_client::p. { int res = 0; iks *removeiq = iks_new("iq"); iks *removequery = iks_new("query"); iks *removeitem = iks_new("item"); iks *send = iks_make_iq(IKS_TYPE_GET, "http://jabber.org/protocol/disco#items"); if (client && removeiq && removequery && removeitem && send) { iks_insert_node(removeiq, removequery); iks_insert_node(removequery, removeitem); ASTOBJ_CONTAINER_TRAVERSE(&client->buddies, 1, { ASTOBJ_RDLOCK(iterator); /* For an aji_buddy, both AUTOPRUNE and AUTOREGISTER will never * be called at the same time */ if (ast_test_flag(iterator, AJI_AUTOPRUNE)) { res = iks_send(client->p, iks_make_s10n(IKS_TYPE_UNSUBSCRIBE, iterator->name, "GoodBye your status is no longer needed by Asterisk the Open Source PBX" " so I am no longer subscribing to your presence.\n")); res = iks_send(client->p, iks_make_s10n(IKS_TYPE_UNSUBSCRIBED, iterator->name, "GoodBye you are no longer in the asterisk config file so I am removing" " your access to my presence.\n")); iks_insert_attrib(removeiq, "from", client->jid->full); iks_insert_attrib(removeiq, "type", "set"); iks_insert_attrib(removequery, "xmlns", "jabber:iq:roster"); iks_insert_attrib(removeitem, "jid", iterator->name); iks_insert_attrib(removeitem, "subscription", "remove"); res = iks_send(client->p, removeiq); } else if (ast_test_flag(iterator, AJI_AUTOREGISTER)) { res = iks_send(client->p, iks_make_s10n(IKS_TYPE_SUBSCRIBE, iterator->name, "Greetings I am the Asterisk Open Source PBX and I want to subscribe to your presence\n")); ast_clear_flag(iterator, AJI_AUTOREGISTER); } ASTOBJ_UNLOCK(iterator); }); } else ast_log(LOG_ERROR, "Out of memory.\n"); if (removeiq) iks_delete(removeiq); if (removequery) iks_delete(removequery); if (removeitem) iks_delete(removeitem); if (send) iks_delete(send); ASTOBJ_CONTAINER_PRUNE_MARKED(&client->buddies, aji_buddy_destroy); }

static int aji_reconnect (  struct aji_client *  client  )  [static]

Definition at line 1751 of file res_jabber.c. References aji_client_initialize(), aji_component_initialize(), AJI_DISCONNECTED, aji_client::authorized, aji_client::component, aji_client::p, aji_client::state, and aji_client::timeout. Referenced by aji_recv_loop(). { int res = 0; if (client->state) client->state = AJI_DISCONNECTED; client->timeout=50; if (client->p) iks_parser_reset(client->p); if (client->authorized) client->authorized = 0; if(client->component) res = aji_component_initialize(client); else res = aji_client_initialize(client); return res; }

static void * aji_recv_loop (  void *  data  )  [static]

receive message loop. Parameters: aji_client  struct. Returns: void. Definition at line 1481 of file res_jabber.c. References aji_client_destroy(), AJI_CONNECTED, aji_reconnect(), ast_log(), ast_verbose(), ASTOBJ_REF, ASTOBJ_UNREF, LOG_WARNING, option_verbose, aji_client::p, aji_client::state, and aji_client::timeout. Referenced by aji_reload(). { struct aji_client *client = ASTOBJ_REF((struct aji_client *) data); int res = IKS_HOOK; do { if (res != IKS_OK) { while(res != IKS_OK) { if(option_verbose > 3) ast_verbose("JABBER: reconnecting.\n"); res = aji_reconnect(client); sleep(4); } } res = iks_recv(client->p, 1); client->timeout--; if (res == IKS_HOOK) ast_log(LOG_WARNING, "JABBER: Got hook event.\n"); else if (res == IKS_NET_TLSFAIL) ast_log(LOG_WARNING, "JABBER: Failure in TLS.\n"); else if (client->timeout == 0 && client->state == AJI_CONNECTED) { res = iks_send_raw(client->p, " "); if(res == IKS_OK) client->timeout = 50; else ast_log(LOG_WARNING, "JABBER: Network Timeout\n"); } else if (res == IKS_NET_RWERR) ast_log(LOG_WARNING, "JABBER: socket read error\n"); } while (client); ASTOBJ_UNREF(client, aji_client_destroy); return 0; }

static int aji_register_approve_handler (  void *  data, ikspak *  pak )  [static]

Definition at line 662 of file res_jabber.c. References aji_client_destroy(), ast_aji_increment_mid(), ast_log(), ASTOBJ_REF, ASTOBJ_UNREF, aji_client::jid, LOG_ERROR, aji_client::mid, and aji_client::p. Referenced by aji_create_client(). { 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 )  [static]

Definition at line 701 of file res_jabber.c. References aji_client_destroy(), ast_log(), ast_verbose(), ASTOBJ_CONTAINER_FIND, ASTOBJ_REF, ASTOBJ_UNREF, aji_client::buddies, error(), LOG_ERROR, aji_client::p, and aji_client::user. Referenced by aji_create_client(). { 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_reload (  void   )  [static]

Definition at line 2361 of file res_jabber.c. References aji_client_destroy(), AJI_DISCONNECTED, aji_load_config(), aji_recv_loop(), ast_log(), ast_pthread_create_background, ASTOBJ_CONTAINER_MARKALL, ASTOBJ_CONTAINER_PRUNE_MARKED, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, clients, and LOG_ERROR. Referenced by aji_do_reload(), load_module(), and reload(). { ASTOBJ_CONTAINER_MARKALL(&clients); if (!aji_load_config()) { ast_log(LOG_ERROR, "JABBER: Failed to load config.\n"); return 0; } ASTOBJ_CONTAINER_PRUNE_MARKED(&clients, aji_client_destroy); ASTOBJ_CONTAINER_TRAVERSE(&clients, 1, { ASTOBJ_RDLOCK(iterator); if(iterator->state == AJI_DISCONNECTED) { if (!iterator->thread) ast_pthread_create_background(&iterator->thread, NULL, aji_recv_loop, iterator); } else if (iterator->state == AJI_CONNECTING) aji_get_roster(iterator); ASTOBJ_UNLOCK(iterator); }); return 1; }

static int aji_send_exec (  struct ast_channel *  chan, void *  data )  [static]

Dial plan function to send a message. Parameters: channel,and  data, data is sender, reciever, message. Returns: 0. Definition at line 399 of file res_jabber.c. References ast_aji_get_client(), ast_aji_send(), ast_log(), ast_strdupa, LOG_ERROR, LOG_WARNING, s, and strsep(). Referenced by load_module(). { struct aji_client *client = NULL; char *s = NULL, *sender = NULL, *recipient = NULL, *message = NULL; if (!data) { ast_log(LOG_ERROR, "Out of memory\n"); return -1; } s = ast_strdupa((char *) 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 \n"); return -1; } } } if (!(client = ast_aji_get_client(sender))) { ast_log(LOG_WARNING, "Could not find Sender.\n"); return -1; } if (strchr(recipient, '@') && message) ast_aji_send(client, recipient, message); return 0; }

static void aji_set_presence (  struct aji_client *  client, char *  to, char *  from, int  level, char *  desc )  [static]

set presence of client. Parameters: aji_client  struct, user to send it to, and from, level, description. Returns: void. Definition at line 1876 of file res_jabber.c. References ast_log(), LOG_ERROR, and aji_client::p. Referenced by aji_get_roster(), aji_handle_presence(), and aji_handle_subscribe(). { int res = 0; iks *presence = iks_make_pres(level, desc); iks *cnode = iks_new("c"); iks *priority = iks_new("priority"); iks_insert_cdata(priority, "0", 1); if (presence && cnode && client) { if(to) iks_insert_attrib(presence, "to", to); if(from) iks_insert_attrib(presence, "from", from); iks_insert_attrib(cnode, "node", "http://www.asterisk.org/xmpp/client/caps"); iks_insert_attrib(cnode, "ver", "asterisk-xmpp"); iks_insert_attrib(cnode, "ext", "voice-v1"); iks_insert_attrib(cnode, "xmlns", "http://jabber.org/protocol/caps"); iks_insert_node(presence, cnode); res = iks_send(client->p, presence); } else ast_log(LOG_ERROR, "Out of memory.\n"); if (cnode) iks_delete(cnode); if (presence) iks_delete(presence); }

static int aji_show_clients (  int  fd, int  argc, char *  argv[] )  [static]

show client status. Parameters: fd,number  of args, args. Returns: RESULT_SUCCESS. Definition at line 1952 of file res_jabber.c. References AJI_CONNECTED, AJI_CONNECTING, AJI_DISCONNECTED, ast_cli(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, and clients. { char *status; int count = 0; ast_cli(fd, "Jabber Users and their status:\n"); ASTOBJ_CONTAINER_TRAVERSE(&clients, 1, { ASTOBJ_RDLOCK(iterator); count++; switch (iterator->state) { case AJI_DISCONNECTED: status = "Disconnected"; break; case AJI_CONNECTING: status = "Connecting"; break; case AJI_CONNECTED: status = "Connected"; break; default: status = "Unknown"; } ast_cli(fd, " User: %s - %s\n", iterator->user, status); ASTOBJ_UNLOCK(iterator); }); ast_cli(fd, "----\n"); ast_cli(fd, " Number of users: %d\n", count); return RESULT_SUCCESS; }

static int aji_status_exec (  struct ast_channel *  chan, void *  data )  [static]

Dial plan function status(). puts the status of watched user into a channel variable. Parameters: channel,and  username,watched user, status var Returns: 0. Definition at line 334 of file res_jabber.c. References aji_find_resource(), ast_aji_get_client(), ast_log(), ast_strdupa, ASTOBJ_CONTAINER_FIND, aji_client::buddies, LOG_ERROR, LOG_NOTICE, LOG_WARNING, pbx_builtin_setvar_helper(), aji_resource::resource, aji_buddy::resources, s, aji_resource::status, and strsep(). Referenced by load_module(). { 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) { s = ast_strdupa((char *) 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; } } } } else { ast_log(LOG_ERROR, "Out of memory\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 Connection.\n"); return -1; } if(!&client->buddies) { ast_log(LOG_WARNING, "No buddies for connection.\n"); return -1; } buddy = ASTOBJ_CONTAINER_FIND(&client->buddies, (resource)?screenname:jid); if (!buddy) { ast_log(LOG_WARNING, "Could not find Buddy in list.\n"); 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); } stat = r->status; sprintf(status, "%d", stat); pbx_builtin_setvar_helper(chan, variable, status); return 0; }

static int aji_test (  int  fd, int  argc, char *  argv[] )  [static]

send test message for debugging. Parameters: fd,number  of args, args. Returns: RESULT_SUCCESS. Definition at line 1986 of file res_jabber.c. References ast_aji_send(), ast_cli(), ast_verbose(), ASTOBJ_CONTAINER_FIND, ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, aji_client::buddies, aji_resource::cap, clients, aji_resource::description, aji_version::jingle, name, aji_resource::next, aji_capabilities::node, aji_version::parent, aji_resource::priority, aji_resource::resource, RESULT_FAILURE, RESULT_SHOWUSAGE, S_OR, aji_resource::status, and aji_version::version. { struct aji_client *client; struct aji_resource *resource; const char *name = "asterisk"; struct aji_message *tmp; if (argc > 3) return RESULT_SHOWUSAGE; else if (argc == 3) name = argv[2]; if (!(client = ASTOBJ_CONTAINER_FIND(&clients, name))) { ast_cli(fd, "Unable to find client '%s'!\n", name); return RESULT_FAILURE; } /* XXX Does Matt really want everyone to use his personal address for tests? */ /* XXX yes he does */ ast_aji_send(client, "mogorman@astjab.org", "blahblah"); ASTOBJ_CONTAINER_TRAVERSE(&client->buddies, 1, { ASTOBJ_RDLOCK(iterator); ast_verbose("User: %s\n", iterator->name); for (resource = iterator->resources; resource; resource = resource->next) { ast_verbose("Resource: %s\n", resource->resource); if(resource->cap) { ast_verbose(" client: %s\n", resource->cap->parent->node); ast_verbose(" version: %s\n", resource->cap->version); ast_verbose(" Jingle Capable: %d\n", resource->cap->jingle); } ast_verbose(" Priority: %d\n", resource->priority); ast_verbose(" Status: %d\n", resource->status); ast_verbose(" Message: %s\n", S_OR(resource->description,"")); } ASTOBJ_UNLOCK(iterator); }); ast_verbose("\nOooh a working message stack!\n"); AST_LIST_LOCK(&client->messages); AST_LIST_TRAVERSE(&client->messages, tmp, list) { ast_verbose(" Message from: %s with id %s @ %s %s\n",tmp->from, S_OR(tmp->id,""), ctime(&tmp->arrived), S_OR(tmp->message, "")); } AST_LIST_UNLOCK(&client->messages); ASTOBJ_UNREF(client, aji_client_destroy); return RESULT_SUCCESS; }

int ast_aji_create_chat (  struct aji_client *  client, char *  room, char *  server, char *  topic )

create a chatroom. Parameters: aji_client  struct , room, server, topic for the room. Returns: 0. Definition at line 1397 of file res_jabber.c. References ast_aji_increment_mid(), ast_log(), LOG_ERROR, aji_client::mid, and aji_client::p. { int res = 0; iks *iq = NULL; iq = iks_new("iq"); if (iq && client) { iks_insert_attrib(iq, "type", "get"); iks_insert_attrib(iq, "to", server); iks_insert_attrib(iq, "id", client->mid); ast_aji_increment_mid(client->mid); iks_send(client->p, iq); } else ast_log(LOG_ERROR, "Out of memory.\n"); return res; }

int ast_aji_disconnect (  struct aji_client *  client  )

disconnect from jabber server. Parameters: aji_client  struct. Returns: 1. Definition at line 1858 of file res_jabber.c. References aji_client_destroy(), ast_verbose(), ASTOBJ_UNREF, option_verbose, aji_client::p, and VERBOSE_PREFIX_3. Referenced by unload_module(). { if (client) { if (option_verbose > 3) ast_verbose(VERBOSE_PREFIX_3 "JABBER: Disconnecting\n"); iks_disconnect(client->p); iks_parser_delete(client->p); ASTOBJ_UNREF(client, aji_client_destroy); } return 1; }

struct aji_client* ast_aji_get_client (  const char *  name  )

grab a aji_client structure by label name. Parameters: void.  Returns: 1. Definition at line 2297 of file res_jabber.c. References ASTOBJ_CONTAINER_FIND, ASTOBJ_CONTAINER_FIND_FULL, clients, and aji_client::user. Referenced by aji_send_exec(), aji_status_exec(), gtalk_create_member(), jingle_create_member(), and manager_jabber_send(). { struct aji_client *client = NULL; client = ASTOBJ_CONTAINER_FIND(&clients, name); if (!client && !strchr(name, '@')) client = ASTOBJ_CONTAINER_FIND_FULL(&clients, name, user,,, strcasecmp); return client; }

struct aji_client_container* ast_aji_get_clients (  void   )

Definition at line 2307 of file res_jabber.c. References clients. { return &clients; }

void ast_aji_increment_mid (  char *  mid  )

increments the mid field for messages and other events. Parameters: message  id. Returns: void. Definition at line 1519 of file res_jabber.c. Referenced by aji_act_hook(), aji_handle_presence(), aji_register_approve_handler(), ast_aji_create_chat(), ast_aji_invite_chat(), gtalk_action(), gtalk_digit(), gtalk_invite_response(), jingle_accept_call(), jingle_action(), jingle_digit(), and jingle_transmit_invite(). { int i = 0; for (i = strlen(mid) - 1; i >= 0; i--) { if (mid[i] != 'z') { mid[i] = mid[i] + 1; i = 0; } else mid[i] = 'a'; } }

int ast_aji_invite_chat (  struct aji_client *  client, char *  user, char *  room, char *  message )

invite to a chatroom. Parameters: aji_client  struct ,user, room, message. Returns: res. Definition at line 1446 of file res_jabber.c. References ast_aji_increment_mid(), ast_log(), LOG_ERROR, aji_client::mid, and aji_client::p. { int res = 0; iks *invite, *body, *namespace; invite = iks_new("message"); body = iks_new("body"); namespace = iks_new("x"); if (client && invite && body && namespace) { iks_insert_attrib(invite, "to", user); iks_insert_attrib(invite, "id", client->mid); ast_aji_increment_mid(client->mid); iks_insert_cdata(body, message, 0); iks_insert_attrib(namespace, "xmlns", "jabber:x:conference"); iks_insert_attrib(namespace, "jid", room); iks_insert_node(invite, body); iks_insert_node(invite, namespace); res = iks_send(client->p, invite); } else ast_log(LOG_ERROR, "Out of memory.\n"); if (body) iks_delete(body); if (namespace) iks_delete(namespace); if (invite) iks_delete(invite); return res; }

int ast_aji_join_chat (  struct aji_client *  client, char *  room )

join a chatroom. Parameters: aji_client  struct , room. Returns: res. Definition at line 1418 of file res_jabber.c. References ast_log(), LOG_ERROR, aji_client::p, and aji_resource::priority. { int res = 0; iks *presence = NULL, *priority = NULL; presence = iks_new("presence"); priority = iks_new("priority"); if (presence && priority && client) { iks_insert_cdata(priority, "0", 1); iks_insert_attrib(presence, "to", room); iks_insert_node(presence, priority); res = iks_send(client->p, presence); iks_insert_cdata(priority, "5", 1); iks_insert_attrib(presence, "to", room); res = iks_send(client->p, presence); } else ast_log(LOG_ERROR, "Out of memory.\n"); if (presence) iks_delete(presence); if (priority) iks_delete(priority); return res; }

int ast_aji_send (  struct aji_client *  client, const char *  address, const char *  message )

sends messages. Parameters: aji_client  struct , reciever, message. Returns: 1. Definition at line 1373 of file res_jabber.c. References AJI_CONNECTED, ast_log(), aji_client::jid, LOG_ERROR, LOG_WARNING, aji_client::p, and aji_client::state. Referenced by aji_send_exec(), aji_test(), and manager_jabber_send(). { int res = 0; iks *message_packet = NULL; if (client->state == AJI_CONNECTED) { message_packet = iks_make_msg(IKS_TYPE_CHAT, address, message); if (message_packet) { iks_insert_attrib(message_packet, "from", client->jid->full); res = iks_send(client->p, message_packet); } else { ast_log(LOG_ERROR, "Out of memory.\n"); } if (message_packet) iks_delete(message_packet); } else ast_log(LOG_WARNING, "JABBER: Not connected can't send\n"); return 1; }

AST_MODULE_INFO (  ASTERISK_GPL_KEY  , AST_MODFLAG_GLOBAL_SYMBOLS  , "AJI - Asterisk Jabber Interface"  , .  load = load_module, .  unload = unload_module, .  reload = reload )

static int gtalk_yuck (  iks *  node  )  [static]

Definition at line 283 of file res_jabber.c. Referenced by aji_handle_presence(). { if (iks_find_with_attrib(node, "c", "node", "http://www.google.com/xmpp/client/caps")) return 1; return 0; }

static iks * jabber_make_auth (  iksid *  id, const char *  pass, const char *  sid )  [static]

Definition at line 307 of file res_jabber.c. References ast_sha1_hash(). Referenced by aji_act_hook(). { 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; }

static int load_module (  void   )  [static]

Definition at line 2405 of file res_jabber.c. References aji_cli, aji_reload(), aji_send_exec(), aji_status_exec(), ajisend_descrip, ajisend_synopsis, ajistatus_descrip, ajistatus_synopsis, app_ajisend, app_ajistatus, ast_cli_register_multiple(), ast_log(), ast_manager_register2(), AST_MODULE_LOAD_DECLINE, ast_register_application(), ASTOBJ_CONTAINER_INIT, clients, EVENT_FLAG_SYSTEM, LOG_NOTICE, manager_jabber_send(), and mandescr_jabber_send. { ASTOBJ_CONTAINER_INIT(&clients); if(!aji_reload()) return AST_MODULE_LOAD_DECLINE; ast_manager_register2("JabberSend", EVENT_FLAG_SYSTEM, manager_jabber_send, "Sends a message to a Jabber Client", mandescr_jabber_send); ast_register_application(app_ajisend, aji_send_exec, ajisend_synopsis, ajisend_descrip); ast_register_application(app_ajistatus, aji_status_exec, ajistatus_synopsis, ajistatus_descrip); ast_cli_register_multiple(aji_cli, sizeof(aji_cli) / sizeof(struct ast_cli_entry)); ast_log(LOG_NOTICE, "res_jabber.so loaded.\n"); return 0; }

static int manager_jabber_send (  struct mansession *  s, const struct message *  m )  [static]

Send a Jabber Message via call from the Manager. Definition at line 2320 of file res_jabber.c. References ast_aji_get_client(), ast_aji_send(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_ack(), astman_send_error(), and s. Referenced by load_module(). { struct aji_client *client = NULL; const char *id = astman_get_header(m,"ActionID"); const char *jabber = astman_get_header(m,"Jabber"); const char *screenname = astman_get_header(m,"ScreenName"); const char *message = astman_get_header(m,"Message"); if (ast_strlen_zero(jabber)) { astman_send_error(s, m, "No transport specified"); return 0; } if (ast_strlen_zero(screenname)) { astman_send_error(s, m, "No ScreenName specified"); return 0; } if (ast_strlen_zero(message)) { astman_send_error(s, m, "No Message specified"); return 0; } astman_send_ack(s, m, "Attempting to send Jabber Message"); client = ast_aji_get_client(jabber); if (!client) { astman_send_error(s, m, "Could not find Sender"); return 0; } if (strchr(screenname, '@') && message){ ast_aji_send(client, screenname, message); if (!ast_strlen_zero(id)) astman_append(s, "ActionID: %s\r\n",id); astman_append(s, "Response: Success\r\n"); return 0; } if (!ast_strlen_zero(id)) astman_append(s, "ActionID: %s\r\n",id); astman_append(s, "Response: Failure\r\n"); return 0; }

static int reload (  void   )  [static]

Definition at line 2420 of file res_jabber.c. References aji_reload(). { aji_reload(); return 0; }

static int unload_module (  void   )  [static]

Definition at line 2382 of file res_jabber.c. References aji_cli, AJI_DISCONNECTED, app_ajisend, app_ajistatus, ast_aji_disconnect(), ast_cli_unregister_multiple(), ast_manager_unregister(), ast_unregister_application(), ast_verbose(), ASTOBJ_CONTAINER_TRAVERSE, ASTOBJ_RDLOCK, ASTOBJ_UNLOCK, clients, option_verbose, and VERBOSE_PREFIX_3. { ast_cli_unregister_multiple(aji_cli, sizeof(aji_cli) / sizeof(struct ast_cli_entry)); ast_unregister_application(app_ajisend); ast_unregister_application(app_ajistatus); ast_manager_unregister("JabberSend"); ASTOBJ_CONTAINER_TRAVERSE(&clients, 1, { ASTOBJ_RDLOCK(iterator); if (option_verbose > 2) ast_verbose(VERBOSE_PREFIX_3 "JABBER: %s\n", iterator->name); iterator->state = AJI_DISCONNECTED; ast_aji_disconnect(iterator); pthread_join(iterator->thread, NULL); ASTOBJ_UNLOCK(iterator); }); ASTOBJ_CONTAINER_DESTROYALL(&clients, aji_client_destroy); ASTOBJ_CONTAINER_DESTROY(&clients); ast_log(LOG_NOTICE, "res_jabber unloaded.\n"); return 0; }

---

Variable Documentation

struct ast_cli_entry aji_cli[] [static]

Definition at line 117 of file res_jabber.c. Referenced by load_module(), and unload_module().

char* ajisend_descrip [static]

Initial value: "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" Definition at line 143 of file res_jabber.c. Referenced by load_module().

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

Definition at line 141 of file res_jabber.c. Referenced by load_module().

char* ajistatus_descrip [static]

Definition at line 153 of file res_jabber.c. Referenced by load_module().

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

Definition at line 151 of file res_jabber.c. Referenced by load_module().

char* app_ajisend = "JabberSend" [static]

Definition at line 139 of file res_jabber.c. Referenced by load_module(), and unload_module().

char* app_ajistatus = "JabberStatus" [static]

Definition at line 149 of file res_jabber.c. Referenced by load_module(), and unload_module().

struct aji_capabilities* capabilities

Definition at line 163 of file res_jabber.c. Referenced by aji_find_version(), and ast_request().

struct aji_client_container clients

Definition at line 161 of file res_jabber.c. Referenced by aji_create_client(), aji_do_debug(), aji_no_debug(), aji_reload(), aji_show_clients(), aji_test(), ast_aji_get_client(), ast_aji_get_clients(), gtalk_load_config(), jingle_load_config(), load_module(), and unload_module().

const char debug_usage[] [static]

Initial value: "Usage: jabber debug\n" " Enables dumping of Jabber packets for debugging purposes.\n" Definition at line 100 of file res_jabber.c.

struct ast_flags globalflags = { AJI_AUTOPRUNE | AJI_AUTOREGISTER } [static]

Global flags, initialized to default values. Definition at line 166 of file res_jabber.c.

char mandescr_jabber_send[] [static]

Definition at line 2312 of file res_jabber.c. Referenced by load_module().

const char no_debug_usage[] [static]

Initial value: "Usage: jabber debug off\n" " Disables dumping of Jabber packets for debugging purposes.\n" Definition at line 104 of file res_jabber.c.

const char reload_usage[] [static]

Initial value: "Usage: jabber reload\n" " Enables reloading of Jabber module.\n" Definition at line 108 of file res_jabber.c.

const char test_usage[] [static]

Initial value: "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" Definition at line 112 of file res_jabber.c.

---

Asterisk is a trademark for Digium, inc.. | Edvina.net | Asterisk.org | This documentation was generated with Doxygen