ahf / ircd-novo Goto Github PK

SSL support is a must have to a modern IRC daemon.

Our current implementation allows the nickname "fooæøå" which is an invalid nickname.

Both tests and utility functions in match.go should be fixed.

The IRCd shouldn't contain any global state, since we might want to support multiple running IRCd's (for simulation purpose) in the same application, but with different handlers for each IRCd instance.

Investigate the current availability of decent configuration parser packages for Go or implement your own.

The IRCd currently only support client-to-client communication over the server. Channel support is needed.

Our IRC protocol parser needs test cases.

Client::OutputHandler()'s _, error := rw.WriteString(s + "\r\n") sometimes return EINVAL when the client is connected via a WebSocket.

We need to PING our clients every now and then, but only if they haven't talked on our input connection for N seconds.

For registered client, we should send a "PING :irc.example.org" and for unregistered clients we should simply kill them, if they haven't been promoted to a registered client within 300 seconds after the initial connect.

Crash with a NULL pointer dereference in Ircd::Run() when the address is an IPv6 address.

Once a client sends a QUIT-message, it's important that said message should be send to each client, that shares at least one channel with the quitting client, exactly once.

The algorithm for doing this, is going to be something in the line of:

q := QuittingClient
n := ClientSet // Set of client's that has already been notified.

for each channel that q is in:
for each client in channel:
if not n.Contains(client):
client.Quit(q) // Let client know that q QUIT.
n.Insert(client)

Our current connection handler is being used for both TCP and WebSocket connections, but there's one problem with the way it's implemented right now and that affects WebSocket connections. Our current implementation looks like this:

func (this *BasicListener) ConnectionHandler(ircd *Ircd, connection net.Conn, remoteAddr string) {
    this.Printf("Incoming Connection from %s to %s (%s %s)", remoteAddr, this.Address(), this.Secure(), this.Protocol())
    NewClient(this, ircd, connection, remoteAddr)
}

The problem here is that NewClient() returns to the caller as soon as we are done doing the initial registration of the user, but once ConnectionHandler() is done, the http package will terminate the WebSocket connection and therefore disconnect our client.

Other IRCd's doesn't show a channel line if the list of channels is empty.

ircd-novo should be able to fork itself into the background. Currently this is not easily done, due to Go issue 227

We need DNS blacklist support a la what BOPM does, but build into the ircd.

Currently the hostname is determent purely based on the result of the reverse DNS lookup. This is incorrect. The result of the reverse DNS lookup should be looked up using forward DNS too and verify if they match.

ip := client.ip
rdns := ReverseDNSLookup(ip)
fdns := ForwardDNSLookup(rdns)

if rdns == fdns then
    return rdns
else
    return ip

Look into jlouis' Go identd library and add support for identd check upon new connection.

Title says everything.

Currently it only supports "NICK" / "USER". It should support "QUIT" too.