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

__author__ = "Paul Scott-Murphy"

    78

__email__ = "paul at scott dash murphy dot com"

    79

__version__ = "0.12"

    80

    81

import string

    82

import time

    83

import struct

    84

import socket

    85

import threading

    86

import select

    87

import traceback

    88

    89

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

    90

    91

# hook for threads

    92

    93

globals()['_GLOBAL_DONE'] = 0

    94

    95

# Some timing constants

    96

    97

_UNREGISTER_TIME = 125

    98

_CHECK_TIME = 175

    99

_REGISTER_TIME = 225

   100

_LISTENER_TIME = 200

   101

_BROWSER_TIME = 500

   102

   103

# Some DNS constants

   104

   105

_MDNS_ADDR = '224.0.0.251'

   106

_MDNS_PORT = 5353

   107

_DNS_PORT = 53

   108

_DNS_TTL = 60 * 60  # one hour default TTL

   109

   110

_MAX_MSG_TYPICAL = 1460  # unused

   111

_MAX_MSG_ABSOLUTE = 8972

   112

   113

_FLAGS_QR_MASK = 0x8000  # query response mask

   114

_FLAGS_QR_QUERY = 0x0000  # query

   115

_FLAGS_QR_RESPONSE = 0x8000  # response

   116

   117

_FLAGS_AA = 0x0400  # Authorative answer

   118

_FLAGS_TC = 0x0200  # Truncated

   119

_FLAGS_RD = 0x0100  # Recursion desired

   120

_FLAGS_RA = 0x8000  # Recursion available

   121

   122

_FLAGS_Z = 0x0040   # Zero

   123

_FLAGS_AD = 0x0020  # Authentic data

   124

_FLAGS_CD = 0x0010  # Checking disabled

   125

   126

_CLASS_IN = 1

   127

_CLASS_CS = 2

   128

_CLASS_CH = 3

   129

_CLASS_HS = 4

   130

_CLASS_NONE = 254

   131

_CLASS_ANY = 255

   132

_CLASS_MASK = 0x7FFF

   133

_CLASS_UNIQUE = 0x8000

   134

   135

_TYPE_A = 1

   136

_TYPE_NS = 2

   137

_TYPE_MD = 3

   138

_TYPE_MF = 4

   139

_TYPE_CNAME = 5

   140

_TYPE_SOA = 6

   141

_TYPE_MB = 7

   142

_TYPE_MG = 8

   143

_TYPE_MR = 9

   144

_TYPE_NULL = 10

   145

_TYPE_WKS = 11

   146

_TYPE_PTR = 12

   147

_TYPE_HINFO = 13

   148

_TYPE_MINFO = 14

   149

_TYPE_MX = 15

   150

_TYPE_TXT = 16

   151

_TYPE_AAAA = 28

   152

_TYPE_SRV = 33

   153

_TYPE_ANY =  255

   154

   155

# Mapping constants to names

   156

   157

_CLASSES = {

   158

    _CLASS_IN:   "in",

   159

    _CLASS_CS:   "cs",

   160

    _CLASS_CH:   "ch",

   161

    _CLASS_HS:   "hs",

   162

    _CLASS_NONE: "none",

   163

    _CLASS_ANY:  "any"

   164

}

   165

   166

_TYPES = {

   167

    _TYPE_A:     "a",

   168

    _TYPE_NS:    "ns",

   169

    _TYPE_MD:    "md",

   170

    _TYPE_MF:    "mf",

   171

    _TYPE_CNAME: "cname",

   172

    _TYPE_SOA:   "soa",

   173

    _TYPE_MB:    "mb",

   174

    _TYPE_MG:    "mg",

   175

    _TYPE_MR:    "mr",

   176

    _TYPE_NULL:  "null",

   177

    _TYPE_WKS:   "wks",

   178

    _TYPE_PTR:   "ptr",

   179

    _TYPE_HINFO: "hinfo",

   180

    _TYPE_MINFO: "minfo",

   181

    _TYPE_MX:    "mx",

   182

    _TYPE_TXT:   "txt",

   183

    _TYPE_AAAA:  "quada",

   184

    _TYPE_SRV:   "srv",

   185

    _TYPE_ANY:   "any"

   186

}

   187

   188

