Context Navigation

source: code/trunk/upstream.go@ 245

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

Centralize logged messages marshaling

This allows messages added to logs to be handled just like messages
added to the ring buffer.

File size: 32.7 KB

Rev	Line
[98]	1	package soju
[13]	2
	3	import (
	4	"crypto/tls"
[95]	5	"encoding/base64"
[155]	6	"errors"
[13]	7	"fmt"
	8	"io"
	9	"net"
[19]	10	"strconv"
[17]	11	"strings"
[19]	12	"time"
[13]	13
[95]	14	"github.com/emersion/go-sasl"
[13]	15	"gopkg.in/irc.v3"
	16	)
	17
[19]	18	type upstreamChannel struct {
[162]	19	Name string
	20	conn *upstreamConn
	21	Topic string
	22	TopicWho string
	23	TopicTime time.Time
	24	Status channelStatus
	25	modes channelModes
	26	creationTime string
	27	Members map[string]*membership
	28	complete bool
[19]	29	}
	30
[13]	31	type upstreamConn struct {
[210]	32	conn
[16]	33
[210]	34	network *network
	35	user *user
	36
[16]	37	serverName string
	38	availableUserModes string
[139]	39	availableChannelModes map[byte]channelModeType
	40	availableChannelTypes string
	41	availableMemberships []membership
[19]	42
	43	registered bool
[42]	44	nick string
[77]	45	username string
	46	realname string
[139]	47	modes userModes
[19]	48	channels map[string]*upstreamChannel
[92]	49	caps map[string]string
[153]	50	batches map[string]batch
[198]	51	away bool
[95]	52
[155]	53	tagsSupported bool
	54	labelsSupported bool
[161]	55	nextLabelID uint64
[152]	56
[95]	57	saslClient sasl.Client
	58	saslStarted bool
[177]	59
	60	// set of LIST commands in progress, per downstream
	61	pendingLISTDownstreamSet map[uint64]struct{}
[178]	62
[215]	63	messageLoggers map[string]*messageLogger
[13]	64	}
	65
[77]	66	func connectToUpstream(network network) (upstreamConn, error) {
	67	logger := &prefixLogger{network.user.srv.Logger, fmt.Sprintf("upstream %q: ", network.Addr)}
[33]	68
[77]	69	addr := network.Addr
	70	if !strings.ContainsRune(addr, ':') {
	71	addr = addr + ":6697"
	72	}
	73
[206]	74	dialer := net.Dialer{Timeout: connectTimeout}
	75
[77]	76	logger.Printf("connecting to TLS server at address %q", addr)
[206]	77	netConn, err := tls.DialWithDialer(&dialer, "tcp", addr, nil)
[33]	78	if err != nil {
[77]	79	return nil, fmt.Errorf("failed to dial %q: %v", addr, err)
[33]	80	}
	81
[55]	82	uc := &upstreamConn{
[210]	83	conn: *newConn(network.user.srv, netConn, logger),
[177]	84	network: network,
	85	user: network.user,
	86	channels: make(map[string]*upstreamChannel),
	87	caps: make(map[string]string),
	88	batches: make(map[string]batch),
	89	availableChannelTypes: stdChannelTypes,
	90	availableChannelModes: stdChannelModes,
	91	availableMemberships: stdMemberships,
	92	pendingLISTDownstreamSet: make(map[uint64]struct{}),
[215]	93	messageLoggers: make(map[string]*messageLogger),
[33]	94	}
	95
[55]	96	return uc, nil
[33]	97	}
	98
[73]	99	func (uc upstreamConn) forEachDownstream(f func(downstreamConn)) {
[218]	100	uc.network.forEachDownstream(f)
[73]	101	}
	102
[161]	103	func (uc upstreamConn) forEachDownstreamByID(id uint64, f func(downstreamConn)) {
[155]	104	uc.forEachDownstream(func(dc *downstreamConn) {
	105	if id != 0 && id != dc.id {
	106	return
	107	}
	108	f(dc)
	109	})
	110	}
	111
[55]	112	func (uc upstreamConn) getChannel(name string) (upstreamChannel, error) {
	113	ch, ok := uc.channels[name]
[19]	114	if !ok {
	115	return nil, fmt.Errorf("unknown channel %q", name)
	116	}
	117	return ch, nil
	118	}
	119
[129]	120	func (uc *upstreamConn) isChannel(entity string) bool {
[139]	121	if i := strings.IndexByte(uc.availableChannelTypes, entity[0]); i >= 0 {
	122	return true
[129]	123	}
	124	return false
	125	}
	126
[181]	127	func (uc upstreamConn) getPendingLIST() pendingLIST {
[177]	128	for _, pl := range uc.user.pendingLISTs {
	129	if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
	130	continue
	131	}
	132	return &pl
	133	}
	134	return nil
	135	}
	136
[181]	137	func (uc *upstreamConn) endPendingLISTs(all bool) (found bool) {
[177]	138	found = false
	139	for i := 0; i < len(uc.user.pendingLISTs); i++ {
	140	pl := uc.user.pendingLISTs[i]
	141	if _, ok := pl.pendingCommands[uc.network.ID]; !ok {
	142	continue
	143	}
	144	delete(pl.pendingCommands, uc.network.ID)
	145	if len(pl.pendingCommands) == 0 {
	146	uc.user.pendingLISTs = append(uc.user.pendingLISTs[:i], uc.user.pendingLISTs[i+1:]...)
	147	i--
	148	uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
	149	dc.SendMessage(&irc.Message{
	150	Prefix: dc.srv.prefix(),
	151	Command: irc.RPL_LISTEND,
	152	Params: []string{dc.nick, "End of /LIST"},
	153	})
	154	})
	155	}
	156	found = true
	157	if !all {
	158	delete(uc.pendingLISTDownstreamSet, pl.downstreamID)
	159	uc.user.forEachUpstream(func(uc *upstreamConn) {
[181]	160	uc.trySendLIST(pl.downstreamID)
[177]	161	})
	162	return
	163	}
	164	}
	165	return
	166	}
	167
