From 6247a8f4940bbc46d93b6d2421ed62f664cc3c92 Mon Sep 17 00:00:00 2001 From: Daniel Keep Date: Mon, 7 Nov 2016 12:29:52 +1100 Subject: [PATCH] Add wininet.h bindings. This also includes a single definition from winineti.h, and a list of symbols dumped from wininet.dll that *aren't* in wininet.h. Includes the wininet.dll import libs for MinGW. --- Cargo.toml | 8 +- build.rs | 1 + i686/lib/libwininet.a | Bin 0 -> 188324 bytes src/um/mod.rs | 2 + src/um/wininet.rs | 2328 +++++++++++++++++++++++++++++++++++++++ src/um/winineti.rs | 146 +++ tests/structs.rs | 212 ++++ x86_64/lib/libwininet.a | Bin 0 -> 175246 bytes 8 files changed, 2696 insertions(+), 1 deletion(-) create mode 100644 i686/lib/libwininet.a create mode 100644 src/um/wininet.rs create mode 100644 src/um/winineti.rs create mode 100644 x86_64/lib/libwininet.a diff --git a/Cargo.toml b/Cargo.toml index 68c971440..18c3f5792 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -74,6 +74,8 @@ headers = ["headers-shared", "headers-um", "headers-vc", "headers-winrt"] "um-wincon", "um-winevt", "um-wingdi", + "um-wininet", + "um-winineti", "um-winioctl", "um-winnt", "um-winreg", @@ -96,6 +98,8 @@ headers = ["headers-shared", "headers-um", "headers-vc", "headers-winrt"] "um-winevt" = ["shared-minwindef", "um-winnt"] "um-wingdi" = ["shared-basetsd", "shared-minwindef", "shared-windef", "um-winnt"] "um-winioctl" = ["shared-minwindef", "um-winnt"] +"um-wininet" = ["shared-basetsd", "shared-minwindef", "shared-ntdef", "shared-windef", "um-minwinbase", "um-winineti", "um-winnt", "wininet"] +"um-winineti" = ["shared-minwindef"] "um-winnt" = ["shared-basetsd", "shared-guiddef", "shared-minwindef", "vc-excpt"] "um-winreg" = ["shared-basetsd", "shared-minwindef", "um-winnt"] "um-winuser" = ["shared-basetsd", "shared-minwindef", "shared-windef", "um-wingdi", "um-winnt"] @@ -117,8 +121,10 @@ headers = ["headers-shared", "headers-um", "headers-vc", "headers-winrt"] libraries = [ "kernel32", "ncrypt", - "ole32" + "ole32", + "wininet", ] "kernel32" = [] "ole32" = [] "ncrypt" = [] +"wininet" = [] diff --git a/build.rs b/build.rs index 10b79d944..b2e697d2c 100644 --- a/build.rs +++ b/build.rs @@ -9,6 +9,7 @@ const LIBS: &'static [&'static str] = &[ "kernel32", "ncrypt", "ole32", + "wininet", ]; fn main() { let target = var("TARGET").unwrap(); diff --git a/i686/lib/libwininet.a b/i686/lib/libwininet.a new file mode 100644 index 0000000000000000000000000000000000000000..dd468f3b878b7b02bda1d084e87e1a07deaf2ba7 GIT binary patch literal 188324 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 literal 0 HcmV?d00001 diff --git a/src/um/mod.rs b/src/um/mod.rs index 71240ad22..6c025d292 100644 --- a/src/um/mod.rs +++ b/src/um/mod.rs @@ -21,6 +21,8 @@ #[cfg(feature = "um-winevt")] pub mod winevt; #[cfg(feature = "um-wingdi")] pub mod wingdi; #[cfg(feature = "um-winioctl")] pub mod winioctl; +#[cfg(feature = "um-wininet")] pub mod wininet; +#[cfg(feature = "um-winineti")] pub mod winineti; #[cfg(feature = "um-winnt")] pub mod winnt; #[cfg(feature = "um-winreg")] pub mod winreg; #[cfg(feature = "um-winuser")] pub mod winuser; diff --git a/src/um/wininet.rs b/src/um/wininet.rs new file mode 100644 index 000000000..4f7ed7651 --- /dev/null +++ b/src/um/wininet.rs @@ -0,0 +1,2328 @@ +// Copyright © 2016 winapi-rs developers +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +//! Windows Internet Services API procedure declarations, types and constants. +use ctypes::c_int; +use shared::basetsd::DWORD_PTR; +use shared::minwindef::{ + BOOL, DWORD, FALSE, FILETIME, INT, LPBYTE, + LPCVOID, LPDWORD, LPVOID, PBYTE, PDWORD, TRUE, WORD, +}; +use shared::ntdef::{ LONG, LONGLONG, PLONG }; +use shared::windef::HWND; +use um::minwinbase::{ LPWIN32_FIND_DATAA, LPWIN32_FIND_DATAW, SYSTEMTIME }; +use um::winineti::INTERNET_FLAG_BGUPDATE; +use um::winnt::{ + CHAR, DWORDLONG, HANDLE, LPCSTR, LPCWSTR, + LPSTR, LPWSTR, PCWSTR, PSTR, PWSTR, WCHAR, +}; + +pub type HINTERNET = LPVOID; +pub type LPHINTERNET = *mut HINTERNET; +pub type INTERNET_PORT = WORD; +pub type LPINTERNET_PORT = *mut INTERNET_PORT; +pub const INTERNET_INVALID_PORT_NUMBER: DWORD = 0; +pub const INTERNET_DEFAULT_FTP_PORT: DWORD = 21; +pub const INTERNET_DEFAULT_GOPHER_PORT: DWORD = 70; +pub const INTERNET_DEFAULT_HTTP_PORT: DWORD = 80; +pub const INTERNET_DEFAULT_HTTPS_PORT: DWORD = 443; +pub const INTERNET_DEFAULT_SOCKS_PORT: DWORD = 1080; +pub const INTERNET_MAX_HOST_NAME_LENGTH: DWORD = 256; +pub const INTERNET_MAX_USER_NAME_LENGTH: DWORD = 128; +pub const INTERNET_MAX_PASSWORD_LENGTH: DWORD = 128; +pub const INTERNET_MAX_PORT_NUMBER_LENGTH: DWORD = 5; +pub const INTERNET_MAX_PORT_NUMBER_VALUE: DWORD = 65535; +pub const INTERNET_MAX_PATH_LENGTH: DWORD = 2048; +pub const INTERNET_MAX_SCHEME_LENGTH: DWORD = 32; +pub const INTERNET_MAX_URL_LENGTH: DWORD = INTERNET_MAX_SCHEME_LENGTH + 3 + + INTERNET_MAX_PATH_LENGTH; +pub const INTERNET_KEEP_ALIVE_UNKNOWN: DWORD = -1i32 as u32; +pub const INTERNET_KEEP_ALIVE_ENABLED: DWORD = 1; +pub const INTERNET_KEEP_ALIVE_DISABLED: DWORD = 0; +pub const INTERNET_REQFLAG_FROM_CACHE: DWORD = 0x00000001; +pub const INTERNET_REQFLAG_ASYNC: DWORD = 0x00000002; +pub const INTERNET_REQFLAG_VIA_PROXY: DWORD = 0x00000004; +pub const INTERNET_REQFLAG_NO_HEADERS: DWORD = 0x00000008; +pub const INTERNET_REQFLAG_PASSIVE: DWORD = 0x00000010; +pub const INTERNET_REQFLAG_CACHE_WRITE_DISABLED: DWORD = 0x00000040; +pub const INTERNET_REQFLAG_NET_TIMEOUT: DWORD = 0x00000080; +pub const INTERNET_FLAG_IDN_DIRECT: DWORD = 0x00000001; +pub const INTERNET_FLAG_IDN_PROXY: DWORD = 0x00000002; +pub const INTERNET_FLAG_RELOAD: DWORD = 0x80000000; +pub const INTERNET_FLAG_RAW_DATA: DWORD = 0x40000000; +pub const INTERNET_FLAG_EXISTING_CONNECT: DWORD = 0x20000000; +pub const INTERNET_FLAG_ASYNC: DWORD = 0x10000000; +pub const INTERNET_FLAG_PASSIVE: DWORD = 0x08000000; +pub const INTERNET_FLAG_NO_CACHE_WRITE: DWORD = 0x04000000; +pub const INTERNET_FLAG_DONT_CACHE: DWORD = INTERNET_FLAG_NO_CACHE_WRITE; +pub const INTERNET_FLAG_MAKE_PERSISTENT: DWORD = 0x02000000; +pub const INTERNET_FLAG_FROM_CACHE: DWORD = 0x01000000; +pub const INTERNET_FLAG_OFFLINE: DWORD = INTERNET_FLAG_FROM_CACHE; +pub const INTERNET_FLAG_SECURE: DWORD = 0x00800000; +pub const INTERNET_FLAG_KEEP_CONNECTION: DWORD = 0x00400000; +pub const INTERNET_FLAG_NO_AUTO_REDIRECT: DWORD = 0x00200000; +pub const INTERNET_FLAG_READ_PREFETCH: DWORD = 0x00100000; +pub const INTERNET_FLAG_NO_COOKIES: DWORD = 0x00080000; +pub const INTERNET_FLAG_NO_AUTH: DWORD = 0x00040000; +pub const INTERNET_FLAG_RESTRICTED_ZONE: DWORD = 0x00020000; +pub const INTERNET_FLAG_CACHE_IF_NET_FAIL: DWORD = 0x00010000; +pub const INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP: DWORD = 0x00008000; +pub const INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS: DWORD = 0x00004000; +pub const INTERNET_FLAG_IGNORE_CERT_DATE_INVALID: DWORD = 0x00002000; +pub const INTERNET_FLAG_IGNORE_CERT_CN_INVALID: DWORD = 0x00001000; +pub const INTERNET_FLAG_RESYNCHRONIZE: DWORD = 0x00000800; +pub const INTERNET_FLAG_HYPERLINK: DWORD = 0x00000400; +pub const INTERNET_FLAG_NO_UI: DWORD = 0x00000200; +pub const INTERNET_FLAG_PRAGMA_NOCACHE: DWORD = 0x00000100; +pub const INTERNET_FLAG_CACHE_ASYNC: DWORD = 0x00000080; +pub const INTERNET_FLAG_FORMS_SUBMIT: DWORD = 0x00000040; +pub const INTERNET_FLAG_FWD_BACK: DWORD = 0x00000020; +pub const INTERNET_FLAG_NEED_FILE: DWORD = 0x00000010; +pub const INTERNET_FLAG_MUST_CACHE_REQUEST: DWORD = INTERNET_FLAG_NEED_FILE; +pub const INTERNET_FLAG_TRANSFER_ASCII: DWORD = FTP_TRANSFER_TYPE_ASCII; +pub const INTERNET_FLAG_TRANSFER_BINARY: DWORD = FTP_TRANSFER_TYPE_BINARY; +pub const SECURITY_INTERNET_MASK: DWORD = INTERNET_FLAG_IGNORE_CERT_CN_INVALID + | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID | INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS + | INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP; +pub const SECURITY_IGNORE_ERROR_MASK: DWORD = INTERNET_FLAG_IGNORE_CERT_CN_INVALID + | INTERNET_FLAG_IGNORE_CERT_DATE_INVALID | SECURITY_FLAG_IGNORE_UNKNOWN_CA + | SECURITY_FLAG_IGNORE_REVOCATION; +pub const INTERNET_FLAGS_MASK: DWORD = INTERNET_FLAG_RELOAD | INTERNET_FLAG_RAW_DATA + | INTERNET_FLAG_EXISTING_CONNECT | INTERNET_FLAG_ASYNC | INTERNET_FLAG_PASSIVE + | INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_MAKE_PERSISTENT | INTERNET_FLAG_FROM_CACHE + | INTERNET_FLAG_SECURE | INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_NO_AUTO_REDIRECT + | INTERNET_FLAG_READ_PREFETCH | INTERNET_FLAG_NO_COOKIES | INTERNET_FLAG_NO_AUTH + | INTERNET_FLAG_CACHE_IF_NET_FAIL | SECURITY_INTERNET_MASK | INTERNET_FLAG_RESYNCHRONIZE + | INTERNET_FLAG_HYPERLINK | INTERNET_FLAG_NO_UI | INTERNET_FLAG_PRAGMA_NOCACHE + | INTERNET_FLAG_CACHE_ASYNC | INTERNET_FLAG_FORMS_SUBMIT | INTERNET_FLAG_NEED_FILE + | INTERNET_FLAG_RESTRICTED_ZONE | INTERNET_FLAG_TRANSFER_BINARY | INTERNET_FLAG_TRANSFER_ASCII + | INTERNET_FLAG_FWD_BACK | INTERNET_FLAG_BGUPDATE; +pub const INTERNET_ERROR_MASK_INSERT_CDROM: DWORD = 0x1; +pub const INTERNET_ERROR_MASK_COMBINED_SEC_CERT: DWORD = 0x2; +pub const INTERNET_ERROR_MASK_NEED_MSN_SSPI_PKG: DWORD = 0x4; +pub const INTERNET_ERROR_MASK_LOGIN_FAILURE_DISPLAY_ENTITY_BODY: DWORD = 0x8; +pub const INTERNET_OPTIONS_MASK: DWORD = !INTERNET_FLAGS_MASK; +pub const WININET_API_FLAG_ASYNC: DWORD = 0x00000001; +pub const WININET_API_FLAG_SYNC: DWORD = 0x00000004; +pub const WININET_API_FLAG_USE_CONTEXT: DWORD = 0x00000008; +pub const INTERNET_NO_CALLBACK: DWORD = 0; +ENUM!{enum INTERNET_SCHEME { + INTERNET_SCHEME_PARTIAL = -2i32 as u32, + INTERNET_SCHEME_UNKNOWN = -1i32 as u32, + INTERNET_SCHEME_DEFAULT = 0, + INTERNET_SCHEME_FTP, + INTERNET_SCHEME_GOPHER, + INTERNET_SCHEME_HTTP, + INTERNET_SCHEME_HTTPS, + INTERNET_SCHEME_FILE, + INTERNET_SCHEME_NEWS, + INTERNET_SCHEME_MAILTO, + INTERNET_SCHEME_SOCKS, + INTERNET_SCHEME_JAVASCRIPT, + INTERNET_SCHEME_VBSCRIPT, + INTERNET_SCHEME_RES, + INTERNET_SCHEME_FIRST = INTERNET_SCHEME_FTP, + INTERNET_SCHEME_LAST = INTERNET_SCHEME_RES, +}} +pub type LPINTERNET_SCHEME = *mut INTERNET_SCHEME; +STRUCT!{struct INTERNET_ASYNC_RESULT { + dwResult: DWORD_PTR, + dwError: DWORD, +}} +pub type LPINTERNET_ASYNC_RESULT = *mut INTERNET_ASYNC_RESULT; +STRUCT!{struct INTERNET_DIAGNOSTIC_SOCKET_INFO { + Socket: DWORD_PTR, + SourcePort: DWORD, + DestPort: DWORD, + Flags: DWORD, +}} +pub type LPINTERNET_DIAGNOSTIC_SOCKET_INFO = *mut INTERNET_DIAGNOSTIC_SOCKET_INFO; +pub const IDSI_FLAG_KEEP_ALIVE: DWORD = 0x00000001; +pub const IDSI_FLAG_SECURE: DWORD = 0x00000002; +pub const IDSI_FLAG_PROXY: DWORD = 0x00000004; +pub const IDSI_FLAG_TUNNEL: DWORD = 0x00000008; +STRUCT!{struct INTERNET_PROXY_INFO { + dwAccessType: DWORD, + lpszProxy: LPCWSTR, + lpszProxyBypass: LPCWSTR, +}} +pub type LPINTERNET_PROXY_INFO = *mut INTERNET_PROXY_INFO; +#[cfg(target_arch = "x86")] +STRUCT!{struct INTERNET_PER_CONN_OPTIONA { + dwOption: DWORD, + Value: [usize; 2], +}} +#[cfg(target_arch = "x86_64")] +STRUCT!{struct INTERNET_PER_CONN_OPTIONA { + dwOption: DWORD, + Value: [usize; 1], +}} +UNION!(INTERNET_PER_CONN_OPTIONA, Value, dwValue, dwValue_mut, DWORD); +UNION!(INTERNET_PER_CONN_OPTIONA, Value, pszValue, pszValue_mut, LPSTR); +UNION!(INTERNET_PER_CONN_OPTIONA, Value, ftValue, ftValue_mut, FILETIME); +pub type LPINTERNET_PER_CONN_OPTIONA = *mut INTERNET_PER_CONN_OPTIONA; +#[cfg(target_arch = "x86")] +STRUCT!{struct INTERNET_PER_CONN_OPTIONW { + dwOption: DWORD, + Value: [usize; 2], +}} +#[cfg(target_arch = "x86_64")] +STRUCT!{struct INTERNET_PER_CONN_OPTIONW { + dwOption: DWORD, + Value: [usize; 1], +}} +UNION!(INTERNET_PER_CONN_OPTIONW, Value, dwValue, dwValue_mut, DWORD); +UNION!(INTERNET_PER_CONN_OPTIONW, Value, pszValue, pszValue_mut, LPWSTR); +UNION!(INTERNET_PER_CONN_OPTIONW, Value, ftValue, ftValue_mut, FILETIME); +pub type LPINTERNET_PER_CONN_OPTIONW = *mut INTERNET_PER_CONN_OPTIONW; +STRUCT!{struct INTERNET_PER_CONN_OPTION_LISTA { + dwSize: DWORD, + pszConnection: LPSTR, + dwOptionCount: DWORD, + dwOptionError: DWORD, + pOptions: LPINTERNET_PER_CONN_OPTIONA, +}} +pub type LPINTERNET_PER_CONN_OPTION_LISTA = *mut INTERNET_PER_CONN_OPTION_LISTA; +STRUCT!{struct INTERNET_PER_CONN_OPTION_LISTW { + dwSize: DWORD, + pszConnection: LPWSTR, + dwOptionCount: DWORD, + dwOptionError: DWORD, + pOptions: LPINTERNET_PER_CONN_OPTIONW, +}} +pub type LPINTERNET_PER_CONN_OPTION_LISTW = *mut INTERNET_PER_CONN_OPTION_LISTW; +pub const INTERNET_PER_CONN_FLAGS: DWORD = 1; +pub const INTERNET_PER_CONN_PROXY_SERVER: DWORD = 2; +pub const INTERNET_PER_CONN_PROXY_BYPASS: DWORD = 3; +pub const INTERNET_PER_CONN_AUTOCONFIG_URL: DWORD = 4; +pub const INTERNET_PER_CONN_AUTODISCOVERY_FLAGS: DWORD = 5; +pub const INTERNET_PER_CONN_AUTOCONFIG_SECONDARY_URL: DWORD = 6; +pub const INTERNET_PER_CONN_AUTOCONFIG_RELOAD_DELAY_MINS: DWORD = 7; +pub const INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_TIME: DWORD = 8; +pub const INTERNET_PER_CONN_AUTOCONFIG_LAST_DETECT_URL: DWORD = 9; +pub const INTERNET_PER_CONN_FLAGS_UI: DWORD = 10; +pub const PROXY_TYPE_DIRECT: DWORD = 0x00000001; +pub const PROXY_TYPE_PROXY: DWORD = 0x00000002; +pub const PROXY_TYPE_AUTO_PROXY_URL: DWORD = 0x00000004; +pub const PROXY_TYPE_AUTO_DETECT: DWORD = 0x00000008; +pub const AUTO_PROXY_FLAG_USER_SET: DWORD = 0x00000001; +pub const AUTO_PROXY_FLAG_ALWAYS_DETECT: DWORD = 0x00000002; +pub const AUTO_PROXY_FLAG_DETECTION_RUN: DWORD = 0x00000004; +pub const AUTO_PROXY_FLAG_MIGRATED: DWORD = 0x00000008; +pub const AUTO_PROXY_FLAG_DONT_CACHE_PROXY_RESULT: DWORD = 0x00000010; +pub const AUTO_PROXY_FLAG_CACHE_INIT_RUN: DWORD = 0x00000020; +pub const AUTO_PROXY_FLAG_DETECTION_SUSPECT: DWORD = 0x00000040; +STRUCT!{struct INTERNET_VERSION_INFO { + dwMajorVersion: DWORD, + dwMinorVersion: DWORD, +}} +pub type LPINTERNET_VERSION_INFO = *mut INTERNET_VERSION_INFO; +STRUCT!{struct HTTP_VERSION_INFO { + dwMajorVersion: DWORD, + dwMinorVersion: DWORD, +}} +pub type LPHTTP_VERSION_INFO = *mut HTTP_VERSION_INFO; +STRUCT!{struct INTERNET_CONNECTED_INFO { + dwConnectedState: DWORD, + dwFlags: DWORD, +}} +pub type LPINTERNET_CONNECTED_INFO = *mut INTERNET_CONNECTED_INFO; +pub const ISO_FORCE_DISCONNECTED: DWORD = 0x00000001; +STRUCT!{struct URL_COMPONENTSA { + dwStructSize: DWORD, + lpszScheme: LPSTR, + dwSchemeLength: DWORD, + nScheme: INTERNET_SCHEME, + lpszHostName: LPSTR, + dwHostNameLength: DWORD, + nPort: INTERNET_PORT, + lpszUserName: LPSTR, + dwUserNameLength: DWORD, + lpszPassword: LPSTR, + dwPasswordLength: DWORD, + lpszUrlPath: LPSTR, + dwUrlPathLength: DWORD, + lpszExtraInfo: LPSTR, + dwExtraInfoLength: DWORD, +}} +pub type LPURL_COMPONENTSA = *mut URL_COMPONENTSA; +STRUCT!{struct URL_COMPONENTSW { + dwStructSize: DWORD, + lpszScheme: LPWSTR, + dwSchemeLength: DWORD, + nScheme: INTERNET_SCHEME, + lpszHostName: LPWSTR, + dwHostNameLength: DWORD, + nPort: INTERNET_PORT, + lpszUserName: LPWSTR, + dwUserNameLength: DWORD, + lpszPassword: LPWSTR, + dwPasswordLength: DWORD, + lpszUrlPath: LPWSTR, + dwUrlPathLength: DWORD, + lpszExtraInfo: LPWSTR, + dwExtraInfoLength: DWORD, +}} +pub type LPURL_COMPONENTSW = *mut URL_COMPONENTSW; +STRUCT!{struct INTERNET_CERTIFICATE_INFO { + ftExpiry: FILETIME, + ftStart: FILETIME, + lpszSubjectInfo: LPWSTR, + lpszIssuerInfo: LPWSTR, + lpszProtocolName: LPWSTR, + lpszSignatureAlgName: LPWSTR, + lpszEncryptionAlgName: LPWSTR, + dwKeySize: DWORD, +}} +pub type LPINTERNET_CERTIFICATE_INFO = *mut INTERNET_CERTIFICATE_INFO; +STRUCT!{struct INTERNET_BUFFERSA { + dwStructSize: DWORD, + Next: *mut INTERNET_BUFFERSA, + lpcszHeader: LPCSTR, + dwHeadersLength: DWORD, + dwHeadersTotal: DWORD, + lpvBuffer: LPVOID, + dwBufferLength: DWORD, + dwBufferTotal: DWORD, + dwOffsetLow: DWORD, + dwOffsetHigh: DWORD, +}} +pub type LPINTERNET_BUFFERSA = *mut INTERNET_BUFFERSA; +STRUCT!{struct INTERNET_BUFFERSW { + dwStructSize: DWORD, + Next: *mut INTERNET_BUFFERSW, + lpcszHeader: LPCWSTR, + dwHeadersLength: DWORD, + dwHeadersTotal: DWORD, + lpvBuffer: LPVOID, + dwBufferLength: DWORD, + dwBufferTotal: DWORD, + dwOffsetLow: DWORD, + dwOffsetHigh: DWORD, +}} +pub type LPINTERNET_BUFFERSW = *mut INTERNET_BUFFERSW; +pub const INTERNET_RFC1123_FORMAT: DWORD = 0; +pub const INTERNET_RFC1123_BUFSIZE: DWORD = 30; +pub const ICU_ESCAPE: DWORD = 0x80000000; +pub const ICU_USERNAME: DWORD = 0x40000000; +pub const ICU_NO_ENCODE: DWORD = 0x20000000; +pub const ICU_DECODE: DWORD = 0x10000000; +pub const ICU_NO_META: DWORD = 0x08000000; +pub const ICU_ENCODE_SPACES_ONLY: DWORD = 0x04000000; +pub const ICU_BROWSER_MODE: DWORD = 0x02000000; +pub const ICU_ENCODE_PERCENT: DWORD = 0x00001000; +pub const INTERNET_OPEN_TYPE_PRECONFIG: DWORD = 0; +pub const INTERNET_OPEN_TYPE_DIRECT: DWORD = 1; +pub const INTERNET_OPEN_TYPE_PROXY: DWORD = 3; +pub const INTERNET_OPEN_TYPE_PRECONFIG_WITH_NO_AUTOPROXY: DWORD = 4; +pub const PRE_CONFIG_INTERNET_ACCESS: DWORD = INTERNET_OPEN_TYPE_PRECONFIG; +pub const LOCAL_INTERNET_ACCESS: DWORD = INTERNET_OPEN_TYPE_DIRECT; +pub const CERN_PROXY_INTERNET_ACCESS: DWORD = INTERNET_OPEN_TYPE_PROXY; +pub const INTERNET_SERVICE_FTP: DWORD = 1; +pub const INTERNET_SERVICE_GOPHER: DWORD = 2; +pub const INTERNET_SERVICE_HTTP: DWORD = 3; +pub const IRF_ASYNC: DWORD = WININET_API_FLAG_ASYNC; +pub const IRF_SYNC: DWORD = WININET_API_FLAG_SYNC; +pub const IRF_USE_CONTEXT: DWORD = WININET_API_FLAG_USE_CONTEXT; +pub const IRF_NO_WAIT: DWORD = 0x00000008; +pub const ISO_GLOBAL: DWORD = 0x00000001; +pub const ISO_REGISTRY: DWORD = 0x00000002; +pub const ISO_VALID_FLAGS: DWORD = ISO_GLOBAL | ISO_REGISTRY; +pub const INTERNET_OPTION_CALLBACK: DWORD = 1; +pub const INTERNET_OPTION_CONNECT_TIMEOUT: DWORD = 2; +pub const INTERNET_OPTION_CONNECT_RETRIES: DWORD = 3; +pub const INTERNET_OPTION_CONNECT_BACKOFF: DWORD = 4; +pub const INTERNET_OPTION_SEND_TIMEOUT: DWORD = 5; +pub const INTERNET_OPTION_CONTROL_SEND_TIMEOUT: DWORD = INTERNET_OPTION_SEND_TIMEOUT; +pub const INTERNET_OPTION_RECEIVE_TIMEOUT: DWORD = 6; +pub const INTERNET_OPTION_CONTROL_RECEIVE_TIMEOUT: DWORD = INTERNET_OPTION_RECEIVE_TIMEOUT; +pub const INTERNET_OPTION_DATA_SEND_TIMEOUT: DWORD = 7; +pub const INTERNET_OPTION_DATA_RECEIVE_TIMEOUT: DWORD = 8; +pub const INTERNET_OPTION_HANDLE_TYPE: DWORD = 9; +pub const INTERNET_OPTION_LISTEN_TIMEOUT: DWORD = 11; +pub const INTERNET_OPTION_READ_BUFFER_SIZE: DWORD = 12; +pub const INTERNET_OPTION_WRITE_BUFFER_SIZE: DWORD = 13; +pub const INTERNET_OPTION_ASYNC_ID: DWORD = 15; +pub const INTERNET_OPTION_ASYNC_PRIORITY: DWORD = 16; +pub const INTERNET_OPTION_PARENT_HANDLE: DWORD = 21; +pub const INTERNET_OPTION_KEEP_CONNECTION: DWORD = 22; +pub const INTERNET_OPTION_REQUEST_FLAGS: DWORD = 23; +pub const INTERNET_OPTION_EXTENDED_ERROR: DWORD = 24; +pub const INTERNET_OPTION_OFFLINE_MODE: DWORD = 26; +pub const INTERNET_OPTION_CACHE_STREAM_HANDLE: DWORD = 27; +pub const INTERNET_OPTION_USERNAME: DWORD = 28; +pub const INTERNET_OPTION_PASSWORD: DWORD = 29; +pub const INTERNET_OPTION_ASYNC: DWORD = 30; +pub const INTERNET_OPTION_SECURITY_FLAGS: DWORD = 31; +pub const INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT: DWORD = 32; +pub const INTERNET_OPTION_DATAFILE_NAME: DWORD = 33; +pub const INTERNET_OPTION_URL: DWORD = 34; +pub const INTERNET_OPTION_SECURITY_CERTIFICATE: DWORD = 35; +pub const INTERNET_OPTION_SECURITY_KEY_BITNESS: DWORD = 36; +pub const INTERNET_OPTION_REFRESH: DWORD = 37; +pub const INTERNET_OPTION_PROXY: DWORD = 38; +pub const INTERNET_OPTION_SETTINGS_CHANGED: DWORD = 39; +pub const INTERNET_OPTION_VERSION: DWORD = 40; +pub const INTERNET_OPTION_USER_AGENT: DWORD = 41; +pub const INTERNET_OPTION_END_BROWSER_SESSION: DWORD = 42; +pub const INTERNET_OPTION_PROXY_USERNAME: DWORD = 43; +pub const INTERNET_OPTION_PROXY_PASSWORD: DWORD = 44; +pub const INTERNET_OPTION_CONTEXT_VALUE: DWORD = 45; +pub const INTERNET_OPTION_CONNECT_LIMIT: DWORD = 46; +pub const INTERNET_OPTION_SECURITY_SELECT_CLIENT_CERT: DWORD = 47; +pub const INTERNET_OPTION_POLICY: DWORD = 48; +pub const INTERNET_OPTION_DISCONNECTED_TIMEOUT: DWORD = 49; +pub const INTERNET_OPTION_CONNECTED_STATE: DWORD = 50; +pub const INTERNET_OPTION_IDLE_STATE: DWORD = 51; +pub const INTERNET_OPTION_OFFLINE_SEMANTICS: DWORD = 52; +pub const INTERNET_OPTION_SECONDARY_CACHE_KEY: DWORD = 53; +pub const INTERNET_OPTION_CALLBACK_FILTER: DWORD = 54; +pub const INTERNET_OPTION_CONNECT_TIME: DWORD = 55; +pub const INTERNET_OPTION_SEND_THROUGHPUT: DWORD = 56; +pub const INTERNET_OPTION_RECEIVE_THROUGHPUT: DWORD = 57; +pub const INTERNET_OPTION_REQUEST_PRIORITY: DWORD = 58; +pub const INTERNET_OPTION_HTTP_VERSION: DWORD = 59; +pub const INTERNET_OPTION_RESET_URLCACHE_SESSION: DWORD = 60; +pub const INTERNET_OPTION_ERROR_MASK: DWORD = 62; +pub const INTERNET_OPTION_FROM_CACHE_TIMEOUT: DWORD = 63; +pub const INTERNET_OPTION_BYPASS_EDITED_ENTRY: DWORD = 64; +pub const INTERNET_OPTION_HTTP_DECODING: DWORD = 65; +pub const INTERNET_OPTION_DIAGNOSTIC_SOCKET_INFO: DWORD = 67; +pub const INTERNET_OPTION_CODEPAGE: DWORD = 68; +pub const INTERNET_OPTION_CACHE_TIMESTAMPS: DWORD = 69; +pub const INTERNET_OPTION_DISABLE_AUTODIAL: DWORD = 70; +pub const INTERNET_OPTION_MAX_CONNS_PER_SERVER: DWORD = 73; +pub const INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER: DWORD = 74; +pub const INTERNET_OPTION_PER_CONNECTION_OPTION: DWORD = 75; +pub const INTERNET_OPTION_DIGEST_AUTH_UNLOAD: DWORD = 76; +pub const INTERNET_OPTION_IGNORE_OFFLINE: DWORD = 77; +pub const INTERNET_OPTION_IDENTITY: DWORD = 78; +pub const INTERNET_OPTION_REMOVE_IDENTITY: DWORD = 79; +pub const INTERNET_OPTION_ALTER_IDENTITY: DWORD = 80; +pub const INTERNET_OPTION_SUPPRESS_BEHAVIOR: DWORD = 81; +pub const INTERNET_OPTION_AUTODIAL_MODE: DWORD = 82; +pub const INTERNET_OPTION_AUTODIAL_CONNECTION: DWORD = 83; +pub const INTERNET_OPTION_CLIENT_CERT_CONTEXT: DWORD = 84; +pub const INTERNET_OPTION_AUTH_FLAGS: DWORD = 85; +pub const INTERNET_OPTION_COOKIES_3RD_PARTY: DWORD = 86; +pub const INTERNET_OPTION_DISABLE_PASSPORT_AUTH: DWORD = 87; +pub const INTERNET_OPTION_SEND_UTF8_SERVERNAME_TO_PROXY: DWORD = 88; +pub const INTERNET_OPTION_EXEMPT_CONNECTION_LIMIT: DWORD = 89; +pub const INTERNET_OPTION_ENABLE_PASSPORT_AUTH: DWORD = 90; +pub const INTERNET_OPTION_HIBERNATE_INACTIVE_WORKER_THREADS: DWORD = 91; +pub const INTERNET_OPTION_ACTIVATE_WORKER_THREADS: DWORD = 92; +pub const INTERNET_OPTION_RESTORE_WORKER_THREAD_DEFAULTS: DWORD = 93; +pub const INTERNET_OPTION_SOCKET_SEND_BUFFER_LENGTH: DWORD = 94; +pub const INTERNET_OPTION_PROXY_SETTINGS_CHANGED: DWORD = 95; +pub const INTERNET_OPTION_DATAFILE_EXT: DWORD = 96; +pub const INTERNET_OPTION_CODEPAGE_PATH: DWORD = 100; +pub const INTERNET_OPTION_CODEPAGE_EXTRA: DWORD = 101; +pub const INTERNET_OPTION_IDN: DWORD = 102; +pub const INTERNET_OPTION_MAX_CONNS_PER_PROXY: DWORD = 103; +pub const INTERNET_OPTION_SUPPRESS_SERVER_AUTH: DWORD = 104; +pub const INTERNET_OPTION_SERVER_CERT_CHAIN_CONTEXT: DWORD = 105; +pub const INTERNET_OPTION_ENABLE_REDIRECT_CACHE_READ: DWORD = 122; +pub const INTERNET_OPTION_ENCODE_EXTRA: DWORD = 155; +pub const INTERNET_FIRST_OPTION: DWORD = INTERNET_OPTION_CALLBACK; +pub const INTERNET_LAST_OPTION: DWORD = INTERNET_OPTION_ENCODE_EXTRA; +pub const INTERNET_PRIORITY_FOREGROUND: DWORD = 1000; +pub const INTERNET_HANDLE_TYPE_INTERNET: DWORD = 1; +pub const INTERNET_HANDLE_TYPE_CONNECT_FTP: DWORD = 2; +pub const INTERNET_HANDLE_TYPE_CONNECT_GOPHER: DWORD = 3; +pub const INTERNET_HANDLE_TYPE_CONNECT_HTTP: DWORD = 4; +pub const INTERNET_HANDLE_TYPE_FTP_FIND: DWORD = 5; +pub const INTERNET_HANDLE_TYPE_FTP_FIND_HTML: DWORD = 6; +pub const INTERNET_HANDLE_TYPE_FTP_FILE: DWORD = 7; +pub const INTERNET_HANDLE_TYPE_FTP_FILE_HTML: DWORD = 8; +pub const INTERNET_HANDLE_TYPE_GOPHER_FIND: DWORD = 9; +pub const INTERNET_HANDLE_TYPE_GOPHER_FIND_HTML: DWORD = 10; +pub const INTERNET_HANDLE_TYPE_GOPHER_FILE: DWORD = 11; +pub const INTERNET_HANDLE_TYPE_GOPHER_FILE_HTML: DWORD = 12; +pub const INTERNET_HANDLE_TYPE_HTTP_REQUEST: DWORD = 13; +pub const INTERNET_HANDLE_TYPE_FILE_REQUEST: DWORD = 14; +pub const AUTH_FLAG_DISABLE_NEGOTIATE: DWORD = 0x00000001; +pub const AUTH_FLAG_ENABLE_NEGOTIATE: DWORD = 0x00000002; +pub const AUTH_FLAG_DISABLE_BASIC_CLEARCHANNEL: DWORD = 0x00000004; +pub const AUTH_FLAG_DISABLE_SERVER_AUTH: DWORD = 0x00000008; +pub const SECURITY_FLAG_SECURE: DWORD = 0x00000001; +pub const SECURITY_FLAG_STRENGTH_WEAK: DWORD = 0x10000000; +pub const SECURITY_FLAG_STRENGTH_MEDIUM: DWORD = 0x40000000; +pub const SECURITY_FLAG_STRENGTH_STRONG: DWORD = 0x20000000; +pub const SECURITY_FLAG_UNKNOWNBIT: DWORD = 0x80000000; +pub const SECURITY_FLAG_FORTEZZA: DWORD = 0x08000000; +pub const SECURITY_FLAG_NORMALBITNESS: DWORD = SECURITY_FLAG_STRENGTH_WEAK; +pub const SECURITY_FLAG_SSL: DWORD = 0x00000002; +pub const SECURITY_FLAG_SSL3: DWORD = 0x00000004; +pub const SECURITY_FLAG_PCT: DWORD = 0x00000008; +pub const SECURITY_FLAG_PCT4: DWORD = 0x00000010; +pub const SECURITY_FLAG_IETFSSL4: DWORD = 0x00000020; +pub const SECURITY_FLAG_40BIT: DWORD = SECURITY_FLAG_STRENGTH_WEAK; +pub const SECURITY_FLAG_128BIT: DWORD = SECURITY_FLAG_STRENGTH_STRONG; +pub const SECURITY_FLAG_56BIT: DWORD = SECURITY_FLAG_STRENGTH_MEDIUM; +pub const SECURITY_FLAG_IGNORE_REVOCATION: DWORD = 0x00000080; +pub const SECURITY_FLAG_IGNORE_UNKNOWN_CA: DWORD = 0x00000100; +pub const SECURITY_FLAG_IGNORE_WRONG_USAGE: DWORD = 0x00000200; +pub const SECURITY_FLAG_IGNORE_CERT_CN_INVALID: DWORD = INTERNET_FLAG_IGNORE_CERT_CN_INVALID; +pub const SECURITY_FLAG_IGNORE_CERT_DATE_INVALID: DWORD = INTERNET_FLAG_IGNORE_CERT_DATE_INVALID; +pub const SECURITY_FLAG_IGNORE_REDIRECT_TO_HTTPS: DWORD = INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTPS; +pub const SECURITY_FLAG_IGNORE_REDIRECT_TO_HTTP: DWORD = INTERNET_FLAG_IGNORE_REDIRECT_TO_HTTP; +pub const SECURITY_SET_MASK: DWORD = SECURITY_FLAG_IGNORE_REVOCATION + | SECURITY_FLAG_IGNORE_UNKNOWN_CA | SECURITY_FLAG_IGNORE_CERT_CN_INVALID + | SECURITY_FLAG_IGNORE_CERT_DATE_INVALID | SECURITY_FLAG_IGNORE_WRONG_USAGE; +pub const AUTODIAL_MODE_NEVER: DWORD = 1; +pub const AUTODIAL_MODE_ALWAYS: DWORD = 2; +pub const AUTODIAL_MODE_NO_NETWORK_PRESENT: DWORD = 4; +FN!{stdcall INTERNET_STATUS_CALLBACK( + HINTERNET, DWORD_PTR, DWORD, LPVOID, DWORD +) -> ()} +pub type LPINTERNET_STATUS_CALLBACK = *mut INTERNET_STATUS_CALLBACK; +pub const INTERNET_STATUS_RESOLVING_NAME: DWORD = 10; +pub const INTERNET_STATUS_NAME_RESOLVED: DWORD = 11; +pub const INTERNET_STATUS_CONNECTING_TO_SERVER: DWORD = 20; +pub const INTERNET_STATUS_CONNECTED_TO_SERVER: DWORD = 21; +pub const INTERNET_STATUS_SENDING_REQUEST: DWORD = 30; +pub const INTERNET_STATUS_REQUEST_SENT: DWORD = 31; +pub const INTERNET_STATUS_RECEIVING_RESPONSE: DWORD = 40; +pub const INTERNET_STATUS_RESPONSE_RECEIVED: DWORD = 41; +pub const INTERNET_STATUS_CTL_RESPONSE_RECEIVED: DWORD = 42; +pub const INTERNET_STATUS_PREFETCH: DWORD = 43; +pub const INTERNET_STATUS_CLOSING_CONNECTION: DWORD = 50; +pub const INTERNET_STATUS_CONNECTION_CLOSED: DWORD = 51; +pub const INTERNET_STATUS_HANDLE_CREATED: DWORD = 60; +pub const INTERNET_STATUS_HANDLE_CLOSING: DWORD = 70; +pub const INTERNET_STATUS_DETECTING_PROXY: DWORD = 80; +pub const INTERNET_STATUS_REQUEST_COMPLETE: DWORD = 100; +pub const INTERNET_STATUS_REDIRECT: DWORD = 110; +pub const INTERNET_STATUS_INTERMEDIATE_RESPONSE: DWORD = 120; +pub const INTERNET_STATUS_USER_INPUT_REQUIRED: DWORD = 140; +pub const INTERNET_STATUS_STATE_CHANGE: DWORD = 200; +pub const INTERNET_STATUS_COOKIE_SENT: DWORD = 320; +pub const INTERNET_STATUS_COOKIE_RECEIVED: DWORD = 321; +pub const INTERNET_STATUS_PRIVACY_IMPACTED: DWORD = 324; +pub const INTERNET_STATUS_P3P_HEADER: DWORD = 325; +pub const INTERNET_STATUS_P3P_POLICYREF: DWORD = 326; +pub const INTERNET_STATUS_COOKIE_HISTORY: DWORD = 327; +pub const INTERNET_STATE_CONNECTED: DWORD = 0x00000001; +pub const INTERNET_STATE_DISCONNECTED: DWORD = 0x00000002; +pub const INTERNET_STATE_DISCONNECTED_BY_USER: DWORD = 0x00000010; +pub const INTERNET_STATE_IDLE: DWORD = 0x00000100; +pub const INTERNET_STATE_BUSY: DWORD = 0x00000200; +ENUM!{enum InternetCookieState { + COOKIE_STATE_UNKNOWN = 0x0, + COOKIE_STATE_ACCEPT = 0x1, + COOKIE_STATE_PROMPT = 0x2, + COOKIE_STATE_LEASH = 0x3, + COOKIE_STATE_DOWNGRADE = 0x4, + COOKIE_STATE_REJECT = 0x5, + COOKIE_STATE_MAX = COOKIE_STATE_REJECT, +}} +STRUCT!{struct IncomingCookieState { + cSession: c_int, + cPersistent: c_int, + cAccepted: c_int, + cLeashed: c_int, + cDowngraded: c_int, + cBlocked: c_int, + pszLocation: LPCSTR, +}} +STRUCT!{struct OutgoingCookieState { + cSent: c_int, + cSuppressed: c_int, + pszLocation: LPCSTR, +}} +STRUCT!{struct InternetCookieHistory { + fAccepted: BOOL, + fLeashed: BOOL, + fDowngraded: BOOL, + fRejected: BOOL, +}} +STRUCT!{struct CookieDecision { + dwCookieState: DWORD, + fAllowSession: BOOL, +}} +pub const INTERNET_INVALID_STATUS_CALLBACK: usize = -1isize as usize; +pub const FTP_TRANSFER_TYPE_UNKNOWN: DWORD = 0x00000000; +pub const FTP_TRANSFER_TYPE_ASCII: DWORD = 0x00000001; +pub const FTP_TRANSFER_TYPE_BINARY: DWORD = 0x00000002; +pub const FTP_TRANSFER_TYPE_MASK: DWORD = FTP_TRANSFER_TYPE_ASCII | FTP_TRANSFER_TYPE_BINARY; +pub const MAX_GOPHER_DISPLAY_TEXT: DWORD = 128; +pub const MAX_GOPHER_SELECTOR_TEXT: DWORD = 256; +pub const MAX_GOPHER_HOST_NAME: DWORD = INTERNET_MAX_HOST_NAME_LENGTH; +pub const MAX_GOPHER_LOCATOR_LENGTH: DWORD = 1 + MAX_GOPHER_DISPLAY_TEXT + 1 + + MAX_GOPHER_SELECTOR_TEXT + 1 + MAX_GOPHER_HOST_NAME + 1 + INTERNET_MAX_PORT_NUMBER_LENGTH + + 1 + 1 + 2; +STRUCT!{struct GOPHER_FIND_DATAA { + DisplayString: [CHAR; MAX_GOPHER_DISPLAY_TEXT as usize + 1], + GopherType: DWORD, + SizeLow: DWORD, + SizeHigh: DWORD, + LastModificationTime: FILETIME, + Locator: [CHAR; MAX_GOPHER_LOCATOR_LENGTH as usize + 1], +}} +pub type LPGOPHER_FIND_DATAA = *mut GOPHER_FIND_DATAA; +STRUCT!{struct GOPHER_FIND_DATAW { + DisplayString: [WCHAR; MAX_GOPHER_DISPLAY_TEXT as usize + 1], + GopherType: DWORD, + SizeLow: DWORD, + SizeHigh: DWORD, + LastModificationTime: FILETIME, + Locator: [WCHAR; MAX_GOPHER_LOCATOR_LENGTH as usize + 1], +}} +pub type LPGOPHER_FIND_DATAW = *mut GOPHER_FIND_DATAW; +pub const GOPHER_TYPE_TEXT_FILE: DWORD = 0x00000001; +pub const GOPHER_TYPE_DIRECTORY: DWORD = 0x00000002; +pub const GOPHER_TYPE_CSO: DWORD = 0x00000004; +pub const GOPHER_TYPE_ERROR: DWORD = 0x00000008; +pub const GOPHER_TYPE_MAC_BINHEX: DWORD = 0x00000010; +pub const GOPHER_TYPE_DOS_ARCHIVE: DWORD = 0x00000020; +pub const GOPHER_TYPE_UNIX_UUENCODED: DWORD = 0x00000040; +pub const GOPHER_TYPE_INDEX_SERVER: DWORD = 0x00000080; +pub const GOPHER_TYPE_TELNET: DWORD = 0x00000100; +pub const GOPHER_TYPE_BINARY: DWORD = 0x00000200; +pub const GOPHER_TYPE_REDUNDANT: DWORD = 0x00000400; +pub const GOPHER_TYPE_TN3270: DWORD = 0x00000800; +pub const GOPHER_TYPE_GIF: DWORD = 0x00001000; +pub const GOPHER_TYPE_IMAGE: DWORD = 0x00002000; +pub const GOPHER_TYPE_BITMAP: DWORD = 0x00004000; +pub const GOPHER_TYPE_MOVIE: DWORD = 0x00008000; +pub const GOPHER_TYPE_SOUND: DWORD = 0x00010000; +pub const GOPHER_TYPE_HTML: DWORD = 0x00020000; +pub const GOPHER_TYPE_PDF: DWORD = 0x00040000; +pub const GOPHER_TYPE_CALENDAR: DWORD = 0x00080000; +pub const GOPHER_TYPE_INLINE: DWORD = 0x00100000; +pub const GOPHER_TYPE_UNKNOWN: DWORD = 0x20000000; +pub const GOPHER_TYPE_ASK: DWORD = 0x40000000; +pub const GOPHER_TYPE_GOPHER_PLUS: DWORD = 0x80000000; +#[inline] +pub fn IS_GOPHER_FILE(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_FILE_MASK) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_DIRECTORY(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_DIRECTORY) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_PHONE_SERVER(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_CSO) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_ERROR(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_ERROR) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_INDEX_SERVER(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_INDEX_SERVER) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_TELNET_SESSION(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_TELNET) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_BACKUP_SERVER(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_REDUNDANT) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_TN3270_SESSION(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_TN3270) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_ASK(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_ASK) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_PLUS(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_GOPHER_PLUS) != 0 { TRUE } else { FALSE } +} +#[inline] +pub fn IS_GOPHER_TYPE_KNOWN(type_: DWORD) -> BOOL { + if (type_ & GOPHER_TYPE_UNKNOWN) != 0 { FALSE } else { TRUE } +} +pub const GOPHER_TYPE_FILE_MASK: DWORD = GOPHER_TYPE_TEXT_FILE | GOPHER_TYPE_MAC_BINHEX + | GOPHER_TYPE_DOS_ARCHIVE | GOPHER_TYPE_UNIX_UUENCODED | GOPHER_TYPE_BINARY | GOPHER_TYPE_GIF + | GOPHER_TYPE_IMAGE | GOPHER_TYPE_BITMAP | GOPHER_TYPE_MOVIE | GOPHER_TYPE_SOUND + | GOPHER_TYPE_HTML | GOPHER_TYPE_PDF | GOPHER_TYPE_CALENDAR | GOPHER_TYPE_INLINE; +STRUCT!{struct GOPHER_ADMIN_ATTRIBUTE_TYPE { + Comment: LPCWSTR, + EmailAddress: LPCWSTR, +}} +pub type LPGOPHER_ADMIN_ATTRIBUTE_TYPE = *mut GOPHER_ADMIN_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_MOD_DATE_ATTRIBUTE_TYPE { + DateAndTime: FILETIME, +}} +pub type LPGOPHER_MOD_DATE_ATTRIBUTE_TYPE = *mut GOPHER_MOD_DATE_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_TTL_ATTRIBUTE_TYPE { + Ttl: DWORD, +}} +pub type LPGOPHER_TTL_ATTRIBUTE_TYPE = *mut GOPHER_TTL_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_SCORE_ATTRIBUTE_TYPE { + Score: INT, +}} +pub type LPGOPHER_SCORE_ATTRIBUTE_TYPE = *mut GOPHER_SCORE_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE { + LowerBound: INT, + UpperBound: INT, +}} +pub type LPGOPHER_SCORE_RANGE_ATTRIBUTE_TYPE = *mut GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_SITE_ATTRIBUTE_TYPE { + Site: LPCWSTR, +}} +pub type LPGOPHER_SITE_ATTRIBUTE_TYPE = *mut GOPHER_SITE_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_ORGANIZATION_ATTRIBUTE_TYPE { + Organization: LPCWSTR, +}} +pub type LPGOPHER_ORGANIZATION_ATTRIBUTE_TYPE = *mut GOPHER_ORGANIZATION_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_LOCATION_ATTRIBUTE_TYPE { + Location: LPCWSTR, +}} +pub type LPGOPHER_LOCATION_ATTRIBUTE_TYPE = *mut GOPHER_LOCATION_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE { + DegreesNorth: INT, + MinutesNorth: INT, + SecondsNorth: INT, + DegreesEast: INT, + MinutesEast: INT, + SecondsEast: INT, +}} +pub type LPGOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE = + *mut GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_TIMEZONE_ATTRIBUTE_TYPE { + Zone: INT, +}} +pub type LPGOPHER_TIMEZONE_ATTRIBUTE_TYPE = *mut GOPHER_TIMEZONE_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_PROVIDER_ATTRIBUTE_TYPE { + Provider: LPCWSTR, +}} +pub type LPGOPHER_PROVIDER_ATTRIBUTE_TYPE = *mut GOPHER_PROVIDER_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_VERSION_ATTRIBUTE_TYPE { + Version: LPCWSTR, +}} +pub type LPGOPHER_VERSION_ATTRIBUTE_TYPE = *mut GOPHER_VERSION_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_ABSTRACT_ATTRIBUTE_TYPE { + ShortAbstract: LPCWSTR, + AbstractFile: LPCWSTR, +}} +pub type LPGOPHER_ABSTRACT_ATTRIBUTE_TYPE = *mut GOPHER_ABSTRACT_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_VIEW_ATTRIBUTE_TYPE { + ContentType: LPCWSTR, + Language: LPCWSTR, + Size: DWORD, +}} +pub type LPGOPHER_VIEW_ATTRIBUTE_TYPE = *mut GOPHER_VIEW_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_VERONICA_ATTRIBUTE_TYPE { + TreeWalk: BOOL, +}} +pub type LPGOPHER_VERONICA_ATTRIBUTE_TYPE = *mut GOPHER_VERONICA_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_ASK_ATTRIBUTE_TYPE { + QuestionType: LPCWSTR, + QuestionText: LPCWSTR, +}} +pub type LPGOPHER_ASK_ATTRIBUTE_TYPE = *mut GOPHER_ASK_ATTRIBUTE_TYPE; +STRUCT!{struct GOPHER_UNKNOWN_ATTRIBUTE_TYPE { + Text: LPCWSTR, +}} +pub type LPGOPHER_UNKNOWN_ATTRIBUTE_TYPE = *mut GOPHER_UNKNOWN_ATTRIBUTE_TYPE; +#[cfg(target_arch = "x86")] +STRUCT!{struct GOPHER_ATTRIBUTE_TYPE { + CategoryId: DWORD, + AttributeId: DWORD, + AttributeType: [u32; 6], +}} +#[cfg(target_arch = "x86_64")] +STRUCT!{struct GOPHER_ATTRIBUTE_TYPE { + CategoryId: DWORD, + AttributeId: DWORD, + AttributeType: [u64; 3], +}} +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Admin, Admin_mut, GOPHER_ADMIN_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, ModDate, ModDate_mut, GOPHER_MOD_DATE_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Ttl, Ttl_mut, GOPHER_TTL_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Score, Score_mut, GOPHER_SCORE_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, ScoreRange, ScoreRange_mut, + GOPHER_SCORE_RANGE_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Site, Site_mut, GOPHER_SITE_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Organization, Organization_mut, + GOPHER_ORGANIZATION_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Location, Location_mut, + GOPHER_LOCATION_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, GeographicalLocation, GeographicalLocation_mut, + GOPHER_GEOGRAPHICAL_LOCATION_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, TimeZone, TimeZone_mut, + GOPHER_TIMEZONE_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Provider, Provider_mut, + GOPHER_PROVIDER_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Version, Version_mut, GOPHER_VERSION_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Abstract, Abstract_mut, + GOPHER_ABSTRACT_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, View, View_mut, GOPHER_VIEW_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Veronica, Veronica_mut, + GOPHER_VERONICA_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Ask, Ask_mut, GOPHER_ASK_ATTRIBUTE_TYPE); +UNION!(GOPHER_ATTRIBUTE_TYPE, AttributeType, Unknown, Unknown_mut, GOPHER_UNKNOWN_ATTRIBUTE_TYPE); +pub type LPGOPHER_ATTRIBUTE_TYPE = *mut GOPHER_ATTRIBUTE_TYPE; +pub const MAX_GOPHER_CATEGORY_NAME: DWORD = 128; +pub const MAX_GOPHER_ATTRIBUTE_NAME: DWORD = 128; +pub const MIN_GOPHER_ATTRIBUTE_LENGTH: DWORD = 256; +pub const GOPHER_INFO_CATEGORY: &'static str = " + INFO"; +pub const GOPHER_ADMIN_CATEGORY: &'static str = " + ADMIN"; +pub const GOPHER_VIEWS_CATEGORY: &'static str = " + VIEWS"; +pub const GOPHER_ABSTRACT_CATEGORY: &'static str = " + ABSTRACT"; +pub const GOPHER_VERONICA_CATEGORY: &'static str = " + VERONICA"; +pub const GOPHER_ADMIN_ATTRIBUTE: &'static str = "Admin"; +pub const GOPHER_MOD_DATE_ATTRIBUTE: &'static str = "Mod-Date"; +pub const GOPHER_TTL_ATTRIBUTE: &'static str = "TTL"; +pub const GOPHER_SCORE_ATTRIBUTE: &'static str = "Score"; +pub const GOPHER_RANGE_ATTRIBUTE: &'static str = "Score-range"; +pub const GOPHER_SITE_ATTRIBUTE: &'static str = "Site"; +pub const GOPHER_ORG_ATTRIBUTE: &'static str = "Org"; +pub const GOPHER_LOCATION_ATTRIBUTE: &'static str = "Loc"; +pub const GOPHER_GEOG_ATTRIBUTE: &'static str = "Geog"; +pub const GOPHER_TIMEZONE_ATTRIBUTE: &'static str = "TZ"; +pub const GOPHER_PROVIDER_ATTRIBUTE: &'static str = "Provider"; +pub const GOPHER_VERSION_ATTRIBUTE: &'static str = "Version"; +pub const GOPHER_ABSTRACT_ATTRIBUTE: &'static str = "Abstract"; +pub const GOPHER_VIEW_ATTRIBUTE: &'static str = "View"; +pub const GOPHER_TREEWALK_ATTRIBUTE: &'static str = "treewalk"; +pub const GOPHER_ATTRIBUTE_ID_BASE: DWORD = 0xabcccc00; +pub const GOPHER_CATEGORY_ID_ALL: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 1; +pub const GOPHER_CATEGORY_ID_INFO: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 2; +pub const GOPHER_CATEGORY_ID_ADMIN: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 3; +pub const GOPHER_CATEGORY_ID_VIEWS: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 4; +pub const GOPHER_CATEGORY_ID_ABSTRACT: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 5; +pub const GOPHER_CATEGORY_ID_VERONICA: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 6; +pub const GOPHER_CATEGORY_ID_ASK: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 7; +pub const GOPHER_CATEGORY_ID_UNKNOWN: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 8; +pub const GOPHER_ATTRIBUTE_ID_ALL: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 9; +pub const GOPHER_ATTRIBUTE_ID_ADMIN: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 10; +pub const GOPHER_ATTRIBUTE_ID_MOD_DATE: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 11; +pub const GOPHER_ATTRIBUTE_ID_TTL: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 12; +pub const GOPHER_ATTRIBUTE_ID_SCORE: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 13; +pub const GOPHER_ATTRIBUTE_ID_RANGE: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 14; +pub const GOPHER_ATTRIBUTE_ID_SITE: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 15; +pub const GOPHER_ATTRIBUTE_ID_ORG: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 16; +pub const GOPHER_ATTRIBUTE_ID_LOCATION: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 17; +pub const GOPHER_ATTRIBUTE_ID_GEOG: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 18; +pub const GOPHER_ATTRIBUTE_ID_TIMEZONE: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 19; +pub const GOPHER_ATTRIBUTE_ID_PROVIDER: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 20; +pub const GOPHER_ATTRIBUTE_ID_VERSION: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 21; +pub const GOPHER_ATTRIBUTE_ID_ABSTRACT: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 22; +pub const GOPHER_ATTRIBUTE_ID_VIEW: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 23; +pub const GOPHER_ATTRIBUTE_ID_TREEWALK: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 24; +pub const GOPHER_ATTRIBUTE_ID_UNKNOWN: DWORD = GOPHER_ATTRIBUTE_ID_BASE + 25; +FN!{stdcall GOPHER_ATTRIBUTE_ENUMERATOR( + LPGOPHER_ATTRIBUTE_TYPE, DWORD +) -> BOOL} +pub const HTTP_MAJOR_VERSION: DWORD = 1; +pub const HTTP_MINOR_VERSION: DWORD = 0; +pub const HTTP_VERSION: &'static str = "HTTP/1.0"; +pub const HTTP_QUERY_MIME_VERSION: DWORD = 0; +pub const HTTP_QUERY_CONTENT_TYPE: DWORD = 1; +pub const HTTP_QUERY_CONTENT_TRANSFER_ENCODING: DWORD = 2; +pub const HTTP_QUERY_CONTENT_ID: DWORD = 3; +pub const HTTP_QUERY_CONTENT_DESCRIPTION: DWORD = 4; +pub const HTTP_QUERY_CONTENT_LENGTH: DWORD = 5; +pub const HTTP_QUERY_CONTENT_LANGUAGE: DWORD = 6; +pub const HTTP_QUERY_ALLOW: DWORD = 7; +pub const HTTP_QUERY_PUBLIC: DWORD = 8; +pub const HTTP_QUERY_DATE: DWORD = 9; +pub const HTTP_QUERY_EXPIRES: DWORD = 10; +pub const HTTP_QUERY_LAST_MODIFIED: DWORD = 11; +pub const HTTP_QUERY_MESSAGE_ID: DWORD = 12; +pub const HTTP_QUERY_URI: DWORD = 13; +pub const HTTP_QUERY_DERIVED_FROM: DWORD = 14; +pub const HTTP_QUERY_COST: DWORD = 15; +pub const HTTP_QUERY_LINK: DWORD = 16; +pub const HTTP_QUERY_PRAGMA: DWORD = 17; +pub const HTTP_QUERY_VERSION: DWORD = 18; +pub const HTTP_QUERY_STATUS_CODE: DWORD = 19; +pub const HTTP_QUERY_STATUS_TEXT: DWORD = 20; +pub const HTTP_QUERY_RAW_HEADERS: DWORD = 21; +pub const HTTP_QUERY_RAW_HEADERS_CRLF: DWORD = 22; +pub const HTTP_QUERY_CONNECTION: DWORD = 23; +pub const HTTP_QUERY_ACCEPT: DWORD = 24; +pub const HTTP_QUERY_ACCEPT_CHARSET: DWORD = 25; +pub const HTTP_QUERY_ACCEPT_ENCODING: DWORD = 26; +pub const HTTP_QUERY_ACCEPT_LANGUAGE: DWORD = 27; +pub const HTTP_QUERY_AUTHORIZATION: DWORD = 28; +pub const HTTP_QUERY_CONTENT_ENCODING: DWORD = 29; +pub const HTTP_QUERY_FORWARDED: DWORD = 30; +pub const HTTP_QUERY_FROM: DWORD = 31; +pub const HTTP_QUERY_IF_MODIFIED_SINCE: DWORD = 32; +pub const HTTP_QUERY_LOCATION: DWORD = 33; +pub const HTTP_QUERY_ORIG_URI: DWORD = 34; +pub const HTTP_QUERY_REFERER: DWORD = 35; +pub const HTTP_QUERY_RETRY_AFTER: DWORD = 36; +pub const HTTP_QUERY_SERVER: DWORD = 37; +pub const HTTP_QUERY_TITLE: DWORD = 38; +pub const HTTP_QUERY_USER_AGENT: DWORD = 39; +pub const HTTP_QUERY_WWW_AUTHENTICATE: DWORD = 40; +pub const HTTP_QUERY_PROXY_AUTHENTICATE: DWORD = 41; +pub const HTTP_QUERY_ACCEPT_RANGES: DWORD = 42; +pub const HTTP_QUERY_SET_COOKIE: DWORD = 43; +pub const HTTP_QUERY_COOKIE: DWORD = 44; +pub const HTTP_QUERY_REQUEST_METHOD: DWORD = 45; +pub const HTTP_QUERY_REFRESH: DWORD = 46; +pub const HTTP_QUERY_CONTENT_DISPOSITION: DWORD = 47; +pub const HTTP_QUERY_AGE: DWORD = 48; +pub const HTTP_QUERY_CACHE_CONTROL: DWORD = 49; +pub const HTTP_QUERY_CONTENT_BASE: DWORD = 50; +pub const HTTP_QUERY_CONTENT_LOCATION: DWORD = 51; +pub const HTTP_QUERY_CONTENT_MD5: DWORD = 52; +pub const HTTP_QUERY_CONTENT_RANGE: DWORD = 53; +pub const HTTP_QUERY_ETAG: DWORD = 54; +pub const HTTP_QUERY_HOST: DWORD = 55; +pub const HTTP_QUERY_IF_MATCH: DWORD = 56; +pub const HTTP_QUERY_IF_NONE_MATCH: DWORD = 57; +pub const HTTP_QUERY_IF_RANGE: DWORD = 58; +pub const HTTP_QUERY_IF_UNMODIFIED_SINCE: DWORD = 59; +pub const HTTP_QUERY_MAX_FORWARDS: DWORD = 60; +pub const HTTP_QUERY_PROXY_AUTHORIZATION: DWORD = 61; +pub const HTTP_QUERY_RANGE: DWORD = 62; +pub const HTTP_QUERY_TRANSFER_ENCODING: DWORD = 63; +pub const HTTP_QUERY_UPGRADE: DWORD = 64; +pub const HTTP_QUERY_VARY: DWORD = 65; +pub const HTTP_QUERY_VIA: DWORD = 66; +pub const HTTP_QUERY_WARNING: DWORD = 67; +pub const HTTP_QUERY_EXPECT: DWORD = 68; +pub const HTTP_QUERY_PROXY_CONNECTION: DWORD = 69; +pub const HTTP_QUERY_UNLESS_MODIFIED_SINCE: DWORD = 70; +pub const HTTP_QUERY_ECHO_REQUEST: DWORD = 71; +pub const HTTP_QUERY_ECHO_REPLY: DWORD = 72; +pub const HTTP_QUERY_ECHO_HEADERS: DWORD = 73; +pub const HTTP_QUERY_ECHO_HEADERS_CRLF: DWORD = 74; +pub const HTTP_QUERY_PROXY_SUPPORT: DWORD = 75; +pub const HTTP_QUERY_AUTHENTICATION_INFO: DWORD = 76; +pub const HTTP_QUERY_PASSPORT_URLS: DWORD = 77; +pub const HTTP_QUERY_PASSPORT_CONFIG: DWORD = 78; +pub const HTTP_QUERY_X_CONTENT_TYPE_OPTIONS: DWORD = 79; +pub const HTTP_QUERY_P3P: DWORD = 80; +pub const HTTP_QUERY_X_P2P_PEERDIST: DWORD = 81; +pub const HTTP_QUERY_TRANSLATE: DWORD = 82; +pub const HTTP_QUERY_X_UA_COMPATIBLE: DWORD = 83; +pub const HTTP_QUERY_DEFAULT_STYLE: DWORD = 84; +pub const HTTP_QUERY_X_FRAME_OPTIONS: DWORD = 85; +pub const HTTP_QUERY_X_XSS_PROTECTION: DWORD = 86; +pub const HTTP_QUERY_SET_COOKIE2: DWORD = 87; +pub const HTTP_QUERY_DO_NOT_TRACK: DWORD = 88; +pub const HTTP_QUERY_KEEP_ALIVE: DWORD = 89; +pub const HTTP_QUERY_MAX: DWORD = 89; +pub const HTTP_QUERY_CUSTOM: DWORD = 65535; +pub const HTTP_QUERY_FLAG_REQUEST_HEADERS: DWORD = 0x80000000; +pub const HTTP_QUERY_FLAG_SYSTEMTIME: DWORD = 0x40000000; +pub const HTTP_QUERY_FLAG_NUMBER: DWORD = 0x20000000; +pub const HTTP_QUERY_FLAG_COALESCE: DWORD = 0x10000000; +pub const HTTP_QUERY_FLAG_NUMBER64: DWORD = 0x08000000; +pub const HTTP_QUERY_MODIFIER_FLAGS_MASK: DWORD = HTTP_QUERY_FLAG_REQUEST_HEADERS + | HTTP_QUERY_FLAG_SYSTEMTIME | HTTP_QUERY_FLAG_NUMBER | HTTP_QUERY_FLAG_COALESCE + | HTTP_QUERY_FLAG_NUMBER64; +pub const HTTP_QUERY_HEADER_MASK: DWORD = !HTTP_QUERY_MODIFIER_FLAGS_MASK; +pub const HTTP_STATUS_CONTINUE: DWORD = 100; +pub const HTTP_STATUS_SWITCH_PROTOCOLS: DWORD = 101; +pub const HTTP_STATUS_OK: DWORD = 200; +pub const HTTP_STATUS_CREATED: DWORD = 201; +pub const HTTP_STATUS_ACCEPTED: DWORD = 202; +pub const HTTP_STATUS_PARTIAL: DWORD = 203; +pub const HTTP_STATUS_NO_CONTENT: DWORD = 204; +pub const HTTP_STATUS_RESET_CONTENT: DWORD = 205; +pub const HTTP_STATUS_PARTIAL_CONTENT: DWORD = 206; +pub const HTTP_STATUS_AMBIGUOUS: DWORD = 300; +pub const HTTP_STATUS_MOVED: DWORD = 301; +pub const HTTP_STATUS_REDIRECT: DWORD = 302; +pub const HTTP_STATUS_REDIRECT_METHOD: DWORD = 303; +pub const HTTP_STATUS_NOT_MODIFIED: DWORD = 304; +pub const HTTP_STATUS_USE_PROXY: DWORD = 305; +pub const HTTP_STATUS_REDIRECT_KEEP_VERB: DWORD = 307; +pub const HTTP_STATUS_BAD_REQUEST: DWORD = 400; +pub const HTTP_STATUS_DENIED: DWORD = 401; +pub const HTTP_STATUS_PAYMENT_REQ: DWORD = 402; +pub const HTTP_STATUS_FORBIDDEN: DWORD = 403; +pub const HTTP_STATUS_NOT_FOUND: DWORD = 404; +pub const HTTP_STATUS_BAD_METHOD: DWORD = 405; +pub const HTTP_STATUS_NONE_ACCEPTABLE: DWORD = 406; +pub const HTTP_STATUS_PROXY_AUTH_REQ: DWORD = 407; +pub const HTTP_STATUS_REQUEST_TIMEOUT: DWORD = 408; +pub const HTTP_STATUS_CONFLICT: DWORD = 409; +pub const HTTP_STATUS_GONE: DWORD = 410; +pub const HTTP_STATUS_LENGTH_REQUIRED: DWORD = 411; +pub const HTTP_STATUS_PRECOND_FAILED: DWORD = 412; +pub const HTTP_STATUS_REQUEST_TOO_LARGE: DWORD = 413; +pub const HTTP_STATUS_URI_TOO_LONG: DWORD = 414; +pub const HTTP_STATUS_UNSUPPORTED_MEDIA: DWORD = 415; +pub const HTTP_STATUS_RETRY_WITH: DWORD = 449; +pub const HTTP_STATUS_SERVER_ERROR: DWORD = 500; +pub const HTTP_STATUS_NOT_SUPPORTED: DWORD = 501; +pub const HTTP_STATUS_BAD_GATEWAY: DWORD = 502; +pub const HTTP_STATUS_SERVICE_UNAVAIL: DWORD = 503; +pub const HTTP_STATUS_GATEWAY_TIMEOUT: DWORD = 504; +pub const HTTP_STATUS_VERSION_NOT_SUP: DWORD = 505; +pub const HTTP_STATUS_FIRST: DWORD = HTTP_STATUS_CONTINUE; +pub const HTTP_STATUS_LAST: DWORD = HTTP_STATUS_VERSION_NOT_SUP; +pub const HTTP_ADDREQ_INDEX_MASK: DWORD = 0x0000FFFF; +pub const HTTP_ADDREQ_FLAGS_MASK: DWORD = 0xFFFF0000; +pub const HTTP_ADDREQ_FLAG_ADD_IF_NEW: DWORD = 0x10000000; +pub const HTTP_ADDREQ_FLAG_ADD: DWORD = 0x20000000; +pub const HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA: DWORD = 0x40000000; +pub const HTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON: DWORD = 0x01000000; +pub const HTTP_ADDREQ_FLAG_COALESCE: DWORD = HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA; +pub const HTTP_ADDREQ_FLAG_REPLACE: DWORD = 0x80000000; +pub const HSR_ASYNC: DWORD = WININET_API_FLAG_ASYNC; +pub const HSR_SYNC: DWORD = WININET_API_FLAG_SYNC; +pub const HSR_USE_CONTEXT: DWORD = WININET_API_FLAG_USE_CONTEXT; +pub const HSR_INITIATE: DWORD = 0x00000008; +pub const HSR_DOWNLOAD: DWORD = 0x00000010; +pub const HSR_CHUNKED: DWORD = 0x00000020; +STRUCT!{struct INTERNET_COOKIE2 { + pwszName: PWSTR, + pwszValue: PWSTR, + pwszDomain: PWSTR, + pwszPath: PWSTR, + dwFlags: DWORD, + ftExpires: FILETIME, + fExpiresSet: BOOL, +}} +pub const INTERNET_COOKIE_IS_SECURE: DWORD = 0x01; +pub const INTERNET_COOKIE_IS_SESSION: DWORD = 0x02; +pub const INTERNET_COOKIE_THIRD_PARTY: DWORD = 0x10; +pub const INTERNET_COOKIE_PROMPT_REQUIRED: DWORD = 0x20; +pub const INTERNET_COOKIE_EVALUATE_P3P: DWORD = 0x40; +pub const INTERNET_COOKIE_APPLY_P3P: DWORD = 0x80; +pub const INTERNET_COOKIE_P3P_ENABLED: DWORD = 0x100; +pub const INTERNET_COOKIE_IS_RESTRICTED: DWORD = 0x200; +pub const INTERNET_COOKIE_IE6: DWORD = 0x400; +pub const INTERNET_COOKIE_IS_LEGACY: DWORD = 0x800; +pub const INTERNET_COOKIE_NON_SCRIPT: DWORD = 0x00001000; +pub const INTERNET_COOKIE_HTTPONLY: DWORD = 0x00002000; +pub const FLAG_ICC_FORCE_CONNECTION: DWORD = 0x00000001; +pub const FLAGS_ERROR_UI_FILTER_FOR_ERRORS: DWORD = 0x01; +pub const FLAGS_ERROR_UI_FLAGS_CHANGE_OPTIONS: DWORD = 0x02; +pub const FLAGS_ERROR_UI_FLAGS_GENERATE_DATA: DWORD = 0x04; +pub const FLAGS_ERROR_UI_FLAGS_NO_UI: DWORD = 0x08; +pub const FLAGS_ERROR_UI_SERIALIZE_DIALOGS: DWORD = 0x10; +FN!{stdcall PFN_AUTH_NOTIFY(DWORD_PTR, DWORD, LPVOID) -> DWORD} +STRUCT!{struct INTERNET_AUTH_NOTIFY_DATA { + cbStruct: DWORD, + dwOptions: DWORD, + pfnNotify: PFN_AUTH_NOTIFY, + dwContext: DWORD_PTR, +}} +pub const INTERNET_ERROR_BASE: DWORD = 12000; +pub const ERROR_INTERNET_OUT_OF_HANDLES: DWORD = INTERNET_ERROR_BASE + 1; +pub const ERROR_INTERNET_TIMEOUT: DWORD = INTERNET_ERROR_BASE + 2; +pub const ERROR_INTERNET_EXTENDED_ERROR: DWORD = INTERNET_ERROR_BASE + 3; +pub const ERROR_INTERNET_INTERNAL_ERROR: DWORD = INTERNET_ERROR_BASE + 4; +pub const ERROR_INTERNET_INVALID_URL: DWORD = INTERNET_ERROR_BASE + 5; +pub const ERROR_INTERNET_UNRECOGNIZED_SCHEME: DWORD = INTERNET_ERROR_BASE + 6; +pub const ERROR_INTERNET_NAME_NOT_RESOLVED: DWORD = INTERNET_ERROR_BASE + 7; +pub const ERROR_INTERNET_PROTOCOL_NOT_FOUND: DWORD = INTERNET_ERROR_BASE + 8; +pub const ERROR_INTERNET_INVALID_OPTION: DWORD = INTERNET_ERROR_BASE + 9; +pub const ERROR_INTERNET_BAD_OPTION_LENGTH: DWORD = INTERNET_ERROR_BASE + 10; +pub const ERROR_INTERNET_OPTION_NOT_SETTABLE: DWORD = INTERNET_ERROR_BASE + 11; +pub const ERROR_INTERNET_SHUTDOWN: DWORD = INTERNET_ERROR_BASE + 12; +pub const ERROR_INTERNET_INCORRECT_USER_NAME: DWORD = INTERNET_ERROR_BASE + 13; +pub const ERROR_INTERNET_INCORRECT_PASSWORD: DWORD = INTERNET_ERROR_BASE + 14; +pub const ERROR_INTERNET_LOGIN_FAILURE: DWORD = INTERNET_ERROR_BASE + 15; +pub const ERROR_INTERNET_INVALID_OPERATION: DWORD = INTERNET_ERROR_BASE + 16; +pub const ERROR_INTERNET_OPERATION_CANCELLED: DWORD = INTERNET_ERROR_BASE + 17; +pub const ERROR_INTERNET_INCORRECT_HANDLE_TYPE: DWORD = INTERNET_ERROR_BASE + 18; +pub const ERROR_INTERNET_INCORRECT_HANDLE_STATE: DWORD = INTERNET_ERROR_BASE + 19; +pub const ERROR_INTERNET_NOT_PROXY_REQUEST: DWORD = INTERNET_ERROR_BASE + 20; +pub const ERROR_INTERNET_REGISTRY_VALUE_NOT_FOUND: DWORD = INTERNET_ERROR_BASE + 21; +pub const ERROR_INTERNET_BAD_REGISTRY_PARAMETER: DWORD = INTERNET_ERROR_BASE + 22; +pub const ERROR_INTERNET_NO_DIRECT_ACCESS: DWORD = INTERNET_ERROR_BASE + 23; +pub const ERROR_INTERNET_NO_CONTEXT: DWORD = INTERNET_ERROR_BASE + 24; +pub const ERROR_INTERNET_NO_CALLBACK: DWORD = INTERNET_ERROR_BASE + 25; +pub const ERROR_INTERNET_REQUEST_PENDING: DWORD = INTERNET_ERROR_BASE + 26; +pub const ERROR_INTERNET_INCORRECT_FORMAT: DWORD = INTERNET_ERROR_BASE + 27; +pub const ERROR_INTERNET_ITEM_NOT_FOUND: DWORD = INTERNET_ERROR_BASE + 28; +pub const ERROR_INTERNET_CANNOT_CONNECT: DWORD = INTERNET_ERROR_BASE + 29; +pub const ERROR_INTERNET_CONNECTION_ABORTED: DWORD = INTERNET_ERROR_BASE + 30; +pub const ERROR_INTERNET_CONNECTION_RESET: DWORD = INTERNET_ERROR_BASE + 31; +pub const ERROR_INTERNET_FORCE_RETRY: DWORD = INTERNET_ERROR_BASE + 32; +pub const ERROR_INTERNET_INVALID_PROXY_REQUEST: DWORD = INTERNET_ERROR_BASE + 33; +pub const ERROR_INTERNET_NEED_UI: DWORD = INTERNET_ERROR_BASE + 34; +pub const ERROR_INTERNET_HANDLE_EXISTS: DWORD = INTERNET_ERROR_BASE + 36; +pub const ERROR_INTERNET_SEC_CERT_DATE_INVALID: DWORD = INTERNET_ERROR_BASE + 37; +pub const ERROR_INTERNET_SEC_CERT_CN_INVALID: DWORD = INTERNET_ERROR_BASE + 38; +pub const ERROR_INTERNET_HTTP_TO_HTTPS_ON_REDIR: DWORD = INTERNET_ERROR_BASE + 39; +pub const ERROR_INTERNET_HTTPS_TO_HTTP_ON_REDIR: DWORD = INTERNET_ERROR_BASE + 40; +pub const ERROR_INTERNET_MIXED_SECURITY: DWORD = INTERNET_ERROR_BASE + 41; +pub const ERROR_INTERNET_CHG_POST_IS_NON_SECURE: DWORD = INTERNET_ERROR_BASE + 42; +pub const ERROR_INTERNET_POST_IS_NON_SECURE: DWORD = INTERNET_ERROR_BASE + 43; +pub const ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED: DWORD = INTERNET_ERROR_BASE + 44; +pub const ERROR_INTERNET_INVALID_CA: DWORD = INTERNET_ERROR_BASE + 45; +pub const ERROR_INTERNET_CLIENT_AUTH_NOT_SETUP: DWORD = INTERNET_ERROR_BASE + 46; +pub const ERROR_INTERNET_ASYNC_THREAD_FAILED: DWORD = INTERNET_ERROR_BASE + 47; +pub const ERROR_INTERNET_REDIRECT_SCHEME_CHANGE: DWORD = INTERNET_ERROR_BASE + 48; +pub const ERROR_INTERNET_DIALOG_PENDING: DWORD = INTERNET_ERROR_BASE + 49; +pub const ERROR_INTERNET_RETRY_DIALOG: DWORD = INTERNET_ERROR_BASE + 50; +pub const ERROR_INTERNET_HTTPS_HTTP_SUBMIT_REDIR: DWORD = INTERNET_ERROR_BASE + 52; +pub const ERROR_INTERNET_INSERT_CDROM: DWORD = INTERNET_ERROR_BASE + 53; +pub const ERROR_INTERNET_FORTEZZA_LOGIN_NEEDED: DWORD = INTERNET_ERROR_BASE + 54; +pub const ERROR_INTERNET_SEC_CERT_ERRORS: DWORD = INTERNET_ERROR_BASE + 55; +pub const ERROR_INTERNET_SEC_CERT_NO_REV: DWORD = INTERNET_ERROR_BASE + 56; +pub const ERROR_INTERNET_SEC_CERT_REV_FAILED: DWORD = INTERNET_ERROR_BASE + 57; +pub const ERROR_FTP_TRANSFER_IN_PROGRESS: DWORD = INTERNET_ERROR_BASE + 110; +pub const ERROR_FTP_DROPPED: DWORD = INTERNET_ERROR_BASE + 111; +pub const ERROR_FTP_NO_PASSIVE_MODE: DWORD = INTERNET_ERROR_BASE + 112; +pub const ERROR_GOPHER_PROTOCOL_ERROR: DWORD = INTERNET_ERROR_BASE + 130; +pub const ERROR_GOPHER_NOT_FILE: DWORD = INTERNET_ERROR_BASE + 131; +pub const ERROR_GOPHER_DATA_ERROR: DWORD = INTERNET_ERROR_BASE + 132; +pub const ERROR_GOPHER_END_OF_DATA: DWORD = INTERNET_ERROR_BASE + 133; +pub const ERROR_GOPHER_INVALID_LOCATOR: DWORD = INTERNET_ERROR_BASE + 134; +pub const ERROR_GOPHER_INCORRECT_LOCATOR_TYPE: DWORD = INTERNET_ERROR_BASE + 135; +pub const ERROR_GOPHER_NOT_GOPHER_PLUS: DWORD = INTERNET_ERROR_BASE + 136; +pub const ERROR_GOPHER_ATTRIBUTE_NOT_FOUND: DWORD = INTERNET_ERROR_BASE + 137; +pub const ERROR_GOPHER_UNKNOWN_LOCATOR: DWORD = INTERNET_ERROR_BASE + 138; +pub const ERROR_HTTP_HEADER_NOT_FOUND: DWORD = INTERNET_ERROR_BASE + 150; +pub const ERROR_HTTP_DOWNLEVEL_SERVER: DWORD = INTERNET_ERROR_BASE + 151; +pub const ERROR_HTTP_INVALID_SERVER_RESPONSE: DWORD = INTERNET_ERROR_BASE + 152; +pub const ERROR_HTTP_INVALID_HEADER: DWORD = INTERNET_ERROR_BASE + 153; +pub const ERROR_HTTP_INVALID_QUERY_REQUEST: DWORD = INTERNET_ERROR_BASE + 154; +pub const ERROR_HTTP_HEADER_ALREADY_EXISTS: DWORD = INTERNET_ERROR_BASE + 155; +pub const ERROR_HTTP_REDIRECT_FAILED: DWORD = INTERNET_ERROR_BASE + 156; +pub const ERROR_HTTP_NOT_REDIRECTED: DWORD = INTERNET_ERROR_BASE + 160; +pub const ERROR_HTTP_COOKIE_NEEDS_CONFIRMATION: DWORD = INTERNET_ERROR_BASE + 161; +pub const ERROR_HTTP_COOKIE_DECLINED: DWORD = INTERNET_ERROR_BASE + 162; +pub const ERROR_HTTP_REDIRECT_NEEDS_CONFIRMATION: DWORD = INTERNET_ERROR_BASE + 168; +pub const ERROR_INTERNET_SECURITY_CHANNEL_ERROR: DWORD = INTERNET_ERROR_BASE + 157; +pub const ERROR_INTERNET_UNABLE_TO_CACHE_FILE: DWORD = INTERNET_ERROR_BASE + 158; +pub const ERROR_INTERNET_TCPIP_NOT_INSTALLED: DWORD = INTERNET_ERROR_BASE + 159; +pub const ERROR_INTERNET_DISCONNECTED: DWORD = INTERNET_ERROR_BASE + 163; +pub const ERROR_INTERNET_SERVER_UNREACHABLE: DWORD = INTERNET_ERROR_BASE + 164; +pub const ERROR_INTERNET_PROXY_SERVER_UNREACHABLE: DWORD = INTERNET_ERROR_BASE + 165; +pub const ERROR_INTERNET_BAD_AUTO_PROXY_SCRIPT: DWORD = INTERNET_ERROR_BASE + 166; +pub const ERROR_INTERNET_UNABLE_TO_DOWNLOAD_SCRIPT: DWORD = INTERNET_ERROR_BASE + 167; +pub const ERROR_INTERNET_SEC_INVALID_CERT: DWORD = INTERNET_ERROR_BASE + 169; +pub const ERROR_INTERNET_SEC_CERT_REVOKED: DWORD = INTERNET_ERROR_BASE + 170; +pub const ERROR_INTERNET_FAILED_DUETOSECURITYCHECK: DWORD = INTERNET_ERROR_BASE + 171; +pub const ERROR_INTERNET_NOT_INITIALIZED: DWORD = INTERNET_ERROR_BASE + 172; +pub const ERROR_INTERNET_NEED_MSN_SSPI_PKG: DWORD = INTERNET_ERROR_BASE + 173; +pub const ERROR_INTERNET_LOGIN_FAILURE_DISPLAY_ENTITY_BODY: DWORD = INTERNET_ERROR_BASE + 174; +pub const ERROR_INTERNET_DECODING_FAILED: DWORD = INTERNET_ERROR_BASE + 175; +pub const INTERNET_ERROR_LAST: DWORD = ERROR_INTERNET_DECODING_FAILED; +pub const NORMAL_CACHE_ENTRY: DWORD = 0x00000001; +pub const STICKY_CACHE_ENTRY: DWORD = 0x00000004; +pub const EDITED_CACHE_ENTRY: DWORD = 0x00000008; +pub const TRACK_OFFLINE_CACHE_ENTRY: DWORD = 0x00000010; +pub const TRACK_ONLINE_CACHE_ENTRY: DWORD = 0x00000020; +pub const SPARSE_CACHE_ENTRY: DWORD = 0x00010000; +pub const COOKIE_CACHE_ENTRY: DWORD = 0x00100000; +pub const URLHISTORY_CACHE_ENTRY: DWORD = 0x00200000; +pub const URLCACHE_FIND_DEFAULT_FILTER: DWORD = NORMAL_CACHE_ENTRY | COOKIE_CACHE_ENTRY + | URLHISTORY_CACHE_ENTRY | TRACK_OFFLINE_CACHE_ENTRY | TRACK_ONLINE_CACHE_ENTRY + | STICKY_CACHE_ENTRY; +STRUCT!{struct INTERNET_CACHE_ENTRY_INFOA { + dwStructSize: DWORD, + lpszSourceUrlName: LPSTR, + lpszLocalFileName: LPSTR, + CacheEntryType: DWORD, + dwUseCount: DWORD, + dwHitRate: DWORD, + dwSizeLow: DWORD, + dwSizeHigh: DWORD, + LastModifiedTime: FILETIME, + ExpireTime: FILETIME, + LastAccessTime: FILETIME, + LastSyncTime: FILETIME, + lpHeaderInfo: LPSTR, + dwHeaderInfoSize: DWORD, + lpszFileExtension: LPSTR, + u: DWORD, +}} +UNION!(INTERNET_CACHE_ENTRY_INFOA, u, dwReserved, dwReserved_mut, DWORD); +UNION!(INTERNET_CACHE_ENTRY_INFOA, u, dwExemptDelta, dwExemptDelta_mut, DWORD); +pub type LPINTERNET_CACHE_ENTRY_INFOA = *mut INTERNET_CACHE_ENTRY_INFOA; +STRUCT!{struct INTERNET_CACHE_ENTRY_INFOW { + dwStructSize: DWORD, + lpszSourceUrlName: LPWSTR, + lpszLocalFileName: LPWSTR, + CacheEntryType: DWORD, + dwUseCount: DWORD, + dwHitRate: DWORD, + dwSizeLow: DWORD, + dwSizeHigh: DWORD, + LastModifiedTime: FILETIME, + ExpireTime: FILETIME, + LastAccessTime: FILETIME, + LastSyncTime: FILETIME, + lpHeaderInfo: LPWSTR, + dwHeaderInfoSize: DWORD, + lpszFileExtension: LPWSTR, + u: DWORD, +}} +UNION!(INTERNET_CACHE_ENTRY_INFOW, u, dwReserved, dwReserved_mut, DWORD); +UNION!(INTERNET_CACHE_ENTRY_INFOW, u, dwExemptDelta, dwExemptDelta_mut, DWORD); +pub type LPINTERNET_CACHE_ENTRY_INFOW = *mut INTERNET_CACHE_ENTRY_INFOW; +STRUCT!{struct INTERNET_CACHE_TIMESTAMPS { + ftExpires: FILETIME, + ftLastModified: FILETIME, +}} +pub type LPINTERNET_CACHE_TIMESTAMPS = *mut INTERNET_CACHE_TIMESTAMPS; +pub type GROUPID = LONGLONG; +pub const CACHEGROUP_ATTRIBUTE_GET_ALL: DWORD = 0xffffffff; +pub const CACHEGROUP_ATTRIBUTE_BASIC: DWORD = 0x00000001; +pub const CACHEGROUP_ATTRIBUTE_FLAG: DWORD = 0x00000002; +pub const CACHEGROUP_ATTRIBUTE_TYPE: DWORD = 0x00000004; +pub const CACHEGROUP_ATTRIBUTE_QUOTA: DWORD = 0x00000008; +pub const CACHEGROUP_ATTRIBUTE_GROUPNAME: DWORD = 0x00000010; +pub const CACHEGROUP_ATTRIBUTE_STORAGE: DWORD = 0x00000020; +pub const CACHEGROUP_FLAG_NONPURGEABLE: DWORD = 0x00000001; +pub const CACHEGROUP_FLAG_GIDONLY: DWORD = 0x00000004; +pub const CACHEGROUP_FLAG_FLUSHURL_ONDELETE: DWORD = 0x00000002; +pub const CACHEGROUP_SEARCH_ALL: DWORD = 0x00000000; +pub const CACHEGROUP_SEARCH_BYURL: DWORD = 0x00000001; +pub const CACHEGROUP_TYPE_INVALID: DWORD = 0x00000001; +pub const CACHEGROUP_READWRITE_MASK: DWORD = CACHEGROUP_ATTRIBUTE_TYPE + | CACHEGROUP_ATTRIBUTE_QUOTA | CACHEGROUP_ATTRIBUTE_GROUPNAME | CACHEGROUP_ATTRIBUTE_STORAGE; +pub const GROUPNAME_MAX_LENGTH: DWORD = 120; +pub const GROUP_OWNER_STORAGE_SIZE: DWORD = 4; +STRUCT!{struct INTERNET_CACHE_GROUP_INFOA { + dwGroupSize: DWORD, + dwGroupFlags: DWORD, + dwGroupType: DWORD, + dwDiskUsage: DWORD, + dwDiskQuota: DWORD, + dwOwnerStorage: [DWORD; GROUP_OWNER_STORAGE_SIZE as usize], + szGroupName: [CHAR; GROUPNAME_MAX_LENGTH as usize], +}} +pub type LPINTERNET_CACHE_GROUP_INFOA = *mut INTERNET_CACHE_GROUP_INFOA; +STRUCT!{struct INTERNET_CACHE_GROUP_INFOW { + dwGroupSize: DWORD, + dwGroupFlags: DWORD, + dwGroupType: DWORD, + dwDiskUsage: DWORD, + dwDiskQuota: DWORD, + dwOwnerStorage: [DWORD; GROUP_OWNER_STORAGE_SIZE as usize], + szGroupName: [WCHAR; GROUPNAME_MAX_LENGTH as usize], +}} +pub type LPINTERNET_CACHE_GROUP_INFOW = *mut INTERNET_CACHE_GROUP_INFOW; +pub const CACHE_ENTRY_ATTRIBUTE_FC: DWORD = 0x00000004; +pub const CACHE_ENTRY_HITRATE_FC: DWORD = 0x00000010; +pub const CACHE_ENTRY_MODTIME_FC: DWORD = 0x00000040; +pub const CACHE_ENTRY_EXPTIME_FC: DWORD = 0x00000080; +pub const CACHE_ENTRY_ACCTIME_FC: DWORD = 0x00000100; +pub const CACHE_ENTRY_SYNCTIME_FC: DWORD = 0x00000200; +pub const CACHE_ENTRY_HEADERINFO_FC: DWORD = 0x00000400; +pub const CACHE_ENTRY_EXEMPT_DELTA_FC: DWORD = 0x00000800; +pub const INTERNET_CACHE_GROUP_ADD: DWORD = 0; +pub const INTERNET_CACHE_GROUP_REMOVE: DWORD = 1; +pub const INTERNET_DIAL_FORCE_PROMPT: DWORD = 0x2000; +pub const INTERNET_DIAL_SHOW_OFFLINE: DWORD = 0x4000; +pub const INTERNET_DIAL_UNATTENDED: DWORD = 0x8000; +pub const INTERENT_GOONLINE_REFRESH: DWORD = 0x00000001; +pub const INTERENT_GOONLINE_NOPROMPT: DWORD = 0x00000002; +pub const INTERENT_GOONLINE_MASK: DWORD = 0x00000003; +pub const INTERNET_AUTODIAL_FORCE_ONLINE: DWORD = 1; +pub const INTERNET_AUTODIAL_FORCE_UNATTENDED: DWORD = 2; +pub const INTERNET_AUTODIAL_FAILIFSECURITYCHECK: DWORD = 4; +pub const INTERNET_AUTODIAL_OVERRIDE_NET_PRESENT: DWORD = 8; +pub const INTERNET_AUTODIAL_FLAGS_MASK: DWORD = INTERNET_AUTODIAL_FORCE_ONLINE + | INTERNET_AUTODIAL_FORCE_UNATTENDED | INTERNET_AUTODIAL_FAILIFSECURITYCHECK + | INTERNET_AUTODIAL_OVERRIDE_NET_PRESENT; +pub const PROXY_AUTO_DETECT_TYPE_DHCP: DWORD = 1; +pub const PROXY_AUTO_DETECT_TYPE_DNS_A: DWORD = 2; +STRUCT!{struct AutoProxyHelperVtbl { + IsResolvable: Option BOOL>, + GetIPAddress: Option DWORD>, + ResolveHostName: Option DWORD>, + IsInNet: Option BOOL>, + IsResolvableEx: Option BOOL>, + GetIPAddressEx: Option DWORD>, + ResolveHostNameEx: Option DWORD>, + IsInNetEx: Option BOOL>, + SortIpList: Option DWORD>, +}} +STRUCT!{struct AUTO_PROXY_SCRIPT_BUFFER { + dwStructSize: DWORD, + lpszScriptBuffer: LPSTR, + dwScriptBufferSize: DWORD, +}} +pub type LPAUTO_PROXY_SCRIPT_BUFFER = *mut AUTO_PROXY_SCRIPT_BUFFER; +STRUCT!{struct AutoProxyHelperFunctions { + lpVtbl: *const AutoProxyHelperVtbl, +}} +FN!{stdcall pfnInternetInitializeAutoProxyDll( + DWORD, LPSTR, LPSTR, *mut AutoProxyHelperFunctions, LPAUTO_PROXY_SCRIPT_BUFFER +) -> BOOL} +FN!{stdcall pfnInternetDeInitializeAutoProxyDll( + LPSTR, DWORD +) -> BOOL} +FN!{stdcall pfnInternetGetProxyInfo( + LPCSTR, DWORD, LPSTR, DWORD, *mut LPSTR, LPDWORD +) -> BOOL} +ENUM!{enum WPAD_CACHE_DELETE { + WPAD_CACHE_DELETE_CURRENT = 0x0, + WPAD_CACHE_DELETE_ALL = 0x1, +}} +pub const INTERNET_CONNECTION_MODEM: DWORD = 0x01; +pub const INTERNET_CONNECTION_LAN: DWORD = 0x02; +pub const INTERNET_CONNECTION_PROXY: DWORD = 0x04; +pub const INTERNET_CONNECTION_MODEM_BUSY: DWORD = 0x08; +pub const INTERNET_RAS_INSTALLED: DWORD = 0x10; +pub const INTERNET_CONNECTION_OFFLINE: DWORD = 0x20; +pub const INTERNET_CONNECTION_CONFIGURED: DWORD = 0x40; +FN!{stdcall PFN_DIAL_HANDLER( + HWND, LPCSTR, DWORD, LPDWORD +) -> DWORD} +pub const INTERNET_CUSTOMDIAL_CONNECT: DWORD = 0; +pub const INTERNET_CUSTOMDIAL_UNATTENDED: DWORD = 1; +pub const INTERNET_CUSTOMDIAL_DISCONNECT: DWORD = 2; +pub const INTERNET_CUSTOMDIAL_SHOWOFFLINE: DWORD = 4; +pub const INTERNET_CUSTOMDIAL_SAFE_FOR_UNATTENDED: DWORD = 1; +pub const INTERNET_CUSTOMDIAL_WILL_SUPPLY_STATE: DWORD = 2; +pub const INTERNET_CUSTOMDIAL_CAN_HANGUP: DWORD = 4; +pub const INTERNET_DIALSTATE_DISCONNECTED: DWORD = 1; +pub const INTERNET_IDENTITY_FLAG_PRIVATE_CACHE: DWORD = 0x01; +pub const INTERNET_IDENTITY_FLAG_SHARED_CACHE: DWORD = 0x02; +pub const INTERNET_IDENTITY_FLAG_CLEAR_DATA: DWORD = 0x04; +pub const INTERNET_IDENTITY_FLAG_CLEAR_COOKIES: DWORD = 0x08; +pub const INTERNET_IDENTITY_FLAG_CLEAR_HISTORY: DWORD = 0x10; +pub const INTERNET_IDENTITY_FLAG_CLEAR_CONTENT: DWORD = 0x20; +pub const INTERNET_SUPPRESS_RESET_ALL: DWORD = 0x00; +pub const INTERNET_SUPPRESS_COOKIE_POLICY: DWORD = 0x01; +pub const INTERNET_SUPPRESS_COOKIE_POLICY_RESET: DWORD = 0x02; +pub const PRIVACY_TEMPLATE_NO_COOKIES: DWORD = 0; +pub const PRIVACY_TEMPLATE_HIGH: DWORD = 1; +pub const PRIVACY_TEMPLATE_MEDIUM_HIGH: DWORD = 2; +pub const PRIVACY_TEMPLATE_MEDIUM: DWORD = 3; +pub const PRIVACY_TEMPLATE_MEDIUM_LOW: DWORD = 4; +pub const PRIVACY_TEMPLATE_LOW: DWORD = 5; +pub const PRIVACY_TEMPLATE_CUSTOM: DWORD = 100; +pub const PRIVACY_TEMPLATE_ADVANCED: DWORD = 101; +pub const PRIVACY_TEMPLATE_MAX: DWORD = PRIVACY_TEMPLATE_LOW; +pub const PRIVACY_TYPE_FIRST_PARTY: DWORD = 0; +pub const PRIVACY_TYPE_THIRD_PARTY: DWORD = 1; + +EXTERN!{stdcall fn CommitUrlCacheEntryA( + lpszUrlName: LPCSTR, + lpszLocalFileName: LPCSTR, + ExpireTime: FILETIME, + LastModifiedTime: FILETIME, + CacheEntryType: DWORD, + lpHeaderInfo: LPBYTE, + cchHeaderInfo: DWORD, + lpszFileExtension: LPCSTR, + lpszOriginalUrl: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn CommitUrlCacheEntryW( + lpszUrlName: LPCWSTR, + lpszLocalFileName: LPCWSTR, + ExpireTime: FILETIME, + LastModifiedTime: FILETIME, + CacheEntryType: DWORD, + lpszHeaderInfo: LPWSTR, + cchHeaderInfo: DWORD, + lpszFileExtension: LPCWSTR, + lpszOriginalUrl: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn CreateMD5SSOHash ( + pszChallengeInfo: PWSTR, + pwszRealm: PWSTR, + pwszTarget: PWSTR, + pbHexHash: PBYTE +) -> BOOL} +EXTERN!{stdcall fn CreateUrlCacheEntryA( + lpszUrlName: LPCSTR, + dwExpectedFileSize: DWORD, + lpszFileExtension: LPCSTR, + lpszFileName: LPSTR, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn CreateUrlCacheEntryW( + lpszUrlName: LPCWSTR, + dwExpectedFileSize: DWORD, + lpszFileExtension: LPCWSTR, + lpszFileName: LPWSTR, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn CreateUrlCacheGroup( + dwFlags: DWORD, + lpReserved: LPVOID +) -> GROUPID} +EXTERN!{stdcall fn DeleteUrlCacheEntryA( + lpszUrlName: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn DeleteUrlCacheEntryW( + lpszUrlName: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn DeleteUrlCacheGroup( + GroupId: GROUPID, + dwFlags: DWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn DeleteWpadCacheForNetworks( + arg0: WPAD_CACHE_DELETE +) -> BOOL} +EXTERN!{stdcall fn DetectAutoProxyUrl( + pszAutoProxyUrl: PSTR, + cchAutoProxyUrl: DWORD, + dwDetectFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn FindCloseUrlCache( + hEnumHandle: HANDLE +) -> BOOL} +EXTERN!{stdcall fn FindFirstUrlCacheEntryA( + lpszUrlSearchPattern: LPCSTR, + lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD +) -> HANDLE} +EXTERN!{stdcall fn FindFirstUrlCacheEntryExA( + lpszUrlSearchPattern: LPCSTR, + dwFlags: DWORD, + dwFilter: DWORD, + GroupId: GROUPID, + lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD, + lpGroupAttributes: LPVOID, + lpcbGroupAttributes: LPDWORD, + lpReserved: LPVOID +) -> HANDLE} +EXTERN!{stdcall fn FindFirstUrlCacheEntryExW( + lpszUrlSearchPattern: LPCWSTR, + dwFlags: DWORD, + dwFilter: DWORD, + GroupId: GROUPID, + lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD, + lpGroupAttributes: LPVOID, + lpcbGroupAttributes: LPDWORD, + lpReserved: LPVOID +) -> HANDLE} +EXTERN!{stdcall fn FindFirstUrlCacheEntryW( + lpszUrlSearchPattern: LPCWSTR, + lpFirstCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD +) -> HANDLE} +EXTERN!{stdcall fn FindFirstUrlCacheGroup( + dwFlags: DWORD, + dwFilter: DWORD, + lpSearchCondition: LPVOID, + dwSearchCondition: DWORD, + lpGroupId: *mut GROUPID, + lpReserved: LPVOID +) -> HANDLE} +EXTERN!{stdcall fn FindNextUrlCacheEntryA( + hEnumHandle: HANDLE, + lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn FindNextUrlCacheEntryExA( + hEnumHandle: HANDLE, + lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD, + lpGroupAttributes: LPVOID, + lpcbGroupAttributes: LPDWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn FindNextUrlCacheEntryExW( + hEnumHandle: HANDLE, + lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD, + lpGroupAttributes: LPVOID, + lpcbGroupAttributes: LPDWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn FindNextUrlCacheEntryW( + hEnumHandle: HANDLE, + lpNextCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn FindNextUrlCacheGroup( + hFind: HANDLE, + lpGroupId: *mut GROUPID, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn FtpCommandA( + hConnect: HINTERNET, + fExpectResponse: BOOL, + dwFlags: DWORD, + lpszCommand: LPCSTR, + dwContext: DWORD_PTR, + phFtpCommand: *mut HINTERNET +) -> BOOL} +EXTERN!{stdcall fn FtpCommandW( + hConnect: HINTERNET, + fExpectResponse: BOOL, + dwFlags: DWORD, + lpszCommand: LPCWSTR, + dwContext: DWORD_PTR, + phFtpCommand: *mut HINTERNET +) -> BOOL} +EXTERN!{stdcall fn FtpCreateDirectoryA( + hConnect: HINTERNET, + lpszDirectory: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn FtpCreateDirectoryW( + hConnect: HINTERNET, + lpszDirectory: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn FtpDeleteFileA( + hConnect: HINTERNET, + lpszFileName: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn FtpDeleteFileW( + hConnect: HINTERNET, + lpszFileName: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn FtpFindFirstFileA( + hConnect: HINTERNET, + lpszSearchFile: LPCSTR, + lpFindFileData: LPWIN32_FIND_DATAA, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn FtpFindFirstFileW( + hConnect: HINTERNET, + lpszSearchFile: LPCWSTR, + lpFindFileData: LPWIN32_FIND_DATAW, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn FtpGetCurrentDirectoryA( + hConnect: HINTERNET, + lpszCurrentDirectory: LPSTR, + lpdwCurrentDirectory: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn FtpGetCurrentDirectoryW( + hConnect: HINTERNET, + lpszCurrentDirectory: LPWSTR, + lpdwCurrentDirectory: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn FtpGetFileA( + hConnect: HINTERNET, + lpszRemoteFile: LPCSTR, + lpszNewFile: LPCSTR, + fFailIfExists: BOOL, + dwFlagsAndAttributes: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn FtpGetFileEx( + hFtpSession: HINTERNET, + lpszRemoteFile: LPCSTR, + lpszNewFile: LPCWSTR, + fFailIfExists: BOOL, + dwFlagsAndAttributes: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn FtpGetFileSize( + hFile: HINTERNET, + lpdwFileSizeHigh: LPDWORD +) -> DWORD} +EXTERN!{stdcall fn FtpGetFileW( + hConnect: HINTERNET, + lpszRemoteFile: LPCWSTR, + lpszNewFile: LPCWSTR, + fFailIfExists: BOOL, + dwFlagsAndAttributes: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn FtpOpenFileA( + hConnect: HINTERNET, + lpszFileName: LPCSTR, + dwAccess: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn FtpOpenFileW( + hConnect: HINTERNET, + lpszFileName: LPCWSTR, + dwAccess: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn FtpPutFileA( + hConnect: HINTERNET, + lpszLocalFile: LPCSTR, + lpszNewRemoteFile: LPCSTR, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn FtpPutFileEx( + hFtpSession: HINTERNET, + lpszLocalFile: LPCWSTR, + lpszNewRemoteFile: LPCSTR, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn FtpPutFileW( + hConnect: HINTERNET, + lpszLocalFile: LPCWSTR, + lpszNewRemoteFile: LPCWSTR, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn FtpRemoveDirectoryA( + hConnect: HINTERNET, + lpszDirectory: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn FtpRemoveDirectoryW( + hConnect: HINTERNET, + lpszDirectory: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn FtpRenameFileA( + hConnect: HINTERNET, + lpszExisting: LPCSTR, + lpszNew: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn FtpRenameFileW( + hConnect: HINTERNET, + lpszExisting: LPCWSTR, + lpszNew: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn FtpSetCurrentDirectoryA( + hConnect: HINTERNET, + lpszDirectory: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn FtpSetCurrentDirectoryW( + hConnect: HINTERNET, + lpszDirectory: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn GetUrlCacheEntryInfoA( + lpszUrlName: LPCSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn GetUrlCacheEntryInfoExA( + lpszUrl: LPCSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD, + lpszRedirectUrl: LPSTR, + lpcbRedirectUrl: LPDWORD, + lpReserved: LPVOID, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn GetUrlCacheEntryInfoExW( + lpszUrl: LPCWSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD, + lpszRedirectUrl: LPWSTR, + lpcbRedirectUrl: LPDWORD, + lpReserved: LPVOID, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn GetUrlCacheEntryInfoW( + lpszUrlName: LPCWSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn GetUrlCacheGroupAttributeA( + gid: GROUPID, + dwFlags: DWORD, + dwAttributes: DWORD, + lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOA, + lpcbGroupInfo: LPDWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn GetUrlCacheGroupAttributeW( + gid: GROUPID, + dwFlags: DWORD, + dwAttributes: DWORD, + lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOW, + lpcbGroupInfo: LPDWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn GopherCreateLocatorA( + lpszHost: LPCSTR, + nServerPort: INTERNET_PORT, + lpszDisplayString: LPCSTR, + lpszSelectorString: LPCSTR, + dwGopherType: DWORD, + lpszLocator: LPSTR, + lpdwBufferLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn GopherCreateLocatorW( + lpszHost: LPCWSTR, + nServerPort: INTERNET_PORT, + lpszDisplayString: LPCWSTR, + lpszSelectorString: LPCWSTR, + dwGopherType: DWORD, + lpszLocator: LPWSTR, + lpdwBufferLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn GopherFindFirstFileA( + hConnect: HINTERNET, + lpszLocator: LPCSTR, + lpszSearchString: LPCSTR, + lpFindData: LPGOPHER_FIND_DATAA, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn GopherFindFirstFileW( + hConnect: HINTERNET, + lpszLocator: LPCWSTR, + lpszSearchString: LPCWSTR, + lpFindData: LPGOPHER_FIND_DATAW, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn GopherGetAttributeA( + hConnect: HINTERNET, + lpszLocator: LPCSTR, + lpszAttributeName: LPCSTR, + lpBuffer: LPBYTE, + dwBufferLength: DWORD, + lpdwCharactersReturned: LPDWORD, + lpfnEnumerator: GOPHER_ATTRIBUTE_ENUMERATOR, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn GopherGetAttributeW( + hConnect: HINTERNET, + lpszLocator: LPCWSTR, + lpszAttributeName: LPCWSTR, + lpBuffer: LPBYTE, + dwBufferLength: DWORD, + lpdwCharactersReturned: LPDWORD, + lpfnEnumerator: GOPHER_ATTRIBUTE_ENUMERATOR, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn GopherGetLocatorTypeA( + lpszLocator: LPCSTR, + lpdwGopherType: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn GopherGetLocatorTypeW( + lpszLocator: LPCWSTR, + lpdwGopherType: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn GopherOpenFileA( + hConnect: HINTERNET, + lpszLocator: LPCSTR, + lpszView: LPCSTR, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn GopherOpenFileW( + hConnect: HINTERNET, + lpszLocator: LPCWSTR, + lpszView: LPCWSTR, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn HttpAddRequestHeadersA( + hRequest: HINTERNET, + lpszHeaders: LPCSTR, + dwHeadersLength: DWORD, + dwModifiers: DWORD +) -> BOOL} +EXTERN!{stdcall fn HttpAddRequestHeadersW( + hRequest: HINTERNET, + lpszHeaders: LPCWSTR, + dwHeadersLength: DWORD, + dwModifiers: DWORD +) -> BOOL} +EXTERN!{stdcall fn HttpEndRequestA( + hRequest: HINTERNET, + lpBuffersOut: LPINTERNET_BUFFERSA, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn HttpEndRequestW( + hRequest: HINTERNET, + lpBuffersOut: LPINTERNET_BUFFERSW, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn HttpOpenRequestA( + hConnect: HINTERNET, + lpszVerb: LPCSTR, + lpszObjectName: LPCSTR, + lpszVersion: LPCSTR, + lpszReferrer: LPCSTR, + lplpszAcceptTypes: *mut LPCSTR, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn HttpOpenRequestW( + hConnect: HINTERNET, + lpszVerb: LPCWSTR, + lpszObjectName: LPCWSTR, + lpszVersion: LPCWSTR, + lpszReferrer: LPCWSTR, + lplpszAcceptTypes: *mut LPCWSTR, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn HttpQueryInfoA( + hRequest: HINTERNET, + dwInfoLevel: DWORD, + lpBuffer: LPVOID, + lpdwBufferLength: LPDWORD, + lpdwIndex: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn HttpQueryInfoW( + hRequest: HINTERNET, + dwInfoLevel: DWORD, + lpBuffer: LPVOID, + lpdwBufferLength: LPDWORD, + lpdwIndex: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn HttpSendRequestA( + hRequest: HINTERNET, + lpszHeaders: LPCSTR, + dwHeadersLength: DWORD, + lpOptional: LPVOID, + dwOptionalLength: DWORD +) -> BOOL} +EXTERN!{stdcall fn HttpSendRequestExA( + hRequest: HINTERNET, + lpBuffersIn: LPINTERNET_BUFFERSA, + lpBuffersOut: LPINTERNET_BUFFERSA, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn HttpSendRequestExW( + hRequest: HINTERNET, + lpBuffersIn: LPINTERNET_BUFFERSW, + lpBuffersOut: LPINTERNET_BUFFERSW, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn HttpSendRequestW( + hRequest: HINTERNET, + lpszHeaders: LPCWSTR, + dwHeadersLength: DWORD, + lpOptional: LPVOID, + dwOptionalLength: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetAttemptConnect( + dwReserved: DWORD +) -> DWORD} +EXTERN!{stdcall fn InternetAutodial( + dwFlags: DWORD, + hwndParent: HWND +) -> BOOL} +EXTERN!{stdcall fn InternetAutodialHangup( + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetCanonicalizeUrlA( + lpszUrl: LPCSTR, + lpszBuffer: LPSTR, + lpdwBufferLength: LPDWORD, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetCanonicalizeUrlW( + lpszUrl: LPCWSTR, + lpszBuffer: LPWSTR, + lpdwBufferLength: LPDWORD, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetCheckConnectionA( + lpszUrl: LPCSTR, + dwFlags: DWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetCheckConnectionW( + lpszUrl: LPCWSTR, + dwFlags: DWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetClearAllPerSiteCookieDecisions( + +) -> BOOL} +EXTERN!{stdcall fn InternetCloseHandle( + hInternet: HINTERNET +) -> BOOL} +EXTERN!{stdcall fn InternetCombineUrlA( + lpszBaseUrl: LPCSTR, + lpszRelativeUrl: LPCSTR, + lpszBuffer: LPSTR, + lpdwBufferLength: LPDWORD, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetCombineUrlW( + lpszBaseUrl: LPCWSTR, + lpszRelativeUrl: LPCWSTR, + lpszBuffer: LPWSTR, + lpdwBufferLength: LPDWORD, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetConfirmZoneCrossingA( + hWnd: HWND, + szUrlPrev: LPSTR, + szUrlNew: LPSTR, + bPost: BOOL +) -> DWORD} +EXTERN!{stdcall fn InternetConfirmZoneCrossingW( + hWnd: HWND, + szUrlPrev: LPWSTR, + szUrlNew: LPWSTR, + bPost: BOOL +) -> DWORD} +EXTERN!{stdcall fn InternetConnectA( + hInternet: HINTERNET, + lpszServerName: LPCSTR, + nServerPort: INTERNET_PORT, + lpszUserName: LPCSTR, + lpszPassword: LPCSTR, + dwService: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn InternetConnectW( + hInternet: HINTERNET, + lpszServerName: LPCWSTR, + nServerPort: INTERNET_PORT, + lpszUserName: LPCWSTR, + lpszPassword: LPCWSTR, + dwService: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn InternetCrackUrlA( + lpszUrl: LPCSTR, + dwUrlLength: DWORD, + dwFlags: DWORD, + lpUrlComponents: LPURL_COMPONENTSA +) -> BOOL} +EXTERN!{stdcall fn InternetCrackUrlW( + lpszUrl: LPCWSTR, + dwUrlLength: DWORD, + dwFlags: DWORD, + lpUrlComponents: LPURL_COMPONENTSW +) -> BOOL} +EXTERN!{stdcall fn InternetCreateUrlA( + lpUrlComponents: LPURL_COMPONENTSA, + dwFlags: DWORD, + lpszUrl: LPSTR, + lpdwUrlLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetCreateUrlW( + lpUrlComponents: LPURL_COMPONENTSW, + dwFlags: DWORD, + lpszUrl: LPWSTR, + lpdwUrlLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetDialA( + hwndParent: HWND, + lpszConnectoid: LPSTR, + dwFlags: DWORD, + lpdwConnection: *mut DWORD_PTR, + dwReserved: DWORD +) -> DWORD} +EXTERN!{stdcall fn InternetDialW( + hwndParent: HWND, + lpszConnectoid: LPWSTR, + dwFlags: DWORD, + lpdwConnection: *mut DWORD_PTR, + dwReserved: DWORD +) -> DWORD} +EXTERN!{stdcall fn InternetEnumPerSiteCookieDecisionA( + pszSiteName: LPSTR, + pcSiteNameSize: *mut u32, + pdwDecision: *mut u32, + dwIndex: u32 +) -> BOOL} +EXTERN!{stdcall fn InternetEnumPerSiteCookieDecisionW( + pszSiteName: LPWSTR, + pcSiteNameSize: *mut u32, + pdwDecision: *mut u32, + dwIndex: u32 +) -> BOOL} +EXTERN!{stdcall fn InternetErrorDlg( + hWnd: HWND, + hRequest: HINTERNET, + dwError: DWORD, + dwFlags: DWORD, + lppvData: *mut LPVOID +) -> DWORD} +EXTERN!{stdcall fn InternetFindNextFileA( + hFind: HINTERNET, + lpvFindData: LPVOID +) -> BOOL} +EXTERN!{stdcall fn InternetFindNextFileW( + hFind: HINTERNET, + lpvFindData: LPVOID +) -> BOOL} +EXTERN!{stdcall fn InternetFreeCookies( + pCookies: *mut INTERNET_COOKIE2, + dwCookieCount: DWORD +) -> ()} +EXTERN!{stdcall fn InternetGetConnectedState( + lpdwFlags: LPDWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGetConnectedStateExA( + lpdwFlags: LPDWORD, + lpszConnectionName: LPSTR, + cchNameLen: DWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGetConnectedStateExW( + lpdwFlags: LPDWORD, + lpszConnectionName: LPWSTR, + cchNameLen: DWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGetCookieA( + lpszUrl: LPCSTR, + lpszCookieName: LPCSTR, + lpszCookieData: LPSTR, + lpdwSize: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGetCookieEx2( + pcwszUrl: PCWSTR, + pcwszCookieName: PCWSTR, + dwFlags: DWORD, + ppCookies: *mut *mut INTERNET_COOKIE2, + pdwCookieCount: PDWORD +) -> DWORD} +EXTERN!{stdcall fn InternetGetCookieExA( + lpszUrl: LPCSTR, + lpszCookieName: LPCSTR, + lpszCookieData: LPSTR, + lpdwSize: LPDWORD, + dwFlags: DWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn InternetGetCookieExW( + lpszUrl: LPCWSTR, + lpszCookieName: LPCWSTR, + lpszCookieData: LPWSTR, + lpdwSize: LPDWORD, + dwFlags: DWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn InternetGetCookieW( + lpszUrl: LPCWSTR, + lpszCookieName: LPCWSTR, + lpszCookieData: LPWSTR, + lpdwSize: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGetLastResponseInfoA( + lpdwError: LPDWORD, + lpszBuffer: LPSTR, + lpdwBufferLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGetLastResponseInfoW( + lpdwError: LPDWORD, + lpszBuffer: LPWSTR, + lpdwBufferLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGetPerSiteCookieDecisionA( + pchHostName: LPCSTR, + pResult: *mut u32 +) -> BOOL} +EXTERN!{stdcall fn InternetGetPerSiteCookieDecisionW( + pchHostName: LPCWSTR, + pResult: *mut u32 +) -> BOOL} +EXTERN!{stdcall fn InternetGoOnlineA( + lpszURL: LPCSTR, + hwndParent: HWND, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetGoOnlineW( + lpszURL: LPCWSTR, + hwndParent: HWND, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetHangUp( + dwConnection: DWORD_PTR, + dwReserved: DWORD +) -> DWORD} +EXTERN!{stdcall fn InternetInitializeAutoProxyDll( + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetLockRequestFile( + hInternet: HINTERNET, + lphLockRequestInfo: *mut HANDLE +) -> BOOL} +EXTERN!{stdcall fn InternetOpenA( + lpszAgent: LPCSTR, + dwAccessType: DWORD, + lpszProxy: LPCSTR, + lpszProxyBypass: LPCSTR, + dwFlags: DWORD +) -> HINTERNET} +EXTERN!{stdcall fn InternetOpenUrlA( + hInternet: HINTERNET, + lpszUrl: LPCSTR, + lpszHeaders: LPCSTR, + dwHeadersLength: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn InternetOpenUrlW( + hInternet: HINTERNET, + lpszUrl: LPCWSTR, + lpszHeaders: LPCWSTR, + dwHeadersLength: DWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> HINTERNET} +EXTERN!{stdcall fn InternetOpenW( + lpszAgent: LPCWSTR, + dwAccessType: DWORD, + lpszProxy: LPCWSTR, + lpszProxyBypass: LPCWSTR, + dwFlags: DWORD +) -> HINTERNET} +EXTERN!{stdcall fn InternetQueryDataAvailable( + hFile: HINTERNET, + lpdwNumberOfBytesAvailable: LPDWORD, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn InternetQueryOptionA( + hInternet: HINTERNET, + dwOption: DWORD, + lpBuffer: LPVOID, + lpdwBufferLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetQueryOptionW( + hInternet: HINTERNET, + dwOption: DWORD, + lpBuffer: LPVOID, + lpdwBufferLength: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetReadFile( + hFile: HINTERNET, + lpBuffer: LPVOID, + dwNumberOfBytesToRead: DWORD, + lpdwNumberOfBytesRead: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn InternetReadFileExA( + hFile: HINTERNET, + lpBuffersOut: LPINTERNET_BUFFERSA, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn InternetReadFileExW( + hFile: HINTERNET, + lpBuffersOut: LPINTERNET_BUFFERSW, + dwFlags: DWORD, + dwContext: DWORD_PTR +) -> BOOL} +EXTERN!{stdcall fn InternetSetCookieA( + lpszUrl: LPCSTR, + lpszCookieName: LPCSTR, + lpszCookieData: LPCSTR +) -> BOOL} +EXTERN!{stdcall fn InternetSetCookieEx2( + pcwszUrl: PCWSTR, + pCookie: *const INTERNET_COOKIE2, + pcwszP3PPolicy: PCWSTR, + dwFlags: DWORD, + pdwCookieState: PDWORD +) -> DWORD} +EXTERN!{stdcall fn InternetSetCookieExA( + lpszUrl: LPCSTR, + lpszCookieName: LPCSTR, + lpszCookieData: LPCSTR, + dwFlags: DWORD, + dwReserved: DWORD_PTR +) -> DWORD} +EXTERN!{stdcall fn InternetSetCookieExW( + lpszUrl: LPCWSTR, + lpszCookieName: LPCWSTR, + lpszCookieData: LPCWSTR, + dwFlags: DWORD, + dwReserved: DWORD_PTR +) -> DWORD} +EXTERN!{stdcall fn InternetSetCookieW( + lpszUrl: LPCWSTR, + lpszCookieName: LPCWSTR, + lpszCookieData: LPCWSTR +) -> BOOL} +EXTERN!{stdcall fn InternetSetDialStateA( + lpszConnectoid: LPCSTR, + dwState: DWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetDialStateW( + lpszConnectoid: LPCWSTR, + dwState: DWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetFilePointer( + hFile: HINTERNET, + lDistanceToMove: LONG, + lpDistanceToMoveHigh: PLONG, + dwMoveMethod: DWORD, + dwContext: DWORD_PTR +) -> DWORD} +EXTERN!{stdcall fn InternetSetOptionA( + hInternet: HINTERNET, + dwOption: DWORD, + lpBuffer: LPVOID, + dwBufferLength: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetOptionExA( + hInternet: HINTERNET, + dwOption: DWORD, + lpBuffer: LPVOID, + dwBufferLength: DWORD, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetOptionExW( + hInternet: HINTERNET, + dwOption: DWORD, + lpBuffer: LPVOID, + dwBufferLength: DWORD, + dwFlags: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetOptionW( + hInternet: HINTERNET, + dwOption: DWORD, + lpBuffer: LPVOID, + dwBufferLength: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetPerSiteCookieDecisionA( + pchHostName: LPCSTR, + dwDecision: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetPerSiteCookieDecisionW( + pchHostName: LPCWSTR, + dwDecision: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetSetStatusCallbackA( + hInternet: HINTERNET, + lpfnInternetCallback: INTERNET_STATUS_CALLBACK +) -> INTERNET_STATUS_CALLBACK} +EXTERN!{stdcall fn InternetSetStatusCallbackW( + hInternet: HINTERNET, + lpfnInternetCallback: INTERNET_STATUS_CALLBACK +) -> INTERNET_STATUS_CALLBACK} +EXTERN!{stdcall fn InternetTimeFromSystemTimeA( + pst: *const SYSTEMTIME, + dwRFC: DWORD, + lpszTime: LPSTR, + cbTime: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetTimeFromSystemTimeW( + pst: *const SYSTEMTIME, + dwRFC: DWORD, + lpszTime: LPWSTR, + cbTime: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetTimeToSystemTimeA( + lpszTime: LPCSTR, + pst: *mut SYSTEMTIME, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetTimeToSystemTimeW( + lpszTime: LPCWSTR, + pst: *mut SYSTEMTIME, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn InternetUnlockRequestFile( + hLockRequestInfo: HANDLE +) -> BOOL} +EXTERN!{stdcall fn InternetWriteFile( + hFile: HINTERNET, + lpBuffer: LPCVOID, + dwNumberOfBytesToWrite: DWORD, + lpdwNumberOfBytesWritten: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn PrivacyGetZonePreferenceW( + dwZone: DWORD, + dwType: DWORD, + pdwTemplate: LPDWORD, + pszBuffer: LPWSTR, + pdwBufferLength: LPDWORD +) -> DWORD} +EXTERN!{stdcall fn PrivacySetZonePreferenceW( + dwZone: DWORD, + dwType: DWORD, + dwTemplate: DWORD, + pszPreference: LPCWSTR +) -> DWORD} +EXTERN!{stdcall fn ReadUrlCacheEntryStream( + hUrlCacheStream: HANDLE, + dwLocation: DWORD, + lpBuffer: LPVOID, + lpdwLen: LPDWORD, + Reserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn ReadUrlCacheEntryStreamEx( + hUrlCacheStream: HANDLE, + qwLocation: DWORDLONG, + lpBuffer: LPVOID, + lpdwLen: LPDWORD +) -> BOOL} +EXTERN!{stdcall fn ResumeSuspendedDownload( + hRequest: HINTERNET, + dwResultCode: DWORD +) -> BOOL} +EXTERN!{stdcall fn RetrieveUrlCacheEntryFileA( + lpszUrlName: LPCSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn RetrieveUrlCacheEntryFileW( + lpszUrlName: LPCWSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn RetrieveUrlCacheEntryStreamA( + lpszUrlName: LPCSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + lpcbCacheEntryInfo: LPDWORD, + fRandomRead: BOOL, + dwReserved: DWORD +) -> HANDLE} +EXTERN!{stdcall fn RetrieveUrlCacheEntryStreamW( + lpszUrlName: LPCWSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + lpcbCacheEntryInfo: LPDWORD, + fRandomRead: BOOL, + dwReserved: DWORD +) -> HANDLE} +EXTERN!{stdcall fn SetUrlCacheEntryGroupA( + lpszUrlName: LPCSTR, + dwFlags: DWORD, + GroupId: GROUPID, + pbGroupAttributes: LPBYTE, + cbGroupAttributes: DWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn SetUrlCacheEntryGroupW( + lpszUrlName: LPCWSTR, + dwFlags: DWORD, + GroupId: GROUPID, + pbGroupAttributes: LPBYTE, + cbGroupAttributes: DWORD, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn SetUrlCacheEntryInfoA( + lpszUrlName: LPCSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOA, + dwFieldControl: DWORD +) -> BOOL} +EXTERN!{stdcall fn SetUrlCacheEntryInfoW( + lpszUrlName: LPCWSTR, + lpCacheEntryInfo: LPINTERNET_CACHE_ENTRY_INFOW, + dwFieldControl: DWORD +) -> BOOL} +EXTERN!{stdcall fn SetUrlCacheGroupAttributeA( + gid: GROUPID, + dwFlags: DWORD, + dwAttributes: DWORD, + lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOA, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn SetUrlCacheGroupAttributeW( + gid: GROUPID, + dwFlags: DWORD, + dwAttributes: DWORD, + lpGroupInfo: LPINTERNET_CACHE_GROUP_INFOW, + lpReserved: LPVOID +) -> BOOL} +EXTERN!{stdcall fn UnlockUrlCacheEntryFileA( + lpszUrlName: LPCSTR, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn UnlockUrlCacheEntryFileW( + lpszUrlName: LPCWSTR, + dwReserved: DWORD +) -> BOOL} +EXTERN!{stdcall fn UnlockUrlCacheEntryStream( + hUrlCacheStream: HANDLE, + Reserved: DWORD +) -> BOOL} diff --git a/src/um/winineti.rs b/src/um/winineti.rs new file mode 100644 index 000000000..ad6f8e107 --- /dev/null +++ b/src/um/winineti.rs @@ -0,0 +1,146 @@ +// Copyright © 2016 winapi-rs developers +// Licensed under the Apache License, Version 2.0 +// or the MIT license +// , at your option. +// All files in the project carrying such notice may not be copied, modified, or distributed +// except according to those terms. +//! Windows Internet Services API procedure declarations, types and constants. + +// Currently, this only contains `INTERNET_FLAG_BGUPDATE`, which is needed to correctly define +// `wininet::INTERNET_FLAGS_MASK`. + +use shared::minwindef::DWORD; +pub const INTERNET_FLAG_BGUPDATE: DWORD = 0x00000008; + +// Functions from wininet.dll that *should* be in this header. +// pub fn AppCacheCheckManifest(); +// pub fn AppCacheCloseHandle(); +// pub fn AppCacheCreateAndCommitFile(); +// pub fn AppCacheDeleteGroup(); +// pub fn AppCacheDeleteIEGroup(); +// pub fn AppCacheDuplicateHandle(); +// pub fn AppCacheFinalize(); +// pub fn AppCacheFreeDownloadList(); +// pub fn AppCacheFreeGroupList(); +// pub fn AppCacheFreeIESpace(); +// pub fn AppCacheFreeSpace(); +// pub fn AppCacheGetDownloadList(); +// pub fn AppCacheGetFallbackUrl(); +// pub fn AppCacheGetGroupList(); +// pub fn AppCacheGetIEGroupList(); +// pub fn AppCacheGetInfo(); +// pub fn AppCacheGetManifestUrl(); +// pub fn AppCacheLookup(); +// pub fn CommitUrlCacheEntryBinaryBlob(); +// pub fn CreateCacheServerRpcBinding(); +// pub fn CreateUrlCacheContainerA(); +// pub fn CreateUrlCacheContainerW(); +// pub fn CreateUrlCacheEntryExW(); +// pub fn DeleteIE3Cache(); +// pub fn DeleteUrlCacheContainerA(); +// pub fn DeleteUrlCacheContainerW(); +// pub fn DoConnectoidsExist(); +// pub fn ExportCookieFileA(); +// pub fn ExportCookieFileW(); +// pub fn FindFirstUrlCacheContainerA(); +// pub fn FindFirstUrlCacheContainerW(); +// pub fn FindNextUrlCacheContainerA(); +// pub fn FindNextUrlCacheContainerW(); +// pub fn FindP3PPolicySymbol(); +// pub fn ForceNexusLookupExW(); +// pub fn FreeP3PObject(); +// pub fn FreeUrlCacheSpaceA(); +// pub fn FreeUrlCacheSpaceW(); +// pub fn GetCacheServerConnection(); +// pub fn GetDiskInfoA(); +// pub fn GetP3PPolicy(); +// pub fn GetP3PRequestStatus(); +// pub fn GetUrlCacheConfigInfoA(); +// pub fn GetUrlCacheConfigInfoW(); +// pub fn GetUrlCacheEntryBinaryBlob(); +// pub fn GetUrlCacheHeaderData(); +// pub fn HttpCheckDavComplianceA(); +// pub fn HttpCheckDavComplianceW(); +// pub fn HttpCloseDependencyHandle(); +// pub fn HttpDuplicateDependencyHandle(); +// pub fn HttpGetServerCredentials(); +// pub fn HttpGetTunnelSocket(); +// pub fn HttpIsHostHstsEnabled(); +// pub fn HttpOpenDependencyHandle(); +// pub fn HttpPushClose(); +// pub fn HttpPushEnable(); +// pub fn HttpPushWait(); +// pub fn HttpWebSocketClose(); +// pub fn HttpWebSocketCompleteUpgrade(); +// pub fn HttpWebSocketQueryCloseStatus(); +// pub fn HttpWebSocketReceive(); +// pub fn HttpWebSocketSend(); +// pub fn HttpWebSocketShutdown(); +// pub fn ImportCookieFileA(); +// pub fn ImportCookieFileW(); +// pub fn IncrementUrlCacheHeaderData(); +// pub fn InternalInternetGetCookie(); +// pub fn InternetAlgIdToStringA(); +// pub fn InternetAlgIdToStringW(); +// pub fn InternetAutodialCallback(); +// pub fn InternetAutoProxyGetProxyForUrl(); +// pub fn InternetAutoProxyOnSendRequestComplete(); +// pub fn InternetFortezzaCommand(); +// pub fn InternetFreeProxyInfoList(); +// pub fn InternetGetCertByURLA(); +// pub fn InternetGetProxyForUrl(); +// pub fn InternetGetSecurityInfoByURLA(); +// pub fn InternetGetSecurityInfoByURLW(); +// pub fn InternetQueryFortezzaStatus(); +// pub fn InternetSecurityProtocolToStringA(); +// pub fn InternetSecurityProtocolToStringW(); +// pub fn InternetShowSecurityInfoByURLA(); +// pub fn InternetShowSecurityInfoByURLW(); +// pub fn InternetWriteFileExA(); +// pub fn InternetWriteFileExW(); +// pub fn IsDialUpConnection(); +// pub fn IsDomainLegalCookieDomainA(); +// pub fn IsDomainLegalCookieDomainW(); +// pub fn IsHostInProxyBypassList(); +// pub fn IsLanConnection(); +// pub fn IsProfilesEnabled(); +// pub fn IsUrlCacheEntryExpiredA(); +// pub fn IsUrlCacheEntryExpiredW(); +// pub fn LoadUrlCacheContent(); +// pub fn MapResourceToPolicy(); +// pub fn ParseX509EncodedCertificateForListBoxEntry(); +// pub fn PerformOperationOverUrlCacheA(); +// pub fn ReadGuidsForConnectedNetworks(); +// pub fn RegisterForNetworkChangeNotification(); +// pub fn RegisterUrlCacheNotification(); +// pub fn RunOnceUrlCache(); +// pub fn SetGlobalJetParameters(); +// pub fn SetUrlCacheConfigInfoA(); +// pub fn SetUrlCacheConfigInfoW(); +// pub fn SetUrlCacheHeaderData(); +// pub fn ShowCertificate(); +// pub fn ShowClientAuthCerts(); +// pub fn ShowSecurityInfo(); +// pub fn ShowX509EncodedCertificate(); +// pub fn UnRegisterNetworkChangeNotification(); +// pub fn UpdateUrlCacheContentPath(); +// pub fn UrlCacheCheckEntriesExist(); +// pub fn UrlCacheCloseEntryHandle(); +// pub fn UrlCacheContainerSetEntryMaximumAge(); +// pub fn UrlCacheCreateContainer(); +// pub fn UrlCacheFindFirstEntry(); +// pub fn UrlCacheFindNextEntry(); +// pub fn UrlCacheFreeEntryInfo(); +// pub fn UrlCacheFreeGlobalSpace(); +// pub fn UrlCacheGetContentPaths(); +// pub fn UrlCacheGetEntryInfo(); +// pub fn UrlCacheGetGlobalCacheSize(); +// pub fn UrlCacheGetGlobalLimit(); +// pub fn UrlCacheReadEntryStream(); +// pub fn UrlCacheReloadSettings(); +// pub fn UrlCacheRetrieveEntryFile(); +// pub fn UrlCacheRetrieveEntryStream(); +// pub fn UrlCacheServer(); +// pub fn UrlCacheSetGlobalLimit(); +// pub fn UrlCacheUpdateEntryExtraData(); +// pub fn UrlZonesDetach(); diff --git a/tests/structs.rs b/tests/structs.rs index 7f12a040d..bbaa4eaa3 100644 --- a/tests/structs.rs +++ b/tests/structs.rs @@ -389,6 +389,218 @@ fn shared_windef() { assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 2); } +#[cfg(all(target_arch = "x86", feature = "um-wininet"))] #[test] +fn um_wininet() { + use winapi::um::wininet::*; + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 20); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 60); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 28); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 808); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1588); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); // FIXME + assert_eq!(align_of::(), 4); // FIXME + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 80); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 156); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 276); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 36); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 12); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); +} +#[cfg(all(target_arch = "x86_64", feature = "um-wininet"))] #[test] +fn um_wininet() { + use winapi::um::wininet::*; + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 104); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 56); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 808); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 1588); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 32); // FIXME + assert_eq!(align_of::(), 8); // FIXME + assert_eq!(size_of::(), 48); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 112); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 156); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 276); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 72); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); +} #[cfg(all(target_arch = "x86", feature = "shared-wtypesbase"))] #[test] fn shared_wtypesbase() { use winapi::shared::wtypesbase::*; diff --git a/x86_64/lib/libwininet.a b/x86_64/lib/libwininet.a new file mode 100644 index 0000000000000000000000000000000000000000..203bd969b1cb9783d120d5968b767f379a42a170 GIT binary patch literal 175246 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 literal 0 HcmV?d00001