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 simple wrapper around chdir.  NAME is expected to be utf8
 800  * encoded.  */
 801 int
 802 gnupg_chdir (const char *name)
 803 {
 804   return chdir (name);
 805 }
 806
 807
 808 /* A wrapper around chmod which takes a string for the mode argument.
 809    This makes it easier to handle the mode argument which is not
 810    defined on all systems.  The format of the modestring is the same
 811    as for gnupg_mkdir.  */
 812 int
 813 gnupg_chmod (const char *name, const char *modestr)
 814 {
 815 #ifdef HAVE_W32_SYSTEM
 816   (void)name;
 817   (void)modestr;
 818   return 0;
 819 #else
 820   return chmod (name, modestr_to_mode (modestr));
 821 #endif
 822 }
 823
 824
 825 /* Our version of mkdtemp.  The API is identical to POSIX.1-2008
 826    version.  We do not use a system provided mkdtemp because we have a
 827    good RNG instantly available and this way we don't have diverging
 828    versions.  */
 829 char *
 830 gnupg_mkdtemp (char *tmpl)
 831 {
 832   /* A lower bound on the number of temporary files to attempt to
 833      generate.  The maximum total number of temporary file names that
 834      can exist for a given template is 62**6 (5*36**3 for Windows).
 835      It should never be necessary to try all these combinations.
 836      Instead if a reasonable number of names is tried (we define
 837      reasonable as 62**3 or 5*36**3) fail to give the system
 838      administrator the chance to remove the problems.  */
 839 #ifdef HAVE_W32_SYSTEM
 840   static const char letters[] =
 841     "abcdefghijklmnopqrstuvwxyz0123456789";
 842 # define NUMBER_OF_LETTERS 36
 843 # define ATTEMPTS_MIN (5 * 36 * 36 * 36)
 844 #else
 845   static const char letters[] =
 846     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 847 # define NUMBER_OF_LETTERS 62
 848 # define ATTEMPTS_MIN (62 * 62 * 62)
 849 #endif
 850   int len;
 851   char *XXXXXX;
 852   uint64_t value;
 853   unsigned int count;
 854   int save_errno = errno;
 855   /* The number of times to attempt to generate a temporary file.  To
 856      conform to POSIX, this must be no smaller than TMP_MAX.  */
 857 #if ATTEMPTS_MIN < TMP_MAX
 858   unsigned int attempts = TMP_MAX;
 859 #else
 860   unsigned int attempts = ATTEMPTS_MIN;
 861 #endif
 862
 863   len = strlen (tmpl);
 864   if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
 865     {
 866       gpg_err_set_errno (EINVAL);
 867       return NULL;
 868     }
 869
 870   /* This is where the Xs start.  */
 871   XXXXXX = &tmpl[len - 6];
 872
 873   /* Get a random start value.  */
 874   gcry_create_nonce (&value, sizeof value);
 875
 876   /* Loop until a directory was created.  */
 877   for (count = 0; count < attempts; value += 7777, ++count)
 878     {
 879       uint64_t v = value;
 880
 881       /* Fill in the random bits.  */
 882       XXXXXX[0] = letters[v % NUMBER_OF_LETTERS];
 883       v /= NUMBER_OF_LETTERS;
 884       XXXXXX[1] = letters[v % NUMBER_OF_LETTERS];
 885       v /= NUMBER_OF_LETTERS;
 886       XXXXXX[2] = letters[v % NUMBER_OF_LETTERS];
 887       v /= NUMBER_OF_LETTERS;
 888       XXXXXX[3] = letters[v % NUMBER_OF_LETTERS];
 889       v /= NUMBER_OF_LETTERS;
 890       XXXXXX[4] = letters[v % NUMBER_OF_LETTERS];
 891       v /= NUMBER_OF_LETTERS;
 892       XXXXXX[5] = letters[v % NUMBER_OF_LETTERS];
 893
 894       if (!gnupg_mkdir (tmpl, "-rwx"))
 895         {
 896           gpg_err_set_errno (save_errno);
 897           return tmpl;
 898         }
 899       if (errno != EEXIST)
 900         return NULL;
 901     }
 902
 903   /* We got out of the loop because we ran out of combinations to try.  */
 904   gpg_err_set_errno (EEXIST);
 905   return NULL;
 906 }
 907
 908
 909 int
 910 gnupg_setenv (const char *name, const char *value, int overwrite)
 911 {
 912 #ifdef HAVE_W32CE_SYSTEM
 913   (void)name;
 914   (void)value;
 915   (void)overwrite;
 916   return 0;
 917 #else /*!W32CE*/
 918 # ifdef HAVE_W32_SYSTEM
 919   /*  Windows maintains (at least) two sets of environment variables.
 920       One set can be accessed by GetEnvironmentVariable and
 921       SetEnvironmentVariable.  This set is inherited by the children.
 922       The other set is maintained in the C runtime, and is accessed
 923       using getenv and putenv.  We try to keep them in sync by
 924       modifying both sets.  */
 925   {
 926     int exists;
 927     char tmpbuf[10];
 928     exists = GetEnvironmentVariable (name, tmpbuf, sizeof tmpbuf);
 929
 930     if ((! exists || overwrite) && !SetEnvironmentVariable (name, value))
 931       {
 932         gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
 933         return -1;
 934       }
 935   }
 936 # endif /*W32*/
 937
 938 # ifdef HAVE_SETENV
 939   return setenv (name, value, overwrite);
 940 # else /*!HAVE_SETENV*/
 941   if (! getenv (name) || overwrite)
 942     {
 943       char *buf;
 944
 945       (void)overwrite;
 946       if (!name || !value)
 947         {
 948           gpg_err_set_errno (EINVAL);
 949           return -1;
 950         }
 951       buf = strconcat (name, "=", value, NULL);
 952       if (!buf)
 953         return -1;
 954 # if __GNUC__
 955 #  warning no setenv - using putenv but leaking memory.
 956 # endif
 957       return putenv (buf);
 958     }
 959   return 0;
 960 # endif /*!HAVE_SETENV*/
 961 #endif /*!W32CE*/
 962 }
 963
 964
 965 int
 966 gnupg_unsetenv (const char *name)
 967 {
 968 #ifdef HAVE_W32CE_SYSTEM
 969   (void)name;
 970   return 0;
 971 #else /*!W32CE*/
 972 # ifdef HAVE_W32_SYSTEM
 973   /*  Windows maintains (at least) two sets of environment variables.
 974       One set can be accessed by GetEnvironmentVariable and
 975       SetEnvironmentVariable.  This set is inherited by the children.
 976       The other set is maintained in the C runtime, and is accessed
 977       using getenv and putenv.  We try to keep them in sync by
 978       modifying both sets.  */
 979   if (!SetEnvironmentVariable (name, NULL))
 980     {
 981       gpg_err_set_errno (EINVAL); /* (Might also be ENOMEM.) */
 982       return -1;
 983     }
 984 # endif /*W32*/
 985
 986 # ifdef HAVE_UNSETENV
 987   return unsetenv (name);
 988 # else /*!HAVE_UNSETENV*/
 989   {
 990     char *buf;
 991
 992     if (!name)
 993       {
 994         gpg_err_set_errno (EINVAL);
 995         return -1;
 996       }
 997     buf = xtrystrdup (name);
 998     if (!buf)
 999       return -1;
1000 #  if __GNUC__
1001 #   warning no unsetenv - trying putenv but leaking memory.
1002 #  endif
1003     return putenv (buf);
1004   }
1005 # endif /*!HAVE_UNSETENV*/
1006 #endif /*!W32CE*/
1007 }
1008
1009
1010 /* Return the current working directory as a malloced string.  Return
1011    NULL and sets ERRNo on error.  */
1012 char *
1013 gnupg_getcwd (void)
1014 {
1015   char *buffer;
1016   size_t size = 100;
1017
1018   for (;;)
1019     {
1020       buffer = xtrymalloc (size+1);
1021       if (!buffer)
1022         return NULL;
1023 #ifdef HAVE_W32CE_SYSTEM
1024       strcpy (buffer, "/");  /* Always "/".  */
1025       return buffer;
1026 #else
1027       if (getcwd (buffer, size) == buffer)
1028         return buffer;
1029       xfree (buffer);
1030       if (errno != ERANGE)
1031         return NULL;
1032       size *= 2;
1033 #endif
1034     }
1035 }
1036
1037
1038 \f
1039 #ifdef HAVE_W32CE_SYSTEM
1040 /* There is a isatty function declaration in cegcc but it does not
1041    make sense, thus we redefine it.  */
1042 int
1043 _gnupg_isatty (int fd)
1044 {
1045   (void)fd;
1046   return 0;
1047 }
1048 #endif
1049
1050
1051 #ifdef HAVE_W32CE_SYSTEM
1052 /* Replacement for getenv which takes care of the our use of getenv.
1053    The code is not thread safe but we expect it to work in all cases
1054    because it is called for the first time early enough.  */
1055 char *
1056 _gnupg_getenv (const char *name)
1057 {
1058   static int initialized;
1059   static char *assuan_debug;
1060
1061   if (!initialized)
1062     {
1063       assuan_debug = read_w32_registry_string (NULL,
1064                                                "\\Software\\GNU\\libassuan",
1065                                                "debug");
1066       initialized = 1;
1067     }
1068
1069   if (!strcmp (name, "ASSUAN_DEBUG"))
1070     return assuan_debug;
1071   else
1072     return NULL;
1073 }
1074
1075 #endif /*HAVE_W32CE_SYSTEM*/
1076
1077
1078 #ifdef HAVE_W32_SYSTEM
1079 /* Return the user's security identifier from the current process.  */
1080 PSID
1081 w32_get_user_sid (void)
1082 {
1083   int okay = 0;
1084   HANDLE proc = NULL;
1085   HANDLE token = NULL;
1086   TOKEN_USER *user = NULL;
1087   PSID sid = NULL;
1088   DWORD tokenlen, sidlen;
1089
1090   proc = OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
1091   if (!proc)
1092     goto leave;
1093
1094   if (!OpenProcessToken (proc, TOKEN_QUERY, &token))
1095     goto leave;
1096
1097   if (!GetTokenInformation (token, TokenUser, NULL, 0, &tokenlen)
1098       && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1099     goto leave;
1100
1101   user = xtrymalloc (tokenlen);
1102   if (!user)
1103     goto leave;
1104
1105   if (!GetTokenInformation (token, TokenUser, user, tokenlen, &tokenlen))
1106     goto leave;
1107   if (!IsValidSid (user->User.Sid))
1108     goto leave;
1109   sidlen = GetLengthSid (user->User.Sid);
1110   sid = xtrymalloc (sidlen);
1111   if (!sid)
1112     goto leave;
1113   if (!CopySid (sidlen, sid, user->User.Sid))
1114     goto leave;
1115   okay = 1;
1116
1117  leave:
1118   xfree (user);
1119   if (token)
1120     CloseHandle (token);
1121   if (proc)
1122     CloseHandle (proc);
1123
1124   if (!okay)
1125     {
1126       xfree (sid);
1127       sid = NULL;
1128     }
1129   return sid;
1130 }
1131 #endif /*HAVE_W32_SYSTEM*/
1132
1133
1134 \f
1135 /* Support for inotify under Linux.  */
1136
1137 /* Store a new inotify file handle for FNAME at R_FD or return an
1138  * error code.  This file descriptor watch the removal of FNAME. */
1139 gpg_error_t
1140 gnupg_inotify_watch_delete_self (int *r_fd, const char *fname)
1141 {
1142 #if HAVE_INOTIFY_INIT
1143   gpg_error_t err;
1144   int fd;
1145
1146   *r_fd = -1;
1147
1148   if (!fname)
1149     return my_error (GPG_ERR_INV_VALUE);
1150
1151   fd = inotify_init ();
1152   if (fd == -1)
1153     return my_error_from_syserror ();
1154
1155   if (inotify_add_watch (fd, fname, IN_DELETE_SELF) == -1)
1156     {
1157       err = my_error_from_syserror ();
1158       close (fd);
1159       return err;
1160     }
1161
1162   *r_fd = fd;
1163   return 0;
1164 #else /*!HAVE_INOTIFY_INIT*/
1165
1166   (void)fname;
1167   *r_fd = -1;
1168   return my_error (GPG_ERR_NOT_SUPPORTED);
1169
1170 #endif /*!HAVE_INOTIFY_INIT*/
1171 }
1172
1173
1174 /* Store a new inotify file handle for SOCKET_NAME at R_FD or return
1175  * an error code. */
1176 gpg_error_t
1177 gnupg_inotify_watch_socket (int *r_fd, const char *socket_name)
1178 {
1179 #if HAVE_INOTIFY_INIT
1180   gpg_error_t err;
1181   char *fname;
1182   int fd;
1183   char *p;
1184
1185   *r_fd = -1;
1186
1187   if (!socket_name)
1188     return my_error (GPG_ERR_INV_VALUE);
1189
1190   fname = xtrystrdup (socket_name);
1191   if (!fname)
1192     return my_error_from_syserror ();
1193
1194   fd = inotify_init ();
1195   if (fd == -1)
1196     {
1197       err = my_error_from_syserror ();
1198       xfree (fname);
1199       return err;
1200     }
1201
1202   /* We need to watch the directory for the file because there won't
1203    * be an IN_DELETE_SELF for a socket file.  To handle a removal of
1204    * the directory we also watch the directory itself. */
1205   p = strrchr (fname, '/');
1206   if (p)
1207     *p = 0;
1208   if (inotify_add_watch (fd, fname,
1209                          (IN_DELETE|IN_DELETE_SELF|IN_EXCL_UNLINK)) == -1)
1210     {
1211       err = my_error_from_syserror ();
1212       close (fd);
1213       xfree (fname);
1214       return err;
1215     }
1216
1217   xfree (fname);
1218
1219   *r_fd = fd;
1220   return 0;
1221 #else /*!HAVE_INOTIFY_INIT*/
1222
1223   (void)socket_name;
1224   *r_fd = -1;
1225   return my_error (GPG_ERR_NOT_SUPPORTED);
1226
1227 #endif /*!HAVE_INOTIFY_INIT*/
1228 }
1229
1230
1231 /* Read an inotify event and return true if it matches NAME or if it
1232  * sees an IN_DELETE_SELF event for the directory of NAME.  */
1233 int
1234 gnupg_inotify_has_name (int fd, const char *name)
1235 {
1236 #if USE_NPTH && HAVE_INOTIFY_INIT
1237 #define BUFSIZE_FOR_INOTIFY (sizeof (struct inotify_event) + 255 + 1)
1238   union {
1239     struct inotify_event ev;
1240     char _buf[sizeof (struct inotify_event) + 255 + 1];
1241   } buf;
1242   struct inotify_event *evp;
1243   int n;
1244
1245   n = npth_read (fd, &buf, sizeof buf);
1246   /* log_debug ("notify read: n=%d\n", n); */
1247   evp = &buf.ev;
1248   while (n >= sizeof (struct inotify_event))
1249     {
1250       /* log_debug ("             mask=%x len=%u name=(%s)\n", */
1251       /*        evp->mask, (unsigned int)evp->len, evp->len? evp->name:""); */
1252       if ((evp->mask & IN_UNMOUNT))
1253         {
1254           /* log_debug ("             found (dir unmounted)\n"); */
1255           return 3; /* Directory was unmounted.  */
1256         }
1257       if ((evp->mask & IN_DELETE_SELF))
1258         {
1259           /* log_debug ("             found (dir removed)\n"); */
1260           return 2; /* Directory was removed.  */
1261         }
1262       if ((evp->mask & IN_DELETE))
1263         {
1264           if (evp->len >= strlen (name) && !strcmp (evp->name, name))
1265             {
1266               /* log_debug ("             found (file removed)\n"); */
1267               return 1; /* File was removed.  */
1268             }
1269         }
1270       n -= sizeof (*evp) + evp->len;
1271       evp = (struct inotify_event *)(void *)
1272         ((char *)evp + sizeof (*evp) + evp->len);
1273     }
1274
1275 #else /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1276
1277   (void)fd;
1278   (void)name;
1279
1280 #endif  /*!(USE_NPTH && HAVE_INOTIFY_INIT)*/
1281
1282   return 0; /* Not found.  */
1283 }
1284
1285
1286 /* Return a malloc'ed string that is the path to the passed
1287  * unix-domain socket (or return NULL if this is not a valid
1288  * unix-domain socket).  We use a plain int here because it is only
1289  * used on Linux.
1290  *
1291  * FIXME: This function needs to be moved to libassuan.  */
1292 #ifndef HAVE_W32_SYSTEM
1293 char *
1294 gnupg_get_socket_name (int fd)
1295 {
1296   struct sockaddr_un un;
1297   socklen_t len = sizeof(un);
1298   char *name = NULL;
1299
1300   if (getsockname (fd, (struct sockaddr*)&un, &len) != 0)
1301     log_error ("could not getsockname(%d): %s\n", fd,
1302                gpg_strerror (my_error_from_syserror ()));
1303   else if (un.sun_family != AF_UNIX)
1304     log_error ("file descriptor %d is not a unix-domain socket\n", fd);
1305   else if (len <= offsetof (struct sockaddr_un, sun_path))
1306     log_error ("socket name not present for file descriptor %d\n", fd);
1307   else if (len > sizeof(un))
1308     log_error ("socket name for file descriptor %d was truncated "
1309                "(passed %zu bytes, wanted %u)\n", fd, sizeof(un), len);
1310   else
1311     {
1312       size_t namelen = len - offsetof (struct sockaddr_un, sun_path);
1313
1314       /* log_debug ("file descriptor %d has path %s (%zu octets)\n", fd, */
1315       /*            un.sun_path, namelen); */
1316       name = xtrymalloc (namelen + 1);
1317       if (!name)
1318         log_error ("failed to allocate memory for name of fd %d: %s\n",
1319                    fd, gpg_strerror (my_error_from_syserror ()));
1320       else
1321         {
1322           memcpy (name, un.sun_path, namelen);
1323           name[namelen] = 0;
1324         }
1325     }
1326
1327   return name;
1328 }
1329 #endif /*!HAVE_W32_SYSTEM*/
1330
1331 /* Check whether FD is valid.  */
1332 int
1333 gnupg_fd_valid (int fd)
1334 {
1335   int d = dup (fd);
1336   if (d < 0)
1337     return 0;
1338   close (d);
1339   return 1;
1340 }