Update golangci-lint

.golangci.toml

 
 [linters]
 enable-all = true
-disable = ["thelper", "ireturn", "varnamelen", "gochecknoglobals", "gas", "goerr113", "exhaustivestruct", "containedctx"]
+disable = [
+    "containedctx",
+    "exhaustivestruct",
+    "exhaustruct",
+    "gas",
+    "gochecknoglobals",
+    "goerr113",
+    "ireturn",
+    "thelper",
+    "varnamelen",
+]

Makefile

 IMAGE_NAME   := mtg
 APP_NAME     := $(IMAGE_NAME)
 
-GOLANGCI_LINT_VERSION := v1.47.3
+GOLANGCI_LINT_VERSION := v1.48.0
 
 VERSION            := $(shell git describe --exact-match HEAD 2>/dev/null || git describe --tags --always)
 COMMON_BUILD_FLAGS := -trimpath -mod=readonly -ldflags="-extldflags '-static' -s -w -X 'main.version=$(VERSION)'"

antireplay/stable_bloom_filter.go

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

buildinfo.go

 )
 
 func getVersion() string {
-	goVersion, date, commit, modulesChecksum, dirty := getVersionData()
-
-	dirtySuffix := ""
-	if dirty {
-		dirtySuffix = " [dirty]"
-	}
-
-	return fmt.Sprintf("%s (%s: %s on %s%s, modules checksum %s)",
-		version,
-		goVersion,
-		date.Format(time.RFC3339),
-		commit,
-		dirtySuffix,
-		modulesChecksum)
-}
-
-func getVersionData() (goVersion string, date time.Time, commit string, modulesChecksum string, dirty bool) {
-	date = time.Now()
-
 	buildInfo, ok := debug.ReadBuildInfo()
 	if !ok {
-		return
+		return version
 	}
 
-	goVersion = buildInfo.GoVersion
+	date := time.Now()
+	commit := ""
+	goVersion := buildInfo.GoVersion
+	dirtySuffix := ""
 
 	for _, setting := range buildInfo.Settings {
 		switch setting.Key {
 		case "vcs.revision":
 			commit = setting.Value
 		case "vcs.modified":
-			dirty, _ = strconv.ParseBool(setting.Value)
+			if dirty, _ := strconv.ParseBool(setting.Value); dirty {
+				dirtySuffix = " [dirty]"
+			}
 		}
 	}
 
 	if _, err := io.WriteString(hasher, buildInfo.Path); err != nil {
 		panic(err)
 	}
-	binary.Write(hasher, binary.LittleEndian, uint64(1+len(buildInfo.Deps)))
+
+	binary.Write(hasher, binary.LittleEndian, uint64(1+len(buildInfo.Deps))) //nolint: errcheck
 
 	sort.Slice(buildInfo.Deps, func(i, j int) bool {
 		return buildInfo.Deps[i].Path > buildInfo.Deps[j].Path
 	})
 
 	buildInfoCheckSumModule(hasher, &buildInfo.Main)
+
 	for _, module := range buildInfo.Deps {
 		buildInfoCheckSumModule(hasher, module)
 	}
 
-	modulesChecksum = base64.StdEncoding.EncodeToString(hasher.Sum(nil))
-
-	return
+	return fmt.Sprintf("%s (%s: %s on %s%s, modules checksum %s)",
+		version,
+		goVersion,
+		date.Format(time.RFC3339),
+		commit,
+		dirtySuffix,
+		base64.StdEncoding.EncodeToString(hasher.Sum(nil)))
 }
 
 func buildInfoCheckSumModule(w io.Writer, module *debug.Module) {
-	w.Write([]byte{buildInfoModuleStart})
+	w.Write([]byte{buildInfoModuleStart}) //nolint: errcheck
 
 	if _, err := io.WriteString(w, module.Path); err != nil {
 		panic(err)
 	}
 
-	w.Write([]byte{buildInfoModuleDelimeter})
+	w.Write([]byte{buildInfoModuleDelimeter}) //nolint: errcheck
 
 	if _, err := io.WriteString(w, module.Version); err != nil {
 		panic(err)
 	}
 
-	w.Write([]byte{buildInfoModuleDelimeter})
+	w.Write([]byte{buildInfoModuleDelimeter}) //nolint: errcheck
 
 	if _, err := io.WriteString(w, module.Sum); err != nil {
 		panic(err)
 	}
 
-	w.Write([]byte{buildInfoModuleFinish})
+	w.Write([]byte{buildInfoModuleFinish}) //nolint: errcheck
 }

events/event_stream.go

 	return rv
 }
 
