X-Git-Url: http://www.project-moonshot.org/gitweb/?p=trust_router.git;a=blobdiff_plain;f=tid%2Ftids.c;h=05693336c5d925a85739d695704eba600c146ad8;hp=04b4eb130d827fa7475fdacf356386896bb3042a;hb=6454056a45ff204133fd53f7f147e46ffb397d4f;hpb=6b2657beba06552cefb325dacf4a628f4206fa6f diff --git a/tid/tids.c b/tid/tids.c index 04b4eb1..0569333 100644 --- a/tid/tids.c +++ b/tid/tids.c @@ -80,6 +80,12 @@ static TID_RESP *tids_create_response(TALLOC_CTX *mem_ctx, TID_REQ *req) 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; @@ -391,6 +397,54 @@ nfds_t tids_get_listener(TIDS_INSTANCE *tids, return (int)n_fd; } +/* Strings used to report results from the handler process. The + * TIDS_MAX_MESSAGE_LEN must be longer than the longest message, including + * null termination (i.e., strlen() + 1) */ +#define TIDS_MAX_MESSAGE_LEN (10) +#define TIDS_SUCCESS_MESSAGE "OK" +#define TIDS_ERROR_MESSAGE "ERR" + +/** + * Process to handle an incoming TIDS request + * + * This should be run in the child process after a fork(). Handles + * the request, writes the result to result_fd, and terminates via exit(). + * Never returns to the caller. + * + * @param tids TID server instance + * @param conn_fd file descriptor for the incoming connection + * @param result_fd writable file descriptor for the result, or 0 to disable reporting + */ +static void tids_handle_proc(TIDS_INSTANCE *tids, int conn_fd, int result_fd) +{ + const char *response_message = NULL; + + switch(tr_gss_handle_connection(conn_fd, + "trustidentity", tids->hostname, /* acceptor name */ + tids->auth_handler, tids->cookie, /* auth callback and cookie */ + tids_req_cb, tids /* req callback and cookie */ + )) { + case TR_GSS_SUCCESS: + response_message = TIDS_SUCCESS_MESSAGE; + break; + + case TR_GSS_ERROR: + default: + response_message = TIDS_ERROR_MESSAGE; + break; + } + + if (0 != result_fd) { + /* write strlen + 1 to include the null termination */ + if (write(result_fd, response_message, strlen(response_message) + 1) < 0) + tr_err("tids_accept: child process unable to write to pipe"); + } + + close(result_fd); + close(conn_fd); + exit(0); /* exit to kill forked child process */ +} + /* Accept and process a connection on a port opened with tids_get_listener() */ int tids_accept(TIDS_INSTANCE *tids, int listen) { @@ -399,8 +453,8 @@ int tids_accept(TIDS_INSTANCE *tids, int listen) int pipe_fd[2]; struct tid_process tp = {0}; - if (0 > (conn = accept(listen, NULL, NULL))) { - perror("Error from TIDS Server accept()"); + if (0 > (conn = tr_sock_accept(listen))) { + tr_err("tids_accept: Error accepting connection"); return 1; } @@ -416,66 +470,95 @@ int tids_accept(TIDS_INSTANCE *tids, int listen) } if (pid == 0) { - close(pipe_fd[0]); /* child only writes */ - close(listen); - tr_gss_handle_connection(conn, - "trustidentity", tids->hostname, /* acceptor name */ - 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 */ + /* Only the child process gets here */ + close(pipe_fd[0]); /* close the read end of the pipe, the child only writes */ + close(listen); /* close the child process's handle on the listen port */ + + tids_handle_proc(tids, conn, pipe_fd[1]); /* never returns */ } /* Only the parent process gets here */ - close(pipe_fd[1]); /* parent only listens */ - close(conn); /* connection belongs to the child */ + close(pipe_fd[1]); /* close the write end of the pipe, the parent only listens */ + close(conn); /* connection belongs to the child, so close parent's handle */ + + /* remember the PID of our child process */ + tr_info("tids_accept: Spawned TID process %d to handle incoming connection.", pid); tp.pid = pid; tp.read_fd = pipe_fd[0]; - g_array_append_val(tids->pids, tp); /* remember the PID of our child process */ + g_array_append_val(tids->pids, tp); /* 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}; + char result[TIDS_MAX_MESSAGE_LEN] = {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); - if (waitpid(tp.pid, &status, WNOHANG) == tp.pid) { - /* the process exited */ - tr_debug("tids_sweep_procs: TID process %d terminated.", tp.pid); + 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"); - g_array_remove_index_fast(tids->pids, ii-1); /* disturbs only indices >= ii-1 which we've already handled */ + /* 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)); } - result_len = read(tp.read_fd, result, 10); - 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); - } + } 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, TIDS_MAX_MESSAGE_LEN); + close(tp.read_fd); + + if ((result_len > 0) && (strcmp(result, TIDS_SUCCESS_MESSAGE) == 0)) { + tids->req_count++; + tr_info("tids_sweep_procs: TID process %d exited successfully.", tp.pid); + } else { + tids->error_count++; + tr_info("tids_sweep_procs: TID process %d exited with an error.", tp.pid); } } }