/**
* Write a response to the GSS connection
*
* @param conn file descriptor for the connection
* @param gssctx GSS context
* @param resp encoded response string to send
* @return 0 on success, -1 on error
*/
static int tr_gss_write_resp(int conn, gss_ctx_id_t gssctx, const char *resp)
{
int err = 0;
/* Send the response over the connection */
err = gsscon_write_encrypted_token (conn, gssctx, resp, strlen(resp) + 1);
if (err) {
tr_debug("tr_gss_send_response: Error sending response over connection, rc=%d.", err);
return -1;
}
return 0;
}
/**
* Encode/send a response
*
* Part of the public interface
*
* @param tids not actually used, but kept for ABI compatibility
* @param req
* @param resp
* @return
*/
int tids_send_response (TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp)
{
int err;
char *resp_buf;
if ((!tids) || (!req) || (!resp)) {
tr_debug("tids_send_response: Invalid parameters.");
return -1;
}
/* Never send a second response if we already sent one. */
if (req->resp_sent)
return 0;
resp_buf = tids_encode_response(NULL, NULL);
if (resp_buf == NULL) {
tr_err("tids_send_response: Error encoding json response.");
tr_audit_req(req);
return -1;
}
tr_debug("tids_send_response: Encoded response: %s", resp_buf);
/* If external logging is enabled, fire off a message */
/* TODO Can be moved to end once segfault in gsscon_write_encrypted_token fixed */
tr_audit_resp(resp);
/* Send the response over the connection */
err = gsscon_write_encrypted_token (req->conn, req->gssctx, resp_buf,
strlen(resp_buf) + 1);
if (err) {
tr_notice("tids_send_response: Error sending response over connection.");
tr_audit_req(req);
return -1;
}
/* indicate that a response has been sent for this request */
req->resp_sent = 1;
free(resp_buf);
return 0;
}
int tidc_fwd_request(TIDC_INSTANCE *tidc,
TID_REQ *tid_req,
TIDC_RESP_FUNC *resp_handler,
void *cookie)
{
char *req_buf = NULL;
char *resp_buf = NULL;
size_t resp_buflen = 0;
TR_MSG *msg = NULL;
TR_MSG *resp_msg = NULL;
int err;
int rc = 0;
/* Create and populate a TID msg structure */
if (!(msg = talloc_zero(tid_req, TR_MSG)))
goto error;
msg->msg_type = TID_REQUEST;
tr_msg_set_req(msg, tid_req);
/* store the response function and cookie */
// tid_req->resp_func = resp_handler;
// tid_req->cookie = cookie;
/* Encode the request into a json string */
if (!(req_buf = tr_msg_encode(msg))) {
tr_err("tidc_fwd_request: Error encoding TID request.\n");
goto error;
}
tr_debug( "tidc_fwd_request: Sending TID request:\n");
tr_debug( "%s\n", req_buf);
/* Send the request over the connection */
if (err = gsscon_write_encrypted_token (tid_req->conn, tid_req->gssctx, req_buf,
strlen(req_buf))) {
tr_err( "tidc_fwd_request: Error sending request over connection.\n");
goto error;
}
/* TBD -- queue request on instance, read resps in separate thread */
/* Read the response from the connection */
/* TBD -- timeout? */
if (err = gsscon_read_encrypted_token(tid_req->conn, tid_req->gssctx, &resp_buf, &resp_buflen)) {
if (resp_buf)
free(resp_buf);
goto error;
}
tr_debug( "tidc_fwd_request: Response Received (%u bytes).\n", (unsigned) resp_buflen);
tr_debug( "%s\n", resp_buf);
if (NULL == (resp_msg = tr_msg_decode(resp_buf, resp_buflen))) {
tr_err( "tidc_fwd_request: Error decoding response.\n");
goto error;
}
/* TBD -- Check if this is actually a valid response */
if (TID_RESPONSE != tr_msg_get_msg_type(resp_msg)) {
tr_err( "tidc_fwd_request: Error, no response in the response!\n");
goto error;
}
if (resp_handler) {
/* Call the caller's response function. It must copy any data it needs before returning. */
tr_debug("tidc_fwd_request: calling response callback function.");
(*resp_handler)(tidc, tid_req, tr_msg_get_resp(resp_msg), cookie);
}
goto cleanup;
error:
rc = -1;
cleanup:
if (msg)
talloc_free(msg);
if (req_buf)
free(req_buf);
if (resp_buf)
free(resp_buf);
if (resp_msg)
tr_msg_free_decoded(resp_msg);
return rc;
}