Example #1
0
static int NonBlockSSH_connect(WOLFSSH* ssh)
{
    int ret;
    int error;
    SOCKET_T sockfd;
    int select_ret = 0;

    ret = wolfSSH_connect(ssh);
    error = wolfSSH_get_error(ssh);
    sockfd = (SOCKET_T)wolfSSH_get_fd(ssh);

    while (ret != WS_SUCCESS &&
            (error == WS_WANT_READ || error == WS_WANT_WRITE))
    {
        if (error == WS_WANT_READ)
            printf("... client would read block\n");
        else if (error == WS_WANT_WRITE)
            printf("... client would write block\n");

        select_ret = tcp_select(sockfd, 1);
        if (select_ret == WS_SELECT_RECV_READY ||
            select_ret == WS_SELECT_ERROR_READY)
        {
            ret = wolfSSH_connect(ssh);
        }
        else if (select_ret == WS_SELECT_TIMEOUT)
            error = WS_WANT_READ;
        else
            error = WS_FATAL_ERROR;
    }

    return ret;
}
Example #2
0
int tcp_accept(int localsocket_fd, int *remotesocket_fd, int timeout)
{
   int             new_sd;
   PRVERBOSE1("accepting...for %ds\n", timeout);
   if (timeout==0) 
     timeout=-1; /* select will wait forever */

   if (tcp_select(localsocket_fd, timeout) != 0) {
     new_sd = accept(localsocket_fd, NULL, NULL);
     if (new_sd == -1) {
       PRERROR("tcp_accept: accept error\n");
       perror("");
       return -1;
     }
     *remotesocket_fd = new_sd;
     close(localsocket_fd);
     /*   connlist[conn].state = CONNSTATE_UP; */
     PRVERBOSE("connected to client!\n");
   }
   else {
     PRERROR("timeout for server exceeded!\n");
     return -1;
   }
   return 0;
}
Example #3
0
/* Echo number of bytes specified by -e arg */
int ServerEchoData(SSL* ssl, int clientfd, int echoData, int throughput)
{
    int ret = 0;
    char* buffer = (char*)malloc(TEST_BUFFER_SIZE);
    if(buffer) {
        double start = 0, rx_time = 0, tx_time = 0;
        int xfer_bytes = 0;
        while((echoData && throughput == 0) || (!echoData && xfer_bytes < throughput)) {
            int select_ret = tcp_select(clientfd, 1); /* Timeout=1 second */
            if (select_ret == TEST_RECV_READY) {
                int len = min(TEST_BUFFER_SIZE, throughput - xfer_bytes);
                int rx_pos = 0;
                if(throughput) {
                    start = current_time(1);
                }
                while(rx_pos < len) {
                    ret = SSL_read(ssl, &buffer[rx_pos], len - rx_pos);
                    if (ret <= 0) {
                        int readErr = SSL_get_error(ssl, 0);
                        if (readErr != SSL_ERROR_WANT_READ) {
                            printf("SSL_read error %d!\n", readErr);
                            err_sys("SSL_read failed");
                        }
                    }
                    else {
                        rx_pos += ret;
                    }
                }
                if(throughput) {
                    rx_time += current_time(0) - start;
                    start = current_time(1);
                }
                if (SSL_write(ssl, buffer, len) != len) {
                    err_sys("SSL_write failed");
                }
                if(throughput) {
                    tx_time += current_time(0) - start;
                }

                xfer_bytes += len;
            }
        }
        free(buffer);

        if(throughput) {
            printf("wolfSSL Server Benchmark %d bytes\n"
                "\tRX      %8.3f ms (%8.3f MBps)\n"
                "\tTX      %8.3f ms (%8.3f MBps)\n",
                throughput,
                tx_time * 1000, throughput / tx_time / 1024 / 1024,
                rx_time * 1000, throughput / rx_time / 1024 / 1024
            );
        }
    }
    else {
        err_sys("Server buffer malloc failed");
    }

    return EXIT_SUCCESS;
}
Example #4
0
/* handle SFTP operations
 * returns 0 on success
 */
