summaryrefslogtreecommitdiff
path: root/src/xmpppy-0.5.0rc1/build/lib/xmpp/transports.py
diff options
context:
space:
mode:
authorlouiz@4325f9fc-e183-4c21-96ce-0ab188b42d13 <louiz@4325f9fc-e183-4c21-96ce-0ab188b42d13>2010-07-20 00:10:39 +0000
committerlouiz@4325f9fc-e183-4c21-96ce-0ab188b42d13 <louiz@4325f9fc-e183-4c21-96ce-0ab188b42d13>2010-07-20 00:10:39 +0000
commit5eeebb36bfe73dcf17dc8b72bd190c266e25c45e (patch)
treeb686f572beea4c420b773219ca2d24a43f3e1694 /src/xmpppy-0.5.0rc1/build/lib/xmpp/transports.py
parent6af387dead3afd22797b94473686cae6d3219b42 (diff)
downloadpoezio-5eeebb36bfe73dcf17dc8b72bd190c266e25c45e.tar.gz
poezio-5eeebb36bfe73dcf17dc8b72bd190c266e25c45e.tar.bz2
poezio-5eeebb36bfe73dcf17dc8b72bd190c266e25c45e.tar.xz
poezio-5eeebb36bfe73dcf17dc8b72bd190c266e25c45e.zip
remove xmpppy from the repos
Diffstat (limited to 'src/xmpppy-0.5.0rc1/build/lib/xmpp/transports.py')
-rw-r--r--src/xmpppy-0.5.0rc1/build/lib/xmpp/transports.py339
1 files changed, 0 insertions, 339 deletions
diff --git a/src/xmpppy-0.5.0rc1/build/lib/xmpp/transports.py b/src/xmpppy-0.5.0rc1/build/lib/xmpp/transports.py
deleted file mode 100644
index 0e3eec90..00000000
--- a/src/xmpppy-0.5.0rc1/build/lib/xmpp/transports.py
+++ /dev/null
@@ -1,339 +0,0 @@
-## transports.py
-##
-## Copyright (C) 2003-2004 Alexey "Snake" Nezhdanov
-##
-## This program is free software; you can redistribute it and/or modify
-## it under the terms of the GNU General Public License as published by
-## the Free Software Foundation; either version 2, or (at your option)
-## any later version.
-##
-## This program is distributed in the hope that it will be useful,
-## but WITHOUT ANY WARRANTY; without even the implied warranty of
-## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-## GNU General Public License for more details.
-
-# $Id: transports.py,v 1.35 2009/04/07 08:34:09 snakeru Exp $
-
-"""
-This module contains the low-level implementations of xmpppy connect methods or
-(in other words) transports for xmpp-stanzas.
-Currently here is three transports:
-direct TCP connect - TCPsocket class
-proxied TCP connect - HTTPPROXYsocket class (CONNECT proxies)
-TLS connection - TLS class. Can be used for SSL connections also.
-
-Transports are stackable so you - f.e. TLS use HTPPROXYsocket or TCPsocket as more low-level transport.
-
-Also exception 'error' is defined to allow capture of this module specific exceptions.
-"""
-
-import socket,select,base64,dispatcher,sys
-from simplexml import ustr
-from client import PlugIn
-from protocol import *
-
-# determine which DNS resolution library is available
-HAVE_DNSPYTHON = False
-HAVE_PYDNS = False
-try:
- import dns.resolver # http://dnspython.org/
- HAVE_DNSPYTHON = True
-except ImportError:
- try:
- import DNS # http://pydns.sf.net/
- HAVE_PYDNS = True
- except ImportError:
- pass
-
-DATA_RECEIVED='DATA RECEIVED'
-DATA_SENT='DATA SENT'
-
-class error:
- """An exception to be raised in case of low-level errors in methods of 'transports' module."""
- def __init__(self,comment):
- """Cache the descriptive string"""
- self._comment=comment
-
- def __str__(self):
- """Serialise exception into pre-cached descriptive string."""
- return self._comment
-
-BUFLEN=1024
-class TCPsocket(PlugIn):
- """ This class defines direct TCP connection method. """
- def __init__(self, server=None, use_srv=True):
- """ Cache connection point 'server'. 'server' is the tuple of (host, port)
- absolutely the same as standard tcp socket uses. However library will lookup for
- ('_xmpp-client._tcp.' + host) SRV record in DNS and connect to the found (if it is)
- server instead
- """
- PlugIn.__init__(self)
- self.DBG_LINE='socket'
- self._exported_methods=[self.send,self.disconnect]
- self._server, self.use_srv = server, use_srv
-
- def srv_lookup(self, server):
- " SRV resolver. Takes server=(host, port) as argument. Returns new (host, port) pair "
- if HAVE_DNSPYTHON or HAVE_PYDNS:
- host, port = server
- possible_queries = ['_xmpp-client._tcp.' + host]
-
- for query in possible_queries:
- try:
- if HAVE_DNSPYTHON:
- answers = [x for x in dns.resolver.query(query, 'SRV')]
- if answers:
- host = str(answers[0].target)
- port = int(answers[0].port)
- break
- elif HAVE_PYDNS:
- # ensure we haven't cached an old configuration
- DNS.DiscoverNameServers()
- response = DNS.Request().req(query, qtype='SRV')
- answers = response.answers
- if len(answers) > 0:
- # ignore the priority and weight for now
- _, _, port, host = answers[0]['data']
- del _
- port = int(port)
- break
- except:
- self.DEBUG('An error occurred while looking up %s' % query, 'warn')
- server = (host, port)
- else:
- self.DEBUG("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",'warn')
- # end of SRV resolver
- return server
-
- def plugin(self, owner):
- """ Fire up connection. Return non-empty string on success.
- Also registers self.disconnected method in the owner's dispatcher.
- Called internally. """
- if not self._server: self._server=(self._owner.Server,5222)
- if self.use_srv: server=self.srv_lookup(self._server)
- else: server=self._server
- if not self.connect(server): return
- self._owner.Connection=self
- self._owner.RegisterDisconnectHandler(self.disconnected)
- return 'ok'
-
- def getHost(self):
- """ Return the 'host' value that is connection is [will be] made to."""
- return self._server[0]
- def getPort(self):
- """ Return the 'port' value that is connection is [will be] made to."""
- return self._server[1]
-
- def connect(self,server=None):
- """ Try to connect to the given host/port. Does not lookup for SRV record.
- Returns non-empty string on success. """
- try:
- if not server: server=self._server
- self._sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self._sock.connect((server[0], int(server[1])))
- self._send=self._sock.sendall
- self._recv=self._sock.recv
- self.DEBUG("Successfully connected to remote host %s"%`server`,'start')
- return 'ok'
- except socket.error, (errno, strerror):
- self.DEBUG("Failed to connect to remote host %s: %s (%s)"%(`server`, strerror, errno),'error')
- except: pass
-
- def plugout(self):
- """ Disconnect from the remote server and unregister self.disconnected method from
- the owner's dispatcher. """
- self._sock.close()
- if self._owner.__dict__.has_key('Connection'):
- del self._owner.Connection
- self._owner.UnregisterDisconnectHandler(self.disconnected)
-
- def receive(self):
- """ Reads all pending incoming data.
- In case of disconnection calls owner's disconnected() method and then raises IOError exception."""
- try: received = self._recv(BUFLEN)
- except socket.sslerror,e:
- self._seen_data=0
- if e[0]==socket.SSL_ERROR_WANT_READ: return ''
- if e[0]==socket.SSL_ERROR_WANT_WRITE: return ''
- self.DEBUG('Socket error while receiving data','error')
- sys.exc_clear()
- self._owner.disconnected()
- raise IOError("Disconnected from server")
- except: received = ''
-
- while self.pending_data(0):
- try: add = self._recv(BUFLEN)
- except: add=''
- received +=add
- if not add: break
-
- if len(received): # length of 0 means disconnect
- self._seen_data=1
- self.DEBUG(received,'got')
- if hasattr(self._owner, 'Dispatcher'):
- self._owner.Dispatcher.Event('', DATA_RECEIVED, received)
- else:
- self.DEBUG('Socket error while receiving data','error')
- self._owner.disconnected()
- raise IOError("Disconnected from server")
- return received
-
- def send(self,raw_data):
- """ Writes raw outgoing data. Blocks until done.
- If supplied data is unicode string, encodes it to utf-8 before send."""
- if type(raw_data)==type(u''): raw_data = raw_data.encode('utf-8')
- elif type(raw_data)<>type(''): raw_data = ustr(raw_data).encode('utf-8')
- try:
- self._send(raw_data)
- # Avoid printing messages that are empty keepalive packets.
- if raw_data.strip():
- self.DEBUG(raw_data,'sent')
- if hasattr(self._owner, 'Dispatcher'): # HTTPPROXYsocket will send data before we have a Dispatcher
- self._owner.Dispatcher.Event('', DATA_SENT, raw_data)
- except:
- self.DEBUG("Socket error while sending data",'error')
- self._owner.disconnected()
-
- def pending_data(self,timeout=0):
- """ Returns true if there is a data ready to be read. """
- return select.select([self._sock],[],[],timeout)[0]
-
- def disconnect(self):
- """ Closes the socket. """
- self.DEBUG("Closing socket",'stop')
- self._sock.close()
-
- def disconnected(self):
- """ Called when a Network Error or disconnection occurs.
- Designed to be overidden. """
- self.DEBUG("Socket operation failed",'error')
-
-DBG_CONNECT_PROXY='CONNECTproxy'
-class HTTPPROXYsocket(TCPsocket):
- """ HTTP (CONNECT) proxy connection class. Uses TCPsocket as the base class
- redefines only connect method. Allows to use HTTP proxies like squid with
- (optionally) simple authentication (using login and password). """
- def __init__(self,proxy,server,use_srv=True):
- """ Caches proxy and target addresses.
- 'proxy' argument is a dictionary with mandatory keys 'host' and 'port' (proxy address)
- and optional keys 'user' and 'password' to use for authentication.
- 'server' argument is a tuple of host and port - just like TCPsocket uses. """
- TCPsocket.__init__(self,server,use_srv)
- self.DBG_LINE=DBG_CONNECT_PROXY
- self._proxy=proxy
-
- def plugin(self, owner):
- """ Starts connection. Used interally. Returns non-empty string on success."""
- owner.debug_flags.append(DBG_CONNECT_PROXY)
- return TCPsocket.plugin(self,owner)
-
- def connect(self,dupe=None):
- """ Starts connection. Connects to proxy, supplies login and password to it
- (if were specified while creating instance). Instructs proxy to make
- connection to the target server. Returns non-empty sting on success. """
- if not TCPsocket.connect(self,(self._proxy['host'],self._proxy['port'])): return
- self.DEBUG("Proxy server contacted, performing authentification",'start')
- connector = ['CONNECT %s:%s HTTP/1.0'%self._server,
- 'Proxy-Connection: Keep-Alive',
- 'Pragma: no-cache',
- 'Host: %s:%s'%self._server,
- 'User-Agent: HTTPPROXYsocket/v0.1']
- if self._proxy.has_key('user') and self._proxy.has_key('password'):
- credentials = '%s:%s'%(self._proxy['user'],self._proxy['password'])
- credentials = base64.encodestring(credentials).strip()
- connector.append('Proxy-Authorization: Basic '+credentials)
- connector.append('\r\n')
- self.send('\r\n'.join(connector))
- try: reply = self.receive().replace('\r','')
- except IOError:
- self.DEBUG('Proxy suddenly disconnected','error')
- self._owner.disconnected()
- return
- try: proto,code,desc=reply.split('\n')[0].split(' ',2)
- except: raise error('Invalid proxy reply')
- if code<>'200':
- self.DEBUG('Invalid proxy reply: %s %s %s'%(proto,code,desc),'error')
- self._owner.disconnected()
- return
- while reply.find('\n\n') == -1:
- try: reply += self.receive().replace('\r','')
- except IOError:
- self.DEBUG('Proxy suddenly disconnected','error')
- self._owner.disconnected()
- return
- self.DEBUG("Authentification successfull. Jabber server contacted.",'ok')
- return 'ok'
-
- def DEBUG(self,text,severity):
- """Overwrites DEBUG tag to allow debug output be presented as "CONNECTproxy"."""
- return self._owner.DEBUG(DBG_CONNECT_PROXY,text,severity)
-
-class TLS(PlugIn):
- """ TLS connection used to encrypts already estabilished tcp connection."""
- def PlugIn(self,owner,now=0):
- """ If the 'now' argument is true then starts using encryption immidiatedly.
- If 'now' in false then starts encryption as soon as TLS feature is
- declared by the server (if it were already declared - it is ok).
- """
- if owner.__dict__.has_key('TLS'): return # Already enabled.
- PlugIn.PlugIn(self,owner)
- DBG_LINE='TLS'
- if now: return self._startSSL()
- if self._owner.Dispatcher.Stream.features:
- try: self.FeaturesHandler(self._owner.Dispatcher,self._owner.Dispatcher.Stream.features)
- except NodeProcessed: pass
- else: self._owner.RegisterHandlerOnce('features',self.FeaturesHandler,xmlns=NS_STREAMS)
- self.starttls=None
-
- def plugout(self,now=0):
- """ Unregisters TLS handler's from owner's dispatcher. Take note that encription
- can not be stopped once started. You can only break the connection and start over."""
- self._owner.UnregisterHandler('features',self.FeaturesHandler,xmlns=NS_STREAMS)
- self._owner.UnregisterHandler('proceed',self.StartTLSHandler,xmlns=NS_TLS)
- self._owner.UnregisterHandler('failure',self.StartTLSHandler,xmlns=NS_TLS)
-
- def FeaturesHandler(self, conn, feats):
- """ Used to analyse server <features/> tag for TLS support.
- If TLS is supported starts the encryption negotiation. Used internally"""
- if not feats.getTag('starttls',namespace=NS_TLS):
- self.DEBUG("TLS unsupported by remote server.",'warn')
- return
- self.DEBUG("TLS supported by remote server. Requesting TLS start.",'ok')
- self._owner.RegisterHandlerOnce('proceed',self.StartTLSHandler,xmlns=NS_TLS)
- self._owner.RegisterHandlerOnce('failure',self.StartTLSHandler,xmlns=NS_TLS)
- self._owner.Connection.send('<starttls xmlns="%s"/>'%NS_TLS)
- raise NodeProcessed
-
- def pending_data(self,timeout=0):
- """ Returns true if there possible is a data ready to be read. """
- return self._tcpsock._seen_data or select.select([self._tcpsock._sock],[],[],timeout)[0]
-
- def _startSSL(self):
- """ Immidiatedly switch socket to TLS mode. Used internally."""
- """ Here we should switch pending_data to hint mode."""
- tcpsock=self._owner.Connection
- tcpsock._sslObj = socket.ssl(tcpsock._sock, None, None)
- tcpsock._sslIssuer = tcpsock._sslObj.issuer()
- tcpsock._sslServer = tcpsock._sslObj.server()
- tcpsock._recv = tcpsock._sslObj.read
- tcpsock._send = tcpsock._sslObj.write
-
- tcpsock._seen_data=1
- self._tcpsock=tcpsock
- tcpsock.pending_data=self.pending_data
- tcpsock._sock.setblocking(0)
-
- self.starttls='success'
-
- def StartTLSHandler(self, conn, starttls):
- """ Handle server reply if TLS is allowed to process. Behaves accordingly.
- Used internally."""
- if starttls.getNamespace()<>NS_TLS: return
- self.starttls=starttls.getName()
- if self.starttls=='failure':
- self.DEBUG("Got starttls response: "+self.starttls,'error')
- return
- self.DEBUG("Got starttls proceed response. Switching to TLS/SSL...",'ok')
- self._startSSL()
- self._owner.Dispatcher.PlugOut()
- dispatcher.Dispatcher().PlugIn(self._owner)