ellinetircd 1.0.0__py3-none-any.whl

ellinetircd/__init__.py

@@ -0,0 +1,34 @@
+import contextvars
+import logging
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("ellinetircd")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+from ellinetircd.config import config as cfg
+logger = logging.getLogger(__package__)
+IO = logging.INFO - 5
+SECURITY = logging.ERROR + 5
+logging.addLevelName(IO, 'IO')
+logging.addLevelName(SECURITY, 'SECURITY')
+logger.setLevel(cfg.LOGLEVEL)
+servlocal = contextvars.ContextVar('servlocal')
+MAXLINELEN = 512
+
+import ellinetircd.channel
+import ellinetircd.exceptions
+import ellinetircd.server
+import ellinetircd.sdnotify
+import ellinetircd.states
+import ellinetircd.user
+
+
+def update_status() -> None:
+    sl = servlocal.get()
+    ellinetircd.sdnotify.status(
+        f"Listening on {cfg.ADDR} ({cfg.HOST}) port {cfg.PORT}. "
+        f"Currently {len(sl.users)} registered users"
+        f" in {len(sl.channels)} channels."
+    )

ellinetircd/__main__.py

@@ -0,0 +1,75 @@
+import argparse
+import logging
+import os
+import sys
+import textwrap
+import trio
+from socket import gethostname, gethostbyname
+
+import ellinetircd
+from ellinetircd.config import config as cfg
+from ellinetircd.server import Server
+
+logger = logging.getLogger(__name__)
+
+# Color the [LEVEL] part of messages, need new terminal on Windows
+# https://github.com/odoo/odoo/blob/13.0/odoo/netsvc.py#L57-L100
+class ColoredFormatter(logging.Formatter):
+    colors = {
+        logging.DEBUG: (34, 49),  # blue
+        ellinetircd.IO: (37, 49),  # white
+        logging.INFO: (32, 49),  # green
+        logging.WARNING: (33, 49),  # yellow
+        logging.ERROR: (31, 49),  # red
+        ellinetircd.SECURITY: (31, 49),  # red
+        logging.CRITICAL: (37, 41),  # white fg, red bg
+    }
+    def format(self, record: logging.LogRecord) -> str:
+        fg, bg = type(self).colors.get(record.levelno, (32, 49))
+        record.levelname = f'\033[1;{fg}m\033[1;{bg}m{record.levelname}\033[0m'
+        return super().format(record)
+
+def main() -> None:
+    stderr = logging.StreamHandler()
+    stderr.formatter = (
+        ColoredFormatter('%(asctime)s [%(levelname)s] %(message)s')
+        if hasattr(sys.stderr, 'fileno') and os.isatty(sys.stderr.fileno()) else
+        logging.Formatter('[%(levelname)s] %(message)s')
+    )
+    root_logger = logging.getLogger('')
+    root_logger.handlers.clear()
+    root_logger.addHandler(stderr)
+
+    server = Server(cfg.HOST, cfg.ADDR, cfg.PORT, cfg.PASS)
+    try:
+        trio.run(server.serve)
+    except Exception:
+        logger.critical("Dead", exc_info=True)
+    finally:
+        logging.shutdown()
+
+# Dummy argparse, used only for --help and --version
+parser = argparse.ArgumentParser(
+    prog=ellinetircd.__name__,
+    usage=f"{sys.executable} -m {ellinetircd.__name__}",
+    description="single-server minimalist IRC",
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    epilog=textwrap.dedent(f"""\
+        environment variables:
+          HOST           public domain name (default: {gethostname()})
+          ADDR           ip address to bind (default: {gethostbyname(cfg.HOST)})
+          PORT           port to bind (default: 6667)
+          PASS           server password (default: )
+          TIMEOUT        kick inactive users after x seconds (default: 60)
+          PING_TIMEOUT   PING inactive users x seconds before timeout (default: 5)
+          LOGLEVEL       logging verbosity (default: WARNING)
+    """)
+)
+parser.add_argument(
+    '-V', '--version',
+    action='version',
+    version=f'{ellinetircd.__name__} {ellinetircd.__version__}',
+)
+parser.parse_args()
+
+main()

ellinetircd/channel.py

