/mandos/trunk : revision 636

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

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

28

# along with this program. If not, see

29

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

30

#

31

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

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

37

39

import SocketServer as socketserver

38

40

import socket

39

41

import argparse

62

64

import functools

63

65

import cPickle as pickle

64

66

import multiprocessing

67

import types

68

import binascii

69

import tempfile

70

import itertools

71

import collections

65

72

66

73

import dbus

67

74

import dbus.service

81

88

except ImportError:

82

89

SO_BINDTODEVICE = None

83

90

84

85

version = "1.3.1"

86

87

#logger = logging.getLogger('mandos')

88

logger = logging.Logger('mandos')

91

version = "1.6.2"

92

stored_state_file = "clients.pickle"

93

94

logger = logging.getLogger()

89

95

syslogger = (logging.handlers.SysLogHandler

90

96

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

97

address = str("/dev/log")))

92

syslogger.setFormatter(logging.Formatter

93

('Mandos [%(process)d]: %(levelname)s:'

94

' %(message)s'))

95

logger.addHandler(syslogger)

96

97

console = logging.StreamHandler()

98

console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'

99

' %(levelname)s:'

100

' %(message)s'))

101

logger.addHandler(console)

98

99

try:

100

if_nametoindex = (ctypes.cdll.LoadLibrary

101

(ctypes.util.find_library("c"))

102

.if_nametoindex)

103

except (OSError, AttributeError):

104

def if_nametoindex(interface):

105

"Get an interface index the hard way, i.e. using fcntl()"

106

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

107

with contextlib.closing(socket.socket()) as s:

108

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

109

struct.pack(str("16s16x"),

110

interface))

111

interface_index = struct.unpack(str("I"),

112

ifreq[16:20])[0]

113

return interface_index

114

115

116

def initlogger(debug, level=logging.WARNING):

117

"""init logger and add loglevel"""

118

119

syslogger.setFormatter(logging.Formatter

120

('Mandos [%(process)d]: %(levelname)s:'

121

' %(message)s'))

122

logger.addHandler(syslogger)

123

124

if debug:

125

console = logging.StreamHandler()

126

console.setFormatter(logging.Formatter('%(asctime)s %(name)s'

127

' [%(process)d]:'

128

' %(levelname)s:'

129

' %(message)s'))

130

logger.addHandler(console)

131

logger.setLevel(level)

132

133

134

class PGPError(Exception):

135

"""Exception if encryption/decryption fails"""

136

pass

137

138

139

class PGPEngine(object):

140

"""A simple class for OpenPGP symmetric encryption & decryption"""

141

def __init__(self):

142

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

143

self.gnupgargs = ['--batch',

144

'--home', self.tempdir,

145

'--force-mdc',

146

'--quiet',

147

'--no-use-agent']

148

149

def __enter__(self):

150

return self

151

152

def __exit__(self, exc_type, exc_value, traceback):

153

self._cleanup()

154

return False

155

156

def __del__(self):

157

self._cleanup()

158

159

def _cleanup(self):

160

if self.tempdir is not None:

161

# Delete contents of tempdir

162

for root, dirs, files in os.walk(self.tempdir,

163

topdown = False):

164

for filename in files:

165

os.remove(os.path.join(root, filename))

166

for dirname in dirs:

167

os.rmdir(os.path.join(root, dirname))

168

# Remove tempdir

169

os.rmdir(self.tempdir)

170

self.tempdir = None

171

172

def password_encode(self, password):

173

# Passphrase can not be empty and can not contain newlines or

174

# NUL bytes. So we prefix it and hex encode it.

175

encoded = b"mandos" + binascii.hexlify(password)

176

if len(encoded) > 2048:

177

# GnuPG can't handle long passwords, so encode differently

178

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

179

.replace(b"\n", b"\\n")

180

.replace(b"\0", b"\\x00"))

181

return encoded

182

183

def encrypt(self, data, password):

184

passphrase = self.password_encode(password)

185

with tempfile.NamedTemporaryFile(dir=self.tempdir

186

) as passfile:

187

passfile.write(passphrase)

188

passfile.flush()

189

proc = subprocess.Popen(['gpg', '--symmetric',

190

'--passphrase-file',

191

passfile.name]

192

+ self.gnupgargs,

193

stdin = subprocess.PIPE,

194

stdout = subprocess.PIPE,

195

stderr = subprocess.PIPE)

196

ciphertext, err = proc.communicate(input = data)

197

if proc.returncode != 0:

198

raise PGPError(err)

199

return ciphertext

200

201

def decrypt(self, data, password):

202

passphrase = self.password_encode(password)

203

with tempfile.NamedTemporaryFile(dir = self.tempdir

204

) as passfile:

205

passfile.write(passphrase)

206

passfile.flush()

207

proc = subprocess.Popen(['gpg', '--decrypt',

208

'--passphrase-file',

209

passfile.name]

210

+ self.gnupgargs,

211

stdin = subprocess.PIPE,

212

stdout = subprocess.PIPE,

213

stderr = subprocess.PIPE)

214

decrypted_plaintext, err = proc.communicate(input

215

= data)

216

if proc.returncode != 0:

217

raise PGPError(err)

218

return decrypted_plaintext

219

102

220

103

221

class AvahiError(Exception):

104

222

def __init__(self, value, *args, **kwargs):

122

240

Used to optionally bind to the specified interface.

123

241

name: string; Example: 'Mandos'

124

242

type: string; Example: '_mandos._tcp'.

125

See <http://www.dns-sd.org/ServiceTypes.html>

243

See <https://www.iana.org/assignments/service-names-port-numbers>

126

244

port: integer; what port to announce

127

245

TXT: list of strings; TXT record for the service

128

246

domain: string; Domain to publish on, default to .local if empty.

134

252

server: D-Bus Server

135

253

bus: dbus.SystemBus()

136

254

"""

255

137

256

def __init__(self, interface = avahi.IF_UNSPEC, name = None,

138

257

servicetype = None, port = None, TXT = None,

139

258

domain = "", host = "", max_renames = 32768,

152

271

self.server = None

153

272

self.bus = bus

154

273

self.entry_group_state_changed_match = None

274

155

275

def rename(self):

156

276

"""Derived from the Avahi example code"""

157

277

if self.rename_count >= self.max_renames:

159

279

" after %i retries, exiting.",

160

280

self.rename_count)

161

281

raise AvahiServiceError("Too many renames")

162

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

282

self.name = unicode(self.server

283

.GetAlternativeServiceName(self.name))

163

284

logger.info("Changing Zeroconf service name to %r ...",

164

285

self.name)

165

syslogger.setFormatter(logging.Formatter

166

('Mandos (%s) [%%(process)d]:'

167

' %%(levelname)s: %%(message)s'

168

% self.name))

169

286

self.remove()

170

287

try:

171

288

self.add()

172

289

except dbus.exceptions.DBusException as error:

173

logger.critical("DBusException: %s", error)

290

logger.critical("D-Bus Exception", exc_info=error)

174

291

self.cleanup()

175

292

os._exit(1)

176

293

self.rename_count += 1

294

177

295

def remove(self):

178

296

"""Derived from the Avahi example code"""

179

297

if self.entry_group_state_changed_match is not None:

181

299

self.entry_group_state_changed_match = None

182

300

if self.group is not None:

183

301

self.group.Reset()

302

184

303

def add(self):

185

304

"""Derived from the Avahi example code"""

186

305

self.remove()

191

310

avahi.DBUS_INTERFACE_ENTRY_GROUP)

192

311

self.entry_group_state_changed_match = (

193

312

self.group.connect_to_signal(

194

'StateChanged', self .entry_group_state_changed))

313

'StateChanged', self.entry_group_state_changed))

195

314

logger.debug("Adding Zeroconf service '%s' of type '%s' ...",

196

315

self.name, self.type)

197

316

self.group.AddService(

203

322

dbus.UInt16(self.port),

204

323

avahi.string_array_to_txt_array(self.TXT))

205

324

self.group.Commit()

325

206

326

def entry_group_state_changed(self, state, error):

207

327

"""Derived from the Avahi example code"""

208

328

logger.debug("Avahi entry group state change: %i", state)

215

335

elif state == avahi.ENTRY_GROUP_FAILURE:

216

336

logger.critical("Avahi: Error in group state changed %s",

217

337

unicode(error))

218

raise AvahiGroupError("State changed: %s"

219

% unicode(error))

338

raise AvahiGroupError("State changed: {0!s}"

339

.format(error))

340

220

341

def cleanup(self):

221

342

"""Derived from the Avahi example code"""

222

343

if self.group is not None:

223

344

try:

224

345

self.group.Free()

225

346

except (dbus.exceptions.UnknownMethodException,

226

dbus.exceptions.DBusException) as e:

347

dbus.exceptions.DBusException):

227

348

pass

228

349

self.group = None

229

350

self.remove()

351

230

352

def server_state_changed(self, state, error=None):

231

353

"""Derived from the Avahi example code"""

232

354

logger.debug("Avahi server state change: %i", state)

251

373

logger.debug("Unknown state: %r", state)

252

374

else:

253

375

logger.debug("Unknown state: %r: %r", state, error)

376

254

377

def activate(self):

255

378

"""Derived from the Avahi example code"""

256

379

if self.server is None:

264

387

self.server_state_changed(self.server.GetState())

265

388

266

389

267

def _timedelta_to_milliseconds(td):

390

class AvahiServiceToSyslog(AvahiService):

391

def rename(self):

392

"""Add the new name to the syslog messages"""

393

ret = AvahiService.rename(self)

394

syslogger.setFormatter(logging.Formatter

395

('Mandos ({0}) [%(process)d]:'

396

' %(levelname)s: %(message)s'

397

.format(self.name)))

398

return ret

399

400

401

def timedelta_to_milliseconds(td):

268

402

"Convert a datetime.timedelta() to milliseconds"

269

403

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

270

404

+ (td.seconds * 1000)

271

405

+ (td.microseconds // 1000))

272

406

407

273

408

class Client(object):

274

409

"""A representation of a client host served by this server.

275

410

276

411

Attributes:

277

_approved: bool(); 'None' if not yet approved/disapproved

412

approved: bool(); 'None' if not yet approved/disapproved

278

413

approval_delay: datetime.timedelta(); Time to wait for approval

279

414

approval_duration: datetime.timedelta(); Duration of one approval

280

415

checker: subprocess.Popen(); a running checker process used

287

422

instance %(name)s can be used in the command.

288

423

checker_initiator_tag: a gobject event source tag, or None

289

424

created: datetime.datetime(); (UTC) object creation

425

client_structure: Object describing what attributes a client has

426

and is used for storing the client at exit

290

427

current_checker_command: string; current running checker_command

291

disable_hook: If set, called by disable() as disable_hook(self)

292

428

disable_initiator_tag: a gobject event source tag, or None

293

429

enabled: bool()

294

430

fingerprint: string (40 or 32 hexadecimal digits); used to

297

433

interval: datetime.timedelta(); How often to start a new checker

298

434

last_approval_request: datetime.datetime(); (UTC) or None

299

435

last_checked_ok: datetime.datetime(); (UTC) or None

300

last_enabled: datetime.datetime(); (UTC)

436

last_checker_status: integer between 0 and 255 reflecting exit

437

status of last checker. -1 reflects crashed

438

checker, -2 means no checker completed yet.

439

last_enabled: datetime.datetime(); (UTC) or None

301

440

name: string; from the config file, used in log messages and

302

441

D-Bus identifiers

303

442

secret: bytestring; sent verbatim (over TLS) to client

304

443

timeout: datetime.timedelta(); How long from last_checked_ok

305

444

until this client is disabled

306

extended_timeout: extra long timeout when password has been sent

445

extended_timeout: extra long timeout when secret has been sent

307

446

runtime_expansions: Allowed attributes for runtime expansion.

308

447

expires: datetime.datetime(); time (UTC) when a client will be

309

448

disabled, or None

449

server_settings: The server_settings dict from main()

310

450

