From 89d2c5ed7a054bc05a21209d5a9c79ad7151f8f7 Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Thu, 3 Jan 2019 19:04:00 +0100 Subject: [PATCH] Extend structs rather than embed, when possible --- conn.go | 28 +++++++------- conn_linux.go | 20 +++++----- cookie.go | 48 ++++++++++++------------ device.go | 54 +++++++++++++-------------- indextable.go | 28 +++++++------- keypair.go | 6 +-- misc.go | 8 ++-- noise-protocol.go | 20 +++++----- peer.go | 46 +++++++++++------------ ratelimiter/ratelimiter.go | 38 +++++++++---------- receive.go | 14 +++---- rwcancel/fdset.go | 6 +-- rwcancel/rwcancel.go | 4 +- send.go | 14 +++---- timers.go | 18 ++++----- uapi.go | 76 +++++++++++++++++++------------------- 16 files changed, 213 insertions(+), 215 deletions(-) diff --git a/conn.go b/conn.go index c3fcf91..b19a9c2 100644 --- a/conn.go +++ b/conn.go @@ -78,8 +78,8 @@ func unsafeCloseBind(device *Device) error { func (device *Device) BindSetMark(mark uint32) error { - device.net.mutex.Lock() - defer device.net.mutex.Unlock() + device.net.Lock() + defer device.net.Unlock() // check if modified @@ -98,23 +98,23 @@ func (device *Device) BindSetMark(mark uint32) error { // clear cached source addresses - device.peers.mutex.RLock() + device.peers.RLock() for _, peer := range device.peers.keyMap { - peer.mutex.Lock() - defer peer.mutex.Unlock() + peer.Lock() + defer peer.Unlock() if peer.endpoint != nil { peer.endpoint.ClearSrc() } } - device.peers.mutex.RUnlock() + device.peers.RUnlock() return nil } func (device *Device) BindUpdate() error { - device.net.mutex.Lock() - defer device.net.mutex.Unlock() + device.net.Lock() + defer device.net.Unlock() // close existing sockets @@ -148,15 +148,15 @@ func (device *Device) BindUpdate() error { // clear cached source addresses - device.peers.mutex.RLock() + device.peers.RLock() for _, peer := range device.peers.keyMap { - peer.mutex.Lock() - defer peer.mutex.Unlock() + peer.Lock() + defer peer.Unlock() if peer.endpoint != nil { peer.endpoint.ClearSrc() } } - device.peers.mutex.RUnlock() + device.peers.RUnlock() // start receiving routines @@ -173,8 +173,8 @@ func (device *Device) BindUpdate() error { } func (device *Device) BindClose() error { - device.net.mutex.Lock() + device.net.Lock() err := unsafeCloseBind(device) - device.net.mutex.Unlock() + device.net.Unlock() return err } diff --git a/conn_linux.go b/conn_linux.go index 305039d..2b3a51e 100644 --- a/conn_linux.go +++ b/conn_linux.go @@ -654,17 +654,17 @@ func (bind *NativeBind) routineRouteListener(device *Device) { if !ok { break } - pePtr.peer.mutex.Lock() + pePtr.peer.Lock() if &pePtr.peer.endpoint != pePtr.endpoint { - pePtr.peer.mutex.Unlock() + pePtr.peer.Unlock() break } if uint32(pePtr.peer.endpoint.(*NativeEndpoint).src4().ifindex) == ifidx { - pePtr.peer.mutex.Unlock() + pePtr.peer.Unlock() break } pePtr.peer.endpoint.(*NativeEndpoint).ClearSrc() - pePtr.peer.mutex.Unlock() + pePtr.peer.Unlock() } attr = attr[attrhdr.Len:] } @@ -675,16 +675,16 @@ func (bind *NativeBind) routineRouteListener(device *Device) { reqPeer = make(map[uint32]peerEndpointPtr) reqPeerLock.Unlock() go func() { - device.peers.mutex.RLock() + device.peers.RLock() i := uint32(1) for _, peer := range device.peers.keyMap { - peer.mutex.RLock() + peer.RLock() if peer.endpoint == nil || peer.endpoint.(*NativeEndpoint) == nil { - peer.mutex.RUnlock() + peer.RUnlock() continue } if peer.endpoint.(*NativeEndpoint).isV6 || peer.endpoint.(*NativeEndpoint).src4().ifindex == 0 { - peer.mutex.RUnlock() + peer.RUnlock() break } nlmsg := struct { @@ -730,14 +730,14 @@ func (bind *NativeBind) routineRouteListener(device *Device) { endpoint: &peer.endpoint, } reqPeerLock.Unlock() - peer.mutex.RUnlock() + peer.RUnlock() i++ _, err := bind.netlinkCancel.Write((*[unsafe.Sizeof(nlmsg)]byte)(unsafe.Pointer(&nlmsg))[:]) if err != nil { break } } - device.peers.mutex.RUnlock() + device.peers.RUnlock() }() } remain = remain[hdr.Len:] diff --git a/cookie.go b/cookie.go index 79b52c6..c648bf1 100644 --- a/cookie.go +++ b/cookie.go @@ -15,8 +15,8 @@ import ( ) type CookieChecker struct { - mutex sync.RWMutex - mac1 struct { + sync.RWMutex + mac1 struct { key [blake2s.Size]byte } mac2 struct { @@ -27,8 +27,8 @@ type CookieChecker struct { } type CookieGenerator struct { - mutex sync.RWMutex - mac1 struct { + sync.RWMutex + mac1 struct { key [blake2s.Size]byte } mac2 struct { @@ -41,8 +41,8 @@ type CookieGenerator struct { } func (st *CookieChecker) Init(pk NoisePublicKey) { - st.mutex.Lock() - defer st.mutex.Unlock() + st.Lock() + defer st.Unlock() // mac1 state @@ -66,8 +66,8 @@ func (st *CookieChecker) Init(pk NoisePublicKey) { } func (st *CookieChecker) CheckMAC1(msg []byte) bool { - st.mutex.RLock() - defer st.mutex.RUnlock() + st.RLock() + defer st.RUnlock() size := len(msg) smac2 := size - blake2s.Size128 @@ -83,8 +83,8 @@ func (st *CookieChecker) CheckMAC1(msg []byte) bool { } func (st *CookieChecker) CheckMAC2(msg []byte, src []byte) bool { - st.mutex.RLock() - defer st.mutex.RUnlock() + st.RLock() + defer st.RUnlock() if time.Now().Sub(st.mac2.secretSet) > CookieRefreshTime { return false @@ -119,21 +119,21 @@ func (st *CookieChecker) CreateReply( src []byte, ) (*MessageCookieReply, error) { - st.mutex.RLock() + st.RLock() // refresh cookie secret if time.Now().Sub(st.mac2.secretSet) > CookieRefreshTime { - st.mutex.RUnlock() - st.mutex.Lock() + st.RUnlock() + st.Lock() _, err := rand.Read(st.mac2.secret[:]) if err != nil { - st.mutex.Unlock() + st.Unlock() return nil, err } st.mac2.secretSet = time.Now() - st.mutex.Unlock() - st.mutex.RLock() + st.Unlock() + st.RLock() } // derive cookie @@ -158,21 +158,21 @@ func (st *CookieChecker) CreateReply( _, err := rand.Read(reply.Nonce[:]) if err != nil { - st.mutex.RUnlock() + st.RUnlock() return nil, err } xchapoly, _ := chacha20poly1305.NewX(st.mac2.encryptionKey[:]) xchapoly.Seal(reply.Cookie[:0], reply.Nonce[:], cookie[:], msg[smac1:smac2]) - st.mutex.RUnlock() + st.RUnlock() return reply, nil } func (st *CookieGenerator) Init(pk NoisePublicKey) { - st.mutex.Lock() - defer st.mutex.Unlock() + st.Lock() + defer st.Unlock() func() { hash, _ := blake2s.New256(nil) @@ -192,8 +192,8 @@ func (st *CookieGenerator) Init(pk NoisePublicKey) { } func (st *CookieGenerator) ConsumeReply(msg *MessageCookieReply) bool { - st.mutex.Lock() - defer st.mutex.Unlock() + st.Lock() + defer st.Unlock() if !st.mac2.hasLastMAC1 { return false @@ -223,8 +223,8 @@ func (st *CookieGenerator) AddMacs(msg []byte) { mac1 := msg[smac1:smac2] mac2 := msg[smac2:] - st.mutex.Lock() - defer st.mutex.Unlock() + st.Lock() + defer st.Unlock() // set mac1 diff --git a/device.go b/device.go index 4404f1e..1b5f808 100644 --- a/device.go +++ b/device.go @@ -29,7 +29,7 @@ type Device struct { state struct { starting sync.WaitGroup stopping sync.WaitGroup - mutex sync.Mutex + sync.Mutex changing AtomicBool current bool } @@ -37,20 +37,20 @@ type Device struct { net struct { starting sync.WaitGroup stopping sync.WaitGroup - mutex sync.RWMutex - bind Bind // bind interface - port uint16 // listening port - fwmark uint32 // mark value (0 = disabled) + sync.RWMutex + bind Bind // bind interface + port uint16 // listening port + fwmark uint32 // mark value (0 = disabled) } staticIdentity struct { - mutex sync.RWMutex + sync.RWMutex privateKey NoisePrivateKey publicKey NoisePublicKey } peers struct { - mutex sync.RWMutex + sync.RWMutex keyMap map[NoisePublicKey]*Peer } @@ -93,7 +93,7 @@ type Device struct { /* Converts the peer into a "zombie", which remains in the peer map, * but processes no packets and does not exists in the routing table. * - * Must hold device.peers.mutex. + * Must hold device.peers.Mutex */ func unsafeRemovePeer(device *Device, peer *Peer, key NoisePublicKey) { @@ -117,13 +117,13 @@ func deviceUpdateState(device *Device) { // compare to current state of device - device.state.mutex.Lock() + device.state.Lock() newIsUp := device.isUp.Get() if newIsUp == device.state.current { device.state.changing.Set(false) - device.state.mutex.Unlock() + device.state.Unlock() return } @@ -135,26 +135,26 @@ func deviceUpdateState(device *Device) { device.isUp.Set(false) break } - device.peers.mutex.RLock() + device.peers.RLock() for _, peer := range device.peers.keyMap { peer.Start() } - device.peers.mutex.RUnlock() + device.peers.RUnlock() case false: device.BindClose() - device.peers.mutex.RLock() + device.peers.RLock() for _, peer := range device.peers.keyMap { peer.Stop() } - device.peers.mutex.RUnlock() + device.peers.RUnlock() } // update state variables device.state.current = newIsUp device.state.changing.Set(false) - device.state.mutex.Unlock() + device.state.Unlock() // check for state change in the mean time @@ -199,11 +199,11 @@ func (device *Device) SetPrivateKey(sk NoisePrivateKey) error { // lock required resources - device.staticIdentity.mutex.Lock() - defer device.staticIdentity.mutex.Unlock() + device.staticIdentity.Lock() + defer device.staticIdentity.Unlock() - device.peers.mutex.Lock() - defer device.peers.mutex.Unlock() + device.peers.Lock() + defer device.peers.Unlock() for _, peer := range device.peers.keyMap { peer.handshake.mutex.RLock() @@ -310,15 +310,15 @@ func NewDevice(tunDevice tun.TUNDevice, logger *Logger) *Device { } func (device *Device) LookupPeer(pk NoisePublicKey) *Peer { - device.peers.mutex.RLock() - defer device.peers.mutex.RUnlock() + device.peers.RLock() + defer device.peers.RUnlock() return device.peers.keyMap[pk] } func (device *Device) RemovePeer(key NoisePublicKey) { - device.peers.mutex.Lock() - defer device.peers.mutex.Unlock() + device.peers.Lock() + defer device.peers.Unlock() // stop peer and remove from routing @@ -329,8 +329,8 @@ func (device *Device) RemovePeer(key NoisePublicKey) { } func (device *Device) RemoveAllPeers() { - device.peers.mutex.Lock() - defer device.peers.mutex.Unlock() + device.peers.Lock() + defer device.peers.Unlock() for key, peer := range device.peers.keyMap { unsafeRemovePeer(device, peer, key) @@ -367,8 +367,8 @@ func (device *Device) Close() { device.log.Info.Println("Device closing") device.state.changing.Set(true) - device.state.mutex.Lock() - defer device.state.mutex.Unlock() + device.state.Lock() + defer device.state.Unlock() device.tun.device.Close() device.BindClose() diff --git a/indextable.go b/indextable.go index edd0898..046113c 100644 --- a/indextable.go +++ b/indextable.go @@ -18,7 +18,7 @@ type IndexTableEntry struct { } type IndexTable struct { - mutex sync.RWMutex + sync.RWMutex table map[uint32]IndexTableEntry } @@ -29,20 +29,20 @@ func randUint32() (uint32, error) { } func (table *IndexTable) Init() { - table.mutex.Lock() - defer table.mutex.Unlock() + table.Lock() + defer table.Unlock() table.table = make(map[uint32]IndexTableEntry) } func (table *IndexTable) Delete(index uint32) { - table.mutex.Lock() - defer table.mutex.Unlock() + table.Lock() + defer table.Unlock() delete(table.table, index) } func (table *IndexTable) SwapIndexForKeypair(index uint32, keypair *Keypair) { - table.mutex.Lock() - defer table.mutex.Unlock() + table.Lock() + defer table.Unlock() entry, ok := table.table[index] if !ok { return @@ -65,19 +65,19 @@ func (table *IndexTable) NewIndexForHandshake(peer *Peer, handshake *Handshake) // check if index used - table.mutex.RLock() + table.RLock() _, ok := table.table[index] - table.mutex.RUnlock() + table.RUnlock() if ok { continue } // check again while locked - table.mutex.Lock() + table.Lock() _, found := table.table[index] if found { - table.mutex.Unlock() + table.Unlock() continue } table.table[index] = IndexTableEntry{ @@ -85,13 +85,13 @@ func (table *IndexTable) NewIndexForHandshake(peer *Peer, handshake *Handshake) handshake: handshake, keypair: nil, } - table.mutex.Unlock() + table.Unlock() return index, nil } } func (table *IndexTable) Lookup(id uint32) IndexTableEntry { - table.mutex.RLock() - defer table.mutex.RUnlock() + table.RLock() + defer table.RUnlock() return table.table[id] } diff --git a/keypair.go b/keypair.go index bc8da0b..5530d6a 100644 --- a/keypair.go +++ b/keypair.go @@ -31,15 +31,15 @@ type Keypair struct { } type Keypairs struct { - mutex sync.RWMutex + sync.RWMutex current *Keypair previous *Keypair next *Keypair } func (kp *Keypairs) Current() *Keypair { - kp.mutex.RLock() - defer kp.mutex.RUnlock() + kp.RLock() + defer kp.RUnlock() return kp.current } diff --git a/misc.go b/misc.go index c4f1d74..6786cb5 100644 --- a/misc.go +++ b/misc.go @@ -17,11 +17,11 @@ const ( ) type AtomicBool struct { - flag int32 + int32 } func (a *AtomicBool) Get() bool { - return atomic.LoadInt32(&a.flag) == AtomicTrue + return atomic.LoadInt32(&a.int32) == AtomicTrue } func (a *AtomicBool) Swap(val bool) bool { @@ -29,7 +29,7 @@ func (a *AtomicBool) Swap(val bool) bool { if val { flag = AtomicTrue } - return atomic.SwapInt32(&a.flag, flag) == AtomicTrue + return atomic.SwapInt32(&a.int32, flag) == AtomicTrue } func (a *AtomicBool) Set(val bool) { @@ -37,7 +37,7 @@ func (a *AtomicBool) Set(val bool) { if val { flag = AtomicTrue } - atomic.StoreInt32(&a.flag, flag) + atomic.StoreInt32(&a.int32, flag) } func min(a, b uint) uint { diff --git a/noise-protocol.go b/noise-protocol.go index ff63ce0..c5c6889 100644 --- a/noise-protocol.go +++ b/noise-protocol.go @@ -154,8 +154,8 @@ func init() { func (device *Device) CreateMessageInitiation(peer *Peer) (*MessageInitiation, error) { - device.staticIdentity.mutex.RLock() - defer device.staticIdentity.mutex.RUnlock() + device.staticIdentity.RLock() + defer device.staticIdentity.RUnlock() handshake := &peer.handshake handshake.mutex.Lock() @@ -241,8 +241,8 @@ func (device *Device) ConsumeMessageInitiation(msg *MessageInitiation) *Peer { return nil } - device.staticIdentity.mutex.RLock() - defer device.staticIdentity.mutex.RUnlock() + device.staticIdentity.RLock() + defer device.staticIdentity.RUnlock() mixHash(&hash, &InitialHash, device.staticIdentity.publicKey[:]) mixHash(&hash, &hash, msg.Ephemeral[:]) @@ -423,8 +423,8 @@ func (device *Device) ConsumeMessageResponse(msg *MessageResponse) *Peer { // lock private key for reading - device.staticIdentity.mutex.RLock() - defer device.staticIdentity.mutex.RUnlock() + device.staticIdentity.RLock() + defer device.staticIdentity.RUnlock() // finish 3-way DH @@ -554,8 +554,8 @@ func (peer *Peer) BeginSymmetricSession() error { // rotate key pairs keypairs := &peer.keypairs - keypairs.mutex.Lock() - defer keypairs.mutex.Unlock() + keypairs.Lock() + defer keypairs.Unlock() previous := keypairs.previous next := keypairs.next @@ -586,8 +586,8 @@ func (peer *Peer) ReceivedWithKeypair(receivedKeypair *Keypair) bool { if keypairs.next != receivedKeypair { return false } - keypairs.mutex.Lock() - defer keypairs.mutex.Unlock() + keypairs.Lock() + defer keypairs.Unlock() if keypairs.next != receivedKeypair { return false } diff --git a/peer.go b/peer.go index 11829cf..f021565 100644 --- a/peer.go +++ b/peer.go @@ -19,7 +19,7 @@ const ( type Peer struct { isRunning AtomicBool - mutex sync.RWMutex // Mostly protects endpoint, but is generally taken whenever we modify peer + sync.RWMutex // Mostly protects endpoint, but is generally taken whenever we modify peer keypairs Keypairs handshake Handshake device *Device @@ -57,10 +57,10 @@ type Peer struct { } routines struct { - mutex sync.Mutex // held when stopping / starting routines - starting sync.WaitGroup // routines pending start - stopping sync.WaitGroup // routines pending stop - stop chan struct{} // size 0, stop all go routines in peer + sync.Mutex // held when stopping / starting routines + starting sync.WaitGroup // routines pending start + stopping sync.WaitGroup // routines pending stop + stop chan struct{} // size 0, stop all go routines in peer } cookieGenerator CookieGenerator @@ -74,11 +74,11 @@ func (device *Device) NewPeer(pk NoisePublicKey) (*Peer, error) { // lock resources - device.staticIdentity.mutex.RLock() - defer device.staticIdentity.mutex.RUnlock() + device.staticIdentity.RLock() + defer device.staticIdentity.RUnlock() - device.peers.mutex.Lock() - defer device.peers.mutex.Unlock() + device.peers.Lock() + defer device.peers.Unlock() // check if over limit @@ -89,8 +89,8 @@ func (device *Device) NewPeer(pk NoisePublicKey) (*Peer, error) { // create peer peer := new(Peer) - peer.mutex.Lock() - defer peer.mutex.Unlock() + peer.Lock() + defer peer.Unlock() peer.cookieGenerator.Init(pk) peer.device = device @@ -126,15 +126,15 @@ func (device *Device) NewPeer(pk NoisePublicKey) (*Peer, error) { } func (peer *Peer) SendBuffer(buffer []byte) error { - peer.device.net.mutex.RLock() - defer peer.device.net.mutex.RUnlock() + peer.device.net.RLock() + defer peer.device.net.RUnlock() if peer.device.net.bind == nil { return errors.New("no bind") } - peer.mutex.RLock() - defer peer.mutex.RUnlock() + peer.RLock() + defer peer.RUnlock() if peer.endpoint == nil { return errors.New("no known endpoint for peer") @@ -162,8 +162,8 @@ func (peer *Peer) Start() { // prevent simultaneous start/stop operations - peer.routines.mutex.Lock() - defer peer.routines.mutex.Unlock() + peer.routines.Lock() + defer peer.routines.Unlock() if peer.isRunning.Get() { return @@ -207,14 +207,14 @@ func (peer *Peer) ZeroAndFlushAll() { // clear key pairs keypairs := &peer.keypairs - keypairs.mutex.Lock() + keypairs.Lock() device.DeleteKeypair(keypairs.previous) device.DeleteKeypair(keypairs.current) device.DeleteKeypair(keypairs.next) keypairs.previous = nil keypairs.current = nil keypairs.next = nil - keypairs.mutex.Unlock() + keypairs.Unlock() // clear handshake state @@ -237,8 +237,8 @@ func (peer *Peer) Stop() { peer.routines.starting.Wait() - peer.routines.mutex.Lock() - defer peer.routines.mutex.Unlock() + peer.routines.Lock() + defer peer.routines.Unlock() peer.device.log.Debug.Println(peer, "- Stopping...") @@ -264,7 +264,7 @@ func (peer *Peer) SetEndpointFromPacket(endpoint Endpoint) { if roamingDisabled { return } - peer.mutex.Lock() + peer.Lock() peer.endpoint = endpoint - peer.mutex.Unlock() + peer.Unlock() } diff --git a/ratelimiter/ratelimiter.go b/ratelimiter/ratelimiter.go index cee367c..595e5a5 100644 --- a/ratelimiter/ratelimiter.go +++ b/ratelimiter/ratelimiter.go @@ -20,21 +20,21 @@ const ( ) type RatelimiterEntry struct { - mutex sync.Mutex + sync.Mutex lastTime time.Time tokens int64 } type Ratelimiter struct { - mutex sync.RWMutex + sync.RWMutex stopReset chan struct{} tableIPv4 map[[net.IPv4len]byte]*RatelimiterEntry tableIPv6 map[[net.IPv6len]byte]*RatelimiterEntry } func (rate *Ratelimiter) Close() { - rate.mutex.Lock() - defer rate.mutex.Unlock() + rate.Lock() + defer rate.Unlock() if rate.stopReset != nil { close(rate.stopReset) @@ -42,8 +42,8 @@ func (rate *Ratelimiter) Close() { } func (rate *Ratelimiter) Init() { - rate.mutex.Lock() - defer rate.mutex.Unlock() + rate.Lock() + defer rate.Unlock() // stop any ongoing garbage collection routine @@ -71,23 +71,23 @@ func (rate *Ratelimiter) Init() { } case <-ticker.C: func() { - rate.mutex.Lock() - defer rate.mutex.Unlock() + rate.Lock() + defer rate.Unlock() for key, entry := range rate.tableIPv4 { - entry.mutex.Lock() + entry.Lock() if time.Now().Sub(entry.lastTime) > garbageCollectTime { delete(rate.tableIPv4, key) } - entry.mutex.Unlock() + entry.Unlock() } for key, entry := range rate.tableIPv6 { - entry.mutex.Lock() + entry.Lock() if time.Now().Sub(entry.lastTime) > garbageCollectTime { delete(rate.tableIPv6, key) } - entry.mutex.Unlock() + entry.Unlock() } if len(rate.tableIPv4) == 0 && len(rate.tableIPv6) == 0 { @@ -109,7 +109,7 @@ func (rate *Ratelimiter) Allow(ip net.IP) bool { IPv4 := ip.To4() IPv6 := ip.To16() - rate.mutex.RLock() + rate.RLock() if IPv4 != nil { copy(keyIPv4[:], IPv4) @@ -119,7 +119,7 @@ func (rate *Ratelimiter) Allow(ip net.IP) bool { entry = rate.tableIPv6[keyIPv6] } - rate.mutex.RUnlock() + rate.RUnlock() // make new entry if not found @@ -127,7 +127,7 @@ func (rate *Ratelimiter) Allow(ip net.IP) bool { entry = new(RatelimiterEntry) entry.tokens = maxTokens - packetCost entry.lastTime = time.Now() - rate.mutex.Lock() + rate.Lock() if IPv4 != nil { rate.tableIPv4[keyIPv4] = entry if len(rate.tableIPv4) == 1 && len(rate.tableIPv6) == 0 { @@ -139,13 +139,13 @@ func (rate *Ratelimiter) Allow(ip net.IP) bool { rate.stopReset <- struct{}{} } } - rate.mutex.Unlock() + rate.Unlock() return true } // add tokens to entry - entry.mutex.Lock() + entry.Lock() now := time.Now() entry.tokens += now.Sub(entry.lastTime).Nanoseconds() entry.lastTime = now @@ -157,9 +157,9 @@ func (rate *Ratelimiter) Allow(ip net.IP) bool { if entry.tokens > packetCost { entry.tokens -= packetCost - entry.mutex.Unlock() + entry.Unlock() return true } - entry.mutex.Unlock() + entry.Unlock() return false } diff --git a/receive.go b/receive.go index 170fa39..fb848eb 100644 --- a/receive.go +++ b/receive.go @@ -26,8 +26,8 @@ type QueueHandshakeElement struct { } type QueueInboundElement struct { - dropped int32 - mutex sync.Mutex + dropped int32 + sync.Mutex buffer *[MaxMessageSize]byte packet []byte counter uint64 @@ -51,7 +51,7 @@ func (device *Device) addToInboundAndDecryptionQueues(inboundQueue chan *QueueIn return true default: element.Drop() - element.mutex.Unlock() + element.Unlock() return false } default: @@ -177,8 +177,8 @@ func (device *Device) RoutineReceiveIncoming(IP int, bind Bind) { elem.dropped = AtomicFalse elem.endpoint = endpoint elem.counter = 0 - elem.mutex = sync.Mutex{} - elem.mutex.Lock() + elem.Mutex = sync.Mutex{} + elem.Lock() // add to decryption queues @@ -281,7 +281,7 @@ func (device *Device) RoutineDecryption() { elem.Drop() device.PutMessageBuffer(elem.buffer) } - elem.mutex.Unlock() + elem.Unlock() } } } @@ -529,7 +529,7 @@ func (peer *Peer) RoutineSequentialReceiver() { // wait for decryption - elem.mutex.Lock() + elem.Lock() if elem.IsDropped() { continue diff --git a/rwcancel/fdset.go b/rwcancel/fdset.go index a46cfc7..28746e6 100644 --- a/rwcancel/fdset.go +++ b/rwcancel/fdset.go @@ -8,15 +8,15 @@ package rwcancel import "golang.org/x/sys/unix" type fdSet struct { - fdset unix.FdSet + unix.FdSet } func (fdset *fdSet) set(i int) { bits := 32 << (^uint(0) >> 63) - fdset.fdset.Bits[i/bits] |= 1 << uint(i%bits) + fdset.Bits[i/bits] |= 1 << uint(i%bits) } func (fdset *fdSet) check(i int) bool { bits := 32 << (^uint(0) >> 63) - return (fdset.fdset.Bits[i/bits] & (1 << uint(i%bits))) != 0 + return (fdset.Bits[i/bits] & (1 << uint(i%bits))) != 0 } diff --git a/rwcancel/rwcancel.go b/rwcancel/rwcancel.go index 83c91a7..3984310 100644 --- a/rwcancel/rwcancel.go +++ b/rwcancel/rwcancel.go @@ -59,7 +59,7 @@ func (rw *RWCancel) ReadyRead() bool { fdset := fdSet{} fdset.set(rw.fd) fdset.set(closeFd) - err := unixSelect(max(rw.fd, closeFd)+1, &fdset.fdset, nil, nil, nil) + err := unixSelect(max(rw.fd, closeFd)+1, &fdset.FdSet, nil, nil, nil) if err != nil { return false } @@ -74,7 +74,7 @@ func (rw *RWCancel) ReadyWrite() bool { fdset := fdSet{} fdset.set(rw.fd) fdset.set(closeFd) - err := unixSelect(max(rw.fd, closeFd)+1, nil, &fdset.fdset, nil, nil) + err := unixSelect(max(rw.fd, closeFd)+1, nil, &fdset.FdSet, nil, nil) if err != nil { return false } diff --git a/send.go b/send.go index d8627d3..b7cac04 100644 --- a/send.go +++ b/send.go @@ -43,7 +43,7 @@ import ( type QueueOutboundElement struct { dropped int32 - mutex sync.Mutex + sync.Mutex buffer *[MaxMessageSize]byte // slice holding the packet data packet []byte // slice of "buffer" (always!) nonce uint64 // nonce for encryption @@ -55,7 +55,7 @@ func (device *Device) NewOutboundElement() *QueueOutboundElement { elem := device.GetOutboundElement() elem.dropped = AtomicFalse elem.buffer = device.GetMessageBuffer() - elem.mutex = sync.Mutex{} + elem.Mutex = sync.Mutex{} elem.nonce = 0 elem.keypair = nil elem.peer = nil @@ -95,7 +95,7 @@ func addToOutboundAndEncryptionQueues(outboundQueue chan *QueueOutboundElement, default: element.Drop() element.peer.device.PutMessageBuffer(element.buffer) - element.mutex.Unlock() + element.Unlock() } default: element.peer.device.PutMessageBuffer(element.buffer) @@ -442,7 +442,7 @@ func (peer *Peer) RoutineNonce() { elem.keypair = keypair elem.dropped = AtomicFalse - elem.mutex.Lock() + elem.Lock() // add to parallel and sequential queue addToOutboundAndEncryptionQueues(peer.queue.outbound, device.queue.encryption, elem) @@ -468,7 +468,7 @@ func (device *Device) RoutineEncryption() { if ok && !elem.IsDropped() { elem.Drop() device.PutMessageBuffer(elem.buffer) - elem.mutex.Unlock() + elem.Unlock() } default: goto out @@ -535,7 +535,7 @@ func (device *Device) RoutineEncryption() { elem.packet, nil, ) - elem.mutex.Unlock() + elem.Unlock() } } } @@ -588,7 +588,7 @@ func (peer *Peer) RoutineSequentialSender() { return } - elem.mutex.Lock() + elem.Lock() if elem.IsDropped() { device.PutOutboundElement(elem) continue diff --git a/timers.go b/timers.go index ac950b5..9c16f13 100644 --- a/timers.go +++ b/timers.go @@ -19,7 +19,7 @@ import ( */ type Timer struct { - timer *time.Timer + *time.Timer modifyingLock sync.RWMutex runningLock sync.Mutex isPending bool @@ -27,7 +27,7 @@ type Timer struct { func (peer *Peer) NewTimer(expirationFunction func(*Peer)) *Timer { timer := &Timer{} - timer.timer = time.AfterFunc(time.Hour, func() { + timer.Timer = time.AfterFunc(time.Hour, func() { timer.runningLock.Lock() timer.modifyingLock.Lock() @@ -42,21 +42,21 @@ func (peer *Peer) NewTimer(expirationFunction func(*Peer)) *Timer { expirationFunction(peer) timer.runningLock.Unlock() }) - timer.timer.Stop() + timer.Stop() return timer } func (timer *Timer) Mod(d time.Duration) { timer.modifyingLock.Lock() timer.isPending = true - timer.timer.Reset(d) + timer.Reset(d) timer.modifyingLock.Unlock() } func (timer *Timer) Del() { timer.modifyingLock.Lock() timer.isPending = false - timer.timer.Stop() + timer.Stop() timer.modifyingLock.Unlock() } @@ -101,11 +101,11 @@ func expiredRetransmitHandshake(peer *Peer) { peer.device.log.Debug.Printf("%s - Handshake did not complete after %d seconds, retrying (try %d)\n", peer, int(RekeyTimeout.Seconds()), atomic.LoadUint32(&peer.timers.handshakeAttempts)+1) /* We clear the endpoint address src address, in case this is the cause of trouble. */ - peer.mutex.Lock() + peer.Lock() if peer.endpoint != nil { peer.endpoint.ClearSrc() } - peer.mutex.Unlock() + peer.Unlock() peer.SendHandshakeInitiation(true) } @@ -124,11 +124,11 @@ func expiredSendKeepalive(peer *Peer) { func expiredNewHandshake(peer *Peer) { peer.device.log.Debug.Printf("%s - Retrying handshake because we stopped hearing back after %d seconds\n", peer, int((KeepaliveTimeout + RekeyTimeout).Seconds())) /* We clear the endpoint address src address, in case this is the cause of trouble. */ - peer.mutex.Lock() + peer.Lock() if peer.endpoint != nil { peer.endpoint.ClearSrc() } - peer.mutex.Unlock() + peer.Unlock() peer.SendHandshakeInitiation(false) } diff --git a/uapi.go b/uapi.go index a13d909..f540989 100644 --- a/uapi.go +++ b/uapi.go @@ -17,15 +17,15 @@ import ( ) type IPCError struct { - Code int64 + int64 } func (s *IPCError) Error() string { - return fmt.Sprintf("IPC error: %d", s.Code) + return fmt.Sprintf("IPC error: %d", s.int64) } func (s *IPCError) ErrorCode() int64 { - return s.Code + return s.int64 } func ipcGetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { @@ -43,14 +43,14 @@ func ipcGetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { // lock required resources - device.net.mutex.RLock() - defer device.net.mutex.RUnlock() + device.net.RLock() + defer device.net.RUnlock() - device.staticIdentity.mutex.RLock() - defer device.staticIdentity.mutex.RUnlock() + device.staticIdentity.RLock() + defer device.staticIdentity.RUnlock() - device.peers.mutex.RLock() - defer device.peers.mutex.RUnlock() + device.peers.RLock() + defer device.peers.RUnlock() // serialize device related values @@ -69,8 +69,8 @@ func ipcGetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { // serialize each peer state for _, peer := range device.peers.keyMap { - peer.mutex.RLock() - defer peer.mutex.RUnlock() + peer.RLock() + defer peer.RUnlock() send("public_key=" + peer.handshake.remoteStatic.ToHex()) send("preshared_key=" + peer.handshake.presharedKey.ToHex()) @@ -101,9 +101,7 @@ func ipcGetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { for _, line := range lines { _, err := socket.WriteString(line + "\n") if err != nil { - return &IPCError{ - Code: ipcErrorIO, - } + return &IPCError{ipcErrorIO} } } @@ -130,7 +128,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { } parts := strings.Split(line, "=") if len(parts) != 2 { - return &IPCError{Code: ipcErrorProtocol} + return &IPCError{ipcErrorProtocol} } key := parts[0] value := parts[1] @@ -145,7 +143,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { err := sk.FromHex(value) if err != nil { logError.Println("Failed to set private_key:", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } logDebug.Println("UAPI: Updating private key") device.SetPrivateKey(sk) @@ -157,20 +155,20 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { port, err := strconv.ParseUint(value, 10, 16) if err != nil { logError.Println("Failed to parse listen_port:", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } // update port and rebind logDebug.Println("UAPI: Updating listen port") - device.net.mutex.Lock() + device.net.Lock() device.net.port = uint16(port) - device.net.mutex.Unlock() + device.net.Unlock() if err := device.BindUpdate(); err != nil { logError.Println("Failed to set listen_port:", err) - return &IPCError{Code: ipcErrorPortInUse} + return &IPCError{ipcErrorPortInUse} } case "fwmark": @@ -187,14 +185,14 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { if err != nil { logError.Println("Invalid fwmark", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } logDebug.Println("UAPI: Updating fwmark") if err := device.BindSetMark(uint32(fwmark)); err != nil { logError.Println("Failed to update fwmark:", err) - return &IPCError{Code: ipcErrorPortInUse} + return &IPCError{ipcErrorPortInUse} } case "public_key": @@ -205,14 +203,14 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { case "replace_peers": if value != "true" { logError.Println("Failed to set replace_peers, invalid value:", value) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } logDebug.Println("UAPI: Removing all peers") device.RemoveAllPeers() default: logError.Println("Invalid UAPI device key:", key) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } } @@ -227,14 +225,14 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { err := publicKey.FromHex(value) if err != nil { logError.Println("Failed to get peer by public key:", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } // ignore peer with public key of device - device.staticIdentity.mutex.RLock() + device.staticIdentity.RLock() dummy = device.staticIdentity.publicKey.Equals(publicKey) - device.staticIdentity.mutex.RUnlock() + device.staticIdentity.RUnlock() if dummy { peer = &Peer{} @@ -246,7 +244,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { peer, err = device.NewPeer(publicKey) if err != nil { logError.Println("Failed to create new peer:", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } logDebug.Println(peer, "- UAPI: Created") } @@ -257,7 +255,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { if value != "true" { logError.Println("Failed to set remove, invalid value:", value) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } if !dummy { logDebug.Println(peer, "- UAPI: Removing") @@ -278,7 +276,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { if err != nil { logError.Println("Failed to set preshared key:", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } case "endpoint": @@ -288,8 +286,8 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { logDebug.Println(peer, "- UAPI: Updating endpoint") err := func() error { - peer.mutex.Lock() - defer peer.mutex.Unlock() + peer.Lock() + defer peer.Unlock() endpoint, err := CreateEndpoint(value) if err != nil { return err @@ -300,7 +298,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { if err != nil { logError.Println("Failed to set endpoint:", value) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } case "persistent_keepalive_interval": @@ -312,7 +310,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { secs, err := strconv.ParseUint(value, 10, 16) if err != nil { logError.Println("Failed to set persistent keepalive interval:", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } old := peer.persistentKeepaliveInterval @@ -323,7 +321,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { if old == 0 && secs != 0 { if err != nil { logError.Println("Failed to get tun device status:", err) - return &IPCError{Code: ipcErrorIO} + return &IPCError{ipcErrorIO} } if device.isUp.Get() && !dummy { peer.SendKeepalive() @@ -336,7 +334,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { if value != "true" { logError.Println("Failed to replace allowedips, invalid value:", value) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } if dummy { @@ -352,7 +350,7 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { _, network, err := net.ParseCIDR(value) if err != nil { logError.Println("Failed to set allowed ip:", err) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } if dummy { @@ -366,12 +364,12 @@ func ipcSetOperation(device *Device, socket *bufio.ReadWriter) *IPCError { if value != "1" { logError.Println("Invalid protocol version:", value) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } default: logError.Println("Invalid UAPI peer key:", key) - return &IPCError{Code: ipcErrorInvalid} + return &IPCError{ipcErrorInvalid} } } }