make server.py executable. you can now run ./server.py instead of python3 server.py

.gitignore

@@ -2,4 +2,3 @@ __pycache__/**
 .env
 cache.py
 *.swp
-bugs.txt

IRC-spec.txt

@@ -1,35 +0,0 @@
-# On-connect
-:<servername> CAP * LS :
-:<servername> 001 <client> :Welcome to the python-talk Network, <client>
-:<servername> 002 <client> :Your host is <servername>, running version 0.1
-:<servername> 003 <client> :This server was created 0
-:<servername> 004 <client> python-talk 0.1 r t
-:<servername> 005 <client> AWAYLEN=200,CASEMAPPING=ascii,CHANTYPES=#,ELIST=U,HOSTLEN=16 :are supported by this server
-:<servername> 005 <client> CHANLIMIT=#:1,CHANMODES=b,k,l,t,CHANNELLEN=4,KICKLEN=1,MAXLIST=b:1 :are supported by this server
-:<servername> 005 <client> MODES=4,NETWORK=talknet,NICKLEN=20,TOPICLEN=30,USERLEN=1 :are supported by this server
-:<servername> 251 <client> :There are <u> users and 0 invisible on <s> servers
-:<servername> 252 <client> 0 :operator(s) online
-:<servername> 253 <client> 0 :unknown connection(s)
-:<servername> 254 <client> 1 :channel formed
-:<servername> 255 <client> :I have <c> clients and <s> servers
-:<servername> 265 <client> [<u> <m>] :Current local users <u>, max <m>
-:<servername> 266 <client> [<u> <m>] :Current global users <u>, max <m>
-:<servername> 422 <client> :This server does not support MOTDs
-:<client> JOIN #main
-:<servername> 324 <client> #main t
-:<servername> 332 <client> #main :Welcome to the main channel!
-:<servername> 353 <client> = #main :<client>, ...other clients here...
-:<servername> 366 <client> #main :End of /NAMES list
-# On Attempting to join/part a channel, or anything else I don't want to deal with
-:<servername> 421 <client> <command> :Unknown command
-# I should probably return the "NOSUCHCHANNEL" thing for joins
-
-#PING PONG
-:<servername> PONG <servername> :<data>
-
-# If the user tries to kill us or another server, respond with an easter egg
-:<servername> 483 <client> :You can't kill me, I'm Skynet!
-# Otherwise, if the user exists:
-:<servername> 481 <client> :Permission Denied- There are no IRC operators here.
-# Otherwise:
-:<servername> 401 <client> <nickname> :No such nick/channel

init-scripts/freebsd-rc

@@ -1,13 +0,0 @@
-#!/bin/sh
-. /etc/rc.subr
-name="python_talk"
-start_cmd="${name}_start"
-stop_cmd=":"
-rcvar=python_talk_enable
-load_rc_config $name
-: ${python_talk_enable:=no}
-python_talk_start() {
-	cd /usr/src/python-talk
-	(while true; do python3 server.py --link=37.27.51.34:65048 --no-log --no-cache --cwlgd 2>&1 >> /var/log/python-talk.log; done) &
-}
-run_rc_command "$1"

init-scripts/systemd-system.service

@@ -1,38 +0,0 @@
-[Unit]
-Description=firepup's python-talk
-
-[Service]
-DynamicUser=yes
-WorkingDirectory=/opt/python-talk
-ExecStart=/usr/bin/python3 server.py --link=37.27.51.34:65048 --no-logs --no-cache --cwlgd
-Restart=always
-RestartSec=5
-NoNewPrivileges=true
-RestrictSUIDSGID=true
-ProtectSystem=strict
-ProtectHome=true
-ProtectProc=ptraceable
-ProcSubset=pid
-PrivateTmp=true
-CapabilityBoundingSet=
-PrivateDevices=true
-ProtectClock=true
-ProtectKernelLogs=true
-ProtectControlGroups=true
-ProtectKernelModules=true
-SystemCallArchitectures=native
-# python.
-MemoryDenyWriteExecute=false
-RestrictNamespaces=true
-ProtectHostname=true
-LockPersonality=true
-ProtectKernelTunables=true
-RestrictAddressFamilies=AF_INET
-RestrictRealtime=true
-PrivateUsers=true
-SystemCallFilter=@system-service
-SystemCallFilter=~@privileged @resources
-UMask=0077
-
-[Install]
-WantedBy=multi-user.target

init-scripts/systemd-user.service

@@ -1,38 +0,0 @@
-[Unit]
-Description=firepup's python-talk
-
-[Service]
-WorkingDirectory=%h/python-talk
-ExecStart=/usr/bin/python3 server.py --link=37.27.51.34:65048 --no-logs --no-cache --cwlgd
-Restart=always
-RestartSec=5
-NoNewPrivileges=true
-RestrictSUIDSGID=true
-ProtectSystem=strict
-ProtectHome=tmpfs
-BindReadOnlyPaths=%h/python-talk
-ProtectProc=ptraceable
-ProcSubset=pid
-PrivateTmp=true
-CapabilityBoundingSet=
-PrivateDevices=true
-ProtectClock=true
-ProtectKernelLogs=true
-ProtectControlGroups=true
-ProtectKernelModules=true
-SystemCallArchitectures=native
-# python.
-MemoryDenyWriteExecute=false
-RestrictNamespaces=true
-ProtectHostname=true
-LockPersonality=true
-ProtectKernelTunables=true
-RestrictAddressFamilies=AF_INET
-RestrictRealtime=true
-PrivateUsers=true
-SystemCallFilter=@system-service
-SystemCallFilter=~@privileged @resources
-UMask=0077
-
-[Install]
-WantedBy=default.target

logs.py

@@ -30,16 +30,12 @@ def log(
         print(
             f"[{level}]{'['+origin+']' if origin else ''}[{time}] {message}",
             file=stream,
-            flush=True,
         )
     else:
         for line in message.split("\n"):
-            log = (
-                log + f"\r\n[{level}]{'['+origin+']' if origin else ''}[{time}] {line}"
-            )
+            log = log + f"\n[{level}]{'['+origin+']' if origin else ''}[{time}] {line}"
             print(
                 f"[{level}]{'['+origin+']' if origin else ''}[{time}] {line}",
                 file=stream,
-                flush=True,
             )
-    return (log[5:] + "\r\n").encode("utf8")
+    return (log[5:] + "\n").encode("utf8")

server.py

@@ -1,27 +1,20 @@
 #!/usr/bin/python3
-import os, sys, asyncio, re, signal, socket, random
+
+import os, sys, asyncio, re, signal
 from platform import uname
 from traceback import format_exc
 from logs import log
 
 
-class LinkDownError(Exception): ...
-
-
-class FailedLinkError(Exception): ...
+class LinksDownException(Exception): ...
 
 
 class Globals: ...
 
 
-TimeoutErrors = (TimeoutError, asyncio.exceptions.TimeoutError)
-DisconnectErrors = (
-    ConnectionResetError,
-    BrokenPipeError,
-    IndexError,
-    UnicodeDecodeError,
-    *TimeoutErrors,
-)
+# The two below lines are a hacky fix for python 3.10 asyncio
+TimoutError = TimeoutError
+TimeoutError = (TimoutError, asyncio.exceptions.TimeoutError)
 G = Globals()
 G.uniqueClients = 0
 G.servers = {}
@@ -36,11 +29,8 @@ G.killList = {}
 G.outboundLinks = []
 G.S2SLogs = []
 G.cwlgd = False
-G.NUL = "\x1e"
-G.IRCStats = {"users": {"localMax": 0, "localCurrent": 0, "globalMax": 0, "globalCurrent": 0}, "servers": 0}
-G.queue = []
 saveLogs = True
-address = "::"
+address = "0.0.0.0"
 # Try to load a message log, if one exists
 try:
     G.msgs = __import__("cache").msgs
@@ -61,9 +51,8 @@ try:
             log("Explicitly erasing cached messages")
             G.msgs = []
         elif arg in ["-?", "-h", "--help"]:
-            filename = filename if filename.startswith("./") else "python3 " + filename
             print(
-                f"""{filename} <args>
+                f"""python3 {filename} <args>
 All arguments are optional!
 All areguments are *expected* to only be specified once, if it appears mutliple times, the last one takes priority.
 The exception to the above rule is `--link`, since you could want to link to multiple other servers.
@@ -76,31 +65,27 @@ Accepted arguments:
 --hostname=<string>         - Sets the hostname for this server to use when talking to other servers. Defaults to the current system's hostname (limit of 16 chars)
 --address=<IP>              - Sets the IP to listen on, defaults to all addresses (0.0.0.0)
 --cwlgd                     - Crashes the server when outbound links go down
--r, --random-port           - Randomizes the port to listen on
 
 Examples:
-{filename} --hostname=Fun-chat --link=chat.example.com:65048 --port=92628
-{filename} --no-logs --no-cache
-{filename} --address=127.0.0.1 -l -p=7288"""
+python3 {filename} --hostname=Fun-chat --link=chat.example.com:65048 --port=92628
+python3 {filename} --no-logs --no-cache
+python3 {filename} --address=127.0.0.1 -l -p=7288"""
             )
             exit(0)
         elif arg in ["-l", "--no-logs"]:
             log("Explicitly disabling saving of logs!")
             saveLogs = False
-        elif arg.startswith("--link="):
+        elif arg.startswith("--link"):
             G.outboundLinks.append((arg[7:].split(":")[0], int(arg.split(":")[1])))
-        elif arg.startswith("--hostname="):
+        elif arg.startswith("--hostname"):
             G.remoteID = arg[11:]
             if not G.remoteID or len(G.remoteID) > 16:
                 raise ValueError
-        elif arg.startswith("--address="):
-            address = arg[10:]
-        elif arg in ["--cwlgd"]:
+        elif arg.startswith("--address"):
+            address = arg[9:]
+        elif arg.startswith("--cwlgd"):
             G.cwlgd = True
-            log("Server will crash when outbound links go down!", "WARN")
-        elif arg in ["-r", "--random-port"]:
-            random.seed()
-            port = random.randint(10000, 60000)
+            log("Server will crasg when outbound links go down!", "WARN")
         else:
             log(f"Unrecognized argument {arg}!", "WARN")
 except Exception:
@@ -109,31 +94,12 @@ except Exception:
 
 if not saveLogs:
     G.msgs.append(
-        b"[00-00-0000 00:00:00] Notice: Logging is disabled on this server instance!\r\n"
+        b"[00-00-0000 00:00:00] Notice: Logging is disabled on this server instance!\n"
     )
 if len(G.remoteID) > 16:
     G.remoteID = G.remoteID[:15]
 
 
-async def getMessage(reader, localQueue: list, size: int = 0, timeout: float = 0, sanitize: bool = False) -> str:
-    if not localQueue:
-        data = ""
-        if timeout and timeout > 0:
-            data = await asyncio.wait_for(reader.read(size), timeout)
-        else:
-            data = await reader.read(size)
-        localQueue = data.decode("utf8").strip().split("\r\n")
-    tmp = localQueue.pop(0)
-    if sanitize:
-        tmp = raw(tmp)
-    if size and size > 0:
-        other = tmp[size:]
-        tmp = tmp[:size]
-        if other:
-            localQueue.insert(0, other)
-    return tmp, localQueue
-
-
 def raw(string: str) -> str:
     s = string.strip()
     s = f"{s!r}"[1:-1].replace("\\\\", "\\")
@@ -152,31 +118,33 @@ def fmt(msg: str, name: str = "", action: bool = False) -> str:
 
 async def handleClient(reader, writer):
     try:
-        name = ""
         global G
-        writer.write(b"Please identify yourself. Nick limit is 20 chars.\r\n")
+        writer.write(b"Please identify yourself. Nick limit is 20 chars.\n")
         await writer.drain()
-        name, localQueue = await getMessage(reader, [], 20, 0, True)
-        localQueue = []
+        name = raw((await reader.read(20)).decode("utf8"))
         if len(name) > 20:
             name = name[
                 :19
             ]  # Really this is only possible if someone passes raw unicode as a nick, but let's clean it up anyways.
+        try:
+            await asyncio.wait_for(
+                reader.read(), 0.01
+            )  # Silently consume the excess username data
+        except TimeoutError:
+            pass
         if not name:
-            writer.write(b"Nice try. Actually set a nick.\r\n")
+            writer.write(b"Nice try. Actually set a nick.\n")
             await writer.drain()
             writer.close()
             await writer.wait_closed()
             return
         if name.lower() in G.clientsConnected:
-            writer.write(f"Nick ({name}) in use\r\n".encode("utf8"))
+            writer.write(f"Nick ({name}) in use\n".encode("utf8"))
             await writer.drain()
             writer.close()
             await writer.wait_closed()
             return
-        if name == "CAP LS 302":
-            pass  # TODO: IRC Logic
-        elif not name.startswith("S2S-"):
+        if not name.startswith("S2S-"):
             G.clientsConnected[name.lower()] = G.remoteID
             msgIndex = 0
             G.uniqueClients += 1
@@ -184,7 +152,8 @@ async def handleClient(reader, writer):
             G.S2SLogs.append(("+", name, G.remoteID))
             while 1:
                 try:
-                    request, localQueue = await getMessage(reader, localQueue, 967, 0.1, True)
+                    buffer = await asyncio.wait_for(reader.read(967), 0.1)
+                    request = raw(buffer.decode("utf8"))
                     response = None
                     if request.startswith("/mes "):
                         response = log(f"* {name}'s {request[5:]}")
@@ -194,25 +163,25 @@ async def handleClient(reader, writer):
                         G.S2SLogs.append(("A", (name, request[4:]), G.remoteID))
                     elif request.startswith("/h"):
                         writer.write(
-                            b"""Command List:\r
-/me <action>  - Sends a special message so it looks like you did <action>\r
-/mes <action> - Same as /me, but adds a 's onto your nick\r
-/afk [reason] - Optional reason, short hand for `/me is afk [to [reason]]`\r
-/h, /help     - Triggers this command listing\r
-/back         - Shorthand for `/me is back`\r
-/stat         - Sends you some server stats\r
-/quit         - Disconnects you from the server\r\n"""
+                            b"""Command List:
+/me <action>  - Sends a special message so it looks like you did <action>
+/mes <action> - Same as /me, but adds a 's onto your nick
+/afk [reason] - Optional reason, short hand for `/me is afk [to [reason]]`
+/h, /help     - Triggers this command listing
+/back         - Shorthand for `/me is back`
+/stats        - Sends you some server stats
+/quit         - Disconnects you from the server\n"""
                         )
                         await writer.drain()
-                    elif request.startswith("/stat"):
+                    elif request.startswith("/stats"):
                         writer.write(
-                            f"""Server stats:\r
-Linked servers:    {len(G.servers)}\r
-Connected clients: {G.uniqueClients}\r
-Total Clients:     {len(G.clientsConnected)}\r
-Messages sent:     {len(G.msgs)}\r
-\r
-Please note that this is not network level statistics.\r\n""".encode(
+                            f"""Server stats:
+Linked servers:    {len(G.servers)}
+Connected clients: {G.uniqueClients}
+Total Clients:     {len(G.clientsConnected)}
+Messages sent:     {len(G.msgs)}
+
+Please note that this is not network level statistics.\n""".encode(
                                 "utf8"
                             )
                         )
@@ -236,14 +205,14 @@ Please note that this is not network level statistics.\r\n""".encode(
                         G.S2SLogs.append(("M", (name, request), G.remoteID))
                     if response:
                         G.msgs.append(response)
-                except TimeoutErrors:
+                except TimeoutError:
                     pass
                 if msgIndex < len(G.msgs):
                     writer.writelines(G.msgs[msgIndex:])
                     await writer.drain()
                     msgIndex = len(G.msgs)
                 if name.lower() in G.killList and G.killList[name.lower()]:
-                    writer.write(b"Your client has been killed by the server\r\n")
+                    writer.write(b"Your client has been killed by the server\n")
                     G.killList[name.lower()] = False
                     break
             await writer.drain()
@@ -261,54 +230,55 @@ Please note that this is not network level statistics.\r\n""".encode(
                 writer.close()
                 await writer.wait_closed()
                 return  # Server is already "linked", drop the connection
-            if G.remoteID == sName or not sName:  # Hey! you can't *also* be ***me***!
+            if G.remoteID == sName:  # Hey! you can't *also* be ***me***!
                 writer.close()
                 await writer.wait_closed()
                 return  # drop "us"
             G.msgs.append(log(f"{sName} has linked to the network"))
             G.servers[sName] = {}
             msgIndex = 0
-            writer.write(b"I am awaiting your client listing.\r\n")
+            writer.write(b"I am awaiting your client listing.\n")
             while 1:
-                client, localQueue = await getMessage(reader, localQueue, 1024, 0, True)
+                client = raw((await reader.read(1024)).decode("utf8"))
                 if client == f"END OF CLIENT LISTING FROM {sName}":
                     break
                 if (
                     client.lower() in G.servers[sName]
                     or client.lower() in G.clientsConnected
                 ):
-                    writer.write(b"K Client rejected: Already exists\r\n")
+                    writer.write(b"K Client rejected: Already exists\n")
                     await writer.drain()
                     continue
-                writer.write(b"I added that client.\r\n")
+                writer.write(b"I added that client.\n")
                 await writer.drain()
                 G.msgs.append(log(f"{client} has connected from {sName}"))
                 G.servers[sName][client.lower()] = False
                 G.S2SLogs.append(("+", client, sName))
-            writer.write(f"{G.remoteID}\r\n".encode("utf8"))
+            writer.write(f"{G.remoteID}\n".encode("utf8"))
             await writer.drain()
             await reader.read(1024)
             for client in G.clientsConnected:
-                writer.write(f"{client}\r\n".encode("utf8"))
+                writer.write(f"{client}\n".encode("utf8"))
                 await writer.drain()
-                resp, localQueue = await getMessage(reader, localQueue, 1024, 0, True)
+                resp = raw((await reader.read(1024)).decode("utf8"))
                 if resp.startswith("K"):
                     if G.clientsConnected[client] == G.remoteID:
                         G.killList[client] = True
                     else:
                         G.servers[G.clientsConnected[client]][client] = True
-            writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\r\n".encode("utf8"))
+            writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\n".encode("utf8"))
             await writer.drain()
             for client in G.servers[sName]:
                 G.clientsConnected[client] = sName
             msgInd = len(G.S2SLogs)
             while 1:
                 try:
-                    buffer, localQueue = await getMessage(reader, localQueue, 1024, 0.1, False)
+                    rawMsg = await asyncio.wait_for(reader.read(967), 0.1)
+                    buffer = raw(rawMsg.decode("utf8"))
                     match buffer[0]:
                         case "S":  # Server notice
                             G.msgs.extend([log(buffer[2:])])
-                            writer.write(b"I Mmm... Blueberries\r\n")
+                            writer.write(b"I Mmm... Blueberries\n")
                         case "I":
                             pass
                         case "+":
@@ -320,9 +290,9 @@ Please note that this is not network level statistics.\r\n""".encode(
                                 G.servers[sName][cName.lower()] = False
                                 G.clientsConnected[cName.lower()] = sName
                                 G.S2SLogs.append(("+", cName, sName))
-                                writer.write(b"I Mmm... Pineapples\r\n")
+                                writer.write(b"I Mmm... Pineapples\n")
                             else:
-                                writer.write(f"K {cName}\r\n".encode("utf8"))
+                                writer.write(f"K {cName}\n".encode("utf8"))
                         case "-":
                             cName = buffer[2:]
                             if G.clientsConnected.get(cName.lower(), None) == sName:
@@ -332,43 +302,41 @@ Please note that this is not network level statistics.\r\n""".encode(
                                 del G.servers[sName][cName.lower()]
                                 del G.clientsConnected[cName.lower()]
                                 G.S2SLogs.append(("-", cName, sName))
-                                writer.write(b"I Mmm... Bananas\r\n")
+                                writer.write(b"I Mmm... Bananas\n")
                             else:
                                 writer.write(
-                                    f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\r\n".encode(
+                                    f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\n".encode(
                                         "utf8"
                                     )
                                 )
                         case "M":
-                            cName = buffer[2:].split(G.NUL, 1)[0]
-                            message = buffer[2:].split(G.NUL, 1)[1]
+                            cName = buffer[2:].split("|", 1)[0]
+                            message = buffer[2:].split("|", 1)[1]
                             G.msgs.append(log(f"  {cName}: {message}"))
                             G.S2SLogs.append(("M", (cName, message), sName))
                             writer.write(
-                                b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\r\n"
+                                b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\n"
                             )
                         case "A":
-                            cName = buffer[2:].split(G.NUL, 1)[0]
-                            message = buffer[2:].split(G.NUL, 1)[1]
+                            cName = buffer[2:].split("|", 1)[0]
+                            message = buffer[2:].split("|", 1)[1]
                             G.msgs.append(log(f"* {cName} {message}"))
                             G.S2SLogs.append(("A", (cName, message), sName))
-                            writer.write(b"I Mmm... Strawberries\r\n")
+                            writer.write(b"I Mmm... Strawberries\n")
                         case "Q":
                             break
                         case "K":
                             cName = buffer[2:]
-                            if not G.clientsConnected.get(cName.lower(), False):
-                                pass  # They don't exist, safe to ignore
-                            elif G.clientsConnected[cName.lower()] == G.remoteID:
+                            if G.clientsConnected[cName.lower()] == G.remoteID:
                                 G.killList[cName.lower()] = True
                             else:
                                 G.servers[G.clientsConnected[cName.lower()]][
                                     cName.lower()
                                 ] = True
-                            writer.write(b"I Mmm... Blood\r\n")
+                            writer.write(b"I Mmm... Blood\n")
                         case _:
                             writer.write(
-                                f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\r\n".encode(
+                                f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\n".encode(
                                     "utf8"
                                 )
                             )
@@ -377,12 +345,12 @@ Please note that this is not network level statistics.\r\n""".encode(
                                 "WARN",
                             )
                     await writer.drain()
-                except TimeoutErrors:
+                except TimeoutError:
                     pass
                 if any(G.servers[sName].values()):
                     for name in G.servers[sName]:
                         if G.servers[sName][name]:
-                            writer.write(f"K {name}\r\n".encode("utf8"))
+                            writer.write(f"K {name}\n".encode("utf8"))
                             await writer.drain()
                             G.servers[sName][name] = False
                 while msgInd < len(G.S2SLogs):
@@ -392,14 +360,14 @@ Please note that this is not network level statistics.\r\n""".encode(
                         match type:
                             case "A":
                                 nick, msg = data
-                                writer.write(f"A {nick}{G.NUL}{msg}\r\n".encode("utf8"))
+                                writer.write(f"A {nick}|{msg}\n".encode("utf8"))
                             case "M":
                                 nick, msg = data
-                                writer.write(f"M {nick}{G.NUL}{msg}\r\n".encode("utf8"))
+                                writer.write(f"M {nick}|{msg}\n".encode("utf8"))
                             case "+":
-                                writer.write(f"+ {data}\r\n".encode("utf8"))
+                                writer.write(f"+ {data}\n".encode("utf8"))
                             case "-":
-                                writer.write(f"- {data}\r\n".encode("utf8"))
+                                writer.write(f"- {data}\n".encode("utf8"))
                             case _:
                                 pass
                     await writer.drain()
@@ -413,9 +381,11 @@ Please note that this is not network level statistics.\r\n""".encode(
                 del G.clientsConnected[cName.lower()]
             del G.servers[sName]
             G.msgs.append(log(f"{sName} has de-linked from the network"))
-    except DisconnectErrors:
-        if not name:
-            return
+    except (
+        ConnectionResetError,
+        BrokenPipeError,
+        IndexError,
+    ):  # Don't ask. IndexError needs to be caught here too.
         if not name.startswith("S2S-"):
             G.uniqueClients -= 1
             G.msgs.append(log(f"{name} has disconnected from the server."))
@@ -431,213 +401,178 @@ Please note that this is not network level statistics.\r\n""".encode(
                     pass
             del G.servers[name[4:]]
             G.msgs.append(log(f"{name[4:]} has de-linked from the network"))
-    except Exception:
-        Err = format_exc()
-        for line in Err.split("\r\n"):
-            log(line, "ERROR")
 
 
 async def connectServer(hostname: str, port: int):
     global G
+    reader, writer = await asyncio.open_connection(hostname, port)
+    await reader.read(1024)
+    writer.write(f"S2S-{G.remoteID}\n".encode("utf8"))
+    await writer.drain()
+    await reader.read(1024)
+    for client in G.clientsConnected:
+        writer.write(f"{client}\n".encode("utf8"))
+        await writer.drain()
+        resp = raw((await reader.read(1024)).decode("utf8"))
+        if resp.startswith("K"):
+            if G.clientsConnected[client] == G.remoteID:
+                G.killList[client] = True
+            else:
+                G.servers[G.clientsConnected[client]][client] = True
+    writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\n".encode("utf8"))
+    await writer.drain()
+    rID = raw((await reader.read(16)).decode("utf8"))
     try:
-        reader, writer = await asyncio.open_connection(hostname, port)
-        ext, localQueue = await getMessage(reader, [], 1024)
-        writer.write(f"S2S-{G.remoteID}\r\n".encode("utf8"))
-        await writer.drain()
-        ext, localQueue = await getMessage(reader, [], 1024)
-        for client in G.clientsConnected:
-            writer.write(f"{client}\r\n".encode("utf8"))
+        await asyncio.wait_for(reader.read(1024), 0.1)
+    except TimeoutError:
+        pass
+    if G.servers.get(rID, False) != False:
+        writer.close()
+        await writer.wait_closed()
+        return
+    if G.remoteID == rID:
+        writer.close()
+        await writer.wait_closed()
+        return
+    G.msgs.append(log(f"{rID} has linked to the network"))
+    G.servers[rID] = {}
+    writer.write(b"I recieved your remote ID, now awaiting client listing\n")
+    await writer.drain()
+    # recieve client list from the other server
+    while 1:
+        client = raw((await reader.read(1024)).decode("utf8"))
+        if client == f"END OF CLIENT LISTING FROM {rID}":
+            break
+        if client.lower() in G.servers[rID] or client.lower() in G.clientsConnected:
+            writer.write(b"K Client rejected: Already exists\n")
             await writer.drain()
-            resp, localQueue = await getMessage(reader, localQueue, 1024, 0, True)
-            if resp.startswith("K"):
-                if G.clientsConnected[client] == G.remoteID:
-                    G.killList[client] = True
-                else:
-                    G.servers[G.clientsConnected[client]][client] = True
-        writer.write(f"END OF CLIENT LISTING FROM {G.remoteID}\r\n".encode("utf8"))
+            continue
+        writer.write(b"I added that client.\n")
         await writer.drain()
-        rID = raw((await reader.read(16)).decode("utf8"))
-        try:
-            await asyncio.wait_for(reader.read(1024), 0.1)
-        except TimeoutErrors:
-            pass
-        if G.servers.get(rID, False) != False:
-            writer.close()
-            await writer.wait_closed()
-            return
-        if G.remoteID == rID or not rID:
-            writer.close()
-            await writer.wait_closed()
-            return
-        G.msgs.append(log(f"{rID} has linked to the network"))
-        G.servers[rID] = {}
-        writer.write(b"I recieved your remote ID, now awaiting client listing\r\n")
-        await writer.drain()
-        # recieve client list from the other server
+        G.msgs.append(log(f"{client} has connected from {rID}"))
+        G.servers[rID][client.lower()] = False
+    for client in G.servers[rID]:
+        G.clientsConnected[client] = rID
+    msgInd = len(G.S2SLogs)
+    try:
         while 1:
-            client, localQueue = await getMessage(reader, localQueue, 1024, 0, True)
-            if client == f"END OF CLIENT LISTING FROM {rID}":
-                break
-            if client.lower() in G.servers[rID] or client.lower() in G.clientsConnected:
-                writer.write(b"K Client rejected: Already exists\r\n")
-                await writer.drain()
-                continue
-            writer.write(b"I added that client.\r\n")
-            await writer.drain()
-            G.msgs.append(log(f"{client} has connected from {rID}"))
-            G.servers[rID][client.lower()] = False
-        for client in G.servers[rID]:
-            G.clientsConnected[client] = rID
-        msgInd = len(G.S2SLogs)
-        try:
-            while 1:
-                try:
-                    buffer, localQueue = await getMessage(reader, localQueue, 1024, 0.1, False)
-                    match buffer[0]:
-                        case "S":
-                            G.msgs.extend([log(buffer[2:])])
-                            writer.write(b"I Mmm... Blueberries\r\n")
-                        case "I":
-                            pass
-                        case "+":
-                            cName = buffer[2:]
-                            if cName.lower() not in G.clientsConnected:
-                                G.msgs.append(log(f"{cName} has connected from {rID}"))
-                                G.S2SLogs.append(("+", cName, rID))
-                                G.servers[rID][cName.lower()] = False
-                                G.clientsConnected[cName.lower()] = rID
-                                writer.write(b"I Mmm... Pineapples\r\n")
-                            else:
-                                writer.write(f"K {cName}\r\n".encode("utf8"))
-                        case "-":
-                            cName = buffer[2:]
-                            if G.clientsConnected.get(cName.lower(), None) == rID:
-                                G.msgs.append(
-                                    log(f"{cName} has disconnected from {rID}")
-                                )
-                                del G.servers[rID][cName.lower()]
-                                del G.clientsConnected[cName.lower()]
-                                G.S2SLogs.append(("-", cName, rID))
-                            else:
-                                writer.write(
-                                    f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\r\n".encode(
-                                        "utf8"
-                                    )
-                                )
-                        case "M":
-                            cName = buffer[2:].split(G.NUL, 1)[0]
-                            message = buffer[2:].split(G.NUL, 1)[1]
-                            G.msgs.append(log(f"  {cName}: {message}"))
-                            G.S2SLogs.append(("M", (cName, message), rID))
+            try:
+                rawMsg = await asyncio.wait_for(reader.read(967), 0.1)
+                buffer = raw(rawMsg.decode("utf8"))
+                match buffer[0]:
+                    case "S":
+                        G.msgs.extend([log(buffer[2:])])
+                        writer.write(b"I Mmm... Blueberries\n")
+                    case "I":
+                        pass
+                    case "+":
+                        cName = buffer[2:]
+                        if cName.lower() not in G.clientsConnected:
+                            G.msgs.append(log(f"{cName} has connected from {rID}"))
+                            G.S2SLogs.append(("+", cName, rID))
+                            G.servers[rID][cName.lower()] = False
+                            G.clientsConnected[cName.lower()] = rID
+                            writer.write(b"I Mmm... Pineapples\n")
+                        else:
+                            writer.write(f"K {cName}\n".encode("utf8"))
+                    case "-":
+                        cName = buffer[2:]
+                        if G.clientsConnected.get(cName.lower(), None) == rID:
+                            G.msgs.append(log(f"{cName} has disconnected from {rID}"))
+                            del G.servers[rID][cName.lower()]
+                            del G.clientsConnected[cName.lower()]
+                            G.S2SLogs.append(("-", cName, rID))
+                        else:
                             writer.write(
-                                b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\r\n"
-                            )
-                        case "A":
-                            cName = buffer[2:].split(G.NUL, 1)[0]
-                            message = buffer[2:].split(G.NUL, 1)[1]
-                            G.S2SLogs.append(("A", (cName, message), rID))
-                            G.msgs.append(log(f"* {cName} {message}"))
-                            writer.write(b"I Mmm... Strawberries\r\n")
-                        case "Q":
-                            break
-                        case "K":
-                            cName = buffer[2:]
-                            if not G.clientsConnected.get(cName.lower(), False):
-                                pass  # They don't exist, safe to ignore
-                            elif G.clientsConnected[cName.lower()] == G.remoteID:
-                                G.killList[cName.lower()] = True
-                            else:
-                                G.servers[G.clientsConnected[cName.lower()]][
-                                    cName.lower()
-                                ] = True
-                            writer.write(b"I Mmm... Blood\r\n")
-                        case _:
-                            writer.write(
-                                f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\r\n".encode(
+                                f"S Your server is LYING about who is connected to it. - {G.remoteID}, a fellow server\n".encode(
                                     "utf8"
                                 )
                             )
-                            log(
-                                f"Recieved invalid message ({buffer}) from {rID}",
-                                "WARN",
+                    case "M":
+                        cName = buffer[2:].split("|", 1)[0]
+                        message = buffer[2:].split("|", 1)[1]
+                        G.msgs.append(log(f"  {cName}: {message}"))
+                        G.S2SLogs.append(("M", (cName, message), rID))
+                        writer.write(
+                            b"I Get these damn heretic ghost clients out of my store so i can buy my cult candles in peace.\n"
+                        )
+                    case "A":
+                        cName = buffer[2:].split("|", 1)[0]
+                        message = buffer[2:].split("|", 1)[1]
+                        G.S2SLogs.append(("A", (cName, message), rID))
+                        G.msgs.append(log(f"* {cName} {message}"))
+                        writer.write(b"I Mmm... Strawberries\n")
+                    case "Q":
+                        break
+                    case "K":
+                        cName = buffer[2:]
+                        if G.clientsConnected[cName.lower()] == G.remoteID:
+                            G.killList[cName.lower()] = True
+                        else:
+                            G.servers[G.clientsConnected[cName.lower()]][
+                                cName.lower()
+                            ] = True
+                        writer.write(b"I Mmm... Blood\n")
+                    case _:
+                        writer.write(
+                            f"S Your server is doing drugs over here, sending me bullshit messages man - {G.remoteID}, A fellow server\n".encode(
+                                "utf8"
                             )
-                    await writer.drain()
-                except TimeoutErrors:
-                    pass
-                if any(G.servers[rID].values()):
-                    for name in G.servers[rID]:
-                        if G.servers[rID][name]:
-                            writer.write(f"K {name}\r\n".encode("utf8"))
-                            await writer.drain()
-                            G.servers[rID][name] = False
-                while msgInd < len(G.S2SLogs):
-                    type, data, server = G.S2SLogs[msgInd]
-                    if server != rID:
-                        match type:
-                            case "A":
-                                nick, msg = data
-                                writer.write(f"A {nick}{G.NUL}{msg}\r\n".encode("utf8"))
-                            case "M":
-                                nick, msg = data
-                                writer.write(f"M {nick}{G.NUL}{msg}\r\n".encode("utf8"))
-                            case "+":
-                                writer.write(f"+ {data}\r\n".encode("utf8"))
-                            case "-":
-                                writer.write(f"- {data}\r\n".encode("utf8"))
-                            case _:
-                                pass
-                    await writer.drain()
-                    msgInd += 1
-            if G.cwlgd:
-                raise LinkDownError
-            await writer.drain()
-            writer.close()
-            await writer.wait_closed()
-            for cName in G.servers[rID]:
-                G.msgs.append(log(f"{cName}'s server is going down"))
-                del G.clientsConnected[cName.lower()]
-            del G.servers[rID]
-            G.msgs.append(log(f"{rID} has de-linked from the network"))
-        except DisconnectErrors:
-            if G.cwlgd:
-                raise LinkDownError
-            for cName in G.servers[rID]:
-                G.msgs.append(log(f"{cName}'s server is going down"))
-                try:
-                    del G.clientsConnected[cName.lower()]
-                except Exception:
-                    pass
-            del G.servers[rID]
-            G.msgs.append(log(f"{rID} has de-linked from the network"))
-    except OSError as E:
-        log("OSError: " + str(E), "ERROR")
+                        )
+                        log(f"Recieved invalid message ({buffer}) from {sName}", "WARN")
+                await writer.drain()
+            except TimeoutError:
+                pass
+            if any(G.servers[rID].values()):
+                for name in G.servers[rID]:
+                    if G.servers[rID][name]:
+                        writer.write(f"K {name}\n".encode("utf8"))
+                        await writer.drain()
+                        G.servers[rID][name] = False
+            while msgInd < len(G.S2SLogs):
+                type, data, server = G.S2SLogs[msgInd]
+                if server != rID:
+                    match type:
+                        case "A":
+                            nick, msg = data
+                            writer.write(f"A {nick}|{msg}\n".encode("utf8"))
+                        case "M":
+                            nick, msg = data
+                            writer.write(f"M {nick}|{msg}\n".encode("utf8"))
+                        case "+":
+                            writer.write(f"+ {data}\n".encode("utf8"))
+                        case "-":
+                            writer.write(f"- {data}\n".encode("utf8"))
+                        case _:
+                            pass
+                await writer.drain()
+                msgInd += 1
         if G.cwlgd:
-            raise FailedLinkError
-    except Exception:
-        Err = format_exc()
-        for line in Err.split("\r\n"):
-            log(line, "ERROR")
-        raise FailedLinkError
+            raise LinksDownException
+        await writer.drain()
+        writer.close()
+        await writer.wait_closed()
+        for cName in G.servers[rID]:
+            G.msgs.append(log(f"{cName}'s server is going down"))
+            del G.clientsConnected[cName.lower()]
+        del G.servers[rID]
+        G.msgs.append(log(f"{rID} has de-linked from the network"))
+    except (ConnectionResetError, BrokenPipeError, IndexError):
+        if G.cwlgd:
+            raise LinksDownException
+        for cName in G.servers[rID]:
+            G.msgs.append(log(f"{cName}'s server is going down"))
+            try:
+                del G.clientsConnected[cName.lower()]
+            except Exception:
+                pass
+        del G.servers[rID]
+        G.msgs.append(log(f"{rID} has de-linked from the network"))
 
 
 async def runServer(address: str, port: int):
     global G
-    sock = None
-    try:
-        if ":" in address:
-            INET = socket.AF_INET6
-        else:
-            INET = socket.AF_INET
-        sock = socket.socket(INET, socket.SOCK_STREAM)
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # Reuse socket
-        sock.bind((address, port))
-    except OSError as E:
-        if E.errno != 97 or address != '::':
-            raise E
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # Reuse socket
-        sock.bind(('0.0.0.0', port))
-    server = await asyncio.start_server(handleClient, sock=sock)
+    server = await asyncio.start_server(handleClient, address, port)
     log(f"Listening on port {port}...")
     G.msgs.append(log("Server startup"))
     links = []
@@ -647,17 +582,12 @@ async def runServer(address: str, port: int):
     try:
         links.append(G.event.wait())
         await asyncio.gather(*links)
-    except LinkDownError:
-        G.msgs.append(log("Lost a server link, going down", "FATAL")[1:])
-        crash = True
-    except FailedLinkError:
-        G.msgs.append(log("Failed to establish a server link, going down", "FATAL")[1:])
     except Exception:
         crash = True
         G.msgs.append(log("Server crash", "FATAL")[1:])
         log("Shutting down from Exception", "FATAL")
         Err = format_exc()
-        for line in Err.split("\r\n"):
+        for line in Err.split("\n"):
             log(line, "ERROR")
     finally:
         if not crash:
@@ -667,11 +597,10 @@ async def runServer(address: str, port: int):
         # server.abort_clients()
         if saveLogs:
             with open("cache.py", "w") as cache:
-                cache.write(f"msgs = {G.msgs}\r\n")
+                cache.write(f"msgs = {G.msgs}\n")
             log("Saved logs, exiting now.")
         else:
             log("Not saving logs, exiting now.")
-        sock.close()
 
 
 class ServerInterruptException(KeyboardInterrupt): ...