/mandos/trunk

# -*- mode: python; after-save-hook: (lambda () (let ((command (if (fboundp 'file-local-name) (file-local-name (buffer-file-name)) (or (file-remote-p (buffer-file-name) 'localname) (buffer-file-name))))) (if (= (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (format "%s --check" (shell-quote-argument command)) nil "*Test*")) 0) (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w))) (progn (with-current-buffer "*Test*" (compilation-mode)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); coding: utf-8 -*-

#

# Mandos server - give out binary blobs to connecting clients.

# "AvahiService" class, and some lines in "main".

#

# Everything else is

#

# This file is part of Mandos.

#

import collections

import codecs

import unittest

 

import dbus

import dbus.service

 

if sys.version_info.major == 2:

    __metaclass__ = type

 

# Show warnings by default

if not sys.warnoptions:

            # No value found

            SO_BINDTODEVICE = None

 

if sys.version_info < (3, 2):

    configparser.Configparser = configparser.SafeConfigParser

 

stored_state_file = "clients.pickle"

 

logger = logging.getLogger()

            output = subprocess.check_output(["gpgconf"])

            for line in output.splitlines():

                name, text, path = line.split(b":")

                    self.gpg = path

                    break

        except OSError as e:

                          '--force-mdc',

                          '--quiet']

        # Only GPG version 1 has the --no-use-agent option.

            self.gnupgargs.append("--no-use-agent")

 

    def __enter__(self):

class AvahiServiceToSyslog(AvahiService):

    def rename(self, *args, **kwargs):

        """Add the new name to the syslog messages"""

        syslogger.setFormatter(logging.Formatter(

            'Mandos ({}) [%(process)d]: %(levelname)s: %(message)s'

            .format(self.name)))

 

        x509_crt_fmt_t = ctypes.c_int

 

        pubkey_init = _library.gnutls_pubkey_init

        pubkey_init.argtypes = [ctypes.POINTER(pubkey_t)]

        pubkey_init.restype = _error_code

        pubkey_deinit.argtypes = [pubkey_t]

        pubkey_deinit.restype = None

    else:

 

        openpgp_crt_init = _library.gnutls_openpgp_crt_init

        openpgp_crt_init.argtypes = [ctypes.POINTER(openpgp_crt_t)]

                                       openpgp_crt_fmt_t]

        openpgp_crt_import.restype = _error_code

 

        openpgp_crt_verify_self.restype = _error_code

 

        openpgp_crt_deinit = _library.gnutls_openpgp_crt_deinit

        if self.checker_initiator_tag is not None:

            GLib.source_remove(self.checker_initiator_tag)

        self.checker_initiator_tag = GLib.timeout_add(

            self.start_checker)

        # Schedule a disable() when 'timeout' has passed

        if self.disable_initiator_tag is not None:

        # Read return code from connection (see call_pipe)

        returncode = connection.recv()

        connection.close()

        self.checker_callback_tag = None

        self.checker = None

 

        if self.checker is None:

            # Escape attributes for the shell

            escaped_attrs = {

                for attr in self.runtime_expansions}

            try:

                command = self.checker_command % escaped_attrs

                raise ValueError("Byte arrays not supported for non-"

                                 "'ay' signature {!r}"

                                 .format(prop._dbus_signature))

        prop(value)

 

    @dbus.service.method(dbus.PROPERTIES_IFACE,

        buf = ctypes.create_string_buffer(32)

        buf_len = ctypes.c_size_t(len(buf))

        # Get the key ID from the raw public key into the buffer

        # Deinit the certificate

        gnutls.pubkey_deinit(pubkey)

 

            address = request[3]

 

            for c in self.clients.values():

                    continue

                if key_id and c.key_id == key_id:

                    client = c

        if command == 'getattr':

            attrname = request[1]

            if isinstance(client_object.__getattribute__(attrname),

                parent_pipe.send(('function', ))

            else:

                parent_pipe.send((

def rfc3339_duration_to_delta(duration):

    """Parse an RFC 3339 "duration" and return a datetime.timedelta

 

    """

 

    # Parsing an RFC 3339 duration with regular expressions is not

def string_to_delta(interval):

    """Parse a string and return a datetime.timedelta

 

    """

 

    try:

                             if isinstance(s, bytes)

                             else s) for s in

                            value["client_structure"]]

                            if isinstance(value[k], bytes):

                                value[k] = value[k].decode("utf-8")

                        if "key_id" not in value:

                        for key, value in

                        bytes_old_client_settings.items()}

                    del bytes_old_client_settings

                    for value in old_client_settings.values():

            os.remove(stored_state_path)

        except IOError as e:

            if e.errno == errno.ENOENT: