/******************************************************************************\
*       This is a part of the Microsoft Source Code Samples.
*       Copyright 1996-1997 Microsoft Corporation.
*       All rights reserved.
*       This source code is only intended as a supplement to
*       Microsoft Development Tools and/or WinHelp documentation.
*       See these sources for detailed information regarding the
*       Microsoft samples programs.
\******************************************************************************/

/*
Module Name:

    bcast.c

Abstract:

    This module illustrates the Win32 Winsock and Mailslot APIs to do a generic
    broadcast over IPX, UDP and Mailslot protocols.

    This example implements a client and a server. The example has a number of
    command line options. For example,

    -s To run the example as a server(default role).
	
	-c To run the example as a client.
   
	-p <i or m or u> To specify the protocol to be used.
	 i - IPX.
	 m - Mailslots.
	 u - UDP(default protocol).
	
    -e <Endpoint> To specify an end point of your choice. This is a mandatory
	parameter. Servers create this endpoint and read broadcast messages. An 
	endpoint in case Mailslot protocol is a Mailslot name.(default is 5005). 
	
    -d <DomainName> - To specify a domain name or a workgroup name. This is 
	useful for Mailslot clients, only.

	To run the application as a server, the following command lines can be 
	specified:
    
	bcast -s -e 8000 -p u
	bcast -s -e 8000 -p i
	bcast -s -e MAILSLOT1 -p m

	To run the application as a client, the following command lines can be
	specified:
	
	bcast -c -e 8000 -p u
	bcast -c -e 8000 -p i
	bcast -c -e MAILSLOT1 -p m -d DOMAIN1
	bcast -c -e MAILSLOT1 -p m -d WORKGROUP1

Author:

    Rajesh Dadhia (rajeshd) 02-Mar-96

Revision History:

*/

#include <stdio.h>
#include <time.h>
#include <windows.h>
#include <winsock.h>
//#include <wsipx.h>
//#include <wsnwlink.h>
#include <Ws2spi.h>


#define MAX_MSGLEN 80
#define MAX_ADDLEN 80
#define MAX_MSLOTNAME 80

//#define INADDR_BROADCAST        (u_long)0x8443ffff

typedef enum _MODE { CLIENT=0, SERVER } MODE;
typedef enum _PROTOCOL { UDP=0, IPX, MAILSLOT } PROTOCOL;

BOOL __stdcall
CtrlCHandler (
    DWORD dwEvent
    );
/*
void __stdcall
DoMailSlot (
    MODE mRole,
    LPSTR lpsEndPoint,
    LPSTR lpsDomainName
    );

void __stdcall
DoIpx (
    MODE mRole,
    USHORT usEndPoint
    );
*/
void __stdcall
DoUdp (
    MODE mRole,
    USHORT usEndPoint
    );

/*void __stdcall
DoMailSlotServer (
    LPSTR lpsEndPoint
    );

void __stdcall
DoMailSlotClient (
    LPSTR lpsEndPoint,
    LPSTR lpsDomainName
    );
*/ 
void __stdcall
DoUdpServer (
    USHORT usEndPoint
    );

void __stdcall
DoUdpClient (
    USHORT usEndPoint
    );

/*void __stdcall 
DoIpxServer (
    USHORT usEndPoint
    );

void __stdcall
DoIpxClient (
    USHORT usEndPoint
    );
*/
void __stdcall
Usage (
    CHAR *pszProgramName
    );

void __stdcall
PrintError (
    LPSTR lpszRoutine,
    LPSTR lpszCallName,
    DWORD dwError
    );

/*CHAR * __stdcall
IpxnetAddr (
    CHAR *lpBuffer,
	CHAR *lpsNetnum, 
	CHAR *lpsNodenum 
	);
*/
void __stdcall
DoStartup ( void );

void __stdcall
DoCleanup ( void );

//
// Global Variables
//

// If Startup was successful, fStarted is used to keep track.
BOOL fStarted = FALSE;

// Global socket descriptor
SOCKET sock = INVALID_SOCKET;

