int
svr_chk_ownerResv(struct batch_request *preq, resc_resv *presv)
{
char owner[PBS_MAXUSER + 1];
char *host;
char *pu;
char rmtuser[PBS_MAXUSER + 1];
/* map user@host to "local" name */
pu = site_map_user(preq->rq_user, preq->rq_host);
if (pu == NULL)
return (-1);
(void)strncpy(rmtuser, pu, PBS_MAXUSER);
get_jobowner(presv->ri_wattr[(int)RESV_ATR_resv_owner].at_val.at_str, owner);
host = get_hostPart(presv->ri_wattr[(int)RESV_ATR_resv_owner].at_val.at_str);
pu = site_map_user(owner, host);
return (strcmp(rmtuser, pu));
}
void
req_orderjob(struct batch_request *req)
{
int jt1, jt2; /* job type */
job *pjob;
job *pjob1;
job *pjob2;
long rank;
int rc;
char tmpqn[PBS_MAXQUEUENAME+1];
if ((pjob1=chk_job_request(req->rq_ind.rq_move.rq_jid, req, &jt1)) == NULL)
return;
if ((pjob2=chk_job_request(req->rq_ind.rq_move.rq_destin, req, &jt2)) == NULL)
return;
if ((jt1 == IS_ARRAY_Single) || (jt2 == IS_ARRAY_Single) ||
(jt1 == IS_ARRAY_Range) || (jt2 == IS_ARRAY_Range)) {
/* can only move regular or Array Job, not Subjobs */
req_reject(PBSE_IVALREQ, 0, req);
return;
}
if (((pjob = pjob1)->ji_qs.ji_state == JOB_STATE_RUNNING) ||
((pjob = pjob2)->ji_qs.ji_state == JOB_STATE_RUNNING) ||
((pjob = pjob1)->ji_qs.ji_state == JOB_STATE_BEGUN) ||
((pjob = pjob2)->ji_qs.ji_state == JOB_STATE_BEGUN)) {
#ifndef NDEBUG
(void)sprintf(log_buffer, "(%s) %s, state=%d",
__func__, msg_badstate, pjob->ji_qs.ji_state);
log_event(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB, LOG_DEBUG,
pjob->ji_qs.ji_jobid, log_buffer);
#endif /* NDEBUG */
req_reject(PBSE_BADSTATE, 0, req);
return;
} else if (pjob1->ji_qhdr != pjob2->ji_qhdr) {
/* Jobs are in different queues */
if ((rc = svr_chkque(pjob1, pjob2->ji_qhdr,
get_hostPart(pjob1->ji_wattr[(int)JOB_ATR_job_owner].at_val.at_str),
MOVE_TYPE_Order)) ||
(rc = svr_chkque(pjob2, pjob1->ji_qhdr,
get_hostPart(pjob2->ji_wattr[(int)JOB_ATR_job_owner].at_val.at_str),
MOVE_TYPE_Order))) {
req_reject(rc, 0, req);
return;
}
}
/* now swap the order of the two jobs in the queue lists */
rank = pjob1->ji_wattr[(int)JOB_ATR_qrank].at_val.at_long;
pjob1->ji_wattr[(int)JOB_ATR_qrank].at_val.at_long =
pjob2->ji_wattr[(int)JOB_ATR_qrank].at_val.at_long;
pjob1->ji_wattr[(int)JOB_ATR_qrank].at_flags |= ATR_VFLAG_MODCACHE;
pjob2->ji_wattr[(int)JOB_ATR_qrank].at_val.at_long = rank;
pjob2->ji_wattr[(int)JOB_ATR_qrank].at_flags |= ATR_VFLAG_MODCACHE;
if (pjob1->ji_qhdr != pjob2->ji_qhdr) {
(void)strcpy(tmpqn, pjob1->ji_qs.ji_queue);
(void)strcpy(pjob1->ji_qs.ji_queue, pjob2->ji_qs.ji_queue);
(void)strcpy(pjob2->ji_qs.ji_queue, tmpqn);
svr_dequejob(pjob1);
svr_dequejob(pjob2);
(void)svr_enquejob(pjob1);
(void)svr_enquejob(pjob2);
} else {
swap_link(&pjob1->ji_jobque, &pjob2->ji_jobque);
swap_link(&pjob1->ji_alljobs, &pjob2->ji_alljobs);
}
/* need to update disk copy of both jobs to save new order */
(void)job_save(pjob1, SAVEJOB_FULL);
(void)job_save(pjob2, SAVEJOB_FULL);
reply_ack(req);
}
int
svr_chk_owner(struct batch_request *preq, job *pjob)
{
char owner[PBS_MAXUSER+1];
char *pu;
char *ph;
char rmtuser[PBS_MAXUSER+PBS_MAXHOSTNAME+2];
extern int ruserok(const char *rhost, int suser, const char *ruser,
const char *luser);
#ifdef WIN32
extern int user_read_password(char *user, char **cred, size_t *len);
extern int read_cred(job *pjob, char **cred, size_t *len);
extern int decrypt_pwd(char *crypted, size_t len, char **passwd);
#endif
/* Are the owner and requestor the same? */
snprintf(rmtuser, sizeof(rmtuser), "%s",
pjob->ji_wattr[(int)JOB_ATR_job_owner].at_val.at_str);
pu = rmtuser;
ph = strchr(rmtuser, '@');
if (!ph)
return -1;
*ph++ = '\0';
if (strcmp(preq->rq_user, pu) == 0) {
/* Avoid the lookup if they match. */
if (strcmp(preq->rq_host, ph) == 0)
return 0;
/* Perform the lookup. */
if (is_same_host(preq->rq_host, ph))
return 0;
}
/* map requestor user@host to "local" name */
pu = site_map_user(preq->rq_user, preq->rq_host);
if (pu == NULL)
return (-1);
(void)strncpy(rmtuser, pu, PBS_MAXUSER);
/*
* Get job owner name without "@host" and then map to "local" name.
*/
get_jobowner(pjob->ji_wattr[(int)JOB_ATR_job_owner].at_val.at_str, owner);
pu = site_map_user(owner, get_hostPart(pjob->ji_wattr[(int)JOB_ATR_job_owner].at_val.at_str));
if (server.sv_attr[(int)SRV_ATR_FlatUID].at_val.at_long) {
/* with flatuid, all that must match is user names */
return (strcmp(rmtuser, pu));
} else {
/* non-flatuid space, must validate rmtuser vs owner */
#ifdef WIN32
if ( (server.sv_attr[SRV_ATR_ssignon_enable].at_flags & \
ATR_VFLAG_SET) && \
(server.sv_attr[SRV_ATR_ssignon_enable].at_val.at_long \
== 1) ) {
/* read/cache user password */
cache_usertoken_and_homedir(pu, NULL, 0,
user_read_password, (char *)pu, pbs_decrypt_pwd, 0);
} else {
/* read/cache job password */
cache_usertoken_and_homedir(pu, NULL, 0,
read_cred, (job *)pjob, pbs_decrypt_pwd, 0);
}
#endif
return (ruserok(preq->rq_host, 0, rmtuser, pu));
}
}
/**
* @brief
* Move a job to another queue in this Server.
*
* @par
* Check the destination to see if it can accept the job.
* If the job can enter the new queue, dequeue from the existing queue and
* enqueue into the new queue
*
* @par
* Note - the destination is specified by the queue's name in the
* ji_qs.ji_destin element of the job structure.
*
* param[in] jobp - pointer to job to move
* param[in] req - client request from a qmove client, null if a route
*
* @return int
* @retval 0 : success
* @retval -1 : permanent failure or rejection, see pbs_errno
* @retval 1 : failed but try again later
*/
int
local_move(job *jobp, struct batch_request *req)
{
pbs_queue *qp;
char *destination = jobp->ji_qs.ji_destin;
int mtype;
attribute *pattr;
long newtype = -1;
/* search for destination queue */
if ((qp = find_queuebyname(destination)) == NULL) {
sprintf(log_buffer,
"queue %s does not exist",
destination);
log_err(-1, __func__, log_buffer);
pbs_errno = PBSE_UNKQUE;
return -1;
}
/*
* if being moved at specific request of administrator, then
* checks on queue availability, etc. are skipped;
* otherwise all checks are enforced.
*/
if (req == NULL) {
mtype = MOVE_TYPE_Route; /* route */
} else if (req->rq_perm & (ATR_DFLAG_MGRD | ATR_DFLAG_MGWR)) {
mtype = MOVE_TYPE_MgrMv; /* privileged move */
} else {
mtype = MOVE_TYPE_Move; /* non-privileged move */
}
pbs_errno = svr_chkque(jobp, qp,
get_hostPart(jobp->ji_wattr[(int)JOB_ATR_job_owner].at_val.at_str),
mtype);
if (pbs_errno) {
/* should this queue be retried? */
return (should_retry_route(pbs_errno));
}
/* dequeue job from present queue, update destination and */
/* queue_rank for new queue and enqueue into destination */
svr_dequejob(jobp);
jobp->ji_myResv = NULL;
strncpy(jobp->ji_qs.ji_queue, qp->qu_qs.qu_name, PBS_MAXQUEUENAME);
jobp->ji_qs.ji_queue[PBS_MAXQUEUENAME] = '\0';
jobp->ji_wattr[(int)JOB_ATR_qrank].at_val.at_long = ++queue_rank;
jobp->ji_wattr[(int)JOB_ATR_qrank].at_flags |= ATR_VFLAG_MODCACHE;
pattr = &jobp->ji_wattr[(int)JOB_ATR_reserve_ID];
if (qp->qu_resvp) {
job_attr_def[(int)JOB_ATR_reserve_ID].at_decode(pattr,
(char *)0, (char *)0, qp->qu_resvp->ri_qs.ri_resvID);
jobp->ji_myResv = qp->qu_resvp;
} else {
job_attr_def[(int)JOB_ATR_reserve_ID].at_decode(pattr,
(char *)0, (char *)0, (char*)0);
}
if (server.sv_attr[(int)SRV_ATR_EligibleTimeEnable].at_val.at_long == 1) {
newtype = determine_accruetype(jobp);
if (newtype == -1)
/* unable to determine accruetype, set it to NEW */
(void)update_eligible_time(JOB_INITIAL, jobp);
else
/* found suiting accruetype, update to this */
(void)update_eligible_time(newtype, jobp);
}
if ((pbs_errno = svr_enquejob(jobp)) != 0)
return -1; /* should never ever get here */
jobp->ji_lastdest = 0; /* reset in case of another route */
(void)job_save(jobp, SAVEJOB_FULL);
/* If a scheduling cycle is in progress, then this moved job may have
* had changes resulting from the move that would impact scheduling or
* placement, add job to list of jobs which cannot be run in this cycle.
*/
if ((req == NULL || (req->rq_conn != scheduler_sock)) && (scheduler_jobs_stat))
am_jobs_add(jobp);
return 0;
}