127
105
max_renames: integer; maximum number of renames
128
106
rename_count: integer; counter so we only rename after collisions
129
107
a sensible number of times
130
group: D-Bus Entry Group
132
bus: dbus.SystemBus()
134
109
def __init__(self, interface = avahi.IF_UNSPEC, name = None,
135
servicetype = None, port = None, TXT = None,
136
domain = u"", host = u"", max_renames = 32768,
137
protocol = avahi.PROTO_UNSPEC, bus = None):
110
type = None, port = None, TXT = None, domain = "",
111
host = "", max_renames = 32768):
138
112
self.interface = interface
140
self.type = servicetype
142
self.TXT = TXT if TXT is not None else []
143
120
self.domain = domain
145
122
self.rename_count = 0
146
123
self.max_renames = max_renames
147
self.protocol = protocol
148
self.group = None # our entry group
151
124
def rename(self):
152
125
"""Derived from the Avahi example code"""
153
126
if self.rename_count >= self.max_renames:
154
127
logger.critical(u"No suitable Zeroconf service name found"
155
128
u" after %i retries, exiting.",
157
raise AvahiServiceError(u"Too many renames")
158
self.name = self.server.GetAlternativeServiceName(self.name)
130
raise AvahiServiceError("Too many renames")
131
self.name = server.GetAlternativeServiceName(self.name)
159
132
logger.info(u"Changing Zeroconf service name to %r ...",
161
syslogger.setFormatter(logging.Formatter
162
(u'Mandos (%s) [%%(process)d]:'
163
u' %%(levelname)s: %%(message)s'
134
syslogger.setFormatter(logging.Formatter\
135
('Mandos (%s): %%(levelname)s:'
136
' %%(message)s' % self.name))
167
139
self.rename_count += 1
168
140
def remove(self):
169
141
"""Derived from the Avahi example code"""
170
if self.group is not None:
142
if group is not None:
173
145
"""Derived from the Avahi example code"""
174
if self.group is None:
175
self.group = dbus.Interface(
176
self.bus.get_object(avahi.DBUS_NAME,
177
self.server.EntryGroupNew()),
178
avahi.DBUS_INTERFACE_ENTRY_GROUP)
179
self.group.connect_to_signal('StateChanged',
181
.entry_group_state_changed)
148
group = dbus.Interface\
149
(bus.get_object(avahi.DBUS_NAME,
150
server.EntryGroupNew()),
151
avahi.DBUS_INTERFACE_ENTRY_GROUP)
152
group.connect_to_signal('StateChanged',
153
entry_group_state_changed)
182
154
logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",
183
self.name, self.type)
184
self.group.AddService(
187
dbus.UInt32(0), # flags
188
self.name, self.type,
189
self.domain, self.host,
190
dbus.UInt16(self.port),
191
avahi.string_array_to_txt_array(self.TXT))
193
def entry_group_state_changed(self, state, error):
194
"""Derived from the Avahi example code"""
195
logger.debug(u"Avahi state change: %i", state)
197
if state == avahi.ENTRY_GROUP_ESTABLISHED:
198
logger.debug(u"Zeroconf service established.")
199
elif state == avahi.ENTRY_GROUP_COLLISION:
200
logger.warning(u"Zeroconf service name collision.")
202
elif state == avahi.ENTRY_GROUP_FAILURE:
203
logger.critical(u"Avahi: Error in group state changed %s",
205
raise AvahiGroupError(u"State changed: %s"
208
"""Derived from the Avahi example code"""
209
if self.group is not None:
212
def server_state_changed(self, state):
213
"""Derived from the Avahi example code"""
214
if state == avahi.SERVER_COLLISION:
215
logger.error(u"Zeroconf server name collision")
217
elif state == avahi.SERVER_RUNNING:
220
"""Derived from the Avahi example code"""
221
if self.server is None:
222
self.server = dbus.Interface(
223
self.bus.get_object(avahi.DBUS_NAME,
224
avahi.DBUS_PATH_SERVER),
225
avahi.DBUS_INTERFACE_SERVER)
226
self.server.connect_to_signal(u"StateChanged",
227
self.server_state_changed)
228
self.server_state_changed(self.server.GetState())
155
service.name, service.type)
157
self.interface, # interface
158
avahi.PROTO_INET6, # protocol
159
dbus.UInt32(0), # flags
160
self.name, self.type,
161
self.domain, self.host,
162
dbus.UInt16(self.port),
163
avahi.string_array_to_txt_array(self.TXT))
166
# From the Avahi example code:
167
group = None # our entry group
168
# End of Avahi example code
231
171
class Client(object):
232
172
"""A representation of a client host served by this server.
235
name: string; from the config file, used in log messages and
174
name: string; from the config file, used in log messages
237
175
fingerprint: string (40 or 32 hexadecimal digits); used to
238
176
uniquely identify the client
239
secret: bytestring; sent verbatim (over TLS) to client
240
host: string; available for use by the checker command
241
created: datetime.datetime(); (UTC) object creation
242
last_enabled: datetime.datetime(); (UTC)
244
last_checked_ok: datetime.datetime(); (UTC) or None
245
timeout: datetime.timedelta(); How long from last_checked_ok
246
until this client is disabled
247
interval: datetime.timedelta(); How often to start a new checker
248
disable_hook: If set, called by disable() as disable_hook(self)
249
checker: subprocess.Popen(); a running checker process used
250
to see if the client lives.
251
'None' if no process is running.
177
secret: bytestring; sent verbatim (over TLS) to client
178
host: string; available for use by the checker command
179
created: datetime.datetime(); object creation, not client host
180
last_checked_ok: datetime.datetime() or None if not yet checked OK
181
timeout: datetime.timedelta(); How long from last_checked_ok
182
until this client is invalid
183
interval: datetime.timedelta(); How often to start a new checker
184
stop_hook: If set, called by stop() as stop_hook(self)
185
checker: subprocess.Popen(); a running checker process used
186
to see if the client lives.
187
'None' if no process is running.
252
188
checker_initiator_tag: a gobject event source tag, or None
253
disable_initiator_tag: - '' -
189
stop_initiator_tag: - '' -
254
190
checker_callback_tag: - '' -
255
191
checker_command: string; External command which is run to check if
256
192
client lives. %() expansions are done at
257
193
runtime with vars(self) as dict, so that for
258
194
instance %(name)s can be used in the command.
259
current_checker_command: string; current running checker_command
260
changesignal: File descriptor; written to on object change
261
_reset: File descriptor; for flushing changesignal
262
delay: datetime.timedelta(); how long to wait for approval/secret
263
approved: bool(); None if not yet approved/disapproved
196
_timeout: Real variable for 'timeout'
197
_interval: Real variable for 'interval'
198
_timeout_milliseconds: Used when calling gobject.timeout_add()
199
_interval_milliseconds: - '' -
267
def _timedelta_to_milliseconds(td):
268
"Convert a datetime.timedelta() to milliseconds"
269
return ((td.days * 24 * 60 * 60 * 1000)
270
+ (td.seconds * 1000)
271
+ (td.microseconds // 1000))
273
def timeout_milliseconds(self):
274
"Return the 'timeout' attribute in milliseconds"
275
return self._timedelta_to_milliseconds(self.timeout)
277
def interval_milliseconds(self):
278
"Return the 'interval' attribute in milliseconds"
279
return self._timedelta_to_milliseconds(self.interval)
281
def __init__(self, name = None, disable_hook=None, config=None):
201
def _set_timeout(self, timeout):
202
"Setter function for 'timeout' attribute"
203
self._timeout = timeout
204
self._timeout_milliseconds = ((self.timeout.days
205
* 24 * 60 * 60 * 1000)
206
+ (self.timeout.seconds * 1000)
207
+ (self.timeout.microseconds
209
timeout = property(lambda self: self._timeout,
212
def _set_interval(self, interval):
213
"Setter function for 'interval' attribute"
214
self._interval = interval
215
self._interval_milliseconds = ((self.interval.days
216
* 24 * 60 * 60 * 1000)
217
+ (self.interval.seconds
219
+ (self.interval.microseconds
221
interval = property(lambda self: self._interval,
224
def __init__(self, name = None, stop_hook=None, config={}):
282
225
"""Note: the 'checker' key in 'config' sets the
283
226
'checker_command' attribute and *not* the 'checker'
288
229
logger.debug(u"Creating client %r", self.name)
289
230
# Uppercase and remove spaces from fingerprint for later
290
231
# comparison purposes with return value from the fingerprint()
292
self.fingerprint = (config[u"fingerprint"].upper()
233
self.fingerprint = config["fingerprint"].upper()\
294
235
logger.debug(u" Fingerprint: %s", self.fingerprint)
295
if u"secret" in config:
296
self._secret = config[u"secret"].decode(u"base64")
297
elif u"secfile" in config:
298
with open(os.path.expanduser(os.path.expandvars
299
(config[u"secfile"])),
301
self._secret = secfile.read()
236
if "secret" in config:
237
self.secret = config["secret"].decode(u"base64")
238
elif "secfile" in config:
239
sf = open(config["secfile"])
240
self.secret = sf.read()
303
#XXX Need to allow secret on demand!
304
243
raise TypeError(u"No secret or secfile for client %s"
306
self.host = config.get(u"host", u"")
307
self.created = datetime.datetime.utcnow()
309
self.last_enabled = None
245
self.host = config.get("host", "")
246
self.created = datetime.datetime.now()
310
247
self.last_checked_ok = None
311
self.timeout = string_to_delta(config[u"timeout"])
312
self.interval = string_to_delta(config[u"interval"])
313
self.disable_hook = disable_hook
248
self.timeout = string_to_delta(config["timeout"])
249
self.interval = string_to_delta(config["interval"])
250
self.stop_hook = stop_hook
314
251
self.checker = None
315
252
self.checker_initiator_tag = None
316
self.disable_initiator_tag = None
253
self.stop_initiator_tag = None
317
254
self.checker_callback_tag = None
318
self.checker_command = config[u"checker"]
319
self.current_checker_command = None
320
self.last_connect = None
321
self.changesignal, self._reset = os.pipe()
322
self._approved = None #XXX should be based on configfile
323
self.delay = 10; #XXX Should be based on configfile
325
def setsecret(self, value):
327
os.write(self.changesignal, "\0")
328
os.read(self._reset, 1)
330
secret = property(lambda self: self._secret, setsecret)
333
def setapproved(self, value):
334
self._approved = value
335
os.write(self.changesignal, "\0")
336
os.read(self._reset, 1)
338
approved = property(lambda self: self._approved, setapproved)
255
self.check_command = config["checker"]
342
257
"""Start this client's checker and timeout hooks"""
343
if getattr(self, u"enabled", False):
346
self.last_enabled = datetime.datetime.utcnow()
347
258
# Schedule a new checker to be started an 'interval' from now,
348
259
# and every interval from then on.
349
self.checker_initiator_tag = (gobject.timeout_add
350
(self.interval_milliseconds(),
352
# Schedule a disable() when 'timeout' has passed
353
self.disable_initiator_tag = (gobject.timeout_add
354
(self.timeout_milliseconds(),
260
self.checker_initiator_tag = gobject.timeout_add\
261
(self._interval_milliseconds,
357
263
# Also start a new checker *right now*.
358
264
self.start_checker()
360
def disable(self, quiet=True):
361
"""Disable this client."""
362
if not getattr(self, "enabled", False):
265
# Schedule a stop() when 'timeout' has passed
266
self.stop_initiator_tag = gobject.timeout_add\
267
(self._timeout_milliseconds,
271
The possibility that a client might be restarted is left open,
272
but not currently used."""
273
# If this client doesn't have a secret, it is already stopped.
274
if hasattr(self, "secret") and self.secret:
275
logger.info(u"Stopping client %s", self.name)
365
logger.info(u"Disabling client %s", self.name)
366
if getattr(self, u"disable_initiator_tag", False):
367
gobject.source_remove(self.disable_initiator_tag)
368
self.disable_initiator_tag = None
369
if getattr(self, u"checker_initiator_tag", False):
279
if getattr(self, "stop_initiator_tag", False):
280
gobject.source_remove(self.stop_initiator_tag)
281
self.stop_initiator_tag = None
282
if getattr(self, "checker_initiator_tag", False):
370
283
gobject.source_remove(self.checker_initiator_tag)
371
284
self.checker_initiator_tag = None
372
285
self.stop_checker()
373
if self.disable_hook:
374
self.disable_hook(self)
376
288
# Do not run this again if called by a gobject.timeout_add
379
290
def __del__(self):
380
self.disable_hook = None
383
def checker_callback(self, pid, condition, command):
291
self.stop_hook = None
293
def checker_callback(self, pid, condition):
384
294
"""The checker has completed, so take appropriate actions."""
295
now = datetime.datetime.now()
385
296
self.checker_callback_tag = None
386
297
self.checker = None
387
if os.WIFEXITED(condition):
388
exitstatus = os.WEXITSTATUS(condition)
390
logger.info(u"Checker for %(name)s succeeded",
394
logger.info(u"Checker for %(name)s failed",
298
if os.WIFEXITED(condition) \
299
and (os.WEXITSTATUS(condition) == 0):
300
logger.info(u"Checker for %(name)s succeeded",
302
self.last_checked_ok = now
303
gobject.source_remove(self.stop_initiator_tag)
304
self.stop_initiator_tag = gobject.timeout_add\
305
(self._timeout_milliseconds,
307
elif not os.WIFEXITED(condition):
397
308
logger.warning(u"Checker for %(name)s crashed?",
400
def checked_ok(self):
401
"""Bump up the timeout for this client.
403
This should only be called when the client has been seen,
406
self.last_checked_ok = datetime.datetime.utcnow()
407
gobject.source_remove(self.disable_initiator_tag)
408
self.disable_initiator_tag = (gobject.timeout_add
409
(self.timeout_milliseconds(),
311
logger.info(u"Checker for %(name)s failed",
412
313
def start_checker(self):
413
314
"""Start a new checker subprocess if one is not running.
415
315
If a checker already exists, leave it running and do
417
317
# The reason for not killing a running checker is that if we
465
346
# always replaced by /dev/null.)
466
347
self.checker = subprocess.Popen(command,
468
shell=True, cwd=u"/")
469
self.checker_callback_tag = (gobject.child_watch_add
471
self.checker_callback,
473
# The checker may have completed before the gobject
474
# watch was added. Check for this.
475
pid, status = os.waitpid(self.checker.pid, os.WNOHANG)
477
gobject.source_remove(self.checker_callback_tag)
478
self.checker_callback(pid, status, command)
350
self.checker_callback_tag = gobject.child_watch_add\
352
self.checker_callback)
479
353
except OSError, error:
480
354
logger.error(u"Failed to start subprocess: %s",
482
356
# Re-run this periodically if run by gobject.timeout_add
485
358
def stop_checker(self):
486
359
"""Force the checker process, if any, to stop."""
487
360
if self.checker_callback_tag:
488
361
gobject.source_remove(self.checker_callback_tag)
489
362
self.checker_callback_tag = None
490
if getattr(self, u"checker", None) is None:
363
if getattr(self, "checker", None) is None:
492
365
logger.debug(u"Stopping checker for %(name)s", vars(self))
494
367
os.kill(self.checker.pid, signal.SIGTERM)
496
369
#if self.checker.poll() is None:
497
370
# os.kill(self.checker.pid, signal.SIGKILL)
498
371
except OSError, error:
499
372
if error.errno != errno.ESRCH: # No such process
501
374
self.checker = None
504
def dbus_service_property(dbus_interface, signature=u"v",
505
access=u"readwrite", byte_arrays=False):
506
"""Decorators for marking methods of a DBusObjectWithProperties to
507
become properties on the D-Bus.
509
The decorated method will be called with no arguments by "Get"
510
and with one argument by "Set".
512
The parameters, where they are supported, are the same as
513
dbus.service.method, except there is only "signature", since the
514
type from Get() and the type sent to Set() is the same.
516
# Encoding deeply encoded byte arrays is not supported yet by the
517
# "Set" method, so we fail early here:
518
if byte_arrays and signature != u"ay":
519
raise ValueError(u"Byte arrays not supported for non-'ay'"
520
u" signature %r" % signature)
522
func._dbus_is_property = True
523
func._dbus_interface = dbus_interface
524
func._dbus_signature = signature
525
func._dbus_access = access
526
func._dbus_name = func.__name__
527
if func._dbus_name.endswith(u"_dbus_property"):
528
func._dbus_name = func._dbus_name[:-14]
529
func._dbus_get_args_options = {u'byte_arrays': byte_arrays }
534
class DBusPropertyException(dbus.exceptions.DBusException):
535
"""A base class for D-Bus property-related exceptions
537
def __unicode__(self):
538
return unicode(str(self))
541
class DBusPropertyAccessException(DBusPropertyException):
542
"""A property's access permissions disallows an operation.
547
class DBusPropertyNotFound(DBusPropertyException):
548
"""An attempt was made to access a non-existing property.
553
class DBusObjectWithProperties(dbus.service.Object):
554
"""A D-Bus object with properties.
556
Classes inheriting from this can use the dbus_service_property
557
decorator to expose methods as D-Bus properties. It exposes the
558
standard Get(), Set(), and GetAll() methods on the D-Bus.
562
def _is_dbus_property(obj):
563
return getattr(obj, u"_dbus_is_property", False)
565
def _get_all_dbus_properties(self):
566
"""Returns a generator of (name, attribute) pairs
568
return ((prop._dbus_name, prop)
570
inspect.getmembers(self, self._is_dbus_property))
572
def _get_dbus_property(self, interface_name, property_name):
573
"""Returns a bound method if one exists which is a D-Bus
574
property with the specified name and interface.
576
for name in (property_name,
577
property_name + u"_dbus_property"):
578
prop = getattr(self, name, None)
580
or not self._is_dbus_property(prop)
581
or prop._dbus_name != property_name
582
or (interface_name and prop._dbus_interface
583
and interface_name != prop._dbus_interface)):
587
raise DBusPropertyNotFound(self.dbus_object_path + u":"
588
+ interface_name + u"."
591
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ss",
593
def Get(self, interface_name, property_name):
594
"""Standard D-Bus property Get() method, see D-Bus standard.
596
prop = self._get_dbus_property(interface_name, property_name)
597
if prop._dbus_access == u"write":
598
raise DBusPropertyAccessException(property_name)
600
if not hasattr(value, u"variant_level"):
602
return type(value)(value, variant_level=value.variant_level+1)
604
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"ssv")
605
def Set(self, interface_name, property_name, value):
606
"""Standard D-Bus property Set() method, see D-Bus standard.
608
prop = self._get_dbus_property(interface_name, property_name)
609
if prop._dbus_access == u"read":
610
raise DBusPropertyAccessException(property_name)
611
if prop._dbus_get_args_options[u"byte_arrays"]:
612
# The byte_arrays option is not supported yet on
613
# signatures other than "ay".
614
if prop._dbus_signature != u"ay":
616
value = dbus.ByteArray(''.join(unichr(byte)
620
@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature=u"s",
621
out_signature=u"a{sv}")
622
def GetAll(self, interface_name):
623
"""Standard D-Bus property GetAll() method, see D-Bus
626
Note: Will not include properties with access="write".
629
for name, prop in self._get_all_dbus_properties():
631
and interface_name != prop._dbus_interface):
632
# Interface non-empty but did not match
634
# Ignore write-only properties
635
if prop._dbus_access == u"write":
638
if not hasattr(value, u"variant_level"):
641
all[name] = type(value)(value, variant_level=
642
value.variant_level+1)
643
return dbus.Dictionary(all, signature=u"sv")
645
@dbus.service.method(dbus.INTROSPECTABLE_IFACE,
647
path_keyword='object_path',
648
connection_keyword='connection')
649
def Introspect(self, object_path, connection):
650
"""Standard D-Bus method, overloaded to insert property tags.
652
xmlstring = dbus.service.Object.Introspect(self, object_path,
655
document = xml.dom.minidom.parseString(xmlstring)
656
def make_tag(document, name, prop):
657
e = document.createElement(u"property")
658
e.setAttribute(u"name", name)
659
e.setAttribute(u"type", prop._dbus_signature)
660
e.setAttribute(u"access", prop._dbus_access)
662
for if_tag in document.getElementsByTagName(u"interface"):
663
for tag in (make_tag(document, name, prop)
665
in self._get_all_dbus_properties()
666
if prop._dbus_interface
667
== if_tag.getAttribute(u"name")):
668
if_tag.appendChild(tag)
669
# Add the names to the return values for the
670
# "org.freedesktop.DBus.Properties" methods
671
if (if_tag.getAttribute(u"name")
672
== u"org.freedesktop.DBus.Properties"):
673
for cn in if_tag.getElementsByTagName(u"method"):
674
if cn.getAttribute(u"name") == u"Get":
675
for arg in cn.getElementsByTagName(u"arg"):
676
if (arg.getAttribute(u"direction")
678
arg.setAttribute(u"name", u"value")
679
elif cn.getAttribute(u"name") == u"GetAll":
680
for arg in cn.getElementsByTagName(u"arg"):
681
if (arg.getAttribute(u"direction")
683
arg.setAttribute(u"name", u"props")
684
xmlstring = document.toxml(u"utf-8")
686
except (AttributeError, xml.dom.DOMException,
687
xml.parsers.expat.ExpatError), error:
688
logger.error(u"Failed to override Introspection method",
693
class ClientDBus(Client, DBusObjectWithProperties):
694
"""A Client class using D-Bus
697
dbus_object_path: dbus.ObjectPath
698
bus: dbus.SystemBus()
700
# dbus.service.Object doesn't use super(), so we can't either.
702
def __init__(self, bus = None, *args, **kwargs):
704
Client.__init__(self, *args, **kwargs)
705
# Only now, when this client is initialized, can it show up on
707
self.dbus_object_path = (dbus.ObjectPath
709
+ self.name.replace(u".", u"_")))
710
DBusObjectWithProperties.__init__(self, self.bus,
711
self.dbus_object_path)
714
def _datetime_to_dbus(dt, variant_level=0):
715
"""Convert a UTC datetime.datetime() to a D-Bus type."""
716
return dbus.String(dt.isoformat(),
717
variant_level=variant_level)
720
oldstate = getattr(self, u"enabled", False)
721
r = Client.enable(self)
722
if oldstate != self.enabled:
724
self.PropertyChanged(dbus.String(u"enabled"),
725
dbus.Boolean(True, variant_level=1))
726
self.PropertyChanged(
727
dbus.String(u"last_enabled"),
728
self._datetime_to_dbus(self.last_enabled,
732
def disable(self, quiet = False):
733
oldstate = getattr(self, u"enabled", False)
734
r = Client.disable(self, quiet=quiet)
735
if not quiet and oldstate != self.enabled:
737
self.PropertyChanged(dbus.String(u"enabled"),
738
dbus.Boolean(False, variant_level=1))
741
def __del__(self, *args, **kwargs):
743
self.remove_from_connection()
746
if hasattr(DBusObjectWithProperties, u"__del__"):
747
DBusObjectWithProperties.__del__(self, *args, **kwargs)
748
Client.__del__(self, *args, **kwargs)
750
def checker_callback(self, pid, condition, command,
752
self.checker_callback_tag = None
755
self.PropertyChanged(dbus.String(u"checker_running"),
756
dbus.Boolean(False, variant_level=1))
757
if os.WIFEXITED(condition):
758
exitstatus = os.WEXITSTATUS(condition)
760
self.CheckerCompleted(dbus.Int16(exitstatus),
761
dbus.Int64(condition),
762
dbus.String(command))
765
self.CheckerCompleted(dbus.Int16(-1),
766
dbus.Int64(condition),
767
dbus.String(command))
769
return Client.checker_callback(self, pid, condition, command,
772
def checked_ok(self, *args, **kwargs):
773
r = Client.checked_ok(self, *args, **kwargs)
775
self.PropertyChanged(
776
dbus.String(u"last_checked_ok"),
777
(self._datetime_to_dbus(self.last_checked_ok,
781
def start_checker(self, *args, **kwargs):
782
old_checker = self.checker
783
if self.checker is not None:
784
old_checker_pid = self.checker.pid
786
old_checker_pid = None
787
r = Client.start_checker(self, *args, **kwargs)
788
# Only if new checker process was started
789
if (self.checker is not None
790
and old_checker_pid != self.checker.pid):
792
self.CheckerStarted(self.current_checker_command)
793
self.PropertyChanged(
794
dbus.String(u"checker_running"),
795
dbus.Boolean(True, variant_level=1))
798
def stop_checker(self, *args, **kwargs):
799
old_checker = getattr(self, u"checker", None)
800
r = Client.stop_checker(self, *args, **kwargs)
801
if (old_checker is not None
802
and getattr(self, u"checker", None) is None):
803
self.PropertyChanged(dbus.String(u"checker_running"),
804
dbus.Boolean(False, variant_level=1))
807
## D-Bus methods, signals & properties
808
_interface = u"se.bsnet.fukt.Mandos.Client"
812
# CheckerCompleted - signal
813
@dbus.service.signal(_interface, signature=u"nxs")
814
def CheckerCompleted(self, exitcode, waitstatus, command):
818
# CheckerStarted - signal
819
@dbus.service.signal(_interface, signature=u"s")
820
def CheckerStarted(self, command):
824
# PropertyChanged - signal
825
@dbus.service.signal(_interface, signature=u"sv")
826
def PropertyChanged(self, property, value):
831
@dbus.service.signal(_interface)
837
@dbus.service.signal(_interface)
845
@dbus.service.method(_interface)
847
return self.checked_ok()
850
@dbus.service.method(_interface)
855
# StartChecker - method
856
@dbus.service.method(_interface)
857
def StartChecker(self):
862
@dbus.service.method(_interface)
867
# StopChecker - method
868
@dbus.service.method(_interface)
869
def StopChecker(self):
875
@dbus_service_property(_interface, signature=u"s", access=u"read")
876
def name_dbus_property(self):
877
return dbus.String(self.name)
879
# fingerprint - property
880
@dbus_service_property(_interface, signature=u"s", access=u"read")
881
def fingerprint_dbus_property(self):
882
return dbus.String(self.fingerprint)
885
@dbus_service_property(_interface, signature=u"s",
887
def host_dbus_property(self, value=None):
888
if value is None: # get
889
return dbus.String(self.host)
892
self.PropertyChanged(dbus.String(u"host"),
893
dbus.String(value, variant_level=1))
896
@dbus_service_property(_interface, signature=u"s", access=u"read")
897
def created_dbus_property(self):
898
return dbus.String(self._datetime_to_dbus(self.created))
900
# last_enabled - property
901
@dbus_service_property(_interface, signature=u"s", access=u"read")
902
def last_enabled_dbus_property(self):
903
if self.last_enabled is None:
904
return dbus.String(u"")
905
return dbus.String(self._datetime_to_dbus(self.last_enabled))
908
@dbus_service_property(_interface, signature=u"b",
910
def enabled_dbus_property(self, value=None):
911
if value is None: # get
912
return dbus.Boolean(self.enabled)
918
# last_checked_ok - property
919
@dbus_service_property(_interface, signature=u"s",
921
def last_checked_ok_dbus_property(self, value=None):
922
if value is not None:
375
def still_valid(self):
376
"""Has the timeout not yet passed for this client?"""
377
now = datetime.datetime.now()
925
378
if self.last_checked_ok is None:
926
return dbus.String(u"")
927
return dbus.String(self._datetime_to_dbus(self
931
@dbus_service_property(_interface, signature=u"t",
933
def timeout_dbus_property(self, value=None):
934
if value is None: # get
935
return dbus.UInt64(self.timeout_milliseconds())
936
self.timeout = datetime.timedelta(0, 0, 0, value)
938
self.PropertyChanged(dbus.String(u"timeout"),
939
dbus.UInt64(value, variant_level=1))
940
if getattr(self, u"disable_initiator_tag", None) is None:
943
gobject.source_remove(self.disable_initiator_tag)
944
self.disable_initiator_tag = None
946
_timedelta_to_milliseconds((self
952
# The timeout has passed
955
self.disable_initiator_tag = (gobject.timeout_add
956
(time_to_die, self.disable))
958
# interval - property
959
@dbus_service_property(_interface, signature=u"t",
961
def interval_dbus_property(self, value=None):
962
if value is None: # get
963
return dbus.UInt64(self.interval_milliseconds())
964
self.interval = datetime.timedelta(0, 0, 0, value)
966
self.PropertyChanged(dbus.String(u"interval"),
967
dbus.UInt64(value, variant_level=1))
968
if getattr(self, u"checker_initiator_tag", None) is None:
970
# Reschedule checker run
971
gobject.source_remove(self.checker_initiator_tag)
972
self.checker_initiator_tag = (gobject.timeout_add
973
(value, self.start_checker))
974
self.start_checker() # Start one now, too
977
@dbus_service_property(_interface, signature=u"s",
979
def checker_dbus_property(self, value=None):
980
if value is None: # get
981
return dbus.String(self.checker_command)
982
self.checker_command = value
984
self.PropertyChanged(dbus.String(u"checker"),
985
dbus.String(self.checker_command,
988
# checker_running - property
989
@dbus_service_property(_interface, signature=u"b",
991
def checker_running_dbus_property(self, value=None):
992
if value is None: # get
993
return dbus.Boolean(self.checker is not None)
999
# object_path - property
1000
@dbus_service_property(_interface, signature=u"o", access=u"read")
1001
def object_path_dbus_property(self):
1002
return self.dbus_object_path # is already a dbus.ObjectPath
1005
@dbus_service_property(_interface, signature=u"ay",
1006
access=u"write", byte_arrays=True)
1007
def secret_dbus_property(self, value):
1008
self.secret = str(value)
1013
class ClientHandler(socketserver.BaseRequestHandler, object):
1014
"""A class to handle client connections.
1016
Instantiated once for each connection to handle it.
379
return now < (self.created + self.timeout)
381
return now < (self.last_checked_ok + self.timeout)
384
def peer_certificate(session):
385
"Return the peer's OpenPGP certificate as a bytestring"
386
# If not an OpenPGP certificate...
387
if gnutls.library.functions.gnutls_certificate_type_get\
388
(session._c_object) \
389
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP:
390
# ...do the normal thing
391
return session.peer_certificate
392
list_size = ctypes.c_uint()
393
cert_list = gnutls.library.functions.gnutls_certificate_get_peers\
394
(session._c_object, ctypes.byref(list_size))
395
if list_size.value == 0:
398
return ctypes.string_at(cert.data, cert.size)
401
def fingerprint(openpgp):
402
"Convert an OpenPGP bytestring to a hexdigit fingerprint string"
403
# New GnuTLS "datum" with the OpenPGP public key
404
datum = gnutls.library.types.gnutls_datum_t\
405
(ctypes.cast(ctypes.c_char_p(openpgp),
406
ctypes.POINTER(ctypes.c_ubyte)),
407
ctypes.c_uint(len(openpgp)))
408
# New empty GnuTLS certificate
409
crt = gnutls.library.types.gnutls_openpgp_crt_t()
410
gnutls.library.functions.gnutls_openpgp_crt_init\
412
# Import the OpenPGP public key into the certificate
413
gnutls.library.functions.gnutls_openpgp_crt_import\
414
(crt, ctypes.byref(datum),
415
gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)
416
# Verify the self signature in the key
417
crtverify = ctypes.c_uint();
418
gnutls.library.functions.gnutls_openpgp_crt_verify_self\
419
(crt, 0, ctypes.byref(crtverify))
420
if crtverify.value != 0:
421
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
422
raise gnutls.errors.CertificateSecurityError("Verify failed")
423
# New buffer for the fingerprint
424
buffer = ctypes.create_string_buffer(20)
425
buffer_length = ctypes.c_size_t()
426
# Get the fingerprint from the certificate into the buffer
427
gnutls.library.functions.gnutls_openpgp_crt_get_fingerprint\
428
(crt, ctypes.byref(buffer), ctypes.byref(buffer_length))
429
# Deinit the certificate
430
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
431
# Convert the buffer to a Python bytestring
432
fpr = ctypes.string_at(buffer, buffer_length.value)
433
# Convert the bytestring to hexadecimal notation
434
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
438
class tcp_handler(SocketServer.BaseRequestHandler, object):
439
"""A TCP request handler class.
440
Instantiated by IPv6_TCPServer for each request to handle it.
1017
441
Note: This will run in its own forked process."""
1019
443
def handle(self):
1020
444
logger.info(u"TCP connection from: %s",
1021
unicode(self.client_address))
1022
logger.debug(u"IPC Pipe FD: %d",
1023
self.server.child_pipe[1].fileno())
1024
# Open IPC pipe to parent process
1025
with contextlib.nested(self.server.child_pipe[1],
1026
self.server.parent_pipe[0]
1027
) as (ipc, ipc_return):
1028
session = (gnutls.connection
1029
.ClientSession(self.request,
1031
.X509Credentials()))
1033
line = self.request.makefile().readline()
1034
logger.debug(u"Protocol version: %r", line)
1036
if int(line.strip().split()[0]) > 1:
1038
except (ValueError, IndexError, RuntimeError), error:
1039
logger.error(u"Unknown protocol version: %s", error)
1042
# Note: gnutls.connection.X509Credentials is really a
1043
# generic GnuTLS certificate credentials object so long as
1044
# no X.509 keys are added to it. Therefore, we can use it
1045
# here despite using OpenPGP certificates.
1047
#priority = u':'.join((u"NONE", u"+VERS-TLS1.1",
1048
# u"+AES-256-CBC", u"+SHA1",
1049
# u"+COMP-NULL", u"+CTYPE-OPENPGP",
1051
# Use a fallback default, since this MUST be set.
1052
priority = self.server.gnutls_priority
1053
if priority is None:
1054
priority = u"NORMAL"
1055
(gnutls.library.functions
1056
.gnutls_priority_set_direct(session._c_object,
1061
except gnutls.errors.GNUTLSError, error:
1062
logger.warning(u"Handshake failed: %s", error)
1063
# Do not run session.bye() here: the session is not
1064
# established. Just abandon the request.
1066
logger.debug(u"Handshake succeeded")
1069
fpr = self.fingerprint(self.peer_certificate
1071
except (TypeError, gnutls.errors.GNUTLSError), error:
1072
logger.warning(u"Bad certificate: %s", error)
1074
logger.debug(u"Fingerprint: %s", fpr)
1076
for c in self.server.clients:
1077
if c.fingerprint == fpr:
1081
ipc.write(u"NOTFOUND %s %s\n"
1082
% (fpr, unicode(self.client_address)))
1085
class proxyclient(object):
1086
def __getattribute__(self, name):
1087
ipc.write(u"GETATTR %s %s\n" % name, client.fpr)
1088
return pickle.load(ipc_reply)
1089
p = proxyclient(client)
1092
if not p.client.enabled:
1093
icp.write("DISABLED %s\n" % client.fpr)
1095
if p.client.approved == False:
1096
icp.write("Disaproved")
1099
if not p.client.secret:
1100
icp.write("No password")
1101
elif not p.client.approved:
1102
icp.write("Need approval"):
1104
#We have a password and are approved
1106
i, o, e = select(p.changesignal, (), (), client.delay)
1108
icp.write("Timeout passed")
1111
ipc.write(u"SENDING %s\n" % client.name)
1113
while sent_size < len(client.secret):
1114
sent = session.send(client.secret[sent_size:])
1115
logger.debug(u"Sent: %d, remaining: %d",
1116
sent, len(client.secret)
1117
- (sent_size + sent))
1123
def peer_certificate(session):
1124
"Return the peer's OpenPGP certificate as a bytestring"
1125
# If not an OpenPGP certificate...
1126
if (gnutls.library.functions
1127
.gnutls_certificate_type_get(session._c_object)
1128
!= gnutls.library.constants.GNUTLS_CRT_OPENPGP):
1129
# ...do the normal thing
1130
return session.peer_certificate
1131
list_size = ctypes.c_uint(1)
1132
cert_list = (gnutls.library.functions
1133
.gnutls_certificate_get_peers
1134
(session._c_object, ctypes.byref(list_size)))
1135
if not bool(cert_list) and list_size.value != 0:
1136
raise gnutls.errors.GNUTLSError(u"error getting peer"
1138
if list_size.value == 0:
1141
return ctypes.string_at(cert.data, cert.size)
1144
def fingerprint(openpgp):
1145
"Convert an OpenPGP bytestring to a hexdigit fingerprint"
1146
# New GnuTLS "datum" with the OpenPGP public key
1147
datum = (gnutls.library.types
1148
.gnutls_datum_t(ctypes.cast(ctypes.c_char_p(openpgp),
1151
ctypes.c_uint(len(openpgp))))
1152
# New empty GnuTLS certificate
1153
crt = gnutls.library.types.gnutls_openpgp_crt_t()
1154
(gnutls.library.functions
1155
.gnutls_openpgp_crt_init(ctypes.byref(crt)))
1156
# Import the OpenPGP public key into the certificate
1157
(gnutls.library.functions
1158
.gnutls_openpgp_crt_import(crt, ctypes.byref(datum),
1159
gnutls.library.constants
1160
.GNUTLS_OPENPGP_FMT_RAW))
1161
# Verify the self signature in the key
1162
crtverify = ctypes.c_uint()
1163
(gnutls.library.functions
1164
.gnutls_openpgp_crt_verify_self(crt, 0,
1165
ctypes.byref(crtverify)))
1166
if crtverify.value != 0:
1167
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1168
raise (gnutls.errors.CertificateSecurityError
1170
# New buffer for the fingerprint
1171
buf = ctypes.create_string_buffer(20)
1172
buf_len = ctypes.c_size_t()
1173
# Get the fingerprint from the certificate into the buffer
1174
(gnutls.library.functions
1175
.gnutls_openpgp_crt_get_fingerprint(crt, ctypes.byref(buf),
1176
ctypes.byref(buf_len)))
1177
# Deinit the certificate
1178
gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)
1179
# Convert the buffer to a Python bytestring
1180
fpr = ctypes.string_at(buf, buf_len.value)
1181
# Convert the bytestring to hexadecimal notation
1182
hex_fpr = u''.join(u"%02X" % ord(char) for char in fpr)
1186
class ForkingMixInWithPipes(socketserver.ForkingMixIn, object):
1187
"""Like socketserver.ForkingMixIn, but also pass a pipe pair."""
1188
def process_request(self, request, client_address):
1189
"""Overrides and wraps the original process_request().
1191
This function creates a new pipe in self.pipe
1193
# Child writes to child_pipe
1194
self.child_pipe = map(os.fdopen, os.pipe(), u"rw", (1, 0))
1195
# Parent writes to parent_pipe
1196
self.parent_pipe = map(os.fdopen, os.pipe(), u"rw", (1, 0))
1197
super(ForkingMixInWithPipes,
1198
self).process_request(request, client_address)
1199
# Close unused ends for parent
1200
self.parent_pipe[0].close() # close read end
1201
self.child_pipe[1].close() # close write end
1202
self.add_pipe_fds(self.child_pipe[0], self.parent_pipe[1])
1203
def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):
1204
"""Dummy function; override as necessary"""
1205
child_pipe_fd.close()
1206
parent_pipe_fd.close()
1209
class IPv6_TCPServer(ForkingMixInWithPipes,
1210
socketserver.TCPServer, object):
1211
"""IPv6-capable TCP server. Accepts 'None' as address and/or port
445
unicode(self.client_address))
446
session = gnutls.connection.ClientSession\
447
(self.request, gnutls.connection.X509Credentials())
449
line = self.request.makefile().readline()
450
logger.debug(u"Protocol version: %r", line)
452
if int(line.strip().split()[0]) > 1:
454
except (ValueError, IndexError, RuntimeError), error:
455
logger.error(u"Unknown protocol version: %s", error)
458
# Note: gnutls.connection.X509Credentials is really a generic
459
# GnuTLS certificate credentials object so long as no X.509
460
# keys are added to it. Therefore, we can use it here despite
461
# using OpenPGP certificates.
463
#priority = ':'.join(("NONE", "+VERS-TLS1.1", "+AES-256-CBC",
464
# "+SHA1", "+COMP-NULL", "+CTYPE-OPENPGP",
466
priority = "NORMAL" # Fallback default, since this
468
if self.server.settings["priority"]:
469
priority = self.server.settings["priority"]
470
gnutls.library.functions.gnutls_priority_set_direct\
471
(session._c_object, priority, None);
475
except gnutls.errors.GNUTLSError, error:
476
logger.warning(u"Handshake failed: %s", error)
477
# Do not run session.bye() here: the session is not
478
# established. Just abandon the request.
481
fpr = fingerprint(peer_certificate(session))
482
except (TypeError, gnutls.errors.GNUTLSError), error:
483
logger.warning(u"Bad certificate: %s", error)
486
logger.debug(u"Fingerprint: %s", fpr)
488
for c in self.server.clients:
489
if c.fingerprint == fpr:
493
logger.warning(u"Client not found for fingerprint: %s",
497
# Have to check if client.still_valid(), since it is possible
498
# that the client timed out while establishing the GnuTLS
500
if not client.still_valid():
501
logger.warning(u"Client %(name)s is invalid",
506
while sent_size < len(client.secret):
507
sent = session.send(client.secret[sent_size:])
508
logger.debug(u"Sent: %d, remaining: %d",
509
sent, len(client.secret)
510
- (sent_size + sent))
515
class IPv6_TCPServer(SocketServer.ForkingTCPServer, object):
516
"""IPv6 TCP server. Accepts 'None' as address and/or port.
1214
enabled: Boolean; whether this server is activated yet
1215
interface: None or a network interface name (string)
1216
use_ipv6: Boolean; to use IPv6 or not
518
settings: Server settings
519
clients: Set() of Client objects
1218
def __init__(self, server_address, RequestHandlerClass,
1219
interface=None, use_ipv6=True):
1220
self.interface = interface
1222
self.address_family = socket.AF_INET6
1223
socketserver.TCPServer.__init__(self, server_address,
1224
RequestHandlerClass)
521
address_family = socket.AF_INET6
522
def __init__(self, *args, **kwargs):
523
if "settings" in kwargs:
524
self.settings = kwargs["settings"]
525
del kwargs["settings"]
526
if "clients" in kwargs:
527
self.clients = kwargs["clients"]
528
del kwargs["clients"]
529
return super(type(self), self).__init__(*args, **kwargs)
1225
530
def server_bind(self):
1226
531
"""This overrides the normal server_bind() function
1227
532
to bind to an interface if one was specified, and also NOT to
1228
533
bind to an address or port if they were not specified."""
1229
if self.interface is not None:
1230
if SO_BINDTODEVICE is None:
1231
logger.error(u"SO_BINDTODEVICE does not exist;"
1232
u" cannot bind to interface %s",
1236
self.socket.setsockopt(socket.SOL_SOCKET,
1240
except socket.error, error:
1241
if error[0] == errno.EPERM:
1242
logger.error(u"No permission to"
1243
u" bind to interface %s",
1245
elif error[0] == errno.ENOPROTOOPT:
1246
logger.error(u"SO_BINDTODEVICE not available;"
1247
u" cannot bind to interface %s",
534
if self.settings["interface"]:
535
# 25 is from /usr/include/asm-i486/socket.h
536
SO_BINDTODEVICE = getattr(socket, "SO_BINDTODEVICE", 25)
538
self.socket.setsockopt(socket.SOL_SOCKET,
540
self.settings["interface"])
541
except socket.error, error:
542
if error[0] == errno.EPERM:
543
logger.error(u"No permission to"
544
u" bind to interface %s",
545
self.settings["interface"])
1251
548
# Only bind(2) the socket if we really need to.
1252
549
if self.server_address[0] or self.server_address[1]:
1253
550
if not self.server_address[0]:
1254
if self.address_family == socket.AF_INET6:
1255
any_address = u"::" # in6addr_any
1257
any_address = socket.INADDR_ANY
1258
self.server_address = (any_address,
552
self.server_address = (in6addr_any,
1259
553
self.server_address[1])
1260
554
elif not self.server_address[1]:
1261
555
self.server_address = (self.server_address[0],
1263
# if self.interface:
557
# if self.settings["interface"]:
1264
558
# self.server_address = (self.server_address[0],
1267
561
# if_nametoindex
1269
return socketserver.TCPServer.server_bind(self)
1272
class MandosServer(IPv6_TCPServer):
1276
clients: set of Client objects
1277
gnutls_priority GnuTLS priority string
1278
use_dbus: Boolean; to emit D-Bus signals or not
1280
Assumes a gobject.MainLoop event loop.
1282
def __init__(self, server_address, RequestHandlerClass,
1283
interface=None, use_ipv6=True, clients=None,
1284
gnutls_priority=None, use_dbus=True):
1285
self.enabled = False
1286
self.clients = clients
1287
if self.clients is None:
1288
self.clients = set()
1289
self.use_dbus = use_dbus
1290
self.gnutls_priority = gnutls_priority
1291
IPv6_TCPServer.__init__(self, server_address,
1292
RequestHandlerClass,
1293
interface = interface,
1294
use_ipv6 = use_ipv6)
1295
def server_activate(self):
1297
return socketserver.TCPServer.server_activate(self)
1300
def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):
1301
# Call "handle_ipc" for both data and EOF events
1302
gobject.io_add_watch(child_pipe_fd.fileno(),
1303
gobject.IO_IN | gobject.IO_HUP,
1304
functools.partial(self.handle_ipc,
1305
reply = parent_pipe_fd,
1306
sender= child_pipe_fd))
1307
def handle_ipc(self, source, condition, reply=None, sender=None):
1309
gobject.IO_IN: u"IN", # There is data to read.
1310
gobject.IO_OUT: u"OUT", # Data can be written (without
1312
gobject.IO_PRI: u"PRI", # There is urgent data to read.
1313
gobject.IO_ERR: u"ERR", # Error condition.
1314
gobject.IO_HUP: u"HUP" # Hung up (the connection has been
1315
# broken, usually for pipes and
1318
conditions_string = ' | '.join(name
1320
condition_names.iteritems()
1321
if cond & condition)
1322
logger.debug(u"Handling IPC: FD = %d, condition = %s", source,
1325
# Read a line from the file object
1326
cmdline = sender.readline()
1327
if not cmdline: # Empty line means end of file
1328
# close the IPC pipes
1332
# Stop calling this function
1335
logger.debug(u"IPC command: %r", cmdline)
1337
# Parse and act on command
1338
cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)
1340
if cmd == u"NOTFOUND":
1341
fpr, address = args.split(None, 1)
1342
logger.warning(u"Client not found for fingerprint: %s, ad"
1343
u"dress: %s", fpr, address)
1346
mandos_dbus_service.ClientNotFound(fpr, address)
1347
elif cmd == u"DISABLED":
1348
for client in self.clients:
1349
if client.name == args:
1350
logger.warning(u"Client %s is disabled", args)
1356
logger.error(u"Unknown client %s is disabled", args)
1357
elif cmd == u"SENDING":
1358
for client in self.clients:
1359
if client.name == args:
1360
logger.info(u"Sending secret to %s", client.name)
1367
logger.error(u"Sending secret to unknown client %s",
1369
elif cmd == u"GETATTR":
1370
attr_name, fpr = args.split(None, 1)
1371
for client in self.clients:
1372
if client.fingerprint == fpr:
1373
attr_value = getattr(client, attr_name, None)
1374
logger.debug("IPC reply: %r", attr_value)
1375
pickle.dump(attr_value, reply)
1378
logger.error(u"Client %s on address %s requesting "
1379
u"attribute %s not found", fpr, address,
1381
pickle.dump(None, reply)
1383
logger.error(u"Unknown IPC command: %r", cmdline)
1385
# Keep calling this function
564
return super(type(self), self).server_bind()
1389
567
def string_to_delta(interval):
1390
568
"""Parse a string and return a datetime.timedelta
1392
>>> string_to_delta(u'7d')
570
>>> string_to_delta('7d')
1393
571
datetime.timedelta(7)
1394
>>> string_to_delta(u'60s')
572
>>> string_to_delta('60s')
1395
573
datetime.timedelta(0, 60)
1396
>>> string_to_delta(u'60m')
574
>>> string_to_delta('60m')
1397
575
datetime.timedelta(0, 3600)
1398
>>> string_to_delta(u'24h')
576
>>> string_to_delta('24h')
1399
577
datetime.timedelta(1)
1400
578
>>> string_to_delta(u'1w')
1401
579
datetime.timedelta(7)
1402
>>> string_to_delta(u'5m 30s')
580
>>> string_to_delta('5m 30s')
1403
581
datetime.timedelta(0, 330)
1405
583
timevalue = datetime.timedelta(0)
1406
584
for s in interval.split():
1408
suffix = unicode(s[-1])
586
suffix=unicode(s[-1])
1410
588
if suffix == u"d":
1411
589
delta = datetime.timedelta(value)
1412
590
elif suffix == u"s":