void __cdecl
main (
    INT argc,
    CHAR **argv
    )
{

  // Default role of the application is SERVER, which means receiver of
  // the broadcast messages.
  //MODE mRole = SERVER;
  MODE mRole = CLIENT;
  
  // Deafult protocol used is UDP.
  PROTOCOL pProto = UDP;
  
  // Default Endpoint.
  USHORT usEndPoint = 5005;
  
  // Strings pointing to Endpoint and DomainName(necessary for Mailslots).
  // eddiea LPSTR lpsEndPoint, lpsDomainName;
  INT  i;
  CHAR chProto;

    //
    // Install the CTRL+BREAK Handler
    //
    if ( FALSE == SetConsoleCtrlHandler ( (PHANDLER_ROUTINE) CtrlCHandler,
					  TRUE 
					  ) ) 
    {
	PrintError ( "main", "SetConsoleCtrlHandler", GetLastError ( ) );
    }  
  
    //
    // allow the user to override settings with command line switches
    //
    for ( i = 1; i < argc; i++ ) 
    {
	if ( ( *argv[i] == '-' ) || ( *argv[i] == '/' ) ) 
	{
	    switch ( tolower ( *( argv[i]+1 ) ) ) 
	    {
		//
		// Role of the application (Client - Sender of broadcasts).
		//
		case 'c':  
		    mRole = CLIENT;
		    break;

		//
		// Role of the application (Server - Receiver of broadcasts)
		//
		case 's':  
		    mRole = SERVER;
		    break;

		//
		// Network protocol (Mailslots, IPX or UDP).
		//
		case 'p':
		    chProto = tolower ( *argv[++i] );
		    if ( 'm' == chProto )
		    {
			pProto = MAILSLOT;
		    }
		    else if ( 'i' == chProto )
		    {
			pProto = IPX;
		    }
		    else
			pProto = UDP;
		    break;
		
		//
		// EndPoint.
		//
		case 'e': 
		    //eddiea lpsEndPoint = argv[++i];
			usEndPoint = atoi (argv[++i]);
		    break;
		
		//
		// DomainName (Important for Mailslot broadcasts, only).
		//
		//case 'd':
		//    lpsDomainName = argv[++i];
		//    break;

		//
		// Help.
		//
		case 'h':
		case '?':
		default:
		    Usage ( argv[0] );
	    }
	}
	else
	    //
	    // Help.
	    //
	    Usage ( argv[0] );
    }

    
    //
    // If the protocol specified is not MAILSLOT, convert the endpoint
    // information to integer format from the string format.
    //
    /*if ( MAILSLOT != pProto )
	{
	usEndPoint = atoi ( lpsEndPoint );
    }*/

    //
    // Print a Summary of the switches specfied 
    // Helpful for debugging
    //
	printf("I am at the summery \n");
    fprintf ( stdout, "SUMMARY:\n" );
    fprintf ( stdout, "\tRole-> %s\n", (CLIENT == mRole)?"Client":"Server" );
    fprintf ( stdout, "\tProtocol-> %s\n","UDP" );
    fprintf ( stdout, "\tEndpoint-> %d\n", /*lpsEndPoint*/ usEndPoint);
    
    //
    // Check the protocol specified.
    // Call the appropriate handler rouine. By default the protocol
    // is UDP.
    //
/*    switch ( pProto )
    {
	case MAILSLOT :
	    DoMailSlot ( mRole, lpsEndPoint, lpsDomainName );
	    break;

	case IPX:
	    DoStartup ( );
	    DoIpx ( mRole, usEndPoint );
	    break;

	default:*/
	    DoStartup ( );
	    DoUdp ( mRole, usEndPoint );
	    // break;

	
    return;
}

//
// CtrlCHandler () intercepts the CTRL+BREAK or CTRL+C events and calls the
// cleanup routines.
//
BOOL __stdcall
CtrlCHandler (
    DWORD dwEvent
	)
{
    if ( ( CTRL_C_EVENT == dwEvent ) || ( CTRL_BREAK_EVENT == dwEvent ) )
    {
	DoCleanup ( );    
    }

    return FALSE;
}

