Fix lint errors

wrappers/blockcipher.go

@@ -12,6 +12,10 @@ import (
 	"github.com/juju/errors"
 )
 
+// BlockCipher is a stream writer which encrypts/decrypts blocks of data
+// with AES CBC. This also is buffered reader. It means, that block
+// reading is transparent for it, you can assume you are working with
+// good old io.Reader.
 type BlockCipher struct {
 	buf *bytes.Buffer
 
@@ -63,22 +67,27 @@ func (b *BlockCipher) Write(p []byte) (int, error) {
 	return b.conn.Write(encrypted)
 }
 
+// Logger returns an instance of the logger for this wrapper.
 func (b *BlockCipher) Logger() *zap.SugaredLogger {
 	return b.logger
 }
 
+// LocalAddr returns local address of the underlying net.Conn.
 func (b *BlockCipher) LocalAddr() *net.TCPAddr {
 	return b.conn.LocalAddr()
 }
 
+// RemoteAddr returns remote address of the underlying net.Conn.
 func (b *BlockCipher) RemoteAddr() *net.TCPAddr {
 	return b.conn.RemoteAddr()
 }
 
+// Close closes underlying net.Conn.
 func (b *BlockCipher) Close() error {
 	return b.conn.Close()
 }
 
+// NewBlockCipher creates new instance of BlockCipher based on given data.
 func NewBlockCipher(conn StreamReadWriteCloser, encryptor, decryptor cipher.BlockMode) StreamReadWriteCloser {
 	return &BlockCipher{
 		buf:       &bytes.Buffer{},

wrappers/conn.go

@@ -9,6 +9,9 @@ import (
 	"github.com/9seconds/mtg/stats"
 )
 
+// ConnPurpose is intented to be identifier of connection purpose. We
+// sometimes want to treat client/telegram connection differently (for
+// logging for example).
 type ConnPurpose uint8
 
 func (c ConnPurpose) String() string {
@@ -22,6 +25,7 @@ func (c ConnPurpose) String() string {
 	return ""
 }
 
+// ConnPurpose* define different connection types.
 const (
 	ConnPurposeClient = iota
 	ConnPurposeTelegram
@@ -32,6 +36,8 @@ const (
 	connTimeoutWrite = 5 * time.Minute
 )
 
+// Conn is a basic wrapper for net.Conn providing the most low-level
+// logic and management as possible.
 type Conn struct {
 	connID string
 	conn   net.Conn
@@ -42,7 +48,7 @@ type Conn struct {
 }
 
 func (c *Conn) Write(p []byte) (int, error) {
-	c.conn.SetWriteDeadline(time.Now().Add(connTimeoutWrite))
+	c.conn.SetWriteDeadline(time.Now().Add(connTimeoutWrite)) // nolint: errcheck
 	n, err := c.conn.Write(p)
 
 	c.logger.Debugw("Write to stream", "bytes", n, "error", err)
@@ -52,7 +58,7 @@ func (c *Conn) Write(p []byte) (int, error) {
 }
 
 func (c *Conn) Read(p []byte) (int, error) {
-	c.conn.SetReadDeadline(time.Now().Add(connTimeoutRead))
+	c.conn.SetReadDeadline(time.Now().Add(connTimeoutRead)) // nolint: errcheck
 	n, err := c.conn.Read(p)
 
 	c.logger.Debugw("Read from stream", "bytes", n, "error", err)
@@ -61,11 +67,18 @@ func (c *Conn) Read(p []byte) (int, error) {
 	return n, err
 }
 
+// Close closes underlying net.Conn instance.
 func (c *Conn) Close() error {
-	defer c.logger.Debugw("Closed connection")
+	defer c.logger.Debugw("Close connection")
 	return c.conn.Close()
 }
 
+// Logger returns an instance of the logger for this wrapper.
+func (c *Conn) Logger() *zap.SugaredLogger {
+	return c.logger
+}
+
+// LocalAddr returns local address of the underlying net.Conn.
 func (c *Conn) LocalAddr() *net.TCPAddr {
 	addr := c.conn.LocalAddr().(*net.TCPAddr)
 	newAddr := *addr
@@ -81,14 +94,12 @@ func (c *Conn) LocalAddr() *net.TCPAddr {
 	return &newAddr
 }
 
+// RemoteAddr returns remote address of the underlying net.Conn.
 func (c *Conn) RemoteAddr() *net.TCPAddr {
 	return c.conn.RemoteAddr().(*net.TCPAddr)
 }
 
-func (c *Conn) Logger() *zap.SugaredLogger {
-	return c.logger
-}
-
+// NewConn initializes Conn wrapper for net.Conn.
 func NewConn(conn net.Conn, connID string, purpose ConnPurpose, publicIPv4, publicIPv6 net.IP) StreamReadWriteCloser {
 	logger := zap.S().With(
 		"connection_id", connID,

wrappers/mtproto_abridged.go

@@ -18,6 +18,8 @@ const (
 	mtprotoAbridgedLargePacketLength = 16777216 // 256 ^ 3
 )
 
+// MTProtoAbridged presents abridged connection between client and
+// middle proxy.
 type MTProtoAbridged struct {
 	conn   StreamReadWriteCloser
 	opts   *mtproto.ConnectionOpts
@@ -127,22 +129,27 @@ func (m *MTProtoAbridged) Write(p []byte) (int, error) {
 	return 0, errors.Errorf("Packet is too big %d", len(p))
 }
 
+// Logger returns an instance of the logger for this wrapper.
 func (m *MTProtoAbridged) Logger() *zap.SugaredLogger {
 	return m.logger
 }
 
+// LocalAddr returns local address of the underlying net.Conn.
 func (m *MTProtoAbridged) LocalAddr() *net.TCPAddr {
 	return m.conn.LocalAddr()
 }
 
+// RemoteAddr returns remote address of the underlying net.Conn.
 func (m *MTProtoAbridged) RemoteAddr() *net.TCPAddr {
 	return m.conn.RemoteAddr()
 }
 
+// Close closes underlying net.Conn instance.
 func (m *MTProtoAbridged) Close() error {
 	return m.conn.Close()
 }
 
+// NewMTProtoAbridged creates new wrapper for abridged client connection.
 func NewMTProtoAbridged(conn StreamReadWriteCloser, opts *mtproto.ConnectionOpts) PacketReadWriteCloser {
 	return &MTProtoAbridged{
 		conn:   conn,

wrappers/mtproto_cipher.go

@@ -4,7 +4,7 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
-	"crypto/md5"
+	"crypto/md5" // nolint: gas
 	"crypto/sha1"
 	"encoding/binary"
 	"net"
@@ -13,21 +13,23 @@ import (
 	"github.com/9seconds/mtg/utils"
 )
 
-type CipherPurpose uint8
+type cipherPurpose uint8
 
 const (
-	CipherPurposeClient CipherPurpose = iota
-	CipherPurposeServer
+	cipherPurposeClient cipherPurpose = iota
+	cipherPurposeServer
 )
 
 var emptyIP = [4]byte{0x00, 0x00, 0x00, 0x00}
 
+// NewMiddleProxyCipher creates new block cipher to proxy<->telegram
+// connection.
 func NewMiddleProxyCipher(conn StreamReadWriteCloser, req *rpc.NonceRequest, resp *rpc.NonceResponse, secret []byte) StreamReadWriteCloser {
 	localAddr := conn.LocalAddr()
 	remoteAddr := conn.RemoteAddr()
 
-	encKey, encIV := deriveKeys(CipherPurposeClient, req, resp, localAddr, remoteAddr, secret)
-	decKey, decIV := deriveKeys(CipherPurposeServer, req, resp, localAddr, remoteAddr, secret)
+	encKey, encIV := deriveKeys(cipherPurposeClient, req, resp, localAddr, remoteAddr, secret)
+	decKey, decIV := deriveKeys(cipherPurposeServer, req, resp, localAddr, remoteAddr, secret)
 
 	enc, _ := makeEncrypterDecrypter(encKey, encIV)
 	_, dec := makeEncrypterDecrypter(decKey, decIV)
@@ -35,7 +37,7 @@ func NewMiddleProxyCipher(conn StreamReadWriteCloser, req *rpc.NonceRequest, res
 	return NewBlockCipher(conn, enc, dec)
 }
 
-func deriveKeys(purpose CipherPurpose, req *rpc.NonceRequest, resp *rpc.NonceResponse, client *net.TCPAddr, remote *net.TCPAddr, secret []byte) ([]byte, []byte) {
+func deriveKeys(purpose cipherPurpose, req *rpc.NonceRequest, resp *rpc.NonceResponse, client *net.TCPAddr, remote *net.TCPAddr, secret []byte) ([]byte, []byte) {
 	message := bytes.Buffer{}
 	message.Write(resp.Nonce[:])
 	message.Write(req.Nonce[:])
@@ -54,9 +56,9 @@ func deriveKeys(purpose CipherPurpose, req *rpc.NonceRequest, resp *rpc.NonceRes
 	message.Write(port[:])
 
 	switch purpose {
-	case CipherPurposeClient:
+	case cipherPurposeClient:
 		message.WriteString("CLIENT")
-	case CipherPurposeServer:
+	case cipherPurposeServer:
 		message.WriteString("SERVER")
 	default:
 		panic("Unexpected cipher purpose")
@@ -75,11 +77,11 @@ func deriveKeys(purpose CipherPurpose, req *rpc.NonceRequest, resp *rpc.NonceRes
 	message.Write(req.Nonce[:])
 
 	data := message.Bytes()
-	md5sum := md5.Sum(data[1:])
+	md5sum := md5.Sum(data[1:]) // nolint: gas
 	sha1sum := sha1.Sum(data)
 
 	key := append(md5sum[:12], sha1sum[:]...)
-	iv := md5.Sum(data[2:])
+	iv := md5.Sum(data[2:]) // nolint: gas
 
 	return key, iv[:]
 }

wrappers/mtproto_frame.go

@@ -20,6 +20,18 @@ const (
 
 var mtprotoFramePadding = []byte{0x04, 0x00, 0x00, 0x00}
 
+// MTProtoFrame is a wrapper which converts written data to the MTProtoFrame.
+// The format of the frame:
+//
+// [ MSGLEN(4) | SEQNO(4) | MSG(...) | CRC32(4) | PADDING(4*x) ]
+//
+// 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.
+// 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
 type MTProtoFrame struct {
 	conn   StreamReadWriteCloser
 	logger *zap.SugaredLogger
@@ -28,7 +40,7 @@ type MTProtoFrame struct {
 	writeSeqNo int32
 }
 
-func (m *MTProtoFrame) Read() ([]byte, error) {
+func (m *MTProtoFrame) Read() ([]byte, error) { // nolint: gocyclo
 	buf := &bytes.Buffer{}
 	sum := crc32.NewIEEE()
 	writer := io.MultiWriter(buf, sum)
@@ -60,7 +72,7 @@ func (m *MTProtoFrame) Read() ([]byte, error) {
 	}
 
 	var seqNo int32
-	binary.Read(buf, binary.LittleEndian, &seqNo)
+	binary.Read(buf, binary.LittleEndian, &seqNo) // nolint: errcheck
 	if seqNo != m.readSeqNo {
 		return nil, errors.Errorf("Unexpected sequence number %d (wait for %d)", seqNo, m.readSeqNo)
 	}
@@ -96,12 +108,12 @@ func (m *MTProtoFrame) Write(p []byte) (int, error) {
 	buf := &bytes.Buffer{}
 	buf.Grow(messageLength + paddingLength)
 
-	binary.Write(buf, binary.LittleEndian, uint32(messageLength))
-	binary.Write(buf, binary.LittleEndian, m.writeSeqNo)
+	binary.Write(buf, binary.LittleEndian, uint32(messageLength)) // nolint: errcheck
+	binary.Write(buf, binary.LittleEndian, m.writeSeqNo)          // nolint: errcheck
 	buf.Write(p)
 
 	checksum := crc32.ChecksumIEEE(buf.Bytes())
-	binary.Write(buf, binary.LittleEndian, checksum)
+	binary.Write(buf, binary.LittleEndian, checksum) // nolint: errcheck
 	buf.Write(bytes.Repeat(mtprotoFramePadding, paddingLength/4))
 
 	m.logger.Debugw("Write MTProto frame",
@@ -117,22 +129,27 @@ func (m *MTProtoFrame) Write(p []byte) (int, error) {
 	return len(p), err
 }
 
+// Logger returns an instance of the logger for this wrapper.
 func (m *MTProtoFrame) Logger() *zap.SugaredLogger {
 	return m.logger
 }
 
+// LocalAddr returns local address of the underlying net.Conn.
 func (m *MTProtoFrame) LocalAddr() *net.TCPAddr {
 	return m.conn.LocalAddr()
 }
 
+// RemoteAddr returns remote address of the underlying net.Conn.
 func (m *MTProtoFrame) RemoteAddr() *net.TCPAddr {
 	return m.conn.RemoteAddr()
 }
 
+// Close closes underlying net.Conn instance.
 func (m *MTProtoFrame) Close() error {
 	return m.conn.Close()
 }
 
+// NewMTProtoFrame creates new PacketWrapper for underlying connection.
 func NewMTProtoFrame(conn StreamReadWriteCloser, seqNo int32) PacketReadWriteCloser {
 	return &MTProtoFrame{
 		conn:       conn,

wrappers/mtproto_intermediate.go

@@ -14,6 +14,8 @@ import (
 
 const mtprotoIntermediateQuickAckLength = 0x80000000
 
+// MTProtoIntermediate presents intermediate connection between client
+// and Telegram.
 type MTProtoIntermediate struct {
 	conn   StreamReadWriteCloser
 	opts   *mtproto.ConnectionOpts
@@ -88,22 +90,28 @@ func (m *MTProtoIntermediate) Write(p []byte) (int, error) {
 	return m.conn.Write(append(length[:], p...))
 }
 
+// Logger returns an instance of the logger for this wrapper.
 func (m *MTProtoIntermediate) Logger() *zap.SugaredLogger {
 	return m.logger
 }
 
+// LocalAddr returns local address of the underlying net.Conn.
 func (m *MTProtoIntermediate) LocalAddr() *net.TCPAddr {
 	return m.conn.LocalAddr()
 }
 
+// RemoteAddr returns remote address of the underlying net.Conn.
 func (m *MTProtoIntermediate) RemoteAddr() *net.TCPAddr {
 	return m.conn.RemoteAddr()
 }
 
+// Close closes underlying net.Conn instance.
 func (m *MTProtoIntermediate) Close() error {
 	return m.conn.Close()
 }
 
+// NewMTProtoIntermediate creates new PacketWrapper for intermediate
+// client connection.
 func NewMTProtoIntermediate(conn StreamReadWriteCloser, opts *mtproto.ConnectionOpts) PacketReadWriteCloser {
 	return &MTProtoIntermediate{
 		conn:   conn,

wrappers/mtproto_proxy.go

@@ -12,6 +12,7 @@ import (
 	"github.com/9seconds/mtg/mtproto/rpc"
 )
 
+// MTProtoProxy is a wrapper which creates/reads RPC responses from Telegram.
 type MTProtoProxy struct {
 	conn   PacketReadWriteCloser
 	req    *rpc.ProxyRequest
@@ -128,22 +129,27 @@ func (m *MTProtoProxy) Write(p []byte) (int, error) {
 	return len(p), nil
 }
 
+// Logger returns an instance of the logger for this wrapper.
 func (m *MTProtoProxy) Logger() *zap.SugaredLogger {
 	return m.logger
 }
 
+// LocalAddr returns local address of the underlying net.Conn.
 func (m *MTProtoProxy) LocalAddr() *net.TCPAddr {
 	return m.conn.LocalAddr()
 }
 
+// RemoteAddr returns remote address of the underlying net.Conn.
 func (m *MTProtoProxy) RemoteAddr() *net.TCPAddr {
 	return m.conn.RemoteAddr()
 }
 
+// Close closes underlying net.Conn instance.
 func (m *MTProtoProxy) Close() error {
 	return m.conn.Close()
 }
 
+// NewMTProtoProxy creates new RPC wrapper.
 func NewMTProtoProxy(conn PacketReadWriteCloser, connOpts *mtproto.ConnectionOpts, adTag []byte) (PacketReadWriteCloser, error) {
 	req, err := rpc.NewProxyRequest(connOpts.ClientAddr, conn.LocalAddr(), connOpts, adTag)
 	if err != nil {

wrappers/streamcipher.go

@@ -8,6 +8,8 @@ import (
 	"go.uber.org/zap"
 )
 
+// StreamCipher is a wrapper which encrypts/decrypts stream with AES-CTR
+// (as a part of obfuscated2 protocol).
 type StreamCipher struct {
 	encryptor cipher.Stream
 	decryptor cipher.Stream
@@ -32,22 +34,27 @@ func (s *StreamCipher) Write(p []byte) (int, error) {
 	return s.conn.Write(encrypted)
 }
 
+// Logger returns an instance of the logger for this wrapper.
 func (s *StreamCipher) Logger() *zap.SugaredLogger {
 	return s.logger
 }
 
+// LocalAddr returns local address of the underlying net.Conn.
 func (s *StreamCipher) LocalAddr() *net.TCPAddr {
 	return s.conn.LocalAddr()
 }
 
+// RemoteAddr returns remote address of the underlying net.Conn.
 func (s *StreamCipher) RemoteAddr() *net.TCPAddr {
 	return s.conn.RemoteAddr()
 }
 
+// Close closes underlying net.Conn instance.
 func (s *StreamCipher) Close() error {
 	return s.conn.Close()
 }
 
+// NewStreamCipher creates new stream cipher wrapper.
 func NewStreamCipher(conn StreamReadWriteCloser, encryptor, decryptor cipher.Stream) StreamReadWriteCloser {
 	return &StreamCipher{
 		conn:      conn,

wrappers/wrap.go

@@ -7,78 +7,104 @@ import (
 	"go.uber.org/zap"
 )
 
+// Wrap is a base interface for all wrappers in this package.
 type Wrap interface {
 	Logger() *zap.SugaredLogger
 	LocalAddr() *net.TCPAddr
 	RemoteAddr() *net.TCPAddr
 }
 
+// Writer is a base interface for writers of this package.
 type Writer interface {
 	io.Writer
 	Wrap
 }
 
+// Closer is a base interface for wrappers of this package which can
+// close connections.
 type Closer interface {
 	io.Closer
 	Wrap
 }
 
+// WriteCloser is a base interface for wrappers of this package which
+// can write to and close connections.
 type WriteCloser interface {
 	io.Closer
 	Writer
 }
 
+// StreamReader is a base interface for wrappers which can read from the
+// stream.
 type StreamReader interface {
 	io.Reader
 	Wrap
 }
 
+// StreamReadCloser is a base interface for wrappers which can read from
+// and close the connections.
 type StreamReadCloser interface {
 	io.Closer
 	StreamReader
 }
 
+// StreamReadWriter is a base interface for wrappers which can read from
+// and write to the connections.
 type StreamReadWriter interface {
 	io.Writer
 	StreamReader
 }
 
+// StreamWriteCloser is a base interface for wrappers which can write to
+// and close the connections.
 type StreamWriteCloser interface {
 	io.WriteCloser
 	Wrap
 }
 
+// StreamReadWriteCloser is a base interface for stream processors.
 type StreamReadWriteCloser interface {
 	io.Closer
 	StreamReadWriter
 }
 
+// PacketReader is a base interface for wrappers which reads 'packets'.
+// packets are atoms so you either get a packet or you get an error You
+// cannot resume reading from packet.
 type PacketReader interface {
 	Read() ([]byte, error)
 	Wrap
 }
 
+// PacketWriter is a base interface for wrappers which can write packets.
 type PacketWriter interface {
 	io.Writer
 	Wrap
 }
 
+// PacketReadWriter is a base interface for wrappers which can read from
+// and write packets.
 type PacketReadWriter interface {
 	io.Writer
 	PacketReader
 }
 
+// PacketReadCloser is a base interface for wrappers which can read
+// packets and close the connection.
 type PacketReadCloser interface {
 	io.Closer
 	PacketReader
 }
 
+// PacketWriteCloser is a base interface for wrappers which can write
+// packets and close the connection.
 type PacketWriteCloser interface {
 	io.Writer
 	io.Closer
 	Wrap
 }
 
+// PacketReadWriteCloser is a base interface for packet processors.
 type PacketReadWriteCloser interface {
 	io.Closer
 	PacketReadWriter