-check return value

[oweals/gnunet.git] / src / util / disk.c

diff --git a/src/util/disk.c b/src/util/disk.c
index 32263584b40341111c1be215d9a740c786eedb6e..5f0e15e137fdbabdec1820aaff71d7a41a9a518b 100644 (file)
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -660,7 +660,7 @@ GNUNET_DISK_file_test (const char *fil)
     GNUNET_free (rdir);
     return GNUNET_NO;
   }
-  if (ACCESS (rdir, R_OK) < 0)
+  if (ACCESS (rdir, F_OK) < 0)
   {
     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "access", rdir);
     GNUNET_free (rdir);
@@ -801,7 +801,7 @@ GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
 #ifdef MINGW
   DWORD bytesRead;
 
-  if (h->type != GNUNET_PIPE)
+  if (h->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
   {
     if (!ReadFile (h->h, result, len, &bytesRead, NULL))
     {
@@ -843,7 +843,8 @@ GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
  */
 ssize_t
 GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle * h,
-    void *result, size_t len)
+                                   void *result, 
+                                   size_t len)
 {
   if (h == NULL)
   {
@@ -854,7 +855,7 @@ GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle * h,
 #ifdef MINGW
   DWORD bytesRead;
 
-  if (h->type != GNUNET_PIPE)
+  if (h->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
   {
     if (!ReadFile (h->h, result, len, &bytesRead, NULL))
     {
@@ -891,10 +892,14 @@ GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle * h,
   /* set to non-blocking, read, then set back */
   flags = fcntl (h->fd, F_GETFL);
   if (0 == (flags & O_NONBLOCK))
-    fcntl (h->fd, F_SETFL, flags | O_NONBLOCK);
+    (void) fcntl (h->fd, F_SETFL, flags | O_NONBLOCK);
   ret = read (h->fd, result, len);
   if (0 == (flags & O_NONBLOCK))
-    fcntl (h->fd, F_SETFL, flags);
+    {
+      int eno = errno;
+      (void) fcntl (h->fd, F_SETFL, flags);
+      errno = eno;
+    }
   return ret;
 #endif
 }
@@ -944,7 +949,7 @@ GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
 #ifdef MINGW
   DWORD bytesWritten;
 
-  if (h->type != GNUNET_PIPE)
+  if (h->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
   {
     if (!WriteFile (h->h, buffer, n, &bytesWritten, NULL))
     {
@@ -1057,10 +1062,10 @@ GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle * h,
   /* set to blocking, write, then set back */
   flags = fcntl (h->fd, F_GETFL);
   if (0 != (flags & O_NONBLOCK))
-    fcntl (h->fd, F_SETFL, flags - O_NONBLOCK);
+    (void) fcntl (h->fd, F_SETFL, flags - O_NONBLOCK);
   ret = write (h->fd, buffer, n);
   if (0 == (flags & O_NONBLOCK))
-    fcntl (h->fd, F_SETFL, flags);
+    (void) fcntl (h->fd, F_SETFL, flags);
   return ret;
 #endif
 }
@@ -1347,34 +1352,34 @@ remove_helper (void *unused, const char *fn)
  * caution.
  *
  *
- * @param fileName the file to remove
+ * @param filename the file to remove
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_directory_remove (const char *fileName)
+GNUNET_DISK_directory_remove (const char *filename)
 {
   struct stat istat;
 
-  if (0 != LSTAT (fileName, &istat))
+  if (0 != LSTAT (filename, &istat))
     return GNUNET_NO;           /* file may not exist... */
-  CHMOD (fileName, S_IWUSR | S_IRUSR | S_IXUSR);
-  if (UNLINK (fileName) == 0)
+  (void) CHMOD (filename, S_IWUSR | S_IRUSR | S_IXUSR);
+  if (UNLINK (filename) == 0)
     return GNUNET_OK;
   if ((errno != EISDIR) &&
       /* EISDIR is not sufficient in all cases, e.g.
        * sticky /tmp directory may result in EPERM on BSD.
        * So we also explicitly check "isDirectory" */
-      (GNUNET_YES != GNUNET_DISK_directory_test (fileName)))
+      (GNUNET_YES != GNUNET_DISK_directory_test (filename)))
   {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", fileName);
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
     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))
+  if (0 != RMDIR (filename))
   {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", fileName);
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
     return GNUNET_SYSERR;
   }
   return GNUNET_OK;
@@ -1708,9 +1713,12 @@ GNUNET_DISK_file_open (const char *fn, enum GNUNET_DISK_OpenFlags flags,
     h = INVALID_HANDLE_VALUE;
   if (h == INVALID_HANDLE_VALUE)
   {
+    int err;
     SetErrnoFromWinError (GetLastError ());
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
+    err = errno;
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_INFO, "open", expfn);
     GNUNET_free (expfn);
+    errno = err;
     return NULL;
   }
 
@@ -1728,7 +1736,7 @@ GNUNET_DISK_file_open (const char *fn, enum GNUNET_DISK_OpenFlags flags,
   ret = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
 #ifdef MINGW
   ret->h = h;
-  ret->type = GNUNET_DISK_FILE;
+  ret->type = GNUNET_DISK_HANLDE_TYPE_FILE;
 #else
   ret->fd = fd;
 #endif
@@ -1783,21 +1791,45 @@ GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h)
 struct GNUNET_DISK_FileHandle *
 GNUNET_DISK_get_handle_from_native (FILE *fd)
 {
-#if MINGW
-  // FIXME: LRN help!
-  GNUNET_break (0);
-  return NULL;
-#else
   struct GNUNET_DISK_FileHandle *fh;
   int fno;
+#if MINGW
+  intptr_t osfh;
+#endif
 
   fno = fileno (fd);
   if (-1 == fno)
     return NULL;
+
+#if MINGW
+  osfh = _get_osfhandle (fno);
+  if (INVALID_HANDLE_VALUE == (HANDLE) osfh)
+    return NULL;
+#endif
+
   fh = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+
+#if MINGW
+  fh->h = (HANDLE) osfh;
+  /* Assume it to be a pipe. TODO: use some kind of detection
+   * function to figure out handle type.
+   * Note that we can't make it overlapped if it isn't already.
+   * (ReOpenFile() is only available in 2003/Vista).
+   * The process that opened this file in the first place (usually a parent
+   * process, if this is stdin/stdout/stderr) must make it overlapped,
+   * otherwise we're screwed, as selecting on non-overlapped handle
+   * will block.
+   */
+  fh->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
+  fh->oOverlapRead = GNUNET_malloc (sizeof (OVERLAPPED));
+  fh->oOverlapWrite = GNUNET_malloc (sizeof (OVERLAPPED));
+  fh->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
+  fh->oOverlapWrite->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
+#else
   fh->fd = fno;
-  return fh;
 #endif
+
+  return fh;
 }
 
 
@@ -2247,8 +2279,8 @@ GNUNET_DISK_pipe (int blocking_read, int blocking_write, int inherit_read, int i
   CloseHandle (p->fd[1]->h);
   p->fd[1]->h = tmp_handle;
 
-  p->fd[0]->type = GNUNET_PIPE;
-  p->fd[1]->type = GNUNET_PIPE;
+  p->fd[0]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
+  p->fd[1]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
 
   p->fd[0]->oOverlapRead = GNUNET_malloc (sizeof (OVERLAPPED));
   p->fd[0]->oOverlapWrite = GNUNET_malloc (sizeof (OVERLAPPED));
@@ -2360,7 +2392,7 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 
   if (p->fd[0]->h != INVALID_HANDLE_VALUE)
   {
-    p->fd[0]->type = GNUNET_PIPE;
+    p->fd[0]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
     p->fd[0]->oOverlapRead = GNUNET_malloc (sizeof (OVERLAPPED));
     p->fd[0]->oOverlapWrite = GNUNET_malloc (sizeof (OVERLAPPED));
     p->fd[0]->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
@@ -2369,7 +2401,7 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 
   if (p->fd[1]->h != INVALID_HANDLE_VALUE)
   {
-    p->fd[1]->type = GNUNET_PIPE;
+    p->fd[1]->type = GNUNET_DISK_HANLDE_TYPE_PIPE;
     p->fd[1]->oOverlapRead = GNUNET_malloc (sizeof (OVERLAPPED));
     p->fd[1]->oOverlapWrite = GNUNET_malloc (sizeof (OVERLAPPED));
     p->fd[1]->oOverlapRead->hEvent = CreateEvent (NULL, FALSE, FALSE, NULL);