# utility functions

   189

   190

   191

def currentTimeMillis():

   192

    """Current system time in milliseconds"""

   193

    return time.time() * 1000

   194

   195

# Exceptions

   196

   197

   198

class NonLocalNameException(Exception):

   199

    pass

   200

   201

   202

class NonUniqueNameException(Exception):

   203

    pass

   204

   205

   206

class NamePartTooLongException(Exception):

   207

    pass

   208

   209

   210

class AbstractMethodException(Exception):

   211

    pass

   212

   213

   214

class BadTypeInNameException(Exception):

   215

    pass

   216

   217

# implementation classes

   218

   219

   220

class DNSEntry(object):

   221

    """A DNS entry"""

   222

   223

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

   224

        self.key = string.lower(name)

   225

        self.name = name

   226

        self.type = type

   227

        self.clazz = clazz & _CLASS_MASK

   228

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

   229

   230

    def __eq__(self, other):

   231

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

   232

        if isinstance(other, DNSEntry):

   233

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

   234

        return 0

   235

   236

    def __ne__(self, other):

   237

        """Non-equality test"""

   238

        return not self.__eq__(other)

   239

   240

    def getClazz(self, clazz):

   241

        """Class accessor"""

   242

        try:

   243

            return _CLASSES[clazz]

   244

        except:

   245

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

   246

   247

    def getType(self, type):

   248

        """Type accessor"""

   249

        try:

   250

            return _TYPES[type]

   251

        except:

   252

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

   253

   254

    def toString(self, hdr, other):

   255

        """String representation with additional information"""

   256

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

   257

        if self.unique:

   258

            result += "-unique,"

   259

        else:

   260

            result += ","

   261

        result += self.name

   262

        if other is not None:

   263

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

   264

        else:

   265

            result += "]"

   266

        return result

   267

   268

   269

class DNSQuestion(DNSEntry):

   270

    """A DNS question entry"""

   271

   272

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

   273

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

   274

            raise NonLocalNameException

   275

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

   276

   277

    def answeredBy(self, rec):

   278

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

   279

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

   280

   281

    def __repr__(self):

   282

        """String representation"""

   283

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

   284

   285

   286

