diff --git a/README.md b/README.md
index 2d8b9d2..6a681f4 100644
--- a/README.md
+++ b/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.
\ No newline at end of file
+keepassxc-proxy listens stdin from keepassxc-browser extension and transfers the data to Unix domain socket `/tmp/kpxc_server` which KeePassXC listens.
diff --git a/src/main.rs b/src/main.rs
index daaca2b..53002f1 100644
--- a/src/main.rs
+++ b/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,45 +19,40 @@ 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];
-					let text = str::from_utf8(&buf).unwrap();
-					write_output(text);
-			    });
-    		}
-    	},
-    	//Err(e) => panic!("Read error: {}", e)
-    	Err(e) => {}
-    }    
+    match socket.read(&mut buf) {
+		Ok(_length) => {
+			let text = str::from_utf8(&buf).unwrap();
+			write_output(text);
+		},
+		Err(_e) => {}
+    }
 }
 
 fn write_output(text: &str)
@@ -66,32 +62,22 @@ 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 timeout: Option<Duration> = Some(Duration::from_secs(1));
-    socket.set_read_timeout(timeout);
+fn main() {
+	let socket = UnixStream::connect("/tmp/kpxc_server").unwrap();
+	let timeout: Option<Duration> = Some(Duration::from_secs(1));
+	socket.set_read_timeout(timeout).unwrap();
 
-    // Start thread for user input reading
-    let send_socket = socket.try_clone().expect("Cannot clone socket");
-    let ui = thread::spawn(move || {
-    	loop {
-	    	let length = read_header();
-	    	read_body(length, &send_socket);
+	// Start thread for user input reading
+	let send_socket = socket.try_clone().expect("Cannot clone socket");
+	let ui = thread::spawn(move || {
+		loop {
+			let length = read_header();
+			read_body(length, &send_socket);
 	    }
     });
 
-    // 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();
-}
\ No newline at end of file
+    let _ui_res = ui.join();
+}