ADDSF(XP1_GUARANTEED_DELIVERY,
			"Delivery guaranteed",
			"Delivery NOT guaranteed");

        ADDSF(XP1_GUARANTEED_ORDER,
			"Order guaranteed",
			"Order NOT guaranteed");

        ADDSF(XP1_MESSAGE_ORIENTED,
			"Message boundaries preserved",
			"Message boundaries NOT preserved");

        if (pInfo->dwServiceFlags1 & XP1_PSEUDO_STREAM)
			AddTreeItem(hWndTree, hParent2, 
				"Message oriented with boundaries ignored");

        ADDSF(XP1_GRACEFUL_CLOSE,
			"Can perform graceful close",
			"Abortive close only");

        ADDSF(XP1_EXPEDITED_DATA,
			"Supports expedited data",
			"Doesn't support expedited data");

        ADDSF(XP1_CONNECT_DATA,
			"Supplies connect data",
			"Doesn't supply connect data");

        ADDSF(XP1_DISCONNECT_DATA,
			"Supplies disconnect data",
			"Doesn't supply disconnect data");

        ADDSF(XP1_SUPPORT_BROADCAST,
			"Supports broadcasts",
			"Doesn't support broadcasts");

		// Multipoint/multicast
        if (pInfo->dwServiceFlags1 & XP1_SUPPORT_MULTIPOINT)
		{
			hParent3 = AddTreeItem(hWndTree, 
								   hParent2, 
								   "Supports multicast");
			AddTreeItem(hWndTree,
						hParent3,
						(pInfo->dwServiceFlags1 & 
						XP1_MULTIPOINT_CONTROL_PLANE) ?
						"Control plane rooted" :
						"Control plane non-rooted");

			AddTreeItem(hWndTree,
						hParent3,
						(pInfo->dwServiceFlags1 & 
						XP1_MULTIPOINT_DATA_PLANE) ?
						"Data plane rooted" :
						"Data plane non-rooted");
		}
		else
			AddTreeItem(hWndTree, 
						hParent2, 
						"Doesn't support multicast");

        ADDSF(XP1_QOS_SUPPORTED,
			"Supports quality of service",
			"Doesn't support quality of service");

        if (pInfo->dwServiceFlags1 & XP1_UNI_SEND)
			AddTreeItem(hWndTree, 
					hParent2, 
					"Unidirectional in the send direction");

        if (pInfo->dwServiceFlags1 & XP1_UNI_RECV)
			AddTreeItem(hWndTree, 
					hParent2, 
					"Unidirectional in the recv direction");
 
        if (!(pInfo->dwServiceFlags1 & XP1_UNI_SEND) &&
			!(pInfo->dwServiceFlags1 & XP1_UNI_RECV))
			 AddTreeItem(hWndTree, 
					hParent2, 
					"Bidirectional sending and receiving");

        if (pInfo->dwServiceFlags1 & XP1_IFS_HANDLES)
			AddTreeItem(hWndTree, 
					hParent2, 
					"Socket descriptors are IFS handles");

        ADDSF(XP1_PARTIAL_MESSAGE,
			"Supports MSG_PARTIAL",
			"Doesn't support MSG_PARTIAL");

		// Provider flags
		hParent2 = AddTreeItem(hWndTree, 
							   hParent, 
							   "Provider Flags");

		if (pInfo->dwProviderFlags & 
				PFL_MULTIPLE_PROTO_ENTRIES)
			AddTreeItem(hWndTree, 
						hParent2, 
						"This is one behavior of two or"
						" more for this protocol");

		if (pInfo->dwProviderFlags & 
				PFL_RECOMMENDED_PROTO_ENTRY)
			AddTreeItem(hWndTree, 
						hParent2, 
						"This is the recommended entry"
						" for this protocol.");

		if (pInfo->dwProviderFlags & PFL_HIDDEN)
			AddTreeItem(hWndTree, 
						hParent2, 
						"WS2 SPI ERROR."
						" Hidden catalog entry shown");

		if (pInfo->dwProviderFlags & 
				PFL_MATCHES_PROTOCOL_ZERO)
			AddTreeItem(hWndTree, 
						hParent2, 
						"Use zero as protocol parameter");

		// Provider ID
		AddTreeItem(hWndTree, 
					hParent, 
					"GUID: %s", 
					GUIDtoString((GUID *)&pInfo->ProviderId));

		// Catalog entry
		AddTreeItem(hWndTree, 
					hParent, 
					"Catalog entry: %ld", 
					pInfo->dwCatalogEntryId);

		// Protocol chain
		switch(pInfo->ProtocolChain.ChainLen)
		{
			case 0:
				AddTreeItem(hWndTree, 
							hParent, 
							"Layered protocol");
				break;
			case 1:
				AddTreeItem(hWndTree, 
							hParent, 
							"Base protocol");
				break;
			default:
				if (pInfo->ProtocolChain.ChainLen > 1)
					AddTreeItem(hWndTree, 
								hParent, 
								"Protocol chain");
				else
					AddTreeItem(hWndTree, 
								hParent, 
								"SPI ERROR:"
								" Invalid ChainLen");
		}

		// Version
		AddTreeItem(hWndTree, 
					hParent, 
					"Version: %d", 
					pInfo->iVersion);

		// Address family
		AddTreeItem(hWndTree, 
					hParent, 
					"Address family: %s",
					AFtoSTR(pInfo->iAddressFamily));

		// Min/Max SOCKADDR size
		AddTreeItem(hWndTree, 
					hParent, 
					"Min/Max Address length: %d/%d",
					pInfo->iMinSockAddr,
					pInfo->iMaxSockAddr);

		// Socket type
		switch(pInfo->iSocketType)
		{
			case SOCK_STREAM:
				AddTreeItem(hWndTree, 
							hParent, 
							"SOCK_STREAM");
				break;
			case SOCK_DGRAM:
				AddTreeItem(hWndTree, 
							hParent, 
							"SOCK_DGRAM");
				break;
			case SOCK_RAW:
				AddTreeItem(hWndTree, 
							hParent, 
							"SOCK_RAW");
				break;
			case SOCK_RDM:
				AddTreeItem(hWndTree, 
							hParent, 
							"SOCK_RDM");
				break;
			case SOCK_SEQPACKET:
				AddTreeItem(hWndTree, 
							hParent, 
							"SOCK_SEQPACKET");
				break;
			default:
				AddTreeItem(hWndTree, 
							hParent, 
							"Unknown");
		}

		// Protocol
		AddTreeItem(hWndTree, 
					hParent, 
					"Protocol: %s",
					PROTOtoSTR(pInfo->iProtocol));

		// Protocol max offset
		AddTreeItem(hWndTree, 
					hParent, 
					"Protocol Max Offset: %d", 
					pInfo->iProtocolMaxOffset);

		// Network byte order
		switch(pInfo->iNetworkByteOrder)
		{
			case BIGENDIAN:
				AddTreeItem(hWndTree, 
							hParent, 
							"Big Endian");
				break;
			case LITTLEENDIAN:
				AddTreeItem(hWndTree, 
							hParent, 
							"Little Endian");
				break;
			default:
				AddTreeItem(hWndTree, 
							hParent, 
							"Unknown");
		}

		// Security
		AddTreeItem(hWndTree, 
					hParent, 
					"Security scheme: %d",
					pInfo->iSecurityScheme);

		// Message size
		switch(pInfo->dwMessageSize)
		{
			case 0:
				AddTreeItem(hWndTree, 
							hParent, 
							"Max message size"
							" not applicable");
				break;
			case 1:
				AddTreeItem(hWndTree, 
							hParent, 
							"Max message size based on MTU");
				break;
			case 0xFFFFFFFF:
				AddTreeItem(hWndTree, 
							hParent, 
							"No limit on max message size");
				break;
			default:
				AddTreeItem(hWndTree, 
							hParent, 
							"Unknown max message size: %ld", 
							pInfo->dwMessageSize);
		}
		// Move pointer to next protocol
		pInfo++;
	}

	free(pBuf);
	return;
}

