/*
This file is part of GNUnet.
- (C) 2001, 2002, 2005, 2006 Christian Grothoff (and other contributing authors)
+ (C) 2001, 2002, 2005, 2006, 2009 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
* @file util/disk.c
* @brief disk IO convenience methods
* @author Christian Grothoff
+ * @author Nils Durner
*/
#include "platform.h"
#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
+{
+ /**
+ * File descriptors for the pipe.
+ */
+ struct GNUNET_DISK_FileHandle *fd[2];
+};
+
+
+/**
+ * Closure for the recursion to determine the file size
+ * of a directory.
+ */
+struct GetFileSizeData
{
- unsigned long long total;
+ /**
+ * Set to the total file size.
+ */
+ uint64_t total;
+
+ /**
+ * GNUNET_YES if symbolic links should be included.
+ */
int include_sym_links;
-} GetFileSizeData;
+};
+
+/**
+ * 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
+ */
+int
+GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h)
+{
+#ifdef MINGW
+ return ((!h) || (h->h == INVALID_HANDLE_VALUE)) ? GNUNET_YES : GNUNET_NO;
+#else
+ return ((!h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
+#endif
+}
+
+
/**
- * Get the size of the file (or directory)
- * of the given file (in bytes).
+ * 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)
+{
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifdef MINGW
+ DWORD ret;
+ 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)
+ {
+ SetErrnoFromWinError (GetLastError ());
+ return GNUNET_SYSERR;
+ }
+ return ret;
+#else
+ 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).
+ *
+ * @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);
return ret;
}
+
+/**
+ * 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,
+ uint32_t * dev, uint64_t * ino)
+{
+#if LINUX
+ struct stat sbuf;
+ struct statvfs fbuf;
+
+ if ((0 == stat (filename, &sbuf)) && (0 == statvfs (filename, &fbuf)))
+ {
+ *dev = (uint32_t) fbuf.f_fsid;
+ *ino = (uint64_t) sbuf.st_ino;
+ return GNUNET_OK;
+ }
+#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);
+ memcpy (szDrive, path, 3);
+ GNUNET_free (path);
szDrive[3] = 0;
if (!GetDiskFreeSpace (szDrive, &dwDummy, &dwDummy, &dwBlocks, &dwDummy))
{
- GNUNET_GE_LOG (GNUNET_ERROR_TYPE_WARNING,
- _("`%s' failed for drive `%s': %u\n"),
- "GetDiskFreeSpace", szDrive, GetLastError ());
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("`%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 fileName the name of the file, not freed,
- * must already be expanded!
- * @param len the maximum number of bytes to read
+ * @param h handle to an open file
* @param result the buffer to write the result to
- * @return the number of bytes read on success, -1 on failure
+ * @param len the maximum number of bytes to read
+ * @return the number of bytes read on success, GNUNET_SYSERR on failure
*/
-int
-GNUNET_DISK_file_read (const char *fileName, int len, void *result)
+ssize_t
+GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
+ size_t len)
{
- /* open file, must exist, open read only */
- int handle;
- int size;
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifdef MINGW
+ DWORD bytesRead;
- GNUNET_assert (fileName != NULL);
- GNUNET_assert (len > 0);
- if (len == 0)
- return 0;
- GNUNET_assert (result != NULL);
- handle = GNUNET_DISK_file_open (fileName, O_RDONLY, S_IRUSR);
- if (handle < 0)
- return -1;
- size = READ (handle, result, len);
- GNUNET_DISK_file_close (fileName, handle);
- return size;
+ if (!ReadFile (h->h, result, len, &bytesRead, NULL))
+ {
+ SetErrnoFromWinError (GetLastError ());
+ return GNUNET_SYSERR;
+ }
+ return bytesRead;
+#else
+ return read (h->fd, result, len);
+#endif
}
/**
- * Convert string to value ('755' for chmod-call)
+ * Read the contents of a binary file into a buffer.
+ *
+ * @param fn file name
+ * @param result the buffer to write the result to
+ * @param len the maximum number of bytes to read
+ * @return number of bytes read, GNUNET_SYSERR on failure
*/
-static int
-atoo (const char *s)
+ssize_t
+GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
{
- int n = 0;
+ struct GNUNET_DISK_FileHandle *fh;
+ ssize_t ret;
- while (('0' <= *s) && (*s < '8'))
- {
- n <<= 3;
- n += *s++ - '0';
- }
- return n;
+ 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));
+
+ return ret;
}
+
/**
* Write a buffer to a file.
- * @param fileName the name of the file, NOT freed!
+ * @param h handle to open file
* @param buffer the data to write
* @param n number of bytes to write
- * @param mode permissions to set on the file
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @return number of bytes written on success, GNUNET_SYSERR on error
*/
-int
-GNUNET_DISK_file_write (const char *fileName,
- const void *buffer, unsigned int n, const char *mode)
+ssize_t
+GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
+ const void *buffer, size_t n)
{
- int handle;
- char *fn;
-
- /* open file, open with 600, create if not
- present, otherwise overwrite */
- GNUNET_assert (fileName != NULL);
- fn = GNUNET_STRINGS_filename_expand (fileName);
- handle = GNUNET_DISK_file_open (fn, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
- if (handle == -1)
+ if (h == NULL)
{
- GNUNET_free (fn);
+ errno = EINVAL;
return GNUNET_SYSERR;
}
- GNUNET_assert ((n == 0) || (buffer != NULL));
- /* write the buffer take length from the beginning */
- if (n != WRITE (handle, buffer, n))
+
+#ifdef MINGW
+ DWORD bytesWritten;
+
+ if (!WriteFile (h->h, buffer, n, &bytesWritten, NULL))
{
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
- GNUNET_DISK_file_close (fn, handle);
- GNUNET_free (fn);
+ SetErrnoFromWinError (GetLastError ());
return GNUNET_SYSERR;
}
- GNUNET_DISK_file_close (fn, handle);
- if (0 != CHMOD (fn, atoo (mode)))
- {
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
- }
- GNUNET_free (fn);
- return GNUNET_OK;
+ return bytesWritten;
+#else
+ return write (h->fd, buffer, n);
+#endif
+}
+
+/**
+ * Write a buffer to a file. If the file is longer than the
+ * 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
+ * @param mode file permissions
+ * @return number of bytes written on success, GNUNET_SYSERR on error
+ */
+ssize_t
+GNUNET_DISK_fn_write (const char *fn, const void *buffer,
+ size_t n, enum GNUNET_DISK_AccessPermissions mode)
+{
+ struct GNUNET_DISK_FileHandle *fh;
+ ssize_t ret;
+
+ 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 = 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;
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;
}
}
+/**
+ * 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;
}
-void
-GNUNET_DISK_file_close (const char *filename, int fd)
-{
- if (0 != CLOSE (fd))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", filename);
-}
-
-int
-GNUNET_DISK_file_open (const char *filename, int oflag, ...)
-{
- char *fn;
- int mode;
- int ret;
-#ifdef MINGW
- char szFile[_MAX_PATH + 1];
- long lRet;
-
- if ((lRet = plibc_conv_to_win_path (filename, szFile)) != ERROR_SUCCESS)
- {
- errno = ENOENT;
- SetLastError (lRet);
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "plibc_conv_to_win_path", filename);
- return -1;
- }
- fn = GNUNET_strdup (szFile);
-#else
- fn = GNUNET_STRINGS_filename_expand (filename);
-#endif
- if (oflag & O_CREAT)
- {
- va_list arg;
- va_start (arg, oflag);
- mode = va_arg (arg, int);
- va_end (arg);
- }
- else
- {
- mode = 0;
- }
-#ifdef MINGW
- /* set binary mode */
- oflag |= O_BINARY;
-#endif
- ret = OPEN (fn, oflag, mode);
- if (ret == -1)
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", fn);
- GNUNET_free (fn);
- return ret;
-}
-
-#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;
- int in;
- int 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, O_RDONLY | O_LARGEFILE);
- if (in == -1)
+ 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,
- O_LARGEFILE | O_WRONLY | O_CREAT | O_EXCL,
- S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
- if (out == -1)
+ 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);
+ if (!out)
{
- GNUNET_DISK_file_close (src, in);
+ GNUNET_DISK_file_close (in);
return GNUNET_SYSERR;
}
buf = GNUNET_malloc (COPY_BLK_SIZE);
len = COPY_BLK_SIZE;
if (len > size - pos)
len = size - pos;
- if (len != READ (in, buf, len))
+ if (len != GNUNET_DISK_file_read (in, buf, len))
goto FAIL;
- if (len != WRITE (out, buf, len))
+ if (len != GNUNET_DISK_file_write (out, buf, len))
goto FAIL;
pos += len;
}
GNUNET_free (buf);
- GNUNET_DISK_file_close (src, in);
- GNUNET_DISK_file_close (dst, out);
+ GNUNET_DISK_file_close (in);
+ GNUNET_DISK_file_close (out);
return GNUNET_OK;
FAIL:
GNUNET_free (buf);
- GNUNET_DISK_file_close (src, in);
- GNUNET_DISK_file_close (dst, out);
+ GNUNET_DISK_file_close (in);
+ GNUNET_DISK_file_close (out);
return GNUNET_SYSERR;
}
/**
* @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
+ * @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, int excl)
+{
+ if (fh == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifndef MINGW
+ struct flock fl;
+
+ 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;
+#else
+ 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. 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, 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,
+ enum GNUNET_DISK_OpenFlags flags,
+ enum GNUNET_DISK_AccessPermissions perm)
+{
+ char *expfn;
+ struct GNUNET_DISK_FileHandle *ret;
+#ifdef MINGW
+ DWORD access;
+ DWORD disp;
+ HANDLE h;
+#else
+ int oflags;
+ int mode;
+ int fd;
+#endif
+
+ expfn = GNUNET_STRINGS_filename_expand (fn);
+ if (NULL == expfn)
+ return NULL;
+#ifndef MINGW
+ mode = 0;
+ if (GNUNET_DISK_OPEN_READWRITE == (flags & GNUNET_DISK_OPEN_READWRITE))
+ 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)
+ oflags = O_WRONLY;
+ else
+ {
+ GNUNET_break (0);
+ GNUNET_free (expfn);
+ return NULL;
+ }
+ if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
+ 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)
+ {
+ (void) GNUNET_DISK_directory_create_for_file (expfn);
+ oflags |= O_CREAT;
+ if (perm & GNUNET_DISK_PERM_USER_READ)
+ mode |= S_IRUSR;
+ if (perm & GNUNET_DISK_PERM_USER_WRITE)
+ mode |= S_IWUSR;
+ if (perm & GNUNET_DISK_PERM_USER_EXEC)
+ mode |= S_IXUSR;
+ if (perm & GNUNET_DISK_PERM_GROUP_READ)
+ mode |= S_IRGRP;
+ if (perm & GNUNET_DISK_PERM_GROUP_WRITE)
+ mode |= S_IWGRP;
+ if (perm & GNUNET_DISK_PERM_GROUP_EXEC)
+ mode |= S_IXGRP;
+ if (perm & GNUNET_DISK_PERM_OTHER_READ)
+ mode |= S_IROTH;
+ if (perm & GNUNET_DISK_PERM_OTHER_WRITE)
+ mode |= S_IWOTH;
+ if (perm & GNUNET_DISK_PERM_OTHER_EXEC)
+ mode |= S_IXOTH;
+ }
+
+ fd = open (expfn, oflags | O_LARGEFILE, mode);
+ if (fd == -1)
+ {
+ 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 (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;
+ else if (flags & GNUNET_DISK_OPEN_WRITE)
+ access = FILE_WRITE_DATA;
+
+ if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
+ {
+ 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);
+ 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_free (expfn);
+ return NULL;
+ }
+#endif
+
+ ret = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+#ifdef MINGW
+ ret->h = h;
+#else
+ ret->fd = fd;
+#endif
+ GNUNET_free (expfn);
+ return ret;
+}
+
+
+/**
+ * Close an open file
+ * @param h file handle
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h)
+{
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#if MINGW
+ if (!CloseHandle (h->h))
+ {
+ 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;
+ }
+#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;
}
+/**
+ * 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_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,
+ enum GNUNET_DISK_MapType access, size_t len)
+{
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return NULL;
+ }
+
+#ifdef MINGW
+ DWORD mapAccess, protect;
+ void *ret;
+
+ 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_TYPE_READ)
+ {
+ protect = PAGE_READONLY;
+ mapAccess = FILE_MAP_READ;
+ }
+ else if (access & GNUNET_DISK_MAP_TYPE_WRITE)
+ {
+ protect = PAGE_READWRITE;
+ mapAccess = FILE_MAP_WRITE;
+ }
+ else
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+
+ *m = GNUNET_malloc (sizeof (struct GNUNET_DISK_MapHandle));
+ (*m)->h = CreateFileMapping (h->h, NULL, protect, 0, 0, NULL);
+ if ((*m)->h == INVALID_HANDLE_VALUE)
+ {
+ SetErrnoFromWinError (GetLastError ());
+ GNUNET_free (*m);
+ return NULL;
+ }
+
+ ret = MapViewOfFile ((*m)->h, mapAccess, 0, 0, len);
+ if (!ret)
+ {
+ SetErrnoFromWinError (GetLastError ());
+ CloseHandle ((*m)->h);
+ GNUNET_free (*m);
+ }
+
+ return ret;
+#else
+ int prot;
+ int ec;
+
+ prot = 0;
+ if (access & GNUNET_DISK_MAP_TYPE_READ)
+ prot = PROT_READ;
+ 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)
+ {
+ ec = errno;
+ GNUNET_free (*m);
+ errno = ec;
+ return NULL;
+ }
+ (*m)->len = len;
+ return (*m)->addr;
+#endif
+}
+
+/**
+ * Unmap a file
+ * @param h mapping handle
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h)
+{
+ int ret;
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifdef MINGW
+ ret = UnmapViewOfFile (h->h) ? GNUNET_OK : GNUNET_SYSERR;
+ if (ret != GNUNET_OK)
+ SetErrnoFromWinError (GetLastError ());
+ if (!CloseHandle (h->h) && (ret == GNUNET_OK))
+ {
+ ret = GNUNET_SYSERR;
+ SetErrnoFromWinError (GetLastError ());
+ }
+#else
+ ret = munmap (h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
+#endif
+ GNUNET_free (h);
+ return ret;
+}
+
+
+/**
+ * Write file changes to disk
+ * @param h handle to an open file
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
+{
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifdef MINGW
+ int ret;
+
+ ret = FlushFileBuffers (h->h) ? GNUNET_OK : GNUNET_SYSERR;
+ if (ret != GNUNET_OK)
+ SetErrnoFromWinError (GetLastError ());
+ return ret;
+#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
+ * @return handle to the new pipe, NULL on error
+ */
+struct GNUNET_DISK_PipeHandle *
+GNUNET_DISK_pipe (int blocking)
+{
+ 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)
+ {
+ eno = errno;
+ GNUNET_free (p);
+ errno = eno;
+ return NULL;
+ }
+ p->fd[0]->fd = fd[0];
+ p->fd[1]->fd = fd[1];
+ if (!blocking)
+ {
+ flags = fcntl (fd[0], F_GETFL);
+ flags |= O_NONBLOCK;
+ ret = fcntl (fd[0], F_SETFL, flags);
+ if (ret != -1)
+ {
+ flags = fcntl (fd[1], F_GETFL);
+ flags |= O_NONBLOCK;
+ ret = fcntl (fd[1], F_SETFL, flags);
+ }
+ 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;
+
+ ret = CreatePipe (&p->fd[0]->h, &p->fd[1]->h, NULL, 0);
+ if (!ret)
+ {
+ GNUNET_free (p);
+ SetErrnoFromWinError (GetLastError ());
+ return NULL;
+ }
+ 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 */