use std::io::{Read, Write};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use bytes::BytesMut;
use symqtt_codec::QoS;
use symqtt_codec::v5 as codec;
use symqtt_codec::v5::{AuthProperties, AuthStatus};
use crate::pinger::Pinger;
use crate::transport::{Transport, WriteTimeout, Writer};
use crate::v5::auth::{AuthHandler, NoOpAuthHandler};
use crate::v5::error::Error;
use crate::v5::session::{Retransmit, ServerProperties, Session};
use crate::v5::token::{PublishAckDetail, Token};
use crate::v5::topic_alias::{InboundTopicAliases, OutboundTopicAliases};
use crate::v5::{ConnectOptions, InboundHandler, PublishMessage, SubscribeFilter};
enum HandshakePacket {
ConnAck(codec::ConnAck),
Auth(codec::Auth),
}
pub struct Client<H: InboundHandler, T: Transport, A: AuthHandler = NoOpAuthHandler> {
inner: Arc<ClientInner<H, T::Write, A>>,
}
impl<H: InboundHandler, T: Transport, A: AuthHandler> std::fmt::Debug for Client<H, T, A> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Client")
.field("connected", &self.is_connected())
.finish_non_exhaustive()
}
}
struct ClientInner<H, W, A> {
handler: H,
auth_handler: A,
pinger: Pinger,
session: Session,
alive: AtomicBool,
opts: ConnectOptions,
writer: Mutex<Option<Writer<W>>>,
stop_tx: Mutex<Option<mpsc::SyncSender<()>>>,
read_done_rx: Mutex<Option<mpsc::Receiver<()>>>,
keepalive_done_rx: Mutex<Option<mpsc::Receiver<()>>>,
outbound_aliases: Mutex<OutboundTopicAliases>,
inbound_aliases: Mutex<InboundTopicAliases>,
reauth_tx: Mutex<Option<mpsc::SyncSender<Result<(), Error>>>>,
}
impl<H: InboundHandler, T: Transport> Client<H, T, NoOpAuthHandler> {
pub fn connect(opts: ConnectOptions, handler: H, session: Session, transport: T) -> Result<Self, Error> {
Self::connect_with_auth(opts, handler, session, transport, NoOpAuthHandler)
}
}
impl<H: InboundHandler, T: Transport, A: AuthHandler> Client<H, T, A> {
pub fn connect_with_auth(
opts: ConnectOptions,
handler: H,
session: Session,
transport: T,
auth_handler: A,
) -> Result<Self, Error> {
log::debug!("connecting as client_id={:?}", opts.client_id);
let pinger = Pinger::new(opts.keep_alive, opts.ping_timeout());
let (reader, writer_half) = transport.split();
let (read_down_tx, read_down_rx) = mpsc::sync_channel::<()>(1);
let (handshake_tx, handshake_rx) = mpsc::sync_channel::<HandshakePacket>(4);
let client_alias_max = opts.topic_alias_maximum.unwrap_or(0);
let inner = Arc::new(ClientInner {
opts,
pinger,
handler,
session,
auth_handler,
writer: Mutex::new(Some(Writer {
stream: writer_half,
buf: BytesMut::with_capacity(4096),
})),
alive: AtomicBool::new(false),
stop_tx: Mutex::new(None),
read_done_rx: Mutex::new(Some(read_down_rx)),
keepalive_done_rx: Mutex::new(None),
outbound_aliases: Mutex::new(OutboundTopicAliases::new(0)), inbound_aliases: Mutex::new(InboundTopicAliases::new(client_alias_max)),
reauth_tx: Mutex::new(None),
});
let inner_ = inner.clone();
std::thread::Builder::new()
.name(format!("m5-r-{}", inner.opts.client_id))
.spawn(move || {
let _guard = read_down_tx;
inner_.read_loop(reader, handshake_tx);
})?;
if let Err(e) = inner.handshake(handshake_rx) {
log::warn!("handshake failed: {e}");
inner.alive.store(false, Ordering::SeqCst);
if let Some(w) = inner.writer.lock().unwrap().take() {
let _ = w.shutdown();
}
return Err(e);
}
let effective_keepalive = inner.effective_keepalive();
inner.pinger.set_keepalive(effective_keepalive);
if effective_keepalive.as_secs() > 0 {
let (stop_tx, stop_rx) = mpsc::sync_channel::<()>(1);
let (keepalive_down_tx, keepalive_down_rx) = mpsc::sync_channel::<()>(1);
*inner.stop_tx.lock().unwrap() = Some(stop_tx);
*inner.keepalive_done_rx.lock().unwrap() = Some(keepalive_down_rx);
let inner_ = inner.clone();
std::thread::Builder::new()
.name(format!("m5-ka-{}", inner_.opts.client_id))
.spawn(move || {
let _guard = keepalive_down_tx;
inner_.keepalive(stop_rx);
})?;
}
log::debug!("connected successfully");
Ok(Self { inner })
}
pub fn is_connected(&self) -> bool {
self.inner.alive.load(Ordering::Relaxed)
}
pub fn server_properties(&self) -> ServerProperties {
self.inner.session.server_properties()
}
pub fn publish(&self, msg: &PublishMessage<'_>) -> Result<Option<Token<PublishAckDetail>>, Error> {
log::debug!(
"publishing topic={:?} qos={:?} retain={} payload_len={}",
msg.topic,
msg.qos,
msg.retain,
msg.payload.len()
);
let server = self.inner.session.server_properties();
if msg.qos > server.maximum_qos {
return Err(Error::QosNotSupported {
requested: msg.qos,
max: server.maximum_qos,
});
}
if msg.retain && !server.retain_available {
return Err(Error::RetainNotSupported);
}
let mut publish = codec::Publish::from(msg);
if let Some((alias, ok)) = self.inner.outbound_aliases.lock().unwrap().resolve(msg.topic) {
publish.properties.topic_alias = Some(alias);
if ok {
publish.topic = String::new(); }
}
if matches!(msg.qos, QoS::AtMostOnce) {
let pkt = codec::Packet::Publish(publish);
self.inner.send_packet(&pkt, msg.timeout)?;
return Ok(None);
}
let pkid = self
.inner
.session
.alloc_pkid()
.ok_or(Error::WindowFull(server.receive_maximum))?;
publish.pkid = Some(pkid);
let mut inflight = codec::Publish::from(msg);
inflight.pkid = Some(pkid);
let rx = self.inner.session.track_publish(pkid, inflight);
let pkt = codec::Packet::Publish(publish);
if let Err(e) = self.inner.send_packet(&pkt, msg.timeout) {
log::warn!("failed to send publish pkid={pkid}: {e}");
self.inner.session.release_pkid(pkid);
return Err(e);
}
log::debug!(
"publish sent, pkid={pkid} topic={:?} qos={:?} payload_len={}",
msg.topic,
msg.qos,
msg.payload.len()
);
Ok(Some(Token::new(rx)))
}
pub fn subscribe(
&self,
filters: &[SubscribeFilter],
properties: Option<codec::SubscribeProperties>,
timeout: Option<Duration>,
) -> Result<Token<Vec<codec::ReasonCode>>, Error> {
if let Some(ref props) = properties {
if props.subscription_identifier.is_some() && !self.inner.session.server_properties().sub_id_available {
return Err(Error::SubscriptionIdNotSupported);
}
}
let pkid = self
.inner
.session
.alloc_pkid()
.ok_or(Error::WindowFull(self.inner.session.receive_maximum()))?;
let pkt = codec::Packet::Subscribe(codec::Subscribe {
pkid,
properties: properties.unwrap_or_default(),
filters: filters.iter().map(codec::SubscribeFilter::from).collect(),
});
let rx = self.inner.session.track_sub(pkid);
if let Err(e) = self.inner.send_packet(&pkt, timeout) {
log::warn!("failed to send subscribe pkid={pkid}: {e}");
self.inner.session.release_pkid(pkid);
return Err(e);
}
log::debug!("subscribe sent, pkid={pkid} filters={filters:?}");
Ok(Token::new(rx))
}
pub fn unsubscribe(
&self,
topics: &[&str],
properties: Option<codec::UnsubscribeProperties>,
timeout: Option<Duration>,
) -> Result<Token<Vec<codec::ReasonCode>>, Error> {
let pkid = self
.inner
.session
.alloc_pkid()
.ok_or(Error::WindowFull(self.inner.session.receive_maximum()))?;
let pkt = codec::Packet::Unsubscribe(codec::Unsubscribe {
pkid,
properties: properties.unwrap_or_default(),
topics: topics.iter().map(ToString::to_string).collect(),
});
let rx = self.inner.session.track_sub(pkid);
if let Err(e) = self.inner.send_packet(&pkt, timeout) {
log::warn!("failed to send unsubscribe pkid={pkid}: {e}");
self.inner.session.release_pkid(pkid);
return Err(e);
}
log::debug!("unsubscribe sent, pkid={pkid} topics={topics:?}");
Ok(Token::new(rx))
}
pub fn reauthenticate(&self, timeout: Option<Duration>) -> Result<(), Error> {
log::debug!("initiating re-authentication");
let auth_method = self
.inner
.opts
.auth_method
.as_ref()
.ok_or(Error::AuthFailed(symqtt_codec::v5::ReasonCode::NotAuthorized))?
.clone();
let initial_data = self.inner.auth_handler.on_auth_continue(None);
let (tx, rx) = mpsc::sync_channel(1);
*self.inner.reauth_tx.lock().unwrap() = Some(tx);
let pkt = codec::Packet::Auth(codec::Auth {
status: AuthStatus::ReAuthenticate,
properties: AuthProperties {
authentication_method: Some(auth_method),
authentication_data: initial_data,
..Default::default()
},
});
self.inner.send_packet(&pkt, timeout)?;
match timeout {
Some(t) => rx.recv_timeout(t).map_err(|_| Error::Timeout)?,
None => rx.recv().map_err(|_| Error::Disconnected)?,
}
}
pub fn disconnect(&self, reason: codec::ReasonCode, timeout: Option<Duration>) {
log::debug!("disconnecting with reason={reason:?}");
let deadline = timeout.map(|t| Instant::now() + t);
self.inner.graceful_close(reason, timeout, true);
wait_thread(self.inner.read_done_rx.lock().unwrap().take(), deadline);
wait_thread(self.inner.keepalive_done_rx.lock().unwrap().take(), deadline);
}
}
impl<H: InboundHandler, T: Transport, A: AuthHandler> Drop for Client<H, T, A> {
fn drop(&mut self) {
if !self.inner.alive.load(Ordering::Relaxed) {
return;
}
log::debug!("Client dropped, sending DISCONNECT");
self.inner
.graceful_close(codec::ReasonCode::Success, Some(Duration::from_secs(1)), false);
}
}
impl<H: InboundHandler, W: Write + WriteTimeout + Send, A: AuthHandler> ClientInner<H, W, A> {
fn effective_keepalive(&self) -> Duration {
let server_ka = self.session.server_properties().server_keep_alive;
match server_ka {
Some(secs) => Duration::from_secs(secs as u64),
None => self.opts.keep_alive,
}
}
fn handshake(&self, hs_rx: mpsc::Receiver<HandshakePacket>) -> Result<(), Error> {
let deadline = self.opts.connect_timeout.map(|v| Instant::now() + v);
let connect = codec::Connect::from(&self.opts);
self.send_packet(&codec::Packet::Connect(connect), self.opts.connect_timeout)?;
self.alive.store(true, Ordering::SeqCst);
let connack = loop {
let pkt = match deadline {
Some(ddl) => hs_rx
.recv_timeout(ddl.saturating_duration_since(Instant::now()))
.map_err(|_| Error::Timeout)?,
None => hs_rx.recv().map_err(|_| Error::Disconnected)?,
};
match pkt {
HandshakePacket::ConnAck(connack) => break connack,
HandshakePacket::Auth(auth) => {
if auth.status != AuthStatus::Continue {
return Err(Error::AuthFailed(codec::ReasonCode::NotAuthorized));
}
let response_data = self
.auth_handler
.on_auth_continue(auth.properties.authentication_data.as_ref())
.ok_or(Error::AuthFailed(codec::ReasonCode::NotAuthorized))?;
let reply = codec::Packet::Auth(codec::Auth {
status: AuthStatus::Continue,
properties: AuthProperties {
authentication_method: self.opts.auth_method.clone(),
authentication_data: Some(response_data),
..Default::default()
},
});
self.send_packet(&reply, self.opts.connect_timeout)?;
}
}
};
if connack.reason_code != codec::ReasonCode::Success {
return Err(Error::ConnectRefused(
connack.reason_code,
connack.properties.reason_string.clone(),
));
}
log::debug!(
"connack received, session_present={}, reason_code={:?}, properties={:?}",
connack.session_present,
connack.reason_code,
connack.properties,
);
let retransmits = self.session.on_connack(&connack);
let server_alias_max = connack.properties.topic_alias_maximum.unwrap_or(0);
self.outbound_aliases.lock().unwrap().reset(server_alias_max);
let client_alias_max = self.opts.topic_alias_maximum.unwrap_or(0);
self.inbound_aliases.lock().unwrap().reset(client_alias_max);
log::debug!("retransmitting {} inflight messages", retransmits.len());
for item in retransmits {
let pkt = match item {
Retransmit::Publish(p) => codec::Packet::Publish(*p),
Retransmit::PubRel { pkid } => codec::Packet::PubRel(codec::PubRel {
pkid,
reason_code: codec::ReasonCode::Success,
properties: codec::PubRelProperties::default(),
}),
};
if let Err(e) = self.send_packet(&pkt, None) {
log::warn!("failed to retransmit packet: {e}");
}
}
self.auth_handler.on_authenticated();
Ok(())
}
fn graceful_close(&self, reason: codec::ReasonCode, timeout: Option<Duration>, notify: bool) {
let pkt = codec::Packet::Disconnect(codec::Disconnect {
reason_code: reason,
properties: codec::DisconnectProperties::default(),
});
let _ = self.send_packet(&pkt, timeout);
self.terminate(Error::Disconnected, true, notify);
}
fn terminate(&self, error: Error, graceful: bool, notify: bool) {
if !self.alive.swap(false, Ordering::SeqCst) {
return;
}
log::debug!("terminating: graceful={graceful} reason={error}");
if let Some(w) = self.writer.lock().unwrap().take() {
let _ = w.shutdown();
}
self.stop_tx.lock().unwrap().take();
if let Some(tx) = self.reauth_tx.lock().unwrap().take() {
let _ = tx.try_send(Err(error.clone()));
}
if graceful {
self.session.on_disconnect();
} else {
self.session.on_connection_lost();
}
if notify {
self.handler.on_disconnect(&error);
}
}
fn read_loop(&self, mut reader: impl Read, hs_tx: mpsc::SyncSender<HandshakePacket>) {
let mut tmp = [0u8; 4096];
let mut buf = BytesMut::with_capacity(8192);
loop {
if let Err(e) = self.drain_decoded_packets(&mut buf, &hs_tx) {
self.terminate(e, false, true);
return;
}
let n = match reader.read(&mut tmp) {
Ok(0) => break,
Ok(n) => n,
Err(ref e) => {
if (e.kind() == std::io::ErrorKind::TimedOut || e.kind() == std::io::ErrorKind::WouldBlock)
&& !self.alive.load(Ordering::SeqCst)
{
return;
} else {
break;
}
}
};
buf.extend_from_slice(&tmp[..n]);
}
self.terminate(Error::Disconnected, false, true);
}
fn keepalive(&self, stop_rx: mpsc::Receiver<()>) {
let ping_timeout = self.opts.ping_timeout.or(Some(Duration::from_secs(3)));
loop {
match self.pinger.poll() {
crate::pinger::PingerAction::Sleep(dur) => match stop_rx.recv_timeout(dur) {
Ok(()) | Err(mpsc::RecvTimeoutError::Disconnected) => return,
Err(mpsc::RecvTimeoutError::Timeout) => {}
},
crate::pinger::PingerAction::SendPing => {
if let Err(e) = self.send_packet(&codec::Packet::PingReq(codec::PingReq), ping_timeout) {
log::warn!("PingReq send failed: {e}");
self.terminate(e, false, true);
return;
}
self.pinger.record_ping_sent();
}
crate::pinger::PingerAction::TimedOut => {
log::warn!("ping response timed out, terminating connection");
self.terminate(Error::PingTimeout, false, true);
return;
}
}
}
}
fn drain_decoded_packets(
&self,
buf: &mut BytesMut,
hs_tx: &mpsc::SyncSender<HandshakePacket>,
) -> Result<(), Error> {
loop {
match codec::Packet::decode(buf) {
Ok(Some(pkt)) => {
self.pinger.record_received();
match pkt {
codec::Packet::ConnAck(connack) => {
let _ = hs_tx.try_send(HandshakePacket::ConnAck(connack));
continue;
}
codec::Packet::Auth(auth) => {
if hs_tx.try_send(HandshakePacket::Auth(auth.clone())).is_err() {
self.handle_post_connect_auth(auth)?;
}
continue;
}
_ => {}
}
self.dispatch_packet(pkt)?;
}
Ok(None) => return Ok(()),
Err(e) => {
log::warn!("packet decode error: {e}");
return Err(Error::Decode(e));
}
}
}
}
fn dispatch_packet(&self, pkt: codec::Packet) -> Result<(), Error> {
match pkt {
codec::Packet::PubAck(ack) => {
log::debug!("received PubAck pkid={} reason={:?}", ack.pkid, ack.reason_code);
let _ = self.session.on_puback(ack.pkid, ack.reason_code, ack.properties);
}
codec::Packet::PubRec(rec) => {
log::debug!("received PubRec pkid={} reason={:?}", rec.pkid, rec.reason_code);
match self.session.on_pubrec(rec.pkid, rec.reason_code) {
Ok(true) => {
log::debug!("sending PubRel pkid={}", rec.pkid);
let pubrel = codec::Packet::PubRel(codec::PubRel {
pkid: rec.pkid,
reason_code: codec::ReasonCode::Success,
properties: codec::PubRelProperties::default(),
});
self.send_packet(&pubrel, None)?;
}
Ok(false) => {} Err(_) => {}
}
}
codec::Packet::PubComp(comp) => {
log::debug!("received PubComp pkid={} reason={:?}", comp.pkid, comp.reason_code);
let _ = self.session.on_pubcomp(comp.pkid, comp.reason_code, comp.properties);
}
codec::Packet::Publish(mut publish) => {
let resolved_topic = self
.inbound_aliases
.lock()
.unwrap()
.resolve(&publish.topic, publish.properties.topic_alias)?;
publish.topic = resolved_topic;
log::debug!(
"received Publish topic={:?} qos={:?} pkid={:?} payload_len={}",
publish.topic,
publish.qos,
publish.pkid,
publish.payload.len()
);
self.handle_inbound_publish(&publish)?;
}
codec::Packet::SubAck(suback) => {
log::debug!("received SubAck pkid={} codes={:?}", suback.pkid, suback.reason_codes);
self.session
.on_suback(suback.pkid, suback.reason_codes, suback.properties);
}
codec::Packet::UnsubAck(unsuback) => {
log::debug!(
"received UnsubAck pkid={} codes={:?}",
unsuback.pkid,
unsuback.reason_codes
);
self.session
.on_unsuback(unsuback.pkid, unsuback.reason_codes, unsuback.properties);
}
codec::Packet::PingResp(_) => {
log::debug!("received PingResp");
self.pinger.record_ping_response();
}
codec::Packet::PubRel(pubrel) => {
log::debug!("received PubRel pkid={}, sending PubComp", pubrel.pkid);
let _ = self.session.release_incoming(pubrel.pkid);
let pubcomp = codec::Packet::PubComp(codec::PubComp {
pkid: pubrel.pkid,
reason_code: codec::ReasonCode::Success,
properties: codec::PubCompProperties::default(),
});
self.send_packet(&pubcomp, None)?;
}
codec::Packet::Disconnect(disconnect) => {
log::debug!("received server Disconnect reason={:?}", disconnect.reason_code);
self.handler.on_server_disconnect(&disconnect);
self.terminate(Error::ServerDisconnect(disconnect.reason_code), false, true);
}
_ => {}
}
Ok(())
}
fn handle_post_connect_auth(&self, auth: codec::Auth) -> Result<(), Error> {
match auth.status {
AuthStatus::Continue => {
let response_data = self
.auth_handler
.on_auth_continue(auth.properties.authentication_data.as_ref())
.ok_or(Error::AuthFailed(codec::ReasonCode::NotAuthorized))?;
let reply = codec::Packet::Auth(codec::Auth {
status: AuthStatus::Continue,
properties: AuthProperties {
authentication_method: self.opts.auth_method.clone(),
authentication_data: Some(response_data),
..Default::default()
},
});
self.send_packet(&reply, None)?;
}
AuthStatus::Success => {
self.auth_handler.on_authenticated();
if let Some(tx) = self.reauth_tx.lock().unwrap().take() {
let _ = tx.try_send(Ok(()));
}
}
AuthStatus::ReAuthenticate => {
log::debug!("unexpected ReAuthenticate status from server, ignoring");
}
}
Ok(())
}
fn handle_inbound_publish(&self, publish: &codec::Publish) -> Result<(), Error> {
match publish.qos {
QoS::AtMostOnce => {
self.handler.on_publish(publish);
}
QoS::AtLeastOnce => {
self.handler.on_publish(publish);
if let Some(pkid) = publish.pkid {
log::debug!("sending PubAck pkid={pkid}");
let puback = codec::Packet::PubAck(codec::PubAck {
pkid,
reason_code: codec::ReasonCode::Success,
properties: codec::PubAckProperties::default(),
});
self.send_packet(&puback, None)?;
}
}
QoS::ExactlyOnce => {
if let Some(pkid) = publish.pkid {
let is_dup = self.session.track_incoming(pkid);
if !is_dup {
self.handler.on_publish(publish);
}
log::debug!("sending PubRec pkid={pkid} dup={is_dup}");
let pubrec = codec::Packet::PubRec(codec::PubRec {
pkid,
reason_code: codec::ReasonCode::Success,
properties: codec::PubRecProperties::default(),
});
self.send_packet(&pubrec, None)?;
}
}
}
Ok(())
}
fn send_packet(&self, pkt: &codec::Packet, timeout: Option<Duration>) -> Result<(), Error> {
if !self.alive.load(Ordering::Relaxed) && !matches!(pkt, codec::Packet::Connect(_)) {
return Err(Error::Disconnected);
}
{
let mut guard = self.writer.lock().unwrap();
let Writer { stream, buf } = guard.as_mut().ok_or(Error::Disconnected)?;
buf.clear();
pkt.encode(buf)?;
if !matches!(pkt, codec::Packet::Connect(_)) {
let server = self.session.server_properties();
if server.maximum_packet_size > 0 && buf.len() > server.maximum_packet_size as usize {
return Err(Error::PacketTooLarge {
size: buf.len(),
max: server.maximum_packet_size,
});
}
}
log::trace!("sending {} ({} bytes)", packet_name(pkt), buf.len());
stream.set_write_timeout(timeout)?;
stream.write_all(buf)?;
stream.flush()?;
}
self.pinger.record_sent();
Ok(())
}
}
fn wait_thread(rx: Option<mpsc::Receiver<()>>, deadline: Option<Instant>) {
if let Some(rx) = rx {
match deadline {
Some(dl) => {
let _ = rx.recv_timeout(dl.saturating_duration_since(Instant::now()));
}
None => {
let _ = rx.recv();
}
}
}
}
fn packet_name(pkt: &codec::Packet) -> &'static str {
match pkt {
codec::Packet::Connect(_) => "CONNECT",
codec::Packet::ConnAck(_) => "CONNACK",
codec::Packet::Publish(_) => "PUBLISH",
codec::Packet::PubAck(_) => "PUBACK",
codec::Packet::PubRec(_) => "PUBREC",
codec::Packet::PubRel(_) => "PUBREL",
codec::Packet::PubComp(_) => "PUBCOMP",
codec::Packet::Subscribe(_) => "SUBSCRIBE",
codec::Packet::SubAck(_) => "SUBACK",
codec::Packet::Unsubscribe(_) => "UNSUBSCRIBE",
codec::Packet::UnsubAck(_) => "UNSUBACK",
codec::Packet::PingReq(_) => "PINGREQ",
codec::Packet::PingResp(_) => "PINGRESP",
codec::Packet::Disconnect(_) => "DISCONNECT",
codec::Packet::Auth(_) => "AUTH",
}
}