Exemplos de globus_gsi_gssapi_test_authenticate em C++ (Cpp)

Exemplo n.º 1

Arquivo: gssapi_context_test.c Projeto: bbockelm/globus-toolkit

void *
client_func(
    void *                              arg)
{
    struct context_arg *                client_args;
    globus_bool_t                       result;
    gss_ctx_id_t                        context_handle = GSS_C_NO_CONTEXT;
    char *                              user_id = NULL;
    gss_cred_id_t                       delegated_cred = GSS_C_NO_CREDENTIAL;
    int                                 connect_fd;
    int                                 rc;
    
    client_args = (struct context_arg *) arg;

    connect_fd = socket(PF_UNIX, SOCK_STREAM, 0);

    rc = connect(connect_fd,
                 (struct sockaddr *) client_args->address,
                 sizeof(struct sockaddr_un));

    if(rc != 0)
    {
        abort();
    }


    result = globus_gsi_gssapi_test_authenticate(
        connect_fd,
        GLOBUS_FALSE, 
        client_args->credential, 
        &context_handle, 
        &user_id, 
        &delegated_cred);
    
    if(result == GLOBUS_FALSE)
    {
        fprintf(stderr, "CLIENT: Authentication failed\n");
        exit(1);
    }

    result = globus_gsi_gssapi_test_send_hello(connect_fd, context_handle);
    
    if(result == GLOBUS_FALSE)
    {
        fprintf(stderr, "CLIENT: failed to send hello\n");
        exit(1);
    }
    
    globus_gsi_gssapi_test_cleanup(&context_handle,
                                   user_id,
                                   &delegated_cred);
    user_id = NULL;
    
    close(connect_fd);

    free(client_args);

    return NULL;
}

Exemplo n.º 2

Arquivo: gssapi_thread_test.c Projeto: eunsungc/globus_toolkit-6.0.1430141288-RAMSES

void *
server_func(
    void *                              arg)
{
    struct thread_arg *                 thread_args;
    globus_bool_t                       authenticated;
    gss_ctx_id_t                        context_handle = GSS_C_NO_CONTEXT;
    char *                              user_id = NULL;
    gss_cred_id_t                       credential = GSS_C_NO_CREDENTIAL;
    gss_cred_id_t                       delegated_cred = GSS_C_NO_CREDENTIAL;
    
    thread_args = (struct thread_arg *) arg;

    authenticated = globus_gsi_gssapi_test_authenticate(
	thread_args->fd,
	GLOBUS_TRUE, 
	thread_args->credential, 
	&context_handle, 
	&user_id, 
	&delegated_cred);
    
    if(authenticated == GLOBUS_FALSE)
    {
	fprintf(stderr, "SERVER: Authentication failed\n");
    }

    close(thread_args->fd);
    
    free(thread_args);
    
    globus_gsi_gssapi_test_cleanup(&context_handle,
				   user_id,
				   &delegated_cred);

    globus_mutex_lock(&mutex);
    {
        server_thread_count--;
        
        if(server_thread_count == 0)
        {
            globus_cond_signal(&done);
        }
    }
    globus_mutex_unlock(&mutex);


    return NULL;
}

Exemplo n.º 3

Arquivo: gssapi_inquire_sec_ctx_by_oid_test.c Projeto: bbockelm/globus-toolkit

void *
server_func(
    void *                              arg)
{
    struct context_arg *                server_args;
    globus_bool_t                       result;
    gss_ctx_id_t                        context_handle = GSS_C_NO_CONTEXT;
    char *                              user_id = NULL;
    gss_cred_id_t                       delegated_cred = GSS_C_NO_CREDENTIAL;
    
    server_args = (struct context_arg *) arg;

    result = globus_gsi_gssapi_test_authenticate(
	server_args->fd,
	GLOBUS_TRUE, 
	server_args->credential, 
	&context_handle, 
	&user_id, 
	&delegated_cred);
    
    if(result == GLOBUS_FALSE)
    {
	fprintf(stderr, "SERVER: Authentication failed\n");
        exit(1);
    }

    result = globus_gsi_gssapi_test_dump_cert_chain(
        "cert_chain.txt",
        context_handle);

    if(result == GLOBUS_FALSE)
    {
	fprintf(stderr, "SERVER: Failed to dump cert chain\n");
        exit(1);
    }
    
    close(server_args->fd);
    
    free(server_args);
    
    globus_gsi_gssapi_test_cleanup(&context_handle,
				   user_id,
				   &delegated_cred);
    
    return NULL;
}

Exemplo n.º 4

Arquivo: gssapi_thread_test.c Projeto: eunsungc/globus_toolkit-6.0.1430141288-RAMSES

void *
client_func(
    void *                              arg)
{
    struct thread_arg *                 thread_args;
    globus_bool_t                       authenticated;
    gss_ctx_id_t                        context_handle = GSS_C_NO_CONTEXT;
    char *                              user_id = NULL;
    gss_cred_id_t                       credential = GSS_C_NO_CREDENTIAL;
    gss_cred_id_t                       delegated_cred = GSS_C_NO_CREDENTIAL;
    int                                 connect_fd;
    int                                 result;
    int                                 i;
    int                                 failed = 0;
    
    thread_args = (struct thread_arg *) arg;

    for(i=0;i<ITERATIONS;i++)
    {
        globus_mutex_lock(&mutex);
        pending_connects++;
        globus_cond_signal(&done);
        globus_mutex_unlock(&mutex);
	connect_fd = socket(AF_INET, SOCK_STREAM, 0);

        do
        {
            result = connect(connect_fd,
                             (struct sockaddr *) thread_args->address,
                             thread_args->len);
        }
        while (result != 0);

	authenticated = globus_gsi_gssapi_test_authenticate(
	    connect_fd,
	    GLOBUS_FALSE, 
	    thread_args->credential, 
	    &context_handle, 
	    &user_id, 
	    &delegated_cred);

	if(authenticated == GLOBUS_FALSE)
	{
	    fprintf(stderr, "CLIENT: Authentication failed\n");
            failed = 1;
	}
    
	globus_gsi_gssapi_test_cleanup(&context_handle,
				       user_id,
				       &delegated_cred);
	user_id = NULL;

	close(connect_fd);
    }

    free(thread_args);

    globus_mutex_lock(&mutex);
    {
        client_thread_count--;
        client_failed += failed;

        printf("%s\n", failed ? "not ok" : "ok");
        
        if(client_thread_count == 0)
        {
            globus_cond_signal(&done);
        }
    }
    globus_mutex_unlock(&mutex);
    
    return NULL;
}