[181]	168	func (uc *upstreamConn) trySendLIST(downstreamID uint64) {
[177]	169	// must be called with a lock in uc.user.pendingLISTsLock
	170
	171	if _, ok := uc.pendingLISTDownstreamSet[downstreamID]; ok {
	172	// a LIST command is already pending
	173	// we will try again when that command is completed
	174	return
	175	}
	176
	177	for _, pl := range uc.user.pendingLISTs {
	178	if pl.downstreamID != downstreamID {
	179	continue
	180	}
	181	// this is the first pending LIST command list of the downstream
	182	listCommand, ok := pl.pendingCommands[uc.network.ID]
	183	if !ok {
	184	// there is no command for this upstream in these LIST commands
	185	// do not send anything
	186	continue
	187	}
	188	// there is a command for this upstream in these LIST commands
	189	// send it now
	190
	191	uc.SendMessageLabeled(downstreamID, listCommand)
	192
	193	uc.pendingLISTDownstreamSet[downstreamID] = struct{}{}
	194	return
	195	}
	196	}
	197
[139]	198	func (uc upstreamConn) parseMembershipPrefix(s string) (membership membership, nick string) {
	199	for _, m := range uc.availableMemberships {
	200	if m.Prefix == s[0] {
	201	return &m, s[1:]
	202	}
	203	}
	204	return nil, s
	205	}
	206