////////////////////////////////////////////////////////////

//
// AddTreeItem()
// Format a string and add it to a TreeView
//
HTREEITEM AddTreeItem(HWND hWndTree, 
					  HTREEITEM hParent, 
					  LPSTR lpszFormat, 
					  ...)
{
	va_list Marker;
	char szBuf[256];
	TV_ITEM tvi;
	TV_INSERTSTRUCT tvis;

	// Format the string
	va_start(Marker, lpszFormat);
	vsprintf(szBuf, lpszFormat, Marker);
	va_end(Marker);

	// Fill in the TV_ITEM structure
	tvi.mask	      = TVIF_TEXT;
	tvi.pszText	      = szBuf; 
	tvi.cchTextMax    = lstrlen(szBuf); 

	// Fill in the TV_INSERTSTRUCT
	tvis.item         = tvi;
	tvis.hInsertAfter = TVI_LAST;
	tvis.hParent       = hParent; 
	return (TreeView_InsertItem(hWndTree, &tvis));
}


// 
// About()
// About dialog box procedure
//
BOOL APIENTRY About(
   HWND hDlg,
	UINT message,
	UINT wParam,
	LONG lParam)
{
	switch (message)
	{
	   case WM_INITDIALOG:
		  return (TRUE);

	   case WM_COMMAND:              
		  if (LOWORD(wParam) == IDOK)
		 {
			  EndDialog(hDlg, TRUE);
			  return (TRUE);
		  }
		  break;
	}
	return (FALSE);   

}


void ShowWinsockError(int iError)
{
	char szMessage[256];

	if (LoadString(ghInst, 
				   iError, 
				   szMessage, 
				   sizeof(szMessage)))
	{
		MessageBox(NULL, szMessage,
						 gszAppName,
						 MB_OK|MB_ICONERROR);

	}
	else
	{
		MessageBox(NULL, "Unknown Winsock Error",
						 gszAppName,
						 MB_OK|MB_ICONERROR);

	}
	return;
}