source: code/trunk/upstream.go@ 49

Last change on this file since 49 was 46, checked in by contact, 5 years ago

Handle downstream MODE messages
File size: 7.8 KB
RevLine 
[13]1package jounce
2
3import (
4 "crypto/tls"
5 "fmt"
6 "io"
7 "net"
[19]8 "strconv"
[17]9 "strings"
[19]10 "time"
[13]11
12 "gopkg.in/irc.v3"
13)
14
[19]15type upstreamChannel struct {
16 Name string
[46]17 conn *upstreamConn
[19]18 Topic string
19 TopicWho string
20 TopicTime time.Time
21 Status channelStatus
[35]22 modes modeSet
[19]23 Members map[string]membership
[25]24 complete bool
[19]25}
26
[13]27type upstreamConn struct {
[19]28 upstream *Upstream
[21]29 logger Logger
[19]30 net net.Conn
31 irc *irc.Conn
32 srv *Server
[37]33 user *user
[33]34 messages chan<- *irc.Message
[16]35
36 serverName string
37 availableUserModes string
38 availableChannelModes string
39 channelModesWithParam string
[19]40
41 registered bool
[42]42 nick string
[33]43 closed bool
[19]44 modes modeSet
45 channels map[string]*upstreamChannel
[13]46}
47
[37]48func connectToUpstream(u *user, upstream *Upstream) (*upstreamConn, error) {
49 logger := &prefixLogger{u.srv.Logger, fmt.Sprintf("upstream %q: ", upstream.Addr)}
[33]50 logger.Printf("connecting to server")
51
52 netConn, err := tls.Dial("tcp", upstream.Addr, nil)
53 if err != nil {
54 return nil, fmt.Errorf("failed to dial %q: %v", upstream.Addr, err)
55 }
56
57 msgs := make(chan *irc.Message, 64)
58 conn := &upstreamConn{
59 upstream: upstream,
60 logger: logger,
61 net: netConn,
62 irc: irc.NewConn(netConn),
[37]63 srv: u.srv,
64 user: u,
[33]65 messages: msgs,
66 channels: make(map[string]*upstreamChannel),
67 }
68
69 go func() {
70 for msg := range msgs {
71 if err := conn.irc.WriteMessage(msg); err != nil {
72 conn.logger.Printf("failed to write message: %v", err)
73 }
74 }
[45]75 if err := conn.net.Close(); err != nil {
76 conn.logger.Printf("failed to close connection: %v", err)
77 } else {
78 conn.logger.Printf("connection closed")
79 }
[33]80 }()
81
82 return conn, nil
83}
84
85func (c *upstreamConn) Close() error {
86 if c.closed {
87 return fmt.Errorf("upstream connection already closed")
88 }
89 close(c.messages)
90 c.closed = true
91 return nil
92}
93
[19]94func (c *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
95 ch, ok := c.channels[name]
96 if !ok {
97 return nil, fmt.Errorf("unknown channel %q", name)
98 }
99 return ch, nil
100}
101
[13]102func (c *upstreamConn) handleMessage(msg *irc.Message) error {
103 switch msg.Command {
104 case "PING":
105 // TODO: handle params
[33]106 c.messages <- &irc.Message{
[13]107 Command: "PONG",
108 Params: []string{c.srv.Hostname},
[33]109 }
110 return nil
[17]111 case "MODE":
[43]112 var name, modeStr string
113 if err := parseMessageParams(msg, &name, &modeStr); err != nil {
114 return err
[17]115 }
[35]116
117 if name == msg.Prefix.Name { // user mode change
[42]118 if name != c.nick {
[35]119 return fmt.Errorf("received MODE message for unknow nick %q", name)
120 }
121 return c.modes.Apply(modeStr)
122 } else { // channel mode change
123 ch, err := c.getChannel(name)
124 if err != nil {
125 return err
126 }
127 if err := ch.modes.Apply(modeStr); err != nil {
128 return err
129 }
[46]130 }
[35]131
[46]132 c.user.forEachDownstream(func(dc *downstreamConn) {
133 dc.messages <- msg
134 })
[18]135 case "NOTICE":
[21]136 c.logger.Print(msg)
[14]137 case irc.RPL_WELCOME:
138 c.registered = true
[21]139 c.logger.Printf("connection registered")
[19]140
141 for _, ch := range c.upstream.Channels {
[33]142 c.messages <- &irc.Message{
[19]143 Command: "JOIN",
144 Params: []string{ch},
145 }
146 }
[16]147 case irc.RPL_MYINFO:
[43]148 if err := parseMessageParams(msg, nil, &c.serverName, nil, &c.availableUserModes, &c.availableChannelModes); err != nil {
149 return err
[16]150 }
151 if len(msg.Params) > 5 {
152 c.channelModesWithParam = msg.Params[5]
153 }
[42]154 case "NICK":
[43]155 var newNick string
156 if err := parseMessageParams(msg, &newNick); err != nil {
157 return err
[42]158 }
159
160 if msg.Prefix.Name == c.nick {
161 c.logger.Printf("changed nick from %q to %q", c.nick, newNick)
162 c.nick = newNick
163 }
164
165 for _, ch := range c.channels {
166 if membership, ok := ch.Members[msg.Prefix.Name]; ok {
167 delete(ch.Members, msg.Prefix.Name)
168 ch.Members[newNick] = membership
169 }
170 }
171
172 c.user.forEachDownstream(func(dc *downstreamConn) {
173 dc.messages <- msg
174 })
[19]175 case "JOIN":
[43]176 var channels string
177 if err := parseMessageParams(msg, &channels); err != nil {
178 return err
[19]179 }
[34]180
[43]181 for _, ch := range strings.Split(channels, ",") {
[42]182 if msg.Prefix.Name == c.nick {
[34]183 c.logger.Printf("joined channel %q", ch)
184 c.channels[ch] = &upstreamChannel{
185 Name: ch,
[46]186 conn: c,
[34]187 Members: make(map[string]membership),
188 }
189 } else {
190 ch, err := c.getChannel(ch)
191 if err != nil {
192 return err
193 }
194 ch.Members[msg.Prefix.Name] = 0
[19]195 }
196 }
[34]197
[40]198 c.user.forEachDownstream(func(dc *downstreamConn) {
[34]199 dc.messages <- msg
[40]200 })
[34]201 case "PART":
[43]202 var channels string
203 if err := parseMessageParams(msg, &channels); err != nil {
204 return err
[34]205 }
206
[43]207 for _, ch := range strings.Split(channels, ",") {
[42]208 if msg.Prefix.Name == c.nick {
[34]209 c.logger.Printf("parted channel %q", ch)
210 delete(c.channels, ch)
211 } else {
212 ch, err := c.getChannel(ch)
213 if err != nil {
214 return err
215 }
216 delete(ch.Members, msg.Prefix.Name)
217 }
218 }
219
[40]220 c.user.forEachDownstream(func(dc *downstreamConn) {
[34]221 dc.messages <- msg
[40]222 })
[19]223 case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
[43]224 var name, topic string
225 if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
226 return err
[19]227 }
[43]228 ch, err := c.getChannel(name)
[19]229 if err != nil {
230 return err
231 }
232 if msg.Command == irc.RPL_TOPIC {
[43]233 ch.Topic = topic
[19]234 } else {
235 ch.Topic = ""
236 }
237 case "TOPIC":
[43]238 var name string
239 if err := parseMessageParams(msg, nil, &name); err != nil {
240 return err
[19]241 }
[43]242 ch, err := c.getChannel(name)
[19]243 if err != nil {
244 return err
245 }
246 if len(msg.Params) > 1 {
247 ch.Topic = msg.Params[1]
248 } else {
249 ch.Topic = ""
250 }
251 case rpl_topicwhotime:
[43]252 var name, who, timeStr string
253 if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
254 return err
[19]255 }
[43]256 ch, err := c.getChannel(name)
[19]257 if err != nil {
258 return err
259 }
[43]260 ch.TopicWho = who
261 sec, err := strconv.ParseInt(timeStr, 10, 64)
[19]262 if err != nil {
263 return fmt.Errorf("failed to parse topic time: %v", err)
264 }
265 ch.TopicTime = time.Unix(sec, 0)
266 case irc.RPL_NAMREPLY:
[43]267 var name, statusStr, members string
268 if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
269 return err
[19]270 }
[43]271 ch, err := c.getChannel(name)
[19]272 if err != nil {
273 return err
274 }
275
[43]276 status, err := parseChannelStatus(statusStr)
[19]277 if err != nil {
278 return err
279 }
280 ch.Status = status
281
[43]282 for _, s := range strings.Split(members, " ") {
[19]283 membership, nick := parseMembershipPrefix(s)
284 ch.Members[nick] = membership
285 }
286 case irc.RPL_ENDOFNAMES:
[43]287 var name string
288 if err := parseMessageParams(msg, nil, &name); err != nil {
289 return err
[25]290 }
[43]291 ch, err := c.getChannel(name)
[25]292 if err != nil {
293 return err
294 }
295
[34]296 if ch.complete {
297 return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
298 }
[25]299 ch.complete = true
[27]300
[40]301 c.user.forEachDownstream(func(dc *downstreamConn) {
[27]302 forwardChannel(dc, ch)
[40]303 })
[36]304 case "PRIVMSG":
[40]305 c.user.forEachDownstream(func(dc *downstreamConn) {
[36]306 dc.messages <- msg
[40]307 })
[16]308 case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]309 // Ignore
310 case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
311 // Ignore
312 case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
313 // Ignore
314 case rpl_localusers, rpl_globalusers:
315 // Ignore
316 case irc.RPL_STATSVLINE, irc.RPL_STATSPING, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
317 // Ignore
[13]318 default:
[21]319 c.logger.Printf("unhandled upstream message: %v", msg)
[13]320 }
[14]321 return nil
[13]322}
323
[44]324func (c *upstreamConn) register() {
[42]325 c.nick = c.upstream.Nick
[33]326 c.messages <- &irc.Message{
[13]327 Command: "NICK",
[23]328 Params: []string{c.upstream.Nick},
[13]329 }
[33]330 c.messages <- &irc.Message{
[13]331 Command: "USER",
[23]332 Params: []string{c.upstream.Username, "0", "*", c.upstream.Realname},
[13]333 }
[44]334}
[13]335
[44]336func (c *upstreamConn) readMessages() error {
[13]337 for {
338 msg, err := c.irc.ReadMessage()
339 if err == io.EOF {
340 break
341 } else if err != nil {
342 return fmt.Errorf("failed to read IRC command: %v", err)
343 }
344
345 if err := c.handleMessage(msg); err != nil {
[21]346 c.logger.Printf("failed to handle message %q: %v", msg, err)
[13]347 }
348 }
349
[45]350 return nil
[13]351}
Note: See TracBrowser for help on using the repository browser.