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


b4841a7beef26c3ef4ac0d86caa3eb8de43e4243
[rbdr/mobius] / hotline / server.go
1 package hotline
2
3 import (
4 "bufio"
5 "bytes"
6 "context"
7 "encoding/binary"
8 "errors"
9 "fmt"
10 "github.com/go-playground/validator/v10"
11 "golang.org/x/text/encoding/charmap"
12 "gopkg.in/yaml.v3"
13 "io"
14 "io/fs"
15 "log"
16 "log/slog"
17 "math/big"
18 "math/rand"
19 "net"
20 "os"
21 "path"
22 "path/filepath"
23 "strings"
24 "sync"
25 "time"
26 )
27
28 type contextKey string
29
30 var contextKeyReq = contextKey("req")
31
32 type requestCtx struct {
33 remoteAddr string
34 }
35
36 // Converts bytes from Mac Roman encoding to UTF-8
37 var txtDecoder = charmap.Macintosh.NewDecoder()
38
39 // Converts bytes from UTF-8 to Mac Roman encoding
40 var txtEncoder = charmap.Macintosh.NewEncoder()
41
42 type Server struct {
43 NetInterface string
44 Port int
45 Accounts map[string]*Account
46 Agreement []byte
47 Clients map[uint16]*ClientConn
48 fileTransfers map[[4]byte]*FileTransfer
49
50 Config *Config
51 ConfigDir string
52 Logger *slog.Logger
53 banner []byte
54
55 PrivateChatsMu sync.Mutex
56 PrivateChats map[uint32]*PrivateChat
57
58 NextGuestID *uint16
59 TrackerPassID [4]byte
60
61 StatsMu sync.Mutex
62 Stats *Stats
63
64 FS FileStore // Storage backend to use for File storage
65
66 outbox chan Transaction
67 mux sync.Mutex
68
69 threadedNewsMux sync.Mutex
70 ThreadedNews *ThreadedNews
71
72 flatNewsMux sync.Mutex
73 FlatNews []byte
74
75 banListMU sync.Mutex
76 banList map[string]*time.Time
77 }
78
79 func (s *Server) CurrentStats() Stats {
80 s.StatsMu.Lock()
81 defer s.StatsMu.Unlock()
82
83 stats := s.Stats
84 stats.CurrentlyConnected = len(s.Clients)
85
86 return *stats
87 }
88
89 type PrivateChat struct {
90 Subject string
91 ClientConn map[uint16]*ClientConn
92 }
93
94 func (s *Server) ListenAndServe(ctx context.Context, cancelRoot context.CancelFunc) error {
95 s.Logger.Info("Hotline server started",
96 "version", VERSION,
97 "API port", fmt.Sprintf("%s:%v", s.NetInterface, s.Port),
98 "Transfer port", fmt.Sprintf("%s:%v", s.NetInterface, s.Port+1),
99 )
100
101 var wg sync.WaitGroup
102
103 wg.Add(1)
104 go func() {
105 ln, err := net.Listen("tcp", fmt.Sprintf("%s:%v", s.NetInterface, s.Port))
106 if err != nil {
107 log.Fatal(err)
108 }
109
110 log.Fatal(s.Serve(ctx, ln))
111 }()
112
113 wg.Add(1)
114 go func() {
115 ln, err := net.Listen("tcp", fmt.Sprintf("%s:%v", s.NetInterface, s.Port+1))
116 if err != nil {
117 log.Fatal(err)
118 }
119
120 log.Fatal(s.ServeFileTransfers(ctx, ln))
121 }()
122
123 wg.Wait()
124
125 return nil
126 }
127
128 func (s *Server) ServeFileTransfers(ctx context.Context, ln net.Listener) error {
129 for {
130 conn, err := ln.Accept()
131 if err != nil {
132 return err
133 }
134
135 go func() {
136 defer func() { _ = conn.Close() }()
137
138 err = s.handleFileTransfer(
139 context.WithValue(ctx, contextKeyReq, requestCtx{
140 remoteAddr: conn.RemoteAddr().String(),
141 }),
142 conn,
143 )
144
145 if err != nil {
146 s.Logger.Error("file transfer error", "reason", err)
147 }
148 }()
149 }
150 }
151
152 func (s *Server) sendTransaction(t Transaction) error {
153 clientID, err := byteToInt(*t.clientID)
154 if err != nil {
155 return fmt.Errorf("invalid client ID: %v", err)
156 }
157
158 s.mux.Lock()
159 client, ok := s.Clients[uint16(clientID)]
160 s.mux.Unlock()
161 if !ok || client == nil {
162 return fmt.Errorf("invalid client id %v", *t.clientID)
163 }
164
165 _, err = io.Copy(client.Connection, &t)
166 if err != nil {
167 return fmt.Errorf("failed to send transaction to client %v: %v", clientID, err)
168 }
169
170 return nil
171 }
172
173 func (s *Server) processOutbox() {
174 for {
175 t := <-s.outbox
176 go func() {
177 if err := s.sendTransaction(t); err != nil {
178 s.Logger.Error("error sending transaction", "err", err)
179 }
180 }()
181 }
182 }
183
184 func (s *Server) Serve(ctx context.Context, ln net.Listener) error {
185 go s.processOutbox()
186
187 for {
188 conn, err := ln.Accept()
189 if err != nil {
190 s.Logger.Error("error accepting connection", "err", err)
191 }
192 connCtx := context.WithValue(ctx, contextKeyReq, requestCtx{
193 remoteAddr: conn.RemoteAddr().String(),
194 })
195
196 go func() {
197 s.Logger.Info("Connection established", "RemoteAddr", conn.RemoteAddr())
198
199 defer conn.Close()
200 if err := s.handleNewConnection(connCtx, conn, conn.RemoteAddr().String()); err != nil {
201 if err == io.EOF {
202 s.Logger.Info("Client disconnected", "RemoteAddr", conn.RemoteAddr())
203 } else {
204 s.Logger.Error("error serving request", "RemoteAddr", conn.RemoteAddr(), "err", err)
205 }
206 }
207 }()
208 }
209 }
210
211 const (
212 agreementFile = "Agreement.txt"
213 )
214
215 // NewServer constructs a new Server from a config dir
216 func NewServer(configDir, netInterface string, netPort int, logger *slog.Logger, fs FileStore) (*Server, error) {
217 server := Server{
218 NetInterface: netInterface,
219 Port: netPort,
220 Accounts: make(map[string]*Account),
221 Config: new(Config),
222 Clients: make(map[uint16]*ClientConn),
223 fileTransfers: make(map[[4]byte]*FileTransfer),
224 PrivateChats: make(map[uint32]*PrivateChat),
225 ConfigDir: configDir,
226 Logger: logger,
227 NextGuestID: new(uint16),
228 outbox: make(chan Transaction),
229 Stats: &Stats{Since: time.Now()},
230 ThreadedNews: &ThreadedNews{},
231 FS: fs,
232 banList: make(map[string]*time.Time),
233 }
234
235 var err error
236
237 // generate a new random passID for tracker registration
238 if _, err := rand.Read(server.TrackerPassID[:]); err != nil {
239 return nil, err
240 }
241
242 server.Agreement, err = os.ReadFile(filepath.Join(configDir, agreementFile))
243 if err != nil {
244 return nil, err
245 }
246
247 if server.FlatNews, err = os.ReadFile(filepath.Join(configDir, "MessageBoard.txt")); err != nil {
248 return nil, err
249 }
250
251 // try to load the ban list, but ignore errors as this file may not be present or may be empty
252 _ = server.loadBanList(filepath.Join(configDir, "Banlist.yaml"))
253
254 if err := server.loadThreadedNews(filepath.Join(configDir, "ThreadedNews.yaml")); err != nil {
255 return nil, err
256 }
257
258 if err := server.loadConfig(filepath.Join(configDir, "config.yaml")); err != nil {
259 return nil, err
260 }
261
262 if err := server.loadAccounts(filepath.Join(configDir, "Users/")); err != nil {
263 return nil, err
264 }
265
266 // If the FileRoot is an absolute path, use it, otherwise treat as a relative path to the config dir.
267 if !filepath.IsAbs(server.Config.FileRoot) {
268 server.Config.FileRoot = filepath.Join(configDir, server.Config.FileRoot)
269 }
270
271 server.banner, err = os.ReadFile(filepath.Join(server.ConfigDir, server.Config.BannerFile))
272 if err != nil {
273 return nil, fmt.Errorf("error opening banner: %w", err)
274 }
275
276 *server.NextGuestID = 1
277
278 if server.Config.EnableTrackerRegistration {
279 server.Logger.Info(
280 "Tracker registration enabled",
281 "frequency", fmt.Sprintf("%vs", trackerUpdateFrequency),
282 "trackers", server.Config.Trackers,
283 )
284
285 go func() {
286 for {
287 tr := &TrackerRegistration{
288 UserCount: server.userCount(),
289 PassID: server.TrackerPassID,
290 Name: server.Config.Name,
291 Description: server.Config.Description,
292 }
293 binary.BigEndian.PutUint16(tr.Port[:], uint16(server.Port))
294 for _, t := range server.Config.Trackers {
295 if err := register(t, tr); err != nil {
296 server.Logger.Error("unable to register with tracker %v", "error", err)
297 }
298 server.Logger.Debug("Sent Tracker registration", "addr", t)
299 }
300
301 time.Sleep(trackerUpdateFrequency * time.Second)
302 }
303 }()
304 }
305
306 // Start Client Keepalive go routine
307 go server.keepaliveHandler()
308
309 return &server, nil
310 }
311
312 func (s *Server) userCount() int {
313 s.mux.Lock()
314 defer s.mux.Unlock()
315
316 return len(s.Clients)
317 }
318
319 func (s *Server) keepaliveHandler() {
320 for {
321 time.Sleep(idleCheckInterval * time.Second)
322 s.mux.Lock()
323
324 for _, c := range s.Clients {
325 c.IdleTime += idleCheckInterval
326 if c.IdleTime > userIdleSeconds && !c.Idle {
327 c.Idle = true
328
329 flagBitmap := big.NewInt(int64(binary.BigEndian.Uint16(c.Flags)))
330 flagBitmap.SetBit(flagBitmap, UserFlagAway, 1)
331 binary.BigEndian.PutUint16(c.Flags, uint16(flagBitmap.Int64()))
332
333 c.sendAll(
334 TranNotifyChangeUser,
335 NewField(FieldUserID, *c.ID),
336 NewField(FieldUserFlags, c.Flags),
337 NewField(FieldUserName, c.UserName),
338 NewField(FieldUserIconID, c.Icon),
339 )
340 }
341 }
342 s.mux.Unlock()
343 }
344 }
345
346 func (s *Server) writeBanList() error {
347 s.banListMU.Lock()
348 defer s.banListMU.Unlock()
349
350 out, err := yaml.Marshal(s.banList)
351 if err != nil {
352 return err
353 }
354 err = os.WriteFile(
355 filepath.Join(s.ConfigDir, "Banlist.yaml"),
356 out,
357 0666,
358 )
359 return err
360 }
361
362 func (s *Server) writeThreadedNews() error {
363 s.threadedNewsMux.Lock()
364 defer s.threadedNewsMux.Unlock()
365
366 out, err := yaml.Marshal(s.ThreadedNews)
367 if err != nil {
368 return err
369 }
370 err = s.FS.WriteFile(
371 filepath.Join(s.ConfigDir, "ThreadedNews.yaml"),
372 out,
373 0666,
374 )
375 return err
376 }
377
378 func (s *Server) NewClientConn(conn io.ReadWriteCloser, remoteAddr string) *ClientConn {
379 s.mux.Lock()
380 defer s.mux.Unlock()
381
382 clientConn := &ClientConn{
383 ID: &[]byte{0, 0},
384 Icon: []byte{0, 0},
385 Flags: []byte{0, 0},
386 UserName: []byte{},
387 Connection: conn,
388 Server: s,
389 Version: []byte{},
390 AutoReply: []byte{},
391 RemoteAddr: remoteAddr,
392 transfers: map[int]map[[4]byte]*FileTransfer{
393 FileDownload: {},
394 FileUpload: {},
395 FolderDownload: {},
396 FolderUpload: {},
397 bannerDownload: {},
398 },
399 }
400
401 *s.NextGuestID++
402 ID := *s.NextGuestID
403
404 binary.BigEndian.PutUint16(*clientConn.ID, ID)
405 s.Clients[ID] = clientConn
406
407 return clientConn
408 }
409
410 // NewUser creates a new user account entry in the server map and config file
411 func (s *Server) NewUser(login, name, password string, access accessBitmap) error {
412 s.mux.Lock()
413 defer s.mux.Unlock()
414
415 account := Account{
416 Login: login,
417 Name: name,
418 Password: hashAndSalt([]byte(password)),
419 Access: access,
420 }
421 out, err := yaml.Marshal(&account)
422 if err != nil {
423 return err
424 }
425
426 // Create account file, returning an error if one already exists.
427 file, err := os.OpenFile(
428 filepath.Join(s.ConfigDir, "Users", path.Join("/", login)+".yaml"),
429 os.O_CREATE|os.O_EXCL|os.O_WRONLY,
430 0644,
431 )
432 if err != nil {
433 return err
434 }
435 defer file.Close()
436
437 _, err = file.Write(out)
438 if err != nil {
439 return fmt.Errorf("error writing account file: %w", err)
440 }
441
442 s.Accounts[login] = &account
443
444 return nil
445 }
446
447 func (s *Server) UpdateUser(login, newLogin, name, password string, access accessBitmap) error {
448 s.mux.Lock()
449 defer s.mux.Unlock()
450
451 // update renames the user login
452 if login != newLogin {
453 err := os.Rename(filepath.Join(s.ConfigDir, "Users", path.Join("/", login)+".yaml"), filepath.Join(s.ConfigDir, "Users", path.Join("/", newLogin)+".yaml"))
454 if err != nil {
455 return fmt.Errorf("unable to rename account: %w", err)
456 }
457 s.Accounts[newLogin] = s.Accounts[login]
458 s.Accounts[newLogin].Login = newLogin
459 delete(s.Accounts, login)
460 }
461
462 account := s.Accounts[newLogin]
463 account.Access = access
464 account.Name = name
465 account.Password = password
466
467 out, err := yaml.Marshal(&account)
468 if err != nil {
469 return err
470 }
471
472 if err := os.WriteFile(filepath.Join(s.ConfigDir, "Users", newLogin+".yaml"), out, 0666); err != nil {
473 return err
474 }
475
476 return nil
477 }
478
479 // DeleteUser deletes the user account
480 func (s *Server) DeleteUser(login string) error {
481 s.mux.Lock()
482 defer s.mux.Unlock()
483
484 err := s.FS.Remove(filepath.Join(s.ConfigDir, "Users", path.Join("/", login)+".yaml"))
485 if err != nil {
486 return err
487 }
488
489 delete(s.Accounts, login)
490
491 return nil
492 }
493
494 func (s *Server) connectedUsers() []Field {
495 s.mux.Lock()
496 defer s.mux.Unlock()
497
498 var connectedUsers []Field
499 for _, c := range sortedClients(s.Clients) {
500 b, err := io.ReadAll(&User{
501 ID: *c.ID,
502 Icon: c.Icon,
503 Flags: c.Flags,
504 Name: string(c.UserName),
505 })
506 if err != nil {
507 return nil
508 }
509 connectedUsers = append(connectedUsers, NewField(FieldUsernameWithInfo, b))
510 }
511 return connectedUsers
512 }
513
514 func (s *Server) loadBanList(path string) error {
515 fh, err := os.Open(path)
516 if err != nil {
517 return err
518 }
519 decoder := yaml.NewDecoder(fh)
520
521 return decoder.Decode(s.banList)
522 }
523
524 // loadThreadedNews loads the threaded news data from disk
525 func (s *Server) loadThreadedNews(threadedNewsPath string) error {
526 fh, err := os.Open(threadedNewsPath)
527 if err != nil {
528 return err
529 }
530 decoder := yaml.NewDecoder(fh)
531
532 return decoder.Decode(s.ThreadedNews)
533 }
534
535 // loadAccounts loads account data from disk
536 func (s *Server) loadAccounts(userDir string) error {
537 matches, err := filepath.Glob(filepath.Join(userDir, "*.yaml"))
538 if err != nil {
539 return err
540 }
541
542 if len(matches) == 0 {
543 return errors.New("no user accounts found in " + userDir)
544 }
545
546 for _, file := range matches {
547 fh, err := s.FS.Open(file)
548 if err != nil {
549 return err
550 }
551
552 account := Account{}
553 decoder := yaml.NewDecoder(fh)
554 if err = decoder.Decode(&account); err != nil {
555 return fmt.Errorf("error loading account %s: %w", file, err)
556 }
557
558 s.Accounts[account.Login] = &account
559 }
560 return nil
561 }
562
563 func (s *Server) loadConfig(path string) error {
564 fh, err := s.FS.Open(path)
565 if err != nil {
566 return err
567 }
568
569 decoder := yaml.NewDecoder(fh)
570 err = decoder.Decode(s.Config)
571 if err != nil {
572 return err
573 }
574
575 validate := validator.New()
576 err = validate.Struct(s.Config)
577 if err != nil {
578 return err
579 }
580 return nil
581 }
582
583 // handleNewConnection takes a new net.Conn and performs the initial login sequence
584 func (s *Server) handleNewConnection(ctx context.Context, rwc io.ReadWriteCloser, remoteAddr string) error {
585 defer dontPanic(s.Logger)
586
587 if err := Handshake(rwc); err != nil {
588 return err
589 }
590
591 // Create a new scanner for parsing incoming bytes into transaction tokens
592 scanner := bufio.NewScanner(rwc)
593 scanner.Split(transactionScanner)
594
595 scanner.Scan()
596
597 // Make a new []byte slice and copy the scanner bytes to it. This is critical to avoid a data race as the
598 // scanner re-uses the buffer for subsequent scans.
599 buf := make([]byte, len(scanner.Bytes()))
600 copy(buf, scanner.Bytes())
601
602 var clientLogin Transaction
603 if _, err := clientLogin.Write(buf); err != nil {
604 return err
605 }
606
607 // check if remoteAddr is present in the ban list
608 if banUntil, ok := s.banList[strings.Split(remoteAddr, ":")[0]]; ok {
609 // permaban
610 if banUntil == nil {
611 t := NewTransaction(
612 TranServerMsg,
613 &[]byte{0, 0},
614 NewField(FieldData, []byte("You are permanently banned on this server")),
615 NewField(FieldChatOptions, []byte{0, 0}),
616 )
617
618 _, err := io.Copy(rwc, t)
619 if err != nil {
620 return err
621 }
622
623 time.Sleep(1 * time.Second)
624 return nil
625 }
626
627 // temporary ban
628 if time.Now().Before(*banUntil) {
629 t := NewTransaction(
630 TranServerMsg,
631 &[]byte{0, 0},
632 NewField(FieldData, []byte("You are temporarily banned on this server")),
633 NewField(FieldChatOptions, []byte{0, 0}),
634 )
635
636 _, err := io.Copy(rwc, t)
637 if err != nil {
638 return err
639 }
640
641 time.Sleep(1 * time.Second)
642 return nil
643 }
644 }
645
646 c := s.NewClientConn(rwc, remoteAddr)
647 defer c.Disconnect()
648
649 encodedLogin := clientLogin.GetField(FieldUserLogin).Data
650 encodedPassword := clientLogin.GetField(FieldUserPassword).Data
651 c.Version = clientLogin.GetField(FieldVersion).Data
652
653 var login string
654 for _, char := range encodedLogin {
655 login += string(rune(255 - uint(char)))
656 }
657 if login == "" {
658 login = GuestAccount
659 }
660
661 c.logger = s.Logger.With("remoteAddr", remoteAddr, "login", login)
662
663 // If authentication fails, send error reply and close connection
664 if !c.Authenticate(login, encodedPassword) {
665 t := c.NewErrReply(&clientLogin, "Incorrect login.")
666
667 _, err := io.Copy(rwc, &t)
668 if err != nil {
669 return err
670 }
671
672 c.logger.Info("Login failed", "clientVersion", fmt.Sprintf("%x", c.Version))
673
674 return nil
675 }
676
677 if clientLogin.GetField(FieldUserIconID).Data != nil {
678 c.Icon = clientLogin.GetField(FieldUserIconID).Data
679 }
680
681 c.Account = c.Server.Accounts[login]
682
683 if clientLogin.GetField(FieldUserName).Data != nil {
684 if c.Authorize(accessAnyName) {
685 c.UserName = clientLogin.GetField(FieldUserName).Data
686 } else {
687 c.UserName = []byte(c.Account.Name)
688 }
689 }
690
691 if c.Authorize(accessDisconUser) {
692 c.Flags = []byte{0, 2}
693 }
694
695 s.outbox <- c.NewReply(&clientLogin,
696 NewField(FieldVersion, []byte{0x00, 0xbe}),
697 NewField(FieldCommunityBannerID, []byte{0, 0}),
698 NewField(FieldServerName, []byte(s.Config.Name)),
699 )
700
701 // Send user access privs so client UI knows how to behave
702 c.Server.outbox <- *NewTransaction(TranUserAccess, c.ID, NewField(FieldUserAccess, c.Account.Access[:]))
703
704 // Accounts with accessNoAgreement do not receive the server agreement on login. The behavior is different between
705 // client versions. For 1.2.3 client, we do not send TranShowAgreement. For other client versions, we send
706 // TranShowAgreement but with the NoServerAgreement field set to 1.
707 if c.Authorize(accessNoAgreement) {
708 // If client version is nil, then the client uses the 1.2.3 login behavior
709 if c.Version != nil {
710 c.Server.outbox <- *NewTransaction(TranShowAgreement, c.ID, NewField(FieldNoServerAgreement, []byte{1}))
711 }
712 } else {
713 c.Server.outbox <- *NewTransaction(TranShowAgreement, c.ID, NewField(FieldData, s.Agreement))
714 }
715
716 // If the client has provided a username as part of the login, we can infer that it is using the 1.2.3 login
717 // flow and not the 1.5+ flow.
718 if len(c.UserName) != 0 {
719 // Add the client username to the logger. For 1.5+ clients, we don't have this information yet as it comes as
720 // part of TranAgreed
721 c.logger = c.logger.With("Name", string(c.UserName))
722
723 c.logger.Info("Login successful", "clientVersion", "Not sent (probably 1.2.3)")
724
725 // Notify other clients on the server that the new user has logged in. For 1.5+ clients we don't have this
726 // information yet, so we do it in TranAgreed instead
727 for _, t := range c.notifyOthers(
728 *NewTransaction(
729 TranNotifyChangeUser, nil,
730 NewField(FieldUserName, c.UserName),
731 NewField(FieldUserID, *c.ID),
732 NewField(FieldUserIconID, c.Icon),
733 NewField(FieldUserFlags, c.Flags),
734 ),
735 ) {
736 c.Server.outbox <- t
737 }
738 }
739
740 c.Server.Stats.ConnectionCounter += 1
741 if len(s.Clients) > c.Server.Stats.ConnectionPeak {
742 c.Server.Stats.ConnectionPeak = len(s.Clients)
743 }
744
745 // Scan for new transactions and handle them as they come in.
746 for scanner.Scan() {
747 // Make a new []byte slice and copy the scanner bytes to it. This is critical to avoid a data race as the
748 // scanner re-uses the buffer for subsequent scans.
749 buf := make([]byte, len(scanner.Bytes()))
750 copy(buf, scanner.Bytes())
751
752 var t Transaction
753 if _, err := t.Write(buf); err != nil {
754 return err
755 }
756
757 if err := c.handleTransaction(t); err != nil {
758 c.logger.Error("Error handling transaction", "err", err)
759 }
760 }
761 return nil
762 }
763
764 func (s *Server) NewPrivateChat(cc *ClientConn) []byte {
765 s.PrivateChatsMu.Lock()
766 defer s.PrivateChatsMu.Unlock()
767
768 randID := make([]byte, 4)
769 rand.Read(randID)
770 data := binary.BigEndian.Uint32(randID)
771
772 s.PrivateChats[data] = &PrivateChat{
773 ClientConn: make(map[uint16]*ClientConn),
774 }
775 s.PrivateChats[data].ClientConn[cc.uint16ID()] = cc
776
777 return randID
778 }
779
780 const dlFldrActionSendFile = 1
781 const dlFldrActionResumeFile = 2
782 const dlFldrActionNextFile = 3
783
784 // handleFileTransfer receives a client net.Conn from the file transfer server, performs the requested transfer type, then closes the connection
785 func (s *Server) handleFileTransfer(ctx context.Context, rwc io.ReadWriter) error {
786 defer dontPanic(s.Logger)
787
788 txBuf := make([]byte, 16)
789 if _, err := io.ReadFull(rwc, txBuf); err != nil {
790 return err
791 }
792
793 var t transfer
794 if _, err := t.Write(txBuf); err != nil {
795 return err
796 }
797
798 defer func() {
799 s.mux.Lock()
800 delete(s.fileTransfers, t.ReferenceNumber)
801 s.mux.Unlock()
802
803 // Wait a few seconds before closing the connection: this is a workaround for problems
804 // observed with Windows clients where the client must initiate close of the TCP connection before
805 // the server does. This is gross and seems unnecessary. TODO: Revisit?
806 time.Sleep(3 * time.Second)
807 }()
808
809 s.mux.Lock()
810 fileTransfer, ok := s.fileTransfers[t.ReferenceNumber]
811 s.mux.Unlock()
812 if !ok {
813 return errors.New("invalid transaction ID")
814 }
815
816 defer func() {
817 fileTransfer.ClientConn.transfersMU.Lock()
818 delete(fileTransfer.ClientConn.transfers[fileTransfer.Type], t.ReferenceNumber)
819 fileTransfer.ClientConn.transfersMU.Unlock()
820 }()
821
822 rLogger := s.Logger.With(
823 "remoteAddr", ctx.Value(contextKeyReq).(requestCtx).remoteAddr,
824 "login", fileTransfer.ClientConn.Account.Login,
825 "Name", string(fileTransfer.ClientConn.UserName),
826 )
827
828 fullPath, err := readPath(s.Config.FileRoot, fileTransfer.FilePath, fileTransfer.FileName)
829 if err != nil {
830 return err
831 }
832
833 switch fileTransfer.Type {
834 case bannerDownload:
835 if _, err := io.Copy(rwc, bytes.NewBuffer(s.banner)); err != nil {
836 return fmt.Errorf("error sending banner: %w", err)
837 }
838 case FileDownload:
839 s.Stats.DownloadCounter += 1
840 s.Stats.DownloadsInProgress += 1
841 defer func() {
842 s.Stats.DownloadsInProgress -= 1
843 }()
844
845 var dataOffset int64
846 if fileTransfer.fileResumeData != nil {
847 dataOffset = int64(binary.BigEndian.Uint32(fileTransfer.fileResumeData.ForkInfoList[0].DataSize[:]))
848 }
849
850 fw, err := newFileWrapper(s.FS, fullPath, 0)
851 if err != nil {
852 return err
853 }
854
855 rLogger.Info("File download started", "filePath", fullPath)
856
857 // if file transfer options are included, that means this is a "quick preview" request from a 1.5+ client
858 if fileTransfer.options == nil {
859 _, err = io.Copy(rwc, fw.ffo)
860 if err != nil {
861 return err
862 }
863 }
864
865 file, err := fw.dataForkReader()
866 if err != nil {
867 return err
868 }
869
870 br := bufio.NewReader(file)
871 if _, err := br.Discard(int(dataOffset)); err != nil {
872 return err
873 }
874
875 if _, err = io.Copy(rwc, io.TeeReader(br, fileTransfer.bytesSentCounter)); err != nil {
876 return err
877 }
878
879 // if the client requested to resume transfer, do not send the resource fork header, or it will be appended into the fileWrapper data
880 if fileTransfer.fileResumeData == nil {
881 err = binary.Write(rwc, binary.BigEndian, fw.rsrcForkHeader())
882 if err != nil {
883 return err
884 }
885 }
886
887 rFile, err := fw.rsrcForkFile()
888 if err != nil {
889 return nil
890 }
891
892 if _, err = io.Copy(rwc, io.TeeReader(rFile, fileTransfer.bytesSentCounter)); err != nil {
893 return err
894 }
895
896 case FileUpload:
897 s.Stats.UploadCounter += 1
898 s.Stats.UploadsInProgress += 1
899 defer func() { s.Stats.UploadsInProgress -= 1 }()
900
901 var file *os.File
902
903 // A file upload has three possible cases:
904 // 1) Upload a new file
905 // 2) Resume a partially transferred file
906 // 3) Replace a fully uploaded file
907 // We have to infer which case applies by inspecting what is already on the filesystem
908
909 // 1) Check for existing file:
910 _, err = os.Stat(fullPath)
911 if err == nil {
912 return errors.New("existing file found at " + fullPath)
913 }
914 if errors.Is(err, fs.ErrNotExist) {
915 // If not found, open or create a new .incomplete file
916 file, err = os.OpenFile(fullPath+incompleteFileSuffix, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
917 if err != nil {
918 return err
919 }
920 }
921
922 f, err := newFileWrapper(s.FS, fullPath, 0)
923 if err != nil {
924 return err
925 }
926
927 rLogger.Info("File upload started", "dstFile", fullPath)
928
929 rForkWriter := io.Discard
930 iForkWriter := io.Discard
931 if s.Config.PreserveResourceForks {
932 rForkWriter, err = f.rsrcForkWriter()
933 if err != nil {
934 return err
935 }
936
937 iForkWriter, err = f.infoForkWriter()
938 if err != nil {
939 return err
940 }
941 }
942
943 if err := receiveFile(rwc, file, rForkWriter, iForkWriter, fileTransfer.bytesSentCounter); err != nil {
944 s.Logger.Error(err.Error())
945 }
946
947 if err := file.Close(); err != nil {
948 return err
949 }
950
951 if err := s.FS.Rename(fullPath+".incomplete", fullPath); err != nil {
952 return err
953 }
954
955 rLogger.Info("File upload complete", "dstFile", fullPath)
956
957 case FolderDownload:
958 s.Stats.DownloadCounter += 1
959 s.Stats.DownloadsInProgress += 1
960 defer func() { s.Stats.DownloadsInProgress -= 1 }()
961
962 // Folder Download flow:
963 // 1. Get filePath from the transfer
964 // 2. Iterate over files
965 // 3. For each fileWrapper:
966 // Send fileWrapper header to client
967 // The client can reply in 3 ways:
968 //
969 // 1. If type is an odd number (unknown type?), or fileWrapper download for the current fileWrapper is completed:
970 // client sends []byte{0x00, 0x03} to tell the server to continue to the next fileWrapper
971 //
972 // 2. If download of a fileWrapper is to be resumed:
973 // client sends:
974 // []byte{0x00, 0x02} // download folder action
975 // [2]byte // Resume data size
976 // []byte fileWrapper resume data (see myField_FileResumeData)
977 //
978 // 3. Otherwise, download of the fileWrapper is requested and client sends []byte{0x00, 0x01}
979 //
980 // When download is requested (case 2 or 3), server replies with:
981 // [4]byte - fileWrapper size
982 // []byte - Flattened File Object
983 //
984 // After every fileWrapper download, client could request next fileWrapper with:
985 // []byte{0x00, 0x03}
986 //
987 // This notifies the server to send the next item header
988
989 basePathLen := len(fullPath)
990
991 rLogger.Info("Start folder download", "path", fullPath)
992
993 nextAction := make([]byte, 2)
994 if _, err := io.ReadFull(rwc, nextAction); err != nil {
995 return err
996 }
997
998 i := 0
999 err = filepath.Walk(fullPath+"/", func(path string, info os.FileInfo, err error) error {
1000 s.Stats.DownloadCounter += 1
1001 i += 1
1002
1003 if err != nil {
1004 return err
1005 }
1006
1007 // skip dot files
1008 if strings.HasPrefix(info.Name(), ".") {
1009 return nil
1010 }
1011
1012 hlFile, err := newFileWrapper(s.FS, path, 0)
1013 if err != nil {
1014 return err
1015 }
1016
1017 subPath := path[basePathLen+1:]
1018 rLogger.Debug("Sending fileheader", "i", i, "path", path, "fullFilePath", fullPath, "subPath", subPath, "IsDir", info.IsDir())
1019
1020 if i == 1 {
1021 return nil
1022 }
1023
1024 fileHeader := NewFileHeader(subPath, info.IsDir())
1025 if _, err := io.Copy(rwc, &fileHeader); err != nil {
1026 return fmt.Errorf("error sending file header: %w", err)
1027 }
1028
1029 // Read the client's Next Action request
1030 if _, err := io.ReadFull(rwc, nextAction); err != nil {
1031 return err
1032 }
1033
1034 rLogger.Debug("Client folder download action", "action", fmt.Sprintf("%X", nextAction[0:2]))
1035
1036 var dataOffset int64
1037
1038 switch nextAction[1] {
1039 case dlFldrActionResumeFile:
1040 // get size of resumeData
1041 resumeDataByteLen := make([]byte, 2)
1042 if _, err := io.ReadFull(rwc, resumeDataByteLen); err != nil {
1043 return err
1044 }
1045
1046 resumeDataLen := binary.BigEndian.Uint16(resumeDataByteLen)
1047 resumeDataBytes := make([]byte, resumeDataLen)
1048 if _, err := io.ReadFull(rwc, resumeDataBytes); err != nil {
1049 return err
1050 }
1051
1052 var frd FileResumeData
1053 if err := frd.UnmarshalBinary(resumeDataBytes); err != nil {
1054 return err
1055 }
1056 dataOffset = int64(binary.BigEndian.Uint32(frd.ForkInfoList[0].DataSize[:]))
1057 case dlFldrActionNextFile:
1058 // client asked to skip this file
1059 return nil
1060 }
1061
1062 if info.IsDir() {
1063 return nil
1064 }
1065
1066 rLogger.Info("File download started",
1067 "fileName", info.Name(),
1068 "TransferSize", fmt.Sprintf("%x", hlFile.ffo.TransferSize(dataOffset)),
1069 )
1070
1071 // Send file size to client
1072 if _, err := rwc.Write(hlFile.ffo.TransferSize(dataOffset)); err != nil {
1073 s.Logger.Error(err.Error())
1074 return err
1075 }
1076
1077 // Send ffo bytes to client
1078 _, err = io.Copy(rwc, hlFile.ffo)
1079 if err != nil {
1080 return err
1081 }
1082
1083 file, err := s.FS.Open(path)
1084 if err != nil {
1085 return err
1086 }
1087
1088 // wr := bufio.NewWriterSize(rwc, 1460)
1089 if _, err = io.Copy(rwc, io.TeeReader(file, fileTransfer.bytesSentCounter)); err != nil {
1090 return err
1091 }
1092
1093 if nextAction[1] != 2 && hlFile.ffo.FlatFileHeader.ForkCount[1] == 3 {
1094 err = binary.Write(rwc, binary.BigEndian, hlFile.rsrcForkHeader())
1095 if err != nil {
1096 return err
1097 }
1098
1099 rFile, err := hlFile.rsrcForkFile()
1100 if err != nil {
1101 return err
1102 }
1103
1104 if _, err = io.Copy(rwc, io.TeeReader(rFile, fileTransfer.bytesSentCounter)); err != nil {
1105 return err
1106 }
1107 }
1108
1109 // Read the client's Next Action request. This is always 3, I think?
1110 if _, err := io.ReadFull(rwc, nextAction); err != nil {
1111 return err
1112 }
1113
1114 return nil
1115 })
1116
1117 if err != nil {
1118 return err
1119 }
1120
1121 case FolderUpload:
1122 s.Stats.UploadCounter += 1
1123 s.Stats.UploadsInProgress += 1
1124 defer func() { s.Stats.UploadsInProgress -= 1 }()
1125 rLogger.Info(
1126 "Folder upload started",
1127 "dstPath", fullPath,
1128 "TransferSize", binary.BigEndian.Uint32(fileTransfer.TransferSize),
1129 "FolderItemCount", fileTransfer.FolderItemCount,
1130 )
1131
1132 // Check if the target folder exists. If not, create it.
1133 if _, err := s.FS.Stat(fullPath); os.IsNotExist(err) {
1134 if err := s.FS.Mkdir(fullPath, 0777); err != nil {
1135 return err
1136 }
1137 }
1138
1139 // Begin the folder upload flow by sending the "next file action" to client
1140 if _, err := rwc.Write([]byte{0, dlFldrActionNextFile}); err != nil {
1141 return err
1142 }
1143
1144 fileSize := make([]byte, 4)
1145
1146 for i := 0; i < fileTransfer.ItemCount(); i++ {
1147 s.Stats.UploadCounter += 1
1148
1149 var fu folderUpload
1150 if _, err := io.ReadFull(rwc, fu.DataSize[:]); err != nil {
1151 return err
1152 }
1153 if _, err := io.ReadFull(rwc, fu.IsFolder[:]); err != nil {
1154 return err
1155 }
1156 if _, err := io.ReadFull(rwc, fu.PathItemCount[:]); err != nil {
1157 return err
1158 }
1159
1160 fu.FileNamePath = make([]byte, binary.BigEndian.Uint16(fu.DataSize[:])-4) // -4 to subtract the path separator bytes
1161
1162 if _, err := io.ReadFull(rwc, fu.FileNamePath); err != nil {
1163 return err
1164 }
1165
1166 rLogger.Info(
1167 "Folder upload continued",
1168 "FormattedPath", fu.FormattedPath(),
1169 "IsFolder", fmt.Sprintf("%x", fu.IsFolder),
1170 "PathItemCount", binary.BigEndian.Uint16(fu.PathItemCount[:]),
1171 )
1172
1173 if fu.IsFolder == [2]byte{0, 1} {
1174 if _, err := os.Stat(filepath.Join(fullPath, fu.FormattedPath())); os.IsNotExist(err) {
1175 if err := os.Mkdir(filepath.Join(fullPath, fu.FormattedPath()), 0777); err != nil {
1176 return err
1177 }
1178 }
1179
1180 // Tell client to send next file
1181 if _, err := rwc.Write([]byte{0, dlFldrActionNextFile}); err != nil {
1182 return err
1183 }
1184 } else {
1185 nextAction := dlFldrActionSendFile
1186
1187 // Check if we have the full file already. If so, send dlFldrAction_NextFile to client to skip.
1188 _, err = os.Stat(filepath.Join(fullPath, fu.FormattedPath()))
1189 if err != nil && !errors.Is(err, fs.ErrNotExist) {
1190 return err
1191 }
1192 if err == nil {
1193 nextAction = dlFldrActionNextFile
1194 }
1195
1196 // Check if we have a partial file already. If so, send dlFldrAction_ResumeFile to client to resume upload.
1197 incompleteFile, err := os.Stat(filepath.Join(fullPath, fu.FormattedPath()+incompleteFileSuffix))
1198 if err != nil && !errors.Is(err, fs.ErrNotExist) {
1199 return err
1200 }
1201 if err == nil {
1202 nextAction = dlFldrActionResumeFile
1203 }
1204
1205 if _, err := rwc.Write([]byte{0, uint8(nextAction)}); err != nil {
1206 return err
1207 }
1208
1209 switch nextAction {
1210 case dlFldrActionNextFile:
1211 continue
1212 case dlFldrActionResumeFile:
1213 offset := make([]byte, 4)
1214 binary.BigEndian.PutUint32(offset, uint32(incompleteFile.Size()))
1215
1216 file, err := os.OpenFile(fullPath+"/"+fu.FormattedPath()+incompleteFileSuffix, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
1217 if err != nil {
1218 return err
1219 }
1220
1221 fileResumeData := NewFileResumeData([]ForkInfoList{*NewForkInfoList(offset)})
1222
1223 b, _ := fileResumeData.BinaryMarshal()
1224
1225 bs := make([]byte, 2)
1226 binary.BigEndian.PutUint16(bs, uint16(len(b)))
1227
1228 if _, err := rwc.Write(append(bs, b...)); err != nil {
1229 return err
1230 }
1231
1232 if _, err := io.ReadFull(rwc, fileSize); err != nil {
1233 return err
1234 }
1235
1236 if err := receiveFile(rwc, file, io.Discard, io.Discard, fileTransfer.bytesSentCounter); err != nil {
1237 s.Logger.Error(err.Error())
1238 }
1239
1240 err = os.Rename(fullPath+"/"+fu.FormattedPath()+".incomplete", fullPath+"/"+fu.FormattedPath())
1241 if err != nil {
1242 return err
1243 }
1244
1245 case dlFldrActionSendFile:
1246 if _, err := io.ReadFull(rwc, fileSize); err != nil {
1247 return err
1248 }
1249
1250 filePath := filepath.Join(fullPath, fu.FormattedPath())
1251
1252 hlFile, err := newFileWrapper(s.FS, filePath, 0)
1253 if err != nil {
1254 return err
1255 }
1256
1257 rLogger.Info("Starting file transfer", "path", filePath, "fileNum", i+1, "fileSize", binary.BigEndian.Uint32(fileSize))
1258
1259 incWriter, err := hlFile.incFileWriter()
1260 if err != nil {
1261 return err
1262 }
1263
1264 rForkWriter := io.Discard
1265 iForkWriter := io.Discard
1266 if s.Config.PreserveResourceForks {
1267 iForkWriter, err = hlFile.infoForkWriter()
1268 if err != nil {
1269 return err
1270 }
1271
1272 rForkWriter, err = hlFile.rsrcForkWriter()
1273 if err != nil {
1274 return err
1275 }
1276 }
1277 if err := receiveFile(rwc, incWriter, rForkWriter, iForkWriter, fileTransfer.bytesSentCounter); err != nil {
1278 return err
1279 }
1280
1281 if err := os.Rename(filePath+".incomplete", filePath); err != nil {
1282 return err
1283 }
1284 }
1285
1286 // Tell client to send next fileWrapper
1287 if _, err := rwc.Write([]byte{0, dlFldrActionNextFile}); err != nil {
1288 return err
1289 }
1290 }
1291 }
1292 rLogger.Info("Folder upload complete")
1293 }
1294
1295 return nil
1296 }
Friendship Quest remix of mobius, a hotline server in go #cli