1

#  Multicast DNS Service Discovery for Python, v0.12

     2

#     Copyright (C) 2003, Paul Scott-Murphy

     3

#

     4

#     This module provides a framework for the use of DNS Service Discovery

     5

#     using IP multicast.  It has been tested against the JRendezvous

     6

#     implementation from <a href="http://strangeberry.com">StrangeBerry</a>,

     7

#     and against the mDNSResponder from Mac OS X 10.3.8.

     8

     9

#     This library is free software; you can redistribute it and/or

    10

#     modify it under the terms of the GNU Lesser General Public

    11

#     License as published by the Free Software Foundation; either

    12

#     version 2.1 of the License, or (at your option) any later version.

    13

    14

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

    15

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

    16

#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

    17

#     Lesser General Public License for more details.

    18

    19

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

    20

#     License along with this library; if not, write to the Free Software

    21

#     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

    22

#

    23

#

    24

#

    25

# 0.12 update - allow selection of binding interface

    26

#          typo fix - Thanks A. M. Kuchlingi

    27

#          removed all use of word 'Rendezvous' - this is an API change

    28

#

    29

# 0.11 update - correction to comments for addListener method

    30

#                  support for new record types seen from OS X

    31

#                   - IPv6 address

    32

#                   - hostinfo

    33

#                  ignore unknown DNS record types

    34

#                  fixes to name decoding

    35

#                  works alongside other processes using port 5353 (e.g. on Mac OS X)

    36

#                  tested against Mac OS X 10.3.2's mDNSResponder

    37

#                  corrections to removal of list entries for service browser

    38

#

    39

# 0.10 update - Jonathon Paisley contributed these corrections:

    40

#                  always multicast replies, even when query is unicast

    41

#                  correct a pointer encoding problem

    42

#                  can now write records in any order

    43

#                  traceback shown on failure

    44

#                  better TXT record parsing

    45

#                  server is now separate from name

    46

#                  can cancel a service browser

    47

#

    48

#                  modified some unit tests to accommodate these changes

    49

#

    50

# 0.09 update - remove all records on service unregistration

    51

#                  fix DOS security problem with readName

    52

#

    53

# 0.08 update - changed licensing to LGPL

    54

#

    55

# 0.07 update - faster shutdown on engine

    56

#                  pointer encoding of outgoing names

    57

#                  ServiceBrowser now works

    58

#                  new unit tests

    59

#

    60

# 0.06 update - small improvements with unit tests

    61

#                  added defined exception types

    62

#                  new style objects

    63

#                  fixed hostname/interface problem

    64

#                  fixed socket timeout problem

    65

#                  fixed addServiceListener() typo bug

    66

#                  using select() for socket reads

    67

#                  tested on Debian unstable with Python 2.2.2

    68

#

    69

# 0.05 update - ensure case insensitivty on domain names

    70

#                  support for unicast DNS queries

    71

#

    72

# 0.04 update - added some unit tests

    73

#                  added __ne__ adjuncts where required

    74

#                  ensure names end in '.local.'

    75

#                  timeout on receiving socket for clean shutdown

    76

    77

import string

    78

import time

    79

import struct

    80

import socket

    81

import threading

    82

import select

    83

import traceback

    84

    85

    86

__author__ = "Paul Scott-Murphy"

    87

__email__ = "paul at scott dash murphy dot com"

    88

__version__ = "0.12"

    89

    90

    91

__all__ = ["Zeroconf", "ServiceInfo", "ServiceBrowser"]

    92

    93

# hook for threads

    94

    95

globals()['_GLOBAL_DONE'] = 0

    96

    97

# Some timing constants

    98

    99

_UNREGISTER_TIME = 125

   100

_CHECK_TIME = 175

   101

_REGISTER_TIME = 225

   102

_LISTENER_TIME = 200

   103

_BROWSER_TIME = 500

   104

   105

# Some DNS constants

   106

   107

_MDNS_ADDR = '224.0.0.251'

   108

_MDNS_PORT = 5353

   109

_DNS_PORT = 53

   110

_DNS_TTL = 60 * 60  # one hour default TTL

   111

   112

_MAX_MSG_TYPICAL = 1460  # unused

   113

_MAX_MSG_ABSOLUTE = 8972

   114

   115

_FLAGS_QR_MASK = 0x8000  # query response mask

   116

_FLAGS_QR_QUERY = 0x0000  # query

   117

