[exim.git] / src / OS / os.c-cygwin

/*************************************************
*     Exim - an Internet mail transport agent    *
*************************************************/

/* Cygwin-specific code. December 2002. Updated Jan 2015.
   This is prefixed to the src/os.c file.

   This code was supplied by Pierre A. Humblet <Pierre.Humblet@ieee.org>
*/

/* We need a special mkdir that
   allows names starting with // */
#undef mkdir
int cygwin_mkdir( const char *path, mode_t mode )
{
  const char * p = path;
  if (*p == '/') while(*(p+1) == '/') p++;
  return mkdir(p, mode);
}

#ifndef COMPILE_UTILITY /* Utilities don't need special code */

#ifdef INCLUDE_PAM
#include "../pam/pam.c"
#endif
#include <alloca.h>

unsigned int cygwin_WinVersion;

/* Conflict between Windows definitions and others */
#ifdef NOERROR
#undef NOERROR
#endif
#ifdef DELETE
#undef DELETE
#endif

#include <windows.h>
#include <ntstatus.h>
#include <lmcons.h>

#define EqualLuid(Luid1, Luid2) \
  ((Luid1.LowPart == Luid2.LowPart) && (Luid1.HighPart == Luid2.HighPart))
#include <sys/cygwin.h>

/* Special static variables */
static BOOL cygwin_debug = FALSE;
static int fakesetugid = 1; /* when not privileged, setugid = noop */

#undef setuid
int cygwin_setuid(uid_t uid )
{
  int res = 0;
  if (fakesetugid == 0) { 
    res = setuid(uid);
    if (cygwin_debug)
      fprintf(stderr, "setuid %u %u %d pid: %d\n",
              uid, getuid(),res, getpid());
  }
  return res;
}

#undef setgid
int cygwin_setgid(gid_t gid )
{
  int res = 0;
  if (fakesetugid == 0) { 
    res = setgid(gid);
    if (cygwin_debug)
      fprintf(stderr, "setgid %u %u %d pid: %d\n",
              gid, getgid(), res, getpid());
  }
  return res;
}

/* Background processes run at lower priority */
static void cygwin_setpriority()
{
  if (!SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS))
    SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
  return;
}


/* GetVersion()
   MSB: 1 for 95/98/ME; Next 7: build number, except for 95/98/ME
   Next byte: 0
   Next byte: minor version of OS
   Low  byte: major version of OS (3 or 4 for for NT, 5 for 2000 and XP) */
//#define VERSION_IS_58M(x) (x & 0x80000000) /* 95, 98, Me   */
//#define VERSION_IS_NT(x)  ((x & 0XFF) < 5) /* NT 4 or 3.51 */

/*
  Routine to find if process or thread is privileged
*/

enum {
  CREATE_BIT = 1,
};

static DWORD get_privileges ()
{
  char buffer[1024];
  DWORD i, length;
  HANDLE hToken = NULL;
  PTOKEN_PRIVILEGES privs;
  LUID cluid, rluid;
  DWORD ret = 0;

  privs = (PTOKEN_PRIVILEGES) buffer;

  if (OpenProcessToken (GetCurrentProcess(), TOKEN_QUERY, &hToken)
      && LookupPrivilegeValue (NULL, SE_CREATE_TOKEN_NAME, &cluid)
      && LookupPrivilegeValue(NULL, SE_RESTORE_NAME, &rluid)
      && (GetTokenInformation( hToken, TokenPrivileges,
                               privs, sizeof (buffer), &length)
          || (GetLastError () == ERROR_INSUFFICIENT_BUFFER
              && (privs = (PTOKEN_PRIVILEGES) alloca (length))
              && GetTokenInformation(hToken, TokenPrivileges,
                                     privs, length, &length)))) {
    for (i = 0; i < privs->PrivilegeCount; i++) {
      if (EqualLuid(privs->Privileges[i].Luid, cluid))
        ret |= CREATE_BIT;
      if (ret == (CREATE_BIT))
        break;
    }
  }
  else
    fprintf(stderr, "has_create_token_privilege %u\n", GetLastError());

  if (hToken)
    CloseHandle(hToken);

  return ret;
}

