Update to go 1.19

.github/workflows/ci.yaml

     strategy:
       matrix:
         go_version:
-          - ^1.18
+          - ^1.19
     steps:
       - name: Checkout
         uses: actions/checkout@v2
       - name: Run linter
         uses: golangci/golangci-lint-action@v2
         with:
-          version: v1.45.0
+          version: v1.48.0
 
   docker:
     name: Docker

.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",
+]

Dockerfile

 ###############################################################################
 # BUILD STAGE
 
-FROM golang:1.18-alpine AS build
+FROM golang:1.19-alpine AS build
 
 RUN set -x \
   && apk --no-cache --update add \

Makefile

 IMAGE_NAME   := mtg
 APP_NAME     := $(IMAGE_NAME)
 
-GOLANGCI_LINT_VERSION := v1.45.0
+GOLANGCI_LINT_VERSION := v1.48.0
 
 VERSION_GO         := $(shell go version)
 VERSION_DATE       := $(shell date -Ru)

cli/proxy.go

 	"go.uber.org/zap/zapcore"
 )
 
-func Proxy() error { // nolint: funlen,cyclop
+func Proxy() error { //nolint: funlen,cyclop
 	ctx := utils.GetSignalContext()
 
 	atom := zap.NewAtomicLevel()
 	))
 
 	zap.ReplaceGlobals(logger)
