able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/win32/credui/creduit/creduit.cxx

1213 lines
31 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*--
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;
}
Reference in a new issue Copy permalink