Package pyxmpp :: Package jabber :: Module clientstream :: Class LegacyClientStream
[show private | hide private]
[frames | no frames]

Class LegacyClientStream

StanzaProcessor --+            
                  |            
  StreamHandler --+            
                  |            
         StreamBase --+        
                      |        
PasswordManager --+   |        
                  |   |        
    StreamSASLMixIn --+        
                      |        
     StreamTLSMixIn --+        
                      |        
                 Stream --+    
                          |    
               ClientStream --+
                              |
                             LegacyClientStream


Handles Jabber (both XMPP and legacy protocol) client connection stream.

Both client and server side of the connection is supported. This class handles client SASL and legacy authentication, authorisation and XMPP resource binding.


Method Summary
  __init__(self, jid, password, server, port, auth_methods, tls_settings, keepalive)
Initialize a LegacyClientStream object.
  auth_error(self, stanza)
Handle legacy authentication error.
  auth_finish(self, _unused)
Handle success of the legacy authentication.
  auth_in_stage1(self, stanza)
Handle the first stage (<iq type='get'/>) of legacy ("plain" or "digest") authentication.
  auth_in_stage2(self, stanza)
Handle the second stage (<iq type='set'/>) of legacy ("plain" or "digest") authentication.
  auth_stage2(self, stanza)
Handle the first stage authentication response (result of the <iq type="get"/>).
  auth_timeout(self)
Handle legacy authentication timeout.
  registration_error(self, stanza)
Handle in-band registration error.
  registration_form_received(self, stanza)
Handle registration form received.
  registration_success(self, stanza)
Handle registration success.
  submit_registration_form(self, form)
Submit a registration form.
  _auth_stage1(self)
Do the first stage (<iq type='get'/>) of legacy ("plain" or "digest") authentication.
  _digest_auth_in_stage2(self, username, _unused, stanza)
Handle the second stage (<iq type='set'/>) of legacy "digest" authentication.
  _digest_auth_stage2(self, _unused)
Do the second stage (<iq type='set'/>) of legacy "digest" authentication.
  _plain_auth_in_stage2(self, username, _unused, stanza)
Handle the second stage (<iq type='set'/>) of legacy "plain" authentication.
  _plain_auth_stage2(self, _unused)
Do the second stage (<iq type='set'/>) of legacy "plain" authentication.
  _post_auth(self)
Unregister legacy authentication handlers after successfull authentication.
  _post_connect(self)
Initialize authentication when the connection is established and we are the initiator.
  _reset(self)
Reset the LegacyClientStream object state, making the object ready to handle new connections.
  _try_auth(self)
Try to authenticate using the first one of allowed authentication methods left.
    Inherited from ClientStream
  accept(self, sock)
Accept an incoming client connection.
bool check_authzid(self, authzid, extra_info)
Check authorization id provided by the client.
unicode choose_realm(self, realm_list)
Choose authentication realm from the list provided by the server.
  connect(self, server, port)
Establish a client connection to a server.
  do_bind(self, stanza)
Do the resource binding requested by a client connected.
  fix_in_stanza(self, stanza)
Fix an incoming stanza.
  fix_out_stanza(self, stanza)
Fix outgoing stanza.
(unicode,`str`) get_password(self, username, realm, acceptable_formats)
Get a user password for the SASL authentication.
list of unicode get_realms(self)
Get realms available for client authentication.
  get_serv_host(self)
Get the service host name for SASL authentication.
  get_serv_name(self)
Get the service name for SASL authentication.
  get_serv_type(self)
Get the server name for SASL authentication.
  _connect(self, server, port)
Same as ClientStream.connect but assume self.lock is acquired.
  _get_stream_features(self)
Include resource binding feature in the stream features list.
    Inherited from Stream
  _got_features(self)
Process incoming <stream:features/> element.
  _make_stream_features(self)
Create the <features/> element for the stream.
  _process_node(self, xmlnode)
Process first level element of the stream.
    Inherited from StreamTLSMixIn
  get_tls_connection(self)
Get the TLS connection object for the stream.
  _handle_tls_features(self)
Process incoming StartTLS related element of <stream:features/>.
libxml2.xmlNode _make_stream_tls_features(self, features)
Update the <features/> with StartTLS feature.
  _make_tls_connection(self)
Initiate TLS connection.
  _process(self)
Same as Stream.process but assume self.lock is acquired.
bool _process_node_tls(self, xmlnode)
Process incoming stream element.
  _process_tls_node(self, xmlnode)
Process stream element in the TLS namespace.
  _read(self)
Read data pending on the stream socket and pass it to the parser.
  _read_tls(self)
Read data pending on the stream socket and pass it to the parser.
  _request_tls(self)
Request a TLS-encrypted connection.
  _reset_tls(self)
Reset StreamTLSMixIn object state making it ready to handle new connections.
  _tls_verify_callback(self, ssl_ctx_ptr, x509_ptr, errnum, depth, ok)
