INT cmdContinue(INT argc, WCHAR **argv)
{
SC_HANDLE hManager = NULL;
SC_HANDLE hService = NULL;
SERVICE_STATUS status;
INT nError = 0;
INT i;
if (argc != 3)
{
PrintResourceString(IDS_CONTINUE_SYNTAX);
return 1;
}
for (i = 2; i < argc; i++)
{
if (_wcsicmp(argv[i], L"/help") == 0)
{
PrintResourceString(IDS_CONTINUE_HELP);
return 1;
}
}
hManager = OpenSCManager(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_ENUMERATE_SERVICE);
if (hManager == NULL)
{
printf("[OpenSCManager] Error: %ld\n", GetLastError());
nError = 1;
goto done;
}
hService = OpenService(hManager, argv[2], SERVICE_PAUSE_CONTINUE);
if (hService == NULL)
{
printf("[OpenService] Error: %ld\n", GetLastError());
nError = 1;
goto done;
}
if (!ControlService(hService, SERVICE_CONTROL_CONTINUE, &status))
{
printf("[ControlService] Error: %ld\n", GetLastError());
nError = 1;
}
done:
if (hService != NULL)
CloseServiceHandle(hService);
if (hManager != NULL)
CloseServiceHandle(hManager);
return nError;
}
//----------------------------------------------------------------------
//
// FormatExCallback
//
// The file system library will call us back with commands that we
// can interpret. If we wanted to halt the chkdsk we could return FALSE.
//
//----------------------------------------------------------------------
BOOLEAN WINAPI
FormatExCallback(
CALLBACKCOMMAND Command,
ULONG Modifier,
PVOID Argument)
{
PDWORD percent;
PTEXTOUTPUT output;
PBOOLEAN status;
//
// We get other types of commands, but we don't have to pay attention to them
//
switch (Command)
{
case PROGRESS:
percent = (PDWORD)Argument;
PrintResourceString(STRING_COMPLETE, *percent);
break;
case OUTPUT:
output = (PTEXTOUTPUT)Argument;
wprintf(L"%S", output->Output);
break;
case DONE:
status = (PBOOLEAN)Argument;
if (*status == FALSE)
{
PrintResourceString(STRING_FORMAT_FAIL);
Error = TRUE;
}
break;
case DONEWITHSTRUCTURE:
case UNKNOWN2:
case UNKNOWN3:
case UNKNOWN4:
case UNKNOWN5:
case INSUFFICIENTRIGHTS:
case FSNOTSUPPORTED:
case VOLUMEINUSE:
case UNKNOWN9:
case UNKNOWNA:
case UNKNOWNC:
case UNKNOWND:
case STRUCTUREPROGRESS:
case CLUSTERSIZETOOSMALL:
PrintResourceString(STRING_NO_SUPPORT);
return FALSE;
}
return TRUE;
}
INT cmdHelpMsg(INT argc, WCHAR **argv)
{
LPWSTR endptr;
LPWSTR lpBuffer;
LONG errNum;
INT i;
if (argc < 3)
{
PrintResourceString(IDS_HELPMSG_SYNTAX);
return 1;
}
for (i = 2; i < argc; i++)
{
if (_wcsicmp(argv[i], L"/help") == 0)
{
PrintResourceString(IDS_HELPMSG_HELP);
return 1;
}
}
errNum = wcstol(argv[2], &endptr, 10);
if (*endptr != 0)
{
PrintResourceString(IDS_HELPMSG_SYNTAX);
return 1;
}
/* Unicode printing is not supported in ReactOS yet */
if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
errNum,
LANG_USER_DEFAULT,
(LPWSTR)&lpBuffer,
0,
NULL))
{
printf("\n%S\n", lpBuffer);
LocalFree(lpBuffer);
}
else
{
printf("Unrecognized error code: %ld\n", errNum);
}
return 0;
}
/*
* RunScript(const char *filename):
* opens the file, reads the contents, convert the text into readable
* code for the computer, and then execute commands in order.
*/
BOOL
RunScript(LPCWSTR filename)
{
FILE *script;
WCHAR tmp_string[MAX_STRING_SIZE];
/* Open the file for processing */
script = _wfopen(filename, L"r");
if (script == NULL)
{
/* if there was problems opening the file */
PrintResourceString(IDS_ERROR_MSG_NO_SCRIPT, filename);
return FALSE; /* if there is no script, exit the program */
}
/* Read and process the script */
while (fgetws(tmp_string, MAX_STRING_SIZE, script) != NULL)
{
if (InterpretScript(tmp_string) == FALSE)
{
fclose(script);
return FALSE;
}
}
/* Close the file */
fclose(script);
return TRUE;
}
int wmain(int argc, WCHAR* argv[])
{
WCHAR CmdLine[CMDLINE_LENGTH];
/*
* If the user hasn't asked for specific help,
* then print out the list of available commands.
*/
if (argc <= 1)
{
PrintResourceString(IDS_HELP1);
PrintResourceString(IDS_HELP2);
return 0;
}
/*
* Bad usage (too much options) or we use the /? switch.
* Display help for the help command.
*/
if ((argc > 2) || (wcscmp(argv[1], L"/?") == 0))
{
PrintResourceString(IDS_USAGE);
return 0;
}
/*
* If the command is not an internal one,
* display an information message and exit.
*/
if (!IsInternalCommand(argv[1]))
{
PrintResourceString(IDS_NO_ENTRY, argv[1]);
return 0;
}
/*
* Run "<command> /?" in the current command processor.
*/
wcsncpy(CmdLine, argv[1], CMDLINE_LENGTH - wcslen(CmdLine));
wcsncat(CmdLine, L" /?" , CMDLINE_LENGTH - wcslen(CmdLine));
_flushall();
return _wsystem(CmdLine);
}
VOID
ShowHeader(VOID)
{
WCHAR szComputerName[MAX_STRING_SIZE];
DWORD comp_size = MAX_STRING_SIZE;
/* Get the name of the computer for us and change the value of comp_name */
GetComputerNameW(szComputerName, &comp_size);
/* TODO: Remove this section of code when program becomes stable enough for production use. */
wprintf(L"\n*WARNING*: This program is incomplete and may not work properly.\n");
/* Print the header information */
wprintf(L"\n");
PrintResourceString(IDS_APP_HEADER);
wprintf(L"\n");
PrintResourceString(IDS_APP_LICENSE);
PrintResourceString(IDS_APP_CURR_COMPUTER, szComputerName);
}
int wmain(int argc, WCHAR **argv)
{
PCOMMAND cmdptr;
if (argc < 2)
{
PrintResourceString(IDS_NET_SYNTAX);
return 1;
}
/* Scan the command table */
for (cmdptr = cmds; cmdptr->name; cmdptr++)
{
if (_wcsicmp(argv[1], cmdptr->name) == 0)
{
return cmdptr->func(argc, argv);
}
}
PrintResourceString(IDS_NET_SYNTAX);
return 1;
}
/*
* Takes the commandline arguments, and creates a
* struct which matches the arguments supplied.
*/
static DWORD
ParseArguments(struct CommandLineOptions* pOpts, int argc, WCHAR *argv[])
{
int index;
if (!pOpts)
return ERROR_INVALID_PARAMETER;
/* Reset all flags in struct */
pOpts->abort = FALSE;
pOpts->force = FALSE;
pOpts->logoff = FALSE;
pOpts->restart = FALSE;
pOpts->shutdown = FALSE;
pOpts->document_reason = FALSE;
pOpts->hibernate = FALSE;
pOpts->shutdown_delay = 30;
pOpts->remote_system = NULL;
pOpts->reason = ParseReasonCode(NULL); /* NOTE: NEVER use 0 here since it can delay the shutdown. */
pOpts->message = NULL;
pOpts->show_gui = FALSE;
/*
* Determine which flags the user has specified
* to the program so we can use them later.
*/
for (index = 1; index < argc; index++)
{
if (argv[index][0] == L'-' || argv[index][0] == L'/')
{
switch (towlower(argv[index][1]))
{
case L'?': /* Help */
PrintResourceString(IDS_USAGE);
return ERROR_SUCCESS;
case L'a': /* Cancel delayed shutdown */
pOpts->abort = TRUE;
break;
case L'c': /* Comment on reason for shutdown */
if(CheckCommentLength(argv[index+1]))
{
if (index+1 <= argc)
pOpts->message = argv[index+1];
else
return ERROR_INVALID_DATA;
index++;
}
else
{
PrintResourceString(IDS_ERROR_MAX_COMMENT_LENGTH);
return ERROR_BAD_LENGTH;
}
break;
case L'd': /* Reason code [p|u:]xx:yy */
if (index+1 <= argc)
pOpts->reason = ParseReasonCode(argv[index+1]);
else
return ERROR_INVALID_DATA;
index++;
break;
case L'e': /* Documents reason for shutdown */
/* TODO: Determine what this flag does exactly. */
pOpts->document_reason = TRUE;
break;
case L'f': /* Force shutdown without warning */
pOpts->force = TRUE;
break;
case L'h': /* Hibernate the local computer */
pOpts->hibernate = TRUE;
break;
case L'i': /* Shows GUI version of the tool */
pOpts->show_gui = TRUE;
break;
case L'l': /* Logoff the current user */
pOpts->logoff = TRUE;
break;
case L'm': /* Target remote systems (UNC name/IP address) */
pOpts->remote_system = argv[index+1];
break;
case L'p': /* Turn off local computer with no warning/time-out */
pOpts->force = TRUE;
pOpts->shutdown_delay = 0;
break;
case L'r': /* Restart computer */
pOpts->restart = TRUE;
break;
case L's': /* Shutdown */
pOpts->shutdown = TRUE;
break;
case L't': /* Shutdown delay */
pOpts->shutdown_delay = _wtoi(argv[index+1]);
if (pOpts->shutdown_delay > 0)
pOpts->force = TRUE;
break;
default:
/* Unknown arguments will exit the program. */
PrintResourceString(IDS_USAGE);
return ERROR_SUCCESS;
}
}
}
return ERROR_SUCCESS;
}
/* Main entry for program */
int wmain(int argc, WCHAR *argv[])
{
DWORD error = ERROR_SUCCESS;
struct CommandLineOptions opts;
if (argc == 1) /* i.e. no commandline arguments given */
{
PrintResourceString(IDS_USAGE);
return EXIT_SUCCESS;
}
error = ParseArguments(&opts, argc, argv);
if (error != ERROR_SUCCESS)
{
DisplayError(error);
return EXIT_FAILURE;
}
/* If the user wants to abort a shutdown */
if (opts.abort)
{
/* First, the program has to determine if the shutdown/restart is local
or remote. This is done since each one requires separate privileges. */
if (opts.remote_system == NULL)
EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
else
EnablePrivilege(SE_REMOTE_SHUTDOWN_NAME, TRUE);
/* Abort the delayed system shutdown specified. */
if (!AbortSystemShutdownW(opts.remote_system))
{
PrintResourceString(IDS_ERROR_ABORT);
DisplayError(GetLastError());
return EXIT_FAILURE;
}
else
{
return EXIT_SUCCESS;
}
}
/*
* If the user wants to hibernate the computer. Assume
* that the user wants to wake the computer up from
* hibernation and it should not force it on the system.
*/
if (opts.hibernate)
{
if (IsPwrHibernateAllowed())
{
EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
/* The shutdown utility cannot hibernate remote systems */
if (opts.remote_system != NULL)
{
return EXIT_FAILURE;
}
if (!SetSuspendState(TRUE, FALSE, FALSE))
{
PrintResourceString(IDS_ERROR_HIBERNATE);
DisplayError(GetLastError());
return EXIT_FAILURE;
}
else
{
PrintResourceString(IDS_ERROR_HIBERNATE_ENABLED);
return EXIT_SUCCESS;
}
}
else
{
return EXIT_FAILURE;
}
}
/* Both shutdown and restart flags cannot both be true */
if (opts.shutdown && opts.restart)
{
PrintResourceString(IDS_ERROR_SHUTDOWN_REBOOT);
return EXIT_FAILURE;
}
/* Ensure that the timout amount is not too high or a negative number */
if ((opts.shutdown_delay < 0) || (opts.shutdown_delay > MAX_TIMEOUT))
{
PrintResourceString(IDS_ERROR_TIMEOUT, opts.shutdown_delay);
return EXIT_FAILURE;
}
/* If the user wants a GUI environment */
if (opts.show_gui)
{
if (ShutdownGuiMain(opts))
return EXIT_SUCCESS;
else
return EXIT_FAILURE;
}
if (opts.logoff && (opts.remote_system == NULL))
{
/*
* NOTE: Sometimes, shutdown and logoff are used together. If the logoff
* flag is used by itself, then simply logoff. But if used with shutdown,
* then skip logging off of the computer and eventually go to the action
* for shutdown.
*/
if (!opts.shutdown && !opts.restart)
{
EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
if (ExitWindowsEx(EWX_LOGOFF, opts.reason))
{
return EXIT_SUCCESS;
}
else
{
PrintResourceString(IDS_ERROR_LOGOFF);
DisplayError(GetLastError());
return EXIT_FAILURE;
}
}
}
/*
* Since both shutting down the system and restarting calls the exact same
* function, all we need to know is if we wanted to restart or shutdown.
*/
if (opts.shutdown || opts.restart)
{
/*
* First, the program has to determine if the shutdown/restart is local
* or remote. This is done since each one requires separate privileges.
*/
if (opts.remote_system == NULL)
{
EnablePrivilege(SE_SHUTDOWN_NAME, TRUE);
}
else
{
/* TODO: Remote shutdown is not supported yet */
// EnablePrivilege(SE_REMOTE_SHUTDOWN_NAME, TRUE);
return EXIT_SUCCESS;
}
/**
** HACK: When InitiateSystemShutdownExW will become really implemented,
** activate this line and delete the other...
**
if(!InitiateSystemShutdownExW(opts.remote_system,
opts.message,
opts.shutdown_delay,
opts.force,
opts.restart,
opts.reason))
***/
if (!ExitWindowsEx((opts.shutdown ? EWX_SHUTDOWN : EWX_REBOOT) |
(opts.force ? EWX_FORCE : 0),
opts.reason))
{
/*
* If there is an error, give the proper output depending
* on whether the user wanted to shutdown or restart.
*/
if (opts.restart)
PrintResourceString(IDS_ERROR_RESTART);
else
PrintResourceString(IDS_ERROR_SHUTDOWN);
DisplayError(GetLastError());
return EXIT_FAILURE;
}
else
{
return EXIT_SUCCESS;
}
}
return EXIT_SUCCESS;
}
/**
* @name: main
* standard main functionality as required by C/C++ for application startup
*
* @return
* error /success value
*/
int wmain( int argc, wchar_t *argv[])
{
DWORD dwSerial = 0;
wchar_t t = 0;
wchar_t *strPath = NULL;
DWORD sz = 0;
//wchar_t *context = NULL;
wchar_t *driveLetter = NULL;
int i;
/* parse the command line */
for (i = 1; i < argc; ++i)
{
if (argv[i][0] == L'-' || argv[i][0] == L'/')
{
switch (towlower(argv[i][1]))
{
case L'?':
/* will print help and exit after */
PrintResourceString(IDS_USAGE);
return 0;
case L'f':
/* if set to true, will populate all the files within the folder structure */
bShowFiles = TRUE;
break;
case L'a':
bUseAscii = TRUE;
break;
default:
break;
}
}
else
{
/* this must be path to some folder */
/* will set the current directory for this executable */
BOOL b = SetCurrentDirectoryW(argv[i]);
if (b == FALSE)
{
PrintResourceString(IDS_NO_SUBDIRECTORIES);
return 1;
}
}
}
PrintResourceString(IDS_FOLDER_PATH);
GetVolumeInformation(NULL, NULL, 0, &dwSerial, NULL, NULL, NULL, 0);
PrintResourceString(IDS_VOL_SERIAL, dwSerial >> 16, dwSerial & 0xffff);
/* get the buffer size */
sz = GetCurrentDirectory(1, &t);
/* must not return before calling delete[] */
strPath = (wchar_t*)malloc(sizeof(wchar_t) * sz);
/* get the current directory */
GetCurrentDirectory(sz, strPath);
/* get the drive letter , must not return before calling delete[] */
driveLetter = (wchar_t*)malloc(sizeof(wchar_t) * sz);
/* As we do not seem to have the _s functions properly set up, use the non-secure version for now */
//wcscpy_s(driveLetter,sz,strPath);
//wcstok_s(driveLetter,L":", &context); //parse for the drive letter
wcscpy(driveLetter, strPath);
wcstok(driveLetter, L":");
wprintf(L"%s:.\n", driveLetter);
free(driveLetter);
/* get the sub directories within this current folder */
GetDirectoryStructure(strPath, 1, L" ");
free(strPath);
wprintf(L"\n");
return 0;
}
//----------------------------------------------------------------------
//
// WMain
//
// Engine. Just get command line switches and fire off a format. This
// could also be done in a GUI like Explorer does when you select a
// drive and run a check on it.
//
// We do this in UNICODE because the chkdsk command expects PWCHAR
// arguments.
//
//----------------------------------------------------------------------
int wmain(int argc, WCHAR *argv[])
{
int badArg;
DWORD media = FMIFS_HARDDISK;
DWORD driveType;
WCHAR fileSystem[1024];
WCHAR volumeName[1024];
WCHAR input[1024];
DWORD serialNumber;
DWORD flags, maxComponent;
ULARGE_INTEGER freeBytesAvailableToCaller, totalNumberOfBytes, totalNumberOfFreeBytes;
WCHAR szMsg[RC_STRING_MAX_SIZE];
wprintf(L"\n"
L"Formatx v1.0 by Mark Russinovich\n"
L"Systems Internals - http://www.sysinternals.com\n"
L"ReactOS adaptation 1999 by Emanuele Aliberti\n\n");
#ifndef FMIFS_IMPORT_DLL
//
// Get function pointers
//
if (!LoadFMIFSEntryPoints())
{
PrintResourceString(STRING_FMIFS_FAIL);
return -1;
}
#endif
//
// Parse command line
//
badArg = ParseCommandLine(argc, argv);
if (badArg)
{
PrintResourceString(STRING_UNKNOW_ARG, argv[badArg]);
Usage(argv[0]);
return -1;
}
//
// Get the drive's format
//
if (!Drive)
{
PrintResourceString(STRING_DRIVE_PARM);
Usage(argv[0]);
return -1;
}
else
{
wcscpy(RootDirectory, Drive);
}
RootDirectory[2] = L'\\';
RootDirectory[3] = L'\0';
//
// See if the drive is removable or not
//
driveType = GetDriveTypeW(RootDirectory);
switch (driveType)
{
case DRIVE_UNKNOWN :
LoadStringW(GetModuleHandle(NULL), STRING_ERROR_DRIVE_TYPE, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
case DRIVE_REMOTE:
case DRIVE_CDROM:
PrintResourceString(STRING_NO_SUPPORT);
return -1;
case DRIVE_NO_ROOT_DIR:
LoadStringW(GetModuleHandle(NULL), STRING_NO_VOLUME, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
case DRIVE_REMOVABLE:
PrintResourceString(STRING_INSERT_DISK, RootDirectory[0]);
fgetws(input, ARRAYSIZE(input), stdin);
media = FMIFS_FLOPPY;
break;
case DRIVE_FIXED:
case DRIVE_RAMDISK:
media = FMIFS_HARDDISK;
break;
}
// Reject attempts to format the system drive
{
WCHAR path[MAX_PATH + 1];
UINT rc;
rc = GetWindowsDirectoryW(path, MAX_PATH);
if (rc == 0 || rc > MAX_PATH)
// todo: Report "Unable to query system directory"
return -1;
if (towlower(path[0]) == towlower(Drive[0]))
{
// todo: report "Cannot format system drive"
PrintResourceString(STRING_NO_SUPPORT);
return -1;
}
}
//
// Determine the drive's file system format
//
if (!GetVolumeInformationW(RootDirectory,
volumeName, ARRAYSIZE(volumeName),
&serialNumber, &maxComponent, &flags,
fileSystem, ARRAYSIZE(fileSystem)))
{
LoadStringW(GetModuleHandle(NULL), STRING_NO_VOLUME, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
}
if (!GetDiskFreeSpaceExW(RootDirectory,
&freeBytesAvailableToCaller,
&totalNumberOfBytes,
&totalNumberOfFreeBytes))
{
LoadStringW(GetModuleHandle(NULL), STRING_NO_VOLUME_SIZE, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
}
PrintResourceString(STRING_FILESYSTEM, fileSystem);
//
// Make sure they want to do this
//
if (driveType == DRIVE_FIXED)
{
if (volumeName[0])
{
while (TRUE)
{
PrintResourceString(STRING_LABEL_NAME_EDIT, RootDirectory[0]);
fgetws(input, ARRAYSIZE(input), stdin);
input[wcslen(input) - 1] = 0;
if (!wcsicmp(input, volumeName))
break;
PrintResourceString(STRING_ERROR_LABEL);
}
}
PrintResourceString(STRING_YN_FORMAT, RootDirectory[0]);
LoadStringW(GetModuleHandle(NULL), STRING_YES_NO_FAQ, szMsg, ARRAYSIZE(szMsg));
while (TRUE)
{
fgetws(input, ARRAYSIZE(input), stdin);
if (_wcsnicmp(&input[0], &szMsg[0], 1) == 0) break;
if (_wcsnicmp(&input[0], &szMsg[1], 1) == 0)
{
wprintf(L"\n");
return 0;
}
}
}
//
// Tell the user we're doing a long format if appropriate
//
if (!QuickFormat)
{
LoadStringW(GetModuleHandle(NULL), STRING_VERIFYING, szMsg, ARRAYSIZE(szMsg));
if (totalNumberOfBytes.QuadPart > 1024*1024*10)
{
PrintString(L"%s %luM\n", szMsg, (DWORD)(totalNumberOfBytes.QuadPart/(1024*1024)));
}
else
{
PrintString(L"%s %.1fM\n", szMsg,
((float)(LONGLONG)totalNumberOfBytes.QuadPart)/(float)(1024.0*1024.0));
}
}
else
{
LoadStringW(GetModuleHandle(NULL), STRING_FAST_FMT, szMsg, ARRAYSIZE(szMsg));
if (totalNumberOfBytes.QuadPart > 1024*1024*10)
{
PrintString(L"%s %luM\n", szMsg, (DWORD)(totalNumberOfBytes.QuadPart/(1024*1024)));
}
else
{
PrintString(L"%s %.2fM\n", szMsg,
((float)(LONGLONG)totalNumberOfBytes.QuadPart)/(float)(1024.0*1024.0));
}
PrintResourceString(STRING_CREATE_FSYS);
}
//
// Format away!
//
FormatEx(RootDirectory, media, FileSystem, Label, QuickFormat,
ClusterSize, FormatExCallback);
if (Error) return -1;
PrintResourceString(STRING_FMT_COMPLETE);
//
// Enable compression if desired
//
if (CompressDrive)
{
if (!EnableVolumeCompression(RootDirectory, TRUE))
PrintResourceString(STRING_VOL_COMPRESS);
}
//
// Get the label if we don't have it
//
if (!GotALabel)
{
PrintResourceString(STRING_ENTER_LABEL);
fgetws(input, ARRAYSIZE(LabelString), stdin);
input[wcslen(input) - 1] = 0;
if (!SetVolumeLabelW(RootDirectory, input))
{
LoadStringW(GetModuleHandle(NULL), STRING_NO_LABEL, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
}
}
if (!GetVolumeInformationW(RootDirectory,
volumeName, ARRAYSIZE(volumeName),
&serialNumber, &maxComponent, &flags,
fileSystem, ARRAYSIZE(fileSystem)))
{
LoadStringW(GetModuleHandle(NULL), STRING_NO_VOLUME, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
}
//
// Print out some stuff including the formatted size
//
if (!GetDiskFreeSpaceExW(RootDirectory,
&freeBytesAvailableToCaller,
&totalNumberOfBytes,
&totalNumberOfFreeBytes))
{
LoadStringW(GetModuleHandle(NULL), STRING_NO_VOLUME_SIZE, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
}
PrintResourceString(STRING_FREE_SPACE, totalNumberOfBytes.QuadPart,
totalNumberOfFreeBytes.QuadPart);
//
// Get the drive's serial number
//
if (!GetVolumeInformationW(RootDirectory,
volumeName, ARRAYSIZE(volumeName),
&serialNumber, &maxComponent, &flags,
fileSystem, ARRAYSIZE(fileSystem)))
{
LoadStringW(GetModuleHandle(NULL), STRING_NO_VOLUME, szMsg, ARRAYSIZE(szMsg));
PrintWin32Error(szMsg, GetLastError());
return -1;
}
PrintResourceString(STRING_SERIAL_NUMBER,
(unsigned int)(serialNumber >> 16),
(unsigned int)(serialNumber & 0xFFFF));
return 0;
}
BOOL online_main(INT argc, LPWSTR *argv)
{
PrintResourceString(IDS_HELP_CMD_ONLINE);
return TRUE;
}
/*
* wmain():
* Main entry point of the application.
*/
int wmain(int argc, const LPWSTR argv[])
{
LPCWSTR script = NULL;
LPCWSTR tmpBuffer = NULL;
WCHAR appTitle[50];
int index, timeout;
int result = EXIT_SUCCESS;
/* Sets the title of the program so the user will have an easier time
determining the current program, especially if diskpart is running a
script */
LoadStringW(GetModuleHandle(NULL), IDS_APP_HEADER, (LPWSTR)appTitle, 50);
SetConsoleTitleW(appTitle);
/* Sets the timeout value to 0 just in case the user doesn't
specify a value */
timeout = 0;
CreatePartitionList();
/* If there are no command arguments, then go straight to the interpreter */
if (argc < 2)
{
ShowHeader();
InterpretMain();
}
/* If there are command arguments, then process them */
else
{
for (index = 1; index < argc; index++)
{
/* checks for flags */
if ((argv[index][0] == '/')||
(argv[index][0] == '-'))
{
tmpBuffer = argv[index] + 1;
}
else
{
/* If there is no flag, then return an error */
PrintResourceString(IDS_ERROR_MSG_BAD_ARG, argv[index]);
result = EXIT_FAILURE;
goto done;
}
/* Checks for the /? flag first since the program
exits as soon as the usage list is shown. */
if (_wcsicmp(tmpBuffer, L"?") == 0)
{
PrintResourceString(IDS_APP_USAGE);
result = EXIT_SUCCESS;
goto done;
}
/* Checks for the script flag */
else if (_wcsicmp(tmpBuffer, L"s") == 0)
{
if ((index + 1) < argc)
{
index++;
script = argv[index];
}
}
/* Checks for the timeout flag */
else if (_wcsicmp(tmpBuffer, L"t") == 0)
{
if ((index + 1) < argc)
{
index++;
timeout = _wtoi(argv[index]);
/* If the number is a negative number, then
change it so that the time is executed properly. */
if (timeout < 0)
timeout = 0;
}
}
else
{
/* Assume that the flag doesn't exist. */
PrintResourceString(IDS_ERROR_MSG_BAD_ARG, tmpBuffer);
result = EXIT_FAILURE;
goto done;
}
}
/* Shows the program information */
ShowHeader();
/* Now we process the filename if it exists */
if (script != NULL)
{
/* if the timeout is greater than 0, then assume
that the user specified a specific time. */
if (timeout > 0)
Sleep(timeout * 1000);
if (RunScript(script) == FALSE)
{
result = EXIT_FAILURE;
goto done;
}
}
else
{
/* Exit failure since the user wanted to run a script */
PrintResourceString(IDS_ERROR_MSG_NO_SCRIPT, script);
result = EXIT_FAILURE;
goto done;
}
}
/* Let the user know the program is exiting */
PrintResourceString(IDS_APP_LEAVING);
done:
DestroyPartitionList();
return result;
}