From 3b7ae6f42a3eeae413515787307e2a97d2a1e949 Mon Sep 17 00:00:00 2001
From: swee <meow@swee.codes>
Date: Wed, 5 Feb 2025 18:59:40 -0800
Subject: [PATCH] Update server.py

---
 server.py | 193 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 100 insertions(+), 93 deletions(-)

diff --git a/server.py b/server.py
index 32a5eb0..e2e037a 100644
--- a/server.py
+++ b/server.py
@@ -209,7 +209,7 @@ def pinger(nick, connection):
                 time.sleep(0.5)
                 try:
                     connection.sendall(bytes(f"PING {server}\r\n","UTF-8"))
-                except (SSL.WantReadError, SSL.WantWriteError, SSL.WantX509LookupError):
+                except (SSL.WantReadError, SSL.WantWriteError, SSL.WantX509LookupError, SSL.SysCallError):
                     pass
                 except Exception as ex:
                     print(traceback.format_exc())
@@ -256,6 +256,13 @@ def session(connection, client, ip, isssl=False):
             #                         ^^^^^^^^^
             #      Cutting these off the string
         return tags + (" " if tags != "" else "")
+    def dosend(content):
+        if content.__class__.__name__ != "bytes":
+            content = bytes(content, "UTF-8")
+        try:
+            connection.sendall(content)
+        except (SSL.WantReadError, SSL.WantWriteError, SSL.WantX509LookupError, SSL.SysCallError):
+            print("Soft error occurred")
     def tags_diffclient(nick:str): # Get tags of another client
         othercap = property_list[nick]["v3cap"]
         tags = ""
@@ -269,27 +276,27 @@ def session(connection, client, ip, isssl=False):
         #    tlsver = connection.version()
         #    print(f"Got SSL version: {tlsver}")
         connection.settimeout(None)
-        connection.sendall(bytes(f":{server} NOTICE * :*** Looking for your hostname...\r\n","UTF-8"))
-        connection.sendall(bytes(f":{server} NOTICE * :*** Checking your ident...\r\n","UTF-8"))
+        dosend(bytes(f":{server} NOTICE * :*** Looking for your hostname...\r\n","UTF-8"))
+        dosend(bytes(f":{server} NOTICE * :*** Checking your ident...\r\n","UTF-8"))
         try:
             hostname = socket.gethostbyaddr(client[0])[0]
-            connection.sendall(bytes(f":{server} NOTICE * :*** Got hostname! {hostname}\r\n","UTF-8"))
+            dosend(bytes(f":{server} NOTICE * :*** Got hostname! {hostname}\r\n","UTF-8"))
         except:
             hostname = client[0]
-            connection.sendall(bytes(f":{server} NOTICE * :*** Oof! Can't find your hostname, using IP...\r\n","UTF-8"))
+            dosend(bytes(f":{server} NOTICE * :*** Oof! Can't find your hostname, using IP...\r\n","UTF-8"))
         try:
             identQuery = getident(hostname, client[1], isssl)
             responseee = identQuery["response"]
             print(identQuery)
             if not identQuery["success"]:
-                connection.sendall(bytes(f":{server} NOTICE * :*** Uhm, Couldn't find your ident: {responseee}\r\n","UTF-8"))
+                dosend(bytes(f":{server} NOTICE * :*** Uhm, Couldn't find your ident: {responseee}\r\n","UTF-8"))
             else:
-                connection.sendall(bytes(f":{server} NOTICE * :*** Got ident! {responseee}\r\n","UTF-8"))
+                dosend(bytes(f":{server} NOTICE * :*** Got ident! {responseee}\r\n","UTF-8"))
                 clident = responseee
                 rident = responseee
         except:
             print(traceback.format_exc())
-            connection.sendall(bytes(f":{server} NOTICE * :*** Uhm, Couldn't find your ident: Unknown error.\r\n","UTF-8"))
+            dosend(bytes(f":{server} NOTICE * :*** Uhm, Couldn't find your ident: Unknown error.\r\n","UTF-8"))
         while True:
             try:
                 data = connection.recv(2048)
