AppPkg/Applications/Sockets/DataSource/DataSource.c

   1 /** @file
   2   Data source for network testing.
   3
   4   Copyright (c) 2011, Intel Corporation
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include <errno.h>
  16 #include <Uefi.h>
  17
  18 #include <Library/BaseMemoryLib.h>
  19 #include <Library/DebugLib.h>
  20 #include <Library/PcdLib.h>
  21 #include <Library/UefiBootServicesTableLib.h>
  22 #include <Library/UefiLib.h>
  23
  24 #include <netinet/in.h>
  25
  26 #include <Protocol/ServiceBinding.h>
  27 #include <Protocol/Tcp4.h>
  28
  29 #include <sys/EfiSysCall.h>
  30 #include <sys/poll.h>
  31 #include <sys/socket.h>
  32
  33 #include <stdio.h>
  34 #include <string.h>
  35
  36
  37 #define DATA_SAMPLE_SHIFT           5       ///<  Shift for number of samples
  38 #define RANGE_SWITCH        ( 1024 * 1024 ) ///<  Switch display ranges
  39 #define DATA_RATE_UPDATE_SHIFT      2       ///<  2n seconds between updates
  40 #define AVERAGE_SHIFT_COUNT ( 6 - DATA_RATE_UPDATE_SHIFT )  ///<  2n samples in average
  41 #define DATA_SAMPLES        ( 1 << DATA_SAMPLE_SHIFT )      ///<  Number of samples
  42
  43 #define TPL_DATASOURCE      TPL_CALLBACK  ///<  Synchronization TPL
  44
  45 #define PACKET_SIZE                 1448  ///<  Size of data packets
  46 #define DATA_BUFFER_SIZE    (( 65536 / PACKET_SIZE ) * PACKET_SIZE )  ///<  Buffer size in bytes
  47
  48
  49 //
  50 //  Socket Data
  51 //
  52 int Socket = -1;
  53
  54 //
  55 //  TCP V4 Data
  56 //
  57 BOOLEAN bTcp4;                      ///<  TRUE if TCP4 is being used
  58 BOOLEAN bTcp4Connected;             ///<  TRUE if connected to remote system
  59 BOOLEAN bTcp4Connecting;            ///<  TRUE while connection in progress
  60 UINTN Tcp4Index;                    ///<  Index into handle array
  61 EFI_HANDLE Tcp4Controller;          ///<  Network controller handle
  62 EFI_HANDLE Tcp4Handle;              ///<  TCP4 port handle
  63 EFI_TCP4_PROTOCOL * pTcp4Protocol;  ///<  TCP4 protocol pointer
  64 EFI_SERVICE_BINDING_PROTOCOL * pTcp4Service;  ///<  TCP4 Service binding
  65 EFI_TCP4_CONFIG_DATA Tcp4ConfigData;///<  TCP4 configuration data
  66 EFI_TCP4_OPTION Tcp4Option;         ///<  TCP4 port options
  67 EFI_TCP4_CLOSE_TOKEN Tcp4CloseToken;///<  Close control
  68 EFI_TCP4_CONNECTION_TOKEN Tcp4ConnectToken; ///<  Connection control
  69 EFI_TCP4_LISTEN_TOKEN Tcp4ListenToken;      ///<  Listen control
  70 EFI_TCP4_IO_TOKEN Tcp4TxToken;      ///<  Normal data token
  71
  72 //
  73 //  Timer Data
  74 //
  75 volatile BOOLEAN bTick;
  76 BOOLEAN bTimerRunning;
  77 EFI_EVENT pTimer;
  78
  79 //
  80 //  Remote IP Address Data
  81 //
  82 struct sockaddr_in6 RemoteHostAddress;
  83 CHAR8 * pRemoteHost;
  84
  85 //
  86 //  Traffic Data
  87 //
  88 UINT64 TotalBytesSent;
  89 UINT32 In;
  90 UINT32 Samples;
  91 UINT64 BytesSent[ DATA_SAMPLES ];
  92 UINT8 Buffer[ DATA_BUFFER_SIZE ];
  93
  94
  95 //
  96 //  Forward routine declarations
  97 //
  98 EFI_STATUS TimerStart ( UINTN Milliseconds );
  99
 100
 101 /**
 102   Check for control C entered at console
 103
 104   @retval  EFI_SUCCESS  Control C not entered
 105   @retval  EFI_ABORTED  Control C entered
 106 **/
 107 EFI_STATUS
 108 ControlCCheck (
 109   )
 110 {
 111   EFI_STATUS Status;
 112
 113   //
 114   //  Assume no user intervention
 115   //
 116   Status = EFI_SUCCESS;
 117
 118   //
 119   //  Display user stop request
 120   //
 121   if ( EFI_ERROR ( Status )) {
 122     DEBUG (( DEBUG_INFO,
 123               "User stop request!\r\n" ));
 124   }
 125
 126   //
 127   //  Return the check status
 128   //
 129   return Status;
 130 }
 131
 132
 133 /**
 134   Get a digit
 135
 136   @param [in] pDigit    The address of the next digit
 137   @param [out] pValue   The address to receive the value
 138
 139   @return   Returns the address of the separator
 140
 141 **/
 142 CHAR8 *
 143 GetDigit (
 144   CHAR8 * pDigit,
 145   UINT32 * pValue
 146   )
 147 {
 148   UINT32 Value;
 149
 150   //
 151   //  Walk the digits
 152   //
 153   Value = 0;
 154   while (( '0' <= *pDigit ) && ( '9' >= *pDigit )) {
 155     //
 156     //  Make room for the new least significant digit
 157     //
 158     Value *= 10;
 159
 160     //
 161     //  Convert the digit from ASCII to binary
 162     //
 163     Value += *pDigit - '0';
 164
 165     //
 166     //  Set the next digit
 167     //
 168     pDigit += 1;
 169   }
 170
 171   //
 172   //  Return the value
 173   //
 174   *pValue = Value;
 175
 176   //
 177   //  Return the next separator
 178   //
 179   return pDigit;
 180 }
 181
 182
 183 /**
 184   Get the IP address
 185
 186   @retval  EFI_SUCCESS  The IP address is valid
 187   @retval  Other        Failure to convert the IP address
 188 **/
 189 EFI_STATUS
 190 IpAddress (
 191   )
 192 {
 193   struct sockaddr_in * pRemoteAddress4;
 194   struct sockaddr_in6 * pRemoteAddress6;
 195   UINT32 RemoteAddress;
 196   EFI_STATUS Status;
 197   UINT32 Value1;
 198   UINT32 Value2;
 199   UINT32 Value3;
 200   UINT32 Value4;
 201   UINT32 Value5;
 202   UINT32 Value6;
 203   UINT32 Value7;
 204   UINT32 Value8;
 205
 206   //
 207   //  Assume failure
 208   //
 209   Status = EFI_INVALID_PARAMETER;
 210
 211   //
 212   //  Get the port number
 213   //
 214   ZeroMem ( &RemoteHostAddress, sizeof ( RemoteHostAddress ));
 215   RemoteHostAddress.sin6_port = htons ( PcdGet16 ( DataSource_Port ));
 216   pRemoteAddress4 = (struct sockaddr_in *)&RemoteHostAddress;
 217   pRemoteAddress6 = &RemoteHostAddress;
 218
 219   //
 220   //  Convert the IP address from a string to a numeric value
 221   //
 222   if (( 4 == sscanf ( pRemoteHost,
 223                       "%d.%d.%d.%d",
 224                       &Value1,
 225                       &Value2,
 226                       &Value3,
 227                       &Value4 ))
 228       && ( 255 >= Value1 )
 229       && ( 255 >= Value2 )
 230       && ( 255 >= Value3 )
 231       && ( 255 >= Value4 )) {
 232     //
 233     //  Build the IPv4 address
 234     //
 235     pRemoteAddress4->sin_len = sizeof ( *pRemoteAddress4 );
 236     pRemoteAddress4->sin_family = AF_INET;
 237     RemoteAddress = Value1
 238                   | ( Value2 << 8 )
 239                   | ( Value3 << 16 )
 240                   | ( Value4 << 24 );
 241     pRemoteAddress4->sin_addr.s_addr = RemoteAddress;
 242     Status = EFI_SUCCESS;
 243
 244     //
 245     //  Display the IP address
 246     //
 247     DEBUG (( DEBUG_INFO,
 248               "%d.%d.%d.%d: Remote host IP address\r\n",
 249               Value1,
 250               Value2,
 251               Value3,
 252               Value4 ));
 253   }
 254   else if (( 8 == sscanf ( pRemoteHost,
 255                            "%x:%x:%x:%x:%x:%x:%x:%x",
 256                            &Value1,
 257                            &Value2,
 258                            &Value3,
 259                            &Value4,
 260                            &Value5,
 261                            &Value6,
 262                            &Value7,
 263                            &Value8 ))
 264             && ( 0xffff >= Value1 )
 265             && ( 0xffff >= Value2 )
 266             && ( 0xffff >= Value3 )
 267             && ( 0xffff >= Value4 )
 268             && ( 0xffff >= Value5 )
 269             && ( 0xffff >= Value6 )
 270             && ( 0xffff >= Value7 )
 271             && ( 0xffff >= Value8 )) {
 272     //
 273     //  Build the IPv6 address
 274     //
 275     pRemoteAddress6->sin6_len = sizeof ( *pRemoteAddress6 );
 276     pRemoteAddress6->sin6_family = AF_INET6;
 277     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 0 ] = (UINT8)( Value1 >> 8 );
 278     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 1 ] = (UINT8)Value1;
 279     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 2 ] = (UINT8)( Value2 >> 8 );
 280     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 3 ] = (UINT8)Value2;
 281     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 4 ] = (UINT8)( Value3 >> 8 );
 282     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 5 ] = (UINT8)Value3;
 283     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 6 ] = (UINT8)( Value4 >> 8 );
 284     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 7 ] = (UINT8)Value4;
 285     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 8 ] = (UINT8)( Value5 >> 8 );
 286     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 9 ] = (UINT8)Value5;
 287     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 10 ] = (UINT8)( Value6 >> 8 );
 288     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 11 ] = (UINT8)Value6;
 289     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 12 ] = (UINT8)( Value7 >> 8 );
 290     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ] = (UINT8)Value7;
 291     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ] = (UINT8)( Value8 >> 8 );
 292     pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ] = (UINT8)Value8;
 293     Status = EFI_SUCCESS;
 294
 295     //
 296     //  Display the IP address
 297     //
 298     DEBUG (( DEBUG_INFO,
 299               "[%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x]: Remote host IP address\r\n",
 300               Value1,
 301               Value2,
 302               Value3,
 303               Value4,
 304               Value5,
 305               Value6,
 306               Value7,
 307               Value8 ));
 308   }
 309   else {
 310     Print ( L"ERROR - Invalid IP address!\r\n" );
 311   }
 312
 313   //
 314   //  Return the operation status
 315   //
 316   return Status;
 317 }
 318
 319
 320 /**
 321   Close the socket
 322
 323   @retval  EFI_SUCCESS  The application is running normally
 324   @retval  Other        The user stopped the application
 325 **/
 326 EFI_STATUS
 327 SocketClose (
 328   )
 329 {
 330   int CloseStatus;
 331   EFI_STATUS Status;
 332
 333   //
 334   //  Determine if the socket is open
 335   //
 336   Status = EFI_DEVICE_ERROR;
 337   if ( -1 != Socket ) {
 338     //
 339     //  Attempt to close the socket
 340     //
 341     CloseStatus = close ( Socket );
 342     if ( 0 == CloseStatus ) {
 343       DEBUG (( DEBUG_INFO,
 344                 "0x%08x: Socket closed\r\n",
 345                 Socket ));
 346       Socket = -1;
 347       Status = EFI_SUCCESS;
 348     }
 349     else {
 350       DEBUG (( DEBUG_ERROR,
 351                 "ERROR: Failed to close socket, errno: %d\r\n",
 352                 errno ));
 353     }
 354   }
 355
 356   //
 357   //  Return the operation status
 358   //
 359   return Status;
 360 }
 361
 362
 363 /**
 364   Connect the socket
 365
 366   @retval  EFI_SUCCESS  The application is running normally
 367   @retval  Other        The user stopped the application
 368 **/
 369 EFI_STATUS
 370 SocketConnect (
 371   )
 372 {
 373   int ConnectStatus;
 374   struct sockaddr_in * pRemoteAddress4;
 375   struct sockaddr_in6 * pRemoteAddress6;
 376   EFI_STATUS Status;
 377
 378   //
 379   //  Display the connecting message
 380   //
 381   pRemoteAddress4 = (struct sockaddr_in *)&RemoteHostAddress;
 382   pRemoteAddress6 = &RemoteHostAddress;
 383   if ( AF_INET == pRemoteAddress6->sin6_family ) {
 384     Print ( L"Connecting to remote system %d.%d.%d.%d:%d\r\n",
 385             pRemoteAddress4->sin_addr.s_addr & 0xff,
 386             ( pRemoteAddress4->sin_addr.s_addr >> 8 ) & 0xff,
 387             ( pRemoteAddress4->sin_addr.s_addr >> 16 ) & 0xff,
 388             ( pRemoteAddress4->sin_addr.s_addr >> 24 ) & 0xff,
 389             htons ( pRemoteAddress4->sin_port ));
 390   }
 391   else {
 392     Print ( L"Connecting to remote system [%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]:%d\r\n",
 393             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 0 ],
 394             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 1 ],
 395             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 2 ],
 396             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 3 ],
 397             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 4 ],
 398             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 5 ],
 399             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 6 ],
 400             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 7 ],
 401             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 8 ],
 402             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 9 ],
 403             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 10 ],
 404             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 11 ],
 405             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 12 ],
 406             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],
 407             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],
 408             pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],
 409             htons ( pRemoteAddress6->sin6_port ));
 410   }
 411
 412   //
 413   //  Connect to the remote system
 414   //
 415   Status = EFI_SUCCESS;
 416   do {
 417     //
 418     //  Check for user stop request
 419     //
 420     while ( !bTick ) {
 421       Status = ControlCCheck ( );
 422       if ( EFI_ERROR ( Status )) {
 423         break;
 424       }
 425     }
 426     bTick = FALSE;
 427     if ( EFI_ERROR ( Status )) {
 428       break;
 429     }
 430
 431     //
 432     //  Connect to the remote system
 433     //
 434     ConnectStatus = connect ( Socket,
 435                               (struct sockaddr *)pRemoteAddress6,
 436                               pRemoteAddress6->sin6_len );
 437     if ( -1 != ConnectStatus ) {
 438       if ( AF_INET == pRemoteAddress6->sin6_family ) {
 439         Print ( L"Connected to remote system %d.%d.%d.%d:%d\r\n",
 440                 pRemoteAddress4->sin_addr.s_addr & 0xff,
 441                 ( pRemoteAddress4->sin_addr.s_addr >> 8 ) & 0xff,
 442                 ( pRemoteAddress4->sin_addr.s_addr >> 16 ) & 0xff,
 443                 ( pRemoteAddress4->sin_addr.s_addr >> 24 ) & 0xff,
 444                 htons ( pRemoteAddress4->sin_port ));
 445       }
 446       else {
 447         Print ( L"Connected to remote system [%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x]:%d\r\n",
 448                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 0 ],
 449                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 1 ],
 450                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 2 ],
 451                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 3 ],
 452                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 4 ],
 453                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 5 ],
 454                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 6 ],
 455                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 7 ],
 456                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 8 ],
 457                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 9 ],
 458                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 10 ],
 459                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 11 ],
 460                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 12 ],
 461                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 13 ],
 462                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 14 ],
 463                 pRemoteAddress6->sin6_addr.__u6_addr.__u6_addr8[ 15 ],
 464                 htons ( pRemoteAddress6->sin6_port ));
 465       }
 466     }
 467     else {
 468       //
 469       //  Close the socket and try again
 470       //
 471       if ( EAGAIN != errno ) {
 472         Status = EFI_NOT_STARTED;
 473         break;
 474       }
 475     }
 476   } while ( -1 == ConnectStatus );
 477
 478   //
 479   //  Return the operation status
 480   //
 481   return Status;
 482 }
 483
 484
 485 /**
 486   Create the socket
 487
 488   @param [in] Family    Network family, AF_INET or AF_INET6
 489
 490   @retval  EFI_SUCCESS  The application is running normally
 491   @retval  Other        The user stopped the application
 492 **/
 493 EFI_STATUS
 494 SocketNew (
 495   sa_family_t Family
 496   )
 497 {
 498   EFI_STATUS Status;
 499
 500   //
 501   //  Loop creating the socket
 502   //
 503   DEBUG (( DEBUG_INFO,
 504             "Creating the socket\r\n" ));
 505   do {
 506     //
 507     //  Check for user stop request
 508     //
 509     Status = ControlCCheck ( );
 510     if ( EFI_ERROR ( Status )) {
 511       break;
 512     }
 513
 514     //
 515     //  Attempt to create the socket
 516     //
 517     Socket = socket ( Family,
 518                       SOCK_STREAM,
 519                       IPPROTO_TCP );
 520     if ( -1 != Socket ) {
 521       DEBUG (( DEBUG_INFO,
 522                 "0x%08x: Socket created\r\n",
 523                 Socket ));
 524       break;
 525     }
 526   } while ( -1 == Socket );
 527
 528   //
 529   //  Return the operation status
 530   //
 531   return Status;
 532 }
 533
 534
 535 /**
 536   Send data over the socket
 537
 538   @retval  EFI_SUCCESS  The application is running normally
 539   @retval  Other        The user stopped the application
 540 **/
 541 EFI_STATUS
 542 SocketSend (
 543   )
 544 {
 545   size_t BytesSent;
 546   EFI_STATUS Status;
 547   EFI_TPL TplPrevious;
 548
 549   //
 550   //  Restart the timer
 551   //
 552   TimerStart ( 1 * 1000 );
 553
 554   //
 555   //  Loop until the connection breaks or the user stops
 556   //
 557   do {
 558     //
 559     //  Check for user stop request
 560     //
 561     Status = ControlCCheck ( );
 562     if ( EFI_ERROR ( Status )) {
 563       break;
 564     }
 565
 566     //
 567     //  Send some bytes
 568     //
 569     BytesSent = write ( Socket, &Buffer[0], sizeof ( Buffer ));
 570     if ( -1 == BytesSent ) {
 571       DEBUG (( DEBUG_INFO,
 572                 "ERROR: send failed, errno: %d\r\n",
 573                 errno ));
 574
 575       //
 576       //  Try again
 577       //
 578       Status = EFI_SUCCESS;
 579
 580 //
 581 //  Exit now
 582 //
 583 Status = EFI_NOT_STARTED;
 584       break;
 585     }
 586
 587     //
 588     //  Synchronize with the TimerCallback routine
 589     //
 590     TplPrevious = gBS->RaiseTPL ( TPL_DATASOURCE );
 591
 592     //
 593     //  Account for the data sent
 594     //
 595     TotalBytesSent += BytesSent;
 596
 597     //
 598     //  Release the TimerCallback routine synchronization
 599     //
 600     gBS->RestoreTPL ( TplPrevious );
 601   } while ( !EFI_ERROR ( Status ));
 602
 603   //
 604   //  Return the operation status
 605   //
 606   return Status;
 607 }
 608
 609
 610 /**
 611   Open the network connection and send the data.
 612
 613   @retval EFI_SUCCESS   Continue looping
 614   @retval other         Stopped by user's Control-C input
 615
 616 **/
 617 EFI_STATUS
 618 SocketOpen (
 619   )
 620 {
 621   EFI_STATUS Status;
 622
 623   //
 624   //  Use do/while and break instead of goto
 625   //
 626   do {
 627     //
 628     //  Wait for the network layer to initialize
 629     //
 630     Status = SocketNew ( RemoteHostAddress.sin6_family );
 631     if ( EFI_ERROR ( Status )) {
 632       break;
 633     }
 634
 635     //
 636     //  Wait for the remote network application to start
 637     //
 638     Status = SocketConnect ( );
 639     if ( EFI_NOT_STARTED == Status ) {
 640       Status = SocketClose ( );
 641       continue;
 642     }
 643     else if ( EFI_SUCCESS != Status ) {
 644       //
 645       //  Control-C
 646       //
 647       break;
 648     }
 649
 650     //
 651     //  Send data until the connection breaks
 652     //
 653     Status = SocketSend ( );
 654     if ( EFI_ERROR ( Status )) {
 655       break;
 656     }
 657   } while ( FALSE );
 658
 659   //
 660   //  Return the operation status
 661   //
 662   return Status;
 663 }
 664
 665
 666 /**
 667   Close the TCP connection
 668
 669   @retval  EFI_SUCCESS  The application is running normally
 670   @retval  Other        The user stopped the application
 671 **/
 672 EFI_STATUS
 673 Tcp4Close (
 674   )
 675 {
 676   UINTN Index;
 677   UINT8 * pIpAddress;
 678   EFI_STATUS Status;
 679
 680   //
 681   //  Close the port
 682   //
 683   if ( bTcp4Connected ) {
 684     Tcp4CloseToken.AbortOnClose = TRUE;
 685     Status = pTcp4Protocol->Close ( pTcp4Protocol,
 686                                     &Tcp4CloseToken );
 687     if ( EFI_ERROR ( Status )) {
 688       DEBUG (( DEBUG_ERROR,
 689                 "ERROR - Failed to start the TCP port close, Status: %r\r\n",
 690                 Status ));
 691     }
 692     else {
 693       Status = gBS->WaitForEvent ( 1,
 694                                    &Tcp4CloseToken.CompletionToken.Event,
 695                                     &Index );
 696       if ( EFI_ERROR ( Status )) {
 697         DEBUG (( DEBUG_ERROR,
 698                   "ERROR - Failed to wait for close event, Status: %r\r\n",
 699                   Status ));
 700       }
 701       else {
 702         Status = Tcp4CloseToken.CompletionToken.Status;
 703         if ( EFI_ERROR ( Status )) {
 704           DEBUG (( DEBUG_ERROR,
 705                     "ERROR - Failed to close the TCP port, Status: %r\r\n",
 706                     Status ));
 707         }
 708         else {
 709           DEBUG (( DEBUG_INFO,
 710                     "0x%08x: TCP port closed\r\n",
 711                     pTcp4Protocol ));
 712           bTcp4Connected = FALSE;
 713
 714           //
 715           //  Display the port closed message
 716           //
 717           pIpAddress = (UINT8 *)&((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr;
 718           Print ( L"Closed connection to %d.%d.%d.%d:%d\r\n",
 719                   pIpAddress[0],
 720                   pIpAddress[1],
 721                   pIpAddress[2],
 722                   pIpAddress[3],
 723                   htons ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));
 724         }
 725       }
 726     }
 727   }
 728
 729   //
 730   //  Release the events
 731   //
 732   if ( NULL != Tcp4TxToken.CompletionToken.Event ) {
 733     Status = gBS->CloseEvent ( Tcp4TxToken.CompletionToken.Event );
 734     if ( !EFI_ERROR ( Status )) {
 735       DEBUG (( DEBUG_INFO,
 736                 "0x%08x: TX event closed\r\n",
 737                 Tcp4TxToken.CompletionToken.Event ));
 738       Tcp4TxToken.CompletionToken.Event = NULL;
 739     }
 740     else {
 741       DEBUG (( DEBUG_ERROR,
 742                 "ERROR - Failed to close the Tcp4TxToken event, Status: %r\r\n",
 743                 Status ));
 744     }
 745   }
 746
 747   if ( NULL != Tcp4ListenToken.CompletionToken.Event ) {
 748     Status = gBS->CloseEvent ( Tcp4ListenToken.CompletionToken.Event );
 749     if ( !EFI_ERROR ( Status )) {
 750       DEBUG (( DEBUG_INFO,
 751                 "0x%08x: Listen event closed\r\n",
 752                 Tcp4ListenToken.CompletionToken.Event ));
 753       Tcp4ListenToken.CompletionToken.Event = NULL;
 754     }
 755     else {
 756       DEBUG (( DEBUG_ERROR,
 757                 "ERROR - Failed to close the Tcp4ListenToken event, Status: %r\r\n",
 758                 Status ));
 759     }
 760   }
 761
 762   if ( NULL != Tcp4ConnectToken.CompletionToken.Event ) {
 763     Status = gBS->CloseEvent ( Tcp4ConnectToken.CompletionToken.Event );
 764     if ( !EFI_ERROR ( Status )) {
 765       DEBUG (( DEBUG_INFO,
 766                 "0x%08x: Connect event closed\r\n",
 767                 Tcp4ConnectToken.CompletionToken.Event ));
 768       Tcp4ConnectToken.CompletionToken.Event = NULL;
 769     }
 770     else {
 771       DEBUG (( DEBUG_ERROR,
 772                 "ERROR - Failed to close the Tcp4ConnectToken event, Status: %r\r\n",
 773                 Status ));
 774     }
 775   }
 776
 777   if ( NULL != Tcp4CloseToken.CompletionToken.Event ) {
 778     Status = gBS->CloseEvent ( Tcp4CloseToken.CompletionToken.Event );
 779     if ( !EFI_ERROR ( Status )) {
 780       DEBUG (( DEBUG_INFO,
 781                 "0x%08x: Close event closed\r\n",
 782                 Tcp4CloseToken.CompletionToken.Event ));
 783       Tcp4CloseToken.CompletionToken.Event = NULL;
 784     }
 785     else {
 786       DEBUG (( DEBUG_ERROR,
 787                 "ERROR - Failed to close the Tcp4CloseToken event, Status: %r\r\n",
 788                 Status ));
 789     }
 790   }
 791
 792   //
 793   //  Close the TCP protocol
 794   //
 795   if ( NULL != pTcp4Protocol ) {
 796     Status = gBS->CloseProtocol ( Tcp4Handle,
 797                                   &gEfiTcp4ProtocolGuid,
 798                                   gImageHandle,
 799                                   NULL );
 800     if ( EFI_ERROR ( Status )) {
 801       DEBUG (( DEBUG_ERROR,
 802                 "ERROR - Failed to close the TCP protocol, Status: %r\r\n",
 803                 Status ));
 804     }
 805     else {
 806       DEBUG (( DEBUG_INFO,
 807                 "0x%08x: TCP4 protocol closed\r\n",
 808                 pTcp4Protocol ));
 809       pTcp4Protocol = NULL;
 810     }
 811   }
 812
 813   //
 814   //  Done with the TCP service
 815   //
 816   if ( NULL != Tcp4Handle ) {
 817     Status = pTcp4Service->DestroyChild ( pTcp4Service,
 818                                           Tcp4Handle );
 819     if ( EFI_ERROR ( Status )) {
 820       DEBUG (( DEBUG_ERROR,
 821                 "ERROR - Failed to release TCP service handle, Status: %r\r\n",
 822                 Status ));
 823     }
 824     else {
 825       DEBUG (( DEBUG_INFO,
 826                 "Ox%08x: TCP service closed\r\n",
 827                 Tcp4Handle ));
 828       Tcp4Handle = NULL;
 829     }
 830   }
 831
 832   //
 833   //  Close the service protocol
 834   //
 835   if ( NULL != pTcp4Service ) {
 836     Status = gBS->CloseProtocol ( Tcp4Controller,
 837                                   &gEfiTcp4ServiceBindingProtocolGuid,
 838                                   gImageHandle,
 839                                   NULL );
 840     if ( !EFI_ERROR ( Status )) {
 841       DEBUG (( DEBUG_INFO,
 842                 "0x%08x: Controller closed gEfiTcp4ServiceBindingProtocolGuid protocol\r\n",
 843                 Tcp4Controller ));
 844       pTcp4Service = NULL;
 845     }
 846     else {
 847       DEBUG (( DEBUG_ERROR,
 848                 "ERROR - Failed to close the gEfiTcp4ServiceBindingProtocolGuid protocol, Status: %r\r\n",
 849                 Status ));
 850     }
 851   }
 852   Tcp4Controller = NULL;
 853   bTcp4Connecting = TRUE;
 854
 855   //
 856   //  Mark the connection as closed
 857   //
 858   Status = EFI_SUCCESS;
 859
 860   //
 861   //  Return the operation status
 862   //
 863   return Status;
 864 }
 865
 866
 867 /**
 868   Locate TCP protocol
 869
 870   @retval EFI_SUCCESS   Protocol found
 871   @retval other         Protocl not found
 872 **/
 873 EFI_STATUS
 874 Tcp4Locate (
 875   )
 876 {
 877   UINTN HandleCount;
 878   EFI_HANDLE * pHandles;
 879   UINT8 * pIpAddress;
 880   EFI_STATUS Status;
 881
 882   //
 883   //  Use do/while and break instead of goto
 884   //
 885   do {
 886     //
 887     //  Attempt to locate the next TCP adapter in the system
 888     //
 889     Status = gBS->LocateHandleBuffer ( ByProtocol,
 890                                        &gEfiTcp4ServiceBindingProtocolGuid,
 891                                        NULL,
 892                                        &HandleCount,
 893                                        &pHandles );
 894     if ( EFI_ERROR ( Status )) {
 895       DEBUG (( DEBUG_WARN,
 896                 "WARNING - No network controllers or TCP4 available, Status: %r\r\n",
 897                 Status ));
 898       break;
 899     }
 900
 901     //
 902     //  Wrap the index if necessary
 903     //
 904     if ( HandleCount <= Tcp4Index ) {
 905       Tcp4Index = 0;
 906
 907       //
 908       //  Wait for the next timer tick
 909       //
 910       do {
 911       } while ( !bTick );
 912       bTick = FALSE;
 913     }
 914
 915     //
 916     //  Display the connecting message
 917     //
 918     if ( bTcp4Connecting ) {
 919       pIpAddress = (UINT8 *)&((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr;
 920       Print ( L"Connecting to %d.%d.%d.%d:%d\r\n",
 921               pIpAddress[0],
 922               pIpAddress[1],
 923               pIpAddress[2],
 924               pIpAddress[3],
 925               htons ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));
 926       bTcp4Connecting = FALSE;
 927     }
 928
 929     //
 930     //  Open the network controller's service protocol
 931     //
 932     Tcp4Controller = pHandles[ Tcp4Index++ ];
 933     Status = gBS->OpenProtocol (
 934                     Tcp4Controller,
 935                     &gEfiTcp4ServiceBindingProtocolGuid,
 936                     (VOID **) &pTcp4Service,
 937                     gImageHandle,
 938                     NULL,
 939                     EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL );
 940     if ( EFI_ERROR ( Status )) {
 941       DEBUG (( DEBUG_ERROR,
 942                 "ERROR - Failed to open gEfiTcp4ServiceBindingProtocolGuid on controller 0x%08x\r\n",
 943                 Tcp4Controller ));
 944       Tcp4Controller = NULL;
 945       break;
 946     }
 947     DEBUG (( DEBUG_INFO,
 948               "0x%08x: Controller opened gEfiTcp4ServiceBindingProtocolGuid protocol\r\n",
 949               Tcp4Controller ));
 950
 951     //
 952     //  Connect to the TCP service
 953     //
 954     Status = pTcp4Service->CreateChild ( pTcp4Service,
 955                                          &Tcp4Handle );
 956     if ( EFI_ERROR ( Status )) {
 957       DEBUG (( DEBUG_ERROR,
 958                 "ERROR - Failed to open TCP service, Status: %r\r\n",
 959                 Status ));
 960       Tcp4Handle = NULL;
 961       break;
 962     }
 963     DEBUG (( DEBUG_INFO,
 964               "Ox%08x: TCP service opened\r\n",
 965               Tcp4Handle ));
 966
 967     //
 968     //  Locate the TCP protcol
 969     //
 970     Status = gBS->OpenProtocol ( Tcp4Handle,
 971                                  &gEfiTcp4ProtocolGuid,
 972                                  (VOID **)&pTcp4Protocol,
 973                                  gImageHandle,
 974                                  NULL,
 975                                  EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL );
 976     if ( EFI_ERROR ( Status )) {
 977       DEBUG (( DEBUG_ERROR,
 978                 "ERROR - Failed to open the TCP protocol, Status: %r\r\n",
 979                 Status ));
 980       pTcp4Protocol = NULL;
 981       break;
 982     }
 983     DEBUG (( DEBUG_INFO,
 984               "0x%08x: TCP4 protocol opened\r\n",
 985               pTcp4Protocol ));
 986   }while ( FALSE );
 987
 988   //
 989   //  Release the handle buffer
 990   //
 991   gBS->FreePool ( pHandles );
 992
 993   //
 994   //  Return the operation status
 995   //
 996   return Status;
 997 }
 998
 999
1000 /**
1001   Send data over the TCP4 connection
1002
1003   @retval  EFI_SUCCESS  The application is running normally
1004   @retval  Other        The user stopped the application
1005 **/
1006 EFI_STATUS
1007 Tcp4Send (
1008   )
1009 {
1010   UINTN Index;
1011   EFI_TCP4_TRANSMIT_DATA Packet;
1012   EFI_STATUS Status;
1013   EFI_TPL TplPrevious;
1014
1015   //
1016   //  Restart the timer
1017   //
1018   TimerStart ( 1 * 1000 );
1019
1020   //
1021   //  Initialize the packet
1022   //
1023   Packet.DataLength = sizeof ( Buffer );
1024   Packet.FragmentCount = 1;
1025   Packet.Push = FALSE;
1026   Packet.Urgent = FALSE;
1027   Packet.FragmentTable[0].FragmentBuffer = &Buffer[0];
1028   Packet.FragmentTable[0].FragmentLength = sizeof ( Buffer );
1029   Tcp4TxToken.Packet.TxData = &Packet;
1030
1031   //
1032   //  Loop until the connection breaks or the user stops
1033   //
1034   do {
1035     //
1036     //  Check for user stop request
1037     //
1038     Status = ControlCCheck ( );
1039     if ( EFI_ERROR ( Status )) {
1040       break;
1041     }
1042
1043     //
1044     //  Send some bytes
1045     //
1046     Status = pTcp4Protocol->Transmit ( pTcp4Protocol,
1047                                        &Tcp4TxToken );
1048     if ( EFI_ERROR ( Status )) {
1049       DEBUG (( DEBUG_ERROR,
1050                 "ERROR - Failed to start the transmit, Status: %r\r\n",
1051                 Status ));
1052
1053       //
1054       //  Try again
1055       //
1056       Status = EFI_SUCCESS;
1057       break;
1058     }
1059
1060     //
1061     //  Wait for the transmit to complete
1062     //
1063     Status = gBS->WaitForEvent ( 1,
1064                                  &Tcp4TxToken.CompletionToken.Event,
1065                                  &Index );
1066     if ( EFI_ERROR ( Status )) {
1067       DEBUG (( DEBUG_ERROR,
1068                 "ERROR - Failed to wait for transmit completion, Status: %r\r\n",
1069                 Status ));
1070
1071       //
1072       //  Try again
1073       //
1074       Status = EFI_SUCCESS;
1075       break;
1076     }
1077
1078     //
1079     //  Get the transmit status
1080     //
1081     Status = Tcp4TxToken.CompletionToken.Status;
1082     if ( EFI_ERROR ( Status )) {
1083       DEBUG (( DEBUG_WARN,
1084                 "WARNING - Failed the transmission, Status: %r\r\n",
1085                 Status ));
1086
1087       //
1088       //  Try again
1089       //
1090       Status = EFI_SUCCESS;
1091
1092 //
1093 //  Exit now
1094 //
1095 Status = EFI_NOT_STARTED;
1096       break;
1097     }
1098
1099     //
1100     //  Synchronize with the TimerCallback routine
1101     //
1102     TplPrevious = gBS->RaiseTPL ( TPL_DATASOURCE );
1103
1104     //
1105     //  Account for the data sent
1106     //
1107     TotalBytesSent += Packet.DataLength;
1108
1109     //
1110     //  Release the TimerCallback routine synchronization
1111     //
1112     gBS->RestoreTPL ( TplPrevious );
1113   } while ( !EFI_ERROR ( Status ));
1114
1115   //
1116   //  Return the operation status
1117   //
1118   return Status;
1119 }
1120
1121
1122 /**
1123   Open the network connection and send the data.
1124
1125   @retval EFI_SUCCESS   Continue looping
1126   @retval other         Stopped by user's Control-C input
1127
1128 **/
1129 EFI_STATUS
1130 Tcp4Open (
1131   )
1132 {
1133   UINTN Index;
1134   UINT8 * pIpAddress;
1135   EFI_STATUS Status;
1136
1137   //
1138   //  Use do/while and break instead of goto
1139   //
1140   do {
1141     //
1142     //  Locate the TCP protocol
1143     //
1144     Status = Tcp4Locate ( );
1145     if ( EFI_ERROR ( Status )) {
1146       break;
1147     }
1148
1149     //
1150     //  Create the necessary events
1151     //
1152     Status = gBS->CreateEvent ( 0,
1153                                 TPL_CALLBACK,
1154                                 NULL,
1155                                 NULL,
1156                                 &Tcp4CloseToken.CompletionToken.Event );
1157     if ( EFI_ERROR ( Status )) {
1158       DEBUG (( DEBUG_ERROR,
1159                 "ERROR - Failed to create the close event, Status: %r\r\n",
1160                 Status ));
1161       Tcp4CloseToken.CompletionToken.Event = NULL;
1162       break;
1163     }
1164     DEBUG (( DEBUG_INFO,
1165               "0x%08x: Close event open\r\n",
1166               Tcp4CloseToken.CompletionToken.Event ));
1167
1168     Status = gBS->CreateEvent ( 0,
1169                                 TPL_CALLBACK,
1170                                 NULL,
1171                                 NULL,
1172                                 &Tcp4ConnectToken.CompletionToken.Event );
1173     if ( EFI_ERROR ( Status )) {
1174       DEBUG (( DEBUG_ERROR,
1175                 "ERROR - Failed to create the connect event, Status: %r\r\n",
1176                 Status ));
1177       Tcp4ConnectToken.CompletionToken.Event = NULL;
1178       break;
1179     }
1180     DEBUG (( DEBUG_INFO,
1181               "0x%08x: Connect event open\r\n",
1182               Tcp4ConnectToken.CompletionToken.Event ));
1183
1184     Status = gBS->CreateEvent ( 0,
1185                                 TPL_CALLBACK,
1186                                 NULL,
1187                                 NULL,
1188                                 &Tcp4ListenToken.CompletionToken.Event );
1189     if ( EFI_ERROR ( Status )) {
1190       DEBUG (( DEBUG_ERROR,
1191                 "ERROR - Failed to create the listen event, Status: %r\r\n",
1192                 Status ));
1193       Tcp4ListenToken.CompletionToken.Event = NULL;
1194       break;
1195     }
1196     DEBUG (( DEBUG_INFO,
1197               "0x%08x: Listen event open\r\n",
1198               Tcp4ListenToken.CompletionToken.Event ));
1199
1200     Status = gBS->CreateEvent ( 0,
1201                                 TPL_CALLBACK,
1202                                 NULL,
1203                                 NULL,
1204                                 &Tcp4TxToken.CompletionToken.Event );
1205     if ( EFI_ERROR ( Status )) {
1206       DEBUG (( DEBUG_ERROR,
1207                 "ERROR - Failed to create the TX event, Status: %r\r\n",
1208                 Status ));
1209       Tcp4TxToken.CompletionToken.Event = NULL;
1210       break;
1211     }
1212     DEBUG (( DEBUG_INFO,
1213               "0x%08x: TX event open\r\n",
1214               Tcp4TxToken.CompletionToken.Event ));
1215
1216     //
1217     //  Configure the local TCP port
1218     //
1219     Tcp4ConfigData.TimeToLive = 255;
1220     Tcp4ConfigData.TypeOfService = 0;
1221     Tcp4ConfigData.ControlOption = NULL;
1222     Tcp4ConfigData.AccessPoint.ActiveFlag = TRUE;
1223     Tcp4ConfigData.AccessPoint.StationAddress.Addr[0] = 0;
1224     Tcp4ConfigData.AccessPoint.StationAddress.Addr[1] = 0;
1225     Tcp4ConfigData.AccessPoint.StationAddress.Addr[2] = 0;
1226     Tcp4ConfigData.AccessPoint.StationAddress.Addr[3] = 0;
1227     Tcp4ConfigData.AccessPoint.StationPort = 0;
1228     Tcp4ConfigData.AccessPoint.RemoteAddress.Addr[0] = (UINT8)  ((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr;
1229     Tcp4ConfigData.AccessPoint.RemoteAddress.Addr[1] = (UINT8)( ((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr >> 8 );
1230     Tcp4ConfigData.AccessPoint.RemoteAddress.Addr[2] = (UINT8)( ((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr >> 16 );
1231     Tcp4ConfigData.AccessPoint.RemoteAddress.Addr[3] = (UINT8)( ((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr >> 24 );
1232     Tcp4ConfigData.AccessPoint.RemotePort = ((struct sockaddr_in *)&RemoteHostAddress)->sin_port;
1233     Tcp4ConfigData.AccessPoint.UseDefaultAddress = TRUE;
1234     Tcp4ConfigData.AccessPoint.SubnetMask.Addr[0] = 0;
1235     Tcp4ConfigData.AccessPoint.SubnetMask.Addr[1] = 0;
1236     Tcp4ConfigData.AccessPoint.SubnetMask.Addr[2] = 0;
1237     Tcp4ConfigData.AccessPoint.SubnetMask.Addr[3] = 0;
1238     Status = pTcp4Protocol->Configure ( pTcp4Protocol,
1239                                         &Tcp4ConfigData );
1240     if ( EFI_ERROR ( Status )) {
1241       DEBUG (( DEBUG_ERROR,
1242                 "ERROR - Failed to configure TCP port, Status: %r\r\n",
1243                 Status ));
1244       break;
1245     }
1246     DEBUG (( DEBUG_INFO,
1247               "0x%08x: TCP4 port configured\r\n",
1248               pTcp4Protocol ));
1249
1250     //
1251     //  Connect to the remote TCP port
1252     //
1253     Status = pTcp4Protocol->Connect ( pTcp4Protocol,
1254                                       &Tcp4ConnectToken );
1255     if ( EFI_ERROR ( Status )) {
1256       DEBUG (( DEBUG_ERROR,
1257                 "ERROR - Failed to start the connection to the remote system, Status: %r\r\n",
1258                 Status ));
1259       break;
1260     }
1261     Status = gBS->WaitForEvent ( 1,
1262                                  &Tcp4ConnectToken.CompletionToken.Event,
1263                                  &Index );
1264     if ( EFI_ERROR ( Status )) {
1265       DEBUG (( DEBUG_ERROR,
1266                 "ERROR - Failed to wait for the connection, Status: %r\r\n",
1267                 Status ));
1268       break;
1269     }
1270     Status = Tcp4ConnectToken.CompletionToken.Status;
1271     if ( EFI_ERROR ( Status )) {
1272       DEBUG (( DEBUG_WARN,
1273                 "WARNING - Failed to connect to the remote system, Status: %r\r\n",
1274                 Status ));
1275       break;
1276     }
1277     DEBUG (( DEBUG_INFO,
1278               "0x%08x: TCP4 port connected\r\n",
1279               pTcp4Protocol ));
1280     bTcp4Connected = TRUE;
1281
1282     //
1283     //  Display the connection
1284     //
1285     pIpAddress = (UINT8 *)&((struct sockaddr_in *)&RemoteHostAddress)->sin_addr.s_addr;
1286     Print ( L"Connected to %d.%d.%d.%d:%d\r\n",
1287             pIpAddress[0],
1288             pIpAddress[1],
1289             pIpAddress[2],
1290             pIpAddress[3],
1291             htons ( ((struct sockaddr_in *)&RemoteHostAddress)->sin_port ));
1292   } while ( 0 );
1293
1294   if ( EFI_ERROR ( Status )) {
1295     //
1296     //  Try again
1297     //
1298     Status = EFI_SUCCESS;
1299   }
1300   else {
1301     //
1302     //  Semd data until the connection breaks
1303     //
1304     Status = Tcp4Send ( );
1305   }
1306
1307   //
1308   //  Return the operation status
1309   //
1310   return Status;
1311 }
1312
1313
1314 /**
1315   Handle the timer callback
1316
1317   @param [in] Event     Event that caused this callback
1318   @param [in] pContext  Context for this routine
1319 **/
1320 VOID
1321 TimerCallback (
1322   IN EFI_EVENT Event,
1323   IN VOID * pContext
1324   )
1325 {
1326   UINT32 Average;
1327   UINT64 BitsPerSecond;
1328   UINT32 Index;
1329   UINT64 TotalBytes;
1330
1331   //
1332   //  Notify the other code of the timer tick
1333   //
1334   bTick = TRUE;
1335
1336   //
1337   //  Update the average bytes per second
1338   //
1339   if ( 0 != TotalBytesSent ) {
1340     BytesSent[ In ] = TotalBytesSent;
1341     TotalBytesSent = 0;
1342     In += 1;
1343     if ( DATA_SAMPLES <= In ) {
1344       In = 0;
1345     }
1346
1347     //
1348     //  Separate the samples
1349     //
1350     if ( DATA_SAMPLES == Samples ) {
1351       Print ( L"---------- Stable average ----------\r\n" );
1352     }
1353     Samples += 1;
1354
1355     //
1356     //  Compute the data rate
1357     //
1358     TotalBytes = 0;
1359     for ( Index = 0; DATA_SAMPLES > Index; Index++ ) {
1360       TotalBytes += BytesSent[ Index ];
1361     }
1362     Average = (UINT32)RShiftU64 ( TotalBytes, DATA_SAMPLE_SHIFT );
1363     BitsPerSecond = Average * 8;
1364
1365     //
1366     //  Display the data rate
1367     //
1368     if (( RANGE_SWITCH >> 10 ) > Average ) {
1369       Print ( L"Ave: %d Bytes/Sec, %Ld Bits/sec\r\n",
1370               Average,
1371               BitsPerSecond );
1372     }
1373     else {
1374       BitsPerSecond /= 1000;
1375       if ( RANGE_SWITCH > Average ) {
1376         Print ( L"Ave: %d.%03d KiBytes/Sec, %Ld KBits/sec\r\n",
1377                 Average >> 10,
1378                 (( Average & 0x3ff ) * 1000 ) >> 10,
1379                 BitsPerSecond );
1380       }
1381       else {
1382         BitsPerSecond /= 1000;
1383         Average >>= 10;
1384         if ( RANGE_SWITCH > Average ) {
1385           Print ( L"Ave: %d.%03d MiBytes/Sec, %Ld MBits/sec\r\n",
1386                   Average >> 10,
1387                   (( Average & 0x3ff ) * 1000 ) >> 10,
1388                   BitsPerSecond );
1389         }
1390         else {
1391           BitsPerSecond /= 1000;
1392           Average >>= 10;
1393           if ( RANGE_SWITCH > Average ) {
1394             Print ( L"Ave: %d.%03d GiBytes/Sec, %Ld GBits/sec\r\n",
1395                     Average >> 10,
1396                     (( Average & 0x3ff ) * 1000 ) >> 10,
1397                     BitsPerSecond );
1398           }
1399           else {
1400             BitsPerSecond /= 1000;
1401             Average >>= 10;
1402             if ( RANGE_SWITCH > Average ) {
1403               Print ( L"Ave: %d.%03d TiBytes/Sec, %Ld TBits/sec\r\n",
1404                       Average >> 10,
1405                       (( Average & 0x3ff ) * 1000 ) >> 10,
1406                       BitsPerSecond );
1407             }
1408             else {
1409               BitsPerSecond /= 1000;
1410               Average >>= 10;
1411               Print ( L"Ave: %d.%03d PiBytes/Sec, %Ld PBits/sec\r\n",
1412                       Average >> 10,
1413                       (( Average & 0x3ff ) * 1000 ) >> 10,
1414                       BitsPerSecond );
1415             }
1416           }
1417         }
1418       }
1419     }
1420   }
1421 }
1422
1423
1424 /**
1425   Create the timer
1426
1427   @retval  EFI_SUCCESS  The timer was successfully created
1428   @retval  Other        Timer initialization failed
1429 **/
1430 EFI_STATUS
1431 TimerCreate (
1432   )
1433 {
1434   EFI_STATUS Status;
1435
1436   //
1437   //  Create the timer
1438   //
1439   Status = gBS->CreateEvent ( EVT_TIMER | EVT_NOTIFY_SIGNAL,
1440                               TPL_DATASOURCE,
1441                               TimerCallback,
1442                               NULL,
1443                               &pTimer );
1444   if ( EFI_ERROR ( Status )) {
1445     DEBUG (( DEBUG_ERROR,
1446               "ERROR - Failed to allocate the timer event, Status: %r\r\n",
1447               Status ));
1448   }
1449   else {
1450     DEBUG (( DEBUG_INFO,
1451               "0x%08x: Timer created\r\n",
1452               pTimer ));
1453   }
1454
1455   //
1456   //  Return the operation status
1457   //
1458   return Status;
1459 }
1460
1461
1462 /**
1463   Stop the timer
1464
1465   @retval  EFI_SUCCESS  The timer was stopped successfully
1466   @retval  Other        The timer failed to stop
1467 **/
1468 EFI_STATUS
1469 TimerStop (
1470   )
1471 {
1472   EFI_STATUS Status;
1473
1474   //
1475   //  Assume success
1476   //
1477   Status = EFI_SUCCESS;
1478
1479   //
1480   //  Determine if the timer is running
1481   //
1482   if ( bTimerRunning ) {
1483     //
1484     //  Stop the timer
1485     //
1486     Status = gBS->SetTimer ( pTimer,
1487                              TimerCancel,
1488                              0 );
1489     if ( EFI_ERROR ( Status )) {
1490       DEBUG (( DEBUG_ERROR,
1491                 "ERROR - Failed to stop the timer, Status: %r\r\n",
1492                 Status ));
1493     }
1494     else {
1495       //
1496       //  Timer timer is now stopped
1497       //
1498       bTimerRunning = FALSE;
1499       DEBUG (( DEBUG_INFO,
1500                 "0x%08x: Timer stopped\r\n",
1501                 pTimer ));
1502     }
1503   }
1504
1505   //
1506   //  Return the operation status
1507   //
1508   return Status;
1509 }
1510
1511
1512 /**
1513   Start the timer
1514
1515   @param [in] Milliseconds  The number of milliseconds between timer callbacks
1516
1517   @retval  EFI_SUCCESS  The timer was successfully created
1518   @retval  Other        Timer initialization failed
1519 **/
1520 EFI_STATUS
1521 TimerStart (
1522   UINTN Milliseconds
1523   )
1524 {
1525   EFI_STATUS Status;
1526   UINT64 TimeDelay;
1527
1528   //
1529   //  Stop the timer if necessary
1530   //
1531   Status = EFI_SUCCESS;
1532   if ( bTimerRunning ) {
1533     Status = TimerStop ( );
1534   }
1535   if ( !EFI_ERROR ( Status )) {
1536     //
1537     //  Compute the new delay
1538     //
1539     TimeDelay = Milliseconds;
1540     TimeDelay *= 1000 * 10;
1541
1542     //
1543     //  Start the timer
1544     //
1545     Status = gBS->SetTimer ( pTimer,
1546                              TimerPeriodic,
1547                              TimeDelay );
1548     if ( EFI_ERROR ( Status )) {
1549       DEBUG (( DEBUG_ERROR,
1550                 "ERROR - Failed to start the timer, Status: %r\r\n",
1551                 Status ));
1552     }
1553     else {
1554       //
1555       //  The timer is now running
1556       //
1557       bTimerRunning = TRUE;
1558       DEBUG (( DEBUG_INFO,
1559         "0x%08x: Timer running\r\n",
1560         pTimer ));
1561     }
1562   }
1563
1564   //
1565   //  Return the operation status
1566   //
1567   return Status;
1568 }
1569
1570
1571 /**
1572   Destroy the timer
1573
1574   @retval  EFI_SUCCESS  The timer was destroyed successfully
1575   @retval  Other        Failed to destroy the timer
1576 **/
1577 EFI_STATUS
1578 TimerDestroy (
1579   )
1580 {
1581   EFI_STATUS Status;
1582
1583   //
1584   //  Assume success
1585   //
1586   Status = EFI_SUCCESS;
1587
1588   //
1589   //  Determine if the timer is running
1590   //
1591   if ( bTimerRunning ) {
1592     //
1593     //  Stop the timer
1594     //
1595     Status = TimerStop ( );
1596   }
1597   if (( !EFI_ERROR ( Status )) && ( NULL != pTimer )) {
1598     //
1599     //  Done with this timer
1600     //
1601     Status = gBS->CloseEvent ( pTimer );
1602     if ( EFI_ERROR ( Status )) {
1603       DEBUG (( DEBUG_ERROR,
1604                 "ERROR - Failed to free the timer event, Status: %r\r\n",
1605                 Status ));
1606     }
1607     else {
1608       DEBUG (( DEBUG_INFO,
1609                 "0x%08x: Timer Destroyed\r\n",
1610                 pTimer ));
1611       pTimer = NULL;
1612     }
1613   }
1614
1615   //
1616   //  Return the operation status
1617   //
1618   return Status;
1619 }
1620
1621
1622 /**
1623   Send data to the DataSink program to test a network's bandwidth.
1624
1625   @param [in] Argc  The number of arguments
1626   @param [in] Argv  The argument value array
1627
1628   @retval  0        The application exited normally.
1629   @retval  Other    An error occurred.
1630 **/
1631 int
1632 main (
1633   IN int Argc,
1634   IN char **Argv
1635   )
1636 {
1637   EFI_STATUS (* pClose) ();
1638   EFI_STATUS (* pOpen) ();
1639   EFI_STATUS Status;
1640
1641   DEBUG (( DEBUG_INFO,
1642             "DataSource starting\r\n" ));
1643
1644   //
1645   //  Validate the command line
1646   //
1647   if ( 2 > Argc ) {
1648     Print ( L"%s  <remote IP address> [Use TCP]\r\n", Argv[0] );
1649     return -1;
1650   }
1651
1652   //
1653   //  Determine if TCP should be used
1654   //
1655   bTcp4 = (BOOLEAN)( 2 < Argc );
1656
1657   //
1658   //  Determine the support routines
1659   //
1660   if ( bTcp4 ) {
1661     pOpen = Tcp4Open;
1662     pClose = Tcp4Close;
1663     bTcp4Connecting = TRUE;
1664   }
1665   else {
1666     pOpen = SocketOpen;
1667     pClose = SocketClose;
1668   }
1669
1670   //
1671   //  Use for/break instead of goto
1672   //
1673   for ( ; ; ) {
1674     //
1675     //  No bytes sent so far
1676     //
1677     TotalBytesSent = 0;
1678     Samples = 0;
1679     memset ( &BytesSent, 0, sizeof ( BytesSent ));
1680
1681     //
1682     //  Get the IP address
1683     //
1684     pRemoteHost = Argv[1];
1685     Status = IpAddress ( );
1686     if ( EFI_ERROR ( Status )) {
1687       break;
1688     }
1689
1690     //
1691     //  Create the timer
1692     //
1693     bTick = TRUE;
1694     Status = TimerCreate ( );
1695     if ( EFI_ERROR ( Status )) {
1696       break;
1697     }
1698
1699     //
1700     //  Loop forever abusing the specified system
1701     //
1702     do {
1703       //
1704       //  Start a timer to perform connection polling and display updates
1705       //
1706       Status = TimerStart ( 2 * 1000 );
1707       if ( EFI_ERROR ( Status )) {
1708         break;
1709       }
1710
1711       //
1712       //  Open the network connection and send the data
1713       //
1714       Status = pOpen ( );
1715       if ( EFI_ERROR ( Status )) {
1716         break;
1717       }
1718
1719       //
1720       //  Done with the network connection
1721       //
1722       Status = pClose ( );
1723     } while ( !EFI_ERROR ( Status ));
1724
1725     //
1726     //  Close the network connection if necessary
1727     //
1728     pClose ( );
1729
1730     //
1731     //  All done
1732     //
1733     break;
1734   }
1735
1736   //
1737   //  Stop the timer if necessary
1738   //
1739   TimerStop ( );
1740   TimerDestroy ( );
1741
1742   //
1743   //  Return the operation status
1744   //
1745   DEBUG (( DEBUG_INFO,
1746             "DataSource exiting, Status: %r\r\n",
1747             Status ));
1748   return Status;
1749 }