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

   1 package hotline
   2
   3 import (
   4         "encoding/binary"
   5         "fmt"
   6         "go.uber.org/zap"
   7         "golang.org/x/crypto/bcrypt"
   8         "io"
   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 *zap.SugaredLogger
  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 == nil {
  64                                 cc.logger.Errorw(
  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.Infow(
  73                                         "Field does not meet minLen",
  74                                         "RequestType", handler.Name, "FieldID", reqField.ID,
  75                                 )
  76                                 return nil
  77                         }
  78                 }
  79
  80                 cc.logger.Debugw("Received Transaction", "RequestType", handler.Name)
  81
  82                 transactions, err := handler.Handler(cc, &transaction)
  83                 if err != nil {
  84                         return err
  85                 }
  86                 for _, t := range transactions {
  87                         cc.Server.outbox <- t
  88                 }
  89         } else {
  90                 cc.logger.Errorw(
  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.Errorw("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         reply := Transaction{
 170                 Flags:     0x00,
 171                 IsReply:   0x01,
 172                 Type:      []byte{0x00, 0x00},
 173                 ID:        t.ID,
 174                 clientID:  cc.ID,
 175                 ErrorCode: []byte{0, 0, 0, 0},
 176                 Fields:    fields,
 177         }
 178
 179         return reply
 180 }
 181
 182 // NewErrReply returns an error reply Transaction with errMsg
 183 func (cc *ClientConn) NewErrReply(t *Transaction, errMsg string) Transaction {
 184         return Transaction{
 185                 clientID:  cc.ID,
 186                 Flags:     0x00,
 187                 IsReply:   0x01,
 188                 Type:      []byte{0, 0},
 189                 ID:        t.ID,
 190                 ErrorCode: []byte{0, 0, 0, 1},
 191                 Fields: []Field{
 192                         NewField(FieldError, []byte(errMsg)),
 193                 },
 194         }
 195 }
 196
 197 // sortedClients is a utility function that takes a map of *ClientConn and returns a sorted slice of the values.
 198 // The purpose of this is to ensure that the ordering of client connections is deterministic so that test assertions work.
 199 func sortedClients(unsortedClients map[uint16]*ClientConn) (clients []*ClientConn) {
 200         for _, c := range unsortedClients {
 201                 clients = append(clients, c)
 202         }
 203         sort.Sort(byClientID(clients))
 204         return clients
 205 }
 206
 207 const userInfoTemplate = `Nickname:   %s
 208 Name:       %s
 209 Account:    %s
 210 Address:    %s
 211
 212 -------- File Downloads ---------
 213
 214 %s
 215 ------- Folder Downloads --------
 216
 217 %s
 218 --------- File Uploads ----------
 219
 220 %s
 221 -------- Folder Uploads ---------
 222
 223 %s
 224 ------- Waiting Downloads -------
 225
 226 %s
 227 `
 228
 229 func formatDownloadList(fts map[[4]byte]*FileTransfer) (s string) {
 230         if len(fts) == 0 {
 231                 return "None.\n"
 232         }
 233
 234         for _, dl := range fts {
 235                 s += dl.String()
 236         }
 237
 238         return s
 239 }
 240
 241 func (cc *ClientConn) String() string {
 242         cc.transfersMU.Lock()
 243         defer cc.transfersMU.Unlock()
 244         template := fmt.Sprintf(
 245                 userInfoTemplate,
 246                 cc.UserName,
 247                 cc.Account.Name,
 248                 cc.Account.Login,
 249                 cc.RemoteAddr,
 250                 formatDownloadList(cc.transfers[FileDownload]),
 251                 formatDownloadList(cc.transfers[FolderDownload]),
 252                 formatDownloadList(cc.transfers[FileUpload]),
 253                 formatDownloadList(cc.transfers[FolderUpload]),
 254                 "None.\n",
 255         )
 256
 257         return strings.ReplaceAll(template, "\n", "\r")
 258 }