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

   1 package hotline
   2
   3 import (
   4         "bytes"
   5         "encoding/binary"
   6         "errors"
   7         "fmt"
   8         "gopkg.in/yaml.v3"
   9         "math/big"
  10         "os"
  11         "path"
  12         "path/filepath"
  13         "sort"
  14         "strings"
  15         "time"
  16 )
  17
  18 type HandlerFunc func(*ClientConn, *Transaction) ([]Transaction, error)
  19
  20 type TransactionType struct {
  21         Handler        HandlerFunc // function for handling the transaction type
  22         Name           string      // Name of transaction as it will appear in logging
  23         RequiredFields []requiredField
  24 }
  25
  26 var TransactionHandlers = map[uint16]TransactionType{
  27         // Server initiated
  28         TranChatMsg: {
  29                 Name: "TranChatMsg",
  30         },
  31         // Server initiated
  32         TranNotifyChangeUser: {
  33                 Name: "TranNotifyChangeUser",
  34         },
  35         TranError: {
  36                 Name: "TranError",
  37         },
  38         TranShowAgreement: {
  39                 Name: "TranShowAgreement",
  40         },
  41         TranUserAccess: {
  42                 Name: "TranUserAccess",
  43         },
  44         TranNotifyDeleteUser: {
  45                 Name: "TranNotifyDeleteUser",
  46         },
  47         TranAgreed: {
  48                 Name:    "TranAgreed",
  49                 Handler: HandleTranAgreed,
  50         },
  51         TranChatSend: {
  52                 Name:    "TranChatSend",
  53                 Handler: HandleChatSend,
  54                 RequiredFields: []requiredField{
  55                         {
  56                                 ID:     FieldData,
  57                                 minLen: 0,
  58                         },
  59                 },
  60         },
  61         TranDelNewsArt: {
  62                 Name:    "TranDelNewsArt",
  63                 Handler: HandleDelNewsArt,
  64         },
  65         TranDelNewsItem: {
  66                 Name:    "TranDelNewsItem",
  67                 Handler: HandleDelNewsItem,
  68         },
  69         TranDeleteFile: {
  70                 Name:    "TranDeleteFile",
  71                 Handler: HandleDeleteFile,
  72         },
  73         TranDeleteUser: {
  74                 Name:    "TranDeleteUser",
  75                 Handler: HandleDeleteUser,
  76         },
  77         TranDisconnectUser: {
  78                 Name:    "TranDisconnectUser",
  79                 Handler: HandleDisconnectUser,
  80         },
  81         TranDownloadFile: {
  82                 Name:    "TranDownloadFile",
  83                 Handler: HandleDownloadFile,
  84         },
  85         TranDownloadFldr: {
  86                 Name:    "TranDownloadFldr",
  87                 Handler: HandleDownloadFolder,
  88         },
  89         TranGetClientInfoText: {
  90                 Name:    "TranGetClientInfoText",
  91                 Handler: HandleGetClientInfoText,
  92         },
  93         TranGetFileInfo: {
  94                 Name:    "TranGetFileInfo",
  95                 Handler: HandleGetFileInfo,
  96         },
  97         TranGetFileNameList: {
  98                 Name:    "TranGetFileNameList",
  99                 Handler: HandleGetFileNameList,
 100         },
 101         TranGetMsgs: {
 102                 Name:    "TranGetMsgs",
 103                 Handler: HandleGetMsgs,
 104         },
 105         TranGetNewsArtData: {
 106                 Name:    "TranGetNewsArtData",
 107                 Handler: HandleGetNewsArtData,
 108         },
 109         TranGetNewsArtNameList: {
 110                 Name:    "TranGetNewsArtNameList",
 111                 Handler: HandleGetNewsArtNameList,
 112         },
 113         TranGetNewsCatNameList: {
 114                 Name:    "TranGetNewsCatNameList",
 115                 Handler: HandleGetNewsCatNameList,
 116         },
 117         TranGetUser: {
 118                 Name:    "TranGetUser",
 119                 Handler: HandleGetUser,
 120         },
 121         TranGetUserNameList: {
 122                 Name:    "tranHandleGetUserNameList",
 123                 Handler: HandleGetUserNameList,
 124         },
 125         TranInviteNewChat: {
 126                 Name:    "TranInviteNewChat",
 127                 Handler: HandleInviteNewChat,
 128         },
 129         TranInviteToChat: {
 130                 Name:    "TranInviteToChat",
 131                 Handler: HandleInviteToChat,
 132         },
 133         TranJoinChat: {
 134                 Name:    "TranJoinChat",
 135                 Handler: HandleJoinChat,
 136         },
 137         TranKeepAlive: {
 138                 Name:    "TranKeepAlive",
 139                 Handler: HandleKeepAlive,
 140         },
 141         TranLeaveChat: {
 142                 Name:    "TranJoinChat",
 143                 Handler: HandleLeaveChat,
 144         },
 145         TranListUsers: {
 146                 Name:    "TranListUsers",
 147                 Handler: HandleListUsers,
 148         },
 149         TranMoveFile: {
 150                 Name:    "TranMoveFile",
 151                 Handler: HandleMoveFile,
 152         },
 153         TranNewFolder: {
 154                 Name:    "TranNewFolder",
 155                 Handler: HandleNewFolder,
 156         },
 157         TranNewNewsCat: {
 158                 Name:    "TranNewNewsCat",
 159                 Handler: HandleNewNewsCat,
 160         },
 161         TranNewNewsFldr: {
 162                 Name:    "TranNewNewsFldr",
 163                 Handler: HandleNewNewsFldr,
 164         },
 165         TranNewUser: {
 166                 Name:    "TranNewUser",
 167                 Handler: HandleNewUser,
 168         },
 169         TranUpdateUser: {
 170                 Name:    "TranUpdateUser",
 171                 Handler: HandleUpdateUser,
 172         },
 173         TranOldPostNews: {
 174                 Name:    "TranOldPostNews",
 175                 Handler: HandleTranOldPostNews,
 176         },
 177         TranPostNewsArt: {
 178                 Name:    "TranPostNewsArt",
 179                 Handler: HandlePostNewsArt,
 180         },
 181         TranRejectChatInvite: {
 182                 Name:    "TranRejectChatInvite",
 183                 Handler: HandleRejectChatInvite,
 184         },
 185         TranSendInstantMsg: {
 186                 Name:    "TranSendInstantMsg",
 187                 Handler: HandleSendInstantMsg,
 188                 RequiredFields: []requiredField{
 189                         {
 190                                 ID:     FieldData,
 191                                 minLen: 0,
 192                         },
 193                         {
 194                                 ID: FieldUserID,
 195                         },
 196                 },
 197         },
 198         TranSetChatSubject: {
 199                 Name:    "TranSetChatSubject",
 200                 Handler: HandleSetChatSubject,
 201         },
 202         TranMakeFileAlias: {
 203                 Name:    "TranMakeFileAlias",
 204                 Handler: HandleMakeAlias,
 205                 RequiredFields: []requiredField{
 206                         {ID: FieldFileName, minLen: 1},
 207                         {ID: FieldFilePath, minLen: 1},
 208                         {ID: FieldFileNewPath, minLen: 1},
 209                 },
 210         },
 211         TranSetClientUserInfo: {
 212                 Name:    "TranSetClientUserInfo",
 213                 Handler: HandleSetClientUserInfo,
 214         },
 215         TranSetFileInfo: {
 216                 Name:    "TranSetFileInfo",
 217                 Handler: HandleSetFileInfo,
 218         },
 219         TranSetUser: {
 220                 Name:    "TranSetUser",
 221                 Handler: HandleSetUser,
 222         },
 223         TranUploadFile: {
 224                 Name:    "TranUploadFile",
 225                 Handler: HandleUploadFile,
 226         },
 227         TranUploadFldr: {
 228                 Name:    "TranUploadFldr",
 229                 Handler: HandleUploadFolder,
 230         },
 231         TranUserBroadcast: {
 232                 Name:    "TranUserBroadcast",
 233                 Handler: HandleUserBroadcast,
 234         },
 235         TranDownloadBanner: {
 236                 Name:    "TranDownloadBanner",
 237                 Handler: HandleDownloadBanner,
 238         },
 239 }
 240
 241 func HandleChatSend(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 242         if !cc.Authorize(accessSendChat) {
 243                 res = append(res, cc.NewErrReply(t, "You are not allowed to participate in chat."))
 244                 return res, err
 245         }
 246
 247         // Truncate long usernames
 248         trunc := fmt.Sprintf("%13s", cc.UserName)
 249         formattedMsg := fmt.Sprintf("\r%.14s:  %s", trunc, t.GetField(FieldData).Data)
 250
 251         // By holding the option key, Hotline chat allows users to send /me formatted messages like:
 252         // *** Halcyon does stuff
 253         // This is indicated by the presence of the optional field FieldChatOptions set to a value of 1.
 254         // Most clients do not send this option for normal chat messages.
 255         if t.GetField(FieldChatOptions).Data != nil && bytes.Equal(t.GetField(FieldChatOptions).Data, []byte{0, 1}) {
 256                 formattedMsg = fmt.Sprintf("\r*** %s %s", cc.UserName, t.GetField(FieldData).Data)
 257         }
 258
 259         // The ChatID field is used to identify messages as belonging to a private chat.
 260         // All clients *except* Frogblast omit this field for public chat, but Frogblast sends a value of 00 00 00 00.
 261         chatID := t.GetField(FieldChatID).Data
 262         if chatID != nil && !bytes.Equal([]byte{0, 0, 0, 0}, chatID) {
 263                 chatInt := binary.BigEndian.Uint32(chatID)
 264                 privChat := cc.Server.PrivateChats[chatInt]
 265
 266                 clients := sortedClients(privChat.ClientConn)
 267
 268                 // send the message to all connected clients of the private chat
 269                 for _, c := range clients {
 270                         res = append(res, *NewTransaction(
 271                                 TranChatMsg,
 272                                 c.ID,
 273                                 NewField(FieldChatID, chatID),
 274                                 NewField(FieldData, []byte(formattedMsg)),
 275                         ))
 276                 }
 277                 return res, err
 278         }
 279
 280         for _, c := range sortedClients(cc.Server.Clients) {
 281                 // Filter out clients that do not have the read chat permission
 282                 if c.Authorize(accessReadChat) {
 283                         res = append(res, *NewTransaction(TranChatMsg, c.ID, NewField(FieldData, []byte(formattedMsg))))
 284                 }
 285         }
 286
 287         return res, err
 288 }
 289
 290 // HandleSendInstantMsg sends instant message to the user on the current server.
 291 // Fields used in the request:
 292 //
 293 //      103     User ID
 294 //      113     Options
 295 //              One of the following values:
 296 //              - User message (myOpt_UserMessage = 1)
 297 //              - Refuse message (myOpt_RefuseMessage = 2)
 298 //              - Refuse chat (myOpt_RefuseChat  = 3)
 299 //              - Automatic response (myOpt_AutomaticResponse = 4)"
 300 //      101     Data    Optional
 301 //      214     Quoting message Optional
 302 //
 303 // Fields used in the reply:
 304 // None
 305 func HandleSendInstantMsg(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 306         if !cc.Authorize(accessSendPrivMsg) {
 307                 res = append(res, cc.NewErrReply(t, "You are not allowed to send private messages."))
 308                 return res, errors.New("user is not allowed to send private messages")
 309         }
 310
 311         msg := t.GetField(FieldData)
 312         ID := t.GetField(FieldUserID)
 313
 314         reply := NewTransaction(
 315                 TranServerMsg,
 316                 &ID.Data,
 317                 NewField(FieldData, msg.Data),
 318                 NewField(FieldUserName, cc.UserName),
 319                 NewField(FieldUserID, *cc.ID),
 320                 NewField(FieldOptions, []byte{0, 1}),
 321         )
 322
 323         // Later versions of Hotline include the original message in the FieldQuotingMsg field so
 324         //  the receiving client can display both the received message and what it is in reply to
 325         if t.GetField(FieldQuotingMsg).Data != nil {
 326                 reply.Fields = append(reply.Fields, NewField(FieldQuotingMsg, t.GetField(FieldQuotingMsg).Data))
 327         }
 328
 329         id, err := byteToInt(ID.Data)
 330         if err != nil {
 331                 return res, errors.New("invalid client ID")
 332         }
 333         otherClient, ok := cc.Server.Clients[uint16(id)]
 334         if !ok {
 335                 return res, errors.New("invalid client ID")
 336         }
 337
 338         // Check if target user has "Refuse private messages" flag
 339         flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(otherClient.Flags)))
 340         if flagBitmap.Bit(UserFlagRefusePChat) == 1 {
 341                 res = append(res,
 342                         *NewTransaction(
 343                                 TranServerMsg,
 344                                 cc.ID,
 345                                 NewField(FieldData, []byte(string(otherClient.UserName)+" does not accept private messages.")),
 346                                 NewField(FieldUserName, otherClient.UserName),
 347                                 NewField(FieldUserID, *otherClient.ID),
 348                                 NewField(FieldOptions, []byte{0, 2}),
 349                         ),
 350                 )
 351         } else {
 352                 res = append(res, *reply)
 353         }
 354
 355         // Respond with auto reply if other client has it enabled
 356         if len(otherClient.AutoReply) > 0 {
 357                 res = append(res,
 358                         *NewTransaction(
 359                                 TranServerMsg,
 360                                 cc.ID,
 361                                 NewField(FieldData, otherClient.AutoReply),
 362                                 NewField(FieldUserName, otherClient.UserName),
 363                                 NewField(FieldUserID, *otherClient.ID),
 364                                 NewField(FieldOptions, []byte{0, 1}),
 365                         ),
 366                 )
 367         }
 368
 369         res = append(res, cc.NewReply(t))
 370
 371         return res, err
 372 }
 373
 374 func HandleGetFileInfo(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 375         fileName := t.GetField(FieldFileName).Data
 376         filePath := t.GetField(FieldFilePath).Data
 377
 378         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
 379         if err != nil {
 380                 return res, err
 381         }
 382
 383         fw, err := newFileWrapper(cc.Server.FS, fullFilePath, 0)
 384         if err != nil {
 385                 return res, err
 386         }
 387
 388         res = append(res, cc.NewReply(t,
 389                 NewField(FieldFileName, []byte(fw.name)),
 390                 NewField(FieldFileTypeString, fw.ffo.FlatFileInformationFork.friendlyType()),
 391                 NewField(FieldFileCreatorString, fw.ffo.FlatFileInformationFork.friendlyCreator()),
 392                 NewField(FieldFileComment, fw.ffo.FlatFileInformationFork.Comment),
 393                 NewField(FieldFileType, fw.ffo.FlatFileInformationFork.TypeSignature),
 394                 NewField(FieldFileCreateDate, fw.ffo.FlatFileInformationFork.CreateDate),
 395                 NewField(FieldFileModifyDate, fw.ffo.FlatFileInformationFork.ModifyDate),
 396                 NewField(FieldFileSize, fw.totalSize()),
 397         ))
 398         return res, err
 399 }
 400
 401 // HandleSetFileInfo updates a file or folder name and/or comment from the Get Info window
 402 // Fields used in the request:
 403 // * 201        File name
 404 // * 202        File path       Optional
 405 // * 211        File new name   Optional
 406 // * 210        File comment    Optional
 407 // Fields used in the reply:    None
 408 func HandleSetFileInfo(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 409         fileName := t.GetField(FieldFileName).Data
 410         filePath := t.GetField(FieldFilePath).Data
 411
 412         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
 413         if err != nil {
 414                 return res, err
 415         }
 416
 417         fi, err := cc.Server.FS.Stat(fullFilePath)
 418         if err != nil {
 419                 return res, err
 420         }
 421
 422         hlFile, err := newFileWrapper(cc.Server.FS, fullFilePath, 0)
 423         if err != nil {
 424                 return res, err
 425         }
 426         if t.GetField(FieldFileComment).Data != nil {
 427                 switch mode := fi.Mode(); {
 428                 case mode.IsDir():
 429                         if !cc.Authorize(accessSetFolderComment) {
 430                                 res = append(res, cc.NewErrReply(t, "You are not allowed to set comments for folders."))
 431                                 return res, err
 432                         }
 433                 case mode.IsRegular():
 434                         if !cc.Authorize(accessSetFileComment) {
 435                                 res = append(res, cc.NewErrReply(t, "You are not allowed to set comments for files."))
 436                                 return res, err
 437                         }
 438                 }
 439
 440                 if err := hlFile.ffo.FlatFileInformationFork.setComment(t.GetField(FieldFileComment).Data); err != nil {
 441                         return res, err
 442                 }
 443                 w, err := hlFile.infoForkWriter()
 444                 if err != nil {
 445                         return res, err
 446                 }
 447                 _, err = w.Write(hlFile.ffo.FlatFileInformationFork.MarshalBinary())
 448                 if err != nil {
 449                         return res, err
 450                 }
 451         }
 452
 453         fullNewFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, t.GetField(FieldFileNewName).Data)
 454         if err != nil {
 455                 return nil, err
 456         }
 457
 458         fileNewName := t.GetField(FieldFileNewName).Data
 459
 460         if fileNewName != nil {
 461                 switch mode := fi.Mode(); {
 462                 case mode.IsDir():
 463                         if !cc.Authorize(accessRenameFolder) {
 464                                 res = append(res, cc.NewErrReply(t, "You are not allowed to rename folders."))
 465                                 return res, err
 466                         }
 467                         err = os.Rename(fullFilePath, fullNewFilePath)
 468                         if os.IsNotExist(err) {
 469                                 res = append(res, cc.NewErrReply(t, "Cannot rename folder "+string(fileName)+" because it does not exist or cannot be found."))
 470                                 return res, err
 471                         }
 472                 case mode.IsRegular():
 473                         if !cc.Authorize(accessRenameFile) {
 474                                 res = append(res, cc.NewErrReply(t, "You are not allowed to rename files."))
 475                                 return res, err
 476                         }
 477                         fileDir, err := readPath(cc.Server.Config.FileRoot, filePath, []byte{})
 478                         if err != nil {
 479                                 return nil, err
 480                         }
 481                         hlFile.name = string(fileNewName)
 482                         err = hlFile.move(fileDir)
 483                         if os.IsNotExist(err) {
 484                                 res = append(res, cc.NewErrReply(t, "Cannot rename file "+string(fileName)+" because it does not exist or cannot be found."))
 485                                 return res, err
 486                         }
 487                         if err != nil {
 488                                 return res, err
 489                         }
 490                 }
 491         }
 492
 493         res = append(res, cc.NewReply(t))
 494         return res, err
 495 }
 496
 497 // HandleDeleteFile deletes a file or folder
 498 // Fields used in the request:
 499 // * 201        File name
 500 // * 202        File path
 501 // Fields used in the reply: none
 502 func HandleDeleteFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 503         fileName := t.GetField(FieldFileName).Data
 504         filePath := t.GetField(FieldFilePath).Data
 505
 506         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
 507         if err != nil {
 508                 return res, err
 509         }
 510
 511         hlFile, err := newFileWrapper(cc.Server.FS, fullFilePath, 0)
 512         if err != nil {
 513                 return res, err
 514         }
 515
 516         fi, err := hlFile.dataFile()
 517         if err != nil {
 518                 res = append(res, cc.NewErrReply(t, "Cannot delete file "+string(fileName)+" because it does not exist or cannot be found."))
 519                 return res, nil
 520         }
 521
 522         switch mode := fi.Mode(); {
 523         case mode.IsDir():
 524                 if !cc.Authorize(accessDeleteFolder) {
 525                         res = append(res, cc.NewErrReply(t, "You are not allowed to delete folders."))
 526                         return res, err
 527                 }
 528         case mode.IsRegular():
 529                 if !cc.Authorize(accessDeleteFile) {
 530                         res = append(res, cc.NewErrReply(t, "You are not allowed to delete files."))
 531                         return res, err
 532                 }
 533         }
 534
 535         if err := hlFile.delete(); err != nil {
 536                 return res, err
 537         }
 538
 539         res = append(res, cc.NewReply(t))
 540         return res, err
 541 }
 542
 543 // HandleMoveFile moves files or folders. Note: seemingly not documented
 544 func HandleMoveFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 545         fileName := string(t.GetField(FieldFileName).Data)
 546
 547         filePath, err := readPath(cc.Server.Config.FileRoot, t.GetField(FieldFilePath).Data, t.GetField(FieldFileName).Data)
 548         if err != nil {
 549                 return res, err
 550         }
 551
 552         fileNewPath, err := readPath(cc.Server.Config.FileRoot, t.GetField(FieldFileNewPath).Data, nil)
 553         if err != nil {
 554                 return res, err
 555         }
 556
 557         cc.logger.Infow("Move file", "src", filePath+"/"+fileName, "dst", fileNewPath+"/"+fileName)
 558
 559         hlFile, err := newFileWrapper(cc.Server.FS, filePath, 0)
 560         if err != nil {
 561                 return res, err
 562         }
 563
 564         fi, err := hlFile.dataFile()
 565         if err != nil {
 566                 res = append(res, cc.NewErrReply(t, "Cannot delete file "+fileName+" because it does not exist or cannot be found."))
 567                 return res, err
 568         }
 569         if err != nil {
 570                 return res, err
 571         }
 572         switch mode := fi.Mode(); {
 573         case mode.IsDir():
 574                 if !cc.Authorize(accessMoveFolder) {
 575                         res = append(res, cc.NewErrReply(t, "You are not allowed to move folders."))
 576                         return res, err
 577                 }
 578         case mode.IsRegular():
 579                 if !cc.Authorize(accessMoveFile) {
 580                         res = append(res, cc.NewErrReply(t, "You are not allowed to move files."))
 581                         return res, err
 582                 }
 583         }
 584         if err := hlFile.move(fileNewPath); err != nil {
 585                 return res, err
 586         }
 587         // TODO: handle other possible errors; e.g. fileWrapper delete fails due to fileWrapper permission issue
 588
 589         res = append(res, cc.NewReply(t))
 590         return res, err
 591 }
 592
 593 func HandleNewFolder(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 594         if !cc.Authorize(accessCreateFolder) {
 595                 res = append(res, cc.NewErrReply(t, "You are not allowed to create folders."))
 596                 return res, err
 597         }
 598         folderName := string(t.GetField(FieldFileName).Data)
 599
 600         folderName = path.Join("/", folderName)
 601
 602         var subPath string
 603
 604         // FieldFilePath is only present for nested paths
 605         if t.GetField(FieldFilePath).Data != nil {
 606                 var newFp FilePath
 607                 _, err := newFp.Write(t.GetField(FieldFilePath).Data)
 608                 if err != nil {
 609                         return nil, err
 610                 }
 611
 612                 for _, pathItem := range newFp.Items {
 613                         subPath = filepath.Join("/", subPath, string(pathItem.Name))
 614                 }
 615         }
 616         newFolderPath := path.Join(cc.Server.Config.FileRoot, subPath, folderName)
 617
 618         // TODO: check path and folder name lengths
 619
 620         if _, err := cc.Server.FS.Stat(newFolderPath); !os.IsNotExist(err) {
 621                 msg := fmt.Sprintf("Cannot create folder \"%s\" because there is already a file or folder with that name.", folderName)
 622                 return []Transaction{cc.NewErrReply(t, msg)}, nil
 623         }
 624
 625         // TODO: check for disallowed characters to maintain compatibility for original client
 626
 627         if err := cc.Server.FS.Mkdir(newFolderPath, 0777); err != nil {
 628                 msg := fmt.Sprintf("Cannot create folder \"%s\" because an error occurred.", folderName)
 629                 return []Transaction{cc.NewErrReply(t, msg)}, nil
 630         }
 631
 632         res = append(res, cc.NewReply(t))
 633         return res, err
 634 }
 635
 636 func HandleSetUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 637         if !cc.Authorize(accessModifyUser) {
 638                 res = append(res, cc.NewErrReply(t, "You are not allowed to modify accounts."))
 639                 return res, err
 640         }
 641
 642         login := DecodeUserString(t.GetField(FieldUserLogin).Data)
 643         userName := string(t.GetField(FieldUserName).Data)
 644
 645         newAccessLvl := t.GetField(FieldUserAccess).Data
 646
 647         account := cc.Server.Accounts[login]
 648         account.Name = userName
 649         copy(account.Access[:], newAccessLvl)
 650
 651         // If the password field is cleared in the Hotline edit user UI, the SetUser transaction does
 652         // not include FieldUserPassword
 653         if t.GetField(FieldUserPassword).Data == nil {
 654                 account.Password = hashAndSalt([]byte(""))
 655         }
 656         if len(t.GetField(FieldUserPassword).Data) > 1 {
 657                 account.Password = hashAndSalt(t.GetField(FieldUserPassword).Data)
 658         }
 659
 660         out, err := yaml.Marshal(&account)
 661         if err != nil {
 662                 return res, err
 663         }
 664         if err := os.WriteFile(filepath.Join(cc.Server.ConfigDir, "Users", login+".yaml"), out, 0666); err != nil {
 665                 return res, err
 666         }
 667
 668         // Notify connected clients logged in as the user of the new access level
 669         for _, c := range cc.Server.Clients {
 670                 if c.Account.Login == login {
 671                         // Note: comment out these two lines to test server-side deny messages
 672                         newT := NewTransaction(TranUserAccess, c.ID, NewField(FieldUserAccess, newAccessLvl))
 673                         res = append(res, *newT)
 674
 675                         flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(c.Flags)))
 676                         if c.Authorize(accessDisconUser) {
 677                                 flagBitmap.SetBit(flagBitmap, UserFlagAdmin, 1)
 678                         } else {
 679                                 flagBitmap.SetBit(flagBitmap, UserFlagAdmin, 0)
 680                         }
 681                         binary.BigEndian.PutUint16(c.Flags, uint16(flagBitmap.Int64()))
 682
 683                         c.Account.Access = account.Access
 684
 685                         cc.sendAll(
 686                                 TranNotifyChangeUser,
 687                                 NewField(FieldUserID, *c.ID),
 688                                 NewField(FieldUserFlags, c.Flags),
 689                                 NewField(FieldUserName, c.UserName),
 690                                 NewField(FieldUserIconID, c.Icon),
 691                         )
 692                 }
 693         }
 694
 695         res = append(res, cc.NewReply(t))
 696         return res, err
 697 }
 698
 699 func HandleGetUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 700         if !cc.Authorize(accessOpenUser) {
 701                 res = append(res, cc.NewErrReply(t, "You are not allowed to view accounts."))
 702                 return res, err
 703         }
 704
 705         account := cc.Server.Accounts[string(t.GetField(FieldUserLogin).Data)]
 706         if account == nil {
 707                 res = append(res, cc.NewErrReply(t, "Account does not exist."))
 708                 return res, err
 709         }
 710
 711         res = append(res, cc.NewReply(t,
 712                 NewField(FieldUserName, []byte(account.Name)),
 713                 NewField(FieldUserLogin, negateString(t.GetField(FieldUserLogin).Data)),
 714                 NewField(FieldUserPassword, []byte(account.Password)),
 715                 NewField(FieldUserAccess, account.Access[:]),
 716         ))
 717         return res, err
 718 }
 719
 720 func HandleListUsers(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 721         if !cc.Authorize(accessOpenUser) {
 722                 res = append(res, cc.NewErrReply(t, "You are not allowed to view accounts."))
 723                 return res, err
 724         }
 725
 726         var userFields []Field
 727         for _, acc := range cc.Server.Accounts {
 728                 b := make([]byte, 0, 100)
 729                 n, err := acc.Read(b)
 730                 if err != nil {
 731                         return res, err
 732                 }
 733
 734                 userFields = append(userFields, NewField(FieldData, b[:n]))
 735         }
 736
 737         res = append(res, cc.NewReply(t, userFields...))
 738         return res, err
 739 }
 740
 741 // HandleUpdateUser is used by the v1.5+ multi-user editor to perform account editing for multiple users at a time.
 742 // An update can be a mix of these actions:
 743 // * Create user
 744 // * Delete user
 745 // * Modify user (including renaming the account login)
 746 //
 747 // The Transaction sent by the client includes one data field per user that was modified.  This data field in turn
 748 // contains another data field encoded in its payload with a varying number of sub fields depending on which action is
 749 // performed.  This seems to be the only place in the Hotline protocol where a data field contains another data field.
 750 func HandleUpdateUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 751         for _, field := range t.Fields {
 752                 subFields, err := ReadFields(field.Data[0:2], field.Data[2:])
 753                 if err != nil {
 754                         return res, err
 755                 }
 756
 757                 if len(subFields) == 1 {
 758                         login := DecodeUserString(getField(FieldData, &subFields).Data)
 759                         cc.logger.Infow("DeleteUser", "login", login)
 760
 761                         if !cc.Authorize(accessDeleteUser) {
 762                                 res = append(res, cc.NewErrReply(t, "You are not allowed to delete accounts."))
 763                                 return res, err
 764                         }
 765
 766                         if err := cc.Server.DeleteUser(login); err != nil {
 767                                 return res, err
 768                         }
 769                         continue
 770                 }
 771
 772                 login := DecodeUserString(getField(FieldUserLogin, &subFields).Data)
 773
 774                 // check if the login dataFile; if so, we know we are updating an existing user
 775                 if acc, ok := cc.Server.Accounts[login]; ok {
 776                         cc.logger.Infow("UpdateUser", "login", login)
 777
 778                         // account dataFile, so this is an update action
 779                         if !cc.Authorize(accessModifyUser) {
 780                                 res = append(res, cc.NewErrReply(t, "You are not allowed to modify accounts."))
 781                                 return res, err
 782                         }
 783
 784                         if getField(FieldUserPassword, &subFields) != nil {
 785                                 newPass := getField(FieldUserPassword, &subFields).Data
 786                                 acc.Password = hashAndSalt(newPass)
 787                         } else {
 788                                 acc.Password = hashAndSalt([]byte(""))
 789                         }
 790
 791                         if getField(FieldUserAccess, &subFields) != nil {
 792                                 copy(acc.Access[:], getField(FieldUserAccess, &subFields).Data)
 793                         }
 794
 795                         err = cc.Server.UpdateUser(
 796                                 DecodeUserString(getField(FieldData, &subFields).Data),
 797                                 DecodeUserString(getField(FieldUserLogin, &subFields).Data),
 798                                 string(getField(FieldUserName, &subFields).Data),
 799                                 acc.Password,
 800                                 acc.Access,
 801                         )
 802                         if err != nil {
 803                                 return res, err
 804                         }
 805                 } else {
 806                         cc.logger.Infow("CreateUser", "login", login)
 807
 808                         if !cc.Authorize(accessCreateUser) {
 809                                 res = append(res, cc.NewErrReply(t, "You are not allowed to create new accounts."))
 810                                 return res, err
 811                         }
 812
 813                         newAccess := accessBitmap{}
 814                         copy(newAccess[:], getField(FieldUserAccess, &subFields).Data)
 815
 816                         // Prevent account from creating new account with greater permission
 817                         for i := 0; i < 64; i++ {
 818                                 if newAccess.IsSet(i) {
 819                                         if !cc.Authorize(i) {
 820                                                 return append(res, cc.NewErrReply(t, "Cannot create account with more access than yourself.")), err
 821                                         }
 822                                 }
 823                         }
 824
 825                         err := cc.Server.NewUser(login, string(getField(FieldUserName, &subFields).Data), string(getField(FieldUserPassword, &subFields).Data), newAccess)
 826                         if err != nil {
 827                                 return []Transaction{}, err
 828                         }
 829                 }
 830         }
 831
 832         res = append(res, cc.NewReply(t))
 833         return res, err
 834 }
 835
 836 // HandleNewUser creates a new user account
 837 func HandleNewUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 838         if !cc.Authorize(accessCreateUser) {
 839                 res = append(res, cc.NewErrReply(t, "You are not allowed to create new accounts."))
 840                 return res, err
 841         }
 842
 843         login := DecodeUserString(t.GetField(FieldUserLogin).Data)
 844
 845         // If the account already dataFile, reply with an error
 846         if _, ok := cc.Server.Accounts[login]; ok {
 847                 res = append(res, cc.NewErrReply(t, "Cannot create account "+login+" because there is already an account with that login."))
 848                 return res, err
 849         }
 850
 851         newAccess := accessBitmap{}
 852         copy(newAccess[:], t.GetField(FieldUserAccess).Data)
 853
 854         // Prevent account from creating new account with greater permission
 855         for i := 0; i < 64; i++ {
 856                 if newAccess.IsSet(i) {
 857                         if !cc.Authorize(i) {
 858                                 res = append(res, cc.NewErrReply(t, "Cannot create account with more access than yourself."))
 859                                 return res, err
 860                         }
 861                 }
 862         }
 863
 864         if err := cc.Server.NewUser(login, string(t.GetField(FieldUserName).Data), string(t.GetField(FieldUserPassword).Data), newAccess); err != nil {
 865                 return []Transaction{}, err
 866         }
 867
 868         res = append(res, cc.NewReply(t))
 869         return res, err
 870 }
 871
 872 func HandleDeleteUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 873         if !cc.Authorize(accessDeleteUser) {
 874                 res = append(res, cc.NewErrReply(t, "You are not allowed to delete accounts."))
 875                 return res, err
 876         }
 877
 878         // TODO: Handle case where account doesn't exist; e.g. delete race condition
 879         login := DecodeUserString(t.GetField(FieldUserLogin).Data)
 880
 881         if err := cc.Server.DeleteUser(login); err != nil {
 882                 return res, err
 883         }
 884
 885         res = append(res, cc.NewReply(t))
 886         return res, err
 887 }
 888
 889 // HandleUserBroadcast sends an Administrator Message to all connected clients of the server
 890 func HandleUserBroadcast(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 891         if !cc.Authorize(accessBroadcast) {
 892                 res = append(res, cc.NewErrReply(t, "You are not allowed to send broadcast messages."))
 893                 return res, err
 894         }
 895
 896         cc.sendAll(
 897                 TranServerMsg,
 898                 NewField(FieldData, t.GetField(TranGetMsgs).Data),
 899                 NewField(FieldChatOptions, []byte{0}),
 900         )
 901
 902         res = append(res, cc.NewReply(t))
 903         return res, err
 904 }
 905
 906 // HandleGetClientInfoText returns user information for the specific user.
 907 //
 908 // Fields used in the request:
 909 // 103  User ID
 910 //
 911 // Fields used in the reply:
 912 // 102  User name
 913 // 101  Data            User info text string
 914 func HandleGetClientInfoText(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 915         if !cc.Authorize(accessGetClientInfo) {
 916                 res = append(res, cc.NewErrReply(t, "You are not allowed to get client info."))
 917                 return res, err
 918         }
 919
 920         clientID, _ := byteToInt(t.GetField(FieldUserID).Data)
 921
 922         clientConn := cc.Server.Clients[uint16(clientID)]
 923         if clientConn == nil {
 924                 return append(res, cc.NewErrReply(t, "User not found.")), err
 925         }
 926
 927         res = append(res, cc.NewReply(t,
 928                 NewField(FieldData, []byte(clientConn.String())),
 929                 NewField(FieldUserName, clientConn.UserName),
 930         ))
 931         return res, err
 932 }
 933
 934 func HandleGetUserNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 935         res = append(res, cc.NewReply(t, cc.Server.connectedUsers()...))
 936
 937         return res, err
 938 }
 939
 940 func HandleTranAgreed(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 941         if t.GetField(FieldUserName).Data != nil {
 942                 if cc.Authorize(accessAnyName) {
 943                         cc.UserName = t.GetField(FieldUserName).Data
 944                 } else {
 945                         cc.UserName = []byte(cc.Account.Name)
 946                 }
 947         }
 948
 949         cc.Icon = t.GetField(FieldUserIconID).Data
 950
 951         cc.logger = cc.logger.With("name", string(cc.UserName))
 952         cc.logger.Infow("Login successful", "clientVersion", fmt.Sprintf("%v", func() int { i, _ := byteToInt(cc.Version); return i }()))
 953
 954         options := t.GetField(FieldOptions).Data
 955         optBitmap := big.NewInt(int64(binary.BigEndian.Uint16(options)))
 956
 957         flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(cc.Flags)))
 958
 959         // Check refuse private PM option
 960         if optBitmap.Bit(refusePM) == 1 {
 961                 flagBitmap.SetBit(flagBitmap, UserFlagRefusePM, 1)
 962                 binary.BigEndian.PutUint16(cc.Flags, uint16(flagBitmap.Int64()))
 963         }
 964
 965         // Check refuse private chat option
 966         if optBitmap.Bit(refuseChat) == 1 {
 967                 flagBitmap.SetBit(flagBitmap, UserFlagRefusePChat, 1)
 968                 binary.BigEndian.PutUint16(cc.Flags, uint16(flagBitmap.Int64()))
 969         }
 970
 971         // Check auto response
 972         if optBitmap.Bit(autoResponse) == 1 {
 973                 cc.AutoReply = t.GetField(FieldAutomaticResponse).Data
 974         } else {
 975                 cc.AutoReply = []byte{}
 976         }
 977
 978         trans := cc.notifyOthers(
 979                 *NewTransaction(
 980                         TranNotifyChangeUser, nil,
 981                         NewField(FieldUserName, cc.UserName),
 982                         NewField(FieldUserID, *cc.ID),
 983                         NewField(FieldUserIconID, cc.Icon),
 984                         NewField(FieldUserFlags, cc.Flags),
 985                 ),
 986         )
 987         res = append(res, trans...)
 988
 989         if cc.Server.Config.BannerFile != "" {
 990                 res = append(res, *NewTransaction(TranServerBanner, cc.ID, NewField(FieldBannerType, []byte("JPEG"))))
 991         }
 992
 993         res = append(res, cc.NewReply(t))
 994
 995         return res, err
 996 }
 997
 998 // HandleTranOldPostNews updates the flat news
 999 // Fields used in this request:
