extern/encfs
1
0
Fork 0
mirror of https://github.com/vgough/encfs.git synced 2024-11-24 17:03:13 +01:00
Code Issues Packages Projects Releases Wiki Activity

Make write return the number of bytes written

Browse Source
This commit is contained in:
benrubson 2017-08-09 17:36:20 +02:00
parent a031aa208c
commit 5c90ad451e
12 changed files with 95 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
encfs/BlockFileIO.cpp
View File

@ -69,7 +69,7 @@ ssize_t BlockFileIO::cacheReadOneBlock(const IORequest &req) const {
* the lower file may have changed behind our back. */
if ((!_noCache) && (req.offset == _cache.offset) && (_cache.dataLen != 0)) {
// satisfy request from cache
int len = req.dataLen;
size_t len = req.dataLen;
if (_cache.dataLen < len) {
len = _cache.dataLen; // Don't read past EOF
}
@ -97,13 +97,13 @@ ssize_t BlockFileIO::cacheReadOneBlock(const IORequest &req) const {
return result;
}
int BlockFileIO::cacheWriteOneBlock(const IORequest &req) {
ssize_t BlockFileIO::cacheWriteOneBlock(const IORequest &req) {
// cache results of write (before pass-thru, because it may be modified
// in-place)
memcpy(_cache.data, req.data, req.dataLen);
_cache.offset = req.offset;
_cache.dataLen = req.dataLen;
int res = writeOneBlock(req);
ssize_t res = writeOneBlock(req);
if (res < 0) {
clearCache(_cache, _blockSize);
}
@ -121,7 +121,7 @@ int BlockFileIO::cacheWriteOneBlock(const IORequest &req) {
ssize_t BlockFileIO::read(const IORequest &req) const {
CHECK(_blockSize != 0);
int partialOffset = req.offset % _blockSize;
int partialOffset = req.offset % _blockSize; //can be int as _blockSize is int
off_t blockNum = req.offset / _blockSize;
ssize_t result = 0;
@ -161,7 +161,7 @@ ssize_t BlockFileIO::read(const IORequest &req) const {
}
if (readSize <= partialOffset) break; // didn't get enough bytes
int cpySize = min((size_t)(readSize - partialOffset), size);
size_t cpySize = min((size_t)(readSize - partialOffset), size);
CHECK(cpySize <= readSize);
// if we read to a temporary buffer, then move the data
@ -188,10 +188,9 @@ ssize_t BlockFileIO::read(const IORequest &req) const {
}
/**
* Returns the very first result returned by RawFileIO::write so :
* 0 in case of success, or -errno in case of failure.
* Returns the number of bytes written, or -errno in case of failure.
*/
int BlockFileIO::write(const IORequest &req) {
ssize_t BlockFileIO::write(const IORequest &req) {
CHECK(_blockSize != 0);
off_t fileSize = getSize();
@ -201,11 +200,11 @@ int BlockFileIO::write(const IORequest &req) {
// where write request begins
off_t blockNum = req.offset / _blockSize;
int partialOffset = req.offset % _blockSize;
int partialOffset = req.offset % _blockSize; //can be int as _blockSize is int
// last block of file (for testing write overlaps with file boundary)
off_t lastFileBlock = fileSize / _blockSize;
ssize_t lastBlockSize = fileSize % _blockSize;
size_t lastBlockSize = fileSize % _blockSize;
off_t lastNonEmptyBlock = lastFileBlock;
if (lastBlockSize == 0) {
@ -243,7 +242,7 @@ int BlockFileIO::write(const IORequest &req) {
blockReq.data = nullptr;
blockReq.dataLen = _blockSize;
int res = 0;
ssize_t res = 0;
size_t size = req.dataLen;
unsigned char *inPtr = req.data;
while (size != 0u) {
@ -272,10 +271,12 @@ int BlockFileIO::write(const IORequest &req) {
} else {
// have to merge with existing block data..
blockReq.dataLen = _blockSize;
if ((blockReq.dataLen = cacheReadOneBlock(blockReq)) < 0) {
res = blockReq.dataLen;
ssize_t readSize = cacheReadOneBlock(blockReq);
if (readSize < 0) {
res = readSize;
break;
}
blockReq.dataLen = readSize;
// extend data if necessary..
if (partialOffset + toCopy > blockReq.dataLen) {
@ -303,20 +304,22 @@ int BlockFileIO::write(const IORequest &req) {
MemoryPool::release(mb);
}
if (res < 0) {
return res;
}
return req.dataLen;
}
int BlockFileIO::blockSize() const { return _blockSize; }
/**
* Returns the very first result returned by RawFileIO::write so :
* 0 in case of success, or -errno in case of failure.
* Returns 0 in case of success, or -errno in case of failure.
*/
int BlockFileIO::padFile(off_t oldSize, off_t newSize, bool forceWrite) {
off_t oldLastBlock = oldSize / _blockSize;
off_t newLastBlock = newSize / _blockSize;
int newBlockSize = newSize % _blockSize;
int res = 0;
int newBlockSize = newSize % _blockSize; //can be int as _blockSize is int
ssize_t res = 0;
IORequest req;
MemBlock mb;
@ -366,7 +369,7 @@ int BlockFileIO::padFile(off_t oldSize, off_t newSize, bool forceWrite) {
// 2, pad zero blocks unless holes are allowed
if (!_allowHoles) {
for (; !(res < 0) && (oldLastBlock != newLastBlock); ++oldLastBlock) {
for (; (res >= 0) && (oldLastBlock != newLastBlock); ++oldLastBlock) {
VLOG(1) << "padding block " << oldLastBlock;
req.offset = oldLastBlock * _blockSize;
req.dataLen = _blockSize;
@ -376,7 +379,7 @@ int BlockFileIO::padFile(off_t oldSize, off_t newSize, bool forceWrite) {
}
// 3. only necessary if write is forced and block is non 0 length
if (!(res < 0) && forceWrite && newBlockSize) {
if ((res >= 0) && forceWrite && newBlockSize) {
req.offset = newLastBlock * _blockSize;
req.dataLen = newBlockSize;
memset(mb.data, 0, req.dataLen);
@ -388,11 +391,17 @@ int BlockFileIO::padFile(off_t oldSize, off_t newSize, bool forceWrite) {
MemoryPool::release(mb);
}
if (res < 0) {
return res;
}
return 0;
}
/**
* Returns 0 in case of success, or -errno in case of failure.
*/
int BlockFileIO::truncateBase(off_t size, FileIO *base) {
int partialBlock = size % _blockSize;
int partialBlock = size % _blockSize; //can be int as _blockSize is int
int res = 0;
off_t oldSize = getSize();
@ -407,7 +416,7 @@ int BlockFileIO::truncateBase(off_t size, FileIO *base) {
}
const bool forceWrite = true;
if (!(res < 0)) {
if (res == 0) {
res = padFile(oldSize, size, forceWrite);
}
} else if (size == oldSize) {
@ -424,20 +433,23 @@ int BlockFileIO::truncateBase(off_t size, FileIO *base) {
req.dataLen = _blockSize;
req.data = mb.data;
ssize_t rdSz = cacheReadOneBlock(req);
if (rdSz < 0) {
res = rdSz;
ssize_t readSize = cacheReadOneBlock(req);
if (readSize < 0) {
res = readSize;
}
// do the truncate
else if (base != nullptr) {
// do the truncate
res = base->truncate(size);
}
// write back out partial block
req.dataLen = partialBlock;
if (!(res < 0)) {
res = cacheWriteOneBlock(req);
if (res == 0) {
ssize_t writeSize = cacheWriteOneBlock(req);
if (writeSize < 0) {
res = writeSize;
}
}
MemoryPool::release(mb);

6
encfs/BlockFileIO.h
View File

@ -43,7 +43,7 @@ class BlockFileIO : public FileIO {
// implemented in terms of blocks.
virtual ssize_t read(const IORequest &req) const;
virtual int write(const IORequest &req);
virtual ssize_t write(const IORequest &req);
virtual int blockSize() const;
@ -54,10 +54,10 @@ class BlockFileIO : public FileIO {
// same as read(), except that the request.offset field is guarenteed to be
// block aligned, and the request size will not be larger then 1 block.
virtual ssize_t readOneBlock(const IORequest &req) const = 0;
virtual int writeOneBlock(const IORequest &req) = 0;
virtual ssize_t writeOneBlock(const IORequest &req) = 0;
ssize_t cacheReadOneBlock(const IORequest &req) const;
int cacheWriteOneBlock(const IORequest &req);
ssize_t cacheWriteOneBlock(const IORequest &req);
int _blockSize;
bool _allowHoles;

27
encfs/CipherFileIO.cpp
View File

@ -233,9 +233,9 @@ int CipherFileIO::initHeader() {
req.data = buf;
req.dataLen = 8;
int res = base->write(req);
if (res < 0) {
return res;
ssize_t writeSize = base->write(req);
if (writeSize < 0) {
return writeSize;
}
} else {
VLOG(1) << "base not writable, IV not written..";
@ -333,14 +333,13 @@ ssize_t CipherFileIO::readOneBlock(const IORequest &req) const {
int bs = blockSize();
off_t blockNum = req.offset / bs;
ssize_t readSize = 0;
IORequest tmpReq = req;
// adjust offset if we have a file header
if (haveHeader && !fsConfig->reverseEncryption) {
tmpReq.offset += HEADER_SIZE;
}
readSize = base->read(tmpReq);
ssize_t readSize = base->read(tmpReq);
bool ok;
if (readSize > 0) {
@ -353,9 +352,9 @@ ssize_t CipherFileIO::readOneBlock(const IORequest &req) const {
if (readSize != bs) {
VLOG(1) << "streamRead(data, " << readSize << ", IV)";
ok = streamRead(tmpReq.data, (int)readSize, blockNum ^ fileIV);
ok = streamRead(tmpReq.data, (int)readSize, blockNum ^ fileIV); //cast works because we work on a block and blocksize fit an int
} else {
ok = blockRead(tmpReq.data, (int)readSize, blockNum ^ fileIV);
ok = blockRead(tmpReq.data, (int)readSize, blockNum ^ fileIV); //cast works because we work on a block and blocksize fit an int
}
if (!ok) {
@ -370,7 +369,7 @@ ssize_t CipherFileIO::readOneBlock(const IORequest &req) const {
return readSize;
}
int CipherFileIO::writeOneBlock(const IORequest &req) {
ssize_t CipherFileIO::writeOneBlock(const IORequest &req) {
if (haveHeader && fsConfig->reverseEncryption) {
VLOG(1)
@ -390,12 +389,12 @@ int CipherFileIO::writeOneBlock(const IORequest &req) {
bool ok;
if (req.dataLen != bs) {
ok = streamWrite(req.data, (int)req.dataLen, blockNum ^ fileIV);
ok = streamWrite(req.data, (int)req.dataLen, blockNum ^ fileIV); //cast works because we work on a block and blocksize fit an int
} else {
ok = blockWrite(req.data, (int)req.dataLen, blockNum ^ fileIV);
ok = blockWrite(req.data, (int)req.dataLen, blockNum ^ fileIV); //cast works because we work on a block and blocksize fit an int
}
int res = 0;
ssize_t res = 0;
if (ok) {
if (haveHeader) {
IORequest tmpReq = req;
@ -481,7 +480,7 @@ int CipherFileIO::truncate(off_t size) {
// the wrong size..
res = BlockFileIO::truncateBase(size, nullptr);
if (!(res < 0)) {
if (res == 0) {
res = base->truncate(size + HEADER_SIZE);
}
}
@ -531,7 +530,7 @@ ssize_t CipherFileIO::read(const IORequest &origReq) const {
VLOG(1) << "Adding " << headerBytes << " header bytes";
// copy the header bytes into the data
int headerOffset = HEADER_SIZE - headerBytes;
int headerOffset = HEADER_SIZE - headerBytes; //can be int as HEADER_SIZE is int
memcpy(req.data, &headerBuf[headerOffset], headerBytes);
// the read does not want data beyond the header
@ -554,7 +553,7 @@ ssize_t CipherFileIO::read(const IORequest &origReq) const {
if (readBytes < 0) {
return readBytes; // Return error code
}
ssize_t sum = headerBytes + readBytes;
ssize_t sum = headerBytes + readBytes; //could be size_t, but as we return ssize_t...
VLOG(1) << "returning sum=" << sum;
return sum;
}

2
encfs/CipherFileIO.h
View File

@ -65,7 +65,7 @@ class CipherFileIO : public BlockFileIO {
private:
virtual ssize_t readOneBlock(const IORequest &req) const;
virtual int writeOneBlock(const IORequest &req);
virtual ssize_t writeOneBlock(const IORequest &req);
virtual int generateReverseHeader(unsigned char *data);
int initHeader();

4
encfs/FileIO.h
View File

@ -34,7 +34,7 @@ struct IORequest {
off_t offset;
// amount of bytes to read/write.
int dataLen;
size_t dataLen;
unsigned char *data;
IORequest();
@ -68,7 +68,7 @@ class FileIO {
virtual off_t getSize() const = 0;
virtual ssize_t read(const IORequest &req) const = 0;
virtual int write(const IORequest &req) = 0;
virtual ssize_t write(const IORequest &req) = 0;
virtual int truncate(off_t size) = 0;

11
encfs/FileNode.cpp
View File

@ -224,7 +224,7 @@ off_t FileNode::getSize() const {
return res;
}
ssize_t FileNode::read(off_t offset, unsigned char *data, ssize_t size) const {
ssize_t FileNode::read(off_t offset, unsigned char *data, size_t size) const {
IORequest req;
req.offset = offset;
req.dataLen = size;
@ -235,7 +235,7 @@ ssize_t FileNode::read(off_t offset, unsigned char *data, ssize_t size) const {
return io->read(req);
}
int FileNode::write(off_t offset, unsigned char *data, ssize_t size) {
ssize_t FileNode::write(off_t offset, unsigned char *data, size_t size) {
VLOG(1) << "FileNode::write offset " << offset << ", data size " << size;
IORequest req;
@ -245,7 +245,12 @@ int FileNode::write(off_t offset, unsigned char *data, ssize_t size) {
Lock _lock(mutex);
return io->write(req);
ssize_t res = io->write(req);
//Of course due to encryption we genrally write more than requested
if (res < 0) {
return res;
}
return size;
}
int FileNode::truncate(off_t size) {

4
encfs/FileNode.h
View File

@ -79,8 +79,8 @@ class FileNode {
int getAttr(struct stat *stbuf) const;
off_t getSize() const;
ssize_t read(off_t offset, unsigned char *data, ssize_t size) const;
int write(off_t offset, unsigned char *data, ssize_t size);
ssize_t read(off_t offset, unsigned char *data, size_t size) const;
ssize_t write(off_t offset, unsigned char *data, size_t size);
// truncate the file to a particular size
int truncate(off_t size);

14
encfs/MACFileIO.cpp
View File

@ -147,7 +147,7 @@ off_t MACFileIO::getSize() const {
ssize_t MACFileIO::readOneBlock(const IORequest &req) const {
int headerSize = macBytes + randBytes;
int bs = blockSize() + headerSize;
int bs = blockSize() + headerSize; //ok, should clearly fit into an int
MemBlock mb = MemoryPool::allocate(bs);
@ -214,10 +214,10 @@ ssize_t MACFileIO::readOneBlock(const IORequest &req) const {
return readSize;
}
int MACFileIO::writeOneBlock(const IORequest &req) {
ssize_t MACFileIO::writeOneBlock(const IORequest &req) {
int headerSize = macBytes + randBytes;
int bs = blockSize() + headerSize;
int bs = blockSize() + headerSize; //ok, should clearly fit into an int
// we have the unencrypted data, so we need to attach a header to it.
MemBlock mb = MemoryPool::allocate(bs);
@ -247,20 +247,20 @@ int MACFileIO::writeOneBlock(const IORequest &req) {
}
// now, we can let the next level have it..
int res = base->write(newReq);
ssize_t writeSize = base->write(newReq);
MemoryPool::release(mb);
return res;
return writeSize;
}
int MACFileIO::truncate(off_t size) {
int headerSize = macBytes + randBytes;
int bs = blockSize() + headerSize;
int bs = blockSize() + headerSize; //ok, should clearly fit into an int
int res = BlockFileIO::truncateBase(size, nullptr);
if (!(res < 0)) {
if (res == 0) {
res = base->truncate(locWithHeader(size, bs, headerSize));
}

2
encfs/MACFileIO.h
View File

@ -64,7 +64,7 @@ class MACFileIO : public BlockFileIO {
private:
virtual ssize_t readOneBlock(const IORequest &req) const;
virtual int writeOneBlock(const IORequest &req);
virtual ssize_t writeOneBlock(const IORequest &req);
std::shared_ptr<FileIO> base;
std::shared_ptr<Cipher> cipher;

4
encfs/RawFileIO.cpp
View File

@ -212,7 +212,7 @@ ssize_t RawFileIO::read(const IORequest &req) const {
return readSize;
}
int RawFileIO::write(const IORequest &req) {
ssize_t RawFileIO::write(const IORequest &req) {
rAssert(fd >= 0);
rAssert(canWrite);
@ -253,7 +253,7 @@ int RawFileIO::write(const IORequest &req) {
}
}
return 0; //No matter how many bytes we wrote, we of course already know this.
return req.dataLen;
}
return true;

2
encfs/RawFileIO.h
View File

@ -46,7 +46,7 @@ class RawFileIO : public FileIO {
virtual off_t getSize() const;
virtual ssize_t read(const IORequest &req) const;
virtual int write(const IORequest &req);
virtual ssize_t write(const IORequest &req);
virtual int truncate(off_t size);

21
encfs/encfs.cpp
View File

@ -31,6 +31,7 @@
#include <sys/time.h>
#include <unistd.h>
#include <utime.h>
#include <limits>
#ifdef linux
#include <sys/fsuid.h>
#endif
@ -686,12 +687,17 @@ int encfs_release(const char *path, struct fuse_file_info *finfo) {
}
}
int _do_read(FileNode *fnode, unsigned char *ptr, size_t size, off_t off) {
ssize_t _do_read(FileNode *fnode, unsigned char *ptr, size_t size, off_t off) {
return fnode->read(off, ptr, size);
}
int encfs_read(const char *path, char *buf, size_t size, off_t offset,
struct fuse_file_info *file) {
//Unfortunately we have to convert from ssize_t (pread) to int (fuse), so let's check this will be OK
if (size > std::numeric_limits<int>::max()) {
RLOG(ERROR) << "tried to read too much data: " << size;
return -EIO;
}
return withFileNode("read", path, file,
bind(_do_read, _1, (unsigned char *)buf, size, offset));
}
@ -708,16 +714,17 @@ int encfs_fsync(const char *path, int dataSync, struct fuse_file_info *file) {
return withFileNode("fsync", path, file, bind(_do_fsync, _1, dataSync));
}
int _do_write(FileNode *fnode, unsigned char *ptr, size_t size, off_t offset) {
int res = fnode->write(offset, ptr, size);
if (res < 0) {
return res;
}
return size;
ssize_t _do_write(FileNode *fnode, unsigned char *ptr, size_t size, off_t offset) {
return fnode->write(offset, ptr, size);
}
int encfs_write(const char *path, const char *buf, size_t size, off_t offset,
struct fuse_file_info *file) {
//Unfortunately we have to convert from ssize_t (pwrite) to int (fuse), so let's check this will be OK
if (size > std::numeric_limits<int>::max()) {
RLOG(ERROR) << "tried to write too much data: " << size;
return -EIO;
}
EncFS_Context *ctx = context();
if (isReadOnly(ctx)) {
return -EROFS;