Merge branch 'source-caching'

1 files changed, 40 insertions, 41 deletions

diff --git a/src/uapi.go b/src/uapi.go
index 326216b..dc8be66 100644
--- a/src/uapi.go
+++ b/src/uapi.go
@@ -39,9 +39,10 @@ func ipcGetOperation(device *Device, socket *bufio.ReadWriter) *IPCError {
 		send("private_key=" + device.privateKey.ToHex())
 	}
 
-	if device.net.addr != nil {
-		send(fmt.Sprintf("listen_port=%d", device.net.addr.Port))
+	if device.net.port != 0 {
+		send(fmt.Sprintf("listen_port=%d", device.net.port))
 	}
+
 	if device.net.fwmark != 0 {
 		send(fmt.Sprintf("fwmark=%d", device.net.fwmark))
 	}
@@ -53,7 +54,7 @@ func ipcGetOperation(device *Device, socket *bufio.ReadWriter) *IPCError {
 			send("public_key=" + peer.handshake.remoteStatic.ToHex())
 			send("preshared_key=" + peer.handshake.presharedKey.ToHex())
 			if peer.endpoint != nil {
-				send("endpoint=" + peer.endpoint.String())
+				send("endpoint=" + peer.endpoint.DstToString())
 			}
 
 			nano := atomic.LoadInt64(&peer.stats.lastHandshakeNano)
@@ -134,56 +135,38 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError {
 			case "listen_port":
 				port, err := strconv.ParseUint(value, 10, 16)
 				if err != nil {
-					logError.Println("Failed to set listen_port:", err)
+					logError.Println("Failed to parse listen_port:", err)
 					return &IPCError{Code: ipcErrorInvalid}
 				}
-
-				addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", port))
-				if err != nil {
+				device.net.port = uint16(port)
+				if err := UpdateUDPListener(device); err != nil {
 					logError.Println("Failed to set listen_port:", err)
-					return &IPCError{Code: ipcErrorInvalid}
+					return &IPCError{Code: ipcErrorPortInUse}
 				}
 
-				device.net.mutex.Lock()
-				device.net.addr = addr
-				device.net.mutex.Unlock()
+			case "fwmark":
 
-				err = updateUDPConn(device)
-				if err != nil {
-					logError.Println("Failed to set listen_port:", err)
-					return &IPCError{Code: ipcErrorPortInUse}
-				}
+				// parse fwmark field
 
-				// TODO: Clear source address of all peers
+				fwmark, err := func() (uint32, error) {
+					if value == "" {
+						return 0, nil
+					}
+					mark, err := strconv.ParseUint(value, 10, 32)
+					return uint32(mark), err
+				}()
 
-			case "fwmark":
-				fwmark, err := strconv.ParseUint(value, 10, 32)
 				if err != nil {
 					logError.Println("Invalid fwmark", err)
 					return &IPCError{Code: ipcErrorInvalid}
 				}
 
 				device.net.mutex.Lock()
-				if fwmark > 0 || device.net.fwmark > 0 {
-					device.net.fwmark = uint32(fwmark)
-					err := setMark(
-						device.net.conn,
-						device.net.fwmark,
-					)
-					if err != nil {
-						logError.Println("Failed to set fwmark:", err)
-						device.net.mutex.Unlock()
-						return &IPCError{Code: ipcErrorIO}
-					}
-
-					// TODO: Clear source address of all peers
-				}
+				device.net.fwmark = uint32(fwmark)
 				device.net.mutex.Unlock()
 
 			case "public_key":
-
 				// switch to peer configuration
-
 				deviceConfig = false
 
 			case "replace_peers":
@@ -218,7 +201,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError {
 				device.mutex.RLock()
 				if device.publicKey.Equals(pubKey) {
 
-					// create dummy instance
+					// create dummy instance (not added to device)
 
 					peer = &Peer{}
 					dummy = true
@@ -244,6 +227,9 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError {
 				}
 
 			case "remove":
+
+				// remove currently selected peer from device
+
 				if value != "true" {
 					logError.Println("Failed to set remove, invalid value:", value)
 					return &IPCError{Code: ipcErrorInvalid}
@@ -256,6 +242,9 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError {
 				dummy = true
 
 			case "preshared_key":
+
+				// update PSK
+
 				peer.mutex.Lock()
 				err := peer.handshake.presharedKey.FromHex(value)
 				peer.mutex.Unlock()
@@ -265,15 +254,25 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError {
 				}
 
 			case "endpoint":
-				addr, err := parseEndpoint(value)
+
+				// set endpoint destination
+
+				err := func() error {
+					peer.mutex.Lock()
+					defer peer.mutex.Unlock()
+					endpoint, err := CreateEndpoint(value)
+					if err != nil {
+						return err
+					}
+					peer.endpoint = endpoint
+					signalSend(peer.signal.handshakeReset)
+					return nil
+				}()
+
 				if err != nil {
 					logError.Println("Failed to set endpoint:", value)
 					return &IPCError{Code: ipcErrorInvalid}
 				}
-				peer.mutex.Lock()
-				peer.endpoint = addr
-				peer.mutex.Unlock()
-				signalSend(peer.signal.handshakeReset)
 
 			case "persistent_keepalive_interval":