comm95c.c

/*
 * Common routines and variables used by Prime95 and NTPrime
 *
 * Comm95b contains information used only during execution
 * Comm95c contains information used during setup and execution
 */ 

#include <ras.h>
#include <winsock.h>
#include <wininet.h>
#include <process.h>
#include <sddl.h>

int	SOCKETS_INITIALIZED = 0;

/* Common routines */

/* Load the PrimeNet DLL, make sure an internet connection is active */

int LoadPrimeNet (void)
{
static	int	RAS_NOT_AVAILABLE = 0;
static	HMODULE	HRAS = 0;
static	DWORD (APIENTRY *RAS_ENUM)(LPRASCONNA, LPDWORD, LPDWORD);
static	DWORD (APIENTRY *RAS_STAT)(HRASCONN, LPRASCONNSTATUSA);
	RASCONN connections[10];
	DWORD	bufsize;
	DWORD	i, num_connections;
	DWORD	ret;

/* Special handling prior to first primenet call. */
/* Init Winsock, requesting version 1.1 */

	if (! SOCKETS_INITIALIZED) {
		static WSADATA zz;
		int	res;
		res = WSAStartup (MAKEWORD (1, 1), &zz);
		if (res != 0) {
			char buf[80];
			sprintf (buf, "ERROR: Winsock initialization returned %d.\n", res);
			OutputStr (COMM_THREAD_NUM, buf);
			return (FALSE);
		}
		SOCKETS_INITIALIZED = 1;
	}

/* If we're not using a dial-up connection, let primenet try */
/* to contact the server. */

	if (!DIAL_UP) return (TRUE);

/* Since Windows 95 can bring up a "Connect To" dialog box */
/* on any call to primenet, we try to make sure we are */
/* already connected before we call primenet.  Otherwise, if */
/* no one is at the computer to respond to the "Connect To" */
/* dialog, the thread hangs until some one does respond. */

/* RAS calls, see below, is no longer the MS-prefered method of detecting */
/* an Internet connection.  Starting in version 22.10 we offer a way for */
/* for users to use the prefered wininet.dll method. */
/* InternetGetConnectedState should return FALSE if the modem is not */
/* connected to the Internet. */
/* Starting in version 25.1, this became the default detection method. */

	if (IniGetInt (INI_FILE, "AlternateModemDetection", 1)) {
		DWORD	flags;
		if (InternetGetConnectedState (&flags, 0)) return (TRUE);
		goto no_modem_connection;
	}

// Unfortunately, the RASAPI32.DLL is not installed on every
// system.  We must load it dynamically.  If the RAS library
// is not found, let primenet.dll try to contact the server.

	if (RAS_NOT_AVAILABLE) return (TRUE);
	if (HRAS == 0) {
		RAS_NOT_AVAILABLE = 1;
		HRAS = LoadLibrary ("rasapi32.dll");
		if (HRAS == 0) return (TRUE);
		RAS_ENUM = (DWORD (APIENTRY *)(LPRASCONNA, LPDWORD, LPDWORD))
			GetProcAddress (HRAS, "RasEnumConnectionsA");
		if (RAS_ENUM == NULL) return (TRUE);
		RAS_STAT = (DWORD (APIENTRY *)(HRASCONN, LPRASCONNSTATUSA))
			GetProcAddress (HRAS, "RasGetConnectStatusA");
		if (RAS_STAT == NULL) return (TRUE);
		RAS_NOT_AVAILABLE = 0;
	}

// Call RAS to see if there are any active connections to the Internet

	connections[0].dwSize = sizeof (RASCONN);
	bufsize = sizeof (connections);
        ret = (*RAS_ENUM) ((RASCONN *) &connections, &bufsize, &num_connections);

// If RAS returns an error who knows what went wrong. 
// Let primenet try to connect anyway.

	if (ret) return (TRUE);

// See if any of these connections are really connected

	for (i = 0; i < num_connections; i++) {
		RASCONNSTATUS status;
		status.dwSize = sizeof (RASCONNSTATUS);
		ret = (*RAS_STAT) (connections[i].hrasconn, &status);
		if (ret) continue;
		if (status.rasconnstate == RASCS_Connected) return (TRUE);
	}

// Print error message if no there are no connections

no_modem_connection:
	OutputStr (COMM_THREAD_NUM, "Dial-up connection not active.\n");
	return (FALSE);
}

/* Unload the PrimeNet DLL */

