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

modernize-use-nullptr: replace NULL, 0 with nullptr

Browse Source
This commit is contained in:
Valient Gough 2017-08-03 21:42:16 -07:00
parent 96b3f8c38d
commit b04c4124d4
No known key found for this signature in database
GPG Key ID: 33C65E29813C14DF
20 changed files with 186 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
encfs/BlockFileIO.cpp
View File

@ -131,7 +131,7 @@ ssize_t BlockFileIO::read(const IORequest &req) const {
MemBlock mb; // in case we need to allocate a temporary block.. MemBlock mb; // in case we need to allocate a temporary block..
IORequest blockReq; // for requests we may need to make IORequest blockReq; // for requests we may need to make
blockReq.dataLen = _blockSize; blockReq.dataLen = _blockSize;
blockReq.data = NULL; blockReq.data = nullptr;
unsigned char *out = req.data; unsigned char *out = req.data;
while (size) { while (size) {
@ -210,7 +210,7 @@ bool BlockFileIO::write(const IORequest &req) {
MemBlock mb; MemBlock mb;
IORequest blockReq; IORequest blockReq;
blockReq.data = NULL; blockReq.data = nullptr;
blockReq.dataLen = _blockSize; blockReq.dataLen = _blockSize;
bool ok = true; bool ok = true;

2
encfs/Cipher.cpp
View File

@ -57,7 +57,7 @@ struct CipherAlg {
}; };
typedef multimap<string, CipherAlg> CipherMap_t; typedef multimap<string, CipherAlg> CipherMap_t;
static CipherMap_t *gCipherMap = NULL; static CipherMap_t *gCipherMap = nullptr;
std::list<Cipher::CipherAlgorithm> Cipher::GetAlgorithmList( std::list<Cipher::CipherAlgorithm> Cipher::GetAlgorithmList(
bool includeHidden) { bool includeHidden) {

2
encfs/CipherFileIO.cpp
View File

@ -441,7 +441,7 @@ int CipherFileIO::truncate(off_t size) {
// can't let BlockFileIO call base->truncate(), since it would be using // can't let BlockFileIO call base->truncate(), since it would be using
// the wrong size.. // the wrong size..
res = BlockFileIO::truncateBase(size, 0); res = BlockFileIO::truncateBase(size, nullptr);
if (res == 0) base->truncate(size + HEADER_SIZE); if (res == 0) base->truncate(size + HEADER_SIZE);
} }

12
encfs/Context.cpp
View File

@ -29,9 +29,9 @@
namespace encfs { namespace encfs {
EncFS_Context::EncFS_Context() { EncFS_Context::EncFS_Context() {
pthread_cond_init(&wakeupCond, 0); pthread_cond_init(&wakeupCond, nullptr);
pthread_mutex_init(&wakeupMutex, 0); pthread_mutex_init(&wakeupMutex, nullptr);
pthread_mutex_init(&contextMutex, 0); pthread_mutex_init(&contextMutex, nullptr);
usageCount = 0; usageCount = 0;
currentFuseFh = 1; currentFuseFh = 1;
@ -109,8 +109,7 @@ void EncFS_Context::renameNode(const char *from, const char *to) {
// putNode stores "node" under key "path" in the "openFiles" map. It // putNode stores "node" under key "path" in the "openFiles" map. It
// increments the reference count if the key already exists. // increments the reference count if the key already exists.
void EncFS_Context::putNode(const char *path, void EncFS_Context::putNode(const char *path, std::shared_ptr<FileNode> node) {
std::shared_ptr<FileNode> node) {
Lock lock(contextMutex); Lock lock(contextMutex);
auto &list = openFiles[std::string(path)]; auto &list = openFiles[std::string(path)];
// The length of "list" serves as the reference count. // The length of "list" serves as the reference count.
@ -120,7 +119,8 @@ void EncFS_Context::putNode(const char *path,
// eraseNode is called by encfs_release in response to the RELEASE // eraseNode is called by encfs_release in response to the RELEASE
// FUSE-command we get from the kernel. // FUSE-command we get from the kernel.
void EncFS_Context::eraseNode(const char *path, std::shared_ptr<FileNode> fnode) { void EncFS_Context::eraseNode(const char *path,
std::shared_ptr<FileNode> fnode) {
Lock lock(contextMutex); Lock lock(contextMutex);
FileMap::iterator it = openFiles.find(std::string(path)); FileMap::iterator it = openFiles.find(std::string(path));

39
encfs/DirNode.cpp
View File

@ -94,7 +94,7 @@ static bool _nextName(struct dirent *&de, const std::shared_ptr<DIR> &dir,
} }
std::string DirTraverse::nextPlaintextName(int *fileType, ino_t *inode) { std::string DirTraverse::nextPlaintextName(int *fileType, ino_t *inode) {
struct dirent *de = 0; struct dirent *de = nullptr;
while (_nextName(de, dir, fileType, inode)) { while (_nextName(de, dir, fileType, inode)) {
try { try {
uint64_t localIv = iv; uint64_t localIv = iv;
@ -109,9 +109,9 @@ std::string DirTraverse::nextPlaintextName(int *fileType, ino_t *inode) {
} }
std::string DirTraverse::nextInvalid() { std::string DirTraverse::nextInvalid() {
struct dirent *de = 0; struct dirent *de = nullptr;
// find the first name which produces a decoding error... // find the first name which produces a decoding error...
while (_nextName(de, dir, (int *)0, (ino_t *)0)) { while (_nextName(de, dir, (int *)nullptr, (ino_t *)nullptr)) {
try { try {
uint64_t localIv = iv; uint64_t localIv = iv;
naming->decodePath(de->d_name, &localIv); naming->decodePath(de->d_name, &localIv);
@ -241,7 +241,7 @@ void RenameOp::undo() {
DirNode::DirNode(EncFS_Context *_ctx, const string &sourceDir, DirNode::DirNode(EncFS_Context *_ctx, const string &sourceDir,
const FSConfigPtr &_config) { const FSConfigPtr &_config) {
pthread_mutex_init(&mutex, 0); pthread_mutex_init(&mutex, nullptr);
Lock _lock(mutex); Lock _lock(mutex);
@ -354,7 +354,7 @@ DirTraverse DirNode::openDir(const char *plaintextPath) {
string cyName = rootDir + naming->encodePath(plaintextPath); string cyName = rootDir + naming->encodePath(plaintextPath);
DIR *dir = ::opendir(cyName.c_str()); DIR *dir = ::opendir(cyName.c_str());
if (dir == NULL) { if (dir == nullptr) {
VLOG(1) << "opendir error " << strerror(errno); VLOG(1) << "opendir error " << strerror(errno);
return DirTraverse(shared_ptr<DIR>(), 0, std::shared_ptr<NameIO>()); return DirTraverse(shared_ptr<DIR>(), 0, std::shared_ptr<NameIO>());
} else { } else {
@ -392,8 +392,8 @@ bool DirNode::genRenameList(list<RenameEl> &renameList, const char *fromP,
std::shared_ptr<DIR>(opendir(sourcePath.c_str()), DirDeleter()); std::shared_ptr<DIR>(opendir(sourcePath.c_str()), DirDeleter());
if (!dir) return false; if (!dir) return false;
struct dirent *de = NULL; struct dirent *de = nullptr;
while ((de = ::readdir(dir.get())) != NULL) { while ((de = ::readdir(dir.get())) != nullptr) {
// decode the name using the oldIV // decode the name using the oldIV
uint64_t localIV = fromIV; uint64_t localIV = fromIV;
string plainName; string plainName;
@ -475,8 +475,9 @@ bool DirNode::genRenameList(list<RenameEl> &renameList, const char *fromP,
will have changed.. will have changed..
Returns a list of renamed items on success, a null list on failure. Returns a list of renamed items on success, a null list on failure.
*/ std::shared_ptr<RenameOp> DirNode::newRenameOp(const char *fromP, */
const char *toP) { std::shared_ptr<RenameOp> DirNode::newRenameOp(const char *fromP,
const char *toP) {
// Do the rename in two stages to avoid chasing our tail // Do the rename in two stages to avoid chasing our tail
// Undo everything if we encounter an error! // Undo everything if we encounter an error!
std::shared_ptr<list<RenameEl> > renameList(new list<RenameEl>); std::shared_ptr<list<RenameEl> > renameList(new list<RenameEl>);
@ -604,10 +605,12 @@ int DirNode::link(const char *from, const char *to) {
/* /*
The node is keyed by filename, so a rename means the internal node names The node is keyed by filename, so a rename means the internal node names
must be changed. must be changed.
*/ std::shared_ptr<FileNode> DirNode::renameNode(const char *from, */
const char *to) { std::shared_ptr<FileNode> DirNode::renameNode(const char *from,
const char *to) {
return renameNode(from, to, true); return renameNode(from, to, true);
} }
std::shared_ptr<FileNode> DirNode::renameNode(const char *from, const char *to, std::shared_ptr<FileNode> DirNode::renameNode(const char *from, const char *to,
bool forwardMode) { bool forwardMode) {
std::shared_ptr<FileNode> node = findOrCreate(from); std::shared_ptr<FileNode> node = findOrCreate(from);
@ -637,18 +640,18 @@ std::shared_ptr<FileNode> DirNode::findOrCreate(const char *plainName) {
std::shared_ptr<FileNode> node; std::shared_ptr<FileNode> node;
// See if we already have a FileNode for this path. // See if we already have a FileNode for this path.
if (ctx) if (ctx) node = ctx->lookupNode(plainName);
node = ctx->lookupNode(plainName);
// If we don't, create a new one. // If we don't, create a new one.
if (!node) { if (!node) {
uint64_t iv = 0; uint64_t iv = 0;
string cipherName = naming->encodePath(plainName, &iv); string cipherName = naming->encodePath(plainName, &iv);
uint64_t fuseFh = ctx->nextFuseFh(); uint64_t fuseFh = ctx->nextFuseFh();
node.reset(new FileNode(this, fsConfig, plainName, node.reset(new FileNode(this, fsConfig, plainName,
(rootDir + cipherName).c_str(), fuseFh)); (rootDir + cipherName).c_str(), fuseFh));
if (fsConfig->config->externalIVChaining) node->setName(0, 0, iv); if (fsConfig->config->externalIVChaining)
node->setName(nullptr, nullptr, iv);
VLOG(1) << "created FileNode for " << node->cipherName(); VLOG(1) << "created FileNode for " << node->cipherName();
} }
@ -669,10 +672,10 @@ shared_ptr<FileNode> DirNode::lookupNode(const char *plainName,
"result" is set to -1 on failure, a value >= 0 on success. "result" is set to -1 on failure, a value >= 0 on success.
*/ */
std::shared_ptr<FileNode> DirNode::openNode(const char *plainName, std::shared_ptr<FileNode> DirNode::openNode(const char *plainName,
const char *requestor, int flags, const char *requestor, int flags,
int *result) { int *result) {
(void)requestor; (void)requestor;
rAssert(result != NULL); rAssert(result != nullptr);
Lock _lock(mutex); Lock _lock(mutex);
std::shared_ptr<FileNode> node = findOrCreate(plainName); std::shared_ptr<FileNode> node = findOrCreate(plainName);

9
encfs/Error.cpp
View File

@ -18,18 +18,17 @@ void initLogging(bool enable_debug, bool is_daemon) {
if (is_daemon) { if (is_daemon) {
prefix = ""; prefix = "";
encfs::rlogAction = el::base::DispatchAction::SysLog; encfs::rlogAction = el::base::DispatchAction::SysLog;
} } else {
else {
el::Loggers::addFlag(el::LoggingFlag::ColoredTerminalOutput); el::Loggers::addFlag(el::LoggingFlag::ColoredTerminalOutput);
} }
if (!enable_debug) { if (!enable_debug) {
suffix = ""; suffix = "";
defaultConf.set(el::Level::Debug, el::ConfigurationType::Enabled, "false"); defaultConf.set(el::Level::Debug, el::ConfigurationType::Enabled, "false");
} } else {
else {
el::Loggers::setVerboseLevel(1); el::Loggers::setVerboseLevel(1);
} }
defaultConf.setGlobally(el::ConfigurationType::Format, prefix + std::string("%level %msg") + suffix); defaultConf.setGlobally(el::ConfigurationType::Format,
prefix + std::string("%level %msg") + suffix);
el::Loggers::reconfigureLogger("default", defaultConf); el::Loggers::reconfigureLogger("default", defaultConf);
} }

5
encfs/FileNode.cpp
View File

@ -53,9 +53,10 @@ namespace encfs {
*/ */
FileNode::FileNode(DirNode *parent_, const FSConfigPtr &cfg, FileNode::FileNode(DirNode *parent_, const FSConfigPtr &cfg,
const char *plaintextName_, const char *cipherName_, uint64_t fuseFh) { const char *plaintextName_, const char *cipherName_,
uint64_t fuseFh) {
pthread_mutex_init(&mutex, 0); pthread_mutex_init(&mutex, nullptr);
Lock _lock(mutex); Lock _lock(mutex);

35
encfs/FileUtils.cpp
View File

@ -111,12 +111,12 @@ struct ConfigInfo {
// backward compatible support for older versions // backward compatible support for older versions
{".encfs5", Config_V5, "ENCFS5_CONFIG", readV5Config, writeV5Config, {".encfs5", Config_V5, "ENCFS5_CONFIG", readV5Config, writeV5Config,
V5SubVersion, V5SubVersionDefault}, V5SubVersion, V5SubVersionDefault},
{".encfs4", Config_V4, NULL, readV4Config, writeV4Config, 0, 0}, {".encfs4", Config_V4, nullptr, readV4Config, writeV4Config, 0, 0},
// no longer support earlier versions // no longer support earlier versions
{".encfs3", Config_V3, NULL, NULL, NULL, 0, 0}, {".encfs3", Config_V3, nullptr, nullptr, nullptr, 0, 0},
{".encfs2", Config_Prehistoric, NULL, NULL, NULL, 0, 0}, {".encfs2", Config_Prehistoric, nullptr, nullptr, nullptr, 0, 0},
{".encfs", Config_Prehistoric, NULL, NULL, NULL, 0, 0}, {".encfs", Config_Prehistoric, nullptr, nullptr, nullptr, 0, 0},
{NULL, Config_None, NULL, NULL, NULL, 0, 0}}; {nullptr, Config_None, nullptr, nullptr, nullptr, 0, 0}};
EncFS_Root::EncFS_Root() {} EncFS_Root::EncFS_Root() {}
@ -188,7 +188,7 @@ bool userAllowMkdir(int promptno, const char *path, mode_t mode) {
} }
res = fgets(answer, sizeof(answer), stdin); res = fgets(answer, sizeof(answer), stdin);
if (res != 0 && toupper(answer[0]) == 'Y') { if (res != nullptr && toupper(answer[0]) == 'Y') {
int result = mkdir(path, mode); int result = mkdir(path, mode);
if (result < 0) { if (result < 0) {
perror(_("Unable to create directory: ")); perror(_("Unable to create directory: "));
@ -235,9 +235,9 @@ ConfigType readConfig(const string &rootDir, EncFSConfig *config) {
ConfigInfo *nm = ConfigFileMapping; ConfigInfo *nm = ConfigFileMapping;
while (nm->fileName) { while (nm->fileName) {
// allow environment variable to override default config path // allow environment variable to override default config path
if (nm->environmentOverride != NULL) { if (nm->environmentOverride != nullptr) {
char *envFile = getenv(nm->environmentOverride); char *envFile = getenv(nm->environmentOverride);
if (envFile != NULL) { if (envFile != nullptr) {
if (!fileExists(envFile)) { if (!fileExists(envFile)) {
RLOG(ERROR) RLOG(ERROR)
<< "fatal: config file specified by environment does not exist: " << "fatal: config file specified by environment does not exist: "
@ -448,10 +448,10 @@ bool saveConfig(ConfigType type, const string &rootDir,
while (nm->fileName) { while (nm->fileName) {
if (nm->type == type && nm->saveFunc) { if (nm->type == type && nm->saveFunc) {
string path = rootDir + nm->fileName; string path = rootDir + nm->fileName;
if (nm->environmentOverride != NULL) { if (nm->environmentOverride != nullptr) {
// use environment file if specified.. // use environment file if specified..
const char *envFile = getenv(nm->environmentOverride); const char *envFile = getenv(nm->environmentOverride);
if (envFile != NULL) path.assign(envFile); if (envFile != nullptr) path.assign(envFile);
} }
try { try {
@ -649,7 +649,7 @@ static Cipher::CipherAlgorithm selectCipherAlgorithm() {
cout << "\n" << _("Enter the number corresponding to your choice: "); cout << "\n" << _("Enter the number corresponding to your choice: ");
char answer[10]; char answer[10];
char *res = fgets(answer, sizeof(answer), stdin); char *res = fgets(answer, sizeof(answer), stdin);
int cipherNum = (res == 0 ? 0 : atoi(answer)); int cipherNum = (res == nullptr ? 0 : atoi(answer));
cout << "\n"; cout << "\n";
if (cipherNum < 1 || cipherNum > (int)algorithms.size()) { if (cipherNum < 1 || cipherNum > (int)algorithms.size()) {
@ -692,7 +692,7 @@ static Interface selectNameCoding() {
cout << "\n" << _("Enter the number corresponding to your choice: "); cout << "\n" << _("Enter the number corresponding to your choice: ");
char answer[10]; char answer[10];
char *res = fgets(answer, sizeof(answer), stdin); char *res = fgets(answer, sizeof(answer), stdin);
int algNum = (res == 0 ? 0 : atoi(answer)); int algNum = (res == nullptr ? 0 : atoi(answer));
cout << "\n"; cout << "\n";
if (algNum < 1 || algNum > (int)algorithms.size()) { if (algNum < 1 || algNum > (int)algorithms.size()) {
@ -754,7 +754,7 @@ static int selectKeySize(const Cipher::CipherAlgorithm &alg) {
char answer[10]; char answer[10];
char *res = fgets(answer, sizeof(answer), stdin); char *res = fgets(answer, sizeof(answer), stdin);
int keySize = (res == 0 ? 0 : atoi(answer)); int keySize = (res == nullptr ? 0 : atoi(answer));
cout << "\n"; cout << "\n";
keySize = alg.keyLength.closest(keySize); keySize = alg.keyLength.closest(keySize);
@ -794,7 +794,8 @@ static int selectBlockSize(const Cipher::CipherAlgorithm &alg) {
char *res = fgets(answer, sizeof(answer), stdin); char *res = fgets(answer, sizeof(answer), stdin);
cout << "\n"; cout << "\n";
if (res != 0 && atoi(answer) >= alg.blockSize.min()) blockSize = atoi(answer); if (res != nullptr && atoi(answer) >= alg.blockSize.min())
blockSize = atoi(answer);
blockSize = alg.blockSize.closest(blockSize); blockSize = alg.blockSize.closest(blockSize);
@ -893,7 +894,7 @@ static void selectBlockMAC(int *macBytes, int *macRandBytes, bool forceMac) {
char *res = fgets(answer, sizeof(answer), stdin); char *res = fgets(answer, sizeof(answer), stdin);
cout << "\n"; cout << "\n";
randSize = (res == 0 ? 0 : atoi(answer)); randSize = (res == nullptr ? 0 : atoi(answer));
if (randSize < 0) randSize = 0; if (randSize < 0) randSize = 0;
if (randSize > 8) randSize = 8; if (randSize > 8) randSize = 8;
@ -1462,7 +1463,7 @@ CipherKey EncFSConfig::getUserKey(const std::string &passProg,
argv[0] = "/bin/sh"; argv[0] = "/bin/sh";
argv[1] = "-c"; argv[1] = "-c";
argv[2] = passProg.c_str(); argv[2] = passProg.c_str();
argv[3] = 0; argv[3] = nullptr;
// child process.. run the command and send output to fds[0] // child process.. run the command and send output to fds[0]
close(fds[1]); // we don't use the other half.. close(fds[1]); // we don't use the other half..
@ -1500,7 +1501,7 @@ CipherKey EncFSConfig::getUserKey(const std::string &passProg,
string password = readPassword(fds[1]); string password = readPassword(fds[1]);
close(fds[1]); close(fds[1]);
waitpid(pid, NULL, 0); waitpid(pid, nullptr, 0);
// convert to key.. // convert to key..
result = makeKey(password.c_str(), password.length()); result = makeKey(password.c_str(), password.length());

2
encfs/MACFileIO.cpp
View File

@ -251,7 +251,7 @@ int MACFileIO::truncate(off_t size) {
int headerSize = macBytes + randBytes; int headerSize = macBytes + randBytes;
int bs = blockSize() + headerSize; int bs = blockSize() + headerSize;
int res = BlockFileIO::truncateBase(size, 0); int res = BlockFileIO::truncateBase(size, nullptr);
if (res == 0) base->truncate(locWithHeader(size, bs, headerSize)); if (res == 0) base->truncate(locWithHeader(size, bs, headerSize));

12
encfs/MemoryPool.cpp
View File

@ -61,15 +61,15 @@ static void freeBlock(BlockList *el) {
} }
static pthread_mutex_t gMPoolMutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t gMPoolMutex = PTHREAD_MUTEX_INITIALIZER;
static BlockList *gMemPool = NULL; static BlockList *gMemPool = nullptr;
MemBlock MemoryPool::allocate(int size) { MemBlock MemoryPool::allocate(int size) {
pthread_mutex_lock(&gMPoolMutex); pthread_mutex_lock(&gMPoolMutex);
BlockList *parent = NULL; BlockList *parent = nullptr;
BlockList *block = gMemPool; BlockList *block = gMemPool;
// check if we already have a large enough block available.. // check if we already have a large enough block available..
while (block != NULL && block->size < size) { while (block != nullptr && block->size < size) {
parent = block; parent = block;
block = block->next; block = block->next;
} }
@ -84,7 +84,7 @@ MemBlock MemoryPool::allocate(int size) {
pthread_mutex_unlock(&gMPoolMutex); pthread_mutex_unlock(&gMPoolMutex);
if (!block) block = allocBlock(size); if (!block) block = allocBlock(size);
block->next = NULL; block->next = nullptr;
MemBlock result; MemBlock result;
result.data = BLOCKDATA(block); result.data = BLOCKDATA(block);
@ -115,11 +115,11 @@ void MemoryPool::destroyAll() {
pthread_mutex_lock(&gMPoolMutex); pthread_mutex_lock(&gMPoolMutex);
BlockList *block = gMemPool; BlockList *block = gMemPool;
gMemPool = NULL; gMemPool = nullptr;
pthread_mutex_unlock(&gMPoolMutex); pthread_mutex_unlock(&gMPoolMutex);
while (block != NULL) { while (block != nullptr) {
BlockList *next = block->next; BlockList *next = block->next;
freeBlock(block); freeBlock(block);

14
encfs/NameIO.cpp
View File

@ -56,7 +56,7 @@ struct NameIOAlg {
}; };
typedef multimap<string, NameIOAlg> NameIOMap_t; typedef multimap<string, NameIOAlg> NameIOMap_t;
static NameIOMap_t *gNameIOMap = 0; static NameIOMap_t *gNameIOMap = nullptr;
list<NameIO::Algorithm> NameIO::GetAlgorithmList(bool includeHidden) { list<NameIO::Algorithm> NameIO::GetAlgorithmList(bool includeHidden) {
AddSymbolReferences(); AddSymbolReferences();
@ -195,14 +195,14 @@ std::string NameIO::decodePath(const char *cipherPath) const {
std::string NameIO::_encodePath(const char *plaintextPath, uint64_t *iv) const { std::string NameIO::_encodePath(const char *plaintextPath, uint64_t *iv) const {
// if chaining is not enabled, then the iv pointer is not used.. // if chaining is not enabled, then the iv pointer is not used..
if (!chainedNameIV) iv = 0; if (!chainedNameIV) iv = nullptr;
return recodePath(plaintextPath, &NameIO::maxEncodedNameLen, return recodePath(plaintextPath, &NameIO::maxEncodedNameLen,
&NameIO::encodeName, iv); &NameIO::encodeName, iv);
} }
std::string NameIO::_decodePath(const char *cipherPath, uint64_t *iv) const { std::string NameIO::_decodePath(const char *cipherPath, uint64_t *iv) const {
// if chaining is not enabled, then the iv pointer is not used.. // if chaining is not enabled, then the iv pointer is not used..
if (!chainedNameIV) iv = 0; if (!chainedNameIV) iv = nullptr;
return recodePath(cipherPath, &NameIO::maxDecodedNameLen, &NameIO::decodeName, return recodePath(cipherPath, &NameIO::maxDecodedNameLen, &NameIO::decodeName,
iv); iv);
} }
@ -217,12 +217,12 @@ std::string NameIO::decodePath(const char *path, uint64_t *iv) const {
int NameIO::encodeName(const char *input, int length, char *output, int NameIO::encodeName(const char *input, int length, char *output,
int bufferLength) const { int bufferLength) const {
return encodeName(input, length, (uint64_t *)0, output, bufferLength); return encodeName(input, length, (uint64_t *)nullptr, output, bufferLength);
} }
int NameIO::decodeName(const char *input, int length, char *output, int NameIO::decodeName(const char *input, int length, char *output,
int bufferLength) const { int bufferLength) const {
return decodeName(input, length, (uint64_t *)0, output, bufferLength); return decodeName(input, length, (uint64_t *)nullptr, output, bufferLength);
} }
std::string NameIO::_encodeName(const char *plaintextName, int length) const { std::string NameIO::_encodeName(const char *plaintextName, int length) const {
@ -232,7 +232,7 @@ std::string NameIO::_encodeName(const char *plaintextName, int length) const {
BUFFER_INIT_S(codeBuf, 32, (unsigned int)approxLen + 1, bufSize) BUFFER_INIT_S(codeBuf, 32, (unsigned int)approxLen + 1, bufSize)
// code the name // code the name
int codedLen = encodeName(plaintextName, length, 0, codeBuf, bufSize); int codedLen = encodeName(plaintextName, length, nullptr, codeBuf, bufSize);
rAssert(codedLen <= approxLen); rAssert(codedLen <= approxLen);
rAssert(codeBuf[codedLen] == '\0'); rAssert(codeBuf[codedLen] == '\0');
@ -251,7 +251,7 @@ std::string NameIO::_decodeName(const char *encodedName, int length) const {
BUFFER_INIT_S(codeBuf, 32, (unsigned int)approxLen + 1, bufSize) BUFFER_INIT_S(codeBuf, 32, (unsigned int)approxLen + 1, bufSize)
// code the name // code the name
int codedLen = decodeName(encodedName, length, 0, codeBuf, bufSize); int codedLen = decodeName(encodedName, length, nullptr, codeBuf, bufSize);
rAssert(codedLen <= approxLen); rAssert(codedLen <= approxLen);
rAssert(codeBuf[codedLen] == '\0'); rAssert(codeBuf[codedLen] == '\0');

56
encfs/SSL_Cipher.cpp
View File

@ -36,8 +36,8 @@
#include "Interface.h" #include "Interface.h"
#include "Mutex.h" #include "Mutex.h"
#include "Range.h" #include "Range.h"
#include "SSL_Compat.h"
#include "SSL_Cipher.h" #include "SSL_Cipher.h"
#include "SSL_Compat.h"
#include "intl/gettext.h" #include "intl/gettext.h"
using namespace std; using namespace std;
@ -66,7 +66,7 @@ inline int MIN(int a, int b) { return (a < b) ? a : b; }
int BytesToKey(int keyLen, int ivLen, const EVP_MD *md, int BytesToKey(int keyLen, int ivLen, const EVP_MD *md,
const unsigned char *data, int dataLen, unsigned int rounds, const unsigned char *data, int dataLen, unsigned int rounds,
unsigned char *key, unsigned char *iv) { unsigned char *key, unsigned char *iv) {
if (data == NULL || dataLen == 0) if (data == nullptr || dataLen == 0)
return 0; // OpenSSL returns nkey here, but why? It is a failure.. return 0; // OpenSSL returns nkey here, but why? It is a failure..
unsigned char mdBuf[EVP_MAX_MD_SIZE]; unsigned char mdBuf[EVP_MAX_MD_SIZE];
@ -79,13 +79,13 @@ int BytesToKey(int keyLen, int ivLen, const EVP_MD *md,
EVP_MD_CTX_init(cx); EVP_MD_CTX_init(cx);
for (;;) { for (;;) {
EVP_DigestInit_ex(cx, md, NULL); EVP_DigestInit_ex(cx, md, nullptr);
if (addmd++) EVP_DigestUpdate(cx, mdBuf, mds); if (addmd++) EVP_DigestUpdate(cx, mdBuf, mds);
EVP_DigestUpdate(cx, data, dataLen); EVP_DigestUpdate(cx, data, dataLen);
EVP_DigestFinal_ex(cx, mdBuf, &mds); EVP_DigestFinal_ex(cx, mdBuf, &mds);
for (unsigned int i = 1; i < rounds; ++i) { for (unsigned int i = 1; i < rounds; ++i) {
EVP_DigestInit_ex(cx, md, NULL); EVP_DigestInit_ex(cx, md, nullptr);
EVP_DigestUpdate(cx, mdBuf, mds); EVP_DigestUpdate(cx, mdBuf, mds);
EVP_DigestFinal_ex(cx, mdBuf, &mds); EVP_DigestFinal_ex(cx, mdBuf, &mds);
} }
@ -125,13 +125,13 @@ int TimedPBKDF2(const char *pass, int passlen, const unsigned char *salt,
timeval start, end; timeval start, end;
for (;;) { for (;;) {
gettimeofday(&start, 0); gettimeofday(&start, nullptr);
int res = int res =
PKCS5_PBKDF2_HMAC_SHA1(pass, passlen, const_cast<unsigned char *>(salt), PKCS5_PBKDF2_HMAC_SHA1(pass, passlen, const_cast<unsigned char *>(salt),
saltlen, iter, keylen, out); saltlen, iter, keylen, out);
if (res != 1) return -1; if (res != 1) return -1;
gettimeofday(&end, 0); gettimeofday(&end, nullptr);
long delta = time_diff(end, start); long delta = time_diff(end, start);
if (delta < desiredPDFTime / 8) { if (delta < desiredPDFTime / 8) {
@ -189,8 +189,8 @@ static std::shared_ptr<Cipher> NewAESCipher(const Interface &iface,
keyLen = AESKeyRange.closest(keyLen); keyLen = AESKeyRange.closest(keyLen);
const EVP_CIPHER *blockCipher = 0; const EVP_CIPHER *blockCipher = nullptr;
const EVP_CIPHER *streamCipher = 0; const EVP_CIPHER *streamCipher = nullptr;
switch (keyLen) { switch (keyLen) {
case 128: case 128:
@ -244,7 +244,7 @@ class SSLKey : public AbstractCipherKey {
SSLKey::SSLKey(int keySize_, int ivLength_) { SSLKey::SSLKey(int keySize_, int ivLength_) {
this->keySize = keySize_; this->keySize = keySize_;
this->ivLength = ivLength_; this->ivLength = ivLength_;
pthread_mutex_init(&mutex, 0); pthread_mutex_init(&mutex, nullptr);
buffer = (unsigned char *)OPENSSL_malloc(keySize + ivLength); buffer = (unsigned char *)OPENSSL_malloc(keySize + ivLength);
memset(buffer, 0, keySize + ivLength); memset(buffer, 0, keySize + ivLength);
@ -272,7 +272,7 @@ SSLKey::~SSLKey() {
keySize = 0; keySize = 0;
ivLength = 0; ivLength = 0;
buffer = 0; buffer = nullptr;
EVP_CIPHER_CTX_free(block_enc); EVP_CIPHER_CTX_free(block_enc);
EVP_CIPHER_CTX_free(block_dec); EVP_CIPHER_CTX_free(block_dec);
@ -295,10 +295,10 @@ void initKey(const std::shared_ptr<SSLKey> &key, const EVP_CIPHER *_blockCipher,
Lock lock(key->mutex); Lock lock(key->mutex);
// initialize the cipher context once so that we don't have to do it for // initialize the cipher context once so that we don't have to do it for
// every block.. // every block..
EVP_EncryptInit_ex(key->block_enc, _blockCipher, NULL, NULL, NULL); EVP_EncryptInit_ex(key->block_enc, _blockCipher, nullptr, nullptr, nullptr);
EVP_DecryptInit_ex(key->block_dec, _blockCipher, NULL, NULL, NULL); EVP_DecryptInit_ex(key->block_dec, _blockCipher, nullptr, nullptr, nullptr);
EVP_EncryptInit_ex(key->stream_enc, _streamCipher, NULL, NULL, NULL); EVP_EncryptInit_ex(key->stream_enc, _streamCipher, nullptr, nullptr, nullptr);
EVP_DecryptInit_ex(key->stream_dec, _streamCipher, NULL, NULL, NULL); EVP_DecryptInit_ex(key->stream_dec, _streamCipher, nullptr, nullptr, nullptr);
EVP_CIPHER_CTX_set_key_length(key->block_enc, _keySize); EVP_CIPHER_CTX_set_key_length(key->block_enc, _keySize);
EVP_CIPHER_CTX_set_key_length(key->block_dec, _keySize); EVP_CIPHER_CTX_set_key_length(key->block_dec, _keySize);
@ -310,12 +310,12 @@ void initKey(const std::shared_ptr<SSLKey> &key, const EVP_CIPHER *_blockCipher,
EVP_CIPHER_CTX_set_padding(key->stream_enc, 0); EVP_CIPHER_CTX_set_padding(key->stream_enc, 0);
EVP_CIPHER_CTX_set_padding(key->stream_dec, 0); EVP_CIPHER_CTX_set_padding(key->stream_dec, 0);
EVP_EncryptInit_ex(key->block_enc, NULL, NULL, KeyData(key), NULL); EVP_EncryptInit_ex(key->block_enc, nullptr, nullptr, KeyData(key), nullptr);
EVP_DecryptInit_ex(key->block_dec, NULL, NULL, KeyData(key), NULL); EVP_DecryptInit_ex(key->block_dec, nullptr, nullptr, KeyData(key), nullptr);
EVP_EncryptInit_ex(key->stream_enc, NULL, NULL, KeyData(key), NULL); EVP_EncryptInit_ex(key->stream_enc, nullptr, nullptr, KeyData(key), nullptr);
EVP_DecryptInit_ex(key->stream_dec, NULL, NULL, KeyData(key), NULL); EVP_DecryptInit_ex(key->stream_dec, nullptr, nullptr, KeyData(key), nullptr);
HMAC_Init_ex(key->mac_ctx, KeyData(key), _keySize, EVP_sha1(), 0); HMAC_Init_ex(key->mac_ctx, KeyData(key), _keySize, EVP_sha1(), nullptr);
} }
SSL_Cipher::SSL_Cipher(const Interface &iface_, const Interface &realIface_, SSL_Cipher::SSL_Cipher(const Interface &iface_, const Interface &realIface_,
@ -401,7 +401,7 @@ CipherKey SSL_Cipher::newKey(const char *password, int passwdLength) {
} }
} else { } else {
// for backward compatibility with filesystems created with 1:0 // for backward compatibility with filesystems created with 1:0
bytes = EVP_BytesToKey(_blockCipher, EVP_sha1(), NULL, bytes = EVP_BytesToKey(_blockCipher, EVP_sha1(), nullptr,
(unsigned char *)password, passwdLength, 16, (unsigned char *)password, passwdLength, 16,
KeyData(key), IVData(key)); KeyData(key), IVData(key));
} }
@ -456,7 +456,7 @@ static uint64_t _checksum_64(SSLKey *key, const unsigned char *data,
unsigned char md[EVP_MAX_MD_SIZE]; unsigned char md[EVP_MAX_MD_SIZE];
unsigned int mdLen = EVP_MAX_MD_SIZE; unsigned int mdLen = EVP_MAX_MD_SIZE;
HMAC_Init_ex(key->mac_ctx, 0, 0, 0, 0); HMAC_Init_ex(key->mac_ctx, nullptr, 0, nullptr, nullptr);
HMAC_Update(key->mac_ctx, data, dataLen); HMAC_Update(key->mac_ctx, data, dataLen);
if (chainedIV) { if (chainedIV) {
// toss in the chained IV as well // toss in the chained IV as well
@ -637,7 +637,7 @@ void SSL_Cipher::setIVec(unsigned char *ivec, uint64_t seed,
} }
// combine ivec and seed with HMAC // combine ivec and seed with HMAC
HMAC_Init_ex(key->mac_ctx, 0, 0, 0, 0); HMAC_Init_ex(key->mac_ctx, nullptr, 0, nullptr, nullptr);
HMAC_Update(key->mac_ctx, ivec, _ivLength); HMAC_Update(key->mac_ctx, ivec, _ivLength);
HMAC_Update(key->mac_ctx, md, 8); HMAC_Update(key->mac_ctx, md, 8);
HMAC_Final(key->mac_ctx, md, &mdLen); HMAC_Final(key->mac_ctx, md, &mdLen);
@ -732,7 +732,7 @@ bool SSL_Cipher::streamEncode(unsigned char *buf, int size, uint64_t iv64,
shuffleBytes(buf, size); shuffleBytes(buf, size);
setIVec(ivec, iv64, key); setIVec(ivec, iv64, key);
EVP_EncryptInit_ex(key->stream_enc, NULL, NULL, NULL, ivec); EVP_EncryptInit_ex(key->stream_enc, nullptr, nullptr, nullptr, ivec);
EVP_EncryptUpdate(key->stream_enc, buf, &dstLen, buf, size); EVP_EncryptUpdate(key->stream_enc, buf, &dstLen, buf, size);
EVP_EncryptFinal_ex(key->stream_enc, buf + dstLen, &tmpLen); EVP_EncryptFinal_ex(key->stream_enc, buf + dstLen, &tmpLen);
@ -740,7 +740,7 @@ bool SSL_Cipher::streamEncode(unsigned char *buf, int size, uint64_t iv64,
shuffleBytes(buf, size); shuffleBytes(buf, size);
setIVec(ivec, iv64 + 1, key); setIVec(ivec, iv64 + 1, key);
EVP_EncryptInit_ex(key->stream_enc, NULL, NULL, NULL, ivec); EVP_EncryptInit_ex(key->stream_enc, nullptr, nullptr, nullptr, ivec);
EVP_EncryptUpdate(key->stream_enc, buf, &dstLen, buf, size); EVP_EncryptUpdate(key->stream_enc, buf, &dstLen, buf, size);
EVP_EncryptFinal_ex(key->stream_enc, buf + dstLen, &tmpLen); EVP_EncryptFinal_ex(key->stream_enc, buf + dstLen, &tmpLen);
@ -766,7 +766,7 @@ bool SSL_Cipher::streamDecode(unsigned char *buf, int size, uint64_t iv64,
int dstLen = 0, tmpLen = 0; int dstLen = 0, tmpLen = 0;
setIVec(ivec, iv64 + 1, key); setIVec(ivec, iv64 + 1, key);
EVP_DecryptInit_ex(key->stream_dec, NULL, NULL, NULL, ivec); EVP_DecryptInit_ex(key->stream_dec, nullptr, nullptr, nullptr, ivec);
EVP_DecryptUpdate(key->stream_dec, buf, &dstLen, buf, size); EVP_DecryptUpdate(key->stream_dec, buf, &dstLen, buf, size);
EVP_DecryptFinal_ex(key->stream_dec, buf + dstLen, &tmpLen); EVP_DecryptFinal_ex(key->stream_dec, buf + dstLen, &tmpLen);
@ -774,7 +774,7 @@ bool SSL_Cipher::streamDecode(unsigned char *buf, int size, uint64_t iv64,
flipBytes(buf, size); flipBytes(buf, size);
setIVec(ivec, iv64, key); setIVec(ivec, iv64, key);
EVP_DecryptInit_ex(key->stream_dec, NULL, NULL, NULL, ivec); EVP_DecryptInit_ex(key->stream_dec, nullptr, nullptr, nullptr, ivec);
EVP_DecryptUpdate(key->stream_dec, buf, &dstLen, buf, size); EVP_DecryptUpdate(key->stream_dec, buf, &dstLen, buf, size);
EVP_DecryptFinal_ex(key->stream_dec, buf + dstLen, &tmpLen); EVP_DecryptFinal_ex(key->stream_dec, buf + dstLen, &tmpLen);
@ -808,7 +808,7 @@ bool SSL_Cipher::blockEncode(unsigned char *buf, int size, uint64_t iv64,
int dstLen = 0, tmpLen = 0; int dstLen = 0, tmpLen = 0;
setIVec(ivec, iv64, key); setIVec(ivec, iv64, key);
EVP_EncryptInit_ex(key->block_enc, NULL, NULL, NULL, ivec); EVP_EncryptInit_ex(key->block_enc, nullptr, nullptr, nullptr, ivec);
EVP_EncryptUpdate(key->block_enc, buf, &dstLen, buf, size); EVP_EncryptUpdate(key->block_enc, buf, &dstLen, buf, size);
EVP_EncryptFinal_ex(key->block_enc, buf + dstLen, &tmpLen); EVP_EncryptFinal_ex(key->block_enc, buf + dstLen, &tmpLen);
dstLen += tmpLen; dstLen += tmpLen;
@ -840,7 +840,7 @@ bool SSL_Cipher::blockDecode(unsigned char *buf, int size, uint64_t iv64,
int dstLen = 0, tmpLen = 0; int dstLen = 0, tmpLen = 0;
setIVec(ivec, iv64, key); setIVec(ivec, iv64, key);
EVP_DecryptInit_ex(key->block_dec, NULL, NULL, NULL, ivec); EVP_DecryptInit_ex(key->block_dec, nullptr, nullptr, nullptr, ivec);
EVP_DecryptUpdate(key->block_dec, buf, &dstLen, buf, size); EVP_DecryptUpdate(key->block_dec, buf, &dstLen, buf, size);
EVP_DecryptFinal_ex(key->block_dec, buf + dstLen, &tmpLen); EVP_DecryptFinal_ex(key->block_dec, buf + dstLen, &tmpLen);
dstLen += tmpLen; dstLen += tmpLen;

8
encfs/XmlReader.cpp
View File

@ -22,8 +22,8 @@
#include <algorithm> // for remove_if #include <algorithm> // for remove_if
#include <cstring> // for NULL #include <cstring> // for NULL
#include <memory> // for shared_ptr
#include <fstream> // for ifstream #include <fstream> // for ifstream
#include <memory> // for shared_ptr
#include <sstream> // for ostringstream #include <sstream> // for ostringstream
#include <tinyxml2.h> // for XMLElement, XMLNode, XMLDocument (ptr only) #include <tinyxml2.h> // for XMLElement, XMLNode, XMLDocument (ptr only)
@ -121,7 +121,7 @@ bool XmlValue::read(const char *path, Interface *out) const {
std::string safeValueForNode(const tinyxml2::XMLElement *element) { std::string safeValueForNode(const tinyxml2::XMLElement *element) {
std::string value; std::string value;
if (element == NULL) return value; if (element == nullptr) return value;
const tinyxml2::XMLNode *child = element->FirstChild(); const tinyxml2::XMLNode *child = element->FirstChild();
if (child) { if (child) {
@ -180,13 +180,13 @@ bool XmlReader::load(const char *fileName) {
XmlValuePtr XmlReader::operator[](const char *name) const { XmlValuePtr XmlReader::operator[](const char *name) const {
tinyxml2::XMLNode *node = pd->doc->FirstChildElement(name); tinyxml2::XMLNode *node = pd->doc->FirstChildElement(name);
if (node == NULL) { if (node == nullptr) {
RLOG(ERROR) << "Xml node " << name << " not found"; RLOG(ERROR) << "Xml node " << name << " not found";
return XmlValuePtr(new XmlValue()); return XmlValuePtr(new XmlValue());
} }
tinyxml2::XMLElement *element = node->ToElement(); tinyxml2::XMLElement *element = node->ToElement();
if (element == NULL) { if (element == nullptr) {
RLOG(ERROR) << "Xml node " << name << " not element"; RLOG(ERROR) << "Xml node " << name << " not element";
return XmlValuePtr(new XmlValue()); return XmlValuePtr(new XmlValue());
} }

8
encfs/autosprintf.cpp
View File

@ -38,13 +38,13 @@ namespace gnu {
autosprintf::autosprintf(const char *format, ...) { autosprintf::autosprintf(const char *format, ...) {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
if (vasprintf(&str, format, args) < 0) str = NULL; if (vasprintf(&str, format, args) < 0) str = nullptr;
va_end(args); va_end(args);
} }
/* Copy constructor. Necessary because the destructor is nontrivial. */ /* Copy constructor. Necessary because the destructor is nontrivial. */
autosprintf::autosprintf(const autosprintf &src) { autosprintf::autosprintf(const autosprintf &src) {
str = (src.str != NULL ? strdup(src.str) : NULL); str = (src.str != nullptr ? strdup(src.str) : nullptr);
} }
/* Destructor: frees the temporarily allocated string. */ /* Destructor: frees the temporarily allocated string. */
@ -52,13 +52,13 @@ autosprintf::~autosprintf() { free(str); }
/* Conversion to string. */ /* Conversion to string. */
autosprintf::operator char *() const { autosprintf::operator char *() const {
if (str != NULL) { if (str != nullptr) {
size_t length = strlen(str) + 1; size_t length = strlen(str) + 1;
char *copy = new char[length]; char *copy = new char[length];
memcpy(copy, str, length); memcpy(copy, str, length);
return copy; return copy;
} else } else
return NULL; return nullptr;
} }
autosprintf::operator std::string() const { autosprintf::operator std::string() const {
return std::string(str ? str : "(error in autosprintf)"); return std::string(str ? str : "(error in autosprintf)");

2
encfs/base64.cpp
View File

@ -105,7 +105,7 @@ static void changeBase2Inline(unsigned char *src, int srcLen, int src2Pow,
void changeBase2Inline(unsigned char *src, int srcLen, int src2Pow, int dst2Pow, void changeBase2Inline(unsigned char *src, int srcLen, int src2Pow, int dst2Pow,
bool outputPartialLastByte) { bool outputPartialLastByte) {
changeBase2Inline(src, srcLen, src2Pow, dst2Pow, outputPartialLastByte, 0, 0, changeBase2Inline(src, srcLen, src2Pow, dst2Pow, outputPartialLastByte, 0, 0,
0); nullptr);
} }
// character set for ascii b64: // character set for ascii b64:

42
encfs/encfs.cpp
View File

@ -76,7 +76,7 @@ static EncFS_Context *context() {
* if the argument is NULL. * if the argument is NULL.
*/ */
static bool isReadOnly(EncFS_Context *ctx) { static bool isReadOnly(EncFS_Context *ctx) {
if (ctx == NULL) ctx = (EncFS_Context *)fuse_get_context()->private_data; if (ctx == nullptr) ctx = (EncFS_Context *)fuse_get_context()->private_data;
return ctx->opts->readOnly; return ctx->opts->readOnly;
} }
@ -112,20 +112,22 @@ static int withCipherPath(const char *opName, const char *path,
} }
static void checkCanary(std::shared_ptr<FileNode> fnode) { static void checkCanary(std::shared_ptr<FileNode> fnode) {
if(fnode->canary == CANARY_OK) { if (fnode->canary == CANARY_OK) {
return; return;
} }
if(fnode->canary == CANARY_RELEASED) { if (fnode->canary == CANARY_RELEASED) {
// "fnode" may have been released after it was retrieved by // "fnode" may have been released after it was retrieved by
// lookupFuseFh. This is not an error. std::shared_ptr will release // lookupFuseFh. This is not an error. std::shared_ptr will release
// the memory only when all operations on the FileNode have been // the memory only when all operations on the FileNode have been
// completed. // completed.
return; return;
} }
if(fnode->canary == CANARY_DESTROYED) { if (fnode->canary == CANARY_DESTROYED) {
RLOG(ERROR) << "canary=CANARY_DESTROYED. FileNode accessed after it was destroyed."; RLOG(ERROR)
<< "canary=CANARY_DESTROYED. FileNode accessed after it was destroyed.";
} else { } else {
RLOG(ERROR) << "canary=0x" << std::hex << fnode->canary << ". Memory corruption?"; RLOG(ERROR) << "canary=0x" << std::hex << fnode->canary
<< ". Memory corruption?";
} }
throw Error("dead canary"); throw Error("dead canary");
} }
@ -214,7 +216,7 @@ int _do_getattr(FileNode *fnode, struct stat *stbuf) {
} }
int encfs_getattr(const char *path, struct stat *stbuf) { int encfs_getattr(const char *path, struct stat *stbuf) {
return withFileNode("getattr", path, NULL, bind(_do_getattr, _1, stbuf)); return withFileNode("getattr", path, nullptr, bind(_do_getattr, _1, stbuf));
} }
int encfs_fgetattr(const char *path, struct stat *stbuf, int encfs_fgetattr(const char *path, struct stat *stbuf,
@ -366,7 +368,7 @@ int _do_rmdir(EncFS_Context *, const string &cipherPath) {
} }
int encfs_rmdir(const char *path) { int encfs_rmdir(const char *path) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withCipherPath("rmdir", path, bind(_do_rmdir, _1, _2)); return withCipherPath("rmdir", path, bind(_do_rmdir, _1, _2));
} }
@ -485,7 +487,7 @@ int _do_chmod(EncFS_Context *, const string &cipherPath, mode_t mode) {
} }
int encfs_chmod(const char *path, mode_t mode) { int encfs_chmod(const char *path, mode_t mode) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withCipherPath("chmod", path, bind(_do_chmod, _1, _2, mode)); return withCipherPath("chmod", path, bind(_do_chmod, _1, _2, mode));
} }
@ -495,19 +497,19 @@ int _do_chown(EncFS_Context *, const string &cyName, uid_t u, gid_t g) {
} }
int encfs_chown(const char *path, uid_t uid, gid_t gid) { int encfs_chown(const char *path, uid_t uid, gid_t gid) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withCipherPath("chown", path, bind(_do_chown, _1, _2, uid, gid)); return withCipherPath("chown", path, bind(_do_chown, _1, _2, uid, gid));
} }
int _do_truncate(FileNode *fnode, off_t size) { return fnode->truncate(size); } int _do_truncate(FileNode *fnode, off_t size) { return fnode->truncate(size); }
int encfs_truncate(const char *path, off_t size) { int encfs_truncate(const char *path, off_t size) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withFileNode("truncate", path, NULL, bind(_do_truncate, _1, size)); return withFileNode("truncate", path, nullptr, bind(_do_truncate, _1, size));
} }
int encfs_ftruncate(const char *path, off_t size, struct fuse_file_info *fi) { int encfs_ftruncate(const char *path, off_t size, struct fuse_file_info *fi) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withFileNode("ftruncate", path, fi, bind(_do_truncate, _1, size)); return withFileNode("ftruncate", path, fi, bind(_do_truncate, _1, size));
} }
@ -517,7 +519,7 @@ int _do_utime(EncFS_Context *, const string &cyName, struct utimbuf *buf) {
} }
int encfs_utime(const char *path, struct utimbuf *buf) { int encfs_utime(const char *path, struct utimbuf *buf) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withCipherPath("utime", path, bind(_do_utime, _1, _2, buf)); return withCipherPath("utime", path, bind(_do_utime, _1, _2, buf));
} }
@ -538,7 +540,7 @@ int _do_utimens(EncFS_Context *, const string &cyName,
} }
int encfs_utimens(const char *path, const struct timespec ts[2]) { int encfs_utimens(const char *path, const struct timespec ts[2]) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withCipherPath("utimens", path, bind(_do_utimens, _1, _2, ts)); return withCipherPath("utimens", path, bind(_do_utimens, _1, _2, ts));
} }
@ -641,7 +643,7 @@ int _do_fsync(FileNode *fnode, int dataSync) {
} }
int encfs_fsync(const char *path, int dataSync, struct fuse_file_info *file) { int encfs_fsync(const char *path, int dataSync, struct fuse_file_info *file) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withFileNode("fsync", path, file, bind(_do_fsync, _1, dataSync)); return withFileNode("fsync", path, file, bind(_do_fsync, _1, dataSync));
} }
@ -654,7 +656,7 @@ int _do_write(FileNode *fnode, unsigned char *ptr, size_t size, off_t offset) {
int encfs_write(const char *path, const char *buf, size_t size, off_t offset, int encfs_write(const char *path, const char *buf, size_t size, off_t offset,
struct fuse_file_info *file) { struct fuse_file_info *file) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withFileNode("write", path, file, return withFileNode("write", path, file,
bind(_do_write, _1, (unsigned char *)buf, size, offset)); bind(_do_write, _1, (unsigned char *)buf, size, offset));
} }
@ -666,7 +668,7 @@ int encfs_statfs(const char *path, struct statvfs *st) {
int res = -EIO; int res = -EIO;
try { try {
(void)path; // path should always be '/' for now.. (void)path; // path should always be '/' for now..
rAssert(st != NULL); rAssert(st != nullptr);
string cyName = ctx->rootCipherDir; string cyName = ctx->rootCipherDir;
VLOG(1) << "doing statfs of " << cyName; VLOG(1) << "doing statfs of " << cyName;
@ -704,7 +706,7 @@ int _do_setxattr(EncFS_Context *, const string &cyName, const char *name,
} }
int encfs_setxattr(const char *path, const char *name, const char *value, int encfs_setxattr(const char *path, const char *name, const char *value,
size_t size, int flags) { size_t size, int flags) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withCipherPath("setxattr", path, return withCipherPath("setxattr", path,
bind(_do_setxattr, _1, _2, name, value, size, flags)); bind(_do_setxattr, _1, _2, name, value, size, flags));
} }
@ -762,7 +764,7 @@ int _do_removexattr(EncFS_Context *, const string &cyName, const char *name) {
} }
int encfs_removexattr(const char *path, const char *name) { int encfs_removexattr(const char *path, const char *name) {
if (isReadOnly(NULL)) return -EROFS; if (isReadOnly(nullptr)) return -EROFS;
return withCipherPath("removexattr", path, return withCipherPath("removexattr", path,
bind(_do_removexattr, _1, _2, name)); bind(_do_removexattr, _1, _2, name));

74
encfs/main.cpp
View File

@ -161,7 +161,8 @@ static void FuseUsage() {
int argc = 2; int argc = 2;
const char *argv[] = {"...", "-h"}; const char *argv[] = {"...", "-h"};
fuse_main(argc, const_cast<char **>(argv), (fuse_operations *)NULL, NULL); fuse_main(argc, const_cast<char **>(argv), (fuse_operations *)nullptr,
nullptr);
} }
#define PUSHARG(ARG) \ #define PUSHARG(ARG) \
@ -202,35 +203,35 @@ static bool processArgs(int argc, char *argv[],
// leave a space for mount point, as FUSE expects the mount point before // leave a space for mount point, as FUSE expects the mount point before
// any flags // any flags
out->fuseArgv[1] = NULL; out->fuseArgv[1] = nullptr;
++out->fuseArgc; ++out->fuseArgc;
// TODO: can flags be internationalized? // TODO: can flags be internationalized?
static struct option long_options[] = { static struct option long_options[] = {
{"fuse-debug", 0, 0, 'd'}, // Fuse debug mode {"fuse-debug", 0, nullptr, 'd'}, // Fuse debug mode
{"forcedecode", 0, 0, 'D'}, // force decode {"forcedecode", 0, nullptr, 'D'}, // force decode
// {"foreground", 0, 0, 'f'}, // foreground mode (no daemon) // {"foreground", 0, 0, 'f'}, // foreground mode (no daemon)
{"fuse-help", 0, 0, 'H'}, // fuse_mount usage {"fuse-help", 0, nullptr, 'H'}, // fuse_mount usage
{"idle", 1, 0, 'i'}, // idle timeout {"idle", 1, nullptr, 'i'}, // idle timeout
{"anykey", 0, 0, 'k'}, // skip key checks {"anykey", 0, nullptr, 'k'}, // skip key checks
{"no-default-flags", 0, 0, 'N'}, // don't use default fuse flags {"no-default-flags", 0, nullptr, 'N'}, // don't use default fuse flags
{"ondemand", 0, 0, 'm'}, // mount on-demand {"ondemand", 0, nullptr, 'm'}, // mount on-demand
{"delaymount", 0, 0, 'M'}, // delay initial mount until use {"delaymount", 0, nullptr, 'M'}, // delay initial mount until use
{"public", 0, 0, 'P'}, // public mode {"public", 0, nullptr, 'P'}, // public mode
{"extpass", 1, 0, 'p'}, // external password program {"extpass", 1, nullptr, 'p'}, // external password program
// {"single-thread", 0, 0, 's'}, // single-threaded mode // {"single-thread", 0, 0, 's'}, // single-threaded mode
{"stdinpass", 0, 0, 'S'}, // read password from stdin {"stdinpass", 0, nullptr, 'S'}, // read password from stdin
{"syslogtag", 1, 0, 't'}, // syslog tag {"syslogtag", 1, nullptr, 't'}, // syslog tag
{"annotate", 0, 0, {"annotate", 0, nullptr,
LONG_OPT_ANNOTATE}, // Print annotation lines to stderr LONG_OPT_ANNOTATE}, // Print annotation lines to stderr
{"nocache", 0, 0, LONG_OPT_NOCACHE}, // disable caching {"nocache", 0, nullptr, LONG_OPT_NOCACHE}, // disable caching
{"verbose", 0, 0, 'v'}, // verbose mode {"verbose", 0, nullptr, 'v'}, // verbose mode
{"version", 0, 0, 'V'}, // version {"version", 0, nullptr, 'V'}, // version
{"reverse", 0, 0, 'r'}, // reverse encryption {"reverse", 0, nullptr, 'r'}, // reverse encryption
{"standard", 0, 0, '1'}, // standard configuration {"standard", 0, nullptr, '1'}, // standard configuration
{"paranoia", 0, 0, '2'}, // standard configuration {"paranoia", 0, nullptr, '2'}, // standard configuration
{"require-macs", 0, 0, LONG_OPT_REQUIRE_MAC}, // require MACs {"require-macs", 0, nullptr, LONG_OPT_REQUIRE_MAC}, // require MACs
{0, 0, 0, 0}}; {nullptr, 0, nullptr, 0}};
while (1) { while (1) {
int option_index = 0; int option_index = 0;
@ -283,7 +284,7 @@ static bool processArgs(int argc, char *argv[],
PUSHARG("-d"); PUSHARG("-d");
break; break;
case 'i': case 'i':
out->idleTimeout = strtol(optarg, (char **)NULL, 10); out->idleTimeout = strtol(optarg, (char **)nullptr, 10);
out->opts->idleTracking = true; out->opts->idleTracking = true;
break; break;
case 'k': case 'k':
@ -358,7 +359,7 @@ static bool processArgs(int argc, char *argv[],
#if defined(HAVE_XATTR) #if defined(HAVE_XATTR)
// "--verbose" has to be passed before "--version" for this to work. // "--verbose" has to be passed before "--version" for this to work.
if (out->isVerbose) { if (out->isVerbose) {
cerr << "Compiled with : HAVE_XATTR" << endl; cerr << "Compiled with : HAVE_XATTR" << endl;
} }
#endif #endif
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);
@ -503,7 +504,8 @@ void *encfs_init(fuse_conn_info *conn) {
VLOG(1) << "starting idle monitoring thread"; VLOG(1) << "starting idle monitoring thread";
ctx->running = true; ctx->running = true;
int res = pthread_create(&ctx->monitorThread, 0, idleMonitor, (void *)ctx); int res =
pthread_create(&ctx->monitorThread, nullptr, idleMonitor, (void *)ctx);
if (res != 0) { if (res != 0) {
RLOG(ERROR) << "error starting idle monitor thread, " RLOG(ERROR) << "error starting idle monitor thread, "
"res = " "res = "
@ -533,7 +535,7 @@ int main(int argc, char *argv[]) {
// we've processed it and only allowed through what we support. // we've processed it and only allowed through what we support.
std::shared_ptr<EncFS_Args> encfsArgs(new EncFS_Args); std::shared_ptr<EncFS_Args> encfsArgs(new EncFS_Args);
for (int i = 0; i < MaxFuseArgs; ++i) for (int i = 0; i < MaxFuseArgs; ++i)
encfsArgs->fuseArgv[i] = NULL; // libfuse expects null args.. encfsArgs->fuseArgv[i] = nullptr; // libfuse expects null args..
if (argc == 1 || !processArgs(argc, argv, encfsArgs)) { if (argc == 1 || !processArgs(argc, argv, encfsArgs)) {
usage(argv[0]); usage(argv[0]);
@ -681,7 +683,7 @@ int main(int argc, char *argv[]) {
pthread_cond_signal(&ctx->wakeupCond); pthread_cond_signal(&ctx->wakeupCond);
pthread_mutex_unlock(&ctx->wakeupMutex); pthread_mutex_unlock(&ctx->wakeupMutex);
VLOG(1) << "joining with idle monitoring thread"; VLOG(1) << "joining with idle monitoring thread";
pthread_join(ctx->monitorThread, 0); pthread_join(ctx->monitorThread, nullptr);
VLOG(1) << "join done"; VLOG(1) << "join done";
} }
} }
@ -715,7 +717,8 @@ static void *idleMonitor(void *_arg) {
bool unmountres = false; bool unmountres = false;
// We will notify when FS will be unmounted, so notify that it has just been mounted // We will notify when FS will be unmounted, so notify that it has just been
// mounted
RLOG(INFO) << "Filesystem mounted: " << arg->opts->mountPoint; RLOG(INFO) << "Filesystem mounted: " << arg->opts->mountPoint;
pthread_mutex_lock(&ctx->wakeupMutex); pthread_mutex_lock(&ctx->wakeupMutex);
@ -751,7 +754,7 @@ static void *idleMonitor(void *_arg) {
<< timeoutCycles; << timeoutCycles;
struct timeval currentTime; struct timeval currentTime;
gettimeofday(&currentTime, 0); gettimeofday(&currentTime, nullptr);
struct timespec wakeupTime; struct timespec wakeupTime;
wakeupTime.tv_sec = currentTime.tv_sec + ActivityCheckInterval; wakeupTime.tv_sec = currentTime.tv_sec + ActivityCheckInterval;
wakeupTime.tv_nsec = currentTime.tv_usec * 1000; wakeupTime.tv_nsec = currentTime.tv_usec * 1000;
@ -760,13 +763,14 @@ static void *idleMonitor(void *_arg) {
pthread_mutex_unlock(&ctx->wakeupMutex); pthread_mutex_unlock(&ctx->wakeupMutex);
// If we are here FS has been unmounted, so if we did not unmount ourselves (manual, kill...), notify // If we are here FS has been unmounted, so if we did not unmount ourselves
// (manual, kill...), notify
if (!unmountres) if (!unmountres)
RLOG(INFO) << "Filesystem unmounted: " << arg->opts->mountPoint; RLOG(INFO) << "Filesystem unmounted: " << arg->opts->mountPoint;
VLOG(1) << "Idle monitoring thread exiting"; VLOG(1) << "Idle monitoring thread exiting";
return 0; return nullptr;
} }
static bool unmountFS(EncFS_Context *ctx) { static bool unmountFS(EncFS_Context *ctx) {
@ -778,9 +782,9 @@ static bool unmountFS(EncFS_Context *ctx) {
ctx->setRoot(std::shared_ptr<DirNode>()); ctx->setRoot(std::shared_ptr<DirNode>());
return false; return false;
} else { } else {
// Time to unmount! // Time to unmount!
#if FUSE_USE_VERSION < 30 #if FUSE_USE_VERSION < 30
fuse_unmount(arg->opts->mountPoint.c_str(), NULL); fuse_unmount(arg->opts->mountPoint.c_str(), nullptr);
#else #else
fuse_unmount(fuse_get_context()->fuse); fuse_unmount(fuse_get_context()->fuse);
#endif #endif

6
encfs/openssl.cpp
View File

@ -37,7 +37,7 @@ namespace encfs {
unsigned long pthreads_thread_id() { return (unsigned long)pthread_self(); } unsigned long pthreads_thread_id() { return (unsigned long)pthread_self(); }
static pthread_mutex_t *crypto_locks = NULL; static pthread_mutex_t *crypto_locks = nullptr;
void pthreads_locking_callback(int mode, int n, const char *caller_file, void pthreads_locking_callback(int mode, int n, const char *caller_file,
int caller_line) { int caller_line) {
(void)caller_file; (void)caller_file;
@ -47,7 +47,7 @@ void pthreads_locking_callback(int mode, int n, const char *caller_file,
VLOG(1) << "Allocating " << CRYPTO_num_locks() << " locks for OpenSSL"; VLOG(1) << "Allocating " << CRYPTO_num_locks() << " locks for OpenSSL";
crypto_locks = new pthread_mutex_t[CRYPTO_num_locks()]; crypto_locks = new pthread_mutex_t[CRYPTO_num_locks()];
for (int i = 0; i < CRYPTO_num_locks(); ++i) for (int i = 0; i < CRYPTO_num_locks(); ++i)
pthread_mutex_init(crypto_locks + i, 0); pthread_mutex_init(crypto_locks + i, nullptr);
} }
if (mode & CRYPTO_LOCK) { if (mode & CRYPTO_LOCK) {
@ -62,7 +62,7 @@ void pthreads_locking_cleanup() {
for (int i = 0; i < CRYPTO_num_locks(); ++i) for (int i = 0; i < CRYPTO_num_locks(); ++i)
pthread_mutex_destroy(crypto_locks + i); pthread_mutex_destroy(crypto_locks + i);
delete[] crypto_locks; delete[] crypto_locks;
crypto_locks = NULL; crypto_locks = nullptr;
} }
} }

20
encfs/readpassphrase.cpp
View File

@ -76,7 +76,7 @@ char *readpassphrase(const char *prompt, char *buf, size_t bufsiz, int flags) {
/* I suppose we could alloc on demand in this case (XXX). */ /* I suppose we could alloc on demand in this case (XXX). */
if (bufsiz == 0) { if (bufsiz == 0) {
errno = EINVAL; errno = EINVAL;
return (NULL); return (nullptr);
} }
restart: restart:
@ -87,7 +87,7 @@ restart:
if ((input = output = open(_PATH_TTY, O_RDWR)) == -1) { if ((input = output = open(_PATH_TTY, O_RDWR)) == -1) {
if (flags & RPP_REQUIRE_TTY) { if (flags & RPP_REQUIRE_TTY) {
errno = ENOTTY; errno = ENOTTY;
return (NULL); return (nullptr);
} }
input = STDIN_FILENO; input = STDIN_FILENO;
output = STDERR_FILENO; output = STDERR_FILENO;
@ -142,13 +142,13 @@ restart:
/* Restore old terminal settings and signals. */ /* Restore old terminal settings and signals. */
if (memcmp(&term, &oterm, sizeof(term)) != 0) if (memcmp(&term, &oterm, sizeof(term)) != 0)
(void)tcsetattr(input, _T_FLUSH, &oterm); (void)tcsetattr(input, _T_FLUSH, &oterm);
(void)sigaction(SIGINT, &saveint, NULL); (void)sigaction(SIGINT, &saveint, nullptr);
(void)sigaction(SIGHUP, &savehup, NULL); (void)sigaction(SIGHUP, &savehup, nullptr);
(void)sigaction(SIGQUIT, &savequit, NULL); (void)sigaction(SIGQUIT, &savequit, nullptr);
(void)sigaction(SIGTERM, &saveterm, NULL); (void)sigaction(SIGTERM, &saveterm, nullptr);
(void)sigaction(SIGTSTP, &savetstp, NULL); (void)sigaction(SIGTSTP, &savetstp, nullptr);
(void)sigaction(SIGTTIN, &savettin, NULL); (void)sigaction(SIGTTIN, &savettin, nullptr);
(void)sigaction(SIGTTOU, &savettou, NULL); (void)sigaction(SIGTTOU, &savettou, nullptr);
if (input != STDIN_FILENO) (void)close(input); if (input != STDIN_FILENO) (void)close(input);
/* /*
@ -167,7 +167,7 @@ restart:
} }
errno = save_errno; errno = save_errno;
return (nr == -1 ? NULL : buf); return (nr == -1 ? nullptr : buf);
} }
#endif /* HAVE_READPASSPHRASE */ #endif /* HAVE_READPASSPHRASE */

7
encfs/test.cpp
View File

@ -173,11 +173,12 @@ bool runTests(const std::shared_ptr<Cipher> &cipher, bool verbose) {
cfg.assignKeyData(keyBuf, encodedKeySize); cfg.assignKeyData(keyBuf, encodedKeySize);
// save config // save config
//Creation of a temporary file should be more platform independent. On c++17 we could use std::filesystem. // Creation of a temporary file should be more platform independent. On
// c++17 we could use std::filesystem.
string name = "/tmp/encfstestXXXXXX"; string name = "/tmp/encfstestXXXXXX";
int tmpFd = mkstemp(&name[0]); int tmpFd = mkstemp(&name[0]);
rAssert(-1 != tmpFd); rAssert(-1 != tmpFd);
//mkstemp opens the temporary file, but we only need its name -> close it // mkstemp opens the temporary file, but we only need its name -> close it
rAssert(0 == close(tmpFd)); rAssert(0 == close(tmpFd));
{ {
auto ok = writeV6Config(name.c_str(), &cfg); auto ok = writeV6Config(name.c_str(), &cfg);
@ -190,7 +191,7 @@ bool runTests(const std::shared_ptr<Cipher> &cipher, bool verbose) {
auto ok = readV6Config(name.c_str(), &cfg2, nullptr); auto ok = readV6Config(name.c_str(), &cfg2, nullptr);
rAssert(ok == true); rAssert(ok == true);
} }
//delete the temporary file where we stored the config // delete the temporary file where we stored the config
rAssert(0 == unlink(name.c_str())); rAssert(0 == unlink(name.c_str()));
// check.. // check..