/mandos/release : revision 277

22

# Contact the authors at <mandos@fukt.bsnet.se>.

23

#

24

25

from __future__ import division, absolute_import, unicode_literals

26

25

from __future__ import division

27

26

import sys

28

27

import dbus

29

28

from optparse import OptionParser

32

31

import re

33

32

import os

34

33

35

locale.setlocale(locale.LC_ALL, "")

34

locale.setlocale(locale.LC_ALL, u'')

36

35

37

36

tablewords = {

38

"Name": "Name",

39

"Enabled": "Enabled",

40

"Timeout": "Timeout",

41

"LastCheckedOK": "Last Successful Check",

42

"LastApprovalRequest": "Last Approval Request",

43

"Created": "Created",

44

"Interval": "Interval",

45

"Host": "Host",

46

"Fingerprint": "Fingerprint",

47

"CheckerRunning": "Check Is Running",

48

"LastEnabled": "Last Enabled",

49

"ApprovalPending": "Approval Is Pending",

50

"ApprovedByDefault": "Approved By Default",

51

"ApprovalDelay": "Approval Delay",

52

"ApprovalDuration": "Approval Duration",

53

"Checker": "Checker",

37

'Name': u'Name',

38

'Enabled': u'Enabled',

39

'Timeout': u'Timeout',

40

'LastCheckedOK': u'Last Successful Check',

41

'LastApprovalRequest': u'Last Approval Request',

42

'Created': u'Created',

43

'Interval': u'Interval',

44

'Host': u'Host',

45

'Fingerprint': u'Fingerprint',

46

'CheckerRunning': u'Check Is Running',

47

'LastEnabled': u'Last Enabled',

48

'ApprovalPending': u'Approval Is Pending',

49

'ApprovedByDefault': u'Approved By Default',

50

'ApprovalDelay': u"Approval Delay",

51

'ApprovalDuration': u"Approval Duration",

52

'Checker': u'Checker',

54

53

}

55

defaultkeywords = ("Name", "Enabled", "Timeout", "LastCheckedOK")

56

domain = "se.bsnet.fukt"

57

busname = domain + ".Mandos"

58

server_path = "/"

59

server_interface = domain + ".Mandos"

60

client_interface = domain + ".Mandos.Client"

61

version = "1.2.3"

54

defaultkeywords = ('Name', 'Enabled', 'Timeout', 'LastCheckedOK')

55

domain = 'se.bsnet.fukt'

56

busname = domain + '.Mandos'

57

server_path = '/'

58

server_interface = domain + '.Mandos'

59

client_interface = domain + '.Mandos.Client'

60

version = "1.2.1"

62

61

63

62

def timedelta_to_milliseconds(td):

64

"""Convert a datetime.timedelta object to milliseconds"""

63

"Convert a datetime.timedelta object to milliseconds"

65

64