Certificate verification callback for TLS connections.
  _write_raw(self, data)
Same as Stream.write_raw but assume self.lock is acquired.
    Inherited from StreamSASLMixIn
  _handle_sasl_features(self)
Process incoming <stream:features/> element.
  _make_stream_sasl_features(self, features)
Add SASL features to the <features/> element of the stream.
bool _process_node_sasl(self, xmlnode)
Process incoming stream element.
  _process_sasl_abort(self)
Process incoming <sasl:abort/> element.
  _process_sasl_auth(self, mechanism, content)
Process incoming <sasl:auth/> element.
  _process_sasl_challenge(self, content)
Process incoming <sasl:challenge/> element.
  _process_sasl_failure(self, xmlnode)
Process incoming <sasl:failure/> element.
  _process_sasl_node(self, xmlnode)
Process stream element in the SASL namespace.
  _process_sasl_response(self, content)
Process incoming <sasl:response/> element.
  _process_sasl_success(self, content)
Process incoming <sasl:success/> element.
  _reset_sasl(self)
Reset StreamSASLMixIn object state making it ready to handle new connections.
  _sasl_authenticate(self, username, authzid, mechanism)
Start SASL authentication process.
    Inherited from PasswordManager
bool check_password(self, username, password, realm)
Check the password validity.
str generate_nonce(self)
Generate a random string for digest authentication challenges.
    Inherited from StreamBase
  __del__(self)
  bind(self, resource)
Bind to a resource.
  check_to(self, to)
Check "to" attribute of received stream header.
  close(self)
Forcibly close the connection and clear the stream state.
  connected(self)
Check if stream is connected.
  disconnect(self)
Gracefully close the connection.
  error(self, descr)
Handle stream XML parse error.
  fileno(self)
Return filedescriptor of the stream socket.
  generate_id(self)
Generate a random and unique stream ID.
  idle(self)
Do some housekeeping (cache expiration, timeout handling).
  loop(self, timeout)
Simple "main loop" for the stream.
  loop_iter(self, timeout)
Single iteration of a simple "main loop" for the stream.
  process(self)
Process stream's pending events.
  process_stream_error(self, err)
Process stream error element received.
  send(self, stanza)
Write stanza to the stream.
  stanza(self, _unused, node)
Process stanza (first level child element of the stream).
  stanza_start(self, doc, node)
Process stanza (first level child element of the stream) start tag -- do nothing.
  state_change(self, state, arg)
Called when connection state is changed.
  stream_end(self, _unused)
Process </stream:stream> (stream end) tag received from peer.
  stream_start(self, doc)
Process <stream:stream> (stream start) tag received from peer.
  write_raw(self, data)
Write raw data to the stream socket.
  _accept(self, sock, myname)
Same as Stream.accept but assume self.lock is acquired.
  _bind_error(self, stanza)
Handle resource binding success.
  _bind_success(self, stanza)
Handle resource binding success.
  _close(self)
Same as Stream.close but assume self.lock is acquired.
  _connect_socket(self, sock, to)
Initialize stream on outgoing connection.
  _disconnect(self)
Same as Stream.disconnect but assume self.lock is acquired.
  _feed_reader(self, data)
Feed the stream reader with data received.
  _idle(self)
Same as Stream.idle but assume self.lock is acquired.
  _loop_iter(self, timeout)
Same as Stream.loop_iter but assume self.lock is acquired.
  _make_reader(self)
Create ne xmlextra.StreamReader instace as self._reader.
  _process_stream_node(self, xmlnode)
Process first level stream-namespaced element of the stream.
  _restart_stream(self)
Restart the stream as needed after SASL and StartTLS negotiation.
  _send(self, stanza)
Same as Stream.send but assume self.lock is acquired.
  _send_stream_end(self)
Send stream end tag.
  _send_stream_error(self, condition)
Send stream error element.
  _send_stream_features(self)
Send stream <features/>.
  _send_stream_start(self, sid)
Send stream start tag.
  _write_node(self, xmlnode)
Write XML xmlnode to the stream.
    Inherited from StanzaProcessor
  process_iq(self, stanza)
Process IQ stanza received.
  process_message(self, stanza)
Process message stanza.
  process_presence(self, stanza)
Process presence stanza.
  process_stanza(self, stanza)
Process stanza received from the stream.
  route_stanza(self, stanza)
Process stanza not addressed to us.
  set_iq_get_handler(self, element, namespace, handler)
Set <iq type="get"/> handler.
  set_iq_set_handler(self, element, namespace, handler)
Set <iq type="set"/> handler.
  set_message_handler(self, typ, handler, namespace, priority)
Set a handler for <message/> stanzas.
  set_presence_handler(self, typ, handler, namespace, priority)
Set a handler for <presence/> stanzas.
  set_response_handlers(self, iq, res_handler, err_handler, timeout_handler, timeout)