-func eventStreamProcessor(ctx context.Context, eventChan <-chan mtglib.Event, observer Observer) { // nolint: cyclop
+func eventStreamProcessor(ctx context.Context, eventChan <-chan mtglib.Event, observer Observer) { //nolint: cyclop
 	defer observer.Shutdown()
 
 	for {

internal/cli/access.go

 type accessResponseURLs struct {
 	IP        net.IP `json:"ip"`
 	Port      uint   `json:"port"`
-	TgURL     string `json:"tg_url"`     // nolint: tagliatelle
-	TgQrCode  string `json:"tg_qrcode"`  // nolint: tagliatelle
-	TmeURL    string `json:"tme_url"`    // nolint: tagliatelle
-	TmeQrCode string `json:"tme_qrcode"` // nolint: tagliatelle
+	TgURL     string `json:"tg_url"`     //nolint: tagliatelle
+	TgQrCode  string `json:"tg_qrcode"`  //nolint: tagliatelle
+	TmeURL    string `json:"tme_url"`    //nolint: tagliatelle
+	TmeQrCode string `json:"tme_qrcode"` //nolint: tagliatelle
 }
 
 type Access struct {
-	ConfigPath string `kong:"arg,required,type='existingfile',help='Path to the configuration file.',name='config-path'"`                 // nolint: lll
-	PublicIPv4 net.IP `kong:"help='Public IPv4 address for proxy. By default it is resolved via remote website',name='ipv4',short='i'"`   // nolint: lll
-	PublicIPv6 net.IP `kong:"help='Public IPv6 address for proxy. By default it is resolved via remote website',name='ipv6',short='I'"`   // nolint: lll
-	Port       uint   `kong:"help='Port number. Default port is taken from configuration file, bind-to parameter',type:'uint',short='p'"` // nolint: lll
+	ConfigPath string `kong:"arg,required,type='existingfile',help='Path to the configuration file.',name='config-path'"`                 //nolint: lll
+	PublicIPv4 net.IP `kong:"help='Public IPv4 address for proxy. By default it is resolved via remote website',name='ipv4',short='i'"`   //nolint: lll
+	PublicIPv6 net.IP `kong:"help='Public IPv6 address for proxy. By default it is resolved via remote website',name='ipv6',short='I'"`   //nolint: lll
+	Port       uint   `kong:"help='Port number. Default port is taken from configuration file, bind-to parameter',type:'uint',short='p'"` //nolint: lll
 	Hex        bool   `kong:"help='Print secret in hex encoding.',short='x'"`
 }
 
 	}
 
 	wg := &sync.WaitGroup{}
-	wg.Add(2) // nolint: gomnd
+	wg.Add(2) //nolint: gomnd
 
 	go func() {
 		defer wg.Done()
 
 func (a *Access) getIP(ntw mtglib.Network, protocol string) net.IP {
 	client := ntw.MakeHTTPClient(func(ctx context.Context, network, address string) (essentials.Conn, error) {
-		return ntw.DialContext(ctx, protocol, address) // nolint: wrapcheck
+		return ntw.DialContext(ctx, protocol, address) //nolint: wrapcheck
 	})
 
-	req, err := http.NewRequest(http.MethodGet, "https://ifconfig.co", nil) // nolint: noctx
+	req, err := http.NewRequest(http.MethodGet, "https://ifconfig.co", nil) //nolint: noctx
 	if err != nil {
 		panic(err)
 	}
 	}
 
 	defer func() {
-		io.Copy(io.Discard, resp.Body) // nolint: errcheck
+		io.Copy(io.Discard, resp.Body) //nolint: errcheck
 		resp.Body.Close()
 	}()
 

internal/cli/generate_secret.go

 	secret := mtglib.GenerateSecret(cli.GenerateSecret.HostName)
 
 	if g.Hex {
-		fmt.Println(secret.Hex()) // nolint: forbidigo
+		fmt.Println(secret.Hex()) //nolint: forbidigo
 	} else {
-		fmt.Println(secret.Base64()) // nolint: forbidigo
+		fmt.Println(secret.Base64()) //nolint: forbidigo
 	}
 
 	return nil

internal/cli/run.go

 )
 
 type Run struct {
-	ConfigPath string `kong:"arg,required,type='existingfile',help='Path to the configuration file.',name='config-path'"` // nolint: lll
+	ConfigPath string `kong:"arg,required,type='existingfile',help='Path to the configuration file.',name='config-path'"` //nolint: lll
 }
 
 func (r *Run) Run(cli *CLI, version string) error {

internal/cli/run_proxy.go

 	}
 
 	if len(conf.Network.Proxies) == 0 {
-		return network.NewNetwork(baseDialer, userAgent, dohIP, httpTimeout) // nolint: wrapcheck
+		return network.NewNetwork(baseDialer, userAgent, dohIP, httpTimeout) //nolint: wrapcheck
 	}
 
 	proxyURLs := make([]*url.URL, 0, len(conf.Network.Proxies))
 			return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
 		}
 
-		return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) // nolint: wrapcheck
+		return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) //nolint: wrapcheck
 	}
 
 	socksDialer, err := network.NewLoadBalancedSocks5Dialer(baseDialer, proxyURLs)
 		return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
 	}
 
-	return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) // nolint: wrapcheck
+	return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout) //nolint: wrapcheck
 }
 
 func makeAntiReplayCache(conf *config.Config) mtglib.AntiReplayCache {
 	logger mtglib.Logger,
 	ntw mtglib.Network,
 	updateCallback ipblocklist.FireholUpdateCallback,
-) (allowlist mtglib.IPBlocklist, err error) {
+) (mtglib.IPBlocklist, error) {
+	var (
+		allowlist mtglib.IPBlocklist
+		err       error
+	)
+
 	if !conf.Enabled.Get(false) {
 		allowlist, err = ipblocklist.NewFireholFromFiles(
 			logger.Named("ipblocklist"),
 }
 
 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) //nolint: gomnd
 
 	if conf.Stats.StatsD.Enabled.Get(false) {
 		statsdFactory, err := stats.NewStatsd(
 			return nil, fmt.Errorf("cannot start a listener for prometheus: %w", err)
 		}
 
-		go prometheus.Serve(listener) // nolint: errcheck
+		go prometheus.Serve(listener) //nolint: errcheck
 
 		factories = append(factories, prometheus.Make)
 	}
 	return events.NewNoopStream(), nil
 }
 
-func runProxy(conf *config.Config, version string) error { // nolint: funlen
+func runProxy(conf *config.Config, version string) error { //nolint: funlen
 	logger := makeLogger(conf)
 
 	logger.BindJSON("configuration", conf.String()).Debug("configuration")
 
 	ctx := utils.RootContext()
 
-	go proxy.Serve(listener) // nolint: errcheck
+	go proxy.Serve(listener) //nolint: errcheck
 
 	<-ctx.Done()
 	listener.Close()

internal/cli/simple_run.go

 	BindTo string `kong:"arg,required,name='bind-to',help='A host:port to bind proxy to.'"`
 	Secret string `kong:"arg,required,name='secret',help='Proxy secret.'"`
 
-	Debug               bool          `kong:"name='debug',short='d',help='Run in debug mode.'"`                                                                        // nolint: lll
-	Concurrency         uint64        `kong:"name='concurrency',short='c',default='8192',help='Max number of concurrent connection to proxy.'"`                        // nolint: lll
-	TCPBuffer           string        `kong:"name='tcp-buffer',short='b',default='4KB',help='Deprecated and ignored'"`                                                 // nolint: lll
-	PreferIP            string        `kong:"name='prefer-ip',short='i',default='prefer-ipv6',help='IP preference. By default we prefer IPv6 with fallback to IPv4.'"` // nolint: lll
-	DomainFrontingPort  uint64        `kong:"name='domain-fronting-port',short='p',default='443',help='A port to access for domain fronting.'"`                        // nolint: lll
-	DOHIP               net.IP        `kong:"name='doh-ip',short='n',default='9.9.9.9',help='IP address of DNS-over-HTTP to use.'"`                                    // nolint: lll
-	Timeout             time.Duration `kong:"name='timeout',short='t',default='10s',help='Network timeout to use'"`                                                    // nolint: lll
-	AntiReplayCacheSize string        `kong:"name='antireplay-cache-size',short='a',default='1MB',help='A size of anti-replay cache to use.'"`                         // nolint: lll
+	Debug               bool          `kong:"name='debug',short='d',help='Run in debug mode.'"`                                                                        //nolint: lll
+	Concurrency         uint64        `kong:"name='concurrency',short='c',default='8192',help='Max number of concurrent connection to proxy.'"`                        //nolint: lll
+	TCPBuffer           string        `kong:"name='tcp-buffer',short='b',default='4KB',help='Deprecated and ignored'"`                                                 //nolint: lll
+	PreferIP            string        `kong:"name='prefer-ip',short='i',default='prefer-ipv6',help='IP preference. By default we prefer IPv6 with fallback to IPv4.'"` //nolint: lll
+	DomainFrontingPort  uint64        `kong:"name='domain-fronting-port',short='p',default='443',help='A port to access for domain fronting.'"`                        //nolint: lll
+	DOHIP               net.IP        `kong:"name='doh-ip',short='n',default='9.9.9.9',help='IP address of DNS-over-HTTP to use.'"`                                    //nolint: lll
+	Timeout             time.Duration `kong:"name='timeout',short='t',default='10s',help='Network timeout to use'"`                                                    //nolint: lll
+	AntiReplayCacheSize string        `kong:"name='antireplay-cache-size',short='a',default='1MB',help='A size of anti-replay cache to use.'"`                         //nolint: lll
 }
 
-func (s *SimpleRun) Run(cli *CLI, version string) error { // nolint: cyclop
+func (s *SimpleRun) Run(cli *CLI, version string) error { //nolint: cyclop
 	conf := &config.Config{}
 
 	if err := conf.BindTo.Set(s.BindTo); err != nil {
 		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 { //nolint: gomnd
 		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 { //nolint: gomnd
 		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) //nolint: gomnd
 	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) //nolint: gomnd
 }

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) //nolint: gomnd
 	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) //nolint: gomnd
 }

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) //nolint: gomnd
 	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) //nolint: gomnd
 	if err != nil {
 		return fmt.Errorf("incorrect port number (%v): %w", value, err)
 	}

