/*
* File: instsrv.c
* Purpose: To install a new service and to insert registry entries.
*
*/
#ifndef __RPCASYNC_H__
#define __RPCASYNC_H__ /* Skip asynch rpc inclusion */
#endif
#include <windows.h>
#include <stdio.h>
#if _MSC_VER <= 1800
#define snprintf _snprintf
#endif
#define PERR(api) printf("\n%s: Error %d from %s on line %d", \
__FILE__, GetLastError(), api, __LINE__);
#define MSG_FOR_ACCESS_DENIED "You aren't authorized to do this - please see your system Administrator"
#define MSG_1_FOR_BAD_PATH "The fully qualified path name to the .exe must be given, and"
#define MSG_2_FOR_BAD_PATH " the drive letter must be for a fixed disk (e.g., not a net drive)"
/* Building an initialised REG_MULTISZ needs a bit of care: The array must be big enough
** to hold the closing double-NUL and should have *exactly* the required size. Since the
** dependencies are fixed here, we take exactly the required 11 bytes:
*/
static const char s_acSvcDeps[11] = "TcpIp\0Afd\0\0";
/* likewise we do with the PPAS API list... */
static const char s_acPpsDlls[30] = "loopback-ppsapi-provider.dll\0\0";
SC_HANDLE schService;
SC_HANDLE schSCManager;
int ok2;
void DisplayHelp(void);
/* --------------------------------------------------------------------------------------- */
static const char *
getServicePath(
const char * const * const argv,
const int argc) /* MUST be >= 1 !! */
{
static const char * const s_chars_to_quote = " []()";
size_t minsize = argc * 3; /* may need separator/NUL + quotes */
int i;
const char *execPath = argv[0];
char *cbuf, *cpos;
/* if just the executable and no dangerous chars, return the exe path. */
if (argc == 1 && !strpbrk(execPath, s_chars_to_quote))
return execPath;
/* calculate buffer size and get the buffer */
for (i = 0; i < argc; ++i)
minsize += strlen(argv[i]);
cpos = cbuf = malloc(minsize);
if (NULL == cbuf) {
printf("malloc() failed\n");
exit(2);
}
/* program name must be quoted in all cases */
*cpos++ = '"';
strcpy(cpos, execPath);
cpos += strlen(cpos);
*cpos++ = '"';
/* append additional args */
for (i = 1; i < argc; ++i) {
*cpos++ = ' ';
if (strpbrk(argv[i], s_chars_to_quote)) { /* needs quotes? */
*cpos++ = '"';
strcpy(cpos, argv[i]);
cpos += strlen(cpos);
*cpos++ = '"';
} else {
strcpy(cpos, argv[i]);
cpos += strlen(cpos);
}
}
*cpos = '\0';
return cbuf;
}
/* --------------------------------------------------------------------------------------- */
BOOL
validateExeName(
const char *exePath)
{
char rootPath[] = "?:\\";
/* check for absolute path */
if ((':' != exePath[1]) || ('\\' != exePath[2])) {
printf("\n%s", MSG_1_FOR_BAD_PATH);
printf("\n%s\n", MSG_2_FOR_BAD_PATH);
return 1;
}
#define DRIVE_TYPE_INDETERMINATE 0
#define ROOT_DIR_DOESNT_EXIST 1
/* check drive type -- must be local HDD! */
rootPath[0] = exePath[0];
switch (GetDriveTypeA(rootPath))
{
case DRIVE_FIXED:
// OK
break;
case ROOT_DIR_DOESNT_EXIST:
printf("\n%s", MSG_1_FOR_BAD_PATH);
printf("\n the root directory where the .exe is specified to be must exist, and");
printf("\n%s\n", MSG_2_FOR_BAD_PATH);
return 1;
case DRIVE_TYPE_INDETERMINATE:
case DRIVE_REMOVABLE:
case DRIVE_REMOTE:
case DRIVE_CDROM:
case DRIVE_RAMDISK:
printf("\n%s", MSG_1_FOR_BAD_PATH);
printf("\n%s\n", MSG_2_FOR_BAD_PATH);
return 1;
default:
printf("\n%s", MSG_1_FOR_BAD_PATH);
printf("\n%s\n", MSG_2_FOR_BAD_PATH);
return 1;
}
/* check if file exists. We just drop the handle. This is a one-shot program! */
if (INVALID_HANDLE_VALUE == CreateFileA(
exePath, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL))
{
printf("\n%s", MSG_1_FOR_BAD_PATH);
printf("\n the file must exist, and");
printf("\n%s\n", MSG_2_FOR_BAD_PATH);
return 1;
}
return 0;
}
/* --------------------------------------------------------------------------------------- */
int
InstallService(
LPCSTR serviceName,
LPCSTR displayName,
LPCSTR serviceExe ,
LPCSTR servDepends)
{
/* create the service now. */
schService = CreateServiceA(
schSCManager, // SCManager database
serviceName, // name of service
displayName, // name to display
SERVICE_ALL_ACCESS, // desired access
SERVICE_WIN32_OWN_PROCESS, // service type
SERVICE_AUTO_START, // start type
SERVICE_ERROR_NORMAL, // error control type
serviceExe, // service's binary
NULL, // no load ordering group
NULL, // no tag identifier
servDepends, // possible dependencies
NULL, // Local System account
NULL); // null password
if (NULL == schService) {
switch (GetLastError())
{
case ERROR_ACCESS_DENIED :
printf("\n%s",MSG_FOR_ACCESS_DENIED);
break;
case ERROR_SERVICE_EXISTS :
printf("\nThe %s service is already installed",serviceName);
printf("\nRemove it first if you need to re-install a new version\n");
break;
default :
PERR("CreateService");
break;
}
return 1;
}
CloseServiceHandle(schService);
return 0;
}
/* --------------------------------------------------------------------------------------- */
int
RemoveService(
LPCSTR serviceName)
{
{
# define SZ_ENUM_BUF 4096
ENUM_SERVICE_STATUS essServiceStatus[SZ_ENUM_BUF];
DWORD dwBufSize = sizeof(essServiceStatus);
DWORD dwBytesNeeded = 0;
DWORD dwServicesReturned = 0;
DWORD dwResumeHandle = 0;
DWORD dwI = 0;
BOOLEAN bFound = FALSE;
if (!EnumServicesStatusA(schSCManager, SERVICE_WIN32, SERVICE_ACTIVE,
(LPENUM_SERVICE_STATUS)&essServiceStatus,
dwBufSize, &dwBytesNeeded, &dwServicesReturned,
&dwResumeHandle))
{
switch (GetLastError())
{
case ERROR_ACCESS_DENIED :
printf("\n%s", MSG_FOR_ACCESS_DENIED);
break;
default :
PERR("EnumServicesStatus");
break;
}
return 1;
}
for (dwI = 0; dwI < dwServicesReturned; ++dwI) {
if(0 == _stricmp(essServiceStatus[dwI].lpServiceName, serviceName)) {
bFound = TRUE;
break;
}
}
if (bFound) {
printf("\nThe %s service cannot be removed until it has been stopped.", serviceName);
printf("\nTo stop the %s service, use the Stop button in the Control" , serviceName);
printf("\n Panel Services applet\n");
return 1;
}
}
schService = OpenServiceA(schSCManager, serviceName, SERVICE_ALL_ACCESS);
if (NULL == schService) {
switch (GetLastError())
{
case ERROR_ACCESS_DENIED :
printf("\n%s", MSG_FOR_ACCESS_DENIED);
break;
case ERROR_SERVICE_DOES_NOT_EXIST :
printf("\nThe %s service is not installed, so cannot be removed\n", serviceName);
break;
default :
PERR("OpenService");
break;
}
return 1;
}
if (DeleteService(schService)) {
printf("\nDelete of Service \"Network Time Protocol\" was SUCCESSFUL\n");
return 0;
}
switch (GetLastError())
{
case ERROR_ACCESS_DENIED :
printf("\n%s", MSG_FOR_ACCESS_DENIED);
break;
default :
PERR("DeleteService");
break;
}
return 1;
}
/* --------------------------------------------------------------------------------------- */
int
addSourceToRegistry(
const char * pszAppname,
const char * pszMsgDLL )
{
HKEY hk; /* registry key handle */
DWORD dwData;
BOOL bSuccess;
char regarray[200];
int rc;
/* When an application uses the RegisterEventSource or OpenEventLog function to get a
handle of an event log, the event logging service searches for the specified
source name in the registry. You can add a new source name to the registry by
opening a new registry subkey under the Application key and adding registry values
to the new subkey.
*/
rc = _snprintf(regarray, sizeof(regarray), "%s%s",
"SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\",
pszAppname);
if (rc < 0 || rc >= sizeof(regarray)) {
fputs("addSourceToRegistry: buffer overrun(app name)", stderr);
return 1;
}
/* Create a new key for our application */
bSuccess = RegCreateKeyA(HKEY_LOCAL_MACHINE, regarray, &hk);
if(bSuccess != ERROR_SUCCESS) {
PERR("RegCreateKey");
return 1;
}
/* Add the Event-ID message-file name to the subkey. */
bSuccess = RegSetValueExA(hk, /* subkey handle */
"EventMessageFile", /* value name */
0, /* must be zero */
REG_EXPAND_SZ, /* value type */
(LPBYTE)pszMsgDLL, /* address of value data */
(DWORD)(strlen(pszMsgDLL) + 1)); /* length of value data */
if(bSuccess != ERROR_SUCCESS) {
PERR("RegSetValueEx");
return 1;
}
/* Set the supported types flags and addit to the subkey. */
dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
bSuccess = RegSetValueExA(hk, /* subkey handle */
"TypesSupported", /* value name */
0, /* must be zero */
REG_DWORD, /* value type */
(LPBYTE) &dwData, /* address of value data */
sizeof(DWORD)); /* length of value data */
if(bSuccess != ERROR_SUCCESS) {
PERR("RegSetValueEx");
return 1;
}
RegCloseKey(hk);
return 0;
}
/* --------------------------------------------------------------------------------------- */
int
addKeysToRegistry(void)
{
HKEY hk; /* registry key handle */
BOOL bSuccess;
/* now add the depends on service key */
/* Create a new key for our application */
bSuccess = RegCreateKeyA(HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Services\\NTP", &hk);
if(bSuccess != ERROR_SUCCESS) {
PERR("RegCreateKey");
return 1;
}
bSuccess = RegSetValueExA(hk, /* subkey handle */
"PPSProviders", /* value name */
0, /* must be zero */
REG_MULTI_SZ, /* value type */
(LPBYTE)s_acPpsDlls, /* address of value data */
(DWORD)sizeof(s_acPpsDlls)); /* length of value data */
if (bSuccess != ERROR_SUCCESS) {
PERR("RegSetValueEx");
return 1;
}
RegCloseKey(hk);
return 0;
}
/* --------------------------------------------------------------------------------------- */
int main(int argc, char *argv[])
{
static const char * const szServiceName = "NTP";
static const char * const szDisplayName = "Network Time Protocol";
BOOL bRemovingService = FALSE;
char *p;
int ok = 0;
// check if Win32s, if so, display notice and terminate
if (GetVersion() & 0x80000000) {
MessageBoxA(NULL,
"This application cannot run on Windows 3.1.\n"
"This application will now terminate.",
"NAMED",
MB_OK | MB_ICONSTOP | MB_SETFOREGROUND );
return 1;
}
if (argc >= 2)
bRemovingService = (!stricmp(argv[1], "remove"));
if ((bRemovingService && argc != 2) || (!bRemovingService && argc < 2)) {
DisplayHelp();
return 1;
}
if(!bRemovingService) {
p = argv[1];
if (('/' == *p) || ('-' == *p) || validateExeName(p)) {
DisplayHelp();
return 1;
}
}
if (strlen(argv[1]) > 256) {
printf("\nThe service name cannot be longer than 256 characters\n");
return 1;
}
schSCManager = OpenSCManagerA(
NULL, // machine (NULL == local)
NULL, // database (NULL == default)
SC_MANAGER_ALL_ACCESS); // access required
if (NULL == schSCManager) {
switch (GetLastError())
{
case ERROR_ACCESS_DENIED :
printf("\n%s", MSG_FOR_ACCESS_DENIED);
break;
default :
PERR("OpenSCManager");
break;
}
return 0;
}
if (bRemovingService)
ok = RemoveService(szServiceName);
else
ok = InstallService(szServiceName, szDisplayName,
getServicePath(argv+1, argc-1), s_acSvcDeps);
CloseServiceHandle(schSCManager);
if (!bRemovingService) {
if (ok == 0)
ok = addSourceToRegistry("NTP", argv[1]);/* Set the Event-ID message-file name. */
if (ok == 0)
ok = addKeysToRegistry(); /* add other stuff */
if (ok == 0)
{
static const char s_msg[] =
"\nThe \"Network Time Protocol\" service was successfully created.\n"
"\nDon't forget!!! You must now go to the Control Panel and"
"\n use the Services applet to change the account name and"
"\n password that the NTP Service will use when"
"\n it starts."
"\nTo do this: use the Startup button in the Services applet,"
"\n and (for example) specify the desired account and"
"\n correct password."
"\nAlso, use the Services applet to ensure this newly installed"
"\n service starts automatically on bootup.\n";
fputs(s_msg, stdout);
}
}
return ok;
}
/* --------------------------------------------------------------------------------------- */
void
DisplayHelp(void)
{
static const char s_hlpmsg[] =
"Installs or removes the NTP service.\n"
"To install the NTP service,\n"
"type INSTSRV <path> [args]\n"
"Where:\n"
" path Absolute path to the NTP service. (ntpd.exe) You must\n"
" use a fully qualified path and the drive letter must be for a\n"
" fixed, local drive.\n\n"
" args Additional command line arguments for the service\n"
"For example, INSTSRV i:\\winnt\\system32\\ntpd.exe\n"
"To remove the NTP service,\n"
"type INSTSRV remove \n";
fputs(s_hlpmsg, stdout);
}
/* EOF */