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; }
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 * issue a batch request to another server or to a MOM * or even to ourself! * * If the request is meant for this every server, then * Set up work-task of type WORK_Deferred_Local with a dummy * connection handle (PBS_LOCAL_CONNECTION). * * Dispatch the request to be processed. [reply_send() will * dispatch the reply via the work task entry.] * * If the request is to another server/MOM, then * Set up work-task of type WORK_Deferred_Reply with the * connection handle as the event. * * Encode and send the request. * * When the reply is ready, process_reply() will decode it and * dispatch the work task. * * @note * IT IS UP TO THE FUNCTION DISPATCHED BY THE WORK TASK TO CLOSE THE * CONNECTION (connection handle not socket) and FREE THE REQUEST * STRUCTURE. The connection (non-negative if open) is in wt_event * and the pointer to the request structure is in wt_parm1. * * @param[in] conn - connection index * @param[in] request - batch request to send * @param[in] func - The callback function to invoke to handle the batch reply * @param[out] ppwt - Return work task to be maintained by server to handle * deferred replies * @param[in] rpp - conn is over tcp or rpp? * * @return Error code * @retval 0 - Success * @retval -1 - Failure * */ int issue_Drequest(int conn, struct batch_request *request, void (*func)(), struct work_task **ppwt, int rpp) { struct attropl *patrl; struct work_task *ptask; struct svrattrl *psvratl; int rc; int sock = -1; enum work_type wt; char *msgid = NULL; request->rppcmd_msgid = NULL; if (conn == PBS_LOCAL_CONNECTION) { wt = WORK_Deferred_Local; request->rq_conn = PBS_LOCAL_CONNECTION; } else if (rpp) { sock = conn; request->rq_conn = conn; wt = WORK_Deferred_Reply; } else { sock = connection[conn].ch_socket; request->rq_conn = sock; wt = WORK_Deferred_Reply; DIS_tcp_setup(sock); } ptask = set_task(wt, (long) conn, func, (void *) request); if (ptask == NULL) { log_err(errno, __func__, "could not set_task"); if (ppwt != 0) *ppwt = 0; return (-1); } if (conn == PBS_LOCAL_CONNECTION) { /* the request should be issued to ourself */ dispatch_request(PBS_LOCAL_CONNECTION, request); if (ppwt != 0) *ppwt = ptask; return (0); } /* the request is bound to another server, encode/send the request */ switch (request->rq_type) { #ifndef PBS_MOM case PBS_BATCH_DeleteJob: rc = PBSD_mgr_put(conn, PBS_BATCH_DeleteJob, MGR_CMD_DELETE, MGR_OBJ_JOB, request->rq_ind.rq_delete.rq_objname, NULL, request->rq_extend, rpp, &msgid); break; case PBS_BATCH_HoldJob: attrl_fixlink(&request->rq_ind.rq_hold.rq_orig.rq_attr); psvratl = (struct svrattrl *)GET_NEXT( request->rq_ind.rq_hold.rq_orig.rq_attr); patrl = &psvratl->al_atopl; rc = PBSD_mgr_put(conn, PBS_BATCH_HoldJob, MGR_CMD_SET, MGR_OBJ_JOB, request->rq_ind.rq_hold.rq_orig.rq_objname, patrl, NULL, rpp, &msgid); break; case PBS_BATCH_MessJob: rc = PBSD_msg_put(conn, request->rq_ind.rq_message.rq_jid, request->rq_ind.rq_message.rq_file, request->rq_ind.rq_message.rq_text, NULL, rpp, &msgid); break; case PBS_BATCH_RelnodesJob: rc = PBSD_relnodes_put(conn, request->rq_ind.rq_relnodes.rq_jid, request->rq_ind.rq_relnodes.rq_node_list, NULL, rpp, &msgid); break; case PBS_BATCH_PySpawn: rc = PBSD_py_spawn_put(conn, request->rq_ind.rq_py_spawn.rq_jid, request->rq_ind.rq_py_spawn.rq_argv, request->rq_ind.rq_py_spawn.rq_envp, rpp, &msgid); break; case PBS_BATCH_ModifyJob: attrl_fixlink(&request->rq_ind.rq_modify.rq_attr); patrl = (struct attropl *)&((struct svrattrl *)GET_NEXT( request->rq_ind.rq_modify.rq_attr))->al_atopl; rc = PBSD_mgr_put(conn, PBS_BATCH_ModifyJob, MGR_CMD_SET, MGR_OBJ_JOB, request->rq_ind.rq_modify.rq_objname, patrl, NULL, rpp, &msgid); break; case PBS_BATCH_Rerun: if (rpp) { rc = is_compose_cmd(sock, IS_CMD, &msgid); if (rc != 0) break; } rc=encode_DIS_ReqHdr(sock, PBS_BATCH_Rerun, pbs_current_user); if (rc != 0) break; rc=encode_DIS_JobId(sock, request->rq_ind.rq_rerun); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, 0); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; case PBS_BATCH_RegistDep: if (rpp) { rc = is_compose_cmd(sock, IS_CMD, &msgid); if (rc != 0) break; } rc=encode_DIS_ReqHdr(sock, PBS_BATCH_RegistDep, pbs_current_user); if (rc != 0) break; rc=encode_DIS_Register(sock, request); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, 0); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; case PBS_BATCH_SignalJob: rc = PBSD_sig_put(conn, request->rq_ind.rq_signal.rq_jid, request->rq_ind.rq_signal.rq_signame, NULL, rpp, &msgid); break; case PBS_BATCH_StatusJob: rc = PBSD_status_put(conn, PBS_BATCH_StatusJob, request->rq_ind.rq_status.rq_id, NULL, NULL, rpp, &msgid); break; case PBS_BATCH_TrackJob: if (rpp) { rc = is_compose_cmd(sock, IS_CMD, &msgid); if (rc != 0) break; } rc=encode_DIS_ReqHdr(sock, PBS_BATCH_TrackJob, pbs_current_user); if (rc != 0) break; rc=encode_DIS_TrackJob(sock, request); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, request->rq_extend); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; case PBS_BATCH_CopyFiles: if (rpp) { rc = is_compose_cmd(sock, IS_CMD, &msgid); if (rc != 0) break; } rc=encode_DIS_ReqHdr(sock, PBS_BATCH_CopyFiles, pbs_current_user); if (rc != 0) break; rc=encode_DIS_CopyFiles(sock, request); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, 0); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; case PBS_BATCH_CopyFiles_Cred: if (rpp) { rc = is_compose_cmd(sock, IS_CMD, &msgid); if (rc != 0) break; } rc=encode_DIS_ReqHdr(sock, PBS_BATCH_CopyFiles_Cred, pbs_current_user); if (rc != 0) break; rc=encode_DIS_CopyFiles_Cred(sock, request); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, 0); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; case PBS_BATCH_DelFiles: if (rpp) { rc = is_compose_cmd(sock, IS_CMD, &msgid); if (rc != 0) break; } rc=encode_DIS_ReqHdr(sock, PBS_BATCH_DelFiles, pbs_current_user); if (rc != 0) break; rc=encode_DIS_CopyFiles(sock, request); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, 0); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; case PBS_BATCH_DelFiles_Cred: if (rpp) { rc = is_compose_cmd(sock, IS_CMD, &msgid); if (rc != 0) break; } rc=encode_DIS_ReqHdr(sock, PBS_BATCH_DelFiles_Cred, pbs_current_user); if (rc != 0) break; rc=encode_DIS_CopyFiles_Cred(sock, request); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, 0); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; case PBS_BATCH_FailOver: rc = put_failover(sock, request); /* we should never do rpp for this one */ break; #else /* PBS_MOM */ case PBS_BATCH_JobObit: rc=encode_DIS_ReqHdr(sock, PBS_BATCH_JobObit, pbs_current_user); if (rc != 0) break; rc=encode_DIS_JobObit(sock, request); if (rc != 0) break; rc=encode_DIS_ReqExtend(sock, 0); if (rc != 0) break; rc = DIS_wflush(sock, rpp); break; #endif /* PBS_MOM */ default: (void)sprintf(log_buffer, msg_issuebad, request->rq_type); log_err(-1, __func__, log_buffer); delete_task(ptask); rc = -1; break; } if (rc) { sprintf(log_buffer, "issue_Drequest failed, error=%d on request %d", rc, request->rq_type); log_err(-1, __func__, log_buffer); if (msgid) free(msgid); delete_task(ptask); } else if (ppwt != 0) { if (rpp) { rpp_add_close_func(sock, process_DreplyRPP); /* register a close handler */ ptask->wt_event2 = msgid; /* * since its an rpp delayed task, remove it from the task_event list * caller will add to moms deferred cmd list */ delete_link(&ptask->wt_linkall); } ptask->wt_aux2 = rpp; /* 0 in case of non-TPP */ *ppwt = ptask; } return (rc); }
/** * @brief * encode a Job Credential Batch Request * * @param[in] c - socket descriptor * @param[in] type - credential type * @param[in] buf - credentials * @param[in] len - credential length * @param[in] rpp - indication for whether to use rpp * @param[in] msgid - msg id * * @return int * @retval 0 success * @retval !0(pbse error) error * */ int PBSD_jcred(int c, int type, char *buf, int len, int rpp, char **msgid) { int rc; struct batch_reply *reply = NULL; 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; } #ifdef PBS_CRED_GRIDPROXY if (type == PBS_CREDTYPE_GRIDPROXY) { OM_uint32 major, minor; gss_buffer_desc input, output; /* OM_uint32 flag = GSS_C_CONF_FLAG|GSS_C_DELEG_FLAG; */ OM_uint32 flag = GSS_C_CONF_FLAG; gss_ctx_id_t context = GSS_C_NO_CONTEXT; OM_uint32 life; int ret; output.length = 0; input.length = 0; for (;;) { major = gss_init_sec_context(&minor, GSS_C_NO_CREDENTIAL, &context, GSS_C_NO_NAME, GSS_C_NO_OID, flag, 0, GSS_C_NO_CHANNEL_BINDINGS, &input, NULL, &output, NULL, NULL); if (reply) PBSD_FreeReply(reply); rc = PBSD_GSS_context(sock, output.value, output.length); if (rc) { connection[c].ch_errtxt = strdup(dis_emsg[rc]); if (connection[c].ch_errtxt == NULL) return (pbs_errno = PBSE_SYSTEM); return (pbs_errno = PBSE_PROTOCOL); } if (GSS_ERROR(major)) { connection[c].ch_errtxt = pbs_gss_error("gss_init_sec_context", major, minor); return (pbs_errno = PBSE_PROTOCOL); } reply = PBSD_rdrpy(c); if (reply == NULL) return (pbs_errno = PBSE_PROTOCOL); if (pbs_errno != PBSE_NONE) { PBSD_FreeReply(reply); return pbs_errno; } if (reply->brp_choice == BATCH_REPLY_CHOICE_Text) { input.length = reply->brp_un.brp_txt.brp_txtlen; input.value = reply->brp_un.brp_txt.brp_str; } else { input.length = 0; input.value = NULL; } if (input.length == 0 && (major & GSS_S_CONTINUE_NEEDED) == 0) break; } if (reply) PBSD_FreeReply(reply); (void)gss_release_buffer(&minor, &output); if (major != GSS_S_COMPLETE || context == GSS_C_NO_CONTEXT) { connection[c].ch_errtxt = strdup("context could not be established"); if (connection[c].ch_errtxt == NULL) return (pbs_errno = PBSE_SYSTEM); return (pbs_errno = PBSE_PROTOCOL); } input.value = buf; input.length = len; output.length = 0; major = gss_seal(&minor, context, 1, GSS_C_QOP_DEFAULT, &input, &ret, &output); if (major != GSS_S_COMPLETE) { connection[c].ch_errtxt = pbs_gss_error("gss_seal", major, minor); return (pbs_errno = PBSE_PROTOCOL); } if (ret == 0) { connection[c].ch_errtxt = strdup("confidentiality not available"); if (connection[c].ch_errtxt == NULL) return (pbs_errno = PBSE_SYSTEM); return (pbs_errno = PBSE_PROTOCOL); } buf = output.value; len = output.length; output.length = 0; major = gss_delete_sec_context(&minor, &context, &output); if (major == GSS_S_COMPLETE && output.length > 0) { (void)gss_process_context_token(&minor, context, &output); (void)gss_release_buffer(&minor, &output); } } #endif if ((rc =encode_DIS_ReqHdr(sock, PBS_BATCH_JobCred, pbs_current_user)) || (rc = encode_DIS_JobCred(sock, type, buf, len)) || (rc = encode_DIS_ReqExtend(sock, (char *)0))) { if (!rpp) { connection[c].ch_errtxt = strdup(dis_emsg[rc]); if (connection[c].ch_errtxt == NULL) return (pbs_errno = PBSE_SYSTEM); } return (pbs_errno = PBSE_PROTOCOL); } if (rpp) { pbs_errno = PBSE_NONE; if (rpp_flush(sock)) pbs_errno = PBSE_PROTOCOL; return (pbs_errno); } if (DIS_tcp_wflush(sock)) { return (pbs_errno = PBSE_PROTOCOL); } reply = PBSD_rdrpy(c); PBSD_FreeReply(reply); return connection[c].ch_errno; }