Changeset 55 in code


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.

Location:
trunk
Files:
2 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        }

  • trunk/upstream.go

    r54 r55  
    5757
    5858        msgs := make(chan *irc.Message, 64)
    59         conn := &upstreamConn{
     59        uc := &upstreamConn{
    6060                upstream: upstream,
    6161                logger:   logger,
    … …  
    7171        go func() {
    7272                for msg := range msgs {
    73                         if err := conn.irc.WriteMessage(msg); err != nil {
    74                                 conn.logger.Printf("failed to write message: %v", err)
    75                         }
    76                 }
    77                 if err := conn.net.Close(); err != nil {
    78                         conn.logger.Printf("failed to close connection: %v", err)
     73                        if err := uc.irc.WriteMessage(msg); err != nil {
     74                                uc.logger.Printf("failed to write message: %v", err)
     75                        }
     76                }
     77                if err := uc.net.Close(); err != nil {
     78                        uc.logger.Printf("failed to close connection: %v", err)
    7979                } else {
    80                         conn.logger.Printf("connection closed")
     80                        uc.logger.Printf("connection closed")
    8181                }
    8282        }()
    8383
    84         return conn, nil
    85 }
    86 
    87 func (c *upstreamConn) Close() error {
    88         if c.closed {
     84        return uc, nil
     85}
     86
     87func (uc *upstreamConn) Close() error {
     88        if uc.closed {
    8989                return fmt.Errorf("upstream connection already closed")
    9090        }
    91         close(c.messages)
    92         c.closed = true
     91        close(uc.messages)
     92        uc.closed = true
    9393        return nil
    9494}
    9595
    96 func (c *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
    97         ch, ok := c.channels[name]
     96func (uc *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
     97        ch, ok := uc.channels[name]
    9898        if !ok {
    9999                return nil, fmt.Errorf("unknown channel %q", name)
    … …  
    102102}
    103103
    104 func (c *upstreamConn) handleMessage(msg *irc.Message) error {
     104func (uc *upstreamConn) handleMessage(msg *irc.Message) error {
    105105        switch msg.Command {
    106106        case "PING":
    107107                // TODO: handle params
    108                 c.messages <- &irc.Message{
     108                uc.messages <- &irc.Message{
    109109                        Command: "PONG",
    110                         Params:  []string{c.srv.Hostname},
     110                        Params:  []string{uc.srv.Hostname},
    111111                }
    112112                return nil
    … …  
    118118
    119119                if name == msg.Prefix.Name { // user mode change
    120                         if name != c.nick {
     120                        if name != uc.nick {
    121121                                return fmt.Errorf("received MODE message for unknow nick %q", name)
    122122                        }
    123                         return c.modes.Apply(modeStr)
     123                        return uc.modes.Apply(modeStr)
    124124                } else { // channel mode change
    125                         ch, err := c.getChannel(name)
     125                        ch, err := uc.getChannel(name)
    126126                        if err != nil {
    127127                                return err
    … …  
    132132                }
    133133
    134                 c.user.forEachDownstream(func(dc *downstreamConn) {
     134                uc.user.forEachDownstream(func(dc *downstreamConn) {
    135135                        dc.SendMessage(msg)
    136136                })
    137137        case "NOTICE":
    138                 c.logger.Print(msg)
     138                uc.logger.Print(msg)
    139139        case irc.RPL_WELCOME:
    140                 c.registered = true
    141                 c.logger.Printf("connection registered")
    142 
    143                 for _, ch := range c.upstream.Channels {
    144                         c.messages <- &irc.Message{
     140                uc.registered = true
     141                uc.logger.Printf("connection registered")
     142
     143                for _, ch := range uc.upstream.Channels {
     144                        uc.messages <- &irc.Message{
    145145                                Command: "JOIN",
    146146                                Params:  []string{ch},
    … …  
    148148                }
    149149        case irc.RPL_MYINFO:
    150                 if err := parseMessageParams(msg, nil, &c.serverName, nil, &c.availableUserModes, &c.availableChannelModes); err != nil {
     150                if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, &uc.availableChannelModes); err != nil {
    151151                        return err
    152152                }
    153153                if len(msg.Params) > 5 {
    154                         c.channelModesWithParam = msg.Params[5]
     154                        uc.channelModesWithParam = msg.Params[5]
    155155                }
    156156        case "NICK":
    … …  
    160160                }
    161161
    162                 if msg.Prefix.Name == c.nick {
    163                         c.logger.Printf("changed nick from %q to %q", c.nick, newNick)
    164                         c.nick = newNick
    165                 }
    166 
    167                 for _, ch := range c.channels {
     162                if msg.Prefix.Name == uc.nick {
     163                        uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
     164                        uc.nick = newNick
     165                }
     166
     167                for _, ch := range uc.channels {
    168168                        if membership, ok := ch.Members[msg.Prefix.Name]; ok {
    169169                                delete(ch.Members, msg.Prefix.Name)
    … …  
    172172                }
    173173
    174                 c.user.forEachDownstream(func(dc *downstreamConn) {
     174                uc.user.forEachDownstream(func(dc *downstreamConn) {
    175175                        dc.SendMessage(msg)
    176176                })
    … …  
    182182
    183183                for _, ch := range strings.Split(channels, ",") {
    184                         if msg.Prefix.Name == c.nick {
    185                                 c.logger.Printf("joined channel %q", ch)
    186                                 c.channels[ch] = &upstreamChannel{
     184                        if msg.Prefix.Name == uc.nick {
     185                                uc.logger.Printf("joined channel %q", ch)
     186                                uc.channels[ch] = &upstreamChannel{
    187187                                        Name:    ch,
    188                                         conn:    c,
     188                                        conn:    uc,
    189189                                        Members: make(map[string]membership),
    190190                                }
    191191                        } else {
    192                                 ch, err := c.getChannel(ch)
     192                                ch, err := uc.getChannel(ch)
    193193                                if err != nil {
    194194                                        return err
    … …  
    198198                }
    199199
    200                 c.user.forEachDownstream(func(dc *downstreamConn) {
     200                uc.user.forEachDownstream(func(dc *downstreamConn) {
    201201                        dc.SendMessage(msg)
    202202                })
    … …  
    208208
    209209                for _, ch := range strings.Split(channels, ",") {
    210                         if msg.Prefix.Name == c.nick {
    211                                 c.logger.Printf("parted channel %q", ch)
    212                                 delete(c.channels, ch)
     210                        if msg.Prefix.Name == uc.nick {
     211                                uc.logger.Printf("parted channel %q", ch)
     212                                delete(uc.channels, ch)
    213213                        } else {
    214                                 ch, err := c.getChannel(ch)
     214                                ch, err := uc.getChannel(ch)
    215215                                if err != nil {
    216216                                        return err
    … …  
    220220                }
    221221
    222                 c.user.forEachDownstream(func(dc *downstreamConn) {
     222                uc.user.forEachDownstream(func(dc *downstreamConn) {
    223223                        dc.SendMessage(msg)
    224224                })
    … …  
    228228                        return err
    229229                }
    230                 ch, err := c.getChannel(name)
     230                ch, err := uc.getChannel(name)
    231231                if err != nil {
    232232                        return err
    … …  
    242242                        return err
    243243                }
    244                 ch, err := c.getChannel(name)
     244                ch, err := uc.getChannel(name)
    245245                if err != nil {
    246246                        return err
    … …  
    256256                        return err
    257257                }
    258                 ch, err := c.getChannel(name)
     258                ch, err := uc.getChannel(name)
    259259                if err != nil {
    260260                        return err
    … …  
    271271                        return err
    272272                }
    273                 ch, err := c.getChannel(name)
     273                ch, err := uc.getChannel(name)
    274274                if err != nil {
    275275                        return err
    … …  
    291291                        return err
    292292                }
    293                 ch, err := c.getChannel(name)
     293                ch, err := uc.getChannel(name)
    294294                if err != nil {
    295295                        return err
    … …  
    301301                ch.complete = true
    302302
    303                 c.user.forEachDownstream(func(dc *downstreamConn) {
     303                uc.user.forEachDownstream(func(dc *downstreamConn) {
    304304                        forwardChannel(dc, ch)
    305305                })
    306306        case "PRIVMSG":
    307                 c.ring.Produce(msg)
    308                 c.user.forEachDownstream(func(dc *downstreamConn) {
     307                uc.ring.Produce(msg)
     308                uc.user.forEachDownstream(func(dc *downstreamConn) {
    309309                        dc.SendMessage(msg)
    310310                })
    … …  
    320320                // Ignore
    321321        default:
    322                 c.logger.Printf("unhandled upstream message: %v", msg)
     322                uc.logger.Printf("unhandled upstream message: %v", msg)
    323323        }
    324324        return nil
    325325}
    326326
    327 func (c *upstreamConn) register() {
    328         c.nick = c.upstream.Nick
    329         c.messages <- &irc.Message{
     327func (uc *upstreamConn) register() {
     328        uc.nick = uc.upstream.Nick
     329        uc.messages <- &irc.Message{
    330330                Command: "NICK",
    331                 Params:  []string{c.upstream.Nick},
    332         }
    333         c.messages <- &irc.Message{
     331                Params:  []string{uc.upstream.Nick},
     332        }
     333        uc.messages <- &irc.Message{
    334334                Command: "USER",
    335                 Params:  []string{c.upstream.Username, "0", "*", c.upstream.Realname},
    336         }
    337 }
    338 
    339 func (c *upstreamConn) readMessages() error {
     335                Params:  []string{uc.upstream.Username, "0", "*", uc.upstream.Realname},
     336        }
     337}
     338
     339func (uc *upstreamConn) readMessages() error {
    340340        for {
    341                 msg, err := c.irc.ReadMessage()
     341                msg, err := uc.irc.ReadMessage()
    342342                if err == io.EOF {
    343343                        break
    … …  
    346346                }
    347347
    348                 if err := c.handleMessage(msg); err != nil {
    349                         c.logger.Printf("failed to handle message %q: %v", msg, err)
     348                if err := uc.handleMessage(msg); err != nil {
     349                        uc.logger.Printf("failed to handle message %q: %v", msg, err)
    350350                }
    351351        }
Note: See TracChangeset for help on using the changeset viewer.