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;
}
Beispiel #4
0
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;
}
Beispiel #5
0
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;
}
Beispiel #8
0
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;
	}
}
Beispiel #9
0
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);
}
Beispiel #10
0
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);
}
Beispiel #11
0
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;
  }
}
Beispiel #14
0
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);
}
Beispiel #15
0
//! 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;
}
Beispiel #17
0
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;
}
Beispiel #19
0
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);
}
Beispiel #20
0
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);
}
Beispiel #21
0
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;
}
Beispiel #23
0
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;
}
Beispiel #26
0
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);
}
Beispiel #27
0
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;
}
Beispiel #28
0
/**
 * 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;
}
Beispiel #29
0
/**
 * 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;
}
Beispiel #30
0
/**
 * 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);
}