Package twisted :: Package conch :: Package ssh :: Module connection :: Class SSHConnection

[show private | hide private]
[frames | no frames]

## Class SSHConnection

    SSHService --+
                 |
                SSHConnection

Known Subclasses:
  `SSHConnection`, `SSHConnection`

Method Summary
| `__init__(self)`
| ``adjustWindow`(self, channel, bytesToAdd)` Tell the other side that we will receive more data.
subclass of `SSHChannel`/`tuple` | ``getChannel`(self, channelType, windowSize, maxPacket, data)` The other side requested a channel of some sort.
`int`/`tuple` | ``gotGlobalRequest`(self, requestType, data)` We got a global request.
| ``openChannel`(self, channel, extra)` Open a new channel on this connection.
| ``packetReceived`(self, messageType, packet)` called when we receieve a packet on the transport (inherited from `SSHService`)
| ``sendClose`(self, channel)` Close a channel.
| ``sendData`(self, channel, data)` Send data to a channel.
| ``sendEOF`(self, channel)` Send an EOF (End of File) for a channel.
| ``sendExtendedData`(self, channel, dataType, data)` Send extended data to a channel.
| ``sendGlobalRequest`(self, request, data, wantReply)` Send a global request for this connection.
| ``sendRequest`(self, channel, requestType, data, wantReply)` Send a request to a channel.
| ``serviceStarted`(self)` called when the service is active on the transport. (inherited from `SSHService`)
| ``serviceStopped`(self)` called when the service is stopped, either by the connection ending or by another service being started
| `ssh_CHANNEL_CLOSE(self, packet)`
| `ssh_CHANNEL_DATA(self, packet)`
| `ssh_CHANNEL_EOF(self, packet)`
| `ssh_CHANNEL_EXTENDED_DATA(self, packet)`
| `ssh_CHANNEL_FAILURE(self, packet)`
| `ssh_CHANNEL_OPEN(self, packet)`
| `ssh_CHANNEL_OPEN_CONFIRMATION(self, packet)`
| `ssh_CHANNEL_OPEN_FAILURE(self, packet)`
| `ssh_CHANNEL_REQUEST(self, packet)`
| `ssh_CHANNEL_SUCCESS(self, packet)`
| `ssh_CHANNEL_WINDOW_ADJUST(self, packet)`
| `ssh_GLOBAL_REQUEST(self, packet)`
| `ssh_REQUEST_FAILURE(self, packet)`
| `ssh_REQUEST_SUCCESS(self, packet)`

Class Variable Summary
`string` | `name`
`dictionary` | `protocolMessages`

Method Details

### adjustWindow(self, channel, bytesToAdd)

Tell the other side that we will receive more data. This should not normally need to be called as it is managed automatically.

  Parameters:
    `channel`
    (type=subclass of `SSHChannel`)
    `bytesToAdd`
    (type=`int`)

### getChannel(self, channelType, windowSize, maxPacket, data)

The other side requested a channel of some sort. channelType is the type of channel being requested, windowSize is the initial size of the remote window, maxPacket is the largest packet we should send, data is any other packet data (often nothing).

We return either a subclass of SSHChannel, or a tuple of (errorCode, errorMessage).

  Parameters:
    `channelType`
    (type=`str`)
    `windowSize`
    (type=`int`)
    `maxPacket`
    (type=`int`)
    `data`
    (type=`str`)
  Returns:
    subclass of `SSHChannel`/`tuple`

### gotGlobalRequest(self, requestType, data)

We got a global request. pretty much, this is just used by the client to request that we forward a port from the server to the client. returns either:

- 1: request accepted
- 1, <data>: request accepted with request specific data
- 0: request denied

  Parameters:
    `requestType`
    (type=`str`)
    `data`
    (type=`str`)
  Returns:
    `int`/`tuple`

### openChannel(self, channel, extra='')

Open a new channel on this connection.

  Parameters:
    `channel`
    (type=subclass of `SSHChannel`)
    `extra`
    (type=`str`)

### sendClose(self, channel)

Close a channel.

  Parameters:
    `channel`
    (type=subclass of `SSHChannel`)

### sendData(self, channel, data)

Send data to a channel. This should not normally be used: instead use channel.write(data) as it manages the window automatically.

  Parameters:
    `channel`
    (type=subclass of `SSHChannel`)
    `data`
    (type=`str`)

### sendEOF(self, channel)

Send an EOF (End of File) for a channel.

  Parameters:
    `channel`
    (type=subclass of `SSHChannel`)

### sendExtendedData(self, channel, dataType, data)

Send extended data to a channel. This should not normally be used: instead use channel.writeExtendedData(data, dataType) as it manages the window automatically.

  Parameters:
    `channel`
    (type=subclass of `SSHChannel`)
    `dataType`
    (type=`int`)
    `data`
    (type=`str`)

### sendGlobalRequest(self, request, data, wantReply=0)

Send a global request for this connection. Current this is only used for remote->local TCP forwarding.

  Parameters:
    `request`
    (type=`str`)
    `data`
    (type=`str`)
    `wantReply`
    (type=`bool` @rtype `Deferred`/`None`)

### sendRequest(self, channel, requestType, data, wantReply=0)

Send a request to a channel.

  Parameters:
    `channel`
    (type=subclass of `SSHChannel`)
    `requestType`
    (type=`str`)
    `data`
    (type=`str`)
    `wantReply`
    (type=`bool` @rtype `Deferred`/`None`)

### serviceStopped(self)

called when the service is stopped, either by the connection ending or by another service being started

  Overrides:
    `twisted.conch.ssh.service.SSHService.serviceStopped` (inherited documentation)

Class Variable Details

### name

  Type:
    `string`
  Value:

        'ssh-connection'

### protocolMessages

  Type:
    `dictionary`
  Value:

        {80: 'MSG_GLOBAL_REQUEST',
         81: 'MSG_REQUEST_SUCCESS',
         82: 'MSG_REQUEST_FAILURE',
         90: 'MSG_CHANNEL_OPEN',
         91: 'MSG_CHANNEL_OPEN_CONFIRMATION',
         92: 'MSG_CHANNEL_OPEN_FAILURE',
         93: 'MSG_CHANNEL_WINDOW_ADJUST',
         94: 'MSG_CHANNEL_DATA',
        ...

Generated by Epydoc 1.1 on Sat Feb 15 21:17:48 2003 | http://epydoc.sf.net