/* 
  We use cygwin_premain to fake a few things 
	and to provide some debug info 
*/
void cygwin_premain2(int argc, char ** argv, struct per_process * ptr)
{
  int i, res, is_daemon = 0, is_spoolwritable, is_privileged, is_eximuser;
  uid_t myuid, systemuid;
  gid_t mygid, adminsgid;
  struct passwd * pwp = NULL;
  struct stat buf;
  char *cygenv;
  SID(1, SystemSid, SECURITY_LOCAL_SYSTEM_RID);
  SID(2, AdminsSid, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS);
  DWORD priv_flags;

  myuid = getuid();
  mygid = getgid();
  cygwin_WinVersion = GetVersion();
  if ((cygenv = getenv("CYGWIN")) == NULL) cygenv = "";
  /* Produce some debugging on stderr,
     cannot yet use exim's debug functions.
     Exim does not use -c and ignores -n.
     Set lower priority for daemons */
  for (i = 1; i < argc; i++) {
    if (argv[i][0] == '-') {
      if (argv[i][1] == 'c') {
        ssize_t size;
        wchar_t *win32_path;
        argv[i][1] = 'n';  /* Replace -c by -n */
        cygwin_debug = TRUE;
        fprintf(stderr, "CYGWIN = \"%s\".\n", cygenv);
        if (((size = cygwin_conv_path(CCP_POSIX_TO_WIN_W,"/", win32_path, 0)) > 0)
 	 && ((win32_path = malloc(size)) != NULL)
         && (cygwin_conv_path(CCP_POSIX_TO_WIN_W,"/", win32_path, size) == 0)) {
	        fprintf(stderr, " Root / mapped to %ls.\n", win32_path);
		free(win32_path);
	}
      }
      else if (argv[i][1] == 'b' && argv[i][2] == 'd') {
        is_daemon = 1;
        cygwin_setpriority();
    }
  }
  }

  /* Nt/2000/XP
     We initially set the exim uid & gid to those of the "exim user",
       or to the root uid (SYSTEM) and exim gid (ADMINS),
     If privileged, we setuid to those.
     We always set the configure uid to the system uid.
     We always set the root uid to the real uid
       to allow exim imposed restrictions (bypassable by recompiling)
       and to avoid exec that cause loss of privilege
     If not privileged and unable to chown,
       we set the exim uid to our uid.
     If unprivileged and /var/spool/exim is writable and not running as listening daemon, 
       we fake all subsequent setuid. */

  /* Get the system and admins uid from their sids */
  if ((systemuid = cygwin_internal(CW_GET_UID_FROM_SID, & SystemSid)) == -1) {
	fprintf(stderr, "Cannot map System sid. Aborting\n");
	exit(1);
  }
  if ((adminsgid = cygwin_internal(CW_GET_GID_FROM_SID, & AdminsSid)) == -1) {
	fprintf(stderr, "Cannot map Admins sid. Aborting\n");
	exit(1);
  }

  priv_flags = get_privileges ();
  is_privileged = !!(priv_flags & CREATE_BIT);

  /* Call getpwnam for account exim after getting the local exim name */
  char exim_username[DNLEN + UNLEN + 2];
  if (cygwin_internal(CW_CYGNAME_FROM_WINNAME, "exim", exim_username, sizeof exim_username) != 0)
     pwp = getpwnam (exim_username);

  /* If cannot setuid to exim or and is not the daemon (which is assumed to be
     able to chown or to be the exim user) set the exim ugid to our ugid to avoid
     chown failures after creating files and to be able to setuid to exim in 
     exim.c ( "privilege not needed" ). */
  if ((is_privileged == 0) && (!is_daemon)) {
    exim_uid = myuid;
    exim_gid = mygid;
  }
  else if (pwp != NULL) {
    exim_uid = pwp->pw_uid;  /* Set it according to passwd */
    exim_gid = pwp->pw_gid;
    is_eximuser = 1;
  }
  else {
    exim_uid = systemuid;
    exim_gid = adminsgid;
    is_eximuser = 0;
  }

  res = stat("/var/spool/exim", &buf);
  /* Check if writable (and can be stat) */
  is_spoolwritable = ((res == 0) && ((buf.st_mode & S_IWOTH) != 0));

  fakesetugid = (is_privileged == 0) && (is_daemon == 0) && (is_spoolwritable == 1);

  if (is_privileged) {             /* Can setuid */
     if (cygwin_setgid(exim_gid) /* Setuid to exim */
         || cygwin_setuid(exim_uid)) {
	   fprintf(stderr, "Unable to setuid/gid to exim. priv_flags: %x\n", priv_flags);
      	   exit(0);          /* Problem... Perhaps not in 544 */
     }
  }

  /* Set the configuration file uid and gid to the system uid and admins gid. */
  config_uid = systemuid;
  config_gid = adminsgid;

  /* Pretend we are root to avoid useless exec
     and avoid exim set limitations.
     We are limited by file access rights */
  root_uid = getuid ();

  if (cygwin_debug) {
    fprintf(stderr, "Starting uid %u, gid %u, priv_flags %x, is_privileged %d, is_daemon %d, is_spoolwritable %d.\n",
            myuid, mygid, priv_flags, is_privileged, is_daemon, is_spoolwritable);
    fprintf(stderr, "root_uid %u, exim_uid %u, exim_gid %u, config_uid %u, config_gid %u, is_eximuser %d.\n",
            root_uid, exim_uid, exim_gid, config_uid, config_gid, is_eximuser);
  }
  return;
}