Set response handler for an IQ "get" or "set" stanza.
  unset_iq_get_handler(self, element, namespace)
Remove <iq type="get"/> handler.
  unset_iq_set_handler(self, element, namespace)
Remove <iq type="set"/> handler.
  _set_response_handlers(self, iq, res_handler, err_handler, timeout_handler, timeout)
Same as Stream.set_response_handlers but assume self.lock is acquired.
    Inherited from StreamHandler
  _stanza(self, _doc, _node)
Process complete stanza.
  _stream_end(self, _doc)
Process stream end.
  _stream_start(self, _doc)
Process stream start.

Instance Variable Summary
    Inherited from ClientStream
list of str auth_methods: allowed authentication methods.
pyxmpp.JID my_jid: requested local JID.
str password: user's password.
int port: port number to use.
str server: server to use.
    Inherited from Stream
  features: stream features as annouced by the initiator.
  initiator: True if local stream endpoint is the initiating entity.
  lock: RLock object used to synchronize access to Stream object.
  me: local stream endpoint JID.
  peer: remote stream endpoint JID.
  process_all_stanzas: when True then all stanzas received are considered local.
  tls: TLS connection object.
  _reader: the stream reader object (push parser) for the stream.

Method Details

__init__(self, jid, password=None, server=None, port=5222, auth_methods=('sasl:DIGEST-MD5', 'digest'), tls_settings=None, keepalive=0)
(Constructor)

Initialize a LegacyClientStream object.
Parameters:
jid - local JID.
           (type=pyxmpp.JID)
password - user's password.
           (type=unicode)
server - server to use. If not given then address will be derived form the JID.
           (type=unicode)
port - port number to use. If not given then address will be derived form the JID.
           (type=int)
auth_methods - sallowed authentication methods. SASL authentication mechanisms in the list should be prefixed with "sasl:" string.
           (type=sequence of str)
tls_settings - settings for StartTLS -- TLSSettings instance.
           (type=pyxmpp.TLSSettings)
keepalive - keepalive output interval. 0 to disable.
           (type=int)
Overrides:
pyxmpp.clientstream.ClientStream.__init__

auth_error(self, stanza)

Handle legacy authentication error.

[client only]

auth_finish(self, _unused)

Handle success of the legacy authentication.

auth_in_stage1(self, stanza)

Handle the first stage (<iq type='get'/>) of legacy ("plain" or "digest") authentication.

[server only]

auth_in_stage2(self, stanza)

Handle the second stage (<iq type='set'/>) of legacy ("plain" or "digest") authentication.

[server only]

auth_stage2(self, stanza)

Handle the first stage authentication response (result of the <iq type="get"/>).

[client only]

auth_timeout(self)

Handle legacy authentication timeout.

[client only]

registration_error(self, stanza)

Handle in-band registration error.

[client only]

Parameters:
stanza - the error stanza received or None on timeout.
           (type=pyxmpp.stanza.Stanza)

registration_form_received(self, stanza)

Handle registration form received.

[client only]

Call self.registration_callback with the registration form received as the argument. Use the value returned by the callback will be a filled-in form.

Parameters:
stanza - the stanza received.
           (type=pyxmpp.iq.Iq)

registration_success(self, stanza)

Handle registration success.

[client only]

Clean up registration stuff, change state to "registered" and initialize authentication.

Parameters:
stanza - the stanza received.
           (type=pyxmpp.iq.Iq)

submit_registration_form(self, form)

Submit a registration form.

[client only]

Parameters:
form - the filled-in form. When form is None or its type is "cancel" the registration is to be canceled.
           (type=pyxmpp.jabber.dataforms.Form)

_auth_stage1(self)

Do the first stage (<iq type='get'/>) of legacy ("plain" or "digest") authentication.

[client only]

_digest_auth_in_stage2(self, username, _unused, stanza)

Handle the second stage (<iq type='set'/>) of legacy "digest" authentication.

[server only]

_digest_auth_stage2(self, _unused)

Do the second stage (<iq type='set'/>) of legacy "digest" authentication.

[client only]

_plain_auth_in_stage2(self, username, _unused, stanza)

Handle the second stage (<iq type='set'/>) of legacy "plain" authentication.

[server only]

_plain_auth_stage2(self, _unused)

Do the second stage (<iq type='set'/>) of legacy "plain" authentication.

[client only]

_post_auth(self)

Unregister legacy authentication handlers after successfull authentication.
Overrides:
pyxmpp.streambase.StreamBase._post_auth

_post_connect(self)

Initialize authentication when the connection is established and we are the initiator.
Overrides:
pyxmpp.clientstream.ClientStream._post_connect

_reset(self)

Reset the LegacyClientStream object state, making the object ready to handle new connections.
Overrides:
pyxmpp.clientstream.ClientStream._reset

_try_auth(self)

Try to authenticate using the first one of allowed authentication methods left.

[client only]

Overrides:
pyxmpp.clientstream.ClientStream._try_auth