summaryrefslogtreecommitdiff
path: root/src/leap/eip/conductor.py
blob: 11b0358c9db193d6b74942ecfb8711d1ec4e0419 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
"""
stablishes a vpn connection and monitors its state
"""
from __future__ import (division, unicode_literals, print_function)
#import threading
from functools import partial
import logging

from leap.util.coroutines import spawn_and_watch_process

# XXX import eip.config as eipconfig
from leap.eip.config import (get_config, build_ovpn_command,
                             check_or_create_default_vpnconf,
                             check_vpn_keys,
                             EIPNoPkexecAvailable,
                             EIPNoPolkitAuthAgentAvailable,
                             EIPInitNoKeyFileError,
                             EIPInitBadKeyFilePermError)
from leap.eip.vpnwatcher import EIPConnectionStatus, status_watcher
from leap.eip.vpnmanager import OpenVPNManager, ConnectionRefusedError

logger = logging.getLogger(name=__name__)


# TODO Move exceptions to their own module
# eip.exceptions

class EIPNoCommandError(Exception):
    pass


class ConnectionError(Exception):
    """
    generic connection error
    """
    pass


class EIPClientError(Exception):
    """
    base EIPClient exception
    """
    def __str__(self):
        if len(self.args) >= 1:
            return repr(self.args[0])
        else:
            return ConnectionError


class UnrecoverableError(EIPClientError):
    """
    we cannot do anything about it, sorry
    """
    # XXX we should catch this and raise
    # to qtland, so we emit signal
    # to translate whatever kind of error
    # to user-friendly msg in dialog.
    pass

#
# Openvpn related classes
#


class OpenVPNConnection(object):
    """
    All related to invocation
    of the openvpn binary
    """
    # Connection Methods

    def __init__(self, config_file=None,
                 watcher_cb=None, debug=False):
        #XXX FIXME
        #change watcher_cb to line_observer
        """
        :param config_file: configuration file to read from
        :param watcher_cb: callback to be \
called for each line in watched stdout
        :param signal_map: dictionary of signal names and callables \
to be triggered for each one of them.
        :type config_file: str
        :type watcher_cb: function
        :type signal_map: dict
        """
        # XXX get host/port from config
        self.manager = OpenVPNManager()
        self.debug = debug
        #print('conductor:%s' % debug)

        self.config_file = config_file
        self.watcher_cb = watcher_cb
        #self.signal_maps = signal_maps

        self.subp = None
        self.watcher = None

        self.server = None
        self.port = None
        self.proto = None

        self.missing_pkexec = False
        self.missing_auth_agent = False
        self.bad_keyfile_perms = False
        self.missing_vpn_keyfile = False

        self.command = None
        self.args = None

        self.autostart = True
        self._get_or_create_config()
        self._check_vpn_keys()

    def _set_autostart(self):
        config = self.config
        if config.has_option('openvpn', 'autostart'):
            autostart = config.getboolean('openvpn',
                                          'autostart')
            self.autostart = autostart
        else:
            if config.has_option('DEFAULT', 'autostart'):
                autostart = config.getboolean('DEFAULT',
                                              'autostart')
                self.autostart = autostart

    def _set_ovpn_command(self):
        config = self.config
        if config.has_option('openvpn', 'command'):
            commandline = config.get('openvpn', 'command')

            command_split = commandline.split(' ')
            command = command_split[0]
            if len(command_split) > 1:
                args = command_split[1:]
            else:
                args = []

            self.command = command
            self.args = args
        else:
        # no command in config, we build it up.
        # XXX check also for command-line --command flag
            try:
                command, args = build_ovpn_command(config,
                                                   debug=self.debug)
            except EIPNoPolkitAuthAgentAvailable:
                command = args = None
                self.missing_auth_agent = True
            except EIPNoPkexecAvailable:
                command = args = None
                self.missing_pkexec = True

            # XXX if not command, signal error.
            self.command = command
            self.args = args

    def _check_ovpn_config(self):
        """
        checks if there is a default openvpn config.
        if not, it writes one with info from the provider
        definition file
        """
        # TODO
        # - get --with-openvpn-config from opts
        check_or_create_default_vpnconf(self.config)

    def _get_or_create_config(self):
        """
        retrieves the config options from defaults or
        home file, or config file passed in command line.
        populates command and args to be passed to subprocess.
        """
        config = get_config(config_file=self.config_file)
        self.config = config

        self._set_autostart()
        self._set_ovpn_command()
        self._check_ovpn_config()

    def _check_vpn_keys(self):
        """
        checks for correct permissions on vpn keys
        """
        try:
            check_vpn_keys(self.config)
        except EIPInitNoKeyFileError:
            self.missing_vpn_keyfile = True
        except EIPInitBadKeyFilePermError:
            logger.error('error while checking vpn keys')
            self.bad_keyfile_perms = True

    def _launch_openvpn(self):
        """
        invocation of openvpn binaries in a subprocess.
        """
        #XXX TODO:
        #deprecate watcher_cb,
        #use _only_ signal_maps instead

        if self.watcher_cb is not None:
            linewrite_callback = self.watcher_cb
        else:
            #XXX get logger instead
            linewrite_callback = lambda line: print('watcher: %s' % line)

        observers = (linewrite_callback,
                     partial(status_watcher, self.status))
        subp, watcher = spawn_and_watch_process(
            self.command,
            self.args,
            observers=observers)
        self.subp = subp
        self.watcher = watcher

        #conn_result = self.status.CONNECTED
        #return conn_result

    def _try_connection(self):
        """
        attempts to connect
        """
        if self.command is None:
            raise EIPNoCommandError
        if self.subp is not None:
            print('cowardly refusing to launch subprocess again')
            return
        self._launch_openvpn()

    def cleanup(self):
        """
        terminates child subprocess
        """
        if self.subp:
            self.subp.terminate()


