windows-xp/Source/XPSP1/NT/net/atm/samples/atmsmpl/app/atmsmapp.c

/*++

Copyright (c) 1990-1998  Microsoft Corporation, All Rights Reserved.

Module Name:

	 atmsmapp.c

Abstract:

	 This is the user mode app that controls the sample ATM client.
	 It can be used for 
		  1. Starting / Stopping the driver.
		  2. Sending to one (point - point) or more (PMP) destinations.
		  3. Receive packets that come on any VC to our SAP.

Author:

	 Anil Francis Thomas (10/98)

Environment:

	 User mode

Revision History:

--*/

#include <windows.h>
#include <winioctl.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "atmsample.h"
#include "utils.h"
#include "atmsmapp.h"

PROGRAM_OPTIONS g_ProgramOptions;


int __cdecl main(int argc, char *argv[])
{

	DWORD   dwRetVal = NO_ERROR;

	memset(&g_ProgramOptions, 0, sizeof(PROGRAM_OPTIONS));

	g_ProgramOptions.dwPktSize      = DEFAULT_PKT_SIZE;
	g_ProgramOptions.dwPktInterval  = DEFAULT_PKT_INTERVAL;
	g_ProgramOptions.dwNumPkts      = DEFAULT_NUM_OF_PKTS;


	// parse the command line parameters
	if((argc < 2) || (FALSE == ParseCommandLine(argc, argv)))
	{
		Usage();
		return 1;
	}

	// Is any driver option specified - start, stop etc
	if(g_ProgramOptions.usDrvAction)
	{

		switch(g_ProgramOptions.usDrvAction)
		{

			case START_DRV:
				dwRetVal = AtmSmDriverStart();
				if(NO_ERROR != dwRetVal)
				{
					printf("Failed to start driver. Error %u\n",
						dwRetVal);
				}
				else
					printf("Successfully started the driver.\n");
				break;

			case STOP_DRV:
				dwRetVal = AtmSmDriverStop();
				if(NO_ERROR != dwRetVal)
				{
					printf("Failed to stop driver. Error %u\n",
						dwRetVal);
					return 1;
				}
				else
				{
					printf("Successfully stopped the driver.\n");
					return 0;	// we are done
				}
				break;
		}
	}

	if(NO_ERROR != dwRetVal)
		return dwRetVal;


	do
	{	  // break off loop

		dwRetVal = AtmSmOpenDriver(&g_ProgramOptions.hDriver);

		if(NO_ERROR != dwRetVal)
			break;


		// enumerate the interfaces
		if(g_ProgramOptions.fEnumInterfaces)
			EnumerateInterfaces();


		if(g_ProgramOptions.fLocalIntf)
			printf("\nLocal Interface Address - %s\n", 
				FormatATMAddr(g_ProgramOptions.ucLocalIntf));

		if(g_ProgramOptions.dwNumDsts)
		{
			DWORD dw;

			printf("\nDestinations specified : %u\n", 
				g_ProgramOptions.dwNumDsts);
			for(dw = 0; dw < g_ProgramOptions.dwNumDsts; dw++)
				printf("    %u - %s\n", dw+1, 
					FormatATMAddr(g_ProgramOptions.ucDstAddrs[dw]));

		}

		if(g_ProgramOptions.usSendRecvAction && !g_ProgramOptions.fLocalIntf)
		{
			// for sends and recv we need a local intf
			printf("Error! Specify a local interface to send and recv\n");
			dwRetVal = 1;
			break;
		}

		if((SEND_PKTS == g_ProgramOptions.usSendRecvAction)
			&& !g_ProgramOptions.dwNumDsts)
		{
			// for sends and recv we need a local intf
			printf("Error! Specify destination address(s) to send packets\n");
			dwRetVal = 1;
			break;
		}

		// Set the Cntrl - C Handler
		SetConsoleCtrlHandler(CtrlCHandler, TRUE);

		if(SEND_PKTS == g_ProgramOptions.usSendRecvAction)
			dwRetVal = DoSendPacketsToDestinations();
		else
			if(RECEIVE_PKTS == g_ProgramOptions.usSendRecvAction)
			dwRetVal = DoRecvPacketsOnAdapter();


	}while(FALSE);

	if(NULL != g_ProgramOptions.hDriver)
		AtmSmCloseDriver(g_ProgramOptions.hDriver);

	return(int)dwRetVal;
}


