bool_t
xdr_jobSetup (XDR *xdrs, struct jobSetup *jsetup, struct LSFHeader *hdr)
{
static char fname[]="xdr_jobSetup";
char *sp1, *sp2, *sp3;
int jobArrId, jobArrElemId;
if (xdrs->x_op == XDR_ENCODE) {
jobId64To32(jsetup->jobId, &jobArrId, &jobArrElemId);
}
if (!(xdr_int(xdrs, &jobArrId) &&
xdr_int(xdrs, &jsetup->jStatus) &&
xdr_float(xdrs, &jsetup->cpuTime) &&
xdr_int(xdrs, &jsetup->w_status) &&
xdr_int(xdrs, &jsetup->reason) &&
xdr_int(xdrs, &jsetup->jobPid) &&
xdr_int(xdrs, &jsetup->jobPGid) &&
xdr_int(xdrs, &jsetup->execGid) &&
xdr_int(xdrs, &jsetup->execUid) &&
xdr_int(xdrs, &jsetup->execJobFlag))) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_int");
return (FALSE);
}
if (!xdr_arrayElement(xdrs, (char *) &jsetup->lsfRusage, hdr,
xdr_lsfRusage))
return (FALSE);
sp1 = jsetup->execUsername;
sp2 = jsetup->execHome;
sp3 = jsetup->execCwd;
if (xdrs->x_op == XDR_DECODE) {
sp1[0] = '\0';
sp2[0] = '\0';
sp3[0] = '\0';
}
if (!(xdr_string(xdrs, &sp1, MAX_LSB_NAME_LEN) &&
xdr_string(xdrs, &sp2, MAXFILENAMELEN) &&
xdr_string(xdrs, &sp3, MAXFILENAMELEN))) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_string");
return (FALSE);
}
if (!xdr_int(xdrs, &jobArrElemId)) {
return (FALSE);
}
if (xdrs->x_op == XDR_DECODE) {
jobId32To64(&jsetup->jobId,jobArrId,jobArrElemId);
}
return (TRUE);
}
bool_t
xdr_sbdPackage (XDR *xdrs, struct sbdPackage *sbdPackage, struct LSFHeader *hdr)
{
static char fname[] = "xdr_sbdPackage";
int i;
char *sp;
sp = sbdPackage->lsbManager;
if (xdrs->x_op == XDR_DECODE)
sp[0] = '\0';
if (!(xdr_int(xdrs, &sbdPackage->mbdPid) &&
xdr_int(xdrs, &sbdPackage->retryIntvl) &&
xdr_int(xdrs, &sbdPackage->preemPeriod) &&
xdr_int(xdrs, &sbdPackage->pgSuspIdleT) &&
xdr_int(xdrs, &sbdPackage->maxJobs) &&
xdr_int(xdrs, &sbdPackage->sbdSleepTime) &&
xdr_int(xdrs, &sbdPackage->managerId) &&
xdr_int(xdrs, &sbdPackage->numJobs) &&
xdr_string (xdrs, &sp, MAX_LSB_NAME_LEN))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int", "lsbManager");
return(FALSE);
}
if (xdrs->x_op == XDR_ENCODE) {
for (i = 0; i < sbdPackage->numJobs; i++)
if (!xdr_arrayElement(xdrs, (char *) &(sbdPackage->jobs[i]),
hdr, xdr_jobSpecs))
return(FALSE);
if (!xdr_sbdPackage1 (xdrs, sbdPackage, hdr))
return(FALSE);
}
return(TRUE);
}
bool_t
xdr_statusReq (XDR *xdrs, struct statusReq *statusReq, struct LSFHeader *hdr)
{
int i;
int jobArrId, jobArrElemId;
if (xdrs->x_op == XDR_FREE) {
for(i=0; i < statusReq->numExecHosts; i++)
FREEUP(statusReq->execHosts[i]);
if (statusReq->numExecHosts > 0)
FREEUP(statusReq->execHosts);
statusReq->numExecHosts = 0;
FREEUP (statusReq->execHome);
FREEUP (statusReq->execCwd);
FREEUP (statusReq->queuePreCmd);
FREEUP (statusReq->queuePostCmd);
FREEUP (statusReq->execUsername);
if (statusReq->runRusage.npids > 0)
FREEUP (statusReq->runRusage.pidInfo);
if (statusReq->runRusage.npgids > 0)
FREEUP (statusReq->runRusage.pgid);
return(TRUE);
}
if (xdrs->x_op == XDR_ENCODE) {
jobId64To32(statusReq->jobId, &jobArrId, &jobArrElemId);
}
if (!(xdr_int(xdrs,&jobArrId) &&
xdr_int(xdrs,&statusReq->jobPid) &&
xdr_int(xdrs,&statusReq->jobPGid) &&
xdr_int(xdrs,&statusReq->actPid) &&
xdr_int(xdrs,&statusReq->seq) &&
xdr_int(xdrs, &statusReq->newStatus) &&
xdr_int(xdrs,&statusReq->reason) &&
xdr_int(xdrs,&statusReq->subreasons) &&
xdr_int(xdrs, (int *) &statusReq->sbdReply)))
return (FALSE);
if (!xdr_arrayElement(xdrs, (char *) &statusReq->lsfRusage, hdr,
xdr_lsfRusage))
return (FALSE);
if (!(xdr_int(xdrs, &statusReq->execUid) &&
xdr_int(xdrs, &statusReq->numExecHosts)))
return(FALSE);
if (xdrs->x_op == XDR_DECODE) {
if (statusReq->numExecHosts > 0) {
statusReq->execHosts = (char **) calloc(statusReq->numExecHosts,
sizeof(char *));
if (!statusReq->execHosts)
return(FALSE);
}
}
if (!xdr_array_string(xdrs, statusReq->execHosts, MAXHOSTNAMELEN,
statusReq->numExecHosts))
return(FALSE);
if (!(xdr_int(xdrs, &statusReq->exitStatus) &&
xdr_var_string(xdrs, &statusReq->execHome) &&
xdr_var_string(xdrs, &statusReq->execUsername) &&
xdr_var_string(xdrs, &statusReq->execCwd) &&
xdr_var_string(xdrs, &statusReq->queuePreCmd) &&
xdr_var_string(xdrs, &statusReq->queuePostCmd)))
return(FALSE);
if (!xdr_int(xdrs, &statusReq->msgId))
return (FALSE);
if (!(xdr_jRusage(xdrs, &(statusReq->runRusage), hdr)))
return (FALSE);
if (!(xdr_int(xdrs, &(statusReq->sigValue)) &&
xdr_int(xdrs, &(statusReq->actStatus))))
return(FALSE);
if (!xdr_int(xdrs, &jobArrElemId)) {
return (FALSE);
}
if (xdrs->x_op == XDR_DECODE) {
jobId32To64(&statusReq->jobId,jobArrId,jobArrElemId);
}
return(TRUE);
}
bool_t
xdr_jobSpecs (XDR *xdrs, struct jobSpecs *jobSpecs, struct LSFHeader *hdr)
{
static char fname[] = "xdr_jobSpecs";
char *sp[15];
char *pTemp;
int i, nLimits;
int jobArrId, jobArrElemId;
LS_LONG_INT tmpJobId;
if (xdrs->x_op == XDR_DECODE) {
jobSpecs->numToHosts = 0;
jobSpecs->toHosts = NULL;
jobSpecs->nxf = 0;
jobSpecs->xf = NULL;
jobSpecs->numEnv = 0;
jobSpecs->env = NULL;
jobSpecs->eexec.len = 0;
jobSpecs->eexec.data = NULL;
jobSpecs->loginShell = NULL;
jobSpecs->schedHostType= NULL;
jobSpecs->execHosts = NULL;
}
if (xdrs->x_op == XDR_FREE) {
for(i=0; i < jobSpecs->numToHosts; i++) {
FREEUP(jobSpecs->toHosts[i]);
}
FREEUP(jobSpecs->toHosts);
for(i=0; i < jobSpecs->numEnv; i++)
FREEUP(jobSpecs->env[i]);
FREEUP(jobSpecs->env);
FREEUP(jobSpecs->xf);
FREEUP(jobSpecs->loginShell);
FREEUP(jobSpecs->schedHostType);
FREEUP(jobSpecs->execHosts);
if (!xdr_thresholds(xdrs, jobSpecs) ||
!xdr_lenData(xdrs, &jobSpecs->eexec))
return(FALSE);
return(TRUE);
}
if (xdrs->x_op == XDR_ENCODE) {
jobId64To32(jobSpecs->jobId, &jobArrId, &jobArrElemId);
}
if (!xdr_int(xdrs, &jobArrId)) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int", "jobId");
return(FALSE);
}
if (!(xdr_int(xdrs, &jobSpecs->userId) &&
xdr_int(xdrs, &jobSpecs->options) &&
xdr_short(xdrs, &jobSpecs->nice) &&
xdr_int(xdrs, &jobSpecs->priority) &&
xdr_int(xdrs, &jobSpecs->chkSig) &&
xdr_int(xdrs, &jobSpecs->actPid) &&
xdr_time_t(xdrs, &jobSpecs->chkPeriod) &&
xdr_time_t(xdrs, &jobSpecs->migThresh) &&
xdr_time_t(xdrs, &jobSpecs->lastSSuspTime) &&
xdr_float(xdrs, &jobSpecs->lastCpuTime))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_int", "userId");
return(FALSE);
}
nLimits = LSF_RLIM_NLIMITS;
tmpJobId = jobArrId;
if (!xdr_int(xdrs, &nLimits)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_int", "nLimits");
return(FALSE);
}
for (i = 0; i < nLimits && i < LSF_RLIM_NLIMITS; i++) {
if(!xdr_lsfLimit(xdrs, &jobSpecs->lsfLimits[i], hdr)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_lsfLimit");
return(FALSE);
}
}
if (nLimits > LSF_RLIM_NLIMITS) {
for (i=LSF_RLIM_NLIMITS; i<nLimits; i++) {
struct lsfLimit lsfLimit;
if (!xdr_lsfLimit(xdrs, &lsfLimit, hdr)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_lsfLimit");
return(FALSE);
}
}
}
if (!(xdr_int(xdrs, &jobSpecs->jStatus) &&
xdr_int(xdrs, &jobSpecs->reasons) &&
xdr_int(xdrs, &jobSpecs->subreasons) &&
xdr_time_t(xdrs, &jobSpecs->termTime) &&
xdr_time_t(xdrs, &jobSpecs->startTime) &&
xdr_int(xdrs, &jobSpecs->runTime) &&
xdr_time_t(xdrs, &jobSpecs->submitTime) &&
xdr_int(xdrs, &jobSpecs->jobPid) &&
xdr_int(xdrs, &jobSpecs->jobPGid) &&
xdr_int(xdrs, &jobSpecs->restartPid) &&
xdr_int(xdrs, &jobSpecs->sigValue) &&
xdr_int(xdrs, &jobSpecs->umask) &&
xdr_int(xdrs, &jobSpecs->jAttrib))) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId),
"xdr_int", "jStatus");
return(FALSE);
}
sp[0] = jobSpecs->jobFile;
sp[1] = jobSpecs->inFile;
sp[2] = jobSpecs->outFile;
sp[3] = jobSpecs->errFile;
sp[4] = jobSpecs->chkpntDir;
sp[5] = jobSpecs->cwd;
sp[6] = jobSpecs->subHomeDir;
sp[7] = jobSpecs->command;
sp[8] = jobSpecs->jobName;
sp[9] = jobSpecs->preExecCmd;
sp[10] = jobSpecs->fromHost;
sp[11] = jobSpecs->resReq;
if (xdrs->x_op == XDR_DECODE)
for (i = 0; i < 11; i++)
sp[i][0] = '\0';
if (!(xdr_string(xdrs, &sp[0], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[1], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[2], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[3], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[4], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[5], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[6], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[7], MAXLINELEN) &&
xdr_string(xdrs, &sp[8], MAXLINELEN) &&
xdr_string(xdrs, &sp[9], MAXLINELEN) &&
xdr_string(xdrs, &sp[10], MAXHOSTNAMELEN))) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_int", "jobFile");
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE)
sp[11][0] = '\0';
if (!xdr_string(xdrs, &sp[11], MAXLINELEN)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_int", "jobFile");
return(FALSE);
}
sp[12] = jobSpecs->queue;
sp[13] = jobSpecs->windows;
sp[14] = jobSpecs->userName;
if (xdrs->x_op == XDR_DECODE)
for (i = 12; i < 15; i++)
sp[i][0] = '\0';
if (!(xdr_string(xdrs, &sp[12], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[13], MAXLINELEN) &&
xdr_string(xdrs, &sp[14], MAX_LSB_NAME_LEN))) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId),
"xdr_int", "jobFile");
return(FALSE);
}
if (!xdr_int(xdrs, &jobSpecs->numToHosts)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname, lsb_jobid2str(tmpJobId),
"xdr_int", "numToHosts");
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE && jobSpecs->numToHosts) {
jobSpecs->toHosts = (char **) my_calloc(jobSpecs->numToHosts,
sizeof (char *), fname);
}
for (i = 0; i < jobSpecs->numToHosts; i++) {
if (!xdr_var_string(xdrs, &jobSpecs->toHosts[i])) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_var_string", "toHosts");
return(FALSE);
}
}
if (!xdr_thresholds(xdrs, jobSpecs))
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_thresholds");
if (!xdr_int(xdrs, &jobSpecs->nxf)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_int", "nxf");
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE && jobSpecs->nxf > 0) {
jobSpecs->xf = (struct xFile *) my_calloc(jobSpecs->nxf,
sizeof(struct xFile), fname);
}
for (i = 0; i < jobSpecs->nxf; i++) {
if (!xdr_arrayElement(xdrs, (char *) &(jobSpecs->xf[i]),
hdr, xdr_xFile)) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(tmpJobId),
"xdr_arrayElement", "xf");
return(FALSE);
}
}
sp[0] = jobSpecs->mailUser;
sp[1] = jobSpecs->clusterName;
sp[2] = jobSpecs->projectName;
sp[3] = jobSpecs->preCmd;
sp[4] = jobSpecs->postCmd;
sp[5] = jobSpecs->execCwd;
sp[6] = jobSpecs->execHome;
sp[7] = jobSpecs->requeueEValues;
if (xdrs->x_op == XDR_DECODE) {
for(i=0; i < 8; i++)
sp[i][0]= '\0';
}
if (!(xdr_string(xdrs, &sp[0], MAXLINELEN) &&
xdr_string(xdrs, &sp[1], MAX_LSB_NAME_LEN) &&
xdr_string(xdrs, &sp[2], MAX_LSB_NAME_LEN) &&
xdr_string(xdrs, &sp[3], MAXLINELEN) &&
xdr_string(xdrs, &sp[4], MAXLINELEN) &&
xdr_string(xdrs, &sp[5], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[6], MAXFILENAMELEN) &&
xdr_string(xdrs, &sp[7], MAXLINELEN) &&
xdr_int(xdrs, &jobSpecs->execUid) &&
xdr_int(xdrs, &jobSpecs->maxNumProcessors) &&
xdr_int(xdrs, &jobSpecs->numEnv)))
return(FALSE);
if (xdrs->x_op == XDR_DECODE && jobSpecs->numEnv) {
jobSpecs->env = (char **) my_calloc(jobSpecs->numEnv,
sizeof (char *), fname);
}
for (i = 0; i < jobSpecs->numEnv; i++) {
if (!xdr_var_string(xdrs, &jobSpecs->env[i]))
return(FALSE);
}
if (!xdr_lenData(xdrs, &jobSpecs->eexec))
return (FALSE);
if (!xdr_int(xdrs, &jobSpecs->niosPort))
return (FALSE);
sp[0] = jobSpecs->resumeCond;
sp[1] = jobSpecs->stopCond;
sp[2] = jobSpecs->suspendActCmd;
sp[3] = jobSpecs->resumeActCmd;
sp[4] = jobSpecs->terminateActCmd;
if (xdrs->x_op == XDR_DECODE) {
sp[0][0] = '\0';
sp[1][0] = '\0';
}
if (!(xdr_string(xdrs, &sp[0], MAXLINELEN)) ||
!(xdr_string(xdrs, &sp[1], MAXLINELEN)))
return (FALSE);
if (xdrs->x_op == XDR_DECODE) {
for ( i = 2; i < 5; i++)
sp[i][0] = '\0';
}
for ( i = 2; i < 5; i++)
if (!(xdr_string(xdrs, &sp[i], MAXLINELEN)))
return(FALSE);
for (i = 0; i <LSB_SIG_NUM; i++)
if (!(xdr_int(xdrs, &jobSpecs->sigMap[i])))
return(FALSE);
if (!(xdr_int(xdrs, &jobSpecs->actValue)))
return (FALSE);
if (!xdr_var_string(xdrs, &jobSpecs->loginShell))
return (FALSE);
if (!xdr_var_string(xdrs, &jobSpecs->schedHostType))
return (FALSE);
if (!xdr_var_string(xdrs, &jobSpecs->execHosts))
return (FALSE);
if (!xdr_int(xdrs, &jobSpecs->options2)) {
return(FALSE);
}
pTemp = jobSpecs->jobSpoolDir;
if(!( xdr_string(xdrs, &pTemp, MAXPATHLEN))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_string", "jobSpoolDir");
return(FALSE);
}
if (!(xdr_int(xdrs, &jobArrElemId))) {
return (FALSE);
}
if (xdrs->x_op == XDR_DECODE) {
jobId32To64(&jobSpecs->jobId,jobArrId,jobArrElemId);
}
sp[0] = jobSpecs->inFileSpool;
sp[1] = jobSpecs->commandSpool;
if (!(xdr_string(xdrs, &sp[0], MAXFILENAMELEN))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_string", "inFileSpool");
return (FALSE);
}
if (!(xdr_string(xdrs, &sp[1], MAXFILENAMELEN))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_string", "commandSpool");
return (FALSE);
}
if (!(xdr_int(xdrs, &jobSpecs->userPriority))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int",
"userPriority");
return (FALSE);
}
sp[0] = jobSpecs->execUsername;
if (!(xdr_string(xdrs, &sp[0], MAX_LSB_NAME_LEN))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_string", "execUsername");
return (FALSE);
}
sp[0] = jobSpecs->prepostUsername;
if (!(xdr_string(xdrs, &sp[0], MAX_LSB_NAME_LEN))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_string", "prepostUsername");
return (FALSE);
}
return(TRUE);
}
bool_t
xdr_jobCard (XDR *xdrs, struct jobCard *jCard, struct LSFHeader *hdr)
{
static char fname[]="xdr_jobCard()";
char *sp1;
if (xdrs->x_op == XDR_FREE) {
FREEUP(jCard->actCmd);
FREEUP(jCard->exitFile);
if (!xdr_jobSpecs(xdrs, &jCard->jobSpecs, hdr))
return(FALSE);
return(TRUE);
}
sp1 = jCard->execUsername;
if (! xdr_int(xdrs, (int *)&jCard->execGid)
|| !xdr_int(xdrs, &jCard->notReported)
|| !xdr_time_t(xdrs, &jCard->windEdge)
|| !xdr_char(xdrs, &jCard->active)
|| !xdr_char(xdrs, &jCard->timeExpire)
|| !xdr_char(xdrs, &jCard->missing)
|| !xdr_char(xdrs, &jCard->mbdRestarted)
|| !xdr_time_t(xdrs, &jCard->windWarnTime)
|| !xdr_int(xdrs, &jCard->runTime)
|| !xdr_int(xdrs, &jCard->w_status)
|| !xdr_float(xdrs, &jCard->cpuTime)
|| !xdr_time_t(xdrs, &jCard->lastChkpntTime)
|| !xdr_int(xdrs, &jCard->migCnt)
|| !xdr_int(xdrs, &jCard->cleanupPid)
|| !xdr_int(xdrs, &jCard->execJobFlag)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr");
return(FALSE);
}
if (! xdr_time_t(xdrs, &jCard->lastStatusMbdTime)) {
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE) {
sp1[0] = '\0';
}
if (!xdr_string(xdrs, &sp1, MAX_LSB_NAME_LEN)) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname,
"xdr_string", "execUserName");
return(FALSE);
}
if (! xdr_int(xdrs, &jCard->actReasons)
|| !xdr_int(xdrs, &jCard->actSubReasons)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr");
return(FALSE);
}
if (! xdr_var_string(xdrs, &jCard->actCmd)
|| !xdr_var_string(xdrs, &jCard->exitFile)
|| !xdr_var_string(xdrs, &jCard->clusterName))
return(FALSE);
if (!xdr_arrayElement(xdrs,
(char *)&jCard->jobSpecs,
hdr,
xdr_jobSpecs)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_jobSpecs");
return(FALSE);
}
if (!xdr_int(xdrs, &jCard->servSocket))
return(FALSE);
if (! xdr_int(xdrs, &jCard->maxRusage.mem)
|| !xdr_int(xdrs, &jCard->maxRusage.swap)
|| !xdr_int(xdrs, &jCard->maxRusage.utime)
|| !xdr_int(xdrs, &jCard->maxRusage.stime)
|| !xdr_int(xdrs, &jCard->maxRusage.npids)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_int jRusage");
return(FALSE);
}
if (!xdr_int(xdrs, (int *)&jCard->actFlags)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_actFlags");
return(FALSE);
}
return(TRUE);
}
void
do_probe(XDR * xdrs, int chfd, struct LSFHeader * reqHdr)
{
static char fname[] = "do_probe()";
char reply_buf[MSGSIZE];
XDR xdrs2;
struct LSFHeader replyHdr;
struct sbdPackage sbdPackage;
struct jobSpecs *jobSpecs;
int i;
struct lsfAuth *auth = NULL;
if (reqHdr->length == 0)
return;
initLSFHeader_(&replyHdr);
replyHdr.opCode = ERR_NO_ERROR;
jobSpecs = NULL;
if (!xdr_sbdPackage(xdrs, &sbdPackage, reqHdr)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_sbdPackage");
relife();
} else {
if (sbdPackage.numJobs) {
jobSpecs = my_calloc(sbdPackage.numJobs,
sizeof(struct jobSpecs), fname);
for (i = 0; i < sbdPackage.numJobs; i++) {
if (!xdr_arrayElement(xdrs, (char *) &(jobSpecs[i]),
reqHdr, xdr_jobSpecs)) {
replyHdr.opCode = ERR_BAD_REQ;
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5815,
"%s: %s(%d) failed for %d jobs"), /* catgets 5815 */
fname, "xdr_arrayElement", i, sbdPackage.numJobs);
break;
}
refreshJob(&(jobSpecs[i]));
xdr_lsffree(xdr_jobSpecs, (char *)&jobSpecs[i], reqHdr);
}
}
}
if (replyHdr.opCode == ERR_NO_ERROR)
if (!xdr_sbdPackage1(xdrs, &sbdPackage, reqHdr)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_sbdPackage1");
relife();
}
if (replyHdr.opCode == ERR_NO_ERROR) {
if (myStatus & NO_LIM) {
replyHdr.opCode = ERR_NO_LIM;
}
}
xdrmem_create(&xdrs2, reply_buf, MSGSIZE, XDR_ENCODE);
if (!xdr_encodeMsg(&xdrs2, NULL, &replyHdr, NULL, 0, auth)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_encodeMsg");
relife();
}
if (chanWrite_(chfd, reply_buf, XDR_GETPOS(&xdrs2)) <= 0) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_M, fname, "chanWrite_");
}
xdr_destroy(&xdrs2);
if (jobSpecs != NULL)
free(jobSpecs);
getManagerId(&sbdPackage);
mbdPid = sbdPackage.mbdPid;
sbdSleepTime = sbdPackage.sbdSleepTime;
retryIntvl = sbdPackage.retryIntvl;
preemPeriod = sbdPackage.preemPeriod;
pgSuspIdleT = sbdPackage.pgSuspIdleT;
maxJobs = sbdPackage.maxJobs;
uJobLimit = sbdPackage.uJobLimit;
rusageUpdateRate = sbdPackage.rusageUpdateRate;
rusageUpdatePercent = sbdPackage.rusageUpdatePercent;
jobTerminateInterval = sbdPackage.jobTerminateInterval;
for (i = 0; i < sbdPackage.nAdmins; i++)
FREEUP(sbdPackage.admins[i]);
FREEUP(sbdPackage.admins);
return;
}
bool_t
xdr_resCmdBill (XDR *xdrs, struct resCmdBill *cmd, struct LSFHeader *hdr)
{
char *sp;
int i, argc, nlimits;
if (!(xdr_portno(xdrs, &cmd->retport) &&
xdr_int(xdrs, &cmd->rpid) &&
xdr_int(xdrs, &cmd->filemask) &&
xdr_int(xdrs, &cmd->priority) &&
xdr_int(xdrs, &cmd->options)))
return (FALSE);
sp = cmd->cwd;
if (xdrs->x_op == XDR_DECODE)
sp[0] = '\0';
if (!xdr_string(xdrs, &sp, MAXPATHLEN))
return (FALSE);
if (xdrs->x_op == XDR_ENCODE)
for (argc=0; cmd->argv[argc]; argc++);
if (!xdr_int(xdrs, &argc))
return (FALSE);
if (xdrs->x_op == XDR_DECODE) {
if ((cmd->argv = (char **) calloc(argc + 1, sizeof(char *))) == NULL)
return (FALSE);
}
for (i=0; i<argc; i++) {
if (!xdr_var_string(xdrs, &(cmd->argv[i]))) {
if (xdrs->x_op == XDR_DECODE) {
while (i--)
free(cmd->argv[i]);
free(cmd->argv);
}
return (FALSE);
}
}
if (xdrs->x_op == XDR_DECODE)
cmd->argv[argc] = NULL;
else
nlimits = LSF_RLIM_NLIMITS;
if (!xdr_int(xdrs, &nlimits)) {
if (xdrs->x_op == XDR_DECODE)
goto DecodeQuit;
else
return (FALSE);
}
if (xdrs->x_op == XDR_DECODE)
nlimits = (nlimits < LSF_RLIM_NLIMITS) ? nlimits : LSF_RLIM_NLIMITS;
for (i=0; i<nlimits; i++) {
if (!xdr_arrayElement(xdrs, (char *) &(cmd->lsfLimits[i]), hdr,
xdr_lsfLimit)) {
if (xdrs->x_op == XDR_DECODE)
goto DecodeQuit;
else
return (FALSE);
}
}
return (TRUE);
DecodeQuit:
for (i=0; i<argc; i++)
free(cmd->argv[i]);
free(cmd->argv);
return (FALSE);
}
