Пример #1
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");
        }
    }

}
Пример #2
0
int axis2_xmpp_client_on_normal_node(
    axis2_xmpp_session_data_t *session,
    iks* node)
{
    if(!strcmp("stream:features", iks_name(node)))
    {
        session->features = iks_stream_features(node);

        if(session->use_sasl)
        {
            if(session->use_tls && !iks_is_secure(session->parser))
            {
                if(!session->authorized)
                {
                    /* we might be in the process of establishing TLS. so should return OK */
                    return IKS_OK;
                }

                return IKS_HOOK;
            }

            if(session->authorized)
            {
                /* Bind a resource if required */
                xmpp_process_msg(session, node);
            }
            else
            {
                if(session->features & IKS_STREAM_SASL_MD5)
                {
                    iks_start_sasl(session->parser, IKS_SASL_DIGEST_MD5, session->jid->user,
                        session->password);
                }
                else if(session->features & IKS_STREAM_SASL_PLAIN)
                {
                    iks_start_sasl(session->parser, IKS_SASL_PLAIN, session->jid->user,
                        session->password);
                }
#ifdef AXIS2_XMPP_GSSAPI
                else if (session->features & IKS_STREAM_SASL_GSSAPI)
                {
                    iks_start_sasl (session->parser, IKS_SASL_GSSAPI,
                        session->jid->user, session->password);
                }
#endif  /* AXIS2_XMPP_GSSAPI */

            }
        }
        else
        {
            /* features node */
            if(!strcmp("stream:features", iks_name(node)))
            {
                if(session->authorized)
                    xmpp_process_msg(session, node);

            }
        }
    }
    else if(!strcmp("failure", iks_name(node)))
    {
        AXIS2_LOG_ERROR(session->env->log, AXIS2_LOG_SI, "[xmpp]Authentication failed.");
        return IKS_HOOK;
    }
    else if(!strcmp("success", iks_name(node)))
    {
        AXIS2_LOG_INFO(session->env->log, "[xmpp]Authentication successful.");
        session->authorized = 1;
        iks_send_header(session->parser, session->server);
    }
    else
    {
        ikspak *pak;
        pak = iks_packet(node);
        iks_filter_packet(session->filter, pak);
    }

    return IKS_OK;
}
Пример #3
0
static int
on_stream (void *ptr, int type, iks *node)
{
	iks *x;
	ikspak *pak;

	switch (type) {
		case IKS_NODE_START:
			/* x = iks_make_auth (j_user, prefs.pass, iks_find_attrib (node, "id"));
			iks_insert_attrib (x, "id", "auth");
			iks_send (j_parser, x);
			iks_delete (x); */
			break;

		case IKS_NODE_NORMAL:
			if (strcmp("stream:features", iks_name(node)) == 0) {
				if (authorized) {
					int features;
					features = iks_stream_features(node);
					if (features & IKS_STREAM_BIND) {
						x = iks_make_resource_bind(j_user);
						iks_send(j_parser, x);
						iks_delete(x);
					}
					if (features & IKS_STREAM_SESSION) {
						x = iks_make_session();
						iks_insert_attrib(x, "id", "auth");
						iks_send(j_parser, x);
						iks_delete(x);
					}
				} else {
					iks_start_sasl(j_parser, IKS_SASL_DIGEST_MD5, j_user->user, prefs.pass);
				}
				break;
			} else if (strcmp("failure", iks_name(node)) == 0) {
				log_event ("Hata: SASL başarısız!");
				return IKS_HOOK;
			} else if (strcmp("success", iks_name(node)) == 0) {
				authorized = 1;
				iks_send_header(j_parser, j_user->server);
				break;
			}
		
			pak = iks_packet (node);
			if (pak->type == IKS_PAK_MESSAGE) {
				// process incoming messages
				command_parse (pak->from->partial, iks_find_cdata (node, "body"));
			} else if (pak->type == IKS_PAK_S10N) {
				// always accept subscriptions
				if (pak->subtype == IKS_TYPE_SUBSCRIBE) {
					x = iks_make_s10n (IKS_TYPE_SUBSCRIBED, pak->from->full, NULL);
					iks_send (j_parser, x);
					iks_delete (x);
				}
			} else if (pak->type == IKS_PAK_IQ) {
				if (iks_strcmp (pak->id, "auth") == 0) {
					// auth response
					if (pak->subtype == IKS_TYPE_RESULT) {
						log_event ("Bağlandık.");
						x = iks_make_iq (IKS_TYPE_GET, IKS_NS_ROSTER);
						iks_send (j_parser, x);
						iks_delete (x);
						x = iks_make_pres (IKS_SHOW_AVAILABLE, NULL);
						iks_send (j_parser, x);
						iks_delete (x);
					} else {
						log_event ("Hata: kullanıcı doğrulama başarısız oldu!");
						return IKS_HOOK;
					}
				}
			}
			break;

		case IKS_NODE_STOP:
		case IKS_NODE_ERROR:
			log_event ("Hata: XMPP stream hatası!");
			return IKS_HOOK;
	}
	if (node) iks_delete (node);

	return IKS_OK;
}