static int sftp_worker(thread_ctx_t* threadCtx) {
    int ret   = WS_SUCCESS;
    int error = WS_SUCCESS;
    SOCKET_T sockfd;
    int select_ret = 0;

    sockfd = (SOCKET_T)wolfSSH_get_fd(threadCtx->ssh);
    do {
        if (threadCtx->nonBlock) {
            if (error == WS_WANT_READ)
                printf("... sftp server would read block\n");
            else if (error == WS_WANT_WRITE)
                printf("... sftp server would write block\n");
        }

        select_ret = tcp_select(sockfd, TEST_SFTP_TIMEOUT);
        if (select_ret == WS_SELECT_RECV_READY ||
            select_ret == WS_SELECT_ERROR_READY ||
            error == WS_WANT_WRITE)
        {
            ret = wolfSSH_SFTP_read(threadCtx->ssh);
            error = wolfSSH_get_error(threadCtx->ssh);
        }
        else if (select_ret == WS_SELECT_TIMEOUT)
            error = WS_WANT_READ;
        else
            error = WS_FATAL_ERROR;

        if (error == WS_WANT_READ || error == WS_WANT_WRITE)
            ret = WS_WANT_READ;

    } while (ret != WS_FATAL_ERROR);

    return ret;
}
Example #5
0
static void NonBlockingSSL_Accept(SSL* ssl)
{
#ifndef CYASSL_CALLBACKS
    int ret = SSL_accept(ssl);
#else
    int ret = CyaSSL_accept_ex(ssl, srvHandShakeCB, srvTimeoutCB, srvTo);
#endif
    int error = SSL_get_error(ssl, 0);
    SOCKET_T sockfd = (SOCKET_T)CyaSSL_get_fd(ssl);
    int select_ret;

    while (ret != SSL_SUCCESS && (error == SSL_ERROR_WANT_READ ||
                                  error == SSL_ERROR_WANT_WRITE)) {
        if (error == SSL_ERROR_WANT_READ)
            printf("... server would read block\n");
        else
            printf("... server would write block\n");

        if (CyaSSL_dtls(ssl))
            select_ret = tcp_select(sockfd,
                                    CyaSSL_dtls_get_current_timeout(ssl));
        else
            select_ret = tcp_select(sockfd, 1);

        if ((select_ret == TEST_RECV_READY) ||
                                        (select_ret == TEST_ERROR_READY)) {
            #ifndef CYASSL_CALLBACKS
                ret = SSL_accept(ssl);
            #else
                ret = CyaSSL_accept_ex(ssl,
                                    srvHandShakeCB, srvTimeoutCB, srvTo);
            #endif
            error = SSL_get_error(ssl, 0);
        }
        else if (select_ret == TEST_TIMEOUT &&
                    (!CyaSSL_dtls(ssl) ||
                    (CyaSSL_dtls_got_timeout(ssl) >= 0))) {
            error = SSL_ERROR_WANT_READ;
        }
        else {
            error = SSL_FATAL_ERROR;
        }
    }
    if (ret != SSL_SUCCESS)
        err_sys("SSL_accept failed");
}
Example #6
0
static int NonBlockingSSL_Accept(SSL* ssl)
{
#ifndef CYASSL_CALLBACKS
    int ret = SSL_accept(ssl);
#else
    int ret = CyaSSL_accept_ex(ssl, srvHandShakeCB, srvTimeoutCB, srvTo);
#endif
    int error = SSL_get_error(ssl, 0);
    SOCKET_T sockfd = (SOCKET_T)CyaSSL_get_fd(ssl);
    int select_ret;

    while (ret != SSL_SUCCESS && (error == SSL_ERROR_WANT_READ ||
                                  error == SSL_ERROR_WANT_WRITE)) {
        int currTimeout = 1;

        if (error == SSL_ERROR_WANT_READ) {
            /* printf("... server would read block\n"); */
        } else {
            /* printf("... server would write block\n"); */
        }

#ifdef CYASSL_DTLS
        currTimeout = CyaSSL_dtls_get_current_timeout(ssl);
#endif
        select_ret = tcp_select(sockfd, currTimeout);

        if ((select_ret == TEST_RECV_READY) ||
                                        (select_ret == TEST_ERROR_READY)) {
            #ifndef CYASSL_CALLBACKS
                ret = SSL_accept(ssl);
            #else
                ret = CyaSSL_accept_ex(ssl,
                                    srvHandShakeCB, srvTimeoutCB, srvTo);
            #endif
            error = SSL_get_error(ssl, 0);
        }
        else if (select_ret == TEST_TIMEOUT && !CyaSSL_dtls(ssl)) {
            error = SSL_ERROR_WANT_READ;
        }
#ifdef CYASSL_DTLS
        else if (select_ret == TEST_TIMEOUT && CyaSSL_dtls(ssl) &&
                                            CyaSSL_dtls_got_timeout(ssl) >= 0) {
            error = SSL_ERROR_WANT_READ;
        }
#endif
        else {
            error = SSL_FATAL_ERROR;
        }
    }

    return ret;
}
Example #7
0
static void NonBlockingSSL_Connect(CYASSL* ssl)
{
#ifndef CYASSL_CALLBACKS
    int ret = CyaSSL_connect(ssl);
#else
    int ret = CyaSSL_connect_ex(ssl, handShakeCB, timeoutCB, timeout);
#endif
    int error = CyaSSL_get_error(ssl, 0);
    SOCKET_T sockfd = (SOCKET_T)CyaSSL_get_fd(ssl);
    int select_ret;

    while (ret != SSL_SUCCESS && (error == SSL_ERROR_WANT_READ ||
                                  error == SSL_ERROR_WANT_WRITE)) {
        int currTimeout = 1;

        if (error == SSL_ERROR_WANT_READ)
            printf("... client would read block\n");
        else
            printf("... client would write block\n");

#ifdef CYASSL_DTLS
        currTimeout = CyaSSL_dtls_get_current_timeout(ssl);
#endif
        select_ret = tcp_select(sockfd, currTimeout);

        if ((select_ret == TEST_RECV_READY) ||
                                        (select_ret == TEST_ERROR_READY)) {
            #ifndef CYASSL_CALLBACKS
                    ret = CyaSSL_connect(ssl);
            #else
                ret = CyaSSL_connect_ex(ssl,handShakeCB,timeoutCB,timeout);
            #endif
            error = CyaSSL_get_error(ssl, 0);
        }
        else if (select_ret == TEST_TIMEOUT && !CyaSSL_dtls(ssl)) {
            error = SSL_ERROR_WANT_READ;
        }
#ifdef CYASSL_DTLS
        else if (select_ret == TEST_TIMEOUT && CyaSSL_dtls(ssl) &&
                                            CyaSSL_dtls_got_timeout(ssl) >= 0) {
            error = SSL_ERROR_WANT_READ;
        }
#endif
        else {
            error = SSL_FATAL_ERROR;
        }
    }
    if (ret != SSL_SUCCESS)
        err_sys("SSL_connect failed");
}
Example #8
0
int main(){
    int conn1;
    char recbuf[PKTSIZE];
    int size,j,i;
	
    sequence_init();
    tcp_init();
    conn1=tcp_add_connection("134.130.62.98" ,2500, "134.130.62.94",2500, CONN_SERVER);
    tcp_add_ip(conn1,"134.130.62.98" ,2501, "134.130.62.94",2501);
    tcp_add_ip(conn1,"134.130.62.98" ,2502, "134.130.62.94",2502);
    tcp_add_ip(conn1,"134.130.62.98" ,2503, "134.130.62.94",2503);
    if (tcp_establish_connection(conn1) < 0) {
	printf("kann Verbindung nicht aufbauen!\n");
	exit(-1);
    }

    i = 0;
    while(1) {
	printf("testing for data...\n");
	while (!tcp_select(conn1, 0)) {  
	    printf("."); 
	    fflush(stdout);
	    sleep(1); 
	}
	printf("\n");
	printf("message available!\n");

	size = tcp_receive_message(recbuf, PKTSIZE, conn1);
	if (size != i) {
	    fprintf(stderr, "expected %d Bytes, got %d Bytes\n", i, size); fflush(stderr);
	}
	    
	fprintf(stderr, "got %d Bytes, first Byte: %d\n", size, (int)((char*)recbuf)[1]); fflush(stderr);
	    
	if (*((char*)recbuf) == FERTIG) {
	    printf("Dienstschluss!\n");
	    break;
	}

	for ( j = 1; j < size; j++) 
	    if (((char*)recbuf)[j] != sequence()) {
		fprintf(stderr,"error in data: size= %d, pos = %d!\n",size,j);fflush(stderr);
		exit(-1);
		    
	    }
	i += 128;
    }
    tcp_close_connections(conn1);	
    return 1;
}
/*
 * Pulled in from examples/server/server.c
 * Function to handle nonblocking. Loops until tcp_select notifies that it's
 * ready for action. 
 */
