134e17798c
Approved by: trasz MFC after: 1 month Sponsored by: Conclusive Engineering (development), vStack.com (funding)
1789 lines
71 KiB
Python
1789 lines
71 KiB
Python
#! /usr/bin/env python
|
|
|
|
"""
|
|
handle plan9 server <-> client connections
|
|
|
|
(We can act as either server or client.)
|
|
|
|
This code needs some doctests or other unit tests...
|
|
"""
|
|
|
|
import collections
|
|
import errno
|
|
import logging
|
|
import math
|
|
import os
|
|
import socket
|
|
import stat
|
|
import struct
|
|
import sys
|
|
import threading
|
|
import time
|
|
|
|
import lerrno
|
|
import numalloc
|
|
import p9err
|
|
import pfod
|
|
import protocol
|
|
|
|
# Timespec based timestamps, if present, have
|
|
# both seconds and nanoseconds.
|
|
Timespec = collections.namedtuple('Timespec', 'sec nsec')
|
|
|
|
# File attributes from Tgetattr, or given to Tsetattr.
|
|
# (move to protocol.py?) We use pfod here instead of
|
|
# namedtuple so that we can create instances with all-None
|
|
# fields easily.
|
|
Fileattrs = pfod.pfod('Fileattrs',
|
|
'ino mode uid gid nlink rdev size blksize blocks '
|
|
'atime mtime ctime btime gen data_version')
|
|
|
|
qt2n = protocol.qid_type2name
|
|
|
|
STD_P9_PORT=564
|
|
|
|
class P9Error(Exception):
|
|
pass
|
|
|
|
class RemoteError(P9Error):
|
|
"""
|
|
Used when the remote returns an error. We track the client
|
|
(connection instance), the operation being attempted, the
|
|
message, and an error number and type. The message may be
|
|
from the Rerror reply, or from converting the errno in a dot-L
|
|
or dot-u Rerror reply. The error number may be None if the
|
|
type is 'Rerror' rather than 'Rlerror'. The message may be
|
|
None or empty string if a non-None errno supplies the error
|
|
instead.
|
|
"""
|
|
def __init__(self, client, op, msg, etype, errno):
|
|
self.client = str(client)
|
|
self.op = op
|
|
self.msg = msg
|
|
self.etype = etype # 'Rerror' or 'Rlerror'
|
|
self.errno = errno # may be None
|
|
self.message = self._get_message()
|
|
super(RemoteError, self).__init__(self, self.message)
|
|
|
|
def __repr__(self):
|
|
return ('{0!r}({1}, {2}, {3}, {4}, '
|
|
'{5})'.format(self.__class__.__name__, self.client, self.op,
|
|
self.msg, self.errno, self.etype))
|
|
def __str__(self):
|
|
prefix = '{0}: {1}: '.format(self.client, self.op)
|
|
if self.errno: # check for "is not None", or just non-false-y?
|
|
name = {'Rerror': '.u', 'Rlerror': 'Linux'}[self.etype]
|
|
middle = '[{0} error {1}] '.format(name, self.errno)
|
|
else:
|
|
middle = ''
|
|
return '{0}{1}{2}'.format(prefix, middle, self.message)
|
|
|
|
def is_ENOTSUP(self):
|
|
if self.etype == 'Rlerror':
|
|
return self.errno == lerrno.EOPNOTSUPP
|
|
return self.errno == errno.EOPNOTSUPP
|
|
|
|
def _get_message(self):
|
|
"get message based on self.msg or self.errno"
|
|
if self.errno is not None:
|
|
return {
|
|
'Rlerror': p9err.dotl_strerror,
|
|
'Rerror' : p9err.dotu_strerror,
|
|
}[self.etype](self.errno)
|
|
return self.msg
|
|
|
|
class LocalError(P9Error):
|
|
pass
|
|
|
|
class TEError(LocalError):
|
|
pass
|
|
|
|
class P9SockIO(object):
|
|
"""
|
|
Common base for server and client, handle send and
|
|
receive to communications channel. Note that this
|
|
need not set up the channel initially, only the logger.
|
|
The channel is typically connected later. However, you
|
|
can provide one initially.
|
|
"""
|
|
def __init__(self, logger, name=None, server=None, port=STD_P9_PORT):
|
|
self.logger = logger
|
|
self.channel = None
|
|
self.name = name
|
|
self.maxio = None
|
|
self.size_coder = struct.Struct('<I')
|
|
if server is not None:
|
|
self.connect(server, port)
|
|
self.max_payload = 2**32 - self.size_coder.size
|
|
|
|
def __str__(self):
|
|
if self.name:
|
|
return self.name
|
|
return repr(self)
|
|
|
|
def get_recommended_maxio(self):
|
|
"suggest a max I/O size, for when self.maxio is 0 / unset"
|
|
return 16 * 4096
|
|
|
|
def min_maxio(self):
|
|
"return a minimum size below which we refuse to work"
|
|
return self.size_coder.size + 100
|
|
|
|
def connect(self, server, port=STD_P9_PORT):
|
|
"""
|
|
Connect to given server name / IP address.
|
|
|
|
If self.name was none, sets self.name to ip:port on success.
|
|
"""
|
|
if self.is_connected():
|
|
raise LocalError('already connected')
|
|
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
|
|
sock.connect((server, port))
|
|
if self.name is None:
|
|
if port == STD_P9_PORT:
|
|
name = server
|
|
else:
|
|
name = '{0}:{1}'.format(server, port)
|
|
else:
|
|
name = None
|
|
self.declare_connected(sock, name, None)
|
|
|
|
def is_connected(self):
|
|
"predicate: are we connected?"
|
|
return self.channel != None
|
|
|
|
def declare_connected(self, chan, name, maxio):
|
|
"""
|
|
Now available for normal protocol (size-prefixed) I/O.
|
|
|
|
Replaces chan and name and adjusts maxio, if those
|
|
parameters are not None.
|
|
"""
|
|
if maxio:
|
|
minio = self.min_maxio()
|
|
if maxio < minio:
|
|
raise LocalError('maxio={0} < minimum {1}'.format(maxio, minio))
|
|
if chan is not None:
|
|
self.channel = chan
|
|
if name is not None:
|
|
self.name = name
|
|
if maxio is not None:
|
|
self.maxio = maxio
|
|
self.max_payload = maxio - self.size_coder.size
|
|
|
|
def reduce_maxio(self, maxio):
|
|
"Reduce maximum I/O size per other-side request"
|
|
minio = self.min_maxio()
|
|
if maxio < minio:
|
|
raise LocalError('new maxio={0} < minimum {1}'.format(maxio, minio))
|
|
if maxio > self.maxio:
|
|
raise LocalError('new maxio={0} > current {1}'.format(maxio,
|
|
self.maxio))
|
|
self.maxio = maxio
|
|
self.max_payload = maxio - self.size_coder.size
|
|
|
|
def declare_disconnected(self):
|
|
"Declare comm channel dead (note: leaves self.name set!)"
|
|
self.channel = None
|
|
self.maxio = None
|
|
|
|
def shutwrite(self):
|
|
"Do a SHUT_WR on the outbound channel - can't send more"
|
|
chan = self.channel
|
|
# we're racing other threads here
|
|
try:
|
|
chan.shutdown(socket.SHUT_WR)
|
|
except (OSError, AttributeError):
|
|
pass
|
|
|
|
def shutdown(self):
|
|
"Shut down comm channel"
|
|
if self.channel:
|
|
try:
|
|
self.channel.shutdown(socket.SHUT_RDWR)
|
|
except socket.error:
|
|
pass
|
|
self.channel.close()
|
|
self.declare_disconnected()
|
|
|
|
def read(self):
|
|
"""
|
|
Try to read a complete packet.
|
|
|
|
Returns '' for EOF, as read() usually does.
|
|
|
|
If we can't even get the size, this still returns ''.
|
|
If we get a sensible size but are missing some data,
|
|
we can return a short packet. Since we know if we did
|
|
this, we also return a boolean: True means "really got a
|
|
complete packet."
|
|
|
|
Note that '' EOF always returns False: EOF is never a
|
|
complete packet.
|
|
"""
|
|
if self.channel is None:
|
|
return b'', False
|
|
size_field = self.xread(self.size_coder.size)
|
|
if len(size_field) < self.size_coder.size:
|
|
if len(size_field) == 0:
|
|
self.logger.log(logging.INFO, '%s: normal EOF', self)
|
|
else:
|
|
self.logger.log(logging.ERROR,
|
|
'%s: EOF while reading size (got %d bytes)',
|
|
self, len(size_field))
|
|
# should we raise an error here?
|
|
return b'', False
|
|
|
|
size = self.size_coder.unpack(size_field)[0] - self.size_coder.size
|
|
if size <= 0 or size > self.max_payload:
|
|
self.logger.log(logging.ERROR,
|
|
'%s: incoming size %d is insane '
|
|
'(max payload is %d)',
|
|
self, size, self.max_payload)
|
|
# indicate EOF - should we raise an error instead, here?
|
|
return b'', False
|
|
data = self.xread(size)
|
|
return data, len(data) == size
|
|
|
|
def xread(self, nbytes):
|
|
"""
|
|
Read nbytes bytes, looping if necessary. Return '' for
|
|
EOF; may return a short count if we get some data, then
|
|
EOF.
|
|
"""
|
|
assert nbytes > 0
|
|
# Try to get everything at once (should usually succeed).
|
|
# Return immediately for EOF or got-all-data.
|
|
data = self.channel.recv(nbytes)
|
|
if data == b'' or len(data) == nbytes:
|
|
return data
|
|
|
|
# Gather data fragments into an array, then join it all at
|
|
# the end.
|
|
count = len(data)
|
|
data = [data]
|
|
while count < nbytes:
|
|
more = self.channel.recv(nbytes - count)
|
|
if more == b'':
|
|
break
|
|
count += len(more)
|
|
data.append(more)
|
|
return b''.join(data)
|
|
|
|
def write(self, data):
|
|
"""
|
|
Write all the data, in the usual encoding. Note that
|
|
the length of the data, including the length of the length
|
|
itself, is already encoded in the first 4 bytes of the
|
|
data.
|
|
|
|
Raises IOError if we can't write everything.
|
|
|
|
Raises LocalError if len(data) exceeds max_payload.
|
|
"""
|
|
size = len(data)
|
|
assert size >= 4
|
|
if size > self.max_payload:
|
|
raise LocalError('data length {0} exceeds '
|
|
'maximum {1}'.format(size, self.max_payload))
|
|
self.channel.sendall(data)
|
|
|
|
def _pathcat(prefix, suffix):
|
|
"""
|
|
Concatenate paths we are using on the server side. This is
|
|
basically just prefix + / + suffix, with two complications:
|
|
|
|
It's possible we don't have a prefix path, in which case
|
|
we want the suffix without a leading slash.
|
|
|
|
It's possible that the prefix is just b'/', in which case we
|
|
want prefix + suffix.
|
|
"""
|
|
if prefix:
|
|
if prefix == b'/': # or prefix.endswith(b'/')?
|
|
return prefix + suffix
|
|
return prefix + b'/' + suffix
|
|
return suffix
|
|
|
|
class P9Client(P9SockIO):
|
|
"""
|
|
Act as client.
|
|
|
|
We need the a logger (see logging), a timeout, and a protocol
|
|
version to request. By default, we will downgrade to a lower
|
|
version if asked.
|
|
|
|
If server and port are supplied, they are remembered and become
|
|
the default for .connect() (which is still deferred).
|
|
|
|
Note that we keep a table of fid-to-path in self.live_fids,
|
|
but at any time (except while holding the lock) a fid can
|
|
be deleted entirely, and the table entry may just be True
|
|
if we have no path name. In general, we update the name
|
|
when we can.
|
|
"""
|
|
def __init__(self, logger, timeout, version, may_downgrade=True,
|
|
server=None, port=None):
|
|
super(P9Client, self).__init__(logger)
|
|
self.timeout = timeout
|
|
self.iproto = protocol.p9_version(version)
|
|
self.may_downgrade = may_downgrade
|
|
self.tagalloc = numalloc.NumAlloc(0, 65534)
|
|
self.tagstate = {}
|
|
# The next bit is slighlty dirty: perhaps we should just
|
|
# allocate NOFID out of the 2**32-1 range, so as to avoid
|
|
# "knowing" that it's 2**32-1.
|
|
self.fidalloc = numalloc.NumAlloc(0, protocol.td.NOFID - 1)
|
|
self.live_fids = {}
|
|
self.rootfid = None
|
|
self.rootqid = None
|
|
self.rthread = None
|
|
self.lock = threading.Lock()
|
|
self.new_replies = threading.Condition(self.lock)
|
|
self._monkeywrench = {}
|
|
self._server = server
|
|
self._port = port
|
|
self._unsup = {}
|
|
|
|
def get_monkey(self, what):
|
|
"check for a monkey-wrench"
|
|
with self.lock:
|
|
wrench = self._monkeywrench.get(what)
|
|
if wrench is None:
|
|
return None
|
|
if isinstance(wrench, list):
|
|
# repeats wrench[0] times, or forever if that's 0
|
|
ret = wrench[1]
|
|
if wrench[0] > 0:
|
|
wrench[0] -= 1
|
|
if wrench[0] == 0:
|
|
del self._monkeywrench[what]
|
|
else:
|
|
ret = wrench
|
|
del self._monkeywrench[what]
|
|
return ret
|
|
|
|
def set_monkey(self, what, how, repeat=None):
|
|
"""
|
|
Set a monkey-wrench. If repeat is not None it is the number of
|
|
times the wrench is applied (0 means forever, or until you call
|
|
set again with how=None). What is what to monkey-wrench, which
|
|
depends on the op. How is generally a replacement value.
|
|
"""
|
|
if how is None:
|
|
with self.lock:
|
|
try:
|
|
del self._monkeywrench[what]
|
|
except KeyError:
|
|
pass
|
|
return
|
|
if repeat is not None:
|
|
how = [repeat, how]
|
|
with self.lock:
|
|
self._monkeywrench[what] = how
|
|
|
|
def get_tag(self, for_Tversion=False):
|
|
"get next available tag ID"
|
|
with self.lock:
|
|
if for_Tversion:
|
|
tag = 65535
|
|
else:
|
|
tag = self.tagalloc.alloc()
|
|
if tag is None:
|
|
raise LocalError('all tags in use')
|
|
self.tagstate[tag] = True # ie, in use, still waiting
|
|
return tag
|
|
|
|
def set_tag(self, tag, reply):
|
|
"set the reply info for the given tag"
|
|
assert tag >= 0 and tag < 65536
|
|
with self.lock:
|
|
# check whether we're still waiting for the tag
|
|
state = self.tagstate.get(tag)
|
|
if state is True:
|
|
self.tagstate[tag] = reply # i.e., here's the answer
|
|
self.new_replies.notify_all()
|
|
return
|
|
# state must be one of these...
|
|
if state is False:
|
|
# We gave up on this tag. Reply came anyway.
|
|
self.logger.log(logging.INFO,
|
|
'%s: got tag %d = %r after timing out on it',
|
|
self, tag, reply)
|
|
self.retire_tag_locked(tag)
|
|
return
|
|
if state is None:
|
|
# We got a tag back from the server that was not
|
|
# outstanding!
|
|
self.logger.log(logging.WARNING,
|
|
'%s: got tag %d = %r when tag %d not in use!',
|
|
self, tag, reply, tag)
|
|
return
|
|
# We got a second reply before handling the first reply!
|
|
self.logger.log(logging.WARNING,
|
|
'%s: got tag %d = %r when tag %d = %r!',
|
|
self, tag, reply, tag, state)
|
|
return
|
|
|
|
def retire_tag(self, tag):
|
|
"retire the given tag - only used by the thread that handled the result"
|
|
if tag == 65535:
|
|
return
|
|
assert tag >= 0 and tag < 65535
|
|
with self.lock:
|
|
self.retire_tag_locked(tag)
|
|
|
|
def retire_tag_locked(self, tag):
|
|
"retire the given tag while holding self.lock"
|
|
# must check "in tagstate" because we can race
|
|
# with retire_all_tags.
|
|
if tag in self.tagstate:
|
|
del self.tagstate[tag]
|
|
self.tagalloc.free(tag)
|
|
|
|
def retire_all_tags(self):
|
|
"retire all tags, after connection drop"
|
|
with self.lock:
|
|
# release all tags in any state (waiting, answered, timedout)
|
|
self.tagalloc.free_multi(self.tagstate.keys())
|
|
self.tagstate = {}
|
|
self.new_replies.notify_all()
|
|
|
|
def alloc_fid(self):
|
|
"allocate new fid"
|
|
with self.lock:
|
|
fid = self.fidalloc.alloc()
|
|
self.live_fids[fid] = True
|
|
return fid
|
|
|
|
def getpath(self, fid):
|
|
"get path from fid, or return None if no path known, or not valid"
|
|
with self.lock:
|
|
path = self.live_fids.get(fid)
|
|
if path is True:
|
|
path = None
|
|
return path
|
|
|
|
def getpathX(self, fid):
|
|
"""
|
|
Much like getpath, but return <fid N, unknown path> if necessary.
|
|
If we do have a path, return its repr().
|
|
"""
|
|
path = self.getpath(fid)
|
|
if path is None:
|
|
return '<fid {0}, unknown path>'.format(fid)
|
|
return repr(path)
|
|
|
|
def setpath(self, fid, path):
|
|
"associate fid with new path (possibly from another fid)"
|
|
with self.lock:
|
|
if isinstance(path, int):
|
|
path = self.live_fids.get(path)
|
|
# path might now be None (not a live fid after all), or
|
|
# True (we have no path name), or potentially even the
|
|
# empty string (invalid for our purposes). Treat all of
|
|
# those as True, meaning "no known path".
|
|
if not path:
|
|
path = True
|
|
if self.live_fids.get(fid):
|
|
# Existing fid maps to either True or its old path.
|
|
# Set the new path (which may be just a placeholder).
|
|
self.live_fids[fid] = path
|
|
|
|
def did_rename(self, fid, ncomp, newdir=None):
|
|
"""
|
|
Announce that we renamed using a fid - we'll try to update
|
|
other fids based on this (we can't really do it perfectly).
|
|
|
|
NOTE: caller must provide a final-component.
|
|
The caller can supply the new path (and should
|
|
do so if the rename is not based on the retained path
|
|
for the supplied fid, i.e., for rename ops where fid
|
|
can move across directories). The rules:
|
|
|
|
- If newdir is None (default), we use stored path.
|
|
- Otherwise, newdir provides the best approximation
|
|
we have to the path that needs ncomp appended.
|
|
|
|
(This is based on the fact that renames happen via Twstat
|
|
or Trename, or Trenameat, which change just one tail component,
|
|
but the path names vary.)
|
|
"""
|
|
if ncomp is None:
|
|
return
|
|
opath = self.getpath(fid)
|
|
if newdir is None:
|
|
if opath is None:
|
|
return
|
|
ocomps = opath.split(b'/')
|
|
ncomps = ocomps[0:-1]
|
|
else:
|
|
ocomps = None # well, none yet anyway
|
|
ncomps = newdir.split(b'/')
|
|
ncomps.append(ncomp)
|
|
if opath is None or opath[0] != '/':
|
|
# We don't have enough information to fix anything else.
|
|
# Just store the new path and return. We have at least
|
|
# a partial path now, which is no worse than before.
|
|
npath = b'/'.join(ncomps)
|
|
with self.lock:
|
|
if fid in self.live_fids:
|
|
self.live_fids[fid] = npath
|
|
return
|
|
if ocomps is None:
|
|
ocomps = opath.split(b'/')
|
|
olen = len(ocomps)
|
|
ofinal = ocomps[olen - 1]
|
|
# Old paths is full path. Find any other fids that start
|
|
# with some or all the components in ocomps. Note that if
|
|
# we renamed /one/two/three to /four/five this winds up
|
|
# renaming files /one/a to /four/a, /one/two/b to /four/five/b,
|
|
# and so on.
|
|
with self.lock:
|
|
for fid2, path2 in self.live_fids.iteritems():
|
|
# Skip fids without byte-string paths
|
|
if not isinstance(path2, bytes):
|
|
continue
|
|
# Before splitting (which is a bit expensive), try
|
|
# a straightforward prefix match. This might give
|
|
# some false hits, e.g., prefix /one/two/threepenny
|
|
# starts with /one/two/three, but it quickly eliminates
|
|
# /raz/baz/mataz and the like.
|
|
if not path2.startswith(opath):
|
|
continue
|
|
# Split up the path, and use that to make sure that
|
|
# the final component is a full match.
|
|
parts2 = path2.split(b'/')
|
|
if parts2[olen - 1] != ofinal:
|
|
continue
|
|
# OK, path2 starts with the old (renamed) sequence.
|
|
# Replace the old components with the new ones.
|
|
# This updates the renamed fid when we come across
|
|
# it! It also handles a change in the number of
|
|
# components, thanks to Python's slice assignment.
|
|
parts2[0:olen] = ncomps
|
|
self.live_fids[fid2] = b'/'.join(parts2)
|
|
|
|
def retire_fid(self, fid):
|
|
"retire one fid"
|
|
with self.lock:
|
|
self.fidalloc.free(fid)
|
|
del self.live_fids[fid]
|
|
|
|
def retire_all_fids(self):
|
|
"return live fids to pool"
|
|
# this is useful for debugging fid leaks:
|
|
#for fid in self.live_fids:
|
|
# print 'retiring', fid, self.getpathX(fid)
|
|
with self.lock:
|
|
self.fidalloc.free_multi(self.live_fids.keys())
|
|
self.live_fids = {}
|
|
|
|
def read_responses(self):
|
|
"Read responses. This gets spun off as a thread."
|
|
while self.is_connected():
|
|
pkt, is_full = super(P9Client, self).read()
|
|
if pkt == b'':
|
|
self.shutwrite()
|
|
self.retire_all_tags()
|
|
return
|
|
if not is_full:
|
|
self.logger.log(logging.WARNING, '%s: got short packet', self)
|
|
try:
|
|
# We have one special case: if we're not yet connected
|
|
# with a version, we must unpack *as if* it's a plain
|
|
# 9P2000 response.
|
|
if self.have_version:
|
|
resp = self.proto.unpack(pkt)
|
|
else:
|
|
resp = protocol.plain.unpack(pkt)
|
|
except protocol.SequenceError as err:
|
|
self.logger.log(logging.ERROR, '%s: bad response: %s',
|
|
self, err)
|
|
try:
|
|
resp = self.proto.unpack(pkt, noerror=True)
|
|
except protocol.SequenceError:
|
|
header = self.proto.unpack_header(pkt, noerror=True)
|
|
self.logger.log(logging.ERROR,
|
|
'%s: (not even raw-decodable)', self)
|
|
self.logger.log(logging.ERROR,
|
|
'%s: header decode produced %r',
|
|
self, header)
|
|
else:
|
|
self.logger.log(logging.ERROR,
|
|
'%s: raw decode produced %r',
|
|
self, resp)
|
|
# after this kind of problem, probably need to
|
|
# shut down, but let's leave that out for a bit
|
|
else:
|
|
# NB: all protocol responses have a "tag",
|
|
# so resp['tag'] always exists.
|
|
self.logger.log(logging.DEBUG, "read_resp: tag %d resp %r", resp.tag, resp)
|
|
self.set_tag(resp.tag, resp)
|
|
|
|
def wait_for(self, tag):
|
|
"""
|
|
Wait for a response to the given tag. Return the response,
|
|
releasing the tag. If self.timeout is not None, wait at most
|
|
that long (and release the tag even if there's no reply), else
|
|
wait forever.
|
|
|
|
If this returns None, either the tag was bad initially, or
|
|
a timeout occurred, or the connection got shut down.
|
|
"""
|
|
self.logger.log(logging.DEBUG, "wait_for: tag %d", tag)
|
|
if self.timeout is None:
|
|
deadline = None
|
|
else:
|
|
deadline = time.time() + self.timeout
|
|
with self.lock:
|
|
while True:
|
|
# tagstate is True (waiting) or False (timedout) or
|
|
# a valid response, or None if we've reset the tag
|
|
# states (retire_all_tags, after connection drop).
|
|
resp = self.tagstate.get(tag, None)
|
|
if resp is None:
|
|
# out of sync, exit loop
|
|
break
|
|
if resp is True:
|
|
# still waiting for a response - wait some more
|
|
self.new_replies.wait(self.timeout)
|
|
if deadline and time.time() > deadline:
|
|
# Halt the waiting, but go around once more.
|
|
# Note we may have killed the tag by now though.
|
|
if tag in self.tagstate:
|
|
self.tagstate[tag] = False
|
|
continue
|
|
# resp is either False (timeout) or a reply.
|
|
# If resp is False, change it to None; the tag
|
|
# is now dead until we get a reply (then we
|
|
# just toss the reply).
|
|
# Otherwise, we're done with the tag: free it.
|
|
# In either case, stop now.
|
|
if resp is False:
|
|
resp = None
|
|
else:
|
|
self.tagalloc.free(tag)
|
|
del self.tagstate[tag]
|
|
break
|
|
return resp
|
|
|
|
def badresp(self, req, resp):
|
|
"""
|
|
Complain that a response was not something expected.
|
|
"""
|
|
if resp is None:
|
|
self.shutdown()
|
|
raise TEError('{0}: {1}: timeout or EOF'.format(self, req))
|
|
if isinstance(resp, protocol.rrd.Rlerror):
|
|
raise RemoteError(self, req, None, 'Rlerror', resp.ecode)
|
|
if isinstance(resp, protocol.rrd.Rerror):
|
|
if resp.errnum is None:
|
|
raise RemoteError(self, req, resp.errstr, 'Rerror', None)
|
|
raise RemoteError(self, req, None, 'Rerror', resp.errnum)
|
|
raise LocalError('{0}: {1} got response {2!r}'.format(self, req, resp))
|
|
|
|
def supports(self, req_code):
|
|
"""
|
|
Test self.proto.support(req_code) unless we've recorded that
|
|
while the protocol supports it, the client does not.
|
|
"""
|
|
return req_code not in self._unsup and self.proto.supports(req_code)
|
|
|
|
def supports_all(self, *req_codes):
|
|
"basically just all(supports(...))"
|
|
return all(self.supports(code) for code in req_codes)
|
|
|
|
def unsupported(self, req_code):
|
|
"""
|
|
Record an ENOTSUP (RemoteError was ENOTSUP) for a request.
|
|
Must be called from the op, this does not happen automatically.
|
|
(It's just an optimization.)
|
|
"""
|
|
self._unsup[req_code] = True
|
|
|
|
def connect(self, server=None, port=None):
|
|
"""
|
|
Connect to given server/port pair.
|
|
|
|
The server and port are remembered. If given as None,
|
|
the last remembered values are used. The initial
|
|
remembered values are from the creation of this client
|
|
instance.
|
|
|
|
New values are only remembered here on a *successful*
|
|
connect, however.
|
|
"""
|
|
if server is None:
|
|
server = self._server
|
|
if server is None:
|
|
raise LocalError('connect: no server specified and no default')
|
|
if port is None:
|
|
port = self._port
|
|
if port is None:
|
|
port = STD_P9_PORT
|
|
self.name = None # wipe out previous name, if any
|
|
super(P9Client, self).connect(server, port)
|
|
maxio = self.get_recommended_maxio()
|
|
self.declare_connected(None, None, maxio)
|
|
self.proto = self.iproto # revert to initial protocol
|
|
self.have_version = False
|
|
self.rthread = threading.Thread(target=self.read_responses)
|
|
self.rthread.start()
|
|
tag = self.get_tag(for_Tversion=True)
|
|
req = protocol.rrd.Tversion(tag=tag, msize=maxio,
|
|
version=self.get_monkey('version'))
|
|
super(P9Client, self).write(self.proto.pack_from(req))
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rversion):
|
|
self.shutdown()
|
|
if isinstance(resp, protocol.rrd.Rerror):
|
|
version = req.version or self.proto.get_version()
|
|
# for python3, we need to convert version to string
|
|
if not isinstance(version, str):
|
|
version = version.decode('utf-8', 'surrogateescape')
|
|
raise RemoteError(self, 'version ' + version,
|
|
resp.errstr, 'Rerror', None)
|
|
self.badresp('version', resp)
|
|
their_maxio = resp.msize
|
|
try:
|
|
self.reduce_maxio(their_maxio)
|
|
except LocalError as err:
|
|
raise LocalError('{0}: sent maxio={1}, they tried {2}: '
|
|
'{3}'.format(self, maxio, their_maxio,
|
|
err.args[0]))
|
|
if resp.version != self.proto.get_version():
|
|
if not self.may_downgrade:
|
|
self.shutdown()
|
|
raise LocalError('{0}: they only support '
|
|
'version {1!r}'.format(self, resp.version))
|
|
# raises LocalError if the version is bad
|
|
# (should we wrap it with a connect-to-{0} msg?)
|
|
self.proto = self.proto.downgrade_to(resp.version)
|
|
self._server = server
|
|
self._port = port
|
|
self.have_version = True
|
|
|
|
def attach(self, afid, uname, aname, n_uname):
|
|
"""
|
|
Attach.
|
|
|
|
Currently we don't know how to do authentication,
|
|
but we'll pass any provided afid through.
|
|
"""
|
|
if afid is None:
|
|
afid = protocol.td.NOFID
|
|
if uname is None:
|
|
uname = ''
|
|
if aname is None:
|
|
aname = ''
|
|
if n_uname is None:
|
|
n_uname = protocol.td.NONUNAME
|
|
tag = self.get_tag()
|
|
fid = self.alloc_fid()
|
|
pkt = self.proto.Tattach(tag=tag, fid=fid, afid=afid,
|
|
uname=uname, aname=aname,
|
|
n_uname=n_uname)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rattach):
|
|
self.retire_fid(fid)
|
|
self.badresp('attach', resp)
|
|
# probably should check resp.qid
|
|
self.rootfid = fid
|
|
self.rootqid = resp.qid
|
|
self.setpath(fid, b'/')
|
|
|
|
def shutdown(self):
|
|
"disconnect from server"
|
|
if self.rootfid is not None:
|
|
self.clunk(self.rootfid, ignore_error=True)
|
|
self.retire_all_tags()
|
|
self.retire_all_fids()
|
|
self.rootfid = None
|
|
self.rootqid = None
|
|
super(P9Client, self).shutdown()
|
|
if self.rthread:
|
|
self.rthread.join()
|
|
self.rthread = None
|
|
|
|
def dupfid(self, fid):
|
|
"""
|
|
Copy existing fid to a new fid.
|
|
"""
|
|
tag = self.get_tag()
|
|
newfid = self.alloc_fid()
|
|
pkt = self.proto.Twalk(tag=tag, fid=fid, newfid=newfid, nwname=0,
|
|
wname=[])
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rwalk):
|
|
self.retire_fid(newfid)
|
|
self.badresp('walk {0}'.format(self.getpathX(fid)), resp)
|
|
# Copy path too
|
|
self.setpath(newfid, fid)
|
|
return newfid
|
|
|
|
def lookup(self, fid, components):
|
|
"""
|
|
Do Twalk. Caller must provide a starting fid, which should
|
|
be rootfid to look up from '/' - we do not do / vs . here.
|
|
Caller must also provide a component-ized path (on purpose,
|
|
so that caller can provide invalid components like '' or '/').
|
|
The components must be byte-strings as well, for the same
|
|
reason.
|
|
|
|
We do allocate the new fid ourselves here, though.
|
|
|
|
There's no logic here to split up long walks (yet?).
|
|
"""
|
|
# these are too easy to screw up, so check
|
|
if self.rootfid is None:
|
|
raise LocalError('{0}: not attached'.format(self))
|
|
if (isinstance(components, (str, bytes) or
|
|
not all(isinstance(i, bytes) for i in components))):
|
|
raise LocalError('{0}: lookup: invalid '
|
|
'components {1!r}'.format(self, components))
|
|
tag = self.get_tag()
|
|
newfid = self.alloc_fid()
|
|
startpath = self.getpath(fid)
|
|
pkt = self.proto.Twalk(tag=tag, fid=fid, newfid=newfid,
|
|
nwname=len(components), wname=components)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rwalk):
|
|
self.retire_fid(newfid)
|
|
self.badresp('walk {0} in '
|
|
'{1}'.format(components, self.getpathX(fid)),
|
|
resp)
|
|
# Just because we got Rwalk does not mean we got ALL the
|
|
# way down the path. Raise OSError(ENOENT) if we're short.
|
|
if resp.nwqid > len(components):
|
|
# ??? this should be impossible. Local error? Remote error?
|
|
# OS Error?
|
|
self.clunk(newfid, ignore_error=True)
|
|
raise LocalError('{0}: walk {1} in {2} returned {3} '
|
|
'items'.format(self, components,
|
|
self.getpathX(fid), resp.nwqid))
|
|
if resp.nwqid < len(components):
|
|
self.clunk(newfid, ignore_error=True)
|
|
# Looking up a/b/c and got just a/b, c is what's missing.
|
|
# Looking up a/b/c and got just a, b is what's missing.
|
|
missing = components[resp.nwqid]
|
|
within = _pathcat(startpath, b'/'.join(components[:resp.nwqid]))
|
|
raise OSError(errno.ENOENT,
|
|
'{0}: {1} in {2}'.format(os.strerror(errno.ENOENT),
|
|
missing, within))
|
|
self.setpath(newfid, _pathcat(startpath, b'/'.join(components)))
|
|
return newfid, resp.wqid
|
|
|
|
def lookup_last(self, fid, components):
|
|
"""
|
|
Like lookup, but return only the last component's qid.
|
|
As a special case, if components is an empty list, we
|
|
handle that.
|
|
"""
|
|
rfid, wqid = self.lookup(fid, components)
|
|
if len(wqid):
|
|
return rfid, wqid[-1]
|
|
if fid == self.rootfid: # usually true, if we get here at all
|
|
return rfid, self.rootqid
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tstat(tag=tag, fid=rfid)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rstat):
|
|
self.badresp('stat {0}'.format(self.getpathX(fid)), resp)
|
|
statval = self.proto.unpack_wirestat(resp.data)
|
|
return rfid, statval.qid
|
|
|
|
def clunk(self, fid, ignore_error=False):
|
|
"issue clunk(fid)"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tclunk(tag=tag, fid=fid)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rclunk):
|
|
if ignore_error:
|
|
return
|
|
self.badresp('clunk {0}'.format(self.getpathX(fid)), resp)
|
|
self.retire_fid(fid)
|
|
|
|
def remove(self, fid, ignore_error=False):
|
|
"issue remove (old style), which also clunks fid"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tremove(tag=tag, fid=fid)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rremove):
|
|
if ignore_error:
|
|
# remove failed: still need to clunk the fid
|
|
self.clunk(fid, True)
|
|
return
|
|
self.badresp('remove {0}'.format(self.getpathX(fid)), resp)
|
|
self.retire_fid(fid)
|
|
|
|
def create(self, fid, name, perm, mode, filetype=None, extension=b''):
|
|
"""
|
|
Issue create op (note that this may be mkdir, symlink, etc).
|
|
fid is the directory in which the create happens, and for
|
|
regular files, it becomes, on success, a fid referring to
|
|
the now-open file. perm is, e.g., 0644, 0755, etc.,
|
|
optionally with additional high bits. mode is a mode
|
|
byte (e.g., protocol.td.ORDWR, or OWRONLY|OTRUNC, etc.).
|
|
|
|
As a service to callers, we take two optional arguments
|
|
specifying the file type ('dir', 'symlink', 'device',
|
|
'fifo', or 'socket') and additional info if needed.
|
|
The additional info for a symlink is the target of the
|
|
link (a byte string), and the additional info for a device
|
|
is a byte string with "b <major> <minor>" or "c <major> <minor>".
|
|
|
|
Otherwise, callers can leave filetype=None and encode the bits
|
|
into the mode (caller must still provide extension if needed).
|
|
|
|
We do NOT check whether the extension matches extra DM bits,
|
|
or that there's only one DM bit set, or whatever, since this
|
|
is a testing setup.
|
|
"""
|
|
tag = self.get_tag()
|
|
if filetype is not None:
|
|
perm |= {
|
|
'dir': protocol.td.DMDIR,
|
|
'symlink': protocol.td.DMSYMLINK,
|
|
'device': protocol.td.DMDEVICE,
|
|
'fifo': protocol.td.DMNAMEDPIPE,
|
|
'socket': protocol.td.DMSOCKET,
|
|
}[filetype]
|
|
pkt = self.proto.Tcreate(tag=tag, fid=fid, name=name,
|
|
perm=perm, mode=mode, extension=extension)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rcreate):
|
|
self.badresp('create {0} in {1}'.format(name, self.getpathX(fid)),
|
|
resp)
|
|
if resp.qid.type == protocol.td.QTFILE:
|
|
# Creating a regular file opens the file,
|
|
# thus changing the fid's path.
|
|
self.setpath(fid, _pathcat(self.getpath(fid), name))
|
|
return resp.qid, resp.iounit
|
|
|
|
def open(self, fid, mode):
|
|
"use Topen to open file or directory fid (mode is 1 byte)"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Topen(tag=tag, fid=fid, mode=mode)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Ropen):
|
|
self.badresp('open {0}'.format(self.getpathX(fid)), resp)
|
|
return resp.qid, resp.iounit
|
|
|
|
def lopen(self, fid, flags):
|
|
"use Tlopen to open file or directory fid (flags from L_O_*)"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tlopen(tag=tag, fid=fid, flags=flags)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rlopen):
|
|
self.badresp('lopen {0}'.format(self.getpathX(fid)), resp)
|
|
return resp.qid, resp.iounit
|
|
|
|
def read(self, fid, offset, count):
|
|
"read (up to) count bytes from offset, given open fid"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tread(tag=tag, fid=fid, offset=offset, count=count)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rread):
|
|
self.badresp('read {0} bytes at offset {1} in '
|
|
'{2}'.format(count, offset, self.getpathX(fid)),
|
|
resp)
|
|
return resp.data
|
|
|
|
def write(self, fid, offset, data):
|
|
"write (up to) count bytes to offset, given open fid"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Twrite(tag=tag, fid=fid, offset=offset,
|
|
count=len(data), data=data)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rwrite):
|
|
self.badresp('write {0} bytes at offset {1} in '
|
|
'{2}'.format(len(data), offset, self.getpathX(fid)),
|
|
resp)
|
|
return resp.count
|
|
|
|
# Caller may
|
|
# - pass an actual stat object, or
|
|
# - pass in all the individual to-set items by keyword, or
|
|
# - mix and match a bit: get an existing stat, then use
|
|
# keywords to override fields.
|
|
# We convert "None"s to the internal "do not change" values,
|
|
# and for diagnostic purposes, can turn "do not change" back
|
|
# to None at the end, too.
|
|
def wstat(self, fid, statobj=None, **kwargs):
|
|
if statobj is None:
|
|
statobj = protocol.td.stat()
|
|
else:
|
|
statobj = statobj._copy()
|
|
# Fields in stat that you can't send as a wstat: the
|
|
# type and qid are informative. Similarly, the
|
|
# 'extension' is an input when creating a file but
|
|
# read-only when stat-ing.
|
|
#
|
|
# It's not clear what it means to set dev, but we'll leave
|
|
# it in as an optional parameter here. fs/backend.c just
|
|
# errors out on an attempt to change it.
|
|
if self.proto == protocol.plain:
|
|
forbid = ('type', 'qid', 'extension',
|
|
'n_uid', 'n_gid', 'n_muid')
|
|
else:
|
|
forbid = ('type', 'qid', 'extension')
|
|
nochange = {
|
|
'type': 0,
|
|
'qid': protocol.td.qid(0, 0, 0),
|
|
'dev': 2**32 - 1,
|
|
'mode': 2**32 - 1,
|
|
'atime': 2**32 - 1,
|
|
'mtime': 2**32 - 1,
|
|
'length': 2**64 - 1,
|
|
'name': b'',
|
|
'uid': b'',
|
|
'gid': b'',
|
|
'muid': b'',
|
|
'extension': b'',
|
|
'n_uid': 2**32 - 1,
|
|
'n_gid': 2**32 - 1,
|
|
'n_muid': 2**32 - 1,
|
|
}
|
|
for field in statobj._fields:
|
|
if field in kwargs:
|
|
if field in forbid:
|
|
raise ValueError('cannot wstat a stat.{0}'.format(field))
|
|
statobj[field] = kwargs.pop(field)
|
|
else:
|
|
if field in forbid or statobj[field] is None:
|
|
statobj[field] = nochange[field]
|
|
if kwargs:
|
|
raise TypeError('wstat() got an unexpected keyword argument '
|
|
'{0!r}'.format(kwargs.popitem()))
|
|
|
|
data = self.proto.pack_wirestat(statobj)
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Twstat(tag=tag, fid=fid, data=data)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rwstat):
|
|
# For error viewing, switch all the do-not-change
|
|
# and can't-change fields to None.
|
|
statobj.qid = None
|
|
for field in statobj._fields:
|
|
if field in forbid:
|
|
statobj[field] = None
|
|
elif field in nochange and statobj[field] == nochange[field]:
|
|
statobj[field] = None
|
|
self.badresp('wstat {0}={1}'.format(self.getpathX(fid), statobj),
|
|
resp)
|
|
# wstat worked - change path names if needed
|
|
if statobj.name != b'':
|
|
self.did_rename(fid, statobj.name)
|
|
|
|
def readdir(self, fid, offset, count):
|
|
"read (up to) count bytes of dir data from offset, given open fid"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Treaddir(tag=tag, fid=fid, offset=offset, count=count)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rreaddir):
|
|
self.badresp('readdir {0} bytes at offset {1} in '
|
|
'{2}'.format(count, offset, self.getpathX(fid)),
|
|
resp)
|
|
return resp.data
|
|
|
|
def rename(self, fid, dfid, name):
|
|
"invoke Trename: rename file <fid> to <dfid>/name"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Trename(tag=tag, fid=fid, dfid=dfid, name=name)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rrename):
|
|
self.badresp('rename {0} to {2} in '
|
|
'{1}'.format(self.getpathX(fid),
|
|
self.getpathX(dfid), name),
|
|
resp)
|
|
self.did_rename(fid, name, self.getpath(dfid))
|
|
|
|
def renameat(self, olddirfid, oldname, newdirfid, newname):
|
|
"invoke Trenameat: rename <olddirfid>/oldname to <newdirfid>/newname"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Trenameat(tag=tag,
|
|
olddirfid=olddirfid, oldname=oldname,
|
|
newdirfid=newdirfid, newname=newname)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rrenameat):
|
|
self.badresp('rename {1} in {0} to {3} in '
|
|
'{2}'.format(oldname, self.getpathX(olddirfid),
|
|
newname, self.getpathX(newdirdfid)),
|
|
resp)
|
|
# There's no renamed *fid*, just a renamed file! So no
|
|
# call to self.did_rename().
|
|
|
|
def unlinkat(self, dirfd, name, flags):
|
|
"invoke Tunlinkat - flags should be 0 or protocol.td.AT_REMOVEDIR"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tunlinkat(tag=tag, dirfd=dirfd,
|
|
name=name, flags=flags)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Runlinkat):
|
|
self.badresp('unlinkat {0} in '
|
|
'{1}'.format(name, self.getpathX(dirfd)), resp)
|
|
|
|
def decode_stat_objects(self, bstring, noerror=False):
|
|
"""
|
|
Read on a directory returns an array of stat objects.
|
|
Note that for .u these encode extra data.
|
|
|
|
It's possible for this to produce a SequenceError, if
|
|
the data are incorrect, unless you pass noerror=True.
|
|
"""
|
|
objlist = []
|
|
offset = 0
|
|
while offset < len(bstring):
|
|
obj, offset = self.proto.unpack_wirestat(bstring, offset, noerror)
|
|
objlist.append(obj)
|
|
return objlist
|
|
|
|
def decode_readdir_dirents(self, bstring, noerror=False):
|
|
"""
|
|
Readdir on a directory returns an array of dirent objects.
|
|
|
|
It's possible for this to produce a SequenceError, if
|
|
the data are incorrect, unless you pass noerror=True.
|
|
"""
|
|
objlist = []
|
|
offset = 0
|
|
while offset < len(bstring):
|
|
obj, offset = self.proto.unpack_dirent(bstring, offset, noerror)
|
|
objlist.append(obj)
|
|
return objlist
|
|
|
|
def lcreate(self, fid, name, lflags, mode, gid):
|
|
"issue lcreate (.L)"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tlcreate(tag=tag, fid=fid, name=name,
|
|
flags=lflags, mode=mode, gid=gid)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rlcreate):
|
|
self.badresp('create {0} in '
|
|
'{1}'.format(name, self.getpathX(fid)), resp)
|
|
# Creating a file opens the file,
|
|
# thus changing the fid's path.
|
|
self.setpath(fid, _pathcat(self.getpath(fid), name))
|
|
return resp.qid, resp.iounit
|
|
|
|
def mkdir(self, dfid, name, mode, gid):
|
|
"issue mkdir (.L)"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tmkdir(tag=tag, dfid=dfid, name=name,
|
|
mode=mode, gid=gid)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rmkdir):
|
|
self.badresp('mkdir {0} in '
|
|
'{1}'.format(name, self.getpathX(dfid)), resp)
|
|
return resp.qid
|
|
|
|
# We don't call this getattr(), for the obvious reason.
|
|
def Tgetattr(self, fid, request_mask=protocol.td.GETATTR_ALL):
|
|
"issue Tgetattr.L - get what you ask for, or everything by default"
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Tgetattr(tag=tag, fid=fid, request_mask=request_mask)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rgetattr):
|
|
self.badresp('Tgetattr {0} of '
|
|
'{1}'.format(request_mask, self.getpathX(fid)), resp)
|
|
attrs = Fileattrs()
|
|
# Handle the simplest valid-bit tests:
|
|
for name in ('mode', 'nlink', 'uid', 'gid', 'rdev',
|
|
'size', 'blocks', 'gen', 'data_version'):
|
|
bit = getattr(protocol.td, 'GETATTR_' + name.upper())
|
|
if resp.valid & bit:
|
|
attrs[name] = resp[name]
|
|
# Handle the timestamps, which are timespec pairs
|
|
for name in ('atime', 'mtime', 'ctime', 'btime'):
|
|
bit = getattr(protocol.td, 'GETATTR_' + name.upper())
|
|
if resp.valid & bit:
|
|
attrs[name] = Timespec(sec=resp[name + '_sec'],
|
|
nsec=resp[name + '_nsec'])
|
|
# There is no control bit for blksize; qemu and Linux always
|
|
# provide one.
|
|
attrs.blksize = resp.blksize
|
|
# Handle ino, which comes out of qid.path
|
|
if resp.valid & protocol.td.GETATTR_INO:
|
|
attrs.ino = resp.qid.path
|
|
return attrs
|
|
|
|
# We don't call this setattr(), for the obvious reason.
|
|
# See wstat for usage. Note that time fields can be set
|
|
# with either second or nanosecond resolutions, and some
|
|
# can be set without supplying an actual timestamp, so
|
|
# this is all pretty ad-hoc.
|
|
#
|
|
# There's also one keyword-only argument, ctime=<anything>,
|
|
# which means "set SETATTR_CTIME". This has the same effect
|
|
# as supplying valid=protocol.td.SETATTR_CTIME.
|
|
def Tsetattr(self, fid, valid=0, attrs=None, **kwargs):
|
|
if attrs is None:
|
|
attrs = Fileattrs()
|
|
else:
|
|
attrs = attrs._copy()
|
|
|
|
# Start with an empty (all-zero) Tsetattr instance. We
|
|
# don't really need to zero out tag and fid, but it doesn't
|
|
# hurt. Note that if caller says, e.g., valid=SETATTR_SIZE
|
|
# but does not supply an incoming size (via "attrs" or a size=
|
|
# argument), we'll ask to set that field to 0.
|
|
attrobj = protocol.rrd.Tsetattr()
|
|
for field in attrobj._fields:
|
|
attrobj[field] = 0
|
|
|
|
# In this case, forbid means "only as kwargs": these values
|
|
# in an incoming attrs object are merely ignored.
|
|
forbid = ('ino', 'nlink', 'rdev', 'blksize', 'blocks', 'btime',
|
|
'gen', 'data_version')
|
|
for field in attrs._fields:
|
|
if field in kwargs:
|
|
if field in forbid:
|
|
raise ValueError('cannot Tsetattr {0}'.format(field))
|
|
attrs[field] = kwargs.pop(field)
|
|
elif attrs[field] is None:
|
|
continue
|
|
# OK, we're setting this attribute. Many are just
|
|
# numeric - if that's the case, we're good, set the
|
|
# field and the appropriate bit.
|
|
bitname = 'SETATTR_' + field.upper()
|
|
bit = getattr(protocol.td, bitname)
|
|
if field in ('mode', 'uid', 'gid', 'size'):
|
|
valid |= bit
|
|
attrobj[field] = attrs[field]
|
|
continue
|
|
# Timestamps are special: The value may be given as
|
|
# an integer (seconds), or as a float (we convert to
|
|
# (we convert to sec+nsec), or as a timespec (sec+nsec).
|
|
# If specified as 0, we mean "we are not providing the
|
|
# actual time, use the server's time."
|
|
#
|
|
# The ctime field's value, if any, is *ignored*.
|
|
if field in ('atime', 'mtime'):
|
|
value = attrs[field]
|
|
if hasattr(value, '__len__'):
|
|
if len(value) != 2:
|
|
raise ValueError('invalid {0}={1!r}'.format(field,
|
|
value))
|
|
sec = value[0]
|
|
nsec = value[1]
|
|
else:
|
|
sec = value
|
|
if isinstance(sec, float):
|
|
nsec, sec = math.modf(sec)
|
|
nsec = int(round(nsec * 1000000000))
|
|
else:
|
|
nsec = 0
|
|
valid |= bit
|
|
attrobj[field + '_sec'] = sec
|
|
attrobj[field + '_nsec'] = nsec
|
|
if sec != 0 or nsec != 0:
|
|
# Add SETATTR_ATIME_SET or SETATTR_MTIME_SET
|
|
# as appropriate, to tell the server to *this
|
|
# specific* time, instead of just "server now".
|
|
bit = getattr(protocol.td, bitname + '_SET')
|
|
valid |= bit
|
|
if 'ctime' in kwargs:
|
|
kwargs.pop('ctime')
|
|
valid |= protocol.td.SETATTR_CTIME
|
|
if kwargs:
|
|
raise TypeError('Tsetattr() got an unexpected keyword argument '
|
|
'{0!r}'.format(kwargs.popitem()))
|
|
|
|
tag = self.get_tag()
|
|
attrobj.valid = valid
|
|
attrobj.tag = tag
|
|
attrobj.fid = fid
|
|
pkt = self.proto.pack(attrobj)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rsetattr):
|
|
self.badresp('Tsetattr {0} {1} of '
|
|
'{2}'.format(valid, attrs, self.getpathX(fid)), resp)
|
|
|
|
def xattrwalk(self, fid, name=None):
|
|
"walk one name or all names: caller should read() the returned fid"
|
|
tag = self.get_tag()
|
|
newfid = self.alloc_fid()
|
|
pkt = self.proto.Txattrwalk(tag=tag, fid=fid, newfid=newfid,
|
|
name=name or '')
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rxattrwalk):
|
|
self.retire_fid(newfid)
|
|
self.badresp('Txattrwalk {0} of '
|
|
'{1}'.format(name, self.getpathX(fid)), resp)
|
|
if name:
|
|
self.setpath(newfid, 'xattr:' + name)
|
|
else:
|
|
self.setpath(newfid, 'xattr')
|
|
return newfid, resp.size
|
|
|
|
def _pathsplit(self, path, startdir, allow_empty=False):
|
|
"common code for uxlookup and uxopen"
|
|
if self.rootfid is None:
|
|
raise LocalError('{0}: not attached'.format(self))
|
|
if path.startswith(b'/') or startdir is None:
|
|
startdir = self.rootfid
|
|
components = [i for i in path.split(b'/') if i != b'']
|
|
if len(components) == 0 and not allow_empty:
|
|
raise LocalError('{0}: {1!r}: empty path'.format(self, path))
|
|
return components, startdir
|
|
|
|
def uxlookup(self, path, startdir=None):
|
|
"""
|
|
Unix-style lookup. That is, lookup('/foo/bar') or
|
|
lookup('foo/bar'). If startdir is not None and the
|
|
path does not start with '/' we look up from there.
|
|
"""
|
|
components, startdir = self._pathsplit(path, startdir, allow_empty=True)
|
|
return self.lookup_last(startdir, components)
|
|
|
|
def uxopen(self, path, oflags=0, perm=None, gid=None,
|
|
startdir=None, filetype=None):
|
|
"""
|
|
Unix-style open()-with-option-to-create, or mkdir().
|
|
oflags is 0/1/2 with optional os.O_CREAT, perm defaults
|
|
to 0o666 (files) or 0o777 (directories). If we use
|
|
a Linux create or mkdir op, we will need a gid, but it's
|
|
not required if you are opening an existing file.
|
|
|
|
Adds a final boolean value for "did we actually create".
|
|
Raises OSError if you ask for a directory but it's a file,
|
|
or vice versa. (??? reconsider this later)
|
|
|
|
Note that this does not handle other file types, only
|
|
directories.
|
|
"""
|
|
needtype = {
|
|
'dir': protocol.td.QTDIR,
|
|
None: protocol.td.QTFILE,
|
|
}[filetype]
|
|
omode_byte = oflags & 3 # cheating
|
|
# allow looking up /, but not creating /
|
|
allow_empty = (oflags & os.O_CREAT) == 0
|
|
components, startdir = self._pathsplit(path, startdir,
|
|
allow_empty=allow_empty)
|
|
if not (oflags & os.O_CREAT):
|
|
# Not creating, i.e., just look up and open existing file/dir.
|
|
fid, qid = self.lookup_last(startdir, components)
|
|
# If we got this far, use Topen on the fid; we did not
|
|
# create the file.
|
|
return self._uxopen2(path, needtype, fid, qid, omode_byte, False)
|
|
|
|
# Only used if using dot-L, but make sure it's always provided
|
|
# since this is generic.
|
|
if gid is None:
|
|
raise ValueError('gid is required when creating file or dir')
|
|
|
|
if len(components) > 1:
|
|
# Look up all but last component; this part must succeed.
|
|
fid, _ = self.lookup(startdir, components[:-1])
|
|
|
|
# Now proceed with the final component, using fid
|
|
# as the start dir. Remember to clunk it!
|
|
startdir = fid
|
|
clunk_startdir = True
|
|
components = components[-1:]
|
|
else:
|
|
# Use startdir as the start dir, and get a new fid.
|
|
# Do not clunk startdir!
|
|
clunk_startdir = False
|
|
fid = self.alloc_fid()
|
|
|
|
# Now look up the (single) component. If this fails,
|
|
# assume the file or directory needs to be created.
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Twalk(tag=tag, fid=startdir, newfid=fid,
|
|
nwname=1, wname=components)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if isinstance(resp, protocol.rrd.Rwalk):
|
|
if clunk_startdir:
|
|
self.clunk(startdir, ignore_error=True)
|
|
# fid successfully walked to refer to final component.
|
|
# Just need to actually open the file.
|
|
self.setpath(fid, _pathcat(self.getpath(startdir), components[0]))
|
|
qid = resp.wqid[0]
|
|
return self._uxopen2(needtype, fid, qid, omode_byte, False)
|
|
|
|
# Walk failed. If we allocated a fid, retire it. Then set
|
|
# up a fid that points to the parent directory in which to
|
|
# create the file or directory. Note that if we're creating
|
|
# a file, this fid will get changed so that it points to the
|
|
# file instead of the directory, but if we're creating a
|
|
# directory, it will be unchanged.
|
|
if fid != startdir:
|
|
self.retire_fid(fid)
|
|
fid = self.dupfid(startdir)
|
|
|
|
try:
|
|
qid, iounit = self._uxcreate(filetype, fid, components[0],
|
|
oflags, omode_byte, perm, gid)
|
|
|
|
# Success. If we created an ordinary file, we have everything
|
|
# now as create alters the incoming (dir) fid to open the file.
|
|
# Otherwise (mkdir), we need to open the file, as with
|
|
# a successful lookup.
|
|
#
|
|
# Note that qid type should match "needtype".
|
|
if filetype != 'dir':
|
|
if qid.type == needtype:
|
|
return fid, qid, iounit, True
|
|
self.clunk(fid, ignore_error=True)
|
|
raise OSError(_wrong_file_type(qid),
|
|
'{0}: server told to create {1} but '
|
|
'created {2} instead'.format(path,
|
|
qt2n(needtype),
|
|
qt2n(qid.type)))
|
|
|
|
# Success: created dir; but now need to walk to and open it.
|
|
fid = self.alloc_fid()
|
|
tag = self.get_tag()
|
|
pkt = self.proto.Twalk(tag=tag, fid=startdir, newfid=fid,
|
|
nwname=1, wname=components)
|
|
super(P9Client, self).write(pkt)
|
|
resp = self.wait_for(tag)
|
|
if not isinstance(resp, protocol.rrd.Rwalk):
|
|
self.clunk(fid, ignore_error=True)
|
|
raise OSError(errno.ENOENT,
|
|
'{0}: server made dir but then failed to '
|
|
'find it again'.format(path))
|
|
self.setpath(fid, _pathcat(self.getpath(fid), components[0]))
|
|
return self._uxopen2(needtype, fid, qid, omode_byte, True)
|
|
finally:
|
|
# Regardless of success/failure/exception, make sure
|
|
# we clunk startdir if needed.
|
|
if clunk_startdir:
|
|
self.clunk(startdir, ignore_error=True)
|
|
|
|
def _uxcreate(self, filetype, fid, name, oflags, omode_byte, perm, gid):
|
|
"""
|
|
Helper for creating dir-or-file. The fid argument is the
|
|
parent directory on input, but will point to the file (if
|
|
we're creating a file) on return. oflags only applies if
|
|
we're creating a file (even then we use omode_byte if we
|
|
are using the plan9 create op).
|
|
"""
|
|
# Try to create or mkdir as appropriate.
|
|
if self.supports_all(protocol.td.Tlcreate, protocol.td.Tmkdir):
|
|
# Use Linux style create / mkdir.
|
|
if filetype == 'dir':
|
|
if perm is None:
|
|
perm = 0o777
|
|
return self.mkdir(startdir, name, perm, gid), None
|
|
if perm is None:
|
|
perm = 0o666
|
|
lflags = flags_to_linux_flags(oflags)
|
|
return self.lcreate(fid, name, lflags, perm, gid)
|
|
|
|
if filetype == 'dir':
|
|
if perm is None:
|
|
perm = protocol.td.DMDIR | 0o777
|
|
else:
|
|
perm |= protocol.td.DMDIR
|
|
else:
|
|
if perm is None:
|
|
perm = 0o666
|
|
return self.create(fid, name, perm, omode_byte)
|
|
|
|
def _uxopen2(self, needtype, fid, qid, omode_byte, didcreate):
|
|
"common code for finishing up uxopen"
|
|
if qid.type != needtype:
|
|
self.clunk(fid, ignore_error=True)
|
|
raise OSError(_wrong_file_type(qid),
|
|
'{0}: is {1}, expected '
|
|
'{2}'.format(path, qt2n(qid.type), qt2n(needtype)))
|
|
qid, iounit = self.open(fid, omode_byte)
|
|
# ? should we re-check qid? it should not have changed
|
|
return fid, qid, iounit, didcreate
|
|
|
|
def uxmkdir(self, path, perm, gid, startdir=None):
|
|
"""
|
|
Unix-style mkdir.
|
|
|
|
The gid is only applied if we are using .L style mkdir.
|
|
"""
|
|
components, startdir = self._pathsplit(path, startdir)
|
|
clunkme = None
|
|
if len(components) > 1:
|
|
fid, _ = self.lookup(startdir, components[:-1])
|
|
startdir = fid
|
|
clunkme = fid
|
|
components = components[-1:]
|
|
try:
|
|
if self.supports(protocol.td.Tmkdir):
|
|
qid = self.mkdir(startdir, components[0], perm, gid)
|
|
else:
|
|
qid, _ = self.create(startdir, components[0],
|
|
protocol.td.DMDIR | perm,
|
|
protocol.td.OREAD)
|
|
# Should we chown/chgrp the dir?
|
|
finally:
|
|
if clunkme:
|
|
self.clunk(clunkme, ignore_error=True)
|
|
return qid
|
|
|
|
def uxreaddir(self, path, startdir=None, no_dotl=False):
|
|
"""
|
|
Read a directory to get a list of names (which may or may not
|
|
include '.' and '..').
|
|
|
|
If no_dotl is True (or anything non-false-y), this uses the
|
|
plain or .u readdir format, otherwise it uses dot-L readdir
|
|
if possible.
|
|
"""
|
|
components, startdir = self._pathsplit(path, startdir, allow_empty=True)
|
|
fid, qid = self.lookup_last(startdir, components)
|
|
try:
|
|
if qid.type != protocol.td.QTDIR:
|
|
raise OSError(errno.ENOTDIR,
|
|
'{0}: {1}'.format(self.getpathX(fid),
|
|
os.strerror(errno.ENOTDIR)))
|
|
# We need both Tlopen and Treaddir to use Treaddir.
|
|
if not self.supports_all(protocol.td.Tlopen, protocol.td.Treaddir):
|
|
no_dotl = True
|
|
if no_dotl:
|
|
statvals = self.uxreaddir_stat_fid(fid)
|
|
return [i.name for i in statvals]
|
|
|
|
dirents = self.uxreaddir_dotl_fid(fid)
|
|
return [dirent.name for dirent in dirents]
|
|
finally:
|
|
self.clunk(fid, ignore_error=True)
|
|
|
|
def uxreaddir_stat(self, path, startdir=None):
|
|
"""
|
|
Use directory read to get plan9 style stat data (plain or .u readdir).
|
|
|
|
Note that this gets a fid, then opens it, reads, then clunks
|
|
the fid. If you already have a fid, you may want to use
|
|
uxreaddir_stat_fid (but note that this opens, yet does not
|
|
clunk, the fid).
|
|
|
|
We return the qid plus the list of the contents. If the
|
|
target is not a directory, the qid will not have type QTDIR
|
|
and the contents list will be empty.
|
|
|
|
Raises OSError if this is applied to a non-directory.
|
|
"""
|
|
components, startdir = self._pathsplit(path, startdir)
|
|
fid, qid = self.lookup_last(startdir, components)
|
|
try:
|
|
if qid.type != protocol.td.QTDIR:
|
|
raise OSError(errno.ENOTDIR,
|
|
'{0}: {1}'.format(self.getpathX(fid),
|
|
os.strerror(errno.ENOTDIR)))
|
|
statvals = self.ux_readdir_stat_fid(fid)
|
|
return qid, statvals
|
|
finally:
|
|
self.clunk(fid, ignore_error=True)
|
|
|
|
def uxreaddir_stat_fid(self, fid):
|
|
"""
|
|
Implement readdir loop that extracts stat values.
|
|
This opens, but does not clunk, the given fid.
|
|
|
|
Unlike uxreaddir_stat(), if this is applied to a file,
|
|
rather than a directory, it just returns no entries.
|
|
"""
|
|
statvals = []
|
|
qid, iounit = self.open(fid, protocol.td.OREAD)
|
|
# ?? is a zero iounit allowed? if so, what do we use here?
|
|
if qid.type == protocol.td.QTDIR:
|
|
if iounit <= 0:
|
|
iounit = 512 # probably good enough
|
|
offset = 0
|
|
while True:
|
|
bstring = self.read(fid, offset, iounit)
|
|
if bstring == b'':
|
|
break
|
|
statvals.extend(self.decode_stat_objects(bstring))
|
|
offset += len(bstring)
|
|
return statvals
|
|
|
|
def uxreaddir_dotl_fid(self, fid):
|
|
"""
|
|
Implement readdir loop that uses dot-L style dirents.
|
|
This opens, but does not clunk, the given fid.
|
|
|
|
If applied to a file, the lopen should fail, because of the
|
|
L_O_DIRECTORY flag.
|
|
"""
|
|
dirents = []
|
|
qid, iounit = self.lopen(fid, protocol.td.OREAD |
|
|
protocol.td.L_O_DIRECTORY)
|
|
# ?? is a zero iounit allowed? if so, what do we use here?
|
|
# but, we want a minimum of over 256 anyway, let's go for 512
|
|
if iounit < 512:
|
|
iounit = 512
|
|
offset = 0
|
|
while True:
|
|
bstring = self.readdir(fid, offset, iounit)
|
|
if bstring == b'':
|
|
break
|
|
ents = self.decode_readdir_dirents(bstring)
|
|
if len(ents) == 0:
|
|
break # ???
|
|
dirents.extend(ents)
|
|
offset = ents[-1].offset
|
|
return dirents
|
|
|
|
def uxremove(self, path, startdir=None, filetype=None,
|
|
force=False, recurse=False):
|
|
"""
|
|
Implement rm / rmdir, with optional -rf.
|
|
if filetype is None, remove dir or file. If 'dir' or 'file'
|
|
remove only if it's one of those. If force is set, ignore
|
|
failures to remove. If recurse is True, remove contents of
|
|
directories (recursively).
|
|
|
|
File type mismatches (when filetype!=None) raise OSError (?).
|
|
"""
|
|
components, startdir = self._pathsplit(path, startdir, allow_empty=True)
|
|
# Look up all components. If
|
|
# we get an error we'll just assume the file does not
|
|
# exist (is this good?).
|
|
try:
|
|
fid, qid = self.lookup_last(startdir, components)
|
|
except RemoteError:
|
|
return
|
|
if qid.type == protocol.td.QTDIR:
|
|
# it's a directory, remove only if allowed.
|
|
# Note that we must check for "rm -r /" (len(components)==0).
|
|
if filetype == 'file':
|
|
self.clunk(fid, ignore_error=True)
|
|
raise OSError(_wrong_file_type(qid),
|
|
'{0}: is dir, expected file'.format(path))
|
|
isroot = len(components) == 0
|
|
closer = self.clunk if isroot else self.remove
|
|
if recurse:
|
|
# NB: _rm_recursive does not clunk fid
|
|
self._rm_recursive(fid, filetype, force)
|
|
# This will fail if the directory is non-empty, unless of
|
|
# course we tell it to ignore error.
|
|
closer(fid, ignore_error=force)
|
|
return
|
|
# Not a directory, call it a file (even if socket or fifo etc).
|
|
if filetype == 'dir':
|
|
self.clunk(fid, ignore_error=True)
|
|
raise OSError(_wrong_file_type(qid),
|
|
'{0}: is file, expected dir'.format(path))
|
|
self.remove(fid, ignore_error=force)
|
|
|
|
def _rm_file_by_dfid(self, dfid, name, force=False):
|
|
"""
|
|
Remove a file whose name is <name> (no path, just a component
|
|
name) whose parent directory is <dfid>. We may assume that the
|
|
file really is a file (or a socket, or fifo, or some such, but
|
|
definitely not a directory).
|
|
|
|
If force is set, ignore failures.
|
|
"""
|
|
# If we have unlinkat, that's the fast way. But it may
|
|
# return an ENOTSUP error. If it does we shouldn't bother
|
|
# doing this again.
|
|
if self.supports(protocol.td.Tunlinkat):
|
|
try:
|
|
self.unlinkat(dfid, name, 0)
|
|
return
|
|
except RemoteError as err:
|
|
if not err.is_ENOTSUP():
|
|
raise
|
|
self.unsupported(protocol.td.Tunlinkat)
|
|
# fall through to remove() op
|
|
# Fall back to lookup + remove.
|
|
try:
|
|
fid, qid = self.lookup_last(dfid, [name])
|
|
except RemoteError:
|
|
# If this has an errno we could tell ENOENT from EPERM,
|
|
# and actually raise an error for the latter. Should we?
|
|
return
|
|
self.remove(fid, ignore_error=force)
|
|
|
|
def _rm_recursive(self, dfid, filetype, force):
|
|
"""
|
|
Recursively remove a directory. filetype is probably None,
|
|
but if it's 'dir' we fail if the directory contains non-dir
|
|
files.
|
|
|
|
If force is set, ignore failures.
|
|
|
|
Although we open dfid (via the readdir.*_fid calls) we
|
|
do not clunk it here; that's the caller's job.
|
|
"""
|
|
# first, remove contents
|
|
if self.supports_all(protocol.td.Tlopen, protocol.td.Treaddir):
|
|
for entry in self.uxreaddir_dotl_fid(dfid):
|
|
if entry.name in (b'.', b'..'):
|
|
continue
|
|
fid, qid = self.lookup(dfid, [entry.name])
|
|
try:
|
|
attrs = self.Tgetattr(fid, protocol.td.GETATTR_MODE)
|
|
if stat.S_ISDIR(attrs.mode):
|
|
self.uxremove(entry.name, dfid, filetype, force, True)
|
|
else:
|
|
self.remove(fid)
|
|
fid = None
|
|
finally:
|
|
if fid is not None:
|
|
self.clunk(fid, ignore_error=True)
|
|
else:
|
|
for statobj in self.uxreaddir_stat_fid(dfid):
|
|
# skip . and ..
|
|
name = statobj.name
|
|
if name in (b'.', b'..'):
|
|
continue
|
|
if statobj.qid.type == protocol.td.QTDIR:
|
|
self.uxremove(name, dfid, filetype, force, True)
|
|
else:
|
|
self._rm_file_by_dfid(dfid, name, force)
|
|
|
|
def _wrong_file_type(qid):
|
|
"return EISDIR or ENOTDIR for passing to OSError"
|
|
if qid.type == protocol.td.QTDIR:
|
|
return errno.EISDIR
|
|
return errno.ENOTDIR
|
|
|
|
def flags_to_linux_flags(flags):
|
|
"""
|
|
Convert OS flags (O_CREAT etc) to Linux flags (protocol.td.L_O_CREAT etc).
|
|
"""
|
|
flagmap = {
|
|
os.O_CREAT: protocol.td.L_O_CREAT,
|
|
os.O_EXCL: protocol.td.L_O_EXCL,
|
|
os.O_NOCTTY: protocol.td.L_O_NOCTTY,
|
|
os.O_TRUNC: protocol.td.L_O_TRUNC,
|
|
os.O_APPEND: protocol.td.L_O_APPEND,
|
|
os.O_DIRECTORY: protocol.td.L_O_DIRECTORY,
|
|
}
|
|
|
|
result = flags & os.O_RDWR
|
|
flags &= ~os.O_RDWR
|
|
for key, value in flagmap.iteritems():
|
|
if flags & key:
|
|
result |= value
|
|
flags &= ~key
|
|
if flags:
|
|
raise ValueError('untranslated bits 0x{0:x} in os flags'.format(flags))
|
|
return result
|