@@ -0,0 +1,85 @@
+import logging
+import trio
+from functools import partial
+from typing import List, Set, Union
+
+import ellinetircd
+
+
+logger = logging.getLogger(__name__)
+
+
+class Channel:
+    """
+    The Channel class represents a chat room.
+
+    Attributes:
+        name: str
+            the channel name.
+        users: Set[User]
+            a set of user who is subscribe to the channel.
+    """
+
+    def __init__(self, name: str) -> None:
+        """
+        Parameters:
+            name: str
+                the channel name.
+        """
+        self._name = name
+        self.users: Set["ellinetircd.user.User"] = set()
+
+    def __str__(self) -> str:
+        """
+        We represents the channel object by his name.
+
+        Return: str
+            the name of the channel.
+        """
+        return self._name
+
+    @property
+    def name(self) -> str:
+        """
+        Getter for private attributes channel name.
+
+        Returns: str 
+            the name of the channel.
+        """
+        return self._name
+
+    def _log_messages(self, messages: List[str]) -> None:
+        """
+        Log all messages sent to a client.
+        
+        Parameters: List[str]
+            A list of messages send to the client.
+        """
+        for message in messages:
+            logger.log(ellinetircd.IO, "send to %s: %s", self, message)
+
+    async def send(
+        self,
+        messages: Union[str, List[str]],
+        skipusers: Set["ellinetircd.user.User"] = set(),
+    ) -> None:
+        """"
+        Send many messages to each user subscribed to this channel.
+        
+        Parameters:
+            messages: Union[str, List[str]]
+                Messages to send to the users.
+            skipusers: Set[User]
+                A set of users to skip sending messages to.
+        """
+        if isinstance(messages, str):
+            messages = [messages]
+
+        async with trio.open_nursery() as self._nursery:
+            self._log_messages(messages)
+            for user in self.users.difference(skipusers):
+                self._nursery.start_soon(partial(
+                    user.send,
+                    messages,
+                    log=logger.isEnabledFor(logging.DEBUG)
+                ))

ellinetircd/config.py

@@ -0,0 +1,14 @@
+import logging
+import os
+from socket import gethostname, gethostbyname
+from types import SimpleNamespace
+
+
+config = SimpleNamespace()
+config.HOST = os.getenv('HOST', gethostname())
+config.ADDR = os.getenv('ADDR', gethostbyname(config.HOST))
+config.PORT = int(os.getenv('PORT', 6667))
+config.PASS = os.getenv('PASS')
+config.TIMEOUT = int(os.getenv('TIMEOUT', 60))
+config.PING_TIMEOUT = int(os.getenv('PING_TIMEOUT', 5))
+config.LOGLEVEL = os.getenv('LOGLEVEL', 'WARNING')

ellinetircd/exceptions.py

@@ -0,0 +1,86 @@
+__ALL__ = [
+    'Disconnect', 'IRCException', 'ErrNoSuchChannel', 'ErrNoRecipient',
+    'ErrNoTextToSend', 'ErrUnknownCommand', 'ErrNoNicknameGiven',
+    'ErrErroneusNickname', 'ErrNicknameInUse', 'ErrNotOnChannel',
+    'ErrNoLogin', 'ErrNeedMoreParams', 'ErrAlreadyRegistred',
+]
+
+import ellinetircd
+from typing import Any
+
+class Disconnect(Exception):
+    pass
+
+class IRCException(Exception):
+    """
+    Abstract IRC exception
+
+    They are excepted by dispatch() and forwarded to the user.
+    """
+    def __init__(self, *args: Any) -> None:
+        super().__init__(type(self).format(*args))
+
+    @classmethod
+    def format(cls, *args: Any) -> str:
+        return ":{host} {code} {error}".format(
+            host=ellinetircd.servlocal.get().host,
+            code=cls.code,
+            error=cls.msg.format(*args),
+        )
+
+class ErrUnknownError(IRCException):
+    # <user> <command> :<info>
+    msg = "{} {} :{}"
+    code = 400
+
+class ErrNoSuchNick(IRCException):
+    msg = "{} :No such nick/channel"
+    code = 401
+
+class ErrNoSuchChannel(IRCException):
+    msg = "{} :No such channel"
+    code = 403
+
+class ErrNoRecipient(IRCException):
+    msg = ":No recipient given ({})"
+    code = 411
+
+class ErrNoTextToSend(IRCException):
+    msg = ":No text to send"
+    code = 412
+
+class ErrUnknownCommand(IRCException):
+    msg = "{} :Unknown command"
+    code = 421
+
+class ErrNoNicknameGiven(IRCException):
+    msg = ":No nickname given"
+    code = 431
+
+class ErrErroneusNickname(IRCException):
+    msg = "{} :Erroneous nickname"
+    code = 432
+
+class ErrNicknameInUse(IRCException):
+    msg = "{} :Nickname is already in use"
+    code = 433
+
+class ErrNotOnChannel(IRCException):
+    msg = "{} :You're not on that channel"
+    code = 442
+
+class ErrNoLogin(IRCException):
+    msg = ":User not logged in"
+    code = 444
+
+class ErrNeedMoreParams(IRCException):
+    msg = "{} :Not enough parameters"
+    code = 461
+
+class ErrAlreadyRegistred(IRCException):
+    msg = ":Unauthorized command (already registered)"
+    code = 462
+
+class ErrPasswdMismatch(IRCException):
+    msg = ":Password incorrect"
+    code = 464

ellinetircd/sdnotify.py

@@ -0,0 +1,32 @@
+import socket
+import os
+
+def notify(payload: bytes) -> None:
+    if _sdsocket:
+        _sdsocket.sendall(payload)
+
+
+def ready() -> None:
+    notify(b"READY=1")
+
+
+def reloading() -> None:
+    notify(b"RELOADING=1")
+
+
+def stopping() -> None:
+    notify(b"STOPPING=1")
+
+
+def status(line: str) -> None:
+    notify(b"STATUS=" + line.encode())
+
+
+# Setup
+_sdsocket = None
+_notify_socket = os.getenv('NOTIFY_SOCKET', '')
+if _notify_socket:
+    if _notify_socket.startswith('@'):
+        _notify_socket = f'\0{_notify_socket[1:]}'
+    _sdsocket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    _sdsocket.connect(_notify_socket)

