/mandos/trunk : revision 606

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/>.

20

# along with this program. If not, see

21

# <http://www.gnu.org/licenses/>.

21

22

#

22

23

# Contact the authors at <mandos@recompile.se>.

23

24

#

25

26

from __future__ import (division, absolute_import, print_function,

26

27

unicode_literals)

27

28

29

from future_builtins import *

30

28

31

import sys

29

32

import dbus

30

33

import argparse

60

63

server_path = "/"

61

64

server_interface = domain + ".Mandos"

62

65

client_interface = domain + ".Mandos.Client"

63

version = "1.5.0"

66

version = "1.5.5"

64

67

65

68

def timedelta_to_milliseconds(td):

66

69

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

70

73

71

74

def milliseconds_to_string(ms):

72

75

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

73

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

74

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

75

"hours": td.seconds // 3600,

76

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

77

"seconds": td.seconds % 60,

78

})

76

return ("{days}{hours:02}:{minutes:02}:{seconds:02}"

77

.format(days = "{0}T".format(td.days) if td.days else "",

78

hours = td.seconds // 3600,

79

minutes = (td.seconds % 3600) // 60,

80

seconds = td.seconds % 60,

81

))

79

82

80

83

def string_to_delta(interval):

81

84

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

116

119

if type(value) is dbus.Boolean:

117

120

return "Yes" if value else "No"

118

121

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

119

"ApprovalDuration"):

122

"ApprovalDuration", "ExtendedTimeout"):

120

123

return milliseconds_to_string(value)

121

124

return unicode(value)

122

125

123

126

# Create format string to print table rows

124

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

125

max(len(tablewords[key]),

126

max(len(valuetostring(client[key],

127

key))

128

for client in

129

clients))

130

for key in keywords)

127

format_string = " ".join("{{{key}:{width}}}".format(

128

width = max(len(tablewords[key]),

129

max(len(valuetostring(client[key],

130

key))

131

for client in

132

clients)),

133

key = key) for key in keywords)

131

134

# Print header line

132

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

135

print(format_string.format(**tablewords))

133

136

for client in clients:

134

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

135

for key in keywords))

137

print(format_string.format(**dict((key,

138

valuetostring(client[key],

139

key))

140

for key in keywords)))

136

141

137

142

def has_actions(options):

138

143

return any((options.enable,

157

162

def main():

158

163

parser = argparse.ArgumentParser()

159

164

parser.add_argument("--version", action="version",

160

version = "%%prog %s" % version,

165

version = "%(prog)s {0}".format(version),

161

166

help="show version number and exit")

162

167

parser.add_argument("-a", "--all", action="store_true",

163

168

help="Select all clients")

205

210

parser.add_argument("client", nargs="*", help="Client name")

206

211

options = parser.parse_args()

207

212

208

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

213

if has_actions(options) and not (options.client or options.all):

209

214

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

210

215

if options.verbose and has_actions(options):

211

216

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

256

261

clients[client_objc] = client

257

262

break

258

263

else:

259

print("Client not found on server: %r" % name,

260

file=sys.stderr)

264

print("Client not found on server: {0!r}"

265

.format(name), file=sys.stderr)

261

266

sys.exit(1)

262

267

263

268

if not has_actions(options) and clients:

277

282

else:

278

283

# Process each client in the list by all selected options

279

284

for client in clients:

285

def set_client_prop(prop, value):

286

"""Set a Client D-Bus property"""

287

client.Set(client_interface, prop, value,

288

dbus_interface=dbus.PROPERTIES_IFACE)

289

def set_client_prop_ms(prop, value):

290

"""Set a Client D-Bus property, converted

291

from a string to milliseconds."""

292

set_client_prop(prop,

293

timedelta_to_milliseconds

294

(string_to_delta(value)))

280

295

if options.remove:

281

296

mandos_serv.RemoveClient(client.__dbus_object_path__)

282

297

if options.enable:

283

client.Enable(dbus_interface=client_interface)

298

set_client_prop("Enabled", dbus.Boolean(True))

284

299

if options.disable:

285

client.Disable(dbus_interface=client_interface)

300

set_client_prop("Enabled", dbus.Boolean(False))

286

301

if options.bump_timeout:

287

client.CheckedOK(dbus_interface=client_interface)

302

set_client_prop("LastCheckedOK", "")

288

303

if options.start_checker:

289

client.StartChecker(dbus_interface=client_interface)

304

set_client_prop("CheckerRunning", dbus.Boolean(True))

290

305

if options.stop_checker:

291

client.StopChecker(dbus_interface=client_interface)

306

set_client_prop("CheckerRunning", dbus.Boolean(False))

292

307

if options.is_enabled:

293

308

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

294

309

"Enabled",

296

311

dbus.PROPERTIES_IFACE)

297

312

else 1)

298

313

if options.checker is not None:

299

client.Set(client_interface, "Checker",

300

options.checker,

301

dbus_interface=dbus.PROPERTIES_IFACE)

314

set_client_prop("Checker", options.checker)

302

315

if options.host is not None:

303

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

304

dbus_interface=dbus.PROPERTIES_IFACE)

316

set_client_prop("Host", options.host)

305

317

if options.interval is not None:

306

client.Set(client_interface, "Interval",

307

timedelta_to_milliseconds

308

(string_to_delta(options.interval)),

309

dbus_interface=dbus.PROPERTIES_IFACE)

318

set_client_prop_ms("Interval", options.interval)

310

319

if options.approval_delay is not None:

311

client.Set(client_interface, "ApprovalDelay",

312

timedelta_to_milliseconds

313

(string_to_delta(options.

314

approval_delay)),

315

dbus_interface=dbus.PROPERTIES_IFACE)

320

set_client_prop_ms("ApprovalDelay",

321

options.approval_delay)

316

322

if options.approval_duration is not None:

317

client.Set(client_interface, "ApprovalDuration",

318

timedelta_to_milliseconds

319

(string_to_delta(options.

320

approval_duration)),

321

dbus_interface=dbus.PROPERTIES_IFACE)

323

set_client_prop_ms("ApprovalDuration",

324

options.approval_duration)

322

325

if options.timeout is not None:

323

client.Set(client_interface, "Timeout",

324

timedelta_to_milliseconds

325

(string_to_delta(options.timeout)),

326

dbus_interface=dbus.PROPERTIES_IFACE)

326

set_client_prop_ms("Timeout", options.timeout)

327

if options.extended_timeout is not None:

328

client.Set(client_interface, "ExtendedTimeout",

329

timedelta_to_milliseconds

330

(string_to_delta(options.extended_timeout)),

331

dbus_interface=dbus.PROPERTIES_IFACE)

328

set_client_prop_ms("ExtendedTimeout",

329

options.extended_timeout)

332

330

if options.secret is not None:

333

client.Set(client_interface, "Secret",

334

dbus.ByteArray(options.secret.read()),

335

dbus_interface=dbus.PROPERTIES_IFACE)

331

set_client_prop("Secret",

332

dbus.ByteArray(options.secret.read()))

336

333

if options.approved_by_default is not None:

337

client.Set(client_interface, "ApprovedByDefault",

338

dbus.Boolean(options

339

.approved_by_default),

340

dbus_interface=dbus.PROPERTIES_IFACE)

334

set_client_prop("ApprovedByDefault",

335

dbus.Boolean(options

336

.approved_by_default))

341

337

if options.approve:

342

338

client.Approve(dbus.Boolean(True),

343

339

dbus_interface=client_interface)