static char *
readPIMBuf(char *pfile)
{
char *fname="readPIMBuf";
struct stat bstat;
FILE *fp;
FREEUP(pimInfoBuf);
pimInfoLen = 0;
if (stat(pfile,&bstat) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "stat", pfile);
return(NULL);
}
pimInfoLen = bstat.st_size;
if ((pimInfoBuf = (char *)malloc(pimInfoLen+1)) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_M, fname, "malloc");
return(NULL);
}
if ((fp = openPIMFile(pfile)) == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "openPIMFile", pfile);
return (FALSE);
}
if (fread(pimInfoBuf,sizeof(char),pimInfoLen,fp) <= 0) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_M, fname, "fread");
FREEUP(pimInfoBuf);
return(NULL);
}
fclose(fp);
pimInfoBuf[pimInfoLen] = '\0';
return(pimInfoBuf);
}
void
freeResVal(struct resVal *resVal)
{
struct _rusage_ *r;
if (resVal == NULL)
return;
FREEUP(resVal->indicies);
FREEUP(resVal->selectStr);
resVal->selectStrSize = 0;
if (resVal->xorExprs) {
int i;
for (i = 0; resVal->xorExprs[i]; i++)
FREEUP(resVal->xorExprs[i]);
FREEUP(resVal->xorExprs);
}
_free_(resVal->val);
_free_(resVal->rusage_bit_map);
while ((r = pop_link(resVal->rl))) {
_free_(r->bitmap);
_free_(r->val);
_free_(r);
}
fin_link(resVal->rl);
}
/* lsb_getlimits()
*/
struct resLimitReply *
lsb_getlimits()
{
XDR xdrs;
struct LSFHeader hdr;
char *reply;
int cc;
char buf[sizeof(struct LSFHeader)];
struct resLimitReply *limitReply;
initLSFHeader_(&hdr);
hdr.opCode = BATCH_RESLIMIT_INFO;
xdrmem_create(&xdrs, buf, sizeof(struct LSFHeader), XDR_ENCODE);
if (! xdr_LSFHeader(&xdrs, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
return NULL;
}
reply = NULL;
cc = callmbd(NULL,
buf,
XDR_GETPOS(&xdrs),
&reply,
&hdr,
NULL,
NULL,
NULL);
if (cc < 0) {
xdr_destroy(&xdrs);
lsberrno = LSBE_PROTOCOL;
return NULL;
}
xdr_destroy(&xdrs);
if (hdr.opCode != LSBE_NO_ERROR) {
FREEUP(reply);
lsberrno = hdr.opCode;
return NULL;
}
xdrmem_create(&xdrs, reply, XDR_DECODE_SIZE_(cc), XDR_DECODE);
limitReply = calloc(1, sizeof(struct resLimitReply));
if(!xdr_resLimitReply(&xdrs, limitReply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
if (cc) {
FREEUP(reply);
FREEUP(limitReply);
}
return NULL;
}
xdr_destroy(&xdrs);
if (cc)
FREEUP(reply);
return limitReply;
}
static int
copyAdmins_ (struct clusterInfo *clusPtr, struct shortCInfo *clusShort)
{
int i, j;
if (clusShort->nAdmins <= 0)
return 0;
clusPtr->adminIds = calloc (clusShort->nAdmins, sizeof (int));
clusPtr->admins = calloc (clusShort->nAdmins, sizeof (char *));
if (!clusPtr->admins || !clusPtr->adminIds)
goto errReturn;
for (i = 0; i < clusShort->nAdmins; i++)
{
clusPtr->admins[i] = NULL;
clusPtr->adminIds[i] = clusShort->adminIds[i];
clusPtr->admins[i] = putstr_ (clusShort->admins[i]);
if (clusPtr->admins[i] == NULL)
{
for (j = 0; j < i; j++)
FREEUP (clusPtr->admins[j]);
goto errReturn;
}
}
return 0;
errReturn:
FREEUP (clusPtr->admins);
FREEUP (clusPtr->adminIds);
lserrno = LSE_MALLOC;
return (-1);
}
int
ls_rtask(char *host, char **argv, int options)
{
char **envp;
int numEnv;
int ret;
for (numEnv = 0; environ[numEnv]; numEnv++)
;
envp = (char **)calloc(numEnv + 1, sizeof(char *));
for (numEnv = 0; environ[numEnv]; numEnv ++)
envp[numEnv] = strdup(environ[numEnv]);
envp[numEnv] = NULL;
ret = ls_rtaske(host, argv, options, envp);
if (envp) {
for (numEnv = 0; envp[numEnv]; numEnv++)
FREEUP(envp[numEnv]);
FREEUP(envp);
}
return ret;
}
static int
getEAuth(struct eauth *eauth, char *host)
{
char *argv[4];
char path[MAXPATHLEN];
struct lenData ld;
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);
argv[0] = path;
argv[1] = "-c";
argv[2] = host;
argv[3] = NULL;
if (logclass & LC_TRACE)
ls_syslog(LOG_DEBUG, "runEAuth(): path=<%s>", path);
if (runEClient_(&ld, argv) == -1) {
if (logclass & (LC_AUTH |LC_TRACE))
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, "runEAuth", "runEClient", path);
lserrno = LSE_EAUTH;
return -1;
}
if (ld.len == 0) {
if (logclass & (LC_AUTH |LC_TRACE))
ls_syslog(LOG_DEBUG, "runEAuth: <%s> got no data", path);
FREEUP(ld.data);
lserrno = LSE_EAUTH;
return -1;
}
if (ld.len > EAUTH_SIZE) {
if (logclass & (LC_AUTH |LC_TRACE))
ls_syslog(LOG_DEBUG, "runEAuth: <%s> got too much data, size=%d",
path, ld.len);
FREEUP(ld.data);
lserrno = LSE_EAUTH;
return -1;
}
memcpy(eauth->data, ld.data, ld.len);
eauth->data[ld.len] = '\0';
if (logclass & (LC_AUTH |LC_TRACE))
ls_syslog(LOG_DEBUG, "runEAuth: <%s> got data=%s",
path, ld.data);
eauth->len = ld.len;
FREEUP(ld.data);
if (logclass & (LC_AUTH |LC_TRACE))
ls_syslog(LOG_DEBUG, "runEAuth: <%s> got len=%d",
path, ld.len);
return 0;
}
int
mapValues(struct keymap *keyList, char *line)
{
int pos = 0;
char *value;
int i = 0;
int found;
int numv = 0;
while (keyList[i].key != NULL) {
FREEUP (keyList[i].val);
if (keyList[i].position != -1)
numv++;
i++;
}
while ((value = getNextValue(&line)) != NULL) {
i=0;
found = FALSE;
while (keyList[i].key != NULL) {
if (keyList[i].position != pos) {
i++;
continue;
}
if (strcmp (value, "-") == 0)
keyList[i].val = putstr_("");
else {
if (keyList[i].val != NULL)
FREEUP (keyList[i].val);
keyList[i].val = putstr_(value);
}
found = TRUE;
break;
}
if (! found)
goto fail;
pos++;
}
if (pos != numv)
goto fail;
return 0;
fail:
i=0;
while (keyList[i].key != NULL) {
if (keyList[i].val != NULL) {
free(keyList[i].val);
keyList[i].val = NULL;
}
i++;
}
return -1;
}
static void
printsummary (void)
{
char localTimeStrBegin[60];
char localTimeStrEnd[60];
char *buf1, *buf2, *buf3, *buf4, *buf5;
if (tottasks == 0)
return;
strcpy (localTimeStrBegin, _i18n_ctime (ls_catd, 1, &actual_start.begin));
strcpy (localTimeStrEnd, _i18n_ctime (ls_catd, 1, &actual_start.end));
printf (_i18n_msg_get (ls_catd, NL_SETN, 1231, "Summary of %d task(s). (Exit status zero: %d; exit status non-zero: %d).\n"), /* catgets 1231 */
tottasks, totstatz, totstatnz);
sprintf (printline, _i18n_msg_get (ls_catd, NL_SETN, 1232, "Started between %s and %s"), /* catgets 1232 */
localTimeStrBegin, localTimeStrEnd);
printf ("%s", printline);
strcpy (localTimeStrBegin,
_i18n_ctime (ls_catd, 1, &actual_complete.begin));
strcpy (localTimeStrEnd, _i18n_ctime (ls_catd, 1, &actual_complete.end));
sprintf (printline, _i18n_msg_get (ls_catd, NL_SETN, 1234, "Completed between %s and %s"), /* catgets 1234 */
localTimeStrBegin, localTimeStrEnd);
printf ("%s\n", printline);
buf1 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1236, "Resource")); /* catgets 1236 */
buf2 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1237, "Total")); /* catgets 1237 */
buf3 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1238, "Average")); /* catgets 1238 */
buf4 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1239, "Maximum")); /* catgets 1239 */
buf5 = putstr_ (_i18n_msg_get (ls_catd, NL_SETN, 1240, "Minimum")); /* catgets 1240 */
printf (" %-30s%12s%12s%12s%12s\n", buf1, buf2, buf3, buf4, buf5);
FREEUP (buf1);
FREEUP (buf2);
FREEUP (buf3);
FREEUP (buf4);
FREEUP (buf5);
printresuse (cpu, _i18n_msg_get (ls_catd, NL_SETN, 1241, "CPU time (seconds):")); /* catgets 1241 */
printresuse (pf, _i18n_msg_get (ls_catd, NL_SETN, 1242, "Page faults:")); /* catgets 1242 */
printresuse (swaps, _i18n_msg_get (ls_catd, NL_SETN, 1243, "Swaps:")); /* catgets 1243 */
printresuse (bin, _i18n_msg_get (ls_catd, NL_SETN, 1244, "Block input:")); /* catgets 1244 */
printresuse (bout, _i18n_msg_get (ls_catd, NL_SETN, 1245, "Block output:")); /* catgets 1245 */
printresuse (msgs, _i18n_msg_get (ls_catd, NL_SETN, 1246, "Messages sent:")); /* catgets 1246 */
printresuse (msgr, _i18n_msg_get (ls_catd, NL_SETN, 1247, "Messages received:")); /* catgets 1247 */
printresuse (vcsw, _i18n_msg_get (ls_catd, NL_SETN, 1248, "Voluntary context switches:")); /* catgets 1248 */
printresuse (ivcsw, _i18n_msg_get (ls_catd, NL_SETN, 1249, "Involuntary context switches:")); /* catgets 1249 */
printresuse (turn, _i18n_msg_get (ls_catd, NL_SETN, 1250, "Turnaround time (seconds):")); /* catgets 1250 */
}
static int
xdr_thresholds(XDR *xdrs, struct jobSpecs *jobSpecs)
{
static char fname[] = "xdr_thresholds";
int i, j;
if (xdrs->x_op == XDR_DECODE) {
jobSpecs->thresholds.loadSched = NULL;
jobSpecs->thresholds.loadStop = NULL;
}
if (xdrs->x_op == XDR_FREE) {
for(i=0; i < jobSpecs->thresholds.nThresholds; i++) {
FREEUP(jobSpecs->thresholds.loadSched[i]);
FREEUP(jobSpecs->thresholds.loadStop[i]);
}
FREEUP(jobSpecs->thresholds.loadSched);
FREEUP(jobSpecs->thresholds.loadStop);
return(TRUE);
}
if (!(xdr_int(xdrs, &jobSpecs->thresholds.nIdx) &&
xdr_int(xdrs, &jobSpecs->thresholds.nThresholds))) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(jobSpecs->jobId),
"xdr_int", "nIdx/nThresholds");
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE) {
jobSpecs->thresholds.loadSched = (float **)
my_calloc (jobSpecs->thresholds.nThresholds, sizeof(float *), fname);
jobSpecs->thresholds.loadStop = (float **)
my_calloc (jobSpecs->thresholds.nThresholds, sizeof(float *), fname);
for (i = 0; i < jobSpecs->thresholds.nThresholds; i++) {
jobSpecs->thresholds.loadSched[i] = (float *)
my_calloc (jobSpecs->thresholds.nIdx, sizeof(float), fname);
jobSpecs->thresholds.loadStop[i] = (float *)
my_calloc (jobSpecs->thresholds.nIdx, sizeof(float), fname);
}
}
for (j = 0; j < jobSpecs->thresholds.nThresholds; j++) {
for (i = 0; i < jobSpecs->thresholds.nIdx; i++) {
if (!(xdr_float(xdrs, &jobSpecs->thresholds.loadStop[j][i]) &&
xdr_float(xdrs, &jobSpecs->thresholds.loadSched[j][i]))) {
ls_syslog(LOG_ERR, I18N_JOB_FAIL_S_S, fname,
lsb_jobid2str(jobSpecs->jobId),
"xdr_float", "loadStop/loadSched");
return(FALSE);
}
}
}
return (TRUE);
}
bool_t
xdr_sbdPackage1 (XDR *xdrs, struct sbdPackage *sbdPackage, struct LSFHeader *hdr)
{
static char fname[] = "xdr_sbdPackage1";
int i;
if (!(xdr_int(xdrs, &sbdPackage->uJobLimit))) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_int", "uJobLimit");
return(FALSE);
}
if (!(xdr_int(xdrs, &sbdPackage->rusageUpdateRate) &&
xdr_int(xdrs, &sbdPackage->rusageUpdatePercent)))
return(FALSE);
if (!xdr_int(xdrs, &sbdPackage->jobTerminateInterval)) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname,
"xdr_int", "jobTerminateInterval");
return (FALSE);
}
if (xdrs->x_op == XDR_ENCODE || (xdrs->x_op != XDR_FREE)) {
if (!xdr_int(xdrs, &sbdPackage->nAdmins))
return FALSE;
if (xdrs->x_op == XDR_DECODE && sbdPackage->nAdmins > 0) {
sbdPackage->admins
= (char **) calloc (sbdPackage->nAdmins, sizeof (char *));
if (sbdPackage->admins == NULL) {
sbdPackage->nAdmins = 0;
return (FALSE);
}
}
for (i = 0; i < sbdPackage->nAdmins; i++) {
if (!xdr_var_string (xdrs, &sbdPackage->admins[i]))
return (FALSE);
}
}
if (xdrs->x_op == XDR_FREE) {
for (i = 0; i < sbdPackage->nAdmins; i++) {
FREEUP(sbdPackage->admins[i]);
}
FREEUP(sbdPackage->admins);
}
return(TRUE);
}
struct jData *
copyJData(struct jData *jp)
{
struct jData *jData;
struct rqHistory *reqHistory;
int i;
jData = initJData(jp->shared);
if (jData->jobSpoolDir) {
FREEUP(jData->jobSpoolDir);
}
reqHistory = jData->reqHistory;
memcpy((char *)jData, (char *)jp, sizeof(struct jData));
jData->reqHistory = reqHistory;
jData->numRef = 0;
jData->nextJob = NULL;
jData->userName = safeSave(jp->userName);
jData->schedHost = safeSave(jp->schedHost);
jData->uPtr = getUserData(jData->userName);
if (jp->askedPtr) {
jData->askedPtr = (struct askedHost *) my_calloc (jp->numAskedPtr,
sizeof(struct askedHost), "copyJData");
for (i = 0; i < jp->numAskedPtr; i++) {
jData->askedPtr[i].hData = jp->askedPtr[i].hData;
jData->askedPtr[i].priority = jp->askedPtr[i].priority;
}
}
if (jp->jobSpoolDir) {
jData->jobSpoolDir = safeSave(jp->jobSpoolDir);
}
return(jData);
}
void
freeGroupInfoReply (struct groupInfoReply *reply)
{
int i;
if (reply == NULL)
return;
for (i = 0; i < reply->numGroups; i++) {
FREEUP(reply->groups[i].memberList);
}
FREEUP (reply->groups);
}
static void
displayShareRes(int argc, char **argv, int index)
{
struct lsbSharedResourceInfo *lsbResourceInfo;
int numRes = 0;
char **resourceNames = NULL, **resources = NULL;
char fname[]="displayShareRes";
if (argc > index) {
if ((resourceNames =
(char **) malloc ((argc - index) * sizeof (char *))) == NULL) {
char i18nBuf[100];
sprintf ( i18nBuf,I18N_FUNC_FAIL,fname,"malloc");
perror( i18nBuf );
exit (-1);
}
numRes = getResourceNames (argc, argv, index, resourceNames);
}
if (numRes > 0)
resources = resourceNames;
TIMEIT(0, (lsbResourceInfo = lsb_sharedresourceinfo (resources, &numRes, NULL, 0)), "lsb_sharedresourceinfo");
if (lsbResourceInfo == NULL) {
if (lsberrno == LSBE_BAD_RESOURCE && resources)
lsb_perror(NULL);
else
lsb_perror("lsb_sharedresourceinfo");
exit(-1);
}
prtResourcesShort(numRes, lsbResourceInfo);
FREEUP(resourceNames);
}
void
h_freeRefTab_ (hTab * tabPtr)
{
struct hLinks *hTabEnd, *slotPtr;
hEnt *hEntPtr;
slotPtr = tabPtr->slotPtr;
hTabEnd = &(slotPtr[tabPtr->size]);
for (; slotPtr < hTabEnd; slotPtr++)
{
while (slotPtr != slotPtr->bwPtr)
{
hEntPtr = (hEnt *) slotPtr->bwPtr;
remList_ ((struct hLinks *) hEntPtr);
FREEUP (hEntPtr->keyname);
free (hEntPtr);
}
}
free (tabPtr->slotPtr);
tabPtr->slotPtr = NULL;
tabPtr->numEnts = 0;
}
int
updLocalJData (struct jData *jp, struct jData *jpbw)
{
int i;
if (jp->numAskedPtr)
FREEUP (jp->askedPtr);
jp->numAskedPtr = 0;
if (jpbw->askedPtr)
{
jp->askedPtr = (struct askedHost *) my_calloc (jpbw->numAskedPtr,
sizeof (struct
askedHost),
"updLocalJData");
for (i = 0; i < jpbw->numAskedPtr; i++)
{
jp->askedPtr[i].hData = jpbw->askedPtr[i].hData;
jp->askedPtr[i].priority = jpbw->askedPtr[i].priority;
}
jp->numAskedPtr = jpbw->numAskedPtr;
}
jp->jFlags &= ~JFLAG_DEPCOND_INVALID;
return (LSBE_NO_ERROR);
}
void
prtJobSubmit(struct jobInfoEnt *job, int prt_q, int tFormat)
{
char prline[MAXLINELEN];
char *timestr;
timestr = putstr_(_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T, &job->submitTime));
if (tFormat) {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,569, "%s: Job <%s> submitted from host <%s>")), /* catgets 569 */
timestr, lsb_jobid2str(job->jobId), job->fromHost);
} else {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,570, "%s: Submitted from host <%s>")), /* catgets 570 */
timestr, job->fromHost);
}
FREEUP(timestr);
prtLine(prline);
if (job->submit.options2 & SUB2_HOLD) {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,570, " with hold")));
/* catgets 570 */
prtLine(prline);
}
if (prt_q) {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,571, ", to Queue <%s>")), job->submit.queue); /* catgets 571 */
prtLine(prline);
}
TIMEIT(2, prtBTTime(job), "prtBTTime");
}
static struct hostInfoEnt *
getHostList(int *numHosts, char **inputHosts)
{
static struct hostInfoEnt *hostInfo = NULL;
int i;
char *localHost;
FREEUP(hostInfo);
if ((hostInfo = (struct hostInfoEnt *) calloc(*numHosts + 1,
sizeof(struct hostInfoEnt)))
== NULL) {
perror("calloc");
return NULL;
}
if (inputHosts) {
for (i = 0; i < *numHosts; i++)
hostInfo[i].host = inputHosts[i];
} else {
if ((localHost = ls_getmyhostname()) == NULL)
hostInfo[0].host = "localhost";
else
hostInfo[0].host = localHost;
}
return hostInfo;
}
int
expandList1_ (char ***tolist, int num, int *bitmMaps, char **keys)
{
int ii, jj, isSet;
char **temp;
if (num <= 0)
return 0;
if ((temp = (char **) calloc (num, sizeof (char *))) == NULL)
{
lserrno = LSE_MALLOC;
return (-1);
}
for (ii = 0, jj = 0; ii < num; ii++)
{
TEST_BIT (ii, bitmMaps, isSet);
if (isSet == 1)
{
temp[jj++] = keys[ii];
}
}
if (jj > 0)
{
*tolist = temp;
}
else
{
FREEUP (temp);
*tolist = NULL;
}
return (jj);
}
static int
readPIMFile(char *pfile)
{
char *fname = "readPIMFile";
struct lsPidInfo *tmp;
char *buffer,*tmpbuf;
char pimString[MAXLINELEN];
if ((buffer=readPIMBuf(pfile))==NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "readPIMBuf");
return(FALSE);
}
FREEUP(pinfoList);
npinfoList = 0;
pinfoList = (struct lsPidInfo *)malloc(sizeof(struct lsPidInfo) * MAX_NUM_PID);
if (pinfoList == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_D_FAIL_M, fname, "malloc",
sizeof(struct lsPidInfo) * MAX_NUM_PID);
return(FALSE);
}
tmpbuf = getNextString(buffer,pimString);
if (tmpbuf == NULL) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5908,
"%s format error"), "pim.info"); /* catgets 5908 */
return(FALSE);
}
buffer = tmpbuf;
while ((tmpbuf = getNextString(buffer,pimString))!=NULL) {
buffer = tmpbuf;
if (logclass & LC_PIM)
ls_syslog(LOG_DEBUG3,"pim info string is %s",pimString);
sscanf(pimString, "%d %d %d %d %d %d %d %d %d %d %d %d",
&pinfoList[npinfoList].pid, &pinfoList[npinfoList].ppid,
&pinfoList[npinfoList].pgid, &pinfoList[npinfoList].jobid,
&pinfoList[npinfoList].utime, &pinfoList[npinfoList].stime,
&pinfoList[npinfoList].cutime, &pinfoList[npinfoList].cstime,
&pinfoList[npinfoList].proc_size, &pinfoList[npinfoList].resident_size,
&pinfoList[npinfoList].stack_size,
(int *)&pinfoList[npinfoList].status);
npinfoList ++;
if (npinfoList % MAX_NUM_PID == 0) {
tmp = (struct lsPidInfo *)realloc(pinfoList,
sizeof(struct lsPidInfo) * (npinfoList + MAX_NUM_PID));
if (tmp == NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_D_FAIL_M, fname, "realloc",
sizeof(struct lsPidInfo)
* (npinfoList + MAX_NUM_PID));
return(FALSE);
}
pinfoList = tmp;
}
}
return(TRUE);
}
void
freeTimeWindow(struct timeWindow *timeW)
{
int i;
if (!timeW) {
return;
}
FREEUP(timeW->windows);
for (i = 0; i < 8; i++) {
delWindow(timeW->week[i]);
}
FREEUP(timeW);
}
/* freeHostEntryLog()
*/
int
freeHostEntryLog(struct hostEntryLog **hPtr)
{
int cc;
if (hPtr == NULL
|| *hPtr == NULL)
return -1;
FREEUP((*hPtr)->busyThreshold);
for (cc = 0; cc < (*hPtr)->nRes; cc++)
FREEUP((*hPtr)->resList[cc]);
FREEUP((*hPtr)->resList);
FREEUP((*hPtr)->window);
FREEUP(*hPtr);
return 0;
}
void
freeGroupInfoReply(struct groupInfoReply *reply)
{
int i;
if (reply == NULL)
return;
for (i = 0; i < reply->numGroups; i++) {
FREEUP(reply->groups[i].memberList);
/* other members of the groupInfoEnt are
* not freed as they address static memory
*/
}
FREEUP(reply->groups);
}
static void
prtResourcesShort(int num, struct lsbSharedResourceInfo *info)
{
struct lsInfo *lsInfo;
int i, j, k;
char *buf1, *buf2, *buf3, *buf4;
if ((lsInfo = ls_info()) == NULL) {
ls_perror("lsinfo");
exit(-10);
}
buf1 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1645, "RESOURCE")); /* catgets 1645 */
buf2 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1646, "TOTAL")); /* catgets 1646 */
buf3 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1647, "RESERVED")); /* catgets 1647 */
buf4 = putstr_(_i18n_msg_get(ls_catd,NL_SETN,1648, "LOCATION")); /* catgets 1648 */
printf("%-20s%10s%15s%15s\n", buf1, buf2, buf3, buf4);
FREEUP(buf1);
FREEUP(buf2);
FREEUP(buf3);
FREEUP(buf4);
for (i = 0; i < num; i++) {
for (j = 0; j < info[i].nInstances; j++) {
for (k = 0; k < lsInfo->nRes; k++) {
if (strcmp(lsInfo->resTable[k].name,
info[i].resourceName) == 0) {
if (lsInfo->resTable[k].valueType & LS_NUMERIC) {
prtOneInstance(info[i].resourceName,
&(info[i].instances[j]));
}
}
}
}
}
}
int
getNames (int argc, char **argv, int optind, char ***nameList,
int *allOrDef, char *nameType)
{
int numNames = 0;
int a_size=0;
static char **list = NULL;
char **temp;
FREEUP (list);
a_size=16;
if ((list=(char **)malloc(a_size*sizeof(char *)))==NULL)
return 0;
*allOrDef = FALSE;
if (argc >= optind+1) {
for (numNames = 0; argc > optind; optind++) {
if (strcmp (nameType, "host") == 0
&& strcmp (argv[optind], "myhostname") == 0) {
*allOrDef = TRUE;
numNames = 1;
break;
}
if ((strcmp (nameType, "hostC") == 0
|| strcmp (nameType, "queueC") == 0
|| strcmp (nameType, "user") == 0)
&& strcmp(argv[optind], "all") == 0) {
*allOrDef = TRUE;
numNames = 0;
break;
}
if (repeatedName(argv[optind], list, numNames))
continue;
if ((a_size!=0) && (numNames>=a_size)) {
a_size <<= 1;
if ((temp=(char **)realloc(list,
a_size*sizeof(char *)))==NULL) {
*nameList = list;
return (numNames);
}
list = temp;
}
list[numNames] = argv[optind];
numNames ++;
}
}
if (numNames == 1 && strcmp (nameType, "queue") == 0
&& strcmp ("default", list[0]) == 0)
*allOrDef = TRUE;
*nameList = list;
return (numNames);
}
int
putInLists (char *word, struct admins *admins, int *numAds, char *forWhat)
{
static char fname[] = "putInLists";
struct passwd *pw;
char **tempNames;
int i, *tempIds, *tempGids;
if ((pw = getpwlsfuser_ (word)) == NULL)
{
if (logclass & LC_TRACE)
{
ls_syslog (LOG_DEBUG, _i18n_msg_get (ls_catd, NL_SETN, 5410, "%s: <%s> is not a valid user on this host"), fname, word); /* catgets 5410 */
}
}
if (isInlist (admins->adminNames, word, admins->nAdmins))
{
ls_syslog (LOG_WARNING, _i18n_msg_get (ls_catd, NL_SETN, 5411, "%s: Duplicate user name <%s> %s; ignored"), fname, word, forWhat); /* catgets 5411 */
return (0);
}
admins->adminIds[admins->nAdmins] = (pw == NULL) ? -1 : pw->pw_uid;
admins->adminGIds[admins->nAdmins] = (pw == NULL) ? -1 : pw->pw_gid;
admins->adminNames[admins->nAdmins] = putstr_ (word);
admins->nAdmins += 1;
if (admins->nAdmins >= *numAds)
{
*numAds = *numAds * 2;
tempIds = (int *) realloc (admins->adminIds, *numAds * sizeof (int));
tempGids = (int *) realloc (admins->adminGIds, *numAds * sizeof (int));
tempNames =
(char **) realloc (admins->adminNames, *numAds * sizeof (char *));
if (tempIds == NULL || tempGids == NULL || tempNames == NULL)
{
ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "realloc");
FREEUP (tempIds);
FREEUP (tempGids);
FREEUP (tempNames);
FREEUP (admins->adminIds);
FREEUP (admins->adminGIds);
for (i = 0; i < admins->nAdmins; i++)
FREEUP (admins->adminNames[i]);
FREEUP (admins->adminNames);
admins->nAdmins = 0;
lserrno = LSE_MALLOC;
return (-1);
}
else
{
admins->adminIds = tempIds;
admins->adminGIds = tempGids;
admins->adminNames = tempNames;
}
}
return (0);
}
void
freeIdxList(struct idxList *idxList)
{
struct idxList *ptr;
while(idxList) {
ptr = idxList->next;
FREEUP(idxList);
idxList = ptr;
}
return;
}
bool_t
xdr_chunkStatusReq (XDR *xdrs, struct chunkStatusReq *chunkStatusReq,
struct LSFHeader *hdr)
{
static char fname[] = "xdr_chunkStatusReq";
int i;
if (xdrs->x_op == XDR_DECODE) {
chunkStatusReq->numStatusReqs = 0;
chunkStatusReq->statusReqs = NULL;
}
if (xdrs->x_op == XDR_FREE) {
for ( i = 0; i < chunkStatusReq->numStatusReqs; i++) {
xdr_lsffree(xdr_statusReq,
(char *)chunkStatusReq->statusReqs[i], hdr);
FREEUP(chunkStatusReq->statusReqs[i]);
}
FREEUP(chunkStatusReq->statusReqs);
return(TRUE);
}
if (!xdr_int(xdrs, &chunkStatusReq->numStatusReqs)) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL, fname, "xdr_int",
"numStatusReqs");
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE && chunkStatusReq->numStatusReqs) {
chunkStatusReq->statusReqs = (struct statusReq **)
my_calloc(chunkStatusReq->numStatusReqs,
sizeof (struct statusReq *), fname);
for ( i = 0; i < chunkStatusReq->numStatusReqs; i++) {
chunkStatusReq->statusReqs[i] = (struct statusReq *) my_calloc(1,
sizeof (struct statusReq), fname);
}
}
for ( i = 0; i < chunkStatusReq->numStatusReqs; i++) {
xdr_statusReq(xdrs, chunkStatusReq->statusReqs[i], hdr);
}
return(TRUE);
}
void
getManagerId(struct sbdPackage *sbdPackage)
{
struct passwd *pw;
int i;
FREEUP(lsbManager);
if (sbdPackage->nAdmins <= 0) {
ls_syslog(LOG_ERR, "\
%s: No LSF administrator defined in sbdPackage from MBD.", __func__);
die(FATAL_ERR);
}
int
ls_rtask(char *host, char **argv, int options)
{
char **envp;
char *sp;
int numEnv;
int i;
int ret;
for (numEnv = 0; environ[numEnv]; numEnv++)
;
envp = (char **)calloc(numEnv + 2, sizeof(char *));
i = 0;
for (numEnv = 0; environ[numEnv]; numEnv ++) {
if ((is_replace_user_map_env!=0)
&& (sp = strstr(environ[numEnv], "WIN_USER_MAPPING")) != NULL)
continue;
envp[i] = strdup(environ[numEnv]);
i++;
}
if (user_map_value && user_map_value[0] != NULL) {
envp[i] = strdup(user_map_value);
i++;
}
envp[i] = NULL;
ret = ls_rtaske(host, argv, options, envp);
if (envp) {
for (numEnv = 0; envp[numEnv]; numEnv++)
FREEUP(envp[numEnv]);
FREEUP(envp);
}
return ret;
}
void
getLSFAdmins_(void)
{
struct clusterInfo *clusterInfo;
int i;
clusterInfo = ls_clusterinfo(NULL, NULL, NULL, 0, 0);
if (clusterInfo == NULL) {
return;
}
if (LSFAdmins.numAdmins != 0) {
FREEUP(LSFAdmins.names);
}
LSFAdmins.numAdmins = clusterInfo->nAdmins;
LSFAdmins.names = calloc(LSFAdmins.numAdmins, sizeof(char *));
if (LSFAdmins.names == NULL) {
LSFAdmins.numAdmins = 0;
return;
}
for (i = 0; i < LSFAdmins.numAdmins; i ++) {
LSFAdmins.names[i] = putstr_(clusterInfo->admins[i]);
if (LSFAdmins.names[i] == NULL) {
int j;
for (j = 0; j < i; j ++) {
FREEUP(LSFAdmins.names[j]);
}
FREEUP(LSFAdmins.names);
LSFAdmins.numAdmins = 0;
return;
}
}
}
