printerxpl-forge 6.2.0__py3-none-any.whl

src/utils/helper.py

@@ -0,0 +1,732 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+# Author    : Andre Henrique (@mrhenrike)
+# GitHub    : https://github.com/mrhenrike
+# LinkedIn  : https://linkedin.com/in/mrhenrike
+# X/Twitter : https://x.com/mrhenrike
+
+from __future__ import print_function
+
+# python standard library
+from socket import socket
+import socket as socket_module
+import sys
+import os
+import re
+import stat
+import time
+import datetime
+import traceback
+
+# third party modules
+try:  # unicode monkeypatch for windoze (only needed on Python 2 / legacy Windows)
+    import win_unicode_console
+    win_unicode_console.enable()
+except Exception:
+    pass  # Optional module – not required on Python 3
+
+try:  # os independent color support (preferred)
+    from colorama import init, Fore, Back, Style
+    init(autoreset=False)  # required for ANSI on Windows via colorama
+except ImportError:
+    # Fallback ANSI – works on Linux, macOS, BSD, Android/Termux,
+    # and on Windows 10 1511+ (ConEmu, Windows Terminal, VS Code terminal).
+    # On legacy Windows consoles (cmd.exe < Win10) ANSI isn't supported,
+    # but colorama should always be installed via requirements.txt.
+    _ANSI = sys.stdout.isatty()  # only emit colors when output is a tty
+
+    class Back():  # type: ignore[no-redef]
+        BLUE    = '\x1b[44m' if _ANSI else ''
+        CYAN    = '\x1b[46m' if _ANSI else ''
+        GREEN   = '\x1b[42m' if _ANSI else ''
+        MAGENTA = '\x1b[45m' if _ANSI else ''
+        RED     = '\x1b[41m' if _ANSI else ''
+        YELLOW  = '\x1b[43m' if _ANSI else ''
+
+    class Fore():  # type: ignore[no-redef]
+        BLUE    = '\x1b[34m' if _ANSI else ''
+        CYAN    = '\x1b[36m' if _ANSI else ''
+        MAGENTA = '\x1b[35m' if _ANSI else ''
+        YELLOW  = '\x1b[33m' if _ANSI else ''
+        RED     = '\x1b[31m' if _ANSI else ''
+
+    class Style():  # type: ignore[no-redef]
+        DIM       = '\x1b[2m'  if _ANSI else ''
+        BRIGHT    = '\x1b[1m'  if _ANSI else ''
+        RESET_ALL = '\x1b[0m'  if _ANSI else ''
+        NORMAL    = '\x1b[22m' if _ANSI else ''
+
+    _msg = "Install 'colorama' for best color support: pip install colorama"
+    print(Back.RED + _msg + Style.RESET_ALL)
+
+# ----------------------------------------------------------------------
+
+# return first item of list or alternative
+
+
+def item(mylist, alternative=""):
+    return next(iter(mylist), alternative)
+
+# split list into chunks of equal size
+
+
+def chunks(l, n):
+    for i in range(0, len(l), n):
+        yield l[i:i+n]
+
+# ----------------------------------------------------------------------
+
+
+class log():
+    # open logfile
+    def open(self, filename):
+        try:
+            return open(filename, mode='wb')
+        except IOError as e:
+            output().errmsg("Cannot open logfile", e)
+            return None
+
+    # write raw data to logfile
+    def write(self, logfile, data):
+        # logfile open and data non-empty
+        if logfile and data:
+            try:
+                logfile.write(data)
+            except IOError as e:
+                output().errmsg("Cannot log", e)
+
+    # write comment to logfile
+    def comment(self, logfile, line):
+        comment = "%" + ("[ " + line + " ]").center(72, '-')
+        self.write(logfile, os.linesep + comment + os.linesep)
+
+    # close logfile
+    def close(self, logfile):
+        try:
+            logfile.close()
+        except IOError as e:
+            output().errmsg("Cannot close logfile", e)
+
+# ----------------------------------------------------------------------
+
+
+class output():
+    # show message in cyan color
+    def message(self, msg):    
+        print(f"\033[1;36m{msg}\033[0m")
+    
+    # show red message
+    def red(self, msg):
+        print(f"\033[1;31m{msg}\033[0m")
+    
+    # show green message
+    def green(self, msg):
+        print(f"\033[1;32m{msg}\033[0m")
+    
+    # show blue message
+    def blue(self, msg):
+        print(f"\033[1;34m{msg}\033[0m")
+
+    # show yellow message
+    def yellow(self, msg):
+        print(f"\033[1;33m{msg}\033[0m")
+    
+    # show banner
+    def intro(self, quiet):
+        if not quiet:
+            print(Style.BRIGHT + Fore.CYAN + "PrinterXPL-Forge - Advanced Printer Penetration Testing" + Style.RESET_ALL)
+            print(Style.DIM + "Printer Reaper - a tool to discover, fuzz and exploit printers" + Style.RESET_ALL)
+    
+    def header(self, msg, eol=None):
+        if msg:
+            print(Back.BLUE + msg + Style.RESET_ALL, end=eol)
+        sys.stdout.flush()
+
+    # show send commands (debug mode)
+    def send(self, str, mode):
+        if str:
+            print(Back.CYAN + str + Style.RESET_ALL)
+        if str and mode == 'hex':
+            print(Fore.CYAN + conv().hex(str, ':') + Style.RESET_ALL)
+
+    # show recv commands (debug mode)
+    def recv(self, str, mode):
+        if str:
+            print(Back.MAGENTA + str + Style.RESET_ALL)
+        if str and mode == 'hex':
+            print(Fore.MAGENTA + conv().hex(str, ':') + Style.RESET_ALL)
+
+    # show information
+    def info(self, msg, eol=None):
+        if msg:
+            print(Back.BLUE + msg + Style.RESET_ALL, end=eol)
+        sys.stdout.flush()
+
+    # show raw data
+    def raw(self, msg, eol=None):
+        if msg:
+            print(Fore.YELLOW + msg + Style.RESET_ALL, end=eol)
+        sys.stdout.flush()
+
+    # show chit-chat
+    def chitchat(self, msg, eol=None):
+        if msg:
+            print(Style.DIM + msg + Style.RESET_ALL, end=eol)
+        sys.stdout.flush()
+
+    # show warning message
+    def warning(self, msg):
+        if msg:
+            print(Back.RED + msg + Style.RESET_ALL)
+
+    # show green message
+    def green(self, msg):
+        if msg:
+            print(Back.GREEN + msg + Style.RESET_ALL)
+
+    # show error message
+    def errmsg(self, msg, info=""):
+        info = str(info).strip()
+        if info:  # monkeypatch to make python error message less ugly
+            info = item(re.findall(r'Errno -?\d+\] (.*)', info),
+                        '') or info.splitlines()[-1]
+            info = Style.RESET_ALL + Style.DIM + \
+                " (" + info.strip('<>') + ")" + Style.RESET_ALL
+        if msg:
+            print(Fore.RED + Style.BRIGHT + msg + info + Style.RESET_ALL)
+
+    # show printer and status
+    def discover(self, entry):
+        """Display a discovered printer entry.
+
+        Accepts either:
+          - a 2-tuple (ipaddr, fields_tuple) where fields_tuple has at least
+            (device, uptime, status, prstat) as first four elements, or
+          - a 2-tuple (label, tuple_of_labels) used as table header.
+        """
+        ipaddr, fields = entry
+        # Normalize: accept tuple with any length, use first 4 fields
+        if isinstance(fields, (tuple, list)):
+            fields = list(fields)
+        else:
+            fields = [str(fields)]
+        # Pad to at least 4 elements
+        while len(fields) < 4:
+            fields.append('?')
+        device, uptime, status = str(fields[0]), str(fields[1]), str(fields[2])
+        prstat = str(fields[3]) if len(fields) > 3 else '?'
+
+        ipaddr = output().strfit(str(ipaddr), 15)
+        device = output().strfit(device, 27)
+        uptime = output().strfit(uptime,  8)
+        status = output().strfit(status, 23)
+        if device.strip() != 'device':
+            device = Style.BRIGHT + device + Style.NORMAL
+        if prstat == '1':
+            status = Back.GREEN + status + Back.BLUE   # unknown
+        if prstat == '2':
+            status = Back.GREEN + status + Back.BLUE   # running
+        if prstat == '3':
+            status = Back.YELLOW + status + Back.BLUE  # warning
+        if prstat == '4':
+            status = Back.GREEN + status + Back.BLUE   # testing
+        if prstat == '5':
+            status = Back.RED + status + Back.BLUE     # down
+        line = (ipaddr, device, uptime, status)
+        output().info('%-15s  %-27s  %-8s  %-23s' % line)
+
+    # recursively list files
+    def psfind(self, name):
+        vol = Style.DIM + Fore.YELLOW + \
+            item(re.findall("^(%.*%)", name)) + Style.RESET_ALL
+        name = Fore.YELLOW + const.SEP + \
+            re.sub("^(%.*%)", '', name) + Style.RESET_ALL
+        print("%s %s" % (vol, name))
+
+    # show directory listing
+    def psdir(self, isdir, size, mtime, name, otime):
+        otime = Style.DIM + "(created " + otime + ")" + Style.RESET_ALL
+        vol = Style.DIM + Fore.YELLOW + \
+            item(re.findall("^(%.*%)", name)) + Style.RESET_ALL
+        # remove volume information from filename
+        name = re.sub("^(%.*%)", '', name)
+        name = Style.BRIGHT + Fore.BLUE + name + Style.RESET_ALL if isdir else name
+        if isdir:
+            print("d %8s   %s %s %s %s" % (size, mtime, otime, vol, name))
+        else:
+            print("- %8s   %s %s %s %s" % (size, mtime, otime, vol, name))
+
+    # show directory listing
+    def pjldir(self, name, size):
+        name = name if size else Style.BRIGHT + Fore.BLUE + name + Style.RESET_ALL
+        if size:
+            print("- %8s   %s" % (size, name))
+        else:
+            print("d %8s   %s" % ("-", name))
+
+    # show directory listing
+    def pcldir(self, size, mtime, id, name):
+        id = Style.DIM + "(macro id: " + id + ")" + Style.RESET_ALL
+        print("- %8s   %s %s %s" % (size, mtime, id, name))
+
+    # show output from df
+    def df(self, args):
+        self.info("%-16s %-11s %-11s %-9s %-10s %-8s %-9s %-10s %-10s" % args)
+
+    # show fuzzing results
+    def fuzzed(self, path, cmd, opt):
+        opt1, opt2, opt3 = opt
+        if isinstance(opt1, bool):
+            opt1 = (Back.GREEN + str(opt1) + Back.BLUE + "   ")\
+                if opt1 else (Back.RED + str(opt1) + Back.BLUE + "  ")
+        if isinstance(opt2, bool):
+            opt2 = (Back.GREEN + str(opt2) + Back.BLUE + "   ")\
+                if opt2 else (Back.RED + str(opt2) + Back.BLUE + "  ")
+        if isinstance(opt3, bool):
+            opt3 = (Back.GREEN + str(opt3) + Back.BLUE + "   ")\
+                if opt3 else (Back.RED + str(opt3) + Back.BLUE + "  ")
+        opt = opt1, opt2, opt3
+        self.info("%-35s %-12s %-7s %-7s %-7s" % ((path, cmd) + opt))
+
+    # show captured jobs
+    def joblist(self, xxx_todo_changeme1):
+        (date, size, user, name, soft) = xxx_todo_changeme1
+        user = output().strfit(user, 13)
+        name = output().strfit(name, 22)
+        soft = output().strfit(soft, 20)
+        line = (date, size, user, name, soft)
+        output().info('%-12s %5s  %-13s  %-22s  %-20s' % line)
+
+    # show ascii only
+    def ascii(self, data):
+        data = re.sub(r"(\x00){10}", "\x00", data)  # shorten nullbyte streams
+        data = re.sub(r"([^ -~])", ".", data)  # replace non-printable chars
+        self.raw(data, "")
+
+    # show binary dump
+    def dump(self, data):
+        # experimental regex to match sensitive strings like passwords
+        data = re.sub(
+            r"[\x00-\x06,\x1e]([!-~]{6,}?(?!\\0A))\x00{16}", "START" + r"\1" + "STOP", data)
+        data = re.sub(r"\00+", "\x00", data)  # ignore nullbyte streams
+        data = re.sub(r"(\x00){10}", "\x00", data)  # ignore nullbyte streams
+        data = re.sub(r"([\x00-\x1f,\x7f-\xff])", ".", data)
+        data = re.sub(r"START([!-~]{6,}?)STOP", Style.RESET_ALL +
+                      Back.BLUE + r"\1" + Style.RESET_ALL + Fore.YELLOW, data)
+        self.raw(data, "")
+
+    # dump ps dictionary
+    def psdict(self, data, indent=''):
+        # Python 3 handles UTF-8 natively; no reload needed
+        # convert list to dictionary with indices as keys
+        if isinstance(data, list):
+            data = dict(enumerate(data))
+        # data now is expected to be a dictionary
+        if len(list(data.keys())) > 0:
+            last = sorted(data.keys())[-1]
+        for key, val in sorted(data.items()):
+            type = val['type'].replace('type', '')
+            value = val['value']
+            perms = val['perms']
+            recursion = False
+            # current entry is a dictionary
+            if isinstance(value, dict):
+                value, recursion = '', True
+            # current entry is a ps array
+            if isinstance(value, list):
+                try:  # array contains only atomic values
+                    value = ' '.join(x['value'] for x in value)
+                except:  # array contains further list or dict
+                    # value = sum(val['value'], [])
+                    value, recursion = '', True
+            # value = value.encode('ascii', errors='ignore')
+            node = '┬' if recursion else '─'
+            edge = indent + ('└' if key == last else '├')
+            # output current node in dictionary
+            print("%s%s %-3s  %-11s  %-30s  %s" %
+                  (edge, node, perms, type, key, value))
+            if recursion:  # ...
+                self.psdict(val['value'], indent +
+                            (' ' if key == last else '│'))
+
+    # show some information
+    def psonly(self):
+        self.chitchat(
+            "Info: This only affects jobs printed by a PostScript driver")
+
+    # countdown from sec to zero
+    def countdown(self, msg, sec, cmd):
+        try:
+            sys.stdout.write(msg)
+            for x in reversed(list(range(1, sec+1))):
+                sys.stdout.write(" " + str(x))
+                sys.stdout.flush()
+                time.sleep(1)
+            print(" KABOOM!")
+            return True
+        except KeyboardInterrupt:
+            print("")
+
+    # show horizontal line
+    def hline(self, len=72):
+        self.info("─" * len)
+
+    # crop/pad string to fixed length
+    def strfit(self, str, max):
+        str = str.strip() or "-"
+        if str.startswith('(') and str.endswith(')'):
+            str = str[1:-1]
+        # crop long strings
+        if len(str) > max:
+            str = str[0:max-1] + "…"
+        # pad short strings
+        return str.ljust(max)
+
+# ----------------------------------------------------------------------
+
+
+class conv():
+    # return current time
+    def now(self):
+        return int(time.time())
+
+    # return time elapsed since unix epoch
+    def elapsed(self, date, div=1, short=False):
+        date = str(datetime.timedelta(seconds=int(date)/div))
+        return date.split(",")[0] if short else date
+
+    # return date dependent on current year
+    def lsdate(self, date):
+        year1 = datetime.datetime.now().year
+        year2 = datetime.datetime.fromtimestamp(date).year
+        # %e (space-padded day) is POSIX-only; %d (zero-padded) is portable.
+        # On Windows, %e is not supported – use %d unconditionally for safety.
+        pdate = '%b %d '
+        fmt = pdate + "%H:%M" if year1 == year2 else pdate + " %Y"
+        return time.strftime(fmt, time.localtime(date))
+
+    # return date plus/minus given seconds
+    def timediff(self, seconds):
+        return self.lsdate(self.now() + self.int(seconds) / 1000)
+
+    # convert size to human readable value
+    def filesize(self, num):
+        num = self.int(num)
+        for unit in ['B', 'K', 'M']:
+            if abs(num) < 1024.0:
+                return (("%4.1f%s" if unit == 'M' else "%4.0f%s") % (num, unit))
+            num /= 1024.0
+
+    # remove carriage return from line breaks
+    def nstrip(self, data):
+        return re.sub(r'\r\n', '\n', data)
+
+    # convert string to hexadecimal
+    def hex(self, data, sep=''):
+        return sep.join("{:02x}".format(ord(c)) for c in data)
+
+    # convert to ascii character
+    def chr(self, num):
+        return chr(self.int(num))
+
+    # convert to integer or zero
+    def int(self, num):
+        try:
+            n = int(num)
+        except ValueError:
+            n = 0
+        return n
+
+# ----------------------------------------------------------------------
+
+
+class file():
+    # read from local file
+    def read(self, path):
+        try:
+            with open(path, mode='rb') as f:
+                data = f.read()
+            f.close()
+            return data
+        except IOError as e:
+            output().errmsg("Cannot read from file", e)
+
+    # write to local file
+    def write(self, path, data, m='wb'):
+        try:
+            with open(path, mode=m) as f:
+                f.write(data)
+            f.close()
+        except IOError as e:
+            output().errmsg("Cannot write to file", e)
+
+    # append to local file
+    def append(self, path, data):
+        # Ensure data is in bytes format
+        if isinstance(data, str):
+            data = data.encode('utf-8')
+        self.write(path, data, 'ab+')
+
+# ----------------------------------------------------------------------
+
+
+class conn(object):
+    # create debug connection object
+    def __init__(self, mode, debug, quiet):
+        self.mode = mode
+        self.debug = debug
+        self.quiet = quiet
+        self._file = None
+        self._sock = socket()
+
+    # open connection
+    def open(self, target, port=9100):
+        try:
+            # target is a character device
+            if os.path.exists(target) \
+                    and stat.S_ISCHR(os.stat(target).st_mode):
+                self._file = os.open(target, os.O_RDWR)
+                return self
+            # treat target as ipv4 socket
+            else:
+                m = re.search('^(.+?):([0-9]+)$', target)
+                if m:
+                    [target, port] = m.groups()
+                    port = int(port)
+                # If no port specified in target, use default port parameter
+
+                self._sock.connect((target, port))
+                return self
+        except Exception as e:
+            output().errmsg(f"Failed to connect to {target}: {str(e)}")
+            return None
+
+    # close connection
+    def close(self, *arg):
+        # close file descriptor
+        if self._file:
+            os.close(self._file)
+        # close inet socket
+        else:
+            self._sock.close()
+
+    # set timeout
+    def timeout(self, *arg):
+        self._sock.settimeout(*arg)
+
+    # send data
+    def send(self, data):
+        if self.debug:
+            output().send(self.beautify(data), self.debug)
+        # send data to device
+        if self._file:
+            return os.write(self._file, data)
+        # send data to socket
+        elif self._sock:
+            if not isinstance(data, bytes):
+                data = data.encode()
+            try:
+                return self._sock.sendall(data)
+            except (ConnectionResetError, BrokenPipeError, OSError) as e:
+                output().errmsg("Connection lost while sending data")
+                return None
+            except Exception as e:
+                output().errmsg(f"Send error: {str(e)}")
+                return None
+
+    # receive data
+    def recv(self, bytes):
+        # receive data from device
+        if self._file:
+            data = os.read(self._file, bytes).decode()
+        # receive data from socket
+        else:
+            try:
+                data = self._sock.recv(bytes).decode()
+            except (ConnectionResetError, BrokenPipeError, OSError) as e:
+                output().errmsg("Connection lost while receiving data")
+                return ""
+            except Exception as e:
+                output().errmsg(f"Receive error: {str(e)}")
+                return ""
+        # output recv data when in debug mode
+        if self.debug:
+            output().recv(self.beautify(data), self.debug)
+        return data
+
+    # so-many-seconds-passed bool condition
+    def past(self, seconds, watchdog):
+        return int(watchdog * 100) % (seconds * 100) == 0
+
+    # connection-feels-slow bool condition
+    def slow(self, limit, watchdog):
+        return not (self.quiet or self.debug) and watchdog > limit
+
+    # receive data until a delimiter is reached
+    def recv_until(self, delimiter, fb=True, crop=True, binary=False):
+        data = ""
+        sleep = 0.01  # pause in recv loop
+        limit = 3.0  # max watchdog overrun
+        wd = 0.0  # watchdog timeout counter
+        max_timeout = 30.0  # maximum timeout in seconds
+        r = re.compile(delimiter, re.DOTALL)
+        s = re.compile("^\x04?\x0d?\x0a?" + delimiter, re.DOTALL)
+        wd_old = 0
+        bytes_received = 0
+        
+        # Set socket timeout to prevent infinite blocking (30 seconds as requested)
+        if hasattr(self, '_sock') and self._sock:
+            self._sock.settimeout(30.0)  # 30 second timeout
+        
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        while not r.search(data):
+            # Check for maximum timeout
+            if wd > max_timeout:
+                output().errmsg("Maximum timeout reached", "timeout exceeded")
+                break
+                
+            try:
+                new_data = self.recv(4096)  # receive actual data
+                if new_data is None or new_data == "":
+                    # No data received, check if we should continue waiting
+                    if wd > limit and bytes_received == 0:
+                        output().errmsg("No data received within timeout period")
+                        break
+                    time.sleep(sleep)
+                    wd += sleep
+                    continue
+                    
+                data += new_data
+                bytes_received = len(data)
+                
+            except socket_module.timeout:
+                output().errmsg("Socket timeout while receiving data")
+                break
+            except Exception as e:
+                output().errmsg(f"Error receiving data: {str(e)}")
+                break
+                
+            if self.past(limit, wd):
+                wd_old, bytes_received = wd, len(data)
+            wd += sleep       # workaround for endless loop w/o socket timeout
+            time.sleep(sleep)  # happens on some devices - python socket error?
+            # timeout plus it seems we are not receiving data anymore
+            if hasattr(self, '_sock') and self._sock and wd > self._sock.gettimeout() and wd >= wd_old + limit:
+                if len(data) == bytes_received:
+                    output().errmsg("Receiving data failed", "watchdog timeout")
+                    break
+            # visual feedback on large/slow data transfers
+            if self.slow(limit, wd) and self.past(0.1, wd) and len(data) > 0:
+                output().chitchat(str(len(data)) + " bytes received\r", '')
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        # clear current line from 'so-many bytes received' chit-chat
+        if self.slow(limit, wd):
+            output().chitchat(' ' * 24 + "\r", '')
+        # warn if feedback expected but response empty (= delimiter only)
+        # this also happens for data received out of order (e.g. brother)
+        if fb and s.search(data):
+            output().chitchat("No data received.")
+        # remove delimiter itself from data
+        if crop:
+            data = r.sub('', data)
+        # crop uel sequence at the beginning
+        data = re.sub(r'(^' + const.UEL + ')', '', data)
+        '''
+    ┌─────────────────────────────────────────────────────────────────────────┐
+    │ delimiters -- note that carriage return (0d) is optional in ps/pjl      │
+    ├─────────────────────────┬─────────────────────────┬─────────────────────┤
+    │                         │           PJL           │      PostScript     │
+    ├─────────────────────────┼─────────┬───────────────┼────────┬────────────┤
+    │                         │ send    │ recv          │ send   │ recv       │
+    ├─────────────────────────┼─────────┼───────────────┼────────┼────────────┤
+    │ normal commands (ascii) │ 0d? 0a  │ 0d+ 0a 0c 04? │ 0d? 0a │ 0d? 0a 04? │
+    ├─────────────────────────┼─────────┼───────────────┼────────┼────────────┤
+    │ file transfers (binary) │ 0d? 0a  │ 0c            │ 0d? 0a │ -          │
+    └─────────────────────────┴─────────┴───────────────┴────────┴────────────┘
+    '''
+        # crop end-of-transmission chars
+        if self.mode == 'ps':
+            data = re.sub(r'^\x04', '', data)
+            if not binary:
+                data = re.sub(r'\x0d?\x0a\x04?$', '', data)
+        else:  # pjl and pcl mode
+            if binary:
+                data = re.sub(r'\x0c$', '', data)
+            else:
+                data = re.sub(r'\x0d+\x0a\x0c\x04?$', '', data)
+        # crop whitespaces/newline as feedback
+        if not binary:
+            data = data.strip()
+        return data
+
+    # beautify debug output
+    def beautify(self, data):
+        # remove sent/recv uel sequences
+        """if isinstance(data, bytes):
+          try:
+            data = data.decode()
+          except UnicodeDecodeError:
+            data = "[PDF bytes]"""
+        data = re.sub(r'' + const.UEL, '', str(data))
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        if self.mode == 'ps':
+            # remove sent postscript header
+            data = re.sub(r'' + re.escape(const.PS_HEADER), '', data)
+            # remove sent postscript hack
+            data = re.sub(r'' + re.escape(const.PS_IOHACK), '', data)
+            # remove sent delimiter token
+            data = re.sub(r'\(DELIMITER\d+\\n\) print flush\n', '', data)
+            # remove recv delimiter token
+            data = re.sub(r'DELIMITER\d+', '', data)
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        elif self.mode == 'pjl':
+            # remove sent/recv delimiter token
+            data = re.sub(r'@PJL ECHO\s+DELIMITER\d+', '', data)
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        elif self.mode == 'pcl':
+            # remove sent delimiter token
+            data = re.sub(r'\x1b\*s-\d+X', '', data)
+            # remove recv delimiter token
+            data = re.sub(r'PCL\x0d?\x0a?\x0c?ECHO -\d+', '', data)
+            # replace sent escape sequences
+            data = re.sub(r'(' + const.ESC + ')', '<Esc>', data)
+            pass
+        # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        # replace lineseps in between
+        data = re.sub(r'\x0d?\x0a?\x0c', os.linesep, data)
+        # remove eot/eof sequences
+        data = data.strip(const.EOF)
+        return data
+
+# ----------------------------------------------------------------------
+
+
+class const():  # define constants
+    SEP = '/'  # use posixoid path separator
+    EOL = '\r\n'  # line feed || carriage return
+    ESC = '\x1b'  # used to start escape sequences
+    UEL = ESC + '%-12345X'  # universal exit language
+    EOF = EOL + '\x0c\x04'  # potential end of file chars
+    DELIMITER = "DELIMITER"  # delimiter marking end of response
+    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    PS_CATCH = r'%%\[ (.*)\]%%'
+    PS_ERROR = r'%%\[ Error: (.*)\]%%'
+    PS_FLUSH = r'%%\[ Flushing: (.*)\]%%'
+    PS_PROMPT = '>'  # TBD: could be derived from PS command 'prompt'
+    PS_HEADER = '@PJL ENTER LANGUAGE = POSTSCRIPT\n%!\n'
+    PS_GLOBAL = 'true 0 startjob pop\n'  # 'serverdict begin 0 exitserver'
+    PS_SUPER = '\n1183615869 internaldict /superexec get exec'
+    PS_NOHOOK = '/nohook true def\n'
+    PS_IOHACK = '/print {(%stdout) (w) file dup 3 2 roll writestring flushfile} def\n'\
+        '/== {128 string cvs print (\\n) print} def\n'
+    PCL_HEADER = '@PJL ENTER LANGUAGE = PCL' + EOL + ESC
+    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    SUPERBLOCK = '31337'  # define super macro id to contain pclfs table
+    BLOCKRANGE = list(range(10000, 20000))  # use those macros for file content
+    FILE_EXISTS = -1  # file size to be returned if file/dir size unknown
+    NONEXISTENT = -2  # file size to be returned if a file does not exist
+    # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    PS_VOL = ''  # no default volume in ps (read: any, write: first)
+    PJL_VOL = '0:' + SEP  # default pjl volume name || path separator