@@ -319,7 +326,7 @@ def session(connection, client, ip, isssl=False):
                 #        print(f"Sending ping msg to {pending}")
                 #        ping_pending = True
                 #        time.sleep(0.5)
-                #        connection.sendall(bytes(f"PING {server}\r\n","UTF-8"))
+                #        dosend(bytes(f"PING {server}\r\n","UTF-8"))
                 #    elif ping_pending and (time.time() - last_ping) > ping_timeout:
                 #        cause = f"Ping timeout: {ping_timeout} seconds"
                 #        print(f"{pending} timed out.")
@@ -338,10 +345,10 @@ def session(connection, client, ip, isssl=False):
                             pending = text.split(" ")[1]
                             if pending[0] == ":": pending = pending[1:]
                             if not isalphanumeric(pending):
-                                connection.sendall(bytes(f"{tags()}:{server} 432 * {pending} :Erroneus nickname\r\n","UTF-8"))
+                                dosend(bytes(f"{tags()}:{server} 432 * {pending} :Erroneus nickname\r\n","UTF-8"))
                                 pending = "*"
                             elif pending.lower() in lower_nicks:
-                                connection.sendall(bytes(f"{tags()}:{server} 433 * {pending} :Nickname is already in use.\r\n","UTF-8"))
+                                dosend(bytes(f"{tags()}:{server} 433 * {pending} :Nickname is already in use.\r\n","UTF-8"))
                                 pending = "*"
                             else:
                                 already_set = True
@@ -353,7 +360,7 @@ def session(connection, client, ip, isssl=False):
                                 ready = True
                         elif command == "CAP":
                             if args[0].upper() == "LS":
-                                connection.sendall(bytes(f"{tags()}:{server} CAP * LS :server-time\r\n", "UTF-8"))
+                                dosend(bytes(f"{tags()}:{server} CAP * LS :server-time\r\n", "UTF-8"))
                             elif args[0].upper() == "REQ":
                                 usesIRCv3 = True # Halt the registration process until CAP END
                                 capabilities = " ".join(args[1:])[1:].split(" ")
@@ -366,9 +373,9 @@ def session(connection, client, ip, isssl=False):
                                         break
                                 capper = " ".join(capabilities)
                                 if capsuccess:
-                                    connection.sendall(bytes(f":{server} CAP * ACK :{capper}\r\n", "UTF-8"))
+                                    dosend(bytes(f":{server} CAP * ACK :{capper}\r\n", "UTF-8"))
                                 else:
-                                    connection.sendall(bytes(f":{server} CAP * NAK :{capper}\r\n", "UTF-8"))
+                                    dosend(bytes(f":{server} CAP * NAK :{capper}\r\n", "UTF-8"))
                             elif args[0].upper() == "END":
                                 CAPEND = True
                         elif command == "WEBIRC" and not finished:
@@ -376,9 +383,9 @@ def session(connection, client, ip, isssl=False):
                                 if args[0] == data2["webirc_pass"]:
                                     hostname = args[2]
                                     client = (args[3], client[1])
-                                    connection.sendall(bytes(f"{tags()}:{server} NOTICE * :*** WebIRC detected, welcome to IRC!\r\n", "UTF-8"))
+                                    dosend(bytes(f"{tags()}:{server} NOTICE * :*** WebIRC detected, welcome to IRC!\r\n", "UTF-8"))
                                     if hostname != client[0]:
-                                        connection.sendall(bytes(f"{tags()}:{server} NOTICE * :*** Got WebIRC hostname! {hostname}\r\n", "UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} NOTICE * :*** Got WebIRC hostname! {hostname}\r\n", "UTF-8"))
                             except:
                                 print(traceback.format_exc())
                                 break
@@ -394,28 +401,28 @@ def session(connection, client, ip, isssl=False):
                             threading.Thread(target=pinger, args=[pending, connection]).start()
                             if clident == None:
                                 rident = f"~{username}"
