static int
badminDebug (int nargc, char *nargv[], int opCode)
{
struct hostInfoEnt *hostInfo;
char opt[10];
char **hostPoint;
char *word;
char **hosts = NULL;
int i, c;
int send;
int retCode = 0;
int all = FALSE, numHosts = 0;
struct debugReq debug;
debug.opCode = opCode;
debug.logClass = 0;
debug.level = 0;
debug.hostName = NULL;
debug.logFileName[0] = '\0';
debug.options = 0;
if (opCode == MBD_DEBUG || opCode == SBD_DEBUG)
strcpy (opt, "oc:l:f:");
else if (opCode == MBD_TIMING || opCode == SBD_TIMING)
strcpy (opt, "ol:f:");
else
return (-2);
linux_optind = 1;
linux_opterr = 1;
if (strstr (nargv[0], "badmin"))
{
linux_optind++;
}
while ((c = getopt (nargc, nargv, opt)) != EOF)
{
switch (c)
{
case 'c':
while (optarg != NULL && (word = getNextWord_ (&optarg)))
{
if (strcmp (word, "LC_SCHED") == 0)
debug.logClass |= LC_SCHED;
if (strcmp (word, "LC_EXEC") == 0)
debug.logClass |= LC_EXEC;
if (strcmp (word, "LC_TRACE") == 0)
debug.logClass |= LC_TRACE;
if (strcmp (word, "LC_COMM") == 0)
debug.logClass |= LC_COMM;
if (strcmp (word, "LC_XDR") == 0)
debug.logClass |= LC_XDR;
if (strcmp (word, "LC_CHKPNT") == 0)
debug.logClass |= LC_CHKPNT;
if (strcmp (word, "LC_FILE") == 0)
debug.logClass |= LC_FILE;
if (strcmp (word, "LC_AUTH") == 0)
debug.logClass |= LC_AUTH;
if (strcmp (word, "LC_HANG") == 0)
debug.logClass |= LC_HANG;
if (strcmp (word, "LC_SIGNAL") == 0)
debug.logClass |= LC_SIGNAL;
if (strcmp (word, "LC_PIM") == 0)
debug.logClass |= LC_PIM;
if (strcmp (word, "LC_SYS") == 0)
debug.logClass |= LC_SYS;
if (strcmp (word, "LC_JLIMIT") == 0)
debug.logClass |= LC_JLIMIT;
if (strcmp (word, "LC_PEND") == 0)
debug.logClass |= LC_PEND;
if (strcmp (word, "LC_LOADINDX") == 0)
debug.logClass |= LC_LOADINDX;
if (strcmp (word, "LC_M_LOG") == 0)
{
debug.logClass |= LC_M_LOG;
}
if (strcmp (word, "LC_PERFM") == 0)
{
debug.logClass |= LC_PERFM;
}
if (strcmp (word, "LC_MPI") == 0)
{
debug.logClass |= LC_MPI;
}
if (strcmp (word, "LC_JGRP") == 0)
{
debug.logClass |= LC_JGRP;
}
}
if (debug.logClass == 0)
{
fprintf (stderr, I18N (2572, "Command denied.Invalid class name\n")); /* catgets 2572 */
return (-1);
}
break;
case 'l':
for (i = 0; i < strlen (optarg); i++)
{
if (!isdigit (optarg[i]))
{
fprintf (stderr, I18N (2573, "Command denied. Invalid level value\n")); /* catgets 2573 */
return (-1);
}
}
debug.level = atoi (optarg);
if (opCode == MBD_DEBUG || opCode == SBD_DEBUG)
{
if (debug.level < 0 || debug.level > 3)
{
fprintf (stderr, I18N (2574, "Command denied. Valid debug level is [0-3] \n")); /* catgets 2574 */
return (-1);
}
}
else if (debug.level < 1 || debug.level > 5)
{
fprintf (stderr, I18N (2575, "Command denied. Valid timing level is [1-5]\n")); /* catgets 2575 */
return (-1);
}
break;
case 'f':
if (strstr (optarg, "/") && strstr (optarg, "\\"))
{
fprintf (stderr, I18N (2576, "Command denied. Invalid file name\n")); /* catgets 2576 */
return (-1);
}
memset (debug.logFileName, 0, sizeof (debug.logFileName));
ls_strcat (debug.logFileName, sizeof (debug.logFileName), optarg);
if (debug.logFileName[strlen (debug.logFileName) - 1] == '/' ||
debug.logFileName[strlen (debug.logFileName) - 1] == '\\')
{
fprintf (stderr, I18N (2577, "Command denied. File name is needed after the path\n")); /* catgets 2577 */
return (-1);
}
break;
case 'o':
debug.options = 1;
break;
default:
return (-2);
}
}
if (opCode == SBD_DEBUG || opCode == SBD_TIMING)
{
numHosts = getNames (nargc, nargv, optind, &hosts, &all, "hostC");
hostPoint = NULL;
if (!numHosts && !all)
numHosts = 1;
else if (numHosts)
hostPoint = hosts;
if ((hostInfo = lsb_hostinfo (hostPoint, &numHosts)) == NULL)
{
lsb_perror (NULL);
return (-1);
}
for (i = 0; i < numHosts; i++)
{
if (strcmp (hostInfo[i].host, "lost_and_found") == 0)
{
if (!all)
fprintf (stderr, "%s.\n", _i18n_msg_get (ls_catd, NL_SETN, 2568, "<lost_and_found> is not a real host, ignored")); /* catgets 2568 */
continue;
}
fflush (stderr);
if (hostInfo[i].hStatus & (HOST_STAT_UNAVAIL | HOST_STAT_UNREACH))
{
if (hostInfo[i].hStatus & HOST_STAT_UNAVAIL)
fprintf (stderr, I18N (2578, "failed : LSF daemon (LIM) is unavailable on host %s\n"), /* catgets 2578 */
hostInfo[i].host);
else
fprintf (stderr, I18N (2579, "failed : Slave batch daemon (sbatchd) is unreachable now on host %s\n"), /* catgets 2579 */
hostInfo[i].host);
continue;
}
if ((send = lsb_debugReq (&debug, hostInfo[i].host)) < 0)
{
char msg[100];
sprintf (msg, I18N (2580, "Operation denied by SBD on <%s>"), /* catgets 2580 */
hostInfo[i].host);
lsb_perror (msg);
retCode = -1;
}
}
return (retCode);
}
else
{
numHosts = getNames (nargc, nargv, optind, &hosts, &all, "hostC");
if (numHosts > 0)
{
fprintf (stderr, I18N (2581, "Host name does not need to be specified, set debug to the host which runs MBD\n")); /* catgets 2581 */
}
if ((send = lsb_debugReq (&debug, NULL)) < 0)
{
char msg[100];
sprintf (msg, I18N (2582, "Operation denied by MBD")); /* catgets 2582 */
lsb_perror (msg);
return (-1);
}
}
return (0);
}
int
verifyEAuth_(struct lsfAuth *auth, struct sockaddr_in *from)
{
static char fname[] = "verifyEAuth/lib.eauth.c";
char path[MAXPATHLEN], uData[256], ok;
char *eauth_client, *eauth_server, *eauth_aux_data, *eauth_aux_status;
int cc, i;
static int connected = FALSE;
static int in[2], out[2];
if (logclass & LC_TRACE)
ls_syslog(LOG_DEBUG, "%s ...", fname);
if (!(genParams_[LSF_AUTH].paramValue &&
!strcmp(genParams_[LSF_AUTH].paramValue, AUTH_PARAM_EAUTH)))
return -1;
eauth_client = getenv("LSF_EAUTH_CLIENT");
eauth_server = getenv("LSF_EAUTH_SERVER");
eauth_aux_data = getenv("LSF_EAUTH_AUX_DATA");
eauth_aux_status = getenv("LSF_EAUTH_AUX_STATUS");
sprintf(uData, "%d %d %s %s %d %d %s %s %s %s\n", auth->uid, auth->gid,
auth->lsfUserName, inet_ntoa(from->sin_addr),
(int) ntohs(from->sin_port), auth->k.eauth.len,
(eauth_client ? eauth_client : "NULL"),
(eauth_server ? eauth_server : "NULL"),
(eauth_aux_data ? eauth_aux_data : "NULL"),
(eauth_aux_status ? eauth_aux_status : "NULL"));
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);
if (logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: <%s> path <%s> connected=%d", fname, uData,
path, connected);
if (connected) {
struct timeval tv;
fd_set mask;
FD_ZERO(&mask);
FD_SET(out[0], &mask);
tv.tv_sec = 0;
tv.tv_usec = 0;
if ((cc = select(out[0] + 1, &mask, NULL, NULL, &tv)) > 0) {
if (logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: <%s> got exception",
fname, uData);
connected = FALSE;
close(in[1]);
close(out[0]);
} else {
if (cc < 0)
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "select", uData);
}
if (logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: <%s> select returned cc=%d", fname,
uData, cc);
}
if (!connected) {
int pid;
char *user;
{
if ((user = getLSFAdmin()) == NULL) {
return -1;
}
}
if (pipe(in) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "pipe(in)", uData);
lserrno = LSE_SOCK_SYS;
return -1;
}
if (pipe(out) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "pipe(out)", uData);
lserrno = LSE_SOCK_SYS;
return -1;
}
if ((pid = fork()) == 0) {
char *myargv[3];
struct passwd *pw;
if ((pw = getpwnam(user)) == (struct passwd *)NULL) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "getpwnam", user);
exit(-1);
}
if (setuid(pw->pw_uid) < 0) {
ls_syslog(LOG_ERR, I18N_FUNC_D_FAIL_M, fname, "setuid", (int)pw->pw_uid);
exit(-1);
}
for (i = 1; i < NSIG; i++)
Signal_(i, SIG_DFL);
alarm(0);
close(in[1]);
if (dup2(in[0], 0) == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "dup2(in[0])", uData);
}
close(out[0]);
if (dup2(out[1], 1) == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "dup2(out[1])", uData);
}
for (i = 3; i < sysconf(_SC_OPEN_MAX); i++)
close(i);
myargv[0] = path;
myargv[1] = "-s";
myargv[2] = NULL;
execvp(myargv[0], myargv);
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "execvp", myargv[0]);
exit(-1);
}
close(in[0]);
close(out[1]);
if (pid == -1) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "fork", path);
close(in[1]);
close(out[0]);
lserrno = LSE_FORK;
return -1;
}
connected = TRUE;
}
i = strlen(uData);
if ((cc = b_write_fix(in[1], uData, i)) != i) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5513,
"%s: b_write_fix <%s> failed, cc=%d, i=%d: %m"), /* catgets 5513 */
fname, uData, cc, i);
CLOSEHANDLE(in[1]);
CLOSEHANDLE(out[0]);
connected = FALSE;
return -1;
}
if(logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, _i18n_msg_get(ls_catd , NL_SETN, 5514,
"%s: b_write_fix <%s> ok, cc=%d, i=%d"),
fname, uData, cc, i);
if ((cc = b_write_fix(in[1], auth->k.eauth.data, auth->k.eauth.len))
!= auth->k.eauth.len) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5515,
"%s: b_write_fix <%s> failed, eauth.len=%d, cc=%d"), /* catgets 5515 */
fname, uData, auth->k.eauth.len, cc);
CLOSEHANDLE(in[1]);
CLOSEHANDLE(out[0]);
connected = FALSE;
return -1;
}
if(logclass & (LC_AUTH | LC_TRACE))
ls_syslog(LOG_DEBUG, _i18n_msg_get(ls_catd , NL_SETN, 5516,
"%s: b_write_fix <%s> ok, eauth.len=%d, eauth.data=%.*s cc=%d:"),
fname, uData, auth->k.eauth.len,
auth->k.eauth.len, auth->k.eauth.data,cc);
if ((cc = b_read_fix(out[0], &ok, 1)) != 1) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5517,
"%s: b_read_fix <%s> failed, cc=%d: %m"), /* catgets 5517 */
fname, uData, cc);
CLOSEHANDLE(in[1]);
CLOSEHANDLE(out[0]);
connected = FALSE;
return -1;
}
if (ok != '1') {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5518,
"%s: eauth <%s> len=%d failed, rc=%c"), /* catgets 5518 */
fname, uData, auth->k.eauth.len, ok);
return -1;
}
return 0;
}
void
displayShareResource (int argc, char **argv, int index, int flag, int extflag)
{
int i, j, k, numRes = 0;
struct lsSharedResourceInfo *lsResourceInfo;
struct lsInfo *lsInfo;
char **resources = NULL, **resourceNames = NULL;
int firstFlag = 1;
if ((lsInfo = ls_info ()) == NULL)
{
ls_perror ("lsinfo");
exit (-10);
}
if (argc > index)
{
if ((resourceNames =
(char **) malloc ((argc - index) * sizeof (char *))) == NULL)
{
lserrno = LSE_MALLOC;
ls_perror ("lshosts");
exit (-1);
}
numRes = getResourceNames (argc, argv, index, resourceNames);
}
if (numRes > 0)
resources = resourceNames;
TIMEIT (0,
(lsResourceInfo =
ls_sharedresourceinfo (resources, &numRes, NULL, 0)),
"ls_sharedresourceinfo");
if (lsResourceInfo == NULL)
{
ls_perror ("ls_sharedresourceinfo");
exit (-1);
}
for (k = 0; k < numRes; k++)
{
for (i = 0; i < lsResourceInfo[k].nInstances; i++)
{
for (j = 0; j < lsInfo->nRes; j++)
{
if (!extflag)
if (lsInfo->resTable[j].flags & RESF_EXTERNAL)
continue;
if (strcmp (lsInfo->resTable[j].name,
lsResourceInfo[k].resourceName) == 0)
{
if (flag == TRUE)
{
if (!(lsInfo->resTable[j].flags & RESF_DYNAMIC))
{
if (firstFlag)
{
firstFlag = 0;
prtTableHeader ();
}
prtOneInstance (lsResourceInfo[k].resourceName,
&(lsResourceInfo[k].instances[i]));
}
}
else
{
if (lsInfo->resTable[j].flags & RESF_DYNAMIC)
{
if (firstFlag)
{
firstFlag = 0;
prtTableHeader ();
}
prtOneInstance (lsResourceInfo[k].resourceName,
&(lsResourceInfo[k].instances[i]));
}
}
}
}
}
}
if (firstFlag)
{
if (flag)
printf (_i18n_msg_get (ls_catd, NL_SETN, 753, "No static shared resources defined \n")); /* catgets 753 */
else
printf (_i18n_msg_get (ls_catd, NL_SETN, 754, "No dynamic shared resources defined \n")); /* catgets 754 */
}
FREEUP (resourceNames);
}
void
rfServ_(int acceptSock)
{
static char fname[] = "rfServ_()";
struct LSFHeader msgHdr;
struct LSFHeader buf;
struct sockaddr_in from;
socklen_t fromLen = sizeof(from);
int sock;
XDR xdrs;
sock = accept(acceptSock, (struct sockaddr *)&from, &fromLen);
if (sock < 0) {
ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_");
closesocket(acceptSock);
return;
}
xdrmem_create(&xdrs, (char *) &buf, sizeof(buf), XDR_DECODE);
for (;;) {
XDR_SETPOS(&xdrs, 0);
if (readDecodeHdr_(sock,
(char *)&buf,
SOCK_READ_FIX,
&xdrs,
&msgHdr) < 0) {
ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeHdr_");
closesocket(sock);
xdr_destroy(&xdrs);
return;
}
switch (msgHdr.opCode) {
case RF_OPEN:
ropen(sock, &msgHdr);
break;
case RF_CLOSE:
rclose(sock, &msgHdr);
break;
case RF_WRITE:
rwrite(sock, &msgHdr);
break;
case RF_READ:
rread(sock, &msgHdr);
break;
case RF_STAT:
rstat(sock, &msgHdr);
break;
case RF_GETMNTHOST:
rgetmnthost(sock, &msgHdr);
break;
case RF_FSTAT:
rfstat(sock, &msgHdr);
break;
case RF_LSEEK:
rlseek(sock, &msgHdr);
break;
case RF_UNLINK:
runlink(sock, &msgHdr);
break;
case RF_TERMINATE:
closesocket(sock);
return;
default:
ls_errlog(stderr, _i18n_msg_get(ls_catd, NL_SETN, 602,
"%s: Unknown opcode %d"),
fname, msgHdr.opCode);
xdr_destroy(&xdrs);
break;
}
}
}
char *
my_getopt(int nargc, char **nargv, char *ostr, char **errMsg)
{
char svstr [256];
char *cp1 = svstr;
char *cp2 = svstr;
char *optName;
int i, num_arg;
if ((optName = nargv[optind]) == NULL)
return (NULL);
if (optind >= nargc || *optName != '-')
return (NULL);
if (optName[1] && *++optName == '-') {
++optind;
return(NULL);
}
if (ostr == NULL)
return(NULL);
strcpy (svstr, ostr);
num_arg = 0;
optarg = NULL;
while (*cp2) {
int cp2len = strlen(cp2);
for (i=0; i<cp2len; i++) {
if (cp2[i] == '|') {
num_arg = 0;
cp2[i] = '\0';
break;
}
else if (cp2[i] == ':') {
num_arg = 1;
cp2[i] = '\0';
break;
}
}
if (i >= cp2len)
return (BADCH);
if (!strcmp (optName, cp1)) {
if (num_arg) {
if (nargc <= optind + 1) {
PRINT_ERRMSG (errMsg, (_i18n_msg_get(ls_catd,NL_SETN,650, "%s: option requires an argument -- %s\n")), nargv[0], optName); /* catgets 650 */
return (BADCH);
}
optarg = nargv[++optind];
}
++optind;
return (optName);
} else if (!strncmp(optName, cp1, strlen(cp1))) {
if (num_arg == 0) {
PRINT_ERRMSG (errMsg, (_i18n_msg_get(ls_catd,NL_SETN,651, "%s: option cannot have an argument -- %s\n")), /* catgets 651 */
nargv[0], cp1);
return (BADCH);
}
optarg = optName + strlen(cp1);
++optind;
return (cp1);
}
cp1 = &cp2[i];
cp2 = ++cp1;
}
PRINT_ERRMSG (errMsg, (_i18n_msg_get(ls_catd,NL_SETN,652, "%s: illegal option -- %s\n")), nargv[0], optName); /* catgets 652 */
return (BADCH);
}
void
bmove (int argc, char **argv, int opCode)
{
int position, reqPos;
LS_LONG_INT jobId = 0;
int achar;
if (lsb_init(argv[0]) < 0) {
lsb_perror("lsb_init");
exit(-1);
}
opterr = 0;
while((achar = getopt(argc, argv, "hV")) != EOF) {
switch(achar) {
case 'V':
fputs(_LS_VERSION_, stderr);
exit(0);
case 'h':
default:
usage(argv[0]);
}
}
if (argc == optind) {
fprintf(stderr, "%s.\n",
(_i18n_msg_get(ls_catd,NL_SETN,852, "Job ID must be specified"))); /* catgets 852 */
usage(argv[0]);
}
if (optind < argc-2) {
fprintf(stderr, "%s.\n",
(_i18n_msg_get(ls_catd,NL_SETN,853, "Command syntax error: too many arguments"))); /* catgets 853 */
usage(argv[0]);
}
if (getOneJobId (argv[optind], &jobId, 0)) {
usage(argv[0]);
}
position = 1;
if (optind == argc - 2) {
if (!isint_(argv[++optind]) || atoi(argv[optind]) <= 0) {
fprintf(stderr, "%s: %s.\n", argv[optind],
I18N(854, "Position value must be a positive integer")); /* catgets854*/
usage(argv[0]);
}
position = atoi(argv[optind]);
}
reqPos = position;
if (lsb_movejob(jobId, &position, opCode) <0) {
lsb_perror(lsb_jobid2str (jobId));
exit(-1);
}
if (position != reqPos)
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,855, "Warning: position value <%d> is beyond movable range.\n")), /* catgets 855 */
reqPos);
if (opCode == TO_TOP)
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,856, "Job <%s> has been moved to position %d from top.\n")), /* catgets 856 */
lsb_jobid2str (jobId), position);
else
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,857, "Job <%s> has been moved to position %d from bottom.\n")), /* catgets 857 */
lsb_jobid2str (jobId), position);
exit(0);
}
int
main (int argc, char **argv, char **environ)
{
char *queue = NULL, *host = NULL, *jobName = NULL, *user = NULL;
LS_LONG_INT jobId;
int options;
struct jobInfoEnt *jInfo;
char *outFile;
char fflag = FALSE;
int cc;
int rc;
rc = _i18n_init (I18N_CAT_MIN);
if (lsb_init (argv[0]) < 0)
{
lsb_perror ("lsb_init");
exit (-1);
}
while ((cc = getopt (argc, argv, "Vhfq:m:J:")) != EOF)
{
switch (cc)
{
case 'q':
if (queue || host || jobName)
oneOf (argv[0]);
queue = optarg;
break;
case 'm':
if (queue || host || jobName)
oneOf (argv[0]);
host = optarg;
break;
case 'J':
if (queue || host || jobName)
oneOf (argv[0]);
jobName = optarg;
break;
case 'V':
fputs (_LS_VERSION_, stderr);
exit (0);
case 'f':
fflag = TRUE;
break;
case 'h':
default:
usage (argv[0]);
}
}
jobId = 0;
options = LAST_JOB;
if (argc >= optind + 1)
{
if (queue || host || jobName)
{
oneOf (argv[0]);
}
else if ((argc > 2 && !fflag) || (argc > 3 && fflag))
usage (argv[0]);
if (getOneJobId (argv[optind], &jobId, 0))
{
usage (argv[0]);
}
options = 0;
}
if (lsb_openjobinfo (jobId, jobName, NULL, queue, host, options) < 0
|| (jInfo = lsb_readjobinfo (NULL)) == NULL)
{
if (jobId != 0 || jobName != NULL)
{
user = ALL_USERS;
if (lsb_openjobinfo (jobId, jobName, user, queue, host, options) < 0
|| (jInfo = lsb_readjobinfo (NULL)) == NULL)
{
jobInfoErr (jobId, jobName, NULL, queue, host, options);
exit (-1);
}
}
else
{
jobInfoErr (jobId, jobName, NULL, queue, host, options);
exit (-1);
}
}
lsb_closejobinfo ();
if (jobId && jInfo->jobId != jobId)
{
lsberrno = LSBE_JOB_ARRAY;
lsb_perror ("bpeek");
exit (-1);
}
if ((jInfo->submit.options & SUB_INTERACTIVE) &&
!(jInfo->submit.options & (SUB_OUT_FILE | SUB_ERR_FILE)))
{
fprintf (stderr, _i18n_msg_get (ls_catd, NL_SETN, 2456, "Job <%s> : Cannot bpeek an interactive job.\n"), /* catgets 2456 */
lsb_jobid2str (jInfo->jobId));
exit (-1);
}
if (IS_PEND (jInfo->status) || jInfo->execUsername[0] == '\0')
{
fprintf (stderr, _i18n_msg_get (ls_catd, NL_SETN, 2454, "Job <%s> : Not yet started.\n"), /* catgets 2454 */
lsb_jobid2str (jInfo->jobId));
exit (-1);
}
if (IS_FINISH (jInfo->status))
{
fprintf (stderr, _i18n_msg_get (ls_catd, NL_SETN, 2455, "Job <%s> : Already finished.\n"), /* catgets 2455 */
lsb_jobid2str (jInfo->jobId));
exit (-1);
}
if ((outFile = lsb_peekjob (jInfo->jobId)) == NULL)
{
char msg[50];
sprintf (msg, "%s <%s>", I18N_Job, lsb_jobid2str (jInfo->jobId));
lsb_perror (msg);
exit (-1);
}
displayOutput (outFile, jInfo, fflag, environ);
_i18n_end (ls_catd);
exit (0);
}
void
displayLong(struct jobInfoEnt *job,
struct jobInfoHead *jInfoH,
float cpuFactor)
{
char *hostPtr, *sp;
char hostName[MAXHOSTNAMELEN];
float hostFactor, *getFactor;
static int first = TRUE;
static struct lsInfo *lsInfo;
char prline[MAXLINELEN];
if (first) {
first = FALSE;
TIMEIT(0, (lsInfo = ls_info()), "ls_info");
if (lsInfo == NULL) {
ls_perror("ls_info");
exit(-1);
}
}
prtHeader(job, TRUE, FALSE);
prtJobSubmit(job, FALSE, FALSE);
TIMEIT(1, prtFileNames(job, TRUE), "prtFileNames");
hostPtr = job->submit.hostSpec;
hostFactor = 1.0;
if (job->numExHosts > 0
&& (strcmp (job->exHosts[0], LOST_AND_FOUND) != 0)
&& !IS_PEND (job->status)) {
strcpy (hostName, job->exHosts[0]);
if ((sp = strstr (hostName, "@")) != NULL) {
*sp = '\0';
if (strcmp(hostName, hostPtr) == 0) {
if ((getFactor=getCpuFactor(hostName, TRUE)) == NULL) {
prtLine("\n");
fprintf(stderr,
(_i18n_msg_get(ls_catd,NL_SETN,1451, "Cannot obtain execution host information: %s\n")), ls_errmsg[lserrno]);
exit(-1);
} else {
hostFactor = *getFactor;
hostPtr = job->exHosts[0];
}
}
}
}
TIMEIT(1, prtSubDetails(job, hostPtr, hostFactor), "prtSubDetails");
if (job->numExHosts > 0 && job->reserveTime > 0) {
TIMEIT(1, prtJobReserv(job), "prtJobReserv");
sprintf(prline, ";\n");
prtLine(prline);
}
if (job->predictedStartTime && IS_PEND(job->status)) {
char localTimeStr[60];
strcpy ( localTimeStr, _i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T, &job->predictedStartTime));
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,1466, "%s: Will be started;\n")), /* catgets 1466 */
localTimeStr );
prtLine(prline);
}
if (job->startTime && !IS_PEND(job->status)) {
TIMEIT(1, prtJobStart(job, BJOBS_PRINT, job->jobPid, FALSE), "prtJobStart");
}
if ((cpuFactor > 0.0) && (job->cpuTime > 0))
job->cpuTime = job->cpuTime * hostFactor / cpuFactor;
if (job->jType == JGRP_NODE_ARRAY) {
printf("\n %s:\n",
_i18n_msg_get(ls_catd,NL_SETN,1467, "COUNTERS")); /* catgets 1467 */
printf( (_i18n_msg_get(ls_catd,NL_SETN,1468, " NJOBS PEND DONE RUN EXIT SSUSP USUSP PSUSP\n"))); /* catgets 1468 */
printf(" %5d %4d %3d %4d %4d %5d %5d %5d\n",
job->counter[JGRP_COUNT_NJOBS],
job->counter[JGRP_COUNT_PEND],
job->counter[JGRP_COUNT_NDONE],
job->counter[JGRP_COUNT_NRUN],
job->counter[JGRP_COUNT_NEXIT],
job->counter[JGRP_COUNT_NSSUSP],
job->counter[JGRP_COUNT_NUSUSP],
job->counter[JGRP_COUNT_NPSUSP]);
return;
}
TIMEIT(1, prtJobFinish(job, jInfoH), "prtJobFinish");
if (lsbMode_ & LSB_MODE_BATCH) {
sprintf(prline, "\n %s:\n",
_i18n_msg_get(ls_catd,NL_SETN,1469, "SCHEDULING PARAMETERS")); /* catgets 1469 */
prtLine(prline);
if (printThresholds (job->loadSched, job->loadStop, NULL, NULL,
job->nIdx, lsInfo) < 0)
exit (-1);
}
return;
}
char *
myGetOpt (int nargc, char **nargv, char *ostr)
{
char svstr [256];
char *cp1 = svstr;
char *cp2 = svstr;
char *optName;
int i, num_arg;
if ((optName = nargv[optind]) == NULL)
return (NULL);
if (optind >= nargc || *optName != '-')
return (NULL);
if (optName[1] && *++optName == '-') {
++optind;
return(NULL);
}
if (ostr == NULL)
return(NULL);
strcpy (svstr, ostr);
num_arg = 0;
optarg = NULL;
while (*cp2) {
int cp2len = strlen(cp2);
for (i=0; i<cp2len; i++) {
if (cp2[i] == '|') {
num_arg = 0;
cp2[i] = '\0';
break;
}
else if (cp2[i] == ':') {
num_arg = 1;
cp2[i] = '\0';
break;
}
}
if (i >= cp2len)
return (BADCH);
if (!strcmp (optName, cp1)) {
if (num_arg) {
if (nargc <= optind + 1) {
fprintf (stderr,
_i18n_msg_get(ls_catd, NL_SETN, 108,
"%s: option requires an argument -- %s\n"),/* catgets 108 */
nargv[0], optName);
return (BADCH);
}
optarg = nargv[++optind];
}
++optind;
return (optName);
}
cp1 = &cp2[i];
cp2 = ++cp1;
}
fprintf (stderr, _i18n_msg_get(ls_catd,NL_SETN,109,
"%s: illegal option -- %s\n"), /* catgets 109 */
nargv[0], optName);
return (BADCH);
}
void
prtJobFinish(struct jobInfoEnt *job, struct jobInfoHead *jInfoH)
{
char prline[MSGSIZE];
time_t doneTime;
static struct loadIndexLog *loadIndex = NULL;
char *pendReasons;
if (loadIndex == NULL)
TIMEIT(1, loadIndex = initLoadIndex(), "initLoadIndex");
doneTime = job->endTime;
switch (job->status) {
case JOB_STAT_DONE:
case (JOB_STAT_DONE | JOB_STAT_PDONE):
case (JOB_STAT_DONE | JOB_STAT_PERR):
if ((job->startTime < job->submitTime)
&& (job->endTime < (job->submitTime
+ (time_t) MAX(job->cpuTime, MIN_CPU_TIME)))) {
doneTime = job->submitTime +
(time_t) MAX(job->cpuTime, 0.0001);
} else if (job->startTime >= job->submitTime &&
job->endTime < (job->startTime +
(time_t)MAX(job->cpuTime, 0.0001)) &&
job->numExHosts == 1) {
doneTime = job->startTime + (time_t) MAX(job->cpuTime, 0.0001);
if (job->endTime <= doneTime) {
doneTime = job->endTime;
}
}
case (JOB_STAT_EXIT | JOB_STAT_PDONE):
case (JOB_STAT_EXIT | JOB_STAT_PERR):
case JOB_STAT_EXIT:
if (job->reasons & EXIT_ZOMBIE) {
sprintf(prline, "%s: ",
_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T, &job->endTime));
prtLineWUF(prline);
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,623, "Termination request issued; the job will be killed once the host is ok;"))); /* catgets 623 */
prtLineWUF(prline);
break;
}
sprintf(prline, "%s: ",
_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T, &doneTime));
prtLineWUF(prline);
if (strcmp(get_status(job), "DONE") == 0)
{
sprintf(prline, I18N(624, "Done successfully.")); /* catgets 624 */
}
else {
LS_WAIT_T wStatus;
LS_STATUS(wStatus) = job->exitStatus;
if (job->cpuTime >= MIN_CPU_TIME && job->exitStatus) {
if (WEXITSTATUS(wStatus))
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,626, "Exited with exit code %d.")), /* catgets 626 */
WEXITSTATUS(wStatus));
else
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,627, "Exited by signal %d.")), WTERMSIG(wStatus)); /* catgets 627 */
} else
sprintf(prline, I18N_Exited);
}
prtLineWUF(prline);
if (job->numExHosts > 0) {
if (job->cpuTime < MIN_CPU_TIME)
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,629, " The CPU time used is unknown.\n"))); /* catgets 629 */
else
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,630, " The CPU time used is %1.1f seconds.\n")), /* catgets 630 */
job->cpuTime);
} else {
sprintf(prline, "\n");
}
prtLineWUF(prline);
break;
case JOB_STAT_PSUSP:
case JOB_STAT_PEND:
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,631, " PENDING REASONS:\n"))); /* catgets 631 */
prtLineWUF(prline);
pendReasons = lsb_pendreason(job->numReasons, job->reasonTb,
jInfoH, loadIndex);
prtLineWUF(pendReasons);
break;
case JOB_STAT_SSUSP:
case JOB_STAT_USUSP:
TIMEIT(1, prtJobRusage(job), "prtJobRusage");
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,632, " SUSPENDING REASONS:\n"))); /* catgets 632 */
prtLineWUF(prline);
if (job->reasons) {
sprintf(prline, "%s", lsb_suspreason(job->reasons,
job->subreasons,
loadIndex));
prtLineWUF(prline);
}
break;
case JOB_STAT_RUN:
TIMEIT(1, prtJobRusage(job), "prtJobRusage");
break;
default:
break;
}
}
void
prtJobRusage(struct jobInfoEnt *job)
{
char prline[MAXLINELEN];
int i, j;
int linepos;
if (IS_FINISH(job->status))
return;
if (IS_PEND(job->status)) {
if (job->runRusage.utime || job->runRusage.stime) {
if (uf_format)
printf ("%s: Resource usage collected. The CPU time used is %d seconds.",
_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T, &job->jRusageUpdateTime),
job->runRusage.utime + job->runRusage.stime);
else {
sprintf(prline, "%s: %s.\n",
_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T,
&job->jRusageUpdateTime),
I18N(644, "Resource usage collected")); /* catgets 644 */
prtLine(prline);
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,645, " The CPU time used is %d seconds.\n")), /* catgets 645 */
job->runRusage.utime + job->runRusage.stime);
prtLine(prline);
}
}
return;
};
if (job->runRusage.utime > 0 || job->runRusage.stime > 0
|| job->runRusage.mem > 0 || job->runRusage.swap > 0
|| job->runRusage.npgids > 0 || job->runRusage.npids > 0) {
if (uf_format)
printf ("%s: Resource usage collected.",
_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T, &job->jRusageUpdateTime));
else {
sprintf(prline, "%s: %s.\n",
_i18n_ctime(ls_catd, CTIME_FORMAT_a_b_d_T,
&job->jRusageUpdateTime),
I18N(646, "Resource usage collected")); /* catgets 646 */
prtLine(prline);
}
} else
return;
if (job->runRusage.utime > 0 || job->runRusage.stime > 0) {
if (uf_format)
printf (" The CPU time used is %d seconds.",
job->runRusage.utime + job->runRusage.stime);
else {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,647, " The CPU time used is %d seconds.\n")), /* catgets 647 */
job->runRusage.utime + job->runRusage.stime);
prtLine(prline);
}
}
if (job->runRusage.mem > 0) {
if (uf_format) {
if (job->runRusage.mem > 1024)
printf(" MEM: %d Mbytes;", job->runRusage.mem/1024);
else
printf(" MEM: %d Kbytes;", job->runRusage.mem);
}
else {
if (job->runRusage.mem > 1024)
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,648, " MEM: %d Mbytes")), job->runRusage.mem/1024); /* catgets 648 */
else
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,649, " MEM: %d Kbytes")), job->runRusage.mem); /* catgets 649 */
prtLine(prline);
}
}
if (job->runRusage.swap > 0) {
char *space;
if (job->runRusage.mem > 0)
space = "; ";
else
space = " ";
if (uf_format) {
if (job->runRusage.swap > 1024)
printf(" SWAP: %d Mbytes;", job->runRusage.swap/1024);
else
printf(" SWAP: %d Kbytes;", job->runRusage.swap);
}
else {
if (job->runRusage.swap > 1024)
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,650, "%sSWAP: %d Mbytes\n")), space, /* catgets 650 */
job->runRusage.swap/1024);
else
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,651, "%sSWAP: %d Kbytes\n")), space, job->runRusage.swap); /* catgets 651 */
prtLine(prline);
}
} else {
if (job->runRusage.mem > 0 && !uf_format) {
sprintf(prline, "\n");
prtLine(prline);
}
}
if (job->runRusage.npgids <= 0)
return;
for (i=0; i < job->runRusage.npgids; i++) {
if (uf_format)
printf (" PGID: %d; ", job->runRusage.pgid[i]);
else {
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,652, " PGID: %d; ")), job->runRusage.pgid[i]); /* catgets 652 */
linepos = strlen(prline);
prtLine(prline);
}
sprintf(prline, (_i18n_msg_get(ls_catd,NL_SETN,653, "PIDs: "))); /* catgets 653 */
linepos += 6;
prtLineWUF(prline);
for (j=0; j < job->runRusage.npids; j++) {
if (job->runRusage.pgid[i] == job->runRusage.pidInfo[j].pgid) {
sprintf(prline, "%d ", job->runRusage.pidInfo[j].pid);
if (uf_format)
printf ("%d%s", job->runRusage.pidInfo[j].pid, j==job->runRusage.npids-1?"":" ");
else {
linepos += strlen(prline);
if (linepos >= 80) {
char *newline ="\n ";
prtLine(newline);
prtLine(prline);
linepos = strlen(prline) + 21;
}
else
prtLine(prline);
}
}
}
if (uf_format)
printf(";");
else {
sprintf(prline, "\n");
prtLine(prline);
}
}
sprintf(prline, "\n");
prtLineWUF(prline);
if (uf_format && job->runRusage.mem > 0) {
printf ("\n MEMORY USAGE:\n");
printf (" MAX MEM: N/A MBytes; AVG MEM: N/A MBytes\n");
}
}
void
die(int sig)
{
static char fname[] = "die";
char myhost[MAXHOSTNAMELEN];
if (debug > 1)
fprintf(stderr, "%s: signal %d\n",
fname,
sig);
if (masterme) {
releaseElogLock();
}
if (gethostname(myhost, MAXHOSTNAMELEN) <0) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname, "gethostname", myhost);
strcpy(myhost, "localhost");
}
if (sig > 0 && sig < 100) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8216,
"Daemon on host <%s> received signal <%d>; exiting"), /* catgets 8216 */
myhost, sig);
} else {
switch (sig) {
case MASTER_RESIGN:
ls_syslog(LOG_INFO, (_i18n_msg_get(ls_catd , NL_SETN, 8272, "Master daemon on host <%s> resigned; exiting")), myhost); /* catgets 8272 */
break;
case MASTER_RECONFIG:
ls_syslog(LOG_INFO, (_i18n_msg_get(ls_catd , NL_SETN, 8273, "Master daemon on host <%s> exiting for reconfiguration")), myhost); /* catgets 8273 */
break;
case SLAVE_MEM:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8217,
"Slave daemon on host <%s> failed in memory allocation; fatal error - exiting"), myhost); /* catgets 8217 */
lsb_merr1(_i18n_msg_get(ls_catd , NL_SETN, 8217,
"Slave daemon on host <%s> failed in memory allocation; fatal error - exiting"), myhost);
break;
case MASTER_MEM:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8218,
"Master daemon on host <%s> failed in memory allocation; fatal error - exiting"), myhost); /* catgets 8218 */
break;
case SLAVE_FATAL:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8219,
"Slave daemon on host <%s> dying; fatal error - see above messages for reason"), myhost); /* catgets 8219 */
break;
case MASTER_FATAL:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8220,
"Master daemon on host <%s> dying; fatal error - see above messages for reason"), myhost); /* catgets 8220 */
break;
case MASTER_CONF:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8221,
"Master daemon on host <%s> died of bad configuration file"), myhost); /* catgets 8221 */
break;
case SLAVE_RESTART:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8222,
"Slave daemon on host <%s> restarting"), myhost); /* catgets 8222 */
break;
case SLAVE_SHUTDOWN:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8223,
"Slave daemon on host <%s> shutdown"), myhost); /* catgets 8223 */
break;
default:
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8224,
"Daemon on host <%s> exiting; cause code <%d> unknown"), myhost, sig); /* catgets 8224 */
break;
}
}
shutdown(chanSock_(batchSock), 2);
exit(sig);
}
int
get_ports(void)
{
static char fname[] = "get_ports";
struct servent *sv;
if (daemonParams[LSB_MBD_PORT].paramValue != NULL)
{
if (!isint_(daemonParams[LSB_MBD_PORT].paramValue)
|| (mbd_port = atoi(daemonParams[LSB_MBD_PORT].paramValue)) <= 0)
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8226,
"%s: LSB_MBD_PORT <%s> in lsf.conf must be a positive number"), /* catgets 8226 */
fname,
daemonParams[LSB_MBD_PORT].paramValue);
else
mbd_port = htons(mbd_port);
}
else if (debug)
mbd_port = htons(BATCH_MASTER_PORT);
else
{
sv = getservbyname(MBATCHD_SERV, "tcp");
if (!sv) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8227,
"%s: %s service not registered"),
fname,
MBATCHD_SERV);
lsb_merr(_i18n_printf(_i18n_msg_get(ls_catd , NL_SETN, 3208,
"%s: %s service not registered"),
fname,
MBATCHD_SERV));
return -1;
}
mbd_port = sv->s_port;
}
if (daemonParams[LSB_SBD_PORT].paramValue != NULL)
{
if (!isint_(daemonParams[LSB_SBD_PORT].paramValue)
|| (sbd_port = atoi(daemonParams[LSB_SBD_PORT].paramValue)) <= 0)
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8229,
"%s: LSB_SBD_PORT <%s> in lsf.conf must be a positive number"), /* catgets 8229 */
fname,
daemonParams[LSB_SBD_PORT].paramValue);
else
sbd_port = htons(sbd_port);
}
else if (debug)
sbd_port = htons(BATCH_SLAVE_PORT);
else
{
sv = getservbyname(SBATCHD_SERV, "tcp");
if (!sv) {
lsb_merr(_i18n_printf(_i18n_msg_get(ls_catd , NL_SETN, 3208,
"%s: %s service not registered"),
fname,
SBATCHD_SERV));
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 8231,
"%s: %s service not registered"), /* catgets 8231 */
fname,
SBATCHD_SERV);
return -1;
}
sbd_port = sv->s_port;
}
return 0;
}
int
main (int argc, char **argv)
{
int cc, myIndex;
const char prompt[] = "badmin> ";
static char line[MAXLINELEN];
int rc;
rc = _i18n_init (I18N_CAT_MIN);
if (lsb_init (argv[0]) < 0)
{
lsb_perror ("lsb_init");
_i18n_end (ls_catd);
exit (-1);
}
while ((cc = getopt (argc, argv, "Vh")) != EOF)
{
switch (cc)
{
case 'V':
fputs (_LS_VERSION_, stderr);
exit (0);
case 'h':
default:
cmdsUsage ("badmin", cmdList,
_i18n_msgArray_get (ls_catd, NL_SETN, cmdInfo_ID,
cmdInfo));
}
}
if (argc > optind)
{
int rc;
if ((myIndex = adminCmdIndex (argv[optind], cmdList)) == -1)
{
fprintf (stderr, (_i18n_msg_get (ls_catd, NL_SETN, 2552, "Invalid command <%s> \n")), argv[optind]); /* catgets 2552 */
cmdsUsage ("badmin", cmdList,
_i18n_msgArray_get (ls_catd, NL_SETN, cmdInfo_ID,
cmdInfo));
}
optind++;
rc = doBatchCmd (argc, argv);
_i18n_end (ls_catd);
exit (rc);
}
for (;;)
{
printf ("%s", prompt);
fflush (stdout);
if (fgets (line, MAXLINELEN, stdin) == NULL)
{
printf ("\n");
_i18n_end (ls_catd);
exit (-1);
}
parseAndDo (line, doBatchCmd);
}
return (0);
}
int
main(int argc, char **argv)
{
static char fname[] = "lsload:main";
int i,j, num, numneeded;
char *resreq = NULL;
struct hostLoad *hosts;
char *hostnames[MAXLISTSIZE];
char statusbuf[20];
int options = 0;
static char **loadval;
char *indexfilter = NULL;
char **nlp;
static char *defaultindex[] = {"r15s", "r1m", "r15m", "ut", "pg", "ls",
"it", "tmp", "swp", "mem", NULL};
int achar;
char longFormat = FALSE;
char wideFormat = FALSE;
char badHost = FALSE, sOption = FALSE, otherOption = FALSE;
int extView = FALSE;
char **shareNames, **shareValues, **formats;
int isClus, retVal = 0;
int rc;
num = 0;
numneeded = 0;
opterr = 0;
rc = _i18n_init ( I18N_CAT_MIN );
if (ls_initdebug(argv[0]) < 0) {
ls_perror("ls_initdebug");
exit(-1);
}
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG, "%s: Entering this routine...", fname);
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-h") == 0) {
usage(argv[0]);
exit (0);
} else if (strcmp(argv[i], "-V") == 0) {
fputs(_LS_VERSION_, stderr);
exit(0);
} else if (strcmp(argv[i], "-s") == 0) {
if (otherOption == TRUE) {
usage(argv[0]);
exit(-1);
}
sOption = TRUE;
optind = i + 1;
} else if (strcmp(argv[i], "-e") == 0) {
if (otherOption == TRUE || sOption == FALSE) {
usage(argv[0]);
exit(-1);
}
extView = TRUE;
optind = i + 1;
} else if (strcmp(argv[i], "-R") == 0 || strcmp(argv[i], "-l") == 0
|| strcmp(argv[i], "-I") == 0 || strcmp(argv[i], "-N") == 0
|| strcmp(argv[i], "-E") == 0 || strcmp(argv[i], "-n") == 0
|| strcmp(argv[i], "-w") == 0 ) {
otherOption = TRUE;
if (sOption == TRUE) {
usage(argv[0]);
exit(-1);
}
}
}
if (sOption == TRUE) {
displayShareResource(argc, argv, optind, FALSE, extView);
return(0);
}
while ((achar = getopt(argc, argv, "R:I:NEln:w")) != EOF)
{
switch (achar)
{
case 'R':
resreq = optarg;
break;
case 'I':
indexfilter = optarg;
break;
case 'N':
if (options & EFFECTIVE)
usage(argv[0]);
options = NORMALIZE;
break;
case 'E':
if (options & NORMALIZE)
usage(argv[0]);
options = EFFECTIVE;
break;
case 'n':
numneeded = atoi(optarg);
if (numneeded <= 0)
usage(argv[0]);
break;
case 'l':
longFormat = TRUE;
if (wideFormat == TRUE)
usage(argv[0]);
break;
case 'w':
wideFormat = TRUE;
if (longFormat == TRUE)
usage(argv[0]);
break;
case 'V':
fputs(_LS_VERSION_, stderr);
exit(0);
case 'h':
default:
usage(argv[0]);
}
}
for ( ; optind < argc ; optind++)
{
if (num>=MAXLISTSIZE) {
fprintf(stderr, _i18n_msg_get(ls_catd,NL_SETN,1951, "too many hosts specified (maximum %d)\n"), /* catgets 1951 */
MAXLISTSIZE);
exit(-1);
}
if ( (isClus = ls_isclustername(argv[optind])) < 0 ) {
fprintf(stderr, "lsload: %s\n", ls_sysmsg());
badHost = TRUE;
continue;
} else if ( (isClus == 0) &&
(!Gethostbyname_(argv[optind])) ) {
fprintf(stderr, "\
%s: invalid hostname %s\n", __func__, argv[optind]);
badHost = TRUE;
continue;
}
hostnames[num] = argv[optind];
num++;
}
int
checkConf(int verbose, int who)
{
char confCheckBuf[] = "RECONFIG_CHECK=TRUE";
pid_t pid;
char *daemon, *lsfEnvDir;
static struct config_param lsfParams[] =
{
{"LSF_SERVERDIR", NULL},
{"LSF_CONFDIR", NULL},
{"LSB_CONFDIR", NULL},
{"LSB_SHAREDIR", NULL},
{NULL, NULL},
};
struct config_param *plp;
LS_WAIT_T status;
int fatalErr = FALSE, cc = 0;
int fd;
if (lsfParams[0].paramValue == NULL) {
lsfEnvDir = getenv("LSF_ENVDIR");
cc = initenv_(lsfParams, lsfEnvDir);
}
if (cc < 0) {
if (lserrno == LSE_CONF_SYNTAX) {
char lno[20];
sprintf (lno, _i18n_msg_get(ls_catd, NL_SETN, 110,
"Line %d"), errLineNum_); /* catgets 110 */
ls_perror(lno);
} else
ls_perror("initenv_");
}
plp = lsfParams;
for (; plp->paramName != NULL; plp++)
if (plp->paramValue == NULL) {
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 111,
"%s is missing or has a syntax error in lsf.conf file\n"),/* catgets 111 */
plp->paramName);
fatalErr = TRUE;
}
if (fatalErr)
return (EXIT_FATAL_ERROR);
if (cc < 0)
return (EXIT_WARNING_ERROR);
if ((daemon = calloc(strlen(lsfParams[0].paramValue)+15,
sizeof(char))) == NULL) {
perror("calloc");
return (EXIT_FATAL_ERROR);
}
strcpy(daemon, lsfParams[0].paramValue);
strcat(daemon, ((who == 1) ? "/lim" : "/mbatchd"));
if (access(daemon, X_OK) < 0) {
perror(daemon);
free(daemon);
return (EXIT_FATAL_ERROR);
}
if (putenv(confCheckBuf)) {
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 112,
"Failed to set environment variable RECONFIG_CHECK\n")); /* catgets 112 */
free(daemon);
return(EXIT_FATAL_ERROR);
}
if ((pid = fork()) < 0) {
perror("fork");
free(daemon);
return (EXIT_FATAL_ERROR);
}
if (pid == 0) {
if (!verbose) {
fd = open(LSDEVNULL, O_RDWR);
dup2(fd, 1);
dup2(fd, 2);
}
if (changeUserEUId() < 0) {
exit(EXIT_FATAL_ERROR);
}
execlp(daemon, daemon, "-C", (char *)0);
perror("execlp");
exit(EXIT_RUN_ERROR);
}
free(daemon);
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,115, "\nChecking configuration files ...\n"))); /* catgets 115 */
if (waitpid(pid, &status, 0) < 0) {
perror("waitpid");
return(EXIT_FATAL_ERROR);
}
if (WIFEXITED(status) != 0 && WEXITSTATUS(status) != 0xf8)
if (verbose)
fprintf(stderr, "---------------------------------------------------------\n");
if (WIFEXITED(status) == 0) {
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 116,
"Child process killed by signal.\n\n")); /* catgets 116 */
return(EXIT_FATAL_ERROR);
}
switch (WEXITSTATUS(status)) {
case 0 :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 117,
"No errors found.\n\n")); /* catgets 117 */
return(EXIT_NO_ERROR);
case 0xff :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 118,
"There are fatal errors.\n\n")); /* catgets 118 */
return(EXIT_FATAL_ERROR);
case 0xf8 :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 119,
"Fail to run checking program \n\n")); /* catgets 119 */
return(EXIT_FATAL_ERROR);
case 0xfe :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 120,
"No fatal errors found.\n\n"));/* catgets 120 */
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 121, "Warning: Some configuration parameters may be incorrect.\n")); /* catgets 121 */
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 122,
" They are either ignored or replaced by default values.\n\n")); /* catgets 122 */
return(EXIT_WARNING_ERROR);
default :
fprintf(stderr,
_i18n_msg_get(ls_catd, NL_SETN, 123,
"Errors found.\n\n")); /* catgets 123 */
return(EXIT_FATAL_ERROR);
}
}
static int
do_options (int argc, char **argv, LS_LONG_INT **jobIds, int signalValue)
{
int cc;
int kflg=0;
int sflg=0;
int sigflg=0;
int forceflg=0;
int newOptions = 0;
sigJobId = 0;
sigUser = NULL;
sigQueue = NULL;
sigHost = NULL;
sigJobName = NULL;
chkOptions = 0;
sigValue = signalValue;
while ((cc = getopt(argc, argv, "VhkSlq:u:m:p:rfs:J:n:ad")) != EOF) {
switch (cc) {
case 'u':
if (sigUser)
usage(argv[0], signalValue);
if (strcmp(optarg, "all") == 0)
sigUser = ALL_USERS;
else
sigUser = optarg;
break;
case 'q':
sigQueue = optarg;
break;
case 'm':
sigHost = optarg;
break;
case 'l':
if (signalValue != SIGKILL) {
fprintf (stderr, "%s: %s %s\n",
argv[0],
_i18n_msg_get(ls_catd,NL_SETN,459, "Illegal option --"), /* catgets 459 */
"l");
usage (argv[0], signalValue);
}
puts (getSigSymbolList());
exit (-1);
case 's':
if (signalValue != SIGKILL) {
fprintf (stderr, "%s: %s %s\n",
argv[0],
_i18n_msg_get(ls_catd,NL_SETN,459, "Illegal option --"),
"s");
usage (argv[0], signalValue);
}
if (forceflg) {
usage (argv[0], signalValue);
exit(-1);
} else {
if ((sigValue = getSigVal(optarg)) < 0) {
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,461,
"%s: Illegal signal value\n")), optarg); /* catgets 461 */
exit (-1);
}
sigflg = TRUE;
}
break;
case 'a':
if (signalValue != SIGDEL && signalValue != SIGSTOP) {
fprintf (stderr, "%s: %s %s\n",
argv[0],
_i18n_msg_get(ls_catd,NL_SETN,459, "Illegal option --"),
"a");
usage (argv[0], signalValue);
}
newOptions |= ALL_JOB;
break;
case 'd':
if (signalValue != SIGDEL && signalValue != SIGSTOP) {
fprintf (stderr, "%s: %s %s\n",
argv[0],
_i18n_msg_get(ls_catd,NL_SETN,459, "Illegal option --"),
"d");
usage (argv[0], signalValue);
}
newOptions |= DONE_JOB;
break;
case 'n':
if (signalValue != SIGDEL) {
fprintf (stderr, "%s: %s %s\n",
argv[0],
_i18n_msg_get(ls_catd,NL_SETN,459, "Illegal option --"),
"n");
usage (argv[0], signalValue);
}
if (isint_(optarg) && ((runCount = atoi(optarg)) >= 0))
break;
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,465, "%s: Illegal times value\n")), optarg); /* catgets 465 */
exit(-1);
case 'J':
if ( supportJobNamePattern(optarg) != 0) {
fprintf(stderr, (_i18n_msg_get(ls_catd, NL_SETN, 491, "%s: Job or Job Group name is not valid.\n")), optarg); /* catgets 491*/
exit (-1);
}
sigJobName = optarg;
break;
case 'f':
if (signalValue == SIGCHK) {
chkOptions |= LSB_CHKPNT_FORCE;
} else {
usage(argv[0], signalValue);
exit(-1);
}
break;
case 'r':
if ( (signalValue == SIGKILL) && (!sigflg) ) {
sigValue = SIGFORCE;
newOptions |= ZOMBIE_JOB;
forceflg=TRUE;
} else {
usage(argv[0], signalValue);
exit(-1);
}
break;
case 'p':
if (signalValue != SIGCHK) {
usage(argv[0], signalValue);
exit(-1);
}
if (isint_(optarg) && ((chkPeriod = atoi(optarg) * 60) >= 0))
break;
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,466, "%s: Illegal checkpoint period value\n")), optarg); /* catgets 466 */
exit(-1);
case 'k':
if (sflg) {
usage(argv[0], signalValue);
exit(-1);
} else {
kflg++;
if (signalValue != SIGCHK) {
usage(argv[0], signalValue);
exit(-1);
}
chkOptions |= LSB_CHKPNT_KILL;
}
break;
case 'S':
if (kflg) {
usage(argv[0], signalValue);
exit(-1);
} else {
sflg++;
if (signalValue != SIGCHK) {
usage(argv[0], signalValue);
exit(-1);
}
chkOptions |= LSB_CHKPNT_STOP;
}
break;
case 'V':
fputs(_LS_VERSION_, stderr);
exit(0);
case 'h':
default:
usage(argv[0], signalValue);
}
}
if ((argc == optind) &&
(sigUser == NULL) &&
(sigQueue == NULL) &&
(sigHost == NULL) &&
(sigJobName == NULL) ) {
fprintf(stderr, "%s.\n",
(_i18n_msg_get(ls_catd,NL_SETN,467, "Job ID or one of '-m', '-u' '-q' and '-J' must be specified"))); /* catgets 467 */
usage(argv[0], signalValue);
}
return (getJobIds (argc, argv, sigJobName, sigUser, sigQueue, sigHost,
jobIds, newOptions));
}
void
parseAndDo (char *cmdBuf, int (*func)() )
{
#define MAX_ARG 100
extern int optind;
int argc, i ;
char *argv[MAX_ARG];
int see_string = 0;
for (i=0; i<MAX_ARG; i++) {
while(isspace(*cmdBuf) && !see_string)
cmdBuf++;
if (*cmdBuf == '"')
{ cmdBuf++;
see_string = 1;
}
if (*cmdBuf == '\0')
break;
argv[i] = cmdBuf;
while(*cmdBuf !='\0' && !isspace(*cmdBuf) && *cmdBuf != '"')
{
cmdBuf++;
}
while ( see_string && *cmdBuf != '"')
{
cmdBuf++;
if (*cmdBuf == '\0')
{
see_string = 0;
ls_perror (_i18n_msg_get(ls_catd, NL_SETN, 100,
"Syntax Error of line parameter! \n")); /* catgets 100 */
exit(-1);
}
}
if (see_string)
see_string = 0;
if (*cmdBuf != '\0') {
*cmdBuf = '\0';
cmdBuf++;
}
}
if (i == 0)
return;
argv[i] = NULL;
argc = i;
optind = 1;
(void) (*func) (argc, argv);
}
static void
oneOf (char *cmd)
{
fprintf (stderr, "%s.\n", _i18n_msg_get (ls_catd, NL_SETN, 2453, "Command syntax error: more than one of -m , -q, -J or jobId are specified")); /* catgets 2453 */
usage (cmd);
}
int
main(int argc, char** argv)
{
char* hosts = NULL;
struct runJobRequest runJobRequest;
int cc;
int c;
bool_t fFlag = FALSE;
bool_t bFlag = FALSE;
int rc;
rc = _i18n_init ( I18N_CAT_MIN );
if (lsb_init(argv[0]) < 0) {
lsb_perror("lsb_init");
exit (-1);
}
while((c = getopt(argc, argv, "m:fbhV")) != EOF) {
switch(c) {
case 'm':
hosts = putstr_(optarg);
if (hosts == NULL) {
perror("putstr_");
exit(-1);
}
break;
case 'f':
fFlag = TRUE;
break;
case 'b':
bFlag = TRUE;
break;
case 'V':
fputs(_LS_VERSION_, stderr);
return (0);
case 'h':
usage(argv[0]);
exit(-1);
}
}
if (argc <= optind) {
usage(argv[0]);
exit(-1);
}
memset((struct runJobRequest* )&runJobRequest, 0,
sizeof(struct runJobRequest));
if (getOneJobId (argv[argc - 1], &(runJobRequest.jobId), 0)) {
usage(argv[0]);
exit(-1);
}
runJobRequest.numHosts = countHosts(hosts);
if (runJobRequest.numHosts > 1) {
int i;
runJobRequest.hostname = (char **)calloc(runJobRequest.numHosts,
sizeof(char *));
if (runJobRequest.hostname == NULL) {
perror("calloc");
exit(-1);
}
for (i = 0; i < runJobRequest.numHosts; i++) {
while (isspace(*hosts)) hosts++;
runJobRequest.hostname[i] = hosts;
hosts += strlen(hosts) + 1;
}
} else
runJobRequest.hostname = &hosts;
runJobRequest.options = (fFlag == TRUE) ?
RUNJOB_OPT_NOSTOP : RUNJOB_OPT_NORMAL;
if (bFlag) {
runJobRequest.options |= RUNJOB_OPT_FROM_BEGIN;
}
cc = lsb_runjob(&runJobRequest);
if (cc < 0) {
lsb_perror((_i18n_msg_get(ls_catd,NL_SETN,2755, "Failed to run the job"))); /* catgets 2755 */
exit(-1);
}
printf((_i18n_msg_get(ls_catd,NL_SETN,2756, "Job <%s> is being forced to run.\n")), /* catgets 2756 */
lsb_jobid2str(runJobRequest.jobId));
_i18n_end ( ls_catd );
return (0);
}
void
prtResourceLimit (int *rLimits, char *hostSpec, float hostFactor, int *procLimits)
{
int limit, i;
limit = FALSE;
if (rLimits[LSF_RLIMIT_CPU] >= 0) {
if (!limit)
printf("\n");
printf(" %-24s",
(_i18n_msg_get(ls_catd,NL_SETN,1402, "CPULIMIT"))); /* catgets 1402 */
limit = TRUE;
}
if (rLimits[LSF_RLIMIT_RUN] >= 0) {
if (!limit)
printf("\n");
printf(" %-24s",
(_i18n_msg_get(ls_catd,NL_SETN,1403, "RUNLIMIT"))); /* catgets 1403 */
limit = TRUE;
}
if (procLimits != NULL) {
if (procLimits[2] > 0 && procLimits[2] != INFINIT_INT) {
if (!limit)
printf("\n");
printf(" %-24s",
(_i18n_msg_get(ls_catd,NL_SETN,1404, "PROCLIMIT"))); /* catgets 1404 */
limit = TRUE;
}
}
if (limit)
printf ("\n");
if (rLimits[LSF_RLIMIT_CPU] >= 0)
prtLimit (rLimits[LSF_RLIMIT_CPU], hostSpec, hostFactor);
if (rLimits[LSF_RLIMIT_RUN] >= 0) {
prtLimit (rLimits[LSF_RLIMIT_RUN], hostSpec, hostFactor);
}
if (procLimits != NULL) {
if (procLimits[0] == 1 && procLimits[1] == 1 && procLimits[2] != INFINIT_INT) {
printf (" %-d", procLimits[2]);
} else {
for (i=0; i<3; i++) {
if ((procLimits[i] >0) && (procLimits[i] != INFINIT_INT))
printf (" %-d", procLimits[i]);
}
}
}
if (limit)
printf ("\n");
limit = FALSE;
if (rLimits[LSF_RLIMIT_FSIZE] > 0) {
if (!limit)
printf("\n");
printf(" %s",
(_i18n_msg_get(ls_catd,NL_SETN,1405, "FILELIMIT"))); /* catgets 1405 */
limit = TRUE;
}
if (rLimits[LSF_RLIMIT_DATA] > 0) {
if (!limit)
printf("\n");
printf(" %s",
(_i18n_msg_get(ls_catd,NL_SETN,1406, "DATALIMIT"))); /* catgets 1406 */
limit = TRUE;
}
if (rLimits[LSF_RLIMIT_STACK] > 0) {
if (!limit)
printf("\n");
printf(" %s",
(_i18n_msg_get(ls_catd,NL_SETN,1407, "STACKLIMIT"))); /* catgets 1407 */
limit = TRUE;
}
if (rLimits[LSF_RLIMIT_CORE] >= 0) {
if (!limit)
printf("\n");
printf(" %s",
(_i18n_msg_get(ls_catd,NL_SETN,1408, "CORELIMIT"))); /* catgets 1408 */
limit = TRUE;
}
if (rLimits[LSF_RLIMIT_RSS] > 0) {
if (!limit)
printf("\n");
printf(" %s",
(_i18n_msg_get(ls_catd,NL_SETN,1409, "MEMLIMIT"))); /* catgets 1409 */
limit = TRUE;
}
if (rLimits[LSF_RLIMIT_SWAP] > 0) {
if (!limit)
printf("\n");
printf(" %s",
(_i18n_msg_get(ls_catd,NL_SETN,1410, "SWAPLIMIT"))); /* catgets 1410 */
limit = TRUE;
}
if (rLimits[LSF_RLIMIT_PROCESS] > 0) {
if (!limit)
printf("\n");
printf(" %s",
(_i18n_msg_get(ls_catd,NL_SETN,1411, "PROCESSLIMIT"))); /* catgets 1411 */
limit = TRUE;
}
if (limit)
printf ("\n");
if (rLimits[LSF_RLIMIT_FSIZE] > 0)
printf(" %6d K ", rLimits[LSF_RLIMIT_FSIZE]);
if (rLimits[LSF_RLIMIT_DATA] > 0)
printf(" %6d K ", rLimits[LSF_RLIMIT_DATA]);
if (rLimits[LSF_RLIMIT_STACK] > 0)
printf(" %6d K ", rLimits[LSF_RLIMIT_STACK]);
if (rLimits[LSF_RLIMIT_CORE] >= 0)
printf(" %6d K ", rLimits[LSF_RLIMIT_CORE]);
if (rLimits[LSF_RLIMIT_RSS] > 0)
printf(" %6d K", rLimits[LSF_RLIMIT_RSS]);
if (rLimits[LSF_RLIMIT_SWAP] > 0)
printf(" %6d K ", rLimits[LSF_RLIMIT_SWAP]);
if (rLimits[LSF_RLIMIT_PROCESS] > 0)
printf(" %6d ", rLimits[LSF_RLIMIT_PROCESS]);
if (limit)
printf ("\n");
}
int
main( int argc, char *argv[] )
{
lsRcpXfer lsXfer;
int iCount;
char* buf;
int rc;
rc = _i18n_init ( I18N_CAT_MIN );
Signal_(SIGUSR1, SIG_IGN);
if (ls_initdebug(argv[0]) < 0) {
ls_perror("ls_initdebug");
exit(-1);
}
if (ls_initrex(1,0) == -1) {
ls_perror("lsrcp: ls_initrex");
return(-1);
}
ls_rfcontrol(RF_CMD_RXFLAGS, REXF_CLNTDIR);
if (setuid(getuid()) < 0) {
perror("lsrcp: setuid");
goto handle_error;
}
if (createXfer(&lsXfer)) {
perror("lsrcp");
goto handle_error;
}
doXferOptions(&lsXfer, argc, argv);
buf = (char*)malloc(LSRCP_MSGSIZE);
if(!buf) {
ls_donerex();
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_S,"lsrcp","main",
_i18n_msg_get(ls_catd,NL_SETN,2301,"try rcp...")); /* catgets 2301 */
if (doXferRcp(&lsXfer, 0) < 0)
return(-1);
return(0);
}
for (iCount=0;iCount < lsXfer.iNumFiles; iCount++) {
if (copyFile(&lsXfer, buf, 0)) {
ls_donerex();
ls_syslog(LOG_ERR, I18N_FUNC_FAIL_S,"lsrcp","main",
_i18n_msg_get(ls_catd,NL_SETN,2301,"try rcp..."));
if (doXferRcp(&lsXfer, 0) < 0)
return(-1);
return(0);
}
if (logclass & (LC_FILE))
ls_syslog(LOG_DEBUG, "main(), copy file succeeded.");
}
free(buf);
ls_donerex();
if (destroyXfer(&lsXfer)) {
perror("lsrcp");
return(-1);
}
_i18n_end ( ls_catd );
return(0);
handle_error:
ls_donerex();
return(-1);
}
void
child_handler(int sig)
{
int pid;
LS_WAIT_T status;
struct rusage rusage;
register float cpuTime;
struct lsfRusage lsfRusage;
struct jobCard *jobCard;
static short lastMbdExitVal = MASTER_NULL;
static int sbd_finish_sleep = -1;
cleanRusage (&rusage);
now = time(0);
while ((pid=wait3(&status, WNOHANG, &rusage)) > 0) {
if (pid == mbdPid) {
int sig = WTERMSIG(status);
if (mbdExitCnt > 150)
mbdExitCnt = 150;
mbdExitVal = WIFSIGNALED(status);
if (mbdExitVal) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5600,
"mbatchd died with signal <%d> termination"), /* catgets 5600 */
sig);
if (WCOREDUMP(status))
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5601,
"mbatchd core dumped")); /* catgets 5601 */
mbdExitVal = sig;
if (mbdExitVal == lastMbdExitVal)
mbdExitCnt++;
else {
mbdExitCnt = 0;
lastMbdExitVal = mbdExitVal;
}
continue;
} else {
mbdExitVal = WEXITSTATUS(status);
if (mbdExitVal == lastMbdExitVal)
mbdExitCnt++;
else {
mbdExitCnt = 0;
lastMbdExitVal = mbdExitVal;
}
if (mbdExitVal == MASTER_RECONFIG) {
ls_syslog(LOG_NOTICE, _i18n_msg_get(ls_catd , NL_SETN, 5602,
"mbatchd resigned for reconfiguration")); /* catgets 5602 */
start_master();
} else
ls_syslog(LOG_NOTICE, _i18n_msg_get(ls_catd , NL_SETN, 5603,
"mbatchd exited with value <%d>"), /* catgets 5603 */
mbdExitVal);
continue;
}
}
ls_ruunix2lsf (&rusage, &lsfRusage);
cpuTime = lsfRusage.ru_utime + lsfRusage.ru_stime;
for (jobCard = jobQueHead->forw; (jobCard != jobQueHead);
jobCard = jobCard->forw) {
if (jobCard->exitPid == pid) {
jobCard->w_status = LS_STATUS(status);
jobCard->exitPid = -1;
if (logclass & LC_EXEC) {
ls_syslog(LOG_DEBUG, I18N(5604,
"child_handler: Job <%s> exitPid <%d> status <%d> exitcode <%d>"),/*catgets 5604*/
lsb_jobid2str(jobCard->jobSpecs.jobId),
pid, jobCard->w_status,
WEXITSTATUS(status));
}
}
if (jobCard->jobSpecs.jobPid == pid) {
jobCard->collectedChild = TRUE;
jobCard->cpuTime = cpuTime;
jobCard->w_status = LS_STATUS(status);
jobCard->exitPid = -1;
memcpy ((char *) &jobCard->lsfRusage, (char *) &lsfRusage,
sizeof (struct lsfRusage));
jobCard->notReported++;
if (sbd_finish_sleep < 0) {
if (daemonParams[LSB_SBD_FINISH_SLEEP].paramValue) {
errno = 0;
sbd_finish_sleep = atoi(daemonParams[LSB_SBD_FINISH_SLEEP].paramValue);
if (errno)
sbd_finish_sleep = 0;
} else {
sbd_finish_sleep=0;
}
}
if (sbd_finish_sleep > 0) {
millisleep_(sbd_finish_sleep);
}
if (logclass & LC_EXEC) {
ls_syslog(LOG_DEBUG, I18N(5605,
"child_handler: Job <%s> Pid <%d> status <%d> exitcode <%d>"), /*catgets 5605*/
lsb_jobid2str(jobCard->jobSpecs.jobId), pid,
jobCard->w_status, WEXITSTATUS(status));
}
need_checkfinish = TRUE;
break;
}
}
}
}
static void
prtHostsLong (int numReply, struct hostInfoEnt *hInfo)
{
struct hostInfoEnt *hPtr;
int i, j, retVal = 0;
char *status, maxJobs[MAX_CHARLEN], userJobLimit[MAX_CHARLEN];
char **nameTable, **totalValues, **rsvValues, **formats;
struct lsInfo *lsInfo;
if ((lsInfo = ls_info()) == NULL) {
ls_perror("ls_info");
exit(-1);
}
lsInfoPtr = lsInfo;
for (i = 0; i < numReply; i++) {
hPtr = &(hInfo[i]);
if (repeatHost (i, hInfo))
continue;
printf("%s %s\n",
(_i18n_msg_get(ls_catd,NL_SETN,1604, "HOST")), /* catgets 1604 */
hPtr->host);
prtWord(HOST_STATUS_LENGTH, I18N_STATUS, 0);
if (lsbMode_ & LSB_MODE_BATCH) {
prtWord(HOST_CPUF_LENGTH, I18N_CPUF, -1);
prtWord(HOST_JL_U_LENGTH, I18N_JL_U, -1);
};
prtWord(HOST_MAX_LENGTH, I18N_MAX, -1);
prtWord(HOST_NJOBS_LENGTH, I18N_NJOBS, -1);
prtWord(HOST_RUN_LENGTH, I18N_RUN, -1);
prtWord(HOST_SSUSP_LENGTH, I18N_SSUSP, -1);
prtWord(HOST_USUSP_LENGTH, I18N_USUSP, -1);
prtWord(HOST_RSV_LENGTH, I18N_RSV, -1);
if (lsbMode_ & LSB_MODE_BATCH)
printf(I18N(1608, "DISPATCH_WINDOW\n")); /* catgets 1608 */
else
printf("\n");
status = I18N_ok;
if (hPtr->hStatus & HOST_STAT_UNAVAIL)
status = I18N_unavail;
else if (hPtr->hStatus & HOST_STAT_UNREACH)
status = (_i18n_msg_get(ls_catd,NL_SETN,1611, "unreach")); /* catgets 1611 */
else if (hPtr->hStatus & (HOST_STAT_BUSY
| HOST_STAT_WIND
| HOST_STAT_DISABLED
| HOST_STAT_EXCLUSIVE
| HOST_STAT_LOCKED
| HOST_STAT_LOCKED_MASTER
| HOST_STAT_FULL
| HOST_STAT_NO_LIM))
getCloseString (hPtr->hStatus, &status);
if (hPtr->userJobLimit < INFINIT_INT)
strcpy(userJobLimit,
prtValue(HOST_JL_U_LENGTH, hPtr->userJobLimit));
else
strcpy(userJobLimit, prtDash(HOST_JL_U_LENGTH));
if ( hPtr->maxJobs < INFINIT_INT )
strcpy(maxJobs,
prtValue(HOST_MAX_LENGTH, hPtr->maxJobs));
else
strcpy(maxJobs, prtDash(HOST_MAX_LENGTH));
prtWordL(HOST_STATUS_LENGTH, status);
if (lsbMode_ & LSB_MODE_BATCH) {
sprintf(fomt, "%%%d.2f %%s", HOST_CPUF_LENGTH );
printf(fomt, hPtr->cpuFactor, userJobLimit);
};
sprintf(fomt, "%%s%%%dd %%%dd %%%dd %%%dd %%%dd ",
HOST_NJOBS_LENGTH,
HOST_RUN_LENGTH,
HOST_SSUSP_LENGTH,
HOST_USUSP_LENGTH,
HOST_RSV_LENGTH);
printf(fomt,
maxJobs, hPtr->numJobs, hPtr->numRUN,
hPtr->numSSUSP, hPtr->numUSUSP, hPtr->numRESERVE);
if (lsbMode_ & LSB_MODE_BATCH)
printf("%s\n\n",
hPtr->windows[0] != '\0' ? hPtr->windows : " -");
else
printf("\n\n");
if (!(hPtr->hStatus & (HOST_STAT_UNAVAIL | HOST_STAT_UNREACH))){
printf(" %s:\n",
_i18n_msg_get(ls_catd,NL_SETN,1612, "CURRENT LOAD USED FOR SCHEDULING")); /* catgets 1612 */
prtLoad(hPtr, lsInfo);
if (lsbSharedResConfigured_) {
retVal = makeShareFields(hPtr->host, lsInfo, &nameTable,
&totalValues, &rsvValues,
&formats);
if (retVal > 0) {
int start =0;
int end;
while ((end = getDispLastItem(nameTable, start, retVal)) > start
&& start < retVal) {
printf(" %11s", " ");
for (j = start; j < end; j++)
printf(formats[j], nameTable[j]);
printf("\n %-11.11s",
_i18n_msg_get(ls_catd,NL_SETN,1613, "Total")); /* catgets 1613 */
for (j = start; j < end; j++)
printf(formats[j], totalValues[j]);
printf("\n %-11.11s",
_i18n_msg_get(ls_catd,NL_SETN,1614, "Reserved")); /* catgets 1614 */
for (j = start; j < end; j++)
printf(formats[j], rsvValues[j]);
putchar('\n');
putchar('\n');
start = end;
}
putchar('\n');
}
}
}
printf(" %s:\n",
_i18n_msg_get(ls_catd,NL_SETN,1615, "LOAD THRESHOLD USED FOR SCHEDULING")); /* catgets 1615 */
if (printThresholds(hPtr->loadSched, hPtr->loadStop,
hPtr->busySched, hPtr->busyStop,
MIN(hInfo->nIdx, lsInfo->numIndx),
lsInfo) < 0)
continue;
printf("\n");
if (hPtr->mig < INFINIT_INT)
printf(( _i18n_msg_get(ls_catd, NL_SETN, 1616, "Migration threshold is %d min \n")), hPtr->mig); /* catgets 1616 */
printf("\n");
}
}
int
bhc(int argc, char *argv[], int opCode)
{
struct hostInfoEnt *hostInfo ;
char **hostPoint ;
char **hosts=NULL;
char *optName;
char message[MAXLINELEN];
int i;
int fFlag = FALSE;
int all = FALSE, numHosts = 0;
int inquerFlag = FALSE;
while ((optName = myGetOpt(argc, argv, "C:f|")) != NULL) {
switch (optName[0]) {
case 'f':
fFlag = TRUE;
break;
case 'C':
if (strlen(optarg) > MAXLINELEN-1) {
printf("Message too long, truncated to %d char.\n", MAXLINELEN-1);
strncpy(message, optarg, MAXLINELEN-1);
message[MAXLINELEN-1]='\0';
} else
strcpy(message, optarg);
break;
default:
return -2;
}
}
switch (opCode) {
case HOST_OPEN :
opStr = (_i18n_msg_get(ls_catd,NL_SETN,901, "Open")); /* catgets 901 */
break;
case HOST_CLOSE :
opStr = (_i18n_msg_get(ls_catd,NL_SETN,902, "Close")); /* catgets 902 */
break;
case HOST_REBOOT :
opStr = (_i18n_msg_get(ls_catd,NL_SETN,903, "Restart slave batch daemon on")); /* catgets 903 */
break;
case HOST_SHUTDOWN :
opStr = (_i18n_msg_get(ls_catd,NL_SETN,904, "Shut down slave batch daemon on")); /* catgets 904 */
break;
default :
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,905, "Unknown operation code\n"))); /* catgets 905 */
exit(-1);
}
exitrc = 0;
numHosts = getNames (argc, argv, optind, &hosts, &all, "hostC");
hostPoint = NULL;
if (!numHosts && !all)
numHosts = 1;
else if (numHosts)
hostPoint = hosts;
if ((opCode == HOST_REBOOT || opCode == HOST_SHUTDOWN) &&
!(numHosts == 0 && all)) {
if ((hostInfo = getHostList(&numHosts, hostPoint)) == NULL)
return -1;
} else {
if ((hostInfo = lsb_hostinfo (hostPoint, &numHosts)) == NULL) {
lsb_perror(NULL);
return -1;
}
}
if (!fFlag && all && (opCode == HOST_REBOOT || opCode == HOST_SHUTDOWN))
inquerFlag = !doConfirm (opCode, NULL);
for (i = 0; i < numHosts; i++) {
if (strcmp(hostInfo[i].host, "lost_and_found") == 0
&& (opCode == HOST_REBOOT || opCode == HOST_SHUTDOWN)) {
if (!all)
fprintf(stderr, (_i18n_msg_get(ls_catd,NL_SETN,906, "<lost_and_found> is not a real host, ignored\n"))); /* catgets 906 */
continue;
}
if (inquerFlag && !(doConfirm (opCode, hostInfo[i].host)))
continue;
fprintf(stderr, "%s <%s> ...... ", opStr, hostInfo[i].host);
fflush(stderr);
ctrlHost (hostInfo[i].host, hostInfo[i].hStatus, opCode, message);
}
return exitrc;
}
static void
prtHostsShort (int numReply, struct hostInfoEnt *hInfo)
{
struct hostInfoEnt *hPtr;
int i;
char *status, maxJobs[MAX_CHARLEN], userJobLimit[MAX_CHARLEN];
char first = TRUE;
for (i = 0; i < numReply; i++) {
hPtr = &(hInfo[i]);
if ( first ) {
first = FALSE;
prtWord(HOST_NAME_LENGTH,
_i18n_msg_get(ls_catd, NL_SETN, 1618, "HOST_NAME"), 0); /* catgets 1618 */
if ( wflag )
prtWord(HOST_STATUS_LENGTH, I18N_STATUS, 0);
else
prtWord(HOST_STATUS_SHORT, I18N_STATUS, 0);
if (lsbMode_ & LSB_MODE_BATCH)
prtWord(HOST_JL_U_LENGTH, I18N_JL_U, -1);
prtWord(HOST_MAX_LENGTH, I18N_MAX, -1);
prtWord(HOST_NJOBS_LENGTH, I18N_NJOBS, -1);
prtWord(HOST_RUN_LENGTH, I18N_RUN, -1);
prtWord(HOST_SSUSP_LENGTH, I18N_SSUSP, -1);
prtWord(HOST_USUSP_LENGTH, I18N_USUSP, -1);
prtWord(HOST_RSV_LENGTH, I18N_RSV, -1);
printf("\n");
};
if ( repeatHost (i, hInfo) )
continue;
if ( wflag )
prtWordL(HOST_NAME_LENGTH, hPtr->host);
else
prtWord(HOST_NAME_LENGTH, hPtr->host, 0);
status = I18N_ok;
if (hPtr->hStatus & HOST_STAT_UNAVAIL)
status = I18N_unavail;
else if (hPtr->hStatus & HOST_STAT_UNREACH)
status = (_i18n_msg_get(ls_catd,NL_SETN,1626, "unreach")); /* catgets 1626 */
else if (hPtr->hStatus & (HOST_STAT_BUSY
| HOST_STAT_WIND
| HOST_STAT_DISABLED
| HOST_STAT_EXCLUSIVE
| HOST_STAT_LOCKED
| HOST_STAT_LOCKED_MASTER
| HOST_STAT_FULL
| HOST_STAT_NO_LIM)) {
if ( !wflag )
status = (_i18n_msg_get(ls_catd,NL_SETN,1627, "closed")); /* catgets 1627 */
else
getCloseString (hPtr->hStatus, &status);
};
if ( hPtr->userJobLimit < INFINIT_INT )
strcpy(userJobLimit,
prtValue(HOST_JL_U_LENGTH, hPtr->userJobLimit));
else
strcpy(userJobLimit, prtDash(HOST_JL_U_LENGTH));
if ( hPtr->maxJobs < INFINIT_INT )
strcpy(maxJobs,
prtValue(HOST_MAX_LENGTH, hPtr->maxJobs));
else
strcpy(maxJobs, prtDash(HOST_MAX_LENGTH));
if ( wflag )
prtWordL(HOST_STATUS_LENGTH, status);
else
prtWordL(HOST_STATUS_SHORT, status);
if ( lsbMode_ & LSB_MODE_BATCH )
printf("%s", userJobLimit);
sprintf(fomt, "%%s%%%dd %%%dd %%%dd %%%dd %%%dd\n",
HOST_NJOBS_LENGTH,
HOST_RUN_LENGTH,
HOST_SSUSP_LENGTH,
HOST_USUSP_LENGTH,
HOST_RSV_LENGTH);
printf(fomt,
maxJobs,
hPtr->numJobs,
hPtr->numRUN, hPtr->numSSUSP, hPtr->numUSUSP,
hPtr->numRESERVE);
}
}
int
main(int argc, char **argv)
{
static char fname[] = "res/main";
int nready;
int maxfd;
int i;
char *sp;
char *pathname = NULL;
int didSomething = 0;
char exbuf;
time_t thisPeriodic, lastPeriodic = 0, timeDiff;
fd_set rm, wm, em;
int sbdPty = FALSE;
char *sbdClHost = NULL;
ushort sbdClPort = 0;
char **sbdArgv = NULL;
int selectError = 0;
_i18n_init(I18N_CAT_RES);
saveDaemonDir_(argv[0]);
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-d") == 0 && argv[i+1] != NULL) {
pathname = argv[i+1];
putEnv("LSF_ENVDIR",pathname);
break;
}
}
if (pathname == NULL) {
if ((pathname = getenv("LSF_ENVDIR")) == NULL)
pathname = LSETCDIR;
}
if (argc > 1) {
if (!strcmp(argv[1],"-V")) {
fputs(_LS_VERSION_, stderr);
exit(0);
}
}
if ((ls_readconfenv(resConfParams, NULL) < 0) ||
(initenv_(resParams, pathname) < 0) ) {
if ((sp = getenv("LSF_LOGDIR")) != NULL)
resParams[LSF_LOGDIR].paramValue = sp;
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, (debug > 1),
resParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_MM, fname, "initenv_",
pathname);
ls_syslog(LOG_ERR, I18N_Exiting);
exit(-1);
}
restart_argc = argc;
restart_argv = argv;
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-d") == 0 && argv[i+1] != NULL) {
pathname = argv[i+1];
i++;
continue;
}
if (strcmp(argv[i], "-1") == 0) {
debug = 1;
continue;
}
if (strcmp(argv[i], "-2") == 0) {
debug = 2;
continue;
}
if (strcmp(argv[i], "-PTY_FIX") == 0) {
printf("PTY_FIX");
exit(0);
}
if ( (strcmp(argv[i], "-j") == 0) && (argv[i+1] != NULL) ) {
lsbJobStarter = argv[++i];
continue;
}
if (strcmp(argv[i], "-P") == 0) {
sbdPty = TRUE;
continue;
}
if (strcmp(argv[i], "-i") == 0) {
sbdFlags |= SBD_FLAG_STDIN;
continue;
}
if (strcmp(argv[i], "-o") == 0) {
sbdFlags |= SBD_FLAG_STDOUT;
continue;
}
if (strcmp(argv[i], "-e") == 0) {
sbdFlags |= SBD_FLAG_STDERR;
continue;
}
if (strcmp(argv[i], "-m") == 0 && argv[i+1] != NULL) {
sbdClHost = argv[i+1];
i++;
sbdMode = TRUE;
continue;
}
if (strcmp(argv[i], "-p") == 0 && argv[i+1] != NULL) {
sbdClPort = atoi(argv[i+1]);
i++;
sbdMode = TRUE;
continue;
}
if (argv[i][0] != '-') {
sbdMode = TRUE;
sbdArgv = argv + i;
break;
}
usage(argv[0]);
}
if (sbdMode) {
if (sbdClHost == NULL || sbdArgv == NULL) {
usage(argv[0]);
exit(-1);
}
if (sbdClPort) {
sbdFlags |= SBD_FLAG_TERM;
} else {
sbdFlags |= SBD_FLAG_STDIN | SBD_FLAG_STDOUT | SBD_FLAG_STDERR;
}
} else {
if (debug < 2)
for (i = sysconf(_SC_OPEN_MAX) ; i >= 0 ; i--)
close(i);
}
if (resParams[LSF_SERVERDIR].paramValue == NULL) {
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, (debug > 1),
resParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5001,
"LSF_SERVERDIR not defined in %s/lsf.conf: %M; res exiting"), /* catgets 5001 */
pathname);
resExit_(-1);
}
if (! debug && resParams[LSF_RES_DEBUG].paramValue != NULL) {
debug = atoi(resParams[LSF_RES_DEBUG].paramValue);
if (debug <= 0)
debug = 1;
}
getLogClass_(resParams[LSF_DEBUG_RES].paramValue,
resParams[LSF_TIME_RES].paramValue);
if (getuid() == 0 && debug) {
if (sbdMode) {
debug = 0;
} else {
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, FALSE,
resParams[LSF_LOG_MASK].paramValue);
ls_syslog(LOG_ERR, I18N(5005,"Root cannot run RES in debug mode ... exiting."));/*catgets 5005 */
exit(-1);
}
}
if (debug > 1)
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, TRUE, "LOG_DEBUG");
else {
ls_openlog("res", resParams[LSF_LOGDIR].paramValue, FALSE,
resParams[LSF_LOG_MASK].paramValue);
}
if (logclass & (LC_TRACE | LC_HANG))
ls_syslog(LOG_DEBUG, "%s: logclass=%x", fname, logclass);
ls_syslog(LOG_DEBUG, "%s: LSF_SERVERDIR=%s", fname, resParams[LSF_SERVERDIR].paramValue);
init_res();
initSignals();
periodic(0);
if (sbdMode) {
lsbJobStart(sbdArgv, sbdClPort, sbdClHost, sbdPty);
}
maxfd = FD_SETSIZE;
for (;;) {
struct timeval *timep;
struct timeval timeout;
loop:
didSomething = 0;
for (i = 0; i < child_cnt; i++) {
if (children[i]->backClnPtr == NULL
&& !FD_IS_VALID(conn2NIOS.sock.fd)
&& children[i]->running == 0) {
delete_child (children[i]);
}
}
if (logclass & LC_TRACE) {
ls_syslog(LOG_DEBUG,"\
%s: %s Res child_res=<%d> child_go=<%d> child_cnt=<%d> client_cnt=<%d>",
fname, ((child_res) ? "Application" : "Root") ,
child_res, child_go, child_cnt, client_cnt);
if (child_cnt == 1 && children != NULL && children[0] != NULL) {
dumpChild(children[0], 1, "in main()");
}
}
if (child_res && child_go && child_cnt == 0 && client_cnt == 0) {
if (debug > 1)
printf (" \n Child <%d> Retired! \n", (int)getpid());
if (logclass & LC_TRACE) {
ls_syslog(LOG_DEBUG,"\
%s: Application Res is exiting.....", fname);
}
millisleep_(5000);
if (sbdMode) {
close(1);
close(2);
exit(lastChildExitStatus);
}
resExit_(EXIT_NO_ERROR);
}
static void
prtLoad (struct hostInfoEnt *hPtrs, struct lsInfo *lsInfo)
{
static char fname[] = "prtLoad";
char **nlp = NULL;
int i, nf;
char **loadval;
char **loadval1;
int start = 0;
int end;
int last;
if (!fmt) {
if(!(fmt=(struct indexFmt *)
malloc((lsInfo->numIndx+2)*sizeof (struct indexFmt)))) {
lsberrno=LSBE_NO_MEM;
lsb_perror("print_long");
exit(-1);
}
for (i=0; i<NBUILTINDEX+2; i++)
fmt[i]=fmt1[i];
}
if ((nlp = formLINamesList (lsInfo)) == NULL) {
fprintf (stderr, "%s\n",
_i18n_msg_get(ls_catd,NL_SETN,1629, "Bad load index name specified")); /* catgets 1629 */
exit (-1);
}
if ((loadval=(char **) malloc((lsInfo->numIndx+1) * sizeof(char *)))
== NULL) {
lserrno=LSE_MALLOC;
lsb_perror(fname);
exit(-1);
}
if ((loadval1=(char **) malloc((lsInfo->numIndx+1) * sizeof(char *)))
== NULL) {
lserrno=LSE_MALLOC;
lsb_perror(fname);
exit(-1);
}
last = hPtrs->nIdx;
for (i=0; i < last; i++) {
loadval[i] = malloc(MAXFIELDSIZE);
loadval1[i] = malloc(MAXFIELDSIZE);
if (loadval[i] == NULL || loadval[i] == NULL) {
lserrno=LSE_MALLOC;
lsb_perror(fname);
exit(-1);
}
}
nf = makeFields(hPtrs, loadval, nlp, TRUE);
nf = makeFields(hPtrs, loadval1, nlp, FALSE);
while ((end = getDispLastItem(nlp, start, last)) > start
&& start < last) {
printf(" %11s", " ");
printf("%s\n", formatHeader(nlp, start, end));
printf( " %-11.11s",
_i18n_msg_get(ls_catd,NL_SETN,1630, "Total")); /* catgets 1630 */
for (i=start; i < end; i++)
printf("%s", loadval[i]);
putchar('\n');
printf( " %-11.11s",
_i18n_msg_get(ls_catd,NL_SETN,1631, "Reserved")); /* catgets 1631 */
for (i=start; i < end; i++)
printf("%s", loadval1[i]);
putchar('\n');
putchar('\n');
start = end;
}
putchar('\n');
for (i=0; i < last; i++) {
FREEUP(loadval[i]);
FREEUP(loadval1[i]);
}
FREEUP(loadval);
FREEUP(loadval1);
}
int
readHvalues(struct keymap *keyList, char *linep, FILE *fp, char *lsfile,
int *LineNum, int exact, char *section)
{
static char fname[] = "readHvalues";
char *key;
char *value;
char *sp, *sp1;
char error = FALSE;
int i=0;
sp = linep;
key = getNextWord_(&linep);
if ((sp1 = strchr(key, '=')) != NULL)
*sp1 = '\0';
value = strchr(sp, '=');
if (!value) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5402,
"%s: %s(%d): missing '=' after keyword %s, section %s ignoring the line"), fname, lsfile, *LineNum, key, section); /* catgets 5402 */
} else {
value++;
while (*value == ' ')
value++;
if (value[0] == '\0') {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5403,
"%s: %s(%d): null value after keyword %s, section %s ignoring the line"), fname, lsfile, *LineNum, key, section); /* catgets 5403 */
}
if (value[0] == '(') {
value++;
if ((sp1 = strrchr(value, ')')) != NULL)
*sp1 = '\0';
}
if (putValue(keyList, key, value) < 0) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5404,
"%s: %s(%d): bad keyword %s in section %s, ignoring the line"), fname, lsfile, *LineNum, key, section); /* catgets 5404 */
}
}
if ((linep = getNextLineC_(fp, LineNum, TRUE)) != NULL) {
if (isSectionEnd(linep, lsfile, LineNum, section)) {
if (! exact)
return 0;
i = 0;
while (keyList[i].key != NULL) {
if (keyList[i].val == NULL) {
ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5405,
"%s: %s(%d): required keyword %s is missing in section %s, ignoring the section"), fname, lsfile, *LineNum, keyList[i].key, section); /* catgets 5405 */
error = TRUE;
}
i++;
}
if (error) {
i = 0;
while (keyList[i].key != NULL) {
FREEUP(keyList[i].val);
i++;
}
return -1;
}
return 0;
}
return readHvalues(keyList, linep, fp, lsfile, LineNum, exact, section);
}
ls_syslog(LOG_ERR, I18N_PREMATURE_EOF,
fname, lsfile, *LineNum, section);
return -1;
}
int
breconfig (int argc, char **argv, int configFlag)
{
char *optName;
int vFlag = 0;
int fFlag = 0;
int checkReply;
int stdoutsave;
int fd;
FILE *fp;
char *linep;
char tmpfile[256];
char *tmpname = "tmpXXXXXX";
while ((optName = myGetOpt (argc, argv, "f|v|")) != NULL)
{
switch (optName[0])
{
case 'v':
vFlag = 1;
break;
case 'f':
fFlag = 1;
break;
default:
return (-2);
}
}
if (optind < argc)
{
return (-2);
}
if (!vFlag && !fFlag)
{
fprintf (stderr, "\nChecking configuration files ...\n\n");
stdoutsave = dup (1);
sprintf (tmpfile, "/tmp/%s", tmpname);
mktemp (tmpfile);
fd = open (tmpfile, O_RDWR | O_CREAT | O_TRUNC, 0666);
if (fd > 0)
{
dup2 (fd, 1);
dup2 (fd, 2);
checkReply = checkConf (1, 2);
fflush (stderr);
close (fd);
dup2 (stdoutsave, 1);
dup2 (stdoutsave, 2);
fp = fopen (tmpfile, "r");
if (fp != 0)
{
if (checkReply == EXIT_FATAL_ERROR
|| checkReply == EXIT_WARNING_ERROR)
{
if (checkReply == EXIT_FATAL_ERROR)
fprintf (stderr, "There are fatal errors.\n\n");
else
fprintf (stderr, "There are warning errors.\n\n");
fflush (stderr);
if (getConfirm ((_i18n_msg_get (ls_catd, NL_SETN, 2563, "Do you want to see detailed messages? [y/n] ")))) /* catgets 2563 */
while ((linep = getNextLine_ (fp, 0)))
fprintf (stderr, "%s\n", linep);
}
else
fprintf (stderr, I18N (2586, "No errors found.\n\n")); /* catgets 2586 */
fflush (stderr);
}
fclose (fp);
unlink (tmpfile);
}
else
checkReply = checkConf (0, 2);
}
else
checkReply = checkConf (vFlag, 2);
if (configFlag == MBD_CKCONFIG)
{
return (0);
}
switch (checkReply)
{
case EXIT_FATAL_ERROR:
return -1;
case EXIT_WARNING_ERROR:
if (fFlag)
break;
if (configFlag == MBD_RECONFIG)
{
if (!getConfirm
((_i18n_msg_get
(ls_catd, NL_SETN, 2564,
"\nDo you want to reconfigure? [y/n] "))))
{ /* catgets 2564 */
fprintf (stderr, (_i18n_msg_get (ls_catd, NL_SETN, 2565, "Reconfiguration aborted.\n"))); /* catgets 2565 */
return (-1);
}
}
else
{
if (!getConfirm
(I18N (2570, "\nDo you want to restart MBD? [y/n] ")))
{ /* catgets 2570 */
fprintf (stderr, (I18N (2571, "MBD restart aborted.\n"))); /* catgets 2571 */
return (-1);
}
}
default:
;
}
if (lsb_reconfig (configFlag) < 0)
{
lsb_perror ((_i18n_msg_get (ls_catd, NL_SETN, 2566, "Failed"))); /* catgets 2566 */
return (-1);
}
if (configFlag == MBD_RECONFIG)
{
printf ("%s\n", _i18n_msg_get (ls_catd, NL_SETN, 2567, "Reconfiguration initiated")); /* catgets 2567 */
}
else
{
printf ("%s\n", I18N (2569, "MBD restart initiated")); /* catgets 2569 */
}
return (0);
}