[55]	207	func (uc upstreamConn) handleMessage(msg irc.Message) error {
[155]	208	var label string
	209	if l, ok := msg.GetTag("label"); ok {
	210	label = l
	211	}
	212
[153]	213	var msgBatch *batch
	214	if batchName, ok := msg.GetTag("batch"); ok {
	215	b, ok := uc.batches[batchName]
	216	if !ok {
	217	return fmt.Errorf("unexpected batch reference: batch was not defined: %q", batchName)
	218	}
	219	msgBatch = &b
[155]	220	if label == "" {
	221	label = msgBatch.Label
	222	}
[153]	223	}
	224
[161]	225	var downstreamID uint64 = 0
[155]	226	if label != "" {
	227	var labelOffset uint64
[161]	228	n, err := fmt.Sscanf(label, "sd-%d-%d", &downstreamID, &labelOffset)
[155]	229	if err == nil && n < 2 {
	230	err = errors.New("not enough arguments")
	231	}
	232	if err != nil {
	233	return fmt.Errorf("unexpected message label: invalid downstream reference for label %q: %v", label, err)
	234	}
	235	}
	236
[216]	237	if _, ok := msg.Tags["time"]; !ok {
[240]	238	msg.Tags["time"] = irc.TagValue(time.Now().UTC().Format(serverTimeLayout))
[216]	239	}
	240
[13]	241	switch msg.Command {
	242	case "PING":
[60]	243	uc.SendMessage(&irc.Message{
[13]	244	Command: "PONG",
[68]	245	Params: msg.Params,
[60]	246	})
[33]	247	return nil
[18]	248	case "NOTICE":
[171]	249	if msg.Prefix.User == "" && msg.Prefix.Host == "" { // server message
[239]	250	uc.produce("", msg, nil)
[171]	251	} else { // regular user NOTICE
[217]	252	var entity, text string
	253	if err := parseMessageParams(msg, &entity, &text); err != nil {
[171]	254	return err
	255	}
	256
[217]	257	target := entity
	258	if target == uc.nick {
[178]	259	target = msg.Prefix.Name
	260	}
[239]	261	uc.produce(target, msg, nil)
[171]	262	}
[92]	263	case "CAP":
[95]	264	var subCmd string
	265	if err := parseMessageParams(msg, nil, &subCmd); err != nil {
	266	return err
[92]	267	}
[95]	268	subCmd = strings.ToUpper(subCmd)
	269	subParams := msg.Params[2:]
	270	switch subCmd {
	271	case "LS":
	272	if len(subParams) < 1 {
	273	return newNeedMoreParamsError(msg.Command)
	274	}
	275	caps := strings.Fields(subParams[len(subParams)-1])
	276	more := len(subParams) >= 2 && msg.Params[len(subParams)-2] == "*"
[92]	277
[95]	278	for _, s := range caps {
	279	kv := strings.SplitN(s, "=", 2)
	280	k := strings.ToLower(kv[0])
	281	var v string
	282	if len(kv) == 2 {
	283	v = kv[1]
	284	}
	285	uc.caps[k] = v
[92]	286	}
	287
[95]	288	if more {
	289	break // wait to receive all capabilities
	290	}
	291
[152]	292	requestCaps := make([]string, 0, 16)
[193]	293	for _, c := range []string{"message-tags", "batch", "labeled-response", "server-time"} {
[152]	294	if _, ok := uc.caps[c]; ok {
	295	requestCaps = append(requestCaps, c)
	296	}
	297	}
	298
[95]	299	if uc.requestSASL() {
[152]	300	requestCaps = append(requestCaps, "sasl")
	301	}
	302
	303	if len(requestCaps) > 0 {
[95]	304	uc.SendMessage(&irc.Message{
	305	Command: "CAP",
[152]	306	Params: []string{"REQ", strings.Join(requestCaps, " ")},
[95]	307	})
[152]	308	}
	309
	310	if uc.requestSASL() {
[95]	311	break // we'll send CAP END after authentication is completed
	312	}
	313
[92]	314	uc.SendMessage(&irc.Message{
	315	Command: "CAP",
	316	Params: []string{"END"},
	317	})
[95]	318	case "ACK", "NAK":
	319	if len(subParams) < 1 {
	320	return newNeedMoreParamsError(msg.Command)
	321	}
	322	caps := strings.Fields(subParams[0])
	323
	324	for _, name := range caps {
	325	if err := uc.handleCapAck(strings.ToLower(name), subCmd == "ACK"); err != nil {
	326	return err
	327	}
	328	}
	329
	330	if uc.saslClient == nil {
	331	uc.SendMessage(&irc.Message{
	332	Command: "CAP",
	333	Params: []string{"END"},
	334	})
	335	}
	336	default:
	337	uc.logger.Printf("unhandled message: %v", msg)
[92]	338	}
[95]	339	case "AUTHENTICATE":
	340	if uc.saslClient == nil {
	341	return fmt.Errorf("received unexpected AUTHENTICATE message")
	342	}
	343
	344	// TODO: if a challenge is 400 bytes long, buffer it
	345	var challengeStr string
	346	if err := parseMessageParams(msg, &challengeStr); err != nil {
	347	uc.SendMessage(&irc.Message{
	348	Command: "AUTHENTICATE",
	349	Params: []string{"*"},
	350	})
	351	return err
	352	}
	353
	354	var challenge []byte
	355	if challengeStr != "+" {
	356	var err error
	357	challenge, err = base64.StdEncoding.DecodeString(challengeStr)
	358	if err != nil {
	359	uc.SendMessage(&irc.Message{
	360	Command: "AUTHENTICATE",
	361	Params: []string{"*"},
	362	})
	363	return err
	364	}
	365	}
	366
	367	var resp []byte
	368	var err error
	369	if !uc.saslStarted {
	370	_, resp, err = uc.saslClient.Start()
	371	uc.saslStarted = true
	372	} else {
	373	resp, err = uc.saslClient.Next(challenge)
	374	}
	375	if err != nil {
	376	uc.SendMessage(&irc.Message{
	377	Command: "AUTHENTICATE",
	378	Params: []string{"*"},
	379	})
	380	return err
	381	}
	382
	383	// TODO: send response in multiple chunks if >= 400 bytes
	384	var respStr = "+"
	385	if resp != nil {
	386	respStr = base64.StdEncoding.EncodeToString(resp)
	387	}
	388
	389	uc.SendMessage(&irc.Message{
	390	Command: "AUTHENTICATE",
	391	Params: []string{respStr},
	392	})
[125]	393	case irc.RPL_LOGGEDIN:
[95]	394	var account string
	395	if err := parseMessageParams(msg, nil, nil, &account); err != nil {
	396	return err
	397	}
	398	uc.logger.Printf("logged in with account %q", account)
[125]	399	case irc.RPL_LOGGEDOUT:
[95]	400	uc.logger.Printf("logged out")
[125]	401	case irc.ERR_NICKLOCKED, irc.RPL_SASLSUCCESS, irc.ERR_SASLFAIL, irc.ERR_SASLTOOLONG, irc.ERR_SASLABORTED:
[95]	402	var info string
	403	if err := parseMessageParams(msg, nil, &info); err != nil {
	404	return err
	405	}
	406	switch msg.Command {
[125]	407	case irc.ERR_NICKLOCKED:
[95]	408	uc.logger.Printf("invalid nick used with SASL authentication: %v", info)
[125]	409	case irc.ERR_SASLFAIL:
[95]	410	uc.logger.Printf("SASL authentication failed: %v", info)
[125]	411	case irc.ERR_SASLTOOLONG:
[95]	412	uc.logger.Printf("SASL message too long: %v", info)
	413	}
	414
	415	uc.saslClient = nil
	416	uc.saslStarted = false
	417
	418	uc.SendMessage(&irc.Message{
	419	Command: "CAP",
	420	Params: []string{"END"},
	421	})
[14]	422	case irc.RPL_WELCOME:
[55]	423	uc.registered = true
	424	uc.logger.Printf("connection registered")
[19]	425
[77]	426	channels, err := uc.srv.db.ListChannels(uc.network.ID)
	427	if err != nil {
	428	uc.logger.Printf("failed to list channels from database: %v", err)
	429	break
	430	}
	431
	432	for _, ch := range channels {
[146]	433	params := []string{ch.Name}
	434	if ch.Key != "" {
	435	params = append(params, ch.Key)
	436	}
[60]	437	uc.SendMessage(&irc.Message{
[19]	438	Command: "JOIN",
[146]	439	Params: params,
[60]	440	})
[19]	441	}
[16]	442	case irc.RPL_MYINFO:
[139]	443	if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, nil); err != nil {
[43]	444	return err
[16]	445	}
[139]	446	case irc.RPL_ISUPPORT:
	447	if err := parseMessageParams(msg, nil, nil); err != nil {
	448	return err
[16]	449	}
[139]	450	for _, token := range msg.Params[1 : len(msg.Params)-1] {
	451	negate := false
	452	parameter := token
	453	value := ""
	454	if strings.HasPrefix(token, "-") {
	455	negate = true
	456	token = token[1:]
	457	} else {
	458	if i := strings.IndexByte(token, '='); i >= 0 {
	459	parameter = token[:i]
	460	value = token[i+1:]
	461	}
	462	}
	463	if !negate {
	464	switch parameter {
	465	case "CHANMODES":
	466	parts := strings.SplitN(value, ",", 5)
	467	if len(parts) < 4 {
	468	return fmt.Errorf("malformed ISUPPORT CHANMODES value: %v", value)
	469	}
	470	modes := make(map[byte]channelModeType)
	471	for i, mt := range []channelModeType{modeTypeA, modeTypeB, modeTypeC, modeTypeD} {
	472	for j := 0; j < len(parts[i]); j++ {
	473	mode := parts[i][j]
	474	modes[mode] = mt
	475	}
	476	}
	477	uc.availableChannelModes = modes
	478	case "CHANTYPES":
	479	uc.availableChannelTypes = value
	480	case "PREFIX":
	481	if value == "" {
	482	uc.availableMemberships = nil
	483	} else {
	484	if value[0] != '(' {
	485	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	486	}
	487	sep := strings.IndexByte(value, ')')
	488	if sep < 0 \|\| len(value) != sep*2 {
	489	return fmt.Errorf("malformed ISUPPORT PREFIX value: %v", value)
	490	}
	491	memberships := make([]membership, len(value)/2-1)
	492	for i := range memberships {
	493	memberships[i] = membership{
	494	Mode: value[i+1],
	495	Prefix: value[sep+i+1],
	496	}
	497	}
	498	uc.availableMemberships = memberships
	499	}
	500	}
	501	} else {
	502	// TODO: handle ISUPPORT negations
	503	}
	504	}
[153]	505	case "BATCH":
	506	var tag string
	507	if err := parseMessageParams(msg, &tag); err != nil {
	508	return err
	509	}
	510
	511	if strings.HasPrefix(tag, "+") {
	512	tag = tag[1:]
	513	if _, ok := uc.batches[tag]; ok {
	514	return fmt.Errorf("unexpected BATCH reference tag: batch was already defined: %q", tag)
	515	}
	516	var batchType string
	517	if err := parseMessageParams(msg, nil, &batchType); err != nil {
	518	return err
	519	}
[155]	520	label := label
	521	if label == "" && msgBatch != nil {
	522	label = msgBatch.Label
	523	}
[153]	524	uc.batches[tag] = batch{
	525	Type: batchType,
	526	Params: msg.Params[2:],
	527	Outer: msgBatch,
[155]	528	Label: label,
[153]	529	}
	530	} else if strings.HasPrefix(tag, "-") {
	531	tag = tag[1:]
	532	if _, ok := uc.batches[tag]; !ok {
	533	return fmt.Errorf("unknown BATCH reference tag: %q", tag)
	534	}
	535	delete(uc.batches, tag)
	536	} else {
	537	return fmt.Errorf("unexpected BATCH reference tag: missing +/- prefix: %q", tag)
	538	}
[42]	539	case "NICK":
[83]	540	if msg.Prefix == nil {
	541	return fmt.Errorf("expected a prefix")
	542	}
	543
[43]	544	var newNick string
	545	if err := parseMessageParams(msg, &newNick); err != nil {
	546	return err
[42]	547	}
	548
[244]	549	me := false
[55]	550	if msg.Prefix.Name == uc.nick {
	551	uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
[244]	552	me = true
[55]	553	uc.nick = newNick
[42]	554	}
	555
[55]	556	for _, ch := range uc.channels {
[42]	557	if membership, ok := ch.Members[msg.Prefix.Name]; ok {
	558	delete(ch.Members, msg.Prefix.Name)
	559	ch.Members[newNick] = membership
[215]	560	uc.appendLog(ch.Name, msg)
[42]	561	}
	562	}
[82]	563
[244]	564	if !me {
[245]	565	uc.network.ring.Produce(msg)
[82]	566	uc.forEachDownstream(func(dc *downstreamConn) {
[245]	567	dc.SendMessage(dc.marshalMessage(msg, uc))
[82]	568	})
	569	}
[69]	570	case "JOIN":
	571	if msg.Prefix == nil {
	572	return fmt.Errorf("expected a prefix")
	573	}
[42]	574
[43]	575	var channels string
	576	if err := parseMessageParams(msg, &channels); err != nil {
	577	return err
[19]	578	}
[34]	579
[43]	580	for _, ch := range strings.Split(channels, ",") {
[55]	581	if msg.Prefix.Name == uc.nick {
	582	uc.logger.Printf("joined channel %q", ch)
	583	uc.channels[ch] = &upstreamChannel{
[34]	584	Name: ch,
[55]	585	conn: uc,
[139]	586	Members: make(map[string]*membership),
[34]	587	}
[139]	588
	589	uc.SendMessage(&irc.Message{
	590	Command: "MODE",
	591	Params: []string{ch},
	592	})
[34]	593	} else {
[55]	594	ch, err := uc.getChannel(ch)
[34]	595	if err != nil {
	596	return err
	597	}
[139]	598	ch.Members[msg.Prefix.Name] = nil
[19]	599	}
[69]	600
[245]	601	chMsg := msg.Copy()
	602	chMsg.Params[0] = ch
	603	uc.produce(ch, chMsg, nil)
[19]	604	}
[69]	605	case "PART":
	606	if msg.Prefix == nil {
	607	return fmt.Errorf("expected a prefix")
	608	}
[34]	609
[43]	610	var channels string
	611	if err := parseMessageParams(msg, &channels); err != nil {
	612	return err
[34]	613	}
	614
[43]	615	for _, ch := range strings.Split(channels, ",") {
[55]	616	if msg.Prefix.Name == uc.nick {
	617	uc.logger.Printf("parted channel %q", ch)
	618	delete(uc.channels, ch)
[34]	619	} else {
[55]	620	ch, err := uc.getChannel(ch)
[34]	621	if err != nil {
	622	return err
	623	}
	624	delete(ch.Members, msg.Prefix.Name)
	625	}
[69]	626
[245]	627	chMsg := msg.Copy()
	628	chMsg.Params[0] = ch
	629	uc.produce(ch, chMsg, nil)
[34]	630	}
[159]	631	case "KICK":
	632	if msg.Prefix == nil {
	633	return fmt.Errorf("expected a prefix")
	634	}
	635
	636	var channel, user string
	637	if err := parseMessageParams(msg, &channel, &user); err != nil {
	638	return err
	639	}
	640
	641	if user == uc.nick {
	642	uc.logger.Printf("kicked from channel %q by %s", channel, msg.Prefix.Name)
	643	delete(uc.channels, channel)
	644	} else {
	645	ch, err := uc.getChannel(channel)
	646	if err != nil {
	647	return err
	648	}
	649	delete(ch.Members, user)
	650	}
	651
[245]	652	uc.produce(channel, msg, nil)
[83]	653	case "QUIT":
	654	if msg.Prefix == nil {
	655	return fmt.Errorf("expected a prefix")
	656	}
	657
	658	if msg.Prefix.Name == uc.nick {
	659	uc.logger.Printf("quit")
	660	}
	661
	662	for _, ch := range uc.channels {
[178]	663	if _, ok := ch.Members[msg.Prefix.Name]; ok {
	664	delete(ch.Members, msg.Prefix.Name)
	665
[215]	666	uc.appendLog(ch.Name, msg)
[178]	667	}
[83]	668	}
	669
	670	if msg.Prefix.Name != uc.nick {
[245]	671	uc.network.ring.Produce(msg)
[83]	672	uc.forEachDownstream(func(dc *downstreamConn) {
[245]	673	dc.SendMessage(dc.marshalMessage(msg, uc))
[83]	674	})
	675	}
[19]	676	case irc.RPL_TOPIC, irc.RPL_NOTOPIC:
[43]	677	var name, topic string
	678	if err := parseMessageParams(msg, nil, &name, &topic); err != nil {
	679	return err
[19]	680	}
[55]	681	ch, err := uc.getChannel(name)
[19]	682	if err != nil {
	683	return err
	684	}
	685	if msg.Command == irc.RPL_TOPIC {
[43]	686	ch.Topic = topic
[19]	687	} else {
	688	ch.Topic = ""
	689	}
	690	case "TOPIC":
[43]	691	var name string
[74]	692	if err := parseMessageParams(msg, &name); err != nil {
[43]	693	return err
[19]	694	}
[55]	695	ch, err := uc.getChannel(name)
[19]	696	if err != nil {
	697	return err
	698	}
	699	if len(msg.Params) > 1 {
	700	ch.Topic = msg.Params[1]
	701	} else {
	702	ch.Topic = ""
	703	}
[245]	704	uc.produce(ch.Name, msg, nil)
[139]	705	case "MODE":
	706	var name, modeStr string
	707	if err := parseMessageParams(msg, &name, &modeStr); err != nil {
	708	return err
	709	}
	710
	711	if !uc.isChannel(name) { // user mode change
	712	if name != uc.nick {
	713	return fmt.Errorf("received MODE message for unknown nick %q", name)
	714	}
	715	return uc.modes.Apply(modeStr)
	716	// TODO: notify downstreams about user mode change?
	717	} else { // channel mode change
	718	ch, err := uc.getChannel(name)
	719	if err != nil {
	720	return err
	721	}
	722
	723	if ch.modes != nil {
	724	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[2:]...); err != nil {
	725	return err
	726	}
	727	}
	728
[245]	729	uc.produce(ch.Name, msg, nil)
[139]	730	}
	731	case irc.RPL_UMODEIS:
	732	if err := parseMessageParams(msg, nil); err != nil {
	733	return err
	734	}
	735	modeStr := ""
	736	if len(msg.Params) > 1 {
	737	modeStr = msg.Params[1]
	738	}
	739
	740	uc.modes = ""
	741	if err := uc.modes.Apply(modeStr); err != nil {
	742	return err
	743	}
	744	// TODO: send RPL_UMODEIS to downstream connections when applicable
	745	case irc.RPL_CHANNELMODEIS:
	746	var channel string
	747	if err := parseMessageParams(msg, nil, &channel); err != nil {
	748	return err
	749	}
	750	modeStr := ""
	751	if len(msg.Params) > 2 {
	752	modeStr = msg.Params[2]
	753	}
	754
	755	ch, err := uc.getChannel(channel)
	756	if err != nil {
	757	return err
	758	}
	759
	760	firstMode := ch.modes == nil
	761	ch.modes = make(map[byte]string)
	762	if err := ch.modes.Apply(uc.availableChannelModes, modeStr, msg.Params[3:]...); err != nil {
	763	return err
	764	}
	765	if firstMode {
	766	modeStr, modeParams := ch.modes.Format()
	767
	768	uc.forEachDownstream(func(dc *downstreamConn) {
	769	params := []string{dc.nick, dc.marshalChannel(uc, channel), modeStr}
	770	params = append(params, modeParams...)
	771
	772	dc.SendMessage(&irc.Message{
	773	Prefix: dc.srv.prefix(),
	774	Command: irc.RPL_CHANNELMODEIS,
	775	Params: params,
	776	})
	777	})
	778	}