void EnumerateInterfaces()
/*++
Routine Description:
 
	 Enumerate all the adapters that the driver is bound to.  You get the 
	 NSAP addresses for these interfaces.

Arguments:
	 NONE

Return Value:
	 NONE
--*/
{
	DWORD           dw, dwRetVal, dwSize;    
	PADAPTER_INFO   pAI;

	dwSize = sizeof(ADAPTER_INFO) + (sizeof(UCHAR) * 5 * NSAP_ADDRESS_LEN);

	pAI = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);

	if(!pAI)
	{
		printf("Error not enough memory\n");
		return;
	}

	do
	{ // break off loop

		dwRetVal = AtmSmEnumerateAdapters(
						  g_ProgramOptions.hDriver,
						  pAI,
						  &dwSize);

		if(NO_ERROR != dwRetVal)
		{
			printf("Failed to enumerate adapters. Error - %u\n",
				dwRetVal);
			break;
		}

		printf("\nNumber of adapters - %u\n", pAI->ulNumAdapters);
		for(dw = 0; dw < pAI->ulNumAdapters; dw++)
		{
			printf("    Adapter [%u] - %s\n", dw+1,
				FormatATMAddr(pAI->ucLocalATMAddr[dw]));
		}

	}while(FALSE);


	HeapFree(GetProcessHeap(), 0, pAI);

	return;
}


DWORD DoSendPacketsToDestinations()
/*++
Routine Description:
	 This routine does the sending of packets to one or more destinations.
	 First a connect call is made to get a handle.  That handle is used for
	 further sends.

Arguments:
	 NONE

Return Value:
	 Status
--*/
{
	DWORD           dw, dwSize;
	PCONNECT_INFO   pCI;
	OVERLAPPED      Overlapped;
	BOOL            bResult;
	DWORD           dwReturnBytes;
	PUCHAR          pBuffer     = NULL;
	DWORD           dwStatus    = NO_ERROR;

	memset(&Overlapped, 0, sizeof(OVERLAPPED));

	dwSize  = sizeof(CONNECT_INFO) + (sizeof(UCHAR) * 
					 g_ProgramOptions.dwNumDsts * NSAP_ADDRESS_LEN);

	pCI     = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);

	if(!pCI)
	{
		printf("Error not enough memory\n");
		return ERROR_NOT_ENOUGH_MEMORY;
	}

	pCI->bPMP           = g_ProgramOptions.fPMP;
	pCI->ulNumDsts      = g_ProgramOptions.dwNumDsts;
	memcpy(pCI->ucLocalATMAddr, g_ProgramOptions.ucLocalIntf,
		(sizeof(UCHAR) * NSAP_ADDR_LEN));
	for(dw = 0; dw < g_ProgramOptions.dwNumDsts; dw++)
		memcpy(pCI->ucDstATMAddrs[dw], g_ProgramOptions.ucDstAddrs[dw],
			(sizeof(UCHAR) * NSAP_ADDR_LEN));


	do
	{	  // break off loop

		Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

		if(NULL == Overlapped.hEvent)
		{
			dwStatus = GetLastError();
			printf("Failed to create event. Error %u\n", dwStatus);
			break;
		}

		dwReturnBytes = 0;

		// Initiate a connection to destinations
		bResult = DeviceIoControl(
						 g_ProgramOptions.hDriver,
						 (ULONG)IOCTL_CONNECT_TO_DSTS,
						 pCI,
						 dwSize,
						 &g_ProgramOptions.hSend,
						 sizeof(HANDLE),
						 &dwReturnBytes,
						 &Overlapped);

		if(!bResult)
		{

			dwStatus = GetLastError();

			if(ERROR_IO_PENDING != dwStatus)
			{
				printf("Failed to connect to destinations. Error %u\n", 
					dwStatus);
				break;
			}

			// the operation is pending
			bResult = GetOverlappedResult(
							 g_ProgramOptions.hDriver,
							 &Overlapped,
							 &dwReturnBytes,
							 TRUE
							 );
			if(!bResult)
			{
				dwStatus = GetLastError();
				printf("Wait for connection to complete failed. Error - %u\n", 
					dwStatus);
				break;
			}

		}

		// successfully connected
		printf("Successfully connected to destination(s) - Handle - 0x%p\n",
			g_ProgramOptions.hSend);

		// allocate a buffer to send 
		dwSize = g_ProgramOptions.dwPktSize;

		pBuffer   = HeapAlloc(GetProcessHeap(), 0, dwSize);

		if(!pBuffer)
		{
			printf("Error not enough memory\n");
			dwStatus = ERROR_NOT_ENOUGH_MEMORY;
			break;
		}

		FillPattern(pBuffer, dwSize);

		// do the number of sends that were asked to do
		for(dw = 0; dw < g_ProgramOptions.dwNumPkts; dw++)
		{

			ResetEvent(Overlapped.hEvent);
			dwReturnBytes = 0;

			bResult = DeviceIoControl(
							 g_ProgramOptions.hDriver,
							 (ULONG)IOCTL_SEND_TO_DSTS,
							 &g_ProgramOptions.hSend,
							 sizeof(HANDLE),
							 pBuffer,	//Note! the buffer given here
							 dwSize,	//Note! the size given here
							 &dwReturnBytes,
							 &Overlapped);

			if(!bResult)
			{

				dwStatus = GetLastError();

				if(ERROR_IO_PENDING != dwStatus)
				{
					printf("Failed to do sends to destinations. Error %u\n", 
						dwStatus);
					break;
				}

				// the operation is pending
				bResult = GetOverlappedResult(
								 g_ProgramOptions.hDriver,
								 &Overlapped,
								 &dwReturnBytes,
								 TRUE
								 );
				if(!bResult)
				{
					dwStatus = GetLastError();
					printf("Wait for send to complete failed. Error - %u\n", 
						dwStatus);
					break;
				}

				printf("Successfully send packet number %u\n", dw+1);

				Sleep(g_ProgramOptions.dwPktInterval);
			}

		}

	} while(FALSE);


	if(g_ProgramOptions.hSend)
	{
		CloseConnectHandle(&Overlapped);
		g_ProgramOptions.hSend = NULL;
	}

	if(pCI)
		HeapFree(GetProcessHeap(), 0, pCI);

	if(pBuffer)
		HeapFree(GetProcessHeap(), 0, pBuffer);


	if(Overlapped.hEvent)
		CloseHandle(Overlapped.hEvent);

	return dwStatus;
}


