/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to mandos

  • Committer: teddy at recompile
  • Date: 2019-12-04 23:46:59 UTC
  • mto: This revision was merged to the branch mainline in revision 396.
  • Revision ID: teddy@recompile.se-20191204234659-m4u7bxnjrns6d3fc
Simplification of Python 3 compatibility code

Apply previously-made change in mandos and mandos-ctl also to
mandos-monitor.

* mandos-monitor: Set "__metaclass__ = type" globally for Python 2,
  and remove inheriting from "object" in all places possible.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mandos
1
 
#!/usr/bin/python
 
1
#!/usr/bin/python3 -bI
2
2
# -*- 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 -*-
3
3
#
4
4
# Mandos server - give out binary blobs to connecting clients.
91
91
 
92
92
if sys.version_info.major == 2:
93
93
    __metaclass__ = type
 
94
    str = unicode
 
95
 
 
96
# Show warnings by default
 
97
if not sys.warnoptions:
 
98
    import warnings
 
99
    warnings.simplefilter("default")
94
100
 
95
101
# Try to find the value of SO_BINDTODEVICE:
96
102
try:
117
123
            # No value found
118
124
            SO_BINDTODEVICE = None
119
125
 
120
 
if sys.version_info.major == 2:
121
 
    str = unicode
122
 
 
123
126
if sys.version_info < (3, 2):
124
127
    configparser.Configparser = configparser.SafeConfigParser
125
128
 
126
 
version = "1.8.8"
 
129
version = "1.8.9"
127
130
stored_state_file = "clients.pickle"
128
131
 
129
132
logger = logging.getLogger()
 
133
logging.captureWarnings(True)   # Show warnings via the logging system
130
134
syslogger = None
131
135
 
132
136
try:
197
201
            output = subprocess.check_output(["gpgconf"])
198
202
            for line in output.splitlines():
199
203
                name, text, path = line.split(b":")
200
 
                if name == "gpg":
 
204
                if name == b"gpg":
201
205
                    self.gpg = path
202
206
                    break
203
207
        except OSError as e:
208
212
                          '--force-mdc',
209
213
                          '--quiet']
210
214
        # Only GPG version 1 has the --no-use-agent option.
211
 
        if self.gpg == "gpg" or self.gpg.endswith("/gpg"):
 
215
        if self.gpg == b"gpg" or self.gpg.endswith(b"/gpg"):
212
216
            self.gnupgargs.append("--no-use-agent")
213
217
 
214
218
    def __enter__(self):
1047
1051
        # Read return code from connection (see call_pipe)
1048
1052
        returncode = connection.recv()
1049
1053
        connection.close()
1050
 
        self.checker.join()
 
1054
        if self.checker is not None:
 
1055
            self.checker.join()
1051
1056
        self.checker_callback_tag = None
1052
1057
        self.checker = None
1053
1058
 
1144
1149
                kwargs=popen_args)
1145
1150
            self.checker.start()
1146
1151
            self.checker_callback_tag = GLib.io_add_watch(
1147
 
                pipe[0].fileno(), GLib.IO_IN,
 
1152
                GLib.IOChannel.unix_new(pipe[0].fileno()),
 
1153
                GLib.PRIORITY_DEFAULT, GLib.IO_IN,
1148
1154
                self.checker_callback, pipe[0], command)
1149
1155
        # Re-run this periodically if run by GLib.timeout_add
1150
1156
        return True
1405
1411
                raise ValueError("Byte arrays not supported for non-"
1406
1412
                                 "'ay' signature {!r}"
1407
1413
                                 .format(prop._dbus_signature))
1408
 
            value = dbus.ByteArray(b''.join(chr(byte)
1409
 
                                            for byte in value))
 
1414
            value = dbus.ByteArray(bytes(value))
1410
1415
        prop(value)
1411
1416
 
