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.v2"
   9         "io/ioutil"
  10         "math/big"
  11         "os"
  12         "path"
  13         "sort"
  14         "strings"
  15         "time"
  16 )
  17
  18 type TransactionType struct {
  19         Access         int                                                    // Specifies access privilege required to perform the transaction
  20         DenyMsg        string                                                 // The error reply message when user does not have access
  21         Handler        func(*ClientConn, *Transaction) ([]Transaction, error) // 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                 Handler: HandleChatSend,
  53                 Name:    "tranChatSend",
  54                 RequiredFields: []requiredField{
  55                         {
  56                                 ID:     fieldData,
  57                                 minLen: 0,
  58                         },
  59                 },
  60         },
  61         tranDelNewsArt: {
  62                 Access:  accessNewsDeleteArt,
  63                 DenyMsg: "You are not allowed to delete news articles.",
  64                 Name:    "tranDelNewsArt",
  65                 Handler: HandleDelNewsArt,
  66         },
  67         tranDelNewsItem: {
  68                 // Has multiple access flags: News Delete Folder (37) or News Delete Category (35)
  69                 // TODO: Implement inside the handler
  70                 Name:    "tranDelNewsItem",
  71                 Handler: HandleDelNewsItem,
  72         },
  73         tranDeleteFile: {
  74                 Name:    "tranDeleteFile",
  75                 Handler: HandleDeleteFile,
  76         },
  77         tranDeleteUser: {
  78                 Name:    "tranDeleteUser",
  79                 Handler: HandleDeleteUser,
  80         },
  81         tranDisconnectUser: {
  82                 Access:  accessDisconUser,
  83                 DenyMsg: "You are not allowed to disconnect users.",
  84                 Name:    "tranDisconnectUser",
  85                 Handler: HandleDisconnectUser,
  86         },
  87         tranDownloadFile: {
  88                 Access:  accessDownloadFile,
  89                 DenyMsg: "You are not allowed to download files.",
  90                 Name:    "tranDownloadFile",
  91                 Handler: HandleDownloadFile,
  92         },
  93         tranDownloadFldr: {
  94                 Access:  accessDownloadFile, // There is no specific access flag for folder vs file download
  95                 DenyMsg: "You are not allowed to download files.",
  96                 Name:    "tranDownloadFldr",
  97                 Handler: HandleDownloadFolder,
  98         },
  99         tranGetClientInfoText: {
 100                 Access:  accessGetClientInfo,
 101                 DenyMsg: "You are not allowed to get client info",
 102                 Name:    "tranGetClientInfoText",
 103                 Handler: HandleGetClientConnInfoText,
 104         },
 105         tranGetFileInfo: {
 106                 Name:    "tranGetFileInfo",
 107                 Handler: HandleGetFileInfo,
 108         },
 109         tranGetFileNameList: {
 110                 Name:    "tranGetFileNameList",
 111                 Handler: HandleGetFileNameList,
 112         },
 113         tranGetMsgs: {
 114                 Access:  accessNewsReadArt,
 115                 DenyMsg: "You are not allowed to read news.",
 116                 Name:    "tranGetMsgs",
 117                 Handler: HandleGetMsgs,
 118         },
 119         tranGetNewsArtData: {
 120                 Access:  accessNewsReadArt,
 121                 DenyMsg: "You are not allowed to read news.",
 122                 Name:    "tranGetNewsArtData",
 123                 Handler: HandleGetNewsArtData,
 124         },
 125         tranGetNewsArtNameList: {
 126                 Access:  accessNewsReadArt,
 127                 DenyMsg: "You are not allowed to read news.",
 128                 Name:    "tranGetNewsArtNameList",
 129                 Handler: HandleGetNewsArtNameList,
 130         },
 131         tranGetNewsCatNameList: {
 132                 Access:  accessNewsReadArt,
 133                 DenyMsg: "You are not allowed to read news.",
 134                 Name:    "tranGetNewsCatNameList",
 135                 Handler: HandleGetNewsCatNameList,
 136         },
 137         tranGetUser: {
 138                 DenyMsg: "You are not allowed to view accounts.",
 139                 Name:    "tranGetUser",
 140                 Handler: HandleGetUser,
 141         },
 142         tranGetUserNameList: {
 143                 Name:    "tranHandleGetUserNameList",
 144                 Handler: HandleGetUserNameList,
 145         },
 146         tranInviteNewChat: {
 147                 Access:  accessOpenChat,
 148                 DenyMsg: "You are not allowed to request private chat.",
 149                 Name:    "tranInviteNewChat",
 150                 Handler: HandleInviteNewChat,
 151         },
 152         tranInviteToChat: {
 153                 Access:  accessOpenChat,
 154                 DenyMsg: "You are not allowed to request private chat.",
 155                 Name:    "tranInviteToChat",
 156                 Handler: HandleInviteToChat,
 157         },
 158         tranJoinChat: {
 159                 Name:    "tranJoinChat",
 160                 Handler: HandleJoinChat,
 161         },
 162         tranKeepAlive: {
 163                 Name:    "tranKeepAlive",
 164                 Handler: HandleKeepAlive,
 165         },
 166         tranLeaveChat: {
 167                 Name:    "tranJoinChat",
 168                 Handler: HandleLeaveChat,
 169         },
 170
 171         tranListUsers: {
 172                 Access:  accessOpenUser,
 173                 DenyMsg: "You are not allowed to view accounts.",
 174                 Name:    "tranListUsers",
 175                 Handler: HandleListUsers,
 176         },
 177         tranMoveFile: {
 178                 Access:  accessMoveFile,
 179                 DenyMsg: "You are not allowed to move files.",
 180                 Name:    "tranMoveFile",
 181                 Handler: HandleMoveFile,
 182         },
 183         tranNewFolder: {
 184                 Access:  accessCreateFolder,
 185                 DenyMsg: "You are not allow to create folders.",
 186                 Name:    "tranNewFolder",
 187                 Handler: HandleNewFolder,
 188         },
 189         tranNewNewsCat: {
 190                 Access:  accessNewsCreateCat,
 191                 DenyMsg: "You are not allowed to create news categories.",
 192                 Name:    "tranNewNewsCat",
 193                 Handler: HandleNewNewsCat,
 194         },
 195         tranNewNewsFldr: {
 196                 Access:  accessNewsCreateFldr,
 197                 DenyMsg: "You are not allowed to create news folders.",
 198                 Name:    "tranNewNewsFldr",
 199                 Handler: HandleNewNewsFldr,
 200         },
 201         tranNewUser: {
 202                 Access:  accessCreateUser,
 203                 DenyMsg: "You are not allowed to create new accounts.",
 204                 Name:    "tranNewUser",
 205                 Handler: HandleNewUser,
 206         },
 207         tranOldPostNews: {
 208                 Access:  accessNewsPostArt,
 209                 DenyMsg: "You are not allowed to post news.",
 210                 Name:    "tranOldPostNews",
 211                 Handler: HandleTranOldPostNews,
 212         },
 213         tranPostNewsArt: {
 214                 Access:  accessNewsPostArt,
 215                 DenyMsg: "You are not allowed to post news articles.",
 216                 Name:    "tranPostNewsArt",
 217                 Handler: HandlePostNewsArt,
 218         },
 219         tranRejectChatInvite: {
 220                 Name:    "tranRejectChatInvite",
 221                 Handler: HandleRejectChatInvite,
 222         },
 223         tranSendInstantMsg: {
 224                 Access: accessAlwaysAllow,
 225                 // Access: accessSendPrivMsg,
 226                 // DenyMsg: "You are not allowed to send private messages",
 227                 Name:    "tranSendInstantMsg",
 228                 Handler: HandleSendInstantMsg,
 229                 RequiredFields: []requiredField{
 230                         {
 231                                 ID:     fieldData,
 232                                 minLen: 0,
 233                         },
 234                         {
 235                                 ID: fieldUserID,
 236                         },
 237                 },
 238         },
 239         tranSetChatSubject: {
 240                 Name:    "tranSetChatSubject",
 241                 Handler: HandleSetChatSubject,
 242         },
 243         tranMakeFileAlias: {
 244                 Name:    "tranMakeFileAlias",
 245                 Handler: HandleMakeAlias,
 246                 RequiredFields: []requiredField{
 247                         {ID: fieldFileName, minLen: 1},
 248                         {ID: fieldFilePath, minLen: 1},
 249                         {ID: fieldFileNewPath, minLen: 1},
 250                 },
 251         },
 252         tranSetClientUserInfo: {
 253                 Name:    "tranSetClientUserInfo",
 254                 Handler: HandleSetClientUserInfo,
 255         },
 256         tranSetFileInfo: {
 257                 Name:    "tranSetFileInfo",
 258                 Handler: HandleSetFileInfo,
 259         },
 260         tranSetUser: {
 261                 Access:  accessModifyUser,
 262                 DenyMsg: "You are not allowed to modify accounts.",
 263                 Name:    "tranSetUser",
 264                 Handler: HandleSetUser,
 265         },
 266         tranUploadFile: {
 267                 Name:    "tranUploadFile",
 268                 Handler: HandleUploadFile,
 269         },
 270         tranUploadFldr: {
 271                 Name:    "tranUploadFldr",
 272                 Handler: HandleUploadFolder,
 273         },
 274         tranUserBroadcast: {
 275                 Access:  accessBroadcast,
 276                 DenyMsg: "You are not allowed to send broadcast messages.",
 277                 Name:    "tranUserBroadcast",
 278                 Handler: HandleUserBroadcast,
 279         },
 280 }
 281
 282 func HandleChatSend(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 283         if !authorize(cc.Account.Access, accessSendChat) {
 284                 res = append(res, cc.NewErrReply(t, "You are not allowed to participate in chat."))
 285                 return res, err
 286         }
 287
 288         // Truncate long usernames
 289         trunc := fmt.Sprintf("%13s", cc.UserName)
 290         formattedMsg := fmt.Sprintf("\r%.14s:  %s", trunc, t.GetField(fieldData).Data)
 291
 292         // By holding the option key, Hotline chat allows users to send /me formatted messages like:
 293         // *** Halcyon does stuff
 294         // This is indicated by the presence of the optional field fieldChatOptions in the transaction payload
 295         if t.GetField(fieldChatOptions).Data != nil {
 296                 formattedMsg = fmt.Sprintf("\r*** %s %s", cc.UserName, t.GetField(fieldData).Data)
 297         }
 298
 299         if bytes.Equal(t.GetField(fieldData).Data, []byte("/stats")) {
 300                 formattedMsg = strings.Replace(cc.Server.Stats.String(), "\n", "\r", -1)
 301         }
 302
 303         chatID := t.GetField(fieldChatID).Data
 304         // a non-nil chatID indicates the message belongs to a private chat
 305         if chatID != nil {
 306                 chatInt := binary.BigEndian.Uint32(chatID)
 307                 privChat := cc.Server.PrivateChats[chatInt]
 308
 309                 // send the message to all connected clients of the private chat
 310                 for _, c := range privChat.ClientConn {
 311                         res = append(res, *NewTransaction(
 312                                 tranChatMsg,
 313                                 c.ID,
 314                                 NewField(fieldChatID, chatID),
 315                                 NewField(fieldData, []byte(formattedMsg)),
 316                         ))
 317                 }
 318                 return res, err
 319         }
 320
 321         for _, c := range sortedClients(cc.Server.Clients) {
 322                 // Filter out clients that do not have the read chat permission
 323                 if authorize(c.Account.Access, accessReadChat) {
 324                         res = append(res, *NewTransaction(tranChatMsg, c.ID, NewField(fieldData, []byte(formattedMsg))))
 325                 }
 326         }
 327
 328         return res, err
 329 }
 330
 331 // HandleSendInstantMsg sends instant message to the user on the current server.
 332 // Fields used in the request:
 333 //      103     User ID
 334 //      113     Options
 335 //              One of the following values:
 336 //              - User message (myOpt_UserMessage = 1)
 337 //              - Refuse message (myOpt_RefuseMessage = 2)
 338 //              - Refuse chat (myOpt_RefuseChat  = 3)
 339 //              - Automatic response (myOpt_AutomaticResponse = 4)"
 340 //      101     Data    Optional
 341 //      214     Quoting message Optional
 342 //
 343 // Fields used in the reply:
 344 // None
 345 func HandleSendInstantMsg(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 346         msg := t.GetField(fieldData)
 347         ID := t.GetField(fieldUserID)
 348         // TODO: Implement reply quoting
 349         // options := transaction.GetField(hotline.fieldOptions)
 350
 351         res = append(res,
 352                 *NewTransaction(
 353                         tranServerMsg,
 354                         &ID.Data,
 355                         NewField(fieldData, msg.Data),
 356                         NewField(fieldUserName, cc.UserName),
 357                         NewField(fieldUserID, *cc.ID),
 358                         NewField(fieldOptions, []byte{0, 1}),
 359                 ),
 360         )
 361         id, _ := byteToInt(ID.Data)
 362
 363         otherClient := cc.Server.Clients[uint16(id)]
 364         if otherClient == nil {
 365                 return res, errors.New("ohno")
 366         }
 367
 368         // Respond with auto reply if other client has it enabled
 369         if len(otherClient.AutoReply) > 0 {
 370                 res = append(res,
 371                         *NewTransaction(
 372                                 tranServerMsg,
 373                                 cc.ID,
 374                                 NewField(fieldData, otherClient.AutoReply),
 375                                 NewField(fieldUserName, otherClient.UserName),
 376                                 NewField(fieldUserID, *otherClient.ID),
 377                                 NewField(fieldOptions, []byte{0, 1}),
 378                         ),
 379                 )
 380         }
 381
 382         res = append(res, cc.NewReply(t))
 383
 384         return res, err
 385 }
 386
 387 func HandleGetFileInfo(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 388         fileName := t.GetField(fieldFileName).Data
 389         filePath := t.GetField(fieldFilePath).Data
 390
 391         ffo, err := NewFlattenedFileObject(cc.Server.Config.FileRoot, filePath, fileName)
 392         if err != nil {
 393                 return res, err
 394         }
 395
 396         res = append(res, cc.NewReply(t,
 397                 NewField(fieldFileName, fileName),
 398                 NewField(fieldFileTypeString, ffo.FlatFileInformationFork.TypeSignature),
 399                 NewField(fieldFileCreatorString, ffo.FlatFileInformationFork.CreatorSignature),
 400                 NewField(fieldFileComment, ffo.FlatFileInformationFork.Comment),
 401                 NewField(fieldFileType, ffo.FlatFileInformationFork.TypeSignature),
 402                 NewField(fieldFileCreateDate, ffo.FlatFileInformationFork.CreateDate),
 403                 NewField(fieldFileModifyDate, ffo.FlatFileInformationFork.ModifyDate),
 404                 NewField(fieldFileSize, ffo.FlatFileDataForkHeader.DataSize),
 405         ))
 406         return res, err
 407 }
 408
 409 // HandleSetFileInfo updates a file or folder name and/or comment from the Get Info window
 410 // TODO: Implement support for comments
 411 // Fields used in the request:
 412 // * 201        File name
 413 // * 202        File path       Optional
 414 // * 211        File new name   Optional
 415 // * 210        File comment    Optional
 416 // Fields used in the reply:    None
 417 func HandleSetFileInfo(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 418         fileName := t.GetField(fieldFileName).Data
 419         filePath := t.GetField(fieldFilePath).Data
 420
 421         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
 422         if err != nil {
 423                 return res, err
 424         }
 425
 426         fullNewFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, t.GetField(fieldFileNewName).Data)
 427         if err != nil {
 428                 return nil, err
 429         }
 430
 431         // fileComment := t.GetField(fieldFileComment).Data
 432         fileNewName := t.GetField(fieldFileNewName).Data
 433
 434         if fileNewName != nil {
 435                 fi, err := FS.Stat(fullFilePath)
 436                 if err != nil {
 437                         return res, err
 438                 }
 439                 switch mode := fi.Mode(); {
 440                 case mode.IsDir():
 441                         if !authorize(cc.Account.Access, accessRenameFolder) {
 442                                 res = append(res, cc.NewErrReply(t, "You are not allowed to rename folders."))
 443                                 return res, err
 444                         }
 445                 case mode.IsRegular():
 446                         if !authorize(cc.Account.Access, accessRenameFile) {
 447                                 res = append(res, cc.NewErrReply(t, "You are not allowed to rename files."))
 448                                 return res, err
 449                         }
 450                 }
 451
 452                 err = os.Rename(fullFilePath, fullNewFilePath)
 453                 if os.IsNotExist(err) {
 454                         res = append(res, cc.NewErrReply(t, "Cannot rename file "+string(fileName)+" because it does not exist or cannot be found."))
 455                         return res, err
 456                 }
 457         }
 458
 459         res = append(res, cc.NewReply(t))
 460         return res, err
 461 }
 462
 463 // HandleDeleteFile deletes a file or folder
 464 // Fields used in the request:
 465 // * 201        File name
 466 // * 202        File path
 467 // Fields used in the reply: none
 468 func HandleDeleteFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 469         fileName := t.GetField(fieldFileName).Data
 470         filePath := t.GetField(fieldFilePath).Data
 471
 472         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
 473         if err != nil {
 474                 return res, err
 475         }
 476
 477         cc.Server.Logger.Debugw("Delete file", "src", fullFilePath)
 478
 479         fi, err := os.Stat(fullFilePath)
 480         if err != nil {
 481                 res = append(res, cc.NewErrReply(t, "Cannot delete file "+string(fileName)+" because it does not exist or cannot be found."))
 482                 return res, nil
 483         }
 484         switch mode := fi.Mode(); {
 485         case mode.IsDir():
 486                 if !authorize(cc.Account.Access, accessDeleteFolder) {
 487                         res = append(res, cc.NewErrReply(t, "You are not allowed to delete folders."))
 488                         return res, err
 489                 }
 490         case mode.IsRegular():
 491                 if !authorize(cc.Account.Access, accessDeleteFile) {
 492                         res = append(res, cc.NewErrReply(t, "You are not allowed to delete files."))
 493                         return res, err
 494                 }
 495         }
 496
 497         if err := os.RemoveAll(fullFilePath); err != nil {
 498                 return res, err
 499         }
 500
 501         res = append(res, cc.NewReply(t))
 502         return res, err
 503 }
 504
 505 // HandleMoveFile moves files or folders. Note: seemingly not documented
 506 func HandleMoveFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 507         fileName := string(t.GetField(fieldFileName).Data)
 508         filePath := cc.Server.Config.FileRoot + ReadFilePath(t.GetField(fieldFilePath).Data)
 509         fileNewPath := cc.Server.Config.FileRoot + ReadFilePath(t.GetField(fieldFileNewPath).Data)
 510
 511         cc.Server.Logger.Debugw("Move file", "src", filePath+"/"+fileName, "dst", fileNewPath+"/"+fileName)
 512
 513         fp := filePath + "/" + fileName
 514         fi, err := os.Stat(fp)
 515         if err != nil {
 516                 return res, err
 517         }
 518         switch mode := fi.Mode(); {
 519         case mode.IsDir():
 520                 if !authorize(cc.Account.Access, accessMoveFolder) {
 521                         res = append(res, cc.NewErrReply(t, "You are not allowed to move folders."))
 522                         return res, err
 523                 }
 524         case mode.IsRegular():
 525                 if !authorize(cc.Account.Access, accessMoveFile) {
 526                         res = append(res, cc.NewErrReply(t, "You are not allowed to move files."))
 527                         return res, err
 528                 }
 529         }
 530
 531         err = os.Rename(filePath+"/"+fileName, fileNewPath+"/"+fileName)
 532         if os.IsNotExist(err) {
 533                 res = append(res, cc.NewErrReply(t, "Cannot delete file "+fileName+" because it does not exist or cannot be found."))
 534                 return res, err
 535         }
 536         if err != nil {
 537                 return []Transaction{}, err
 538         }
 539         // TODO: handle other possible errors; e.g. file delete fails due to file permission issue
 540
 541         res = append(res, cc.NewReply(t))
 542         return res, err
 543 }
 544
 545 func HandleNewFolder(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 546         newFolderPath := cc.Server.Config.FileRoot
 547         folderName := string(t.GetField(fieldFileName).Data)
 548
 549         folderName = path.Join("/", folderName)
 550
 551         // fieldFilePath is only present for nested paths
 552         if t.GetField(fieldFilePath).Data != nil {
 553                 var newFp FilePath
 554                 err := newFp.UnmarshalBinary(t.GetField(fieldFilePath).Data)
 555                 if err != nil {
 556                         return nil, err
 557                 }
 558                 newFolderPath += newFp.String()
 559         }
 560         newFolderPath = path.Join(newFolderPath, folderName)
 561
 562         // TODO: check path and folder name lengths
 563
 564         if _, err := FS.Stat(newFolderPath); !os.IsNotExist(err) {
 565                 msg := fmt.Sprintf("Cannot create folder \"%s\" because there is already a file or folder with that name.", folderName)
 566                 return []Transaction{cc.NewErrReply(t, msg)}, nil
 567         }
 568
 569         // TODO: check for disallowed characters to maintain compatibility for original client
 570
 571         if err := FS.Mkdir(newFolderPath, 0777); err != nil {
 572                 msg := fmt.Sprintf("Cannot create folder \"%s\" because an error occurred.", folderName)
 573                 return []Transaction{cc.NewErrReply(t, msg)}, nil
 574         }
 575
 576         res = append(res, cc.NewReply(t))
 577         return res, err
 578 }
 579
 580 func HandleSetUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 581         login := DecodeUserString(t.GetField(fieldUserLogin).Data)
 582         userName := string(t.GetField(fieldUserName).Data)
 583
 584         newAccessLvl := t.GetField(fieldUserAccess).Data
 585
 586         account := cc.Server.Accounts[login]
 587         account.Access = &newAccessLvl
 588         account.Name = userName
 589
 590         // If the password field is cleared in the Hotline edit user UI, the SetUser transaction does
 591         // not include fieldUserPassword
 592         if t.GetField(fieldUserPassword).Data == nil {
 593                 account.Password = hashAndSalt([]byte(""))
 594         }
 595         if len(t.GetField(fieldUserPassword).Data) > 1 {
 596                 account.Password = hashAndSalt(t.GetField(fieldUserPassword).Data)
 597         }
 598
 599         file := cc.Server.ConfigDir + "Users/" + login + ".yaml"
 600         out, err := yaml.Marshal(&account)
 601         if err != nil {
 602                 return res, err
 603         }
 604         if err := ioutil.WriteFile(file, out, 0666); err != nil {
 605                 return res, err
 606         }
 607
 608         // Notify connected clients logged in as the user of the new access level
 609         for _, c := range cc.Server.Clients {
 610                 if c.Account.Login == login {
 611                         // Note: comment out these two lines to test server-side deny messages
 612                         newT := NewTransaction(tranUserAccess, c.ID, NewField(fieldUserAccess, newAccessLvl))
 613                         res = append(res, *newT)
 614
 615                         flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(*c.Flags)))
 616                         if authorize(c.Account.Access, accessDisconUser) {
 617                                 flagBitmap.SetBit(flagBitmap, userFlagAdmin, 1)
 618                         } else {
 619                                 flagBitmap.SetBit(flagBitmap, userFlagAdmin, 0)
 620                         }
 621                         binary.BigEndian.PutUint16(*c.Flags, uint16(flagBitmap.Int64()))
 622
 623                         c.Account.Access = account.Access
 624
 625                         cc.sendAll(
 626                                 tranNotifyChangeUser,
 627                                 NewField(fieldUserID, *c.ID),
 628                                 NewField(fieldUserFlags, *c.Flags),
 629                                 NewField(fieldUserName, c.UserName),
 630                                 NewField(fieldUserIconID, *c.Icon),
 631                         )
 632                 }
 633         }
 634
 635         res = append(res, cc.NewReply(t))
 636         return res, err
 637 }
 638
 639 func HandleGetUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 640         if !authorize(cc.Account.Access, accessOpenUser) {
 641                 res = append(res, cc.NewErrReply(t, "You are not allowed to view accounts."))
 642                 return res, err
 643         }
 644
 645         account := cc.Server.Accounts[string(t.GetField(fieldUserLogin).Data)]
 646         if account == nil {
 647                 errorT := cc.NewErrReply(t, "Account does not exist.")
 648                 res = append(res, errorT)
 649                 return res, err
 650         }
 651
 652         res = append(res, cc.NewReply(t,
 653                 NewField(fieldUserName, []byte(account.Name)),
 654                 NewField(fieldUserLogin, negateString(t.GetField(fieldUserLogin).Data)),
 655                 NewField(fieldUserPassword, []byte(account.Password)),
 656                 NewField(fieldUserAccess, *account.Access),
 657         ))
 658         return res, err
 659 }
 660
 661 func HandleListUsers(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 662         var userFields []Field
 663         // TODO: make order deterministic
 664         for _, acc := range cc.Server.Accounts {
 665                 userField := acc.MarshalBinary()
 666                 userFields = append(userFields, NewField(fieldData, userField))
 667         }
 668
 669         res = append(res, cc.NewReply(t, userFields...))
 670         return res, err
 671 }
 672
 673 // HandleNewUser creates a new user account
 674 func HandleNewUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 675         login := DecodeUserString(t.GetField(fieldUserLogin).Data)
 676
 677         // If the account already exists, reply with an error
 678         // TODO: make order deterministic
 679         if _, ok := cc.Server.Accounts[login]; ok {
 680                 res = append(res, cc.NewErrReply(t, "Cannot create account "+login+" because there is already an account with that login."))
 681                 return res, err
 682         }
 683
 684         if err := cc.Server.NewUser(
 685                 login,
 686                 string(t.GetField(fieldUserName).Data),
 687                 string(t.GetField(fieldUserPassword).Data),
 688                 t.GetField(fieldUserAccess).Data,
 689         ); err != nil {
 690                 return []Transaction{}, err
 691         }
 692
 693         res = append(res, cc.NewReply(t))
 694         return res, err
 695 }
 696
 697 func HandleDeleteUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 698         if !authorize(cc.Account.Access, accessDeleteUser) {
 699                 res = append(res, cc.NewErrReply(t, "You are not allowed to delete accounts."))
 700                 return res, err
 701         }
 702
 703         // TODO: Handle case where account doesn't exist; e.g. delete race condition
 704         login := DecodeUserString(t.GetField(fieldUserLogin).Data)
 705
 706         if err := cc.Server.DeleteUser(login); err != nil {
 707                 return res, err
 708         }
 709
 710         res = append(res, cc.NewReply(t))
 711         return res, err
 712 }
 713
 714 // HandleUserBroadcast sends an Administrator Message to all connected clients of the server
 715 func HandleUserBroadcast(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 716         cc.sendAll(
 717                 tranServerMsg,
 718                 NewField(fieldData, t.GetField(tranGetMsgs).Data),
 719                 NewField(fieldChatOptions, []byte{0}),
 720         )
 721
 722         res = append(res, cc.NewReply(t))
 723         return res, err
 724 }
 725
 726 func byteToInt(bytes []byte) (int, error) {
 727         switch len(bytes) {
 728         case 2:
 729                 return int(binary.BigEndian.Uint16(bytes)), nil
 730         case 4:
 731                 return int(binary.BigEndian.Uint32(bytes)), nil
 732         }
 733
 734         return 0, errors.New("unknown byte length")
 735 }
 736
 737 func HandleGetClientConnInfoText(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 738         clientID, _ := byteToInt(t.GetField(fieldUserID).Data)
 739
 740         clientConn := cc.Server.Clients[uint16(clientID)]
 741         if clientConn == nil {
 742                 return res, errors.New("invalid client")
 743         }
 744
 745         // TODO: Implement non-hardcoded values
 746         template := `Nickname:   %s
 747 Name:       %s
 748 Account:    %s
 749 Address:    %s
 750
 751 -------- File Downloads ---------
 752
 753 %s
 754
 755 ------- Folder Downloads --------
 756
 757 None.
 758
 759 --------- File Uploads ----------
 760
 761 None.
 762
 763 -------- Folder Uploads ---------
 764
 765 None.
 766
 767 ------- Waiting Downloads -------
 768
 769 None.
 770
 771         `
 772
 773         activeDownloads := clientConn.Transfers[FileDownload]
 774         activeDownloadList := "None."
 775         for _, dl := range activeDownloads {
 776                 activeDownloadList += dl.String() + "\n"
 777         }
 778
 779         template = fmt.Sprintf(
 780                 template,
 781                 clientConn.UserName,
 782                 clientConn.Account.Name,
 783                 clientConn.Account.Login,
 784                 clientConn.Connection.RemoteAddr().String(),
 785                 activeDownloadList,
 786         )
 787         template = strings.Replace(template, "\n", "\r", -1)
 788
 789         res = append(res, cc.NewReply(t,
 790                 NewField(fieldData, []byte(template)),
 791                 NewField(fieldUserName, clientConn.UserName),
 792         ))
 793         return res, err
 794 }
 795
 796 func HandleGetUserNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 797         res = append(res, cc.NewReply(t, cc.Server.connectedUsers()...))
 798
 799         return res, err
 800 }
 801
 802 func HandleTranAgreed(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 803         cc.Agreed = true
 804         cc.UserName = t.GetField(fieldUserName).Data
 805         *cc.Icon = t.GetField(fieldUserIconID).Data
 806
 807         options := t.GetField(fieldOptions).Data
 808         optBitmap := big.NewInt(int64(binary.BigEndian.Uint16(options)))
 809
 810         flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(*cc.Flags)))
 811
 812         // Check refuse private PM option
 813         if optBitmap.Bit(refusePM) == 1 {
 814                 flagBitmap.SetBit(flagBitmap, userFlagRefusePM, 1)
 815                 binary.BigEndian.PutUint16(*cc.Flags, uint16(flagBitmap.Int64()))
 816         }
 817
 818         // Check refuse private chat option
 819         if optBitmap.Bit(refuseChat) == 1 {
 820                 flagBitmap.SetBit(flagBitmap, userFLagRefusePChat, 1)
 821                 binary.BigEndian.PutUint16(*cc.Flags, uint16(flagBitmap.Int64()))
 822         }
 823
 824         // Check auto response
 825         if optBitmap.Bit(autoResponse) == 1 {
 826                 cc.AutoReply = t.GetField(fieldAutomaticResponse).Data
 827         } else {
 828                 cc.AutoReply = []byte{}
 829         }
 830
 831         cc.notifyOthers(
 832                 *NewTransaction(
 833                         tranNotifyChangeUser, nil,
 834                         NewField(fieldUserName, cc.UserName),
 835                         NewField(fieldUserID, *cc.ID),
 836                         NewField(fieldUserIconID, *cc.Icon),
 837                         NewField(fieldUserFlags, *cc.Flags),
 838                 ),
 839         )
 840
 841         res = append(res, cc.NewReply(t))
 842
 843         return res, err
 844 }
 845
 846 const defaultNewsDateFormat = "Jan02 15:04" // Jun23 20:49
 847 //  "Mon, 02 Jan 2006 15:04:05 MST"
 848
 849 const defaultNewsTemplate = `From %s (%s):
 850
 851 %s
 852
 853 __________________________________________________________`
 854
 855 // HandleTranOldPostNews updates the flat news
 856 // Fields used in this request:
 857 // 101  Data
 858 func HandleTranOldPostNews(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 859         cc.Server.flatNewsMux.Lock()
 860         defer cc.Server.flatNewsMux.Unlock()
 861
 862         newsDateTemplate := defaultNewsDateFormat
 863         if cc.Server.Config.NewsDateFormat != "" {
 864                 newsDateTemplate = cc.Server.Config.NewsDateFormat
 865         }
 866
 867         newsTemplate := defaultNewsTemplate
 868         if cc.Server.Config.NewsDelimiter != "" {
 869                 newsTemplate = cc.Server.Config.NewsDelimiter
 870         }
 871
 872         newsPost := fmt.Sprintf(newsTemplate+"\r", cc.UserName, time.Now().Format(newsDateTemplate), t.GetField(fieldData).Data)
 873         newsPost = strings.Replace(newsPost, "\n", "\r", -1)
 874
 875         // update news in memory
 876         cc.Server.FlatNews = append([]byte(newsPost), cc.Server.FlatNews...)
 877
 878         // update news on disk
 879         if err := ioutil.WriteFile(cc.Server.ConfigDir+"MessageBoard.txt", cc.Server.FlatNews, 0644); err != nil {
 880                 return res, err
 881         }
 882
 883         // Notify all clients of updated news
 884         cc.sendAll(
 885                 tranNewMsg,
 886                 NewField(fieldData, []byte(newsPost)),
 887         )
 888
 889         res = append(res, cc.NewReply(t))
 890         return res, err
 891 }
 892
 893 func HandleDisconnectUser(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 894         clientConn := cc.Server.Clients[binary.BigEndian.Uint16(t.GetField(fieldUserID).Data)]
 895
 896         if authorize(clientConn.Account.Access, accessCannotBeDiscon) {
 897                 res = append(res, cc.NewErrReply(t, clientConn.Account.Login+" is not allowed to be disconnected."))
 898                 return res, err
 899         }
 900
 901         if err := clientConn.Connection.Close(); err != nil {
 902                 return res, err
 903         }
 904
 905         res = append(res, cc.NewReply(t))
 906         return res, err
 907 }
 908
 909 func HandleGetNewsCatNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 910         // Fields used in the request:
 911         // 325  News path       (Optional)
 912
 913         newsPath := t.GetField(fieldNewsPath).Data
 914         cc.Server.Logger.Infow("NewsPath: ", "np", string(newsPath))
 915
 916         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
 917         cats := cc.Server.GetNewsCatByPath(pathStrs)
 918
 919         // To store the keys in slice in sorted order
 920         keys := make([]string, len(cats))
 921         i := 0
 922         for k := range cats {
 923                 keys[i] = k
 924                 i++
 925         }
 926         sort.Strings(keys)
 927
 928         var fieldData []Field
 929         for _, k := range keys {
 930                 cat := cats[k]
 931                 b, _ := cat.MarshalBinary()
 932                 fieldData = append(fieldData, NewField(
 933                         fieldNewsCatListData15,
 934                         b,
 935                 ))
 936         }
 937
 938         res = append(res, cc.NewReply(t, fieldData...))
 939         return res, err
 940 }
 941
 942 func HandleNewNewsCat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 943         name := string(t.GetField(fieldNewsCatName).Data)
 944         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
 945
 946         cats := cc.Server.GetNewsCatByPath(pathStrs)
 947         cats[name] = NewsCategoryListData15{
 948                 Name:     name,
 949                 Type:     []byte{0, 3},
 950                 Articles: map[uint32]*NewsArtData{},
 951                 SubCats:  make(map[string]NewsCategoryListData15),
 952         }
 953
 954         if err := cc.Server.writeThreadedNews(); err != nil {
 955                 return res, err
 956         }
 957         res = append(res, cc.NewReply(t))
 958         return res, err
 959 }
 960
 961 func HandleNewNewsFldr(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 962         // Fields used in the request:
 963         // 322  News category name
 964         // 325  News path
 965         name := string(t.GetField(fieldFileName).Data)
 966         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
 967
 968         cc.Server.Logger.Infof("Creating new news folder %s", name)
 969
 970         cats := cc.Server.GetNewsCatByPath(pathStrs)
 971         cats[name] = NewsCategoryListData15{
 972                 Name:     name,
 973                 Type:     []byte{0, 2},
 974                 Articles: map[uint32]*NewsArtData{},
 975                 SubCats:  make(map[string]NewsCategoryListData15),
 976         }
 977         if err := cc.Server.writeThreadedNews(); err != nil {
 978                 return res, err
 979         }
 980         res = append(res, cc.NewReply(t))
 981         return res, err
 982 }
 983
 984 // Fields used in the request:
 985 // 325  News path       Optional
 986 //
 987 // Reply fields:
 988 // 321  News article list data  Optional
 989 func HandleGetNewsArtNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
 990         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
 991
 992         var cat NewsCategoryListData15
 993         cats := cc.Server.ThreadedNews.Categories
 994
 995         for _, fp := range pathStrs {
 996                 cat = cats[fp]
 997                 cats = cats[fp].SubCats
 998         }
 999