[162]	779	case rpl_creationtime:
	780	var channel, creationTime string
	781	if err := parseMessageParams(msg, nil, &channel, &creationTime); err != nil {
	782	return err
	783	}
	784
	785	ch, err := uc.getChannel(channel)
	786	if err != nil {
	787	return err
	788	}
	789
	790	firstCreationTime := ch.creationTime == ""
	791	ch.creationTime = creationTime
	792	if firstCreationTime {
	793	uc.forEachDownstream(func(dc *downstreamConn) {
	794	dc.SendMessage(&irc.Message{
	795	Prefix: dc.srv.prefix(),
	796	Command: rpl_creationtime,
	797	Params: []string{dc.nick, channel, creationTime},
	798	})
	799	})
	800	}
[19]	801	case rpl_topicwhotime:
[43]	802	var name, who, timeStr string
	803	if err := parseMessageParams(msg, nil, &name, &who, &timeStr); err != nil {
	804	return err
[19]	805	}
[55]	806	ch, err := uc.getChannel(name)
[19]	807	if err != nil {
	808	return err
	809	}
[43]	810	ch.TopicWho = who
	811	sec, err := strconv.ParseInt(timeStr, 10, 64)
[19]	812	if err != nil {
	813	return fmt.Errorf("failed to parse topic time: %v", err)
	814	}
	815	ch.TopicTime = time.Unix(sec, 0)
