自学教程：C++ CLEAR_HEAD函数代码示例

END_TESTSTART_TEST(send_job_over_network_test)  {  bool timeout = false;  char *jobid = strdup("1.napali");  char *destin = strdup("bob");  bool attempt_to_queue = true;  bool c = true;  tlist_head h;  int my_err;  int mom_err;  CLEAR_HEAD(h);  fail_unless(send_job_over_network(strdup("2.napali"), 5, destin, h, attempt_to_queue, c, timeout, "script", true, false, 10, strdup("/out"), strdup("/err"), strdup("/chkpt"), MOVE_TYPE_Exec, &my_err,&mom_err) == LOCUTION_FAIL);  CLEAR_HEAD(h);  fail_unless(send_job_over_network(jobid, 5, destin, h, attempt_to_queue, c, timeout, "script", true, false, 10, strdup("/out"), strdup("/err"), strdup("/chkpt"), MOVE_TYPE_Exec, &my_err,&mom_err) == PBSE_NONE);  fail_unless(attempt_to_queue == false);  fprintf(stderr,"%p %s/n",(void *)destin,destin);  CLEAR_HEAD(h);  rdycommit_fail = true;  fail_unless(send_job_over_network(jobid, 5, destin, h, attempt_to_queue, c, timeout, "script", true, false, 10, strdup("/out"), strdup("/err"), strdup("/chkpt"), MOVE_TYPE_Exec, &my_err,&mom_err) == LOCUTION_RETRY);  rdycommit_fail = false;  }

END_TESTSTART_TEST(add_node_attribute_to_list_test)  {  char  line[1024];  char *ptr;  tlist_head th;  int ret;  svrattrl *sattr;  CLEAR_HEAD(th);  // this should work and create the attribute np with the value of 100  snprintf(line, sizeof(line), "100");  ptr = line;  ret = add_node_attribute_to_list(strdup("np"), &ptr, &th, 1);  fail_unless(ret == PBSE_NONE);  sattr = (svrattrl *)GET_NEXT(th);   fail_unless(strcmp(sattr->al_name, "np") == 0);  fail_unless(strcmp(sattr->al_value, "100") == 0);  attrlist_free();  attrname.clear();  attrval.clear();  CLEAR_HEAD(th);  // this is invalid syntax  snprintf(line, sizeof(line), "100=");  ptr = line;  fail_unless(add_node_attribute_to_list(strdup("np"), &ptr, &th, 1) != PBSE_NONE);  CLEAR_HEAD(th);  // run over the two special cases  snprintf(line, sizeof(line), "100");  ptr = line;  fail_unless(add_node_attribute_to_list(strdup("TTL"), &ptr, &th, 1) == PBSE_NONE);  sattr = (svrattrl *)GET_NEXT(th);   fail_unless(strcmp(sattr->al_name, "TTL") == 0);  fail_unless(strcmp(sattr->al_value, "100") == 0);  attrlist_free();  attrname.clear();  attrval.clear();  CLEAR_HEAD(th);  snprintf(line, sizeof(line), "bob,tom");  ptr = line;  fail_unless(add_node_attribute_to_list(strdup("acl"), &ptr, &th, 1) == PBSE_NONE);  sattr = (svrattrl *)GET_NEXT(th);   fail_unless(strcmp(sattr->al_name, "acl") == 0);  fail_unless(strcmp(sattr->al_value, "bob,tom") == 0);  attrlist_free();  attrname.clear();  attrval.clear();  }

/** * @brief * 		status_sched - Build the status reply for single scheduler * * @param[in]	psched	-	ptr to sched receiving status query * @param[in]	preq	-	ptr to the decoded request * @param[out]	pstathd	-	head of list to append status to * * @return	int * @retval	0	: success * @retval	!0	: PBSE error code */static intstatus_sched(pbs_sched *psched, struct batch_request *preq, pbs_list_head *pstathd){	int		   rc = 0;	struct brp_status *pstat;	svrattrl	  *pal;	pstat = (struct brp_status *)malloc(sizeof(struct brp_status));	if (pstat == NULL)		return (PBSE_SYSTEM);	pstat->brp_objtype = MGR_OBJ_SCHED;	(void)strncpy(pstat->brp_objname, psched->sc_name, (PBS_MAXSVRJOBID > PBS_MAXDEST ?			PBS_MAXSVRJOBID : PBS_MAXDEST) -1);	pstat->brp_objname[(PBS_MAXSVRJOBID > PBS_MAXDEST ? PBS_MAXSVRJOBID : PBS_MAXDEST) - 1] = '/0';	CLEAR_LINK(pstat->brp_stlink);	CLEAR_HEAD(pstat->brp_attr);	append_link(pstathd, &pstat->brp_stlink, pstat);	bad = 0;	pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);	if (status_attrib(pal, sched_attr_def, psched->sch_attr, SCHED_ATR_LAST,		preq->rq_perm, &pstat->brp_attr, &bad))		reply_badattr(PBSE_NOATTR, bad, pal, preq);	return (rc);}

