1 /*
2 * Copyright © 2016 Broadcom
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #ifdef HAVE_DIX_CONFIG_H
25 #include <dix-config.h>
26 #endif
27
28 #include <errno.h>
29 #include <signal.h>
30 #include <stdbool.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <sys/wait.h>
35 #include <unistd.h>
36
37 static void
kill_server(int server_pid)38 kill_server(int server_pid)
39 {
40 int ret = kill(server_pid, SIGTERM);
41 int wstatus;
42
43 if (ret) {
44 fprintf(stderr, "Failed to send kill to the server: %s\n",
45 strerror(errno));
46 exit(1);
47 }
48
49 ret = waitpid(server_pid, &wstatus, 0);
50 if (ret < 0) {
51 fprintf(stderr, "Failed to wait for X to die: %s\n", strerror(errno));
52 exit(1);
53 }
54 }
55
56 static void
usage(int argc,char ** argv)57 usage(int argc, char **argv)
58 {
59 fprintf(stderr, "%s <client command> -- <server command>\n", argv[0]);
60 exit(1);
61 }
62
63 /* Starts the X server, returning its pid. */
64 static int
start_server(char * const * server_args)65 start_server(char *const *server_args)
66 {
67 int server_pid = fork();
68
69 if (server_pid == -1) {
70 fprintf(stderr, "Fork failed: %s\n", strerror(errno));
71 exit(1);
72 } else if (server_pid != 0) {
73 /* Continue along the main process that will exec the client. */
74 return server_pid;
75 }
76
77 /* Execute the server. This only returns if an error occurred. */
78 execvp(server_args[0], server_args);
79 fprintf(stderr, "Error starting the server: %s\n", strerror(errno));
80 exit(1);
81 }
82
83 /* Reads the display number out of the started server's display socket. */
84 static int
get_display(int displayfd)85 get_display(int displayfd)
86 {
87 char display_string[10];
88 ssize_t ret;
89
90 ret = read(displayfd, display_string, sizeof(display_string) - 1);
91 if (ret <= 0) {
92 fprintf(stderr, "Failed reading displayfd: %s\n", strerror(errno));
93 exit(1);
94 }
95
96 /* We've read in the display number as a string terminated by
97 * '\n', but not '\0'. Cap it and parse the number.
98 */
99 display_string[ret] = '\0';
100 return atoi(display_string);
101 }
102
103 static int
start_client(char * const * client_args,int display)104 start_client(char *const *client_args, int display)
105 {
106 char *display_string;
107 int ret;
108 int client_pid;
109
110 ret = asprintf(&display_string, ":%d", display);
111 if (ret < 0) {
112 fprintf(stderr, "asprintf fail\n");
113 exit(1);
114 }
115
116 ret = setenv("DISPLAY", display_string, true);
117 if (ret) {
118 fprintf(stderr, "Failed to set DISPLAY\n");
119 exit(1);
120 }
121
122 client_pid = fork();
123 if (client_pid == -1) {
124 fprintf(stderr, "Fork failed: %s\n", strerror(errno));
125 exit(1);
126 } else if (client_pid) {
127 int wstatus;
128
129 ret = waitpid(client_pid, &wstatus, 0);
130 if (ret < 0) {
131 fprintf(stderr, "Error waiting for client to start: %s\n",
132 strerror(errno));
133 return 1;
134 }
135
136 if (!WIFEXITED(wstatus))
137 return 1;
138
139 return WEXITSTATUS(wstatus);
140 } else {
141 execvp(client_args[0], client_args);
142 /* exec only returns if an error occurred. */
143 fprintf(stderr, "Error starting the client: %s\n", strerror(errno));
144 exit(1);
145 }
146 }
147
148 /* Splits the incoming argc/argv into a pair of NULL-terminated arrays
149 * of args.
150 */
151 static void
parse_args(int argc,char ** argv,char * const ** out_client_args,char * const ** out_server_args,int displayfd)152 parse_args(int argc, char **argv,
153 char * const **out_client_args,
154 char * const **out_server_args,
155 int displayfd)
156 {
157 /* We're stripping the -- and the program name, inserting two
158 * NULLs, and also the -displayfd and fd number.
159 */
160 char **args_storage = calloc(argc + 2, sizeof(char *));
161 char *const *client_args;
162 char *const *server_args = NULL;
163 char **next_arg = args_storage;
164 bool parsing_client = true;
165 int i, ret;
166 char *displayfd_string;
167
168 if (!args_storage)
169 exit(1);
170
171 client_args = args_storage;
172 for (i = 1; i < argc; i++) {
173 if (strcmp(argv[i], "--") == 0) {
174 if (!parsing_client)
175 usage(argc, argv);
176
177 /* Cap the client list */
178 *next_arg = NULL;
179 next_arg++;
180
181 /* Move to adding into server_args. */
182 server_args = next_arg;
183 parsing_client = false;
184 continue;
185 }
186
187 *next_arg = argv[i];
188 next_arg++;
189 }
190
191 if (client_args[0] == NULL || !server_args || server_args[0] == NULL)
192 usage(argc, argv);
193
194 /* Give the server -displayfd X */
195 *next_arg = (char *)"-displayfd";
196 next_arg++;
197
198 ret = asprintf(&displayfd_string, "%d", displayfd);
199 if (ret < 0) {
200 fprintf(stderr, "asprintf fail\n");
201 exit(1);
202 }
203 *next_arg = displayfd_string;
204 next_arg++;
205
206 *out_client_args = client_args;
207 *out_server_args = server_args;
208 }
209
210 int
main(int argc,char ** argv)211 main(int argc, char **argv)
212 {
213 char * const *client_args;
214 char * const *server_args;
215 int displayfd_pipe[2];
216 int display, server_pid;
217 int ret;
218
219 ret = pipe(displayfd_pipe);
220 if (ret) {
221 fprintf(stderr, "Pipe creation failure: %s", strerror(errno));
222 exit(1);
223 }
224
225 parse_args(argc, argv, &client_args, &server_args, displayfd_pipe[1]);
226 server_pid = start_server(server_args);
227 display = get_display(displayfd_pipe[0]);
228 ret = start_client(client_args, display);
229 kill_server(server_pid);
230
231 exit(ret);
232 }
233