//
// DoMailSlot () function calls appropriate handler function (client/server),
// if protocol=MAILSLOT is specified. By default, the role of the application
// is - SERVER.
//
/*void __stdcall
DoMailSlot (
    MODE mRole,
    LPSTR lpsEndPoint,
    LPSTR lpsDomainName
    )
{
    switch ( mRole )
    {
	case CLIENT:
	    DoMailSlotClient ( lpsEndPoint, lpsDomainName );
	    break;

	default:
	    DoMailSlotServer ( lpsEndPoint );
    }
	return;
}

//
// DoIpx () function calls appropriate handler function (client/server),
// if protocol=IPX  is specified. By default, the role of the application
// is - SERVER.
//
void __stdcall
DoIpx (
    MODE mRole,
    USHORT usEndPoint
    )
{
    //
    // Initialize the global socket descriptor.
    //
    sock = socket ( AF_IPX, SOCK_DGRAM, NSPROTO_IPX );

    if ( INVALID_SOCKET ==  sock )
    {
	PrintError( "DoIpx", "socket", WSAGetLastError ( ) );
    }

    switch ( mRole )
    {
	case CLIENT:
	    DoIpxClient ( usEndPoint );
	    break;

	default:
	    DoIpxServer ( usEndPoint );
    }
	return;
}

*/
//
// DoUdp () function calls appropriate handler function (client/server),
// if protocol=UDP  is specified. By default, the role of the application
// is - SERVER.
//
void __stdcall
DoUdp (
    MODE mRole,
    USHORT usEndPoint
    )
{
    //
    // Initialize the global socket descriptor.
    //
    sock = socket ( AF_INET, SOCK_DGRAM, 0 );

    if ( INVALID_SOCKET ==  sock)
    {
	PrintError ( "DoUdp", "socket", WSAGetLastError() );
    }
    
    switch ( mRole )
    {
	case CLIENT:
	    DoUdpClient ( usEndPoint );
	    break;

	default:
	    DoUdpServer ( usEndPoint );
    }
    return;
}

