int send_command_str(
struct tcp_chan *chan,
int cmd,
char *query) /* I */
{
int rc;
rc = diswsi(chan, cmd);
if ((rc != DIS_SUCCESS) ||
(cmd == RM_CMD_CLOSE))
return(rc);
if (cmd == RM_CMD_CONFIG)
{
if((rc = diswst(chan, ConfigBuf)) != DIS_SUCCESS)
return (rc);
}
rc = diswcs(chan, query, strlen(query));
DIS_tcp_wflush(chan);
return(rc);
} /* END send_command_str() */
int
encode_DIS_CopyHookFile(int sock, int seq, char *buf, int len, char *filename)
{
int rc;
if ((rc = diswui(sock, seq) != 0) ||
(rc = diswui(sock, len) != 0) ||
(rc = diswst(sock, filename) != 0) ||
(rc = diswcs(sock, buf, len) != 0))
return rc;
return 0;
}
int configrm(
int stream, /* I */
int *local_errno, /* O */
char *file) /* I */
{
int ret;
size_t len;
struct out *op;
if ((op = findout(local_errno, stream)) == NULL)
{
return(-1);
}
op->len = -1;
/* NOTE: remove absolute job path check to allow config file staging (CRI) */
/* NOTE: remove filename size check (was 'MAXPATHLEN') */
if ((len = strlen(file)) > (size_t)65536)
{
return(-1 * EINVAL);
}
if (startcom(op->chan, local_errno, RM_CMD_CONFIG,1) != DIS_SUCCESS)
{
return(-1);
}
ret = diswcs(op->chan, file, len);
if (ret != DIS_SUCCESS)
{
#if defined(ECOMM)
*local_errno = ECOMM;
#elif defined(ENOCONNECT)
*local_errno = ENOCONNECT;
#else
*local_errno = ETXTBSY;
#endif
DBPRT(("configrm: diswcs %s\n",
dis_emsg[ret]))
return(-1);
}
/**
* @brief
* -encode_DIS_CopyFiles_Cred() - encode a Copy Files with Credential Dependency
* Batch Request
*
* @par Note:
* This request is used by the server ONLY; its input is a server
* batch request structure.
*
* @param[in] sock - socket descriptor
* @param[in] preq - pointer to batch request
*
* @par Data items are:\n
* string job id\n
* string job owner(may be null)\n
* string execution user name\n
* string execution group name(may be null)\n
* unsigned int direction & job_dir_enable flag\n
* unsigned int count of file pairs in set\n
* set of file pairs:\n
* unsigned int flag\n
* string local path name\n
* string remote path name (may be null)\n
* unsigned int credential type\n
* unsigned int credential length (bytes)\n
* byte string credential\n
*
* @return int
* @retval 0 success
* @retval !0 error
*
*/
int
encode_DIS_CopyFiles_Cred(int sock, struct batch_request *preq)
{
int pair_ct = 0;
char *nullstr = "";
struct rqfpair *ppair;
int rc;
size_t clen;
struct rq_cpyfile *rcpyf;
clen = (size_t)preq->rq_ind.rq_cpyfile_cred.rq_credlen;
rcpyf = &preq->rq_ind.rq_cpyfile_cred.rq_copyfile;
ppair = (struct rqfpair *)GET_NEXT(rcpyf->rq_pair);
while (ppair) {
++pair_ct;
ppair = (struct rqfpair *)GET_NEXT(ppair->fp_link);
}
if ((rc = diswst(sock, rcpyf->rq_jobid) != 0) ||
(rc = diswst(sock, rcpyf->rq_owner) != 0) ||
(rc = diswst(sock, rcpyf->rq_user) != 0) ||
(rc = diswst(sock, rcpyf->rq_group) != 0) ||
(rc = diswui(sock, rcpyf->rq_dir) != 0))
return rc;
if ((rc = diswui(sock, pair_ct) != 0))
return rc;
ppair = (struct rqfpair *)GET_NEXT(rcpyf->rq_pair);
while (ppair) {
if (ppair->fp_rmt == NULL)
ppair->fp_rmt = nullstr;
if ((rc = diswui(sock, ppair->fp_flag) != 0) ||
(rc = diswst(sock, ppair->fp_local) != 0) ||
(rc = diswst(sock, ppair->fp_rmt) != 0))
return rc;
ppair = (struct rqfpair *)GET_NEXT(ppair->fp_link);
}
rc = diswui(sock, preq->rq_ind.rq_cpyfile_cred.rq_credtype);
if (rc != 0) return rc;
rc = diswcs(sock, preq->rq_ind.rq_cpyfile_cred.rq_pcred, clen);
if (rc != 0) return rc;
return 0;
}
int encode_DIS_JobCred(
struct tcp_chan *chan,
int type,
char *cred,
int len)
{
int rc;
if ((rc = diswui(chan, type)))
return rc;
rc = diswcs(chan, cred, (size_t)len);
return rc;
}
static int
PBSD_GSS_context(int sock, char *buf, int len)
{
int rc;
if (len == 0)
return 0;
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_GSS_Context,
pbs_current_user)) ||
(rc = diswcs(sock, buf, (size_t)len)) ||
(rc = encode_DIS_ReqExtend(sock, (char *)0))) {
return rc;
}
if (DIS_tcp_wflush(sock))
return DIS_NOCOMMIT;
return 0;
}
int encode_DIS_JobFile(
struct tcp_chan *chan,
int seq,
char *buf,
int len,
const char *jobid,
int which)
{
int rc;
if (jobid == (char *)0)
jobid = (char *)"";
if ((rc = diswui(chan, seq) != 0) ||
(rc = diswui(chan, which) != 0) ||
(rc = diswui(chan, len) != 0) ||
(rc = diswst(chan, jobid) != 0) ||
(rc = diswcs(chan, buf, len) != 0))
return rc;
return 0;
}
int encode_DIS_reply(
struct tcp_chan *chan,
struct batch_reply *reply)
{
int ct;
int i;
struct brp_select *psel;
struct brp_status *pstat;
svrattrl *psvrl;
int rc;
/* first encode "header" consisting of protocol type and version */
if ((rc = diswui(chan, PBS_BATCH_PROT_TYPE)) ||
(rc = diswui(chan, PBS_BATCH_PROT_VER)))
return rc;
/* next encode code, auxcode and choice (union type identifier) */
if ((rc = diswsi(chan, reply->brp_code)) ||
(rc = diswsi(chan, reply->brp_auxcode)) ||
(rc = diswui(chan, reply->brp_choice)))
return rc;
switch (reply->brp_choice)
{
case BATCH_REPLY_CHOICE_NULL:
break; /* no more to do */
case BATCH_REPLY_CHOICE_Queue:
case BATCH_REPLY_CHOICE_RdytoCom:
case BATCH_REPLY_CHOICE_Commit:
if ((rc = diswst(chan, reply->brp_un.brp_jid)))
return (rc);
break;
case BATCH_REPLY_CHOICE_Select:
/* have to send count of number of strings first */
ct = 0;
psel = reply->brp_un.brp_select;
while (psel)
{
++ct;
psel = psel->brp_next;
}
if ((rc = diswui(chan, ct)))
return rc;
psel = reply->brp_un.brp_select;
while (psel)
{
/* now encode each string */
if ((rc = diswst(chan, psel->brp_jobid)))
return rc;
psel = psel->brp_next;
}
break;
case BATCH_REPLY_CHOICE_Status:
/* encode "server version" of status structure.
*
* Server always uses svrattrl form.
* Commands decode into their form.
*
* First need to encode number of status objects and then
* the object itself.
*/
ct = 0;
pstat = (struct brp_status *)GET_NEXT(reply->brp_un.brp_status);
while (pstat)
{
++ct;
pstat = (struct brp_status *)GET_NEXT(pstat->brp_stlink);
}
if ((rc = diswui(chan, ct)))
return rc;
pstat = (struct brp_status *)GET_NEXT(reply->brp_un.brp_status);
while (pstat)
{
if ((rc = diswui(chan, pstat->brp_objtype)) ||
(rc = diswst(chan, pstat->brp_objname)))
return rc;
psvrl = (svrattrl *)GET_NEXT(pstat->brp_attr);
if ((rc = encode_DIS_svrattrl(chan, psvrl)))
return rc;
pstat = (struct brp_status *)GET_NEXT(pstat->brp_stlink);
}
break;
case BATCH_REPLY_CHOICE_Text:
/* text reply */
if ((rc = diswcs(chan, reply->brp_un.brp_txt.brp_str,
reply->brp_un.brp_txt.brp_txtlen)))
return rc;
break;
case BATCH_REPLY_CHOICE_Locate:
/* Locate Job Reply */
if ((rc = diswst(chan, reply->brp_un.brp_locate)))
return rc;
break;
case BATCH_REPLY_CHOICE_RescQuery:
/* Query Resources Reply */
ct = reply->brp_un.brp_rescq.brq_number;
if ((rc = diswui(chan, ct)))
return rc;
for (i = 0; (i < ct) && (rc == 0); ++i)
{
rc = diswui(chan, *(reply->brp_un.brp_rescq.brq_avail + i));
}
if (rc) return rc;
for (i = 0; (i < ct) && (rc == 0); ++i)
{
rc = diswui(chan, *(reply->brp_un.brp_rescq.brq_alloc + i));
}
if (rc) return rc;
for (i = 0; (i < ct) && (rc == 0); ++i)
{
rc = diswui(chan, *(reply->brp_un.brp_rescq.brq_resvd + i));
}
if (rc) return rc;
for (i = 0; (i < ct) && (rc == 0); ++i)
{
rc = diswui(chan, *(reply->brp_un.brp_rescq.brq_down + i));
}
if (rc) return rc;
break;
default:
return -1;
}
return 0;
}
/**
* @brief
* Generate munge key specific to the user and send PBS batch request
* (PBS_BATCH_AuthExternal)to PBS server to authenticate user.
*
* @param[in] sock - socket fd
* @param[in] auth_type - Authentication type (Munge/AMS etc)
* @param[in] fromsvr - connection initiated from server?
*
* @return int
* @retval 0 on success
* @retval -1 on failure
* @retval -2 on unsupported auth_type
*
*/
int
engage_external_authentication(int sock, int auth_type, int fromsvr, char *ebuf, int ebufsz)
{
int cred_len = 0, rc = 0, ret = 0;
char *cred = NULL;
struct batch_reply *reply = NULL;
switch (auth_type) {
#ifndef WIN32
case AUTH_MUNGE:
ebuf[0] = '\0';
cred = pbs_get_munge_auth_data(fromsvr, ebuf, ebufsz);
if (!cred)
goto err;
break;
#endif
default:
snprintf(ebuf, ebufsz, "Authentication type not supported");
ret = -2;
}
if (cred) {
ret = -1;
cred_len = strlen(cred);
DIS_tcp_setup(sock);
if (encode_DIS_ReqHdr(sock, PBS_BATCH_AuthExternal, pbs_current_user) ||
diswuc(sock, auth_type) || /* authentication_type */
diswsi(sock, cred_len) || /* credential length */
diswcs(sock, cred, cred_len) || /* credential data */
encode_DIS_ReqExtend(sock, NULL)) {
pbs_errno = PBSE_SYSTEM;
goto err;
}
if (DIS_tcp_wflush(sock)) {
pbs_errno = PBSE_SYSTEM;
goto err;
}
memset(cred, 0, cred_len);
reply = PBSD_rdrpy_sock(sock, &rc);
if ((reply != NULL) && (reply->brp_code != 0)) {
pbs_errno = PBSE_BADCRED;
PBSD_FreeReply(reply);
goto err;
}
PBSD_FreeReply(reply);
free(cred);
return 0;
}
/* else fall through */
err:
if (ebuf[0] != '\0') {
fprintf(stderr, "%s\n", ebuf);
cs_logerr(-1, __func__, ebuf);
}
free(cred);
return ret;
}
