Update to the latest golangci-lint

.golangci.toml

+# https://golangci-lint.run/docs/configuration/file/
+
+version = 2
+
 [run]
 concurrency = 4
-deadline = "2m"
 tests = true
-skip-dirs = ["vendor"]
-
-[output]
-format = "colored-line-number"
 
-[linters]
-enable-all = true
-disable = [
-    "containedctx",
-    "exhaustivestruct",
-    "exhaustruct",
-    "gas",
-    "gochecknoglobals",
-    "goerr113",
-    "ireturn",
-    "thelper",
-    "varnamelen",
-]
+# [linters]
+# enable-all = true
+# disable = [
+#     "containedctx",
+#     "exhaustivestruct",
+#     "exhaustruct",
+#     "gas",
+#     "gochecknoglobals",
+#     "goerr113",
+#     "ireturn",
+#     "thelper",
+#     "varnamelen",
+# ]

.mise.toml

 outputs = ["mtg"]
 run = "go build"
 
+[tasks.lint]
+description = "Run linter"
+tools.golangci-lint = "latest"
+run = "golangci-lint run"
+
 [tasks.test]
 description = "Run tests"
 run = "go test -v ./..."

antireplay/stable_bloom_filter.go

 		errorRate = DefaultStableBloomFilterErrorRate
 	}
 
-	sf := boom.NewDefaultStableBloomFilter(byteSize*8, errorRate) //nolint: gomnd
+	sf := boom.NewDefaultStableBloomFilter(byteSize*8, errorRate)
 	sf.SetHash(xxhash.New64())
 
 	return &stableBloomFilter{

internal/cli/access.go

 	}
 
 	wg := &sync.WaitGroup{}
-	wg.Add(2) //nolint: gomnd
+	wg.Add(2)
 
 	go func() {
 		defer wg.Done()
 
 	defer func() {
 		io.Copy(io.Discard, resp.Body) //nolint: errcheck
-		resp.Body.Close()
+		resp.Body.Close() //nolint: errcheck
 	}()
 
 	data, err := io.ReadAll(resp.Body)

internal/cli/run_proxy.go

 }
 
 func makeEventStream(conf *config.Config, logger mtglib.Logger) (mtglib.EventStream, error) {
-	factories := make([]events.ObserverFactory, 0, 2) //nolint: gomnd
+	factories := make([]events.ObserverFactory, 0, 2)
 
 	if conf.Stats.StatsD.Enabled.Get(false) {
 		statsdFactory, err := stats.NewStatsd(
 	go proxy.Serve(listener) //nolint: errcheck
 
 	<-ctx.Done()
-	listener.Close()
+	listener.Close() //nolint: errcheck
 	proxy.Shutdown()
 
 	return nil

internal/cli/simple_run.go

 		return fmt.Errorf("incorrect secret: %w", err)
 	}
 
-	if err := conf.Concurrency.Set(strconv.FormatUint(s.Concurrency, 10)); err != nil { //nolint: gomnd
+	if err := conf.Concurrency.Set(strconv.FormatUint(s.Concurrency, 10)); err != nil {
 		return fmt.Errorf("incorrect concurrency: %w", err)
 	}
 
 		return fmt.Errorf("incorrect prefer-ip: %w", err)
 	}
 
-	if err := conf.DomainFrontingPort.Set(strconv.FormatUint(s.DomainFrontingPort, 10)); err != nil { //nolint: gomnd
+	if err := conf.DomainFrontingPort.Set(strconv.FormatUint(s.DomainFrontingPort, 10)); err != nil {
 		return fmt.Errorf("incorrect domain-fronting-port: %w", err)
 	}
 

internal/config/type_concurrency.go

 }
 
 func (t *TypeConcurrency) Set(value string) error {
-	concurrencyValue, err := strconv.ParseUint(value, 10, 16) //nolint: gomnd
+	concurrencyValue, err := strconv.ParseUint(value, 10, 16)
 	if err != nil {
 		return fmt.Errorf("value is not uint (%s): %w", value, err)
 	}
 }
 
 func (t TypeConcurrency) String() string {
-	return strconv.FormatUint(uint64(t.Value), 10) //nolint: gomnd
+	return strconv.FormatUint(uint64(t.Value), 10)
 }

internal/config/type_error_rate.go

 }
 
 func (t *TypeErrorRate) Set(value string) error {
-	parsedValue, err := strconv.ParseFloat(value, 64) //nolint: gomnd
+	parsedValue, err := strconv.ParseFloat(value, 64)
 	if err != nil {
 		return fmt.Errorf("value is not a float (%s): %w", value, err)
 	}
 }
 
 func (t TypeErrorRate) String() string {
-	return strconv.FormatFloat(t.Value, 'f', -1, 64) //nolint: gomnd
+	return strconv.FormatFloat(t.Value, 'f', -1, 64)
 }

internal/config/type_hostport.go

 		return fmt.Errorf("incorrect host:port value (%v): %w", value, err)
 	}
 