//
// DoMailSlotServer () function receives a mailslot message on a particular
// mailslot. The function creates a mailslot, posts a ReadFile () to receive
// the message. The function then checks the first four bytes of the message
// for the message ID, and discards all the messages with same ID, in future.
//
/*void __stdcall
DoMailSlotServer (
    LPSTR lpsEndPoint
    )
{
  HANDLE hSlot;
   
  // Variables that store MessageID, previous messageID, number of bytes to 
  // read/read, size of next available message and the number of messages.
  DWORD dwMessageID,
	dwPrevID,
	cbMessage,
	cbRead, 
	cbToRead, 
	nMessages;
  
  BOOL fResult;
  
  CHAR achMailSlotName[MAX_MSLOTNAME], 
       achBuffer[MAX_MSGLEN + sizeof ( DWORD )];
  
  // Variable that points past the message ID part in the message.
  LPSTR lpsMessage;

    //
    // Create a string for the mailslot name.
    //
    wsprintf ( achMailSlotName, "\\\\.\\mailslot\\%s", lpsEndPoint );

    //
    // Create the mailslot.
    //
    hSlot = CreateMailslot ( achMailSlotName,
			     0,
			     MAILSLOT_WAIT_FOREVER,
			     (LPSECURITY_ATTRIBUTES) NULL
			     );

    if ( INVALID_HANDLE_VALUE == hSlot )
    {
	PrintError ( "DoMailSlotServer",  "CreateMailSlot", GetLastError() );
    }

    //
    // Post ReadFile() and read a message.
    //
    cbToRead = MAX_MSGLEN + sizeof (DWORD);

    fResult = ReadFile ( hSlot,
			 achBuffer,
			 cbToRead,
			 &cbRead,
			 (LPOVERLAPPED) NULL
			 );
    
    if ( TRUE != fResult )
    {
	PrintError ( "DoMailSlotServer", "ReadFile", GetLastError() );
    }
	
    achBuffer[cbRead] = '\0';

    //
    // Get the message ID part from the message.
    //
    memcpy ( &dwMessageID, achBuffer, sizeof ( DWORD ) );

    //
    // Adjust the actual message pointer.
    //
    lpsMessage = achBuffer + sizeof ( DWORD );
	    
    //
    // Print the message
    //
    fprintf ( stdout, 
	      "A MailSlot Message of %d bytes received with ID %d\n", 
              strlen (lpsMessage ), 
              dwMessageID 
              );

    fprintf ( stdout, "MessageText->%s\n", lpsMessage );

    //
    // Check for duplicate messages.
    //
    dwPrevID = dwMessageID;
    
    while ( 1 )
    {
	//
	// get information on pending messages.
	//
	fResult = GetMailslotInfo ( hSlot,
				    (LPDWORD) NULL,
				    &cbMessage, 
				    &nMessages,
				    (LPDWORD) NULL
				    );
	if ( TRUE != fResult )
	{ 
	    PrintError ( "DoMailSlotServer", 
			 "GetMailSlotInfo", 
			 GetLastError ( ) 
			 );
	}
									
	//
	// Break if no more messages.
	//
	if ( MAILSLOT_NO_MESSAGE == cbMessage )
		break;

	//
	// We now know how much to read.
	//
	cbToRead = cbMessage;
	fResult = ReadFile ( hSlot,
			     achBuffer,
			     cbToRead,
			     &cbRead,
			     (LPOVERLAPPED) NULL
			     );

	if ( TRUE != fResult )
	{
	    PrintError ( "DoMailSlotServer",
			 "ReadFile", 
			 GetLastError ( ) 
			 );
	}
    
	achBuffer[cbRead] = '\0';
	memcpy ( &dwMessageID, achBuffer, sizeof (DWORD) );

	//
	// print the message only if it is not a duplicate.
	//
	lpsMessage = achBuffer + sizeof (DWORD);
	if ( dwMessageID != dwPrevID )    
	{
	    fprintf ( stdout, 
		      "A MailSlot Message of %d bytes received with ID %d\n", 
		      strlen (lpsMessage ), 
		      dwMessageID 
		      );

	    fprintf ( stdout, "MessageText->%s\n", achBuffer );
	}
	
	dwPrevID = dwMessageID;
    }
    
    //
    // Close the handle to our mailslot.
    //
    fResult = CloseHandle ( hSlot );

    if ( TRUE != fResult )
    {
	PrintError ( "DoMailSlotServer", "CloseHandle", GetLastError() );
    }
    return;
}*/

//
// DoMailSlotClient () function implements the broadcast routine for a
// Mailslot client. The function opens handle to the mailslot using 
// CreateFile (). CreateFile will fail on Windows NT for local mailslots,
// if the mailslot is not already created using CreateMailSlot () API. 
//  
// The function appends a message number to the message which the server uses
// to discard duplicate messages. In the event of a client runnig on a system
// with multiple transport protocols loaded, a mailsot message is sent over
// each protocol.
//
// This routine broadcasts a mailslot message to everyone on a Windows NT
// domain, it can also be used to send a mailslot message to a particular
// host or a workgroup.
//
/*void __stdcall
DoMailSlotClient (
    LPSTR lpsEndPoint,
    LPSTR lpsDomainName
    )
{
  HANDLE hFile;
  
  // Variables that store MessageID, number of bytes to write/written.
  DWORD dwMessageID, 
	cbWritten,
	cbToWrite;
  
  BOOL fResult;
  
  CHAR achMailSlotName[MAX_MSLOTNAME],
       achBuffer[MAX_MSGLEN + sizeof ( DWORD ) ];
 
    if ( NULL == lpsDomainName )
    {
	fprintf ( stdout, 
		  "Domain/Workgroup name must be specified....Exiting\n"
		  );
	exit ( 1 );
    }
  
    //
    // Create a string for the mailslot name.
    //
    wsprintf ( achMailSlotName,
	       "\\\\%s\\mailslot\\%s",
	       lpsDomainName,
	       lpsEndPoint 
	       );

    //
    // Open a handle to the mailslot.
    //
    hFile = CreateFile ( achMailSlotName,
			 GENERIC_WRITE,
			 FILE_SHARE_READ,
			 (LPSECURITY_ATTRIBUTES) NULL,
			 OPEN_EXISTING,
			 FILE_ATTRIBUTE_NORMAL,
			 (HANDLE) NULL 
			 );
    
    if ( INVALID_HANDLE_VALUE == hFile)
    {
	PrintError ( "DoMailSlotClient", "CreateFile", GetLastError ( ) );
    }
    
    //
    // Generate a Message ID.
    //
    srand ( (UINT) time ( NULL) );
    dwMessageID = rand ( );

    memcpy ( achBuffer, &dwMessageID, sizeof ( DWORD ) );
    lstrcpy ( achBuffer + sizeof (DWORD), "A MailSlot Broadcast Message" );

    //
    // Total number of bytes to write.
    //
    cbToWrite = sizeof ( DWORD ) + strlen ( achBuffer + sizeof ( DWORD ) );
	
    //
    // Send a mailslot message.
    //
    fResult = WriteFile ( hFile,
			  achBuffer,
			  cbToWrite,
			  &cbWritten,
			  (LPOVERLAPPED) NULL
			  );

    if ( TRUE != fResult )
    {
	PrintError ( "DoMailSlotClient", "WriteFile", GetLastError ( ) );
    }

    fprintf ( stdout, 
	      "%d bytes of MailSlot data broadcasted with ID %d\n", 
	      cbWritten, 
	      dwMessageID
	      );
    
    //
    // Close the mailslot handle.
    //
    fResult = CloseHandle ( hFile );

    if ( TRUE != fResult )
    {
	PrintError ( "DoMailSlotClient", "CloseHandle", GetLastError() );
    }
    return;
}*/

