Microsoft/WindowsXP-SP1
Microsoft/WindowsXP-SP1
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f7ca35dddd
WindowsXP-SP1/base/ntsetup/win95upg/tools/rasdump/rasdump.c
Microsoft f7ca35dddd First commit
2020-09-30 16:53:49 +02:00

868 lines
23 KiB
C
Raw Blame History

/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
w9xtool.c
Abstract:
Implements a stub tool that is designed to run with Win9x-side
upgrade code.
Author:
<full name> (<alias>) <date>
Revision History:
<alias> <date> <comments>
--*/
#include "pch.h"
typedef struct _IPData {
DWORD dwSize;
DWORD fdwTCPIP;
DWORD dwIPAddr;
DWORD dwDNSAddr;
DWORD dwDNSAddrAlt;
DWORD dwWINSAddr;
DWORD dwWINSAddrAlt;
} IPDATA, *PIPDATA;
typedef struct _AddrEntry {
DWORD dwVersion;
DWORD dwCountryCode;
UINT uOffArea;
UINT uOffPhone;
DWORD dwCountryID;
UINT uOffSMMCfg;
UINT uOffSMM;
UINT uOffDI;
} ADDRENTRY, *PADDRENTRY;
typedef struct _SubConnEntry {
DWORD dwSize;
DWORD dwFlags;
char szDeviceType[RAS_MaxDeviceType+1];
char szDeviceName[RAS_MaxDeviceName+1];
char szLocal[RAS_MaxPhoneNumber+1];
} SUBCONNENTRY, *PSUBCONNENTRY;
typedef struct _DEVICEINFO {
DWORD dwVersion;
UINT uSize;
char szDeviceName[RAS_MaxDeviceName+1];
char szDeviceType[RAS_MaxDeviceType+1];
} DEVICEINFO, *PDEVICEINFO;
typedef struct _SMMCFG {
DWORD dwSize;
DWORD fdwOptions;
DWORD fdwProtocols;
} SMMCFG, *PSMMCFG;
typedef struct {
DWORD Size;
DWORD Unknown1;
DWORD ModemUiOptions; // num seconds in high byte.
DWORD Unknown2;
DWORD Unknown3;
DWORD Unknown4;
DWORD ConnectionSpeed;
DWORD UnknownFlowControlData; //Somehow related to flow control.
DWORD Unknown5;
DWORD Unknown6;
DWORD Unknown7;
DWORD Unknown8;
DWORD Unknown9;
DWORD Unknown10;
DWORD Unknown11;
DWORD Unknown12;
DWORD Unknown13;
DWORD Unknown14;
DWORD Unknown15;
DWORD CancelSeconds; //Num seconds to wait before cancel if not connected. (0xFF equals off.)
DWORD IdleDisconnectSeconds; // 0 = Not Set.
DWORD Unknown16;
DWORD SpeakerVolume; // 0|1
DWORD ConfigOptions;
DWORD Unknown17;
DWORD Unknown18;
DWORD Unknown19;
} MODEMDEVINFO, *PMODEMDEVINFO;
#define RAS_UI_FLAG_TERMBEFOREDIAL 0x1
#define RAS_UI_FLAG_TERMAFTERDIAL 0x2
#define RAS_UI_FLAG_OPERATORASSISTED 0x4
#define RAS_UI_FLAG_MODEMSTATUS 0x8
#define RAS_CFG_FLAG_HARDWARE_FLOW_CONTROL 0x00000010
#define RAS_CFG_FLAG_SOFTWARE_FLOW_CONTROL 0x00000020
#define RAS_CFG_FLAG_STANDARD_EMULATION 0x00000040
#define RAS_CFG_FLAG_COMPRESS_DATA 0x00000001
#define RAS_CFG_FLAG_USE_ERROR_CONTROL 0x00000002
#define RAS_CFG_FLAG_ERROR_CONTROL_REQUIRED 0x00000004
#define RAS_CFG_FLAG_USE_CELLULAR_PROTOCOL 0x00000008
#define RAS_CFG_FLAG_NO_WAIT_FOR_DIALTONE 0x00000200
PCTSTR g_User = NULL;
PCTSTR g_Setting = NULL;
PCTSTR g_Entry = NULL;
BOOL g_ShowBinary = FALSE;
#define S_REMOTE_ACCESS_KEY TEXT("RemoteAccess")
#define S_PROFILE_KEY TEXT("RemoteAccess\\Profile")
#define S_ADDRESSES_KEY TEXT("RemoteAccess\\Addresses")
#define S_DIALUI TEXT("DialUI")
#define S_ENABLE_REDIAL TEXT("EnableRedial")
#define S_REDIAL_WAIT TEXT("RedialWait")
#define S_REDIAL_TRY TEXT("RedialTry")
#define S_ENABLE_IMPLICIT TEXT("EnableImplicit")
#define S_TERMINAL TEXT("Terminal")
#define S_MODE TEXT("Mode")
#define S_MULTILINK TEXT("MultiLink")
#define DIALUI_DONT_PROMPT_FOR_INFO 0x01
#define DIALUI_DONT_SHOW_CONFIRM_DIALOG 0x02
#define DIALUI_DONT_SHOW_ICON 0x04
#define SMMCFG_TCPIP_PROTOCOL 0x04
#define SMMCFG_NETBEUI_PROTOCOL 0x01
#define SMMCFG_IPXSPX_PROTOCOL 0x02
#define PAESMMCFG(pAE) ((PSMMCFG)(((PBYTE)pAE)+(pAE->uOffSMMCfg)))
#define PAESMM(pAE) ((PSTR)(((PBYTE)pAE)+(pAE->uOffSMM)))
#define PAEDI(pAE) ((PDEVICEINFO)(((PBYTE)pAE)+(pAE->uOffDI )))
#define PAEAREA(pAE) ((PSTR)(((PBYTE)pAE)+(pAE->uOffArea)))
#define PAEPHONE(pAE) ((PSTR)(((PBYTE)pAE)+(pAE->uOffPhone)))
#define DECRYPTENTRY(x, y, z) EnDecryptEntry(x, (LPBYTE)y, z)
static BYTE NEAR PASCAL GenerateEncryptKey (LPSTR szKey)
{
BYTE bKey;
LPBYTE lpKey;
for (bKey = 0, lpKey = (LPBYTE)szKey; *lpKey != 0; lpKey++)
{
bKey += *lpKey;
};
return bKey;
}
DWORD NEAR PASCAL EnDecryptEntry (LPSTR szEntry, LPBYTE lpEnt,
DWORD cb);
VOID
pDumpPerUserSettings (
IN HKEY UserKey
)
{
HKEY settingsKey;
PDWORD data;
printf("\n*** Ras Per User Setting Information ***\n");
settingsKey = OpenRegKey(UserKey,S_REMOTE_ACCESS_KEY);
if (settingsKey) {
//
// Get UI settings.
//
data = (PDWORD) GetRegValueBinary(settingsKey,S_DIALUI);
printf("\n\t** Dialup UI Information **\n");
if (data) {
printf("\t\t%sprompt for information before dialing.\n",
DIALUI_DONT_PROMPT_FOR_INFO & *data ? "Don't " :""
);
printf("\t\t%sshow confirmation dialog after connected.\n",
DIALUI_DONT_SHOW_CONFIRM_DIALOG & *data ? "Don't ":""
);
printf("\t\t%sshow an icon on the taskbar after connected.\n",
DIALUI_DONT_SHOW_ICON & *data ? "Don't ":""
);
MemFree(g_hHeap,0,data);
}
else {
printf("\t\tNo user UI Settings found..\n");
}
//
// Get Redial information.
//
printf("\n\t** Redialing Information **\n");
data = (PDWORD) GetRegValueBinary(settingsKey,S_ENABLE_REDIAL);
if (data) {
printf("\t\tRedialing %s.\n",*data ? "Enabled." : "Disabled.");
MemFree(g_hHeap,0,data);
}
else {
printf("\t\tNo Redial information found.\n");
}
data = (PDWORD) GetRegValueBinary(settingsKey,S_REDIAL_TRY);
if (data) {
printf("\t\tNumber of redial tries: %u.\n", *data);
MemFree(g_hHeap,0,data);
}
data = (PDWORD) GetRegValueBinary(settingsKey,S_REDIAL_WAIT);
if (data) {
printf("\t\tRedial time in seconds: %u\n", HIWORD(*data) * 60 + LOWORD(*data));
MemFree(g_hHeap,0,data);
}
//
// Get implicit connection information.
//
data = (PDWORD) GetRegValueBinary(settingsKey,S_ENABLE_IMPLICIT);
if (data) {
printf("\n\t%sprompt with dial-up networking to establish connection.\n",
*data ? "" : "Don't "
);
MemFree(g_hHeap,0,data);
}
CloseRegKey(settingsKey);
}
printf("\n***\n");
}
PTSTR
pIpAddressAsString(
DWORD dwAddress
)
{
BYTE bAddress[4];
static TCHAR address[30];
*((LPDWORD)bAddress) = dwAddress;
sprintf(address,"%d.%d.%d.%d", bAddress[0], bAddress[1], bAddress[2],bAddress[3]);
return address;
}
VOID
pDumpBinaryData(
IN PBYTE Data,
IN UINT Size
)
{
UINT i,j;
TCHAR hexArray[40];
TCHAR strArray[20];
TCHAR buf[20];
printf("\n\t\tBinary Dump...\n");
for (j = 0;j<Size + Size % 8;j +=8) {
*hexArray = 0;
*strArray = 0;
for (i = 0;i < 8;i++) {
sprintf(buf," %02x",i + j < Size ? Data[i+j] : 0x00);
_tcscat(hexArray,buf);
sprintf(buf," %c",isprint(Data[i+j]) && i + j < Size ? Data[i+j] : TEXT('.'));
_tcscat(strArray,buf);
}
printf("\n\t\t%s\t%s",hexArray,strArray);
}
printf("\n\n");
}
VOID
pDumpIpInformation (
IN PIPDATA IpData
)
{
printf("\t\t<IPINFO> fTcpIp = %u\n",IpData -> fdwTCPIP);
printf("\t\t<IPINFO> IP Address = %s\n",pIpAddressAsString(IpData -> dwIPAddr));
printf("\t\t<IPINFO> DNS Address = %s\n",pIpAddressAsString(IpData -> dwDNSAddr));
printf("\t\t<IPINFO> Alternate DNS Address = %s\n",pIpAddressAsString(IpData -> dwDNSAddrAlt));
printf("\t\t<IPINFO> WINS Address = %s\n",pIpAddressAsString(IpData -> dwWINSAddr));
printf("\t\t<IPINFO> Alternate WINS Address = %s\n",pIpAddressAsString(IpData -> dwWINSAddrAlt));
}
VOID
pDumpConnectionSettings (
IN HANDLE Key,
IN PCTSTR Name
)
{
REGVALUE_ENUM e;
PBYTE curData;
printf("\n\t** %s Setting.. **\n",Name);
if (EnumFirstRegValue(&e,Key)) {
do {
//
// Get the data for this entry.
//
curData = GetRegValueData(Key,e.ValueName);
if (curData) {
if (!g_Setting || StringIMatch(g_Setting,e.ValueName)) {
switch (e.Type) {
case REG_SZ:
case REG_MULTI_SZ:
case REG_EXPAND_SZ:
printf("\t\t<STRING DATA> %s = %s\n",e.ValueName,(PCTSTR) curData);
break;
case REG_DWORD:
printf("\t\t<DWORD DATA> %s = %u\n",e.ValueName,*((PDWORD) curData));
break;
case REG_BINARY:
if (StringIMatch(S_IPINFO,e.ValueName)) {
pDumpIpInformation((PIPDATA) curData);
}
else if (StringIMatch(S_TERMINAL,e.ValueName)) {
PWINDOWPLACEMENT wp = (PWINDOWPLACEMENT) curData;
PCTSTR showStr = NULL;
switch(wp -> showCmd) {
case SW_HIDE:
showStr = "SW_HIDE";
break;
case SW_MINIMIZE:
showStr = "SW_MINIMIZE";
break;
case SW_RESTORE:
showStr = "SW_RESTORE";
break;
case SW_SHOW:
showStr = "SW_SHOW";
break;
case SW_SHOWMAXIMIZED:
showStr = "SW_SHOWMAXIMIZED";
break;
case SW_SHOWMINIMIZED:
showStr = "SW_SHOWMINIMIZED";
break;
case SW_SHOWMINNOACTIVE:
showStr = "SW_SHOWMINNOACTIVE";
break;
case SW_SHOWNA:
showStr = "SW_SHOWNA";
break;
case SW_SHOWNOACTIVATE:
showStr = "SW_SHOWNOACTIVATE";
break;
case SW_SHOWNORMAL:
showStr = "SW_SHOWNORMAL";
break;
default:
showStr = "Unknown SHOW FLAG!";
break;
}
printf("\t\tTerminal Window Show Flag: %s\n", showStr);
} else if (StringIMatch(S_MODE,e.ValueName)) {
if (*curData) {
printf("\t\tStep through script. (Testing Mode..)\n");
}
else {
printf("\t\tScript should be run in normal mode.\n");
}
} else if (StringIMatch(S_MULTILINK,e.ValueName)) {
printf("\t\tMultilink is %s.\n",*curData ? "ENABLED" : "DISABLED");
} else {
printf("\t\t<!!UNKNOWN BINARY DATA!!> %s = <BINARY BLOB>\n",e.ValueName);
}
if (g_ShowBinary) {
pDumpBinaryData(curData,e.DataSize);
}
break;
default:
printf("\t\t<UNKNOWN DATA TYPE> %s = <UNKNOWN DATA TYPE>\n",e.ValueName);
break;
}
}
MemFree(g_hHeap,0,curData);
}
} while (EnumNextRegValue(&e));
}
}
VOID
pDumpDevInfo (
IN PDEVICEINFO Info
)
{
UINT size;
UINT i;
PMODEMDEVINFO caps;
printf ("** Device Info: \n"
"\t\tVersion: %u \n"
"\t\tSize: %u\n"
"\t\tDevice Name: %s\n"
"\t\tDevice Type: %s\n",
Info->dwVersion,
Info->uSize,
Info->szDeviceName,
Info->szDeviceType
);
size = Info->uSize - ((PBYTE) (Info->szDeviceType + RAS_MaxDeviceType + 1) - (PBYTE) Info);
caps = (PMODEMDEVINFO) (Info->szDeviceType + RAS_MaxDeviceType + 3);
#if 0
pDumpBinaryData ((PBYTE) caps, sizeof (REGDEVCAPS));
printf ("As Dwords..\n");
for (i = 0; i < 27; i++) {
printf ("Dword %u = %u (%x)\n",i, caps->foo[i], caps->foo[i]);
}
#endif
printf (
"\tCaps Size: %u\n"
"\tStart Term Before Redial? %s\n"
"\tStart Term After Redial? %s\n"
"\tOperator Assited Dial? %s\n"
"\tShow Modem Status? %s\n"
"\tUI Options: %u (%x)\n"
"\tConnection Speed: %u\n"
"\tCancel if not connected within %u seconds.\n"
"\tDisconnect if Idle for %u seconds.\n"
"\tSpeaker %s.\n"
"\tHardware Flow Control? %s\n"
"\tSoftware Flow Control? %s\n"
"\tStandard Emulation? %s\n"
"\tCompress Data? %s\n"
"\tUse Error Control? %s\n"
"\tError Control Required? %s\n"
"\tUse Cellular Protocol? %s\n"
"\tWait for Dialtone? %s\n"
"\tConfig Options: %u (%x)\n",
caps->Size,
caps->ModemUiOptions & RAS_UI_FLAG_TERMBEFOREDIAL ? "Yes" : "No",
caps->ModemUiOptions & RAS_UI_FLAG_TERMAFTERDIAL ? "Yes" : "No",
caps->ModemUiOptions & RAS_UI_FLAG_OPERATORASSISTED ? "Yes" : "No",
caps->ModemUiOptions & RAS_UI_FLAG_MODEMSTATUS ? "Yes" : "No",
caps->ModemUiOptions,
caps->ModemUiOptions,
caps->ConnectionSpeed,
caps->CancelSeconds,
caps->IdleDisconnectSeconds,
caps->SpeakerVolume ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_HARDWARE_FLOW_CONTROL ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_SOFTWARE_FLOW_CONTROL ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_STANDARD_EMULATION ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_COMPRESS_DATA ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_USE_ERROR_CONTROL ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_ERROR_CONTROL_REQUIRED ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_USE_CELLULAR_PROTOCOL ? "Yes" : "No",
caps->ConfigOptions & RAS_CFG_FLAG_NO_WAIT_FOR_DIALTONE ? "No" : "Yes",
caps->ConfigOptions,
caps->ConfigOptions
);
}
VOID
pDumpAddressInfo (
IN HKEY AddressKey,
IN PCTSTR SubKeyName
)
{
PBYTE data = NULL;
UINT count = 0;
UINT type = 0;
PADDRENTRY entry;
PSMMCFG smmCfg;
PDEVICEINFO devInfo;
UINT sequencer = 0;
HKEY subEntriesKey;
PTSTR subEntriesKeyStr;
REGVALUE_ENUM eSubEntries;
PSUBCONNENTRY subEntry;
if (RegQueryValueEx(AddressKey, SubKeyName, NULL, &type, NULL, &count) == ERROR_SUCCESS) {
data = MemAlloc(g_hHeap,0,count);
if (data) {
if (RegQueryValueEx(AddressKey, SubKeyName, NULL, &type, (LPBYTE)data,&count) == ERROR_SUCCESS) {
entry = (PADDRENTRY) data;
DECRYPTENTRY((PTSTR)SubKeyName, entry, count);
smmCfg = PAESMMCFG(entry);
devInfo = PAEDI(entry);
pDumpDevInfo (devInfo);
if (!g_Setting || StringMatch(g_Setting,"AddressData")) {
printf("\t\t<AddressData> Phone Number = %s\n",PAEPHONE(entry));
printf("\t\t<AddressData> Area Code = %s\n",PAEAREA(entry));
printf("\t\t<AddressData> SMM = %s\n",PAESMM(entry));
printf("\t\t<AddressData> Country Code = %u\n",entry -> dwCountryCode);
printf("\t\t<AddressData> Country Id = %u\n",entry -> dwCountryID);
printf("\t\t<Device Info> DeviceName = %s\n",devInfo -> szDeviceName);
printf("\t\t<Device Info> DeviceType = %s\n",devInfo -> szDeviceType);
printf("\t\t<SMM Cfg> Options = %u\n",smmCfg -> fdwOptions);
printf("\t\t<SMM Cfg> TCPIP is %s.\n",
smmCfg -> fdwProtocols & SMMCFG_TCPIP_PROTOCOL ? "ENABLED" : "DISABLED");
printf("\t\t<SMM Cfg> NETBEUI is %s.\n",
smmCfg -> fdwProtocols & SMMCFG_NETBEUI_PROTOCOL ? "ENABLED" : "DISABLED");
printf("\t\t<SMM Cfg> IPX/SPX is %s.\n",
smmCfg -> fdwProtocols & SMMCFG_IPXSPX_PROTOCOL ? "ENABLED" : "DISABLED");
if (g_ShowBinary) {
pDumpBinaryData((PBYTE) entry,count);
}
}
}
MemFree(g_hHeap,0,data);
subEntriesKeyStr = JoinPaths ("SubEntries", SubKeyName);
subEntriesKey = OpenRegKey (AddressKey, subEntriesKeyStr);
FreePathString (subEntriesKeyStr);
sequencer = 0;
if (subEntriesKey) {
if (EnumFirstRegValue (&eSubEntries, subEntriesKey)) {
do {
data = GetRegValueBinary (subEntriesKey, eSubEntries.ValueName);
if (data) {
subEntry = (PSUBCONNENTRY) data;
DECRYPTENTRY ((PTSTR) SubKeyName, subEntry, eSubEntries.DataSize);
printf ("\tSub Entry Device Type: %s\n", subEntry->szDeviceType);
printf ("\tSub Entry Device Name: %s\n", subEntry->szDeviceName);
printf ("\tSub Entry Phone Number: %s\n", subEntry->szDeviceName);
printf ("\tSub Entry Flags: %u (%x)\n", subEntry->dwFlags);
printf ("\tSub Entry Size: %u\n", subEntry->dwSize);
pDumpBinaryData ((PBYTE) subEntry, subEntry->dwSize);
MemFree (g_hHeap, 0, data);
}
sequencer++;
} while (EnumNextRegValue (&eSubEntries));
}
CloseRegKey (subEntriesKey);
}
}
}
}
VOID
pDumpPerConnectionSettings (
IN HKEY UserKey
)
{
REGKEY_ENUM e;
HKEY profileKey;
HKEY entryKey = NULL;
HKEY addressKey = NULL;
printf("\n*** Ras Per Connection Setting Information ***\n");
profileKey = OpenRegKey (UserKey,S_PROFILE_KEY);
addressKey = OpenRegKey (UserKey,S_ADDRESSES_KEY);
if (profileKey && addressKey) {
if (EnumFirstRegKey(&e,addressKey)) {
do {
if (!g_Entry || StringIMatch(g_Entry,e.SubKeyName)) {
pDumpAddressInfo(addressKey,e.SubKeyName);
entryKey = OpenRegKey(profileKey,e.SubKeyName);
if (entryKey ) {
pDumpConnectionSettings (entryKey, e.SubKeyName);
CloseRegKey(entryKey);
}
}
} while (EnumNextRegKey(&e));
}
}
CloseRegKey(addressKey);
CloseRegKey(profileKey);
printf("\n***\n");
}
BOOL
Init (
VOID
)
{
HINSTANCE hInstance;
hInstance = GetModuleHandle (NULL);
return InitToolMode (hInstance);
}
VOID
Terminate (
VOID
)
{
HINSTANCE hInstance;
hInstance = GetModuleHandle (NULL);
TerminateToolMode (hInstance);
}
VOID
pShowHelp (
VOID
)
{
printf("\nUsage: RasDump [-h?b] [-u:<UserName>] [-e:<EntryName>] [-s:<SettingName>]\n"
"\n\t\t -h - Display this message."
"\n\t\t -? - Display this message."
"\n\t\t -u - Dump information for user <UserName>."
"\n\t\t -b - Dump raw binary data."
"\n\t\t -e - Dump Entry infor for DialUp Connection <EntryName>.\n");
exit(0);
}
VOID
pProcessCommandLine (
UINT argc,
PTSTR * argv
)
{
UINT i;
PTSTR p;
for (i = 1;i < argc; i++) {
p = argv[i];
if (*p != TEXT('-') && *p != TEXT('/')) {
pShowHelp();
}
p++;
switch(tolower(*p)) {
case TEXT('u'):
if (*++p != ':') {
pShowHelp();
}
g_User = ++p;
break;
case TEXT('s'):
if (*++p != ':') {
pShowHelp();
}
g_Setting = ++p;
break;
case TEXT('h'): case TEXT('?'):
pShowHelp();
break;
case TEXT('e'):
if (*++p != ':') {
pShowHelp();
}
g_Entry = ++p;
break;
case TEXT('b') :
g_ShowBinary = TRUE;
break;
default:
pShowHelp();
break;
}
}
}
INT
__cdecl
main (
INT argc,
CHAR *argv[]
)
{
USERENUM e;
TCHAR buf[MEMDB_MAX];
if (!Init()) {
printf ("Unable to initialize!\n");
return 255;
}
//
// needed by enumuser..
//
GetWindowsDirectory(buf,MAX_PATH);
g_WinDir = buf;
Win95RegInit(g_WinDir,NULL);
pProcessCommandLine(argc,argv);
if (EnumFirstUser (&e, ENUMUSER_ENABLE_NAME_FIX)) {
do {
if (!g_User || StringIMatch(g_User,e.UserName)) {
printf("Dumping ras settings for user %s..\n",*e.UserName ? e.UserName : "<Default>");
__try {
pDumpPerUserSettings(e.UserRegKey);
pDumpPerConnectionSettings(e.UserRegKey);
}
except (1) {
printf("Caught an exception..");
}
}
} while (EnumNextUser(&e));
}
Terminate();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink