/mandos/release : revision 24.1.166

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

#

24

3

25

4

from __future__ import division

26

5

import sys

38

17

'Enabled': u'Enabled',

39

18

'Timeout': u'Timeout',

40

19

'LastCheckedOK': u'Last Successful Check',

41

'LastApprovalRequest': u'Last Approval Request',

42

20

'Created': u'Created',

43

21

'Interval': u'Interval',

44

22

'Host': u'Host',

45

23

'Fingerprint': u'Fingerprint',

46

24

'CheckerRunning': u'Check Is Running',

47

25

'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

26

'Checker': u'Checker',

53

27

}

54

28

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

57

31

server_path = '/'

58

32

server_interface = domain + '.Mandos'

59

33

client_interface = domain + '.Mandos.Client'

60

version = "1.2"

34

version = "1.0.14"

61

35

62

36

def timedelta_to_milliseconds(td):

63

37

"Convert a datetime.timedelta object to milliseconds"

119

93

def valuetostring(value, keyword):

120

94

if type(value) is dbus.Boolean:

121

95

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

122

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

123

u"ApprovalDuration"):

96

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

124

97

return milliseconds_to_string(value)

125

98

return unicode(value)

126

99

137

110

for client in clients:

138

111

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

139

112

for key in keywords)

140

141

113

def has_actions(options):

142

114

return any((options.enable,

143

115

options.disable,

149

121

options.checker is not None,

150

122

options.timeout is not None,

151

123

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,

155

124

options.host is not None,

156

125

options.secret is not None,

157

126

options.approve,

183

152

help="Set timeout for client")

184

153

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

185

154

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

196

155

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

197

156

help="Set host for client")

198

157

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

202

161

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

203

162

help="Deny any current client request")

204

163

options, client_names = parser.parse_args()

205

164

206

165

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

207

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

166

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

208

167

if options.verbose and has_actions(options):

209

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

210

' --all.')

168

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

211

169

if options.all and not has_actions(options):

212

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

213

170

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

171

214

172

try:

215

173

bus = dbus.SystemBus()

216

174

mandos_dbus_objc = bus.get_object(busname, server_path)

237

195

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

238

196

sys.exit(1)

239

197

240

# Compile dict of (clients: properties) to process

241

clients={}

242

198

# Compile list of clients to process

199

clients=[]

200

243

201

if options.all or not client_names:

244

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

245

for path, properties in

246

mandos_clients.iteritems())

202

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

247

203

else:

248

204

for name in client_names:

249

205

for path, client in mandos_clients.iteritems():

250

206

if client['Name'] == name:

251

207

client_objc = bus.get_object(busname, path)

252

clients[client_objc] = client

208

clients.append(client_objc)

253

209

break

254

210

else:

255

211

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

257

213

258

214

if not has_actions(options) and clients:

259

215

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

216

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

217

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

218

'CheckerRunning', 'LastEnabled', 'Checker')

267

219

else:

268

220

keywords = defaultkeywords

269

270

print_clients(clients.values(), keywords)

221

222

print_clients(mandos_clients.values(), keywords)

271

223

else:

272

224

# Process each client in the list by all selected options

273

225

for client in clients:

299

251

timedelta_to_milliseconds

300

252

(string_to_delta(options.interval)),

301

253

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)

314

254

if options.timeout:

315

255

client.Set(client_interface, u"Timeout",

316

timedelta_to_milliseconds

317

(string_to_delta(options.timeout)),

256

timedelta_to_milliseconds(string_to_delta

257

(options.timeout)),

318

258

dbus_interface=dbus.PROPERTIES_IFACE)

319

259

if options.secret:

320

260

client.Set(client_interface, u"Secret",

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

261

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

328

262

dbus_interface=dbus.PROPERTIES_IFACE)

329

263

if options.approve:

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)

264

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

265

if options.deny:

266

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

335

267

336

268

if __name__ == '__main__':

337

269

main()