Add option for account-specific file root

[rbdr/mobius] / hotline / client_conn.go

diff --git a/hotline/client_conn.go b/hotline/client_conn.go
index 8e9a6147c5e3d864d8b2a26378dcdd096ffc7b14..d32459116074aeff5213ff35601a0e15a17283f6 100644 (file)
--- a/hotline/client_conn.go
+++ b/hotline/client_conn.go
@@ -1,248 +1,252 @@
 package hotline
 
 import (
 package hotline
 
 import (

-       "bytes"
+       "cmp"

        "encoding/binary"
        "encoding/binary"

-       "errors"
+       "fmt"

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

-       "math/big"
-       "net"
+       "io"
+       "log/slog"
+       "strings"
+       "sync"

 )
 
 )
 

-type byClientID []*ClientConn
+var clientConnSortFunc = func(a, b *ClientConn) int {
+       return cmp.Compare(
+               binary.BigEndian.Uint16(a.ID[:]),
+               binary.BigEndian.Uint16(b.ID[:]),
+       )
+}
+
+// ClientConn represents a client connected to a Server
+type ClientConn struct {
+       Connection io.ReadWriteCloser
+       RemoteAddr string
+       ID         ClientID
+       Icon       []byte // TODO: make fixed size of 2
+       Version    []byte // TODO: make fixed size of 2
+
+       FlagsMU sync.Mutex // TODO: move into UserFlags struct
+       Flags   UserFlags
+
+       UserName  []byte
+       Account   *Account
+       IdleTime  int
+       Server    *Server // TODO: consider adding methods to interact with server
+       AutoReply []byte
+
+       ClientFileTransferMgr ClientFileTransferMgr
+
+       Logger *slog.Logger

 
 

-func (s byClientID) Len() int {
-       return len(s)
+       mu sync.RWMutex

 }
 
 }
 

-func (s byClientID) Swap(i, j int) {
-       s[i], s[j] = s[j], s[i]
+func (cc *ClientConn) FileRoot() string {
+       if cc.Account.FileRoot != "" {
+               return cc.Account.FileRoot
+       }
+       return cc.Server.Config.FileRoot

 }
 
 }
 

-func (s byClientID) Less(i, j int) bool {
-       return s[i].uint16ID() < s[j].uint16ID()
+type ClientFileTransferMgr struct {
+       transfers map[FileTransferType]map[FileTransferID]*FileTransfer
+
+       mu sync.RWMutex

 }
 
 }
 

-// ClientConn represents a client connected to a Server
-type ClientConn struct {
-       Connection net.Conn
-       ID         *[]byte
-       Icon       *[]byte
-       Flags      *[]byte
-       UserName   []byte
-       Account    *Account
-       IdleTime   *int
-       Server     *Server
-       Version    *[]byte
-       Idle       bool
-       AutoReply  *[]byte
-       Transfers  map[int][]*FileTransfer
-       Agreed     bool
-}
-
-func (cc *ClientConn) sendAll(t int, fields ...Field) {
-       for _, c := range sortedClients(cc.Server.Clients) {
-               cc.Server.outbox <- *NewTransaction(t, c.ID, fields...)
+func NewClientFileTransferMgr() ClientFileTransferMgr {
+       return ClientFileTransferMgr{
+               transfers: map[FileTransferType]map[FileTransferID]*FileTransfer{
+                       FileDownload:   {},
+                       FileUpload:     {},
+                       FolderDownload: {},
+                       FolderUpload:   {},
+                       BannerDownload: {},
+               },

        }
 }
 
        }
 }
 

-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.Infow(
-                                       "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
-                       }
-               }
-               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)
+func (cftm *ClientFileTransferMgr) Add(ftType FileTransferType, ft *FileTransfer) {
+       cftm.mu.Lock()
+       defer cftm.mu.Unlock()

 
 

-                       return nil
-               }
+       cftm.transfers[ftType][ft.RefNum] = ft
+}
+
+func (cftm *ClientFileTransferMgr) Get(ftType FileTransferType) []FileTransfer {
+       cftm.mu.Lock()
+       defer cftm.mu.Unlock()
+
+       fts := cftm.transfers[ftType]
+
+       var transfers []FileTransfer
+       for _, ft := range fts {
+               transfers = append(transfers, *ft)
+       }
+
+       return transfers
+}
+
+func (cftm *ClientFileTransferMgr) Delete(ftType FileTransferType, id FileTransferID) {
+       cftm.mu.Lock()
+       defer cftm.mu.Unlock()

 
 

-               cc.Server.Logger.Infow(
-                       "Received Transaction",
-                       "login", cc.Account.Login,
-                       "name", string(cc.UserName),
-                       "RequestType", handler.Name,
-               )
+       delete(cftm.transfers[ftType], id)
+}
+
+func (cc *ClientConn) SendAll(t [2]byte, fields ...Field) {
+       for _, c := range cc.Server.ClientMgr.List() {
+               cc.Server.outbox <- NewTransaction(t, c.ID, fields...)
+       }
+}

 
 

