<depend>iksemel</depend>
<use>openssl</use>
***/
+/*** DOCUMENTATION
+ <application name="JabberSend" language="en_US">
+ <synopsis>
+ Sends an XMPP message to a buddy.
+ </synopsis>
+ <syntax>
+ <parameter name="account" required="true">
+ <para>The local named account to listen on (specified in
+ jabber.conf)</para>
+ </parameter>
+ <parameter name="jid" required="true">
+ <para>Jabber ID of the buddy to send the message to. It can be a
+ bare JID (username@domain) or a full JID (username@domain/resource).</para>
+ </parameter>
+ <parameter name="message" required="true">
+ <para>The message to send.</para>
+ </parameter>
+ </syntax>
+ <description>
+ <para>Sends the content of <replaceable>message</replaceable> as text message
+ from the given <replaceable>account</replaceable> to the buddy identified by
+ <replaceable>jid</replaceable></para>
+ <para>Example: JabberSend(asterisk,bob@domain.com,Hello world) sends "Hello world"
+ to <replaceable>bob@domain.com</replaceable> as an XMPP message from the account
+ <replaceable>asterisk</replaceable>, configured in jabber.conf.</para>
+ </description>
+ <see-also>
+ <ref type="function">JABBER_STATUS</ref>
+ <ref type="function">JABBER_RECEIVE</ref>
+ </see-also>
+ </application>
+ <function name="JABBER_RECEIVE" language="en_US">
+ <synopsis>
+ Reads XMPP messages.
+ </synopsis>
+ <syntax>
+ <parameter name="account" required="true">
+ <para>The local named account to listen on (specified in
+ jabber.conf)</para>
+ </parameter>
+ <parameter name="jid" required="true">
+ <para>Jabber ID of the buddy to receive message from. It can be a
+ bare JID (username@domain) or a full JID (username@domain/resource).</para>
+ </parameter>
+ <parameter name="timeout">
+ <para>In seconds, defaults to <literal>20</literal>.</para>
+ </parameter>
+ </syntax>
+ <description>
+ <para>Receives a text message on the given <replaceable>account</replaceable>
+ from the buddy identified by <replaceable>jid</replaceable> and returns the contents.</para>
+ <para>Example: ${JABBER_RECEIVE(asterisk,bob@domain.com)} returns an XMPP message
+ sent from <replaceable>bob@domain.com</replaceable> (or nothing in case of a time out), to
+ the <replaceable>asterisk</replaceable> XMPP account configured in jabber.conf.</para>
+ </description>
+ <see-also>
+ <ref type="function">JABBER_STATUS</ref>
+ <ref type="application">JabberSend</ref>
+ </see-also>
+ </function>
+ <function name="JABBER_STATUS" language="en_US">
+ <synopsis>
+ Retrieves a buddy's status.
+ </synopsis>
+ <syntax>
+ <parameter name="account" required="true">
+ <para>The local named account to listen on (specified in
+ jabber.conf)</para>
+ </parameter>
+ <parameter name="jid" required="true">
+ <para>Jabber ID of the buddy to receive message from. It can be a
+ bare JID (username@domain) or a full JID (username@domain/resource).</para>
+ </parameter>
+ </syntax>
+ <description>
+ <para>Retrieves the numeric status associated with the buddy identified
+ by <replaceable>jid</replaceable>.
+ If the buddy does not exist in the buddylist, returns 7.</para>
+ <para>Status will be 1-7.</para>
+ <para>1=Online, 2=Chatty, 3=Away, 4=XAway, 5=DND, 6=Offline</para>
+ <para>If not in roster variable will be set to 7.</para>
+ <para>Example: ${JABBER_STATUS(asterisk,bob@domain.com)} returns 1 if
+ <replaceable>bob@domain.com</replaceable> is online. <replaceable>asterisk</replaceable> is
+ the associated XMPP account configured in jabber.conf.</para>
+ </description>
+ <see-also>
+ <ref type="function">JABBER_RECEIVE</ref>
+ <ref type="application">JabberSend</ref>
+ </see-also>
+ </function>
+ ***/
#include "asterisk.h"
#define JABBER_CONFIG "jabber.conf"
/*-- Forward declarations */
+static void aji_message_destroy(struct aji_message *obj);
static void aji_buddy_destroy(struct aji_buddy *obj);
static void aji_client_destroy(struct aji_client *obj);
static int aji_is_secure(struct aji_client *client);
static struct aji_client_container clients;
static struct aji_capabilities *capabilities = NULL;
+static ast_cond_t message_received_condition;
+static ast_mutex_t messagelock;
/*! \brief Global flags, initialized to default values */
static struct ast_flags globalflags = { AJI_AUTOREGISTER };
/*!
+ * \internal
* \brief Deletes the aji_client data structure.
* \param obj aji_client The structure we will delete.
* \return void.
iks_stack_delete(obj->stack);
AST_LIST_LOCK(&obj->messages);
while ((tmp = AST_LIST_REMOVE_HEAD(&obj->messages, list))) {
- if (tmp->from)
- ast_free(tmp->from);
- if (tmp->message)
- ast_free(tmp->message);
+ aji_message_destroy(tmp);
}
AST_LIST_HEAD_DESTROY(&obj->messages);
ast_free(obj);
}
/*!
+ * \internal
* \brief Deletes the aji_buddy data structure.
* \param obj aji_buddy The structure we will delete.
* \return void.
}
/*!
+ * \internal
+ * \brief Deletes the aji_message data structure.
+ * \param obj aji_message The structure we will delete.
+ * \return void.
+ */
+static void aji_message_destroy(struct aji_message *obj)
+{
+ if (obj->from) {
+ ast_free(obj->from);
+ }
+ if (obj->message) {
+ ast_free(obj->message);
+ }
+ ast_free(obj);
+}
+
+/*!
+ * \internal
* \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
+ * \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
+ * \param version the version attribute in the caps element we'll look for or
* add to our list
* \param pak struct 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;
list = capabilities;
- if(!node)
+ if (!node)
node = pak->from->full;
- if(!version)
+ if (!version)
version = "none supplied.";
while(list) {
- if(!strcasecmp(list->node, node)) {
+ if (!strcasecmp(list->node, node)) {
res = list->versions;
while(res) {
- if(!strcasecmp(res->version, version))
+ if (!strcasecmp(res->version, version))
return res;
res = res->next;
}
- /* Specified version not found. Let's add it to
+ /* Specified version not found. Let's add it to
this node in our capabilities list */
- if(!res) {
+ if (!res) {
res = ast_malloc(sizeof(*res));
- if(!res) {
+ if (!res) {
ast_log(LOG_ERROR, "Out of memory!\n");
return NULL;
}
list = list->next;
}
/* Specified node not found. Let's add it our capabilities list */
- if(!list) {
+ if (!list) {
list = ast_malloc(sizeof(*list));
- if(!list) {
+ if (!list) {
ast_log(LOG_ERROR, "Out of memory!\n");
return NULL;
}
res = ast_malloc(sizeof(*res));
- if(!res) {
+ if (!res) {
ast_log(LOG_ERROR, "Out of memory!\n");
ast_free(list);
return NULL;
}
return res;
}
+
/*!
+ * \internal
* \brief Find the aji_resource we want
* \param buddy aji_buddy A buddy
* \param name
}
/*!
+ * \internal
* \brief Jabber GTalk function
* \param node iks
* \return 1 on success, 0 on failure.
}
/*!
+ * \internal
* \brief Setup the authentication struct
* \param id iksid
* \param pass password
}
/*!
+ * \internal
* \brief Dial plan function status(). puts the status of watched user
- into a channel variable.
+ * into a channel variable.
* \param chan ast_channel
* \param data
- * \return 0 on success, -1 on error
+ * \retval 0 success
+ * \retval -1 error
*/
static int aji_status_exec(struct ast_channel *chan, const char *data)
{
}
AST_NONSTANDARD_APP_ARGS(jid, args.jid, '/');
+ if (jid.argc < 1 || jid.argc > 2) {
+ ast_log(LOG_WARNING, "Wrong JID %s, exiting\n", args.jid);
+ return -1;
+ }
if (!(client = ast_aji_get_client(args.sender))) {
ast_log(LOG_WARNING, "Could not find sender connection: '%s'\n", args.sender);
return 0;
}
+/*!
+ * \internal
+ * \brief Dial plan funtcion to retrieve the status of a buddy.
+ * \param channel The associated ast_channel, if there is one
+ * \param data The account, buddy JID, and optional timeout
+ * timeout.
+ * \retval 0 success
+ * \retval -1 failure
+ */
static int acf_jabberstatus_read(struct ast_channel *chan, const char *name, char *data, char *buf, size_t buflen)
{
struct aji_client *client = NULL;
}
AST_NONSTANDARD_APP_ARGS(jid, args.jid, '/');
+ if (jid.argc < 1 || jid.argc > 2) {
+ ast_log(LOG_WARNING, "Wrong JID %s, exiting\n", args.jid);
+ return -1;
+ }
if (!(client = ast_aji_get_client(args.sender))) {
ast_log(LOG_WARNING, "Could not find sender connection: '%s'\n", args.sender);
};
/*!
+ * \internal
+ * \brief Dial plan function to receive a message.
+ * \param channel The associated ast_channel, if there is one
+ * \param data The account, JID, and optional timeout
+ * timeout.
+ * \retval 0 success
+ * \retval -1 failure
+ */
+static int acf_jabberreceive_read(struct ast_channel *chan, const char *name, char *data, char *buf, size_t buflen)
+{
+ char *aux = NULL, *parse = NULL;
+ int timeout;
+ int jidlen, resourcelen;
+ struct timeval start;
+ long diff = 0;
+ struct aji_client *client = NULL;
+ int found = 0;
+ struct aji_message *tmp = NULL;
+ AST_DECLARE_APP_ARGS(args,
+ AST_APP_ARG(account);
+ AST_APP_ARG(jid);
+ AST_APP_ARG(timeout);
+ );
+ AST_DECLARE_APP_ARGS(jid,
+ AST_APP_ARG(screenname);
+ AST_APP_ARG(resource);
+ );
+
+ if (ast_strlen_zero(data)) {
+ ast_log(LOG_WARNING, "%s requires arguments (account,jid[,timeout])\n", name);
+ return -1;
+ }
+
+ parse = ast_strdupa(data);
+ AST_STANDARD_APP_ARGS(args, parse);
+
+ if (args.argc < 2 || args.argc > 3) {
+ ast_log(LOG_WARNING, "%s requires arguments (account,jid[,timeout])\n", name);
+ return -1;
+ }
+
+ client = ast_aji_get_client(args.account);
+ if (!client) {
+ ast_log(LOG_WARNING, "Could not find client %s, exiting\n", args.account);
+ return -1;
+ }
+
+ parse = ast_strdupa(args.jid);
+ AST_NONSTANDARD_APP_ARGS(jid, parse, '/');
+ if (jid.argc < 1 || jid.argc > 2 || strlen(args.jid) > AJI_MAX_JIDLEN) {
+ ast_log(LOG_WARNING, "Invalid JID : %s\n", parse);
+ ASTOBJ_UNREF(client, aji_client_destroy);
+ return -1;
+ }
+
+ if (ast_strlen_zero(args.timeout)) {
+ timeout = 20;
+ } else {
+ sscanf(args.timeout, "%d", &timeout);
+ if (timeout <= 0) {
+ ast_log(LOG_WARNING, "Invalid timeout specified: '%s'\n", args.timeout);
+ ASTOBJ_UNREF(client, aji_client_destroy);
+ return -1;
+ }
+ }
+
+ jidlen = strlen(jid.screenname);
+ resourcelen = ast_strlen_zero(jid.resource) ? 0 : strlen(jid.resource);
+
+ ast_debug(3, "Waiting for an XMPP message from %s\n", args.jid);
+
+ start = ast_tvnow();
+
+ if (ast_autoservice_start(chan) < 0) {
+ ast_log(LOG_WARNING, "Cannot start autoservice for channel %s\n", chan->name);
+ return -1;
+ }
+
+ /* search the messages list, grab the first message that matches with
+ * the from JID we're expecting, and remove it from the messages list */
+ while (diff < timeout) {
+ struct timespec ts = { 0, };
+ struct timeval wait;
+ int res;
+
+ wait = ast_tvadd(start, ast_tv(timeout, 0));
+ ts.tv_sec = wait.tv_sec;
+ ts.tv_nsec = wait.tv_usec * 1000;
+
+ /* wait up to timeout seconds for an incoming message */
+ ast_mutex_lock(&messagelock);
+ res = ast_cond_timedwait(&message_received_condition, &messagelock, &ts);
+ ast_mutex_unlock(&messagelock);
+ if (res == ETIMEDOUT) {
+ ast_debug(3, "No message received from %s in %d seconds\n", args.jid, timeout);
+ break;
+ };
+
+ AST_LIST_LOCK(&client->messages);
+ AST_LIST_TRAVERSE_SAFE_BEGIN(&client->messages, tmp, list) {
+ if (jid.argc == 1) {
+ /* no resource provided, compare bare JIDs */
+ if (strncasecmp(jid.screenname, tmp->from, jidlen)) {
+ continue;
+ }
+ } else {
+ /* resource appended, compare bare JIDs and resources */
+ char *resource = strchr(tmp->from, '/');
+ if (!resource || strlen(resource) == 0) {
+ ast_log(LOG_WARNING, "Remote JID has no resource : %s\n", tmp->from);
+ if (strncasecmp(jid.screenname, tmp->from, jidlen)) {
+ continue;
+ }
+ } else {
+ resource ++;
+ if (strncasecmp(jid.screenname, tmp->from, jidlen) || strncmp(jid.resource, resource, resourcelen)) {
+ continue;
+ }
+ }
+ }
+ /* check if the message is not too old */
+ if (ast_tvdiff_sec(ast_tvnow(), tmp->arrived) >= client->message_timeout) {
+ ast_debug(3, "Found old message from %s, deleting it\n", tmp->from);
+ AST_LIST_REMOVE_CURRENT(list);
+ aji_message_destroy(tmp);
+ continue;
+ }
+ found = 1;
+ aux = ast_strdupa(tmp->message);
+ AST_LIST_REMOVE_CURRENT(list);
+ aji_message_destroy(tmp);
+ break;
+ }
+ AST_LIST_TRAVERSE_SAFE_END;
+ AST_LIST_UNLOCK(&client->messages);
+ if (found) {
+ break;
+ }
+
+ /* check timeout */
+ diff = ast_tvdiff_ms(ast_tvnow(), start);
+ }
+
+ ASTOBJ_UNREF(client, aji_client_destroy);
+ if (ast_autoservice_stop(chan) < 0) {
+ ast_log(LOG_WARNING, "Cannot stop autoservice for channel %s\n", chan->name);
+ }
+
+ /* return if we timed out */
+ if (!found) {
+ ast_log(LOG_NOTICE, "Timed out : no message received from %s\n", args.jid);
+ return -1;
+ }
+ ast_copy_string(buf, aux, buflen);
+
+ return 0;
+}
+
+static struct ast_custom_function jabberreceive_function = {
+ .name = "JABBER_RECEIVE",
+ .read = acf_jabberreceive_read,
+};
+
+/*!
+ * \internal
+ * \brief Delete old messages from a given JID
+ * Messages stored during more than client->message_timeout are deleted
+ * \param client Asterisk's XMPP client
+ * \param from the JID we received messages from
+ * \retval the number of deleted messages
+ * \retval -1 failure
+ */
+static int delete_old_messages(struct aji_client *client, char *from)
+{
+ int deleted = 0;
+ int isold = 0;
+ struct aji_message *tmp = NULL;
+ if (!client) {
+ ast_log(LOG_ERROR, "Cannot find our XMPP client\n");
+ return -1;
+ }
+
+ /* remove old messages */
+ AST_LIST_LOCK(&client->messages);
+ if (AST_LIST_EMPTY(&client->messages)) {
+ AST_LIST_UNLOCK(&client->messages);
+ return 0;
+ }
+
+ AST_LIST_TRAVERSE_SAFE_BEGIN(&client->messages, tmp, list) {
+ if (isold) {
+ if (!from || !strncasecmp(from, tmp->from, strlen(from))) {
+ AST_LIST_REMOVE_CURRENT(list);
+ aji_message_destroy(tmp);
+ deleted ++;
+ }
+ } else if (ast_tvdiff_sec(ast_tvnow(), tmp->arrived) >= client->message_timeout) {
+ isold = 1;
+ if (!from || !strncasecmp(from, tmp->from, strlen(from))) {
+ AST_LIST_REMOVE_CURRENT(list);
+ aji_message_destroy(tmp);
+ deleted ++;
+ }
+ }
+ }
+ AST_LIST_TRAVERSE_SAFE_END;
+ AST_LIST_UNLOCK(&client->messages);
+
+ return deleted;
+}
+
+/*!
+ * \internal
+ * \brief Delete old messages
+ * Messages stored during more than client->message_timeout are deleted
+ * \param client Asterisk's XMPP client
+ * \retval the number of deleted messages
+ * \retval -1 failure
+ */
+static int delete_old_messages_all(struct aji_client *client)
+{
+ return delete_old_messages(client, NULL);
+}
+
+/*!
+ * \internal
* \brief Dial plan function to send a message.
* \param chan ast_channel
- * \param data Data is sender|receiver|message.
- * \return 0 on success,-1 on error.
+ * \param data Data is account,jid,message.
+ * \retval 0 success
+ * \retval -1 failure
*/
static int aji_send_exec(struct ast_channel *chan, const char *data)
{
);
if (!data) {
- ast_log(LOG_ERROR, "Usage: JabberSend(<sender>,<recipient>,<message>)\n");
- return 0;
+ ast_log(LOG_WARNING, "%s requires arguments (account,jid,message)\n", app_ajisend);
+ return -1;
}
s = ast_strdupa(data);
AST_STANDARD_APP_ARGS(args, s);
if (args.argc < 3) {
- ast_log(LOG_ERROR, "JabberSend requires 3 arguments: '%s'\n", data);
+ ast_log(LOG_WARNING, "%s requires arguments (account,jid,message)\n", app_ajisend);
return -1;
}
ast_log(LOG_WARNING, "Could not find sender connection: '%s'\n", args.sender);
return -1;
}
- if (strchr(args.recipient, '@') && !ast_strlen_zero(args.message))
+ if (strchr(args.recipient, '@') && !ast_strlen_zero(args.message)) {
ast_aji_send_chat(client, args.recipient, args.message);
+ }
return 0;
}
-/*!
+/*!
+ * \internal
* \brief Tests whether the connection is secured or not
* \return 0 if the connection is not secured
*/
#ifdef HAVE_OPENSSL
/*!
+ * \internal
* \brief Starts the TLS procedure
* \param client the configured XMPP client we use to connect to a XMPP server
* \return IKS_OK on success, an error code if sending failed, IKS_NET_TLSFAIL
}
/*!
+ * \internal
* \brief TLS handshake, OpenSSL initialization
* \param client the configured XMPP client we use to connect to a XMPP server
* \return IKS_OK on success, IKS_NET_TLSFAIL on failure
#endif /* HAVE_OPENSSL */
/*!
+ * \internal
* \brief Secured or unsecured IO socket receiving function
* \param client the configured XMPP client we use to connect to a XMPP server
* \param buffer the reception buffer
* \param buf_len the size of the buffer
* \param timeout the select timer
- * \return the number of read bytes on success, 0 on timeout expiration,
- * -1 on error
+ * \retval the number of read bytes
+ * \retval 0 timeout expiration
+ * \retval -1 error
*/
static int aji_io_recv(struct aji_client *client, char *buffer, size_t buf_len, int timeout)
{
}
/*!
+ * \internal
* \brief Tries to receive data from the Jabber server
* \param client the configured XMPP client we use to connect to a XMPP server
* \param timeout the timeout value
* This function receives (encrypted or unencrypted) data from the XMPP server,
* and passes it to the parser.
- * \return IKS_OK on success, IKS_NET_RWERR on IO error, IKS_NET_NOCONN, if no
- * connection available, IKS_NET_EXPIRED on timeout expiration
+ * \retval IKS_OK success
+ * \retval IKS_NET_RWERR IO error
+ * \retval IKS_NET_NOCONN no connection available
+ * \retval IKS_NET_EXPIRED timeout expiration
*/
static int aji_recv (struct aji_client *client, int timeout)
{
}
/*!
+ * \internal
* \brief Sends XMPP header to the server
* \param client the configured XMPP client we use to connect to a XMPP server
* \param to the target XMPP server
}
/*!
+ * \internal
* \brief Sends an XML string over an XMPP connection
* \param client the configured XMPP client we use to connect to a XMPP server
* \param xmlstr the XML string to send
}
/*!
+ * \internal
* \brief the debug loop.
* \param data void
* \param xmpp xml data as string
if (is_incoming)
ast_verbose("\nJABBER: %s INCOMING: %s\n", client->name, xmpp);
else {
- if( strlen(xmpp) == 1) {
- if(option_debug > 2 && xmpp[0] == ' ') {
+ if (strlen(xmpp) == 1) {
+ if (option_debug > 2 && xmpp[0] == ' ') {
ast_verbose("\nJABBER: Keep alive packet\n");
}
} else
}
/*!
+ * \internal
* \brief A wrapper function for iks_start_sasl
* \param client the configured XMPP client we use to connect to a XMPP server
* \param type the SASL authentication type. Supported types are PLAIN and MD5
}
/*!
+ * \internal
* \brief The action hook parses the inbound packets, constantly running.
* \param data aji client structure
* \param type type of packet
iks *auth = NULL;
int features = 0;
- if(!node) {
+ 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;
handshake = NULL;
}
client->state = AJI_CONNECTING;
- if(aji_recv(client, 1) == 2) /*XXX proper result for iksemel library on iks_recv of <handshake/> XXX*/
+ if (aji_recv(client, 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 authenticate.\n");
return IKS_OK;
}
/*!
+ * \internal
* \brief Unknown
* \param data void
* \param pak ikspak
return IKS_FILTER_EAT;
}
/*!
+ * \internal
* \brief register handler for incoming querys (IQ's)
* \param data incoming aji_client request
* \param pak ikspak
query = iks_new("query");
error = iks_new("error");
notacceptable = iks_new("not-acceptable");
- if(iq && query && error && notacceptable) {
+ 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);
}
/*!
+ * \internal
* \brief Handles stuff
* \param data void
* \param pak ikspak
return IKS_FILTER_EAT;
}
+
/*!
+ * \internal
* \brief Handle add extra info
* \param data void
* \param pak ikspak
ASTOBJ_UNREF(client, aji_client_destroy);
return IKS_FILTER_EAT;
}
+
/*!
+ * \internal
* \brief Handler of the return info packet
* \param data aji_client
* \param pak ikspak
}
/*!
- * \brief Handles \verbatim <iq> \endverbatim tags.
+ * \internal
+ * \brief Handles \verbatim <iq> \endverbatim stanzas.
* \param client the configured XMPP client we use to connect to a XMPP server
- * \param node iks
+ * \param node iks
* \return void.
*/
static void aji_handle_iq(struct aji_client *client, iks *node)
}
/*!
- * \brief Handles presence packets.
+ * \internal
+ * \brief Handles \verbatim <message>\endverbatim stanzas.
+ * Adds the incoming message to the client's message list.
* \param client the configured XMPP client we use to connect to a XMPP server
* \param pak ikspak the node
*/
static void aji_handle_message(struct aji_client *client, ikspak *pak)
{
- struct aji_message *insert, *tmp;
- int flag = 0;
-
- if (!(insert = ast_calloc(1, sizeof(*insert))))
+ struct aji_message *insert;
+ int deleted = 0;
+
+ ast_debug(3, "client %s received a message\n", client->name);
+
+ if (!(insert = ast_calloc(1, sizeof(*insert)))) {
return;
- time(&insert->arrived);
- if (iks_find_cdata(pak->x, "body"))
+ }
+
+ insert->arrived = ast_tvnow();
+
+ /* wake up threads waiting for messages */
+ ast_mutex_lock(&messagelock);
+ ast_cond_broadcast(&message_received_condition);
+ ast_mutex_unlock(&messagelock);
+
+ 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)
+ }
+ if (pak->id) {
+ ast_copy_string(insert->id, pak->id, sizeof(insert->id));
+ }
+ if (pak->from){
+ /* insert will furtherly be added to message list */
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(list);
- if (tmp->from)
- ast_free(tmp->from);
- if (tmp->message)
- ast_free(tmp->message);
- } else if (difftime(time(NULL), tmp->arrived) >= client->message_timeout) {
- flag = 1;
- AST_LIST_REMOVE_CURRENT(list);
- if (tmp->from)
- ast_free(tmp->from);
- if (tmp->message)
- ast_free(tmp->message);
+ if (!insert->from) {
+ ast_log(LOG_ERROR, "Memory allocation failure\n");
+ return;
}
+ ast_debug(3, "message comes from %s\n", insert->from);
}
- AST_LIST_TRAVERSE_SAFE_END;
+
+ /* remove old messages received from this JID
+ * and insert received message */
+ deleted = delete_old_messages(client, pak->from->partial);
+ ast_debug(3, "Deleted %d messages for client %s from JID %s\n", deleted, client->name, pak->from->partial);
+ AST_LIST_LOCK(&client->messages);
AST_LIST_INSERT_HEAD(&client->messages, insert, list);
AST_LIST_UNLOCK(&client->messages);
}
+
/*!
- * \brief Check the presence info
+ * \internal
+ * \brief handles \verbatim <presence>\endverbatim stanzas.
* \param client the configured XMPP client we use to connect to a XMPP server
* \param pak ikspak
-*/
+ */
static void aji_handle_presence(struct aji_client *client, ikspak *pak)
{
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)
+
+ if (client->state != AJI_CONNECTED)
aji_create_buddy(pak->from->partial, client);
buddy = ASTOBJ_CONTAINER_FIND(&client->buddies, pak->from->partial);
return;
}
type = iks_find_attrib(pak->x, "type");
- if(client->component && type &&!strcasecmp("probe", type)) {
+ if (client->component && type &&!strcasecmp("probe", type)) {
aji_set_presence(client, pak->from->full, iks_find_attrib(pak->x, "to"), client->status, client->statusmessage);
ast_verbose("what i was looking for \n");
}
}
/* retrieve capabilites of the new resource */
- if(status !=6 && found && !found->cap) {
+ if (status != 6 && found && !found->cap) {
found->cap = aji_find_version(node, ver, pak);
- if(gtalk_yuck(pak->x)) /* gtalk should do discover */
+ if (gtalk_yuck(pak->x)) /* gtalk should do discover */
found->cap->jingle = 1;
- if(found->cap->jingle && option_debug > 4) {
+ if (found->cap->jingle && option_debug > 4) {
ast_debug(1,"Special case for google till they support discover.\n");
}
else {
iks *iq, *query;
iq = iks_new("iq");
query = iks_new("query");
- if(query && iq) {
+ if (query && iq) {
iks_insert_attrib(iq, "type", "get");
iks_insert_attrib(iq, "to", pak->from->full);
iks_insert_attrib(iq,"from", client->jid->full);
}
/*!
+ * \internal
* \brief handles subscription requests.
* \param client the configured XMPP client we use to connect to a XMPP server
* \param pak ikspak iksemel packet.
* \param client the configured XMPP client we use to connect to a XMPP server
* \param address
* \param message
- * \return 1.
+ * \retval IKS_OK success
+ * \retval -1 failure
*/
int ast_aji_send_chat(struct aji_client *client, const char *address, const char *message)
{
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 = ast_aji_send(client, message_packet);
- } else {
- ast_log(LOG_ERROR, "Out of memory.\n");
- }
- iks_delete(message_packet);
- } else
+ if (client->state != AJI_CONNECTED) {
ast_log(LOG_WARNING, "JABBER: Not connected can't send\n");
- return 1;
+ return -1;
+ }
+
+ message_packet = iks_make_msg(IKS_TYPE_CHAT, address, message);
+ if (!message_packet) {
+ ast_log(LOG_ERROR, "Out of memory.\n");
+ return -1;
+ }
+
+ iks_insert_attrib(message_packet, "from", client->jid->full);
+ res = ast_aji_send(client, message_packet);
+ iks_delete(message_packet);
+
+ return res;
}
/*!
return res;
}
-
/*!
+ * \internal
* \brief receive message loop.
* \param data void
* \return void.
pthread_exit(NULL);
}
- /* Decrease timeout if no data received */
- if (res == IKS_NET_EXPIRED)
+ /* Decrease timeout if no data received, and delete
+ * old messages globally */
+ if (res == IKS_NET_EXPIRED) {
client->timeout--;
-
- if (res == IKS_HOOK)
+ delete_old_messages_all(client);
+ }
+ if (res == IKS_HOOK) {
ast_log(LOG_WARNING, "JABBER: Got hook event.\n");
- else if (res == IKS_NET_TLSFAIL)
+ } else if (res == IKS_NET_TLSFAIL) {
ast_log(LOG_ERROR, "JABBER: Failure in TLS.\n");
- else if (client->timeout == 0 && client->state == AJI_CONNECTED) {
+ } else if (client->timeout == 0 && client->state == AJI_CONNECTED) {
res = client->keepalive ? aji_send_raw(client, " ") : IKS_OK;
- if(res == IKS_OK)
+ if (res == IKS_OK) {
client->timeout = 50;
- else
+ } else {
ast_log(LOG_WARNING, "JABBER: Network Timeout\n");
- } else if (res == IKS_NET_RWERR)
+ }
+ } 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;
#endif
/*!
+ * \internal
* \brief goes through roster and prunes users not needed in list, or adds them accordingly.
* \param client the configured XMPP client we use to connect to a XMPP server
* \return void.
}
/*!
+ * \internal
* \brief filters the roster packet we get back from server.
* \param data void
* \param pak ikspak iksemel packet.
ASTOBJ_WRLOCK(buddy);
ast_copy_string(buddy->name, iks_find_attrib(x, "jid"), sizeof(buddy->name));
ast_clear_flag(&buddy->flags, AST_FLAGS_ALL);
- if(ast_test_flag(&client->flags, AJI_AUTOPRUNE)) {
+ if (ast_test_flag(&client->flags, AJI_AUTOPRUNE)) {
ast_set_flag(&buddy->flags, AJI_AUTOPRUNE);
ASTOBJ_MARK(buddy);
} else if (!iks_strcmp(iks_find_attrib(x, "subscription"), "none") || !iks_strcmp(iks_find_attrib(x, "subscription"), "from")) {
- /* subscribe to buddy's presence only
+ /* subscribe to buddy's presence only
if we really need to */
ast_set_flag(&buddy->flags, AJI_AUTOREGISTER);
}
}
/*!
+ * \internal
* \brief reconnect to jabber server
* \param client the configured XMPP client we use to connect to a XMPP server
* \return res.
}
/*!
+ * \internal
* \brief Get the roster of jabber users
* \param client the configured XMPP client we use to connect to a XMPP server
* \return 1.
iks *roster = NULL;
roster = iks_make_iq(IKS_TYPE_GET, IKS_NS_ROSTER);
- if(roster) {
+ if (roster) {
iks_insert_attrib(roster, "id", "roster");
aji_set_presence(client, NULL, client->jid->full, client->status, client->statusmessage);
ast_aji_send(client, roster);
}
/*!
+ * \internal
* \brief connects as a client to jabber server.
* \param data void
* \param pak ikspak iksemel packet
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*/
+ if (!client->component) /*client*/
aji_get_roster(client);
}
} else
}
/*!
+ * \internal
* \brief prepares client for connect.
* \param client the configured XMPP client we use to connect to a XMPP server
* \return 1.
}
/*!
+ * \internal
* \brief set presence of client.
* \param client the configured XMPP client we use to connect to a XMPP server
* \param to user send it to
char priorityS[10];
if (presence && cnode && client && priority) {
- if(to)
+ if (to)
iks_insert_attrib(presence, "to", to);
- if(from)
+ if (from)
iks_insert_attrib(presence, "from", from);
snprintf(priorityS, sizeof(priorityS), "%d", client->priority);
iks_insert_cdata(priority, priorityS, strlen(priorityS));
}
/*!
+ * \internal
* \brief Turn on/off console debugging.
* \return CLI_SUCCESS.
*/
}
/*!
+ * \internal
* \brief Reload jabber module.
* \return CLI_SUCCESS.
*/
}
/*!
+ * \internal
* \brief Show client status.
* \return CLI_SUCCESS.
*/
}
/*!
+ * \internal
* \brief Show buddy lists
* \return CLI_SUCCESS.
*/
ASTOBJ_RDLOCK(iterator);
ast_cli(a->fd,"\tBuddy:\t%s\n", iterator->name);
if (!iterator->resources)
- ast_cli(a->fd,"\t\tResource: None\n");
+ ast_cli(a->fd,"\t\tResource: None\n");
for (resource = iterator->resources; resource; resource = resource->next) {
ast_cli(a->fd,"\t\tResource: %s\n", resource->resource);
- if(resource->cap) {
+ if (resource->cap) {
ast_cli(a->fd,"\t\t\tnode: %s\n", resource->cap->parent->node);
ast_cli(a->fd,"\t\t\tversion: %s\n", resource->cap->version);
ast_cli(a->fd,"\t\t\tJingle capable: %s\n", resource->cap->jingle ? "yes" : "no");
}
/*!
+ * \internal
* \brief Send test message for debugging.
* \return CLI_SUCCESS,CLI_FAILURE.
*/
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) {
+ 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,""));
+ 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_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);
}
/*!
+ * \internal
* \brief creates aji_client structure.
* \param label
* \param var ast_variable
client->forcessl = 0;
client->keepalive = 1;
client->timeout = 50;
- client->message_timeout = 100;
+ client->message_timeout = 5;
AST_LIST_HEAD_INIT(&client->messages);
client->component = 0;
ast_copy_string(client->statusmessage, "Online and Available", sizeof(client->statusmessage));
buddy = ASTOBJ_CONTAINER_FIND(&client->buddies,label);
if (!buddy) {
buddy = ast_calloc(1, sizeof(*buddy));
- if(!buddy) {
+ if (!buddy) {
ast_log(LOG_WARNING, "Out of memory\n");
return 0;
}
#endif
/*!
+ * \internal
* \brief creates buddy.
* \param label char.
* \param client the configured XMPP client we use to connect to a XMPP server
if (!buddy) {
flag = 1;
buddy = ast_calloc(1, sizeof(*buddy));
- if(!buddy) {
+ if (!buddy) {
ast_log(LOG_WARNING, "Out of memory\n");
return 0;
}
ASTOBJ_WRLOCK(buddy);
ast_copy_string(buddy->name, label, sizeof(buddy->name));
ASTOBJ_UNLOCK(buddy);
- if(flag)
+ if (flag)
ASTOBJ_CONTAINER_LINK(&client->buddies, buddy);
else {
ASTOBJ_UNMARK(buddy);
}
/*!
+ * \internal
* \brief Send a Jabber Message via call from the Manager
* \param s mansession Manager session
* \param m message Message to send
return 0;
}
-/*! \brief Reload the jabber module */
+/*!
+ * \internal
+ * \brief Reload the jabber module
+ */
static int aji_reload(int reload)
{
int res;
ASTOBJ_CONTAINER_PRUNE_MARKED(&clients, aji_client_destroy);
ASTOBJ_CONTAINER_TRAVERSE(&clients, 1, {
ASTOBJ_RDLOCK(iterator);
- if(iterator->state == AJI_DISCONNECTED) {
+ 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)
return 1;
}
-/*! \brief Unload the jabber module */
+/*!
+ * \internal
+ * \brief Unload the jabber module
+ */
static int unload_module(void)
{
ast_unregister_application(app_ajistatus);
ast_manager_unregister("JabberSend");
ast_custom_function_unregister(&jabberstatus_function);
-
+ ast_custom_function_unregister(&jabberreceive_function);
+
ASTOBJ_CONTAINER_TRAVERSE(&clients, 1, {
ASTOBJ_RDLOCK(iterator);
ast_debug(3, "JABBER: Releasing and disconnecting client: %s\n", iterator->name);
ASTOBJ_CONTAINER_DESTROYALL(&clients, aji_client_destroy);
ASTOBJ_CONTAINER_DESTROY(&clients);
+
+ ast_cond_destroy(&message_received_condition);
+ ast_mutex_destroy(&messagelock);
+
return 0;
}
-/*! \brief Unload the jabber module */
+/*!
+ * \internal
+ * \brief Unload the jabber module
+ */
static int load_module(void)
{
ASTOBJ_CONTAINER_INIT(&clients);
- if(!aji_reload(0))
+ if (!aji_reload(0))
return AST_MODULE_LOAD_DECLINE;
ast_manager_register_xml("JabberSend", EVENT_FLAG_SYSTEM, manager_jabber_send);
ast_register_application_xml(app_ajisend, aji_send_exec);
ast_register_application_xml(app_ajistatus, aji_status_exec);
ast_cli_register_multiple(aji_cli, ARRAY_LEN(aji_cli));
ast_custom_function_register(&jabberstatus_function);
+ ast_custom_function_register(&jabberreceive_function);
+ ast_mutex_init(&messagelock);
+ ast_cond_init(&message_received_condition, NULL);
return 0;
}
-/*! \brief Wrapper for aji_reload */
+/*!
+ * \internal
+ * \brief Wrapper for aji_reload
+ */
static int reload(void)
{
aji_reload(1);
projects / asterisk/asterisk.git / commitdiff