Merge pull request #56 from jhalter/refuse_priv_chat

Implement handing for "Refuse Private Chat" preference

diff --git a/hotline/server.go b/hotline/server.go
index 852b7727b5da640d867b752cd69dfb1311d37a6c..06a0695771d5e8fdfac7b717f366b240a82f54d7 100644 (file)
--- a/hotline/server.go
+++ b/hotline/server.go
@@ -48,10 +48,13 @@ type Server struct {
        Clients       map[uint16]*ClientConn
        fileTransfers map[[4]byte]*FileTransfer
 
-       Config        *Config
-       ConfigDir     string
-       Logger        *zap.SugaredLogger
-       PrivateChats  map[uint32]*PrivateChat
+       Config    *Config
+       ConfigDir string
+       Logger    *zap.SugaredLogger
+
+       PrivateChatsMu sync.Mutex
+       PrivateChats   map[uint32]*PrivateChat
+
        NextGuestID   *uint16
        TrackerPassID [4]byte
        Stats         *Stats
@@ -698,15 +701,14 @@ func (s *Server) handleNewConnection(ctx context.Context, rwc io.ReadWriteCloser
 }
 
 func (s *Server) NewPrivateChat(cc *ClientConn) []byte {
-       s.mux.Lock()
-       defer s.mux.Unlock()
+       s.PrivateChatsMu.Lock()
+       defer s.PrivateChatsMu.Unlock()
 
        randID := make([]byte, 4)
        rand.Read(randID)
        data := binary.BigEndian.Uint32(randID[:])
 
        s.PrivateChats[data] = &PrivateChat{
-               Subject:    "",
                ClientConn: make(map[uint16]*ClientConn),
        }
        s.PrivateChats[data].ClientConn[cc.uint16ID()] = cc

diff --git a/hotline/transaction_handlers.go b/hotline/transaction_handlers.go
index afc24ff1b794e36dc344ca982d4f5a50ab1665fc..2dc5e0683af1934f916aae91f8956aec48fbf093 100644 (file)
--- a/hotline/transaction_handlers.go
+++ b/hotline/transaction_handlers.go
@@ -1704,15 +1704,35 @@ func HandleInviteNewChat(cc *ClientConn, t *Transaction) (res []Transaction, err
        targetID := t.GetField(fieldUserID).Data
        newChatID := cc.Server.NewPrivateChat(cc)
 
-       res = append(res,
-               *NewTransaction(
-                       tranInviteToChat,
-                       &targetID,
-                       NewField(fieldChatID, newChatID),
-                       NewField(fieldUserName, cc.UserName),
-                       NewField(fieldUserID, *cc.ID),
-               ),
-       )
+       // Halcyon does not accept private chats.
+
+       // Check if target user has "Refuse private chat" flag
+       binary.BigEndian.Uint16(targetID)
+       targetClient := cc.Server.Clients[binary.BigEndian.Uint16(targetID)]
+
+       flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(targetClient.Flags)))
+       if flagBitmap.Bit(userFLagRefusePChat) == 1 {
+               res = append(res,
+                       *NewTransaction(
+                               tranServerMsg,
+                               cc.ID,
+                               NewField(fieldData, []byte(string(targetClient.UserName)+" does not accept private messages.")),
+                               NewField(fieldUserName, targetClient.UserName),
+                               NewField(fieldUserID, *targetClient.ID),
+                               NewField(fieldOptions, []byte{0, 2}),
+                       ),
+               )
+       } else {
+               res = append(res,
+                       *NewTransaction(
+                               tranInviteToChat,
+                               &targetID,
+                               NewField(fieldChatID, newChatID),
+                               NewField(fieldUserName, cc.UserName),
+                               NewField(fieldUserID, *cc.ID),
+                       ),
+               )
+       }
 
        res = append(res,
                cc.NewReply(t,

diff --git a/hotline/transaction_handlers_test.go b/hotline/transaction_handlers_test.go
index 0a95f62538e289b315f0c4d981b3df6c813a9567..cb9e21f301a117faf12188fd9e24b99b226c8baa 100644 (file)
--- a/hotline/transaction_handlers_test.go
+++ b/hotline/transaction_handlers_test.go
@@ -3286,3 +3286,182 @@ func TestHandleTranOldPostNews(t *testing.T) {
                })
        }
 }
