/*
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"
int include_sym_links;
} GetFileSizeData;
+struct GNUNET_DISK_FileHandle
+{
+#if MINGW
+ HANDLE h;
+#else
+ int fd;
+#endif
+};
+
static int
getSizeRec (void *ptr, const char *fn)
{
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
+}
+
+
+/**
+ * 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_SEEK_SET] = FILE_BEGIN,
+ [GNUNET_SEEK_CUR] = FILE_CURRENT, [GNUNET_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_SEEK_SET] = SEEK_SET,
+ [GNUNET_SEEK_CUR] = SEEK_CUR, [GNUNET_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).
return ret;
}
+
/**
* Get the number of blocks that are left on the partition that
* contains the given file (for normal users).
/**
* 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)
-{
- /* open file, must exist, open read only */
- int handle;
- int size;
-
- 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;
+ssize_t
+GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, void *result,
+ size_t len)
+{
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifdef MINGW
+ DWORD bytesRead;
+
+ 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 * const 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);
+ 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, iit 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
+ */
+ssize_t
+GNUNET_DISK_fn_write (const char * const fn, const void *buffer,
+ size_t n, int mode)
+{
+ struct GNUNET_DISK_FileHandle *fh;
+ int 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 = (n == GNUNET_DISK_file_write (fh, buffer, n)) ? GNUNET_OK : GNUNET_SYSERR;
+ GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
+
+ return ret;
}
/**
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
/**
unsigned long long pos;
unsigned long long size;
unsigned long long len;
- int in;
- int out;
+ struct GNUNET_DISK_FileHandle *in, *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);
+ 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;
}
}
+/**
+ * Lock a part of a file
+ * @param fh file handle
+ * @lockStart absolute position from where to lock
+ * @lockEnd absolute position until where to 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)
+{
+ if (fh == NULL)
+ {
+ errno = EINVAL;
+ return GNUNET_SYSERR;
+ }
+
+#ifndef MINGW
+ struct flock fl;
+
+ memset(&fl, 0, sizeof(struct flock));
+ fl.l_type = F_WRLCK;
+ 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
+ if (!LockFile(fh->h, 0, lockStart, 0, lockEnd))
+ {
+ SetErrnoFromWinError(GetLastError());
+ return GNUNET_SYSERR;
+ }
+
+ return GNUNET_OK;
+#endif
+}
+
+
+/**
+ * Open a file
+ * @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
+ * @return IO handle on success, NULL on error
+ */
+struct GNUNET_DISK_FileHandle *
+GNUNET_DISK_file_open (const char *fn, int flags, ...)
+{
+ 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);
+
+#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 */
+ else if (flags & GNUNET_DISK_OPEN_READ)
+ oflags = O_RDONLY;
+ else if (flags & GNUNET_DISK_OPEN_WRITE)
+ oflags = O_WRONLY;
+ else
+ {
+ GNUNET_break (0);
+ 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)
+ {
+ int perm;
+
+ 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)
+ 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)
+ {
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
+ GNUNET_free (expfn);
+ return NULL;
+ }
+#else
+ access = 0;
+ disp = OPEN_ALWAYS;
+
+ if (flags & GNUNET_DISK_OPEN_READ)
+ access = FILE_READ_DATA;
+ 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;
+
+ /* 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
return ret;
}
+struct GNUNET_DISK_MapHandle
+{
+#ifdef MINGW
+ HANDLE h;
+#else
+ void *addr;
+ size_t len;
+#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 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)
+{
+ if (h == NULL)
+ {
+ errno = EINVAL;
+ return NULL;
+ }
+
+#ifdef MINGW
+ DWORD mapAccess, protect;
+ void *ret;
+
+ if (access & GNUNET_DISK_MAP_READ && access & GNUNET_DISK_MAP_WRITE)
+ {
+ protect = PAGE_READWRITE;
+ mapAccess = FILE_MAP_ALL_ACCESS;
+ }
+ else if (access & GNUNET_DISK_MAP_READ)
+ {
+ protect = PAGE_READONLY;
+ mapAccess = FILE_MAP_READ;
+ }
+ else if (access & GNUNET_DISK_MAP_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;
+
+ prot = 0;
+ if (access & GNUNET_DISK_MAP_READ)
+ prot = PROT_READ;
+ if (access & GNUNET_DISK_MAP_WRITE)
+ prot |= PROT_WRITE;
+ *m = GNUNET_malloc (sizeof (struct GNUNET_DISK_MapHandle));
+ (*m)->addr = mmap (NULL, len, prot, MAP_SHARED, h->fd, 0);
+ (*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 (addr) ? 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;
+#else
+ return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
+#endif
+}
/* end of disk.c */
projects / oweals / gnunet.git / blobdiff