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; }
char *ls_getmnthost(char *file) { struct stat statb; if (stat(file, &statb) < 0) { return (NULL); } return (ls_getmyhostname()); }
int parseXferArg(char *arg, char **userName, char **hostName, char **fName) { char *tmp_arg, *tmp_ptr; char *user_arg = NULL, *host_arg; char *freeup_tmp; char szOfficialName[MAXHOSTNAMELEN]; freeup_tmp = tmp_arg = putstr_(arg); tmp_ptr = strchr(tmp_arg, '@'); if (tmp_ptr) { *tmp_ptr = '\0'; user_arg = tmp_arg; tmp_arg = ++tmp_ptr; } if (!tmp_ptr || *user_arg == '\0') { char lsfUserName[MAXLSFNAMELEN]; if (getUser(lsfUserName, sizeof(lsfUserName)) != 0) { free(freeup_tmp); return -1; } *userName = putstr_(lsfUserName); } else *userName = putstr_(user_arg); tmp_ptr = strchr(tmp_arg, ':'); if (tmp_ptr) { *tmp_ptr = '\0'; host_arg = tmp_arg; tmp_arg = ++tmp_ptr; } if (!tmp_ptr || *host_arg == '\0') { *hostName = putstr_(ls_getmyhostname()); } else { strcpy(szOfficialName, host_arg); *hostName = putstr_(szOfficialName); } if (tmp_arg) { *fName = putstr_(tmp_arg); } else { free(freeup_tmp); return -1; } free(freeup_tmp); return 0; }
int getElock(void) { static char fname[] = "getElock"; int force = 0; int retry; char *myhostnm, *mastername; struct stat statbuf; time_t lastmodtime; char first = TRUE; char buf[MAXHOSTNAMELEN+8]; int lock_fd = -1; if (lsb_CheckMode) return 0; if ((myhostnm = ls_getmyhostname()) == NULL) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname"); return MASTER_FATAL; } sprintf(lockfile, "%s/logdir/%s", daemonParams[LSB_SHAREDIR].paramValue, EVENT_LOCK_FILE); access: chuser(managerId); if (force) lock_fd = open(lockfile, O_RDWR | O_CREAT | O_TRUNC, 0644); else lock_fd = open(lockfile, O_RDWR | O_CREAT | O_EXCL, 0644); if (lock_fd >= 0) { sprintf(buf, "%s:%d", myhostnm, (int)getpid()); write(lock_fd, buf, strlen(buf)); close(lock_fd); chuser(batchId); ls_syslog(LOG_INFO, "%s: Got lock file", fname); gotLock = TRUE; return 0; } else if (errno == EEXIST) { int fd,cc,i,pid; fd = open(lockfile, O_RDONLY, 0444); chuser(batchId); if (fd < 0) { ls_syslog(LOG_ERR, "\ %s: Can't open existing lock file <%s>: %m", fname, lockfile); return MASTER_FATAL; }
static void setdefaults (void) { int n; char *confpath, *localHost; struct config_param acctdir[] = { {"LSF_RES_ACCTDIR", NULL}, {NULL, NULL} }; struct stat statBuf; char lsfUserName[MAX_LOGIN + 1]; details = 0; if ((confpath = getenv ("LSF_ENVDIR")) == NULL) confpath = "/etc"; ls_readconfenv (acctdir, confpath); if (acctdir[0].paramValue == NULL || stat (acctdir[0].paramValue, &statBuf) == -1) acctdir[0].paramValue = "/tmp"; strcpy (logfile, acctdir[0].paramValue); n = strlen (logfile); strncat (logfile, "/lsf.acct.", MAX_PATH - n); if ((localHost = ls_getmyhostname ()) == NULL) { ls_perror ("ls_getmyhostname"); return; } n = strlen (logfile); strncat (logfile, localHost, MAX_PATH - n); if (getLSFUser_ (lsfUserName, MAX_LOGIN + 1) != 0) { ls_perror ("getLSFUser_"); return; } strcpy (mylogin, lsfUserName); users[0] = mylogin; users[1] = NULL; hosts[0] = NULL; eternity = mkinterval (mktime (&creation), mktime (&destruction)); start = complete = eternity; }
int copyFile(lsRcpXfer *lsXfer, char* buf, int option ) { char szThisHost[MAXHOSTNAMELEN]; struct stat sLstat, sRstat; int iRetVal = 0, len = 0; int lfd, rfd; int file_no_exist = FALSE; int ret = 0; mode_t mode; char fname[]="copyFile"; static struct hostent pheHostBuf, pheDestBuf; struct hostent *hp1, *hp2; static int first = 1; if (first) { memset(&pheHostBuf, 0, sizeof(struct hostent)); memset(&pheDestBuf, 0, sizeof(struct hostent)); first = 0; } if (pheHostBuf.h_name != NULL) { free(pheHostBuf.h_name); } if (pheDestBuf.h_name != NULL) { free(pheDestBuf.h_name); } strcpy(szThisHost, ls_getmyhostname()); lserrno = LSE_FILE_SYS; if (strcmp(lsXfer->szHostUser, lsXfer->szDestUser) != 0) { ls_syslog(LOG_ERR, I18N(6050,"%s: %s does not support account mapping using rcp"), /* catgets 6050*/ fname,"RES"); return -1; } if ((hp1 = Gethostbyname_(lsXfer->szHost)) == NULL) { ls_syslog(LOG_ERR, "\ %s gethostbyname() failed for %s", __func__, lsXfer->szHost); return -1; }
void lsb_merr(char *s) { char fname[] = "lsb_merr"; FILE *mail; char *myhostnm; if (lsb_CheckMode) return; if ((myhostnm = ls_getmyhostname()) == NULL) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname"); if (masterme) die(MASTER_FATAL); else die (SLAVE_FATAL); } if (lsbManager == NULL || (getpwnam(lsbManager)) == NULL) { if (lsbManager == NULL) ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8601, "%s: LSF administrator name is NULL"), /* catgets 8601 */ fname); else ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8602, "%s: Bad LSF administrator name <%s>"), /* catgets 8602 */ fname, lsbManager); if (masterme) die (MASTER_FATAL); else die (SLAVE_FATAL); } mail = smail(lsbManager, myhostnm); if (masterme) fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3201, "Subject: mbatchd on %s: %s\n"), /* catgets 3201 */ myhostnm, s); else fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3202, "Subject: sbatchd on %s: %s\n"), /* catgets 3202 */ myhostnm, s); mclose(mail); }
char * ls_gethostmodel (char *hostname) { struct hostInfo *hostinfo; static char hostModel[MAXLSFNAMELEN]; if (hostname == NULL) if ((hostname = ls_getmyhostname ()) == NULL) return (NULL); hostinfo = ls_gethostinfo ("-", NULL, &hostname, 1, 0); if (hostinfo == NULL) return (NULL); strcpy (hostModel, hostinfo[0].hostModel); return hostModel; }
char * ls_gethosttype (char *hostname) { struct hostInfo *hostinfo; static char hostType[MAXLSFNAMELEN]; if (hostname == NULL) if ((hostname = ls_getmyhostname ()) == NULL) return (NULL); hostinfo = ls_gethostinfo ("-", NULL, &hostname, 1, 0); if (hostinfo == NULL) return (NULL); strcpy (hostType, hostinfo[0].hostType); return (hostType); }
float * ls_gethostfactor (char *hostname) { struct hostInfo *hostinfo; static float cpufactor; if (hostname == NULL) if ((hostname = ls_getmyhostname ()) == NULL) return (NULL); hostinfo = ls_gethostinfo ("-", NULL, &hostname, 1, 0); if (hostinfo == NULL) return (NULL); cpufactor = hostinfo->cpuFactor; return (&cpufactor); }
static void initChildRes (char *envdir) { static char fname[] = "initChildRes"; int i, maxfds; getLogClass_ (resParams[LSF_DEBUG_RES].paramValue, resParams[LSF_TIME_RES].paramValue); openChildLog ("res", resParams[LSF_LOGDIR].paramValue, (debug > 1), &(resParams[LSF_LOG_MASK].paramValue)); if ((Myhost = ls_getmyhostname ()) == NULL) { ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "ls_getmyhostname"); resExit_ (-1); } client_cnt = child_cnt = 0; for (i = 0; i < MAXCLIENTS_HIGHWATER_MARK + 1; i++) { clients[i] = NULL; } children = calloc (sysconf (_SC_OPEN_MAX), sizeof (struct children *)); if (!children) { ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "calloc"); resExit_ (-1); } maxfds = sysconf (_SC_OPEN_MAX); for (i = 0; i < maxfds; i++) { children[i] = NULL; } initConn2NIOS (); resNotifyList = listCreate ("resNotifyList"); if (!resNotifyList) { ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "listCreate"); resExit_ (-1); } }
void getJobsState(struct sbdPackage *sbdPackage) { mbdReqType mbdReqtype; char request_buf[MSGSIZE/8]; char *reply_buf; char *myhostnm; XDR xdrs; struct LSFHeader hdr; int reply; int i; int cc; int numJobs; struct jobSpecs jobSpecs; struct jobCard *job = NULL; if ((myhostnm = ls_getmyhostname()) == NULL) { ls_syslog(LOG_ERR, "\ %s: Ohmygosh failed to get my hostname... %M", __func__); die(SLAVE_FATAL); }
int hostValue(void) { static unsigned char value; char *sp; if (value) return value; sp = ls_getmyhostname(); if (sp == NULL) return 50; while (*sp != '\0') { value = value + *sp; sp++; } return (int) value; }
int setLockOnOff_(int on, time_t duration, char *hname) { struct limLock lockReq; char *host = hname; if (initenv_(NULL, NULL) <0) return -1; lockReq.on = on; lockReq.uid = getuid(); if (getLSFUser_(lockReq.lsfUserName, sizeof(lockReq.lsfUserName)) < 0) { return -1; } if (duration == 0) lockReq.time = 77760000; else lockReq.time = duration; if (host == NULL) host = ls_getmyhostname(); if (callLim_(LIM_LOCK_HOST, &lockReq, xdr_limLock, NULL, NULL, host, 0, NULL) < 0) return -1; return 0; }
char * chDisplay_(char *disp) { char *sp; char *hostName; static char dspbuf[MAXHOSTNAMELEN+10]; sp = disp +8; if (strncmp("unix:", sp, 5) == 0) sp += 4; else if (strncmp("localhost:", sp, 10) == 0) sp += 9; if (sp[0] == ':') { if ((hostName = ls_getmyhostname()) == NULL) return(disp); sprintf(dspbuf, "%s=%s%s", "DISPLAY", hostName, sp); return dspbuf; } return disp; }
void merr_user(char *user, char *host, char *msg, char *type) { char fname[] = "merr_user"; FILE *mail; char *myhostnm; if ((myhostnm = ls_getmyhostname()) == NULL) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname"); die(MASTER_FATAL); } mail = smail(user, host); fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3203, "Subject: job %s report from %s\n"), /* catgets 3203 */ type, myhostnm); fprintf(mail, _i18n_msg_get(ls_catd, NL_SETN, 3204, "\n\nDear %s,\n\n%s\n\n"), /* catgets 3204 */ user, msg); mclose(mail); }
int ls_servavail(int servId, int nonblock) { int options = 0; if (nonblock) options |= _NON_BLOCK_; if (initenv_(NULL, NULL) < 0) return -1; if (callLim_(LIM_SERV_AVAIL, &servId, xdr_int, NULL, NULL, ls_getmyhostname(), options, NULL) < 0) return -1; return 0; }
void ls_openlog(const char *ident, const char *path, int use_stderr, char *logMask) { char *msg = NULL; strncpy(logident, ident, 9); logident[9] = '\0'; logmask = getLogMask(&msg, logMask); if (use_stderr) { log_dest = LOGTO_STDERR; return; } if (path && *path) { char *myname; FILE *lfp; struct stat st; if ((myname = ls_getmyhostname()) == NULL) goto syslog; sprintf(logfile, "%s/%s.log.%s", path, ident, myname); if (lstat(logfile, &st) < 0) { if (errno == ENOENT) { if (openLogFile(ident, myname) == 0) { if (msg != NULL) ls_syslog(LOG_ERR, "%s", msg); return; } } else { sprintf(logfile, "%s/%s.log.%s", lsTmpDir_, ident, myname); if (lstat(logfile, &st) < 0) { if (errno == ENOENT) { if ((lfp = fopen(logfile, "a")) != NULL) { fclose(lfp); if (!strcmp(ident, "res") || (logmask >= LOG_UPTO(LOG_DEBUG) && logmask <= LOG_UPTO(LOG_DEBUG3))) chmod(logfile, 0666); else chmod(logfile, 0644); log_dest = LOGTO_FILE; if (msg != NULL) ls_syslog(LOG_ERR, "%s", msg); return; } } } else if (S_ISREG(st.st_mode) && st.st_nlink == 1) { if ((lfp = fopen(logfile, "a")) != NULL) { fclose(lfp); if (!strcmp(ident, "res") || (logmask >= LOG_UPTO(LOG_DEBUG) && logmask <= LOG_UPTO(LOG_DEBUG3))) chmod(logfile, 0666); else chmod(logfile, 0644); log_dest = LOGTO_FILE; if (msg != NULL) ls_syslog(LOG_ERR, "%s", msg); return; } } } } else if (S_ISREG(st.st_mode) && st.st_nlink == 1) { if (openLogFile(ident, myname) == 0) { if (msg != NULL) ls_syslog(LOG_ERR, "%s", msg); return; } } } syslog: log_dest = LOGTO_SYS; logfile[0] = '\0'; openlog((char *) ident, LOG_PID, LOG_DAEMON); setlogmask(logmask); if (msg != NULL) ls_syslog(LOG_ERR, "%s", msg); }
void init_res (void) { static char fname[] = "init_res"; int i, maxfds; if (logclass & (LC_TRACE | LC_HANG)) ls_syslog (LOG_DEBUG, "%s: Entering this routine...", fname); if (!sbdMode) { if (!debug) { if (geteuid () || getuid ()) { fprintf (stderr, "RES should be run as root.\n"); fflush (stderr); resExit_ (1); } chdir ("/tmp"); } if (debug <= 1) { daemonize_ (); ls_openlog ("res", resParams[LSF_LOGDIR].paramValue, 0, resParams[LSF_LOG_MASK].paramValue); umask (0); nice (NICE_LEAST); } } if ((Myhost = ls_getmyhostname ()) == NULL) { ls_syslog (LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname"); resExit_ (-1); } if (isatty (0)) { tcgetattr (0, &defaultTty.attr); defaultTty.ws.ws_row = 24; defaultTty.ws.ws_col = 80; defaultTty.ws.ws_xpixel = defaultTty.ws.ws_ypixel = 0; } else { defaultTty.ws.ws_row = 24; defaultTty.ws.ws_col = 80; defaultTty.ws.ws_xpixel = defaultTty.ws.ws_ypixel = 0; } if (!sbdMode) { init_AcceptSock (); } client_cnt = child_cnt = 0; for (i = 0; i < MAXCLIENTS_HIGHWATER_MARK + 1; i++) { clients[i] = NULL; } children = (struct child **) calloc (sysconf (_SC_OPEN_MAX), sizeof (struct children *)); if (!children) { ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "calloc"); resExit_ (-1); } maxfds = sysconf (_SC_OPEN_MAX); for (i = 0; i < maxfds; i++) { children[i] = NULL; } initConn2NIOS (); resNotifyList = listCreate ("resNotifyList"); if (!resNotifyList) { ls_syslog (LOG_ERR, I18N_FUNC_FAIL_M, fname, "listCreate"); resExit_ (-1); } ls_syslog (LOG_INFO, (_i18n_msg_get (ls_catd, NL_SETN, 5346, "Daemon started"))); /* catgets 5346 */ initResLog (); }
void job_checking (void) { static char fname[] = "job_checking"; struct jobCard *jobCard, *nextJob; struct hostLoad *myload, savedLoad; char *myhostnm; static time_t last_check; char preempted = FALSE; int i; if (last_check == 0) last_check = now; if (jobcnt <= 0) { last_check = now; return; } checkFinish (); for (jobCard = jobQueHead->forw; (jobCard != jobQueHead); jobCard = nextJob) { nextJob = jobCard->forw; if (IS_FINISH(jobCard->jobSpecs.jStatus) || (jobCard->jobSpecs.jStatus & JOB_STAT_PEND)) continue; ruLimits(jobCard); if (IS_RUN_JOB_CMD(jobCard->jobSpecs.jStatus)) { jobCard->runTime += (int) (now - last_check); } if (jobCard->runTime > jobCard->jobSpecs.lsfLimits[LSF_RLIMIT_RUN].rlim_curl) { if ((jobCard->jobSpecs.terminateActCmd == NULL) || (jobCard->jobSpecs.terminateActCmd[0] == '\0')) { if (jobCard->runTime > jobCard->jobSpecs.lsfLimits[LSF_RLIMIT_RUN].rlim_curl + WARN_TIME && jobCard->timeExpire) { if ((IS_SUSP (jobCard->jobSpecs.jStatus)) && (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT) && (jobCard->jobSpecs.subreasons & SUB_REASON_RUNLIMIT)) continue; else if (jobCard->jobSpecs.jStatus & JOB_STAT_KILL) continue; else { ls_syslog(LOG_INFO, \ "%s: warning period expired killing the job=%d", fname, jobCard->jobSpecs.jobId); jobSigStart (jobCard, SIG_TERM_RUNLIMIT, 0, 0, SIGLOG); sbdlog_newstatus(jobCard); jobCard->jobSpecs.jStatus |= JOB_STAT_KILL; } } else if (!jobCard->timeExpire) { ls_syslog(LOG_INFO, I18N(5704, "%s: sending warning signal to job=%d"), /* catgets 5704 */ fname, jobCard->jobSpecs.jobId); jobsig(jobCard, SIGUSR2, FALSE); jobCard->timeExpire = TRUE; } } else { if (jobCard->runTime > jobCard->jobSpecs.lsfLimits[LSF_RLIMIT_RUN].rlim_curl) { if ((IS_SUSP (jobCard->jobSpecs.jStatus)) && (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT) && (jobCard->jobSpecs.subreasons & SUB_REASON_RUNLIMIT)) continue; else { jobSigStart (jobCard, SIG_TERM_RUNLIMIT, 0, 0, SIGLOG); sbdlog_newstatus(jobCard); } } } continue; } if (jobCard->jobSpecs.termTime && now > jobCard->jobSpecs.termTime && !(jobCard->jobSpecs.jAttrib & JOB_FORCE_KILL)) { if ((jobCard->jobSpecs.terminateActCmd == NULL) || (jobCard->jobSpecs.terminateActCmd[0] == '\0')) { if (now > jobCard->jobSpecs.termTime + WARN_TIME && jobCard->timeExpire) { if ((IS_SUSP (jobCard->jobSpecs.jStatus)) && (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT) && (jobCard->jobSpecs.subreasons & SUB_REASON_DEADLINE)) continue; else if (jobCard->jobSpecs.jStatus & JOB_STAT_KILL) continue; else { jobSigStart (jobCard, SIG_TERM_DEADLINE, 0, 0, SIGLOG); sbdlog_newstatus(jobCard); jobCard->jobSpecs.jStatus |= JOB_STAT_KILL; } } else if (!jobCard->timeExpire) { jobsig(jobCard, SIGUSR2, FALSE); jobCard->timeExpire = TRUE; } } else { if (now > jobCard->jobSpecs.termTime) { if ((IS_SUSP (jobCard->jobSpecs.jStatus)) && (jobCard->jobSpecs.reasons & SUSP_RES_LIMIT) && (jobCard->jobSpecs.subreasons & SUB_REASON_DEADLINE)) continue; else { jobSigStart (jobCard, SIG_TERM_DEADLINE, 0, 0, SIGLOG); sbdlog_newstatus(jobCard); } } } continue; } if (! window_ok (jobCard) && !(jobCard->jobSpecs.jAttrib & JOB_URGENT_NOSTOP)) { if (! (jobCard->jobSpecs.options & SUB_WINDOW_SIG) || ((jobCard->jobSpecs.options & SUB_WINDOW_SIG) && now - jobCard->windWarnTime >= WARN_TIME)) { jobSuspendAction(jobCard, SIG_SUSP_WINDOW, SUSP_QUEUE_WINDOW, 0); continue; } } else { jobResumeAction(jobCard, SIG_RESUME_WINDOW, SUSP_QUEUE_WINDOW); continue; } } if ((myhostnm = ls_getmyhostname()) == NULL) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL_MM, fname, "ls_getmyhostname"); die(SLAVE_FATAL); } myload = ls_loadofhosts (NULL, 0, EXACT|EFFECTIVE, 0, &myhostnm, 1); if (myload == NULL) { if (myStatus != NO_LIM) ls_syslog(LOG_INFO, I18N_FUNC_FAIL_MM, fname, "ls_loadofhosts"); if (lserrno == LSE_LIM_BADHOST) relife(); if (lserrno == LSE_BAD_XDR) relife(); if (lserrno == LSE_LIM_DOWN || lserrno == LSE_TIME_OUT) { myStatus |= NO_LIM; tryChkpntMig(); } last_check = now; return; } else myStatus = 0; memcpy ((char *)&savedLoad, (char *)myload, sizeof (struct hostLoad)); savedLoad.li = (float *) my_malloc (allLsInfo->numIndx * sizeof (float), "job_checking"); savedLoad.status = (int *) my_malloc ((1 + GET_INTNUM(allLsInfo->numIndx)) * sizeof (int), "job_checking"); for (i = 0; i < allLsInfo->numIndx; i++) savedLoad.li[i] = myload->li[i]; for (i = 0; i < 1 + GET_INTNUM(allLsInfo->numIndx); i++) savedLoad.status[i] = myload->status[i]; tryResume (&savedLoad); if (!preempted) tryStop (myhostnm, &savedLoad); tryChkpntMig(); FREEUP(savedLoad.li); FREEUP(savedLoad.status); last_check = now; return; }
int limCtrl(int argc, char **argv, int opCode) { char *optName; char *localHost; int vFlag = 0; int config = 0, checkReply; fFlag = 0; if (strcmp(argv[optind-1], "reconfig") == 0) { config = 1; } while ((optName = myGetOpt(argc, argv, "f|v|")) != NULL) { switch (optName[0]) { case 'v': if (opCode == LIM_CMD_SHUTDOWN) return(-2); vFlag = 1; break; case 'f': fFlag = 1; break; default: return(-2); } } exitrc = 0; if (config && optind != argc) return -2; switch (checkReply) { case EXIT_FATAL_ERROR: return -1; case EXIT_WARNING_ERROR: if (fFlag) break; if (!getConfirm(I18N(250, "Do you want to reconfigure? [y/n] "))) /* catgets 250 */ { fprintf(stderr, I18N(251, "Reconfiguration aborted.\n")); /* catgets 251 */ return(-1); } break; default: break; } if (config) { doAllHosts(opCode); return(exitrc); } if (optind == argc) { if ((localHost = ls_getmyhostname()) == NULL) { ls_perror("ls_getmyhostname"); return -1; } operateHost(localHost, opCode, 0); } else { doHosts(argc, argv, opCode); } return(exitrc); }
struct hostInfo * ls_gethostinfo (char *resReq, int *numhosts, char **hostlist, int listsize, int options) { static char fname[] = "ls_gethostinfo"; struct decisionReq hostInfoReq; static struct hostInfoReply hostInfoReply; struct shortLsInfo lsInfo; char *hname; int cc, i; if (logclass & (LC_TRACE)) ls_syslog (LOG_DEBUG1, "%s: Entering this routine...", fname); if ((hname = ls_getmyhostname ()) == NULL) return (NULL); if (listsize) { if (hostlist == NULL) { lserrno = LSE_BAD_ARGS; return NULL; } hostInfoReq.preferredHosts = (char **) calloc (listsize + 1, sizeof (char *)); if (hostInfoReq.preferredHosts == NULL) { lserrno = LSE_MALLOC; return NULL; } for (i = 0; i < listsize; i++) { if (hostlist[i] == NULL) { lserrno = LSE_BAD_ARGS; break; } cc = ls_isclustername (hostlist[i]); if (cc <= 0) { if (cc < 0) break; if (Gethostbyname_ (hostlist[i]) == NULL) { lserrno = LSE_BAD_HOST; break; } hostInfoReq.preferredHosts[i + 1] = putstr_ (hostlist[i]); } else hostInfoReq.preferredHosts[i + 1] = putstr_ (hostlist[i]); if (!hostInfoReq.preferredHosts[i + 1]) { lserrno = LSE_MALLOC; break; } } if (i < listsize) { int j; for (j = 1; j < i + 1; j++) free (hostInfoReq.preferredHosts[j]); free (hostInfoReq.preferredHosts); return (NULL); } hostInfoReq.ofWhat = OF_HOSTS; } else { hostInfoReq.preferredHosts = (char **) calloc (1, sizeof (char *)); if (hostInfoReq.preferredHosts == NULL) { lserrno = LSE_MALLOC; return NULL; } hostInfoReq.ofWhat = OF_ANY; } hostInfoReq.options = options; strcpy (hostInfoReq.hostType, " "); hostInfoReq.preferredHosts[0] = putstr_ (hname); hostInfoReq.numPrefs = listsize + 1; if (resReq != NULL) strcpy (hostInfoReq.resReq, resReq); else strcpy (hostInfoReq.resReq, " "); hostInfoReply.shortLsInfo = &lsInfo; hostInfoReq.numHosts = 0; cc = callLim_ (LIM_GET_HOSTINFO, &hostInfoReq, xdr_decisionReq, &hostInfoReply, xdr_hostInfoReply, NULL, _USE_TCP_, NULL); for (i = 0; i < hostInfoReq.numPrefs; i++) free (hostInfoReq.preferredHosts[i]); free (hostInfoReq.preferredHosts); if (cc < 0) return NULL; if (numhosts != NULL) *numhosts = hostInfoReply.nHost; return (expandSHinfo (&hostInfoReply)); }
int lsb_hostcontrol (char *host, int opCode) { XDR xdrs; char request_buf[MSGSIZE]; char *reply_buf, *contactHost = NULL; static struct controlReq hostControlReq; int cc; struct LSFHeader hdr; struct lsfAuth auth; if (hostControlReq.name == NULL) { hostControlReq.name = (char *) malloc (MAXHOSTNAMELEN); if (hostControlReq.name == NULL) { lsberrno = LSBE_NO_MEM; return(-1); } } if (opCode != HOST_OPEN && opCode != HOST_CLOSE && opCode != HOST_REBOOT && opCode != HOST_SHUTDOWN) { lsberrno = LSBE_BAD_ARG; return (-1); } if (host) if (strlen (host) >= MAXHOSTNAMELEN - 1) { lsberrno = LSBE_BAD_ARG; return (-1); } hostControlReq.opCode = opCode; if (host) strcpy(hostControlReq.name, host); else { char *h; if ((h = ls_getmyhostname()) == NULL) { lsberrno = LSBE_LSLIB; return(-1); } strcpy(hostControlReq.name, h); } switch (opCode) { case HOST_REBOOT: hdr.opCode = CMD_SBD_REBOOT; contactHost = host; break; case HOST_SHUTDOWN: hdr.opCode = CMD_SBD_SHUTDOWN; contactHost = host; break; default: hdr.opCode = BATCH_HOST_CTRL; break; } if (authTicketTokens_(&auth, contactHost) == -1) return (-1); xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE); if (!xdr_encodeMsg(&xdrs, (char*) &hostControlReq, &hdr, xdr_controlReq, 0, &auth)) { lsberrno = LSBE_XDR; return(-1); } if (opCode == HOST_REBOOT || opCode == HOST_SHUTDOWN) { if ((cc = cmdCallSBD_(hostControlReq.name, request_buf, XDR_GETPOS(&xdrs), &reply_buf, &hdr, NULL)) == -1) return (-1); } else { if ((cc = callmbd (NULL, request_buf, XDR_GETPOS(&xdrs), &reply_buf, &hdr, NULL, NULL, NULL)) == -1) return (-1); } lsberrno = hdr.opCode; if (cc) free(reply_buf); if (lsberrno == LSBE_NO_ERROR) return(0); else return(-1); }
struct hostLoad * loadinfo_(char *resReq, struct decisionReq *loadReqPtr, char *fromhost, int *numHosts, char ***outnlist) { static char fname[] = "loadinfo_"; static struct loadReply loadReply; int i; char *hname; int options = 0; if (logclass & (LC_TRACE)) ls_syslog(LOG_DEBUG, "%s: Entering this routine...", fname); if (loadReqPtr->numHosts <=0) { lserrno = LSE_BAD_ARGS; goto error; } if (!fromhost) { if ((hname = ls_getmyhostname()) == NULL) goto error; loadReqPtr->preferredHosts[0] = putstr_(hname); } else loadReqPtr->preferredHosts[0] = putstr_(fromhost); if (loadReqPtr->preferredHosts[0] == NULL) { lserrno = LSE_MALLOC; goto error; } if (resReq) { strncpy(loadReqPtr->resReq, resReq, MAXLINELEN); } else strcpy(loadReqPtr->resReq, " "); loadReqPtr->resReq[MAXLINELEN-1] = '\0'; if (loadReqPtr->ofWhat == OF_HOSTS && loadReqPtr->numPrefs == 2 && loadReqPtr->numHosts == 1 && equalHost_(loadReqPtr->preferredHosts[1], loadReqPtr->preferredHosts[0])) options |= _LOCAL_; else options |= _USE_TCP_; if (callLim_(LIM_LOAD_REQ, loadReqPtr, xdr_decisionReq, &loadReply, xdr_loadReply, NULL, options, NULL) < 0) goto error; if (loadReply.flags & LOAD_REPLY_SHARED_RESOURCE) { sharedResConfigured_ = TRUE; } for (i=0; i<loadReqPtr->numPrefs; i++) FREEUP(loadReqPtr->preferredHosts[i]); FREEUP (loadReqPtr->preferredHosts); *numHosts = loadReply.nEntry; *outnlist = loadReply.indicies; return (loadReply.loadMatrix); error: for (i=0; i<loadReqPtr->numPrefs; i++) FREEUP(loadReqPtr->preferredHosts[i]); FREEUP (loadReqPtr->preferredHosts); return (NULL); }
struct jRusage *getJInfo_(int npgid, int *pgid, int options, int cpgid) { static char fname[] = "lib.pim.c/getJInfo_()"; struct jRusage *jru; static char pfile[MAXFILENAMELEN]; char *myHost; static struct sockaddr_in pimAddr; struct LSFHeader sendHdr, recvHdr, hdrBuf; int s, cc; struct timeval timeOut; static time_t lastTime = 0, lastUpdateNow = 0; time_t now; static time_t pimSleepTime = PIM_SLEEP_TIME; static bool_t periodicUpdateOnly = FALSE; now = time(0); if (logclass & LC_PIM) ls_syslog(LOG_DEBUG3,"now = %ld, lastTime = %ld, sleepTime = %ld", now, lastUpdateNow, pimSleepTime); argOptions = options; if (lastTime == 0) { struct hostent *hp; struct config_param *plp; for (plp = pimParams; plp->paramName != NULL; plp++) { if (plp->paramValue != NULL) { FREEUP (plp->paramValue); } } if (initenv_(pimParams, NULL) < 0) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: initenv_() failed: %M", fname); return NULL; } if ((myHost = ls_getmyhostname()) == NULL) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: ls_getmyhostname() failed: %m", fname); return (NULL); } if (pimParams[LSF_PIM_INFODIR].paramValue) sprintf(pfile, "%s/pim.info.%s", pimParams[LSF_PIM_INFODIR].paramValue, myHost); else { if (pimParams[LSF_LIM_DEBUG].paramValue) { if (pimParams[LSF_LOGDIR].paramValue) sprintf(pfile, "%s/pim.info.%s", pimParams[LSF_LOGDIR].paramValue, myHost); else sprintf(pfile, "/tmp/pim.info.%s.%d", myHost, (int)getuid()); } else { sprintf(pfile, "/tmp/pim.info.%s", myHost); } } if (pimParams[LSF_PIM_SLEEPTIME].paramValue) { if ((pimSleepTime = atoi(pimParams[LSF_PIM_SLEEPTIME].paramValue)) < 0) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "LSF_PIM_SLEEPTIME value <%s> must be a positive integer, defaulting to %d", pimParams[LSF_PIM_SLEEPTIME].paramValue, PIM_SLEEP_TIME); pimSleepTime = PIM_SLEEP_TIME; } } if (pimParams[LSF_PIM_SLEEPTIME_UPDATE].paramValue != NULL && strcasecmp(pimParams[LSF_PIM_SLEEPTIME_UPDATE].paramValue, "y") == 0) { periodicUpdateOnly = TRUE; if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: Only to call pim each PIM_SLEEP_TIME interval", fname); } if ((hp = Gethostbyname_(myHost)) == NULL) { return NULL; } memset((char *) &pimAddr, 0, sizeof(pimAddr)); memcpy((char *) &pimAddr.sin_addr, (char *) hp->h_addr, (int)hp->h_length); pimAddr.sin_family = AF_INET; } if (now - lastUpdateNow >= pimSleepTime || (options & PIM_API_UPDATE_NOW)) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG,"%s: update now", fname); lastUpdateNow = now; if ((s = TcpCreate_(FALSE, 0)) < 0) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: tcpCreate failed: %m", fname); return (NULL); } if (pimPort(&pimAddr, pfile) == -1) { close(s); return (NULL); } if (b_connect_(s, (struct sockaddr *) &pimAddr, sizeof(pimAddr), 0) == -1) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: b_connect() failed: %m", fname); lserrno = LSE_CONN_SYS; close(s); return (NULL); } initLSFHeader_(&sendHdr); initLSFHeader_(&recvHdr); sendHdr.opCode = options; sendHdr.refCode = (short) now & 0xffff; sendHdr.reserved = cpgid; if ((cc = writeEncodeHdr_(s, &sendHdr, b_write_fix)) < 0) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: writeEncodeHdr failed cc=%d: %M", fname, cc); close(s); return (NULL); } timeOut.tv_sec = 10; timeOut.tv_usec = 0; if ((cc = rd_select_(s, &timeOut)) < 0) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: rd_select_ cc=%d: %m", fname, cc); close(s); return (NULL); } if ((cc = lsRecvMsg_(s, (char *) &hdrBuf, sizeof(hdrBuf), &recvHdr, NULL, NULL, b_read_fix)) < 0) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: lsRecvMsg_ failed cc=%d: %M", fname, cc); close(s); return (NULL); } close(s); if (recvHdr.refCode != sendHdr.refCode) { if (logclass & LC_PIM) ls_syslog(LOG_DEBUG, "%s: recv refCode=%d not equal to send refCode=%d, server is not PIM", fname, (int) recvHdr.refCode, (int) sendHdr.refCode); return (NULL); } if (logclass & LC_PIM) ls_syslog(LOG_DEBUG,"%s updated now",fname); if (!readPIMFile(pfile)) { ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "readPIMFile"); return(NULL); } } lastTime = now; if ((jru = readPIMInfo(npgid, pgid)) == NULL && !(options & PIM_API_UPDATE_NOW) && (periodicUpdateOnly == FALSE || (periodicUpdateOnly == TRUE && now - lastUpdateNow >= pimSleepTime))) { if (hitPGid > 0) { jru = getJInfo_(npgid, pgid, options | PIM_API_UPDATE_NOW, hitPGid); hitPGid = 0; return jru; } else { return (getJInfo_(npgid, pgid, options | PIM_API_UPDATE_NOW, cpgid)); } } return jru; }