scd: Split data structures into app and card related objects.
[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 #ifdef F_GETFD
555   int did_stdin = 0;
556   int did_stdout = 0;
557   int did_stderr = 0;
558   FILE *complain;
559
560   if (fcntl (STDIN_FILENO, F_GETFD) == -1 && errno ==EBADF)
561     {
562       if (open ("/dev/null",O_RDONLY) == STDIN_FILENO)
563         did_stdin = 1;
564       else
565         did_stdin = 2;
566     }
567
568   if (fcntl (STDOUT_FILENO, F_GETFD) == -1 && errno == EBADF)
569     {
570       if (open ("/dev/null",O_WRONLY) == STDOUT_FILENO)
571         did_stdout = 1;
572       else
573         did_stdout = 2;
574     }
575
576   if (fcntl (STDERR_FILENO, F_GETFD)==-1 && errno==EBADF)
577     {
578       if (open ("/dev/null", O_WRONLY) == STDERR_FILENO)
579         did_stderr = 1;
580       else
581         did_stderr = 2;
582     }
583
584   /* It's hard to log this sort of thing since the filehandle we would
585      complain to may be closed... */
586   if (!did_stderr)
587     complain = stderr;
588   else if (!did_stdout)
589     complain = stdout;
590   else
591     complain = NULL;
592
593   if (complain)
594     {
595       if (did_stdin == 1)
596         fprintf (complain, "%s: WARNING: standard input reopened\n", pgmname);
597       if (did_stdout == 1)
598         fprintf (complain, "%s: WARNING: standard output reopened\n", pgmname);
599       if (did_stderr == 1)
600         fprintf (complain, "%s: WARNING: standard error reopened\n", pgmname);
601
602       if (did_stdin == 2 || did_stdout == 2 || did_stderr == 2)
603         fprintf(complain,"%s: fatal: unable to reopen standard input,"
604                 " output, or error\n", pgmname);
605     }
606
607   if (did_stdin == 2 || did_stdout == 2 || did_stderr == 2)
608     exit (3);
609 #else /* !F_GETFD */
610   (void)pgmname;
611 #endif
612 }
613
614
615 /* Hack required for Windows.  */
616 void
617 gnupg_allow_set_foregound_window (pid_t pid)
618 {
619   if (!pid)
620     log_info ("%s called with invalid pid %lu\n",
621               "gnupg_allow_set_foregound_window", (unsigned long)pid);
622 #if defined(HAVE_W32_SYSTEM) && !defined(HAVE_W32CE_SYSTEM)
623   else if (!AllowSetForegroundWindow ((pid_t)pid == (pid_t)(-1)?ASFW_ANY:pid))
624     log_info ("AllowSetForegroundWindow(%lu) failed: %s\n",
625                (unsigned long)pid, w32_strerror (-1));
626 #endif
627 }
628
629 int
630 gnupg_remove (const char *fname)
631 {
632 #ifdef HAVE_W32CE_SYSTEM
633   int rc;
634   wchar_t *wfname;
635
636   wfname = utf8_to_wchar (fname);
637   if (!wfname)
638     rc = 0;
639   else
640     {
641       rc = DeleteFile (wfname);
642       xfree (wfname);
643     }
644   if (!rc)
645     return -1; /* ERRNO is automagically provided by gpg-error.h.  */
646   return 0;
647 #else
648   return remove (fname);
649 #endif
650 }
651
652
653 /* Wrapper for rename(2) to handle Windows peculiarities.  If
654  * BLOCK_SIGNALS is not NULL and points to a variable set to true, all
655  * signals will be blocked by calling gnupg_block_all_signals; the
656  * caller needs to call gnupg_unblock_all_signals if that variable is
657  * still set to true on return. */
658 gpg_error_t
659 gnupg_rename_file (const char *oldname, const char *newname, int *block_signals)
660 {
661   gpg_error_t err = 0;
662
663   if (block_signals && *block_signals)
664     gnupg_block_all_signals ();
665
666 #ifdef HAVE_DOSISH_SYSTEM
667   {
668     int wtime = 0;
669
670     gnupg_remove (newname);
671   again:
672     if (rename (oldname, newname))
673       {
674         if (GetLastError () == ERROR_SHARING_VIOLATION)
675           {
676             /* Another process has the file open.  We do not use a
677              * lock for read but instead we wait until the other
678              * process has closed the file.  This may take long but
679              * that would also be the case with a dotlock approach for
680              * read and write.  Note that we don't need this on Unix
681              * due to the inode concept.
682              *
683              * So let's wait until the rename has worked.  The retry
684              * intervals are 50, 100, 200, 400, 800, 50ms, ...  */
685             if (!wtime || wtime >= 800)
686               wtime = 50;
687             else
688               wtime *= 2;
689
690             if (wtime >= 800)
691               log_info (_("waiting for file '%s' to become accessible ...\n"),
692                         oldname);
693
694             Sleep (wtime);
695             goto again;
696           }
697         err = my_error_from_syserror ();
698       }
699   }
700 #else /* Unix */
701   {
702 #ifdef __riscos__
703     gnupg_remove (newname);
704 #endif
705     if (rename (oldname, newname) )
706       err = my_error_from_syserror ();
707   }
708 #endif /* Unix */
709
710   if (block_signals && *block_signals && err)
711     {
712       gnupg_unblock_all_signals ();
713       *block_signals = 0;
714     }
715
716   if (err)
717     log_error (_("renaming '%s' to '%s' failed: %s\n"),
718                oldname, newname, gpg_strerror (err));
719   return err;
720 }
721
722
723 #ifndef HAVE_W32_SYSTEM
724 static mode_t
725 modestr_to_mode (const char *modestr)
726 {
727   mode_t mode = 0;
728
729   if (modestr && *modestr)
730     {
731       modestr++;
732       if (*modestr && *modestr++ == 'r')
733         mode |= S_IRUSR;
734       if (*modestr && *modestr++ == 'w')
735         mode |= S_IWUSR;
736       if (*modestr && *modestr++ == 'x')
737         mode |= S_IXUSR;
738       if (*modestr && *modestr++ == 'r')
739         mode |= S_IRGRP;
740       if (*modestr && *modestr++ == 'w')
741         mode |= S_IWGRP;
742       if (*modestr && *modestr++ == 'x')
743         mode |= S_IXGRP;
744       if (*modestr && *modestr++ == 'r')
745         mode |= S_IROTH;
746       if (*modestr && *modestr++ == 'w')
747         mode |= S_IWOTH;
748       if (*modestr && *modestr++ == 'x')
749         mode |= S_IXOTH;
750     }
751
752   return mode;
753 }
754 #endif
755
756
757 /* A wrapper around mkdir which takes a string for the mode argument.
758    This makes it easier to handle the mode argument which is not
759    defined on all systems.  The format of the modestring is
760
761       "-rwxrwxrwx"
762
763    '-' is a don't care or not set.  'r', 'w', 'x' are read allowed,
764    write allowed, execution allowed with the first group for the user,
765    the second for the group and the third for all others.  If the
766    string is shorter than above the missing mode characters are meant
767    to be not set.  */
768 int
769 gnupg_mkdir (const char *name, const char *modestr)
770 {
771 #ifdef HAVE_W32CE_SYSTEM
772   wchar_t *wname;
773   (void)modestr;
774
775   wname = utf8_to_wchar (name);
776   if (!wname)
777     return -1;
778   if (!CreateDirectoryW (wname, NULL))
779     {
780       xfree (wname);
781       return -1;  /* ERRNO is automagically provided by gpg-error.h.  */
782     }
783   xfree (wname);
784   return 0;
785 #elif MKDIR_TAKES_ONE_ARG
786   (void)modestr;
787   /* Note: In the case of W32 we better use CreateDirectory and try to
788      set appropriate permissions.  However using mkdir is easier
789      because this sets ERRNO.  */
790   return mkdir (name);
791 #else
792   return mkdir (name, modestr_to_mode (modestr));
793 #endif
794 }
795
796
797 /* A simple wrapper around chdir.  NAME is expected to be utf8
798  * encoded.  */
799 int
800 gnupg_chdir (const char *name)
801 {
802   return chdir (name);
803 }
804
805
806 /* A wrapper around chmod which takes a string for the mode argument.
807    This makes it easier to handle the mode argument which is not
808    defined on all systems.  The format of the modestring is the same
809    as for gnupg_mkdir.  */
810 int
811 gnupg_chmod (const char *name, const char *modestr)
812 {
813 #ifdef HAVE_W32_SYSTEM
814   (void)name;
815   (void)modestr;
816   return 0;
817 #else
818   return chmod (name, modestr_to_mode (modestr));
819 #endif
820 }
821
822
823 /* Our version of mkdtemp.  The API is identical to POSIX.1-2008
824    version.  We do not use a system provided mkdtemp because we have a
825    good RNG instantly available and this way we don't have diverging
826    versions.  */
827 char *
828 gnupg_mkdtemp (char *tmpl)
829 {
830   /* A lower bound on the number of temporary files to attempt to
831      generate.  The maximum total number of temporary file names that
832      can exist for a given template is 62**6 (5*36**3 for Windows).
833      It should never be necessary to try all these combinations.
834      Instead if a reasonable number of names is tried (we define
835      reasonable as 62**3 or 5*36**3) fail to give the system
836      administrator the chance to remove the problems.  */
837 #ifdef HAVE_W32_SYSTEM
838   static const char letters[] =
839     "abcdefghijklmnopqrstuvwxyz0123456789";
840 # define NUMBER_OF_LETTERS 36
841 # define ATTEMPTS_MIN (5 * 36 * 36 * 36)
842 #else
843   static const char letters[] =
844     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
845 # define NUMBER_OF_LETTERS 62
846 # define ATTEMPTS_MIN (62 * 62 * 62)
847 #endif
848   int len;
849   char *XXXXXX;
850   uint64_t value;
851   unsigned int count;
852   int save_errno = errno;
853   /* The number of times to attempt to generate a temporary file.  To
854      conform to POSIX, this must be no smaller than TMP_MAX.  */
855 #if ATTEMPTS_MIN < TMP_MAX
856   unsigned int attempts = TMP_MAX;
857 #else
858   unsigned int attempts = ATTEMPTS_MIN;
859 #endif
860
861   len = strlen (tmpl);
862   if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
863     {
864       gpg_err_set_errno (EINVAL);
865       return NULL;
866     }
867
868   /* This is where the Xs start.  */
869   XXXXXX = &tmpl[len - 6];
870
871   /* Get a random start value.  */
872   gcry_create_nonce (&value, sizeof value);
873
874   /* Loop until a directory was created.  */
875   for (count = 0; count < attempts; value += 7777, ++count)
876     {
877       uint64_t v = value;
878
879       /* Fill in the random bits.  */
880       XXXXXX[0] = letters[v % NUMBER_OF_LETTERS];
881       v /= NUMBER_OF_LETTERS;
882       XXXXXX[1] = letters[v % NUMBER_OF_LETTERS];
883       v /= NUMBER_OF_LETTERS;
884       XXXXXX[2] = letters[v % NUMBER_OF_LETTERS];
885       v /= NUMBER_OF_LETTERS;
886       XXXXXX[3] = letters[v % NUMBER_OF_LETTERS];
887       v /= NUMBER_OF_LETTERS;
888       XXXXXX[4] = letters[v % NUMBER_OF_LETTERS];
889       v /= NUMBER_OF_LETTERS;
890       XXXXXX[5] = letters[v % NUMBER_OF_LETTERS];
891
892       if (!gnupg_mkdir (tmpl, "-rwx"))
893         {
894           gpg_err_set_errno (save_errno);
895           return tmpl;
896         }
897       if (errno != EEXIST)
898         return NULL;
899     }
900
901   /* We got out of the loop because we ran out of combinations to try.  */
902   gpg_err_set_errno (EEXIST);
903   return NULL;
904 }
905
906
907 int
908 gnupg_setenv (const char *name, const char *value, int overwrite)
909 {
910 #ifdef HAVE_W32CE_SYSTEM
911   (void)name;
912   (void)value;
913   (void)overwrite;
914   return 0;
915 #else /*!W32CE*/
916 # ifdef HAVE_W32_SYSTEM
917   /*  Windows maintains (at least) two sets of environment variables.
918       One set can be accessed by GetEnvironmentVariable and
919       SetEnvironmentVariable.  This set is inherited by the children.
920       The other set is maintained in the C runtime, and is accessed
921       using getenv and putenv.  We try to keep them in sync by
922       modifying both sets.  */
923   {
924     int exists;
925     char tmpbuf[10];
926     exists = GetEnvironmentVariable (name, tmpbuf, sizeof tmpbuf);
927
928     if ((! exists || overwrite) && !SetEnvironmentVariable (name, value))
929       {
930         gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
931         return -1;
932       }
933   }
934 # endif /*W32*/
935
936 # ifdef HAVE_SETENV
937   return setenv (name, value, overwrite);
938 # else /*!HAVE_SETENV*/
939   if (! getenv (name) || overwrite)
940     {
941       char *buf;
942
943       (void)overwrite;
944       if (!name || !value)
945         {
946           gpg_err_set_errno (EINVAL);
947           return -1;
948         }
949       buf = strconcat (name, "=", value, NULL);
950       if (!buf)
951         return -1;
952 # if __GNUC__
953 #  warning no setenv - using putenv but leaking memory.
954 # endif
955       return putenv (buf);
956     }
957   return 0;
958 # endif /*!HAVE_SETENV*/
959 #endif /*!W32CE*/
960 }
961
962
963 int
964 gnupg_unsetenv (const char *name)
965 {
966 #ifdef HAVE_W32CE_SYSTEM
967   (void)name;
968   return 0;
969 #else /*!W32CE*/
970 # ifdef HAVE_W32_SYSTEM
971   /*  Windows maintains (at least) two sets of environment variables.
972       One set can be accessed by GetEnvironmentVariable and
973       SetEnvironmentVariable.  This set is inherited by the children.
974       The other set is maintained in the C runtime, and is accessed
975       using getenv and putenv.  We try to keep them in sync by
976       modifying both sets.  */
977   if (!SetEnvironmentVariable (name, NULL))
978     {
979       gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
980       return -1;
981     }
982 # endif /*W32*/
983
984 # ifdef HAVE_UNSETENV
985   return unsetenv (name);
986 # else /*!HAVE_UNSETENV*/
987   {
988     char *buf;
989
990     if (!name)
991       {
992         gpg_err_set_errno (EINVAL);
993         return -1;
994       }
995     buf = xtrystrdup (name);
996     if (!buf)
997       return -1;
998 #  if __GNUC__
999 #   warning no unsetenv - trying putenv but leaking memory.
1000 #  endif
1001     return putenv (buf);
1002   }
1003 # endif /*!HAVE_UNSETENV*/
1004 #endif /*!W32CE*/
1005 }
1006
1007
1008 /* Return the current working directory as a malloced string.  Return
1009    NULL and sets ERRNo on error.  */
1010 char *
1011 gnupg_getcwd (void)
1012 {
1013   char *buffer;
1014   size_t size = 100;
1015
1016   for (;;)
1017     {
1018       buffer = xtrymalloc (size+1);
1019       if (!buffer)
1020         return NULL;
1021 #ifdef HAVE_W32CE_SYSTEM
1022       strcpy (buffer, "/");  /* Always "/".  */
1023       return buffer;
1024 #else
1025       if (getcwd (buffer, size) == buffer)
1026         return buffer;
1027       xfree (buffer);
1028       if (errno != ERANGE)
1029         return NULL;
1030       size *= 2;
1031 #endif
1032     }
1033 }
1034
1035
1036 \f
1037 #ifdef HAVE_W32CE_SYSTEM
1038 /* There is a isatty function declaration in cegcc but it does not
1039    make sense, thus we redefine it.  */
1040 int
1041 _gnupg_isatty (int fd)
1042 {
1043   (void)fd;
1044   return 0;
1045 }
1046 #endif
1047
1048
1049 #ifdef HAVE_W32CE_SYSTEM
1050 /* Replacement for getenv which takes care of the our use of getenv.
1051    The code is not thread safe but we expect it to work in all cases
1052    because it is called for the first time early enough.  */
1053 char *
1054 _gnupg_getenv (const char *name)
1055 {
1056   static int initialized;
1057   static char *assuan_debug;
1058
1059   if (!initialized)
1060     {
1061       assuan_debug = read_w32_registry_string (NULL,
1062                                                "\\Software\\GNU\\libassuan",
1063                                                "debug");
1064       initialized = 1;
1065     }
1066
1067   if (!strcmp (name, "ASSUAN_DEBUG"))
1068     return assuan_debug;
1069   else
1070     return NULL;
1071 }
1072
1073 #endif /*HAVE_W32CE_SYSTEM*/
1074
1075
1076 #ifdef HAVE_W32_SYSTEM
1077 /* Return the user's security identifier from the current process.  */
1078 PSID
1079 w32_get_user_sid (void)
1080 {
1081   int okay = 0;
1082   HANDLE proc = NULL;
1083   HANDLE token = NULL;
1084   TOKEN_USER *user = NULL;
1085   PSID sid = NULL;
1086   DWORD tokenlen, sidlen;
1087
1088   proc = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1089   if (!proc)
1090     goto leave;
1091
1092   if (!OpenProcessToken (proc, TOKEN_QUERY, &token))
1093     goto leave;
1094
1095   if (!GetTokenInformation (token, TokenUser, NULL, 0, &tokenlen)
1096       && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1097     goto leave;
1098
1099   user = xtrymalloc (tokenlen);
1100   if (!user)
1101     goto leave;
1102
1103   if (!GetTokenInformation (token, TokenUser, user, tokenlen, &tokenlen))
1104     goto leave;
1105   if (!IsValidSid (user->User.Sid))
1106     goto leave;
1107   sidlen = GetLengthSid (user->User.Sid);
1108   sid = xtrymalloc (sidlen);
1109   if (!sid)
1110     goto leave;
1111   if (!CopySid (sidlen, sid, user->User.Sid))
1112     goto leave;
1113   okay = 1;
1114
1115  leave:
1116   xfree (user);
1117   if (token)
1118     CloseHandle (token);
1119   if (proc)
1120     CloseHandle (proc);
1121
1122   if (!okay)
1123     {
1124       xfree (sid);
1125       sid = NULL;
1126     }
1127   return sid;
1128 }
1129 #endif /*HAVE_W32_SYSTEM*/
1130
1131
1132 \f
1133 /* Support for inotify under Linux.  */
1134
1135 /* Store a new inotify file handle for FNAME at R_FD or return an
1136  * error code.  This file descriptor watch the removal of FNAME. */
1137 gpg_error_t
1138 gnupg_inotify_watch_delete_self (int *r_fd, const char *fname)
1139 {
1140 #if HAVE_INOTIFY_INIT
1141   gpg_error_t err;
1142   int fd;
1143
1144   *r_fd = -1;
1145
1146   if (!fname)
1147     return my_error (GPG_ERR_INV_VALUE);
1148
1149   fd = inotify_init ();
1150   if (fd == -1)
1151     return my_error_from_syserror ();
1152
1153   if (inotify_add_watch (fd, fname, IN_DELETE_SELF) == -1)
1154     {
1155       err = my_error_from_syserror ();
1156       close (fd);
1157       return err;
1158     }
1159
1160   *r_fd = fd;
1161   return 0;
1162 #else /*!HAVE_INOTIFY_INIT*/
1163
1164   (void)fname;
1165   *r_fd = -1;
1166   return my_error (GPG_ERR_NOT_SUPPORTED);
1167
1168 #endif /*!HAVE_INOTIFY_INIT*/
1169 }
1170
1171
1172 /* Store a new inotify file handle for SOCKET_NAME at R_FD or return
1173  * an error code. */
1174 gpg_error_t
1175 gnupg_inotify_watch_socket (int *r_fd, const char *socket_name)
1176 {
1177 #if HAVE_INOTIFY_INIT
1178   gpg_error_t err;
1179   char *fname;
1180   int fd;
1181   char *p;
1182
1183   *r_fd = -1;
1184
1185   if (!socket_name)
1186     return my_error (GPG_ERR_INV_VALUE);
1187
1188   fname = xtrystrdup (socket_name);
1189   if (!fname)
1190     return my_error_from_syserror ();
1191
1192   fd = inotify_init ();
1193   if (fd == -1)
1194     {
1195       err = my_error_from_syserror ();
1196       xfree (fname);
1197       return err;
1198     }
1199
1200   /* We need to watch the directory for the file because there won't
1201    * be an IN_DELETE_SELF for a socket file.  To handle a removal of
1202    * the directory we also watch the directory itself. */
1203   p = strrchr (fname, '/');
1204   if (p)
1205     *p = 0;
1206   if (inotify_add_watch (fd, fname,
1207                          (IN_DELETE|IN_DELETE_SELF|IN_EXCL_UNLINK)) == -1)
1208     {
1209       err = my_error_from_syserror ();
1210       close (fd);
1211       xfree (fname);
1212       return err;
1213     }
1214
1215   xfree (fname);
1216
1217   *r_fd = fd;
1218   return 0;
1219 #else /*!HAVE_INOTIFY_INIT*/
1220
1221   (void)socket_name;
1222   *r_fd = -1;
1223   return my_error (GPG_ERR_NOT_SUPPORTED);
1224
1225 #endif /*!HAVE_INOTIFY_INIT*/
1226 }
1227
1228
1229 /* Read an inotify event and return true if it matches NAME or if it
1230  * sees an IN_DELETE_SELF event for the directory of NAME.  */
1231 int
1232 gnupg_inotify_has_name (int fd, const char *name)
1233 {
1234 #if USE_NPTH && HAVE_INOTIFY_INIT
1235 #define BUFSIZE_FOR_INOTIFY (sizeof (struct inotify_event) + 255 + 1)
1236   union {
1237     struct inotify_event ev;
1238     char _buf[sizeof (struct inotify_event) + 255 + 1];
1239   } buf;
1240   struct inotify_event *evp;
1241   int n;
1242
1243   n = npth_read (fd, &buf, sizeof buf);
1244   /* log_debug ("notify read: n=%d\n", n); */
1245   evp = &buf.ev;
1246   while (n >= sizeof (struct inotify_event))
1247     {
1248       /* log_debug ("             mask=%x len=%u name=(%s)\n", */
1249       /*        evp->mask, (unsigned int)evp->len, evp->len? evp->name:""); */
1250       if ((evp->mask & IN_UNMOUNT))
1251         {
1252           /* log_debug ("             found (dir unmounted)\n"); */
1253           return 3; /* Directory was unmounted.  */
1254         }
1255       if ((evp->mask & IN_DELETE_SELF))
1256         {
1257           /* log_debug ("             found (dir removed)\n"); */
1258           return 2; /* Directory was removed.  */
1259         }
1260       if ((evp->mask & IN_DELETE))
1261         {
1262           if (evp->len >= strlen (name) && !strcmp (evp->name, name))
1263             {
1264               /* log_debug ("             found (file removed)\n"); */
1265               return 1; /* File was removed.  */
1266             }
1267         }
1268       n -= sizeof (*evp) + evp->len;
1269       evp = (struct inotify_event *)(void *)
1270         ((char *)evp + sizeof (*evp) + evp->len);
1271     }
1272
1273 #else /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1274
1275   (void)fd;
1276   (void)name;
1277
1278 #endif  /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1279
1280   return 0; /* Not found.  */
1281 }
1282
1283
1284 /* Return a malloc'ed string that is the path to the passed
1285  * unix-domain socket (or return NULL if this is not a valid
1286  * unix-domain socket).  We use a plain int here because it is only
1287  * used on Linux.
1288  *
1289  * FIXME: This function needs to be moved to libassuan.  */
1290 #ifndef HAVE_W32_SYSTEM
1291 char *
1292 gnupg_get_socket_name (int fd)
1293 {
1294   struct sockaddr_un un;
1295   socklen_t len = sizeof(un);
1296   char *name = NULL;
1297
1298   if (getsockname (fd, (struct sockaddr*)&un, &len) != 0)
1299     log_error ("could not getsockname(%d): %s\n", fd,
1300                gpg_strerror (my_error_from_syserror ()));
1301   else if (un.sun_family != AF_UNIX)
1302     log_error ("file descriptor %d is not a unix-domain socket\n", fd);
1303   else if (len <= offsetof (struct sockaddr_un, sun_path))
1304     log_error ("socket name not present for file descriptor %d\n", fd);
1305   else if (len > sizeof(un))
1306     log_error ("socket name for file descriptor %d was truncated "
1307                "(passed %zu bytes, wanted %u)\n", fd, sizeof(un), len);
1308   else
1309     {
1310       size_t namelen = len - offsetof (struct sockaddr_un, sun_path);
1311
1312       /* log_debug ("file descriptor %d has path %s (%zu octets)\n", fd, */
1313       /*            un.sun_path, namelen); */
1314       name = xtrymalloc (namelen + 1);
1315       if (!name)
1316         log_error ("failed to allocate memory for name of fd %d: %s\n",
1317                    fd, gpg_strerror (my_error_from_syserror ()));
1318       else
1319         {
1320           memcpy (name, un.sun_path, namelen);
1321           name[namelen] = 0;
1322         }
1323     }
1324
1325   return name;
1326 }
1327 #endif /*!HAVE_W32_SYSTEM*/
1328
1329 /* Check whether FD is valid.  */
1330 int
1331 gnupg_fd_valid (int fd)
1332 {
1333   int d = dup (fd);
1334   if (d < 0)
1335     return 0;
1336   close (d);
1337   return 1;
1338 }