X-Git-Url: http://www.project-moonshot.org/gitweb/?p=trust_router.git;a=blobdiff_plain;f=tid%2Ftids.c;h=9b9d51f71d90dbb555cbbda477ae346aaea9b13b;hp=3d37739e7295adef960e3ddb42f3eac52b7cf1b7;hb=3c5fb17459ff56d5e23cea059503f46a42150a1e;hpb=1a3ad555c6b58de28efb85e7ab07c2f35208ab0d diff --git a/tid/tids.c b/tid/tids.c index 3d37739..9b9d51f 100644 --- a/tid/tids.c +++ b/tid/tids.c @@ -37,10 +37,8 @@ #include #include #include -#include #include #include -#include #include #include #include @@ -52,7 +50,14 @@ #include #include -static TID_RESP *tids_create_response(TALLOC_CTX *mem_ctx, TIDS_INSTANCE *tids, TID_REQ *req) +/** + * Create a response with minimal fields filled in + * + * @param mem_ctx talloc context for the return value + * @param req request to respond to + * @return new response structure allocated in the mem_ctx context + */ +static TID_RESP *tids_create_response(TALLOC_CTX *mem_ctx, TID_REQ *req) { TID_RESP *resp=NULL; int success=0; @@ -75,6 +80,12 @@ static TID_RESP *tids_create_response(TALLOC_CTX *mem_ctx, TIDS_INSTANCE *tids, goto cleanup; } } + if (req->request_id) { + if (NULL == (resp->request_id = tr_dup_name(req->request_id))) { + tr_crit("tids_create_response: Error allocating fields in response."); + goto cleanup; + } + } success=1; @@ -86,22 +97,6 @@ cleanup: return resp; } -/* returns EACCES if authorization is denied */ -static int tids_auth_cb(gss_name_t clientName, gss_buffer_t displayName, - void *data) -{ - struct tids_instance *inst = (struct tids_instance *) data; - TR_NAME name ={(char *) displayName->value, (int) displayName->length}; - int result=0; - - if (0!=inst->auth_handler(clientName, &name, inst->cookie)) { - tr_debug("tids_auth_cb: client '%.*s' denied authorization.", name.len, name.buf); - result=EACCES; /* denied */ - } - - return result; -} - static int tids_handle_request(TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp) { int rc=-1; @@ -112,8 +107,8 @@ static int tids_handle_request(TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp (!(req->realm)) || (!(req->comm))) { tr_notice("tids_handle_request(): Not a valid TID Request."); - resp->result = TID_ERROR; - resp->err_msg = tr_new_name("Bad request format"); + tid_resp_set_result(resp, TID_ERROR); + tid_resp_set_err_msg(resp, tr_new_name("Bad request format")); return -1; } @@ -125,14 +120,13 @@ static int tids_handle_request(TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp if (0 > (rc = (*tids->req_handler)(tids, req, resp, tids->cookie))) { /* set-up an error response */ tr_debug("tids_handle_request: req_handler returned error."); - resp->result = TID_ERROR; - if (!resp->err_msg) /* Use msg set by handler, if any */ - resp->err_msg = tr_new_name("Internal processing error"); - } - else { + tid_resp_set_result(resp, TID_ERROR); + if (!tid_resp_get_err_msg(resp)) /* Use msg set by handler, if any */ + tid_resp_set_err_msg(resp, tr_new_name("Internal processing error")); + } else { /* set-up a success response */ tr_debug("tids_handle_request: req_handler returned success."); - resp->result = TID_SUCCESS; + tid_resp_set_result(resp, TID_SUCCESS); resp->err_msg = NULL; /* No error msg on successful return */ } @@ -143,12 +137,10 @@ static int tids_handle_request(TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp * Produces a JSON-encoded msg containing the TID response * * @param mem_ctx talloc context for the return value - * @param tids TIDS_INSTANCE handling the request - * @param req incoming request * @param resp outgoing response * @return JSON-encoded message containing the TID response */ -static char *tids_encode_response(TALLOC_CTX *mem_ctx, TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp) +static char *tids_encode_response(TALLOC_CTX *mem_ctx, TID_RESP *resp) { TR_MSG mresp; char *resp_buf = NULL; @@ -192,7 +184,7 @@ int tids_send_err_response (TIDS_INSTANCE *tids, TID_REQ *req, const char *err_m if (req->resp_sent) return 0; - if (NULL == (resp = tids_create_response(req, tids, req))) { + if (NULL == (resp = tids_create_response(req, req))) { tr_crit("tids_send_err_response: Can't create response."); return -1; } @@ -213,7 +205,7 @@ int tids_send_err_response (TIDS_INSTANCE *tids, TID_REQ *req, const char *err_m * * Part of the public interface * - * @param tids + * @param tids not actually used, but kept for ABI compatibility * @param req * @param resp * @return @@ -232,7 +224,7 @@ int tids_send_response (TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp) if (req->resp_sent) return 0; - resp_buf = tids_encode_response(NULL, tids, req, resp); + resp_buf = tids_encode_response(NULL, NULL); if (resp_buf == NULL) { tr_err("tids_send_response: Error encoding json response."); tr_audit_req(req); @@ -269,41 +261,45 @@ int tids_send_response (TIDS_INSTANCE *tids, TID_REQ *req, TID_RESP *resp) * @param data pointer to a TIDS_INSTANCE * @return pointer to the response string or null to send no response */ -static char *tids_req_cb(TALLOC_CTX *mem_ctx, const char *req_str, void *data) +static TR_MSG *tids_req_cb(TALLOC_CTX *mem_ctx, TR_MSG *mreq, void *data) { + TALLOC_CTX *tmp_ctx = talloc_new(NULL); TIDS_INSTANCE *tids = talloc_get_type_abort(data, TIDS_INSTANCE); - TR_MSG *mreq = NULL; TID_REQ *req = NULL; TID_RESP *resp = NULL; - char *resp_str = NULL; + TR_MSG *resp_msg = NULL; /* this is the return value */ int rc = 0; - mreq = tr_msg_decode(req_str, strlen(req_str)); // allocates memory on success! - if (mreq == NULL) { - tr_debug("tids_req_cb: Error decoding request."); - return NULL; - } - /* If this isn't a TID Request, just drop it. */ if (mreq->msg_type != TID_REQUEST) { - tr_msg_free_decoded(mreq); tr_debug("tids_req_cb: Not a TID request, dropped."); - return NULL; + goto cleanup; } /* Get a handle on the request itself. Don't free req - it belongs to mreq */ req = tr_msg_get_req(mreq); - /* Allocate a response structure and populate common fields. The resp is in req's talloc context, - * which will be cleaned up when mreq is freed. */ - resp = tids_create_response(req, tids, req); + /* Allocate a response message */ + resp_msg = talloc(tmp_ctx, TR_MSG); + if (resp_msg == NULL) { + /* We cannot create a response message, so all we can really do is emit + * an error message and return. */ + tr_crit("tids_req_cb: Error allocating response message."); + goto cleanup; + } + + /* Allocate a response structure and populate common fields. Put it in the + * response message's talloc context. */ + resp = tids_create_response(resp_msg, req); if (resp == NULL) { /* If we were unable to create a response, we cannot reply. Log an * error if we can, then drop the request. */ - tr_msg_free_decoded(mreq); tr_crit("tids_req_cb: Error creating response structure."); - return NULL; + resp_msg = NULL; /* the contents are in tmp_ctx, so they will still be cleaned up */ + goto cleanup; } + /* Now officially assign the response to the message. */ + tr_msg_set_resp(resp_msg, resp); /* Handle the request and fill in resp */ rc = tids_handle_request(tids, req, resp); @@ -312,17 +308,34 @@ static char *tids_req_cb(TALLOC_CTX *mem_ctx, const char *req_str, void *data) /* Fall through, to send the response, either way */ } - /* Convert the completed response into an encoded response */ - resp_str = tids_encode_response(mem_ctx, tids, req, resp); + /* put the response message in the caller's context */ + talloc_steal(mem_ctx, resp_msg); + +cleanup: + talloc_free(tmp_ctx); + return resp_msg; +} - /* Finished; free the request and return */ - tr_msg_free_decoded(mreq); // this frees req and resp, too - return resp_str; +static int tids_destructor(void *object) +{ + TIDS_INSTANCE *tids = talloc_get_type_abort(object, TIDS_INSTANCE); + if (tids->pids) + g_array_unref(tids->pids); + return 0; } TIDS_INSTANCE *tids_new(TALLOC_CTX *mem_ctx) { - return talloc_zero(mem_ctx, TIDS_INSTANCE); + TIDS_INSTANCE *tids = talloc_zero(mem_ctx, TIDS_INSTANCE); + if (tids) { + tids->pids = g_array_new(FALSE, FALSE, sizeof(struct tid_process)); + if (tids->pids == NULL) { + talloc_free(tids); + return NULL; + } + talloc_set_destructor((void *)tids, tids_destructor); + } + return tids; } /** @@ -333,18 +346,19 @@ TIDS_INSTANCE *tids_new(TALLOC_CTX *mem_ctx) */ TIDS_INSTANCE *tids_create(void) { - return talloc_zero(NULL, TIDS_INSTANCE); + return tids_new(NULL); } + /* Get a listener for tids requests, returns its socket fd. Accept * connections with tids_accept() */ -int tids_get_listener(TIDS_INSTANCE *tids, - TIDS_REQ_FUNC *req_handler, - tids_auth_func *auth_handler, - const char *hostname, - unsigned int port, - void *cookie, - int *fd_out, - size_t max_fd) +nfds_t tids_get_listener(TIDS_INSTANCE *tids, + TIDS_REQ_FUNC *req_handler, + tids_auth_func *auth_handler, + const char *hostname, + unsigned int port, + void *cookie, + int *fd_out, + size_t max_fd) { nfds_t n_fd = 0; nfds_t ii = 0; @@ -388,36 +402,123 @@ int tids_accept(TIDS_INSTANCE *tids, int listen) { int conn=-1; int pid=-1; + int pipe_fd[2]; + struct tid_process tp = {0}; if (0 > (conn = accept(listen, NULL, NULL))) { perror("Error from TIDS Server accept()"); return 1; } + if (0 > pipe(pipe_fd)) { + perror("Error on pipe()"); + return 1; + } + /* pipe_fd[0] is for reading, pipe_fd[1] is for writing */ + if (0 > (pid = fork())) { perror("Error on fork()"); return 1; } if (pid == 0) { + close(pipe_fd[0]); /* child only writes */ close(listen); tr_gss_handle_connection(conn, "trustidentity", tids->hostname, /* acceptor name */ - tids_auth_cb, tids, /* auth callback and cookie */ + tids->auth_handler, tids->cookie, /* auth callback and cookie */ tids_req_cb, tids /* req callback and cookie */ ); + if (write(pipe_fd[1], "OK\0", 3) < 0) + tr_crit("tids_accept: child process unable to write to pipe"); + close(pipe_fd[1]); close(conn); exit(0); /* exit to kill forked child process */ - } else { - close(conn); } - /* clean up any processes that have completed (TBD: move to main loop?) */ - while (waitpid(-1, 0, WNOHANG) > 0); + /* Only the parent process gets here */ + close(pipe_fd[1]); /* parent only listens */ + close(conn); /* connection belongs to the child */ + tp.pid = pid; + tp.read_fd = pipe_fd[0]; + g_array_append_val(tids->pids, tp); /* remember the PID of our child process */ + /* clean up any processes that have completed */ + tids_sweep_procs(tids); return 0; } +/** + * Clean up any finished TID request processes + * + * This is called by the main process after forking each TID request. If you want to be + * sure finished processes are cleaned up promptly even during a lull in TID requests, + * this can be called from the main thread of the main process. It is not thread-safe, + * so should not be used from sub-threads. It should not be called by child processes - + * this would probably be harmless but ineffective. + * + * @param tids + */ +void tids_sweep_procs(TIDS_INSTANCE *tids) +{ + guint ii; + struct tid_process tp = {0}; + char result[10] = {0}; + ssize_t result_len; + int status; + int wait_rc; + + /* loop backwards over the array so we can remove elements as we go */ + for (ii=tids->pids->len; ii > 0; ii--) { + /* ii-1 is the current index - get our own copy, we may destroy the list's copy */ + tp = g_array_index(tids->pids, struct tid_process, ii-1); + + wait_rc = waitpid(tp.pid, &status, WNOHANG); + if (wait_rc == 0) + continue; /* process still running */ + + if (wait_rc < 0) { + /* invalid options will probably keep being invalid, report that condition */ + if(errno == EINVAL) + tr_crit("tids_sweep_procs: waitpid called with invalid options"); + + /* If we got ECHILD, that means the PID was invalid; we'll assume the process was + * terminated and we missed it. For all other errors, move on + * to the next PID to check. */ + if (errno != ECHILD) + continue; + + tr_warning("tid_sweep_procs: TID process %d disappeared", tp.pid); + } + + /* remove the item (we still have a copy of the data) */ + g_array_remove_index_fast(tids->pids, ii-1); /* disturbs only indices >= ii-1 which we've already handled */ + + /* Report exit status unless we got ECHILD above or somehow waitpid returned the wrong pid */ + if (wait_rc == tp.pid) { + if (WIFEXITED(status)) { + tr_debug("tids_sweep_procs: TID process %d exited with status %d.", tp.pid, WTERMSIG(status)); + } else if (WIFSIGNALED(status)) { + tr_debug("tids_sweep_procs: TID process %d terminated by signal %d.", tp.pid, WTERMSIG(status)); + } + } else if (wait_rc > 0) { + tr_err("tids_sweep_procs: waitpid returned pid %d, expected %d", wait_rc, tp.pid); + } + + /* read the pipe - if the TID request worked, it will have written status before terminating */ + result_len = read(tp.read_fd, result, sizeof(result)/sizeof(result[0])); + close(tp.read_fd); + + if ((result_len > 0) && (strcmp(result, "OK") == 0)) { + tids->req_count++; + tr_debug("tids_sweep_procs: TID process %d succeeded", tp.pid); + } else { + tids->error_count++; + tr_debug("tids_sweep_procs: TID process %d failed", tp.pid); + } + } +} + /* Process tids requests forever. Should not return except on error. */ int tids_start (TIDS_INSTANCE *tids, TIDS_REQ_FUNC *req_handler, @@ -431,7 +532,7 @@ int tids_start (TIDS_INSTANCE *tids, struct pollfd poll_fd[TR_MAX_SOCKETS]={{0}}; int ii=0; - n_fd=tids_get_listener(tids, req_handler, auth_handler, hostname, port, cookie, fd, TR_MAX_SOCKETS); + n_fd = tids_get_listener(tids, req_handler, auth_handler, hostname, port, cookie, fd, TR_MAX_SOCKETS); if (n_fd <= 0) { perror ("Error from tids_listen()"); return 1;