int
ls_stdinmode(int onoff)
{
fd_set rmask;
struct timeval timeout;
struct lslibNiosHdr reqHdr, replyHdr;
sigset_t newMask, oldMask;
int cc;
if (!nios_ok_) {
lserrno = LSE_NIOS_DOWN;
return(-1);
}
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
SET_LSLIB_NIOS_HDR(reqHdr,
(onoff ? LIB_NIOS_REM_ON : LIB_NIOS_REM_OFF), 0);
FD_ZERO(&rmask);
FD_SET(cli_nios_fd[0], &rmask);
timeout.tv_sec = NIOS_TIMEOUT;
timeout.tv_usec = 0;
if (b_write_fix(cli_nios_fd[0], (char *) &reqHdr, sizeof(reqHdr)) !=
sizeof(reqHdr)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if ((cc = select(cli_nios_fd[0] + 1, &rmask, 0, 0, &timeout)) <= 0) {
if (cc == 0)
lserrno = LSE_TIME_OUT;
else
lserrno = LSE_SELECT_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &replyHdr, sizeof(replyHdr))
== -1) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (replyHdr.opCode != REM_ONOFF) {
lserrno = LSE_PROTOC_NIOS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(0);
}
int
ls_donerex(void)
{
fd_set rmask;
struct timeval timeout;
struct lslibNiosHdr reqHdr, replyHdr;
sigset_t newMask, oldMask;
if (!nios_ok_) {
lserrno = LSE_NIOS_DOWN;
return(-1);
}
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
SET_LSLIB_NIOS_HDR(reqHdr, LIB_NIOS_EXIT, 0);
FD_ZERO(&rmask);
FD_SET(cli_nios_fd[0], &rmask);
timeout.tv_sec = NIOS_TIMEOUT;
timeout.tv_usec = 0;
if (b_write_fix(cli_nios_fd[0], (char *)&reqHdr, sizeof(reqHdr)) !=
sizeof(reqHdr)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (select(cli_nios_fd[0] + 1, &rmask, 0, 0, &timeout) <= 0) {
lserrno = LSE_SELECT_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &replyHdr, sizeof(replyHdr))
== -1) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (replyHdr.opCode != NIOS_OK) {
lserrno = LSE_PROTOC_NIOS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
nios_ok_ = FALSE;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(0);
}
int
ls_sndmsg(int tid, char *buf, int count, task_sock)
{
int cc, sock;
struct tid *tid;
if (amSlave_ == TRUE)
sock = msock_;
else {
if ((tid = tid_find(tid, task_sock)) == NULL)
return (-1);
sock = tid->sock;
}
return(b_write_fix( sock, buf, count) );
}
int
ls_rtaske(char *host, char **argv, int options, char **envp)
{
static u_short retport;
static int rpid;
static int reg_ls_donerex = FALSE;
struct sockaddr_in sin;
int max;
char c_chfd[8];
char pathbuf[MAXPATHLEN];
int d;
int niosOptions = 0;
char *new_argv[5];
int pid;
int s;
int descriptor[2];
struct resCmdBill cmdmsg;
struct lslibNiosRTask taskReq;
u_short taskPort = 0;
sigset_t newMask;
sigset_t oldMask;
socklen_t len;
if (!reg_ls_donerex) {
atexit( (void (*) ()) ls_donerex);
reg_ls_donerex = TRUE;
}
if (_isconnected_(host, descriptor))
s = descriptor[0];
else if ((s = ls_connect(host)) < 0)
return(-1);
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0){
closesocket(s);
_lostconnection_(host);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
}
if (!nios_ok_)
niosOptions = options & REXF_SYNCNIOS;
options &= ~REXF_SYNCNIOS;
cmdmsg.options = options;
if (cmdmsg.options & REXF_SHMODE)
cmdmsg.options |= REXF_USEPTY;
if (!isatty(0) && !isatty(1))
cmdmsg.options &= ~REXF_USEPTY;
else if (cmdmsg.options & REXF_USEPTY ){
if (options & REXF_TTYASYNC){
if (rstty_async_(host) < 0) {
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
} else {
if (rstty_(host) < 0) {
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
}
}
if ( (genParams_[LSF_INTERACTIVE_STDERR].paramValue != NULL)
&& (strcasecmp(genParams_[LSF_INTERACTIVE_STDERR].paramValue,
"y") == 0) ) {
cmdmsg.options |= REXF_STDERR;
}
if (!nios_ok_) {
initSigHandler(SIGTSTP);
initSigHandler(SIGTTIN);
initSigHandler(SIGTTOU);
if (socketpair(AF_UNIX, SOCK_STREAM, 0, cli_nios_fd) < 0) {
lserrno = LSE_SOCK_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
closesocket(s);
return(-1);
}
if ((pid = fork()) != 0) {
int mypid;
close(cli_nios_fd[1]);
mypid = getpid();
if (b_write_fix(cli_nios_fd[0], (char *) &mypid, sizeof (mypid)) !=
sizeof (mypid)) {
close(cli_nios_fd[0]);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
lserrno = LSE_MSG_SYS;
return (-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &retport, sizeof (u_short))
!= sizeof(u_short) ) {
close(cli_nios_fd[0]);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
lserrno = LSE_MSG_SYS;
return (-1);
}
nios_ok_ = TRUE;
if (waitpid(pid, 0, 0) <0) {
if (errno != ECHILD) {
close(cli_nios_fd[0]);
nios_ok_ = FALSE;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
lserrno = LSE_WAIT_SYS;
return (-1);
}
}
} else {
if (fork()) {
max = sysconf(_SC_OPEN_MAX);
for (d = 3; d < max; ++d) {
(void)close(d);
}
exit(0);
}
if (initenv_(NULL, NULL) <0)
exit (-1);
strcpy(pathbuf, genParams_[LSF_SERVERDIR].paramValue);
strcat(pathbuf, "/nios");
sprintf(c_chfd, "%d", cli_nios_fd[1]);
new_argv[0] = pathbuf;
new_argv[1] = c_chfd;
if (cmdmsg.options & REXF_USEPTY) {
if (cmdmsg.options & REXF_SHMODE)
new_argv[2] = "2";
else
new_argv[2] = "1";
}
else
new_argv[2] = "0";
new_argv[3] = NULL;
max = sysconf(_SC_OPEN_MAX);
for (d = 3; d < max; ++d) {
if (d != cli_nios_fd[1])
(void)close(d);
}
for (d = 1; d < NSIG; d++)
Signal_(d, SIG_DFL);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
(void)lsfExecvp(new_argv[0], new_argv);
exit(-1);
}
}
if (envp) {
if (ls_rsetenv_async (host, envp) < 0) {
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
}
if (rexcwd_[0] != '\0')
strcpy(cmdmsg.cwd, rexcwd_);
else if (mygetwd_(cmdmsg.cwd) == 0) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_WDIR;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
rpid++;
cmdmsg.rpid = rpid;
cmdmsg.retport = retport;
cmdmsg.argv = argv;
cmdmsg.priority = 0;
if (sendCmdBill_(s, (resCmd) RES_EXEC, &cmdmsg, NULL, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (cmdmsg.options & REXF_TASKPORT) {
if ((taskPort = getTaskPort(s)) == 0) {
closesocket(s);
_lostconnection_(host);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
}
len = sizeof(sin);
if (getpeername(s, (struct sockaddr *) &sin, &len) <0) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_SOCK_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
SET_LSLIB_NIOS_HDR(taskReq.hdr, LIB_NIOS_RTASK, sizeof(taskReq.r));
taskReq.r.pid = rpid;
taskReq.r.peer = sin.sin_addr;
taskReq.r.pid = (niosOptions & REXF_SYNCNIOS)? -rpid : rpid;
if (b_write_fix(cli_nios_fd[0], (char *) &taskReq, sizeof(taskReq))
!= sizeof(taskReq)) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
if (tid_register(rpid, s, taskPort, host, options & REXF_TASKINFO) == -1) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_MALLOC;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (-1);
}
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (rpid);
}
static int
rwait_(int tid, LS_WAIT_T *status, int options, struct rusage *ru)
{
int rpid;
struct lslibNiosWaitReq req;
struct lslibNiosHdr hdr;
fd_set rmask;
struct timeval timeout;
sigset_t newMask, oldMask;
int cc;
if (tid < 0) {
lserrno = LSE_BAD_ARGS;
return -1;
}
if (!nios_ok_) {
lserrno = LSE_NORCHILD;
return -1;
}
blockALL_SIGS_(&newMask, &oldMask);
Start:
FD_ZERO(&rmask);
FD_SET(cli_nios_fd[0], &rmask);
timeout.tv_sec = NIOS_TIMEOUT;
timeout.tv_usec = 0;
SET_LSLIB_NIOS_HDR(req.hdr, LIB_NIOS_RWAIT, sizeof(req.r));
req.r.options = options;
req.r.tid = tid;
if (b_write_fix(cli_nios_fd[0], (char *) &req, sizeof(req))
!= sizeof(req)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return -1;
}
cc = select(cli_nios_fd[0] + 1, &rmask, 0, 0, &timeout);
if (cc <= 0) {
if (cc < 0)
lserrno = LSE_SELECT_SYS;
else
lserrno = LSE_TIME_OUT;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return -1;
}
if (b_read_fix(cli_nios_fd[0], (char *) &hdr, sizeof(hdr)) == -1) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return -1;
}
if (WAIT_BLOCK(options) && hdr.opCode == NONB_RETRY) {
restartRWait(oldMask);
if(!isPamBlockWait){
goto Start;
}
}
switch (hdr.opCode) {
case CHILD_FAIL:
lserrno = LSE_NORCHILD;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return -1;
case NONB_RETRY:
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return 0;
case CHILD_OK:
rpid = readWaitReply(status, ru);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return (rpid);
default:
lserrno = LSE_PROTOC_NIOS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return -1;
}
}
int
verifyEAuth_(struct lsfAuth *auth, struct sockaddr_in *from)
{
static char fname[] = "verifyEAuth/lib.eauth.c";
char path[MAXPATHLEN], uData[256], ok;
char *eauth_client, *eauth_server, *eauth_aux_data, *eauth_aux_status;
int cc, i;
static int connected = FALSE;
static int in[2], out[2];
if (logclass & LC_TRACE)
ls_syslog(LOG_DEBUG, "%s ...", fname);
if (!(genParams_[LSF_AUTH].paramValue &&
!strcmp(genParams_[LSF_AUTH].paramValue, AUTH_PARAM_EAUTH)))
return -1;
eauth_client = getenv("LSF_EAUTH_CLIENT");
eauth_server = getenv("LSF_EAUTH_SERVER");
eauth_aux_data = getenv("LSF_EAUTH_AUX_DATA");
eauth_aux_status = getenv("LSF_EAUTH_AUX_STATUS");
sprintf(uData, "%d %d %s %s %d %d %s %s %s %s\n", auth->uid, auth->gid,
auth->lsfUserName, inet_ntoa(from->sin_addr),
(int) ntohs(from->sin_port), auth->k.eauth.len,
(eauth_client ? eauth_client : "NULL"),
(eauth_server ? eauth_server : "NULL"),
(eauth_aux_data ? eauth_aux_data : "NULL"),
(eauth_aux_status ? eauth_aux_status : "NULL"));
memset(path,0,sizeof(path));
ls_strcat(path,sizeof(path),genParams_[LSF_SERVERDIR].paramValue);
ls_strcat(path,sizeof(path),"/");
ls_strcat(path,sizeof(path),EAUTHNAME);
if (logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: <%s> path <%s> connected=%d", fname, uData,
path, connected);
if (connected) {
struct timeval tv;
fd_set mask;
FD_ZERO(&mask);
FD_SET(out[0], &mask);
tv.tv_sec = 0;
tv.tv_usec = 0;
if ((cc = select(out[0] + 1, &mask, NULL, NULL, &tv)) > 0) {
if (logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: <%s> got exception",
fname, uData);
connected = FALSE;
close(in[1]);
close(out[0]);
} else {
if (cc < 0)
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "select", uData);
}
if (logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: <%s> select returned cc=%d", fname,
uData, cc);
}
if (!connected) {
int pid;
char *user;
{
if ((user = getLSFAdmin()) == NULL) {
return -1;
}
}
if (pipe(in) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "pipe(in)", uData);
lserrno = LSE_SOCK_SYS;
return -1;
}
if (pipe(out) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "pipe(out)", uData);
lserrno = LSE_SOCK_SYS;
return -1;
}
if ((pid = fork()) == 0) {
char *myargv[3];
struct passwd *pw;
if ((pw = getpwnam(user)) == (struct passwd *)NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "getpwnam", user);
exit(-1);
}
if (setuid(pw->pw_uid) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_D_FAIL_M, fname, "setuid", (int)pw->pw_uid);
exit(-1);
}
for (i = 1; i < NSIG; i++)
Signal_(i, SIG_DFL);
alarm(0);
close(in[1]);
if (dup2(in[0], 0) == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "dup2(in[0])", uData);
}
close(out[0]);
if (dup2(out[1], 1) == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "dup2(out[1])", uData);
}
for (i = 3; i < sysconf(_SC_OPEN_MAX); i++)
close(i);
myargv[0] = path;
myargv[1] = "-s";
myargv[2] = NULL;
execvp(myargv[0], myargv);
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "execvp", myargv[0]);
exit(-1);
}
close(in[0]);
close(out[1]);
if (pid == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "fork", path);
close(in[1]);
close(out[0]);
lserrno = LSE_FORK;
return -1;
}
connected = TRUE;
}
i = strlen(uData);
if ((cc = b_write_fix(in[1], uData, i)) != i) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5513,
"%s: b_write_fix <%s> failed, cc=%d, i=%d: %m"), /* catgets 5513 */
fname, uData, cc, i);
CLOSEHANDLE(in[1]);
CLOSEHANDLE(out[0]);
connected = FALSE;
return -1;
}
if(logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, _i18n_msg_get(ls_catd , NL_SETN, 5514,
"%s: b_write_fix <%s> ok, cc=%d, i=%d"),
fname, uData, cc, i);
if ((cc = b_write_fix(in[1], auth->k.eauth.data, auth->k.eauth.len))
!= auth->k.eauth.len) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5515,
"%s: b_write_fix <%s> failed, eauth.len=%d, cc=%d"), /* catgets 5515 */
fname, uData, auth->k.eauth.len, cc);
CLOSEHANDLE(in[1]);
CLOSEHANDLE(out[0]);
connected = FALSE;
return -1;
}
if(logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, _i18n_msg_get(ls_catd , NL_SETN, 5516,
"%s: b_write_fix <%s> ok, eauth.len=%d, eauth.data=%.*s cc=%d:"),
fname, uData, auth->k.eauth.len,
auth->k.eauth.len, auth->k.eauth.data,cc);
if ((cc = b_read_fix(out[0], &ok, 1)) != 1) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5517,
"%s: b_read_fix <%s> failed, cc=%d: %m"), /* catgets 5517 */
fname, uData, cc);
CLOSEHANDLE(in[1]);
CLOSEHANDLE(out[0]);
connected = FALSE;
return -1;
}
if (ok != '1') {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5518,
"%s: eauth <%s> len=%d failed, rc=%c"), /* catgets 5518 */
fname, uData, auth->k.eauth.len, ok);
return -1;
}
return 0;
}
int
ls_getstdin(int on, int *rpidlist, int maxlen)
{
fd_set rmask;
struct timeval timeout;
struct lslibNiosStdin req;
struct lslibNiosGetStdinReply reply;
sigset_t newMask, oldMask;
if (!nios_ok_) {
lserrno = LSE_NIOS_DOWN;
return(-1);
}
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
FD_ZERO(&rmask);
FD_SET(cli_nios_fd[0], &rmask);
timeout.tv_sec = NIOS_TIMEOUT;
timeout.tv_usec = 0;
SET_LSLIB_NIOS_HDR(req.hdr, LIB_NIOS_GETSTDIN, sizeof(req.r.set_on));
req.r.set_on = on;
if (b_write_fix(cli_nios_fd[0], (char *)&req, sizeof(req.hdr) +
sizeof(req.r.set_on)) != sizeof(req.hdr) +
sizeof(req.r.set_on)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (select(cli_nios_fd[0] + 1, &rmask, 0, 0, &timeout) <= 0) {
lserrno = LSE_SELECT_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &reply.hdr, sizeof(reply.hdr))
== -1) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
switch(reply.hdr.opCode) {
case STDIN_OK:
break;
default:
lserrno = LSE_PROTOC_NIOS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (reply.hdr.len)
if (b_read_fix(cli_nios_fd[0], (char *)reply.rpidlist, reply.hdr.len)
!= reply.hdr.len) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (reply.hdr.len <= maxlen*sizeof(int)) {
memcpy((char *)rpidlist, (char *)reply.rpidlist, reply.hdr.len);
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(reply.hdr.len/sizeof(int));
} else {
lserrno = LSE_RPIDLISTLEN;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
}
int
ls_setstdin(int on, int *rpidlist, int len)
{
fd_set rmask;
struct timeval timeout;
struct lslibNiosStdin req;
struct lslibNiosHdr replyHdr;
sigset_t newMask, oldMask;
if (!nios_ok_) {
lserrno = LSE_NIOS_DOWN;
return(-1);
}
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
if ((rpidlist == NULL && len != 0)
|| (len < 0) || (len > NOFILE)) {
lserrno = LSE_SETPARAM;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
FD_ZERO(&rmask);
FD_SET(cli_nios_fd[0], &rmask);
timeout.tv_sec = NIOS_TIMEOUT;
timeout.tv_usec = 0;
SET_LSLIB_NIOS_HDR(req.hdr, LIB_NIOS_SETSTDIN, sizeof(req.r) +
len * sizeof(int));
req.r.set_on = on;
req.r.len = len;
if (b_write_fix(cli_nios_fd[0], (char *)&req, sizeof(req.hdr) +
sizeof(req.r)) != sizeof(req.hdr) + sizeof(req.r)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (rpidlist != NULL && len != 0) {
if (b_write_fix(cli_nios_fd[0], (char *)rpidlist, len*sizeof(int))
!= len * sizeof(int)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
}
if (select(cli_nios_fd[0] + 1, &rmask, 0, 0, &timeout) <= 0) {
lserrno = LSE_SELECT_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &replyHdr, sizeof(replyHdr))
== -1) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
switch(replyHdr.opCode) {
case STDIN_FAIL:
lserrno = LSE_SETPARAM;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
case STDIN_OK:
break;
default:
lserrno = LSE_PROTOC_NIOS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(0);
}
int
ls_setstdout(int on, char *format)
{
fd_set rmask;
struct timeval timeout;
struct lslibNiosStdout req;
struct lslibNiosHdr replyHdr;
sigset_t newMask, oldMask;
if (!nios_ok_) {
lserrno = LSE_NIOS_DOWN;
return(-1);
}
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
FD_ZERO(&rmask);
FD_SET(cli_nios_fd[0], &rmask);
timeout.tv_sec = NIOS_TIMEOUT;
timeout.tv_usec = 0;
req.r.set_on = on;
req.r.len = (format == NULL) ? 0 : strlen(format);
if (req.r.len > 0)
req.r.len++;
SET_LSLIB_NIOS_HDR(req.hdr, LIB_NIOS_SETSTDOUT, sizeof(req.r) +
req.r.len*sizeof(char));
if (b_write_fix(cli_nios_fd[0], (char *)&req, sizeof(req.hdr) +
sizeof(req.r)) != sizeof(req.hdr) + sizeof(req.r)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (req.r.len > 0) {
if (b_write_fix(cli_nios_fd[0], (char *)format, req.r.len*sizeof(char))
!= req.r.len * sizeof(char)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
}
if (select(cli_nios_fd[0] + 1, &rmask, 0, 0, &timeout) <= 0) {
lserrno = LSE_SELECT_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &replyHdr, sizeof(replyHdr))
== -1) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
switch(replyHdr.opCode) {
case STDOUT_FAIL:
lserrno = LSE_SETPARAM;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
case STDOUT_OK:
break;
default:
lserrno = LSE_PROTOC_NIOS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(0);
}
int
ls_niossync(int numTasks)
{
fd_set rmask;
struct timeval timeout;
struct lslibNiosHdr replyHdr, reqHdr;
sigset_t newMask, oldMask;
if (!nios_ok_) {
lserrno = LSE_NIOS_DOWN;
return(-1);
}
if (numTasks < 0) {
lserrno = LSE_BAD_ARGS;
return(-1);
}
if (blockALL_SIGS_(&newMask, &oldMask) < 0)
return (-1);
FD_ZERO(&rmask);
FD_SET(cli_nios_fd[0], &rmask);
timeout.tv_sec = NIOS_TIMEOUT;
timeout.tv_usec = 0;
SET_LSLIB_NIOS_HDR(reqHdr, LIB_NIOS_SYNC, numTasks);
if (b_write_fix(cli_nios_fd[0], (char *)&reqHdr, sizeof(reqHdr))
!= sizeof(reqHdr)) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (select(cli_nios_fd[0] + 1, &rmask, 0, 0, &timeout) <= 0) {
lserrno = LSE_SELECT_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
if (b_read_fix(cli_nios_fd[0], (char *) &replyHdr, sizeof(replyHdr))
== -1) {
lserrno = LSE_MSG_SYS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
switch(replyHdr.opCode) {
case SYNC_FAIL:
lserrno = LSE_SETPARAM;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
case SYNC_OK:
break;
default:
lserrno = LSE_PROTOC_NIOS;
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(-1);
}
sigprocmask(SIG_SETMASK, &oldMask, NULL);
return(0);
}
int
resParent (int s, struct passwd *pw, struct lsfAuth *auth,
struct resConnect *connReq, struct hostent *hostp)
{
static char fname[] = "resParent";
int cc;
char *argv[7];
char hndlbuf[64];
struct resChildInfo childInfo;
char buf[2 * MSGSIZE];
XDR xdrs;
int len;
struct LSFHeader hdr;
int hpipe[2];
int wrapPipe[2];
int pid;
if (resParams[LSF_SERVERDIR].paramValue != NULL)
{
argv[0] = getDaemonPath_ ("/res", resParams[LSF_SERVERDIR].paramValue);
}
else
{
argv[0] = "res";
}
childInfo.resConnect = connReq;
childInfo.lsfAuth = auth;
childInfo.pw = pw;
childInfo.host = hostp;
childInfo.parentPort = ctrlAddr.sin_port;
childInfo.currentRESSN = currentRESSN;
if (resLogOn == 1)
{
char strLogCpuTime[32];
sprintf (strLogCpuTime, "%d", resLogcpuTime);
putEnv ("LSF_RES_LOGON", "1");
putEnv ("LSF_RES_CPUTIME", strLogCpuTime);
putEnv ("LSF_RES_ACCTPATH", resAcctFN);
}
else if (resLogOn == 0)
{
putEnv ("LSF_RES_LOGON", "0");
}
else if (resLogOn == -1)
{
putEnv ("LSF_RES_LOGON", "-1");
}
xdrmem_create (&xdrs, buf, 2 * MSGSIZE, XDR_ENCODE);
memset ((void *) &hdr, 0, sizeof (struct LSFHeader));
hdr.version = OPENLAVA_VERSION;
if (!xdr_resChildInfo (&xdrs, &childInfo, &hdr))
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_resChildInfo");
return (-1);
}
len = XDR_GETPOS (&xdrs);
if (socketpair (AF_UNIX, SOCK_STREAM, 0, hpipe) < 0)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "socketpair");
return (-1);
}
if (socketpair (AF_UNIX, SOCK_STREAM, 0, wrapPipe) < 0)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "socketpair");
return (-1);
}
sprintf (hndlbuf, "%d:%d", hpipe[1], s);
cc = 1;
argv[cc++] = "-d";
argv[cc++] = env_dir;
if (debug)
{
if (debug == 1)
argv[cc++] = "-1";
else
argv[cc++] = "-2";
argv[cc++] = "-s";
argv[cc++] = hndlbuf;
argv[cc++] = NULL;
}
else
{
argv[cc++] = "-s";
argv[cc++] = hndlbuf;
argv[cc++] = NULL;
}
if (getenv ("LSF_SETDCEPAG") == NULL)
putEnv ("LSF_SETDCEPAG", "Y");
pid = fork ();
if (pid < 0)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "fork");
close (hpipe[0]);
close (hpipe[1]);
close (wrapPipe[0]);
close (wrapPipe[1]);
return (-1);
}
if (pid == 0)
{
if (logclass & LC_TRACE)
{
if (debug)
{
ls_syslog (LOG_DEBUG2, "%s: executing %s %s %s %s %s %s ",
fname, argv[0], argv[1], argv[2], argv[3], argv[4],
argv[5]);
}
else
{
ls_syslog (LOG_DEBUG2, "%s: executing %s %s %s %s %s ",
fname, argv[0], argv[1], argv[2], argv[3], argv[4]);
}
}
close (hpipe[0]);
close (wrapPipe[0]);
if (dup2 (wrapPipe[1], 0) == -1)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "dup2");
exit (-1);
}
close (wrapPipe[1]);
lsfExecv (argv[0], argv);
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "execv");
exit (-1);
}
close (hpipe[1]);
close (wrapPipe[1]);
if (connReq->eexec.len > 0)
{
int cc1;
if ((cc1 = b_write_fix (wrapPipe[0], connReq->eexec.data,
connReq->eexec.len)) != connReq->eexec.len)
{
ls_syslog (LOG_ERR, _i18n_msg_get (ls_catd, NL_SETN, 5333, "%s: Falied in sending data to wrap for user <%s>, length = %d, cc=1%d: %m"), fname, pw->pw_name, connReq->eexec.len, cc1) /* catgets 5333 */
;
close (wrapPipe[0]);
close (hpipe[0]);
return (-1);
}
}
close (wrapPipe[0]);
if (write (hpipe[0], (char *) &len, sizeof (len)) != sizeof (len))
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "write");
xdr_destroy (&xdrs);
close (hpipe[0]);
return (-1);
}
if (write (hpipe[0], buf, len) != len)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "write");
xdr_destroy (&xdrs);
close (hpipe[0]);
return (-1);
}
xdr_destroy (&xdrs);
close (hpipe[0]);
return (0);
}
int
lsMsgSnd_(int taskid, char *buffer, int len, int options)
{
struct LSFHeader header;
char headerBuf[sizeof(struct LSFHeader)];
XDR xdrs;
struct tid *tEnt;
int rc;
char hostname[MAXHOSTNAMELEN];
tEnt = tid_find(taskid);
if (! tEnt)
return -1;
if (tEnt->sock < 0) {
lserrno = LSE_LOSTCON;
return -1;
}
#ifdef OS_HAS_PTHREAD
pthread_mutex_lock(&fdLSLIBWriteMutex);
#endif
header.opCode = RES_NONRES;
header.refCode = currentSN = REQUESTSN;
header.length = len;
header.reserved = taskid;
gethostbysock_(tEnt->sock, hostname);
if (strcmp(hostname, "LSF_HOST_NULL"))
_setcurseqno_(hostname, currentSN);
xdrmem_create(&xdrs, headerBuf, LSF_HEADER_LEN, XDR_ENCODE);
if (!xdr_LSFHeader(&xdrs, &header)) {
lserrno = LSE_BAD_XDR;
xdr_destroy(&xdrs);
rc = -1;
goto AbortSnd;
}
xdr_destroy(&xdrs);
rc = b_write_fix(tEnt->sock, headerBuf, LSF_HEADER_LEN);
if (rc < 0) {
if (errno == EPIPE) {
close(tEnt->sock);
tEnt->sock = -1;
_lostconnection_(hostname);
lserrno = LSE_LOSTCON;
}
rc = -1;
goto AbortSnd;
}
rc = b_write_fix(tEnt->sock, buffer, len);
if (rc < 0) {
if (errno == EPIPE) {
close(tEnt->sock);
tEnt->sock = -1;
_lostconnection_(hostname);
lserrno = LSE_LOSTCON;
}
rc = -1;
goto AbortSnd;
}
if (ackReturnCode_(tEnt->sock) < 0) {
rc = -1;
goto AbortSnd;
}
AbortSnd:
#ifdef OS_HAS_PTHREAD
pthread_mutex_unlock(&fdLSLIBWriteMutex);
#endif
return rc;
}
int
runEexec_(char *option, int job, struct lenData *eexec, char *path)
{
static char fname[] = "runEexec";
char eexecPath[MAXFILENAMELEN], *myargv[3];
int pid = -1, i, p[2], cc, isRenew = FALSE;
struct stat sbuf;
if (strcmp (option, "-r") == 0)
isRenew = TRUE;
if (isRenew == TRUE) {
if (path[0] == '\0')
strcpy(eexecPath, EEXECNAME);
else
sprintf(eexecPath, "%s/%s", path, EEXECNAME);
} else {
sprintf(eexecPath, "%s/%s", genParams_[LSF_SERVERDIR].paramValue, EEXECNAME);
}
if (logclass & LC_TRACE)
ls_syslog(LOG_DEBUG,"%s: eexec path, option and data length of job/task <%d> are <%s>, <%s> and <%d>",fname, job, eexecPath, option, eexec->len);
if (stat(eexecPath, &sbuf) < 0) {
if (logclass & LC_TRACE)
ls_syslog(LOG_DEBUG,
"%s: Job/task <%d> eexec will not be run, stat(%s) failed: %m", fname, job, eexecPath);
lserrno = LSE_ESUB;
return -1;
}
i = 0;
myargv[i++] = eexecPath;
if (strcmp (option, "-r") == 0)
myargv[i++] = "-r";
myargv[i] = NULL;
if (pipe(p) < 0) {
lserrno = LSE_PIPE;
return -1;
}
if ((pid = fork()) == 0) {
char *user;
uid_t uid;
{
struct passwd *pw;
if ((user = getenv("LSFUSER")) != NULL) {
if (getUid(user, &uid) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_MM, fname, "getUid", user);
exit(-1);
}
} else {
user = getenv("USER");
if ((pw = getpwnam(user)) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "getpwnam", user);
exit(-1);
}
uid = pw->pw_uid;
}
}
if (setuid(uid) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_D_FAIL_M, fname, "setuid", (int) uid);
exit (-1);
}
if (setpgid(0, getpid()) <0) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_M, fname, "setpgid");
exit (-1);
}
for (i = 1; i < NSIG; i++)
Signal_(i, SIG_DFL);
alarm(0);
close(p[1]);
if (dup2(p[0], 0) == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_M, fname, "dup2(stdin,0)");
}
for (i = 3; i < sysconf(_SC_OPEN_MAX); i++)
close(i);
execvp(myargv[0], myargv);
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "execvp", myargv[0]);
exit(-1);
}
if (pid == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_M, fname, "fork");
close(p[0]);
close(p[1]);
lserrno = LSE_FORK;
return -1;
}
close(p[0]);
if (eexec->len > 0) {
if ((cc = b_write_fix(p[1], eexec->data, eexec->len)) != eexec->len &&
strcmp (option, "-p")) {
ls_syslog(LOG_ERR, I18N_FUNC_D_FAIL_M, fname, "b_write_fix", eexec->len);
}
}
close(p[1]);
while (waitpid(pid, NULL, 0) < 0 && errno == EINTR)
;
return 0;
}