You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
681 lines
18 KiB
681 lines
18 KiB
/*++
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
display.c
|
|
|
|
Abstract:
|
|
|
|
format the network info for display
|
|
|
|
--*/
|
|
|
|
#include <precomp.h>
|
|
|
|
#define STATIC_BUFFER_LENGTH 100
|
|
|
|
LCID GetSupportedUserLocale(void);
|
|
|
|
DWORD
|
|
NodeTypeMap[][2] = {
|
|
NodeTypeUnknown, MSG_NODE_TYPE_UNKNOWN,
|
|
NodeTypeBroadcast, MSG_NODE_TYPE_BROADCAST,
|
|
NodeTypeMixed, MSG_NODE_TYPE_MIXED,
|
|
NodeTypeHybrid, MSG_NODE_TYPE_HYBRID,
|
|
NodeTypePeerPeer, MSG_NODE_TYPE_PEER_PEER
|
|
};
|
|
|
|
DWORD
|
|
IfTypeMap[][2] = {
|
|
IfTypeUnknown, MSG_IF_TYPE_UNKNOWN,
|
|
IfTypeOther, MSG_IF_TYPE_OTHER,
|
|
IfTypeEthernet, MSG_IF_TYPE_ETHERNET,
|
|
IfTypeTokenring, MSG_IF_TYPE_TOKENRING,
|
|
IfTypeFddi, MSG_IF_TYPE_FDDI,
|
|
IfTypeLoopback, MSG_IF_TYPE_LOOPBACK,
|
|
IfTypePPP, MSG_IF_TYPE_PPP,
|
|
IfTypeSlip, MSG_IF_TYPE_SLIP,
|
|
IfTypeTunnel, MSG_IF_TYPE_TUNNEL,
|
|
IfType1394, MSG_IF_TYPE_OTHER
|
|
};
|
|
|
|
DWORD
|
|
InternalErrorMap[][2] = {
|
|
GlobalHostNameFailure, MSG_FAILURE_HOST_NAME,
|
|
GlobalDomainNameFailure, MSG_FAILURE_DOM_NAME,
|
|
GlobalEnableRouterFailure, MSG_FAILURE_ENABLE_ROUTER,
|
|
GlobalEnableDnsFailure, MSG_FAILURE_ENABLE_DNS,
|
|
GlobalIfTableFailure, MSG_FAILURE_IF_TABLE,
|
|
GlobalIfInfoFailure, MSG_FAILURE_IF_INFO,
|
|
GlobalAddrTableFailure, MSG_FAILURE_ADDR_TABLE,
|
|
GlobalRouteTableFailure, MSG_FAILURE_ROUTE_TABLE,
|
|
InterfaceUnknownType, MSG_FAILURE_UNKNOWN_IF,
|
|
InterfaceUnknownFriendlyName, MSG_FAILURE_UNKNOWN_NAME,
|
|
InterfaceUnknownMediaStatus, MSG_FAILURE_UNKNOWN_MEDIA_STATUS,
|
|
InterfaceUnknownTcpipDevice, MSG_FAILURE_UNKNOWN_TCPIP_DEVICE,
|
|
InterfaceOpenTcpipKeyReadFailure, MSG_FAILURE_OPEN_KEY,
|
|
InterfaceDhcpValuesFailure, MSG_FAILURE_DHCP_VALUES,
|
|
InterfaceDnsValuesFailure, MSG_FAILURE_DNS_VALUES,
|
|
InterfaceWinsValuesFailure, MSG_FAILURE_WINS_VALUES,
|
|
InterfaceAddressValuesFailure, MSG_FAILURE_ADDRESS_VALUES,
|
|
InterfaceRouteValuesFailure, MSG_FAILURE_ROUTE_VALUES,
|
|
NoSpecificError, MSG_FAILURE_NO_SPECIFIC,
|
|
};
|
|
|
|
#define Dimension(X) (sizeof(X)/sizeof(X[0]))
|
|
|
|
DWORD
|
|
MapNodeType(
|
|
IN DWORD NodeType
|
|
)
|
|
{
|
|
DWORD i;
|
|
for( i = 0; i < Dimension(NodeTypeMap); i ++ )
|
|
if( NodeTypeMap[i][0] == NodeType ) return NodeTypeMap[i][1];
|
|
|
|
return MSG_NODE_TYPE_UNKNOWN;
|
|
}
|
|
|
|
static DWORD
|
|
MapIfType(
|
|
IN DWORD IfType
|
|
)
|
|
{
|
|
DWORD i;
|
|
for( i = 0; i < Dimension(IfTypeMap); i ++ )
|
|
if( IfTypeMap[i][0] == IfType ) return IfTypeMap[i][1];
|
|
|
|
return MSG_IF_TYPE_UNKNOWN;
|
|
}
|
|
|
|
DWORD
|
|
MapInternalError(
|
|
IN DWORD InternalError
|
|
)
|
|
{
|
|
DWORD i;
|
|
for( i = 0; i < Dimension(InternalErrorMap); i ++ )
|
|
if( InternalErrorMap[i][0] == InternalError ) {
|
|
return InternalErrorMap[i][1];
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
DWORD
|
|
DumpMessage(
|
|
IN LPWSTR Buffer,
|
|
IN ULONG BufSize,
|
|
IN ULONG MsgId,
|
|
...
|
|
)
|
|
{
|
|
va_list ArgPtr;
|
|
ULONG Count;
|
|
|
|
va_start(ArgPtr, MsgId);
|
|
Count = wcslen(Buffer);
|
|
Buffer += Count; BufSize -= Count;
|
|
|
|
Count = FormatMessageW(
|
|
FORMAT_MESSAGE_FROM_HMODULE, NULL, // use default module
|
|
MsgId, 0 /* default language */, Buffer, BufSize, &ArgPtr );
|
|
|
|
if( Count == 0 ) return GetLastError();
|
|
return NO_ERROR;
|
|
}
|
|
|
|
DWORD
|
|
DumpMessageError(
|
|
IN LPWSTR Buffer,
|
|
IN ULONG BufSize,
|
|
IN ULONG MsgId,
|
|
IN ULONG_PTR Error,
|
|
IN PVOID Arg OPTIONAL
|
|
)
|
|
{
|
|
va_list ArgPtr;
|
|
ULONG Count;
|
|
WCHAR ErrorString[200];
|
|
|
|
Count = FormatMessageW(
|
|
FORMAT_MESSAGE_FROM_SYSTEM, NULL, // use default Module
|
|
(ULONG)Error, 0 /* default language */, ErrorString, 200,
|
|
NULL );
|
|
if( 0 == Count ) swprintf((LPWSTR)ErrorString, (LPWSTR)L"0x%lx.", Error);
|
|
|
|
Error = (ULONG_PTR)ErrorString;
|
|
|
|
return DumpMessage( Buffer, BufSize, MsgId, Error, Arg );
|
|
}
|
|
|
|
DWORD
|
|
DumpErrorMessage(
|
|
IN LPWSTR Buffer,
|
|
IN ULONG BufSize,
|
|
IN ULONG InternalError,
|
|
IN ULONG Win32Error
|
|
)
|
|
{
|
|
ULONG Count;
|
|
WCHAR ErrorString[200];
|
|
|
|
Count = FormatMessageW(
|
|
FORMAT_MESSAGE_FROM_SYSTEM, NULL, // use default Module
|
|
Win32Error, 0 /* default language */, ErrorString, 200,
|
|
NULL );
|
|
if( 0 == Count ) swprintf((LPWSTR)ErrorString, (LPWSTR)L"0x%lx.", Win32Error);
|
|
|
|
return DumpMessage(
|
|
Buffer, BufSize, MapInternalError(InternalError),
|
|
(LPWSTR)ErrorString );
|
|
}
|
|
|
|
LPWSTR
|
|
MapIp(
|
|
IN DWORD IpAddress, // network order
|
|
IN LPWSTR Buffer
|
|
)
|
|
{
|
|
LPSTR Ip = inet_ntoa( *(struct in_addr*)&IpAddress);
|
|
|
|
if( NULL == Ip ) wcscpy(Buffer, (LPWSTR)L"0.0.0.0" );
|
|
else {
|
|
MultiByteToWideChar(
|
|
CP_ACP, 0, Ip, -1, Buffer, STATIC_BUFFER_LENGTH );
|
|
}
|
|
|
|
return Buffer;
|
|
}
|
|
|
|
LPWSTR
|
|
MapIpv6(
|
|
IN LPSOCKADDR_IN6 SockAddr,
|
|
IN LPWSTR Buffer
|
|
)
|
|
{
|
|
DWORD BufferLength = STATIC_BUFFER_LENGTH;
|
|
DWORD Error;
|
|
static DWORD Initialized = FALSE;
|
|
|
|
if (!Initialized) {
|
|
WSADATA WsaData;
|
|
WSAStartup(MAKEWORD(2,0), &WsaData);
|
|
Initialized = TRUE;
|
|
}
|
|
|
|
Error = WSAAddressToStringW((LPSOCKADDR)SockAddr,
|
|
sizeof(SOCKADDR_IN6),
|
|
NULL,
|
|
Buffer,
|
|
&BufferLength);
|
|
|
|
if (Error != NO_ERROR) {
|
|
Error = WSAGetLastError();
|
|
wcscpy(Buffer, L"?");
|
|
}
|
|
|
|
return Buffer;
|
|
}
|
|
|
|
DWORD
|
|
GetCommandArgConstants(
|
|
IN OUT PCMD_ARGS Args
|
|
)
|
|
{
|
|
DWORD Error, i;
|
|
struct _local_struct {
|
|
LPWSTR *Str;
|
|
DWORD MsgId;
|
|
} Map[] = {
|
|
&Args->All, MSG_CMD_ALL,
|
|
&Args->Renew, MSG_CMD_RENEW,
|
|
&Args->Release, MSG_CMD_RELEASE,
|
|
&Args->FlushDns, MSG_CMD_FLUSHDNS,
|
|
&Args->DisplayDns, MSG_CMD_DISPLAYDNS,
|
|
&Args->Register, MSG_CMD_REGISTER,
|
|
&Args->ShowClassId, MSG_CMD_SHOWCLASSID,
|
|
&Args->SetClassId, MSG_CMD_SETCLASSID,
|
|
&Args->Debug, MSG_CMD_DEBUG,
|
|
&Args->Usage, MSG_CMD_USAGE,
|
|
&Args->UsageErr, MSG_CMD_USAGE_ERR,
|
|
NULL, 0
|
|
};
|
|
|
|
i = 0;
|
|
while( Map[i].Str ) {
|
|
Error = FormatMessageW(
|
|
FORMAT_MESSAGE_FROM_HMODULE |
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
NULL, // use default module
|
|
Map[i].MsgId, 0 /* default language */,
|
|
(LPVOID)Map[i].Str, 0, NULL );
|
|
if( 0 == Error ) return GetLastError();
|
|
i ++;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
DWORD
|
|
FormatTime(
|
|
IN FILETIME *Time,
|
|
IN LPWSTR TimeStr,
|
|
IN ULONG TimeStrSize
|
|
)
|
|
{
|
|
DWORD Count;
|
|
FILETIME FileTime;
|
|
SYSTEMTIME SysTime;
|
|
|
|
FileTimeToLocalFileTime( Time, &FileTime );
|
|
FileTimeToSystemTime( &FileTime, &SysTime );
|
|
|
|
Count = GetDateFormat(
|
|
GetSupportedUserLocale(), DATE_LONGDATE, &SysTime, NULL,
|
|
TimeStr, TimeStrSize );
|
|
|
|
if( Count == 0 ) return GetLastError();
|
|
if( Count == TimeStrSize ) return ERROR_INSUFFICIENT_BUFFER;
|
|
|
|
|
|
TimeStr+= Count-1;
|
|
TimeStrSize -= Count;
|
|
*TimeStr++ = L' ';
|
|
|
|
Count = GetTimeFormat(
|
|
GetSupportedUserLocale(), 0, &SysTime, NULL, TimeStr,
|
|
TimeStrSize );
|
|
|
|
if( Count == 0 ) return GetLastError();
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
VOID
|
|
FormatPerInterfaceInfo(
|
|
IN OUT LPWSTR Buffer,
|
|
IN ULONG BufSize, // in WCHARs
|
|
IN PINTERFACE_NETWORK_INFO IfInfo,
|
|
IN BOOL fVerbose,
|
|
IN BOOL fDebug
|
|
)
|
|
{
|
|
LPWSTR Str;
|
|
WCHAR Phys[STATIC_BUFFER_LENGTH];
|
|
DWORD i, MsgId, Addr, Error, HeaderDisplayed;
|
|
|
|
//
|
|
// Skip tunnels with no addresses.
|
|
//
|
|
|
|
if (!fVerbose && (IfInfo->IfType == IfTypeTunnel) &&
|
|
(IfInfo->nIpv6Addresses == 0) && (IfInfo->nIpAddresses == 0))
|
|
return;
|
|
|
|
if( NULL != IfInfo->ConnectionName &&
|
|
IfInfo->ConnectionName[0] != L'\0')
|
|
Str = IfInfo->ConnectionName;
|
|
else
|
|
Str = IfInfo->DeviceGuidName;
|
|
|
|
//
|
|
// adapter title
|
|
//
|
|
|
|
DumpMessage(
|
|
Buffer, BufSize, MapIfType(IfInfo->IfType), Str );
|
|
if( fDebug ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DEVICE_GUID,
|
|
IfInfo->DeviceGuidName );
|
|
}
|
|
|
|
//
|
|
// media status
|
|
//
|
|
|
|
if( IfInfo->MediaDisconnected ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_MEDIA_DISCONNECTED );
|
|
}
|
|
|
|
//
|
|
// domain name
|
|
//
|
|
|
|
if( fDebug || !IfInfo->MediaDisconnected ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DOMAIN_NAME, IfInfo->DnsSuffix );
|
|
}
|
|
|
|
if( fVerbose ) {
|
|
|
|
//
|
|
// card name
|
|
//
|
|
|
|
Str = IfInfo->FriendlyName;
|
|
if( NULL != Str ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_FRIENDLY_NAME, Str );
|
|
}
|
|
|
|
//
|
|
// mac address
|
|
//
|
|
|
|
Str = (LPWSTR)Phys;
|
|
if( IfInfo->PhysicalNameLength ) {
|
|
for( i = 0; i < IfInfo->PhysicalNameLength; i ++ ) {
|
|
swprintf(Str, (LPWSTR) L"%02X-", (UCHAR)IfInfo->PhysicalName[i] );
|
|
Str += 3;
|
|
}
|
|
|
|
Str --; *Str = L'\0';
|
|
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_PHYSICAL_ADDRESS, (LPWSTR)Phys );
|
|
}
|
|
|
|
//
|
|
// dhcp and autoconfig enabled status
|
|
//
|
|
|
|
if( !IfInfo->MediaDisconnected ) {
|
|
MsgId = MSG_DHCP_DISABLED + IfInfo->EnableDhcp;
|
|
|
|
DumpMessage( Buffer, BufSize, MsgId );
|
|
|
|
if( IfInfo->EnableDhcp ) {
|
|
MsgId = MSG_AUTOCONFIG_DISABLED + IfInfo->EnableAutoconfig;
|
|
|
|
DumpMessage( Buffer, BufSize, MsgId );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( IfInfo->MediaDisconnected && !fDebug ) return;
|
|
|
|
//
|
|
// ip address and mask
|
|
//
|
|
|
|
if( IfInfo->IpAddress && IfInfo->nIpAddresses ) {
|
|
for( i = IfInfo->nIpAddresses-1; i > 0; i -- ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_IP_ADDRESS,
|
|
MapIp(IfInfo->IpAddress[i], (LPWSTR) Phys) );
|
|
|
|
if( IfInfo->nIpMasks <= i ) Addr = 0;
|
|
else Addr = IfInfo->IpMask[i];
|
|
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_SUBNET_MASK,
|
|
MapIp(Addr, (LPWSTR) Phys ));
|
|
}
|
|
|
|
if( IfInfo->AutoconfigActive ) MsgId = MSG_AUTO_ADDRESS;
|
|
else MsgId = MSG_IP_ADDRESS;
|
|
|
|
DumpMessage(
|
|
Buffer, BufSize, MsgId,
|
|
MapIp(*IfInfo->IpAddress, (LPWSTR) Phys) );
|
|
|
|
if( NULL != IfInfo->IpMask ) Addr = *IfInfo->IpMask;
|
|
else Addr = 0;
|
|
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_SUBNET_MASK,
|
|
MapIp(Addr, (LPWSTR) Phys) );
|
|
}
|
|
if( IfInfo->Ipv6Address && IfInfo->nIpv6Addresses ) {
|
|
for( i = 0; i < IfInfo->nIpv6Addresses; i ++ ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_IP_ADDRESS,
|
|
MapIpv6(&IfInfo->Ipv6Address[i], (LPWSTR) Phys) );
|
|
}
|
|
}
|
|
|
|
//
|
|
// default gateways
|
|
//
|
|
HeaderDisplayed = FALSE;
|
|
for( i = 0; i < IfInfo->nRouters; i ++ ) {
|
|
if (!HeaderDisplayed) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DEFAULT_GATEWAY,
|
|
MapIp( IfInfo->Router[i], (LPWSTR)Phys));
|
|
HeaderDisplayed = TRUE;
|
|
} else {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_ADDITIONAL_ENTRY,
|
|
MapIp( IfInfo->Router[i], (LPWSTR)Phys) );
|
|
}
|
|
}
|
|
for( i = 0; i < IfInfo->nIpv6Routers; i ++ ) {
|
|
if (!HeaderDisplayed) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DEFAULT_GATEWAY,
|
|
MapIpv6( &IfInfo->Ipv6Router[i], (LPWSTR)Phys));
|
|
HeaderDisplayed = TRUE;
|
|
} else {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_ADDITIONAL_ENTRY,
|
|
MapIpv6( &IfInfo->Ipv6Router[i], (LPWSTR)Phys) );
|
|
}
|
|
}
|
|
if (!HeaderDisplayed) {
|
|
DumpMessage(Buffer, BufSize, MSG_DEFAULT_GATEWAY, L"");
|
|
}
|
|
|
|
//
|
|
// dhcp classid
|
|
//
|
|
|
|
if( NULL != IfInfo->DhcpClassId ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DHCP_CLASS_ID,
|
|
IfInfo->DhcpClassId );
|
|
}
|
|
|
|
if( !fVerbose ) return;
|
|
|
|
//
|
|
// dhcp server and dns servers
|
|
//
|
|
|
|
if( IfInfo->EnableDhcp && !IfInfo->AutoconfigActive ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DHCP_SERVER,
|
|
MapIp( IfInfo->DhcpServer, (LPWSTR)Phys) );
|
|
}
|
|
|
|
HeaderDisplayed = FALSE;
|
|
if( IfInfo->nDnsServers && IfInfo->DnsServer) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DNS_SERVERS,
|
|
MapIp( IfInfo->DnsServer[0], (LPWSTR)Phys) );
|
|
HeaderDisplayed = TRUE;
|
|
for( i = 1; i < IfInfo->nDnsServers; i ++ ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_ADDITIONAL_ENTRY,
|
|
MapIp( IfInfo->DnsServer[i], (LPWSTR)Phys) );
|
|
}
|
|
}
|
|
if( IfInfo->nIpv6DnsServers && IfInfo->Ipv6DnsServer) {
|
|
for( i = 0; i < IfInfo->nIpv6DnsServers; i ++ ) {
|
|
if (!HeaderDisplayed) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DNS_SERVERS,
|
|
MapIpv6( &IfInfo->Ipv6DnsServer[i], (LPWSTR)Phys) );
|
|
HeaderDisplayed = TRUE;
|
|
} else {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_ADDITIONAL_ENTRY,
|
|
MapIpv6( &IfInfo->Ipv6DnsServer[i], (LPWSTR)Phys) );
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// wins info
|
|
//
|
|
|
|
if( IfInfo->nWinsServers && IfInfo->WinsServer ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_WINS_SERVER_1,
|
|
MapIp( IfInfo->WinsServer[0], (LPWSTR)Phys) );
|
|
}
|
|
|
|
if( IfInfo->nWinsServers > 1 && IfInfo->WinsServer ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_WINS_SERVER_2,
|
|
MapIp( IfInfo->WinsServer[1], (LPWSTR)Phys) );
|
|
for( i = 2; i < IfInfo->nWinsServers; i ++ ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_ADDITIONAL_ENTRY,
|
|
MapIp( IfInfo->WinsServer[i], (LPWSTR)Phys) );
|
|
}
|
|
}
|
|
|
|
if( !IfInfo->EnableNbtOverTcpip ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_NETBIOS_DISABLED );
|
|
}
|
|
|
|
if( IfInfo->EnableDhcp && !IfInfo->AutoconfigActive
|
|
&& IfInfo->nIpAddresses && IfInfo->IpAddress &&
|
|
IfInfo->IpAddress[0] ) {
|
|
|
|
WCHAR TimeString[STATIC_BUFFER_LENGTH];
|
|
|
|
Error = FormatTime(
|
|
(FILETIME *)(&IfInfo->LeaseObtainedTime), (LPWSTR)TimeString, STATIC_BUFFER_LENGTH);
|
|
if( NO_ERROR == Error ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_LEASE_OBTAINED, TimeString );
|
|
}
|
|
|
|
Error = FormatTime(
|
|
(FILETIME *)(&IfInfo->LeaseExpiresTime), (LPWSTR)TimeString, STATIC_BUFFER_LENGTH);
|
|
if( NO_ERROR == Error ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_LEASE_EXPIRES, TimeString );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#define MIN_XTRA_SPACE 1000
|
|
|
|
DWORD
|
|
FormatNetworkInfo(
|
|
IN OUT LPWSTR Buffer,
|
|
IN ULONG BufSize, // in WCHARs
|
|
IN PNETWORK_INFO NetInfo,
|
|
IN DWORD Win32Error,
|
|
IN DWORD InternalError,
|
|
IN BOOL fVerbose,
|
|
IN BOOL fDebug
|
|
)
|
|
{
|
|
DWORD i;
|
|
LPWSTR Str;
|
|
|
|
if( Win32Error || InternalError ) {
|
|
DumpErrorMessage(
|
|
Buffer, BufSize, InternalError, Win32Error );
|
|
|
|
if( !fDebug ) return NO_ERROR;
|
|
}
|
|
|
|
if( NULL == NetInfo ) return NO_ERROR;
|
|
|
|
if( fDebug ) fVerbose = TRUE;
|
|
|
|
//
|
|
// dump globals
|
|
//
|
|
|
|
if( fVerbose ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_HOST_NAME, NetInfo->HostName );
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_PRIMARY_DNS_SUFFIX,
|
|
NetInfo->DomainName );
|
|
DumpMessage(
|
|
Buffer, BufSize, MapNodeType(NetInfo->NodeType) );
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_ROUTING_DISABLED +
|
|
NetInfo->EnableRouting );
|
|
if (NetInfo->EnableProxy) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_WINS_PROXY_ENABLED);
|
|
} else {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_WINS_PROXY_DISABLED);
|
|
}
|
|
|
|
if( NULL != NetInfo->SuffixSearchList ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_DNS_SUFFIX_LIST,
|
|
NetInfo->SuffixSearchList );
|
|
Str = NetInfo->SuffixSearchList;
|
|
Str += wcslen(Str); Str++;
|
|
|
|
while( wcslen(Str) ) {
|
|
DumpMessage(
|
|
Buffer, BufSize, MSG_ADDITIONAL_ENTRY, Str );
|
|
Str += wcslen(Str); Str ++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// dump per interface stuff
|
|
//
|
|
|
|
for( i = 0; i < NetInfo->nInterfaces; i++ ) {
|
|
if( NULL != NetInfo->IfInfo &&
|
|
NULL != NetInfo->IfInfo[i] ) {
|
|
FormatPerInterfaceInfo(
|
|
Buffer, BufSize, NetInfo->IfInfo[i], fVerbose, fDebug );
|
|
}
|
|
}
|
|
|
|
if( wcslen(Buffer) + MIN_XTRA_SPACE > BufSize ) {
|
|
return ERROR_MORE_DATA;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
*
|
|
* GetSupportedUserLocale
|
|
*
|
|
* If LOCALE_USER_DEFAULT is not supported in the console it will return
|
|
* English US (409)
|
|
*
|
|
*******************************************************************************/
|
|
LCID GetSupportedUserLocale(void)
|
|
{
|
|
LCID lcid = GetUserDefaultLCID();
|
|
if (
|
|
(PRIMARYLANGID(lcid) == LANG_ARABIC) ||
|
|
(PRIMARYLANGID(lcid) == LANG_HEBREW) ||
|
|
(PRIMARYLANGID(lcid) == LANG_THAI) ||
|
|
(PRIMARYLANGID(lcid) == LANG_HINDI) ||
|
|
(PRIMARYLANGID(lcid) == LANG_TAMIL) ||
|
|
(PRIMARYLANGID(lcid) == LANG_FARSI)
|
|
)
|
|
{
|
|
lcid = MAKELCID (MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), SORT_DEFAULT); // 0x409;
|
|
}
|
|
return lcid;
|
|
}
|