DWORD DoRecvPacketsOnAdapter()
/*++
Routine Description:
	 This routine is used to receive packets that come to our SAP on any VCs.
	 Note:  Only one recv can pend at a time.

Arguments:
	 NONE

Return Value:
	 Status
--*/
{
	DWORD                   dw, dwSize;
	POPEN_FOR_RECV_INFO     pORI;
	OVERLAPPED              Overlapped;
	BOOL                    bResult;
	DWORD                   dwReturnBytes;
	PUCHAR                  pBuffer     = NULL;
	DWORD                   dwStatus    = NO_ERROR;

	memset(&Overlapped, 0, sizeof(OVERLAPPED));

	dwSize  = sizeof(OPEN_FOR_RECV_INFO);

	pORI    = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize);

	if(!pORI)
	{
		printf("Error not enough memory\n");
		return ERROR_NOT_ENOUGH_MEMORY;
	}

	memcpy(pORI->ucLocalATMAddr, g_ProgramOptions.ucLocalIntf,
		(sizeof(UCHAR) * NSAP_ADDR_LEN));

	do
	{	  // break off loop

		Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

		if(NULL == Overlapped.hEvent)
		{
			dwStatus = GetLastError();
			printf("Failed to create event. Error %u\n", dwStatus);
			break;
		}

		dwReturnBytes = 0;

		// Open the adapter for recvs
		bResult = DeviceIoControl(
						 g_ProgramOptions.hDriver,
						 (ULONG)IOCTL_OPEN_FOR_RECV,
						 pORI,
						 dwSize,
						 &g_ProgramOptions.hReceive,
						 sizeof(HANDLE),
						 &dwReturnBytes,
						 &Overlapped);

		if(!bResult)
		{

			dwStatus = GetLastError();

			if(ERROR_IO_PENDING != dwStatus)
			{
				printf("Failed to open adapter for recvs. Error %u\n", 
					dwStatus);
				break;
			}

			// the operation is pending
			bResult = GetOverlappedResult(
							 g_ProgramOptions.hDriver,
							 &Overlapped,
							 &dwReturnBytes,
							 TRUE
							 );
			if(!bResult)
			{
				dwStatus = GetLastError();
				printf("Wait for open to complete failed. Error - %u\n", 
					dwStatus);
				break;
			}

		}

		// successfully connected
		printf("Successfully opened adapter for recvs - Handle - 0x%p\n",
			g_ProgramOptions.hReceive);

		// allocate a buffer to receive data into
		dwSize = MAX_PKT_SIZE;

		pBuffer = HeapAlloc(GetProcessHeap(), 0, dwSize);

		if(!pBuffer)
		{
			printf("Error not enough memory\n");
			dwStatus = ERROR_NOT_ENOUGH_MEMORY;
			break;
		}


		// start receiving packets
		dw = 0;
		while(TRUE)
		{

			dwReturnBytes = 0;
			ResetEvent(Overlapped.hEvent);
			memset(pBuffer, 0, dwSize);

			bResult = DeviceIoControl(
							 g_ProgramOptions.hDriver,
							 (ULONG)IOCTL_RECV_DATA,
							 &g_ProgramOptions.hReceive,
							 sizeof(HANDLE),
							 pBuffer,
							 dwSize,
							 &dwReturnBytes,
							 &Overlapped);

			if(!bResult)
			{

				dwStatus = GetLastError();

				if(ERROR_IO_PENDING != dwStatus)
				{
					printf("Failed to receive data. Error %u\n", dwStatus);
					break;
				}

				// the operation is pending
				bResult = GetOverlappedResult(
								 g_ProgramOptions.hDriver,
								 &Overlapped,
								 &dwReturnBytes,
								 TRUE
								 );
				if(!bResult)
				{
					dwStatus = GetLastError();
					if(dwStatus == ERROR_OPERATION_ABORTED)
					{
						printf("Receive operation is aborted.\n");
					}
					else
					{
						printf("Wait for recv to complete failed. Error - %u\n", 
							dwStatus);
					}
					break;
				}

				printf("Successfully received a packet (%u). Size  %u\n", 
					dw+1, dwReturnBytes);

				VerifyPattern(pBuffer, dwReturnBytes);
			}

			dw++;
		}

	} while(FALSE);


	if(g_ProgramOptions.hReceive)
	{
		CloseReceiveHandle(&Overlapped);
	}

	if(pORI)
		HeapFree(GetProcessHeap(), 0, pORI);

	if(pBuffer)
		HeapFree(GetProcessHeap(), 0, pBuffer);

	if(Overlapped.hEvent)
		CloseHandle(Overlapped.hEvent);

	return dwStatus;
}


