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