_FLAGS_QR_RESPONSE = 0x8000  # response

   118

   119

_FLAGS_AA = 0x0400  # Authorative answer

   120

_FLAGS_TC = 0x0200  # Truncated

   121

_FLAGS_RD = 0x0100  # Recursion desired

   122

_FLAGS_RA = 0x8000  # Recursion available

   123

   124

_FLAGS_Z = 0x0040   # Zero

   125

_FLAGS_AD = 0x0020  # Authentic data

   126

_FLAGS_CD = 0x0010  # Checking disabled

   127

   128

_CLASS_IN = 1

   129

_CLASS_CS = 2

   130

_CLASS_CH = 3

   131

_CLASS_HS = 4

   132

_CLASS_NONE = 254

   133

_CLASS_ANY = 255

   134

_CLASS_MASK = 0x7FFF

   135

_CLASS_UNIQUE = 0x8000

   136

   137

_TYPE_A = 1

   138

_TYPE_NS = 2

   139

_TYPE_MD = 3

   140

_TYPE_MF = 4

   141

_TYPE_CNAME = 5

   142

_TYPE_SOA = 6

   143

_TYPE_MB = 7

   144

_TYPE_MG = 8

   145

_TYPE_MR = 9

   146

_TYPE_NULL = 10

   147

_TYPE_WKS = 11

   148

_TYPE_PTR = 12

   149

_TYPE_HINFO = 13

   150

_TYPE_MINFO = 14

   151

_TYPE_MX = 15

   152

_TYPE_TXT = 16

   153

_TYPE_AAAA = 28

   154

_TYPE_SRV = 33

   155

_TYPE_ANY = 255

   156

   157

# Mapping constants to names

   158

   159

_CLASSES = {

   160

    _CLASS_IN:   "in",

   161

    _CLASS_CS:   "cs",

   162

    _CLASS_CH:   "ch",

   163

    _CLASS_HS:   "hs",

   164

    _CLASS_NONE: "none",

   165

    _CLASS_ANY:  "any"

   166

}

   167

   168

_TYPES = {

   169

    _TYPE_A:     "a",

   170

    _TYPE_NS:    "ns",

   171

    _TYPE_MD:    "md",

   172

    _TYPE_MF:    "mf",

   173

    _TYPE_CNAME: "cname",

   174

    _TYPE_SOA:   "soa",

   175

    _TYPE_MB:    "mb",

   176

    _TYPE_MG:    "mg",

   177

    _TYPE_MR:    "mr",

   178

    _TYPE_NULL:  "null",

   179

    _TYPE_WKS:   "wks",

   180

    _TYPE_PTR:   "ptr",

   181

    _TYPE_HINFO: "hinfo",

   182

    _TYPE_MINFO: "minfo",

   183

    _TYPE_MX:    "mx",

   184

    _TYPE_TXT:   "txt",

   185

    _TYPE_AAAA:  "quada",

   186

    _TYPE_SRV:   "srv",

   187

    _TYPE_ANY:   "any"

   188

}

   189

   190

# utility functions

   191

   192

   193

def currentTimeMillis():

   194

    """Current system time in milliseconds"""

   195

    return time.time() * 1000

   196

   197

# Exceptions

   198

   199

   200

class NonLocalNameException(Exception):

   201

    pass

   202

   203

   204

class NonUniqueNameException(Exception):

   205

    pass

   206

   207

   208

class NamePartTooLongException(Exception):

   209

    pass

   210

   211

   212

class AbstractMethodException(Exception):

   213

    pass

   214

   215

   216

class BadTypeInNameException(Exception):

   217

    pass

   218

   219

# implementation classes

   220

   221

   222

