19#include <sys/socket.h>
23#include <yajl/yajl_gen.h>
24#include <yajl/yajl_parse.h>
33static ev_tstamp kill_timeout = 10.0;
69 struct ev_timer *timeout =
scalloc(1,
sizeof(
struct ev_timer));
71 timeout->data = client;
73 ev_set_priority(timeout, EV_MINPRI);
75 }
else if (result > 0) {
79 ev_timer_set(client->
timeout, kill_timeout, 0.0);
99 const i3_ipc_header_t
header = {
100 .magic = {
'i',
'3',
'-',
'i',
'p',
'c'},
102 .type = message_type};
103 const size_t header_size =
sizeof(i3_ipc_header_t);
104 const size_t message_size = header_size + size;
118 if (client->
fd != exempt_fd) {
119 DLOG(
"Disconnecting client on fd %d\n", client->
fd);
134 for (
int i = 0; i < client->
num_events; i++) {
147void ipc_send_event(
const char *event, uint32_t message_type,
const char *payload) {
150 for (
int i = 0; i < current->
num_events; i++) {
151 if (strcasecmp(current->
events[i], event) == 0) {
176 const unsigned char *payload;
179 y(get_buf, &payload, &length);
180 ipc_send_event(
"shutdown", I3_IPC_EVENT_SHUTDOWN, (
const char *)payload);
198 if (current->
fd != exempt_fd) {
199 shutdown(current->
fd, SHUT_RDWR);
212 char *command =
sstrndup((
const char *)message, message_size);
213 LOG(
"IPC: received: *%.4000s*\n", command);
214 yajl_gen gen = yajl_gen_alloc(NULL);
224 const unsigned char *reply;
226 yajl_gen_get_buf(gen, &reply, &length);
229 (
const uint8_t *)reply);
238 y(integer, (int32_t)r.
x);
240 y(integer, (int32_t)r.
y);
257 y(integer, gaps.
top);
260 y(integer, gaps.
top);
266 y(integer, gaps.
left);
272 for (
int i = 0; i < 20; i++) {
275 case XCB_KEY_BUT_MASK_SHIFT:
278 case XCB_KEY_BUT_MASK_LOCK:
281 case XCB_KEY_BUT_MASK_CONTROL:
284 case XCB_KEY_BUT_MASK_MOD_1:
287 case XCB_KEY_BUT_MASK_MOD_2:
290 case XCB_KEY_BUT_MASK_MOD_3:
293 case XCB_KEY_BUT_MASK_MOD_4:
296 case XCB_KEY_BUT_MASK_MOD_5:
299 case XCB_KEY_BUT_MASK_BUTTON_1:
302 case XCB_KEY_BUT_MASK_BUTTON_2:
305 case XCB_KEY_BUT_MASK_BUTTON_3:
308 case XCB_KEY_BUT_MASK_BUTTON_4:
311 case XCB_KEY_BUT_MASK_BUTTON_5:
354 ystr(
"event_state_mask");
363 y(integer, (uintptr_t)con);
376 case CT_FLOATING_CON:
377 ystr(
"floating_con");
398 ystr(
"scratchpad_state");
400 case SCRATCHPAD_NONE:
403 case SCRATCHPAD_FRESH:
406 case SCRATCHPAD_CHANGED:
431 if (con->
type != CT_ROOT && con->
type != CT_OUTPUT) {
439 DLOG(
"About to dump layout=default, this is a bug in the code.\n");
462 ystr(
"workspace_layout");
474 DLOG(
"About to dump workspace_layout=%d (none of default/stacked/tabbed), this is a bug.\n", con->
workspace_layout);
479 ystr(
"last_split_layout");
502 ystr(
"current_border_width");
510 dump_rect(gen,
"deco_rect", simulated_deco_rect);
521 else if (con->
name != NULL)
527 ystr(
"title_format");
531 ystr(
"window_icon_padding");
534 if (con->
type == CT_WORKSPACE) {
536 y(integer, con->
num);
564 ystr(
"dropdown_menu");
570 ystr(
"notification");
577 if (con->
window && !inplace_restart) {
581 ystr(
"window_properties");
584#define DUMP_PROPERTY(key, prop_name) \
586 if (con->window->prop_name != NULL) { \
588 ystr(con->window->prop_name); \
602 ystr(
"transient_for");
614 if (con->
type != CT_DOCKAREA || !inplace_restart) {
621 ystr(
"floating_nodes");
623 TAILQ_FOREACH (node, &(con->floating_head), floating_windows) {
631 y(integer, (uintptr_t)node);
635 ystr(
"fullscreen_mode");
643 case FLOATING_AUTO_OFF:
646 case FLOATING_AUTO_ON:
649 case FLOATING_USER_OFF:
652 case FLOATING_USER_ON:
666 if (match->
dock != M_DONTCHECK) {
668 y(integer, match->
dock);
669 ystr(
"insert_where");
673#define DUMP_REGEX(re_name) \
675 if (match->re_name != NULL) { \
677 ystr(match->re_name->pattern); \
691 if (inplace_restart) {
692 if (con->
window != NULL) {
696 ystr(
"restart_mode");
703 if (inplace_restart && con->
window != NULL) {
709 ystr(
"previous_workspace_name");
732 y(
bool, current->
release == B_UPON_KEYRELEASE);
742 if (strcasecmp(name,
"primary") == 0 || strcasecmp(name,
"nonprimary") == 0) {
755 if (
config->num_outputs > 0) {
758 for (
int c = 0; c <
config->num_outputs; c++) {
769 ystr(
"tray_outputs");
780#define YSTR_IF_SET(name) \
782 if (config->name) { \
784 ystr(config->name); \
788 ystr(
"tray_padding");
789 y(integer,
config->tray_padding);
807 ystr(
"hidden_state");
808 switch (
config->hidden_state) {
824 if (
config->position == P_BOTTOM)
835 y(integer,
config->bar_height);
840 if (
config->separator_symbol) {
841 ystr(
"separator_symbol");
845 ystr(
"workspace_buttons");
846 y(
bool, !
config->hide_workspace_buttons);
848 ystr(
"workspace_min_width");
849 y(integer,
config->workspace_min_width);
851 ystr(
"strip_workspace_numbers");
852 y(
bool,
config->strip_workspace_numbers);
854 ystr(
"strip_workspace_name");
855 y(
bool,
config->strip_workspace_name);
857 ystr(
"binding_mode_indicator");
858 y(
bool, !
config->hide_binding_mode_indicator);
864#define YSTR_IF_SET(name) \
866 if (config->colors.name) { \
868 ystr(config->colors.name); \
902 setlocale(LC_NUMERIC,
"C");
905 setlocale(LC_NUMERIC,
"");
907 const unsigned char *payload;
909 y(get_buf, &payload, &length);
932 assert(ws->
type == CT_WORKSPACE);
936 y(integer, (uintptr_t)ws);
948 y(
bool, ws == focused_ws);
953 y(integer, ws->rect.x);
955 y(integer, ws->rect.y);
957 y(integer, ws->rect.width);
959 y(integer, ws->rect.height);
974 const unsigned char *payload;
976 y(get_buf, &payload, &length);
1011 y(integer,
output->rect.width);
1013 y(integer,
output->rect.height);
1016 ystr(
"current_workspace");
1028 const unsigned char *payload;
1030 y(get_buf, &payload, &length);
1055 const unsigned char *payload;
1057 y(get_buf, &payload, &length);
1072 y(integer, MAJOR_VERSION);
1075 y(integer, MINOR_VERSION);
1078 y(integer, PATCH_VERSION);
1080 ystr(
"human_readable");
1083 ystr(
"loaded_config_file_name");
1086 ystr(
"included_config_file_names");
1099 const unsigned char *payload;
1101 y(get_buf, &payload, &length);
1116 if (message_size == 0) {
1124 const unsigned char *payload;
1126 y(get_buf, &payload, &length);
1135 char *bar_id = NULL;
1136 sasprintf(&bar_id,
"%.*s", message_size, message);
1137 LOG(
"IPC: looking for config for bar ID \"%s\"\n", bar_id);
1140 if (strcmp(current->
id, bar_id) != 0)
1161 const unsigned char *payload;
1163 y(get_buf, &payload, &length);
1183 const unsigned char *payload;
1185 y(get_buf, &payload, &length);
1199 DLOG(
"should add subscription to extra %p, sub %.*s\n", client, (
int)len, s);
1207 memcpy(client->
events[event], s, len);
1209 DLOG(
"client is now subscribed to:\n");
1210 for (
int i = 0; i < client->
num_events; i++) {
1228 static yajl_callbacks callbacks = {
1232 p =
yalloc(&callbacks, (
void *)client);
1233 stat = yajl_parse(p, (
const unsigned char *)message, message_size);
1234 if (stat != yajl_status_ok) {
1236 err = yajl_get_error(p,
true, (
const unsigned char *)message,
1238 ELOG(
"YAJL parse error: %s\n", err);
1239 yajl_free_error(p, err);
1241 const char *reply =
"{\"success\":false}";
1247 const char *reply =
"{\"success\":true}";
1250 if (client->first_tick_sent) {
1254 bool is_tick =
false;
1255 for (
int i = 0; i < client->num_events; i++) {
1256 if (strcmp(client->events[i],
"tick") == 0) {
1265 client->first_tick_sent =
true;
1266 const char *payload =
"{\"first\":true,\"payload\":\"\"}";
1282 ystr(
"included_configs");
1288 ystr(
"raw_contents");
1290 ystr(
"variable_replaced_contents");
1298 const unsigned char *payload;
1300 y(get_buf, &payload, &length);
1319 yajl_gen_string(gen, (
unsigned char *)message, message_size);
1323 const unsigned char *payload;
1325 y(get_buf, &payload, &length);
1327 ipc_send_event(
"tick", I3_IPC_EVENT_TICK, (
const char *)payload);
1330 const char *reply =
"{\"success\":true}";
1332 DLOG(
"Sent tick event\n");
1345 memcpy(
state->last_key, val, len);
1351 if (strcasecmp(
state->last_key,
"rnd") == 0) {
1353 }
else if (strcasecmp(
state->last_key,
"window") == 0) {
1354 state->window = (xcb_window_t)val;
1364 static yajl_callbacks callbacks = {
1372 stat = yajl_parse(p, (
const unsigned char *)message, message_size);
1374 if (stat != yajl_status_ok) {
1376 err = yajl_get_error(p,
true, (
const unsigned char *)message,
1378 ELOG(
"YAJL parse error: %s\n", err);
1379 yajl_free_error(p, err);
1381 const char *reply =
"{\"success\":false}";
1388 DLOG(
"received IPC sync request (rnd = %d, window = 0x%08x)\n",
state.rnd,
state.window);
1390 const char *reply =
"{\"success\":true}";
1404 const unsigned char *payload;
1406 y(get_buf, &payload, &length);
1416 handle_get_workspaces,
1421 handle_get_bar_config,
1423 handle_get_binding_modes,
1427 handle_get_binding_state,
1441 uint32_t message_type;
1442 uint32_t message_length;
1443 uint8_t *message = NULL;
1445 assert(client->
fd == w->fd);
1447 int ret =
ipc_recv_message(w->fd, &message_type, &message_length, &message);
1451 if (ret == -1 && errno == EAGAIN) {
1464 DLOG(
"Unhandled message type: %d\n", message_type);
1467 h(client, message, 0, message_length, message_type);
1478 char *cmdline = NULL;
1479#if defined(__linux__) && defined(SO_PEERCRED)
1480 struct ucred peercred;
1481 socklen_t so_len =
sizeof(peercred);
1482 if (getsockopt(client->
fd, SOL_SOCKET, SO_PEERCRED, &peercred, &so_len) != 0) {
1486 sasprintf(&exepath,
"/proc/%d/cmdline", peercred.pid);
1488 int fd = open(exepath, O_RDONLY);
1493 char buf[512] = {
'\0'};
1494 const ssize_t n = read(fd, buf,
sizeof(buf));
1499 for (
char *walk = buf; walk < buf + n - 1; walk++) {
1500 if (*walk ==
'\0') {
1507 ELOG(
"client %p with pid %d and cmdline '%s' on fd %d timed out, killing\n", client, peercred.pid, cmdline, client->
fd);
1513 ELOG(
"client %p on fd %d timed out, killing\n", client, client->
fd);
1520 DLOG(
"fd %d writeable\n", w->fd);
1525 assert(client->
timeout != NULL);
1537 struct sockaddr_un peer;
1538 socklen_t len =
sizeof(
struct sockaddr_un);
1540 if ((fd = accept(w->fd, (
struct sockaddr *)&peer, &len)) < 0) {
1541 if (errno != EINTR) {
1548 (void)fcntl(fd, F_SETFD, FD_CLOEXEC);
1576 DLOG(
"IPC: new client connected on fd %d\n", fd);
1586 setlocale(LC_NUMERIC,
"C");
1595 if (current == NULL)
1608 setlocale(LC_NUMERIC,
"");
1621 const unsigned char *payload;
1623 y(get_buf, &payload, &length);
1625 ipc_send_event(
"workspace", I3_IPC_EVENT_WORKSPACE, (
const char *)payload);
1635 DLOG(
"Issue IPC window %s event (con = %p, window = 0x%08x)\n",
1636 property, con, (con->
window ? con->
window->
id : XCB_WINDOW_NONE));
1638 setlocale(LC_NUMERIC,
"C");
1651 const unsigned char *payload;
1653 y(get_buf, &payload, &length);
1655 ipc_send_event(
"window", I3_IPC_EVENT_WINDOW, (
const char *)payload);
1657 setlocale(LC_NUMERIC,
"");
1664 DLOG(
"Issue barconfig_update event for id = %s\n", barconfig->
id);
1665 setlocale(LC_NUMERIC,
"C");
1670 const unsigned char *payload;
1672 y(get_buf, &payload, &length);
1674 ipc_send_event(
"barconfig_update", I3_IPC_EVENT_BARCONFIG_UPDATE, (
const char *)payload);
1676 setlocale(LC_NUMERIC,
"");
1683 DLOG(
"Issue IPC binding %s event (sym = %s, code = %d)\n", event_type, bind->
symbol, bind->
keycode);
1685 setlocale(LC_NUMERIC,
"C");
1695 if (modename == NULL) {
1706 const unsigned char *payload;
1708 y(get_buf, &payload, &length);
1710 ipc_send_event(
"binding", I3_IPC_EVENT_BINDING, (
const char *)payload);
1713 setlocale(LC_NUMERIC,
"");
1720 DLOG(
"ipc_confirm_restart(fd %d)\n", client->
fd);
1721 static const char *reply =
"[{\"success\":true}]";
1723 client, strlen(reply), I3_IPC_REPLY_TYPE_COMMAND,
1724 (
const uint8_t *)reply);
CommandResult * parse_command(const char *input, yajl_gen gen, ipc_client *client)
Parses and executes the given command.
void command_result_free(CommandResult *result)
Frees a CommandResult.
Con * con_get_fullscreen_con(Con *con, fullscreen_mode_t fullscreen_mode)
Returns the first fullscreen node below this node.
orientation_t con_orientation(Con *con)
Returns the orientation of the given container (for stacked containers, vertical orientation is used ...
Con * con_get_workspace(Con *con)
Gets the workspace container this node is on.
bool con_is_split(Con *con)
Returns true if a container should be considered split.
bool con_is_internal(Con *con)
Returns true if the container is internal, such as __i3_scratch.
bool con_draw_decoration_into_frame(Con *con)
Returns whether the window decoration (title bar) should be drawn into the X11 frame window of this c...
Con * con_get_output(Con *con)
Gets the output container (first container with CT_OUTPUT in hierarchy) this node is on.
struct includedfiles_head included_files
struct barconfig_head barconfigs
char * current_configpath
struct pending_marks * marks
char * output_primary_name(Output *output)
Retrieves the primary name of an output.
Con * output_get_content(Con *output)
Returns the output container below the given output container.
Output * get_output_by_name(const char *name, const bool require_active)
Returns the output with the given name or NULL.
struct outputs_head outputs
void sync_respond(xcb_window_t window, uint32_t rnd)
struct all_cons_head all_cons
void tree_render(void)
Renders the tree, that is rendering all outputs using render_con() and pushing the changes to X11 usi...
const char * i3_version
Git commit identifier, from version.c.
bool workspace_is_visible(Con *ws)
Returns true if the workspace is currently visible.
char * previous_workspace_name
Stores a copy of the name of the last used workspace for the workspace back-and-forth switching.
static void free_ipc_client(ipc_client *client, int exempt_fd)
static int _sync_json_int(void *extra, long long val)
static void dump_event_state_mask(yajl_gen gen, Binding *bind)
static void ipc_send_shutdown_event(shutdown_reason_t reason)
static void dump_bar_config(yajl_gen gen, Barconfig *config)
#define DUMP_REGEX(re_name)
static void dump_rect(yajl_gen gen, const char *name, Rect r)
static int _sync_json_key(void *extra, const unsigned char *val, size_t len)
static void ipc_client_timeout(EV_P_ ev_timer *w, int revents)
static void dump_binding(yajl_gen gen, Binding *bind)
void ipc_confirm_restart(ipc_client *client)
Sends a restart reply to the IPC client on the specified fd.
ipc_client * ipc_new_client_on_fd(EV_P_ int fd)
ipc_new_client_on_fd() only sets up the event handler for activity on the new connection and inserts ...
char * current_socketpath
void ipc_send_binding_event(const char *event_type, Binding *bind, const char *modename)
For the binding events, we send the serialized binding struct.
static void dump_bar_bindings(yajl_gen gen, Barconfig *config)
static void ipc_receive_message(EV_P_ struct ev_io *w, int revents)
void ipc_shutdown(shutdown_reason_t reason, int exempt_fd)
Calls shutdown() on each socket and closes it.
void dump_node(yajl_gen gen, struct Con *con, bool inplace_restart)
static void ipc_send_client_message(ipc_client *client, size_t size, const uint32_t message_type, const uint8_t *payload)
#define YSTR_IF_SET(name)
void ipc_send_workspace_event(const char *change, Con *current, Con *old)
For the workspace events we send, along with the usual "change" field, also the workspace container i...
static void dump_gaps(yajl_gen gen, const char *name, gaps_t gaps)
void ipc_new_client(EV_P_ struct ev_io *w, int revents)
Handler for activity on the listening socket, meaning that a new client has just connected and we sho...
void ipc_send_barconfig_update_event(Barconfig *barconfig)
For the barconfig update events, we send the serialized barconfig.
void ipc_send_event(const char *event, uint32_t message_type, const char *payload)
Sends the specified event to all IPC clients which are currently connected and subscribed to this kin...
yajl_gen ipc_marshal_workspace_event(const char *change, Con *current, Con *old)
Generates a json workspace event.
static int add_subscription(void *extra, const unsigned char *s, ylength len)
static void ipc_socket_writeable_cb(EV_P_ ev_io *w, int revents)
static char * canonicalize_output_name(char *name)
void ipc_send_window_event(const char *property, Con *con)
For the window events we send, along the usual "change" field, also the window container,...
static void ipc_push_pending(ipc_client *client)
#define DUMP_PROPERTY(key, prop_name)
static i3_shmlog_header * header
const char * current_binding_mode
struct ev_loop * main_loop
struct bindings_head * bindings
ssize_t writeall_nonblock(int fd, const void *buf, size_t count)
Like writeall, but instead of retrying upon EAGAIN (returned when a write would block),...
void set_nonblock(int sockfd)
Puts the given socket file descriptor into non-blocking mode or dies if setting O_NONBLOCK failed.
const char * i3string_as_utf8(i3String *str)
Returns the UTF-8 encoded version of the i3String.
int ipc_recv_message(int sockfd, uint32_t *message_type, uint32_t *reply_length, uint8_t **reply)
Reads a message from the given socket file descriptor and stores its length (reply_length) as well as...
void * scalloc(size_t num, size_t size)
Safe-wrapper around calloc which exits if malloc returns NULL (meaning that there is no more memory a...
int sasprintf(char **strp, const char *fmt,...)
Safe-wrapper around asprintf which exits if it returns -1 (meaning that there is no more memory avail...
char * sstrndup(const char *str, size_t size)
Safe-wrapper around strndup which exits if strndup returns NULL (meaning that there is no more memory...
void * srealloc(void *ptr, size_t size)
Safe-wrapper around realloc which exits if realloc returns NULL (meaning that there is no more memory...
#define SLIST_FOREACH(var, head, field)
#define TAILQ_FOREACH(var, head, field)
#define TAILQ_HEAD(name, type)
#define TAILQ_INSERT_TAIL(head, elm, field)
#define TAILQ_FIRST(head)
#define TAILQ_REMOVE(head, elm, field)
#define TAILQ_HEAD_INITIALIZER(head)
#define TAILQ_EMPTY(head)
#define yalloc(callbacks, client)
#define IPC_HANDLER(name)
void ipc_set_kill_timeout(ev_tstamp new)
Set the maximum duration that we allow for a connection with an unwriteable socket.
void(* handler_t)(ipc_client *, uint8_t *, int, uint32_t, uint32_t)
shutdown_reason_t
Calls to ipc_shutdown() should provide a reason for the shutdown.
@ SHUTDOWN_REASON_RESTART
A struct that contains useful information about the result of a command as a whole (e....
List entry struct for an included file.
char * variable_replaced_contents
The configuration file can contain multiple sets of bindings.
Holds the status bar configuration (i3bar).
char * id
Automatically generated ID for this bar config.
Defines a mouse command to be executed instead of the default behavior when clicking on the non-statu...
bool release
If true, the command will be executed after the button is released.
int input_code
The button to be used (e.g., 1 for "button1").
char * command
The command which is to be executed for this button.
Stores a rectangle, for example the size of a window, the child window etc.
Holds a keybinding, consisting of a keycode combined with modifiers and the command which is executed...
char * command
Command, like in command mode.
uint32_t keycode
Keycode to bind.
char * symbol
Symbol the user specified in configfile, if any.
i3_event_state_mask_t event_state_mask
Bitmask which is applied against event->state for KeyPress and KeyRelease events to determine whether...
An Output is a physical output on your graphics driver.
i3String * name
The name of the window.
xcb_atom_t window_type
The _NET_WM_WINDOW_TYPE for this window.
xcb_window_t transient_for
A "match" is a data structure which acts like a mask or expression to match certain windows or not.
enum Match::@15 insert_where
A 'Con' represents everything from the X11 root window down to a single X11 window.
enum Con::@20 scratchpad_state
layout_t workspace_layout
gaps_t gaps
Only applicable for containers of type CT_WORKSPACE.
int num
the workspace number, if this Con is of type CT_WORKSPACE and the workspace is not a named workspace ...
int window_icon_padding
Whether the window icon should be displayed, and with what padding.
char * title_format
The format with which the window's name should be displayed.
border_style_t border_style
struct Rect geometry
the geometry this window requested when getting mapped
enum Con::@19 floating
floating? (= not in tiling layout) This cannot be simply a bool because we want to keep track of whet...
fullscreen_mode_t fullscreen_mode
struct ev_io * read_callback
struct ev_timer * timeout
struct ev_io * write_callback