source: code/trunk/user.go@ 540

Last change on this file since 540 was 540, checked in by contact, 4 years ago

Add support for IRCv3 setname

References: ​https://todo.sr.ht/~emersion/soju/41
File size: 19.7 KB
Line 
1package soju
2
3import (
4 "crypto/sha256"
5 "encoding/binary"
6 "encoding/hex"
7 "fmt"
8 "time"
9
10 "gopkg.in/irc.v3"
11)
12
13type event interface{}
14
15type eventUpstreamMessage struct {
16 msg *irc.Message
17 uc *upstreamConn
18}
19
20type eventUpstreamConnectionError struct {
21 net *network
22 err error
23}
24
25type eventUpstreamConnected struct {
26 uc *upstreamConn
27}
28
29type eventUpstreamDisconnected struct {
30 uc *upstreamConn
31}
32
33type eventUpstreamError struct {
34 uc *upstreamConn
35 err error
36}
37
38type eventDownstreamMessage struct {
39 msg *irc.Message
40 dc *downstreamConn
41}
42
43type eventDownstreamConnected struct {
44 dc *downstreamConn
45}
46
47type eventDownstreamDisconnected struct {
48 dc *downstreamConn
49}
50
51type eventChannelDetach struct {
52 uc *upstreamConn
53 name string
54}
55
56type eventStop struct{}
57
58type deliveredClientMap map[string]string // client name -> msg ID
59
60type deliveredStore struct {
61 m deliveredCasemapMap
62}
63
64func newDeliveredStore() deliveredStore {
65 return deliveredStore{deliveredCasemapMap{newCasemapMap(0)}}
66}
67
68func (ds deliveredStore) HasTarget(target string) bool {
69 return ds.m.Value(target) != nil
70}
71
72func (ds deliveredStore) LoadID(target, clientName string) string {
73 clients := ds.m.Value(target)
74 if clients == nil {
75 return ""
76 }
77 return clients[clientName]
78}
79
80func (ds deliveredStore) StoreID(target, clientName, msgID string) {
81 clients := ds.m.Value(target)
82 if clients == nil {
83 clients = make(deliveredClientMap)
84 ds.m.SetValue(target, clients)
85 }
86 clients[clientName] = msgID
87}
88
89func (ds deliveredStore) ForEachTarget(f func(target string)) {
90 for _, entry := range ds.m.innerMap {
91 f(entry.originalKey)
92 }
93}
94
95func (ds deliveredStore) ForEachClient(f func(clientName string)) {
96 clients := make(map[string]struct{})
97 for _, entry := range ds.m.innerMap {
98 delivered := entry.value.(deliveredClientMap)
99 for clientName := range delivered {
100 clients[clientName] = struct{}{}
101 }
102 }
103
104 for clientName := range clients {
105 f(clientName)
106 }
107}
108
109type network struct {
110 Network
111 user *user
112 logger Logger
113 stopped chan struct{}
114
115 conn *upstreamConn
116 channels channelCasemapMap
117 delivered deliveredStore
118 lastError error
119 casemap casemapping
120}
121
122func newNetwork(user *user, record *Network, channels []Channel) *network {
123 logger := &prefixLogger{user.logger, fmt.Sprintf("network %q: ", record.GetName())}
124
125 m := channelCasemapMap{newCasemapMap(0)}
126 for _, ch := range channels {
127 ch := ch
128 m.SetValue(ch.Name, &ch)
129 }
130
131 return &network{
132 Network: *record,
133 user: user,
134 logger: logger,
135 stopped: make(chan struct{}),
136 channels: m,
137 delivered: newDeliveredStore(),
138 casemap: casemapRFC1459,
139 }
140}
141
142func (net *network) forEachDownstream(f func(*downstreamConn)) {
143 net.user.forEachDownstream(func(dc *downstreamConn) {
144 if dc.network == nil && dc.caps["soju.im/bouncer-networks"] {
145 return
146 }
147 if dc.network != nil && dc.network != net {
148 return
149 }
150 f(dc)
151 })
152}
153
154func (net *network) isStopped() bool {
155 select {
156 case <-net.stopped:
157 return true
158 default:
159 return false
160 }
161}
162
163func userIdent(u *User) string {
164 // The ident is a string we will send to upstream servers in clear-text.
165 // For privacy reasons, make sure it doesn't expose any meaningful user
166 // metadata. We just use the base64-encoded hashed ID, so that people don't
167 // start relying on the string being an integer or following a pattern.
168 var b [64]byte
169 binary.LittleEndian.PutUint64(b[:], uint64(u.ID))
170 h := sha256.Sum256(b[:])
171 return hex.EncodeToString(h[:16])
172}
173
174func (net *network) run() {
175 var lastTry time.Time
176 for {
177 if net.isStopped() {
178 return
179 }
180
181 if dur := time.Now().Sub(lastTry); dur < retryConnectDelay {
182 delay := retryConnectDelay - dur
183 net.logger.Printf("waiting %v before trying to reconnect to %q", delay.Truncate(time.Second), net.Addr)
184 time.Sleep(delay)
185 }
186 lastTry = time.Now()
187
188 uc, err := connectToUpstream(net)
189 if err != nil {
190 net.logger.Printf("failed to connect to upstream server %q: %v", net.Addr, err)
191 net.user.events <- eventUpstreamConnectionError{net, fmt.Errorf("failed to connect: %v", err)}
192 continue
193 }
194
195 if net.user.srv.Identd != nil {
196 net.user.srv.Identd.Store(uc.RemoteAddr().String(), uc.LocalAddr().String(), userIdent(&net.user.User))
197 }
198
199 uc.register()
200 if err := uc.runUntilRegistered(); err != nil {
201 text := err.Error()
202 if regErr, ok := err.(registrationError); ok {
203 text = string(regErr)
204 }
205 uc.logger.Printf("failed to register: %v", text)
206 net.user.events <- eventUpstreamConnectionError{net, fmt.Errorf("failed to register: %v", text)}
207 uc.Close()
208 continue
209 }
210
211 // TODO: this is racy with net.stopped. If the network is stopped
212 // before the user goroutine receives eventUpstreamConnected, the
213 // connection won't be closed.
214 net.user.events <- eventUpstreamConnected{uc}
215 if err := uc.readMessages(net.user.events); err != nil {
216 uc.logger.Printf("failed to handle messages: %v", err)
217 net.user.events <- eventUpstreamError{uc, fmt.Errorf("failed to handle messages: %v", err)}
218 }
219 uc.Close()
220 net.user.events <- eventUpstreamDisconnected{uc}
221
222 if net.user.srv.Identd != nil {
223 net.user.srv.Identd.Delete(uc.RemoteAddr().String(), uc.LocalAddr().String())
224 }
225 }
226}
227
228func (net *network) stop() {
229 if !net.isStopped() {
230 close(net.stopped)
231 }
232
233 if net.conn != nil {
234 net.conn.Close()
235 }
236}
237
238func (net *network) detach(ch *Channel) {
239 if ch.Detached {
240 return
241 }
242
243 net.logger.Printf("detaching channel %q", ch.Name)
244
245 ch.Detached = true
246
247 if net.user.msgStore != nil {
248 nameCM := net.casemap(ch.Name)
249 lastID, err := net.user.msgStore.LastMsgID(net, nameCM, time.Now())
250 if err != nil {
251 net.logger.Printf("failed to get last message ID for channel %q: %v", ch.Name, err)
252 }
253 ch.DetachedInternalMsgID = lastID
254 }
255
256 if net.conn != nil {
257 uch := net.conn.channels.Value(ch.Name)
258 if uch != nil {
259 uch.updateAutoDetach(0)
260 }
261 }
262
263 net.forEachDownstream(func(dc *downstreamConn) {
264 dc.SendMessage(&irc.Message{
265 Prefix: dc.prefix(),
266 Command: "PART",
267 Params: []string{dc.marshalEntity(net, ch.Name), "Detach"},
268 })
269 })
270}
271
272func (net *network) attach(ch *Channel) {
273 if !ch.Detached {
274 return
275 }
276
277 net.logger.Printf("attaching channel %q", ch.Name)
278
279 detachedMsgID := ch.DetachedInternalMsgID
280 ch.Detached = false
281 ch.DetachedInternalMsgID = ""
282
283 var uch *upstreamChannel
284 if net.conn != nil {
285 uch = net.conn.channels.Value(ch.Name)
286
287 net.conn.updateChannelAutoDetach(ch.Name)
288 }
289
290 net.forEachDownstream(func(dc *downstreamConn) {
291 dc.SendMessage(&irc.Message{
292 Prefix: dc.prefix(),
293 Command: "JOIN",
294 Params: []string{dc.marshalEntity(net, ch.Name)},
295 })
296
297 if uch != nil {
298 forwardChannel(dc, uch)
299 }
300
301 if detachedMsgID != "" {
302 dc.sendTargetBacklog(net, ch.Name, detachedMsgID)
303 }
304 })
305}
306
307func (net *network) deleteChannel(name string) error {
308 ch := net.channels.Value(name)
309 if ch == nil {
310 return fmt.Errorf("unknown channel %q", name)
311 }
312 if net.conn != nil {
313 uch := net.conn.channels.Value(ch.Name)
314 if uch != nil {
315 uch.updateAutoDetach(0)
316 }
317 }
318
319 if err := net.user.srv.db.DeleteChannel(ch.ID); err != nil {
320 return err
321 }
322 net.channels.Delete(name)
323 return nil
324}
325
326func (net *network) updateCasemapping(newCasemap casemapping) {
327 net.casemap = newCasemap
328 net.channels.SetCasemapping(newCasemap)
329 net.delivered.m.SetCasemapping(newCasemap)
330 if net.conn != nil {
331 net.conn.channels.SetCasemapping(newCasemap)
332 for _, entry := range net.conn.channels.innerMap {
333 uch := entry.value.(*upstreamChannel)
334 uch.Members.SetCasemapping(newCasemap)
335 }
336 }
337}
338
339func (net *network) storeClientDeliveryReceipts(clientName string) {
340 if !net.user.hasPersistentMsgStore() {
341 return
342 }
343
344 var receipts []DeliveryReceipt
345 net.delivered.ForEachTarget(func(target string) {
346 msgID := net.delivered.LoadID(target, clientName)
347 if msgID == "" {
348 return
349 }
350 receipts = append(receipts, DeliveryReceipt{
351 Target: target,
352 InternalMsgID: msgID,
353 })
354 })
355
356 if err := net.user.srv.db.StoreClientDeliveryReceipts(net.ID, clientName, receipts); err != nil {
357 net.logger.Printf("failed to store delivery receipts for client %q: %v", clientName, err)
358 }
359}
360
361func (net *network) isHighlight(msg *irc.Message) bool {
362 if msg.Command != "PRIVMSG" && msg.Command != "NOTICE" {
363 return false
364 }
365
366 text := msg.Params[1]
367
368 nick := net.Nick
369 if net.conn != nil {
370 nick = net.conn.nick
371 }
372
373 // TODO: use case-mapping aware comparison here
374 return msg.Prefix.Name != nick && isHighlight(text, nick)
375}
376
377func (net *network) detachedMessageNeedsRelay(ch *Channel, msg *irc.Message) bool {
378 highlight := net.isHighlight(msg)
379 return ch.RelayDetached == FilterMessage || ((ch.RelayDetached == FilterHighlight || ch.RelayDetached == FilterDefault) && highlight)
380}
381
382type user struct {
383 User
384 srv *Server
385 logger Logger
386
387 events chan event
388 done chan struct{}
389
390 networks []*network
391 downstreamConns []*downstreamConn
392 msgStore messageStore
393
394 // LIST commands in progress
395 pendingLISTs []pendingLIST
396}
397
398type pendingLIST struct {
399 downstreamID uint64
400 // list of per-upstream LIST commands not yet sent or completed
401 pendingCommands map[int64]*irc.Message
402}
403
404func newUser(srv *Server, record *User) *user {
405 logger := &prefixLogger{srv.Logger, fmt.Sprintf("user %q: ", record.Username)}
406
407 var msgStore messageStore
408 if srv.LogPath != "" {
409 msgStore = newFSMessageStore(srv.LogPath, record.Username)
410 } else {
411 msgStore = newMemoryMessageStore()
412 }
413
414 return &user{
415 User: *record,
416 srv: srv,
417 logger: logger,
418 events: make(chan event, 64),
419 done: make(chan struct{}),
420 msgStore: msgStore,
421 }
422}
423
424func (u *user) forEachNetwork(f func(*network)) {
425 for _, network := range u.networks {
426 f(network)
427 }
428}
429
430func (u *user) forEachUpstream(f func(uc *upstreamConn)) {
431 for _, network := range u.networks {
432 if network.conn == nil {
433 continue
434 }
435 f(network.conn)
436 }
437}
438
439func (u *user) forEachDownstream(f func(dc *downstreamConn)) {
440 for _, dc := range u.downstreamConns {
441 f(dc)
442 }
443}
444
445func (u *user) getNetwork(name string) *network {
446 for _, network := range u.networks {
447 if network.Addr == name {
448 return network
449 }
450 if network.Name != "" && network.Name == name {
451 return network
452 }
453 }
454 return nil
455}
456
457func (u *user) getNetworkByID(id int64) *network {
458 for _, net := range u.networks {
459 if net.ID == id {
460 return net
461 }
462 }
463 return nil
464}
465
466func (u *user) run() {
467 defer func() {
468 if u.msgStore != nil {
469 if err := u.msgStore.Close(); err != nil {
470 u.logger.Printf("failed to close message store for user %q: %v", u.Username, err)
471 }
472 }
473 close(u.done)
474 }()
475
476 networks, err := u.srv.db.ListNetworks(u.ID)
477 if err != nil {
478 u.logger.Printf("failed to list networks for user %q: %v", u.Username, err)
479 return
480 }
481
482 for _, record := range networks {
483 record := record
484 channels, err := u.srv.db.ListChannels(record.ID)
485 if err != nil {
486 u.logger.Printf("failed to list channels for user %q, network %q: %v", u.Username, record.GetName(), err)
487 continue
488 }
489
490 network := newNetwork(u, &record, channels)
491 u.networks = append(u.networks, network)
492
493 if u.hasPersistentMsgStore() {
494 receipts, err := u.srv.db.ListDeliveryReceipts(record.ID)
495 if err != nil {
496 u.logger.Printf("failed to load delivery receipts for user %q, network %q: %v", u.Username, network.GetName(), err)
497 return
498 }
499
500 for _, rcpt := range receipts {
501 network.delivered.StoreID(rcpt.Target, rcpt.Client, rcpt.InternalMsgID)
502 }
503 }
504
505 go network.run()
506 }
507
508 for e := range u.events {
509 switch e := e.(type) {
510 case eventUpstreamConnected:
511 uc := e.uc
512
513 uc.network.conn = uc
514
515 uc.updateAway()
516
517 netIDStr := fmt.Sprintf("%v", uc.network.ID)
518 uc.forEachDownstream(func(dc *downstreamConn) {
519 dc.updateSupportedCaps()
520
521 if dc.caps["soju.im/bouncer-networks-notify"] {
522 dc.SendMessage(&irc.Message{
523 Prefix: dc.srv.prefix(),
524 Command: "BOUNCER",
525 Params: []string{"NETWORK", netIDStr, "status=connected"},
526 })
527 } else if !dc.caps["soju.im/bouncer-networks"] {
528 sendServiceNOTICE(dc, fmt.Sprintf("connected to %s", uc.network.GetName()))
529 }
530
531 dc.updateNick()
532 dc.updateRealname()
533 })
534 uc.network.lastError = nil
535 case eventUpstreamDisconnected:
536 u.handleUpstreamDisconnected(e.uc)
537 case eventUpstreamConnectionError:
538 net := e.net
539
540 stopped := false
541 select {
542 case <-net.stopped:
543 stopped = true
544 default:
545 }
546
547 if !stopped && (net.lastError == nil || net.lastError.Error() != e.err.Error()) {
548 net.forEachDownstream(func(dc *downstreamConn) {
549 sendServiceNOTICE(dc, fmt.Sprintf("failed connecting/registering to %s: %v", net.GetName(), e.err))
550 })
551 }
552 net.lastError = e.err
553 case eventUpstreamError:
554 uc := e.uc
555
556 uc.forEachDownstream(func(dc *downstreamConn) {
557 sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s: %v", uc.network.GetName(), e.err))
558 })
559 uc.network.lastError = e.err
560 case eventUpstreamMessage:
561 msg, uc := e.msg, e.uc
562 if uc.isClosed() {
563 uc.logger.Printf("ignoring message on closed connection: %v", msg)
564 break
565 }
566 if err := uc.handleMessage(msg); err != nil {
567 uc.logger.Printf("failed to handle message %q: %v", msg, err)
568 }
569 case eventChannelDetach:
570 uc, name := e.uc, e.name
571 c := uc.network.channels.Value(name)
572 if c == nil || c.Detached {
573 continue
574 }
575 uc.network.detach(c)
576 if err := uc.srv.db.StoreChannel(uc.network.ID, c); err != nil {
577 u.logger.Printf("failed to store updated detached channel %q: %v", c.Name, err)
578 }
579 case eventDownstreamConnected:
580 dc := e.dc
581
582 if err := dc.welcome(); err != nil {
583 dc.logger.Printf("failed to handle new registered connection: %v", err)
584 break
585 }
586
587 u.downstreamConns = append(u.downstreamConns, dc)
588
589 dc.forEachNetwork(func(network *network) {
590 if network.lastError != nil {
591 sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s: %v", network.GetName(), network.lastError))
592 }
593 })
594
595 u.forEachUpstream(func(uc *upstreamConn) {
596 uc.updateAway()
597 })
598 case eventDownstreamDisconnected:
599 dc := e.dc
600
601 for i := range u.downstreamConns {
602 if u.downstreamConns[i] == dc {
603 u.downstreamConns = append(u.downstreamConns[:i], u.downstreamConns[i+1:]...)
604 break
605 }
606 }
607
608 dc.forEachNetwork(func(net *network) {
609 net.storeClientDeliveryReceipts(dc.clientName)
610 })
611
612 u.forEachUpstream(func(uc *upstreamConn) {
613 uc.updateAway()
614 })
615 case eventDownstreamMessage:
616 msg, dc := e.msg, e.dc
617 if dc.isClosed() {
618 dc.logger.Printf("ignoring message on closed connection: %v", msg)
619 break
620 }
621 err := dc.handleMessage(msg)
622 if ircErr, ok := err.(ircError); ok {
623 ircErr.Message.Prefix = dc.srv.prefix()
624 dc.SendMessage(ircErr.Message)
625 } else if err != nil {
626 dc.logger.Printf("failed to handle message %q: %v", msg, err)
627 dc.Close()
628 }
629 case eventStop:
630 u.forEachDownstream(func(dc *downstreamConn) {
631 dc.Close()
632 })
633 for _, n := range u.networks {
634 n.stop()
635
636 n.delivered.ForEachClient(func(clientName string) {
637 n.storeClientDeliveryReceipts(clientName)
638 })
639 }
640 return
641 default:
642 panic(fmt.Sprintf("received unknown event type: %T", e))
643 }
644 }
645}
646
647func (u *user) handleUpstreamDisconnected(uc *upstreamConn) {
648 uc.network.conn = nil
649
650 uc.endPendingLISTs(true)
651
652 for _, entry := range uc.channels.innerMap {
653 uch := entry.value.(*upstreamChannel)
654 uch.updateAutoDetach(0)
655 }
656
657 netIDStr := fmt.Sprintf("%v", uc.network.ID)
658 uc.forEachDownstream(func(dc *downstreamConn) {
659 dc.updateSupportedCaps()
660
661 if dc.caps["soju.im/bouncer-networks-notify"] {
662 dc.SendMessage(&irc.Message{
663 Prefix: dc.srv.prefix(),
664 Command: "BOUNCER",
665 Params: []string{"NETWORK", netIDStr, "status=disconnected"},
666 })
667 }
668 })
669
670 if uc.network.lastError == nil {
671 uc.forEachDownstream(func(dc *downstreamConn) {
672 if !dc.caps["soju.im/bouncer-networks"] {
673 sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s", uc.network.GetName()))
674 }
675 })
676 }
677}
678
679func (u *user) addNetwork(network *network) {
680 u.networks = append(u.networks, network)
681 go network.run()
682}
683
684func (u *user) removeNetwork(network *network) {
685 network.stop()
686
687 u.forEachDownstream(func(dc *downstreamConn) {
688 if dc.network != nil && dc.network == network {
689 dc.Close()
690 }
691 })
692
693 for i, net := range u.networks {
694 if net == network {
695 u.networks = append(u.networks[:i], u.networks[i+1:]...)
696 return
697 }
698 }
699
700 panic("tried to remove a non-existing network")
701}
702
703func (u *user) checkNetwork(record *Network) error {
704 for _, net := range u.networks {
705 if net.GetName() == record.GetName() && net.ID != record.ID {
706 return fmt.Errorf("a network with the name %q already exists", record.GetName())
707 }
708 }
709 return nil
710}
711
712func (u *user) createNetwork(record *Network) (*network, error) {
713 if record.ID != 0 {
714 panic("tried creating an already-existing network")
715 }
716
717 if err := u.checkNetwork(record); err != nil {
718 return nil, err
719 }
720
721 network := newNetwork(u, record, nil)
722 err := u.srv.db.StoreNetwork(u.ID, &network.Network)
723 if err != nil {
724 return nil, err
725 }
726
727 u.addNetwork(network)
728
729 idStr := fmt.Sprintf("%v", network.ID)
730 attrs := getNetworkAttrs(network)
731 u.forEachDownstream(func(dc *downstreamConn) {
732 if dc.caps["soju.im/bouncer-networks-notify"] {
733 dc.SendMessage(&irc.Message{
734 Prefix: dc.srv.prefix(),
735 Command: "BOUNCER",
736 Params: []string{"NETWORK", idStr, attrs.String()},
737 })
738 }
739 })
740
741 return network, nil
742}
743
744func (u *user) updateNetwork(record *Network) (*network, error) {
745 if record.ID == 0 {
746 panic("tried updating a new network")
747 }
748
749 if err := u.checkNetwork(record); err != nil {
750 return nil, err
751 }
752
753 network := u.getNetworkByID(record.ID)
754 if network == nil {
755 panic("tried updating a non-existing network")
756 }
757
758 if err := u.srv.db.StoreNetwork(u.ID, record); err != nil {
759 return nil, err
760 }
761
762 // Most network changes require us to re-connect to the upstream server
763
764 channels := make([]Channel, 0, network.channels.Len())
765 for _, entry := range network.channels.innerMap {
766 ch := entry.value.(*Channel)
767 channels = append(channels, *ch)
768 }
769
770 updatedNetwork := newNetwork(u, record, channels)
771
772 // If we're currently connected, disconnect and perform the necessary
773 // bookkeeping
774 if network.conn != nil {
775 network.stop()
776 // Note: this will set network.conn to nil
777 u.handleUpstreamDisconnected(network.conn)
778 }
779
780 // Patch downstream connections to use our fresh updated network
781 u.forEachDownstream(func(dc *downstreamConn) {
782 if dc.network != nil && dc.network == network {
783 dc.network = updatedNetwork
784 }
785 })
786
787 // We need to remove the network after patching downstream connections,
788 // otherwise they'll get closed
789 u.removeNetwork(network)
790
791 // This will re-connect to the upstream server
792 u.addNetwork(updatedNetwork)
793
794 // TODO: only broadcast attributes that have changed
795 idStr := fmt.Sprintf("%v", updatedNetwork.ID)
796 attrs := getNetworkAttrs(updatedNetwork)
797 u.forEachDownstream(func(dc *downstreamConn) {
798 if dc.caps["soju.im/bouncer-networks-notify"] {
799 dc.SendMessage(&irc.Message{
800 Prefix: dc.srv.prefix(),
801 Command: "BOUNCER",
802 Params: []string{"NETWORK", idStr, attrs.String()},
803 })
804 }
805 })
806
807 return updatedNetwork, nil
808}
809
810func (u *user) deleteNetwork(id int64) error {
811 network := u.getNetworkByID(id)
812 if network == nil {
813 panic("tried deleting a non-existing network")
814 }
815
816 if err := u.srv.db.DeleteNetwork(network.ID); err != nil {
817 return err
818 }
819
820 u.removeNetwork(network)
821
822 idStr := fmt.Sprintf("%v", network.ID)
823 u.forEachDownstream(func(dc *downstreamConn) {
824 if dc.caps["soju.im/bouncer-networks-notify"] {
825 dc.SendMessage(&irc.Message{
826 Prefix: dc.srv.prefix(),
827 Command: "BOUNCER",
828 Params: []string{"NETWORK", idStr, "*"},
829 })
830 }
831 })
832
833 return nil
834}
835
836func (u *user) updatePassword(hashed string) error {
837 u.User.Password = hashed
838 return u.srv.db.StoreUser(&u.User)
839}
840
841func (u *user) stop() {
842 u.events <- eventStop{}
843 <-u.done
844}
845
846func (u *user) hasPersistentMsgStore() bool {
847 if u.msgStore == nil {
848 return false
849 }
850 _, isMem := u.msgStore.(*memoryMessageStore)
851 return !isMem
852}
Note: See TracBrowser for help on using the repository browser.