return ((td.days * 24 * 60 * 60 * 1000)

66

65

+ (td.seconds * 1000)

67

66

+ (td.microseconds // 1000))

68

67

69

68

def milliseconds_to_string(ms):

70

69

td = datetime.timedelta(0, 0, 0, ms)

71

return ("%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"

70

return (u"%(days)s%(hours)02d:%(minutes)02d:%(seconds)02d"

72

71

% { "days": "%dT" % td.days if td.days else "",

73

72

"hours": td.seconds // 3600,

74

73

"minutes": (td.seconds % 3600) // 60,

79

78

def string_to_delta(interval):

80

79

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

81

80

82

>>> string_to_delta("7d")

81

>>> string_to_delta('7d')

83

82

datetime.timedelta(7)

84

>>> string_to_delta("60s")

83

>>> string_to_delta('60s')

85

84

datetime.timedelta(0, 60)

86

>>> string_to_delta("60m")

85

>>> string_to_delta('60m')

87

86

datetime.timedelta(0, 3600)

88

>>> string_to_delta("24h")

87

>>> string_to_delta('24h')

89

88

datetime.timedelta(1)

90

>>> string_to_delta("1w")

89

>>> string_to_delta(u'1w')

91

90

datetime.timedelta(7)

92

>>> string_to_delta("5m 30s")

91

>>> string_to_delta('5m 30s')

93

92

datetime.timedelta(0, 330)

94

93

"""

95

94

timevalue = datetime.timedelta(0)

99

98

try:

100

99

suffix = unicode(s[-1])

101

100

value = int(s[:-1])

102

if suffix == "d":

101

if suffix == u"d":

103

102

delta = datetime.timedelta(value)

104

elif suffix == "s":

103

elif suffix == u"s":

105

104

delta = datetime.timedelta(0, value)

106

elif suffix == "m":

105

elif suffix == u"m":

107

106

delta = datetime.timedelta(0, 0, 0, 0, value)

108

elif suffix == "h":

107

elif suffix == u"h":

109

108

delta = datetime.timedelta(0, 0, 0, 0, 0, value)

110

elif suffix == "w":

109

elif suffix == u"w":

111

110

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

112

111

else:

113

112

raise ValueError

119

118

def print_clients(clients, keywords):

120

119

def valuetostring(value, keyword):

121

120

if type(value) is dbus.Boolean:

122

return "Yes" if value else "No"

123

if keyword in ("Timeout", "Interval", "ApprovalDelay",

124

"ApprovalDuration"):

121

return u"Yes" if value else u"No"

122

if keyword in (u"Timeout", u"Interval", u"ApprovalDelay",

123

u"ApprovalDuration"):

125

124

return milliseconds_to_string(value)

126

125

return unicode(value)

127

126

128

127

# Create format string to print table rows

129

format_string = " ".join("%%-%ds" %

130

max(len(tablewords[key]),

131

max(len(valuetostring(client[key],

132

key))

133

for client in

134

clients))

135

for key in keywords)

128

format_string = u' '.join(u'%%-%ds' %

129

max(len(tablewords[key]),

130

max(len(valuetostring(client[key],

131

key))

132

for client in

133

clients))

134

for key in keywords)

136

135

# Print header line

137

136

print format_string % tuple(tablewords[key] for key in keywords)

138

137

for client in clients:

185

184

parser.add_option("-i", "--interval", type="string",

186

185

help="Set checker interval for client")

187

186

parser.add_option("--approve-by-default", action="store_true",

188

dest="approved_by_default",

187

dest=u"approved_by_default",

189

188

help="Set client to be approved by default")

190

189

parser.add_option("--deny-by-default", action="store_false",

191

dest="approved_by_default",

190

dest=u"approved_by_default",

192

191

help="Set client to be denied by default")

193

192

parser.add_option("--approval-delay", type="string",

194

193

help="Set delay before client approve/deny")

205

204

options, client_names = parser.parse_args()

206

205

207

206

if has_actions(options) and not client_names and not options.all:

208

parser.error("Options require clients names or --all.")

207

parser.error('Options require clients names or --all.')

209

208

if options.verbose and has_actions(options):

210

parser.error("--verbose can only be used alone or with"

211

" --all.")

209

parser.error('--verbose can only be used alone or with'

210

' --all.')

212

211

if options.all and not has_actions(options):

213

parser.error("--all requires an action.")

212

parser.error('--all requires an action.')

214

213

215

214

try:

216

215

bus = dbus.SystemBus()

248

247

else:

249

248

for name in client_names:

250

249

for path, client in mandos_clients.iteritems():

251

if client["Name"] == name:

250

if client['Name'] == name:

252

251

client_objc = bus.get_object(busname, path)

253

252

clients[client_objc] = client

254

253

break

258

257

259

258

if not has_actions(options) and clients:

260

259

if options.verbose:

261

keywords = ("Name", "Enabled", "Timeout",

262

"LastCheckedOK", "Created", "Interval",

263

"Host", "Fingerprint", "CheckerRunning",

264

"LastEnabled", "ApprovalPending",

265

"ApprovedByDefault",

266

"LastApprovalRequest", "ApprovalDelay",

267

"ApprovalDuration", "Checker")

260

keywords = ('Name', 'Enabled', 'Timeout',

261

'LastCheckedOK', 'Created', 'Interval',

262

'Host', 'Fingerprint', 'CheckerRunning',

263

'LastEnabled', 'ApprovalPending',

264

'ApprovedByDefault',

265

'LastApprovalRequest', 'ApprovalDelay',

266

'ApprovalDuration', 'Checker')

268

267

else:

269

268

keywords = defaultkeywords

270

269

286

285

client.StopChecker(dbus_interface=client_interface)

287

286

if options.is_enabled:

288

287

sys.exit(0 if client.Get(client_interface,

289

"Enabled",

288

u"Enabled",

290

289

dbus_interface=dbus.PROPERTIES_IFACE)

291

290

else 1)

292

291

if options.checker:

293

client.Set(client_interface, "Checker", options.checker,

292

client.Set(client_interface, u"Checker", options.checker,

294

293

dbus_interface=dbus.PROPERTIES_IFACE)

295

294

if options.host:

296

client.Set(client_interface, "Host", options.host,

295

client.Set(client_interface, u"Host", options.host,

297

296

dbus_interface=dbus.PROPERTIES_IFACE)

298

297

if options.interval:

299

client.Set(client_interface, "Interval",

298

client.Set(client_interface, u"Interval",

300

299

timedelta_to_milliseconds

301

300

(string_to_delta(options.interval)),

302

301

dbus_interface=dbus.PROPERTIES_IFACE)

303

302

if options.approval_delay:

304

client.Set(client_interface, "ApprovalDelay",

303

client.Set(client_interface, u"ApprovalDelay",

305

304

timedelta_to_milliseconds

306

305

(string_to_delta(options.

307

306

approval_delay)),

308

307

dbus_interface=dbus.PROPERTIES_IFACE)

309

308

if options.approval_duration:

310

client.Set(client_interface, "ApprovalDuration",

309

client.Set(client_interface, u"ApprovalDuration",

311

310

timedelta_to_milliseconds

312

311

(string_to_delta(options.

313

312

approval_duration)),

314

313

dbus_interface=dbus.PROPERTIES_IFACE)

315

314

if options.timeout:

316

client.Set(client_interface, "Timeout",

315

client.Set(client_interface, u"Timeout",

317

316

timedelta_to_milliseconds

318

317

(string_to_delta(options.timeout)),

319

318

dbus_interface=dbus.PROPERTIES_IFACE)

320

319

if options.secret:

321

client.Set(client_interface, "Secret",

320

client.Set(client_interface, u"Secret",

322

321

dbus.ByteArray(open(options.secret,

323

"rb").read()),

322

u'rb').read()),

324

323

dbus_interface=dbus.PROPERTIES_IFACE)

325

324

if options.approved_by_default is not None:

326

client.Set(client_interface, "ApprovedByDefault",

325

client.Set(client_interface, u"ApprovedByDefault",

327

326

dbus.Boolean(options

328

327

.approved_by_default),

329

328

dbus_interface=dbus.PROPERTIES_IFACE)

334

333

client.Approve(dbus.Boolean(False),

335

334

dbus_interface=client_interface)

336

335

337

if __name__ == "__main__":

336

if __name__ == '__main__':

338

337

main()