git.sur5r.net Git - i3/i3/blob - src/ipc.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  * ipc.c: UNIX domain socket IPC (initialization, client handling, protocol).
   8  *
   9  */
  10 #include "all.h"
  11
  12 #include "yajl_utils.h"
  13
  14 #include <stdint.h>
  15 #include <sys/socket.h>
  16 #include <sys/un.h>
  17 #include <fcntl.h>
  18 #include <libgen.h>
  19 #include <ev.h>
  20 #include <yajl/yajl_gen.h>
  21 #include <yajl/yajl_parse.h>
  22
  23 char *current_socketpath = NULL;
  24
  25 TAILQ_HEAD(ipc_client_head, ipc_client)
  26 all_clients = TAILQ_HEAD_INITIALIZER(all_clients);
  27
  28 /*
  29  * Puts the given socket file descriptor into non-blocking mode or dies if
  30  * setting O_NONBLOCK failed. Non-blocking sockets are a good idea for our
  31  * IPC model because we should by no means block the window manager.
  32  *
  33  */
  34 static void set_nonblock(int sockfd) {
  35     int flags = fcntl(sockfd, F_GETFL, 0);
  36     flags |= O_NONBLOCK;
  37     if (fcntl(sockfd, F_SETFL, flags) < 0)
  38         err(-1, "Could not set O_NONBLOCK");
  39 }
  40
  41 /*
  42  * Given a message and a message type, create the corresponding header, merge it
  43  * with the message and append it to the given client's output buffer.
  44  *
  45  */
  46 static void append_payload(ipc_client *client, uint32_t message_type, const char *payload) {
  47     const size_t size = strlen(payload);
  48     const i3_ipc_header_t header = {
  49         .magic = {'i', '3', '-', 'i', 'p', 'c'},
  50         .size = size,
  51         .type = message_type};
  52     const size_t header_size = sizeof(i3_ipc_header_t);
  53     const size_t message_size = header_size + size;
  54
  55     client->buffer = srealloc(client->buffer, client->buffer_size + message_size);
  56     memcpy(client->buffer + client->buffer_size, ((void *)&header), header_size);
  57     memcpy(client->buffer + client->buffer_size + header_size, payload, size);
  58     client->buffer_size += message_size;
  59 }
  60
  61 static void free_ipc_client(ipc_client *client) {
  62     close(client->fd);
  63
  64     ev_io_stop(main_loop, client->callback);
  65     FREE(client->callback);
  66     if (client->timeout) {
  67         ev_timer_stop(main_loop, client->timeout);
  68         FREE(client->timeout);
  69     }
  70
  71     free(client->buffer);
  72
  73     for (int i = 0; i < client->num_events; i++) {
  74         free(client->events[i]);
  75     }
  76     free(client->events);
  77     TAILQ_REMOVE(&all_clients, client, clients);
  78     free(client);
  79 }
  80
  81 static void ipc_client_timeout(EV_P_ ev_timer *w, int revents);
  82 static void ipc_socket_writeable_cb(EV_P_ struct ev_io *w, int revents);
  83
  84 static ev_tstamp kill_timeout = 10.0;
  85
  86 void ipc_set_kill_timeout(ev_tstamp new) {
  87     kill_timeout = new;
  88 }
  89
  90 /*
  91  * Try to write the contents of the pending buffer to the client's subscription
  92  * socket. Will set, reset or clear the timeout and io callbacks depending on
  93  * the result of the write operation.
  94  *
  95  */
  96 static void ipc_push_pending(ipc_client *client) {
  97     const ssize_t result = writeall_nonblock(client->fd, client->buffer, client->buffer_size);
  98     if (result < 0) {
  99         return;
 100     }
 101
 102     if ((size_t)result == client->buffer_size) {
 103         /* Everything was written successfully: clear the timer and stop the io
 104          * callback. */
 105         FREE(client->buffer);
 106         client->buffer_size = 0;
 107         if (client->timeout) {
 108             ev_timer_stop(main_loop, client->timeout);
 109             FREE(client->timeout);
 110         }
 111         ev_io_stop(main_loop, client->callback);
 112         return;
 113     }
 114
 115     /* Otherwise, make sure that the io callback is enabled and create a new
 116      * timer if needed. */
 117     ev_io_start(main_loop, client->callback);
 118
 119     if (!client->timeout) {
 120         struct ev_timer *timeout = scalloc(1, sizeof(struct ev_timer));
 121         ev_timer_init(timeout, ipc_client_timeout, kill_timeout, 0.);
 122         timeout->data = client;
 123         client->timeout = timeout;
 124         ev_set_priority(timeout, EV_MINPRI);
 125         ev_timer_start(main_loop, client->timeout);
 126     } else if (result > 0) {
 127         /* Keep the old timeout when nothing is written. Otherwise, we would
 128          * keep a dead connection by continuously renewing its timeouts. */
 129         ev_timer_stop(main_loop, client->timeout);
 130         ev_timer_set(client->timeout, kill_timeout, 0.0);
 131         ev_timer_start(main_loop, client->timeout);
 132     }
 133     if (result == 0) {
 134         return;
 135     }
 136
 137     /* Shift the buffer to the left and reduce the allocated space. */
 138     client->buffer_size -= (size_t)result;
 139     memmove(client->buffer, client->buffer + result, client->buffer_size);
 140     client->buffer = srealloc(client->buffer, client->buffer_size);
 141 }
 142
 143 /*
 144  * Sends the specified event to all IPC clients which are currently connected
 145  * and subscribed to this kind of event.
 146  *
 147  */
 148 void ipc_send_event(const char *event, uint32_t message_type, const char *payload) {
 149     ipc_client *current;
 150     TAILQ_FOREACH(current, &all_clients, clients) {
 151         /* see if this client is interested in this event */
 152         bool interested = false;
 153         for (int i = 0; i < current->num_events; i++) {
 154             if (strcasecmp(current->events[i], event) != 0)
 155                 continue;
 156             interested = true;
 157             break;
 158         }
 159         if (!interested)
 160             continue;
 161
 162         const bool push_now = (current->buffer_size == 0);
 163         append_payload(current, message_type, payload);
 164         if (push_now) {
 165             ipc_push_pending(current);
 166         }
 167     }
 168 }
 169
 170 /*
 171  * For shutdown events, we send the reason for the shutdown.
 172  */
 173 static void ipc_send_shutdown_event(shutdown_reason_t reason) {
 174     yajl_gen gen = ygenalloc();
 175     y(map_open);
 176
 177     ystr("change");
 178
 179     if (reason == SHUTDOWN_REASON_RESTART) {
 180         ystr("restart");
 181     } else if (reason == SHUTDOWN_REASON_EXIT) {
 182         ystr("exit");
 183     }
 184
 185     y(map_close);
 186
 187     const unsigned char *payload;
 188     ylength length;
 189
 190     y(get_buf, &payload, &length);
 191     ipc_send_event("shutdown", I3_IPC_EVENT_SHUTDOWN, (const char *)payload);
 192
 193     y(free);
 194 }
 195
 196 /*
 197  * Calls shutdown() on each socket and closes it. This function is to be called
 198  * when exiting or restarting only!
 199  *
 200  */
 201 void ipc_shutdown(shutdown_reason_t reason) {
 202     ipc_send_shutdown_event(reason);
 203
 204     ipc_client *current;
 205     while (!TAILQ_EMPTY(&all_clients)) {
 206         current = TAILQ_FIRST(&all_clients);
 207         shutdown(current->fd, SHUT_RDWR);
 208         free_ipc_client(current);
 209     }
 210 }
 211
 212 /*
 213  * Executes the command and returns whether it could be successfully parsed
 214  * or not (at the moment, always returns true).
 215  *
 216  */
 217 IPC_HANDLER(run_command) {
 218     /* To get a properly terminated buffer, we copy
 219      * message_size bytes out of the buffer */
 220     char *command = scalloc(message_size + 1, 1);
 221     strncpy(command, (const char *)message, message_size);
 222     LOG("IPC: received: *%s*\n", command);
 223     yajl_gen gen = yajl_gen_alloc(NULL);
 224
 225     CommandResult *result = parse_command((const char *)command, gen);
 226     free(command);
 227
 228     if (result->needs_tree_render)
 229         tree_render();
 230
 231     command_result_free(result);
 232
 233     const unsigned char *reply;
 234     ylength length;
 235     yajl_gen_get_buf(gen, &reply, &length);
 236
 237     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_COMMAND,
 238                      (const uint8_t *)reply);
 239
 240     yajl_gen_free(gen);
 241 }
 242
 243 static void dump_rect(yajl_gen gen, const char *name, Rect r) {
 244     ystr(name);
 245     y(map_open);
 246     ystr("x");
 247     y(integer, r.x);
 248     ystr("y");
 249     y(integer, r.y);
 250     ystr("width");
 251     y(integer, r.width);
 252     ystr("height");
 253     y(integer, r.height);
 254     y(map_close);
 255 }
 256
 257 static void dump_event_state_mask(yajl_gen gen, Binding *bind) {
 258     y(array_open);
 259     for (int i = 0; i < 20; i++) {
 260         if (bind->event_state_mask & (1 << i)) {
 261             switch (1 << i) {
 262                 case XCB_KEY_BUT_MASK_SHIFT:
 263                     ystr("shift");
 264                     break;
 265                 case XCB_KEY_BUT_MASK_LOCK:
 266                     ystr("lock");
 267                     break;
 268                 case XCB_KEY_BUT_MASK_CONTROL:
 269                     ystr("ctrl");
 270                     break;
 271                 case XCB_KEY_BUT_MASK_MOD_1:
 272                     ystr("Mod1");
 273                     break;
 274                 case XCB_KEY_BUT_MASK_MOD_2:
 275                     ystr("Mod2");
 276                     break;
 277                 case XCB_KEY_BUT_MASK_MOD_3:
 278                     ystr("Mod3");
 279                     break;
 280                 case XCB_KEY_BUT_MASK_MOD_4:
 281                     ystr("Mod4");
 282                     break;
 283                 case XCB_KEY_BUT_MASK_MOD_5:
 284                     ystr("Mod5");
 285                     break;
 286                 case XCB_KEY_BUT_MASK_BUTTON_1:
 287                     ystr("Button1");
 288                     break;
 289                 case XCB_KEY_BUT_MASK_BUTTON_2:
 290                     ystr("Button2");
 291                     break;
 292                 case XCB_KEY_BUT_MASK_BUTTON_3:
 293                     ystr("Button3");
 294                     break;
 295                 case XCB_KEY_BUT_MASK_BUTTON_4:
 296                     ystr("Button4");
 297                     break;
 298                 case XCB_KEY_BUT_MASK_BUTTON_5:
 299                     ystr("Button5");
 300                     break;
 301                 case (I3_XKB_GROUP_MASK_1 << 16):
 302                     ystr("Group1");
 303                     break;
 304                 case (I3_XKB_GROUP_MASK_2 << 16):
 305                     ystr("Group2");
 306                     break;
 307                 case (I3_XKB_GROUP_MASK_3 << 16):
 308                     ystr("Group3");
 309                     break;
 310                 case (I3_XKB_GROUP_MASK_4 << 16):
 311                     ystr("Group4");
 312                     break;
 313             }
 314         }
 315     }
 316     y(array_close);
 317 }
 318
 319 static void dump_binding(yajl_gen gen, Binding *bind) {
 320     y(map_open);
 321     ystr("input_code");
 322     y(integer, bind->keycode);
 323
 324     ystr("input_type");
 325     ystr((const char *)(bind->input_type == B_KEYBOARD ? "keyboard" : "mouse"));
 326
 327     ystr("symbol");
 328     if (bind->symbol == NULL)
 329         y(null);
 330     else
 331         ystr(bind->symbol);
 332
 333     ystr("command");
 334     ystr(bind->command);
 335
 336     // This key is only provided for compatibility, new programs should use
 337     // event_state_mask instead.
 338     ystr("mods");
 339     dump_event_state_mask(gen, bind);
 340
 341     ystr("event_state_mask");
 342     dump_event_state_mask(gen, bind);
 343
 344     y(map_close);
 345 }
 346
 347 void dump_node(yajl_gen gen, struct Con *con, bool inplace_restart) {
 348     y(map_open);
 349     ystr("id");
 350     y(integer, (uintptr_t)con);
 351
 352     ystr("type");
 353     switch (con->type) {
 354         case CT_ROOT:
 355             ystr("root");
 356             break;
 357         case CT_OUTPUT:
 358             ystr("output");
 359             break;
 360         case CT_CON:
 361             ystr("con");
 362             break;
 363         case CT_FLOATING_CON:
 364             ystr("floating_con");
 365             break;
 366         case CT_WORKSPACE:
 367             ystr("workspace");
 368             break;
 369         case CT_DOCKAREA:
 370             ystr("dockarea");
 371             break;
 372     }
 373
 374     /* provided for backwards compatibility only. */
 375     ystr("orientation");
 376     if (!con_is_split(con))
 377         ystr("none");
 378     else {
 379         if (con_orientation(con) == HORIZ)
 380             ystr("horizontal");
 381         else
 382             ystr("vertical");
 383     }
 384
 385     ystr("scratchpad_state");
 386     switch (con->scratchpad_state) {
 387         case SCRATCHPAD_NONE:
 388             ystr("none");
 389             break;
 390         case SCRATCHPAD_FRESH:
 391             ystr("fresh");
 392             break;
 393         case SCRATCHPAD_CHANGED:
 394             ystr("changed");
 395             break;
 396     }
 397
 398     ystr("percent");
 399     if (con->percent == 0.0)
 400         y(null);
 401     else
 402         y(double, con->percent);
 403
 404     ystr("urgent");
 405     y(bool, con->urgent);
 406
 407     if (!TAILQ_EMPTY(&(con->marks_head))) {
 408         ystr("marks");
 409         y(array_open);
 410
 411         mark_t *mark;
 412         TAILQ_FOREACH(mark, &(con->marks_head), marks) {
 413             ystr(mark->name);
 414         }
 415
 416         y(array_close);
 417     }
 418
 419     ystr("focused");
 420     y(bool, (con == focused));
 421
 422     if (con->type != CT_ROOT && con->type != CT_OUTPUT) {
 423         ystr("output");
 424         ystr(con_get_output(con)->name);
 425     }
 426
 427     ystr("layout");
 428     switch (con->layout) {
 429         case L_DEFAULT:
 430             DLOG("About to dump layout=default, this is a bug in the code.\n");
 431             assert(false);
 432             break;
 433         case L_SPLITV:
 434             ystr("splitv");
 435             break;
 436         case L_SPLITH:
 437             ystr("splith");
 438             break;
 439         case L_STACKED:
 440             ystr("stacked");
 441             break;
 442         case L_TABBED:
 443             ystr("tabbed");
 444             break;
 445         case L_DOCKAREA:
 446             ystr("dockarea");
 447             break;
 448         case L_OUTPUT:
 449             ystr("output");
 450             break;
 451     }
 452
 453     ystr("workspace_layout");
 454     switch (con->workspace_layout) {
 455         case L_DEFAULT:
 456             ystr("default");
 457             break;
 458         case L_STACKED:
 459             ystr("stacked");
 460             break;
 461         case L_TABBED:
 462             ystr("tabbed");
 463             break;
 464         default:
 465             DLOG("About to dump workspace_layout=%d (none of default/stacked/tabbed), this is a bug.\n", con->workspace_layout);
 466             assert(false);
 467             break;
 468     }
 469
 470     ystr("last_split_layout");
 471     switch (con->layout) {
 472         case L_SPLITV:
 473             ystr("splitv");
 474             break;
 475         default:
 476             ystr("splith");
 477             break;
 478     }
 479
 480     ystr("border");
 481     switch (con->border_style) {
 482         case BS_NORMAL:
 483             ystr("normal");
 484             break;
 485         case BS_NONE:
 486             ystr("none");
 487             break;
 488         case BS_PIXEL:
 489             ystr("pixel");
 490             break;
 491     }
 492
 493     ystr("current_border_width");
 494     y(integer, con->current_border_width);
 495
 496     dump_rect(gen, "rect", con->rect);
 497     dump_rect(gen, "deco_rect", con->deco_rect);
 498     dump_rect(gen, "window_rect", con->window_rect);
 499     dump_rect(gen, "geometry", con->geometry);
 500
 501     ystr("name");
 502     if (con->window && con->window->name)
 503         ystr(i3string_as_utf8(con->window->name));
 504     else if (con->name != NULL)
 505         ystr(con->name);
 506     else
 507         y(null);
 508
 509     if (con->title_format != NULL) {
 510         ystr("title_format");
 511         ystr(con->title_format);
 512     }
 513
 514     if (con->type == CT_WORKSPACE) {
 515         ystr("num");
 516         y(integer, con->num);
 517     }
 518
 519     ystr("window");
 520     if (con->window)
 521         y(integer, con->window->id);
 522     else
 523         y(null);
 524
 525     if (con->window && !inplace_restart) {
 526         /* Window properties are useless to preserve when restarting because
 527          * they will be queried again anyway. However, for i3-save-tree(1),
 528          * they are very useful and save i3-save-tree dealing with X11. */
 529         ystr("window_properties");
 530         y(map_open);
 531
 532 #define DUMP_PROPERTY(key, prop_name)         \
 533     do {                                      \
 534         if (con->window->prop_name != NULL) { \
 535             ystr(key);                        \
 536             ystr(con->window->prop_name);     \
 537         }                                     \
 538     } while (0)
 539
 540         DUMP_PROPERTY("class", class_class);
 541         DUMP_PROPERTY("instance", class_instance);
 542         DUMP_PROPERTY("window_role", role);
 543
 544         if (con->window->name != NULL) {
 545             ystr("title");
 546             ystr(i3string_as_utf8(con->window->name));
 547         }
 548
 549         ystr("transient_for");
 550         if (con->window->transient_for == XCB_NONE)
 551             y(null);
 552         else
 553             y(integer, con->window->transient_for);
 554
 555         y(map_close);
 556     }
 557
 558     ystr("nodes");
 559     y(array_open);
 560     Con *node;
 561     if (con->type != CT_DOCKAREA || !inplace_restart) {
 562         TAILQ_FOREACH(node, &(con->nodes_head), nodes) {
 563             dump_node(gen, node, inplace_restart);
 564         }
 565     }
 566     y(array_close);
 567
 568     ystr("floating_nodes");
 569     y(array_open);
 570     TAILQ_FOREACH(node, &(con->floating_head), floating_windows) {
 571         dump_node(gen, node, inplace_restart);
 572     }
 573     y(array_close);
 574
 575     ystr("focus");
 576     y(array_open);
 577     TAILQ_FOREACH(node, &(con->focus_head), focused) {
 578         y(integer, (uintptr_t)node);
 579     }
 580     y(array_close);
 581
 582     ystr("fullscreen_mode");
 583     y(integer, con->fullscreen_mode);
 584
 585     ystr("sticky");
 586     y(bool, con->sticky);
 587
 588     ystr("floating");
 589     switch (con->floating) {
 590         case FLOATING_AUTO_OFF:
 591             ystr("auto_off");
 592             break;
 593         case FLOATING_AUTO_ON:
 594             ystr("auto_on");
 595             break;
 596         case FLOATING_USER_OFF:
 597             ystr("user_off");
 598             break;
 599         case FLOATING_USER_ON:
 600             ystr("user_on");
 601             break;
 602     }
 603
 604     ystr("swallows");
 605     y(array_open);
 606     Match *match;
 607     TAILQ_FOREACH(match, &(con->swallow_head), matches) {
 608         /* We will generate a new restart_mode match specification after this
 609          * loop, so skip this one. */
 610         if (match->restart_mode)
 611             continue;
 612         y(map_open);
 613         if (match->dock != M_DONTCHECK) {
 614             ystr("dock");
 615             y(integer, match->dock);
 616             ystr("insert_where");
 617             y(integer, match->insert_where);
 618         }
 619
 620 #define DUMP_REGEX(re_name)                \
 621     do {                                   \
 622         if (match->re_name != NULL) {      \
 623             ystr(#re_name);                \
 624             ystr(match->re_name->pattern); \
 625         }                                  \
 626     } while (0)
 627
 628         DUMP_REGEX(class);
 629         DUMP_REGEX(instance);
 630         DUMP_REGEX(window_role);
 631         DUMP_REGEX(title);
 632
 633 #undef DUMP_REGEX
 634         y(map_close);
 635     }
 636
 637     if (inplace_restart) {
 638         if (con->window != NULL) {
 639             y(map_open);
 640             ystr("id");
 641             y(integer, con->window->id);
 642             ystr("restart_mode");
 643             y(bool, true);
 644             y(map_close);
 645         }
 646     }
 647     y(array_close);
 648
 649     if (inplace_restart && con->window != NULL) {
 650         ystr("depth");
 651         y(integer, con->depth);
 652     }
 653
 654     y(map_close);
 655 }
 656
 657 static void dump_bar_bindings(yajl_gen gen, Barconfig *config) {
 658     if (TAILQ_EMPTY(&(config->bar_bindings)))
 659         return;
 660
 661     ystr("bindings");
 662     y(array_open);
 663
 664     struct Barbinding *current;
 665     TAILQ_FOREACH(current, &(config->bar_bindings), bindings) {
 666         y(map_open);
 667
 668         ystr("input_code");
 669         y(integer, current->input_code);
 670         ystr("command");
 671         ystr(current->command);
 672         ystr("release");
 673         y(bool, current->release == B_UPON_KEYRELEASE);
 674
 675         y(map_close);
 676     }
 677
 678     y(array_close);
 679 }
 680
 681 static char *canonicalize_output_name(char *name) {
 682     /* Do not canonicalize special output names. */
 683     if (strcasecmp(name, "primary") == 0) {
 684         return name;
 685     }
 686     Output *output = get_output_by_name(name, false);
 687     return output ? output_primary_name(output) : name;
 688 }
 689
 690 static void dump_bar_config(yajl_gen gen, Barconfig *config) {
 691     y(map_open);
 692
 693     ystr("id");
 694     ystr(config->id);
 695
 696     if (config->num_outputs > 0) {
 697         ystr("outputs");
 698         y(array_open);
 699         for (int c = 0; c < config->num_outputs; c++) {
 700             /* Convert monitor names (RandR ≥ 1.5) or output names
 701              * (RandR < 1.5) into monitor names. This way, existing
 702              * configs which use output names transparently keep
 703              * working. */
 704             ystr(canonicalize_output_name(config->outputs[c]));
 705         }
 706         y(array_close);
 707     }
 708
 709     if (!TAILQ_EMPTY(&(config->tray_outputs))) {
 710         ystr("tray_outputs");
 711         y(array_open);
 712
 713         struct tray_output_t *tray_output;
 714         TAILQ_FOREACH(tray_output, &(config->tray_outputs), tray_outputs) {
 715             ystr(canonicalize_output_name(tray_output->output));
 716         }
 717
 718         y(array_close);
 719     }
 720
 721 #define YSTR_IF_SET(name)       \
 722     do {                        \
 723         if (config->name) {     \
 724             ystr(#name);        \
 725             ystr(config->name); \
 726         }                       \
 727     } while (0)
 728
 729     ystr("tray_padding");
 730     y(integer, config->tray_padding);
 731
 732     YSTR_IF_SET(socket_path);
 733
 734     ystr("mode");
 735     switch (config->mode) {
 736         case M_HIDE:
 737             ystr("hide");
 738             break;
 739         case M_INVISIBLE:
 740             ystr("invisible");
 741             break;
 742         case M_DOCK:
 743         default:
 744             ystr("dock");
 745             break;
 746     }
 747
 748     ystr("hidden_state");
 749     switch (config->hidden_state) {
 750         case S_SHOW:
 751             ystr("show");
 752             break;
 753         case S_HIDE:
 754         default:
 755             ystr("hide");
 756             break;
 757     }
 758
 759     ystr("modifier");
 760     y(integer, config->modifier);
 761
 762     dump_bar_bindings(gen, config);
 763
 764     ystr("position");
 765     if (config->position == P_BOTTOM)
 766         ystr("bottom");
 767     else
 768         ystr("top");
 769
 770     YSTR_IF_SET(status_command);
 771     YSTR_IF_SET(font);
 772
 773     if (config->separator_symbol) {
 774         ystr("separator_symbol");
 775         ystr(config->separator_symbol);
 776     }
 777
 778     ystr("workspace_buttons");
 779     y(bool, !config->hide_workspace_buttons);
 780
 781     ystr("strip_workspace_numbers");
 782     y(bool, config->strip_workspace_numbers);
 783
 784     ystr("strip_workspace_name");
 785     y(bool, config->strip_workspace_name);
 786
 787     ystr("binding_mode_indicator");
 788     y(bool, !config->hide_binding_mode_indicator);
 789
 790     ystr("verbose");
 791     y(bool, config->verbose);
 792
 793 #undef YSTR_IF_SET
 794 #define YSTR_IF_SET(name)              \
 795     do {                               \
 796         if (config->colors.name) {     \
 797             ystr(#name);               \
 798             ystr(config->colors.name); \
 799         }                              \
 800     } while (0)
 801
 802     ystr("colors");
 803     y(map_open);
 804     YSTR_IF_SET(background);
 805     YSTR_IF_SET(statusline);
 806     YSTR_IF_SET(separator);
 807     YSTR_IF_SET(focused_background);
 808     YSTR_IF_SET(focused_statusline);
 809     YSTR_IF_SET(focused_separator);
 810     YSTR_IF_SET(focused_workspace_border);
 811     YSTR_IF_SET(focused_workspace_bg);
 812     YSTR_IF_SET(focused_workspace_text);
 813     YSTR_IF_SET(active_workspace_border);
 814     YSTR_IF_SET(active_workspace_bg);
 815     YSTR_IF_SET(active_workspace_text);
 816     YSTR_IF_SET(inactive_workspace_border);
 817     YSTR_IF_SET(inactive_workspace_bg);
 818     YSTR_IF_SET(inactive_workspace_text);
 819     YSTR_IF_SET(urgent_workspace_border);
 820     YSTR_IF_SET(urgent_workspace_bg);
 821     YSTR_IF_SET(urgent_workspace_text);
 822     YSTR_IF_SET(binding_mode_border);
 823     YSTR_IF_SET(binding_mode_bg);
 824     YSTR_IF_SET(binding_mode_text);
 825     y(map_close);
 826
 827     y(map_close);
 828 #undef YSTR_IF_SET
 829 }
 830
 831 IPC_HANDLER(tree) {
 832     setlocale(LC_NUMERIC, "C");
 833     yajl_gen gen = ygenalloc();
 834     dump_node(gen, croot, false);
 835     setlocale(LC_NUMERIC, "");
 836
 837     const unsigned char *payload;
 838     ylength length;
 839     y(get_buf, &payload, &length);
 840
 841     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_TREE, payload);
 842     y(free);
 843 }
 844
 845 /*
 846  * Formats the reply message for a GET_WORKSPACES request and sends it to the
 847  * client
 848  *
 849  */
 850 IPC_HANDLER(get_workspaces) {
 851     yajl_gen gen = ygenalloc();
 852     y(array_open);
 853
 854     Con *focused_ws = con_get_workspace(focused);
 855
 856     Con *output;
 857     TAILQ_FOREACH(output, &(croot->nodes_head), nodes) {
 858         if (con_is_internal(output))
 859             continue;
 860         Con *ws;
 861         TAILQ_FOREACH(ws, &(output_get_content(output)->nodes_head), nodes) {
 862             assert(ws->type == CT_WORKSPACE);
 863             y(map_open);
 864
 865             ystr("num");
 866             y(integer, ws->num);
 867
 868             ystr("name");
 869             ystr(ws->name);
 870
 871             ystr("visible");
 872             y(bool, workspace_is_visible(ws));
 873
 874             ystr("focused");
 875             y(bool, ws == focused_ws);
 876
 877             ystr("rect");
 878             y(map_open);
 879             ystr("x");
 880             y(integer, ws->rect.x);
 881             ystr("y");
 882             y(integer, ws->rect.y);
 883             ystr("width");
 884             y(integer, ws->rect.width);
 885             ystr("height");
 886             y(integer, ws->rect.height);
 887             y(map_close);
 888
 889             ystr("output");
 890             ystr(output->name);
 891
 892             ystr("urgent");
 893             y(bool, ws->urgent);
 894
 895             y(map_close);
 896         }
 897     }
 898
 899     y(array_close);
 900
 901     const unsigned char *payload;
 902     ylength length;
 903     y(get_buf, &payload, &length);
 904
 905     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_WORKSPACES, payload);
 906     y(free);
 907 }
 908
 909 /*
 910  * Formats the reply message for a GET_OUTPUTS request and sends it to the
 911  * client
 912  *
 913  */
 914 IPC_HANDLER(get_outputs) {
 915     yajl_gen gen = ygenalloc();
 916     y(array_open);
 917
 918     Output *output;
 919     TAILQ_FOREACH(output, &outputs, outputs) {
 920         y(map_open);
 921
 922         ystr("name");
 923         ystr(output_primary_name(output));
 924
 925         ystr("active");
 926         y(bool, output->active);
 927
 928         ystr("primary");
 929         y(bool, output->primary);
 930
 931         ystr("rect");
 932         y(map_open);
 933         ystr("x");
 934         y(integer, output->rect.x);
 935         ystr("y");
 936         y(integer, output->rect.y);
 937         ystr("width");
 938         y(integer, output->rect.width);
 939         ystr("height");
 940         y(integer, output->rect.height);
 941         y(map_close);
 942
 943         ystr("current_workspace");
 944         Con *ws = NULL;
 945         if (output->con && (ws = con_get_fullscreen_con(output->con, CF_OUTPUT)))
 946             ystr(ws->name);
 947         else
 948             y(null);
 949
 950         y(map_close);
 951     }
 952
 953     y(array_close);
 954
 955     const unsigned char *payload;
 956     ylength length;
 957     y(get_buf, &payload, &length);
 958
 959     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_OUTPUTS, payload);
 960     y(free);
 961 }
 962
 963 /*
 964  * Formats the reply message for a GET_MARKS request and sends it to the
 965  * client
 966  *
 967  */
 968 IPC_HANDLER(get_marks) {
 969     yajl_gen gen = ygenalloc();
 970     y(array_open);
 971
 972     Con *con;
 973     TAILQ_FOREACH(con, &all_cons, all_cons) {
 974         mark_t *mark;
 975         TAILQ_FOREACH(mark, &(con->marks_head), marks) {
 976             ystr(mark->name);
 977         }
 978     }
 979
 980     y(array_close);
 981
 982     const unsigned char *payload;
 983     ylength length;
 984     y(get_buf, &payload, &length);
 985
 986     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_MARKS, payload);
 987     y(free);
 988 }
 989
 990 /*
 991  * Returns the version of i3
 992  *
 993  */
 994 IPC_HANDLER(get_version) {
 995     yajl_gen gen = ygenalloc();
 996     y(map_open);
 997
 998     ystr("major");
 999     y(integer, MAJOR_VERSION);
1000
1001     ystr("minor");
1002     y(integer, MINOR_VERSION);
1003
1004     ystr("patch");
1005     y(integer, PATCH_VERSION);
1006
1007     ystr("human_readable");
1008     ystr(i3_version);
1009
1010     ystr("loaded_config_file_name");
1011     ystr(current_configpath);
1012
1013     y(map_close);
1014
1015     const unsigned char *payload;
1016     ylength length;
1017     y(get_buf, &payload, &length);
1018
1019     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_VERSION, payload);
1020     y(free);
1021 }
1022
1023 /*
1024  * Formats the reply message for a GET_BAR_CONFIG request and sends it to the
1025  * client.
1026  *
1027  */
1028 IPC_HANDLER(get_bar_config) {
1029     yajl_gen gen = ygenalloc();
1030
1031     /* If no ID was passed, we return a JSON array with all IDs */
1032     if (message_size == 0) {
1033         y(array_open);
1034         Barconfig *current;
1035         TAILQ_FOREACH(current, &barconfigs, configs) {
1036             ystr(current->id);
1037         }
1038         y(array_close);
1039
1040         const unsigned char *payload;
1041         ylength length;
1042         y(get_buf, &payload, &length);
1043
1044         ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_BAR_CONFIG, payload);
1045         y(free);
1046         return;
1047     }
1048
1049     /* To get a properly terminated buffer, we copy
1050      * message_size bytes out of the buffer */
1051     char *bar_id = NULL;
1052     sasprintf(&bar_id, "%.*s", message_size, message);
1053     LOG("IPC: looking for config for bar ID \"%s\"\n", bar_id);
1054     Barconfig *current, *config = NULL;
1055     TAILQ_FOREACH(current, &barconfigs, configs) {
1056         if (strcmp(current->id, bar_id) != 0)
1057             continue;
1058
1059         config = current;
1060         break;
1061     }
1062     free(bar_id);
1063
1064     if (!config) {
1065         /* If we did not find a config for the given ID, the reply will contain
1066          * a null 'id' field. */
1067         y(map_open);
1068
1069         ystr("id");
1070         y(null);
1071
1072         y(map_close);
1073     } else {
1074         dump_bar_config(gen, config);
1075     }
1076
1077     const unsigned char *payload;
1078     ylength length;
1079     y(get_buf, &payload, &length);
1080
1081     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_BAR_CONFIG, payload);
1082     y(free);
1083 }
1084
1085 /*
1086  * Returns a list of configured binding modes
1087  *
1088  */
1089 IPC_HANDLER(get_binding_modes) {
1090     yajl_gen gen = ygenalloc();
1091
1092     y(array_open);
1093     struct Mode *mode;
1094     SLIST_FOREACH(mode, &modes, modes) {
1095         ystr(mode->name);
1096     }
1097     y(array_close);
1098
1099     const unsigned char *payload;
1100     ylength length;
1101     y(get_buf, &payload, &length);
1102
1103     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_BINDING_MODES, payload);
1104     y(free);
1105 }
1106
1107 /*
1108  * Callback for the YAJL parser (will be called when a string is parsed).
1109  *
1110  */
1111 static int add_subscription(void *extra, const unsigned char *s,
1112                             ylength len) {
1113     ipc_client *client = extra;
1114
1115     DLOG("should add subscription to extra %p, sub %.*s\n", client, (int)len, s);
1116     int event = client->num_events;
1117
1118     client->num_events++;
1119     client->events = srealloc(client->events, client->num_events * sizeof(char *));
1120     /* We copy the string because it is not null-terminated and strndup()
1121      * is missing on some BSD systems */
1122     client->events[event] = scalloc(len + 1, 1);
1123     memcpy(client->events[event], s, len);
1124
1125     DLOG("client is now subscribed to:\n");
1126     for (int i = 0; i < client->num_events; i++) {
1127         DLOG("event %s\n", client->events[i]);
1128     }
1129     DLOG("(done)\n");
1130
1131     return 1;
1132 }
1133
1134 /*
1135  * Subscribes this connection to the event types which were given as a JSON
1136  * serialized array in the payload field of the message.
1137  *
1138  */
1139 IPC_HANDLER(subscribe) {
1140     yajl_handle p;
1141     yajl_status stat;
1142     ipc_client *current, *client = NULL;
1143
1144     /* Search the ipc_client structure for this connection */
1145     TAILQ_FOREACH(current, &all_clients, clients) {
1146         if (current->fd != fd)
1147             continue;
1148
1149         client = current;
1150         break;
1151     }
1152
1153     if (client == NULL) {
1154         ELOG("Could not find ipc_client data structure for fd %d\n", fd);
1155         return;
1156     }
1157
1158     /* Setup the JSON parser */
1159     static yajl_callbacks callbacks = {
1160         .yajl_string = add_subscription,
1161     };
1162
1163     p = yalloc(&callbacks, (void *)client);
1164     stat = yajl_parse(p, (const unsigned char *)message, message_size);
1165     if (stat != yajl_status_ok) {
1166         unsigned char *err;
1167         err = yajl_get_error(p, true, (const unsigned char *)message,
1168                              message_size);
1169         ELOG("YAJL parse error: %s\n", err);
1170         yajl_free_error(p, err);
1171
1172         const char *reply = "{\"success\":false}";
1173         ipc_send_message(fd, strlen(reply), I3_IPC_REPLY_TYPE_SUBSCRIBE, (const uint8_t *)reply);
1174         yajl_free(p);
1175         return;
1176     }
1177     yajl_free(p);
1178     const char *reply = "{\"success\":true}";
1179     ipc_send_message(fd, strlen(reply), I3_IPC_REPLY_TYPE_SUBSCRIBE, (const uint8_t *)reply);
1180
1181     if (client->first_tick_sent) {
1182         return;
1183     }
1184
1185     bool is_tick = false;
1186     for (int i = 0; i < client->num_events; i++) {
1187         if (strcmp(client->events[i], "tick") == 0) {
1188             is_tick = true;
1189             break;
1190         }
1191     }
1192     if (!is_tick) {
1193         return;
1194     }
1195
1196     client->first_tick_sent = true;
1197     const char *payload = "{\"first\":true,\"payload\":\"\"}";
1198     ipc_send_message(client->fd, strlen(payload), I3_IPC_EVENT_TICK, (const uint8_t *)payload);
1199 }
1200
1201 /*
1202  * Returns the raw last loaded i3 configuration file contents.
1203  */
1204 IPC_HANDLER(get_config) {
1205     yajl_gen gen = ygenalloc();
1206
1207     y(map_open);
1208
1209     ystr("config");
1210     ystr(current_config);
1211
1212     y(map_close);
1213
1214     const unsigned char *payload;
1215     ylength length;
1216     y(get_buf, &payload, &length);
1217
1218     ipc_send_message(fd, length, I3_IPC_REPLY_TYPE_CONFIG, payload);
1219     y(free);
1220 }
1221
1222 /*
1223  * Sends the tick event from the message payload to subscribers. Establishes a
1224  * synchronization point in event-related tests.
1225  */
1226 IPC_HANDLER(send_tick) {
1227     yajl_gen gen = ygenalloc();
1228
1229     y(map_open);
1230
1231     ystr("first");
1232     y(bool, false);
1233
1234     ystr("payload");
1235     yajl_gen_string(gen, (unsigned char *)message, message_size);
1236
1237     y(map_close);
1238
1239     const unsigned char *payload;
1240     ylength length;
1241     y(get_buf, &payload, &length);
1242
1243     ipc_send_event("tick", I3_IPC_EVENT_TICK, (const char *)payload);
1244     y(free);
1245
1246     const char *reply = "{\"success\":true}";
1247     ipc_send_message(fd, strlen(reply), I3_IPC_REPLY_TYPE_TICK, (const uint8_t *)reply);
1248     DLOG("Sent tick event\n");
1249 }
1250
1251 struct sync_state {
1252     char *last_key;
1253     uint32_t rnd;
1254     xcb_window_t window;
1255 };
1256
1257 static int _sync_json_key(void *extra, const unsigned char *val, size_t len) {
1258     struct sync_state *state = extra;
1259     FREE(state->last_key);
1260     state->last_key = scalloc(len + 1, 1);
1261     memcpy(state->last_key, val, len);
1262     return 1;
1263 }
1264
1265 static int _sync_json_int(void *extra, long long val) {
1266     struct sync_state *state = extra;
1267     if (strcasecmp(state->last_key, "rnd") == 0) {
1268         state->rnd = val;
1269     } else if (strcasecmp(state->last_key, "window") == 0) {
1270         state->window = (xcb_window_t)val;
1271     }
1272     return 1;
1273 }
1274
1275 IPC_HANDLER(sync) {
1276     yajl_handle p;
1277     yajl_status stat;
1278
1279     /* Setup the JSON parser */
1280     static yajl_callbacks callbacks = {
1281         .yajl_map_key = _sync_json_key,
1282         .yajl_integer = _sync_json_int,
1283     };
1284
1285     struct sync_state state;
1286     memset(&state, '\0', sizeof(struct sync_state));
1287     p = yalloc(&callbacks, (void *)&state);
1288     stat = yajl_parse(p, (const unsigned char *)message, message_size);
1289     FREE(state.last_key);
1290     if (stat != yajl_status_ok) {
1291         unsigned char *err;
1292         err = yajl_get_error(p, true, (const unsigned char *)message,
1293                              message_size);
1294         ELOG("YAJL parse error: %s\n", err);
1295         yajl_free_error(p, err);
1296
1297         const char *reply = "{\"success\":false}";
1298         ipc_send_message(fd, strlen(reply), I3_IPC_REPLY_TYPE_SYNC, (const uint8_t *)reply);
1299         yajl_free(p);
1300         return;
1301     }
1302     yajl_free(p);
1303
1304     DLOG("received IPC sync request (rnd = %d, window = 0x%08x)\n", state.rnd, state.window);
1305     sync_respond(state.window, state.rnd);
1306     const char *reply = "{\"success\":true}";
1307     ipc_send_message(fd, strlen(reply), I3_IPC_REPLY_TYPE_SYNC, (const uint8_t *)reply);
1308 }
1309
1310 /* The index of each callback function corresponds to the numeric
1311  * value of the message type (see include/i3/ipc.h) */
1312 handler_t handlers[12] = {
1313     handle_run_command,
1314     handle_get_workspaces,
1315     handle_subscribe,
1316     handle_get_outputs,
1317     handle_tree,
1318     handle_get_marks,
1319     handle_get_bar_config,
1320     handle_get_version,
1321     handle_get_binding_modes,
1322     handle_get_config,
1323     handle_send_tick,
1324     handle_sync,
1325 };
1326
1327 /*
1328  * Handler for activity on a client connection, receives a message from a
1329  * client.
1330  *
1331  * For now, the maximum message size is 2048. I’m not sure for what the
1332  * IPC interface will be used in the future, thus I’m not implementing a
1333  * mechanism for arbitrarily long messages, as it seems like overkill
1334  * at the moment.
1335  *
1336  */
1337 static void ipc_receive_message(EV_P_ struct ev_io *w, int revents) {
1338     uint32_t message_type;
1339     uint32_t message_length;
1340     uint8_t *message = NULL;
1341
1342     int ret = ipc_recv_message(w->fd, &message_type, &message_length, &message);
1343     /* EOF or other error */
1344     if (ret < 0) {
1345         /* Was this a spurious read? See ev(3) */
1346         if (ret == -1 && errno == EAGAIN) {
1347             FREE(message);
1348             return;
1349         }
1350
1351         /* If not, there was some kind of error. We don’t bother and close the
1352          * connection. Delete the client from the list of clients. */
1353         bool closed = false;
1354         ipc_client *current;
1355         TAILQ_FOREACH(current, &all_clients, clients) {
1356             if (current->fd != w->fd)
1357                 continue;
1358
1359             free_ipc_client(current);
1360             closed = true;
1361             break;
1362         }
1363         if (!closed) {
1364             close(w->fd);
1365         }
1366
1367         ev_io_stop(EV_A_ w);
1368         free(w);
1369         FREE(message);
1370
1371         DLOG("IPC: client disconnected\n");
1372         return;
1373     }
1374
1375     if (message_type >= (sizeof(handlers) / sizeof(handler_t)))
1376         DLOG("Unhandled message type: %d\n", message_type);
1377     else {
1378         handler_t h = handlers[message_type];
1379         h(w->fd, message, 0, message_length, message_type);
1380     }
1381
1382     FREE(message);
1383 }
1384
1385 static void ipc_client_timeout(EV_P_ ev_timer *w, int revents) {
1386     /* No need to be polite and check for writeability, the other callback would
1387      * have been called by now. */
1388     ipc_client *client = (ipc_client *)w->data;
1389
1390     char *cmdline = NULL;
1391 #if defined(__linux__) && defined(SO_PEERCRED)
1392     struct ucred peercred;
1393     socklen_t so_len = sizeof(peercred);
1394     if (getsockopt(client->fd, SOL_SOCKET, SO_PEERCRED, &peercred, &so_len) != 0) {
1395         goto end;
1396     }
1397     char *exepath;
1398     sasprintf(&exepath, "/proc/%d/cmdline", peercred.pid);
1399
1400     int fd = open(exepath, O_RDONLY);
1401     free(exepath);
1402     if (fd == -1) {
1403         goto end;
1404     }
1405     char buf[512] = {'\0'}; /* cut off cmdline for the error message. */
1406     const ssize_t n = read(fd, buf, sizeof(buf));
1407     close(fd);
1408     if (n < 0) {
1409         goto end;
1410     }
1411     for (char *walk = buf; walk < buf + n - 1; walk++) {
1412         if (*walk == '\0') {
1413             *walk = ' ';
1414         }
1415     }
1416     cmdline = buf;
1417
1418     if (cmdline) {
1419         ELOG("client %p with pid %d and cmdline '%s' on fd %d timed out, killing\n", client, peercred.pid, cmdline, client->fd);
1420     }
1421
1422 end:
1423 #endif
1424     if (!cmdline) {
1425         ELOG("client %p on fd %d timed out, killing\n", client, client->fd);
1426     }
1427
1428     free_ipc_client(client);
1429 }
1430
1431 static void ipc_socket_writeable_cb(EV_P_ ev_io *w, int revents) {
1432     DLOG("fd %d writeable\n", w->fd);
1433     ipc_client *client = (ipc_client *)w->data;
1434
1435     /* If this callback is called then there should be a corresponding active
1436      * timer. */
1437     assert(client->timeout != NULL);
1438     ipc_push_pending(client);
1439 }
1440
1441 /*
1442  * Handler for activity on the listening socket, meaning that a new client
1443  * has just connected and we should accept() him. Sets up the event handler
1444  * for activity on the new connection and inserts the file descriptor into
1445  * the list of clients.
1446  *
1447  */
1448 void ipc_new_client(EV_P_ struct ev_io *w, int revents) {
1449     struct sockaddr_un peer;
1450     socklen_t len = sizeof(struct sockaddr_un);
1451     int client;
1452     if ((client = accept(w->fd, (struct sockaddr *)&peer, &len)) < 0) {
1453         if (errno == EINTR)
1454             return;
1455         else
1456             perror("accept()");
1457         return;
1458     }
1459
1460     /* Close this file descriptor on exec() */
1461     (void)fcntl(client, F_SETFD, FD_CLOEXEC);
1462
1463     set_nonblock(client);
1464
1465     struct ev_io *package = scalloc(1, sizeof(struct ev_io));
1466     ev_io_init(package, ipc_receive_message, client, EV_READ);
1467     ev_io_start(EV_A_ package);
1468
1469     ipc_client *new = scalloc(1, sizeof(ipc_client));
1470
1471     package = scalloc(1, sizeof(struct ev_io));
1472     package->data = new;
1473     ev_io_init(package, ipc_socket_writeable_cb, client, EV_WRITE);
1474
1475     DLOG("IPC: new client connected on fd %d\n", w->fd);
1476
1477     new->fd = client;
1478     new->callback = package;
1479
1480     TAILQ_INSERT_TAIL(&all_clients, new, clients);
1481 }
1482
1483 /*
1484  * Creates the UNIX domain socket at the given path, sets it to non-blocking
1485  * mode, bind()s and listen()s on it.
1486  *
1487  */
1488 int ipc_create_socket(const char *filename) {
1489     int sockfd;
1490
1491     FREE(current_socketpath);
1492
1493     char *resolved = resolve_tilde(filename);
1494     DLOG("Creating IPC-socket at %s\n", resolved);
1495     char *copy = sstrdup(resolved);
1496     const char *dir = dirname(copy);
1497     if (!path_exists(dir))
1498         mkdirp(dir, DEFAULT_DIR_MODE);
1499     free(copy);
1500
1501     /* Unlink the unix domain socket before */
1502     unlink(resolved);
1503
1504     if ((sockfd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0) {
1505         perror("socket()");
1506         free(resolved);
1507         return -1;
1508     }
1509
1510     (void)fcntl(sockfd, F_SETFD, FD_CLOEXEC);
1511
1512     struct sockaddr_un addr;
1513     memset(&addr, 0, sizeof(struct sockaddr_un));
1514     addr.sun_family = AF_LOCAL;
1515     strncpy(addr.sun_path, resolved, sizeof(addr.sun_path) - 1);
1516     if (bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0) {
1517         perror("bind()");
1518         free(resolved);
1519         return -1;
1520     }
1521
1522     set_nonblock(sockfd);
1523
1524     if (listen(sockfd, 5) < 0) {
1525         perror("listen()");
1526         free(resolved);
1527         return -1;
1528     }
1529
1530     current_socketpath = resolved;
1531     return sockfd;
1532 }
1533
1534 /*
1535  * Generates a json workspace event. Returns a dynamically allocated yajl
1536  * generator. Free with yajl_gen_free().
1537  */
1538 yajl_gen ipc_marshal_workspace_event(const char *change, Con *current, Con *old) {
1539     setlocale(LC_NUMERIC, "C");
1540     yajl_gen gen = ygenalloc();
1541
1542     y(map_open);
1543
1544     ystr("change");
1545     ystr(change);
1546
1547     ystr("current");
1548     if (current == NULL)
1549         y(null);
1550     else
1551         dump_node(gen, current, false);
1552
1553     ystr("old");
1554     if (old == NULL)
1555         y(null);
1556     else
1557         dump_node(gen, old, false);
1558
1559     y(map_close);
1560
1561     setlocale(LC_NUMERIC, "");
1562
1563     return gen;
1564 }
1565
1566 /*
1567  * For the workspace events we send, along with the usual "change" field, also
1568  * the workspace container in "current". For focus events, we send the
1569  * previously focused workspace in "old".
1570  */
1571 void ipc_send_workspace_event(const char *change, Con *current, Con *old) {
1572     yajl_gen gen = ipc_marshal_workspace_event(change, current, old);
1573
1574     const unsigned char *payload;
1575     ylength length;
1576     y(get_buf, &payload, &length);
1577
1578     ipc_send_event("workspace", I3_IPC_EVENT_WORKSPACE, (const char *)payload);
1579
1580     y(free);
1581 }
1582
1583 /*
1584  * For the window events we send, along the usual "change" field,
1585  * also the window container, in "container".
1586  */
1587 void ipc_send_window_event(const char *property, Con *con) {
1588     DLOG("Issue IPC window %s event (con = %p, window = 0x%08x)\n",
1589          property, con, (con->window ? con->window->id : XCB_WINDOW_NONE));
1590
1591     setlocale(LC_NUMERIC, "C");
1592     yajl_gen gen = ygenalloc();
1593
1594     y(map_open);
1595
1596     ystr("change");
1597     ystr(property);
1598
1599     ystr("container");
1600     dump_node(gen, con, false);
1601
1602     y(map_close);
1603
1604     const unsigned char *payload;
1605     ylength length;
1606     y(get_buf, &payload, &length);
1607
1608     ipc_send_event("window", I3_IPC_EVENT_WINDOW, (const char *)payload);
1609     y(free);
1610     setlocale(LC_NUMERIC, "");
1611 }
1612
1613 /*
1614  * For the barconfig update events, we send the serialized barconfig.
1615  */
1616 void ipc_send_barconfig_update_event(Barconfig *barconfig) {
1617     DLOG("Issue barconfig_update event for id = %s\n", barconfig->id);
1618     setlocale(LC_NUMERIC, "C");
1619     yajl_gen gen = ygenalloc();
1620
1621     dump_bar_config(gen, barconfig);
1622
1623     const unsigned char *payload;
1624     ylength length;
1625     y(get_buf, &payload, &length);
1626
1627     ipc_send_event("barconfig_update", I3_IPC_EVENT_BARCONFIG_UPDATE, (const char *)payload);
1628     y(free);
1629     setlocale(LC_NUMERIC, "");
1630 }
1631
1632 /*
1633  * For the binding events, we send the serialized binding struct.
1634  */
1635 void ipc_send_binding_event(const char *event_type, Binding *bind) {
1636     DLOG("Issue IPC binding %s event (sym = %s, code = %d)\n", event_type, bind->symbol, bind->keycode);
1637
1638     setlocale(LC_NUMERIC, "C");
1639
1640     yajl_gen gen = ygenalloc();
1641
1642     y(map_open);
1643
1644     ystr("change");
1645     ystr(event_type);
1646
1647     ystr("binding");
1648     dump_binding(gen, bind);
1649
1650     y(map_close);
1651
1652     const unsigned char *payload;
1653     ylength length;
1654     y(get_buf, &payload, &length);
1655
1656     ipc_send_event("binding", I3_IPC_EVENT_BINDING, (const char *)payload);
1657
1658     y(free);
1659     setlocale(LC_NUMERIC, "");
1660 }