Changes to make use of code taken from libassuan. This replaces the
[gnupg.git] / g10 / misc.c
index 207367d..a478392 100644 (file)
@@ -1,6 +1,6 @@
 /* misc.c -  miscellaneous functions
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
- *               2004 Free Software Foundation, Inc.
+ *               2004, 2005 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #ifdef ENABLE_SELINUX_HACKS
 #include <sys/stat.h>
 #endif
+#ifdef _WIN32
+#include <time.h>
+#include <process.h>
+#include <windows.h> 
+#include <shlobj.h>
+#ifndef CSIDL_APPDATA
+#define CSIDL_APPDATA 0x001a
+#endif
+#ifndef CSIDL_LOCAL_APPDATA
+#define CSIDL_LOCAL_APPDATA 0x001c
+#endif
+#ifndef CSIDL_FLAG_CREATE
+#define CSIDL_FLAG_CREATE 0x8000
+#endif
+#include "errors.h"
+#include "dynload.h"
+#endif /*_WIN32*/
+
 #include "util.h"
 #include "main.h"
 #include "photoid.h"
@@ -45,6 +63,8 @@
 #include "cardglue.h"
 
 
+
+
 #ifdef ENABLE_SELINUX_HACKS
 /* A object and a global variable to keep track of files marked as
    secured. */
@@ -198,6 +218,41 @@ is_secured_file (int fd)
   return 0; /* No. */
 }
 
+/* Return true if FNAME is corresponds to a secured file.  Using NULL,
+   "" or "-" for FS is allowed and will return false. This function is
+   used before creating a file, thus it won't fail if the file does
+   not exist. */ 
+int 
+is_secured_filename (const char *fname)
+{
+#ifdef ENABLE_SELINUX_HACKS
+  struct stat buf;
+  struct secured_file_item *sf;
+
+  if (iobuf_is_pipe_filename (fname) || !*fname)
+    return 0; 
+
+  /* Note that we print out a error here and claim that a file is
+     secure if something went wrong. */
+  if (stat (fname, &buf))
+    {
+      if (errno == ENOENT || errno == EPERM || errno == EACCES)
+        return 0;
+      log_error (_("fstat of `%s' failed in %s: %s\n"), fname,
+                 "is_secured_filename", strerror (errno));
+      return 1;
+    }
+/*   log_debug ("is_secured_filename (%s) i=%lu.%lu\n", fname, */
+/*              (unsigned long)buf.st_dev, (unsigned long)buf.st_ino); */
+  for (sf=secured_files; sf; sf = sf->next)
+    {
+      if (sf->ino == buf.st_ino && sf->dev == buf.st_dev)
+        return 1; /* Yes.  */
+    }
+#endif /*ENABLE_SELINUX_HACKS*/
+  return 0; /* No. */
+}
+
 
 
 u16
@@ -248,46 +303,32 @@ buffer_to_u32( const byte *buffer )
     return a;
 }
 
