ccso.py

#!/usr/bin/env python

# © 2019 ported to python 2/3 by Michael Lazar
# © 1994-1997,2013 by Jeffrey C. Ollie
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or (at
# your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import re
import crypt
import socket
from subprocess import Popen, PIPE

version = '0.4'

digits = re.compile(b'^-?[0-9]+$')


class CSSOError(Exception):
    pass


class Encryptor(object):
    """Class that packages up the CCSO password encryption. This allows
    logging into the server without passing the password over the network
    in the clear."""

    ROTORSZ = 256
    MASK = 255
    b32 = 4294967296
    b31 = 2147483648

    def __init__(self, password):
        """Uses the password to initialize the encryptor state."""

        self.n1 = 0
        self.n2 = 0

        self.t1 = list(range(self.ROTORSZ))
        self.t2 = [0] * self.ROTORSZ
        self.t3 = [0] * self.ROTORSZ

        buffer = crypt.crypt(password, password)

        buffer_length = len(buffer)
        if buffer_length <= 0:
            raise CSSOError('no password supplied?')

        seed = 123

        for i in range(buffer_length):
            seed = (seed * ord(buffer[i]) + i) % self.b32

        for i in range(self.ROTORSZ):
            seed = (5 * seed + ord(buffer[i % buffer_length])) % self.b32
            if seed >= self.b31:
                sign = -1
                signed_seed = seed - self.b32
            else:
                sign = 1
                signed_seed = seed
            random = sign * int(abs(signed_seed) % 65521)
            k = self.ROTORSZ - 1 - i
            ic = (random & self.MASK) % (k + 1)
            random = (random >> 8) & self.MASK
            temp = self.t1[k]
            self.t1[k] = self.t1[ic]
            self.t1[ic] = temp
            if self.t3[k] != 0:
                continue
            if k == 0:
                raise CSSOError('[0] can\t %% by zero. k=%i' % k)
            ic = (random & self.MASK) % k
            while self.t3[ic] != 0:
                if k == 0:
                    raise CSSOError('[1] can\'t %% by zero. k=%i' % k)
                ic = (ic + 1) % k
            self.t3[k] = ic
            self.t3[ic] = k
        for i in range(self.ROTORSZ):
            self.t2[self.t1[i] & self.MASK] = i

    def _encode(self, cr):
        """Translate a list of bytes to a printable string."""
        data = self._encode_byte(len(cr))

        ts = cr[:3]
        cr = cr[3:]
        while len(ts) == 3:
            c1 = int(ts[0] / 4)
            c2 = int((ts[0] % 4) * 16 + (int(ts[1] / 16) % 16))
            c3 = int((ts[1] % 16) * 4 + (int(ts[2] / 64) % 4))
            c4 = int((ts[2] % 64))
            data = data + self._encode_byte(c1) + self._encode_byte(c2) + \
                self._encode_byte(c3) + self._encode_byte(c4)
            ts = cr[:3]
            cr = cr[3:]

        return data

    def _encode_byte(self, c):
        """Translate a byte to a printable character."""
        return chr((c % 64) + ord('#'))

    def encrypt(self, plain_str):
        """Encrypt a plaintext string."""
        cr = []

        for i in range(len(plain_str)):
            x = ord(plain_str[i]) + self.n1
            x = self.t1[x & self.MASK] + self.n2
            x = self.t3[x & self.MASK] - self.n2
            x = self.t2[x & self.MASK] - self.n1
            x = x & self.MASK
            cr.append(x)
            self.n1 = (self.n1 + 1) % self.ROTORSZ
            if self.n1 == 0:
                self.n2 = (self.n2 + 1) % self.ROTORSZ
        crypt_str = self._encode(cr)
        return crypt_str


class CCSO(object):
    """Superclass that implements the generic behavior for interacting with
    the CCSO qi (query interpreter). Instances of this class should not be
    created directly. Instead, a subclass should be created that adds
    'read_line' and 'write_line' methods."""

    def __init__(self):
        """Generic initialization. Makes sure that qi is in the state that
        we want and gathers some information about the installation."""
        self.alias = None
        self.siteinfo = {}
        self.write_line(b'set verbose=off')
        response = self._get_response()
        while response[0] < 200:
            response = self._get_response()
        if response[0] != 200:
            raise CSSOError(response[0], response[3])
        self.write_line(b'siteinfo')
        response = self._get_response()
        while response[0] < 200:
            if response[0] == -200:
                self.siteinfo[response[2]] = response[3]
            response = self._get_response()
        if b'mailbox' not in self.siteinfo:
            self.siteinfo[b'mailbox'] = b'email'

    def write_line(self, data):
        raise NotImplementedError

    def read_line(self):
        raise NotImplementedError

    def _get_response(self):
        """Private method that reads and parses the response from qi. See
        the documentation that comes with qi for a more complete description
        of the format of responses."""
        line = b''
        while not line:
            line = self.read_line()
        i1 = line.find(b':')
        if i1 == -1:
            raise CSSOError('response does not match format "%s"' % line)
        result_code = int(line[:i1])
        i2 = line.find(b':', i1 + 1)
        if i2 == -1:
            entry_index = None
            field_name = None
            text = line[i1 + 1:].strip()
        else:
            if digits.match(line[i1 + 1:i2].strip()) != -1:
                entry_index = int(line[i1 + 1:i2])
                i3 = line.find(b':', i2 + 1)
                if i3 == -1:
                    field_name = None
                    text = line[i2 + 1:].strip()
                else:
                    field_name = line[i2 + 1:i3].strip()
                    text = line[i3 + 1:].strip()
            else:
                entry_index = None
                field_name = line[i1 + 1:i2].strip()
                text = line[i2 + 1:].strip()
        return result_code, entry_index, field_name, text

    def query(self, data):
        """Send a query to qi. The string that is passed should be exactly
        as you would send it to qi, minus the 'query' keyword and and 'return'
        clause. The 'query' keyword and 'return all' are added
        automatically."""
        q = b'query ' + data.strip() + b' return all'
        self.write_line(q)
        currentindex = None
        currententry = {}
        lastfield = None
        entries = []
        response = self._get_response()
        while response[0] < 200:
            if response[0] == -200:
                if response[1] != currentindex:
                    if currentindex is not None:
                        entries.append(currententry)
                    currententry = {}
                    currentindex = response[1]
                    lastfield = None
                if response[2] == b'':
                    currententry[lastfield] = currententry[lastfield] + \
                                              b'\n' + \
                                              response[3]
                else:
                    currententry[response[2]] = response[3]
                    lastfield = response[2]
            response = self._get_response()
        if response[0] >= 300:
            raise CSSOError(response[0], response[3])
        entries.append(currententry)
        return entries

    def login(self, alias, password):
        """Log into the server so that updates can be made. Passwords are
        not sent across the network in the clear."""
        q = b'login ' + alias.strip()
        self.write_line(q)
        response = self._get_response()
        while response[0] < 200:
            response = self._get_response()
        if response[0] == 200:
            self.alias = alias
            return alias
        elif response[0] == 301:
            c = Encryptor(password)
            length, ciphertext = c.encrypt(response[3])
            self.write_line(b'answer ' + ciphertext)
            response = self._get_response()
            while response[0] < 200:
                response = self._get_response()
            if response[0] >= 400:
                raise CSSOError(response[0], response[3])
            self.alias = alias
            return alias
        else:
            raise CSSOError(response[0], response[3])

    def logout(self):
        """Log out of the server so that changes can no longer be made
        to the database."""
        q = b'logout'
        self.write_line(q)
        response = self._get_response()
        while response[0] < 200:
            response = self._get_response()
        if response[0] >= 400:
            raise CSSOError(response[0], response[3])
        self.alias = None

    def othercmd(self, data):
        """Send a raw command to qi and return the response as a list of
        4-tuples."""
        q = data.strip()
        self.write_line(q)
        responses = []
        response = self._get_response()
        while response[0] < 200:
            responses.append(response)
            response = self._get_response()
        responses.append(response)
        return responses

    def get_email(self, data):
        """Return a list (name, email address) tuples that result from
        the supplied query.
        The algorithm for get_email is taken from messages posted to
        the info-ph mailing list by Steve Dorner <sdorner@qualcomm.com>
        and Scott M. Ballew <smb@pern.cc.purdue.edu>.
        Message-ID's: <9411102104.AA14717@pern.cc.purdue.edu>
                      <v03000728aae842fd09b2@[192.17.16.12]>
                          <v0300073baae6af3eb78f@[192.17.16.12]>
        """
        mailbox = self.siteinfo[b'mailbox']
        mailfield = self.siteinfo[b'mailfield']
        responses = self.query(data)
        addresses = []
        if self.siteinfo.get(b'maildomain', b'') != b'':
            maildomain = self.siteinfo[b'maildomain']
            for entry in responses:
                if entry.get(mailbox, b'') != b'':
                    addresses.append({
                        'name': entry[b'name'],
                        'email': (entry[mailfield] + b'@' + maildomain)})
        else:
            for entry in responses:
                if entry.get(mailfield, b'') != b'':
                    addresses.append({
                        'name': entry[b'name'],
                        'email': entry[mailfield]})
        return addresses

    def close(self):
        """Send the quit command to qi. The subclass will have to worry
        about closing any sockets, files, or pipes."""
        self.write_line(b'quit')


class Local(CCSO):
    """Subclass of CCSO that implements a connection to qi running as
    a subprocess on the local system. This has the benefit that you
    don't need to log in to make changes to the database."""

    def __init__(self, command='/usr/local/sbin/qi'):
        p = Popen(command + ' -q', shell=True, stdin=PIPE, stdout=PIPE,
                  close_fds=True)
        self.read, self.write = (p.stdin, p.stdout)
        CCSO.__init__(self)

    def read_line(self):
        return self.read.readline()

    def write_line(self, line):
        self.write.write(line + b'\n')
        self.write.flush()

    def close(self):
        CCSO.close(self)
        self.write.close()
        self.read.close()


class Network(CCSO):
    """Subclass of CCSO that implements a connection over the network to
    qi running out of inetd on a remote system."""

    def __init__(self, host='localhost', port=105):
        self.host = host
        self.port = port

        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((self.host, self.port))
        CCSO.__init__(self)

    def read_line(self):
        line = b''
        ch = self.sock.recv(1)
        while ch != b'\n':
            line = line + ch
            ch = self.sock.recv(1)
        if line[-2:] == b'\r\n':
            return line[:-2] + b'\n'
        else:
            return line

    def write_line(self, line):
        self.sock.send(line + b'\r\n')

    def close(self):
        CCSO.close(self)
        self.sock.close()