Here are the examples of the python api twisted.conch.ssh.common.getNS taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
107 Examples
3
Source : factory.py
with MIT License
from autofelix
with MIT License
from autofelix
def getPublicKeys(self):
"""
Return the server public keys.
"""
ks = {}
for filename in os.listdir(self.dataRoot):
if filename[:9] == 'ssh_host_' and filename[-8:]=='_key.pub':
try:
k = keys.Key.fromFile(
os.path.join(self.dataRoot, filename))
t = common.getNS(k.blob())[0]
ks[t] = k
except Exception as e:
log.msg('bad public key file %s: %s' % (filename, e))
return ks
def getPrivateKeys(self):
3
Source : agent.py
with MIT License
from autofelix
with MIT License
from autofelix
def _cbRequestIdentities(self, data):
"""
Unpack a collection of identities into a list of tuples comprised of
public key blobs and comments.
"""
if ord(data[0:1]) != AGENT_IDENTITIES_ANSWER:
raise ConchError('unexpected response: %i' % ord(data[0:1]))
numKeys = struct.unpack('!L', data[1:5])[0]
result = []
data = data[5:]
for i in range(numKeys):
blob, data = getNS(data)
comment, data = getNS(data)
result.append((blob, comment))
return result
def addIdentity(self, blob, comment = b''):
3
Source : agent.py
with MIT License
from autofelix
with MIT License
from autofelix
def _cbSignData(self, data):
if ord(data[0:1]) != AGENT_SIGN_RESPONSE:
raise ConchError('unexpected data: %i' % ord(data[0:1]))
signature = getNS(data[1:])[0]
return signature
def removeIdentity(self, blob):
3
Source : agent.py
with MIT License
from autofelix
with MIT License
from autofelix
def agentc_SIGN_REQUEST(self, data):
"""
Data is a structure with a reference to an already added key object and
some data that the clients wants signed with that key. If the key
object wasn't loaded, return AGENT_FAILURE, else return the signature.
"""
blob, data = getNS(data)
if blob not in self.factory.keys:
return self.sendResponse(AGENT_FAILURE, b'')
signData, data = getNS(data)
assert data == b'\000\000\000\000'
self.sendResponse(AGENT_SIGN_RESPONSE, NS(self.factory.keys[blob][0].sign(signData)))
def agentc_ADD_IDENTITY(self, data):
3
Source : agent.py
with MIT License
from autofelix
with MIT License
from autofelix
def agentc_REMOVE_IDENTITY(self, data):
"""
Remove a specific key from the agent's collection of identities.
"""
blob, _ = getNS(data)
k = keys.Key.fromString(blob, type='blob')
del self.factory.keys[k.blob()]
self.sendResponse(AGENT_SUCCESS, b'')
def agentc_REMOVE_ALL_IDENTITIES(self, data):
3
Source : connection.py
with MIT License
from autofelix
with MIT License
from autofelix
def ssh_CHANNEL_OPEN_FAILURE(self, packet):
"""
The other side did not accept our MSG_CHANNEL_OPEN request. Payload::
uint32 local channel number
uint32 reason code
string reason description
Find the channel using the local channel number and notify it by
calling its openFailed() method.
"""
localChannel, reasonCode = struct.unpack('>2L', packet[:8])
reasonDesc = common.getNS(packet[8:])[0]
channel = self.channels[localChannel]
del self.channels[localChannel]
channel.conn = self
reason = error.ConchError(reasonDesc, reasonCode)
log.callWithLogger(channel, channel.openFailed, reason)
def ssh_CHANNEL_WINDOW_ADJUST(self, packet):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_INIT(self, data):
(version,) = struct.unpack('!L', data[:4])
self.version = min(list(self.versions) + [version])
data = data[4:]
ext = {}
while data:
extName, data = getNS(data)
extData, data = getNS(data)
ext[extName] = extData
ourExt = self.client.gotVersion(version, ext)
ourExtData = b""
for (k, v) in ourExt.items():
ourExtData += NS(k) + NS(v)
self.sendPacket(FXP_VERSION, struct.pack('!L', self.version) +
ourExtData)
def packet_OPEN(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_OPEN(self, data):
requestId = data[:4]
data = data[4:]
filename, data = getNS(data)
(flags,) = struct.unpack('!L', data[:4])
data = data[4:]
attrs, data = self._parseAttributes(data)
assert data == b'', 'still have data in OPEN: {!r}'.format(data)
d = defer.maybeDeferred(self.client.openFile, filename, flags, attrs)
d.addCallback(self._cbOpenFile, requestId)
d.addErrback(self._ebStatus, requestId, b"open failed")
def _cbOpenFile(self, fileObj, requestId):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_READ(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
(offset, length), data = struct.unpack('!QL', data[:12]), data[12:]
assert data == b'', 'still have data in READ: {!r}'.format(data)
if handle not in self.openFiles:
self._ebRead(failure.Failure(KeyError()), requestId)
else:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.readChunk, offset, length)
d.addCallback(self._cbRead, requestId)
d.addErrback(self._ebStatus, requestId, b"read failed")
def _cbRead(self, result, requestId):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_WRITE(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
offset, = struct.unpack('!Q', data[:8])
data = data[8:]
writeData, data = getNS(data)
assert data == b'', 'still have data in WRITE: {!r}'.format(data)
if handle not in self.openFiles:
self._ebWrite(failure.Failure(KeyError()), requestId)
else:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.writeChunk, offset, writeData)
d.addCallback(self._cbStatus, requestId, b"write succeeded")
d.addErrback(self._ebStatus, requestId, b"write failed")
def packet_REMOVE(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_REMOVE(self, data):
requestId = data[:4]
data = data[4:]
filename, data = getNS(data)
assert data == b'', 'still have data in REMOVE: {!r}'.format(data)
d = defer.maybeDeferred(self.client.removeFile, filename)
d.addCallback(self._cbStatus, requestId, b"remove succeeded")
d.addErrback(self._ebStatus, requestId, b"remove failed")
def packet_RENAME(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_RENAME(self, data):
requestId = data[:4]
data = data[4:]
oldPath, data = getNS(data)
newPath, data = getNS(data)
assert data == b'', 'still have data in RENAME: {!r}'.format(data)
d = defer.maybeDeferred(self.client.renameFile, oldPath, newPath)
d.addCallback(self._cbStatus, requestId, b"rename succeeded")
d.addErrback(self._ebStatus, requestId, b"rename failed")
def packet_MKDIR(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_MKDIR(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
attrs, data = self._parseAttributes(data)
assert data == b'', 'still have data in MKDIR: {!r}'.format(data)
d = defer.maybeDeferred(self.client.makeDirectory, path, attrs)
d.addCallback(self._cbStatus, requestId, b"mkdir succeeded")
d.addErrback(self._ebStatus, requestId, b"mkdir failed")
def packet_RMDIR(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_RMDIR(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in RMDIR: {!r}'.format(data)
d = defer.maybeDeferred(self.client.removeDirectory, path)
d.addCallback(self._cbStatus, requestId, b"rmdir succeeded")
d.addErrback(self._ebStatus, requestId, b"rmdir failed")
def packet_OPENDIR(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_OPENDIR(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in OPENDIR: {!r}'.format(data)
d = defer.maybeDeferred(self.client.openDirectory, path)
d.addCallback(self._cbOpenDirectory, requestId)
d.addErrback(self._ebStatus, requestId, b"opendir failed")
def _cbOpenDirectory(self, dirObj, requestId):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_READDIR(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
assert data == b'', 'still have data in READDIR: {!r}'.format(data)
if handle not in self.openDirs:
self._ebStatus(failure.Failure(KeyError()), requestId)
else:
dirObj, dirIter = self.openDirs[handle]
d = defer.maybeDeferred(self._scanDirectory, dirIter, [])
d.addCallback(self._cbSendDirectory, requestId)
d.addErrback(self._ebStatus, requestId, b"scan directory failed")
def _scanDirectory(self, dirIter, f):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_STAT(self, data, followLinks=1):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in STAT/LSTAT: {!r}'.format(data)
d = defer.maybeDeferred(self.client.getAttrs, path, followLinks)
d.addCallback(self._cbStat, requestId)
d.addErrback(self._ebStatus, requestId, b'stat/lstat failed')
def packet_LSTAT(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_FSTAT(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
assert data == b'', 'still have data in FSTAT: {!r}'.format(data)
if handle not in self.openFiles:
self._ebStatus(failure.Failure(KeyError(
'{} not in self.openFiles'.format(handle))), requestId)
else:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.getAttrs)
d.addCallback(self._cbStat, requestId)
d.addErrback(self._ebStatus, requestId, b'fstat failed')
def _cbStat(self, result, requestId):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_SETSTAT(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
attrs, data = self._parseAttributes(data)
if data != b'':
log.msg('WARN: still have data in SETSTAT: {!r}'.format(data))
d = defer.maybeDeferred(self.client.setAttrs, path, attrs)
d.addCallback(self._cbStatus, requestId, b'setstat succeeded')
d.addErrback(self._ebStatus, requestId, b'setstat failed')
def packet_FSETSTAT(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_FSETSTAT(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
attrs, data = self._parseAttributes(data)
assert data == b'', 'still have data in FSETSTAT: {!r}'.format(data)
if handle not in self.openFiles:
self._ebStatus(failure.Failure(KeyError()), requestId)
else:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.setAttrs, attrs)
d.addCallback(self._cbStatus, requestId, b'fsetstat succeeded')
d.addErrback(self._ebStatus, requestId, b'fsetstat failed')
def packet_READLINK(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_READLINK(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in READLINK: {!r}'.format(data)
d = defer.maybeDeferred(self.client.readLink, path)
d.addCallback(self._cbReadLink, requestId)
d.addErrback(self._ebStatus, requestId, b'readlink failed')
def _cbReadLink(self, result, requestId):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_SYMLINK(self, data):
requestId = data[:4]
data = data[4:]
linkPath, data = getNS(data)
targetPath, data = getNS(data)
d = defer.maybeDeferred(self.client.makeLink, linkPath, targetPath)
d.addCallback(self._cbStatus, requestId, b'symlink succeeded')
d.addErrback(self._ebStatus, requestId, b'symlink failed')
def packet_REALPATH(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_REALPATH(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in REALPATH: {!r}'.format(data)
d = defer.maybeDeferred(self.client.realPath, path)
d.addCallback(self._cbReadLink, requestId) # Same return format
d.addErrback(self._ebStatus, requestId, b'realpath failed')
def packet_EXTENDED(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_EXTENDED(self, data):
requestId = data[:4]
data = data[4:]
extName, extData = getNS(data)
d = defer.maybeDeferred(self.client.extendedRequest, extName, extData)
d.addCallback(self._cbExtended, requestId)
d.addErrback(self._ebStatus, requestId,
b'extended ' + extName + b' failed')
def _cbExtended(self, data, requestId):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_VERSION(self, data):
version, = struct.unpack('!L', data[:4])
data = data[4:]
d = {}
while data:
k, data = getNS(data)
v, data = getNS(data)
d[k]=v
self.version = version
self.gotServerVersion(version, d)
def packet_STATUS(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_HANDLE(self, data):
d, data = self._parseRequest(data)
handle, _ = getNS(data)
d.callback(handle)
def packet_DATA(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_DATA(self, data):
d, data = self._parseRequest(data)
d.callback(getNS(data)[0])
def packet_NAME(self, data):
3
Source : filetransfer.py
with MIT License
from autofelix
with MIT License
from autofelix
def packet_NAME(self, data):
d, data = self._parseRequest(data)
count, = struct.unpack('!L', data[:4])
data = data[4:]
files = []
for i in range(count):
filename, data = getNS(data)
longname, data = getNS(data)
attrs, data = self._parseAttributes(data)
files.append((filename, longname, attrs))
d.callback(files)
def packet_ATTRS(self, data):
3
Source : forwarding.py
with MIT License
from autofelix
with MIT License
from autofelix
def unpackOpen_direct_tcpip(data):
"""Unpack the data to a usable format.
"""
connHost, rest = common.getNS(data)
if _PY3 and isinstance(connHost, bytes):
connHost = connHost.decode("utf-8")
connPort = int(struct.unpack('>L', rest[:4])[0])
origHost, rest = common.getNS(rest[4:])
if _PY3 and isinstance(origHost, bytes):
origHost = origHost.decode("utf-8")
origPort = int(struct.unpack('>L', rest[:4])[0])
return (connHost, connPort), (origHost, origPort)
unpackOpen_forwarded_tcpip = unpackOpen_direct_tcpip
3
Source : forwarding.py
with MIT License
from autofelix
with MIT License
from autofelix
def unpackGlobal_tcpip_forward(data):
host, rest = common.getNS(data)
if _PY3 and isinstance(host, bytes):
host = host.decode("utf-8")
port = int(struct.unpack('>L', rest[:4])[0])
return host, port
"""This is how the data -> eof -> close stuff /should/ work.
3
Source : session.py
with MIT License
from autofelix
with MIT License
from autofelix
def request_subsystem(self, data):
subsystem, ignored= common.getNS(data)
log.msg('asking for subsystem "%s"' % subsystem)
client = self.avatar.lookupSubsystem(subsystem, data)
if client:
pp = SSHSessionProcessProtocol(self)
proto = wrapProcessProtocol(pp)
client.makeConnection(proto)
pp.makeConnection(wrapProtocol(client))
self.client = pp
return 1
else:
log.msg('failed to get subsystem')
return 0
def request_shell(self, data):
3
Source : session.py
with MIT License
from autofelix
with MIT License
from autofelix
def request_exec(self, data):
if not self.session:
self.session = ISession(self.avatar)
f,data = common.getNS(data)
log.msg('executing command "%s"' % f)
try:
pp = SSHSessionProcessProtocol(self)
self.session.execCommand(pp, f)
except:
log.deferr()
return 0
else:
self.client = pp
return 1
def request_pty_req(self, data):
3
Source : session.py
with MIT License
from autofelix
with MIT License
from autofelix
def parseRequest_pty_req(data):
"""Parse the data from a pty-req request into usable data.
@returns: a tuple of (terminal type, (rows, cols, xpixel, ypixel), modes)
"""
term, rest = common.getNS(data)
cols, rows, xpixel, ypixel = struct.unpack('>4L', rest[: 16])
modes, ignored= common.getNS(rest[16:])
winSize = (rows, cols, xpixel, ypixel)
modes = [(ord(modes[i:i+1]), struct.unpack('>L', modes[i+1: i+5])[0])
for i in range(0, len(modes)-1, 5)]
return term, winSize, modes
def packRequest_pty_req(term, geometry, modes):
3
Source : transport.py
with MIT License
from autofelix
with MIT License
from autofelix
def ssh_DISCONNECT(self, packet):
"""
Called when we receive a MSG_DISCONNECT message. Payload::
long code
string description
This means that the other side has disconnected. Pass the message up
and disconnect ourselves.
@type packet: L{bytes}
@param packet: The message data.
"""
reasonCode = struct.unpack('>L', packet[: 4])[0]
description, foo = getNS(packet[4:])
self.receiveError(reasonCode, description)
self.transport.loseConnection()
def ssh_IGNORE(self, packet):
3
Source : transport.py
with MIT License
from autofelix
with MIT License
from autofelix
def ssh_DEBUG(self, packet):
"""
Called when we receive a MSG_DEBUG message. Payload::
bool alwaysDisplay
string message
string language
This means the other side has passed along some debugging info.
@type packet: L{bytes}
@param packet: The message data.
"""
alwaysDisplay = bool(ord(packet[0:1]))
message, lang, foo = getNS(packet[1:], 2)
self.receiveDebug(alwaysDisplay, message, lang)
def setService(self, service):
3
Source : userauth.py
with MIT License
from autofelix
with MIT License
from autofelix
def auth_password(self, packet):
"""
Password authentication. Payload::
string password
Make a UsernamePassword credential and verify it with our portal.
"""
password = getNS(packet[1:])[0]
c = credentials.UsernamePassword(self.user, password)
return self.portal.login(c, None, interfaces.IConchUser).addErrback(
self._ebPassword)
def _ebPassword(self, f):
3
Source : userauth.py
with MIT License
from autofelix
with MIT License
from autofelix
def ssh_USERAUTH_PK_OK_password(self, packet):
"""
This is MSG_USERAUTH_PASSWD_CHANGEREQ. The password given has expired.
We ask for an old password and a new password, then send both back to
the server.
"""
prompt, language, rest = getNS(packet, 2)
self._oldPass = self._newPass = None
d = self.getPassword(b'Old Password: ')
d = d.addCallbacks(self._setOldPass, self._ebAuth)
d.addCallback(lambda ignored: self.getPassword(prompt))
d.addCallbacks(self._setNewPass, self._ebAuth)
def ssh_USERAUTH_PK_OK_keyboard_interactive(self, packet):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_INIT(self, data):
version ,= struct.unpack('!L', data[:4])
self.version = min(list(self.versions) + [version])
data = data[4:]
ext = {}
while data:
ext_name, data = getNS(data)
ext_data, data = getNS(data)
ext[ext_name] = ext_data
our_ext = self.client.gotVersion(version, ext)
our_ext_data = b""
for (k,v) in our_ext.items():
our_ext_data += NS(k) + NS(v)
self.sendPacket(FXP_VERSION, struct.pack('!L', self.version) + \
our_ext_data)
def packet_OPEN(self, data):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_OPEN(self, data):
requestId = data[:4]
data = data[4:]
filename, data = getNS(data)
flags ,= struct.unpack('!L', data[:4])
data = data[4:]
attrs, data = self._parseAttributes(data)
assert data == b'', 'still have data in OPEN: %s' % repr(data)
d = defer.maybeDeferred(self.client.openFile, filename, flags, attrs)
d.addCallback(self._cbOpenFile, requestId)
d.addErrback(self._ebStatus, requestId, b"open failed")
def _cbOpenFile(self, fileObj, requestId):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_CLOSE(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
assert data == b'', 'still have data in CLOSE: %s' % repr(data)
if handle in self.openFiles:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.close)
d.addCallback(self._cbClose, handle, requestId)
d.addErrback(self._ebStatus, requestId, b"close failed")
elif handle in self.openDirs:
dirObj = self.openDirs[handle][0]
d = defer.maybeDeferred(dirObj.close)
d.addCallback(self._cbClose, handle, requestId, 1)
d.addErrback(self._ebStatus, requestId, b"close failed")
else:
self._ebClose(failure.Failure(KeyError()), requestId)
def _cbClose(self, result, handle, requestId, isDir = 0):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_READ(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
(offset, length), data = struct.unpack('!QL', data[:12]), data[12:]
assert data == b'', 'still have data in READ: %s' % repr(data)
if handle not in self.openFiles:
self._ebRead(failure.Failure(KeyError()), requestId)
else:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.readChunk, offset, length)
d.addCallback(self._cbRead, requestId)
d.addErrback(self._ebStatus, requestId, b"read failed")
def _cbRead(self, result, requestId):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_WRITE(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
offset, = struct.unpack('!Q', data[:8])
data = data[8:]
writeData, data = getNS(data)
assert data == b'', 'still have data in WRITE: %s' % repr(data)
if handle not in self.openFiles:
self._ebWrite(failure.Failure(KeyError()), requestId)
else:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.writeChunk, offset, writeData)
d.addCallback(self._cbStatus, requestId, b"write succeeded")
d.addErrback(self._ebStatus, requestId, b"write failed")
def packet_REMOVE(self, data):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_REMOVE(self, data):
requestId = data[:4]
data = data[4:]
filename, data = getNS(data)
assert data == b'', 'still have data in REMOVE: %s' % repr(data)
d = defer.maybeDeferred(self.client.removeFile, filename)
d.addCallback(self._cbStatus, requestId, b"remove succeeded")
d.addErrback(self._ebStatus, requestId, b"remove failed")
def packet_RENAME(self, data):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_RENAME(self, data):
requestId = data[:4]
data = data[4:]
oldPath, data = getNS(data)
newPath, data = getNS(data)
assert data == b'', 'still have data in RENAME: %s' % repr(data)
d = defer.maybeDeferred(self.client.renameFile, oldPath, newPath)
d.addCallback(self._cbStatus, requestId, b"rename succeeded")
d.addErrback(self._ebStatus, requestId, b"rename failed")
def packet_MKDIR(self, data):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_MKDIR(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
attrs, data = self._parseAttributes(data)
assert data == b'', 'still have data in MKDIR: %s' % repr(data)
d = defer.maybeDeferred(self.client.makeDirectory, path, attrs)
d.addCallback(self._cbStatus, requestId, b"mkdir succeeded")
d.addErrback(self._ebStatus, requestId, b"mkdir failed")
def packet_RMDIR(self, data):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_RMDIR(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in RMDIR: %s' % repr(data)
d = defer.maybeDeferred(self.client.removeDirectory, path)
d.addCallback(self._cbStatus, requestId, b"rmdir succeeded")
d.addErrback(self._ebStatus, requestId, b"rmdir failed")
def packet_OPENDIR(self, data):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_OPENDIR(self, data):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in OPENDIR: %s' % repr(data)
d = defer.maybeDeferred(self.client.openDirectory, path)
d.addCallback(self._cbOpenDirectory, requestId)
d.addErrback(self._ebStatus, requestId, b"opendir failed")
def _cbOpenDirectory(self, dirObj, requestId):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_READDIR(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
assert data == b'', 'still have data in READDIR: %s' % repr(data)
if handle not in self.openDirs:
self._ebStatus(failure.Failure(KeyError()), requestId)
else:
dirObj, dirIter = self.openDirs[handle]
d = defer.maybeDeferred(self._scanDirectory, dirIter, [])
d.addCallback(self._cbSendDirectory, requestId)
d.addErrback(self._ebStatus, requestId, b"scan directory failed")
def _scanDirectory(self, dirIter, f):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_STAT(self, data, followLinks = 1):
requestId = data[:4]
data = data[4:]
path, data = getNS(data)
assert data == b'', 'still have data in STAT/LSTAT: %s' % repr(data)
d = defer.maybeDeferred(self.client.getAttrs, path, followLinks)
d.addCallback(self._cbStat, requestId)
d.addErrback(self._ebStatus, requestId, b'stat/lstat failed')
def packet_LSTAT(self, data):
3
Source : filetransfer.py
with MIT License
from fbla-competitive-events
with MIT License
from fbla-competitive-events
def packet_FSTAT(self, data):
requestId = data[:4]
data = data[4:]
handle, data = getNS(data)
assert data == b'', 'still have data in FSTAT: %s' % repr(data)
if handle not in self.openFiles:
self._ebStatus(failure.Failure(KeyError('%s not in self.openFiles'
% handle)), requestId)
else:
fileObj = self.openFiles[handle]
d = defer.maybeDeferred(fileObj.getAttrs)
d.addCallback(self._cbStat, requestId)
d.addErrback(self._ebStatus, requestId, b'fstat failed')
def _cbStat(self, result, requestId):
See More Examples