void clear_attr(    pbs_attribute *pattr, /* O */    attribute_def *pdef)  /* I */  {#ifndef NDEBUG  if (pdef == NULL)    {    fprintf(stderr, "Assertion failed, bad pdef in clear_attr/n");    abort();    }#endif /* NDEBUG */  memset(pattr, 0, sizeof(pbs_attribute));  pattr->at_type = pdef->at_type;  if ((pattr->at_type == ATR_TYPE_RESC) ||      (pattr->at_type == ATR_TYPE_LIST))    {    CLEAR_HEAD(pattr->at_val.at_list);    }  return;  }

END_TESTSTART_TEST(tm_spawn_request_test)  {  struct tcp_chan test_chan;  struct job test_job;  struct hnodent test_hnodent;  char *test_cookie = strdup("cookie");  int reply = 0;  int ret = 0;  int result = 0;  memset(&test_chan, 0, sizeof(test_chan));  memset(&test_job, 0, sizeof(test_job));  memset(&test_hnodent, 0, sizeof(test_hnodent));  test_job.ji_vnods = (vnodent *)calloc(3, sizeof(vnodent));  CLEAR_HEAD(test_job.ji_tasks);  result = tm_spawn_request(&test_chan,                            &test_job,                            0,                            0,                            (char *)test_cookie,                            &reply,                            &ret,                            0,                            &test_hnodent,                            0);  fail_unless(result == TM_DONE, "tm_spawn_request fail: %d", result);  }

int status_job(  job                  *pjob,    /* ptr to job to status */  struct batch_request *preq,  svrattrl             *pal,     /* specific attributes to status */  tlist_head           *pstathd, /* RETURN: head of list to append status to */  int                  *bad)     /* RETURN: index of first bad pbs_attribute */  {  struct brp_status *pstat;  int                IsOwner = 0;  long               query_others = 0;  /* see if the client is authorized to status this job */  if (svr_authorize_jobreq(preq, pjob) == 0)    IsOwner = 1;  get_svr_attr_l(SRV_ATR_query_others, &query_others);  if (!query_others)    {    if (IsOwner == 0)      {      return(PBSE_PERM);      }    }  /* allocate reply structure and fill in header portion */  if ((pstat = calloc(1, sizeof(struct brp_status))) == NULL)    {    return(PBSE_SYSTEM);    }  CLEAR_LINK(pstat->brp_stlink);  pstat->brp_objtype = MGR_OBJ_JOB;  strcpy(pstat->brp_objname, pjob->ji_qs.ji_jobid);  CLEAR_HEAD(pstat->brp_attr);  append_link(pstathd, &pstat->brp_stlink, pstat);  /* add attributes to the status reply */  *bad = 0;  if (status_attrib(        pal,        job_attr_def,        pjob->ji_wattr,        JOB_ATR_LAST,        preq->rq_perm,        &pstat->brp_attr,        bad,        IsOwner))    {    return(PBSE_NOATTR);    }  return (0);  }  /* END status_job() */

intdecode_unkn(struct attribute *patr, char *name, char *rescn, char *value){	svrattrl *entry;	size_t	     valln;	if (patr == NULL)		return (PBSE_INTERNAL);	if (!(patr->at_flags & ATR_VFLAG_SET))		CLEAR_HEAD(patr->at_val.at_list);	if (name == NULL)		return (PBSE_INTERNAL);	if (value == NULL)		valln = 0;	else		valln = strlen(value) + 1;	entry = attrlist_create(name, rescn, valln);	if (entry == NULL)		return (PBSE_SYSTEM);	if (valln)		memcpy(entry->al_value, value, valln);	append_link(&patr->at_val.at_list, &entry->al_link, entry);	patr->at_flags |= ATR_VFLAG_SET | ATR_VFLAG_MODIFY | ATR_VFLAG_MODCACHE;	return (0);}

END_TESTSTART_TEST(clear_depend_test)  {  struct depend pd;  i = 1;  clear_depend(&pd, 0, 0);  fail_unless(pd.dp_type == 0, "type not set");  fail_unless(pd.dp_numexp == 0, "attr not set correctly");  fail_unless(pd.dp_numreg == 0, "attr not set correctly");  fail_unless(pd.dp_released == 0, "attr not set correctly");    i = 1;  memset(&pd, 0, sizeof(pd));  CLEAR_HEAD(pd.dp_jobs);  make_dependjob(&pd, job1, host);  make_dependjob(&pd, job2, host);  clear_depend(&pd, 0, 1);  fail_unless(pd.dp_type == 0, "type not set");  fail_unless(pd.dp_numexp == 0, "attr not set correctly");  fail_unless(pd.dp_numreg == 0, "attr not set correctly");  fail_unless(pd.dp_released == 0, "attr not set correctly");  }

job *job_alloc(void)  {  job *pj;  pj = (job *)calloc(1, sizeof(job));  if (pj == NULL)    {    log_err(errno, "job_alloc", (char *)"no memory");    return(NULL);    }  pj->ji_qs.qs_version = PBS_QS_VERSION;  CLEAR_LINK(pj->ji_alljobs);  CLEAR_LINK(pj->ji_jobque);  CLEAR_HEAD(pj->ji_tasks);  pj->ji_taskid = TM_NULL_TASK + 1;  pj->ji_obit = TM_NULL_EVENT;  pj->ji_nodekill = TM_ERROR_NODE;  pj->ji_momhandle = -1;  /* mark mom connection invalid */  /* set the working attributes to "unspecified" */  job_init_wattr(pj);  return(pj);  }  /* END job_alloc() */

pbs_queue *que_alloc(char *name){	int        i;	pbs_queue *pq;	pq = (pbs_queue *)malloc(sizeof(pbs_queue));	if (pq == (pbs_queue *)0) {		log_err(errno, "que_alloc", "no memory");		return ((pbs_queue *)0);	}	(void)memset((char *)pq, (int)0, (size_t)sizeof(pbs_queue));	pq->qu_qs.qu_type = QTYPE_Unset;	CLEAR_HEAD(pq->qu_jobs);	CLEAR_LINK(pq->qu_link);	strncpy(pq->qu_qs.qu_name, name, PBS_MAXQUEUENAME);	append_link(&svr_queues, &pq->qu_link, pq);	server.sv_qs.sv_numque++;	/* set the working attributes to "unspecified" */	for (i=0; i<(int)QA_ATR_LAST; i++) {		clear_attr(&pq->qu_attr[i], &que_attr_def[i]);	}	return (pq);}

voidreq_stat_svr(struct batch_request *preq){	svrattrl	   *pal;	struct batch_reply *preply;	struct brp_status  *pstat;	/* update count and state counts from sv_numjobs and sv_jobstates */	server.sv_attr[(int)SRV_ATR_TotalJobs].at_val.at_long = server.sv_qs.sv_numjobs;	server.sv_attr[(int)SRV_ATR_TotalJobs].at_flags |= ATR_VFLAG_SET|ATR_VFLAG_MODCACHE;	update_state_ct(&server.sv_attr[(int)SRV_ATR_JobsByState],		server.sv_jobstates,		server.sv_jobstbuf);	update_license_ct(&server.sv_attr[(int)SRV_ATR_license_count],		server.sv_license_ct_buf);	/* allocate a reply structure and a status sub-structure */	preply = &preq->rq_reply;	preply->brp_choice = BATCH_REPLY_CHOICE_Status;	CLEAR_HEAD(preply->brp_un.brp_status);	pstat = (struct brp_status *)malloc(sizeof(struct brp_status));	if (pstat == NULL) {		reply_free(preply);		req_reject(PBSE_SYSTEM, 0, preq);		return;	}	CLEAR_LINK(pstat->brp_stlink);	(void)strcpy(pstat->brp_objname, server_name);	pstat->brp_objtype = MGR_OBJ_SERVER;	CLEAR_HEAD(pstat->brp_attr);	append_link(&preply->brp_un.brp_status, &pstat->brp_stlink, pstat);	/* add attributes to the status reply */	bad = 0;	pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);	if (status_attrib(pal, svr_attr_def, server.sv_attr, SRV_ATR_LAST,		preq->rq_perm, &pstat->brp_attr, &bad))		reply_badattr(PBSE_NOATTR, bad, pal, preq);	else		(void)reply_send(preq);}

