src/vsl_test_ssh.c

Go to the documentation of this file.

/*
 * Copyright 2006, Internet2
 * Legal conditions are in file LICENSE
 * (MD5 = c434f2e53b8089d8b4d0172c7ce07360).
 */

/**
 * @file   vsl_test_ssh.c
 * @author Nikolaus Rath
 * @brief  Test client for SSH Starting Mode
 *
 * First argument has to be the path to the server.
 *
 **/


#include "vfer_api.h"
#include "vsl_util.h"
#include "vsl_api.h"
#include "vfer_tests.h"


enum status {
    READ,
    WROTE
};


#define TESTSIZE 63*1024

/**
 * main
 */
int main (int argc, char** argv) {
    TEST_INIT("VSL_TEST_SSH", "vsl_test_ssh.c", stdout, stdout);
    vsl_sock sock1, sock2, sock3;
    vfer_fd vfd;
    char errmsg[512];

    ASSERT(vsl_init() == 0);

    // Handle debug
    int sargc=0;
    char **sargv1, **sargv2, **sargv3;
    if ( argc == 3 ) {
        vsl_debug(stdout, NULL);
        sargc = 1;
        sargv1 = (char*[]) { "vsl_test_ssh_1.log" };
        sargv2 = (char*[]) { "vsl_test_ssh_2.log" };
        sargv3 = (char*[]) { "vsl_test_ssh_3.log" };
    }

    // Prepare testdata
    char buf[TESTSIZE];
    const size_t buflen = sizeof(buf);
    char buf2[buflen];
    int fd;
    ASSERT( (fd = open(RANDDEV, 0)) >= 0);
    ASSERT( read(fd, (void*)buf, TESTSIZE) == TESTSIZE );
    ASSERT( close(fd) == 0 );

    /* Init socket 1, write and read */
    ASSERT((vfd = vfer_socket(SOCK_DGRAM)) >= 0);
    ASSERT( vsl_socket(&sock1, vfd) == 0);
    vsl_test_mode(&sock1);
    set_blocking(&sock1, true);
    ASSERT( vsl_connect_ssh(&sock1, "localhost", NULL,
                            argv[1], sargc, (const char* const*) sargv1, errmsg) == 0);
    ASSERT( vsl_send(&sock1, buf, buflen) == buflen );
    ASSERT( vsl_recv(&sock1, buf2, buflen) == buflen );
    ASSERT( memcmp(buf, buf2, buflen) == 0 );
    set_blocking(&sock1, false);


    // Init socket 2, write
    ASSERT((vfd = vfer_socket(SOCK_DGRAM)) >= 0);
    ASSERT( vsl_socket(&sock2, vfd) == 0);
    ASSERT( vsl_connect_ssh(&sock2, "localhost", NULL,
                            argv[1], sargc, (const char* const*) sargv2, errmsg) == 0);
    vsl_test_mode(&sock2);
    ASSERT( vsl_send(&sock1, buf, buflen) == buflen );
    set_blocking(&sock2, false);

    // Init socket 3
    ASSERT((vfd = vfer_socket(SOCK_DGRAM)) >= 0);
    ASSERT( vsl_socket(&sock3, vfd) == 0);
    vsl_test_mode(&sock3);
    set_blocking(&sock3, false);

    // Do test
    bool s3_connected = false;
    enum status s1_stat = READ;
    enum status s2_stat = WROTE;
    int vsl_connect_ssh_ret;
    int maxtries = 20;
    int num_read = 0;
    int num_written = 0;
    do {
        ASSERT( vsl_selectmark(&sock3, VSL_AUTHABLE | VSL_EXCEPTION) == 0 );
#define SETMARK(SOCK) do { \
        if ( s ## SOCK ## _stat == WROTE ) \
            ASSERT( vsl_selectmark(&sock ## SOCK, VSL_READABLE | VSL_EXCEPTION) == 0 ); \
        else \
            ASSERT( vsl_selectmark(&sock ## SOCK, VSL_WRITABLE | VSL_EXCEPTION) == 0 ); \
} while(0)
        SETMARK(2);
        SETMARK(1);
        ASSERT( vsl_selectpoll(3, (vsl_sock*[]) { &sock1, &sock2, &sock3 }, NULL, 1000000) > 0 );

        // Handle connect
        ASSERT( vsl_selecttest(&sock3) == VSL_AUTHABLE ||
                vsl_selecttest(&sock3) == 0);
        if ( vsl_selecttest(&sock3) == VSL_AUTHABLE ) {
            vsl_connect_ssh_ret =
                vsl_connect_ssh(&sock3, "localhost", NULL,
                                argv[1], sargc, (const char* const*) sargv3, errmsg);
            ASSERT(vsl_connect_ssh_ret == VFER_INPROGRESS ||
                   vsl_connect_ssh_ret == 0);
            if ( vsl_connect_ssh_ret == 0 )
                s3_connected = true;
        }

#define READWRITE(NR) do { \
        /* Handle read */ \
        if ( s ## NR ## _stat == WROTE ) { \
            ASSERT( vsl_selecttest(&sock ## NR) == VSL_READABLE || \
                    vsl_selecttest(&sock ## NR) == 0); \
            if ( vsl_selecttest(&sock ## NR) == VSL_READABLE ) { \
                ASSERT( vsl_recv(&sock ## NR, buf2, buflen) == buflen ); \
                ASSERT( memcmp(buf, buf2, buflen) == 0 ); \
            } \
            s ## NR ## _stat = READ; \
            num_read++; \
        } \
        /* Handle write */  \
        else if ( s ## NR ## _stat == READ ) { \
            ASSERT( vsl_selecttest(&sock ## NR) == VSL_WRITABLE || \
                    vsl_selecttest(&sock ## NR) == 0); \
            if ( vsl_selecttest(&sock ## NR) == VSL_WRITABLE ) { \
                ASSERT( vsl_send(&sock ## NR, buf, buflen) == buflen ); \
            } \
            s ## NR ## _stat = WROTE; \
            num_written++; \
        } \
} while(0)
        READWRITE(1);
        READWRITE(2);
        ASSERT(maxtries-- > 0);
        usleep(500000);
    } while (!s3_connected);
    ASSERT(num_written > 0);
    ASSERT(num_read > 0);

    vsl_close(&sock1);
    vsl_close(&sock2);
    vsl_close(&sock3);

    TEST_SUMMARY();
    exit(0);
}


/*
 * Local Variables:
 * compile-command: "cd ..; make vsl_test_ssh"
 * compilation-search-path: ("..")
 * End:
 */

---