//
// DoUdpServer () function receives the broadcast on a specified port. The
// server will have to post a recv (), before the client sends the broadcast.
// 
void __stdcall
DoUdpServer (
    USHORT usEndPoint
    )
{
  
  // IP address structures needed to bind to a local port and get the sender's
  // information.
  SOCKADDR_IN saUdpServ, saUdpCli;
  
  INT err, nSize;
  
  CHAR achBuffer[MAX_MSGLEN];

    //
    // bind to the specified port.
    //
    saUdpServ.sin_family = AF_INET;
    saUdpServ.sin_addr.s_addr = htonl ( INADDR_ANY );
    saUdpServ.sin_port = htons ( usEndPoint );

    err = bind ( sock, (SOCKADDR FAR *)&saUdpServ, sizeof ( SOCKADDR_IN ) );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoUdpServer", "bind", WSAGetLastError ( ) );
    }

    //
    // receive a datagram on the bound port number.
    //
    nSize = sizeof ( SOCKADDR_IN );
    err = recvfrom ( sock,
		     achBuffer,
		     MAX_MSGLEN,
		     0,
		     (SOCKADDR FAR *) &saUdpCli,
		     &nSize
		     );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoUdpServer", "recvfrom", WSAGetLastError ( ) );
    }
     
    //
    // print the sender's information.
    //
    achBuffer[err] = '\0';
    fprintf ( stdout, "A Udp Datagram of length %d bytes received from ", err );
    fprintf ( stdout, "\n\tIP Adress->%s ", inet_ntoa ( saUdpCli.sin_addr ) );
    fprintf ( stdout, "\n\tPort Number->%d\n", ntohs ( saUdpCli.sin_port ) );
    fprintf ( stdout, "MessageText->%s\n", achBuffer );

    //
    // Call the cleanup routine
    //
    DoCleanup ( );
      
    return;
}