"""

311

451

312

452

runtime_expansions = ("approval_delay", "approval_duration",

313

"created", "enabled", "fingerprint",

314

"host", "interval", "last_checked_ok",

453

"created", "enabled", "expires",

454

"fingerprint", "host", "interval",

455

"last_approval_request", "last_checked_ok",

315

456

"last_enabled", "name", "timeout")

316

457

client_defaults = { "timeout": "PT5M",

458

"extended_timeout": "PT15M",

459

"interval": "PT2M",

460

"checker": "fping -q -- %%(host)s",

461

"host": "",

462

"approval_delay": "PT0S",

463

"approval_duration": "PT1S",

464

"approved_by_default": "True",

465

"enabled": "True",

466

}

467

317

468

def timeout_milliseconds(self):

318

469

"Return the 'timeout' attribute in milliseconds"

319

return _timedelta_to_milliseconds(self.timeout)

320

470

return timedelta_to_milliseconds(self.timeout)

471

321

472

def extended_timeout_milliseconds(self):

322

473

"Return the 'extended_timeout' attribute in milliseconds"

323

return _timedelta_to_milliseconds(self.extended_timeout)

474

return timedelta_to_milliseconds(self.extended_timeout)

324

475

325

476

def interval_milliseconds(self):

326

477

"Return the 'interval' attribute in milliseconds"

327

return _timedelta_to_milliseconds(self.interval)

328

478

return timedelta_to_milliseconds(self.interval)

479

329

480

def approval_delay_milliseconds(self):

330

return _timedelta_to_milliseconds(self.approval_delay)

331

332

def __init__(self, name = None, disable_hook=None, config=None):

333

"""Note: the 'checker' key in 'config' sets the

334

'checker_command' attribute and *not* the 'checker'

335

attribute."""

481

return timedelta_to_milliseconds(self.approval_delay)

482

483

@staticmethod

484

def config_parser(config):

485

"""Construct a new dict of client settings of this form:

486

{ client_name: {setting_name: value, ...}, ...}

487

with exceptions for any special settings as defined above.

488

NOTE: Must be a pure function. Must return the same result

489

value given the same arguments.

490

"""

491

settings = {}

492

for client_name in config.sections():

493

section = dict(config.items(client_name))

494

client = settings[client_name] = {}

495

496

client["host"] = section["host"]

497

# Reformat values from string types to Python types

498

client["approved_by_default"] = config.getboolean(

499

client_name, "approved_by_default")

500

client["enabled"] = config.getboolean(client_name,

501

"enabled")

502

503

client["fingerprint"] = (section["fingerprint"].upper()

504

.replace(" ", ""))

505

if "secret" in section:

506

client["secret"] = section["secret"].decode("base64")

507

elif "secfile" in section:

508

with open(os.path.expanduser(os.path.expandvars

509

(section["secfile"])),

510

"rb") as secfile:

511

client["secret"] = secfile.read()

512

else:

513

raise TypeError("No secret or secfile for section {0}"

514

.format(section))

515

client["timeout"] = string_to_delta(section["timeout"])

516

client["extended_timeout"] = string_to_delta(

517

section["extended_timeout"])

518

client["interval"] = string_to_delta(section["interval"])

519

client["approval_delay"] = string_to_delta(

520

section["approval_delay"])

521

client["approval_duration"] = string_to_delta(

522

section["approval_duration"])

523

client["checker_command"] = section["checker"]

524

client["last_approval_request"] = None

525

client["last_checked_ok"] = None

526

client["last_checker_status"] = -2

527

528

return settings

529

530

def __init__(self, settings, name = None, server_settings=None):

336

531

self.name = name

337

if config is None:

338

config = {}

532

if server_settings is None:

533

server_settings = {}

534

self.server_settings = server_settings

535

# adding all client settings

536

for setting, value in settings.iteritems():

537

setattr(self, setting, value)

538

539

if self.enabled:

540

if not hasattr(self, "last_enabled"):

541

self.last_enabled = datetime.datetime.utcnow()

542

if not hasattr(self, "expires"):

543

self.expires = (datetime.datetime.utcnow()

544

+ self.timeout)

545

else:

546

self.last_enabled = None

547

self.expires = None

548

339

549

logger.debug("Creating client %r", self.name)

340

550

# Uppercase and remove spaces from fingerprint for later

341

551

# comparison purposes with return value from the fingerprint()

342

552

# function

343

self.fingerprint = (config["fingerprint"].upper()

344

.replace(" ", ""))

345

553

logger.debug(" Fingerprint: %s", self.fingerprint)

346

if "secret" in config:

347

self.secret = config["secret"].decode("base64")

348

elif "secfile" in config:

349

with open(os.path.expanduser(os.path.expandvars

350

(config["secfile"])),

351

"rb") as secfile:

352

self.secret = secfile.read()

353

else:

354

raise TypeError("No secret or secfile for client %s"

355

% self.name)

356

self.host = config.get("host", "")

357

self.created = datetime.datetime.utcnow()

358

self.enabled = False

359

self.last_approval_request = None

360

self.last_enabled = None

361

self.last_checked_ok = None

362

self.timeout = string_to_delta(config["timeout"])

363

self.extended_timeout = string_to_delta(config["extended_timeout"])

364

self.interval = string_to_delta(config["interval"])

365

self.disable_hook = disable_hook

554

self.created = settings.get("created",

555

datetime.datetime.utcnow())

556

557

# attributes specific for this server instance

366

558

self.checker = None

367

559

self.checker_initiator_tag = None

368

560

self.disable_initiator_tag = None

369

self.expires = None

370

561

self.checker_callback_tag = None

371

self.checker_command = config["checker"]

372

562

self.current_checker_command = None

373

self.last_connect = None

374

self._approved = None

375

self.approved_by_default = config.get("approved_by_default",

376

True)

563

self.approved = None

377

564

self.approvals_pending = 0

378

self.approval_delay = string_to_delta(

379

config["approval_delay"])

380

self.approval_duration = string_to_delta(

381

config["approval_duration"])

382

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

565

self.changedstate = (multiprocessing_manager

566

.Condition(multiprocessing_manager

567

.Lock()))

568

self.client_structure = [attr for attr in

569

self.__dict__.iterkeys()

570

if not attr.startswith("_")]

571

self.client_structure.append("client_structure")

572

573

for name, t in inspect.getmembers(type(self),

574

lambda obj:

575

isinstance(obj,

576

property)):

577

if not name.startswith("_"):

578

self.client_structure.append(name)

383

579

580

# Send notice to process children that client state has changed

384

581

def send_changedstate(self):

385

self.changedstate.acquire()

386

self.changedstate.notify_all()

387

self.changedstate.release()

388

582

with self.changedstate:

583

self.changedstate.notify_all()

584

389

585

def enable(self):

390

586

"""Start this client's checker and timeout hooks"""

391

587

if getattr(self, "enabled", False):

392

588

# Already enabled

393

589

return

590

self.expires = datetime.datetime.utcnow() + self.timeout

591

self.enabled = True

592

self.last_enabled = datetime.datetime.utcnow()

593

self.init_checker()

394

594

self.send_changedstate()

595

596

def disable(self, quiet=True):

597

"""Disable this client."""

598

if not getattr(self, "enabled", False):

599

return False

600

if not quiet:

601

logger.info("Disabling client %s", self.name)

602

if getattr(self, "disable_initiator_tag", None) is not None:

603

gobject.source_remove(self.disable_initiator_tag)

604

self.disable_initiator_tag = None

605

self.expires = None

606

if getattr(self, "checker_initiator_tag", None) is not None:

607

gobject.source_remove(self.checker_initiator_tag)

608

self.checker_initiator_tag = None

609

self.stop_checker()

610

self.enabled = False

611

if not quiet:

612

self.send_changedstate()

613

# Do not run this again if called by a gobject.timeout_add

614

return False

615

616

def __del__(self):

617

self.disable()

618

619

def init_checker(self):

395

620

# Schedule a new checker to be started an 'interval' from now,

396

621

# and every interval from then on.

622

if self.checker_initiator_tag is not None:

623

gobject.source_remove(self.checker_initiator_tag)

397

624

self.checker_initiator_tag = (gobject.timeout_add

398

625

(self.interval_milliseconds(),

399

626

self.start_checker))

400

627

# Schedule a disable() when 'timeout' has passed

401

self.expires = datetime.datetime.utcnow() + self.timeout

628

if self.disable_initiator_tag is not None:

629

gobject.source_remove(self.disable_initiator_tag)

402

630

self.disable_initiator_tag = (gobject.timeout_add

403

631

(self.timeout_milliseconds(),

404

632

self.disable))

405

self.enabled = True

406

self.last_enabled = datetime.datetime.utcnow()

407

633

# Also start a new checker *right now*.

408

634

self.start_checker()

409

635

410

def disable(self, quiet=True):

411

"""Disable this client."""

412

if not getattr(self, "enabled", False):

413

return False

414

if not quiet:

415

self.send_changedstate()

416

if not quiet:

417

logger.info("Disabling client %s", self.name)

418

if getattr(self, "disable_initiator_tag", False):

419

gobject.source_remove(self.disable_initiator_tag)

420

self.disable_initiator_tag = None

421

self.expires = None

422

if getattr(self, "checker_initiator_tag", False):

423

gobject.source_remove(self.checker_initiator_tag)

424

self.checker_initiator_tag = None

425

self.stop_checker()

426

if self.disable_hook:

427

self.disable_hook(self)

428

self.enabled = False

429

# Do not run this again if called by a gobject.timeout_add

430

return False

431

432

def __del__(self):

433

self.disable_hook = None

434

self.disable()

435

436

636

def checker_callback(self, pid, condition, command):

437

637

"""The checker has completed, so take appropriate actions."""

438

638

self.checker_callback_tag = None

439

639

self.checker = None

440

640

if os.WIFEXITED(condition):

441

exitstatus = os.WEXITSTATUS(condition)

442

if exitstatus == 0:

641

self.last_checker_status = os.WEXITSTATUS(condition)

642

if self.last_checker_status == 0:

443

643

logger.info("Checker for %(name)s succeeded",

444

644

vars(self))

445

645

self.checked_ok()

447

647

logger.info("Checker for %(name)s failed",

448

648

vars(self))

449

649

else:

650

self.last_checker_status = -1

450

651

logger.warning("Checker for %(name)s crashed?",

451

652

vars(self))

452

653

453

def checked_ok(self, timeout=None):

454

"""Bump up the timeout for this client.

455

456

This should only be called when the client has been seen,

457

alive and well.

458

"""

654

def checked_ok(self):

655

"""Assert that the client has been seen, alive and well."""

656

self.last_checked_ok = datetime.datetime.utcnow()

657

self.last_checker_status = 0

658

self.bump_timeout()

659

660

def bump_timeout(self, timeout=None):

661

"""Bump up the timeout for this client."""

459

662

if timeout is None:

460

663

timeout = self.timeout

461

self.last_checked_ok = datetime.datetime.utcnow()

462

gobject.source_remove(self.disable_initiator_tag)

463

self.expires = datetime.datetime.utcnow() + timeout

464

self.disable_initiator_tag = (gobject.timeout_add

465

(_timedelta_to_milliseconds(timeout),

466

self.disable))

664

if self.disable_initiator_tag is not None:

665

gobject.source_remove(self.disable_initiator_tag)

666

self.disable_initiator_tag = None

667

if getattr(self, "enabled", False):

668

self.disable_initiator_tag = (gobject.timeout_add

669

(timedelta_to_milliseconds

670

(timeout), self.disable))

671

self.expires = datetime.datetime.utcnow() + timeout

467

672

468

673

def need_approval(self):

469

674

self.last_approval_request = datetime.datetime.utcnow()

474

679

If a checker already exists, leave it running and do

475

680

