use ntlmssp::Ntlm;
use tokio::net::TcpStream;
use crate::error::{Error, Result};
use crate::login7::Login7;
use crate::packet::PacketType;
use crate::prelogin::{encryption, PreLogin};
use crate::token::{parse_all, Token};
use crate::transport::{AsyncStream, Transport};
#[derive(Debug, Clone)]
pub struct Column {
pub name: String,
pub type_id: u8,
}
#[derive(Debug, Clone, Default)]
pub struct Row {
pub values: Vec<String>,
}
#[derive(Debug, Default, Clone)]
pub struct ResultSet {
pub columns: Vec<Column>,
pub rows: Vec<Row>,
pub messages: Vec<String>,
pub row_count: u64,
}
impl ResultSet {
pub fn empty() -> Self {
Self::default()
}
}
pub struct TdsClient {
transport: Transport,
server: String,
logged_in: bool,
encrypted: bool,
}
impl TdsClient {
pub async fn connect(host: &str, port: u16, _instance: Option<&str>) -> Result<Self> {
let stream = TcpStream::connect((host, port)).await?;
Self::from_stream(Box::new(stream), host.to_string()).await
}
pub async fn from_stream(stream: Box<dyn AsyncStream>, server: String) -> Result<Self> {
let mut transport = Transport::new_boxed(stream);
let mut pre = PreLogin::new_default();
pre.encryption = encryption::OFF;
transport.send(PacketType::PreLogin, &pre.encode()).await?;
let (kind, body) = transport.recv().await?;
if kind != PacketType::TabularResult && kind != PacketType::PreLogin {
return Err(Error::Protocol("prelogin: unexpected response type"));
}
let server_pre = PreLogin::decode(&body)?;
let encrypted = match server_pre.encryption {
encryption::REQ | encryption::ON => {
let cfg = crate::tls::client_config_trust_any();
transport = crate::tls::upgrade_to_tls(transport, &server, cfg).await?;
true
}
encryption::OFF | encryption::NOT_SUP => false,
_ => return Err(Error::Protocol("prelogin: unknown ENCRYPTION value")),
};
Ok(Self {
transport,
server,
logged_in: false,
encrypted,
})
}
pub fn is_encrypted(&self) -> bool {
self.encrypted
}
pub async fn login_ntlm(&mut self, domain: &str, user: &str, password: &str) -> Result<()> {
let ntlm = Ntlm::new();
let type1 = ntlm.negotiate().to_vec();
let host = hostname_fallback();
let login = Login7::new_sspi(&host, &self.server, "", type1);
self.transport
.send(PacketType::Login7, &login.encode())
.await?;
loop {
let (_kind, body) = self.transport.recv().await?;
let tokens = parse_all(&body)?;
let mut sent_type3 = false;
for tok in tokens {
match tok {
Token::Sspi(challenge) => {
let (type3, _key) =
ntlm.authenticate(&challenge, domain, user, password, &host)?;
self.transport.send(PacketType::Sspi, &type3).await?;
sent_type3 = true;
}
Token::LoginAck { .. } => {
self.logged_in = true;
return Ok(());
}
Token::Error {
number, message, ..
} => {
return Err(Error::Server {
code: number,
message,
});
}
_ => {}
}
}
if !sent_type3 {
return Err(Error::Protocol(
"login: no SSPI challenge or LOGINACK in response",
));
}
}
}
pub async fn sql_batch(&mut self, query: &str) -> Result<ResultSet> {
let mut payload = Vec::with_capacity(22 + query.len() * 2);
let mut td = Vec::with_capacity(18);
td.extend_from_slice(&18u32.to_le_bytes()); td.extend_from_slice(&2u16.to_le_bytes()); td.extend_from_slice(&0u64.to_le_bytes()); td.extend_from_slice(&1u32.to_le_bytes()); let total_all_headers = (4 + td.len()) as u32;
payload.extend_from_slice(&total_all_headers.to_le_bytes());
payload.extend_from_slice(&td);
for u in query.encode_utf16() {
payload.extend_from_slice(&u.to_le_bytes());
}
self.transport.send(PacketType::SqlBatch, &payload).await?;
let (_, body) = self.transport.recv().await?;
let mut rs = ResultSet::empty();
let tokens = match parse_all(&body) {
Ok(t) => t,
Err(Error::Unsupported(_)) => Vec::new(),
Err(e) => return Err(e),
};
for tok in tokens {
match tok {
Token::Error {
number, message, ..
} => {
return Err(Error::Server {
code: number,
message,
});
}
Token::Info { message, .. } => rs.messages.push(message),
Token::Done { row_count, .. } => rs.row_count = row_count,
_ => {}
}
}
Ok(rs)
}
pub fn is_logged_in(&self) -> bool {
self.logged_in
}
}
fn hostname_fallback() -> String {
std::env::var("COMPUTERNAME")
.or_else(|_| std::env::var("HOSTNAME"))
.unwrap_or_else(|_| "ms-tds-client".to_string())
}