-
-static void
-no_exp_algo(void)
-{
-    static int did_note = 0;
-
-    if( !did_note ) {
-       did_note = 1;
-       log_info(_("Experimental algorithms should not be used!\n"));
-    }
-}
-
 void
 print_pubkey_algo_note( int algo )
 {
-    if( algo >= 100 && algo <= 110 )
-       no_exp_algo();
+  if(algo >= 100 && algo <= 110)
+    {
+      static int warn=0;
+      if(!warn)
+       {
+         warn=1;
+         log_info(_("WARNING: using experimental public key algorithm %s\n"),
+                  pubkey_algo_to_string(algo));
+       }
+    }
 }
 
 void
 print_cipher_algo_note( int algo )
 {
-    if( algo >= 100 && algo <= 110 )
-       no_exp_algo();
-    else if(   algo == CIPHER_ALGO_3DES
-            || algo == CIPHER_ALGO_CAST5
-            || algo == CIPHER_ALGO_BLOWFISH
-            || algo == CIPHER_ALGO_TWOFISH
-            || algo == CIPHER_ALGO_AES
-            || algo == CIPHER_ALGO_AES192
-            || algo == CIPHER_ALGO_AES256
-          )
-       ;
-    else {
-       static int did_note = 0;
-
-       if( !did_note ) {
-           did_note = 1;
-           log_info(_("this cipher algorithm is deprecated; "
-                      "please use a more standard one!\n"));
+  if(algo >= 100 && algo <= 110)
+    {
+      static int warn=0;
+      if(!warn)
+       {
+         warn=1;
+         log_info(_("WARNING: using experimental cipher algorithm %s\n"),
+                  cipher_algo_to_string(algo));
        }
     }
 }
@@ -295,11 +336,21 @@ print_cipher_algo_note( int algo )
 void
 print_digest_algo_note( int algo )
 {
-    if( algo >= 100 && algo <= 110 )
-       no_exp_algo();
+  if(algo >= 100 && algo <= 110)
+    {
+      static int warn=0;
+      if(!warn)
+       {
+         warn=1;
+         log_info(_("WARNING: using experimental digest algorithm %s\n"),
+                  digest_algo_to_string(algo));
+       }
+    }
+  else if(algo==DIGEST_ALGO_MD5)
+    log_info(_("WARNING: digest algorithm %s is deprecated\n"),
+            digest_algo_to_string(algo));
 }
 
-
 /* Return a string which is used as a kind of process ID */
 const byte *
 get_session_marker( size_t *rlen )
@@ -967,3 +1018,86 @@ parse_options(char *str,unsigned int *options,
 
   return 1;
 }
+
+
+/* This is a helper function to load a Windows function from either of
+   one DLLs. */
+#ifdef HAVE_W32_SYSTEM
+static HRESULT
+w32_shgetfolderpath (HWND a, int b, HANDLE c, DWORD d, LPSTR e)
+{
+  static int initialized;
+  static HRESULT (WINAPI * func)(HWND,int,HANDLE,DWORD,LPSTR);
+
+  if (!initialized)
+    {
+      static char *dllnames[] = { "shell32.dll", "shfolder.dll", NULL };
+      void *handle;
+      int i;
+
+      initialized = 1;
+
+      for (i=0, handle = NULL; !handle && dllnames[i]; i++)
+        {
+          handle = dlopen (dllnames[i], RTLD_LAZY);
+          if (handle)
+            {
+              func = dlsym (handle, "SHGetFolderPathA");
+              if (!func)
+                {
+                  dlclose (handle);
+                  handle = NULL;
+                }
+            }
+        }
+    }
+
+  if (func)
+    return func (a,b,c,d,e);
+  else
+    return -1;
+}
+#endif /*HAVE_W32_SYSTEM*/
+
+
+/* Set up the default home directory.  The usual --homedir option
+   should be parsed later. */
+char *
+default_homedir (void)
+{
+  char *dir;
+
+  dir = getenv("GNUPGHOME");
+#ifdef HAVE_W32_SYSTEM
+  if (!dir || !*dir)
+    dir = read_w32_registry_string (NULL, "Software\\GNU\\GnuPG", "HomeDir");
+  if (!dir || !*dir)
+    {
+      char path[MAX_PATH];
+      
+      /* It might be better to use LOCAL_APPDATA because this is
+         defined as "non roaming" and thus more likely to be kept
+         locally.  For private keys this is desired.  However, given
+         that many users copy private keys anyway forth and back,
+         using a system roaming serives might be better than to let
+         them do it manually.  A security conscious user will anyway
+         use the registry entry to have better control.  */
+      if (w32_shgetfolderpath (NULL, CSIDL_APPDATA|CSIDL_FLAG_CREATE, 
+                               NULL, 0, path) >= 0) 
+        {
+          char *tmp = xmalloc (strlen (path) + 6 +1);
+          strcpy (stpcpy (tmp, path), "\\gnupg");
+          dir = tmp;
+          
+          /* Try to create the directory if it does not yet
+             exists.  */
+          if (access (dir, F_OK))
+            CreateDirectory (dir, NULL);
+        }
+    }
+#endif /*HAVE_W32_SYSTEM*/
+  if (!dir || !*dir)
+    dir = GNUPG_HOMEDIR;
+
+  return dir;
+}