/mandos/trunk : revision 24.1.163

To get this branch, use:

bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to mandos-ctl

Committer: Björn Påhlsson
Date: 2010-09-12 18:12:11 UTC
mto: (237.4.3 mandos-release)
mto: This revision was merged to the branch mainline in revision 428.
Revision ID: belorn@fukt.bsnet.se-20100912181211-wvkt0sk37zhx7tws

mandos-client: Added never ending loop for --connect
mandos-ctl: Better option parsing.

Show diffs side-by-side

added added

removed removed

mandos-ctl

#!/usr/bin/python

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

# Mandos Monitor - Control and monitor the Mandos server

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

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

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

# (at your option) any later version.

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

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

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

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

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

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

from __future__ import division

import sys

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

tablewords = {

'Name': u'Name',

'Enabled': u'Enabled',

'Timeout': u'Timeout',

'LastCheckedOK': u'Last Successful Check',

'LastApprovalRequest': u'Last Approval Request',

'Created': u'Created',

'Interval': u'Interval',

'Host': u'Host',

'Fingerprint': u'Fingerprint',

'CheckerRunning': u'Check Is Running',

'LastEnabled': u'Last Enabled',

'ApprovalPending': u'Approval Is Pending',

'ApprovedByDefault': u'Approved By Default',

'ApprovalDelay': u"Approval Delay",

'ApprovalDuration': u"Approval Duration",

'Checker': u'Checker',

'name': u'Name',

'enabled': u'Enabled',

'timeout': u'Timeout',

'last_checked_ok': u'Last Successful Check',

'created': u'Created',

'interval': u'Interval',

'host': u'Host',

'fingerprint': u'Fingerprint',

'checker_running': u'Check Is Running',

'last_enabled': u'Last Enabled',

'checker': u'Checker',

}

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

defaultkeywords = ('name', 'enabled', 'timeout', 'last_checked_ok')

domain = 'se.bsnet.fukt'

busname = domain + '.Mandos'

server_path = '/'

server_interface = domain + '.Mandos'

client_interface = domain + '.Mandos.Client'

version = "1.2"

version = "1.0.14"

def timedelta_to_milliseconds(td):

"Convert a datetime.timedelta object to milliseconds"

119

def valuetostring(value, keyword):

120

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

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

124

return milliseconds_to_string(value)

125

return unicode(value)

126

127

100

# Create format string to print table rows

128

101

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

129

102

max(len(tablewords[key]),

130

max(len(valuetostring(client[key],

131

key))

103

max(len(valuetostring(client[key], key))

132

104

for client in

133

105

clients))

134

106

for key in keywords)

137

109

for client in clients:

138

110

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

139

111

for key in keywords)

140

141

112

def has_actions(options):

142

113

return any((options.enable,

143

114

options.disable,

149

120

options.checker is not None,

150

121

options.timeout is not None,

151

122

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

123

options.host is not None,

156

124

options.secret is not None,

157

125

options.approve,

183

151

help="Set timeout for client")

184

152

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

185

153

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

154

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

197

155

help="Set host for client")

198

156

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

202

160

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

203

161

help="Deny any current client request")

204

162

options, client_names = parser.parse_args()

205

163

206

164

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

207

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

165

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

208

166

if options.verbose and has_actions(options):

209

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

210

' --all.')

167

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

211

168

if options.all and not has_actions(options):

212

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

213

169

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

170

214

171

try:

215

172

bus = dbus.SystemBus()

216

173

mandos_dbus_objc = bus.get_object(busname, server_path)

237

194

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

238

195

sys.exit(1)

239

196

240

# Compile dict of (clients: properties) to process

241

clients={}

242

197

# Compile list of clients to process

198

clients=[]

199

243

200

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

201

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

247

202

else:

248

203

for name in client_names:

249

204

for path, client in mandos_clients.iteritems():

250

if client['Name'] == name:

205

if client['name'] == name:

251

206

client_objc = bus.get_object(busname, path)

252

clients[client_objc] = client

207

clients.append(client_objc)

253

208

break

254

209

else:

255

210

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

257

212

258

213

if not has_actions(options) and clients:

259

214

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

215

keywords = ('name', 'enabled', 'timeout', 'last_checked_ok',

216

'created', 'interval', 'host', 'fingerprint',

217

'checker_running', 'last_enabled', 'checker')

267

218

else:

268

219

keywords = defaultkeywords

269

270

print_clients(clients.values(), keywords)

220

221

print_clients(mandos_clients.values(), keywords)

271

222

else:

272

223

# Process each client in the list by all selected options

273

224

for client in clients:

285

236

client.StopChecker(dbus_interface=client_interface)

286

237

if options.is_enabled:

287

238

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

288

u"Enabled",

239

u"enabled",

289

240

dbus_interface=dbus.PROPERTIES_IFACE)

290

241

else 1)

291

242

if options.checker:

292

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

243

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

293

244

dbus_interface=dbus.PROPERTIES_IFACE)

294

245

if options.host:

295

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

246

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

296

247

dbus_interface=dbus.PROPERTIES_IFACE)

297

248

if options.interval:

298

client.Set(client_interface, u"Interval",

249

client.Set(client_interface, u"interval",

299

250

timedelta_to_milliseconds

300

251

(string_to_delta(options.interval)),

301

252

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

253

if options.timeout:

315

client.Set(client_interface, u"Timeout",

316

timedelta_to_milliseconds

317

(string_to_delta(options.timeout)),

254

client.Set(client_interface, u"timeout",

255

timedelta_to_milliseconds(string_to_delta

256

(options.timeout)),

318

257

dbus_interface=dbus.PROPERTIES_IFACE)

319

258

if options.secret:

320

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

259

client.Set(client_interface, u"secret",

260

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

328

261

dbus_interface=dbus.PROPERTIES_IFACE)

329

262

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)

263

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

264

if options.deny:

265

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

335

266

336

267

if __name__ == '__main__':

337

268

main()

Older »