#ifndef OS_LOAD_AVERAGE /* Can be set on command line */
#define OS_LOAD_AVERAGE /* src/os.c need not provide it */

/*****************************************************************
 Functions for average load measurements

 Uses NtQuerySystemInformation.
 This requires definitions that are not part of
 standard include files.

 This is discouraged starting with WinXP.

*************************************************************/
/* Structure to compute the load average efficiently */
typedef struct {
  DWORD Lock;
  unsigned long long Time100ns;   /* Last measurement time */
  unsigned long long IdleCount;   /* Latest cumulative idle time */
  unsigned long long LastCounter; /* Last measurement counter */
  unsigned long long PerfFreq;    /* Perf counter frequency */
  int LastLoad;                   /* Last reported load, or -1 */
} cygwin_perf_t;

static struct {
   HANDLE handle;
   pid_t pid;
   cygwin_perf_t *perf;
} cygwin_load = {NULL, 0, NULL};

#include <ntdef.h>

typedef enum _SYSTEM_INFORMATION_CLASS
{
  SystemBasicInformation = 0,
  SystemPerformanceInformation = 2,
  SystemTimeOfDayInformation = 3,
  SystemProcessesAndThreadsInformation = 5,
  SystemProcessorTimes = 8,
  SystemPagefileInformation = 18,
  /* There are a lot more of these... */
} SYSTEM_INFORMATION_CLASS;

typedef struct _SYSTEM_BASIC_INFORMATION
{
  ULONG Unknown;
  ULONG MaximumIncrement;
  ULONG PhysicalPageSize;
  ULONG NumberOfPhysicalPages;
  ULONG LowestPhysicalPage;
  ULONG HighestPhysicalPage;
  ULONG AllocationGranularity;
  ULONG LowestUserAddress;
  ULONG HighestUserAddress;
  ULONG ActiveProcessors;
  UCHAR NumberProcessors;
} SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;

