void *req_modifyjob(
batch_request *preq) /* I */
{
job *pjob;
svrattrl *plist;
char log_buf[LOCAL_LOG_BUF_SIZE];
pjob = chk_job_request(preq->rq_ind.rq_modify.rq_objname, preq);
if (pjob == NULL)
{
return(NULL);
}
mutex_mgr job_mutex(pjob->ji_mutex, true);
plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr);
if (plist == NULL)
{
/* nothing to do */
reply_ack(preq);
/* SUCCESS */
return(NULL);
}
job_mutex.unlock();
/* If async modify, reply now; otherwise reply is handled later */
if (preq->rq_type == PBS_BATCH_AsyModifyJob)
{
/* reply_ack will free preq. We need to copy it before we call reply_ack */
batch_request *new_preq;
new_preq = duplicate_request(preq, -1);
if (new_preq == NULL)
{
sprintf(log_buf, "failed to duplicate batch request");
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, log_buf);
return(NULL);
}
get_batch_request_id(new_preq);
reply_ack(preq);
new_preq->rq_noreply = TRUE; /* set for no more replies */
enqueue_threadpool_request((void *(*)(void *))modify_job_work, new_preq);
}
else
modify_job_work(preq);
return(NULL);
} /* END req_modifyjob() */
void process_checkpoint_reply(
batch_request *preq)
{
job *pjob;
/* preq handled previously */
if (preq == NULL)
return;
preq->rq_conn = preq->rq_orgconn; /* restore client socket */
if ((pjob = svr_find_job(preq->rq_ind.rq_manager.rq_objname, FALSE)) == NULL)
{
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB,
preq->rq_ind.rq_manager.rq_objname,
msg_postmomnojob);
req_reject(PBSE_UNKJOBID, 0, preq, NULL, msg_postmomnojob);
}
else
{
mutex_mgr job_mutex = mutex_mgr(pjob->ji_mutex, true);
/* record that MOM has a checkpoint file */
account_record(PBS_ACCT_CHKPNT, pjob, "Checkpointed"); /* note in accounting file */
reply_ack(preq);
}
} /* END process_checkpoint_reply() */
int req_releasejob(
batch_request *vp) /* I */
{
job *pjob;
int rc;
batch_request *preq = (batch_request *)vp;
pjob = chk_job_request(preq->rq_ind.rq_release.rq_objname, preq);
if (pjob == NULL)
{
return(PBSE_NONE);
}
mutex_mgr job_mutex(pjob->ji_mutex, true);
if ((rc = release_job(preq, pjob, NULL)) != 0)
{
req_reject(rc,0,preq,NULL,NULL);
}
else
{
reply_ack(preq);
}
return(PBSE_NONE);
} /* END req_releasejob() */
void *single_delete_work(
void *vp)
{
int rc = -1;
batch_request *preq = (batch_request *)vp;
char *jobid = preq->rq_ind.rq_delete.rq_objname;
job *pjob;
char *Msg = preq->rq_extend;
pjob = svr_find_job(jobid, FALSE);
if (pjob == NULL)
{
req_reject(PBSE_JOBNOTFOUND, 0, preq, NULL, "job unexpectedly deleted");
}
else
{
/* mutex is freed below */
if ((rc = forced_jobpurge(pjob, preq)) == PBSE_NONE)
rc = execute_job_delete(pjob, Msg, preq);
if ((rc == PBSE_NONE) ||
(rc == PURGE_SUCCESS))
reply_ack(preq);
}
return(NULL);
} /* END single_delete_work() */
int handle_single_delete(
struct batch_request *preq,
struct batch_request *preq_tmp,
char *Msg)
{
char *jobid = preq->rq_ind.rq_delete.rq_objname;
job *pjob = svr_find_job(jobid, FALSE);
if (pjob == NULL)
{
log_event(PBSEVENT_DEBUG,PBS_EVENTCLASS_JOB,jobid,pbse_to_txt(PBSE_UNKJOBID));
req_reject(PBSE_UNKJOBID, 0, preq, NULL, "cannot locate job");
}
else
{
unlock_ji_mutex(pjob, __func__, NULL, 0);
/* send the asynchronous reply if needed */
if (preq_tmp != NULL)
{
reply_ack(preq_tmp);
preq->rq_noreply = TRUE; /* set for no more replies */
enqueue_threadpool_request(single_delete_work, preq);
}
else
single_delete_work(preq);
}
return(PBSE_NONE);
} /* END handle_single_delete() */
static void post_message_req(
struct work_task *pwt)
{
struct batch_request *preq;
char log_buf[LOCAL_LOG_BUF_SIZE];
svr_disconnect(pwt->wt_event); /* close connection to MOM */
preq = get_remove_batch_request(pwt->wt_parm1);
free(pwt->wt_mutex);
free(pwt);
/* preq has been hadnled previously */
if (preq == NULL)
return;
preq->rq_conn = preq->rq_orgconn; /* restore socket to client */
sprintf(log_buf, msg_messagejob, preq->rq_reply.brp_code);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, preq->rq_ind.rq_message.rq_jid, log_buf);
if (preq->rq_reply.brp_code)
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, NULL);
else
reply_ack(preq);
} /* END post_message_req() */
int req_releasejob(
void *vp) /* ptr to the decoded request */
{
job *pjob;
int rc;
struct batch_request *preq = (struct batch_request *)vp;
pjob = chk_job_request(preq->rq_ind.rq_release.rq_objname, preq);
if (pjob == NULL)
{
return(PBSE_NONE);
}
if ((rc = release_job(preq,pjob)) != 0)
{
req_reject(rc,0,preq,NULL,NULL);
}
else
{
reply_ack(preq);
}
unlock_ji_mutex(pjob, __func__, (char *)"1", LOGLEVEL);
return(PBSE_NONE);
} /* END req_releasejob() */
void *single_delete_work(
void *vp)
{
int rc = -1;
batch_request *preq = (batch_request *)vp;
char *jobid = preq->rq_ind.rq_delete.rq_objname;
job *pjob;
char *Msg = preq->rq_extend;
// TRUE is the same for non-heterogeneous jobs as FALSE. For heterogeneous
// jobs simply delete one to trigger the other being deleted as well.
pjob = svr_find_job(jobid, TRUE);
if (pjob == NULL)
{
req_reject(PBSE_JOBNOTFOUND, 0, preq, NULL, "job unexpectedly deleted");
}
else
{
/* mutex is freed below */
if ((rc = forced_jobpurge(pjob, preq)) == PBSE_NONE)
rc = execute_job_delete(pjob, Msg, preq);
if ((rc == PBSE_NONE) ||
(rc == PURGE_SUCCESS))
reply_ack(preq);
}
return(NULL);
} /* END single_delete_work() */
static void post_modify_req(
struct work_task *pwt)
{
struct batch_request *preq;
job *pjob;
svr_disconnect(pwt->wt_event); /* close connection to MOM */
preq = pwt->wt_parm1;
preq->rq_conn = preq->rq_orgconn; /* restore socket to client */
if ((preq->rq_reply.brp_code) && (preq->rq_reply.brp_code != PBSE_UNKJOBID))
{
sprintf(log_buffer, msg_mombadmodify, preq->rq_reply.brp_code);
log_event(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
preq->rq_ind.rq_modify.rq_objname,
log_buffer);
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, NULL);
}
else
{
if (preq->rq_reply.brp_code == PBSE_UNKJOBID)
{
if ((pjob = find_job(preq->rq_ind.rq_modify.rq_objname)) == NULL)
{
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, NULL);
return;
}
else
{
if (LOGLEVEL >= 0)
{
sprintf(log_buffer, "post_modify_req: PBSE_UNKJOBID for job %s in state %s-%s, dest = %s",
(pjob->ji_qs.ji_jobid != NULL) ? pjob->ji_qs.ji_jobid : "",
PJobState[pjob->ji_qs.ji_state],
PJobSubState[pjob->ji_qs.ji_substate],
pjob->ji_qs.ji_destin);
LOG_EVENT(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
pjob->ji_qs.ji_jobid,
log_buffer);
}
}
}
reply_ack(preq);
}
return;
} /* END post_modify_req() */
void *req_modifyarray(
batch_request *vp) /* I */
{
job_array *pa;
struct batch_request *preq = (struct batch_request *)vp;
pa = get_array(preq->rq_ind.rq_modify.rq_objname);
if (pa == NULL)
{
req_reject(PBSE_UNKARRAYID, 0, preq, NULL, "unable to find array");
return(NULL);
}
unlock_ai_mutex(pa, __func__, "4", LOGLEVEL);
/* If async modify, reply now; otherwise reply is handled later */
if (preq->rq_type == PBS_BATCH_AsyModifyJob)
{
preq->rq_noreply = TRUE; /* set for no more replies */
reply_ack(preq);
enqueue_threadpool_request(modify_array_work, preq);
}
else
modify_array_work(preq);
return(NULL);
} /* END req_modifyarray() */
static void process_checkpoint_reply(
struct work_task *pwt)
{
job *pjob;
struct batch_request *preq;
svr_disconnect(pwt->wt_event); /* close connection to MOM */
preq = pwt->wt_parm1;
preq->rq_conn = preq->rq_orgconn; /* restore client socket */
if ((pjob = find_job(preq->rq_ind.rq_manager.rq_objname)) == (job *)0)
{
LOG_EVENT(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB,
preq->rq_ind.rq_manager.rq_objname,
msg_postmomnojob);
req_reject(PBSE_UNKJOBID, 0, preq, NULL, msg_postmomnojob);
}
else
{
/* record that MOM has a checkpoint file */
account_record(PBS_ACCT_CHKPNT, pjob, "Checkpointed"); /* note in accounting file */
reply_ack(preq);
}
}
int handle_requeue_all(
batch_request *preq)
{
int rc;
job *pjob;
all_jobs_iterator *iter;
if ((preq->rq_perm & (ATR_DFLAG_MGWR)) == 0)
{
rc = PBSE_PERM;
req_reject(rc, 0, preq, NULL, "You must be a manager to requeue all jobs");
return(rc);
}
alljobs.lock();
iter = alljobs.get_iterator();
alljobs.unlock();
while ((pjob = next_job(&alljobs, iter)) != NULL)
{
mutex_mgr job_mutex(pjob->ji_mutex, true);
requeue_job_without_contacting_mom(*pjob);
}
delete iter;
reply_ack(preq);
return(PBSE_NONE);
} /* END handle_requeue_all() */
void
req_authenResvPort(struct batch_request *preq)
{
pbs_net_t req_addr;
conn_t *cp;
uint authrequest_port = preq->rq_ind.rq_authen_resvport.rq_port;
cp = get_conn(preq->rq_conn);
if (!cp) {
req_reject(PBSE_SYSTEM, 0, preq);
return;
}
req_addr = cp->cn_addr;
/*
* find the socket whose client side is bound to the port named
* in the request
*/
for (cp = (conn_t *)GET_NEXT(svr_allconns); cp; cp = GET_NEXT(cp->cn_link)) {
if (authrequest_port == cp->cn_port && req_addr == cp->cn_addr) {
if ((cp->cn_authen & (PBS_NET_CONN_AUTHENTICATED | PBS_NET_CONN_FROM_PRIVIL)) == 0) {
(void) strcpy(cp->cn_username, preq->rq_user);
(void)strcpy(cp->cn_hostname, preq->rq_host);
/* time stamp just for the record */
cp->cn_timestamp = time_now;
cp->cn_authen |= PBS_NET_CONN_AUTHENTICATED;
}
reply_ack(preq);
return;
}
}
req_reject(PBSE_BADCRED, 0, preq);
}
void
shutdown_ack()
{
if (pshutdown_request) {
reply_ack(pshutdown_request);
pshutdown_request = 0;
}
}
static int svr_stagein(
job *pjob, /* I */
struct batch_request *preq, /* I */
int state, /* I */
int substate) /* I */
{
struct batch_request *momreq = 0;
int rc;
momreq = cpy_stage(momreq, pjob, JOB_ATR_stagein, STAGE_DIR_IN);
if (momreq == NULL)
{
/* no files to stage, go directly to sending job to mom */
return(svr_strtjob2(pjob, preq));
}
/* have files to stage in */
/* save job id for post_stagein */
momreq->rq_extra = malloc(PBS_MAXSVRJOBID + 1);
if (momreq->rq_extra == 0)
{
return(PBSE_SYSTEM);
}
strcpy(momreq->rq_extra, pjob->ji_qs.ji_jobid);
rc = relay_to_mom(
pjob->ji_qs.ji_un.ji_exect.ji_momaddr,
momreq,
post_stagein);
if (rc == 0)
{
svr_setjobstate(pjob, state, substate);
/*
* stage-in started ok - reply to client as copy may
* take too long to wait.
*/
if (preq != NULL)
reply_ack(preq);
}
else
{
free(momreq->rq_extra);
}
return(rc);
} /* END svr_stagein() */
void *req_modifyjob(
batch_request *preq) /* I */
{
job *pjob;
svrattrl *plist;
pjob = chk_job_request(preq->rq_ind.rq_modify.rq_objname, preq);
if (pjob == NULL)
{
return(NULL);
}
mutex_mgr job_mutex(pjob->ji_mutex, true);
plist = (svrattrl *)GET_NEXT(preq->rq_ind.rq_modify.rq_attr);
if (plist == NULL)
{
/* nothing to do */
reply_ack(preq);
/* SUCCESS */
return(NULL);
}
job_mutex.unlock();
/* If async modify, reply now; otherwise reply is handled later */
if (preq->rq_type == PBS_BATCH_AsyModifyJob)
{
reply_ack(preq);
preq->rq_noreply = TRUE; /* set for no more replies */
enqueue_threadpool_request((void *(*)(void *))modify_job_work, preq);
}
else
modify_job_work(preq);
return(NULL);
} /* END req_modifyjob() */
void post_modify_req(
batch_request *preq)
{
job *pjob;
char log_buf[LOCAL_LOG_BUF_SIZE];
if (preq == NULL)
return;
preq->rq_conn = preq->rq_orgconn; /* restore socket to client */
if ((preq->rq_reply.brp_code) && (preq->rq_reply.brp_code != PBSE_UNKJOBID))
{
sprintf(log_buf, msg_mombadmodify, preq->rq_reply.brp_code);
log_event(
PBSEVENT_JOB,
PBS_EVENTCLASS_JOB,
preq->rq_ind.rq_modify.rq_objname,
log_buf);
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, NULL);
}
else
{
if (preq->rq_reply.brp_code == PBSE_UNKJOBID)
{
if ((pjob = svr_find_job(preq->rq_ind.rq_modify.rq_objname, FALSE)) == NULL)
{
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, NULL);
return;
}
else
{
mutex_mgr job_mutex(pjob->ji_mutex, true);
if (LOGLEVEL >= 0)
{
sprintf(log_buf, "post_modify_req: PBSE_UNKJOBID for job %s in state %s-%s, dest = %s",
pjob->ji_qs.ji_jobid,
PJobState[pjob->ji_qs.ji_state],
PJobSubState[pjob->ji_qs.ji_substate],
pjob->ji_qs.ji_destin);
log_event(PBSEVENT_JOB,PBS_EVENTCLASS_JOB,pjob->ji_qs.ji_jobid,log_buf);
}
}
}
reply_ack(preq);
}
return;
} /* END post_modify_req() */
/*
* req_altauthenuser - The intent of this function is to have a way to use
* multiple types of authorization utilities. But for right now we are using
* munge so this function is munge specific until we add support for another
* utility
*
*/
int req_altauthenuser(
struct batch_request *preq) /* I */
{
int s;
int rc = PBSE_NONE;
unsigned short conn_port;
/*
* find the socket whose client side is bound to the port named
* in the request
*/
for (s = 0;s < PBS_NET_MAX_CONNECTIONS;++s)
{
pthread_mutex_lock(svr_conn[s].cn_mutex);
conn_port = svr_conn[s].cn_port;
pthread_mutex_unlock(svr_conn[s].cn_mutex);
if (preq->rq_ind.rq_authen.rq_port != conn_port)
{
continue;
}
break;
} /* END for (s) */
/* If s is less than PBS_NET_MAX_CONNECTIONS we have our port */
if (s >= PBS_NET_MAX_CONNECTIONS)
{
req_reject(PBSE_BADCRED, 0, preq, NULL, "cannot authenticate user. Client connection not found");
return(PBSE_BADCRED);
}
rc = unmunge_request(s, preq);
if (rc)
{
/* FAILED */
return(rc);
}
/* SUCCESS */
/* time stamp just for the record */
conn_credent[s].timestamp = time(NULL);
pthread_mutex_lock(svr_conn[s].cn_mutex);
svr_conn[s].cn_authen = PBS_NET_CONN_AUTHENTICATED;
pthread_mutex_unlock(svr_conn[s].cn_mutex);
reply_ack(preq);
return(PBSE_NONE);
} /* END req_altauthenuser() */
void shutdown_ack(void)
{
if (pshutdown_request)
{
reply_ack(pshutdown_request);
pshutdown_request = 0;
}
return;
}
int handle_single_delete(
struct batch_request *preq,
struct batch_request *preq_tmp,
char *Msg)
{
int rc= -1;
char *jobid = preq->rq_ind.rq_delete.rq_objname;
job *pjob = svr_find_job(jobid, FALSE);
if (pjob == NULL)
{
log_event(PBSEVENT_DEBUG,PBS_EVENTCLASS_JOB,jobid,pbse_to_txt(PBSE_UNKJOBID));
req_reject(PBSE_UNKJOBID, 0, preq, NULL, "cannot locate job");
}
else
{
if (preq_tmp != NULL)
{
reply_ack(preq_tmp);
preq->rq_noreply = TRUE; /* set for no more replies */
}
/* mutex is freed below */
if ((rc = forced_jobpurge(pjob, preq)) == PBSE_NONE)
rc = execute_job_delete(pjob, Msg, preq);
}
if ((rc == PBSE_NONE) ||
(rc == PURGE_SUCCESS))
reply_ack(preq);
return(PBSE_NONE);
} /* END handle_single_delete() */
static void
post_message_req(struct work_task *pwt)
{
struct batch_request *preq;
if (pwt->wt_aux2 != 1) /* not rpp */
svr_disconnect(pwt->wt_event); /* close connection to MOM */
preq = pwt->wt_parm1;
preq->rq_conn = preq->rq_orgconn; /* restore socket to client */
(void)sprintf(log_buffer, msg_messagejob, preq->rq_reply.brp_code);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, LOG_INFO,
preq->rq_ind.rq_message.rq_jid, log_buffer);
if (preq->rq_reply.brp_code)
req_reject(preq->rq_reply.brp_code, 0, preq);
else
reply_ack(preq);
}
int handle_delete_all(
struct batch_request *preq,
struct batch_request *preq_tmp,
char *Msg)
{
/* preq_tmp is not null if this is an asynchronous request */
if (preq_tmp != NULL)
{
reply_ack(preq_tmp);
preq->rq_noreply = TRUE; /* set for no more replies */
enqueue_threadpool_request(delete_all_work, preq);
}
else
delete_all_work(preq);
return(PBSE_NONE);
} /* END handle_delete_all() */
static void process_gpu_request_reply(
struct work_task *pwt)
{
char *id = "process_gpu_request_reply";
struct batch_request *preq;
svr_disconnect(pwt->wt_event); /* close connection to MOM */
preq = pwt->wt_parm1;
preq->rq_conn = preq->rq_orgconn; /* restore client socket */
if (preq->rq_reply.brp_code != 0)
{
sprintf(log_buffer,
"MOM failed on GPU request, rc = %d",
preq->rq_reply.brp_code);
log_err(errno, id, log_buffer);
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, log_buffer);
}
else
{
/* record that MOM changed gpu mode */
if (LOGLEVEL >= 7)
{
sprintf(
log_buffer,
"GPU control request completed for node %s gpuid %s mode %d reset_perm %d reset_vol %d",
preq->rq_ind.rq_gpuctrl.rq_momnode,
preq->rq_ind.rq_gpuctrl.rq_gpuid,
preq->rq_ind.rq_gpuctrl.rq_gpumode,
preq->rq_ind.rq_gpuctrl.rq_reset_perm,
preq->rq_ind.rq_gpuctrl.rq_reset_vol);
log_ext(-1, id, log_buffer, LOG_INFO);
}
reply_ack(preq);
}
}
void req_jobcredential(
struct batch_request *preq) /* ptr to the decoded request */
{
job *pj;
pj = locate_new_job(preq->rq_conn, NULL);
if (pj == NULL)
{
req_reject(PBSE_IVALREQ, 0, preq, NULL, NULL);
return;
}
reply_ack(preq);
return;
} /* END req_jobcredential() */
/*
* process_gpu_request_reply
* called when a gpu change request was sent to MOM and the answer
* is received. Completes the gpu request.
*/
void process_gpu_request_reply(
batch_request *preq)
{
char log_buf[LOCAL_LOG_BUF_SIZE];
if (preq == NULL)
return;
preq->rq_conn = preq->rq_orgconn; /* restore client socket */
if (preq->rq_reply.brp_code != 0)
{
sprintf(log_buf,
"MOM failed on GPU request, rc = %d",
preq->rq_reply.brp_code);
log_err(errno, __func__, log_buf);
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, log_buf);
}
else
{
/* record that MOM changed gpu mode */
if (LOGLEVEL >= 7)
{
sprintf(
log_buf,
"GPU control request completed for node %s gpuid %s mode %d reset_perm %d reset_vol %d",
preq->rq_ind.rq_gpuctrl.rq_momnode,
preq->rq_ind.rq_gpuctrl.rq_gpuid,
preq->rq_ind.rq_gpuctrl.rq_gpumode,
preq->rq_ind.rq_gpuctrl.rq_reset_perm,
preq->rq_ind.rq_gpuctrl.rq_reset_vol);
log_ext(-1, __func__, log_buf, LOG_INFO);
}
reply_ack(preq);
}
} /* END process_gpu_request_reply() */
void post_message_req(
batch_request *preq)
{
char log_buf[LOCAL_LOG_BUF_SIZE];
/* preq has been hadnled previously */
if (preq == NULL)
return;
preq->rq_conn = preq->rq_orgconn; /* restore socket to client */
sprintf(log_buf, msg_messagejob, preq->rq_reply.brp_code);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, preq->rq_ind.rq_message.rq_jid, log_buf);
if (preq->rq_reply.brp_code)
req_reject(preq->rq_reply.brp_code, 0, preq, NULL, NULL);
else
reply_ack(preq);
} /* END post_message_req() */
static void process_checkpoint_reply(
struct work_task *pwt)
{
job *pjob;
struct batch_request *preq;
svr_disconnect(pwt->wt_event); /* close connection to MOM */
preq = get_remove_batch_request(pwt->wt_parm1);
free(pwt->wt_mutex);
free(pwt);
/* preq handled previously */
if (preq == NULL)
return;
preq->rq_conn = preq->rq_orgconn; /* restore client socket */
if ((pjob = svr_find_job(preq->rq_ind.rq_manager.rq_objname, FALSE)) == NULL)
{
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB,
preq->rq_ind.rq_manager.rq_objname,
msg_postmomnojob);
req_reject(PBSE_UNKJOBID, 0, preq, NULL, msg_postmomnojob);
}
else
{
/* record that MOM has a checkpoint file */
account_record(PBS_ACCT_CHKPNT, pjob, "Checkpointed"); /* note in accounting file */
reply_ack(preq);
unlock_ji_mutex(pjob, __func__, "1", LOGLEVEL);
}
} /* END process_checkpoint_reply() */
void req_connect(
struct batch_request *preq)
{
int sock = preq->rq_conn;
unsigned short conn_authen;
/* Called from one location inside a lock */
pthread_mutex_lock(svr_conn[sock].cn_mutex);
conn_authen = svr_conn[sock].cn_authen;
pthread_mutex_unlock(svr_conn[sock].cn_mutex);
if (conn_authen == 0)
{
reply_ack(preq);
}
else
{
req_reject(PBSE_BADCRED, 0, preq, NULL, "Connection not authorized");
}
return;
} /* END req_connect() */
void
req_connect(struct batch_request *preq)
{
conn_t *conn = get_conn(preq->rq_conn);
if (!conn) {
req_reject(PBSE_SYSTEM, 0, preq);
return;
}
if (preq->rq_extend != NULL) {
if (strcmp(preq->rq_extend, QSUB_DAEMON) == 0)
conn->cn_authen |= PBS_NET_CONN_FROM_QSUB_DAEMON;
else if (strcmp(preq->rq_extend, SC_DAEMON) == 0)
conn->cn_authen |= PBS_NET_CONN_FROM_PRIVIL;
}
if ((conn->cn_authen &
(PBS_NET_CONN_AUTHENTICATED|PBS_NET_CONN_FROM_PRIVIL))==0) {
reply_ack(preq);
} else
req_reject(PBSE_BADCRED, 0, preq);
}
void
req_shutdown(struct batch_request *preq)
{
int type;
extern int shutdown_who;
if ((preq->rq_perm & (ATR_DFLAG_MGWR | ATR_DFLAG_MGRD | ATR_DFLAG_OPRD |
ATR_DFLAG_OPWR)) == 0) {
req_reject(PBSE_PERM, 0, preq);
return;
}
(void)sprintf(log_buffer, msg_shutdown_op, preq->rq_user, preq->rq_host);
log_event(PBSEVENT_SYSTEM|PBSEVENT_ADMIN|PBSEVENT_DEBUG,
PBS_EVENTCLASS_SERVER, LOG_NOTICE, msg_daemonname, log_buffer);
pshutdown_request = preq; /* save for reply from main() when done */
type = preq->rq_ind.rq_shutdown;
shutdown_who = type & SHUT_WHO_MASK;
if (shutdown_who & SHUT_WHO_SECDONLY)
(void)failover_send_shutdown(FAILOVER_SecdShutdown);
if (shutdown_who & SHUT_WHO_SCHED)
(void)contact_sched(SCH_QUIT, NULL); /* tell scheduler to quit */
if (shutdown_who & SHUT_WHO_SECDONLY) {
reply_ack(preq);
return; /* do NOT shutdown this Server */
}
/* Moms are told to shutdown in pbsd_main.c after main loop */
svr_shutdown(type);
return;
}
