Skip to content

F
freeswitch
提交 0f0f2781 authored 作者: Chris Rienzo's avatar Chris Rienzo
浏览文件
操作

mod_rayo: reworked internal messaging- all messages sent by JID only

上级 911948c8
显示空白字符变更
内嵌 并排
正在显示 包含 380 行增加 和 400 行删除
src/mod/event_handlers/mod_rayo/mod_rayo.c
浏览文件 @ 0f0f2781
......@@ -67,9 +67,9 @@ struct rayo_call;
* Function pointer wrapper for the handlers hash
*/
struct rayo_xmpp_handler {
enum rayo_actor_type from_type;
const char *from_type;
const char *from_subtype;
enum rayo_actor_type to_type;
const char *to_type;
const char *to_subtype;
rayo_actor_xmpp_handler fn;
};
......@@ -102,8 +102,6 @@ struct rayo_client {
struct rayo_actor base;
/** availability */
enum presence_status availability;
/** true if superuser */
int is_admin;
/** set if reachable via s2s */
struct rayo_peer_server *peer_server;
/** domain or full JID to route to */
......@@ -215,16 +213,25 @@ struct dial_gateway {
int strip;
};
static void rayo_call_send(struct rayo_actor *client, struct rayo_actor *call, struct rayo_message *msg, const char *file, int line);
static void rayo_server_send(struct rayo_actor *client, struct rayo_actor *server, struct rayo_message *msg, const char *file, int line);
static void rayo_mixer_send(struct rayo_actor *client, struct rayo_actor *mixer, struct rayo_message *msg, const char *file, int line);
static void rayo_component_send(struct rayo_actor *client, struct rayo_actor *component, struct rayo_message *msg, const char *file, int line);
static void rayo_client_send(struct rayo_actor *from, struct rayo_actor *client, struct rayo_message *msg, const char *file, int line);
static void rayo_console_client_send(struct rayo_actor *from, struct rayo_actor *client, struct rayo_message *msg, const char *file, int line);
static void rayo_call_send(struct rayo_actor *call, struct rayo_message *msg, const char *file, int line);
static void rayo_server_send(struct rayo_actor *server, struct rayo_message *msg, const char *file, int line);
static void rayo_mixer_send(struct rayo_actor *mixer, struct rayo_message *msg, const char *file, int line);
static void rayo_component_send(struct rayo_actor *component, struct rayo_message *msg, const char *file, int line);
static void rayo_client_send(struct rayo_actor *client, struct rayo_message *msg, const char *file, int line);
static void rayo_console_client_send(struct rayo_actor *client, struct rayo_message *msg, const char *file, int line);
static void on_client_presence(struct rayo_client *rclient, iks *node);
/**
* @param jid to check
* @return true if jid is admin client (console)
*/
static int is_admin_client(const char *jid)
{
return !zstr(jid) && !strcmp(RAYO_JID(globals.console), jid);
}
/**
* Presence status
* @param status the presence status
......@@ -241,25 +248,6 @@ static const char *presence_status_to_string(enum presence_status status)
return "UNKNOWN";
}
/**
* Convert Rayo actor type to string
* @param type the Rayo actor type
* @return the string value of type or "UNKNOWN"
*/
static const char *rayo_actor_type_to_string(enum rayo_actor_type type)
{
switch(type) {
case RAT_PEER_SERVER: return "PEER_SERVER";
case RAT_CLIENT: return "CLIENT";
case RAT_CALL: return "CALL";
case RAT_CALL_COMPONENT: return "CALL_COMPONENT";
case RAT_MIXER: return "MIXER";
case RAT_MIXER_COMPONENT: return "MIXER_COMPONENT";
case RAT_SERVER: return "SERVER";
}
return "UNKNOWN";
}
/**
* Get rayo cause code from FS hangup cause
* @param cause FS hangup cause
......@@ -436,7 +424,7 @@ static void rayo_command_handler_add(const char *name, struct rayo_xmpp_handler
{
char full_name[1024];
full_name[1023] = '\0';
snprintf(full_name, sizeof(full_name) - 1, "%i:%s:%s", handler->to_type, handler->to_subtype, name);
snprintf(full_name, sizeof(full_name) - 1, "%s:%s:%s", handler->to_type, handler->to_subtype, name);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding command: %s\n", full_name);
switch_core_hash_insert(globals.command_handlers, full_name, handler);
}
......@@ -448,10 +436,10 @@ static void rayo_command_handler_add(const char *name, struct rayo_xmpp_handler
* @param name the command name
* @param fn the command callback function
*/
void rayo_actor_command_handler_add(enum rayo_actor_type type, const char *subtype, const char *name, rayo_actor_xmpp_handler fn)
void rayo_actor_command_handler_add(const char *type, const char *subtype, const char *name, rayo_actor_xmpp_handler fn)
{
struct rayo_xmpp_handler *handler = switch_core_alloc(globals.pool, sizeof (*handler));
handler->to_type = type;
handler->to_type = zstr(type) ? "" : switch_core_strdup(globals.pool, type);
handler->to_subtype = zstr(subtype) ? "" : switch_core_strdup(globals.pool, subtype);
handler->fn = fn;
rayo_command_handler_add(name, handler);
......@@ -460,11 +448,12 @@ void rayo_actor_command_handler_add(enum rayo_actor_type type, const char *subty
/**
* Get command handler function from hash
* @param hash the hash to search
* @param iq
* @param msg the command
* @return the command handler function or NULL
*/
rayo_actor_xmpp_handler rayo_actor_command_handler_find(struct rayo_actor *actor, iks *iq)
rayo_actor_xmpp_handler rayo_actor_command_handler_find(struct rayo_actor *actor, struct rayo_message *msg)
{
iks *iq = msg->payload;
const char *iq_type = iks_find_attrib_soft(iq, "type");
iks *command = iks_first_tag(iq);
const char *name = "";
......@@ -481,7 +470,7 @@ rayo_actor_xmpp_handler rayo_actor_command_handler_find(struct rayo_actor *actor
}
}
snprintf(full_name, sizeof(full_name) - 1, "%i:%s:%s:%s:%s", actor->type, actor->subtype, iq_type, namespace, name);
snprintf(full_name, sizeof(full_name) - 1, "%s:%s:%s:%s:%s", actor->type, actor->subtype, iq_type, namespace, name);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, looking for %s command\n", RAYO_JID(actor), full_name);
handler = (struct rayo_xmpp_handler *)switch_core_hash_find(globals.command_handlers, full_name);
if (handler) {
......@@ -500,7 +489,7 @@ static void rayo_event_handler_add(const char *name, struct rayo_xmpp_handler *h
{
char full_name[1024];
full_name[1023] = '\0';
snprintf(full_name, sizeof(full_name) - 1, "%i:%s:%i:%s:%s", handler->from_type, handler->from_subtype, handler->to_type, handler->to_subtype, name);
snprintf(full_name, sizeof(full_name) - 1, "%s:%s:%s:%s:%s", handler->from_type, handler->from_subtype, handler->to_type, handler->to_subtype, name);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding event: %s\n", full_name);
switch_core_hash_insert(globals.event_handlers, full_name, handler);
}
......@@ -514,12 +503,12 @@ static void rayo_event_handler_add(const char *name, struct rayo_xmpp_handler *h
* @param name the event name
* @param fn the event callback function
*/
void rayo_actor_event_handler_add(enum rayo_actor_type from_type, const char *from_subtype, enum rayo_actor_type to_type, const char *to_subtype, const char *name, rayo_actor_xmpp_handler fn)
void rayo_actor_event_handler_add(const char *from_type, const char *from_subtype, const char *to_type, const char *to_subtype, const char *name, rayo_actor_xmpp_handler fn)
{
struct rayo_xmpp_handler *handler = switch_core_alloc(globals.pool, sizeof (*handler));
handler->from_type = from_type;
handler->from_type = zstr(from_type) ? "" : switch_core_strdup(globals.pool, from_type);
handler->from_subtype = zstr(from_subtype) ? "" : switch_core_strdup(globals.pool, from_subtype);
handler->to_type = to_type;
handler->to_type = zstr(to_type) ? "" : switch_core_strdup(globals.pool, to_type);
handler->to_subtype = zstr(to_subtype) ? "" : switch_core_strdup(globals.pool, to_subtype);
handler->fn = fn;
rayo_event_handler_add(name, handler);
......@@ -527,13 +516,13 @@ void rayo_actor_event_handler_add(enum rayo_actor_type from_type, const char *fr
/**
* Get event handler function from hash
* @param from the event source
* @param actor the event destination
* @param presence the event
* @param msg the event
* @return the event handler function or NULL
*/
rayo_actor_xmpp_handler rayo_actor_event_handler_find(struct rayo_actor *from, struct rayo_actor *actor, iks *presence)
rayo_actor_xmpp_handler rayo_actor_event_handler_find(struct rayo_actor *actor, struct rayo_message *msg)
{
iks *presence = msg->payload;
iks *event = iks_first_tag(presence);
if (event) {
struct rayo_xmpp_handler *handler = NULL;
......@@ -545,39 +534,38 @@ rayo_actor_xmpp_handler rayo_actor_event_handler_find(struct rayo_actor *from, s
if (zstr(event_name)) {
return NULL;
}
snprintf(full_name, sizeof(full_name) - 1, "%i:%s:%i:%s:%s:%s:%s", from->type, from->subtype, actor->type, actor->subtype, presence_type, event_namespace, event_name);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s => %s, looking for %s event handler\n", RAYO_JID(from), RAYO_JID(actor), full_name);
snprintf(full_name, sizeof(full_name) - 1, "%s:%s:%s:%s:%s:%s:%s", msg->from_type, msg->from_subtype, actor->type, actor->subtype, presence_type, event_namespace, event_name);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s => %s, looking for %s event handler\n", msg->from_jid, RAYO_JID(actor), full_name);
handler = (struct rayo_xmpp_handler *)switch_core_hash_find(globals.event_handlers, full_name);
if (handler) {
return handler->fn;
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s => %s, event missing child element\n", RAYO_JID(from), RAYO_JID(actor));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s => %s, event missing child element\n", msg->from_jid, RAYO_JID(actor));
}
return NULL;
}
/**
* Create a new xml message for delivery to an actor.
* @param from actor creating this message
* @param xml to create message from. This value will be freed upon message delivery.
* @param dup true if duplicate payload
* @param reply true if a reply (error or result)
* @return the message
*/
struct rayo_message *rayo_message_create(iks *xml)
{
struct rayo_message *msg = malloc(sizeof(*msg));
msg->payload = xml;
return msg;
}
/**
* Create a new xml message for delivery to an actor. The XML is duplicated before delivery.
* @param xml to create message from. This value will not be freed.
* @return the message
*/
struct rayo_message *rayo_message_create_dup(iks *xml)
struct rayo_message *rayo_message_create(struct rayo_actor *from, iks *xml, int dup, int reply)
{
struct rayo_message *msg = malloc(sizeof(*msg));
if (dup) {
msg->payload = iks_copy(xml);
} else {
msg->payload = xml;
}
msg->is_reply = reply;
msg->from_jid = strdup(RAYO_JID(from));
msg->from_type = strdup(zstr(from->type) ? "" : from->type);
msg->from_subtype = strdup(zstr(from->subtype) ? "" : from->subtype);
return msg;
}
......@@ -591,6 +579,9 @@ void rayo_message_destroy(struct rayo_message *msg)
if (msg->payload) {
iks_delete(msg->payload);
}
switch_safe_free(msg->from_jid);
switch_safe_free(msg->from_type);
switch_safe_free(msg->from_subtype);
free(msg);
}
}
......@@ -606,16 +597,16 @@ iks *rayo_message_remove_payload(struct rayo_message *msg)
}
/**
* Send message to actor
* Deliver message to actor
*/
void rayo_actor_send(struct rayo_actor *from, struct rayo_actor *actor, struct rayo_message *msg, const char *file, int line)
static void rayo_actor_deliver(struct rayo_actor *actor, struct rayo_message *msg, const char *file, int line)
{
iks *payload = msg->payload;
char *msg_str = iks_string(iks_stack(payload), payload);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, "", line, "", SWITCH_LOG_DEBUG, "%s, %s\n", RAYO_JID(from), msg_str);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, "", line, "", SWITCH_LOG_DEBUG, "%s, %s\n", msg->from_jid, msg_str);
switch_mutex_lock(actor->mutex);
actor->send_fn(from, actor, msg, file, line);
actor->send_fn(actor, msg, file, line);
switch_mutex_unlock(actor->mutex);
rayo_message_destroy(msg);
......@@ -624,14 +615,19 @@ void rayo_actor_send(struct rayo_actor *from, struct rayo_actor *actor, struct r
/**
* Send message to actor addressed by JID
*/
void rayo_actor_send_by_jid(struct rayo_actor *from, const char *jid, struct rayo_message *msg, const char *file, int line)
void rayo_actor_send(const char *jid, struct rayo_message *msg, const char *file, int line)
{
struct rayo_actor *actor = RAYO_LOCATE(jid);
if (actor) {
rayo_actor_send(from, actor, msg, file, line);
/* TODO queue to thread pool */
rayo_actor_deliver(actor, msg, file, line);
RAYO_UNLOCK(actor);
} else {
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, "", line, "", SWITCH_LOG_DEBUG, "%s, failed to locate %s.\n", RAYO_JID(from), jid);
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, "", line, "", SWITCH_LOG_DEBUG, "%s, failed to locate %s.\n", msg->from_jid, jid);
if (!msg->is_reply) {
/* don't reply to replies to prevent infinite loops */
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(globals.server, iks_new_error(msg->payload, STANZA_ERROR_ITEM_NOT_FOUND)));
}
rayo_message_destroy(msg);
}
}
......@@ -698,11 +694,15 @@ void rayo_actor_destroy(struct rayo_actor *actor, const char *file, int line)
}
actor->destroy = 1;
if (actor->ref_count <= 0) {
struct rayo_message *msg;
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, "", line, "", SWITCH_LOG_DEBUG, "Destroying %s\n", RAYO_JID(actor));
if (actor->cleanup_fn) {
actor->cleanup_fn(actor);
}
switch_core_hash_delete(globals.destroy_actors, RAYO_JID(actor));
while (switch_queue_trypop(actor->msg_queue, (void *)&msg) == SWITCH_STATUS_SUCCESS) {
rayo_message_destroy(msg);
}
switch_core_destroy_memory_pool(&pool);
} else {
switch_core_hash_insert(globals.destroy_actors, RAYO_JID(actor), actor);
......@@ -760,7 +760,7 @@ int rayo_actor_seq_next(struct rayo_actor *actor)
static struct rayo_call *rayo_call_locate(const char *call_uuid, const char *file, int line)
{
struct rayo_actor *actor = rayo_actor_locate_by_id(call_uuid, file, line);
if (actor && actor->type == RAT_CALL) {
if (actor && !strcmp(RAT_CALL, actor->type)) {
return RAYO_CALL(actor);
} else if (actor) {
RAYO_UNLOCK(actor);
......@@ -834,14 +834,14 @@ static void rayo_call_cleanup(struct rayo_actor *actor)
switch_assert(client_jid);
iks_insert_attrib(revent, "to", client_jid);
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(rayo_call_get_uuid(call)), SWITCH_LOG_DEBUG, "Sending <end> to offered client %s\n", client_jid);
RAYO_SEND_BY_JID(actor, client_jid, rayo_message_create_dup(revent));
RAYO_SEND(client_jid, RAYO_MESSAGE_CREATE_DUP(actor, revent));
no_offered_clients = 0;
}
if (no_offered_clients) {
/* send to DCP only */
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(rayo_call_get_uuid(call)), SWITCH_LOG_DEBUG, "Sending <end> to DCP %s\n", rayo_call_get_dcp_jid(call));
RAYO_SEND_BY_JID(actor, rayo_call_get_dcp_jid(call), rayo_message_create_dup(revent));
RAYO_SEND(rayo_call_get_dcp_jid(call), RAYO_MESSAGE_CREATE_DUP(actor, revent));
}
iks_delete(revent);
......@@ -875,7 +875,7 @@ static int rayo_call_is_joined(struct rayo_call *call)
static struct rayo_mixer *rayo_mixer_locate(const char *mixer_name, const char *file, int line)
{
struct rayo_actor *actor = rayo_actor_locate_by_id(mixer_name, file, line);
if (actor && actor->type == RAT_MIXER) {
if (actor && !strcmp(RAT_MIXER, actor->type)) {
return RAYO_MIXER(actor);
} else if (actor) {
RAYO_UNLOCK(actor);
......@@ -886,9 +886,9 @@ static struct rayo_mixer *rayo_mixer_locate(const char *mixer_name, const char *
/**
* Default message handler - drops messages
*/
void rayo_actor_send_ignore(struct rayo_actor *from, struct rayo_actor *to, struct rayo_message *msg, const char *file, int line)
void rayo_actor_send_ignore(struct rayo_actor *to, struct rayo_message *msg, const char *file, int line)
{
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, "", line, "", SWITCH_LOG_WARNING, "%s, dropping unexpected message to %s.\n", RAYO_JID(from), RAYO_JID(to));
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, "", line, "", SWITCH_LOG_WARNING, "%s, dropping unexpected message to %s.\n", msg->from_jid, RAYO_JID(to));
}
#define RAYO_ACTOR_INIT(actor, pool, type, subtype, id, jid, cleanup, send) rayo_actor_init(actor, pool, type, subtype, id, jid, cleanup, send, __FILE__, __LINE__)
......@@ -901,14 +901,15 @@ void rayo_actor_send_ignore(struct rayo_actor *from, struct rayo_actor *to, stru
* @param id internal ID
* @param jid external ID
* @param cleanup function
* @param send sent message handler
* @param file that called this function
* @param line that called this function
* @return the actor
*/
static struct rayo_actor *rayo_actor_init(struct rayo_actor *actor, switch_memory_pool_t *pool, enum rayo_actor_type type, const char *subtype, const char *id, const char *jid, rayo_actor_cleanup_fn cleanup, rayo_actor_send_fn send, const char *file, int line)
static struct rayo_actor *rayo_actor_init(struct rayo_actor *actor, switch_memory_pool_t *pool, const char *type, const char *subtype, const char *id, const char *jid, rayo_actor_cleanup_fn cleanup, rayo_actor_send_fn send, const char *file, int line)
{
char *domain;
actor->type = type;
actor->type = switch_core_strdup(pool, type);
actor->subtype = switch_core_strdup(pool, subtype);
actor->pool = pool;
if (!zstr(id)) {
......@@ -938,6 +939,7 @@ static struct rayo_actor *rayo_actor_init(struct rayo_actor *actor, switch_memor
} else {
actor->send_fn = send;
}
switch_queue_create(&actor->msg_queue, 20, pool);
/* add to hash of actors, so commands can route to call */
switch_mutex_lock(globals.actors_mutex);
......@@ -1036,30 +1038,21 @@ static void rayo_component_cleanup(struct rayo_actor *actor)
/**
* Initialize Rayo component
* @param type of this component
* @param subtype of this component
* @param id internal ID of this component
* @param parent the parent that owns this component
* @param client_jid the client that created this component
* @return the component
*/
struct rayo_component *_rayo_component_init(struct rayo_component *component, switch_memory_pool_t *pool, const char *type, const char *id, struct rayo_actor *parent, const char *client_jid, const char *file, int line)
struct rayo_component *_rayo_component_init(struct rayo_component *component, switch_memory_pool_t *pool, const char *type, const char *subtype, const char *id, struct rayo_actor *parent, const char *client_jid, const char *file, int line)
{
enum rayo_actor_type actor_type;
char *ref = switch_mprintf("%s-%d", type, rayo_actor_seq_next(parent));
char *jid = switch_mprintf("%s/%s", RAYO_JID(parent), ref);
if (zstr(id)) {
id = jid;
}
if (parent->type == RAT_CALL || parent->type == RAT_CALL_COMPONENT) {
actor_type = RAT_CALL_COMPONENT;
} else if (parent->type == RAT_MIXER) {
actor_type = RAT_MIXER_COMPONENT;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Created component with parent %s, type (%s)\n",
RAYO_JID(parent), rayo_actor_type_to_string(parent->type));
return NULL;
}
rayo_actor_init(RAYO_ACTOR(component), pool, actor_type, type, id, jid, rayo_component_cleanup, rayo_component_send, file, line);
rayo_actor_init(RAYO_ACTOR(component), pool, type, subtype, id, jid, rayo_component_cleanup, rayo_component_send, file, line);
RAYO_RDLOCK(parent);
component->client_jid = switch_core_strdup(pool, client_jid);
......@@ -1074,7 +1067,7 @@ struct rayo_component *_rayo_component_init(struct rayo_component *component, sw
/**
* Send XMPP message to client
*/
void rayo_client_send(struct rayo_actor *from, struct rayo_actor *client, struct rayo_message *msg, const char *file, int line)
void rayo_client_send(struct rayo_actor *client, struct rayo_message *msg, const char *file, int line)
{
xmpp_stream_context_send(globals.xmpp_context, RAYO_CLIENT(client)->route, msg->payload);
}
......@@ -1103,14 +1096,12 @@ static void rayo_client_cleanup(struct rayo_actor *actor)
* @param route to this client
* @param availability of client
* @param send message transmission function
* @param is_admin true if admin client
* @param peer_server NULL if locally connected client
* @return the new client
*/
static struct rayo_client *rayo_client_init(struct rayo_client *client, switch_memory_pool_t *pool, const char *jid, const char *route, enum presence_status availability, rayo_actor_send_fn send, int is_admin, struct rayo_peer_server *peer_server)
static struct rayo_client *rayo_client_init(struct rayo_client *client, switch_memory_pool_t *pool, const char *jid, const char *route, enum presence_status availability, rayo_actor_send_fn send, struct rayo_peer_server *peer_server)
{
RAYO_ACTOR_INIT(RAYO_ACTOR(client), pool, RAT_CLIENT, "", jid, jid, rayo_client_cleanup, send);
client->is_admin = is_admin;
client->availability = availability;
client->peer_server = peer_server;
client->last_probe = 0;
......@@ -1136,11 +1127,10 @@ static struct rayo_client *rayo_client_init(struct rayo_client *client, switch_m
* @param route to this client
* @param availability of client
* @param send message transmission function
* @param is_admin true if admin client
* @param peer_server NULL if locally connected client
* @return the new client or NULL
*/
static struct rayo_client *rayo_client_create(const char *jid, const char *route, enum presence_status availability, rayo_actor_send_fn send, int is_admin, struct rayo_peer_server *peer_server)
static struct rayo_client *rayo_client_create(const char *jid, const char *route, enum presence_status availability, rayo_actor_send_fn send, struct rayo_peer_server *peer_server)
{
switch_memory_pool_t *pool;
struct rayo_client *rclient = NULL;
......@@ -1150,13 +1140,13 @@ static struct rayo_client *rayo_client_create(const char *jid, const char *route
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error\n");
return NULL;
}
return rayo_client_init(rclient, pool, jid, route, availability, send, is_admin, peer_server);
return rayo_client_init(rclient, pool, jid, route, availability, send, peer_server);
}
/**
* Send XMPP message to peer server
*/
void rayo_peer_server_send(struct rayo_actor *from, struct rayo_actor *server, struct rayo_message *msg, const char *file, int line)
void rayo_peer_server_send(struct rayo_actor *server, struct rayo_message *msg, const char *file, int line)
{
xmpp_stream_context_send(globals.xmpp_context, RAYO_JID(server), msg->payload);
}
......@@ -1217,11 +1207,11 @@ static struct rayo_peer_server *rayo_peer_server_create(const char *jid)
* @param call_uuid the internal call UUID
* @return 1 if session has call control
*/
static int rayo_client_has_call_control(struct rayo_client *rclient, struct rayo_call *call, switch_core_session_t *session)
static int rayo_client_has_call_control(const char *rclient, struct rayo_call *call, switch_core_session_t *session)
{
int control = 0;
if (zstr(RAYO_JID(rclient))) {
if (zstr(rclient)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Null client JID!!\n");
return 0;
}
......@@ -1229,19 +1219,19 @@ static int rayo_client_has_call_control(struct rayo_client *rclient, struct rayo
/* nobody in charge */
if (zstr(call->dcp_jid)) {
/* was offered to this session? */
if (switch_core_hash_find(call->pcps, RAYO_JID(rclient))) {
if (switch_core_hash_find(call->pcps, rclient)) {
/* take charge */
call->dcp_jid = switch_core_strdup(RAYO_POOL(call), RAYO_JID(rclient));
call->dcp_jid = switch_core_strdup(RAYO_POOL(call), rclient);
switch_channel_set_variable(switch_core_session_get_channel(session), "rayo_dcp_jid", rayo_call_get_dcp_jid(call));
control = 1;
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(rayo_call_get_uuid(call)), SWITCH_LOG_INFO, "%s has control of call\n", rayo_call_get_dcp_jid(call));
}
} else if (rclient->is_admin || !strcmp(rayo_call_get_dcp_jid(call), RAYO_JID(rclient))) {
} else if (is_admin_client(rclient) || !strcmp(rayo_call_get_dcp_jid(call), rclient)) {
control = 1;
}
if (!control) {
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(rayo_call_get_uuid(call)), SWITCH_LOG_INFO, "%s does not have control of call\n", RAYO_JID(rclient));
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(rayo_call_get_uuid(call)), SWITCH_LOG_INFO, "%s does not have control of call\n", rclient);
}
return control;
......@@ -1249,21 +1239,18 @@ static int rayo_client_has_call_control(struct rayo_client *rclient, struct rayo
/**
* Check Rayo server command for errors.
* @param rclient the Rayo client
* @param node the <iq> node
* @param server the server
* @param msg the command
* @return 1 if OK
*/
static iks *rayo_server_command_ok(struct rayo_actor *rclient, struct rayo_actor *server, iks *node)
static iks *rayo_server_command_ok(struct rayo_actor *server, struct rayo_message *msg)
{
iks *node = msg->payload;
iks *response = NULL;
int bad = zstr(iks_find_attrib(node, "id"));
if (bad) {
response = iks_new_error(node, STANZA_ERROR_BAD_REQUEST);
} else if (rclient->type != RAT_CLIENT) {
/* not a rayo client request */
response = iks_new_error(node, STANZA_ERROR_NOT_ALLOWED);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s not a client\n", RAYO_JID(rclient), RAYO_JID(server));
}
return response;
......@@ -1271,36 +1258,22 @@ static iks *rayo_server_command_ok(struct rayo_actor *rclient, struct rayo_actor
/**
* Check Rayo call command for errors.
* @param rclient the Rayo client
* @param call the Rayo call
* @param session the session
* @param node the <iq> node
* @param msg the command
* @return 1 if OK
*/
static iks *rayo_call_command_ok(struct rayo_actor *rclient, struct rayo_call *call, switch_core_session_t *session, iks *node)
static iks *rayo_call_command_ok(struct rayo_call *call, switch_core_session_t *session, struct rayo_message *msg)
{
iks *node = msg->payload;
iks *response = NULL;
int bad = zstr(iks_find_attrib(node, "id"));
if (bad) {
response = iks_new_error(node, STANZA_ERROR_BAD_REQUEST);
} else if (rclient->type == RAT_CALL_COMPONENT) {
struct rayo_actor *client = RAYO_LOCATE(RAYO_COMPONENT(rclient)->client_jid);
if (client) {
iks *response = rayo_call_command_ok(client, call, session, node);
RAYO_UNLOCK(client);
return response;
}
/* not a client request */
response = iks_new_error(node, STANZA_ERROR_NOT_ALLOWED);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s call component client is gone\n", RAYO_JID(rclient), RAYO_JID(call));
} else if (rclient->type != RAT_CLIENT) {
/* not a client request */
response = iks_new_error(node, STANZA_ERROR_NOT_ALLOWED);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s not a client request\n", RAYO_JID(rclient), RAYO_JID(call));
} else if (!rayo_client_has_call_control(RAYO_CLIENT(rclient), call, session)) {
} else if (!rayo_client_has_call_control(msg->from_jid, call, session)) {
response = iks_new_error(node, STANZA_ERROR_CONFLICT);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s conflict\n", RAYO_JID(rclient), RAYO_JID(call));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s conflict\n", msg->from_jid, RAYO_JID(call));
}
return response;
......@@ -1308,27 +1281,24 @@ static iks *rayo_call_command_ok(struct rayo_actor *rclient, struct rayo_call *c
/**
* Check Rayo component command for errors.
* @param rclient the client
* @param component the component
* @param node the <iq> node
* @param msg the command
* @return 0 if error
*/
static iks *rayo_component_command_ok(struct rayo_actor *rclient, struct rayo_component *component, iks *node)
static iks *rayo_component_command_ok(struct rayo_component *component, struct rayo_message *msg)
{
iks *node = msg->payload;
iks *response = NULL;
char *from = iks_find_attrib(node, "from");
int bad = zstr(iks_find_attrib(node, "id"));
if (bad) {
response = iks_new_error(node, STANZA_ERROR_BAD_REQUEST);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s bad request\n", RAYO_JID(rclient), RAYO_JID(component));
} else if (rclient->type != RAT_CLIENT) {
/* internal message is ok */
return NULL;
} else if (!RAYO_CLIENT(rclient)->is_admin && strcmp(component->client_jid, from)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s bad request\n", msg->from_jid, RAYO_JID(component));
} else if (!is_admin_client(msg->from_jid) && strcmp(component->client_jid, from)) {
/* does not have control of this component */
response = iks_new_error(node, STANZA_ERROR_CONFLICT);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s conflict\n", RAYO_JID(rclient), RAYO_JID(component));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, %s conflict\n", msg->from_jid, RAYO_JID(component));
}
return response;
......@@ -1337,39 +1307,46 @@ static iks *rayo_component_command_ok(struct rayo_actor *rclient, struct rayo_co
/**
* Handle server message
*/
void rayo_server_send(struct rayo_actor *client, struct rayo_actor *server, struct rayo_message *msg, const char *file, int line)
void rayo_server_send(struct rayo_actor *server, struct rayo_message *msg, const char *file, int line)
{
iks *response = NULL;
rayo_actor_xmpp_handler handler = NULL;
iks *iq = msg->payload;
if (!strcmp("presence", iks_name(iq))) {
/* this is a hack - message from internal console */
struct rayo_actor *client = RAYO_LOCATE(msg->from_jid);
if (client) {
if (!strcmp(RAT_CLIENT, client->type)) {
on_client_presence(RAYO_CLIENT(client), iq);
}
RAYO_UNLOCK(client);
}
return;
}
/* is this a command a server supports? */
handler = rayo_actor_command_handler_find(server, iq);
handler = rayo_actor_command_handler_find(server, msg);
if (!handler) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, no handler function for command to %s\n", RAYO_JID(client), RAYO_JID(server));
RAYO_SEND(server, client, rayo_message_create(iks_new_error(iq, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, no handler function for command to %s\n", msg->from_jid, RAYO_JID(server));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(server, iks_new_error(iq, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
return;
}
/* is the command valid? */
if (!(response = rayo_server_command_ok(client, server, iq))) {
response = handler(client, server, iq, NULL);
if (!(response = rayo_server_command_ok(server, msg))) {
response = handler(server, msg, NULL);
}
if (response) {
RAYO_SEND(server, client, rayo_message_create(response));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(server, response));
}
}
/**
* Handle call message
*/
void rayo_call_send(struct rayo_actor *client, struct rayo_actor *call, struct rayo_message *msg, const char *file, int line)
void rayo_call_send(struct rayo_actor *call, struct rayo_message *msg, const char *file, int line)
{
rayo_actor_xmpp_handler handler = NULL;
iks *iq = msg->payload;
......@@ -1377,10 +1354,10 @@ void rayo_call_send(struct rayo_actor *client, struct rayo_actor *call, struct r
iks *response = NULL;
/* is this a command a call supports? */
handler = rayo_actor_command_handler_find(call, iq);
handler = rayo_actor_command_handler_find(call, msg);
if (!handler) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, no handler function for command\n", RAYO_JID(call));
RAYO_SEND(call, client, rayo_message_create(iks_new_error(iq, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(call, iks_new_error(iq, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
return;
}
......@@ -1388,52 +1365,52 @@ void rayo_call_send(struct rayo_actor *client, struct rayo_actor *call, struct r
session = switch_core_session_locate(rayo_call_get_uuid(RAYO_CALL(call)));
if (!session) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, session not found\n", RAYO_JID(call));
RAYO_SEND(call, client, rayo_message_create(iks_new_error(iq, STANZA_ERROR_SERVICE_UNAVAILABLE)));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(call, iks_new_error(iq, STANZA_ERROR_SERVICE_UNAVAILABLE)));
return;
}
/* is the command valid? */
if (!(response = rayo_call_command_ok(client, RAYO_CALL(call), session, iq))) {
if (!(response = rayo_call_command_ok(RAYO_CALL(call), session, msg))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, executing command\n", RAYO_JID(call));
response = handler(client, call, iq, session);
response = handler(call, msg, session);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, done executing command\n", RAYO_JID(call));
RAYO_CALL(call)->idle_start_time = switch_micro_time_now();
}
switch_core_session_rwunlock(session);
if (response) {
RAYO_SEND(call, client, rayo_message_create(response));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(call, response));
}
}
/**
* Handle mixer message
*/
void rayo_mixer_send(struct rayo_actor *client, struct rayo_actor *mixer, struct rayo_message *msg, const char *file, int line)
void rayo_mixer_send(struct rayo_actor *mixer, struct rayo_message *msg, const char *file, int line)
{
rayo_actor_xmpp_handler handler = NULL;
iks *iq = msg->payload;
iks *response = NULL;
/* is this a command a mixer supports? */
handler = rayo_actor_command_handler_find(mixer, iq);
handler = rayo_actor_command_handler_find(mixer, msg);
if (!handler) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, no handler function for command\n", RAYO_JID(mixer));
RAYO_SEND(mixer, client, rayo_message_create(iks_new_error(iq, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(mixer, iks_new_error(iq, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
return;
}
/* execute the command */
response = handler(client, mixer, iq, NULL);
response = handler(mixer, msg, NULL);
if (response) {
RAYO_SEND(mixer, client, rayo_message_create(response));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(mixer, response));
}
}
/**
* Handle mixer message
*/
void rayo_component_send(struct rayo_actor *client, struct rayo_actor *component, struct rayo_message *msg, const char *file, int line)
void rayo_component_send(struct rayo_actor *component, struct rayo_message *msg, const char *file, int line)
{
rayo_actor_xmpp_handler handler = NULL;
iks *xml_msg = msg->payload;
......@@ -1441,27 +1418,27 @@ void rayo_component_send(struct rayo_actor *client, struct rayo_actor *component
if (!strcmp("iq", iks_name(xml_msg))) {
/* is this a command a component supports? */
handler = rayo_actor_command_handler_find(component, xml_msg);
handler = rayo_actor_command_handler_find(component, msg);
if (!handler) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, no component handler function for command\n", RAYO_JID(component));
RAYO_SEND(component, client, rayo_message_create(iks_new_error(xml_msg, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(component, iks_new_error(xml_msg, STANZA_ERROR_FEATURE_NOT_IMPLEMENTED)));
return;
}
/* is the command valid? */
if (!(response = rayo_component_command_ok(client, RAYO_COMPONENT(component), xml_msg))) {
if (!(response = rayo_component_command_ok(RAYO_COMPONENT(component), msg))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, executing command\n", RAYO_JID(component));
response = handler(client, component, xml_msg, NULL);
response = handler(component, msg, NULL);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, done executing command\n", RAYO_JID(component));
}
if (response) {
RAYO_SEND(component, client, rayo_message_create(response));
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(component, response));
return;
}
} else if (!strcmp("presence", iks_name(xml_msg))) {
/* is this an event the component wants? */
handler = rayo_actor_event_handler_find(client, component, xml_msg);
handler = rayo_actor_event_handler_find(component, msg);
if (!handler) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, no component handler function for event\n", RAYO_JID(component));
return;
......@@ -1469,7 +1446,10 @@ void rayo_component_send(struct rayo_actor *client, struct rayo_actor *component
/* forward the event */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, forwarding event\n", RAYO_JID(component));
handler(client, component, xml_msg, NULL);
response = handler(component, msg, NULL);
if (response) {
RAYO_SEND(msg->from_jid, RAYO_REPLY_CREATE(component, response));
}
}
}
......@@ -1501,8 +1481,9 @@ static void add_signaling_headers(switch_core_session_t *session, iks *iq_cmd, c
* @param session the session
* @param node the <iq> node
*/
static iks *on_rayo_accept(struct rayo_actor *client, struct rayo_actor *call, iks *node, void *session_data)
static iks *on_rayo_accept(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *node = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
iks *response = NULL;
......@@ -1519,8 +1500,9 @@ static iks *on_rayo_accept(struct rayo_actor *client, struct rayo_actor *call, i
* @param session the session
* @param node the <iq> node
*/
static iks *on_rayo_answer(struct rayo_actor *client, struct rayo_actor *call, iks *node, void *session_data)
static iks *on_rayo_answer(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *node = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
iks *response = NULL;
......@@ -1537,8 +1519,9 @@ static iks *on_rayo_answer(struct rayo_actor *client, struct rayo_actor *call, i
* @param session the session
* @param node the <iq> node
*/
static iks *on_rayo_redirect(struct rayo_actor *client, struct rayo_actor *call, iks *node, void *session_data)
static iks *on_rayo_redirect(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *node = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
iks *response = NULL;
iks *redirect = iks_find(node, "redirect");
......@@ -1566,8 +1549,9 @@ static iks *on_rayo_redirect(struct rayo_actor *client, struct rayo_actor *call,
* @param session the session
* @param node the <iq> node
*/
static iks *on_rayo_hangup(struct rayo_actor *client, struct rayo_actor *call, iks *node, void *session_data)
static iks *on_rayo_hangup(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *node = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
iks *response = NULL;
iks *hangup = iks_first_tag(node);
......@@ -1673,8 +1657,9 @@ static iks *join_mixer(struct rayo_call *call, switch_core_session_t *session, i
* @param session the session
* @param node the <iq> node
*/
static iks *on_rayo_join(struct rayo_actor *client, struct rayo_actor *call, iks *node, void *session_data)
static iks *on_rayo_join(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *node = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
iks *response = NULL;
iks *join = iks_find(node, "join");
......@@ -1728,7 +1713,7 @@ done:
* @param call_id the b-leg uuid
* @return the response
*/
static iks *unjoin_call(struct rayo_actor *client, struct rayo_call *call, switch_core_session_t *session, iks *node, const char *call_id)
static iks *unjoin_call(struct rayo_call *call, switch_core_session_t *session, iks *node, const char *call_id)
{
iks *response = NULL;
const char *bleg = switch_channel_get_variable(switch_core_session_get_channel(session), SWITCH_BRIDGE_UUID_VARIABLE);
......@@ -1754,7 +1739,7 @@ static iks *unjoin_call(struct rayo_actor *client, struct rayo_call *call, switc
* @param mixer_name the mixer name
* @return the response
*/
static iks *unjoin_mixer(struct rayo_actor *client, struct rayo_call *call, switch_core_session_t *session, iks *node, const char *mixer_name)
static iks *unjoin_mixer(struct rayo_call *call, switch_core_session_t *session, iks *node, const char *mixer_name)
{
switch_channel_t *channel = switch_core_session_get_channel(session);
const char *conf_member_id = switch_channel_get_variable(channel, "conference_member_id");
......@@ -1793,8 +1778,9 @@ done:
* @param session the session
* @param node the <iq> node
*/
static iks *on_rayo_unjoin(struct rayo_actor *client, struct rayo_actor *call, iks *node, void *session_data)
static iks *on_rayo_unjoin(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *node = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
iks *response = NULL;
iks *unjoin = iks_find(node, "unjoin");
......@@ -1807,9 +1793,9 @@ static iks *on_rayo_unjoin(struct rayo_actor *client, struct rayo_actor *call, i
/* not joined to anything */
response = iks_new_error(node, STANZA_ERROR_SERVICE_UNAVAILABLE);
} else if (!zstr(call_id)) {
response = unjoin_call(client, RAYO_CALL(call), session, node, call_id);
response = unjoin_call(RAYO_CALL(call), session, node, call_id);
} else if (!zstr(mixer_name)) {
response = unjoin_mixer(client, RAYO_CALL(call), session, node, mixer_name);
response = unjoin_mixer(RAYO_CALL(call), session, node, mixer_name);
} else {
/* missing mixer or call */
response = iks_new_error(node, STANZA_ERROR_BAD_REQUEST);
......@@ -1818,15 +1804,22 @@ static iks *on_rayo_unjoin(struct rayo_actor *client, struct rayo_actor *call, i
return response;
}
struct dial_thread_data {
switch_memory_pool_t *pool;
iks *node;
};
/**
* Thread that handles originating new calls
* @param thread this thread
* @param obj the Rayo client
* @return NULL
*/
static void *SWITCH_THREAD_FUNC rayo_dial_thread(switch_thread_t *thread, void *node)
static void *SWITCH_THREAD_FUNC rayo_dial_thread(switch_thread_t *thread, void *user)
{
iks *iq = (iks *)node;
struct dial_thread_data *dtdata = (struct dial_thread_data *)user;
iks *iq = dtdata->node;
iks *dial = iks_find(iq, "dial");
iks *response = NULL;
const char *dcp_jid = iks_find_attrib(iq, "from");
......@@ -1977,7 +1970,7 @@ done:
/* response when error */
if (response) {
/* send response to client */
RAYO_SEND_BY_JID(call, iks_find_attrib(response, "to"), rayo_message_create(response));
RAYO_SEND(iks_find_attrib(response, "to"), RAYO_REPLY_CREATE(call, response));
/* destroy call */
if (call) {
......@@ -1990,18 +1983,24 @@ done:
switch_safe_free(stream.data);
switch_safe_free(dial_to_dup);
{
switch_memory_pool_t *pool = dtdata->pool;
switch_core_destroy_memory_pool(&pool);
}
return NULL;
}
/**
* Dial a new call
* @param rclient requesting the call
* @param server handling the call
* @param node the request
*/
static iks *on_rayo_dial(struct rayo_actor *client, struct rayo_actor *server, iks *node, void *data)
static iks *on_rayo_dial(struct rayo_actor *server, struct rayo_message *msg, void *data)
{
struct rayo_client *rclient = RAYO_CLIENT(client);
iks *node = msg->payload;
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
iks *dial = iks_find(node, "dial");
......@@ -2013,14 +2012,20 @@ static iks *on_rayo_dial(struct rayo_actor *client, struct rayo_actor *server, i
} else if (strchr(dial_to, ' ')) {
response = iks_new_error_detailed(node, STANZA_ERROR_BAD_REQUEST, "malformed dial string");
} else {
iks *node_dup = iks_copy(node);
iks_insert_attrib(node_dup, "from", RAYO_JID(rclient)); /* save DCP jid in case it isn't specified */
switch_memory_pool_t *pool;
struct dial_thread_data *dtdata = NULL;
switch_core_new_memory_pool(&pool);
dtdata = switch_core_alloc(pool, sizeof(*dtdata));
dtdata->pool = pool;
dtdata->node = iks_copy(node);
iks_insert_attrib(dtdata->node, "from", msg->from_jid); /* save DCP jid in case it isn't specified */
/* start dial thread */
switch_threadattr_create(&thd_attr, RAYO_POOL(rclient));
switch_threadattr_create(&thd_attr, pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_thread_create(&thread, thd_attr, rayo_dial_thread, node_dup, RAYO_POOL(rclient));
switch_thread_create(&thread, thd_attr, rayo_dial_thread, dtdata, pool);
}
return response;
......@@ -2033,14 +2038,15 @@ static iks *on_rayo_dial(struct rayo_actor *client, struct rayo_actor *server, i
* @param node the <iq> node
* @return NULL
*/
static iks *on_iq_xmpp_ping(struct rayo_actor *rclient, struct rayo_actor *server, iks *node, void *data)
static iks *on_iq_xmpp_ping(struct rayo_actor *server, struct rayo_message *msg, void *data)
{
iks *node = msg->payload;
iks *pong = iks_new("iq");
char *from = iks_find_attrib(node, "from");
char *to = iks_find_attrib(node, "to");
if (zstr(from)) {
from = RAYO_JID(rclient);
from = msg->from_jid;
}
if (zstr(to)) {
......@@ -2062,8 +2068,9 @@ static iks *on_iq_xmpp_ping(struct rayo_actor *rclient, struct rayo_actor *serve
* @param node the <iq> node
* @return NULL
*/
static iks *on_iq_get_xmpp_disco(struct rayo_actor *rclient, struct rayo_actor *server, iks *node, void *data)
static iks *on_iq_get_xmpp_disco(struct rayo_actor *server, struct rayo_message *msg, void *data)
{
iks *node = msg->payload;
iks *response = NULL;
iks *x;
response = iks_new_iq_result(node);
......@@ -2087,7 +2094,6 @@ static iks *on_iq_get_xmpp_disco(struct rayo_actor *rclient, struct rayo_actor *
static void on_client_message(struct rayo_client *rclient, iks *message)
{
const char *to = iks_find_attrib(message, "to");
struct rayo_actor *actor;
/* must be directed to a client */
if (zstr(to)) {
......@@ -2101,11 +2107,7 @@ static void on_client_message(struct rayo_client *rclient, iks *message)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, recv message, availability = %s\n", RAYO_JID(rclient), presence_status_to_string(rclient->availability));
actor = RAYO_LOCATE(to);
if (actor && actor->type == RAT_CLIENT) {
RAYO_SEND(rclient, actor, rayo_message_create_dup(message));
}
RAYO_UNLOCK(actor);
RAYO_SEND(to, RAYO_MESSAGE_CREATE_DUP(rclient, message));
}
/**
......@@ -2171,11 +2173,10 @@ static void on_client_presence(struct rayo_client *rclient, iks *node)
}
/* destroy if not a local client (connected via peer_server) and is OFFLINE */
/* TODO rethink this */
//if (rclient->peer_server && rclient->availability == PS_OFFLINE) {
// RAYO_DESTROY(rclient);
// RAYO_UNLOCK(rclient);
//}
if (rclient->peer_server && rclient->availability == PS_OFFLINE) {
RAYO_DESTROY(rclient);
RAYO_UNLOCK(rclient);
}
}
/**
......@@ -2201,19 +2202,10 @@ static void rayo_client_command_recv(struct rayo_client *rclient, iks *iq)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, recv iq, availability = %s\n", RAYO_JID(rclient), presence_status_to_string(rclient->availability));
if (rclient->availability == PS_UNKNOWN) {
}
if (command) {
struct rayo_actor *actor = RAYO_LOCATE(to);
if (actor) {
RAYO_SEND(rclient, actor, rayo_message_create_dup(iq));
RAYO_UNLOCK(actor);
RAYO_SEND(to, RAYO_MESSAGE_CREATE_DUP(rclient, iq));
} else {
RAYO_SEND(globals.server, rclient, rayo_message_create(iks_new_error(iq, STANZA_ERROR_ITEM_NOT_FOUND)));
}
} else {
RAYO_SEND(globals.server, rclient, rayo_message_create(iks_new_error_detailed(iq, STANZA_ERROR_BAD_REQUEST, "empty IQ request")));
RAYO_SEND(RAYO_JID(rclient), RAYO_REPLY_CREATE(globals.server, iks_new_error_detailed(iq, STANZA_ERROR_BAD_REQUEST, "empty IQ request")));
}
}
......@@ -2233,7 +2225,7 @@ static void broadcast_mixer_event(struct rayo_mixer *mixer, iks *rayo_event)
subscriber = (struct rayo_mixer_subscriber *)val;
switch_assert(subscriber);
iks_insert_attrib(rayo_event, "to", subscriber->jid);
RAYO_SEND_BY_JID(mixer, subscriber->jid, rayo_message_create_dup(rayo_event));
RAYO_SEND(subscriber->jid, RAYO_MESSAGE_CREATE_DUP(mixer, rayo_event));
}
}
......@@ -2272,7 +2264,7 @@ static void on_mixer_delete_member_event(struct rayo_mixer *mixer, switch_event_
delete_member_event = iks_new_presence("unjoined", RAYO_NS, member->jid, member->dcp_jid);
x = iks_find(delete_member_event, "unjoined");
iks_insert_attrib(x, "mixer-name", rayo_mixer_get_name(mixer));
RAYO_SEND_BY_JID(mixer, member->dcp_jid, rayo_message_create(delete_member_event));
RAYO_SEND(member->dcp_jid, RAYO_MESSAGE_CREATE(mixer, delete_member_event));
/* broadcast member unjoined event to subscribers */
delete_member_event = iks_new_presence("unjoined", RAYO_NS, RAYO_JID(mixer), "");
......@@ -2346,7 +2338,7 @@ static void on_mixer_add_member_event(struct rayo_mixer *mixer, switch_event_t *
add_member_event = iks_new_presence("joined", RAYO_NS, RAYO_JID(call), call->dcp_jid);
x = iks_find(add_member_event, "joined");
iks_insert_attrib(x, "mixer-name", rayo_mixer_get_name(mixer));
RAYO_SEND_BY_JID(call, call->dcp_jid, rayo_message_create(add_member_event));
RAYO_SEND(call->dcp_jid, RAYO_MESSAGE_CREATE(call, add_member_event));
RAYO_UNLOCK(call);
}
......@@ -2422,7 +2414,7 @@ static void on_call_originate_event(struct rayo_client *rclient, switch_event_t
#else
iks_insert_attrib_printf(ref, "uri", "xmpp:%s", RAYO_JID(call));
#endif
RAYO_SEND(call, rclient, rayo_message_create(response));
RAYO_SEND(RAYO_JID(rclient), RAYO_MESSAGE_CREATE(call, response));
call->dial_id = NULL;
}
RAYO_UNLOCK(call);
......@@ -2463,7 +2455,7 @@ static void on_call_answer_event(struct rayo_client *rclient, switch_event_t *ev
iks *revent = iks_new_presence("answered", RAYO_NS,
switch_event_get_header(event, "variable_rayo_call_jid"),
switch_event_get_header(event, "variable_rayo_dcp_jid"));
RAYO_SEND(call, rclient, rayo_message_create(revent));
RAYO_SEND(RAYO_JID(rclient), RAYO_MESSAGE_CREATE(call, revent));
RAYO_UNLOCK(call);
}
}
......@@ -2480,7 +2472,7 @@ static void on_call_ringing_event(struct rayo_client *rclient, switch_event_t *e
iks *revent = iks_new_presence("ringing", RAYO_NS,
switch_event_get_header(event, "variable_rayo_call_jid"),
switch_event_get_header(event, "variable_rayo_dcp_jid"));
RAYO_SEND(call, rclient, rayo_message_create(revent));
RAYO_SEND(RAYO_JID(rclient), RAYO_MESSAGE_CREATE(call, revent));
RAYO_UNLOCK(call);
}
}
......@@ -2507,7 +2499,7 @@ static void on_call_bridge_event(struct rayo_client *rclient, switch_event_t *ev
call->joined = 1;
RAYO_SEND(call, rclient, rayo_message_create(revent));
RAYO_SEND(RAYO_JID(rclient), RAYO_MESSAGE_CREATE(call, revent));
/* send B-leg event */
b_call = RAYO_CALL_LOCATE(b_uuid);
......@@ -2518,7 +2510,7 @@ static void on_call_bridge_event(struct rayo_client *rclient, switch_event_t *ev
b_call->joined = 1;
RAYO_SEND_BY_JID(b_call, rayo_call_get_dcp_jid(b_call), rayo_message_create(revent));
RAYO_SEND(rayo_call_get_dcp_jid(b_call), RAYO_MESSAGE_CREATE(b_call, revent));
RAYO_UNLOCK(b_call);
}
RAYO_UNLOCK(call);
......@@ -2544,7 +2536,7 @@ static void on_call_unbridge_event(struct rayo_client *rclient, switch_event_t *
switch_event_get_header(event, "variable_rayo_dcp_jid"));
iks *joined = iks_find(revent, "unjoined");
iks_insert_attrib(joined, "call-uri", b_uuid);
RAYO_SEND(call, rclient, rayo_message_create(revent));
RAYO_SEND(RAYO_JID(rclient), RAYO_MESSAGE_CREATE(call, revent));
call->joined = 0;
......@@ -2554,7 +2546,7 @@ static void on_call_unbridge_event(struct rayo_client *rclient, switch_event_t *
revent = iks_new_presence("unjoined", RAYO_NS, RAYO_JID(b_call), rayo_call_get_dcp_jid(b_call));
joined = iks_find(revent, "unjoined");
iks_insert_attrib(joined, "call-uri", a_uuid);
RAYO_SEND_BY_JID(b_call, rayo_call_get_dcp_jid(b_call), rayo_message_create(revent));
RAYO_SEND(rayo_call_get_dcp_jid(b_call), RAYO_MESSAGE_CREATE(b_call, revent));
b_call->joined = 0;
RAYO_UNLOCK(b_call);
......@@ -2613,13 +2605,9 @@ static void route_call_event(switch_event_t *event)
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(uuid), SWITCH_LOG_DEBUG, "%s rayo event %s\n", dcp_jid, switch_event_name(event->event_id));
actor = RAYO_LOCATE(dcp_jid);
if (actor && actor->type == RAT_CLIENT) {
if (RAYO_CLIENT(actor)->is_admin) {
/* FIXME ignore? */
} else {
/* process event and route to client */
if (actor && !strcmp(RAT_CLIENT, actor->type)) {
/* route to client */
rayo_client_handle_event(RAYO_CLIENT(actor), event);
}
} else {
/* TODO orphaned call... maybe allow events to queue so they can be delivered on reconnect? */
switch_log_printf(SWITCH_CHANNEL_UUID_LOG(uuid), SWITCH_LOG_DEBUG, "Orphaned call event %s to %s\n", switch_event_name(event->event_id), dcp_jid);
......@@ -2771,7 +2759,7 @@ SWITCH_STANDARD_APP(rayo_app)
ok = 1;
switch_core_hash_insert(call->pcps, RAYO_JID(rclient), "1");
iks_insert_attrib(offer, "to", RAYO_JID(rclient));
RAYO_SEND_BY_JID(call, RAYO_JID(rclient), rayo_message_create_dup(offer));
RAYO_SEND(RAYO_JID(rclient), RAYO_MESSAGE_CREATE_DUP(call, offer));
}
}
iks_delete(offer);
......@@ -2811,9 +2799,9 @@ static struct rayo_actor *xmpp_stream_client_locate(struct xmpp_stream *stream,
if (!actor) {
/* previously unknown client - add it */
struct rayo_peer_server *rserver = RAYO_PEER_SERVER(xmpp_stream_get_private(stream));
actor = RAYO_ACTOR(rayo_client_create(jid, xmpp_stream_get_jid(stream), PS_UNKNOWN, rayo_client_send, 0, rserver));
actor = RAYO_ACTOR(rayo_client_create(jid, xmpp_stream_get_jid(stream), PS_UNKNOWN, rayo_client_send, rserver));
RAYO_RDLOCK(actor);
} else if (actor->type != RAT_CLIENT) {
} else if (!strcmp(RAT_CLIENT, actor->type)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, not a client: %s\n", xmpp_stream_get_jid(stream), jid);
RAYO_UNLOCK(actor);
actor = NULL;
......@@ -2845,11 +2833,11 @@ static void on_xmpp_stream_ready(struct xmpp_stream *stream)
iks_insert_attrib(presence, "to", xmpp_stream_get_jid(stream));
x = iks_insert(presence, "show");
iks_insert_cdata(x, "chat", 4);
RAYO_SEND_BY_JID(globals.server, xmpp_stream_get_jid(stream), rayo_message_create(presence));
RAYO_SEND(xmpp_stream_get_jid(stream), RAYO_MESSAGE_CREATE(globals.server, presence));
}
} else {
/* client belongs to stream */
xmpp_stream_set_private(stream, rayo_client_create(xmpp_stream_get_jid(stream), xmpp_stream_get_jid(stream), PS_OFFLINE, rayo_client_send, 0, NULL));
xmpp_stream_set_private(stream, rayo_client_create(xmpp_stream_get_jid(stream), xmpp_stream_get_jid(stream), PS_OFFLINE, rayo_client_send, NULL));
}
}
......@@ -2862,22 +2850,6 @@ static void rayo_client_presence_check(struct rayo_client *rclient)
if (rclient->availability == PS_UNKNOWN) {
/* for now, set online */
rclient->availability = PS_ONLINE;
#if 0
/* send probe */
switch_time_t now = switch_micro_time_now();
/* throttle probes... */
if (now - rclient->last_probe > 1000 * 1000 * 10) {
iks *probe = iks_new("presence");
rclient->last_probe = now;
iks_insert_attrib(probe, "type", "probe");
iks_insert_attrib(probe, "from", RAYO_JID(globals.server));
iks_insert_attrib(probe, "to", RAYO_JID(rclient));
RAYO_SEND(globals.server, rclient, rayo_message_create(probe));
}
} else {
rclient->last_probe = 0;
#endif
}
}
......@@ -3101,10 +3073,10 @@ done:
*/
static void rayo_actor_dump(struct rayo_actor *actor, switch_stream_handle_t *stream)
{
if (actor->type == RAT_CLIENT) {
stream->write_function(stream, "TYPE='%s',SUBTYPE='%s',ID='%s',JID='%s',DOMAIN='%s',REFS=%i,STATUS='%s'", rayo_actor_type_to_string(actor->type), actor->subtype, actor->id, RAYO_JID(actor), RAYO_DOMAIN(actor), actor->ref_count, presence_status_to_string(RAYO_CLIENT(actor)->availability));
if (!strcmp(RAT_CLIENT, actor->type)) {
stream->write_function(stream, "TYPE='%s',SUBTYPE='%s',ID='%s',JID='%s',DOMAIN='%s',REFS=%i,STATUS='%s'", actor->type, actor->subtype, actor->id, RAYO_JID(actor), RAYO_DOMAIN(actor), actor->ref_count, presence_status_to_string(RAYO_CLIENT(actor)->availability));
} else {
stream->write_function(stream, "TYPE='%s',SUBTYPE='%s',ID='%s',JID='%s',DOMAIN='%s',REFS=%i", rayo_actor_type_to_string(actor->type), actor->subtype, actor->id, RAYO_JID(actor), RAYO_DOMAIN(actor), actor->ref_count);
stream->write_function(stream, "TYPE='%s',SUBTYPE='%s',ID='%s',JID='%s',DOMAIN='%s',REFS=%i", actor->type, actor->subtype, actor->id, RAYO_JID(actor), RAYO_DOMAIN(actor), actor->ref_count);
}
}
......@@ -3153,14 +3125,14 @@ static int dump_api(const char *cmd, switch_stream_handle_t *stream)
/**
* Process response to console command_api
*/
void rayo_console_client_send(struct rayo_actor *from, struct rayo_actor *actor, struct rayo_message *msg, const char *file, int line)
void rayo_console_client_send(struct rayo_actor *actor, struct rayo_message *msg, const char *file, int line)
{
iks *response = msg->payload;
if (response) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nRECV: from %s, %s\n", RAYO_JID(from), iks_string(iks_stack(response), response));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nRECV: from %s, %s\n", msg->from_jid, iks_string(iks_stack(response), response));
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nRECV: (null) from %s\n", RAYO_JID(from));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nRECV: (null) from %s\n", msg->from_jid);
}
}
......@@ -3175,7 +3147,7 @@ static struct rayo_client *rayo_console_client_create(void)
char id[SWITCH_UUID_FORMATTED_LENGTH + 1] = { 0 };
switch_uuid_str(id, sizeof(id));
jid = switch_mprintf("%s@%s/console", id, RAYO_JID(globals.server));
client = rayo_client_create(jid, NULL, PS_OFFLINE, rayo_console_client_send, 1, NULL);
client = rayo_client_create(jid, NULL, PS_OFFLINE, rayo_console_client_send, NULL);
free(jid);
return client;
}
......@@ -3255,8 +3227,6 @@ static int command_api(const char *cmd, switch_stream_handle_t *stream)
*/
static void send_console_message(struct rayo_client *client, const char *to, const char *message_str)
{
struct rayo_actor *actor = RAYO_LOCATE(to);
if (actor) {
iks *message = NULL, *x;
message = iks_new("message");
iks_insert_attrib(message, "to", to);
......@@ -3266,9 +3236,7 @@ static void send_console_message(struct rayo_client *client, const char *to, con
x = iks_insert(message, "body");
iks_insert_cdata(x, message_str, strlen(message_str));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nSEND: to %s, %s\n", to, iks_string(iks_stack(message), message));
RAYO_SEND(client, actor, rayo_message_create(message));
RAYO_UNLOCK(actor);
}
RAYO_SEND(to, RAYO_MESSAGE_CREATE(client, message));
}
/**
......@@ -3298,8 +3266,6 @@ static int message_api(const char *msg, switch_stream_handle_t *stream)
*/
static void send_console_presence(struct rayo_client *client, const char *to, int is_online)
{
struct rayo_actor *actor = RAYO_LOCATE(to);
if (actor) {
iks *presence = NULL, *x;
presence = iks_new("presence");
iks_insert_attrib(presence, "to", to);
......@@ -3311,9 +3277,7 @@ static void send_console_presence(struct rayo_client *client, const char *to, in
x = iks_insert(presence, "show");
iks_insert_cdata(x, is_online ? "chat" : "dnd", 0);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CONSOLE, "\nSEND: to %s, %s\n", to, iks_string(iks_stack(presence), presence));
RAYO_SEND(client, actor, rayo_message_create(presence));
RAYO_UNLOCK(actor);
}
RAYO_SEND(to, RAYO_MESSAGE_CREATE(client, presence));
}
/**
......@@ -3383,7 +3347,7 @@ switch_status_t list_internal(const char *line, const char *cursor, switch_conso
switch_hash_this(hi, &vvar, NULL, &val);
actor = (struct rayo_actor *) val;
if (actor->type != RAT_CLIENT && actor->type != RAT_PEER_SERVER) {
if (strcmp(RAT_CLIENT, actor->type) && strcmp(RAT_PEER_SERVER, actor->type)) {
switch_console_push_match(&my_matches, (const char *) vvar);
}
}
......@@ -3414,7 +3378,7 @@ switch_status_t list_external(const char *line, const char *cursor, switch_conso
switch_hash_this(hi, &vvar, NULL, &val);
actor = (struct rayo_actor *) val;
if (actor->type == RAT_CLIENT || actor->type == RAT_PEER_SERVER) {
if (!strcmp(RAT_CLIENT, actor->type) || !strcmp(RAT_PEER_SERVER, actor->type)) {
switch_console_push_match(&my_matches, (const char *) vvar);
}
}
......
src/mod/event_handlers/mod_rayo/mod_rayo.h
浏览文件 @ 0f0f2781
......@@ -42,6 +42,14 @@
#define RAYO_CALL_NS RAYO_BASE "call:" RAYO_VERSION
#define RAYO_MIXER_NS RAYO_BASE "mixer:" RAYO_VERSION
#define RAT_CALL "CALL"
#define RAT_COMPONENT "COMPONENT"
#define RAT_CALL_COMPONENT RAT_COMPONENT"_CALL"
#define RAT_MIXER "MIXER"
#define RAT_MIXER_COMPONENT RAT_COMPONENT"_MIXER"
#define RAT_SERVER "SERVER"
#define RAT_PEER_SERVER "PEER_SERVER"
#define RAT_CLIENT "CLIENT"
/* these are support punchblock.. undefine once punchblock is fixed */
#define RAYO_UUID_IN_REF_URI
......@@ -56,30 +64,21 @@ struct rayo_component;
*/
struct rayo_message {
iks *payload;
char *from_jid;
char *from_type;
char *from_subtype;
int is_reply;
};
typedef void (* rayo_actor_cleanup_fn)(struct rayo_actor *);
typedef void (* rayo_actor_send_fn)(struct rayo_actor *, struct rayo_actor *, struct rayo_message *, const char *file, int line);
/**
* Type of actor
*/
enum rayo_actor_type {
RAT_PEER_SERVER,
RAT_CLIENT,
RAT_SERVER,
RAT_CALL,
RAT_MIXER,
RAT_CALL_COMPONENT,
RAT_MIXER_COMPONENT
};
typedef void (* rayo_actor_send_fn)(struct rayo_actor *, struct rayo_message *, const char *file, int line);
/**
* A rayo actor - this is an entity that can be controlled by a rayo client
*/
struct rayo_actor {
/** Type of actor */
enum rayo_actor_type type;
char *type;
/** Sub-type of actor */
char *subtype;
/** domain part of JID */
......@@ -102,6 +101,8 @@ struct rayo_actor {
rayo_actor_send_fn send_fn;
/** optional cleanup */
rayo_actor_cleanup_fn cleanup_fn;
/** incoming message queue */
switch_queue_t *msg_queue;
};
/**
......@@ -125,16 +126,19 @@ struct rayo_component {
#define RAYO_CALL(x) ((struct rayo_call *)x)
#define RAYO_MIXER(x) ((struct rayo_mixer *)x)
extern struct rayo_message *rayo_message_create(iks *xml);
extern struct rayo_message *rayo_message_create_dup(iks *xml);
extern struct rayo_message *rayo_message_create(struct rayo_actor *from, iks *xml, int dup, int reply);
extern void rayo_message_destroy(struct rayo_message *msg);
extern iks *rayo_message_remove_payload(struct rayo_message *msg);
#define RAYO_MESSAGE_CREATE(from, msg) rayo_message_create(RAYO_ACTOR(from), msg, 0, 0)
#define RAYO_MESSAGE_CREATE_DUP(from, msg) rayo_message_create(RAYO_ACTOR(from), msg, 1, 0)
#define RAYO_REPLY_CREATE(from, msg) rayo_message_create(RAYO_ACTOR(from), msg, 0, 1)
#define RAYO_REPLY_CREATE_DUP(from, msg) rayo_message_create(RAYO_ACTOR(from), msg, 1, 1)
extern struct rayo_actor *rayo_actor_locate(const char *jid, const char *file, int line);
extern struct rayo_actor *rayo_actor_locate_by_id(const char *id, const char *file, int line);
extern int rayo_actor_seq_next(struct rayo_actor *actor);
extern void rayo_actor_send(struct rayo_actor *from, struct rayo_actor *to, struct rayo_message *msg, const char *file, int line);
extern void rayo_actor_send_by_jid(struct rayo_actor *from, const char *jid, struct rayo_message *msg, const char *file, int line);
extern void rayo_actor_send(const char *jid, struct rayo_message *msg, const char *file, int line);
extern void rayo_actor_rdlock(struct rayo_actor *actor, const char *file, int line);
extern void rayo_actor_unlock(struct rayo_actor *actor, const char *file, int line);
extern void rayo_actor_destroy(struct rayo_actor *actor, const char *file, int line);
......@@ -150,19 +154,18 @@ extern void rayo_actor_destroy(struct rayo_actor *actor, const char *file, int l
#define RAYO_UNLOCK(x) rayo_actor_unlock(RAYO_ACTOR(x), __FILE__, __LINE__)
#define RAYO_DESTROY(x) rayo_actor_destroy(RAYO_ACTOR(x), __FILE__, __LINE__)
#define RAYO_SEQ_NEXT(x) rayo_actor_seq_next(RAYO_ACTOR(x))
#define RAYO_SEND(from, to, msg) rayo_actor_send(RAYO_ACTOR(from), RAYO_ACTOR(to), msg, __FILE__, __LINE__)
#define RAYO_SEND_BY_JID(from, jid, msg) rayo_actor_send_by_jid(RAYO_ACTOR(from), jid, msg, __FILE__, __LINE__)
#define RAYO_SEND(to, msg) rayo_actor_send(to, msg, __FILE__, __LINE__)
extern const char *rayo_call_get_dcp_jid(struct rayo_call *call);
#define rayo_mixer_get_name(mixer) RAYO_ID(mixer)
#define rayo_component_init(component, pool, type, id, parent, client_jid) _rayo_component_init(component, pool, type, id, parent, client_jid, __FILE__, __LINE__)
extern struct rayo_component *_rayo_component_init(struct rayo_component *component, switch_memory_pool_t *pool, const char *type, const char *id, struct rayo_actor *parent, const char *client_jid, const char *file, int line);
#define rayo_component_init(component, pool, type, subtype, id, parent, client_jid) _rayo_component_init(component, pool, type, subtype, id, parent, client_jid, __FILE__, __LINE__)
extern struct rayo_component *_rayo_component_init(struct rayo_component *component, switch_memory_pool_t *pool, const char *type, const char *subtype, const char *id, struct rayo_actor *parent, const char *client_jid, const char *file, int line);
typedef iks *(*rayo_actor_xmpp_handler)(struct rayo_actor *, struct rayo_actor *, iks *, void *);
extern void rayo_actor_command_handler_add(enum rayo_actor_type type, const char *subtype, const char *name, rayo_actor_xmpp_handler fn);
extern void rayo_actor_event_handler_add(enum rayo_actor_type from_type, const char *from_subtype, enum rayo_actor_type to_type, const char *to_subtype, const char *name, rayo_actor_xmpp_handler fn);
typedef iks *(*rayo_actor_xmpp_handler)(struct rayo_actor *, struct rayo_message *, void *);
extern void rayo_actor_command_handler_add(const char *type, const char *subtype, const char *name, rayo_actor_xmpp_handler fn);
extern void rayo_actor_event_handler_add(const char *from_type, const char *from_subtype, const char *to_type, const char *to_subtype, const char *name, rayo_actor_xmpp_handler fn);
#endif
......
src/mod/event_handlers/mod_rayo/rayo_components.c
浏览文件 @ 0f0f2781
......@@ -40,7 +40,7 @@
struct rayo_component *rayo_component_locate(const char *id, const char *file, int line)
{
struct rayo_actor *actor = rayo_actor_locate_by_id(id, file, line);
if (actor && (actor->type == RAT_MIXER_COMPONENT || actor->type == RAT_CALL_COMPONENT)) {
if (actor && !strncmp(RAT_COMPONENT, actor->type, strlen(RAT_COMPONENT))) {
return RAYO_COMPONENT(actor);
} else if (actor) {
RAYO_UNLOCK(actor);
......@@ -63,7 +63,7 @@ void rayo_component_send_start(struct rayo_component *component, iks *iq)
#else
iks_insert_attrib_printf(ref, "uri", "xmpp:%s", RAYO_JID(component));
#endif
RAYO_SEND_BY_JID(component, iks_find_attrib(response, "to"), rayo_message_create(response));
RAYO_SEND(iks_find_attrib(response, "to"), RAYO_REPLY_CREATE(component, response));
}
/**
......@@ -116,7 +116,7 @@ iks *rayo_component_create_complete_event(struct rayo_component *component, cons
*/
void rayo_component_send_complete_event(struct rayo_component *component, iks *response)
{
RAYO_SEND_BY_JID(component, iks_find_attrib(response, "to"), rayo_message_create(response));
RAYO_SEND(iks_find_attrib(response, "to"), RAYO_REPLY_CREATE(component, response));
RAYO_UNLOCK(component);
RAYO_DESTROY(component);
}
......
src/mod/event_handlers/mod_rayo/rayo_input_component.c
浏览文件 @ 0f0f2781
......@@ -187,7 +187,7 @@ static void send_barge_event(struct rayo_component *component)
iks_insert_attrib(event, "to", component->client_jid);
x = iks_insert(event, "start-of-input");
iks_insert_attrib(x, "xmlns", RAYO_INPUT_NS);
RAYO_SEND_BY_JID(component, component->client_jid, rayo_message_create(event));
RAYO_SEND(component->client_jid, RAYO_REPLY_CREATE(component, event));
}
/**
......@@ -466,8 +466,9 @@ static iks *start_call_input(struct input_component *component, switch_core_sess
/**
* Start execution of input component
*/
static iks *start_call_input_component(struct rayo_actor *client, struct rayo_actor *call, iks *iq, void *session_data)
static iks *start_call_input_component(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *iq = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
char *component_id = switch_mprintf("%s-input", switch_core_session_get_uuid(session));
switch_memory_pool_t *pool = NULL;
......@@ -482,7 +483,7 @@ static iks *start_call_input_component(struct rayo_actor *client, struct rayo_ac
/* create component */
switch_core_new_memory_pool(&pool);
input_component = switch_core_alloc(pool, sizeof(*input_component));
rayo_component_init(RAYO_COMPONENT(input_component), pool, "input", component_id, call, iks_find_attrib(iq, "from"));
rayo_component_init(RAYO_COMPONENT(input_component), pool, RAT_CALL_COMPONENT, "input", component_id, call, iks_find_attrib(iq, "from"));
switch_safe_free(component_id);
/* start input */
......@@ -492,8 +493,9 @@ static iks *start_call_input_component(struct rayo_actor *client, struct rayo_ac
/**
* Stop execution of input component
*/
static iks *stop_call_input_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *stop_call_input_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
struct input_component *input_component = INPUT_COMPONENT(component);
if (input_component && !input_component->stop) {
......@@ -518,8 +520,9 @@ static iks *stop_call_input_component(struct rayo_actor *client, struct rayo_act
/**
* Start input component timers
*/
static iks *start_timers_call_input_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *start_timers_call_input_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
struct input_component *input_component = INPUT_COMPONENT(component);
if (input_component) {
switch_core_session_t *session = switch_core_session_locate(RAYO_COMPONENT(component)->parent->id);
......
src/mod/event_handlers/mod_rayo/rayo_output_component.c
浏览文件 @ 0f0f2781
......@@ -57,14 +57,14 @@ struct output_component {
/**
* Create new output component
*/
static struct rayo_component *create_output_component(struct rayo_actor *actor, iks *output, const char *client_jid)
static struct rayo_component *create_output_component(struct rayo_actor *actor, const char *type, iks *output, const char *client_jid)
{
switch_memory_pool_t *pool;
struct output_component *output_component = NULL;
switch_core_new_memory_pool(&pool);
output_component = switch_core_alloc(pool, sizeof(*output_component));
rayo_component_init((struct rayo_component *)output_component, pool, "output", NULL, actor, client_jid);
rayo_component_init((struct rayo_component *)output_component, pool, type, "output", NULL, actor, client_jid);
output_component->document = iks_copy(output);
output_component->repeat_interval = iks_find_int_attrib(output, "repeat-interval");
......@@ -120,8 +120,9 @@ static iks *start_call_output(struct rayo_component *component, switch_core_sess
/**
* Start execution of call output component
*/
static iks *start_call_output_component(struct rayo_actor *client, struct rayo_actor *call, iks *iq, void *session_data)
static iks *start_call_output_component(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *iq = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
struct rayo_component *output_component = NULL;
iks *output = iks_find(iq, "output");
......@@ -131,15 +132,16 @@ static iks *start_call_output_component(struct rayo_actor *client, struct rayo_a
return iks_new_error(iq, STANZA_ERROR_BAD_REQUEST);
}
output_component = create_output_component(call, output, iks_find_attrib(iq, "from"));
output_component = create_output_component(call, RAT_CALL_COMPONENT, output, iks_find_attrib(iq, "from"));
return start_call_output(output_component, session, output, iq);
}
/**
* Start execution of mixer output component
*/
static iks *start_mixer_output_component(struct rayo_actor *client, struct rayo_actor *mixer, iks *iq, void *data)
static iks *start_mixer_output_component(struct rayo_actor *mixer, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
struct rayo_component *component = NULL;
iks *output = iks_find(iq, "output");
switch_stream_handle_t stream = { 0 };
......@@ -149,7 +151,7 @@ static iks *start_mixer_output_component(struct rayo_actor *client, struct rayo_
return iks_new_error(iq, STANZA_ERROR_BAD_REQUEST);
}
component = create_output_component(mixer, output, iks_find_attrib(iq, "from"));
component = create_output_component(mixer, RAT_MIXER_COMPONENT, output, iks_find_attrib(iq, "from"));
/* build conference command */
SWITCH_STANDARD_STREAM(stream);
......@@ -174,8 +176,9 @@ static iks *start_mixer_output_component(struct rayo_actor *client, struct rayo_
/**
* Stop execution of output component
*/
static iks *stop_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *stop_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s stop", RAYO_JID(component));
SWITCH_STANDARD_STREAM(stream);
......@@ -190,8 +193,9 @@ static iks *stop_output_component(struct rayo_actor *client, struct rayo_actor *
/**
* Pause execution of output component
*/
static iks *pause_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *pause_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s pause", RAYO_JID(component));
SWITCH_STANDARD_STREAM(stream);
......@@ -205,8 +209,9 @@ static iks *pause_output_component(struct rayo_actor *client, struct rayo_actor
/**
* Resume execution of output component
*/
static iks *resume_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *resume_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s resume", RAYO_JID(component));
SWITCH_STANDARD_STREAM(stream);
......@@ -220,8 +225,9 @@ static iks *resume_output_component(struct rayo_actor *client, struct rayo_actor
/**
* Speed up execution of output component
*/
static iks *speed_up_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *speed_up_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s speed:+", RAYO_JID(component));
SWITCH_STANDARD_STREAM(stream);
......@@ -235,8 +241,9 @@ static iks *speed_up_output_component(struct rayo_actor *client, struct rayo_act
/**
* Slow down execution of output component
*/
static iks *speed_down_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *speed_down_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s speed:-", RAYO_JID(component));
SWITCH_STANDARD_STREAM(stream);
......@@ -250,8 +257,9 @@ static iks *speed_down_output_component(struct rayo_actor *client, struct rayo_a
/**
* Increase volume of output component
*/
static iks *volume_up_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *volume_up_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s volume:+", RAYO_JID(component));
SWITCH_STANDARD_STREAM(stream);
......@@ -265,8 +273,9 @@ static iks *volume_up_output_component(struct rayo_actor *client, struct rayo_ac
/**
* Lower volume of output component
*/
static iks *volume_down_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *volume_down_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s volume:-", RAYO_JID(component));
SWITCH_STANDARD_STREAM(stream);
......@@ -280,8 +289,9 @@ static iks *volume_down_output_component(struct rayo_actor *client, struct rayo_
/**
* Seek output component
*/
static iks *seek_output_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *seek_output_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
iks *seek = iks_find(iq, "seek");
if (VALIDATE_RAYO_OUTPUT_SEEK(seek)) {
......
src/mod/event_handlers/mod_rayo/rayo_prompt_component.c
浏览文件 @ 0f0f2781
......@@ -62,8 +62,8 @@ struct prompt_component {
enum prompt_component_state state;
iks *iq;
iks *complete;
struct rayo_actor *input;
struct rayo_actor *output;
const char *input_jid;
const char *output_jid;
};
#define PROMPT_COMPONENT(x) ((struct prompt_component *)x)
......@@ -89,17 +89,17 @@ static const char *prompt_component_state_to_string(enum prompt_component_state
/**
* Send stop to component
*/
static void rayo_component_send_stop(struct rayo_actor *from, struct rayo_actor *to)
static void rayo_component_send_stop(struct rayo_actor *from, const char *to)
{
iks *stop = iks_new("iq");
iks *x;
iks_insert_attrib(stop, "from", RAYO_JID(from));
iks_insert_attrib(stop, "to", RAYO_JID(to));
iks_insert_attrib(stop, "to", to);
iks_insert_attrib(stop, "type", "set");
iks_insert_attrib_printf(stop, "id", "mod_rayo-%d", RAYO_SEQ_NEXT(from));
x = iks_insert(stop, "stop");
iks_insert_attrib(x, "xmlns", RAYO_EXT_NS);
RAYO_SEND(from, to, rayo_message_create(stop));
RAYO_SEND(to, RAYO_MESSAGE_CREATE(from, stop));
}
/**
......@@ -118,7 +118,7 @@ static void start_input(struct prompt_component *prompt, int start_timers, int b
iks_insert_attrib(input, "start-timers", start_timers ? "true" : "false");
iks_insert_attrib(input, "barge-event", barge_event ? "true" : "false");
iks_insert_node(iq, input);
RAYO_SEND(prompt, RAYO_COMPONENT(prompt)->parent, rayo_message_create(iq));
RAYO_SEND(RAYO_JID(RAYO_COMPONENT(prompt)->parent), RAYO_MESSAGE_CREATE(prompt, iq));
}
/**
......@@ -129,33 +129,31 @@ static void start_input_timers(struct prompt_component *prompt)
iks *x;
iks *iq = iks_new("iq");
iks_insert_attrib(iq, "from", RAYO_JID(prompt));
iks_insert_attrib(iq, "to", RAYO_JID(prompt->input));
iks_insert_attrib(iq, "to", prompt->input_jid);
iks_insert_attrib(iq, "type", "set");
iks_insert_attrib_printf(iq, "id", "mod_rayo-%d", RAYO_SEQ_NEXT(prompt));
x = iks_insert(iq, "start-timers");
iks_insert_attrib(x, "xmlns", RAYO_INPUT_NS);
RAYO_SEND(prompt, prompt->input, rayo_message_create(iq));
RAYO_SEND(prompt->input_jid, RAYO_MESSAGE_CREATE(prompt, iq));
}
/**
* Handle start of output.
*/
static iks *prompt_component_handle_output_start(struct rayo_actor *output, struct rayo_actor *prompt, iks *iq, void *data)
static iks *prompt_component_handle_output_start(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) output start\n",
RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state));
switch (PROMPT_COMPONENT(prompt)->state) {
case PCS_START_OUTPUT:
PROMPT_COMPONENT(prompt)->output = output;
RAYO_RDLOCK(output);
PROMPT_COMPONENT(prompt)->output_jid = switch_core_strdup(RAYO_POOL(prompt), msg->from_jid);
PROMPT_COMPONENT(prompt)->state = PCS_OUTPUT;
/* send ref to client */
rayo_component_send_start(RAYO_COMPONENT(prompt), PROMPT_COMPONENT(prompt)->iq);
break;
case PCS_START_OUTPUT_BARGE:
PROMPT_COMPONENT(prompt)->output = output;
RAYO_RDLOCK(output);
PROMPT_COMPONENT(prompt)->output_jid = switch_core_strdup(RAYO_POOL(prompt), msg->from_jid);
PROMPT_COMPONENT(prompt)->state = PCS_START_INPUT_OUTPUT;
/* start input without timers and with barge events */
start_input(PROMPT_COMPONENT(prompt), 0, 1);
......@@ -179,28 +177,25 @@ static iks *prompt_component_handle_output_start(struct rayo_actor *output, stru
/**
* Handle start of input.
*/
static iks *prompt_component_handle_input_start(struct rayo_actor *input, struct rayo_actor *prompt, iks *iq, void *data)
static iks *prompt_component_handle_input_start(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) input start\n",
RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state));
switch (PROMPT_COMPONENT(prompt)->state) {
case PCS_START_INPUT:
PROMPT_COMPONENT(prompt)->input = input;
RAYO_RDLOCK(input);
PROMPT_COMPONENT(prompt)->input_jid = switch_core_strdup(RAYO_POOL(prompt), msg->from_jid);
PROMPT_COMPONENT(prompt)->state = PCS_INPUT;
break;
case PCS_START_INPUT_OUTPUT:
PROMPT_COMPONENT(prompt)->input = input;
RAYO_RDLOCK(input);
PROMPT_COMPONENT(prompt)->input_jid = switch_core_strdup(RAYO_POOL(prompt), msg->from_jid);
PROMPT_COMPONENT(prompt)->state = PCS_INPUT_OUTPUT;
/* send ref to client */
rayo_component_send_start(RAYO_COMPONENT(prompt), PROMPT_COMPONENT(prompt)->iq);
iks_delete(PROMPT_COMPONENT(prompt)->iq);
break;
case PCS_START_INPUT_TIMERS:
PROMPT_COMPONENT(prompt)->input = input;
RAYO_RDLOCK(input);
PROMPT_COMPONENT(prompt)->input_jid = switch_core_strdup(RAYO_POOL(prompt), msg->from_jid);
PROMPT_COMPONENT(prompt)->state = PCS_INPUT;
/* send ref to client */
rayo_component_send_start(RAYO_COMPONENT(prompt), PROMPT_COMPONENT(prompt)->iq);
......@@ -209,9 +204,8 @@ static iks *prompt_component_handle_input_start(struct rayo_actor *input, struct
break;
case PCS_DONE:
/* stopped by client */
PROMPT_COMPONENT(prompt)->input = input;
RAYO_RDLOCK(input);
rayo_component_send_stop(prompt, input);
PROMPT_COMPONENT(prompt)->input_jid = switch_core_strdup(RAYO_POOL(prompt), msg->from_jid);
rayo_component_send_stop(prompt, msg->from_jid);
break;
case PCS_START_OUTPUT:
case PCS_START_OUTPUT_BARGE:
......@@ -229,14 +223,15 @@ static iks *prompt_component_handle_input_start(struct rayo_actor *input, struct
/**
* Handle start of input/output.
*/
static iks *prompt_component_handle_io_start(struct rayo_actor *component, struct rayo_actor *prompt, iks *iq, void *data)
static iks *prompt_component_handle_io_start(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, got <ref> from %s: %s\n",
RAYO_JID(prompt), RAYO_JID(component), iks_string(iks_stack(iq), iq));
if (!strcmp("input", component->subtype)) {
return prompt_component_handle_input_start(component, prompt, iq, data);
} else if (!strcmp("output", component->subtype)) {
return prompt_component_handle_output_start(component, prompt, iq, data);
RAYO_JID(prompt), msg->from_jid, iks_string(iks_stack(iq), iq));
if (!strcmp("input", msg->from_subtype)) {
return prompt_component_handle_input_start(prompt, msg, data);
} else if (!strcmp("output", msg->from_subtype)) {
return prompt_component_handle_output_start(prompt, msg, data);
}
return NULL;
}
......@@ -244,7 +239,7 @@ static iks *prompt_component_handle_io_start(struct rayo_actor *component, struc
/**
* Handle barge event
*/
static iks *prompt_component_handle_input_start_timers_error(struct rayo_actor *input, struct rayo_actor *prompt, iks *iq, void *data)
static iks *prompt_component_handle_input_start_timers_error(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
/* this is only expected if input component is gone */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) start timers error\n",
......@@ -256,8 +251,9 @@ static iks *prompt_component_handle_input_start_timers_error(struct rayo_actor *
/**
* Handle input failure.
*/
static iks *prompt_component_handle_input_error(struct rayo_actor *input, struct rayo_actor *prompt, iks *iq, void *data)
static iks *prompt_component_handle_input_error(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
iks *error = iks_find(iq, "error");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) input error\n",
......@@ -282,7 +278,7 @@ static iks *prompt_component_handle_input_error(struct rayo_actor *input, struct
iks_insert_node(iq, iks_copy_within(error, iks_stack(iq)));
PROMPT_COMPONENT(prompt)->complete = iq;
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output);
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output_jid);
break;
case PCS_START_OUTPUT:
case PCS_START_OUTPUT_BARGE:
......@@ -302,8 +298,9 @@ static iks *prompt_component_handle_input_error(struct rayo_actor *input, struct
/**
* Handle output failure.
*/
static iks *prompt_component_handle_output_error(struct rayo_actor *output, struct rayo_actor *prompt, iks *iq, void *data)
static iks *prompt_component_handle_output_error(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
iks *error = iks_find(iq, "error");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) output error\n",
......@@ -320,7 +317,7 @@ static iks *prompt_component_handle_output_error(struct rayo_actor *output, stru
iks_insert_attrib(iq, "from", RAYO_JID(RAYO_COMPONENT(prompt)->parent));
iks_insert_attrib(iq, "to", RAYO_COMPONENT(prompt)->client_jid);
iks_insert_node(iq, iks_copy_within(error, iks_stack(iq)));
RAYO_SEND_BY_JID(prompt, RAYO_COMPONENT(prompt)->client_jid, rayo_message_create(iq));
RAYO_SEND(RAYO_COMPONENT(prompt)->client_jid, RAYO_REPLY_CREATE(prompt, iq));
/* done */
RAYO_UNLOCK(prompt);
......@@ -346,17 +343,18 @@ static iks *prompt_component_handle_output_error(struct rayo_actor *output, stru
/**
* Handle barge event
*/
static iks *prompt_component_handle_input_barge(struct rayo_actor *input, struct rayo_actor *prompt, iks *presence, void *data)
static iks *prompt_component_handle_input_barge(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
iks *presence = msg->payload;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) input barge\n",
RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state));
switch (PROMPT_COMPONENT(prompt)->state) {
case PCS_INPUT_OUTPUT:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, got <start-of-input> from %s: %s\n",
RAYO_JID(prompt), RAYO_JID(input), iks_string(iks_stack(presence), presence));
RAYO_JID(prompt), msg->from_jid, iks_string(iks_stack(presence), presence));
PROMPT_COMPONENT(prompt)->state = PCS_STOP_OUTPUT;
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output);
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output_jid);
break;
case PCS_STOP_OUTPUT:
case PCS_INPUT:
......@@ -379,8 +377,9 @@ static iks *prompt_component_handle_input_barge(struct rayo_actor *input, struct
/**
* Handle completion event
*/
static iks *prompt_component_handle_input_complete(struct rayo_actor *input, struct rayo_actor *prompt, iks *presence, void *data)
static iks *prompt_component_handle_input_complete(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
iks *presence = msg->payload;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) input complete\n",
RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state));
......@@ -391,8 +390,7 @@ static iks *prompt_component_handle_input_complete(struct rayo_actor *input, str
iks_insert_attrib(presence, "from", RAYO_JID(prompt));
iks_insert_attrib(presence, "to", RAYO_COMPONENT(prompt)->client_jid);
PROMPT_COMPONENT(prompt)->complete = presence;
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output);
RAYO_UNLOCK(input);
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output_jid);
break;
case PCS_STOP_OUTPUT:
PROMPT_COMPONENT(prompt)->state = PCS_DONE_STOP_OUTPUT;
......@@ -400,7 +398,6 @@ static iks *prompt_component_handle_input_complete(struct rayo_actor *input, str
iks_insert_attrib(presence, "from", RAYO_JID(prompt));
iks_insert_attrib(presence, "to", RAYO_COMPONENT(prompt)->client_jid);
PROMPT_COMPONENT(prompt)->complete = presence;
RAYO_UNLOCK(input);
break;
case PCS_INPUT:
PROMPT_COMPONENT(prompt)->state = PCS_DONE;
......@@ -410,7 +407,6 @@ static iks *prompt_component_handle_input_complete(struct rayo_actor *input, str
iks_insert_attrib(presence, "from", RAYO_JID(prompt));
iks_insert_attrib(presence, "to", RAYO_COMPONENT(prompt)->client_jid);
rayo_component_send_complete_event(RAYO_COMPONENT(prompt), presence);
RAYO_UNLOCK(input);
break;
case PCS_OUTPUT:
case PCS_START_OUTPUT:
......@@ -429,7 +425,7 @@ static iks *prompt_component_handle_input_complete(struct rayo_actor *input, str
/**
* Handle completion event
*/
static iks *prompt_component_handle_output_complete(struct rayo_actor *output, struct rayo_actor *prompt, iks *presence, void *data)
static iks *prompt_component_handle_output_complete(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) output complete\n",
RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state));
......@@ -437,30 +433,25 @@ static iks *prompt_component_handle_output_complete(struct rayo_actor *output, s
switch (PROMPT_COMPONENT(prompt)->state) {
case PCS_OUTPUT:
PROMPT_COMPONENT(prompt)->state = PCS_START_INPUT;
RAYO_UNLOCK(output);
/* start input with timers enabled and barge events disabled */
start_input(PROMPT_COMPONENT(prompt), 1, 0);
iks_delete(PROMPT_COMPONENT(prompt)->iq);
break;
case PCS_START_INPUT_OUTPUT:
PROMPT_COMPONENT(prompt)->state = PCS_INPUT;
RAYO_UNLOCK(output);
break;
case PCS_INPUT_OUTPUT:
PROMPT_COMPONENT(prompt)->state = PCS_INPUT;
RAYO_UNLOCK(output);
start_input_timers(PROMPT_COMPONENT(prompt));
break;
case PCS_STOP_OUTPUT:
PROMPT_COMPONENT(prompt)->state = PCS_INPUT;
RAYO_UNLOCK(output);
start_input_timers(PROMPT_COMPONENT(prompt));
break;
case PCS_DONE_STOP_OUTPUT:
if (PROMPT_COMPONENT(prompt)->complete) {
rayo_component_send_complete_event(RAYO_COMPONENT(prompt), PROMPT_COMPONENT(prompt)->complete);
}
RAYO_UNLOCK(output);
break;
case PCS_INPUT:
case PCS_START_OUTPUT:
......@@ -478,8 +469,9 @@ static iks *prompt_component_handle_output_complete(struct rayo_actor *output, s
/**
* Start execution of prompt component
*/
static iks *start_call_prompt_component(struct rayo_actor *client, struct rayo_actor *call, iks *iq, void *session_data)
static iks *start_call_prompt_component(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *iq = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
switch_memory_pool_t *pool;
struct prompt_component *prompt_component = NULL;
......@@ -508,7 +500,7 @@ static iks *start_call_prompt_component(struct rayo_actor *client, struct rayo_a
/* create prompt component, linked to call */
switch_core_new_memory_pool(&pool);
prompt_component = switch_core_alloc(pool, sizeof(*prompt_component));
rayo_component_init(RAYO_COMPONENT(prompt_component), pool, "prompt", NULL, call, iks_find_attrib(iq, "from"));
rayo_component_init(RAYO_COMPONENT(prompt_component), pool, RAT_CALL_COMPONENT, "prompt", NULL, call, iks_find_attrib(iq, "from"));
prompt_component->iq = iks_copy(iq);
/* start output */
......@@ -524,7 +516,7 @@ static iks *start_call_prompt_component(struct rayo_actor *client, struct rayo_a
iks_insert_attrib(cmd, "type", "set");
output = iks_copy_within(output, iks_stack(cmd));
iks_insert_node(cmd, output);
RAYO_SEND(prompt_component, call, rayo_message_create(cmd));
RAYO_SEND(RAYO_JID(call), RAYO_MESSAGE_CREATE(prompt_component, cmd));
return NULL;
}
......@@ -532,8 +524,9 @@ static iks *start_call_prompt_component(struct rayo_actor *client, struct rayo_a
/**
* Stop execution of prompt component
*/
static iks *stop_call_prompt_component(struct rayo_actor *client, struct rayo_actor *prompt, iks *iq, void *data)
static iks *stop_call_prompt_component(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
iks *reply = NULL;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) stop prompt\n",
RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state));
......@@ -543,13 +536,13 @@ static iks *stop_call_prompt_component(struct rayo_actor *client, struct rayo_ac
/* input hasn't started yet */
PROMPT_COMPONENT(prompt)->state = PCS_DONE_STOP_OUTPUT;
PROMPT_COMPONENT(prompt)->complete = rayo_component_create_complete_event(RAYO_COMPONENT(prompt), COMPONENT_COMPLETE_STOP);
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output);
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output_jid);
break;
case PCS_INPUT_OUTPUT:
case PCS_INPUT:
case PCS_STOP_OUTPUT:
/* stopping input will trigger completion */
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->input);
rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->input_jid);
break;
case PCS_START_INPUT:
/* stop input as soon as it starts */
......@@ -577,8 +570,9 @@ static iks *stop_call_prompt_component(struct rayo_actor *client, struct rayo_ac
/**
* Pass output component command
*/
static iks *forward_output_component_request(struct rayo_actor *client, struct rayo_actor *prompt, iks *iq, void *data)
static iks *forward_output_component_request(struct rayo_actor *prompt, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s (%s) %s prompt\n",
RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state), iks_name(iks_first_tag(iq)));
......@@ -588,8 +582,8 @@ static iks *forward_output_component_request(struct rayo_actor *client, struct r
case PCS_INPUT_OUTPUT: {
/* forward request to output component */
iks_insert_attrib(iq, "from", RAYO_JID(prompt));
iks_insert_attrib(iq, "to", RAYO_JID(PROMPT_COMPONENT(prompt)->output));
RAYO_SEND(prompt, PROMPT_COMPONENT(prompt)->output, rayo_message_create_dup(iq));
iks_insert_attrib(iq, "to", RAYO_JID(PROMPT_COMPONENT(prompt)->output_jid));
RAYO_SEND(PROMPT_COMPONENT(prompt)->output_jid, RAYO_MESSAGE_CREATE_DUP(prompt, iq));
return NULL;
}
case PCS_START_INPUT_TIMERS:
......
src/mod/event_handlers/mod_rayo/rayo_record_component.c
浏览文件 @ 0f0f2781
......@@ -144,7 +144,7 @@ static void on_call_record_stop_event(switch_event_t *event)
/**
* Create a record component
*/
static struct rayo_component *record_component_create(struct rayo_actor *actor, const char *client_jid, iks *record)
static struct rayo_component *record_component_create(struct rayo_actor *actor, const char *type, const char *client_jid, iks *record)
{
switch_memory_pool_t *pool;
struct record_component *record_component = NULL;
......@@ -171,7 +171,7 @@ static struct rayo_component *record_component_create(struct rayo_actor *actor,
switch_core_new_memory_pool(&pool);
record_component = switch_core_alloc(pool, sizeof(*record_component));
rayo_component_init(RAYO_COMPONENT(record_component), pool, "record", fs_file_path, actor, client_jid);
rayo_component_init(RAYO_COMPONENT(record_component), pool, type, "record", fs_file_path, actor, client_jid);
record_component->max_duration = iks_find_int_attrib(record, "max-duration");
record_component->initial_timeout = iks_find_int_attrib(record, "initial-timeout");
record_component->final_timeout = iks_find_int_attrib(record, "final-timeout");
......@@ -259,13 +259,14 @@ static int start_call_record(switch_core_session_t *session, struct rayo_compone
/**
* Start execution of call record component
*/
static iks *start_call_record_component(struct rayo_actor *client, struct rayo_actor *call, iks *iq, void *session_data)
static iks *start_call_record_component(struct rayo_actor *call, struct rayo_message *msg, void *session_data)
{
iks *iq = msg->payload;
switch_core_session_t *session = (switch_core_session_t *)session_data;
struct rayo_component *component = NULL;
iks *record = iks_find(iq, "record");
component = record_component_create(call, iks_find_attrib(iq, "from"), record);
component = record_component_create(call, RAT_CALL_COMPONENT, iks_find_attrib(iq, "from"), record);
if (!component) {
return iks_new_error(iq, STANZA_ERROR_BAD_REQUEST);
}
......@@ -284,8 +285,9 @@ static iks *start_call_record_component(struct rayo_actor *client, struct rayo_a
/**
* Stop execution of record component
*/
static iks *stop_call_record_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *stop_call_record_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
switch_core_session_t *session = switch_core_session_locate(RAYO_COMPONENT(component)->parent->id);
if (session) {
RECORD_COMPONENT(component)->stop = 1;
......@@ -298,8 +300,9 @@ static iks *stop_call_record_component(struct rayo_actor *client, struct rayo_ac
/**
* Pause execution of record component
*/
static iks *pause_record_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *pause_record_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
struct record_component *record = RECORD_COMPONENT(component);
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s pause", record->local_file_path);
......@@ -319,8 +322,9 @@ static iks *pause_record_component(struct rayo_actor *client, struct rayo_actor
/**
* Resume execution of record component
*/
static iks *resume_record_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *resume_record_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
struct record_component *record = RECORD_COMPONENT(component);
switch_stream_handle_t stream = { 0 };
char *command = switch_mprintf("%s resume", record->local_file_path);
......@@ -381,12 +385,13 @@ static int start_mixer_record(struct rayo_component *component)
/**
* Start execution of mixer record component
*/
static iks *start_mixer_record_component(struct rayo_actor *client, struct rayo_actor *mixer, iks *iq, void *data)
static iks *start_mixer_record_component(struct rayo_actor *mixer, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
struct rayo_component *component = NULL;
iks *record = iks_find(iq, "record");
component = record_component_create(mixer, iks_find_attrib(iq, "from"), record);
component = record_component_create(mixer, RAT_MIXER_COMPONENT, iks_find_attrib(iq, "from"), record);
if (!component) {
return iks_new_error(iq, STANZA_ERROR_BAD_REQUEST);
}
......@@ -412,8 +417,9 @@ static iks *start_mixer_record_component(struct rayo_actor *client, struct rayo_
/**
* Stop execution of record component
*/
static iks *stop_mixer_record_component(struct rayo_actor *client, struct rayo_actor *component, iks *iq, void *data)
static iks *stop_mixer_record_component(struct rayo_actor *component, struct rayo_message *msg, void *data)
{
iks *iq = msg->payload;
char *args;
switch_stream_handle_t stream = { 0 };
SWITCH_STANDARD_STREAM(stream);
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论