/** Removes the Tor NT service. Returns 0 if the service was successfully
* removed, or -1 on error. */
static int
nt_service_remove(void)
{
SC_HANDLE hSCManager = NULL;
SC_HANDLE hService = NULL;
char *errmsg;
nt_service_loadlibrary();
if ((hSCManager = nt_service_open_scm()) == NULL)
return -1;
if ((hService = nt_service_open(hSCManager)) == NULL) {
service_fns.CloseServiceHandle_fn(hSCManager);
return -1;
}
nt_service_stop(hService);
if (service_fns.DeleteService_fn(hService) == FALSE) {
errmsg = format_win32_error(GetLastError());
printf("DeleteService() failed : %s\n", errmsg);
tor_free(errmsg);
service_fns.CloseServiceHandle_fn(hService);
service_fns.CloseServiceHandle_fn(hSCManager);
return -1;
}
service_fns.CloseServiceHandle_fn(hService);
service_fns.CloseServiceHandle_fn(hSCManager);
printf("Service removed successfully\n");
return 0;
}
/** Stop the Tor service. Return 0 if the service is stopped or was not
* previously running. Return -1 on error. */
static int
nt_service_stop(SC_HANDLE hService)
{
/** Wait at most 10 seconds for the service to stop. */
#define MAX_SERVICE_WAIT_TIME 10
int wait_time;
char *errmsg = NULL;
nt_service_loadlibrary();
service_fns.QueryServiceStatus_fn(hService, &service_status);
if (service_status.dwCurrentState == SERVICE_STOPPED) {
printf("Service is already stopped\n");
return 0;
}
if (service_fns.ControlService_fn(hService, SERVICE_CONTROL_STOP,
&service_status)) {
wait_time = 0;
while (service_fns.QueryServiceStatus_fn(hService, &service_status) &&
(service_status.dwCurrentState != SERVICE_STOPPED) &&
(wait_time < MAX_SERVICE_WAIT_TIME)) {
Sleep(1000);
wait_time++;
}
if (service_status.dwCurrentState == SERVICE_STOPPED) {
printf("Service stopped successfully\n");
return 0;
} else if (wait_time == MAX_SERVICE_WAIT_TIME) {
printf("Service did not stop within %d seconds.\n", wait_time);
} else {
errmsg = format_win32_error(GetLastError());
printf("QueryServiceStatus() failed : %s\n",errmsg);
tor_free(errmsg);
}
} else {
errmsg = format_win32_error(GetLastError());
printf("ControlService() failed : %s\n", errmsg);
tor_free(errmsg);
}
return -1;
}
void
tor_threadlocal_set(tor_threadlocal_t *threadlocal, void *value)
{
BOOL ok = TlsSetValue(threadlocal->index, value);
if (!ok) {
DWORD err = GetLastError();
char *msg = format_win32_error(err);
log_err(LD_GENERAL, "Error adjusting thread-local value: %s", msg);
tor_free(msg);
tor_assert(ok);
}
}
/** Open a handle to the Tor service using <b>hSCManager</b>. Return NULL
* on failure. */
static SC_HANDLE
nt_service_open(SC_HANDLE hSCManager)
{
SC_HANDLE hService;
char *errmsg = NULL;
nt_service_loadlibrary();
if ((hService = service_fns.OpenServiceA_fn(hSCManager, GENSRV_SERVICENAME,
SERVICE_ALL_ACCESS)) == NULL) {
errmsg = format_win32_error(GetLastError());
printf("OpenService() failed : %s\n", errmsg);
tor_free(errmsg);
}
return hService;
}
/** Start the Tor service. Return 0 if the service is started or was
* previously running. Return -1 on error. */
static int
nt_service_start(SC_HANDLE hService)
{
char *errmsg = NULL;
nt_service_loadlibrary();
service_fns.QueryServiceStatus_fn(hService, &service_status);
if (service_status.dwCurrentState == SERVICE_RUNNING) {
printf("Service is already running\n");
return 0;
}
if (service_fns.StartServiceA_fn(hService, 0, NULL)) {
/* Loop until the service has finished attempting to start */
while (service_fns.QueryServiceStatus_fn(hService, &service_status) &&
(service_status.dwCurrentState == SERVICE_START_PENDING)) {
Sleep(500);
}
/* Check if it started successfully or not */
if (service_status.dwCurrentState == SERVICE_RUNNING) {
printf("Service started successfully\n");
return 0;
} else {
errmsg = format_win32_error(service_status.dwWin32ExitCode);
printf("Service failed to start : %s\n", errmsg);
tor_free(errmsg);
}
} else {
errmsg = format_win32_error(GetLastError());
printf("StartService() failed : %s\n", errmsg);
tor_free(errmsg);
}
return -1;
}
/** Return a handle to the service control manager on success, or NULL on
* failure. */
static SC_HANDLE
nt_service_open_scm(void)
{
SC_HANDLE hSCManager;
char *errmsg = NULL;
nt_service_loadlibrary();
if ((hSCManager = service_fns.OpenSCManagerA_fn(
NULL, NULL, SC_MANAGER_CREATE_SERVICE)) == NULL) {
errmsg = format_win32_error(GetLastError());
printf("OpenSCManager() failed : %s\n", errmsg);
tor_free(errmsg);
}
return hSCManager;
}
void *
tor_threadlocal_get(tor_threadlocal_t *threadlocal)
{
void *value = TlsGetValue(threadlocal->index);
if (value == NULL) {
DWORD err = GetLastError();
if (err != ERROR_SUCCESS) {
char *msg = format_win32_error(err);
log_err(LD_GENERAL, "Error retrieving thread-local value: %s", msg);
tor_free(msg);
tor_assert(err == ERROR_SUCCESS);
}
}
return value;
}
/** Main service entry point. Starts the service control dispatcher and waits
* until the service status is set to SERVICE_STOPPED. */
static void
nt_service_main(void)
{
SERVICE_TABLE_ENTRYA table[2];
DWORD result = 0;
char *errmsg;
nt_service_loadlibrary();
table[0].lpServiceName = (char*)GENSRV_SERVICENAME;
table[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTIONA)nt_service_body;
table[1].lpServiceName = NULL;
table[1].lpServiceProc = NULL;
if (!service_fns.StartServiceCtrlDispatcherA_fn(table)) {
result = GetLastError();
errmsg = format_win32_error(result);
printf("Service error %d : %s\n", (int) result, errmsg);
tor_free(errmsg);
if (result == ERROR_FAILED_SERVICE_CONTROLLER_CONNECT) {
if (tor_init(backup_argc, backup_argv))
return;
switch (get_options()->command) {
case CMD_RUN_TOR:
do_main_loop();
break;
case CMD_LIST_FINGERPRINT:
case CMD_HASH_PASSWORD:
case CMD_VERIFY_CONFIG:
case CMD_DUMP_CONFIG:
case CMD_KEYGEN:
case CMD_KEY_EXPIRATION:
log_err(LD_CONFIG, "Unsupported command (--list-fingerprint, "
"--hash-password, --keygen, --dump-config, --verify-config, "
"or --key-expiration) in NT service.");
break;
case CMD_RUN_UNITTESTS:
default:
log_err(LD_CONFIG, "Illegal command number %d: internal error.",
get_options()->command);
}
tor_cleanup();
}
}
}
/** Libevent callback to poll for the existence of the process
* monitored by <b>procmon_</b>. */
static void
tor_process_monitor_poll_cb(evutil_socket_t unused1, short unused2,
void *procmon_)
{
tor_process_monitor_t *procmon = (tor_process_monitor_t *)(procmon_);
int its_dead_jim;
(void)unused1; (void)unused2;
tor_assert(procmon != NULL);
#ifdef MS_WINDOWS
if (procmon->poll_hproc) {
DWORD exit_code;
if (!GetExitCodeProcess(procmon->hproc, &exit_code)) {
char *errmsg = format_win32_error(GetLastError());
log_warn(procmon->log_domain, "Error \"%s\" occurred while polling "
"handle for monitored process %d; assuming it's dead.",
errmsg, procmon->pid);
tor_free(errmsg);
its_dead_jim = 1;
} else {
its_dead_jim = (exit_code != STILL_ACTIVE);
}
} else {
/* All we can do is try to open the process, and look at the error
* code if it fails again. */
procmon->hproc = OpenProcess(PROCESS_QUERY_INFORMATION | SYNCHRONIZE,
FALSE,
procmon->pid);
if (procmon->hproc != NULL) {
log_info(procmon->log_domain, "Successfully opened handle to monitored "
"process %d.",
procmon->pid);
its_dead_jim = 0;
procmon->poll_hproc = 1;
} else {
DWORD err_code = GetLastError();
char *errmsg = format_win32_error(err_code);
/* When I tested OpenProcess's error codes on Windows 7, I
* received error code 5 (ERROR_ACCESS_DENIED) for PIDs of
* existing processes that I could not open and error code 87
* (ERROR_INVALID_PARAMETER) for PIDs that were not in use.
* Since the nonexistent-process error code is sane, I'm going
* to assume that all errors other than ERROR_INVALID_PARAMETER
* mean that the process we are monitoring is still alive. */
its_dead_jim = (err_code == ERROR_INVALID_PARAMETER);
if (!its_dead_jim)
log_info(procmon->log_domain, "Failed to open handle to monitored "
"process %d, and error code %lu (%s) is not 'invalid "
"parameter' -- assuming the process is still alive.",
procmon->pid,
err_code, errmsg);
tor_free(errmsg);
}
}
#else
/* Unix makes this part easy, if a bit racy. */
its_dead_jim = kill(procmon->pid, 0);
its_dead_jim = its_dead_jim && (errno == ESRCH);
#endif
log(its_dead_jim ? LOG_NOTICE : LOG_INFO,
procmon->log_domain, "Monitored process %d is %s.",
(int)procmon->pid,
its_dead_jim ? "dead" : "still alive");
if (its_dead_jim) {
procmon->cb(procmon->cb_arg);
#ifndef HAVE_EVENT2_EVENT_H
} else {
evtimer_add(procmon->e, &poll_interval_tv);
#endif
}
}
/** Creates a Tor NT service, set to start on boot. The service will be
* started if installation succeeds. Returns 0 on success, or -1 on
* failure. */
static int
nt_service_install(int argc, char **argv)
{
/* Notes about developing NT services:
*
* 1. Don't count on your CWD. If an absolute path is not given, the
* fopen() function goes wrong.
* 2. The parameters given to the nt_service_body() function differ
* from those given to main() function.
*/
SC_HANDLE hSCManager = NULL;
SC_HANDLE hService = NULL;
SERVICE_DESCRIPTIONA sdBuff;
char *command;
char *errmsg;
const char *user_acct = NULL;
const char *password = "";
int i;
OSVERSIONINFOEX info;
SID_NAME_USE sidUse;
DWORD sidLen = 0, domainLen = 0;
int is_win2k_or_worse = 0;
int using_default_torrc = 0;
nt_service_loadlibrary();
/* Open the service control manager so we can create a new service */
if ((hSCManager = nt_service_open_scm()) == NULL)
return -1;
/* Build the command line used for the service */
if ((command = nt_service_command_line(&using_default_torrc)) == NULL) {
printf("Unable to build service command line.\n");
service_fns.CloseServiceHandle_fn(hSCManager);
return -1;
}
for (i=1; i < argc; ++i) {
if (!strcmp(argv[i], "--user") && i+1<argc) {
user_acct = argv[i+1];
++i;
}
if (!strcmp(argv[i], "--password") && i+1<argc) {
password = argv[i+1];
++i;
}
}
/* Compute our version and see whether we're running win2k or earlier. */
memset(&info, 0, sizeof(info));
info.dwOSVersionInfoSize = sizeof(info);
if (! GetVersionEx((LPOSVERSIONINFO)&info)) {
printf("Call to GetVersionEx failed.\n");
is_win2k_or_worse = 1;
} else {
if (info.dwMajorVersion < 5 ||
(info.dwMajorVersion == 5 && info.dwMinorVersion == 0))
is_win2k_or_worse = 1;
}
if (!user_acct) {
if (is_win2k_or_worse) {
/* On Win2k, there is no LocalService account, so we actually need to
* fall back on NULL (the system account). */
printf("Running on Win2K or earlier, so the LocalService account "
"doesn't exist. Falling back to SYSTEM account.\n");
} else {
/* Genericity is apparently _so_ last year in Redmond, where some
* accounts are accounts that you can look up, and some accounts
* are magic and undetectable via the security subsystem. See
* http://msdn2.microsoft.com/en-us/library/ms684188.aspx
*/
printf("Running on a Post-Win2K OS, so we'll assume that the "
"LocalService account exists.\n");
user_acct = GENSRV_USERACCT;
}
} else if (0 && service_fns.LookupAccountNameA_fn(NULL, // On this system
user_acct,
NULL, &sidLen, // Don't care about the SID
NULL, &domainLen, // Don't care about the domain
&sidUse) == 0) {
/* XXXX For some reason, the above test segfaults. Fix that. */
printf("User \"%s\" doesn't seem to exist.\n", user_acct);
return -1;
} else {
printf("Will try to install service as user \"%s\".\n", user_acct);
}
/* XXXX This warning could be better about explaining how to resolve the
* situation. */
if (using_default_torrc)
printf("IMPORTANT NOTE:\n"
" The Tor service will run under the account \"%s\". This means\n"
" that Tor will look for its configuration file under that\n"
" account's Application Data directory, which is probably not\n"
" the same as yours.\n", user_acct?user_acct:"<local system>");
/* Create the Tor service, set to auto-start on boot */
if ((hService = service_fns.CreateServiceA_fn(hSCManager, GENSRV_SERVICENAME,
GENSRV_DISPLAYNAME,
SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_IGNORE,
command, NULL, NULL, NULL,
user_acct, password)) == NULL) {
errmsg = format_win32_error(GetLastError());
printf("CreateService() failed : %s\n", errmsg);
service_fns.CloseServiceHandle_fn(hSCManager);
tor_free(errmsg);
tor_free(command);
return -1;
}
printf("Done with CreateService.\n");
/* Set the service's description */
sdBuff.lpDescription = (char*)GENSRV_DESCRIPTION;
service_fns.ChangeServiceConfig2A_fn(hService, SERVICE_CONFIG_DESCRIPTION,
&sdBuff);
printf("Service installed successfully\n");
/* Start the service initially */
nt_service_start(hService);
service_fns.CloseServiceHandle_fn(hService);
service_fns.CloseServiceHandle_fn(hSCManager);
tor_free(command);
return 0;
}
tor_mmap_t *
tor_mmap_file(const char *filename)
{
TCHAR tfilename[MAX_PATH]= {0};
tor_mmap_t *res = tor_malloc_zero(sizeof(tor_mmap_t));
int empty = 0;
HANDLE file_handle = INVALID_HANDLE_VALUE;
DWORD size_low, size_high;
uint64_t real_size;
res->mmap_handle = NULL;
#ifdef UNICODE
mbstowcs(tfilename,filename,MAX_PATH);
#else
strlcpy(tfilename,filename,MAX_PATH);
#endif
file_handle = CreateFile(tfilename,
GENERIC_READ, FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
0);
if (file_handle == INVALID_HANDLE_VALUE)
goto win_err;
size_low = GetFileSize(file_handle, &size_high);
if (size_low == INVALID_FILE_SIZE && GetLastError() != NO_ERROR) {
log_warn(LD_FS,"Error getting size of \"%s\".",filename);
goto win_err;
}
if (size_low == 0 && size_high == 0) {
log_info(LD_FS,"File \"%s\" is empty. Ignoring.",filename);
empty = 1;
goto err;
}
real_size = (((uint64_t)size_high)<<32) | size_low;
if (real_size > SIZE_MAX) {
log_warn(LD_FS,"File \"%s\" is too big to map; not trying.",filename);
goto err;
}
res->size = real_size;
res->mmap_handle = CreateFileMapping(file_handle,
NULL,
PAGE_READONLY,
size_high,
size_low,
NULL);
if (res->mmap_handle == NULL)
goto win_err;
res->data = (char*) MapViewOfFile(res->mmap_handle,
FILE_MAP_READ,
0, 0, 0);
if (!res->data)
goto win_err;
CloseHandle(file_handle);
return res;
win_err: {
DWORD e = GetLastError();
int severity = (e == ERROR_FILE_NOT_FOUND || e == ERROR_PATH_NOT_FOUND) ?
LOG_INFO : LOG_WARN;
char *msg = format_win32_error(e);
log_fn(severity, LD_FS, "Couldn't mmap file \"%s\": %s", filename, msg);
tor_free(msg);
if (e == ERROR_FILE_NOT_FOUND || e == ERROR_PATH_NOT_FOUND)
errno = ENOENT;
else
errno = EINVAL;
}
err:
if (empty)
errno = ERANGE;
if (file_handle != INVALID_HANDLE_VALUE)
CloseHandle(file_handle);
tor_munmap_file(res);
return NULL;
}