|
@@ -31,75 +31,103 @@
|
|
|
#include <pwd.h>
|
|
|
#include <grp.h>
|
|
|
#include <sys/stat.h>
|
|
|
+#include <assert.h>
|
|
|
#include "qrexec.h"
|
|
|
#include <libvchan.h>
|
|
|
#include "libqrexec-utils.h"
|
|
|
+#include "qrexec-agent.h"
|
|
|
|
|
|
-enum fdtype {
|
|
|
- FDTYPE_INVALID,
|
|
|
- FDTYPE_STDOUT,
|
|
|
- FDTYPE_STDERR
|
|
|
-};
|
|
|
-
|
|
|
-struct _process_fd {
|
|
|
- int client_id;
|
|
|
- int type;
|
|
|
- int is_blocked;
|
|
|
-};
|
|
|
-struct _client_info {
|
|
|
- int stdin_fd;
|
|
|
- int stdout_fd;
|
|
|
- int stderr_fd;
|
|
|
-
|
|
|
- int exit_status;
|
|
|
- int is_exited;
|
|
|
+struct _connection_info {
|
|
|
int pid;
|
|
|
- int is_blocked;
|
|
|
- int is_close_after_flush_needed;
|
|
|
- struct buffer buffer;
|
|
|
+ int connect_domain;
|
|
|
+ int connect_port;
|
|
|
};
|
|
|
|
|
|
int max_process_fd = -1;
|
|
|
|
|
|
-/* indexed by file descriptor */
|
|
|
-struct _process_fd process_fd[MAX_FDS];
|
|
|
+/* */
|
|
|
+struct _connection_info connection_info[MAX_FDS];
|
|
|
|
|
|
-/* indexed by client id, which is descriptor number of a client in daemon */
|
|
|
-struct _client_info client_info[MAX_FDS];
|
|
|
-
|
|
|
-libvchan_t *vchan;
|
|
|
+libvchan_t *ctrl_vchan;
|
|
|
|
|
|
int trigger_fd;
|
|
|
int passfd_socket;
|
|
|
|
|
|
int meminfo_write_started = 0;
|
|
|
|
|
|
-void do_exec(const char *cmd);
|
|
|
-void handle_vchan_error(const char *op) {
|
|
|
+void handle_vchan_error(const char *op)
|
|
|
+{
|
|
|
fprintf(stderr, "Error while vchan %s, exiting\n", op);
|
|
|
exit(1);
|
|
|
}
|
|
|
|
|
|
+int handle_handshake(libvchan_t *ctrl)
|
|
|
+{
|
|
|
+ struct msg_header hdr;
|
|
|
+ struct peer_info info;
|
|
|
+
|
|
|
+ /* send own HELLO */
|
|
|
+ hdr.type = MSG_HELLO;
|
|
|
+ hdr.len = sizeof(info);
|
|
|
+ info.version = QREXEC_PROTOCOL_VERSION;
|
|
|
+
|
|
|
+ if (libvchan_send(ctrl, &hdr, sizeof(hdr)) != sizeof(hdr)) {
|
|
|
+ fprintf(stderr, "Failed to send HELLO hdr to agent\n");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (libvchan_send(ctrl, &info, sizeof(info)) != sizeof(info)) {
|
|
|
+ fprintf(stderr, "Failed to send HELLO hdr to agent\n");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* receive MSG_HELLO from remote */
|
|
|
+ if (libvchan_recv(ctrl, &hdr, sizeof(hdr)) != sizeof(hdr)) {
|
|
|
+ fprintf(stderr, "Failed to read agent HELLO hdr\n");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (hdr.type != MSG_HELLO || hdr.len != sizeof(info)) {
|
|
|
+ fprintf(stderr, "Invalid HELLO packet received: type %d, len %d\n", hdr.type, hdr.len);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (libvchan_recv(ctrl, &info, sizeof(info)) != sizeof(info)) {
|
|
|
+ fprintf(stderr, "Failed to read agent HELLO body\n");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (info.version != QREXEC_PROTOCOL_VERSION) {
|
|
|
+ fprintf(stderr, "Incompatible agent protocol version (remote %d, local %d)\n", info.version, QREXEC_PROTOCOL_VERSION);
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
void init()
|
|
|
{
|
|
|
/* FIXME: This 0 is remote domain ID */
|
|
|
- vchan = libvchan_server_init(0, REXEC_PORT, 4096, 4096);
|
|
|
- if (!vchan)
|
|
|
+ ctrl_vchan = libvchan_server_init(0, VCHAN_BASE_PORT, 4096, 4096);
|
|
|
+ if (!ctrl_vchan)
|
|
|
handle_vchan_error("server_init");
|
|
|
+ if (handle_handshake(ctrl_vchan) < 0)
|
|
|
+ exit(1);
|
|
|
umask(0);
|
|
|
mkfifo(QREXEC_AGENT_TRIGGER_PATH, 0666);
|
|
|
passfd_socket = get_server_socket(QREXEC_AGENT_FDPASS_PATH);
|
|
|
umask(077);
|
|
|
trigger_fd =
|
|
|
open(QREXEC_AGENT_TRIGGER_PATH, O_RDONLY | O_NONBLOCK);
|
|
|
- register_exec_func(do_exec);
|
|
|
|
|
|
/* wait for qrexec daemon */
|
|
|
- while (!libvchan_is_open(vchan))
|
|
|
- libvchan_wait(vchan);
|
|
|
+ while (!libvchan_is_open(ctrl_vchan))
|
|
|
+ libvchan_wait(ctrl_vchan);
|
|
|
}
|
|
|
|
|
|
-void wake_meminfo_writer() {
|
|
|
+void wake_meminfo_writer()
|
|
|
+{
|
|
|
FILE *f;
|
|
|
int pid;
|
|
|
|
|
@@ -130,266 +158,82 @@ void wake_meminfo_writer() {
|
|
|
meminfo_write_started = 1;
|
|
|
}
|
|
|
|
|
|
-void no_colon_in_cmd()
|
|
|
-{
|
|
|
- fprintf(stderr,
|
|
|
- "cmdline is supposed to be in user:command form\n");
|
|
|
- exit(1);
|
|
|
-}
|
|
|
-
|
|
|
-void do_exec(const char *cmd)
|
|
|
+void register_vchan_connection(pid_t pid, int domain, int port)
|
|
|
{
|
|
|
- char buf[strlen(QUBES_RPC_MULTIPLEXER_PATH) + strlen(cmd) - strlen(QUBES_RPC_MAGIC_CMD) + 1];
|
|
|
- char *realcmd = index(cmd, ':'), *user;
|
|
|
- if (!realcmd)
|
|
|
- no_colon_in_cmd();
|
|
|
- /* mark end of username and move to command */
|
|
|
- user=strndup(cmd,realcmd-cmd);
|
|
|
- realcmd++;
|
|
|
- /* ignore "nogui:" prefix in linux agent */
|
|
|
- if (strncmp(realcmd, "nogui:", 6) == 0)
|
|
|
- realcmd+=6;
|
|
|
- /* replace magic RPC cmd with RPC multiplexer path */
|
|
|
- if (strncmp(realcmd, QUBES_RPC_MAGIC_CMD " ", strlen(QUBES_RPC_MAGIC_CMD)+1)==0) {
|
|
|
- strcpy(buf, QUBES_RPC_MULTIPLEXER_PATH);
|
|
|
- strcpy(buf + strlen(QUBES_RPC_MULTIPLEXER_PATH), realcmd + strlen(QUBES_RPC_MAGIC_CMD));
|
|
|
- realcmd = buf;
|
|
|
- }
|
|
|
- signal(SIGCHLD, SIG_DFL);
|
|
|
- signal(SIGPIPE, SIG_DFL);
|
|
|
-
|
|
|
- execl("/bin/su", "su", "-", user, "-c", realcmd, NULL);
|
|
|
- perror("execl");
|
|
|
- exit(1);
|
|
|
-}
|
|
|
+ int i;
|
|
|
|
|
|
-void handle_just_exec(int len)
|
|
|
-{
|
|
|
- char buf[len];
|
|
|
- int fdn, pid;
|
|
|
-
|
|
|
- if (libvchan_recv(vchan, buf, len) < 0)
|
|
|
- handle_vchan_error("read");
|
|
|
- switch (pid = fork()) {
|
|
|
- case -1:
|
|
|
- perror("fork");
|
|
|
- exit(1);
|
|
|
- case 0:
|
|
|
- fdn = open("/dev/null", O_RDWR);
|
|
|
- fix_fds(fdn, fdn, fdn);
|
|
|
- do_exec(buf);
|
|
|
- perror("execl");
|
|
|
- exit(1);
|
|
|
- default:;
|
|
|
+ for (i = 0; i < MAX_FDS; i++) {
|
|
|
+ if (connection_info[i].pid == 0) {
|
|
|
+ connection_info[i].pid = pid;
|
|
|
+ connection_info[i].connect_domain = domain;
|
|
|
+ connection_info[i].connect_port = port;
|
|
|
+ return;
|
|
|
+ }
|
|
|
}
|
|
|
- fprintf(stderr, "executed (nowait) %s pid %d\n", buf, pid);
|
|
|
-}
|
|
|
|
|
|
-void create_info_about_client(int client_id, int pid, int stdin_fd,
|
|
|
- int stdout_fd, int stderr_fd)
|
|
|
-{
|
|
|
- process_fd[stdout_fd].client_id = client_id;
|
|
|
- process_fd[stdout_fd].type = FDTYPE_STDOUT;
|
|
|
- process_fd[stdout_fd].is_blocked = 0;
|
|
|
- process_fd[stderr_fd].client_id = client_id;
|
|
|
- process_fd[stderr_fd].type = FDTYPE_STDERR;
|
|
|
- process_fd[stderr_fd].is_blocked = 0;
|
|
|
-
|
|
|
- if (stderr_fd > max_process_fd)
|
|
|
- max_process_fd = stderr_fd;
|
|
|
- if (stdout_fd > max_process_fd)
|
|
|
- max_process_fd = stdout_fd;
|
|
|
-
|
|
|
- set_nonblock(stdin_fd);
|
|
|
-
|
|
|
- client_info[client_id].stdin_fd = stdin_fd;
|
|
|
- client_info[client_id].stdout_fd = stdout_fd;
|
|
|
- client_info[client_id].stderr_fd = stderr_fd;
|
|
|
- client_info[client_id].exit_status = 0;
|
|
|
- client_info[client_id].is_exited = 0;
|
|
|
- client_info[client_id].pid = pid;
|
|
|
- client_info[client_id].is_blocked = 0;
|
|
|
- client_info[client_id].is_close_after_flush_needed = 0;
|
|
|
- buffer_init(&client_info[client_id].buffer);
|
|
|
+ fprintf(stderr, "No free slot for child %d (connection to %d:%d)\n", pid, domain, port);
|
|
|
}
|
|
|
|
|
|
-void handle_exec(int client_id, int len)
|
|
|
+void handle_server_exec_request(struct msg_header *hdr)
|
|
|
{
|
|
|
- char buf[len];
|
|
|
- int pid, stdin_fd, stdout_fd, stderr_fd;
|
|
|
+ struct exec_params params;
|
|
|
+ char buf[hdr->len-sizeof(params)];
|
|
|
+ pid_t child_agent;
|
|
|
|
|
|
- if (libvchan_recv(vchan, buf, len) < 0)
|
|
|
- handle_vchan_error("read");
|
|
|
+ assert(hdr->len >= sizeof(params));
|
|
|
|
|
|
- do_fork_exec(buf, &pid, &stdin_fd, &stdout_fd, &stderr_fd);
|
|
|
+ if (libvchan_recv(ctrl_vchan, ¶ms, sizeof(params)) < 0)
|
|
|
+ handle_vchan_error("read exec params");
|
|
|
+ if (libvchan_recv(ctrl_vchan, buf, hdr->len-sizeof(params)) < 0)
|
|
|
+ handle_vchan_error("read exec cmd");
|
|
|
|
|
|
- create_info_about_client(client_id, pid, stdin_fd, stdout_fd,
|
|
|
- stderr_fd);
|
|
|
-
|
|
|
- fprintf(stderr, "executed %s pid %d\n", buf, pid);
|
|
|
+ child_agent = handle_new_process(hdr->type,
|
|
|
+ params.connect_domain, params.connect_port,
|
|
|
+ buf, hdr->len-sizeof(params));
|
|
|
|
|
|
+ register_vchan_connection(child_agent,
|
|
|
+ params.connect_domain, params.connect_port);
|
|
|
}
|
|
|
|
|
|
-void handle_connect_existing(int client_id, int len)
|
|
|
+void handle_service_refused(struct msg_header *hdr)
|
|
|
{
|
|
|
+ struct service_params params;
|
|
|
int stdin_fd, stdout_fd, stderr_fd;
|
|
|
- char buf[len];
|
|
|
- if (libvchan_recv(vchan, buf, len) < 0)
|
|
|
- handle_vchan_error("read");
|
|
|
- sscanf(buf, "%d %d %d", &stdin_fd, &stdout_fd, &stderr_fd);
|
|
|
- create_info_about_client(client_id, -1, stdin_fd, stdout_fd,
|
|
|
- stderr_fd);
|
|
|
- client_info[client_id].is_exited = 1; //do not wait for SIGCHLD
|
|
|
-}
|
|
|
-
|
|
|
-void update_max_process_fd()
|
|
|
-{
|
|
|
- int i;
|
|
|
- for (i = max_process_fd;
|
|
|
- i >= 0 && process_fd[i].type == FDTYPE_INVALID; i--);
|
|
|
- max_process_fd = i;
|
|
|
-}
|
|
|
-
|
|
|
-void send_exit_code(int client_id, int status)
|
|
|
-{
|
|
|
- struct server_header s_hdr;
|
|
|
- s_hdr.type = MSG_AGENT_TO_SERVER_EXIT_CODE;
|
|
|
- s_hdr.client_id = client_id;
|
|
|
- s_hdr.len = sizeof status;
|
|
|
- if (libvchan_send(vchan, &s_hdr, sizeof(s_hdr)) < 0)
|
|
|
- handle_vchan_error("write hdr");
|
|
|
- if (libvchan_send(vchan, &status, sizeof(status)) < 0)
|
|
|
- handle_vchan_error("write status");
|
|
|
- fprintf(stderr, "send exit code %d for client_id %d pid %d\n",
|
|
|
- status, client_id, client_info[client_id].pid);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-// erase process data structures, possibly forced by remote
|
|
|
-void remove_process(int client_id, int status)
|
|
|
-{
|
|
|
- int i;
|
|
|
- if (!client_info[client_id].pid)
|
|
|
- return;
|
|
|
- if (client_info[client_id].stdin_fd >= 0)
|
|
|
- fork_and_flush_stdin(client_info[client_id].stdin_fd,
|
|
|
- &client_info[client_id].buffer);
|
|
|
-#if 0
|
|
|
- // let's let it die by itself, possibly after it has received buffered stdin
|
|
|
- kill(client_info[client_id].pid, SIGKILL);
|
|
|
-#endif
|
|
|
- if (status != -1)
|
|
|
- send_exit_code(client_id, status);
|
|
|
-
|
|
|
-
|
|
|
- close(client_info[client_id].stdin_fd);
|
|
|
- client_info[client_id].pid = 0;
|
|
|
- client_info[client_id].stdin_fd = -1;
|
|
|
- client_info[client_id].is_blocked = 0;
|
|
|
- buffer_free(&client_info[client_id].buffer);
|
|
|
-
|
|
|
- for (i = 0; i <= max_process_fd; i++)
|
|
|
- if (process_fd[i].type != FDTYPE_INVALID
|
|
|
- && process_fd[i].client_id == client_id) {
|
|
|
- process_fd[i].type = FDTYPE_INVALID;
|
|
|
- process_fd[i].client_id = -1;
|
|
|
- process_fd[i].is_blocked = 0;
|
|
|
- close(i);
|
|
|
- }
|
|
|
- update_max_process_fd();
|
|
|
-}
|
|
|
-
|
|
|
-// remove process not immediately after it has exited, but after its stdout and stderr has been drained
|
|
|
-// previous method implemented in flush_out_err was broken - it cannot work when peer signalled it is blocked
|
|
|
-void possibly_remove_process(int client_id)
|
|
|
-{
|
|
|
- if (client_info[client_id].stdout_fd == -1 &&
|
|
|
- client_info[client_id].stderr_fd == -1 &&
|
|
|
- client_info[client_id].is_exited)
|
|
|
- remove_process(client_id,
|
|
|
- client_info[client_id].exit_status);
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-void handle_input(int client_id, int len)
|
|
|
-{
|
|
|
- char buf[len];
|
|
|
-
|
|
|
- if (libvchan_recv(vchan, buf, len) < 0)
|
|
|
- handle_vchan_error("read");
|
|
|
- if (!client_info[client_id].pid || client_info[client_id].stdin_fd == -1)
|
|
|
- return;
|
|
|
|
|
|
- if (len == 0) {
|
|
|
- if (client_info[client_id].is_blocked)
|
|
|
- client_info[client_id].is_close_after_flush_needed
|
|
|
- = 1;
|
|
|
- else {
|
|
|
- close(client_info[client_id].stdin_fd);
|
|
|
- client_info[client_id].stdin_fd = -1;
|
|
|
- }
|
|
|
- return;
|
|
|
+ if (hdr->len != sizeof(params)) {
|
|
|
+ fprintf(stderr, "Invalid msg 0x%x length (%d)\n", MSG_SERVICE_REFUSED, hdr->len);
|
|
|
+ exit(1);
|
|
|
}
|
|
|
|
|
|
- switch (write_stdin
|
|
|
- (vchan, client_info[client_id].stdin_fd, client_id, buf, len,
|
|
|
- &client_info[client_id].buffer)) {
|
|
|
- case WRITE_STDIN_OK:
|
|
|
- break;
|
|
|
- case WRITE_STDIN_BUFFERED:
|
|
|
- client_info[client_id].is_blocked = 1;
|
|
|
- break;
|
|
|
- case WRITE_STDIN_ERROR:
|
|
|
- // do not remove process, as it still can write data to stdout
|
|
|
- close(client_info[client_id].stdin_fd);
|
|
|
- client_info[client_id].stdin_fd = -1;
|
|
|
- client_info[client_id].is_blocked = 0;
|
|
|
- break;
|
|
|
- default:
|
|
|
- fprintf(stderr, "unknown write_stdin?\n");
|
|
|
- exit(1);
|
|
|
- }
|
|
|
+ if (libvchan_recv(ctrl_vchan, ¶ms, sizeof(params)) < 0)
|
|
|
+ handle_vchan_error("read exec params");
|
|
|
|
|
|
+ sscanf(params.ident, "%d %d %d", &stdin_fd, &stdout_fd, &stderr_fd);
|
|
|
+ /* TODO: send some signal? some response? */
|
|
|
+ close(stdin_fd);
|
|
|
+ close(stdout_fd);
|
|
|
+ close(stderr_fd);
|
|
|
}
|
|
|
|
|
|
-void set_blocked_outerr(int client_id, int val)
|
|
|
+void handle_server_cmd()
|
|
|
{
|
|
|
- process_fd[client_info[client_id].stdout_fd].is_blocked = val;
|
|
|
- process_fd[client_info[client_id].stderr_fd].is_blocked = val;
|
|
|
-}
|
|
|
+ struct msg_header s_hdr;
|
|
|
|
|
|
-void handle_server_data()
|
|
|
-{
|
|
|
- struct server_header s_hdr;
|
|
|
- if (libvchan_recv(vchan, &s_hdr, sizeof(s_hdr)) < 0)
|
|
|
+ if (libvchan_recv(ctrl_vchan, &s_hdr, sizeof(s_hdr)) < 0)
|
|
|
handle_vchan_error("read s_hdr");
|
|
|
|
|
|
// fprintf(stderr, "got %x %x %x\n", s_hdr.type, s_hdr.client_id,
|
|
|
// s_hdr.len);
|
|
|
|
|
|
switch (s_hdr.type) {
|
|
|
- case MSG_XON:
|
|
|
- set_blocked_outerr(s_hdr.client_id, 0);
|
|
|
- break;
|
|
|
- case MSG_XOFF:
|
|
|
- set_blocked_outerr(s_hdr.client_id, 1);
|
|
|
- break;
|
|
|
- case MSG_SERVER_TO_AGENT_CONNECT_EXISTING:
|
|
|
- handle_connect_existing(s_hdr.client_id, s_hdr.len);
|
|
|
- break;
|
|
|
- case MSG_SERVER_TO_AGENT_EXEC_CMDLINE:
|
|
|
- wake_meminfo_writer();
|
|
|
- handle_exec(s_hdr.client_id, s_hdr.len);
|
|
|
- break;
|
|
|
- case MSG_SERVER_TO_AGENT_JUST_EXEC:
|
|
|
+ case MSG_EXEC_CMDLINE:
|
|
|
+ case MSG_JUST_EXEC:
|
|
|
+ case MSG_SERVICE_CONNECT:
|
|
|
wake_meminfo_writer();
|
|
|
- handle_just_exec(s_hdr.len);
|
|
|
- break;
|
|
|
- case MSG_SERVER_TO_AGENT_INPUT:
|
|
|
- handle_input(s_hdr.client_id, s_hdr.len);
|
|
|
+ handle_server_exec_request(&s_hdr);
|
|
|
break;
|
|
|
- case MSG_SERVER_TO_AGENT_CLIENT_END:
|
|
|
- remove_process(s_hdr.client_id, -1);
|
|
|
+ case MSG_SERVICE_REFUSED:
|
|
|
+ handle_service_refused(&s_hdr);
|
|
|
break;
|
|
|
default:
|
|
|
fprintf(stderr, "msg type from daemon is %d ?\n",
|
|
@@ -398,54 +242,6 @@ void handle_server_data()
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void handle_process_data(int fd)
|
|
|
-{
|
|
|
- struct server_header s_hdr;
|
|
|
- char buf[MAX_DATA_CHUNK];
|
|
|
- int ret;
|
|
|
- unsigned int len;
|
|
|
-
|
|
|
- len = libvchan_buffer_space(vchan);
|
|
|
- if (len <= sizeof s_hdr)
|
|
|
- return;
|
|
|
-
|
|
|
- ret = read(fd, buf, len - sizeof s_hdr);
|
|
|
- s_hdr.client_id = process_fd[fd].client_id;
|
|
|
-
|
|
|
- if (process_fd[fd].type == FDTYPE_STDOUT)
|
|
|
- s_hdr.type = MSG_AGENT_TO_SERVER_STDOUT;
|
|
|
- else if (process_fd[fd].type == FDTYPE_STDERR)
|
|
|
- s_hdr.type = MSG_AGENT_TO_SERVER_STDERR;
|
|
|
- else {
|
|
|
- fprintf(stderr, "fd=%d, client_id=%d, type=%d ?\n", fd,
|
|
|
- process_fd[fd].client_id, process_fd[fd].type);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- s_hdr.len = ret;
|
|
|
- if (ret >= 0) {
|
|
|
- if (libvchan_send(vchan, &s_hdr, sizeof(s_hdr)) < 0)
|
|
|
- handle_vchan_error("write hdr");
|
|
|
- if (libvchan_send(vchan, buf, ret) < 0)
|
|
|
- handle_vchan_error("write buf");
|
|
|
- }
|
|
|
- if (ret == 0) {
|
|
|
- int client_id = process_fd[fd].client_id;
|
|
|
- if (process_fd[fd].type == FDTYPE_STDOUT)
|
|
|
- client_info[client_id].stdout_fd = -1;
|
|
|
- else
|
|
|
- client_info[client_id].stderr_fd = -1;
|
|
|
-
|
|
|
- process_fd[fd].type = FDTYPE_INVALID;
|
|
|
- process_fd[fd].client_id = -1;
|
|
|
- process_fd[fd].is_blocked = 0;
|
|
|
- close(fd);
|
|
|
- update_max_process_fd();
|
|
|
- possibly_remove_process(client_id);
|
|
|
- }
|
|
|
- if (ret < 0)
|
|
|
- remove_process(process_fd[fd].client_id, 127);
|
|
|
-}
|
|
|
-
|
|
|
volatile int child_exited;
|
|
|
|
|
|
void sigchld_handler(int x __attribute__((__unused__)))
|
|
@@ -454,37 +250,36 @@ void sigchld_handler(int x __attribute__((__unused__)))
|
|
|
signal(SIGCHLD, sigchld_handler);
|
|
|
}
|
|
|
|
|
|
-int find_info(int pid)
|
|
|
+int find_connection(int pid)
|
|
|
{
|
|
|
int i;
|
|
|
for (i = 0; i < MAX_FDS; i++)
|
|
|
- if (client_info[i].pid == pid)
|
|
|
+ if (connection_info[i].pid == pid)
|
|
|
return i;
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
|
|
|
-void handle_process_data_all(fd_set * select_fds)
|
|
|
-{
|
|
|
- int i;
|
|
|
- for (i = 0; i <= max_process_fd; i++)
|
|
|
- if (process_fd[i].type != FDTYPE_INVALID
|
|
|
- && FD_ISSET(i, select_fds))
|
|
|
- handle_process_data(i);
|
|
|
-}
|
|
|
-
|
|
|
void reap_children()
|
|
|
{
|
|
|
int status;
|
|
|
int pid;
|
|
|
- int client_id;
|
|
|
+ int id;
|
|
|
+ struct msg_header hdr;
|
|
|
+ struct exec_params params;
|
|
|
while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
|
|
|
- client_id = find_info(pid);
|
|
|
- if (client_id < 0)
|
|
|
+ id = find_connection(pid);
|
|
|
+ if (id < 0)
|
|
|
continue;
|
|
|
- client_info[client_id].is_exited = 1;
|
|
|
- client_info[client_id].exit_status = status;
|
|
|
- possibly_remove_process(client_id);
|
|
|
+ hdr.type = MSG_CONNECTION_TERMINATED;
|
|
|
+ hdr.len = sizeof(struct exec_params);
|
|
|
+ params.connect_domain = connection_info[id].connect_domain;
|
|
|
+ params.connect_port = connection_info[id].connect_port;
|
|
|
+ if (libvchan_send(ctrl_vchan, &hdr, sizeof(hdr)) < 0)
|
|
|
+ handle_vchan_error("send");
|
|
|
+ if (libvchan_send(ctrl_vchan, ¶ms, sizeof(params)) < 0)
|
|
|
+ handle_vchan_error("send");
|
|
|
+ connection_info[id].pid = 0;
|
|
|
}
|
|
|
child_exited = 0;
|
|
|
}
|
|
@@ -492,62 +287,18 @@ void reap_children()
|
|
|
int fill_fds_for_select(fd_set * rdset, fd_set * wrset)
|
|
|
{
|
|
|
int max = -1;
|
|
|
- int fd, i;
|
|
|
FD_ZERO(rdset);
|
|
|
FD_ZERO(wrset);
|
|
|
|
|
|
- for (i = 0; i <= max_process_fd; i++)
|
|
|
- if (process_fd[i].type != FDTYPE_INVALID
|
|
|
- && !process_fd[i].is_blocked) {
|
|
|
- FD_SET(i, rdset);
|
|
|
- max = i;
|
|
|
- }
|
|
|
-
|
|
|
FD_SET(trigger_fd, rdset);
|
|
|
if (trigger_fd > max)
|
|
|
max = trigger_fd;
|
|
|
FD_SET(passfd_socket, rdset);
|
|
|
if (passfd_socket > max)
|
|
|
max = passfd_socket;
|
|
|
-
|
|
|
- for (i = 0; i < MAX_FDS; i++)
|
|
|
- if (client_info[i].pid && client_info[i].is_blocked) {
|
|
|
- fd = client_info[i].stdin_fd;
|
|
|
- FD_SET(fd, wrset);
|
|
|
- if (fd > max)
|
|
|
- max = fd;
|
|
|
- }
|
|
|
return max;
|
|
|
}
|
|
|
|
|
|
-void flush_client_data_agent(int client_id)
|
|
|
-{
|
|
|
- struct _client_info *info = &client_info[client_id];
|
|
|
- switch (flush_client_data
|
|
|
- (vchan, info->stdin_fd, client_id, &info->buffer)) {
|
|
|
- case WRITE_STDIN_OK:
|
|
|
- info->is_blocked = 0;
|
|
|
- if (info->is_close_after_flush_needed) {
|
|
|
- close(info->stdin_fd);
|
|
|
- info->stdin_fd = -1;
|
|
|
- info->is_close_after_flush_needed = 0;
|
|
|
- }
|
|
|
- break;
|
|
|
- case WRITE_STDIN_ERROR:
|
|
|
- // do not remove process, as it still can write data to stdout
|
|
|
- info->is_blocked = 0;
|
|
|
- close(info->stdin_fd);
|
|
|
- info->stdin_fd = -1;
|
|
|
- info->is_close_after_flush_needed = 0;
|
|
|
- break;
|
|
|
- case WRITE_STDIN_BUFFERED:
|
|
|
- break;
|
|
|
- default:
|
|
|
- fprintf(stderr, "unknown flush_client_data?\n");
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
void handle_new_passfd()
|
|
|
{
|
|
|
int fd = do_accept(passfd_socket);
|
|
@@ -561,21 +312,19 @@ void handle_new_passfd()
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-
|
|
|
void handle_trigger_io()
|
|
|
{
|
|
|
- struct server_header s_hdr;
|
|
|
- struct trigger_connect_params params;
|
|
|
+ struct msg_header hdr;
|
|
|
+ struct trigger_service_params params;
|
|
|
int ret;
|
|
|
|
|
|
- s_hdr.client_id = 0;
|
|
|
- s_hdr.len = 0;
|
|
|
+ hdr.len = sizeof(params);
|
|
|
ret = read(trigger_fd, ¶ms, sizeof(params));
|
|
|
if (ret == sizeof(params)) {
|
|
|
- s_hdr.type = MSG_AGENT_TO_SERVER_TRIGGER_CONNECT_EXISTING;
|
|
|
- if (libvchan_send(vchan, &s_hdr, sizeof(s_hdr)) < 0)
|
|
|
+ hdr.type = MSG_TRIGGER_SERVICE;
|
|
|
+ if (libvchan_send(ctrl_vchan, &hdr, sizeof(hdr)) < 0)
|
|
|
handle_vchan_error("write hdr");
|
|
|
- if (libvchan_send(vchan, ¶ms, sizeof(params)) < 0)
|
|
|
+ if (libvchan_send(ctrl_vchan, ¶ms, sizeof(params)) < 0)
|
|
|
handle_vchan_error("write params");
|
|
|
}
|
|
|
// trigger_fd is nonblock - so no need to reopen
|
|
@@ -591,7 +340,6 @@ int main()
|
|
|
{
|
|
|
fd_set rdset, wrset;
|
|
|
int max;
|
|
|
- int i;
|
|
|
sigset_t chld_set;
|
|
|
|
|
|
init();
|
|
@@ -606,27 +354,20 @@ int main()
|
|
|
if (child_exited)
|
|
|
reap_children();
|
|
|
max = fill_fds_for_select(&rdset, &wrset);
|
|
|
- if (libvchan_buffer_space(vchan) <=
|
|
|
- sizeof(struct server_header))
|
|
|
+ if (libvchan_buffer_space(ctrl_vchan) <=
|
|
|
+ (int)sizeof(struct msg_header))
|
|
|
FD_ZERO(&rdset);
|
|
|
|
|
|
- wait_for_vchan_or_argfd(vchan, max, &rdset, &wrset);
|
|
|
+ wait_for_vchan_or_argfd(ctrl_vchan, max, &rdset, &wrset);
|
|
|
sigprocmask(SIG_UNBLOCK, &chld_set, NULL);
|
|
|
|
|
|
if (FD_ISSET(passfd_socket, &rdset))
|
|
|
handle_new_passfd();
|
|
|
|
|
|
- while (libvchan_data_ready(vchan))
|
|
|
- handle_server_data();
|
|
|
+ while (libvchan_data_ready(ctrl_vchan))
|
|
|
+ handle_server_cmd();
|
|
|
|
|
|
if (FD_ISSET(trigger_fd, &rdset))
|
|
|
handle_trigger_io();
|
|
|
-
|
|
|
- handle_process_data_all(&rdset);
|
|
|
- for (i = 0; i <= MAX_FDS; i++)
|
|
|
- if (client_info[i].pid
|
|
|
- && client_info[i].is_blocked
|
|
|
- && FD_ISSET(client_info[i].stdin_fd, &wrset))
|
|
|
- flush_client_data_agent(i);
|
|
|
}
|
|
|
}
|