1000 // 101  Data
1001 func HandleTranOldPostNews(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1002         if !cc.Authorize(accessNewsPostArt) {
1003                 res = append(res, cc.NewErrReply(t, "You are not allowed to post news."))
1004                 return res, err
1005         }
1006
1007         cc.Server.flatNewsMux.Lock()
1008         defer cc.Server.flatNewsMux.Unlock()
1009
1010         newsDateTemplate := defaultNewsDateFormat
1011         if cc.Server.Config.NewsDateFormat != "" {
1012                 newsDateTemplate = cc.Server.Config.NewsDateFormat
1013         }
1014
1015         newsTemplate := defaultNewsTemplate
1016         if cc.Server.Config.NewsDelimiter != "" {
1017                 newsTemplate = cc.Server.Config.NewsDelimiter
1018         }
1019
1020         newsPost := fmt.Sprintf(newsTemplate+"\r", cc.UserName, time.Now().Format(newsDateTemplate), t.GetField(FieldData).Data)
1021         newsPost = strings.ReplaceAll(newsPost, "\n", "\r")
1022
1023         // update news in memory
1024         cc.Server.FlatNews = append([]byte(newsPost), cc.Server.FlatNews...)
1025
1026         // update news on disk
1027         if err := cc.Server.FS.WriteFile(filepath.Join(cc.Server.ConfigDir, "MessageBoard.txt"), cc.Server.FlatNews, 0644); err != nil {
1028                 return res, err
1029         }
1030
1031         // Notify all clients of updated news
1032         cc.sendAll(
1033                 TranNewMsg,
1034                 NewField(FieldData, []byte(newsPost)),
1035         )
1036
1037         res = append(res, cc.NewReply(t))
1038         return res, err
1039 }
1040
1041 func HandleDisconnectUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1042         if !cc.Authorize(accessDisconUser) {
1043                 res = append(res, cc.NewErrReply(t, "You are not allowed to disconnect users."))
1044                 return res, err
1045         }
1046
1047         clientConn := cc.Server.Clients[binary.BigEndian.Uint16(t.GetField(FieldUserID).Data)]
1048
1049         if clientConn.Authorize(accessCannotBeDiscon) {
1050                 res = append(res, cc.NewErrReply(t, clientConn.Account.Login+" is not allowed to be disconnected."))
1051                 return res, err
1052         }
1053
1054         // If FieldOptions is set, then the client IP is banned in addition to disconnected.
1055         // 00 01 = temporary ban
1056         // 00 02 = permanent ban
1057         if t.GetField(FieldOptions).Data != nil {
1058                 switch t.GetField(FieldOptions).Data[1] {
1059                 case 1:
1060                         // send message: "You are temporarily banned on this server"
1061                         cc.logger.Infow("Disconnect & temporarily ban " + string(clientConn.UserName))
1062
1063                         res = append(res, *NewTransaction(
1064                                 TranServerMsg,
1065                                 clientConn.ID,
1066                                 NewField(FieldData, []byte("You are temporarily banned on this server")),
1067                                 NewField(FieldChatOptions, []byte{0, 0}),
1068                         ))
1069
1070                         banUntil := time.Now().Add(tempBanDuration)
1071                         cc.Server.banList[strings.Split(clientConn.RemoteAddr, ":")[0]] = &banUntil
1072                 case 2:
1073                         // send message: "You are permanently banned on this server"
1074                         cc.logger.Infow("Disconnect & ban " + string(clientConn.UserName))
1075
1076                         res = append(res, *NewTransaction(
1077                                 TranServerMsg,
1078                                 clientConn.ID,
1079                                 NewField(FieldData, []byte("You are permanently banned on this server")),
1080                                 NewField(FieldChatOptions, []byte{0, 0}),
1081                         ))
1082
1083                         cc.Server.banList[strings.Split(clientConn.RemoteAddr, ":")[0]] = nil
1084                 }
1085
1086                 err := cc.Server.writeBanList()
1087                 if err != nil {
1088                         return res, err
1089                 }
1090         }
1091
1092         // TODO: remove this awful hack
1093         go func() {
1094                 time.Sleep(1 * time.Second)
1095                 clientConn.Disconnect()
1096         }()
1097
1098         return append(res, cc.NewReply(t)), err
1099 }
1100
1101 // HandleGetNewsCatNameList returns a list of news categories for a path
1102 // Fields used in the request:
1103 // 325  News path       (Optional)
1104 func HandleGetNewsCatNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1105         if !cc.Authorize(accessNewsReadArt) {
1106                 res = append(res, cc.NewErrReply(t, "You are not allowed to read news."))
1107                 return res, err
1108         }
1109
1110         pathStrs := ReadNewsPath(t.GetField(FieldNewsPath).Data)
1111         cats := cc.Server.GetNewsCatByPath(pathStrs)
1112
1113         // To store the keys in slice in sorted order
1114         keys := make([]string, len(cats))
1115         i := 0
1116         for k := range cats {
1117                 keys[i] = k
1118                 i++
1119         }
1120         sort.Strings(keys)
1121
1122         var fieldData []Field
1123         for _, k := range keys {
1124                 cat := cats[k]
1125                 b, _ := cat.MarshalBinary()
1126                 fieldData = append(fieldData, NewField(
1127                         FieldNewsCatListData15,
1128                         b,
1129                 ))
1130         }
1131
1132         res = append(res, cc.NewReply(t, fieldData...))
1133         return res, err
1134 }
1135
1136 func HandleNewNewsCat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1137         if !cc.Authorize(accessNewsCreateCat) {
1138                 res = append(res, cc.NewErrReply(t, "You are not allowed to create news categories."))
1139                 return res, err
1140         }
1141
1142         name := string(t.GetField(FieldNewsCatName).Data)
1143         pathStrs := ReadNewsPath(t.GetField(FieldNewsPath).Data)
1144
1145         cats := cc.Server.GetNewsCatByPath(pathStrs)
1146         cats[name] = NewsCategoryListData15{
1147                 Name:     name,
1148                 Type:     []byte{0, 3},
1149                 Articles: map[uint32]*NewsArtData{},
1150                 SubCats:  make(map[string]NewsCategoryListData15),
1151         }
1152
1153         if err := cc.Server.writeThreadedNews(); err != nil {
1154                 return res, err
1155         }
1156         res = append(res, cc.NewReply(t))
1157         return res, err
1158 }
1159
1160 // Fields used in the request:
1161 // 322  News category name
1162 // 325  News path
1163 func HandleNewNewsFldr(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1164         if !cc.Authorize(accessNewsCreateFldr) {
1165                 res = append(res, cc.NewErrReply(t, "You are not allowed to create news folders."))
1166                 return res, err
1167         }
1168
1169         name := string(t.GetField(FieldFileName).Data)
1170         pathStrs := ReadNewsPath(t.GetField(FieldNewsPath).Data)
1171
1172         cc.logger.Infof("Creating new news folder %s", name)
1173
1174         cats := cc.Server.GetNewsCatByPath(pathStrs)
1175         cats[name] = NewsCategoryListData15{
1176                 Name:     name,
1177                 Type:     []byte{0, 2},
1178                 Articles: map[uint32]*NewsArtData{},
1179                 SubCats:  make(map[string]NewsCategoryListData15),
1180         }
1181         if err := cc.Server.writeThreadedNews(); err != nil {
1182                 return res, err
1183         }
1184         res = append(res, cc.NewReply(t))
1185         return res, err
1186 }
1187
1188 // HandleGetNewsArtData gets the list of article names at the specified news path.
1189
1190 // Fields used in the request:
1191 // 325  News path       Optional
1192
1193 // Fields used in the reply:
1194 // 321  News article list data  Optional
1195 func HandleGetNewsArtNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1196         if !cc.Authorize(accessNewsReadArt) {
1197                 res = append(res, cc.NewErrReply(t, "You are not allowed to read news."))
1198                 return res, err
1199         }
1200         pathStrs := ReadNewsPath(t.GetField(FieldNewsPath).Data)
1201
1202         var cat NewsCategoryListData15
1203         cats := cc.Server.ThreadedNews.Categories
1204
1205         for _, fp := range pathStrs {
1206                 cat = cats[fp]
1207                 cats = cats[fp].SubCats
1208         }
1209
1210         nald := cat.GetNewsArtListData()
1211
1212         res = append(res, cc.NewReply(t, NewField(FieldNewsArtListData, nald.Payload())))
1213         return res, err
1214 }
1215
1216 // HandleGetNewsArtData requests information about the specific news article.
1217 // Fields used in the request:
1218 //
1219 // Request fields
1220 // 325  News path
1221 // 326  News article ID
1222 // 327  News article data flavor
1223 //
1224 // Fields used in the reply:
1225 // 328  News article title
1226 // 329  News article poster
1227 // 330  News article date
1228 // 331  Previous article ID
1229 // 332  Next article ID
1230 // 335  Parent article ID
1231 // 336  First child article ID
1232 // 327  News article data flavor        "Should be “text/plain”
1233 // 333  News article data       Optional (if data flavor is “text/plain”)
1234 func HandleGetNewsArtData(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1235         if !cc.Authorize(accessNewsReadArt) {
1236                 res = append(res, cc.NewErrReply(t, "You are not allowed to read news."))
1237                 return res, err
1238         }
1239
1240         var cat NewsCategoryListData15
1241         cats := cc.Server.ThreadedNews.Categories
1242
1243         for _, fp := range ReadNewsPath(t.GetField(FieldNewsPath).Data) {
1244                 cat = cats[fp]
1245                 cats = cats[fp].SubCats
1246         }
1247
1248         // The official Hotline clients will send the article ID as 2 bytes if possible, but
1249         // some third party clients such as Frogblast and Heildrun will always send 4 bytes
1250         convertedID, err := byteToInt(t.GetField(FieldNewsArtID).Data)
1251         if err != nil {
1252                 return res, err
1253         }
1254
1255         art := cat.Articles[uint32(convertedID)]
1256         if art == nil {
1257                 res = append(res, cc.NewReply(t))
1258                 return res, err
1259         }
1260
1261         res = append(res, cc.NewReply(t,
1262                 NewField(FieldNewsArtTitle, []byte(art.Title)),
1263                 NewField(FieldNewsArtPoster, []byte(art.Poster)),
1264                 NewField(FieldNewsArtDate, art.Date),
1265                 NewField(FieldNewsArtPrevArt, art.PrevArt),
1266                 NewField(FieldNewsArtNextArt, art.NextArt),
1267                 NewField(FieldNewsArtParentArt, art.ParentArt),
1268                 NewField(FieldNewsArt1stChildArt, art.FirstChildArt),
1269                 NewField(FieldNewsArtDataFlav, []byte("text/plain")),
1270                 NewField(FieldNewsArtData, []byte(art.Data)),
1271         ))
1272         return res, err
1273 }
1274
1275 // HandleDelNewsItem deletes an existing threaded news folder or category from the server.
1276 // Fields used in the request:
1277 // 325  News path
1278 // Fields used in the reply:
1279 // None
1280 func HandleDelNewsItem(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1281         pathStrs := ReadNewsPath(t.GetField(FieldNewsPath).Data)
1282
1283         cats := cc.Server.ThreadedNews.Categories
1284         delName := pathStrs[len(pathStrs)-1]
1285         if len(pathStrs) > 1 {
1286                 for _, fp := range pathStrs[0 : len(pathStrs)-1] {
1287                         cats = cats[fp].SubCats
1288                 }
1289         }
1290
1291         if bytes.Equal(cats[delName].Type, []byte{0, 3}) {
1292                 if !cc.Authorize(accessNewsDeleteCat) {
1293                         return append(res, cc.NewErrReply(t, "You are not allowed to delete news categories.")), nil
1294                 }
1295         } else {
1296                 if !cc.Authorize(accessNewsDeleteFldr) {
1297                         return append(res, cc.NewErrReply(t, "You are not allowed to delete news folders.")), nil
1298                 }
1299         }
1300
1301         delete(cats, delName)
1302
1303         if err := cc.Server.writeThreadedNews(); err != nil {
1304                 return res, err
1305         }
1306
1307         return append(res, cc.NewReply(t)), nil
1308 }
1309
1310 func HandleDelNewsArt(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1311         if !cc.Authorize(accessNewsDeleteArt) {
1312                 res = append(res, cc.NewErrReply(t, "You are not allowed to delete news articles."))
1313                 return res, err
1314         }
1315
1316         // Request Fields
1317         // 325  News path
1318         // 326  News article ID
1319         // 337  News article – recursive delete       Delete child articles (1) or not (0)
1320         pathStrs := ReadNewsPath(t.GetField(FieldNewsPath).Data)
1321         ID, err := byteToInt(t.GetField(FieldNewsArtID).Data)
1322         if err != nil {
1323                 return res, err
1324         }
1325
1326         // TODO: Delete recursive
1327         cats := cc.Server.GetNewsCatByPath(pathStrs[:len(pathStrs)-1])
1328
1329         catName := pathStrs[len(pathStrs)-1]
1330         cat := cats[catName]
1331
1332         delete(cat.Articles, uint32(ID))
1333
1334         cats[catName] = cat
1335         if err := cc.Server.writeThreadedNews(); err != nil {
1336                 return res, err
1337         }
1338
1339         res = append(res, cc.NewReply(t))
1340         return res, err
1341 }
1342
1343 // Request fields
1344 // 325  News path
1345 // 326  News article ID                                                 ID of the parent article?
1346 // 328  News article title
1347 // 334  News article flags
1348 // 327  News article data flavor                Currently “text/plain”
1349 // 333  News article data
1350 func HandlePostNewsArt(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1351         if !cc.Authorize(accessNewsPostArt) {
1352                 res = append(res, cc.NewErrReply(t, "You are not allowed to post news articles."))
1353                 return res, err
1354         }
1355
1356         pathStrs := ReadNewsPath(t.GetField(FieldNewsPath).Data)
1357         cats := cc.Server.GetNewsCatByPath(pathStrs[:len(pathStrs)-1])
1358
1359         catName := pathStrs[len(pathStrs)-1]
1360         cat := cats[catName]
1361
1362         artID, err := byteToInt(t.GetField(FieldNewsArtID).Data)
1363         if err != nil {
1364                 return res, err
1365         }
1366         convertedArtID := uint32(artID)
1367         bs := make([]byte, 4)
1368         binary.BigEndian.PutUint32(bs, convertedArtID)
1369
1370         newArt := NewsArtData{
1371                 Title:         string(t.GetField(FieldNewsArtTitle).Data),
1372                 Poster:        string(cc.UserName),
1373                 Date:          toHotlineTime(time.Now()),
1374                 PrevArt:       []byte{0, 0, 0, 0},
1375                 NextArt:       []byte{0, 0, 0, 0},
1376                 ParentArt:     bs,
1377                 FirstChildArt: []byte{0, 0, 0, 0},
1378                 DataFlav:      []byte("text/plain"),
1379                 Data:          string(t.GetField(FieldNewsArtData).Data),
1380         }
1381
1382         var keys []int
1383         for k := range cat.Articles {
1384                 keys = append(keys, int(k))
1385         }
1386
1387         nextID := uint32(1)
1388         if len(keys) > 0 {
1389                 sort.Ints(keys)
1390                 prevID := uint32(keys[len(keys)-1])
1391                 nextID = prevID + 1
1392
1393                 binary.BigEndian.PutUint32(newArt.PrevArt, prevID)
1394
1395                 // Set next article ID
1396                 binary.BigEndian.PutUint32(cat.Articles[prevID].NextArt, nextID)
1397         }
1398
1399         // Update parent article with first child reply
1400         parentID := convertedArtID
1401         if parentID != 0 {
1402                 parentArt := cat.Articles[parentID]
1403
1404                 if bytes.Equal(parentArt.FirstChildArt, []byte{0, 0, 0, 0}) {
1405                         binary.BigEndian.PutUint32(parentArt.FirstChildArt, nextID)
1406                 }
1407         }
1408
1409         cat.Articles[nextID] = &newArt
1410
1411         cats[catName] = cat
1412         if err := cc.Server.writeThreadedNews(); err != nil {
1413                 return res, err
1414         }
1415
1416         res = append(res, cc.NewReply(t))
1417         return res, err
1418 }
1419
1420 // HandleGetMsgs returns the flat news data
1421 func HandleGetMsgs(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1422         if !cc.Authorize(accessNewsReadArt) {
1423                 res = append(res, cc.NewErrReply(t, "You are not allowed to read news."))
1424                 return res, err
1425         }
1426
1427         res = append(res, cc.NewReply(t, NewField(FieldData, cc.Server.FlatNews)))
1428
1429         return res, err
1430 }
1431
1432 func HandleDownloadFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1433         if !cc.Authorize(accessDownloadFile) {
1434                 res = append(res, cc.NewErrReply(t, "You are not allowed to download files."))
1435                 return res, err
1436         }
1437
1438         fileName := t.GetField(FieldFileName).Data
1439         filePath := t.GetField(FieldFilePath).Data
1440         resumeData := t.GetField(FieldFileResumeData).Data
1441
1442         var dataOffset int64
1443         var frd FileResumeData
1444         if resumeData != nil {
1445                 if err := frd.UnmarshalBinary(t.GetField(FieldFileResumeData).Data); err != nil {
1446                         return res, err
1447                 }
1448                 // TODO: handle rsrc fork offset
1449                 dataOffset = int64(binary.BigEndian.Uint32(frd.ForkInfoList[0].DataSize[:]))
1450         }
1451
1452         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
1453         if err != nil {
1454                 return res, err
1455         }
1456
1457         hlFile, err := newFileWrapper(cc.Server.FS, fullFilePath, dataOffset)
1458         if err != nil {
1459                 return res, err
1460         }
1461
1462         xferSize := hlFile.ffo.TransferSize(0)
1463
1464         ft := cc.newFileTransfer(FileDownload, fileName, filePath, xferSize)
1465
1466         // TODO: refactor to remove this
1467         if resumeData != nil {
1468                 var frd FileResumeData
1469                 if err := frd.UnmarshalBinary(t.GetField(FieldFileResumeData).Data); err != nil {
1470                         return res, err
1471                 }
1472                 ft.fileResumeData = &frd
1473         }
1474
1475         // Optional field for when a HL v1.5+ client requests file preview
1476         // Used only for TEXT, JPEG, GIFF, BMP or PICT files
1477         // The value will always be 2
1478         if t.GetField(FieldFileTransferOptions).Data != nil {
1479                 ft.options = t.GetField(FieldFileTransferOptions).Data
1480                 xferSize = hlFile.ffo.FlatFileDataForkHeader.DataSize[:]
1481         }
1482
1483         res = append(res, cc.NewReply(t,
1484                 NewField(FieldRefNum, ft.refNum[:]),
1485                 NewField(FieldWaitingCount, []byte{0x00, 0x00}), // TODO: Implement waiting count
1486                 NewField(FieldTransferSize, xferSize),
1487                 NewField(FieldFileSize, hlFile.ffo.FlatFileDataForkHeader.DataSize[:]),
1488         ))
1489
1490         return res, err
1491 }
1492
1493 // Download all files from the specified folder and sub-folders
1494 func HandleDownloadFolder(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1495         if !cc.Authorize(accessDownloadFile) {
1496                 res = append(res, cc.NewErrReply(t, "You are not allowed to download folders."))
1497                 return res, err
1498         }
1499
1500         fullFilePath, err := readPath(cc.Server.Config.FileRoot, t.GetField(FieldFilePath).Data, t.GetField(FieldFileName).Data)
1501         if err != nil {
1502                 return res, err
1503         }
1504
1505         transferSize, err := CalcTotalSize(fullFilePath)
1506         if err != nil {
1507                 return res, err
1508         }
1509         itemCount, err := CalcItemCount(fullFilePath)
1510         if err != nil {
1511                 return res, err
1512         }
1513
1514         fileTransfer := cc.newFileTransfer(FolderDownload, t.GetField(FieldFileName).Data, t.GetField(FieldFilePath).Data, transferSize)
1515
1516         var fp FilePath
1517         _, err = fp.Write(t.GetField(FieldFilePath).Data)
1518         if err != nil {
1519                 return res, err
1520         }
1521
1522         res = append(res, cc.NewReply(t,
1523                 NewField(FieldRefNum, fileTransfer.ReferenceNumber),
1524                 NewField(FieldTransferSize, transferSize),
1525                 NewField(FieldFolderItemCount, itemCount),
1526                 NewField(FieldWaitingCount, []byte{0x00, 0x00}), // TODO: Implement waiting count
1527         ))
1528         return res, err
1529 }
1530
1531 // Upload all files from the local folder and its subfolders to the specified path on the server
1532 // Fields used in the request
1533 // 201  File name
1534 // 202  File path
1535 // 108  transfer size   Total size of all items in the folder
1536 // 220  Folder item count
1537 // 204  File transfer options   "Optional Currently set to 1" (TODO: ??)
1538 func HandleUploadFolder(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1539         var fp FilePath
1540         if t.GetField(FieldFilePath).Data != nil {
1541                 if _, err = fp.Write(t.GetField(FieldFilePath).Data); err != nil {
1542                         return res, err
1543                 }
1544         }
1545
1546         // Handle special cases for Upload and Drop Box folders
1547         if !cc.Authorize(accessUploadAnywhere) {
1548                 if !fp.IsUploadDir() && !fp.IsDropbox() {
1549                         res = append(res, cc.NewErrReply(t, fmt.Sprintf("Cannot accept upload of the folder \"%v\" because you are only allowed to upload to the \"Uploads\" folder.", string(t.GetField(FieldFileName).Data))))
1550                         return res, err
1551                 }
1552         }
1553
1554         fileTransfer := cc.newFileTransfer(FolderUpload,
1555                 t.GetField(FieldFileName).Data,
1556                 t.GetField(FieldFilePath).Data,
1557                 t.GetField(FieldTransferSize).Data,
1558         )
1559
1560         fileTransfer.FolderItemCount = t.GetField(FieldFolderItemCount).Data
1561
1562         res = append(res, cc.NewReply(t, NewField(FieldRefNum, fileTransfer.ReferenceNumber)))
1563         return res, err
1564 }
1565
1566 // HandleUploadFile
1567 // Fields used in the request:
1568 // 201  File name
1569 // 202  File path
1570 // 204  File transfer options   "Optional
1571 // Used only to resume download, currently has value 2"
1572 // 108  File transfer size      "Optional used if download is not resumed"
1573 func HandleUploadFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1574         if !cc.Authorize(accessUploadFile) {
1575                 res = append(res, cc.NewErrReply(t, "You are not allowed to upload files."))
1576                 return res, err
1577         }
1578
1579         fileName := t.GetField(FieldFileName).Data
1580         filePath := t.GetField(FieldFilePath).Data
1581         transferOptions := t.GetField(FieldFileTransferOptions).Data
1582         transferSize := t.GetField(FieldTransferSize).Data // not sent for resume
1583
1584         var fp FilePath
1585         if filePath != nil {
1586                 if _, err = fp.Write(filePath); err != nil {
1587                         return res, err
1588                 }
1589         }
1590
1591         // Handle special cases for Upload and Drop Box folders
1592         if !cc.Authorize(accessUploadAnywhere) {
1593                 if !fp.IsUploadDir() && !fp.IsDropbox() {
1594                         res = append(res, cc.NewErrReply(t, fmt.Sprintf("Cannot accept upload of the file \"%v\" because you are only allowed to upload to the \"Uploads\" folder.", string(fileName))))
1595                         return res, err
1596                 }
1597         }
1598         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
1599         if err != nil {
1600                 return res, err
1601         }
1602
1603         if _, err := cc.Server.FS.Stat(fullFilePath); err == nil {
1604                 res = append(res, cc.NewErrReply(t, fmt.Sprintf("Cannot accept upload because there is already a file named \"%v\".  Try choosing a different name.", string(fileName))))
1605                 return res, err
1606         }
1607
1608         ft := cc.newFileTransfer(FileUpload, fileName, filePath, transferSize)
1609
1610         replyT := cc.NewReply(t, NewField(FieldRefNum, ft.ReferenceNumber))
1611
1612         // client has requested to resume a partially transferred file
1613         if transferOptions != nil {
1614                 fileInfo, err := cc.Server.FS.Stat(fullFilePath + incompleteFileSuffix)
1615                 if err != nil {
1616                         return res, err
1617                 }
1618
1619                 offset := make([]byte, 4)
1620                 binary.BigEndian.PutUint32(offset, uint32(fileInfo.Size()))
1621
1622                 fileResumeData := NewFileResumeData([]ForkInfoList{
1623                         *NewForkInfoList(offset),
1624                 })
1625
1626                 b, _ := fileResumeData.BinaryMarshal()
1627
1628                 ft.TransferSize = offset
1629
1630                 replyT.Fields = append(replyT.Fields, NewField(FieldFileResumeData, b))
1631         }
1632
1633         res = append(res, replyT)
1634         return res, err
1635 }
1636
1637 func HandleSetClientUserInfo(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1638         if len(t.GetField(FieldUserIconID).Data) == 4 {
1639                 cc.Icon = t.GetField(FieldUserIconID).Data[2:]
1640         } else {
1641                 cc.Icon = t.GetField(FieldUserIconID).Data
1642         }
1643         if cc.Authorize(accessAnyName) {
1644                 cc.UserName = t.GetField(FieldUserName).Data
1645         }
1646
1647         // the options field is only passed by the client versions > 1.2.3.
1648         options := t.GetField(FieldOptions).Data
1649         if options != nil {
1650                 optBitmap := big.NewInt(int64(binary.BigEndian.Uint16(options)))
1651                 flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(cc.Flags)))
1652
1653                 flagBitmap.SetBit(flagBitmap, UserFlagRefusePM, optBitmap.Bit(refusePM))
1654                 binary.BigEndian.PutUint16(cc.Flags, uint16(flagBitmap.Int64()))
1655
1656                 flagBitmap.SetBit(flagBitmap, UserFlagRefusePChat, optBitmap.Bit(refuseChat))
1657                 binary.BigEndian.PutUint16(cc.Flags, uint16(flagBitmap.Int64()))
1658
1659                 // Check auto response
1660                 if optBitmap.Bit(autoResponse) == 1 {
1661                         cc.AutoReply = t.GetField(FieldAutomaticResponse).Data
1662                 } else {
1663                         cc.AutoReply = []byte{}
1664                 }
1665         }
1666
1667         for _, c := range sortedClients(cc.Server.Clients) {
1668                 res = append(res, *NewTransaction(
1669                         TranNotifyChangeUser,
1670                         c.ID,
1671                         NewField(FieldUserID, *cc.ID),
1672                         NewField(FieldUserIconID, cc.Icon),
1673                         NewField(FieldUserFlags, cc.Flags),
1674                         NewField(FieldUserName, cc.UserName),
1675                 ))
1676         }
1677
1678         return res, err
1679 }
1680
1681 // HandleKeepAlive responds to keepalive transactions with an empty reply
1682 // * HL 1.9.2 Client sends keepalive msg every 3 minutes
1683 // * HL 1.2.3 Client doesn't send keepalives
1684 func HandleKeepAlive(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1685         res = append(res, cc.NewReply(t))
1686
1687         return res, err
1688 }
1689
1690 func HandleGetFileNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1691         fullPath, err := readPath(
1692                 cc.Server.Config.FileRoot,
1693                 t.GetField(FieldFilePath).Data,
1694                 nil,
1695         )
1696         if err != nil {
1697                 return res, err
1698         }
1699
1700         var fp FilePath
1701         if t.GetField(FieldFilePath).Data != nil {
1702                 if _, err = fp.Write(t.GetField(FieldFilePath).Data); err != nil {
1703                         return res, err
1704                 }
1705         }
1706
1707         // Handle special case for drop box folders
1708         if fp.IsDropbox() && !cc.Authorize(accessViewDropBoxes) {
1709                 res = append(res, cc.NewErrReply(t, "You are not allowed to view drop boxes."))
1710                 return res, err
1711         }
1712
1713         fileNames, err := getFileNameList(fullPath, cc.Server.Config.IgnoreFiles)
1714         if err != nil {
1715                 return res, err
1716         }
1717
1718         res = append(res, cc.NewReply(t, fileNames...))
1719
1720         return res, err
1721 }
1722
1723 // =================================
1724 //     Hotline private chat flow
1725 // =================================
1726 // 1. ClientA sends TranInviteNewChat to server with user ID to invite
1727 // 2. Server creates new ChatID
1728 // 3. Server sends TranInviteToChat to invitee
1729 // 4. Server replies to ClientA with new Chat ID
1730 //
1731 // A dialog box pops up in the invitee client with options to accept or decline the invitation.
1732 // If Accepted is clicked:
1733 // 1. ClientB sends TranJoinChat with FieldChatID
1734
1735 // HandleInviteNewChat invites users to new private chat
1736 func HandleInviteNewChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1737         if !cc.Authorize(accessOpenChat) {
1738                 res = append(res, cc.NewErrReply(t, "You are not allowed to request private chat."))
1739                 return res, err
1740         }
1741
1742         // Client to Invite
1743         targetID := t.GetField(FieldUserID).Data
1744         newChatID := cc.Server.NewPrivateChat(cc)
1745
1746         // Check if target user has "Refuse private chat" flag
1747         binary.BigEndian.Uint16(targetID)
1748         targetClient := cc.Server.Clients[binary.BigEndian.Uint16(targetID)]
1749
1750         flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(targetClient.Flags)))
1751         if flagBitmap.Bit(UserFlagRefusePChat) == 1 {
1752                 res = append(res,
1753                         *NewTransaction(
1754                                 TranServerMsg,
1755                                 cc.ID,
1756                                 NewField(FieldData, []byte(string(targetClient.UserName)+" does not accept private chats.")),
1757                                 NewField(FieldUserName, targetClient.UserName),
1758                                 NewField(FieldUserID, *targetClient.ID),
1759                                 NewField(FieldOptions, []byte{0, 2}),
1760                         ),
1761                 )
1762         } else {
1763                 res = append(res,
1764                         *NewTransaction(
1765                                 TranInviteToChat,
1766                                 &targetID,
1767                                 NewField(FieldChatID, newChatID),
1768                                 NewField(FieldUserName, cc.UserName),
1769                                 NewField(FieldUserID, *cc.ID),
1770                         ),
1771                 )
1772         }
1773
1774         res = append(res,
1775                 cc.NewReply(t,
1776                         NewField(FieldChatID, newChatID),
1777                         NewField(FieldUserName, cc.UserName),
1778                         NewField(FieldUserID, *cc.ID),
1779                         NewField(FieldUserIconID, cc.Icon),
1780                         NewField(FieldUserFlags, cc.Flags),
1781                 ),
1782         )
1783
1784         return res, err
1785 }
1786
1787 func HandleInviteToChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1788         if !cc.Authorize(accessOpenChat) {
1789                 res = append(res, cc.NewErrReply(t, "You are not allowed to request private chat."))
1790                 return res, err
1791         }
1792
1793         // Client to Invite
1794         targetID := t.GetField(FieldUserID).Data
1795         chatID := t.GetField(FieldChatID).Data
1796
1797         res = append(res,
1798                 *NewTransaction(
1799                         TranInviteToChat,
1800                         &targetID,
1801                         NewField(FieldChatID, chatID),
1802                         NewField(FieldUserName, cc.UserName),
1803                         NewField(FieldUserID, *cc.ID),
1804                 ),
1805         )
1806         res = append(res,
1807                 cc.NewReply(
1808                         t,
1809                         NewField(FieldChatID, chatID),
1810                         NewField(FieldUserName, cc.UserName),
1811                         NewField(FieldUserID, *cc.ID),
1812                         NewField(FieldUserIconID, cc.Icon),
1813                         NewField(FieldUserFlags, cc.Flags),
1814                 ),
1815         )
1816
1817         return res, err
1818 }
1819
1820 func HandleRejectChatInvite(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1821         chatID := t.GetField(FieldChatID).Data
1822         chatInt := binary.BigEndian.Uint32(chatID)
1823
1824         privChat := cc.Server.PrivateChats[chatInt]
1825
1826         resMsg := append(cc.UserName, []byte(" declined invitation to chat")...)
1827
1828         for _, c := range sortedClients(privChat.ClientConn) {
1829                 res = append(res,
1830                         *NewTransaction(
1831                                 TranChatMsg,
1832                                 c.ID,
1833                                 NewField(FieldChatID, chatID),
1834                                 NewField(FieldData, resMsg),
1835                         ),
1836                 )
1837         }
1838
1839         return res, err
1840 }
1841
1842 // HandleJoinChat is sent from a v1.8+ Hotline client when the joins a private chat
1843 // Fields used in the reply:
1844 // * 115        Chat subject
1845 // * 300        User name with info (Optional)
1846 // * 300        (more user names with info)
1847 func HandleJoinChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1848         chatID := t.GetField(FieldChatID).Data
1849         chatInt := binary.BigEndian.Uint32(chatID)
1850
1851         privChat := cc.Server.PrivateChats[chatInt]
1852
1853         // Send TranNotifyChatChangeUser to current members of the chat to inform of new user
1854         for _, c := range sortedClients(privChat.ClientConn) {
1855                 res = append(res,
1856                         *NewTransaction(
1857                                 TranNotifyChatChangeUser,
1858                                 c.ID,
1859                                 NewField(FieldChatID, chatID),
1860                                 NewField(FieldUserName, cc.UserName),
1861                                 NewField(FieldUserID, *cc.ID),
1862                                 NewField(FieldUserIconID, cc.Icon),
1863                                 NewField(FieldUserFlags, cc.Flags),
1864                         ),
1865                 )
1866         }
1867
1868         privChat.ClientConn[cc.uint16ID()] = cc
1869
1870         replyFields := []Field{NewField(FieldChatSubject, []byte(privChat.Subject))}
1871         for _, c := range sortedClients(privChat.ClientConn) {
1872                 user := User{
1873                         ID:    *c.ID,
1874                         Icon:  c.Icon,
1875                         Flags: c.Flags,
1876                         Name:  string(c.UserName),
1877                 }
1878
1879                 replyFields = append(replyFields, NewField(FieldUsernameWithInfo, user.Payload()))
1880         }
1881
1882         res = append(res, cc.NewReply(t, replyFields...))
1883         return res, err
1884 }
1885
1886 // HandleLeaveChat is sent from a v1.8+ Hotline client when the user exits a private chat
1887 // Fields used in the request:
1888 //   - 114      FieldChatID
1889 //
1890 // Reply is not expected.
1891 func HandleLeaveChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1892         chatID := t.GetField(FieldChatID).Data
1893         chatInt := binary.BigEndian.Uint32(chatID)
1894
1895         privChat, ok := cc.Server.PrivateChats[chatInt]
1896         if !ok {
1897                 return res, nil
1898         }
1899
1900         delete(privChat.ClientConn, cc.uint16ID())
1901
1902         // Notify members of the private chat that the user has left
1903         for _, c := range sortedClients(privChat.ClientConn) {
1904                 res = append(res,
1905                         *NewTransaction(
1906                                 TranNotifyChatDeleteUser,
1907                                 c.ID,
1908                                 NewField(FieldChatID, chatID),
1909                                 NewField(FieldUserID, *cc.ID),
1910                         ),
1911                 )
1912         }
1913
1914         return res, err
1915 }
1916
1917 // HandleSetChatSubject is sent from a v1.8+ Hotline client when the user sets a private chat subject
1918 // Fields used in the request:
1919 // * 114        Chat ID
1920 // * 115        Chat subject
1921 // Reply is not expected.
1922 func HandleSetChatSubject(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1923         chatID := t.GetField(FieldChatID).Data
1924         chatInt := binary.BigEndian.Uint32(chatID)
1925
1926         privChat := cc.Server.PrivateChats[chatInt]
1927         privChat.Subject = string(t.GetField(FieldChatSubject).Data)
1928
1929         for _, c := range sortedClients(privChat.ClientConn) {
1930                 res = append(res,
1931                         *NewTransaction(
1932                                 TranNotifyChatSubject,
1933                                 c.ID,
1934                                 NewField(FieldChatID, chatID),
1935                                 NewField(FieldChatSubject, t.GetField(FieldChatSubject).Data),
1936                         ),
1937                 )
1938         }
1939
1940         return res, err
1941 }
1942
1943 // HandleMakeAlias makes a file alias using the specified path.
1944 // Fields used in the request:
1945 // 201  File name
1946 // 202  File path
1947 // 212  File new path   Destination path
1948 //
1949 // Fields used in the reply:
1950 // None
1951 func HandleMakeAlias(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1952         if !cc.Authorize(accessMakeAlias) {
1953                 res = append(res, cc.NewErrReply(t, "You are not allowed to make aliases."))
1954                 return res, err
1955         }
1956         fileName := t.GetField(FieldFileName).Data
1957         filePath := t.GetField(FieldFilePath).Data
1958         fileNewPath := t.GetField(FieldFileNewPath).Data
1959
1960         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
1961         if err != nil {
1962                 return res, err
1963         }
1964
1965         fullNewFilePath, err := readPath(cc.Server.Config.FileRoot, fileNewPath, fileName)
1966         if err != nil {
1967                 return res, err
1968         }
1969
1970         cc.logger.Debugw("Make alias", "src", fullFilePath, "dst", fullNewFilePath)
1971
1972         if err := cc.Server.FS.Symlink(fullFilePath, fullNewFilePath); err != nil {
1973                 res = append(res, cc.NewErrReply(t, "Error creating alias"))
1974                 return res, nil
1975         }
1976
1977         res = append(res, cc.NewReply(t))
1978         return res, err
1979 }
1980
1981 // HandleDownloadBanner handles requests for a new banner from the server
1982 // Fields used in the request:
1983 // None
1984 // Fields used in the reply:
1985 // 107  FieldRefNum                     Used later for transfer
1986 // 108  FieldTransferSize       Size of data to be downloaded
1987 func HandleDownloadBanner(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1988         fi, err := cc.Server.FS.Stat(filepath.Join(cc.Server.ConfigDir, cc.Server.Config.BannerFile))
1989         if err != nil {
1990                 return res, err
1991         }
1992
1993         ft := cc.newFileTransfer(bannerDownload, []byte{}, []byte{}, make([]byte, 4))
1994
1995         binary.BigEndian.PutUint32(ft.TransferSize, uint32(fi.Size()))
1996
1997         res = append(res, cc.NewReply(t,
1998                 NewField(FieldRefNum, ft.refNum[:]),
1999                 NewField(FieldTransferSize, ft.TransferSize),
2000         ))
2001
2002         return res, err
2003 }