nothing."""

476

681

# The reason for not killing a running checker is that if we

477

# did that, then if a checker (for some reason) started

478

# running slowly and taking more than 'interval' time, the

479

# client would inevitably timeout, since no checker would get

480

# a chance to run to completion. If we instead leave running

682

# did that, and if a checker (for some reason) started running

683

# slowly and taking more than 'interval' time, then the client

684

# would inevitably timeout, since no checker would get a

685

# chance to run to completion. If we instead leave running

481

686

# checkers alone, the checker would have to take more time

482

687

# than 'timeout' for the client to be disabled, which is as it

483

688

# should be.

497

702

self.current_checker_command)

498

703

# Start a new checker if needed

499

704

if self.checker is None:

705

# Escape attributes for the shell

706

escaped_attrs = dict(

707

(attr, re.escape(unicode(getattr(self, attr))))

708

for attr in

709

self.runtime_expansions)

500

710

try:

501

# In case checker_command has exactly one % operator

502

command = self.checker_command % self.host

503

except TypeError:

504

# Escape attributes for the shell

505

escaped_attrs = dict(

506

(attr,

507

re.escape(unicode(str(getattr(self, attr, "")),

508

errors=

509

'replace')))

510

for attr in

511

self.runtime_expansions)

512

513

try:

514

command = self.checker_command % escaped_attrs

515

except TypeError as error:

516

logger.error('Could not format string "%s":'

517

' %s', self.checker_command, error)

518

return True # Try again later

711

command = self.checker_command % escaped_attrs

712

except TypeError as error:

713

logger.error('Could not format string "%s"',

714

self.checker_command, exc_info=error)

715

return True # Try again later

519

716

self.current_checker_command = command

520

717

try:

521

718

logger.info("Starting checker %r for %s",

524

721

# in normal mode, that is already done by daemon(),

525

722

# and in debug mode we don't want to. (Stdin is

526

723

# always replaced by /dev/null.)

724

# The exception is when not debugging but nevertheless

725

# running in the foreground; use the previously

726

# created wnull.

727

popen_args = {}

728

if (not self.server_settings["debug"]

729

and self.server_settings["foreground"]):

730

popen_args.update({"stdout": wnull,

731

"stderr": wnull })

527

732

self.checker = subprocess.Popen(command,

528

733

close_fds=True,

529

shell=True, cwd="/")

530

self.checker_callback_tag = (gobject.child_watch_add

531

(self.checker.pid,

532

self.checker_callback,

533

data=command))

534

# The checker may have completed before the gobject

535

# watch was added. Check for this.

734

shell=True, cwd="/",

735

**popen_args)

736

except OSError as error:

737

logger.error("Failed to start subprocess",

738

exc_info=error)

739

return True

740

self.checker_callback_tag = (gobject.child_watch_add

741

(self.checker.pid,

742

self.checker_callback,

743

data=command))

744

# The checker may have completed before the gobject

745

# watch was added. Check for this.

746

try:

536

747

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

537

if pid:

538

gobject.source_remove(self.checker_callback_tag)

539

self.checker_callback(pid, status, command)

540

748

except OSError as error:

541

logger.error("Failed to start subprocess: %s",

542

error)

749

if error.errno == errno.ECHILD:

750

# This should never happen

751

logger.error("Child process vanished",

752

exc_info=error)

753

return True

754

raise

755

if pid:

756

gobject.source_remove(self.checker_callback_tag)

757

self.checker_callback(pid, status, command)

543

758

# Re-run this periodically if run by gobject.timeout_add

544

759

return True

545

760

552

767

return

553

768

logger.debug("Stopping checker for %(name)s", vars(self))

554

769

try:

555

os.kill(self.checker.pid, signal.SIGTERM)

770

self.checker.terminate()

556

771

#time.sleep(0.5)

557

772

#if self.checker.poll() is None:

558

# os.kill(self.checker.pid, signal.SIGKILL)

773

# self.checker.kill()

559

774

except OSError as error:

560

775

if error.errno != errno.ESRCH: # No such process

561

776

raise

562

777

self.checker = None

563

778

779

564

780

def dbus_service_property(dbus_interface, signature="v",

565

781

access="readwrite", byte_arrays=False):

566

782

"""Decorators for marking methods of a DBusObjectWithProperties to

577

793

# "Set" method, so we fail early here:

578

794

if byte_arrays and signature != "ay":

579

795

raise ValueError("Byte arrays not supported for non-'ay'"

580

" signature %r" % signature)

796

" signature {0!r}".format(signature))

581

797

def decorator(func):

582

798

func._dbus_is_property = True

583

799

func._dbus_interface = dbus_interface

591

807

return decorator

592

808

593

809

810

def dbus_interface_annotations(dbus_interface):

811

"""Decorator for marking functions returning interface annotations

812

813

Usage:

814

815

@dbus_interface_annotations("org.example.Interface")

816

def _foo(self): # Function name does not matter

817

return {"org.freedesktop.DBus.Deprecated": "true",

818

"org.freedesktop.DBus.Property.EmitsChangedSignal":

819

"false"}

820

"""

821

def decorator(func):

822

func._dbus_is_interface = True

823

func._dbus_interface = dbus_interface

824

func._dbus_name = dbus_interface

825

return func

826

return decorator

827

828

829

def dbus_annotations(annotations):

830

"""Decorator to annotate D-Bus methods, signals or properties

831

Usage:

832

833

@dbus_service_property("org.example.Interface", signature="b",

834

access="r")

835

@dbus_annotations({{"org.freedesktop.DBus.Deprecated": "true",

836

"org.freedesktop.DBus.Property."

837

"EmitsChangedSignal": "false"})

838

def Property_dbus_property(self):

839

return dbus.Boolean(False)

840

"""

841

def decorator(func):

842

func._dbus_annotations = annotations

843

return func

844

return decorator

845

846

594

847

class DBusPropertyException(dbus.exceptions.DBusException):

595

848

"""A base class for D-Bus property-related exceptions

596

849

"""

612

865

613

866

class DBusObjectWithProperties(dbus.service.Object):

614

867

"""A D-Bus object with properties.

615

868

616

869

Classes inheriting from this can use the dbus_service_property

617

870

decorator to expose methods as D-Bus properties. It exposes the

618

871

standard Get(), Set(), and GetAll() methods on the D-Bus.

619

872

"""

620

873

621

874

@staticmethod

622

def _is_dbus_property(obj):

623

return getattr(obj, "_dbus_is_property", False)

875

def _is_dbus_thing(thing):

876

"""Returns a function testing if an attribute is a D-Bus thing

877

878

If called like _is_dbus_thing("method") it returns a function

879

suitable for use as predicate to inspect.getmembers().

880

"""

881

return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),

882

False)

624

883

625

def _get_all_dbus_properties(self):

884

def _get_all_dbus_things(self, thing):

626

885

"""Returns a generator of (name, attribute) pairs

627

886

"""

628

return ((prop._dbus_name, prop)

629

for name, prop in

630

inspect.getmembers(self, self._is_dbus_property))

887

return ((getattr(athing.__get__(self), "_dbus_name",

888

name),

889

athing.__get__(self))

890

for cls in self.__class__.__mro__

891

for name, athing in

892

inspect.getmembers(cls,

893

self._is_dbus_thing(thing)))

631

894

632

895

def _get_dbus_property(self, interface_name, property_name):

633

896

"""Returns a bound method if one exists which is a D-Bus

634

897

property with the specified name and interface.

635

898

"""

636

for name in (property_name,

637

property_name + "_dbus_property"):

638

prop = getattr(self, name, None)

639

if (prop is None

640

or not self._is_dbus_property(prop)

641

or prop._dbus_name != property_name

642

or (interface_name and prop._dbus_interface

643

and interface_name != prop._dbus_interface)):

644

continue

645

return prop

899

for cls in self.__class__.__mro__:

900

for name, value in (inspect.getmembers

901

(cls,

902

self._is_dbus_thing("property"))):

903

if (value._dbus_name == property_name

904

and value._dbus_interface == interface_name):

905

return value.__get__(self)

906

646

907

# No such property

647

908

raise DBusPropertyNotFound(self.dbus_object_path + ":"

648

909

+ interface_name + "."

673

934

# signatures other than "ay".

674

935

if prop._dbus_signature != "ay":

675

936

raise ValueError

676

value = dbus.ByteArray(''.join(unichr(byte)

677

for byte in value))

937

value = dbus.ByteArray(b''.join(chr(byte)

938

for byte in value))

678

939

prop(value)

679

940

680

941

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",

682

943

def GetAll(self, interface_name):

683

944

"""Standard D-Bus property GetAll() method, see D-Bus

684

945

standard.

685

946

686

947

Note: Will not include properties with access="write".

687

948

"""

688

all = {}

689

for name, prop in self._get_all_dbus_properties():

949

properties = {}

950

for name, prop in self._get_all_dbus_things("property"):

690

951

if (interface_name

691

952

and interface_name != prop._dbus_interface):

692

953

# Interface non-empty but did not match

696

957

continue

697

958

value = prop()

698

959

if not hasattr(value, "variant_level"):

699

all[name] = value

960

properties[name] = value

700

961

continue

701

all[name] = type(value)(value, variant_level=

702

value.variant_level+1)

703

return dbus.Dictionary(all, signature="sv")

962

properties[name] = type(value)(value, variant_level=

963

value.variant_level+1)

964

return dbus.Dictionary(properties, signature="sv")

704

965

705

966

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

706

967

out_signature="s",

707

968

path_keyword='object_path',

708

969

connection_keyword='connection')

709

970

def Introspect(self, object_path, connection):

710

"""Standard D-Bus method, overloaded to insert property tags.

971

"""Overloading of standard D-Bus method.

972

973

Inserts property tags and interface annotation tags.

711

974

"""

712

975

xmlstring = dbus.service.Object.Introspect(self, object_path,

713

976

connection)

720

983

e.setAttribute("access", prop._dbus_access)

721

984

return e

722

985

for if_tag in document.getElementsByTagName("interface"):

986

# Add property tags

723

987

for tag in (make_tag(document, name, prop)

724

988

for name, prop

725

in self._get_all_dbus_properties()

989

in self._get_all_dbus_things("property")

726

990

if prop._dbus_interface

727

991

== if_tag.getAttribute("name")):

728

992

if_tag.appendChild(tag)

993

# Add annotation tags

994

for typ in ("method", "signal", "property"):

995

for tag in if_tag.getElementsByTagName(typ):

996

annots = dict()

997

for name, prop in (self.

998

_get_all_dbus_things(typ)):

999

if (name == tag.getAttribute("name")

1000

and prop._dbus_interface

1001

== if_tag.getAttribute("name")):

1002

annots.update(getattr

1003

(prop,

1004

"_dbus_annotations",

1005

{}))

1006

for name, value in annots.iteritems():

1007

ann_tag = document.createElement(

1008

"annotation")

1009

ann_tag.setAttribute("name", name)

1010

ann_tag.setAttribute("value", value)

1011

tag.appendChild(ann_tag)

1012

# Add interface annotation tags

1013

for annotation, value in dict(

1014

itertools.chain.from_iterable(

1015

annotations().iteritems()

1016

for name, annotations in

1017

self._get_all_dbus_things("interface")

1018

if name == if_tag.getAttribute("name")

1019

)).iteritems():

1020

ann_tag = document.createElement("annotation")

1021

ann_tag.setAttribute("name", annotation)

1022

ann_tag.setAttribute("value", value)

1023

if_tag.appendChild(ann_tag)

729

1024

# Add the names to the return values for the

730

1025

# "org.freedesktop.DBus.Properties" methods

731

1026

if (if_tag.getAttribute("name")

746

1041

except (AttributeError, xml.dom.DOMException,

747

1042

xml.parsers.expat.ExpatError) as error:

748

1043

logger.error("Failed to override Introspection method",

749

error)

1044

exc_info=error)

750

1045

return xmlstring

751

1046

752

1047

753

def datetime_to_dbus (dt, variant_level=0):

1048

def datetime_to_dbus(dt, variant_level=0):

754

1049

"""Convert a UTC datetime.datetime() to a D-Bus type."""

755

1050

if dt is None:

756

1051

return dbus.String("", variant_level = variant_level)

757

1052

return dbus.String(dt.isoformat(),

758

1053

variant_level=variant_level)

759

1054

1055

1056

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1057

"""A class decorator; applied to a subclass of

1058

dbus.service.Object, it will add alternate D-Bus attributes with

1059

interface names according to the "alt_interface_names" mapping.

1060

Usage:

1061

1062

@alternate_dbus_interfaces({"org.example.Interface":

1063

"net.example.AlternateInterface"})

1064

class SampleDBusObject(dbus.service.Object):

1065

@dbus.service.method("org.example.Interface")

1066

def SampleDBusMethod():

1067

pass

1068

1069

