int
PBSD_msg_put(int c, char *jobid, int fileopt, char *msg, char *extend, int rpp, char **msgid)
{
int rc = 0;
int sock;
if (!rpp) {
sock = connection[c].ch_socket;
DIS_tcp_setup(sock);
} else {
sock = c;
if ((rc = is_compose_cmd(sock, IS_CMD, msgid)) != DIS_SUCCESS)
return rc;
}
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_MessJob,
pbs_current_user)) ||
(rc = encode_DIS_MessageJob(sock, jobid, fileopt, msg)) ||
(rc = encode_DIS_ReqExtend(sock, extend))) {
return (pbs_errno = PBSE_PROTOCOL);
}
if (DIS_wflush(sock, rpp)) {
pbs_errno = PBSE_PROTOCOL;
rc = pbs_errno;
}
return rc;
}
/**
* @brief
* -PBS_resc() - internal common code for sending resource requests
*
* @par Functionality:
* Formats and sends the requests for pbs_rescquery(), pbs_rescreserve(),
* and pbs_rescfree(). Note, while the request is overloaded for all
* three, each has its own expected reply format.
*
* @param[in] c - communication handle
* @param[in] reqtype - request type
* @param[in] rescl- pointer to resource list
* @param[in] ct - count of query strings
* @param[in] rh - resource handle
*
* @return int
* @retval 0 success
* @retval !0 error
*
*/
static int
PBS_resc(int c, int reqtype, char **rescl, int ct, pbs_resource_t rh)
{
int rc;
int sock;
sock = connection[c].ch_socket;
/* setup DIS support routines for following DIS calls */
DIS_tcp_setup(sock);
if ((rc = encode_DIS_ReqHdr(sock, reqtype, pbs_current_user)) ||
(rc = encode_DIS_Resc(sock, rescl, ct, rh)) ||
(rc = encode_DIS_ReqExtend(sock, (char *)0))) {
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
if (connection[c].ch_errtxt == NULL) {
pbs_errno = PBSE_SYSTEM;
} else {
pbs_errno = PBSE_PROTOCOL;
}
return (pbs_errno);
}
if (DIS_tcp_wflush(sock)) {
return (pbs_errno = PBSE_PROTOCOL);
}
return (0);
}
static int dis_reply_write(
int sfds, /* I */
struct batch_reply *preply) /* I */
{
int rc = PBSE_NONE;
char log_buf[LOCAL_LOG_BUF_SIZE];
struct tcp_chan *chan = NULL;
/* setup for DIS over tcp */
if ((chan = DIS_tcp_setup(sfds)) == NULL)
{
}
/* send message to remote client */
else if ((rc = encode_DIS_reply(chan, preply)) ||
(rc = DIS_tcp_wflush(chan)))
{
sprintf(log_buf, "DIS reply failure, %d", rc);
log_event(PBSEVENT_SYSTEM, PBS_EVENTCLASS_REQUEST, __func__, log_buf);
/* don't need to get the lock here because we already have it from process request */
close_conn(sfds, FALSE);
}
if (chan != NULL)
DIS_tcp_cleanup(chan);
return(rc);
} /* END dis_reply_write() */
int
PBSD_py_spawn_put(int c, char *jobid, char **argv, char **envp, int rpp, char **msgid)
{
int rc = 0;
int sock;
if (!rpp) {
sock = connection[c].ch_socket;
DIS_tcp_setup(sock);
} else {
sock = c;
if ((rc = is_compose_cmd(sock, IS_CMD, msgid)) != DIS_SUCCESS)
return rc;
}
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_PySpawn,
pbs_current_user)) ||
(rc = encode_DIS_PySpawn(sock, jobid, argv, envp)) ||
(rc = encode_DIS_ReqExtend(sock, NULL))) {
return (pbs_errno = PBSE_PROTOCOL);
}
if (DIS_wflush(sock, rpp)) {
pbs_errno = PBSE_PROTOCOL;
rc = pbs_errno;
}
return rc;
}
/**
* @brief read a batch reply from the given socket
*
* @param[in] sock - The socket fd to read from
* @param[out] rc - Return DIS error code
*
* @return Batch reply structure
* @retval !NULL - Success
* @retval NULL - Failure
*
*/
struct batch_reply *
PBSD_rdrpy_sock(int sock, int *rc)
{
struct batch_reply *reply;
time_t old_timeout;
*rc = DIS_SUCCESS;
/* clear any prior error message */
if ((reply = (struct batch_reply *)malloc(sizeof(struct batch_reply))) == 0) {
pbs_errno = PBSE_SYSTEM;
return ((struct batch_reply *)0);
}
(void)memset(reply, 0, sizeof(struct batch_reply));
DIS_tcp_setup(sock);
old_timeout = pbs_tcp_timeout;
if (pbs_tcp_timeout < PBS_DIS_TCP_TIMEOUT_LONG)
pbs_tcp_timeout = PBS_DIS_TCP_TIMEOUT_LONG;
if ((*rc = decode_DIS_replyCmd(sock, reply)) != 0) {
(void)free(reply);
pbs_errno = PBSE_PROTOCOL;
return (struct batch_reply *)NULL;
}
DIS_tcp_reset(sock, 0); /* reset DIS read buffer */
pbs_tcp_timeout = old_timeout;
pbs_errno = reply->brp_code;
return reply;
}
int pbs_disconnect(
int connect) /* I (socket descriptor) */
{
int sock;
/* send close-connection message */
sock = connection[connect].ch_socket;
DIS_tcp_setup(sock);
if (encode_DIS_ReqHdr(sock, PBS_BATCH_Disconnect, pbs_current_user) == 0)
{
DIS_tcp_wflush(sock);
}
close(sock);
DIS_tcp_release(sock);
if (connection[connect].ch_errtxt != (char *)NULL)
free(connection[connect].ch_errtxt);
connection[connect].ch_errno = 0;
connection[connect].ch_inuse = 0;
return(0);
} /* END pbs_disconnect() */
static int addrm(
int stream) /* I */
{
struct out *op, **head;
if ((op = (struct out *)calloc(1, sizeof(struct out))) == NULL)
{
return(errno);
}
else if ((op->chan = DIS_tcp_setup(stream)) == NULL)
{
free(op);
return errno;
}
head = &outs[stream % HASHOUT];
op->len = -1;
op->next = *head;
*head = op;
return 0;
}
static int dis_reply_write(
int sfds, /* I */
struct batch_reply *preply) /* I */
{
int rc;
/* setup for DIS over tcp */
DIS_tcp_setup(sfds);
/* send message to remote client */
if ((rc = encode_DIS_reply(sfds, preply)) ||
(rc = DIS_tcp_wflush(sfds)))
{
sprintf(log_buffer, "DIS reply failure, %d",
rc);
LOG_EVENT(
PBSEVENT_SYSTEM,
PBS_EVENTCLASS_REQUEST,
"dis_reply_write",
log_buffer);
close_conn(sfds);
}
return(rc);
} /* END dis_reply_write() */
int
__pbs_orderjob(int c, char *job1, char *job2, char *extend)
{
struct batch_reply *reply;
int rc;
int sock;
if ((job1 == NULL) || (*job1 == '\0') ||
(job2 == NULL) || (*job2 == '\0'))
return (pbs_errno = PBSE_IVALREQ);
sock = connection[c].ch_socket;
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return pbs_errno;
/* lock pthread mutex here for this connection */
/* blocking call, waits for mutex release */
if (pbs_client_thread_lock_connection(c) != 0)
return pbs_errno;
/* setup DIS support routines for following DIS calls */
DIS_tcp_setup(sock);
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_OrderJob, pbs_current_user)) ||
(rc = encode_DIS_MoveJob(sock, job1, job2)) ||
(rc = encode_DIS_ReqExtend(sock, extend))) {
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
if (connection[c].ch_errtxt == NULL) {
pbs_errno = PBSE_SYSTEM;
} else {
pbs_errno = PBSE_PROTOCOL;
}
(void)pbs_client_thread_unlock_connection(c);
return pbs_errno;
}
if (DIS_tcp_wflush(sock)) {
pbs_errno = PBSE_PROTOCOL;
(void)pbs_client_thread_unlock_connection(c);
return pbs_errno;
}
/* read reply */
reply = PBSD_rdrpy(c);
PBSD_FreeReply(reply);
rc = connection[c].ch_errno;
/* unlock the thread lock and update the thread context data */
if (pbs_client_thread_unlock_connection(c) != 0)
return pbs_errno;
return rc;
}
int parse_response_svr(
int sock,
char **err_msg)
{
/*
* PBS_BATCH_PROT_TYPE
* PBS_BATCH_PROT_VER
* reply->brp_code
* reply->brp_auxcode
* reply->brp_choice
* if reply->brp_choice == BATCH_REPLY_CHOICE_Text also read:
* preq->rq_reply.brp_un.brp_txt.brp_str
* using
* preq->rq_reply.brp_un.brp_txt.brp_txtlen
*/
int rc = PBSE_NONE;
struct batch_reply *reply = NULL;
char *tmp_val = NULL;
struct tcp_chan *chan = NULL;
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
}
else if ((reply = (struct batch_reply *)calloc(1, sizeof(struct batch_reply))) == NULL)
{
}
else if ((rc = decode_DIS_replyCmd(chan, reply)))
{
free(reply);
if (chan->IsTimeout == TRUE)
{
rc = PBSE_TIMEOUT;
}
else
{
rc = PBSE_PROTOCOL;
}
if ((tmp_val = pbs_strerror(rc)) == NULL)
{
char err_buf[80];
snprintf(err_buf, 79, "Error creating error message for code %d", rc);
*err_msg = strdup(err_buf);
}
else
*err_msg = strdup(tmp_val);
}
else
{
rc = reply->brp_code;
if (reply->brp_code != PBSE_NONE)
{
*err_msg = strdup(reply->brp_un.brp_txt.brp_str);
}
free(reply);
}
DIS_tcp_cleanup(chan);
return rc;
}
void *start_process_request(void *vp)
{
int sock = *(int *)vp;
struct tcp_chan *chan = NULL;
if ((chan = DIS_tcp_setup(sock)) == NULL)
return NULL;
process_request(chan);
DIS_tcp_cleanup(chan);
return(NULL);
}
int PBSD_selectattr_put(
int c,
int type,
struct attropl *attropl,
struct attrl *attrib,
char *extend)
{
int rc = PBSE_NONE;
int sock;
struct tcp_chan *chan = NULL;
if ((c < 0) ||
(c >= PBS_NET_MAX_CONNECTIONS))
{
return(PBSE_IVALREQ);
}
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
/* setup DIS support routines for following DIS calls */
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
pthread_mutex_unlock(connection[c].ch_mutex);
rc = PBSE_PROTOCOL;
return rc;
}
else if ((rc = encode_DIS_ReqHdr(chan, type, pbs_current_user)) ||
(rc = encode_DIS_attropl(chan, attropl)) ||
(rc = encode_DIS_attrl(chan, attrib)) ||
(rc = encode_DIS_ReqExtend(chan, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return (PBSE_PROTOCOL);
}
pthread_mutex_unlock(connection[c].ch_mutex);
/* write data */
if (DIS_tcp_wflush(chan))
{
rc = PBSE_PROTOCOL;
}
DIS_tcp_cleanup(chan);
return rc;
} /* END PBSD_selectattr_put() */
int PBSD_rdytocmt(
int connect,
char *jobid)
{
int rc;
struct batch_reply *reply;
int sock;
struct tcp_chan *chan = NULL;
if ((connect < 0) ||
(connect >= PBS_NET_MAX_CONNECTIONS))
{
return(PBSE_IVALREQ);
}
pthread_mutex_lock(connection[connect].ch_mutex);
sock = connection[connect].ch_socket;
pthread_mutex_unlock(connection[connect].ch_mutex);
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
return(PBSE_MEM_MALLOC);
}
else if ((rc = encode_DIS_ReqHdr(chan, PBS_BATCH_RdytoCommit, pbs_current_user)) ||
(rc = encode_DIS_JobId(chan, jobid)) ||
(rc = encode_DIS_ReqExtend(chan, NULL)))
{
pthread_mutex_lock(connection[connect].ch_mutex);
connection[connect].ch_errtxt = strdup(dis_emsg[rc]);
pthread_mutex_unlock(connection[connect].ch_mutex);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
if (DIS_tcp_wflush(chan))
{
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
DIS_tcp_cleanup(chan);
/* read reply */
reply = PBSD_rdrpy(&rc, connect);
PBSD_FreeReply(reply);
return(rc);
}
int
PBSD_ucred(int c, char *user, int type, char *buf, int len)
{
int rc;
struct batch_reply *reply = NULL;
int sock;
sock = connection[c].ch_socket;
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return pbs_errno;
/* lock pthread mutex here for this connection */
/* blocking call, waits for mutex release */
if (pbs_client_thread_lock_connection(c) != 0)
return pbs_errno;
DIS_tcp_setup(sock);
if ((rc =encode_DIS_ReqHdr(sock, PBS_BATCH_UserCred, pbs_current_user)) ||
(rc = encode_DIS_UserCred(sock, user, type, buf, len)) ||
(rc = encode_DIS_ReqExtend(sock, (char *)0))) {
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
if (connection[c].ch_errtxt == NULL) {
pbs_errno = PBSE_SYSTEM;
} else {
pbs_errno = PBSE_PROTOCOL;
}
(void)pbs_client_thread_unlock_connection(c);
return pbs_errno;
}
if (DIS_tcp_wflush(sock)) {
pbs_errno = PBSE_PROTOCOL;
(void)pbs_client_thread_unlock_connection(c);
return pbs_errno;
}
reply = PBSD_rdrpy(c);
PBSD_FreeReply(reply);
rc = connection[c].ch_errno;
/* unlock the thread lock and update the thread context data */
if (pbs_client_thread_unlock_connection(c) != 0)
return pbs_errno;
return rc;
}
int PBSD_status_put(
int c,
int function,
char *id,
struct attrl *attrib,
char *extend)
{
int rc = 0;
int sock;
struct tcp_chan *chan = NULL;
if ((c < 0) ||
(c >= PBS_NET_MAX_CONNECTIONS))
{
return(PBSE_IVALREQ);
}
mutex_mgr ch_mutex = mutex_mgr(connection[c].ch_mutex, false);
sock = connection[c].ch_socket;
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
rc = PBSE_MEM_MALLOC;
return rc;
}
else if ((rc = encode_DIS_ReqHdr(chan, function, pbs_current_user)) ||
(rc = encode_DIS_Status(chan, id, attrib)) ||
(rc = encode_DIS_ReqExtend(chan, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
ch_mutex.unlock();
if (DIS_tcp_wflush(chan))
{
rc = PBSE_PROTOCOL;
}
/* success */
DIS_tcp_cleanup(chan);
return(PBSE_NONE);
} /* END PBSD_status_put() */
int pbs_lock(
int c, /* I */
int action, /* I */
char *extend) /* I */
{
struct batch_reply *reply;
int rc = 0;
int sock;
/* send request */
sock = connection[c].ch_socket;
/* setup DIS support routines for following DIS calls */
DIS_tcp_setup(sock);
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_SchedulerLock, pbs_current_user)) ||
(rc = encode_DIS_SchedLock(sock, action)) ||
(rc = encode_DIS_ReqExtend(sock, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
pbs_errno = PBSE_PROTOCOL;
return(pbs_errno);
}
if (DIS_tcp_wflush(sock))
{
pbs_errno = PBSE_PROTOCOL;
return(pbs_errno);
}
/* read in reply */
reply = PBSD_rdrpy(c);
rc = connection[c].ch_errno;
PBSD_FreeReply(reply);
return(rc);
} /* END pbs_terminate() */
int PBSD_mgr_put(
int c, /* I */
int function, /* I */
int command, /* I */
int objtype, /* I */
char *objname, /* I */
struct attropl *aoplp, /* I */
char *extend) /* I */
{
int rc = PBSE_NONE;
int sock;
struct tcp_chan *chan = NULL;
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
pthread_mutex_unlock(connection[c].ch_mutex);
rc = PBSE_PROTOCOL;
return(rc);
}
else if ((rc = encode_DIS_ReqHdr(chan, function, pbs_current_user)) ||
(rc = encode_DIS_Manage(chan, command, objtype, objname, aoplp)) ||
(rc = encode_DIS_ReqExtend(chan, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
rc = PBSE_PROTOCOL; /* We shouldn't be overridding this error!!! */
return rc;
}
if (DIS_tcp_wflush(chan))
{
pthread_mutex_unlock(connection[c].ch_mutex);
rc = PBSE_PROTOCOL;
}
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return rc;
} /* END PBSD_mgr_put() */
int pbs_disconnect_socket(
int sock) /* I (socket descriptor) */
{
char tmp_buf[THE_BUF_SIZE / 4];
struct tcp_chan *chan = NULL;
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
}
else if ((encode_DIS_ReqHdr(chan,PBS_BATCH_Disconnect, pbs_current_user) == 0)
&& (DIS_tcp_wflush(chan) == 0))
{
int atime;
struct sigaction act;
struct sigaction oldact;
/* set alarm to break out of potentially infinite read */
/* act.sa_handler = SIG_IGN; */
act.sa_handler = empty_alarm_handler; /* need SOME handler or blocking read never gets interrupted */
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGALRM, &act, &oldact);
atime = alarm(5);
while (1)
{
/* wait for server to close connection */
/* NOTE: if read of 'sock' is blocking, request below may hang forever
-- hence the signal handler above */
if (read_ac_socket(sock, &tmp_buf, sizeof(tmp_buf)) < 1)
break;
}
alarm(atime);
sigaction(SIGALRM, &oldact, NULL);
}
if (chan != NULL)
DIS_tcp_cleanup(chan);
close(sock);
return(0);
} /* END pbs_disconnect_socket() */
int PBSD_commit(
int connect, /* I */
char *jobid) /* I */
{
struct batch_reply *reply;
int rc;
int sock;
struct tcp_chan *chan = NULL;
pthread_mutex_lock(connection[connect].ch_mutex);
sock = connection[connect].ch_socket;
pthread_mutex_unlock(connection[connect].ch_mutex);
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
return(PBSE_MEM_MALLOC);
}
else if ((rc = encode_DIS_ReqHdr(chan, PBS_BATCH_Commit, pbs_current_user)) ||
(rc = encode_DIS_JobId(chan, jobid)) ||
(rc = encode_DIS_ReqExtend(chan, NULL)))
{
pthread_mutex_lock(connection[connect].ch_mutex);
connection[connect].ch_errtxt = strdup(dis_emsg[rc]);
pthread_mutex_unlock(connection[connect].ch_mutex);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
if (DIS_tcp_wflush(chan))
{
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
DIS_tcp_cleanup(chan);
/* PBSD_rdrpy sets connection[connect].ch_errno */
reply = PBSD_rdrpy(&rc, connect);
PBSD_FreeReply(reply);
return(rc);
} /* END PBSD_commit() */
int PBSD_async_sig_put(
int c,
char *jobid,
char *signal,
char *extend)
{
int sock;
int rc = 0;
struct tcp_chan *chan = NULL;
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
rc = PBSE_PROTOCOL;
return rc;
}
else if ((rc = encode_DIS_ReqHdr(chan,PBS_BATCH_SignalJob,pbs_current_user))
|| (rc = encode_DIS_SignalJob(chan,jobid,signal))
|| (rc = encode_DIS_ReqExtend(chan,extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return (PBSE_PROTOCOL);
}
pthread_mutex_unlock(connection[c].ch_mutex);
if (DIS_tcp_wflush(chan))
{
rc = PBSE_PROTOCOL;
}
DIS_tcp_cleanup(chan);
return(rc);
} /* END PBSD_async_sig_put() */
static int PBS_resc(
int c,
int reqtype,
char **rescl,
int ct,
resource_t rh)
{
int rc;
int sock;
struct tcp_chan *chan = NULL;
sock = connection[c].ch_socket;
/* setup DIS support routines for following DIS calls */
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
pthread_mutex_unlock(connection[c].ch_mutex);
rc = PBSE_PROTOCOL;
return rc;
}
else if ((rc = encode_DIS_ReqHdr(chan, reqtype, pbs_current_user)) ||
(rc = encode_DIS_Resc(chan, rescl, ct, rh)) ||
(rc = encode_DIS_ReqExtend(chan, (char *)0)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return (PBSE_PROTOCOL);
}
if (DIS_tcp_wflush(chan))
{
rc = PBSE_PROTOCOL;
}
DIS_tcp_cleanup(chan);
return rc;
} /* END PBS_resc() */
int PBSD_status_put(
int c,
int function,
char *id,
struct attrl *attrib,
char *extend)
{
int rc = 0;
int sock;
sock = connection[c].ch_socket;
DIS_tcp_setup(sock);
if ((rc = encode_DIS_ReqHdr(sock, function, pbs_current_user)) ||
(rc = encode_DIS_Status(sock, id, attrib)) ||
(rc = encode_DIS_ReqExtend(sock, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
pbs_errno = PBSE_PROTOCOL;
return(pbs_errno);
}
if (DIS_tcp_wflush(sock))
{
pbs_errno = PBSE_PROTOCOL;
return(pbs_errno);
}
/* success */
return(0);
} /* END PBSD_status_put() */
int PBSD_gpu_put(
int c,
char *node,
char *gpuid,
int gpumode,
int reset_perm,
int reset_vol,
char *extend)
{
int sock;
int rc = 0;
struct tcp_chan *chan = NULL;
sock = connection[c].ch_socket;
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
return PBSE_PROTOCOL;
}
else if ((rc = encode_DIS_ReqHdr(chan, PBS_BATCH_GpuCtrl, pbs_current_user)) ||
(rc = encode_DIS_GpuCtrl(chan, node, gpuid, gpumode, reset_perm, reset_vol)) ||
(rc = encode_DIS_ReqExtend(chan, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
if (DIS_tcp_wflush(chan))
{
rc = PBSE_PROTOCOL;
}
DIS_tcp_cleanup(chan);
return(rc);
}
int PBSD_munge_authenticate(
int psock, /* I */
int handle) /* I */
{
int rc;
munge_ctx_t mctx = NULL;
munge_err_t mret = EMUNGE_SNAFU;
char *mcred = NULL;
/* user id and name stuff */
struct passwd *pwent;
uid_t myrealuid;
struct batch_reply *reply;
unsigned short user_port = 0;
struct sockaddr_in sockname;
socklen_t socknamelen = sizeof(sockname);
struct tcp_chan *chan;
if ((mctx = munge_ctx_create()) == NULL)
{
return(-1);
}
if ((mret = munge_encode (&mcred, mctx, NULL, 0)) != EMUNGE_SUCCESS)
{
const char *merrmsg = NULL;
if (!(merrmsg = munge_ctx_strerror(mctx)))
{
merrmsg = munge_strerror(mret);
}
fprintf(stderr, "munge_encode failed: %s (%d)\n", merrmsg, mret);
munge_ctx_destroy(mctx);
return(PBSE_MUNGE_NOT_FOUND); /*TODO more fine-grained error codes? */
}
munge_ctx_destroy(mctx);
/* We got the certificate. Now make the PBS_BATCH_AltAuthenUser request */
myrealuid = getuid();
pwent = getpwuid(myrealuid);
rc = getsockname(psock, (struct sockaddr *)&sockname, &socknamelen);
if (rc == -1)
{
fprintf(stderr, "getsockname failed: %d\n", errno);
return(-1);
}
user_port = ntohs(sockname.sin_port);
if ((chan = DIS_tcp_setup(psock)) == NULL)
{
}
else if ((rc = encode_DIS_ReqHdr(chan, PBS_BATCH_AltAuthenUser, pwent->pw_name)) ||
(rc = diswui(chan, user_port)) ||
(rc = diswst(chan, mcred)) ||
(rc = encode_DIS_ReqExtend(chan, NULL)) ||
(rc = DIS_tcp_wflush(chan)))
{
PBSD_munge_cred_destroy(&mcred);
/* ERROR */
return(rc);
}
else
{
int local_err = PBSE_NONE;
PBSD_munge_cred_destroy(&mcred);
/* read the reply */
if ((reply = PBSD_rdrpy(&local_err, handle)) != NULL)
free(reply);
return(PBSE_NONE);
}
return(-1);
}
int PBSD_munge_authenticate(
int psock, /* I */
int handle) /* I */
{
int rc = PBSE_NONE;
int fd;
FILE *munge_pipe;
char munge_buf[MUNGE_SIZE];
char munge_command[MUNGE_SIZE];
char *ptr; /* pointer to the current place to copy data into munge_buf */
int bytes_read;
int total_bytes_read = 0;
int local_errno = 0;
/* user id and name stuff */
struct passwd *pwent;
uid_t myrealuid;
struct batch_reply *reply;
unsigned short user_port = 0;
struct sockaddr_in sockname;
socklen_t socknamelen = sizeof(sockname);
struct tcp_chan *chan = NULL;
snprintf(munge_command,sizeof(munge_command),
"munge -n 2>/dev/null");
memset(munge_buf, 0, MUNGE_SIZE);
ptr = munge_buf;
if ((munge_pipe = popen(munge_command,"r")) == NULL)
{
/* FAILURE */
return(-1);
}
fd = fileno(munge_pipe);
while ((bytes_read = read_ac_socket(fd, ptr, MUNGE_SIZE - total_bytes_read)) > 0)
{
total_bytes_read += bytes_read;
ptr += bytes_read;
}
pclose(munge_pipe);
if (bytes_read == -1)
{
/* read failed */
local_errno = errno;
log_err(local_errno, __func__, "error reading pipe in PBSD_munge_authenticate");
return -1;
}
/* if we got no bytes back then Munge may not be installed etc. */
if (total_bytes_read == 0)
{
return(PBSE_MUNGE_NOT_FOUND);
}
/* We got the certificate. Now make the PBS_BATCH_AltAuthenUser request */
myrealuid = getuid();
pwent = getpwuid(myrealuid);
rc = getsockname(psock, (struct sockaddr *)&sockname, &socknamelen);
if (rc == -1)
{
fprintf(stderr, "getsockname failed: %d\n", errno);
return rc;
}
user_port = ntohs(sockname.sin_port);
if ((chan = DIS_tcp_setup(psock)) == NULL)
{
rc = PBSE_MEM_MALLOC;
}
else if ((rc = encode_DIS_ReqHdr(chan,PBS_BATCH_AltAuthenUser,pwent->pw_name)) ||
(rc = diswui(chan, user_port)) ||
(rc = diswst(chan, munge_buf)) ||
(rc = encode_DIS_ReqExtend(chan, NULL)) ||
(rc = DIS_tcp_wflush(chan)))
{
/* ERROR */
}
else
{
/* read the reply */
if ((reply = PBSD_rdrpy(&local_errno, handle)) != NULL)
free(reply);
rc = PBSE_NONE;
}
if (chan != NULL)
DIS_tcp_cleanup(chan);
return rc;
} /* END PBSD_munge_authenticate() */
int pbs_original_connect(
char *server) /* I (FORMAT: NULL | '\0' | HOSTNAME | HOSTNAME:PORT )*/
{
struct sockaddr_in server_addr;
struct hostent *hp;
int out;
int i;
#ifdef GSSAPI
int neediff = 0;
#endif
int auth;
struct passwd *pw;
int use_unixsock = 0;
#ifdef ENABLE_UNIX_SOCKETS
struct sockaddr_un unserver_addr;
char hnamebuf[256];
#endif
char *ptr;
/* reserve a connection state record */
out = -1;
for (i = 1;i < NCONNECTS;i++)
{
if (connection[i].ch_inuse)
continue;
out = i;
connection[out].ch_inuse = 1;
connection[out].ch_errno = 0;
connection[out].ch_socket = -1;
connection[out].ch_errtxt = NULL;
break;
}
if (out < 0)
{
pbs_errno = PBSE_NOCONNECTS;
if (getenv("PBSDEBUG"))
fprintf(stderr, "ALERT: cannot locate free channel\n");
/* FAILURE */
return(-1);
}
/* get server host and port */
server = PBS_get_server(server, &server_port);
if (server == NULL)
{
connection[out].ch_inuse = 0;
pbs_errno = PBSE_NOSERVER;
if (getenv("PBSDEBUG"))
fprintf(stderr, "ALERT: PBS_get_server() failed\n");
return(-1);
}
/* determine who we are */
pbs_current_uid = getuid();
if ((pw = getpwuid(pbs_current_uid)) == NULL)
{
pbs_errno = PBSE_SYSTEM;
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ALERT: cannot get password info for uid %ld\n",
(long)pbs_current_uid);
}
return(-1);
}
strcpy(pbs_current_user, pw->pw_name);
pbs_server = server; /* set for error messages from commands */
#ifdef ENABLE_UNIX_SOCKETS
/* determine if we want to use unix domain socket */
if (!strcmp(server, "localhost"))
use_unixsock = 1;
else if ((gethostname(hnamebuf, sizeof(hnamebuf) - 1) == 0) && !strcmp(hnamebuf, server))
use_unixsock = 1;
/* NOTE: if any part of using unix domain sockets fails,
* we just cleanup and try again with inet sockets */
/* get socket */
if (use_unixsock)
{
connection[out].ch_socket = socket(AF_UNIX, SOCK_STREAM, 0);
if (connection[out].ch_socket < 0)
{
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot create socket: errno=%d (%s)\n",
errno,
strerror(errno));
}
connection[out].ch_inuse = 0;
pbs_errno = PBSE_PROTOCOL;
use_unixsock = 0;
}
}
/* and connect... */
if (use_unixsock)
{
unserver_addr.sun_family = AF_UNIX;
strcpy(unserver_addr.sun_path, TSOCK_PATH);
if (connect(
connection[out].ch_socket,
(struct sockaddr *)&unserver_addr,
(strlen(unserver_addr.sun_path) + sizeof(unserver_addr.sun_family))) < 0)
{
close(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = errno;
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot connect to server, errno=%d (%s)\n",
errno,
strerror(errno));
}
use_unixsock = 0; /* will try again with inet socket */
}
}
if (use_unixsock)
{
if (!send_unix_creds(connection[out].ch_socket))
{
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot send unix creds to pbs_server: errno=%d (%s)\n",
errno,
strerror(errno));
}
close(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_PROTOCOL;
use_unixsock = 0; /* will try again with inet socket */
}
}
#endif /* END ENABLE_UNIX_SOCKETS */
if (!use_unixsock)
{
/* at this point, either using unix sockets failed, or we determined not to
* try */
connection[out].ch_socket = socket(AF_INET, SOCK_STREAM, 0);
if (connection[out].ch_socket < 0)
{
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot connect to server \"%s\", errno=%d (%s)\n",
server,
errno,
strerror(errno));
}
connection[out].ch_inuse = 0;
pbs_errno = PBSE_PROTOCOL;
return(-1);
}
/* connection succeeded re-mark as used */
connection[out].ch_inuse = 1;
server_addr.sin_family = AF_INET;
hp = NULL;
hp = gethostbyname(server);
/* setup DIS support routines for following pbs_* calls */
if (hp == NULL)
{
close(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = PBSE_BADHOST;
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot get servername (%s) errno=%d (%s)\n",
(server != NULL) ? server : "NULL",
errno,
strerror(errno));
}
return(-1);
}
memcpy((char *)&server_addr.sin_addr, hp->h_addr_list[0], hp->h_length);
server_addr.sin_port = htons(server_port);
if (connect(
connection[out].ch_socket,
(struct sockaddr *)&server_addr,
sizeof(server_addr)) < 0)
{
close(connection[out].ch_socket);
connection[out].ch_inuse = 0;
pbs_errno = errno;
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot connect to server, errno=%d (%s)\n",
errno,
strerror(errno));
}
return(-1);
}
DIS_tcp_setup(connection[out].ch_socket);
if ((ptr = getenv("PBSAPITIMEOUT")) != NULL)
{
pbs_tcp_timeout = strtol(ptr,NULL,0);
if (pbs_tcp_timeout <= 0)
{
pbs_tcp_timeout = 10800; /* set for 3 hour time out */
}
}
else
{
pbs_tcp_timeout = 10800; /* set for 3 hour time out */
}
/* If we have GSSAPI, then try gssapi authentication first. If that fails, fall back to iff.
If there's no GSSAPI, then just use iff.
*/
#ifdef GSSAPI
if (!getenv("TORQUE_IGNORE_KERBEROS") &&
!ignore_kerberos_for_connection &&
pbsgss_can_get_creds())
{
if (encode_DIS_ReqHdr(connection[out].ch_socket, PBS_BATCH_GSSAuthenUser, pbs_current_user) ||
encode_DIS_ReqExtend(connection[out].ch_socket,0))
{
if (getenv("PBSDEBUG"))
{
fprintf(stderr,"ERROR: cannot authenticate connection with gssapi, errno=%d (%s)\n", errno, strerror(errno));
}
neediff = 1;
}
else
{
DIS_tcp_wflush(connection[out].ch_socket);
if (pbsgss_client_authenticate(server,connection[out].ch_socket,1,1) != 0)
{
neediff = 1;
if (getenv("PBSDEBUG"))
{
fprintf(stderr,"ERROR: cannot authenticate connection, errno=%d (%s)\n", errno, strerror(errno));
}
}
}
}
else
{
neediff = 1;
}
if (neediff)
{
#endif
/* FIXME: is this necessary? Contributed by one user that fixes a problem,
but doesn't fix the same problem for another user! */
#if 0
#if defined(__hpux)
/*HP-UX : avoiding socket caching */
send(connection[out].ch_socket, '?', 1, MSG_OOB);
#endif
#endif
/* Have pbs_iff authenticate connection */
if ((ENABLE_TRUSTED_AUTH == FALSE) && ((auth = PBSD_authenticate(connection[out].ch_socket)) != 0))
{
close(connection[out].ch_socket);
connection[out].ch_inuse = 0;
if (auth == ENOENT)
{
pbs_errno = ENOENT;
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot find pbs_iif executable\n");
}
}
else
{
pbs_errno = PBSE_PERM;
if (getenv("PBSDEBUG"))
{
fprintf(stderr, "ERROR: cannot authenticate connection to server \"%s\", errno=%d (%s)\n",
server,
errno,
strerror(errno));
}
}
return(-1);
}
#ifdef GSSAPI
} /* END if neediff */
#endif
} /* END !useunix */
DIS_tcp_setup(connection[out].ch_socket);
if ((ptr = getenv("PBSAPITIMEOUT")) != NULL)
{
pbs_tcp_timeout = strtol(ptr, NULL, 0);
if (pbs_tcp_timeout <= 0)
{
pbs_tcp_timeout = 10800; /* set for 3 hour time out */
}
}
else
{
pbs_tcp_timeout = 10800; /* set for 3 hour time out */
}
return(out);
} /* END pbs_original_connect() */
int pbs_asyrunjob_err(
int c,
char *jobid, /* I */
char *location,
char *extend,
int *local_errno)
{
int rc;
struct batch_reply *reply;
unsigned int resch = 0;
int sock;
struct tcp_chan *chan = NULL;
if ((c < 0) || (jobid == NULL) || (*jobid == '\0'))
{
return(PBSE_IVALREQ);
}
if (location == NULL)
location = "";
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
/* setup DIS support routines for following DIS calls */
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
rc = PBSE_PROTOCOL;
return rc;
}
else if ((rc = encode_DIS_ReqHdr(chan, PBS_BATCH_AsyrunJob, pbs_current_user))
|| (rc = encode_DIS_RunJob(chan, jobid, location, resch))
|| (rc = encode_DIS_ReqExtend(chan, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
if (DIS_tcp_wflush(chan))
{
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
/* get reply */
reply = PBSD_rdrpy(local_errno, c);
rc = connection[c].ch_errno;
pthread_mutex_unlock(connection[c].ch_mutex);
PBSD_FreeReply(reply);
DIS_tcp_cleanup(chan);
return(rc);
} /* END pbs_asyrunjob_err() */
int pbs_runjob_err(
int c,
char *jobid,
char *location,
char *extend,
int *rc)
{
struct batch_reply *reply;
unsigned int resch = 0;
int sock;
struct tcp_chan *chan = NULL;
/* NOTE: set_task sets WORK_Deferred_Child : request remains until child terminates */
if ((jobid == NULL) ||
(*jobid == '\0'))
{
*rc = PBSE_IVALREQ;
return (*rc) * -1;
}
if ((c < 0) ||
(c >= PBS_NET_MAX_CONNECTIONS))
{
return(PBSE_IVALREQ * -1);
}
if (location == NULL)
{
location = (char *)"";
}
pthread_mutex_lock(connection[c].ch_mutex);
sock = connection[c].ch_socket;
/* setup DIS support routines for following DIS calls */
if ((chan = DIS_tcp_setup(sock)) == NULL)
{
pthread_mutex_unlock(connection[c].ch_mutex);
*rc = PBSE_PROTOCOL;
return(*rc);
}
/* send run request */
else if ((*rc = encode_DIS_ReqHdr(chan, PBS_BATCH_RunJob, pbs_current_user)) ||
(*rc = encode_DIS_RunJob(chan, jobid, location, resch)) ||
(*rc = encode_DIS_ReqExtend(chan, extend)))
{
connection[c].ch_errtxt = strdup(dis_emsg[*rc]);
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
if ((*rc = DIS_tcp_wflush(chan)) != PBSE_NONE)
{
pthread_mutex_unlock(connection[c].ch_mutex);
DIS_tcp_cleanup(chan);
return(PBSE_PROTOCOL);
}
/* get reply */
reply = PBSD_rdrpy(rc, c);
/* *rc = connection[c].ch_errno; */
pthread_mutex_unlock(connection[c].ch_mutex);
PBSD_FreeReply(reply);
DIS_tcp_cleanup(chan);
return(*rc);
} /* END pbs_runjob_err() */
int do_mom(
char *HPtr,
int MOMPort,
int CmdIndex)
{
int socket;
int local_errno = 0;
struct tcp_chan *chan = NULL;
int rc;
if ((socket = openrm(HPtr, MOMPort)) < 0)
{
/* FAILURE */
extern char TRMEMsg[];
fprintf(stderr, "cannot connect to MOM on node '%s', errno=%d (%s)\n",
HPtr,
errno,
strerror(errno));
if (TRMEMsg[0] != '\0')
{
fprintf(stderr, " %s\n",
TRMEMsg);
}
return(socket);
}
else if ((chan = DIS_tcp_setup(socket)) == NULL)
{
fprintf(stderr, "%s: can not allocate memory of socket buffers\n", __func__);
return -1;
}
/* send protocol and version, plus how many queries we're sending */
if (QueryI == 0)
QueryI = 1;
if (start_dialogue(chan) != DIS_SUCCESS)
{
fprintf(stderr,"ERROR: Unable to write the number of queries to %s (errno=%d-%s)\n",
HPtr,
errno,
strerror(errno));
send_command(chan,RM_CMD_CLOSE);
DIS_tcp_cleanup(chan);
return(-1);
}
if (IsVerbose == TRUE)
{
fprintf(stderr, "INFO: successfully connected to %s\n",
HPtr);
}
switch (CmdIndex)
{
case momClear:
{
char tmpLine[1024];
char *Value;
snprintf(tmpLine, 1024, "clearjob=%s",
(JPtr != NULL) ? JPtr : "all");
if (send_command_str(chan, RM_CMD_REQUEST, tmpLine) != 0)
{
/* FAILURE */
fprintf(stderr,"ERROR: cannot request job clear on %s (errno=%d-%s)\n",
HPtr,
errno,
strerror(errno));
send_command(chan,RM_CMD_CLOSE);
return(-1);
}
if ((Value = (char *)read_mom_reply(&local_errno, chan)) == NULL)
{
/* FAILURE */
fprintf(stderr,"ERROR: job clear failed on %s (errno=%d - %s: %d - %s)\n",
HPtr,
errno,
pbs_strerror(errno),
local_errno,
pbs_strerror(local_errno));
send_command(chan,RM_CMD_CLOSE);
return(-1);
}
/* job cleared */
fprintf(stdout,"job clear request successful on %s\n",
HPtr);
free(Value);
} /* END BLOCK (case momClear) */
break;
case momShutdown:
{
if ((send_command(chan,RM_CMD_SHUTDOWN) != PBSE_NONE) ||
(check_success(chan) != PBSE_NONE))
{
/* FAILURE */
fprintf(stderr,"ERROR: cannot shutdown mom daemon on %s (errno=%d-%s)\n",
HPtr,
errno,
pbs_strerror(errno));
send_command(chan,RM_CMD_CLOSE);
exit(EXIT_FAILURE);
}
fprintf(stdout, "shutdown request successful on %s\n",
HPtr);
} /* END BLOCK */
break;
case momReconfig:
{
if ((send_command(chan,RM_CMD_CONFIG) != PBSE_NONE) ||
(check_success(chan) != PBSE_NONE))
{
/* FAILURE */
fprintf(stderr,"ERROR: cannot reconfigure mom on %s (errno=%d-%s)\n",
HPtr,
errno,
pbs_strerror(errno));
send_command(chan,RM_CMD_CLOSE);
return(-1);
}
fprintf(stdout, "reconfig successful on %s\n",
HPtr);
} /* END BLOCK (case momReconfig) */
break;
case momLayout:
char *value;
if (send_command(chan, RM_CMD_LAYOUT) != PBSE_NONE)
{
fprintf(stdout, "Layout command failed to send to mom\n");
return(-1);
}
if ((value = read_mom_reply(&local_errno, chan)) == NULL)
{
fprintf(stdout, "Could not read a layout reply from the mom\n");
return(-1);
}
else
{
fprintf(stdout, "%s", value);
free(value);
}
break;
case momQuery:
default:
{
char *ptr;
int rindex;
char *Value;
for (rindex = 0; rindex < QueryI; rindex++)
{
if (send_command_str(chan, RM_CMD_REQUEST, Query[rindex]) != 0)
{
fprintf(stderr,"ERROR: cannot add query for '%s' on %s (errno=%d-%s)\n",
Query[rindex],
HPtr,
errno,
pbs_strerror(errno));
}
}
for (rindex = 0;rindex < QueryI;rindex++)
{
if ((ptr = strchr(Query[rindex],'=')) != NULL)
{
*ptr = '\0';
}
if ((Value = (char *)read_mom_reply(&local_errno, chan)) == NULL)
{
fprintf(stderr, "ERROR: query[%d] '%s' failed on %s (errno=%d - %s : %d - %s)\n",
rindex,
Query[rindex],
HPtr,
errno,
pbs_strerror(errno),
local_errno,
pbs_strerror(local_errno));
return(-1);
}
else
{
if (!strncmp(Query[rindex], "diag", strlen("diag")))
{
fprintf(stdout, "%s\n",
Value);
}
else if (!strncmp(Query[rindex], "cycle", strlen("cycle")))
{
fprintf(stdout, "mom %s successfully cycled %s\n",
HPtr,
Value);
}
else
{
fprintf(stdout, "%12s: %12s = '%s'\n",
HPtr,
Query[rindex],
Value);
}
}
free(Value);
if (ptr != NULL)
{
*ptr = '=';
}
} /* END for (rindex) */
} /* END BLOCK (case momQuery) */
break;
} /* END switch(CmdIndex) */
rc = diswsi(chan, RM_PROTOCOL);
if (rc != DIS_SUCCESS)
goto do_mom_fail;
rc = diswsi(chan, RM_PROTOCOL_VER);
if (rc != DIS_SUCCESS)
goto do_mom_fail;
rc = diswsi(chan, 1);
if (rc != DIS_SUCCESS)
goto do_mom_fail;
/* send_command will free chan */
send_command(chan,RM_CMD_CLOSE);
return(0);
do_mom_fail:
DIS_tcp_close(chan);
return(rc);
} /* END do_mom() */
int
__pbs_rerunjob(int c, char *jobid, char *extend)
{
int rc;
struct batch_reply *reply;
int sock;
time_t old_tcp_timeout;
if ((jobid == NULL) || (*jobid == '\0'))
return (pbs_errno = PBSE_IVALREQ);
sock = connection[c].ch_socket;
/* initialize the thread context data, if not already initialized */
if (pbs_client_thread_init_thread_context() != 0)
return pbs_errno;
/* lock pthread mutex here for this connection */
/* blocking call, waits for mutex release */
if (pbs_client_thread_lock_connection(c) != 0)
return pbs_errno;
/* setup DIS support routines for following DIS calls */
DIS_tcp_setup(sock);
if ((rc = encode_DIS_ReqHdr(sock, PBS_BATCH_Rerun, pbs_current_user)) ||
(rc = encode_DIS_JobId(sock, jobid)) ||
(rc = encode_DIS_ReqExtend(sock, extend))) {
connection[c].ch_errtxt = strdup(dis_emsg[rc]);
if (connection[c].ch_errtxt == NULL) {
pbs_errno = PBSE_SYSTEM;
} else {
pbs_errno = PBSE_PROTOCOL;
}
(void)pbs_client_thread_unlock_connection(c);
return pbs_errno;
}
/* write data */
if (DIS_tcp_wflush(sock)) {
pbs_errno = PBSE_PROTOCOL;
(void)pbs_client_thread_unlock_connection(c);
return pbs_errno;
}
/* Set timeout value to very long value as rerun request */
/* goes from Server to Mom and may take a long time */
old_tcp_timeout = pbs_tcp_timeout;
pbs_tcp_timeout = PBS_DIS_TCP_TIMEOUT_VLONG;
/* read reply from stream into presentation element */
reply = PBSD_rdrpy(c);
/* reset timeout */
pbs_tcp_timeout = old_tcp_timeout;
PBSD_FreeReply(reply);
rc = connection[c].ch_errno;
/* unlock the thread lock and update the thread context data */
if (pbs_client_thread_unlock_connection(c) != 0)
return pbs_errno;
return rc;
}