/mandos/release : revision 24.1.157

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

81

SO_BINDTODEVICE = None

82

83

84

version = "1.2"

84

version = "1.0.14"

85

86

#logger = logging.getLogger(u'mandos')

87

logger = logging.Logger(u'mandos')

165

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

166

% self.name))

167

self.remove()

168

try:

169

self.add()

170

except dbus.exceptions.DBusException, error:

171

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

172

self.cleanup()

173

os._exit(1)

168

self.add()

174

169

self.rename_count += 1

175

170

def remove(self):

176

171

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

240

235

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

241

236

242

237

Attributes:

243

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

244

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

245

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

238

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

239

D-Bus identifiers

240

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

241

uniquely identify the client

242

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

243

host: string; available for use by the checker command

244

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

245

last_enabled: datetime.datetime(); (UTC)

246

enabled: bool()

247

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

248

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

249

until this client is disabled

250

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

251

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

246

252

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

247

253

to see if the client lives.

248

254

'None' if no process is running.

249

checker_callback_tag: a gobject event source tag, or None

250

checker_command: string; External command which is run to check

251

if client lives. %() expansions are done at

255

checker_initiator_tag: a gobject event source tag, or None

256

disable_initiator_tag: - '' -

257

checker_callback_tag: - '' -

258

checker_command: string; External command which is run to check if

259

client lives. %() expansions are done at

252

260

runtime with vars(self) as dict, so that for

253

261

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

254

checker_initiator_tag: a gobject event source tag, or None

255

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

256

262

current_checker_command: string; current running checker_command

257

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

258

disable_initiator_tag: a gobject event source tag, or None

259

enabled: bool()

260

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

261

uniquely identify the client

262

host: string; available for use by the checker command

263

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

264

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

265

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

266

last_enabled: datetime.datetime(); (UTC)

267

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

268

D-Bus identifiers

269

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

270

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

271

until this client is disabled

272

runtime_expansions: Allowed attributes for runtime expansion.

263

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

264

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

265

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

273

266

"""

274

267

275

runtime_expansions = (u"approval_delay", u"approval_duration",

276

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

277

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

278

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

279

280

268

@staticmethod

281

269

def _timedelta_to_milliseconds(td):

282

270

"Convert a datetime.timedelta() to milliseconds"

292

280

"Return the 'interval' attribute in milliseconds"

293

281

return self._timedelta_to_milliseconds(self.interval)

294

282

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

283

def approved_delay_milliseconds(self):

284

return self._timedelta_to_milliseconds(self.approved_delay)

297

285

298

286

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

299

287

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

322

310

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

323

311

self.created = datetime.datetime.utcnow()

324

312

self.enabled = False

325

self.last_approval_request = None

326

313

self.last_enabled = None

327

314

self.last_checked_ok = None

328

315

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

339

326

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

340

327

True)

341

328

self.approvals_pending = 0

342

self.approval_delay = string_to_delta(

343

config[u"approval_delay"])

344

self.approval_duration = string_to_delta(

345

config[u"approval_duration"])

329

self.approved_delay = string_to_delta(

330

config[u"approved_delay"])

331

self.approved_duration = string_to_delta(

332

config[u"approved_duration"])

346

333

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

347

334

348

335

def send_changedstate(self):

424

411

(self.timeout_milliseconds(),

425

412

self.disable))

426

413

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

430

414

def start_checker(self):

431

415

"""Start a new checker subprocess if one is not running.

432

416

461

445

command = self.checker_command % self.host

462

446

except TypeError:

463

447

# Escape attributes for the shell

464

escaped_attrs = dict(

465

(attr,

466

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

467

errors=

468

u'replace')))

469

for attr in

470

self.runtime_expansions)

471

448

escaped_attrs = dict((key,

449

re.escape(unicode(str(val),

450

errors=

451

u'replace')))

452

for key, val in

453

vars(self).iteritems())

472

454

try:

473

455

command = self.checker_command % escaped_attrs

474

456

except TypeError, error:

716

698

dbus_object_path: dbus.ObjectPath

717

699

bus: dbus.SystemBus()

718

700

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

723

701

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

724

702

725

703

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

728

706

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

729

707

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

730

708

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

{ord(u"."): ord(u"_"),

733

ord(u"-"): ord(u"_")})

734

709

self.dbus_object_path = (dbus.ObjectPath

735

(u"/clients/" + client_object_name))

710

(u"/clients/"

711

+ self.name.replace(u".", u"_")))

736

712

DBusObjectWithProperties.__init__(self, self.bus,

737

713

self.dbus_object_path)

738

714

739

715

def _get_approvals_pending(self):

740

716

return self._approvals_pending

741

717

def _set_approvals_pending(self, value):

745

721

if (hasattr(self, "dbus_object_path")

746

722

and bval is not bool(old_value)):

747

723

dbus_bool = dbus.Boolean(bval, variant_level=1)

748

self.PropertyChanged(dbus.String(u"ApprovalPending"),

724

self.PropertyChanged(dbus.String(u"approved_pending"),

749

725

dbus_bool)

750

726

751

727

approvals_pending = property(_get_approvals_pending,

763

739

r = Client.enable(self)

764

740

if oldstate != self.enabled:

765

741

# Emit D-Bus signals

766

self.PropertyChanged(dbus.String(u"Enabled"),

742

self.PropertyChanged(dbus.String(u"enabled"),

767

743

dbus.Boolean(True, variant_level=1))

768

744

self.PropertyChanged(

769

dbus.String(u"LastEnabled"),

745

dbus.String(u"last_enabled"),

770

746

self._datetime_to_dbus(self.last_enabled,

771

747

variant_level=1))

772

748

return r

776

752

r = Client.disable(self, quiet=quiet)

777

753

if not quiet and oldstate != self.enabled:

778

754

# Emit D-Bus signal

779

self.PropertyChanged(dbus.String(u"Enabled"),

755

self.PropertyChanged(dbus.String(u"enabled"),

780

756

dbus.Boolean(False, variant_level=1))

781

757

return r

782

758

794

770

self.checker_callback_tag = None

795

771

self.checker = None

796

772

# Emit D-Bus signal

797

self.PropertyChanged(dbus.String(u"CheckerRunning"),

773

self.PropertyChanged(dbus.String(u"checker_running"),

798

774

dbus.Boolean(False, variant_level=1))

799

775

if os.WIFEXITED(condition):

800

776

exitstatus = os.WEXITSTATUS(condition)

815

791

r = Client.checked_ok(self, *args, **kwargs)

816

792

# Emit D-Bus signal

817

793

self.PropertyChanged(

818

dbus.String(u"LastCheckedOK"),

794

dbus.String(u"last_checked_ok"),

819

795

(self._datetime_to_dbus(self.last_checked_ok,

820

796

variant_level=1)))

821

797

return r

822

798

823

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

824

r = Client.need_approval(self, *args, **kwargs)

825

# Emit D-Bus signal

826

self.PropertyChanged(

827

dbus.String(u"LastApprovalRequest"),

828

(self._datetime_to_dbus(self.last_approval_request,

829

variant_level=1)))

830

return r

831

832

799

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

833

800

old_checker = self.checker

834

801

if self.checker is not None:

842

809

# Emit D-Bus signal

843

810

self.CheckerStarted(self.current_checker_command)

844

811

self.PropertyChanged(

845

dbus.String(u"CheckerRunning"),

812

dbus.String(u"checker_running"),

846

813

dbus.Boolean(True, variant_level=1))

847

814

return r

848

815

851

818

r = Client.stop_checker(self, *args, **kwargs)

852

819

if (old_checker is not None

853

820

and getattr(self, u"checker", None) is None):

854

self.PropertyChanged(dbus.String(u"CheckerRunning"),

821

self.PropertyChanged(dbus.String(u"checker_running"),

855

822

dbus.Boolean(False, variant_level=1))

856

823

return r

857

824

862

829

def approve(self, value=True):

863

830

self.send_changedstate()

864

831

self._approved = value

865

gobject.timeout_add(self._timedelta_to_milliseconds

866

(self.approval_duration),

832

gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration),

867

833

self._reset_approved)

868

834

869

835

906

872

pass

907

873

908

874

# NeedApproval - signal

909

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

875

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

910

876

def NeedApproval(self, timeout, default):

911

877

"D-Bus signal"

912

return self.need_approval()

878

pass

913

879

914

880

## Methods

915

881

916

882

# Approve - method

917

883

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

918

884

def Approve(self, value):

919

885

self.approve(value)

920

886

921

887

# CheckedOK - method

922

888

@dbus.service.method(_interface)

923

889

def CheckedOK(self):

948

914

949

915

## Properties

950

916

951

# ApprovalPending - property

917

# approved_pending - property

952

918

@dbus_service_property(_interface, signature=u"b", access=u"read")

953

def ApprovalPending_dbus_property(self):

919

def approved_pending_dbus_property(self):

954

920

return dbus.Boolean(bool(self.approvals_pending))

955

921

956

# ApprovedByDefault - property

922

# approved_by_default - property

957

923

@dbus_service_property(_interface, signature=u"b",

958

924

access=u"readwrite")

959

def ApprovedByDefault_dbus_property(self, value=None):

960

if value is None: # get

961

return dbus.Boolean(self.approved_by_default)

962

self.approved_by_default = bool(value)

963

# Emit D-Bus signal

964

self.PropertyChanged(dbus.String(u"ApprovedByDefault"),

965

dbus.Boolean(value, variant_level=1))

966

967

# ApprovalDelay - property

968

@dbus_service_property(_interface, signature=u"t",

969

access=u"readwrite")

970

def ApprovalDelay_dbus_property(self, value=None):

971

if value is None: # get

972

return dbus.UInt64(self.approval_delay_milliseconds())

973

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

974

# Emit D-Bus signal

975

self.PropertyChanged(dbus.String(u"ApprovalDelay"),

976

dbus.UInt64(value, variant_level=1))

977

978

# ApprovalDuration - property

979

@dbus_service_property(_interface, signature=u"t",

980

access=u"readwrite")

981

def ApprovalDuration_dbus_property(self, value=None):

982

if value is None: # get

983

return dbus.UInt64(self._timedelta_to_milliseconds(

984

self.approval_duration))

985

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

986

# Emit D-Bus signal

987

self.PropertyChanged(dbus.String(u"ApprovalDuration"),

988

dbus.UInt64(value, variant_level=1))

989

990

# Name - property

925

def approved_by_default_dbus_property(self):

926

return dbus.Boolean(self.approved_by_default)

927

928

# approved_delay - property

929

@dbus_service_property(_interface, signature=u"t",

930

access=u"readwrite")

931

def approved_delay_dbus_property(self):

932

return dbus.UInt64(self.approved_delay_milliseconds())

933

934

# approved_duration - property

935

@dbus_service_property(_interface, signature=u"t",

936

access=u"readwrite")

937

def approved_duration_dbus_property(self):

938

return dbus.UInt64(self._timedelta_to_milliseconds(

939

self.approved_duration))

940

941

# name - property

991

942

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

992

def Name_dbus_property(self):

943

def name_dbus_property(self):

993

944

return dbus.String(self.name)

994

945

995

# Fingerprint - property

946

# fingerprint - property

996

947

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

997

def Fingerprint_dbus_property(self):

948

def fingerprint_dbus_property(self):

998

949

return dbus.String(self.fingerprint)

999

950

1000

# Host - property

951

# host - property

1001

952

@dbus_service_property(_interface, signature=u"s",

1002

953

access=u"readwrite")

1003

def Host_dbus_property(self, value=None):

954

def host_dbus_property(self, value=None):

1004

955

if value is None: # get

1005

956

return dbus.String(self.host)

1006

957

self.host = value

1007

958

# Emit D-Bus signal

1008

self.PropertyChanged(dbus.String(u"Host"),

959

self.PropertyChanged(dbus.String(u"host"),

1009

960

dbus.String(value, variant_level=1))

1010

961

1011

# Created - property

962

# created - property

1012

963

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

1013

def Created_dbus_property(self):

964

def created_dbus_property(self):

1014

965

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

1015

966

1016

# LastEnabled - property

967

# last_enabled - property

1017

968

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

1018

def LastEnabled_dbus_property(self):

969

def last_enabled_dbus_property(self):

1019

970

if self.last_enabled is None:

1020

971

return dbus.String(u"")

1021

972

return dbus.String(self._datetime_to_dbus(self.last_enabled))

1022

973

1023

# Enabled - property

974

# enabled - property

1024

975

@dbus_service_property(_interface, signature=u"b",

1025

976

access=u"readwrite")

1026

def Enabled_dbus_property(self, value=None):

977

def enabled_dbus_property(self, value=None):

1027

978

if value is None: # get

1028

979

return dbus.Boolean(self.enabled)

1029

980

if value:

1031

982

else:

1032

983

self.disable()

1033

984

1034

# LastCheckedOK - property

985

# last_checked_ok - property

1035

986

@dbus_service_property(_interface, signature=u"s",

1036

987

access=u"readwrite")

1037

def LastCheckedOK_dbus_property(self, value=None):

988

def last_checked_ok_dbus_property(self, value=None):

1038

989

if value is not None:

1039

990

self.checked_ok()

1040

991

return

1043

994

return dbus.String(self._datetime_to_dbus(self

1044

995

.last_checked_ok))

1045

996

1046

# LastApprovalRequest - property

1047

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

1048

def LastApprovalRequest_dbus_property(self):

1049

if self.last_approval_request is None:

1050

return dbus.String(u"")

1051

return dbus.String(self.

1052

_datetime_to_dbus(self

1053

.last_approval_request))

1054

1055

# Timeout - property

997

# timeout - property

1056

998

@dbus_service_property(_interface, signature=u"t",

1057

999

access=u"readwrite")

1058

def Timeout_dbus_property(self, value=None):

1000

def timeout_dbus_property(self, value=None):

1059

1001

if value is None: # get

1060

1002

return dbus.UInt64(self.timeout_milliseconds())

1061

1003

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

1062

1004

# Emit D-Bus signal

1063

self.PropertyChanged(dbus.String(u"Timeout"),

1005

self.PropertyChanged(dbus.String(u"timeout"),

1064

1006

dbus.UInt64(value, variant_level=1))

1065

1007

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

1066

1008

return

1080

1022

self.disable_initiator_tag = (gobject.timeout_add

1081

1023

(time_to_die, self.disable))

1082

1024

1083

# Interval - property

1025

# interval - property

1084

1026

@dbus_service_property(_interface, signature=u"t",

1085

1027

access=u"readwrite")

1086

def Interval_dbus_property(self, value=None):

1028

def interval_dbus_property(self, value=None):

1087

1029

if value is None: # get

1088

1030

return dbus.UInt64(self.interval_milliseconds())

1089

1031

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

1090

1032

# Emit D-Bus signal

1091

self.PropertyChanged(dbus.String(u"Interval"),

1033

self.PropertyChanged(dbus.String(u"interval"),

1092

1034

dbus.UInt64(value, variant_level=1))

1093

1035

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

1094

1036

return

1098

1040

(value, self.start_checker))

1099

1041

self.start_checker() # Start one now, too

1100

1042

1101

# Checker - property

1043

# checker - property

1102

1044

@dbus_service_property(_interface, signature=u"s",

1103

1045

access=u"readwrite")

1104

def Checker_dbus_property(self, value=None):

1046

def checker_dbus_property(self, value=None):

1105

1047

if value is None: # get

1106

1048

return dbus.String(self.checker_command)

1107

1049

self.checker_command = value

1108

1050

# Emit D-Bus signal

1109

self.PropertyChanged(dbus.String(u"Checker"),

1051

self.PropertyChanged(dbus.String(u"checker"),

1110

1052

dbus.String(self.checker_command,

1111

1053

variant_level=1))

1112

1054

1113

# CheckerRunning - property

1055

# checker_running - property

1114

1056

@dbus_service_property(_interface, signature=u"b",

1115

1057

access=u"readwrite")

1116

def CheckerRunning_dbus_property(self, value=None):

1058

def checker_running_dbus_property(self, value=None):

1117

1059

if value is None: # get

1118

1060

return dbus.Boolean(self.checker is not None)

1119

1061

if value:

1121

1063

else:

1122

1064

self.stop_checker()

1123

1065

1124

# ObjectPath - property

1066

# object_path - property

1125

1067

@dbus_service_property(_interface, signature=u"o", access=u"read")

1126

def ObjectPath_dbus_property(self):

1068

def object_path_dbus_property(self):

1127

1069

return self.dbus_object_path # is already a dbus.ObjectPath

1128

1070

1129

# Secret = property

1071

# secret = property

1130

1072

@dbus_service_property(_interface, signature=u"ay",

1131

1073

access=u"write", byte_arrays=True)

1132

def Secret_dbus_property(self, value):

1074

def secret_dbus_property(self, value):

1133

1075

self.secret = str(value)

1134

1076

1135

1077

del _interface

1233

1175

except KeyError:

1234

1176

return

1235

1177

1236

if client.approval_delay:

1237

delay = client.approval_delay

1178

if client.approved_delay:

1179

delay = client.approved_delay

1238

1180

client.approvals_pending += 1

1239

1181

approval_required = True

1240

1182

1247

1189

client.Rejected("Disabled")

1248

1190

return

1249

1191

1250

if client._approved or not client.approval_delay:

1192

if client._approved or not client.approved_delay:

1251

1193

#We are approved or approval is disabled

1252

1194

break

1253

1195

elif client._approved is None:

1254

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

1196

logger.info(u"Client %s need approval",

1255

1197

client.name)

1256

1198

if self.server.use_dbus:

1257

1199

# Emit D-Bus signal

1258

1200

client.NeedApproval(

1259

client.approval_delay_milliseconds(),

1201

client.approved_delay_milliseconds(),

1260

1202

client.approved_by_default)

1261

1203

else:

1262

1204

logger.warning(u"Client %s was not approved",

1263

1205

client.name)

1264

1206

if self.server.use_dbus:

1265

1207

# Emit D-Bus signal

1266

client.Rejected("Denied")

1208

client.Rejected("Disapproved")

1267

1209

return

1268

1210

1269

1211

#wait until timeout or approved

1280

1222

client.name)

1281

1223

if self.server.use_dbus:

1282

1224

# Emit D-Bus signal

1283

client.Rejected("Approval timed out")

1225

client.Rejected("Time out")

1284

1226

return

1285

1227

else:

1286

1228

break

1312

1254

try:

1313

1255

session.bye()

1314

1256

except (gnutls.errors.GNUTLSError), error:

1315

logger.warning("GnuTLS bye failed")

1257

logger.warning("gnutls bye failed")

1316

1258

1317

1259

@staticmethod

1318

1260

def peer_certificate(session):

1524

1466

for cond, name in

1525

1467

condition_names.iteritems()

1526

1468

if cond & condition)

1469

logger.debug(u"Handling IPC: FD = %d, condition = %s", source,

1470

conditions_string)

1471

1527

1472

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

1528

1473

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

1529

1474

return False

1530

1475

1531

1476

# Read a request from the child

1532

1477

request = parent_pipe.recv()

1478

logger.debug(u"IPC request: %s", repr(request))

1533

1479

command = request[0]

1534

1480

1535

1481

if command == 'init':

1545

1491

u"dress: %s", fpr, address)

1546

1492

if self.use_dbus:

1547

1493

# Emit D-Bus signal

1548

mandos_dbus_service.ClientNotFound(fpr, address[0])

1494

mandos_dbus_service.ClientNotFound(fpr, address)

1549

1495

parent_pipe.send(False)

1550

1496

return False

1551

1497

1684

1630

parser.add_option("--debug", action=u"store_true",

1685

1631

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

1686

1632

u" terminal")

1687

parser.add_option("--debuglevel", type=u"string", metavar="LEVEL",

1633

parser.add_option("--debuglevel", type=u"string", metavar="Level",

1688

1634

help=u"Debug level for stdout output")

1689

1635

parser.add_option("--priority", type=u"string", help=u"GnuTLS"

1690

1636

u" priority string (see GnuTLS documentation)")

1769

1715

u"interval": u"5m",

1770

1716

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

1771

1717

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1718

u"approved_delay": u"0s",

1719

u"approved_duration": u"1s",

1774

1720

}

1775

1721

client_config = configparser.SafeConfigParser(client_defaults)

1776

1722

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

1782

1728

tcp_server = MandosServer((server_settings[u"address"],

1783

1729

server_settings[u"port"]),

1784

1730

ClientHandler,

1785

interface=(server_settings[u"interface"]

1786

or None),

1731

interface=server_settings[u"interface"],

1787

1732

use_ipv6=use_ipv6,

1788

1733

gnutls_priority=

1789

1734

server_settings[u"priority"],

1790

1735

use_dbus=use_dbus)

1791

if not debug:

1792

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

1793

try:

1794

pidfile = open(pidfilename, u"w")

1795

except IOError:

1796

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

1736

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

1737

try:

1738

pidfile = open(pidfilename, u"w")

1739

except IOError:

1740

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

1797

1741

1798

1742

try:

1799

1743

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

1816

1760

if error[0] != errno.EPERM:

1817

1761

raise error

1818

1762

1763

# Enable all possible GnuTLS debugging

1764

1765

1819

1766

if not debug and not debuglevel:

1820

1767

syslogger.setLevel(logging.WARNING)

1821

1768

console.setLevel(logging.WARNING)

1825

1772

console.setLevel(level)

1826

1773

1827

1774

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1830

1775

# "Use a log level over 10 to enable all debugging options."

1831

1776

# - GnuTLS manual

1832

1777

gnutls.library.functions.gnutls_global_set_log_level(11)

1837

1782

1838

1783

(gnutls.library.functions

1839

1784

.gnutls_global_set_log_function(debug_gnutls))

1840

1785

1841

1786

# Redirect stdin so all checkers get /dev/null

1842

1787

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

1843

1788

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

1846

1791

else:

1847

1792

# No console logging

1848

1793

logger.removeHandler(console)

1849

1794

1850

1795

1851

1796

global main_loop

1852

1797

# From the Avahi example code

1901

1846

if not tcp_server.clients:

1902

1847

logger.warning(u"No clients defined")

1903

1848

1849

try:

1850

with pidfile:

1851

pid = os.getpid()

1852

pidfile.write(str(pid) + "\n")

1853

del pidfile

1854

except IOError:

1855

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

1856

pidfilename, pid)

1857

except NameError:

1858

# "pidfile" was never created

1859

pass

1860

del pidfilename

1861

1904

1862

if not debug:

1905

try:

1906

with pidfile:

1907

pid = os.getpid()

1908

pidfile.write(str(pid) + "\n")

1909

del pidfile

1910

except IOError:

1911

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

1912

pidfilename, pid)

1913

except NameError:

1914

# "pidfile" was never created

1915

pass

1916

del pidfilename

1917

1918

1863

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

1919

1920

1864

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

1921

1865

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

1922

1866