1213 lines
31 KiB
C++
1213 lines
31 KiB
C++
/*--
|
|
|
|
Copyright (c) 2000-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
creduit.cxx
|
|
|
|
Abstract:
|
|
|
|
Test program for the credential manager UI API.
|
|
|
|
|
|
Author:
|
|
|
|
16-Jan-2001 (cliffv)
|
|
|
|
Environment:
|
|
|
|
User mode only.
|
|
Contains NT-specific code.
|
|
Requires ANSI C extensions: slash-slash comments, long external names.
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#define UNICODE
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <shellapi.h>
|
|
#include <wincred.h>
|
|
#include <credp.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <lmerr.h>
|
|
#include <align.h>
|
|
|
|
#define _CREDUI_
|
|
#include <wincrui.h>
|
|
|
|
#include <lmcons.h>
|
|
extern "C" {
|
|
#include <names.h>
|
|
#include <rpcutil.h>
|
|
}
|
|
#include <winerror.dbg>
|
|
|
|
//
|
|
// Structure defining a array of parsed strings
|
|
//
|
|
|
|
typedef struct _STRING_ARRAY {
|
|
BOOLEAN Specified;
|
|
DWORD Count;
|
|
#define STRING_ARRAY_COUNT 100
|
|
LPWSTR Strings[STRING_ARRAY_COUNT];
|
|
} STRING_ARRAY, *PSTRING_ARRAY;
|
|
|
|
//
|
|
// Parsed Parameters
|
|
//
|
|
|
|
LPWSTR CommandLine;
|
|
DWORD GlCommand = 0xFFFFFFFF;
|
|
|
|
BOOLEAN GlAnsi;
|
|
BOOLEAN GlDoGui;
|
|
|
|
LPWSTR GlUserName;
|
|
LPWSTR GlTargetName;
|
|
LPWSTR GlMessage;
|
|
LPWSTR GlTitle;
|
|
LPWSTR GlAuthError;
|
|
DWORD GlCreduiFlags;
|
|
BOOLEAN GlNoConfirm;
|
|
BOOL GlSave;
|
|
|
|
//
|
|
// Table of valid parameters to the command.
|
|
//
|
|
|
|
struct _PARAMAMTER_DEF {
|
|
LPWSTR Name; // Name of the parameter
|
|
|
|
LPSTR ValueName; // Test describing parameter value
|
|
|
|
DWORD Type; // Parameter type
|
|
#define PARM_COMMAND 1 // Parameter defines a command
|
|
#define PARM_COMMAND_STR 2 // Parameter defines a command (and has text string)
|
|
#define PARM_COMMAND_OPTSTR 3 // Parameter defines a command (and optionaly has text string)
|
|
#define PARM_STRING 4 // Parameter defines a text string
|
|
#define PARM_STRING_ENUM 5 // Parameter is an enumeration of text strings
|
|
#define PARM_STRING_ARRAY 6 // Parameter is an array of text strings
|
|
#define PARM_BOOLEAN 7 // Parameter set a boolean
|
|
#define PARM_BIT 8 // Parameter sets a bit in a DWORD
|
|
|
|
PVOID Global; // Address of global to write
|
|
|
|
LPWSTR *EnumStrings;
|
|
|
|
//
|
|
// Describe relationships to other parameters.
|
|
//
|
|
DWORD Relationships;
|
|
#define ALLOW_CRED 0x01 // If specified, this parameter allows other IS_CRED parameters
|
|
#define IS_CRED 0x02 // This parameter is only allow if an ALLOW_CRED parameter has been seen previously
|
|
#define ALLOW_TI 0x10 // If specified, this parameter allows other IS_TI or IS_TIX parameters
|
|
#define IS_TI 0x20 // This parameter is only allow if an ALLOW_TI parameter has been seen previously
|
|
#define IS_TIX 0x40 // This parameter is only allow if an ALLOW_TI parameter has been seen previously
|
|
LPSTR Comment;
|
|
} ParameterDefinitions[] =
|
|
{
|
|
{L"UserName", "UserName", PARM_STRING, &GlUserName, NULL, 0, "User Name" },
|
|
{L"TargetName", "TargetName", PARM_STRING, &GlTargetName, NULL, 0, "Target Name" },
|
|
{L"Message", "Message", PARM_STRING, &GlMessage, NULL, 0, "Message for dialog box" },
|
|
{L"Title", "Title", PARM_STRING, &GlTitle, NULL, 0, "Title for dialog box" },
|
|
{L"Gui", NULL, PARM_BOOLEAN, &GlDoGui, NULL, 0, "Call GUI version of API" },
|
|
{L"Ansi", NULL, PARM_BOOLEAN, &GlAnsi, NULL, 0, "Use ANSI version of APIs" },
|
|
{ NULL },
|
|
{L"ReqSmartcard", (LPSTR)ULongToPtr(CREDUI_FLAGS_REQUIRE_SMARTCARD), PARM_BIT, &GlCreduiFlags, NULL, 0, "Require smartcard" },
|
|
{L"ReqCertificate", (LPSTR)ULongToPtr(CREDUI_FLAGS_REQUIRE_CERTIFICATE), PARM_BIT, &GlCreduiFlags, NULL, 0, "Require certificate" },
|
|
{L"ExcCertificates",(LPSTR)ULongToPtr(CREDUI_FLAGS_EXCLUDE_CERTIFICATES), PARM_BIT, &GlCreduiFlags, NULL, 0, "Exclude certificates" },
|
|
{ NULL },
|
|
{L"GenericCreds", (LPSTR)ULongToPtr(CREDUI_FLAGS_GENERIC_CREDENTIALS), PARM_BIT, &GlCreduiFlags, NULL, 0, "Generic Credentials" },
|
|
{L"RunasCreds", (LPSTR)ULongToPtr(CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS),PARM_BIT,&GlCreduiFlags, NULL, 0, "Runas Credentials" },
|
|
{ NULL },
|
|
{L"Persist", (LPSTR)ULongToPtr(CREDUI_FLAGS_PERSIST), PARM_BIT, &GlCreduiFlags, NULL, 0, "Always save Credentials" },
|
|
{L"NoPersist", (LPSTR)ULongToPtr(CREDUI_FLAGS_DO_NOT_PERSIST), PARM_BIT, &GlCreduiFlags, NULL, 0, "Never save Credentials" },
|
|
{L"ShowSaveCheckbox:(T/F)",(LPSTR)ULongToPtr(CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX), PARM_BIT, &GlCreduiFlags, ((LPWSTR *)&GlSave), 0, "Show Save checkbox (initial value)" },
|
|
{ NULL },
|
|
{L"ValidateUsername",(LPSTR)ULongToPtr(CREDUI_FLAGS_VALIDATE_USERNAME), PARM_BIT, &GlCreduiFlags, NULL, 0, "Validate Username" },
|
|
{L"CompleteUsername",(LPSTR)ULongToPtr(CREDUI_FLAGS_COMPLETE_USERNAME), PARM_BIT, &GlCreduiFlags, NULL, 0, "Complete Username" },
|
|
{ NULL },
|
|
{L"Confirm", (LPSTR)ULongToPtr(CREDUI_FLAGS_EXPECT_CONFIRMATION), PARM_BIT, &GlCreduiFlags, NULL, 0, "Confirm that the credential worked" },
|
|
{L"NoConfirm", NULL, PARM_BOOLEAN,&GlNoConfirm,NULL, 0, "Confirm that the credential failed" },
|
|
{ NULL },
|
|
{L"AlwaysShowUi",(LPSTR)ULongToPtr(CREDUI_FLAGS_ALWAYS_SHOW_UI), PARM_BIT, &GlCreduiFlags, NULL, 0, "Always Show UI" },
|
|
{L"IncorrectPassword",(LPSTR)ULongToPtr(CREDUI_FLAGS_INCORRECT_PASSWORD), PARM_BIT, &GlCreduiFlags, NULL, 0, "Show 'incorrect password' tip" },
|
|
{L"AuthError", "ErrorNum", PARM_STRING, &GlAuthError, NULL, 0, "Previous auth error number" },
|
|
|
|
|
|
};
|
|
#define PARAMETER_COUNT (sizeof(ParameterDefinitions)/sizeof(ParameterDefinitions[0]))
|
|
|
|
VOID
|
|
PrintOneUsage(
|
|
LPWSTR Argument OPTIONAL,
|
|
ULONG ArgumentIndex
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Print the command line parameter usage for one parameter
|
|
|
|
Arguments:
|
|
|
|
Argument - Argument as typed by caller
|
|
NULL if printing complete list of arguments
|
|
|
|
ArugmentIndex - Index of the parameter to print
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
ULONG j;
|
|
|
|
if ( ParameterDefinitions[ArgumentIndex].Name == NULL ) {
|
|
fprintf( stderr, "\n" );
|
|
return;
|
|
}
|
|
|
|
if ( Argument != NULL ) {
|
|
fprintf( stderr, "\nSyntax of '%ls' parameter is:\n", Argument );
|
|
}
|
|
|
|
fprintf( stderr, " /%ls", ParameterDefinitions[ArgumentIndex].Name );
|
|
|
|
switch ( ParameterDefinitions[ArgumentIndex].Type ) {
|
|
case PARM_COMMAND:
|
|
case PARM_BOOLEAN:
|
|
break;
|
|
case PARM_BIT:
|
|
if ( ParameterDefinitions[ArgumentIndex].EnumStrings == NULL ) {
|
|
break;
|
|
} else {
|
|
fprintf( stderr, ":{T/F}" );
|
|
break;
|
|
}
|
|
case PARM_COMMAND_OPTSTR:
|
|
fprintf( stderr, "[:<%s>]", ParameterDefinitions[ArgumentIndex].ValueName );
|
|
break;
|
|
case PARM_STRING:
|
|
case PARM_COMMAND_STR:
|
|
fprintf( stderr, ":<%s>", ParameterDefinitions[ArgumentIndex].ValueName );
|
|
break;
|
|
case PARM_STRING_ENUM:
|
|
fprintf( stderr, ":<" );
|
|
for ( j=0; ParameterDefinitions[ArgumentIndex].EnumStrings[j] != NULL; j++) {
|
|
if ( j!= 0 ) {
|
|
fprintf( stderr, "|");
|
|
}
|
|
fprintf( stderr, "%ls", ParameterDefinitions[ArgumentIndex].EnumStrings[j] );
|
|
}
|
|
fprintf( stderr, ">" );
|
|
|
|
break;
|
|
case PARM_STRING_ARRAY:
|
|
fprintf( stderr, ":<%s>", ParameterDefinitions[ArgumentIndex].ValueName );
|
|
break;
|
|
}
|
|
|
|
if ( Argument == NULL ) {
|
|
fprintf( stderr, " - %s", ParameterDefinitions[ArgumentIndex].Comment );
|
|
}
|
|
|
|
fprintf( stderr, "\n" );
|
|
|
|
}
|
|
|
|
VOID
|
|
PrintUsage(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Print the command line parameter usage.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
ULONG i;
|
|
|
|
fprintf( stderr, "\nUsage: creduit [Options]\n\nWhere options are:\n\n");
|
|
|
|
for ( i=0; i<PARAMETER_COUNT; i++ ) {
|
|
PrintOneUsage( NULL, i );
|
|
}
|
|
|
|
}
|
|
|
|
LPSTR
|
|
FindSymbolicNameForStatus(
|
|
DWORD Id
|
|
)
|
|
{
|
|
ULONG i;
|
|
|
|
i = 0;
|
|
if (Id == 0) {
|
|
return "NO_ERROR";
|
|
}
|
|
|
|
#ifdef notdef
|
|
if (Id & 0xC0000000) {
|
|
while (ntstatusSymbolicNames[ i ].SymbolicName) {
|
|
if (ntstatusSymbolicNames[ i ].MessageId == (NTSTATUS)Id) {
|
|
return ntstatusSymbolicNames[ i ].SymbolicName;
|
|
} else {
|
|
i += 1;
|
|
}
|
|
}
|
|
}
|
|
#endif // notdef
|
|
|
|
while (winerrorSymbolicNames[ i ].SymbolicName) {
|
|
if (winerrorSymbolicNames[ i ].MessageId == Id) {
|
|
return winerrorSymbolicNames[ i ].SymbolicName;
|
|
} else {
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
#ifdef notdef
|
|
while (neteventSymbolicNames[ i ].SymbolicName) {
|
|
if (neteventSymbolicNames[ i ].MessageId == Id) {
|
|
return neteventSymbolicNames[ i ].SymbolicName
|
|
} else {
|
|
i += 1;
|
|
}
|
|
}
|
|
#endif // notdef
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintStatus(
|
|
DWORD NetStatus
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Print a net status code.
|
|
|
|
Arguments:
|
|
|
|
NetStatus - The net status code to print.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
printf( "Status = %lu 0x%lx", NetStatus, NetStatus );
|
|
|
|
switch (NetStatus) {
|
|
case NERR_Success:
|
|
printf( " NERR_Success" );
|
|
break;
|
|
|
|
case NERR_DCNotFound:
|
|
printf( " NERR_DCNotFound" );
|
|
break;
|
|
|
|
case NERR_UserNotFound:
|
|
printf( " NERR_UserNotFound" );
|
|
break;
|
|
|
|
case NERR_NetNotStarted:
|
|
printf( " NERR_NetNotStarted" );
|
|
break;
|
|
|
|
case NERR_WkstaNotStarted:
|
|
printf( " NERR_WkstaNotStarted" );
|
|
break;
|
|
|
|
case NERR_ServerNotStarted:
|
|
printf( " NERR_ServerNotStarted" );
|
|
break;
|
|
|
|
case NERR_BrowserNotStarted:
|
|
printf( " NERR_BrowserNotStarted" );
|
|
break;
|
|
|
|
case NERR_ServiceNotInstalled:
|
|
printf( " NERR_ServiceNotInstalled" );
|
|
break;
|
|
|
|
case NERR_BadTransactConfig:
|
|
printf( " NERR_BadTransactConfig" );
|
|
break;
|
|
|
|
default:
|
|
printf( " %s", FindSymbolicNameForStatus( NetStatus ) );
|
|
break;
|
|
|
|
}
|
|
|
|
printf( "\n" );
|
|
}
|
|
|
|
VOID
|
|
PrintBytes(
|
|
PVOID Buffer,
|
|
DWORD BufferSize
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dumps the buffer content as hex and characters.
|
|
|
|
Arguments:
|
|
|
|
Buffer: buffer pointer.
|
|
|
|
BufferSize: size of the buffer.
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
#define NUM_CHARS 16
|
|
|
|
DWORD i, limit;
|
|
CHAR TextBuffer[NUM_CHARS + 1];
|
|
LPBYTE BufferPtr = (LPBYTE)Buffer;
|
|
BOOLEAN DumpDwords = FALSE;
|
|
|
|
//
|
|
// Preprocess
|
|
//
|
|
|
|
if ( BufferSize > NUM_CHARS ) {
|
|
printf("\n"); // Ensure this starts on a new line
|
|
printf("------------------------------------\n");
|
|
} else {
|
|
if ( BufferSize % sizeof(DWORD) == 0 ) {
|
|
DumpDwords = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Hex dump of the bytes
|
|
//
|
|
limit = ((BufferSize - 1) / NUM_CHARS + 1) * NUM_CHARS;
|
|
|
|
for (i = 0; i < limit; i++) {
|
|
|
|
if (i < BufferSize) {
|
|
|
|
if ( DumpDwords ) {
|
|
if ( i % sizeof(DWORD) == 0 ) {
|
|
DWORD ADword;
|
|
RtlCopyMemory( &ADword, &BufferPtr[i], sizeof(DWORD) );
|
|
printf("%08x ", ADword);
|
|
}
|
|
} else {
|
|
printf("%02x ", BufferPtr[i]);
|
|
}
|
|
|
|
if ( isprint(BufferPtr[i]) ) {
|
|
TextBuffer[i % NUM_CHARS] = (CHAR) BufferPtr[i];
|
|
} else {
|
|
TextBuffer[i % NUM_CHARS] = '.';
|
|
}
|
|
|
|
} else {
|
|
|
|
if ( DumpDwords ) {
|
|
TextBuffer[i % NUM_CHARS] = '\0';
|
|
} else {
|
|
if ( BufferSize > NUM_CHARS ) {
|
|
printf(" ");
|
|
TextBuffer[i % NUM_CHARS] = ' ';
|
|
} else {
|
|
TextBuffer[i % NUM_CHARS] = '\0';
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if ((i + 1) % NUM_CHARS == 0) {
|
|
TextBuffer[NUM_CHARS] = 0;
|
|
printf(" %s\n", TextBuffer);
|
|
}
|
|
|
|
}
|
|
|
|
if ( BufferSize > NUM_CHARS ) {
|
|
printf("------------------------------------\n");
|
|
} else if ( BufferSize < NUM_CHARS ) {
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PrintTime(
|
|
LPSTR Comment,
|
|
LPFILETIME ConvertTime
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Print the specified time
|
|
|
|
Arguments:
|
|
|
|
Comment - Comment to print in front of the time
|
|
|
|
Time - GMT time to print (Nothing is printed if this is zero)
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// If we've been asked to convert an NT GMT time to ascii,
|
|
// Do so
|
|
//
|
|
|
|
if ( ConvertTime->dwLowDateTime != 0 || ConvertTime->dwHighDateTime != 0 ) {
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalFileTime;
|
|
|
|
printf( "%s", Comment );
|
|
|
|
if ( !FileTimeToLocalFileTime( ConvertTime, &LocalFileTime ) ) {
|
|
printf( "Can't convert time from GMT to Local time: " );
|
|
PrintStatus( GetLastError() );
|
|
return;
|
|
}
|
|
|
|
if ( !FileTimeToSystemTime( &LocalFileTime, &SystemTime ) ) {
|
|
printf( "Can't convert time from file time to system time: " );
|
|
PrintStatus( GetLastError() );
|
|
return;
|
|
}
|
|
|
|
printf( "%ld/%ld/%ld %ld:%2.2ld:%2.2ld\n",
|
|
SystemTime.wMonth,
|
|
SystemTime.wDay,
|
|
SystemTime.wYear,
|
|
SystemTime.wHour,
|
|
SystemTime.wMinute,
|
|
SystemTime.wSecond );
|
|
}
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
ParseParameters(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Parse the command line parameters
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
TRUE if parse was successful.
|
|
|
|
--*/
|
|
{
|
|
LPWSTR *argvw;
|
|
int argcw;
|
|
int i;
|
|
ULONG j;
|
|
|
|
LPWSTR OrigArgument;
|
|
LPWSTR Argument;
|
|
|
|
|
|
//
|
|
// Get the command line in Unicode
|
|
//
|
|
|
|
CommandLine = GetCommandLine();
|
|
|
|
argvw = CommandLineToArgvW( CommandLine, &argcw );
|
|
|
|
if ( argvw == NULL ) {
|
|
fprintf( stderr, "Can't convert command line to Unicode: %ld\n", GetLastError() );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Loop through the command line arguments
|
|
//
|
|
|
|
for ( i=1; i<argcw; i++ ) {
|
|
|
|
OrigArgument = Argument = argvw[i];
|
|
|
|
//
|
|
// Check if the Argument is a switch
|
|
//
|
|
|
|
if ( Argument[0] == '-' || Argument[0] == '/' ) {
|
|
DWORD ArgumentIndex;
|
|
ULONG ArgumentLength;
|
|
PWCHAR ColonPointer;
|
|
Argument ++;
|
|
|
|
//
|
|
// Find the colon at the end of the argument
|
|
//
|
|
|
|
ColonPointer = wcschr( Argument, L':' );
|
|
if ( ColonPointer != NULL ) {
|
|
*ColonPointer = '\0';
|
|
}
|
|
ArgumentLength = wcslen(Argument);
|
|
|
|
//
|
|
// Loop through the list of valid arguments finding all that match
|
|
//
|
|
|
|
ArgumentIndex = 0xFFFFFFFF;
|
|
for ( j=0; j<PARAMETER_COUNT; j++ ) {
|
|
|
|
//
|
|
// Ignore placeholders
|
|
//
|
|
|
|
if ( ParameterDefinitions[j].Name == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Compare the names
|
|
//
|
|
|
|
if ( _wcsnicmp( Argument, ParameterDefinitions[j].Name, ArgumentLength ) == 0 ) {
|
|
//
|
|
// If more than one matches,
|
|
// it's an error
|
|
//
|
|
|
|
if ( ArgumentIndex != 0xFFFFFFFF ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' is ambiguous: %ls or %ls.\n",
|
|
OrigArgument,
|
|
ParameterDefinitions[j].Name,
|
|
ParameterDefinitions[ArgumentIndex].Name );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
ArgumentIndex = j;
|
|
|
|
//
|
|
// If this is an exact match,
|
|
// we're done.
|
|
//
|
|
|
|
if ( ArgumentLength == wcslen(ParameterDefinitions[j].Name)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If there were not matches,
|
|
// complain.
|
|
//
|
|
|
|
if ( ArgumentIndex == 0xFFFFFFFF ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' is invalid.\n",
|
|
OrigArgument );
|
|
PrintUsage();
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Ensure the : is present as required
|
|
//
|
|
|
|
|
|
//
|
|
// Return TRUE if the specified argument should have a : character after the
|
|
// argument name.
|
|
//
|
|
|
|
if ( ParameterDefinitions[ArgumentIndex].Type == PARM_COMMAND ||
|
|
ParameterDefinitions[ArgumentIndex].Type == PARM_BOOLEAN ||
|
|
(ParameterDefinitions[ArgumentIndex].Type == PARM_BIT &&
|
|
ParameterDefinitions[ArgumentIndex].EnumStrings == NULL ) ) {
|
|
|
|
if ( ColonPointer != NULL ) {
|
|
PrintOneUsage( OrigArgument, ArgumentIndex );
|
|
return FALSE;
|
|
}
|
|
|
|
} else {
|
|
|
|
if ( ColonPointer == NULL ) {
|
|
if ( ParameterDefinitions[ArgumentIndex].Type != PARM_COMMAND_OPTSTR ) {
|
|
PrintOneUsage( OrigArgument, ArgumentIndex );
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
Argument = ColonPointer + 1;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Parse the rest of the argument
|
|
//
|
|
// Handle commands
|
|
//
|
|
|
|
switch ( ParameterDefinitions[ArgumentIndex].Type ) {
|
|
case PARM_COMMAND:
|
|
case PARM_COMMAND_STR:
|
|
case PARM_COMMAND_OPTSTR:
|
|
if ( GlCommand != 0xFFFFFFFF ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' and '/%ls' are mutually exclusive.\n",
|
|
OrigArgument,
|
|
ParameterDefinitions[GlCommand].Name );
|
|
|
|
return FALSE;
|
|
}
|
|
GlCommand = ArgumentIndex;
|
|
|
|
|
|
/* Drop through */
|
|
|
|
//
|
|
// Handle parameters of the form /xxx:string
|
|
//
|
|
|
|
case PARM_STRING: {
|
|
LPWSTR *StringPointer;
|
|
StringPointer = (LPWSTR *)(ParameterDefinitions[ArgumentIndex].Global);
|
|
|
|
//
|
|
// If a string is not present,
|
|
// we're done.
|
|
//
|
|
|
|
if ( ColonPointer == NULL ) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Ensure argument only specified once.
|
|
//
|
|
|
|
if ( *StringPointer != NULL ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' may only be specified once.\n",
|
|
OrigArgument );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
//
|
|
// Ensure an actual string was specified.
|
|
//
|
|
|
|
if ( *Argument == '\0' ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' requires a value.\n",
|
|
OrigArgument );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
*StringPointer = Argument;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Handle parameters of the form /xxx:a|b|c
|
|
//
|
|
|
|
case PARM_STRING_ENUM: {
|
|
ULONG EnumIndex;
|
|
LPDWORD DwordPointer;
|
|
LPWSTR *EnumStrings;
|
|
|
|
//
|
|
// Ensure argument only specified once.
|
|
//
|
|
|
|
DwordPointer = (LPDWORD)(ParameterDefinitions[ArgumentIndex].Global);
|
|
|
|
if ( *DwordPointer != 0 ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' may only be specified once.\n",
|
|
OrigArgument );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
EnumStrings = ParameterDefinitions[ArgumentIndex].EnumStrings;
|
|
ArgumentLength = wcslen(Argument);
|
|
|
|
//
|
|
// Loop through the list of valid values finding all that match
|
|
//
|
|
|
|
EnumIndex = 0xFFFFFFFF;
|
|
for ( j=0; EnumStrings[j] != NULL; j++ ) {
|
|
|
|
//
|
|
// Compare the names
|
|
//
|
|
|
|
if ( _wcsnicmp( Argument, EnumStrings[j], ArgumentLength ) == 0 ) {
|
|
|
|
//
|
|
// If more than one matches,
|
|
// it's an error
|
|
//
|
|
|
|
if ( EnumIndex != 0xFFFFFFFF ) {
|
|
|
|
PrintOneUsage( OrigArgument, ArgumentIndex );
|
|
|
|
fprintf( stderr,
|
|
"\nValue '%ls' is ambiguous: %ls or %ls.\n",
|
|
Argument,
|
|
EnumStrings[j],
|
|
EnumStrings[EnumIndex] );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
EnumIndex = j;
|
|
|
|
//
|
|
// If this is an exact match,
|
|
// we're done.
|
|
//
|
|
|
|
if ( ArgumentLength == wcslen(EnumStrings[j]) ) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If there were not matches,
|
|
// complain.
|
|
//
|
|
|
|
if ( EnumIndex == 0xFFFFFFFF ) {
|
|
|
|
PrintOneUsage( OrigArgument, ArgumentIndex );
|
|
|
|
fprintf( stderr,
|
|
"\nValue '%ls' is invalid.\n",
|
|
Argument );
|
|
|
|
return FALSE;
|
|
}
|
|
*DwordPointer = EnumIndex + 1;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Handle parameters of the form /xxx:a,b,c
|
|
//
|
|
|
|
case PARM_STRING_ARRAY: {
|
|
PWCHAR CommaPointer;
|
|
PSTRING_ARRAY StringArray;
|
|
|
|
StringArray = ((PSTRING_ARRAY)(ParameterDefinitions[ArgumentIndex].Global));
|
|
|
|
//
|
|
// Ensure argument only specified once.
|
|
//
|
|
|
|
if ( StringArray->Specified ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' may only be specified once.\n",
|
|
OrigArgument );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
StringArray->Specified = TRUE;
|
|
|
|
//
|
|
// Loop through the values specified by the user
|
|
//
|
|
|
|
for (;;) {
|
|
|
|
//
|
|
// Ensure an actual string was specified.
|
|
//
|
|
|
|
if ( *Argument == '\0' ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' requires a value.\n",
|
|
OrigArgument );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Save it
|
|
//
|
|
|
|
StringArray->Count ++;
|
|
|
|
if ( StringArray->Count >= STRING_ARRAY_COUNT ) {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' has too many values.\n",
|
|
OrigArgument );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
StringArray->Strings[StringArray->Count-1] = Argument;
|
|
|
|
//
|
|
// Determine if there is another value
|
|
//
|
|
CommaPointer = wcschr( Argument, L',' );
|
|
if ( CommaPointer == NULL ) {
|
|
break;
|
|
}
|
|
|
|
*CommaPointer = '\0';
|
|
Argument = CommaPointer + 1;
|
|
|
|
};
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Handle parameters of the form /xxx
|
|
//
|
|
|
|
case PARM_BOOLEAN: {
|
|
BOOLEAN *BooleanPointer;
|
|
BooleanPointer = (BOOLEAN *)(ParameterDefinitions[ArgumentIndex].Global);
|
|
|
|
*BooleanPointer = TRUE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Handle parameters of the form /xxx that imply setting a bit
|
|
//
|
|
|
|
case PARM_BIT: {
|
|
DWORD *DwordPointer;
|
|
DwordPointer = (DWORD *)(ParameterDefinitions[ArgumentIndex].Global);
|
|
|
|
*DwordPointer |= PtrToUlong( ParameterDefinitions[ArgumentIndex].ValueName );
|
|
|
|
//
|
|
// Some of these have TRUE or FALSE as an optional argument
|
|
//
|
|
|
|
if ( ParameterDefinitions[ArgumentIndex].EnumStrings != NULL ) {
|
|
if ( toupper(*Argument) == 'T' ) {
|
|
*((BOOL *)(ParameterDefinitions[ArgumentIndex].EnumStrings)) = TRUE;
|
|
} else if ( toupper(*Argument) == 'F' ) {
|
|
*((BOOL *)(ParameterDefinitions[ArgumentIndex].EnumStrings)) = FALSE;
|
|
} else {
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' requires a T or F as value.\n",
|
|
OrigArgument );
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
fprintf( stderr,
|
|
"\nArgument '%ls' had an internal error.\n",
|
|
OrigArgument );
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Handle arguments that aren't switches.
|
|
//
|
|
} else {
|
|
|
|
//
|
|
// All current arguments are switches
|
|
//
|
|
|
|
PrintUsage();
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// Include routines to support the /ANSI parameter
|
|
//
|
|
|
|
LPSTR
|
|
NetpAllocAStrFromWStr (
|
|
IN LPCWSTR Unicode
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert an UNICODE (zero terminated) string to the corresponding ANSI
|
|
string.
|
|
|
|
Arguments:
|
|
|
|
Unicode - Specifies the UNICODE zero terminated string to convert.
|
|
|
|
|
|
Return Value:
|
|
|
|
NULL - There was some error in the conversion.
|
|
|
|
Otherwise, it returns a pointer to the zero terminated ANSI string in
|
|
an allocated buffer. The buffer must be freed using NetApiBufferFree.
|
|
|
|
--*/
|
|
|
|
{
|
|
ANSI_STRING AnsiString;
|
|
UNICODE_STRING UnicodeString;
|
|
|
|
RtlInitUnicodeString( &UnicodeString, Unicode );
|
|
|
|
AnsiString.MaximumLength =
|
|
(USHORT) RtlUnicodeStringToAnsiSize( &UnicodeString );
|
|
|
|
AnsiString.Buffer = (PCHAR) LocalAlloc( 0, AnsiString.MaximumLength );
|
|
|
|
if ( AnsiString.Buffer == NULL) {
|
|
return (NULL);
|
|
}
|
|
|
|
if(!NT_SUCCESS( RtlUnicodeStringToAnsiString( &AnsiString,
|
|
&UnicodeString,
|
|
FALSE))){
|
|
(void) LocalFree( AnsiString.Buffer );
|
|
return NULL;
|
|
}
|
|
|
|
return AnsiString.Buffer;
|
|
|
|
} // NetpAllocStrFromWStr
|
|
|
|
extern "C"
|
|
BOOL
|
|
DllMain(
|
|
HINSTANCE instance,
|
|
DWORD reason,
|
|
VOID *
|
|
);
|
|
|
|
int __cdecl
|
|
main(
|
|
IN int argc,
|
|
IN char ** argv
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Drive the credential manager API.
|
|
|
|
Arguments:
|
|
|
|
argc - the number of command-line arguments.
|
|
|
|
argv - an array of pointers to the arguments.
|
|
|
|
Return Value:
|
|
|
|
Exit status
|
|
|
|
--*/
|
|
{
|
|
DWORD WinStatus;
|
|
WCHAR Password[CREDUI_MAX_PASSWORD_LENGTH + 1];
|
|
WCHAR UserName[CREDUI_MAX_USERNAME_LENGTH + 1];
|
|
DWORD AuthError = NO_ERROR;
|
|
CREDUI_INFOW UiInfoW;
|
|
PCREDUI_INFOW UiInfoWptr = NULL;
|
|
|
|
//
|
|
// Parse the command line parameters
|
|
//
|
|
|
|
UserName[0] = '\0';
|
|
Password[0] = '\0';
|
|
|
|
if ( !ParseParameters() ) {
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// Fill in the parameters
|
|
//
|
|
|
|
if ( GlUserName != NULL) {
|
|
wcscpy( UserName, GlUserName );
|
|
}
|
|
|
|
//
|
|
// Get the error number
|
|
//
|
|
|
|
if ( GlAuthError != NULL ) {
|
|
LPWSTR End;
|
|
|
|
AuthError = wcstoul( GlAuthError, &End, 10 );
|
|
}
|
|
|
|
//
|
|
// Handle special parameters
|
|
//
|
|
|
|
if ( GlNoConfirm ) {
|
|
GlCreduiFlags |= CREDUI_FLAGS_EXPECT_CONFIRMATION;
|
|
}
|
|
|
|
//
|
|
// Build the UI info
|
|
//
|
|
|
|
if ( GlMessage || GlTitle ) {
|
|
UiInfoWptr = &UiInfoW;
|
|
|
|
ZeroMemory( &UiInfoW, sizeof(UiInfoW) );
|
|
|
|
UiInfoW.cbSize = sizeof(UiInfoW);
|
|
UiInfoW.pszMessageText = GlMessage;
|
|
UiInfoW.pszCaptionText = GlTitle;
|
|
}
|
|
|
|
|
|
//
|
|
// Execute the requested command
|
|
//
|
|
|
|
switch ( GlCommand ) {
|
|
case 0xFFFFFFFF:
|
|
if ( GlAnsi ) {
|
|
printf( "We don't yet do ansi.\n");
|
|
} else {
|
|
|
|
if ( GlDoGui ) {
|
|
WinStatus = CredUIPromptForCredentialsW(
|
|
UiInfoWptr,
|
|
GlTargetName,
|
|
NULL, // No security context
|
|
AuthError,
|
|
UserName,
|
|
sizeof(UserName)/sizeof(WCHAR),
|
|
Password,
|
|
sizeof(Password)/sizeof(WCHAR),
|
|
&GlSave,
|
|
GlCreduiFlags );
|
|
} else {
|
|
WinStatus = CredUICmdLinePromptForCredentialsW(
|
|
GlTargetName,
|
|
NULL, // No security context
|
|
AuthError,
|
|
UserName,
|
|
sizeof(UserName)/sizeof(WCHAR),
|
|
Password,
|
|
sizeof(Password)/sizeof(WCHAR),
|
|
&GlSave,
|
|
GlCreduiFlags );
|
|
|
|
}
|
|
|
|
if ( WinStatus != NO_ERROR ) {
|
|
fprintf( stderr, "CredUIPromptForCredentialsW failed: \n" );
|
|
PrintStatus( WinStatus );
|
|
return 1;
|
|
}
|
|
|
|
printf( "UserName: '%ws'\n", UserName );
|
|
printf( "Password: '%ws'\n", Password );
|
|
printf( "Save: %ld\n", GlSave );
|
|
|
|
//
|
|
// Do confirmation
|
|
//
|
|
|
|
if ( GlCreduiFlags & CREDUI_FLAGS_EXPECT_CONFIRMATION ) {
|
|
|
|
WinStatus = CredUIConfirmCredentialsW( GlTargetName, !GlNoConfirm );
|
|
|
|
if ( WinStatus != NO_ERROR ) {
|
|
fprintf( stderr, "CredUIConfirmCredentialsW failed: \n" );
|
|
PrintStatus( WinStatus );
|
|
}
|
|
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
fprintf( stderr, "Internal error: %ld\n", GlCommand );
|
|
return 1;
|
|
}
|
|
|
|
fprintf( stderr, "Command completed successfully.\n" );
|
|
return 0;
|
|
}
|