Fix io.Reader implementations and wrap more errors

[rbdr/mobius] / hotline / client_conn.go

diff --git a/hotline/client_conn.go b/hotline/client_conn.go
index b43a6ff65a371dcca85a169404ae98b5346f5b72..c886dfcc712e88eed55b99dc3a80c2d22aced448 100644 (file)
--- a/hotline/client_conn.go
+++ b/hotline/client_conn.go
@@ -1,12 +1,15 @@
 package hotline
 
 import (
 package hotline
 
 import (

-       "bytes"

        "encoding/binary"
        "encoding/binary"

-       "errors"
+       "fmt"

        "golang.org/x/crypto/bcrypt"
        "golang.org/x/crypto/bcrypt"

+       "io"
+       "log/slog"

        "math/big"
        "math/big"

-       "net"
+       "sort"
+       "strings"
+       "sync"

 )
 
 type byClientID []*ClientConn
 )
 
 type byClientID []*ClientConn


@@ -25,19 +28,23 @@ func (s byClientID) Less(i, j int) bool {
 
 // ClientConn represents a client connected to a Server
 type ClientConn struct {
 
 // ClientConn represents a client connected to a Server
 type ClientConn struct {

-       Connection net.Conn
+       Connection io.ReadWriteCloser
+       RemoteAddr string

        ID         *[]byte
        ID         *[]byte

-       Icon       *[]byte
-       Flags      *[]byte
+       Icon       []byte
+       Flags      []byte

        UserName   []byte
        Account    *Account
        IdleTime   int
        Server     *Server
        UserName   []byte
        Account    *Account
        IdleTime   int
        Server     *Server

-       Version    *[]byte
+       Version    []byte

        Idle       bool
        Idle       bool

-       AutoReply  *[]byte
-       Transfers  map[int][]*FileTransfer
-       Agreed     bool
+       AutoReply  []byte
+
+       transfersMU sync.Mutex
+       transfers   map[int]map[[4]byte]*FileTransfer
+
+       logger *slog.Logger

 }
 
 func (cc *ClientConn) sendAll(t int, fields ...Field) {
 }
 
 func (cc *ClientConn) sendAll(t int, fields ...Field) {


@@ -46,81 +53,65 @@ func (cc *ClientConn) sendAll(t int, fields ...Field) {
        }
 }
 
        }
 }
 

-func (cc *ClientConn) handleTransaction(transaction *Transaction) error {
+func (cc *ClientConn) handleTransaction(transaction Transaction) error {

        requestNum := binary.BigEndian.Uint16(transaction.Type)
        if handler, ok := TransactionHandlers[requestNum]; ok {
                for _, reqField := range handler.RequiredFields {
                        field := transaction.GetField(reqField.ID)
 
                        // Validate that required field is present
        requestNum := binary.BigEndian.Uint16(transaction.Type)
        if handler, ok := TransactionHandlers[requestNum]; ok {
                for _, reqField := range handler.RequiredFields {
                        field := transaction.GetField(reqField.ID)
 
                        // Validate that required field is present

-                       if field.ID == nil {
-                               cc.Server.Logger.Infow(
+                       if field.ID == [2]byte{0, 0} {
+                               cc.logger.Error(

                                        "Missing required field",
                                        "Missing required field",

-                                       "Account", cc.Account.Login, "UserName", string(cc.UserName), "RequestType", handler.Name, "FieldID", reqField.ID,
+                                       "RequestType", handler.Name, "FieldID", reqField.ID,

                                )
                                return nil
                        }
 
                        if len(field.Data) < reqField.minLen {
                                )
                                return nil
                        }
 
                        if len(field.Data) < reqField.minLen {

-                               cc.Server.Logger.Infow(
+                               cc.logger.Info(

                                        "Field does not meet minLen",
                                        "Field does not meet minLen",

-                                       "Account", cc.Account.Login, "UserName", string(cc.UserName), "RequestType", handler.Name, "FieldID", reqField.ID,
+                                       "RequestType", handler.Name, "FieldID", reqField.ID,

                                )
                                return nil
                        }
                }
                                )
                                return nil
                        }
                }

-               if !authorize(cc.Account.Access, handler.Access) {
-                       cc.Server.Logger.Infow(
-                               "Unauthorized Action",
-                               "Account", cc.Account.Login, "UserName", string(cc.UserName), "RequestType", handler.Name,
-                       )
-                       cc.Server.outbox <- cc.NewErrReply(transaction, handler.DenyMsg)
-
-                       return nil
-               }

 
 

-               cc.Server.Logger.Infow(
-                       "Received Transaction",
-                       "login", cc.Account.Login,
-                       "name", string(cc.UserName),
-                       "RequestType", handler.Name,
-               )
+               cc.logger.Debug("Received Transaction", "RequestType", handler.Name)

 
 

-               transactions, err := handler.Handler(cc, transaction)
+               transactions, err := handler.Handler(cc, &transaction)

                if err != nil {
                if err != nil {

-                       return err
+                       return fmt.Errorf("error handling transaction: %w", err)

                }
                for _, t := range transactions {
                        cc.Server.outbox <- t
                }
        } else {
                }
                for _, t := range transactions {
                        cc.Server.outbox <- t
                }
        } else {

-               cc.Server.Logger.Errorw(
-                       "Unimplemented transaction type received",
-                       "UserName", string(cc.UserName), "RequestID", requestNum,
-               )
+               cc.logger.Error(
+                       "Unimplemented transaction type received", "RequestID", requestNum)

        }
 
        cc.Server.mux.Lock()
        defer cc.Server.mux.Unlock()
 
        }
 
        cc.Server.mux.Lock()
        defer cc.Server.mux.Unlock()
 

-       if requestNum != tranKeepAlive {
+       if requestNum != TranKeepAlive {

                // reset the user idle timer
                cc.IdleTime = 0
 
                // if user was previously idle, mark as not idle and notify other connected clients that
                // the user is no longer away
                if cc.Idle {
                // reset the user idle timer
                cc.IdleTime = 0
 
                // if user was previously idle, mark as not idle and notify other connected clients that
                // the user is no longer away
                if cc.Idle {

-                       flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(*cc.Flags)))
-                       flagBitmap.SetBit(flagBitmap, userFlagAway, 0)
-                       binary.BigEndian.PutUint16(*cc.Flags, uint16(flagBitmap.Int64()))
+                       flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(cc.Flags)))
+                       flagBitmap.SetBit(flagBitmap, UserFlagAway, 0)
+                       binary.BigEndian.PutUint16(cc.Flags, uint16(flagBitmap.Int64()))

                        cc.Idle = false
 
                        cc.sendAll(
                        cc.Idle = false
 
                        cc.sendAll(

-                               tranNotifyChangeUser,
-                               NewField(fieldUserID, *cc.ID),
-                               NewField(fieldUserFlags, *cc.Flags),
-                               NewField(fieldUserName, cc.UserName),
-                               NewField(fieldUserIconID, *cc.Icon),
+                               TranNotifyChangeUser,
+                               NewField(FieldUserID, *cc.ID),
+                               NewField(FieldUserFlags, cc.Flags),
+                               NewField(FieldUserName, cc.UserName),
+                               NewField(FieldUserIconID, cc.Icon),

                        )
                }
        }
                        )
                }
        }


