]> git.r.bdr.sh - rbdr/mobius/blob - hotline/transaction_handlers.go
git.r.bdr.sh / rbdr / mobius / blob
? search:


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