The above "SampleDBusMethod" on "SampleDBusObject" will be

1070

reachable via two interfaces: "org.example.Interface" and

1071

"net.example.AlternateInterface", the latter of which will have

1072

its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to

1073

"true", unless "deprecate" is passed with a False value.

1074

1075

This works for methods and signals, and also for D-Bus properties

1076

(from DBusObjectWithProperties) and interfaces (from the

1077

dbus_interface_annotations decorator).

1078

"""

1079

def wrapper(cls):

1080

for orig_interface_name, alt_interface_name in (

1081

alt_interface_names.iteritems()):

1082

attr = {}

1083

interface_names = set()

1084

# Go though all attributes of the class

1085

for attrname, attribute in inspect.getmembers(cls):

1086

# Ignore non-D-Bus attributes, and D-Bus attributes

1087

# with the wrong interface name

1088

if (not hasattr(attribute, "_dbus_interface")

1089

or not attribute._dbus_interface

1090

.startswith(orig_interface_name)):

1091

continue

1092

# Create an alternate D-Bus interface name based on

1093

# the current name

1094

alt_interface = (attribute._dbus_interface

1095

.replace(orig_interface_name,

1096

alt_interface_name))

1097

interface_names.add(alt_interface)

1098

# Is this a D-Bus signal?

1099

if getattr(attribute, "_dbus_is_signal", False):

1100

# Extract the original non-method undecorated

1101

# function by black magic

1102

nonmethod_func = (dict(

1103

zip(attribute.func_code.co_freevars,

1104

attribute.__closure__))["func"]

1105

.cell_contents)

1106

# Create a new, but exactly alike, function

1107

# object, and decorate it to be a new D-Bus signal

1108

# with the alternate D-Bus interface name

1109

new_function = (dbus.service.signal

1110

(alt_interface,

1111

attribute._dbus_signature)

1112

(types.FunctionType(

1113

nonmethod_func.func_code,

1114

nonmethod_func.func_globals,

1115

nonmethod_func.func_name,

1116

nonmethod_func.func_defaults,

1117

nonmethod_func.func_closure)))

1118

# Copy annotations, if any

1119

try:

1120

new_function._dbus_annotations = (

1121

dict(attribute._dbus_annotations))

1122

except AttributeError:

1123

pass

1124

# Define a creator of a function to call both the

1125

# original and alternate functions, so both the

1126

# original and alternate signals gets sent when

1127

# the function is called

1128

def fixscope(func1, func2):

1129

"""This function is a scope container to pass

1130

func1 and func2 to the "call_both" function

1131

outside of its arguments"""

1132

def call_both(*args, **kwargs):

1133

"""This function will emit two D-Bus

1134

signals by calling func1 and func2"""

1135

func1(*args, **kwargs)

1136

func2(*args, **kwargs)

1137

return call_both

1138

# Create the "call_both" function and add it to

1139

# the class

1140

attr[attrname] = fixscope(attribute, new_function)

1141

# Is this a D-Bus method?

1142

elif getattr(attribute, "_dbus_is_method", False):

1143

# Create a new, but exactly alike, function

1144

# object. Decorate it to be a new D-Bus method

1145

# with the alternate D-Bus interface name. Add it

1146

# to the class.

1147

attr[attrname] = (dbus.service.method

1148

(alt_interface,

1149

attribute._dbus_in_signature,

1150

attribute._dbus_out_signature)

1151

(types.FunctionType

1152

(attribute.func_code,

1153

attribute.func_globals,

1154

attribute.func_name,

1155

attribute.func_defaults,

1156

attribute.func_closure)))

1157

# Copy annotations, if any

1158

try:

1159

attr[attrname]._dbus_annotations = (

1160

dict(attribute._dbus_annotations))

1161

except AttributeError:

1162

pass

1163

# Is this a D-Bus property?

1164

elif getattr(attribute, "_dbus_is_property", False):

1165

# Create a new, but exactly alike, function

1166

# object, and decorate it to be a new D-Bus

1167

# property with the alternate D-Bus interface

1168

# name. Add it to the class.

1169

attr[attrname] = (dbus_service_property

1170

(alt_interface,

1171

attribute._dbus_signature,

1172

attribute._dbus_access,

1173

attribute

1174

._dbus_get_args_options

1175

["byte_arrays"])

1176

(types.FunctionType

1177

(attribute.func_code,

1178

attribute.func_globals,

1179

attribute.func_name,

1180

attribute.func_defaults,

1181

attribute.func_closure)))

1182

# Copy annotations, if any

1183

try:

1184

attr[attrname]._dbus_annotations = (

1185

dict(attribute._dbus_annotations))

1186

except AttributeError:

1187

pass

1188

# Is this a D-Bus interface?

1189

elif getattr(attribute, "_dbus_is_interface", False):

1190

# Create a new, but exactly alike, function

1191

# object. Decorate it to be a new D-Bus interface

1192

# with the alternate D-Bus interface name. Add it

1193

# to the class.

1194

attr[attrname] = (dbus_interface_annotations

1195

(alt_interface)

1196

(types.FunctionType

1197

(attribute.func_code,

1198

attribute.func_globals,

1199

attribute.func_name,

1200

attribute.func_defaults,

1201

attribute.func_closure)))

1202

if deprecate:

1203

# Deprecate all alternate interfaces

1204

iname="_AlternateDBusNames_interface_annotation{0}"

1205

for interface_name in interface_names:

1206

@dbus_interface_annotations(interface_name)

1207

def func(self):

1208

return { "org.freedesktop.DBus.Deprecated":

1209

"true" }

1210

# Find an unused name

1211

for aname in (iname.format(i)

1212

for i in itertools.count()):

1213

if aname not in attr:

1214

attr[aname] = func

1215

break

1216

if interface_names:

1217

# Replace the class with a new subclass of it with

1218

# methods, signals, etc. as created above.

1219

cls = type(b"{0}Alternate".format(cls.__name__),

1220

(cls,), attr)

1221

return cls

1222

return wrapper

1223

1224

1225

@alternate_dbus_interfaces({"se.recompile.Mandos":

1226

"se.bsnet.fukt.Mandos"})

760

1227

class ClientDBus(Client, DBusObjectWithProperties):

761

1228

"""A Client class using D-Bus

762

1229

771

1238

# dbus.service.Object doesn't use super(), so we can't either.

772

1239

773

1240

def __init__(self, bus = None, *args, **kwargs):

774

self._approvals_pending = 0

775

1241

self.bus = bus

776

1242

Client.__init__(self, *args, **kwargs)

777

1243

# Only now, when this client is initialized, can it show up on

783

1249

("/clients/" + client_object_name))

784

1250

DBusObjectWithProperties.__init__(self, self.bus,

785

1251

self.dbus_object_path)

786

1252

787

1253

def notifychangeproperty(transform_func,

788

1254

dbus_name, type_func=lambda x: x,

789

1255

variant_level=1):

790

""" Modify a variable so that its a property that announce its

791

changes to DBus.

792

transform_fun: Function that takes a value and transform it to

793

DBus type.

794

dbus_name: DBus name of the variable

1256

""" Modify a variable so that it's a property which announces

1257

its changes to DBus.

1258

1259

transform_fun: Function that takes a value and a variant_level

1260

and transforms it to a D-Bus type.

1261

dbus_name: D-Bus name of the variable

795

1262

type_func: Function that transform the value before sending it

796

to DBus

797

variant_level: DBus variant level. default: 1

1263

to the D-Bus. Default: no transform

1264

variant_level: D-Bus variant level. Default: 1

798

1265