class DNSEntry(object):

   223

    """A DNS entry"""

   224

   225

    def __init__(self, name, type, clazz):

   226

        self.key = string.lower(name)

   227

        self.name = name

   228

        self.type = type

   229

        self.clazz = clazz & _CLASS_MASK

   230

        self.unique = (clazz & _CLASS_UNIQUE) != 0

   231

   232

    def __eq__(self, other):

   233

        """Equality test on name, type, and class"""

   234

        if isinstance(other, DNSEntry):

   235

            return self.name == other.name and self.type == other.type and self.clazz == other.clazz

   236

        return 0

   237

   238

    def __ne__(self, other):

   239

        """Non-equality test"""

   240

        return not self.__eq__(other)

   241

   242

    def getClazz(self, clazz):

   243

        """Class accessor"""

   244

        try:

   245

            return _CLASSES[clazz]

   246

        except Exception:

   247

            return "?(%s)" % (clazz)

   248

   249

    def getType(self, type):

   250

        """Type accessor"""

   251

        try:

   252

            return _TYPES[type]

   253

        except Exception:

   254

            return "?(%s)" % (type)

   255

   256

    def toString(self, hdr, other):

   257

        """String representation with additional information"""

   258

        result = "%s[%s,%s" % (hdr, self.getType(self.type), self.getClazz(self.clazz))

   259

        if self.unique:

   260

            result += "-unique,"

   261

        else:

   262

            result += ","

   263

        result += self.name

   264

        if other is not None:

   265

            result += ",%s]" % (other)

   266

        else:

   267

            result += "]"

   268

        return result

   269

   270

   271

class DNSQuestion(DNSEntry):

   272

    """A DNS question entry"""

   273

   274

    def __init__(self, name, type, clazz):

   275

        if not name.endswith(".local."):

   276

            raise NonLocalNameException

   277

        DNSEntry.__init__(self, name, type, clazz)

   278

   279

    def answeredBy(self, rec):

   280

        """Returns true if the question is answered by the record"""

   281

        return self.clazz == rec.clazz and (self.type == rec.type or self.type == _TYPE_ANY) and self.name == rec.name

   282

   283

    def __repr__(self):

   284

        """String representation"""

   285

        return DNSEntry.toString(self, "question", None)

   286

   287

   288

class DNSRecord(DNSEntry):

   289

    """A DNS record - like a DNS entry, but has a TTL"""

   290

   291

    def __init__(self, name, type, clazz, ttl):

   292

        DNSEntry.__init__(self, name, type, clazz)

   293

        self.ttl = ttl

   294

        self.created = currentTimeMillis()

   295

   296

    def __eq__(self, other):

   297

        """Tests equality as per DNSRecord"""

   298

        if isinstance(other, DNSRecord):

   299

            return DNSEntry.__eq__(self, other)

   300

        return 0

   301

   302

    def suppressedBy(self, msg):

   303

        """Returns true if any answer in a message can suffice for the

   304

        information held in this record."""

   305

        for record in msg.answers:

   306

            if self.suppressedByAnswer(record):

   307

                return 1

   308

        return 0

   309

   310

    def suppressedByAnswer(self, other):

   311

        """Returns true if another record has same name, type and class,

   312

        and if its TTL is at least half of this record's."""

   313

        if self == other and other.ttl > (self.ttl / 2):

   314

            return 1

   315

        return 0

   316

   317

    def getExpirationTime(self, percent):

   318

        """Returns the time at which this record will have expired

   319

        by a certain percentage."""

   320

        return self.created + (percent * self.ttl * 10)

   321

   322

    def getRemainingTTL(self, now):

   323

        """Returns the remaining TTL in seconds."""

   324

        return max(0, (self.getExpirationTime(100) - now) / 1000)

   325

   326

    def isExpired(self, now):

   327

        """Returns true if this record has expired."""

   328

        return self.getExpirationTime(100) <= now

   329

   330

    def isStale(self, now):

   331

        """Returns true if this record is at least half way expired."""

   332

        return self.getExpirationTime(50) <= now

   333

   334

    def resetTTL(self, other):

   335

        """Sets this record's TTL and created time to that of

   336

        another record."""

   337

        self.created = other.created

   338

        self.ttl = other.ttl

   339

   340

    def write(self, out):

   341

        """Abstract method"""

   342

        raise AbstractMethodException

   343

   344

    def toString(self, other):

   345

        """String representation with addtional information"""

   346

        arg = "%s/%s,%s" % (self.ttl, self.getRemainingTTL(currentTimeMillis()), other)

   347

        return DNSEntry.toString(self, "record", arg)

   348

   349

   350

class DNSAddress(DNSRecord):

   351

    """A DNS address record"""

   352

   353

    def __init__(self, name, type, clazz, ttl, address):

   354

        DNSRecord.__init__(self, name, type, clazz, ttl)

   355

        self.address = address

   356

   357

    def write(self, out):

   358

        """Used in constructing an outgoing packet"""

   359

        out.writeString(self.address, len(self.address))

   360

   361

    def __eq__(self, other):

   362

        """Tests equality on address"""

   363

        if isinstance(other, DNSAddress):

   364

            return self.address == other.address

   365

        return 0

   366

   367

    def __repr__(self):

   368

        """String representation"""

   369

        try:

   370

            return socket.inet_ntoa(self.address)

   371

        except Exception:

   372

            return self.address

   373

   374

   375

