115 lines
3.4 KiB
Rust
115 lines
3.4 KiB
Rust
use {
|
|
crate::{
|
|
dbus::{incoming::handle_incoming, outgoing::handle_outgoing, DbusError, DbusSocket},
|
|
utils::{errorfmt::ErrorFmt, hex},
|
|
},
|
|
std::{io::Write, rc::Rc},
|
|
uapi::{c, Errno},
|
|
};
|
|
|
|
pub(super) async fn handle_auth(socket: Rc<DbusSocket>) {
|
|
let mut auth = Auth {
|
|
socket: socket.clone(),
|
|
buf: Box::new([0; BUF_SIZE]),
|
|
buf_start: 0,
|
|
buf_stop: 0,
|
|
};
|
|
auth.run().await;
|
|
}
|
|
|
|
const BUF_SIZE: usize = 128;
|
|
|
|
struct Auth {
|
|
socket: Rc<DbusSocket>,
|
|
|
|
buf: Box<[u8; BUF_SIZE]>,
|
|
buf_start: usize,
|
|
buf_stop: usize,
|
|
}
|
|
|
|
impl Auth {
|
|
async fn run(&mut self) {
|
|
if let Err(e) = self.handle_auth().await {
|
|
log::error!(
|
|
"{}: Could not authenticate to dbus socket: {}",
|
|
self.socket.bus_name,
|
|
ErrorFmt(e)
|
|
);
|
|
self.socket.kill();
|
|
return;
|
|
}
|
|
log::info!("{}: Authenticated", self.socket.bus_name);
|
|
self.socket.incoming.set(Some(
|
|
self.socket.eng.spawn(handle_incoming(self.socket.clone())),
|
|
));
|
|
self.socket.outgoing_.set(Some(
|
|
self.socket.eng.spawn(handle_outgoing(self.socket.clone())),
|
|
));
|
|
self.socket.auth.take();
|
|
}
|
|
|
|
async fn handle_auth(&mut self) -> Result<(), DbusError> {
|
|
let uid = hex::to_hex(&uapi::getuid().to_string());
|
|
let mut out_buf = Vec::new();
|
|
let _ = write!(out_buf, "\0AUTH EXTERNAL {}\r\n", uid);
|
|
self.write_buf(&mut out_buf).await?;
|
|
let line = self.readline().await?;
|
|
let (cmd, _) = line_to_cmd(&line);
|
|
if cmd != "OK" {
|
|
return Err(DbusError::Auth);
|
|
}
|
|
let _ = write!(out_buf, "NEGOTIATE_UNIX_FD\r\n");
|
|
self.write_buf(&mut out_buf).await?;
|
|
let line = self.readline().await?;
|
|
let (cmd, _) = line_to_cmd(&line);
|
|
if cmd != "AGREE_UNIX_FD" {
|
|
return Err(DbusError::UnixFd);
|
|
}
|
|
let _ = write!(out_buf, "BEGIN\r\n");
|
|
self.write_buf(&mut out_buf).await?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn readline(&mut self) -> Result<String, DbusError> {
|
|
let mut s = String::new();
|
|
loop {
|
|
for i in self.buf_start..self.buf_stop {
|
|
let c = self.buf[i % BUF_SIZE] as char;
|
|
s.push(c);
|
|
if c == '\n' {
|
|
self.buf_start = i + 1;
|
|
return Ok(s);
|
|
}
|
|
}
|
|
self.buf_start = 0;
|
|
self.buf_stop = 0;
|
|
match uapi::read(self.socket.fd.raw(), &mut self.buf[..]) {
|
|
Ok(n) => self.buf_stop = n.len(),
|
|
Err(Errno(c::EAGAIN)) => {
|
|
self.socket.fd.readable().await?;
|
|
}
|
|
Err(e) => return Err(DbusError::ReadError(e.into())),
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn write_buf(&mut self, buf: &mut Vec<u8>) -> Result<(), DbusError> {
|
|
let mut start = 0;
|
|
while start < buf.len() {
|
|
match uapi::write(self.socket.fd.raw(), &buf[start..]) {
|
|
Ok(n) => start += n,
|
|
Err(Errno(c::EAGAIN)) => {
|
|
self.socket.fd.writable().await?;
|
|
}
|
|
Err(e) => return Err(DbusError::WriteError(e.into())),
|
|
}
|
|
}
|
|
buf.clear();
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn line_to_cmd(line: &str) -> (&str, &str) {
|
|
let line = line.trim();
|
|
line.split_once(' ').unwrap_or((line, ""))
|
|
}
|