Unix socket version

README.md

@@ -4,4 +4,4 @@ Application that works as a proxy between Native Messaging browser extension and
 This is still under development. Installing the proxy needs manual changes to JSON scripts installed for Native Messaging.
 See [this page](https://developer.chrome.com/extensions/nativeMessaging) for further information.
 
-keepassxc-proxy listens stdin from keepassxc-browser extension and transfers the data to UDP port 19700 which KeePassXC listens.
+keepassxc-proxy listens stdin from keepassxc-browser extension and transfers the data to Unix domain socket `/tmp/kpxc_server` which KeePassXC listens.

src/main.rs

@@ -1,7 +1,8 @@
 extern crate byteorder;
 
 use std::io::{self, Read, Write};
-use std::net::UdpSocket;
+use std::os::unix::net::UnixStream;
+use std::os::unix::net::UnixListener;
 use std::str;
 use std::thread;
 use std::time::Duration;
@@ -9,7 +10,7 @@ use byteorder::{ByteOrder, NativeEndian, WriteBytesExt};
 
 fn valid_length(length: u32) -> bool
 {
-	return length > 0 && length <= 16384;	// 1024 ^ 2 is the maximum
+	return length > 0 && length <= 4096;	// 1024 ^ 2 is the maximum
 }
 
 fn read_header() -> (u32)
@@ -18,44 +19,39 @@ fn read_header() -> (u32)
 	let mut buf = vec![0; 4];
 	let mut handle = stdin.lock();
 
-	handle.read_exact(&mut buf);
+	handle.read_exact(&mut buf).unwrap();
 	let length: u32 = NativeEndian::read_u32(&buf);
 	return length;
 }
 
-fn read_body(length: u32, socket: &UdpSocket)
+fn read_body(length: u32, mut socket: &UnixStream)
 {
 	let mut buffer = vec![0; length as usize];
 	let stdin = io::stdin();
 	let mut handle = stdin.lock();
 
 	match handle.read_exact(&mut buffer) {
-		Ok(v) => {
+		Ok(_v) => {
 			if valid_length(length) {
-				socket.send_to(&buffer, "127.0.0.1:19700").expect("Cannot send data");
+				socket.write(&buffer).unwrap();
+				socket.flush().unwrap();
+				read_unix_response(length, &socket);
 			}
 		},
-		Err(e) => panic!("Read error: {}", e)
-		//Err(e) => {}
+		Err(_e) => {}
 	}
 }
 
-fn read_udp_response(socket: &UdpSocket)
+fn read_unix_response(length: u32, mut socket: &UnixStream)
 {
-	let mut buf = [0; 4069];
+	let mut buf = vec![0; length as usize];
 
-    match socket.recv_from(&mut buf) {
-    	Ok((length, src)) => {
-    		if valid_length(length as u32) {
-    			thread::spawn(move || {
-    				let buf = &mut buf[..length];
+    match socket.read(&mut buf) {
+		Ok(_length) => {
 			let text = str::from_utf8(&buf).unwrap();
 			write_output(text);
-			    });
-    		}
 		},
-    	//Err(e) => panic!("Read error: {}", e)
-    	Err(e) => {}
+		Err(_e) => {}
     }
 }
 
@@ -66,14 +62,13 @@ fn write_output(text: &str)
 	let mut handle = stdout.lock();
 
 	handle.write_u32::<NativeEndian>(textlen as u32).unwrap();
-	handle.write(text.as_bytes());
+	handle.write(text.as_bytes()).unwrap();
 }
 
 fn main() {
-
-    let socket = UdpSocket::bind("127.0.0.1:0").expect("Couldn't bind to address");
+	let socket = UnixStream::connect("/tmp/kpxc_server").unwrap();
 	let timeout: Option<Duration> = Some(Duration::from_secs(1));
-    socket.set_read_timeout(timeout);
+	socket.set_read_timeout(timeout).unwrap();
 
 	// Start thread for user input reading
 	let send_socket = socket.try_clone().expect("Cannot clone socket");
@@ -84,14 +79,5 @@ fn main() {
 	    }
     });
 
-    // Start thread for UDP packet receiving
-    let recv_socket = socket.try_clone().expect("Cannot clone socket");
-    let pr = thread::spawn(move || {
-    	loop {
-    		read_udp_response(&recv_socket);
-    	}
-    });
-
-    let ui_res = ui.join();
-    let pr_res = pr.join();
+    let _ui_res = ui.join();
 }