//
// DoUdpClient () function implements the broadcast routine for an UDP
// client. The function sets the SO_BROADCAST option with the global socket.
// Calling this API is important. After binding to a local port, it sends an 
// UDP boradcasts to the IP address INADDR_BROADCAST, with a particular
// port number.
//
void __stdcall
DoUdpClient (
    USHORT usEndPoint
    )
{
  
  // IP address structures needed to fill the source and destination 
  // addresses.
  SOCKADDR_IN saUdpServ, saUdpCli;
  
  INT err;
  
  CHAR achMessage[MAX_MSGLEN];

  CHAR Socket_options[MAX_MSGLEN];
  
  // Variable to set the broadcast option with setsockopt ().
  BOOL fBroadcast = TRUE;


	printf("In the DOUdpClient function \n");
    err = setsockopt ( sock, 
		       SOL_SOCKET,
		       SO_BROADCAST,
		       (CHAR *) &fBroadcast,
		       sizeof ( BOOL )
		       );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoUdpClient", "setsockopt", WSAGetLastError ( )  );
    }

    //
    // bind to a local socket and an interface.
    //
    saUdpCli.sin_family = AF_INET;
    saUdpCli.sin_addr.s_addr = htonl ( INADDR_ANY );
    saUdpCli.sin_port = htons ( 0 );

    err = bind ( sock, (SOCKADDR *) &saUdpCli, sizeof (SOCKADDR_IN) );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoUdpClient", "bind", WSAGetLastError ( ) );
    }

    //
    // Fill an IP address structure, to send an IP broadcast. The 
    // packet will be broadcasted to the specified port.
    //
    saUdpServ.sin_family = AF_INET;
    saUdpServ.sin_addr.s_addr = htonl ( INADDR_BROADCAST );
    saUdpServ.sin_port = htons ( usEndPoint );
	
	printf("The bytes are: b1=%d, b2=%d, b3=%d, b4=%d\n",
			saUdpServ.sin_addr.S_un.S_un_b.s_b1,
			saUdpServ.sin_addr.S_un.S_un_b.s_b2,
			saUdpServ.sin_addr.S_un.S_un_b.s_b3,
			saUdpServ.sin_addr.S_un.S_un_b.s_b4);
	
	int WSPIoctl (
		/*SOCKET													*/ sock,
		/*DWORD dwIoControlCode										*/ SIO_GET_BROADCAST_ADDRESS,
		/*LPVOID lpvInBuffer,										*/ NULL,
		/*DWORD cbInBuffer,											*/ 0,
		/*LPVOID lpvOutBuffer,										*/ Socket_options,
		/*DWORD cbOutBuffer,										*/ sizeof(Socket_options),
		/*LPDWORD lpcbBytesReturned,								*/ sizeof(Socket_options),
		/*LPWSAOVERLAPPED lpOverlapped,								*/ NULL,	
		/*LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,	*/ (LPWSAOVERLAPPED_COMPLETION_ROUTINE   *) NULL,
		/*LPWSATHREADID lpThreadId,									*/ NULL,
		/*LPINT lpErrno												*/ NULL,
		);



	lstrcpy ( achMessage, "This Message was sent as a broadcast datagram" );
  
    err = sendto ( sock,
		   achMessage,
		   lstrlen ( achMessage ),
		   0,
		   (SOCKADDR *) &saUdpServ,
		   sizeof ( SOCKADDR_IN )
		   );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoUdpClient", "sendto", WSAGetLastError ( ) );
    }

    fprintf ( stdout, "%d bytes of data broadcasted\n", err );

    //
    // Call the cleanup routine.
    //
    DoCleanup ( );

    return;
}


