Package pyxmpp :: Package jabberd :: Module componentstream :: Class ComponentStream
[show private | hide private]
[frames | no frames]

Class ComponentStream

StanzaProcessor --+        
                  |        
  StreamHandler --+        
                  |        
         StreamBase --+    
                      |    
PasswordManager --+   |    
                  |   |    
    StreamSASLMixIn --+    
                      |    
     StreamTLSMixIn --+    
                      |    
                 Stream --+
                          |
                         ComponentStream


Handles jabberd component (jabber:component:accept) connection stream.

:Ivariables:
    - `server`: server to use.
    - `port`: port number to use.
    - `secret`: authentication secret.
:Types:
    - `server`: `unicode`
    - `port`: `int`
    - `secret`: `unicode`

Method Summary
  __init__(self, jid, secret, server, port, keepalive)
Initialize a `ComponentStream` object.
  accept(self, sock)
Accept an incoming component connection.
  connect(self, server, port)
Establish a client connection to a server.
  stream_start(self, doc)
Process <stream:stream> (stream start) tag received from peer.
  _auth(self)
Authenticate on the server.
  _compute_handshake(self)
Compute the authentication handshake value.
  _connect(self, server, port)
Same as `ComponentStream.connect` but assume `self.lock` is acquired.
  _post_connect(self)
Initialize authentication when the connection is established and we are the initiator.
  _process_node(self, node)
Process first level element of the stream.
  _reset(self)
Reset `ComponentStream` object state, making the object ready to handle new connections.
    Inherited from Stream
  _got_features(self)
Process incoming <stream:features/> element.
  _make_stream_features(self)
Create the <features/> element for 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/>.
  _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.
  _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.
  _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
  check_authzid(self, authzid, extra_info)
Check if the authenticated entity is allowed to use given authorization id.
  check_password(self, username, password, realm)
Check the password validity.
  choose_realm(self, realm_list)
Choose an authentication realm from the list provided by the server.
  generate_nonce(self)
Generate a random string for digest authentication challenges.
  get_password(self, username, realm, acceptable_formats)
Get the password for user authentication.
  get_realms(self)
Get available realms list.
  get_serv_host(self)
Return the host name for DIGEST-MD5 'digest-uri' field.
  get_serv_name(self)
Return the service name for DIGEST-MD5 'digest-uri' field.
  get_serv_type(self)
Return the service type for DIGEST-MD5 'digest-uri' field.
    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.
  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`.
  _post_auth(self)
Called when connection is authenticated.
  _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
  fix_in_stanza(self, stanza)
Modify incoming stanza before processing it.
  fix_out_stanza(self, stanza)
Modify outgoing stanza before sending into the stream.
  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.

Method Details

__init__(self, jid, secret, server, port, keepalive=0)
(Constructor)

Initialize a `ComponentStream` object.

:Parameters:
    - `jid`: JID of the component.
    - `secret`: authentication secret.
    - `server`: server address.
    - `port`: TCP port number on the server.
    - `keepalive`: keepalive interval. 0 to disable.
Overrides:
pyxmpp.stream.Stream.__init__

accept(self, sock)

Accept an incoming component connection.

[server only]

:Parameters:
    - `sock`: a listening socket.
Overrides:
pyxmpp.streambase.StreamBase.accept

connect(self, server=None, port=None)

Establish a client connection to a server.

[component only]

:Parameters:
    - `server`: name or address of the server to use.  If not given
      then use the one specified when creating the object.
    - `port`: port number of the server to use.  If not given then use
      the one specified when creating the object.

:Types:
    - `server`: `unicode`
    - `port`: `int`
Overrides:
pyxmpp.streambase.StreamBase.connect

stream_start(self, doc)

Process <stream:stream> (stream start) tag received from peer.

Call `Stream.stream_start`, but ignore any `HostMismatch` error.

:Parameters:
    - `doc`: document created by the parser
Overrides:
pyxmpp.streambase.StreamBase.stream_start

_auth(self)

Authenticate on the server.

[component only]

_compute_handshake(self)

Compute the authentication handshake value.

:return: the computed hash value.
:returntype: `str`

_connect(self, server=None, port=None)

Same as `ComponentStream.connect` but assume `self.lock` is acquired.
Overrides:
pyxmpp.streambase.StreamBase._connect

_post_connect(self)

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

_process_node(self, node)

Process first level element of the stream.

Handle component handshake (authentication) element, and
treat elements in "jabber:component:accept", "jabber:client"
and "jabber:server" equally (pass to `self.process_stanza`).
All other elements are passed to `Stream._process_node`.

:Parameters:
    - `node`: XML node describing the element
Overrides:
pyxmpp.stream.Stream._process_node

_reset(self)

Reset `ComponentStream` object state, making the object ready to
handle new connections.
Overrides:
pyxmpp.stream.Stream._reset

Generated by Epydoc 2.1 on Wed May 31 22:37:01 2006 http://epydoc.sf.net