Changeset 55 in code for trunk/downstream.go


Ignore:
Timestamp:
Feb 17, 2020, 11:36:42 AM (5 years ago)
Author:
contact
Message:

Abbreviate {upstream,downstream}Conn with uc and dc

This makes it clearer than just c when we manipulate both kinds at the
same time.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/downstream.go

    r54 r55  
    5757func newDownstreamConn(srv *Server, netConn net.Conn) *downstreamConn {
    5858        msgs := make(chan *irc.Message, 64)
    59         conn := &downstreamConn{
     59        dc := &downstreamConn{
    6060                net:      netConn,
    6161                irc:      irc.NewConn(netConn),
    … …  
    6767        go func() {
    6868                for msg := range msgs {
    69                         if err := conn.irc.WriteMessage(msg); err != nil {
    70                                 conn.logger.Printf("failed to write message: %v", err)
    71                         }
    72                 }
    73                 if err := conn.net.Close(); err != nil {
    74                         conn.logger.Printf("failed to close connection: %v", err)
     69                        if err := dc.irc.WriteMessage(msg); err != nil {
     70                                dc.logger.Printf("failed to write message: %v", err)
     71                        }
     72                }
     73                if err := dc.net.Close(); err != nil {
     74                        dc.logger.Printf("failed to close connection: %v", err)
    7575                } else {
    76                         conn.logger.Printf("connection closed")
     76                        dc.logger.Printf("connection closed")
    7777                }
    7878        }()
    7979
    80         return conn
    81 }
    82 
    83 func (c *downstreamConn) prefix() *irc.Prefix {
     80        return dc
     81}
     82
     83func (dc *downstreamConn) prefix() *irc.Prefix {
    8484        return &irc.Prefix{
    85                 Name: c.nick,
    86                 User: c.username,
     85                Name: dc.nick,
     86                User: dc.username,
    8787                // TODO: fill the host?
    8888        }
    8989}
    9090
    91 func (c *downstreamConn) readMessages() error {
    92         c.logger.Printf("new connection")
     91func (dc *downstreamConn) readMessages() error {
     92        dc.logger.Printf("new connection")
    9393
    9494        for {
    95                 msg, err := c.irc.ReadMessage()
     95                msg, err := dc.irc.ReadMessage()
    9696                if err == io.EOF {
    9797                        break
    … …  
    100100                }
    101101
    102                 err = c.handleMessage(msg)
     102                err = dc.handleMessage(msg)
    103103                if ircErr, ok := err.(ircError); ok {
    104                         ircErr.Message.Prefix = c.srv.prefix()
    105                         c.SendMessage(ircErr.Message)
     104                        ircErr.Message.Prefix = dc.srv.prefix()
     105                        dc.SendMessage(ircErr.Message)
    106106                } else if err != nil {
    107107                        return fmt.Errorf("failed to handle IRC command %q: %v", msg.Command, err)
    108108                }
    109109
    110                 if c.closed {
     110                if dc.closed {
    111111                        return nil
    112112                }
    … …  
    116116}
    117117
    118 func (c *downstreamConn) Close() error {
    119         if c.closed {
     118func (dc *downstreamConn) Close() error {
     119        if dc.closed {
    120120                return fmt.Errorf("downstream connection already closed")
    121121        }
    122122
    123         if u := c.user; u != nil {
     123        if u := dc.user; u != nil {
    124124                u.lock.Lock()
    125125                for i := range u.downstreamConns {
    126                         if u.downstreamConns[i] == c {
     126                        if u.downstreamConns[i] == dc {
    127127                                u.downstreamConns = append(u.downstreamConns[:i], u.downstreamConns[i+1:]...)
    128128                        }
    … …  
    137137        }
    138138
    139         close(c.messages)
    140         c.closed = true
    141 
    142         return nil
    143 }
    144 
    145 func (c *downstreamConn) SendMessage(msg *irc.Message) {
    146         c.messages <- msg
    147 }
    148 
    149 func (c *downstreamConn) handleMessage(msg *irc.Message) error {
     139        close(dc.messages)
     140        dc.closed = true
     141
     142        return nil
     143}
     144
     145func (dc *downstreamConn) SendMessage(msg *irc.Message) {
     146        dc.messages <- msg
     147}
     148
     149func (dc *downstreamConn) handleMessage(msg *irc.Message) error {
    150150        switch msg.Command {
    151151        case "QUIT":
    152                 return c.Close()
     152                return dc.Close()
    153153        case "PING":
    154154                // TODO: handle params
    155                 c.SendMessage(&irc.Message{
    156                         Prefix:  c.srv.prefix(),
     155                dc.SendMessage(&irc.Message{
     156                        Prefix:  dc.srv.prefix(),
    157157                        Command: "PONG",
    158                         Params:  []string{c.srv.Hostname},
     158                        Params:  []string{dc.srv.Hostname},
    159159                })
    160160                return nil
    161161        default:
    162                 if c.registered {
    163                         return c.handleMessageRegistered(msg)
     162                if dc.registered {
     163                        return dc.handleMessageRegistered(msg)
    164164                } else {
    165                         return c.handleMessageUnregistered(msg)
    166                 }
    167         }
    168 }
    169 
    170 func (c *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
     165                        return dc.handleMessageUnregistered(msg)
     166                }
     167        }
     168}
     169
     170func (dc *downstreamConn) handleMessageUnregistered(msg *irc.Message) error {
    171171        switch msg.Command {
    172172        case "NICK":
    173                 if err := parseMessageParams(msg, &c.nick); err != nil {
     173                if err := parseMessageParams(msg, &dc.nick); err != nil {
    174174                        return err
    175175                }
    176176        case "USER":
    177177                var username string
    178                 if err := parseMessageParams(msg, &username, nil, nil, &c.realname); err != nil {
    179                         return err
    180                 }
    181                 c.username = "~" + username
     178                if err := parseMessageParams(msg, &username, nil, nil, &dc.realname); err != nil {
     179                        return err
     180                }
     181                dc.username = "~" + username
    182182        default:
    183                 c.logger.Printf("unhandled message: %v", msg)
     183                dc.logger.Printf("unhandled message: %v", msg)
    184184                return newUnknownCommandError(msg.Command)
    185185        }
    186         if c.username != "" && c.nick != "" {
    187                 return c.register()
    188         }
    189         return nil
    190 }
    191 
    192 func (c *downstreamConn) register() error {
    193         u := c.srv.getUser(strings.TrimPrefix(c.username, "~"))
     186        if dc.username != "" && dc.nick != "" {
     187                return dc.register()
     188        }
     189        return nil
     190}
     191
     192func (dc *downstreamConn) register() error {
     193        u := dc.srv.getUser(strings.TrimPrefix(dc.username, "~"))
    194194        if u == nil {
    195                 c.logger.Printf("failed authentication: unknown username %q", c.username)
    196                 c.SendMessage(&irc.Message{
    197                         Prefix:  c.srv.prefix(),
     195                dc.logger.Printf("failed authentication: unknown username %q", dc.username)
     196                dc.SendMessage(&irc.Message{
     197                        Prefix:  dc.srv.prefix(),
    198198                        Command: irc.ERR_PASSWDMISMATCH,
    199199                        Params:  []string{"*", "Invalid username or password"},
    … …  
    202202        }
    203203
    204         c.registered = true
    205         c.user = u
     204        dc.registered = true
     205        dc.user = u
    206206
    207207        u.lock.Lock()
    208         u.downstreamConns = append(u.downstreamConns, c)
     208        u.downstreamConns = append(u.downstreamConns, dc)
    209209        u.lock.Unlock()
    210210
    211         c.SendMessage(&irc.Message{
    212                 Prefix:  c.srv.prefix(),
     211        dc.SendMessage(&irc.Message{
     212                Prefix:  dc.srv.prefix(),
    213213                Command: irc.RPL_WELCOME,
    214                 Params:  []string{c.nick, "Welcome to jounce, " + c.nick},
    215         })
    216         c.SendMessage(&irc.Message{
    217                 Prefix:  c.srv.prefix(),
     214                Params:  []string{dc.nick, "Welcome to jounce, " + dc.nick},
     215        })
     216        dc.SendMessage(&irc.Message{
     217                Prefix:  dc.srv.prefix(),
    218218                Command: irc.RPL_YOURHOST,
    219                 Params:  []string{c.nick, "Your host is " + c.srv.Hostname},
    220         })
    221         c.SendMessage(&irc.Message{
    222                 Prefix:  c.srv.prefix(),
     219                Params:  []string{dc.nick, "Your host is " + dc.srv.Hostname},
     220        })
     221        dc.SendMessage(&irc.Message{
     222                Prefix:  dc.srv.prefix(),
    223223                Command: irc.RPL_CREATED,
    224                 Params:  []string{c.nick, "Who cares when the server was created?"},
    225         })
    226         c.SendMessage(&irc.Message{
    227                 Prefix:  c.srv.prefix(),
     224                Params:  []string{dc.nick, "Who cares when the server was created?"},
     225        })
     226        dc.SendMessage(&irc.Message{
     227                Prefix:  dc.srv.prefix(),
    228228                Command: irc.RPL_MYINFO,
    229                 Params:  []string{c.nick, c.srv.Hostname, "jounce", "aiwroO", "OovaimnqpsrtklbeI"},
    230         })
    231         c.SendMessage(&irc.Message{
    232                 Prefix:  c.srv.prefix(),
     229                Params:  []string{dc.nick, dc.srv.Hostname, "jounce", "aiwroO", "OovaimnqpsrtklbeI"},
     230        })
     231        dc.SendMessage(&irc.Message{
     232                Prefix:  dc.srv.prefix(),
    233233                Command: irc.ERR_NOMOTD,
    234                 Params:  []string{c.nick, "No MOTD"},
     234                Params:  []string{dc.nick, "No MOTD"},
    235235        })
    236236
    … …  
    239239                for _, ch := range uc.channels {
    240240                        if ch.complete {
    241                                 forwardChannel(c, ch)
     241                                forwardChannel(dc, ch)
    242242                        }
    243243                }
    … …  
    251251                                break
    252252                        }
    253                         c.SendMessage(msg)
    254                 }
    255         })
    256 
    257         return nil
    258 }
    259 
    260 func (c *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
     253                        dc.SendMessage(msg)
     254                }
     255        })
     256
     257        return nil
     258}
     259
     260func (dc *downstreamConn) handleMessageRegistered(msg *irc.Message) error {
    261261        switch msg.Command {
    262262        case "USER":
    263263                return ircError{&irc.Message{
    264264                        Command: irc.ERR_ALREADYREGISTERED,
    265                         Params:  []string{c.nick, "You may not reregister"},
     265                        Params:  []string{dc.nick, "You may not reregister"},
    266266                }}
    267267        case "NICK":
    268                 c.user.forEachUpstream(func(uc *upstreamConn) {
     268                dc.user.forEachUpstream(func(uc *upstreamConn) {
    269269                        uc.messages <- msg
    270270                })
    … …  
    275275                }
    276276
    277                 if ch, _ := c.user.getChannel(name); ch != nil {
     277                if ch, _ := dc.user.getChannel(name); ch != nil {
    278278                        break // already joined
    279279                }
    … …  
    290290                }
    291291
    292                 ch, err := c.user.getChannel(name)
     292                ch, err := dc.user.getChannel(name)
    293293                if err != nil {
    294294                        return err
    … …  
    309309
    310310                if msg.Prefix.Name != name {
    311                         ch, err := c.user.getChannel(name)
     311                        ch, err := dc.user.getChannel(name)
    312312                        if err != nil {
    313313                                return err
    … …  
    317317                                ch.conn.messages <- msg
    318318                        } else {
    319                                 c.SendMessage(&irc.Message{
    320                                         Prefix:  c.srv.prefix(),
     319                                dc.SendMessage(&irc.Message{
     320                                        Prefix:  dc.srv.prefix(),
    321321                                        Command: irc.RPL_CHANNELMODEIS,
    322322                                        Params:  []string{ch.Name, string(ch.modes)},
    … …  
    324324                        }
    325325                } else {
    326                         if name != c.nick {
     326                        if name != dc.nick {
    327327                                return ircError{&irc.Message{
    328328                                        Command: irc.ERR_USERSDONTMATCH,
    329                                         Params:  []string{c.nick, "Cannot change mode for other users"},
     329                                        Params:  []string{dc.nick, "Cannot change mode for other users"},
    330330                                }}
    331331                        }
    332332
    333333                        if modeStr != "" {
    334                                 c.user.forEachUpstream(func(uc *upstreamConn) {
     334                                dc.user.forEachUpstream(func(uc *upstreamConn) {
    335335                                        uc.messages <- msg
    336336                                })
    337337                        } else {
    338                                 c.SendMessage(&irc.Message{
    339                                         Prefix:  c.srv.prefix(),
     338                                dc.SendMessage(&irc.Message{
     339                                        Prefix:  dc.srv.prefix(),
    340340                                        Command: irc.RPL_UMODEIS,
    341341                                        Params:  []string{""}, // TODO
    … …  
    344344                }
    345345        default:
    346                 c.logger.Printf("unhandled message: %v", msg)
     346                dc.logger.Printf("unhandled message: %v", msg)
    347347                return newUnknownCommandError(msg.Command)
    348348        }
Note: See TracChangeset for help on using the changeset viewer.