static int CFStouXmppGwConnStartAuth(CFStouXmppGwConn *gwConn) { iks *stz; const char *sid; stz = iks_new("STOU_XMPP"); if (!stz) { LCF_ERR_OUT(ERR_OUT, "out of memory !!\n"); } iks_insert_attrib(stz, "from", gwConn->xmppSvrJid->full); iks_insert_attrib(stz, "to", gwConn->xmppClientJid->full); if (!(sid = CFRandomStr("", 0, "", 0, 10))) { LCF_ERR_OUT(ERR_DEL_STZ, "\n"); } gwConn->sid = strdup(sid); LCF_DBG("sid=%s\n", gwConn->sid); iks_insert_attrib(stz, "sid", sid); if (CFStouSvrConnSendStanza(gwConn->stouConn, stz)) { LCF_ERR_OUT(ERR_FREE_SID, "\n"); } iks_delete(stz); return 0; ERR_FREE_SID: free(gwConn->sid); ERR_DEL_STZ: iks_delete(stz); ERR_OUT: return -1; }
static int CFStouXmppGwConnSendAuthResutl(CFStouXmppGwConn* gwConn, BOOL ok) { iks *stz; if (!(stz = iks_new("STOU_XMPP_AUTH"))) { LCF_ERR_OUT(ERR_OUT, "\n"); } if (ok) { iks_insert_attrib(stz, "auth", "proceed"); } else { iks_insert_attrib(stz, "auth", "failed"); } if (CFStouSvrConnSendStanza(gwConn->stouConn, stz)) { LCF_ERR_OUT(ERR_DEL_STZ, "\n"); } iks_delete(stz); return 0; ERR_DEL_STZ: iks_delete(stz); ERR_OUT: return -1; }
static int _StouSvrConnStreamHook(void *userData, int type, iks *node) { CFStouXmppGwConn *sxgc; sxgc = (CFStouXmppGwConn*)userData; LCF_DBG_IN_FUNC(); switch (type) { case IKS_NODE_START: _StouXmppGwConnParseStreamStart(sxgc, node); break; case IKS_NODE_NORMAL: _StouXmppGwConnParseStouSvrConnXml(sxgc, node); break; case IKS_NODE_ERROR: LCF_ERR_OUT(ERR_OUT, "\n"); break; case IKS_NODE_STOP: CFStouXmppGwDestroyConn(sxgc->gw, sxgc); break; } if (node) { iks_delete(node); } return 0; ERR_OUT: if (node) { iks_delete(node); } return -1; }
int iks_start_sasl(iksparser *prs, enum ikssasltype type, char *username, char *pass) { iks *x; x = iks_new("auth"); iks_insert_attrib(x, "xmlns", IKS_NS_XMPP_SASL); switch(type) { case IKS_SASL_PLAIN: { int len = iks_strlen(username) + iks_strlen(pass) + 2; char *s = iks_malloc(80 + len); char *base64; iks_insert_attrib(x, "mechanism", "PLAIN"); sprintf(s, "%c%s%c%s", 0, username, 0, pass); base64 = iks_base64_encode(s, len); iks_insert_cdata(x, base64, 0); iks_free(base64); iks_free(s); break; } case IKS_SASL_DIGEST_MD5: { struct stream_data *data = iks_user_data(prs); iks_insert_attrib(x, "mechanism", "DIGEST-MD5"); data->auth_username = username; data->auth_pass = pass; break; } case IKS_SASL_OAUTH_2: { int len = iks_strlen(username) + iks_strlen(pass) + 2; char *s = iks_malloc(80 + len); char *base64; iks_insert_attrib(x, "mechanism", "X-OAUTH2"); iks_insert_attrib(x, "auth:service", "oauth2"); iks_insert_attrib(x, "xmlns:auth", "http://www.google.com/talk/protocol/auth"); sprintf(s, "%c%s%c%s", 0, username, 0, pass); base64 = iks_base64_encode(s, len); iks_insert_cdata(x, base64, 0); iks_free(base64); iks_free(s); break; } default: iks_delete(x); return IKS_NET_NOTSUPP; } iks_send(prs, x); iks_delete(x); return IKS_OK; }
static void xmpp_process_msg( axis2_xmpp_session_data_t *session, iks *node) { iks *t = NULL; session->features = iks_stream_features(node); /* save features */ if(session->features & IKS_STREAM_BIND) { t = iks_make_resource_bind(session->jid); iks_send(session->parser, t); iks_delete(t); } /* Send a session if required */ if(session->features & IKS_STREAM_SESSION) { t = iks_make_session(); iks_insert_attrib(t, "id", "auth"); iks_send(session->parser, t); iks_delete(t); } /* Subscribe if the service is configured to do so */ if((session->subscribe) && (session->subscribe_to)) { /* Check whether the type of subscription is user or room * and send the subscription request accordingly */ if(!axutil_strcmp(session->subscribe_type, AXIS2_XMPP_SUB_TYPE_USER)) { iks_send(session->parser, iks_make_s10n(IKS_TYPE_SUBSCRIBE, session->subscribe_to, "")); } else if(!axutil_strcmp(session->subscribe_type, AXIS2_XMPP_SUB_TYPE_ROOM)) { axis2_char_t *id = axutil_uuid_gen(session->env); iks *x = iks_make_pres(IKS_SHOW_AVAILABLE, ""); iks_insert_attrib(x, "to", session->subscribe_to); iks_insert_attrib(x, "id", id); iks_send(session->parser, x); AXIS2_FREE(session->env->allocator, id); } else { AXIS2_LOG_ERROR(session->env->log, AXIS2_LOG_SI, "[xmpp]Unknown subscription type. No subscription done"); } } }
// xxx needs error return value static void send_sasl_challenge (ikss_Stream *self, iks *challenge) { char *message; iks *x; char *tmp; tmp = iks_cdata (iks_child (challenge)); if (!tmp) return; /* decode received blob */ message = iks_base64_decode (tmp); if (!message) return; /* reply the challenge */ if (strstr (message, "rspauth")) { x = iks_new ("response"); } else { x = make_sasl_response (self, message); } if (x) { iks_insert_attrib (x, "xmlns", IKS_NS_XMPP_SASL); ikss_Stream_send_node (self, x); // xxx check return value iks_delete (x); } iks_free (message); }
/** * Close SSML document. * @param handle * @return SWITCH_STATUS_SUCCESS */ static switch_status_t rayo_file_close(switch_file_handle_t *handle) { struct rayo_file_context *context = (struct rayo_file_context *)handle->private_info; if (context && context->component) { struct output_component *output = OUTPUT_COMPONENT(context->component); /* send completion and destroy */ if (output->stop) { rayo_component_send_complete(context->component, COMPONENT_COMPLETE_STOP); } else { rayo_component_send_complete(context->component, OUTPUT_FINISH); } /* TODO hangup / timed out */ /* cleanup internals */ switch_safe_free(context->ssml); context->ssml = NULL; if (output->document) { iks_delete(output->document); output->document = NULL; } /* close SSML file */ if (switch_test_flag((&context->fh), SWITCH_FILE_OPEN)) { return switch_core_file_close(&context->fh); } } return SWITCH_STATUS_SUCCESS; }
int pkg_data_parse( packet_parser_t *pkg, const char* source, int source_len, int plain_body_len) { char *parsed_body = NULL; // 解析出来的包体 int result; // TODO:根据包体是否经过加密判断是数据包还是协商包 iks *x = iks_tree (source, 0, &result); // 解析协商包 if (x) { iks_delete(x); if (pkg->talk_type == 0) { // 客户端解析服务器端响应的协商包,从中解析出以后通信使用的临时密钥并解密后填充到pkg中 return pkg_talk_parse(pkg, source); } else// if (pkg->talk_type == 1) { // 服务器端解析客户端发来的协商包请求 return pkg_talk_parse(pkg, source); } } // 解析数据包 else { // 是数据包,返回解析出来的明文数据包 parsed_body = pkg_uncompress_decrypt(pkg, source, source_len, plain_body_len); pkg->callback(parsed_body); free(parsed_body); return SUCCESS; } }
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); }
void document (char *xml) { enum ikserror err; iksparser *p; nr_tests++; if (my_x) iks_delete (my_x); p = iks_dom_new (&my_x); err = iks_parse (p, xml, 0, 1); switch (err) { case IKS_OK: break; case IKS_NOMEM: PR_TEST; puts ("Not enough memory."); exit (1); case IKS_BADXML: PR_TEST; printf ("Invalid xml at byte %ld in\n[%s]\n", iks_nr_bytes (p), xml); exit (1); case IKS_HOOK: PR_TEST; puts ("Hook."); } iks_parser_delete (p); }
static void iks_sasl_challenge(struct stream_data *data, iks *challenge) { char *message; iks *x; char *tmp; tmp = iks_cdata(iks_child(challenge)); if(!tmp) return; /* decode received blob */ message = iks_base64_decode(tmp, NULL); if(!message) return; /* reply the challenge */ if(strstr(message, "rspauth")) { x = iks_new("response"); } else { x = make_sasl_response(data, message); } if(x) { iks_insert_attrib(x, "xmlns", IKS_NS_XMPP_SASL); iks_send(data->prs, x); iks_delete(x); } iks_free(message); }
/** * Start execution of call output component * @param component to start * @param session the session to output to * @param output the output request * @param iq the original request */ static iks *start_call_output(struct rayo_component *component, switch_core_session_t *session, iks *output, iks *iq) { switch_stream_handle_t stream = { 0 }; /* acknowledge command */ rayo_component_send_start(component, iq); /* build playback command */ SWITCH_STANDARD_STREAM(stream); stream.write_function(&stream, "{id=%s,session=%s,pause=%s", RAYO_JID(component), switch_core_session_get_uuid(session), OUTPUT_COMPONENT(component)->start_paused ? "true" : "false"); if (OUTPUT_COMPONENT(component)->max_time > 0) { stream.write_function(&stream, ",timeout=%i", OUTPUT_COMPONENT(component)->max_time * 1000); } stream.write_function(&stream, "}fileman://rayo://%s", RAYO_JID(component)); if (switch_ivr_displace_session(session, stream.data, 0, "m") == SWITCH_STATUS_SUCCESS) { RAYO_UNLOCK(component); } else { if (OUTPUT_COMPONENT(component)->document) { iks_delete(OUTPUT_COMPONENT(component)->document); } if (switch_channel_get_state(switch_core_session_get_channel(session)) >= CS_HANGUP) { rayo_component_send_complete(component, COMPONENT_COMPLETE_HANGUP); component = NULL; } else { rayo_component_send_complete(component, COMPONENT_COMPLETE_ERROR); component = NULL; } } switch_safe_free(stream.data); return NULL; }
// invoked only upon parser resetting or deletion (iks_parser_reset, iks_parser_delete) static void deleteHook (ikss_Stream *self) { if (self->current) { iks_delete (self->current); self->current = NULL; } }
static void test_rayo_test_srgs(void) { iks *grammar = NULL; iksparser *p = iks_dom_new(&grammar); ASSERT_EQUALS(IKS_OK, iks_parse(p, rayo_test_srgs, 0, 1)); iks_parser_delete(p); iks_delete(grammar); }
//! Returns a dictionar of models: methods int db_load_models(PyObject **py_models) { /*! * Returns a dictionary of models and their methods. * * @py_models Pointer to dictionary * @return 0 on success, -1 on error * */ struct dirent *dp; DIR *dir = opendir(config_dir_models); iks *xml; *py_models = PyDict_New(); // Iterate over all files under models directory while ((dp = readdir(dir)) != NULL) { if (dp->d_name[0] == '.') { continue; } // Load XML int size = strlen(config_dir_models) + 1 + strlen(dp->d_name) + 1; char *fn_xml = malloc(size); if (fn_xml == NULL) oom(); snprintf(fn_xml, size, "%s/%s", config_dir_models, dp->d_name); fn_xml[size - 1] = 0; switch (iks_load(fn_xml, &xml)) { case IKS_NOMEM: free(fn_xml); oom(); case IKS_FILE_RWERR: case IKS_FILE_NOACCESS: log_error("Unable to open XML: %s\n", fn_xml); closedir(dir); free(fn_xml); return -1; } // Validate XML if (db_validate_model(xml, fn_xml) != 0) { closedir(dir); iks_delete(xml); free(fn_xml); return -1; } // Load model db_load_model(xml, py_models); } closedir(dir); return 0; }
/** * 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; }
void jabber_send (char *user, char *message) { iks *x; x = iks_make_msg (IKS_TYPE_NONE, user, message); iks_send (j_parser, x); iks_delete (x); }
/** * Handle start of input. */ 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_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_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_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); iks_delete(PROMPT_COMPONENT(prompt)->iq); start_input_timers(PROMPT_COMPONENT(prompt)); break; case PCS_DONE: /* stopped by client */ 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: case PCS_INPUT_OUTPUT: case PCS_INPUT: case PCS_STOP_OUTPUT: case PCS_OUTPUT: case PCS_DONE_STOP_OUTPUT: switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, unexpected start input event\n", RAYO_JID(prompt)); break; } return NULL; }
static void test_empty_cdata(void) { iks *iq = NULL; iks *input = NULL; iksparser *p = iks_dom_new(&iq); const char *cdata; ASSERT_EQUALS(IKS_OK, iks_parse(p, empty_cdata, 0, 1)); iks_parser_delete(p); ASSERT_NOT_NULL((input = iks_find(iq, "input"))); ASSERT_NULL((cdata = iks_find_cdata(input, "grammar"))); iks_delete(iq); }
static void test_repeating_bracket(void) { iks *iq = NULL; iks *input = NULL; iksparser *p = iks_dom_new(&iq); const char *cdata; ASSERT_EQUALS(IKS_OK, iks_parse(p, repeating_bracket, 0, 1)); iks_parser_delete(p); ASSERT_NOT_NULL((input = iks_find(iq, "input"))); ASSERT_NOT_NULL((cdata = iks_find_cdata(input, "grammar"))); ASSERT_STRING_EQUALS("[1 DIGITS]>]]]]]]]]] ]] ", cdata); iks_delete(iq); }
static void deleteHook(struct stream_data *data) { if(data->flags & SF_SECURE) { iks_default_tls.terminate(data->tlsdata); data->tlsdata = NULL; } if(data->trans) data->trans->close(data->sock); data->trans = NULL; if(data->current) iks_delete(data->current); data->current = NULL; data->flags = 0; }
// if returns IKS_OK, do not send more before ikss_SENT callback int ikss_Stream_start_sasl (ikss_Stream *self, enum ikssasltype type, const char *username, const char *pass) { iks *x; x = iks_new ("auth"); // xxx check return? iks_insert_attrib (x, "xmlns", IKS_NS_XMPP_SASL); // xxx check return? switch (type) { case IKS_SASL_PLAIN: { int len = iks_strlen (username) + iks_strlen (pass) + 2; char *s = iks_malloc (80+len); // xxx check for oom, on error free x and return error code char *base64; iks_insert_attrib (x, "mechanism", "PLAIN"); // xxx check return? sprintf (s, "%c%s%c%s", 0, username, 0, pass); base64 = iks_base64_encode (s, len); // xxx check return? iks_insert_cdata (x, base64, 0); iks_free (base64); iks_free (s); break; } case IKS_SASL_DIGEST_MD5: { iks_insert_attrib (x, "mechanism", "DIGEST-MD5"); // xxx check return? self->auth_username = username; self->auth_pass = pass; break; } default: iks_delete (x); return IKS_NET_NOTSUPP; } int ret = ikss_Stream_send_node (self, x); iks_delete (x); // delete ok since above makes a copy if (ret) return ret; return IKS_OK; }
void prefs_setup (void) { iks *x; memset (&prefs, 0, sizeof (struct prefs_struct)); prefs_chdir (".ulubot"); if (iks_load ("ayarlar.xml", &x) == IKS_OK) { if (iks_strcmp (iks_name (x), "ulubot") == 0) { prefs.jid = iks_strdup (iks_find_cdata (x, "id")); prefs.pass = iks_strdup (iks_find_cdata (x, "password")); prefs.admin_jid = iks_strdup (iks_find_cdata (x, "admin_id")); iks_delete (x); if (prefs.jid && prefs.pass && prefs.admin_jid) return; } } puts (PACKAGE" v"VERSION" sözlük sunucusuna hoşgeldiniz!"); puts ("Hemen bir kaç ayar yapalım:"); prefs.jid = iks_strdup (input ("Botun Jabber hesabı")); prefs.pass = iks_strdup (input ("Botun Jabber şifresi")); prefs.admin_jid = iks_strdup (input ("Yöneticinin Jabber hesabı")); x = iks_new ("ulubot"); iks_insert_cdata (iks_insert (x, "id"), prefs.jid, 0); iks_insert_cdata (iks_insert (x, "password"), prefs.pass, 0); iks_insert_cdata (iks_insert (x, "admin_id"), prefs.admin_jid, 0); if (iks_save ("ayarlar.xml", x) != IKS_OK) { puts ("Hata: ayarları kaydedemedim!"); } iks_delete (x); puts ("Ayarlar tamam."); }
// iksparser calls this when it has a full tag // // Important: Nothing must be done after a self->streamHook invocation // if the hook returns a non-zero value. static int tagHook (ikss_Stream *self, char *name, char **atts, int type) { iks *x; int err; switch (type) { case IKS_OPEN: case IKS_SINGLE: if (self->current) { x = iks_insert (self->current, name); insert_attribs (x, atts); } else { x = iks_new (name); insert_attribs (x, atts); if (iks_strcmp (name, "stream:stream") == 0) { err = self->streamHook (self->user_data, IKS_NODE_START, x); if (err != IKS_OK) return err; break; } } self->current = x; if (IKS_OPEN == type) break; case IKS_CLOSE: x = self->current; if (NULL == x) { err = self->streamHook (self->user_data, IKS_NODE_STOP, NULL); if (err != IKS_OK) return err; break; } if (NULL == iks_parent (x)) { self->current = NULL; if (iks_strcmp (name, "challenge") == 0) { send_sasl_challenge(self, x); iks_delete (x); } else if (iks_strcmp (name, "stream:error") == 0) { err = self->streamHook (self->user_data, IKS_NODE_ERROR, x); if (err != IKS_OK) return err; } else { err = self->streamHook (self->user_data, IKS_NODE_NORMAL, x); if (err != IKS_OK) return err; } break; } self->current = iks_parent (x); } return IKS_OK; }
/** * Close SSML document. * @param handle * @return SWITCH_STATUS_SUCCESS */ static switch_status_t rayo_file_close(switch_file_handle_t *handle) { struct rayo_file_context *context = (struct rayo_file_context *)handle->private_info; if (context && context->component) { struct output_component *output = OUTPUT_COMPONENT(context->component); /* send completion and destroy */ if (output->stop) { rayo_component_send_complete(context->component, COMPONENT_COMPLETE_STOP); } else { if (!strcmp(RAYO_ACTOR(context->component)->type, RAT_CALL_COMPONENT)) { /* call output... check for hangup */ switch_core_session_t *session = switch_core_session_locate(RAYO_ACTOR(context->component)->parent->id); if (session) { if (switch_channel_get_state(switch_core_session_get_channel(session)) >= CS_HANGUP) { rayo_component_send_complete(context->component, COMPONENT_COMPLETE_HANGUP); } else { rayo_component_send_complete(context->component, OUTPUT_FINISH); } switch_core_session_rwunlock(session); } else { /* session is gone */ rayo_component_send_complete(context->component, COMPONENT_COMPLETE_HANGUP); } } else { /* mixer output... finished */ rayo_component_send_complete(context->component, OUTPUT_FINISH); } } /* TODO timed out */ /* cleanup internals */ switch_safe_free(context->ssml); context->ssml = NULL; if (output->document) { iks_delete(output->document); output->document = NULL; } /* close SSML file */ if (switch_test_flag((&context->fh), SWITCH_FILE_OPEN)) { return switch_core_file_close(&context->fh); } } return SWITCH_STATUS_SUCCESS; }
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); }
char * db_dump_profile(void) { struct databases db; struct pack *p; DBC *cursor = NULL; DBT pair[2]; int e; iks *xml = NULL, *item, *x; char *ret = NULL; memset(&pair[0], 0, sizeof(DBT) * 2); pair[1].flags = DB_DBT_MALLOC; if (open_env(&db, PROFILE_DB)) goto out; db.profile->cursor(db.profile, NULL, &cursor, 0); xml = iks_new("comarProfile"); iks_insert_cdata(xml, "\n", 1); while ((e = cursor->c_get(cursor, &pair[0], &pair[1], DB_NEXT)) == 0) { char *t; size_t ts; item = iks_insert(xml, "item"); iks_insert_cdata(iks_insert(item, "key"), pair[0].data, pair[0].size); p = pack_wrap(pair[1].data, pair[1].size); while (pack_get(p, &t, &ts)) { iks_insert_cdata(item, "\n", 1); x = iks_insert(item, "data"); iks_insert_attrib(x, "key", t); pack_get(p, &t, &ts); iks_insert_cdata(iks_insert(x, "value"), t, ts); } pack_delete(p); iks_insert_cdata(xml, "\n", 1); } if (e != DB_NOTFOUND) { goto out; } ret = iks_string(NULL, xml); out: if (cursor) cursor->c_close(cursor); close_env(&db); if (xml) iks_delete(xml); return ret; }
/** * Makes NLSML result to conform to mrcpv2 * @param result the potentially non-conforming result * @return the conforming result */ iks *nlsml_normalize(const char *result) { iks *result_xml = NULL; iksparser *p = iks_dom_new(&result_xml); if (iks_parse(p, result, 0, 1) == IKS_OK && result_xml) { /* for now, all that is needed is to set the proper namespace */ iks_insert_attrib(result_xml, "xmlns", NLSML_NS); } else { /* unexpected ... */ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Failed to normalize NLSML result: %s\n", result); if (result_xml) { iks_delete(result_xml); } } iks_parser_delete(p); return result_xml; }
/** * Handle completion event */ 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)); switch (PROMPT_COMPONENT(prompt)->state) { case PCS_INPUT_OUTPUT: PROMPT_COMPONENT(prompt)->state = PCS_DONE_STOP_OUTPUT; presence = iks_copy(presence); 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_jid); break; case PCS_STOP_OUTPUT: PROMPT_COMPONENT(prompt)->state = PCS_DONE_STOP_OUTPUT; presence = iks_copy(presence); iks_insert_attrib(presence, "from", RAYO_JID(prompt)); iks_insert_attrib(presence, "to", RAYO_COMPONENT(prompt)->client_jid); PROMPT_COMPONENT(prompt)->complete = presence; break; case PCS_INPUT: PROMPT_COMPONENT(prompt)->state = PCS_DONE; /* pass through */ case PCS_DONE: presence = iks_copy(presence); iks_insert_attrib(presence, "from", RAYO_JID(prompt)); iks_insert_attrib(presence, "to", RAYO_COMPONENT(prompt)->client_jid); iks_delete(PROMPT_COMPONENT(prompt)->iq); rayo_component_send_complete_event(RAYO_COMPONENT(prompt), presence); 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: switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s, unexpected start output error event\n", RAYO_JID(prompt)); break; } return NULL; }
/** * Send rayo complete */ void rayo_component_send_complete_with_metadata_string(struct rayo_component *component, const char *reason, const char *reason_namespace, const char *meta, int child_of_complete) { iks *meta_xml = NULL; iksparser *p = iks_dom_new(&meta_xml); if (iks_parse(p, meta, 0, 1) != IKS_OK) { /* unexpected ... */ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "%s Failed to parse metadata for complete event: %s\n", RAYO_JID(component), meta); /* send without... */ rayo_component_send_complete(component, reason, reason_namespace); } else { rayo_component_send_complete_with_metadata(component, reason, reason_namespace, meta_xml, child_of_complete); } if (meta_xml) { iks_delete(meta_xml); } iks_parser_delete(p); }