chore: awg 2.0 adjustments

device/awg/special_handshake_handler.go

@@ -1,9 +1,6 @@
 package awg
 
 import (
-	"errors"
-	"time"
-
 	"github.com/tevino/abool"
 	"go.uber.org/atomic"
 )
@@ -21,25 +18,13 @@ var WaitResponse = struct {
 }
 
 type SpecialHandshakeHandler struct {
-	isFirstDone    bool
+	SpecialJunk TagJunkPacketGenerators
-	SpecialJunk    TagJunkPacketGenerators
-	ControlledJunk TagJunkPacketGenerators
-
-	nextItime time.Time
-	ITimeout  time.Duration // seconds
 
 	IsSet bool
 }
 
 func (handler *SpecialHandshakeHandler) Validate() error {
-	var errs []error
+	return handler.SpecialJunk.Validate()
-	if err := handler.SpecialJunk.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-	if err := handler.ControlledJunk.Validate(); err != nil {
-		errs = append(errs, err)
-	}
-	return errors.Join(errs...)
 }
 
 func (handler *SpecialHandshakeHandler) GenerateSpecialJunk() [][]byte {
@@ -47,27 +32,5 @@ func (handler *SpecialHandshakeHandler) GenerateSpecialJunk() [][]byte {
 		return nil
 	}
 
-	// TODO: create tests
+	return handler.SpecialJunk.GeneratePackets()
-	if !handler.isFirstDone {
-		handler.isFirstDone = true
-	} else if !handler.isTimeToSendSpecial() {
-		return nil
-	}
-
-	rv := handler.SpecialJunk.GeneratePackets()
-	handler.nextItime = time.Now().Add(handler.ITimeout)
-
-	return rv
-}
-
-func (handler *SpecialHandshakeHandler) isTimeToSendSpecial() bool {
-	return time.Now().After(handler.nextItime)
-}
-
-func (handler *SpecialHandshakeHandler) GenerateControlledJunk() [][]byte {
-	if !handler.ControlledJunk.IsDefined() {
-		return nil
-	}
-
-	return handler.ControlledJunk.GeneratePackets()
 }

device/awg/tag_generator.go

@@ -184,34 +184,6 @@ func newTimestampGenerator(param string) (Generator, error) {
 	return &TimestampGenerator{}, nil
 }
 
-type WaitTimeoutGenerator struct {
-	waitTimeout time.Duration
-}
-
-func (wtg *WaitTimeoutGenerator) Generate() []byte {
-	time.Sleep(wtg.waitTimeout)
-	return []byte{}
-}
-
-func (wtg *WaitTimeoutGenerator) Size() int {
-	return 0
-}
-
-func newWaitTimeoutGenerator(param string) (Generator, error) {
-	timeout, err := strconv.Atoi(param)
-	if err != nil {
-		return nil, fmt.Errorf("timeout parse int: %w", err)
-	}
-
-	if timeout > 5000 {
-		return nil, fmt.Errorf("timeout must be less than 5000ms")
-	}
-
-	return &WaitTimeoutGenerator{
-		waitTimeout: time.Duration(timeout) * time.Millisecond,
-	}, nil
-}
-
 type PacketCounterGenerator struct {
 }
 

device/awg/tag_parser.go

@@ -12,14 +12,12 @@ type IpcFields struct{ Key, Value string }
 type EnumTag string
 
 const (
-	BytesEnumTag        EnumTag = "b"
+	BytesEnumTag       EnumTag = "b"
-	CounterEnumTag      EnumTag = "c"
+	CounterEnumTag     EnumTag = "c"
-	TimestampEnumTag    EnumTag = "t"
+	TimestampEnumTag   EnumTag = "t"
-	RandomBytesEnumTag  EnumTag = "r"
+	RandomBytesEnumTag EnumTag = "r"
-	RandomASCIIEnumTag  EnumTag = "rc"
+	RandomASCIIEnumTag EnumTag = "rc"
-	RandomDigitEnumTag  EnumTag = "rd"
+	RandomDigitEnumTag EnumTag = "rd"
-	WaitTimeoutEnumTag  EnumTag = "wt"
-	WaitResponseEnumTag EnumTag = "wr"
 )
 
 var generatorCreator = map[EnumTag]newGenerator{
@@ -29,8 +27,6 @@ var generatorCreator = map[EnumTag]newGenerator{
 	RandomBytesEnumTag: newRandomBytesGenerator,
 	RandomASCIIEnumTag: newRandomASCIIGenerator,
 	RandomDigitEnumTag: newRandomDigitGenerator,
-	WaitTimeoutEnumTag: newWaitTimeoutGenerator,
-	// WaitResponseEnumTag: newWaitResponseGenerator,
 }
 
 // helper map to determine enumTags are unique

device/device.go

@@ -847,7 +847,6 @@ func (device *Device) handlePostConfig(tempAwg *awg.Protocol) error {
 				ipc.IpcErrorInvalid, "handshake handler validate: %w", err))
 		} else {
 			device.awg.HandshakeHandler = tempAwg.HandshakeHandler
-			device.awg.HandshakeHandler.ControlledJunk.DefaultJunkCount = tempAwg.Cfg.JunkPacketCount
 			device.awg.HandshakeHandler.SpecialJunk.DefaultJunkCount = tempAwg.Cfg.JunkPacketCount
 			device.version = VersionAwgSpecialHandshake
 		}

