/**
* @brief
* -returns the default server name.
*
* @return string
* @retval dflt srvr name success
* @retval NULL error
*
*/
char *
__pbs_default()
{
char dflt_server[PBS_MAXSERVERNAME+1];
struct pbs_client_thread_context *p;
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return NULL;
p = pbs_client_thread_get_context_data();
if (pbs_loadconf(0) == 0)
return NULL;
if (p->th_pbs_defserver[0] == '\0') {
/* The check for PBS_DEFAULT is done in pbs_loadconf() */
if (pbs_conf.pbs_primary && pbs_conf.pbs_secondary) {
strncpy(dflt_server, pbs_conf.pbs_primary, PBS_MAXSERVERNAME);
} else if (pbs_conf.pbs_server_host_name) {
strncpy(dflt_server, pbs_conf.pbs_server_host_name, PBS_MAXSERVERNAME);
} else if (pbs_conf.pbs_server_name) {
strncpy(dflt_server, pbs_conf.pbs_server_name, PBS_MAXSERVERNAME);
} else {
dflt_server[0] = '\0';
}
strcpy(p->th_pbs_defserver, dflt_server);
}
return (p->th_pbs_defserver);
}
/**
* @brief
* main - the entry point in pbs_config_add_win.c
*
* @param[in] argc - argument count
* @param[in] argv - argument variables.
*
* @return int
* @retval 1 - Function failed to perform the requested operation.
* @retval 0 - Function succeeded in the requested operation
*/
int
main(int argc, char *argv[])
{
char *mode;
if (argc < 2) {
fprintf(stderr, "Usage: %s check|monitor\n", argv[0]);
return 1;
}
mode = argv[1];
if (pbs_loadconf(0) == 0) {
fprintf(stderr, "Failed to load PBS conf file\n");
return 1;
}
#ifdef WIN32
if (winsock_init()) {
return 1;
}
if (gethostname(thishost, (sizeof(thishost) - 1)) == SOCKET_ERROR)
#else
if (gethostname(thishost, (sizeof(thishost) - 1)) == -1)
#endif
{
fprintf(stderr, "Failed to detect hostname\n");
return -1;
}
#ifdef WIN32
if (strcmp(mode, "monitorchild") == 0) {
int rc;
rc = win_db_monitor_child();
return rc;
}
#endif
#ifdef WIN32
strncpy(pbs_ds_monitor_exe, argv[0], MAXPATHLEN);
return win_db_monitor(mode);
#else
return unix_db_monitor(mode);
#endif
}
/**
* @brief
* main - the initialization and main loop of pbs_daemon
*/
int
main(int argc, char *argv[])
{
char buf[4096];
char *param_name, *param_val;
int rc;
execution_mode(argc, argv);
if(set_msgdaemonname("PBS_send_hooks")) {
fprintf(stderr, "Out of memory\n");
return 1;
}
pbs_loadconf(0);
/* If we are not run with real and effective uid of 0, forget it */
if (!isAdminPrivilege(getlogin())) {
fprintf(stderr, "%s: Must be run by root\n", argv[0]);
exit(-1);
}
pbs_client_thread_set_single_threaded_mode();
/* disable attribute verification */
set_no_attribute_verification();
/* initialize the thread context */
if (pbs_client_thread_init_thread_context() != 0) {
fprintf(stderr, "%s: Unable to initialize thread context\n",
argv[0]);
exit(-1);
}
winsock_init();
connection_init();
while (fgets(buf, sizeof(buf), stdin) != NULL) {
buf[strlen(buf)-1] = '\0'; /* gets rid of newline */
param_name = buf;
param_val = strchr(buf, '=');
if (param_val) {
*param_val = '\0';
param_val++;
} else { /* bad param_val -- skipping */
break;
}
if (strcmp(param_name, "path_log") == 0) {
path_log[0] = '\0';
strncpy(path_log, param_val, MAXPATHLEN);
} else if (strcmp(param_name, "path_hooks") == 0) {
path_hooks = strdup(param_val);
if (path_hooks == NULL)
exit(-1);
} else if (strcmp(param_name, "log_file") == 0) {
log_file = strdup(param_val);
if (log_file == NULL)
exit(-1);
} else if (strcmp(param_name, "path_hooks_tracking") == 0) {
path_hooks_tracking = strdup(param_val);
if (path_hooks_tracking == NULL)
exit(-1);
} else if (strcmp(param_name, "hook_action_tid") == 0) {
#ifdef WIN32
hook_action_tid_set(_atoi64(param_val));
#else
hook_action_tid_set(atoll(param_val));
#endif
} else if (strcmp(param_name, "pbs_server_port_dis") == 0) {
pbs_server_port_dis = atoi(param_val);
} else if (strcmp(param_name, "pbs_server_addr") == 0) {
pbs_server_addr = atol(param_val);
} else
break;
}
(void)log_open_main(log_file, path_log, 1); /* silent open */
hook_track_recov();
rc = sync_mom_hookfiles(NULL);
log_close(0); /* silent close */
net_close(-1);
if (log_file != NULL)
free(log_file);
if (path_hooks != NULL)
free(path_hooks);
if (path_hooks_tracking != NULL)
free(path_hooks_tracking);
exit(rc);
}
/**
* @brief
* main - the initialization and main loop of pbs_daemon
*/
int
main(int argc, char *argv[])
{
char jobfile[MAXPATHLEN+1];
char jobfile_full[MAXPATHLEN+1];
pbs_net_t hostaddr = 0;
int port = -1;
int move_type = -1;
pbs_list_head attrl;
enum conn_type cntype = ToServerDIS;
int con = -1;
char *destin;
int encode_type;
int i;
job *jobp;
char job_id[PBS_MAXSVRJOBID+1];
attribute *pattr;
struct attropl *pqjatr; /* list (single) of attropl for quejob */
char script_name[MAXPATHLEN+1];
int in_server = -1;
char *param_name, *param_val;
char buf[4096];
struct hostent *hp;
struct in_addr addr;
char *credbuf = NULL;
size_t credlen = 0;
int prot = PROT_TCP;
/*the real deal or output version and exit?*/
execution_mode(argc, argv);
/* If we are not run with real and effective uid of 0, forget it */
pbs_loadconf(0);
if (!isAdminPrivilege(getlogin())) {
fprintf(stderr, "%s: Must be run by root\n", argv[0]);
exit(SEND_JOB_FATAL);
}
/* initialize the pointers in the resource_def array */
for (i = 0; i < (svr_resc_size - 1); ++i)
svr_resc_def[i].rs_next = &svr_resc_def[i+1];
/* last entry is left with null pointer */
/* set single threaded mode */
pbs_client_thread_set_single_threaded_mode();
/* disable attribute verification */
set_no_attribute_verification();
/* initialize the thread context */
if (pbs_client_thread_init_thread_context() != 0) {
fprintf(stderr, "%s: Unable to initialize thread context\n",
argv[0]);
exit(SEND_JOB_FATAL);
}
if(set_msgdaemonname("PBS_send_job")) {
fprintf(stderr, "Out of memory\n");
return 1;
}
winsock_init();
connection_init();
while (fgets(buf, sizeof(buf), stdin) != NULL) {
buf[strlen(buf)-1] = '\0'; /* gets rid of newline */
param_name = buf;
param_val = strchr(buf, '=');
if (param_val) {
*param_val = '\0';
param_val++;
} else { /* bad param_val -- skipping */
break;
}
if (strcmp(param_name, "jobfile") == 0) {
jobfile[0] = '\0';
strncpy(jobfile, param_val, MAXPATHLEN);
} else if (strcmp(param_name, "destaddr") == 0) {
hostaddr = atol(param_val);
} else if (strcmp(param_name, "destport") == 0) {
port = atoi(param_val);
} else if (strcmp(param_name, "move_type") == 0) {
move_type = atoi(param_val);
} else if (strcmp(param_name, "in_server") == 0) {
in_server = atoi(param_val);
} else if (strcmp(param_name, "server_name") == 0) {
server_name[0] = '\0';
strncpy(server_name, param_val, PBS_MAXSERVERNAME);
} else if (strcmp(param_name, "server_host") == 0) {
server_host[0] = '\0';
strncpy(server_host, param_val, (sizeof(server_host) - 1));
} else if (strcmp(param_name, "server_addr") == 0) {
pbs_server_addr = atol(param_val);
} else if (strcmp(param_name, "server_port") == 0) {
pbs_server_port_dis = atoi(param_val);
} else if (strcmp(param_name, "log_file") == 0) {
log_file = strdup(param_val);
} else if (strcmp(param_name, "path_log") == 0) {
path_log[0] = '\0';
strncpy(path_log, param_val, MAXPATHLEN);
} else if (strcmp(param_name, "path_jobs") == 0) {
path_jobs = strdup(param_val);
} else if (strcmp(param_name, "path_spool") == 0) {
path_spool = strdup(param_val);
} else if (strcmp(param_name, "path_rescdef") == 0) {
path_rescdef = strdup(param_val);
} else if (strcmp(param_name, "path_users") == 0) {
path_users = strdup(param_val);
} else if (strcmp(param_name, "path_hooks_workdir") == 0) {
path_hooks_workdir = strdup(param_val);
if (path_hooks_workdir == NULL)
exit(SEND_JOB_FATAL);
} else if (strcmp(param_name, "svr_history_enable") == 0) {
svr_history_enable = atol(param_val);
} else if (strcmp(param_name, "svr_history_duration") == 0) {
svr_history_duration = atol(param_val);
} else if (strcmp(param_name, "single_signon_password_enable") == 0) {
if (decode_b(&server.sv_attr[(int)SRV_ATR_ssignon_enable],
NULL, NULL, param_val) != 0) {
fprintf(stderr, "%s: failed to set ssignon_password_enable\n", argv[0]);
exit(SEND_JOB_FATAL);
}
} else if (strcmp(param_name, "script_name") == 0) {
strncpy(script_name, param_val, MAXPATHLEN + 1);
} else
break;
}
time(&time_now);
(void)log_open_main(log_file, path_log, 1); /* silent open */
if (setup_resc(1) == -1) {
/* log_buffer set in setup_resc */
log_err(-1, "pbsd_send_job(setup_resc)", log_buffer);
return (-1);
}
if( strlen(jobfile) == 0 || hostaddr == 0 || port == 0 || move_type == -1 || \
in_server == -1 || strlen(server_name) == 0 || strlen(server_host) == 0 || \
pbs_server_addr == 0 || pbs_server_port_dis == 0 || \
strlen(path_log) == 0 || path_jobs == NULL || \
path_spool == NULL || path_users == NULL ) {
log_err(-1, "pbs_send_job", "error on one of the parameters");
log_close(0); /* silent close */
exit(SEND_JOB_FATAL);
}
CLEAR_HEAD(task_list_immed);
CLEAR_HEAD(task_list_timed);
CLEAR_HEAD(task_list_event);
CLEAR_HEAD(svr_queues);
CLEAR_HEAD(svr_alljobs);
CLEAR_HEAD(svr_newjobs);
CLEAR_HEAD(svr_allresvs);
CLEAR_HEAD(svr_newresvs);
CLEAR_HEAD(svr_deferred_req);
CLEAR_HEAD(svr_unlicensedjobs);
strcpy(jobfile_full, path_jobs);
strcat(jobfile_full, jobfile);
if (chk_save_file(jobfile_full) != 0) {
sprintf(log_buffer, "Error opening jobfile=%s", jobfile);
log_err(-1, __func__, log_buffer);
goto fatal_exit;
}
if ((jobp=job_recov_fs(jobfile, RECOV_SUBJOB)) == NULL) {
sprintf(log_buffer, "Failed to recreate job in jobfile=%s", jobfile);
log_err(-1, __func__, log_buffer);
goto fatal_exit;
}
/* now delete the temp job file that was created by job_save_fs in server code
* jobs are in database now, no need to keep in filesystem
*/
unlink(jobfile_full);
if (in_server)
append_link(&svr_alljobs, &jobp->ji_alljobs, jobp);
/* select attributes/resources to send based on move type */
if (move_type == MOVE_TYPE_Exec) {
resc_access_perm = ATR_DFLAG_MOM;
encode_type = ATR_ENCODE_MOM;
cntype = ToServerDIS;
} else {
resc_access_perm = ATR_DFLAG_USWR | ATR_DFLAG_OPWR |
ATR_DFLAG_MGWR | ATR_DFLAG_SvRD;
encode_type = ATR_ENCODE_SVR;
svr_dequejob(jobp);
}
CLEAR_HEAD(attrl);
pattr = jobp->ji_wattr;
for (i=0; i < (int)JOB_ATR_LAST; i++) {
if ((job_attr_def+i)->at_flags & resc_access_perm) {
(void)(job_attr_def+i)->at_encode(pattr+i, &attrl,
(job_attr_def+i)->at_name, NULL,
encode_type, NULL);
}
}
attrl_fixlink(&attrl);
/* script name is passed from parent */
/* get host name */
pbs_loadconf(0);
addr.s_addr = htonl(hostaddr);
hp = gethostbyaddr((void *)&addr, sizeof(struct in_addr), AF_INET);
if (hp == NULL) {
sprintf(log_buffer, "%s: h_errno=%d",
inet_ntoa(addr), h_errno);
log_err(-1, __func__, log_buffer);
}
else {
/* read any credential file */
(void)get_credential(hp->h_name, jobp, PBS_GC_BATREQ,
&credbuf, &credlen);
}
/* save the job id for when after we purge the job */
(void)strcpy(job_id, jobp->ji_qs.ji_jobid);
con = -1;
DIS_tcparray_init();
for (i=0; i<RETRY; i++) {
pbs_errno = 0;
/* connect to receiving server with retries */
if (i > 0) { /* recycle after an error */
if (con >= 0)
svr_disconnect(con);
if (should_retry_route(pbs_errno) == -1) {
goto fatal_exit; /* fatal error, don't retry */
}
sleep(1<<i);
}
if ((con = svr_connect(hostaddr, port, 0, cntype, prot)) ==
PBS_NET_RC_FATAL) {
(void)sprintf(log_buffer, "send_job failed to %lx port %d",
hostaddr, port);
log_err(pbs_errno, __func__, log_buffer);
goto fatal_exit;
} else if (con == PBS_NET_RC_RETRY) {
pbs_errno = WSAECONNREFUSED; /* should retry */
continue;
}
/*
* if the job is substate JOB_SUBSTATE_TRNOUTCM which means
* we are recovering after being down or a late failure, we
* just want to send the "read-to-commit/commit"
*/
if (jobp->ji_qs.ji_substate != JOB_SUBSTATE_TRNOUTCM) {
if (jobp->ji_qs.ji_substate != JOB_SUBSTATE_TRNOUT) {
jobp->ji_qs.ji_substate = JOB_SUBSTATE_TRNOUT;
}
pqjatr = &((svrattrl *)GET_NEXT(attrl))->al_atopl;
destin = jobp->ji_qs.ji_destin;
if (PBSD_queuejob(con, jobp->ji_qs.ji_jobid, destin, pqjatr, NULL, prot, NULL)== 0) {
if (pbs_errno == PBSE_JOBEXIST && move_type == MOVE_TYPE_Exec) {
/* already running, mark it so */
log_event(PBSEVENT_ERROR,
PBS_EVENTCLASS_JOB, LOG_INFO,
jobp->ji_qs.ji_jobid, "Mom reports job already running");
goto ok_exit;
} else if ((pbs_errno == PBSE_HOOKERROR) ||
(pbs_errno == PBSE_HOOK_REJECT) ||
(pbs_errno == PBSE_HOOK_REJECT_RERUNJOB) ||
(pbs_errno == PBSE_HOOK_REJECT_DELETEJOB)) {
char name_buf[MAXPATHLEN+1];
int rfd;
int len;
char *reject_msg;
int err;
err = pbs_errno;
reject_msg = pbs_geterrmsg(con);
(void)snprintf(log_buffer, sizeof(log_buffer),
"send of job to %s failed error = %d reject_msg=%s",
destin, err,
reject_msg?reject_msg:"");
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB,
LOG_INFO, jobp->ji_qs.ji_jobid,
log_buffer);
(void)strcpy(name_buf, path_hooks_workdir);
(void)strcat(name_buf, jobp->ji_qs.ji_jobid);
(void)strcat(name_buf, HOOK_REJECT_SUFFIX);
if ((reject_msg != NULL) &&
(reject_msg[0] != '\0')) {
if ((rfd = open(name_buf,
O_RDWR|O_CREAT|O_TRUNC, 0600)) == -1) {
snprintf(log_buffer,
sizeof(log_buffer),
"open of reject file %s failed: errno %d",
name_buf, errno);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO, jobp->ji_qs.ji_jobid, log_buffer);
} else {
secure_file(name_buf, "Administrators",
READS_MASK|WRITES_MASK|STANDARD_RIGHTS_REQUIRED);
setmode(rfd, O_BINARY);
len = strlen(reject_msg)+1;
/* write also trailing null char */
if (write(rfd, reject_msg, len) != len) {
snprintf(log_buffer,
sizeof(log_buffer),
"write to file %s incomplete: errno %d", name_buf, errno);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO, jobp->ji_qs.ji_jobid, log_buffer);
}
close(rfd);
}
}
if (err == PBSE_HOOKERROR)
exit(SEND_JOB_HOOKERR);
if (err == PBSE_HOOK_REJECT)
exit(SEND_JOB_HOOK_REJECT);
if (err == PBSE_HOOK_REJECT_RERUNJOB)
exit(SEND_JOB_HOOK_REJECT_RERUNJOB);
if (err == PBSE_HOOK_REJECT_DELETEJOB)
exit(SEND_JOB_HOOK_REJECT_DELETEJOB);
} else {
(void)sprintf(log_buffer, "send of job to %s failed error = %d", destin, pbs_errno);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO, jobp->ji_qs.ji_jobid, log_buffer);
continue;
}
}
if (jobp->ji_qs.ji_svrflags & JOB_SVFLG_SCRIPT) {
if (PBSD_jscript(con, script_name, prot, NULL) != 0)
continue;
}
if (credlen > 0) {
int ret;
ret = PBSD_jcred(con,
jobp->ji_extended.ji_ext.ji_credtype,
credbuf, credlen, prot, NULL);
if ((ret == 0) || (i == (RETRY - 1)))
free(credbuf); /* free credbuf if credbuf is sent successfully OR */
/* at the end of all retry attempts */
if (ret != 0)
continue;
}
if ((move_type == MOVE_TYPE_Exec) &&
(jobp->ji_qs.ji_svrflags & JOB_SVFLG_HASRUN) &&
(hostaddr != pbs_server_addr)) {
/* send files created on prior run */
if ((move_job_file(con, jobp, StdOut, prot) != 0) ||
(move_job_file(con, jobp, StdErr, prot) != 0) ||
(move_job_file(con, jobp, Chkpt, prot) != 0))
continue;
}
jobp->ji_qs.ji_substate = JOB_SUBSTATE_TRNOUTCM;
}
if (PBSD_rdytocmt(con, job_id, prot, NULL) != 0)
continue;
if (PBSD_commit(con, job_id, prot, NULL) != 0)
goto fatal_exit;
goto ok_exit; /* This child process is all done */
}
if (con >= 0)
svr_disconnect(con);
/*
* If connection is actively refused by the execution node(or mother superior) OR
* the execution node(or mother superior) is rejecting request with error
* PBSE_BADHOST(failing to authorize server host), the node should be marked down.
*/
if ((move_type == MOVE_TYPE_Exec) && (pbs_errno == WSAECONNREFUSED || pbs_errno == PBSE_BADHOST)) {
i = SEND_JOB_NODEDW;
} else if (should_retry_route(pbs_errno) == -1) {
i = SEND_JOB_FATAL;
} else {
i = SEND_JOB_RETRY;
}
(void)sprintf(log_buffer, "send_job failed with error %d", pbs_errno);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, LOG_NOTICE,
jobp->ji_qs.ji_jobid, log_buffer);
log_close(0);
net_close(-1);
unlink(script_name);
exit(i);
fatal_exit:
if (con >= 0)
svr_disconnect(con);
log_close(0);
net_close(-1);
unlink(script_name);
exit(SEND_JOB_FATAL);
ok_exit:
if (con >= 0)
svr_disconnect(con);
log_close(0);
net_close(-1);
unlink(script_name);
exit(SEND_JOB_OK);
}
/**
* @brief
* establishes connection to host
*
* @param[in] momhost - The name of the MOM host to connect to.
*
* @return int
* @retval connection slot success
* @retval -1 error
*
*/
static int
pbs_connect2mom(char *momhost)
{
int conn, sd;
#if defined(__hpux)
struct sockaddr_in mom_addr;
struct hostent *hp;
#else
struct addrinfo *aip, *pai;
struct addrinfo hints;
struct sockaddr_in *inp;
#endif
#if 0
struct passwd *pw;
#endif
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return -1;
if (pbs_loadconf(0) == 0)
return -1;
if (pbs_client_thread_lock_conntable() != 0)
return -1;
/*
* Find an available connection slot.
*/
for (conn=1; conn<NCONNECTS; conn++) {
if (connection[conn].ch_inuse)
continue;
break;
}
if (conn >= NCONNECTS) {
pbs_errno = PBSE_NOCONNECTS;
goto err;
}
/*
* Ensure we have something valid to connect to.
*/
if (!momhost)
momhost = "localhost";
if (strlen(momhost) <= 0)
momhost = "localhost";
#if defined(__hpux)
hp = gethostbyname(momhost);
if (!hp) {
pbs_errno = PBSE_BADHOST;
goto err;
}
#else
memset(&hints, 0, sizeof(struct addrinfo));
/*
* Why do we use AF_UNSPEC rather than AF_INET? Some
* implementations of getaddrinfo() will take an IPv6
* address and map it to an IPv4 one if we ask for AF_INET
* only. We don't want that - we want only the addresses
* that are genuinely, natively, IPv4 so we start with
* AF_UNSPEC and filter ai_family below.
*/
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (getaddrinfo(momhost, NULL, &hints, &pai) != 0) {
pbs_errno = PBSE_BADHOST;
goto err;
}
for (aip = pai; aip != NULL; aip = aip->ai_next) {
/* skip non-IPv4 addresses */
if (aip->ai_family == AF_INET) {
inp = (struct sockaddr_in *) aip->ai_addr;
break;
}
}
if (aip == NULL) {
pbs_errno = PBSE_BADHOST;
goto err;
} else
inp->sin_port = htons(pbs_conf.mom_service_port);
#endif
#if 0
/*
* Prepare for authentication before we make the connection.
*/
pbs_current_uid = getuid();
if ((pw = getpwuid(pbs_current_uid)) == NULL) {
pbs_errno = PBSE_SYSTEM;
goto err;
}
strcpy(pbs_current_user, pw->pw_name);
#endif
/*
* Establish a connection.
*/
sd = socket(AF_INET, SOCK_STREAM, 0);
if (sd < 0) {
pbs_errno = PBSE_PROTOCOL;
goto err;
}
#if defined(__hpux)
mom_addr.sin_family = AF_INET;
mom_addr.sin_port = htons(pbs_conf.mom_service_port);
memcpy((char *)&mom_addr.sin_addr, hp->h_addr_list[0], hp->h_length);
if (connect(sd, (struct sockaddr *)&mom_addr, sizeof(mom_addr)) < 0) {
close(sd);
pbs_errno = errno;
goto err;
}
#else
if (connect(sd, aip->ai_addr, aip->ai_addrlen) < 0) {
close(sd);
pbs_errno = errno;
freeaddrinfo(pai);
goto err;
}
freeaddrinfo(pai);
#endif
#if 0
/*
* Have pbs_iff authenticate the connection.
*/
if (PBSD_authenticate(sd)) {
close(sd);
pbs_errno = PBSE_PERM;
return -1;
}
#endif
/*
* Setup DIS support routines.
*/
DIS_tcp_setup(sd);
pbs_tcp_timeout = PBS_DIS_TCP_TIMEOUT_VLONG;
/*
* Register the connection slot as in use.
*/
connection[conn].ch_inuse = 1;
connection[conn].ch_errno = 0;
connection[conn].ch_socket= sd;
connection[conn].ch_errtxt = (char *)NULL;
/* setup connection level thread context */
if (pbs_client_thread_init_connect_context(conn) != 0) {
close(connection[conn].ch_socket);
connection[conn].ch_inuse = 0;
/* pbs_errno would be set by the pbs_connect_init_context routine */
goto err;
}
if (pbs_client_thread_unlock_conntable() != 0)
return -1;
return conn;
err:
(void)pbs_client_thread_unlock_conntable();
return -1;
}
/**
* @brief
* main - the entry point in pbsTclInit.c
*
* @param[in] argc - argument count.
* @param[in] argv - argument variables.
*
* @return int
* @retval 0 : success
*/
int
main(int argc, char *argv[])
{
char tcl_libpath[MAXPATHLEN+13]; /* 13 for "TCL_LIBRARY=" + \0 */
int rc;
/*the real deal or just pbs_version and exit?*/
execution_mode(argc, argv);
if(set_msgdaemonname("pbs_tclsh")) {
fprintf(stderr, "Out of memory\n");
return 1;
}
set_logfile(stderr);
#ifdef WIN32
winsock_init();
Tcl_FindExecutable(argv[0]);
#endif
/* load the pbs conf file */
if (pbs_loadconf(0) == 0) {
fprintf(stderr, "%s: Configuration error\n", argv[0]);
return (1);
}
if (!getenv("TCL_LIBRARY")) {
if (pbs_conf.pbs_exec_path) {
sprintf((char *)tcl_libpath,
#ifdef WIN32
"TCL_LIBRARY=%s/lib/tcl%s",
#else
"TCL_LIBRARY=%s/tcltk/lib/tcl%s",
#endif
pbs_conf.pbs_exec_path, TCL_VERSION);
putenv(tcl_libpath);
}
}
if (pbs_conf.pbs_use_tcp == 1) {
char *nodename;
struct tpp_config tpp_conf;
char my_hostname[PBS_MAXHOSTNAME+1];
fd_set selset;
struct timeval tv;
if (pbs_conf.pbs_leaf_name)
nodename = pbs_conf.pbs_leaf_name;
else {
if (gethostname(my_hostname, (sizeof(my_hostname) - 1)) < 0) {
fprintf(stderr, "Failed to get hostname\n");
return -1;
}
nodename = my_hostname;
}
/* We don't want to show logs related to connecting pbs_comm on console
* this set this flag to ignore it
*/
log_mask = SHOW_NONE;
/* set tpp function pointers */
set_tpp_funcs(log_tppmsg);
/* call tpp_init */
rc = 0;
#ifndef WIN32
if (pbs_conf.auth_method == AUTH_MUNGE)
rc = set_tpp_config(&pbs_conf, &tpp_conf, nodename, -1, pbs_conf.pbs_leaf_routers,
pbs_conf.pbs_use_compression,
TPP_AUTH_EXTERNAL,
get_ext_auth_data, validate_ext_auth_data);
else
#endif
rc = set_tpp_config(&pbs_conf, &tpp_conf, nodename, -1, pbs_conf.pbs_leaf_routers,
pbs_conf.pbs_use_compression,
TPP_AUTH_RESV_PORT,
NULL, NULL);
if (rc == -1) {
fprintf(stderr, "Error setting TPP config\n");
return -1;
}
if ((rpp_fd = tpp_init(&tpp_conf)) == -1) {
fprintf(stderr, "rpp_init failed\n");
return -1;
}
/*
* Wait for net to get restored, ie, app to connect to routers
*/
FD_ZERO(&selset);
FD_SET(rpp_fd, &selset);
tv.tv_sec = 5;
tv.tv_usec = 0;
select(FD_SETSIZE, &selset, (fd_set *) 0, (fd_set *) 0, &tv);
rpp_poll(); /* to clear off the read notification */
/* Once the connection is established we can unset log_mask */
log_mask &= ~SHOW_NONE;
} else {
/* set rpp function pointers */
set_rpp_funcs(log_rppfail);
}
Tcl_Main(argc, argv, pbsTcl_Init);
return 0;
}
int
main(int argc, char *argv[])
{
int i;
char mom_name[PBS_MAXHOSTNAME+1];
int mom_port = 0;
int c, rc;
int mom_sd;
char *req;
#ifdef WIN32
if (winsock_init()) {
return 1;
}
#endif
if (gethostname(mom_name, (sizeof(mom_name) - 1)) < 0 )
mom_name[0] = '\0';
while ((c = getopt(argc, argv, "m:p:")) != EOF) {
switch (c) {
case 'm':
strcpy(mom_name, optarg);
break;
case 'p':
mom_port = atoi(optarg);
break;
default:
fprintf(stderr, "Bad option: %c\n", c);
}
}
if (mom_name[0] == '\0' || optind == argc) {
fprintf(stderr,
"Error in usage: pbs_rmget [-m mom name] [-p mom port] <req1>...[reqN]\n");
return 1;
}
if(set_msgdaemonname("pbs_rmget")) {
fprintf(stderr, "Out of memory\n");
return 1;
}
/* load the pbs conf file */
if (pbs_loadconf(0) == 0) {
fprintf(stderr, "%s: Configuration error\n", argv[0]);
return (1);
}
if (pbs_conf.pbs_use_tcp == 1) {
struct tpp_config tpp_conf;
fd_set selset;
struct timeval tv;
if (!pbs_conf.pbs_leaf_name) {
char my_hostname[PBS_MAXHOSTNAME+1];
if (gethostname(my_hostname, (sizeof(my_hostname) - 1)) < 0) {
fprintf(stderr, "Failed to get hostname\n");
return -1;
}
pbs_conf.pbs_leaf_name = get_all_ips(my_hostname, log_buffer, sizeof(log_buffer) - 1);
if (!pbs_conf.pbs_leaf_name) {
fprintf(stderr, "%s\n", log_buffer);
fprintf(stderr, "%s\n", "Unable to determine TPP node name");
return -1;
}
}
/* We don't want to show logs related to connecting pbs_comm on console
* this set this flag to ignore it
*/
log_mask = SHOW_NONE;
/* set tpp function pointers */
set_tpp_funcs(log_tppmsg);
/* call tpp_init */
rc = 0;
#ifndef WIN32
if (pbs_conf.auth_method == AUTH_MUNGE)
rc = set_tpp_config(&pbs_conf, &tpp_conf, pbs_conf.pbs_leaf_name, -1, pbs_conf.pbs_leaf_routers,
pbs_conf.pbs_use_compression,
TPP_AUTH_EXTERNAL,
get_ext_auth_data, validate_ext_auth_data);
else
#endif
rc = set_tpp_config(&pbs_conf, &tpp_conf, pbs_conf.pbs_leaf_name, -1, pbs_conf.pbs_leaf_routers,
pbs_conf.pbs_use_compression,
TPP_AUTH_RESV_PORT,
NULL, NULL);
if (rc == -1) {
fprintf(stderr, "Error setting TPP config\n");
return -1;
}
if ((rpp_fd = tpp_init(&tpp_conf)) == -1) {
fprintf(stderr, "rpp_init failed\n");
return -1;
}
/*
* Wait for net to get restored, ie, app to connect to routers
*/
FD_ZERO(&selset);
FD_SET(rpp_fd, &selset);
tv.tv_sec = 5;
tv.tv_usec = 0;
select(FD_SETSIZE, &selset, NULL, NULL, &tv);
rpp_poll(); /* to clear off the read notification */
/* Once the connection is established we can unset log_mask */
log_mask &= ~SHOW_NONE;
} else {
/* set rpp function pointers */
set_rpp_funcs(log_rppfail);
}
/* get the FQDN of the mom */
c = get_fullhostname(mom_name, mom_name, (sizeof(mom_name) - 1));
if (c == -1) {
fprintf(stderr, "Unable to get full hostname for mom %s\n", mom_name);
return -1;
}
if ((mom_sd = openrm(mom_name, mom_port)) < 0) {
fprintf(stderr, "Unable to open connection to mom: %s:%d\n", mom_name, mom_port);
return 1;
}
for (i = optind; i < argc; i++)
addreq(mom_sd, argv[i]);
for (i = optind; i < argc; i++) {
req = getreq(mom_sd);
if (req == NULL) {
fprintf(stderr, "Error getting response %d from mom.\n", i - optind);
return 1;
}
printf("[%d] %s\n", i - optind, req);
free(req);
}
closerm(mom_sd);
return 0;
}
/**
* @brief
* The entry point of pbsfs
*
* @return int
* @retval 0 : success
* @retval 1 : something is wrong!
*/
int
main(int argc, char *argv[])
{
char path_buf[256] = {0};
char sched_name[PBS_MAXSCHEDNAME + 1] = "default";
group_info *ginfo;
group_info *ginfo2;
int c;
int flags = FS_PRINT;
int flag1 = 0;
double val;
char *endp;
char *testp;
/* the real deal or output version and exit? */
PRINT_VERSION_AND_EXIT(argc, argv);
set_msgdaemonname("pbsfs");
#ifdef WIN32
if (winsock_init()) {
return 1;
}
#endif
if (pbs_loadconf(0) <= 0)
exit(1);
while ((c = getopt(argc, argv, "sgptdceI:-:")) != -1)
switch (c) {
case 'g':
flags = FS_GET;
break;
case 's':
flags = FS_SET | FS_WRITE_FILE;
break;
case 'p':
flags = FS_PRINT;
break;
case 't':
flags = FS_PRINT_TREE;
break;
case 'd':
flags = FS_DECAY | FS_WRITE_FILE;
break;
case 'c':
flags = FS_COMP;
break;
case 'e':
flags = FS_TRIM_TREE | FS_WRITE_FILE;
break;
case 'I':
snprintf(sched_name, sizeof(sched_name), "%s", optarg);
break;
case '-':
flag1 = 1;
break;
}
if (flag1 == 1) {
fprintf(stderr, "Usage: pbsfs --version\n");
exit(1);
}
if ((flags & (FS_PRINT | FS_PRINT_TREE)) && (argc - optind) != 0) {
fprintf(stderr, "Usage: pbsfs -[ptdgcs] [-I sched_name]\n");
exit(1);
}
else if ((flags & FS_GET) && (argc - optind) != 1) {
fprintf(stderr, "Usage: pbsfs [-I sched_name] -g <fairshare_entity>\n");
exit(1);
}
else if ((flags & FS_SET) && (argc - optind) != 2) {
fprintf(stderr, "Usage: pbsfs [-I sched_name] -s <fairshare_entity> <usage>\n");
exit(1);
}
else if ((flags & FS_COMP) && (argc - optind) != 2) {
fprintf(stderr, "Usage: pbsfs [-I sched_name] -c <entity1> <entity2>\n");
exit(1);
}
if (strcmp(sched_name, "default") != 0) {
int pbs_sd;
struct batch_status *bs;
struct batch_status *cur_bs;
pbs_sd = pbs_connect(NULL);
if (pbs_sd < 0) {
fprintf(stderr, "Can't connect to the server\n");
exit(1);
}
bs = pbs_statsched(pbs_sd, NULL, NULL);
for (cur_bs = bs; cur_bs != NULL; cur_bs = cur_bs->next) {
if (strcmp(cur_bs->name, sched_name) == 0) {
struct attrl *cur_attrl;
for (cur_attrl = cur_bs->attribs; cur_attrl != NULL; cur_attrl = cur_attrl->next) {
if (strcmp(cur_attrl->name, ATTR_sched_priv) == 0) {
strncpy(path_buf, cur_attrl->value, sizeof(path_buf));
path_buf[sizeof(path_buf) - 1] = '\0';
break;
}
}
if (cur_attrl == NULL) {
fprintf(stderr, "Scheduler %s does not have its sched_priv set\n", sched_name);
exit(1);
}
break;
}
}
if (cur_bs == NULL) {
fprintf(stderr, "Scheduler %s does not exist\n", sched_name);
exit(1);
}
pbs_disconnect(pbs_sd);
} else
snprintf(path_buf, sizeof(path_buf), "%s/sched_priv/", pbs_conf.pbs_home_path);
if (chdir(path_buf) == -1) {
perror("Unable to access fairshare data");
exit(1);
}
init_config();
parse_config(CONFIG_FILE);
if ((conf.fairshare = preload_tree()) == NULL) {
fprintf(stderr, "Error in preloading fairshare information\n");
return 1;
}
if (parse_group(RESGROUP_FILE, conf.fairshare->root) == 0)
return 1;
if (flags & FS_TRIM_TREE)
read_usage(USAGE_FILE, FS_TRIM, conf.fairshare);
else
read_usage(USAGE_FILE, 0, conf.fairshare);
calc_fair_share_perc(conf.fairshare->root->child, UNSPECIFIED);
calc_usage_factor(conf.fairshare);
if (flags & FS_PRINT_TREE)
print_fairshare(conf.fairshare->root, 0);
else if (flags & FS_PRINT ) {
printf("Fairshare usage units are in: %s\n", conf.fairshare_res);
print_fairshare(conf.fairshare->root, -1);
}
else if (flags & FS_DECAY)
decay_fairshare_tree(conf.fairshare->root);
else if (flags & (FS_GET | FS_SET | FS_COMP)) {
ginfo = find_group_info(argv[optind], conf.fairshare->root);
if (ginfo == NULL) {
fprintf(stderr, "Fairshare Entity %s does not exist.\n", argv[optind]);
return 1;
}
if (flags & FS_COMP) {
ginfo2 = find_group_info(argv[optind + 1], conf.fairshare->root);
if (ginfo2 == NULL) {
fprintf(stderr, "Fairshare Entity %s does not exist.\n", argv[optind + 1]);
return 1;
}
switch (compare_path(ginfo->gpath, ginfo2->gpath)) {
case -1:
printf("%s\n", ginfo->name);
break;
case 0:
printf("%s == %s\n", ginfo->name, ginfo2->name);
break;
case 1:
printf("%s\n", ginfo2->name);
}
}
else if (flags & FS_GET)
print_fairshare_entity(ginfo);
else {
testp = argv[optind + 1];
val = strtod(testp, &endp);
if (*endp == '\0')
ginfo->usage = val;
}
}
if (flags & FS_WRITE_FILE) {
FILE *fp;
/* make backup of database file */
remove(USAGE_FILE ".bak");
if (rename(USAGE_FILE, USAGE_FILE ".bak") < 0)
perror("Could not backup usage database.");
write_usage(USAGE_FILE, conf.fairshare);
if ((fp = fopen(USAGE_TOUCH, "w")) != NULL)
fclose(fp);
}
return 0;
}
int
main(int argc, char **argv)
#endif /* WIN32 */
{
#ifdef WIN32
struct arg_param *p = (struct arg_param *)pv;
int argc;
char **argv;
SERVICE_STATUS ss;
#endif /* WIN32 */
char *name = NULL;
struct tpp_config conf;
int rpp_fd;
char *pc;
int numthreads;
char lockfile[MAXPATHLEN + 1];
char path_log[MAXPATHLEN + 1];
char svr_home[MAXPATHLEN + 1];
char *log_file = 0;
char *host;
int port;
char *routers = NULL;
int c, i, rc;
extern char *optarg;
int are_primary;
int num_var_env;
#ifndef WIN32
struct sigaction act;
struct sigaction oact;
#endif
#ifndef WIN32
/*the real deal or just pbs_version and exit*/
execution_mode(argc, argv);
#endif
/* As a security measure and to make sure all file descriptors */
/* are available to us, close all above stderr */
#ifdef WIN32
_fcloseall();
#else
i = sysconf(_SC_OPEN_MAX);
while (--i > 2)
(void)close(i); /* close any file desc left open by parent */
#endif
/* If we are not run with real and effective uid of 0, forget it */
#ifdef WIN32
argc = p->argc;
argv = p->argv;
ZeroMemory(&ss, sizeof(ss));
ss.dwCheckPoint = 0;
ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
ss.dwCurrentState = g_dwCurrentState;
ss.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
ss.dwWaitHint = 6000;
if (g_ssHandle != 0)
SetServiceStatus(g_ssHandle, &ss);
if (!isAdminPrivilege(getlogin())) {
fprintf(stderr, "%s: Must be run by root\n", argv[0]);
return (2);
}
#else
if ((getuid() != 0) || (geteuid() != 0)) {
fprintf(stderr, "%s: Must be run by root\n", argv[0]);
return (2);
}
#endif /* WIN32 */
/* set standard umask */
#ifndef WIN32
umask(022);
#endif
/* load the pbs conf file */
if (pbs_loadconf(0) == 0) {
fprintf(stderr, "%s: Configuration error\n", argv[0]);
return (1);
}
umask(022);
#ifdef WIN32
save_env();
#endif
/* The following is code to reduce security risks */
/* start out with standard umask, system resource limit infinite */
if ((num_var_env = setup_env(pbs_conf.pbs_environment)) == -1) {
#ifdef WIN32
g_dwCurrentState = SERVICE_STOPPED;
ss.dwCurrentState = g_dwCurrentState;
ss.dwWin32ExitCode = ERROR_INVALID_ENVIRONMENT;
if (g_ssHandle != 0) SetServiceStatus(g_ssHandle, &ss);
return (1);
#else
exit(1);
#endif /* WIN32 */
}
#ifndef WIN32
i = getgid();
(void)setgroups(1, (gid_t *)&i); /* secure suppl. groups */
#endif
log_event_mask = &pbs_conf.pbs_comm_log_events;
tpp_set_logmask(*log_event_mask);
#ifdef WIN32
winsock_init();
#endif
routers = pbs_conf.pbs_comm_routers;
numthreads = pbs_conf.pbs_comm_threads;
server_host[0] = '\0';
if (pbs_conf.pbs_comm_name) {
name = pbs_conf.pbs_comm_name;
host = tpp_parse_hostname(name, &port);
if (host)
snprintf(server_host, sizeof(server_host), "%s", host);
free(host);
host = NULL;
} else if (pbs_conf.pbs_leaf_name) {
char *endp;
snprintf(server_host, sizeof(server_host), "%s", pbs_conf.pbs_leaf_name);
endp = strchr(server_host, ','); /* find the first name */
if (endp)
*endp = '\0';
endp = strchr(server_host, ':'); /* cut out the port */
if (endp)
*endp = '\0';
name = server_host;
} else {
if (gethostname(server_host, (sizeof(server_host) - 1)) == -1) {
#ifndef WIN32
sprintf(log_buffer, "Could not determine my hostname, errno=%d", errno);
#else
sprintf(log_buffer, "Could not determine my hostname, errno=%d", WSAGetLastError());
#endif
fprintf(stderr, "%s\n", log_buffer);
return (1);
}
if ((get_fullhostname(server_host, server_host, (sizeof(server_host) - 1)) == -1)) {
sprintf(log_buffer, "Could not determine my hostname");
fprintf(stderr, "%s\n", log_buffer);
return (1);
}
name = server_host;
}
if (server_host[0] == '\0') {
sprintf(log_buffer, "Could not determine server host");
fprintf(stderr, "%s\n", log_buffer);
return (1);
}
while ((c = getopt(argc, argv, "r:t:e:N")) != -1) {
switch (c) {
case 'e': *log_event_mask = strtol(optarg, NULL, 0);
break;
case 'r':
routers = optarg;
break;
case 't':
numthreads = atol(optarg);
if (numthreads == -1) {
usage(argv[0]);
return (1);
}
break;
case 'N':
stalone = 1;
break;
default:
usage(argv[0]);
return (1);
}
}
(void)strcpy(daemonname, "Comm@");
(void)strcat(daemonname, name);
if ((pc = strchr(daemonname, (int)'.')) != NULL)
*pc = '\0';
if(set_msgdaemonname(daemonname)) {
fprintf(stderr, "Out of memory\n");
return 1;
}
(void) snprintf(path_log, sizeof(path_log), "%s/%s", pbs_conf.pbs_home_path, PBS_COMM_LOGDIR);
#ifdef WIN32
/*
* let SCM wait 10 seconds for log_open() to complete
* as it does network interface query which can take time
*/
ss.dwCheckPoint++;
ss.dwWaitHint = 60000;
if (g_ssHandle != 0) SetServiceStatus(g_ssHandle, &ss);
#endif
(void) log_open(log_file, path_log);
/* set pbs_comm's process limits */
set_limits(); /* set_limits can call log_record, so call only after opening log file */
/* set tcp function pointers */
set_tpp_funcs(log_tppmsg);
(void) snprintf(svr_home, sizeof(svr_home), "%s/%s", pbs_conf.pbs_home_path, PBS_SVR_PRIVATE);
if (chdir(svr_home) != 0) {
(void) sprintf(log_buffer, msg_init_chdir, svr_home);
log_err(-1, __func__, log_buffer);
return (1);
}
(void) sprintf(lockfile, "%s/%s/comm.lock", pbs_conf.pbs_home_path, PBS_SVR_PRIVATE);
if ((are_primary = are_we_primary()) == FAILOVER_SECONDARY) {
strcat(lockfile, ".secondary");
} else if (are_primary == FAILOVER_CONFIG_ERROR) {
sprintf(log_buffer, "Failover configuration error");
log_err(-1, __func__, log_buffer);
#ifdef WIN32
g_dwCurrentState = SERVICE_STOPPED;
ss.dwCurrentState = g_dwCurrentState;
ss.dwWin32ExitCode = ERROR_SERVICE_NOT_ACTIVE;
if (g_ssHandle != 0) SetServiceStatus(g_ssHandle, &ss);
#endif
return (3);
}
if ((lockfds = open(lockfile, O_CREAT | O_WRONLY, 0600)) < 0) {
(void) sprintf(log_buffer, "pbs_comm: unable to open lock file");
log_err(errno, __func__, log_buffer);
return (1);
}
if ((host = tpp_parse_hostname(name, &port)) == NULL) {
sprintf(log_buffer, "Out of memory parsing leaf name");
log_err(errno, __func__, log_buffer);
return (1);
}
rc = 0;
if (pbs_conf.auth_method == AUTH_RESV_PORT) {
rc = set_tpp_config(&pbs_conf, &conf, host, port, routers, pbs_conf.pbs_use_compression,
TPP_AUTH_RESV_PORT, NULL, NULL);
} else {
/* for all non-resv-port based authentication use a callback from TPP */
rc = set_tpp_config(&pbs_conf, &conf, host, port, routers, pbs_conf.pbs_use_compression,
TPP_AUTH_EXTERNAL, get_ext_auth_data, validate_ext_auth_data);
}
if (rc == -1) {
(void) sprintf(log_buffer, "Error setting TPP config");
log_err(-1, __func__, log_buffer);
return (1);
}
free(host);
i = 0;
if (conf.routers) {
while (conf.routers[i]) {
sprintf(log_buffer, "Router[%d]:%s", i, conf.routers[i]);
fprintf(stdout, "%s\n", log_buffer);
log_event(PBSEVENT_SYSTEM | PBSEVENT_FORCE, PBS_EVENTCLASS_SERVER, LOG_INFO, msg_daemonname, log_buffer);
i++;
}
}
#ifndef DEBUG
#ifndef WIN32
if (stalone != 1)
go_to_background();
#endif
#endif
#ifdef WIN32
ss.dwCheckPoint = 0;
g_dwCurrentState = SERVICE_RUNNING;
ss.dwCurrentState = g_dwCurrentState;
if (g_ssHandle != 0) SetServiceStatus(g_ssHandle, &ss);
#endif
if (already_forked == 0)
lock_out(lockfds, F_WRLCK);
/* go_to_backgroud call creates a forked process,
* thus print/log pid only after go_to_background()
* has been called
*/
sprintf(log_buffer, "%s ready (pid=%d), Proxy Name:%s, Threads:%d", argv[0], getpid(), conf.node_name, numthreads);
fprintf(stdout, "%s\n", log_buffer);
log_event(PBSEVENT_SYSTEM | PBSEVENT_FORCE, PBS_EVENTCLASS_SERVER, LOG_INFO, msg_daemonname, log_buffer);
#ifndef DEBUG
pbs_close_stdfiles();
#endif
#ifdef WIN32
signal(SIGINT, stop_me);
signal(SIGTERM, stop_me);
#else
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = hup_me;
if (sigaction(SIGHUP, &act, &oact) != 0) {
log_err(errno, __func__, "sigaction for HUP");
return (2);
}
act.sa_handler = stop_me;
if (sigaction(SIGINT, &act, &oact) != 0) {
log_err(errno, __func__, "sigaction for INT");
return (2);
}
if (sigaction(SIGTERM, &act, &oact) != 0) {
log_err(errno, __func__, "sigactin for TERM");
return (2);
}
if (sigaction(SIGQUIT, &act, &oact) != 0) {
log_err(errno, __func__, "sigactin for QUIT");
return (2);
}
#ifdef SIGSHUTDN
if (sigaction(SIGSHUTDN, &act, &oact) != 0) {
log_err(errno, __func__, "sigactin for SHUTDN");
return (2);
}
#endif /* SIGSHUTDN */
act.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &act, &oact) != 0) {
log_err(errno, __func__, "sigaction for PIPE");
return (2);
}
if (sigaction(SIGUSR1, &act, &oact) != 0) {
log_err(errno, __func__, "sigaction for USR1");
return (2);
}
if (sigaction(SIGUSR2, &act, &oact) != 0) {
log_err(errno, __func__, "sigaction for USR2");
return (2);
}
#endif /* WIN32 */
conf.node_type = TPP_ROUTER_NODE;
conf.numthreads = numthreads;
if ((rpp_fd = tpp_init_router(&conf)) == -1) {
log_err(-1, __func__, "tpp init failed\n");
return 1;
}
/* Protect from being killed by kernel */
daemon_protect(0, PBS_DAEMON_PROTECT_ON);
/* go in a while loop */
while (get_out == 0) {
if (hupped == 1) {
struct pbs_config pbs_conf_bak;
int new_logevent;
hupped = 0; /* reset back */
memcpy(&pbs_conf_bak, &pbs_conf, sizeof(struct pbs_config));
if (pbs_loadconf(1) == 0) {
log_tppmsg(LOG_CRIT, NULL, "Configuration error, ignoring");
memcpy(&pbs_conf, &pbs_conf_bak, sizeof(struct pbs_config));
} else {
/* restore old pbs.conf */
new_logevent = pbs_conf.pbs_comm_log_events;
memcpy(&pbs_conf, &pbs_conf_bak, sizeof(struct pbs_config));
pbs_conf.pbs_comm_log_events = new_logevent;
log_tppmsg(LOG_INFO, NULL, "Processed SIGHUP");
log_event_mask = &pbs_conf.pbs_comm_log_events;
tpp_set_logmask(*log_event_mask);
}
}
sleep(3);
}
tpp_router_shutdown();
log_event(PBSEVENT_SYSTEM | PBSEVENT_FORCE, PBS_EVENTCLASS_SERVER, LOG_NOTICE, msg_daemonname, "Exiting");
log_close(1);
lock_out(lockfds, F_UNLCK); /* unlock */
(void)close(lockfds);
(void)unlink(lockfile);
return 0;
}
/**
* @brief
* processes input jobid according to above mentioned rules
*
* @param[in] job_id_in - input job id
* @param[out] job_id_out - processed job id
* @param[out] server_out - server name
*
* @return int
* @retval 0 success
* @retval 1 error
*
*/
int
get_server(char *job_id_in, char *job_id_out, char *server_out)
{
char *seq_number = NULL;
char *parent_server = NULL;
char *current_server = NULL;
char host_server[PBS_MAXSERVERNAME+1];
if (!job_id_in || !job_id_out || !server_out)
return 1;
if (pbs_loadconf(0) != 1)
return 1;
/* parse the job_id_in into components */
if (parse_jobid(job_id_in, &seq_number, &parent_server,
¤t_server)) {
free(seq_number);
free(parent_server);
free(current_server);
return 1;
}
/* Apply the above rules, in order, except for the locate job request.
That request is only sent if the job is not found on the local server.
*/
server_out[0] = '\0';
if (notNULL(current_server)) /* @server found */
strcpy(server_out, current_server);
free(current_server);
strcpy(job_id_out, seq_number);
free(seq_number);
if (notNULL(parent_server)) {
/* If parent_server matches PBS_SERVER then use it */
if (pbs_conf.pbs_server_name) {
if (strcasecmp(parent_server, pbs_conf.pbs_server_name) == 0) {
strcat(job_id_out, ".");
strcat(job_id_out, pbs_conf.pbs_server_name);
free(parent_server);
return 0;
}
}
if (get_fullhostname(parent_server, host_server,
PBS_MAXSERVERNAME) != 0) {
free(parent_server);
return 1;
}
strcat(job_id_out, ".");
#ifdef NAS_CANON_JOBID /* localmod 086 */
strcat(job_id_out, host_server);
#else
strcat(job_id_out, parent_server);
#endif /* localmod 086 */
if (server_out[0] == '\0')
strcpy(server_out, parent_server);
free(parent_server);
return 0;
}
free(parent_server);
if (pbs_conf.pbs_server_name) {
strcat(job_id_out, ".");
strcat(job_id_out, pbs_conf.pbs_server_name);
} else {
return 1;
}
return 0;
}
/**
* @brief
* Open a connection with a pbs server.
* Do not allow TCP to block us if Server host is down
* At this point, this does not attempt to find a fail_over Server
*
* @param[in] server - specifies the server to which to connect
* @param[in] tout - timeout value for select
*
* @return int
* @retval >= 0 index to the internal connection table representing the
* connection made.
* @retval -1 error encountered in getting index
*/
int
pbs_connect_noblk(char *server, int tout)
{
int out;
int i;
pbs_socklen_t l;
int n;
struct timeval tv;
fd_set fdset;
struct batch_reply *reply;
char server_name[PBS_MAXSERVERNAME+1];
unsigned int server_port;
struct addrinfo *aip, *pai;
struct addrinfo hints;
struct sockaddr_in *inp;
short int connect_err = 0;
struct sockaddr_in sockname;
pbs_socklen_t socknamelen;
#ifdef WIN32
int non_block = 1;
struct sockaddr_in to_sock;
struct sockaddr_in from_sock;
#endif
#ifndef WIN32
int nflg;
int oflg;
#endif
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return -1;
if (pbs_loadconf(0) == 0)
return -1;
/* get server host and port */
server = PBS_get_server(server, server_name, &server_port);
if (server == NULL) {
pbs_errno = PBSE_NOSERVER;
return -1;
}
/* Reserve a connection state record */
if (pbs_client_thread_lock_conntable() != 0)
return -1;
out = -1;
for (i=1;i<NCONNECTS;i++) {
if (connection[i].ch_inuse) continue;
out = i;
connection[out].ch_inuse = 1;
connection[out].ch_errno = 0;
connection[out].ch_socket= -1;
connection[out].ch_errtxt = NULL;
break;
}
if (pbs_client_thread_unlock_conntable() != 0)
return -1; /* pbs_errno set by the function */
if (out < 0) {
pbs_errno = PBSE_NOCONNECTS;
return -1;
}
/* get socket */
#ifdef WIN32
/* the following lousy hack is needed since the socket call needs */
/* SYSTEMROOT env variable properly set! */
if (getenv("SYSTEMROOT") == NULL) {
setenv("SYSTEMROOT", "C:\\WINNT", 1);
setenv("SystemRoot", "C:\\WINNT", 1);
}
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
if (connection[out].ch_socket < 0) {
setenv("SYSTEMROOT", "C:\\WINDOWS", 1);
setenv("SystemRoot", "C:\\WINDOWS", 1);
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
}
#else
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
#endif
if (connection[out].ch_socket < 0) {
connection[out].ch_inuse = 0;
pbs_errno = ERRORNO;
return -1;
}
/* set socket non-blocking */
#ifdef WIN32
if (ioctlsocket(connection[out].ch_socket, FIONBIO, &non_block) == SOCKET_ERROR)
#else
oflg = fcntl(connection[out].ch_socket, F_GETFL) & ~O_ACCMODE;
nflg = oflg | O_NONBLOCK;
if (fcntl(connection[out].ch_socket, F_SETFL, nflg) == -1)
#endif
goto err;
/* and connect... */
strcpy(pbs_server, server); /* set for error messages from commands */
memset(&hints, 0, sizeof(struct addrinfo));
/*
* Why do we use AF_UNSPEC rather than AF_INET? Some
* implementations of getaddrinfo() will take an IPv6
* address and map it to an IPv4 one if we ask for AF_INET
* only. We don't want that - we want only the addresses
* that are genuinely, natively, IPv4 so we start with
* AF_UNSPEC and filter ai_family below.
*/
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
if (getaddrinfo(server, NULL, &hints, &pai) != 0) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_BADHOST;
return -1;
}
for (aip = pai; aip != NULL; aip = aip->ai_next) {
/* skip non-IPv4 addresses */
if (aip->ai_family == AF_INET) {
inp = (struct sockaddr_in *) aip->ai_addr;
break;
}
}
if (aip == NULL) {
/* treat no IPv4 addresses as getaddrinfo() failure */
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_BADHOST;
freeaddrinfo(pai);
return -1;
} else
inp->sin_port = htons(server_port);
if (connect(connection[out].ch_socket,
aip->ai_addr,
aip->ai_addrlen) < 0) {
connect_err = 1;
}
if (connect_err == 1)
{
/* connect attempt failed */
pbs_errno = ERRORNO;
switch (pbs_errno) {
#ifdef WIN32
case WSAEWOULDBLOCK:
#else
case EINPROGRESS:
case EWOULDBLOCK:
#endif
while (1) {
FD_ZERO(&fdset);
FD_SET(connection[out].ch_socket, &fdset);
tv.tv_sec = tout;
tv.tv_usec = 0;
n = select(connection[out].ch_socket+1, NULL, &fdset, NULL, &tv);
if (n > 0) {
pbs_errno = 0;
l = sizeof(pbs_errno);
(void)getsockopt(connection[out].ch_socket,
SOL_SOCKET, SO_ERROR,
&pbs_errno, &l);
if (pbs_errno == 0)
break;
else
goto err;
} if ((n < 0) &&
#ifdef WIN32
(ERRORNO == WSAEINTR)
#else
(ERRORNO == EINTR)
#endif
) {
continue;
} else {
goto err;
}
}
break;
default:
err:
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
freeaddrinfo(pai);
return -1; /* cannot connect */
}
}
freeaddrinfo(pai);
/* reset socket blocking */
#ifdef WIN32
non_block = 0;
if (ioctlsocket(connection[out].ch_socket, FIONBIO, &non_block) == SOCKET_ERROR)
#else
if (fcntl(connection[out].ch_socket, F_SETFL, oflg) < 0)
#endif
goto err;
/*
* multiple threads cant get the same connection id above,
* so no need to lock this piece of code
*/
/* setup connection level thread context */
if (pbs_client_thread_init_connect_context(out) != 0) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
/* pbs_errno set by the pbs_connect_init_context routine */
return -1;
}
/*
* even though the following is communication with server on
* a connection handle, it does not need to be lock since
* this connection handle has not be returned back yet to the client
* so others threads cannot use it
*/
/* send "dummy" connect message */
DIS_tcp_setup(connection[out].ch_socket);
if ((i = encode_DIS_ReqHdr(connection[out].ch_socket,
PBS_BATCH_Connect, pbs_current_user)) ||
(i = encode_DIS_ReqExtend(connection[out].ch_socket,
NULL))) {
pbs_errno = PBSE_SYSTEM;
return -1;
}
if (DIS_tcp_wflush(connection[out].ch_socket)) {
pbs_errno = PBSE_SYSTEM;
return -1;
}
reply = PBSD_rdrpy(out);
PBSD_FreeReply(reply);
/*do configured authentication (kerberos, pbs_iff, whatever)*/
/*Get the socket port for engage_authentication()*/
socknamelen = sizeof(sockname);
if (getsockname(connection[out].ch_socket, (struct sockaddr *)&sockname, &socknamelen))
return -1;
if (engage_authentication(connection[out].ch_socket,
server,
server_port,
&sockname) == -1) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_PERM;
return -1;
}
/* setup DIS support routines for following pbs_* calls */
DIS_tcp_setup(connection[out].ch_socket);
pbs_tcp_timeout = PBS_DIS_TCP_TIMEOUT_VLONG; /* set for 3 hours */
return out;
}
/**
* @brief
* Makes a PBS_BATCH_Connect request to 'server'.
*
* @param[in] server - the hostname of the pbs server to connect to.
* @param[in] extend_data - a string to send as "extend" data.
*
* @return int
* @retval >= 0 index to the internal connection table representing the
* connection made.
* @retval -1 error encountered setting up the connection.
*/
int
__pbs_connect_extend(char *server, char *extend_data)
{
struct sockaddr_in server_addr;
struct sockaddr_in my_sockaddr;
int out;
int i;
int f;
char *altservers[2];
int have_alt = 0;
struct batch_reply *reply;
char server_name[PBS_MAXSERVERNAME+1];
unsigned int server_port;
struct sockaddr_in sockname;
pbs_socklen_t socknamelen;
#ifdef WIN32
struct sockaddr_in to_sock;
struct sockaddr_in from_sock;
#endif
#ifndef WIN32
char pbsrc[_POSIX_PATH_MAX];
struct stat sb;
int using_secondary = 0;
#endif /* not WIN32 */
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return -1;
if (pbs_loadconf(0) == 0)
return -1;
/* get server host and port */
server = PBS_get_server(server, server_name, &server_port);
if (server == NULL) {
pbs_errno = PBSE_NOSERVER;
return -1;
}
if (pbs_conf.pbs_primary && pbs_conf.pbs_secondary) {
/* failover configuered ... */
if (hostnmcmp(server, pbs_conf.pbs_primary) == 0) {
have_alt = 1;
/* We want to try the one last seen as "up" first to not */
/* have connection delays. If the primary was up, there */
/* is no .pbsrc.NAME file. If the last command connected */
/* to the Secondary, then it created the .pbsrc.USER file. */
/* see if already seen Primary down */
#ifdef WIN32
/* due to windows quirks, all try both in same order */
altservers[0] = pbs_conf.pbs_primary;
altservers[1] = pbs_conf.pbs_secondary;
#else
(void)snprintf(pbsrc, _POSIX_PATH_MAX, "%s/.pbsrc.%s", pbs_conf.pbs_tmpdir, pbs_current_user);
if (stat(pbsrc, &sb) == -1) {
/* try primary first */
altservers[0] = pbs_conf.pbs_primary;
altservers[1] = pbs_conf.pbs_secondary;
using_secondary = 0;
} else {
/* try secondary first */
altservers[0] = pbs_conf.pbs_secondary;
altservers[1] = pbs_conf.pbs_primary;
using_secondary = 1;
}
#endif
}
}
/* if specific host name declared for the host on which */
/* this client is running, get its address */
if (pbs_conf.pbs_public_host_name) {
if (get_hostsockaddr(pbs_conf.pbs_public_host_name, &my_sockaddr) != 0)
return -1; /* pbs_errno was set */
}
/* Reserve a connection state record */
if (pbs_client_thread_lock_conntable() != 0)
return -1;
out = -1;
for (i=1;i<NCONNECTS;i++) {
if (connection[i].ch_inuse) continue;
out = i;
connection[out].ch_errno = 0;
connection[out].ch_socket= -1;
connection[out].ch_errtxt = NULL;
connection[out].ch_inuse = 1; /* reserve the socket */
break;
}
if (pbs_client_thread_unlock_conntable() != 0)
return -1; /* pbs_errno set by the function */
if (out < 0) {
pbs_errno = PBSE_NOCONNECTS;
return -1;
}
/*
* connect to server ...
* If attempt to connect fails and if Failover configured and
* if attempting to connect to Primary, try the Secondary
* if attempting to connect to Secondary, try the Primary
*/
for (i=0; i<(have_alt+1); ++i) {
/* get socket */
#ifdef WIN32
/* the following lousy hack is needed since the socket call needs */
/* SYSTEMROOT env variable properly set! */
if (getenv("SYSTEMROOT") == NULL) {
setenv("SYSTEMROOT", "C:\\WINNT", 1);
setenv("SystemRoot", "C:\\WINNT", 1);
}
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
if (connection[out].ch_socket < 0) {
setenv("SYSTEMROOT", "C:\\WINDOWS", 1);
setenv("SystemRoot", "C:\\WINDOWS", 1);
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
}
#else
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
#endif
if (connection[out].ch_socket < 0) {
connection[out].ch_inuse = 0;
pbs_errno = errno;
return -1;
}
/* and connect... */
if (have_alt) {
server = altservers[i];
}
strcpy(pbs_server, server); /* set for error messages from commands */
/* If a specific host name is defined which the client should use */
if (pbs_conf.pbs_public_host_name) {
/* my address will be in my_sockaddr, bind the socket to it */
my_sockaddr.sin_port = 0;
if (bind(connection[out].ch_socket, (struct sockaddr *)&my_sockaddr, sizeof(my_sockaddr)) != 0) {
return -1;
}
}
if (get_hostsockaddr(server, &server_addr) != 0)
return -1;
server_addr.sin_port = htons(server_port);
if (connect(connection[out].ch_socket,
(struct sockaddr *)&server_addr,
sizeof(struct sockaddr)) == 0) {
break;
} else {
/* connect attempt failed */
CLOSESOCKET(connection[out].ch_socket);
pbs_errno = errno;
}
}
if (i >= (have_alt+1)) {
connection[out].ch_inuse = 0;
return -1; /* cannot connect */
}
#ifndef WIN32
if (have_alt && (i == 1)) {
/* had to use the second listed server ... */
if (using_secondary == 1) {
/* remove file that causes trying the Secondary first */
unlink(pbsrc);
} else {
/* create file that causes trying the Primary first */
f = open(pbsrc, O_WRONLY|O_CREAT, 0200);
if (f != -1)
(void)close(f);
}
}
#endif
/* setup connection level thread context */
if (pbs_client_thread_init_connect_context(out) != 0) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
/* pbs_errno set by the pbs_connect_init_context routine */
return -1;
}
/*
* No need for global lock now on, since rest of the code
* is only communication on a connection handle.
* But we dont need to lock the connection handle, since this
* connection handle is not yet been returned to the client
*/
/* The following code was originally put in for HPUX systems to deal
* with the issue where returning from the connect() call doesn't
* mean the connection is complete. However, this has also been
* experienced in some Linux ppc64 systems like js-2. Decision was
* made to enable this harmless code for all architectures.
* FIX: Need to use the socket to send
* a message to complete the process. For IFF authentication there is
* no leading authentication message needing to be sent on the client
* socket, so will send a "dummy" message and discard the replyback.
*/
#if !defined(PBS_SECURITY ) || (PBS_SECURITY == STD )
DIS_tcp_setup(connection[out].ch_socket);
if ((i = encode_DIS_ReqHdr(connection[out].ch_socket,
PBS_BATCH_Connect, pbs_current_user)) ||
(i = encode_DIS_ReqExtend(connection[out].ch_socket,
extend_data))) {
pbs_errno = PBSE_SYSTEM;
return -1;
}
if (DIS_tcp_wflush(connection[out].ch_socket)) {
pbs_errno = PBSE_SYSTEM;
return -1;
}
reply = PBSD_rdrpy(out);
PBSD_FreeReply(reply);
#endif /* PBS_SECURITY ... */
/*do configured authentication (kerberos, pbs_iff, whatever)*/
/*Get the socket port for engage_authentication() */
socknamelen = sizeof(sockname);
if (getsockname(connection[out].ch_socket, (struct sockaddr *)&sockname, &socknamelen))
return -1;
if (engage_authentication(connection[out].ch_socket,
server,
server_port,
&sockname) == -1) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_PERM;
return -1;
}
/* setup DIS support routines for following pbs_* calls */
DIS_tcp_setup(connection[out].ch_socket);
pbs_tcp_timeout = PBS_DIS_TCP_TIMEOUT_VLONG; /* set for 3 hours */
/*
* Disable Nagle's algorithm on the TCP connection to server.
* Nagle's algorithm is hurting cmd-server communication.
*/
if (pbs_connection_set_nodelay(out) == -1) {
CLOSESOCKET(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_SYSTEM;
return -1;
}
return out;
}
/**
* @brief
* The main function in C - entry point
*
* @param[in] argc - argument count
* @param[in] argv - pointer to argument array
*
* @return int
* @retval 0 - success
* @retval !0 - error
*/
int
main(int argc, char *argv[])
{
int i, rc;
char passwd[MAX_PASSWORD_LEN + 1] = {'\0'};
char passwd2[MAX_PASSWORD_LEN + 1];
char *pquoted;
char pwd_file[MAXPATHLEN + 1];
char userid[LOGIN_NAME_MAX + 1];
int fd, errflg = 0;
int gen_pwd = 0;
char sqlbuff[1024];
int db_conn_error=0;
char *db_errmsg = NULL;
int pmode;
int change_user = 0;
char *olduser;
int update_db = 0;
char getopt_format[5];
char prog[]="pbs_ds_password";
char errmsg[PBS_MAX_DB_CONN_INIT_ERR + 1];
conn = NULL;
pwd_file_new[0]=0;
/*test for real deal or just version and exit*/
PRINT_VERSION_AND_EXIT(argc, argv);
/* read configuration file */
if (pbs_loadconf(0) == 0) {
fprintf(stderr, "%s: Could not load pbs configuration\n", prog);
return (-1);
}
/* backup old user name */
if ((olduser = pbs_get_dataservice_usr(errmsg, PBS_MAX_DB_CONN_INIT_ERR)) == NULL) {
fprintf(stderr, "%s: Could not retrieve current data service user\n", prog);
if (strlen(errmsg) > 0)
fprintf(stderr, "%s\n", errmsg);
return (-1);
}
if (pbs_conf.pbs_data_service_host == NULL)
update_db = 1;
userid[0]=0; /* empty user id */
strcpy(getopt_format, "rC:");
while ((i = getopt(argc, argv, getopt_format)) != EOF) {
switch (i) {
case 'r':
gen_pwd = 1;
break;
case 'C':
strcpy(userid, optarg);
break;
case '?':
default:
errflg++;
}
}
if (errflg) {
fprintf(stderr, "\nusage:\t%s [-r] [-C username]\n", prog);
fprintf(stderr, " \t%s --version\n", prog);
return (-1);
}
/* NOTE : This functionality is added just for the automation testing purpose.
* Usage: pbs_ds_password <password>
*/
if (argv[optind] != NULL) {
gen_pwd = 0;
strncpy(passwd, argv[optind], sizeof(passwd));
passwd[sizeof(passwd) - 1] = '\0';
}
/* check admin privileges */
#ifdef WIN32
if (!isAdminPrivilege(getlogin())) {
fprintf(stderr, "pbs_ds_password: Must be run by Admin\n");
return (1);
}
#else
if ((getuid() != 0) || (geteuid() != 0)) {
fprintf(stderr, "%s: Must be run by root\n", prog);
return (1);
}
#endif /* WIN32 */
change_user = 0;
/* if the -C option was specified read the user from pbs.conf */
if (userid[0] != 0) {
if (strcmp(olduser, userid) != 0) {
change_user = 1;
}
}
if (change_user == 1) {
/* check that the supplied user-id exists (and is non-root on unix) */
if (check_user(userid) != 0) {
#ifdef WIN32
fprintf(stderr, "\n%s: User-id %s does not exist\n", prog, userid);
#else
fprintf(stderr, "\n%s: User-id %s does not exist/is root user/home dir is not accessible\n", prog, userid);
#endif
return (-1);
}
}
atexit(cleanup);
if (update_db == 1) {
/* then connect to database */
conn = pbs_db_init_connection(NULL, PBS_DB_CNT_TIMEOUT_NORMAL, 1, &db_conn_error, errmsg, PBS_MAX_DB_CONN_INIT_ERR);
if (!conn) {
get_db_errmsg(db_conn_error, &db_errmsg);
fprintf(stderr, "%s: %s\n", prog, db_errmsg);
if (strlen(errmsg) > 0)
fprintf(stderr, "%s\n", errmsg);
return -1;
}
db_conn_error = pbs_db_connect(conn);
if (db_conn_error == PBS_DB_SUCCESS && change_user == 1) {
/* able to connect ? Thats bad, PBS or dataservice is running */
fprintf(stderr, "%s: PBS Services and/or PBS Data Service is running\n", prog);
fprintf(stderr, " Stop PBS and Data Services before changing Data Service user\n");
return (-1);
}
if (db_conn_error != PBS_DB_SUCCESS) {
if (db_conn_error == PBS_DB_CONNREFUSED) {
/* start db only if it was not already running */
if (pbs_startup_db(&db_errmsg) != 0) {
if (db_errmsg)
fprintf(stderr, "%s: Failed to start PBS dataservice:[%s]\n", prog, db_errmsg);
else
fprintf(stderr, "%s: Failed to start PBS dataservice\n", prog);
return (-1);
}
started_db = 1;
}
db_conn_error = pbs_db_connect(conn);
if (db_conn_error != PBS_DB_SUCCESS) {
get_db_errmsg(db_conn_error, &db_errmsg);
if (conn->conn_db_err)
fprintf(stderr, "%s: Could not connect to PBS data service:%s:[%s]\n", prog,
db_errmsg, (char*)conn->conn_db_err);
else
fprintf(stderr, "%s: Could not connect to PBS data service:%s\n", prog, db_errmsg);
return (-1);
}
}
}
if (gen_pwd == 0 && passwd[0] == '\0') {
/* ask user to enter password twice */
printf("Enter the password:"******"\nRe-enter the password:"******"\n\n");
if (strcmp(passwd, passwd2) != 0) {
fprintf(stderr, "Entered passwords do not match\n");
return (-2);
}
if (strlen(passwd) == 0) {
fprintf(stderr, "Blank password is not allowed\n");
return (-2);
}
} else if (gen_pwd == 1) {
gen_password(passwd, 16);
}
rc = pbs_encrypt_pwd(passwd, &cred_type, &cred_buf, &cred_len);
if (rc != 0) {
fprintf(stderr, "%s: Failed to encrypt password\n", prog);
return (-1);
}
/* escape password to use in sql strings later */
if ((pquoted = pbs_db_escape_str(conn, passwd)) == NULL) {
fprintf(stderr, "%s: Out of memory\n", prog);
return -1;
}
#ifdef WIN32
sprintf(pwd_file_new, "%s\\server_priv\\db_password.new", pbs_conf.pbs_home_path);
sprintf(pwd_file, "%s\\server_priv\\db_password", pbs_conf.pbs_home_path);
#else
sprintf(pwd_file_new, "%s/server_priv/db_password.new", pbs_conf.pbs_home_path);
sprintf(pwd_file, "%s/server_priv/db_password", pbs_conf.pbs_home_path);
#endif
/* write encrypted password to the password file */
#ifdef WIN32
pmode = _S_IWRITE | _S_IREAD;
fix_perms2(pwd_file_new, pwd_file);
if ((fd = open(pwd_file_new, O_WRONLY | O_TRUNC | O_CREAT | O_Sync | O_BINARY,
pmode)) == -1)
#else
pmode = 0600;
if ((fd = open(pwd_file_new, O_WRONLY | O_TRUNC | O_CREAT | O_Sync,
pmode)) == -1)
#endif
{
perror("open/create failed");
fprintf(stderr, "%s: Unable to create file %s\n", prog, pwd_file_new);
return (-1);
}
#ifdef WIN32
secure_file(pwd_file_new, "Administrators",
READS_MASK|WRITES_MASK|STANDARD_RIGHTS_REQUIRED);
setmode(fd, O_BINARY);
#endif
if (update_db == 1) {
/* change password only if this config option is not set */
if (pbs_db_begin_trx(conn, 0, 0) != 0) {
fprintf(stderr, "%s: Could not start transaction\n", prog);
unlink(pwd_file_new);
return -1;
}
if (change_user == 1) {
/* check whether user exists */
snprintf(sqlbuff, sizeof(sqlbuff),
"select usename from pg_user where usename = '%s'",
userid);
if (pbs_db_execute_str(conn, sqlbuff) == 1) {
/* now attempt to create new user & set the database passwd to the un-encrypted password */
snprintf(sqlbuff, sizeof(sqlbuff),
"create user \"%s\" SUPERUSER ENCRYPTED PASSWORD '%s'",
userid, pquoted);
} else {
/* attempt to alter new user & set the database passwd to the un-encrypted password */
snprintf(sqlbuff, sizeof(sqlbuff),
"alter user \"%s\" SUPERUSER ENCRYPTED PASSWORD '%s'",
userid, pquoted);
}
memset(passwd, 0, sizeof(passwd));
memset(passwd2, 0, sizeof(passwd2));
memset(pquoted, 0, (sizeof(char) * strlen(pquoted)));
if (pbs_db_execute_str(conn, sqlbuff) == -1) {
fprintf(stderr, "%s: Failed to create/alter user id %s\n", prog, userid);
(void) pbs_db_end_trx(conn, PBS_DB_ROLLBACK);
return -1;
}
} else {
/* now attempt to set the database passwd to the un-encrypted password */
/* alter user ${user} SUPERUSER ENCRYPTED PASSWORD '${passwd}' */
sprintf(sqlbuff, "alter user \"%s\" SUPERUSER ENCRYPTED PASSWORD '%s'",
olduser, pquoted);
memset(passwd, 0, sizeof(passwd));
memset(passwd2, 0, sizeof(passwd2));
memset(pquoted, 0, (sizeof(char) * strlen(pquoted)));
if (pbs_db_execute_str(conn, sqlbuff) == -1) {
fprintf(stderr, "%s: Failed to create/alter user id %s\n", prog, userid);
(void) pbs_db_end_trx(conn, PBS_DB_ROLLBACK);
return -1;
}
}
}
if (write(fd, cred_buf, cred_len) != cred_len) {
perror("write failed");
fprintf(stderr, "%s: Unable to write to file %s\n", prog, pwd_file_new);
if (update_db == 1) {
(void) pbs_db_end_trx(conn, PBS_DB_ROLLBACK);
}
return -1;
}
close(fd);
free(cred_buf);
#ifdef WIN32
if (MoveFileEx(pwd_file_new, pwd_file,
MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH) == 0) {
errno = GetLastError();
fprintf(stderr, "MoveFileEx(%s, %s) failed!",
pwd_file_new, pwd_file);
if (update_db == 1) {
(void) pbs_db_end_trx(conn, PBS_DB_ROLLBACK);
}
return (-1);
}
#else
if (rename(pwd_file_new, pwd_file) != 0) {
if (update_db == 1) {
(void) pbs_db_end_trx(conn, PBS_DB_ROLLBACK);
}
return (-1);
}
#endif
if (update_db == 1) {
/* commit to database */
(void) pbs_db_end_trx(conn, PBS_DB_COMMIT);
cleanup(); /* cleanup will disconnect and delete tmp file too */
}
printf("---> Updated user password\n");
if (update_db == 1 && change_user == 1) {
printf("---> Updated user in datastore\n");
printf("---> Stored user password in datastore\n");
}
if (change_user == 1) {
char usr_file[MAXPATHLEN + 1];
#ifdef WIN32
sprintf(usr_file, "%s\\server_priv\\db_user", pbs_conf.pbs_home_path);
#else
sprintf(usr_file, "%s/server_priv/db_user", pbs_conf.pbs_home_path);
#endif
/* update PBS_HOME/server_priv/db_user file with the new user name */
if (update_db_usr(usr_file, userid) != 0) {
fprintf(stderr, "Unable to update file %s\n", usr_file);
return -1;
}
printf("---> Updated new user\n");
}
if (update_db == 1 && change_user == 1) {
char datastore[MAXPATHLEN + 1];
#ifndef WIN32
/* ownership is changed only for Unix users
* On windows, these files are allways owned by the user who installed the database
* and writable by administrators anyway
*/
sprintf(datastore, "%s/datastore", pbs_conf.pbs_home_path);
/* change ownership of the datastore directories to the new user, so that db can be started again */
if (change_ownership(datastore, userid) != 0) {
fprintf(stderr, "%s: Failed to change ownership on path %s\n", prog, datastore);
return -1;
}
printf("---> Changed ownership of %s to user %s\n", datastore, userid);
#endif
/* reload configuration file */
if (pbs_loadconf(1) == 0) {
fprintf(stderr, "%s: Could not load pbs configuration\n", prog);
return (-1);
}
if (pbs_startup_db(&db_errmsg) != 0) {
if (db_errmsg)
fprintf(stderr, "%s: Failed to start PBS dataservice as new user:[%s]\n", prog, db_errmsg);
else
fprintf(stderr, "%s: Failed to start PBS dataservice as new user\n", prog);
return (-1);
}
started_db = 1;
/* connect again to drop the old user */
conn = pbs_db_init_connection(NULL, PBS_DB_CNT_TIMEOUT_NORMAL, 1, &db_conn_error, errmsg, PBS_MAX_DB_CONN_INIT_ERR);
if (!conn) {
get_db_errmsg(db_conn_error, &db_errmsg);
fprintf(stderr, "%s: %s\n", prog, db_errmsg);
if (strlen(errmsg) > 0)
fprintf(stderr, "%s\n", errmsg);
return -1;
}
db_conn_error = pbs_db_connect(conn);
if (db_conn_error != PBS_DB_SUCCESS) {
get_db_errmsg(db_conn_error, &db_errmsg);
if (conn->conn_db_err)
fprintf(stderr, "%s: Could not connect to PBS data service as new user:%s[%s]\n", prog,
db_errmsg, (char*)conn->conn_db_err);
else
fprintf(stderr, "%s: Could not connect to PBS data service as new user:%s\n", prog, db_errmsg);
return (-1);
}
/* delete the old user from the database */
sprintf(sqlbuff, "drop user \"%s\"", olduser);
pbs_db_execute_str(conn, sqlbuff);
}
printf("---> Success\n");
return (0);
}
