source: code/trunk/downstream.go@ 449

Last change on this file since 449 was 448, checked in by hubert, 4 years ago

Request invite-notify to upstreams

... and do not forward INVITEs to downstreams that do not support the
capability.

The downstream capability can be permanent because there is no way for a
client to get the list of people invited to a channel, thus no state can
be corrupted.
File size: 45.8 KB
RevLine 
[98]1package soju
[13]2
3import (
[91]4 "crypto/tls"
[112]5 "encoding/base64"
[13]6 "fmt"
7 "io"
8 "net"
[108]9 "strconv"
[39]10 "strings"
[91]11 "time"
[13]12
[112]13 "github.com/emersion/go-sasl"
[85]14 "golang.org/x/crypto/bcrypt"
[13]15 "gopkg.in/irc.v3"
16)
17
18type ircError struct {
19 Message *irc.Message
20}
21
[85]22func (err ircError) Error() string {
23 return err.Message.String()
24}
25
[13]26func newUnknownCommandError(cmd string) ircError {
27 return ircError{&irc.Message{
28 Command: irc.ERR_UNKNOWNCOMMAND,
29 Params: []string{
30 "*",
31 cmd,
32 "Unknown command",
33 },
34 }}
35}
36
37func newNeedMoreParamsError(cmd string) ircError {
38 return ircError{&irc.Message{
39 Command: irc.ERR_NEEDMOREPARAMS,
40 Params: []string{
41 "*",
42 cmd,
43 "Not enough parameters",
44 },
45 }}
46}
47
[319]48func newChatHistoryError(subcommand string, target string) ircError {
49 return ircError{&irc.Message{
50 Command: "FAIL",
51 Params: []string{"CHATHISTORY", "MESSAGE_ERROR", subcommand, target, "Messages could not be retrieved"},
52 }}
53}
54
[85]55var errAuthFailed = ircError{&irc.Message{
56 Command: irc.ERR_PASSWDMISMATCH,
57 Params: []string{"*", "Invalid username or password"},
58}}
[13]59
[411]60// ' ' and ':' break the IRC message wire format, '@' and '!' break prefixes,
61// '*' and '?' break masks
62const illegalNickChars = " :@!*?"
[404]63
[275]64// permanentDownstreamCaps is the list of always-supported downstream
65// capabilities.
66var permanentDownstreamCaps = map[string]string{
[448]67 "batch": "",
68 "cap-notify": "",
69 "echo-message": "",
70 "invite-notify": "",
71 "message-tags": "",
72 "sasl": "PLAIN",
73 "server-time": "",
[275]74}
75
[292]76// needAllDownstreamCaps is the list of downstream capabilities that
77// require support from all upstreams to be enabled
78var needAllDownstreamCaps = map[string]string{
[419]79 "away-notify": "",
80 "extended-join": "",
81 "multi-prefix": "",
[292]82}
83
[13]84type downstreamConn struct {
[210]85 conn
[22]86
[210]87 id uint64
88
[100]89 registered bool
90 user *user
91 nick string
92 rawUsername string
[168]93 networkName string
[183]94 clientName string
[100]95 realname string
[141]96 hostname string
[100]97 password string // empty after authentication
98 network *network // can be nil
[105]99
[108]100 negociatingCaps bool
101 capVersion int
[275]102 supportedCaps map[string]string
[236]103 caps map[string]bool
[108]104
[112]105 saslServer sasl.Server
[13]106}
107
[347]108func newDownstreamConn(srv *Server, ic ircConn, id uint64) *downstreamConn {
109 remoteAddr := ic.RemoteAddr().String()
[323]110 logger := &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", remoteAddr)}
[398]111 options := connOptions{Logger: logger}
[55]112 dc := &downstreamConn{
[398]113 conn: *newConn(srv, ic, &options),
[276]114 id: id,
[275]115 supportedCaps: make(map[string]string),
[276]116 caps: make(map[string]bool),
[22]117 }
[323]118 dc.hostname = remoteAddr
[141]119 if host, _, err := net.SplitHostPort(dc.hostname); err == nil {
120 dc.hostname = host
121 }
[275]122 for k, v := range permanentDownstreamCaps {
123 dc.supportedCaps[k] = v
124 }
[319]125 if srv.LogPath != "" {
126 dc.supportedCaps["draft/chathistory"] = ""
127 }
[55]128 return dc
[22]129}
130
[55]131func (dc *downstreamConn) prefix() *irc.Prefix {
[27]132 return &irc.Prefix{
[55]133 Name: dc.nick,
[184]134 User: dc.user.Username,
[141]135 Host: dc.hostname,
[27]136 }
137}
138
[90]139func (dc *downstreamConn) forEachNetwork(f func(*network)) {
140 if dc.network != nil {
141 f(dc.network)
142 } else {
143 dc.user.forEachNetwork(f)
144 }
145}
146
[73]147func (dc *downstreamConn) forEachUpstream(f func(*upstreamConn)) {
148 dc.user.forEachUpstream(func(uc *upstreamConn) {
[77]149 if dc.network != nil && uc.network != dc.network {
[73]150 return
151 }
152 f(uc)
153 })
154}
155
[89]156// upstream returns the upstream connection, if any. If there are zero or if
157// there are multiple upstream connections, it returns nil.
158func (dc *downstreamConn) upstream() *upstreamConn {
159 if dc.network == nil {
160 return nil
161 }
[279]162 return dc.network.conn
[89]163}
164
[260]165func isOurNick(net *network, nick string) bool {
166 // TODO: this doesn't account for nick changes
167 if net.conn != nil {
168 return nick == net.conn.nick
169 }
170 // We're not currently connected to the upstream connection, so we don't
171 // know whether this name is our nickname. Best-effort: use the network's
172 // configured nickname and hope it was the one being used when we were
173 // connected.
174 return nick == net.Nick
175}
176
[249]177// marshalEntity converts an upstream entity name (ie. channel or nick) into a
178// downstream entity name.
179//
180// This involves adding a "/<network>" suffix if the entity isn't the current
181// user.
[260]182func (dc *downstreamConn) marshalEntity(net *network, name string) string {
[289]183 if isOurNick(net, name) {
184 return dc.nick
185 }
[257]186 if dc.network != nil {
[260]187 if dc.network != net {
[258]188 panic("soju: tried to marshal an entity for another network")
189 }
[257]190 return name
[119]191 }
[260]192 return name + "/" + net.GetName()
[119]193}
194
[260]195func (dc *downstreamConn) marshalUserPrefix(net *network, prefix *irc.Prefix) *irc.Prefix {
196 if isOurNick(net, prefix.Name) {
[257]197 return dc.prefix()
198 }
[130]199 if dc.network != nil {
[260]200 if dc.network != net {
[258]201 panic("soju: tried to marshal a user prefix for another network")
202 }
[257]203 return prefix
[119]204 }
[257]205 return &irc.Prefix{
[260]206 Name: prefix.Name + "/" + net.GetName(),
[257]207 User: prefix.User,
208 Host: prefix.Host,
209 }
[119]210}
211
[249]212// unmarshalEntity converts a downstream entity name (ie. channel or nick) into
213// an upstream entity name.
214//
215// This involves removing the "/<network>" suffix.
[127]216func (dc *downstreamConn) unmarshalEntity(name string) (*upstreamConn, string, error) {
[89]217 if uc := dc.upstream(); uc != nil {
218 return uc, name, nil
219 }
220
[127]221 var conn *upstreamConn
[119]222 if i := strings.LastIndexByte(name, '/'); i >= 0 {
[127]223 network := name[i+1:]
[119]224 name = name[:i]
225
226 dc.forEachUpstream(func(uc *upstreamConn) {
227 if network != uc.network.GetName() {
228 return
229 }
230 conn = uc
231 })
232 }
233
[127]234 if conn == nil {
[73]235 return nil, "", ircError{&irc.Message{
236 Command: irc.ERR_NOSUCHCHANNEL,
237 Params: []string{name, "No such channel"},
238 }}
[69]239 }
[127]240 return conn, name, nil
[69]241}
242
[268]243func (dc *downstreamConn) unmarshalText(uc *upstreamConn, text string) string {
244 if dc.upstream() != nil {
245 return text
246 }
247 // TODO: smarter parsing that ignores URLs
248 return strings.ReplaceAll(text, "/"+uc.network.GetName(), "")
249}
250
[165]251func (dc *downstreamConn) readMessages(ch chan<- event) error {
[22]252 for {
[210]253 msg, err := dc.ReadMessage()
[22]254 if err == io.EOF {
255 break
256 } else if err != nil {
257 return fmt.Errorf("failed to read IRC command: %v", err)
258 }
259
[165]260 ch <- eventDownstreamMessage{msg, dc}
[22]261 }
262
[45]263 return nil
[22]264}
265
[230]266// SendMessage sends an outgoing message.
267//
268// This can only called from the user goroutine.
[55]269func (dc *downstreamConn) SendMessage(msg *irc.Message) {
[230]270 if !dc.caps["message-tags"] {
[303]271 if msg.Command == "TAGMSG" {
272 return
273 }
[216]274 msg = msg.Copy()
275 for name := range msg.Tags {
276 supported := false
277 switch name {
278 case "time":
[230]279 supported = dc.caps["server-time"]
[216]280 }
281 if !supported {
282 delete(msg.Tags, name)
283 }
284 }
285 }
[419]286 if msg.Command == "JOIN" && !dc.caps["extended-join"] {
287 msg.Params = msg.Params[:1]
288 }
[216]289
[210]290 dc.conn.SendMessage(msg)
[54]291}
292
[428]293// sendMessageWithID sends an outgoing message with the specified internal ID.
294func (dc *downstreamConn) sendMessageWithID(msg *irc.Message, id string) {
295 dc.SendMessage(msg)
296
297 if id == "" || !dc.messageSupportsHistory(msg) {
298 return
299 }
300
301 dc.sendPing(id)
302}
303
304// advanceMessageWithID advances history to the specified message ID without
305// sending a message. This is useful e.g. for self-messages when echo-message
306// isn't enabled.
307func (dc *downstreamConn) advanceMessageWithID(msg *irc.Message, id string) {
308 if id == "" || !dc.messageSupportsHistory(msg) {
309 return
310 }
311
312 dc.sendPing(id)
313}
314
315// ackMsgID acknowledges that a message has been received.
316func (dc *downstreamConn) ackMsgID(id string) {
[440]317 netID, entity, _, err := parseMsgID(id)
[428]318 if err != nil {
319 dc.logger.Printf("failed to ACK message ID %q: %v", id, err)
320 return
321 }
322
[440]323 network := dc.user.getNetworkByID(netID)
[428]324 if network == nil {
325 return
326 }
327
328 history, ok := network.history[entity]
329 if !ok {
330 return
331 }
332
333 history.clients[dc.clientName] = id
334}
335
336func (dc *downstreamConn) sendPing(msgID string) {
337 token := "soju-msgid-" + base64.RawURLEncoding.EncodeToString([]byte(msgID))
338 dc.SendMessage(&irc.Message{
339 Command: "PING",
340 Params: []string{token},
341 })
342}
343
344func (dc *downstreamConn) handlePong(token string) {
345 if !strings.HasPrefix(token, "soju-msgid-") {
346 dc.logger.Printf("received unrecognized PONG token %q", token)
347 return
348 }
349 token = strings.TrimPrefix(token, "soju-msgid-")
350 b, err := base64.RawURLEncoding.DecodeString(token)
351 if err != nil {
352 dc.logger.Printf("received malformed PONG token: %v", err)
353 return
354 }
355 msgID := string(b)
356
357 dc.ackMsgID(msgID)
358}
359
[245]360// marshalMessage re-formats a message coming from an upstream connection so
361// that it's suitable for being sent on this downstream connection. Only
[293]362// messages that may appear in logs are supported, except MODE.
[261]363func (dc *downstreamConn) marshalMessage(msg *irc.Message, net *network) *irc.Message {
[227]364 msg = msg.Copy()
[261]365 msg.Prefix = dc.marshalUserPrefix(net, msg.Prefix)
[245]366
[227]367 switch msg.Command {
[303]368 case "PRIVMSG", "NOTICE", "TAGMSG":
[261]369 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]370 case "NICK":
371 // Nick change for another user
[261]372 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]373 case "JOIN", "PART":
[261]374 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]375 case "KICK":
[261]376 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
377 msg.Params[1] = dc.marshalEntity(net, msg.Params[1])
[245]378 case "TOPIC":
[261]379 msg.Params[0] = dc.marshalEntity(net, msg.Params[0])
[245]380 case "QUIT":
[262]381 // This space is intentionally left blank
[227]382 default:
383 panic(fmt.Sprintf("unexpected %q message", msg.Command))
384 }
385
[245]386 return msg
[227]387}
388
[55]389func (dc *downstreamConn) handleMessage(msg *irc.Message) error {
[13]390 switch msg.Command {
[28]391 case "QUIT":
[55]392 return dc.Close()
[13]393 default:
[55]394 if dc.registered {
395 return dc.handleMessageRegistered(msg)
[13]396 } else {
[55]397 return dc.handleMessageUnregistered(msg)
[13]398 }
399 }
400}
401
[55]402func (dc *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
[13]403 switch msg.Command {
404 case "NICK":
[117]405 var nick string
406 if err := parseMessageParams(msg, &nick); err != nil {
[43]407 return err
[13]408 }
[404]409 if strings.ContainsAny(nick, illegalNickChars) {
410 return ircError{&irc.Message{
411 Command: irc.ERR_ERRONEUSNICKNAME,
412 Params: []string{dc.nick, nick, "contains illegal characters"},
413 }}
414 }
[117]415 if nick == serviceNick {
416 return ircError{&irc.Message{
417 Command: irc.ERR_NICKNAMEINUSE,
418 Params: []string{dc.nick, nick, "Nickname reserved for bouncer service"},
419 }}
420 }
421 dc.nick = nick
[13]422 case "USER":
[117]423 if err := parseMessageParams(msg, &dc.rawUsername, nil, nil, &dc.realname); err != nil {
[43]424 return err
[13]425 }
[85]426 case "PASS":
427 if err := parseMessageParams(msg, &dc.password); err != nil {
428 return err
429 }
[108]430 case "CAP":
431 var subCmd string
432 if err := parseMessageParams(msg, &subCmd); err != nil {
433 return err
434 }
435 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
436 return err
437 }
[112]438 case "AUTHENTICATE":
[230]439 if !dc.caps["sasl"] {
[112]440 return ircError{&irc.Message{
[125]441 Command: irc.ERR_SASLFAIL,
[112]442 Params: []string{"*", "AUTHENTICATE requires the \"sasl\" capability to be enabled"},
443 }}
444 }
445 if len(msg.Params) == 0 {
446 return ircError{&irc.Message{
[125]447 Command: irc.ERR_SASLFAIL,
[112]448 Params: []string{"*", "Missing AUTHENTICATE argument"},
449 }}
450 }
451 if dc.nick == "" {
452 return ircError{&irc.Message{
[125]453 Command: irc.ERR_SASLFAIL,
[112]454 Params: []string{"*", "Expected NICK command before AUTHENTICATE"},
455 }}
456 }
457
458 var resp []byte
459 if dc.saslServer == nil {
460 mech := strings.ToUpper(msg.Params[0])
461 switch mech {
462 case "PLAIN":
463 dc.saslServer = sasl.NewPlainServer(sasl.PlainAuthenticator(func(identity, username, password string) error {
464 return dc.authenticate(username, password)
465 }))
466 default:
467 return ircError{&irc.Message{
[125]468 Command: irc.ERR_SASLFAIL,
[112]469 Params: []string{"*", fmt.Sprintf("Unsupported SASL mechanism %q", mech)},
470 }}
471 }
472 } else if msg.Params[0] == "*" {
473 dc.saslServer = nil
474 return ircError{&irc.Message{
[125]475 Command: irc.ERR_SASLABORTED,
[112]476 Params: []string{"*", "SASL authentication aborted"},
477 }}
478 } else if msg.Params[0] == "+" {
479 resp = nil
480 } else {
481 // TODO: multi-line messages
482 var err error
483 resp, err = base64.StdEncoding.DecodeString(msg.Params[0])
484 if err != nil {
485 dc.saslServer = nil
486 return ircError{&irc.Message{
[125]487 Command: irc.ERR_SASLFAIL,
[112]488 Params: []string{"*", "Invalid base64-encoded response"},
489 }}
490 }
491 }
492
493 challenge, done, err := dc.saslServer.Next(resp)
494 if err != nil {
495 dc.saslServer = nil
496 if ircErr, ok := err.(ircError); ok && ircErr.Message.Command == irc.ERR_PASSWDMISMATCH {
497 return ircError{&irc.Message{
[125]498 Command: irc.ERR_SASLFAIL,
[112]499 Params: []string{"*", ircErr.Message.Params[1]},
500 }}
501 }
502 dc.SendMessage(&irc.Message{
503 Prefix: dc.srv.prefix(),
[125]504 Command: irc.ERR_SASLFAIL,
[112]505 Params: []string{"*", "SASL error"},
506 })
507 return fmt.Errorf("SASL authentication failed: %v", err)
508 } else if done {
509 dc.saslServer = nil
510 dc.SendMessage(&irc.Message{
511 Prefix: dc.srv.prefix(),
[125]512 Command: irc.RPL_LOGGEDIN,
[306]513 Params: []string{dc.nick, dc.prefix().String(), dc.user.Username, "You are now logged in"},
[112]514 })
515 dc.SendMessage(&irc.Message{
516 Prefix: dc.srv.prefix(),
[125]517 Command: irc.RPL_SASLSUCCESS,
[112]518 Params: []string{dc.nick, "SASL authentication successful"},
519 })
520 } else {
521 challengeStr := "+"
[135]522 if len(challenge) > 0 {
[112]523 challengeStr = base64.StdEncoding.EncodeToString(challenge)
524 }
525
526 // TODO: multi-line messages
527 dc.SendMessage(&irc.Message{
528 Prefix: dc.srv.prefix(),
529 Command: "AUTHENTICATE",
530 Params: []string{challengeStr},
531 })
532 }
[13]533 default:
[55]534 dc.logger.Printf("unhandled message: %v", msg)
[13]535 return newUnknownCommandError(msg.Command)
536 }
[108]537 if dc.rawUsername != "" && dc.nick != "" && !dc.negociatingCaps {
[55]538 return dc.register()
[13]539 }
540 return nil
541}
542
[108]543func (dc *downstreamConn) handleCapCommand(cmd string, args []string) error {
[111]544 cmd = strings.ToUpper(cmd)
545
[108]546 replyTo := dc.nick
547 if !dc.registered {
548 replyTo = "*"
549 }
550
551 switch cmd {
552 case "LS":
553 if len(args) > 0 {
554 var err error
555 if dc.capVersion, err = strconv.Atoi(args[0]); err != nil {
556 return err
557 }
558 }
[437]559 if !dc.registered && dc.capVersion >= 302 {
560 // Let downstream show everything it supports, and trim
561 // down the available capabilities when upstreams are
562 // known.
563 for k, v := range needAllDownstreamCaps {
564 dc.supportedCaps[k] = v
565 }
566 }
[108]567
[275]568 caps := make([]string, 0, len(dc.supportedCaps))
569 for k, v := range dc.supportedCaps {
570 if dc.capVersion >= 302 && v != "" {
[276]571 caps = append(caps, k+"="+v)
[275]572 } else {
573 caps = append(caps, k)
574 }
[112]575 }
[108]576
577 // TODO: multi-line replies
578 dc.SendMessage(&irc.Message{
579 Prefix: dc.srv.prefix(),
580 Command: "CAP",
581 Params: []string{replyTo, "LS", strings.Join(caps, " ")},
582 })
583
[275]584 if dc.capVersion >= 302 {
585 // CAP version 302 implicitly enables cap-notify
586 dc.caps["cap-notify"] = true
587 }
588
[108]589 if !dc.registered {
590 dc.negociatingCaps = true
591 }
592 case "LIST":
593 var caps []string
594 for name := range dc.caps {
595 caps = append(caps, name)
596 }
597
598 // TODO: multi-line replies
599 dc.SendMessage(&irc.Message{
600 Prefix: dc.srv.prefix(),
601 Command: "CAP",
602 Params: []string{replyTo, "LIST", strings.Join(caps, " ")},
603 })
604 case "REQ":
605 if len(args) == 0 {
606 return ircError{&irc.Message{
607 Command: err_invalidcapcmd,
608 Params: []string{replyTo, cmd, "Missing argument in CAP REQ command"},
609 }}
610 }
611
[275]612 // TODO: atomically ack/nak the whole capability set
[108]613 caps := strings.Fields(args[0])
614 ack := true
615 for _, name := range caps {
616 name = strings.ToLower(name)
617 enable := !strings.HasPrefix(name, "-")
618 if !enable {
619 name = strings.TrimPrefix(name, "-")
620 }
621
[275]622 if enable == dc.caps[name] {
[108]623 continue
624 }
625
[275]626 _, ok := dc.supportedCaps[name]
627 if !ok {
[108]628 ack = false
[275]629 break
[108]630 }
[275]631
632 if name == "cap-notify" && dc.capVersion >= 302 && !enable {
633 // cap-notify cannot be disabled with CAP version 302
634 ack = false
635 break
636 }
637
638 dc.caps[name] = enable
[108]639 }
640
641 reply := "NAK"
642 if ack {
643 reply = "ACK"
644 }
645 dc.SendMessage(&irc.Message{
646 Prefix: dc.srv.prefix(),
647 Command: "CAP",
648 Params: []string{replyTo, reply, args[0]},
649 })
650 case "END":
651 dc.negociatingCaps = false
652 default:
653 return ircError{&irc.Message{
654 Command: err_invalidcapcmd,
655 Params: []string{replyTo, cmd, "Unknown CAP command"},
656 }}
657 }
658 return nil
659}
660
[275]661func (dc *downstreamConn) setSupportedCap(name, value string) {
662 prevValue, hasPrev := dc.supportedCaps[name]
663 changed := !hasPrev || prevValue != value
664 dc.supportedCaps[name] = value
665
666 if !dc.caps["cap-notify"] || !changed {
667 return
668 }
669
670 replyTo := dc.nick
671 if !dc.registered {
672 replyTo = "*"
673 }
674
675 cap := name
676 if value != "" && dc.capVersion >= 302 {
677 cap = name + "=" + value
678 }
679
680 dc.SendMessage(&irc.Message{
681 Prefix: dc.srv.prefix(),
682 Command: "CAP",
683 Params: []string{replyTo, "NEW", cap},
684 })
685}
686
687func (dc *downstreamConn) unsetSupportedCap(name string) {
688 _, hasPrev := dc.supportedCaps[name]
689 delete(dc.supportedCaps, name)
690 delete(dc.caps, name)
691
692 if !dc.caps["cap-notify"] || !hasPrev {
693 return
694 }
695
696 replyTo := dc.nick
697 if !dc.registered {
698 replyTo = "*"
699 }
700
701 dc.SendMessage(&irc.Message{
702 Prefix: dc.srv.prefix(),
703 Command: "CAP",
704 Params: []string{replyTo, "DEL", name},
705 })
706}
707
[276]708func (dc *downstreamConn) updateSupportedCaps() {
[292]709 supportedCaps := make(map[string]bool)
710 for cap := range needAllDownstreamCaps {
711 supportedCaps[cap] = true
712 }
[276]713 dc.forEachUpstream(func(uc *upstreamConn) {
[292]714 for cap, supported := range supportedCaps {
715 supportedCaps[cap] = supported && uc.caps[cap]
716 }
[276]717 })
718
[292]719 for cap, supported := range supportedCaps {
720 if supported {
721 dc.setSupportedCap(cap, needAllDownstreamCaps[cap])
722 } else {
723 dc.unsetSupportedCap(cap)
724 }
[276]725 }
726}
727
[296]728func (dc *downstreamConn) updateNick() {
729 if uc := dc.upstream(); uc != nil && uc.nick != dc.nick {
730 dc.SendMessage(&irc.Message{
731 Prefix: dc.prefix(),
732 Command: "NICK",
733 Params: []string{uc.nick},
734 })
735 dc.nick = uc.nick
736 }
737}
738
[91]739func sanityCheckServer(addr string) error {
740 dialer := net.Dialer{Timeout: 30 * time.Second}
741 conn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
742 if err != nil {
743 return err
744 }
745 return conn.Close()
746}
747
[183]748func unmarshalUsername(rawUsername string) (username, client, network string) {
[112]749 username = rawUsername
[183]750
751 i := strings.IndexAny(username, "/@")
752 j := strings.LastIndexAny(username, "/@")
753 if i >= 0 {
754 username = rawUsername[:i]
[73]755 }
[183]756 if j >= 0 {
[190]757 if rawUsername[j] == '@' {
758 client = rawUsername[j+1:]
759 } else {
760 network = rawUsername[j+1:]
761 }
[73]762 }
[183]763 if i >= 0 && j >= 0 && i < j {
[190]764 if rawUsername[i] == '@' {
765 client = rawUsername[i+1 : j]
766 } else {
767 network = rawUsername[i+1 : j]
768 }
[183]769 }
770
771 return username, client, network
[112]772}
[73]773
[168]774func (dc *downstreamConn) authenticate(username, password string) error {
[183]775 username, clientName, networkName := unmarshalUsername(username)
[168]776
[173]777 u, err := dc.srv.db.GetUser(username)
778 if err != nil {
[438]779 dc.logger.Printf("failed authentication for %q: user not found: %v", username, err)
[168]780 return errAuthFailed
781 }
782
[322]783 // Password auth disabled
784 if u.Password == "" {
785 return errAuthFailed
786 }
787
[173]788 err = bcrypt.CompareHashAndPassword([]byte(u.Password), []byte(password))
[168]789 if err != nil {
[438]790 dc.logger.Printf("failed authentication for %q: wrong password: %v", username, err)
[168]791 return errAuthFailed
792 }
793
[173]794 dc.user = dc.srv.getUser(username)
795 if dc.user == nil {
796 dc.logger.Printf("failed authentication for %q: user not active", username)
797 return errAuthFailed
798 }
[183]799 dc.clientName = clientName
[168]800 dc.networkName = networkName
801 return nil
802}
803
804func (dc *downstreamConn) register() error {
805 if dc.registered {
806 return fmt.Errorf("tried to register twice")
807 }
808
809 password := dc.password
810 dc.password = ""
811 if dc.user == nil {
812 if err := dc.authenticate(dc.rawUsername, password); err != nil {
813 return err
814 }
815 }
816
[183]817 if dc.clientName == "" && dc.networkName == "" {
818 _, dc.clientName, dc.networkName = unmarshalUsername(dc.rawUsername)
[168]819 }
820
821 dc.registered = true
[184]822 dc.logger.Printf("registration complete for user %q", dc.user.Username)
[168]823 return nil
824}
825
826func (dc *downstreamConn) loadNetwork() error {
827 if dc.networkName == "" {
[112]828 return nil
829 }
[85]830
[168]831 network := dc.user.getNetwork(dc.networkName)
[112]832 if network == nil {
[168]833 addr := dc.networkName
[112]834 if !strings.ContainsRune(addr, ':') {
835 addr = addr + ":6697"
836 }
837
838 dc.logger.Printf("trying to connect to new network %q", addr)
839 if err := sanityCheckServer(addr); err != nil {
840 dc.logger.Printf("failed to connect to %q: %v", addr, err)
841 return ircError{&irc.Message{
842 Command: irc.ERR_PASSWDMISMATCH,
[168]843 Params: []string{"*", fmt.Sprintf("Failed to connect to %q", dc.networkName)},
[112]844 }}
845 }
846
[354]847 // Some clients only allow specifying the nickname (and use the
848 // nickname as a username too). Strip the network name from the
849 // nickname when auto-saving networks.
850 nick, _, _ := unmarshalUsername(dc.nick)
851
[168]852 dc.logger.Printf("auto-saving network %q", dc.networkName)
[112]853 var err error
[120]854 network, err = dc.user.createNetwork(&Network{
[168]855 Addr: dc.networkName,
[354]856 Nick: nick,
[120]857 })
[112]858 if err != nil {
859 return err
860 }
861 }
862
863 dc.network = network
864 return nil
865}
866
[168]867func (dc *downstreamConn) welcome() error {
868 if dc.user == nil || !dc.registered {
869 panic("tried to welcome an unregistered connection")
[37]870 }
871
[168]872 // TODO: doing this might take some time. We should do it in dc.register
873 // instead, but we'll potentially be adding a new network and this must be
874 // done in the user goroutine.
875 if err := dc.loadNetwork(); err != nil {
876 return err
[85]877 }
878
[446]879 isupport := []string{
880 fmt.Sprintf("CHATHISTORY=%v", dc.srv.HistoryLimit),
881 }
882
[447]883 if uc := dc.upstream(); uc != nil && uc.networkName != "" {
884 isupport = append(isupport, fmt.Sprintf("NETWORK=%v", uc.networkName))
885 }
886
[55]887 dc.SendMessage(&irc.Message{
888 Prefix: dc.srv.prefix(),
[13]889 Command: irc.RPL_WELCOME,
[98]890 Params: []string{dc.nick, "Welcome to soju, " + dc.nick},
[54]891 })
[55]892 dc.SendMessage(&irc.Message{
893 Prefix: dc.srv.prefix(),
[13]894 Command: irc.RPL_YOURHOST,
[55]895 Params: []string{dc.nick, "Your host is " + dc.srv.Hostname},
[54]896 })
[55]897 dc.SendMessage(&irc.Message{
898 Prefix: dc.srv.prefix(),
[13]899 Command: irc.RPL_CREATED,
[55]900 Params: []string{dc.nick, "Who cares when the server was created?"},
[54]901 })
[55]902 dc.SendMessage(&irc.Message{
903 Prefix: dc.srv.prefix(),
[13]904 Command: irc.RPL_MYINFO,
[98]905 Params: []string{dc.nick, dc.srv.Hostname, "soju", "aiwroO", "OovaimnqpsrtklbeI"},
[54]906 })
[446]907 // TODO: other RPL_ISUPPORT tokens
[55]908 dc.SendMessage(&irc.Message{
[447]909 Prefix: dc.srv.prefix(),
[446]910 Command: irc.RPL_ISUPPORT,
[447]911 Params: append(append([]string{dc.nick}, isupport...), "are supported"),
[446]912 })
913 dc.SendMessage(&irc.Message{
[55]914 Prefix: dc.srv.prefix(),
[13]915 Command: irc.ERR_NOMOTD,
[55]916 Params: []string{dc.nick, "No MOTD"},
[54]917 })
[13]918
[296]919 dc.updateNick()
[437]920 dc.updateSupportedCaps()
[296]921
[73]922 dc.forEachUpstream(func(uc *upstreamConn) {
[30]923 for _, ch := range uc.channels {
[284]924 if !ch.complete {
925 continue
926 }
927 if record, ok := uc.network.channels[ch.Name]; ok && record.Detached {
928 continue
929 }
[132]930
[284]931 dc.SendMessage(&irc.Message{
932 Prefix: dc.prefix(),
933 Command: "JOIN",
934 Params: []string{dc.marshalEntity(ch.conn.network, ch.Name)},
935 })
936
937 forwardChannel(dc, ch)
[30]938 }
[143]939 })
[50]940
[143]941 dc.forEachNetwork(func(net *network) {
[253]942 // Only send history if we're the first connected client with that name
943 // for the network
944 if _, ok := net.offlineClients[dc.clientName]; ok {
945 dc.sendNetworkHistory(net)
946 delete(net.offlineClients, dc.clientName)
[227]947 }
[409]948
949 // Fast-forward history to last message
950 for target, history := range net.history {
951 if ch, ok := net.channels[target]; ok && ch.Detached {
952 continue
953 }
954
[423]955 lastID, err := dc.user.msgStore.LastMsgID(net, target, time.Now())
[409]956 if err != nil {
957 dc.logger.Printf("failed to get last message ID: %v", err)
958 continue
959 }
960 history.clients[dc.clientName] = lastID
961 }
[253]962 })
[57]963
[253]964 return nil
965}
[144]966
[428]967// messageSupportsHistory checks whether the provided message can be sent as
968// part of an history batch.
969func (dc *downstreamConn) messageSupportsHistory(msg *irc.Message) bool {
970 // Don't replay all messages, because that would mess up client
971 // state. For instance we just sent the list of users, sending
972 // PART messages for one of these users would be incorrect.
973 // TODO: add support for draft/event-playback
974 switch msg.Command {
975 case "PRIVMSG", "NOTICE":
976 return true
977 }
978 return false
979}
980
[253]981func (dc *downstreamConn) sendNetworkHistory(net *network) {
[423]982 if dc.caps["draft/chathistory"] || dc.user.msgStore == nil {
[319]983 return
984 }
[253]985 for target, history := range net.history {
[284]986 if ch, ok := net.channels[target]; ok && ch.Detached {
987 continue
988 }
989
[409]990 lastDelivered, ok := history.clients[dc.clientName]
[253]991 if !ok {
992 continue
993 }
994
[409]995 limit := 4000
[423]996 history, err := dc.user.msgStore.LoadLatestID(net, target, lastDelivered, limit)
[409]997 if err != nil {
998 dc.logger.Printf("failed to send implicit history for %q: %v", target, err)
999 continue
1000 }
[253]1001
[256]1002 batchRef := "history"
1003 if dc.caps["batch"] {
1004 dc.SendMessage(&irc.Message{
1005 Prefix: dc.srv.prefix(),
1006 Command: "BATCH",
[260]1007 Params: []string{"+" + batchRef, "chathistory", dc.marshalEntity(net, target)},
[256]1008 })
1009 }
1010
[409]1011 for _, msg := range history {
[428]1012 if !dc.messageSupportsHistory(msg) {
[245]1013 continue
1014 }
1015
[256]1016 if dc.caps["batch"] {
1017 msg.Tags["batch"] = irc.TagValue(batchRef)
1018 }
[261]1019 dc.SendMessage(dc.marshalMessage(msg, net))
[227]1020 }
[256]1021
1022 if dc.caps["batch"] {
1023 dc.SendMessage(&irc.Message{
1024 Prefix: dc.srv.prefix(),
1025 Command: "BATCH",
1026 Params: []string{"-" + batchRef},
1027 })
1028 }
[253]1029 }
[13]1030}
1031
[103]1032func (dc *downstreamConn) runUntilRegistered() error {
1033 for !dc.registered {
[212]1034 msg, err := dc.ReadMessage()
[106]1035 if err != nil {
[103]1036 return fmt.Errorf("failed to read IRC command: %v", err)
1037 }
1038
1039 err = dc.handleMessage(msg)
1040 if ircErr, ok := err.(ircError); ok {
1041 ircErr.Message.Prefix = dc.srv.prefix()
1042 dc.SendMessage(ircErr.Message)
1043 } else if err != nil {
1044 return fmt.Errorf("failed to handle IRC command %q: %v", msg, err)
1045 }
1046 }
1047
1048 return nil
1049}
1050
[55]1051func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
[13]1052 switch msg.Command {
[111]1053 case "CAP":
1054 var subCmd string
1055 if err := parseMessageParams(msg, &subCmd); err != nil {
1056 return err
1057 }
1058 if err := dc.handleCapCommand(subCmd, msg.Params[1:]); err != nil {
1059 return err
1060 }
[107]1061 case "PING":
[412]1062 var source, destination string
1063 if err := parseMessageParams(msg, &source); err != nil {
1064 return err
1065 }
1066 if len(msg.Params) > 1 {
1067 destination = msg.Params[1]
1068 }
1069 if destination != "" && destination != dc.srv.Hostname {
1070 return ircError{&irc.Message{
1071 Command: irc.ERR_NOSUCHSERVER,
[413]1072 Params: []string{dc.nick, destination, "No such server"},
[412]1073 }}
1074 }
[107]1075 dc.SendMessage(&irc.Message{
1076 Prefix: dc.srv.prefix(),
1077 Command: "PONG",
[412]1078 Params: []string{dc.srv.Hostname, source},
[107]1079 })
1080 return nil
[428]1081 case "PONG":
1082 if len(msg.Params) == 0 {
1083 return newNeedMoreParamsError(msg.Command)
1084 }
1085 token := msg.Params[len(msg.Params)-1]
1086 dc.handlePong(token)
[42]1087 case "USER":
[13]1088 return ircError{&irc.Message{
1089 Command: irc.ERR_ALREADYREGISTERED,
[55]1090 Params: []string{dc.nick, "You may not reregister"},
[13]1091 }}
[42]1092 case "NICK":
[429]1093 var rawNick string
1094 if err := parseMessageParams(msg, &rawNick); err != nil {
[90]1095 return err
1096 }
1097
[429]1098 nick := rawNick
[297]1099 var upstream *upstreamConn
1100 if dc.upstream() == nil {
1101 uc, unmarshaledNick, err := dc.unmarshalEntity(nick)
1102 if err == nil { // NICK nick/network: NICK only on a specific upstream
1103 upstream = uc
1104 nick = unmarshaledNick
1105 }
1106 }
1107
[404]1108 if strings.ContainsAny(nick, illegalNickChars) {
1109 return ircError{&irc.Message{
1110 Command: irc.ERR_ERRONEUSNICKNAME,
[430]1111 Params: []string{dc.nick, rawNick, "contains illegal characters"},
[404]1112 }}
1113 }
[429]1114 if nick == serviceNick {
1115 return ircError{&irc.Message{
1116 Command: irc.ERR_NICKNAMEINUSE,
1117 Params: []string{dc.nick, rawNick, "Nickname reserved for bouncer service"},
1118 }}
1119 }
[404]1120
[90]1121 var err error
1122 dc.forEachNetwork(func(n *network) {
[297]1123 if err != nil || (upstream != nil && upstream.network != n) {
[90]1124 return
1125 }
1126 n.Nick = nick
[421]1127 err = dc.srv.db.StoreNetwork(dc.user.ID, &n.Network)
[90]1128 })
1129 if err != nil {
1130 return err
1131 }
1132
[73]1133 dc.forEachUpstream(func(uc *upstreamConn) {
[297]1134 if upstream != nil && upstream != uc {
1135 return
1136 }
[301]1137 uc.SendMessageLabeled(dc.id, &irc.Message{
[297]1138 Command: "NICK",
1139 Params: []string{nick},
1140 })
[42]1141 })
[296]1142
1143 if dc.upstream() == nil && dc.nick != nick {
1144 dc.SendMessage(&irc.Message{
1145 Prefix: dc.prefix(),
1146 Command: "NICK",
1147 Params: []string{nick},
1148 })
1149 dc.nick = nick
1150 }
[146]1151 case "JOIN":
1152 var namesStr string
1153 if err := parseMessageParams(msg, &namesStr); err != nil {
[48]1154 return err
1155 }
1156
[146]1157 var keys []string
1158 if len(msg.Params) > 1 {
1159 keys = strings.Split(msg.Params[1], ",")
1160 }
1161
1162 for i, name := range strings.Split(namesStr, ",") {
[145]1163 uc, upstreamName, err := dc.unmarshalEntity(name)
1164 if err != nil {
[158]1165 return err
[145]1166 }
[48]1167
[146]1168 var key string
1169 if len(keys) > i {
1170 key = keys[i]
1171 }
1172
1173 params := []string{upstreamName}
1174 if key != "" {
1175 params = append(params, key)
1176 }
[301]1177 uc.SendMessageLabeled(dc.id, &irc.Message{
[146]1178 Command: "JOIN",
1179 Params: params,
[145]1180 })
[89]1181
[435]1182 var ch *Channel
1183 var ok bool
1184 if ch, ok = uc.network.channels[upstreamName]; ok {
[285]1185 // Don't clear the channel key if there's one set
1186 // TODO: add a way to unset the channel key
[435]1187 if key != "" {
1188 ch.Key = key
1189 }
1190 uc.network.attach(ch)
1191 } else {
1192 ch = &Channel{
1193 Name: upstreamName,
1194 Key: key,
1195 }
1196 uc.network.channels[upstreamName] = ch
[285]1197 }
[435]1198 if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
[222]1199 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
[89]1200 }
1201 }
[146]1202 case "PART":
1203 var namesStr string
1204 if err := parseMessageParams(msg, &namesStr); err != nil {
1205 return err
1206 }
1207
1208 var reason string
1209 if len(msg.Params) > 1 {
1210 reason = msg.Params[1]
1211 }
1212
1213 for _, name := range strings.Split(namesStr, ",") {
1214 uc, upstreamName, err := dc.unmarshalEntity(name)
1215 if err != nil {
[158]1216 return err
[146]1217 }
1218
[284]1219 if strings.EqualFold(reason, "detach") {
[435]1220 var ch *Channel
1221 var ok bool
1222 if ch, ok = uc.network.channels[upstreamName]; ok {
1223 uc.network.detach(ch)
1224 } else {
1225 ch = &Channel{
1226 Name: name,
1227 Detached: true,
1228 }
1229 uc.network.channels[upstreamName] = ch
[284]1230 }
[435]1231 if err := dc.srv.db.StoreChannel(uc.network.ID, ch); err != nil {
1232 dc.logger.Printf("failed to create or update channel %q: %v", upstreamName, err)
1233 }
[284]1234 } else {
1235 params := []string{upstreamName}
1236 if reason != "" {
1237 params = append(params, reason)
1238 }
[301]1239 uc.SendMessageLabeled(dc.id, &irc.Message{
[284]1240 Command: "PART",
1241 Params: params,
1242 })
[146]1243
[284]1244 if err := uc.network.deleteChannel(upstreamName); err != nil {
1245 dc.logger.Printf("failed to delete channel %q: %v", upstreamName, err)
1246 }
[146]1247 }
1248 }
[159]1249 case "KICK":
1250 var channelStr, userStr string
1251 if err := parseMessageParams(msg, &channelStr, &userStr); err != nil {
1252 return err
1253 }
1254
1255 channels := strings.Split(channelStr, ",")
1256 users := strings.Split(userStr, ",")
1257
1258 var reason string
1259 if len(msg.Params) > 2 {
1260 reason = msg.Params[2]
1261 }
1262
1263 if len(channels) != 1 && len(channels) != len(users) {
1264 return ircError{&irc.Message{
1265 Command: irc.ERR_BADCHANMASK,
1266 Params: []string{dc.nick, channelStr, "Bad channel mask"},
1267 }}
1268 }
1269
1270 for i, user := range users {
1271 var channel string
1272 if len(channels) == 1 {
1273 channel = channels[0]
1274 } else {
1275 channel = channels[i]
1276 }
1277
1278 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
1279 if err != nil {
1280 return err
1281 }
1282
1283 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
1284 if err != nil {
1285 return err
1286 }
1287
1288 if ucChannel != ucUser {
1289 return ircError{&irc.Message{
1290 Command: irc.ERR_USERNOTINCHANNEL,
[400]1291 Params: []string{dc.nick, user, channel, "They are on another network"},
[159]1292 }}
1293 }
1294 uc := ucChannel
1295
1296 params := []string{upstreamChannel, upstreamUser}
1297 if reason != "" {
1298 params = append(params, reason)
1299 }
[301]1300 uc.SendMessageLabeled(dc.id, &irc.Message{
[159]1301 Command: "KICK",
1302 Params: params,
1303 })
1304 }
[69]1305 case "MODE":
[46]1306 var name string
1307 if err := parseMessageParams(msg, &name); err != nil {
1308 return err
1309 }
1310
1311 var modeStr string
1312 if len(msg.Params) > 1 {
1313 modeStr = msg.Params[1]
1314 }
1315
[139]1316 if name == dc.nick {
[46]1317 if modeStr != "" {
[73]1318 dc.forEachUpstream(func(uc *upstreamConn) {
[301]1319 uc.SendMessageLabeled(dc.id, &irc.Message{
[69]1320 Command: "MODE",
1321 Params: []string{uc.nick, modeStr},
1322 })
[46]1323 })
1324 } else {
[55]1325 dc.SendMessage(&irc.Message{
1326 Prefix: dc.srv.prefix(),
[46]1327 Command: irc.RPL_UMODEIS,
[129]1328 Params: []string{dc.nick, ""}, // TODO
[54]1329 })
[46]1330 }
[139]1331 return nil
[46]1332 }
[139]1333
1334 uc, upstreamName, err := dc.unmarshalEntity(name)
1335 if err != nil {
1336 return err
1337 }
1338
1339 if !uc.isChannel(upstreamName) {
1340 return ircError{&irc.Message{
1341 Command: irc.ERR_USERSDONTMATCH,
1342 Params: []string{dc.nick, "Cannot change mode for other users"},
1343 }}
1344 }
1345
1346 if modeStr != "" {
1347 params := []string{upstreamName, modeStr}
1348 params = append(params, msg.Params[2:]...)
[301]1349 uc.SendMessageLabeled(dc.id, &irc.Message{
[139]1350 Command: "MODE",
1351 Params: params,
1352 })
1353 } else {
1354 ch, ok := uc.channels[upstreamName]
1355 if !ok {
1356 return ircError{&irc.Message{
1357 Command: irc.ERR_NOSUCHCHANNEL,
1358 Params: []string{dc.nick, name, "No such channel"},
1359 }}
1360 }
1361
1362 if ch.modes == nil {
1363 // we haven't received the initial RPL_CHANNELMODEIS yet
1364 // ignore the request, we will broadcast the modes later when we receive RPL_CHANNELMODEIS
1365 return nil
1366 }
1367
1368 modeStr, modeParams := ch.modes.Format()
1369 params := []string{dc.nick, name, modeStr}
1370 params = append(params, modeParams...)
1371
1372 dc.SendMessage(&irc.Message{
1373 Prefix: dc.srv.prefix(),
1374 Command: irc.RPL_CHANNELMODEIS,
1375 Params: params,
1376 })
[162]1377 if ch.creationTime != "" {
1378 dc.SendMessage(&irc.Message{
1379 Prefix: dc.srv.prefix(),
1380 Command: rpl_creationtime,
1381 Params: []string{dc.nick, name, ch.creationTime},
1382 })
1383 }
[139]1384 }
[160]1385 case "TOPIC":
1386 var channel string
1387 if err := parseMessageParams(msg, &channel); err != nil {
1388 return err
1389 }
1390
1391 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1392 if err != nil {
1393 return err
1394 }
1395
1396 if len(msg.Params) > 1 { // setting topic
1397 topic := msg.Params[1]
[301]1398 uc.SendMessageLabeled(dc.id, &irc.Message{
[160]1399 Command: "TOPIC",
1400 Params: []string{upstreamChannel, topic},
1401 })
1402 } else { // getting topic
1403 ch, ok := uc.channels[upstreamChannel]
1404 if !ok {
1405 return ircError{&irc.Message{
1406 Command: irc.ERR_NOSUCHCHANNEL,
1407 Params: []string{dc.nick, upstreamChannel, "No such channel"},
1408 }}
1409 }
1410 sendTopic(dc, ch)
1411 }
[177]1412 case "LIST":
1413 // TODO: support ELIST when supported by all upstreams
1414
1415 pl := pendingLIST{
1416 downstreamID: dc.id,
1417 pendingCommands: make(map[int64]*irc.Message),
1418 }
[298]1419 var upstream *upstreamConn
[177]1420 var upstreamChannels map[int64][]string
1421 if len(msg.Params) > 0 {
[298]1422 uc, upstreamMask, err := dc.unmarshalEntity(msg.Params[0])
1423 if err == nil && upstreamMask == "*" { // LIST */network: send LIST only to one network
1424 upstream = uc
1425 } else {
1426 upstreamChannels = make(map[int64][]string)
1427 channels := strings.Split(msg.Params[0], ",")
1428 for _, channel := range channels {
1429 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1430 if err != nil {
1431 return err
1432 }
1433 upstreamChannels[uc.network.ID] = append(upstreamChannels[uc.network.ID], upstreamChannel)
[177]1434 }
1435 }
1436 }
1437
1438 dc.user.pendingLISTs = append(dc.user.pendingLISTs, pl)
1439 dc.forEachUpstream(func(uc *upstreamConn) {
[298]1440 if upstream != nil && upstream != uc {
1441 return
1442 }
[177]1443 var params []string
1444 if upstreamChannels != nil {
1445 if channels, ok := upstreamChannels[uc.network.ID]; ok {
1446 params = []string{strings.Join(channels, ",")}
1447 } else {
1448 return
1449 }
1450 }
1451 pl.pendingCommands[uc.network.ID] = &irc.Message{
1452 Command: "LIST",
1453 Params: params,
1454 }
[181]1455 uc.trySendLIST(dc.id)
[177]1456 })
[140]1457 case "NAMES":
1458 if len(msg.Params) == 0 {
1459 dc.SendMessage(&irc.Message{
1460 Prefix: dc.srv.prefix(),
1461 Command: irc.RPL_ENDOFNAMES,
1462 Params: []string{dc.nick, "*", "End of /NAMES list"},
1463 })
1464 return nil
1465 }
1466
1467 channels := strings.Split(msg.Params[0], ",")
1468 for _, channel := range channels {
1469 uc, upstreamChannel, err := dc.unmarshalEntity(channel)
1470 if err != nil {
1471 return err
1472 }
1473
1474 ch, ok := uc.channels[upstreamChannel]
1475 if ok {
1476 sendNames(dc, ch)
1477 } else {
1478 // NAMES on a channel we have not joined, ask upstream
[176]1479 uc.SendMessageLabeled(dc.id, &irc.Message{
[140]1480 Command: "NAMES",
1481 Params: []string{upstreamChannel},
1482 })
1483 }
1484 }
[127]1485 case "WHO":
1486 if len(msg.Params) == 0 {
1487 // TODO: support WHO without parameters
1488 dc.SendMessage(&irc.Message{
1489 Prefix: dc.srv.prefix(),
1490 Command: irc.RPL_ENDOFWHO,
[140]1491 Params: []string{dc.nick, "*", "End of /WHO list"},
[127]1492 })
1493 return nil
1494 }
1495
1496 // TODO: support WHO masks
1497 entity := msg.Params[0]
1498
[142]1499 if entity == dc.nick {
1500 // TODO: support AWAY (H/G) in self WHO reply
1501 dc.SendMessage(&irc.Message{
1502 Prefix: dc.srv.prefix(),
1503 Command: irc.RPL_WHOREPLY,
[184]1504 Params: []string{dc.nick, "*", dc.user.Username, dc.hostname, dc.srv.Hostname, dc.nick, "H", "0 " + dc.realname},
[142]1505 })
1506 dc.SendMessage(&irc.Message{
1507 Prefix: dc.srv.prefix(),
1508 Command: irc.RPL_ENDOFWHO,
1509 Params: []string{dc.nick, dc.nick, "End of /WHO list"},
1510 })
1511 return nil
1512 }
[343]1513 if entity == serviceNick {
1514 dc.SendMessage(&irc.Message{
1515 Prefix: dc.srv.prefix(),
1516 Command: irc.RPL_WHOREPLY,
1517 Params: []string{serviceNick, "*", servicePrefix.User, servicePrefix.Host, dc.srv.Hostname, serviceNick, "H", "0 " + serviceRealname},
1518 })
1519 dc.SendMessage(&irc.Message{
1520 Prefix: dc.srv.prefix(),
1521 Command: irc.RPL_ENDOFWHO,
1522 Params: []string{dc.nick, serviceNick, "End of /WHO list"},
1523 })
1524 return nil
1525 }
[142]1526
[127]1527 uc, upstreamName, err := dc.unmarshalEntity(entity)
1528 if err != nil {
1529 return err
1530 }
1531
1532 var params []string
1533 if len(msg.Params) == 2 {
1534 params = []string{upstreamName, msg.Params[1]}
1535 } else {
1536 params = []string{upstreamName}
1537 }
1538
[176]1539 uc.SendMessageLabeled(dc.id, &irc.Message{
[127]1540 Command: "WHO",
1541 Params: params,
1542 })
[128]1543 case "WHOIS":
1544 if len(msg.Params) == 0 {
1545 return ircError{&irc.Message{
1546 Command: irc.ERR_NONICKNAMEGIVEN,
1547 Params: []string{dc.nick, "No nickname given"},
1548 }}
1549 }
1550
1551 var target, mask string
1552 if len(msg.Params) == 1 {
1553 target = ""
1554 mask = msg.Params[0]
1555 } else {
1556 target = msg.Params[0]
1557 mask = msg.Params[1]
1558 }
1559 // TODO: support multiple WHOIS users
1560 if i := strings.IndexByte(mask, ','); i >= 0 {
1561 mask = mask[:i]
1562 }
1563
[142]1564 if mask == dc.nick {
1565 dc.SendMessage(&irc.Message{
1566 Prefix: dc.srv.prefix(),
1567 Command: irc.RPL_WHOISUSER,
[184]1568 Params: []string{dc.nick, dc.nick, dc.user.Username, dc.hostname, "*", dc.realname},
[142]1569 })
1570 dc.SendMessage(&irc.Message{
1571 Prefix: dc.srv.prefix(),
1572 Command: irc.RPL_WHOISSERVER,
1573 Params: []string{dc.nick, dc.nick, dc.srv.Hostname, "soju"},
1574 })
1575 dc.SendMessage(&irc.Message{
1576 Prefix: dc.srv.prefix(),
1577 Command: irc.RPL_ENDOFWHOIS,
1578 Params: []string{dc.nick, dc.nick, "End of /WHOIS list"},
1579 })
1580 return nil
1581 }
1582
[128]1583 // TODO: support WHOIS masks
1584 uc, upstreamNick, err := dc.unmarshalEntity(mask)
1585 if err != nil {
1586 return err
1587 }
1588
1589 var params []string
1590 if target != "" {
[299]1591 if target == mask { // WHOIS nick nick
1592 params = []string{upstreamNick, upstreamNick}
1593 } else {
1594 params = []string{target, upstreamNick}
1595 }
[128]1596 } else {
1597 params = []string{upstreamNick}
1598 }
1599
[176]1600 uc.SendMessageLabeled(dc.id, &irc.Message{
[128]1601 Command: "WHOIS",
1602 Params: params,
1603 })
[58]1604 case "PRIVMSG":
1605 var targetsStr, text string
1606 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1607 return err
1608 }
[303]1609 tags := copyClientTags(msg.Tags)
[58]1610
1611 for _, name := range strings.Split(targetsStr, ",") {
[117]1612 if name == serviceNick {
[431]1613 if dc.caps["echo-message"] {
1614 echoTags := tags.Copy()
1615 echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
1616 dc.SendMessage(&irc.Message{
1617 Tags: echoTags,
1618 Prefix: dc.prefix(),
1619 Command: "PRIVMSG",
1620 Params: []string{name, text},
1621 })
1622 }
[117]1623 handleServicePRIVMSG(dc, text)
1624 continue
1625 }
1626
[127]1627 uc, upstreamName, err := dc.unmarshalEntity(name)
[58]1628 if err != nil {
1629 return err
1630 }
1631
[95]1632 if upstreamName == "NickServ" {
1633 dc.handleNickServPRIVMSG(uc, text)
1634 }
1635
[268]1636 unmarshaledText := text
1637 if uc.isChannel(upstreamName) {
1638 unmarshaledText = dc.unmarshalText(uc, text)
1639 }
[301]1640 uc.SendMessageLabeled(dc.id, &irc.Message{
[303]1641 Tags: tags,
[58]1642 Command: "PRIVMSG",
[268]1643 Params: []string{upstreamName, unmarshaledText},
[60]1644 })
[105]1645
[303]1646 echoTags := tags.Copy()
1647 echoTags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
[113]1648 echoMsg := &irc.Message{
[303]1649 Tags: echoTags,
[113]1650 Prefix: &irc.Prefix{
1651 Name: uc.nick,
1652 User: uc.username,
1653 },
[114]1654 Command: "PRIVMSG",
[113]1655 Params: []string{upstreamName, text},
1656 }
[239]1657 uc.produce(upstreamName, echoMsg, dc)
[435]1658
1659 uc.updateChannelAutoDetach(upstreamName)
[58]1660 }
[164]1661 case "NOTICE":
1662 var targetsStr, text string
1663 if err := parseMessageParams(msg, &targetsStr, &text); err != nil {
1664 return err
1665 }
[303]1666 tags := copyClientTags(msg.Tags)
[164]1667
1668 for _, name := range strings.Split(targetsStr, ",") {
1669 uc, upstreamName, err := dc.unmarshalEntity(name)
1670 if err != nil {
1671 return err
1672 }
1673
[268]1674 unmarshaledText := text
1675 if uc.isChannel(upstreamName) {
1676 unmarshaledText = dc.unmarshalText(uc, text)
1677 }
[301]1678 uc.SendMessageLabeled(dc.id, &irc.Message{
[303]1679 Tags: tags,
[164]1680 Command: "NOTICE",
[268]1681 Params: []string{upstreamName, unmarshaledText},
[164]1682 })
[435]1683
1684 uc.updateChannelAutoDetach(upstreamName)
[164]1685 }
[303]1686 case "TAGMSG":
1687 var targetsStr string
1688 if err := parseMessageParams(msg, &targetsStr); err != nil {
1689 return err
1690 }
1691 tags := copyClientTags(msg.Tags)
1692
1693 for _, name := range strings.Split(targetsStr, ",") {
1694 uc, upstreamName, err := dc.unmarshalEntity(name)
1695 if err != nil {
1696 return err
1697 }
[427]1698 if _, ok := uc.caps["message-tags"]; !ok {
1699 continue
1700 }
[303]1701
1702 uc.SendMessageLabeled(dc.id, &irc.Message{
1703 Tags: tags,
1704 Command: "TAGMSG",
1705 Params: []string{upstreamName},
1706 })
[435]1707
1708 uc.updateChannelAutoDetach(upstreamName)
[303]1709 }
[163]1710 case "INVITE":
1711 var user, channel string
1712 if err := parseMessageParams(msg, &user, &channel); err != nil {
1713 return err
1714 }
1715
1716 ucChannel, upstreamChannel, err := dc.unmarshalEntity(channel)
1717 if err != nil {
1718 return err
1719 }
1720
1721 ucUser, upstreamUser, err := dc.unmarshalEntity(user)
1722 if err != nil {
1723 return err
1724 }
1725
1726 if ucChannel != ucUser {
1727 return ircError{&irc.Message{
1728 Command: irc.ERR_USERNOTINCHANNEL,
[401]1729 Params: []string{dc.nick, user, channel, "They are on another network"},
[163]1730 }}
1731 }
1732 uc := ucChannel
1733
[176]1734 uc.SendMessageLabeled(dc.id, &irc.Message{
[163]1735 Command: "INVITE",
1736 Params: []string{upstreamUser, upstreamChannel},
1737 })
[319]1738 case "CHATHISTORY":
1739 var subcommand string
1740 if err := parseMessageParams(msg, &subcommand); err != nil {
1741 return err
1742 }
1743 var target, criteria, limitStr string
1744 if err := parseMessageParams(msg, nil, &target, &criteria, &limitStr); err != nil {
1745 return ircError{&irc.Message{
1746 Command: "FAIL",
1747 Params: []string{"CHATHISTORY", "NEED_MORE_PARAMS", subcommand, "Missing parameters"},
1748 }}
1749 }
1750
[441]1751 store, ok := dc.user.msgStore.(chatHistoryMessageStore)
1752 if !ok {
[319]1753 return ircError{&irc.Message{
1754 Command: irc.ERR_UNKNOWNCOMMAND,
1755 Params: []string{dc.nick, subcommand, "Unknown command"},
1756 }}
1757 }
1758
1759 uc, entity, err := dc.unmarshalEntity(target)
1760 if err != nil {
1761 return err
1762 }
1763
1764 // TODO: support msgid criteria
1765 criteriaParts := strings.SplitN(criteria, "=", 2)
1766 if len(criteriaParts) != 2 || criteriaParts[0] != "timestamp" {
1767 return ircError{&irc.Message{
1768 Command: "FAIL",
1769 Params: []string{"CHATHISTORY", "UNKNOWN_CRITERIA", criteria, "Unknown criteria"},
1770 }}
1771 }
1772
1773 timestamp, err := time.Parse(serverTimeLayout, criteriaParts[1])
1774 if err != nil {
1775 return ircError{&irc.Message{
1776 Command: "FAIL",
1777 Params: []string{"CHATHISTORY", "INVALID_CRITERIA", criteria, "Invalid criteria"},
1778 }}
1779 }
1780
1781 limit, err := strconv.Atoi(limitStr)
1782 if err != nil || limit < 0 || limit > dc.srv.HistoryLimit {
1783 return ircError{&irc.Message{
1784 Command: "FAIL",
1785 Params: []string{"CHATHISTORY", "INVALID_LIMIT", limitStr, "Invalid limit"},
1786 }}
1787 }
1788
[387]1789 var history []*irc.Message
[319]1790 switch subcommand {
1791 case "BEFORE":
[441]1792 history, err = store.LoadBeforeTime(uc.network, entity, timestamp, limit)
[360]1793 case "AFTER":
[441]1794 history, err = store.LoadAfterTime(uc.network, entity, timestamp, limit)
[319]1795 default:
[360]1796 // TODO: support LATEST, BETWEEN
[319]1797 return ircError{&irc.Message{
1798 Command: "FAIL",
1799 Params: []string{"CHATHISTORY", "UNKNOWN_COMMAND", subcommand, "Unknown command"},
1800 }}
1801 }
[387]1802 if err != nil {
1803 dc.logger.Printf("failed parsing log messages for chathistory: %v", err)
1804 return newChatHistoryError(subcommand, target)
1805 }
1806
1807 batchRef := "history"
1808 dc.SendMessage(&irc.Message{
1809 Prefix: dc.srv.prefix(),
1810 Command: "BATCH",
1811 Params: []string{"+" + batchRef, "chathistory", target},
1812 })
1813
1814 for _, msg := range history {
1815 msg.Tags["batch"] = irc.TagValue(batchRef)
1816 dc.SendMessage(dc.marshalMessage(msg, uc.network))
1817 }
1818
1819 dc.SendMessage(&irc.Message{
1820 Prefix: dc.srv.prefix(),
1821 Command: "BATCH",
1822 Params: []string{"-" + batchRef},
1823 })
[13]1824 default:
[55]1825 dc.logger.Printf("unhandled message: %v", msg)
[13]1826 return newUnknownCommandError(msg.Command)
1827 }
[42]1828 return nil
[13]1829}
[95]1830
1831func (dc *downstreamConn) handleNickServPRIVMSG(uc *upstreamConn, text string) {
1832 username, password, ok := parseNickServCredentials(text, uc.nick)
1833 if !ok {
1834 return
1835 }
1836
[307]1837 // User may have e.g. EXTERNAL mechanism configured. We do not want to
1838 // automatically erase the key pair or any other credentials.
1839 if uc.network.SASL.Mechanism != "" && uc.network.SASL.Mechanism != "PLAIN" {
1840 return
1841 }
1842
[95]1843 dc.logger.Printf("auto-saving NickServ credentials with username %q", username)
1844 n := uc.network
1845 n.SASL.Mechanism = "PLAIN"
1846 n.SASL.Plain.Username = username
1847 n.SASL.Plain.Password = password
[421]1848 if err := dc.srv.db.StoreNetwork(dc.user.ID, &n.Network); err != nil {
[95]1849 dc.logger.Printf("failed to save NickServ credentials: %v", err)
1850 }
1851}
1852
1853func parseNickServCredentials(text, nick string) (username, password string, ok bool) {
1854 fields := strings.Fields(text)
1855 if len(fields) < 2 {
1856 return "", "", false
1857 }
1858 cmd := strings.ToUpper(fields[0])
1859 params := fields[1:]
1860 switch cmd {
1861 case "REGISTER":
1862 username = nick
1863 password = params[0]
1864 case "IDENTIFY":
1865 if len(params) == 1 {
1866 username = nick
[182]1867 password = params[0]
[95]1868 } else {
1869 username = params[0]
[182]1870 password = params[1]
[95]1871 }
[182]1872 case "SET":
1873 if len(params) == 2 && strings.EqualFold(params[0], "PASSWORD") {
1874 username = nick
1875 password = params[1]
1876 }
[340]1877 default:
1878 return "", "", false
[95]1879 }
1880 return username, password, true
1881}
Note: See TracBrowser for help on using the repository browser.