static int ConnectToHost(char *host, int port, smpd_state_t state, SMPDU_Sock_set_t set, SMPDU_Sock_t *sockp, smpd_context_t **contextpp)
{
int result;
char error_msg[SMPD_MAX_ERROR_LEN];
int len;
/*printf("posting a connect to %s:%d\n", host, port);fflush(stdout);*/
result = smpd_create_context(SMPD_CONTEXT_PMI, set, SMPDU_SOCK_INVALID_SOCK/**sockp*/, -1, contextpp);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("ConnectToHost failed: unable to create a context to connect to %s:%d with.\n", host, port);
return SMPD_FAIL;
}
result = SMPDU_Sock_post_connect(set, *contextpp, host, port, sockp);
if (result != SMPD_SUCCESS)
{
len = SMPD_MAX_ERROR_LEN;
PMPI_Error_string(result, error_msg, &len);
smpd_err_printf("ConnectToHost failed: unable to post a connect to %s:%d, error: %s\n", host, port, error_msg);
return SMPD_FAIL;
}
(*contextpp)->sock = *sockp;
(*contextpp)->state = state;
result = smpd_enter_at_state(set, state);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("ConnectToHost failed: unable to connect to %s:%d.\n", host, port);
return SMPD_FAIL;
}
return SMPD_SUCCESS;
}
int smpd_set_user_data(const char *key, const char *value)
{
#ifdef HAVE_WINDOWS_H
HKEY tkey;
DWORD len, result;
char err_msg[512];
smpd_enter_fn(FCNAME);
if (key == NULL || value == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
result = RegCreateKeyEx(HKEY_CURRENT_USER, SMPD_REGISTRY_KEY,
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tkey, NULL);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result);
smpd_err_printf("%s\n", err_msg);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
len = (DWORD)(strlen(value)+1);
result = RegSetValueEx(tkey, key, 0, REG_SZ, (const BYTE *)value, len);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to write the user smpd registry value '%s:%s', error %d\n", key, value, result);
smpd_err_printf("%s\n", err_msg);
RegCloseKey(tkey);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
result = RegCloseKey(tkey);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result);
smpd_err_printf("%s\n", err_msg);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
#else
int result;
smpd_enter_fn(FCNAME);
result = smpd_set_smpd_data(key, value);
smpd_exit_fn(FCNAME);
return result;
#endif
}
int smpd_delete_user_data(const char *key)
{
#ifdef HAVE_WINDOWS_H
HKEY tkey;
DWORD result;
char err_msg[512];
smpd_enter_fn(FCNAME);
if (key == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
result = RegCreateKeyEx(HKEY_CURRENT_USER, SMPD_REGISTRY_KEY,
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &tkey, NULL);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result);
smpd_err_printf("%s\n", err_msg);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
result = RegDeleteValue(tkey, key);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to delete the user smpd registry value '%s', error %d: ", key, result);
smpd_err_printf("%s\n", err_msg);
RegCloseKey(tkey);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
result = RegCloseKey(tkey);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result);
smpd_err_printf("%s\n", err_msg);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
#else
int result;
smpd_enter_fn(FCNAME);
result = smpd_delete_smpd_data(key);
smpd_exit_fn(FCNAME);
return result;
#endif
}
int smpd_hpc_js_init(smpd_hpc_js_ctxt_t *pctxt)
{
HRESULT hr;
int result;
smpd_enter_fn(FCNAME);
if(pctxt == NULL){
smpd_err_printf("ERROR: Invalid pointer to js handle\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
/* Alloc memory for scheduler object */
*pctxt = (smpd_hpc_js_ctxt_t )MPIU_Malloc(sizeof(smpd_hpc_js_ctxt_));
if(*pctxt == NULL){
smpd_err_printf("ERROR: Unable to allocate memory for js handle\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
(*pctxt)->pscheduler = NULL;
(*pctxt)->pnode_names = NULL;
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
/* Get an instance of the Scheduler object */
hr = CoCreateInstance( __uuidof(Scheduler),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IScheduler),
reinterpret_cast<void **>(&((*pctxt)->pscheduler)));
CoUninitialize();
if (FAILED(hr)){
smpd_err_printf("ERROR: CoCreateInstance(IScheduler) failed, 0x%x\n", hr);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
/* Connect to the head node */
result = smpd_hpc_js_connect_to_head_node(*pctxt, NULL);
if(result != SMPD_SUCCESS){
smpd_err_printf("Unable to connect to head node \n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
/*
FUNCTION: smpd_service_stop
PURPOSE: Stops the service
PARAMETERS:
none
RETURN VALUE:
none
COMMENTS:
If a ServiceStop procedure is going to
take longer than 3 seconds to execute,
it should spawn a thread to execute the
stop code, and return. Otherwise, the
ServiceControlManager will believe that
the service has stopped responding.
*/
void smpd_service_stop()
{
SMPDU_Sock_set_t set;
SMPDU_Sock_t sock;
SMPDU_Sock_event_t event;
char host[SMPD_MAX_HOST_LENGTH];
int iter;
DWORD dwThreadID;
int result;
for (iter=0; iter<10; iter++)
{
smpd_process.hBombThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)smpd_bomb_thread, NULL, 0, &dwThreadID);
if (smpd_process.hBombThread != NULL)
break;
Sleep(250);
}
/* stop the main thread */
smpd_process.service_stop = SMPD_TRUE;
smpd_get_hostname(host, SMPD_MAX_HOST_LENGTH);
result = SMPDU_Sock_create_set(&set);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("SMPDU_Sock_create_set failed,\nsock error: %s\n", get_sock_error_string(result));
SetEvent(smpd_process.hBombDiffuseEvent);
WaitForSingleObject(smpd_process.hBombThread, (DWORD)3000);
CloseHandle(smpd_process.hBombThread);
ExitProcess((UINT)-1);
}
result = SMPDU_Sock_post_connect(set, NULL, host, smpd_process.port, &sock);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to connect to '%s:%d',\nsock error: %s\n",
smpd_process.host_list->host, smpd_process.port, get_sock_error_string(result));
SetEvent(smpd_process.hBombDiffuseEvent);
WaitForSingleObject(smpd_process.hBombThread, (DWORD)3000);
CloseHandle(smpd_process.hBombThread);
ExitProcess((UINT)-1);
}
result = SMPDU_Sock_wait(set, SMPDU_SOCK_INFINITE_TIME, &event);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to connect to '%s:%d',\nsock error: %s\n",
smpd_process.host_list->host, smpd_process.port, get_sock_error_string(result));
SetEvent(smpd_process.hBombDiffuseEvent);
WaitForSingleObject(smpd_process.hBombThread, (DWORD)3000);
CloseHandle(smpd_process.hBombThread);
ExitProcess((UINT)-1);
}
}
int smpd_lock_smpd_data(void)
{
smpd_enter_fn(FCNAME);
#ifdef HAVE_WINDOWS_H
if (smpd_process.hSMPDDataMutex == NULL)
{
smpd_process.hSMPDDataMutex = CreateMutex(NULL, FALSE, SMPD_DATA_MUTEX_NAME);
if (smpd_process.hSMPDDataMutex == NULL)
{
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
}
if (WaitForSingleObject(smpd_process.hSMPDDataMutex, SMPD_SHORT_TIMEOUT*1000) != WAIT_OBJECT_0)
{
smpd_err_printf("lock_smpd_data failed\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
#else
/* No lock implemented for Unix systems */
#endif
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
static int stop_root_smpd(PROCESS_HANDLE_TYPE hnd)
{
#ifdef HAVE_WINDOWS_H
DWORD result;
#else
int status;
#endif
#ifdef HAVE_WINDOWS_H
result = WaitForSingleObject(hnd, INFINITE);
if (result != WAIT_OBJECT_0){
smpd_err_printf("Error waiting for root smpd to stop\n");
return SMPD_FAIL;
}
#else
kill(PROCESS_HANDLE_GET_PID(hnd), SIGKILL);
/*
if (waitpid(PROCESS_HANDLE_GET_PID(hnd), &status, WUNTRACED) == -1)
{
return SMPD_FAIL;
}
*/
#endif
return SMPD_SUCCESS;
}
int smpd_hpc_js_finalize(smpd_hpc_js_ctxt_t *pctxt)
{
int result;
smpd_enter_fn(FCNAME);
if(pctxt == NULL){
smpd_err_printf("ERROR: Invalid pointer to js ctxt\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if(*pctxt == NULL){
smpd_dbg_printf("Null js handle\n");
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
/* Release the job scheduler object */
if((*pctxt)->pscheduler){
((*pctxt)->pscheduler)->Release();
(*pctxt)->pscheduler = NULL;
}
/* Free the job scheduler handle */
MPIU_Free(*pctxt);
*pctxt = NULL;
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
int smpd_hpc_js_task_setenv(ISchedulerTask *ptask, char *proc_encoded_env)
{
char name[SMPD_MAX_ENV_LENGTH], equals[3], value[SMPD_MAX_ENV_LENGTH];
wchar_t namew[SMPD_MAX_ENV_LENGTH], valuew[SMPD_MAX_ENV_LENGTH];
HRESULT hr;
smpd_enter_fn(FCNAME);
if((ptask == NULL) || (proc_encoded_env == NULL)){
smpd_err_printf("Invalid ptr to task or proc environment\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
for (;;){
name[0] = '\0';
equals[0] = '\0';
value[0] = '\0';
if (MPIU_Str_get_string(&proc_encoded_env, name, SMPD_MAX_ENV_LENGTH) != MPIU_STR_SUCCESS)
break;
if (name[0] == '\0')
break;
if (MPIU_Str_get_string(&proc_encoded_env, equals, 3) != MPIU_STR_SUCCESS)
break;
if (equals[0] == '\0')
break;
if (MPIU_Str_get_string(&proc_encoded_env, value, SMPD_MAX_ENV_LENGTH) != MPIU_STR_SUCCESS)
break;
smpd_dbg_printf("setting environment variable: <%s> = <%s>\n", name, value);
mbstowcs(namew, name, SMPD_MAX_ENV_LENGTH);
mbstowcs(valuew, value, SMPD_MAX_ENV_LENGTH);
hr = ptask->SetHpcEnvironmentVariable(_bstr_t(namew), _bstr_t(valuew));
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
static int start_pmi_server(int nproc, char *host, int len, int *port)
{
char cmd[100];
char line[1024];
char *argv0 = NULL;
if (smpd_process.mpiexec_argv0 != NULL)
{
argv0 = smpd_process.mpiexec_argv0;
}
sprintf(cmd, "%s -pmiserver %d", argv0, nproc);
pmi_server = popen(cmd, "r");
if (pmi_server == NULL)
{
smpd_err_printf("popen failed: %d\n", errno);
return SMPD_FAIL;
}
fgets(line, 1024, pmi_server);
strtok(line, "\r\n");
strncpy(host, line, len);
/*printf("read host: %s\n", host);*/
fgets(line, 1024, pmi_server);
*port = atoi(line);
/*printf("read port: %d\n", *port);*/
fgets(line, 1024, pmi_server);
strtok(line, "\r\n");
strncpy(smpd_process.kvs_name, line, SMPD_MAX_DBS_NAME_LEN);
/*printf("read kvs: %s\n", smpd_process.kvs_name);*/
return SMPD_SUCCESS;
}
int smpd_spn_list_finalize(smpd_spn_list_hnd_t *spn_list_hnd_p)
{
smpd_host_spn_node_t *spn_list_head, *cur_node;
smpd_enter_fn(FCNAME);
if(spn_list_hnd_p == NULL){
smpd_err_printf("Invalid pointer to spn list handle\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if(!SMPD_SPN_LIST_HND_IS_INIT(*spn_list_hnd_p)){
smpd_dbg_printf("Trying to finalize an uninitialized handle\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
spn_list_head = **spn_list_hnd_p;
while(spn_list_head != NULL){
cur_node = spn_list_head;
spn_list_head = cur_node->next;
MPIU_Free(cur_node);
}
/* Free contents of the spn handle */
MPIU_Free(*spn_list_hnd_p);
*spn_list_hnd_p = NULL;
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
int smpd_watch_processes()
{
HANDLE hThread;
char line[1024], cmd[1024];
int result;
/* turn off extra error output */
smpd_process.dbg_state ^= SMPD_DBG_STATE_TRACE;
smpd_process.dbg_state ^= SMPD_DBG_STATE_PREPEND_RANK;
hQuit = CreateEvent(NULL, TRUE, FALSE, NULL);
if (hQuit == NULL)
{
result = GetLastError();
smpd_translate_win_error(result, line, 1024, NULL);
smpd_err_printf("CreateEvent failed: %s\n", line);
goto fn_exit;
}
hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)smpd_watch_processes_thread, NULL, 0, NULL);
if (hThread == NULL)
{
printf("Unable to create a thread to watch the processes, exiting...\n");
fflush(stdout);
goto fn_exit;
}
while (fgets(line, 1024, stdin) != NULL)
{
line[1023] = '\0';
cmd[0] = '\0';
result = sscanf(line, "%s", cmd);
if (result == EOF)
{
goto fn_exit;
}
if (stricmp(cmd, "start") == 0)
{
bPrint = SMPD_TRUE;
}
if (stricmp(cmd, "stop") == 0)
{
bPrint = SMPD_FALSE;
}
if ((stricmp(cmd, "quit") == 0) || (stricmp(cmd, "exit") == 0))
{
SetEvent(hQuit);
WaitForSingleObject(hThread, INFINITE);
break;
}
}
fn_exit:
if (hThread != NULL)
CloseHandle(hThread);
if (hQuit != NULL)
CloseHandle(hQuit);
return SMPD_SUCCESS;
}
void smpd_get_password(char *password)
{
#ifdef HAVE_WINDOWS_H
HANDLE hStdin;
DWORD dwMode;
#else
struct termios terminal_settings, original_settings;
#endif
size_t len;
smpd_enter_fn(FCNAME);
#ifdef HAVE_WINDOWS_H
hStdin = GetStdHandle(STD_INPUT_HANDLE);
if (!GetConsoleMode(hStdin, &dwMode))
dwMode = ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT;
SetConsoleMode(hStdin, dwMode & ~ENABLE_ECHO_INPUT);
*password = '******';
fgets(password, 100, stdin);
SetConsoleMode(hStdin, dwMode);
fprintf(stderr, "\n");
#else
/* save the current terminal settings */
tcgetattr(STDIN_FILENO, &terminal_settings);
original_settings = terminal_settings;
/* turn off echo */
terminal_settings.c_lflag &= ~ECHO;
terminal_settings.c_lflag |= ECHONL;
tcsetattr(STDIN_FILENO, TCSAFLUSH, &terminal_settings);
/* check that echo is off */
tcgetattr(STDIN_FILENO, &terminal_settings);
if (terminal_settings.c_lflag & ECHO)
{
smpd_err_printf("\nunable to turn off the terminal echo\n");
tcsetattr(STDIN_FILENO, TCSANOW, &original_settings);
}
fgets(password, 100, stdin);
/* restore the original settings */
tcsetattr(STDIN_FILENO, TCSANOW, &original_settings);
#endif
while ((len = strlen(password)) > 0)
{
if (password[len-1] == '\r' || password[len-1] == '\n')
password[len-1] = '\0';
else
break;
}
smpd_exit_fn(FCNAME);
}
int smpd_remove_from_dynamic_hosts(void)
{
#ifndef HAVE_WINDOWS_H
char myhostname[SMPD_MAX_HOST_LENGTH];
char hosts[8192];
char hosts_less_me[8192];
char *host;
#endif
smpd_enter_fn(FCNAME);
#ifndef HAVE_WINDOWS_H
if (smpd_get_hostname(myhostname, SMPD_MAX_HOST_LENGTH) != 0)
{
smpd_err_printf("smpd_get_hostname failed, errno = %d\n", errno);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_lock_smpd_data();
hosts[0] = '\0';
if (smpd_get_smpd_data(SMPD_DYNAMIC_HOSTS_KEY, hosts, 8192) != SMPD_SUCCESS)
{
smpd_unlock_smpd_data();
smpd_dbg_printf("not removing host because "SMPD_DYNAMIC_HOSTS_KEY" does not exist\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
/* create a new hosts lists without this host name in it */
hosts_less_me[0] = '\0';
host = strtok(hosts, " \t\r\n");
while (host)
{
if (strcmp(host, myhostname))
{
if (hosts_less_me[0] != '\0')
strcat(hosts_less_me, " ");
strcat(hosts_less_me, host);
}
host = strtok(NULL, " \t\r\n");
}
if (hosts_less_me[0] == '\0')
{
smpd_dbg_printf("removing "SMPD_DYNAMIC_HOSTS_KEY"\n");
smpd_delete_smpd_data(SMPD_DYNAMIC_HOSTS_KEY);
}
else
{
smpd_dbg_printf("setting new "SMPD_DYNAMIC_HOSTS_KEY": %s\n", hosts_less_me);
smpd_set_smpd_data(SMPD_DYNAMIC_HOSTS_KEY, hosts_less_me);
}
smpd_unlock_smpd_data();
#endif
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
int smpd_lookup_spn(char *target, int length, const char *host, int port)
{
int result;
char err_msg[256];
ULONG len = length/*SMPD_MAX_NAME_LENGTH*/;
char *env;
smpd_host_spn_node_t *iter;
env = getenv("MPICH_SPN");
if (env)
{
MPIU_Strncpy(target, env, SMPD_MAX_NAME_LENGTH);
return SMPD_SUCCESS;
}
smpd_build_spn_list();
iter = spn_list;
while (iter != NULL)
{
if (stricmp(iter->host, host) == 0)
{
MPIU_Strncpy(target, iter->spn, SMPD_MAX_NAME_LENGTH);
return SMPD_SUCCESS;
}
if (stricmp(iter->dnshost, host) == 0)
{
MPIU_Strncpy(target, iter->spn, SMPD_MAX_NAME_LENGTH);
return SMPD_SUCCESS;
}
iter = iter->next;
}
result = DsMakeSpn(SMPD_SERVICE_NAME, NULL, host, (USHORT)port, NULL, &len, target);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 255, NULL);
smpd_err_printf("DsMakeSpn(%s, %s, %d) failed: %s\n", SMPD_SERVICE_NAME, host, port, err_msg);
return SMPD_FAIL;
}
/*result = DsMakeSpn(SMPD_SERVICE_NAME, SMPD_SERVICE_NAME, NULL, 0, NULL, &len, target);*/
/*
char **spns;
result = DsGetSpn(DS_SPN_DNS_HOST, SMPD_SERVICE_NAME, NULL, port, 1, &host, NULL, &len, &spns);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 255, NULL);
smpd_err_printf("DsGetSpn failed: %s\n", err_msg);
return SMPD_FAIL;
}
MPIU_Strncpy(target, spns[0], SMPD_MAX_NAME_LENGTH);
DsFreeSpnArray(1, spns);
*/
/*MPIU_Snprintf(target, SMPD_MAX_NAME_LENGTH, "%s/%s:%d", SMPD_SERVICE_NAME, host, port);*/
return SMPD_SUCCESS;
}
int smpd_generate_session_header(char *str, int session_id)
{
char * str_orig;
int result;
int len;
smpd_enter_fn(FCNAME);
str_orig = str;
*str = '\0';
len = SMPD_MAX_SESSION_HEADER_LENGTH;
/* add header fields */
result = MPIU_Str_add_int_arg(&str, &len, "id", session_id);
if (result != MPIU_STR_SUCCESS)
{
smpd_err_printf("unable to create session header, adding session id failed.\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
result = MPIU_Str_add_int_arg(&str, &len, "parent", smpd_process.id);
if (result != MPIU_STR_SUCCESS)
{
smpd_err_printf("unable to create session header, adding parent id failed.\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
result = MPIU_Str_add_int_arg(&str, &len, "level", smpd_process.level + 1);
if (result != MPIU_STR_SUCCESS)
{
smpd_err_printf("unable to create session header, adding session level failed.\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
/* remove the trailing space */
str--;
*str = '\0';
smpd_dbg_printf("session header: (%s)\n", str_orig);
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
int smpd_hpc_js_submit_job(smpd_hpc_js_ctxt_t ctxt, ISchedulerJob *pjob)
{
int result;
HRESULT hr;
smpd_enter_fn(FCNAME);
if(!SMPDU_HPC_JS_CTXT_IS_VALID(ctxt)){
smpd_err_printf("ERROR: Invalid handle to hpc job scheduler\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
hr = (ctxt->pscheduler)->SubmitJob(pjob, NULL, NULL);
if(FAILED(hr)){
smpd_err_printf("ERROR: Submitting job failed, 0x%x\n", hr);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
int smpd_get_user_data(const char *key, char *value, int value_len)
{
#ifdef HAVE_WINDOWS_H
HKEY tkey;
DWORD len, result;
char err_msg[512];
smpd_enter_fn(FCNAME);
result = RegOpenKeyEx(HKEY_CURRENT_USER, SMPD_REGISTRY_KEY, 0, KEY_READ, &tkey);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to open the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d\n", result);
smpd_dbg_printf("%s\n", err_msg);
result = smpd_get_user_data_default(key, value, value_len);
smpd_exit_fn(FCNAME);
return result;
}
len = value_len;
result = RegQueryValueEx(tkey, key, 0, NULL, (unsigned char *)value, &len);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to read the smpd registry key '%s', error %d\n", key, result);
smpd_dbg_printf("%s\n", err_msg);
RegCloseKey(tkey);
result = smpd_get_user_data_default(key, value, value_len);
smpd_exit_fn(FCNAME);
return result;
}
result = RegCloseKey(tkey);
if (result != ERROR_SUCCESS)
{
smpd_translate_win_error(result, err_msg, 512, "Unable to close the HKEY_CURRENT_USER\\" SMPD_REGISTRY_KEY " registry key, error %d: ", result);
smpd_err_printf("%s\n", err_msg);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
#else
int result;
smpd_enter_fn(FCNAME);
result = smpd_get_smpd_data(key, value, value_len);
if (result != SMPD_SUCCESS)
{
result = smpd_get_user_data_default(key, value, value_len);
}
smpd_exit_fn(FCNAME);
return result;
#endif
}
static int stop_pmi_server()
{
if (pmi_server != NULL)
{
if (pclose(pmi_server) == -1)
{
smpd_err_printf("pclose failed: %d\n", errno);
return SMPD_FAIL;
}
}
return SMPD_SUCCESS;
}
int smpd_dbs_getNextKeyVal(smpd_dbsIter_t *pIter, char *key, char *value){
smpd_enter_fn(FCNAME);
if(!pIter || !(*pIter) || !key || !value){
/* FIXME: Desc error msgs ?*/
smpd_err_printf("Invalid args to smpd_dbs_getNextKeyVal()\n");
return SMPD_DBS_FAIL;
}
MPIU_Strncpy(key, (*pIter)->pszKey, SMPD_MAX_DBS_KEY_LEN);
MPIU_Strncpy(value, (*pIter)->pszValue, SMPD_MAX_DBS_VALUE_LEN);
(*pIter) = (*pIter)->pNext;
smpd_exit_fn(FCNAME);
return SMPD_DBS_SUCCESS;
}
void *timeout_thread(void *p)
{
SMPDU_Size_t num_written;
char ch = -1;
sleep(smpd_process.timeout);
smpd_err_printf("\nmpiexec terminated job due to %d second timeout.\n", smpd_process.timeout);
if (smpd_process.timeout_sock != SMPDU_SOCK_INVALID_SOCK)
{
SMPDU_Sock_write(smpd_process.timeout_sock, &ch, 1, &num_written);
sleep(30); /* give the engine 30 seconds to shutdown and then force an exit */
}
exit(-1);
}
int smpd_hpc_js_connect_to_head_node(smpd_hpc_js_ctxt_t ctxt, smpd_host_node_t **head_node)
{
HRESULT hr;
smpd_enter_fn(FCNAME);
if(!SMPDU_HPC_JS_CTXT_IS_VALID(ctxt)){
smpd_err_printf("ERROR: Invalid handle to hpc job scheduler\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
/* FIXME: Currently we ignore the head node passed. Ideally
* we should use AD to find the head node and connect to it.
* We just connect to the localhost now
*/
hr = (ctxt->pscheduler)->Connect(_bstr_t(L"localhost"));
if(FAILED(hr)){
smpd_err_printf("ERROR: Unable to connect to the head node of the cluster, 0x%x\n", hr);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
void timeout_function(int signo)
{
SMPDU_Size_t num_written;
char ch = -1;
static int alarmed = 0;
if (signo == SIGALRM)
{
if (smpd_process.timeout_sock != SMPDU_SOCK_INVALID_SOCK && alarmed == 0)
{
alarmed = 1;
smpd_err_printf("\nmpiexec terminated job due to %d second timeout.\n", smpd_process.timeout);
SMPDU_Sock_write(smpd_process.timeout_sock, &ch, 1, &num_written);
alarm(30); /* give the engine 30 seconds to shutdown and then force an exit */
}
else
{
if (alarmed == 0)
{
smpd_err_printf("\nmpiexec terminated job due to %d second timeout.\n", smpd_process.timeout);
}
exit(-1);
}
}
}
void timeout_thread(void *p)
{
SMPDU_Size_t num_written;
char ch = -1;
SMPD_UNREFERENCED_ARG(p);
Sleep(smpd_process.timeout * 1000);
smpd_err_printf("\nmpiexec terminated job due to %d second timeout.\n", smpd_process.timeout);
if (smpd_process.timeout_sock != SMPDU_SOCK_INVALID_SOCK)
{
SMPDU_Sock_write(smpd_process.timeout_sock, &ch, 1, &num_written);
Sleep(30000); /* give the engine 30 seconds to shutdown and then force an exit */
}
ExitProcess((UINT)-1);
}
int smpd_unlock_smpd_data(void)
{
smpd_enter_fn(FCNAME);
#ifdef HAVE_WINDOWS_H
if (!ReleaseMutex(smpd_process.hSMPDDataMutex))
{
int result;
char err_msg[512];
result = GetLastError();
smpd_translate_win_error(result, err_msg, 512, "Unable to release the SMPD data mutex, error %d: ", result);
smpd_err_printf("%s\n", err_msg);
return SMPD_FAIL;
}
#else
/* No lock implemented for Unix systems */
#endif
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
int smpd_dbsIter_init(const char *name, smpd_dbsIter_t *pIter){
smpd_database_node_t *pDBNode;
int nameLen = 0;
smpd_enter_fn(FCNAME);
if(!name || !pIter){
smpd_err_printf("Invalid args to smpd_dbsIter_init()\n");
return SMPD_DBS_FAIL;
}
nameLen = strlen(name);
pDBNode = smpd_process.pDatabase;
while(pDBNode){
if(strncmp(pDBNode->pszName, name, nameLen) == 0){
*pIter = pDBNode->pData;
return SMPD_DBS_SUCCESS;
}
pDBNode = pDBNode->pNext;
}
smpd_exit_fn(FCNAME);
return SMPD_DBS_FAIL;
}
int smpd_tprintf_templ(smpd_printf_fp_t fp, TCHAR *str, ...){
char *str_mb = NULL;
int len = 0;
int result = 0;
va_list args;
len = _tcslen(str) * sizeof(TCHAR) + 1;
str_mb = (char *)MPIU_Malloc(len);
if(str_mb == NULL){
smpd_err_printf("Unable to allocate memory for temp buffer\n");
return 0;
}
SMPDU_TCSTOMBS(str_mb, str, len);
va_start(args, str);
fp(str_mb, args);
va_end(args);
MPIU_Free(str_mb);
return result;
}
int smpd_lookup_spn_list(smpd_spn_list_hnd_t hnd, char *target, int length, const char *fq_name, int port)
{
int result = SMPD_SUCCESS;
char err_msg[256];
ULONG len = length/*SMPD_MAX_NAME_LENGTH*/;
char *env;
smpd_host_spn_node_t *iter;
smpd_enter_fn(FCNAME);
if(!SMPD_SPN_LIST_HND_IS_INIT(hnd)){
smpd_err_printf("Invalid handle to spn list \n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_spn_list_dbg_print(hnd); fflush(stdout);
env = getenv("MPICH_SPN");
if (env){
MPIU_Strncpy(target, env, SMPD_MAX_NAME_LENGTH);
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
/* smpd_build_spn_list(); */
iter = (smpd_host_spn_node_t *) (*hnd);
while (iter != NULL){
if (stricmp(iter->fq_service_name, fq_name) == 0){
MPIU_Strncpy(target, iter->spn, length);
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
iter = iter->next;
}
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
int smpd_parse_command_args(int *argcp, char **argvp[])
{
int result = 0;
#ifdef HAVE_WINDOWS_H
char str[20], read_handle_str[20], write_handle_str[20];
int port;
SMPDU_Sock_t listener;
SMPDU_Sock_set_t set;
HANDLE hWrite, hRead;
DWORD num_written, num_read;
#endif
int dbg_flag;
char domain[SMPD_MAX_HOST_LENGTH];
char opt[SMPD_MAX_NAME_LENGTH];
char opt_val[SMPD_MAX_VALUE_LENGTH];
char filename[SMPD_MAX_FILENAME];
int i;
smpd_enter_fn(FCNAME);
/* check for help option */
if (
#ifndef HAVE_WINDOWS_H
*argcp < 2 || /* unix: print the options if no arguments are supplied */
#endif
smpd_get_opt(argcp, argvp, "-help") || smpd_get_opt(argcp, argvp, "-?"))
{
smpd_print_options();
smpd_exit(0);
}
/* check for the printprocs option */
if (smpd_get_opt(argcp, argvp, "-printprocs"))
{
smpd_watch_processes();
smpd_exit(0);
}
if (smpd_get_opt(argcp, argvp, "-hosts"))
{
char first_host[SMPD_MAX_HOST_LENGTH], host[SMPD_MAX_HOST_LENGTH], alt_host[SMPD_MAX_HOST_LENGTH];
smpd_get_default_hosts();
result = smpd_get_next_hostname(first_host, alt_host);
if (result != SMPD_SUCCESS)
smpd_exit(result);
printf("%s\n", first_host);
result = smpd_get_next_hostname(host, alt_host);
if (result != SMPD_SUCCESS)
smpd_exit(result);
while (strcmp(host, first_host) != 0)
{
printf("%s\n", host);
result = smpd_get_next_hostname(host, alt_host);
if (result != SMPD_SUCCESS)
smpd_exit(result);
}
smpd_exit(0);
}
if (smpd_get_opt(argcp, argvp, "-sethosts"))
{
char *buffer, *iter;
int i, length;
length = (*argcp) * SMPD_MAX_HOST_LENGTH;
buffer = MPIU_Malloc(length);
if (buffer == NULL)
{
smpd_err_printf("unable to allocate memory to store the host names.\n");
smpd_exit(-1);
}
iter = buffer;
for (i=1; i<*argcp; i++)
{
result = MPIU_Str_add_string(&iter, &length, (*argvp)[i]);
if (result)
{
printf("unable to add host #%d, %s\n", i, (*argvp)[i]);
MPIU_Free(buffer);
smpd_exit(-1);
}
}
/*printf("hosts: %s\n", buffer);*/
result = smpd_set_smpd_data("hosts", buffer);
if (result == SMPD_SUCCESS)
{
printf("hosts data saved successfully.\n");
}
else
{
printf("Error: unable to save the hosts data.\n");
}
MPIU_Free(buffer);
smpd_exit(0);
}
if (smpd_get_opt_two_strings(argcp, argvp, "-set", opt, SMPD_MAX_NAME_LENGTH, opt_val, SMPD_MAX_VALUE_LENGTH))
{
/* The do loop allows for multiple -set operations to be specified on the command line */
do
{
if (strlen(opt) == 0)
{
printf("invalid option specified.\n");
smpd_exit(-1);
}
if (strlen(opt_val) == 0)
{
result = smpd_delete_smpd_data(opt);
}
else
{
result = smpd_set_smpd_data(opt, opt_val);
}
if (result == SMPD_SUCCESS)
{
printf("%s = %s\n", opt, opt_val);
}
else
{
printf("unable to set %s option.\n", opt);
}
} while (smpd_get_opt_two_strings(argcp, argvp, "-set", opt, SMPD_MAX_NAME_LENGTH, opt_val, SMPD_MAX_VALUE_LENGTH));
smpd_exit(0);
}
if (smpd_get_opt_string(argcp, argvp, "-get", opt, SMPD_MAX_NAME_LENGTH))
{
if (strlen(opt) == 0)
{
printf("invalid option specified.\n");
smpd_exit(-1);
}
result = smpd_get_smpd_data(opt, opt_val, SMPD_MAX_VALUE_LENGTH);
if (result == SMPD_SUCCESS)
{
printf("%s\n", opt_val);
}
else
{
printf("default\n");
}
smpd_exit(0);
}
/* If we've made it here and there still is "-set" or "-get" on the command line then the user
* probably didn't supply the correct number of parameters. So print the usage message
* and exit.
*/
if (smpd_get_opt(argcp, argvp, "-set") || smpd_get_opt(argcp, argvp, "-get"))
{
smpd_print_options();
smpd_exit(-1);
}
if (smpd_get_opt(argcp, argvp, "-enumerate") || smpd_get_opt(argcp, argvp, "-enum"))
{
smpd_data_t *data;
if (smpd_get_all_smpd_data(&data) == SMPD_SUCCESS)
{
smpd_data_t *iter = data;
while (iter != NULL)
{
printf("%s\n%s\n", iter->name, iter->value);
iter = iter->next;
}
while (data != NULL)
{
iter = data;
data = data->next;
MPIU_Free(iter);
}
}
smpd_exit(0);
}
if (smpd_get_opt_string(argcp, argvp, "-query", domain, SMPD_MAX_HOST_LENGTH))
{
printf("querying hosts in the %s domain:\n", domain);
printf("Not implemented.\n");
smpd_exit(0);
}
if (smpd_get_opt(argcp, argvp, "-query"))
{
printf("querying hosts in the default domain:\n");
printf("Not implemented.\n");
smpd_exit(0);
}
/* check for the service/silent option */
#ifdef HAVE_WINDOWS_H
smpd_process.bService = SMPD_TRUE;
#endif
if (smpd_get_opt(argcp, argvp, "-s"))
{
#ifdef HAVE_WINDOWS_H
printf("The -s option is only available under unix.\n");
smpd_print_options();
smpd_exit(0);
#else
smpd_process.bNoTTY = SMPD_TRUE;
#endif
}
if (smpd_get_opt(argcp, argvp, "-r"))
{
#ifdef HAVE_WINDOWS_H
printf("The -r option is only available under unix.\n");
smpd_print_options();
#else
printf("The -r root option is not yet implemented.\n");
#endif
smpd_exit(0);
}
/* check for debug option */
if (smpd_get_opt_int(argcp, argvp, "-d", &dbg_flag))
{
smpd_process.dbg_state = dbg_flag;
smpd_process.bNoTTY = SMPD_FALSE;
smpd_process.bService = SMPD_FALSE;
}
if (smpd_get_opt(argcp, argvp, "-d"))
{
smpd_process.dbg_state = SMPD_DBG_STATE_ERROUT | SMPD_DBG_STATE_STDOUT | SMPD_DBG_STATE_PREPEND_RANK | SMPD_DBG_STATE_TRACE;
smpd_process.bNoTTY = SMPD_FALSE;
smpd_process.bService = SMPD_FALSE;
}
if (smpd_get_opt_int(argcp, argvp, "-debug", &dbg_flag))
{
smpd_process.dbg_state = dbg_flag;
smpd_process.bNoTTY = SMPD_FALSE;
smpd_process.bService = SMPD_FALSE;
}
if (smpd_get_opt(argcp, argvp, "-debug"))
{
smpd_process.dbg_state = SMPD_DBG_STATE_ERROUT | SMPD_DBG_STATE_STDOUT | SMPD_DBG_STATE_PREPEND_RANK | SMPD_DBG_STATE_TRACE;
smpd_process.bNoTTY = SMPD_FALSE;
smpd_process.bService = SMPD_FALSE;
}
/* check for port option */
smpd_get_opt_int(argcp, argvp, "-p", &smpd_process.port);
smpd_get_opt_int(argcp, argvp, "-port", &smpd_process.port);
if (smpd_get_opt(argcp, argvp, "-anyport"))
{
smpd_process.port = 0;
smpd_process.dbg_state = 0; /* turn of debugging or you won't be able to read the port from stdout */
smpd_process.bNoTTY = SMPD_FALSE;
smpd_process.bService = SMPD_FALSE;
}
smpd_process.noprompt = smpd_get_opt(argcp, argvp, "-noprompt");
#ifdef HAVE_WINDOWS_H
/* check for service options */
if (smpd_get_opt(argcp, argvp, "-remove") ||
smpd_get_opt(argcp, argvp, "-unregserver") ||
smpd_get_opt(argcp, argvp, "-uninstall") ||
smpd_get_opt(argcp, argvp, "/Remove") ||
smpd_get_opt(argcp, argvp, "/Uninstall"))
{
/*RegDeleteKey(HKEY_CURRENT_USER, MPICHKEY);*/
smpd_remove_service(SMPD_TRUE);
ExitProcess(0);
}
if (smpd_get_opt(argcp, argvp, "-install") ||
smpd_get_opt(argcp, argvp, "-regserver") ||
smpd_get_opt(argcp, argvp, "/Install") ||
smpd_get_opt(argcp, argvp, "/install") ||
smpd_get_opt(argcp, argvp, "/RegServer"))
{
char phrase[SMPD_PASSPHRASE_MAX_LENGTH]="", port_str[SMPD_MAX_PORT_STR_LENGTH]="";
if (smpd_remove_service(SMPD_FALSE) == SMPD_FALSE)
{
printf("Unable to remove the previous installation, install failed.\n");
ExitProcess(0);
}
if (smpd_get_opt_string(argcp, argvp, "-phrase", phrase, SMPD_PASSPHRASE_MAX_LENGTH) ||
smpd_get_win_opt_string(argcp, argvp, "/phrase", phrase, SMPD_PASSPHRASE_MAX_LENGTH))
{
smpd_set_smpd_data("phrase", phrase);
}
if (smpd_get_opt(argcp, argvp, "-getphrase"))
{
printf("passphrase for smpd: ");fflush(stdout);
smpd_get_password(phrase);
smpd_set_smpd_data("phrase", phrase);
}
if (smpd_process.port != SMPD_LISTENER_PORT)
{
snprintf(port_str, SMPD_MAX_PORT_STR_LENGTH, "%d", smpd_process.port);
smpd_set_smpd_data("port", port_str);
}
smpd_install_service(SMPD_FALSE, SMPD_TRUE, smpd_get_opt(argcp, argvp, "-delegation"));
smpd_set_smpd_data("version", SMPD_VERSION);
ExitProcess(0);
}
if (smpd_get_opt(argcp, argvp, "-start"))
{
smpd_start_service();
ExitProcess(0);
}
if (smpd_get_opt(argcp, argvp, "-stop"))
{
smpd_stop_service();
ExitProcess(0);
}
if (smpd_get_opt(argcp, argvp, "-register_spn"))
{
char filename[SMPD_MAX_FILENAME];
if(smpd_get_opt_string(argcp, argvp, "-f", filename, SMPD_MAX_FILENAME)){
result = smpd_setup_scps_with_file(filename);
if(result != SMPD_SUCCESS){
printf("Failed to register smpd's Service Principal Names (at least one failed) with Domain Controller\n");
ExitProcess((UINT )-1);
}
}
else{
result = smpd_setup_scp(NULL);
if(result != SMPD_SUCCESS){
printf("Failed to register smpd's Service Principal Name with Domain Controller\n");
ExitProcess((UINT )-1);
}
}
printf("Service Principal Name registered with the domain controller.\n");
printf("SMPD is now capable of launching processes using passwordless delegation.\n");
printf("The system administrator must ensure the following:\n");
printf(" 1) This host is trusted for delegation in Active Directory\n");
printf(" 2) All users who will run jobs are trusted for delegation.\n");
printf("Domain administrators can enable these options for hosts and users\nin Active Directory on the domain controller.\n");
ExitProcess(0);
}
if (smpd_get_opt(argcp, argvp, "-remove_spn"))
{
char filename[SMPD_MAX_FILENAME];
smpd_spn_list_hnd_t hnd;
result = smpd_spn_list_init(&hnd);
if(result != SMPD_SUCCESS){
printf("Unable to initialize SPN list\n");
ExitProcess((UINT ) -1);
}
if(smpd_get_opt_string(argcp, argvp, "-f", filename, SMPD_MAX_FILENAME)){
result = smpd_remove_scps_with_file(filename, hnd);
if(result != SMPD_SUCCESS){
printf("Failed to remove smpd's Service Principal Names (at least one failed) with Domain Controller\n");
ExitProcess((UINT )-1);
}
printf("Removed smpd's Service Principal Names successfully\n");
}
else{
result = smpd_remove_scp(NULL, hnd);
if(result != SMPD_SUCCESS){
printf("Failed to remove smpd's Service Principal Name with Domain Controller\n");
ExitProcess((UINT )-1);
}
printf("Removed smpd's Service Principal Name successfully\n");
}
smpd_spn_list_finalize(&hnd);
ExitProcess(0);
}
if (smpd_get_opt(argcp, argvp, "-mgr"))
{
/* Set a ctrl-handler to kill child processes if this smpd is killed */
if (!SetConsoleCtrlHandler(smpd_ctrl_handler, TRUE))
{
result = GetLastError();
smpd_dbg_printf("unable to set the ctrl handler for the smpd manager, error %d.\n", result);
}
#ifdef HAVE_WINDOWS_H
{
BOOL ret;
ret = smpd_init_affinity_table();
if(!ret){
smpd_dbg_printf("Initializing smpd affinity table failed\n");
}
}
#endif
smpd_process.bService = SMPD_FALSE;
if (!smpd_get_opt_string(argcp, argvp, "-read", read_handle_str, 20))
{
smpd_err_printf("manager started without a read pipe handle.\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if (!smpd_get_opt_string(argcp, argvp, "-write", write_handle_str, 20))
{
smpd_err_printf("manager started without a write pipe handle.\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
hRead = smpd_decode_handle(read_handle_str);
hWrite = smpd_decode_handle(write_handle_str);
smpd_dbg_printf("manager creating listener and session sets.\n");
result = SMPDU_Sock_create_set(&set);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("SMPDU_Sock_create_set(listener) failed,\nsock error: %s\n", get_sock_error_string(result));
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_process.set = set;
smpd_dbg_printf("created set for manager listener, %d\n", SMPDU_Sock_get_sock_set_id(set));
port = 0;
result = SMPDU_Sock_listen(set, NULL, &port, &listener);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("SMPDU_Sock_listen failed,\nsock error: %s\n", get_sock_error_string(result));
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_dbg_printf("smpd manager listening on port %d\n", port);
result = smpd_create_context(SMPD_CONTEXT_LISTENER, set, listener, -1, &smpd_process.listener_context);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("unable to create a context for the smpd listener.\n");
smpd_exit_fn(FCNAME);
return result;
}
result = SMPDU_Sock_set_user_ptr(listener, smpd_process.listener_context);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("SMPDU_Sock_set_user_ptr failed,\nsock error: %s\n", get_sock_error_string(result));
smpd_exit_fn(FCNAME);
return result;
}
smpd_process.listener_context->state = SMPD_MGR_LISTENING;
memset(str, 0, 20);
snprintf(str, 20, "%d", port);
smpd_dbg_printf("manager writing port back to smpd.\n");
if (!WriteFile(hWrite, str, 20, &num_written, NULL))
{
smpd_err_printf("WriteFile failed, error %d\n", GetLastError());
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
CloseHandle(hWrite);
if (num_written != 20)
{
smpd_err_printf("wrote only %d bytes of 20\n", num_written);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_dbg_printf("manager reading account and password from smpd.\n");
if (!ReadFile(hRead, smpd_process.UserAccount, SMPD_MAX_ACCOUNT_LENGTH, &num_read, NULL))
{
smpd_err_printf("ReadFile failed, error %d\n", GetLastError());
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if (num_read != SMPD_MAX_ACCOUNT_LENGTH)
{
smpd_err_printf("read only %d bytes of %d\n", num_read, SMPD_MAX_ACCOUNT_LENGTH);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if (!ReadFile(hRead, smpd_process.UserPassword, SMPD_MAX_PASSWORD_LENGTH, &num_read, NULL))
{
smpd_err_printf("ReadFile failed, error %d\n", GetLastError());
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if (num_read != SMPD_MAX_PASSWORD_LENGTH)
{
smpd_err_printf("read only %d bytes of %d\n", num_read, SMPD_MAX_PASSWORD_LENGTH);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if (!ReadFile(hRead, smpd_process.passphrase, SMPD_PASSPHRASE_MAX_LENGTH, &num_read, NULL))
{
smpd_err_printf("ReadFile failed, error %d\n", GetLastError());
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
if (num_read != SMPD_PASSPHRASE_MAX_LENGTH)
{
smpd_err_printf("read only %d bytes of %d\n", num_read, SMPD_PASSPHRASE_MAX_LENGTH);
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
smpd_process.credentials_prompt = SMPD_FALSE;
result = smpd_enter_at_state(set, SMPD_MGR_LISTENING);
if (result != SMPD_SUCCESS)
{
smpd_err_printf("state machine failed.\n");
}
/*
result = SMPDU_Sock_finalize();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("SMPDU_Sock_finalize failed,\nsock error: %s\n", get_sock_error_string(result));
}
*/
smpd_exit(0);
smpd_exit_fn(FCNAME);
ExitProcess(0);
}
#endif
/* check for the status option */
if (smpd_get_opt_string(argcp, argvp, "-status", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
{
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_DO_STATUS;
}
else if (smpd_get_opt(argcp, argvp, "-status"))
{
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_DO_STATUS;
}
/* check for console options */
if (smpd_get_opt_string(argcp, argvp, "-console", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
{
smpd_process.do_console = 1;
}
else if (smpd_get_opt(argcp, argvp, "-console"))
{
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
}
if (smpd_process.do_console)
{
/* This may need to be changed to avoid conflict */
if (smpd_get_opt(argcp, argvp, "-p"))
{
smpd_process.use_process_session = 1;
}
}
if (smpd_get_opt_string(argcp, argvp, "-shutdown", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
{
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_SHUTDOWN;
}
else if (smpd_get_opt(argcp, argvp, "-shutdown"))
{
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_SHUTDOWN;
}
if (smpd_get_opt_string(argcp, argvp, "-restart", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
{
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_RESTART;
}
else if (smpd_get_opt(argcp, argvp, "-restart"))
{
#ifdef HAVE_WINDOWS_H
printf("restarting the smpd service...\n");
smpd_stop_service();
Sleep(1000);
smpd_start_service();
smpd_exit(0);
#else
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_RESTART;
#endif
}
if (smpd_get_opt_string(argcp, argvp, "-version", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
{
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_VERSION;
}
else if (smpd_get_opt(argcp, argvp, "-version"))
{
printf("%s\n", SMPD_VERSION);
fflush(stdout);
smpd_exit(0);
}
/* These commands are handled by mpiexec although doing them here is an alternate solution.
if (smpd_get_opt_two_strings(argcp, argvp, "-add_job", smpd_process.job_key, SMPD_MAX_NAME_LENGTH, smpd_process.job_key_account, SMPD_MAX_ACCOUNT_LENGTH))
{
if (!smpd_get_opt_string(argcp, argvp, "-host", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
if (smpd_get_opt_string(argcp, argvp, "-password", smpd_process.job_key_password, SMPD_MAX_PASSWORD_LENGTH)
smpd_process.builtin_cmd = SMPD_CMD_ADD_JOB_KEY_AND_PASSWORD;
else
smpd_process.builtin_cmd = SMPD_CMD_ADD_JOB_KEY;
smpd_process.do_console = 1;
}
if (smpd_get_opt_string(argcp, argvp, "-remove_job", smpd_process.job_key, SMPD_MAX_NAME_LENGTH))
{
if (!smpd_get_opt_string(argcp, argvp, "-host", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_REMOVE_JOB_KEY;
}
if (smpd_get_opt_string(argcp, argvp, "-associate_job", smpd_process.job_key, SMPD_MAX_NAME_LENGTH))
{
if (!smpd_get_opt_string(argcp, argvp, "-host", smpd_process.console_host, SMPD_MAX_HOST_LENGTH))
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_ASSOCIATE_JOB_KEY;
}
*/
smpd_get_opt_string(argcp, argvp, "-phrase", smpd_process.passphrase, SMPD_PASSPHRASE_MAX_LENGTH);
if (smpd_get_opt(argcp, argvp, "-getphrase"))
{
printf("passphrase for smpd: ");fflush(stdout);
smpd_get_password(smpd_process.passphrase);
}
if (smpd_get_opt_string(argcp, argvp, "-smpdfile", smpd_process.smpd_filename, SMPD_MAX_FILENAME))
{
struct stat s;
if (stat(smpd_process.smpd_filename, &s) == 0)
{
if (s.st_mode & 00077)
{
printf(".smpd file cannot be readable by anyone other than the current user.\n");
smpd_exit_fn(FCNAME);
return SMPD_FAIL;
}
}
}
if (smpd_get_opt_string(argcp, argvp, "-traceon", filename, SMPD_MAX_FILENAME))
{
smpd_process.do_console_returns = SMPD_TRUE;
if (*argcp > 1)
{
for (i=1; i<*argcp; i++)
{
strcpy(smpd_process.console_host, (*argvp)[i]);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_SET;
strcpy(smpd_process.key, "logfile");
strcpy(smpd_process.val, filename);
result = smpd_do_console();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to set the logfile name on host '%s'\n", smpd_process.console_host);
smpd_exit_fn(FCNAME);
return result;
}
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_SET;
strcpy(smpd_process.key, "log");
strcpy(smpd_process.val, "yes");
result = smpd_do_console();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to set the log option on host '%s'\n", smpd_process.console_host);
smpd_exit_fn(FCNAME);
return result;
}
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_RESTART;
result = smpd_do_console();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to restart the smpd on host '%s'\n", smpd_process.console_host);
smpd_exit_fn(FCNAME);
return result;
}
}
}
else
{
result = smpd_set_smpd_data("logfile", filename);
result = smpd_set_smpd_data("log", "yes");
#ifdef HAVE_WINDOWS_H
printf("restarting the smpd service...\n");
smpd_stop_service();
Sleep(1000);
smpd_start_service();
#else
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_RESTART;
result = smpd_do_console();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to restart the smpd on host '%s'\n", smpd_process.console_host);
smpd_exit_fn(FCNAME);
return result;
}
#endif
}
smpd_exit_fn(FCNAME);
smpd_exit(result);
}
if (smpd_get_opt(argcp, argvp, "-traceoff"))
{
smpd_process.do_console_returns = SMPD_TRUE;
if (*argcp > 1)
{
for (i=1; i<*argcp; i++)
{
strcpy(smpd_process.console_host, (*argvp)[i]);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_SET;
strcpy(smpd_process.key, "log");
strcpy(smpd_process.val, "no");
result = smpd_do_console();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to set the log option on host '%s'\n", smpd_process.console_host);
smpd_exit_fn(FCNAME);
return result;
}
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_RESTART;
result = smpd_do_console();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to restart the smpd on host '%s'\n", smpd_process.console_host);
smpd_exit_fn(FCNAME);
return result;
}
}
}
else
{
result = smpd_set_smpd_data("log", "no");
#ifdef HAVE_WINDOWS_H
printf("restarting the smpd service...\n");
smpd_stop_service();
Sleep(1000);
smpd_start_service();
#else
smpd_get_hostname(smpd_process.console_host, SMPD_MAX_HOST_LENGTH);
smpd_process.do_console = 1;
smpd_process.builtin_cmd = SMPD_CMD_RESTART;
result = smpd_do_console();
if (result != SMPD_SUCCESS)
{
smpd_err_printf("Unable to restart the smpd on host '%s'\n", smpd_process.console_host);
smpd_exit_fn(FCNAME);
return result;
}
#endif
}
smpd_exit_fn(FCNAME);
smpd_exit(result);
}
if (smpd_process.do_console)
{
result = smpd_do_console();
smpd_exit_fn(FCNAME);
return result;
}
smpd_exit_fn(FCNAME);
return SMPD_SUCCESS;
}
static HRESULT GetGCSearch(IDirectorySearch **ppDS)
{
HRESULT hr;
IEnumVARIANT *pEnum = NULL;
IADsContainer *pCont = NULL;
IDispatch *pDisp = NULL;
VARIANT var;
ULONG lFetch;
*ppDS = NULL;
/* Bind to the GC: namespace container object. The true GC DN
is a single immediate child of the GC: namespace, which must
be obtained using enumeration. */
hr = ADsOpenObject(L"GC:", NULL, NULL, ADS_SECURE_AUTHENTICATION, /* Use Secure Authentication. */
IID_IADsContainer,
(void**)&pCont);
if (FAILED(hr))
{
smpd_err_printf("ADsOpenObject failed: 0x%x\n", hr);
goto cleanup;
}
/* Get an enumeration interface for the GC container. */
hr = ADsBuildEnumerator(pCont, &pEnum);
if (FAILED(hr))
{
smpd_err_printf("ADsBuildEnumerator failed: 0x%x\n", hr);
goto cleanup;
}
/* Now enumerate. There is only one child of the GC: object. */
hr = ADsEnumerateNext(pEnum, 1, &var, &lFetch);
if (FAILED(hr))
{
smpd_err_printf("ADsEnumerateNext failed: 0x%x\n", hr);
goto cleanup;
}
if ((hr == S_OK) && (lFetch == 1))
{
pDisp = V_DISPATCH(&var);
hr = pDisp->QueryInterface(IID_IDirectorySearch, (void**)ppDS);
}
cleanup:
if (pEnum)
{
ADsFreeEnumerator(pEnum);
pEnum = NULL;
}
if (pCont)
{
pCont->Release();
pCont = NULL;
}
if (pDisp)
{
pDisp->Release();
pDisp = NULL;
}
return hr;
}