-                            connection.sendall(bytes(f"{tags()}:{server} 001 {pending} :Welcome to the {displayname} Internet Relay Chat Network {pending}\r\n", "UTF-8"))
-                            connection.sendall(bytes(f"{tags()}:{server} 002 {pending} :Your host is {server}[{ip}/6667], running version IRCat-v{__version__}\r\n", "UTF-8"))
-                            connection.sendall(bytes(f"{tags()}:{server} 004 {pending} {server} IRCat-{__version__} iow msitnR lfovkqb\r\n", "UTF-8"))
-                            connection.sendall(bytes(f"{tags()}:{server} 005 {pending} CHANMODES=bq,k,fl,irmnpst CHANTYPES=# NETWORK={displayname} :are supported by this server\r\n", "UTF-8"))
-                            # connection.sendall(bytes(f":{server} 251 {pending} :There are {allusers} users and {allinvis} invisible in {servers} servers\r\n", "UTF-8")) Not supported as there isn't multi-server capability (yet)
+                            dosend(bytes(f"{tags()}:{server} 001 {pending} :Welcome to the {displayname} Internet Relay Chat Network {pending}\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 002 {pending} :Your host is {server}[{ip}/6667], running version IRCat-v{__version__}\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 004 {pending} {server} IRCat-{__version__} iow msitnR lfovkqb\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 005 {pending} CHANMODES=bq,k,fl,irmnpst CHANTYPES=# NETWORK={displayname} :are supported by this server\r\n", "UTF-8"))
+                            # dosend(bytes(f":{server} 251 {pending} :There are {allusers} users and {allinvis} invisible in {servers} servers\r\n", "UTF-8")) Not supported as there isn't multi-server capability (yet)
                             ops = 0 # Placeholder, will replace with caclulating how much people have +o
-                            connection.sendall(bytes(f"{tags()}:{server} 252 {pending} {ops} :IRC Operators online\r\n", "UTF-8"))
-                            connection.sendall(bytes(f"{tags()}:{server} 253 {pending} 0 :unknown connection(s)\r\n", "UTF-8")) # Replace 0 with a variable of not setup clients.
+                            dosend(bytes(f"{tags()}:{server} 252 {pending} {ops} :IRC Operators online\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 253 {pending} 0 :unknown connection(s)\r\n", "UTF-8")) # Replace 0 with a variable of not setup clients.
                             chans = len(channels_list)
-                            connection.sendall(bytes(f"{tags()}:{server} 254 {pending} {chans} :channels formed\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 254 {pending} {chans} :channels formed\r\n", "UTF-8"))
                             cleints = len(nickname_list)
                             servers = 1
-                            connection.sendall(bytes(f"{tags()}:{server} 255 {pending} :I have {cleints} clients and {servers} servers\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 255 {pending} :I have {cleints} clients and {servers} servers\r\n", "UTF-8"))
                             # Start the MOTD
                             if motd_file != None:
                                 motd = open(motd_file).read()
-                            connection.sendall(bytes(f"{tags()}:{server} 375 {pending} :- {server} Message of the Day -\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 375 {pending} :- {server} Message of the Day -\r\n", "UTF-8"))
                             for i in motd.rstrip().split("\n"):
-                                connection.sendall(bytes(f"{tags()}:{server} 372 {pending} :- {i}\r\n", "UTF-8"))
-                            connection.sendall(bytes(f"{tags()}:{server} 376 {pending} :End of /MOTD command\r\n", "UTF-8"))
+                                dosend(bytes(f"{tags()}:{server} 372 {pending} :- {i}\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 376 {pending} :End of /MOTD command\r\n", "UTF-8"))
                             # End the MOTD
-                            connection.sendall(bytes(f"{tags()}:{pending} MODE {pending} +iw\r\n","UTF-8"))
+                            dosend(bytes(f"{tags()}:{pending} MODE {pending} +iw\r\n","UTF-8"))
                             finished = True
                         elif command == "PING":
                             try:
@@ -427,10 +434,10 @@ def session(connection, client, ip, isssl=False):
                         elif command == "MOTD":
                             if motd_file != None:
                                 motd = open(motd_file).read()