[177]	816	case irc.RPL_LIST:
	817	var channel, clients, topic string
	818	if err := parseMessageParams(msg, nil, &channel, &clients, &topic); err != nil {
	819	return err
	820	}
	821
[181]	822	pl := uc.getPendingLIST()
[177]	823	if pl == nil {
	824	return fmt.Errorf("unexpected RPL_LIST: no matching pending LIST")
	825	}
	826
	827	uc.forEachDownstreamByID(pl.downstreamID, func(dc *downstreamConn) {
	828	dc.SendMessage(&irc.Message{
	829	Prefix: dc.srv.prefix(),
	830	Command: irc.RPL_LIST,
	831	Params: []string{dc.nick, dc.marshalChannel(uc, channel), clients, topic},
	832	})
	833	})
	834	case irc.RPL_LISTEND:
[181]	835	ok := uc.endPendingLISTs(false)
[177]	836	if !ok {
	837	return fmt.Errorf("unexpected RPL_LISTEND: no matching pending LIST")
	838	}
[19]	839	case irc.RPL_NAMREPLY:
[43]	840	var name, statusStr, members string
	841	if err := parseMessageParams(msg, nil, &statusStr, &name, &members); err != nil {
	842	return err
[19]	843	}
[140]	844
	845	ch, ok := uc.channels[name]
	846	if !ok {
	847	// NAMES on a channel we have not joined, forward to downstream
[161]	848	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[140]	849	channel := dc.marshalChannel(uc, name)
[174]	850	members := splitSpace(members)
[140]	851	for i, member := range members {
	852	membership, nick := uc.parseMembershipPrefix(member)
	853	members[i] = membership.String() + dc.marshalNick(uc, nick)
	854	}
	855	memberStr := strings.Join(members, " ")
	856
	857	dc.SendMessage(&irc.Message{
	858	Prefix: dc.srv.prefix(),
	859	Command: irc.RPL_NAMREPLY,
	860	Params: []string{dc.nick, statusStr, channel, memberStr},
	861	})
	862	})
	863	return nil
[19]	864	}
	865
[43]	866	status, err := parseChannelStatus(statusStr)
[19]	867	if err != nil {
	868	return err
	869	}
	870	ch.Status = status
	871
[174]	872	for _, s := range splitSpace(members) {
[139]	873	membership, nick := uc.parseMembershipPrefix(s)
[19]	874	ch.Members[nick] = membership
	875	}
	876	case irc.RPL_ENDOFNAMES:
[43]	877	var name string
	878	if err := parseMessageParams(msg, nil, &name); err != nil {
	879	return err
[25]	880	}
[140]	881
	882	ch, ok := uc.channels[name]
	883	if !ok {
	884	// NAMES on a channel we have not joined, forward to downstream
[161]	885	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[140]	886	channel := dc.marshalChannel(uc, name)
	887
	888	dc.SendMessage(&irc.Message{
	889	Prefix: dc.srv.prefix(),
	890	Command: irc.RPL_ENDOFNAMES,
	891	Params: []string{dc.nick, channel, "End of /NAMES list"},
	892	})
	893	})
	894	return nil
[25]	895	}
	896
[34]	897	if ch.complete {
	898	return fmt.Errorf("received unexpected RPL_ENDOFNAMES")
	899	}
[25]	900	ch.complete = true
[27]	901
[73]	902	uc.forEachDownstream(func(dc *downstreamConn) {
[27]	903	forwardChannel(dc, ch)
[40]	904	})
[127]	905	case irc.RPL_WHOREPLY:
	906	var channel, username, host, server, nick, mode, trailing string
	907	if err := parseMessageParams(msg, nil, &channel, &username, &host, &server, &nick, &mode, &trailing); err != nil {
	908	return err
	909	}
	910
	911	parts := strings.SplitN(trailing, " ", 2)
	912	if len(parts) != 2 {
	913	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong trailing parameter: %s", trailing)
	914	}
	915	realname := parts[1]
	916	hops, err := strconv.Atoi(parts[0])
	917	if err != nil {
	918	return fmt.Errorf("received malformed RPL_WHOREPLY: wrong hop count: %s", parts[0])
	919	}
	920	hops++
	921
	922	trailing = strconv.Itoa(hops) + " " + realname
	923
[161]	924	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	925	channel := channel
	926	if channel != "*" {
	927	channel = dc.marshalChannel(uc, channel)
	928	}
	929	nick := dc.marshalNick(uc, nick)
	930	dc.SendMessage(&irc.Message{
	931	Prefix: dc.srv.prefix(),
	932	Command: irc.RPL_WHOREPLY,
	933	Params: []string{dc.nick, channel, username, host, server, nick, mode, trailing},
	934	})
	935	})
	936	case irc.RPL_ENDOFWHO:
	937	var name string
	938	if err := parseMessageParams(msg, nil, &name); err != nil {
	939	return err
	940	}
	941
[161]	942	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[127]	943	name := name
	944	if name != "*" {
	945	// TODO: support WHO masks
	946	name = dc.marshalEntity(uc, name)
	947	}
	948	dc.SendMessage(&irc.Message{
	949	Prefix: dc.srv.prefix(),
	950	Command: irc.RPL_ENDOFWHO,
[142]	951	Params: []string{dc.nick, name, "End of /WHO list"},
[127]	952	})
	953	})
[128]	954	case irc.RPL_WHOISUSER:
	955	var nick, username, host, realname string
	956	if err := parseMessageParams(msg, nil, &nick, &username, &host, nil, &realname); err != nil {
	957	return err
	958	}
	959
[161]	960	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	961	nick := dc.marshalNick(uc, nick)
	962	dc.SendMessage(&irc.Message{
	963	Prefix: dc.srv.prefix(),
	964	Command: irc.RPL_WHOISUSER,
	965	Params: []string{dc.nick, nick, username, host, "*", realname},
	966	})
	967	})
	968	case irc.RPL_WHOISSERVER:
	969	var nick, server, serverInfo string
	970	if err := parseMessageParams(msg, nil, &nick, &server, &serverInfo); err != nil {
	971	return err
	972	}
	973
[161]	974	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	975	nick := dc.marshalNick(uc, nick)
	976	dc.SendMessage(&irc.Message{
	977	Prefix: dc.srv.prefix(),
	978	Command: irc.RPL_WHOISSERVER,
	979	Params: []string{dc.nick, nick, server, serverInfo},
	980	})
	981	})
	982	case irc.RPL_WHOISOPERATOR:
	983	var nick string
	984	if err := parseMessageParams(msg, nil, &nick); err != nil {
	985	return err
	986	}
	987
[161]	988	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	989	nick := dc.marshalNick(uc, nick)
	990	dc.SendMessage(&irc.Message{
	991	Prefix: dc.srv.prefix(),
	992	Command: irc.RPL_WHOISOPERATOR,
	993	Params: []string{dc.nick, nick, "is an IRC operator"},
	994	})
	995	})
	996	case irc.RPL_WHOISIDLE:
	997	var nick string
	998	if err := parseMessageParams(msg, nil, &nick, nil); err != nil {
	999	return err
	1000	}
	1001
[161]	1002	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1003	nick := dc.marshalNick(uc, nick)
	1004	params := []string{dc.nick, nick}
	1005	params = append(params, msg.Params[2:]...)
	1006	dc.SendMessage(&irc.Message{
	1007	Prefix: dc.srv.prefix(),
	1008	Command: irc.RPL_WHOISIDLE,
	1009	Params: params,
	1010	})
	1011	})
	1012	case irc.RPL_WHOISCHANNELS:
	1013	var nick, channelList string
	1014	if err := parseMessageParams(msg, nil, &nick, &channelList); err != nil {
	1015	return err
	1016	}