-	defer logger.Sync() // nolint: errcheck
+	defer logger.Sync() //nolint: errcheck
 
 	if err := config.InitPublicAddress(ctx); err != nil {
 		Fatal(err)

cli/utils.go

 
 func Fatal(arg interface{}) {
 	if value, ok := arg.(error); ok {
-		arg = fmt.Errorf("fatal error: %+v", value) // nolint: errorlint
+		arg = fmt.Errorf("fatal error: %+v", value) //nolint: errorlint
 	}
 
 	PrintStderr(arg)
 }
 
 func PrintStdout(args ...interface{}) {
-	fmt.Println(args...) // nolint: forbidigo
+	fmt.Println(args...) //nolint: forbidigo
 }
 
 func PrintJSONStderr(data interface{}) {

config/config.go

 
 type Config struct {
 	Bind             *net.TCPAddr      `json:"bind"`
-	PublicIPv4       *net.TCPAddr      `json:"public_ipv4"`        // nolint: tagliatelle
-	PublicIPv6       *net.TCPAddr      `json:"public_ipv6"`        // nolint: tagliatelle
-	StatsBind        *net.TCPAddr      `json:"stats_bind"`         // nolint: tagliatelle
-	StatsdAddr       *net.TCPAddr      `json:"stats_addr"`         // nolint: tagliatelle
-	StatsdTagsFormat *statsd.TagFormat `json:"statsd_tags_format"` // nolint: tagliatelle
+	PublicIPv4       *net.TCPAddr      `json:"public_ipv4"`        //nolint: tagliatelle
+	PublicIPv6       *net.TCPAddr      `json:"public_ipv6"`        //nolint: tagliatelle
+	StatsBind        *net.TCPAddr      `json:"stats_bind"`         //nolint: tagliatelle
+	StatsdAddr       *net.TCPAddr      `json:"stats_addr"`         //nolint: tagliatelle
+	StatsdTagsFormat *statsd.TagFormat `json:"statsd_tags_format"` //nolint: tagliatelle
 
-	StatsNamespace string            `json:"stats_namespace"` // nolint: tagliatelle
-	CloakHost      string            `json:"cloak_host"`      // nolint: tagliatelle
-	StatsdTags     map[string]string `json:"statsd_tags"`     // nolint: tagliatelle
+	StatsNamespace string            `json:"stats_namespace"` //nolint: tagliatelle
+	CloakHost      string            `json:"cloak_host"`      //nolint: tagliatelle
+	StatsdTags     map[string]string `json:"statsd_tags"`     //nolint: tagliatelle
 
-	WriteBuffer int `json:"write_buffer"` // nolint: tagliatelle
-	ReadBuffer  int `json:"read_buffer"`  // nolint: tagliatelle
-	CloakPort   int `json:"cloak_port"`   // nolint: tagliatelle
+	WriteBuffer int `json:"write_buffer"` //nolint: tagliatelle
+	ReadBuffer  int `json:"read_buffer"`  //nolint: tagliatelle
+	CloakPort   int `json:"cloak_port"`   //nolint: tagliatelle
 
-	AntiReplayMaxSize int `json:"anti_replay_max_size"` // nolint: tagliatelle
+	AntiReplayMaxSize int `json:"anti_replay_max_size"` //nolint: tagliatelle
 
-	MultiplexPerConnection int `json:"multiplex_per_connection"` // nolint: tagliatelle
+	MultiplexPerConnection int `json:"multiplex_per_connection"` //nolint: tagliatelle
 
 	Debug      bool       `json:"debug"`
 	Verbose    bool       `json:"verbose"`
-	SecretMode SecretMode `json:"secret_mode"` // nolint: tagliatelle
-	PreferIP   PreferIP   `json:"prefer_ip"`   // nolint: tagliatelle
-	NTPServers []string   `json:"ntp_servers"` // nolint: tagliatelle
+	SecretMode SecretMode `json:"secret_mode"` //nolint: tagliatelle
+	PreferIP   PreferIP   `json:"prefer_ip"`   //nolint: tagliatelle
+	NTPServers []string   `json:"ntp_servers"` //nolint: tagliatelle
 
 	Secret []byte `json:"secret"`
 	AdTag  []byte `json:"adtag"`
 
 	fvalue := float64(value)
 
-	newValue := fvalue * 2 * math.Log(float64(c.MultiplexPerConnection)) // nolint: gomnd
+	newValue := fvalue * 2 * math.Log(float64(c.MultiplexPerConnection)) //nolint: gomnd
 	newValue = math.Ceil(newValue)
 	newValue = math.Max(fvalue, newValue)
 
 
 var C = Config{}
 
-func Init(options ...Opt) error { // nolint: gocyclo, funlen, cyclop
+func Init(options ...Opt) error { //nolint: gocyclo, funlen, cyclop
 	for _, opt := range options {
 		switch opt.Option {
 		case OptionTypeDebug:
-			C.Debug = opt.Value.(bool) // nolint: forcetypeassert
+			C.Debug = opt.Value.(bool) //nolint: forcetypeassert
 		case OptionTypeVerbose:
-			C.Verbose = opt.Value.(bool) // nolint: forcetypeassert
+			C.Verbose = opt.Value.(bool) //nolint: forcetypeassert
 		case OptionTypePreferIP:
-			value := opt.Value.(string) // nolint: forcetypeassert
+			value := opt.Value.(string) //nolint: forcetypeassert
 			switch value {
 			case "ipv4":
 				C.PreferIP = PreferIPv4
 				return fmt.Errorf("incorrect direct IP mode %s", value)
 			}
 		case OptionTypeBind:
-			C.Bind = opt.Value.(*net.TCPAddr) // nolint: forcetypeassert
+			C.Bind = opt.Value.(*net.TCPAddr) //nolint: forcetypeassert
 		case OptionTypePublicIPv4:
-			C.PublicIPv4 = opt.Value.(*net.TCPAddr) // nolint: forcetypeassert
+			C.PublicIPv4 = opt.Value.(*net.TCPAddr) //nolint: forcetypeassert
 			if C.PublicIPv4 == nil {
 				C.PublicIPv4 = &net.TCPAddr{}
 			}
 		case OptionTypePublicIPv6:
-			C.PublicIPv6 = opt.Value.(*net.TCPAddr) // nolint: forcetypeassert
+			C.PublicIPv6 = opt.Value.(*net.TCPAddr) //nolint: forcetypeassert
 			if C.PublicIPv6 == nil {
 				C.PublicIPv6 = &net.TCPAddr{}
 			}
 		case OptionTypeStatsBind:
-			C.StatsBind = opt.Value.(*net.TCPAddr) // nolint: forcetypeassert
+			C.StatsBind = opt.Value.(*net.TCPAddr) //nolint: forcetypeassert
 		case OptionTypeStatsNamespace:
-			C.StatsNamespace = opt.Value.(string) // nolint: forcetypeassert
+			C.StatsNamespace = opt.Value.(string) //nolint: forcetypeassert
 		case OptionTypeStatsdAddress:
-			C.StatsdAddr = opt.Value.(*net.TCPAddr) // nolint: forcetypeassert
+			C.StatsdAddr = opt.Value.(*net.TCPAddr) //nolint: forcetypeassert
 		case OptionTypeStatsdTagsFormat:
-			value := opt.Value.(string) // nolint: forcetypeassert
+			value := opt.Value.(string) //nolint: forcetypeassert
 			switch value {
 			case "datadog":
 				C.StatsdTagsFormat = statsd.TagFormatDatadog
 				return fmt.Errorf("incorrect statsd tag %s", value)
 			}
 		case OptionTypeStatsdTags:
-			C.StatsdTags = opt.Value.(map[string]string) // nolint: forcetypeassert
+			C.StatsdTags = opt.Value.(map[string]string) //nolint: forcetypeassert
 		case OptionTypeWriteBufferSize:
-			C.WriteBuffer = int(opt.Value.(units.Base2Bytes)) // nolint: forcetypeassert
+			C.WriteBuffer = int(opt.Value.(units.Base2Bytes)) //nolint: forcetypeassert
 		case OptionTypeReadBufferSize:
-			C.ReadBuffer = int(opt.Value.(units.Base2Bytes)) // nolint: forcetypeassert
+			C.ReadBuffer = int(opt.Value.(units.Base2Bytes)) //nolint: forcetypeassert
 		case OptionTypeCloakPort:
-			C.CloakPort = int(opt.Value.(uint16)) // nolint: forcetypeassert
+			C.CloakPort = int(opt.Value.(uint16)) //nolint: forcetypeassert
 		case OptionTypeAntiReplayMaxSize:
-			C.AntiReplayMaxSize = int(opt.Value.(units.Base2Bytes)) // nolint: forcetypeassert
+			C.AntiReplayMaxSize = int(opt.Value.(units.Base2Bytes)) //nolint: forcetypeassert
 		case OptionTypeMultiplexPerConnection:
-			C.MultiplexPerConnection = int(opt.Value.(uint)) // nolint: forcetypeassert
+			C.MultiplexPerConnection = int(opt.Value.(uint)) //nolint: forcetypeassert
 		case OptionTypeNTPServers:
-			C.NTPServers = opt.Value.([]string) // nolint: forcetypeassert
+			C.NTPServers = opt.Value.([]string) //nolint: forcetypeassert
 			if len(C.NTPServers) == 0 {
 				return errors.New("ntp server list is empty")
 			}
 		case OptionTypeSecret:
-			C.Secret = opt.Value.([]byte) // nolint: forcetypeassert
+			C.Secret = opt.Value.([]byte) //nolint: forcetypeassert
 		case OptionTypeAdtag:
-			C.AdTag = opt.Value.([]byte) // nolint: forcetypeassert
+			C.AdTag = opt.Value.([]byte) //nolint: forcetypeassert
 		default:
 			return fmt.Errorf("unknown tag %v", opt.Option)
 		}

config/global_ips.go

 	"context"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net"
 	"net/http"
 	"strings"
 		Timeout: ifconfigTimeout,
 		Transport: &http.Transport{
 			DialContext: func(ctx context.Context, _, addr string) (net.Conn, error) {
-				return dialer.DialContext(ctx, network, addr) // nolint: wrapcheck
+				return dialer.DialContext(ctx, network, addr) //nolint: wrapcheck
 			},
 		},
 	}
 
-	req, err := http.NewRequest("GET", ifconfigAddress, nil)
+	req, err := http.NewRequest(http.MethodGet, ifconfigAddress, nil)
 	if err != nil {
 		return nil, fmt.Errorf("cannot create a request: %w", err)
 	}
 	resp, err := client.Do(req.WithContext(ctx))
 	if err != nil {
 		if resp != nil {
-			io.Copy(ioutil.Discard, resp.Body) // nolint: errcheck
+			io.Copy(io.Discard, resp.Body) //nolint: errcheck
 		}
 
 		return nil, fmt.Errorf("cannot perform a request: %w", err)
 
 	defer resp.Body.Close()
 
-	respDataBytes, err := ioutil.ReadAll(resp.Body)
+	respDataBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("cannot read response body: %w", err)
 	}

config/urls.go

 )
 
 type URLs struct {
-	TG        string `json:"tg_url"`     // nolint: tagliatelle
-	TMe       string `json:"tme_url"`    // nolint: tagliatelle
-	TGQRCode  string `json:"tg_qrcode"`  // nolint: tagliatelle
-	TMeQRCode string `json:"tme_qrcode"` // nolint: tagliatelle
+	TG        string `json:"tg_url"`     //nolint: tagliatelle
+	TMe       string `json:"tme_url"`    //nolint: tagliatelle
+	TGQRCode  string `json:"tg_qrcode"`  //nolint: tagliatelle
+	TMeQRCode string `json:"tme_qrcode"` //nolint: tagliatelle
 }
 
 type IPURLs struct {
 	IPv4      *URLs  `json:"ipv4,omitempty"`
 	IPv6      *URLs  `json:"ipv6,omitempty"`
-	BotSecret string `json:"secret_for_mtproxybot"` // nolint: tagliatelle
+	BotSecret string `json:"secret_for_mtproxybot"` //nolint: tagliatelle
 }
 
-func GetURLs() (urls IPURLs) {
+func GetURLs() IPURLs {
 	secret := ""
+	urls := IPURLs{}
 
 	switch C.SecretMode {
 	case SecretModeSimple:

faketls/client_protocol.go

 
 	conn, err := c.ClientProtocol.Handshake(conn)
 	if err != nil {
-		return nil, err // nolint: wrapcheck
+		return nil, err //nolint: wrapcheck
 	}
 
-	return conn, err // nolint: wrapcheck
+	return conn, err //nolint: wrapcheck
 }
 
 func (c *ClientProtocol) tlsHandshake(conn io.ReadWriter) error {

faketls/cloak.go

 	another = rwc.NewPing(ctx, another, channelPing)
 	wg := &sync.WaitGroup{}
 
-	wg.Add(2) // nolint: gomnd
+	wg.Add(2) //nolint: gomnd
 
 	go cloakPipe(one, another, wg)
 
 func cloakPipe(one io.Writer, another io.Reader, wg *sync.WaitGroup) {
 	defer wg.Done()
 
-	io.Copy(one, another) // nolint: errcheck
+	io.Copy(one, another) //nolint: errcheck
 }

go.mod

 	go.uber.org/multierr v1.8.0 // indirect
 	go.uber.org/zap v1.21.0
 	golang.org/x/crypto v0.0.0-20220315160706-3147a52a75dd
-	golang.org/x/net v0.0.0-20220225172249-27dd8689420f // indirect
-	golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8
+	golang.org/x/net v0.0.0-20220809012201-f428fae20770 // indirect
+	golang.org/x/sys v0.0.0-20220808155132-1c4a2a72c664
 	google.golang.org/protobuf v1.27.1 // indirect
 	gopkg.in/alecthomas/kingpin.v2 v2.2.6
 )
 	github.com/golang/protobuf v1.5.2 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
 	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/yuin/goldmark v1.4.13 // indirect
 	go.uber.org/atomic v1.9.0 // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
+	golang.org/x/tools v0.1.12 // indirect
 )

go.sum

 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13 h1:fVcFKWvrslecOb/tg+Cc05dkeYx540o0FuFt3nUVDoE=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
 go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220225172249-27dd8689420f h1:oA4XRj0qtSt8Yo1Zms0CUlsT3KG69V2UGQWPBxujDmc=
 golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
+golang.org/x/net v0.0.0-20220809012201-f428fae20770 h1:dIi4qVdvjZEjiMDv7vhokAZNGnz3kepwuXqFKYDdDMs=
+golang.org/x/net v0.0.0-20220809012201-f428fae20770/go.mod h1:YDH+HFinaLZZlnHAfSS6ZXJJ9M9t4Dl22yv3iI2vPwk=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sys v0.0.0-20220204135822-1c1b9b1eba6a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8 h1:OH54vjqzRWmbJ62fjuhxy7AxFFgoHN0/DPc/UrL8cAs=
 golang.org/x/sys v0.0.0-20220319134239-a9b59b0215f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220808155132-1c4a2a72c664 h1:v1W7bwXHsnLLloWYTVEdvGvA7BHMeBYsPcF0GLDxIRs=
+golang.org/x/sys v0.0.0-20220808155132-1c4a2a72c664/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12 h1:VveCTK38A2rkS8ZqFY25HIDFscX5X9OoEhJd3quQmXU=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

hub/connection.go

 	channelConnDetach chan conntypes.ConnID
 }
 
-func (c *connection) run() { // nolint: cyclop
+func (c *connection) run() { //nolint: cyclop
 	defer c.Close()
 
 	ttl := time.NewTimer(connectionTTL)
 		return nil, fmt.Errorf("cannot create a new connection: %w", err)
 	}
 
-	id := rand.Int() // nolint: gosec
+	id := rand.Int() //nolint: gosec
 	rv := &connection{
 		conn: conn,
 		id:   id,

hub/hub.go

 }
 
 func (h *hub) getMux(req *protocol.TelegramRequest) *mux {
-	key := 32767 + int32(req.ClientProtocol.DC()) + 100000*int32(req.ClientProtocol.ConnectionProtocol()) // nolint: gomnd
+	key := 32767 + int32(req.ClientProtocol.DC()) + 100000*int32(req.ClientProtocol.ConnectionProtocol()) //nolint: gomnd
 
 	h.mutex.RLock()
 	m, ok := h.muxes[key]

main.go

 
 	"github.com/9seconds/mtg/cli"
 	"github.com/9seconds/mtg/config"
-	"github.com/9seconds/mtg/utils"
 	kingpin "gopkg.in/alecthomas/kingpin.v2"
 )
 
 	app.Version(getVersion())
 	app.HelpFlag.Short('h')
 
-	if err := utils.SetLimits(); err != nil {
-		cli.Fatal(err)
-	}
-
 	switch kingpin.MustParse(app.Parse(os.Args[1:])) {
 	case generateSecretCommand.FullCommand():
 		cli.Generate(*generateSecretType, *generateCloakHost)

mtproto/protocol.go

 	}
 
 	if err := conn.Write(rpcNonceReq.Bytes()); err != nil {
-		return nil, err // nolint: wrapcheck
+		return nil, err //nolint: wrapcheck
 	}
 
 	return rpcNonceReq, nil

mtproto/rpc/handshake_response.go

 // NewHandshakeResponse constructs new handshake response from the given
 // data.
 func NewHandshakeResponse(data []byte) (*HandshakeResponse, error) {
-	if len(data) != 32 { // nolint: gomnd
+	if len(data) != 32 { //nolint: gomnd
 		return nil, fmt.Errorf("incorrect handshake response length %d", len(data))
 	}
 

mtproto/rpc/nonce_request.go

 
 // NewNonceRequest builds new none request based on proxy secret.
 func NewNonceRequest(proxySecret []byte) (*NonceRequest, error) {
-	nonce := make([]byte, 16)      // nolint: gomnd
-	keySelector := make([]byte, 4) // nolint: gomnd
-	cryptoTS := make([]byte, 4)    // nolint: gomnd
+	nonce := make([]byte, 16)      //nolint: gomnd
+	keySelector := make([]byte, 4) //nolint: gomnd
+	cryptoTS := make([]byte, 4)    //nolint: gomnd
 
 	if _, err := rand.Read(nonce); err != nil {
 		return nil, fmt.Errorf("cannot generate nonce: %w", err)
 
 	copy(keySelector, proxySecret)
 	// 256 ^ 4 - do not know how to name
-	timestamp := time.Now().Truncate(time.Second).Unix() % 4294967296 // nolint: gomnd
+	timestamp := time.Now().Truncate(time.Second).Unix() % 4294967296 //nolint: gomnd
 	binary.LittleEndian.PutUint32(cryptoTS, uint32(timestamp))
 
 	return &NonceRequest{

mtproto/rpc/nonce_response.go

 
 // NewNonceResponse build new nonce response based on the given data.
 func NewNonceResponse(data []byte) (*NonceResponse, error) {
-	if len(data) != 32 { // nolint: gomnd
+	if len(data) != 32 { //nolint: gomnd
 		return nil, fmt.Errorf("unexpected message length %d", len(data))
 	}
 

mtproto/rpc/proxy_flags.go

 var ProxyRequestFlagsEncryptedPrefix [8]byte
 
 func (r ProxyRequestFlags) Bytes() []byte {
-	converted := make([]byte, 4) // nolint: gomnd
+	converted := make([]byte, 4) //nolint: gomnd
 	binary.LittleEndian.PutUint32(converted, uint32(r))
 
 	return converted
 }
 
 func (r ProxyRequestFlags) String() string {
-	flags := make([]string, 0, 7) // nolint: gomnd
+	flags := make([]string, 0, 7) //nolint: gomnd
 
 	if r&ProxyRequestFlagsHasAdTag != 0 {
 		flags = append(flags, "HAS_AD_TAG")

mtproto/rpc/proxy_response.go

 func ParseProxyResponse(packet conntypes.Packet) (*ProxyResponse, error) {
 	var response ProxyResponse
 
-	if len(packet) < 4 { // nolint: gomnd
+	if len(packet) < 4 { //nolint: gomnd
 		return nil, fmt.Errorf("incorrect packet length: %d", len(packet))
 	}
 

ntp/ntp.go

 
 // Fetch fetches the data on time drift.
 func Fetch() (time.Duration, error) {
-	url := config.C.NTPServers[rand.Intn(len(config.C.NTPServers))] // nolint: gosec
+	url := config.C.NTPServers[rand.Intn(len(config.C.NTPServers))] //nolint: gosec
 
 	resp, err := ntp.Query(url)
 	if err != nil {

obfuscated2/client_protocol.go

 	return stream.NewObfuscated2(socket, encryptor, decryptor), nil
 }
 
-func (c *ClientProtocol) ReadFrame(socket conntypes.StreamReader) (fm Frame, err error) {
-	if _, err = io.ReadFull(handshakeReader{socket}, fm.Bytes()); err != nil {
-		err = fmt.Errorf("cannot extract obfuscated2 frame: %w", err)
+func (c *ClientProtocol) ReadFrame(socket conntypes.StreamReader) (Frame, error) {
+	fm := Frame{}
+
+	if _, err := io.ReadFull(handshakeReader{socket}, fm.Bytes()); err != nil {
+		return fm, fmt.Errorf("cannot extract obfuscated2 frame: %w", err)
 	}
 
-	return
+	return fm, nil
 }
 
 type handshakeReader struct {
 }
 
 func (h handshakeReader) Read(p []byte) (int, error) {
-	return h.parent.ReadTimeout(p, clientProtocolHandshakeTimeout) // nolint: wrapcheck
+	return h.parent.ReadTimeout(p, clientProtocolHandshakeTimeout) //nolint: wrapcheck
 }
 
 func MakeClientProtocol() protocol.ClientProtocol {

obfuscated2/frame.go

 	return f.data[frameOffsetFirst:frameOffsetDC]
 }
 
-func (f *Frame) Invert() (nf Frame) {
-	nf = *f
+func (f *Frame) Invert() Frame {
+	nf := *f
 	for i := 0; i < frameLenKey+frameLenIV; i++ {
 		nf.data[frameOffsetFirst+i] = f.data[frameOffsetIV-1-i]
 	}
 
-	return
+	return nf
 }

obfuscated2/telegram_protocol.go

 	return stream.NewObfuscated2(conn, encryptor, decryptor), nil
 }
 
-func generateFrame(cp protocol.ClientProtocol) (fm Frame) {
+func generateFrame(cp protocol.ClientProtocol) Frame {
+	fm := Frame{}
 	data := fm.Bytes()
 
 	for {
 			continue
 		}
 
-		if data[0] == 0xef { // nolint: gomnd
+		if data[0] == 0xef { //nolint: gomnd
 			continue
 		}
 
-		val := (uint32(data[3]) << 24) | (uint32(data[2]) << 16) | (uint32(data[1]) << 8) | uint32(data[0])        // nolint: gomnd, lll
-		if val == 0x44414548 || val == 0x54534f50 || val == 0x20544547 || val == 0x4954504f || val == 0xeeeeeeee { // nolint: lll
+		val := (uint32(data[3]) << 24) | (uint32(data[2]) << 16) | (uint32(data[1]) << 8) | uint32(data[0])        //nolint: gomnd, lll
+		if val == 0x44414548 || val == 0x54534f50 || val == 0x20544547 || val == 0x4954504f || val == 0xeeeeeeee { //nolint: lll
 			continue
 		}
 
-		val = (uint32(data[7]) << 24) | (uint32(data[6]) << 16) | (uint32(data[5]) << 8) | uint32(data[4]) // nolint: gomnd
-		if val == 0x00000000 {                                                                             // nolint: gomnd
+		val = (uint32(data[7]) << 24) | (uint32(data[6]) << 16) | (uint32(data[5]) << 8) | uint32(data[4]) //nolint: gomnd
+		if val == 0x00000000 {                                                                             //nolint: gomnd
 			continue
 		}
 
 		copy(fm.Magic(), cp.ConnectionType().Tag())
 
-		return
+		return fm
 	}
 }

proxy/direct.go

 func directConnection(request *protocol.TelegramRequest) error {
 	telegramConnRaw, err := obfuscated2.TelegramProtocol(request)
 	if err != nil {
-		return err // nolint: wrapcheck
+		return err //nolint: wrapcheck
 	}
 
 	defer telegramConnRaw.Close()
 
 	wg := &sync.WaitGroup{}
-	wg.Add(2) // nolint: gomnd
+	wg.Add(2) //nolint: gomnd
 
 	go directPipe(telegramConnRaw, request.ClientConn, wg, request.Logger)
 

proxy/middle.go

 	}
 
 	wg := &sync.WaitGroup{}
-	wg.Add(2) // nolint: gomnd
+	wg.Add(2) //nolint: gomnd
 
 	go middlePipe(telegramConn, clientConn, wg, request.Logger)
 

stats/stats.go

 		Handler: mux,
 	}
 
-	go srv.Serve(listener) // nolint: errcheck
+	go srv.Serve(listener) //nolint: errcheck
 
 	go func() {
 		<-ctx.Done()
-		srv.Shutdown(context.Background()) // nolint: errcheck, contextcheck
+		srv.Shutdown(context.Background()) //nolint: errcheck
 	}()
 
 	Stats = multiStats(stats)

stats/stats_statsd.go

 }
 
 func (s *statsStatsd) changeConnections(connectionType conntypes.ConnectionType, addr *net.TCPAddr, increment int64) {
-	tags := make([]*statsStatsdTag, 0, 2) // nolint: gomnd
+	tags := make([]*statsStatsdTag, 0, 2) //nolint: gomnd
 
 	switch connectionType {
 	case conntypes.ConnectionTypeAbridged:
 		s.seenMutex.RUnlock()
 
 		return
-	} else { // nolint: golint,revive
+	} else { //nolint: golint,revive
 		s.seenMutex.RUnlock()
 	}
 
 	return &statsStatsd{
 		seen: make(map[string]struct{}),
 		client: statsd.NewClient(config.C.StatsdAddr.String(),
-			statsd.SendLoopCount(2),                  // nolint: gomnd
-			statsd.ReconnectInterval(10*time.Second), // nolint: gomnd
+			statsd.SendLoopCount(2),                  //nolint: gomnd
+			statsd.ReconnectInterval(10*time.Second), //nolint: gomnd
 			statsd.Logger(logger),
 			statsd.MetricPrefix(prefix),
 			statsd.TagStyle(config.C.StatsdTagsFormat),

telegram/api/addresses.go

 )
 
 const (
-	addressesURLV4 = "https://core.telegram.org/getProxyConfig"   // nolint: gas
-	addressesURLV6 = "https://core.telegram.org/getProxyConfigV6" // nolint: gas
+	addressesURLV4 = "https://core.telegram.org/getProxyConfig"   //nolint: gas
+	addressesURLV6 = "https://core.telegram.org/getProxyConfigV6" //nolint: gas
 )
 
 var addressesProxyForSplitter = regexp.MustCompile(`\s+`)
 }
 
 func addressesParseProxyFor(text string) (string, conntypes.DC, error) {
-	chunks := addressesProxyForSplitter.Split(text, 3) // nolint: gomnd
+	chunks := addressesProxyForSplitter.Split(text, 3) //nolint: gomnd
 	if len(chunks) != 3 || chunks[0] != "proxy_for" {
 		return "", 0, fmt.Errorf("incorrect config %s", text)
 	}
 
-	dc, err := strconv.ParseInt(chunks[1], 10, 16) // nolint: gomnd
+	dc, err := strconv.ParseInt(chunks[1], 10, 16) //nolint: gomnd
 	if err != nil {
 		return "", 0, fmt.Errorf("incorrect config '%s': %w", text, err)
 	}
 }
 
 func addressesParseDefault(text string) (conntypes.DC, error) {
-	chunks := addressesProxyForSplitter.Split(text, 2) // nolint: gomnd
+	chunks := addressesProxyForSplitter.Split(text, 2) //nolint: gomnd
 	if len(chunks) != 2 || chunks[0] != "default" {
 		return 0, fmt.Errorf("incorrect config '%s'", text)
 	}
 
 	dcString := strings.TrimRight(chunks[1], ";")
 
-	dc, err := strconv.ParseInt(dcString, 10, 16) // nolint: gomnd
+	dc, err := strconv.ParseInt(dcString, 10, 16) //nolint: gomnd
 	if err != nil {
 		return 0, fmt.Errorf("incorrect config '%s': %w", text, err)
 	}

telegram/api/api.go

 	"context"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"time"
 )
 	ctx, cancel := context.WithTimeout(context.Background(), apiHTTPTimeout)
 	defer cancel()
 
-	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 	if err != nil {
 		panic(err)
 	}
 	resp, err := httpClient.Do(req)
 	if err != nil {
 		if resp != nil {
-			io.Copy(ioutil.Discard, resp.Body) // nolint: errcheck
+			io.Copy(io.Discard, resp.Body) //nolint: errcheck
 			resp.Body.Close()
 		}
 
 		return nil, fmt.Errorf("cannot perform a request: %w", err)
 	}
 
-	return resp.Body, err // nolint: wrapcheck
+	return resp.Body, err //nolint: wrapcheck
 }

telegram/api/secret.go

 
 import (
 	"fmt"
-	"io/ioutil"
+	"io"
 )
 
-const secretURL = "https://core.telegram.org/getProxySecret" // nolint: gas
+const secretURL = "https://core.telegram.org/getProxySecret" //nolint: gas
 
 func Secret() ([]byte, error) {
 	resp, err := request(secretURL)
 
 	defer resp.Close()
 
-	secret, err := ioutil.ReadAll(resp)
+	secret, err := io.ReadAll(resp)
 	if err != nil {
 		return nil, fmt.Errorf("cannot read response: %w", err)
 	}

telegram/base.go

 }
 
 func (b *baseTelegram) getAddresses(dc conntypes.DC, protocol conntypes.ConnectionProtocol) []string {
-	addresses := make([]string, 0, 2) // nolint: gomnd
+	addresses := make([]string, 0, 2) //nolint: gomnd
 	protos := []conntypes.ConnectionProtocol{
 		conntypes.ConnectionProtocolIPv6,
 		conntypes.ConnectionProtocolIPv4,
 	case len(addrs) == 1:
 		return addrs[0]
 	case len(addrs) > 1:
-		return addrs[rand.Intn(len(addrs))] // nolint: gosec
+		return addrs[rand.Intn(len(addrs))] //nolint: gosec
 	}
 
 	return ""

tlstypes/consts.go

 type CipherSuiteType uint8
 
 const (
-	CipherSuiteType_TLS_AES_128_GCM_SHA256       CipherSuiteType = iota // nolint: stylecheck,golint,revive
-	CipherSuiteType_TLS_AES_256_GCM_SHA384                              // nolint: stylecheck,golint,revive
-	CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256                        // nolint: stylecheck,golint,revive
+	CipherSuiteType_TLS_AES_128_GCM_SHA256       CipherSuiteType = iota //nolint: stylecheck,golint,revive,nosnakecase
+	CipherSuiteType_TLS_AES_256_GCM_SHA384                              //nolint: stylecheck,golint,revive,nosnakecase
+	CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256                        //nolint: stylecheck,golint,revive,nosnakecase
 )
 
 func (c CipherSuiteType) Bytes() []byte {
 	switch c {
-	case CipherSuiteType_TLS_AES_128_GCM_SHA256:
-		return CipherSuiteType_TLS_AES_128_GCM_SHA256_Bytes
-	case CipherSuiteType_TLS_AES_256_GCM_SHA384:
-		return CipherSuiteType_TLS_AES_256_GCM_SHA384_Bytes
-	case CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256:
-		return CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256_Bytes
+	case CipherSuiteType_TLS_AES_128_GCM_SHA256: //nolint: nosnakecase
+		return CipherSuiteType_TLS_AES_128_GCM_SHA256_Bytes //nolint: nosnakecase
+	case CipherSuiteType_TLS_AES_256_GCM_SHA384: //nolint: nosnakecase
+		return CipherSuiteType_TLS_AES_256_GCM_SHA384_Bytes //nolint: nosnakecase
+	case CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256: //nolint: nosnakecase
+		return CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256_Bytes //nolint: nosnakecase
 	}
 
-	return CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256_Bytes
+	return CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256_Bytes //nolint: nosnakecase
 }
 
 type Version uint8
 	Version12Bytes = []byte{0x03, 0x03}
 	Version13Bytes = []byte{0x03, 0x04}
 
-	CipherSuiteType_TLS_AES_128_GCM_SHA256_Bytes       = []byte{0x13, 0x01} // nolint: stylecheck,golint,revive
-	CipherSuiteType_TLS_AES_256_GCM_SHA384_Bytes       = []byte{0x13, 0x02} // nolint: stylecheck,golint,revive
-	CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256_Bytes = []byte{0x13, 0x03} // nolint: stylecheck,golint,revive
+	CipherSuiteType_TLS_AES_128_GCM_SHA256_Bytes       = []byte{0x13, 0x01} //nolint: stylecheck,golint,revive,nosnakecase
+	CipherSuiteType_TLS_AES_256_GCM_SHA384_Bytes       = []byte{0x13, 0x02} //nolint: stylecheck,golint,revive,nosnakecase
+	CipherSuiteType_TLS_CHACHA20_POLY1305_SHA256_Bytes = []byte{0x13, 0x03} //nolint: stylecheck,golint,revive,nosnakecase
 )
 
 type Byter interface {
 type RawBytes []byte
 
 func (r RawBytes) WriteBytes(writer io.Writer) {
-	writer.Write(r) // nolint: errcheck
+	writer.Write(r) //nolint: errcheck
 }
 
 func (r RawBytes) Len() int {

tlstypes/handshake.go

 func (h *Handshake) WriteBytes(writer io.Writer) {
 	packetBuf := bytes.Buffer{}
 
-	writer.Write([]byte{byte(h.Type)}) // nolint: errcheck
+	writer.Write([]byte{byte(h.Type)}) //nolint: errcheck
 
 	packetBuf.Write(h.Version.Bytes())
 	packetBuf.Write(h.Random[:])
 	sizeUint24Bytes := sizeUint24[:]
 	sizeUint24Bytes[0], sizeUint24Bytes[2] = sizeUint24Bytes[2], sizeUint24Bytes[0]
 
-	writer.Write(sizeUint24Bytes) // nolint: errcheck
-	packetBuf.WriteTo(writer)     // nolint: errcheck
+	writer.Write(sizeUint24Bytes) //nolint: errcheck
+	packetBuf.WriteTo(writer)     //nolint: errcheck
 }
 
 func (h *Handshake) Len() int {

tlstypes/record.go

 }
 
 func (r Record) WriteBytes(writer io.Writer) {
-	writer.Write([]byte{byte(r.Type)})                           // nolint: errcheck
-	writer.Write(r.Version.Bytes())                              // nolint: errcheck
-	binary.Write(writer, binary.BigEndian, uint16(r.Data.Len())) // nolint: errcheck
+	writer.Write([]byte{byte(r.Type)})                           //nolint: errcheck
+	writer.Write(r.Version.Bytes())                              //nolint: errcheck
+	binary.Write(writer, binary.BigEndian, uint16(r.Data.Len())) //nolint: errcheck
 	r.Data.WriteBytes(writer)
 }
 
 	return rec, nil
 }
 
-func MakeRecords(raw []byte) (arr []Record) {
+func MakeRecords(raw []byte) []Record {
+	var arr []Record
+
 	for len(raw) > 0 {
 		chunkSize := recordMaxChunkSize
 		if chunkSize > len(raw) {
 		raw = raw[chunkSize:]
 	}
 
-	return
+	return arr
 }

tlstypes/server_hello.go

 	}
 	recChangeCipher.WriteBytes(buf)
 
-	hostCert := make([]byte, 1024+mrand.Intn(3092)) // nolint: gosec, gomnd
-	rand.Read(hostCert)                             // nolint: errcheck
+	hostCert := make([]byte, 1024+mrand.Intn(3092)) //nolint: gosec, gomnd
+	rand.Read(hostCert)                             //nolint: errcheck
 
 	recData := Record{
 		Type:    RecordTypeApplicationData,
 	rv.SessionID = make([]byte, len(clientHello.SessionID))
 	copy(rv.SessionID, clientHello.SessionID)
 
-	tail := bytes.NewBuffer(CipherSuiteType_TLS_AES_128_GCM_SHA256_Bytes)
-	tail.WriteByte(0x00) // nolint: gomnd // no compression
+	tail := bytes.NewBuffer(CipherSuiteType_TLS_AES_128_GCM_SHA256_Bytes) //nolint: nosnakecase
+	tail.WriteByte(0x00)                                                  //nolint: gomnd // no compression
 	makeTLSExtensions(tail)
 	rv.Tail = RawBytes(tail.Bytes())
 
 }
 
 func makeTLSExtensions(buf io.Writer) {
-	buf.Write([]byte{ // nolint: errcheck
+	buf.Write([]byte{ //nolint: errcheck
 		0x00, 0x2e, // 46 bytes of data
 		0x00, 0x33, // Extension - Key Share
 		0x00, 0x24, // 36 bytes
 
 	var scalar [32]byte
 
-	rand.Read(scalar[:]) // nolint: errcheck
+	rand.Read(scalar[:]) //nolint: errcheck
 	curve, _ := curve25519.X25519(scalar[:], curve25519.Basepoint)
-	buf.Write(curve) // nolint: errcheck
+	buf.Write(curve) //nolint: errcheck
 
-	buf.Write([]byte{ // nolint: errcheck
+	buf.Write([]byte{ //nolint: errcheck
 		0x00, 0x2b, // Extension - Supported Versions
 		0x00, 0x02, // 2 bytes are following
 		0x03, 0x04, // TLS 1.3

utils/init_tcp.go

 )
 
 func InitTCP(conn net.Conn, readBufferSize, writeBufferSize int) error {
-	tcpConn := conn.(*net.TCPConn) // nolint: forcetypeassert
+	tcpConn := conn.(*net.TCPConn) //nolint: forcetypeassert
 
 	if err := tcpConn.SetNoDelay(true); err != nil {
 		return fmt.Errorf("cannot set TCP_NO_DELAY: %w", err)

utils/read_full.go

 
 const readFullBufferSize = 1024 + 1 // +1 because telegram opreates with blocks mod 4
 
-func ReadFull(src io.Reader) (rv []byte, err error) {
+func ReadFull(src io.Reader) ([]byte, error) {
 	buf := make([]byte, readFullBufferSize)
 	n := readFullBufferSize
+	rv := []byte{}
 
 	for n == len(buf) {
-		n, err = src.Read(buf)
+		n, err := src.Read(buf)
 		if err != nil {
-			return nil, err // nolint: wrapcheck
+			return nil, err //nolint: wrapcheck
 		}
 
 		rv = append(rv, buf[:n]...)

utils/reverse_bytes.go

 	rv := make([]byte, dataLen)
 	rv[dataLen/2] = data[dataLen/2]
 
-	for i := dataLen/2 - 1; i >= 0; i-- { // nolint: gomnd
+	for i := dataLen/2 - 1; i >= 0; i-- { //nolint: gomnd
 		opp := dataLen - i - 1
 		rv[i], rv[opp] = data[opp], data[i]
 	}

utils/rlimit.go

-//go:build !windows
-// +build !windows
-
-package utils
-
-import (
-	"fmt"
-
-	"golang.org/x/sys/unix"
-)
-
-func SetLimits() error {
-	rLimit := unix.Rlimit{}
-	if err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rLimit); err != nil {
-		return fmt.Errorf("cannot get rlimit: %w", err)
-	}
-
-	rLimit.Cur = rLimit.Max
-
-	if err := unix.Setrlimit(unix.RLIMIT_NOFILE, &rLimit); err != nil {
-		return fmt.Errorf("cannot set rlimit: %w", err)
-	}
-
-	return nil
-}

utils/uint24.go

 type Uint24 [3]byte
 
 func ToUint24(number uint32) Uint24 {
-	return Uint24{byte(number), byte(number >> 8), byte(number >> 16)} // nolint: gomnd
+	return Uint24{byte(number), byte(number >> 8), byte(number >> 16)} //nolint: gomnd
 }
 
 func FromUint24(number Uint24) uint32 {
-	return uint32(number[0]) + (uint32(number[1]) << 8) + (uint32(number[2]) << 16) // nolint: gomnd
+	return uint32(number[0]) + (uint32(number[1]) << 8) + (uint32(number[2]) << 16) //nolint: gomnd
 }

wrappers/packet/mtproto_frame.go

 	"fmt"
 	"hash/crc32"
 	"io"
-	"io/ioutil"
 	"net"
 
 	"github.com/9seconds/mtg/conntypes"
 //
 // MSGLEN is the length of the message + len of seqno and msglen.
 // SEQNO is the number of frame in the receive/send sequence. If client
-//   sends a message with SeqNo 18, it has to receive message with SeqNo 18.
+//
+//	sends a message with SeqNo 18, it has to receive message with SeqNo 18.
+//
 // MSG is the data which has to be written
 // CRC32 is the CRC32 checksum of MSGLEN + SEQNO + MSG
 // PADDING is custom padding schema to complete frame length to such that
-//    len(frame) % 16 == 0
+//
+//	len(frame) % 16 == 0
 type wrapperMtprotoFrame struct {
 	parent     conntypes.StreamReadWriteCloser
 	logger     *zap.SugaredLogger
 	writeSeqNo int32
 }
 
-func (w *wrapperMtprotoFrame) Read() (conntypes.Packet, error) { // nolint: funlen, cyclop
+func (w *wrapperMtprotoFrame) Read() (conntypes.Packet, error) { //nolint: funlen, cyclop
 	buf := &bytes.Buffer{}
 
 	sum := crc32.NewIEEE()
 		buf.Reset()
 		sum.Reset()
 
-		if _, err := io.CopyN(writer, w.parent, 4); err != nil { // nolint: gomnd
+		if _, err := io.CopyN(writer, w.parent, 4); err != nil { //nolint: gomnd
 			return nil, fmt.Errorf("cannot read frame padding: %w", err)
 		}
 
 
 	buf.Reset()
 
-	if _, err := io.CopyN(writer, w.parent, int64(messageLength)-4-4); err != nil { // nolint: gomnd
+	if _, err := io.CopyN(writer, w.parent, int64(messageLength)-4-4); err != nil { //nolint: gomnd
 		return nil, fmt.Errorf("cannot read the message frame: %w", err)
 	}
 
 	var seqNo int32
 
-	binary.Read(buf, binary.LittleEndian, &seqNo) // nolint: errcheck
+	binary.Read(buf, binary.LittleEndian, &seqNo) //nolint: errcheck
 
 	if seqNo != w.readSeqNo {
 		return nil, fmt.Errorf("unexpected sequence number %d (wait for %d)", seqNo, w.readSeqNo)
 	}
 
-	data, _ := ioutil.ReadAll(buf)
+	data, _ := io.ReadAll(buf)
 	buf.Reset()
 	// write to buf, not to writer. This is because we are going to fetch
 	// crc32 checksum.
-	if _, err := io.CopyN(buf, w.parent, 4); err != nil { // nolint: gomnd
+	if _, err := io.CopyN(buf, w.parent, 4); err != nil { //nolint: gomnd
 		return nil, fmt.Errorf("cannot read checksum: %w", err)
 	}
 
 }
 
 func (w *wrapperMtprotoFrame) Write(p conntypes.Packet) error {
-	messageLength := 4 + 4 + len(p) + 4 // nolint: gomnd
+	messageLength := 4 + 4 + len(p) + 4 //nolint: gomnd
 	paddingLength := (aes.BlockSize - messageLength%aes.BlockSize) % aes.BlockSize
 
 	buf := &bytes.Buffer{}
 
-	binary.Write(buf, binary.LittleEndian, uint32(messageLength)) // nolint: errcheck
-	binary.Write(buf, binary.LittleEndian, w.writeSeqNo)          // nolint: errcheck
+	binary.Write(buf, binary.LittleEndian, uint32(messageLength)) //nolint: errcheck
+	binary.Write(buf, binary.LittleEndian, w.writeSeqNo)          //nolint: errcheck
 	buf.Write(p)
 
 	checksum := crc32.ChecksumIEEE(buf.Bytes())
-	binary.Write(buf, binary.LittleEndian, checksum)              // nolint: errcheck
-	buf.Write(bytes.Repeat(mtprotoFramePadding, paddingLength/4)) // nolint: gomnd
+	binary.Write(buf, binary.LittleEndian, checksum)              //nolint: errcheck
+	buf.Write(bytes.Repeat(mtprotoFramePadding, paddingLength/4)) //nolint: gomnd
 
 	w.logger.Debugw("Write MTProto frame",
 		"length", len(p),
 
 	_, err := w.parent.Write(buf.Bytes())
 
-	return err // nolint: wrapcheck
+	return err //nolint: wrapcheck
 }
 
 func (w *wrapperMtprotoFrame) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperMtprotoFrame) Conn() net.Conn {

wrappers/packetack/client_abridged.go

 	}
 
 	if msgLength == clientAbridgedSmallPacketLength {
-		buf.Grow(3) // nolint: gomnd
+		buf.Grow(3) //nolint: gomnd
 
-		if _, err := io.CopyN(&buf, w.parent, 3); err != nil { // nolint: gomnd
+		if _, err := io.CopyN(&buf, w.parent, 3); err != nil { //nolint: gomnd
 			return nil, fmt.Errorf("cannot read correct message length: %w", err)
 		}
 
 		return nil
 	}
 
-	packetLength := len(packet) / 4 // nolint: gomnd
+	packetLength := len(packet) / 4 //nolint: gomnd
 
 	switch {
 	case packetLength < clientAbridgedSmallPacketLength:
 }
 
 func (w *wrapperClientAbridged) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperClientAbridged) Conn() net.Conn {

wrappers/packetack/client_intermediate.go

 func (w *wrapperClientIntermediate) Read(acks *conntypes.ConnectionAcks) (conntypes.Packet, error) {
 	buf := bytes.Buffer{}
 
-	buf.Grow(4) // nolint: gomnd
+	buf.Grow(4) //nolint: gomnd
 
-	if _, err := io.CopyN(&buf, w.parent, 4); err != nil { // nolint: gomnd
+	if _, err := io.CopyN(&buf, w.parent, 4); err != nil { //nolint: gomnd
 		return nil, fmt.Errorf("cannot read message length: %w", err)
 	}
 
 }
 
 func (w *wrapperClientIntermediate) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperClientIntermediate) Conn() net.Conn {

wrappers/packetack/client_intermediate_secure.go

 		return nil, err
 	}
 
-	length := len(data) - (len(data) % 4) // nolint: gomnd
+	length := len(data) - (len(data) % 4) //nolint: gomnd
 
 	return data[:length], nil
 }
 	}
 
 	buf := &bytes.Buffer{}
-	paddingLength := rand.Intn(4) // nolint: gosec, gomnd
+	paddingLength := rand.Intn(4) //nolint: gosec, gomnd
 
 	buf.Grow(4 + len(packet) + paddingLength)
 
-	binary.Write(buf, binary.LittleEndian, uint32(len(packet)+paddingLength)) // nolint: errcheck
+	binary.Write(buf, binary.LittleEndian, uint32(len(packet)+paddingLength)) //nolint: errcheck
 	buf.Write(packet)
 	buf.Write(make([]byte, paddingLength))
 

wrappers/packetack/proxy.go

 	buf.Write(rpc.ProxyRequestProxyTag)
 	buf.WriteByte(byte(len(config.C.AdTag)))
 	buf.Write(config.C.AdTag)
-	buf.Write(make([]byte, (4-buf.Len()%4)%4)) // nolint: gomnd
+	buf.Write(make([]byte, (4-buf.Len()%4)%4)) //nolint: gomnd
 	buf.Grow(len(packet))
 	buf.Write(packet)
 
-	return w.proxy.Write(buf.Bytes()) // nolint: wrapcheck
+	return w.proxy.Write(buf.Bytes()) //nolint: wrapcheck
 }
 
 func (w *wrapperProxy) Read(acks *conntypes.ConnectionAcks) (conntypes.Packet, error) {

wrappers/rwc/ping.go

 		}
 	}
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperPing) Write(p []byte) (int, error) {
 		}
 	}
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperPing) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func NewPing(ctx context.Context, parent io.ReadWriteCloser, channelPing chan<- struct{}) io.ReadWriteCloser {

wrappers/stream/blockcipher.go

 		return 0, err
 	}
 
-	return w.parent.Write(encrypted) // nolint: wrapcheck
+	return w.parent.Write(encrypted) //nolint: wrapcheck
 }
 
 func (w *wrapperBlockCipher) WriteTimeout(p []byte, timeout time.Duration) (int, error) {
 		return 0, err
 	}
 
-	return w.parent.WriteTimeout(encrypted, timeout) // nolint: wrapcheck
+	return w.parent.WriteTimeout(encrypted, timeout) //nolint: wrapcheck
 }
 
 func (w *wrapperBlockCipher) encrypt(p []byte) ([]byte, error) {
 }
 
 func (w *wrapperBlockCipher) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperBlockCipher) Conn() net.Conn {

wrappers/stream/buffered_reader.go

 
 func (b *bufferedReader) flush(p []byte) (int, error) {
 	if b.buf.Len() > len(p) {
-		return b.buf.Read(p) // nolint: wrapcheck
+		return b.buf.Read(p) //nolint: wrapcheck
 	}
 
 	sizeToReturn := b.buf.Len()

wrappers/stream/conn.go

 		w.Close()
 	}
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperConn) ReadTimeout(p []byte, timeout time.Duration) (int, error) {
 		w.Close()
 	}
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperConn) Close() error {
 	w.logger.Debugw("Close connection")
 
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperConn) Conn() net.Conn {
 	connID conntypes.ConnID,
 	purpose connPurpose,
 ) conntypes.StreamReadWriteCloser {
-	localAddr := *parent.LocalAddr().(*net.TCPAddr) // nolint: forcetypeassert
+	localAddr := *parent.LocalAddr().(*net.TCPAddr) //nolint: forcetypeassert
 
-	if parent.RemoteAddr().(*net.TCPAddr).IP.To4() != nil { // nolint: forcetypeassert
+	if parent.RemoteAddr().(*net.TCPAddr).IP.To4() != nil { //nolint: forcetypeassert
 		if config.C.PublicIPv4.IP != nil {
 			localAddr.IP = config.C.PublicIPv4.IP
 		}
 		parent:     parent,
 		connID:     connID,
 		logger:     logger,
-		remoteAddr: parent.RemoteAddr().(*net.TCPAddr), // nolint: forcetypeassert
+		remoteAddr: parent.RemoteAddr().(*net.TCPAddr), //nolint: forcetypeassert
 		localAddr:  &localAddr,
 	}
 }

wrappers/stream/ctx.go

 
 		return 0, fmt.Errorf("cannot write because context was closed: %w", w.ctx.Err())
 	default:
-		return w.parent.WriteTimeout(p, timeout) // nolint: wrapcheck
+		return w.parent.WriteTimeout(p, timeout) //nolint: wrapcheck
 	}
 }
 
 
 		return 0, fmt.Errorf("cannot write because context was closed: %w", w.ctx.Err())
 	default:
-		return w.parent.Write(p) // nolint: wrapcheck
+		return w.parent.Write(p) //nolint: wrapcheck
 	}
 }
 
 
 		return 0, fmt.Errorf("cannot write because context was closed: %w", w.ctx.Err())
 	default:
-		return w.parent.ReadTimeout(p, timeout) // nolint: wrapcheck
+		return w.parent.ReadTimeout(p, timeout) //nolint: wrapcheck
 	}
 }
 
 
 		return 0, fmt.Errorf("cannot write because context was closed: %w", w.ctx.Err())
 	default:
-		return w.parent.Read(p) // nolint: wrapcheck
+		return w.parent.Read(p) //nolint: wrapcheck
 	}
 }
 
 func (w *wrapperCtx) Close() error {
 	w.cancel()
 
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperCtx) Conn() net.Conn {

wrappers/stream/faketls.go

 
 func (w *wrapperFakeTLS) Write(p []byte) (int, error) {
 	return w.write(p, func(b []byte) (int, error) {
-		return w.parent.Write(b) // nolint: wrapcheck
+		return w.parent.Write(b) //nolint: wrapcheck
 	})
 }
 
 	return w.write(p, func(b []byte) (int, error) {
 		elapsed := time.Since(startTime)
 		if elapsed > timeout {
-			return w.parent.WriteTimeout(b, timeout-elapsed) // nolint: wrapcheck
+			return w.parent.WriteTimeout(b, timeout-elapsed) //nolint: wrapcheck
 		}
 
 		return 0, errors.New("timeout")
 }
 
 func (w *wrapperFakeTLS) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func NewFakeTLS(socket conntypes.StreamReadWriteCloser) conntypes.StreamReadWriteCloser {
 		for {
 			rec, err := tlstypes.ReadRecord(faketls.parent)
 			if err != nil {
-				return nil, err // nolint: wrapcheck
+				return nil, err //nolint: wrapcheck
 			}
 
 			switch rec.Type {

wrappers/stream/mtproto_cipher.go

 	message.Write(req.Nonce)
 
 	data := message.Bytes()
-	md5sum := md5.Sum(data[1:]) // nolint: gas
-	sha1sum := sha1.Sum(data)   // nolint: gosec
+	md5sum := md5.Sum(data[1:]) //nolint: gas
+	sha1sum := sha1.Sum(data)   //nolint: gosec
 
 	key := append(md5sum[:12], sha1sum[:]...)
-	iv := md5.Sum(data[2:]) // nolint: gas
+	iv := md5.Sum(data[2:]) //nolint: gas
 
 	return key, iv[:]
 }

wrappers/stream/obfuscated2.go

 func (w *wrapperObfuscated2) Read(p []byte) (int, error) {
 	n, err := w.parent.Read(p)
 	if err != nil {
-		return n, err // nolint: wrapcheck
+		return n, err //nolint: wrapcheck
 	}
 
 	w.decryptor.XORKeyStream(p, p[:n])
 
 	w.encryptor.XORKeyStream(buf, buf)
 
-	return w.parent.WriteTimeout(buf, timeout) // nolint: wrapcheck
+	return w.parent.WriteTimeout(buf, timeout) //nolint: wrapcheck
 }
 
 func (w *wrapperObfuscated2) Write(p []byte) (int, error) {
 
 	w.encryptor.XORKeyStream(buf, buf)
 
-	return w.parent.Write(buf) // nolint: wrapcheck
+	return w.parent.Write(buf) //nolint: wrapcheck
 }
 
 func (w *wrapperObfuscated2) Conn() net.Conn {
 }
 
 func (w *wrapperObfuscated2) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func NewObfuscated2(socket conntypes.StreamReadWriteCloser,

wrappers/stream/rewind.go

 }
 
 func (w *wrapperRewind) Write(p []byte) (int, error) {
-	return w.parent.Write(p) // nolint: wrapcheck
+	return w.parent.Write(p) //nolint: wrapcheck
 }
 
 func (w *wrapperRewind) WriteTimeout(p []byte, timeout time.Duration) (int, error) {
-	return w.parent.WriteTimeout(p, timeout) // nolint: wrapcheck
+	return w.parent.WriteTimeout(p, timeout) //nolint: wrapcheck
 }
 
 func (w *wrapperRewind) Read(p []byte) (int, error) {
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
 
-	return w.activeReader.Read(p) // nolint: wrapcheck
+	return w.activeReader.Read(p) //nolint: wrapcheck
 }
 
 func (w *wrapperRewind) ReadTimeout(p []byte, _ time.Duration) (int, error) {
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
 
-	return w.activeReader.Read(p) // nolint: wrapcheck
+	return w.activeReader.Read(p) //nolint: wrapcheck
 }
 
 func (w *wrapperRewind) Conn() net.Conn {
 func (w *wrapperRewind) Close() error {
 	w.buf.Reset()
 
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperRewind) Rewind() {

wrappers/stream/stats_telegram.go

 }
 
 func (w *wrapperTelegramStats) Write(p []byte) (int, error) {
-	return w.parent.Write(p) // nolint: wrapcheck
+	return w.parent.Write(p) //nolint: wrapcheck
 }
 
 func (w *wrapperTelegramStats) WriteTimeout(p []byte, timeout time.Duration) (int, error) {
-	return w.parent.WriteTimeout(p, timeout) // nolint: wrapcheck
+	return w.parent.WriteTimeout(p, timeout) //nolint: wrapcheck
 }
 
 func (w *wrapperTelegramStats) Read(p []byte) (int, error) {
-	return w.parent.Read(p) // nolint: wrapcheck
+	return w.parent.Read(p) //nolint: wrapcheck
 }
 
 func (w *wrapperTelegramStats) ReadTimeout(p []byte, timeout time.Duration) (int, error) {
-	return w.parent.ReadTimeout(p, timeout) // nolint: wrapcheck
+	return w.parent.ReadTimeout(p, timeout) //nolint: wrapcheck
 }
 
 func (w *wrapperTelegramStats) Conn() net.Conn {
 		stats.Stats.TelegramDisconnected(w.dc, w.RemoteAddr())
 	})
 
-	return err // nolint: wrapcheck
+	return err //nolint: wrapcheck
 }
 
 func NewTelegramStats(dc conntypes.DC, parent conntypes.StreamReadWriteCloser) conntypes.StreamReadWriteCloser {

wrappers/stream/stats_traffic.go

 	n, err := w.parent.Write(p)
 	stats.Stats.EgressTraffic(n)
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperTrafficStats) WriteTimeout(p []byte, timeout time.Duration) (int, error) {
 	n, err := w.parent.WriteTimeout(p, timeout)
 	stats.Stats.EgressTraffic(n)
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperTrafficStats) Read(p []byte) (int, error) {
 	n, err := w.parent.Read(p)
 	stats.Stats.IngressTraffic(n)
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperTrafficStats) ReadTimeout(p []byte, timeout time.Duration) (int, error) {
 	n, err := w.parent.ReadTimeout(p, timeout)
 	stats.Stats.IngressTraffic(n)
 
-	return n, err // nolint: wrapcheck
+	return n, err //nolint: wrapcheck
 }
 
 func (w *wrapperTrafficStats) Conn() net.Conn {
 }
 
 func (w *wrapperTrafficStats) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func NewTrafficStats(parent conntypes.StreamReadWriteCloser) conntypes.StreamReadWriteCloser {

wrappers/stream/timeout.go

 }
 
 func (w *wrapperTimeout) WriteTimeout(p []byte, timeout time.Duration) (int, error) {
-	return w.parent.WriteTimeout(p, timeout) // nolint: wrapcheck
+	return w.parent.WriteTimeout(p, timeout) //nolint: wrapcheck
 }
 
 func (w *wrapperTimeout) Write(p []byte) (int, error) {
-	return w.parent.WriteTimeout(p, timeoutWrite) // nolint: wrapcheck
+	return w.parent.WriteTimeout(p, timeoutWrite) //nolint: wrapcheck
 }
 
 func (w *wrapperTimeout) ReadTimeout(p []byte, timeout time.Duration) (int, error) {
-	return w.parent.ReadTimeout(p, timeout) // nolint: wrapcheck
+	return w.parent.ReadTimeout(p, timeout) //nolint: wrapcheck
 }
 
 func (w *wrapperTimeout) Read(p []byte) (int, error) {
-	return w.parent.ReadTimeout(p, timeoutRead) // nolint: wrapcheck
+	return w.parent.ReadTimeout(p, timeoutRead) //nolint: wrapcheck
 }
 
 func (w *wrapperTimeout) Close() error {
-	return w.parent.Close() // nolint: wrapcheck
+	return w.parent.Close() //nolint: wrapcheck
 }
 
 func (w *wrapperTimeout) Conn() net.Conn {