| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| //! Authentication API Prototypes and Definitions |
| use shared::minwindef::{ |
| BOOL, DWORD, FILETIME, LPBYTE, LPCVOID, LPDWORD, LPVOID, PBOOL, PBYTE, UCHAR, ULONG |
| }; |
| use shared::windef::{HBITMAP, HWND}; |
| use um::sspi::PCtxtHandle; |
| use um::winnt::{CHAR, LPCSTR, LPCWSTR, LPSTR, LPWSTR, PCSTR, PCWSTR, PSTR, PVOID, PWSTR, WCHAR}; |
| // STATUS_* |
| pub const NERR_BASE: DWORD = 2100; |
| pub const NERR_PasswordExpired: DWORD = NERR_BASE + 142; |
| pub const CRED_MAX_STRING_LENGTH: DWORD = 256; |
| pub const CRED_MAX_USERNAME_LENGTH: DWORD = 256 + 1 + 256; |
| pub const CRED_MAX_GENERIC_TARGET_NAME_LENGTH: DWORD = 32767; |
| pub const CRED_MAX_DOMAIN_TARGET_NAME_LENGTH: DWORD = 256 + 1 + 80; |
| pub const CRED_MAX_TARGETNAME_NAMESPACE_LENGTH: DWORD = 256; |
| pub const CRED_MAX_TARGETNAME_ATTRIBUTE_LENGTH: DWORD = 256; |
| pub const CRED_MAX_VALUE_SIZE: DWORD = 256; |
| pub const CRED_MAX_ATTRIBUTES: DWORD = 64; |
| STRUCT!{struct CREDENTIAL_ATTRIBUTEA { |
| Keyword: LPSTR, |
| Flags: DWORD, |
| ValueSize: DWORD, |
| Value: LPBYTE, |
| }} |
| pub type PCREDENTIAL_ATTRIBUTEA = *mut CREDENTIAL_ATTRIBUTEA; |
| STRUCT!{struct CREDENTIAL_ATTRIBUTEW { |
| Keyword: LPWSTR, |
| Flags: DWORD, |
| ValueSize: DWORD, |
| Value: LPBYTE, |
| }} |
| pub type PCREDENTIAL_ATTRIBUTEW = *mut CREDENTIAL_ATTRIBUTEW; |
| pub const CRED_LOGON_TYPES_MASK: DWORD = 0xF000; |
| pub const CRED_FLAGS_PASSWORD_FOR_CERT: DWORD = 0x0001; |
| pub const CRED_FLAGS_PROMPT_NOW: DWORD = 0x0002; |
| pub const CRED_FLAGS_USERNAME_TARGET: DWORD = 0x0004; |
| pub const CRED_FLAGS_OWF_CRED_BLOB: DWORD = 0x0008; |
| pub const CRED_FLAGS_REQUIRE_CONFIRMATION: DWORD = 0x0010; |
| pub const CRED_FLAGS_WILDCARD_MATCH: DWORD = 0x0020; |
| pub const CRED_FLAGS_VALID_FLAGS: DWORD = 0xF03F; |
| pub const CRED_FLAGS_VALID_INPUT_FLAGS: DWORD = 0xF01F; |
| pub const CRED_TYPE_GENERIC: DWORD = 1; |
| pub const CRED_TYPE_DOMAIN_PASSWORD: DWORD = 2; |
| pub const CRED_TYPE_DOMAIN_CERTIFICATE: DWORD = 3; |
| pub const CRED_TYPE_DOMAIN_VISIBLE_PASSWORD: DWORD = 4; |
| pub const CRED_TYPE_GENERIC_CERTIFICATE: DWORD = 5; |
| pub const CRED_TYPE_DOMAIN_EXTENDED: DWORD = 6; |
| pub const CRED_TYPE_MAXIMUM: DWORD = 7; |
| pub const CRED_TYPE_MAXIMUM_EX: DWORD = CRED_TYPE_MAXIMUM + 1000; |
| pub const CRED_MAX_CREDENTIAL_BLOB_SIZE: DWORD = 5 * 512; |
| pub const CRED_PERSIST_NONE: DWORD = 0; |
| pub const CRED_PERSIST_SESSION: DWORD = 1; |
| pub const CRED_PERSIST_LOCAL_MACHINE: DWORD = 2; |
| pub const CRED_PERSIST_ENTERPRISE: DWORD = 3; |
| STRUCT!{struct CREDENTIALA { |
| Flags: DWORD, |
| Type: DWORD, |
| TargetName: LPSTR, |
| Comment: LPSTR, |
| LastWritten: FILETIME, |
| CredentialBlobSize: DWORD, |
| CredentialBlob: LPBYTE, |
| Persist: DWORD, |
| AttributeCount: DWORD, |
| Attributes: PCREDENTIAL_ATTRIBUTEA, |
| TargetAlias: LPSTR, |
| UserName: LPSTR, |
| }} |
| pub type PCREDENTIALA = *mut CREDENTIALA; |
| STRUCT!{struct CREDENTIALW { |
| Flags: DWORD, |
| Type: DWORD, |
| TargetName: LPWSTR, |
| Comment: LPWSTR, |
| LastWritten: FILETIME, |
| CredentialBlobSize: DWORD, |
| CredentialBlob: LPBYTE, |
| Persist: DWORD, |
| AttributeCount: DWORD, |
| Attributes: PCREDENTIAL_ATTRIBUTEW, |
| TargetAlias: LPWSTR, |
| UserName: LPWSTR, |
| }} |
| pub type PCREDENTIALW = *mut CREDENTIALW; |
| pub const CRED_TI_SERVER_FORMAT_UNKNOWN: ULONG = 0x0001; |
| pub const CRED_TI_DOMAIN_FORMAT_UNKNOWN: ULONG = 0x0002; |
| pub const CRED_TI_ONLY_PASSWORD_REQUIRED: ULONG = 0x0004; |
| pub const CRED_TI_USERNAME_TARGET: ULONG = 0x0008; |
| pub const CRED_TI_CREATE_EXPLICIT_CRED: ULONG = 0x0010; |
| pub const CRED_TI_WORKGROUP_MEMBER: ULONG = 0x0020; |
| pub const CRED_TI_VALID_FLAGS: ULONG = 0xF07F; |
| STRUCT!{struct CREDENTIAL_TARGET_INFORMATIONA { |
| TargetName: LPSTR, |
| NetbiosServerName: LPSTR, |
| DnsServerName: LPSTR, |
| NetbiosDomainName: LPSTR, |
| DnsDomainName: LPSTR, |
| DnsTreeName: LPSTR, |
| PackageName: LPSTR, |
| Flags: ULONG, |
| CredTypeCount: DWORD, |
| CredTypes: LPDWORD, |
| }} |
| pub type PCREDENTIAL_TARGET_INFORMATIONA = *mut CREDENTIAL_TARGET_INFORMATIONA; |
| STRUCT!{struct CREDENTIAL_TARGET_INFORMATIONW { |
| TargetName: LPWSTR, |
| NetbiosServerName: LPWSTR, |
| DnsServerName: LPWSTR, |
| NetbiosDomainName: LPWSTR, |
| DnsDomainName: LPWSTR, |
| DnsTreeName: LPWSTR, |
| PackageName: LPWSTR, |
| Flags: ULONG, |
| CredTypeCount: DWORD, |
| CredTypes: LPDWORD, |
| }} |
| pub type PCREDENTIAL_TARGET_INFORMATIONW = *mut CREDENTIAL_TARGET_INFORMATIONW; |
| pub const CERT_HASH_LENGTH: usize = 20; |
| STRUCT!{struct CERT_CREDENTIAL_INFO { |
| cbSize: ULONG, |
| rgbHashOfCert: [UCHAR; CERT_HASH_LENGTH], |
| }} |
| pub type PCERT_CREDENTIAL_INFO = *mut CERT_CREDENTIAL_INFO; |
| STRUCT!{struct USERNAME_TARGET_CREDENTIAL_INFO { |
| UserName: LPWSTR, |
| }} |
| pub type PUSERNAME_TARGET_CREDENTIAL_INFO = *mut USERNAME_TARGET_CREDENTIAL_INFO; |
| STRUCT!{struct BINARY_BLOB_CREDENTIAL_INFO { |
| cbBlob: ULONG, |
| pbBlob: LPBYTE, |
| }} |
| pub type PBINARY_BLOB_CREDENTIAL_INFO = *mut BINARY_BLOB_CREDENTIAL_INFO; |
| ENUM!{enum CRED_MARSHAL_TYPE { |
| CertCredential = 1, |
| UsernameTargetCredential, |
| BinaryBlobCredential, |
| UsernameForPackedCredentials, |
| }} |
| pub type PCRED_MARSHAL_TYPE = *mut CRED_MARSHAL_TYPE; |
| ENUM!{enum CRED_PROTECTION_TYPE { |
| CredUnprotected, |
| CredUserProtection, |
| CredTrustedProtection, |
| }} |
| pub type PCRED_PROTECTION_TYPE = *mut CRED_PROTECTION_TYPE; |
| pub const CRED_PACK_PROTECTED_CREDENTIALS: DWORD = 0x1; |
| pub const CRED_PACK_WOW_BUFFER: DWORD = 0x2; |
| pub const CRED_PACK_GENERIC_CREDENTIALS: DWORD = 0x4; |
| pub const CRED_PACK_ID_PROVIDER_CREDENTIALS: DWORD = 0x8; |
| STRUCT!{struct CREDUI_INFOA { |
| cbSize: DWORD, |
| hwndParent: HWND, |
| pszMessageText: PCSTR, |
| pszCaptionText: PCSTR, |
| hbmBanner: HBITMAP, |
| }} |
| pub type PCREDUI_INFOA = *mut CREDUI_INFOA; |
| STRUCT!{struct CREDUI_INFOW { |
| cbSize: DWORD, |
| hwndParent: HWND, |
| pszMessageText: PCWSTR, |
| pszCaptionText: PCWSTR, |
| hbmBanner: HBITMAP, |
| }} |
| pub type PCREDUI_INFOW = *mut CREDUI_INFOW; |
| pub const CREDUI_MAX_MESSAGE_LENGTH: DWORD = 1024; |
| pub const CREDUI_MAX_CAPTION_LENGTH: DWORD = 128; |
| pub const CREDUI_MAX_GENERIC_TARGET_LENGTH: DWORD = CRED_MAX_GENERIC_TARGET_NAME_LENGTH; |
| pub const CREDUI_MAX_DOMAIN_TARGET_LENGTH: DWORD = CRED_MAX_DOMAIN_TARGET_NAME_LENGTH; |
| pub const CREDUI_MAX_USERNAME_LENGTH: DWORD = CRED_MAX_USERNAME_LENGTH; |
| pub const CREDUI_MAX_PASSWORD_LENGTH: DWORD = 512 / 2; |
| pub const CREDUI_FLAGS_INCORRECT_PASSWORD: DWORD = 0x00001; |
| pub const CREDUI_FLAGS_DO_NOT_PERSIST: DWORD = 0x00002; |
| pub const CREDUI_FLAGS_REQUEST_ADMINISTRATOR: DWORD = 0x00004; |
| pub const CREDUI_FLAGS_EXCLUDE_CERTIFICATES: DWORD = 0x00008; |
| pub const CREDUI_FLAGS_REQUIRE_CERTIFICATE: DWORD = 0x00010; |
| pub const CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX: DWORD = 0x00040; |
| pub const CREDUI_FLAGS_ALWAYS_SHOW_UI: DWORD = 0x00080; |
| pub const CREDUI_FLAGS_REQUIRE_SMARTCARD: DWORD = 0x00100; |
| pub const CREDUI_FLAGS_PASSWORD_ONLY_OK: DWORD = 0x00200; |
| pub const CREDUI_FLAGS_VALIDATE_USERNAME: DWORD = 0x00400; |
| pub const CREDUI_FLAGS_COMPLETE_USERNAME: DWORD = 0x00800; |
| pub const CREDUI_FLAGS_PERSIST: DWORD = 0x01000; |
| pub const CREDUI_FLAGS_SERVER_CREDENTIAL: DWORD = 0x04000; |
| pub const CREDUI_FLAGS_EXPECT_CONFIRMATION: DWORD = 0x20000; |
| pub const CREDUI_FLAGS_GENERIC_CREDENTIALS: DWORD = 0x40000; |
| pub const CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS: DWORD = 0x80000; |
| pub const CREDUI_FLAGS_KEEP_USERNAME: DWORD = 0x100000; |
| pub const CREDUI_FLAGS_PROMPT_VALID: DWORD = CREDUI_FLAGS_INCORRECT_PASSWORD |
| | CREDUI_FLAGS_DO_NOT_PERSIST | CREDUI_FLAGS_REQUEST_ADMINISTRATOR |
| | CREDUI_FLAGS_EXCLUDE_CERTIFICATES | CREDUI_FLAGS_REQUIRE_CERTIFICATE |
| | CREDUI_FLAGS_SHOW_SAVE_CHECK_BOX | CREDUI_FLAGS_ALWAYS_SHOW_UI |
| | CREDUI_FLAGS_REQUIRE_SMARTCARD | CREDUI_FLAGS_PASSWORD_ONLY_OK |
| | CREDUI_FLAGS_VALIDATE_USERNAME | CREDUI_FLAGS_COMPLETE_USERNAME | CREDUI_FLAGS_PERSIST |
| | CREDUI_FLAGS_SERVER_CREDENTIAL | CREDUI_FLAGS_EXPECT_CONFIRMATION |
| | CREDUI_FLAGS_GENERIC_CREDENTIALS | CREDUI_FLAGS_USERNAME_TARGET_CREDENTIALS |
| | CREDUI_FLAGS_KEEP_USERNAME; |
| pub const CREDUIWIN_GENERIC: DWORD = 0x00000001; |
| pub const CREDUIWIN_CHECKBOX: DWORD = 0x00000002; |
| pub const CREDUIWIN_AUTHPACKAGE_ONLY: DWORD = 0x00000010; |
| pub const CREDUIWIN_IN_CRED_ONLY: DWORD = 0x00000020; |
| pub const CREDUIWIN_ENUMERATE_ADMINS: DWORD = 0x00000100; |
| pub const CREDUIWIN_ENUMERATE_CURRENT_USER: DWORD = 0x00000200; |
| pub const CREDUIWIN_SECURE_PROMPT: DWORD = 0x00001000; |
| pub const CREDUIWIN_PREPROMPTING: DWORD = 0x00002000; |
| pub const CREDUIWIN_PACK_32_WOW: DWORD = 0x10000000; |
| pub const CREDUIWIN_VALID_FLAGS: DWORD = CREDUIWIN_GENERIC | CREDUIWIN_CHECKBOX |
| | CREDUIWIN_AUTHPACKAGE_ONLY | CREDUIWIN_IN_CRED_ONLY | CREDUIWIN_ENUMERATE_ADMINS |
| | CREDUIWIN_ENUMERATE_CURRENT_USER | CREDUIWIN_SECURE_PROMPT | CREDUIWIN_PREPROMPTING |
| | CREDUIWIN_PACK_32_WOW; |
| pub const CRED_PRESERVE_CREDENTIAL_BLOB: DWORD = 0x1; |
| extern "system" { |
| pub fn CredWriteW( |
| Credential: PCREDENTIALW, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn CredWriteA( |
| Credential: PCREDENTIALA, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn CredReadW( |
| TargetName: LPCWSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| Credential: *mut PCREDENTIALW, |
| ) -> BOOL; |
| pub fn CredReadA( |
| TargetName: LPCSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| Credential: *mut PCREDENTIALA, |
| ) -> BOOL; |
| } |
| pub const CRED_ENUMERATE_ALL_CREDENTIALS: DWORD = 0x1; |
| extern "system" { |
| pub fn CredEnumerateW( |
| Filter: LPCWSTR, |
| Flags: DWORD, |
| Count: *mut DWORD, |
| Credential: *mut *mut PCREDENTIALW, |
| ) -> BOOL; |
| pub fn CredEnumerateA( |
| Filter: LPCSTR, |
| Flags: DWORD, |
| Count: *mut DWORD, |
| Credential: *mut *mut PCREDENTIALA, |
| ) -> BOOL; |
| pub fn CredWriteDomainCredentialsW( |
| TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, |
| Credential: PCREDENTIALW, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn CredWriteDomainCredentialsA( |
| TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, |
| Credential: PCREDENTIALA, |
| Flags: DWORD, |
| ) -> BOOL; |
| } |
| pub const CRED_CACHE_TARGET_INFORMATION: DWORD = 0x1; |
| extern "system" { |
| pub fn CredReadDomainCredentialsW( |
| TargetInfo: PCREDENTIAL_TARGET_INFORMATIONW, |
| Flags: DWORD, |
| Count: *mut DWORD, |
| Credential: *mut *mut PCREDENTIALW, |
| ) -> BOOL; |
| pub fn CredReadDomainCredentialsA( |
| TargetInfo: PCREDENTIAL_TARGET_INFORMATIONA, |
| Flags: DWORD, |
| Count: *mut DWORD, |
| Credential: *mut *mut PCREDENTIALA, |
| ) -> BOOL; |
| pub fn CredDeleteW( |
| TargetName: LPCWSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn CredDeleteA( |
| TargetName: LPCSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn CredRenameW( |
| OldTargetName: LPCWSTR, |
| NewTargetName: LPCWSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| ) -> BOOL; |
| pub fn CredRenameA( |
| OldTargetName: LPCSTR, |
| NewTargetName: LPCSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| ) -> BOOL; |
| } |
| pub const CRED_ALLOW_NAME_RESOLUTION: DWORD = 0x1; |
| extern "system" { |
| pub fn CredGetTargetInfoW( |
| TargetName: LPCWSTR, |
| Flags: DWORD, |
| TargetInfo: *mut PCREDENTIAL_TARGET_INFORMATIONW, |
| ) -> BOOL; |
| pub fn CredGetTargetInfoA( |
| TargetName: LPCSTR, |
| Flags: DWORD, |
| TargetInfo: *mut PCREDENTIAL_TARGET_INFORMATIONA, |
| ) -> BOOL; |
| pub fn CredMarshalCredentialW( |
| CredType: CRED_MARSHAL_TYPE, |
| Credential: PVOID, |
| MarhaledCredential: *mut LPWSTR, |
| ) -> BOOL; |
| pub fn CredMarshalCredentialA( |
| CredType: CRED_MARSHAL_TYPE, |
| Credential: PVOID, |
| MarhaledCredential: *mut LPSTR, |
| ) -> BOOL; |
| pub fn CredUnmarshalCredentialW( |
| MarshaledCredential: LPCWSTR, |
| CredType: PCRED_MARSHAL_TYPE, |
| Credential: *mut PVOID, |
| ) -> BOOL; |
| pub fn CredUnmarshalCredentialA( |
| MarshaledCredential: LPCSTR, |
| CredType: PCRED_MARSHAL_TYPE, |
| Credential: *mut PVOID, |
| ) -> BOOL; |
| pub fn CredIsMarshaledCredentialW( |
| MarshaledCredential: LPCWSTR, |
| ) -> BOOL; |
| pub fn CredIsMarshaledCredentialA( |
| MarshaledCredential: LPCSTR, |
| ) -> BOOL; |
| pub fn CredUnPackAuthenticationBufferW( |
| dwFlags: DWORD, |
| pAuthBuffer: PVOID, |
| cbAuthBuffer: DWORD, |
| pszUserName: LPWSTR, |
| pcchlMaxUserName: *mut DWORD, |
| pszDomainName: LPWSTR, |
| pcchMaxDomainName: *mut DWORD, |
| pszPassword: LPWSTR, |
| pcchMaxPassword: *mut DWORD, |
| ) -> BOOL; |
| pub fn CredUnPackAuthenticationBufferA( |
| dwFlags: DWORD, |
| pAuthBuffer: PVOID, |
| cbAuthBuffer: DWORD, |
| pszUserName: LPSTR, |
| pcchlMaxUserName: *mut DWORD, |
| pszDomainName: LPSTR, |
| pcchMaxDomainName: *mut DWORD, |
| pszPassword: LPSTR, |
| pcchMaxPassword: *mut DWORD, |
| ) -> BOOL; |
| pub fn CredPackAuthenticationBufferW( |
| dwFlags: DWORD, |
| pszUserName: LPWSTR, |
| pszPassword: LPWSTR, |
| pPackedCredentials: PBYTE, |
| pcbPackedCredentials: *mut DWORD, |
| ) -> BOOL; |
| pub fn CredPackAuthenticationBufferA( |
| dwFlags: DWORD, |
| pszUserName: LPSTR, |
| pszPassword: LPSTR, |
| pPackedCredentials: PBYTE, |
| pcbPackedCredentials: *mut DWORD, |
| ) -> BOOL; |
| pub fn CredProtectW( |
| fAsSelf: BOOL, |
| pszCredentials: LPWSTR, |
| cchCredentials: DWORD, |
| pszProtectedCredentials: LPWSTR, |
| pcchMaxChars: *mut DWORD, |
| ProtectionType: *mut CRED_PROTECTION_TYPE, |
| ) -> BOOL; |
| pub fn CredProtectA( |
| fAsSelf: BOOL, |
| pszCredentials: LPSTR, |
| cchCredentials: DWORD, |
| pszProtectedCredentials: LPSTR, |
| pcchMaxChars: *mut DWORD, |
| ProtectionType: *mut CRED_PROTECTION_TYPE, |
| ) -> BOOL; |
| pub fn CredUnprotectW( |
| fAsSelf: BOOL, |
| pszProtectedCredentials: LPWSTR, |
| cchCredentials: DWORD, |
| pszCredentials: LPWSTR, |
| pcchMaxChars: *mut DWORD, |
| ) -> BOOL; |
| pub fn CredUnprotectA( |
| fAsSelf: BOOL, |
| pszProtectedCredentials: LPSTR, |
| cchCredentials: DWORD, |
| pszCredentials: LPSTR, |
| pcchMaxChars: *mut DWORD, |
| ) -> BOOL; |
| pub fn CredIsProtectedW( |
| pszProtectedCredentials: LPWSTR, |
| pProtectionType: *mut CRED_PROTECTION_TYPE, |
| ) -> BOOL; |
| pub fn CredIsProtectedA( |
| pszProtectedCredentials: LPSTR, |
| pProtectionType: *mut CRED_PROTECTION_TYPE, |
| ) -> BOOL; |
| pub fn CredFindBestCredentialW( |
| TargetName: LPCWSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| Credential: *mut PCREDENTIALW, |
| ) -> BOOL; |
| pub fn CredFindBestCredentialA( |
| TargetName: LPCSTR, |
| Type: DWORD, |
| Flags: DWORD, |
| Credential: *mut PCREDENTIALA, |
| ) -> BOOL; |
| pub fn CredGetSessionTypes( |
| MaximumPersistCount: DWORD, |
| MaximumPersist: LPDWORD, |
| ) -> BOOL; |
| pub fn CredFree( |
| Buffer: PVOID, |
| ); |
| pub fn CredUIPromptForCredentialsW( |
| pUiInfo: PCREDUI_INFOW, |
| pszTargetName: PCWSTR, |
| pContext: PCtxtHandle, |
| dwAuthError: DWORD, |
| pszUserName: PWSTR, |
| ulUserNameBufferSize: ULONG, |
| pszPassword: PWSTR, |
| ulPasswordBufferSize: ULONG, |
| save: *mut BOOL, |
| dwFlags: DWORD, |
| ) -> DWORD; |
| pub fn CredUIPromptForCredentialsA( |
| pUiInfo: PCREDUI_INFOA, |
| pszTargetName: PCSTR, |
| pContext: PCtxtHandle, |
| dwAuthError: DWORD, |
| pszUserName: PSTR, |
| ulUserNameBufferSize: ULONG, |
| pszPassword: PSTR, |
| ulPasswordBufferSize: ULONG, |
| save: *mut BOOL, |
| dwFlags: DWORD, |
| ) -> DWORD; |
| pub fn CredUIPromptForWindowsCredentialsW( |
| pUiInfo: PCREDUI_INFOW, |
| dwAuthError: DWORD, |
| pulAuthPackage: *mut ULONG, |
| pvInAuthBuffer: LPCVOID, |
| ulInAuthBufferSize: ULONG, |
| ppvOutAuthBuffer: *mut LPVOID, |
| pulOutAuthBufferSize: *mut ULONG, |
| pfSave: *mut BOOL, |
| dwFlags: DWORD, |
| ) -> DWORD; |
| pub fn CredUIPromptForWindowsCredentialsA( |
| pUiInfo: PCREDUI_INFOA, |
| dwAuthError: DWORD, |
| pulAuthPackage: *mut ULONG, |
| pvInAuthBuffer: LPCVOID, |
| ulInAuthBufferSize: ULONG, |
| ppvOutAuthBuffer: *mut LPVOID, |
| pulOutAuthBufferSize: *mut ULONG, |
| pfSave: *mut BOOL, |
| dwFlags: DWORD, |
| ) -> DWORD; |
| pub fn CredUIParseUserNameW( |
| userName: PCWSTR, |
| user: *mut WCHAR, |
| userBufferSize: ULONG, |
| domain: *mut WCHAR, |
| domainBufferSize: ULONG, |
| ) -> DWORD; |
| pub fn CredUIParseUserNameA( |
| userName: PCSTR, |
| user: *mut CHAR, |
| userBufferSize: ULONG, |
| domain: *mut CHAR, |
| domainBufferSize: ULONG, |
| ) -> DWORD; |
| pub fn CredUICmdLinePromptForCredentialsW( |
| pszTargetName: PCWSTR, |
| pContext: PCtxtHandle, |
| dwAuthError: DWORD, |
| UserName: PWSTR, |
| ulUserBufferSize: ULONG, |
| pszPassword: PWSTR, |
| ulPasswordBufferSize: ULONG, |
| pfSave: PBOOL, |
| dwFlags: DWORD, |
| ) -> DWORD; |
| pub fn CredUICmdLinePromptForCredentialsA( |
| pszTargetName: PCSTR, |
| pContext: PCtxtHandle, |
| dwAuthError: DWORD, |
| UserName: PSTR, |
| ulUserBufferSize: ULONG, |
| pszPassword: PSTR, |
| ulPasswordBufferSize: ULONG, |
| pfSave: PBOOL, |
| dwFlags: DWORD, |
| ) -> DWORD; |
| pub fn CredUIConfirmCredentialsW( |
| pszTargetName: PCWSTR, |
| bConfirm: BOOL, |
| ) -> DWORD; |
| pub fn CredUIConfirmCredentialsA( |
| pszTargetName: PCSTR, |
| bConfirm: BOOL, |
| ) -> DWORD; |
| pub fn CredUIStoreSSOCredW( |
| pszRealm: PCWSTR, |
| pszUsername: PCWSTR, |
| pszPassword: PCWSTR, |
| bPersist: BOOL, |
| ) -> DWORD; |
| pub fn CredUIReadSSOCredW( |
| pszRealm: PCWSTR, |
| ppszUsername: *mut PWSTR, |
| ) -> DWORD; |
| } |