[174]	1017	channels := splitSpace(channelList)
[128]	1018
[161]	1019	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1020	nick := dc.marshalNick(uc, nick)
	1021	channelList := make([]string, len(channels))
	1022	for i, channel := range channels {
[139]	1023	prefix, channel := uc.parseMembershipPrefix(channel)
[128]	1024	channel = dc.marshalChannel(uc, channel)
	1025	channelList[i] = prefix.String() + channel
	1026	}
	1027	channels := strings.Join(channelList, " ")
	1028	dc.SendMessage(&irc.Message{
	1029	Prefix: dc.srv.prefix(),
	1030	Command: irc.RPL_WHOISCHANNELS,
	1031	Params: []string{dc.nick, nick, channels},
	1032	})
	1033	})
	1034	case irc.RPL_ENDOFWHOIS:
	1035	var nick string
	1036	if err := parseMessageParams(msg, nil, &nick); err != nil {
	1037	return err
	1038	}
	1039
[161]	1040	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
[128]	1041	nick := dc.marshalNick(uc, nick)
	1042	dc.SendMessage(&irc.Message{
	1043	Prefix: dc.srv.prefix(),
	1044	Command: irc.RPL_ENDOFWHOIS,
[142]	1045	Params: []string{dc.nick, nick, "End of /WHOIS list"},
[128]	1046	})
	1047	})
[36]	1048	case "PRIVMSG":
[117]	1049	if msg.Prefix == nil {
	1050	return fmt.Errorf("expected a prefix")
	1051	}
	1052
[217]	1053	var entity, text string
	1054	if err := parseMessageParams(msg, &entity, &text); err != nil {
[69]	1055	return err
	1056	}
[117]	1057
	1058	if msg.Prefix.Name == serviceNick {
	1059	uc.logger.Printf("skipping PRIVMSG from soju's service: %v", msg)
	1060	break
	1061	}
[217]	1062	if entity == serviceNick {
[117]	1063	uc.logger.Printf("skipping PRIVMSG to soju's service: %v", msg)
	1064	break
	1065	}
	1066
[217]	1067	target := entity
	1068	if target == uc.nick {
[178]	1069	target = msg.Prefix.Name
	1070	}
[239]	1071	uc.produce(target, msg, nil)
[115]	1072	case "INVITE":
	1073	var nick string
	1074	var channel string
	1075	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1076	return err
	1077	}
	1078
	1079	uc.forEachDownstream(func(dc *downstreamConn) {
	1080	dc.SendMessage(&irc.Message{
	1081	Prefix: dc.marshalUserPrefix(uc, msg.Prefix),
	1082	Command: "INVITE",
	1083	Params: []string{dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	1084	})
	1085	})
[163]	1086	case irc.RPL_INVITING:
	1087	var nick string
	1088	var channel string
	1089	if err := parseMessageParams(msg, &nick, &channel); err != nil {
	1090	return err
	1091	}
	1092
	1093	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1094	dc.SendMessage(&irc.Message{
	1095	Prefix: dc.srv.prefix(),
	1096	Command: irc.RPL_INVITING,
	1097	Params: []string{dc.nick, dc.marshalNick(uc, nick), dc.marshalChannel(uc, channel)},
	1098	})
	1099	})
[177]	1100	case irc.ERR_UNKNOWNCOMMAND, irc.RPL_TRYAGAIN:
	1101	var command, reason string
	1102	if err := parseMessageParams(msg, nil, &command, &reason); err != nil {
	1103	return err
	1104	}
	1105
	1106	if command == "LIST" {
[181]	1107	ok := uc.endPendingLISTs(false)
[177]	1108	if !ok {
	1109	return fmt.Errorf("unexpected response for LIST: %q: no matching pending LIST", msg.Command)
	1110	}
	1111	uc.forEachDownstreamByID(downstreamID, func(dc *downstreamConn) {
	1112	dc.SendMessage(&irc.Message{
	1113	Prefix: uc.srv.prefix(),
	1114	Command: msg.Command,
	1115	Params: []string{dc.nick, "LIST", reason},
	1116	})
	1117	})
	1118	}
[152]	1119	case "TAGMSG":
	1120	// TODO: relay to downstream connections that accept message-tags
[155]	1121	case "ACK":
	1122	// Ignore
[198]	1123	case irc.RPL_NOWAWAY, irc.RPL_UNAWAY:
	1124	// Ignore
[16]	1125	case irc.RPL_YOURHOST, irc.RPL_CREATED:
[14]	1126	// Ignore
	1127	case irc.RPL_LUSERCLIENT, irc.RPL_LUSEROP, irc.RPL_LUSERUNKNOWN, irc.RPL_LUSERCHANNELS, irc.RPL_LUSERME:
	1128	// Ignore
	1129	case irc.RPL_MOTDSTART, irc.RPL_MOTD, irc.RPL_ENDOFMOTD:
	1130	// Ignore
[177]	1131	case irc.RPL_LISTSTART:
	1132	// Ignore
[14]	1133	case rpl_localusers, rpl_globalusers:
	1134	// Ignore
[96]	1135	case irc.RPL_STATSVLINE, rpl_statsping, irc.RPL_STATSBLINE, irc.RPL_STATSDLINE:
[14]	1136	// Ignore
[13]	1137	default:
[95]	1138	uc.logger.Printf("unhandled message: %v", msg)
[13]	1139	}
[14]	1140	return nil
[13]	1141	}
	1142
[174]	1143	func splitSpace(s string) []string {
	1144	return strings.FieldsFunc(s, func(r rune) bool {
	1145	return r == ' '
	1146	})
	1147	}
	1148
