xmpp/transports.py

   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)