internal/testlib/capture_output.go

 	closeChan := make(chan bool)
 
 	go func() {
-		io.Copy(buf, reader) // nolint: errcheck
+		io.Copy(buf, reader) //nolint: errcheck
 		close(closeChan)
 	}()
 

internal/testlib/mtglib_network_mock.go

 func (m *MtglibNetworkMock) Dial(network, address string) (essentials.Conn, error) {
 	args := m.Called(network, address)
 
-	return args.Get(0).(essentials.Conn), args.Error(1) // nolint: wrapcheck, forcetypeassert
+	return args.Get(0).(essentials.Conn), args.Error(1) //nolint: wrapcheck, forcetypeassert
 }
 
 func (m *MtglibNetworkMock) DialContext(ctx context.Context, network, address string) (essentials.Conn, error) {
 	args := m.Called(ctx, network, address)
 
-	return args.Get(0).(essentials.Conn), args.Error(1) // nolint: wrapcheck, forcetypeassert
+	return args.Get(0).(essentials.Conn), args.Error(1) //nolint: wrapcheck, forcetypeassert
 }
 
 func (m *MtglibNetworkMock) MakeHTTPClient(dialFunc func(ctx context.Context,
 	network, address string) (essentials.Conn, error),
 ) *http.Client {
-	return m.Called(dialFunc).Get(0).(*http.Client) // nolint: forcetypeassert
+	return m.Called(dialFunc).Get(0).(*http.Client) //nolint: forcetypeassert
 }

internal/testlib/net_conn_mock.go

 }
 
 func (n *EssentialsConnMock) Close() error {
-	return n.Called().Error(0) // nolint: wrapcheck
+	return n.Called().Error(0) //nolint: wrapcheck
 }
 
 func (n *EssentialsConnMock) CloseRead() error {
-	return n.Called().Error(0) // nolint: wrapcheck
+	return n.Called().Error(0) //nolint: wrapcheck
 }
 
 func (n *EssentialsConnMock) CloseWrite() error {
-	return n.Called().Error(0) // nolint: wrapcheck
+	return n.Called().Error(0) //nolint: wrapcheck
 }
 
 func (n *EssentialsConnMock) LocalAddr() net.Addr {
-	return n.Called().Get(0).(net.Addr) // nolint: forcetypeassert
+	return n.Called().Get(0).(net.Addr) //nolint: forcetypeassert
 }
 
 func (n *EssentialsConnMock) RemoteAddr() net.Addr {
-	return n.Called().Get(0).(net.Addr) // nolint: forcetypeassert
+	return n.Called().Get(0).(net.Addr) //nolint: forcetypeassert
 }
 
 func (n *EssentialsConnMock) SetDeadline(t time.Time) error {
-	return n.Called(t).Error(0) // nolint: wrapcheck
+	return n.Called(t).Error(0) //nolint: wrapcheck
 }
 
 func (n *EssentialsConnMock) SetReadDeadline(t time.Time) error {
-	return n.Called(t).Error(0) // nolint: wrapcheck
+	return n.Called(t).Error(0) //nolint: wrapcheck
 }
 
 func (n *EssentialsConnMock) SetWriteDeadline(t time.Time) error {
-	return n.Called(t).Error(0) // nolint: wrapcheck
+	return n.Called(t).Error(0) //nolint: wrapcheck
 }

internal/utils/net_listener.go

 func (l Listener) Accept() (net.Conn, error) {
 	conn, err := l.Listener.Accept()
 	if err != nil {
-		return nil, err // nolint: wrapcheck
+		return nil, err //nolint: wrapcheck
 	}
 
 	if err := network.SetClientSocketOptions(conn, 0); err != nil {

ipblocklist/files/doc.go

+// files defines a set of abstraction for 'files': an openable entities that
+// could be read after.
+//
+// This is not a file on a filesystem of your local machine, it also can
+// include "in memory" files or even remote ones, like HTTP endpoints. If you
+// make a GET request to HTTP endpoint, then a body is readable and you can
+// consider it as an openable file.
+package files

ipblocklist/files/http.go

 	response, err := h.http.Do(request)
 	if err != nil {
 		if response != nil {
-			io.Copy(io.Discard, response.Body) // nolint: errcheck
+			io.Copy(io.Discard, response.Body) //nolint: errcheck
 			response.Body.Close()
 		}
 

ipblocklist/files/http_test.go

 }
 
 func (suite *HTTPTestSuite) makeFile(path string) (files.File, error) {
-	return files.NewHTTP(suite.httpClient, suite.httpServer.URL+"/"+path) // nolint: wrapcheck
+	return files.NewHTTP(suite.httpClient, suite.httpServer.URL+"/"+path) //nolint: wrapcheck
 }
 
 func (suite *HTTPTestSuite) SetupSuite() {

ipblocklist/files/local.go

 }
 
 func (l localFile) Open(ctx context.Context) (io.ReadCloser, error) {
-	return os.Open(l.path) // nolint: wrapcheck
+	return os.Open(l.path) //nolint: wrapcheck
 }
 
 func (l localFile) String() string {

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)   //nolint: gomnd
+	fireholIPv6DefaultCIDR = net.CIDRMask(128, 128) //nolint: gomnd
 )
 
 // FireholUpdateCallback defines a signature of the callback that has to be

ipblocklist/firehol_test.go

 
 		defer filefp.Close()
 
-		io.Copy(w, filefp) // nolint: errcheck
+		io.Copy(w, filefp) //nolint: errcheck
 	})
 
 	suite.httpServer = httptest.NewServer(mux)

