package hotline
import (
+ "cmp"
"encoding/binary"
+ "fmt"
"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
-func (s byClientID) Len() int {
- return len(s)
+ Logger *slog.Logger
+
+ 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.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
- }
- }
- 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)
+ }
- cc.Server.Logger.Infow(
- "Received Transaction",
- "login", cc.Account.Login,
- "name", string(cc.UserName),
- "RequestType", handler.Name,
- )
+ return transfers
+}
+
+func (cftm *ClientFileTransferMgr) Delete(ftType FileTransferType, id FileTransferID) {
+ cftm.mu.Lock()
+ defer cftm.mu.Unlock()
+
+ 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
}
- } 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 transaction.Type != TranKeepAlive {
+ cc.mu.Lock()
+ defer cc.mu.Unlock()
- 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 {
- 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(
- tranNotifyChangeUser,
- NewField(fieldUserID, *cc.ID),
- NewField(fieldUserFlags, *cc.Flags),
- NewField(fieldUserName, cc.UserName),
- NewField(fieldUserIconID, *cc.Icon),
+ 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),
)
}
}
-
- return nil
}
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
}
-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 {
- 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()
-
- delete(cc.Server.Clients, binary.BigEndian.Uint16(*cc.ID))
+// Disconnect notifies other clients that a client has disconnected and closes the connection.
+func (cc *ClientConn) Disconnect() {
+ cc.Server.ClientMgr.Delete(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 {
- 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
-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
}
// 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
-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)),
+ },
},
}
}
+
+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 s
+}
+
+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")
+}
git.r.bdr.sh / rbdr / mobius / blobdiff