BOOL WINAPI CtrlCHandler(
	DWORD dwCtrlType
	)
/*++
Routine Description:
	 This routine is called when Cntrl-C is used to exit the app from recv loop
	 or during sends.  It just cleans up the handles.

Arguments:

Return Value:
	 
--*/
{
	OVERLAPPED Overlapped;

	printf("Control - C Handler\n");

	memset(&Overlapped, 0, sizeof(OVERLAPPED));

	Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

	if(NULL == Overlapped.hEvent)
	{
		printf("Failed to create event. Error %u\n", GetLastError());
		return FALSE;
	}

	// If Recv was enabled then close that handle
	if(g_ProgramOptions.hReceive)
	{
		CloseReceiveHandle(&Overlapped);
	}

	printf("###-1\n");

	// If Send was enabled then close that handle
	if(g_ProgramOptions.hSend)
	{
		CloseConnectHandle(&Overlapped);
		g_ProgramOptions.hSend = NULL;
	}

	CloseHandle(Overlapped.hEvent);

	printf("###-2\n");

	return FALSE;	 // causes the app to exit
}


void Usage()
{
	printf( "\n This program is used for sending or receiving data over ATM"
		"\n using the ATMSMDRV.SYS.\n\n");

	printf( " Mandatory Arguments:\n\n"

		"    For SEND and RECV:\n"
		"         /INTF:3908...0C100  -   Local ATM adapter to use\n\n");

	printf( " Optional Arguments:\n\n"

		"         /START              -   Start the driver.\n"
		"         /STOP               -   Stop the driver.\n"
		"         /ENUM               -   Enumerate interfaces.\n\n"

		"    For SEND:\n"
		"         /SEND:39..C100,49.. -   ATM addresses of destinations\n"
		"         /PMP                -   Make a PMP call.\n"
		"         /INTVL:100          -   Time interval between sends"
		" (millisec).\n"
		"         /SIZE:512           -   Packet Size (bytes).\n"
		"         /NUMPKTS:10         -   No. of packets to send.\n\n"

		"    For RECV:\n"
		"         /RECV               -   Receive pkts on the adapter\n\n");

	printf( " Example:\n\n"

		"    AtmSmApp  /INTF:4700918100000000613E5BFE010000C100741F00 "
		"/RECV\n"
		"    AtmSmApp  /INTF:4700...41F00 /SEND:4700...41F00,4700...123F00"
		" \n\n");

	printf( " Notes:\n\n"

		"     A PMP call is made, when multiple destinations are specified."
		"\n"
		"     Full NSAP address should be specified. Selector Byte defaults"
		" to 05.\n");
}


