git.r.bdr.sh - rbdr/mobius/blob - hotline/client_conn.go

   1 package hotline
   2
   3 import (
   4         "encoding/binary"
   5         "fmt"
   6         "golang.org/x/crypto/bcrypt"
   7         "io"
   8         "log/slog"
   9         "math/big"
  10         "sort"
  11         "strings"
  12         "sync"
  13 )
  14
  15 type byClientID []*ClientConn
  16
  17 func (s byClientID) Len() int {
  18         return len(s)
  19 }
  20
  21 func (s byClientID) Swap(i, j int) {
  22         s[i], s[j] = s[j], s[i]
  23 }
  24
  25 func (s byClientID) Less(i, j int) bool {
  26         return s[i].uint16ID() < s[j].uint16ID()
  27 }
  28
  29 // ClientConn represents a client connected to a Server
  30 type ClientConn struct {
  31         Connection io.ReadWriteCloser
  32         RemoteAddr string
  33         ID         *[]byte
  34         Icon       []byte
  35         Flags      []byte
  36         UserName   []byte
  37         Account    *Account
  38         IdleTime   int
  39         Server     *Server
  40         Version    []byte
  41         Idle       bool
  42         AutoReply  []byte
  43
  44         transfersMU sync.Mutex
  45         transfers   map[int]map[[4]byte]*FileTransfer
  46
  47         logger *slog.Logger
  48 }
  49
  50 func (cc *ClientConn) sendAll(t int, fields ...Field) {
  51         for _, c := range sortedClients(cc.Server.Clients) {
  52                 cc.Server.outbox <- *NewTransaction(t, c.ID, fields...)
  53         }
  54 }
  55
  56 func (cc *ClientConn) handleTransaction(transaction Transaction) error {
  57         requestNum := binary.BigEndian.Uint16(transaction.Type[:])
  58         if handler, ok := TransactionHandlers[requestNum]; ok {
  59                 for _, reqField := range handler.RequiredFields {
  60                         field := transaction.GetField(reqField.ID)
  61
  62                         // Validate that required field is present
  63                         if field.ID == [2]byte{0, 0} {
  64                                 cc.logger.Error(
  65                                         "Missing required field",
  66                                         "RequestType", handler.Name, "FieldID", reqField.ID,
  67                                 )
  68                                 return nil
  69                         }
  70
  71                         if len(field.Data) < reqField.minLen {
  72                                 cc.logger.Info(
  73                                         "Field does not meet minLen",
  74                                         "RequestType", handler.Name, "FieldID", reqField.ID,
  75                                 )
  76                                 return nil
  77                         }
  78                 }
  79
  80                 cc.logger.Debug("Received Transaction", "RequestType", handler.Name)
  81
  82                 transactions, err := handler.Handler(cc, &transaction)
  83                 if err != nil {
  84                         return fmt.Errorf("error handling transaction: %w", err)
  85                 }
  86                 for _, t := range transactions {
  87                         cc.Server.outbox <- t
  88                 }
  89         } else {
  90                 cc.logger.Error(
  91                         "Unimplemented transaction type received", "RequestID", requestNum)
  92         }
  93
  94         cc.Server.mux.Lock()
  95         defer cc.Server.mux.Unlock()
  96
  97         if requestNum != TranKeepAlive {
  98                 // reset the user idle timer
  99                 cc.IdleTime = 0
 100
 101                 // if user was previously idle, mark as not idle and notify other connected clients that
 102                 // the user is no longer away
 103                 if cc.Idle {
 104                         flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(cc.Flags)))
 105                         flagBitmap.SetBit(flagBitmap, UserFlagAway, 0)
 106                         binary.BigEndian.PutUint16(cc.Flags, uint16(flagBitmap.Int64()))
 107                         cc.Idle = false
 108
 109                         cc.sendAll(
 110                                 TranNotifyChangeUser,
 111                                 NewField(FieldUserID, *cc.ID),
 112                                 NewField(FieldUserFlags, cc.Flags),
 113                                 NewField(FieldUserName, cc.UserName),
 114                                 NewField(FieldUserIconID, cc.Icon),
 115                         )
 116                 }
 117         }
 118
 119         return nil
 120 }
 121
 122 func (cc *ClientConn) Authenticate(login string, password []byte) bool {
 123         if account, ok := cc.Server.Accounts[login]; ok {
 124                 return bcrypt.CompareHashAndPassword([]byte(account.Password), password) == nil
 125         }
 126
 127         return false
 128 }
 129
 130 func (cc *ClientConn) uint16ID() uint16 {
 131         id, _ := byteToInt(*cc.ID)
 132         return uint16(id)
 133 }
 134
 135 // Authorize checks if the user account has the specified permission
 136 func (cc *ClientConn) Authorize(access int) bool {
 137         return cc.Account.Access.IsSet(access)
 138 }
 139
 140 // Disconnect notifies other clients that a client has disconnected
 141 func (cc *ClientConn) Disconnect() {
 142         cc.Server.mux.Lock()
 143         defer cc.Server.mux.Unlock()
 144
 145         delete(cc.Server.Clients, binary.BigEndian.Uint16(*cc.ID))
 146
 147         for _, t := range cc.notifyOthers(*NewTransaction(TranNotifyDeleteUser, nil, NewField(FieldUserID, *cc.ID))) {
 148                 cc.Server.outbox <- t
 149         }
 150
 151         if err := cc.Connection.Close(); err != nil {
 152                 cc.Server.Logger.Error("error closing client connection", "RemoteAddr", cc.RemoteAddr)
 153         }
 154 }
 155
 156 // notifyOthers sends transaction t to other clients connected to the server
 157 func (cc *ClientConn) notifyOthers(t Transaction) (trans []Transaction) {
 158         for _, c := range sortedClients(cc.Server.Clients) {
 159                 if c.ID != cc.ID {
 160                         t.clientID = c.ID
 161                         trans = append(trans, t)
 162                 }
 163         }
 164         return trans
 165 }
 166
 167 // NewReply returns a reply Transaction with fields for the ClientConn
 168 func (cc *ClientConn) NewReply(t *Transaction, fields ...Field) Transaction {
 169         return Transaction{
 170                 IsReply:   0x01,
 171                 Type:      [2]byte{0x00, 0x00},
 172                 ID:        t.ID,
 173                 clientID:  cc.ID,
 174                 ErrorCode: [4]byte{0, 0, 0, 0},
 175                 Fields:    fields,
 176         }
 177 }
 178
 179 // NewErrReply returns an error reply Transaction with errMsg
 180 func (cc *ClientConn) NewErrReply(t *Transaction, errMsg string) Transaction {
 181         return Transaction{
 182                 clientID:  cc.ID,
 183                 IsReply:   0x01,
 184                 Type:      [2]byte{0, 0},
 185                 ID:        t.ID,
 186                 ErrorCode: [4]byte{0, 0, 0, 1},
 187                 Fields: []Field{
 188                         NewField(FieldError, []byte(errMsg)),
 189                 },
 190         }
 191 }
 192
 193 // sortedClients is a utility function that takes a map of *ClientConn and returns a sorted slice of the values.
 194 // The purpose of this is to ensure that the ordering of client connections is deterministic so that test assertions work.
 195 func sortedClients(unsortedClients map[uint16]*ClientConn) (clients []*ClientConn) {
 196         for _, c := range unsortedClients {
 197                 clients = append(clients, c)
 198         }
 199         sort.Sort(byClientID(clients))
 200         return clients
 201 }
 202
 203 const userInfoTemplate = `Nickname:   %s
 204 Name:       %s
 205 Account:    %s
 206 Address:    %s
 207
 208 -------- File Downloads ---------
 209
 210 %s
 211 ------- Folder Downloads --------
 212
 213 %s
 214 --------- File Uploads ----------
 215
 216 %s
 217 -------- Folder Uploads ---------
 218
 219 %s
 220 ------- Waiting Downloads -------
 221
 222 %s
 223 `
 224
 225 func formatDownloadList(fts map[[4]byte]*FileTransfer) (s string) {
 226         if len(fts) == 0 {
 227                 return "None.\n"
 228         }
 229
 230         for _, dl := range fts {
 231                 s += dl.String()
 232         }
 233
 234         return s
 235 }
 236
 237 func (cc *ClientConn) String() string {
 238         cc.transfersMU.Lock()
 239         defer cc.transfersMU.Unlock()
 240         template := fmt.Sprintf(
 241                 userInfoTemplate,
 242                 cc.UserName,
 243                 cc.Account.Name,
 244                 cc.Account.Login,
 245                 cc.RemoteAddr,
 246                 formatDownloadList(cc.transfers[FileDownload]),
 247                 formatDownloadList(cc.transfers[FolderDownload]),
 248                 formatDownloadList(cc.transfers[FileUpload]),
 249                 formatDownloadList(cc.transfers[FolderUpload]),
 250                 "None.\n",
 251         )
 252
 253         return strings.ReplaceAll(template, "\n", "\r")
 254 }