void UnloadPrimeNet (void)
{

/* Tell winsock we are done. */

	if (SOCKETS_INITIALIZED) {
		// Should we call WSACancelBlockingCall first??
		// Should we check error code from WSACleanup?
		// Should we call WSACleanup after each communication session
		// with the server?  That is, are we tying up any resources?
		WSACleanup ();
		SOCKETS_INITIALIZED = 0;
	}
}

/* Get Windows Serial Number */

void getWindowsSerialNumber (
	char	*output)
{
	HKEY	hkey = 0;
	char	buf[256];
	DWORD	type, disposition;
	DWORD	bufsize = sizeof (buf);

	*output = 0;
	if (RegCreateKeyEx (
			HKEY_LOCAL_MACHINE,
			"Software\\Microsoft\\Windows\\CurrentVersion",
			0,
			NULL,
			REG_OPTION_NON_VOLATILE,
			KEY_ALL_ACCESS,
			NULL,
			&hkey,
			&disposition) == ERROR_SUCCESS &&
	    RegQueryValueEx (hkey, "ProductId", NULL, &type,
			(BYTE *) buf, &bufsize) == ERROR_SUCCESS &&
	    type == REG_SZ)
		strcpy (output, buf);
	if (hkey) RegCloseKey (hkey);
}

/* Get Windows Serial Number - our second attempt.  This is more robust */
/* as it works under Vista too. */

void getWindowsSerialNumber_2 (
	char	*output)
{
	HKEY	hkey;
	char	buf[256];
	DWORD	type;
	DWORD	bufsize;

	*output = 0;

	hkey = 0;
	bufsize = sizeof (buf);
	if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
			  "Software\\Microsoft\\Windows\\CurrentVersion", 0,
			  KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS &&
	    RegQueryValueEx (hkey, "ProductId", NULL, &type,
			     (BYTE *) buf, &bufsize) == ERROR_SUCCESS &&
	    type == REG_SZ)
		strcpy (output, buf);
	if (hkey) RegCloseKey (hkey);

	if (*output) return;

	hkey = 0;
	bufsize = sizeof (buf);
	if (RegOpenKeyEx (HKEY_LOCAL_MACHINE,
			  "Software\\Microsoft\\Windows NT\\CurrentVersion", 0,
			  KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS &&
	    RegQueryValueEx (hkey, "ProductId", NULL, &type,
			     (BYTE *) buf, &bufsize) == ERROR_SUCCESS &&
	    type == REG_SZ)
		strcpy (output, buf);
	if (hkey) RegCloseKey (hkey);
}

/* Get Window's SID.  Hopefully this will combined with the Window's */
/* serial # will generate a unique computer ID.  The SID code */
/* came courtesy of www.sysinternals.com with this copyright */
/* and restriction. */
// Copyright (c) 1997-2002 Mark Russinovich and Bryce Cogswell
//
// Changes the computer SID. 
//
// This code is protected under copyright law. You do not have 
// permission to use this code in a commercial SID-changing product.