logger/zerolog_test.go

 	suite.NotContains("lalala", log12Output)
 }
 
-func TestZeroLogger(t *testing.T) { // nolint: paralleltest
+func TestZeroLogger(t *testing.T) { //nolint: paralleltest
 	suite.Run(t, &ZeroLoggerTestSuite{})
 }

mtglib/conns.go

 		c.stream.Send(c.ctx, NewEventTraffic(c.streamID, uint(n), true))
 	}
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (c connTraffic) Write(b []byte) (int, error) {
 		c.stream.Send(c.ctx, NewEventTraffic(c.streamID, uint(n), false))
 	}
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 type connRewind struct {
 	c.mutex.RLock()
 	defer c.mutex.RUnlock()
 
-	return c.active.Read(p) // nolint: wrapcheck
+	return c.active.Read(p) //nolint: wrapcheck
 }
 
 func (c *connRewind) Rewind() {

mtglib/conns_internal_test.go

 func (c *ConnRewindBaseConn) Read(p []byte) (int, error) {
 	c.Called(p)
 
-	return c.readBuffer.Read(p) // nolint: wrapcheck
+	return c.readBuffer.Read(p) //nolint: wrapcheck
 }
 
 type ConnTrafficTestSuite struct {
 	suite.Equal(10, n)
 }
 
-func (suite *ConnTrafficTestSuite) TestReadErr() { // nolint: dupl
+func (suite *ConnTrafficTestSuite) TestReadErr() { //nolint: dupl
 	suite.eventStreamMock.
 		On("Send", mock.Anything, mock.Anything).
 		Once().
 	suite.Equal(10, n)
 }
 
-func (suite *ConnTrafficTestSuite) TestWriteErr() { // nolint: dupl
+func (suite *ConnTrafficTestSuite) TestWriteErr() { //nolint: dupl
 	suite.eventStreamMock.
 		On("Send", mock.Anything, mock.Anything).
 		Once().

mtglib/init.go

 // This knowledge is encapsulated into instances of such interface.
 //
 // mtglib uses Network for:
-//     1. Dialing to Telegram
-//     2. Dialing to front domain
-//     3. Doing HTTP requests (for example, for FireHOL ipblocklist).
+//  1. Dialing to Telegram
+//  2. Dialing to front domain
+//  3. Doing HTTP requests (for example, for FireHOL ipblocklist).
 type Network interface {
 	// Dial establishes context-free TCP connections.
 	Dial(network, address string) (essentials.Conn, error)

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) //nolint: gomnd
 	}
 
 	copy(hello.Random[:], handshake[ClientHelloRandomOffset:])
 	// mac is calculated for the whole record, not only
 	// for the payload part
 	mac := hmac.New(sha256.New, secret)
-	rec.Dump(mac) // nolint: errcheck
+	rec.Dump(mac) //nolint: errcheck
 
 	computedRandom := mac.Sum(nil)
 
 }
 
 func parseCipherSuite(hello *ClientHello, handshake []byte) {
-	cipherSuiteOffset := ClientHelloSessionIDOffset + len(hello.SessionID) + 3 // nolint: gomnd
+	cipherSuiteOffset := ClientHelloSessionIDOffset + len(hello.SessionID) + 3 //nolint: gomnd
 	hello.CipherSuite = binary.BigEndian.Uint16(handshake[cipherSuiteOffset : cipherSuiteOffset+2])
 }
 

mtglib/internal/faketls/conn.go

 
 	for {
 		if err := rec.Read(c.Conn); err != nil {
-			return 0, err // nolint: wrapcheck
+			return 0, err //nolint: wrapcheck
 		}
 
-		switch rec.Type { // nolint: exhaustive
+		switch rec.Type { //nolint: exhaustive
 		case record.TypeApplicationData:
-			rec.Payload.WriteTo(&c.readBuffer) // nolint: errcheck
+			rec.Payload.WriteTo(&c.readBuffer) //nolint: errcheck
 
-			return c.readBuffer.Read(p) // nolint: wrapcheck
+			return c.readBuffer.Read(p) //nolint: wrapcheck
 		case record.TypeChangeCipherSpec:
 		default:
 			return 0, fmt.Errorf("unsupported record type %v", rec.Type)
 
 		rec.Payload.Reset()
 		rec.Payload.Write(p[:chunkSize])
-		rec.Dump(sendBuffer) // nolint: errcheck
+		rec.Dump(sendBuffer) //nolint: errcheck
 
 		p = p[chunkSize:]
 	}
 
 	if _, err := c.Conn.Write(sendBuffer.Bytes()); err != nil {
-		return 0, err // nolint: wrapcheck
+		return 0, err //nolint: wrapcheck
 	}
 
 	return lenP, nil

mtglib/internal/faketls/conn_test.go

 func (m *ConnMock) Read(p []byte) (int, error) {
 	m.Called(p)
 
-	return m.readBuffer.Read(p) // nolint: wrapcheck
+	return m.readBuffer.Read(p) //nolint: wrapcheck
 }
 
 func (m *ConnMock) Write(p []byte) (int, error) {
 	m.Called(p)
 
-	return m.writeBuffer.Write(p) // nolint: wrapcheck
+	return m.writeBuffer.Write(p) //nolint: wrapcheck
 }
 
 type ConnTestSuite struct {
 	rec.Version = record.Version12
 
 	rec.Payload.WriteByte(0x01)
-	rec.Dump(&suite.connMock.readBuffer) // nolint: errcheck
+	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
 	rec.Reset()
 
 	rec.Type = record.TypeApplicationData
 	rec.Version = record.Version12
 
 	rec.Payload.Write([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
-	rec.Dump(&suite.connMock.readBuffer) // nolint: errcheck
+	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
 
 	resultBuffer := &bytes.Buffer{}
 	buf := make([]byte, 2)
 	rec.Version = record.Version12
 
 	rec.Payload.WriteByte(0x01)
-	rec.Dump(&suite.connMock.readBuffer) // nolint: errcheck
+	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
 	rec.Reset()
 
 	rec.Type = record.TypeHandshake
 	rec.Version = record.Version12
 
 	rec.Payload.Write([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
-	rec.Dump(&suite.connMock.readBuffer) // nolint: errcheck
+	rec.Dump(&suite.connMock.readBuffer) //nolint: errcheck
 
 	buf := make([]byte, 2)
 
 
 		suite.Equal(record.TypeApplicationData, rec.Type)
 		suite.Equal(record.Version12, rec.Version)
-		rec.Payload.WriteTo(buf) // nolint: errcheck
+		rec.Payload.WriteTo(buf) //nolint: errcheck
 	}
 
 	suite.Equal(dataToRec, buf.Bytes())

mtglib/internal/faketls/pools.go

 }
 
 func acquireBytesBuffer() *bytes.Buffer {
-	return bytesBufferPool.Get().(*bytes.Buffer) // nolint: forcetypeassert
+	return bytesBufferPool.Get().(*bytes.Buffer) //nolint: forcetypeassert
 }
 
 func releaseBytesBuffer(b *bytes.Buffer) {

mtglib/internal/faketls/record/pools.go

 }
 
 func AcquireRecord() *Record {
-	return recordPool.Get().(*Record) // nolint: forcetypeassert
+	return recordPool.Get().(*Record) //nolint: forcetypeassert
 }
 
 func ReleaseRecord(r *Record) {

mtglib/internal/faketls/welcome.go

 	rec.Version = record.Version12
 
 	generateServerHello(&rec.Payload, clientHello)
-	rec.Dump(buf) // nolint: errcheck
+	rec.Dump(buf) //nolint: errcheck
 	rec.Reset()
 
 	rec.Type = record.TypeChangeCipherSpec
 	rec.Version = record.Version12
 	rec.Payload.WriteByte(ChangeCipherValue)
 
-	rec.Dump(buf) // nolint: errcheck
+	rec.Dump(buf) //nolint: errcheck
 	rec.Reset()
 
 	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 { //nolint: gomnd
 		panic(err)
 	}
 
-	rec.Dump(buf) // nolint: errcheck
+	rec.Dump(buf) //nolint: errcheck
 
 	packet := buf.Bytes()
 	mac := hmac.New(sha256.New, secret)
 	copy(packet[WelcomePacketRandomOffset:], mac.Sum(nil))
 
 	if _, err := writer.Write(packet); err != nil {
-		return err // nolint: wrapcheck
+		return err //nolint: wrapcheck
 	}
 
 	return nil
 	binary.BigEndian.PutUint32(header[:], uint32(bodyBuf.Len()))
 	header[0] = HandshakeTypeServer
 
-	writer.Write(header[:]) // nolint: errcheck
-	bodyBuf.WriteTo(writer) // nolint: errcheck
+	writer.Write(header[:]) //nolint: errcheck
+	bodyBuf.WriteTo(writer) //nolint: errcheck
 }

mtglib/internal/obfuscated2/client_handshake_test.go

 
 func (suite *ClientHandshakeTestSuite) TestCannotRead() {
 	buf := bytes.NewBuffer([]byte{1, 2, 3})
-	_, _, _, err := obfuscated2.ClientHandshake([]byte{1, 2, 3}, buf) // nolint: dogsled
+	_, _, _, err := obfuscated2.ClientHandshake([]byte{1, 2, 3}, buf) //nolint: dogsled
 
 	suite.Error(err)
 }

mtglib/internal/obfuscated2/conn.go

 func (c Conn) Read(p []byte) (int, error) {
 	n, err := c.Conn.Read(p)
 	if err != nil {
-		return n, err // nolint: wrapcheck
+		return n, err //nolint: wrapcheck
 	}
 
 	c.Decryptor.XORKeyStream(p, p[:n])
 	payload := buf.Bytes()
 	c.Encryptor.XORKeyStream(payload, payload)
 
-	return c.Conn.Write(payload) // nolint: wrapcheck
+	return c.Conn.Write(payload) //nolint: wrapcheck
 }

mtglib/internal/obfuscated2/handshake_frame.go

 
 // A structure of obfuscated2 handshake frame is following:
 //
-//    [frameOffsetFirst:frameOffsetKey:frameOffsetIV:frameOffsetMagic:frameOffsetDC:frameOffsetEnd].
+//	[frameOffsetFirst:frameOffsetKey:frameOffsetIV:frameOffsetMagic:frameOffsetDC:frameOffsetEnd].
 //
-//    - 8 bytes of noise
-//    - 32 bytes of AES Key
-//    - 16 bytes of AES IV
-//    - 4 bytes of 'connection type' - this has some setting like a connection type
-//    - 2 bytes of 'DC'. DC is little endian int16
-//    - 2 bytes of noise
+//	- 8 bytes of noise
+//	- 32 bytes of AES Key
+//	- 16 bytes of AES IV
+//	- 4 bytes of 'connection type' - this has some setting like a connection type
+//	- 2 bytes of 'DC'. DC is little endian int16
+//	- 2 bytes of noise
 type handshakeFrame struct {
 	data [handshakeFrameLen]byte
 }
 
 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: gomnd, lll // little endian for int16 is here
 
 	switch {
 	case idx > 0:

mtglib/internal/obfuscated2/handshake_frame_internal_test.go

 		suite.T().Run(strconv.Itoa(int(incoming)), func(t *testing.T) {
 			frame := handshakeFrame{}
 
-			rand.Read(frame.data[:]) // nolint: errcheck
+			rand.Read(frame.data[:]) //nolint: errcheck
 
 			frame.data[handshakeFrameOffsetDC] = byte(incoming)
 			frame.data[handshakeFrameOffsetDC+1] = byte(incoming >> 8)

mtglib/internal/obfuscated2/pools.go

 )
 
 func acquireSha256Hasher() hash.Hash {
-	return sha256HasherPool.Get().(hash.Hash) // nolint: forcetypeassert
+	return sha256HasherPool.Get().(hash.Hash) //nolint: forcetypeassert
 }
 
 func releaseSha256Hasher(h hash.Hash) {
 }
 
 func acquireBytesBuffer() *bytes.Buffer {
-	return bytesBufferPool.Get().(*bytes.Buffer) // nolint: forcetypeassert
+	return bytesBufferPool.Get().(*bytes.Buffer) //nolint: forcetypeassert
 }
 
 func releaseBytesBuffer(buf *bytes.Buffer) {

mtglib/internal/obfuscated2/server_handshake.go

 			panic(err)
 		}
 
-		if frame.data[0] == 0xef { // nolint: gomnd // taken from tg sources
+		if frame.data[0] == 0xef { //nolint: gomnd // 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: //nolint: gomnd // taken from tg sources
 			continue
 		}
 

mtglib/internal/obfuscated2/server_handshake_fuzz_test.go

 			Once().
 			Run(func(args mock.Arguments) {
 				message := make([]byte, len(data))
-				handshakeData.decryptor.XORKeyStream(message, args.Get(0).([]byte)) // nolint: forcetypeassert
+				handshakeData.decryptor.XORKeyStream(message, args.Get(0).([]byte)) //nolint: forcetypeassert
 				assert.Equal(t, message, data)
 			})
 
 			Run(func(args mock.Arguments) {
 				message := make([]byte, len(data))
 				handshakeData.encryptor.XORKeyStream(message, data)
-				copy(args.Get(0).([]byte), message) // nolint: forcetypeassert
+				copy(args.Get(0).([]byte), message) //nolint: forcetypeassert
 			})
 
 		n, err := handshakeData.proxyConn.Read(buffer)

mtglib/internal/obfuscated2/server_handshake_test.go

 		Once().
 		Run(func(args mock.Arguments) {
 			message := make([]byte, len(messageToTelegram))
-			suite.data.decryptor.XORKeyStream(message, args.Get(0).([]byte)) // nolint: forcetypeassert
+			suite.data.decryptor.XORKeyStream(message, args.Get(0).([]byte)) //nolint: forcetypeassert
 			suite.Equal(messageToTelegram, message)
 		})
 
 		Run(func(args mock.Arguments) {
 			message := make([]byte, len(messageFromTelegram))
 			suite.data.encryptor.XORKeyStream(message, messageFromTelegram)
-			copy(args.Get(0).([]byte), message) // nolint: forcetypeassert
+			copy(args.Get(0).([]byte), message) //nolint: forcetypeassert
 		})
 
 	n, err := suite.data.proxyConn.Read(buffer)

mtglib/internal/relay/pools.go

 }
 
 func acquireCopyBuffer() *[]byte {
-	return copyBufferPool.Get().(*[]byte) // nolint: forcetypeassert
+	return copyBufferPool.Get().(*[]byte) //nolint: forcetypeassert
 }
 
 func releaseCopyBuffer(buf *[]byte) {

mtglib/internal/relay/relay.go

 }
 
 func pump(log Logger, src, dst essentials.Conn, direction string) {
-	defer src.CloseRead()  // nolint: errcheck
-	defer dst.CloseWrite() // nolint: errcheck
+	defer src.CloseRead()  //nolint: errcheck
+	defer dst.CloseWrite() //nolint: errcheck
 
 	copyBuffer := acquireCopyBuffer()
 	defer releaseCopyBuffer(copyBuffer)

mtglib/proxy.go

 			}
 		}
 
-		ipAddr := conn.RemoteAddr().(*net.TCPAddr).IP // nolint: forcetypeassert
+		ipAddr := conn.RemoteAddr().(*net.TCPAddr).IP //nolint: forcetypeassert
 		logger := p.logger.BindStr("ip", ipAddr.String())
 
 		if !p.allowlist.Contains(ipAddr) {
 
 	p.eventStream.Send(ctx,
 		NewEventConnectedToDC(ctx.streamID,
-			conn.RemoteAddr().(*net.TCPAddr).IP, // nolint: forcetypeassert
+			conn.RemoteAddr().(*net.TCPAddr).IP, //nolint: forcetypeassert
 			ctx.dc),
 	)
 
 
 	pool, err := ants.NewPoolWithFunc(opts.getConcurrency(),
 		func(arg interface{}) {
-			proxy.ServeConn(arg.(essentials.Conn)) // nolint: forcetypeassert
+			proxy.ServeConn(arg.(essentials.Conn)) //nolint: forcetypeassert
 		},
 		ants.WithLogger(opts.getLogger("ants")),
 		ants.WithNonblocking(true))

mtglib/proxy_test.go

 
 	suite.listener = listener
 
-	go suite.p.Serve(suite.listener) // nolint: errcheck
+	go suite.p.Serve(suite.listener) //nolint: errcheck
 }
 
 func (suite *ProxyTestSuite) TearDownSuite() {
 
 	addr := fmt.Sprintf("https://%s/headers", suite.ProxyAddress())
 
-	resp, err := client.Get(addr) // nolint: noctx
+	resp, err := client.Get(addr) //nolint: noctx
 	suite.NoError(err)
 
 	defer resp.Body.Close()
 
 	jsonStruct := struct {
 		Headers struct {
-			TraceID string `json:"X-Amzn-Trace-Id"` // nolint: tagliatelle
+			TraceID string `json:"X-Amzn-Trace-Id"` //nolint: tagliatelle
 		} `json:"headers"`
 	}{}
 
 		_, err := tg.NewClient(tgClient).HelpGetConfig(ctx)
 		suite.NoError(err)
 
-		return err // nolint: wrapcheck
+		return err //nolint: wrapcheck
 	}))
 }
 

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 { //nolint: gomnd // we need at least 1 byte here
 		return fmt.Errorf("secret is truncated, length=%d", len(decoded))
 	}
 

mtglib/stream_context.go

 }
 
 func (s *streamContext) Err() error {
-	return s.ctx.Err() // nolint: wrapcheck
+	return s.ctx.Err() //nolint: wrapcheck
 }
 
 func (s *streamContext) Value(key interface{}) interface{} {
 }
 
 func (s *streamContext) ClientIP() net.IP {
-	return s.clientConn.RemoteAddr().(*net.TCPAddr).IP // nolint: forcetypeassert
+	return s.clientConn.RemoteAddr().(*net.TCPAddr).IP //nolint: forcetypeassert
 }
 
 func newStreamContext(ctx context.Context, logger Logger, clientConn essentials.Conn) *streamContext {

mtglib/stream_context_internal_test.go

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

network/circuit_breaker.go

 			conn.Close()
 		}
 
-		return nil, ctx.Err() // nolint: wrapcheck
+		return nil, ctx.Err() //nolint: wrapcheck
 	case c.stateMutexChan <- true:
 		defer func() {
 			<-c.stateMutexChan
 		c.switchState(circuitBreakerStateOpened)
 	}
 
-	return conn, err // nolint: wrapcheck
+	return conn, err //nolint: wrapcheck
 }
 
 func (c *circuitBreakerDialer) doHalfOpened(ctx context.Context,
 			conn.Close()
 		}
 
-		return nil, ctx.Err() // nolint: wrapcheck
+		return nil, ctx.Err() //nolint: wrapcheck
 	case c.stateMutexChan <- true:
 		defer func() {
 			<-c.stateMutexChan
 	}
 
 	if c.state != circuitBreakerStateHalfOpened {
-		return conn, err // nolint: wrapcheck
+		return conn, err //nolint: wrapcheck
 	}
 
 	if err == nil {
 		c.switchState(circuitBreakerStateOpened)
 	}
 
-	return conn, err // nolint: wrapcheck
+	return conn, err //nolint: wrapcheck
 }
 
 func (c *circuitBreakerDialer) switchState(state uint32) {

network/circuit_breaker_internal_test.go

 		Port: 80,
 	})
 
-	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") // nolint: errcheck
-	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") // nolint: errcheck
-	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") // nolint: errcheck
-	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") // nolint: errcheck
+	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") //nolint: errcheck
+	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") //nolint: errcheck
+	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") //nolint: errcheck
+	suite.d.DialContext(suite.ctx, "tcp", "127.0.0.1") //nolint: errcheck
 
 	time.Sleep(500 * time.Millisecond)
 

network/default.go

 
 func (d *defaultDialer) DialContext(ctx context.Context, network, address string) (essentials.Conn, error) {
 	switch network {
-	case "tcp", "tcp4", "tcp6": // nolint: goconst
+	case "tcp", "tcp4", "tcp6": //nolint: goconst
 	default:
 		return nil, fmt.Errorf("unsupported network %s", network)
 	}
 		return nil, fmt.Errorf("cannot set socket options: %w", err)
 	}
 
-	return conn.(essentials.Conn), nil // nolint: forcetypeassert
+	return conn.(essentials.Conn), nil //nolint: forcetypeassert
 }
 
 // NewDefaultDialer build a new dialer which dials bypassing proxies