"""

799

real_value = [None,]

1266

attrname = "_{0}".format(dbus_name)

800

1267

def setter(self, value):

801

old_value = real_value[0]

802

real_value[0] = value

803

1268

if hasattr(self, "dbus_object_path"):

804

if type_func(old_value) != type_func(real_value[0]):

805

dbus_value = transform_func(type_func(real_value[0]),

806

variant_level)

1269

if (not hasattr(self, attrname) or

1270

type_func(getattr(self, attrname, None))

1271

!= type_func(value)):

1272

dbus_value = transform_func(type_func(value),

1273

variant_level

1274

=variant_level)

807

1275

self.PropertyChanged(dbus.String(dbus_name),

808

1276

dbus_value)

809

810

return property(lambda self: real_value[0], setter)

811

812

1277

setattr(self, attrname, value)

1278

1279

return property(lambda self: getattr(self, attrname), setter)

1280

813

1281

expires = notifychangeproperty(datetime_to_dbus, "Expires")

814

1282

approvals_pending = notifychangeproperty(dbus.Boolean,

815

1283

"ApprovalPending",

818

1286

last_enabled = notifychangeproperty(datetime_to_dbus,

819

1287

"LastEnabled")

820

1288

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

821

type_func = lambda checker: checker is not None)

1289

type_func = lambda checker:

1290

checker is not None)

822

1291

last_checked_ok = notifychangeproperty(datetime_to_dbus,

823

1292

"LastCheckedOK")

824

last_approval_request = notifychangeproperty(datetime_to_dbus,

825

"LastApprovalRequest")

1293

last_checker_status = notifychangeproperty(dbus.Int16,

1294

"LastCheckerStatus")

1295

last_approval_request = notifychangeproperty(

1296

datetime_to_dbus, "LastApprovalRequest")

826

1297

approved_by_default = notifychangeproperty(dbus.Boolean,

827

1298

"ApprovedByDefault")

828

approval_delay = notifychangeproperty(dbus.UInt16, "ApprovalDelay",

829

type_func = _timedelta_to_milliseconds)

830

approval_duration = notifychangeproperty(dbus.UInt16, "ApprovalDuration",

831

type_func = _timedelta_to_milliseconds)

1299

approval_delay = notifychangeproperty(dbus.UInt64,

1300

"ApprovalDelay",

1301

type_func =

1302

timedelta_to_milliseconds)

1303

approval_duration = notifychangeproperty(

1304

dbus.UInt64, "ApprovalDuration",

1305

type_func = timedelta_to_milliseconds)

832

1306

host = notifychangeproperty(dbus.String, "Host")

833

timeout = notifychangeproperty(dbus.UInt16, "Timeout",

834

type_func = _timedelta_to_milliseconds)

835

extended_timeout = notifychangeproperty(dbus.UInt16, "ExtendedTimeout",

836

type_func = _timedelta_to_milliseconds)

837

interval = notifychangeproperty(dbus.UInt16, "Interval",

838

type_func = _timedelta_to_milliseconds)

1307

timeout = notifychangeproperty(dbus.UInt64, "Timeout",

1308

type_func =

1309

timedelta_to_milliseconds)

1310

extended_timeout = notifychangeproperty(

1311

dbus.UInt64, "ExtendedTimeout",

1312

type_func = timedelta_to_milliseconds)

1313

interval = notifychangeproperty(dbus.UInt64,

1314

"Interval",

1315

type_func =

1316

timedelta_to_milliseconds)

839

1317

checker_command = notifychangeproperty(dbus.String, "Checker")

840

1318

841

1319

del notifychangeproperty

867

1345

868

1346

return Client.checker_callback(self, pid, condition, command,

869

1347

*args, **kwargs)

870

1348

871

1349

def start_checker(self, *args, **kwargs):

872

1350

old_checker = self.checker

873

1351

if self.checker is not None:

883

1361

return r

884

1362

885

1363

def _reset_approved(self):

886

self._approved = None

1364

self.approved = None

887

1365

return False

888

1366

889

1367

def approve(self, value=True):

890

self.send_changedstate()

891

self._approved = value

892

gobject.timeout_add(_timedelta_to_milliseconds

1368

self.approved = value

1369

gobject.timeout_add(timedelta_to_milliseconds

893

1370

(self.approval_duration),

894

1371

self._reset_approved)

895

1372

self.send_changedstate()

896

1373

897

1374

## D-Bus methods, signals & properties

898

_interface = "se.bsnet.fukt.Mandos.Client"

1375

_interface = "se.recompile.Mandos.Client"

1376

1377

## Interfaces

1378

1379

@dbus_interface_annotations(_interface)

1380

def _foo(self):

1381

return { "org.freedesktop.DBus.Property.EmitsChangedSignal":

1382

"false"}

899

1383

900

1384

## Signals

901

1385

1001

1485

access="readwrite")

1002

1486

def ApprovalDuration_dbus_property(self, value=None):

1003

1487

if value is None: # get

1004

return dbus.UInt64(_timedelta_to_milliseconds(

1488

return dbus.UInt64(timedelta_to_milliseconds(

1005

1489

self.approval_duration))

1006

1490

self.approval_duration = datetime.timedelta(0, 0, 0, value)

1007

1491

1021

1505

def Host_dbus_property(self, value=None):

1022

1506

if value is None: # get

1023

1507

return dbus.String(self.host)

1024

self.host = value

1508

self.host = unicode(value)

1025

1509

1026

1510

# Created - property

1027

1511

@dbus_service_property(_interface, signature="s", access="read")

1028

1512

def Created_dbus_property(self):

1029

return dbus.String(datetime_to_dbus(self.created))

1513

return datetime_to_dbus(self.created)

1030

1514

1031

1515

# LastEnabled - property

1032

1516

@dbus_service_property(_interface, signature="s", access="read")

1053

1537

return

1054

1538

return datetime_to_dbus(self.last_checked_ok)

1055

1539

1540

# LastCheckerStatus - property

1541

@dbus_service_property(_interface, signature="n",

1542

access="read")

1543

def LastCheckerStatus_dbus_property(self):

1544

return dbus.Int16(self.last_checker_status)

1545

1056

1546

# Expires - property

1057

1547

@dbus_service_property(_interface, signature="s", access="read")

1058

1548

def Expires_dbus_property(self):

1069

1559

def Timeout_dbus_property(self, value=None):

1070

1560

if value is None: # get

1071

1561

return dbus.UInt64(self.timeout_milliseconds())

1562

old_timeout = self.timeout

1072

1563

self.timeout = datetime.timedelta(0, 0, 0, value)

1073

if getattr(self, "disable_initiator_tag", None) is None:

1074

return

1075

# Reschedule timeout

1076

gobject.source_remove(self.disable_initiator_tag)

1077

self.disable_initiator_tag = None

1078

self.expires = None

1079

time_to_die = (self.

1080

_timedelta_to_milliseconds((self

1081

.last_checked_ok

1082

+ self.timeout)

1083

- datetime.datetime

1084

.utcnow()))

1085

if time_to_die <= 0:

1086

# The timeout has passed

1087

self.disable()

1088

else:

1089

self.expires = (datetime.datetime.utcnow()

1090

+ datetime.timedelta(milliseconds = time_to_die))

1091

self.disable_initiator_tag = (gobject.timeout_add

1092

(time_to_die, self.disable))

1093

1564

# Reschedule disabling

1565

if self.enabled:

1566

now = datetime.datetime.utcnow()

1567

self.expires += self.timeout - old_timeout

1568

if self.expires <= now:

1569

# The timeout has passed

1570

self.disable()

1571

else:

1572

if (getattr(self, "disable_initiator_tag", None)

1573

is None):

1574

return

1575

gobject.source_remove(self.disable_initiator_tag)

1576

self.disable_initiator_tag = (

1577

gobject.timeout_add(

1578

timedelta_to_milliseconds(self.expires - now),

1579

self.disable))

1580

1094

1581

# ExtendedTimeout - property

1095

1582

@dbus_service_property(_interface, signature="t",

1096

1583

access="readwrite")

1098

1585

if value is None: # get

1099

1586

return dbus.UInt64(self.extended_timeout_milliseconds())

1100

1587

self.extended_timeout = datetime.timedelta(0, 0, 0, value)

1101

1588

1102

1589

# Interval - property

1103

1590

@dbus_service_property(_interface, signature="t",

1104

1591

access="readwrite")

1108

1595

self.interval = datetime.timedelta(0, 0, 0, value)

1109

1596

if getattr(self, "checker_initiator_tag", None) is None:

1110

1597

return

1111

# Reschedule checker run

1112

gobject.source_remove(self.checker_initiator_tag)

1113

self.checker_initiator_tag = (gobject.timeout_add

1114

(value, self.start_checker))

1115

self.start_checker() # Start one now, too

1116

1598

if self.enabled:

1599

# Reschedule checker run

1600

gobject.source_remove(self.checker_initiator_tag)

1601

self.checker_initiator_tag = (gobject.timeout_add

1602

(value, self.start_checker))

1603

self.start_checker() # Start one now, too

1604

1117

1605

# Checker - property

1118

1606

@dbus_service_property(_interface, signature="s",

1119

1607

access="readwrite")

1120

1608

def Checker_dbus_property(self, value=None):

1121

1609

if value is None: # get

1122

1610

return dbus.String(self.checker_command)

1123

self.checker_command = value

1611

self.checker_command = unicode(value)

1124

1612

1125

1613

# CheckerRunning - property

1126

1614

@dbus_service_property(_interface, signature="b",

1153

1641

self._pipe.send(('init', fpr, address))

1154

1642

if not self._pipe.recv():

1155

1643

raise KeyError()

1156

1644

1157

1645

def __getattribute__(self, name):

1158

if(name == '_pipe'):

1646

if name == '_pipe':

1159

1647

return super(ProxyClient, self).__getattribute__(name)

1160

1648

self._pipe.send(('getattr', name))

1161

1649

data = self._pipe.recv()

1166

1654

self._pipe.send(('funcall', name, args, kwargs))

1167

1655

return self._pipe.recv()[1]

1168

1656

return func

1169

1657

1170

1658

def __setattr__(self, name, value):

1171

if(name == '_pipe'):

1659

if name == '_pipe':

1172

1660

return super(ProxyClient, self).__setattr__(name, value)

1173

1661

self._pipe.send(('setattr', name, value))

1174

1662

1185

1673

unicode(self.client_address))

1186

1674

logger.debug("Pipe FD: %d",

1187

1675

self.server.child_pipe.fileno())

1188

1676

1189

1677

session = (gnutls.connection

1190

1678

.ClientSession(self.request,

1191

1679

gnutls.connection

1192

1680

.X509Credentials()))

1193

1681

1194

1682

# Note: gnutls.connection.X509Credentials is really a

1195

1683

# generic GnuTLS certificate credentials object so long as

1196

1684

# no X.509 keys are added to it. Therefore, we can use it

1197

1685

# here despite using OpenPGP certificates.

1198

1686

1199

1687

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1200

1688

# "+AES-256-CBC", "+SHA1",

1201

1689

# "+COMP-NULL", "+CTYPE-OPENPGP",

1207

1695

(gnutls.library.functions

1208

1696

.gnutls_priority_set_direct(session._c_object,

1209

1697

priority, None))

1210

1698

1211

1699

# Start communication using the Mandos protocol

1212

1700

# Get protocol number

1213

1701

line = self.request.makefile().readline()

1218

1706

except (ValueError, IndexError, RuntimeError) as error:

1219

1707

logger.error("Unknown protocol version: %s", error)

1220

1708

return

1221

1709

1222

1710

# Start GnuTLS connection

1223

1711

try:

1224

1712

session.handshake()

1228

1716

# established. Just abandon the request.

1229

1717

return

1230

1718

logger.debug("Handshake succeeded")

1231

1719

1232

1720

approval_required = False

1233

1721

try:

1234

1722

try:

1239

1727

logger.warning("Bad certificate: %s", error)

1240

1728

return

1241

1729

logger.debug("Fingerprint: %s", fpr)

1242

1730

1243

1731

try:

1244

1732

client = ProxyClient(child_pipe, fpr,

1245

1733

self.client_address)

1257

1745

client.name)

1258

1746

if self.server.use_dbus:

1259

1747

# Emit D-Bus signal

1260

client.Rejected("Disabled")

1748

client.Rejected("Disabled")

1261

1749

return

1262

1750

1263

if client._approved or not client.approval_delay:

1751

if client.approved or not client.approval_delay:

1264

1752

#We are approved or approval is disabled

1265

1753

break

1266

elif client._approved is None:

1754

elif client.approved is None:

1267

1755

logger.info("Client %s needs approval",

1268

1756

client.name)

1269

1757

if self.server.use_dbus:

1280

1768

return

1281

1769

1282

1770

#wait until timeout or approved

1283

#x = float(client._timedelta_to_milliseconds(delay))

1284

1771

time = datetime.datetime.now()

1285

1772

client.changedstate.acquire()

1286

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1773

client.changedstate.wait(

1774

float(timedelta_to_milliseconds(delay)

1775

/ 1000))

1287

1776

client.changedstate.release()

1288

1777

time2 = datetime.datetime.now()

1289

1778

if (time2 - time) >= delay:

1305

1794

try:

1306

1795

sent = session.send(client.secret[sent_size:])

1307

1796

except gnutls.errors.GNUTLSError as error:

1308

logger.warning("gnutls send failed")

1797

logger.warning("gnutls send failed",

1798

exc_info=error)

1309

1799

return

1310

1800

logger.debug("Sent: %d, remaining: %d",

1311

1801

sent, len(client.secret)

1312

1802

- (sent_size + sent))

1313

1803

sent_size += sent

1314

1804

1315

1805

logger.info("Sending secret to %s", client.name)

1316

# bump the timeout as if seen

1317

client.checked_ok(client.extended_timeout)

1806

# bump the timeout using extended_timeout

1807

client.bump_timeout(client.extended_timeout)

1318

1808

if self.server.use_dbus:

1319

1809

# Emit D-Bus signal

1320

1810

client.GotSecret()

1325

1815

try:

1326

1816

session.bye()

1327

1817

except gnutls.errors.GNUTLSError as error:

1328

logger.warning("GnuTLS bye failed")

1818

logger.warning("GnuTLS bye failed",

1819

exc_info=error)

1329

1820

1330

1821

@staticmethod

1331

1822

def peer_certificate(session):

1387

1878

# Convert the buffer to a Python bytestring

1388

1879

fpr = ctypes.string_at(buf, buf_len.value)

1389

1880

# Convert the bytestring to hexadecimal notation

1390

hex_fpr = ''.join("%02X" % ord(char) for char in fpr)

1881

hex_fpr = binascii.hexlify(fpr).upper()

1391

1882

return hex_fpr

1392

1883

1393

1884

1396

1887

def sub_process_main(self, request, address):

1397

1888

try:

1398

1889

self.finish_request(request, address)

1399

except:

1890

except Exception:

1400

1891

self.handle_error(request, address)

1401

1892

self.close_request(request)

1402

1893

1403

1894

def process_request(self, request, address):

1404

1895

"""Start a new process to process the request."""

1405

multiprocessing.Process(target = self.sub_process_main,

1406

args = (request, address)).start()

1896

proc = multiprocessing.Process(target = self.sub_process_main,

1897

args = (request, address))

1898

proc.start()

1899

return proc

1900

1407

1901

1408

1902

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1409

1903

""" adds a pipe to the MixIn """

1413

1907

This function creates a new pipe in self.pipe

1414

1908

"""

1415

1909

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1416

1417

super(MultiprocessingMixInWithPipe,

1418

self).process_request(request, client_address)

1910

1911

proc = MultiprocessingMixIn.process_request(self, request,

1912

client_address)

1419

1913

self.child_pipe.close()

1420

self.add_pipe(parent_pipe)

1421

1422

def add_pipe(self, parent_pipe):

1914

self.add_pipe(parent_pipe, proc)

1915

1916

def add_pipe(self, parent_pipe, proc):

1423

1917

"""Dummy function; override as necessary"""

1424

1918

raise NotImplementedError

1425

1919

1920

1426

1921

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1427

1922

socketserver.TCPServer, object):

1428

1923

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

1433

1928

use_ipv6: Boolean; to use IPv6 or not

1434

1929

"""

1435

1930

def __init__(self, server_address, RequestHandlerClass,

1436

interface=None, use_ipv6=True):

1931

interface=None, use_ipv6=True, socketfd=None):

1932

"""If socketfd is set, use that file descriptor instead of

1933

creating a new one with socket.socket().

1934

