]> git.sur5r.net Git - i3/i3/blob - testcases/inject_randr1.5.c
travis: fix mk-build-deps call by providing changelog file
[i3/i3] / testcases / inject_randr1.5.c
1 /*
2  * vim:ts=4:sw=4:expandtab
3  *
4  * i3 - an improved dynamic tiling window manager
5  * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
6  *
7  * inject_randr1.5.c: An X11 proxy which interprets RandR 1.5 GetMonitors
8  * requests and overwrites their reply with a custom reply.
9  *
10  * This tool can be refactored as necessary in order to perform the same
11  * purpose for other request types. The RandR 1.5 specific portions of the code
12  * have been marked as such to make such a refactoring easier.
13  *
14  */
15 #include "all.h"
16
17 #include <ev.h>
18 #include <fcntl.h>
19 #include <sys/types.h>
20 #include <sys/socket.h>
21 #include <sys/un.h>
22 #include <sys/time.h>
23 #include <sys/resource.h>
24 #include <sys/mman.h>
25 #include <sys/stat.h>
26 #include <sys/wait.h>
27 #include <libgen.h>
28
29 static void uds_connection_cb(EV_P_ ev_io *w, int revents);
30 static void read_client_setup_request_cb(EV_P_ ev_io *w, int revents);
31 static void read_server_setup_reply_cb(EV_P_ ev_io *w, int revents);
32 static void read_client_x11_packet_cb(EV_P_ ev_io *w, int revents);
33 static void read_server_x11_packet_cb(EV_P_ ev_io *w, int revents);
34
35 static char *sun_path = NULL;
36
37 void cleanup_socket(void) {
38     if (sun_path != NULL) {
39         unlink(sun_path);
40         free(sun_path);
41         sun_path = NULL;
42     }
43 }
44
45 struct injected_reply {
46     void *buf;
47     off_t len;
48 };
49
50 /* BEGIN RandR 1.5 specific */
51 static struct injected_reply getmonitors_reply = {NULL, 0};
52 static struct injected_reply getoutputinfo_reply = {NULL, 0};
53 /* END RandR 1.5 specific */
54
55 #define XCB_PAD(i) (-(i)&3)
56
57 struct connstate {
58     /* clientw is a libev watcher for the connection which we accept()ed. */
59     ev_io *clientw;
60
61     /* serverw is a libev watcher for the connection to X11 which we initiated
62          * on behalf of the client. */
63     ev_io *serverw;
64
65     /* sequence is the client-side sequence number counter. In X11’s wire
66      * encoding, sequence counters are not included in requests, only in
67      * replies. */
68     int sequence;
69
70     /* BEGIN RandR 1.5 specific */
71     /* sequence number of the most recent GetExtension request for RANDR */
72     int getext_randr;
73     /* sequence number of the most recent RRGetMonitors request */
74     int getmonitors;
75     /* sequence number of the most recent RRGetOutputInfo request */
76     int getoutputinfo;
77
78     int randr_major_opcode;
79     /* END RandR 1.5 specific */
80 };
81
82 /*
83  * Returns 0 on EOF
84  * Returns -1 on error (with errno from read() untouched)
85  *
86  */
87 static size_t readall_into(void *buffer, const size_t len, int fd) {
88     size_t read_bytes = 0;
89     while (read_bytes < len) {
90         ssize_t n = read(fd, buffer + read_bytes, len - read_bytes);
91         if (n <= 0) {
92             return n;
93         }
94         read_bytes += (size_t)n;
95     }
96     return read_bytes;
97 }
98
99 /*
100  * Exits the program with an error if the read failed.
101  *
102  */
103 static void must_read(int n) {
104     if (n == -1) {
105         err(EXIT_FAILURE, "read()");
106     }
107     if (n == 0) {
108         errx(EXIT_FAILURE, "EOF");
109     }
110 }
111
112 /*
113  * Exits the program with an error if the write failed.
114  *
115  */
116 static void must_write(int n) {
117     if (n == -1) {
118         err(EXIT_FAILURE, "write()");
119     }
120 }
121
122 static void uds_connection_cb(EV_P_ ev_io *w, int revents) {
123     struct sockaddr_un addr;
124     socklen_t addrlen = sizeof(addr);
125     const int clientfd = accept(w->fd, (struct sockaddr *)&addr, &addrlen);
126     if (clientfd == -1) {
127         if (errno == EINTR) {
128             return;
129         }
130         err(EXIT_FAILURE, "accept()");
131     }
132
133     struct connstate *connstate = scalloc(1, sizeof(struct connstate));
134
135     ev_io *clientw = scalloc(1, sizeof(ev_io));
136     connstate->clientw = clientw;
137     clientw->data = connstate;
138     ev_io_init(clientw, read_client_setup_request_cb, clientfd, EV_READ);
139     ev_io_start(EV_A_ clientw);
140 }
141
142 // https://www.x.org/releases/current/doc/xproto/x11protocol.html#Encoding::Connection_Setup
143 static void read_client_setup_request_cb(EV_P_ ev_io *w, int revents) {
144     ev_io_stop(EV_A_ w);
145     struct connstate *connstate = (struct connstate *)w->data;
146
147     /* Read X11 setup request in its entirety. */
148     xcb_setup_request_t setup_request;
149     must_read(readall_into(&setup_request, sizeof(setup_request), w->fd));
150
151     /* Establish a connection to X11. */
152     int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
153     if (fd == -1) {
154         err(EXIT_FAILURE, "socket()");
155     }
156
157     char *host;
158     int displayp;
159     if (xcb_parse_display(getenv("DISPLAY"), &host, &displayp, NULL) == 0) {
160         errx(EXIT_FAILURE, "Could not parse DISPLAY=%s", getenv("DISPLAY"));
161     }
162     free(host);
163
164     struct sockaddr_un addr;
165     memset(&addr, 0, sizeof(addr));
166     addr.sun_family = AF_LOCAL;
167     snprintf(addr.sun_path, sizeof(addr.sun_path), "/tmp/.X11-unix/X%d", displayp);
168     if (connect(fd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
169         err(EXIT_FAILURE, "connect(%s)", addr.sun_path);
170     }
171
172     /* Relay setup request. */
173     must_write(writeall(fd, &setup_request, sizeof(setup_request)));
174
175     if (setup_request.authorization_protocol_name_len > 0 ||
176         setup_request.authorization_protocol_data_len > 0) {
177         const size_t authlen = setup_request.authorization_protocol_name_len +
178                                XCB_PAD(setup_request.authorization_protocol_name_len) +
179                                setup_request.authorization_protocol_data_len +
180                                XCB_PAD(setup_request.authorization_protocol_data_len);
181         void *buf = smalloc(authlen);
182         must_read(readall_into(buf, authlen, w->fd));
183         must_write(writeall(fd, buf, authlen));
184         free(buf);
185     }
186
187     /* Wait for a response from the X11 server. */
188     ev_io *serverw = scalloc(1, sizeof(ev_io));
189     connstate->serverw = serverw;
190     serverw->data = connstate;
191     ev_io_init(serverw, read_server_setup_reply_cb, fd, EV_READ);
192     ev_io_start(EV_A_ serverw);
193 }
194
195 static void read_server_setup_reply_cb(EV_P_ ev_io *w, int revents) {
196     struct connstate *connstate = (struct connstate *)w->data;
197     xcb_setup_failed_t setup_failed;
198     must_read(readall_into(&setup_failed, sizeof(setup_failed), w->fd));
199
200     switch (setup_failed.status) {
201         case 0:
202             errx(EXIT_FAILURE, "error authenticating at the X11 server");
203
204         case 2:
205             errx(EXIT_FAILURE, "two-factor auth not implemented");
206
207         case 1:
208             must_write(writeall(connstate->clientw->fd, &setup_failed, sizeof(xcb_setup_failed_t)));
209             const size_t len = (setup_failed.length * 4);
210             void *buf = smalloc(len);
211             must_read(readall_into(buf, len, w->fd));
212             must_write(writeall(connstate->clientw->fd, buf, len));
213             free(buf);
214
215             ev_set_cb(connstate->clientw, read_client_x11_packet_cb);
216             ev_set_cb(connstate->serverw, read_server_x11_packet_cb);
217             ev_io_start(EV_A_ connstate->clientw);
218             break;
219
220         default:
221             errx(EXIT_FAILURE, "X11 protocol error: expected setup_failed.status in [0..2], got %d", setup_failed.status);
222     }
223 }
224
225 // https://www.x.org/releases/current/doc/xproto/x11protocol.html#request_format
226 typedef struct {
227     uint8_t opcode;
228     uint8_t pad0;
229     uint16_t length;
230 } generic_x11_request_t;
231
232 // https://www.x.org/releases/current/doc/xproto/x11protocol.html#reply_format
233 typedef struct {
234     uint8_t code; /* if 1, this is a reply. if 0, this is an error. else, an event */
235     uint8_t pad0;
236     uint16_t sequence;
237     uint32_t length;
238 } generic_x11_reply_t;
239
240 static void read_client_x11_packet_cb(EV_P_ ev_io *w, int revents) {
241     struct connstate *connstate = (struct connstate *)w->data;
242
243     void *request = smalloc(sizeof(generic_x11_request_t));
244     must_read(readall_into(request, sizeof(generic_x11_request_t), connstate->clientw->fd));
245     const size_t len = (((generic_x11_request_t *)request)->length * 4);
246     if (len > sizeof(generic_x11_request_t)) {
247         request = srealloc(request, len);
248         must_read(readall_into(request + sizeof(generic_x11_request_t),
249                                len - sizeof(generic_x11_request_t),
250                                connstate->clientw->fd));
251     }
252
253     // XXX: sequence counter wrapping is not implemented, but should not be
254     // necessary given that this tool is scoped for test cases.
255     connstate->sequence++;
256
257     /* BEGIN RandR 1.5 specific */
258     const uint8_t opcode = ((generic_x11_request_t *)request)->opcode;
259     if (opcode == XCB_QUERY_EXTENSION) {
260         xcb_query_extension_request_t *req = request;
261         const char *name = request + sizeof(xcb_query_extension_request_t);
262         if (req->name_len == strlen("RANDR") &&
263             strncmp(name, "RANDR", strlen("RANDR")) == 0) {
264             connstate->getext_randr = connstate->sequence;
265         }
266     } else if (opcode == connstate->randr_major_opcode) {
267         const uint8_t randr_opcode = ((generic_x11_request_t *)request)->pad0;
268         if (randr_opcode == XCB_RANDR_GET_MONITORS) {
269             connstate->getmonitors = connstate->sequence;
270         } else if (randr_opcode == XCB_RANDR_GET_OUTPUT_INFO) {
271             connstate->getoutputinfo = connstate->sequence;
272         }
273     }
274     /* END RandR 1.5 specific */
275
276     must_write(writeall(connstate->serverw->fd, request, len));
277     free(request);
278 }
279
280 static bool handle_sequence(struct connstate *connstate, uint16_t sequence) {
281     /* BEGIN RandR 1.5 specific */
282     if (sequence == connstate->getmonitors) {
283         printf("RRGetMonitors reply!\n");
284         if (getmonitors_reply.buf != NULL) {
285             printf("injecting reply\n");
286             ((generic_x11_reply_t *)getmonitors_reply.buf)->sequence = sequence;
287             must_write(writeall(connstate->clientw->fd, getmonitors_reply.buf, getmonitors_reply.len));
288             return true;
289         }
290     }
291
292     if (sequence == connstate->getoutputinfo) {
293         printf("RRGetOutputInfo reply!\n");
294         if (getoutputinfo_reply.buf != NULL) {
295             printf("injecting reply\n");
296             ((generic_x11_reply_t *)getoutputinfo_reply.buf)->sequence = sequence;
297             must_write(writeall(connstate->clientw->fd, getoutputinfo_reply.buf, getoutputinfo_reply.len));
298             return true;
299         }
300     }
301     /* END RandR 1.5 specific */
302
303     return false;
304 }
305
306 static void read_server_x11_packet_cb(EV_P_ ev_io *w, int revents) {
307     struct connstate *connstate = (struct connstate *)w->data;
308     // all packets from the server are at least 32 bytes in length
309     size_t len = 32;
310     void *packet = smalloc(len);
311     must_read(readall_into(packet, len, connstate->serverw->fd));
312     switch (((generic_x11_reply_t *)packet)->code) {
313         case 0: {  // error
314             const uint16_t sequence = ((xcb_request_error_t *)packet)->sequence;
315             if (handle_sequence(connstate, sequence)) {
316                 free(packet);
317                 return;
318             }
319             break;
320         }
321         case 1:  // reply
322             len += ((generic_x11_reply_t *)packet)->length * 4;
323             if (len > 32) {
324                 packet = srealloc(packet, len);
325                 must_read(readall_into(packet + 32, len - 32, connstate->serverw->fd));
326             }
327
328             /* BEGIN RandR 1.5 specific */
329             const uint16_t sequence = ((generic_x11_reply_t *)packet)->sequence;
330
331             if (sequence == connstate->getext_randr) {
332                 xcb_query_extension_reply_t *reply = packet;
333                 connstate->randr_major_opcode = reply->major_opcode;
334             }
335             /* END RandR 1.5 specific */
336
337             if (handle_sequence(connstate, sequence)) {
338                 free(packet);
339                 return;
340             }
341
342             break;
343
344         default:  // event
345             break;
346     }
347     must_write(writeall(connstate->clientw->fd, packet, len));
348     free(packet);
349 }
350
351 static void child_cb(EV_P_ ev_child *w, int revents) {
352     ev_child_stop(EV_A_ w);
353     if (WIFEXITED(w->rstatus)) {
354         exit(WEXITSTATUS(w->rstatus));
355     } else {
356         exit(WTERMSIG(w->rstatus) + 128);
357     }
358 }
359
360 static void must_read_reply(const char *filename, struct injected_reply *reply) {
361     FILE *f;
362     if ((f = fopen(filename, "r")) == NULL) {
363         err(EXIT_FAILURE, "fopen(%s)", filename);
364     }
365     struct stat stbuf;
366     if (fstat(fileno(f), &stbuf) != 0) {
367         err(EXIT_FAILURE, "fstat(%s)", filename);
368     }
369     reply->len = stbuf.st_size;
370     reply->buf = smalloc(stbuf.st_size);
371     int n = fread(reply->buf, 1, stbuf.st_size, f);
372     if (n != stbuf.st_size) {
373         err(EXIT_FAILURE, "fread(%s)", filename);
374     }
375     fclose(f);
376 }
377
378 int main(int argc, char *argv[]) {
379     static struct option long_options[] = {
380         {"getmonitors_reply", required_argument, 0, 0},
381         {"getoutputinfo_reply", required_argument, 0, 0},
382         {0, 0, 0, 0},
383     };
384     char *options_string = "";
385     int opt;
386     int option_index = 0;
387
388     while ((opt = getopt_long(argc, argv, options_string, long_options, &option_index)) != -1) {
389         switch (opt) {
390             case 0: {
391                 const char *option_name = long_options[option_index].name;
392                 if (strcmp(option_name, "getmonitors_reply") == 0) {
393                     must_read_reply(optarg, &getmonitors_reply);
394                 } else if (strcmp(option_name, "getoutputinfo_reply") == 0) {
395                     must_read_reply(optarg, &getoutputinfo_reply);
396                 }
397                 break;
398             }
399             default:
400                 exit(EXIT_FAILURE);
401         }
402     }
403
404     if (optind >= argc) {
405         errx(EXIT_FAILURE, "syntax: %s [options] <command>\n", argv[0]);
406     }
407
408     int fd = socket(AF_LOCAL, SOCK_STREAM, 0);
409     if (fd == -1) {
410         err(EXIT_FAILURE, "socket(AF_UNIX)");
411     }
412
413     if (fcntl(fd, F_SETFD, FD_CLOEXEC)) {
414         warn("Could not set FD_CLOEXEC");
415     }
416
417     struct sockaddr_un addr;
418     memset(&addr, 0, sizeof(struct sockaddr_un));
419     addr.sun_family = AF_UNIX;
420     int i;
421     bool bound = false;
422     for (i = 0; i < 100; i++) {
423         /* XXX: The path to X11 sockets differs on some platforms (e.g. Trusted
424          * Solaris, HPUX), but since libxcb doesn’t provide a function to
425          * generate the path, we’ll just have to hard-code it for now. */
426         snprintf(addr.sun_path, sizeof(addr.sun_path), "/tmp/.X11-unix/X%d", i);
427
428         if (bind(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
429             warn("bind(%s)", addr.sun_path);
430         } else {
431             bound = true;
432             /* Let the user know bind() was successful, so that they know the
433              * error messages can be disregarded. */
434             fprintf(stderr, "Successfuly bound to %s\n", addr.sun_path);
435             sun_path = sstrdup(addr.sun_path);
436             break;
437         }
438     }
439
440     if (!bound) {
441         err(EXIT_FAILURE, "bind()");
442     }
443
444     atexit(cleanup_socket);
445
446     /* This program will be started for each testcase which requires it, so we
447      * expect precisely one connection. */
448     if (listen(fd, 1) == -1) {
449         err(EXIT_FAILURE, "listen()");
450     }
451
452     pid_t child = fork();
453     if (child == -1) {
454         err(EXIT_FAILURE, "fork()");
455     }
456     if (child == 0) {
457         char *display;
458         sasprintf(&display, ":%d", i);
459         setenv("DISPLAY", display, 1);
460         free(display);
461
462         char **child_args = argv + optind;
463         execvp(child_args[0], child_args);
464         err(EXIT_FAILURE, "exec()");
465     }
466
467     struct ev_loop *loop = ev_default_loop(0);
468
469     ev_child cw;
470     ev_child_init(&cw, child_cb, child, 0);
471     ev_child_start(loop, &cw);
472
473     ev_io watcher;
474     ev_io_init(&watcher, uds_connection_cb, fd, EV_READ);
475     ev_io_start(loop, &watcher);
476
477     ev_run(loop, 0);
478 }