char *tr_msg_encode(TR_MSG *msg)
{
json_t *jmsg=NULL;
json_t *jmsg_type=NULL;
char *encoded=NULL;
TID_RESP *tidresp=NULL;
TID_REQ *tidreq=NULL;
TRP_UPD *trpupd=NULL;
TRP_REQ *trpreq=NULL;
/* TBD -- add error handling */
jmsg = json_object();
switch (msg->msg_type)
{
case TID_REQUEST:
jmsg_type = json_string("tid_request");
json_object_set_new(jmsg, "msg_type", jmsg_type);
tidreq=tr_msg_get_req(msg);
json_object_set_new(jmsg, "msg_body", tr_msg_encode_tidreq(tidreq));
break;
case TID_RESPONSE:
jmsg_type = json_string("tid_response");
json_object_set_new(jmsg, "msg_type", jmsg_type);
tidresp=tr_msg_get_resp(msg);
json_object_set_new(jmsg, "msg_body", tr_msg_encode_tidresp(tidresp));
break;
case TRP_UPDATE:
jmsg_type = json_string("trp_update");
json_object_set_new(jmsg, "msg_type", jmsg_type);
trpupd=tr_msg_get_trp_upd(msg);
json_object_set_new(jmsg, "msg_body", tr_msg_encode_trp_upd(trpupd));
break;
case TRP_REQUEST:
jmsg_type = json_string("trp_request");
json_object_set_new(jmsg, "msg_type", jmsg_type);
trpreq=tr_msg_get_trp_req(msg);
json_object_set_new(jmsg, "msg_body", tr_msg_encode_trp_req(trpreq));
break;
default:
json_decref(jmsg);
return NULL;
}
encoded=json_dumps(jmsg, 0);
json_decref(jmsg);
return encoded;
}
void tr_msg_free_decoded(TR_MSG *msg)
{
if (msg) {
switch (msg->msg_type) {
case TID_REQUEST:
tid_req_free(tr_msg_get_req(msg));
break;
case TID_RESPONSE:
tid_resp_free(tr_msg_get_resp(msg));
break;
case TRP_UPDATE:
trp_upd_free(tr_msg_get_trp_upd(msg));
break;
case TRP_REQUEST:
trp_req_free(tr_msg_get_trp_req(msg));
default:
break;
}
free (msg);
}
}
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;
}