//
// DoIpxServer () function receives the broadcast on a specified socket. The
// server will have to post a recv (), before the client sends the broadcast. 
// It is necessary call setsockopt () with SO_BROADCAST flag set, in order to
// receive IPX broadcasts on Windows 95.
//
/*void __stdcall 
DoIpxServer (
    USHORT usEndPoint
    )
{
   
  // IPX address structures needed to bind to a local socket and get the
  // sender's information.
  SOCKADDR_IPX saIpxServ, saIpxCli;
  
  INT err, nSize;
  
  CHAR achBuffer[MAX_MSGLEN], 
	   achAddress[MAX_ADDLEN];
  
  OSVERSIONINFO osVer;
  
  // Variable to set the broadcast option with setsockopt ().
  BOOL fResult, fBroadcast = TRUE;

    //
    // Check the platform.
    //
    osVer.dwOSVersionInfoSize = sizeof ( OSVERSIONINFO );
    fResult  = GetVersionEx ( &osVer);

    if ( FALSE == fResult)
    {
        PrintError ( "DoIpxServer", "GetVersionEx", GetLastError ( ) );
    }

    //
    // If the platform is Windows 95, call setsockopt ().
    //
    if ( VER_PLATFORM_WIN32_WINDOWS == osVer.dwPlatformId )
    {   
	err = setsockopt ( sock, 
			   SOL_SOCKET, 
			   SO_BROADCAST, 
			   (CHAR *) &fBroadcast, 
			   sizeof ( BOOL ) 
			   );

	if ( SOCKET_ERROR == err )
	{
	    PrintError ( "DoIpxServer", "setsockopt", WSAGetLastError() );
	}
    }

    //
    // bind to the specified socket.
    //
    saIpxServ.sa_family = AF_IPX;
    saIpxServ.sa_socket = usEndPoint;
    memset ( saIpxServ.sa_netnum, 0, sizeof (saIpxServ.sa_netnum ) );
    memset ( saIpxServ.sa_nodenum, 0, sizeof (saIpxServ.sa_nodenum ) );

    err = bind ( sock, (SOCKADDR *) &saIpxServ, sizeof (SOCKADDR_IPX) );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoIpxServer", "bind", WSAGetLastError ( ) );
    }

    //
    // receive a datagram on the bound socket number.
    //
    nSize = sizeof ( SOCKADDR_IPX );
    err = recvfrom ( sock,
		     achBuffer,
		     MAX_MSGLEN,
		     0,
		     (SOCKADDR *) &saIpxCli,
		     &nSize 
		     );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoIpxServer", "recvfrom", WSAGetLastError ( ) );
    }
    
    //
    // print the sender's information.
    //
    achBuffer[err] = '\0';
    fprintf ( stdout, 
	      "An Ipx Datagram of length %d bytes received from ", 
	      err );
    fprintf ( stdout, 
	      "\n\tIPX Adress->%s ", 
	      IpxnetAddr ( achAddress, 
			   saIpxCli.sa_netnum, 
			   saIpxCli.sa_nodenum 
			   ) 
	      );
    fprintf ( stdout, "\n\tSocket Number->%d\n", saIpxCli.sa_socket );
    fprintf ( stdout, "MessageText->%s\n", achBuffer );
    
    //
    // Call the cleanup routine.
    //
    DoCleanup ( );
    return;

} */

//
// DoIpxClient () function implements the broadcast routine for a an IPX
// client. The fucntion sets the SO_BROADCAST option with the gloabal socket.
// Calling this API is important. After binding to a local port, it sends an IPX
// packet to the address with node number as all 1's and net number as all 0's,
// with a particuler socket number.
//

/*void __stdcall
DoIpxClient (
    USHORT usEndPoint
	)
{
   
  // IPX address structures needed to fill the source and destination 
  // addresses.
  SOCKADDR_IPX saIpxServ, saIpxCli;
  
  INT err;
  
  CHAR achMessage[MAX_MSGLEN];
  
  // Variable to set the broadcast option with setsockopt ().
  BOOL fBroadcast = TRUE;
    
  err = setsockopt ( sock, 
		     SOL_SOCKET, 
		     SO_BROADCAST,
		     (CHAR *) &fBroadcast, 
		     sizeof ( BOOL ) 
		     );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoIpxClient", "setsockopt", WSAGetLastError ( ) );
    }

    //
    // bind to a local socket and an interface.
    //
    saIpxCli.sa_family = AF_IPX;
    saIpxCli.sa_socket = (USHORT) 0;
    memset ( saIpxCli.sa_netnum, 0, sizeof ( saIpxCli.sa_netnum ) );
    memset ( saIpxCli.sa_nodenum, 0, sizeof ( saIpxCli.sa_nodenum ) );

    err = bind ( sock, (SOCKADDR  *) &saIpxCli, sizeof ( SOCKADDR_IPX ) );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoIpxClient", "bind", WSAGetLastError() );
    }

    //
    // Fill an IPX address structure, to send an IPX broadcast. The 
    // packet will be broadcasted to the specified socket.
    // 
    saIpxServ.sa_family = AF_IPX;
    saIpxServ.sa_socket = usEndPoint;
    memset ( saIpxServ.sa_netnum, 0, sizeof ( saIpxServ.sa_netnum ) );
    memset ( saIpxServ.sa_nodenum, 0xFF, sizeof ( saIpxServ.sa_nodenum ) );

    lstrcpy ( achMessage, "A Broadcast Datagram" );
  
    err = sendto ( sock,
		   achMessage,
		   lstrlen ( achMessage ),
		   0,
		   (SOCKADDR *) &saIpxServ,
		   sizeof ( SOCKADDR_IPX )
		   );

    if ( SOCKET_ERROR == err )
    {
	PrintError ( "DoIpxClient", "sendto", WSAGetLastError ( ) );
    }

    fprintf ( stdout, "%d bytes of data broadcasted\n", err);

    //
    // Call the cleanup routine.
    //
    DoCleanup ( );

    return;
}*/