int add_encoded_attributes(  xmlNodePtr *attr_node,   /* M attribute node */   pbs_attribute  *pattr)   /* M ptr to pbs_attribute value array */  {  tlist_head  lhead;  int         i;  int         resc_access_perm = ATR_DFLAG_ACCESS;  svrattrl   *pal;  int         rc = PBSE_NONE;  xmlNodePtr  attributeNode = *attr_node;  char        buf[BUFSIZE];  xmlNodePtr  pal_xmlNode;  CLEAR_HEAD(lhead);  xmlNodePtr  resource_list_head_node = NULL;  xmlNodePtr  resource_used_head_node = NULL;  for (i = 0; ((i < JOB_ATR_LAST) && (rc >= 0)); i++)    {    if (job_attr_def[i].at_type != ATR_TYPE_ACL)      if ((pattr + i)->at_flags & ATR_VFLAG_SET)        {        rc = job_attr_def[i].at_encode(        pattr + i,        &lhead,        job_attr_def[i].at_name,        NULL,        ATR_ENCODE_SAVE,        resc_access_perm);        (pattr + i)->at_flags &= ~ATR_VFLAG_MODIFY;        if (rc < 0)          return -1;        while ((pal = (svrattrl *)GET_NEXT(lhead)) != NULL)          {          if (!strcmp(ATTR_l, pal->al_atopl.name))             pal_xmlNode = add_resouce_list_attribute(ATTR_l, attr_node, &resource_list_head_node, pal);          else if (!strcmp(ATTR_used, pal->al_atopl.name))             pal_xmlNode = add_resouce_list_attribute(ATTR_used, attr_node, &resource_used_head_node, pal);          else             pal_xmlNode = xmlNewChild(attributeNode, NULL, (xmlChar *)pal->al_atopl.name, (xmlChar *)pal->al_atopl.value);            if (pal_xmlNode)              {              snprintf(buf, sizeof(buf), "%u", (unsigned int)pal->al_flags);              xmlSetProp(pal_xmlNode, (const xmlChar *)AL_FLAGS_ATTR, (const xmlChar *)buf);              }            delete_link(&pal->al_link);            free(pal);            if (!pal_xmlNode)              rc = -1;          }        }    }  return (0);  } /* END add_encoded_attributes */