//
//  Options are of the form
//
//      /START
//      /NUMPKTS:12

#define START_DRV_OPT           101
#define STOP_DRV_OPT            102
#define ENUM_INTFS_OPT          103
#define LOCAL_INTF_OPT          104
#define SEND_ADDRS_OPT          105
#define RECV_PKTS_OPT           106
#define PKT_INTERVAL_OPT        107
#define PKT_SIZE_OPT            108
#define NUM_PKTS_OPT            109
#define PMP_CONNECTION          110
#define UNKNOWN_OPTION          111

struct _CmdOptions
{
	LPTSTR  lptOption;
	UINT    uOpt;
} CmdOptions[]    = {
	{_T("/START")        , START_DRV_OPT},
	{_T("/STOP")         , STOP_DRV_OPT},
	{_T("/ENUM")         , ENUM_INTFS_OPT},
	{_T("/INTF:")        , LOCAL_INTF_OPT},
	{_T("/SEND:")        , SEND_ADDRS_OPT},
	{_T("/RECV")         , RECV_PKTS_OPT},
	{_T("/INTVL:")       , PKT_INTERVAL_OPT},
	{_T("/SIZE:")        , PKT_SIZE_OPT},
	{_T("/NUMPKTS:")     , NUM_PKTS_OPT},
	{_T("/PMP")          , PMP_CONNECTION},
};

INT iCmdOptionsCounts = sizeof(CmdOptions)/sizeof(struct _CmdOptions);

BOOL ParseCommandLine(
	int argc,
	char * argv[]
	)
/*++
Routine Description:
	 Parse the command line parameters.

Arguments:
	 argc        - number of arguments
	 argv        - arguments

Return Value:
	 TRUE        - if successful
	 FALSE       - failure
--*/
{
	BOOL    bRetVal = TRUE;
	int     iIndx;
	UINT    uOpt;
	char    *pVal;

	for(iIndx = 1; iIndx < argc; iIndx++)
	{

		uOpt = FindOption(argv[iIndx], &pVal);

		switch(uOpt)
		{

			case START_DRV_OPT:
				g_ProgramOptions.usDrvAction = START_DRV;
				break;

			case STOP_DRV_OPT:
				g_ProgramOptions.usDrvAction = STOP_DRV;
				break;

			case ENUM_INTFS_OPT:
				g_ProgramOptions.fEnumInterfaces = TRUE;
				break;

			case LOCAL_INTF_OPT:
				if(!GetATMAddrs(pVal, g_ProgramOptions.ucLocalIntf))
				{
					printf("Local Interface address specified - Bad characters!\n");
					return FALSE;
				}
				g_ProgramOptions.fLocalIntf  = TRUE;
				break;

			case SEND_ADDRS_OPT:
				g_ProgramOptions.usSendRecvAction = SEND_PKTS;

				if(!GetSpecifiedDstAddrs(pVal))
				{
					printf("Destination address(es) specified - Bad characters!\n");
					return FALSE;
				}
				// more than 1 destinations, it is a PMP VC
				if(1 < g_ProgramOptions.dwNumDsts)
					g_ProgramOptions.fPMP = TRUE;

				break;

			case RECV_PKTS_OPT:
				g_ProgramOptions.usSendRecvAction = RECEIVE_PKTS;
				break;

			case PKT_INTERVAL_OPT:
				g_ProgramOptions.dwPktInterval = atol(pVal);
				break;

			case PKT_SIZE_OPT:
				g_ProgramOptions.dwPktSize = atol(pVal);
				if(g_ProgramOptions.dwPktSize > MAX_PKT_SIZE)
					g_ProgramOptions.dwPktSize = MAX_PKT_SIZE;
				break;

			case NUM_PKTS_OPT:
				g_ProgramOptions.dwNumPkts = atol(pVal);
				break;

			case PMP_CONNECTION:
				g_ProgramOptions.fPMP = TRUE;
				break;

			default:
				printf("Unknown switch - %s\n", argv[iIndx]);
				return FALSE;
		}
	}

	return bRetVal;
}