-	portValue, err := strconv.ParseUint(port, 10, 16) //nolint: gomnd
+	portValue, err := strconv.ParseUint(port, 10, 16)
 	if err != nil {
 		return fmt.Errorf("incorrect port number (%v): %w", value, err)
 	}

internal/config/type_port.go

 }
 
 func (t *TypePort) Set(value string) error {
-	portValue, err := strconv.ParseUint(value, 10, 16) //nolint: gomnd
+	portValue, err := strconv.ParseUint(value, 10, 16)
 	if err != nil {
 		return fmt.Errorf("incorrect port number (%v): %w", value, err)
 	}

internal/testlib/capture_output.go

 
 	callback()
 
-	writer.Close()
+	writer.Close() //nolint: errcheck
 	<-closeChan
 
 	return strings.TrimSpace(buf.String())

internal/utils/net_listener.go

 	}
 
 	if err := network.SetClientSocketOptions(conn, 0); err != nil {
-		conn.Close()
+		conn.Close() //nolint: errcheck
 
 		return nil, fmt.Errorf("cannot set TCP options: %w", err)
 	}

ipblocklist/files/http.go

 	if err != nil {
 		if response != nil {
 			io.Copy(io.Discard, response.Body) //nolint: errcheck
-			response.Body.Close()
+			response.Body.Close() //nolint: errcheck
 		}
 
 		return nil, fmt.Errorf("cannot get url %s: %w", h.url, err)

ipblocklist/files/http_test.go

 	readCloser, err := file.Open(suite.ctx)
 	suite.NoError(err)
 
-	defer readCloser.Close()
+	defer readCloser.Close() //nolint: errcheck
 
 	data, err := io.ReadAll(readCloser)
 	suite.NoError(err)

ipblocklist/firehol.go

 var (
 	fireholRegexpComment = regexp.MustCompile(`\s*#.*?$`)
 
-	fireholIPv4DefaultCIDR = net.CIDRMask(32, 32)   //nolint: gomnd
-	fireholIPv6DefaultCIDR = net.CIDRMask(128, 128) //nolint: gomnd
+	fireholIPv4DefaultCIDR = net.CIDRMask(32, 32)
+	fireholIPv6DefaultCIDR = net.CIDRMask(128, 128)
 )
 
 // FireholUpdateCallback defines a signature of the callback that has to be
 				return
 			}
 
-			defer fileContent.Close()
+			defer fileContent.Close() //nolint: errcheck
 
 			if err := f.updateFromFile(mutex, ranger, bufio.NewScanner(fileContent)); err != nil {
 				logger.WarningError("update has failed", err)

ipblocklist/firehol_test.go

 			panic(err)
 		}
 
-		defer filefp.Close()
+		defer filefp.Close() //nolint: errcheck
 
 		io.Copy(w, filefp) //nolint: errcheck
 	})

mtglib/internal/faketls/client_hello.go

 	if len(handshake)-4 != int(handshakeLength) {
 		return hello,
 			fmt.Errorf("incorrect handshake size. manifested=%d, real=%d",
-				handshakeLength, len(handshake)-4) //nolint: gomnd
+				handshakeLength, len(handshake)-4)
 	}
 
 	copy(hello.Random[:], handshake[ClientHelloRandomOffset:])
 }
 
 func parseCipherSuite(hello *ClientHello, handshake []byte) {
-	cipherSuiteOffset := ClientHelloSessionIDOffset + len(hello.SessionID) + 3 //nolint: gomnd
+	cipherSuiteOffset := ClientHelloSessionIDOffset + len(hello.SessionID) + 3
 	hello.CipherSuite = binary.BigEndian.Uint16(handshake[cipherSuiteOffset : cipherSuiteOffset+2])
 }
 

mtglib/internal/faketls/welcome.go

 	rec.Type = record.TypeApplicationData
 	rec.Version = record.Version12
 
