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

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