"""

1437

1935

self.interface = interface

1438

1936

if use_ipv6:

1439

1937

self.address_family = socket.AF_INET6

1938

if socketfd is not None:

1939

# Save the file descriptor

1940

self.socketfd = socketfd

1941

# Save the original socket.socket() function

1942

self.socket_socket = socket.socket

1943

# To implement --socket, we monkey patch socket.socket.

1944

#

1945

# (When socketserver.TCPServer is a new-style class, we

1946

# could make self.socket into a property instead of monkey

1947

# patching socket.socket.)

1948

#

1949

# Create a one-time-only replacement for socket.socket()

1950

@functools.wraps(socket.socket)

1951

def socket_wrapper(*args, **kwargs):

1952

# Restore original function so subsequent calls are

1953

# not affected.

1954

socket.socket = self.socket_socket

1955

del self.socket_socket

1956

# This time only, return a new socket object from the

1957

# saved file descriptor.

1958

return socket.fromfd(self.socketfd, *args, **kwargs)

1959

# Replace socket.socket() function with wrapper

1960

socket.socket = socket_wrapper

1961

# The socketserver.TCPServer.__init__ will call

1962

# socket.socket(), which might be our replacement,

1963

# socket_wrapper(), if socketfd was set.

1440

1964

socketserver.TCPServer.__init__(self, server_address,

1441

1965

RequestHandlerClass)

1966

1442

1967

def server_bind(self):

1443

1968

"""This overrides the normal server_bind() function

1444

1969

to bind to an interface if one was specified, and also NOT to

1452

1977

try:

1453

1978

self.socket.setsockopt(socket.SOL_SOCKET,

1454

1979

SO_BINDTODEVICE,

1455

str(self.interface

1456

+ '\0'))

1980

str(self.interface + '\0'))

1457

1981

except socket.error as error:

1458

if error[0] == errno.EPERM:

1459

logger.error("No permission to"

1460

" bind to interface %s",

1461

self.interface)

1462

elif error[0] == errno.ENOPROTOOPT:

1982

if error.errno == errno.EPERM:

1983

logger.error("No permission to bind to"

1984

" interface %s", self.interface)

1985

elif error.errno == errno.ENOPROTOOPT:

1463

1986

logger.error("SO_BINDTODEVICE not available;"

1464

1987

" cannot bind to interface %s",

1465

1988

self.interface)

1989

elif error.errno == errno.ENODEV:

1990

logger.error("Interface %s does not exist,"

1991

" cannot bind", self.interface)

1466

1992

else:

1467

1993

raise

1468

1994

# Only bind(2) the socket if we really need to.

1471

1997

if self.address_family == socket.AF_INET6:

1472

1998

any_address = "::" # in6addr_any

1473

1999

else:

1474

any_address = socket.INADDR_ANY

2000

any_address = "0.0.0.0" # INADDR_ANY

1475

2001

self.server_address = (any_address,

1476

2002

self.server_address[1])

1477

2003

elif not self.server_address[1]:

1498

2024

"""

1499

2025

def __init__(self, server_address, RequestHandlerClass,

1500

2026

interface=None, use_ipv6=True, clients=None,

1501

gnutls_priority=None, use_dbus=True):

2027

gnutls_priority=None, use_dbus=True, socketfd=None):

1502

2028

self.enabled = False

1503

2029

self.clients = clients

1504

2030

if self.clients is None:

1505

self.clients = set()

2031

self.clients = {}

1506

2032

self.use_dbus = use_dbus

1507

2033

self.gnutls_priority = gnutls_priority

1508

2034

IPv6_TCPServer.__init__(self, server_address,

1509

2035

RequestHandlerClass,

1510

2036

interface = interface,

1511

use_ipv6 = use_ipv6)

2037

use_ipv6 = use_ipv6,

2038

socketfd = socketfd)

1512

2039

def server_activate(self):

1513

2040

if self.enabled:

1514

2041

return socketserver.TCPServer.server_activate(self)

2042

1515

2043

def enable(self):

1516

2044

self.enabled = True

1517

def add_pipe(self, parent_pipe):

2045

2046

def add_pipe(self, parent_pipe, proc):

1518

2047

# Call "handle_ipc" for both data and EOF events

1519

2048

gobject.io_add_watch(parent_pipe.fileno(),

1520

2049

gobject.IO_IN | gobject.IO_HUP,

1521

2050

functools.partial(self.handle_ipc,

1522

parent_pipe = parent_pipe))

1523

2051

parent_pipe =

2052

parent_pipe,

2053

proc = proc))

2054

1524

2055

def handle_ipc(self, source, condition, parent_pipe=None,

1525

client_object=None):

1526

condition_names = {

1527

gobject.IO_IN: "IN", # There is data to read.

1528

gobject.IO_OUT: "OUT", # Data can be written (without

1529

# blocking).

1530

gobject.IO_PRI: "PRI", # There is urgent data to read.

1531

gobject.IO_ERR: "ERR", # Error condition.

1532

gobject.IO_HUP: "HUP" # Hung up (the connection has been

1533

# broken, usually for pipes and

1534

# sockets).

1535

}

1536

conditions_string = ' | '.join(name

1537

for cond, name in

1538

condition_names.iteritems()

1539

if cond & condition)

1540

# error or the other end of multiprocessing.Pipe has closed

1541

if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):

2056

proc = None, client_object=None):

2057

# error, or the other end of multiprocessing.Pipe has closed

2058

if condition & (gobject.IO_ERR | gobject.IO_HUP):

2059

# Wait for other process to exit

2060

proc.join()

1542

2061

return False

1543

2062

1544

2063

# Read a request from the child

1549

2068

fpr = request[1]

1550

2069

address = request[2]

1551

2070

1552

for c in self.clients:

2071

for c in self.clients.itervalues():

1553

2072

if c.fingerprint == fpr:

1554

2073

client = c

1555

2074

break

1558

2077

"dress: %s", fpr, address)

1559

2078

if self.use_dbus:

1560

2079

# Emit D-Bus signal

1561

mandos_dbus_service.ClientNotFound(fpr, address[0])

2080

mandos_dbus_service.ClientNotFound(fpr,

2081

address[0])

1562

2082

parent_pipe.send(False)

1563

2083

return False

1564

2084

1565

2085

gobject.io_add_watch(parent_pipe.fileno(),

1566

2086

gobject.IO_IN | gobject.IO_HUP,

1567

2087

functools.partial(self.handle_ipc,

1568

parent_pipe = parent_pipe,

1569

client_object = client))

2088

parent_pipe =

2089

parent_pipe,

2090

proc = proc,

2091

client_object =

2092

client))

1570

2093

parent_pipe.send(True)

1571

# remove the old hook in favor of the new above hook on same fileno

2094

# remove the old hook in favor of the new above hook on

2095

# same fileno

1572

2096

return False

1573

2097

if command == 'funcall':

1574

2098

funcname = request[1]

1575

2099

args = request[2]

1576

2100

kwargs = request[3]

1577

2101

1578

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1579

2102

parent_pipe.send(('data', getattr(client_object,

2103

funcname)(*args,

2104

**kwargs)))

2105

1580

2106

if command == 'getattr':

1581

2107

attrname = request[1]

1582

2108

if callable(client_object.__getattribute__(attrname)):

1583

2109

parent_pipe.send(('function',))

1584

2110

else:

1585

parent_pipe.send(('data', client_object.__getattribute__(attrname)))

2111

parent_pipe.send(('data', client_object

2112

.__getattribute__(attrname)))

1586

2113

1587

2114

if command == 'setattr':

1588

2115

attrname = request[1]

1589

2116

value = request[2]

1590

2117

setattr(client_object, attrname, value)

1591

2118

1592

2119

return True

1593

2120

1594

2121

2122

def rfc3339_duration_to_delta(duration):

2123

"""Parse an RFC 3339 "duration" and return a datetime.timedelta

2124

2125

>>> rfc3339_duration_to_delta("P7D")

2126

datetime.timedelta(7)

2127

>>> rfc3339_duration_to_delta("PT60S")

2128

datetime.timedelta(0, 60)

2129

>>> rfc3339_duration_to_delta("PT60M")

2130

datetime.timedelta(0, 3600)

2131

>>> rfc3339_duration_to_delta("PT24H")

2132

datetime.timedelta(1)

2133

>>> rfc3339_duration_to_delta("P1W")

2134

datetime.timedelta(7)

2135

>>> rfc3339_duration_to_delta("PT5M30S")

2136

datetime.timedelta(0, 330)

2137

>>> rfc3339_duration_to_delta("P1DT3M20S")

2138

datetime.timedelta(1, 200)

2139

"""

2140

2141

# Parsing an RFC 3339 duration with regular expressions is not

2142

# possible - there would have to be multiple places for the same

2143

# values, like seconds. The current code, while more esoteric, is

2144

# cleaner without depending on a parsing library. If Python had a

2145

# built-in library for parsing we would use it, but we'd like to

2146

# avoid excessive use of external libraries.

2147

2148

# New type for defining tokens, syntax, and semantics all-in-one

2149

Token = collections.namedtuple("Token",

2150

("regexp", # To match token; if

2151

# "value" is not None,

2152

# must have a "group"

2153

# containing digits

2154

"value", # datetime.timedelta or

2155

# None

2156

"followers")) # Tokens valid after

2157

# this token

2158

# RFC 3339 "duration" tokens, syntax, and semantics; taken from

2159

# the "duration" ABNF definition in RFC 3339, Appendix A.

2160

token_end = Token(re.compile(r"$"), None, frozenset())

2161

token_second = Token(re.compile(r"(\d+)S"),

2162

datetime.timedelta(seconds=1),

2163

frozenset((token_end,)))

2164

token_minute = Token(re.compile(r"(\d+)M"),

2165

datetime.timedelta(minutes=1),

2166

frozenset((token_second, token_end)))

2167

token_hour = Token(re.compile(r"(\d+)H"),

2168

datetime.timedelta(hours=1),

2169

frozenset((token_minute, token_end)))

2170

token_time = Token(re.compile(r"T"),

2171

None,

2172

frozenset((token_hour, token_minute,

2173

token_second)))

2174

token_day = Token(re.compile(r"(\d+)D"),

2175

datetime.timedelta(days=1),

2176

frozenset((token_time, token_end)))

2177

token_month = Token(re.compile(r"(\d+)M"),

2178

datetime.timedelta(weeks=4),

2179

frozenset((token_day, token_end)))

2180

token_year = Token(re.compile(r"(\d+)Y"),

2181

datetime.timedelta(weeks=52),

2182

frozenset((token_month, token_end)))

2183

token_week = Token(re.compile(r"(\d+)W"),

2184

datetime.timedelta(weeks=1),

2185

frozenset((token_end,)))

2186

token_duration = Token(re.compile(r"P"), None,

2187

frozenset((token_year, token_month,

2188

token_day, token_time,

2189

token_week))),

2190

# Define starting values

2191

value = datetime.timedelta() # Value so far

2192

found_token = None

2193

followers = frozenset(token_duration,) # Following valid tokens

2194

s = duration # String left to parse

2195

# Loop until end token is found

2196

while found_token is not token_end:

2197

# Search for any currently valid tokens

2198

for token in followers:

2199

match = token.regexp.match(s)

2200

if match is not None:

2201

# Token found

2202

if token.value is not None:

2203

# Value found, parse digits

2204

factor = int(match.group(1), 10)

2205

# Add to value so far

2206

value += factor * token.value

2207

# Strip token from string

2208

s = token.regexp.sub("", s, 1)

2209

# Go to found token

2210

found_token = token

2211

# Set valid next tokens

2212

followers = found_token.followers

2213

break

2214

else:

2215

# No currently valid tokens were found

2216

raise ValueError("Invalid RFC 3339 duration")

2217

# End token found

2218

return value

2219

2220

1595

2221

def string_to_delta(interval):

1596

2222

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

1597

2223

1608

2234

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

1609

2235

datetime.timedelta(0, 330)

1610

2236

"""

2237

2238

try:

2239

return rfc3339_duration_to_delta(interval)

2240

except ValueError:

2241

pass

2242

1611

2243

timevalue = datetime.timedelta(0)

1612

2244

for s in interval.split():

1613

2245

try:

1624

2256

elif suffix == "w":

1625

2257

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

1626

2258

else:

1627

raise ValueError("Unknown suffix %r" % suffix)

2259

raise ValueError("Unknown suffix {0!r}"

2260

.format(suffix))

