#![allow(non_snake_case, clippy::upper_case_acronyms)]
use std::cell::UnsafeCell;
use std::collections::VecDeque;
use std::ffi::c_void;
use std::fmt::Write as _;
use std::io::Read;
use std::sync::{Arc, Mutex, MutexGuard, OnceLock};
use std::time::{Duration, Instant};
use crate::client::{
Answer, Capabilities, Completion, Event, Events, Head, Message, Metrics, Prepared,
PreparedBody, QuestionId, Socket, Transfer, Transport, TransportConfig, WsEvent, WsEvents,
};
use crate::{HttpError, Identity, Tier};
pub const TIER: Tier = Tier::NativeStack;
type HINTERNET = *mut c_void;
type DWORD = u32;
type BOOL = i32;
type LPCWSTR = *const u16;
const WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY: DWORD = 4;
const WINHTTP_FLAG_ASYNC: DWORD = 0x1000_0000;
const WINHTTP_FLAG_SECURE: DWORD = 0x0080_0000;
const WINHTTP_ADDREQ_FLAG_ADD: DWORD = 0x2000_0000;
const WINHTTP_QUERY_STATUS_CODE: DWORD = 19;
const WINHTTP_QUERY_RAW_HEADERS_CRLF: DWORD = 22;
const WINHTTP_QUERY_FLAG_NUMBER: DWORD = 0x2000_0000;
const IGNORE_TOTAL_LENGTH: DWORD = 0;
const OPTION_CONTEXT_VALUE: DWORD = 45;
const OPTION_CLIENT_CERT_CONTEXT: DWORD = 47;
const OPTION_DISABLE_FEATURE: DWORD = 63;
const OPTION_MAX_CONNS_PER_SERVER: DWORD = 73;
const OPTION_MAX_CONNS_PER_1_0_SERVER: DWORD = 74;
const OPTION_REDIRECT_POLICY: DWORD = 88;
const OPTION_UPGRADE_TO_WEB_SOCKET: DWORD = 114;
const OPTION_ENABLE_HTTP_PROTOCOL: DWORD = 133;
const OPTION_HTTP_PROTOCOL_USED: DWORD = 134;
const REDIRECT_POLICY_NEVER: DWORD = 0;
const DISABLE_COOKIES: DWORD = 1;
const PROTOCOL_FLAG_HTTP2: DWORD = 0x1;
const PROTOCOL_FLAG_HTTP3: DWORD = 0x2;
const WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS: DWORD = 0xFFFF_FFFF;
const STATUS_HANDLE_CLOSING: DWORD = 0x0000_0800;
const STATUS_SENDREQUEST_COMPLETE: DWORD = 0x0040_0000;
const STATUS_HEADERS_AVAILABLE: DWORD = 0x0002_0000;
const STATUS_READ_COMPLETE: DWORD = 0x0008_0000;
const STATUS_REQUEST_ERROR: DWORD = 0x0020_0000;
const STATUS_WRITE_COMPLETE: DWORD = 0x0010_0000;
const STATUS_CLOSE_COMPLETE: DWORD = 0x0200_0000;
const INVALID_STATUS_CALLBACK: usize = usize::MAX;
const WS_BINARY_MESSAGE: u32 = 0;
const WS_BINARY_FRAGMENT: u32 = 1;
const WS_UTF8_MESSAGE: u32 = 2;
const WS_UTF8_FRAGMENT: u32 = 3;
const WS_CLOSE: u32 = 4;
const E_TIMEOUT: DWORD = 12002;
const E_INVALID_URL: DWORD = 12005;
const E_UNRECOGNIZED_SCHEME: DWORD = 12006;
const E_NAME_NOT_RESOLVED: DWORD = 12007;
const E_OPERATION_CANCELLED: DWORD = 12017;
const E_CANNOT_CONNECT: DWORD = 12029;
const E_CONNECTION_ERROR: DWORD = 12030;
const SECURE_ERRORS: [DWORD; 7] = [12037, 12038, 12044, 12045, 12057, 12157, 12175];
const PKCS12_NO_PERSIST_KEY: DWORD = 0x0000_8000;
const ENCODING_X509_PKCS7: DWORD = 0x0001_0001;
const CERT_FIND_ANY: DWORD = 0;
const CERT_FIND_HAS_PRIVATE_KEY: DWORD = 0x0015_0000;
const PIECE: usize = 64 << 10;
type StatusCallback = unsafe extern "system" fn(HINTERNET, usize, DWORD, *mut c_void, DWORD);
#[allow(dead_code)]
#[repr(C)]
struct AsyncResult {
result: usize,
error: DWORD,
}
#[repr(C)]
struct WsStatus {
bytes: DWORD,
buffer_type: u32,
}
#[allow(dead_code)]
#[repr(C)]
struct CertContext {
encoding: DWORD,
encoded: *const u8,
encoded_len: DWORD,
info: *const c_void,
store: *mut c_void,
}
#[allow(dead_code)]
#[repr(C)]
struct DataBlob {
len: DWORD,
data: *const u8,
}
struct Api {
open: unsafe extern "system" fn(LPCWSTR, DWORD, LPCWSTR, LPCWSTR, DWORD) -> HINTERNET,
connect: unsafe extern "system" fn(HINTERNET, LPCWSTR, u16, DWORD) -> HINTERNET,
open_request: unsafe extern "system" fn(
HINTERNET,
LPCWSTR,
LPCWSTR,
LPCWSTR,
LPCWSTR,
*const LPCWSTR,
DWORD,
) -> HINTERNET,
set_timeouts: unsafe extern "system" fn(HINTERNET, i32, i32, i32, i32) -> BOOL,
set_option: unsafe extern "system" fn(HINTERNET, DWORD, *const c_void, DWORD) -> BOOL,
query_option: unsafe extern "system" fn(HINTERNET, DWORD, *mut c_void, *mut DWORD) -> BOOL,
add_headers: unsafe extern "system" fn(HINTERNET, LPCWSTR, DWORD, DWORD) -> BOOL,
send: unsafe extern "system" fn(
HINTERNET,
LPCWSTR,
DWORD,
*const c_void,
DWORD,
DWORD,
usize,
) -> BOOL,
write_data: unsafe extern "system" fn(HINTERNET, *const c_void, DWORD, *mut DWORD) -> BOOL,
receive: unsafe extern "system" fn(HINTERNET, *mut c_void) -> BOOL,
query_headers: unsafe extern "system" fn(
HINTERNET,
DWORD,
LPCWSTR,
*mut c_void,
*mut DWORD,
*mut DWORD,
) -> BOOL,
read_data: unsafe extern "system" fn(HINTERNET, *mut c_void, DWORD, *mut DWORD) -> BOOL,
close: unsafe extern "system" fn(HINTERNET) -> BOOL,
set_status_callback:
unsafe extern "system" fn(HINTERNET, Option<StatusCallback>, DWORD, usize) -> usize,
ws: Option<WsApi>,
}
struct WsApi {
complete_upgrade: unsafe extern "system" fn(HINTERNET, usize) -> HINTERNET,
send: unsafe extern "system" fn(HINTERNET, u32, *const c_void, DWORD) -> DWORD,
receive:
unsafe extern "system" fn(HINTERNET, *mut c_void, DWORD, *mut DWORD, *mut u32) -> DWORD,
close: unsafe extern "system" fn(HINTERNET, u16, *const c_void, DWORD) -> DWORD,
query_close_status:
unsafe extern "system" fn(HINTERNET, *mut u16, *mut c_void, DWORD, *mut DWORD) -> DWORD,
}
struct Crypt {
pfx_import: unsafe extern "system" fn(*const DataBlob, LPCWSTR, DWORD) -> *mut c_void,
find_certificate: unsafe extern "system" fn(
*mut c_void,
DWORD,
DWORD,
DWORD,
*const c_void,
*const CertContext,
) -> *const CertContext,
free_certificate: unsafe extern "system" fn(*const CertContext) -> BOOL,
close_store: unsafe extern "system" fn(*mut c_void, DWORD) -> BOOL,
}
unsafe impl Send for Api {}
unsafe impl Sync for Api {}
unsafe impl Send for Crypt {}
unsafe impl Sync for Crypt {}
unsafe extern "system" {
fn LoadLibraryW(name: LPCWSTR) -> *mut c_void;
fn GetProcAddress(module: *mut c_void, name: *const u8) -> *mut c_void;
fn GetLastError() -> DWORD;
}
fn wide(s: &str) -> Vec<u16> {
s.encode_utf16().chain(std::iter::once(0)).collect()
}
fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
}
unsafe fn symbol<T: Copy>(library: *mut c_void, name: &str) -> Option<T> {
if std::mem::size_of::<T>() != std::mem::size_of::<*mut c_void>() {
return None;
}
let name: Vec<u8> = name.bytes().chain(std::iter::once(0)).collect();
let address = unsafe { GetProcAddress(library, name.as_ptr()) };
if address.is_null() {
return None;
}
Some(unsafe { std::mem::transmute_copy::<*mut c_void, T>(&address) })
}
fn api() -> Option<&'static Api> {
static API: OnceLock<Option<Api>> = OnceLock::new();
API.get_or_init(|| {
let lib = unsafe { LoadLibraryW(wide("winhttp.dll").as_ptr()) };
if lib.is_null() {
return None;
}
unsafe {
let ws = (|| {
Some(WsApi {
complete_upgrade: symbol(lib, "WinHttpWebSocketCompleteUpgrade")?,
send: symbol(lib, "WinHttpWebSocketSend")?,
receive: symbol(lib, "WinHttpWebSocketReceive")?,
close: symbol(lib, "WinHttpWebSocketClose")?,
query_close_status: symbol(lib, "WinHttpWebSocketQueryCloseStatus")?,
})
})();
Some(Api {
open: symbol(lib, "WinHttpOpen")?,
connect: symbol(lib, "WinHttpConnect")?,
open_request: symbol(lib, "WinHttpOpenRequest")?,
set_timeouts: symbol(lib, "WinHttpSetTimeouts")?,
set_option: symbol(lib, "WinHttpSetOption")?,
query_option: symbol(lib, "WinHttpQueryOption")?,
add_headers: symbol(lib, "WinHttpAddRequestHeaders")?,
send: symbol(lib, "WinHttpSendRequest")?,
write_data: symbol(lib, "WinHttpWriteData")?,
receive: symbol(lib, "WinHttpReceiveResponse")?,
query_headers: symbol(lib, "WinHttpQueryHeaders")?,
read_data: symbol(lib, "WinHttpReadData")?,
close: symbol(lib, "WinHttpCloseHandle")?,
set_status_callback: symbol(lib, "WinHttpSetStatusCallback")?,
ws,
})
}
})
.as_ref()
}
fn crypt() -> Option<&'static Crypt> {
static CRYPT: OnceLock<Option<Crypt>> = OnceLock::new();
CRYPT
.get_or_init(|| {
let lib = unsafe { LoadLibraryW(wide("crypt32.dll").as_ptr()) };
if lib.is_null() {
return None;
}
unsafe {
Some(Crypt {
pfx_import: symbol(lib, "PFXImportCertStore")?,
find_certificate: symbol(lib, "CertFindCertificateInStore")?,
free_certificate: symbol(lib, "CertFreeCertificateContext")?,
close_store: symbol(lib, "CertCloseStore")?,
})
}
})
.as_ref()
}
pub(crate) fn capabilities() -> Capabilities {
let Some(api) = api() else {
return Capabilities::default();
};
let websockets = api.ws.is_some();
Capabilities {
streaming: true,
upload_streaming: true,
upload_progress: true,
manual_redirects: true,
auth_questions: false,
native_auth_schemes: false,
server_trust: false,
client_identity: crypt().is_some(),
platform_cookies: false,
platform_cache: false,
metrics: true,
websockets,
websocket_ping: false,
websocket_headers: websockets,
wait_for_connectivity: false,
}
}
pub(crate) fn transport(config: &TransportConfig) -> Arc<dyn Transport> {
Arc::new(WinTransport {
session: Session::open(config),
identity: config.identity.as_ref().map(ClientCert::import),
})
}
fn split_url(url: &str) -> Result<(bool, String, u16, String), HttpError> {
let bad = || HttpError::BadUrl(url.to_string());
let (secure, rest) = [
("https://", true),
("wss://", true),
("http://", false),
("ws://", false),
]
.iter()
.find_map(|(scheme, secure)| {
(url.len() >= scheme.len() && url[..scheme.len()].eq_ignore_ascii_case(scheme))
.then(|| (*secure, &url[scheme.len()..]))
})
.ok_or_else(bad)?;
let (authority, path) = match rest.find(['/', '?']) {
Some(i) if rest.as_bytes()[i] == b'?' => (&rest[..i], format!("/{}", &rest[i..])),
Some(i) => (&rest[..i], rest[i..].to_string()),
None => (rest, "/".to_string()),
};
let path = path.split('#').next().unwrap_or("/").to_string();
if authority.is_empty() || authority.contains('@') || authority.contains('[') {
return Err(bad());
}
let (host, port) = match authority.rsplit_once(':') {
Some((h, p)) => (h.to_string(), p.parse::<u16>().map_err(|_| bad())?),
None => (authority.to_string(), if secure { 443 } else { 80 }),
};
Ok((secure, host, port, path))
}
fn map_error(code: DWORD) -> HttpError {
match code {
E_TIMEOUT => HttpError::Timeout,
E_OPERATION_CANCELLED => HttpError::Cancelled,
E_NAME_NOT_RESOLVED => HttpError::Dns,
E_CANNOT_CONNECT | E_CONNECTION_ERROR => HttpError::Connect,
E_INVALID_URL | E_UNRECOGNIZED_SCHEME => HttpError::BadUrl(format!("winhttp {code}")),
c if SECURE_ERRORS.contains(&c) => HttpError::Tls(format!("winhttp secure failure {c}")),
c => HttpError::Io(format!("winhttp error {c}")),
}
}
fn last_error() -> HttpError {
map_error(unsafe { GetLastError() })
}
fn set_dword(api: &Api, handle: HINTERNET, option: DWORD, value: DWORD) -> bool {
unsafe {
(api.set_option)(
handle,
option,
(&raw const value).cast(),
std::mem::size_of::<DWORD>() as DWORD,
) != 0
}
}
struct Session {
api: &'static Api,
handle: HINTERNET,
}
unsafe impl Send for Session {}
unsafe impl Sync for Session {}
impl Session {
fn open(config: &TransportConfig) -> Result<Arc<Session>, HttpError> {
let api = api().ok_or(HttpError::Unsupported)?;
let handle = unsafe {
(api.open)(
wide("day-part-http").as_ptr(),
WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY,
std::ptr::null(),
std::ptr::null(),
WINHTTP_FLAG_ASYNC,
)
};
if handle.is_null() {
return Err(last_error());
}
let session = Arc::new(Session { api, handle });
let previous = unsafe {
(api.set_status_callback)(
handle,
Some(on_status),
WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS,
0,
)
};
if previous == INVALID_STATUS_CALLBACK {
return Err(last_error());
}
set_dword(
api,
handle,
OPTION_ENABLE_HTTP_PROTOCOL,
PROTOCOL_FLAG_HTTP2,
);
if let Some(limit) = config.max_per_host {
set_dword(api, handle, OPTION_MAX_CONNS_PER_SERVER, limit.max(1));
set_dword(api, handle, OPTION_MAX_CONNS_PER_1_0_SERVER, limit.max(1));
}
Ok(session)
}
}
impl Drop for Session {
fn drop(&mut self) {
unsafe { (self.api.close)(self.handle) };
}
}
struct ClientCert {
crypt: &'static Crypt,
store: *mut c_void,
context: *const CertContext,
}
unsafe impl Send for ClientCert {}
unsafe impl Sync for ClientCert {}
impl ClientCert {
fn import(identity: &Identity) -> Result<Arc<ClientCert>, HttpError> {
let crypt = crypt().ok_or(HttpError::Unsupported)?;
let blob = DataBlob {
len: DWORD::try_from(identity.pkcs12.len())
.map_err(|_| HttpError::Tls("the client identity is too large".into()))?,
data: identity.pkcs12.as_ptr(),
};
let password = wide(&identity.password);
let mut store = unsafe {
(crypt.pfx_import)(&raw const blob, password.as_ptr(), PKCS12_NO_PERSIST_KEY)
};
if store.is_null() && identity.password.is_empty() {
store = unsafe {
(crypt.pfx_import)(&raw const blob, std::ptr::null(), PKCS12_NO_PERSIST_KEY)
};
}
if store.is_null() {
let code = unsafe { GetLastError() };
return Err(HttpError::Tls(format!(
"the client identity could not be read ({code})"
)));
}
let find = |kind: DWORD| {
unsafe {
(crypt.find_certificate)(
store,
ENCODING_X509_PKCS7,
0,
kind,
std::ptr::null(),
std::ptr::null(),
)
}
};
let mut context = find(CERT_FIND_HAS_PRIVATE_KEY);
if context.is_null() {
context = find(CERT_FIND_ANY);
}
if context.is_null() {
unsafe { (crypt.close_store)(store, 0) };
return Err(HttpError::Tls(
"the client identity holds no certificate".into(),
));
}
Ok(Arc::new(ClientCert {
crypt,
store,
context,
}))
}
}
impl Drop for ClientCert {
fn drop(&mut self) {
unsafe {
(self.crypt.free_certificate)(self.context);
(self.crypt.close_store)(self.store, 0);
}
}
}
struct WinTransport {
session: Result<Arc<Session>, HttpError>,
identity: Option<Result<Arc<ClientCert>, HttpError>>,
}
impl WinTransport {
fn parts(&self) -> Result<(Arc<Session>, Option<Arc<ClientCert>>), HttpError> {
let session = self.session.clone()?;
let cert = match &self.identity {
None => None,
Some(identity) => Some(identity.clone()?),
};
Ok((session, cert))
}
}
impl Transport for WinTransport {
fn capabilities(&self) -> Capabilities {
capabilities()
}
fn start(&self, prepared: Prepared, events: Events) -> Arc<dyn Transfer> {
match self
.parts()
.and_then(|(session, cert)| Exchange::begin(session, cert, prepared, events.clone()))
{
Ok(exchange) => exchange,
Err(error) => {
events(Event::Failed(error));
Arc::new(Dead)
}
}
}
fn websocket(&self, prepared: Prepared, events: WsEvents) -> Arc<dyn Socket> {
let opened = self.parts().and_then(|(session, cert)| {
let api: &'static Api = session.api;
let ws = api.ws.as_ref().ok_or(HttpError::Unsupported)?;
WsConn::begin(session.clone(), ws, cert, prepared, events.clone())
});
match opened {
Ok(socket) => socket,
Err(error) => {
events(WsEvent::Failed(error));
Arc::new(Dead)
}
}
}
}
struct Dead;
impl Transfer for Dead {
fn demand(&self, _chunks: u32) {}
fn answer(&self, _id: QuestionId, _answer: Answer) {}
fn cancel(&self) {}
}
impl Socket for Dead {
fn send(&self, _message: Message, done: Completion) {
done(Err(HttpError::Unsupported));
}
fn ping(&self, done: Completion) {
done(Err(HttpError::Unsupported));
}
fn close(&self, _code: u16, _reason: &str) {}
fn demand(&self, _messages: u32) {}
}
enum Context {
Exchange(Arc<Exchange>),
Upgrade(Arc<WsConn>),
Socket(Arc<WsConn>),
}
impl Context {
fn into_raw(self) -> usize {
Box::into_raw(Box::new(self)) as usize
}
}
fn attach(api: &Api, request: HINTERNET, context: Context) -> Result<usize, HttpError> {
let raw = context.into_raw();
let ok = unsafe {
(api.set_option)(
request,
OPTION_CONTEXT_VALUE,
(&raw const raw).cast(),
std::mem::size_of::<usize>() as DWORD,
)
};
if ok == 0 {
let error = last_error();
drop(unsafe { Box::from_raw(raw as *mut Context) });
return Err(error);
}
Ok(raw)
}
unsafe extern "system" fn on_status(
handle: HINTERNET,
context: usize,
status: DWORD,
info: *mut c_void,
info_len: DWORD,
) {
if context == 0 {
return;
}
let raw = context as *mut Context;
if status == STATUS_HANDLE_CLOSING {
let context = unsafe { Box::from_raw(raw) };
match *context {
Context::Exchange(exchange) => exchange.closed(),
Context::Upgrade(conn) => conn.request_closed(),
Context::Socket(conn) => conn.socket_closed(),
}
return;
}
let context = unsafe { &*raw };
let error = || {
if info.is_null() {
E_CONNECTION_ERROR
} else {
unsafe { (*(info as *const AsyncResult)).error }
}
};
match context {
Context::Exchange(exchange) => match status {
STATUS_SENDREQUEST_COMPLETE => exchange.write_next(),
STATUS_WRITE_COMPLETE => exchange.written(),
STATUS_HEADERS_AVAILABLE => exchange.head(),
STATUS_READ_COMPLETE => exchange.read(info_len as usize),
STATUS_REQUEST_ERROR => exchange.fail(map_error(error())),
_ => {}
},
Context::Upgrade(conn) => match status {
STATUS_SENDREQUEST_COMPLETE => conn.receive_response(),
STATUS_HEADERS_AVAILABLE => conn.upgrade(),
STATUS_REQUEST_ERROR => conn.fail(map_error(error())),
_ => {}
},
Context::Socket(conn) => {
let ws_status = || {
(!info.is_null()).then(|| unsafe { &*(info as *const WsStatus) })
};
match status {
STATUS_READ_COMPLETE => match ws_status() {
Some(s) => conn.received(s.bytes as usize, s.buffer_type),
None => conn.fail(HttpError::Io("the WebSocket receive failed".into())),
},
STATUS_WRITE_COMPLETE => conn.sent(),
STATUS_CLOSE_COMPLETE => conn.close_complete(handle),
STATUS_REQUEST_ERROR => conn.request_error(error()),
_ => {}
}
}
}
}
struct Opened {
connection: HINTERNET,
request: HINTERNET,
}
impl Opened {
fn close(&self, api: &Api) {
unsafe {
(api.close)(self.request);
(api.close)(self.connection);
}
}
}
fn open_request(
session: &Session,
cert: Option<&ClientCert>,
method: &str,
url: &str,
headers: &[(String, String)],
idle: Duration,
) -> Result<Opened, HttpError> {
let api = session.api;
let (secure, host, port, path) = split_url(url)?;
unsafe {
let connection = (api.connect)(session.handle, wide(&host).as_ptr(), port, 0);
if connection.is_null() {
return Err(last_error());
}
let request = (api.open_request)(
connection,
wide(method).as_ptr(),
wide(&path).as_ptr(),
std::ptr::null(),
std::ptr::null(),
std::ptr::null(),
if secure { WINHTTP_FLAG_SECURE } else { 0 },
);
if request.is_null() {
let error = last_error();
(api.close)(connection);
return Err(error);
}
let opened = Opened {
connection,
request,
};
let ms = i32::try_from(idle.as_millis()).unwrap_or(i32::MAX).max(1);
(api.set_timeouts)(request, ms, ms, ms, ms);
set_dword(api, request, OPTION_REDIRECT_POLICY, REDIRECT_POLICY_NEVER);
set_dword(api, request, OPTION_DISABLE_FEATURE, DISABLE_COOKIES);
match cert {
Some(cert) => {
(api.set_option)(
request,
OPTION_CLIENT_CERT_CONTEXT,
cert.context.cast(),
std::mem::size_of::<CertContext>() as DWORD,
);
}
None => {
(api.set_option)(request, OPTION_CLIENT_CERT_CONTEXT, std::ptr::null(), 0);
}
}
if !headers.is_empty() {
let joined = headers.iter().fold(String::new(), |mut block, (k, v)| {
let _ = write!(block, "{k}: {v}\r\n");
block
});
let joined = wide(&joined);
if (api.add_headers)(
request,
joined.as_ptr(),
DWORD::MAX,
WINHTTP_ADDREQ_FLAG_ADD,
) == 0
{
let error = last_error();
opened.close(api);
return Err(error);
}
}
Ok(opened)
}
}
fn read_head(api: &Api, request: HINTERNET) -> Result<(u16, Vec<(String, String)>), HttpError> {
let mut status: DWORD = 0;
let mut len = std::mem::size_of::<DWORD>() as DWORD;
let ok = unsafe {
(api.query_headers)(
request,
WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
std::ptr::null(),
(&raw mut status).cast(),
&raw mut len,
std::ptr::null_mut(),
)
};
if ok == 0 {
return Err(last_error());
}
let mut headers = Vec::new();
let mut bytes: DWORD = 0;
unsafe {
(api.query_headers)(
request,
WINHTTP_QUERY_RAW_HEADERS_CRLF,
std::ptr::null(),
std::ptr::null_mut(),
&raw mut bytes,
std::ptr::null_mut(),
)
};
if bytes > 0 {
let mut buf = vec![0u16; (bytes as usize).div_ceil(2)];
let ok = unsafe {
(api.query_headers)(
request,
WINHTTP_QUERY_RAW_HEADERS_CRLF,
std::ptr::null(),
buf.as_mut_ptr().cast(),
&raw mut bytes,
std::ptr::null_mut(),
)
};
if ok != 0 {
let raw = String::from_utf16_lossy(&buf[..(bytes as usize / 2).min(buf.len())]);
for line in raw.lines().skip(1) {
if let Some((k, v)) = line.split_once(':') {
headers.push((k.trim().to_string(), v.trim().to_string()));
}
}
}
}
Ok((u16::try_from(status).unwrap_or(0), headers))
}
fn header<'a>(headers: &'a [(String, String)], name: &str) -> Option<&'a str> {
headers
.iter()
.find(|(k, _)| k.eq_ignore_ascii_case(name))
.map(|(_, v)| v.as_str())
}
enum Source {
None,
Bytes { data: Arc<Vec<u8>>, at: usize },
File(std::fs::File),
Stream(Box<dyn Read + Send>),
}
fn read_some(reader: &mut dyn Read, buf: &mut [u8]) -> Result<usize, HttpError> {
loop {
match reader.read(buf) {
Ok(n) => return Ok(n),
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {}
Err(e) => return Err(HttpError::Io(e.to_string())),
}
}
}
struct Upload {
source: Source,
remaining: Option<u64>,
total: Option<u64>,
chunked: bool,
finished: bool,
sent: u64,
out: Vec<u8>,
out_body: usize,
}
impl Upload {
fn next(&mut self) -> Result<bool, HttpError> {
if self.finished {
return Ok(false);
}
let limit = self.remaining.map_or(PIECE, |r| {
usize::try_from(r.min(PIECE as u64)).unwrap_or(PIECE)
});
let mut data = vec![0u8; limit];
let n = if limit == 0 {
0
} else {
match &mut self.source {
Source::None => 0,
Source::Bytes { data: bytes, at } => {
let n = (bytes.len() - *at).min(limit);
data[..n].copy_from_slice(&bytes[*at..*at + n]);
*at += n;
n
}
Source::File(file) => read_some(file, &mut data)?,
Source::Stream(reader) => read_some(reader.as_mut(), &mut data)?,
}
};
data.truncate(n);
if let Some(remaining) = &mut self.remaining {
if n == 0 && *remaining > 0 {
return Err(HttpError::Io(
"the request body ended before its declared length".into(),
));
}
*remaining -= n as u64;
}
self.out_body = n;
if n == 0 {
self.finished = true;
if !self.chunked {
return Ok(false);
}
self.out = b"0\r\n\r\n".to_vec();
} else if self.chunked {
let mut framed = format!("{n:X}\r\n").into_bytes();
framed.extend_from_slice(&data);
framed.extend_from_slice(b"\r\n");
self.out = framed;
} else {
self.out = data;
}
Ok(true)
}
}
struct ExState {
events: Option<Events>,
head: bool,
reading: bool,
demand: u32,
closing: bool,
first_byte: Option<Duration>,
received: u64,
expected: Option<u64>,
}
struct Exchange {
session: Arc<Session>,
_identity: Option<Arc<ClientCert>>,
connection: HINTERNET,
request: HINTERNET,
url: String,
head_only: bool,
started: Instant,
buffer: UnsafeCell<Box<[u8]>>,
state: Mutex<ExState>,
upload: Mutex<Upload>,
}
unsafe impl Send for Exchange {}
unsafe impl Sync for Exchange {}
impl Exchange {
#[expect(
clippy::needless_pass_by_value,
reason = "the exchange takes over its caller's shares of the session and identity"
)]
fn begin(
session: Arc<Session>,
identity: Option<Arc<ClientCert>>,
prepared: Prepared,
events: Events,
) -> Result<Arc<Exchange>, HttpError> {
let api = session.api;
let mut headers: Vec<(String, String)> = prepared
.headers
.iter()
.filter(|(k, _)| {
!k.eq_ignore_ascii_case("content-length")
&& !k.eq_ignore_ascii_case("transfer-encoding")
})
.cloned()
.collect();
let length = match &prepared.body {
PreparedBody::Empty => Some(0),
PreparedBody::Bytes(data) => Some(data.len() as u64),
PreparedBody::File { len, .. } => Some(*len),
PreparedBody::Stream { len, .. } => *len,
};
let source = match prepared.body {
PreparedBody::Empty => Source::None,
PreparedBody::Bytes(data) => Source::Bytes { data, at: 0 },
PreparedBody::File { path, .. } => {
Source::File(std::fs::File::open(&path).map_err(|e| HttpError::Io(e.to_string()))?)
}
PreparedBody::Stream { reader, .. } => {
Source::Stream(reader.take().ok_or_else(|| {
HttpError::Io("the request body stream was already sent".into())
})?)
}
};
let total_length = if let Some(n) = length {
DWORD::try_from(n).unwrap_or_else(|_| {
headers.push(("Content-Length".into(), n.to_string()));
IGNORE_TOTAL_LENGTH
})
} else {
headers.push(("Transfer-Encoding".into(), "chunked".into()));
IGNORE_TOTAL_LENGTH
};
let opened = open_request(
&session,
identity.as_deref(),
&prepared.method,
&prepared.url,
&headers,
prepared.timeout_idle,
)?;
let exchange = Arc::new(Exchange {
session: session.clone(),
_identity: identity,
connection: opened.connection,
request: opened.request,
url: prepared.url,
head_only: prepared.method.eq_ignore_ascii_case("HEAD"),
started: Instant::now(),
buffer: UnsafeCell::new(vec![0u8; PIECE].into_boxed_slice()),
state: Mutex::new(ExState {
events: Some(events),
head: false,
reading: false,
demand: 0,
closing: false,
first_byte: None,
received: 0,
expected: None,
}),
upload: Mutex::new(Upload {
source,
remaining: length,
total: length,
chunked: length.is_none(),
finished: false,
sent: 0,
out: Vec::new(),
out_body: 0,
}),
});
let context = match attach(api, exchange.request, Context::Exchange(exchange.clone())) {
Ok(context) => context,
Err(error) => {
opened.close(api);
return Err(error);
}
};
let ok = unsafe {
(api.send)(
exchange.request,
std::ptr::null(),
0,
std::ptr::null(),
0,
total_length,
context,
)
};
if ok == 0 {
exchange.fail(last_error());
}
Ok(exchange)
}
fn api(&self) -> &'static Api {
self.session.api
}
fn emit(&self, event: Event) {
let events = lock(&self.state).events.clone();
if let Some(events) = events {
events(event);
}
}
fn write_next(&self) {
if lock(&self.state).events.is_none() {
return;
}
let piece = {
let mut upload = lock(&self.upload);
upload
.next()
.map(|more| more.then(|| (upload.out.as_ptr(), upload.out.len())))
};
match piece {
Ok(Some((data, len))) => {
let ok = unsafe {
(self.api().write_data)(
self.request,
data.cast(),
len as DWORD,
std::ptr::null_mut(),
)
};
if ok == 0 {
self.fail(last_error());
}
}
Ok(None) => self.receive_response(),
Err(error) => self.fail(error),
}
}
fn written(&self) {
let (sent, total, body) = {
let mut upload = lock(&self.upload);
upload.sent += upload.out_body as u64;
(upload.sent, upload.total, upload.out_body)
};
if body > 0 {
self.emit(Event::Sent { sent, total });
}
self.write_next();
}
fn receive_response(&self) {
if unsafe { (self.api().receive)(self.request, std::ptr::null_mut()) } == 0 {
self.fail(last_error());
}
}
fn head(&self) {
let (status, headers) = match read_head(self.api(), self.request) {
Ok(head) => head,
Err(error) => return self.fail(error),
};
let expected_length = match header(&headers, "content-encoding") {
Some(encoding) if !encoding.eq_ignore_ascii_case("identity") => None,
_ => header(&headers, "content-length").and_then(|v| v.trim().parse().ok()),
};
{
let mut st = lock(&self.state);
st.head = true;
st.first_byte = Some(self.started.elapsed());
let bodiless = self.head_only || matches!(status, 100..=199 | 204 | 304);
st.expected = expected_length.filter(|_| !bodiless);
}
self.emit(Event::Head(Head {
status,
headers,
url: self.url.clone(),
expected_length,
}));
self.pump();
}
fn pump(&self) {
{
let mut st = lock(&self.state);
if st.events.is_none() || !st.head || st.reading || st.demand == 0 {
return;
}
st.reading = true;
}
let ok = unsafe {
(self.api().read_data)(
self.request,
(*self.buffer.get()).as_mut_ptr().cast(),
PIECE as DWORD,
std::ptr::null_mut(),
)
};
if ok == 0 {
self.fail(last_error());
}
}
fn read(&self, n: usize) {
if n == 0 {
let short = {
let mut st = lock(&self.state);
st.reading = false;
let received = st.received;
st.expected
.filter(|&want| received < want)
.map(|want| (received, want))
};
if let Some((received, want)) = short {
return self.fail(HttpError::Io(format!(
"the connection closed after {received} of {want} body bytes"
)));
}
return self.finish();
}
let buffer: &[u8] = unsafe { &*self.buffer.get() };
let chunk = buffer[..n.min(PIECE)].to_vec();
{
let mut st = lock(&self.state);
st.reading = false;
st.demand = st.demand.saturating_sub(1);
st.received += n as u64;
}
self.emit(Event::Chunk(chunk));
self.pump();
}
fn finish(&self) {
let (events, first_byte, received) = {
let mut st = lock(&self.state);
(st.events.take(), st.first_byte, st.received)
};
let Some(events) = events else {
return;
};
let sent = lock(&self.upload).sent;
events(Event::Metrics(Metrics {
first_byte,
total: Some(self.started.elapsed()),
protocol: self.protocol(),
bytes_sent: Some(sent),
bytes_received: Some(received),
..Metrics::default()
}));
events(Event::End);
self.close();
}
fn protocol(&self) -> Option<String> {
let mut flags: DWORD = 0;
let mut len = std::mem::size_of::<DWORD>() as DWORD;
let ok = unsafe {
(self.api().query_option)(
self.request,
OPTION_HTTP_PROTOCOL_USED,
(&raw mut flags).cast(),
&raw mut len,
)
};
(ok != 0).then(|| {
if flags & PROTOCOL_FLAG_HTTP3 != 0 {
"h3".to_string()
} else if flags & PROTOCOL_FLAG_HTTP2 != 0 {
"h2".to_string()
} else {
"http/1.1".to_string()
}
})
}
fn fail(&self, error: HttpError) {
let events = lock(&self.state).events.take();
if let Some(events) = events {
events(Event::Failed(error));
}
self.close();
}
fn close(&self) {
{
let mut st = lock(&self.state);
if st.closing {
return;
}
st.closing = true;
}
unsafe { (self.api().close)(self.request) };
}
fn closed(&self) {
let events = lock(&self.state).events.take();
if let Some(events) = events {
events(Event::Failed(HttpError::Io("the request closed".into())));
}
unsafe { (self.api().close)(self.connection) };
}
}
impl Transfer for Exchange {
fn demand(&self, chunks: u32) {
{
let mut st = lock(&self.state);
st.demand = st.demand.saturating_add(chunks);
}
self.pump();
}
fn answer(&self, _id: QuestionId, _answer: Answer) {}
fn cancel(&self) {
let events = lock(&self.state).events.take();
if let Some(events) = events {
events(Event::Failed(HttpError::Cancelled));
}
self.close();
}
}
const CLOSE_REASON_MAX: usize = 123;
struct WsState {
events: Option<WsEvents>,
socket: HINTERNET,
open: bool,
request_closing: bool,
socket_closing: bool,
closing: bool,
demand: u32,
receiving: bool,
message: Vec<u8>,
queue: VecDeque<(u32, Vec<u8>, Completion)>,
sending: Vec<u8>,
sending_done: Option<Completion>,
}
enum Received {
More,
Message(Message),
Close,
}
struct WsConn {
session: Arc<Session>,
ws: &'static WsApi,
_identity: Option<Arc<ClientCert>>,
connection: HINTERNET,
request: HINTERNET,
buffer: UnsafeCell<Box<[u8]>>,
state: Mutex<WsState>,
}
unsafe impl Send for WsConn {}
unsafe impl Sync for WsConn {}
fn refuse(waiting: Vec<Completion>) {
for done in waiting {
done(Err(HttpError::Io("the WebSocket is closed".into())));
}
}
impl WsConn {
#[expect(
clippy::needless_pass_by_value,
reason = "the connection takes over its caller's shares of the session and identity"
)]
fn begin(
session: Arc<Session>,
ws: &'static WsApi,
identity: Option<Arc<ClientCert>>,
prepared: Prepared,
events: WsEvents,
) -> Result<Arc<WsConn>, HttpError> {
let api = session.api;
let mut headers = prepared.headers.clone();
if !prepared.protocols.is_empty() {
headers.push((
"Sec-WebSocket-Protocol".into(),
prepared.protocols.join(", "),
));
}
let opened = open_request(
&session,
identity.as_deref(),
"GET",
&prepared.url,
&headers,
prepared.timeout_idle,
)?;
let ok = unsafe {
(api.set_option)(
opened.request,
OPTION_UPGRADE_TO_WEB_SOCKET,
std::ptr::null(),
0,
)
};
if ok == 0 {
let error = last_error();
opened.close(api);
return Err(error);
}
let conn = Arc::new(WsConn {
session: session.clone(),
ws,
_identity: identity,
connection: opened.connection,
request: opened.request,
buffer: UnsafeCell::new(vec![0u8; PIECE].into_boxed_slice()),
state: Mutex::new(WsState {
events: Some(events),
socket: std::ptr::null_mut(),
open: false,
request_closing: false,
socket_closing: false,
closing: false,
demand: 0,
receiving: false,
message: Vec::new(),
queue: VecDeque::new(),
sending: Vec::new(),
sending_done: None,
}),
});
let context = match attach(api, conn.request, Context::Upgrade(conn.clone())) {
Ok(context) => context,
Err(error) => {
opened.close(api);
return Err(error);
}
};
let ok = unsafe {
(api.send)(
conn.request,
std::ptr::null(),
0,
std::ptr::null(),
0,
0,
context,
)
};
if ok == 0 {
conn.fail(last_error());
}
Ok(conn)
}
fn receive_response(&self) {
if unsafe { (self.session.api.receive)(self.request, std::ptr::null_mut()) } == 0 {
self.fail(last_error());
}
}
fn upgrade(self: &Arc<Self>) {
let (status, headers) = match read_head(self.session.api, self.request) {
Ok(head) => head,
Err(error) => return self.fail(error),
};
if status != 101 {
return self.fail(HttpError::Io(format!(
"the server answered {status} to the upgrade"
)));
}
let protocol = header(&headers, "sec-websocket-protocol")
.map(str::to_string)
.filter(|p| !p.is_empty());
let raw = Context::Socket(self.clone()).into_raw();
let socket = unsafe { (self.ws.complete_upgrade)(self.request, raw) };
if socket.is_null() {
let error = last_error();
drop(unsafe { Box::from_raw(raw as *mut Context) });
return self.fail(error);
}
let events = {
let mut st = lock(&self.state);
st.socket = socket;
st.open = true;
st.events.clone()
};
self.close_request();
let Some(events) = events else {
return self.close_socket();
};
events(WsEvent::Open { protocol });
self.flush();
self.pump();
}
fn pump(&self) {
let socket = {
let mut st = lock(&self.state);
if st.events.is_none()
|| !st.open
|| st.socket_closing
|| st.closing
|| st.receiving
|| st.demand == 0
{
return;
}
st.receiving = true;
st.socket
};
let rc = unsafe {
(self.ws.receive)(
socket,
(*self.buffer.get()).as_mut_ptr().cast(),
PIECE as DWORD,
std::ptr::null_mut(),
std::ptr::null_mut(),
)
};
if rc != 0 {
lock(&self.state).receiving = false;
self.fail(map_error(rc));
}
}
fn received(&self, n: usize, kind: u32) {
let (events, got) = {
let mut st = lock(&self.state);
let buffer: &[u8] = unsafe { &*self.buffer.get() };
let bytes = &buffer[..n.min(PIECE)];
st.message.extend_from_slice(bytes);
st.receiving = false;
#[expect(
clippy::match_same_arms,
reason = "the fragment arm names the two frame types the catch-all would otherwise hide"
)]
let got = match kind {
WS_BINARY_MESSAGE => {
Received::Message(Message::Binary(std::mem::take(&mut st.message)))
}
WS_UTF8_MESSAGE => {
let text = std::mem::take(&mut st.message);
Received::Message(Message::Text(String::from_utf8_lossy(&text).into_owned()))
}
WS_CLOSE => {
st.message.clear();
Received::Close
}
WS_BINARY_FRAGMENT | WS_UTF8_FRAGMENT => Received::More,
_ => Received::More,
};
if matches!(got, Received::Message(_)) {
st.demand = st.demand.saturating_sub(1);
}
(st.events.clone(), got)
};
match got {
Received::More => self.pump(),
Received::Message(message) => {
if let Some(events) = events {
events(WsEvent::Message(message));
}
self.pump();
}
Received::Close => self.peer_closed(),
}
}
fn peer_closed(&self) {
let socket = lock(&self.state).socket;
let (code, reason) = self.close_status(socket);
self.closed_with(code, reason, false);
let answer = if matches!(code, 1005 | 1006 | 1015) {
1000
} else {
code
};
let rc = unsafe { (self.ws.close)(socket, answer, std::ptr::null(), 0) };
if rc != 0 {
self.close_socket();
}
}
fn close_complete(&self, socket: HINTERNET) {
let (code, reason) = self.close_status(socket);
self.closed_with(code, reason, true);
}
fn close_status(&self, socket: HINTERNET) -> (u16, String) {
let mut code: u16 = 1005;
let mut reason = [0u8; CLOSE_REASON_MAX];
let mut len: DWORD = 0;
let rc = unsafe {
(self.ws.query_close_status)(
socket,
&raw mut code,
reason.as_mut_ptr().cast(),
CLOSE_REASON_MAX as DWORD,
&raw mut len,
)
};
if rc != 0 {
return (1005, String::new());
}
let len = (len as usize).min(CLOSE_REASON_MAX);
(code, String::from_utf8_lossy(&reason[..len]).into_owned())
}
fn closed_with(&self, code: u16, reason: String, close_socket: bool) {
let (events, waiting) = self.terminal();
if let Some(events) = events {
events(WsEvent::Closed { code, reason });
}
refuse(waiting);
if close_socket {
self.close_socket();
}
}
fn terminal(&self) -> (Option<WsEvents>, Vec<Completion>) {
let mut st = lock(&self.state);
let mut waiting: Vec<Completion> = st.queue.drain(..).map(|(_, _, done)| done).collect();
waiting.extend(st.sending_done.take());
(st.events.take(), waiting)
}
fn sent(&self) {
let done = lock(&self.state).sending_done.take();
if let Some(done) = done {
done(Ok(()));
}
self.flush();
}
fn flush(&self) {
loop {
let (socket, kind, data, len) = {
let mut st = lock(&self.state);
if st.events.is_none()
|| !st.open
|| st.socket_closing
|| st.closing
|| st.sending_done.is_some()
{
return;
}
let Some((kind, bytes, done)) = st.queue.pop_front() else {
return;
};
let Ok(len) = DWORD::try_from(bytes.len()) else {
drop(st);
done(Err(HttpError::Io(
"the message is too large to send".into(),
)));
continue;
};
st.sending = bytes;
st.sending_done = Some(done);
(st.socket, kind, st.sending.as_ptr(), len)
};
let rc = unsafe { (self.ws.send)(socket, kind, data.cast(), len) };
if rc == 0 {
return;
}
let done = lock(&self.state).sending_done.take();
if let Some(done) = done {
done(Err(map_error(rc)));
}
}
}
fn request_error(&self, code: DWORD) {
{
let mut st = lock(&self.state);
if st.closing && code == E_OPERATION_CANCELLED {
st.receiving = false;
return;
}
}
self.fail(map_error(code));
}
fn fail(&self, error: HttpError) {
let (events, waiting) = self.terminal();
if let Some(events) = events {
events(WsEvent::Failed(error));
}
refuse(waiting);
self.close_request();
self.close_socket();
}
fn close_request(&self) {
{
let mut st = lock(&self.state);
if st.request_closing {
return;
}
st.request_closing = true;
}
unsafe { (self.session.api.close)(self.request) };
}
fn close_socket(&self) {
let socket = {
let mut st = lock(&self.state);
if st.socket.is_null() || st.socket_closing {
return;
}
st.socket_closing = true;
st.socket
};
unsafe { (self.session.api.close)(socket) };
}
fn request_closed(&self) {
if !lock(&self.state).socket.is_null() {
return;
}
let (events, waiting) = self.terminal();
if let Some(events) = events {
events(WsEvent::Failed(HttpError::Io(
"the WebSocket handshake ended".into(),
)));
}
refuse(waiting);
unsafe { (self.session.api.close)(self.connection) };
}
fn socket_closed(&self) {
let (events, waiting) = self.terminal();
if let Some(events) = events {
events(WsEvent::Closed {
code: 1006,
reason: String::new(),
});
}
refuse(waiting);
unsafe { (self.session.api.close)(self.connection) };
}
}
impl Socket for WsConn {
fn send(&self, message: Message, done: Completion) {
let (kind, bytes) = match message {
Message::Text(text) => (WS_UTF8_MESSAGE, text.into_bytes()),
Message::Binary(bytes) => (WS_BINARY_MESSAGE, bytes),
Message::Close { code, reason } => {
self.close(code, &reason);
return done(Ok(()));
}
};
{
let mut st = lock(&self.state);
if st.events.is_none() {
drop(st);
return done(Err(HttpError::Io("the WebSocket is closed".into())));
}
st.queue.push_back((kind, bytes, done));
}
self.flush();
}
fn ping(&self, done: Completion) {
done(Err(HttpError::Unsupported));
}
fn close(&self, code: u16, reason: &str) {
let socket = {
let mut st = lock(&self.state);
if st.events.is_none() || st.closing {
return;
}
st.closing = st.open;
st.open.then_some(st.socket)
};
let Some(socket) = socket else {
self.closed_with(code, reason.to_string(), false);
return self.close_request();
};
let mut end = reason.len().min(CLOSE_REASON_MAX);
while !reason.is_char_boundary(end) {
end -= 1;
}
let data = if end == 0 {
std::ptr::null()
} else {
reason.as_ptr().cast()
};
let rc = unsafe { (self.ws.close)(socket, code, data, end as DWORD) };
if rc != 0 {
self.fail(map_error(rc));
}
}
fn demand(&self, messages: u32) {
{
let mut st = lock(&self.state);
st.demand = st.demand.saturating_add(messages);
}
self.pump();
}
}