def chdir(path):
"""chdir(path)
Change the current working directory to the specified path.
"""
realpath = _path.realpath(path)
if not _path.exists(realpath):
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), path)
if not _path.isdir(realpath):
raise OSError(errno.ENOTDIR, errno.strerror(errno.ENOTDIR), path)
sys.setCurrentWorkingDir(realpath)
def rmdir(path):
"""rmdir(path)
Remove a directory."""
f = File(sys.getPath(path))
if not f.exists():
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), path)
elif not f.isDirectory():
raise OSError(errno.ENOTDIR, errno.strerror(errno.ENOTDIR), path)
elif not f.delete():
raise OSError(0, "couldn't delete directory", path)
def __init__(self, filename, *, write=False, new=False, perror=False):
''' Open/create a CRAB file.
If `write` is True, the data in the file may be written
directly. This is not needed for ordinary section manipulation,
and should be used with extreme caution.
If `new` is True, an existing file will not be opened, but the
filename will still be used when `save()` is called.
If `perror` is True, errors will be sent to stderr as well as
raising a python exception. Note that unrecoverable errors also
exist.
'''
# forced - it exists for our benefit, after all!
flags = _lib.CRAB_FILE_FLAG_ERROR
if write:
flags |= _lib.CRAB_FILE_FLAG_WRITE
if new:
flags |= _lib.CRAB_FILE_FLAG_NEW
if perror:
flags |= _lib.CRAB_FILE_FLAG_PERROR
raw = _lib.crab_file_open(filename.encode('utf-8'), flags)
if raw == _ffi.NULL:
raise OSError(_ffi.errno, 'malloc: %s' % errno.strerror(_ffi.errno))
self._raw = _ffi.gc(raw, _lib.crab_file_close)
self.raise_error(always=False)
def fdopen(fd, mode='r', bufsize=-1):
"""fdopen(fd [, mode='r' [, bufsize]]) -> file_object
Return an open file object connected to a file descriptor.
"""
rawio = FileDescriptors.get(fd)
if (len(mode) and mode[0] or '') not in 'rwa':
raise ValueError("invalid file mode '%s'" % mode)
if rawio.closed():
raise OSError(errno.EBADF, errno.strerror(errno.EBADF))
try:
fp = FileDescriptors.wrap(rawio, mode, bufsize)
except IOError:
raise OSError(errno.EINVAL, errno.strerror(errno.EINVAL))
return fp
def stat(path):
"""stat(path) -> stat result
Perform a stat system call on the given path.
The Java stat implementation only returns a small subset of
the standard fields: size, modification time and change time.
"""
abs_path = sys.getPath(path)
try:
return stat_result.from_jnastat(_posix.stat(abs_path))
except NotImplementedError:
pass
except:
raise
f = File(abs_path)
if not f.exists():
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), path)
size = f.length()
mtime = f.lastModified() / 1000.0
mode = 0
if f.isDirectory():
mode = _stat.S_IFDIR
elif f.isFile():
mode = _stat.S_IFREG
if f.canRead():
mode = mode | _stat.S_IREAD
if f.canWrite():
mode = mode | _stat.S_IWRITE
return stat_result((mode, 0, 0, 0, 0, 0, size, mtime, mtime, 0))
def ftruncate(fd, length):
"""ftruncate(fd, length)
Truncate a file to a specified length.
"""
rawio = FileDescriptors.get(fd)
try:
rawio.truncate(length)
except Exception, e:
raise IOError(errno.EBADF, errno.strerror(errno.EBADF))
def strerror(code):
"""strerror(code) -> string
Translate an error code to a message string.
"""
if not isinstance(code, (int, long)):
raise TypeError('an integer is required')
try:
return errno.strerror(code)
except KeyError:
return 'Unknown error: %d' % code
def chmod(path, mode):
"""chmod(path, mode)
Change the access permissions of a file.
"""
# XXX no error handling for chmod in jna-posix
# catch not found errors explicitly here, for now
abs_path = sys.getPath(path)
if not File(abs_path).exists():
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), path)
_posix.chmod(abs_path, mode)
def open(filename, flag, mode=0777):
"""open(filename, flag [, mode=0777]) -> fd
Open a file (for low level IO).
"""
reading = flag & O_RDONLY
writing = flag & O_WRONLY
updating = flag & O_RDWR
creating = flag & O_CREAT
truncating = flag & O_TRUNC
exclusive = flag & O_EXCL
sync = flag & O_SYNC
appending = flag & O_APPEND
if updating and writing:
raise OSError(errno.EINVAL, errno.strerror(errno.EINVAL), filename)
if not creating and not path.exists(filename):
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), filename)
if not writing:
if updating:
writing = True
else:
reading = True
if truncating and not writing:
# Explicitly truncate, writing will truncate anyway
FileIO(filename, 'w').close()
if exclusive and creating:
try:
if not File(sys.getPath(filename)).createNewFile():
raise OSError(errno.EEXIST, errno.strerror(errno.EEXIST),
filename)
except java.io.IOException, ioe:
raise OSError(ioe)
def mkdir(path, mode='ignored'):
"""mkdir(path [, mode=0777])
Create a directory.
The optional parameter is currently ignored.
"""
# XXX: use _posix.mkdir when we can get the real errno upon failure
fp = File(sys.getPath(path))
if not fp.mkdir():
if fp.isDirectory() or fp.isFile():
err = errno.EEXIST
else:
err = 0
msg = errno.strerror(err) if err else "couldn't make directory"
raise OSError(err, msg, path)
def raise_error(self, *, always=True):
''' Utility function to turn message+errno pairs into exceptions.
Usually this library will take care of this all for you.
'''
msg_ptr = _ffi.new('char **')
no_ptr = _ffi.new('int *')
_lib.crab_file_error(self._raw, msg_ptr, no_ptr)
msg = msg_ptr[0]
no = no_ptr[0]
if msg == _ffi.NULL:
if not always:
return
raise TypeError('expected an error to exist!')
msg = _ffi.string(msg).decode('ascii')
raise OSError(no, '%s: %s' % (msg, errno.strerror(no)))
def lstat(path):
"""lstat(path) -> stat result
Like stat(path), but do not follow symbolic links.
"""
abs_path = sys.getPath(path)
try:
return stat_result.from_jnastat(_posix.lstat(abs_path))
except NotImplementedError:
pass
except:
raise
f = File(sys.getPath(path))
abs_parent = f.getAbsoluteFile().getParentFile()
if not abs_parent:
# root isn't a link
return stat(path)
can_parent = abs_parent.getCanonicalFile()
if can_parent.getAbsolutePath() == abs_parent.getAbsolutePath():
# The parent directory's absolute path is canonical..
if f.getAbsolutePath() != f.getCanonicalPath():
# but the file's absolute and canonical paths differ (a
# link)
return stat_result((_stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
# The parent directory's path is not canonical (one of the parent
# directories is a symlink). Build a new path with the parent's
# canonical path and compare the files
f = File(_path.join(can_parent.getAbsolutePath(), f.getName()))
if f.getAbsolutePath() != f.getCanonicalPath():
return stat_result((_stat.S_IFLNK, 0, 0, 0, 0, 0, 0, 0, 0, 0))
# Not a link, only now can we determine if it exists (because
# File.exists() returns False for dead links)
if not f.exists():
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), path)
return stat(path)
def errcheck(result, func, args):
if result < 0:
e = ctypes.get_errno()
raise OSError(e, errno.strerror(e))
return result
filename)
except java.io.IOException, ioe:
raise OSError(ioe)
mode = '%s%s%s%s' % (reading and 'r' or '',
(not appending and writing) and 'w' or '',
(appending and (writing or updating)) and 'a' or '',
updating and '+' or '')
if sync and (writing or updating):
from java.io import FileNotFoundException, RandomAccessFile
try:
fchannel = RandomAccessFile(sys.getPath(filename), 'rws').getChannel()
except FileNotFoundException, fnfe:
if path.isdir(filename):
raise OSError(errno.EISDIR, errno.strerror(errno.EISDIR))
raise OSError(errno.ENOENT, errno.strerror(errno.ENOENT), filename)
return FileIO(fchannel, mode)
return FileIO(filename, mode)
def read(fd, buffersize):
"""read(fd, buffersize) -> string
Read a file descriptor.
"""
from org.python.core.util import StringUtil
rawio = FileDescriptors.get(fd)
buf = _handle_oserror(rawio.read, buffersize)
return asPyString(StringUtil.fromBytes(buf))
def error(self, error, msg):
err = getattr(errno, error.name(), None)
if err is None:
raise OSError('%s: %s' % (error, msg))
raise OSError(err, errno.strerror(err), msg)
def _handle_oserror(func, *args, **kwargs):
"""Translate exceptions into OSErrors"""
try:
return func(*args, **kwargs)
except:
raise OSError(errno.EBADF, errno.strerror(errno.EBADF))
def errcheck(result, func, args):
if result < 0:
e = ctypes.get_errno()
raise OSError(e, errno.strerror(e))
return result