ellinetircd/server.py

@@ -0,0 +1,77 @@
+import dataclasses
+import logging
+import signal
+import trio
+from typing import Any, Dict, Optional
+
+import ellinetircd
+from ellinetircd import sdnotify
+from ellinetircd.exceptions import Disconnect
+from ellinetircd.user import User
+
+
+logger = logging.getLogger(__name__)
+
+
+class Server:
+    def __init__(self, host: str, addr: str, port: int, pwd: Optional[str]) -> None:
+        self.host = host
+        self.addr = addr
+        self.port = port
+        self.pwd = pwd
+
+    async def handle(self, stream: trio.abc.Stream) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        async with trio.open_nursery() as nursery:
+            user = User(stream, nursery)
+            logger.info("Connection with %s established.", user)
+            nursery.start_soon(user.ping_forever)
+            try:
+                await user.serve()
+            except Disconnect as exc:
+                logger.warning("Protocol violation while serving %s, %s.", user, repr(exc.__cause__ or exc))
+                await user.terminate(exc.args[0] if exc.args else "Protocol violation")
+            except Exception:
+                logger.exception("Error while serving %s.", user)
+                await user.terminate("Internal host error")
+            else:
+                await user.terminate()
+
+        logger.info("Connection with %s closed.", user)
+
+    def started(self, _listeners: Any) -> None:
+        sdnotify.ready()
+        ellinetircd.update_status()
+
+    async def _onterm(self) -> None:
+        with trio.open_signal_receiver(signal.SIGTERM, signal.SIGINT) as signal_aiter:
+            async for _ in signal_aiter:
+                if self._nursery.cancel_scope.cancel_called:
+                    raise KeyboardInterrupt()
+                sdnotify.stopping()
+                sdnotify.status("Terminating connections...")
+                self._nursery.cancel_scope.cancel()
+
+    async def serve(self) -> None:
+        ellinetircd.servlocal.set(ServLocal(self.host, self.pwd, {}, {}))
+        async with trio.open_nursery() as self._nursery:
+            self._nursery.start_soon(self._onterm)
+            logger.info("Listening on %s port %s.", self.addr, self.port)
+            await trio.serve_tcp(self.handle, self.port, host=self.addr, task_status=self)
+
+
+@dataclasses.dataclass(eq=False)
+class ServLocal:
+    host: str
+    pwd: str  # password, "pass" is a reserved keyword
+    users: Dict[str, User]
+    channels: Dict[str, "ellinetircd.channel.Channel"]
+
+    def __repr__(self) -> str:
+        return (
+            f'{self.__name__}('
+            f'host: {self.host!r}, '
+            f'pass: {"yes" if self.pwd else "no"}, '
+            f'users: {len(self.users)}, '
+            f'channels: {len(self.channels)})'
+        )

ellinetircd/states.py

