diff --git a/.gitignore b/.gitignore
index eb5a316..fa8d85a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
+Cargo.lock
 target
diff --git a/src/main.rs b/src/main.rs
index 00b42b0..0349526 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,24 +3,16 @@ extern crate serde;
 #[macro_use] extern crate serde_derive;
 
 use std::io;
+use std::io::Read;
+use std::net::TcpStream;
 use std::net::UdpSocket;
+use std::sync::{Arc, Mutex};
 use std::thread;
 use std::time::Duration;
 
-static recv_address: &'static str = "192.168.43.154:54321";
-static send_address: &'static str = "192.168.43.154:54322";
-
-
-static RECEIVER_ADDRESSES: &'static [&'static str] = &[
-    "192.168.43.72:54321",
-    "192.168.43.154:54321",
-    "192.168.43.239:54321",
-    "192.168.43.90:54321",
-    "192.168.43.255:54321"
-];
-
-
-static broadcast_address: &'static str = "255.255.255.255:54321";
+static recv_address:&'static str = "0.0.0.0";
+static recv_port:&'static str = "54321";
+static server_address: &'static str = "harkness:17424";
 
 #[derive(Debug, Serialize, Deserialize)]
 struct Message {
@@ -35,28 +27,43 @@ enum ContentType{
     Annouce,
 }
 
-fn broadcast(send_socket: &UdpSocket, msg: &Message) {
+fn broadcast(receiver_addresses: &Vec<String>, send_socket: &UdpSocket, msg: &Message) {
     let wire_format = serde_json::to_string(&msg).unwrap();
 
-    for addr in RECEIVER_ADDRESSES.iter() {
-        send_socket.send_to(wire_format.as_bytes(),addr);
-    }
-}
-
-fn make_message(content: ContentType) -> Message {
-    Message {
-        name: String::from("Hendrik"),
-        content: content
+    for addr in receiver_addresses.iter() {
+        send_socket.send_to(wire_format.as_bytes(),addr).unwrap();
     }
 }
 
 fn main() {
-    let mut recv_socket = UdpSocket::bind(recv_address).unwrap();
-    let mut send_socket = UdpSocket::bind(send_address).unwrap();
+    let mut receiver_addresses = Arc::new(Mutex::new(vec!()));
+    let mut socket = Arc::new(UdpSocket::bind(format!("{}:{}", recv_address, recv_port)).unwrap());
+
+    let mut discover_receiver_addresses = receiver_addresses.clone();
+    let discover_thread = thread::spawn(move || {
+        let mut discover_socket = TcpStream::connect(server_address).unwrap();
+        let mut first_read = true;
+        loop {
+            let mut buffer = [0; 512];
+            let count = discover_socket.read(&mut buffer[..]).unwrap();
+            if count == 0 {
+                println!("Server returned empty response, aborting discovery!");
+                break;
+            }
 
-    let send_thread = thread::spawn(move || {
+            let mut receiver_addresses = discover_receiver_addresses.lock().unwrap();
+            receiver_addresses.clear();
+            let json_response : serde_json::Value = serde_json::from_str(&String::from_utf8_lossy(&buffer[0..count])).unwrap();
+            for client in json_response["clients"].as_array().unwrap() {
+                let mut new_address = format!("{}:{}", client["address"].as_str().unwrap(), recv_port);
+                receiver_addresses.push(new_address);
+            }
+        }
+    });
 
-        send_socket.set_broadcast(true).unwrap();
+    let send_receiver_addresses = receiver_addresses.clone();
+    let mut send_socket = socket.clone();
+    let send_thread = thread::spawn(move || {
 
         while true {
             let mut input = String::new();
@@ -66,13 +73,15 @@ fn main() {
                         name: String::from("hoodie"),
                         content: ContentType::Message(input.trim().into())
                     };
-                    broadcast(&send_socket, &msg);
+                    let receiver_addresses = send_receiver_addresses.lock().unwrap();
+                    broadcast(&receiver_addresses, &send_socket, &msg);
                 }
                 Err(error) => println!("error: {}", error),
             }
         }
     });
 
+    let mut recv_socket = socket.clone();
     let receive = thread::spawn(move || {
         // recv_socket.set_broadcast(true).unwrap();
 
@@ -98,5 +107,7 @@ fn main() {
     });
 
 
+    receive.join().unwrap();
     send_thread.join().unwrap();
+    discover_thread.join().unwrap();
 }