1628

2261

except (ValueError, IndexError) as e:

1629

2262

raise ValueError(*(e.args))

1630

2263

timevalue += delta

1631

2264

return timevalue

1632

2265

1633

2266

1634

def if_nametoindex(interface):

1635

"""Call the C function if_nametoindex(), or equivalent

1636

1637

Note: This function cannot accept a unicode string."""

1638

global if_nametoindex

1639

try:

1640

if_nametoindex = (ctypes.cdll.LoadLibrary

1641

(ctypes.util.find_library("c"))

1642

.if_nametoindex)

1643

except (OSError, AttributeError):

1644

logger.warning("Doing if_nametoindex the hard way")

1645

def if_nametoindex(interface):

1646

"Get an interface index the hard way, i.e. using fcntl()"

1647

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

1648

with contextlib.closing(socket.socket()) as s:

1649

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1650

struct.pack(str("16s16x"),

1651

interface))

1652

interface_index = struct.unpack(str("I"),

1653

ifreq[16:20])[0]

1654

return interface_index

1655

return if_nametoindex(interface)

1656

1657

1658

2267

def daemon(nochdir = False, noclose = False):

1659

2268

"""See daemon(3). Standard BSD Unix function.

1660

2269

1668

2277

sys.exit()

1669

2278

if not noclose:

1670

2279

# Close all standard open file descriptors

1671

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

2280

null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)

1672

2281

if not stat.S_ISCHR(os.fstat(null).st_mode):

1673

2282

raise OSError(errno.ENODEV,

1674

"%s not a character device"

1675

% os.path.devnull)

2283

"{0} not a character device"

2284

.format(os.devnull))

1676

2285

os.dup2(null, sys.stdin.fileno())

1677

2286

os.dup2(null, sys.stdout.fileno())

1678

2287

os.dup2(null, sys.stderr.fileno())

1687

2296

1688

2297

parser = argparse.ArgumentParser()

1689

2298

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

1690

version = "%%(prog)s %s" % version,

2299

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

1691

2300

help="show version number and exit")

1692

2301

parser.add_argument("-i", "--interface", metavar="IF",

1693

2302

help="Bind to interface IF")

1699

2308

help="Run self-test")

1700

2309

parser.add_argument("--debug", action="store_true",

1701

2310

help="Debug mode; run in foreground and log"

1702

" to terminal")

2311

" to terminal", default=None)

1703

2312

parser.add_argument("--debuglevel", metavar="LEVEL",

1704

2313

help="Debug level for stdout output")

1705

2314

parser.add_argument("--priority", help="GnuTLS"

1712

2321

" files")

1713

2322

parser.add_argument("--no-dbus", action="store_false",

1714

2323

dest="use_dbus", help="Do not provide D-Bus"

1715

" system bus interface")

2324

" system bus interface", default=None)

1716

2325

parser.add_argument("--no-ipv6", action="store_false",

1717

dest="use_ipv6", help="Do not use IPv6")

2326

dest="use_ipv6", help="Do not use IPv6",

2327

default=None)

2328

parser.add_argument("--no-restore", action="store_false",

2329

dest="restore", help="Do not restore stored"

2330

" state", default=None)

2331

parser.add_argument("--socket", type=int,

2332

help="Specify a file descriptor to a network"

2333

" socket to use instead of creating one")

2334

parser.add_argument("--statedir", metavar="DIR",

2335

help="Directory to save/restore state in")

2336

parser.add_argument("--foreground", action="store_true",

2337

help="Run in foreground", default=None)

2338

1718

2339

options = parser.parse_args()

1719

2340

1720

2341

if options.check:

1728

2349

"port": "",

1729

2350

"debug": "False",

1730

2351

"priority":

1731

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

2352

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

1732

2353

"servicename": "Mandos",

1733

2354

"use_dbus": "True",

1734

2355

"use_ipv6": "True",

1735

2356

"debuglevel": "",

2357

"restore": "True",

2358

"socket": "",

2359

"statedir": "/var/lib/mandos",

2360

"foreground": "False",

1736

2361

}

1737

2362

1738

2363

# Parse config file for server-global settings

1743

2368

# Convert the SafeConfigParser object to a dict

1744

2369

server_settings = server_config.defaults()

1745

2370

# Use the appropriate methods on the non-string config options

1746

for option in ("debug", "use_dbus", "use_ipv6"):

2371

for option in ("debug", "use_dbus", "use_ipv6", "foreground"):

1747

2372

server_settings[option] = server_config.getboolean("DEFAULT",

1748

2373

option)

1749

2374

if server_settings["port"]:

1750

2375

server_settings["port"] = server_config.getint("DEFAULT",

1751

2376

"port")

2377

if server_settings["socket"]:

2378

server_settings["socket"] = server_config.getint("DEFAULT",

2379

"socket")

2380

# Later, stdin will, and stdout and stderr might, be dup'ed

2381

# over with an opened os.devnull. But we don't want this to

2382

# happen with a supplied network socket.

2383

if 0 <= server_settings["socket"] <= 2:

2384

server_settings["socket"] = os.dup(server_settings

2385

["socket"])

1752

2386

del server_config

1753

2387

1754

2388

# Override the settings from the config file with command line

1755

2389

# options, if set.

1756

2390

for option in ("interface", "address", "port", "debug",

1757

2391

"priority", "servicename", "configdir",

1758

"use_dbus", "use_ipv6", "debuglevel"):

2392

"use_dbus", "use_ipv6", "debuglevel", "restore",

2393

"statedir", "socket", "foreground"):

1759

2394

value = getattr(options, option)

1760

2395

if value is not None:

1761

2396

server_settings[option] = value

1764

2399

for option in server_settings.keys():

1765

2400

if type(server_settings[option]) is str:

1766

2401

server_settings[option] = unicode(server_settings[option])

2402

# Force all boolean options to be boolean

2403

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2404

"foreground"):

2405

server_settings[option] = bool(server_settings[option])

2406

# Debug implies foreground

2407

if server_settings["debug"]:

2408

server_settings["foreground"] = True

1767

2409

# Now we have our good server settings in "server_settings"

1768

2410

1769

2411

##################################################################

1773

2415

debuglevel = server_settings["debuglevel"]

1774

2416

use_dbus = server_settings["use_dbus"]

1775

2417

use_ipv6 = server_settings["use_ipv6"]

1776

2418

stored_state_path = os.path.join(server_settings["statedir"],

2419

stored_state_file)

2420

foreground = server_settings["foreground"]

2421

2422

if debug:

2423

initlogger(debug, logging.DEBUG)

2424

else:

2425

if not debuglevel:

2426

initlogger(debug)

2427

else:

2428

level = getattr(logging, debuglevel.upper())

2429

initlogger(debug, level)

2430

1777

2431

if server_settings["servicename"] != "Mandos":

1778

2432

syslogger.setFormatter(logging.Formatter

1779

('Mandos (%s) [%%(process)d]:'

1780

' %%(levelname)s: %%(message)s'

1781

% server_settings["servicename"]))

2433

('Mandos ({0}) [%(process)d]:'

2434

' %(levelname)s: %(message)s'

2435

.format(server_settings

2436

["servicename"])))

1782

2437

1783

2438

# Parse config file with clients

1784

client_defaults = { "timeout": "5m",

1785

"extended_timeout": "15m",

1786

"interval": "2m",

1787

"checker": "fping -q -- %%(host)s",

1788

"host": "",

1789

"approval_delay": "0s",

1790

"approval_duration": "1s",

1791

}

1792

client_config = configparser.SafeConfigParser(client_defaults)

2439

client_config = configparser.SafeConfigParser(Client

2440

.client_defaults)

1793

2441

client_config.read(os.path.join(server_settings["configdir"],

1794

2442

"clients.conf"))

1795

2443

1804

2452

use_ipv6=use_ipv6,

1805

2453

gnutls_priority=

1806

2454

server_settings["priority"],

1807

use_dbus=use_dbus)

1808

if not debug:

1809

pidfilename = "/var/run/mandos.pid"

2455

use_dbus=use_dbus,

2456

socketfd=(server_settings["socket"]

2457

or None))

2458

if not foreground:

2459

pidfilename = "/run/mandos.pid"

2460

if not os.path.isdir("/run/."):

2461

pidfilename = "/var/run/mandos.pid"

2462

pidfile = None

1810

2463

try:

1811

2464

pidfile = open(pidfilename, "w")

1812

except IOError:

1813

logger.error("Could not open file %r", pidfilename)

2465

except IOError as e:

2466

logger.error("Could not open file %r", pidfilename,

2467

exc_info=e)

1814

2468

1815

try:

1816

uid = pwd.getpwnam("_mandos").pw_uid

1817

gid = pwd.getpwnam("_mandos").pw_gid

1818

except KeyError:

2469

for name in ("_mandos", "mandos", "nobody"):

1819

2470

try:

1820

uid = pwd.getpwnam("mandos").pw_uid

1821

gid = pwd.getpwnam("mandos").pw_gid

2471

uid = pwd.getpwnam(name).pw_uid

2472

gid = pwd.getpwnam(name).pw_gid

2473

break

1822

2474

except KeyError:

1823

try:

1824

uid = pwd.getpwnam("nobody").pw_uid

1825

gid = pwd.getpwnam("nobody").pw_gid

1826

except KeyError:

1827

uid = 65534

1828

gid = 65534

2475

continue

2476

else:

2477

uid = 65534

2478

gid = 65534

1829

2479

try:

1830

2480

os.setgid(gid)

1831

2481

os.setuid(uid)

1832

2482

except OSError as error:

1833

if error[0] != errno.EPERM:

2483

if error.errno != errno.EPERM:

1834

2484

raise error

1835

2485

1836

if not debug and not debuglevel:

1837

syslogger.setLevel(logging.WARNING)

1838

console.setLevel(logging.WARNING)

1839

if debuglevel:

1840

level = getattr(logging, debuglevel.upper())

1841

syslogger.setLevel(level)

1842

console.setLevel(level)

1843

1844

2486

if debug:

1845

2487

# Enable all possible GnuTLS debugging

1846

2488

1856

2498

.gnutls_global_set_log_function(debug_gnutls))

1857

2499

1858

2500

# Redirect stdin so all checkers get /dev/null

1859

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

2501

null = os.open(os.devnull, os.O_NOCTTY | os.O_RDWR)

1860

2502

os.dup2(null, sys.stdin.fileno())

1861

2503

if null > 2:

1862

2504

os.close(null)

1863

else:

1864

# No console logging

1865

logger.removeHandler(console)

1866

2505

1867

2506

# Need to fork before connecting to D-Bus

1868

if not debug:

2507

if not foreground:

1869

2508

# Close all input and output, do double fork, etc.

1870

2509

daemon()

1871

2510

2511

# multiprocessing will use threads, so before we use gobject we

2512

# need to inform gobject that threads will be used.

2513

gobject.threads_init()

2514

1872

2515

global main_loop

1873

2516

# From the Avahi example code

1874

DBusGMainLoop(set_as_default=True )

2517

DBusGMainLoop(set_as_default=True)

1875

2518

main_loop = gobject.MainLoop()

1876

2519

bus = dbus.SystemBus()

1877

2520

# End of Avahi example code

1878

2521

if use_dbus:

1879

2522

try:

1880

bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",

2523

bus_name = dbus.service.BusName("se.recompile.Mandos",

1881

2524

bus, do_not_queue=True)

2525

old_bus_name = (dbus.service.BusName

2526

("se.bsnet.fukt.Mandos", bus,

2527

do_not_queue=True))

1882

2528

except dbus.exceptions.NameExistsException as e:

1883

logger.error(unicode(e) + ", disabling D-Bus")

2529

logger.error("Disabling D-Bus:", exc_info=e)

1884

2530

use_dbus = False

1885

2531

server_settings["use_dbus"] = False

1886

2532

tcp_server.use_dbus = False

1887

2533

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1888

service = AvahiService(name = server_settings["servicename"],

1889

servicetype = "_mandos._tcp",

1890

protocol = protocol, bus = bus)

2534

service = AvahiServiceToSyslog(name =

2535

server_settings["servicename"],

2536

servicetype = "_mandos._tcp",

2537

protocol = protocol, bus = bus)

1891

2538

if server_settings["interface"]:

1892

2539

service.interface = (if_nametoindex

1893

2540

(str(server_settings["interface"])))

1898

2545

client_class = Client

1899

2546

if use_dbus:

1900

2547

client_class = functools.partial(ClientDBus, bus = bus)

1901

def client_config_items(config, section):

1902

special_settings = {

1903

"approved_by_default":

1904

lambda: config.getboolean(section,

1905

"approved_by_default"),

1906

}

1907

for name, value in config.items(section):

2548

2549

client_settings = Client.config_parser(client_config)

2550

old_client_settings = {}

2551

clients_data = {}

2552

2553

# This is used to redirect stdout and stderr for checker processes

2554

global wnull

2555

wnull = open(os.devnull, "w") # A writable /dev/null

2556

# Only used if server is running in foreground but not in debug

2557

# mode

2558

if debug or not foreground:

2559

wnull.close()

2560

2561

# Get client data and settings from last running state.

2562

if server_settings["restore"]:

2563

try:

2564

with open(stored_state_path, "rb") as stored_state:

2565

clients_data, old_client_settings = (pickle.load

2566

(stored_state))

2567

os.remove(stored_state_path)

2568

except IOError as e:

2569

if e.errno == errno.ENOENT:

2570

logger.warning("Could not load persistent state: {0}"

2571

.format(os.strerror(e.errno)))

2572

else:

2573

logger.critical("Could not load persistent state:",

2574

exc_info=e)

2575

raise

2576

except EOFError as e:

2577

logger.warning("Could not load persistent state: "

2578

"EOFError:", exc_info=e)

2579

2580

with PGPEngine() as pgp:

2581

for client_name, client in clients_data.iteritems():

2582

# Skip removed clients

2583

if client_name not in client_settings:

2584

continue

2585

2586

# Decide which value to use after restoring saved state.

2587

# We have three different values: Old config file,

2588

# new config file, and saved state.

2589

# New config value takes precedence if it differs from old

2590

# config value, otherwise use saved state.

2591

for name, value in client_settings[client_name].items():

2592

try:

2593

# For each value in new config, check if it

2594

# differs from the old config value (Except for

2595

# the "secret" attribute)

2596

if (name != "secret" and

2597

value != old_client_settings[client_name]

2598

[name]):

2599

client[name] = value

2600

except KeyError:

2601

pass

2602

2603

# Clients who has passed its expire date can still be

2604

# enabled if its last checker was successful. Clients

2605

# whose checker succeeded before we stored its state is

2606

# assumed to have successfully run all checkers during

2607

# downtime.

2608

if client["enabled"]:

2609

if datetime.datetime.utcnow() >= client["expires"]:

2610

if not client["last_checked_ok"]:

2611

logger.warning(

2612

"disabling client {0} - Client never "

2613

"performed a successful checker"

2614

.format(client_name))

2615

client["enabled"] = False

2616

elif client["last_checker_status"] != 0:

2617

logger.warning(

2618

"disabling client {0} - Client "

2619

"last checker failed with error code {1}"

2620

.format(client_name,

2621

client["last_checker_status"]))

2622

client["enabled"] = False

2623

else:

2624

client["expires"] = (datetime.datetime

2625

.utcnow()

2626

+ client["timeout"])

2627

logger.debug("Last checker succeeded,"

2628

" keeping {0} enabled"

2629

.format(client_name))

1908

2630

try:

1909

yield (name, special_settings[name]())

1910

except KeyError:

1911

yield (name, value)

1912

1913

tcp_server.clients.update(set(

1914

client_class(name = section,

1915

config= dict(client_config_items(

1916

client_config, section)))

1917

for section in client_config.sections()))

2631

client["secret"] = (

2632

pgp.decrypt(client["encrypted_secret"],

2633

client_settings[client_name]

2634

["secret"]))

2635

except PGPError:

2636

# If decryption fails, we use secret from new settings

2637

logger.debug("Failed to decrypt {0} old secret"

2638

.format(client_name))

2639

client["secret"] = (

2640

client_settings[client_name]["secret"])

2641

2642

# Add/remove clients based on new changes made to config

2643

for client_name in (set(old_client_settings)

2644

- set(client_settings)):

2645

del clients_data[client_name]

2646

for client_name in (set(client_settings)

2647

- set(old_client_settings)):

2648

clients_data[client_name] = client_settings[client_name]

2649

2650

# Create all client objects

2651

for client_name, client in clients_data.iteritems():

2652

tcp_server.clients[client_name] = client_class(

2653

name = client_name, settings = client,

2654

server_settings = server_settings)

2655

1918

2656

if not tcp_server.clients:

1919

2657

logger.warning("No clients defined")

1920

1921

if not debug:

1922

try:

1923

with pidfile:

1924

pid = os.getpid()

1925

pidfile.write(str(pid) + "\n".encode("utf-8"))

1926

del pidfile

1927

except IOError:

1928

logger.error("Could not write to file %r with PID %d",

1929

pidfilename, pid)

1930

except NameError:

1931

# "pidfile" was never created

1932

pass

2658

2659

if not foreground:

2660

if pidfile is not None:

2661

try:

2662

with pidfile:

2663

pid = os.getpid()

2664

pidfile.write(str(pid) + "\n".encode("utf-8"))

2665

except IOError:

2666

logger.error("Could not write to file %r with PID %d",

2667

pidfilename, pid)

2668

del pidfile

1933

2669

del pidfilename

1934

1935

signal.signal(signal.SIGINT, signal.SIG_IGN)

1936

2670

1937

2671

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

1938

2672

signal.signal(signal.SIGTERM, lambda signum, frame: sys.exit())

1939

2673

1940

2674

if use_dbus:

1941

class MandosDBusService(dbus.service.Object):

2675

@alternate_dbus_interfaces({"se.recompile.Mandos":

2676

"se.bsnet.fukt.Mandos"})

2677

class MandosDBusService(DBusObjectWithProperties):

1942

2678

"""A D-Bus proxy object"""

1943

2679

def __init__(self):

1944

2680

dbus.service.Object.__init__(self, bus, "/")

1945

_interface = "se.bsnet.fukt.Mandos"

2681

_interface = "se.recompile.Mandos"

2682

2683

@dbus_interface_annotations(_interface)

2684

def _foo(self):

2685

return { "org.freedesktop.DBus.Property"

2686

".EmitsChangedSignal":

2687

"false"}

1946

2688

1947

2689

@dbus.service.signal(_interface, signature="o")

1948

2690

def ClientAdded(self, objpath):

1963

2705

def GetAllClients(self):

1964

2706

"D-Bus method"

1965

2707

return dbus.Array(c.dbus_object_path

1966

for c in tcp_server.clients)

2708

for c in

2709

tcp_server.clients.itervalues())

1967

2710

1968

2711

@dbus.service.method(_interface,

1969

2712

out_signature="a{oa{sv}}")

1971

2714

"D-Bus method"

1972

2715

return dbus.Dictionary(

1973

2716

((c.dbus_object_path, c.GetAll(""))

1974

for c in tcp_server.clients),

2717

for c in tcp_server.clients.itervalues()),

1975

2718

signature="oa{sv}")

1976

2719

1977

2720

@dbus.service.method(_interface, in_signature="o")

1978

2721

def RemoveClient(self, object_path):

1979

2722

"D-Bus method"

1980

for c in tcp_server.clients:

2723

for c in tcp_server.clients.itervalues():

1981

2724

if c.dbus_object_path == object_path:

1982

tcp_server.clients.remove(c)

2725

del tcp_server.clients[c.name]

1983

2726

c.remove_from_connection()

1984

2727

# Don't signal anything except ClientRemoved

1985

2728

c.disable(quiet=True)

1996

2739

"Cleanup function; run on exit"

1997

2740

service.cleanup()

1998

2741

2742

multiprocessing.active_children()

2743

wnull.close()

2744

if not (tcp_server.clients or client_settings):

2745

return

2746

2747

# Store client before exiting. Secrets are encrypted with key

2748

# based on what config file has. If config file is

2749

# removed/edited, old secret will thus be unrecovable.

2750

clients = {}

2751

with PGPEngine() as pgp:

2752

for client in tcp_server.clients.itervalues():

2753

key = client_settings[client.name]["secret"]

2754

client.encrypted_secret = pgp.encrypt(client.secret,

2755

key)

2756

client_dict = {}

2757

2758

# A list of attributes that can not be pickled

2759

# + secret.

2760

exclude = set(("bus", "changedstate", "secret",

2761

"checker", "server_settings"))

2762

for name, typ in (inspect.getmembers

2763

(dbus.service.Object)):

2764

exclude.add(name)

2765

2766

client_dict["encrypted_secret"] = (client

2767

.encrypted_secret)

2768

for attr in client.client_structure:

2769

if attr not in exclude:

2770

client_dict[attr] = getattr(client, attr)

2771

2772

clients[client.name] = client_dict

2773

del client_settings[client.name]["secret"]

2774

2775

try:

2776

with (tempfile.NamedTemporaryFile

2777

(mode='wb', suffix=".pickle", prefix='clients-',

2778

dir=os.path.dirname(stored_state_path),

2779

delete=False)) as stored_state:

2780

pickle.dump((clients, client_settings), stored_state)

2781

tempname=stored_state.name

2782

os.rename(tempname, stored_state_path)

2783

except (IOError, OSError) as e:

2784

if not debug:

2785

try:

2786

os.remove(tempname)

2787

except NameError:

2788

pass

2789

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

2790

logger.warning("Could not save persistent state: {0}"

2791

.format(os.strerror(e.errno)))

2792

else:

2793

logger.warning("Could not save persistent state:",

2794

exc_info=e)

2795

raise e

2796

2797

# Delete all clients, and settings from config

1999

2798

while tcp_server.clients:

2000

client = tcp_server.clients.pop()

2799

name, client = tcp_server.clients.popitem()

2001

2800

if use_dbus:

2002

2801

client.remove_from_connection()

2003

client.disable_hook = None

2004

2802

# Don't signal anything except ClientRemoved

2005

2803

client.disable(quiet=True)

2006

2804

if use_dbus:

2007

2805

# Emit D-Bus signal

2008

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2806

mandos_dbus_service.ClientRemoved(client

2807

.dbus_object_path,

2009

2808

client.name)

2809

client_settings.clear()

2010

2810

2011

2811

atexit.register(cleanup)

2012

2812

2013

for client in tcp_server.clients:

2813

for client in tcp_server.clients.itervalues():

2014

2814

if use_dbus:

2015

2815

# Emit D-Bus signal

2016

2816

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2017

client.enable()

2817

# Need to initiate checking of clients

2818

if client.enabled:

2819

client.init_checker()

2018

2820

2019

2821

tcp_server.enable()

2020

2822

tcp_server.server_activate()

2023

2825

service.port = tcp_server.socket.getsockname()[1]

2024

2826

if use_ipv6:

2025

2827

logger.info("Now listening on address %r, port %d,"

2026

" flowinfo %d, scope_id %d"

2027

% tcp_server.socket.getsockname())

2828

" flowinfo %d, scope_id %d",

2829

*tcp_server.socket.getsockname())

2028

2830

else: # IPv4

2029

logger.info("Now listening on address %r, port %d"

2030

% tcp_server.socket.getsockname())

2831

logger.info("Now listening on address %r, port %d",

2832

*tcp_server.socket.getsockname())

2031

2833

2032

2834

#service.interface = tcp_server.socket.getsockname()[3]

2033

2835

2036

2838

try:

2037

2839

service.activate()

2038

2840

except dbus.exceptions.DBusException as error:

2039

logger.critical("DBusException: %s", error)

2841

logger.critical("D-Bus Exception", exc_info=error)

2040

2842

cleanup()

2041

2843

sys.exit(1)

2042

2844

# End of Avahi example code

2049

2851

logger.debug("Starting main loop")

2050

2852

main_loop.run()

2051

2853

except AvahiError as error:

2052

logger.critical("AvahiError: %s", error)

2854

logger.critical("Avahi Error", exc_info=error)

2053

2855

cleanup()

2054

2856

sys.exit(1)

2055

2857

except KeyboardInterrupt: