/mandos/trunk : revision 463.1.8

22

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

23

#

24

25

from __future__ import division

25

from __future__ import division, absolute_import, unicode_literals

26

27

import sys

27

28

import dbus

28

29

from optparse import OptionParser

31

32

import re

32

33

import os

33

34

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

35

locale.setlocale(locale.LC_ALL, "")

35

36

37

tablewords = {

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',

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",

53

54

}

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"

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"

61

62

63

def timedelta_to_milliseconds(td):

63

"Convert a datetime.timedelta object to milliseconds"

64

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

64

65

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

65

66

+ (td.seconds * 1000)

66

67

+ (td.microseconds // 1000))

67

68

69

def milliseconds_to_string(ms):

69

70

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

70

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

71

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

71

72

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

72

73

"hours": td.seconds // 3600,

73

74

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

78

79

def string_to_delta(interval):

79

80

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

80

81

>>> string_to_delta('7d')

82

>>> string_to_delta("7d")

82

83

datetime.timedelta(7)

83

>>> string_to_delta('60s')

84

>>> string_to_delta("60s")

84

85

datetime.timedelta(0, 60)

85

>>> string_to_delta('60m')

86

>>> string_to_delta("60m")

86

87

datetime.timedelta(0, 3600)

87

>>> string_to_delta('24h')

88

>>> string_to_delta("24h")

88

89

datetime.timedelta(1)

89

>>> string_to_delta(u'1w')

90

>>> string_to_delta("1w")

90

91

datetime.timedelta(7)

91

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

92

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

92

93

datetime.timedelta(0, 330)

93

94

"""

94

95

timevalue = datetime.timedelta(0)

98

99

try:

99

100

suffix = unicode(s[-1])

100

101

value = int(s[:-1])

101

if suffix == u"d":

102

if suffix == "d":

102

103

delta = datetime.timedelta(value)

103

elif suffix == u"s":

104

elif suffix == "s":

104

105

delta = datetime.timedelta(0, value)

105

elif suffix == u"m":

106

elif suffix == "m":

106

107

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

107

elif suffix == u"h":

108

elif suffix == "h":

108

109

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

109

elif suffix == u"w":

110

elif suffix == "w":

110

111

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

111

112

else:

112

113

raise ValueError

118

119

def print_clients(clients, keywords):

119

120

def valuetostring(value, keyword):

120

121

if type(value) is dbus.Boolean:

121

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

122

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

123

u"ApprovalDuration"):

122

return "Yes" if value else "No"

123

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

124

"ApprovalDuration"):

124

125

return milliseconds_to_string(value)

125

126

return unicode(value)

126

127

128

# Create format string to print table rows

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)

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)

135

136

# Print header line

136

137

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

137

138

for client in clients:

184

185

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

185

186

help="Set checker interval for client")

186

187

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

187

dest=u"approved_by_default",

188

dest="approved_by_default",

188

189

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

189

190

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

190

dest=u"approved_by_default",

191

dest="approved_by_default",

191

192

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

192

193

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

193

194

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

204

205

options, client_names = parser.parse_args()

205

206

207

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

207

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

208

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

208

209

if options.verbose and has_actions(options):

209

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

210

' --all.')

210

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

211

" --all.")

211

212

if options.all and not has_actions(options):

212

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

213

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

213

214

215

try:

215

216

bus = dbus.SystemBus()

247

248

else:

248

249

for name in client_names:

249

250

for path, client in mandos_clients.iteritems():

250

if client['Name'] == name:

251

if client["Name"] == name:

251

252

client_objc = bus.get_object(busname, path)

252

253

clients[client_objc] = client

253

254

break

257

258

259

if not has_actions(options) and clients:

259

260

if options.verbose:

260

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

261

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

262

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

263

'LastEnabled', 'ApprovalPending',

264

'ApprovedByDefault',

265

'LastApprovalRequest', 'ApprovalDelay',

266

'ApprovalDuration', 'Checker')

261

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

262

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

263

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

264

"LastEnabled", "ApprovalPending",

265

"ApprovedByDefault",

266

"LastApprovalRequest", "ApprovalDelay",

267

"ApprovalDuration", "Checker")

267

268

else:

268

269

keywords = defaultkeywords

269

270

285

286

client.StopChecker(dbus_interface=client_interface)

286

287

if options.is_enabled:

287

288

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

288

u"Enabled",

289

"Enabled",

289

290

dbus_interface=dbus.PROPERTIES_IFACE)

290

291

else 1)

291

292

if options.checker:

292

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

293

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

293

294

dbus_interface=dbus.PROPERTIES_IFACE)

294

295

if options.host:

295

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

296

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

296

297

dbus_interface=dbus.PROPERTIES_IFACE)

297

298

if options.interval:

298

client.Set(client_interface, u"Interval",

299

client.Set(client_interface, "Interval",

299

300

timedelta_to_milliseconds

300

301

(string_to_delta(options.interval)),

301

302

dbus_interface=dbus.PROPERTIES_IFACE)

302

303

if options.approval_delay:

303

client.Set(client_interface, u"ApprovalDelay",

304

client.Set(client_interface, "ApprovalDelay",

304

305

timedelta_to_milliseconds

305

306

(string_to_delta(options.

306

307

approval_delay)),

307

308

dbus_interface=dbus.PROPERTIES_IFACE)

308

309

if options.approval_duration:

309

client.Set(client_interface, u"ApprovalDuration",

310

client.Set(client_interface, "ApprovalDuration",

310

311

timedelta_to_milliseconds

311

312

(string_to_delta(options.

312

313

approval_duration)),

313

314

dbus_interface=dbus.PROPERTIES_IFACE)

314

315

if options.timeout:

315

client.Set(client_interface, u"Timeout",

316

client.Set(client_interface, "Timeout",

316

317

timedelta_to_milliseconds

317

318

(string_to_delta(options.timeout)),

318

319

dbus_interface=dbus.PROPERTIES_IFACE)

319

320

if options.secret:

320

client.Set(client_interface, u"Secret",

321

client.Set(client_interface, "Secret",

321

322

dbus.ByteArray(open(options.secret,

322

u'rb').read()),

323

"rb").read()),

323

324

dbus_interface=dbus.PROPERTIES_IFACE)

324

325

if options.approved_by_default is not None:

325

client.Set(client_interface, u"ApprovedByDefault",

326

client.Set(client_interface, "ApprovedByDefault",

326

327

dbus.Boolean(options

327

328

.approved_by_default),

328

329

dbus_interface=dbus.PROPERTIES_IFACE)

333

334

client.Approve(dbus.Boolean(False),

334

335

dbus_interface=client_interface)

335

336

if __name__ == '__main__':

337

if __name__ == "__main__":

337

338

main()