Detect unsigned time_t and adjust y2038 detection.
[gnupg.git] / util / fileutil.c
index 8651315..202b324 100644 (file)
@@ -1,11 +1,11 @@
 /* fileutil.c -  file utilities
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 2003, 2005, 2007 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -14,8 +14,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <string.h>
 #include <assert.h>
 #include <unistd.h>
+#include <sys/types.h>
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+#include <ctype.h>
+#ifdef HAVE_W32_SYSTEM
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#else /*!HAVE_W32_SYSTEM*/
+# include <sys/types.h>
+# include <sys/stat.h>
+# include <unistd.h>
+#endif /*!HAVE_W32_SYSTEM*/
+
+
 #include "util.h"
 #include "memory.h"
 #include "ttyio.h"
@@ -49,10 +63,10 @@ make_basename(const char *filepath, const char *inputpath)
            if ( !(p=strrchr(filepath, ':')) )
 #endif
              {
-               return m_strdup(filepath);
+               return xstrdup(filepath);
              }
 
-    return m_strdup(p+1);
+    return xstrdup(p+1);
 }
 
 
@@ -71,35 +85,90 @@ make_dirname(const char *filepath)
     char *p;
 
     if ( !(p=strrchr(filepath, DIRSEP_C)) )
-      #ifdef HAVE_DRIVE_LETTERS
+#ifdef HAVE_DRIVE_LETTERS
        if ( !(p=strrchr(filepath, '\\')) )
            if ( !(p=strrchr(filepath, ':')) )
-      #endif
+#endif
              {
-               return m_strdup(EXTSEP_S);
+               return xstrdup(EXTSEP_S);
              }
 
     dirname_length = p-filepath;
-    dirname = m_alloc(dirname_length+1);
+    dirname = xmalloc(dirname_length+1);
     strncpy(dirname, filepath, dirname_length);
     dirname[dirname_length] = 0;
 
     return dirname;
 }
 
+/* Expand tildes.  Handles both the ~/foo and ~username/foo cases.
+   Returns what the tilde expands to.  *name is advanced to be past
+   the tilde expansion. */
+static char *
+untilde(const char **name)
+{
+  char *home=NULL;
+
+  assert((*name)[0]=='~');
+
+  if((*name)[1]==DIRSEP_C || (*name)[1]=='\0')
+    {
+      /* This is the "~/foo" or "~" case. */
+      char *tmp=getenv("HOME");
+      if(tmp)
+       home=xstrdup(tmp);
+
+#ifdef HAVE_GETPWUID
+      if(!home)
+       {
+         struct passwd *pwd;
+
+         pwd=getpwuid(getuid());
+         if(pwd)
+           home=xstrdup(pwd->pw_dir);
+       }
+#endif
+      if(home)
+       (*name)++;
+    }
+#ifdef HAVE_GETPWNAM
+  else
+    {
+      /* This is the "~username" case. */
+      char *user,*sep;
+      struct passwd *pwd;
+
+      user=xstrdup((*name)+1);
+
+      sep=strchr(user,DIRSEP_C);
+      if(sep)
+       *sep='\0';
+
+      pwd=getpwnam(user);
+      if(pwd)
+       {
+         home=xstrdup(pwd->pw_dir);
+         (*name)+=1+strlen(user);
+       }
+
+      xfree(user);
+    }
+#endif
 
+  return home;
+}
 
-/****************
- * Construct a filename from the NULL terminated list of parts.
- * Tilde expansion is done here.
- */
+/*
+  Construct a filename from the NULL terminated list of parts.  Tilde
+  expansion is done here.  Note that FIRST_PART must never be NULL and
 that this function is guaranteed to return an allocated string.  */
 char *
 make_filename( const char *first_part, ... )
 {
     va_list arg_ptr ;
     size_t n;
     const char *s;
-    char *name, *home, *p;
+    char *name, *p, *home=NULL;
 
     va_start( arg_ptr, first_part ) ;
     n = strlen(first_part)+1;
@@ -107,56 +176,114 @@ make_filename( const char *first_part, ... )
        n += strlen(s) + 1;
     va_end(arg_ptr);
 
-    home = NULL;
 #ifndef __riscos__
-    if( *first_part == '~' && first_part[1] == DIRSEP_C
-                          && (home = getenv("HOME")) && *home )
-       n += strlen(home);
+    if(*first_part=='~')
+      {
+       home=untilde(&first_part);
+       if(home)
+         n+=strlen(home);
+      }
 #endif
-    name = m_alloc(n);
-    p = home ? stpcpy(stpcpy(name,home), first_part+1)
+    name = xmalloc(n);
+    p = home ? stpcpy(stpcpy(name,home), first_part)
             : stpcpy(name, first_part);
     va_start( arg_ptr, first_part ) ;
     while( (s=va_arg(arg_ptr, const char *)) )
        p = stpcpy(stpcpy(p, DIRSEP_S), s);
     va_end(arg_ptr);
+    xfree(home);
 
 #ifndef __riscos__
     return name;
 #else /* __riscos__ */
-    p = gstrans(name);
-    m_free(name);
+    p = riscos_gstrans(name);
+    xfree(name);
     return p;
 #endif /* __riscos__ */
 }
 
 
