*/
int
GNUNET_DISK_file_get_identifiers (const char *filename,
- uint32_t * dev, uint64_t * ino)
+ uint64_t * dev, uint64_t * ino)
{
#if LINUX
struct stat sbuf;
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;
}
+#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", tmpdir, 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);
if (ERROR_SUCCESS != plibc_conv_to_win_path (tmpl, fn))
char *path;
path = GNUNET_STRINGS_filename_expand (part);
+ if (path == NULL)
+ return -1;
memcpy (szDrive, path, 3);
GNUNET_free (path);
szDrive[3] = 0;
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_with_priority (iter->sched,
- iter->priority,
+ 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);
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))
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);
+ 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;
}
return ret;
#else
int prot;
- int ec;
prot = 0;
if (access & GNUNET_DISK_MAP_TYPE_READ)
GNUNET_assert (NULL != (*m)->addr);
if (MAP_FAILED == (*m)->addr)
{
- ec = errno;
GNUNET_free (*m);
- errno = ec;
return NULL;
}
(*m)->len = len;
#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;
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)
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;
* 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)
+GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p,
+ enum GNUNET_DISK_PipeEnd end)
{
int ret = GNUNET_OK;
int save;
- /* FIXME: What can we safely set HANDLE to once we've closed an end, NULL? */
#ifdef MINGW
if (end == GNUNET_DISK_PIPE_END_READ)
{
SetErrnoFromWinError (GetLastError ());
ret = GNUNET_SYSERR;
}
+ p->fd[0]->h = INVALID_HANDLE_VALUE;
}
else if (end == GNUNET_DISK_PIPE_END_WRITE)
{
SetErrnoFromWinError (GetLastError ());
ret = GNUNET_SYSERR;
}
+ p->fd[1]->h = INVALID_HANDLE_VALUE;
}
save = errno;
#else
/**
* 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,
projects / oweals / gnunet.git / blobdiff