int NonBlockingSSL(WOLFSSL* ssl)
{
    int ret;
    int error;
    int select_ret;
    int sockfd = wolfSSL_get_fd(ssl);
    ret = wolfSSL_accept(ssl);
    error = wolfSSL_get_error(ssl, 0);
    while (ret != SSL_SUCCESS && (error == SSL_ERROR_WANT_READ ||
                                  error == SSL_ERROR_WANT_WRITE)) {
        int currTimeout = 1;

        /* print out for user notification */
        if (error == SSL_ERROR_WANT_READ)
            printf("... server would read block\n");
        else
            printf("... server would write block\n");

        select_ret = tcp_select(sockfd, currTimeout);
        
        /* if tcp_select signals ready try to accept otherwise continue loop*/
        if ((select_ret == TEST_RECV_READY) || 
            (select_ret == TEST_ERROR_READY)) {
            ret = wolfSSL_accept(ssl);
            error = wolfSSL_get_error(ssl, 0);
        }
        else if (select_ret == TEST_TIMEOUT) {
            error = SSL_ERROR_WANT_READ;
        }
        else {
            error = SSL_FATAL_ERROR;
        }
    }
    /* faliure to accept */
    if (ret != SSL_SUCCESS) {
        printf("Fatal error : SSL_accept failed\n");
        ret = SSL_FATAL_ERROR;
    }

    return ret;
}
/*
 * sets up and uses nonblocking protocols using wolfssl 
 */