typedef struct __attribute__ ((aligned (8))) _SYSTEM_PROCESSOR_TIMES
{
  LARGE_INTEGER IdleTime;
  LARGE_INTEGER KernelTime;
  LARGE_INTEGER UserTime;
  LARGE_INTEGER DpcTime;
  LARGE_INTEGER InterruptTime;
  ULONG InterruptCount;
} SYSTEM_PROCESSOR_TIMES, *PSYSTEM_PROCESSOR_TIMES;

typedef NTSTATUS NTAPI (*NtQuerySystemInformation_t) (SYSTEM_INFORMATION_CLASS, PVOID, ULONG, PULONG);
typedef ULONG NTAPI (*RtlNtStatusToDosError_t) (NTSTATUS);

static NtQuerySystemInformation_t NtQuerySystemInformation;
static RtlNtStatusToDosError_t RtlNtStatusToDosError;

/*****************************************************************
 *
 LoadNtdll()
 Load special functions from the NTDLL
 Return TRUE if success.

 *****************************************************************/

static BOOL LoadNtdll()
{
  HINSTANCE hinstLib;

  if ((hinstLib = LoadLibrary("NTDLL.DLL"))
      && (NtQuerySystemInformation =
          (NtQuerySystemInformation_t) GetProcAddress(hinstLib,
                                                        "NtQuerySystemInformation"))
      && (RtlNtStatusToDosError =
          (RtlNtStatusToDosError_t) GetProcAddress(hinstLib,
                                                     "RtlNtStatusToDosError")))
    return TRUE;

  DEBUG(D_load)
    debug_printf("perf: load: %u (Windows)\n", GetLastError());
  return FALSE;
}
/*****************************************************************
 *
 ReadStat()
 Measures current Time100ns and IdleCount
 Return TRUE if success.

 *****************************************************************/

static BOOL ReadStat(unsigned long long int *Time100nsPtr,
                     unsigned long long int *IdleCountPtr)
{
  NTSTATUS ret;
  SYSTEM_BASIC_INFORMATION sbi;
  PSYSTEM_PROCESSOR_TIMES spt;

  *Time100nsPtr = *IdleCountPtr = 0;

  if ((ret = NtQuerySystemInformation(SystemBasicInformation,
                                      (PVOID) &sbi, sizeof sbi, NULL))
      != STATUS_SUCCESS) {
    DEBUG(D_load)
      debug_printf("Perf: NtQuerySystemInformation: %u (Windows)\n",
                   RtlNtStatusToDosError(ret));
  }
  else if (!(spt = (PSYSTEM_PROCESSOR_TIMES) alloca(sizeof(spt[0]) * sbi.NumberProcessors))) {
    DEBUG(D_load)
      debug_printf("Perf: alloca: errno %d (%s)\n", errno, strerror(errno));
  }
  else if ((ret = NtQuerySystemInformation(SystemProcessorTimes, (PVOID) spt,
                                           sizeof spt[0] * sbi.NumberProcessors, NULL))
           != STATUS_SUCCESS) {
    DEBUG(D_load)
      debug_printf("Perf: NtQuerySystemInformation: %u (Windows)\n",
                   RtlNtStatusToDosError(ret));
  }
  else {
    int i;
    for (i = 0; i < sbi.NumberProcessors; i++) {
      *Time100nsPtr += spt[i].KernelTime.QuadPart;;
      *Time100nsPtr += spt[i].UserTime.QuadPart;
      *IdleCountPtr += spt[i].IdleTime.QuadPart;
    }
    return TRUE;
  }
  return FALSE;
}

/*****************************************************************
 *
 InitLoadAvg()
 Initialize the cygwin_load.perf structure.
 and set cygwin_load.perf->Flag to TRUE if successful.
 This is called the first time os_getloadavg is called
 *****************************************************************/
