README.TXT

Sample: Named Pipe Client/Server Demonstration 
 
Summary: 
 
NPCLIENT and NPSERVER demonstrate the use of named pipes. 
The basic design consist of a server application serving 
multiple client applications.  The user can use the client 
applications as an interface to all of the other client 
applications via the server.  The effect is a simple 
communication program that can be used over the network 
between multiple clients. 
 
More Information: 
 
The actual implementation works by having the NPSERVER 
application launch a new thread, which creates and services 
a new instance of the server side of the named pipe every 
time a client connects to it.  You need only start one 
instance of the NPSERVER application.  It will service up to 
100 instances of the NPCLIENT application.  (Note that the 
100 instance limit is hard coded into the sample.  It does 
not reflect the number of named pipe instances you can 
create, which is virtually infinite.) 
 
TO USE: 
 
Start an instance of NPSERVER.  A window will appear. 
 
Start an instance of NPCLIENT.  Two dialog boxes will 
appear, one on top of the other.  The top level dialog box 
will prompt you for a share name and a client or user name. 
If the instance of NPCLIENT is local to (on the same machine 
as) the NPSERVER instance, enter a '.' for the share name. 
Otherwise, enter the machine name of the server that the 
NPSERVER instance was started on, i.e. 'FoobarServer'.  For 
the client or user name, enter any name you wish to be 
identified with.  Hit enter or click the OK button. 
 
The upper dialog box will go away, and you'll see the Client 
dialog box of NPCLIENT.  It consists of two edit fields and 
a 'Send' button.  You will be able to read messages from 
other clients (and yourself) in the larger/upper edit field. 
(Note, if the message seems garbled, make sure the cursor of 
the edit field is located in the lower left hand corner of 
the field.)  The smaller edit field is used to type 
messages.  To send a message: type something in the 
lower/smaller edit field, and hit enter or click the Send 
button.  The message will appear in the larger edit field of 
all the clients connected to the NPSERVER instance; 
prepended by the user name you selected.  Note that the user 
name you selected will be entered into the caption bar of 
the NPCLIENT instance.  This allows you to more easily keep 
track of multiple instances of NPCLIENT on the same machine. 
 
At the same time the top level dialog box was dismissed from 
the NPCLIENT instance, the NPSERVER window was updated with 
the picture of a red spool of thread accompanied by the user 
name you selected.  This red spool indicates an active 
client thread connected to NPSERVER.  The spool may be 
connected to other spools with a thin blue line (similar to 
the way the File Manager connects files or directories). 
Any time a client disconnects from NPSERVER; the spool 
representing it will be grayed out. 
 
DESIGN: 
 
Basically, the NPSERVER application launches multiple 
instances of a server thread.  When the application is 
started, the first thread is created.  It creates an 
instance of the server side of the named pipe, and waits for 
a client to connect.  Once a client connects, another thread 
is started and it too blocks waiting for a client. 
Meanwhile, the first thread updates a global array of client 
information with this specific client's information.  The 
thread then enters a loop reading from this client.  Any 
time this specific client sends a message, this server 
thread will call a function (TellAll) which will write the 
message to all the clients that have been listed in the 
global array. 
 
On the client side, NPCLIENT tries to connect to the named 
pipe with a CreateFile call.  Once it has connected, it 
creates a thread which loops and reads any message from the 
server side.  Once a message is read, it is printed in the 
larger edit field.  Any time the user hits the Send button, 
the main thread grabs any text in the lower edit field, and 
writes it to the server. 
 
The steps between NPSERVER and an instance of NPCLIENT looks 
like this: 
 
   NPSERVER                          NPCLIENT 
   --------                          -------- 
 
   CreateNamedPipe() 
   ConnectPipe()   // Blocks 
                                      CreateFile()  //Connects to pipe. 
                                      spawn separate thread to read pipe 
   return from block 
   updates array of clients 
   spawn another server thread 
   Loop 
     ReadFile() // Blocks on overlap 
                                      WriteFile() // User hits Send. 
 
     return from block 
     WriteFile() // Broadcast to clients 
   End loop      // When client breaks pipe. 
 
 
                                      ReadPipe Thread: 
                                        Loop 
                                          ReadFile() 
                                            block till server broadcasts 
 
                                            return from block. 
                                            put string in edit field. 
 
                                         End loop // when server breaks. 
 
The overlapped structure should be used anytime a pipe is 
expected to block for any length of time on a read or write. 
This allows the thread to return immediately from a read or 
write to service any other part of your application.  The 
overlapped structure should also be used on a named pipe 
anytime you expect to do simultaneous reads and writes.