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