static void InitLoadAvg(cygwin_perf_t *this)
{
  BOOL success = TRUE;

  /* Get perf frequency and counter */
  QueryPerformanceFrequency((LARGE_INTEGER *)& this->PerfFreq);
  QueryPerformanceCounter((LARGE_INTEGER *)& this->LastCounter);

  /* Get initial values for Time100ns and IdleCount */
  success = success
            && ReadStat( & this->Time100ns,
                         & this->IdleCount);
  /* If success, set the Load to 0, else to -1 */
  if (success) this->LastLoad = 0;
  else {
    log_write(0, LOG_MAIN, "Cannot obtain Load Average");
    this->LastLoad = -1;
  }
}


/*****************************************************************
 *
 os_getloadavg()

 Return -1 if not available;
 Return the previous value if less than AVERAGING sec old.
 else return the processor load on a [0 - 1000] scale.

 The first time we are called we initialize the counts
 and return 0 or -1.
 The initial load cannot be measured as we use the processor 100%
*****************************************************************/
static SECURITY_ATTRIBUTES sa = {sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
#define AVERAGING 10

int os_getloadavg()
{
  unsigned long long Time100ns, IdleCount, CurrCounter;
  int value;
  pid_t newpid;

  /* New process.
     Reload the dlls and the file mapping */
  if ((newpid = getpid()) != cygwin_load.pid) {
    BOOL new;
    cygwin_load.pid = newpid;

    if (!LoadNtdll()) {
      log_write(0, LOG_MAIN, "Cannot obtain Load Average");
      cygwin_load.perf = NULL;
      return -1;
    }

    if ((new = !cygwin_load.handle)) {
      cygwin_load.handle = CreateFileMapping (INVALID_HANDLE_VALUE, &sa, PAGE_READWRITE,
                                              0, sizeof(cygwin_perf_t), NULL);
      DEBUG(D_load)
        debug_printf("Perf: CreateFileMapping: handle %p\n", (void *) cygwin_load.handle);
    }
    cygwin_load.perf = (cygwin_perf_t *) MapViewOfFile (cygwin_load.handle,
                                                        FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
    DEBUG(D_load)
      debug_printf("Perf: MapViewOfFile: addr %p\n", (void *) cygwin_load.perf);
    if (new && cygwin_load.perf)
      InitLoadAvg(cygwin_load.perf);
  }

  /* Check if initialized OK */
  if (!cygwin_load.perf || cygwin_load.perf->LastLoad < 0)
    return -1;

  /* If we cannot get the lock, we return 0.
     This is to prevent any lock-up possibility.
     Finding a lock busy is unlikely, and giving up only
     results in an immediate delivery .*/

  if (InterlockedCompareExchange(&cygwin_load.perf->Lock, 1, 0)) {
    DEBUG(D_load)
      debug_printf("Perf: Lock busy\n");
    return 0;
  }

    /* Get the current time (PerfCounter) */
    QueryPerformanceCounter((LARGE_INTEGER *)& CurrCounter);
    /* Calls closer than AVERAGING sec apart use the previous value */
  if (CurrCounter - cygwin_load.perf->LastCounter >
      AVERAGING * cygwin_load.perf->PerfFreq) {
      /* Get Time100ns and IdleCount */
      if (ReadStat( & Time100ns, & IdleCount)) { /* Success */
        /* Return processor load on 1000 scale */
      value = 1000 - ((1000 * (IdleCount - cygwin_load.perf->IdleCount)) /
                      (Time100ns - cygwin_load.perf->Time100ns));
      cygwin_load.perf->Time100ns = Time100ns;
      cygwin_load.perf->IdleCount = IdleCount;
      cygwin_load.perf->LastCounter = CurrCounter;
      cygwin_load.perf->LastLoad = value;
      DEBUG(D_load)
        debug_printf("Perf: New load average %d\n", value);
      }
      else { /* Something bad happened.
                Refuse to measure the load anymore
                but don't bother releasing the buffer */
        log_write(0, LOG_MAIN, "Cannot obtain Load Average");
      cygwin_load.perf->LastLoad = -1;
    }
  }
  else
  DEBUG(D_load)
      debug_printf("Perf: Old load average %d\n", cygwin_load.perf->LastLoad);
  cygwin_load.perf->Lock = 0;
  return cygwin_load.perf->LastLoad;
}
#endif /* OS_LOAD_AVERAGE */
#endif /* COMPILE_UTILITY */
Commit	Line	Data
61ec970d PH	1	/*************************************************
	2	* Exim - an Internet mail transport agent *
	3	*************************************************/
	4
92e6a3d9 JH	5	/* Cygwin-specific code. December 2002. Updated Jan 2015.
92e6a3d9 JH	6	This is prefixed to the src/os.c file.
61ec970d PH	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
61ec970d	21	#ifndef COMPILE_UTILITY /* Utilities don't need special code */
61ec970d PH	22
	23	#ifdef INCLUDE_PAM
	24	#include "../pam/pam.c"
	25	#endif
92e6a3d9	26	#include <alloca.h>
61ec970d PH	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>
92e6a3d9 JH	39	#include <ntstatus.h>
	40	#include <lmcons.h>
	41
2c5db4fd PH	42	#define EqualLuid(Luid1, Luid2) \
2c5db4fd PH	43	((Luid1.LowPart == Luid2.LowPart) && (Luid1.HighPart == Luid2.HighPart))
61ec970d PH	44	#include <sys/cygwin.h>
	45
	46	/* Special static variables */
	47	static BOOL cygwin_debug = FALSE;
92e6a3d9	48	static int fakesetugid = 1; /* when not privileged, setugid = noop */
61ec970d PH	49
	50	#undef setuid
	51	int cygwin_setuid(uid_t uid )
	52	{
92e6a3d9 JH	53	int res = 0;
92e6a3d9 JH	54	if (fakesetugid == 0) {
61ec970d PH	55	res = setuid(uid);
61ec970d PH	56	if (cygwin_debug)
92e6a3d9	57	fprintf(stderr, "setuid %u %u %d pid: %d\n",
61ec970d PH	58	uid, getuid(),res, getpid());
	59	}
	60	return res;
	61	}
	62
	63	#undef setgid
	64	int cygwin_setgid(gid_t gid )
	65	{
92e6a3d9 JH	66	int res = 0;
92e6a3d9 JH	67	if (fakesetugid == 0) {
61ec970d PH	68	res = setgid(gid);
61ec970d PH	69	if (cygwin_debug)
92e6a3d9	70	fprintf(stderr, "setgid %u %u %d pid: %d\n",
8c841523	71	gid, getgid(), res, getpid());
61ec970d PH	72	}
	73	return res;
	74	}
	75
	76	/* Background processes run at lower priority */
b6c6011d	77	static void cygwin_setpriority()
61ec970d PH	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) */
92e6a3d9 JH	90	//#define VERSION_IS_58M(x) (x & 0x80000000) /* 95, 98, Me */
92e6a3d9 JH	91	//#define VERSION_IS_NT(x) ((x & 0XFF) < 5) /* NT 4 or 3.51 */
61ec970d PH	92
	93	/*
	94	Routine to find if process or thread is privileged
	95	*/
	96
	97	enum {
	98	CREATE_BIT = 1,
61ec970d PH	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,
8c841523 PH	116	privs, sizeof (buffer), &length)
	117	\|\| (GetLastError () == ERROR_INSUFFICIENT_BUFFER
	118	&& (privs = (PTOKEN_PRIVILEGES) alloca (length))
	119	&& GetTokenInformation(hToken, TokenPrivileges,
	120	privs, length, &length)))) {
61ec970d	121	for (i = 0; i < privs->PrivilegeCount; i++) {
2c5db4fd	122	if (EqualLuid(privs->Privileges[i].Luid, cluid))
8c841523	123	ret \|= CREATE_BIT;
92e6a3d9	124	if (ret == (CREATE_BIT))
8c841523	125	break;
61ec970d PH	126	}
	127	}
	128	else