-                            connection.sendall(bytes(f"{tags()}:{server} 375 {pending} :- {server} Message of the Day -\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 375 {pending} :- {server} Message of the Day -\r\n", "UTF-8"))
                             for i in motd.rstrip().split("\n"):
-                                connection.sendall(bytes(f"{tags()}:{server} 372 {pending} :- {i}\r\n", "UTF-8"))
-                            connection.sendall(bytes(f"{tags()}:{server} 376 {pending} :End of /MOTD command\r\n", "UTF-8"))
+                                dosend(bytes(f"{tags()}:{server} 372 {pending} :- {i}\r\n", "UTF-8"))
+                            dosend(bytes(f"{tags()}:{server} 376 {pending} :End of /MOTD command\r\n", "UTF-8"))
                         elif finished:
                             pendingCommands += text
                             for comd in pendingCommands.replace("\r", "").split("\n"):
@@ -444,11 +451,11 @@ def session(connection, client, ip, isssl=False):
                                         if "identify" in cmdrun:
                                             if cmdrun["identify"] == "logout":
                                                 if "o" in property_list[pending]["modes"]:
-                                                    connection.sendall(bytes(f"{tags()}:{pending} MODE {pending} -o\r\n","UTF-8"))
+                                                    dosend(bytes(f"{tags()}:{pending} MODE {pending} -o\r\n","UTF-8"))
                                                 if not "i" in property_list[pending]["modes"]:
-                                                    connection.sendall(bytes(f"{tags()}:{pending} MODE {pending} +i\r\n","UTF-8"))
+                                                    dosend(bytes(f"{tags()}:{pending} MODE {pending} +i\r\n","UTF-8"))
                                                 if not "w" in property_list[pending]["modes"]:
-                                                    connection.sendall(bytes(f"{tags()}:{pending} MODE {pending} +w\r\n","UTF-8"))
+                                                    dosend(bytes(f"{tags()}:{pending} MODE {pending} +w\r\n","UTF-8"))
                                                 property_list[pending]["modes"] = "iw"
                                                 property_list[pending]["identified"] = False
                                             else:
@@ -456,7 +463,7 @@ def session(connection, client, ip, isssl=False):
                                                 property_list[pending]["identusername"] = cmdrun["identify"][0]
                                                 temp_mode = cmdrun["identify"][1]
                                                 property_list[pending]["modes"] = temp_mode
-                                                connection.sendall(bytes(f"{tags()}:{pending} MODE {pending} +{temp_mode}\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{pending} MODE {pending} +{temp_mode}\r\n","UTF-8"))
                                         processedExternally = True
                                         break
                                 if processedExternally:
@@ -484,7 +491,7 @@ def session(connection, client, ip, isssl=False):
                                                         lower_chans[channel.lower()] = channel
                                                         topic_list[channel] = "Topic is not implemented."
                                                 except:
-                                                    connection.sendall(bytes(f"{tags()}:{server} NOTICE * :*** Could not join {channel}\r\n","UTF-8"))
+                                                    dosend(bytes(f"{tags()}:{server} NOTICE * :*** Could not join {channel}\r\n","UTF-8"))
                                                 print(channels_list)
                                                 for i in channels_list[channel]:
                                                     try:
@@ -495,17 +502,17 @@ def session(connection, client, ip, isssl=False):
                                             if channel in channels_list:
                                                     if pending in channels_list[channel]:
                                                         users = " ".join(channels_list[channel])
-                                                        connection.sendall(bytes(f":{server} 353 {pending} = {channel} :{users}\r\n","UTF-8"))
-                                            connection.sendall(bytes(f"{tags()}:{server} 366 {pending} {channel} :End of /NAMES list.\r\n","UTF-8"))
+                                                        dosend(bytes(f":{server} 353 {pending} = {channel} :{users}\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 366 {pending} {channel} :End of /NAMES list.\r\n","UTF-8"))
                                             print("Successfully pre-loaded /NAMES list")
                                         else:
-                                            connection.sendall(bytes(f"{tags()}:{server} 479 {pending} {channel} :Channel has erroneus characters\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 479 {pending} {channel} :Channel has erroneus characters\r\n","UTF-8"))
                                 elif command == "LIST":
