src/OS/os.c-cygwin

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Cygwin-specific code. December 2002. Updated Jan 2015.
   6    This is prefixed to the src/os.c file.
   7
   8    This code was supplied by Pierre A. Humblet <Pierre.Humblet@ieee.org>
   9 */
  10
  11 /* We need a special mkdir that
  12    allows names starting with // */
  13 #undef mkdir
  14 int cygwin_mkdir( const char *path, mode_t mode )
  15 {
  16   const char * p = path;
  17   if (*p == '/') while(*(p+1) == '/') p++;
  18   return mkdir(p, mode);
  19 }
  20
  21 #ifndef COMPILE_UTILITY /* Utilities don't need special code */
  22
  23 #ifdef INCLUDE_PAM
  24 #include "../pam/pam.c"
  25 #endif
  26 #include <alloca.h>
  27
  28 unsigned int cygwin_WinVersion;
  29
  30 /* Conflict between Windows definitions and others */
  31 #ifdef NOERROR
  32 #undef NOERROR
  33 #endif
  34 #ifdef DELETE
  35 #undef DELETE
  36 #endif
  37
  38 #include <windows.h>
  39 #include <ntstatus.h>
  40 #include <lmcons.h>
  41
  42 #define EqualLuid(Luid1, Luid2) \
  43   ((Luid1.LowPart == Luid2.LowPart) && (Luid1.HighPart == Luid2.HighPart))
  44 #include <sys/cygwin.h>
  45
  46 /* Special static variables */
  47 static BOOL cygwin_debug = FALSE;
  48 static int fakesetugid = 1; /* when not privileged, setugid = noop */
  49
  50 #undef setuid
  51 int cygwin_setuid(uid_t uid )
  52 {
  53   int res = 0;
  54   if (fakesetugid == 0) {
  55     res = setuid(uid);
  56     if (cygwin_debug)
  57       fprintf(stderr, "setuid %u %u %d pid: %d\n",
  58               uid, getuid(),res, getpid());
  59   }
  60   return res;
  61 }
  62
  63 #undef setgid
  64 int cygwin_setgid(gid_t gid )
  65 {
  66   int res = 0;
  67   if (fakesetugid == 0) {
  68     res = setgid(gid);
  69     if (cygwin_debug)
  70       fprintf(stderr, "setgid %u %u %d pid: %d\n",
  71               gid, getgid(), res, getpid());
  72   }
  73   return res;
  74 }
  75
  76 /* Background processes run at lower priority */
  77 static void cygwin_setpriority()
  78 {
  79   if (!SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS))
  80     SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
  81   return;
  82 }
  83
  84
  85 /* GetVersion()
  86    MSB: 1 for 95/98/ME; Next 7: build number, except for 95/98/ME
  87    Next byte: 0
  88    Next byte: minor version of OS
  89    Low  byte: major version of OS (3 or 4 for for NT, 5 for 2000 and XP) */
  90 //#define VERSION_IS_58M(x) (x & 0x80000000) /* 95, 98, Me   */
  91 //#define VERSION_IS_NT(x)  ((x & 0XFF) < 5) /* NT 4 or 3.51 */
  92
  93 /*
  94   Routine to find if process or thread is privileged
  95 */
  96
  97 enum {
  98   CREATE_BIT = 1,
  99 };
 100
 101 static DWORD get_privileges ()
 102 {
 103   char buffer[1024];
 104   DWORD i, length;
 105   HANDLE hToken = NULL;
 106   PTOKEN_PRIVILEGES privs;
 107   LUID cluid, rluid;
 108   DWORD ret = 0;
 109
 110   privs = (PTOKEN_PRIVILEGES) buffer;
 111
 112   if (OpenProcessToken (GetCurrentProcess(), TOKEN_QUERY, &hToken)
 113       && LookupPrivilegeValue (NULL, SE_CREATE_TOKEN_NAME, &cluid)
 114       && LookupPrivilegeValue(NULL, SE_RESTORE_NAME, &rluid)
 115       && (GetTokenInformation( hToken, TokenPrivileges,
 116                                privs, sizeof (buffer), &length)
 117           || (GetLastError () == ERROR_INSUFFICIENT_BUFFER
 118               && (privs = (PTOKEN_PRIVILEGES) alloca (length))
 119               && GetTokenInformation(hToken, TokenPrivileges,
 120                                      privs, length, &length)))) {
 121     for (i = 0; i < privs->PrivilegeCount; i++) {
 122       if (EqualLuid(privs->Privileges[i].Luid, cluid))
 123         ret |= CREATE_BIT;
 124       if (ret == (CREATE_BIT))
 125         break;
 126     }
 127   }
 128   else
 129     fprintf(stderr, "has_create_token_privilege %u\n", GetLastError());
 130
 131   if (hToken)
 132     CloseHandle(hToken);
 133
 134   return ret;
 135 }
 136
 137 /*
 138   We use cygwin_premain to fake a few things
 139         and to provide some debug info
 140 */
 141 void cygwin_premain2(int argc, char ** argv, struct per_process * ptr)
 142 {
 143   int i, res, is_daemon = 0, is_spoolwritable, is_privileged, is_eximuser;
 144   uid_t myuid, systemuid;
 145   gid_t mygid, adminsgid;
 146   struct passwd * pwp = NULL;
 147   struct stat buf;
 148   char *cygenv;
 149   SID(1, SystemSid, SECURITY_LOCAL_SYSTEM_RID);
 150   SID(2, AdminsSid, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS);
 151   DWORD priv_flags;
 152
 153   myuid = getuid();
 154   mygid = getgid();
 155   cygwin_WinVersion = GetVersion();
 156   if ((cygenv = getenv("CYGWIN")) == NULL) cygenv = "";
 157   /* Produce some debugging on stderr,
 158      cannot yet use exim's debug functions.
 159      Exim does not use -c and ignores -n.
 160      Set lower priority for daemons */
 161   for (i = 1; i < argc; i++) {
 162     if (argv[i][0] == '-') {
 163       if (argv[i][1] == 'c') {
 164         ssize_t size;
 165         wchar_t *win32_path;
 166         argv[i][1] = 'n';  /* Replace -c by -n */
 167         cygwin_debug = TRUE;
 168         fprintf(stderr, "CYGWIN = \"%s\".\n", cygenv);
 169         if (((size = cygwin_conv_path(CCP_POSIX_TO_WIN_W,"/", win32_path, 0)) > 0)
 170          && ((win32_path = malloc(size)) != NULL)
 171          && (cygwin_conv_path(CCP_POSIX_TO_WIN_W,"/", win32_path, size) == 0)) {
 172                 fprintf(stderr, " Root / mapped to %ls.\n", win32_path);
 173                 free(win32_path);
 174         }
 175       }
 176       else if (argv[i][1] == 'b' && argv[i][2] == 'd') {
 177         is_daemon = 1;
 178         cygwin_setpriority();
 179     }
 180   }
 181   }
 182
 183   /* Nt/2000/XP
 184      We initially set the exim uid & gid to those of the "exim user",
 185        or to the root uid (SYSTEM) and exim gid (ADMINS),
 186      If privileged, we setuid to those.
 187      We always set the configure uid to the system uid.
 188      We always set the root uid to the real uid
 189        to allow exim imposed restrictions (bypassable by recompiling)
 190        and to avoid exec that cause loss of privilege
 191      If not privileged and unable to chown,
 192        we set the exim uid to our uid.
 193      If unprivileged and /var/spool/exim is writable and not running as listening daemon,
 194        we fake all subsequent setuid. */
 195
 196   /* Get the system and admins uid from their sids */
 197   if ((systemuid = cygwin_internal(CW_GET_UID_FROM_SID, & SystemSid)) == -1) {
 198         fprintf(stderr, "Cannot map System sid. Aborting\n");
 199         exit(1);
 200   }
 201   if ((adminsgid = cygwin_internal(CW_GET_GID_FROM_SID, & AdminsSid)) == -1) {
 202         fprintf(stderr, "Cannot map Admins sid. Aborting\n");
 203         exit(1);
 204   }
 205
 206   priv_flags = get_privileges ();
 207   is_privileged = !!(priv_flags & CREATE_BIT);
 208
 209   /* Call getpwnam for account exim after getting the local exim name */
 210   char exim_username[DNLEN + UNLEN + 2];
 211   if (cygwin_internal(CW_CYGNAME_FROM_WINNAME, "exim", exim_username, sizeof exim_username) != 0)
 212      pwp = getpwnam (exim_username);
 213
 214   /* If cannot setuid to exim or and is not the daemon (which is assumed to be
 215      able to chown or to be the exim user) set the exim ugid to our ugid to avoid
 216      chown failures after creating files and to be able to setuid to exim in
 217      exim.c ( "privilege not needed" ). */
 218   if ((is_privileged == 0) && (!is_daemon)) {
 219     exim_uid = myuid;
 220     exim_gid = mygid;
 221   }
 222   else if (pwp != NULL) {
 223     exim_uid = pwp->pw_uid;  /* Set it according to passwd */
 224     exim_gid = pwp->pw_gid;
 225     is_eximuser = 1;
 226   }
 227   else {
 228     exim_uid = systemuid;
 229     exim_gid = adminsgid;
 230     is_eximuser = 0;
 231   }
 232
 233   res = stat("/var/spool/exim", &buf);
 234   /* Check if writable (and can be stat) */
 235   is_spoolwritable = ((res == 0) && ((buf.st_mode & S_IWOTH) != 0));
 236
 237   fakesetugid = (is_privileged == 0) && (is_daemon == 0) && (is_spoolwritable == 1);
 238
 239   if (is_privileged) {             /* Can setuid */
 240      if (cygwin_setgid(exim_gid) /* Setuid to exim */
 241          || cygwin_setuid(exim_uid)) {
 242            fprintf(stderr, "Unable to setuid/gid to exim. priv_flags: %x\n", priv_flags);
 243            exit(0);          /* Problem... Perhaps not in 544 */
 244      }
 245   }
 246
 247   /* Set the configuration file uid and gid to the system uid and admins gid. */
 248   config_uid = systemuid;
 249   config_gid = adminsgid;
 250
 251   /* Pretend we are root to avoid useless exec
 252      and avoid exim set limitations.
 253      We are limited by file access rights */
 254   root_uid = getuid ();
 255
 256   if (cygwin_debug) {
 257     fprintf(stderr, "Starting uid %u, gid %u, priv_flags %x, is_privileged %d, is_daemon %d, is_spoolwritable %d.\n",
 258             myuid, mygid, priv_flags, is_privileged, is_daemon, is_spoolwritable);
 259     fprintf(stderr, "root_uid %u, exim_uid %u, exim_gid %u, config_uid %u, config_gid %u, is_eximuser %d.\n",
 260             root_uid, exim_uid, exim_gid, config_uid, config_gid, is_eximuser);
 261   }
 262   return;
 263 }
 264
 265 #ifndef OS_LOAD_AVERAGE /* Can be set on command line */
 266 #define OS_LOAD_AVERAGE /* src/os.c need not provide it */
 267
 268 /*****************************************************************
 269  Functions for average load measurements
 270
 271  Uses NtQuerySystemInformation.
 272  This requires definitions that are not part of
 273  standard include files.
 274
 275  This is discouraged starting with WinXP.
 276
 277 *************************************************************/
 278 /* Structure to compute the load average efficiently */
 279 typedef struct {
 280   DWORD Lock;
 281   unsigned long long Time100ns;   /* Last measurement time */
 282   unsigned long long IdleCount;   /* Latest cumulative idle time */
 283   unsigned long long LastCounter; /* Last measurement counter */
 284   unsigned long long PerfFreq;    /* Perf counter frequency */
 285   int LastLoad;                   /* Last reported load, or -1 */
 286 } cygwin_perf_t;
 287
 288 static struct {
 289    HANDLE handle;
 290    pid_t pid;
 291    cygwin_perf_t *perf;
 292 } cygwin_load = {NULL, 0, NULL};
 293
 294 #include <ntdef.h>
 295
 296 typedef enum _SYSTEM_INFORMATION_CLASS
 297 {
 298   SystemBasicInformation = 0,
 299   SystemPerformanceInformation = 2,
 300   SystemTimeOfDayInformation = 3,
 301   SystemProcessesAndThreadsInformation = 5,
 302   SystemProcessorTimes = 8,
 303   SystemPagefileInformation = 18,
 304   /* There are a lot more of these... */
 305 } SYSTEM_INFORMATION_CLASS;
 306
 307 typedef struct _SYSTEM_BASIC_INFORMATION
 308 {
 309   ULONG Unknown;
 310   ULONG MaximumIncrement;
 311   ULONG PhysicalPageSize;
 312   ULONG NumberOfPhysicalPages;
 313   ULONG LowestPhysicalPage;
 314   ULONG HighestPhysicalPage;
 315   ULONG AllocationGranularity;
 316   ULONG LowestUserAddress;
 317   ULONG HighestUserAddress;
 318   ULONG ActiveProcessors;
 319   UCHAR NumberProcessors;
 320 } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
 321
 322 typedef struct __attribute__ ((aligned (8))) _SYSTEM_PROCESSOR_TIMES
 323 {
 324   LARGE_INTEGER IdleTime;
 325   LARGE_INTEGER KernelTime;
 326   LARGE_INTEGER UserTime;
 327   LARGE_INTEGER DpcTime;
 328   LARGE_INTEGER InterruptTime;
 329   ULONG InterruptCount;
 330 } SYSTEM_PROCESSOR_TIMES, *PSYSTEM_PROCESSOR_TIMES;
 331
 332 typedef NTSTATUS NTAPI (*NtQuerySystemInformation_t) (SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG);
 333 typedef ULONG NTAPI (*RtlNtStatusToDosError_t) (NTSTATUS);
 334
 335 static NtQuerySystemInformation_t NtQuerySystemInformation;
 336 static RtlNtStatusToDosError_t RtlNtStatusToDosError;
 337
 338 /*****************************************************************
 339  *
 340  LoadNtdll()
 341  Load special functions from the NTDLL
 342  Return TRUE if success.
 343
 344  *****************************************************************/
 345
 346 static BOOL LoadNtdll()
 347 {
 348   HINSTANCE hinstLib;
 349
 350   if ((hinstLib = LoadLibrary("NTDLL.DLL"))
 351       && (NtQuerySystemInformation =
 352           (NtQuerySystemInformation_t) GetProcAddress(hinstLib,
 353                                                         "NtQuerySystemInformation"))
 354       && (RtlNtStatusToDosError =
 355           (RtlNtStatusToDosError_t) GetProcAddress(hinstLib,
 356                                                      "RtlNtStatusToDosError")))
 357     return TRUE;
 358
 359   DEBUG(D_load)
 360     debug_printf("perf: load: %u (Windows)\n", GetLastError());
 361   return FALSE;
 362 }
 363 /*****************************************************************
 364  *
 365  ReadStat()
 366  Measures current Time100ns and IdleCount
 367  Return TRUE if success.
 368
 369  *****************************************************************/
 370
 371 static BOOL ReadStat(unsigned long long int *Time100nsPtr,
 372                      unsigned long long int *IdleCountPtr)
 373 {
 374   NTSTATUS ret;
 375   SYSTEM_BASIC_INFORMATION sbi;
 376   PSYSTEM_PROCESSOR_TIMES spt;
 377
 378   *Time100nsPtr = *IdleCountPtr = 0;
 379
 380   if ((ret = NtQuerySystemInformation(SystemBasicInformation,
 381                                       (PVOID) &sbi, sizeof sbi, NULL))
 382       != STATUS_SUCCESS) {
 383     DEBUG(D_load)
 384       debug_printf("Perf: NtQuerySystemInformation: %u (Windows)\n",
 385                    RtlNtStatusToDosError(ret));
 386   }
 387   else if (!(spt = (PSYSTEM_PROCESSOR_TIMES) alloca(sizeof(spt[0]) * sbi.NumberProcessors))) {
 388     DEBUG(D_load)
 389       debug_printf("Perf: alloca: errno %d (%s)\n", errno, strerror(errno));
 390   }
 391   else if ((ret = NtQuerySystemInformation(SystemProcessorTimes, (PVOID) spt,
 392                                            sizeof spt[0] * sbi.NumberProcessors, NULL))
 393            != STATUS_SUCCESS) {
 394     DEBUG(D_load)
 395       debug_printf("Perf: NtQuerySystemInformation: %u (Windows)\n",
 396                    RtlNtStatusToDosError(ret));
 397   }
 398   else {
 399     int i;
 400     for (i = 0; i < sbi.NumberProcessors; i++) {
 401       *Time100nsPtr += spt[i].KernelTime.QuadPart;;
 402       *Time100nsPtr += spt[i].UserTime.QuadPart;
 403       *IdleCountPtr += spt[i].IdleTime.QuadPart;
 404     }
 405     return TRUE;
 406   }
 407   return FALSE;
 408 }
 409
 410 /*****************************************************************
 411  *
 412  InitLoadAvg()
 413  Initialize the cygwin_load.perf structure.
 414  and set cygwin_load.perf->Flag to TRUE if successful.
 415  This is called the first time os_getloadavg is called
 416  *****************************************************************/
 417 static void InitLoadAvg(cygwin_perf_t *this)
 418 {
 419   BOOL success = TRUE;
 420
 421   /* Get perf frequency and counter */
 422   QueryPerformanceFrequency((LARGE_INTEGER *)& this->PerfFreq);
 423   QueryPerformanceCounter((LARGE_INTEGER *)& this->LastCounter);
 424
 425   /* Get initial values for Time100ns and IdleCount */
 426   success = success
 427             && ReadStat( & this->Time100ns,
 428                          & this->IdleCount);
 429   /* If success, set the Load to 0, else to -1 */
 430   if (success) this->LastLoad = 0;
 431   else {
 432     log_write(0, LOG_MAIN, "Cannot obtain Load Average");
 433     this->LastLoad = -1;
 434   }
 435 }
 436
 437
 438 /*****************************************************************
 439  *
 440  os_getloadavg()
 441
 442  Return -1 if not available;
 443  Return the previous value if less than AVERAGING sec old.
 444  else return the processor load on a [0 - 1000] scale.
 445
 446  The first time we are called we initialize the counts
 447  and return 0 or -1.
 448  The initial load cannot be measured as we use the processor 100%
 449 *****************************************************************/
 450 static SECURITY_ATTRIBUTES sa = {sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
 451 #define AVERAGING 10
 452
 453 int os_getloadavg()
 454 {
 455   unsigned long long Time100ns, IdleCount, CurrCounter;
 456   int value;
 457   pid_t newpid;
 458
 459   /* New process.
 460      Reload the dlls and the file mapping */
 461   if ((newpid = getpid()) != cygwin_load.pid) {
 462     BOOL new;
 463     cygwin_load.pid = newpid;
 464
 465     if (!LoadNtdll()) {
 466       log_write(0, LOG_MAIN, "Cannot obtain Load Average");
 467       cygwin_load.perf = NULL;
 468       return -1;
 469     }
 470
 471     if ((new = !cygwin_load.handle)) {
 472       cygwin_load.handle = CreateFileMapping (INVALID_HANDLE_VALUE, &sa, PAGE_READWRITE,
 473                                               0, sizeof(cygwin_perf_t), NULL);
 474       DEBUG(D_load)
 475         debug_printf("Perf: CreateFileMapping: handle %p\n", (void *) cygwin_load.handle);
 476     }
 477     cygwin_load.perf = (cygwin_perf_t *) MapViewOfFile (cygwin_load.handle,
 478                                                         FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
 479     DEBUG(D_load)
 480       debug_printf("Perf: MapViewOfFile: addr %p\n", (void *) cygwin_load.perf);
 481     if (new && cygwin_load.perf)
 482       InitLoadAvg(cygwin_load.perf);
 483   }
 484
 485   /* Check if initialized OK */
 486   if (!cygwin_load.perf || cygwin_load.perf->LastLoad < 0)
 487     return -1;
 488
 489   /* If we cannot get the lock, we return 0.
 490      This is to prevent any lock-up possibility.
 491      Finding a lock busy is unlikely, and giving up only
 492      results in an immediate delivery .*/
 493
 494   if (InterlockedCompareExchange(&cygwin_load.perf->Lock, 1, 0)) {
 495     DEBUG(D_load)
 496       debug_printf("Perf: Lock busy\n");
 497     return 0;
 498   }
 499
 500     /* Get the current time (PerfCounter) */
 501     QueryPerformanceCounter((LARGE_INTEGER *)& CurrCounter);
 502     /* Calls closer than AVERAGING sec apart use the previous value */
 503   if (CurrCounter - cygwin_load.perf->LastCounter >
 504       AVERAGING * cygwin_load.perf->PerfFreq) {
 505       /* Get Time100ns and IdleCount */
 506       if (ReadStat( & Time100ns, & IdleCount)) { /* Success */
 507         /* Return processor load on 1000 scale */
 508       value = 1000 - ((1000 * (IdleCount - cygwin_load.perf->IdleCount)) /
 509                       (Time100ns - cygwin_load.perf->Time100ns));
 510       cygwin_load.perf->Time100ns = Time100ns;
 511       cygwin_load.perf->IdleCount = IdleCount;
 512       cygwin_load.perf->LastCounter = CurrCounter;
 513       cygwin_load.perf->LastLoad = value;
 514       DEBUG(D_load)
 515         debug_printf("Perf: New load average %d\n", value);
 516       }
 517       else { /* Something bad happened.
 518                 Refuse to measure the load anymore
 519                 but don't bother releasing the buffer */
 520         log_write(0, LOG_MAIN, "Cannot obtain Load Average");
 521       cygwin_load.perf->LastLoad = -1;
 522     }
 523   }
 524   else
 525   DEBUG(D_load)
 526       debug_printf("Perf: Old load average %d\n", cygwin_load.perf->LastLoad);
 527   cygwin_load.perf->Lock = 0;
 528   return cygwin_load.perf->LastLoad;
 529 }
 530 #endif /* OS_LOAD_AVERAGE */
 531 #endif /* COMPILE_UTILITY */