xmpp.transports

Package xmpp :: Module transports |
[hide private]
[frames] | no frames]

# Source Code for Module xmpp.transports

      1  ##   transports.py
      2  ##
      3  ##   Copyright (C) 2003-2004 Alexey "Snake" Nezhdanov
      4  ##
      5  ##   This program is free software; you can redistribute it and/or modify
      6  ##   it under the terms of the GNU General Public License as published by
      7  ##   the Free Software Foundation; either version 2, or (at your option)
      8  ##   any later version.
      9  ##
     10  ##   This program is distributed in the hope that it will be useful,
     11  ##   but WITHOUT ANY WARRANTY; without even the implied warranty of
     12  ##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     13  ##   GNU General Public License for more details.
     14
     15  # $Id: transports.py,v 1.31 2007/09/15 11:34:28 normanr Exp $
     16
     17  """
     18  This module contains the low-level implementations of xmpppy connect methods or
     19  (in other words) transports for xmpp-stanzas.
     20  Currently here is three transports:
     21  direct TCP connect - TCPsocket class
     22  proxied TCP connect - HTTPPROXYsocket class (CONNECT proxies)
     23  TLS connection - TLS class. Can be used for SSL connections also.
     24
     25  Transports are stackable so you - f.e. TLS use HTPPROXYsocket or TCPsocket as more low-level transport.
     26
     27  Also exception 'error' is defined to allow capture of this module specific exceptions.
     28  """
     29
     30  import socket,select,base64,dispatcher,sys
     31  from simplexml import ustr
     32  from client import PlugIn
     33  from protocol import *
     34
     35  # determine which DNS resolution library is available
     36  HAVE_DNSPYTHON = False
     37  HAVE_PYDNS = False
     38  try:
     39      import dns.resolver # http://dnspython.org/
     40      HAVE_DNSPYTHON = True
     41  except ImportError:
     42      try:
     43          import DNS # http://pydns.sf.net/
     44          HAVE_PYDNS = True
     45      except ImportError:
     46          #TODO: use self.DEBUG()
     47          sys.stderr.write("Could not load one of the supported DNS libraries (dnspython or pydns). SRV records will not be queried and you may need to set custom hostname/port for some servers to be accessible.\n")
     48
     49  DATA_RECEIVED='DATA RECEIVED'
     50  DATA_SENT='DATA SENT'
     51
     52 -class error:
     53      """An exception to be raised in case of low-level errors in methods of 'transports' module."""
     54 -    def __init__(self,comment):
     55          """Cache the descriptive string"""
     56          self._comment=comment
     57
     58 -    def __str__(self):
     59          """Serialise exception into pre-cached descriptive string."""
     60          return self._comment
     61
     62  BUFLEN=1024
     63 -class TCPsocket(PlugIn):
     64      """ This class defines direct TCP connection method. """
     65 -    def __init__(self, server=None, use_srv=True):
     66          """ Cache connection point 'server'. 'server' is the tuple of (host, port)
     67              absolutely the same as standard tcp socket uses. """
     68          PlugIn.__init__(self)
     69          self.DBG_LINE='socket'
     70          self._exported_methods=[self.send,self.disconnect]
     71
     72          # SRV resolver
     73          if use_srv and (HAVE_DNSPYTHON or HAVE_PYDNS):
     74              host, port = server
     75              possible_queries = ['_xmpp-client._tcp.' + host]
     76
     77              for query in possible_queries:
     78                  try:
     79                      if HAVE_DNSPYTHON:
     80                          answers = [x for x in dns.resolver.query(query, 'SRV')]
     81                          if answers:
     82                              host = str(answers[0].target)
     83                              port = int(answers[0].port)
     84                              break
     85                      elif HAVE_PYDNS:
     86                          # ensure we haven't cached an old configuration
     87                          DNS.ParseResolvConf()
     88                          response = DNS.Request().req(query, qtype='SRV')
     89                          answers = response.answers
     90                          if len(answers) > 0:
     91                              # ignore the priority and weight for now
     92                              _, _, port, host = answers[0]['data']
     93                              del _
     94                              port = int(port)
     95                              break
     96                  except:
     97                      #TODO: use self.DEBUG()
     98                      print 'An error occurred while looking up %s' % query
     99              server = (host, port)
    100          # end of SRV resolver
    101
    102          self._server = server
    103
    104 -    def plugin(self, owner):
    105          """ Fire up connection. Return non-empty string on success.
    106              Also registers self.disconnected method in the owner's dispatcher.
    107              Called internally. """
    108          if not self._server: self._server=(self._owner.Server,5222)
    109          if not self.connect(self._server): return
    110          self._owner.Connection=self
    111          self._owner.RegisterDisconnectHandler(self.disconnected)
    112          return 'ok'
    113
    114 -    def getHost(self):
    115          """ Return the 'host' value that is connection is [will be] made to."""
    116          return self._server[0]
    117 -    def getPort(self):
    118          """ Return the 'port' value that is connection is [will be] made to."""
    119          return self._server[1]
    120
    121 -    def connect(self,server=None):
    122          """ Try to connect. Returns non-empty string on success. """
    123          try:
    124              if not server: server=self._server
    125              self._sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    126              self._sock.connect((server[0], int(server[1])))
    127              self._send=self._sock.sendall
    128              self._recv=self._sock.recv
    129              self.DEBUG("Successfully connected to remote host %s"%`server`,'start')
    130              return 'ok'
    131          except socket.error, (errno, strerror):
    132              self.DEBUG("Failed to connect to remote host %s: %s (%s)"%(`server`, strerror, errno),'error')
    133          except: pass
    134
    135 -    def plugout(self):
    136          """ Disconnect from the remote server and unregister self.disconnected method from
    137              the owner's dispatcher. """
    138          self._sock.close()
    139          if self._owner.__dict__.has_key('Connection'):
    140              del self._owner.Connection
    141              self._owner.UnregisterDisconnectHandler(self.disconnected)
    142
    143 -    def receive(self):
    144          """ Reads all pending incoming data.
    145              In case of disconnection calls owner's disconnected() method and then raises IOError exception."""
    146          try: received = self._recv(BUFLEN)
    147          except socket.sslerror,e:
    148              self._seen_data=0
    149              if e[0]==socket.SSL_ERROR_WANT_READ: return ''
    150              if e[0]==socket.SSL_ERROR_WANT_WRITE: return ''
    151              self.DEBUG('Socket error while receiving data','error')
    152              sys.exc_clear()
    153              self._owner.disconnected()
    154              raise IOError("Disconnected from server")
    155          except: received = ''
    156
    157          while self.pending_data(0):
    158              try: add = self._recv(BUFLEN)
    159              except: add=''
    160              received +=add
    161              if not add: break
    162
    163          if len(received): # length of 0 means disconnect
    164              self._seen_data=1
    165              self.DEBUG(received,'got')
    166              if hasattr(self._owner, 'Dispatcher'):
    167                  self._owner.Dispatcher.Event('', DATA_RECEIVED, received)
    168          else:
    169              self.DEBUG('Socket error while receiving data','error')
    170              self._owner.disconnected()
    171              raise IOError("Disconnected from server")
    172          return received
    173
    174 -    def send(self,raw_data):
    175          """ Writes raw outgoing data. Blocks until done.
    176              If supplied data is unicode string, encodes it to utf-8 before send."""
    177          if type(raw_data)==type(u''): raw_data = raw_data.encode('utf-8')
    178          elif type(raw_data)<>type(''): raw_data = ustr(raw_data).encode('utf-8')
    179          try:
    180              self._send(raw_data)
    181              # Avoid printing messages that are empty keepalive packets.
    182              if raw_data.strip():
    183                  self.DEBUG(raw_data,'sent')
    184                  self._owner.Dispatcher.Event('', DATA_SENT, raw_data)
    185          except:
    186              self.DEBUG("Socket error while sending data",'error')
    187              self._owner.disconnected()
    188
    189 -    def pending_data(self,timeout=0):
    190          """ Returns true if there is a data ready to be read. """
    191          return select.select([self._sock],[],[],timeout)[0]
    192
    193 -    def disconnect(self):
    194          """ Closes the socket. """
    195          self.DEBUG("Closing socket",'stop')
    196          self._sock.close()
    197
    198 -    def disconnected(self):
    199          """ Called when a Network Error or disconnection occurs.
    200              Designed to be overidden. """
    201          self.DEBUG("Socket operation failed",'error')
    202
    203  DBG_CONNECT_PROXY='CONNECTproxy'
    204 -class HTTPPROXYsocket(TCPsocket):
    205      """ HTTP (CONNECT) proxy connection class. Uses TCPsocket as the base class
    206          redefines only connect method. Allows to use HTTP proxies like squid with
    207          (optionally) simple authentication (using login and password). """
    208 -    def __init__(self,proxy,server,use_srv=True):
    209          """ Caches proxy and target addresses.
    210              'proxy' argument is a dictionary with mandatory keys 'host' and 'port' (proxy address)
    211              and optional keys 'user' and 'password' to use for authentication.
    212              'server' argument is a tuple of host and port - just like TCPsocket uses. """
    213          TCPsocket.__init__(self,server,use_srv)
    214          self.DBG_LINE=DBG_CONNECT_PROXY
    215          self._proxy=proxy
    216
    217 -    def plugin(self, owner):
    218          """ Starts connection. Used interally. Returns non-empty string on success."""
    219          owner.debug_flags.append(DBG_CONNECT_PROXY)
    220          return TCPsocket.plugin(self,owner)
    221
    222 -    def connect(self,dupe=None):
    223          """ Starts connection. Connects to proxy, supplies login and password to it
    224              (if were specified while creating instance). Instructs proxy to make
    225              connection to the target server. Returns non-empty sting on success. """
    226          if not TCPsocket.connect(self,(self._proxy['host'],self._proxy['port'])): return
    227          self.DEBUG("Proxy server contacted, performing authentification",'start')
    228          connector = ['CONNECT %s:%s HTTP/1.0'%self._server,
    229              'Proxy-Connection: Keep-Alive',
    230              'Pragma: no-cache',
    231              'Host: %s:%s'%self._server,
    232              'User-Agent: HTTPPROXYsocket/v0.1']
    233          if self._proxy.has_key('user') and self._proxy.has_key('password'):
    234              credentials = '%s:%s'%(self._proxy['user'],self._proxy['password'])
    235              credentials = base64.encodestring(credentials).strip()
    236              connector.append('Proxy-Authorization: Basic '+credentials)
    237          connector.append('\r\n')
    238          self.send('\r\n'.join(connector))
    239          try: reply = self.receive().replace('\r','')
    240          except IOError:
    241              self.DEBUG('Proxy suddenly disconnected','error')
    242              self._owner.disconnected()
    243              return
    244          try: proto,code,desc=reply.split('\n')[0].split(' ',2)
    245          except: raise error('Invalid proxy reply')
    246          if code<>'200':
    247              self.DEBUG('Invalid proxy reply: %s %s %s'%(proto,code,desc),'error')
    248              self._owner.disconnected()
    249              return
    250          while reply.find('\n\n') == -1:
    251              try: reply += self.receive().replace('\r','')
    252              except IOError:
    253                  self.DEBUG('Proxy suddenly disconnected','error')
    254                  self._owner.disconnected()
    255                  return
    256          self.DEBUG("Authentification successfull. Jabber server contacted.",'ok')
    257          return 'ok'
    258
    259 -    def DEBUG(self,text,severity):
    260          """Overwrites DEBUG tag to allow debug output be presented as "CONNECTproxy"."""
    261          return self._owner.DEBUG(DBG_CONNECT_PROXY,text,severity)
    262
    263 -class TLS(PlugIn):
    264      """ TLS connection used to encrypts already estabilished tcp connection."""
    265 -    def PlugIn(self,owner,now=0):
    266          """ If the 'now' argument is true then starts using encryption immidiatedly.
    267              If 'now' in false then starts encryption as soon as TLS feature is
    268              declared by the server (if it were already declared - it is ok).
    269          """
    270          if owner.__dict__.has_key('TLS'): return  # Already enabled.
    271          PlugIn.PlugIn(self,owner)
    272          DBG_LINE='TLS'
    273          if now: return self._startSSL()
    274          if self._owner.Dispatcher.Stream.features:
    275              try: self.FeaturesHandler(self._owner.Dispatcher,self._owner.Dispatcher.Stream.features)
    276              except NodeProcessed: pass
    277          else: self._owner.RegisterHandlerOnce('features',self.FeaturesHandler,xmlns=NS_STREAMS)
    278          self.starttls=None
    279
    280 -    def plugout(self,now=0):
    281          """ Unregisters TLS handler's from owner's dispatcher. Take note that encription
    282              can not be stopped once started. You can only break the connection and start over."""
    283          self._owner.UnregisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
    284          self._owner.UnregisterHandler('proceed',self.StartTLSHandler,xmlns=NS_TLS)
    285          self._owner.UnregisterHandler('failure',self.StartTLSHandler,xmlns=NS_TLS)
    286
    287 -    def FeaturesHandler(self, conn, feats):
    288          """ Used to analyse server <features/> tag for TLS support.
    289              If TLS is supported starts the encryption negotiation. Used internally"""
    290          if not feats.getTag('starttls',namespace=NS_TLS):
    291              self.DEBUG("TLS unsupported by remote server.",'warn')
    292              return
    293          self.DEBUG("TLS supported by remote server. Requesting TLS start.",'ok')
    294          self._owner.RegisterHandlerOnce('proceed',self.StartTLSHandler,xmlns=NS_TLS)
    295          self._owner.RegisterHandlerOnce('failure',self.StartTLSHandler,xmlns=NS_TLS)
    296          self._owner.Connection.send('<starttls xmlns="%s"/>'%NS_TLS)
    297          raise NodeProcessed
    298
    299 -    def pending_data(self,timeout=0):
    300          """ Returns true if there possible is a data ready to be read. """
    301          return self._tcpsock._seen_data or select.select([self._tcpsock._sock],[],[],timeout)[0]
    302
    303 -    def _startSSL(self):
    304          """ Immidiatedly switch socket to TLS mode. Used internally."""
    305          """ Here we should switch pending_data to hint mode."""
    306          tcpsock=self._owner.Connection
    307          tcpsock._sslObj    = socket.ssl(tcpsock._sock, None, None)
    308          tcpsock._sslIssuer = tcpsock._sslObj.issuer()
    309          tcpsock._sslServer = tcpsock._sslObj.server()
    310          tcpsock._recv = tcpsock._sslObj.read
    311          tcpsock._send = tcpsock._sslObj.write
    312
    313          tcpsock._seen_data=1
    314          self._tcpsock=tcpsock
    315          tcpsock.pending_data=self.pending_data
    316          tcpsock._sock.setblocking(0)
    317
    318          self.starttls='success'
    319
    320 -    def StartTLSHandler(self, conn, starttls):
    321          """ Handle server reply if TLS is allowed to process. Behaves accordingly.
    322              Used internally."""
    323          if starttls.getNamespace()<>NS_TLS: return
    324          self.starttls=starttls.getName()
    325          if self.starttls=='failure':
    326              self.DEBUG("Got starttls response: "+self.starttls,'error')
    327              return
    328          self.DEBUG("Got starttls proceed response. Switching to TLS/SSL...",'ok')
    329          self._startSSL()
    330          self._owner.Dispatcher.PlugOut()
    331          dispatcher.Dispatcher().PlugIn(self._owner)
    332