/mandos/trunk : revision 460

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.0.14"

84

version = "1.2.3"

85

86

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

87

logger = logging.Logger(u'mandos')

240

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

241

242

Attributes:

243

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

244

D-Bus identifiers

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

246

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

247

to see if the client lives.

248

'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

252

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

253

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

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

245

260

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

246

261

uniquely identify the client

247

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

248

262

host: string; available for use by the checker command

249

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

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

250

266

last_enabled: datetime.datetime(); (UTC)

251

enabled: bool()

252

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

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

253

270

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

254

271

until this client is disabled

255

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

256

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

257

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

258

to see if the client lives.

259

'None' if no process is running.

260

checker_initiator_tag: a gobject event source tag, or None

261

disable_initiator_tag: - '' -

262

checker_callback_tag: - '' -

263

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

264

client lives. %() expansions are done at

265

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

266

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

267

current_checker_command: string; current running checker_command

268

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

269

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

270

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

272

runtime_expansions: Allowed attributes for runtime expansion.

271

273

"""

272

274

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

273

280

@staticmethod

274

281

def _timedelta_to_milliseconds(td):

275

282

"Convert a datetime.timedelta() to milliseconds"

285

292

"Return the 'interval' attribute in milliseconds"

286

293

return self._timedelta_to_milliseconds(self.interval)

287

294

288

def approved_delay_milliseconds(self):

289

return self._timedelta_to_milliseconds(self.approved_delay)

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

290

297

291

298

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

292

299

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

315

322

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

316

323

self.created = datetime.datetime.utcnow()

317

324

self.enabled = False

325

self.last_approval_request = None

318

326

self.last_enabled = None

319

327

self.last_checked_ok = None

320

328

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

331

339

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

332

340

True)

333

341

self.approvals_pending = 0

334

self.approved_delay = string_to_delta(

335

config[u"approved_delay"])

336

self.approved_duration = string_to_delta(

337

config[u"approved_duration"])

342

self.approval_delay = string_to_delta(

343

config[u"approval_delay"])

344

self.approval_duration = string_to_delta(

345

config[u"approval_duration"])

338

346

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

339

347

340

348

def send_changedstate(self):

416

424

(self.timeout_milliseconds(),

417

425

self.disable))

418

426

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

419

430

def start_checker(self):

420

431

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

421

432

450

461

command = self.checker_command % self.host

451

462

except TypeError:

452

463

# Escape attributes for the shell

453

escaped_attrs = dict((key,

454

re.escape(unicode(str(val),

455

errors=

456

u'replace')))

457

for key, val in

458

vars(self).iteritems())

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

459

472

try:

460

473

command = self.checker_command % escaped_attrs

461

474

except TypeError, error:

703

716

dbus_object_path: dbus.ObjectPath

704

717

bus: dbus.SystemBus()

705

718

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

706

723

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

707

724

708

725

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

711

728

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

712

729

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

713

730

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

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

733

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

714

734

self.dbus_object_path = (dbus.ObjectPath

715

(u"/clients/"

716

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

735

(u"/clients/" + client_object_name))

717

736

DBusObjectWithProperties.__init__(self, self.bus,

718

737

self.dbus_object_path)

719

738

720

739

def _get_approvals_pending(self):

721

740

return self._approvals_pending

722

741

def _set_approvals_pending(self, value):

726

745

if (hasattr(self, "dbus_object_path")

727

746

and bval is not bool(old_value)):

728

747

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

729

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

748

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

730

749

dbus_bool)

731

750

732

751

approvals_pending = property(_get_approvals_pending,

744

763

r = Client.enable(self)

745

764

if oldstate != self.enabled:

746

765

# Emit D-Bus signals

747

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

766

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

748

767

dbus.Boolean(True, variant_level=1))

749

768

self.PropertyChanged(

750

dbus.String(u"last_enabled"),

769

dbus.String(u"LastEnabled"),

751

770

self._datetime_to_dbus(self.last_enabled,

752

771

variant_level=1))

753

772

return r

757

776

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

758

777

if not quiet and oldstate != self.enabled:

759

778

# Emit D-Bus signal

760

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

779

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

761

780

dbus.Boolean(False, variant_level=1))

762

781

return r

763

782

775

794

self.checker_callback_tag = None

776

795

self.checker = None

777

796

# Emit D-Bus signal

778

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

797

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

779

798

dbus.Boolean(False, variant_level=1))

780

799

if os.WIFEXITED(condition):

781

800

exitstatus = os.WEXITSTATUS(condition)

796

815

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

797

816

# Emit D-Bus signal

798

817

self.PropertyChanged(

799

dbus.String(u"last_checked_ok"),

818

dbus.String(u"LastCheckedOK"),

800

819

(self._datetime_to_dbus(self.last_checked_ok,

801

820

variant_level=1)))

802

821

return r

803

822

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

804

832

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

805

833

old_checker = self.checker

806

834

if self.checker is not None:

814

842

# Emit D-Bus signal

815

843

self.CheckerStarted(self.current_checker_command)

816

844

self.PropertyChanged(

817

dbus.String(u"checker_running"),

845

dbus.String(u"CheckerRunning"),

818

846

dbus.Boolean(True, variant_level=1))

819

847

return r

820

848

823

851

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

824

852

if (old_checker is not None

825

853

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

826

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

854

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

827

855

dbus.Boolean(False, variant_level=1))

828

856

return r

829

857

834

862

def approve(self, value=True):

835

863

self.send_changedstate()

836

864

self._approved = value

837

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

865

gobject.timeout_add(self._timedelta_to_milliseconds

866

(self.approval_duration),

838

867

self._reset_approved)

839

868

840

869

877

906

pass

878

907

879

908

# NeedApproval - signal

880

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

909

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

881

910

def NeedApproval(self, timeout, default):

882

911

"D-Bus signal"

883

pass

912

return self.need_approval()

884

913

885

914

## Methods

886

915

887

916

# Approve - method

888

917

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

889

918

def Approve(self, value):

890

919

self.approve(value)

891

920

892

921

# CheckedOK - method

893

922

@dbus.service.method(_interface)

894

923

def CheckedOK(self):

919

948

920

949

## Properties

921

950

922

# approved_pending - property

951

# ApprovalPending - property

923

952

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

924

def approved_pending_dbus_property(self):

953

def ApprovalPending_dbus_property(self):

925

954

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

926

955

927

# approved_by_default - property

956

# ApprovedByDefault - property

928

957

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

929

958

access=u"readwrite")

930

def approved_by_default_dbus_property(self):

931

return dbus.Boolean(self.approved_by_default)

932

933

# approved_delay - property

934

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

935

access=u"readwrite")

936

def approved_delay_dbus_property(self):

937

return dbus.UInt64(self.approved_delay_milliseconds())

938

939

# approved_duration - property

940

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

941

access=u"readwrite")

942

def approved_duration_dbus_property(self):

943

return dbus.UInt64(self._timedelta_to_milliseconds(

944

self.approved_duration))

945

946

# name - property

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

947

991

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

948

def name_dbus_property(self):

992

def Name_dbus_property(self):

949

993

return dbus.String(self.name)

950

994

951

# fingerprint - property

995

# Fingerprint - property

952

996

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

953

def fingerprint_dbus_property(self):

997

def Fingerprint_dbus_property(self):

954

998

return dbus.String(self.fingerprint)

955

999

956

# host - property

1000

# Host - property

957

1001

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

958

1002

access=u"readwrite")

959

def host_dbus_property(self, value=None):

1003

def Host_dbus_property(self, value=None):

960

1004

if value is None: # get

961

1005

return dbus.String(self.host)

962

1006

self.host = value

963

1007

# Emit D-Bus signal

964

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

1008

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

965

1009

dbus.String(value, variant_level=1))

966

1010

967

# created - property

1011

# Created - property

968

1012

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

969

def created_dbus_property(self):

1013

def Created_dbus_property(self):

970

1014

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

971

1015

972

# last_enabled - property

1016

# LastEnabled - property

973

1017

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

974

def last_enabled_dbus_property(self):

1018

def LastEnabled_dbus_property(self):

975

1019

if self.last_enabled is None:

976

1020

return dbus.String(u"")

977

1021

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

978

1022

979

# enabled - property

1023

# Enabled - property

980

1024

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

981

1025

access=u"readwrite")

982

def enabled_dbus_property(self, value=None):

1026

def Enabled_dbus_property(self, value=None):

983

1027

if value is None: # get

984

1028

return dbus.Boolean(self.enabled)

985

1029

if value:

987

1031

else:

988

1032

self.disable()

989

1033

990

# last_checked_ok - property

1034

# LastCheckedOK - property

991

1035

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

992

1036

access=u"readwrite")

993

def last_checked_ok_dbus_property(self, value=None):

1037

def LastCheckedOK_dbus_property(self, value=None):

994

1038

if value is not None:

995

1039

self.checked_ok()

996

1040

return

999

1043

return dbus.String(self._datetime_to_dbus(self

1000

1044

.last_checked_ok))

1001

1045

1002

# timeout - property

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

1003

1056

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

1004

1057

access=u"readwrite")

1005

def timeout_dbus_property(self, value=None):

1058

def Timeout_dbus_property(self, value=None):

1006

1059

if value is None: # get

1007

1060

return dbus.UInt64(self.timeout_milliseconds())

1008

1061

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

1009

1062

# Emit D-Bus signal

1010

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

1063

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

1011

1064

dbus.UInt64(value, variant_level=1))

1012

1065

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

1013

1066

return

1027

1080

self.disable_initiator_tag = (gobject.timeout_add

1028

1081

(time_to_die, self.disable))

1029

1082

1030

# interval - property

1083

# Interval - property

1031

1084

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

1032

1085

access=u"readwrite")

1033

def interval_dbus_property(self, value=None):

1086

def Interval_dbus_property(self, value=None):

1034

1087

if value is None: # get

1035

1088

return dbus.UInt64(self.interval_milliseconds())

1036

1089

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

1037

1090

# Emit D-Bus signal

1038

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

1091

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

1039

1092

dbus.UInt64(value, variant_level=1))

1040

1093

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

1041

1094

return

1045

1098

(value, self.start_checker))

1046

1099

self.start_checker() # Start one now, too

1047

1100

1048

# checker - property

1101

# Checker - property

1049

1102

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

1050

1103

access=u"readwrite")

1051

def checker_dbus_property(self, value=None):

1104

def Checker_dbus_property(self, value=None):

1052

1105

if value is None: # get

1053

1106

return dbus.String(self.checker_command)

1054

1107

self.checker_command = value

1055

1108

# Emit D-Bus signal

1056

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

1109

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

1057

1110

dbus.String(self.checker_command,

1058

1111

variant_level=1))

1059

1112

1060

# checker_running - property

1113

# CheckerRunning - property

1061

1114

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

1062

1115

access=u"readwrite")

1063

def checker_running_dbus_property(self, value=None):

1116

def CheckerRunning_dbus_property(self, value=None):

1064

1117

if value is None: # get

1065

1118

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

1066

1119

if value:

1068

1121

else:

1069

1122

self.stop_checker()

1070

1123

1071

# object_path - property

1124

# ObjectPath - property

1072

1125

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

1073

def object_path_dbus_property(self):

1126

def ObjectPath_dbus_property(self):

1074

1127

return self.dbus_object_path # is already a dbus.ObjectPath

1075

1128

1076

# secret = property

1129

# Secret = property

1077

1130

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

1078

1131

access=u"write", byte_arrays=True)

1079

def secret_dbus_property(self, value):

1132

def Secret_dbus_property(self, value):

1080

1133

self.secret = str(value)

1081

1134

1082

1135

del _interface

1180

1233

except KeyError:

1181

1234

return

1182

1235

1183

if client.approved_delay:

1184

delay = client.approved_delay

1236

if client.approval_delay:

1237

delay = client.approval_delay

1185

1238

client.approvals_pending += 1

1186

1239

approval_required = True

1187

1240

1194

1247

client.Rejected("Disabled")

1195

1248

return

1196

1249

1197

if client._approved or not client.approved_delay:

1250

if client._approved or not client.approval_delay:

1198

1251

#We are approved or approval is disabled

1199

1252

break

1200

1253

elif client._approved is None:

1201

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

1254

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

1202

1255

client.name)

1203

1256

if self.server.use_dbus:

1204

1257

# Emit D-Bus signal

1205

1258

client.NeedApproval(

1206

client.approved_delay_milliseconds(),

1259

client.approval_delay_milliseconds(),

1207

1260

client.approved_by_default)

1208

1261

else:

1209

1262

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

1210

1263

client.name)

1211

1264

if self.server.use_dbus:

1212

1265

# Emit D-Bus signal

1213

client.Rejected("Disapproved")

1266

client.Rejected("Denied")

1214

1267

return

1215

1268

1216

1269

#wait until timeout or approved

1227

1280

client.name)

1228

1281

if self.server.use_dbus:

1229

1282

# Emit D-Bus signal

1230

client.Rejected("Time out")

1283

client.Rejected("Approval timed out")

1231

1284

return

1232

1285

else:

1233

1286

break

1259

1312

try:

1260

1313

session.bye()

1261

1314

except (gnutls.errors.GNUTLSError), error:

1262

logger.warning("gnutls bye failed")

1315

logger.warning("GnuTLS bye failed")

1263

1316

1264

1317

@staticmethod

1265

1318

def peer_certificate(session):

1471

1524

for cond, name in

1472

1525

condition_names.iteritems()

1473

1526

if cond & condition)

1474

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

1475

conditions_string)

1476

1477

1527

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

1478

1528

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

1479

1529

return False

1480

1530

1481

1531

# Read a request from the child

1482

1532

request = parent_pipe.recv()

1483

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

1484

1533

command = request[0]

1485

1534

1486

1535

if command == 'init':

1496

1545

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

1497

1546

if self.use_dbus:

1498

1547

# Emit D-Bus signal

1499

mandos_dbus_service.ClientNotFound(fpr, address)

1548

mandos_dbus_service.ClientNotFound(fpr, address[0])

1500

1549

parent_pipe.send(False)

1501

1550

return False

1502

1551

1635

1684

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

1636

1685

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

1637

1686

u" terminal")

1638

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

1687

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

1639

1688

help=u"Debug level for stdout output")

1640

1689

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

1641

1690

u" priority string (see GnuTLS documentation)")

1720

1769

u"interval": u"5m",

1721

1770

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

1722

1771

u"host": u"",

1723

u"approved_delay": u"0s",

1724

u"approved_duration": u"1s",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1725

1774

}

1726

1775

client_config = configparser.SafeConfigParser(client_defaults)

1727

1776

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

1733

1782

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

1734

1783

server_settings[u"port"]),

1735

1784

ClientHandler,

1736

interface=server_settings[u"interface"],

1785

interface=(server_settings[u"interface"]

1786

or None),

1737

1787

use_ipv6=use_ipv6,

1738

1788

gnutls_priority=

1739

1789

server_settings[u"priority"],

1740

1790

use_dbus=use_dbus)

1741

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

1742

try:

1743

pidfile = open(pidfilename, u"w")

1744

except IOError:

1745

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

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)

1746

1797

1747

1798

try:

1748

1799

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

1765

1816

if error[0] != errno.EPERM:

1766

1817

raise error

1767

1818

1768

# Enable all possible GnuTLS debugging

1769

1770

1771

1819

if not debug and not debuglevel:

1772

1820

syslogger.setLevel(logging.WARNING)

1773

1821

console.setLevel(logging.WARNING)

1777

1825

console.setLevel(level)

1778

1826

1779

1827

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1780

1830

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

1781

1831

# - GnuTLS manual

1782

1832

gnutls.library.functions.gnutls_global_set_log_level(11)

1787

1837

1788

1838

(gnutls.library.functions

1789

1839

.gnutls_global_set_log_function(debug_gnutls))

1790

1840

1791

1841

# Redirect stdin so all checkers get /dev/null

1792

1842

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

1793

1843

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

1796

1846

else:

1797

1847

# No console logging

1798

1848

logger.removeHandler(console)

1799

1849

1850

# Need to fork before connecting to D-Bus

1851

if not debug:

1852

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

1853

daemon()

1800

1854

1801

1855

global main_loop

1802

1856

# From the Avahi example code

1820

1874

if server_settings["interface"]:

1821

1875

service.interface = (if_nametoindex

1822

1876

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

1823

1824

if not debug:

1825

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

1826

daemon()

1827

1877

1828

1878

global multiprocessing_manager

1829

1879

multiprocessing_manager = multiprocessing.Manager()

1830

1880

1851

1901

if not tcp_server.clients:

1852

1902

logger.warning(u"No clients defined")

1853

1903

1854

try:

1855

with pidfile:

1856

pid = os.getpid()

1857

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

1858

del pidfile

1859

except IOError:

1860

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

1861

pidfilename, pid)

1862

except NameError:

1863

# "pidfile" was never created

1864

pass

1865

del pidfilename

1866

1867

1904

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

1868

1918

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

1919

1869

1920

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

1870

1921

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

1871

1922