]> git.r.bdr.sh - rbdr/mobius/blobdiff - hotline/client_conn.go
git.r.bdr.sh / rbdr / mobius / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Refactoring, cleanup, test backfilling
[rbdr/mobius] / hotline / client_conn.go
diff --git a/hotline/client_conn.go b/hotline/client_conn.go
index c1ae4e3c8fb9f5f4fb0d5b4bb09cffaba2e30da3..e527eba99db5ef1ad101abda698991572a622243 100644 (file)
--- a/hotline/client_conn.go
+++ b/hotline/client_conn.go
@@ -1,148 +1,78 @@
 package hotline
 
 import (
 package hotline
 
 import (
+       "cmp"
        "encoding/binary"
        "encoding/binary"
+       "fmt"
        "golang.org/x/crypto/bcrypt"
        "io"
        "golang.org/x/crypto/bcrypt"
        "io"
-       "math/big"
+       "log/slog"
+       "slices"
+       "strings"
+       "sync"
 )
 
 )
 
-type byClientID []*ClientConn
-
-func (s byClientID) Len() int {
-       return len(s)
-}
-
-func (s byClientID) Swap(i, j int) {
-       s[i], s[j] = s[j], s[i]
-}
-
-func (s byClientID) Less(i, j int) bool {
-       return s[i].uint16ID() < s[j].uint16ID()
-}
-
-const template = `Nickname:   %s
-Name:       %s
-Account:    %s
-Address:    %s
-
--------- File Downloads ---------
-
-%s
-
-------- Folder Downloads --------
-
-None.
-
---------- File Uploads ----------
-
-None.
-
--------- Folder Uploads ---------
-
-None.
-
-------- Waiting Downloads -------
-
-None.
-
-       `
-
 // ClientConn represents a client connected to a Server
 type ClientConn struct {
        Connection io.ReadWriteCloser
        RemoteAddr string
 // ClientConn represents a client connected to a Server
 type ClientConn struct {
        Connection io.ReadWriteCloser
        RemoteAddr string
-       ID         *[]byte
-       Icon       *[]byte
-       Flags      *[]byte
+       ID         [2]byte
+       Icon       []byte
+       flagsMU    sync.Mutex
+       Flags      UserFlags
        UserName   []byte
        Account    *Account
        IdleTime   int
        Server     *Server
        UserName   []byte
        Account    *Account
        IdleTime   int
        Server     *Server
-       Version    *[]byte
+       Version    []byte
        Idle       bool
        AutoReply  []byte
        Idle       bool
        AutoReply  []byte
-       Transfers  map[int][]*FileTransfer
-       Agreed     bool
+
+       transfersMU sync.Mutex
+       transfers   map[int]map[[4]byte]*FileTransfer
+
+       logger *slog.Logger
+
+       sync.Mutex
 }
 
 }
 
-func (cc *ClientConn) sendAll(t int, fields ...Field) {
-       for _, c := range sortedClients(cc.Server.Clients) {
-               cc.Server.outbox <- *NewTransaction(t, c.ID, fields...)
+func (cc *ClientConn) sendAll(t [2]byte, fields ...Field) {
+       for _, c := range cc.Server.Clients {
+               cc.Server.outbox <- NewTransaction(t, c.ID, fields...)
        }
 }
 
        }
 }
 
-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
-                       if field.ID == nil {
-                               cc.Server.Logger.Errorw(
-                                       "Missing required field",
-                                       "Account", cc.Account.Login, "UserName", string(cc.UserName), "RequestType", handler.Name, "FieldID", reqField.ID,
-                               )
-                               return nil
-                       }
-
-                       if len(field.Data) < reqField.minLen {
-                               cc.Server.Logger.Infow(
-                                       "Field does not meet minLen",
-                                       "Account", cc.Account.Login, "UserName", string(cc.UserName), "RequestType", handler.Name, "FieldID", reqField.ID,
-                               )
-                               return nil
-                       }
-               }
+func (cc *ClientConn) handleTransaction(transaction Transaction) {
+       if handler, ok := TransactionHandlers[transaction.Type]; ok {
+               cc.logger.Debug("Received Transaction", "RequestType", transaction.Type)
 
 
-               cc.Server.Logger.Infow(
-                       "Received Transaction",
-                       "login", cc.Account.Login,
-                       "name", string(cc.UserName),
-                       "RequestType", handler.Name,
-               )
-
-               transactions, err := handler.Handler(cc, transaction)
-               if err != nil {
-                       return err
-               }
-               for _, t := range transactions {
+               for _, t := range handler(cc, &transaction) {
                        cc.Server.outbox <- t
                }
                        cc.Server.outbox <- t
                }
-       } else {
-               cc.Server.Logger.Errorw(
-                       "Unimplemented transaction type received",
-                       "UserName", string(cc.UserName), "RequestID", requestNum,
-               )
        }
 
        cc.Server.mux.Lock()
        defer cc.Server.mux.Unlock()
 
        }
 
        cc.Server.mux.Lock()
        defer cc.Server.mux.Unlock()
 
-       if requestNum != tranKeepAlive {
+       if transaction.Type != 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()))
+                       cc.Flags.Set(UserFlagAway, 0)
                        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),
                        )
                }
        }
                        )
                }
        }
-
-       return nil
 }
 
 func (cc *ClientConn) Authenticate(login string, password []byte) bool {
 }
 
 func (cc *ClientConn) Authenticate(login string, password []byte) bool {
@@ -153,72 +83,137 @@ func (cc *ClientConn) Authenticate(login string, password []byte) bool {
        return false
 }
 
        return false
 }
 
-func (cc *ClientConn) uint16ID() uint16 {
-       id, _ := byteToInt(*cc.ID)
-       return uint16(id)
-}
-
 // 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
+       cc.Lock()
+       defer cc.Unlock()
+       if cc.Account == nil {
+               return false
        }
        }
-
-       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
 func (cc *ClientConn) Disconnect() {
        cc.Server.mux.Lock()
 }
 
 // Disconnect notifies other clients that a client has disconnected
 func (cc *ClientConn) Disconnect() {
        cc.Server.mux.Lock()
-       defer cc.Server.mux.Unlock()
+       delete(cc.Server.Clients, cc.ID)
+       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, [2]byte{}, 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.RemoteAddr)
+               cc.Server.Logger.Error("error closing client connection", "RemoteAddr", cc.RemoteAddr)
        }
 }
 
 // notifyOthers sends transaction t to other clients connected to the server
        }
 }
 
 // notifyOthers sends transaction t to other clients connected to the server
-func (cc *ClientConn) notifyOthers(t Transaction) {
-       for _, c := range sortedClients(cc.Server.Clients) {
-               if c.ID != cc.ID && c.Agreed {
+func (cc *ClientConn) notifyOthers(t Transaction) (trans []Transaction) {
+       cc.Server.mux.Lock()
+       defer cc.Server.mux.Unlock()
+       for _, c := range cc.Server.Clients {
+               if c.ID != cc.ID {
                        t.clientID = c.ID
                        t.clientID = c.ID
-                       cc.Server.outbox <- t
+                       trans = append(trans, t)
                }
        }
                }
        }
+       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,
-               IsReply:   0x01,
-               Type:      t.Type,
-               ID:        t.ID,
-               clientID:  cc.ID,
-               ErrorCode: []byte{0, 0, 0, 0},
-               Fields:    fields,
+       return Transaction{
+               IsReply:  1,
+               ID:       t.ID,
+               clientID: cc.ID,
+               Fields:   fields,
        }
        }
-
-       return reply
 }
 
 // NewErrReply returns an error reply Transaction with errMsg
 }
 
 // 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{
-                       NewField(fieldError, []byte(errMsg)),
+func (cc *ClientConn) NewErrReply(t *Transaction, errMsg string) []Transaction {
+       return []Transaction{
+               {
+                       clientID:  cc.ID,
+                       IsReply:   1,
+                       ID:        t.ID,
+                       ErrorCode: [4]byte{0, 0, 0, 1},
+                       Fields: []Field{
+                               NewField(FieldError, []byte(errMsg)),
+                       },
                },
        }
 }
                },
        }
 }
+
+var clientSortFunc = func(a, b *ClientConn) int {
+       return cmp.Compare(
+               binary.BigEndian.Uint16(a.ID[:]),
+               binary.BigEndian.Uint16(b.ID[:]),
+       )
+}
+
+// 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[[2]byte]*ClientConn) (clients []*ClientConn) {
+       for _, c := range unsortedClients {
+               clients = append(clients, c)
+       }
+
+       slices.SortFunc(clients, clientSortFunc)
+
+       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")
+}
Friendship Quest remix of mobius, a hotline server in go #cli