-                                    connection.sendall(bytes(f"{tags()}:{server} 321 {pending} Channel :Users  Name\r\n","UTF-8"))
+                                    dosend(bytes(f"{tags()}:{server} 321 {pending} Channel :Users  Name\r\n","UTF-8"))
                                     for key, value in topic_list.items():
                                         usersin = len(channels_list[key])
-                                        connection.sendall(bytes(f"{tags()}:{server} 322 {pending} {key} {usersin} :{value}\r\n","UTF-8"))
-                                    connection.sendall(bytes(f"{tags()}:{server} 323 {pending} :End of /LIST\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 322 {pending} {key} {usersin} :{value}\r\n","UTF-8"))
+                                    dosend(bytes(f"{tags()}:{server} 323 {pending} :End of /LIST\r\n","UTF-8"))
                                 elif command == "PONG":
                                     e = text.split(" ")[1]
                                     if e == server or e == f":{server}":
@@ -514,19 +521,19 @@ def session(connection, client, ip, isssl=False):
                                         property_list[pending]["ping_pending"] = False
                                 elif command == "NICK":
                                     if len(args) == 0:
-                                        connection.sendall(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                     elif text.split(" ")[1] == pending:
                                         pass
                                     else:
                                         pending2 = text.split(" ")[1]
                                         if pending2[0] == ":": pending2 = pending2[1:]
                                         if not isalphanumeric(pending2):
-                                            connection.sendall(bytes(f"{tags()}:{server} 432 {pending} {pending2} :Erroneus nickname\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 432 {pending} {pending2} :Erroneus nickname\r\n","UTF-8"))
                                         elif pending2.lower() in lower_nicks:
-                                            connection.sendall(bytes(f"{tags()}:{server} 433 {pending} {pending2} :Nickname is already in use.\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 433 {pending} {pending2} :Nickname is already in use.\r\n","UTF-8"))
                                         else:
                                             print("Sending nickname change...")
-                                            connection.sendall(bytes(f"{tags()}:{pending}!{rident}@{hostname} NICK {pending2}\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{pending}!{rident}@{hostname} NICK {pending2}\r\n","UTF-8"))
                                             # Broadcast the nickname change
                                             done = []
                                             for i, users in channels_list.items():
@@ -557,7 +564,7 @@ def session(connection, client, ip, isssl=False):
                                             print("Broadcasting nickname change...")
                                 elif command == "PART":
                                     if len(args) == 0:
-                                        connection.sendall(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                     else:
                                         channel = text.split(" ")[1]
                                         for i in channels_list[channel]:
@@ -572,16 +579,16 @@ def session(connection, client, ip, isssl=False):
                                 elif command == "AWAY":
                                     if len(args) == 0:
                                         property_list[pending]["away"] = False
-                                        connection.sendall(bytes(f"{tags()}:{server} 305 {pending} :You are no longer marked as being away\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 305 {pending} :You are no longer marked as being away\r\n","UTF-8"))
                                     else:
                                         reasons = " ".join(args)
                                         if reasons[0] == ":": reasons = reasons[1:]
                                         property_list[pending]["away"] = True
                                         property_list[pending]["reason"] = reasons
-                                        connection.sendall(bytes(f"{tags()}:{server} 306 {pending} :You have been marked as being away\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 306 {pending} :You have been marked as being away\r\n","UTF-8"))
                                 elif command == "WHO":
                                     if len(args) == 0:
-                                        connection.sendall(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                     else:
                                         channel = text.split(" ")[1]
                                         if channel in channels_list:
@@ -590,18 +597,18 @@ def session(connection, client, ip, isssl=False):
                                                 who_user = property_list[i]["username"]
                                                 who_realname = property_list[i]["realname"]
                                                 who_away = "G" if property_list[i]["away"] else "H"
-                                                connection.sendall(bytes(f"{tags()}:{server} 352 {pending} {channel} {who_user} {who_host} {server} {i} {who_away} :0 {who_realname}\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{server} 352 {pending} {channel} {who_user} {who_host} {server} {i} {who_away} :0 {who_realname}\r\n","UTF-8"))
                                         elif channel in nickname_list:
                                             who_host = property_list[channel]["host"]
                                             who_user = property_list[channel]["username"]
                                             who_realname = property_list[channel]["realname"]
                                             who_away = "G" if property_list[channel]["away"] else "H"
-                                            connection.sendall(bytes(f"{tags()}:{server} 352 {pending} * {who_user} {who_host} {server} {channel} {who_away} :0 {who_realname}\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 352 {pending} * {who_user} {who_host} {server} {channel} {who_away} :0 {who_realname}\r\n","UTF-8"))
 
-                                        connection.sendall(bytes(f"{tags()}:{server} 315 {pending} {channel} :End of /WHO list.\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 315 {pending} {channel} :End of /WHO list.\r\n","UTF-8"))
                                 elif command == "WHOIS":
                                     if len(args) == 0:
-                                        connection.sendall(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                     else:
                                         target = text.split(" ")[1]
                                         if target.lower() in lower_nicks:
@@ -620,33 +627,33 @@ def session(connection, client, ip, isssl=False):
                                                 who_flags = property_list[target]["modes"]
                                             except:
                                                 who_flags = None
-                                            connection.sendall(bytes(f"{tags()}:{server} 311 {pending} {target} {who_user} {who_host} * :{who_realname}\r\n","UTF-8"))
-                                            connection.sendall(bytes(f"{tags()}:{server} 312 {pending} {target} {server} :{identifier}\r\n","UTF-8"))
-                                            if "o" in who_flags: connection.sendall(bytes(f":{server} 313 {pending} {target} :is an IRC operator\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 311 {pending} {target} {who_user} {who_host} * :{who_realname}\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 312 {pending} {target} {server} :{identifier}\r\n","UTF-8"))
+                                            if "o" in who_flags: dosend(bytes(f":{server} 313 {pending} {target} :is an IRC operator\r\n","UTF-8"))
                                             who_away = property_list[target]["away"]
                                             if who_away: 
                                                 who_reason = who_away = property_list[target]["reason"]
-                                                connection.sendall(bytes(f"{tags()}:{server} 301 {pending} {target} :{who_reason}\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{server} 301 {pending} {target} :{who_reason}\r\n","UTF-8"))
                                             if who_identified:
-                                                connection.sendall(bytes(f"{tags()}:{server} 330 {pending} {target} {who_identifying} :is logged in as\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{server} 330 {pending} {target} {who_identifying} :is logged in as\r\n","UTF-8"))
                                             if who_ssl:
-                                                connection.sendall(bytes(f"{tags()}:{server} 671 {pending} {target} :is using a secure connection\r\n","UTF-8"))
-                                            #connection.sendall(bytes(f":{server} 317 {pending} {target} {time} :seconds idle\r\n","UTF-8")) # I haven't implemented idle time yet.
+                                                dosend(bytes(f"{tags()}:{server} 671 {pending} {target} :is using a secure connection\r\n","UTF-8"))
+                                            #dosend(bytes(f":{server} 317 {pending} {target} {time} :seconds idle\r\n","UTF-8")) # I haven't implemented idle time yet.
                                             if who_flags != None and who_flags != "iw":
-                                                connection.sendall(bytes(f"{tags()}:{server} 379 {pending} {target} :Is using modes +{who_flags}\r\n","UTF-8"))
-                                            connection.sendall(bytes(f"{tags()}:{server} 318 {pending} {target} :End of /WHOIS list\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{server} 379 {pending} {target} :Is using modes +{who_flags}\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 318 {pending} {target} :End of /WHOIS list\r\n","UTF-8"))
                                         else:
-                                            connection.sendall(bytes(f"{tags()}:{server} 401 {pending} {target} :No such nick/channel\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 401 {pending} {target} :No such nick/channel\r\n","UTF-8"))
                                 elif command == "NAMES":
                                     if len(args) == 0:
-                                        connection.sendall(bytes(f":{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f":{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                     else:
                                         channel = text.split(" ")[1]
                                         if channel in channels_list:
                                                 if pending in channels_list[channel]:
                                                     users = " ".join(channels_list[channel])
-                                                    connection.sendall(bytes(f"{tags()}:{server} 353 {pending} = {channel} :{users}\r\n","UTF-8"))
-                                        connection.sendall(bytes(f"{tags()}:{server} 366 {pending} {channel} :End of /NAMES list.\r\n","UTF-8"))
+                                                    dosend(bytes(f"{tags()}:{server} 353 {pending} = {channel} :{users}\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 366 {pending} {channel} :End of /NAMES list.\r\n","UTF-8"))
                                 elif command == "NOTICE":
                                     if len(args) >= 2:
                                         target = text.split(" ")[1]
@@ -663,9 +670,9 @@ def session(connection, client, ip, isssl=False):
                                         elif target in nickname_list:
                                             nickname_list[target].sendall(bytes(f"{tags_diffclient(target)}:{pending}!{rident}@{hostname} {text}\r\n","UTF-8"))
                                         else:
-                                            connection.sendall(bytes(f"{tags()}:{server} 401 {pending} {target} :No such nick/channel\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 401 {pending} {target} :No such nick/channel\r\n","UTF-8"))
                                     else:
-                                        connection.sendall(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                 elif command == "QUIT":
                                     # Parse the quit message.
                                     done = []
@@ -693,8 +700,8 @@ def session(connection, client, ip, isssl=False):
                                                 print(traceback.format_exc())
                                     # Confirm QUIT and close the socket.
                                     try:
-                                        connection.sendall(bytes(f"{tags()}:{pending}!{rident}@{hostname} {text}\r\n","UTF-8"))
-                                        connection.sendall(bytes(f"ERROR :Closing Link: {hostname} ({msg})\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{pending}!{rident}@{hostname} {text}\r\n","UTF-8"))
+                                        dosend(bytes(f"ERROR :Closing Link: {hostname} ({msg})\r\n","UTF-8"))
                                     finally:
                                         connection.close()
                                         safe_quit = True
@@ -702,29 +709,29 @@ def session(connection, client, ip, isssl=False):
                                 elif command == "MODE":
                                     target = args[0]
                                     if len(args) == 0:
-                                        connection.sendall(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                     elif len(args) == 1:
                                         if args[0] == pending:
                                             yourmodes = property_list[pending]["modes"]
-                                            connection.sendall(bytes(f"{tags()}:{server} 221 {pending} +{yourmodes}\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 221 {pending} +{yourmodes}\r\n","UTF-8"))
                                         elif args[0] in channels_list:
                                             if args[0] in property_list:
                                                 if "modes" in property_list[args[0]]:
                                                     # Get the modes + parameters, then print them out.
                                                     modes = property_list[args[0]]["modes"]
                                                     params = property_list[args[0]]["params"]
-                                                    connection.sendall(bytes(f"{tags()}:{server} 221 {pending} {target} +{modes} {params}\r\n","UTF-8"))
+                                                    dosend(bytes(f"{tags()}:{server} 221 {pending} {target} +{modes} {params}\r\n","UTF-8"))
                                                 else:
                                                     # Default channel mode
-                                                    connection.sendall(bytes(f"{tags()}:{server} 324 {pending} {target} +n\r\n","UTF-8"))
+                                                    dosend(bytes(f"{tags()}:{server} 324 {pending} {target} +n\r\n","UTF-8"))
                                             else:
                                                 # Default channel mode
-                                                connection.sendall(bytes(f"{tags()}:{server} 324 {pending} {target} +n\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{server} 324 {pending} {target} +n\r\n","UTF-8"))
                                         else:
                                             if args[0][0] == "#":
-                                                connection.sendall(bytes(f"{tags()}:{server} 403 {pending} {target} :No such channel\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{server} 403 {pending} {target} :No such channel\r\n","UTF-8"))
                                             else:
-                                                connection.sendall(bytes(f"{tags()}:{server} 505 {pending} :Cant change mode for other users\r\n","UTF-8"))
+                                                dosend(bytes(f"{tags()}:{server} 505 {pending} :Cant change mode for other users\r\n","UTF-8"))
 
                                 elif command == "CATSERV" or (command == "PRIVMSG" and args[0].lower() == "catserv"):
                                     if command == "PRIVMSG":
@@ -732,26 +739,26 @@ def session(connection, client, ip, isssl=False):
                                         if args[0][0] == ":":
                                             args[0] = args[0][1:]
                                     if len(args) == 0:
-                                        connection.sendall(bytes(f":{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f":{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                     elif args[0].upper() == "PULL":
                                         updater = subprocess.run(["git", "pull"], stdout=subprocess.PIPE)
                                         if updater.stdout.decode().strip() == "Already up to date.":
-                                            connection.sendall(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :Codename IRCat is already up-to-date.\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :Codename IRCat is already up-to-date.\r\n","UTF-8"))
                                         else:
-                                            connection.sendall(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :Done, it is recommended to use /RESTART if you're an IRC op\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :Done, it is recommended to use /RESTART if you're an IRC op\r\n","UTF-8"))
                                     elif args[0].upper() == "VERSION":
-                                        connection.sendall(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :Codename IRCat version {__version__}\r\n","UTF-8"))
-                                        connection.sendall(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :This is Codename IRCat's integrated services.\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :Codename IRCat version {__version__}\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :This is Codename IRCat's integrated services.\r\n","UTF-8"))
                                     else:
-                                        connection.sendall(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :CatServ Usage:\r\n","UTF-8"))
-                                        connection.sendall(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :PULL     - Pulls the latest version of Codename IRCat\r\n","UTF-8"))
-                                        connection.sendall(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :VERSION  - Gets the version number of this service.\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :CatServ Usage:\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :PULL     - Pulls the latest version of Codename IRCat\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:CatServ!Meow@IRCatCore NOTICE {pending} :VERSION  - Gets the version number of this service.\r\n","UTF-8"))
                                 elif command == "RESTART":
                                     if "o" in property_list[pending]["modes"]:
                                         global opened
                                         opened = False
                                     else:
-                                        connection.sendall(bytes(f"{tags()}:{server} 481 {pending} :Permission Denied- You're not an IRC operator\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 481 {pending} :Permission Denied- You're not an IRC operator\r\n","UTF-8"))
                                 elif command == "PRIVMSG":
                                     if len(args) >= 2:
                                         target = text.split(" ")[1]
@@ -774,23 +781,23 @@ def session(connection, client, ip, isssl=False):
                                         elif target in nickname_list:
                                             nickname_list[target].sendall(bytes(f"{tags_diffclient(target)}:{pending}!{rident}@{hostname} {text}\r\n","UTF-8"))
                                         else:
-                                            connection.sendall(bytes(f"{tags()}:{server} 401 {pending} {target} :No such nick/channel\r\n","UTF-8"))
+                                            dosend(bytes(f"{tags()}:{server} 401 {pending} {target} :No such nick/channel\r\n","UTF-8"))
                                     else:
-                                        connection.sendall(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
+                                        dosend(bytes(f"{tags()}:{server} 461 {pending} {command} :Not enough parameters\r\n","UTF-8"))
                                 # Ignore empty text
                                 elif text.split(" ")[0] == "":
                                     pass
                                 else:
                                     # Unknown command
                                     cmd = text.split(" ")[0]
-                                    connection.sendall(bytes(f"{tags()}:{server} 421 {pending} {cmd} :Unknown command\r\n","UTF-8"))
+                                    dosend(bytes(f"{tags()}:{server} 421 {pending} {cmd} :Unknown command\r\n","UTF-8"))
                             pendingCommands = ""
                         else:
                             pendingCommands += text
                     textt = ""
-                    connection.sendall(bytes(pendingSend, "UTF-8"))
+                    dosend(bytes(pendingSend, "UTF-8"))
                     pendingSend = ""
-            except (SSL.WantReadError, SSL.WantWriteError, SSL.WantX509LookupError):
+            except (SSL.WantReadError, SSL.WantWriteError, SSL.WantX509LookupError, SSL.SysCallError):
                 print("Skipable error occurred.")
                 pass
             except SSL.ZeroReturnError: