archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
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.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-nt-4.0/private/sdktools/getbin/getbin.c

838 lines
22 KiB
Raw Permalink Blame History

#include <nt.h> // For shutdown privilege.
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include "getbin.h"
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <locale.h>
#include <process.h>
#include <windows.h>
#define MV_FLAGS (MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT)
#define CCH_BUF 512
#define RES_DLGOPTIONS 1
BOOL CALLBACK OptionsDlgProc (HWND, UINT, WPARAM, LPARAM);
CONST CHAR szDEFSAVEEXT[] = "lst";
CONST CHAR szSAVEEXT[] = "SaveExtension";
CONST CHAR szDEFCOPYEXT[] = "dll";
CONST CHAR szJUNKEXT[] = "yuk";
CONST CHAR szDEST[] = "Dest";
CONST CHAR szSYMS[] = "Symbols";
CONST CHAR szSOURCE[] = "Source";
CONST CHAR szSYSTEM32[] = "SYSTEM32";
CONST CHAR szSYMBOLS[] = "SYMBOLS";
CONST CHAR szGETBIN[] = "Getbin";
CONST CHAR szGETBINDIR[] = "GetbinSourceDir";
CONST CHAR szWINDIR[] = "windir";
CHAR szTRYRENAME[] = "TryRename";
CHAR szTRYCOPY[] = "TryCopy";
CHAR szPOLL[] = "Poll";
CHAR szREBOOT[] = "Reboot";
CHAR szSAVEPREVIOUS[] = "SavePrevious";
CHAR szRESTORECMD[] = "Restore.Cmd";
CHAR szCOPYDBGTOO[] = "CopyDbgToo";
CHAR szCOPYSOURCETYPE[] = "CopySourceType";
BOOL gbTryRename = TRUE;
BOOL gbDelayCopy = FALSE;
BOOL gbTryCopy = TRUE;
BOOL gbPoll = FALSE;
BOOL gbReboot = FALSE;
BOOL gbSavePrevious = FALSE;
BOOL gbRestoreCmd = FALSE;
BOOL gbCopyDbgToo = FALSE;
BOOL gbForceTempCopy = FALSE;
HANDLE ghRestoreCmd = NULL; // file handle for Restore.Cmd
BOOL giCopySourceType = IDD_COPY_COMMAND;
CHAR szDestDir[CCH_BUF];
CHAR szSymsDir[CCH_BUF];
CHAR szSourceDir[CCH_BUF];
CHAR szWinDir[CCH_BUF];
CHAR szSaveExtension[4];
CHAR szCopyExtension[4];
BOOL DoGetbin(LPSTR szFileName, BOOL bDbgFile);
void PrintUsage(void) {
printf("usage: getbin [-c] [-d] [-D] [-l] [-r] [-t] [-w] <filename> [[-w] <filename>]...\n");
printf(" -c create Restore.Cmd\n");
printf(" -d delay copy until reboot\n");
printf(" -D copy DBG files too\n");
printf(" -l copy old file to *.lst\n");
printf(" -w <filename> : wait for <filename> to be updated\n");
printf(" -r reboot after copy\n");
printf(" -t copy when date of src is newer\n");
printf(" -T Force temp copy when using -d\n");
printf("usage: getbin -o\n");
printf(" GUI biset options\n");
}
int _CRTAPI1 main (int argc, char *argv[])
{
DWORD dwRet;
int iArg = 1;
int nFiles = 0;
if (argc <= 1) {
PrintUsage();
exit(0);
}
setlocale(LC_ALL, ".OCP");
dwRet = GetEnvironmentVariable( szWINDIR, szWinDir, sizeof(szWinDir)/sizeof(szWinDir[0]));
if (!dwRet) {
szWinDir[0] = '\0';
}
/*
* Get the defaults
*
* Destination Directory
*/
if (GetProfileString(szGETBIN, szDEST, "", szDestDir, sizeof(szDestDir)) < 2) {
if (szWinDir[0] == '\0') {
printf("Getbin: can not read environment string %s.\n", szWINDIR);
exit(0);
}
sprintf(szDestDir, "%s\\%s", szWinDir, szSYSTEM32);
}
_strupr(szDestDir);
if (GetProfileString(szGETBIN, szSYMS, "", szSymsDir, sizeof(szSymsDir)) < 2) {
if (szWINDIR[0] == '\0') {
printf("Getbin: can not read environment string %s.\n", szWINDIR);
exit(0);
}
sprintf(szSymsDir, "%s\\%s", szWinDir, szSYMBOLS);
}
_strupr(szSymsDir);
GetProfileString(szGETBIN, szSOURCE, "", szSourceDir, sizeof(szSourceDir));
gbTryRename = GetProfileInt(szGETBIN, szTRYRENAME, gbTryRename);
gbTryCopy = GetProfileInt(szGETBIN, szTRYCOPY, gbTryCopy);
gbPoll = GetProfileInt(szGETBIN, szPOLL, gbPoll);
gbReboot = GetProfileInt(szGETBIN, szREBOOT, gbReboot);
gbSavePrevious = GetProfileInt(szGETBIN, szSAVEPREVIOUS, gbSavePrevious);
gbRestoreCmd = GetProfileInt(szGETBIN, szRESTORECMD, gbRestoreCmd);
if (gbRestoreCmd) {
gbSavePrevious = TRUE;
}
gbCopyDbgToo = GetProfileInt(szGETBIN, szCOPYDBGTOO, gbCopyDbgToo);
giCopySourceType = GetProfileInt(szGETBIN, szCOPYSOURCETYPE, giCopySourceType);
GetProfileString(szGETBIN, szSAVEEXT, szDEFSAVEEXT, szSaveExtension, sizeof(szSaveExtension));
/*
* Compute the flags
*/
// printf("argc %lX %s %s %s\n", argc, argv[0], argv[1], argv[2] );
for (iArg=1; iArg<argc; iArg++) {
if (argv[iArg][0] == '-') {
switch (argv[iArg][1]) {
case 'c':
gbRestoreCmd = TRUE;
// need to save the previous files then!
gbSavePrevious = TRUE;
break;
case 'D':
gbCopyDbgToo = TRUE;
break;
case 'd':
gbDelayCopy = TRUE;
break;
case 'r':
gbReboot = TRUE;
break;
case 'l':
gbSavePrevious = TRUE;
break;
case 't':
giCopySourceType; //!!!
break;
case 'T':
gbForceTempCopy = TRUE;
break;
case 'o':
DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(RES_DLGOPTIONS), NULL, OptionsDlgProc);
return 1;
break;
case 'w':
gbPoll = TRUE;
break;
default:
printf("ERROR: Invalid flag %c\n", argv[iArg][1]);
case '?':
PrintUsage();
exit(0);
break;
}
} else {
if (!DoGetbin(argv[iArg], FALSE)) {
gbReboot = FALSE;
} else if (gbCopyDbgToo) {
// got the binary, so now get the DBG file
if (!DoGetbin(argv[iArg], TRUE)) {
gbReboot = FALSE;
}
}
nFiles++;
}
}
if (nFiles == 0) {
printf("ERROR: No files specified\n");
PrintUsage();
exit(0);
}
/*
* Reboot if requested
*/
if (gbReboot) {
BOOLEAN PreviousPriv;
printf("\nRebooting system\n");
RtlAdjustPrivilege(SE_SHUTDOWN_PRIVILEGE, TRUE, FALSE, &PreviousPriv);
ExitWindowsEx(EWX_FORCE|EWX_REBOOT, 0);
}
CloseHandle(ghRestoreCmd);
return 1;
}
#define ENTER 0x0d
BOOL fConfirm(char *pszQuestion)
{
int ch, chLast;
chLast = 0;
printf ("%s [yn] ", pszQuestion);
while( TRUE ) {
ch = _getch();
ch = tolower( ch );
if (ch == ENTER && (chLast == 'y' || chLast == 'n')) {
putchar('\n');
return (chLast == 'y');
}
if (ch != 0) {
if (ch == 'y' || ch == 'n') {
putchar(ch);
putchar('\b');
}
}
chLast = ch;
}
}
#define F_TIME 0x01
#define F_DATE 0x02
LPWSTR DateTimeString(
CONST FILETIME *pft,
DWORD Flags)
{
SYSTEMTIME DateTime;
FILETIME LocalFileTime;
static WCHAR wszDateTime[80];
int cch;
FileTimeToLocalFileTime(pft, &LocalFileTime);
FileTimeToSystemTime(&LocalFileTime, &DateTime);
if (Flags == 0) {
Flags = F_TIME;
}
if (Flags & F_DATE) {
cch = GetDateFormatW(LOCALE_USER_DEFAULT,
LOCALE_NOUSEROVERRIDE,
&DateTime,
NULL,
wszDateTime,
sizeof(wszDateTime)/sizeof(wszDateTime[0]) - 1);
wszDateTime[cch-1] = '\t';
} else {
cch = 0;
}
if (Flags & F_TIME) {
GetTimeFormatW(LOCALE_USER_DEFAULT,
LOCALE_NOUSEROVERRIDE,
&DateTime,
NULL,
&wszDateTime[cch],
sizeof(wszDateTime)/sizeof(wszDateTime[0]) - cch);
}
return wszDateTime;
}
DWORD MyGetFileSize(
CONST LPSTR pszFile)
{
HANDLE hFindNext;
WIN32_FIND_DATA FindFileData;
hFindNext = FindFirstFile(pszFile, &FindFileData);
if (hFindNext != INVALID_HANDLE_VALUE) {
FindClose(hFindNext);
}
printf("Size %ld\n", FindFileData.nFileSizeLow);
return FindFileData.nFileSizeLow;
}
/*
* Poll for a file, returns TRUE when the file is ready to be fetched, FALSE if not
*/
BOOL PollForFile(
CONST LPSTR szSrc,
CONST LPSTR szDest)
{
FILETIME ftLastWriteSrc = {0, 0};
FILETIME ftLastWriteDest = {0, 0};
HANDLE hFindNext;
WIN32_FIND_DATA FindFileData;
FILETIME ft;
SYSTEMTIME DateTime;
OFSTRUCT OpenBuff;
/*
* Get last write time of destination (ftLastWriteDest)
*/
hFindNext = FindFirstFile(szDest, &FindFileData);
if (hFindNext != INVALID_HANDLE_VALUE) {
FindClose(hFindNext);
ftLastWriteDest = FindFileData.ftLastWriteTime;
printf("Time of destination = %ws\n",
DateTimeString(&ftLastWriteDest, F_DATE|F_TIME));
} else {
printf("Can't find destination %s\n", szDest);
}
/*
* Give the user a chance to pull down the current source if it is already
* more recent than the destination.
* If they want an even more recent source, Wait until the source file
* starts getting updated.
*/
while (TRUE) {
hFindNext = FindFirstFile(szSrc, &FindFileData);
if (hFindNext != INVALID_HANDLE_VALUE) {
FindClose(hFindNext);
if ((ftLastWriteSrc.dwHighDateTime | ftLastWriteSrc.dwLowDateTime) == 0) {
ftLastWriteSrc = FindFileData.ftLastWriteTime;
printf("Time of source = %ws\n",
DateTimeString(&ftLastWriteSrc, F_DATE|F_TIME));
if (CompareFileTime(&ftLastWriteSrc, &ftLastWriteDest) > 0) {
// Source is more recent!
if (fConfirm("Source is more recent, fetch it now?")) {
return TRUE;
}
}
printf("Polling for a new %s...\n", szSrc);
} else {
if (CompareFileTime(&FindFileData.ftLastWriteTime, &ftLastWriteSrc) > 0) {
// it got updated!
break;
}
}
} else {
/*
* Source not there yet, we want to grab it as soon as it is ready
*/
ftLastWriteSrc.dwLowDateTime = 1;
}
printf(".");
Sleep(1000);
}
/*
* The source is being written, so wait until the write stops
* (When the write has finished, we will be able to open it exclusively)
*/
do {
HANDLE hTmp;
#ifdef DBG_POLL
/*
* This debug stuff show if & how the source file's timestamps & size
* vary each time we go around the loop.
*/
DWORD dwSizeH, dwSizeL;
FILETIME ftC, ftA, ftW;
ftC = FindFileData.ftCreationTime;
ftA = FindFileData.ftLastAccessTime;
ftW = FindFileData.ftLastWriteTime;
dwSizeH = FindFileData.nFileSizeHigh;
dwSizeL = FindFileData.nFileSizeLow;
hFindNext = FindFirstFile(szSrc, &FindFileData);
if (hFindNext == INVALID_HANDLE_VALUE) {
break;
}
FindClose(hFindNext);
/*
* Some debug output each time we see that the src file has
* changed size or timestamps.
*/
if ((CompareFileTime(&ftA, &FindFileData.ftLastAccessTime) != 0) ||
(CompareFileTime(&ftW, &FindFileData.ftLastWriteTime) != 0) ||
(CompareFileTime(&ftC, &FindFileData.ftCreationTime) != 0) ||
(dwSizeH != FindFileData.nFileSizeHigh) ||
(dwSizeL != FindFileData.nFileSizeLow)) {
printf("Create %ws ",
DateTimeString(&FindFileData.ftCreationTime, F_TIME));
printf("Access %ws ",
DateTimeString(&FindFileData.ftLastAccessTime, F_TIME));
ft = FindFileData.ftLastWriteTime;
printf("Write %ws ", DateTimeString(&ft, F_TIME));
printf("Size %ld\n", dwSizeL);
}
#endif
/*
* If we can open the file for writing, no other process has it open
*/
hTmp = CreateFileA(
szSrc,
GENERIC_READ | GENERIC_WRITE, // write access
0, // no sharing
NULL, // no Security Attributes
OPEN_EXISTING, // of course
FILE_ATTRIBUTE_NORMAL | // whatever
FILE_FLAG_NO_BUFFERING, // why not?
NULL); // no template
if (hTmp != INVALID_HANDLE_VALUE) {
CloseHandle(hTmp);
break;
}
/*
* If the share is read-only, the trick above won't work so we wait
* for 1 second and then take it.
*/
if (GetLastError() == ERROR_ACCESS_DENIED) {
int i;
printf("\n\t%s is read-only, delay 5 seconds.\n", szSrc);
for (i = 0; i < 5; i++) {
Sleep(1000);
printf(".");
}
break;
}
printf("+");
Sleep(500);
} while (TRUE);
/*
* One last delay (for binplace etc.)
*/
Sleep(500);
/*
* Find out how big the file is now, just for the keck of it.
*/
hFindNext = FindFirstFile(szSrc, &FindFileData);
if (hFindNext != INVALID_HANDLE_VALUE) {
FindClose(hFindNext);
}
printf("Size %ld\n", FindFileData.nFileSizeLow);
return TRUE;
}
BOOL DoGetbin(
LPSTR szFileName,
BOOL bDbgFile)
{
BOOL bNetDrive = FALSE;
BOOL bRet;
DWORD dwRet;
CHAR szDest[CCH_BUF]; // !! to go
CHAR szTempFile[CCH_BUF];
CHAR szSrc[CCH_BUF];
CHAR szBackup[CCH_BUF];
CHAR szSourceFile[CCH_BUF];
CHAR szExt[10];
PCHAR pszSrc = szSrc;
PCHAR pszDot;
WIN32_FIND_DATA FindFileData;
/*
* Get the source and destination files
*/
strcpy( szSourceFile, szFileName );
/*
* Add the default extension if no extension of this file
*/
pszDot = strrchr(szSourceFile, '.');
if (pszDot == NULL) {
pszDot = szSourceFile + strlen(szSourceFile);
*pszDot = '.';
strcpy( pszDot+1, szDEFCOPYEXT);
}
strcpy( szExt, pszDot+1);
if (bDbgFile) {
strcpy(pszDot+1, "dbg");
sprintf(szDest, "%s\\%s\\%s", szSymsDir, szExt, szSourceFile);
sprintf(szSrc, "%s\\symbols\\%s\\%s", szSourceDir, szExt, szSourceFile);
} else {
sprintf(szDest, "%s\\%s", szDestDir, szSourceFile);
sprintf(szSrc, "%s\\%s", szSourceDir, szSourceFile);
}
printf("Source: %s\n", szSrc);
/*
* Backup the original if requested
*/
if (gbSavePrevious) {
PCHAR pch;
strcpy(szBackup, szDest);
// find LAST dot
pch = strrchr(szBackup, '.');
pch++;
strcpy(pch, szSaveExtension);
if (pch) {
bRet = CopyFile(szDest, szBackup, FALSE);
if (!bRet) {
dwRet = GetLastError();
printf("Unable to make backup copy %ld\n", dwRet);
// don't worry about failing to back up DBG files
if (!bDbgFile) {
return FALSE;
}
} else {
printf("Original backed up to %s\n", szBackup);
}
}
}
printf("Destination: %s\n", szDest);
if (gbDelayCopy) {
gbTryCopy = FALSE;
gbTryRename = FALSE;
}
if (gbPoll) {
PollForFile(szSrc, szDest);
gbPoll = FALSE;
}
/*
* Try a regular copy
*/
if (gbTryCopy) {
printf("Try Reg copy\n");
TryCopy:
bRet = CopyFile(szSrc, szDest, FALSE);
MyGetFileSize(szSrc);
if (bRet) {
printf("success\n");
return TRUE;
} else {
dwRet = GetLastError();
switch (dwRet) {
case ERROR_FILE_NOT_FOUND:
printf("ERROR: File not found\n");
return FALSE;
case ERROR_ACCESS_DENIED:
case ERROR_SHARING_VIOLATION:
// Need to do delay copy
break;
default:
printf("\nERROR: Copy Failed %ld", dwRet);
return FALSE;
}
}
}
/*
* Try a rename copy
*/
if (gbTryRename) {
printf("Try Rename\n");
bRet = MoveFileEx(szDest, szJUNKEXT, MOVEFILE_REPLACE_EXISTING);
if (bRet) {
gbTryRename = FALSE;
goto TryCopy;
} else {
dwRet = GetLastError();
switch (dwRet) {
case ERROR_FILE_NOT_FOUND:
printf("ERROR: File not found\n");
return FALSE;
case ERROR_ACCESS_DENIED:
case ERROR_SHARING_VIOLATION:
// Need to do delay copy
break;
default:
printf("\nERROR: Rename Failed %ld", dwRet);
return FALSE;
}
}
}
printf("Trying delayed copy\n");
if (_strnicmp(szFileName, "ntoskrnl", 8) == 0) {
printf(" ===================== WARNING =====================\n");
printf(" !Delayed copy of ntoskrnl.exe requires TWO reboots!\n");
printf(" ===================================================\n");
}
if (!gbForceTempCopy) {
/*
* Determine source drive type
*/
if (szSrc[0] == '\\' && szSrc[0] == '\\') {
bNetDrive = TRUE;
} else if (szSrc[1] == ':') {
CHAR szRoot[5];
szRoot[0] = szSrc[0];
szRoot[1] = ':';
szRoot[1] = '\\';
if (GetDriveType(szRoot) == DRIVE_REMOTE)
bNetDrive = TRUE;
}
}
/*
* If the source is a network path then copy it locally to temp file
*/
if (gbForceTempCopy || bNetDrive) {
// if (!GetTempPath(sizeof(szTempPath)/sizeof(szTempPath[0]), szTempPath)) {
// printf("ERROR; GetTempPath Failed %ld\n", GetLastError());
// return FALSE;
// }
if (!GetTempFileName(szDestDir, "upd", 0, szTempFile)) {
printf("ERROR; GetTempFileName Failed %ld\n", GetLastError());
return FALSE;
}
bRet = CopyFile(szSrc, szTempFile, FALSE);
if (!bRet) {
dwRet = GetLastError();
switch (dwRet) {
case ERROR_FILE_NOT_FOUND:
printf("ERROR: File not found\n");
return FALSE;
default:
printf("\nERROR: Copy to temp file failed %ld", dwRet);
return FALSE;
}
}
pszSrc = szTempFile;
printf("Temp File: %s\n", pszSrc);
}
bRet = MoveFileEx(pszSrc, szDest, MV_FLAGS);
if (bRet) {
printf("success; file will be copied after you reboot.\n");
} else {
printf("ERROR: MoveFileEx failed %ld\n", GetLastError());
return FALSE;
}
/*
* Create the Restore.Cmd file if requested.
*/
if (gbRestoreCmd) {
char szBuff[CCH_BUF * 2];
DWORD nb, nbWritten;
if (ghRestoreCmd == NULL) {
sprintf(szBuff, "%s\\%s", szWinDir, szRESTORECMD);
ghRestoreCmd = CreateFile(szBuff, GENERIC_WRITE, 0,
(LPSECURITY_ATTRIBUTES)NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
(HANDLE)NULL);
}
nb = sprintf(szBuff, "del %s\nmv %s %s\n", szDest, szBackup, szDest);
bRet = WriteFile(ghRestoreCmd, szBuff, nb, &nbWritten, NULL);
if (!bRet) {
printf("ERROR: WriteFile failed %ld\n", GetLastError());
}
}
return bRet;
}
BOOL CALLBACK OptionsDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
CHAR szNew[CCH_BUF];
BOOL fRet;
switch (msg) {
case WM_INITDIALOG:
SendDlgItemMessage( hDlg, IDD_DEST, WM_SETTEXT, 0, (LPARAM)szDestDir);
SetDlgItemText( hDlg, IDD_SOURCE, szSourceDir);
SetDlgItemText( hDlg, IDD_SYMS, szSymsDir);
if (gbTryRename)
CheckDlgButton( hDlg, IDD_RENAME, TRUE);
if (gbTryCopy)
CheckDlgButton( hDlg, IDD_REG_COPY, TRUE);
if (gbPoll)
CheckDlgButton( hDlg, IDD_POLL, TRUE);
if (gbReboot)
CheckDlgButton( hDlg, IDD_REBOOT, TRUE);
CheckDlgButton( hDlg, giCopySourceType, TRUE);
SetDlgItemText( hDlg, IDD_SAVEEXTENSION, szSaveExtension);
SetDlgItemText( hDlg, IDD_COPYEXTENSION, szDEFCOPYEXT);
if (gbSavePrevious) {
if (gbRestoreCmd) {
CheckDlgButton( hDlg, IDD_RESTORECMD, TRUE);
}
CheckDlgButton( hDlg, IDD_SAVEPREVIOUS, TRUE);
} else {
EnableWindow( GetDlgItem( hDlg, IDD_SAVEEXTENSION), FALSE);
CheckDlgButton( hDlg, IDD_RESTORECMD, FALSE);
EnableWindow( GetDlgItem( hDlg, IDD_RESTORECMD), FALSE);
gbRestoreCmd = FALSE;
}
if (gbCopyDbgToo) {
CheckDlgButton( hDlg, IDD_DBGTOO, TRUE);
}
SendDlgItemMessage( hDlg, IDD_SAVEEXTENSION, EM_LIMITTEXT, sizeof(szSaveExtension)-1, 0);
SendDlgItemMessage( hDlg, IDD_COPYEXTENSION, EM_LIMITTEXT, sizeof(szCopyExtension)-1, 0);
break;
case WM_COMMAND:
switch(LOWORD(wParam))
{
CHAR szString[8];
case IDOK:
// Write out the new defaults
if (GetDlgItemText(hDlg, IDD_SOURCE, szNew, sizeof(szNew))) {
_strupr(szNew);
WriteProfileString(szGETBIN, szSOURCE, szNew);
}
if (GetDlgItemText(hDlg, IDD_DEST, szNew, sizeof(szNew))) {
_strupr(szNew);
WriteProfileString(szGETBIN, szDEST, szNew);
}
if (GetDlgItemText(hDlg, IDD_SYMS, szNew, sizeof(szNew))) {
_strupr(szNew);
WriteProfileString(szGETBIN, szSYMS, szNew);
}
fRet = IsDlgButtonChecked( hDlg, IDD_RENAME);
WriteProfileString(szGETBIN, szTRYRENAME, fRet ? "1" : "0");
fRet = IsDlgButtonChecked( hDlg, IDD_REG_COPY);
WriteProfileString(szGETBIN, szTRYCOPY, fRet ? "1" : "0");
fRet = IsDlgButtonChecked( hDlg, IDD_POLL);
WriteProfileString(szGETBIN, szPOLL, fRet ? "1" : "0");
fRet = IsDlgButtonChecked( hDlg, IDD_REBOOT);
WriteProfileString(szGETBIN, szREBOOT, fRet ? "1" : "0");
fRet = IsDlgButtonChecked( hDlg, IDD_SAVEPREVIOUS);
WriteProfileString(szGETBIN, szSAVEPREVIOUS, fRet ? "1" : "0");
if (fRet && GetDlgItemText(hDlg, IDD_SAVEEXTENSION, szNew, sizeof(szNew))) {
_strupr(szNew);
WriteProfileString(szGETBIN, szSAVEEXT, szNew);
}
fRet = IsDlgButtonChecked( hDlg, IDD_RESTORECMD);
WriteProfileString(szGETBIN, szRESTORECMD, fRet ? "1" : "0");
fRet = IsDlgButtonChecked( hDlg, IDD_DBGTOO);
WriteProfileString(szGETBIN, szCOPYDBGTOO, fRet ? "1" : "0");
if (IsDlgButtonChecked( hDlg, IDD_COPY_DATE)) {
giCopySourceType = IDD_COPY_DATE;
} else if (IsDlgButtonChecked( hDlg, IDD_COPY_LIST)) {
giCopySourceType = IDD_COPY_LIST;
} else {
giCopySourceType = IDD_COPY_COMMAND;
}
_itoa(giCopySourceType, szString, 10);
WriteProfileString(szGETBIN, szCOPYSOURCETYPE, szString);
// FALL THROUGH!
case IDCANCEL:
EndDialog(hDlg, FALSE);
break;
case IDD_SAVEPREVIOUS:
if (HIWORD(wParam) == BN_CLICKED) {
fRet = IsDlgButtonChecked( hDlg, IDD_SAVEPREVIOUS);
EnableWindow( GetDlgItem( hDlg, IDD_SAVEEXTENSION), fRet);
if (!fRet) {
CheckDlgButton( hDlg, IDD_RESTORECMD, FALSE);
}
EnableWindow( GetDlgItem( hDlg, IDD_RESTORECMD), fRet);
}
break;
default:
return(FALSE);
}
break;
break;
}
return FALSE;
}