//
// Usage () lists the available command line options.
//
void __stdcall
Usage (
    CHAR *pszProgramName
	)
{
    fprintf ( stderr, "Usage:  %s\n", pszProgramName );
    fprintf ( stderr, 
	"\t-s or -c (s - server, c - client, default - server)\n" );
    fprintf ( stderr, 
	"\t-p <i or m or u> (i - IPX, m - Mailslots, u - UDP)\n" );
    fprintf ( stderr, "\t-e <Endpoint>\n" );
    fprintf ( stderr, 
		"\t-d <DomainName> - needed only for a Mailslot client\n" );
    fprintf ( stderr, 
	"\n\tDefault Values-> Role:Server, Protocol:UDP, EndPoint:5005\n" );
    
	exit ( 1 );
}


//
// PrintError () is a function available globally for printing the error and 
// doing the cleanup.
//
void __stdcall
PrintError (
    LPSTR lpszRoutine,
	LPSTR lpszCallName,
	DWORD dwError
	)
{

    fprintf ( stderr, 
	      "The Call to %s() in routine() %s failed with error %d\n", 
	      lpszCallName, 
	      lpszRoutine,
	      dwError 
	      );

    DoCleanup ( );

    exit ( 1 );
}

//
// IpxnetAddr () function converts an IPX address address in the binary form
// to ascii format, it fills the input buffer with the address and returns a
// pointer to it.
//
CHAR * __stdcall
IpxnetAddr (
    CHAR *lpBuffer,
    CHAR *lpsNetnum, 
    CHAR *lpsNodenum 
    )
{
    wsprintf ( lpBuffer, 
	       "%02X%02X%02X%02X.%02X%02X%02X%02X%02X%02X",
	       (UCHAR) lpsNetnum[0], (UCHAR) lpsNetnum[1], 
	       (UCHAR) lpsNetnum[2], (UCHAR) lpsNetnum[3],
	       (UCHAR) lpsNodenum[0], (UCHAR) lpsNodenum[1],
	       (UCHAR) lpsNodenum[2], (UCHAR) lpsNodenum[3],
	       (UCHAR) lpsNodenum[4], (USHORT) lpsNodenum[5]
	       );

    return ( lpBuffer);
}

//
// DoStartup () initializes the Winsock DLL with Winsock version 1.1
//
void __stdcall
DoStartup ( void )
{
  WSADATA wsaData;
  
  INT iRetVal;

    iRetVal = WSAStartup ( MAKEWORD ( 1,1 ), &wsaData );
	
    if ( 0 != iRetVal)
    {
	PrintError ( "DoStartup", "WSAStartup", iRetVal );
    }
    
    //
    // Set the global flag.
    //
    fStarted = TRUE;
 
    return;
}

//
// DoCleanup () will close the global socket which was opened successfully by
// a call to socket (). Additionally, it will call WSACleanup (), if a call
// to WSAStartup () was made successfully.
//
void __stdcall
DoCleanup ( void )
{
    if ( INVALID_SOCKET != sock )
    {
	closesocket ( sock );
    }

    if ( TRUE == fStarted )
    {
	WSACleanup ( );
    }

    fprintf ( stdout, "DONE\n" );

    return;
}