source: code/trunk/upstream.go@ 70

Last change on this file since 70 was 69, checked in by contact, 5 years ago

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