+
+func TestHandleInviteNewChat(t *testing.T) {
+       type args struct {
+               cc *ClientConn
+               t  *Transaction
+       }
+       tests := []struct {
+               name    string
+               args    args
+               wantRes []Transaction
+               wantErr assert.ErrorAssertionFunc
+       }{
+               {
+                       name: "when user does not have required permission",
+                       args: args{
+                               cc: &ClientConn{
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       return bits
+                                               }(),
+                                       },
+                               },
+                               t: NewTransaction(tranInviteNewChat, &[]byte{0, 1}),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       Flags:     0x00,
+                                       IsReply:   0x01,
+                                       Type:      []byte{0, 0x00},
+                                       ID:        []byte{0, 0, 0, 0},
+                                       ErrorCode: []byte{0, 0, 0, 1},
+                                       Fields: []Field{
+                                               NewField(fieldError, []byte("You are not allowed to request private chat.")),
+                                       },
+                               },
+                       },
+                       wantErr: assert.NoError,
+               },
+               {
+                       name: "when userA invites userB to new private chat",
+                       args: args{
+                               cc: &ClientConn{
+                                       ID: &[]byte{0, 1},
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       bits.Set(accessOpenChat)
+                                                       return bits
+                                               }(),
+                                       },
+                                       UserName: []byte("UserA"),
+                                       Icon:     []byte{0, 1},
+                                       Flags:    []byte{0, 0},
+                                       Server: &Server{
+                                               Clients: map[uint16]*ClientConn{
+                                                       uint16(2): {
+                                                               ID:       &[]byte{0, 2},
+                                                               UserName: []byte("UserB"),
+                                                               Flags:    []byte{0, 0},
+                                                       },
+                                               },
+                                               PrivateChats: make(map[uint32]*PrivateChat),
+                                       },
+                               },
+                               t: NewTransaction(
+                                       tranInviteNewChat, &[]byte{0, 1},
+                                       NewField(fieldUserID, []byte{0, 2}),
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       clientID:  &[]byte{0, 2},
+                                       Flags:     0x00,
+                                       IsReply:   0x00,
+                                       Type:      []byte{0, 0x71},
+                                       ID:        []byte{0, 0, 0, 0},
+                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       Fields: []Field{
+                                               NewField(fieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(fieldUserName, []byte("UserA")),
+                                               NewField(fieldUserID, []byte{0, 1}),
+                                       },
+                               },
+
+                               {
+                                       clientID:  &[]byte{0, 1},
+                                       Flags:     0x00,
+                                       IsReply:   0x01,
+                                       Type:      []byte{0, 0x70},
+                                       ID:        []byte{0, 0, 0, 0},
+                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       Fields: []Field{
+                                               NewField(fieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(fieldUserName, []byte("UserA")),
+                                               NewField(fieldUserID, []byte{0, 1}),
+                                               NewField(fieldUserIconID, []byte{0, 1}),
+                                               NewField(fieldUserFlags, []byte{0, 0}),
+                                       },
+                               },
+                       },
+                       wantErr: assert.NoError,
+               },
+               {
+                       name: "when userA invites userB to new private chat, but UserB has refuse private chat enabled",
+                       args: args{
+                               cc: &ClientConn{
+                                       ID: &[]byte{0, 1},
+                                       Account: &Account{
+                                               Access: func() accessBitmap {
+                                                       var bits accessBitmap
+                                                       bits.Set(accessOpenChat)
+                                                       return bits
+                                               }(),
+                                       },
+                                       UserName: []byte("UserA"),
+                                       Icon:     []byte{0, 1},
+                                       Flags:    []byte{0, 0},
+                                       Server: &Server{
+                                               Clients: map[uint16]*ClientConn{
+                                                       uint16(2): {
+                                                               ID:       &[]byte{0, 2},
+                                                               UserName: []byte("UserB"),
+                                                               Flags:    []byte{255, 255},
+                                                       },
+                                               },
+                                               PrivateChats: make(map[uint32]*PrivateChat),
+                                       },
+                               },
+                               t: NewTransaction(
+                                       tranInviteNewChat, &[]byte{0, 1},
+                                       NewField(fieldUserID, []byte{0, 2}),
+                               ),
+                       },
+                       wantRes: []Transaction{
+                               {
+                                       clientID:  &[]byte{0, 1},
+                                       Flags:     0x00,
+                                       IsReply:   0x00,
+                                       Type:      []byte{0, 0x68},
+                                       ID:        []byte{0, 0, 0, 0},
+                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       Fields: []Field{
+                                               NewField(fieldData, []byte("UserB does not accept private messages.")),
+                                               NewField(fieldUserName, []byte("UserB")),
+                                               NewField(fieldUserID, []byte{0, 2}),
+                                               NewField(fieldOptions, []byte{0, 2}),
+                                       },
+                               },
+                               {
+                                       clientID:  &[]byte{0, 1},
+                                       Flags:     0x00,
+                                       IsReply:   0x01,
+                                       Type:      []byte{0, 0x70},
+                                       ID:        []byte{0, 0, 0, 0},
+                                       ErrorCode: []byte{0, 0, 0, 0},
+                                       Fields: []Field{
+                                               NewField(fieldChatID, []byte{0x52, 0xfd, 0xfc, 0x07}),
+                                               NewField(fieldUserName, []byte("UserA")),
+                                               NewField(fieldUserID, []byte{0, 1}),
+                                               NewField(fieldUserIconID, []byte{0, 1}),
+                                               NewField(fieldUserFlags, []byte{0, 0}),
+                                       },
+                               },
+                       },
+                       wantErr: assert.NoError,
+               },
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       rand.Seed(1)
+                       gotRes, err := HandleInviteNewChat(tt.args.cc, tt.args.t)
+                       if !tt.wantErr(t, err, fmt.Sprintf("HandleInviteNewChat(%v, %v)", tt.args.cc, tt.args.t)) {
+                               return
+                       }
+                       tranAssertEqual(t, tt.wantRes, gotRes)
+               })
+       }
+}