update golangci-lint (#554)

.golangci.yml

@@ -68,4 +68,3 @@ linters-settings:
     disable:
     - fieldalignment
     - reflectvaluecompare
-    - shadow

client.go

@@ -748,7 +748,7 @@ func (c *Client) trySwitchingProtocol() error {
 	}
 
 	for i, cm := range prevMedias {
-		_, err := c.doSetup(prevBaseURL, cm.media, 0, 0)
+		_, err = c.doSetup(prevBaseURL, cm.media, 0, 0)
 		if err != nil {
 			return err
 		}
@@ -1132,7 +1132,8 @@ func (c *Client) doDescribe(u *base.URL) (*description.Session, *base.Response,
 			len(res.Header["Location"]) == 1 {
 			c.reset()
 
-			ru, err := base.ParseURL(res.Header["Location"][0])
+			var ru *base.URL
+			ru, err = base.ParseURL(res.Header["Location"][0])
 			if err != nil {
 				return nil, nil, err
 			}
@@ -1325,7 +1326,7 @@ func (c *Client) doSetup(
 			return nil, liberrors.ErrClientUDPPortsNotConsecutive{}
 		}
 
-		err := cm.allocateUDPListeners(
+		err = cm.allocateUDPListeners(
 			false,
 			nil,
 			net.JoinHostPort("", strconv.FormatInt(int64(rtpPort), 10)),
@@ -1480,7 +1481,7 @@ func (c *Client) doSetup(
 			readIP = c.nconn.RemoteAddr().(*net.TCPAddr).IP
 		}
 
-		err := cm.allocateUDPListeners(
+		err = cm.allocateUDPListeners(
 			true,
 			readIP,
 			net.JoinHostPort(thRes.Destination.String(), strconv.FormatInt(int64(thRes.Ports[0]), 10)),

client_test.go

@@ -61,12 +61,12 @@ func TestClientTLSSetServerName(t *testing.T) {
 	go func() {
 		defer close(serverDone)
 
-		nconn, err := l.Accept()
+		nconn, err2 := l.Accept()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		defer nconn.Close()
 
-		cert, err := tls.X509KeyPair(serverCert, serverKey)
+		cert, err2 := tls.X509KeyPair(serverCert, serverKey)
-		require.NoError(t, err)
+		require.NoError(t, err2)
 
 		tnconn := tls.Server(nconn, &tls.Config{
 			Certificates:       []tls.Certificate{cert},
@@ -77,8 +77,8 @@ func TestClientTLSSetServerName(t *testing.T) {
 			},
 		})
 
-		err = tnconn.Handshake()
+		err2 = tnconn.Handshake()
-		require.EqualError(t, err, "remote error: tls: bad certificate")
+		require.EqualError(t, err2, "remote error: tls: bad certificate")
 	}()
 
 	u, err := base.ParseURL("rtsps://localhost:8554/stream")
@@ -144,13 +144,13 @@ func TestClientCloseDuringRequest(t *testing.T) {
 	go func() {
 		defer close(serverDone)
 
-		nconn, err := l.Accept()
+		nconn, err2 := l.Accept()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
 
-		req, err := conn.ReadRequest()
+		req, err2 := conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Options, req.Method)
 
 		close(requestReceived)
@@ -188,16 +188,16 @@ func TestClientSession(t *testing.T) {
 	go func() {
 		defer close(serverDone)
 
-		nconn, err := l.Accept()
+		nconn, err2 := l.Accept()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		conn := conn.NewConn(nconn)
 		defer nconn.Close()
 
-		req, err := conn.ReadRequest()
+		req, err2 := conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Options, req.Method)
 
-		err = conn.WriteResponse(&base.Response{
+		err2 = conn.WriteResponse(&base.Response{
 			StatusCode: base.StatusOK,
 			Header: base.Header{
 				"Public": base.HeaderValue{strings.Join([]string{
@@ -206,16 +206,16 @@ func TestClientSession(t *testing.T) {
 				"Session": base.HeaderValue{"123456"},
 			},
 		})
-		require.NoError(t, err)
+		require.NoError(t, err2)
 
-		req, err = conn.ReadRequest()
+		req, err2 = conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Describe, req.Method)
 		require.Equal(t, base.HeaderValue{"123456"}, req.Header["Session"])
 
 		medias := []*description.Media{testH264Media}
 
-		err = conn.WriteResponse(&base.Response{
+		err2 = conn.WriteResponse(&base.Response{
 			StatusCode: base.StatusOK,
 			Header: base.Header{
 				"Content-Type": base.HeaderValue{"application/sdp"},
@@ -223,7 +223,7 @@ func TestClientSession(t *testing.T) {
 			},
 			Body: mediasToSDP(medias),
 		})
-		require.NoError(t, err)
+		require.NoError(t, err2)
 	}()
 
 	u, err := base.ParseURL("rtsp://localhost:8554/stream")
@@ -249,16 +249,16 @@ func TestClientAuth(t *testing.T) {
 	go func() {
 		defer close(serverDone)
 
-		nconn, err := l.Accept()
+		nconn, err2 := l.Accept()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		conn := conn.NewConn(nconn)
 		defer nconn.Close()
 
-		req, err := conn.ReadRequest()
+		req, err2 := conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Options, req.Method)
 
-		err = conn.WriteResponse(&base.Response{
+		err2 = conn.WriteResponse(&base.Response{
 			StatusCode: base.StatusOK,
 			Header: base.Header{
 				"Public": base.HeaderValue{strings.Join([]string{
@@ -266,40 +266,40 @@ func TestClientAuth(t *testing.T) {
 				}, ", ")},
 			},
 		})
-		require.NoError(t, err)
+		require.NoError(t, err2)
 
-		req, err = conn.ReadRequest()
+		req, err2 = conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Describe, req.Method)
 
-		nonce, err := auth.GenerateNonce()
+		nonce, err2 := auth.GenerateNonce()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 
-		err = conn.WriteResponse(&base.Response{
+		err2 = conn.WriteResponse(&base.Response{
 			StatusCode: base.StatusUnauthorized,
 			Header: base.Header{
 				"WWW-Authenticate": auth.GenerateWWWAuthenticate(nil, "IPCAM", nonce),
 			},
 		})
-		require.NoError(t, err)
+		require.NoError(t, err2)
 
-		req, err = conn.ReadRequest()
+		req, err2 = conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Describe, req.Method)
 
-		err = auth.Validate(req, "myuser", "mypass", nil, nil, "IPCAM", nonce)
+		err2 = auth.Validate(req, "myuser", "mypass", nil, nil, "IPCAM", nonce)
-		require.NoError(t, err)
+		require.NoError(t, err2)
 
 		medias := []*description.Media{testH264Media}
 
-		err = conn.WriteResponse(&base.Response{
+		err2 = conn.WriteResponse(&base.Response{
 			StatusCode: base.StatusOK,
 			Header: base.Header{
 				"Content-Type": base.HeaderValue{"application/sdp"},
 			},
 			Body: mediasToSDP(medias),
 		})
-		require.NoError(t, err)
+		require.NoError(t, err2)
 	}()
 
 	u, err := base.ParseURL("rtsp://myuser:mypass@localhost:8554/stream")
@@ -330,18 +330,18 @@ func TestClientCSeq(t *testing.T) {
 			go func() {
 				defer close(serverDone)
 
-				nconn, err := l.Accept()
+				nconn, err2 := l.Accept()
-				require.NoError(t, err)
+				require.NoError(t, err2)
 				defer nconn.Close()
 				conn := conn.NewConn(nconn)
 
-				req, err := conn.ReadRequest()
+				req, err2 := conn.ReadRequest()
-				require.NoError(t, err)
+				require.NoError(t, err2)
 				require.Equal(t, base.Options, req.Method)
 
 				switch ca {
 				case "different cseq":
-					err = conn.WriteResponse(&base.Response{
+					err2 = conn.WriteResponse(&base.Response{
 						StatusCode: base.StatusOK,
 						Header: base.Header{
 							"Public": base.HeaderValue{strings.Join([]string{
@@ -350,9 +350,9 @@ func TestClientCSeq(t *testing.T) {
 							"CSeq": base.HeaderValue{"150"},
 						},
 					})
-					require.NoError(t, err)
+					require.NoError(t, err2)
 
-					err = conn.WriteResponse(&base.Response{
+					err2 = conn.WriteResponse(&base.Response{
 						StatusCode: base.StatusOK,
 						Header: base.Header{
 							"Public": base.HeaderValue{strings.Join([]string{
@@ -361,10 +361,10 @@ func TestClientCSeq(t *testing.T) {
 							"CSeq": req.Header["CSeq"],
 						},
 					})
-					require.NoError(t, err)
+					require.NoError(t, err2)
 
 				case "space at the end":
-					err = conn.WriteResponse(&base.Response{
+					err2 = conn.WriteResponse(&base.Response{
 						StatusCode: base.StatusOK,
 						Header: base.Header{
 							"Public": base.HeaderValue{strings.Join([]string{
@@ -373,7 +373,7 @@ func TestClientCSeq(t *testing.T) {
 							"CSeq": base.HeaderValue{req.Header["CSeq"][0] + " "},
 						},
 					})
-					require.NoError(t, err)
+					require.NoError(t, err2)
 				}
 			}()
 
@@ -402,16 +402,16 @@ func TestClientDescribeCharset(t *testing.T) {
 	go func() {
 		defer close(serverDone)
 
-		nconn, err := l.Accept()
+		nconn, err2 := l.Accept()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)
 
-		req, err := conn.ReadRequest()
+		req, err2 := conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Options, req.Method)
 
-		err = conn.WriteResponse(&base.Response{
+		err2 = conn.WriteResponse(&base.Response{
 			StatusCode: base.StatusOK,
 			Header: base.Header{
 				"Public": base.HeaderValue{strings.Join([]string{
@@ -419,16 +419,16 @@ func TestClientDescribeCharset(t *testing.T) {
 				}, ", ")},
 			},
 		})
-		require.NoError(t, err)
+		require.NoError(t, err2)
 
-		req, err = conn.ReadRequest()
+		req, err2 = conn.ReadRequest()
-		require.NoError(t, err)
+		require.NoError(t, err2)
 		require.Equal(t, base.Describe, req.Method)
 		require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
 
 		medias := []*description.Media{testH264Media}
 
-		err = conn.WriteResponse(&base.Response{
+		err2 = conn.WriteResponse(&base.Response{
 			StatusCode: base.StatusOK,
 			Header: base.Header{
 				"Content-Type": base.HeaderValue{"application/sdp; charset=utf-8"},
@@ -436,7 +436,7 @@ func TestClientDescribeCharset(t *testing.T) {
 			},
 			Body: mediasToSDP(medias),
 		})
-		require.NoError(t, err)
+		require.NoError(t, err2)
 	}()
 
 	u, err := base.ParseURL("rtsp://localhost:8554/teststream")
@@ -464,17 +464,17 @@ func TestClientReplyToServerRequest(t *testing.T) {
 			go func() {
 				defer close(serverDone)
 
-				nconn, err := l.Accept()
+				nconn, err2 := l.Accept()
-				require.NoError(t, err)
+				require.NoError(t, err2)
 				conn := conn.NewConn(nconn)
 				defer nconn.Close()
 
-				req, err := conn.ReadRequest()
+				req, err2 := conn.ReadRequest()
-				require.NoError(t, err)
+				require.NoError(t, err2)
 				require.Equal(t, base.Options, req.Method)
 
 				if ca == "after response" {
-					err = conn.WriteResponse(&base.Response{
+					err2 = conn.WriteResponse(&base.Response{
 						StatusCode: base.StatusOK,
 						Header: base.Header{
 							"Public": base.HeaderValue{strings.Join([]string{
@@ -482,37 +482,38 @@ func TestClientReplyToServerRequest(t *testing.T) {
 							}, ", ")},
 						},
 					})
-					require.NoError(t, err)
+					require.NoError(t, err2)
 
-					err = conn.WriteRequest(&base.Request{
+					err2 = conn.WriteRequest(&base.Request{
 						Method: base.Options,
 						URL:    nil,
 						Header: base.Header{
 							"CSeq": base.HeaderValue{"4"},
 						},
 					})
-					require.NoError(t, err)
+					require.NoError(t, err2)
 
-					res, err := conn.ReadResponse()
+					var res *base.Response
-					require.NoError(t, err)
+					res, err2 = conn.ReadResponse()
+					require.NoError(t, err2)
 					require.Equal(t, base.StatusOK, res.StatusCode)
 					require.Equal(t, "4", res.Header["CSeq"][0])
 				} else {
-					err = conn.WriteRequest(&base.Request{
+					err2 = conn.WriteRequest(&base.Request{
 						Method: base.Options,
 						URL:    nil,
 						Header: base.Header{
 							"CSeq": base.HeaderValue{"4"},
 						},
 					})
-					require.NoError(t, err)
+					require.NoError(t, err2)
 
-					res, err := conn.ReadResponse()
+					res, err2 := conn.ReadResponse()
-					require.NoError(t, err)
+					require.NoError(t, err2)
 					require.Equal(t, base.StatusOK, res.StatusCode)
 					require.Equal(t, "4", res.Header["CSeq"][0])
 
-					err = conn.WriteResponse(&base.Response{
+					err2 = conn.WriteResponse(&base.Response{
 						StatusCode: base.StatusOK,
 						Header: base.Header{
 							"Public": base.HeaderValue{strings.Join([]string{
@@ -520,7 +521,7 @@ func TestClientReplyToServerRequest(t *testing.T) {
 							}, ", ")},
 						},
 					})
-					require.NoError(t, err)
+					require.NoError(t, err2)
 				}
 			}()
 

pkg/base/header.go

@@ -45,7 +45,7 @@ func (h *Header) unmarshal(br *bufio.Reader) error {
 		}
 
 		if byt == '\r' {
-			err := readByteEqual(br, '\n')
+			err = readByteEqual(br, '\n')
 			if err != nil {
 				return err
 			}
@@ -68,7 +68,7 @@ func (h *Header) unmarshal(br *bufio.Reader) error {
 		// https://tools.ietf.org/html/rfc2616
 		// The field value MAY be preceded by any amount of spaces
 		for {
-			byt, err := br.ReadByte()
+			byt, err = br.ReadByte()
 			if err != nil {
 				return err
 			}

pkg/base/request.go

@@ -65,7 +65,8 @@ func (req *Request) Unmarshal(br *bufio.Reader) error {
 	rawURL := string(byts[:len(byts)-1])
 
 	if rawURL != "*" {
-		ur, err := ParseURL(rawURL)
+		var ur *URL
+		ur, err = ParseURL(rawURL)
 		if err != nil {
 			return fmt.Errorf("invalid URL (%v)", rawURL)
 		}

pkg/headers/range.go

@@ -52,7 +52,7 @@ func (t *RangeSMPTETime) unmarshal(s string) error {
 	t.Time = time.Duration(seconds+mins*60+hours*3600) * time.Second
 
 	if len(parts) == 4 {
-		parts := strings.Split(parts[3], ".")
+		parts = strings.Split(parts[3], ".")
 		if len(parts) == 2 {
 			tmp, err := strconv.ParseUint(parts[0], 10, 64)
 			if err != nil {

pkg/rtpreorderer/reorderer_test.go

@@ -189,7 +189,7 @@ func TestBufferIsFull(t *testing.T) {
 	var expected []*rtp.Packet
 
 	for i := 0; i < 64-toMiss; i++ {
-		out, missing := r.Process(&rtp.Packet{
+		out, missing = r.Process(&rtp.Packet{
 			Header: rtp.Header{
 				SequenceNumber: sn + uint16(toMiss),
 			},

pkg/sdp/sdp.go

@@ -114,7 +114,7 @@ func (s *SessionDescription) unmarshalOrigin(value string) error {
 	var tmp string
 	tmp, value = value[i+1:], value[:i]
 
-	if i := strings.Index(tmp, "."); i >= 0 {
+	if i = strings.Index(tmp, "."); i >= 0 {
 		tmp = tmp[:i]
 	}
 	tmp = strings.TrimPrefix(tmp, "-")

server_conn.go

@@ -287,7 +287,7 @@ func (sc *ServerConn) handleRequestInner(req *base.Request) (*base.Response, err
 				// to return a SDP that contains a multicast address.
 				multicast := false
 				if sc.s.MulticastIPRange != "" {
-					if q, err := gourl.ParseQuery(query); err == nil {
+					if q, err2 := gourl.ParseQuery(query); err2 == nil {
 						if _, ok := q["vlcmulticast"]; ok {
 							multicast = true
 						}

server_play_test.go

@@ -682,11 +682,12 @@ func TestServerPlay(t *testing.T) {
 
 				p := ipv4.NewPacketConn(l1)
 
-				intfs, err := net.Interfaces()
+				var intfs []net.Interface
+				intfs, err = net.Interfaces()
 				require.NoError(t, err)
 
 				for _, intf := range intfs {
-					err := p.JoinGroup(&intf, &net.UDPAddr{IP: *th.Destination})
+					err = p.JoinGroup(&intf, &net.UDPAddr{IP: *th.Destination})
 					require.NoError(t, err)
 				}
 
@@ -700,7 +701,7 @@ func TestServerPlay(t *testing.T) {
 				require.NoError(t, err)
 
 				for _, intf := range intfs {
-					err := p.JoinGroup(&intf, &net.UDPAddr{IP: *th.Destination})
+					err = p.JoinGroup(&intf, &net.UDPAddr{IP: *th.Destination})
 					require.NoError(t, err)
 				}
 
@@ -719,12 +720,14 @@ func TestServerPlay(t *testing.T) {
 			switch transport {
 			case "udp":
 				buf := make([]byte, 2048)
-				n, _, err := l2.ReadFrom(buf)
+				var n int
+				n, _, err = l2.ReadFrom(buf)
 				require.NoError(t, err)
 				require.Equal(t, testRTCPPacketMarshaled, buf[:n])
 
 			case "tcp", "tls":
-				f, err := conn.ReadInterleavedFrame()
+				var f *base.InterleavedFrame
+				f, err = conn.ReadInterleavedFrame()
 				require.NoError(t, err)
 
 				switch f.Channel {
@@ -742,7 +745,8 @@ func TestServerPlay(t *testing.T) {
 			// server -> client (through stream)
 			if transport == "udp" || transport == "multicast" {
 				buf := make([]byte, 2048)
-				n, _, err := l1.ReadFrom(buf)
+				var n int
+				n, _, err = l1.ReadFrom(buf)
 				require.NoError(t, err)
 				require.Equal(t, testRTPPacketMarshaled, buf[:n])
 
@@ -752,7 +756,8 @@ func TestServerPlay(t *testing.T) {
 				require.Equal(t, testRTCPPacketMarshaled, buf[:n])
 			} else {
 				for i := 0; i < 2; i++ {
-					f, err := conn.ReadInterleavedFrame()
+					var f *base.InterleavedFrame
+					f, err = conn.ReadInterleavedFrame()
 					require.NoError(t, err)
 
 					switch f.Channel {
@@ -771,7 +776,7 @@ func TestServerPlay(t *testing.T) {
 			// client -> server (RTCP)
 			switch transport {
 			case "udp":
-				_, err := l2.WriteTo(testRTCPPacketMarshaled, &net.UDPAddr{
+				_, err = l2.WriteTo(testRTCPPacketMarshaled, &net.UDPAddr{
 					IP:   net.ParseIP("127.0.0.1"),
 					Port: th.ServerPorts[1],
 				})
@@ -779,7 +784,7 @@ func TestServerPlay(t *testing.T) {
 				<-framesReceived
 
 			case "multicast":
-				_, err := l2.WriteTo(testRTCPPacketMarshaled, &net.UDPAddr{
+				_, err = l2.WriteTo(testRTCPPacketMarshaled, &net.UDPAddr{
 					IP:   *th.Destination,
 					Port: th.Ports[1],
 				})
@@ -787,7 +792,7 @@ func TestServerPlay(t *testing.T) {
 				<-framesReceived
 
 			default:
-				err := conn.WriteInterleavedFrame(&base.InterleavedFrame{
+				err = conn.WriteInterleavedFrame(&base.InterleavedFrame{
 					Channel: 6,
 					Payload: testRTCPPacketMarshaled,
 				}, make([]byte, 1024))
@@ -1078,10 +1083,11 @@ func TestServerPlayRTCPReport(t *testing.T) {
 				require.NoError(t, err)
 				buf = buf[:n]
 			} else {
-				_, err := conn.ReadInterleavedFrame()
+				_, err = conn.ReadInterleavedFrame()
 				require.NoError(t, err)
 
-				f, err := conn.ReadInterleavedFrame()
+				var f *base.InterleavedFrame
+				f, err = conn.ReadInterleavedFrame()
 				require.NoError(t, err)
 				require.Equal(t, 1, f.Channel)
 				buf = f.Payload
@@ -2061,7 +2067,8 @@ func TestServerPlayBytesSent(t *testing.T) {
 	defer stream.Close()
 
 	for _, transport := range []string{"tcp", "multicast"} {
-		nconn, err := net.Dial("tcp", "localhost:8554")
+		var nconn net.Conn
+		nconn, err = net.Dial("tcp", "localhost:8554")
 		require.NoError(t, err)
 		defer nconn.Close()
 		conn := conn.NewConn(nconn)

server_record_test.go

@@ -637,11 +637,13 @@ func TestServerRecord(t *testing.T) {
 				// server -> client (direct)
 				if transport == "udp" {
 					buf := make([]byte, 2048)
-					n, _, err := l2s[i].ReadFrom(buf)
+					var n int
+					n, _, err = l2s[i].ReadFrom(buf)
 					require.NoError(t, err)
 					require.Equal(t, testRTCPPacketMarshaled, buf[:n])
 				} else {
-					f, err := conn.ReadInterleavedFrame()
+					var f *base.InterleavedFrame
+					f, err = conn.ReadInterleavedFrame()
 					require.NoError(t, err)
 					require.Equal(t, 3+i*2, f.Channel)
 					require.Equal(t, testRTCPPacketMarshaled, f.Payload)
@@ -650,7 +652,7 @@ func TestServerRecord(t *testing.T) {
 				// skip firewall opening
 				if transport == "udp" {
 					buf := make([]byte, 2048)
-					_, _, err := l2s[i].ReadFrom(buf)
+					_, _, err = l2s[i].ReadFrom(buf)
 					require.NoError(t, err)
 				}
 

server_session.go

@@ -593,7 +593,8 @@ func (ss *ServerSession) handleRequestInner(sc *ServerConn, req *base.Request) (
 		}
 
 		for _, medi := range desc.Medias {
-			mediURL, err := medi.URL(req.URL)
+			var mediURL *base.URL
+			mediURL, err = medi.URL(req.URL)
 			if err != nil {
 				return &base.Response{
 					StatusCode: base.StatusBadRequest,
@@ -662,12 +663,9 @@ func (ss *ServerSession) handleRequestInner(sc *ServerConn, req *base.Request) (
 			}, nil
 		}
 
-		var path string
-		var query string
 		var trackID string
 		switch ss.state {
 		case ServerSessionStateInitial, ServerSessionStatePrePlay: // play
-			var err error
 			path, query, trackID, err = serverParseURLForPlay(req.URL)
 			if err != nil {
 				return &base.Response{
@@ -794,7 +792,7 @@ func (ss *ServerSession) handleRequestInner(sc *ServerConn, req *base.Request) (
 		ss.setuppedTransport = &transport
 
 		if ss.state == ServerSessionStateInitial {
-			err := stream.readerAdd(ss,
+			err = stream.readerAdd(ss,
 				inTH.ClientPorts,
 			)
 			if err != nil {

server_test.go

@@ -1041,8 +1041,8 @@ func TestServerAuth(t *testing.T) {
 	s := &Server{
 		Handler: &testServerHandler{
 			onAnnounce: func(ctx *ServerHandlerOnAnnounceCtx) (*base.Response, error) {
-				err := auth.Validate(ctx.Request, "myuser", "mypass", nil, nil, "IPCAM", nonce)
+				err2 := auth.Validate(ctx.Request, "myuser", "mypass", nil, nil, "IPCAM", nonce)
-				if err != nil {
+				if err2 != nil {
 					return &base.Response{ //nolint:nilerr
 						StatusCode: base.StatusUnauthorized,
 						Header: base.Header{

server_udp_listener.go

@@ -136,9 +136,9 @@ func (u *serverUDPListener) run() {
 			u.clientsMutex.RLock()
 			defer u.clientsMutex.RUnlock()
 
-			var clientAddr clientAddr
+			var ca clientAddr
-			clientAddr.fill(addr.IP, addr.Port)
+			ca.fill(addr.IP, addr.Port)
-			cb, ok := u.clients[clientAddr]
+			cb, ok := u.clients[ca]
 			if !ok {
 				return
 			}