@@ -143,106 +134,121 @@ func (cc *ClientConn) uint16ID() uint16 {
 
 // Authorize checks if the user account has the specified permission
 func (cc *ClientConn) Authorize(access int) bool {
 
 // Authorize checks if the user account has the specified permission
 func (cc *ClientConn) Authorize(access int) bool {

-       if access == 0 {
-               return true
-       }
-
-       accessBitmap := big.NewInt(int64(binary.BigEndian.Uint64(*cc.Account.Access)))
-
-       return accessBitmap.Bit(63-access) == 1
+       return cc.Account.Access.IsSet(access)

 }
 
 // Disconnect notifies other clients that a client has disconnected
 }
 
 // Disconnect notifies other clients that a client has disconnected

-func (cc ClientConn) Disconnect() {
+func (cc *ClientConn) Disconnect() {

        cc.Server.mux.Lock()
        defer cc.Server.mux.Unlock()
 
        delete(cc.Server.Clients, binary.BigEndian.Uint16(*cc.ID))
 
        cc.Server.mux.Lock()
        defer cc.Server.mux.Unlock()
 
        delete(cc.Server.Clients, binary.BigEndian.Uint16(*cc.ID))
 

-       cc.NotifyOthers(*NewTransaction(tranNotifyDeleteUser, nil, NewField(fieldUserID, *cc.ID)))
+       for _, t := range cc.notifyOthers(*NewTransaction(TranNotifyDeleteUser, nil, NewField(FieldUserID, *cc.ID))) {
+               cc.Server.outbox <- t
+       }

 
        if err := cc.Connection.Close(); err != nil {
 
        if err := cc.Connection.Close(); err != nil {

-               cc.Server.Logger.Errorw("error closing client connection", "RemoteAddr", cc.Connection.RemoteAddr())
+               cc.Server.Logger.Error("error closing client connection", "RemoteAddr", cc.RemoteAddr)

        }
 }
 
        }
 }
 

-// NotifyOthers sends transaction t to other clients connected to the server
-func (cc ClientConn) NotifyOthers(t Transaction) {
+// notifyOthers sends transaction t to other clients connected to the server
+func (cc *ClientConn) notifyOthers(t Transaction) (trans []Transaction) {

        for _, c := range sortedClients(cc.Server.Clients) {
        for _, c := range sortedClients(cc.Server.Clients) {

-               if c.ID != cc.ID && c.Agreed {
+               if c.ID != cc.ID {

                        t.clientID = c.ID
                        t.clientID = c.ID

-                       cc.Server.outbox <- t
+                       trans = append(trans, t)

                }
        }
                }
        }

-}
-
-type handshake struct {
-       Protocol    [4]byte // Must be 0x54525450 TRTP
-       SubProtocol [4]byte
-       Version     [2]byte // Always 1
-       SubVersion  [2]byte
-}
-
-// Handshake
-// After establishing TCP connection, both client and server start the handshake process
-// in order to confirm that each of them comply with requirements of the other.
-// The information provided in this initial data exchange identifies protocols,
-// and their versions, used in the communication. In the case where, after inspection,
-// the capabilities of one of the subjects do not comply with the requirements of the other,
-// the connection is dropped.
-//
-// The following information is sent to the server:
-// Description         Size    Data    Note
-// Protocol ID         4               TRTP    0x54525450
-// Sub-protocol ID     4               HOTL    User defined
-// VERSION                     2               1               Currently 1
-// Sub-version         2               2               User defined
-//
-// The server replies with the following:
-// Description         Size    Data    Note
-// Protocol ID         4               TRTP
-//Error code           4                               Error code returned by the server (0 = no error)
-func Handshake(conn net.Conn, buf []byte) error {
-       var h handshake
-       r := bytes.NewReader(buf)
-       if err := binary.Read(r, binary.BigEndian, &h); err != nil {
-               return err
-       }
-
-       if h.Protocol != [4]byte{0x54, 0x52, 0x54, 0x50} {
-               return errors.New("invalid handshake")
-       }
-
-       _, err := conn.Write([]byte{84, 82, 84, 80, 0, 0, 0, 0})
-       return err
+       return trans

 }
 
 // NewReply returns a reply Transaction with fields for the ClientConn
 func (cc *ClientConn) NewReply(t *Transaction, fields ...Field) Transaction {
 }
 
 // NewReply returns a reply Transaction with fields for the ClientConn
 func (cc *ClientConn) NewReply(t *Transaction, fields ...Field) Transaction {

-       reply := Transaction{
-               Flags:     0x00,
+       return Transaction{

                IsReply:   0x01,
                IsReply:   0x01,

-               Type:      t.Type,
+               Type:      []byte{0x00, 0x00},

                ID:        t.ID,
                clientID:  cc.ID,
                ErrorCode: []byte{0, 0, 0, 0},
                Fields:    fields,
        }
                ID:        t.ID,
                clientID:  cc.ID,
                ErrorCode: []byte{0, 0, 0, 0},
                Fields:    fields,
        }

-
-       return reply

 }
 
 // NewErrReply returns an error reply Transaction with errMsg
 func (cc *ClientConn) NewErrReply(t *Transaction, errMsg string) Transaction {
        return Transaction{
                clientID:  cc.ID,
 }
 
 // NewErrReply returns an error reply Transaction with errMsg
 func (cc *ClientConn) NewErrReply(t *Transaction, errMsg string) Transaction {
        return Transaction{
                clientID:  cc.ID,

-               Flags:     0x00,

                IsReply:   0x01,
                Type:      []byte{0, 0},
                ID:        t.ID,
                ErrorCode: []byte{0, 0, 0, 1},
                Fields: []Field{
                IsReply:   0x01,
                Type:      []byte{0, 0},
                ID:        t.ID,
                ErrorCode: []byte{0, 0, 0, 1},
                Fields: []Field{

-                       NewField(fieldError, []byte(errMsg)),
+                       NewField(FieldError, []byte(errMsg)),

                },
        }
 }
                },
        }
 }

+
+// sortedClients is a utility function that takes a map of *ClientConn and returns a sorted slice of the values.
+// The purpose of this is to ensure that the ordering of client connections is deterministic so that test assertions work.
+func sortedClients(unsortedClients map[uint16]*ClientConn) (clients []*ClientConn) {
+       for _, c := range unsortedClients {
+               clients = append(clients, c)
+       }
+       sort.Sort(byClientID(clients))
+       return clients
+}
+
+const userInfoTemplate = `Nickname:   %s
+Name:       %s
+Account:    %s
+Address:    %s
+
+-------- File Downloads ---------
+
+%s
+------- Folder Downloads --------
+
+%s
+--------- File Uploads ----------
+
+%s
+-------- Folder Uploads ---------
+
+%s
+------- Waiting Downloads -------
+
+%s
+`
+
+func formatDownloadList(fts map[[4]byte]*FileTransfer) (s string) {
+       if len(fts) == 0 {
+               return "None.\n"
+       }
+
+       for _, dl := range fts {
+               s += dl.String()
+       }
+
+       return s
+}
+
+func (cc *ClientConn) String() string {
+       cc.transfersMU.Lock()
+       defer cc.transfersMU.Unlock()
+       template := fmt.Sprintf(
+               userInfoTemplate,
+               cc.UserName,
+               cc.Account.Name,
+               cc.Account.Login,
+               cc.RemoteAddr,
+               formatDownloadList(cc.transfers[FileDownload]),
+               formatDownloadList(cc.transfers[FolderDownload]),
+               formatDownloadList(cc.transfers[FileUpload]),
+               formatDownloadList(cc.transfers[FolderUpload]),
+               "None.\n",
+       )
+
+       return strings.ReplaceAll(template, "\n", "\r")
+}