void initialize_depend_attr(  pbs_attribute *pattr)  {  memset(pattr, 0, sizeof(pbs_attribute));  CLEAR_HEAD(pattr->at_val.at_list);  } /* END initialize_depend_attr() */

voidreq_stat_que(struct batch_request *preq){	char		   *name;	pbs_queue	   *pque;	struct batch_reply *preply;	int		    rc   = 0;	int		    type = 0;	/*	 * first, validate the name of the requested object, either	 * a queue, or null for all queues	 */	name = preq->rq_ind.rq_status.rq_id;	if ((*name == '/0') || (*name =='@'))		type = 1;	else {		pque = find_queuebyname(name);#ifdef NAS /* localmod 075 */		if (pque == NULL)			pque = find_resvqueuebyname(name);#endif /* localmod 075 */		if (pque == NULL) {			req_reject(PBSE_UNKQUE, 0, preq);			return;		}	}	preply = &preq->rq_reply;	preply->brp_choice = BATCH_REPLY_CHOICE_Status;	CLEAR_HEAD(preply->brp_un.brp_status);	if (type == 0) {	/* get status of the one named queue */		rc = status_que(pque, preq, &preply->brp_un.brp_status);	} else {	/* get status of queues */		pque = (pbs_queue *)GET_NEXT(svr_queues);		while (pque) {			rc = status_que(pque, preq, &preply->brp_un.brp_status);			if (rc != 0) {				if (rc == PBSE_PERM)					rc = 0;				else					break;			}			pque = (pbs_queue *)GET_NEXT(pque->qu_link);		}	}	if (rc) {		(void)reply_free(preply);		req_reject(rc, bad, preq);	} else {		(void)reply_send(preq);	}}

int release_array_range(  job_array            *pa,  struct batch_request *preq,  char                 *range_str)  {  tlist_head tl;  int i;  int rc;  array_request_node *rn;  array_request_node *to_free;    char *range = strchr(range_str,'=');  if (range == NULL)    return(PBSE_IVALREQ);  range++; /* move past the '=' */    CLEAR_HEAD(tl);    if (parse_array_request(range,&tl) > 0)    {    /* don't hold the jobs if range error */        return(PBSE_IVALREQ);    }    /* hold just that range from the array */  rn = (array_request_node*)GET_NEXT(tl);    while (rn != NULL)    {    for (i = rn->start; i <= rn->end; i++)      {      if (pa->jobs[i] == NULL)        continue;            /* don't stomp on other memory */      if (i >= pa->ai_qs.array_size)        continue;            if ((rc = release_job(preq,pa->jobs[i])))        return(rc);      }        /* release mem */    to_free = rn;    rn = (array_request_node*)GET_NEXT(rn->request_tokens_link);    free(to_free);    }  return(0);  } /* END release_array_range() */

/* * hold_array_range() *  * holds just a specified range from an array * @param pa - the array to be acted on * @param range_str - string specifying the range  */int hold_array_range(  job_array *pa,         /* O */  char      *range_str,  /* I */  attribute *temphold)   /* I */  {  tlist_head tl;  int i;  array_request_node *rn;  array_request_node *to_free;    char *range = strchr(range_str,'=');  if (range == NULL)    return(PBSE_IVALREQ);  range++; /* move past the '=' */    CLEAR_HEAD(tl);    if (parse_array_request(range,&tl) > 0)    {    /* don't hold the jobs if range error */        return(PBSE_IVALREQ);    }  else     {    /* hold just that range from the array */    rn = (array_request_node*)GET_NEXT(tl);        while (rn != NULL)      {      for (i = rn->start; i <= rn->end; i++)        {        if (pa->jobs[i] == NULL)          continue;                /* don't stomp on other memory */        if (i >= pa->ai_qs.array_size)          continue;                hold_job(temphold,pa->jobs[i]);        }            /* release mem */      to_free = rn;      rn = (array_request_node*)GET_NEXT(rn->request_tokens_link);      free(to_free);      }    }  return(0);  } /* END hold_array_range() */

voidreq_stat_resv(struct batch_request * preq){	char		   *name;	struct batch_reply *preply;	resc_resv	   *presv = NULL;	int		    rc   = 0;	int		    type = 0;	/*	 * first, validate the name sent in the request.	 * This is either the ID of a specific reservation	 * or a '/0' or "@..." for all reservations.	 */	name = preq->rq_ind.rq_status.rq_id;	if ((*name == '/0') || (*name =='@'))		type = 1;	else {		presv = find_resv(name);		if (presv == NULL) {			req_reject(PBSE_UNKRESVID, 0, preq);			return;		}	}	preply = &preq->rq_reply;	preply->brp_choice = BATCH_REPLY_CHOICE_Status;	CLEAR_HEAD(preply->brp_un.brp_status);	if (type == 0) {		/* get status of the specifically named reservation */		rc = status_resv(presv, preq, &preply->brp_un.brp_status);	} else {		/* get status of all the reservations */		presv = (resc_resv *)GET_NEXT(svr_allresvs);		while (presv) {			rc = status_resv(presv, preq, &preply->brp_un.brp_status);			if (rc == PBSE_PERM)				rc = 0;			if (rc)				break;			presv = (resc_resv *)GET_NEXT(presv->ri_allresvs);		}	}	if (rc == 0)		(void)reply_send(preq);	else		req_reject(rc, bad, preq);}

void clear_attr(pbs_attribute *pattr, attribute_def *pdef)  {  memset(pattr, 0, sizeof(pbs_attribute));  pattr->at_type = pdef->at_type;  if ((pattr->at_type == ATR_TYPE_RESC) ||      (pattr->at_type == ATR_TYPE_LIST))    {    CLEAR_HEAD(pattr->at_val.at_list);    }  }

intdecode_DIS_QueueJob(int sock, struct batch_request *preq){	int rc;	CLEAR_HEAD(preq->rq_ind.rq_queuejob.rq_attr);	rc = disrfst(sock, PBS_MAXSVRJOBID+1, preq->rq_ind.rq_queuejob.rq_jid);	if (rc) return rc;	rc = disrfst(sock, PBS_MAXSVRJOBID+1, preq->rq_ind.rq_queuejob.rq_destin);	if (rc) return rc;	return (decode_DIS_svrattrl(sock, &preq->rq_ind.rq_queuejob.rq_attr));}

intdecode_DIS_Status(int sock, struct batch_request *preq)  {  int rc;  CLEAR_HEAD(preq->rq_ind.rq_status.rq_attr);  rc = disrfst(sock,               (PBS_MAXSVRJOBID > PBS_MAXDEST ? PBS_MAXSVRJOBID : PBS_MAXDEST) + 1,               preq->rq_ind.rq_status.rq_id);  if (rc) return rc;  rc = decode_DIS_svrattrl(sock, &preq->rq_ind.rq_status.rq_attr);  return rc;  }

END_TESTSTART_TEST(set_array_depend_holds_test)  {  batch_request *preq = (batch_request *)calloc(1, sizeof(batch_request));  job_array     *pa = (job_array *)calloc(1, sizeof(job_array));  strcpy(preq->rq_ind.rq_register.rq_child, job1);  strcpy(preq->rq_ind.rq_register.rq_svr, host);  CLEAR_HEAD(pa->ai_qs.deps);  fail_unless(register_array_depend(pa, preq, JOB_DEPEND_TYPE_AFTEROKARRAY, 10) == PBSE_NONE);  pa->ai_qs.num_successful = 12;  fail_unless(set_array_depend_holds(pa) == true);  }

intshutdown_preempt_chkpt(job *pjob){	struct batch_request *phold;	attribute temp;	void (*func)(struct work_task *);	long *hold_val = NULL;	long old_hold = 0;	phold = alloc_br(PBS_BATCH_HoldJob);	if (phold == NULL)		return (PBSE_SYSTEM);	temp.at_flags = ATR_VFLAG_SET;	temp.at_type  = job_attr_def[(int)JOB_ATR_hold].at_type;	temp.at_user_encoded = NULL;	temp.at_priv_encoded = NULL;	temp.at_val.at_long = HOLD_s;	phold->rq_perm = ATR_DFLAG_MGRD | ATR_DFLAG_MGWR;	(void)strcpy(phold->rq_ind.rq_hold.rq_orig.rq_objname, pjob->ji_qs.ji_jobid);	CLEAR_HEAD(phold->rq_ind.rq_hold.rq_orig.rq_attr);	if (job_attr_def[(int)JOB_ATR_hold].at_encode(&temp,		&phold->rq_ind.rq_hold.rq_orig.rq_attr,		job_attr_def[(int)JOB_ATR_hold].at_name,		NULL,		ATR_ENCODE_CLIENT, NULL) < 0)		return (PBSE_SYSTEM);	phold->rq_extra = pjob;	func = post_chkpt;	if (relay_to_mom(pjob, phold, func) == 0) {		if (pjob->ji_qs.ji_state == JOB_STATE_TRANSIT)			svr_setjobstate(pjob, JOB_STATE_RUNNING, JOB_SUBSTATE_RUNNING);		pjob->ji_qs.ji_svrflags |= (JOB_SVFLG_HASRUN | JOB_SVFLG_CHKPT | JOB_SVFLG_HASHOLD);		pjob->ji_modified = 1;		(void)job_save(pjob, SAVEJOB_QUICK);		return (0);	} else {		*hold_val = old_hold;	/* reset to the old value */		return (-1);	}}

static intstatus_que(pbs_queue *pque, struct batch_request *preq, pbs_list_head *pstathd){	struct brp_status *pstat;	svrattrl	  *pal;	if ((preq->rq_perm & ATR_DFLAG_RDACC) == 0)		return (PBSE_PERM);	/* ok going to do status, update count and state counts from qu_qs */	if (!svr_chk_history_conf()) {		pque->qu_attr[(int)QA_ATR_TotalJobs].at_val.at_long = pque->qu_numjobs;	} else {		pque->qu_attr[(int)QA_ATR_TotalJobs].at_val.at_long = pque->qu_numjobs -			(pque->qu_njstate[JOB_STATE_MOVED] + pque->qu_njstate[JOB_STATE_FINISHED]);	}	pque->qu_attr[(int)QA_ATR_TotalJobs].at_flags |= ATR_VFLAG_SET|ATR_VFLAG_MODCACHE;	update_state_ct(&pque->qu_attr[(int)QA_ATR_JobsByState],		pque->qu_njstate,		pque->qu_jobstbuf);	/* allocate status sub-structure and fill in header portion */	pstat = (struct brp_status *)malloc(sizeof(struct brp_status));	if (pstat == NULL)		return (PBSE_SYSTEM);	pstat->brp_objtype = MGR_OBJ_QUEUE;	(void)strcpy(pstat->brp_objname, pque->qu_qs.qu_name);	CLEAR_LINK(pstat->brp_stlink);	CLEAR_HEAD(pstat->brp_attr);	append_link(pstathd, &pstat->brp_stlink, pstat);	/* add attributes to the status reply */	bad = 0;	pal = (svrattrl *)GET_NEXT(preq->rq_ind.rq_status.rq_attr);	if (status_attrib(pal, que_attr_def, pque->qu_attr, QA_ATR_LAST,		preq->rq_perm, &pstat->brp_attr, &bad))		return (PBSE_NOATTR);	return (0);}

job *job_alloc(void)  {  job *pj;  pj = (job *)calloc(1, sizeof(job));  if (pj == NULL)    {    log_err(errno, "job_alloc", "no memory");    return(NULL);    }  pj->ji_qs.qs_version = PBS_QS_VERSION;  CLEAR_LINK(pj->ji_alljobs);  CLEAR_LINK(pj->ji_jobque);  CLEAR_HEAD(pj->ji_tasks);  pj->ji_taskid = TM_NULL_TASK + 1;  pj->ji_numnodes = 0;  pj->ji_numvnod  = 0;  pj->ji_hosts = NULL;  pj->ji_vnods = NULL;  pj->ji_resources = NULL;  pj->ji_obit = TM_NULL_EVENT;  pj->ji_preq = NULL;  pj->ji_nodekill = TM_ERROR_NODE;  pj->ji_flags = 0;  pj->ji_globid = NULL;  pj->ji_stdout = 0;  pj->ji_stderr = 0;  pj->ji_qs.ji_un.ji_momt.ji_exitstat = 0;  pj->ji_job_is_being_rerun = 0;  pj->ji_momhandle = -1;  /* mark mom connection invalid */  /* set the working attributes to "unspecified" */  job_init_wattr(pj);  return(pj);  }  /* END job_alloc() */