gpg: Disable compliance module for other GnuPG components.
[gnupg.git] / common / sysutils.c
1 /* sysutils.c -  system helpers
2  * Copyright (C) 1991-2001, 2003-2004,
3  *               2006-2008  Free Software Foundation, Inc.
4  * Copyright (C) 2013-2016 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * This file is free software; you can redistribute it and/or modify
9  * it under the terms of either
10  *
11  *   - the GNU Lesser General Public License as published by the Free
12  *     Software Foundation; either version 3 of the License, or (at
13  *     your option) any later version.
14  *
15  * or
16  *
17  *   - the GNU General Public License as published by the Free
18  *     Software Foundation; either version 2 of the License, or (at
19  *     your option) any later version.
20  *
21  * or both in parallel, as here.
22  *
23  * This file is distributed in the hope that it will be useful,
24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26  * GNU General Public License for more details.
27  *
28  * You should have received a copy of the GNU General Public License
29  * along with this program; if not, see <https://www.gnu.org/licenses/>.
30  */
31
32 #include <config.h>
33
34 #ifdef WITHOUT_NPTH /* Give the Makefile a chance to build without Pth.  */
35 # undef HAVE_NPTH
36 # undef USE_NPTH
37 #endif
38
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <stdint.h>
42 #include <string.h>
43 #include <unistd.h>
44 #include <errno.h>
45 #ifdef HAVE_STAT
46 # include <sys/stat.h>
47 #endif
48 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
49 # include <asm/sysinfo.h>
50 # include <asm/unistd.h>
51 #endif
52 #include <time.h>
53 #ifdef HAVE_SETRLIMIT
54 # include <sys/time.h>
55 # include <sys/resource.h>
56 #endif
57 #ifdef HAVE_W32_SYSTEM
58 # if WINVER < 0x0500
59 #   define WINVER 0x0500  /* Required for AllowSetForegroundWindow.  */
60 # endif
61 # ifdef HAVE_WINSOCK2_H
62 #  include <winsock2.h>
63 # endif
64 # include <windows.h>
65 #else /*!HAVE_W32_SYSTEM*/
66 # include <sys/socket.h>
67 # include <sys/un.h>
68 #endif
69 #ifdef HAVE_INOTIFY_INIT
70 # include <sys/inotify.h>
71 #endif /*HAVE_INOTIFY_INIT*/
72 #ifdef HAVE_NPTH
73 # include <npth.h>
74 #endif
75 #include <fcntl.h>
76
77 #include <assuan.h>
78
79 #include "util.h"
80 #include "i18n.h"
81
82 #include "sysutils.h"
83
84 #define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
85
86 /* Flag to tell whether special file names are enabled.  See gpg.c for
87  * an explanation of these file names.  */
88 static int allow_special_filenames;
89
90
91 static GPGRT_INLINE gpg_error_t
92 my_error_from_syserror (void)
93 {
94   return gpg_err_make (default_errsource, gpg_err_code_from_syserror ());
95 }
96
97 static GPGRT_INLINE gpg_error_t
98 my_error (int e)
99 {
100   return gpg_err_make (default_errsource, (e));
101 }
102
103
104
105 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
106 #warning using trap_unaligned
107 static int
108 setsysinfo(unsigned long op, void *buffer, unsigned long size,
109                      int *start, void *arg, unsigned long flag)
110 {
111     return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
112 }
113
114 void
115 trap_unaligned(void)
116 {
117     unsigned int buf[2];
118
119     buf[0] = SSIN_UACPROC;
120     buf[1] = UAC_SIGBUS | UAC_NOPRINT;
121     setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
122 }
123 #else
124 void
125 trap_unaligned(void)
126 {  /* dummy */
127 }
128 #endif
129
130
131 int
132 disable_core_dumps (void)
133 {
134 #ifdef HAVE_DOSISH_SYSTEM
135     return 0;
136 #else
137 # ifdef HAVE_SETRLIMIT
138     struct rlimit limit;
139
140     /* We only set the current limit unless we were not able to
141        retrieve the old value. */
142     if (getrlimit (RLIMIT_CORE, &limit))
143       limit.rlim_max = 0;
144     limit.rlim_cur = 0;
145     if( !setrlimit (RLIMIT_CORE, &limit) )
146         return 0;
147     if( errno != EINVAL && errno != ENOSYS )
148         log_fatal (_("can't disable core dumps: %s\n"), strerror(errno) );
149 #endif
150     return 1;
151 #endif
152 }
153
154 int
155 enable_core_dumps (void)
156 {
157 #ifdef HAVE_DOSISH_SYSTEM
158     return 0;
159 #else
160 # ifdef HAVE_SETRLIMIT
161     struct rlimit limit;
162
163     if (getrlimit (RLIMIT_CORE, &limit))
164       return 1;
165     limit.rlim_cur = limit.rlim_max;
166     setrlimit (RLIMIT_CORE, &limit);
167     return 1; /* We always return true because this function is
168                  merely a debugging aid. */
169 # endif
170     return 1;
171 #endif
172 }
173
174
175 /* Allow the use of special "-&nnn" style file names.  */
176 void
177 enable_special_filenames (void)
178 {
179   allow_special_filenames = 1;
180 }
181
182
183 /* Return a string which is used as a kind of process ID.  */
184 const byte *
185 get_session_marker (size_t *rlen)
186 {
187   static byte marker[SIZEOF_UNSIGNED_LONG*2];
188   static int initialized;
189
190   if (!initialized)
191     {
192       gcry_create_nonce (marker, sizeof marker);
193       initialized = 1;
194     }
195   *rlen = sizeof (marker);
196   return marker;
197 }
198
199 /* Return a random number in an unsigned int. */
200 unsigned int
201 get_uint_nonce (void)
202 {
203   unsigned int value;
204
205   gcry_create_nonce (&value, sizeof value);
206   return value;
207 }
208
209
210
211 #if 0 /* not yet needed - Note that this will require inclusion of
212          cmacros.am in Makefile.am */
213 int
214 check_permissions(const char *path,int extension,int checkonly)
215 {
216 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
217   char *tmppath;
218   struct stat statbuf;
219   int ret=1;
220   int isdir=0;
221
222   if(opt.no_perm_warn)
223     return 0;
224
225   if(extension && path[0]!=DIRSEP_C)
226     {
227       if(strchr(path,DIRSEP_C))
228         tmppath=make_filename(path,NULL);
229       else
230         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
231     }
232   else
233     tmppath=m_strdup(path);
234
235   /* It's okay if the file doesn't exist */
236   if(stat(tmppath,&statbuf)!=0)
237     {
238       ret=0;
239       goto end;
240     }
241
242   isdir=S_ISDIR(statbuf.st_mode);
243
244   /* Per-user files must be owned by the user.  Extensions must be
245      owned by the user or root. */
246   if((!extension && statbuf.st_uid != getuid()) ||
247      (extension && statbuf.st_uid!=0 && statbuf.st_uid!=getuid()))
248     {
249       if(!checkonly)
250         log_info(_("Warning: unsafe ownership on %s \"%s\"\n"),
251                  isdir?"directory":extension?"extension":"file",path);
252       goto end;
253     }
254
255   /* This works for both directories and files - basically, we don't
256      care what the owner permissions are, so long as the group and
257      other permissions are 0 for per-user files, and non-writable for
258      extensions. */
259   if((extension && (statbuf.st_mode & (S_IWGRP|S_IWOTH)) !=0) ||
260      (!extension && (statbuf.st_mode & (S_IRWXG|S_IRWXO)) != 0))
261     {
262       char *dir;
263
264       /* However, if the directory the directory/file is in is owned
265          by the user and is 700, then this is not a problem.
266          Theoretically, we could walk this test up to the root
267          directory /, but for the sake of sanity, I'm stopping at one
268          level down. */
269
270       dir= make_dirname (tmppath);
271       if(stat(dir,&statbuf)==0 && statbuf.st_uid==getuid() &&
272          S_ISDIR(statbuf.st_mode) && (statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
273         {
274           xfree (dir);
275           ret=0;
276           goto end;
277         }
278
279       m_free(dir);
280
281       if(!checkonly)
282         log_info(_("Warning: unsafe permissions on %s \"%s\"\n"),
283                  isdir?"directory":extension?"extension":"file",path);
284       goto end;
285     }
286
287   ret=0;
288
289  end:
290   m_free(tmppath);
291
292   return ret;
293
294 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
295
296   return 0;
297 }
298 #endif
299
300
301 /* Wrapper around the usual sleep function.  This one won't wake up
302    before the sleep time has really elapsed.  When build with Pth it
303    merely calls pth_sleep and thus suspends only the current
304    thread. */
305 void
306 gnupg_sleep (unsigned int seconds)
307 {
308 #ifdef USE_NPTH
309   npth_sleep (seconds);
310 #else
311   /* Fixme:  make sure that a sleep won't wake up to early.  */
312 # ifdef HAVE_W32_SYSTEM
313   Sleep (seconds*1000);
314 # else
315   sleep (seconds);
316 # endif
317 #endif
318 }
319
320
321 /* Wrapper around the platforms usleep function.  This one won't wake
322  * up before the sleep time has really elapsed.  When build with nPth
323  * it merely calls npth_usleep and thus suspends only the current
324  * thread. */
325 void
326 gnupg_usleep (unsigned int usecs)
327 {
328 #if defined(USE_NPTH)
329
330   npth_usleep (usecs);
331
332 #elif defined(HAVE_W32_SYSTEM)
333
334   Sleep ((usecs + 999) / 1000);
335
336 #elif defined(HAVE_NANOSLEEP)
337
338   if (usecs)
339     {
340       struct timespec req;
341       struct timespec rem;
342
343       req.tv_sec = 0;
344       req.tv_nsec = usecs * 1000;
345
346       while (nanosleep (&req, &rem) < 0 && errno == EINTR)
347         req = rem;
348     }
349
350 #else /*Standard Unix*/
351
352   if (usecs)
353     {
354       struct timeval tv;
355
356       tv.tv_sec  = usecs / 1000000;
357       tv.tv_usec = usecs % 1000000;
358       select (0, NULL, NULL, NULL, &tv);
359     }
360
361 #endif
362 }
363
364
365 /* This function is a NOP for POSIX systems but required under Windows
366    as the file handles as returned by OS calls (like CreateFile) are
367    different from the libc file descriptors (like open). This function
368    translates system file handles to libc file handles.  FOR_WRITE
369    gives the direction of the handle.  */
370 int
371 translate_sys2libc_fd (gnupg_fd_t fd, int for_write)
372 {
373 #if defined(HAVE_W32CE_SYSTEM)
374   (void)for_write;
375   return (int) fd;
376 #elif defined(HAVE_W32_SYSTEM)
377   int x;
378
379   if (fd == GNUPG_INVALID_FD)
380     return -1;
381
382   /* Note that _open_osfhandle is currently defined to take and return
383      a long.  */
384   x = _open_osfhandle ((long)fd, for_write ? 1 : 0);
385   if (x == -1)
386     log_error ("failed to translate osfhandle %p\n", (void *) fd);
387   return x;
388 #else /*!HAVE_W32_SYSTEM */
389   (void)for_write;
390   return fd;
391 #endif
392 }
393
394 /* This is the same as translate_sys2libc_fd but takes an integer
395    which is assumed to be such an system handle.  On WindowsCE the
396    passed FD is a rendezvous ID and the function finishes the pipe
397    creation. */
398 int
399 translate_sys2libc_fd_int (int fd, int for_write)
400 {
401 #if HAVE_W32CE_SYSTEM
402   fd = (int) _assuan_w32ce_finish_pipe (fd, for_write);
403   return translate_sys2libc_fd ((void*)fd, for_write);
404 #elif HAVE_W32_SYSTEM
405   if (fd <= 2)
406     return fd;  /* Do not do this for error, stdin, stdout, stderr. */
407
408   return translate_sys2libc_fd ((void*)fd, for_write);
409 #else
410   (void)for_write;
411   return fd;
412 #endif
413 }
414
415
416 /* Check whether FNAME has the form "-&nnnn", where N is a non-zero
417  * number.  Returns this number or -1 if it is not the case.  If the
418  * caller wants to use the file descriptor for writing FOR_WRITE shall
419  * be set to 1.  If NOTRANSLATE is set the Windows specific mapping is
420  * not done. */
421 int
422 check_special_filename (const char *fname, int for_write, int notranslate)
423 {
424   if (allow_special_filenames
425       && fname && *fname == '-' && fname[1] == '&')
426     {
427       int i;
428
429       fname += 2;
430       for (i=0; digitp (fname+i); i++ )
431         ;
432       if (!fname[i])
433         return notranslate? atoi (fname)
434           /**/            : translate_sys2libc_fd_int (atoi (fname), for_write);
435     }
436   return -1;
437 }
438
439
440 /* Replacement for tmpfile().  This is required because the tmpfile
441    function of Windows' runtime library is broken, insecure, ignores
442    TMPDIR and so on.  In addition we create a file with an inheritable
443    handle.  */
444 FILE *
445 gnupg_tmpfile (void)
446 {
447 #ifdef HAVE_W32_SYSTEM
448   int attempts, n;
449 #ifdef HAVE_W32CE_SYSTEM
450   wchar_t buffer[MAX_PATH+7+12+1];
451 # define mystrlen(a) wcslen (a)
452   wchar_t *name, *p;
453 #else
454   char buffer[MAX_PATH+7+12+1];
455 # define mystrlen(a) strlen (a)
456   char *name, *p;
457 #endif
458   HANDLE file;
459   int pid = GetCurrentProcessId ();
460   unsigned int value;
461   int i;
462   SECURITY_ATTRIBUTES sec_attr;
463
464   memset (&sec_attr, 0, sizeof sec_attr );
465   sec_attr.nLength = sizeof sec_attr;
466   sec_attr.bInheritHandle = TRUE;
467
468   n = GetTempPath (MAX_PATH+1, buffer);
469   if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
470     {
471       gpg_err_set_errno (ENOENT);
472       return NULL;
473     }
474   p = buffer + mystrlen (buffer);
475 #ifdef HAVE_W32CE_SYSTEM
476   wcscpy (p, L"_gnupg");
477   p += 7;
478 #else
479   p = stpcpy (p, "_gnupg");
480 #endif
481   /* We try to create the directory but don't care about an error as
482      it may already exist and the CreateFile would throw an error
483      anyway.  */
484   CreateDirectory (buffer, NULL);
485   *p++ = '\\';
486   name = p;
487   for (attempts=0; attempts < 10; attempts++)
488     {
489       p = name;
490       value = (GetTickCount () ^ ((pid<<16) & 0xffff0000));
491       for (i=0; i < 8; i++)
492         {
493           *p++ = tohex (((value >> 28) & 0x0f));
494           value <<= 4;
495         }
496 #ifdef HAVE_W32CE_SYSTEM
497       wcscpy (p, L".tmp");
498 #else
499       strcpy (p, ".tmp");
500 #endif
501       file = CreateFile (buffer,
502                          GENERIC_READ | GENERIC_WRITE,
503                          0,
504                          &sec_attr,
505                          CREATE_NEW,
506                          FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
507                          NULL);
508       if (file != INVALID_HANDLE_VALUE)
509         {
510           FILE *fp;
511 #ifdef HAVE_W32CE_SYSTEM
512           int fd = (int)file;
513           fp = _wfdopen (fd, L"w+b");
514 #else
515           int fd = _open_osfhandle ((long)file, 0);
516           if (fd == -1)
517             {
518               CloseHandle (file);
519               return NULL;
520             }
521           fp = fdopen (fd, "w+b");
522 #endif
523           if (!fp)
524             {
525               int save = errno;
526               close (fd);
527               gpg_err_set_errno (save);
528               return NULL;
529             }
530           return fp;
531         }
532       Sleep (1); /* One ms as this is the granularity of GetTickCount.  */
533     }
534   gpg_err_set_errno (ENOENT);
535   return NULL;
536 #undef mystrlen
537 #else /*!HAVE_W32_SYSTEM*/
538   return tmpfile ();
539 #endif /*!HAVE_W32_SYSTEM*/
540 }
541
542
543 /* Make sure that the standard file descriptors are opened. Obviously
544    some folks close them before an exec and the next file we open will
545    get one of them assigned and thus any output (i.e. diagnostics) end
546    up in that file (e.g. the trustdb).  Not actually a gpg problem as
547    this will happen with almost all utilities when called in a wrong
548    way.  However we try to minimize the damage here and raise
549    awareness of the problem.
550
551    Must be called before we open any files! */
552 void
553 gnupg_reopen_std (const char *pgmname)
554 {
555 #if defined(HAVE_STAT) && !defined(HAVE_W32_SYSTEM)
556   struct stat statbuf;
557   int did_stdin = 0;
558   int did_stdout = 0;
559   int did_stderr = 0;
560   FILE *complain;
561
562   if (fstat (STDIN_FILENO, &statbuf) == -1 && errno ==EBADF)
563     {
564       if (open ("/dev/null",O_RDONLY) == STDIN_FILENO)
565         did_stdin = 1;
566       else
567         did_stdin = 2;
568     }
569
570   if (fstat (STDOUT_FILENO, &statbuf) == -1 && errno == EBADF)
571     {
572       if (open ("/dev/null",O_WRONLY) == STDOUT_FILENO)
573         did_stdout = 1;
574       else
575         did_stdout = 2;
576     }
577
578   if (fstat (STDERR_FILENO, &statbuf)==-1 && errno==EBADF)
579     {
580       if (open ("/dev/null", O_WRONLY) == STDERR_FILENO)
581         did_stderr = 1;
582       else
583         did_stderr = 2;
584     }
585
586   /* It's hard to log this sort of thing since the filehandle we would
587      complain to may be closed... */
588   if (!did_stderr)
589     complain = stderr;
590   else if (!did_stdout)
591     complain = stdout;
592   else
593     complain = NULL;
594
595   if (complain)
596     {
597       if (did_stdin == 1)
598         fprintf (complain, "%s: WARNING: standard input reopened\n", pgmname);
599       if (did_stdout == 1)
600         fprintf (complain, "%s: WARNING: standard output reopened\n", pgmname);
601       if (did_stderr == 1)
602         fprintf (complain, "%s: WARNING: standard error reopened\n", pgmname);
603
604       if (did_stdin == 2 || did_stdout == 2 || did_stderr == 2)
605         fprintf(complain,"%s: fatal: unable to reopen standard input,"
606                 " output, or error\n", pgmname);
607     }
608
609   if (did_stdin == 2 || did_stdout == 2 || did_stderr == 2)
610     exit (3);
611 #else /* !(HAVE_STAT && !HAVE_W32_SYSTEM) */
612   (void)pgmname;
613 #endif
614 }
615
616
617 /* Hack required for Windows.  */
618 void
619 gnupg_allow_set_foregound_window (pid_t pid)
620 {
621   if (!pid)
622     log_info ("%s called with invalid pid %lu\n",
623               "gnupg_allow_set_foregound_window", (unsigned long)pid);
624 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
625   else if (!AllowSetForegroundWindow ((pid_t)pid == (pid_t)(-1)?ASFW_ANY:pid))
626     log_info ("AllowSetForegroundWindow(%lu) failed: %s\n",
627                (unsigned long)pid, w32_strerror (-1));
628 #endif
629 }
630
631 int
632 gnupg_remove (const char *fname)
633 {
634 #ifdef HAVE_W32CE_SYSTEM
635   int rc;
636   wchar_t *wfname;
637
638   wfname = utf8_to_wchar (fname);
639   if (!wfname)
640     rc = 0;
641   else
642     {
643       rc = DeleteFile (wfname);
644       xfree (wfname);
645     }
646   if (!rc)
647     return -1; /* ERRNO is automagically provided by gpg-error.h.  */
648   return 0;
649 #else
650   return remove (fname);
651 #endif
652 }
653
654
655 /* Wrapper for rename(2) to handle Windows peculiarities.  If
656  * BLOCK_SIGNALS is not NULL and points to a variable set to true, all
657  * signals will be blocked by calling gnupg_block_all_signals; the
658  * caller needs to call gnupg_unblock_all_signals if that variable is
659  * still set to true on return. */
660 gpg_error_t
661 gnupg_rename_file (const char *oldname, const char *newname, int *block_signals)
662 {
663   gpg_error_t err = 0;
664
665   if (block_signals && *block_signals)
666     gnupg_block_all_signals ();
667
668 #ifdef HAVE_DOSISH_SYSTEM
669   {
670     int wtime = 0;
671
672     gnupg_remove (newname);
673   again:
674     if (rename (oldname, newname))
675       {
676         if (GetLastError () == ERROR_SHARING_VIOLATION)
677           {
678             /* Another process has the file open.  We do not use a
679              * lock for read but instead we wait until the other
680              * process has closed the file.  This may take long but
681              * that would also be the case with a dotlock approach for
682              * read and write.  Note that we don't need this on Unix
683              * due to the inode concept.
684              *
685              * So let's wait until the rename has worked.  The retry
686              * intervals are 50, 100, 200, 400, 800, 50ms, ...  */
687             if (!wtime || wtime >= 800)
688               wtime = 50;
689             else
690               wtime *= 2;
691
692             if (wtime >= 800)
693               log_info (_("waiting for file '%s' to become accessible ...\n"),
694                         oldname);
695
696             Sleep (wtime);
697             goto again;
698           }
699         err = my_error_from_syserror ();
700       }
701   }
702 #else /* Unix */
703   {
704 #ifdef __riscos__
705     gnupg_remove (newname);
706 #endif
707     if (rename (oldname, newname) )
708       err = my_error_from_syserror ();
709   }
710 #endif /* Unix */
711
712   if (block_signals && *block_signals && err)
713     {
714       gnupg_unblock_all_signals ();
715       *block_signals = 0;
716     }
717
718   if (err)
719     log_error (_("renaming '%s' to '%s' failed: %s\n"),
720                oldname, newname, gpg_strerror (err));
721   return err;
722 }
723
724
725 #ifndef HAVE_W32_SYSTEM
726 static mode_t
727 modestr_to_mode (const char *modestr)
728 {
729   mode_t mode = 0;
730
731   if (modestr && *modestr)
732     {
733       modestr++;
734       if (*modestr && *modestr++ == 'r')
735         mode |= S_IRUSR;
736       if (*modestr && *modestr++ == 'w')
737         mode |= S_IWUSR;
738       if (*modestr && *modestr++ == 'x')
739         mode |= S_IXUSR;
740       if (*modestr && *modestr++ == 'r')
741         mode |= S_IRGRP;
742       if (*modestr && *modestr++ == 'w')
743         mode |= S_IWGRP;
744       if (*modestr && *modestr++ == 'x')
745         mode |= S_IXGRP;
746       if (*modestr && *modestr++ == 'r')
747         mode |= S_IROTH;
748       if (*modestr && *modestr++ == 'w')
749         mode |= S_IWOTH;
750       if (*modestr && *modestr++ == 'x')
751         mode |= S_IXOTH;
752     }
753
754   return mode;
755 }
756 #endif
757
758
759 /* A wrapper around mkdir which takes a string for the mode argument.
760    This makes it easier to handle the mode argument which is not
761    defined on all systems.  The format of the modestring is
762
763       "-rwxrwxrwx"
764
765    '-' is a don't care or not set.  'r', 'w', 'x' are read allowed,
766    write allowed, execution allowed with the first group for the user,
767    the second for the group and the third for all others.  If the
768    string is shorter than above the missing mode characters are meant
769    to be not set.  */
770 int
771 gnupg_mkdir (const char *name, const char *modestr)
772 {
773 #ifdef HAVE_W32CE_SYSTEM
774   wchar_t *wname;
775   (void)modestr;
776
777   wname = utf8_to_wchar (name);
778   if (!wname)
779     return -1;
780   if (!CreateDirectoryW (wname, NULL))
781     {
782       xfree (wname);
783       return -1;  /* ERRNO is automagically provided by gpg-error.h.  */
784     }
785   xfree (wname);
786   return 0;
787 #elif MKDIR_TAKES_ONE_ARG
788   (void)modestr;
789   /* Note: In the case of W32 we better use CreateDirectory and try to
790      set appropriate permissions.  However using mkdir is easier
791      because this sets ERRNO.  */
792   return mkdir (name);
793 #else
794   return mkdir (name, modestr_to_mode (modestr));
795 #endif
796 }
797
798
799 /* A wrapper around chmod which takes a string for the mode argument.
800    This makes it easier to handle the mode argument which is not
801    defined on all systems.  The format of the modestring is the same
802    as for gnupg_mkdir.  */
803 int
804 gnupg_chmod (const char *name, const char *modestr)
805 {
806 #ifdef HAVE_W32_SYSTEM
807   (void)name;
808   (void)modestr;
809   return 0;
810 #else
811   return chmod (name, modestr_to_mode (modestr));
812 #endif
813 }
814
815
816 /* Our version of mkdtemp.  The API is identical to POSIX.1-2008
817    version.  We do not use a system provided mkdtemp because we have a
818    good RNG instantly available and this way we don't have diverging
819    versions.  */
820 char *
821 gnupg_mkdtemp (char *tmpl)
822 {
823   /* A lower bound on the number of temporary files to attempt to
824      generate.  The maximum total number of temporary file names that
825      can exist for a given template is 62**6 (5*36**3 for Windows).
826      It should never be necessary to try all these combinations.
827      Instead if a reasonable number of names is tried (we define
828      reasonable as 62**3 or 5*36**3) fail to give the system
829      administrator the chance to remove the problems.  */
830 #ifdef HAVE_W32_SYSTEM
831   static const char letters[] =
832     "abcdefghijklmnopqrstuvwxyz0123456789";
833 # define NUMBER_OF_LETTERS 36
834 # define ATTEMPTS_MIN (5 * 36 * 36 * 36)
835 #else
836   static const char letters[] =
837     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
838 # define NUMBER_OF_LETTERS 62
839 # define ATTEMPTS_MIN (62 * 62 * 62)
840 #endif
841   int len;
842   char *XXXXXX;
843   uint64_t value;
844   unsigned int count;
845   int save_errno = errno;
846   /* The number of times to attempt to generate a temporary file.  To
847      conform to POSIX, this must be no smaller than TMP_MAX.  */
848 #if ATTEMPTS_MIN < TMP_MAX
849   unsigned int attempts = TMP_MAX;
850 #else
851   unsigned int attempts = ATTEMPTS_MIN;
852 #endif
853
854   len = strlen (tmpl);
855   if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
856     {
857       gpg_err_set_errno (EINVAL);
858       return NULL;
859     }
860
861   /* This is where the Xs start.  */
862   XXXXXX = &tmpl[len - 6];
863
864   /* Get a random start value.  */
865   gcry_create_nonce (&value, sizeof value);
866
867   /* Loop until a directory was created.  */
868   for (count = 0; count < attempts; value += 7777, ++count)
869     {
870       uint64_t v = value;
871
872       /* Fill in the random bits.  */
873       XXXXXX[0] = letters[v % NUMBER_OF_LETTERS];
874       v /= NUMBER_OF_LETTERS;
875       XXXXXX[1] = letters[v % NUMBER_OF_LETTERS];
876       v /= NUMBER_OF_LETTERS;
877       XXXXXX[2] = letters[v % NUMBER_OF_LETTERS];
878       v /= NUMBER_OF_LETTERS;
879       XXXXXX[3] = letters[v % NUMBER_OF_LETTERS];
880       v /= NUMBER_OF_LETTERS;
881       XXXXXX[4] = letters[v % NUMBER_OF_LETTERS];
882       v /= NUMBER_OF_LETTERS;
883       XXXXXX[5] = letters[v % NUMBER_OF_LETTERS];
884
885       if (!gnupg_mkdir (tmpl, "-rwx"))
886         {
887           gpg_err_set_errno (save_errno);
888           return tmpl;
889         }
890       if (errno != EEXIST)
891         return NULL;
892     }
893
894   /* We got out of the loop because we ran out of combinations to try.  */
895   gpg_err_set_errno (EEXIST);
896   return NULL;
897 }
898
899
900 int
901 gnupg_setenv (const char *name, const char *value, int overwrite)
902 {
903 #ifdef HAVE_W32CE_SYSTEM
904   (void)name;
905   (void)value;
906   (void)overwrite;
907   return 0;
908 #else /*!W32CE*/
909 # ifdef HAVE_W32_SYSTEM
910   /*  Windows maintains (at least) two sets of environment variables.
911       One set can be accessed by GetEnvironmentVariable and
912       SetEnvironmentVariable.  This set is inherited by the children.
913       The other set is maintained in the C runtime, and is accessed
914       using getenv and putenv.  We try to keep them in sync by
915       modifying both sets.  */
916   {
917     int exists;
918     char tmpbuf[10];
919     exists = GetEnvironmentVariable (name, tmpbuf, sizeof tmpbuf);
920
921     if ((! exists || overwrite) && !SetEnvironmentVariable (name, value))
922       {
923         gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
924         return -1;
925       }
926   }
927 # endif /*W32*/
928
929 # ifdef HAVE_SETENV
930   return setenv (name, value, overwrite);
931 # else /*!HAVE_SETENV*/
932   if (! getenv (name) || overwrite)
933     {
934       char *buf;
935
936       (void)overwrite;
937       if (!name || !value)
938         {
939           gpg_err_set_errno (EINVAL);
940           return -1;
941         }
942       buf = strconcat (name, "=", value, NULL);
943       if (!buf)
944         return -1;
945 # if __GNUC__
946 #  warning no setenv - using putenv but leaking memory.
947 # endif
948       return putenv (buf);
949     }
950   return 0;
951 # endif /*!HAVE_SETENV*/
952 #endif /*!W32CE*/
953 }
954
955
956 int
957 gnupg_unsetenv (const char *name)
958 {
959 #ifdef HAVE_W32CE_SYSTEM
960   (void)name;
961   return 0;
962 #else /*!W32CE*/
963 # ifdef HAVE_W32_SYSTEM
964   /*  Windows maintains (at least) two sets of environment variables.
965       One set can be accessed by GetEnvironmentVariable and
966       SetEnvironmentVariable.  This set is inherited by the children.
967       The other set is maintained in the C runtime, and is accessed
968       using getenv and putenv.  We try to keep them in sync by
969       modifying both sets.  */
970   if (!SetEnvironmentVariable (name, NULL))
971     {
972       gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
973       return -1;
974     }
975 # endif /*W32*/
976
977 # ifdef HAVE_UNSETENV
978   return unsetenv (name);
979 # else /*!HAVE_UNSETENV*/
980   {
981     char *buf;
982
983     if (!name)
984       {
985         gpg_err_set_errno (EINVAL);
986         return -1;
987       }
988     buf = xtrystrdup (name);
989     if (!buf)
990       return -1;
991 #  if __GNUC__
992 #   warning no unsetenv - trying putenv but leaking memory.
993 #  endif
994     return putenv (buf);
995   }
996 # endif /*!HAVE_UNSETENV*/
997 #endif /*!W32CE*/
998 }
999
1000
1001 /* Return the current working directory as a malloced string.  Return
1002    NULL and sets ERRNo on error.  */
1003 char *
1004 gnupg_getcwd (void)
1005 {
1006   char *buffer;
1007   size_t size = 100;
1008
1009   for (;;)
1010     {
1011       buffer = xtrymalloc (size+1);
1012       if (!buffer)
1013         return NULL;
1014 #ifdef HAVE_W32CE_SYSTEM
1015       strcpy (buffer, "/");  /* Always "/".  */
1016       return buffer;
1017 #else
1018       if (getcwd (buffer, size) == buffer)
1019         return buffer;
1020       xfree (buffer);
1021       if (errno != ERANGE)
1022         return NULL;
1023       size *= 2;
1024 #endif
1025     }
1026 }
1027
1028
1029 \f
1030 #ifdef HAVE_W32CE_SYSTEM
1031 /* There is a isatty function declaration in cegcc but it does not
1032    make sense, thus we redefine it.  */
1033 int
1034 _gnupg_isatty (int fd)
1035 {
1036   (void)fd;
1037   return 0;
1038 }
1039 #endif
1040
1041
1042 #ifdef HAVE_W32CE_SYSTEM
1043 /* Replacement for getenv which takes care of the our use of getenv.
1044    The code is not thread safe but we expect it to work in all cases
1045    because it is called for the first time early enough.  */
1046 char *
1047 _gnupg_getenv (const char *name)
1048 {
1049   static int initialized;
1050   static char *assuan_debug;
1051
1052   if (!initialized)
1053     {
1054       assuan_debug = read_w32_registry_string (NULL,
1055                                                "\\Software\\GNU\\libassuan",
1056                                                "debug");
1057       initialized = 1;
1058     }
1059
1060   if (!strcmp (name, "ASSUAN_DEBUG"))
1061     return assuan_debug;
1062   else
1063     return NULL;
1064 }
1065
1066 #endif /*HAVE_W32CE_SYSTEM*/
1067
1068
1069 #ifdef HAVE_W32_SYSTEM
1070 /* Return the user's security identifier from the current process.  */
1071 PSID
1072 w32_get_user_sid (void)
1073 {
1074   int okay = 0;
1075   HANDLE proc = NULL;
1076   HANDLE token = NULL;
1077   TOKEN_USER *user = NULL;
1078   PSID sid = NULL;
1079   DWORD tokenlen, sidlen;
1080
1081   proc = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1082   if (!proc)
1083     goto leave;
1084
1085   if (!OpenProcessToken (proc, TOKEN_QUERY, &token))
1086     goto leave;
1087
1088   if (!GetTokenInformation (token, TokenUser, NULL, 0, &tokenlen)
1089       && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1090     goto leave;
1091
1092   user = xtrymalloc (tokenlen);
1093   if (!user)
1094     goto leave;
1095
1096   if (!GetTokenInformation (token, TokenUser, user, tokenlen, &tokenlen))
1097     goto leave;
1098   if (!IsValidSid (user->User.Sid))
1099     goto leave;
1100   sidlen = GetLengthSid (user->User.Sid);
1101   sid = xtrymalloc (sidlen);
1102   if (!sid)
1103     goto leave;
1104   if (!CopySid (sidlen, sid, user->User.Sid))
1105     goto leave;
1106   okay = 1;
1107
1108  leave:
1109   xfree (user);
1110   if (token)
1111     CloseHandle (token);
1112   if (proc)
1113     CloseHandle (proc);
1114
1115   if (!okay)
1116     {
1117       xfree (sid);
1118       sid = NULL;
1119     }
1120   return sid;
1121 }
1122 #endif /*HAVE_W32_SYSTEM*/
1123
1124
1125 \f
1126 /* Support for inotify under Linux.  */
1127
1128 /* Store a new inotify file handle for SOCKET_NAME at R_FD or return
1129  * an error code. */
1130 gpg_error_t
1131 gnupg_inotify_watch_socket (int *r_fd, const char *socket_name)
1132 {
1133 #if HAVE_INOTIFY_INIT
1134   gpg_error_t err;
1135   char *fname;
1136   int fd;
1137   char *p;
1138
1139   *r_fd = -1;
1140
1141   if (!socket_name)
1142     return my_error (GPG_ERR_INV_VALUE);
1143
1144   fname = xtrystrdup (socket_name);
1145   if (!fname)
1146     return my_error_from_syserror ();
1147
1148   fd = inotify_init ();
1149   if (fd == -1)
1150     {
1151       err = my_error_from_syserror ();
1152       xfree (fname);
1153       return err;
1154     }
1155
1156   /* We need to watch the directory for the file because there won't
1157    * be an IN_DELETE_SELF for a socket file.  To handle a removal of
1158    * the directory we also watch the directory itself. */
1159   p = strrchr (fname, '/');
1160   if (p)
1161     *p = 0;
1162   if (inotify_add_watch (fd, fname,
1163                          (IN_DELETE|IN_DELETE_SELF|IN_EXCL_UNLINK)) == -1)
1164     {
1165       err = my_error_from_syserror ();
1166       close (fd);
1167       xfree (fname);
1168       return err;
1169     }
1170
1171   xfree (fname);
1172
1173   *r_fd = fd;
1174   return 0;
1175 #else /*!HAVE_INOTIFY_INIT*/
1176
1177   (void)socket_name;
1178   *r_fd = -1;
1179   return my_error (GPG_ERR_NOT_SUPPORTED);
1180
1181 #endif /*!HAVE_INOTIFY_INIT*/
1182 }
1183
1184
1185 /* Read an inotify event and return true if it matches NAME or if it
1186  * sees an IN_DELETE_SELF event for the directory of NAME.  */
1187 int
1188 gnupg_inotify_has_name (int fd, const char *name)
1189 {
1190 #if USE_NPTH && HAVE_INOTIFY_INIT
1191 #define BUFSIZE_FOR_INOTIFY (sizeof (struct inotify_event) + 255 + 1)
1192   union {
1193     struct inotify_event ev;
1194     char _buf[sizeof (struct inotify_event) + 255 + 1];
1195   } buf;
1196   struct inotify_event *evp;
1197   int n;
1198
1199   n = npth_read (fd, &buf, sizeof buf);
1200   /* log_debug ("notify read: n=%d\n", n); */
1201   evp = &buf.ev;
1202   while (n >= sizeof (struct inotify_event))
1203     {
1204       /* log_debug ("             mask=%x len=%u name=(%s)\n", */
1205       /*        evp->mask, (unsigned int)evp->len, evp->len? evp->name:""); */
1206       if ((evp->mask & IN_UNMOUNT))
1207         {
1208           /* log_debug ("             found (dir unmounted)\n"); */
1209           return 3; /* Directory was unmounted.  */
1210         }
1211       if ((evp->mask & IN_DELETE_SELF))
1212         {
1213           /* log_debug ("             found (dir removed)\n"); */
1214           return 2; /* Directory was removed.  */
1215         }
1216       if ((evp->mask & IN_DELETE))
1217         {
1218           if (evp->len >= strlen (name) && !strcmp (evp->name, name))
1219             {
1220               /* log_debug ("             found (file removed)\n"); */
1221               return 1; /* File was removed.  */
1222             }
1223         }
1224       n -= sizeof (*evp) + evp->len;
1225       evp = (struct inotify_event *)(void *)
1226         ((char *)evp + sizeof (*evp) + evp->len);
1227     }
1228
1229 #else /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1230
1231   (void)fd;
1232   (void)name;
1233
1234 #endif  /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1235
1236   return 0; /* Not found.  */
1237 }
1238
1239
1240 /* Return a malloc'ed string that is the path to the passed
1241  * unix-domain socket (or return NULL if this is not a valid
1242  * unix-domain socket).  We use a plain int here because it is only
1243  * used on Linux.
1244  *
1245  * FIXME: This function needs to be moved to libassuan.  */
1246 #ifndef HAVE_W32_SYSTEM
1247 char *
1248 gnupg_get_socket_name (int fd)
1249 {
1250   struct sockaddr_un un;
1251   socklen_t len = sizeof(un);
1252   char *name = NULL;
1253
1254   if (getsockname (fd, (struct sockaddr*)&un, &len) != 0)
1255     log_error ("could not getsockname(%d): %s\n", fd,
1256                gpg_strerror (my_error_from_syserror ()));
1257   else if (un.sun_family != AF_UNIX)
1258     log_error ("file descriptor %d is not a unix-domain socket\n", fd);
1259   else if (len <= offsetof (struct sockaddr_un, sun_path))
1260     log_error ("socket name not present for file descriptor %d\n", fd);
1261   else if (len > sizeof(un))
1262     log_error ("socket name for file descriptor %d was truncated "
1263                "(passed %zu bytes, wanted %u)\n", fd, sizeof(un), len);
1264   else
1265     {
1266       size_t namelen = len - offsetof (struct sockaddr_un, sun_path);
1267
1268       /* log_debug ("file descriptor %d has path %s (%zu octets)\n", fd, */
1269       /*            un.sun_path, namelen); */
1270       name = xtrymalloc (namelen + 1);
1271       if (!name)
1272         log_error ("failed to allocate memory for name of fd %d: %s\n",
1273                    fd, gpg_strerror (my_error_from_syserror ()));
1274       else
1275         {
1276           memcpy (name, un.sun_path, namelen);
1277           name[namelen] = 0;
1278         }
1279     }
1280
1281   return name;
1282 }
1283 #endif /*!HAVE_W32_SYSTEM*/
1284
1285 /* Check whether FD is valid.  */
1286 int
1287 gnupg_fd_valid (int fd)
1288 {
1289   int d = dup (fd);
1290   if (d < 0)
1291     return 0;
1292   close (d);
1293   return 1;
1294 }