static int NonBlockingSSL_Connect(WOLFSSL* ssl)
{
    int ret, error, sockfd, select_ret, currTimeout;
    
    ret    = wolfSSL_connect(ssl);
    error  = wolfSSL_get_error(ssl, 0);
    sockfd = (int)wolfSSL_get_fd(ssl);

    while (ret != SSL_SUCCESS && (error == SSL_ERROR_WANT_READ ||
                                  error == SSL_ERROR_WANT_WRITE)) {
        currTimeout = 1;

        if (error == SSL_ERROR_WANT_READ)
            printf("... client would read block\n");
        else
            printf("... client would write block\n");

        select_ret = tcp_select(sockfd, currTimeout);

        if ((select_ret == TEST_RECV_READY) ||
            (select_ret == TEST_ERROR_READY)) {
            ret   = wolfSSL_connect(ssl);
            error = wolfSSL_get_error(ssl, 0);
        }
        else if (select_ret == TEST_TIMEOUT) {
            error = SSL_ERROR_WANT_READ;
        }
        else {
            error = SSL_FATAL_ERROR;
        }
    }
    if (ret != SSL_SUCCESS){
        printf("SSL_connect failed");
        return 1;
    }

	return 0;
}
Example #11
0
int device_select(struct timeval *timeout, struct gn_statemachine *state)
{
	switch (state->device.type) {
	case GN_CT_DKU2:
	case GN_CT_Serial:
	case GN_CT_Infrared:
		return serial_select(state->device.fd, timeout, state);
	case GN_CT_Irda:
		return irda_select(state->device.fd, timeout, state);
	case GN_CT_Bluetooth:
		return bluetooth_select(state->device.fd, timeout, state);
	case GN_CT_Tekram:
		return tekram_select(state->device.fd, timeout, state);
	case GN_CT_TCP:
		return tcp_select(state->device.fd, timeout, state);
	case GN_CT_DKU2LIBUSB:
		return fbusdku2usb_select(timeout, state);
	case GN_CT_SOCKETPHONET:
		return socketphonet_select(state->device.fd, timeout, state);
	default:
		break;
	}
	return -1;
}
Example #12
0
/**
 * This function initializes the tcp context global instance to 0 except for
 * file descriptor descriptor for stdin, stdout and stderr.
 *
 * @author    Mohd Naushad Ahmed
 * @version   1.0
 * @param     none
 * @return    none
 */
