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; } } }