+/* Compare whether the filenames are identical.  This is a
+   special version of strcmp() taking the semantics of filenames in
+   account.  Note that this function works only on the supplied names
+   without considereing any context like the current directory.  See
+   also same_file_p(). */
 int
-compare_filenames( const char *a, const char *b )
+compare_filenames (const char *a, const char *b)
 {
-    /* ? check whether this is an absolute filename and
-     * resolve symlinks?
-     */
-#ifndef __riscos__
-  #ifdef HAVE_DRIVE_LETTERS
-    return ascii_strcasecmp(a,b);
-  #else
-    return strcmp(a,b);
-  #endif
-#else /* __riscos__ */
-    int c = 0;
-    char *abuf, *bbuf;
-
-    abuf = gstrans(a);
-    bbuf = gstrans(b);
-
-    c = ascii_strcasecmp (abuf, bbuf);
-
-    m_free(abuf);
-    m_free(bbuf);
+#ifdef __riscos__
+  int c = 0;
+  char *abuf, *bbuf;
+  
+  abuf = riscos_gstrans(a);
+  bbuf = riscos_gstrans(b);
+  c = ascii_strcasecmp (abuf, bbuf);
+  xfree(abuf);
+  xfree(bbuf);
+  
+  return c;
+#elif defined (HAVE_DRIVE_LETTERS)
+  for ( ; *a && *b; a++, b++ ) 
+    {
+      if (*a != *b 
+          && (toupper (*(const unsigned char*)a)
+              != toupper (*(const unsigned char*)b) )
+          && !((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/')))
+        break;
+    }
+  if ((*a == '/' && *b == '\\') || (*a == '\\' && *b == '/'))
+    return 0;
+  else
+    return (toupper (*(const unsigned char*)a) 
+            - toupper (*(const unsigned char*)b));
+#else /*!HAVE_DRIVE_LETTERS*/
+  return strcmp (a,b);
+#endif
+}
 
-    return c;
-#endif /* __riscos__ */
+/* Check whether the files NAME1 and NAME2 are identical.  This is for
+   example achieved by comparing the inode numbers of the files.  */
+int
+same_file_p (const char *name1, const char *name2)
+{
+  int yes;
+      
+  /* First try a shortcut.  */
+  if (!compare_filenames (name1, name2))
+    yes = 1;
+  else
+    {
+#ifdef HAVE_W32_SYSTEM  
+      HANDLE file1, file2;
+      BY_HANDLE_FILE_INFORMATION info1, info2;
+      
+      file1 = CreateFile (name1, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
+      if (file1 == INVALID_HANDLE_VALUE)
+        yes = 0; /* If we can't open the file, it is not the same.  */
+      else
+        {
+          file2 = CreateFile (name2, 0, 0, NULL, OPEN_EXISTING, 0, NULL);
+          if (file1 == INVALID_HANDLE_VALUE)
+            yes = 0; /* If we can't open the file, it is not the same.  */
+          else
+            {
+              yes = (GetFileInformationByHandle (file1, &info1)
+                     && GetFileInformationByHandle (file2, &info2)
+                     && info1.dwVolumeSerialNumber==info2.dwVolumeSerialNumber
+                     && info1.nFileIndexHigh == info2.nFileIndexHigh
+                     && info1.nFileIndexLow == info2.nFileIndexLow);
+              CloseHandle (file2);
+            }
+          CloseHandle (file1);
+        }
+#else /*!HAVE_W32_SYSTEM*/
+      struct stat info1, info2;
+      
+      yes = (!stat (name1, &info1) && !stat (name2, &info2)
+             && info1.st_dev == info2.st_dev && info1.st_ino == info2.st_ino);
+#endif /*!HAVE_W32_SYSTEM*/
+    }
+  return yes;
 }
 
 
@@ -190,6 +317,7 @@ is_file_compressed( const char *s, int *ret_rc )
     IOBUF a;
     byte buf[4];
     int i, rc = 0;
+    int overflow;
 
     struct magic_compress_s {
         size_t len;
@@ -200,7 +328,7 @@ is_file_compressed( const char *s, int *ret_rc )
         { 4, { 0x50, 0x4b, 0x03, 0x04 } }, /* (pk)zip */
     };
     
-    if ( !s || *s == '-' || !ret_rc )
+    if ( iobuf_is_pipe_filename (s) || !ret_rc )
         return 0; /* We can't check stdin or no file was given */
 
     a = iobuf_open( s );
@@ -209,7 +337,7 @@ is_file_compressed( const char *s, int *ret_rc )
         return 0;
     }
 
-    if ( iobuf_get_filelength( a ) < 4 ) {
+    if ( iobuf_get_filelength( a, &overflow ) < 4 && !overflow) {
         *ret_rc = 0;
         goto leave;
     }
@@ -231,5 +359,3 @@ leave:
     iobuf_close( a );
     return rc;
 }
-
-