开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
test_ncbi_socket.c
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：33k
源码类别：

生物技术

开发平台：

C/C++

test_ncbi_socket.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: test_ncbi_socket.c,v $
  4.  * PRODUCTION Revision 1000.0  2003/10/29 17:06:50  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R6.21
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: test_ncbi_socket.c,v 1000.0 2003/10/29 17:06:50 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Denis Vakatov
  36.  *
  37.  * File Description:
  38.  *   Test suite for "ncbi_socket.[ch]", the portable TCP/IP socket API
  39.  *
  40.  */
  42. #include "../ncbi_config.h"
  44. /* OS must be specified in the command-line ("-D....") or in the conf. header
  45.  */
  46. #if !defined(NCBI_OS_UNIX) && !defined(NCBI_OS_MSWIN) && !defined(NCBI_OS_MAC)
  47. #  error "Unknown OS, must be one of NCBI_OS_UNIX, NCBI_OS_MSWIN, NCBI_OS_MAC!"
  48. #endif
  50. #include <connect/ncbi_socket.h>
  51. #include <connect/ncbi_util.h>
  52. #include <stdlib.h>
  53. #include <string.h>
  54. #if defined(NCBI_OS_UNIX)
  55. #  include <unistd.h>
  56. #  define X_SLEEP(x) ((void) sleep(x))
  57. #elif defined(NCBI_OS_MSWIN)
  58. #  include <windows.h>
  59. #  define X_SLEEP(x) ((void) Sleep(1000 * x))
  60. #else
  61. #  define X_SLEEP(x) ((void) 0)
  62. #endif
  63. /* This header must go last */
  64. #include "test_assert.h"
  67. /* #define DO_CLIENT */
  68. /* #define DO_SERVER */
  70. #define TEST_BUFSIZE 8192
  72. /* exit server before sending the data expected by client(Test 1) */
  73. /*#define TEST_SRV1_SHUTDOWN*/
  75. #ifndef TEST_SRV1_SHUTDOWN
  76. /* exit server immediately after its first client is served(Test 1) */
  77. /*#define TEST_SRV1_ONCE*/
  78. #endif
  80. /* test SOCK_Reconnect() */
  81. #define DO_RECONNECT
  85. /* Log stream
  86.  */
  87. static FILE* log_fp;
  90. /* The simplest randezvous (a plain request-reply) test functions
  91.  *      "TEST__client_1(SOCK sock)"
  92.  *      "TEST__server_1(SOCK sock)"
  93.  */
  95. static const char s_C1[] = "C1";
  96. static const char s_M1[] = "M1";
  97. static const char s_S1[] = "S1";
  99. #define N_SUB_BLOB    10
  100. #define SUB_BLOB_SIZE 70000
  101. #define BIG_BLOB_SIZE (N_SUB_BLOB * SUB_BLOB_SIZE)
  104. static void TEST__client_1(SOCK sock)
  105. {
  106.     EIO_Status status;
  107.     size_t     n_io, n_io_done;
  108.     char       buf[TEST_BUFSIZE];
  110.     fprintf(log_fp, "[INFO] TEST__client_1(TC1)n");
  112.     /* Send a short string */
  113.     SOCK_SetDataLoggingAPI(eOn);
  114.     {{
  115. #if defined(NCBI_OS_MAC)
  116.         /* Special treatment for MAC clients -- server not to
  117.          * shutdown the socket on writing. MAC library
  118.          * mistakingly assumes that if server is shutdown on writing then
  119.          * it is shutdown on reading, too (?!). 
  120.          */
  121.         const char* x_C1 = s_M1;
  122. #else
  123.         const char* x_C1 = s_C1;
  124. #endif
  125.         n_io = strlen(x_C1) + 1;
  126.         status = SOCK_Write(sock, x_C1, n_io, &n_io_done, eIO_WritePersist);
  127.     }}
  128.     assert(status == eIO_Success  &&  n_io == n_io_done);
  130.     /* Read the string back (it must be bounced by the server) */
  131.     SOCK_SetDataLoggingAPI(eOff);
  132.     SOCK_SetDataLogging(sock, eOn);
  133.     n_io = strlen(s_S1) + 1;
  134.     status = SOCK_Read(sock, buf, n_io, &n_io_done, eIO_ReadPeek);
  135.     status = SOCK_Read(sock, buf, n_io, &n_io_done, eIO_ReadPlain);
  136.     if (status == eIO_Closed) {
  137.         fprintf(log_fp, "[WARNING] TC1:: connection closedn");
  138.         assert(0);
  139.     }
  140.     assert(status == eIO_Success  &&  n_io == n_io_done);
  141.     assert(strcmp(buf, s_S1) == 0);
  142.     assert(SOCK_PushBack(sock, buf, n_io_done) == eIO_Success);
  143.     memset(buf, 'xFF', n_io_done);
  144.     assert(SOCK_Read(sock, buf, n_io_done, &n_io_done, eIO_ReadPlain)
  145.            == eIO_Success);
  146.     assert(SOCK_Status(sock, eIO_Read) == eIO_Success);
  147.     assert(strcmp(buf, s_S1) == 0);
  149.     SOCK_SetDataLoggingAPI(eDefault);
  150.     SOCK_SetDataLogging(sock, eDefault);
  152.     /* Send a very big binary blob */
  153.     {{
  154.         size_t i;
  155.         unsigned char* blob = (unsigned char*) malloc(BIG_BLOB_SIZE);
  156.         for (i = 0;  i < BIG_BLOB_SIZE;  blob[i] = (unsigned char) i, i++)
  157.             continue;
  158.         for (i = 0;  i < 10;  i++) {
  159.             status = SOCK_Write(sock, blob + i * SUB_BLOB_SIZE, SUB_BLOB_SIZE,
  160.                                 &n_io_done, eIO_WritePersist);
  161.             assert(status == eIO_Success  &&  n_io_done==SUB_BLOB_SIZE);
  162.         }
  163.         free(blob);
  164.     }}
  166.     /* Send a very big binary blob with read on write */
  167.     /* (it must be bounced by the server) */
  168.     {{
  169.         size_t i;
  170.         unsigned char* blob = (unsigned char*) malloc(BIG_BLOB_SIZE);
  172.         SOCK_SetReadOnWrite(sock, eOn);
  174.         for (i = 0;  i < BIG_BLOB_SIZE;  blob[i] = (unsigned char) i, i++)
  175.             continue;
  176.         for (i = 0;  i < 10;  i++) {
  177.             status = SOCK_Write(sock, blob + i * SUB_BLOB_SIZE, SUB_BLOB_SIZE,
  178.                                 &n_io_done, eIO_WritePersist);
  179.             assert(status == eIO_Success  &&  n_io_done == SUB_BLOB_SIZE);
  180.         }
  181.         /* Receive back a very big binary blob, and check its content */
  182.         memset(blob,0,BIG_BLOB_SIZE);
  183.         for (i = 0;  i < 10;  i++) {
  184.             status = SOCK_Read(sock, blob + i * SUB_BLOB_SIZE, SUB_BLOB_SIZE,
  185.                                &n_io_done, eIO_ReadPersist);
  186.             assert(status == eIO_Success  &&  n_io_done == SUB_BLOB_SIZE);
  187.         }
  188.         for (n_io = 0;  n_io < BIG_BLOB_SIZE;  n_io++)
  189.             assert(blob[n_io] == (unsigned char) n_io);
  190.         free(blob);
  191.     }}
  193.     /* Try to read more data (must hit EOF as the peer is shutdown) */
  194. #if !defined(NCBI_OS_MAC)
  195.     assert(SOCK_Read(sock, buf, 1, &n_io_done, eIO_ReadPeek)
  196.            == eIO_Closed);
  197.     assert(SOCK_Status(sock, eIO_Read) == eIO_Closed);
  198.     assert(SOCK_Read(sock, buf, 1, &n_io_done, eIO_ReadPlain)
  199.            == eIO_Closed);
  200.     assert(SOCK_Status(sock, eIO_Read) == eIO_Closed);
  201. #endif
  203.     /* Shutdown on read */
  204.     assert(SOCK_Shutdown(sock, eIO_Read)  == eIO_Success);
  205.     assert(SOCK_Status  (sock, eIO_Write) == eIO_Success);
  206.     assert(SOCK_Status  (sock, eIO_Read)  == eIO_Closed);
  207.     assert(SOCK_Read    (sock, 0, 0, &n_io_done, eIO_ReadPlain) == eIO_Closed);
  208.     assert(SOCK_Read    (sock, 0, 0, &n_io_done, eIO_ReadPeek)  == eIO_Closed);
  209.     assert(SOCK_Status  (sock, eIO_Read)  == eIO_Closed);
  210.     assert(SOCK_Status  (sock, eIO_Write) == eIO_Success);
  211.     assert(SOCK_Read    (sock, buf, 1,&n_io_done,eIO_ReadPlain) == eIO_Closed);
  212.     assert(SOCK_Read    (sock, buf, 1,&n_io_done,eIO_ReadPeek)  == eIO_Closed);
  213.     assert(SOCK_Status  (sock, eIO_Read)  == eIO_Closed);
  214.     assert(SOCK_Status  (sock, eIO_Write) == eIO_Success);
  216.     /* Shutdown on write */
  217.     assert(SOCK_Shutdown(sock, eIO_Write)          == eIO_Success);
  218.     assert(SOCK_Status  (sock, eIO_Write)          == eIO_Closed);
  219.     assert(SOCK_Write   (sock, 0, 0, &n_io_done, eIO_WritePersist)
  220.                                                    == eIO_Closed);
  221.     assert(SOCK_Status  (sock, eIO_Write)          == eIO_Closed);
  222.     assert(SOCK_Write   (sock, buf, 1, &n_io_done, eIO_WritePersist)
  223.                                                    == eIO_Closed);
  224.     assert(SOCK_Status  (sock, eIO_Write)          == eIO_Closed);
  226.     /* Double shutdown should be okay */
  227.     assert(SOCK_Shutdown(sock, eIO_Read)      == eIO_Success);
  228.     assert(SOCK_Shutdown(sock, eIO_ReadWrite) == eIO_Success);
  229.     assert(SOCK_Shutdown(sock, eIO_Write)     == eIO_Success);
  230.     assert(SOCK_Status  (sock, eIO_Read)      == eIO_Closed);
  231.     assert(SOCK_Status  (sock, eIO_Write)     == eIO_Closed);
  232.     assert(SOCK_Status  (sock, eIO_ReadWrite) == eIO_InvalidArg);
  233. }
  236. static void TEST__server_1(SOCK sock)
  237. {
  238.     EIO_Status status;
  239.     size_t     n_io, n_io_done;
  240.     char       buf[TEST_BUFSIZE];
  242.     fprintf(log_fp, "[INFO] TEST__server_1(TS1)n");
  244.     /* Receive and send back a short string */
  245.     SOCK_SetDataLogging(sock, eOn);
  246.     n_io = strlen(s_C1) + 1;
  247.     status = SOCK_Read(sock, buf, n_io, &n_io_done, eIO_ReadPlain);
  248.     assert(status == eIO_Success  &&  n_io == n_io_done);
  249.     assert(strcmp(buf, s_C1) == 0  ||  strcmp(buf, s_M1) == 0);
  251. #ifdef TEST_SRV1_SHUTDOWN
  252.     return 212;
  253. #endif
  255.     SOCK_SetDataLogging(sock, eDefault);
  256.     SOCK_SetDataLoggingAPI(eOn);
  257.     n_io = strlen(s_S1) + 1;
  258.     status = SOCK_Write(sock, s_S1, n_io, &n_io_done, eIO_WritePersist);
  259.     assert(status == eIO_Success  &&  n_io == n_io_done);
  260.     SOCK_SetDataLoggingAPI(eOff);
  262.     /* Receive a very big binary blob, and check its content */
  263.     {{
  264. #define DO_LOG_SIZE    300
  265. #define DONT_LOG_SIZE  BIG_BLOB_SIZE - DO_LOG_SIZE
  266.         unsigned char* blob = (unsigned char*) malloc(BIG_BLOB_SIZE);
  268.         status = SOCK_Read(sock,blob,DONT_LOG_SIZE,&n_io_done,eIO_ReadPersist);
  269.         assert(status == eIO_Success  &&  n_io_done == DONT_LOG_SIZE);
  271.         SOCK_SetDataLogging(sock, eOn);
  272.         status = SOCK_Read(sock, blob + DONT_LOG_SIZE, DO_LOG_SIZE,
  273.                            &n_io_done, eIO_ReadPersist);
  274.         assert(status == eIO_Success  &&  n_io_done == DO_LOG_SIZE);
  275.         SOCK_SetDataLogging(sock, eDefault);
  276.         SOCK_SetDataLoggingAPI(eDefault);
  278.         for (n_io = 0;  n_io < BIG_BLOB_SIZE;  n_io++)
  279.             assert(blob[n_io] == (unsigned char) n_io);
  280.         free(blob);
  281.     }}
  283.     /* Receive a very big binary blob, and write data back */
  284.     {{
  285. #define DO_LOG_SIZE    300
  286. #define DONT_LOG_SIZE  BIG_BLOB_SIZE - DO_LOG_SIZE
  287.         unsigned char* blob = (unsigned char*) malloc(BIG_BLOB_SIZE);
  288.         int i;
  289.         for (i = 0;  i < 10;  i++) {
  290.             /*            X_SLEEP(1);*/
  291.             status = SOCK_Read(sock, blob + i * SUB_BLOB_SIZE, SUB_BLOB_SIZE,
  292.                                &n_io_done, eIO_ReadPersist);
  293.             assert(status == eIO_Success  &&  n_io_done == SUB_BLOB_SIZE);
  294.             status = SOCK_Write(sock, blob + i * SUB_BLOB_SIZE, SUB_BLOB_SIZE,
  295.                                 &n_io_done, eIO_WritePersist);
  296.             assert(status == eIO_Success  &&  n_io_done == SUB_BLOB_SIZE);
  297.         }
  298.         for (n_io = 0;  n_io < BIG_BLOB_SIZE;  n_io++)
  299.             assert(blob[n_io] == (unsigned char) n_io);
  300.         free(blob);
  301.     }}
  303.     /* Shutdown on write */
  304. #ifdef NCBI_OS_MSWIN
  305.     assert(SOCK_Shutdown(sock, eIO_ReadWrite)    == eIO_Success);
  306. #else
  307.     assert(SOCK_Shutdown(sock, eIO_Write)        == eIO_Success);
  308. #endif
  309.     assert(SOCK_Status  (sock, eIO_Write)        == eIO_Closed);
  310.     assert(SOCK_Write   (sock, 0, 0, &n_io_done, eIO_WritePersist)
  311.                                                  == eIO_Closed);
  312.     assert(SOCK_Status  (sock, eIO_Write)        == eIO_Closed);
  313. #ifdef NCBI_OS_MSWIN
  314.     assert(SOCK_Status  (sock, eIO_Read)         == eIO_Closed);
  315. #else
  316.     assert(SOCK_Status  (sock, eIO_Read)         == eIO_Success);
  317. #endif
  318. }
  321. /* More complicated randezvous test functions
  322.  *      "TEST__client_2(SOCK sock)"
  323.  *      "TEST__server_2(SOCK sock)"
  324.  */
  326. static void s_DoubleTimeout(STimeout *to) {
  327.     if (!to->sec  &&  !to->usec) {
  328.         to->usec = 1;
  329.     } else {
  330.         to->sec   = 2 * to->sec + (2 * to->usec) / 1000000;
  331.         to->usec = (2 * to->usec) % 1000000;
  332.     }
  333. }
  336. static void TEST__client_2(SOCK sock)
  337. {
  338. #define W_FIELD  10
  339. #define N_FIELD  1000
  340. #define N_REPEAT 10
  341. #define N_RECONNECT 3
  342.     EIO_Status status;
  343.     size_t     n_io, n_io_done, i;
  344.     char       buf[W_FIELD * N_FIELD + 1];
  346.     fprintf(log_fp, "[INFO] TEST__client_2(TC2)n");
  348.     /* fill out a buffer to send to server */
  349.     memset(buf, 0, sizeof(buf));
  350.     for (i = 0;  i < N_FIELD;  i++) {
  351.         sprintf(buf + i * W_FIELD, "%10lu", (unsigned long)i);
  352.     }
  354.     /* send the buffer to server, then get it back */
  355.     for (i = 0;  i < N_REPEAT;  i++) {
  356.         char        buf1[sizeof(buf)];
  357.         STimeout    w_to, r_to;
  358.         int/*bool*/ w_timeout_on = (int)(i%2); /* if to start from     */
  359.         int/*bool*/ r_timeout_on = (int)(i%3); /* zero or inf. timeout */
  360.         char*       x_buf;
  362.         /* set timeout */
  363.         w_to.sec  = 0;
  364.         w_to.usec = 0;
  365.         status = SOCK_SetTimeout(sock, eIO_Write, w_timeout_on ? &w_to : 0);
  366.         assert(status == eIO_Success);
  368. #ifdef DO_RECONNECT
  369.         /* reconnect */
  370.         if ((i % N_RECONNECT) == 0) {
  371.             size_t j = i / N_RECONNECT;
  372.             do {
  373.                 status = SOCK_Reconnect(sock, 0, 0, 0);
  374.                 fprintf(log_fp,
  375.                         "[INFO] TEST__client_2::reconnect: i=%lu, status=%sn",
  376.                         (unsigned long)i, IO_StatusStr(status));
  377.                 assert(status == eIO_Success);
  378.                 assert(SOCK_Status(sock, eIO_Read)  == eIO_Success);
  379.                 assert(SOCK_Status(sock, eIO_Write) == eIO_Success);
  381.                 /* give a break to let server reset the listening socket */
  382.                 X_SLEEP(1);
  383.             } while ( j-- );
  384.         }
  385. #endif
  387.         /* send */
  388.         x_buf = buf;
  389.         n_io = sizeof(buf);
  390.         do {
  391.             X_SLEEP(1);
  392.             status = SOCK_Write(sock, x_buf, n_io,
  393.                                 &n_io_done, eIO_WritePersist);
  394.             if (status == eIO_Closed) {
  395.                 fprintf(log_fp,
  396.                         "[ERROR] TC2::write: connection closedn");
  397.                 assert(0);
  398.             }
  399.             fprintf(log_fp, "[INFO] TC2::write "
  400.                     "i=%d, status=%7s, n_io=%5lu, n_io_done=%5lu"
  401.                     "ntimeout(%d): %5lu sec, %6lu msecn",
  402.                     (int)i, IO_StatusStr(status),
  403.                     (unsigned long)n_io, (unsigned long)n_io_done,
  404.                     (int)w_timeout_on,
  405.                     (unsigned long)w_to.sec, (unsigned long)w_to.usec);
  406.             if ( !w_timeout_on ) {
  407.                 assert(status == eIO_Success  &&  n_io_done == n_io);
  408.             } else {
  409.                 const STimeout* x_to;
  410.                 assert(status == eIO_Success  ||  status == eIO_Timeout);
  411.                 x_to = SOCK_GetTimeout(sock, eIO_Write);
  412.                 assert(w_to.sec == x_to->sec  &&  w_to.usec == x_to->usec);
  413.             }
  414.             n_io  -= n_io_done;
  415.             x_buf += n_io_done;
  416.             if (status == eIO_Timeout)
  417.                 s_DoubleTimeout(&w_to);
  418.             status = SOCK_SetTimeout(sock, eIO_Write, &w_to);
  419.             assert(status == eIO_Success);
  420.             w_timeout_on = 1/*true*/;
  421.         } while ( n_io );
  423.         /* get back the just sent data */
  424.         r_to.sec  = 0;
  425.         r_to.usec = 0;
  426.         status = SOCK_SetTimeout(sock, eIO_Read, (r_timeout_on ? &r_to : 0));
  427.         assert(status == eIO_Success);
  429.         x_buf = buf1;
  430.         n_io = sizeof(buf1);
  431.         do {
  432.             if (i%2 == 0) {
  433.                 /* peek a little piece twice and compare */
  434.                 char   xx_buf1[128], xx_buf2[128];
  435.                 size_t xx_io_done1, xx_io_done2;
  436.                 if (SOCK_Read(sock, xx_buf1, sizeof(xx_buf1), &xx_io_done1,
  437.                               eIO_ReadPeek) == eIO_Success  &&
  438.                     SOCK_Read(sock, xx_buf2, xx_io_done1, &xx_io_done2,
  439.                               eIO_ReadPeek) == eIO_Success) {
  440.                     assert(xx_io_done1 >= xx_io_done2);
  441.                     assert(memcmp(xx_buf1, xx_buf2, xx_io_done2) == 0);
  442.                 }
  443.             }
  444.             status = SOCK_Read(sock, x_buf, n_io, &n_io_done, eIO_ReadPlain);
  445.             if (status == eIO_Closed) {
  446.                 fprintf(log_fp,
  447.                         "[ERROR] TC2::read: connection closedn");
  448.                 assert(SOCK_Status(sock, eIO_Read) == eIO_Closed);
  449.                 assert(0);
  450.             }
  451.             fprintf(log_fp, "[INFO] TC2::read: "
  452.                     "i=%d, status=%7s, n_io=%5lu, n_io_done=%5lu"
  453.                     "ntimeout(%d): %5u sec, %6u usecn",
  454.                     (int)i, IO_StatusStr(status),
  455.                     (unsigned long)n_io, (unsigned long)n_io_done,
  456.                     (int)r_timeout_on, r_to.sec, r_to.usec);
  457.             if ( !r_timeout_on ) {
  458.                 assert(status == eIO_Success  &&  n_io_done > 0);
  459.             } else {
  460.                 const STimeout* x_to;
  461.                 assert(status == eIO_Success  ||  status == eIO_Timeout);
  462.                 x_to = SOCK_GetTimeout(sock, eIO_Read);
  463.                 assert(r_to.sec == x_to->sec  &&  r_to.usec == x_to->usec);
  464.             }
  466.             n_io  -= n_io_done;
  467.             x_buf += n_io_done;
  468.             if (status == eIO_Timeout)
  469.                 s_DoubleTimeout(&r_to);
  470.             status = SOCK_SetTimeout(sock, eIO_Read, &r_to);
  471.             assert(status == eIO_Success);
  472.             r_timeout_on = 1/*true*/;
  473.         } while ( n_io );
  475.         assert(memcmp(buf, buf1, sizeof(buf)) == 0);
  476.     }
  477. }
  480. static void TEST__server_2(SOCK sock, LSOCK lsock)
  481. {
  482.     EIO_Status status;
  483.     size_t     n_io, n_io_done;
  484.     char       buf[TEST_BUFSIZE];
  485.     STimeout   r_to, w_to, rc_to;
  486.     size_t     i;
  488.     fprintf(log_fp, "[INFO] TEST__server_2(TS2)n");
  490.     r_to.sec   = 0;
  491.     r_to.usec  = 0;
  492.     w_to = r_to;
  494.     rc_to.sec  = 30;
  495.     rc_to.usec = 123456;
  497.     /* goto */
  498.  l_reconnect: /* reconnection loopback */
  500.     status = SOCK_SetTimeout(sock, eIO_Read,  &r_to);
  501.     assert(status == eIO_Success);
  502.     status = SOCK_SetTimeout(sock, eIO_Write, &w_to);
  503.     assert(status == eIO_Success);
  505.     for (i = 0;  ;  i++) {
  506.         char* x_buf;
  508.         /* read data from socket */
  509.         n_io = sizeof(buf);
  510.         status = SOCK_Read(sock, buf, n_io, &n_io_done, eIO_ReadPlain);
  511.         switch ( status ) {
  512.         case eIO_Success:
  513.             fprintf(log_fp, "[INFO] TS2::read: "
  514.                     "[%lu], status=%7s, n_io=%5lu, n_io_done=%5lun",
  515.                     (unsigned long)i, IO_StatusStr(status),
  516.                     (unsigned long)n_io, (unsigned long)n_io_done);
  517.             assert(n_io_done > 0);
  518.             break;
  520.         case eIO_Closed:
  521.             fprintf(log_fp, "[INFO] TS2::read: connection closedn");
  522.             assert(SOCK_Status(sock, eIO_Read) == eIO_Closed);
  523.             /* reconnect */
  524.             if ( !lsock )
  525.                 return;
  527.             fprintf(log_fp, "[INFO] TS2:: reconnectn");
  528.             SOCK_Close(sock);
  529.             if ((status = LSOCK_Accept(lsock, &rc_to, &sock)) != eIO_Success)
  530.                 return;
  531.             assert(SOCK_Status(sock, eIO_Read) == eIO_Success);
  532.             /* !!! */
  533.             goto l_reconnect;
  535.         case eIO_Timeout:
  536.             fprintf(log_fp, "[INFO] TS2::read: "
  537.                     "[%lu] timeout expired: %5u sec, %6u usecn",
  538.                     (unsigned long)i, r_to.sec, r_to.usec);
  539.             assert(n_io_done == 0);
  540.             s_DoubleTimeout(&r_to);
  541.             status = SOCK_SetTimeout(sock, eIO_Read, &r_to);
  542.             assert(status == eIO_Success);
  543.             assert(SOCK_Status(sock, eIO_Read) == eIO_Success);
  544.             break;
  546.         default:
  547.             assert(0);
  548.             return;
  549.         } /* switch */
  551.         /* write(just the same) data back to client */
  552.         n_io  = n_io_done;
  553.         x_buf = buf;
  554.         while ( n_io ) {
  555.             status = SOCK_Write(sock, buf, n_io, &n_io_done, eIO_WritePersist);
  556.             switch ( status ) {
  557.             case eIO_Success:
  558.                 fprintf(log_fp, "[INFO] TS2::write: "
  559.                         "[%lu], status=%7s, n_io=%5lu, n_io_done=%5lun",
  560.                         (unsigned long)i, IO_StatusStr(status),
  561.                         (unsigned long)n_io, (unsigned long)n_io_done);
  562.                 assert(n_io_done > 0);
  563.                 break;
  564.             case eIO_Closed:
  565.                 fprintf(log_fp, "[ERROR] TS2::write: connection closedn");
  566.                 assert(0);
  567.                 return;
  568.             case eIO_Timeout:
  569.                 fprintf(log_fp, "[INFO] TS2::write: "
  570.                         "[%lu] timeout expired: %5u sec, %6u usecn",
  571.                         (unsigned long)i, w_to.sec, w_to.usec);
  572.                 assert(n_io_done == 0);
  573.                 s_DoubleTimeout(&w_to);
  574.                 status = SOCK_SetTimeout(sock, eIO_Write, &w_to);
  575.                 assert(status == eIO_Success);
  576.                 break;
  577.             default:
  578.                 assert(0);
  579.                 return;
  580.             } /* switch */
  582.             n_io  -= n_io_done;
  583.             x_buf += n_io_done;
  584.         }
  585.     }
  586. }
  589. /* Skeletons for the socket i/o test:
  590.  *   TEST__client(...)
  591.  *   TEST__server(...)
  592.  *   establish and close connection;  call test i/o functions like
  593.  *     TEST__[client|server]_[1|2|...] (...)
  594.  */
  595. static void TEST__client(const char*     server_host,
  596.                          unsigned short  server_port,
  597.                          const STimeout* timeout)
  598. {
  599.     SOCK       sock;
  600.     EIO_Status status;
  602.     fprintf(log_fp, "[INFO] TEST__client(host = "%s", port = %hu, ",
  603.             server_host, server_port);
  604.     if ( timeout )
  605.         fprintf(log_fp, "timeout = %u.%u)n", timeout->sec, timeout->usec);
  606.     else
  607.         fprintf(log_fp, "timeout = INFINITE)n");
  609.     /* Connect to server */
  610.     status = SOCK_Create(server_host, server_port, timeout, &sock);
  611.     assert(status == eIO_Success);
  613.     /* Test the simplest randezvous(plain request-reply)
  614.      * The two peer functions are:
  615.      *      "TEST__[client|server]_1(SOCK sock)"
  616.      */
  617.     TEST__client_1(sock);
  619.     /* Test a more complex case
  620.      * The two peer functions are:
  621.      *      "TEST__[client|server]_2(SOCK sock)"
  622.      */
  623.     TEST__client_2(sock);
  625.     /* Close connection and exit */
  626.     status = SOCK_Close(sock);
  627.     assert(status == eIO_Success  ||  status == eIO_Closed);
  628. }
  631. static void TEST__server(unsigned short port)
  632. {
  633.     LSOCK      lsock;
  634.     EIO_Status status;
  636.     fprintf(log_fp, "[INFO] TEST__server(port = %hu)n", port);
  638.     /* Create listening socket */
  639.     status = LSOCK_Create(port, 1, &lsock);
  640.     assert(status == eIO_Success);
  642.     /* Accept connections from clients and run test sessions */
  643.     for (;;) {
  644.         /* Accept connection */
  645.         SOCK sock;
  646.         status = LSOCK_Accept(lsock, NULL, &sock);
  647.         assert(status == eIO_Success);
  649.         /* Test the simplest randezvous(plain request-reply)
  650.          * The two peer functions are:
  651.          *      "TEST__[client|server]_1(SOCK sock)"
  652.          */
  653.         TEST__server_1(sock);
  655.         /* Test a more complex case
  656.          * The two peer functions are:
  657.          *      "TEST__[client|server]_2(SOCK sock)"
  658.          */
  659. #ifdef DO_RECONNECT
  660.         TEST__server_2(sock, lsock);
  661. #else
  662.         TEST__server_2(sock, 0);
  663. #endif
  665.         /* Close connection */
  666.         status = SOCK_Close(sock);
  667.         assert(status == eIO_Success  ||  status == eIO_Closed);
  669. #ifdef TEST_SRV1_ONCE
  670.         /* Close listening socket */
  671.         assert(LSOCK_Close(lsock) == eIO_Success);
  672.         /* Finish after the first session */
  673.         break;
  674. #endif
  675.     } /* for */
  676. }
  679. /* Consistency...
  680.  */
  681. #if defined(DO_SERVER)  &&  defined(DO_CLIENT)
  682. #  error "Only one of DO_SERVER, DO_CLIENT can be defined!"
  683. #endif
  686. /* Fake (printout only) MT critical section callback and data
  687.  */
  688. static char TEST_LockUserData[] = "TEST_LockUserData";
  690. #if defined(__cplusplus)
  691. extern "C" {
  692.     static int/*bool*/ TEST_LockHandler(void* user_data, EMT_Lock how);
  693.     static void        TEST_LockCleanup(void* user_data);
  694. }
  695. #endif /* __cplusplus */
  698. static int/*bool*/ TEST_LockHandler(void* user_data, EMT_Lock how)
  699. {
  700.     const char* what_str = 0;
  701.     switch ( how ) {
  702.     case eMT_Lock:
  703.         what_str = "eMT_Lock";
  704.         break;
  705.     case eMT_LockRead:
  706.         what_str = "eMT_LockRead";
  707.         break;
  708.     case eMT_Unlock:
  709.         what_str = "eMT_Unlock";
  710.         break;
  711.     }
  712.     fprintf(log_fp, "TEST_LockHandler("%s", %s)n",
  713.             user_data ? (char*)user_data : "<NULL>", what_str);
  714.     return 1/*true*/;
  715. }
  718. static void TEST_LockCleanup(void* user_data)
  719. {
  720.     fprintf(log_fp, "TEST_LockCleanup("%s")n",
  721.             user_data ? (char*)user_data : "<NULL>");
  722. }
  725. static int/*bool*/ TEST_gethostbyaddr(unsigned int host);
  727. static const char* s_ntoa(unsigned int host)
  728. {
  729.     static char buf[256];
  730.     if (SOCK_ntoa(host, buf, sizeof(buf)) != 0) {
  731.         buf[0] = '?';
  732.         buf[1] = '';
  733.     }
  734.     return buf;
  735. }
  737. static int/*bool*/ TEST_gethostbyname(const char* name)
  738. {
  739.     char         buf[256];
  740.     unsigned int host;
  742.     fprintf(log_fp, "------------n");
  744.     host = SOCK_gethostbyname(name);
  745.     fprintf(log_fp, "SOCK_gethostbyname("%s"):  0x%08X [%s]n",
  746.             name, (unsigned int) host, s_ntoa(host));
  747.     if ( !host ) {
  748.         return 0/*false*/;
  749.     }
  750.       
  751.     name = SOCK_gethostbyaddr(host, buf, sizeof(buf));
  752.     if ( name ) {
  753.         assert(name == buf);
  754.         assert(0 < strlen(buf)  &&  strlen(buf) < sizeof(buf));
  755.         fprintf(log_fp, "SOCK_gethostbyaddr(0x%08X [%s]):  "%s"n",
  756.                 (unsigned int) host, s_ntoa(host), name);
  757.     } else {
  758.         fprintf(log_fp, "SOCK_gethostbyaddr(0x%08X [%s]):  <not found>n",
  759.                 (unsigned int) host, s_ntoa(host));
  760.     }
  762.     return 1/*true*/;
  763. }
  766. static int/*bool*/ TEST_gethostbyaddr(unsigned int host)
  767. {
  768.     const char*  name;
  769.     char         buf[1024];
  771.     fprintf(log_fp, "- - - - - - -n");
  773.     name = SOCK_gethostbyaddr(host, buf, sizeof(buf));
  774.     if ( name ) {
  775.         assert(name == buf);
  776.         assert(0 < strlen(buf)  &&  strlen(buf) < sizeof(buf));
  777.         fprintf(log_fp, "SOCK_gethostbyaddr(0x%08X [%s]):  "%s"n",
  778.                 (unsigned int) host, s_ntoa(host), name);
  779.     } else {
  780.         fprintf(log_fp, "SOCK_gethostbyaddr(0x%08X [%s]):  <not found>n",
  781.                 (unsigned int) host, s_ntoa(host));
  782.         return 0/*false*/;
  783.     }
  785.     host = SOCK_gethostbyname(name);
  786.     fprintf(log_fp, "SOCK_gethostbyname("%s"):  0x%08X [%s]n",
  787.             name, (unsigned int) host, s_ntoa(host));
  788.       
  789.     return 1/*true*/;
  790. }
  793. /* Try SOCK_htonl(), SOCK_gethostbyname() and SOCK_gethostbyaddr()
  794.  */
  795. static void TEST_gethostby(void)
  796. {
  797.     fprintf(log_fp, "n===============================n");
  799.     assert( SOCK_htonl(0) == 0 );
  800.     assert( SOCK_htonl(0xFFFFFFFF) == 0xFFFFFFFF );
  802.     assert( !TEST_gethostbyname("  ") );
  803.     assert( !TEST_gethostbyname("a1....b1") );
  804.     assert( !TEST_gethostbyname("boo.foo.bar.doo") );
  806.     fprintf(log_fp, "n++++++++++++++++++++++n");
  808.     (void) TEST_gethostbyname("localhost");
  809.     (void) TEST_gethostbyname("ncbi.nlm.nih.gov");
  811.     (void) TEST_gethostbyname("127.0.0.1");
  812.     (void) TEST_gethostbyname("130.14.25.1");
  814.     (void) TEST_gethostbyaddr(0);
  815.     (void) TEST_gethostbyaddr(SOCK_gethostbyname("127.0.0.1"));
  816.     (void) TEST_gethostbyaddr(SOCK_gethostbyname("130.14.25.1"));
  817.     (void) TEST_gethostbyaddr(SOCK_gethostbyname("234.234.234.234"));
  818.     (void) TEST_gethostbyaddr(0xFFFFFFFF);
  820.     fprintf(log_fp, "n===============================n");
  821. }
  825. /* Main function
  826.  * Parse command-line options, initialize and cleanup API internals;
  827.  * run client or server test
  828.  */
  829. extern int main(int argc, char** argv)
  830. {
  831. #define MIN_PORT 5001
  832. #define DEF_PORT 5555
  833. #define DEF_HOST "localhost"
  835.     /* Error log stream */
  836.     log_fp = stderr;
  838.     /* Test client or server using hard-coded parameters */
  839. #if   defined(DO_SERVER)
  840.     argc = 2;
  841. #elif defined(DO_CLIENT)
  842.     argc = 3;
  843. #endif
  845.     /* Try to set various fake MT safety locks
  846.      */
  847.     CORE_SetLOCK( MT_LOCK_Create(0, TEST_LockHandler, TEST_LockCleanup) );
  848.     CORE_SetLOCK(0);
  849.     CORE_SetLOCK(0);
  850.     CORE_SetLOCK( MT_LOCK_Create(&TEST_LockUserData,
  851.                                  TEST_LockHandler, TEST_LockCleanup) );
  853.     /* Setup log stream
  854.      */
  855.     CORE_SetLOGFormatFlags(fLOG_None          | fLOG_Level   |
  856.                            fLOG_OmitNoteLevel | fLOG_DateTime);
  857.     CORE_SetLOGFILE(stderr, 0/*false*/);
  859.     /* Printout local hostname
  860.      */
  861.     {{
  862.         char local_host[64];
  863.         assert(SOCK_gethostname(local_host, sizeof(local_host)) == 0);
  864.         fprintf(log_fp, "[INFO] Running NCBISOCK test on host "%s"n",
  865.                 local_host);
  866.     }}
  868.     /* Parse cmd.-line args and decide whether it's a client or a server
  869.      */
  870.     switch ( argc ) {
  871.     case 2: {
  872.         /*** SERVER ***/
  873.         int port;
  875. #if defined(DO_SERVER)
  876.         port = DEF_PORT;
  877. #else
  878.         if (sscanf(argv[1], "%d", &port) != 1  ||  port < MIN_PORT)
  879.             break;
  880. #endif /* DO_SERVER */
  882.         TEST__server((unsigned short) port);
  883.         assert(SOCK_ShutdownAPI() == eIO_Success);
  884.         CORE_SetLOG(0);
  885.         CORE_SetLOCK(0);
  886.         return 0;
  887.     }
  889.     case 3: case 4: {
  890.         /*** CLIENT ***/
  891.         const char* server_host;
  892.         int         server_port;
  893.         STimeout*   timeout = 0;
  895. #if defined(DO_CLIENT)
  896.         server_host = DEF_HOST;
  897.         server_port = DEF_PORT;
  898. #else
  899.         STimeout    x_timeout;
  900.         /* host */
  901.         server_host = argv[1];
  903.         /* port */
  904.         if (sscanf(argv[2], "%d", &server_port) != 1  ||
  905.             server_port < MIN_PORT)
  906.             break;
  908.         /* timeout */
  909.         if (argc == 4) {
  910.             double tm_out = atof(argv[3]);
  911.             if (tm_out < 0)
  912.                 break;
  913.             x_timeout.sec  = (unsigned int)tm_out;
  914.             x_timeout.usec = (unsigned int)((tm_out - x_timeout.sec) *1000000);
  915.             timeout = &x_timeout;
  916.         };
  917. #endif /* DO_CLIENT */
  919.         TEST_gethostby();
  921.         TEST__client(server_host, (unsigned short)server_port, timeout);
  922.         assert(SOCK_ShutdownAPI() == eIO_Success);
  923.         CORE_SetLOG(0);
  924.         CORE_SetLOCK(0);
  925.         return 0;
  926.     }
  927.     } /* switch */
  930.     /* USAGE
  931.      */
  932.     fprintf(log_fp,
  933.             "nUSAGE:n"
  934.             "  Client: %s <srv_host> <port> [conn_timeout]n"
  935.             "  Server: %s <port>n"
  936.             " where <port> is greater than %d, and [conn_timeout] is doublen",
  937.             argv[0], argv[0], (int)MIN_PORT);
  938.     CORE_SetLOG(0);
  939.     CORE_SetLOCK(0);
  940.     return 1;
  941. }
  944. /*
  945.  * ---------------------------------------------------------------------------
  946.  * $Log: test_ncbi_socket.c,v $
  947.  * Revision 1000.0  2003/10/29 17:06:50  gouriano
  948.  * PRODUCTION: IMPORTED [ORIGINAL] Dev-tree R6.21
  949.  *
  950.  * Revision 6.21  2003/05/21 17:46:51  lavr
  951.  * Fix MSVC-related problems with SOCK_Shutdown()
  952.  *
  953.  * Revision 6.20  2003/05/14 03:58:43  lavr
  954.  * Match changes in respective APIs of the tests
  955.  *
  956.  * Revision 6.19  2002/12/04 16:58:13  lavr
  957.  * No changes
  958.  *
  959.  * Revision 6.18  2002/11/01 20:17:39  lavr
  960.  * Change hostname buffers to hold up to 256 chars
  961.  *
  962.  * Revision 6.17  2002/10/11 19:58:23  lavr
  963.  * Remove asserts() (replace with tests) for SOCK_gethostbyaddr({0|0xFFFFFFFF})
  964.  *
  965.  * Revision 6.16  2002/08/12 15:10:43  lavr
  966.  * Use persistent SOCK_Write()
  967.  *
  968.  * Revision 6.15  2002/08/07 16:38:08  lavr
  969.  * EIO_ReadMethod enums changed accordingly; log moved to end
  970.  *
  971.  * Revision 6.14  2002/03/22 19:47:48  lavr
  972.  * Test_assert.h made last among the include files
  973.  *
  974.  * Revision 6.13  2002/02/11 20:36:45  lavr
  975.  * Use "ncbi_config.h"
  976.  *
  977.  * Revision 6.12  2002/01/16 21:23:15  vakatov
  978.  * Utilize header "test_assert.h" to switch on ASSERTs in the Release mode too
  979.  *
  980.  * Revision 6.11  2001/07/11 00:44:33  vakatov
  981.  * Added TEST_gethostby***() -- tests for SOCK_gethostby{addr,name}()
  982.  *
  983.  * Revision 6.10  2001/05/21 15:11:13  ivanov
  984.  * Added test for automatic read on write data from the socket
  985.  * (stall protection).
  986.  *
  987.  * Revision 6.9  2001/01/26 23:55:10  vakatov
  988.  * [NCBI_OS_MAC]  Do not do server write shutdown for MAC client
  989.  *
  990.  * Revision 6.8  2000/11/15 18:51:44  vakatov
  991.  * Add tests for SOCK_Shutdown() and SOCK_Status().
  992.  * Use SOCK_Status() instead of SOCK_Eof().
  993.  *
  994.  * Revision 6.7  2000/06/23 19:39:22  vakatov
  995.  * Test the logging of socket I/O (incl. binary data)
  996.  *
  997.  * Revision 6.6  2000/03/24 23:12:13  vakatov
  998.  * Starting the development quasi-branch to implement CONN API.
  999.  * All development is performed in the NCBI C++ tree only, while
  1000.  * the NCBI C tree still contains "frozen" (see the last revision) code.
  1001.  *
  1002.  * Revision 6.5  2000/02/24 23:09:42  vakatov
  1003.  * Use C++ Toolkit specific wrapper "test_ncbi_socket_.c" for
  1004.  * "test_ncbi_socket.c"
  1005.  *
  1006.  * Revision 6.4  2000/02/23 22:34:37  vakatov
  1007.  * Can work both "standalone" and as a part of NCBI C++ or C toolkits
  1008.  *
  1009.  * Revision 6.3  1999/11/26 19:05:21  vakatov
  1010.  * Initialize "log_fp" in "main()"...
  1011.  *
  1012.  * Revision 6.2  1999/10/19 16:16:03  vakatov
  1013.  * Try the NCBI C and C++ headers only if NCBI_OS_{UNIX, MSWIN, MAC} is
  1014.  * not #define'd
  1015.  *
  1016.  * Revision 6.1  1999/10/18 15:40:21  vakatov
  1017.  * Initial revision
  1018.  *
  1019.  * ===========================================================================
  1020.  */