device/device_test.go

@@ -268,10 +268,6 @@ func TestAWGHandshakeDevicePing(t *testing.T) {
 		"i2", "<b 0xf6ab3267fa><c><b 0xf6ab><t><rc 10>",
 		"i3", "<b 0xf6ab3267fa><c><b 0xf6ab><t><rd 10>",
 		"i4", "<b 0xf6ab3267fa><r 100>",
-		// "j1", "<b 0xffffffff><c><b 0xf6ab><t><r 10>",
-		// "j2", "<c><b 0xf6ab><t><wt 1000>",
-		// "j3", "<t><b 0xf6ab><c><r 10>",
-		// "itime", "60",
 		// "jc", "1",
 		// "jmin", "500",
 		// "jmax", "1000",

device/send.go

@@ -133,12 +133,7 @@ func (peer *Peer) SendHandshakeInitiation(isRetry bool) error {
 			peer.device.awg.Mux.RLock()
 			// set junks depending on packet type
 			junks = peer.device.awg.HandshakeHandler.GenerateSpecialJunk()
-			if junks == nil {
+			if junks != nil {
-				junks = peer.device.awg.HandshakeHandler.GenerateControlledJunk()
-				if junks != nil {
-					peer.device.log.Verbosef("%v - Controlled junks sent", peer)
-				}
-			} else {
 				peer.device.log.Verbosef("%v - Special junks sent", peer)
 			}
 			peer.device.awg.Mux.RUnlock()

device/uapi.go

@@ -135,13 +135,6 @@ func (device *Device) IpcGetOperation(w io.Writer) error {
 			for _, field := range specialJunkIpcFields {
 				sendf("%s=%s", field.Key, field.Value)
 			}
-			controlledJunkIpcFields := device.awg.HandshakeHandler.ControlledJunk.IpcGetFields()
-			for _, field := range controlledJunkIpcFields {
-				sendf("%s=%s", field.Key, field.Value)
-			}
-			if device.awg.HandshakeHandler.ITimeout != 0 {
-				sendf("itime=%d", device.awg.HandshakeHandler.ITimeout/time.Second)
-			}
 		}
 
 		for _, peer := range device.peers.keyMap {
@@ -413,34 +406,6 @@ func (device *Device) handleDeviceLine(key, value string, tempAwg *awg.Protocol)
 		device.log.Verbosef("UAPI: Updating %s", key)
 		tempAwg.HandshakeHandler.SpecialJunk.AppendGenerator(generators)
 		tempAwg.HandshakeHandler.IsSet = true
-	case "j1", "j2", "j3":
-		if len(value) == 0 {
-			device.log.Verbosef("UAPI: received empty %s", key)
-			return nil
-		}
-
-		generators, err := awg.ParseTagJunkGenerator(key, value)
-		if err != nil {
-			return ipcErrorf(ipc.IpcErrorInvalid, "invalid %s: %w", key, err)
-		}
-		device.log.Verbosef("UAPI: Updating %s", key)
-
-		tempAwg.HandshakeHandler.ControlledJunk.AppendGenerator(generators)
-		tempAwg.HandshakeHandler.IsSet = true
-	case "itime":
-		if len(value) == 0 {
-			device.log.Verbosef("UAPI: received empty itime")
-			return nil
-		}
-
-		itime, err := strconv.ParseInt(value, 10, 64)
-		if err != nil {
-			return ipcErrorf(ipc.IpcErrorInvalid, "parse itime %w", err)
-		}
-		device.log.Verbosef("UAPI: Updating itime")
-
-		tempAwg.HandshakeHandler.ITimeout = time.Duration(itime) * time.Second
-		tempAwg.HandshakeHandler.IsSet = true
 	default:
 		return ipcErrorf(ipc.IpcErrorInvalid, "invalid UAPI device key: %v", key)
 	}