network/default_test.go

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

network/dns_resolver.go

 	return ips
 }
 
-func newDNSResolver(hostname string, httpClient *http.Client) (ret *dnsResolver) {
+func newDNSResolver(hostname string, httpClient *http.Client) *dnsResolver {
 	if net.ParseIP(hostname).To4() == nil {
 		// the hostname is an IPv6 address
 		hostname = fmt.Sprintf("[%s]", hostname)
 	}
 
-	ret = &dnsResolver{
+	return &dnsResolver{
 		resolver: doh.Resolver{
 			Host:       hostname,
 			Class:      doh.IN,
 		},
 		cache: map[string]dnsResolverCacheEntry{},
 	}
-
-	return
 }

network/init_internal_test.go

 func (d *DialerMock) Dial(network, address string) (essentials.Conn, error) {
 	args := d.Called(network, address)
 
-	return args.Get(0).(essentials.Conn), args.Error(1) // nolint: wrapcheck, forcetypeassert
+	return args.Get(0).(essentials.Conn), args.Error(1) //nolint: wrapcheck, forcetypeassert
 }
 
 func (d *DialerMock) DialContext(ctx context.Context, network, address string) (essentials.Conn, error) {
 	args := d.Called(ctx, network, address)
 
-	return args.Get(0).(essentials.Conn), args.Error(1) // nolint: wrapcheck, forcetypeassert
+	return args.Get(0).(essentials.Conn), args.Error(1) //nolint: wrapcheck, forcetypeassert
 }

network/init_test.go

 func (d *DialerMock) Dial(network, address string) (essentials.Conn, error) {
 	args := d.Called(network, address)
 
-	return args.Get(0).(essentials.Conn), args.Error(1) // nolint: wrapcheck, forcetypeassert
+	return args.Get(0).(essentials.Conn), args.Error(1) //nolint: wrapcheck, forcetypeassert
 }
 
 func (d *DialerMock) DialContext(ctx context.Context, network, address string) (essentials.Conn, error) {
 	args := d.Called(ctx, network, address)
 
-	return args.Get(0).(essentials.Conn), args.Error(1) // nolint: wrapcheck, forcetypeassert
+	return args.Get(0).(essentials.Conn), args.Error(1) //nolint: wrapcheck, forcetypeassert
 }
 
 type HTTPServerTestSuite struct {
 	return &http.Client{
 		Transport: &http.Transport{
 			DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
-				return dialer.DialContext(ctx, network, address) // nolint: wrapcheck
+				return dialer.DialContext(ctx, network, address) //nolint: wrapcheck
 			},
 		},
 	}
 		},
 	})
 
