/** * Handle input failure. */ 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", RAYO_JID(prompt), prompt_component_state_to_string(PROMPT_COMPONENT(prompt)->state)); switch (PROMPT_COMPONENT(prompt)->state) { case PCS_START_INPUT_TIMERS: switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, <input> error: %s\n", RAYO_JID(prompt), iks_string(iks_stack(iq), iq)); PROMPT_COMPONENT(prompt)->state = PCS_DONE; /* forward IQ error to client */ iq = PROMPT_COMPONENT(prompt)->iq; 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_REPLY(prompt, RAYO_COMPONENT(prompt)->client_jid, iq); /* done */ RAYO_UNLOCK(prompt); RAYO_DESTROY(prompt); break; case PCS_START_INPUT: /* send presence error to client */ PROMPT_COMPONENT(prompt)->state = PCS_DONE; iks_delete(PROMPT_COMPONENT(prompt)->iq); rayo_component_send_complete(RAYO_COMPONENT(prompt), COMPONENT_COMPLETE_ERROR); break; case PCS_START_INPUT_OUTPUT: PROMPT_COMPONENT(prompt)->state = PCS_DONE_STOP_OUTPUT; /* forward IQ error to client */ iq = PROMPT_COMPONENT(prompt)->iq; 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))); PROMPT_COMPONENT(prompt)->complete = iq; rayo_component_send_stop(prompt, PROMPT_COMPONENT(prompt)->output_jid); break; case PCS_START_OUTPUT: case PCS_START_OUTPUT_BARGE: case PCS_INPUT_OUTPUT: case PCS_STOP_OUTPUT: case PCS_INPUT: case PCS_OUTPUT: case PCS_DONE_STOP_OUTPUT: case PCS_DONE: switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, unexpected start input error event\n", RAYO_JID(prompt)); break; } return NULL; }
/** * Handle barge event */ 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), 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_jid); break; case PCS_STOP_OUTPUT: case PCS_INPUT: /* don't care */ break; case PCS_OUTPUT: case PCS_START_OUTPUT: case PCS_START_OUTPUT_BARGE: case PCS_START_INPUT: case PCS_START_INPUT_OUTPUT: case PCS_START_INPUT_TIMERS: case PCS_DONE_STOP_OUTPUT: case PCS_DONE: switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, unexpected start output error event\n", RAYO_JID(prompt)); break; } return NULL; }
int axis2_xmpp_client_on_presence( void *user_data, ikspak *pak) { axis2_xmpp_session_data_t *session = NULL; axutil_env_t *env = NULL; char* presence_str = NULL; axis2_status_t status = AXIS2_SUCCESS; char request_uri[500] = ""; session = (axis2_xmpp_session_data_t*) user_data; env = session->env; presence_str = iks_string(iks_stack(pak->x), pak->x); if(!presence_str) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to serialize the " "presence envelope"); return IKS_FILTER_EAT; } snprintf(request_uri, 500, "xmpp://localhost/axis2/services/%s", axis2_svc_get_name( session->svc, env)); status = axis2_xmpp_transport_utils_process_presence_client(session->env, session, presence_str, request_uri); return IKS_FILTER_EAT; /* no need to pass to other filters */ }
void serialize_test (char *buf, int len) { unsigned long time; iks *x; iksparser *prs; char *xml; int err; prs = iks_dom_new (&x); err = iks_parse (prs, buf, len, 1); switch (err) { case IKS_OK: break; case IKS_NOMEM: exit (2); case IKS_BADXML: fprintf (stderr, "Invalid xml at byte %ld, line %ld\n", iks_nr_bytes (prs), iks_nr_lines (prs)); exit (1); case IKS_HOOK: exit (1); } iks_parser_delete (prs); t_reset (); xml = iks_string (iks_stack (x), x); time = t_elapsed (); printf ("Serialize: serializing the tree took %ld milliseconds.\n", time); iks_delete (x); }
static int auth_failed_cb (ta_xmpp_client_t *client, void *data, void *TA_UNUSED(hdata)) { ikspak *pak = (ikspak *) data; char *node_str = iks_string (iks_stack (pak->x), pak->x); printf ("not connected: =(\n"); printf ("%s\n", node_str); ta_xmpp_client_disconnect (client); return 0; }
int axis2_xmpp_client_on_message( void *user_data, ikspak *pak) { axis2_xmpp_session_data_t *session = NULL; axutil_env_t *env = NULL; iks* body_elem = NULL; iks* soap_elem = NULL; char *soap_str = NULL; char *from = NULL; char request_uri[500] = ""; axis2_status_t status = AXIS2_SUCCESS; session = (axis2_xmpp_session_data_t*) user_data; env = session->env; /* Serialize the message and pass it up */ /* extract the body of message */ body_elem = iks_find(pak->x, "body"); if(!body_elem) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to extract body of " "message stanza"); return IKS_FILTER_EAT; } soap_elem = iks_child(body_elem); if(!soap_elem) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to extract soap envelope" "from message stanza"); return IKS_FILTER_EAT; } soap_str = iks_string(iks_stack(soap_elem), soap_elem); if(!soap_str) { AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "[xmpp]Failed to serialize the soap " "envelope"); return IKS_FILTER_EAT; } snprintf(request_uri, 500, "xmpp://localhost/axis2/services/%s", axis2_svc_get_name( session->svc, env)); from = iks_find_attrib(pak->x, "from"); status = axis2_xmpp_transport_utils_process_message_client(session->env, session, soap_str, from, request_uri); /* TODO: Check whether we need to return IKS_HOOK on failure. I think not, * because, failure here means the failure of a single request. We should * keep running for other requests */ session->in_msg = 1; return IKS_FILTER_EAT; /* no need to pass to other filters */ }
/** * Handle start of input/output. */ 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), 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; }
void string (char *xml) { char *tmp; tmp = iks_string (iks_stack (my_x), my_x); if (iks_strcmp (tmp, xml) != 0) { PR_TEST; printf ("Result: %s\n", tmp); printf ("Expected: %s\n", xml); exit (1); } }
/** * Start execution of prompt component */ 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; iks *prompt = iks_find(iq, "prompt"); iks *input; iks *output; iks *cmd; if (!VALIDATE_RAYO_PROMPT(prompt)) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Bad <prompt> attrib\n"); return iks_new_error_detailed(iq, STANZA_ERROR_BAD_REQUEST, "Bad <prompt> attrib value"); } output = iks_find(prompt, "output"); if (!output) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Missing <output>\n"); return iks_new_error_detailed(iq, STANZA_ERROR_BAD_REQUEST, "Missing <output>"); } input = iks_find(prompt, "input"); if (!input) { switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Missing <input>\n"); return iks_new_error_detailed(iq, STANZA_ERROR_BAD_REQUEST, "Missing <input>"); } /* 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, RAT_CALL_COMPONENT, "prompt", NULL, call, iks_find_attrib(iq, "from")); prompt_component->iq = iks_copy(iq); /* start output */ if (iks_find_bool_attrib(prompt, "barge-in")) { prompt_component->state = PCS_START_OUTPUT_BARGE; } else { prompt_component->state = PCS_START_OUTPUT; } cmd = iks_new("iq"); iks_insert_attrib(cmd, "from", RAYO_JID(prompt_component)); iks_insert_attrib(cmd, "to", RAYO_JID(call)); iks_insert_attrib(cmd, "id", iks_find_attrib(iq, "id")); iks_insert_attrib(cmd, "type", "set"); output = iks_copy_within(output, iks_stack(cmd)); iks_insert_node(cmd, output); RAYO_SEND_MESSAGE(prompt_component, RAYO_JID(call), cmd); return NULL; }
/** * Start input component */ static void start_input(struct prompt_component *prompt, int start_timers, int barge_event) { iks *iq = iks_new("iq"); iks *input = iks_find(PROMPT_COMPONENT(prompt)->iq, "prompt"); input = iks_find(input, "input"); iks_insert_attrib(iq, "from", RAYO_JID(prompt)); iks_insert_attrib(iq, "to", RAYO_JID(RAYO_COMPONENT(prompt)->parent)); iks_insert_attrib_printf(iq, "id", "mod_rayo-prompt-%d", RAYO_SEQ_NEXT(prompt)); iks_insert_attrib(iq, "type", "set"); input = iks_copy_within(input, iks_stack(iq)); 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_MESSAGE(prompt, RAYO_JID(RAYO_COMPONENT(prompt)->parent), iq); }
void dom_test (char *buf, int len) { int bs, i, err; iksparser *prs; unsigned long time; iks *x; size_t allocated, used; bs = block_size; if (0 == bs) bs = len; t_reset (); prs = iks_dom_new (&x); iks_set_size_hint (prs, len); i = 0; while (i < len) { if (i + bs > len) bs = len - i; err = iks_parse (prs, buf + i, bs, 0); switch (err) { case IKS_OK: break; case IKS_NOMEM: exit (2); case IKS_BADXML: fprintf (stderr, "Invalid xml at byte %ld, line %ld\n", iks_nr_bytes (prs), iks_nr_lines (prs)); exit (1); case IKS_HOOK: exit (1); } i += bs; } time = t_elapsed (); iks_stack_stat (iks_stack (x), &allocated, &used); printf ("DOM: parsing and building the tree took %ld milliseconds.\n", time); printf ("DOM: ikstack: %d bytes allocated, %d bytes used.\n", allocated, used); t_reset (); iks_delete (x); time = t_elapsed (); printf ("DOM: deleting the tree took %ld milliseconds.\n", time); iks_parser_delete (prs); }
static int CFStouSvrConnSendStanza(CFStouSvrConn* conn, iks* stz) { const char *stzStr; size_t len; if ((stzStr = iks_string(iks_stack(stz), stz))) { len = strlen(stzStr); if (CFStouSvrConnSend(conn, (const uint8_t*)stzStr, len)) { LCF_ERR_OUT(ERR_OUT, "CFStouSvrConnWrite() failed, maybe blocking\n todo: send iq error back\n"); } } else { LCF_ERR_OUT(ERR_OUT, "iks_string() failed, maybe iks stack memory is so low\n"); } return 0; ERR_OUT: return -1; }
/** * Create component complete event * @param component the component * @param reason_str the completion reason * @param reason_namespace the completion reason namespace * @param meta metadata to add as child * @param child_of_complete if true metadata is child of complete instead of reason * @return the event */ iks *rayo_component_create_complete_event_with_metadata(struct rayo_component *component, const char *reason_str, const char *reason_namespace, iks *meta, int child_of_complete) { iks *response = iks_new("presence"); iks *complete; iks *reason; iks_insert_attrib(response, "from", RAYO_JID(component)); iks_insert_attrib(response, "to", component->client_jid); iks_insert_attrib(response, "type", "unavailable"); complete = iks_insert(response, "complete"); iks_insert_attrib(complete, "xmlns", RAYO_EXT_NS); reason = iks_insert(complete, reason_str); iks_insert_attrib(reason, "xmlns", reason_namespace); if (meta) { meta = iks_copy_within(meta, iks_stack(response)); if (child_of_complete) { iks_insert_node(complete, meta); } else { iks_insert_node(reason, meta); } } return response; }
static int _XcFilterIqCtlHook(void *userData, ikspak *pak) { iks *stz; const char *stzStr; CFStouXmppGwConn* gwConn; CFStouSvrConn* stouConn; size_t len; LCF_DBG_IN_FUNC(); gwConn = userData; stouConn = gwConn->stouConn; stz = pak->x; if ((stzStr = iks_string(iks_stack(stz), stz))) { len = strlen(stzStr); if (CFStouSvrConnSend(stouConn, (const uint8_t*)stzStr, len)) { LCF_ERR("CFStouSvrConnWrite() failed, maybe blocking\n todo: send iq error back\n"); } } else { LCF_ERR("iks_string() failed, maybe iks stack memory is so low\n"); } return IKS_FILTER_EAT; }
int iks_send(iksparser *prs, iks *x) { return iks_send_raw(prs, iks_string(iks_stack(x), x)); }
ikspak * iks_packet (iks *x) { ikspak *pak; ikstack *s; char *tmp; s = iks_stack (x); pak = iks_stack_alloc (s, sizeof (ikspak)); if (!pak) return NULL; memset (pak, 0, sizeof (ikspak)); pak->x = x; tmp = iks_find_attrib (x, "from"); if (tmp) pak->from = iks_id_new (s, tmp); pak->id = iks_find_attrib (x, "id"); tmp = iks_find_attrib (x, "type"); if (strcmp (iks_name (x), "message") == 0) { pak->type = IKS_PAK_MESSAGE; if (tmp) { if (strcmp (tmp, "chat") == 0) pak->subtype = IKS_TYPE_CHAT; else if (strcmp (tmp, "groupchat") == 0) pak->subtype = IKS_TYPE_GROUPCHAT; else if (strcmp (tmp, "headline") == 0) pak->subtype = IKS_TYPE_HEADLINE; else if (strcmp (tmp, "error") == 0) pak->subtype = IKS_TYPE_ERROR; } } else if (strcmp (iks_name (x), "presence") == 0) { pak->type = IKS_PAK_S10N; if (tmp) { if (strcmp (tmp, "unavailable") == 0) { pak->type = IKS_PAK_PRESENCE; pak->subtype = IKS_TYPE_UNAVAILABLE; pak->show = IKS_SHOW_UNAVAILABLE; } else if (strcmp (tmp, "probe") == 0) { pak->type = IKS_PAK_PRESENCE; pak->subtype = IKS_TYPE_PROBE; } else if(strcmp(tmp, "subscribe") == 0) pak->subtype = IKS_TYPE_SUBSCRIBE; else if(strcmp(tmp, "subscribed") == 0) pak->subtype = IKS_TYPE_SUBSCRIBED; else if(strcmp(tmp, "unsubscribe") == 0) pak->subtype = IKS_TYPE_UNSUBSCRIBE; else if(strcmp(tmp, "unsubscribed") == 0) pak->subtype = IKS_TYPE_UNSUBSCRIBED; else if(strcmp(tmp, "error") == 0) pak->subtype = IKS_TYPE_ERROR; } else { pak->type = IKS_PAK_PRESENCE; pak->subtype = IKS_TYPE_AVAILABLE; tmp = iks_find_cdata (x, "show"); pak->show = IKS_SHOW_AVAILABLE; if (tmp) { if (strcmp (tmp, "chat") == 0) pak->show = IKS_SHOW_CHAT; else if (strcmp (tmp, "away") == 0) pak->show = IKS_SHOW_AWAY; else if (strcmp (tmp, "xa") == 0) pak->show = IKS_SHOW_XA; else if (strcmp (tmp, "dnd") == 0) pak->show = IKS_SHOW_DND; } } } else if (strcmp (iks_name (x), "iq") == 0) { iks *q; pak->type = IKS_PAK_IQ; if (tmp) { if (strcmp (tmp, "get") == 0) pak->subtype = IKS_TYPE_GET; else if (strcmp (tmp, "set") == 0) pak->subtype = IKS_TYPE_SET; else if (strcmp (tmp, "result") == 0) pak->subtype = IKS_TYPE_RESULT; else if (strcmp (tmp, "error") == 0) pak->subtype = IKS_TYPE_ERROR; } for (q = iks_child (x); q; q = iks_next (q)) { if (IKS_TAG == iks_type (q)) { char *ns; ns = iks_find_attrib (q, "xmlns"); if (ns) { pak->query = q; pak->ns = ns; break; } } } } return pak; }