class DNSRecord(DNSEntry):

   287

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

   288

   289

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

   290

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

   291

        self.ttl = ttl

   292

        self.created = currentTimeMillis()

   293

   294

    def __eq__(self, other):

   295

        """Tests equality as per DNSRecord"""

   296

        if isinstance(other, DNSRecord):

   297

            return DNSEntry.__eq__(self, other)

   298

        return 0

   299

   300

    def suppressedBy(self, msg):

   301

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

   302

        information held in this record."""

   303

        for record in msg.answers:

   304

            if self.suppressedByAnswer(record):

   305

                return 1

   306

        return 0

   307

   308

    def suppressedByAnswer(self, other):

   309

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

   310

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

   311

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

   312

            return 1

   313

        return 0

   314

   315

    def getExpirationTime(self, percent):

   316

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

   317

        by a certain percentage."""

   318

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

   319

   320

    def getRemainingTTL(self, now):

   321

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

   322

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

   323

   324

    def isExpired(self, now):

   325

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

   326

        return self.getExpirationTime(100) <= now

   327

   328

    def isStale(self, now):

   329

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

   330

        return self.getExpirationTime(50) <= now

   331

   332

    def resetTTL(self, other):

   333

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

   334

        another record."""

   335

        self.created = other.created

   336

        self.ttl = other.ttl

   337

   338

    def write(self, out):

   339

        """Abstract method"""

   340

        raise AbstractMethodException

   341

   342

    def toString(self, other):

   343

        """String representation with addtional information"""

   344

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

   345

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

   346

   347

   348

class DNSAddress(DNSRecord):

   349

    """A DNS address record"""

   350

   351

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

   352

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

   353

        self.address = address

   354

   355

    def write(self, out):

   356

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

   357

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

   358

   359

    def __eq__(self, other):

   360

        """Tests equality on address"""

   361

        if isinstance(other, DNSAddress):

   362

            return self.address == other.address

   363

        return 0

   364

   365

    def __repr__(self):

   366

        """String representation"""

   367

        try:

   368

            return socket.inet_ntoa(self.address)

   369

        except:

   370

            return self.address

   371

   372

   373

class DNSHinfo(DNSRecord):

   374

    """A DNS host information record"""

   375

   376

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

   377

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

   378

        self.cpu = cpu

   379

        self.os = os

   380

   381

    def write(self, out):

   382

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

   383

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

   384

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

   385

   386

    def __eq__(self, other):

   387

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

   388

        if isinstance(other, DNSHinfo):

   389

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

   390

        return 0

   391

   392

    def __repr__(self):

   393

        """String representation"""

   394

        return self.cpu + " " + self.os

   395

   396

   397

class DNSPointer(DNSRecord):

   398

    """A DNS pointer record"""

   399

   400

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

   401

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

   402

        self.alias = alias

   403

   404

    def write(self, out):

   405

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

   406

        out.writeName(self.alias)

   407

   408

    def __eq__(self, other):

   409

        """Tests equality on alias"""

   410

        if isinstance(other, DNSPointer):

   411

            return self.alias == other.alias

   412

        return 0

   413

   414

    def __repr__(self):

   415

        """String representation"""

   416

        return self.toString(self.alias)

   417

   418

   419

class DNSText(DNSRecord):

   420

    """A DNS text record"""

   421

   422

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

   423

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

   424

        self.text = text

   425

   426

    def write(self, out):

   427

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

   428

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

   429

   430

    def __eq__(self, other):

   431

        """Tests equality on text"""

   432

        if isinstance(other, DNSText):

   433

            return self.text == other.text

   434

        return 0

   435

   436

    def __repr__(self):

   437

        """String representation"""

   438

        if len(self.text) > 10:

   439

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

   440

        else:

   441

            return self.toString(self.text)

   442

   443

   444

class DNSService(DNSRecord):

   445

    """A DNS service record"""

   446

   447

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

   448

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

   449

        self.priority = priority

   450

        self.weight = weight

   451

        self.port = port

   452

        self.server = server

   453

   454

    def write(self, out):

   455

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

   456

        out.writeShort(self.priority)

   457

        out.writeShort(self.weight)

   458

        out.writeShort(self.port)

   459

        out.writeName(self.server)

   460

   461

    def __eq__(self, other):

   462

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

   463

        if isinstance(other, DNSService):

   464

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

   465

        return 0

   466

   467

    def __repr__(self):

   468

        """String representation"""

   469

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

   470

   471

   472

class DNSIncoming(object):

   473

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

   474

   475

    def __init__(self, data):

   476

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

   477

        self.offset = 0

   478

        self.data = data

   479

        self.questions = []

   480

        self.answers = []

   481

        self.numQuestions = 0

   482

        self.numAnswers = 0

   483

        self.numAuthorities = 0

   484

        self.numAdditionals = 0

   485

   486

        self.readHeader()

   487

        self.readQuestions()

   488

        self.readOthers()

   489

   490

    def readHeader(self):

   491

        """Reads header portion of packet"""

   492

        format = '!HHHHHH'

   493

        length = struct.calcsize(format)

   494

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

   495

        self.offset += length

   496

   497

        self.id = info[0]

   498

        self.flags = info[1]

   499

        self.numQuestions = info[2]