@@ -0,0 +1,497 @@
+__all__ = [
+    'UserState', 'ConnectedState', 'PasswordState', 'RegisteredState',
+    'QuitState'
+]
+
+import abc
+import inspect
+import ipaddress
+import logging
+import re
+import textwrap
+import trio
+from typing import Any, Callable, Dict, List, Optional, Set, TypeVar
+
+import ellinetircd
+from ellinetircd.channel import Channel
+from ellinetircd.exceptions import *
+
+FuncType = TypeVar('FuncType', bound=Callable[..., Any])
+
+
+logger = logging.getLogger(__name__)
+nick_re = re.compile(r"[a-zA-Z][a-zA-Z0-9\-_]{1,15}")
+chan_re = re.compile(r"[&#][a-zA-Z0-9\-_]{1,49}")
+
+
+def command(func: FuncType) -> FuncType:
+    """ Denote the function can be triggered by an IRC message """
+    func.command = True
+    return func
+
+
+class UserState(metaclass=abc.ABCMeta):
+    def __init__(self, user: "ellinetircd.user.User") -> None:
+        logger.debug("state of user %s changed: %s -> %s", user, user.state, self)
+        self.user = user
+
+    def __str__(self) -> str:
+        return type(self).__name__[:-5]
+
+    async def dispatch(self, cmd: str, *params: str) -> None:
+        logger.debug('Dispatch to %s: %s', cmd, params)
+        meth = getattr(self, cmd, None)
+        if not meth or not getattr(meth, 'command', False):
+            raise ErrUnknownError(self.user, '-', f"Command {cmd} is unknown.")
+
+        sign = inspect.signature(meth)
+        try:
+            sign.bind(*params)
+        except TypeError:
+            meth_params_cnt = len(inspect.signature(meth).parameters.values())
+            if len(params) < meth_params_cnt:
+                raise ErrNeedMoreParams(cmd)
+            else:
+                raise ErrUnknownError(self.user, cmd, f"Couldn't bind {params} to {sign}.")
+
+        await meth(*params)
+
+    @command
+    async def PING(self, token: str) -> None:
+        host = ellinetircd.servlocal.get().host
+        await self.user.send(f":{host} PONG {host} {token}", log=logger.isEnabledFor(logging.DEBUG))
+
+    @command
+    async def PONG(self, token: Optional[str] = None) -> None:
+        pass  # ignored
+
+
+    @command
+    async def USER(self, username: str, _zero: str, _star: str, realname: str) -> None:
+        raise ErrUnknownError(self.user, "USER", "Called while in the wrong state.")
+
+    @command
+    async def PASS(self, password: str) -> None:
+        raise ErrUnknownError(self.user, "PASS", "Called while in the wrong state.")
+
+    @command
+    async def NICK(self, nickname: str) -> None:
+        raise ErrUnknownError(self.user, "NICK", "Called while in the wrong state.")
+    
+    @command
+    async def WHO(self, channel: str) -> None:
+        raise ErrUnknownError(self.user, "WHO", "Called while in the wrong state.")
+    
+    @command
+    async def WHOIS(self, channel: str) -> None:
+        raise ErrUnknownError(self.user, "WHOIS", "Called while in the wrong state.")
+
+    @command
+    async def JOIN(self, channels: str) -> None:
+        raise ErrUnknownError(self.user, "JOIN", "Called while in the wrong state.")
+
+    @command
+    async def PART(self, channels: str, reason: Optional[str] = None) -> None:
+        raise ErrUnknownError(self.user, "PART", "Called while in the wrong state.")
+
+    @command
+    async def NAMES(self, channel: str) -> None:
+        raise ErrUnknownError(self.user, "NAMES", "Called while in the wrong state.")
+
+    @command
+    async def LIST(self) -> None:
+        raise ErrUnknownError(self.user, "LIST", "Called while in the wrong state.")
+
+    @command
+    async def PRIVMSG(self, args: str) -> None:
+        raise ErrUnknownError(self.user, "PRIVMSG", "Called while in the wrong state.")
+    
+    @command
+    async def MODE(self, args: str) -> None:
+        raise ErrUnknownError(self.user, "MODE", "Called while in the wrong state.")
+
+    @command
+    async def QUIT(self, reason: str = "", *, kick: bool = False) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        if not kick:
+            reason = 'Quit: ' + reason
+        for chan in self.user.channels:
+            chan.users.remove(self.user)
+            await chan.send(f":{self.user.nick} QUIT :{reason}")
+            if not chan.users:
+                servlocal.channels.pop(chan.name)
+        self.user.channels.clear()
+        self.user.state = QuitState(self.user)
+
+
+class PasswordState(UserState):
+    @command
+    async def PASS(self, password: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        if password != servlocal.pwd:
+            logger.log(ellinetircd.SECURITY, "Invalid password for %s", self.user)
+            raise ErrPasswdMismatch()
+
+        self.user.state = ConnectedState(self.user)
+
+
+class ConnectedState(UserState):
+    """
+    The user is just connected, he must register via the NICK command
+    first before going on.
+    """
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.has_nick = False
+        self.has_user = False
+        self.cap_ended = False
+        self.cap_started = False
+
+    @command
+    async def CAP(self, subcommand: str, *params: str) -> None:
+        host = ellinetircd.servlocal.get().host
+        subcommand = subcommand.upper()
+        self.cap_started = True
+
+        CAPS = [
+            "away-notify",
+            "cap-notify",
+            "multi-prefix",
+            "chghost",
+        ]
+        caps = " ".join(CAPS)
+
+        if subcommand == 'LS':
+            await self.user.send(f":{host} CAP * LS :{caps}")
+        elif subcommand == 'LIST':
+            await self.user.send(f":{host} CAP * LIST :{caps}")
+        elif subcommand == 'REQ':
+            requested = set(params[-1].split())
+
+            supported = CAPS
+            unknown = requested.difference(supported)
+
+            if unknown:
+                await self.user.send(
+                    f":{host} CAP * NAK :{' '.join(unknown)}"
+                )
+            else:
+                await self.user.send(
+                    f":{host} CAP * ACK :{' '.join(requested)}"
+                )
+        elif subcommand == 'END':
+            self.cap_ended = True
+            if self.has_user and self.has_nick:
+                await self.register()
+        else:
+            raise ErrUnknownError(self.user, "CAP", f"Unknown CAP subcommand {subcommand}.")
+
+    @command
+    async def PASS(self, password: str) -> None:
+        raise ErrAlreadyRegistred()
+
+    @command
+    async def USER(self, username: str, _zero: str, _star: str, realname: str) -> None:
+        self.has_user = True
+        self.user.realname = realname
+        if self.has_user and self.has_nick and (not self.cap_started or self.cap_ended):
+            await self.register()
+
+    @command
+    async def NICK(self, nickname: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        if nickname in servlocal.users:
+            raise ErrNicknameInUse(nickname)
+        if not nick_re.match(nickname):
+            raise ErrErroneusNickname(nickname)
+        if not self.user.can_use_nick(nickname):
+            logger.log(ellinetircd.SECURITY, '%s tried to use nick %s', self.user, nickname)
+            raise ErrErroneusNickname(nickname)
+
+        self.user.nick = nickname
+        self.has_nick = True
+        if self.has_user and self.has_nick and (not self.cap_started or self.cap_ended):
+            await self.register()
+
+    async def register(self) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        self.user.state = RegisteredState(self.user)
+        ellinetircd.update_status()
+        await self.user.send(textwrap.dedent("""\
+            :{host} 001 {nick} :Welcome to the Internet Relay Network {nick}
+            :{host} 002 {nick} :Your host is {host}, running version {version}
+            :{host} 003 {nick} :The server was created someday
+            :{host} 004 {nick} ellinetircd {version} {usermodes} {chanmodes}
+            :{host} 005 {nick} {cap1} :are supported by this server
+            :{host} 005 {nick} {cap2} :are supported by this server
+            :{host} 422 {nick} :MOTD File is missing""".format(
+                host=servlocal.host,
+                nick=self.user.nick,
+                version=ellinetircd.__version__,
+                # RPL_MYINFO (004), advertise availables modes (none)
+                usermodes="",
+                chanmodes="",
+                # RPL_ISUPPORT (005), advertise server capabilities (not much)
+                cap1 = "AWAYLEN=0 CASEMAPPING=ascii CHANLIMIT=#: CHANMODES= CHANNELLEN=50 CHANTYPES=# ELIST=",
+                cap2 = "HOSTLEN=63 KICKLEN=0 MAXLIST= MAXTARGETS=12 MODES=0 NICKLEN=15 STATUSMSG= TOPICLEN=0 USERLEN=15",
+            )
+        ).split('\n'))
+
+class RegisteredState(UserState):
+    """
+    The user sent the NICK command, he is fully registered to the server
+    and may use any command.
+    """
+
+    @command
+    async def PASS(self, password: str) -> None:
+        raise ErrAlreadyRegistred()
+
+    @command
+    async def USER(self, username: str, _zero: str, _star: str, realname: str) -> None:
+        raise ErrAlreadyRegistred()
+
+    @command
+    async def NICK(self, nickname: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+
+        if nickname in servlocal.users:
+            raise ErrNicknameInUse(nickname)
+        if not nick_re.match(nickname):
+            raise ErrErroneusNickname(nickname)
+
+        old_nick = self.user.nick
+        async with trio.open_nursery() as nursery:
+            for chan in self.user.channels:
+                nursery.start_soon(chan.send, f":{old_nick} NICK {nickname}")
+
+        self.user.nick = nickname
+
+    @command
+    async def JOIN(self, channels: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+
+        for channel in channels.split(','):
+            if not chan_re.match(channel):
+                await self.user.send(ErrNoSuchChannel.format(channel))
+                continue
+
+            # Find or create the channel, add the user in it
+            chan = servlocal.channels.get(channel)
+            if not chan:
+                chan = Channel(channel)
+                servlocal.channels[chan.name] = chan
+                ellinetircd.update_status()
+            chan.users.add(self.user)
+            self.user.channels.add(chan)
+
+            # Send JOIN response to all
+            await chan.send(f":{self.user.nick} JOIN {channel}")
+
+            # Send NAMES list to joiner
+            await self.NAMES(channel)
+
+    @command
+    async def PART(self, channels: str, reason: Optional[str] = None) -> None:
+        servlocal = ellinetircd.servlocal.get()
+
+        for channel in channels.split(','):
+            chan = servlocal.channels.get(channel)
+            if not chan:
+                await self.user.send(ErrNoSuchChannel.format(channel))
+                continue
+
+            if self.user not in chan.users:
+                await self.user.send(ErrNotOnChannel.format(channel))
+                continue
+
+            self.user.channels.remove(chan)
+            chan.users.remove(self.user)
+            if not chan.users:
+                servlocal.channels.pop(chan.name)
+                ellinetircd.update_status()
+
+            if reason:
+                await chan.send(f":{self.user.nick} PART {channel} :{reason}")
+            else:
+                await chan.send(f":{self.user.nick} PART {channel}")
+
+    @command
+    async def NAMES(self, channel: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        chan = servlocal.channels.get(channel)
+        host = servlocal.host
+        nick = self.user.nick
+
+        if chan:
+            await self.user.send([
+                f":{host} 353 {nick} = {chan} :{some_users}"
+                # merged all users in a str and split it by MAXLINELEN chunks
+                for some_users in textwrap.wrap(
+                    ' '.join(sorted(user.nick for user in chan.users)),
+                    width=ellinetircd.MAXLINELEN - len(host) - len(nick) - len(channel) - 13
+                )
+            ])
+
+        await self.user.send(f":{host} 366 {nick} {chan} :End of /NAMES list.")
+            
+    @command
+    async def LIST(self) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        host = servlocal.host
+        nick = self.user.nick
+
+        await self.user.send([
+            f":{host} 321 {nick} Channel :Users Name",
+            *[
+                f":{host} 322 {nick} {chan} {len(chan.users)} :"
+                for chan in servlocal.channels.values()
+            ],
+            f":{host} 323 {nick} :End of /LIST"
+        ])
+
+    @command
+    async def PRIVMSG(self, targets: str, text: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+
+        for target in targets.split(','):
+            chan_or_user = (
+                servlocal.channels.get(target)
+                if target.startswith(('&', '#')) else
+                servlocal.users.get(target)
+            )
+
+            if not chan_or_user:
+                await self.user.send(ErrNoSuchNick.format(target))
+                continue
+
+            await chan_or_user.send(
+                f":{self.user.nick} PRIVMSG {target} :{text}",
+                skipusers={self.user}
+            )
+
+    @command
+    async def WHO(self, target: str = "*") -> None:
+        servlocal = ellinetircd.servlocal.get()
+        host = servlocal.host
+        requester = self.user.nick
+    
+        def match(user: "ellinetircd.user.User", target: str) -> bool:
+            if target == "*" or target == "":
+                return True
+            if target.startswith("#"):
+                return user in servlocal.channels.get(target, set()).users
+            return target.lower() in user.nick.lower()
+    
+        users = set()
+    
+        # Channel WHO
+        if target.startswith("#"):
+            chan = servlocal.channels.get(target)
+            if chan:
+                users = chan.users
+    
+        # Global / nick WHO
+        else:
+            for chan in servlocal.channels.values():
+                users.update(chan.users)
+    
+            users = [u for u in users if target == "*" or target.lower() in u.nick.lower()]
+    
+        # Send WHO replies
+        for user in users:
+            await self.user.send(
+                f":{host} 352 {requester} "
+                f"{target} "
+                f"~{user.nick} "
+                f"{user.host} "
+                f"{host} "
+                f"{user.nick} "
+                f"H :0 {user.realname}"
+            )
+    
+        # End of WHO list
+        await self.user.send(
+            f":{host} 315 {requester} {target} :End of /WHO list."
+        )
+
+    @command
+    async def WHOIS(self, target: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        host = servlocal.host
+        requester = self.user.nick
+
+        user = servlocal.users.get(target)
+        if not user:
+            raise ErrNoSuchNick(target)
+
+        await self.user.send(
+            f":{host} 311 {requester} {target} ~{user.nick} {user.host} {host} :{user.realname}"
+        )
+        await self.user.send(
+            f":{host} 312 {requester} {target} {host} :ellinetircd"
+        )
+
+        channels = ' '.join(sorted(chan.name for chan in user.channels))
+        if channels:
+            await self.user.send(
+                f":{host} 319 {requester} {target} :{channels}"
+            )
+
+        await self.user.send(
+            f":{host} 318 {requester} {target} :End of /WHOIS list."
+        )
+
+    @command
+    async def MODE(self, target: Optional[str] = None, *params: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        host = servlocal.host
+        nick = self.user.nick
+
+        # Replace IF I add a MODE system
+
+        # User MODE query
+        if not target or target == self.user.nick:
+            await self.user.send(
+                f":{host} 221 {nick} +"
+            )
+            return
+
+        # Channel MODE query
+        if target.startswith("#") or target.startswith("&"):
+            if target not in servlocal.channels:
+                await self.user.send(ErrNoSuchChannel.format(target))
+                return
+
+            # Placeholder: pretend all channels are "+nt"
+            await self.user.send(
+                f":{host} 324 {nick} {target} +nt"
+            )
+            await self.user.send(
+                f":{host} 329 {nick} {target} 0"
+            )
+            return
+
+        # Unknown target (nick etc.)
+        await self.user.send(
+            ErrNoSuchNick.format(target)
+        )
+
+class QuitState(UserState):
+    """ The user sent the QUIT command, no more message should be processed """
+    def __init__(self, user: "ellinetircd.user.User") -> None:
+        super().__init__(user)
+        user.nick = None
+        ellinetircd.update_status()
+
+    @command
+    async def PING(self, server1: Optional[str] = None, server2: Optional[str] = None) -> None:
+        raise ErrUnknownError(self.user, "PING", "Called while in the wrong state.")
+
+    @command
+    async def PONG(self, server1: Optional[str] = None, server2: Optional[str] = None) -> None:
+        raise ErrUnknownError(self.user, "PONG", "Called while in the wrong state.")
+
+    @command
+    def QUIT(self, args: str) -> None:
+        raise ErrUnknownError(self.user, "QUIT", "Called while in the wrong state.")

ellinetircd/user.py

@@ -0,0 +1,199 @@
+import ipaddress
+import logging
+import re
+import trio
+import uuid
+from typing import List, Optional, Set, Tuple, Union
+
+import ellinetircd
+from ellinetircd.config import config as cfg
+from ellinetircd.exceptions import IRCException, Disconnect
+from ellinetircd.states import PasswordState, ConnectedState, QuitState
+
+
+logger = logging.getLogger('ellinetircd.user')
+
+message_re = re.compile(r"""
+    (?P<command>[A-Z]+)
+    (?P<middle>(?:\ [^\ :]+)*)
+    (?:\ :(?P<trailing>.+))?
+""", re.VERBOSE)
+
+# Nicknames that users should not use
+_unsafe_nicks = {
+    # RFC
+    'anonymous',
+    # anope services
+    'ChanServ',
+    'NickServ',
+    'OperServ',
+    'MemoServ',
+    'HostServ',
+    'BotServ',
+}
+
+# Networks allowed to use the above unsafe nicks
+_safenets = [
+    ipaddress.ip_network('::1/128'),
+    ipaddress.ip_network('127.0.0.0/8'),
+]
+
+
+class User:
+    def __init__(self, stream: trio.abc.Stream, nursery: trio.Nursery) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        self.stream = stream
+        self._nursery = nursery
+        self._nick: Optional[str] = None
+        self._addr: Tuple[str, int, ...] = stream.socket.getpeername()
+        self._realname: Optional[str] = None
+        self.state = None
+        self.state = (PasswordState if servlocal.pwd else ConnectedState)(self)
+        self.channels = set()
+        self._ping_timer = trio.CancelScope()  # dummy
+        self._send_lock = trio.StrictFIFOLock()
+
+    def __str__(self) -> str:
+        if self.nick:
+            return self.nick
+
+        ip, port, *_ = self._addr
+        if ':' in ip:
+            return f'[{ip}]:{port}'
+        return f'{ip}:{port}'
+
+    @property
+    def nick(self) -> Optional[str]:
+        return self._nick
+    
+    @property
+    def addr(self) -> Tuple[str, int, ...]:
+        return self._addr
+    
+    @property
+    def host(self) -> str:
+        return self._addr[0]
+    
+    @property
+    def realname(self) -> Optional[str]:
+        return self._realname
+
+    @nick.setter
+    def nick(self, nick: str) -> None:
+        servlocal = ellinetircd.servlocal.get()
+        servlocal.users[nick] = servlocal.users.pop(self._nick, self)
+        self._nick = nick
+
+    @realname.setter
+    def realname(self, realname: str) -> None:
+        self._realname = realname
+
+    def can_use_nick(self, nick: str) -> bool:
+        """ Whether this user is allowed to use ``nick``. """
+        if nick not in _unsafe_nicks:
+            return True
+
+        ip = ipaddress.ip_address(self._addr[0])
+        return any(ip in net for net in _safenets)
+
+    async def ping_forever(self) -> None:
+        """
+        If the user did not send any message for some time, send him a
+        PING message that he should answer ASAP with a PONG message. If
+        he fails to answer (maybe because the network failed) he'll be
+        automatically disconnected, see :meth:`serve`.
+        """
+        while True:
+            with trio.move_on_after(cfg.TIMEOUT - cfg.PING_TIMEOUT) as self._ping_timer:
+                await trio.sleep_forever()
+            await self.send(f'PING {uuid.uuid4().hex}', log=logger.isEnabledFor(logging.DEBUG))
+
+    async def serve(self) -> None:
+        """
+        Read for messages on the user socket, parse them and dispatch
+        each message to the current's user state.
+        """
+        buffer = b""
+        while type(self.state) is not QuitState:
+
+            # Read the socket in a buffer, wait at most TIMEOUT seconds
+            self._ping_timer.deadline = trio.current_time() + (cfg.TIMEOUT - cfg.PING_TIMEOUT)
+            with trio.move_on_after(cfg.TIMEOUT) as cs:
+                try:
+                    chunk = await self.stream.receive_some(ellinetircd.MAXLINELEN)
+                except Exception as exc:
+                    raise Disconnect("Network failure") from exc
+            if cs.cancelled_caught:
+                raise Disconnect("Timeout")
+            elif not chunk:
+                raise Disconnect("End of transmission")
+
+            # Split the buffer into as many IRC messages as possible,
+            # ensure each message has a length of maximum MAXLINELEN
+            *messages, buffer = (buffer + chunk).split(b'\r\n')
+            if any(len(m) > ellinetircd.MAXLINELEN - 2 for m in messages + [buffer]):
+                raise Disconnect("Payload too long")
+
+            for message in (m for m in messages if m):
+                # IO-log all messages, except PING/PONG that are only
+                # log in DEBUG
+                if not (message.startswith(b'PING') or message.startswith(b'PONG')
+                   ) or logger.isEnabledFor(logging.DEBUG):
+                    logger.log(ellinetircd.IO, "recv from %s: %s", self, message)
+
+                # Parse the message
+                try:
+                    if not (match := message_re.match(message.decode())):
+                        raise SyntaxError(f"Couldn't parse {message}")
+                except UnicodeDecodeError as exc:
+                    raise Disconnect("Gibberish") from exc
+                except SyntaxError as exc:
+                    raise Disconnect("Parsing error") from exc
+
+                # Re-construct the arguments
+                args = [match.group('command')]
+                if middle := match.group('middle'):
+                    args.extend(middle.split())
+                if trailing := match.group('trailing'):
+                    args.append(trailing)
+
+                # Execute the command
+                try:
+                    await self.state.dispatch(*args)
+                except IRCException as exc:
+                    logger.warning("Command %s sent by %s failed, code: %s",
+                        args[0], self, exc.code)
+                    await self.send(exc.args[0])
+
+    async def terminate(self, kick_msg: str = "Connection terminated by host") -> None:
+        """
+        Terminate the connection with this user by closing the
+        underlying socket and cancelling the user's nursery effectively
+        cancelling all user's related tasks.
+        """
+        logger.info("Terminate connection of %s", self)
+        if type(self.state) != QuitState:
+            await self.state.QUIT(f":{kick_msg}".split(' '), kick=True)
+        with trio.move_on_after(cfg.PING_TIMEOUT) as cs:
+            try:
+                await self.stream.send_eof()
+            except (trio.BrokenResourceError, OSError):
+                pass # client already died
+        await self.stream.aclose()
+        self._nursery.cancel_scope.cancel()
+
+    async def send(
+        self,
+        messages: Union[str, List[str]],
+        log: bool = True,
+        skipusers: Optional[Set["ellinetircd.user.User"]] = None,
+    ) -> None:
+        """ Send many messages to the user. """
+        if isinstance(messages, str):
+            messages = [messages]
+
+        async with self._send_lock:
+            if log:
+                for msg in messages:
+                    logger.log(ellinetircd.IO, "send to %s: %s", self, msg)
+            await self.stream.send_all(b"".join(f"{msg}\r\n".encode() for msg in messages))

ellinetircd-1.0.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: ellinetircd
+Version: 1.0.0
+Summary: ElliNetIRCd - an asynchronous IRC server
+Home-page: https://github.com/ElliNet13/ElliNetIRCd
+Download-URL: https://pypi.org/project/ellinetircd/
+Author: ElliNet13
+Author-email: your@email.com
+License: MIT
+Classifier: Environment :: No Input/Output (Daemon)
+Classifier: Framework :: AsyncIO
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Communications :: Chat :: Internet Relay Chat
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: trio
+Dynamic: download-url
+Dynamic: license-file
+
+ellinetircd
+=======
+
+A python asynchronous IRC server based on aioirc.
+
+### Installation and Usage
+
+Download and install the latest stable version using pip.
+Windows users might replace `python3` by `py`.
+```bash
+python3 -m pip install ellinetircd
+```
+
+Then run the server:
+```bash
+HOST=0.0.0.0 LOGLEVEL=INFO python3 -m ellinetircd
+```
+If you are using powershell you can use the following command:
+```powershell
+$env:HOST="0.0.0.0"
+$env:LOGLEVEL="INFO"
+python -m ellinetircd
+```
+
+The configuration is done via environment variables, see `--help`:
+
+    optional arguments:
+      -h, --help     show this help message and exit
+      -V, --version  show program's version number and exit
+
+    environment variables:
+      HOST           public domain name (default: julien-UX410UAR)
+      ADDR           ip address to bind (default: 127.0.1.1)
+      PORT           port to bind (default: 6667)
+      PASS           server password (default: )
+      TIMEOUT        kick inactive users after x seconds (default: 60)
+      PING_TIMEOUT   PING inactive users x seconds before timeout (default: 5)
+      LOGLEVEL       logging verbosity (default: WARNING)

ellinetircd-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+ellinetircd/__init__.py,sha256=roTAItzYx_WKprglbCjG47tJMmreltbAgT795cteuhA,926
+ellinetircd/__main__.py,sha256=e4tNtoc2NkNIl_Mm07lV_-GpIKzPUB4SorZxmiQGRhs,2626
+ellinetircd/channel.py,sha256=mbGw9OdhJSqwz1NEupk0pv67WRf1XCjWIg2e3eOOA0Q,2197
+ellinetircd/config.py,sha256=rNdhETi-OBQyXr3uRmz82290iGWhwU5QQ8DSjzYbnu4,470
+ellinetircd/exceptions.py,sha256=7LEwSwDuFsz2pCfF7B9WBhORIojJbKyUthFMo-nc6JA,2113
+ellinetircd/sdnotify.py,sha256=nJU4x-WCUXiDbNfSZSnacwwCkdNOI-59gJlVMv73LnI,625
+ellinetircd/server.py,sha256=-cVqK6-rgLmZjSSngthe359Y9lBxB_xxcJ6fG3syIUQ,2733
+ellinetircd/states.py,sha256=e3d7CSsXf8ZeHVsdiQ6JdrYobJyLSd9cF37aExpbVkU,17180
+ellinetircd/user.py,sha256=eYsKObPdQrkED0ptyVazdaEBRYK0XFUA3cchEiuaj8A,7079
+ellinetircd-1.0.0.dist-info/licenses/LICENSE,sha256=INUFoaswHMmCIpYFaWhj7XYkxXw8KbUTSGI0BODWNWM,1080
+ellinetircd-1.0.0.dist-info/METADATA,sha256=52rqeAqExMK50A3YVG7_SoESspGA_OjmHFNQURmtxbc,1874
+ellinetircd-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ellinetircd-1.0.0.dist-info/top_level.txt,sha256=rW1Qb1lptOI4ayIfFJScLyepNgPj8-zflm_xkjcVcYA,12
+ellinetircd-1.0.0.dist-info/RECORD,,

ellinetircd-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ellinetircd-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,8 @@
+Copyright Julien Castiaux 2020
+Copyright ElliNet13 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

ellinetircd-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ellinetircd