bitfling.xmlrpcstuff.myServer

Package bitfling :: Module xmlrpcstuff :: Class myServer

[show private | hide private]

Type myServer

     object --+    
              |    
ServerInterface --+
                  |
                 myServer

Method Summary
	`__init__(self, peeraddr, onbehalfof)`
int	`check_auth_password(self, username, password)` Determine if a given username and password supplied by the client is acceptable for use in authentication.
int	`check_channel_request(self, kind, chanid)` Determine if a channel request of a given type will be granted, and return `OPEN_SUCCEEDED` or an error code.
str	`get_allowed_auths(self, username)` Return a list of authentication methods supported by the server.
Inherited from ServerInterface
	`cancel_port_forward_request(self, address, port)` The client would like to cancel a previous port-forwarding request.
int or `InteractiveQuery`	`check_auth_interactive(self, username, submethods)` Begin an interactive authentication challenge, if supported.
int or `InteractiveQuery`	`check_auth_interactive_response(self, responses)` Continue or finish an interactive authentication challenge, if supported.
int	`check_auth_none(self, username)` Determine if a client may open channels with no (further) authentication.
int	`check_auth_publickey(self, username, key)` Determine if a given key supplied by the client is acceptable for use in authentication.
bool	`check_channel_exec_request(self, channel, command)` Determine if a shell command will be executed for the client.
bool	`check_channel_pty_request(self, channel, term, width, height, pixelwidth, pixelheight, modes)` Determine if a pseudo-terminal of the given dimensions (usually requested for shell access) can be provided on the given channel.
bool	`check_channel_shell_request(self, channel)` Determine if a shell will be provided to the client on the given channel.
bool	`check_channel_subsystem_request(self, channel, name)` Determine if a requested subsystem will be provided to the client on the given channel.
bool	`check_channel_window_change_request(self, channel, width, height, pixelwidth, pixelheight)` Determine if the pseudo-terminal on the given channel can be resized.
bool	`check_channel_x11_request(self, channel, single_connection, auth_protocol, auth_cookie, screen_number)` Determine if the client will be provided with an X11 session.
bool	`check_global_request(self, kind, msg)` Handle a global request of the given `kind`.
int	`check_port_forward_request(self, address, port)` Handle a request for port forwarding.
Inherited from object
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__hash__(x)` x.__hash__() <==> hash(x)
	`__new__(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
	`__reduce__(...)` helper for pickle
	`__reduce_ex__(...)` helper for pickle
	`__repr__(x)` x.__repr__() <==> repr(x)
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value
	`__str__(x)` x.__str__() <==> str(x)

Method Details

check_auth_password(self, username, password)

Determine if a given username and password supplied by the client is acceptable for use in authentication.

Return AUTH_FAILED if the password is not accepted, AUTH_SUCCESSFUL if the password is accepted and completes the authentication, or AUTH_PARTIALLY_SUCCESSFUL if your authentication is stateful, and this key is accepted for authentication, but more authentication is required. (In this latter case, get_allowed_auths will be called to report to the client what options it has for continuing the authentication.)

The default implementation always returns AUTH_FAILED.

Parameters:: username - the username of the authenticating client.
(type=str); password - the password given by the client.
(type=str)

Returns:: AUTH_FAILED if the authentication fails; AUTH_SUCCESSFUL if it succeeds; AUTH_PARTIALLY_SUCCESSFUL if the password auth is successful, but authentication must continue.
(type=int)

Overrides:: paramiko.ServerInterface.check_auth_password (inherited documentation)

check_channel_request(self, kind, chanid)

Determine if a channel request of a given type will be granted, and return OPEN_SUCCEEDED or an error code. This method is called in server mode when the client requests a channel, after authentication is complete.

If you allow channel requests (and an ssh server that didn't would be useless), you should also override some of the channel request methods below, which are used to determine which services will be allowed on a given channel:

The chanid parameter is a small number that uniquely identifies the channel within a Transport. A Channel object is not created unless this method returns OPEN_SUCCEEDED -- once a Channel object is created, you can call Channel.get_id to retrieve the channel ID.

The return value should either be OPEN_SUCCEEDED (or 0) to allow the channel request, or one of the following error codes to reject it:

OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED
OPEN_FAILED_CONNECT_FAILED
OPEN_FAILED_UNKNOWN_CHANNEL_TYPE
OPEN_FAILED_RESOURCE_SHORTAGE

The default implementation always returns OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED.

Parameters:: kind - the kind of channel the client would like to open (usually "session").
(type=str); chanid - ID of the channel
(type=int)

Returns:: a success or failure code (listed above)
(type=int)

Overrides:: paramiko.ServerInterface.check_channel_request (inherited documentation)

get_allowed_auths(self, username)

Return a list of authentication methods supported by the server. This list is sent to clients attempting to authenticate, to inform them of authentication methods that might be successful.

The "list" is actually a string of comma-separated names of types of authentication. Possible values are "password", "publickey", and "none".

The default implementation always returns "password".

Parameters:: username - the username requesting authentication.
(type=str)

Returns:: a comma-separated list of authentication types
(type=str)

Overrides:: paramiko.ServerInterface.get_allowed_auths (inherited documentation)

Generated by Epydoc 2.1 on Fri Aug 15 18:58:35 2008

http://epydoc.sf.net