/mandos/release : revision 24.1.170

1

#!/usr/bin/python

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos Monitor - Control and monitor the Mandos server

5

#

6

7

8

#

9

# This program is free software: you can redistribute it and/or modify

10

# it under the terms of the GNU General Public License as published by

11

# the Free Software Foundation, either version 3 of the License, or

12

# (at your option) any later version.

13

#

14

# This program is distributed in the hope that it will be useful,

15

# but WITHOUT ANY WARRANTY; without even the implied warranty of

16

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

# GNU General Public License for more details.

18

#

19

# You should have received a copy of the GNU General Public License

20

# along with this program. If not, see <http://www.gnu.org/licenses/>.

21

#

22

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

23

#

3

24

4

25

from __future__ import division

5

26

import sys

17

38

'Enabled': u'Enabled',

18

39

'Timeout': u'Timeout',

19

40

'LastCheckedOK': u'Last Successful Check',

41

'LastApprovalRequest': u'Last Approval Request',

20

42

'Created': u'Created',

21

43

'Interval': u'Interval',

22

44

'Host': u'Host',

23

45

'Fingerprint': u'Fingerprint',

24

46

'CheckerRunning': u'Check Is Running',

25

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

26

52

'Checker': u'Checker',

27

53

}

28

54

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

31

57

server_path = '/'

32

58

server_interface = domain + '.Mandos'

33

59

client_interface = domain + '.Mandos.Client'

34

version = "1.0.14"

60

version = "1.2.1"

35

61

36

62

def timedelta_to_milliseconds(td):

37

63

"Convert a datetime.timedelta object to milliseconds"

93

119

def valuetostring(value, keyword):

94

120

if type(value) is dbus.Boolean:

95

121

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

96

if keyword in (u"timeout", u"interval"):

122

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

123

u"ApprovalDuration"):

97

124

return milliseconds_to_string(value)

98

125

return unicode(value)

99

126

110

137

for client in clients:

111

138

print format_string % tuple(valuetostring(client[key], key)

112

139

for key in keywords)

140

113

141

def has_actions(options):

114

142

return any((options.enable,

115

143

options.disable,

121

149

options.checker is not None,

122

150

options.timeout is not None,

123

151

options.interval is not None,

152

options.approved_by_default is not None,

153

options.approval_delay is not None,

154

options.approval_duration is not None,

124

155

options.host is not None,

125

156

options.secret is not None,

126

157

options.approve,

152

183

help="Set timeout for client")

153

184

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

154

185

help="Set checker interval for client")

186

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

187

dest=u"approved_by_default",

188

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

189

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

190

dest=u"approved_by_default",

191

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

192

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

193

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

194

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

195

help="Set duration of one client approval")

155

196

parser.add_option("-H", "--host", type="string",

156

197

help="Set host for client")

157

198

parser.add_option("-s", "--secret", type="string",

161

202

parser.add_option("-D", "--deny", action="store_true",

162

203

help="Deny any current client request")

163

204

options, client_names = parser.parse_args()

164

205

165

206

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

166

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

207

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

167

208

if options.verbose and has_actions(options):

168

parser.error('Verbose option can only be used alone or with --all.')

209

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

210

' --all.')

169

211

if options.all and not has_actions(options):

170

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

171

212

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

213

172

214

try:

173

215

bus = dbus.SystemBus()

174

216

mandos_dbus_objc = bus.get_object(busname, server_path)

195

237

print >> sys.stderr, "Access denied: Accessing mandos server through dbus."

196

238

sys.exit(1)

197

239

198

# Compile list of clients to process

199

clients=[]

200

240

# Compile dict of (clients: properties) to process

241

clients={}

242

201

243

if options.all or not client_names:

202

clients = (bus.get_object(busname, path) for path in mandos_clients.iterkeys())

244

clients = dict((bus.get_object(busname, path), properties)

245

for path, properties in

246

mandos_clients.iteritems())

203

247

else:

204

248

for name in client_names:

205

249

for path, client in mandos_clients.iteritems():

206

250

if client['Name'] == name:

207

251

client_objc = bus.get_object(busname, path)

208

clients.append(client_objc)

252

clients[client_objc] = client

209

253

break

210

254

else:

211

255

print >> sys.stderr, "Client not found on server: %r" % name

213

257

214

258

if not has_actions(options) and clients:

215

259

if options.verbose:

216

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

217

'Created', 'Interval', 'Host', 'Fingerprint',

218

'CheckerRunning', 'LastEnabled', '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')

219

267

else:

220

268

keywords = defaultkeywords

221

222

print_clients(mandos_clients.values(), keywords)

269

270

print_clients(clients.values(), keywords)

223

271

else:

224

272

# Process each client in the list by all selected options

225

273

for client in clients:

251

299

timedelta_to_milliseconds

252

300

(string_to_delta(options.interval)),

253

301

dbus_interface=dbus.PROPERTIES_IFACE)

302

if options.approval_delay:

303

client.Set(client_interface, u"ApprovalDelay",

304

timedelta_to_milliseconds

305

(string_to_delta(options.

306

approval_delay)),

307

dbus_interface=dbus.PROPERTIES_IFACE)

308

if options.approval_duration:

309

client.Set(client_interface, u"ApprovalDuration",

310

timedelta_to_milliseconds

311

(string_to_delta(options.

312

approval_duration)),

313

dbus_interface=dbus.PROPERTIES_IFACE)

254

314

if options.timeout:

255

315

client.Set(client_interface, u"Timeout",

256

timedelta_to_milliseconds(string_to_delta

257

(options.timeout)),

316

timedelta_to_milliseconds

317

(string_to_delta(options.timeout)),

258

318

dbus_interface=dbus.PROPERTIES_IFACE)

259

319

if options.secret:

260

320

client.Set(client_interface, u"Secret",

261

dbus.ByteArray(open(options.secret, u'rb').read()),

321

dbus.ByteArray(open(options.secret,

322

u'rb').read()),

323

dbus_interface=dbus.PROPERTIES_IFACE)

324

if options.approved_by_default is not None:

325

client.Set(client_interface, u"ApprovedByDefault",

326

dbus.Boolean(options

327

.approved_by_default),

262

328

dbus_interface=dbus.PROPERTIES_IFACE)

263

329

if options.approve:

264

client.Approve(dbus.Boolean(True), dbus_interface=client_interface)

265

if options.deny:

266

client.Approve(dbus.Boolean(False), dbus_interface=client_interface)

330

client.Approve(dbus.Boolean(True),

331

dbus_interface=client_interface)

332

elif options.deny:

333

client.Approve(dbus.Boolean(False),

334

dbus_interface=client_interface)

267

335

268

336

if __name__ == '__main__':

269

337

main()