/**
* File descriptors for the pipe.
*/
- struct GNUNET_DISK_FileHandle * fd[2];
+ struct GNUNET_DISK_FileHandle *fd[2];
};
* @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_DISK_SEEK_SET] = FILE_BEGIN,
- [GNUNET_DISK_SEEK_CUR] = FILE_CURRENT, [GNUNET_DISK_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_DISK_SEEK_SET] = SEEK_SET,
- [GNUNET_DISK_SEEK_CUR] = SEEK_CUR, [GNUNET_DISK_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
*/
int
GNUNET_DISK_file_size (const char *filename,
- uint64_t *size,
- int includeSymLinks)
+ uint64_t * size, int includeSymLinks)
{
struct GetFileSizeData gfsd;
int ret;
* @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)
+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) ) )
+ if ((0 == stat (filename, &sbuf)) && (0 == statvfs (filename, &fbuf)))
{
- *dev = (uint32_t) fbuf.f_fsid;
+ *dev = (uint64_t) fbuf.f_fsid;
*ino = (uint64_t) sbuf.st_ino;
return GNUNET_OK;
}
-#endif
+#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.
+ * 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/".
char *tmpl;
char *fn;
- tmpdir = getenv ("TMPDIR");
- tmpdir = tmpdir ? tmpdir : "/tmp";
-
- GNUNET_asprintf (&tmpl,
- "%s%s%s%s",
- tmpdir,
- DIR_SEPARATOR_STR,
- t,
- "XXXXXX");
+ 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);
- plibc_conv_to_win_path (tmpl, fn);
+ if (ERROR_SUCCESS != plibc_conv_to_win_path (tmpl, fn))
+ {
+ GNUNET_free (fn);
+ GNUNET_free (tmpl);
+ return NULL;
+ }
GNUNET_free (tmpl);
#else
fn = tmpl;
fd = mkstemp (fn);
if (fd == -1)
{
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
- "mkstemp",
- fn);
+ 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);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn);
return fn;
}
char *path;
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;
}
* @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 * 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,
- GNUNET_DISK_PERM_NONE);
+ 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)
{
* @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)
+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);
+ 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));
+ GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
return ret;
}
int
GNUNET_DISK_directory_scan (const char *dirName,
GNUNET_FileNameCallback callback,
- void *callback_cls)
+ 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))
*/
struct GNUNET_DISK_DirectoryIterator
{
- /**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
/**
* Function to call on directory entries.
GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES);
return GNUNET_NO;
}
- GNUNET_SCHEDULER_add_after (iter->sched,
- GNUNET_YES,
- iter->priority,
- GNUNET_SCHEDULER_NO_TASK,
- &directory_iterator_task, iter);
+ GNUNET_SCHEDULER_add_with_priority (iter->priority,
+ &directory_iterator_task, iter);
return GNUNET_YES;
}
* If a scheduler does not need to be used, GNUNET_DISK_directory_scan
* may provide a simpler API.
*
- * @param sched scheduler to use
* @param prio priority to use
* @param dirName the name of the directory
* @param callback the method to call for each file
* @param callback_cls closure for callback
*/
void
-GNUNET_DISK_directory_iterator_start (struct GNUNET_SCHEDULER_Handle *sched,
- enum GNUNET_SCHEDULER_Priority prio,
+GNUNET_DISK_directory_iterator_start (enum GNUNET_SCHEDULER_Priority prio,
const char *dirName,
GNUNET_DISK_DirectoryIteratorCallback
callback, void *callback_cls)
struct GNUNET_DISK_DirectoryIterator *di;
di = GNUNET_malloc (sizeof (struct GNUNET_DISK_DirectoryIterator));
- di->sched = sched;
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);
static int
remove_helper (void *unused, const char *fn)
{
- GNUNET_DISK_directory_remove (fn);
+ (void) GNUNET_DISK_directory_remove (fn);
return GNUNET_OK;
}
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_SYSERR;
pos = 0;
in = GNUNET_DISK_file_open (src, GNUNET_DISK_OPEN_READ,
- GNUNET_DISK_PERM_NONE);
+ 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);
*/
int
GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh, off_t lockStart,
- off_t lockEnd, int excl)
+ off_t lockEnd, int excl)
{
if (fh == NULL)
{
#ifndef MINGW
struct flock fl;
- memset (&fl, 0, sizeof(struct flock));
+ memset (&fl, 0, sizeof (struct flock));
fl.l_type = excl ? F_WRLCK : F_RDLCK;
fl.l_whence = SEEK_SET;
fl.l_start = lockStart;
#else
OVERLAPPED o;
- memset (&o, 0, sizeof(OVERLAPPED));
+ 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))
+ | LOCKFILE_FAIL_IMMEDIATELY, 0, lockEnd - lockStart, 0,
+ &o))
{
SetErrnoFromWinError (GetLastError ());
return GNUNET_SYSERR;
*/
int
GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, off_t unlockStart,
- off_t unlockEnd)
+ off_t unlockEnd)
{
if (fh == NULL)
{
#ifndef MINGW
struct flock fl;
- memset (&fl, 0, sizeof(struct flock));
+ memset (&fl, 0, sizeof (struct flock));
fl.l_type = F_UNLCK;
fl.l_whence = SEEK_SET;
fl.l_start = unlockStart;
#else
OVERLAPPED o;
- memset (&o, 0, sizeof(OVERLAPPED));
+ memset (&o, 0, sizeof (OVERLAPPED));
o.Offset = unlockStart;
if (!UnlockFileEx (fh->h, 0, unlockEnd - unlockStart, 0, &o))
*/
struct GNUNET_DISK_FileHandle *
GNUNET_DISK_file_open (const char *fn,
- enum GNUNET_DISK_OpenFlags flags,
- enum GNUNET_DISK_AccessPermissions perm)
+ 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;
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)
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)
{
+ (void) GNUNET_DISK_directory_create_for_file (expfn);
oflags |= O_CREAT;
if (perm & GNUNET_DISK_PERM_USER_READ)
mode |= S_IRUSR;
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;
disp = TRUNCATE_EXISTING;
}
else
- {
- disp = OPEN_ALWAYS;
- }
+ {
+ 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
#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;
};
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *) -1)
+#endif
+
/**
* Map a file into memory
*
* @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)
+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_TYPE_READ) &&
+ if ((access & GNUNET_DISK_MAP_TYPE_READ) &&
(access & GNUNET_DISK_MAP_TYPE_WRITE))
{
protect = PAGE_READWRITE;
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
#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)
+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));
+ 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];
if (ret == -1)
{
eno = errno;
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
GNUNET_free (p);
errno = eno;
return NULL;
}
p->fd[0]->fd = fd[0];
p->fd[1]->fd = fd[1];
+ ret = 0;
+ flags = fcntl (fd[0], F_GETFL);
if (!blocking)
+ flags |= O_NONBLOCK;
+ if (0 > fcntl (fd[0], F_SETFL, flags))
+ ret = -1;
+ flags = fcntl (fd[0], F_GETFD);
+ flags |= FD_CLOEXEC;
+ if (0 > fcntl (fd[0], F_SETFD, flags))
+ ret = -1;
+
+ flags = fcntl (fd[1], F_GETFL);
+ if (!blocking)
+ flags |= O_NONBLOCK;
+ if (0 > fcntl (fd[1], F_SETFL, flags))
+ ret = -1;
+ flags = fcntl (fd[1], F_GETFD);
+ flags |= FD_CLOEXEC;
+ if (0 > fcntl (fd[1], F_SETFD, flags))
+ ret = -1;
+ if (ret == -1)
{
- 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;
- }
+ 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)
+ 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;
- p->fd[0] = GNUNET_malloc(sizeof(struct GNUNET_DISK_FileHandle));
- p->fd[1] = GNUNET_malloc(sizeof(struct GNUNET_DISK_FileHandle));
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 */
}
+/**
+ * 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
*
{
int ret = GNUNET_OK;
int save;
-
+
#ifdef MINGW
if (!CloseHandle (p->fd[0]->h))
{
save = errno;
#else
save = 0;
- if (0 != close (p->fd[0]->fd))
+ if (p->fd[0]->fd != -1)
{
- ret = GNUNET_SYSERR;
- save = errno;
+ if (0 != close (p->fd[0]->fd))
+ {
+ ret = GNUNET_SYSERR;
+ save = errno;
+ }
}
- if (0 != close (p->fd[1]->fd))
+
+ if (p->fd[1]->fd != -1)
{
- ret = GNUNET_SYSERR;
- save = errno;
+ if (0 != close (p->fd[1]->fd))
+ {
+ ret = GNUNET_SYSERR;
+ save = errno;
+ }
}
#endif
GNUNET_free (p);
/**
* 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)
+GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
+ enum GNUNET_DISK_PipeEnd n)
{
switch (n)
{
*/
int
GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,
- void *dst,
- size_t dst_len)
+ 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))
+ if (dst_len < sizeof (int))
return GNUNET_SYSERR;
*((int *) dst) = fh->fd;
#endif
projects / oweals / gnunet.git / blobdiff