-	go suite.socks5Server.Serve(suite.socks5Listener) // nolint: errcheck
+	go suite.socks5Server.Serve(suite.socks5Listener) //nolint: errcheck
 }
 
 func (suite *Socks5ServerTestSuite) TearDownSuite() {

network/load_balanced_socks5_test.go

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

network/network.go

 func (n networkHTTPTransport) RoundTrip(req *http.Request) (*http.Response, error) {
 	req.Header.Set("User-Agent", n.userAgent)
 
-	return n.next.RoundTrip(req) // nolint: wrapcheck
+	return n.next.RoundTrip(req) //nolint: wrapcheck
 }
 
 type network struct {

network/network_test.go

 
 	client := ntw.MakeHTTPClient(nil)
 
-	resp, err := client.Get(suite.httpServer.URL + "/headers") // nolint: noctx
+	resp, err := client.Get(suite.httpServer.URL + "/headers") //nolint: noctx
 	suite.NoError(err)
 
 	defer resp.Body.Close()
 
 	jsonStruct := struct {
 		Headers struct {
-			UserAgent []string `json:"User-Agent"` // nolint: tagliatelle
+			UserAgent []string `json:"User-Agent"` //nolint: tagliatelle
 		} `json:"headers"`
 	}{}
 
 
 	client := ntw.MakeHTTPClient(nil)
 
-	resp, err := client.Get("https://httpbin.org/headers") // nolint: noctx
+	resp, err := client.Get("https://httpbin.org/headers") //nolint: noctx
 	suite.NoError(err)
 
 	defer resp.Body.Close()
 
 	jsonStruct := struct {
 		Headers struct {
-			UserAgent string `json:"User-Agent"` // nolint: tagliatelle
+			UserAgent string `json:"User-Agent"` //nolint: tagliatelle
 		} `json:"headers"`
 	}{}
 

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 { //nolint: gomnd
 			openThreshold = uint32(intNum)
 		}
 	}

network/proxy_dialer_internal_test.go

 }
 
 func (suite *ProxyDialerTestSuite) TestSetupDefaults() {
-	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
+	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) //nolint: forcetypeassert
 	suite.EqualValues(ProxyDialerOpenThreshold, d.openThreshold)
 	suite.EqualValues(ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 	suite.EqualValues(ProxyDialerResetFailuresTimeout, d.resetFailuresTimeout)
 	query.Set("half_open_timeout", "2s")
 	suite.u.RawQuery = query.Encode()
 
-	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
+	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) //nolint: forcetypeassert
 	suite.EqualValues(30, d.openThreshold)
 	suite.EqualValues(2*time.Second, d.halfOpenTimeout)
 	suite.EqualValues(time.Second, d.resetFailuresTimeout)
 			query.Set("open_threshold", param)
 			suite.u.RawQuery = query.Encode()
 
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) //nolint: forcetypeassert
 			assert.EqualValues(t, ProxyDialerOpenThreshold, d.openThreshold)
 		})
 	}
 			query.Set("half_open_timeout", param)
 			suite.u.RawQuery = query.Encode()
 
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) //nolint: forcetypeassert
 			assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 		})
 	}
 			query.Set("reset_failures_timeout", param)
 			suite.u.RawQuery = query.Encode()
 
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) // nolint: forcetypeassert
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer) //nolint: forcetypeassert
 			assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 		})
 	}