-               transactions, err := handler.Handler(cc, transaction)
-               if err != nil {
-                       return err
+func (cc *ClientConn) handleTransaction(transaction Transaction) {
+       if handler, ok := cc.Server.handlers[transaction.Type]; ok {
+               if transaction.Type != TranKeepAlive {
+                       cc.Logger.Info(tranTypeNames[transaction.Type])

                }
                }

-               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()
-
-       // if user was idle and this is a non-keepalive transaction
-       if *cc.IdleTime > userIdleSeconds && requestNum != tranKeepAlive {
-               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.IdleTime = 0
-
-               cc.sendAll(
-                       tranNotifyChangeUser,
-                       NewField(fieldUserID, *cc.ID),
-                       NewField(fieldUserFlags, *cc.Flags),
-                       NewField(fieldUserName, cc.UserName),
-                       NewField(fieldUserIconID, *cc.Icon),
-               )
-
-               //return nil
-       }
+       if transaction.Type != TranKeepAlive {
+               cc.mu.Lock()
+               defer cc.mu.Unlock()

 
 

-       // TODO: Don't we need to skip this if requestNum == tranKeepalive ??
-       *cc.IdleTime = 0
+               // reset the user idle timer
+               cc.IdleTime = 0

 
 

-       return nil
+               // if user was previously idle, mark as not idle and notify other connected clients that
+               // the user is no longer away
+               if cc.Flags.IsSet(UserFlagAway) {
+                       cc.Flags.Set(UserFlagAway, 0)
+
+                       cc.SendAll(
+                               TranNotifyChangeUser,
+                               NewField(FieldUserID, cc.ID[:]),
+                               NewField(FieldUserFlags, cc.Flags[:]),
+                               NewField(FieldUserName, cc.UserName),
+                               NewField(FieldUserIconID, cc.Icon),
+                       )
+               }
+       }

 }
 
 func (cc *ClientConn) Authenticate(login string, password []byte) bool {
 }
 
 func (cc *ClientConn) Authenticate(login string, password []byte) bool {

-       if account, ok := cc.Server.Accounts[login]; ok {
+       if account := cc.Server.AccountManager.Get(login); account != nil {

                return bcrypt.CompareHashAndPassword([]byte(account.Password), password) == nil
        }
 
        return false
 }
 
                return bcrypt.CompareHashAndPassword([]byte(account.Password), password) == nil
        }
 
        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
+       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()
-       defer cc.Server.mux.Unlock()
+// Disconnect notifies other clients that a client has disconnected and closes the connection.
+func (cc *ClientConn) Disconnect() {
+       cc.Server.ClientMgr.Delete(cc.ID)

 
 

-       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.Connection.RemoteAddr())
+               cc.Server.Logger.Debug("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 {
-                       t.clientID = c.ID
-                       cc.Server.outbox <- t
+func (cc *ClientConn) NotifyOthers(t Transaction) (trans []Transaction) {
+       for _, c := range cc.Server.ClientMgr.List() {
+               if c.ID != cc.ID {
+                       t.ClientID = c.ID
+                       trans = append(trans, t)

                }
        }
                }
        }

+       return trans

 }
 
 }
 

-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
+// NewReply returns a reply Transaction with fields for the ClientConn
+func (cc *ClientConn) NewReply(t *Transaction, fields ...Field) Transaction {
+       return Transaction{
+               IsReply:  1,
+               ID:       t.ID,
+               ClientID: cc.ID,
+               Fields:   fields,

        }
        }

+}

 
 

-       if h.Protocol != [4]byte{0x54, 0x52, 0x54, 0x50} {
-               return errors.New("invalid handshake")
+// NewErrReply returns an error reply Transaction with 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)),
+                       },
+               },

        }
        }

-
-       _, err := conn.Write([]byte{84, 82, 84, 80, 0, 0, 0, 0})
-       return err

 }
 
 }
 

-// 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,
+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 []FileTransfer) (s string) {
+       if len(fts) == 0 {
+               return "None.\n"
+       }
+
+       for _, dl := range fts {
+               s += dl.String()

        }
 
        }
 

-       return reply
+       return s

 }
 
 }
 

-// 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) String() string {
+       template := fmt.Sprintf(
+               userInfoTemplate,
+               cc.UserName,
+               cc.Account.Name,
+               cc.Account.Login,
+               cc.RemoteAddr,
+               formatDownloadList(cc.ClientFileTransferMgr.Get(FileDownload)),
+               formatDownloadList(cc.ClientFileTransferMgr.Get(FolderDownload)),
+               formatDownloadList(cc.ClientFileTransferMgr.Get(FileUpload)),
+               formatDownloadList(cc.ClientFileTransferMgr.Get(FolderUpload)),
+               "None.\n",
+       )
+
+       return strings.ReplaceAll(template, "\n", "\r")

 }
 }