Example #1
0
/* 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;
}
Example #2
0
int
callLim_(enum limReqCode reqCode,
         void *dsend,
         bool_t (*xdr_sfunc)(),
         void *drecv,
         bool_t (*xdr_rfunc)(),
         char *host,
         int options,
         struct LSFHeader *hdr)
{
    struct LSFHeader reqHdr;
    struct LSFHeader replyHdr;
    XDR    xdrs;
    char   sbuf[8*MSGSIZE];
    char   rbuf[MAXMSGLEN];
    char   *repBuf;
    enum limReplyCode limReplyCode;
    static char first = TRUE;
    int reqLen;

    masterLimDown = FALSE;
    if (first) {

        if (initLimSock_() < 0)
            return(-1);
        first = FALSE;

        if (genParams_[LSF_API_CONNTIMEOUT].paramValue) {
            conntimeout_ = atoi(genParams_[LSF_API_CONNTIMEOUT].paramValue);
            if (conntimeout_ <= 0)
                conntimeout_ =  CONNECT_TIMEOUT;
        }

        if (genParams_[LSF_API_RECVTIMEOUT].paramValue) {
            recvtimeout_ = atoi(genParams_[LSF_API_RECVTIMEOUT].paramValue);
            if (recvtimeout_ <= 0)
                recvtimeout_ = RECV_TIMEOUT;
        }
    }

    initLSFHeader_(&reqHdr);
    reqHdr.opCode = reqCode;

    reqHdr.refCode  = getRefNum_();
    reqHdr.version = OPENLAVA_VERSION;

    xdrmem_create(&xdrs, sbuf, 8*MSGSIZE, XDR_ENCODE);
    if (!xdr_encodeMsg(&xdrs, dsend, &reqHdr, xdr_sfunc, 0, NULL)) {
        xdr_destroy(&xdrs);
        lserrno = LSE_BAD_XDR;
        return -1;
    }

    reqLen = XDR_GETPOS(&xdrs);
    xdr_destroy(&xdrs);
    if (options & _USE_TCP_) {
        if (callLimTcp_(sbuf, &repBuf, reqLen, &replyHdr, options) < 0)
            return -1;
        if (replyHdr.length != 0)
            xdrmem_create(&xdrs, repBuf, XDR_DECODE_SIZE_(replyHdr.length),
                          XDR_DECODE);
        else
            xdrmem_create(&xdrs, rbuf, MAXMSGLEN, XDR_DECODE);
    } else {
        if (callLimUdp_(sbuf, rbuf, reqLen, &reqHdr, host, options) < 0)
            return -1;
        if (options & _NON_BLOCK_)
            return 0;
        xdrmem_create(&xdrs, rbuf, MAXMSGLEN, XDR_DECODE);
    }

    if (!(options & _USE_TCP_)) {
        if (!xdr_LSFHeader(&xdrs, &replyHdr)) {
            xdr_destroy(&xdrs);
            lserrno = LSE_BAD_XDR;
            return -1;
        }
    }

    limReplyCode = replyHdr.opCode;

    lsf_lim_version = (int)replyHdr.version;

    switch (limReplyCode) {
        case LIME_NO_ERR:
            if (drecv != NULL) {
                if (! (*xdr_rfunc) (&xdrs, drecv, &replyHdr)) {
                    xdr_destroy(&xdrs);
                    if (options & _USE_TCP_)
                        FREEUP(repBuf);
                    lserrno = LSE_BAD_XDR;
                    return -1;
                }
            }
            xdr_destroy(&xdrs);
            if (options & _USE_TCP_)
                FREEUP(repBuf);
            if (hdr != NULL)
                *hdr = replyHdr;
            return (0);

        default:
            xdr_destroy(&xdrs);
            if (options & _USE_TCP_)
                FREEUP(repBuf);
            err_return_(limReplyCode);
            return (-1);
    }

}
Example #3
0
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;
}
Example #4
0
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;

}
Example #5
0
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 = &paramInfo;
        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;

}
Example #6
0
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);

}
Example #7
0
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);

} 
Example #8
0
struct jobInfoEnt *
lsb_readjobinfo(int *more)
{
    XDR  xdrs;
    int num, i, aa;
    struct LSFHeader hdr;
    char *buffer = NULL;
    static struct jobInfoReply jobInfoReply;
    static struct jobInfoEnt jobInfo;
    static struct submitReq submitReq;   
    static int first = TRUE;

    static int npids = 0;
    static struct pidInfo  *pidInfo = NULL;
    static int npgids = 0;
    static int *pgid = NULL;


    TIMEIT(0, (num = readNextPacket(&buffer, _lsb_recvtimeout, &hdr,
				    mbdSock)), "readNextPacket");
    if (num < 0) {
	closeSession(mbdSock);
        lsberrno = LSBE_EOF;
	return NULL;
    }

    if (first) {
	if ( (submitReq.fromHost = malloc(MAXHOSTNAMELEN)) == NULL
	    || (submitReq.jobFile = malloc(MAXFILENAMELEN)) == NULL
	    || (submitReq.inFile  = malloc(MAXFILENAMELEN)) == NULL
	    || (submitReq.outFile = malloc(MAXFILENAMELEN)) == NULL
	    || (submitReq.errFile = malloc(MAXFILENAMELEN)) == NULL
	    || (submitReq.inFileSpool = malloc(MAXFILENAMELEN)) == NULL
	    || (submitReq.commandSpool = malloc(MAXFILENAMELEN)) == NULL
	    || (submitReq.hostSpec = malloc(MAXHOSTNAMELEN)) == NULL
	    || (submitReq.chkpntDir = malloc(MAXFILENAMELEN)) == NULL
	    || (submitReq.subHomeDir = malloc(MAXFILENAMELEN)) == NULL
	    || (jobInfoReply.userName  = malloc(MAXLSFNAMELEN)) == NULL
	    || (submitReq.cwd       = malloc(MAXFILENAMELEN)) == NULL) {
	    lsberrno = LSBE_NO_MEM;
	    FREEUP(submitReq.fromHost);
	    FREEUP(submitReq.jobFile);
	    FREEUP(submitReq.inFile);
	    FREEUP(submitReq.outFile);
	    FREEUP(submitReq.errFile);
	    FREEUP(submitReq.inFileSpool);
	    FREEUP(submitReq.commandSpool);
	    FREEUP(submitReq.hostSpec);
	    FREEUP(submitReq.chkpntDir);
	    FREEUP(submitReq.subHomeDir);
	    FREEUP(jobInfoReply.userName);
	    FREEUP(submitReq.cwd);

	    free(buffer);
	    return NULL;
	}
	
	submitReq.xf = NULL;             
        submitReq.nxf = 0;
        jobInfoReply.numToHosts = 0;
        submitReq.numAskedHosts = 0;
        first = FALSE;
    }

    jobInfoReply.jobBill = &submitReq;

    if (jobInfoReply.numToHosts > 0) {   
	for (i=0; i<jobInfoReply.numToHosts; i++)
	    FREEUP(jobInfoReply.toHosts[i]);
        FREEUP(jobInfoReply.toHosts);
	jobInfoReply.numToHosts = 0;
	jobInfoReply.toHosts = NULL;
    }

    if (submitReq.xf) { 
	free(submitReq.xf);
        submitReq.xf = NULL;
    }

    
    FREEUP( jobInfoReply.execHome );
    FREEUP( jobInfoReply.execCwd );
    FREEUP( jobInfoReply.execUsername );
    FREEUP( jobInfoReply.parentGroup );
    FREEUP( jobInfoReply.jName );

    TIMEIT(1, xdrmem_create(&xdrs, buffer, XDR_DECODE_SIZE_(hdr.length), XDR_DECODE), "xdrmem_create");
    TIMEIT(1, (aa = xdr_jobInfoReply(&xdrs, &jobInfoReply, &hdr)), "xdr_jobInfoReply");
    if (aa == FALSE) {
	lsberrno = LSBE_XDR;
	xdr_destroy(&xdrs);
	free(buffer);
	jobInfoReply.toHosts = NULL; 
	jobInfoReply.numToHosts = 0;
	return NULL;
    }

    TIMEIT(1, xdr_destroy(&xdrs), "xdr_destroy");
    free(buffer);
    jobInfo.jobId = jobInfoReply.jobId;
    jobInfo.status = jobInfoReply.status;
    jobInfo.numReasons = jobInfoReply.numReasons;
    jobInfo.reasonTb = jobInfoReply.reasonTb;
    jobInfo.reasons = jobInfoReply.reasons;
    jobInfo.subreasons = jobInfoReply.subreasons;
    jobInfo.startTime = jobInfoReply.startTime;
    jobInfo.predictedStartTime = jobInfoReply.predictedStartTime;
    jobInfo.endTime  = jobInfoReply.endTime;
    jobInfo.cpuTime  = jobInfoReply.cpuTime;
    jobInfo.numExHosts = jobInfoReply.numToHosts;
    jobInfo.exHosts = jobInfoReply.toHosts;
    jobInfo.nIdx = jobInfoReply.nIdx;
    jobInfo.loadSched = jobInfoReply.loadSched;
    jobInfo.loadStop = jobInfoReply.loadStop;
    jobInfo.exitStatus = jobInfoReply.exitStatus;
    jobInfo.reserveTime = jobInfoReply.reserveTime;
    jobInfo.jobPid = jobInfoReply.jobPid;
    jobInfo.port = jobInfoReply.port;
    jobInfo.jobPriority = jobInfoReply.jobPriority; 

    jobInfo.user = jobInfoReply.userName;

    jobInfo.execUid = jobInfoReply.execUid;
    jobInfo.execHome = jobInfoReply.execHome;
    jobInfo.execCwd = jobInfoReply.execCwd;
    jobInfo.execUsername = jobInfoReply.execUsername;

    
    jobInfo.jType    = jobInfoReply.jType;
    jobInfo.parentGroup = jobInfoReply.parentGroup;
    jobInfo.jName        = jobInfoReply.jName;
    for (i=0; i<NUM_JGRP_COUNTERS; i++)
        jobInfo.counter[i] = jobInfoReply.counter[i];

    jobInfo.submitTime = jobInfoReply.jobBill->submitTime;
    jobInfo.umask = jobInfoReply.jobBill->umask;
    jobInfo.cwd = jobInfoReply.jobBill->cwd;
    jobInfo.subHomeDir = jobInfoReply.jobBill->subHomeDir;    
    jobInfo.submit.options = jobInfoReply.jobBill->options;
    jobInfo.submit.options2 = jobInfoReply.jobBill->options2;
    jobInfo.submit.numProcessors = jobInfoReply.jobBill->numProcessors;
    jobInfo.submit.maxNumProcessors = jobInfoReply.jobBill->maxNumProcessors;
    jobInfo.submit.jobName = jobInfoReply.jobBill->jobName;
    jobInfo.submit.command = jobInfoReply.jobBill->command;
    jobInfo.submit.resReq = jobInfoReply.jobBill->resReq;
    jobInfo.submit.queue = jobInfoReply.jobBill->queue;
    jobInfo.fromHost = jobInfoReply.jobBill->fromHost;
    jobInfo.submit.inFile = jobInfoReply.jobBill->inFile;
    jobInfo.submit.outFile = jobInfoReply.jobBill->outFile;
    jobInfo.submit.errFile = jobInfoReply.jobBill->errFile;
    jobInfo.submit.beginTime = jobInfoReply.jobBill->beginTime;
    jobInfo.submit.termTime = jobInfoReply.jobBill->termTime;
    jobInfo.submit.userPriority = jobInfoReply.jobBill->userPriority;

     
    for (i=0; i<LSF_RLIM_NLIMITS; i++) {
	jobInfo.submit.rLimits[i] = jobInfoReply.jobBill->rLimits[i];
    }
    jobInfo.submit.hostSpec = jobInfoReply.jobBill->hostSpec;
    jobInfo.submit.sigValue = jobInfoReply.jobBill->sigValue;
    jobInfo.submit.chkpntDir = jobInfoReply.jobBill->chkpntDir;
    jobInfo.submit.dependCond = jobInfoReply.jobBill->dependCond;
    jobInfo.submit.preExecCmd = jobInfoReply.jobBill->preExecCmd;
    jobInfo.submit.chkpntPeriod = jobInfoReply.jobBill->chkpntPeriod;
    jobInfo.submit.numAskedHosts = jobInfoReply.jobBill->numAskedHosts;
    jobInfo.submit.askedHosts = jobInfoReply.jobBill->askedHosts;
    jobInfo.submit.projectName = jobInfoReply.jobBill->projectName;
    jobInfo.submit.mailUser = jobInfoReply.jobBill->mailUser;
    jobInfo.submit.loginShell = jobInfoReply.jobBill->loginShell;
    jobInfo.submit.nxf = jobInfoReply.jobBill->nxf;
    jobInfo.submit.xf = jobInfoReply.jobBill->xf;

    

    jobInfo.jRusageUpdateTime = jobInfoReply.jRusageUpdateTime;
    jobInfo.runRusage.npids = npids;
    jobInfo.runRusage.pidInfo = pidInfo;

    jobInfo.runRusage.npgids = npgids;
    jobInfo.runRusage.pgid = pgid;

    copyJUsage(&(jobInfo.runRusage), &jobInfoReply.runRusage);

     
    npids = jobInfo.runRusage.npids;
    pidInfo = jobInfo.runRusage.pidInfo;

    npgids = jobInfo.runRusage.npgids;
    pgid = jobInfo.runRusage.pgid;
 

     
    if (jobInfoReply.runRusage.npids > 0) {
        FREEUP(jobInfoReply.runRusage.pidInfo); 
        jobInfoReply.runRusage.npids = 0;
    }

    if (jobInfoReply.runRusage.npgids > 0) {
        FREEUP(jobInfoReply.runRusage.pgid); 
        jobInfoReply.runRusage.npgids = 0;
    }

    if (more)
	*more = hdr.reserved;

    return &jobInfo;

} 
Example #9
0
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);
} 
Example #10
0
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;

}