Update to support the latest KeePassXC

src/main.rs

@@ -14,58 +14,58 @@ use proxy_socket::ProxySocket;
 const BUFFER_SIZE: u32 = 1024 ^ 2;	 // 1024 ^ 2 is the maximum
 
 fn valid_length(length: u32) -> bool {
-	return length > 0 && length <= BUFFER_SIZE;
+    return length > 0 && length <= BUFFER_SIZE;
 }
 
 fn read_header() -> u32 {
-	let stdin = io::stdin();
-	let mut buf = vec![0; 4];
-	let mut handle = stdin.lock();
+    let stdin = io::stdin();
+    let mut buf = vec![0; 4];
+    let mut handle = stdin.lock();
 
-	handle.read_exact(&mut buf).unwrap();
-	NativeEndian::read_u32(&buf)
+    handle.read_exact(&mut buf).unwrap();
+    NativeEndian::read_u32(&buf)
 }
 
 fn read_body<T: Read + Write>(length: u32, socket: &mut ProxySocket<T>) {
-	let mut buffer = vec![0; length as usize];
-	let stdin = io::stdin();
-	let mut handle = stdin.lock();
+    let mut buffer = vec![0; length as usize];
+    let stdin = io::stdin();
+    let mut handle = stdin.lock();
 
-	if let Ok(_) = handle.read_exact(&mut buffer) {
-		if valid_length(length) {
-			socket.write(&buffer).unwrap();
-			socket.flush().unwrap();
-			read_response(socket);
-		}
-	}
+    if let Ok(_) = handle.read_exact(&mut buffer) {
+        if valid_length(length) {
+            socket.write(&buffer).unwrap();
+            socket.flush().unwrap();
+            read_response(socket);
+        }
+    }
 }
 
 fn read_response<T: Read>(socket: &mut ProxySocket<T>) {
-	let mut buf = vec![0; BUFFER_SIZE as usize];
-	if let Ok(len) = socket.read(&mut buf) {
-		write_response(&buf[0..len]);
-	}
+    let mut buf = vec![0; BUFFER_SIZE as usize];
+    if let Ok(len) = socket.read(&mut buf) {
+        write_response(&buf[0..len]);
+    }
 }
 
 fn write_response(buf: &[u8]) {
-	let stdout = io::stdout();
-	let mut out = stdout.lock();
+    let stdout = io::stdout();
+    let mut out = stdout.lock();
 
-	out.write_u32::<NativeEndian>(buf.len() as u32).unwrap();
-	out.write(buf).unwrap();
-	out.flush().unwrap();
+    out.write_u32::<NativeEndian>(buf.len() as u32).unwrap();
+    out.write(buf).unwrap();
+    out.flush().unwrap();
 }
 
 fn main() {
-	let mut socket = proxy_socket::connect(BUFFER_SIZE).unwrap();
+    let mut socket = proxy_socket::connect(BUFFER_SIZE).unwrap();
 
-	// Start thread for user input reading
-	let ui = thread::spawn(move || {
-		loop {
-			let length = read_header();
-			read_body(length, &mut socket);
-		}
-	});
+    // Start thread for user input reading
+    let ui = thread::spawn(move || {
+        loop {
+            let length = read_header();
+            read_body(length, &mut socket);
+        }
+    });
 
-	let _ui_res = ui.join().unwrap();
+    let _ui_res = ui.join().unwrap();
 }

src/proxy_socket.rs

@@ -12,48 +12,48 @@ use nix::sys::socket::sockopt::RcvBuf;
 use named_pipe::PipeClient;
 
 pub struct ProxySocket<T> {
-	inner: T,
+    inner: T,
 }
 
 impl<R: Read> Read for ProxySocket<R> {
-	fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-		self.inner.read(buf)
-	}
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(buf)
+    }
 }
 
 impl<W: Write> Write for ProxySocket<W> {
-	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-		self.inner.write(buf)
-	}
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.write(buf)
+    }
 
-	fn flush(&mut self) -> io::Result<()> {
-		self.inner.flush()
-	}
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
 }
 
 #[cfg(windows)]
 pub fn connect(buffer_size: u32) -> io::Result<ProxySocket<PipeClient>> {
-	let username = env::var("USERNAME").unwrap();
-	let pipe_name = format!("\\\\.\\pipe\\keepassxc\\{}\\kpxc_server", username);
-	let client = PipeClient::connect(pipe_name)?;
-	Ok(ProxySocket { inner: client })
+    let username = env::var("USERNAME").unwrap();
+    let pipe_name = format!("\\\\.\\pipe\\keepassxc\\{}\\org.keepassxc.KeePassXC.BrowserServer", username);
+    let client = PipeClient::connect(pipe_name)?;
+    Ok(ProxySocket { inner: client })
 }
 
 #[cfg(not(windows))]
 pub fn connect(buffer_size: u32) -> io::Result<ProxySocket<UnixStream>> {
-	use std::time::Duration;
+    use std::time::Duration;
 
-	let socket_name = "kpxc_server";
-	let socket: String;
-	if let Ok(dir) = if cfg!(target_os = "macos") {env::var("TMPDIR") } else { env::var("XDG_RUNTIME_DIR") } {
-		socket = format!("{}/{}", dir, socket_name);
-	} else {
-		socket = format!("/tmp/{}", socket_name);
-	}
-	let s = UnixStream::connect(socket)?;
-	socket::setsockopt(s.as_raw_fd(), SndBuf, &(buffer_size as usize)).expect("setsockopt for SndBuf failed");
-	socket::setsockopt(s.as_raw_fd(), RcvBuf, &(buffer_size as usize)).expect("setsockopt for RcvBuf failed");
-	let timeout: Option<Duration> = Some(Duration::from_secs(1));
-	s.set_read_timeout(timeout)?;
-	Ok(ProxySocket { inner: s })
+    let socket_name = "org.keepassxc.KeePassXC.BrowserServer";
+    let socket: String;
+    if let Ok(dir) = if cfg!(target_os = "macos") {env::var("TMPDIR") } else { env::var("XDG_RUNTIME_DIR") } {
+        socket = format!("{}/{}", dir, socket_name);
+    } else {
+        socket = format!("/tmp/{}", socket_name);
+    }
+    let s = UnixStream::connect(socket)?;
+    socket::setsockopt(s.as_raw_fd(), SndBuf, &(buffer_size as usize)).expect("setsockopt for SndBuf failed");
+    socket::setsockopt(s.as_raw_fd(), RcvBuf, &(buffer_size as usize)).expect("setsockopt for RcvBuf failed");
+    let timeout: Option<Duration> = Some(Duration::from_secs(1));
+    s.set_read_timeout(timeout)?;
+    Ok(ProxySocket { inner: s })
 }