class EIPConductor(OpenVPNConnection):
    """
    Manages the execution of the OpenVPN process, auto starts, monitors the
    network connection, handles configuration, fixes leaky hosts, handles
    errors, etc.
    Preferences will be stored via the Storage API. (TBD)
    Status updates (connected, bandwidth, etc) are signaled to the GUI.
    """

    def __init__(self, *args, **kwargs):
        self.settingsfile = kwargs.get('settingsfile', None)
        self.logfile = kwargs.get('logfile', None)
        self.error_queue = []
        self.desired_con_state = None  # ???

        status_signals = kwargs.pop('status_signals', None)
        self.status = EIPConnectionStatus(callbacks=status_signals)

        super(EIPConductor, self).__init__(*args, **kwargs)

    def connect(self):
        """
        entry point for connection process
        """
        self.manager.forget_errors()
        self._try_connection()
        # XXX should capture errors here?

    def disconnect(self):
        """
        disconnects client
        """
        self._disconnect()
        self.status.change_to(self.status.DISCONNECTED)

    def poll_connection_state(self):
        """
        """
        try:
            state = self.manager.get_connection_state()
        except ConnectionRefusedError:
            # connection refused. might be not ready yet.
            return
        if not state:
            return
        (ts, status_step,
         ok, ip, remote) = state
        self.status.set_vpn_state(status_step)
        status_step = self.status.get_readable_status()
        return (ts, status_step, ok, ip, remote)

    def get_icon_name(self):
        """
        get icon name from status object
        """
        return self.status.get_state_icon()

    #
    # private methods
    #

    def _disconnect(self):
        """
        private method for disconnecting
        """
        if self.subp is not None:
            self.subp.terminate()
            self.subp = None
        # XXX signal state changes! :)

    def _is_alive(self):
        """
        don't know yet
        """
        pass

    def _connect(self):
        """
        entry point for connection cascade methods.
        """
        #conn_result = ConState.DISCONNECTED
        try:
            conn_result = self._try_connection()
        except UnrecoverableError as except_msg:
            logger.error("FATAL: %s" % unicode(except_msg))
            conn_result = self.status.UNRECOVERABLE
        except Exception as except_msg:
            self.error_queue.append(except_msg)
            logger.error("Failed Connection: %s" %
                         unicode(except_msg))
        return conn_result