1412
1417
    @dbus.service.method(dbus.PROPERTIES_IFACE,
2674
2679
    def add_pipe(self, parent_pipe, proc):
2675
2680
        # Call "handle_ipc" for both data and EOF events
2676
2681
        GLib.io_add_watch(
2677
 
            parent_pipe.fileno(),
2678
 
            GLib.IO_IN | GLib.IO_HUP,
 
2682
            GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2683
            GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2679
2684
            functools.partial(self.handle_ipc,
2680
2685
                              parent_pipe=parent_pipe,
2681
2686
                              proc=proc))
2719
2724
                return False
2720
2725
 
2721
2726
            GLib.io_add_watch(
2722
 
                parent_pipe.fileno(),
2723
 
                GLib.IO_IN | GLib.IO_HUP,
 
2727
                GLib.IOChannel.unix_new(parent_pipe.fileno()),
 
2728
                GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_HUP,
2724
2729
                functools.partial(self.handle_ipc,
2725
2730
                                  parent_pipe=parent_pipe,
2726
2731
                                  proc=proc,
2758
2763
def rfc3339_duration_to_delta(duration):
2759
2764
    """Parse an RFC 3339 "duration" and return a datetime.timedelta
2760
2765
 
2761
 
    >>> rfc3339_duration_to_delta("P7D")
2762
 
    datetime.timedelta(7)
2763
 
    >>> rfc3339_duration_to_delta("PT60S")
2764
 
    datetime.timedelta(0, 60)
2765
 
    >>> rfc3339_duration_to_delta("PT60M")
2766
 
    datetime.timedelta(0, 3600)
2767
 
    >>> rfc3339_duration_to_delta("PT24H")
2768
 
    datetime.timedelta(1)
2769
 
    >>> rfc3339_duration_to_delta("P1W")
2770
 
    datetime.timedelta(7)
2771
 
    >>> rfc3339_duration_to_delta("PT5M30S")
2772
 
    datetime.timedelta(0, 330)
2773
 
    >>> rfc3339_duration_to_delta("P1DT3M20S")
2774
 
    datetime.timedelta(1, 200)
 
2766
    >>> rfc3339_duration_to_delta("P7D") == datetime.timedelta(7)
 
2767
    True
 
2768
    >>> rfc3339_duration_to_delta("PT60S") == datetime.timedelta(0, 60)
 
2769
    True
 
2770
    >>> rfc3339_duration_to_delta("PT60M") == datetime.timedelta(0, 3600)
 
2771
    True
 
2772
    >>> rfc3339_duration_to_delta("PT24H") == datetime.timedelta(1)
 
2773
    True
 
2774
    >>> rfc3339_duration_to_delta("P1W") == datetime.timedelta(7)
 
2775
    True
 
2776
    >>> rfc3339_duration_to_delta("PT5M30S") == datetime.timedelta(0, 330)
 
2777
    True
 
2778
    >>> rfc3339_duration_to_delta("P1DT3M20S") == datetime.timedelta(1, 200)
 
2779
    True
2775
2780
    """
2776
2781
 
2777
2782
    # Parsing an RFC 3339 duration with regular expressions is not
2857
2862
def string_to_delta(interval):
2858
2863
    """Parse a string and return a datetime.timedelta
2859
2864
 
2860
 
    >>> string_to_delta('7d')
2861
 
    datetime.timedelta(7)
2862
 
    >>> string_to_delta('60s')
2863
 
    datetime.timedelta(0, 60)
2864
 
    >>> string_to_delta('60m')
2865
 
    datetime.timedelta(0, 3600)
2866
 
    >>> string_to_delta('24h')
2867
 
    datetime.timedelta(1)
2868
 
    >>> string_to_delta('1w')
2869
 
    datetime.timedelta(7)
2870
 
    >>> string_to_delta('5m 30s')
2871
 
    datetime.timedelta(0, 330)
 
2865
    >>> string_to_delta('7d') == datetime.timedelta(7)
 
2866
    True
 
2867
    >>> string_to_delta('60s') == datetime.timedelta(0, 60)
 
2868
    True
 
2869
    >>> string_to_delta('60m') == datetime.timedelta(0, 3600)
 
2870
    True
 
2871
    >>> string_to_delta('24h') == datetime.timedelta(1)
 
2872
    True
 
2873
    >>> string_to_delta('1w') == datetime.timedelta(7)
 
2874
    True
 
2875
    >>> string_to_delta('5m 30s') == datetime.timedelta(0, 330)
 
2876
    True
2872
2877
    """
2873
2878
 
2874
2879
    try:
3244
3249
                             if isinstance(s, bytes)
3245
3250
                             else s) for s in
3246
3251
                            value["client_structure"]]
3247
 
                        # .name & .host
3248
 
                        for k in ("name", "host"):
 
3252
                        # .name, .host, and .checker_command
 
3253
                        for k in ("name", "host", "checker_command"):
3249
3254
                            if isinstance(value[k], bytes):
3250
3255
                                value[k] = value[k].decode("utf-8")
3251
3256
                        if "key_id" not in value:
3261
3266
                        for key, value in
3262
3267
                        bytes_old_client_settings.items()}
3263
3268
                    del bytes_old_client_settings
3264
 
                    # .host
 
3269
                    # .host and .checker_command
3265
3270
                    for value in old_client_settings.values():
3266
 
                        if isinstance(value["host"], bytes):
3267
 
                            value["host"] = (value["host"]
3268
 
                                             .decode("utf-8"))
 
3271
                        for attribute in ("host", "checker_command"):
 
3272
                            if isinstance(value[attribute], bytes):
 
3273
                                value[attribute] = (value[attribute]
 
3274
                                                    .decode("utf-8"))
3269
3275
            os.remove(stored_state_path)
3270
3276
        except IOError as e:
3271
3277
            if e.errno == errno.ENOENT:
3596
3602
                sys.exit(1)
3597
3603
            # End of Avahi example code
3598
3604
 
3599
 
        GLib.io_add_watch(tcp_server.fileno(), GLib.IO_IN,
3600
 
                          lambda *args, **kwargs:
3601
 
                          (tcp_server.handle_request
3602
 
                           (*args[2:], **kwargs) or True))
 
3605
        GLib.io_add_watch(
 
3606
            GLib.IOChannel.unix_new(tcp_server.fileno()),
 
3607
            GLib.PRIORITY_DEFAULT, GLib.IO_IN,
 
3608
            lambda *args, **kwargs: (tcp_server.handle_request
 
3609
                                     (*args[2:], **kwargs) or True))
3603
3610
 
3604
3611
        logger.debug("Starting main loop")
3605
3612
        main_loop.run()