class DNSHinfo(DNSRecord):

   376

    """A DNS host information record"""

   377

   378

    def __init__(self, name, type, clazz, ttl, cpu, os):

   379

        DNSRecord.__init__(self, name, type, clazz, ttl)

   380

        self.cpu = cpu

   381

        self.os = os

   382

   383

    def write(self, out):

   384

        """Used in constructing an outgoing packet"""

   385

        out.writeString(self.cpu, len(self.cpu))

   386

        out.writeString(self.os, len(self.os))

   387

   388

    def __eq__(self, other):

   389

        """Tests equality on cpu and os"""

   390

        if isinstance(other, DNSHinfo):

   391

            return self.cpu == other.cpu and self.os == other.os

   392

        return 0

   393

   394

    def __repr__(self):

   395

        """String representation"""

   396

        return self.cpu + " " + self.os

   397

   398

   399

class DNSPointer(DNSRecord):

   400

    """A DNS pointer record"""

   401

   402

    def __init__(self, name, type, clazz, ttl, alias):

   403

        DNSRecord.__init__(self, name, type, clazz, ttl)

   404

        self.alias = alias

   405

   406

    def write(self, out):

   407

        """Used in constructing an outgoing packet"""

   408

        out.writeName(self.alias)

   409

   410

    def __eq__(self, other):

   411

        """Tests equality on alias"""

   412

        if isinstance(other, DNSPointer):

   413

            return self.alias == other.alias

   414

        return 0

   415

   416

    def __repr__(self):

   417

        """String representation"""

   418

        return self.toString(self.alias)

   419

   420

   421

class DNSText(DNSRecord):

   422

    """A DNS text record"""

   423

   424

    def __init__(self, name, type, clazz, ttl, text):

   425

        DNSRecord.__init__(self, name, type, clazz, ttl)

   426

        self.text = text

   427

   428

    def write(self, out):

   429

        """Used in constructing an outgoing packet"""

   430

        out.writeString(self.text, len(self.text))

   431

   432

    def __eq__(self, other):

   433

        """Tests equality on text"""

   434

        if isinstance(other, DNSText):

   435

            return self.text == other.text

   436

        return 0

   437

   438

    def __repr__(self):

   439

        """String representation"""

   440

        if len(self.text) > 10:

   441

            return self.toString(self.text[:7] + "...")

   442

        else:

   443

            return self.toString(self.text)

   444

   445

   446

class DNSService(DNSRecord):

   447

    """A DNS service record"""

   448

   449

    def __init__(self, name, type, clazz, ttl, priority, weight, port, server):

   450

        DNSRecord.__init__(self, name, type, clazz, ttl)

   451

        self.priority = priority

   452

        self.weight = weight

   453

        self.port = port

   454

        self.server = server

   455

   456

    def write(self, out):

   457

        """Used in constructing an outgoing packet"""

   458

        out.writeShort(self.priority)

   459

        out.writeShort(self.weight)

   460

        out.writeShort(self.port)

   461

        out.writeName(self.server)

   462

   463

    def __eq__(self, other):

   464

        """Tests equality on priority, weight, port and server"""

   465

        if isinstance(other, DNSService):

   466

            return self.priority == other.priority and self.weight == other.weight and self.port == other.port and self.server == other.server

   467

        return 0

   468

   469

    def __repr__(self):

   470

        """String representation"""

   471

        return self.toString("%s:%s" % (self.server, self.port))

   472

   473

   474

class DNSIncoming(object):

   475

    """Object representation of an incoming DNS packet"""

   476

   477

    def __init__(self, data):

   478

        """Constructor from string holding bytes of packet"""

   479

        self.offset = 0

   480

        self.data = data

   481

        self.questions = []

   482

        self.answers = []

   483

        self.numQuestions = 0

   484

        self.numAnswers = 0

   485

        self.numAuthorities = 0

   486

        self.numAdditionals = 0

   487

   488

        self.readHeader()

   489

        self.readQuestions()

   490

        self.readOthers()

   491

   492

    def readHeader(self):

   493

        """Reads header portion of packet"""

   494

        format = '!HHHHHH'

   495

        length = struct.calcsize(format)

   496

        info = struct.unpack(format, self.data[self.offset:self.offset+length])