UINT FindOption(
	char *lptOpt,
	char **ppVal
	)
/*++
Routine Description:
	 Find the option number based on the command line switch.

Arguments:
	 lptOpt          - command line option
	 ppVal           - Value associated with the option

Return Value:
	 OPTION_NUMBER   - if success

--*/
{
	int     i;
	UINT    iLen;

	for(i = 0; i < iCmdOptionsCounts; i++)
	{
		if(strlen(lptOpt) >= (iLen = strlen(CmdOptions[i].lptOption)))
			if(0 == _strnicmp(lptOpt, CmdOptions[i].lptOption, iLen))
			{
				*ppVal = lptOpt + iLen;
				return CmdOptions[i].uOpt;
			}
	}

	return UNKNOWN_OPTION;
}


BOOL GetSpecifiedDstAddrs(
	char    *pStr
	)
/*++
Routine Description:
	 Get all the ATM destination addresses specified based from the
	 command line parameter (after /SEND:)

Arguments:
	 pStr        - pointer to what follows after /SEND:

Return Value:
	 TRUE        - if successful
	 FALSE       - failure
--*/
{
	char szTmp[512];
	char *pToken;
	int  i;

	strcpy(szTmp, pStr);

	pToken = strtok(szTmp, DELIMITOR_CHARS);

	i = 0;
	while(pToken)
	{

		if(!GetATMAddrs(pToken, g_ProgramOptions.ucDstAddrs[i]))
			return FALSE;

		pToken = strtok(NULL, DELIMITOR_CHARS);
		i++;
	}

	g_ProgramOptions.dwNumDsts = i;

	return TRUE;
}


BOOL GetATMAddrs(
	char    *pStr,
	UCHAR   ucAddr[]
	)
/*++
Routine Description:
	 Parse the string specified as an ATM (NSAP)address into a 20byte
	 array to hold the address

Arguments:
	 pStr        - pointer to the string holding the address
	 ucAddr      - 20Byte Array holding the ATM address

Return Value:
	 TRUE        - if successful
	 FALSE       - failure
--*/
{
	UCHAR   ucVal;
	int     i;

	for(i = 0; (*pStr != '\0') && (i < NSAP_ADDR_LEN); i++)
	{

		CharToHex(*pStr, ucVal);
		if((UCHAR)-1 == ucVal)
			return FALSE;

		ucAddr[i] = (UCHAR)(ucVal * 16);
		pStr++;

		CharToHex(*pStr, ucVal);
		if((UCHAR)-1 == ucVal)
			return FALSE;

		ucAddr[i] = (UCHAR)(ucAddr[i] + ucVal);
		pStr++;
	}

	return TRUE;
}


char * FormatATMAddr(
	UCHAR   ucAddr[]
	)
/*++
Routine Description:
	 Format a 20 byte ATM [NSAP] address into a character array for printing.

Arguments:
	 ucAddr      - 20Byte Array holding the ATM address

Return Value:
	 String      - pointer to the string holding the address
--*/
{
	static char szStr[NSAP_ADDR_LEN * 2 + 1];
	int  i,j;
	char HexChars[] = "0123456789ABCDEF";

	j = 0;
	for(i = 0; i < NSAP_ADDR_LEN; i++)
	{
		szStr[j++] = HexChars[(ucAddr[i] >> 4)];
		szStr[j++] = HexChars[(ucAddr[i] &0xF)];
	}

	szStr[j] = '\0';

	return szStr;
}