agent: Fix segv running in --server mode
[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  = usecs / 1000000;
344       req.tv_nsec = (usecs % 1000000) * 1000;
345       while (nanosleep (&req, &rem) < 0 && errno == EINTR)
346           req = rem;
347     }
348
349 #else /*Standard Unix*/
350
351   if (usecs)
352     {
353       struct timeval tv;
354
355       tv.tv_sec  = usecs / 1000000;
356       tv.tv_usec = usecs % 1000000;
357       select (0, NULL, NULL, NULL, &tv);
358     }
359
360 #endif
361 }
362
363
364 /* This function is a NOP for POSIX systems but required under Windows
365    as the file handles as returned by OS calls (like CreateFile) are
366    different from the libc file descriptors (like open). This function
367    translates system file handles to libc file handles.  FOR_WRITE
368    gives the direction of the handle.  */
369 int
370 translate_sys2libc_fd (gnupg_fd_t fd, int for_write)
371 {
372 #if defined(HAVE_W32CE_SYSTEM)
373   (void)for_write;
374   return (int) fd;
375 #elif defined(HAVE_W32_SYSTEM)
376   int x;
377
378   if (fd == GNUPG_INVALID_FD)
379     return -1;
380
381   /* Note that _open_osfhandle is currently defined to take and return
382      a long.  */
383   x = _open_osfhandle ((long)fd, for_write ? 1 : 0);
384   if (x == -1)
385     log_error ("failed to translate osfhandle %p\n", (void *) fd);
386   return x;
387 #else /*!HAVE_W32_SYSTEM */
388   (void)for_write;
389   return fd;
390 #endif
391 }
392
393 /* This is the same as translate_sys2libc_fd but takes an integer
394    which is assumed to be such an system handle.  On WindowsCE the
395    passed FD is a rendezvous ID and the function finishes the pipe
396    creation. */
397 int
398 translate_sys2libc_fd_int (int fd, int for_write)
399 {
400 #if HAVE_W32CE_SYSTEM
401   fd = (int) _assuan_w32ce_finish_pipe (fd, for_write);
402   return translate_sys2libc_fd ((void*)fd, for_write);
403 #elif HAVE_W32_SYSTEM
404   if (fd <= 2)
405     return fd;  /* Do not do this for error, stdin, stdout, stderr. */
406
407   return translate_sys2libc_fd ((void*)fd, for_write);
408 #else
409   (void)for_write;
410   return fd;
411 #endif
412 }
413
414
415 /* Check whether FNAME has the form "-&nnnn", where N is a non-zero
416  * number.  Returns this number or -1 if it is not the case.  If the
417  * caller wants to use the file descriptor for writing FOR_WRITE shall
418  * be set to 1.  If NOTRANSLATE is set the Windows specific mapping is
419  * not done. */
420 int
421 check_special_filename (const char *fname, int for_write, int notranslate)
422 {
423   if (allow_special_filenames
424       && fname && *fname == '-' && fname[1] == '&')
425     {
426       int i;
427
428       fname += 2;
429       for (i=0; digitp (fname+i); i++ )
430         ;
431       if (!fname[i])
432         return notranslate? atoi (fname)
433           /**/            : translate_sys2libc_fd_int (atoi (fname), for_write);
434     }
435   return -1;
436 }
437
438
439 /* Replacement for tmpfile().  This is required because the tmpfile
440    function of Windows' runtime library is broken, insecure, ignores
441    TMPDIR and so on.  In addition we create a file with an inheritable
442    handle.  */
443 FILE *
444 gnupg_tmpfile (void)
445 {
446 #ifdef HAVE_W32_SYSTEM
447   int attempts, n;
448 #ifdef HAVE_W32CE_SYSTEM
449   wchar_t buffer[MAX_PATH+7+12+1];
450 # define mystrlen(a) wcslen (a)
451   wchar_t *name, *p;
452 #else
453   char buffer[MAX_PATH+7+12+1];
454 # define mystrlen(a) strlen (a)
455   char *name, *p;
456 #endif
457   HANDLE file;
458   int pid = GetCurrentProcessId ();
459   unsigned int value;
460   int i;
461   SECURITY_ATTRIBUTES sec_attr;
462
463   memset (&sec_attr, 0, sizeof sec_attr );
464   sec_attr.nLength = sizeof sec_attr;
465   sec_attr.bInheritHandle = TRUE;
466
467   n = GetTempPath (MAX_PATH+1, buffer);
468   if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH)
469     {
470       gpg_err_set_errno (ENOENT);
471       return NULL;
472     }
473   p = buffer + mystrlen (buffer);
474 #ifdef HAVE_W32CE_SYSTEM
475   wcscpy (p, L"_gnupg");
476   p += 7;
477 #else
478   p = stpcpy (p, "_gnupg");
479 #endif
480   /* We try to create the directory but don't care about an error as
481      it may already exist and the CreateFile would throw an error
482      anyway.  */
483   CreateDirectory (buffer, NULL);
484   *p++ = '\\';
485   name = p;
486   for (attempts=0; attempts < 10; attempts++)
487     {
488       p = name;
489       value = (GetTickCount () ^ ((pid<<16) & 0xffff0000));
490       for (i=0; i < 8; i++)
491         {
492           *p++ = tohex (((value >> 28) & 0x0f));
493           value <<= 4;
494         }
495 #ifdef HAVE_W32CE_SYSTEM
496       wcscpy (p, L".tmp");
497 #else
498       strcpy (p, ".tmp");
499 #endif
500       file = CreateFile (buffer,
501                          GENERIC_READ | GENERIC_WRITE,
502                          0,
503                          &sec_attr,
504                          CREATE_NEW,
505                          FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE,
506                          NULL);
507       if (file != INVALID_HANDLE_VALUE)
508         {
509           FILE *fp;
510 #ifdef HAVE_W32CE_SYSTEM
511           int fd = (int)file;
512           fp = _wfdopen (fd, L"w+b");
513 #else
514           int fd = _open_osfhandle ((long)file, 0);
515           if (fd == -1)
516             {
517               CloseHandle (file);
518               return NULL;
519             }
520           fp = fdopen (fd, "w+b");
521 #endif
522           if (!fp)
523             {
524               int save = errno;
525               close (fd);
526               gpg_err_set_errno (save);
527               return NULL;
528             }
529           return fp;
530         }
531       Sleep (1); /* One ms as this is the granularity of GetTickCount.  */
532     }
533   gpg_err_set_errno (ENOENT);
534   return NULL;
535 #undef mystrlen
536 #else /*!HAVE_W32_SYSTEM*/
537   return tmpfile ();
538 #endif /*!HAVE_W32_SYSTEM*/
539 }
540
541
542 /* Make sure that the standard file descriptors are opened. Obviously
543    some folks close them before an exec and the next file we open will
544    get one of them assigned and thus any output (i.e. diagnostics) end
545    up in that file (e.g. the trustdb).  Not actually a gpg problem as
546    this will happen with almost all utilities when called in a wrong
547    way.  However we try to minimize the damage here and raise
548    awareness of the problem.
549
550    Must be called before we open any files! */
551 void
552 gnupg_reopen_std (const char *pgmname)
553 {
554 #if defined(HAVE_STAT) && !defined(HAVE_W32_SYSTEM)
555   struct stat statbuf;
556   int did_stdin = 0;
557   int did_stdout = 0;
558   int did_stderr = 0;
559   FILE *complain;
560
561   if (fstat (STDIN_FILENO, &statbuf) == -1 && errno ==EBADF)
562     {
563       if (open ("/dev/null",O_RDONLY) == STDIN_FILENO)
564         did_stdin = 1;
565       else
566         did_stdin = 2;
567     }
568
569   if (fstat (STDOUT_FILENO, &statbuf) == -1 && errno == EBADF)
570     {
571       if (open ("/dev/null",O_WRONLY) == STDOUT_FILENO)
572         did_stdout = 1;
573       else
574         did_stdout = 2;
575     }
576
577   if (fstat (STDERR_FILENO, &statbuf)==-1 && errno==EBADF)
578     {
579       if (open ("/dev/null", O_WRONLY) == STDERR_FILENO)
580         did_stderr = 1;
581       else
582         did_stderr = 2;
583     }
584
585   /* It's hard to log this sort of thing since the filehandle we would
586      complain to may be closed... */
587   if (!did_stderr)
588     complain = stderr;
589   else if (!did_stdout)
590     complain = stdout;
591   else
592     complain = NULL;
593
594   if (complain)
595     {
596       if (did_stdin == 1)
597         fprintf (complain, "%s: WARNING: standard input reopened\n", pgmname);
598       if (did_stdout == 1)
599         fprintf (complain, "%s: WARNING: standard output reopened\n", pgmname);
600       if (did_stderr == 1)
601         fprintf (complain, "%s: WARNING: standard error reopened\n", pgmname);
602
603       if (did_stdin == 2 || did_stdout == 2 || did_stderr == 2)
604         fprintf(complain,"%s: fatal: unable to reopen standard input,"
605                 " output, or error\n", pgmname);
606     }
607
608   if (did_stdin == 2 || did_stdout == 2 || did_stderr == 2)
609     exit (3);
610 #else /* !(HAVE_STAT && !HAVE_W32_SYSTEM) */
611   (void)pgmname;
612 #endif
613 }
614
615
616 /* Hack required for Windows.  */
617 void
618 gnupg_allow_set_foregound_window (pid_t pid)
619 {
620   if (!pid)
621     log_info ("%s called with invalid pid %lu\n",
622               "gnupg_allow_set_foregound_window", (unsigned long)pid);
623 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
624   else if (!AllowSetForegroundWindow ((pid_t)pid == (pid_t)(-1)?ASFW_ANY:pid))
625     log_info ("AllowSetForegroundWindow(%lu) failed: %s\n",
626                (unsigned long)pid, w32_strerror (-1));
627 #endif
628 }
629
630 int
631 gnupg_remove (const char *fname)
632 {
633 #ifdef HAVE_W32CE_SYSTEM
634   int rc;
635   wchar_t *wfname;
636
637   wfname = utf8_to_wchar (fname);
638   if (!wfname)
639     rc = 0;
640   else
641     {
642       rc = DeleteFile (wfname);
643       xfree (wfname);
644     }
645   if (!rc)
646     return -1; /* ERRNO is automagically provided by gpg-error.h.  */
647   return 0;
648 #else
649   return remove (fname);
650 #endif
651 }
652
653
654 /* Wrapper for rename(2) to handle Windows peculiarities.  If
655  * BLOCK_SIGNALS is not NULL and points to a variable set to true, all
656  * signals will be blocked by calling gnupg_block_all_signals; the
657  * caller needs to call gnupg_unblock_all_signals if that variable is
658  * still set to true on return. */
659 gpg_error_t
660 gnupg_rename_file (const char *oldname, const char *newname, int *block_signals)
661 {
662   gpg_error_t err = 0;
663
664   if (block_signals && *block_signals)
665     gnupg_block_all_signals ();
666
667 #ifdef HAVE_DOSISH_SYSTEM
668   {
669     int wtime = 0;
670
671     gnupg_remove (newname);
672   again:
673     if (rename (oldname, newname))
674       {
675         if (GetLastError () == ERROR_SHARING_VIOLATION)
676           {
677             /* Another process has the file open.  We do not use a
678              * lock for read but instead we wait until the other
679              * process has closed the file.  This may take long but
680              * that would also be the case with a dotlock approach for
681              * read and write.  Note that we don't need this on Unix
682              * due to the inode concept.
683              *
684              * So let's wait until the rename has worked.  The retry
685              * intervals are 50, 100, 200, 400, 800, 50ms, ...  */
686             if (!wtime || wtime >= 800)
687               wtime = 50;
688             else
689               wtime *= 2;
690
691             if (wtime >= 800)
692               log_info (_("waiting for file '%s' to become accessible ...\n"),
693                         oldname);
694
695             Sleep (wtime);
696             goto again;
697           }
698         err = my_error_from_syserror ();
699       }
700   }
701 #else /* Unix */
702   {
703 #ifdef __riscos__
704     gnupg_remove (newname);
705 #endif
706     if (rename (oldname, newname) )
707       err = my_error_from_syserror ();
708   }
709 #endif /* Unix */
710
711   if (block_signals && *block_signals && err)
712     {
713       gnupg_unblock_all_signals ();
714       *block_signals = 0;
715     }
716
717   if (err)
718     log_error (_("renaming '%s' to '%s' failed: %s\n"),
719                oldname, newname, gpg_strerror (err));
720   return err;
721 }
722
723
724 #ifndef HAVE_W32_SYSTEM
725 static mode_t
726 modestr_to_mode (const char *modestr)
727 {
728   mode_t mode = 0;
729
730   if (modestr && *modestr)
731     {
732       modestr++;
733       if (*modestr && *modestr++ == 'r')
734         mode |= S_IRUSR;
735       if (*modestr && *modestr++ == 'w')
736         mode |= S_IWUSR;
737       if (*modestr && *modestr++ == 'x')
738         mode |= S_IXUSR;
739       if (*modestr && *modestr++ == 'r')
740         mode |= S_IRGRP;
741       if (*modestr && *modestr++ == 'w')
742         mode |= S_IWGRP;
743       if (*modestr && *modestr++ == 'x')
744         mode |= S_IXGRP;
745       if (*modestr && *modestr++ == 'r')
746         mode |= S_IROTH;
747       if (*modestr && *modestr++ == 'w')
748         mode |= S_IWOTH;
749       if (*modestr && *modestr++ == 'x')
750         mode |= S_IXOTH;
751     }
752
753   return mode;
754 }
755 #endif
756
757
758 /* A wrapper around mkdir which takes a string for the mode argument.
759    This makes it easier to handle the mode argument which is not
760    defined on all systems.  The format of the modestring is
761
762       "-rwxrwxrwx"
763
764    '-' is a don't care or not set.  'r', 'w', 'x' are read allowed,
765    write allowed, execution allowed with the first group for the user,
766    the second for the group and the third for all others.  If the
767    string is shorter than above the missing mode characters are meant
768    to be not set.  */
769 int
770 gnupg_mkdir (const char *name, const char *modestr)
771 {
772 #ifdef HAVE_W32CE_SYSTEM
773   wchar_t *wname;
774   (void)modestr;
775
776   wname = utf8_to_wchar (name);
777   if (!wname)
778     return -1;
779   if (!CreateDirectoryW (wname, NULL))
780     {
781       xfree (wname);
782       return -1;  /* ERRNO is automagically provided by gpg-error.h.  */
783     }
784   xfree (wname);
785   return 0;
786 #elif MKDIR_TAKES_ONE_ARG
787   (void)modestr;
788   /* Note: In the case of W32 we better use CreateDirectory and try to
789      set appropriate permissions.  However using mkdir is easier
790      because this sets ERRNO.  */
791   return mkdir (name);
792 #else
793   return mkdir (name, modestr_to_mode (modestr));
794 #endif
795 }
796
797
798 /* A simple wrapper around chdir.  NAME is expected to be utf8
799  * encoded.  */
800 int
801 gnupg_chdir (const char *name)
802 {
803   return chdir (name);
804 }
805
806
807 /* A wrapper around chmod which takes a string for the mode argument.
808    This makes it easier to handle the mode argument which is not
809    defined on all systems.  The format of the modestring is the same
810    as for gnupg_mkdir.  */
811 int
812 gnupg_chmod (const char *name, const char *modestr)
813 {
814 #ifdef HAVE_W32_SYSTEM
815   (void)name;
816   (void)modestr;
817   return 0;
818 #else
819   return chmod (name, modestr_to_mode (modestr));
820 #endif
821 }
822
823
824 /* Our version of mkdtemp.  The API is identical to POSIX.1-2008
825    version.  We do not use a system provided mkdtemp because we have a
826    good RNG instantly available and this way we don't have diverging
827    versions.  */
828 char *
829 gnupg_mkdtemp (char *tmpl)
830 {
831   /* A lower bound on the number of temporary files to attempt to
832      generate.  The maximum total number of temporary file names that
833      can exist for a given template is 62**6 (5*36**3 for Windows).
834      It should never be necessary to try all these combinations.
835      Instead if a reasonable number of names is tried (we define
836      reasonable as 62**3 or 5*36**3) fail to give the system
837      administrator the chance to remove the problems.  */
838 #ifdef HAVE_W32_SYSTEM
839   static const char letters[] =
840     "abcdefghijklmnopqrstuvwxyz0123456789";
841 # define NUMBER_OF_LETTERS 36
842 # define ATTEMPTS_MIN (5 * 36 * 36 * 36)
843 #else
844   static const char letters[] =
845     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
846 # define NUMBER_OF_LETTERS 62
847 # define ATTEMPTS_MIN (62 * 62 * 62)
848 #endif
849   int len;
850   char *XXXXXX;
851   uint64_t value;
852   unsigned int count;
853   int save_errno = errno;
854   /* The number of times to attempt to generate a temporary file.  To
855      conform to POSIX, this must be no smaller than TMP_MAX.  */
856 #if ATTEMPTS_MIN < TMP_MAX
857   unsigned int attempts = TMP_MAX;
858 #else
859   unsigned int attempts = ATTEMPTS_MIN;
860 #endif
861
862   len = strlen (tmpl);
863   if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
864     {
865       gpg_err_set_errno (EINVAL);
866       return NULL;
867     }
868
869   /* This is where the Xs start.  */
870   XXXXXX = &tmpl[len - 6];
871
872   /* Get a random start value.  */
873   gcry_create_nonce (&value, sizeof value);
874
875   /* Loop until a directory was created.  */
876   for (count = 0; count < attempts; value += 7777, ++count)
877     {
878       uint64_t v = value;
879
880       /* Fill in the random bits.  */
881       XXXXXX[0] = letters[v % NUMBER_OF_LETTERS];
882       v /= NUMBER_OF_LETTERS;
883       XXXXXX[1] = letters[v % NUMBER_OF_LETTERS];
884       v /= NUMBER_OF_LETTERS;
885       XXXXXX[2] = letters[v % NUMBER_OF_LETTERS];
886       v /= NUMBER_OF_LETTERS;
887       XXXXXX[3] = letters[v % NUMBER_OF_LETTERS];
888       v /= NUMBER_OF_LETTERS;
889       XXXXXX[4] = letters[v % NUMBER_OF_LETTERS];
890       v /= NUMBER_OF_LETTERS;
891       XXXXXX[5] = letters[v % NUMBER_OF_LETTERS];
892
893       if (!gnupg_mkdir (tmpl, "-rwx"))
894         {
895           gpg_err_set_errno (save_errno);
896           return tmpl;
897         }
898       if (errno != EEXIST)
899         return NULL;
900     }
901
902   /* We got out of the loop because we ran out of combinations to try.  */
903   gpg_err_set_errno (EEXIST);
904   return NULL;
905 }
906
907
908 int
909 gnupg_setenv (const char *name, const char *value, int overwrite)
910 {
911 #ifdef HAVE_W32CE_SYSTEM
912   (void)name;
913   (void)value;
914   (void)overwrite;
915   return 0;
916 #else /*!W32CE*/
917 # ifdef HAVE_W32_SYSTEM
918   /*  Windows maintains (at least) two sets of environment variables.
919       One set can be accessed by GetEnvironmentVariable and
920       SetEnvironmentVariable.  This set is inherited by the children.
921       The other set is maintained in the C runtime, and is accessed
922       using getenv and putenv.  We try to keep them in sync by
923       modifying both sets.  */
924   {
925     int exists;
926     char tmpbuf[10];
927     exists = GetEnvironmentVariable (name, tmpbuf, sizeof tmpbuf);
928
929     if ((! exists || overwrite) && !SetEnvironmentVariable (name, value))
930       {
931         gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
932         return -1;
933       }
934   }
935 # endif /*W32*/
936
937 # ifdef HAVE_SETENV
938   return setenv (name, value, overwrite);
939 # else /*!HAVE_SETENV*/
940   if (! getenv (name) || overwrite)
941     {
942       char *buf;
943
944       (void)overwrite;
945       if (!name || !value)
946         {
947           gpg_err_set_errno (EINVAL);
948           return -1;
949         }
950       buf = strconcat (name, "=", value, NULL);
951       if (!buf)
952         return -1;
953 # if __GNUC__
954 #  warning no setenv - using putenv but leaking memory.
955 # endif
956       return putenv (buf);
957     }
958   return 0;
959 # endif /*!HAVE_SETENV*/
960 #endif /*!W32CE*/
961 }
962
963
964 int
965 gnupg_unsetenv (const char *name)
966 {
967 #ifdef HAVE_W32CE_SYSTEM
968   (void)name;
969   return 0;
970 #else /*!W32CE*/
971 # ifdef HAVE_W32_SYSTEM
972   /*  Windows maintains (at least) two sets of environment variables.
973       One set can be accessed by GetEnvironmentVariable and
974       SetEnvironmentVariable.  This set is inherited by the children.
975       The other set is maintained in the C runtime, and is accessed
976       using getenv and putenv.  We try to keep them in sync by
977       modifying both sets.  */
978   if (!SetEnvironmentVariable (name, NULL))
979     {
980       gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
981       return -1;
982     }
983 # endif /*W32*/
984
985 # ifdef HAVE_UNSETENV
986   return unsetenv (name);
987 # else /*!HAVE_UNSETENV*/
988   {
989     char *buf;
990
991     if (!name)
992       {
993         gpg_err_set_errno (EINVAL);
994         return -1;
995       }
996     buf = xtrystrdup (name);
997     if (!buf)
998       return -1;
999 #  if __GNUC__
1000 #   warning no unsetenv - trying putenv but leaking memory.
1001 #  endif
1002     return putenv (buf);
1003   }
1004 # endif /*!HAVE_UNSETENV*/
1005 #endif /*!W32CE*/
1006 }
1007
1008
1009 /* Return the current working directory as a malloced string.  Return
1010    NULL and sets ERRNo on error.  */
1011 char *
1012 gnupg_getcwd (void)
1013 {
1014   char *buffer;
1015   size_t size = 100;
1016
1017   for (;;)
1018     {
1019       buffer = xtrymalloc (size+1);
1020       if (!buffer)
1021         return NULL;
1022 #ifdef HAVE_W32CE_SYSTEM
1023       strcpy (buffer, "/");  /* Always "/".  */
1024       return buffer;
1025 #else
1026       if (getcwd (buffer, size) == buffer)
1027         return buffer;
1028       xfree (buffer);
1029       if (errno != ERANGE)
1030         return NULL;
1031       size *= 2;
1032 #endif
1033     }
1034 }
1035
1036
1037 \f
1038 #ifdef HAVE_W32CE_SYSTEM
1039 /* There is a isatty function declaration in cegcc but it does not
1040    make sense, thus we redefine it.  */
1041 int
1042 _gnupg_isatty (int fd)
1043 {
1044   (void)fd;
1045   return 0;
1046 }
1047 #endif
1048
1049
1050 #ifdef HAVE_W32CE_SYSTEM
1051 /* Replacement for getenv which takes care of the our use of getenv.
1052    The code is not thread safe but we expect it to work in all cases
1053    because it is called for the first time early enough.  */
1054 char *
1055 _gnupg_getenv (const char *name)
1056 {
1057   static int initialized;
1058   static char *assuan_debug;
1059
1060   if (!initialized)
1061     {
1062       assuan_debug = read_w32_registry_string (NULL,
1063                                                "\\Software\\GNU\\libassuan",
1064                                                "debug");
1065       initialized = 1;
1066     }
1067
1068   if (!strcmp (name, "ASSUAN_DEBUG"))
1069     return assuan_debug;
1070   else
1071     return NULL;
1072 }
1073
1074 #endif /*HAVE_W32CE_SYSTEM*/
1075
1076
1077 #ifdef HAVE_W32_SYSTEM
1078 /* Return the user's security identifier from the current process.  */
1079 PSID
1080 w32_get_user_sid (void)
1081 {
1082   int okay = 0;
1083   HANDLE proc = NULL;
1084   HANDLE token = NULL;
1085   TOKEN_USER *user = NULL;
1086   PSID sid = NULL;
1087   DWORD tokenlen, sidlen;
1088
1089   proc = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1090   if (!proc)
1091     goto leave;
1092
1093   if (!OpenProcessToken (proc, TOKEN_QUERY, &token))
1094     goto leave;
1095
1096   if (!GetTokenInformation (token, TokenUser, NULL, 0, &tokenlen)
1097       && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1098     goto leave;
1099
1100   user = xtrymalloc (tokenlen);
1101   if (!user)
1102     goto leave;
1103
1104   if (!GetTokenInformation (token, TokenUser, user, tokenlen, &tokenlen))
1105     goto leave;
1106   if (!IsValidSid (user->User.Sid))
1107     goto leave;
1108   sidlen = GetLengthSid (user->User.Sid);
1109   sid = xtrymalloc (sidlen);
1110   if (!sid)
1111     goto leave;
1112   if (!CopySid (sidlen, sid, user->User.Sid))
1113     goto leave;
1114   okay = 1;
1115
1116  leave:
1117   xfree (user);
1118   if (token)
1119     CloseHandle (token);
1120   if (proc)
1121     CloseHandle (proc);
1122
1123   if (!okay)
1124     {
1125       xfree (sid);
1126       sid = NULL;
1127     }
1128   return sid;
1129 }
1130 #endif /*HAVE_W32_SYSTEM*/
1131
1132
1133 \f
1134 /* Support for inotify under Linux.  */
1135
1136 /* Store a new inotify file handle for FNAME at R_FD or return an
1137  * error code.  This file descriptor watch the removal of FNAME. */
1138 gpg_error_t
1139 gnupg_inotify_watch_delete_self (int *r_fd, const char *fname)
1140 {
1141 #if HAVE_INOTIFY_INIT
1142   gpg_error_t err;
1143   int fd;
1144
1145   *r_fd = -1;
1146
1147   if (!fname)
1148     return my_error (GPG_ERR_INV_VALUE);
1149
1150   fd = inotify_init ();
1151   if (fd == -1)
1152     return my_error_from_syserror ();
1153
1154   if (inotify_add_watch (fd, fname, IN_DELETE_SELF) == -1)
1155     {
1156       err = my_error_from_syserror ();
1157       close (fd);
1158       return err;
1159     }
1160
1161   *r_fd = fd;
1162   return 0;
1163 #else /*!HAVE_INOTIFY_INIT*/
1164
1165   (void)fname;
1166   *r_fd = -1;
1167   return my_error (GPG_ERR_NOT_SUPPORTED);
1168
1169 #endif /*!HAVE_INOTIFY_INIT*/
1170 }
1171
1172
1173 /* Store a new inotify file handle for SOCKET_NAME at R_FD or return
1174  * an error code. */
1175 gpg_error_t
1176 gnupg_inotify_watch_socket (int *r_fd, const char *socket_name)
1177 {
1178 #if HAVE_INOTIFY_INIT
1179   gpg_error_t err;
1180   char *fname;
1181   int fd;
1182   char *p;
1183
1184   *r_fd = -1;
1185
1186   if (!socket_name)
1187     return my_error (GPG_ERR_INV_VALUE);
1188
1189   fname = xtrystrdup (socket_name);
1190   if (!fname)
1191     return my_error_from_syserror ();
1192
1193   fd = inotify_init ();
1194   if (fd == -1)
1195     {
1196       err = my_error_from_syserror ();
1197       xfree (fname);
1198       return err;
1199     }
1200
1201   /* We need to watch the directory for the file because there won't
1202    * be an IN_DELETE_SELF for a socket file.  To handle a removal of
1203    * the directory we also watch the directory itself. */
1204   p = strrchr (fname, '/');
1205   if (p)
1206     *p = 0;
1207   if (inotify_add_watch (fd, fname,
1208                          (IN_DELETE|IN_DELETE_SELF|IN_EXCL_UNLINK)) == -1)
1209     {
1210       err = my_error_from_syserror ();
1211       close (fd);
1212       xfree (fname);
1213       return err;
1214     }
1215
1216   xfree (fname);
1217
1218   *r_fd = fd;
1219   return 0;
1220 #else /*!HAVE_INOTIFY_INIT*/
1221
1222   (void)socket_name;
1223   *r_fd = -1;
1224   return my_error (GPG_ERR_NOT_SUPPORTED);
1225
1226 #endif /*!HAVE_INOTIFY_INIT*/
1227 }
1228
1229
1230 /* Read an inotify event and return true if it matches NAME or if it
1231  * sees an IN_DELETE_SELF event for the directory of NAME.  */
1232 int
1233 gnupg_inotify_has_name (int fd, const char *name)
1234 {
1235 #if USE_NPTH && HAVE_INOTIFY_INIT
1236 #define BUFSIZE_FOR_INOTIFY (sizeof (struct inotify_event) + 255 + 1)
1237   union {
1238     struct inotify_event ev;
1239     char _buf[sizeof (struct inotify_event) + 255 + 1];
1240   } buf;
1241   struct inotify_event *evp;
1242   int n;
1243
1244   n = npth_read (fd, &buf, sizeof buf);
1245   /* log_debug ("notify read: n=%d\n", n); */
1246   evp = &buf.ev;
1247   while (n >= sizeof (struct inotify_event))
1248     {
1249       /* log_debug ("             mask=%x len=%u name=(%s)\n", */
1250       /*        evp->mask, (unsigned int)evp->len, evp->len? evp->name:""); */
1251       if ((evp->mask & IN_UNMOUNT))
1252         {
1253           /* log_debug ("             found (dir unmounted)\n"); */
1254           return 3; /* Directory was unmounted.  */
1255         }
1256       if ((evp->mask & IN_DELETE_SELF))
1257         {
1258           /* log_debug ("             found (dir removed)\n"); */
1259           return 2; /* Directory was removed.  */
1260         }
1261       if ((evp->mask & IN_DELETE))
1262         {
1263           if (evp->len >= strlen (name) && !strcmp (evp->name, name))
1264             {
1265               /* log_debug ("             found (file removed)\n"); */
1266               return 1; /* File was removed.  */
1267             }
1268         }
1269       n -= sizeof (*evp) + evp->len;
1270       evp = (struct inotify_event *)(void *)
1271         ((char *)evp + sizeof (*evp) + evp->len);
1272     }
1273
1274 #else /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1275
1276   (void)fd;
1277   (void)name;
1278
1279 #endif  /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1280
1281   return 0; /* Not found.  */
1282 }
1283
1284
1285 /* Return a malloc'ed string that is the path to the passed
1286  * unix-domain socket (or return NULL if this is not a valid
1287  * unix-domain socket).  We use a plain int here because it is only
1288  * used on Linux.
1289  *
1290  * FIXME: This function needs to be moved to libassuan.  */
1291 #ifndef HAVE_W32_SYSTEM
1292 char *
1293 gnupg_get_socket_name (int fd)
1294 {
1295   struct sockaddr_un un;
1296   socklen_t len = sizeof(un);
1297   char *name = NULL;
1298
1299   if (getsockname (fd, (struct sockaddr*)&un, &len) != 0)
1300     log_error ("could not getsockname(%d): %s\n", fd,
1301                gpg_strerror (my_error_from_syserror ()));
1302   else if (un.sun_family != AF_UNIX)
1303     log_error ("file descriptor %d is not a unix-domain socket\n", fd);
1304   else if (len <= offsetof (struct sockaddr_un, sun_path))
1305     log_error ("socket name not present for file descriptor %d\n", fd);
1306   else if (len > sizeof(un))
1307     log_error ("socket name for file descriptor %d was truncated "
1308                "(passed %zu bytes, wanted %u)\n", fd, sizeof(un), len);
1309   else
1310     {
1311       size_t namelen = len - offsetof (struct sockaddr_un, sun_path);
1312
1313       /* log_debug ("file descriptor %d has path %s (%zu octets)\n", fd, */
1314       /*            un.sun_path, namelen); */
1315       name = xtrymalloc (namelen + 1);
1316       if (!name)
1317         log_error ("failed to allocate memory for name of fd %d: %s\n",
1318                    fd, gpg_strerror (my_error_from_syserror ()));
1319       else
1320         {
1321           memcpy (name, un.sun_path, namelen);
1322           name[namelen] = 0;
1323         }
1324     }
1325
1326   return name;
1327 }
1328 #endif /*!HAVE_W32_SYSTEM*/
1329
1330 /* Check whether FD is valid.  */
1331 int
1332 gnupg_fd_valid (int fd)
1333 {
1334   int d = dup (fd);
1335   if (d < 0)
1336     return 0;
1337   close (d);
1338   return 1;
1339 }