PSECURITY_DESCRIPTOR GetRegSecDesc (HKEY Root, TCHAR *Path, 
				    SECURITY_INFORMATION Information)
{
	HKEY					hKey;
	LONG					Status;
	DWORD					nb = 0;
	PSECURITY_DESCRIPTOR	SecDesc;

	//
	// Open the key with no access requests, since we don't need
	// any.
	// SECURITY_DESCRIPTOR
	if (RegOpenKeyEx (Root, Path, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
		return NULL;

	//
	// Grab a copy of the security for key
	//
	if (RegGetKeySecurity (hKey, Information, NULL, &nb) 
					!= ERROR_INSUFFICIENT_BUFFER)
		return NULL;

	SecDesc = malloc (nb);
	Status = RegGetKeySecurity (hKey, Information, SecDesc, &nb);

	//
	// Close the key anyway
	//
	RegCloseKey (hKey);
	if (Status != ERROR_SUCCESS) {
		free (SecDesc);
		return NULL;
	}
	return SecDesc;
}
PSECURITY_DESCRIPTOR GetRegAccess (HKEY hKey)
{
	DWORD		nb = 0;
	PSECURITY_DESCRIPTOR SecDesc;
	//
	// Get access
	//
	if (RegGetKeySecurity (hKey, DACL_SECURITY_INFORMATION, NULL, &nb) != ERROR_INSUFFICIENT_BUFFER)
		return NULL;
	SecDesc = (PSECURITY_DESCRIPTOR) malloc (nb);
	if (RegGetKeySecurity (hKey, DACL_SECURITY_INFORMATION, SecDesc, &nb) != ERROR_SUCCESS) {
		free (SecDesc);
		return (NULL);
	}
	return (SecDesc);
}
LONG SetRegAccess (HKEY hKey, LPCTSTR lpSubKey,
		   PSECURITY_DESCRIPTOR SecDesc, PHKEY phKey)
{
	//
	// Grant requested access
	//
	if (RegSetKeySecurity (*phKey, DACL_SECURITY_INFORMATION, SecDesc) 
					!= ERROR_SUCCESS)
		return FALSE;

	//
	// Re-open the key if requested
	//
	if (! hKey) return TRUE;

	RegCloseKey (*phKey);
	return (RegOpenKey (hKey, lpSubKey, phKey) == ERROR_SUCCESS);
}
PBYTE IsSubAuthValid( PBYTE SidData, DWORD SidLength )
{
	PBYTE	sidPtr;

	sidPtr = NULL;
	if ( SidLength % sizeof(DWORD) == 0 )  {
		for ( sidPtr = SidData + SidLength - 5*sizeof(DWORD); sidPtr >= SidData; sidPtr -= sizeof(DWORD) )
			if ( ((PDWORD)sidPtr)[1] == 0x05000000  &&  ((PDWORD)sidPtr)[2] == 0x00000015 )
				break;
		if ( sidPtr < SidData )
			sidPtr = NULL;
	}
	return sidPtr;
}
void GetTextualSid(
    PSID pSid,            // binary Sid
    PTCHAR TextualSid)    // buffer for Textual representation of Sid
{
    PSID_IDENTIFIER_AUTHORITY psia;
    DWORD dwSubAuthorities;
    DWORD dwSidRev=SID_REVISION;
    DWORD dwCounter;
    DWORD dwSidSize;

    // Validate the binary SID.

    if(!IsValidSid(pSid)) return;

    // Get the identifier authority value from the SID.

    psia = GetSidIdentifierAuthority(pSid);

    // Get the number of subauthorities in the SID.

    dwSubAuthorities = *GetSidSubAuthorityCount(pSid);

    // Compute the buffer length.
    // S-SID_REVISION- + IdentifierAuthority- + subauthorities- + NULL

    dwSidSize=(15 + 12 + (12 * dwSubAuthorities) + 1) * sizeof(TCHAR);

    // Add 'S' prefix and revision number to the string.

    dwSidSize= _stprintf(TextualSid, _T("S-%lu-"), dwSidRev );

    // Add SID identifier authority to the string.

    if ( (psia->Value[0] != 0) || (psia->Value[1] != 0) ) {

        dwSidSize += _stprintf(TextualSid + lstrlen(TextualSid),
                    _T("0x%02hx%02hx%02hx%02hx%02hx%02hx"),
                    (USHORT)psia->Value[0],
                    (USHORT)psia->Value[1],
                    (USHORT)psia->Value[2],
                    (USHORT)psia->Value[3],
                    (USHORT)psia->Value[4],
                    (USHORT)psia->Value[5]);

    } else {

        dwSidSize += _stprintf(TextualSid + lstrlen(TextualSid),
                     _T("%lu"),
                    (ULONG)(psia->Value[5]      )   +
                    (ULONG)(psia->Value[4] <<  8)   +
                    (ULONG)(psia->Value[3] << 16)   +
                    (ULONG)(psia->Value[2] << 24)   );
    }

    // Add SID subauthorities to the string.
    //
    for (dwCounter=0 ; dwCounter < dwSubAuthorities ; dwCounter++) {
        dwSidSize+= _stprintf(TextualSid + dwSidSize, _T("-%lu"),
                    *GetSidSubAuthority(pSid, dwCounter) );
    }
}
void getWindowsSID (
	char	*output)
{
	PSECURITY_DESCRIPTOR	newSecDesc, oldSecDesc;
	DWORD					valType;
	PBYTE					vData;
	HKEY					hKey;
	DWORD					nb;
	PBYTE					sidPtr;
	DWORD					Status;

	*output = 0;
	//
	// Now, get the descriptor of HKLM\SOFTWARE and apply this to SECURITY
	//
	newSecDesc = GetRegSecDesc( HKEY_LOCAL_MACHINE, "SOFTWARE",
					DACL_SECURITY_INFORMATION );

	//
	// Read the last subauthority of the current computer SID
	//
	if( RegOpenKey( HKEY_LOCAL_MACHINE, "SECURITY\\SAM\\Domains\\Account", 
			&hKey) != ERROR_SUCCESS ) {
		free (newSecDesc);
		return;
	}
	oldSecDesc = GetRegAccess( hKey );
	SetRegAccess( HKEY_LOCAL_MACHINE, "SECURITY\\SAM\\Domains\\Account", 
		newSecDesc, &hKey );
	nb = 0;
	vData = NULL;
	RegQueryValueEx( hKey, "V", NULL, &valType, vData, &nb );
	vData = (PBYTE) malloc( nb );
	Status = RegQueryValueEx( hKey, "V", NULL, &valType, vData, &nb );
	if( Status != ERROR_SUCCESS ) {
		SetRegAccess( HKEY_LOCAL_MACHINE, "SECURITY\\SAM\\Domains\\Account",
				oldSecDesc, &hKey );
		free (vData);
		free (oldSecDesc);
		free (newSecDesc);
		return;
	}
	SetRegAccess( NULL, NULL, oldSecDesc, &hKey );
	RegCloseKey( hKey );
	free (oldSecDesc);
	free (newSecDesc);

	//
	// Make sure that we're dealing with a SID we understand
	//
	if( !(sidPtr = IsSubAuthValid( vData, nb ))) {
		free (vData);
		return;
	}

	GetTextualSid( sidPtr, output );
	free (vData);
}

/* Version 2.  My simpler attempt at getting the Windows SID. */
/* Version 1 failed on RegOpenKey when I switch users on Vista. */

void getWindowsSID_2 (
	char	*output)
{
	char	computer_name[256];
	SID	*sid;
	SID_NAME_USE snu;
	char	*domain;
	char	*stringsid;
	unsigned long size, domainsize;

	*output = 0;

/* Get the computer name */

	size = sizeof (computer_name);
	if (! GetComputerName ((LPSTR) computer_name, &size)) return;

/* First find the size of buffers required for the SID and domain name */

	sid = 0;
	domain = 0;
	size = domainsize = 0;
	LookupAccountName(0, (LPCSTR) computer_name, sid, &size, domain, &domainsize, &snu);

/* Should have failed with ERROR_INSUFFICIENT_BUFFER */

	if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return;

/* Allocate memory */

	sid = (SID *) malloc (size);
	domain = (char *) malloc (domainsize);

/* Get the SID */

	if (sid != NULL && domain != NULL &&
	    LookupAccountName (0, (LPCSTR) computer_name, sid, &size, domain, &domainsize, &snu) &&
	    ConvertSidToStringSid(sid, &stringsid)) {
		strcpy (output, stringsid);
		LocalFree (stringsid);
	}

/* Cleanup */

	free (sid);
	free (domain);
}


/* Return the number of MB of physical memory. */

unsigned long physical_memory (void)
{
#ifdef X86_64
	MEMORYSTATUSEX mem;
	mem.dwLength = sizeof (mem);
	GlobalMemoryStatusEx (&mem);
	return ((unsigned long) ((mem.ullTotalPhys + 1000000) >> 20));
#else
	HMODULE	hlib;
	MEMORYSTATUS mem;

/* Try using GlobalMemoryStatusEx - not available in Win98 and earlier */

	hlib = LoadLibrary ("KERNEL32.DLL");
	if (hlib) {
		DWORD (__stdcall *proc)(MEMORYSTATUSEX *);
		proc = (DWORD (__stdcall *)(MEMORYSTATUSEX *))
		       GetProcAddress (hlib, "GlobalMemoryStatusEx");
		if (proc != NULL) {
			MEMORYSTATUSEX mem;
			mem.dwLength = sizeof (mem);
			(*proc) (&mem);
			FreeLibrary (hlib);
			return ((unsigned long) ((mem.ullTotalPhys + 1000000) >> 20));
		}
		FreeLibrary (hlib);
	}

/* Fall back to using GlobalMemoryStatus - it can't cope with machines having more than 2GB memory */

	GlobalMemoryStatus (&mem);
	return (mem.dwTotalPhys >> 20);
#endif
}

/* Return a better guess for amount of memory to use in a torture test. */
/* Caller passes in its guess for amount of memory to use, but this routine */
/* can reduce that guess based on OS-specific code that looks at amount */
/* of available physical memory. */
/* This code was written by an anonymous GIMPS user. */

unsigned long GetSuggestedMemory (unsigned long nDesiredMemory)
{
#ifdef X86_64
	MEMORYSTATUSEX ms = {0};
	DWORDLONG ullUsedMem;	// In-use Physical RAM in bytes
	DWORDLONG ullDesiredMem = (DWORDLONG) nDesiredMemory << 20;	// Desired memory in bytes
	DWORDLONG ullDesiredMemNew = ullDesiredMem;

	ms.dwLength = sizeof (ms);
	GlobalMemoryStatusEx (&ms);
	ullUsedMem = ms.ullTotalPhys - ms.ullAvailPhys;

	// if very small/no page-file (pagefile <= total RAM) and
	// in-use memory + desired memory > total RAM, then
	// we have to set desired memory to free RAM,
	// because the OS can't page out other apps to
	// reclaim enough free memory since
	// there's not enough space in the pagefile
	// to store the paged-out apps
	if ((ms.ullTotalPageFile <= ms.ullTotalPhys) &&
	    (ullUsedMem + ullDesiredMem >= ms.ullTotalPhys)) {
		ullDesiredMemNew = ms.ullAvailPhys;
	}

	return ((unsigned long) (ullDesiredMemNew >> 20));
#else
	HMODULE	hlib;
	MEMORYSTATUS ms = {0};
	DWORD dwUsedMem;	// In-use Physical RAM in bytes
	DWORD dwDesiredMem; 	// Desired memory in bytes
	DWORD dwDesiredMemNew;

/* Try using GlobalMemoryStatusEx - not available in Win98 and earlier */

	hlib = LoadLibrary ("KERNEL32.DLL");
	if (hlib) {
		DWORD (__stdcall *proc)(MEMORYSTATUSEX *);
		proc = (DWORD (__stdcall *)(MEMORYSTATUSEX *))
		       GetProcAddress (hlib, "GlobalMemoryStatusEx");
		if (proc != NULL) {
			MEMORYSTATUSEX ms = {0};
			DWORDLONG ullUsedMem;	// In-use Physical RAM in bytes
			DWORDLONG ullDesiredMem = (DWORDLONG) nDesiredMemory << 20;	// Desired memory in bytes
			DWORDLONG ullDesiredMemNew = ullDesiredMem;

			ms.dwLength = sizeof (ms);
			(*proc) (&ms);
			ullUsedMem = ms.ullTotalPhys - ms.ullAvailPhys;

			// if very small/no page-file (pagefile <= total RAM) and
			// in-use memory + desired memory > total RAM, then
			// we have to set desired memory to free RAM,
			// because the OS can't page out other apps to
			// reclaim enough free memory since
			// there's not enough space in the pagefile
			// to store the paged-out apps
			if ((ms.ullTotalPageFile <= ms.ullTotalPhys) &&
			    (ullUsedMem + ullDesiredMem >= ms.ullTotalPhys)) {
				ullDesiredMemNew = ms.ullAvailPhys;
			}

			FreeLibrary (hlib);
			return ((unsigned long) (ullDesiredMemNew >> 20));
		}
		FreeLibrary (hlib);
	}

/* Fall back to using GlobalMemoryStatus - it can't cope with machines having more than 2GB memory */

	dwDesiredMem = nDesiredMemory << 20;
	dwDesiredMemNew	= dwDesiredMem;

	GlobalMemoryStatus (&ms);
	dwUsedMem = ms.dwTotalPhys - ms.dwAvailPhys;

	// if very small/no page-file (pagefile <= total RAM) and
	// in-use memory + desired memory > total RAM, then
	// we have to set desired memory to free RAM,
	// because the OS can't page out other apps to
	// reclaim enough free memory since
	// there's not enough space in the pagefile
	// to store the paged-out apps
	if ((ms.dwTotalPageFile <= ms.dwTotalPhys) &&
	    ((dwUsedMem + dwDesiredMem) >= ms.dwTotalPhys))
	{
		dwDesiredMemNew = ms.dwAvailPhys;
	}

	return (dwDesiredMemNew >> 20);
#endif
}

/* Return 1 to print time in AM/PM format.  Return 2 to print */
/* times using a 24-hour clock. */

int getDefaultTimeFormat (void)
{
	char	buf[10];

	GetLocaleInfo (
		LOCALE_USER_DEFAULT, LOCALE_ITIME, (LPTSTR) buf, sizeof (buf));
	return (buf[0] == '0' ? 1 : 2);
}

/* Return TRUE if we are on battery power. */

int OnBattery (void)
{
	SYSTEM_POWER_STATUS power;

// We might be able to optimize this by caching the system power status
// and only regetting it after a PBT_APMPOWERSTATUSCHANGE message.

	if (GetSystemPowerStatus (&power) &&
	    (power.ACLineStatus != 1 ||
	     (power.ACLineStatus == 1 &&
	      power.BatteryLifePercent < BATTERY_PERCENT)))
		return (TRUE);

// Return FALSE, were on AC power */

	return (FALSE);
}