Testing XIA with an echo server

Linux XIA can be tested using an echo application written for the XIA stack. The application, net-echo, can run over TCP/IP's UDP and TCP, as well as XIA's XDP and Serval.

Table of Contents Obtaining net-echo Using net-echo Running the server Running the client Running the corked client

Obtaining net-echo

The net-echo application can be obtained by executing:

 git clone git://github.com/AltraMayor/net-echo.git

To install, follow the instructions in the README file.

Using net-echo

The main files that will be used are:

• eserv.c - an echo server
• ecli.c - an echo client
• eclicork.c - an echo client that supports socket corking

Running the server

The server is equipped to echo plain text and files back to the client, and it returns every packet immediately upon receipt. To run the server, issue one of the following forms:

 ./eserv datagram ip PORT # UDP
 ./eserv stream ip PORT # TCP
 ./eserv datagram xip SERVER_ADDRESS_FILE # XDP
 ./eserv stream xip SERVER_ADDRESS_FILE # Serval

For the IP stack, replace "PORT" to the desired port number on which eserv will accept echo requests. For the XIP stack, replace "SERVER_ADDRESS_FILE" to the name of a file that holds the XIP address that eserv will use to bind its listening socket.

Information about XIP addresses format can be found on the page Human readable XIP address format. The following one-line example file can be used to test eserv with Serval:

 serval-007f4e38904e83634acc7e1340ef7665e3f1f57a-0

Running the client

To run a client, issue the command:

 ./ecli datagram ip IP_ADDRESS PORT # UDP
 ./ecli stream ip IP_ADDRESS PORT # TCP
 ./ecli datagram xip CLIENT_ADDRESS_FILE SERVER_ADDRESS_FILE # XDP
 ./ecli stream xip CLIENT_ADDRESS_FILE SERVER_ADDRESS_FILE # Serval

For the IP stack, replace "IP_ADDRESS" to the IP address of the host where eserv is running, and "PORT" to the port number on which eserv will accept echo requests. For the XIP stack, replace "CLIENT_ADDRESS_FILE" to the name of a file that holds the XIP address that ecli will use to bind its connecting socket, and replace "SERVER_ADDRESS_FILE" to the name of a file that holds the XIP address to reach the server; it can be the same file passed to eserv.

The following one-line example file can be used to test ecli with Serval:

 serval-007f4e38904e83634acc7e1340ef7665e3f1f57b-0

Once the client is running, it accepts both plain text and files to be echoed. The client accepts requests in the form:

 [-f] string

Where "-f" is optionally specified to denote "string" as the name of the file to be sent to the echo server. Otherwise, "string" is interpreted as the plain text to be echoed.

The client will then either print the echoed plain text message, or create an echoed file of the name "<string></string>_echo" which can found in the working directory.

For example, a sample interaction might be:

 $ ./ecli datagram ip 128.197.12.4 9950
 This is a test packet.
 This is a test packet.
 -f file.txt

Note that there is no output written to the standard output device after the last command. The output of echoing a file is a copy of the file in the working directory.

Running the corked client

net-echo also provides an option for the user to run a "corked" client. Using this client, the output socket is "corked" so that even after bytes are written to the socket, a packet will not be sent. The packet will only be sent when the socket is "uncorked," which happens when the socket contains CORK_SIZE bytes. CORK_SIZE is defined in eclicork.c.

To run the corked client, issue one of the following commands:

 ./eclicork datagram ip IP_ADDRESS PORT # UDP
 ./eclicork datagram xip CLIENT_ADDRESS_FILE SERVER_ADDRESS_FILE # XDP

The parameters have the same meaning as for ecli. At the time of this writing, eclicork has not been extended to support TCP and Serval.

While running the client, the user can also specify:

 [-f] string

When enough bytes have been collected in the buffer (specified by CORK_SIZE in the code), the packet is uncorked and the data is echoed. This means that when a new plain text message is written to a socket, part of the message could be sent and part of the message might remain in a new corked buffer until it is released.

Note that if there is already plain text in the buffering packet and the user attempts to echo a file, the socket will be uncorked and the "partial" plain text packet will be released before the file data is processed. Also, when the file has been processed completely, the packet is uncorked as well, so that there is no residual data from the file left in an incomplete packet.

For example, a sample interaction might be:

 $ ./eclicork datagram ip 128.197.12.4 9950
 This is a test packet.
 -f file.txt
 This is a test packet.

Note the difference between this interaction and the one in the above section. Here, “This is a test packet.” is not more than CORK_SIZE bytes (if CORK_SIZE is, say, 64 bytes), so it is held in the packet buffer and not immediately echoed. However, once the file is specified to be echoed, the partial packet is sent before the file is processed.