---------------------------------------
 WAL.EXE: WinSock application launcher
---------------------------------------

This application was not referenced at all by the book _Windows 
Sockets Network Programming_  by Bob Quinn and Dave Shute (published 
by Addison-Wesley, Reading, MA ISBN: 0-201-63372-8), but it was
a tool created and used for exploration and development of many
programming techniques described throughout the text.  It's like 
a black box with many different knobs and displays.  It may seem 
overwhelming at first glance, but it is really quite simple to use.

What it does: It can act as a client or server application,
 using TCP or UDP, in blocking, nonblocking or asynchronous operation
 mode, sending or receiving or both. It has many operational parameters,
 many of which can be adjusted on-the-fly during execution, and
 it allows setting and getting socket options as it executes also.
 It implements several simple protocols: echo (RFC 862), discard (RFC 
 863), and chargen (RFC 864).

What it illustrates: It is a WinSock exploration, experimentation
 and benchmarking tool that illustrates how a WinSock implementation
 behaves in certain conditions. Most significantly, it illustrates
 the effects of looping on recv() calls in response to asynchronous
 FD_READ event notification, and investigates how to adjust the
 read loop dynamically.

How to Use it: Typically, the first menu item to select
 is "Start," which displays the "Applications Options"
 dialog box. You can select the operation mode (blocking, non-blocking,
 or asynchronous), the transport protocol (TCP or UDP), and the
 application role (a client or server). If you choose to run as
 a client, you need to enter a destination host or address before
 you press the "Start!" button to initiate execution.
 There are a number of I/O parameters you can change by pressing
 the "Options" button..

  - The "Control" menu item has a pull-down menu that 
     allows you to open a new socket without starting a connection
     first. You can also close an existing connection gracefully, or
     abort it by resetting the connection.
  - The "Options" menu item has a pull-down menu with
     commands that change and examine socket options using setsockopt()
     and getsockopt(). You can also access the same application "I/O
     options" dialog available from the "Start" dialog.
     Any option can be changed "on-the-fly" as data is transferred
     during execution.
  - The "Statistics" menu item allows you to reset the
     counter values currently displayed in the main window to zero.
     The "Update" command forces an update of the statistics
     when the application is in a tight loop (i.e. when the timer messages
     that normally initiate update are not available).

Known Problems: The OOB implementation needs an application--which
 isn't available here--to receive the OOB data sent, and send some
 OOB data back. The detailed statics (avaliable from the "Statistics"
 menu item), causes the application to fail in the 32-bit version.
 It could benefit greatly from the addition of scripting and logging
 features. There are some application settings that can have problems
 during execution; for example, reading a constant stream of incoming
 data with a non-blocking socket (from the chargen port, for instance)
 can make the application unresponsive to user input.

 Also, running WAL as an echo server can have the same problems
 that AS_ECHO does when run against a client that sends faster
 than it receives. See the Known Problems section for AS_ECHO for
 more information.

File List: 
 WAL\ASYNC.C: Asynchronous operation mode routines
 WAL\BLOCKING.C: Blocking operation mode routines
 WAL\DEBUG.C:
 WAL\ERRNO.C 
 WAL\IDWALICO.ICO 
 WAL\NONBLKNG.C: Non-blocking operation mode routines 
 WAL\RESOURCE.H 
 WAL\WAL.MAK Makefile for 16-bit wal.exe 
 WAL\WAL32.MAK Makefile for 32-bit wal32.exe 
 WAL\OOBDATA.C: TCP out-of-band data routines
 WAL\WAL.DEF 
 WAL\WAL.H 
 WAL\WAL.INI Sample default settings file 
 WAL\WAL.RC 
 WAL\WAL.C

--------
 NOTES:
--------

We used Microsoft Visual C++ enviroments (versions 1.52 for 16-bit,
and version 2.1 for 32-bit) to create most of the makefiles.
Unfortunately, because the paths are hard-coded in the file, you will
have to bring the project files (.mak) into the respective MS C++
environments to readjust things to the new directory, and even then
you will have to manually alter the project to access the library
files (the are in the root of the directory where you install the
samples).

All samples--including the sample DLL and static library--have a
number of other things in common:

  - They all have 32-bit versions, and all 32-bit version names
     end with "32" (16-bit versions don't have a number).
  - They use the WSAperror() function from #WINSOCKX">WINSOCKX.LIB
    to display error values and short descriptions when an unexpected
    error occurs.
  - They display error messages on any suspicious error condition.
     They don't hide errors, but report them whenever they occur. As
     we describe n a_c.htm">Appendix C: WinSock Error Reference,
     these error messages should appear only when a "user fixable
     error" occurs. If you get an error message from a sample
     application for a non user-fixable error, then this may
     indicate an anomoly in the WinSock implementation that your applications
     may need to deal with. We show you the errors on purpose, to make
     you aware of unexpected conditions.
  - They have a minimal user interface, and do not have help (.HLP)
     files available.
  - They are meant to be played with. They are for exploration
     and experimentation as well as to illustrate how to write WinSock
     applications.

The icons used for each sample don't mean much, but they meet
the following three criteria:

    - They each contain the socket from the official WinSock icon.
    - Each one is colorful in its own unique and wonderful way.
    - Each took under 10 minutes to create.

