Fixed port endianness

1 files changed, 89 insertions, 98 deletions

diff --git a/src/receive.go b/src/receive.go
index 1f05b2f..cb53f80 100644
--- a/src/receive.go
+++ b/src/receive.go
@@ -99,135 +99,126 @@ func (device *Device) RoutineReceiveIncomming(IPVersion int) {
 
 	for {
 
-		// wait for new conn
-
-		logDebug.Println("Waiting for udp socket")
-
-		select {
-		case <-device.signal.stop:
-			return
-
-		case <-device.signal.updateBind:
-
-			// fetch new socket
+		// wait for bind
+
+		logDebug.Println("Waiting for udp bind")
+		device.net.mutex.Lock()
+		device.net.update.Wait()
+		bind := device.net.bind
+		device.net.mutex.Unlock()
+		if bind == nil {
+			continue
+		}
 
-			device.net.mutex.RLock()
-			bind := device.net.bind
-			device.net.mutex.RUnlock()
-			if bind == nil {
-				continue
-			}
+		logDebug.Println("LISTEN\n\n\n")
 
-			logDebug.Println("Listening for inbound packets")
+		// receive datagrams until conn is closed
 
-			// receive datagrams until conn is closed
+		buffer := device.GetMessageBuffer()
 
-			buffer := device.GetMessageBuffer()
+		var size int
+		var err error
 
-			var size int
-			var err error
+		for {
 
-			for {
+			// read next datagram
 
-				// read next datagram
+			var endpoint Endpoint
 
-				var endpoint Endpoint
-
-				switch IPVersion {
-				case ipv4.Version:
-					size, err = bind.ReceiveIPv4(buffer[:], &endpoint)
-				case ipv6.Version:
-					size, err = bind.ReceiveIPv6(buffer[:], &endpoint)
-				default:
-					return
-				}
+			switch IPVersion {
+			case ipv4.Version:
+				size, err = bind.ReceiveIPv4(buffer[:], &endpoint)
+			case ipv6.Version:
+				size, err = bind.ReceiveIPv6(buffer[:], &endpoint)
+			default:
+				return
+			}
 
-				if err != nil {
-					break
-				}
+			if err != nil {
+				break
+			}
 
-				if size < MinMessageSize {
-					continue
-				}
+			if size < MinMessageSize {
+				continue
+			}
 
-				// check size of packet
+			// check size of packet
 
-				packet := buffer[:size]
-				msgType := binary.LittleEndian.Uint32(packet[:4])
+			packet := buffer[:size]
+			msgType := binary.LittleEndian.Uint32(packet[:4])
 
-				var okay bool
+			var okay bool
 
-				switch msgType {
+			switch msgType {
 
-				// check if transport
+			// check if transport
 
-				case MessageTransportType:
+			case MessageTransportType:
 
-					// check size
+				// check size
 
-					if len(packet) < MessageTransportType {
-						continue
-					}
+				if len(packet) < MessageTransportType {
+					continue
+				}
 
-					// lookup key pair
+				// lookup key pair
 
-					receiver := binary.LittleEndian.Uint32(
-						packet[MessageTransportOffsetReceiver:MessageTransportOffsetCounter],
-					)
-					value := device.indices.Lookup(receiver)
-					keyPair := value.keyPair
-					if keyPair == nil {
-						continue
-					}
+				receiver := binary.LittleEndian.Uint32(
+					packet[MessageTransportOffsetReceiver:MessageTransportOffsetCounter],
+				)
+				value := device.indices.Lookup(receiver)
+				keyPair := value.keyPair
+				if keyPair == nil {
+					continue
+				}
 
-					// check key-pair expiry
+				// check key-pair expiry
 
-					if keyPair.created.Add(RejectAfterTime).Before(time.Now()) {
-						continue
-					}
+				if keyPair.created.Add(RejectAfterTime).Before(time.Now()) {
+					continue
+				}
 
-					// create work element
+				// create work element
 
-					peer := value.peer
-					elem := &QueueInboundElement{
-						packet:  packet,
-						buffer:  buffer,
-						keyPair: keyPair,
-						dropped: AtomicFalse,
-					}
-					elem.mutex.Lock()
+				peer := value.peer
+				elem := &QueueInboundElement{
+					packet:  packet,
+					buffer:  buffer,
+					keyPair: keyPair,
+					dropped: AtomicFalse,
+				}
+				elem.mutex.Lock()
 
-					// add to decryption queues
+				// add to decryption queues
 
-					device.addToDecryptionQueue(device.queue.decryption, elem)
-					device.addToInboundQueue(peer.queue.inbound, elem)
-					buffer = device.GetMessageBuffer()
-					continue
+				device.addToDecryptionQueue(device.queue.decryption, elem)
+				device.addToInboundQueue(peer.queue.inbound, elem)
+				buffer = device.GetMessageBuffer()
+				continue
 
-				// otherwise it is a fixed size & handshake related packet
+			// otherwise it is a fixed size & handshake related packet
 
-				case MessageInitiationType:
-					okay = len(packet) == MessageInitiationSize
+			case MessageInitiationType:
+				okay = len(packet) == MessageInitiationSize
 
-				case MessageResponseType:
-					okay = len(packet) == MessageResponseSize
+			case MessageResponseType:
+				okay = len(packet) == MessageResponseSize
 
-				case MessageCookieReplyType:
-					okay = len(packet) == MessageCookieReplySize
-				}
+			case MessageCookieReplyType:
+				okay = len(packet) == MessageCookieReplySize
+			}
 
-				if okay {
-					device.addToHandshakeQueue(
-						device.queue.handshake,
-						QueueHandshakeElement{
-							msgType:  msgType,
-							buffer:   buffer,
-							packet:   packet,
-							endpoint: endpoint,
-						},
-					)
-					buffer = device.GetMessageBuffer()
-				}
+			if okay {
+				device.addToHandshakeQueue(
+					device.queue.handshake,
+					QueueHandshakeElement{
+						msgType:  msgType,
+						buffer:   buffer,
+						packet:   packet,
+						endpoint: endpoint,
+					},
+				)
+				buffer = device.GetMessageBuffer()
 			}
 		}
 	}