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