source: code/trunk/user.go@ 547

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

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