[55]	1149	func (uc *upstreamConn) register() {
[77]	1150	uc.nick = uc.network.Nick
	1151	uc.username = uc.network.Username
	1152	if uc.username == "" {
	1153	uc.username = uc.nick
	1154	}
	1155	uc.realname = uc.network.Realname
	1156	if uc.realname == "" {
	1157	uc.realname = uc.nick
	1158	}
	1159
[60]	1160	uc.SendMessage(&irc.Message{
[92]	1161	Command: "CAP",
	1162	Params: []string{"LS", "302"},
	1163	})
	1164
[93]	1165	if uc.network.Pass != "" {
	1166	uc.SendMessage(&irc.Message{
	1167	Command: "PASS",
	1168	Params: []string{uc.network.Pass},
	1169	})
	1170	}
	1171
[92]	1172	uc.SendMessage(&irc.Message{
[13]	1173	Command: "NICK",
[69]	1174	Params: []string{uc.nick},
[60]	1175	})
	1176	uc.SendMessage(&irc.Message{
[13]	1177	Command: "USER",
[77]	1178	Params: []string{uc.username, "0", "*", uc.realname},
[60]	1179	})
[44]	1180	}
[13]	1181
[197]	1182	func (uc *upstreamConn) runUntilRegistered() error {
	1183	for !uc.registered {
[212]	1184	msg, err := uc.ReadMessage()
[197]	1185	if err != nil {
	1186	return fmt.Errorf("failed to read message: %v", err)
	1187	}
	1188
	1189	if err := uc.handleMessage(msg); err != nil {
	1190	return fmt.Errorf("failed to handle message %q: %v", msg, err)
	1191	}
	1192	}
	1193
	1194	return nil
	1195	}
	1196
[95]	1197	func (uc *upstreamConn) requestSASL() bool {
	1198	if uc.network.SASL.Mechanism == "" {
	1199	return false
	1200	}
	1201
	1202	v, ok := uc.caps["sasl"]
	1203	if !ok {
	1204	return false
	1205	}
	1206	if v != "" {
	1207	mechanisms := strings.Split(v, ",")
	1208	found := false
	1209	for _, mech := range mechanisms {
	1210	if strings.EqualFold(mech, uc.network.SASL.Mechanism) {
	1211	found = true
	1212	break
	1213	}
	1214	}
	1215	if !found {
	1216	return false
	1217	}
	1218	}
	1219
	1220	return true
	1221	}
	1222
	1223	func (uc *upstreamConn) handleCapAck(name string, ok bool) error {
	1224	auth := &uc.network.SASL
	1225	switch name {
	1226	case "sasl":
	1227	if !ok {
	1228	uc.logger.Printf("server refused to acknowledge the SASL capability")
	1229	return nil
	1230	}
	1231
	1232	switch auth.Mechanism {
	1233	case "PLAIN":
	1234	uc.logger.Printf("starting SASL PLAIN authentication with username %q", auth.Plain.Username)
	1235	uc.saslClient = sasl.NewPlainClient("", auth.Plain.Username, auth.Plain.Password)
	1236	default:
	1237	return fmt.Errorf("unsupported SASL mechanism %q", name)
	1238	}
	1239
	1240	uc.SendMessage(&irc.Message{
	1241	Command: "AUTHENTICATE",
	1242	Params: []string{auth.Mechanism},
	1243	})
[152]	1244	case "message-tags":
	1245	uc.tagsSupported = ok
[155]	1246	case "labeled-response":
	1247	uc.labelsSupported = ok
[193]	1248	case "batch", "server-time":
	1249	// Nothing to do
	1250	default:
	1251	uc.logger.Printf("received CAP ACK/NAK for a cap we don't support: %v", name)
[95]	1252	}
	1253	return nil
	1254	}
	1255
[165]	1256	func (uc *upstreamConn) readMessages(ch chan<- event) error {
[13]	1257	for {
[210]	1258	msg, err := uc.ReadMessage()
[13]	1259	if err == io.EOF {
	1260	break
	1261	} else if err != nil {
	1262	return fmt.Errorf("failed to read IRC command: %v", err)
	1263	}
	1264
[165]	1265	ch <- eventUpstreamMessage{msg, uc}
[13]	1266	}
	1267
[45]	1268	return nil
[13]	1269	}
[60]	1270
[176]	1271	func (uc upstreamConn) SendMessageLabeled(downstreamID uint64, msg irc.Message) {
[155]	1272	if uc.labelsSupported {
	1273	if msg.Tags == nil {
	1274	msg.Tags = make(map[string]irc.TagValue)
	1275	}
[176]	1276	msg.Tags["label"] = irc.TagValue(fmt.Sprintf("sd-%d-%d", downstreamID, uc.nextLabelID))
[161]	1277	uc.nextLabelID++
[155]	1278	}
	1279	uc.SendMessage(msg)
	1280	}
[178]	1281
	1282	// TODO: handle moving logs when a network name changes, when support for this is added
[215]	1283	func (uc upstreamConn) appendLog(entity string, msg irc.Message) {
[178]	1284	if uc.srv.LogPath == "" {
	1285	return
	1286	}
[215]	1287
	1288	ml, ok := uc.messageLoggers[entity]
	1289	if !ok {
	1290	ml = newMessageLogger(uc, entity)
	1291	uc.messageLoggers[entity] = ml
[178]	1292	}
	1293
[215]	1294	if err := ml.Append(msg); err != nil {
	1295	uc.logger.Printf("failed to log message: %v", err)
[178]	1296	}
	1297	}
[198]	1298
[245]	1299	// produce appends a message to the logs, adds it to the history and forwards
	1300	// it to connected downstream connections.
	1301	//
	1302	// If origin is not nil and origin doesn't support echo-message, the message is
	1303	// forwarded to all connections except origin.
[239]	1304	func (uc upstreamConn) produce(target string, msg irc.Message, origin *downstreamConn) {
	1305	if target != "" {
	1306	uc.appendLog(target, msg)
	1307	}
	1308
[226]	1309	uc.network.ring.Produce(msg)
[227]	1310
	1311	uc.forEachDownstream(func(dc *downstreamConn) {
[238]	1312	if dc != origin \|\| dc.caps["echo-message"] {
[245]	1313	dc.SendMessage(dc.marshalMessage(msg, uc))
[238]	1314	}
[227]	1315	})
[226]	1316	}
	1317
[198]	1318	func (uc *upstreamConn) updateAway() {
	1319	away := true
	1320	uc.forEachDownstream(func(*downstreamConn) {
	1321	away = false
	1322	})
	1323	if away == uc.away {
	1324	return
	1325	}
	1326	if away {
	1327	uc.SendMessage(&irc.Message{
	1328	Command: "AWAY",
	1329	Params: []string{"Auto away"},
	1330	})
	1331	} else {
	1332	uc.SendMessage(&irc.Message{
	1333	Command: "AWAY",
	1334	})
	1335	}
	1336	uc.away = away
	1337	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: