/* lsb_getlimits()
*/
struct resLimitReply *
lsb_getlimits()
{
XDR xdrs;
struct LSFHeader hdr;
char *reply;
int cc;
char buf[sizeof(struct LSFHeader)];
struct resLimitReply *limitReply;
initLSFHeader_(&hdr);
hdr.opCode = BATCH_RESLIMIT_INFO;
xdrmem_create(&xdrs, buf, sizeof(struct LSFHeader), XDR_ENCODE);
if (! xdr_LSFHeader(&xdrs, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
return NULL;
}
reply = NULL;
cc = callmbd(NULL,
buf,
XDR_GETPOS(&xdrs),
&reply,
&hdr,
NULL,
NULL,
NULL);
if (cc < 0) {
xdr_destroy(&xdrs);
lsberrno = LSBE_PROTOCOL;
return NULL;
}
xdr_destroy(&xdrs);
if (hdr.opCode != LSBE_NO_ERROR) {
FREEUP(reply);
lsberrno = hdr.opCode;
return NULL;
}
xdrmem_create(&xdrs, reply, XDR_DECODE_SIZE_(cc), XDR_DECODE);
limitReply = calloc(1, sizeof(struct resLimitReply));
if(!xdr_resLimitReply(&xdrs, limitReply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
if (cc) {
FREEUP(reply);
FREEUP(limitReply);
}
return NULL;
}
xdr_destroy(&xdrs);
if (cc)
FREEUP(reply);
return limitReply;
}
int
lsb_reconfig (int configFlag)
{
mbdReqType mbdReqtype;
XDR xdrs;
char request_buf[MSGSIZE];
char *reply_buf;
int cc;
struct LSFHeader hdr;
struct lsfAuth auth;
int tmp;
mbdReqtype = BATCH_RECONFIG;
if (authTicketTokens_ (&auth, NULL) == -1)
return (-1);
xdrmem_create (&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_ (&hdr);
hdr.opCode = mbdReqtype;
tmp = (short) configFlag;
hdr.reserved = tmp;
if (!xdr_encodeMsg (&xdrs, NULL, &hdr, NULL, 0, &auth))
{
lsberrno = LSBE_XDR;
return (-1);
}
if ((cc = callmbd (NULL, request_buf, XDR_GETPOS (&xdrs), &reply_buf,
&hdr, NULL, NULL, NULL)) == -1)
{
xdr_destroy (&xdrs);
return (-1);
}
xdr_destroy (&xdrs);
if (cc)
free (reply_buf);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR)
return (0);
else
return (-1);
}
struct queueInfoEnt *
lsb_queueinfo (char **queues,
int *numQueues,
char *hosts,
char *users,
int options)
{
mbdReqType mbdReqtype;
static struct infoReq queueInfoReq;
static struct queueInfoReply reply;
static struct queueInfoEnt **qInfo = NULL;
struct queueInfoEnt **qTmp;
XDR xdrs;
XDR xdrs2;
char *request_buf;
char *reply_buf;
int cc;
int i;
static struct LSFHeader hdr;
char *clusterName = NULL;
if (qInfo != NULL) {
for (i = 0; i < reply.numQueues; i++) {
xdr_lsffree(xdr_queueInfoEnt,
(char*)qInfo[i],
&hdr);
}
}
if (numQueues == NULL) {
lsberrno = LSBE_BAD_ARG;
return NULL;
}
if ((queues == NULL && *numQueues > 1) || (*numQueues < 0)) {
lsberrno = LSBE_BAD_ARG;
return NULL;
}
queueInfoReq.options = 0;
if (queueInfoReq.names) {
FREEUP (queueInfoReq.names);
}
if (numQueues == NULL || *numQueues == 0)
queueInfoReq.options |= ALL_QUEUE;
else if (queues == NULL && *numQueues == 1)
queueInfoReq.options |= DFT_QUEUE;
if ((queueInfoReq.options & ALL_QUEUE)
|| (queueInfoReq.options & DFT_QUEUE)) {
if ((queueInfoReq.names = malloc(3 * sizeof(char *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
queueInfoReq.names[0] = "";
queueInfoReq.numNames = 1;
cc = 1;
} else {
if ((queueInfoReq.names = calloc(*numQueues + 2,
sizeof(char*))) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
queueInfoReq.numNames = *numQueues;
for (i = 0; i < *numQueues; i++) {
if (queues[i] && strlen(queues[i]) + 1 < MAXHOSTNAMELEN) {
queueInfoReq.names[i] = queues[i];
} else {
free (queueInfoReq.names);
queueInfoReq.names = NULL;
lsberrno = LSBE_BAD_QUEUE;
*numQueues = i;
return NULL;
}
}
cc = queueInfoReq.numNames;
}
if (users != NULL) {
if (strlen(users) + 1 < MAX_LSB_NAME_LEN) {
queueInfoReq.options |= CHECK_USER;
queueInfoReq.names[cc] = users;
cc++;
} else {
lsberrno = LSBE_BAD_USER;
*numQueues = 0;
return NULL;
}
}
if (hosts != NULL) {
if (ls_isclustername(hosts) <= 0) {
if (strlen (hosts) + 1 < MAXHOSTNAMELEN) {
queueInfoReq.options |= CHECK_HOST;
queueInfoReq.names[cc] = hosts;
cc++;
} else {
lsberrno = LSBE_BAD_HOST;
*numQueues = 0;
return NULL;
}
} else
clusterName = hosts;
}
queueInfoReq.resReq = "";
mbdReqtype = BATCH_QUE_INFO;
cc = sizeof(struct infoReq) + cc * MAXHOSTNAMELEN + cc + 128;
if ((request_buf = malloc (cc)) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&hdr);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs,
(char *)&queueInfoReq,
&hdr,
xdr_infoReq,
0,
NULL)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
free (request_buf);
return NULL;
}
if ((cc = callmbd(clusterName,
request_buf,
XDR_GETPOS(&xdrs),
&reply_buf,
&hdr,
NULL,
NULL,
NULL)) == -1) {
xdr_destroy(&xdrs);
free (request_buf);
return NULL;
}
xdr_destroy(&xdrs);
free (request_buf);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR
|| lsberrno == LSBE_BAD_QUEUE) {
xdrmem_create(&xdrs2, reply_buf, XDR_DECODE_SIZE_(cc), XDR_DECODE);
if (!xdr_queueInfoReply(&xdrs2, &reply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs2);
if (cc)
free(reply_buf);
*numQueues = 0;
return NULL;
}
xdr_destroy(&xdrs2);
if (cc)
free(reply_buf);
if (lsberrno == LSBE_BAD_QUEUE) {
*numQueues = reply.badQueue;
return NULL;
}
if ((qTmp = myrealloc(qInfo,
reply.numQueues
* sizeof(struct queueInfoEnt *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
qInfo = qTmp;
for (i = 0; i < reply.numQueues; i++)
qInfo[i] = &(reply.queues[i]);
*numQueues = reply.numQueues;
return qInfo[0];
}
if (cc)
free(reply_buf);
*numQueues = 0;
return NULL;
}
static int
sendGrpReq (char *clusterName, int options, struct infoReq *groupInfo,
struct groupInfoReply *reply)
{
XDR xdrs;
char request_buf[MSGSIZE];
char * reply_buf;
struct LSFHeader hdr;
mbdReqType mbdReqtype;
int cc;
xdr_lsffree(xdr_groupInfoReply, (char *)reply, &hdr);
mbdReqtype = BATCH_GRP_INFO;
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs,
(char *)groupInfo,
&hdr,
xdr_infoReq,
0,
NULL)){
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
return -1;
}
if ((cc = callmbd (clusterName,
request_buf,
XDR_GETPOS(&xdrs),
&reply_buf,
&hdr,
NULL,
NULL,
NULL)) == -1) {
xdr_destroy(&xdrs);
return -1;
}
xdr_destroy(&xdrs);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR || lsberrno == LSBE_BAD_GROUP ) {
xdrmem_create(&xdrs,
reply_buf,
XDR_DECODE_SIZE_(cc),
XDR_DECODE);
if (!xdr_groupInfoReply(&xdrs, reply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return -1;
}
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return 0;
}
if (cc)
free(reply_buf);
return -1;
}
struct parameterInfo *
lsb_parameterinfo (char **names, int *numUsers, int options)
{
mbdReqType mbdReqtype;
XDR xdrs;
struct LSFHeader hdr;
char *request_buf;
char *reply_buf;
static struct parameterInfo paramInfo;
struct parameterInfo *reply;
static struct infoReq infoReq;
static int alloc = FALSE;
int cc = 0;
infoReq.options = options;
if (alloc == TRUE) {
alloc = FALSE;
FREEUP(infoReq.names);
}
if (numUsers)
infoReq.numNames = *numUsers;
else
infoReq.numNames = 0;
if (names)
infoReq.names = names;
else {
if ((infoReq.names = malloc(sizeof(char *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
alloc = TRUE;
infoReq.names[0] = "";
cc = 1;
}
infoReq.resReq = "";
mbdReqtype = BATCH_PARAM_INFO;
cc = sizeof(struct infoReq) + cc * MAXHOSTNAMELEN + cc + 100;
if ((request_buf = malloc (cc)) == NULL) {
lsberrno = LSBE_NO_MEM;
return NULL;
}
xdrmem_create(&xdrs, request_buf, cc, XDR_ENCODE);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs, (char *)&infoReq, &hdr, xdr_infoReq, 0, NULL)) {
xdr_destroy(&xdrs);
free (request_buf);
lsberrno = LSBE_XDR;
return NULL;
}
if ((cc = callmbd (NULL,request_buf, XDR_GETPOS(&xdrs), &reply_buf, &hdr,
NULL, NULL, NULL)) == -1) {
xdr_destroy(&xdrs);
free (request_buf);
return NULL;
}
xdr_destroy(&xdrs);
free (request_buf);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR || lsberrno == LSBE_BAD_USER) {
xdrmem_create(&xdrs, reply_buf, XDR_DECODE_SIZE_(cc), XDR_DECODE);
reply = ¶mInfo;
if(!xdr_parameterInfo (&xdrs, reply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return NULL;
}
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return(reply);
}
if (cc)
free(reply_buf);
return NULL;
}
static int
signalJob_(int sigValue, LS_LONG_INT jobId, time_t period, int options)
{
struct signalReq signalReq;
char request_buf[MSGSIZE];
char *reply_buf;
XDR xdrs;
mbdReqType mbdReqtype;
int cc;
struct LSFHeader hdr;
struct lsfAuth auth;
signalReq.jobId = jobId;
if (authTicketTokens_(&auth, NULL) == -1)
return -1;
signalReq.sigValue = sigValue;
signalReq.chkPeriod = period;
signalReq.actFlags = options;
signalReq.sigValue = sig_encode(signalReq.sigValue);
mbdReqtype = BATCH_JOB_SIG;
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&hdr);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs,
(char *)&signalReq,
&hdr,
xdr_signalReq,
0,
&auth)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
return -1;
}
if ((cc = callmbd(NULL,
request_buf,
XDR_GETPOS(&xdrs),
&reply_buf,
&hdr,
NULL,
NULL,
NULL)) < 0) {
xdr_destroy(&xdrs);
return -1;
}
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR || lsberrno == LSBE_JOB_DEP)
return 0;
return -1 ;
}
int
lsb_msgjob (LS_LONG_INT jobId, char *msg)
{
struct lsbMsg jmsg;
char src[LSB_MAX_SD_LENGTH];
char dest[LSB_MAX_SD_LENGTH];
struct lsbMsgHdr header;
char request_buf[MSGSIZE];
char *reply_buf;
XDR xdrs;
mbdReqType mbdReqtype;
int cc;
struct LSFHeader hdr;
struct passwd *pw;
header.src = src;
header.dest = dest;
jmsg.header = &header;
TIMEIT (0, (pw = getpwuid (getuid ())), "getpwuid");
if (pw == NULL)
{
lsberrno = LSBE_BAD_USER;
return (-1);
}
jmsg.header->usrId = pw->pw_uid;
jmsg.header->jobId = jobId;
jmsg.msg = msg;
strcpy (jmsg.header->src, "lsbatch");
strcpy (jmsg.header->dest, "user job");
jmsg.header->msgId = 999;
jmsg.header->type = -1;
mbdReqtype = BATCH_JOB_MSG;
xdrmem_create (&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg (&xdrs, (char *) &jmsg, &hdr, xdr_lsbMsg, 0, NULL))
{
lsberrno = LSBE_XDR;
xdr_destroy (&xdrs);
return (-1);
}
cc = callmbd (NULL, request_buf, XDR_GETPOS (&xdrs), &reply_buf,
&hdr, NULL, NULL, NULL);
if (cc < 0)
{
xdr_destroy (&xdrs);
return (-1);
}
xdr_destroy (&xdrs);
if (cc != 0)
free (reply_buf);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR)
return (0);
else
return (-1);
}
int
lsb_switchjob (LS_LONG_INT jobId, char *queue)
{
struct jobSwitchReq jobSwitchReq;
char request_buf[MSGSIZE];
char *reply_buf;
XDR xdrs;
mbdReqType mbdReqtype;
int cc;
struct LSFHeader hdr;
struct lsfAuth auth;
if (jobId <= 0 || queue == 0) {
lsberrno = LSBE_BAD_ARG;
return(-1);
}
if (queue && (strlen (queue) >= MAX_LSB_NAME_LEN - 1)) {
lsberrno = LSBE_BAD_QUEUE;
return(-1);
}
if (authTicketTokens_(&auth, NULL) == -1)
return (-1);
jobSwitchReq.jobId = jobId;
strcpy (jobSwitchReq.queue, queue);
mbdReqtype = BATCH_JOB_SWITCH;
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&hdr);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs, (char *)&jobSwitchReq, &hdr, xdr_jobSwitchReq,
0, &auth)) {
lsberrno = LSBE_XDR;
return(-1);
}
if ((cc = callmbd (NULL, request_buf, XDR_GETPOS(&xdrs), &reply_buf,
&hdr, NULL, NULL, NULL)) == -1)
{
xdr_destroy(&xdrs);
return (-1);
}
xdr_destroy(&xdrs);
lsberrno = hdr.opCode;
if (cc)
free(reply_buf);
if (lsberrno == LSBE_NO_ERROR)
return(0);
else
return(-1);
}
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 userInfoEnt *
lsb_userinfo (char **users, int *numUsers)
{
mbdReqType mbdReqtype;
XDR xdrs;
struct LSFHeader hdr;
char *reply_buf;
char *request_buf;
struct userInfoReply userInfoReply, *reply;
static struct infoReq userInfoReq;
int i, cc = 0, numReq = -1;
char lsfUserName[MAXLINELEN];
if (numUsers)
{
numReq = *numUsers;
*numUsers = 0;
}
if (numReq < 0)
{
lsberrno = LSBE_BAD_ARG;
return (NULL);
}
if (userInfoReq.names)
free (userInfoReq.names);
if (numUsers == NULL || numReq == 0)
{
userInfoReq.numNames = 0;
if ((userInfoReq.names = (char **) malloc (sizeof (char *))) == NULL)
{
lsberrno = LSBE_NO_MEM;
return (NULL);
}
userInfoReq.names[0] = "";
cc = 1;
}
else if (numReq == 1 && users == NULL)
{
if (getLSFUser_ (lsfUserName, MAXLINELEN) != 0)
{
return (NULL);
}
userInfoReq.numNames = 1;
if ((userInfoReq.names = (char **) malloc (sizeof (char *))) == NULL)
{
lsberrno = LSBE_NO_MEM;
return (NULL);
}
userInfoReq.names[0] = lsfUserName;
cc = 1;
}
else
{
if ((userInfoReq.names = (char **) calloc
(numReq, sizeof (char *))) == NULL)
{
lsberrno = LSBE_NO_MEM;
return (NULL);
}
userInfoReq.numNames = numReq;
for (i = 0; i < numReq; i++)
{
if (users[i] && strlen (users[i]) + 1 < MAXHOSTNAMELEN)
userInfoReq.names[i] = users[i];
else
{
free (userInfoReq.names);
lsberrno = LSBE_BAD_USER;
*numUsers = i;
return (NULL);
}
}
cc = numReq;
}
userInfoReq.resReq = "";
mbdReqtype = BATCH_USER_INFO;
cc = sizeof (struct infoReq) + cc * MAXHOSTNAMELEN + cc + 100;
if ((request_buf = malloc (cc)) == NULL)
{
lsberrno = LSBE_NO_MEM;
return (NULL);
}
xdrmem_create (&xdrs, request_buf, cc, XDR_ENCODE);
initLSFHeader_ (&hdr);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg (&xdrs, (char *) &userInfoReq, &hdr, xdr_infoReq,
0, NULL))
{
xdr_destroy (&xdrs);
free (request_buf);
lsberrno = LSBE_XDR;
return (NULL);
}
if ((cc = callmbd (NULL, request_buf, XDR_GETPOS (&xdrs),
&reply_buf, &hdr, NULL, NULL, NULL)) == -1)
{
xdr_destroy (&xdrs);
free (request_buf);
return (NULL);
}
xdr_destroy (&xdrs);
free (request_buf);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR || lsberrno == LSBE_BAD_USER)
{
xdrmem_create (&xdrs, reply_buf, XDR_DECODE_SIZE_ (cc), XDR_DECODE);
reply = &userInfoReply;
if (!xdr_userInfoReply (&xdrs, reply, &hdr))
{
lsberrno = LSBE_XDR;
xdr_destroy (&xdrs);
if (cc)
free (reply_buf);
return (NULL);
}
xdr_destroy (&xdrs);
if (cc)
free (reply_buf);
if (lsberrno == LSBE_BAD_USER)
{
*numUsers = reply->badUser;
return (NULL);
}
*numUsers = reply->numUsers;
return (reply->users);
}
if (cc)
free (reply_buf);
return (NULL);
}
struct jobInfoHead *
lsb_openjobinfo_a (LS_LONG_INT jobId, char *jobName, char *userName,
char *queueName, char *hostName, int options)
{
static int first = TRUE;
static struct jobInfoReq jobInfoReq;
static struct jobInfoHead jobInfoHead;
mbdReqType mbdReqtype;
XDR xdrs, xdrs2;
char request_buf[MSGSIZE];
char *reply_buf, *clusterName = NULL;
int cc, aa;
struct LSFHeader hdr;
char lsfUserName[MAXLINELEN];
if (first) {
if ( !(jobInfoReq.jobName = (char *) malloc(MAX_CMD_DESC_LEN))
|| !(jobInfoReq.queue = (char *) malloc(MAX_LSB_NAME_LEN))
|| !(jobInfoReq.userName = (char *) malloc(MAX_LSB_NAME_LEN))
|| !(jobInfoReq.host = (char *) malloc(MAXHOSTNAMELEN))) {
lsberrno = LSBE_SYS_CALL;
return(NULL);
}
first = FALSE;
}
if (queueName == NULL)
jobInfoReq.queue[0] = '\0';
else {
if (strlen (queueName) >= MAX_LSB_NAME_LEN - 1) {
lsberrno = LSBE_BAD_QUEUE;
return(NULL);
}
TIMEIT(1, strcpy(jobInfoReq.queue, queueName), "strcpy");
}
if (hostName == NULL)
jobInfoReq.host[0] = '\0';
else {
if (ls_isclustername(hostName) > 0) {
jobInfoReq.host[0] = '\0';
clusterName = hostName;
} else {
struct hostent *hp;
TIMEIT(0, (hp = Gethostbyname_(hostName)), "getHostOfficialByName_");
if (hp != NULL) {
struct hostInfo *hostinfo;
char officialNameBuf[MAXHOSTNAMELEN];
strcpy(officialNameBuf, hp->h_name);
hostinfo = ls_gethostinfo("-",
NULL,
(char **)&hp->h_name,
1,
LOCAL_ONLY);
if (hostinfo == NULL) {
strcpy(jobInfoReq.host, hostName);
} else {
strcpy(jobInfoReq.host, officialNameBuf);
}
} else {
if (strlen (hostName) >= MAXHOSTNAMELEN - 1) {
lsberrno = LSBE_BAD_HOST;
return(NULL);
}
strcpy(jobInfoReq.host, hostName);
}
}
}
if (jobName == NULL)
jobInfoReq.jobName[0] = '\0';
else {
if (strlen (jobName) >= MAX_CMD_DESC_LEN - 1) {
lsberrno = LSBE_BAD_JOB;
return(NULL);
}
strcpy(jobInfoReq.jobName, jobName);
}
if (userName == NULL ) {
TIMEIT(0, (cc = getLSFUser_(lsfUserName, MAXLINELEN)), "getLSFUser_");
if (cc != 0) {
return (NULL);
}
TIMEIT(1, strcpy(jobInfoReq.userName, lsfUserName), "strcpy");
} else {
if (strlen (userName) >= MAX_LSB_NAME_LEN - 1) {
lsberrno = LSBE_BAD_USER;
return(NULL);
}
strcpy(jobInfoReq.userName, userName);
}
if ((options & ~(JOBID_ONLY | JOBID_ONLY_ALL | HOST_NAME | NO_PEND_REASONS)) == 0)
jobInfoReq.options = CUR_JOB;
else
jobInfoReq.options = options;
if (jobId < 0) {
lsberrno = LSBE_BAD_ARG;
return(NULL);
}
jobInfoReq.jobId = jobId;
mbdReqtype = BATCH_JOB_INFO;
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
hdr.opCode = mbdReqtype;
TIMEIT(1, (aa = xdr_encodeMsg(&xdrs, (char *) &jobInfoReq , &hdr,
xdr_jobInfoReq, 0, NULL)), "xdr_encodeMsg");
if (aa == FALSE) {
lsberrno = LSBE_XDR;
return(NULL);
}
TIMEIT(0, (cc = callmbd (clusterName, request_buf, XDR_GETPOS(&xdrs),
&reply_buf, &hdr, &mbdSock, NULL, NULL)), "callmbd");
if (cc == -1) {
xdr_destroy(&xdrs);
return (NULL);
}
xdr_destroy(&xdrs);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR) {
xdrmem_create(&xdrs2, reply_buf, XDR_DECODE_SIZE_(cc), XDR_DECODE);
if (! xdr_jobInfoHead (&xdrs2, &jobInfoHead, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs2);
if (cc)
free(reply_buf);
return(NULL);
}
xdr_destroy(&xdrs2);
if (cc)
free(reply_buf);
return (&jobInfoHead);
}
if (cc)
free(reply_buf);
return(NULL);
}
int
lsb_runjob(struct runJobRequest* runJobRequest)
{
XDR xdrs;
struct LSFHeader lsfHeader;
struct lsfAuth auth;
mbdReqType mbdReqType;
char request_buf[MSGSIZE/2];
char* reply_buf;
int retVal;
int cc;
if (runJobRequest == NULL
|| runJobRequest->numHosts == 0
|| runJobRequest->hostname == NULL
|| runJobRequest->jobId < 0
|| ( runJobRequest->options != 0
&& ! (runJobRequest->options &
(RUNJOB_OPT_NORMAL | RUNJOB_OPT_NOSTOP))))
{
lsberrno = LSBE_BAD_ARG;
return(-1);
}
if (!( runJobRequest->options & (RUNJOB_OPT_NORMAL | RUNJOB_OPT_NOSTOP))) {
runJobRequest->options |= RUNJOB_OPT_NORMAL;
}
if (authTicketTokens_(&auth, NULL) == -1) {
lsberrno = LSBE_LSBLIB;
return (-1);
}
mbdReqType = BATCH_JOB_FORCE;
xdrmem_create(&xdrs,
request_buf,
MSGSIZE/2,
XDR_ENCODE);
initLSFHeader_(&lsfHeader);
lsfHeader.opCode = mbdReqType;
if (!xdr_encodeMsg(&xdrs,
(char *)runJobRequest,
&lsfHeader,
xdr_runJobReq,
0,
&auth)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
return(-1);
}
if ((cc = callmbd(NULL,
request_buf,
XDR_GETPOS(&xdrs),
&reply_buf,
&lsfHeader,
NULL,
NULL,
NULL)) == -1) {
xdr_destroy(&xdrs);
return(-1);
}
xdr_destroy(&xdrs);
lsberrno = lsfHeader.opCode;
if (lsberrno == LSBE_NO_ERROR)
retVal = 0;
else
retVal = -1;
return(retVal);
}
struct lsbSharedResourceInfo *
lsb_sharedresourceinfo(char **resources, int *numResources, char *hostName, int options)
{
static char fname[] = "lsb_sharedresourceinfo";
static struct lsbShareResourceInfoReply lsbResourceInfoReply;
struct resourceInfoReq resourceInfoReq;
int cc = 0, i;
char *clusterName = NULL;
static struct LSFHeader hdr;
char *request_buf;
char *reply_buf;
mbdReqType mbdReqtype;
XDR xdrs, xdrs2;
#define FREE_MEMORY \
{ \
free(request_buf); \
free(resourceInfoReq.resourceNames); \
}
#define FREE_REPLY_BUFFER \
{ \
if (cc) \
free(reply_buf); \
}
if (logclass & (LC_TRACE))
ls_syslog(LOG_DEBUG1, "%s: Entering this routine...", fname);
if (lsbResourceInfoReply.numResources > 0)
xdr_lsffree(xdr_lsbShareResourceInfoReply, (char *)&lsbResourceInfoReply, &hdr);
if (numResources == NULL ||
*numResources < 0 ||
(resources == NULL && *numResources != 0) ||
(resources != NULL && *numResources == 0)) {
lsberrno = LSBE_BAD_ARG;
return (NULL);
}
resourceInfoReq.options = 0;
if (*numResources == 0) {
if ((resourceInfoReq.resourceNames =
(char **) malloc(sizeof (char *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return (NULL);
}
resourceInfoReq.resourceNames[0] = "";
resourceInfoReq.numResourceNames = 1;
cc += 2;
} else {
if ((resourceInfoReq.resourceNames =
(char **) malloc (*numResources * sizeof(char *))) == NULL) {
lsberrno = LSBE_NO_MEM;
return(NULL);
}
for (i = 0; i < *numResources; i++) {
if (resources[i] && strlen (resources[i]) + 1 < MAXLSFNAMELEN) {
resourceInfoReq.resourceNames[i] = resources[i];
cc += MAXLSFNAMELEN;
} else {
free (resourceInfoReq.resourceNames);
lserrno = LSBE_BAD_RESOURCE;
return (NULL);
}
}
resourceInfoReq.numResourceNames = *numResources;
}
if (hostName != NULL) {
if (ls_isclustername(hostName) <= 0) {
if (strlen (hostName) + 1 < MAXHOSTNAMELEN) {
resourceInfoReq.hostName = hostName;
} else {
lsberrno = LSBE_BAD_HOST;
return (NULL);
}
} else {
clusterName = hostName;
cc += MAXHOSTNAMELEN;
}
} else
resourceInfoReq.hostName = " ";
mbdReqtype = BATCH_RESOURCE_INFO;
cc = sizeof(struct resourceInfoReq) + cc + 100;
if ((request_buf = malloc (cc)) == NULL) {
lsberrno = LSBE_NO_MEM;
return(NULL);
}
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
initLSFHeader_(&hdr);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs, (char*)&resourceInfoReq, &hdr, xdr_resourceInfoReq,
0, NULL)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
FREE_MEMORY;
return(NULL);
}
if ((cc = callmbd(clusterName, request_buf, XDR_GETPOS(&xdrs), &reply_buf,
&hdr, NULL, NULL, NULL)) == -1)
{
xdr_destroy(&xdrs);
FREE_MEMORY;
return (NULL);
}
FREE_MEMORY;
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR) {
xdrmem_create(&xdrs2, reply_buf, XDR_DECODE_SIZE_(cc), XDR_DECODE);
if (!xdr_lsbShareResourceInfoReply(&xdrs2, &lsbResourceInfoReply, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs2);
FREE_REPLY_BUFFER;
return(NULL);
}
xdr_destroy(&xdrs2);
FREE_REPLY_BUFFER;
*numResources = lsbResourceInfoReply.numResources;
return (lsbResourceInfoReply.resources);
}
FREE_REPLY_BUFFER;
return (NULL);
}
int
lsb_movejob (LS_LONG_INT jobId, int *position, int opCode)
{
struct jobMoveReq jobMoveReq;
char request_buf[MSGSIZE];
char *reply_buf;
XDR xdrs;
mbdReqType mbdReqtype;
int cc;
struct LSFHeader hdr;
struct lsfAuth auth;
if (opCode != TO_TOP && opCode != TO_BOTTOM) {
lsberrno = LSBE_BAD_ARG;
return -1;
}
if (position == NULL ) {
lsberrno = LSBE_BAD_ARG;
return -1;
}
if (jobId <= 0 || *position <= 0) {
lsberrno = LSBE_BAD_ARG;
return -1;
}
if (authTicketTokens_(&auth, NULL) == -1)
return -1;
jobMoveReq.jobId = jobId;
jobMoveReq.position = *position;
jobMoveReq.opCode = opCode;
mbdReqtype = BATCH_JOB_MOVE;
xdrmem_create(&xdrs, request_buf, MSGSIZE, XDR_ENCODE);
hdr.opCode = mbdReqtype;
if (!xdr_encodeMsg(&xdrs, (char *) &jobMoveReq, &hdr, xdr_jobMoveReq, 0, &auth)) {
xdr_destroy(&xdrs);
lsberrno = LSBE_XDR;
return -1;
}
if ((cc = callmbd (NULL, request_buf, XDR_GETPOS(&xdrs), &reply_buf,
&hdr, NULL, NULL, NULL)) == -1) {
xdr_destroy(&xdrs);
return -1;
}
xdr_destroy(&xdrs);
lsberrno = hdr.opCode;
if (lsberrno == LSBE_NO_ERROR) {
xdrmem_create(&xdrs, reply_buf, XDR_DECODE_SIZE_(cc), XDR_DECODE);
if (!xdr_jobMoveReq(&xdrs, &jobMoveReq, &hdr)) {
lsberrno = LSBE_XDR;
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return -1;
}
*position = jobMoveReq.position ;
xdr_destroy(&xdrs);
if (cc)
free(reply_buf);
return 0;
}
if (cc)
free(reply_buf);
return -1;
}
