#!/usr/bin/python
import struct, socket, sys
# network block device server, substitute for nbd-server. Probably slower.
# But it works! And it's probably a lot easier to improve the
# performance of this Python version than of the C version. This
# Python version is 14% of the size and perhaps 20% of the features of
# the C version. Hmm, that's not so great after all...
# Working:
# - nbd protocol
# - read/write serving up files
# - error handling
# - file size detection
# - in theory, large file support... not really
# - so_reuseaddr
# - nonforking
# Missing:
# - reporting errors to client (in particular writing and reading past end)
# - multiple clients (this probably requires copy-on-write or read-only)
# - copy on write
# - read-only
# - permission tracking
# - idle timeouts
# - running from inetd
# - filename substitution
# - partial file exports
# - exports of large files (bigger than 1/4 of RAM)
# - manual exportsize specification
# - so_keepalive
# - that "split an export file into multiple files" thing that sticks the .0
# on the end of your filename
# - backgrounding
# - daemonizing
class Error(Exception): pass
class buffsock:
"Buffered socket wrapper; always returns the amount of data you want."
def __init__(self, sock): self.sock = sock
def recv(self, nbytes):
rv = ''
while len(rv) < nbytes:
more = self.sock.recv(nbytes - len(rv))
if more == '': raise Error(nbytes)
rv += more
return rv
def send(self, astring): self.sock.send(astring)
def close(self): self.sock.close()
class debugsock:
"Debugging socket wrapper."
def __init__(self, sock): self.sock = sock
def recv(self, nbytes):
print "recv(%d) =" % nbytes,
rv = self.sock.recv(nbytes)
print `rv`
return rv
def send(self, astring):
print "send(%r) =" % astring,
rv = self.sock.send(astring)
print `rv`
return rv
def close(self):
print "close()"
self.sock.close()
def negotiation(exportsize):
"Returns initial NBD negotiation sequence for exportsize in bytes."
return ('NBDMAGIC' + '\x00\x00\x42\x02\x81\x86\x12\x53' +
struct.pack('>Q', exportsize) + '\0' * 128);
def nbd_reply(error=0, handle=1, data=''):
"Construct an NBD reply."
assert type(handle) is type('') and len(handle) == 8
return ('\x67\x44\x66\x98' + struct.pack('>L', error) + handle + data)
# possible request types
read_request = 0
write_request = 1
disconnect_request = 2
class nbd_request:
"Decodes an NBD request off the TCP socket."
def __init__(self, conn):
conn = buffsock(conn)
template = '>LL8sQL'
header = conn.recv(struct.calcsize(template))
(self.magic, self.type, self.handle, self.offset,
self.len) = struct.unpack(template, header)
if self.magic != 0x25609513: raise Error(self.magic)
if self.type == write_request:
self.data = conn.recv(self.len)
assert len(self.data) == self.len
def reply(self, error, data=''):
return nbd_reply(error=error, handle=self.handle, data=data)
def range(self):
return slice(self.offset, self.offset + self.len)
def serveclient(asock, afile):
"Serves a single client until it exits."
afile.seek(0)
abuf = list(afile.read())
asock.send(negotiation(len(abuf)))
while 1:
req = nbd_request(asock)
if req.type == read_request:
asock.send(req.reply(error=0,
data=''.join(abuf[req.range()])))
elif req.type == write_request:
abuf[req.range()] = req.data
afile.seek(req.offset)
afile.write(req.data)
afile.flush()
asock.send(req.reply(error=0))
elif req.type == disconnect_request:
asock.close()
return
def mainloop(listensock, afile):
"Serves clients forever."
while 1:
(sock, addr) = listensock.accept()
print "got conn on", addr
serveclient(sock, afile)
def main(argv):
"Given a port and a filename, serves up the file."
afile = file(argv[2], 'rb+')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('', int(argv[1])))
sock.listen(5)
mainloop(sock, afile)
if __name__ == '__main__': main(sys.argv)
