PageRenderTime 58ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

/platform/FNET/fnet_demos/common/fnet_application/fapp_bench.c

https://gitlab.com/fuggles/ucos
C | 921 lines | 609 code | 163 blank | 149 comment | 130 complexity | b657e662a449f8ad2d9560151c052021 MD5 | raw file
Possible License(s): GPL-3.0, LGPL-3.0 
    

  1. /**************************************************************************

    2. 

  2. * 

    3. 

  3. * Copyright 2011-2015 by Andrey Butok. FNET Community.

    4. 

  4. * Copyright 2008-2010 by Andrey Butok. Freescale Semiconductor, Inc.

    5. 

  5. *

    6. 

  6. ***************************************************************************

    7. 

  7. * This program is free software: you can redistribute it and/or modify

    8. 

  8. * it under the terms of the GNU Lesser General Public License Version 3 

    9. 

  9. * or later (the "LGPL").

    10. 

  10. *

    11. 

  11. * As a special exception, the copyright holders of the FNET project give you

    12. 

  12. * permission to link the FNET sources with independent modules to produce an

    13. 

  13. * executable, regardless of the license terms of these independent modules,

    14. 

  14. * and to copy and distribute the resulting executable under terms of your 

    15. 

  15. * choice, provided that you also meet, for each linked independent module,

    16. 

  16. * the terms and conditions of the license of that module.

    17. 

  17. * An independent module is a module which is not derived from or based 

    18. 

  18. * on this library. 

    19. 

  19. * If you modify the FNET sources, you may extend this exception 

    20. 

  20. * to your version of the FNET sources, but you are not obligated 

    21. 

  21. * to do so. If you do not wish to do so, delete this

    22. 

  22. * exception statement from your version.

    23. 

  23. *

    24. 

  24. * This program is distributed in the hope that it will be useful,

    25. 

  25. * but WITHOUT ANY WARRANTY; without even the implied warranty of

    26. 

  26. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

    27. 

  27. *

    28. 

  28. * You should have received a copy of the GNU General Public License

    29. 

  29. * and the GNU Lesser General Public License along with this program.

    30. 

  30. * If not, see <http://www.gnu.org/licenses/>.

    31. 

  31. *

    32. 

  32. **********************************************************************/ /*!

    33. 

  33. *

    34. 

  34. * @file fapp_bench.c

    35. 

  35. *

    36. 

  36. * @author Andrey Butok

    37. 

  37. *

    38. 

  38. * @brief FNET Shell Demo implementation.

    39. 

  39. *

    40. 

  40. ***************************************************************************/

    41. 

  41. 

    42. 

  42. #include "fnet.h"

    43. 

  43. 

    44. 

  44. #include "fapp_prv.h"

    45. 

  45. #include "fapp_bench.h"

    46. 

  46. 

    47. 

  47. #if FAPP_CFG_BENCH_CMD

    48. 

  48. 

    49. 

  49. 

    50. 

  50. /************************************************************************

    51. 

  51. * Benchmark definitions

    52. 

  52. ************************************************************************/

    53. 

  53. #define FAPP_BENCH_UDP_END_BUFFER_LENGTH    (1) 

    54. 

  54. #define FAPP_UDP_TIMEOUT_MS                 (8000)

    55. 

  55. 

    56. 

  56. /* Socket Tx&Rx buffer sizes. */

    57. 

  57. #define FAPP_BENCH_SOCKET_BUF_SIZE          (FAPP_BENCH_PACKET_SIZE_MAX)

    58. 

  58. #define FAPP_BENCH_BUFFER_SIZE              (FAPP_BENCH_PACKET_SIZE_MAX)

    59. 

  59. 

    60. 

  60. #define FAPP_BENCH_TX_UDP_END_ITERATIONS    (10)

    61. 

  61. 

    62. 

  62. 

    63. 

  63. /* Keepalive probe retransmit limit.*/

    64. 

  64. #define FAPP_BENCH_TCP_KEEPCNT              (2)

    65. 

  65. 

    66. 

  66. /* Keepalive retransmit interval.*/

    67. 

  67. #define FAPP_BENCH_TCP_KEEPINTVL            (5) /*sec*/

    68. 

  68. 

    69. 

  69. /* Time between keepalive probes.*/

    70. 

  70. #define FAPP_BENCH_TCP_KEEPIDLE             (5) /*sec*/

    71. 

  71. 

    72. 

  72. 

    73. 

  73. #define FAPP_BENCH_COMPLETED_STR            "Test completed."

    74. 

  74. 

    75. 

  75. /************************************************************************

    76. 

  76. *    Benchmark server control structure.

    77. 

  77. *************************************************************************/

    78. 

  78. struct fapp_bench_t

    79. 

  79. {

    80. 

  80.     SOCKET socket_listen;                   /* Listening socket.*/

    81. 

  81.     SOCKET socket_foreign;                  /* Foreign socket.*/

    82. 

  82.     

    83. 

  83.     char buffer[FAPP_BENCH_BUFFER_SIZE];    /* Transmit circular buffer */    

    84. 

  84.  	

    85. 

  85.  	unsigned long first_time;

    86. 

  86.  	unsigned long last_time;

    87. 

  87.  	unsigned long bytes;

    88. 

  88.  	unsigned long remote_bytes;

    89. 

  89. }; 

    90. 

  90. 

    91. 

  91. static struct fapp_bench_t fapp_bench;

    92. 

  92. 

    93. 

  93. /**************************************************************************/ /*!

    94. 

  94.  * TX benchmark parameters

    95. 

  95.  ******************************************************************************/

    96. 

  96. struct fapp_bench_tx_params

    97. 

  97. {

    98. 

  98.     fnet_shell_desc_t desc;

    99. 

  99.     struct sockaddr foreign_addr;

    100. 

  100.     int packet_size;

    101. 

  101.     int packet_number;

    102. 

  102.     int iteration_number;

    103. 

  103. };

    104. 

  104. 

    105. 

  105. /************************************************************************

    106. 

  106. *     Function Prototypes

    107. 

  107. *************************************************************************/

    108. 

  108. static void fapp_bench_print_results (fnet_shell_desc_t desc);

    109. 

  109. static void fapp_bench_tcp_rx (fnet_shell_desc_t desc, fnet_address_family_t family);

    110. 

  110. static void fapp_bench_udp_rx (fnet_shell_desc_t desc, fnet_address_family_t family, struct sockaddr *multicast_address /* optional, set to 0*/);

    111. 

  111. static void fapp_bench_tcp_tx (struct fapp_bench_tx_params *params);

    112. 

  112. static void fapp_bench_udp_tx (struct fapp_bench_tx_params *params);

    113. 

  113. 

    114. 

  114. /************************************************************************

    115. 

  115. * NAME: fapp_bench_print_results

    116. 

  116. *

    117. 

  117. * DESCRIPTION: Print Benchmark results. 

    118. 

  118. ************************************************************************/

    119. 

  119. static void fapp_bench_print_results (fnet_shell_desc_t desc)

    120. 

  120. {

    121. 

  121. /* Print benchmark results.*/

    122. 

  122.     unsigned long interval = fnet_timer_get_interval(fapp_bench.first_time, fapp_bench.last_time);

    123. 

  123.     

    124. 

  124.     fnet_shell_println(desc, "Results:");

    125. 

  125.     

    126. 

  126.     if(fapp_bench.remote_bytes == 0)

    127. 

  127.     {

    128. 

  128.         fnet_shell_println(desc, "\t%d bytes in %d.%d seconds = %d Kbits/sec\n", fapp_bench.bytes, 

    129. 

  129.             ((interval*FNET_TIMER_PERIOD_MS)/1000),

    130. 

  130.             ((interval*FNET_TIMER_PERIOD_MS)%1000)/100,

    131. 

  131.             (interval == 0) ? -1 : (int)((fapp_bench.bytes*8/**(1000*//FNET_TIMER_PERIOD_MS/*)*/)/interval)/*/1000*/); 

    132. 

  132.     }

    133. 

  133.     else /* UDP TX only */

    134. 

  134.     {

    135. 

  135.         fnet_shell_println(desc, "\t%d [%d] bytes in %d.%d seconds = %d [%d] Kbits/sec\n", fapp_bench.bytes, fapp_bench.remote_bytes, 

    136. 

  136.             ((interval*FNET_TIMER_PERIOD_MS)/1000),

    137. 

  137.             ((interval*FNET_TIMER_PERIOD_MS)%1000)/100,

    138. 

  138.             (interval == 0) ? -1 : (int)((fapp_bench.bytes*8/**(1000*//FNET_TIMER_PERIOD_MS/*)*/)/interval)/*/1000*/,

    139. 

  139.             (interval == 0) ? -1 : (int)((fapp_bench.remote_bytes*8/**(1000*//FNET_TIMER_PERIOD_MS/*)*/)/interval)/*/1000*/);     

    140. 

  140.     }

    141. 

  141. }

    142. 

  142. 

    143. 

  143. /************************************************************************

    144. 

  144. * NAME: fapp_bench_tcp_rx

    145. 

  145. *

    146. 

  146. * DESCRIPTION: Start Benchmark TCP server. 

    147. 

  147. ************************************************************************/

    148. 

  148. static void fapp_bench_tcp_rx (fnet_shell_desc_t desc, fnet_address_family_t family)

    149. 

  149. {

    150. 

  150.     struct sockaddr     local_addr;

    151. 

  151.     int                 received;

    152. 

  152.     char                ip_str[FNET_IP_ADDR_STR_SIZE];

    153. 

  153.     struct linger       linger_option ={1, /*l_onoff*/

    154. 

  154.                                         4  /*l_linger*/};

    155. 

  155.     unsigned long       bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;

    156. 

  156.     int                 keepalive_option = 1;

    157. 

  157.     int                 keepcnt_option = FAPP_BENCH_TCP_KEEPCNT;

    158. 

  158.     int                 keepintvl_option = FAPP_BENCH_TCP_KEEPINTVL;

    159. 

  159.     int                 keepidle_option = FAPP_BENCH_TCP_KEEPIDLE;

    160. 

  160.     struct sockaddr     foreign_addr;

    161. 

  161.     unsigned int        addr_len;

    162. 

  162.     int                 exit_flag = 0;

    163. 

  163. 	

    164. 

  164.     

    165. 

  165.     fapp_bench.socket_foreign = SOCKET_INVALID;

    166. 

  166.     

    167. 

  167. 	/* Create listen socket */

    168. 

  168.     if((fapp_bench.socket_listen = socket(family, SOCK_STREAM, 0)) == SOCKET_INVALID)

    169. 

  169.     {

    170. 

  170.         FNET_DEBUG("BENCH: Socket creation error.");

    171. 

  171.         goto ERROR_1;

    172. 

  172.     }

    173. 

  173.     

    174. 

  174.     /* Bind socket.*/

    175. 

  175.     fnet_memset_zero(&local_addr, sizeof(local_addr));

    176. 

  176.     

    177. 

  177.     local_addr.sa_port = FAPP_BENCH_PORT;    

    178. 

  178.     local_addr.sa_family = family;

    179. 

  179.     

    180. 

  180.     if(bind(fapp_bench.socket_listen, &local_addr, sizeof(local_addr)) == SOCKET_ERROR)

    181. 

  181.     {

    182. 

  182.         FNET_DEBUG("BENCH: Socket bind error.");

    183. 

  183.         goto ERROR_2;

    184. 

  184.     }

    185. 

  185. 

    186. 

  186.     /* Set Socket options. */

    187. 

  187.     if( /* Setup linger option. */

    188. 

  188.         (setsockopt (fapp_bench.socket_listen, SOL_SOCKET, SO_LINGER, (char *)&linger_option, sizeof(linger_option)) == SOCKET_ERROR) ||

    189. 

  189.         /* Set socket buffer size. */

    190. 

  190.         (setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_RCVBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||

    191. 

  191.         (setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_SNDBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||

    192. 

  192.         /* Enable keepalive_option option. */

    193. 

  193.         (setsockopt (fapp_bench.socket_listen, SOL_SOCKET, SO_KEEPALIVE, (char *)&keepalive_option, sizeof(keepalive_option)) == SOCKET_ERROR) ||

    194. 

  194.         /* Keepalive probe retransmit limit. */

    195. 

  195.         (setsockopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPCNT, (char *)&keepcnt_option, sizeof(keepcnt_option)) == SOCKET_ERROR) ||

    196. 

  196.         /* Keepalive retransmit interval.*/

    197. 

  197.         (setsockopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPINTVL, (char *)&keepintvl_option, sizeof(keepintvl_option)) == SOCKET_ERROR) ||

    198. 

  198.         /* Time between keepalive probes.*/

    199. 

  199.         (setsockopt (fapp_bench.socket_listen, IPPROTO_TCP, TCP_KEEPIDLE, (char *)&keepidle_option, sizeof(keepidle_option)) == SOCKET_ERROR)

    200. 

  200.       )

    201. 

  201.     {

    202. 

  202.         FNET_DEBUG("BENCH: Socket setsockopt error.\n");

    203. 

  203.         goto ERROR_2;		

    204. 

  204.     }

    205. 

  205.     

    206. 

  206.     /* Listen. */

    207. 

  207.     if(listen(fapp_bench.socket_listen, 1) == SOCKET_ERROR)

    208. 

  208.     {

    209. 

  209.         FNET_DEBUG("BENCH: Socket listen error.\n");

    210. 

  210.         goto ERROR_2;

    211. 

  211.     }

    212. 

  212.     

    213. 

  213.     /* ------ Start test.----------- */

    214. 

  214.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    215. 

  215.     fnet_shell_println(desc, " TCP RX Test");

    216. 

  216.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    217. 

  217.     fapp_netif_addr_print(desc, family, fapp_default_netif, FNET_FALSE);

    218. 

  218.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Local Port", FNET_NTOHS(FAPP_BENCH_PORT));

    219. 

  219.     fnet_shell_println(desc, FAPP_TOCANCEL_STR);

    220. 

  220.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    221. 

  221.     

    222. 

  222.     while(exit_flag == 0)

    223. 

  223.     {

    224. 

  224.         fnet_shell_println(desc, "Waiting.");

    225. 

  225.         

    226. 

  226.         fapp_bench.bytes = 0;

    227. 

  227.         fapp_bench.remote_bytes = 0;

    228. 

  228.         if(fapp_bench.socket_foreign != SOCKET_INVALID)

    229. 

  229.         {

    230. 

  230.             closesocket(fapp_bench.socket_foreign);

    231. 

  231.             fapp_bench.socket_foreign = SOCKET_INVALID;

    232. 

  232.         }

    233. 

  233.         

    234. 

  234.         while((fapp_bench.socket_foreign == SOCKET_INVALID) && (exit_flag == 0))

    235. 

  235.         {

    236. 

  236.             /*Accept*/

    237. 

  237.             addr_len = sizeof(foreign_addr);

    238. 

  238.             fapp_bench.socket_foreign = accept(fapp_bench.socket_listen, &foreign_addr, &addr_len);

    239. 

  239.             

    240. 

  240.    

    241. 

  241.             exit_flag = fnet_shell_ctrlc (desc);

    242. 

  242.                     

    243. 

  243.             if(fapp_bench.socket_foreign != SOCKET_INVALID)

    244. 

  244.             {

    245. 

  245.    

    246. 

  246.                 fnet_shell_println(desc,"Receiving from %s:%d", fnet_inet_ntop(foreign_addr.sa_family, (char*)(foreign_addr.sa_data), ip_str, sizeof(ip_str)), fnet_ntohs(foreign_addr.sa_port));

    247. 

  247.                           

    248. 

  248.                 fapp_bench.first_time = fnet_timer_ticks();

    249. 

  249. 

    250. 

  250.                 while(1) /* Receiving data.*/

    251. 

  251.                 {

    252. 

  252.                     received = recv(fapp_bench.socket_foreign, (char*)(&fapp_bench.buffer[0]), FAPP_BENCH_BUFFER_SIZE, 0);

    253. 

  253.                     

    254. 

  254.                     if ((received == SOCKET_ERROR) || exit_flag)

    255. 

  255.                     {              

    256. 

  256.                         fapp_bench.last_time = fnet_timer_ticks();

    257. 

  257.                         

    258. 

  258.                         /* Print benchmark results.*/

    259. 

  259.                         fapp_bench_print_results (desc);           			

    260. 

  260.                         break;

    261. 

  261.                     }

    262. 

  262.                     else

    263. 

  263.                     {

    264. 

  264.                         fapp_bench.bytes += received;

    265. 

  265.                     }

    266. 

  266.                     

    267. 

  267.                     exit_flag = fnet_shell_ctrlc (desc); /* Check [Ctrl+c]*/

    268. 

  268.                 }

    269. 

  269.             }

    270. 

  270.         }

    271. 

  271.     }

    272. 

  272. 

    273. 

  273.     closesocket(fapp_bench.socket_foreign);

    274. 

  274.     

    275. 

  275. ERROR_2:

    276. 

  276.     closesocket(fapp_bench.socket_listen);

    277. 

  277. 

    278. 

  278. ERROR_1:

    279. 

  279.  

    280. 

  280.     fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);

    281. 

  281. }

    282. 

  282. 

    283. 

  283. /************************************************************************

    284. 

  284. * NAME: fapp_bench_udp_rx

    285. 

  285. *

    286. 

  286. * DESCRIPTION: Start Benchmark UDP server. 

    287. 

  287. ************************************************************************/

    288. 

  288. static void fapp_bench_udp_rx (fnet_shell_desc_t desc, fnet_address_family_t family, struct sockaddr *multicast_address /* optional, set to 0*/)

    289. 

  289. {

    290. 

  290. 	struct sockaddr         local_addr;

    291. 

  291. 	const unsigned long     bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;

    292. 

  292. 	int                     received;

    293. 

  293. 	char                    ip_str[FNET_IP_ADDR_STR_SIZE];

    294. 

  294. 	struct sockaddr         addr;

    295. 

  295.     unsigned int            addr_len;

    296. 

  296. 	int                     is_first = 1;

    297. 

  297. 	int                     exit_flag = 0;

    298. 

  298. 	

    299. 

  299. 

    300. 

  300. 	/* Create listen socket */

    301. 

  301.     if((fapp_bench.socket_listen = socket(family, SOCK_DGRAM, 0)) == SOCKET_INVALID)

    302. 

  302.     {

    303. 

  303.         FNET_DEBUG("BENCH: Socket creation error.\n");

    304. 

  304.         goto ERROR_1;

    305. 

  305.     }

    306. 

  306.     

    307. 

  307.     /*Bind.*/

    308. 

  308.     fnet_memset_zero(&local_addr, sizeof(local_addr));

    309. 

  309.     

    310. 

  310.     local_addr.sa_port = FAPP_BENCH_PORT;    

    311. 

  311.     local_addr.sa_family = family;

    312. 

  312.     

    313. 

  313.     if(bind(fapp_bench.socket_listen, &local_addr, sizeof(local_addr)) == SOCKET_ERROR)

    314. 

  314.     {

    315. 

  315.         FNET_DEBUG("BENCH: Socket bind error.\n");

    316. 

  316.         goto ERROR_2;

    317. 

  317.     }

    318. 

  318. 

    319. 

  319. 

    320. 

  320. 	/* Set socket options. */    

    321. 

  321. 	if( 

    322. 

  322. 		/* Set socket buffer size. */

    323. 

  323. 		(setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_RCVBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||

    324. 

  324. 		(setsockopt(fapp_bench.socket_listen, SOL_SOCKET, SO_SNDBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) 

    325. 

  325. 	)

    326. 

  326. 	{

    327. 

  327.     	FNET_DEBUG("BENCH: Socket setsockopt error.\n");

    328. 

  328.         goto ERROR_2;		

    329. 

  329. 	}

    330. 

  330.     

    331. 

  331.     /* Join multicast group, if set. */

    332. 

  332.     if(multicast_address)

    333. 

  333.     {

    334. 

  334.     

    335. 

  335.     #if FNET_CFG_IP4

    336. 

  336.         if(multicast_address->sa_family == AF_INET)

    337. 

  337.         {

    338. 

  338.             struct ip_mreq mreq; /* Multicast group information.*/

    339. 

  339.             

    340. 

  340.             mreq.imr_multiaddr.s_addr = ((struct sockaddr_in*)multicast_address)->sin_addr.s_addr;

    341. 

  341.             mreq.imr_interface.s_addr = FNET_HTONL(INADDR_ANY); /* Default Interface.*/

    342. 

  342.             

    343. 

  343.             /* Join multicast group. */

    344. 

  344.             if(setsockopt(fapp_bench.socket_listen, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *)&mreq, sizeof(mreq)) == SOCKET_ERROR) 

    345. 

  345.     	    {

    346. 

  346.             	FNET_DEBUG("BENCH: Joining to multicast group is failed.\n");

    347. 

  347.                 goto ERROR_2;		

    348. 

  348.         	}

    349. 

  349.     	}

    350. 

  350.     #endif

    351. 

  351.     #if FNET_CFG_IP6

    352. 

  352.         if(multicast_address->sa_family == AF_INET6)

    353. 

  353.         {

    354. 

  354.             struct ipv6_mreq mreq6; /* Multicast group information.*/

    355. 

  355.             

    356. 

  356.             FNET_IP6_ADDR_COPY(&((struct sockaddr_in6*)multicast_address)->sin6_addr.s6_addr, &mreq6.ipv6imr_multiaddr.s6_addr);

    357. 

  357.             mreq6.ipv6imr_interface = ((struct sockaddr_in6*)multicast_address)->sin6_scope_id;

    358. 

  358.             

    359. 

  359.             /* Join multicast group. */

    360. 

  360.             if(setsockopt(fapp_bench.socket_listen, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *)&mreq6, sizeof(mreq6)) == SOCKET_ERROR) 

    361. 

  361.     	    {

    362. 

  362.             	FNET_DEBUG("BENCH: Joining to multicast group is failed.\n");

    363. 

  363.                 goto ERROR_2;		

    364. 

  364.         	}

    365. 

  365.         }

    366. 

  366.     #endif    	

    367. 

  367.         

    368. 

  368.     }

    369. 

  369.     

    370. 

  370.      /* ------ Start test.----------- */

    371. 

  371.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    372. 

  372.     fnet_shell_println(desc, " UDP RX Test" );

    373. 

  373.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    374. 

  374.     fapp_netif_addr_print(desc, family, fapp_default_netif, FNET_FALSE);

    375. 

  375.     if(multicast_address)

    376. 

  376.     {

    377. 

  377.         fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Multicast Group", fnet_inet_ntop(multicast_address->sa_family, (char*)(multicast_address->sa_data), ip_str, sizeof(ip_str)) );

    378. 

  378.     }       

    379. 

  379.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Local Port", FNET_NTOHS(FAPP_BENCH_PORT));

    380. 

  380.     fnet_shell_println(desc, FAPP_TOCANCEL_STR);

    381. 

  381.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    382. 

  382.   

    383. 

  383.     

    384. 

  384.     while(exit_flag == 0) /* Main loop */

    385. 

  385.     {

    386. 

  386.         fnet_shell_println(desc, "Waiting.");

    387. 

  387.         

    388. 

  388.         fapp_bench.bytes = 0;

    389. 

  389.         fapp_bench.remote_bytes = 0;

    390. 

  390.         addr_len = sizeof(addr);

    391. 

  391.         is_first = 1;

    392. 

  392.         

    393. 

  393.         while(exit_flag == 0) /* Test loop. */

    394. 

  394.         {

    395. 

  395. 

    396. 

  396.     		/* Receive data */

    397. 

  397.             received = recvfrom  (fapp_bench.socket_listen, (char*)(&fapp_bench.buffer[0]), FAPP_BENCH_BUFFER_SIZE, 0,

    398. 

  398.                                 &addr, &addr_len );

    399. 

  399. 

    400. 

  400.             if(received >= FAPP_BENCH_UDP_END_BUFFER_LENGTH)

    401. 

  401.             {   

    402. 

  402.       

    403. 

  403.                 /* Reset timeout. */

    404. 

  404.                 fapp_bench.last_time = fnet_timer_ticks();

    405. 

  405.                 

    406. 

  406.                 if(is_first)

    407. 

  407.                 {

    408. 

  408.                     if( received > FAPP_BENCH_UDP_END_BUFFER_LENGTH )

    409. 

  409.                     {

    410. 

  410.                         fnet_shell_println(desc,"Receiving from %s:%d",  fnet_inet_ntop(addr.sa_family, (char*)(addr.sa_data), ip_str, sizeof(ip_str)), fnet_ntohs(addr.sa_port));

    411. 

  411.                         fapp_bench.first_time = fnet_timer_ticks();

    412. 

  412.                         is_first = 0;

    413. 

  413.                     }

    414. 

  414.                 }

    415. 

  415.                 else

    416. 

  416.                 {

    417. 

  417.                     if(received == FAPP_BENCH_UDP_END_BUFFER_LENGTH ) /* End of transfer. */

    418. 

  418.                     {

    419. 

  419.                         /* Send ACK containing amount of received data.*/

    420. 

  420.                         unsigned long ack_bytes = fnet_htonl(fapp_bench.bytes);

    421. 

  421.                         

    422. 

  422.                         /* Send several times, just to be sure that it is received/not lost.*/

    423. 

  423.                         sendto(fapp_bench.socket_listen, (char*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));

    424. 

  424.                         sendto(fapp_bench.socket_listen, (char*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));

    425. 

  425.                         sendto(fapp_bench.socket_listen, (char*)(&ack_bytes), sizeof(ack_bytes), 0, (struct sockaddr*)&addr, sizeof(addr));

    426. 

  426.                         

    427. 

  427.                         

    428. 

  428.                         /* Print benchmark results.*/

    429. 

  429.                         fapp_bench_print_results (desc);           		

    430. 

  430.     					

    431. 

  431.                         break;    	

    432. 

  432.                     }

    433. 

  433.                     else

    434. 

  434.                         fapp_bench.bytes += received; 

    435. 

  435.                 }

    436. 

  436.             }

    437. 

  437.             else

    438. 

  438.             {

    439. 

  439.                 /* Check error. Check timeout */

    440. 

  440.                 if(received == SOCKET_ERROR)

    441. 

  441.                 {

    442. 

  442.                     fnet_shell_println(desc, "BENCH: Error (%d).", fnet_error_get());                   

    443. 

  443.                     break;

    444. 

  444.                 }

    445. 

  445.                 /* Check timeout. */

    446. 

  446.                 if((is_first == 0) &&

    447. 

  447.                     (fnet_timer_get_interval(fapp_bench.last_time, fnet_timer_ticks()) > (FAPP_UDP_TIMEOUT_MS/FNET_TIMER_PERIOD_MS)))

    448. 

  448.                 {

    449. 

  449.                     fnet_shell_println(desc, "BENCH: Exit on timeout.");

    450. 

  450.                     fapp_bench_print_results (desc);            

    451. 

  451.                     break;

    452. 

  452.                 }

    453. 

  453.             }

    454. 

  454.             

    455. 

  455.             exit_flag = fnet_shell_ctrlc (desc);

    456. 

  456.         }

    457. 

  457.     }

    458. 

  458. 

    459. 

  459. ERROR_2:

    460. 

  460.     closesocket(fapp_bench.socket_listen);

    461. 

  461. 

    462. 

  462. ERROR_1:

    463. 

  463.  

    464. 

  464.     fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);

    465. 

  465. }

    466. 

  466. 

    467. 

  467. /************************************************************************

    468. 

  468. * NAME: fapp_benchrx_cmd

    469. 

  469. *

    470. 

  470. * DESCRIPTION: Start RX Benchmark server. 

    471. 

  471. ************************************************************************/

    472. 

  472. void fapp_benchrx_cmd( fnet_shell_desc_t desc, int argc, char ** argv )

    473. 

  473. {

    474. 

  474.     fnet_address_family_t family;

    475. 

  475. 

    476. 

  476.     family = AF_SUPPORTED;            

    477. 

  477.         

    478. 

  478.     /* TCP */

    479. 

  479.     if((argc == 1)||(argc == 2 && fnet_strcasecmp("tcp", argv[1]) == 0)) 

    480. 

  480.     {

    481. 

  481.         fapp_bench_tcp_rx(desc, family);

    482. 

  482.     }

    483. 

  483.     /* UDP */

    484. 

  484.     else if(((argc == 2) || (argc == 3)) && fnet_strcasecmp("udp", argv[1]) == 0) 

    485. 

  485.     {

    486. 

  486.         struct sockaddr multicast_address;

    487. 

  487.         struct sockaddr *multicast_address_p = FNET_NULL;

    488. 

  488.        

    489. 

  489.         if(argc == 3) /* Multicast group address.*/

    490. 

  490.         {

    491. 

  491.             if((fnet_inet_ptos(argv[2], &multicast_address) == FNET_ERR)    /* Convert from string to address.*/

    492. 

  492.                 || !fnet_socket_addr_is_multicast(&multicast_address)       /* Check if address is multicast.*/

    493. 

  493.                 || !(family & multicast_address.sa_family) )                /* Check supported family.*/

    494. 

  494.             {

    495. 

  495.                 fnet_shell_println(desc, FAPP_PARAM_ERR, argv[2]);

    496. 

  496.                 return;

    497. 

  497.             }   

    498. 

  498.             

    499. 

  499.             multicast_address_p = &multicast_address;

    500. 

  500.         }

    501. 

  501.         

    502. 

  502.         fapp_bench_udp_rx(desc, family, multicast_address_p);

    503. 

  503.     }

    504. 

  504.     else

    505. 

  505.     {

    506. 

  506.         fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);

    507. 

  507.     }

    508. 

  508. }

    509. 

  509. 

    510. 

  510. ////////////////////////////////////////////// TX //////////////////////////////////////

    511. 

  511. /************************************************************************

    512. 

  512. * NAME: fapp_bench_tcp_tx

    513. 

  513. *

    514. 

  514. * DESCRIPTION: Start TX TCP Benchmark. 

    515. 

  515. ************************************************************************/

    516. 

  516. static void fapp_bench_tcp_tx (struct fapp_bench_tx_params *params)

    517. 

  517. {

    518. 

  518.     int                     send_result;

    519. 

  519.     char                    ip_str[FNET_IP_ADDR_STR_SIZE];

    520. 

  520.     const struct linger     linger_option ={1, /*l_onoff*/

    521. 

  521.                                             4  /*l_linger*/};

    522. 

  522.     const unsigned long     bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;

    523. 

  523.     const int               keepalive_option = 1;

    524. 

  524.     const int               keepcnt_option = FAPP_BENCH_TCP_KEEPCNT;

    525. 

  525.     const int               keepintvl_option = FAPP_BENCH_TCP_KEEPINTVL;

    526. 

  526.     const int               keepidle_option = FAPP_BENCH_TCP_KEEPIDLE;

    527. 

  527.     struct sockaddr         foreign_addr;

    528. 

  528.     int                     exit_flag = 0;

    529. 

  529.     int                     sock_err ;

    530. 

  530.     unsigned int            option_len;

    531. 

  531.     fnet_shell_desc_t       desc = params->desc;

    532. 

  532.     fnet_socket_state_t     connection_state;

    533. 

  533.     int                     packet_size = params->packet_size;

    534. 

  534.     int                     cur_packet_number;

    535. 

  535.     int                     buffer_offset;

    536. 

  536.     int                     iterations = params->iteration_number;

    537. 

  537.     fnet_address_family_t   family = params->foreign_addr.sa_family; 

    538. 

  538. 	

    539. 

  539.     if(packet_size > FAPP_BENCH_BUFFER_SIZE) /* Check max size.*/

    540. 

  540. 	     packet_size = FAPP_BENCH_BUFFER_SIZE;

    541. 

  541. 	

    542. 

  542.     

    543. 

  543.     fapp_bench.socket_listen = SOCKET_INVALID;

    544. 

  544.     

    545. 

  545.     /* ------ Start test.----------- */

    546. 

  546.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    547. 

  547.     fnet_shell_println(desc, " TCP TX Test" );

    548. 

  548.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    549. 

  549.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Remote IP Addr", fnet_inet_ntop(family, params->foreign_addr.sa_data, ip_str, sizeof(ip_str)));

    550. 

  550.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Remote Port", fnet_ntohs(params->foreign_addr.sa_port));

    551. 

  551.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Message Size", params->packet_size);

    552. 

  552.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Num. of messages", params->packet_number);

    553. 

  553.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Num. of iterations", params->iteration_number);

    554. 

  554.     fnet_shell_println(desc, FAPP_TOCANCEL_STR);

    555. 

  555.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    556. 

  556.     

    557. 

  557.     

    558. 

  558.     while(iterations--)

    559. 

  559.     {

    560. 

  560.         /* Create socket */

    561. 

  561.         if((fapp_bench.socket_foreign = socket(family, SOCK_STREAM, 0)) == SOCKET_INVALID)

    562. 

  562.         {

    563. 

  563.             FNET_DEBUG("BENCH: Socket creation error.\n");

    564. 

  564.             iterations = 0;

    565. 

  565.             goto ERROR_1;

    566. 

  566.         }

    567. 

  567.         

    568. 

  568.         /* Set Socket options. */

    569. 

  569.         if( /* Setup linger option. */

    570. 

  570.             (setsockopt (fapp_bench.socket_foreign, SOL_SOCKET, SO_LINGER, (char *)&linger_option, sizeof(linger_option)) == SOCKET_ERROR) ||

    571. 

  571.             /* Set socket buffer size. */

    572. 

  572.             (setsockopt(fapp_bench.socket_foreign, SOL_SOCKET, SO_RCVBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||

    573. 

  573.             (setsockopt(fapp_bench.socket_foreign, SOL_SOCKET, SO_SNDBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||

    574. 

  574.             /* Enable keepalive_option option. */

    575. 

  575.             (setsockopt (fapp_bench.socket_foreign, SOL_SOCKET, SO_KEEPALIVE, (char *)&keepalive_option, sizeof(keepalive_option)) == SOCKET_ERROR) ||

    576. 

  576.             /* Keepalive probe retransmit limit. */

    577. 

  577.             (setsockopt (fapp_bench.socket_foreign, IPPROTO_TCP, TCP_KEEPCNT, (char *)&keepcnt_option, sizeof(keepcnt_option)) == SOCKET_ERROR) ||

    578. 

  578.             /* Keepalive retransmit interval.*/

    579. 

  579.             (setsockopt (fapp_bench.socket_foreign, IPPROTO_TCP, TCP_KEEPINTVL, (char *)&keepintvl_option, sizeof(keepintvl_option)) == SOCKET_ERROR) ||

    580. 

  580.             /* Time between keepalive probes.*/

    581. 

  581.             (setsockopt (fapp_bench.socket_foreign, IPPROTO_TCP, TCP_KEEPIDLE, (char *)&keepidle_option, sizeof(keepidle_option)) == SOCKET_ERROR)

    582. 

  582.           )

    583. 

  583.         {

    584. 

  584.             FNET_DEBUG("BENCH: Socket setsockopt error.\n");

    585. 

  585.             iterations = 0;

    586. 

  586.             goto ERROR_2;		

    587. 

  587.         }

    588. 

  588.     

    589. 

  589.         /* Connect to the server.*/

    590. 

  590.         fnet_shell_println(desc,"Connecting.");

    591. 

  591. 

    592. 

  592.         foreign_addr = params->foreign_addr;

    593. 

  593.         

    594. 

  594.         connect(fapp_bench.socket_foreign, (struct sockaddr *)(&foreign_addr), sizeof(foreign_addr)); 

    595. 

  595.         

    596. 

  596.         do

    597. 

  597.         {

    598. 

  598.             option_len = sizeof(connection_state); 

    599. 

  599.             getsockopt(fapp_bench.socket_foreign, SOL_SOCKET, SO_STATE, (char*)&connection_state, &option_len);

    600. 

  600.         }

    601. 

  601.         while (connection_state == SS_CONNECTING);

    602. 

  602.         

    603. 

  603.         if(connection_state != SS_CONNECTED)

    604. 

  604.         {

    605. 

  605.            fnet_shell_println(desc, "Connection failed.");

    606. 

  606.            iterations = 0;

    607. 

  607.            goto ERROR_2;

    608. 

  608.         } 

    609. 

  609.         

    610. 

  610.         /* Sending.*/

    611. 

  611.         fnet_shell_println(desc,"Sending."); 

    612. 

  612.         fapp_bench.bytes = 0;

    613. 

  613.         fapp_bench.remote_bytes = 0;

    614. 

  614.         cur_packet_number = 0;

    615. 

  615.         buffer_offset = 0;

    616. 

  616.         

    617. 

  617.         fapp_bench.first_time = fnet_timer_ticks();

    618. 

  618.         

    619. 

  619.         while(1)

    620. 

  620.         {

    621. 

  621.             send_result = send( fapp_bench.socket_foreign, (char*)(&fapp_bench.buffer[buffer_offset]), (packet_size-buffer_offset), 0);

    622. 

  622.             fapp_bench.last_time = fnet_timer_ticks();

    623. 

  623.              

    624. 

  624.             if ( send_result == SOCKET_ERROR )

    625. 

  625.             {              

    626. 

  626.                 option_len = sizeof(sock_err); 

    627. 

  627.                 getsockopt(fapp_bench.socket_foreign, SOL_SOCKET, SO_ERROR, (char*)&sock_err, &option_len);

    628. 

  628.                 fnet_shell_println(desc, "Socket error = %d", sock_err);

    629. 

  629.                 

    630. 

  630.                 iterations = 0;

    631. 

  631.                 #if 0

    632. 

  632.                     /* Print benchmark results.*/

    633. 

  633.                     fapp_bench_print_results (desc);           			

    634. 

  634.                 #endif

    635. 

  635.                 break;

    636. 

  636.             }

    637. 

  637.             else if(send_result)

    638. 

  638.             {

    639. 

  639.                 fapp_bench.bytes += send_result;

    640. 

  640.                 buffer_offset += send_result;

    641. 

  641.                 

    642. 

  642.                 if(buffer_offset == packet_size)

    643. 

  643.                 {

    644. 

  644.                     cur_packet_number ++;

    645. 

  645.                     buffer_offset = 0;

    646. 

  646.                 }

    647. 

  647.                 

    648. 

  648.                 exit_flag = fnet_shell_ctrlc(desc); /* Check [Ctrl+c]*/

    649. 

  649.                 

    650. 

  650.                 if((cur_packet_number >= params->packet_number)|| exit_flag)

    651. 

  651.                 { 

    652. 

  652.                     if(exit_flag)

    653. 

  653.                     {

    654. 

  654.                         fnet_shell_println(desc, FAPP_SHELL_CANCELED_CTRL_C);

    655. 

  655.                         iterations = 0;

    656. 

  656.                     }

    657. 

  657.                     /* Print benchmark results.*/

    658. 

  658.                     fapp_bench_print_results (desc);

    659. 

  659.                     break;

    660. 

  660.                 }

    661. 

  661.             }

    662. 

  662.         }

    663. 

  663. 

    664. 

  664. ERROR_2:

    665. 

  665.         closesocket(fapp_bench.socket_foreign);

    666. 

  666.     }

    667. 

  667. ERROR_1:

    668. 

  668.     fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);

    669. 

  669. }

    670. 

  670. 

    671. 

  671. /************************************************************************

    672. 

  672. * NAME: fapp_bench_udp_tx

    673. 

  673. *

    674. 

  674. * DESCRIPTION: Start TX TCP Benchmark. 

    675. 

  675. ************************************************************************/

    676. 

  676. static void fapp_bench_udp_tx (struct fapp_bench_tx_params *params)

    677. 

  677. {

    678. 

  678. 	int                     send_result;

    679. 

  679. 	char                    ip_str[FNET_IP_ADDR_STR_SIZE];

    680. 

  680. 	int                     i;

    681. 

  681. 	int                     received;

    682. 

  682.     const struct linger     linger_option ={1, /*l_onoff*/

    683. 

  683.                                             4  /*l_linger*/};

    684. 

  684.     const unsigned long     bufsize_option = FAPP_BENCH_SOCKET_BUF_SIZE;

    685. 

  685.     struct sockaddr         foreign_addr;

    686. 

  686.     int                     exit_flag = 0;

    687. 

  687.     int                     sock_err;

    688. 

  688.     unsigned int            option_len;

    689. 

  689.     fnet_shell_desc_t       desc = params->desc;

    690. 

  690.     int                     packet_size = params->packet_size;

    691. 

  691.     int                     cur_packet_number;

    692. 

  692.     int                     iterations = params->iteration_number;

    693. 

  693.     fnet_address_family_t   family = params->foreign_addr.sa_family;

    694. 

  694. 

    695. 

  695. 	

    696. 

  696.     if(packet_size > FAPP_BENCH_BUFFER_SIZE) /* Check max size.*/

    697. 

  697. 	    packet_size = FAPP_BENCH_BUFFER_SIZE;

    698. 

  698.     

    699. 

  699.     fapp_bench.socket_listen = SOCKET_INVALID;

    700. 

  700.     

    701. 

  701.     /* ------ Start test.----------- */

    702. 

  702.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    703. 

  703.     fnet_shell_println(desc, " UDP TX Test" );

    704. 

  704.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    705. 

  705.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_S, "Remote IP addr", fnet_inet_ntop(family, params->foreign_addr.sa_data, ip_str, sizeof(ip_str)));

    706. 

  706.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Remote Port", fnet_ntohs(params->foreign_addr.sa_port));

    707. 

  707.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Message Size", params->packet_size);

    708. 

  708.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Num. of messages", params->packet_number);

    709. 

  709.     fnet_shell_println(desc, FAPP_SHELL_INFO_FORMAT_D, "Num. of iterations", params->iteration_number);

    710. 

  710.     fnet_shell_println(desc, FAPP_TOCANCEL_STR);

    711. 

  711.     fnet_shell_println(desc, FAPP_DELIMITER_STR);

    712. 

  712.     

    713. 

  713.     while(iterations--)

    714. 

  714.     {

    715. 

  715.         /* Create socket */

    716. 

  716.         if((fapp_bench.socket_foreign = socket(family, SOCK_DGRAM, 0)) == SOCKET_INVALID)

    717. 

  717.         {

    718. 

  718.             FNET_DEBUG("BENCH: Socket creation error.\n");

    719. 

  719.             iterations = 0;

    720. 

  720.             goto ERROR_1;

    721. 

  721.         }

    722. 

  722.         

    723. 

  723.         /* Set Socket options. */

    724. 

  724.         if( /* Setup linger option. */

    725. 

  725.             (setsockopt (fapp_bench.socket_foreign, SOL_SOCKET, SO_LINGER, (char *)&linger_option, sizeof(linger_option)) == SOCKET_ERROR) ||

    726. 

  726.             /* Set socket buffer size. */

    727. 

  727.             (setsockopt(fapp_bench.socket_foreign, SOL_SOCKET, SO_RCVBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) ||

    728. 

  728.             (setsockopt(fapp_bench.socket_foreign, SOL_SOCKET, SO_SNDBUF, (char *) &bufsize_option, sizeof(bufsize_option))== SOCKET_ERROR) 

    729. 

  729.           )

    730. 

  730.         {

    731. 

  731.             FNET_DEBUG("BENCH: Socket setsockopt error.\n");

    732. 

  732.             iterations = 0;

    733. 

  733.             goto ERROR_2;		

    734. 

  734.         }

    735. 

  735.         

    736. 

  736.         /* Bind to the server.*/

    737. 

  737.         fnet_shell_println(desc,"Connecting.");

    738. 

  738. 

    739. 

  739.         foreign_addr = params->foreign_addr;

    740. 

  740.         

    741. 

  741.         if(connect(fapp_bench.socket_foreign, &foreign_addr, sizeof(foreign_addr))== FNET_ERR) 

    742. 

  742.         {

    743. 

  743.            fnet_shell_println(desc, "Connection failed.");

    744. 

  744.            iterations = 0;

    745. 

  745.            goto ERROR_2;

    746. 

  746.         } 

    747. 

  747.     

    748. 

  748.         /* Sending.*/

    749. 

  749.         fnet_shell_println(desc,"Sending."); 

    750. 

  750.         fapp_bench.bytes = 0;

    751. 

  751.         fapp_bench.remote_bytes = 0;

    752. 

  752.         cur_packet_number = 0;

    753. 

  753.         

    754. 

  754.         fapp_bench.first_time = fnet_timer_ticks();

    755. 

  755.         

    756. 

  756.         while(1)

    757. 

  757.         {

    758. 

  758.             send_result = send( fapp_bench.socket_foreign, (char*)(&fapp_bench.buffer[0]), packet_size, 0);

    759. 

  759.             fapp_bench.last_time = fnet_timer_ticks();

    760. 

  760.             

    761. 

  761.             

    762. 

  762.             if ( send_result == SOCKET_ERROR )

    763. 

  763.             {              

    764. 

  764.                 option_len = sizeof(sock_err); 

    765. 

  765.                 getsockopt(fapp_bench.socket_foreign, SOL_SOCKET, SO_ERROR, (char*)&sock_err, &option_len);

    766. 

  766.                 fnet_shell_println(desc, "socket_error = %d", sock_err);

    767. 

  767.                

    768. 

  768.                 iterations = 0;

    769. 

  769.                 

    770. 

  770.                 goto ERROR_2;

    771. 

  771.             }

    772. 

  772.             else

    773. 

  773.             {

    774. 

  774.                 fapp_bench.bytes += send_result;

    775. 

  775.                 cur_packet_number ++;

    776. 

  776.                 

    777. 

  777.                 exit_flag = fnet_shell_ctrlc (desc); /* Check [Ctrl+c]*/

    778. 

  778.                 

    779. 

  779.                 if((cur_packet_number >= params->packet_number)|| exit_flag)

    780. 

  780.                 { 

    781. 

  781.                     if(exit_flag)

    782. 

  782.                     {

    783. 

  783.                         fnet_shell_println(desc, FAPP_SHELL_CANCELED_CTRL_C);

    784. 

  784.                         iterations = 0;

    785. 

  785.                     }

    786. 

  786.                      

    787. 

  787.                     break;/* => TX END. */

    788. 

  788.                 }

    789. 

  789.             }

    790. 

  790.         }

    791. 

  791. 

    792. 

  792.         /* Send End mark.*/

    793. 

  793.         for(i=0; i < FAPP_BENCH_TX_UDP_END_ITERATIONS; i++)

    794. 

  794.         {

    795. 

  795.             unsigned long ack_bytes;

    796. 

  796.             

    797. 

  797.             /* Send END mark.*/

    798. 

  798.             send( fapp_bench.socket_foreign, (char*)(&fapp_bench.buffer[0]), 1, 0);

    799. 

  799.             fnet_timer_delay(1);

    800. 

  800.             

    801. 

  801.             /* Check ACK. It should contain recieved amount of data.*/

    802. 

  802.             received = recv(fapp_bench.socket_foreign, (char*)(&ack_bytes), sizeof(ack_bytes), 0);

    803. 

  803. 

    804. 

  804.             if(received == sizeof(ack_bytes)) /* ACK received.*/

    805. 

  805.             { 

    806. 

  806.                 fapp_bench.remote_bytes = fnet_ntohl(ack_bytes);

    807. 

  807.                 break;

    808. 

  808.             }

    809. 

  809.             else if(received == SOCKET_ERROR)

    810. 

  810.             {

    811. 

  811.                 break;            

    812. 

  812.             }

    813. 

  813.         }

    814. 

  814.         

    815. 

  815.         /* Print benchmark results.*/

    816. 

  816.         fapp_bench_print_results (desc);

    817. 

  817. 

    818. 

  818. ERROR_2:

    819. 

  819.         closesocket(fapp_bench.socket_foreign);

    820. 

  820.     }

    821. 

  821. 

    822. 

  822. ERROR_1:

    823. 

  823.     fnet_shell_println(desc, FAPP_BENCH_COMPLETED_STR);

    824. 

  824. }

    825. 

  825. 

    826. 

  826. 

    827. 

  827. /************************************************************************

    828. 

  828. * NAME: fapp_benchtx_cmd

    829. 

  829. *

    830. 

  830. * DESCRIPTION: Start TX Benchmark. 

    831. 

  831. ************************************************************************/

    832. 

  832. void fapp_benchtx_cmd( fnet_shell_desc_t desc, int argc, char ** argv )

    833. 

  833. {

    834. 

  834.     struct fapp_bench_tx_params bench_params;

    835. 

  835. 

    836. 

  836.     fnet_memset_zero(&bench_params.foreign_addr, sizeof(bench_params.foreign_addr));

    837. 

  837.        

    838. 

  838.     if(fnet_inet_ptos(argv[1], &bench_params.foreign_addr) == FNET_OK)

    839. 

  839.     {

    840. 

  840.         bench_params.desc = desc;

    841. 

  841. 

    842. 

  842.         bench_params.foreign_addr.sa_port = FAPP_BENCH_PORT;

    843. 

  843.         

    844. 

  844.         bench_params.packet_size = FAPP_BENCH_TX_PACKET_SIZE_DEFAULT;

    845. 

  845.         bench_params.packet_number = FAPP_BENCH_TX_PACKET_NUMBER_DEFAULT;

    846. 

  846.         bench_params.iteration_number = FAPP_BENCH_TX_ITERATION_NUMBER_DEFAULT;

    847. 

  847.         

    848. 

  848.         if(argc > 3)

    849. 

  849.         {

    850. 

  850.             char *p = 0;

    851. 

  851.             

    852. 

  852.             /* Packet size.*/

    853. 

  853.             bench_params.packet_size = (int)fnet_strtoul(argv[3], &p, 0);

    854. 

  854.             if ((bench_params.packet_size == 0) || (bench_params.packet_size > FAPP_BENCH_PACKET_SIZE_MAX))

    855. 

  855.             {

    856. 

  856.                 fnet_shell_println(desc, FAPP_PARAM_ERR, argv[3]); /* Print error mesage. */

    857. 

  857.                 return;

    858. 

  858.             }

    859. 

  859.             

    860. 

  860.             /* Number of packets.*/

    861. 

  861.             if(argc > 4)

    862. 

  862.             {

    863. 

  863.                 bench_params.packet_number = (int)fnet_strtoul(argv[4], &p, 0);

    864. 

  864.                 if (bench_params.packet_number == 0)

    865. 

  865.                 {

    866. 

  866.                     fnet_shell_println(desc, FAPP_PARAM_ERR, argv[4]); /* Print error mesage. */

    867. 

  867.                     return;

    868. 

  868.                 }

    869. 

  869.                 

    870. 

  870.                 /* Number of iterations.*/

    871. 

  871.                 if(argc > 5)

    872. 

  872.                 {

    873. 

  873.                     bench_params.iteration_number = (int)fnet_strtoul(argv[5], &p, 0);

    874. 

  874.                     if ((bench_params.iteration_number < 1) || (bench_params.iteration_number > FAPP_BENCH_TX_ITERATION_NUMBER_MAX) )

    875. 

  875.                     {

    876. 

  876.                         fnet_shell_println(desc, FAPP_PARAM_ERR, argv[5]); /* Print error mesage. */

    877. 

  877.                         return;

    878. 

  878.                     }

    879. 

  879.                 }

    880. 

  880.             }

    881. 

  881.         } 

    882. 

  882.         

    883. 

  883.         /* TCP */

    884. 

  884.         if((argc == 2)||(argc >= 3 && fnet_strcasecmp("tcp", argv[2]) == 0)) 

    885. 

  885.         {

    886. 

  886.             fapp_bench_tcp_tx (&bench_params);

    887. 

  887.         }

    888. 

  888.         /* UDP */

    889. 

  889.         else if(argc >= 3 && fnet_strcasecmp("udp", argv[2]) == 0) 

    890. 

  890.         {

    891. 

  891.             fapp_bench_udp_tx (&bench_params);

    892. 

  892.         }

    893. 

  893.         else

    894. 

  894.         {

    895. 

  895.             fnet_shell_println(desc, FAPP_PARAM_ERR, argv[2]);

    896. 

  896.         }

    897. 

  897.                 

    898. 

  898.     }

    899. 

  899.     else

    900. 

  900.     {

    901. 

  901.         fnet_shell_println(desc, FAPP_PARAM_ERR, argv[1]);   /* Wrong Benchmark Server IP address. */

    902. 

  902.         return;

    903. 

  903.     }

    904. 

  904. }

    905. 

  905. 

    906. 

  906. 

    907. 

  907. #endif /* FAPP_CFG_BENCH_CMD */

    908. 

  908. 

    909. 

  909. 

    910. 

  910. 

    911. 

  911. 

    912. 

  912. 

    913. 

  913. 

    914. 

  914. 

    915. 

  915. 

    916. 

  916. 

    917. 

  917. 

    918. 

  918. 

    919. 

  919. 

    920. 

  920. 

    921. 

  921. 

    922. 

  922.