LS_REQUEST_T *
lsGetIRProcRusage_(char *host, int tid, int pid, struct jRusage *ru,
appCompletionHandler appHandler,
void *appExtra)
{
struct {
struct LSFHeader hdr;
struct resRusage rusageReq;
} requestBuf;
struct lsRequest *request;
struct resRusage rusageReq;
int s;
int descriptor[2];
if (_isconnected_(host, descriptor))
s = descriptor[0];
else {
lserrno = LSE_LOSTCON;
return NULL;
}
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return NULL;
}
}
rusageReq.rid = pid;
rusageReq.whatid = RES_RID_ISPID;
if (callRes_(s, RES_RUSAGE, (char *)&rusageReq, (char *)&requestBuf,
sizeof(requestBuf), xdr_resGetRusage, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return NULL;
}
request = lsReqHandCreate_(tid,
currentSN,
s,
(void *)ru,
rgetRusageCompletionHandler_,
appHandler,
appExtra);
if (request == NULL)
return NULL;
if (lsQueueDataAppend_((char *)request, requestQ)) {
lsReqFree_(request);
return NULL;
}
return(request);
}
int
lsRGetpgrp_(int sock, int taskid, int pid)
{
struct _buf_ {
struct LSFHeader hdrBuf;
struct resPid pidBuf;
} buf;
LS_REQUEST_T *request;
char host[MAXHOSTNAMELEN];
struct resPid pidReq;
int s, pgid;
s = sock;
gethostbysock_(s, host);
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return (-1);
}
}
pidReq.rpid = taskid;
pidReq.pid = pid;
if (callRes_(s, RES_GETPID, (char *) &pidReq, (char *) &buf,
sizeof(buf), xdr_resGetpid, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return (-1);
}
request = lsReqHandCreate_(taskid,
currentSN,
s,
(void *)&pgid,
rgetpidCompletionHandler_,
(appCompletionHandler) NULL,
NULL);
if (request == NULL)
return(-1);
if (lsQueueDataAppend_((char *)request, requestQ))
return(-1);
if (lsReqWait_(request, 0) < 0)
return (-1);
lsReqFree_(request);
return(pgid);
}
void *
lsRGetpidAsync_(int taskid, int *pid)
{
struct _buf_ {
struct LSFHeader hdrBuf;
struct resPid pidBuf;
} buf;
LS_REQUEST_T *request;
struct resPid pidReq;
int s;
struct tid *tid;
char host[MAXHOSTNAMELEN];
if ((tid = tid_find(taskid)) == NULL) {
return(NULL);
}
s = tid->sock;
gethostbysock_(s, host);
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return (NULL);
}
}
pidReq.rpid = taskid;
pidReq.pid = -1;
if (callRes_(s, RES_GETPID, (char *) &pidReq, (char *) &buf,
sizeof(buf), xdr_resGetpid, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return (NULL);
}
request = lsReqHandCreate_(taskid,
currentSN,
s,
(void *)pid,
rgetpidCompletionHandler_,
(appCompletionHandler) NULL,
NULL);
if (request != NULL)
if (lsQueueDataAppend_((char *)request, requestQ))
return(NULL);
return (void *)request;
}
int
oneResDebug (struct debugReq *pdebug , char *hostname)
{
int s, descriptor[2];
char space[ ]=" ";
struct debugReq debugData;
struct {
struct LSFHeader hdr;
struct debugReq d;
} buf;
if (_isconnected_(hostname, descriptor))
s = descriptor[0];
else if ((s = ls_connect(hostname)) < 0)
return -1;
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(hostname);
return -1;
}
}
debugData.opCode = pdebug->opCode;
debugData.logClass = pdebug->logClass;
debugData.level = pdebug->level;
debugData.hostName = space;
debugData.options = pdebug->options;
strcpy(debugData.logFileName, pdebug->logFileName);
if (callRes_(s, RES_DEBUGREQ, (char *) &debugData, (char *) &buf,
sizeof(buf), xdr_debugReq, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(hostname);
return( -1 );
}
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(hostname);
return( -1 );
}
return 0;
}
int
do_rstty1_(char *host, int async)
{
int s, descriptor[2];
int redirect, io_fd;
redirect = 0;
if (isatty(0)) {
if (!isatty(1))
redirect = 1;
io_fd = 0;
} else if (isatty(1)) {
redirect = 1;
io_fd = 1;
} else
return 0;
if (_isconnected_(host, descriptor))
s = descriptor[0];
else if ((s = ls_connect(host)) < 0)
return -1;
if (! FD_ISSET(s,&connection_ok_) ) {
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return -1;
}
}
if (do_rstty2_(s, io_fd, redirect, async) == -1) {
closesocket(s);
_lostconnection_(host);
return -1;
}
if (!async){
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return -1;
}
}
return 0;
}
int
ls_chdir(char *host, char *dir)
{
int s, descriptor[2];
struct {
struct LSFHeader hdr;
struct resChdir ch;
} buf;
struct resChdir chReq;
if (_isconnected_(host, descriptor))
s = descriptor[0];
else if ((s = ls_connect(host)) < 0)
return -1;
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return -1;
}
}
if (dir[0] != '/' && dir[1] != ':' && (dir[0] != '\\' || dir[1] != '\\')) {
lserrno = LSE_BAD_ARGS;
return -1;
}
strcpy(chReq.dir, dir);
if (callRes_(s, RES_CHDIR, (char *) &chReq, (char *) &buf,
sizeof(buf), xdr_resChdir, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return -1;
}
if (ackReturnCode_(s) < 0) {
if (lserrno == LSE_RES_DIRW)
return -2;
else
return -1;
}
return 0;
}
int
lsConnWait_(char *host)
{
int s;
int descriptor[2];
if (_isconnected_(host, descriptor))
s = descriptor[0];
else
return -1;
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0){
closesocket(s);
_lostconnection_(host);
return -1;
}
}
return 0;
}
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);
}
LS_REQUEST_T *
lsIRGetRusage_(int rpid,
struct jRusage *ru,
appCompletionHandler appHandler,
void *appExtra,
int options)
{
struct {
struct LSFHeader hdr;
struct resRusage rusageReq;
} requestBuf;
struct lsRequest *request;
struct resRusage rusageReq;
int s;
struct tid *tid;
char host[MAXHOSTNAMELEN];
if ((tid = tid_find(rpid)) == NULL) {
return NULL;
}
s = tid->sock;
gethostbysock_(s, host);
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return NULL;
}
}
rusageReq.rid = rpid;
if (options == 0 || (options & RID_ISTID))
rusageReq.whatid = RES_RID_ISTID;
else
rusageReq.whatid = RES_RID_ISPID;
if (callRes_(s, RES_RUSAGE, (char *)&rusageReq, (char *)&requestBuf,
sizeof(requestBuf), xdr_resGetRusage, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return NULL;
}
request = lsReqHandCreate_(rpid,
currentSN,
s,
(void *)ru,
rgetRusageCompletionHandler_,
appHandler,
appExtra);
if (request == NULL)
return NULL;
if (lsQueueDataAppend_((char *)request, requestQ)) {
lsReqFree_(request);
return NULL;
}
return(request);
}
int
ls_rescontrol(char *host, int opCode, int data)
{
int s;
int descriptor[2];
int cc;
struct resControl ctrl;
struct {
struct LSFHeader hdr;
struct resControl c;
} buf;
struct timeval timeout;
if (genParams_[LSF_RES_TIMEOUT].paramValue) {
timeout.tv_sec = atoi(genParams_[LSF_RES_TIMEOUT].paramValue);
} else {
timeout.tv_sec = LSF_RES_TIMEOUT;
}
timeout.tv_usec = 0;
if (_isconnected_(host, descriptor))
s = descriptor[0];
else if ((s = ls_connect(host)) < 0)
return -1;
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
cc = rd_select_(s, &timeout);
if (cc <= 0) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_TIME_OUT;
return -1;
}
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return -1;
}
}
if (opCode != RES_CMD_REBOOT
&& opCode != RES_CMD_SHUTDOWN
&& opCode != RES_CMD_LOGON
&& opCode != RES_CMD_LOGOFF) {
lserrno = LSE_BAD_OPCODE;
return -1;
}
ctrl.opCode = opCode;
ctrl.data = data;
if (callRes_(s, RES_CONTROL, (char *) &ctrl, (char *) &buf,
sizeof(buf), xdr_resControl, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return( -1 );
}
cc = rd_select_(s, &timeout);
if (cc <= 0) {
closesocket(s);
_lostconnection_(host);
lserrno = LSE_TIME_OUT;
return -1;
}
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return( -1 );
}
return 0;
}
int
lsMsgWait_(int inTidCnt, int *tidArray, int *rdyTidCnt,
int inFdCnt, int *fdArray, int *rdyFdCnt, int *outFdArray,
struct timeval *timeout, int options)
{
int i;
fd_set rm;
struct tid *taskEnt;
int maxfd;
int nready;
char hdrBuf[sizeof(struct LSFHeader)];
struct LSFHeader msgHdr;
int rc;
int rdycnt;
XDR xdrs;
bool_t tMsgQNonEmpty;
int nBitsSet;
bool_t anythingRdy;
if ((! rdyTidCnt && ! rdyFdCnt) ||
(! tidArray && !fdArray) ||
(! inTidCnt && ! inFdCnt))
return 0;
for (i = 0; i < inFdCnt; i++)
outFdArray[i] = -1;
Again:
tMsgQNonEmpty = FALSE;
FD_ZERO(&rm);
nBitsSet = 0;
if (rdyTidCnt) *rdyTidCnt = 0;
if (rdyFdCnt) *rdyFdCnt = 0;
if (inFdCnt > 0 && fdArray)
for (i = 0; i < inFdCnt; i++) {
if (FD_NOT_VALID(fdArray[i])) {
lserrno = LSE_BAD_ARGS;
rc = -1;
goto Fail;
}
FD_SET(fdArray[i], &rm);
nBitsSet++;
}
rdycnt = 0;
if (inTidCnt && tidArray) {
for (i = 0; i < inTidCnt; i++) {
rc = lsMsgRdy_(tidArray[i], NULL);
if (rc > 0) {
tMsgQNonEmpty = TRUE;
rdycnt++;
continue;
}
taskEnt = tid_find(tidArray[i]);
if (taskEnt == NULL) {
rc = -1;
goto Fail;
}
if (FD_NOT_VALID(taskEnt->sock)) {
lserrno = LSE_BAD_ARGS;
rc = -1;
goto Fail;
}
nBitsSet++;
FD_SET(taskEnt->sock, &rm);
}
if (tMsgQNonEmpty) {
*rdyTidCnt = rdycnt;
return 0;
}
}
if (nBitsSet == 0)
return 0;
maxfd = sysconf(_SC_OPEN_MAX);
if (maxfd > 1024) maxfd = 1024-1;
nready = select(maxfd, &rm, NULL, NULL, timeout);
if (nready < 0)
{
if (errno == EINTR) {
goto Again;
} else {
lserrno = LSE_SELECT_SYS;
rc = -1;
goto Fail;
}
}
if (rdyFdCnt) {
rdycnt = 0;
for (i = 0; i < inFdCnt; i++) {
if (FD_ISSET(fdArray[i], &rm)) {
rdycnt++;
outFdArray[i] = fdArray[i];
}
else
outFdArray[i] = -1;
}
*rdyFdCnt = rdycnt;
}
if (nready == 0) {
if (rdyTidCnt)
*rdyTidCnt = 0;
return 0;
}
if (rdyTidCnt) {
rdycnt = 0;
xdrmem_create(&xdrs, hdrBuf, sizeof(struct LSFHeader), XDR_DECODE);
for (i = 0; i < inTidCnt; i++) {
taskEnt = tidFindIgnoreConn_(tidArray[i]);
if (taskEnt == NULL) {
rc = -1;
xdr_destroy(&xdrs);
goto Fail;
}
if (FD_NOT_VALID(taskEnt->sock))
continue;
if (! FD_ISSET(taskEnt->sock, &rm))
continue;
xdr_setpos(&xdrs, 0);
rc = readDecodeHdr_(taskEnt->sock, hdrBuf, b_read_fix, &xdrs, &msgHdr);
if (rc < 0) {
int nTids;
int *tidSameConns;
int tidIDx;
rc = tidSameConnection_(taskEnt->sock, &nTids, &tidSameConns);
for (tidIDx = 0; tidIDx < nTids; tidIDx++) {
rc = enqueueTaskMsg_(-1, tidSameConns[tidIDx], NULL);
if (rc < 0) {
free(tidSameConns);
xdr_destroy(&xdrs);
goto Fail;
}
}
rdycnt += nTids;
free(tidSameConns);
_lostconnection_(taskEnt->host);
} else if (msgHdr.opCode != RES_NONRES) {
rc = ackAsyncReturnCode_(taskEnt->sock, &msgHdr);
if (rc < 0) {
xdr_destroy(&xdrs);
goto Fail;
}
} else {
rc = enqueueTaskMsg_(taskEnt->sock, msgHdr.refCode, &msgHdr);
if (rc < 0) {
xdr_destroy(&xdrs);
goto Fail;
}
FD_CLR(taskEnt->sock, &rm);
rdycnt++;
}
}
xdr_destroy(&xdrs);
*rdyTidCnt = rdycnt;
}
anythingRdy = FALSE;
if (rdyTidCnt)
if (*rdyTidCnt > 0)
anythingRdy = TRUE;
if (rdyFdCnt)
if (*rdyFdCnt > 0)
anythingRdy = TRUE;
if (! anythingRdy)
goto Again;
rc = 0;
Fail:
return rc;
}
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
sendSig_(char *host, int rid, int sig, int options)
{
struct {
struct LSFHeader hdr;
struct resRKill rk;
} buf;
struct resRKill killReq;
int descriptor[2];
int s;
if (_isconnected_(host, descriptor))
s = descriptor[0];
else {
lserrno = LSE_LOSTCON;
return -1;
}
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return -1;
}
}
if ( sig >= NSIG || sig < 0 ){
lserrno = LSE_BAD_ARGS;
return( -1 );
}
killReq.rid = rid;
if (options & RSIG_ID_ISTID) {
killReq.whatid = RES_RID_ISTID;
} else if (options & RSIG_ID_ISPID) {
killReq.whatid = RES_RID_ISPID;
} else {
lserrno = LSE_BAD_ARGS;
return -1;
}
killReq.signal = sig_encode(sig);
if (callRes_(s, RES_RKILL, (char *) &killReq, (char *) &buf,
sizeof(buf), xdr_resRKill, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return -1;
}
if (ackReturnCode_(s) < 0) {
if (options & RSIG_KEEP_CONN)
return -1;
closesocket(s);
_lostconnection_(host);
return( -1 );
}
return 0;
}
int
lsGetRProcRusage(char *host, int pid, struct jRusage *ru, int options)
{
struct {
struct LSFHeader hdr;
struct resRusage rusageReq;
} requestBuf;
struct lsRequest *request;
struct resRusage rusageReq;
int s;
int descriptor[2];
if (_isconnected_(host, descriptor))
s = descriptor[0];
else {
lserrno = LSE_LOSTCON;
return -1;
}
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
return -1;
}
}
rusageReq.rid = pid;
rusageReq.whatid = RES_RID_ISPID;
if (options & RES_RPID_KEEPPID) {
rusageReq.options |= RES_RPID_KEEPPID;
} else {
rusageReq.options = 0;
}
if (callRes_(s, RES_RUSAGE, (char *)&rusageReq, (char *)&requestBuf,
sizeof(requestBuf), xdr_resGetRusage, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
return -1;
}
request = lsReqHandCreate_(pid,
currentSN,
s,
(void *)ru,
rgetRusageCompletionHandler_,
NULL,
NULL);
if (request == NULL)
return -1;
if (lsQueueDataAppend_((char *)request, requestQ))
return -1;
if (! request)
return -1;
if (lsReqWait_(request, 0) < 0)
return -1;
lsReqFree_(request);
return 0;
}
/* ls_startserver()
*/
int
ls_startserver (char *host, char **server, int options)
{
int retsock;
char official[MAXHOSTNAMELEN];
struct timeval timeout;
struct sockaddr_in sin;
int s;
int descriptor[2];
struct resCmdBill cmdmsg;
int resTimeout;
socklen_t len;
if (genParams_[LSF_RES_TIMEOUT].paramValue)
resTimeout = atoi (genParams_[LSF_RES_TIMEOUT].paramValue);
else
resTimeout = RES_TIMEOUT;
if (_isconnected_ (host, descriptor))
s = descriptor[0];
else if ((s = ls_connect (host)) < 0)
return (-1);
if (!FD_ISSET (s, &connection_ok_))
{
FD_SET (s, &connection_ok_);
if (ackReturnCode_ (s) < 0)
{
closesocket (s);
_lostconnection_ (host);
return (-1);
}
}
if (!isatty (0) && !isatty (1))
options &= ~REXF_USEPTY;
else if (options & REXF_USEPTY)
{
if (rstty_ (host) < 0)
{
_lostconnection_ (host);
return (-1);
}
}
if (mygetwd_ (cmdmsg.cwd) == 0)
{
closesocket (s);
_lostconnection_ (host);
lserrno = LSE_WDIR;
return (-1);
}
if ((retsock = TcpCreate_ (TRUE, 0)) < 0)
{
closesocket (s);
_lostconnection_ (host);
return (-1);
}
len = sizeof (sin);
if (getsockname (retsock, (struct sockaddr *) &sin, &len) < 0)
{
closesocket (retsock);
closesocket (s);
_lostconnection_ (host);
lserrno = LSE_SOCK_SYS;
return (-1);
}
cmdmsg.retport = sin.sin_port;
cmdmsg.options = options & ~REXF_TASKPORT;
cmdmsg.rpid = 0;
cmdmsg.argv = server;
timeout.tv_usec = 0;
timeout.tv_sec = resTimeout;
if (sendCmdBill_ (s, (resCmd) RES_SERVER, &cmdmsg, &retsock, &timeout)
== -1)
{
closesocket (retsock);
closesocket (s);
_lostconnection_ (host);
return (-1);
}
if (ackReturnCode_ (s) < 0)
{
closesocket (retsock);
closesocket (s);
_lostconnection_ (host);
return (-1);
}
if (retsock <= 2 && (retsock = get_nonstd_desc_ (retsock)) < 0)
{
closesocket (s);
_lostconnection_ (host);
lserrno = LSE_SOCK_SYS;
return (-1);
}
gethostbysock_ (s, official);
(void) connected_ (official, -1, retsock, currentSN);
return (retsock);
} /* ls_startserver() */
int
ls_rexecve (char *host, char **argv, int options, char **envp)
{
int d;
int retsock;
struct timeval timeout;
socklen_t len;
struct sockaddr_in sin;
int max;
char sock_buf[20];
char *new_argv[5];
char pathbuf[MAXPATHLEN];
int s;
int descriptor[2];
struct resCmdBill cmdmsg;
int resTimeout;
if (genParams_[LSF_RES_TIMEOUT].paramValue)
resTimeout = atoi (genParams_[LSF_RES_TIMEOUT].paramValue);
else
resTimeout = RES_TIMEOUT;
if (_isconnected_ (host, descriptor))
s = descriptor[0];
else if ((s = ls_connect (host)) < 0)
return (-1);
if (!FD_ISSET (s, &connection_ok_))
{
FD_SET (s, &connection_ok_);
if (ackReturnCode_ (s) < 0)
{
closesocket (s);
_lostconnection_ (host);
return (-1);
}
}
cmdmsg.options = options & ~REXF_TASKPORT;
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 (rstty_ (host) < 0)
{
_lostconnection_ (host);
return (-1);
}
}
if ((genParams_[LSF_INTERACTIVE_STDERR].paramValue != NULL)
&& (strcasecmp (genParams_[LSF_INTERACTIVE_STDERR].paramValue,
"y") == 0))
{
cmdmsg.options |= REXF_STDERR;
}
if (mygetwd_ (cmdmsg.cwd) == 0)
{
closesocket (s);
_lostconnection_ (host);
lserrno = LSE_WDIR;
return (-1);
}
if (envp)
{
if (ls_rsetenv (host, envp) < 0)
{
_lostconnection_ (host);
return (-1);
}
}
if ((retsock = TcpCreate_ (TRUE, 0)) < 0)
{
closesocket (s);
_lostconnection_ (host);
return (-1);
}
len = sizeof (sin);
if (getsockname (retsock, (struct sockaddr *) &sin, &len) < 0)
{
(void) closesocket (retsock);
closesocket (s);
_lostconnection_ (host);
lserrno = LSE_SOCK_SYS;
return (-1);
}
cmdmsg.retport = sin.sin_port;
cmdmsg.rpid = 0;
cmdmsg.argv = argv;
cmdmsg.priority = 0;
timeout.tv_usec = 0;
timeout.tv_sec = resTimeout;
if (sendCmdBill_ (s, (resCmd) RES_EXEC, &cmdmsg, &retsock, &timeout) == -1)
{
closesocket (retsock);
closesocket (s);
_lostconnection_ (host);
return (-1);
}
(void) sprintf (sock_buf, "%d", retsock);
if (initenv_ (NULL, NULL) < 0)
return (-1);
strcpy (pathbuf, genParams_[LSF_SERVERDIR].paramValue);
strcat (pathbuf, "/nios");
new_argv[0] = pathbuf;
new_argv[1] = "-n";
new_argv[2] = sock_buf;
if (cmdmsg.options & REXF_USEPTY)
{
if (cmdmsg.options & REXF_SHMODE)
new_argv[3] = "2";
else
new_argv[3] = "1";
}
else
new_argv[3] = "0";
new_argv[4] = 0;
max = sysconf (_SC_OPEN_MAX);
for (d = 3; d < max; ++d)
{
if (d != retsock)
(void) close (d);
}
(void) lsfExecvp (new_argv[0], new_argv);
lserrno = LSE_EXECV_SYS;
close (retsock);
close (s);
return (-1);
}
int
rsetenv_ (char *host, char **envp, int option)
{
int descriptor[2];
struct resSetenv envMsg;
char *sendBuf;
int bufferSize;
int i, s;
resCmd resCmdOption;
bufferSize = 512;
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG, "rsetenv_: Entering this routine...");
if (!envp)
return 0;
for(i=0; envp[i] != NULL; i++)
bufferSize = bufferSize + ALIGNWORD_(strlen(envp[i])) + sizeof(int);
sendBuf = (char *)malloc(bufferSize);
if (sendBuf == NULL) {
lserrno = LSE_MALLOC;
goto err;
}
if (_isconnected_(host, descriptor))
s = descriptor[0];
else if ((s = ls_connect(host)) < 0) {
free(sendBuf);
goto err;
}
if (!FD_ISSET(s,&connection_ok_)){
FD_SET(s,&connection_ok_);
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
free(sendBuf);
goto err;
}
}
envMsg.env = envp;
if (option == RSETENV_SYNCH)
resCmdOption = RES_SETENV;
else if (option == RSETENV_ASYNC)
resCmdOption = RES_SETENV_ASYNC;
if (callRes_(s, resCmdOption, (char *) &envMsg, sendBuf, bufferSize,
xdr_resSetenv, 0, 0, NULL) == -1) {
closesocket(s);
_lostconnection_(host);
free(sendBuf);
goto err;
}
free(sendBuf);
if (option == RSETENV_SYNCH){
if (ackReturnCode_(s) < 0) {
closesocket(s);
_lostconnection_(host);
goto err;
}
}
return 0;
err:
return -1;
}