Rename sploit package to nsploit

Rename all affected files, references to file paths, and module imports
within the code.  Since this line of development represents a fork from
the original sploit, a name change is seen as necessary to distinguish
the projects, as well as allow them to be installed side by side.

What does the "n" mean?  Great question!  You can think of it as meaning
"new sploit" if you want, though that's not quite intended.  The name is
simply distinct and easy to pronounce.  I had originally settled on
"msploit" (something along the lines of "Malf's sploit"), but this name
is too close to "metasploit" for me - and N is right next to it on the
keyboard.

Signed-off-by: Malfurious <m@lfurio.us>

1 files changed, 0 insertions, 205 deletions

diff --git a/sploit/comm/comm.py b/sploit/comm/comm.py
deleted file mode 100644
index 3bc448e..0000000
--- a/sploit/comm/comm.py
+++ /dev/null
@@ -1,205 +0,0 @@
-import subprocess
-import tempfile
-import os
-import sys
-import select
-
-from sploit.until import bind
-from sploit.util.log import *
-
-class Comm:
-    logonread = True
-    logonwrite = False
-    flushonwrite = True
-    readonwrite = False
-    timeout = 250 # milliseconds
-    last = None # result of last discrete read
-
-    def __init__(self, backend):
-        self.back = backend
-
-    def shutdown(self):
-        try:
-            self.back.stdout.close()
-        except BrokenPipeError:
-            pass
-
-    def read(self, size=-1):
-        if size < 0:
-            return self.readall_nonblock()
-        elif size == 0:
-            data = b''
-        else:
-            data = self.back.stdin.read(size)
-            if(data == b''):
-                raise BrokenPipeError('Tried to read on broken pipe')
-        if self.logonread : ilog(data, file=sys.stdout, color=NORMAL)
-        self.last = data
-        return data
-
-    def readline(self):
-        data = self.back.stdin.readline()
-        if(data == b''):
-            raise BrokenPipeError('Tried to read on broken pipe')
-        if data.endswith(b'\n'):
-            data = data[:-1]
-        if self.logonread : ilog(data, file=sys.stdout, color=NORMAL)
-        self.last = data
-        return data
-
-    def readall(self):
-        data = b''
-        try:
-            for line in self.back.stdin:
-                tolog = (line[:-1] if line.endswith(b'\n') else line)
-                if self.logonread : ilog(tolog, file=sys.stdout, color=NORMAL)
-                data += line
-        except KeyboardInterrupt:
-            pass
-        self.last = data
-        return data
-
-    def readall_nonblock(self):
-        try:
-            data = b''
-            os.set_blocking(self.back.stdin.fileno(), False)
-            poll = select.poll()
-            poll.register(self.back.stdin, select.POLLIN)
-            while True:
-                poll.poll(self.timeout)
-                d = self.readall()
-                if len(d) == 0:
-                    self.last = data
-                    return data
-                data += d
-        finally:
-            os.set_blocking(self.back.stdin.fileno(), True)
-
-    def readuntil(self, pred, /, *args, **kwargs):
-        data = b''
-        pred = bind(pred, *args, **kwargs)
-        l = self.logonread
-        self.logonread = False
-        try:
-            while(True):
-                data += self.read(1)
-                if(pred(data)):
-                    break
-        finally:
-            self.logonread = l
-        if self.logonread : ilog(data, file=sys.stdout, color=NORMAL)
-        self.last = data
-        return data
-
-    def readlineuntil(self, pred, /, *args, **kwargs):
-        dataarr = []
-        pred = bind(pred, *args, **kwargs)
-        while(True):
-            dataarr.append(self.readline())
-            if(pred(dataarr)):
-                break
-        self.last = dataarr
-        return dataarr
-
-    def write(self, data):
-        self.back.stdout.write(data)
-        if self.flushonwrite : self.back.stdout.flush()
-        if self.logonwrite : ilog(data, file=sys.stdout, color=ALT)
-        if self.readonwrite : self.readall_nonblock()
-
-    def writeline(self, data=b''):
-        self.write(data + b'\n')
-
-    def interact(self):
-        stdin = sys.stdin.buffer
-        event = select.POLLIN
-
-        def readall_stdin():
-            try:
-                os.set_blocking(stdin.fileno(), False)
-                for line in stdin:
-                    self.write(line)
-            finally:
-                os.set_blocking(stdin.fileno(), True)
-
-        readtable = {
-                self.back.stdin.fileno(): self.readall_nonblock,
-                stdin.fileno(): readall_stdin,
-        }
-
-        try:
-            ilog("<--Interact Mode-->")
-            l = self.logonread
-            self.logonread = True
-
-            poll = select.poll()
-            poll.register(self.back.stdin, event)
-            poll.register(stdin, event)
-
-            readtable[self.back.stdin.fileno()]()
-            while True:
-                for fd, e in poll.poll(self.timeout):
-                    if not e & event: return
-                    readtable[fd]()
-        except KeyboardInterrupt:
-            pass
-        finally:
-            self.logonread = l
-            ilog("<--Interact Mode Done-->")
-
-def popen(cmdline=''):
-    io = Comm((Process(cmdline.split()) if len(cmdline) > 0 else Pipes()))
-    io.readall_nonblock()
-    io.readonwrite = True
-    return io
-
-class Process:
-    def __init__(self, args):
-        ilog(f"Running: {' '.join(args)}")
-        self.proc = subprocess.Popen(args,
-                stdin=subprocess.PIPE,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                preexec_fn=lambda : os.setpgrp())
-        ilog(f"PID: {self.proc.pid}")
-        self.stdin = self.proc.stdout
-        self.stdout = self.proc.stdin
-
-    def __del__(self):
-        if getattr(self, 'proc', None) == None : return
-        if(self.proc.poll() != None):
-            return
-        try:
-            ilog("Waiting on Target Program to End...")
-            ilog("Press Ctrl+C to Forcefully Kill It...")
-            self.proc.wait()
-        except KeyboardInterrupt:
-            self.proc.kill()
-
-class Pipes:
-    def __init__(self, tmp=None):
-        if(tmp == None):
-            self.dir = tempfile.TemporaryDirectory()
-            dirname = self.dir.name
-        else:
-            if(not os.path.exists(tmp)):
-                os.mkdir(tmp)
-            dirname = tmp
-        self.pathin = os.path.join(dirname, "in")
-        self.pathout = os.path.join(dirname, "out")
-        os.mkfifo(self.pathin)
-        os.mkfifo(self.pathout)
-        ilog("Waiting on Target to Connect...", file=sys.stdout)
-        ilog(f"<{self.pathin} >{self.pathout}", file=sys.stdout)
-        self.stdout = open(self.pathin, "wb")
-        self.stdin = open(self.pathout, "rb")
-        ilog("Connected!")
-
-    def __del__(self):
-        try:
-            if getattr(self,'stdout',None) : self.stdout.close()
-            if getattr(self,'stdin',None) : self.stdin.close()
-        except BrokenPipeError:
-            pass
-        if getattr(self,'pathin',None) and os.path.exists(self.pathin) : os.unlink(self.pathin)
-        if getattr(self,'pathout',None) and os.path.exists(self.pathout) : os.unlink(self.pathout)