92e6a3d9	129	fprintf(stderr, "has_create_token_privilege %u\n", GetLastError());
61ec970d PH	130
	131	if (hToken)
	132	CloseHandle(hToken);
	133
	134	return ret;
	135	}
	136
92e6a3d9 JH	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)
61ec970d	142	{
92e6a3d9	143	int i, res, is_daemon = 0, is_spoolwritable, is_privileged, is_eximuser;
61ec970d PH	144	uid_t myuid, systemuid;
61ec970d PH	145	gid_t mygid, adminsgid;
92e6a3d9 JH	146	struct passwd * pwp = NULL;
	147	struct stat buf;
	148	char *cygenv;
61ec970d PH	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') {
92e6a3d9 JH	164	ssize_t size;
92e6a3d9 JH	165	wchar_t *win32_path;
61ec970d PH	166	argv[i][1] = 'n'; /* Replace -c by -n */
61ec970d PH	167	cygwin_debug = TRUE;
92e6a3d9 JH	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	}
61ec970d	175	}
92e6a3d9 JH	176	else if (argv[i][1] == 'b' && argv[i][2] == 'd') {
92e6a3d9 JH	177	is_daemon = 1;
b6c6011d	178	cygwin_setpriority();
61ec970d PH	179	}
61ec970d PH	180	}
61ec970d	181	}
92e6a3d9	182
61ec970d	183	/* Nt/2000/XP
92e6a3d9	184	We initially set the exim uid & gid to those of the "exim user",
61ec970d PH	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
92e6a3d9 JH	189	to allow exim imposed restrictions (bypassable by recompiling)
92e6a3d9 JH	190	and to avoid exec that cause loss of privilege
61ec970d PH	191	If not privileged and unable to chown,
61ec970d PH	192	we set the exim uid to our uid.
4c04137d	193	If unprivileged and /var/spool/exim is writable and not running as listening daemon,
92e6a3d9 JH	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	}
61ec970d PH	205
61ec970d PH	206	priv_flags = get_privileges ();
92e6a3d9 JH	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;
61ec970d PH	226	}
61ec970d PH	227	else {
92e6a3d9 JH	228	exim_uid = systemuid;
	229	exim_gid = adminsgid;
	230	is_eximuser = 0;
61ec970d PH	231	}
61ec970d PH	232
92e6a3d9 JH	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);
61ec970d	238
92e6a3d9 JH	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	}
61ec970d PH	245	}
61ec970d PH	246
92e6a3d9 JH	247	/* Set the configuration file uid and gid to the system uid and admins gid. */
	248	config_uid = systemuid;
	249	config_gid = adminsgid;
61ec970d	250
92e6a3d9 JH	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 ();
61ec970d PH	255
61ec970d PH	256	if (cygwin_debug) {
92e6a3d9 JH	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);
61ec970d PH	261	}
	262	return;
	263	}
	264
8c841523 PH	265	#ifndef OS_LOAD_AVERAGE /* Can be set on command line */
	266	#define OS_LOAD_AVERAGE /* src/os.c need not provide it */
	267
61ec970d	268	/*****************************************************************
61ec970d PH	269	Functions for average load measurements
61ec970d PH	270
92e6a3d9 JH	271	Uses NtQuerySystemInformation.
	272	This requires definitions that are not part of
	273	standard include files.
8c841523	274
92e6a3d9	275	This is discouraged starting with WinXP.
8c841523	276
92e6a3d9	277	*************************************************************/
8c841523 PH	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 */
8c841523 PH	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
8c841523 PH	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)
92e6a3d9	360	debug_printf("perf: load: %u (Windows)\n", GetLastError());
8c841523 PH	361	return FALSE;
8c841523 PH	362	}
8c841523 PH	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)
92e6a3d9	384	debug_printf("Perf: NtQuerySystemInformation: %u (Windows)\n",
8c841523 PH	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)
92e6a3d9	395	debug_printf("Perf: NtQuerySystemInformation: %u (Windows)\n",
8c841523 PH	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	}
8c841523	409
61ec970d PH	410	/*****************************************************************
	411	*
	412	InitLoadAvg()
8c841523 PH	413	Initialize the cygwin_load.perf structure.
8c841523 PH	414	and set cygwin_load.perf->Flag to TRUE if successful.
61ec970d PH	415	This is called the first time os_getloadavg is called
61ec970d PH	416	*****************************************************************/
8c841523	417	static void InitLoadAvg(cygwin_perf_t *this)
61ec970d PH	418	{
61ec970d PH	419	BOOL success = TRUE;
8c841523	420
61ec970d	421	/* Get perf frequency and counter */
8c841523 PH	422	QueryPerformanceFrequency((LARGE_INTEGER *)& this->PerfFreq);
	423	QueryPerformanceCounter((LARGE_INTEGER *)& this->LastCounter);
	424
8c841523 PH	425	/* Get initial values for Time100ns and IdleCount */
	426	success = success
	427	&& ReadStat( & this->Time100ns,
	428	& this->IdleCount);
61ec970d	429	/* If success, set the Load to 0, else to -1 */
8c841523	430	if (success) this->LastLoad = 0;
61ec970d PH	431	else {
61ec970d PH	432	log_write(0, LOG_MAIN, "Cannot obtain Load Average");
8c841523	433	this->LastLoad = -1;
61ec970d	434	}
61ec970d	435	}
8c841523 PH	436
8c841523 PH	437
61ec970d PH	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.
8c841523	448	The initial load cannot be measured as we use the processor 100%
61ec970d	449	*****************************************************************/
8c841523	450	static SECURITY_ATTRIBUTES sa = {sizeof (SECURITY_ATTRIBUTES), NULL, TRUE};
61ec970d	451	#define AVERAGING 10
8c841523	452
61ec970d PH	453	int os_getloadavg()
61ec970d PH	454	{
8c841523	455	unsigned long long Time100ns, IdleCount, CurrCounter;
61ec970d	456	int value;
8c841523 PH	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
8c841523 PH	465	if (!LoadNtdll()) {
	466	log_write(0, LOG_MAIN, "Cannot obtain Load Average");
	467	cygwin_load.perf = NULL;
	468	return -1;
	469	}
8c841523 PH	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)
92e6a3d9	475	debug_printf("Perf: CreateFileMapping: handle %p\n", (void *) cygwin_load.handle);
8c841523 PH	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)
92e6a3d9	480	debug_printf("Perf: MapViewOfFile: addr %p\n", (void *) cygwin_load.perf);
8c841523 PH	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	}
61ec970d	499
61ec970d PH	500	/* Get the current time (PerfCounter) */
	501	QueryPerformanceCounter((LARGE_INTEGER *)& CurrCounter);
	502	/* Calls closer than AVERAGING sec apart use the previous value */
8c841523 PH	503	if (CurrCounter - cygwin_load.perf->LastCounter >
8c841523 PH	504	AVERAGING * cygwin_load.perf->PerfFreq) {
61ec970d PH	505	/* Get Time100ns and IdleCount */
61ec970d PH	506	if (ReadStat( & Time100ns, & IdleCount)) { /* Success */
8c841523 PH	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);
61ec970d PH	516	}
61ec970d PH	517	else { /* Something bad happened.
8c841523 PH	518	Refuse to measure the load anymore
8c841523 PH	519	but don't bother releasing the buffer */
61ec970d	520	log_write(0, LOG_MAIN, "Cannot obtain Load Average");
8c841523	521	cygwin_load.perf->LastLoad = -1;
61ec970d PH	522	}
61ec970d PH	523	}
8c841523	524	else
61ec970d	525	DEBUG(D_load)
8c841523 PH	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;
61ec970d PH	529	}
	530	#endif /* OS_LOAD_AVERAGE */
	531	#endif /* COMPILE_UTILITY */