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.
2421 lines
67 KiB
2421 lines
67 KiB
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
cliparse.cpp
|
|
|
|
Abstract:
|
|
|
|
Implements CLI parsing engine
|
|
|
|
Author:
|
|
|
|
Ravisankar Pudipeddi [ravisp] 3-March-2000
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
//
|
|
// Throughout this parse module, we return E_NOINTERFACE
|
|
// to indicate invalid command line syntax/parameters.
|
|
// This is to explicitly distinguish from E_INVALIDARG that may
|
|
// be returned by the CLI dll: we wish to distinguish a syntax error
|
|
// detected by the parser from a syntax error detected by the CLI dll
|
|
// because in the latter case we do not print the usage for the interface.
|
|
// Whereas for errors detected by the parser, we *do* print the usage.
|
|
// This rule needs to be strictly adhered to
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "stdlib.h"
|
|
#include "cliparse.h"
|
|
#include "string.h"
|
|
#include "locale.h"
|
|
#include "winnlsp.h"
|
|
|
|
#pragma warning( disable : 4100 )
|
|
|
|
CComModule _Module;
|
|
CComPtr<IWsbTrace> g_pTrace;
|
|
|
|
#define MAX_ARGS 40
|
|
#define MAX_SWITCHES 20
|
|
//
|
|
// List of all CLI keywords
|
|
// TBD: Sort them!
|
|
//
|
|
RSS_KEYWORD RssInterfaceStrings[] = {
|
|
{L"ADMIN", L"AD", ADMIN_IF},
|
|
{L"VOLUME", L"VL", VOLUME_IF},
|
|
{L"MEDIA", L"MD", MEDIA_IF},
|
|
{L"FILE", L"FL", FILE_IF},
|
|
{L"SHOW", L"SH", SHOW_IF},
|
|
{L"SET", L"ST", SET_IF},
|
|
{L"MANAGE", L"MG", MANAGE_IF},
|
|
{L"UNMANAGE", L"UM", UNMANAGE_IF},
|
|
{L"DELETE", L"DL", DELETE_IF},
|
|
{L"JOB", L"JB", JOB_IF},
|
|
{L"RECALL", L"RC", RECALL_IF},
|
|
{L"SYNCHRONIZE", L"SN", SYNCHRONIZE_IF},
|
|
{L"RECREATEMASTER", L"RM", RECREATEMASTER_IF},
|
|
{L"HELP", L"/?", HELP_IF},
|
|
//
|
|
// Duplicate entry for HELP to recognize -? also as a help
|
|
// interface
|
|
//
|
|
{L"HELP", L"-?", HELP_IF},
|
|
{NULL, NULL, UNKNOWN_IF}
|
|
};
|
|
|
|
//
|
|
// Rss option strings - listed here without the preceding
|
|
// '/' or '-' (or whatever that distinguishes a switch from
|
|
// an argument)
|
|
// TBD: Sort them!
|
|
//
|
|
|
|
RSS_SWITCH_DEFINITION RssSwitchStrings[] = {
|
|
{L"RECALLLIMIT", L"LM", RECALLLIMIT_SW, RSS_ARG_DWORD},
|
|
{L"MEDIACOPIES", L"MC", MEDIACOPIES_SW, RSS_ARG_DWORD},
|
|
{L"SCHEDULE", L"SC", SCHEDULE_SW, RSS_ARG_STRING},
|
|
{L"CONCURRENCY", L"CN", CONCURRENCY_SW, RSS_ARG_DWORD},
|
|
{L"ADMINEXEMPT", L"AE", ADMINEXEMPT_SW, RSS_ARG_DWORD},
|
|
{L"GENERAL", L"GN", GENERAL_SW, RSS_NO_ARG},
|
|
{L"MANAGEABLES", L"MS", MANAGEABLES_SW, RSS_NO_ARG},
|
|
{L"MANAGED", L"MN", MANAGED_SW, RSS_NO_ARG},
|
|
{L"MEDIA", L"MD", MEDIA_SW, RSS_NO_ARG},
|
|
{L"DFS", L"DF", DFS_SW, RSS_ARG_DWORD},
|
|
{L"SIZE", L"SZ", SIZE_SW, RSS_ARG_DWORD},
|
|
{L"ACCESS", L"AC", ACCESS_SW, RSS_ARG_DWORD},
|
|
{L"INCLUDE", L"IN", INCLUDE_SW, RSS_ARG_STRING},
|
|
{L"EXCLUDE", L"EX", EXCLUDE_SW, RSS_ARG_STRING},
|
|
{L"RECURSIVE", L"RC", RECURSIVE_SW, RSS_NO_ARG},
|
|
{L"QUICK", L"QK", QUICK_SW, RSS_NO_ARG},
|
|
{L"FULL", L"FL", FULL_SW, RSS_NO_ARG},
|
|
{L"RULE", L"RL", RULE_SW, RSS_ARG_STRING},
|
|
{L"STATISTICS", L"ST", STATISTICS_SW, RSS_NO_ARG},
|
|
{L"TYPE", L"TY", TYPE_SW, RSS_ARG_STRING},
|
|
{L"RUN", L"RN", RUN_SW, RSS_NO_ARG},
|
|
{L"CANCEL", L"CX", CANCEL_SW, RSS_NO_ARG},
|
|
{L"WAIT", L"WT", WAIT_SW, RSS_NO_ARG},
|
|
{L"COPYSET", L"CS", COPYSET_SW, RSS_ARG_DWORD},
|
|
{L"NAME", L"NM", NAME_SW, RSS_ARG_STRING},
|
|
{L"STATUS", L"SS", STATUS_SW, RSS_NO_ARG},
|
|
{L"CAPACITY", L"CP", CAPACITY_SW, RSS_NO_ARG},
|
|
{L"FREESPACE", L"FS", FREESPACE_SW, RSS_NO_ARG},
|
|
{L"VERSION", L"VR", VERSION_SW, RSS_NO_ARG},
|
|
{L"COPIES", L"CP", COPIES_SW, RSS_NO_ARG},
|
|
{L"HELP", L"?", HELP_SW, RSS_NO_ARG},
|
|
{NULL, NULL, UNKNOWN_SW, RSS_NO_ARG}
|
|
};
|
|
|
|
RSS_JOB_DEFINITION RssJobTypeStrings[] = {
|
|
{L"CREATEFREESPACE", L"F", CreateFreeSpace},
|
|
{L"COPYFILES", L"C", CopyFiles},
|
|
{L"VALIDATE", L"V", Validate},
|
|
{NULL, NULL, InvalidJobType}
|
|
};
|
|
|
|
//
|
|
// Global arrays of arguments and switches
|
|
// These will be used as 'known' entities by all
|
|
// the interface implementations instead of passing
|
|
// them around as parameters
|
|
//
|
|
LPWSTR Args[MAX_ARGS];
|
|
RSS_SWITCHES Switches[MAX_SWITCHES];
|
|
DWORD NumberOfArguments = 0;
|
|
DWORD NumberOfSwitches = 0;
|
|
|
|
//
|
|
// Useful macros
|
|
//
|
|
|
|
#define CLIP_ARGS_REQUIRED() { \
|
|
if (NumberOfArguments <= 0) { \
|
|
WsbThrow(E_NOINTERFACE); \
|
|
} \
|
|
}
|
|
|
|
#define CLIP_ARGS_NOT_REQUIRED() { \
|
|
if (NumberOfArguments > 0) { \
|
|
WsbThrow(E_NOINTERFACE); \
|
|
} \
|
|
}
|
|
|
|
#define CLIP_SWITCHES_REQUIRED() { \
|
|
if (NumberOfSwitches <= 0) { \
|
|
WsbThrow(E_NOINTERFACE); \
|
|
} \
|
|
}
|
|
|
|
#define CLIP_SWITCHES_NOT_REQUIRED() { \
|
|
if (NumberOfSwitches > 0) { \
|
|
WsbThrow(E_NOINTERFACE); \
|
|
} \
|
|
}
|
|
|
|
#define CLIP_TRANSLATE_HR_AND_RETURN(__HR) { \
|
|
if (__HR == S_OK) { \
|
|
return CLIP_ERROR_SUCCESS; \
|
|
} else if ((__HR == E_NOINTERFACE) || \
|
|
(__HR == E_INVALIDARG)) { \
|
|
return CLIP_ERROR_INVALID_PARAMETER; \
|
|
} else if (__HR == E_OUTOFMEMORY) { \
|
|
return CLIP_ERROR_INSUFFICIENT_MEMORY; \
|
|
} else { \
|
|
return CLIP_ERROR_UNKNOWN; \
|
|
} \
|
|
}
|
|
|
|
#define CLIP_GET_DWORD_ARG(__VAL, __STRING, __STOPSTRING) { \
|
|
__VAL = wcstol(__STRING, &(__STOPSTRING), 10); \
|
|
if (*(__STOPSTRING) != L'\0') { \
|
|
WsbThrow(E_NOINTERFACE); \
|
|
} \
|
|
}
|
|
|
|
#define CLIP_VALIDATE_DUPLICATE_DWORD_ARG(__ARG) { \
|
|
if ((__ARG) != INVALID_DWORD_ARG) { \
|
|
WsbThrow(E_NOINTERFACE); \
|
|
} \
|
|
}
|
|
|
|
#define CLIP_VALIDATE_DUPLICATE_POINTER_ARG(__ARG) { \
|
|
if ((__ARG) != INVALID_POINTER_ARG) { \
|
|
WsbThrow(E_NOINTERFACE); \
|
|
} \
|
|
}
|
|
|
|
//
|
|
// Local function prototypes
|
|
//
|
|
|
|
RSS_INTERFACE
|
|
ClipGetInterface(
|
|
IN LPWSTR InterfaceString
|
|
);
|
|
|
|
DWORD
|
|
ClipGetSwitchTypeIndex(
|
|
IN LPWSTR SwitchString
|
|
);
|
|
|
|
HSM_JOB_TYPE
|
|
ClipGetJobType(
|
|
IN LPWSTR JobTypeString
|
|
);
|
|
|
|
HRESULT
|
|
ClipCompileSwitchesAndArgs(
|
|
IN LPWSTR CommandLine,
|
|
IN RSS_INTERFACE Interface,
|
|
IN RSS_INTERFACE SubInterface
|
|
);
|
|
|
|
VOID
|
|
ClipCleanup(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipAdminShow(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipAdminSet(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipVolumeShow(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipVolumeUnmanage(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipVolumeSetManage(
|
|
IN BOOL Set
|
|
);
|
|
|
|
HRESULT
|
|
ClipVolumeDelete(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipVolumeJob(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipMediaShow(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipMediaSynchronize(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipMediaRecreateMaster(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipMediaDelete(
|
|
VOID
|
|
);
|
|
|
|
HRESULT
|
|
ClipFileRecall(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
ClipHelp(
|
|
IN RSS_INTERFACE Interface,
|
|
IN RSS_INTERFACE SubInterface
|
|
);
|
|
|
|
HRESULT
|
|
ClipParseTime(
|
|
IN LPWSTR TimeString,
|
|
OUT PSYSTEMTIME ScheduledTime
|
|
);
|
|
|
|
HRESULT
|
|
ClipParseSchedule(
|
|
IN LPWSTR ScheduleString,
|
|
OUT PHSM_JOB_SCHEDULE Schedule
|
|
);
|
|
BOOL
|
|
ClipInitializeTrace(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
ClipUninitializeTrace(
|
|
VOID
|
|
);
|
|
|
|
|
|
VOID
|
|
ClipHandleErrors(
|
|
IN HRESULT RetCode,
|
|
IN RSS_INTERFACE Interface,
|
|
IN RSS_INTERFACE SubInterface
|
|
);
|
|
//
|
|
// Function bodies start here
|
|
//
|
|
|
|
RSS_INTERFACE
|
|
ClipGetInterface(
|
|
IN LPWSTR InterfaceString
|
|
)
|
|
/*++
|
|
Routine Description:
|
|
|
|
Maps the interface string that is supplied to an enum
|
|
|
|
Arguments
|
|
|
|
InterfaceString - Pointer to the interface string
|
|
TBD: implement a binary search
|
|
|
|
Return Value
|
|
|
|
UNKNOWN_IF - if the interface string is not recognized
|
|
An RSS_INTERFACE value if it is.
|
|
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
RSS_INTERFACE ret = UNKNOWN_IF;
|
|
|
|
WsbTraceIn(OLESTR("ClipHandleErrors"), OLESTR(""));
|
|
|
|
for (i=0 ; TRUE ; i++) {
|
|
if (RssInterfaceStrings[i].Long == NULL) {
|
|
//
|
|
// Reached end of table.
|
|
//
|
|
break;
|
|
|
|
} else if ((_wcsicmp(RssInterfaceStrings[i].Short,
|
|
InterfaceString) == 0) ||
|
|
(_wcsicmp(RssInterfaceStrings[i].Long,
|
|
InterfaceString) == 0)) {
|
|
ret = RssInterfaceStrings[i].Interface;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("ClipGetInterface"), OLESTR("Interface = <%ls>"), WsbLongAsString((LONG) ret));
|
|
return ret;
|
|
}
|
|
|
|
|
|
DWORD
|
|
ClipGetSwitchTypeIndex(
|
|
IN LPWSTR SwitchString
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Maps the Switch to an entry in the global list of switches
|
|
and returns the index
|
|
|
|
Arguments
|
|
|
|
SwitchString - Pointer to switch string
|
|
TBD: implement a binary search
|
|
|
|
Return Value
|
|
|
|
-1 - If the switch is not recognized
|
|
A positive value (index to the entry) if it is
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
|
|
WsbTraceIn(OLESTR("ClipGetSwitchTypeIndex"), OLESTR(""));
|
|
|
|
for (i = 0; TRUE; i++) {
|
|
if (RssSwitchStrings[i].Long == NULL) {
|
|
//
|
|
// Reached end of table.
|
|
//
|
|
i = -1;
|
|
break;
|
|
} else if ((_wcsicmp(RssSwitchStrings[i].Short,
|
|
SwitchString) == 0) ||
|
|
(_wcsicmp(RssSwitchStrings[i].Long,
|
|
SwitchString) == 0)) {
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("ClipGetSwitchTypeIndex"), OLESTR("index = <%ls>"), WsbLongAsString((LONG) i));
|
|
return i;
|
|
}
|
|
|
|
|
|
HSM_JOB_TYPE
|
|
ClipGetJobType(
|
|
IN LPWSTR JobTypeString
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Maps the job string to an enum
|
|
|
|
Arguments
|
|
|
|
JobTypeString - Pointer to JobType string
|
|
TBD: implement a binary search
|
|
|
|
Return Value
|
|
|
|
InvalidJobType - If the job type is not recognized
|
|
HSM_JOB_TYPE value if it is
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HSM_JOB_TYPE jobType = InvalidJobType;
|
|
|
|
WsbTraceIn(OLESTR("ClipGetJobType"), OLESTR(""));
|
|
|
|
for (i = 0; TRUE; i++) {
|
|
if (RssJobTypeStrings[i].Long == NULL) {
|
|
//
|
|
// Reached end of table.
|
|
//
|
|
break;
|
|
}
|
|
if ((_wcsicmp(RssJobTypeStrings[i].Short,
|
|
JobTypeString) == 0) ||
|
|
(_wcsicmp(RssJobTypeStrings[i].Long,
|
|
JobTypeString) == 0)) {
|
|
jobType = RssJobTypeStrings[i].JobType;
|
|
break;
|
|
}
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("ClipGetJobType"), OLESTR("JobType = <%ls>"), WsbLongAsString((LONG) jobType));
|
|
|
|
return jobType;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipCompileSwitchesAndArgs(
|
|
IN LPWSTR CommandLine,
|
|
IN RSS_INTERFACE Interface,
|
|
IN RSS_INTERFACE SubInterface
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Parses the passed in string and compiles all switches
|
|
(a switch is identified by an appropriate delimiter preceding
|
|
it, such as a '/') into a global switches array (along with
|
|
the arguments to the switch) and the rest of the parameters
|
|
into an Args array
|
|
|
|
Arguments
|
|
|
|
CommandLine - String to be parsed
|
|
|
|
Return Value
|
|
|
|
S_OK if success
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
WCHAR token[MAX_PATH+1];
|
|
LPWSTR p = CommandLine, pToken = token, switchArg = NULL, switchString = NULL;
|
|
int cToken = 0;
|
|
RSS_SWITCH_TYPE switchType;
|
|
DWORD index;
|
|
BOOL isSwitch, skipSpace;
|
|
|
|
WsbTraceIn(OLESTR("ClipCompileSwitchesAndArgs"), OLESTR(""));
|
|
|
|
try {
|
|
if (p == NULL) {
|
|
WsbThrow(S_OK);
|
|
}
|
|
|
|
while (*p != L'\0') {
|
|
|
|
if (wcschr(SEPARATORS, *p) != NULL) {
|
|
//
|
|
// Skip white space
|
|
//
|
|
p++;
|
|
continue;
|
|
}
|
|
if (wcschr(SWITCH_DELIMITERS, *p) != NULL) {
|
|
isSwitch = TRUE;
|
|
p++;
|
|
if (*p == L'\0') {
|
|
//
|
|
// Badly formed - a SWITCH_DELIMITER with no switch
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
} else {
|
|
isSwitch = FALSE;
|
|
}
|
|
//
|
|
// Get the rest of the word
|
|
//
|
|
skipSpace = FALSE;
|
|
while (*p != L'\0' && *p != L'\n') {
|
|
//
|
|
// We wish to consider stuff enclosed entirely in
|
|
// quotes as a single token. As a result
|
|
// we won't consider white space to be a delimiter
|
|
// for tokens when they are in quotes.
|
|
//
|
|
if (*p == QUOTE) {
|
|
if (skipSpace) {
|
|
//
|
|
// A quote was encountered previously.
|
|
// This signifies - hence - the end of the token
|
|
//
|
|
p++;
|
|
break;
|
|
} else {
|
|
//
|
|
// Start of quoted string..don't treat whitespace
|
|
// as a delimiter anymore, only a quote will end the token
|
|
//
|
|
skipSpace = TRUE;
|
|
p++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (!skipSpace && (wcschr(SEPARATORS, *p) != NULL)) {
|
|
//
|
|
// This is not quoted and white space was encountered..
|
|
//
|
|
break;
|
|
}
|
|
cToken++;
|
|
if (cToken > MAX_PATH) {
|
|
// Token is too large
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
*pToken++ = *p++;
|
|
}
|
|
|
|
*pToken = L'\0';
|
|
|
|
if (isSwitch) {
|
|
//
|
|
// For a switch, we will have to further split it into
|
|
// the switch part and the argument part
|
|
//
|
|
switchString = wcstok(token, SWITCH_ARG_DELIMITERS);
|
|
|
|
index = ClipGetSwitchTypeIndex(switchString);
|
|
if (index == -1) {
|
|
//
|
|
// Invalid switch. Get out.
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
switchType = RssSwitchStrings[index].SwitchType;
|
|
|
|
switchArg = wcstok(NULL, L"");
|
|
//
|
|
// Validation - badly formed commandline if either:
|
|
// 1. An argument was supplied and the switch definition indicated
|
|
// no argument was required
|
|
// OR
|
|
// 2. This is a non-SHOW interface (by default show interface
|
|
// don't require arguments for options), and an argument was not
|
|
// supplied even though the switch definition indicated one is
|
|
// required.
|
|
//
|
|
// 3. This is a SHOW interface and an argument was supplied
|
|
//
|
|
if ( ((switchArg != NULL) &&
|
|
(RssSwitchStrings[index].ArgRequired == RSS_NO_ARG)) ||
|
|
|
|
((SubInterface != SHOW_IF) && (switchArg == NULL) &&
|
|
(RssSwitchStrings[index].ArgRequired != RSS_NO_ARG)) ||
|
|
((SubInterface == SHOW_IF) && (switchArg != NULL))) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
|
|
Switches[NumberOfSwitches].SwitchType = switchType;
|
|
|
|
if (switchArg != NULL) {
|
|
Switches[NumberOfSwitches].Arg = new WCHAR [wcslen(switchArg)+1];
|
|
|
|
if (Switches[NumberOfSwitches].Arg == NULL) {
|
|
WsbThrow(E_OUTOFMEMORY);
|
|
}
|
|
|
|
wcscpy(Switches[NumberOfSwitches].Arg, switchArg);
|
|
|
|
} else {
|
|
//
|
|
// No arg for this switch
|
|
//
|
|
Switches[NumberOfSwitches].Arg = NULL;
|
|
}
|
|
|
|
NumberOfSwitches++;
|
|
} else {
|
|
//
|
|
// This is an argument..
|
|
//
|
|
Args[NumberOfArguments] = new WCHAR [wcslen(token)+1];
|
|
|
|
if (Args[NumberOfArguments] == NULL) {
|
|
WsbThrow(E_OUTOFMEMORY);
|
|
}
|
|
|
|
wcscpy(Args[NumberOfArguments],
|
|
token);
|
|
NumberOfArguments++;
|
|
}
|
|
pToken = token;
|
|
cToken = 0;
|
|
}
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipCompileSwitchesAndArgs"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
VOID
|
|
ClipCleanup(VOID)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Performs global cleanup for CLI parse module.
|
|
Mainly - frees up all allocated arguments and switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
None
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
|
|
WsbTraceIn(OLESTR("ClipCleanup"), OLESTR(""));
|
|
|
|
for (i = 0; i < NumberOfArguments; i++) {
|
|
delete [] Args[i];
|
|
}
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
if (Switches[i].Arg != NULL) {
|
|
delete [] Switches[i].Arg;
|
|
}
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("ClipCleanup"), OLESTR(""));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipAdminShow(VOID)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Implements RSS ADMIN SHOW interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if args/switches are bad
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
BOOL recallLimit = FALSE;
|
|
BOOL adminExempt = FALSE;
|
|
BOOL mediaCopies = FALSE;
|
|
BOOL concurrency = FALSE;
|
|
BOOL schedule = FALSE;
|
|
BOOL general = FALSE;
|
|
BOOL manageables = FALSE;
|
|
BOOL managed = FALSE;
|
|
BOOL media = FALSE;
|
|
|
|
|
|
WsbTraceIn(OLESTR("ClipAdminShow"), OLESTR(""));
|
|
try {
|
|
//
|
|
// No arguments needed for this interface
|
|
//
|
|
CLIP_ARGS_NOT_REQUIRED();
|
|
|
|
if (NumberOfSwitches) {
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case RECALLLIMIT_SW: {
|
|
recallLimit = TRUE;
|
|
break;
|
|
}
|
|
case ADMINEXEMPT_SW: {
|
|
adminExempt = TRUE;
|
|
break;
|
|
}
|
|
case MEDIACOPIES_SW: {
|
|
mediaCopies = TRUE;
|
|
break;
|
|
}
|
|
case CONCURRENCY_SW: {
|
|
concurrency = TRUE;
|
|
break;
|
|
}
|
|
case SCHEDULE_SW: {
|
|
schedule = TRUE;
|
|
break;
|
|
}
|
|
case GENERAL_SW: {
|
|
general = TRUE;
|
|
break;
|
|
}
|
|
case MANAGEABLES_SW: {
|
|
manageables = TRUE;
|
|
break;
|
|
}
|
|
case MANAGED_SW: {
|
|
managed = TRUE;
|
|
break;
|
|
}
|
|
case MEDIA_SW: {
|
|
media = TRUE;
|
|
break;
|
|
}
|
|
default: {
|
|
// Unknown switch - get out
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
hr = AdminShow(recallLimit,
|
|
adminExempt,
|
|
mediaCopies,
|
|
concurrency,
|
|
schedule,
|
|
general,
|
|
manageables,
|
|
managed,
|
|
media);
|
|
|
|
} else {
|
|
hr = AdminShow(TRUE,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE);
|
|
}
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipAdminShow"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipAdminSet(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS ADMIN SET interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
LPWSTR stopString = NULL;
|
|
DWORD recallLimit = INVALID_DWORD_ARG;
|
|
DWORD adminExempt = INVALID_DWORD_ARG;
|
|
DWORD mediaCopies = INVALID_DWORD_ARG;
|
|
DWORD concurrency = INVALID_DWORD_ARG;
|
|
PHSM_JOB_SCHEDULE schedule = INVALID_POINTER_ARG;
|
|
HSM_JOB_SCHEDULE schedAllocated;
|
|
|
|
WsbTraceIn(OLESTR("ClipAdminSet"), OLESTR(""));
|
|
try {
|
|
//
|
|
// No arguments needed for this interface
|
|
//
|
|
CLIP_ARGS_NOT_REQUIRED();
|
|
|
|
if (NumberOfSwitches) {
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case RECALLLIMIT_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(recallLimit);
|
|
CLIP_GET_DWORD_ARG(recallLimit,
|
|
Switches[i].Arg,
|
|
stopString);
|
|
break;
|
|
}
|
|
|
|
case ADMINEXEMPT_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(adminExempt);
|
|
CLIP_GET_DWORD_ARG(adminExempt,
|
|
Switches[i].Arg,
|
|
stopString);
|
|
break;
|
|
}
|
|
|
|
case MEDIACOPIES_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(mediaCopies);
|
|
CLIP_GET_DWORD_ARG(mediaCopies,
|
|
Switches[i].Arg,
|
|
stopString);
|
|
break;
|
|
}
|
|
|
|
case CONCURRENCY_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(concurrency);
|
|
CLIP_GET_DWORD_ARG(concurrency,
|
|
Switches[i].Arg,
|
|
stopString);
|
|
break;
|
|
}
|
|
|
|
case SCHEDULE_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_POINTER_ARG(schedule);
|
|
hr = ClipParseSchedule(Switches[i].Arg,
|
|
&schedAllocated);
|
|
if (!SUCCEEDED(hr)) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
} else {
|
|
//
|
|
// schedAllocated has the schedule
|
|
//
|
|
schedule = &schedAllocated;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
// Unknown switch - get out
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
hr = AdminSet(recallLimit,
|
|
adminExempt,
|
|
mediaCopies,
|
|
concurrency,
|
|
schedule);
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipAdminSet"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
ClipVolumeShow(VOID)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Implements RSS VOLUME SHOW interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
LPWSTR stopString = NULL;
|
|
BOOL dfs = FALSE;
|
|
BOOL size = FALSE;
|
|
BOOL access = FALSE;
|
|
BOOL rules = FALSE;
|
|
BOOL statistics = FALSE;
|
|
|
|
WsbTraceIn(OLESTR("ClipVolumeShow"), OLESTR(""));
|
|
try {
|
|
//
|
|
// Atleast one arg. required for this interface
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
if (NumberOfSwitches == 0) {
|
|
dfs = size = access = rules = statistics = TRUE;
|
|
} else {
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case DFS_SW: {
|
|
dfs = TRUE;
|
|
break;
|
|
}
|
|
case SIZE_SW: {
|
|
size = TRUE;
|
|
break;
|
|
}
|
|
case ACCESS_SW: {
|
|
access = TRUE;
|
|
break;
|
|
}
|
|
case RULE_SW: {
|
|
rules = TRUE;
|
|
break;
|
|
}
|
|
case STATISTICS_SW: {
|
|
statistics = TRUE;
|
|
break;
|
|
}
|
|
default: {
|
|
//
|
|
// Invalid option
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
hr = VolumeShow(Args,
|
|
NumberOfArguments,
|
|
dfs,
|
|
size,
|
|
access,
|
|
rules,
|
|
statistics);
|
|
}WsbCatch(hr);
|
|
|
|
|
|
WsbTraceOut(OLESTR("ClipVolumeShow"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipVolumeUnmanage(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS VOLUME UNMANAGE interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
|
|
--*/
|
|
{
|
|
DWORD i = 0;
|
|
HRESULT hr;
|
|
|
|
|
|
#define QUICK_UNMANAGE 0
|
|
#define FULL_UNMANAGE 1
|
|
|
|
DWORD fullOrQuick = INVALID_DWORD_ARG;
|
|
|
|
WsbTraceIn(OLESTR("ClipVolumeUnmanage"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// Atleast one arg. required for this interface
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
if (NumberOfSwitches) {
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case FULL_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(fullOrQuick);
|
|
fullOrQuick = FULL_UNMANAGE;
|
|
break;
|
|
}
|
|
case QUICK_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(fullOrQuick);
|
|
fullOrQuick = QUICK_UNMANAGE;
|
|
break;
|
|
}
|
|
default: {
|
|
//
|
|
// Invalid option
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// The default for UNMANAGE is quick. So if fullOrQuick is either
|
|
// QUICK_UNMANAGE or INVALID_DWORD_ARG, we call unmanage of the quick
|
|
// variety
|
|
//
|
|
hr = VolumeUnmanage(Args,
|
|
NumberOfArguments,
|
|
(fullOrQuick == FULL_UNMANAGE)? TRUE : FALSE);
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipVolumeUnmanage"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipVolumeSetManage(IN BOOL Set)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS VOLUME MANAGE & RSS VOLUME SET interfaces.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
CLIP_ERROR_SUCCESS if everything's ok
|
|
CLIP_ERROR_INVALID_PARAMETER if args/switches are bad
|
|
CLIP_ERROR_UNKNOWN any other error
|
|
|
|
--*/
|
|
{
|
|
DWORD i = 0;
|
|
HRESULT hr;
|
|
LPWSTR stopString = NULL;
|
|
DWORD dfs = INVALID_DWORD_ARG;
|
|
DWORD size = INVALID_DWORD_ARG;
|
|
DWORD access = INVALID_DWORD_ARG;
|
|
LPWSTR rulePath = INVALID_POINTER_ARG;
|
|
LPWSTR ruleFileSpec = INVALID_POINTER_ARG;
|
|
BOOL include = FALSE;
|
|
BOOL recursive = FALSE;
|
|
|
|
WsbTraceIn(OLESTR("ClipVolumeSetManage"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// Atleast one arg. required for this interface
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
if (NumberOfSwitches) {
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case DFS_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(dfs);
|
|
CLIP_GET_DWORD_ARG(dfs, Switches[i].Arg, stopString);
|
|
break;
|
|
}
|
|
|
|
case SIZE_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(size);
|
|
CLIP_GET_DWORD_ARG(size, Switches[i].Arg, stopString);
|
|
break;
|
|
}
|
|
|
|
case ACCESS_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(access);
|
|
CLIP_GET_DWORD_ARG(access, Switches[i].Arg, stopString);
|
|
break;
|
|
}
|
|
case INCLUDE_SW: {
|
|
include = TRUE;
|
|
//
|
|
// Deliberately fall down to the EXCLUDE case
|
|
// (break intentionally omitted)
|
|
//
|
|
}
|
|
case EXCLUDE_SW: {
|
|
|
|
CLIP_VALIDATE_DUPLICATE_POINTER_ARG(rulePath);
|
|
|
|
rulePath = wcstok(Switches[i].Arg, RULE_DELIMITERS);
|
|
ruleFileSpec = wcstok(NULL, L"");
|
|
if (ruleFileSpec == NULL) {
|
|
//
|
|
// Omission of this indicates all files
|
|
//
|
|
ruleFileSpec = CLI_ALL_STR;
|
|
}
|
|
break;
|
|
}
|
|
case RECURSIVE_SW: {
|
|
recursive = TRUE;
|
|
break;
|
|
}
|
|
default: {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Validate the rule arguments
|
|
//
|
|
if ((rulePath == INVALID_POINTER_ARG) && recursive) {
|
|
//
|
|
// The recursive flag is valid only if a rule was specified
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
|
|
if (Set) {
|
|
hr = VolumeSet(Args,
|
|
NumberOfArguments,
|
|
dfs,
|
|
size,
|
|
access,
|
|
rulePath,
|
|
ruleFileSpec,
|
|
include,
|
|
recursive);
|
|
} else {
|
|
hr = VolumeManage(Args,
|
|
NumberOfArguments,
|
|
dfs,
|
|
size,
|
|
access,
|
|
rulePath,
|
|
ruleFileSpec,
|
|
include,
|
|
recursive);
|
|
}
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipVolumeSetManage"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipVolumeDelete(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS VOLUME DELETE interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
BOOL rule = FALSE;
|
|
LPWSTR rulePath = INVALID_POINTER_ARG;
|
|
LPWSTR ruleFileSpec = INVALID_POINTER_ARG;
|
|
|
|
WsbTraceIn(OLESTR("ClipVolumeDelete"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// Atleast one arg. required for this interface
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case RULE_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_POINTER_ARG(rulePath);
|
|
rule = TRUE;
|
|
rulePath = wcstok(Switches[i].Arg, RULE_DELIMITERS);
|
|
ruleFileSpec = wcstok(NULL, L"");
|
|
if (ruleFileSpec == NULL) {
|
|
//
|
|
// Omission of this indicates all files
|
|
//
|
|
ruleFileSpec = CLI_ALL_STR;
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
//
|
|
// Invalid option
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Only deleting rules is supported now
|
|
//
|
|
if (rule) {
|
|
hr = VolumeDeleteRule(Args,
|
|
NumberOfArguments,
|
|
rulePath,
|
|
ruleFileSpec);
|
|
} else {
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
}WsbCatch(hr);
|
|
|
|
|
|
WsbTraceOut(OLESTR("ClipVolumeDelete"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipVolumeJob(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS VOLUME JOB interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
HSM_JOB_TYPE jobType = InvalidJobType;
|
|
|
|
#define CANCEL_JOB 0
|
|
#define RUN_JOB 1
|
|
|
|
DWORD runOrCancel = INVALID_DWORD_ARG;
|
|
BOOL synchronous = FALSE;
|
|
|
|
WsbTraceIn(OLESTR("ClipVolumeJob"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// Atleast one arg. required for this interface
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case RUN_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(runOrCancel);
|
|
runOrCancel = RUN_JOB;
|
|
break;
|
|
}
|
|
case CANCEL_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(runOrCancel);
|
|
runOrCancel = CANCEL_JOB;
|
|
break;
|
|
}
|
|
case WAIT_SW: {
|
|
synchronous = TRUE;
|
|
break;
|
|
}
|
|
case TYPE_SW: {
|
|
if (jobType != InvalidJobType) {
|
|
//
|
|
// Duplicate switch. Bail
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
jobType = ClipGetJobType(Switches[i].Arg);
|
|
if (jobType == InvalidJobType) {
|
|
//
|
|
// Invalid job type supplied..
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// More validation:
|
|
// job type should be valid i.e., specified
|
|
//
|
|
if (jobType == InvalidJobType) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
|
|
//
|
|
// Run is the default.. (i.e. TRUE). So if runOrCancel is either
|
|
// INVALID_DWORD_ARG or RUN_JOB, we pass TRUE
|
|
//
|
|
hr = VolumeJob(Args,
|
|
NumberOfArguments,
|
|
jobType,
|
|
(runOrCancel == CANCEL_JOB)? FALSE: TRUE,
|
|
synchronous);
|
|
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipVolumeJob"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipMediaShow(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS MEDIA SHOW interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
BOOL name = FALSE;
|
|
BOOL status = FALSE;
|
|
BOOL capacity = FALSE;
|
|
BOOL freeSpace = FALSE;
|
|
BOOL version = FALSE;
|
|
BOOL copies = FALSE;
|
|
|
|
WsbTraceIn(OLESTR("ClipMediaShow"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// Atleast one arg. required for this interface
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
if (NumberOfSwitches == 0) {
|
|
name = status = capacity = freeSpace = version = copies = TRUE;
|
|
} else {
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case NAME_SW: {
|
|
name = TRUE;
|
|
break;
|
|
}
|
|
case STATUS_SW: {
|
|
status = TRUE;
|
|
break;
|
|
}
|
|
case CAPACITY_SW: {
|
|
capacity = TRUE;
|
|
break;
|
|
}
|
|
case FREESPACE_SW: {
|
|
freeSpace = TRUE;
|
|
break;
|
|
}
|
|
case VERSION_SW: {
|
|
version = TRUE;
|
|
break;
|
|
}
|
|
case COPIES_SW: {
|
|
copies = TRUE;
|
|
break;
|
|
}
|
|
default: {
|
|
//
|
|
// Invalid option
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
hr = MediaShow(Args,
|
|
NumberOfArguments,
|
|
name,
|
|
status,
|
|
capacity,
|
|
freeSpace,
|
|
version,
|
|
copies);
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipMediaShow"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipMediaSynchronize(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS MEDIA SYNCHRONIZE interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
DWORD copySetNumber = INVALID_DWORD_ARG;
|
|
BOOL synchronous = FALSE;
|
|
LPWSTR stopString = NULL;
|
|
|
|
WsbTraceIn(OLESTR("ClipMediaSynchronize"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// No arguments needed
|
|
//
|
|
CLIP_ARGS_NOT_REQUIRED();
|
|
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case COPYSET_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(copySetNumber);
|
|
CLIP_GET_DWORD_ARG(copySetNumber, Switches[i].Arg, stopString);
|
|
break;
|
|
}
|
|
case WAIT_SW: {
|
|
synchronous = TRUE;
|
|
break;
|
|
}
|
|
default: {
|
|
//
|
|
// Invalid option
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Need copy set number..
|
|
//
|
|
if (copySetNumber == INVALID_DWORD_ARG) {
|
|
//
|
|
// None was specified
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
hr = MediaSynchronize(copySetNumber, synchronous);
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipMediaRecreateMaster"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipMediaRecreateMaster(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS MEDIA RECREATEMASTER interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
|
|
--*/
|
|
{
|
|
|
|
DWORD i;
|
|
HRESULT hr;
|
|
DWORD copySetNumber = INVALID_DWORD_ARG;
|
|
LPWSTR stopString = NULL;
|
|
BOOL synchronous = FALSE;
|
|
|
|
WsbTraceIn(OLESTR("ClipMediaRecreateMaster"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
//
|
|
// Atleast one arg required
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
if (NumberOfArguments > 1) {
|
|
//
|
|
// Only one argument supported...
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case COPYSET_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(copySetNumber);
|
|
CLIP_GET_DWORD_ARG(copySetNumber, Switches[i].Arg, stopString);
|
|
break;
|
|
}
|
|
|
|
case WAIT_SW: {
|
|
synchronous = TRUE;
|
|
break;
|
|
}
|
|
|
|
default: {
|
|
//
|
|
// Invalid option
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Need copy set number..
|
|
//
|
|
if (copySetNumber == INVALID_DWORD_ARG) {
|
|
//
|
|
// None was specified
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
|
|
hr = MediaRecreateMaster(Args[0],
|
|
copySetNumber,
|
|
synchronous);
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipRecreateMaster"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipMediaDelete(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS MEDIA DELETE interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
|
|
--*/
|
|
{
|
|
DWORD i;
|
|
HRESULT hr;
|
|
DWORD copySetNumber = INVALID_DWORD_ARG;
|
|
LPWSTR stopString = NULL;
|
|
|
|
WsbTraceIn(OLESTR("ClipMediaDelete"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// Atleast one arg required
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
|
|
for (i = 0; i < NumberOfSwitches; i++) {
|
|
switch (Switches[i].SwitchType) {
|
|
case COPYSET_SW: {
|
|
CLIP_VALIDATE_DUPLICATE_DWORD_ARG(copySetNumber);
|
|
CLIP_GET_DWORD_ARG(copySetNumber, Switches[i].Arg, stopString);
|
|
break;
|
|
}
|
|
default: {
|
|
//
|
|
// Invalid option
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Need copy set number..
|
|
//
|
|
if (copySetNumber == INVALID_DWORD_ARG) {
|
|
//
|
|
// None was specified
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
hr = MediaDelete(Args,
|
|
NumberOfArguments,
|
|
copySetNumber);
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipMediaDelete"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipFileRecall(VOID)
|
|
/*++
|
|
Routine Description
|
|
|
|
Implements RSS FILE RECALL interface.
|
|
Arguments are in global arrays:
|
|
Args - containing list of arguments
|
|
Switches - containing list of switches
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
S_OK if everything's ok
|
|
E_NOINTERFACE if arguments are invalid
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr;
|
|
|
|
WsbTraceIn(OLESTR("ClipFileRecall"), OLESTR(""));
|
|
|
|
try {
|
|
//
|
|
// Atleast one arg. required for this interface
|
|
//
|
|
CLIP_ARGS_REQUIRED();
|
|
//
|
|
// No switches supported
|
|
//
|
|
CLIP_SWITCHES_NOT_REQUIRED();
|
|
|
|
hr = FileRecall(Args,
|
|
NumberOfArguments);
|
|
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipFileRecall"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
VOID
|
|
ClipHelp(
|
|
IN RSS_INTERFACE Interface,
|
|
IN RSS_INTERFACE SubInterface
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Prints appropriate help message depending on the interface
|
|
|
|
Arguments
|
|
|
|
Interface - Specifies interface for which help has to be
|
|
displayed
|
|
SubInterface - Specifies sub-interface for which help has to be
|
|
displayed
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
|
|
#define BREAK_IF_NOT_UNKNOWN_IF(__INTERFACE) { \
|
|
if (((__INTERFACE) != UNKNOWN_IF) && \
|
|
((__INTERFACE) != HELP_IF)) { \
|
|
break; \
|
|
} \
|
|
}
|
|
|
|
|
|
WsbTraceIn(OLESTR("ClipHelp"), OLESTR(""));
|
|
|
|
switch (Interface) {
|
|
|
|
case HELP_IF:
|
|
case UNKNOWN_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MAIN_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
|
|
case ADMIN_IF: {
|
|
switch (SubInterface) {
|
|
case HELP_IF:
|
|
case UNKNOWN_IF:
|
|
case SHOW_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_ADMIN_SHOW_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case SET_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_ADMIN_SET_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
}
|
|
BREAK_IF_NOT_UNKNOWN_IF(Interface);
|
|
}
|
|
case VOLUME_IF: {
|
|
switch (SubInterface) {
|
|
case HELP_IF:
|
|
case UNKNOWN_IF:
|
|
case SHOW_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VOLUME_SHOW_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case SET_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VOLUME_SET_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case MANAGE_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VOLUME_MANAGE_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case UNMANAGE_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VOLUME_UNMANAGE_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case JOB_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VOLUME_JOB_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case DELETE_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_VOLUME_DELETE_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
}
|
|
BREAK_IF_NOT_UNKNOWN_IF(Interface);
|
|
}
|
|
|
|
case MEDIA_IF: {
|
|
switch (SubInterface) {
|
|
case HELP_IF:
|
|
case UNKNOWN_IF:
|
|
case SHOW_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MEDIA_SHOW_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case DELETE_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MEDIA_DELETE_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case SYNCHRONIZE_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MEDIA_SYNCHRONIZE_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
case RECREATEMASTER_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_MEDIA_RECREATEMASTER_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
}
|
|
BREAK_IF_NOT_UNKNOWN_IF(Interface);
|
|
}
|
|
case FILE_IF: {
|
|
switch (SubInterface) {
|
|
case HELP_IF:
|
|
case UNKNOWN_IF:
|
|
case RECALL_IF: {
|
|
WsbTraceAndPrint(CLI_MESSAGE_FILE_RECALL_HELP, NULL);
|
|
BREAK_IF_NOT_UNKNOWN_IF(SubInterface);
|
|
}
|
|
}
|
|
BREAK_IF_NOT_UNKNOWN_IF(Interface);
|
|
}
|
|
}
|
|
WsbTraceOut(OLESTR("ClipHelp"), OLESTR(""));
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipParseTime(
|
|
IN LPWSTR TimeString,
|
|
OUT PSYSTEMTIME ScheduledTime)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
|
|
Parses the passed in TimeString as a 24 hour format
|
|
(hh:mm:ss) and sets hour/minute/sec/millisec in the passed
|
|
in SYSTEMTIME structure
|
|
|
|
Arguments
|
|
|
|
TimeString - String in the format "hh:mm:ss"
|
|
ScheduledTime - Pointer to SYSTEMTIME structure. Time parsed from TimeString
|
|
(if ok) will be used to set hour/min/sec/millisec fields in this struc.
|
|
|
|
|
|
Return Value
|
|
|
|
S_OK - TimeString is valid and time was successfully parsed
|
|
Any other - Syntax error in TimeString
|
|
|
|
|
|
--*/
|
|
{
|
|
LPWSTR stopString = NULL, hourString = NULL, minuteString = NULL, secondString = NULL;
|
|
DWORD hour, minute, second = 0;
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("ClipParseTime"), OLESTR(""));
|
|
|
|
try {
|
|
hourString = wcstok(TimeString, HSM_SCHED_TIME_SEPARATORS);
|
|
WsbAssert(hourString != NULL, E_NOINTERFACE);
|
|
CLIP_GET_DWORD_ARG(hour, hourString, stopString);
|
|
|
|
if (hour > 23) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
|
|
|
|
minuteString = wcstok(NULL, HSM_SCHED_TIME_SEPARATORS);
|
|
WsbAssert(minuteString != NULL, E_NOINTERFACE);
|
|
CLIP_GET_DWORD_ARG(minute, minuteString, stopString);
|
|
|
|
if (minute > 59) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
|
|
secondString = wcstok(NULL, HSM_SCHED_TIME_SEPARATORS);
|
|
if (secondString != NULL) {
|
|
CLIP_GET_DWORD_ARG(second, secondString, stopString);
|
|
if (second > 59) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}
|
|
|
|
ScheduledTime->wHour = (WORD) hour;
|
|
ScheduledTime->wMinute = (WORD) minute;
|
|
ScheduledTime->wSecond = (WORD) second;
|
|
ScheduledTime->wMilliseconds = 0;
|
|
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipParseTime"), OLESTR(""));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
ClipParseSchedule(
|
|
IN LPWSTR ScheduleString,
|
|
OUT PHSM_JOB_SCHEDULE Schedule
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Parses the passed in schedule string, and constructs the canonical schedule
|
|
form (of type HSM_JOB_SCHEDULE)
|
|
|
|
Examples of schedule parameter:
|
|
|
|
"At 21:03:00"
|
|
"At Startup"
|
|
"At Login"
|
|
"At Idle"
|
|
"Every 1 Week 1 21:03:00"
|
|
"Every 2 Day 21:03:00"
|
|
"Every 1 Month 2 21:03:00"
|
|
|
|
Arguments
|
|
|
|
ScheduleString - String specifying the schedule in user-readable syntax
|
|
Schedule - Pointer to canonical schedule form will be returned in this var.
|
|
|
|
Return Value
|
|
|
|
S_OK - Successful, Schedule contains a pointer to the constructed schedule.
|
|
E_OUTOFMEMORY - Lack of sufficient system resources
|
|
Any other error: incorrect schedule specification
|
|
--*/
|
|
{
|
|
LPWSTR token;
|
|
DWORD occurrence;
|
|
HSM_JOB_FREQUENCY frequency;
|
|
SYSTEMTIME scheduledTime;
|
|
DWORD day;
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("ClipParseSchedule"), OLESTR(""));
|
|
|
|
try {
|
|
token = wcstok(ScheduleString, SEPARATORS);
|
|
|
|
WsbAssert(token != NULL, E_NOINTERFACE);
|
|
|
|
if (!_wcsicmp(token, HSM_SCHED_AT)) {
|
|
|
|
token = wcstok(NULL, SEPARATORS);
|
|
|
|
if (token == NULL) {
|
|
//
|
|
// Bad arguments
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
} else if (!_wcsicmp(token, HSM_SCHED_SYSTEMSTARTUP)) {
|
|
//
|
|
// Once at system startup
|
|
//
|
|
Schedule->Frequency = SystemStartup;
|
|
WsbThrow(S_OK);
|
|
} else if (!_wcsicmp(token, HSM_SCHED_LOGIN)) {
|
|
//
|
|
// Once at login time
|
|
//
|
|
Schedule->Frequency = Login;
|
|
WsbThrow(S_OK);
|
|
} else if (!_wcsicmp(token, HSM_SCHED_IDLE)) {
|
|
//
|
|
// Whenever system's idle
|
|
//
|
|
Schedule->Frequency = WhenIdle;
|
|
WsbThrow(S_OK);
|
|
} else {
|
|
|
|
GetSystemTime(&scheduledTime);
|
|
//
|
|
// Once at specified time.
|
|
// Parse the time string and obtain it
|
|
// TBD - Add provision to specify date as well as time
|
|
//
|
|
hr = ClipParseTime(token,
|
|
&scheduledTime);
|
|
WsbAssertHr(hr);
|
|
|
|
Schedule->Frequency = Once;
|
|
Schedule->Parameters.Once.Time = scheduledTime;
|
|
WsbThrow(S_OK);
|
|
}
|
|
} else if (!_wcsicmp(token, HSM_SCHED_EVERY)) {
|
|
LPWSTR stopString = NULL;
|
|
|
|
//
|
|
// Get the occurrence
|
|
//
|
|
token = wcstok(NULL, SEPARATORS);
|
|
WsbAssert(token != NULL, E_NOINTERFACE);
|
|
CLIP_GET_DWORD_ARG(occurrence, token, stopString);
|
|
|
|
//
|
|
// Get the qualifier: Daily/Weekly/Monthly
|
|
//
|
|
token = wcstok(NULL, SEPARATORS);
|
|
WsbAssert(token != NULL, E_NOINTERFACE);
|
|
if (!_wcsicmp(token, HSM_SCHED_DAILY)) {
|
|
frequency = Daily;
|
|
} else if (!_wcsicmp(token, HSM_SCHED_WEEKLY)) {
|
|
frequency = Weekly;
|
|
} else if (!_wcsicmp(token, HSM_SCHED_MONTHLY)) {
|
|
frequency = Monthly;
|
|
} else {
|
|
//
|
|
// Badly constructed argument
|
|
//
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
//
|
|
// Get current time
|
|
//
|
|
GetSystemTime(&scheduledTime);
|
|
//
|
|
// For weekly/monthly we also need to get the day of the week/month
|
|
// Monday = 1, Sunday = 7 for weekly
|
|
//
|
|
if ((frequency == Weekly) || (frequency == Monthly)) {
|
|
token = wcstok(NULL, SEPARATORS);
|
|
WsbAssert(token != NULL, E_NOINTERFACE);
|
|
|
|
CLIP_GET_DWORD_ARG(day, token, stopString);
|
|
|
|
//
|
|
// Validate & update the parameters
|
|
//
|
|
if (frequency == Weekly) {
|
|
if (day > 6) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
scheduledTime.wDayOfWeek = (WORD) day;
|
|
}
|
|
if (frequency == Monthly) {
|
|
if ((day > 31) || (day < 1)) {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
scheduledTime.wDay = (WORD) day;
|
|
}
|
|
}
|
|
//
|
|
// Fetch the time
|
|
//
|
|
token = wcstok(NULL, SEPARATORS);
|
|
WsbAssert(token != NULL, E_NOINTERFACE);
|
|
hr = ClipParseTime(token,
|
|
&scheduledTime);
|
|
|
|
WsbAssertHr(hr);
|
|
|
|
Schedule->Frequency = frequency;
|
|
Schedule->Parameters.Daily.Occurrence = occurrence;
|
|
Schedule->Parameters.Daily.Time = scheduledTime;
|
|
} else {
|
|
WsbThrow(E_NOINTERFACE);
|
|
}
|
|
}WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("ClipParseSchedule"), OLESTR(""));
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ClipInitializeTrace(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Initializes the trace/printing mechanism for CLI
|
|
|
|
Arguments
|
|
|
|
NONE
|
|
|
|
Return Value
|
|
|
|
TRUE if successful, FALSE otherwise
|
|
|
|
--*/
|
|
{
|
|
BOOL ret = TRUE;
|
|
|
|
|
|
if (S_OK == CoCreateInstance(CLSID_CWsbTrace, 0, CLSCTX_SERVER, IID_IWsbTrace, (void **)&g_pTrace)) {
|
|
CWsbStringPtr tracePath;
|
|
CWsbStringPtr regPath;
|
|
CWsbStringPtr outString;
|
|
|
|
// Registry path for CLI settings
|
|
// If those expand beyond Trace settings, this path should go to a header file
|
|
regPath = L"SOFTWARE\\Microsoft\\RemoteStorage\\CLI";
|
|
|
|
// Check if tracing path already exists, if not - set it (this should happen only once)
|
|
WsbAffirmHr(outString.Alloc(WSB_TRACE_BUFF_SIZE));
|
|
if ( WsbGetRegistryValueString(NULL, regPath, L"WsbTraceFileName", outString, WSB_TRACE_BUFF_SIZE, 0) != S_OK) {
|
|
// No trace settings yet
|
|
WCHAR *systemPath;
|
|
systemPath = _wgetenv(L"SystemRoot");
|
|
WsbAffirmHr(tracePath.Printf( L"%ls\\System32\\RemoteStorage\\Trace\\RsCli.Trc", systemPath));
|
|
|
|
// Set default settings in the Registry
|
|
WsbEnsureRegistryKeyExists(0, regPath);
|
|
WsbSetRegistryValueString(0, regPath, L"WsbTraceFileName", tracePath);
|
|
|
|
// Make sure the trace directory exists.
|
|
WsbAffirmHr(tracePath.Printf( L"%ls\\System32\\RemoteStorage", systemPath));
|
|
CreateDirectory(tracePath, 0);
|
|
WsbAffirmHr(tracePath.Printf( L"%ls\\System32\\RemoteStorage\\Trace", systemPath));
|
|
CreateDirectory(tracePath, 0);
|
|
}
|
|
|
|
g_pTrace->SetRegistryEntry(regPath);
|
|
g_pTrace->LoadFromRegistry();
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
ClipUninitializeTrace(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Uninitializes the trace/print mechansim
|
|
Paired with ClipInitializeTrace
|
|
|
|
Arguments
|
|
|
|
NONE
|
|
|
|
Return Value
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
g_pTrace = 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
ClipHandleErrors(
|
|
IN HRESULT RetCode,
|
|
IN RSS_INTERFACE Interface,
|
|
IN RSS_INTERFACE SubInterface
|
|
)
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Translates the main return value & displays any appropriate
|
|
error messages and returns
|
|
|
|
Arguments
|
|
|
|
RetCode - Error to handle
|
|
Interface - RSS interface specified in the command
|
|
SubInterface - RSS sub-interface specified in the command
|
|
|
|
Return Value
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
WsbTraceIn(OLESTR("ClipHandleErrors"), OLESTR(""));
|
|
|
|
switch (RetCode) {
|
|
case E_INVALIDARG:
|
|
case S_OK:{
|
|
//
|
|
// Nothing to print
|
|
//
|
|
break;}
|
|
|
|
case E_NOINTERFACE:{
|
|
WsbTraceAndPrint(CLI_MESSAGE_VALUE_DISPLAY, WsbHrAsString(E_INVALIDARG));
|
|
ClipHelp(Interface,
|
|
SubInterface);
|
|
break;}
|
|
default:{
|
|
WsbTraceAndPrint(CLI_MESSAGE_VALUE_DISPLAY, WsbHrAsString(RetCode));
|
|
break;}
|
|
}
|
|
|
|
WsbTraceOut(OLESTR("ClipHandleErrors"), OLESTR(""));
|
|
}
|
|
|
|
|
|
extern "C"
|
|
int __cdecl
|
|
wmain()
|
|
{
|
|
LPWSTR commandLine, token;
|
|
HRESULT hr = E_NOINTERFACE;
|
|
RSS_INTERFACE intrface = HELP_IF, subInterface = UNKNOWN_IF;
|
|
|
|
try {
|
|
WsbAffirmHr(CoInitialize(NULL));
|
|
|
|
//
|
|
// Set to OEM page locale
|
|
//
|
|
_wsetlocale(LC_ALL, L".OCP");
|
|
|
|
//
|
|
// Set to console UI langauge
|
|
//
|
|
SetThreadUILanguage(0);
|
|
|
|
ClipInitializeTrace();
|
|
|
|
commandLine = GetCommandLine();
|
|
//
|
|
// Get argv[0] out of the way
|
|
//
|
|
token = wcstok(commandLine, SEPARATORS);
|
|
|
|
//
|
|
// Get the interface string
|
|
//
|
|
token = wcstok(NULL, SEPARATORS);
|
|
|
|
if (token == NULL) {
|
|
ClipHelp(HELP_IF,
|
|
UNKNOWN_IF);
|
|
hr = S_OK;
|
|
goto exit;
|
|
}
|
|
|
|
intrface = ClipGetInterface(token);
|
|
|
|
if (intrface == UNKNOWN_IF) {
|
|
hr = E_NOINTERFACE;
|
|
intrface = HELP_IF;
|
|
goto exit;
|
|
}
|
|
|
|
if (intrface == HELP_IF) {
|
|
ClipHelp(HELP_IF,
|
|
UNKNOWN_IF);
|
|
hr = S_OK;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Get sub interface string
|
|
//
|
|
token = wcstok(NULL, SEPARATORS);
|
|
|
|
if (token == NULL) {
|
|
hr = E_NOINTERFACE;
|
|
goto exit;
|
|
}
|
|
subInterface = ClipGetInterface(token);
|
|
|
|
if (subInterface == UNKNOWN_IF) {
|
|
hr = E_NOINTERFACE;
|
|
goto exit;
|
|
}
|
|
|
|
if (subInterface == HELP_IF) {
|
|
ClipHelp(intrface,
|
|
UNKNOWN_IF);
|
|
hr = S_OK;
|
|
goto exit;
|
|
}
|
|
//
|
|
// Now compile the switches & arguments into separate arrays
|
|
// First, get the rest of line ..
|
|
//
|
|
token = wcstok(NULL, L"");
|
|
hr = ClipCompileSwitchesAndArgs(token,
|
|
intrface,
|
|
subInterface);
|
|
|
|
if (hr != S_OK) {
|
|
goto exit;
|
|
}
|
|
|
|
switch (intrface) {
|
|
|
|
case ADMIN_IF:{
|
|
if (subInterface == SHOW_IF) {
|
|
hr = ClipAdminShow();
|
|
} else if (subInterface == SET_IF) {
|
|
hr = ClipAdminSet();
|
|
} else {
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case VOLUME_IF:{
|
|
if (subInterface == MANAGE_IF) {
|
|
hr = ClipVolumeSetManage(FALSE);
|
|
} else if (subInterface == UNMANAGE_IF) {
|
|
hr = ClipVolumeUnmanage();
|
|
} else if (subInterface == SET_IF) {
|
|
hr = ClipVolumeSetManage(TRUE);
|
|
} else if (subInterface == SHOW_IF) {
|
|
hr = ClipVolumeShow();
|
|
} else if (subInterface == DELETE_IF) {
|
|
hr = ClipVolumeDelete();
|
|
} else if (subInterface == JOB_IF) {
|
|
hr = ClipVolumeJob();
|
|
} else {
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case FILE_IF:{
|
|
if (subInterface == RECALL_IF) {
|
|
hr = ClipFileRecall();
|
|
} else {
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MEDIA_IF:{
|
|
if (subInterface == SYNCHRONIZE_IF) {
|
|
hr = ClipMediaSynchronize();
|
|
} else if (subInterface == RECREATEMASTER_IF) {
|
|
hr = ClipMediaRecreateMaster();
|
|
} else if (subInterface == DELETE_IF) {
|
|
hr = ClipMediaDelete();
|
|
} else if (subInterface == SHOW_IF) {
|
|
hr = ClipMediaShow();
|
|
} else {
|
|
hr = E_NOINTERFACE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:{
|
|
hr = E_NOINTERFACE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
exit:
|
|
|
|
ClipHandleErrors(hr,
|
|
intrface,
|
|
subInterface);
|
|
|
|
ClipCleanup();
|
|
ClipUninitializeTrace();
|
|
CoUninitialize();
|
|
|
|
}WsbCatchAndDo(hr,
|
|
WsbTraceAndPrint(CLI_MESSAGE_GENERIC_ERROR, WsbHrAsString(hr));
|
|
);
|
|
|
|
CLIP_TRANSLATE_HR_AND_RETURN(hr);
|
|
}
|