1000         nald := cat.GetNewsArtListData()
1001
1002         res = append(res, cc.NewReply(t, NewField(fieldNewsArtListData, nald.Payload())))
1003         return res, err
1004 }
1005
1006 func HandleGetNewsArtData(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1007         // Request fields
1008         // 325  News fp
1009         // 326  News article ID
1010         // 327  News article data flavor
1011
1012         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
1013
1014         var cat NewsCategoryListData15
1015         cats := cc.Server.ThreadedNews.Categories
1016
1017         for _, fp := range pathStrs {
1018                 cat = cats[fp]
1019                 cats = cats[fp].SubCats
1020         }
1021         newsArtID := t.GetField(fieldNewsArtID).Data
1022
1023         convertedArtID := binary.BigEndian.Uint16(newsArtID)
1024
1025         art := cat.Articles[uint32(convertedArtID)]
1026         if art == nil {
1027                 res = append(res, cc.NewReply(t))
1028                 return res, err
1029         }
1030
1031         // Reply fields
1032         // 328  News article title
1033         // 329  News article poster
1034         // 330  News article date
1035         // 331  Previous article ID
1036         // 332  Next article ID
1037         // 335  Parent article ID
1038         // 336  First child article ID
1039         // 327  News article data flavor        "Should be “text/plain”
1040         // 333  News article data       Optional (if data flavor is “text/plain”)
1041
1042         res = append(res, cc.NewReply(t,
1043                 NewField(fieldNewsArtTitle, []byte(art.Title)),
1044                 NewField(fieldNewsArtPoster, []byte(art.Poster)),
1045                 NewField(fieldNewsArtDate, art.Date),
1046                 NewField(fieldNewsArtPrevArt, art.PrevArt),
1047                 NewField(fieldNewsArtNextArt, art.NextArt),
1048                 NewField(fieldNewsArtParentArt, art.ParentArt),
1049                 NewField(fieldNewsArt1stChildArt, art.FirstChildArt),
1050                 NewField(fieldNewsArtDataFlav, []byte("text/plain")),
1051                 NewField(fieldNewsArtData, []byte(art.Data)),
1052         ))
1053         return res, err
1054 }
1055
1056 func HandleDelNewsItem(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1057         // Access:              News Delete Folder (37) or News Delete Category (35)
1058
1059         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
1060
1061         // TODO: determine if path is a Folder (Bundle) or Category and check for permission
1062
1063         cc.Server.Logger.Infof("DelNewsItem %v", pathStrs)
1064
1065         cats := cc.Server.ThreadedNews.Categories
1066
1067         delName := pathStrs[len(pathStrs)-1]
1068         if len(pathStrs) > 1 {
1069                 for _, fp := range pathStrs[0 : len(pathStrs)-1] {
1070                         cats = cats[fp].SubCats
1071                 }
1072         }
1073
1074         delete(cats, delName)
1075
1076         err = cc.Server.writeThreadedNews()
1077         if err != nil {
1078                 return res, err
1079         }
1080
1081         // Reply params: none
1082         res = append(res, cc.NewReply(t))
1083
1084         return res, err
1085 }
1086
1087 func HandleDelNewsArt(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1088         // Request Fields
1089         // 325  News path
1090         // 326  News article ID
1091         // 337  News article – recursive delete       Delete child articles (1) or not (0)
1092         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
1093         ID := binary.BigEndian.Uint16(t.GetField(fieldNewsArtID).Data)
1094
1095         // TODO: Delete recursive
1096         cats := cc.Server.GetNewsCatByPath(pathStrs[:len(pathStrs)-1])
1097
1098         catName := pathStrs[len(pathStrs)-1]
1099         cat := cats[catName]
1100
1101         delete(cat.Articles, uint32(ID))
1102
1103         cats[catName] = cat
1104         if err := cc.Server.writeThreadedNews(); err != nil {
1105                 return res, err
1106         }
1107
1108         res = append(res, cc.NewReply(t))
1109         return res, err
1110 }
1111
1112 func HandlePostNewsArt(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1113         // Request fields
1114         // 325  News path
1115         // 326  News article ID                                                 ID of the parent article?
1116         // 328  News article title
1117         // 334  News article flags
1118         // 327  News article data flavor                Currently “text/plain”
1119         // 333  News article data
1120
1121         pathStrs := ReadNewsPath(t.GetField(fieldNewsPath).Data)
1122         cats := cc.Server.GetNewsCatByPath(pathStrs[:len(pathStrs)-1])
1123
1124         catName := pathStrs[len(pathStrs)-1]
1125         cat := cats[catName]
1126
1127         newArt := NewsArtData{
1128                 Title:         string(t.GetField(fieldNewsArtTitle).Data),
1129                 Poster:        string(cc.UserName),
1130                 Date:          toHotlineTime(time.Now()),
1131                 PrevArt:       []byte{0, 0, 0, 0},
1132                 NextArt:       []byte{0, 0, 0, 0},
1133                 ParentArt:     append([]byte{0, 0}, t.GetField(fieldNewsArtID).Data...),
1134                 FirstChildArt: []byte{0, 0, 0, 0},
1135                 DataFlav:      []byte("text/plain"),
1136                 Data:          string(t.GetField(fieldNewsArtData).Data),
1137         }
1138
1139         var keys []int
1140         for k := range cat.Articles {
1141                 keys = append(keys, int(k))
1142         }
1143
1144         nextID := uint32(1)
1145         if len(keys) > 0 {
1146                 sort.Ints(keys)
1147                 prevID := uint32(keys[len(keys)-1])
1148                 nextID = prevID + 1
1149
1150                 binary.BigEndian.PutUint32(newArt.PrevArt, prevID)
1151
1152                 // Set next article ID
1153                 binary.BigEndian.PutUint32(cat.Articles[prevID].NextArt, nextID)
1154         }
1155
1156         // Update parent article with first child reply
1157         parentID := binary.BigEndian.Uint16(t.GetField(fieldNewsArtID).Data)
1158         if parentID != 0 {
1159                 parentArt := cat.Articles[uint32(parentID)]
1160
1161                 if bytes.Equal(parentArt.FirstChildArt, []byte{0, 0, 0, 0}) {
1162                         binary.BigEndian.PutUint32(parentArt.FirstChildArt, nextID)
1163                 }
1164         }
1165
1166         cat.Articles[nextID] = &newArt
1167
1168         cats[catName] = cat
1169         if err := cc.Server.writeThreadedNews(); err != nil {
1170                 return res, err
1171         }
1172
1173         res = append(res, cc.NewReply(t))
1174         return res, err
1175 }
1176
1177 // HandleGetMsgs returns the flat news data
1178 func HandleGetMsgs(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1179         res = append(res, cc.NewReply(t, NewField(fieldData, cc.Server.FlatNews)))
1180
1181         return res, err
1182 }
1183
1184 func HandleDownloadFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1185         fileName := t.GetField(fieldFileName).Data
1186         filePath := t.GetField(fieldFilePath).Data
1187
1188         var fp FilePath
1189         err = fp.UnmarshalBinary(filePath)
1190         if err != nil {
1191                 return res, err
1192         }
1193
1194         ffo, err := NewFlattenedFileObject(cc.Server.Config.FileRoot, filePath, fileName)
1195         if err != nil {
1196                 return res, err
1197         }
1198
1199         transactionRef := cc.Server.NewTransactionRef()
1200         data := binary.BigEndian.Uint32(transactionRef)
1201
1202         ft := &FileTransfer{
1203                 FileName:        fileName,
1204                 FilePath:        filePath,
1205                 ReferenceNumber: transactionRef,
1206                 Type:            FileDownload,
1207         }
1208
1209         cc.Server.FileTransfers[data] = ft
1210         cc.Transfers[FileDownload] = append(cc.Transfers[FileDownload], ft)
1211
1212         res = append(res, cc.NewReply(t,
1213                 NewField(fieldRefNum, transactionRef),
1214                 NewField(fieldWaitingCount, []byte{0x00, 0x00}), // TODO: Implement waiting count
1215                 NewField(fieldTransferSize, ffo.TransferSize()),
1216                 NewField(fieldFileSize, ffo.FlatFileDataForkHeader.DataSize),
1217         ))
1218
1219         return res, err
1220 }
1221
1222 // Download all files from the specified folder and sub-folders
1223 // response example
1224 //
1225 //      00
1226 //      01
1227 //      00 00
1228 //      00 00 00 11
1229 //      00 00 00 00
1230 //      00 00 00 18
1231 //      00 00 00 18
1232 //
1233 //      00 03
1234 //
1235 //      00 6c // transfer size
1236 //      00 04 // len
1237 //      00 0f d5 ae
1238 //
1239 //      00 dc // field Folder item count
1240 //      00 02 // len
1241 //      00 02
1242 //
1243 //      00 6b // ref number
1244 //      00 04 // len
1245 //      00 03 64 b1
1246 func HandleDownloadFolder(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1247         transactionRef := cc.Server.NewTransactionRef()
1248         data := binary.BigEndian.Uint32(transactionRef)
1249
1250         fileTransfer := &FileTransfer{
1251                 FileName:        t.GetField(fieldFileName).Data,
1252                 FilePath:        t.GetField(fieldFilePath).Data,
1253                 ReferenceNumber: transactionRef,
1254                 Type:            FolderDownload,
1255         }
1256         cc.Server.FileTransfers[data] = fileTransfer
1257         cc.Transfers[FolderDownload] = append(cc.Transfers[FolderDownload], fileTransfer)
1258
1259         var fp FilePath
1260         err = fp.UnmarshalBinary(t.GetField(fieldFilePath).Data)
1261         if err != nil {
1262                 return res, err
1263         }
1264
1265         fullFilePath, err := readPath(cc.Server.Config.FileRoot, t.GetField(fieldFilePath).Data, t.GetField(fieldFileName).Data)
1266         if err != nil {
1267                 return res, err
1268         }
1269
1270         transferSize, err := CalcTotalSize(fullFilePath)
1271         if err != nil {
1272                 return res, err
1273         }
1274         itemCount, err := CalcItemCount(fullFilePath)
1275         if err != nil {
1276                 return res, err
1277         }
1278         res = append(res, cc.NewReply(t,
1279                 NewField(fieldRefNum, transactionRef),
1280                 NewField(fieldTransferSize, transferSize),
1281                 NewField(fieldFolderItemCount, itemCount),
1282                 NewField(fieldWaitingCount, []byte{0x00, 0x00}), // TODO: Implement waiting count
1283         ))
1284         return res, err
1285 }
1286
1287 // Upload all files from the local folder and its subfolders to the specified path on the server
1288 // Fields used in the request
1289 // 201  File name
1290 // 202  File path
1291 // 108  transfer size   Total size of all items in the folder
1292 // 220  Folder item count
1293 // 204  File transfer options   "Optional Currently set to 1" (TODO: ??)
1294 func HandleUploadFolder(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1295         transactionRef := cc.Server.NewTransactionRef()
1296         data := binary.BigEndian.Uint32(transactionRef)
1297
1298         var fp FilePath
1299         if t.GetField(fieldFilePath).Data != nil {
1300                 if err = fp.UnmarshalBinary(t.GetField(fieldFilePath).Data); err != nil {
1301                         return res, err
1302                 }
1303         }
1304
1305         // Handle special cases for Upload and Drop Box folders
1306         if !authorize(cc.Account.Access, accessUploadAnywhere) {
1307                 if !fp.IsUploadDir() && !fp.IsDropbox() {
1308                         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))))
1309                         return res, err
1310                 }
1311         }
1312
1313         fileTransfer := &FileTransfer{
1314                 FileName:        t.GetField(fieldFileName).Data,
1315                 FilePath:        t.GetField(fieldFilePath).Data,
1316                 ReferenceNumber: transactionRef,
1317                 Type:            FolderUpload,
1318                 FolderItemCount: t.GetField(fieldFolderItemCount).Data,
1319                 TransferSize:    t.GetField(fieldTransferSize).Data,
1320         }
1321         cc.Server.FileTransfers[data] = fileTransfer
1322
1323         res = append(res, cc.NewReply(t, NewField(fieldRefNum, transactionRef)))
1324         return res, err
1325 }
1326
1327 // HandleUploadFile
1328 // Special cases:
1329 // * If the target directory contains "uploads" (case insensitive)
1330 func HandleUploadFile(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1331         if !authorize(cc.Account.Access, accessUploadFile) {
1332                 res = append(res, cc.NewErrReply(t, "You are not allowed to upload files."))
1333                 return res, err
1334         }
1335
1336         fileName := t.GetField(fieldFileName).Data
1337         filePath := t.GetField(fieldFilePath).Data
1338
1339         var fp FilePath
1340         if filePath != nil {
1341                 if err = fp.UnmarshalBinary(filePath); err != nil {
1342                         return res, err
1343                 }
1344         }
1345
1346         // Handle special cases for Upload and Drop Box folders
1347         if !authorize(cc.Account.Access, accessUploadAnywhere) {
1348                 if !fp.IsUploadDir() && !fp.IsDropbox() {
1349                         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))))
1350                         return res, err
1351                 }
1352         }
1353
1354         transactionRef := cc.Server.NewTransactionRef()
1355         data := binary.BigEndian.Uint32(transactionRef)
1356
1357         cc.Server.FileTransfers[data] = &FileTransfer{
1358                 FileName:        fileName,
1359                 FilePath:        filePath,
1360                 ReferenceNumber: transactionRef,
1361                 Type:            FileUpload,
1362         }
1363
1364         res = append(res, cc.NewReply(t, NewField(fieldRefNum, transactionRef)))
1365         return res, err
1366 }
1367
1368 func HandleSetClientUserInfo(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1369         var icon []byte
1370         if len(t.GetField(fieldUserIconID).Data) == 4 {
1371                 icon = t.GetField(fieldUserIconID).Data[2:]
1372         } else {
1373                 icon = t.GetField(fieldUserIconID).Data
1374         }
1375         *cc.Icon = icon
1376         cc.UserName = t.GetField(fieldUserName).Data
1377
1378         // the options field is only passed by the client versions > 1.2.3.
1379         options := t.GetField(fieldOptions).Data
1380
1381         if options != nil {
1382                 optBitmap := big.NewInt(int64(binary.BigEndian.Uint16(options)))
1383                 flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(*cc.Flags)))
1384
1385                 flagBitmap.SetBit(flagBitmap, userFlagRefusePM, optBitmap.Bit(refusePM))
1386                 binary.BigEndian.PutUint16(*cc.Flags, uint16(flagBitmap.Int64()))
1387
1388                 flagBitmap.SetBit(flagBitmap, userFLagRefusePChat, optBitmap.Bit(refuseChat))
1389                 binary.BigEndian.PutUint16(*cc.Flags, uint16(flagBitmap.Int64()))
1390
1391                 // Check auto response
1392                 if optBitmap.Bit(autoResponse) == 1 {
1393                         cc.AutoReply = t.GetField(fieldAutomaticResponse).Data
1394                 } else {
1395                         cc.AutoReply = []byte{}
1396                 }
1397         }
1398
1399         // Notify all clients of updated user info
1400         cc.sendAll(
1401                 tranNotifyChangeUser,
1402                 NewField(fieldUserID, *cc.ID),
1403                 NewField(fieldUserIconID, *cc.Icon),
1404                 NewField(fieldUserFlags, *cc.Flags),
1405                 NewField(fieldUserName, cc.UserName),
1406         )
1407
1408         return res, err
1409 }
1410
1411 // HandleKeepAlive responds to keepalive transactions with an empty reply
1412 // * HL 1.9.2 Client sends keepalive msg every 3 minutes
1413 // * HL 1.2.3 Client doesn't send keepalives
1414 func HandleKeepAlive(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1415         res = append(res, cc.NewReply(t))
1416
1417         return res, err
1418 }
1419
1420 func HandleGetFileNameList(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1421         fullPath, err := readPath(
1422                 cc.Server.Config.FileRoot,
1423                 t.GetField(fieldFilePath).Data,
1424                 nil,
1425         )
1426         if err != nil {
1427                 return res, err
1428         }
1429
1430         var fp FilePath
1431         if t.GetField(fieldFilePath).Data != nil {
1432                 if err = fp.UnmarshalBinary(t.GetField(fieldFilePath).Data); err != nil {
1433                         return res, err
1434                 }
1435         }
1436
1437         // Handle special case for drop box folders
1438         if fp.IsDropbox() && !authorize(cc.Account.Access, accessViewDropBoxes) {
1439                 res = append(res, cc.NewReply(t))
1440                 return res, err
1441         }
1442
1443         fileNames, err := getFileNameList(fullPath)
1444         if err != nil {
1445                 return res, err
1446         }
1447
1448         res = append(res, cc.NewReply(t, fileNames...))
1449
1450         return res, err
1451 }
1452
1453 // =================================
1454 //     Hotline private chat flow
1455 // =================================
1456 // 1. ClientA sends tranInviteNewChat to server with user ID to invite
1457 // 2. Server creates new ChatID
1458 // 3. Server sends tranInviteToChat to invitee
1459 // 4. Server replies to ClientA with new Chat ID
1460 //
1461 // A dialog box pops up in the invitee client with options to accept or decline the invitation.
1462 // If Accepted is clicked:
1463 // 1. ClientB sends tranJoinChat with fieldChatID
1464
1465 // HandleInviteNewChat invites users to new private chat
1466 func HandleInviteNewChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1467         // Client to Invite
1468         targetID := t.GetField(fieldUserID).Data
1469         newChatID := cc.Server.NewPrivateChat(cc)
1470
1471         res = append(res,
1472                 *NewTransaction(
1473                         tranInviteToChat,
1474                         &targetID,
1475                         NewField(fieldChatID, newChatID),
1476                         NewField(fieldUserName, cc.UserName),
1477                         NewField(fieldUserID, *cc.ID),
1478                 ),
1479         )
1480
1481         res = append(res,
1482                 cc.NewReply(t,
1483                         NewField(fieldChatID, newChatID),
1484                         NewField(fieldUserName, cc.UserName),
1485                         NewField(fieldUserID, *cc.ID),
1486                         NewField(fieldUserIconID, *cc.Icon),
1487                         NewField(fieldUserFlags, *cc.Flags),
1488                 ),
1489         )
1490
1491         return res, err
1492 }
1493
1494 func HandleInviteToChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1495         // Client to Invite
1496         targetID := t.GetField(fieldUserID).Data
1497         chatID := t.GetField(fieldChatID).Data
1498
1499         res = append(res,
1500                 *NewTransaction(
1501                         tranInviteToChat,
1502                         &targetID,
1503                         NewField(fieldChatID, chatID),
1504                         NewField(fieldUserName, cc.UserName),
1505                         NewField(fieldUserID, *cc.ID),
1506                 ),
1507         )
1508         res = append(res,
1509                 cc.NewReply(
1510                         t,
1511                         NewField(fieldChatID, chatID),
1512                         NewField(fieldUserName, cc.UserName),
1513                         NewField(fieldUserID, *cc.ID),
1514                         NewField(fieldUserIconID, *cc.Icon),
1515                         NewField(fieldUserFlags, *cc.Flags),
1516                 ),
1517         )
1518
1519         return res, err
1520 }
1521
1522 func HandleRejectChatInvite(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1523         chatID := t.GetField(fieldChatID).Data
1524         chatInt := binary.BigEndian.Uint32(chatID)
1525
1526         privChat := cc.Server.PrivateChats[chatInt]
1527
1528         resMsg := append(cc.UserName, []byte(" declined invitation to chat")...)
1529
1530         for _, c := range sortedClients(privChat.ClientConn) {
1531                 res = append(res,
1532                         *NewTransaction(
1533                                 tranChatMsg,
1534                                 c.ID,
1535                                 NewField(fieldChatID, chatID),
1536                                 NewField(fieldData, resMsg),
1537                         ),
1538                 )
1539         }
1540
1541         return res, err
1542 }
1543
1544 // HandleJoinChat is sent from a v1.8+ Hotline client when the joins a private chat
1545 // Fields used in the reply:
1546 // * 115        Chat subject
1547 // * 300        User name with info (Optional)
1548 // * 300        (more user names with info)
1549 func HandleJoinChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1550         chatID := t.GetField(fieldChatID).Data
1551         chatInt := binary.BigEndian.Uint32(chatID)
1552
1553         privChat := cc.Server.PrivateChats[chatInt]
1554
1555         // Send tranNotifyChatChangeUser to current members of the chat to inform of new user
1556         for _, c := range sortedClients(privChat.ClientConn) {
1557                 res = append(res,
1558                         *NewTransaction(
1559                                 tranNotifyChatChangeUser,
1560                                 c.ID,
1561                                 NewField(fieldChatID, chatID),
1562                                 NewField(fieldUserName, cc.UserName),
1563                                 NewField(fieldUserID, *cc.ID),
1564                                 NewField(fieldUserIconID, *cc.Icon),
1565                                 NewField(fieldUserFlags, *cc.Flags),
1566                         ),
1567                 )
1568         }
1569
1570         privChat.ClientConn[cc.uint16ID()] = cc
1571
1572         replyFields := []Field{NewField(fieldChatSubject, []byte(privChat.Subject))}
1573         for _, c := range sortedClients(privChat.ClientConn) {
1574                 user := User{
1575                         ID:    *c.ID,
1576                         Icon:  *c.Icon,
1577                         Flags: *c.Flags,
1578                         Name:  string(c.UserName),
1579                 }
1580
1581                 replyFields = append(replyFields, NewField(fieldUsernameWithInfo, user.Payload()))
1582         }
1583
1584         res = append(res, cc.NewReply(t, replyFields...))
1585         return res, err
1586 }
1587
1588 // HandleLeaveChat is sent from a v1.8+ Hotline client when the user exits a private chat
1589 // Fields used in the request:
1590 //      * 114   fieldChatID
1591 // Reply is not expected.
1592 func HandleLeaveChat(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1593         chatID := t.GetField(fieldChatID).Data
1594         chatInt := binary.BigEndian.Uint32(chatID)
1595
1596         privChat := cc.Server.PrivateChats[chatInt]
1597
1598         delete(privChat.ClientConn, cc.uint16ID())
1599
1600         // Notify members of the private chat that the user has left
1601         for _, c := range sortedClients(privChat.ClientConn) {
1602                 res = append(res,
1603                         *NewTransaction(
1604                                 tranNotifyChatDeleteUser,
1605                                 c.ID,
1606                                 NewField(fieldChatID, chatID),
1607                                 NewField(fieldUserID, *cc.ID),
1608                         ),
1609                 )
1610         }
1611
1612         return res, err
1613 }
1614
1615 // HandleSetChatSubject is sent from a v1.8+ Hotline client when the user sets a private chat subject
1616 // Fields used in the request:
1617 // * 114        Chat ID
1618 // * 115        Chat subject    Chat subject string
1619 // Reply is not expected.
1620 func HandleSetChatSubject(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1621         chatID := t.GetField(fieldChatID).Data
1622         chatInt := binary.BigEndian.Uint32(chatID)
1623
1624         privChat := cc.Server.PrivateChats[chatInt]
1625         privChat.Subject = string(t.GetField(fieldChatSubject).Data)
1626
1627         for _, c := range sortedClients(privChat.ClientConn) {
1628                 res = append(res,
1629                         *NewTransaction(
1630                                 tranNotifyChatSubject,
1631                                 c.ID,
1632                                 NewField(fieldChatID, chatID),
1633                                 NewField(fieldChatSubject, t.GetField(fieldChatSubject).Data),
1634                         ),
1635                 )
1636         }
1637
1638         return res, err
1639 }
1640
1641 // HandleMakeAlias makes a file alias using the specified path.
1642 // Fields used in the request:
1643 // 201  File name
1644 // 202  File path
1645 // 212  File new path   Destination path
1646 //
1647 // Fields used in the reply:
1648 // None
1649 func HandleMakeAlias(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
1650         if !authorize(cc.Account.Access, accessMakeAlias) {
1651                 res = append(res, cc.NewErrReply(t, "You are not allowed to make aliases."))
1652                 return res, err
1653         }
1654         fileName := t.GetField(fieldFileName).Data
1655         filePath := t.GetField(fieldFilePath).Data
1656         fileNewPath := t.GetField(fieldFileNewPath).Data
1657
1658         fullFilePath, err := readPath(cc.Server.Config.FileRoot, filePath, fileName)
1659         if err != nil {
1660                 return res, err
1661         }
1662
1663         fullNewFilePath, err := readPath(cc.Server.Config.FileRoot, fileNewPath, fileName)
1664         if err != nil {
1665                 return res, err
1666         }
1667
1668         cc.Server.Logger.Debugw("Make alias", "src", fullFilePath, "dst", fullNewFilePath)
1669
1670         if err := FS.Symlink(fullFilePath, fullNewFilePath); err != nil {
1671                 res = append(res, cc.NewErrReply(t, "Error creating alias"))
1672                 return res, nil
1673         }
1674
1675         res = append(res, cc.NewReply(t))
1676         return res, err
1677 }