int main (int argc, char *argv[])
{
  
  tcp_instance_create("192.168.3.1",8989,tcp_process_request_cb);
  tcp_select();
}
Example #13
0
/* handle SSH echo operations
 * returns 0 on success
 */
static int ssh_worker(thread_ctx_t* threadCtx) {
    byte* buf = NULL;
    byte* tmpBuf;
    int bufSz, backlogSz = 0, rxSz, txSz, stop = 0, txSum;

    do {
        bufSz = EXAMPLE_BUFFER_SZ + backlogSz;

        tmpBuf = (byte*)realloc(buf, bufSz);
        if (tmpBuf == NULL)
            stop = 1;
        else
            buf = tmpBuf;

        if (!stop) {
            if (threadCtx->nonBlock) {
                SOCKET_T sockfd;
                int select_ret = 0;

                sockfd = (SOCKET_T)wolfSSH_get_fd(threadCtx->ssh);

                select_ret = tcp_select(sockfd, 1);
                if (select_ret != WS_SELECT_RECV_READY &&
                    select_ret != WS_SELECT_ERROR_READY &&
                    select_ret != WS_SELECT_TIMEOUT) {
                    break;
                }
            }

            rxSz = wolfSSH_stream_read(threadCtx->ssh,
                                       buf + backlogSz,
                                       EXAMPLE_BUFFER_SZ);
            if (rxSz > 0) {
                backlogSz += rxSz;
                txSum = 0;
                txSz = 0;

                while (backlogSz != txSum && txSz >= 0 && !stop) {
                    txSz = wolfSSH_stream_send(threadCtx->ssh,
                                               buf + txSum,
                                               backlogSz - txSum);

                    if (txSz > 0) {
                        byte c;
                        const byte matches[] = { 0x03, 0x05, 0x06, 0x00 };

                        c = find_char(matches, buf + txSum, txSz);
                        switch (c) {
                            case 0x03:
                                stop = 1;
                                break;
                            case 0x06:
                                if (wolfSSH_TriggerKeyExchange(threadCtx->ssh)
                                        != WS_SUCCESS)
                                    stop = 1;
                                break;
                            case 0x05:
                                if (dump_stats(threadCtx) <= 0)
                                    stop = 1;
                                break;
                        }
                        txSum += txSz;
                    }
                    else if (txSz != WS_REKEYING) {
                        int error = wolfSSH_get_error(threadCtx->ssh);
                        if (error != WS_WANT_WRITE) {
                            stop = 1;
                        }
                        else {
                            txSz = 0;
                        }
                    }
                }

                if (txSum < backlogSz)
                    memmove(buf, buf + txSum, backlogSz - txSum);
                backlogSz -= txSum;
            }
            else {
                int error = wolfSSH_get_error(threadCtx->ssh);
                if (error != WS_WANT_READ)
                    stop = 1;
            }
        }
    } while (!stop);

    free(buf);
    return 0;
}
Example #14
0
int ClientBenchmarkThroughput(WOLFSSL_CTX* ctx, char* host, word16 port,
    int doDTLS, int throughput)
{
    double start, conn_time = 0, tx_time = 0, rx_time = 0;
    SOCKET_T sockfd;
    WOLFSSL* ssl;
    int ret;

    start = current_time();
    ssl = wolfSSL_new(ctx);
    if (ssl == NULL)
        err_sys("unable to get SSL object");
    tcp_connect(&sockfd, host, port, doDTLS, ssl);
    wolfSSL_set_fd(ssl, sockfd);
    if (wolfSSL_connect(ssl) == SSL_SUCCESS) {
        /* Perform throughput test */
        char *tx_buffer, *rx_buffer;

        /* Record connection time */
        conn_time = current_time() - start;

        /* Allocate TX/RX buffers */
        tx_buffer = (char*)malloc(TEST_BUFFER_SIZE);
        rx_buffer = (char*)malloc(TEST_BUFFER_SIZE);
        if(tx_buffer && rx_buffer) {
            WC_RNG rng;

            /* Startup the RNG */
            ret = wc_InitRng(&rng);
            if(ret == 0) {
                int xfer_bytes;

                /* Generate random data to send */
                ret = wc_RNG_GenerateBlock(&rng, (byte*)tx_buffer, TEST_BUFFER_SIZE);
                wc_FreeRng(&rng);
                if(ret != 0) {
                    err_sys("wc_RNG_GenerateBlock failed");
                }

                /* Perform TX and RX of bytes */
                xfer_bytes = 0;
                while(throughput > xfer_bytes) {
                    int len, rx_pos, select_ret;

                    /* Determine packet size */
                    len = min(TEST_BUFFER_SIZE, throughput - xfer_bytes);

                    /* Perform TX */
                    start = current_time();
                    if (wolfSSL_write(ssl, tx_buffer, len) != len) {
                        int writeErr = wolfSSL_get_error(ssl, 0);
                        printf("wolfSSL_write error %d!\n", writeErr);
                        err_sys("wolfSSL_write failed");
                    }
                    tx_time += current_time() - start;

                    /* Perform RX */
                    select_ret = tcp_select(sockfd, 1); /* Timeout=1 second */
                    if (select_ret == TEST_RECV_READY) {
                        start = current_time();
                        rx_pos = 0;
                        while(rx_pos < len) {
                            ret = wolfSSL_read(ssl, &rx_buffer[rx_pos], len - rx_pos);
                            if(ret <= 0) {
                                int readErr = wolfSSL_get_error(ssl, 0);
                                if (readErr != SSL_ERROR_WANT_READ) {
                                    printf("wolfSSL_read error %d!\n", readErr);
                                    err_sys("wolfSSL_read failed");
                                }
                            }
                            else {
                                rx_pos += ret;
                            }
                        }
                        rx_time += current_time() - start;
                    }

                    /* Compare TX and RX buffers */
                    if(XMEMCMP(tx_buffer, rx_buffer, len) != 0) {
                        err_sys("Compare TX and RX buffers failed");
                    }

                    /* Update overall position */
                    xfer_bytes += len;
                }
            }
            else {
                err_sys("wc_InitRng failed");
            }
        }
        else {
            err_sys("Client buffer malloc failed");
        }
        if(tx_buffer) free(tx_buffer);
        if(rx_buffer) free(rx_buffer);
    }
    else {
        err_sys("wolfSSL_connect failed");
    }

    wolfSSL_shutdown(ssl);
    wolfSSL_free(ssl);
    CloseSocket(sockfd);

    printf("wolfSSL Client Benchmark %d bytes\n"
        "\tConnect %8.3f ms\n"
        "\tTX      %8.3f ms (%8.3f MBps)\n"
        "\tRX      %8.3f ms (%8.3f MBps)\n",
        throughput,
        conn_time * 1000,
        tx_time * 1000, throughput / tx_time / 1024 / 1024,
        rx_time * 1000, throughput / rx_time / 1024 / 1024
    );

    return EXIT_SUCCESS;
}
Example #15
0
/* メイン処理 */
main(int argc, char **argv) {
    int i;
    int ret;
    int stdbuf_len;
    time_t tm;
    char stdbuf[MAX_STDIN_BUF];

    signal(SIGPIPE, SigHandler);

    /* デフォルト値設定 */
    com_ReadConfig(CONFIG_FILE);
    strcpy(config_name,CONFIG_FILE);
    strcpy(server_name,LOGTRAIN_SERVER);
    server_port=LOGTRAIN_PORT;
    strcpy(cache_dir,CACHE_DIR);
    connect_timeout=CONNECT_TIMEOUT;
    connect_err_wait=CONNECT_ERR_WAIT;
    read_timeout=READ_TIMEOUT;
    write_timeout=WRITE_TIMEOUT;
    cache_limit=CACHE_LIMIT;

    /* パラメータ解析 */
    for ( i=1; i < argc; i++) {
        if ( strcmp(argv[i],"-d") == 0 ) {
            debug_flg=1;
            continue;
        }

        if ( i < argc -1 ) {
            if ( strcmp(argv[i],"-f") == 0 ) {
                strcpy(config_name,argv[++i]);
                com_ReadConfig(config_name);
                continue;
            }
            if ( strcmp(argv[i],"-h") == 0 ) {
                strcpy(server_name,argv[++i]);
                continue;
            }
            if ( strcmp(argv[i],"-p") == 0 ) {
                server_port=atoi(argv[++i]);
                continue;
            }
            if ( strcmp(argv[i],"-c") == 0 ) {
                strcpy(cache_dir,argv[++i]);
                continue;
            }
            if ( strcmp(argv[i],"-ct") == 0 ) {
                connect_timeout=atoi(argv[++i]);
                continue;
            }
            if ( strcmp(argv[i],"-rt") == 0 ) {
                read_timeout=atoi(argv[++i]);
                continue;
            }
            if ( strcmp(argv[i],"-wt") == 0 ) {
                write_timeout=atoi(argv[++i]);
                continue;
            }
        }
        if ( argv[i][0] == '-' ) {
            usage(argv[0]);
            exit(1);
        }
    }
    if ( com_fileCheck(cache_dir) != 1 ) {
        printf("no directory (%s)\n",cache_dir);
        exit(1);
    }

    com_logPrint("-------parameter----------");
    com_logPrint("config           = %s",config_name);
    com_logPrint("server           = %s",server_name);
    com_logPrint("port             = %d",server_port);
    com_logPrint("cache_dir        = %s",cache_dir);
    com_logPrint("connect timeout  = %d",connect_timeout);
    com_logPrint("connect err wait = %d",connect_err_wait);
    com_logPrint("read timeout     = %d",read_timeout);
    com_logPrint("write timeout    = %d",write_timeout);
    com_logPrint("--------------------------");

    /* サーバ接続 */
    LogTrainTcpConnect();
    ret=tcp_select(1,connect_timeout);
    if ( ret != 1 ) {
        com_logPrint("connect error");
        exit(1);
    }

    /* キャッシュファイル検索とリモート転送処理 */
    LogTrainTrans(cache_dir);

    LogTrainTcpClose();
    exit(0);
}