#include "gnunet_disk_lib.h"
#include "gnunet_scheduler_lib.h"
#include "gnunet_strings_lib.h"
+#include "disk.h"
-#if LINUX || CYGWIN
+/**
+ * Block size for IO for copying files.
+ */
+#define COPY_BLK_SIZE 65536
+
+
+
+#if defined(LINUX) || defined(CYGWIN)
#include <sys/vfs.h>
#else
-#ifdef SOMEBSD
-#include <sys/param.h>
-#include <sys/mount.h>
-#else
-#ifdef OSX
+#if defined(SOMEBSD) || defined(DARWIN)
#include <sys/param.h>
#include <sys/mount.h>
#else
#endif
#endif
#endif
-#endif
-#ifndef SOMEBSD
-#ifndef WINDOWS
-#ifndef OSX
+#if !defined(SOMEBSD) && !defined(DARWIN) && !defined(WINDOWS)
#include <wordexp.h>
#endif
+#if LINUX
+#include <sys/statvfs.h>
#endif
-#endif
-typedef struct
+
+/**
+ * Handle used to manage a pipe.
+ */
+struct GNUNET_DISK_PipeHandle
{
- unsigned long long total;
- int include_sym_links;
-} GetFileSizeData;
+ /**
+ * File descriptors for the pipe.
+ */
+ struct GNUNET_DISK_FileHandle *fd[2];
+};
-struct GNUNET_DISK_FileHandle
+
+/**
+ * Closure for the recursion to determine the file size
+ * of a directory.
+ */
+struct GetFileSizeData
{
-#if MINGW
- HANDLE h;
-#else
- int fd;
-#endif
+ /**
+ * Set to the total file size.
+ */
+ uint64_t total;
+
+ /**
+ * GNUNET_YES if symbolic links should be included.
+ */
+ int include_sym_links;
};
+
+/**
+ * Iterate over all files in the given directory and
+ * accumulate their size.
+ *
+ * @param cls closure of type "struct GetFileSizeData"
+ * @param fn current filename we are looking at
+ * @return GNUNET_SYSERR on serious errors, otherwise GNUNET_OK
+ */
static int
-getSizeRec (void *ptr, const char *fn)
+getSizeRec (void *cls, const char *fn)
{
- GetFileSizeData *gfsd = ptr;
+ struct GetFileSizeData *gfsd = cls;
#ifdef HAVE_STAT64
struct stat64 buf;
#else
return GNUNET_OK;
}
+
/**
* Checks whether a handle is invalid
+ *
* @param h handle to check
* @return GNUNET_YES if invalid, GNUNET_NO if valid
*/
GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h)
{
#ifdef MINGW
- return !h || h->h == INVALID_HANDLE_VALUE ? GNUNET_YES : GNUNET_NO;
+ return ((!h) || (h->h == INVALID_HANDLE_VALUE)) ? GNUNET_YES : GNUNET_NO;
#else
- return !h || h->fd == -1 ? GNUNET_YES : GNUNET_NO;
+ return ((!h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
#endif
}
/**
* Move the read/write pointer in a file
+ *
* @param h handle of an open file
* @param offset position to move to
* @param whence specification to which position the offset parameter relates to
* @return the new position on success, GNUNET_SYSERR otherwise
*/
off_t
-GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, off_t offset,
- enum GNUNET_DISK_Seek whence)
+GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle * h, off_t offset,
+ enum GNUNET_DISK_Seek whence)
{
if (h == NULL)
{
#ifdef MINGW
DWORD ret;
- static DWORD t[] = { [GNUNET_SEEK_SET] = FILE_BEGIN,
- [GNUNET_SEEK_CUR] = FILE_CURRENT, [GNUNET_SEEK_END] = FILE_END };
+ static DWORD t[] = {[GNUNET_DISK_SEEK_SET] = FILE_BEGIN,
+ [GNUNET_DISK_SEEK_CUR] = FILE_CURRENT,[GNUNET_DISK_SEEK_END] = FILE_END
+ };
ret = SetFilePointer (h->h, offset, NULL, t[whence]);
if (ret == INVALID_SET_FILE_POINTER)
}
return ret;
#else
- static int t[] = { [GNUNET_SEEK_SET] = SEEK_SET,
- [GNUNET_SEEK_CUR] = SEEK_CUR, [GNUNET_SEEK_END] = SEEK_END };
+ static int t[] = {[GNUNET_DISK_SEEK_SET] = SEEK_SET,
+ [GNUNET_DISK_SEEK_CUR] = SEEK_CUR,[GNUNET_DISK_SEEK_END] = SEEK_END
+ };
return lseek (h->fd, offset, t[whence]);
#endif
}
+
/**
- * Get the size of the file (or directory)
- * of the given file (in bytes).
+ * Get the size of the file (or directory) of the given file (in
+ * bytes).
*
+ * @param filename name of the file or directory
+ * @param size set to the size of the file (or,
+ * in the case of directories, the sum
+ * of all sizes of files in the directory)
+ * @param includeSymLinks should symbolic links be
+ * included?
* @return GNUNET_SYSERR on error, GNUNET_OK on success
*/
int
GNUNET_DISK_file_size (const char *filename,
- unsigned long long *size, int includeSymLinks)
+ uint64_t * size, int includeSymLinks)
{
- GetFileSizeData gfsd;
+ struct GetFileSizeData gfsd;
int ret;
GNUNET_assert (size != NULL);
}
+/**
+ * Obtain some unique identifiers for the given file
+ * that can be used to identify it in the local system.
+ * This function is used between GNUnet processes to
+ * quickly check if two files with the same absolute path
+ * are actually identical. The two processes represent
+ * the same peer but may communicate over the network
+ * (and the file may be on an NFS volume). This function
+ * may not be supported on all operating systems.
+ *
+ * @param filename name of the file
+ * @param dev set to the device ID
+ * @param ino set to the inode ID
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_DISK_file_get_identifiers (const char *filename,
+ uint64_t * dev, uint64_t * ino)
+{
+#if LINUX
+ struct stat sbuf;
+ struct statvfs fbuf;
+
+ if ((0 == stat (filename, &sbuf)) && (0 == statvfs (filename, &fbuf)))
+ {
+ *dev = (uint64_t) fbuf.f_fsid;
+ *ino = (uint64_t) sbuf.st_ino;
+ return GNUNET_OK;
+ }
+#elif SOMEBSD
+ struct stat sbuf;
+ struct statfs fbuf;
+
+ if ( (0 == stat (filename, &sbuf)) &&
+ (0 == statfs (filename, &fbuf) ) )
+ {
+ *dev = ((uint64_t) fbuf.f_fsid.val[0]) << 32 || ((uint64_t) fbuf.f_fsid.val[1]);
+ *ino = (uint64_t) sbuf.st_ino;
+ return GNUNET_OK;
+ }
+#elif WINDOWS
+ // FIXME NILS: test this
+ struct GNUNET_DISK_FileHandle *fh;
+ BY_HANDLE_FILE_INFORMATION info;
+ int succ;
+
+ fh = GNUNET_DISK_file_open(filename, GNUNET_DISK_OPEN_READ, 0);
+ if (fh == NULL)
+ return GNUNET_SYSERR;
+ succ = GetFileInformationByHandle(fh->h, &info);
+ GNUNET_DISK_file_close(fh);
+ if (succ)
+ {
+ *dev = info.dwVolumeSerialNumber;
+ *ino = ((info.nFileIndexHigh << sizeof(DWORD)) | info.nFileIndexLow);
+ return GNUNET_OK;
+ }
+ else
+ return GNUNET_SYSERR;
+
+#endif
+ return GNUNET_SYSERR;
+}
+
+
+/**
+ * Create an (empty) temporary file on disk. If the given name is not
+ * an absolute path, the current 'TMPDIR' will be prepended. In any case,
+ * 6 random characters will be appended to the name to create a unique
+ * filename.
+ *
+ * @param t component to use for the name;
+ * does NOT contain "XXXXXX" or "/tmp/".
+ * @return NULL on error, otherwise name of fresh
+ * file on disk in directory for temporary files
+ */
+char *
+GNUNET_DISK_mktemp (const char *t)
+{
+ const char *tmpdir;
+ int fd;
+ char *tmpl;
+ char *fn;
+
+ if ( (t[0] != '/') &&
+ (t[0] != '\\') )
+ {
+ tmpdir = getenv ("TMPDIR");
+ tmpdir = tmpdir ? tmpdir : "/tmp";
+ GNUNET_asprintf (&tmpl, "%s/%s%s", tmpdir, t, "XXXXXX");
+ }
+ else
+ {
+ GNUNET_asprintf (&tmpl, "%s%s", t, "XXXXXX");
+ }
+#ifdef MINGW
+ fn = (char *) GNUNET_malloc (MAX_PATH + 1);
+ if (ERROR_SUCCESS != plibc_conv_to_win_path (tmpl, fn))
+ {
+ GNUNET_free (fn);
+ GNUNET_free (tmpl);
+ return NULL;
+ }
+ GNUNET_free (tmpl);
+#else
+ fn = tmpl;
+#endif
+ fd = mkstemp (fn);
+ if (fd == -1)
+ {
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkstemp", fn);
+ GNUNET_free (fn);
+ return NULL;
+ }
+ if (0 != CLOSE (fd))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn);
+ return fn;
+}
+
+
/**
* Get the number of blocks that are left on the partition that
* contains the given file (for normal users).
DWORD dwDummy;
DWORD dwBlocks;
char szDrive[4];
+ char *path;
- memcpy (szDrive, part, 3);
+ path = GNUNET_STRINGS_filename_expand (part);
+ if (path == NULL)
+ return -1;
+ memcpy (szDrive, path, 3);
+ GNUNET_free (path);
szDrive[3] = 0;
if (!GetDiskFreeSpace (szDrive, &dwDummy, &dwDummy, &dwBlocks, &dwDummy))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("`%s' failed for drive `%s': %u\n"),
- "GetDiskFreeSpace", szDrive, GetLastError ());
+ _("`%s' failed for drive `%s': %u\n"),
+ "GetDiskFreeSpace", szDrive, GetLastError ());
return -1;
}
#endif
}
+
/**
- * Test if fil is a directory.
+ * Test if "fil" is a directory.
+ * Will not print an error message if the directory
+ * does not exist. Will log errors if GNUNET_SYSERR is
+ * returned (i.e., a file exists with the same name).
*
+ * @param fil filename to test
* @return GNUNET_YES if yes, GNUNET_NO if not, GNUNET_SYSERR if it
* does not exist
*/
/**
* Check that fil corresponds to a filename
* (of a file that exists and that is not a directory).
- * @returns GNUNET_YES if yes, GNUNET_NO if not a file, GNUNET_SYSERR if something
+ *
+ * @param fil filename to check
+ * @return GNUNET_YES if yes, GNUNET_NO if not a file, GNUNET_SYSERR if something
* else (will print an error message in that case, too).
*/
int
return GNUNET_YES;
}
+
/**
* Implementation of "mkdir -p"
* @param dir the directory to create
* exists but is not writeable for us
*/
int
-GNUNET_DISK_directory_create_for_file (const char *dir)
+GNUNET_DISK_directory_create_for_file (const char *filename)
{
char *rdir;
int len;
int ret;
- rdir = GNUNET_STRINGS_filename_expand (dir);
+ rdir = GNUNET_STRINGS_filename_expand (filename);
if (rdir == NULL)
return GNUNET_SYSERR;
len = strlen (rdir);
return ret;
}
+
/**
* Read the contents of a binary file into a buffer.
* @param h handle to an open file
* @return the number of bytes read on success, GNUNET_SYSERR on failure
*/
ssize_t
-GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, void *result,
- size_t len)
+GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
+ size_t len)
{
if (h == NULL)
{
* @return number of bytes read, GNUNET_SYSERR on failure
*/
ssize_t
-GNUNET_DISK_fn_read (const char * const fn,
- void *result,
- size_t len)
+GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
{
struct GNUNET_DISK_FileHandle *fh;
ssize_t ret;
- fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ);
+ fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ,
+ GNUNET_DISK_PERM_NONE);
if (!fh)
return GNUNET_SYSERR;
ret = GNUNET_DISK_file_read (fh, result, len);
- GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
return ret;
}
* @return number of bytes written on success, GNUNET_SYSERR on error
*/
ssize_t
-GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h, const void *buffer,
- size_t n)
+GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
+ const void *buffer, size_t n)
{
if (h == NULL)
{
/**
* Write a buffer to a file. If the file is longer than the
- * number of bytes that will be written, iit will be truncated.
+ * number of bytes that will be written, it will be truncated.
*
* @param fn file name
* @param buffer the data to write
* @param n number of bytes to write
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @param mode file permissions
+ * @return number of bytes written on success, GNUNET_SYSERR on error
*/
ssize_t
-GNUNET_DISK_fn_write (const char * const fn, const void *buffer,
- size_t n, int mode)
+GNUNET_DISK_fn_write (const char *fn, const void *buffer,
+ size_t n, enum GNUNET_DISK_AccessPermissions mode)
{
struct GNUNET_DISK_FileHandle *fh;
- int ret;
+ ssize_t ret;
- fh = GNUNET_DISK_file_open (fn,
- GNUNET_DISK_OPEN_WRITE
- | GNUNET_DISK_OPEN_TRUNCATE
- | GNUNET_DISK_OPEN_CREATE, mode);
+ fh = GNUNET_DISK_file_open (fn,
+ GNUNET_DISK_OPEN_WRITE
+ | GNUNET_DISK_OPEN_TRUNCATE
+ | GNUNET_DISK_OPEN_CREATE, mode);
if (!fh)
return GNUNET_SYSERR;
- ret = (n == GNUNET_DISK_file_write (fh, buffer, n)) ? GNUNET_OK : GNUNET_SYSERR;
- GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
-
+ ret = GNUNET_DISK_file_write (fh, buffer, n);
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
return ret;
}
/**
- * Scan a directory for files. The name of the directory
- * must be expanded first (!).
+ * Scan a directory for files.
+ *
* @param dirName the name of the directory
* @param callback the method to call for each file,
* can be NULL, in that case, we only count
- * @param data argument to pass to callback
+ * @param callback_cls closure for callback
* @return the number of files found, GNUNET_SYSERR on error or
* ieration aborted by callback returning GNUNET_SYSERR
*/
int
GNUNET_DISK_directory_scan (const char *dirName,
- GNUNET_FileNameCallback callback, void *data)
+ GNUNET_FileNameCallback callback,
+ void *callback_cls)
{
DIR *dinfo;
struct dirent *finfo;
GNUNET_assert (dirName != NULL);
dname = GNUNET_STRINGS_filename_expand (dirName);
+ if (dname == NULL)
+ return GNUNET_SYSERR;
while ((strlen (dname) > 0) && (dname[strlen (dname) - 1] == DIR_SEPARATOR))
dname[strlen (dname) - 1] = '\0';
if (0 != STAT (dname, &istat))
dname,
(strcmp (dname, DIR_SEPARATOR_STR) ==
0) ? "" : DIR_SEPARATOR_STR, finfo->d_name);
- if (GNUNET_OK != callback (data, name))
+ if (GNUNET_OK != callback (callback_cls, name))
{
closedir (dinfo);
GNUNET_free (name);
GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES);
return GNUNET_NO;
}
- GNUNET_SCHEDULER_add_after (iter->sched,
- GNUNET_YES,
- iter->priority,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- &directory_iterator_task, iter);
+ GNUNET_SCHEDULER_add_with_priority (iter->sched,
+ iter->priority,
+ &directory_iterator_task, iter);
return GNUNET_YES;
}
di->callback = callback;
di->callback_cls = callback_cls;
di->directory = OPENDIR (dirName);
+ if (di->directory == NULL)
+ {
+ GNUNET_free (di);
+ callback (callback_cls, NULL, NULL, NULL);
+ return;
+ }
di->dirname = GNUNET_strdup (dirName);
di->priority = prio;
GNUNET_DISK_directory_iterator_next (di, GNUNET_NO);
}
+/**
+ * Function that removes the given directory by calling
+ * "GNUNET_DISK_directory_remove".
+ *
+ * @param unused not used
+ * @param fn directory to remove
+ * @return GNUNET_OK
+ */
static int
remove_helper (void *unused, const char *fn)
{
- GNUNET_DISK_directory_remove (fn);
+ (void) GNUNET_DISK_directory_remove (fn);
return GNUNET_OK;
}
+
/**
* Remove all files in a directory (rm -rf). Call with
* caution.
return GNUNET_SYSERR;
}
if (GNUNET_SYSERR ==
- GNUNET_DISK_directory_scan (fileName, remove_helper, NULL))
+ GNUNET_DISK_directory_scan (fileName, &remove_helper, NULL))
return GNUNET_SYSERR;
if (0 != RMDIR (fileName))
{
return GNUNET_OK;
}
-#define COPY_BLK_SIZE 65536
/**
* Copy a file.
+ *
+ * @param src file to copy
+ * @param dst destination file name
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
int
GNUNET_DISK_file_copy (const char *src, const char *dst)
{
char *buf;
- unsigned long long pos;
- unsigned long long size;
- unsigned long long len;
- struct GNUNET_DISK_FileHandle *in, *out;
+ uint64_t pos;
+ uint64_t size;
+ size_t len;
+ struct GNUNET_DISK_FileHandle *in;
+ struct GNUNET_DISK_FileHandle *out;
if (GNUNET_OK != GNUNET_DISK_file_size (src, &size, GNUNET_YES))
return GNUNET_SYSERR;
pos = 0;
- in = GNUNET_DISK_file_open (src, GNUNET_DISK_OPEN_READ);
+ in = GNUNET_DISK_file_open (src, GNUNET_DISK_OPEN_READ,
+ GNUNET_DISK_PERM_NONE);
if (!in)
return GNUNET_SYSERR;
out = GNUNET_DISK_file_open (dst, GNUNET_DISK_OPEN_WRITE
- | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_FAILIFEXISTS,
- GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
- | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_GROUP_WRITE);
+ | GNUNET_DISK_OPEN_CREATE |
+ GNUNET_DISK_OPEN_FAILIFEXISTS,
+ GNUNET_DISK_PERM_USER_READ |
+ GNUNET_DISK_PERM_USER_WRITE |
+ GNUNET_DISK_PERM_GROUP_READ |
+ GNUNET_DISK_PERM_GROUP_WRITE);
if (!out)
{
GNUNET_DISK_file_close (in);
/**
* @brief Change owner of a file
+ *
+ * @param filename name of file to change the owner of
+ * @param user name of the new owner
+ * @return GNUNET_OK on success, GNUNET_SYSERR on failure
*/
int
GNUNET_DISK_file_change_owner (const char *filename, const char *user)
/**
* Lock a part of a file
* @param fh file handle
- * @lockStart absolute position from where to lock
- * @lockEnd absolute position until where to lock
+ * @param lockStart absolute position from where to lock
+ * @param lockEnd absolute position until where to lock
+ * @param excl GNUNET_YES for an exclusive lock
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
int
-GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh, off_t lockStart,
- off_t lockEnd)
+GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh, off_t lockStart,
+ off_t lockEnd, int excl)
{
if (fh == NULL)
{
#ifndef MINGW
struct flock fl;
- memset(&fl, 0, sizeof(struct flock));
- fl.l_type = F_WRLCK;
+ memset (&fl, 0, sizeof (struct flock));
+ fl.l_type = excl ? F_WRLCK : F_RDLCK;
fl.l_whence = SEEK_SET;
fl.l_start = lockStart;
fl.l_len = lockEnd;
- return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
+ return fcntl (fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
#else
- if (!LockFile(fh->h, 0, lockStart, 0, lockEnd))
- {
- SetErrnoFromWinError(GetLastError());
- return GNUNET_SYSERR;
- }
+ OVERLAPPED o;
+
+ memset (&o, 0, sizeof (OVERLAPPED));
+ o.Offset = lockStart;
+
+ if (!LockFileEx (fh->h, (excl ? LOCKFILE_EXCLUSIVE_LOCK : 0)
+ | LOCKFILE_FAIL_IMMEDIATELY, 0, lockEnd - lockStart, 0,
+ &o))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ return GNUNET_SYSERR;
+ }
+
+ return GNUNET_OK;
+#endif
+}
+
+
+/**
+ * Unlock a part of a file
+ * @param fh file handle
+ * @param unlockStart absolute position from where to unlock
+ * @param unlockEnd absolute position until where to unlock
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, off_t unlockStart,
+ off_t unlockEnd)
+{
+ if (fh == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifndef MINGW
+ struct flock fl;
+
+ memset (&fl, 0, sizeof (struct flock));
+ fl.l_type = F_UNLCK;
+ fl.l_whence = SEEK_SET;
+ fl.l_start = unlockStart;
+ fl.l_len = unlockEnd;
+
+ return fcntl (fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
+#else
+ OVERLAPPED o;
+
+ memset (&o, 0, sizeof (OVERLAPPED));
+ o.Offset = unlockStart;
+
+ if (!UnlockFileEx (fh->h, 0, unlockEnd - unlockStart, 0, &o))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ return GNUNET_SYSERR;
+ }
return GNUNET_OK;
#endif
/**
- * Open a file
+ * Open a file. Note that the access permissions will only be
+ * used if a new file is created and if the underlying operating
+ * system supports the given permissions.
+ *
* @param fn file name to be opened
* @param flags opening flags, a combination of GNUNET_DISK_OPEN_xxx bit flags
- * @param perm permissions for the newly created file
+ * @param perm permissions for the newly created file, use
+ * GNUNET_DISK_PERM_USER_NONE if a file could not be created by this
+ * call (because of flags)
* @return IO handle on success, NULL on error
*/
struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_file_open (const char *fn, int flags, ...)
+GNUNET_DISK_file_open (const char *fn,
+ enum GNUNET_DISK_OpenFlags flags,
+ enum GNUNET_DISK_AccessPermissions perm)
{
char *expfn;
struct GNUNET_DISK_FileHandle *ret;
#endif
expfn = GNUNET_STRINGS_filename_expand (fn);
-
+ if (NULL == expfn)
+ return NULL;
#ifndef MINGW
mode = 0;
- oflags = 0;
if (GNUNET_DISK_OPEN_READWRITE == (flags & GNUNET_DISK_OPEN_READWRITE))
- oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
+ oflags = O_RDWR; /* note: O_RDWR is NOT always O_RDONLY | O_WRONLY */
else if (flags & GNUNET_DISK_OPEN_READ)
oflags = O_RDONLY;
else if (flags & GNUNET_DISK_OPEN_WRITE)
else
{
GNUNET_break (0);
+ GNUNET_free (expfn);
return NULL;
}
if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
- oflags |= (O_CREAT & O_EXCL);
+ oflags |= (O_CREAT | O_EXCL);
if (flags & GNUNET_DISK_OPEN_TRUNCATE)
oflags |= O_TRUNC;
if (flags & GNUNET_DISK_OPEN_APPEND)
oflags |= O_APPEND;
if (flags & GNUNET_DISK_OPEN_CREATE)
{
- int perm;
-
+ (void) GNUNET_DISK_directory_create_for_file (expfn);
oflags |= O_CREAT;
-
- va_list arg;
- va_start (arg, flags);
- perm = va_arg (arg, int);
- va_end (arg);
-
if (perm & GNUNET_DISK_PERM_USER_READ)
mode |= S_IRUSR;
if (perm & GNUNET_DISK_PERM_USER_WRITE)
fd = open (expfn, oflags | O_LARGEFILE, mode);
if (fd == -1)
- {
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
- GNUNET_free (expfn);
- return NULL;
- }
+ {
+ if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
+ else
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_DEBUG, "open", expfn);
+ GNUNET_free (expfn);
+ return NULL;
+ }
#else
access = 0;
disp = OPEN_ALWAYS;
- if (flags & GNUNET_DISK_OPEN_READ)
+ if (GNUNET_DISK_OPEN_READWRITE == (flags & GNUNET_DISK_OPEN_READWRITE))
+ access = FILE_READ_DATA | FILE_WRITE_DATA;
+ else if (flags & GNUNET_DISK_OPEN_READ)
access = FILE_READ_DATA;
- if (flags & GNUNET_DISK_OPEN_WRITE)
+ else if (flags & GNUNET_DISK_OPEN_WRITE)
access = FILE_WRITE_DATA;
if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
- disp = CREATE_NEW;
- if (flags & GNUNET_DISK_OPEN_TRUNCATE)
- disp = TRUNCATE_EXISTING;
- if (flags & GNUNET_DISK_OPEN_CREATE)
- disp |= OPEN_ALWAYS;
+ {
+ disp = CREATE_NEW;
+ }
+ else if (flags & GNUNET_DISK_OPEN_CREATE)
+ {
+ if (flags & GNUNET_DISK_OPEN_TRUNCATE)
+ disp = CREATE_ALWAYS;
+ else
+ disp = OPEN_ALWAYS;
+ }
+ else if (flags & GNUNET_DISK_OPEN_TRUNCATE)
+ {
+ disp = TRUNCATE_EXISTING;
+ }
+ else
+ {
+ disp = OPEN_EXISTING;
+ }
/* TODO: access priviledges? */
h = CreateFile (expfn, access, FILE_SHARE_DELETE | FILE_SHARE_READ
- | FILE_SHARE_WRITE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
+ | FILE_SHARE_WRITE, NULL, disp, FILE_ATTRIBUTE_NORMAL,
+ NULL);
if (h == INVALID_HANDLE_VALUE)
- {
- SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
- GNUNET_free (expfn);
- return NULL;
- }
-
- if (flags & GNUNET_DISK_OPEN_APPEND)
- if (SetFilePointer (h, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
{
SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "SetFilePointer", expfn);
- CloseHandle (h);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
GNUNET_free (expfn);
return NULL;
}
+
+ if (flags & GNUNET_DISK_OPEN_APPEND)
+ if (SetFilePointer (h, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "SetFilePointer",
+ expfn);
+ CloseHandle (h);
+ GNUNET_free (expfn);
+ return NULL;
+ }
#endif
- ret = GNUNET_malloc(sizeof(struct GNUNET_DISK_FileHandle));
+ ret = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
#ifdef MINGW
ret->h = h;
#else
return ret;
}
+
/**
* Close an open file
* @param h file handle
#if MINGW
if (!CloseHandle (h->h))
- {
- SetErrnoFromWinError (GetLastError ());
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
- GNUNET_free (h);
- return GNUNET_SYSERR;
- }
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
+ GNUNET_free (h);
+ return GNUNET_SYSERR;
+ }
#else
if (close (h->fd) != 0)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
- GNUNET_free (h);
- return GNUNET_SYSERR;
- }
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
+ GNUNET_free (h);
+ return GNUNET_SYSERR;
+ }
#endif
GNUNET_free (h);
return GNUNET_OK;
}
+
/**
* Construct full path to a file inside of the private
* directory used by GNUnet. Also creates the corresponding
* a directory, end the last argument in '/' (or pass
* DIR_SEPARATOR_STR as the last argument before NULL).
*
+ * @param cfg configuration to use (determines HOME)
* @param serviceName name of the service
- * @param varargs is NULL-terminated list of
+ * @param ... is NULL-terminated list of
* path components to append to the
* private directory name.
* @return the constructed filename
*/
char *
-GNUNET_DISK_get_home_filename (struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_DISK_get_home_filename (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *serviceName, ...)
{
const char *c;
return ret;
}
+
+/**
+ * Handle for a memory-mapping operation.
+ */
struct GNUNET_DISK_MapHandle
{
#ifdef MINGW
+ /**
+ * Underlying OS handle.
+ */
HANDLE h;
#else
+ /**
+ * Address where the map is in memory.
+ */
void *addr;
+
+ /**
+ * Number of bytes mapped.
+ */
size_t len;
#endif
};
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *) -1)
+#endif
+
/**
* Map a file into memory
+ *
* @param h open file handle
* @param m handle to the new mapping
- * @param access access specification, GNUNET_DISK_MAP_xxx
+ * @param access access specification, GNUNET_DISK_MAP_TYPE_xxx
* @param len size of the mapping
* @return pointer to the mapped memory region, NULL on failure
*/
void *
-GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h, struct GNUNET_DISK_MapHandle **m,
- int access, size_t len)
+GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
+ struct GNUNET_DISK_MapHandle **m,
+ enum GNUNET_DISK_MapType access, size_t len)
{
if (h == NULL)
{
DWORD mapAccess, protect;
void *ret;
- if (access & GNUNET_DISK_MAP_READ && access & GNUNET_DISK_MAP_WRITE)
+ if ((access & GNUNET_DISK_MAP_TYPE_READ) &&
+ (access & GNUNET_DISK_MAP_TYPE_WRITE))
{
protect = PAGE_READWRITE;
mapAccess = FILE_MAP_ALL_ACCESS;
}
- else if (access & GNUNET_DISK_MAP_READ)
+ else if (access & GNUNET_DISK_MAP_TYPE_READ)
{
protect = PAGE_READONLY;
mapAccess = FILE_MAP_READ;
}
- else if (access & GNUNET_DISK_MAP_WRITE)
+ else if (access & GNUNET_DISK_MAP_TYPE_WRITE)
{
protect = PAGE_READWRITE;
mapAccess = FILE_MAP_WRITE;
int prot;
prot = 0;
- if (access & GNUNET_DISK_MAP_READ)
+ if (access & GNUNET_DISK_MAP_TYPE_READ)
prot = PROT_READ;
- if (access & GNUNET_DISK_MAP_WRITE)
+ if (access & GNUNET_DISK_MAP_TYPE_WRITE)
prot |= PROT_WRITE;
*m = GNUNET_malloc (sizeof (struct GNUNET_DISK_MapHandle));
(*m)->addr = mmap (NULL, len, prot, MAP_SHARED, h->fd, 0);
+ GNUNET_assert (NULL != (*m)->addr);
+ if (MAP_FAILED == (*m)->addr)
+ {
+ GNUNET_free (*m);
+ return NULL;
+ }
(*m)->len = len;
return (*m)->addr;
#endif
}
#ifdef MINGW
- ret = UnmapViewOfFile (addr) ? GNUNET_OK : GNUNET_SYSERR;
+ ret = UnmapViewOfFile (h->h) ? GNUNET_OK : GNUNET_SYSERR;
if (ret != GNUNET_OK)
SetErrnoFromWinError (GetLastError ());
if (!CloseHandle (h->h) && (ret == GNUNET_OK))
if (ret != GNUNET_OK)
SetErrnoFromWinError (GetLastError ());
return ret;
-#else
+#elif defined(FREEBSD) || defined(OPENBSD) || defined(DARWIN)
return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
+#else
+ return fdatasync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
#endif
}
+/**
+ * Creates an interprocess channel
+ *
+ * @param blocking creates an asynchronous pipe if set to GNUNET_NO
+ * @param inherit_read inherit the parent processes stdin (only for windows)
+ * @param inherit_write inherit the parent processes stdout (only for windows)
+ *
+ * @return handle to the new pipe, NULL on error
+ */
+struct GNUNET_DISK_PipeHandle *
+GNUNET_DISK_pipe (int blocking, int inherit_read, int inherit_write)
+{
+ struct GNUNET_DISK_PipeHandle *p;
+ struct GNUNET_DISK_FileHandle *fds;
+
+ p =
+ GNUNET_malloc (sizeof (struct GNUNET_DISK_PipeHandle) +
+ 2 * sizeof (struct GNUNET_DISK_FileHandle));
+ fds = (struct GNUNET_DISK_FileHandle *) &p[1];
+ p->fd[0] = &fds[0];
+ p->fd[1] = &fds[1];
+#ifndef MINGW
+ int fd[2];
+ int ret;
+ int flags;
+ int eno;
+
+ ret = pipe (fd);
+ if (ret == -1)
+ {
+ GNUNET_free (p);
+ return NULL;
+ }
+ p->fd[0]->fd = fd[0];
+ p->fd[1]->fd = fd[1];
+ ret = 0;
+ flags = fcntl (fd[0], F_GETFL);
+ flags |= FD_CLOEXEC;
+ if (!blocking)
+ flags |= O_NONBLOCK;
+ if (0 > fcntl (fd[0], F_SETFL, flags))
+ ret = -1;
+ flags = fcntl (fd[1], F_GETFL);
+ flags |= FD_CLOEXEC;
+ if (!blocking)
+ flags |= O_NONBLOCK;
+ if (0 > fcntl (fd[1], F_SETFL, flags))
+ ret = -1;
+ if (ret == -1)
+ {
+ eno = errno;
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fcntl");
+ GNUNET_break (0 == close (p->fd[0]->fd));
+ GNUNET_break (0 == close (p->fd[1]->fd));
+ GNUNET_free (p);
+ errno = eno;
+ return NULL;
+ }
+#else
+ BOOL ret;
+ HANDLE tmp_handle;
+
+ ret = CreatePipe (&p->fd[0]->h, &p->fd[1]->h, NULL, 0);
+ if (!ret)
+ {
+ GNUNET_free (p);
+ SetErrnoFromWinError (GetLastError ());
+ return NULL;
+ }
+ if (!DuplicateHandle (GetCurrentProcess (), p->fd[0]->h,
+ GetCurrentProcess (), &tmp_handle, 0, inherit_read == GNUNET_YES ? TRUE : FALSE,
+ DUPLICATE_SAME_ACCESS))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ CloseHandle (p->fd[0]->h);
+ CloseHandle (p->fd[1]->h);
+ GNUNET_free (p);
+ return NULL;
+ }
+ CloseHandle (p->fd[0]->h);
+ p->fd[0]->h = tmp_handle;
+
+ if (!DuplicateHandle (GetCurrentProcess (), p->fd[1]->h,
+ GetCurrentProcess (), &tmp_handle, 0, inherit_write == GNUNET_YES ? TRUE : FALSE,
+ DUPLICATE_SAME_ACCESS))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ CloseHandle (p->fd[0]->h);
+ CloseHandle (p->fd[1]->h);
+ GNUNET_free (p);
+ return NULL;
+ }
+ CloseHandle (p->fd[1]->h);
+ p->fd[1]->h = tmp_handle;
+ if (!blocking)
+ {
+ DWORD mode;
+
+ mode = PIPE_NOWAIT;
+ SetNamedPipeHandleState (p->fd[0]->h, &mode, NULL, NULL);
+ SetNamedPipeHandleState (p->fd[1]->h, &mode, NULL, NULL);
+ /* this always fails on Windows 95, so we don't care about error handling */
+ }
+#endif
+ return p;
+}
+
+
+/**
+ * Closes an interprocess channel
+ *
+ * @param p pipe to close
+ * @param end which end of the pipe to close
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p,
+ enum GNUNET_DISK_PipeEnd end)
+{
+ int ret = GNUNET_OK;
+ int save;
+
+#ifdef MINGW
+ if (end == GNUNET_DISK_PIPE_END_READ)
+ {
+ if (!CloseHandle (p->fd[0]->h))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ ret = GNUNET_SYSERR;
+ }
+ p->fd[0]->h = INVALID_HANDLE_VALUE;
+ }
+ else if (end == GNUNET_DISK_PIPE_END_WRITE)
+ {
+ if (!CloseHandle (p->fd[1]->h))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ ret = GNUNET_SYSERR;
+ }
+ p->fd[1]->h = INVALID_HANDLE_VALUE;
+ }
+ save = errno;
+#else
+ save = 0;
+ if (end == GNUNET_DISK_PIPE_END_READ)
+ {
+ if (0 != close (p->fd[0]->fd))
+ {
+ ret = GNUNET_SYSERR;
+ save = errno;
+ }
+ p->fd[0]->fd = -1;
+ }
+ else if (end == GNUNET_DISK_PIPE_END_WRITE)
+ {
+ if (0 != close (p->fd[1]->fd))
+ {
+ ret = GNUNET_SYSERR;
+ save = errno;
+ }
+ p->fd[1]->fd = -1;
+ }
+#endif
+ errno = save;
+ return ret;
+}
+
+/**
+ * Closes an interprocess channel
+ *
+ * @param p pipe to close
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
+{
+ int ret = GNUNET_OK;
+ int save;
+
+#ifdef MINGW
+ if (!CloseHandle (p->fd[0]->h))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ ret = GNUNET_SYSERR;
+ }
+ if (!CloseHandle (p->fd[1]->h))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ ret = GNUNET_SYSERR;
+ }
+ save = errno;
+#else
+ save = 0;
+ if (p->fd[0]->fd != -1)
+ {
+ if (0 != close (p->fd[0]->fd))
+ {
+ ret = GNUNET_SYSERR;
+ save = errno;
+ }
+ }
+
+ if (p->fd[1]->fd != -1)
+ {
+ if (0 != close (p->fd[1]->fd))
+ {
+ ret = GNUNET_SYSERR;
+ save = errno;
+ }
+ }
+#endif
+ GNUNET_free (p);
+ errno = save;
+ return ret;
+}
+
+
+/**
+ * Get the handle to a particular pipe end
+ *
+ * @param p pipe
+ * @param n end to access
+ * @return handle for the respective end
+ */
+const struct GNUNET_DISK_FileHandle *
+GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
+ enum GNUNET_DISK_PipeEnd n)
+{
+ switch (n)
+ {
+ case GNUNET_DISK_PIPE_END_READ:
+ case GNUNET_DISK_PIPE_END_WRITE:
+ return p->fd[n];
+ default:
+ GNUNET_break (0);
+ return NULL;
+ }
+}
+
+
+/**
+ * Retrieve OS file handle
+ * @internal
+ * @param fh GNUnet file descriptor
+ * @param dst destination buffer
+ * @param dst_len length of dst
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,
+ void *dst, size_t dst_len)
+{
+#ifdef MINGW
+ if (dst_len < sizeof (HANDLE))
+ return GNUNET_SYSERR;
+ *((HANDLE *) dst) = fh->h;
+#else
+ if (dst_len < sizeof (int))
+ return GNUNET_SYSERR;
+ *((int *) dst) = fh->fd;
+#endif
+
+ return GNUNET_OK;
+}
+
/* end of disk.c */