* options.h, main.h, export.c (parse_export_options, do_export_stream),
[gnupg.git] / g10 / misc.c
index 09811ae..c2330d9 100644 (file)
@@ -1,5 +1,5 @@
 /* misc.c -  miscellaneous functions
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 #include <errno.h>
+#ifdef HAVE_STAT
+#include <sys/stat.h>
+#endif
 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
   #include <asm/sysinfo.h>
   #include <asm/unistd.h>
 #endif
 #ifdef HAVE_SETRLIMIT
+  #include <time.h>
   #include <sys/time.h>
   #include <sys/resource.h>
 #endif
 #include "util.h"
 #include "main.h"
+#include "photoid.h"
 #include "options.h"
 #include "i18n.h"
 
@@ -41,7 +47,10 @@ const char *g10m_revision_string(int);
 const char *g10c_revision_string(int);
 const char *g10u_revision_string(int);
 
-volatile void
+#ifdef __GNUC__
+volatile
+#endif
+        void
 pull_in_libs(void)
 {
     g10m_revision_string(0);
@@ -51,7 +60,6 @@ pull_in_libs(void)
 
 
 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
-#warning using trap_unaligned
 static int
 setsysinfo(unsigned long op, void *buffer, unsigned long size,
                     int *start, void *arg, unsigned long flag)
@@ -76,21 +84,24 @@ trap_unaligned(void)
 #endif
 
 
-void
+int
 disable_core_dumps()
 {
+ #ifdef HAVE_DOSISH_SYSTEM
+    return 0;
+ #else
   #ifdef HAVE_SETRLIMIT
     struct rlimit limit;
 
     limit.rlim_cur = 0;
     limit.rlim_max = 0;
     if( !setrlimit( RLIMIT_CORE, &limit ) )
-       return;
-    if( errno != EINVAL )
+       return 0;
+    if( errno != EINVAL && errno != ENOSYS )
        log_fatal(_("can't disable core dumps: %s\n"), strerror(errno) );
   #endif
-    if( !opt.quiet )
-       log_info(_("WARNING: program may create a core file!\n"));
+    return 1;
+ #endif
 }
 
 
@@ -206,15 +217,6 @@ print_pubkey_algo_note( int algo )
 {
     if( algo >= 100 && algo <= 110 )
        no_exp_algo();
-    else if( is_RSA( algo ) ) {
-       static int did_note = 0;
-
-       if( !did_note ) {
-           did_note = 1;
-           log_info(_("RSA keys are deprecated; please consider "
-                      "creating a new key and use this key in the future\n"));
-       }
-    }
 }
 
 void
@@ -225,6 +227,10 @@ print_cipher_algo_note( int algo )
     else if(   algo == CIPHER_ALGO_3DES
             || algo == CIPHER_ALGO_CAST5
             || algo == CIPHER_ALGO_BLOWFISH
+            || algo == CIPHER_ALGO_TWOFISH
+            || algo == CIPHER_ALGO_RIJNDAEL
+            || algo == CIPHER_ALGO_RIJNDAEL192
+            || algo == CIPHER_ALGO_RIJNDAEL256
           )
        ;
     else {
@@ -232,7 +238,7 @@ print_cipher_algo_note( int algo )
 
        if( !did_note ) {
            did_note = 1;
-           log_info(_("this cipher algorithm is depreciated; "
+           log_info(_("this cipher algorithm is deprecated; "
                       "please use a more standard one!\n"));
        }
     }
@@ -246,4 +252,440 @@ print_digest_algo_note( int algo )
 }
 
 
+/* Return a string which is used as a kind of process ID */
+const byte *
+get_session_marker( size_t *rlen )
+{
+    static byte marker[SIZEOF_UNSIGNED_LONG*2];
+    static int initialized;
+
+    if ( !initialized ) {
+        volatile ulong aa, bb; /* we really want the uninitialized value */
+        ulong a, b;
+
+        initialized = 1;
+        /* also this marker is guessable it is not easy to use this 
+         * for a faked control packet because an attacker does not
+         * have enough control about the time the verification does 
+         * take place.  Of course, we can add just more random but 
+         * than we need the random generator even for verification
+         * tasks - which does not make sense. */
+        a = aa ^ (ulong)getpid();
+        b = bb ^ (ulong)time(NULL);
+        memcpy( marker, &a, SIZEOF_UNSIGNED_LONG );
+        memcpy( marker+SIZEOF_UNSIGNED_LONG, &b, SIZEOF_UNSIGNED_LONG );
+    }
+    *rlen = sizeof(marker);
+    return marker;
+}
+
+/****************
+ * Wrapper around the libgcrypt function with addional checks on
+ * openPGP contraints for the algo ID.
+ */
+int
+openpgp_cipher_test_algo( int algo )
+{
+    if( algo < 0 || algo > 110 )
+        return G10ERR_CIPHER_ALGO;
+    return check_cipher_algo(algo);
+}
+
+int
+openpgp_pk_test_algo( int algo, unsigned int usage_flags )
+{
+    if( algo < 0 || algo > 110 )
+       return G10ERR_PUBKEY_ALGO;
+    return check_pubkey_algo2( algo, usage_flags );
+}
+
+int 
+openpgp_pk_algo_usage ( int algo )
+{
+    int use = 0; 
+    
+    /* they are hardwired in gpg 1.0 */
+    switch ( algo ) {    
+      case PUBKEY_ALGO_RSA:
+          use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_ENC;
+          break;
+      case PUBKEY_ALGO_RSA_E:
+          use = PUBKEY_USAGE_ENC;
+          break;
+      case PUBKEY_ALGO_RSA_S:
+          use = PUBKEY_USAGE_SIG;
+          break;
+      case PUBKEY_ALGO_ELGAMAL_E:
+          use = PUBKEY_USAGE_ENC;
+          break;
+      case PUBKEY_ALGO_DSA:  
+          use = PUBKEY_USAGE_SIG;
+          break;
+      case PUBKEY_ALGO_ELGAMAL:
+          use = PUBKEY_USAGE_SIG | PUBKEY_USAGE_ENC;
+          break;
+      default:
+          break;
+    }
+    return use;
+}
+
+int
+openpgp_md_test_algo( int algo )
+{
+    if( algo < 0 || algo > 110 )
+        return G10ERR_DIGEST_ALGO;
+    return check_digest_algo(algo);
+}
+
+int
+check_permissions(const char *path,int extension,int checkonly)
+{
+#if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
+  char *tmppath;
+  struct stat statbuf;
+  int ret=1;
+  int isdir=0;
+
+  if(opt.no_perm_warn)
+    return 0;
+
+  if(extension && path[0]!=DIRSEP_C)
+    {
+      if(strchr(path,DIRSEP_C))
+       tmppath=make_filename(path,NULL);
+      else
+       tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
+    }
+  else
+    tmppath=m_strdup(path);
+
+  /* It's okay if the file doesn't exist */
+  if(stat(tmppath,&statbuf)!=0)
+    {
+      ret=0;
+      goto end;
+    }
+
+  isdir=S_ISDIR(statbuf.st_mode);
+
+  /* We may have to revisit this if we start piping keyrings to gpg
+     over a named pipe or keyserver character device :) */
+  if(!isdir && !S_ISREG(statbuf.st_mode))
+    {
+      ret=0;
+      goto end;
+    }
+
+  /* Per-user files must be owned by the user.  Extensions must be
+     owned by the user or root. */
+  if((!extension && statbuf.st_uid != getuid()) ||
+     (extension && statbuf.st_uid!=0 && statbuf.st_uid!=getuid()))
+    {
+      if(!checkonly)
+       log_info(_("Warning: unsafe ownership on %s \"%s\"\n"),
+                isdir?"directory":extension?"extension":"file",path);
+      goto end;
+    }
+
+  /* This works for both directories and files - basically, we don't
+     care what the owner permissions are, so long as the group and
+     other permissions are 0 for per-user files, and non-writable for
+     extensions. */
+  if((extension && (statbuf.st_mode & (S_IWGRP|S_IWOTH)) !=0) ||
+     (!extension && (statbuf.st_mode & (S_IRWXG|S_IRWXO)) != 0))
+    {
+      char *dir;
+
+      /* However, if the directory the directory/file is in is owned
+         by the user and is 700, then this is not a problem.
+         Theoretically, we could walk this test up to the root
+         directory /, but for the sake of sanity, I'm stopping at one
+         level down. */
+
+      dir=make_dirname(tmppath);
+      if(stat(dir,&statbuf)==0 && statbuf.st_uid==getuid() &&
+        S_ISDIR(statbuf.st_mode) && (statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
+       {
+         m_free(dir);
+         ret=0;
+         goto end;
+       }
+
+      m_free(dir);
+
+      if(!checkonly)
+       log_info(_("Warning: unsafe permissions on %s \"%s\"\n"),
+                isdir?"directory":extension?"extension":"file",path);
+      goto end;
+    }
+
+  ret=0;
+
+ end:
+  m_free(tmppath);
+
+  return ret;
+
+#endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
+
+  return 0;
+}
 
+/* Special warning for the IDEA cipher */
+void
+idea_cipher_warn(int show)
+{
+  static int warned=0;
+
+  if(!warned || show)
+    {
+      log_info(_("the IDEA cipher plugin is not present\n"));
+      log_info(_("please see http://www.gnupg.org/why-not-idea.html "
+                "for more information\n"));
+      warned=1;
+    }
+}
+
+/* Expand %-strings.  Returns a string which must be m_freed.  Returns
+   NULL if the string cannot be expanded (too large). */
+char *
+pct_expando(const char *string,struct expando_args *args)
+{
+  const char *ch=string;
+  int idx=0,maxlen=0,done=0;
+  u32 pk_keyid[2]={0,0},sk_keyid[2]={0,0};
+  char *ret=NULL;
+
+  if(args->pk)
+    keyid_from_pk(args->pk,pk_keyid);
+
+  if(args->sk)
+    keyid_from_sk(args->sk,sk_keyid);
+
+  if(!args->pk && args->sk)
+    keyid_from_sk(args->sk,pk_keyid);
+
+  while(*ch!='\0')
+    {
+      char *str=NULL;
+
+      if(!done)
+       {
+         /* 8192 is way bigger than we'll need here */
+         if(maxlen>=8192)
+           goto fail;
+
+         maxlen+=1024;
+         ret=m_realloc(ret,maxlen);
+       }
+
+      done=0;
+
+      if(*ch=='%')
+       {
+         switch(*(ch+1))
+           {
+           case 's': /* short key id */
+             if(idx+8<maxlen)
+               {
+                 sprintf(&ret[idx],"%08lX",(ulong)sk_keyid[1]);
+                 idx+=8;
+                 done=1;
+               }
+             break;
+
+           case 'S': /* long key id */
+             if(idx+16<maxlen)
+               {
+                 sprintf(&ret[idx],"%08lX%08lX",
+                         (ulong)sk_keyid[0],(ulong)sk_keyid[1]);
+                 idx+=16;
+                 done=1;
+               }
+             break;
+
+           case 'k': /* short key id */
+             if(idx+8<maxlen)
+               {
+                 sprintf(&ret[idx],"%08lX",(ulong)pk_keyid[1]);
+                 idx+=8;
+                 done=1;
+               }
+             break;
+
+           case 'K': /* long key id */
+             if(idx+16<maxlen)
+               {
+                 sprintf(&ret[idx],"%08lX%08lX",
+                         (ulong)pk_keyid[0],(ulong)pk_keyid[1]);
+                 idx+=16;
+                 done=1;
+               }
+             break;
+
+           case 'f': /* fingerprint */
+             {
+               byte array[MAX_FINGERPRINT_LEN];
+               size_t len;
+               int i;
+
+               if(args->pk)
+                 fingerprint_from_pk(args->pk,array,&len);
+               else
+                 memset(array,0,MAX_FINGERPRINT_LEN);
+
+               if(idx+(len*2)<maxlen)
+                 {
+                   for(i=0;i<len;i++)
+                     {
+                       sprintf(&ret[idx],"%02X",array[i]);
+                       idx+=2;
+                     }
+                   done=1;
+                 }
+             }
+             break;
+
+           case 't': /* e.g. "jpg" */
+             str=image_type_to_string(args->imagetype,0);
+             /* fall through */
+
+           case 'T': /* e.g. "image/jpeg" */
+             if(str==NULL)
+               str=image_type_to_string(args->imagetype,2);
+
+             if(idx+strlen(str)<maxlen)
+               {
+                 strcpy(&ret[idx],str);
+                 idx+=strlen(str);
+                 done=1;
+               }
+             break;
+
+           case '%':
+             if(idx+1<maxlen)
+               {
+                 ret[idx++]='%';
+                 ret[idx]='\0';
+                 done=1;
+               }
+             break;
+
+             /* Any unknown %-keys (like %i, %o, %I, and %O) are
+                passed through for later expansion.  Note this also
+                handles the case where the last character in the
+                string is a '%' - the terminating \0 will end up here
+                and properly terminate the string. */
+           default:
+             if(idx+2<maxlen)
+               {
+                 ret[idx++]='%';
+                 ret[idx++]=*(ch+1);
+                 ret[idx]='\0';
+                 done=1;
+               }
+             break;
+             }
+
+         if(done)
+           ch++;
+       }
+      else
+       {
+         if(idx+1<maxlen)
+           {
+             ret[idx++]=*ch;
+             ret[idx]='\0';
+             done=1;
+           }
+       }
+
+      if(done)
+       ch++;
+    }
+
+  return ret;
+
+ fail:
+  m_free(ret);
+  return NULL;
+}
+
+int
+hextobyte( const char *s )
+{
+    int c;
+
+    if( *s >= '0' && *s <= '9' )
+       c = 16 * (*s - '0');
+    else if( *s >= 'A' && *s <= 'F' )
+       c = 16 * (10 + *s - 'A');
+    else if( *s >= 'a' && *s <= 'f' )
+       c = 16 * (10 + *s - 'a');
+    else
+       return -1;
+    s++;
+    if( *s >= '0' && *s <= '9' )
+       c += *s - '0';
+    else if( *s >= 'A' && *s <= 'F' )
+       c += 10 + *s - 'A';
+    else if( *s >= 'a' && *s <= 'f' )
+       c += 10 + *s - 'a';
+    else
+       return -1;
+    return c;
+}
+
+void
+deprecated_warning(const char *configname,unsigned int configlineno,
+                  const char *option,const char *repl1,const char *repl2)
+{
+  if(configname)
+    {
+      if(strncmp("--",option,2)==0)
+       option+=2;
+
+      if(strncmp("--",repl1,2)==0)
+       repl1+=2;
+
+      log_info(_("%s:%d: deprecated option \"%s\"\n"),
+              configname,configlineno,option);
+    }
+  else
+    log_info(_("WARNING: \"%s\" is a deprecated option\n"),option);
+
+  log_info(_("please use \"%s%s\" instead\n"),repl1,repl2);
+}
+
+const char *
+compress_algo_to_string(int algo)
+{
+  const char *s="?";
+
+  switch(algo)
+    {
+    case 0:
+      s="Uncompressed";
+      break;
+
+    case 1:
+      s="ZIP";
+      break;
+
+    case 2:
+      s="ZLIB";
+      break;
+    }
+
+  return s;
+}
+
+int
+check_compress_algo(int algo)
+{
+  if(algo>=0 && algo<=2)
+    return 0;
+
+  return G10ERR_COMPR_ALGO;
+}