-	if _, err := io.CopyN(&rec.Payload, rand.Reader, int64(1024+mrand.Intn(3092))); err != nil { //nolint: gomnd
+	if _, err := io.CopyN(&rec.Payload, rand.Reader, int64(1024+mrand.Intn(3092))); err != nil {
 		panic(err)
 	}
 

mtglib/internal/obfuscated2/handshake_frame.go

 }
 
 func (h *handshakeFrame) dc() int {
-	idx := int16(h.data[handshakeFrameOffsetDC]) | int16(h.data[handshakeFrameOffsetDC+1])<<8 //nolint: gomnd, lll // little endian for int16 is here
+	idx := int16(h.data[handshakeFrameOffsetDC]) | int16(h.data[handshakeFrameOffsetDC+1])<<8 //nolint: lll // little endian for int16 is here
 
 	switch {
 	case idx > 0:

mtglib/internal/obfuscated2/server_handshake.go

 			panic(err)
 		}
 
-		if frame.data[0] == 0xef { //nolint: gomnd // taken from tg sources
+		if frame.data[0] == 0xef { // taken from tg sources
 			continue
 		}
 
 		switch binary.LittleEndian.Uint32(frame.data[:4]) {
-		case 0x44414548, 0x54534f50, 0x20544547, 0x4954504f, 0xeeeeeeee: //nolint: gomnd // taken from tg sources
+		case 0x44414548, 0x54534f50, 0x20544547, 0x4954504f, 0xeeeeeeee: // taken from tg sources
 			continue
 		}
 

mtglib/internal/relay/relay.go

 )
 
 func Relay(ctx context.Context, log Logger, telegramConn, clientConn essentials.Conn) {
-	defer telegramConn.Close()
-	defer clientConn.Close()
+	defer telegramConn.Close() //nolint: errcheck
+	defer clientConn.Close() //nolint: errcheck
 
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
 	go func() {
 		<-ctx.Done()
-		telegramConn.Close()
-		clientConn.Close()
+		telegramConn.Close() //nolint: errcheck
+		clientConn.Close() //nolint: errcheck
 	}()
 
 	closeChan := make(chan struct{})

mtglib/proxy.go

 		logger := p.logger.BindStr("ip", ipAddr.String())
 
 		if !p.allowlist.Contains(ipAddr) {
-			conn.Close()
+			conn.Close() //nolint: errcheck
 			logger.Info("ip was rejected by allowlist")
 			p.eventStream.Send(p.ctx, NewEventIPAllowlisted(ipAddr))
 
 		}
 
 		if p.blocklist.Contains(ipAddr) {
-			conn.Close()
+			conn.Close() //nolint: errcheck
 			logger.Info("ip was blacklisted")
 			p.eventStream.Send(p.ctx, NewEventIPBlocklisted(ipAddr))
 
 
 	encryptor, decryptor, err := obfuscated2.ServerHandshake(conn)
 	if err != nil {
-		conn.Close()
+		conn.Close() //nolint: errcheck
 
 		return fmt.Errorf("cannot perform obfuscated2 handshake: %w", err)
 	}

mtglib/proxy_test.go

 
 func (suite *ProxyTestSuite) TearDownSuite() {
 	if suite.listener != nil {
-		suite.listener.Close()
+		suite.listener.Close() //nolint: errcheck
 	}
 
 	if suite.p != nil {
 	resp, err := client.Get(addr) //nolint: noctx
 	suite.NoError(err)
 
-	defer resp.Body.Close()
+	defer resp.Body.Close() //nolint: errcheck
 
 	suite.Equal(http.StatusOK, resp.StatusCode)
 

mtglib/secret.go

 		return fmt.Errorf("incorrect secret format: %w", err)
 	}
 
-	if len(decoded) < 2 { //nolint: gomnd // we need at least 1 byte here
+	if len(decoded) < 2 { // we need at least 1 byte here
 		return fmt.Errorf("secret is truncated, length=%d", len(decoded))
 	}
 

mtglib/stream_context.go

 	s.ctxCancel()
 
 	if s.clientConn != nil {
-		s.clientConn.Close()
+		s.clientConn.Close() //nolint: errcheck
 	}
 
 	if s.telegramConn != nil {
-		s.telegramConn.Close()
+		s.telegramConn.Close() //nolint: errcheck
 	}
 }
 

mtglib/stream_context_internal_test.go

 
 func (suite *StreamContextTestSuite) SetupTest() {
 	ctx, cancel := context.WithCancel(context.Background())
-	ctx = context.WithValue(ctx, "key", "value") //nolint: golint, staticcheck
+	ctx = context.WithValue(ctx, "key", "value") //nolint: staticcheck
 
 	suite.ctxCancel = cancel
 	suite.connMock = &testlib.EssentialsConnMock{}

network/circuit_breaker.go

 	select {
 	case <-ctx.Done():
 		if conn != nil {
-			conn.Close()
+			conn.Close() //nolint: errcheck
 		}
 
 		return nil, ctx.Err() //nolint: wrapcheck
 	select {
 	case <-ctx.Done():
 		if conn != nil {
-			conn.Close()
+			conn.Close() //nolint: errcheck
 		}
 
 		return nil, ctx.Err() //nolint: wrapcheck

network/default.go

 
 	// we do not need to call to end user. End users call us.
 	if err := SetServerSocketOptions(conn, 0); err != nil {
-		conn.Close()
+		conn.Close() //nolint: errcheck
 
 		return nil, fmt.Errorf("cannot set socket options: %w", err)
 	}

network/default_test.go

 	suite.NoError(err)
 	suite.NotNil(conn)
 
-	conn.Close()
+	conn.Close() //nolint: errcheck
 }
 
 func (suite *DefaultDialerTestSuite) TestHTTPRequest() {
 
 	resp, err := httpClient.Get(suite.MakeURL("/get")) //nolint: noctx
 	if err == nil {
-		defer resp.Body.Close()
+		defer resp.Body.Close() //nolint: errcheck
 	}
 
 	suite.NoError(err)

network/init_test.go

 }
 
 func (suite *Socks5ServerTestSuite) TearDownSuite() {
-	suite.socks5Listener.Close()
+	suite.socks5Listener.Close() //nolint: errcheck
 }
 
 func (suite *Socks5ServerTestSuite) MakeSocks5URL(user, password string) *url.URL {

network/load_balanced_socks5_test.go

 func (suite *LoadBalancedSocks5TestSuite) TestDialOk() {
 	resp, err := suite.httpClient.Get(suite.MakeURL("/get")) //nolint: noctx
 	if err == nil {
-		defer resp.Body.Close()
+		defer resp.Body.Close() //nolint: errcheck
 	}
 
 	suite.NoError(err)

network/network_test.go

 	resp, err := client.Get(suite.httpServer.URL + "/headers") //nolint: noctx
 	suite.NoError(err)
 
-	defer resp.Body.Close()
+	defer resp.Body.Close() //nolint: errcheck
 
 	data, err := io.ReadAll(resp.Body)
 	suite.NoError(err)
 	resp, err := client.Get("https://httpbin.org/headers") //nolint: noctx
 	suite.NoError(err)
 
-	defer resp.Body.Close()
+	defer resp.Body.Close() //nolint: errcheck
 
 	data, err := io.ReadAll(resp.Body)
 	suite.NoError(err)

network/proxy_dialer.go

 	)
 
 	if param := params.Get("open_threshold"); param != "" {
-		if intNum, err := strconv.ParseUint(param, 10, 32); err == nil { //nolint: gomnd
+		if intNum, err := strconv.ParseUint(param, 10, 32); err == nil {
 			openThreshold = uint32(intNum)
 		}
 	}

network/sockopts_unix.go

 	var err error
 
 	conn.Control(func(fd uintptr) { //nolint: errcheck
-		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1) //nolint: nosnakecase
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
 		if err != nil {
 			err = fmt.Errorf("cannot set SO_REUSEADDR: %w", err)
 
 			return
 		}
 
-		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1) //nolint: nosnakecase
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
 		if err != nil {
 			err = fmt.Errorf("cannot set SO_REUSEPORT: %w", err)
 		}

network/socks5.go

 	}
 
 	if err := s.handshake(conn); err != nil {
-		conn.Close()
+		conn.Close() //nolint: errcheck
 
 		return nil, fmt.Errorf("cannot perform a handshake: %w", err)
 	}
 
 	if err := s.connect(conn, address); err != nil {
-		conn.Close()
+		conn.Close() //nolint: errcheck
 
 		return nil, fmt.Errorf("cannot connect to a destination host %s: %w", address, err)
 	}

network/socks5_test.go

 
 	resp, err := httpClient.Get(suite.MakeURL("/get")) //nolint: noctx
 	if err == nil {
-		defer resp.Body.Close()
+		defer resp.Body.Close() //nolint: errcheck
 	}
 
 	suite.Error(err)
 
 	resp, err := httpClient.Get(suite.MakeURL("/get")) //nolint: noctx
 	if err == nil {
-		defer resp.Body.Close()
+		defer resp.Body.Close() //nolint: errcheck
 	}
 
 	suite.NoError(err)

stats/prometheus_test.go

 		return "", err //nolint: wrapcheck
 	}
 
-	defer resp.Body.Close()
+	defer resp.Body.Close() //nolint: errcheck
 
 	data, err := io.ReadAll(resp.Body)
 	if err != nil {
 func (suite *PrometheusTestSuite) TearDownTest() {
 	suite.prometheus.Shutdown()
 	suite.NoError(suite.factory.Close())
-	suite.httpListener.Close()
+	suite.httpListener.Close() //nolint: errcheck
 }
 
 func (suite *PrometheusTestSuite) TestTelegramPath() {

stats/statsd_test.go

 
 func (suite *StatsdTestSuite) TearDownTest() {
 	suite.statsd.Shutdown()
-	suite.factory.Close()
-	suite.statsdServer.Close()
+	suite.factory.Close() //nolint: errcheck
+	suite.statsdServer.Close() //nolint: errcheck
 }
 
 func (suite *StatsdTestSuite) TestTelegramPath() {