network/sockopts.go

 //
 // bufferSize setting is deprecated and ignored.
 func SetClientSocketOptions(conn net.Conn, bufferSize int) error {
-	return setCommonSocketOptions(conn.(*net.TCPConn)) // nolint: forcetypeassert
+	return setCommonSocketOptions(conn.(*net.TCPConn)) //nolint: forcetypeassert
 }
 
 // SetServerSocketOptions tunes a TCP socket that represents a connection to
 // remote server like Telegram or fronting domain (but not end user).
 func SetServerSocketOptions(conn net.Conn, bufferSize int) error {
-	return setCommonSocketOptions(conn.(*net.TCPConn)) // nolint: forcetypeassert
+	return setCommonSocketOptions(conn.(*net.TCPConn)) //nolint: forcetypeassert
 }
 
 func setCommonSocketOptions(conn *net.TCPConn) error {

network/sockopts_unix.go

 func setSocketReuseAddrPort(conn syscall.RawConn) error {
 	var err error
 
-	conn.Control(func(fd uintptr) { // nolint: errcheck
-		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
+	conn.Control(func(fd uintptr) { //nolint: errcheck
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1) //nolint: nosnakecase
 		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)
+		err = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1) //nolint: nosnakecase
 		if err != nil {
 			err = fmt.Errorf("cannot set SO_REUSEPORT: %w", err)
 		}

network/socks5.go

 // NewSocks5Dialer build a new dialer from a given one (so, in theory you can
 // chain here). Proxy parameters are passed with URI in a form of:
 //
-//     socks5://[user:[password]]@host:port
+//	socks5://[user:[password]]@host:port
 func NewSocks5Dialer(baseDialer Dialer, proxyURL *url.URL) (Dialer, error) {
 	if _, _, err := net.SplitHostPort(proxyURL.Host); err != nil {
 		return nil, fmt.Errorf("incorrect url %s", proxyURL.Redacted())

network/socks5_test.go

 	dialer, _ := network.NewSocks5Dialer(suite.d, proxyURL)
 	httpClient := suite.MakeHTTPClient(dialer)
 
-	resp, err := httpClient.Get(suite.MakeURL("/get")) // nolint: noctx
+	resp, err := httpClient.Get(suite.MakeURL("/get")) //nolint: noctx
 	if err == nil {
 		defer resp.Body.Close()
 	}
 	dialer, _ := network.NewSocks5Dialer(suite.d, proxyURL)
 	httpClient := suite.MakeHTTPClient(dialer)
 
-	resp, err := httpClient.Get(suite.MakeURL("/get")) // nolint: noctx
+	resp, err := httpClient.Get(suite.MakeURL("/get")) //nolint: noctx
 	if err == nil {
 		defer resp.Body.Close()
 	}

stats/pools.go

 }
 
 func acquireStreamInfo() *streamInfo {
-	return streamInfoPool.Get().(*streamInfo) // nolint: forcetypeassert
+	return streamInfoPool.Get().(*streamInfo) //nolint: forcetypeassert
 }
 
 func releaseStreamInfo(info *streamInfo) {

stats/prometheus.go

 
 // Serve starts an HTTP server on a given listener.
 func (p *PrometheusFactory) Serve(listener net.Listener) error {
-	return p.httpServer.Serve(listener) // nolint: wrapcheck
+	return p.httpServer.Serve(listener) //nolint: wrapcheck
 }
 
 // Close stops a factory. Please pay attention that underlying listener
 // is not closed.
 func (p *PrometheusFactory) Close() error {
-	return p.httpServer.Shutdown(context.Background()) // nolint: wrapcheck
+	return p.httpServer.Shutdown(context.Background()) //nolint: wrapcheck
 }
 
 // NewPrometheus builds an events.ObserverFactory which can serve HTTP
 // endpoint with Prometheus scrape data.
-func NewPrometheus(metricPrefix, httpPath string) *PrometheusFactory { // nolint: funlen
+func NewPrometheus(metricPrefix, httpPath string) *PrometheusFactory { //nolint: funlen
 	registry := prometheus.NewPedanticRegistry()
 	httpHandler := promhttp.HandlerFor(registry, promhttp.HandlerOpts{
 		EnableOpenMetrics: true,

stats/prometheus_test.go

 func (suite *PrometheusTestSuite) Get() (string, error) {
 	addr := fmt.Sprintf("http://%s/", suite.httpListener.Addr().String())
 
-	resp, err := http.Get(addr) // nolint: noctx
+	resp, err := http.Get(addr) //nolint: noctx
 	if err != nil {
-		return "", err // nolint: wrapcheck
+		return "", err //nolint: wrapcheck
 	}
 
 	defer resp.Body.Close()
 
 	data, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return "", err // nolint: wrapcheck
+		return "", err //nolint: wrapcheck
 	}
 
 	return string(data), nil
 	suite.factory = stats.NewPrometheus("mtg", "/")
 	suite.prometheus = suite.factory.Make()
 
-	go suite.factory.Serve(suite.httpListener) // nolint: errcheck
+	go suite.factory.Serve(suite.httpListener) //nolint: errcheck
 }
 
 func (suite *PrometheusTestSuite) TearDownTest() {

stats/statsd.go

 
 // Close stops sending requests to statsd.
 func (s StatsdFactory) Close() error {
-	return s.client.Close() // nolint: wrapcheck
+	return s.client.Close() //nolint: wrapcheck
 }
 
 // Make build a new observer.

stats/statsd_test.go

 
 func (s *statsdFakeServer) Close() error {
 	if s.conn != nil {
-		return s.conn.Close() // nolint: wrapcheck
+		return s.conn.Close() //nolint: wrapcheck
 	}
 
 	return nil