diff options
| -rw-r--r-- | IPCClient.c | 66 | ||||
| -rw-r--r-- | IPCClient.h | 61 | ||||
| -rw-r--r-- | Makefile | 10 | ||||
| -rw-r--r-- | config.def.h | 29 | ||||
| -rw-r--r-- | config.mk | 8 | ||||
| -rw-r--r-- | dwm-msg.c | 548 | ||||
| -rw-r--r-- | dwm-msg.o | bin | 0 -> 14792 bytes | |||
| -rw-r--r-- | dwm.c | 150 | ||||
| -rw-r--r-- | ipc.c | 1202 | ||||
| -rw-r--r-- | ipc.h | 320 | ||||
| -rw-r--r-- | patches/dwm-ipc-20201106-f04cac6.diff | 3246 | ||||
| -rw-r--r-- | util.c | 135 | ||||
| -rw-r--r-- | util.h | 10 | ||||
| -rw-r--r-- | yajl_dumps.c | 351 | ||||
| -rw-r--r-- | yajl_dumps.h | 65 |
15 files changed, 6182 insertions, 19 deletions
diff --git a/IPCClient.c b/IPCClient.c new file mode 100644 index 0000000..0d3eefb --- /dev/null +++ b/IPCClient.c @@ -0,0 +1,66 @@ +#include "IPCClient.h" + +#include <string.h> +#include <sys/epoll.h> + +#include "util.h" + +IPCClient * +ipc_client_new(int fd) +{ + IPCClient *c = (IPCClient *)malloc(sizeof(IPCClient)); + + if (c == NULL) return NULL; + + // Initialize struct + memset(&c->event, 0, sizeof(struct epoll_event)); + + c->buffer_size = 0; + c->buffer = NULL; + c->fd = fd; + c->event.data.fd = fd; + c->next = NULL; + c->prev = NULL; + c->subscriptions = 0; + + return c; +} + +void +ipc_list_add_client(IPCClientList *list, IPCClient *nc) +{ + DEBUG("Adding client with fd %d to list\n", nc->fd); + + if (*list == NULL) { + // List is empty, point list at first client + *list = nc; + } else { + IPCClient *c; + // Go to last client in list + for (c = *list; c && c->next; c = c->next) + ; + c->next = nc; + nc->prev = c; + } +} + +void +ipc_list_remove_client(IPCClientList *list, IPCClient *c) +{ + IPCClient *cprev = c->prev; + IPCClient *cnext = c->next; + + if (cprev != NULL) cprev->next = c->next; + if (cnext != NULL) cnext->prev = c->prev; + if (c == *list) *list = c->next; +} + +IPCClient * +ipc_list_get_client(IPCClientList list, int fd) +{ + for (IPCClient *c = list; c; c = c->next) { + if (c->fd == fd) return c; + } + + return NULL; +} diff --git a/IPCClient.h b/IPCClient.h new file mode 100644 index 0000000..307dfba --- /dev/null +++ b/IPCClient.h @@ -0,0 +1,61 @@ +#ifndef IPC_CLIENT_H_ +#define IPC_CLIENT_H_ + +#include <stdio.h> +#include <stdlib.h> +#include <sys/epoll.h> + +typedef struct IPCClient IPCClient; +/** + * This structure contains the details of an IPC Client and pointers for a + * linked list + */ +struct IPCClient { + int fd; + int subscriptions; + + char *buffer; + uint32_t buffer_size; + + struct epoll_event event; + IPCClient *next; + IPCClient *prev; +}; + +typedef IPCClient *IPCClientList; + +/** + * Allocate memory for new IPCClient with the specified file descriptor and + * initialize struct. + * + * @param fd File descriptor of IPC client + * + * @return Address to allocated IPCClient struct + */ +IPCClient *ipc_client_new(int fd); + +/** + * Add an IPC Client to the specified list + * + * @param list Address of the list to add the client to + * @param nc Address of the IPCClient + */ +void ipc_list_add_client(IPCClientList *list, IPCClient *nc); + +/** + * Remove an IPCClient from the specified list + * + * @param list Address of the list to remove the client from + * @param c Address of the IPCClient + */ +void ipc_list_remove_client(IPCClientList *list, IPCClient *c); + +/** + * Get an IPCClient from the specified IPCClient list + * + * @param list List to remove the client from + * @param fd File descriptor of the IPCClient + */ +IPCClient *ipc_list_get_client(IPCClientList list, int fd); + +#endif // IPC_CLIENT_H_ @@ -6,7 +6,7 @@ include config.mk SRC = drw.c dwm.c util.c OBJ = ${SRC:.c=.o} -all: dwm +all: dwm dwm-msg .c.o: ${CC} -c ${CFLAGS} $< @@ -19,8 +19,11 @@ config.h: dwm: ${OBJ} ${CC} -o $@ ${OBJ} ${LDFLAGS} +dwm-msg: dwm-msg.o + ${CC} -o $@ $< ${LDFLAGS} + clean: - rm -f dwm ${OBJ} dwm-${VERSION}.tar.gz config.h + rm -f dwm dwm-msg ${OBJ} dwm-${VERSION}.tar.gz config.h patch: rm -f *.orig *.rej @@ -35,8 +38,9 @@ dist: clean install: all mkdir -p ${DESTDIR}${PREFIX}/bin - cp -f dwm ${DESTDIR}${PREFIX}/bin + cp -f dwm dwm-msg ${DESTDIR}${PREFIX}/bin chmod 755 ${DESTDIR}${PREFIX}/bin/dwm + chmod 755 ${DESTDIR}${PREFIX}/bin/dwm-msg mkdir -p ${DESTDIR}${MANPREFIX}/man1 sed "s/VERSION/${VERSION}/g" < dwm.1 > ${DESTDIR}${MANPREFIX}/man1/dwm.1 chmod 644 ${DESTDIR}${MANPREFIX}/man1/dwm.1 diff --git a/config.def.h b/config.def.h index e8ab761..d9c3965 100644 --- a/config.def.h +++ b/config.def.h @@ -80,12 +80,6 @@ static char *colors[][3] = { komputer([SchemeSel] = { selfgcolor, selbgcolor, selbordercolor },) }; -// static const unsigned int alphas[][3] = { -// /* fg bg border */ -// [SchemeNorm] = { OPAQUE, baralpha, borderalpha }, -// [SchemeSel] = { OPAQUE, baralpha, borderalpha }, -// }; - /* tagging */ static const char *tags[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9" }; @@ -320,3 +314,26 @@ static const Button buttons[] = { { ClkTagBar, MODKEY, Button1, tag, {0} }, { ClkTagBar, MODKEY, Button3, toggletag, {0} }, }; + +static const char *ipcsockpath = "/tmp/dwm.sock"; +static IPCCommand ipccommands[] = { + IPCCOMMAND( focusmon, 1, {ARG_TYPE_SINT} ), + IPCCOMMAND( focusstack, 1, {ARG_TYPE_SINT} ), + IPCCOMMAND( incnmaster, 1, {ARG_TYPE_SINT} ), + IPCCOMMAND( killclient, 1, {ARG_TYPE_SINT} ), + IPCCOMMAND( movecenter, 1, {ARG_TYPE_NONE} ), + IPCCOMMAND( movestack, 1, {ARG_TYPE_SINT} ), + IPCCOMMAND( quit, 1, {ARG_TYPE_NONE} ), + IPCCOMMAND( setlayoutsafe, 1, {ARG_TYPE_PTR} ), + IPCCOMMAND( setmfact, 1, {ARG_TYPE_FLOAT} ), + IPCCOMMAND( tag, 1, {ARG_TYPE_UINT} ), + IPCCOMMAND( tagmon, 1, {ARG_TYPE_UINT} ), + IPCCOMMAND( togglebar, 1, {ARG_TYPE_UINT} ), + IPCCOMMAND( togglefloating, 1, {ARG_TYPE_NONE} ), + IPCCOMMAND( togglefullscr, 1, {ARG_TYPE_NONE} ), + IPCCOMMAND( toggletag, 1, {ARG_TYPE_UINT} ), + IPCCOMMAND( toggleview, 1, {ARG_TYPE_UINT} ), + IPCCOMMAND( view, 1, {ARG_TYPE_UINT} ), + IPCCOMMAND( xrdb, 1, {ARG_TYPE_NONE} ), + IPCCOMMAND( zoom, 1, {ARG_TYPE_NONE} ), +}; @@ -24,9 +24,13 @@ FREETYPEINC = /usr/include/freetype2 #MANPREFIX = ${PREFIX}/man #KVMLIB = -lkvm +# yajl +YAJLLIBS = -lyajl +YAJLINC = /usr/include/yajl + # includes and libs -INCS = -I${X11INC} -I${FREETYPEINC} -LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} -lX11-xcb -lxcb -lxcb-res -lXrender ${KVMLIB} +INCS = -I${X11INC} -I${FREETYPEINC} -I${YAJLINC} +LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} -lX11-xcb -lxcb -lxcb-res -lXrender ${KVMLIB} ${YAJLLIBS} # flags CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS} $(MYFLAGS) diff --git a/dwm-msg.c b/dwm-msg.c new file mode 100644 index 0000000..1971d32 --- /dev/null +++ b/dwm-msg.c @@ -0,0 +1,548 @@ +#include <ctype.h> +#include <errno.h> +#include <inttypes.h> +#include <stdarg.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <unistd.h> +#include <yajl/yajl_gen.h> + +#define IPC_MAGIC "DWM-IPC" +// clang-format off +#define IPC_MAGIC_ARR { 'D', 'W', 'M', '-', 'I', 'P', 'C' } +// clang-format on +#define IPC_MAGIC_LEN 7 // Not including null char + +#define IPC_EVENT_TAG_CHANGE "tag_change_event" +#define IPC_EVENT_CLIENT_FOCUS_CHANGE "client_focus_change_event" +#define IPC_EVENT_LAYOUT_CHANGE "layout_change_event" +#define IPC_EVENT_MONITOR_FOCUS_CHANGE "monitor_focus_change_event" +#define IPC_EVENT_FOCUSED_TITLE_CHANGE "focused_title_change_event" +#define IPC_EVENT_FOCUSED_STATE_CHANGE "focused_state_change_event" + +#define YSTR(str) yajl_gen_string(gen, (unsigned char *)str, strlen(str)) +#define YINT(num) yajl_gen_integer(gen, num) +#define YDOUBLE(num) yajl_gen_double(gen, num) +#define YBOOL(v) yajl_gen_bool(gen, v) +#define YNULL() yajl_gen_null(gen) +#define YARR(body) \ + { \ + yajl_gen_array_open(gen); \ + body; \ + yajl_gen_array_close(gen); \ + } +#define YMAP(body) \ + { \ + yajl_gen_map_open(gen); \ + body; \ + yajl_gen_map_close(gen); \ + } + +typedef unsigned long Window; + +const char *DEFAULT_SOCKET_PATH = "/tmp/dwm.sock"; +static int sock_fd = -1; +static unsigned int ignore_reply = 0; + +typedef enum IPCMessageType { + IPC_TYPE_RUN_COMMAND = 0, + IPC_TYPE_GET_MONITORS = 1, + IPC_TYPE_GET_TAGS = 2, + IPC_TYPE_GET_LAYOUTS = 3, + IPC_TYPE_GET_DWM_CLIENT = 4, + IPC_TYPE_SUBSCRIBE = 5, + IPC_TYPE_EVENT = 6 +} IPCMessageType; + +// Every IPC message must begin with this +typedef struct dwm_ipc_header { + uint8_t magic[IPC_MAGIC_LEN]; + uint32_t size; + uint8_t type; +} __attribute((packed)) dwm_ipc_header_t; + +static int +recv_message(uint8_t *msg_type, uint32_t *reply_size, uint8_t **reply) +{ + uint32_t read_bytes = 0; + const int32_t to_read = sizeof(dwm_ipc_header_t); + char header[to_read]; + char *walk = header; + + // Try to read header + while (read_bytes < to_read) { + ssize_t n = read(sock_fd, header + read_bytes, to_read - read_bytes); + + if (n == 0) { + if (read_bytes == 0) { + fprintf(stderr, "Unexpectedly reached EOF while reading header."); + fprintf(stderr, + "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", + read_bytes, to_read); + return -2; + } else { + fprintf(stderr, "Unexpectedly reached EOF while reading header."); + fprintf(stderr, + "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", + read_bytes, to_read); + return -3; + } + } else if (n == -1) { + return -1; + } + + read_bytes += n; + } + + // Check if magic string in header matches + if (memcmp(walk, IPC_MAGIC, IPC_MAGIC_LEN) != 0) { + fprintf(stderr, "Invalid magic string. Got '%.*s', expected '%s'\n", + IPC_MAGIC_LEN, walk, IPC_MAGIC); + return -3; + } + + walk += IPC_MAGIC_LEN; + + // Extract reply size + memcpy(reply_size, walk, sizeof(uint32_t)); + walk += sizeof(uint32_t); + + // Extract message type + memcpy(msg_type, walk, sizeof(uint8_t)); + walk += sizeof(uint8_t); + + (*reply) = malloc(*reply_size); + + // Extract payload + read_bytes = 0; + while (read_bytes < *reply_size) { + ssize_t n = read(sock_fd, *reply + read_bytes, *reply_size - read_bytes); + + if (n == 0) { + fprintf(stderr, "Unexpectedly reached EOF while reading payload."); + fprintf(stderr, "Read %" PRIu32 " bytes, expected %" PRIu32 " bytes.\n", + read_bytes, *reply_size); + free(*reply); + return -2; + } else if (n == -1) { + if (errno == EINTR || errno == EAGAIN) continue; + free(*reply); + return -1; + } + + read_bytes += n; + } + + return 0; +} + +static int +read_socket(IPCMessageType *msg_type, uint32_t *msg_size, char **msg) +{ + int ret = -1; + + while (ret != 0) { + ret = recv_message((uint8_t *)msg_type, msg_size, (uint8_t **)msg); + + if (ret < 0) { + // Try again (non-fatal error) + if (ret == -1 && (errno == EINTR || errno == EAGAIN)) continue; + + fprintf(stderr, "Error receiving response from socket. "); + fprintf(stderr, "The connection might have been lost.\n"); + exit(2); + } + } + + return 0; +} + +static ssize_t +write_socket(const void *buf, size_t count) +{ + size_t written = 0; + + while (written < count) { + const ssize_t n = + write(sock_fd, ((uint8_t *)buf) + written, count - written); + + if (n == -1) { + if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) + continue; + else + return n; + } + written += n; + } + return written; +} + +static void +connect_to_socket() +{ + struct sockaddr_un addr; + + int sock = socket(AF_UNIX, SOCK_STREAM, 0); + + // Initialize struct to 0 + memset(&addr, 0, sizeof(struct sockaddr_un)); + + addr.sun_family = AF_UNIX; + strcpy(addr.sun_path, DEFAULT_SOCKET_PATH); + + connect(sock, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)); + + sock_fd = sock; +} + +static int +send_message(IPCMessageType msg_type, uint32_t msg_size, uint8_t *msg) +{ + dwm_ipc_header_t header = { + .magic = IPC_MAGIC_ARR, .size = msg_size, .type = msg_type}; + + size_t header_size = sizeof(dwm_ipc_header_t); + size_t total_size = header_size + msg_size; + + uint8_t buffer[total_size]; + + // Copy header to buffer + memcpy(buffer, &header, header_size); + // Copy message to buffer + memcpy(buffer + header_size, msg, header.size); + + write_socket(buffer, total_size); + + return 0; +} + +static int +is_float(const char *s) +{ + size_t len = strlen(s); + int is_dot_used = 0; + int is_minus_used = 0; + + // Floats can only have one decimal point in between or digits + // Optionally, floats can also be below zero (negative) + for (int i = 0; i < len; i++) { + if (isdigit(s[i])) + continue; + else if (!is_dot_used && s[i] == '.' && i != 0 && i != len - 1) { + is_dot_used = 1; + continue; + } else if (!is_minus_used && s[i] == '-' && i == 0) { + is_minus_used = 1; + continue; + } else + return 0; + } + + return 1; +} + +static int +is_unsigned_int(const char *s) +{ + size_t len = strlen(s); + + // Unsigned int can only have digits + for (int i = 0; i < len; i++) { + if (isdigit(s[i])) + continue; + else + return 0; + } + + return 1; +} + +static int +is_signed_int(const char *s) +{ + size_t len = strlen(s); + + // Signed int can only have digits and a negative sign at the start + for (int i = 0; i < len; i++) { + if (isdigit(s[i])) + continue; + else if (i == 0 && s[i] == '-') { + continue; + } else + return 0; + } + + return 1; +} + +static void +flush_socket_reply() +{ + IPCMessageType reply_type; + uint32_t reply_size; + char *reply; + + read_socket(&reply_type, &reply_size, &reply); + + free(reply); +} + +static void +print_socket_reply() +{ + IPCMessageType reply_type; + uint32_t reply_size; + char *reply; + + read_socket(&reply_type, &reply_size, &reply); + + printf("%.*s\n", reply_size, reply); + fflush(stdout); + free(reply); +} + +static int +run_command(const char *name, char *args[], int argc) +{ + const unsigned char *msg; + size_t msg_size; + + yajl_gen gen = yajl_gen_alloc(NULL); + + // Message format: + // { + // "command": "<name>", + // "args": [ ... ] + // } + // clang-format off + YMAP( + YSTR("command"); YSTR(name); + YSTR("args"); YARR( + for (int i = 0; i < argc; i++) { + if (is_signed_int(args[i])) { + long long num = atoll(args[i]); + YINT(num); + } else if (is_float(args[i])) { + float num = atof(args[i]); + YDOUBLE(num); + } else { + YSTR(args[i]); + } + } + ) + ) + // clang-format on + + yajl_gen_get_buf(gen, &msg, &msg_size); + + send_message(IPC_TYPE_RUN_COMMAND, msg_size, (uint8_t *)msg); + + if (!ignore_reply) + print_socket_reply(); + else + flush_socket_reply(); + + yajl_gen_free(gen); + + return 0; +} + +static int +get_monitors() +{ + send_message(IPC_TYPE_GET_MONITORS, 1, (uint8_t *)""); + print_socket_reply(); + return 0; +} + +static int +get_tags() +{ + send_message(IPC_TYPE_GET_TAGS, 1, (uint8_t *)""); + print_socket_reply(); + + return 0; +} + +static int +get_layouts() +{ + send_message(IPC_TYPE_GET_LAYOUTS, 1, (uint8_t *)""); + print_socket_reply(); + + return 0; +} + +static int +get_dwm_client(Window win) +{ + const unsigned char *msg; + size_t msg_size; + + yajl_gen gen = yajl_gen_alloc(NULL); + + // Message format: + // { + // "client_window_id": "<win>" + // } + // clang-format off + YMAP( + YSTR("client_window_id"); YINT(win); + ) + // clang-format on + + yajl_gen_get_buf(gen, &msg, &msg_size); + + send_message(IPC_TYPE_GET_DWM_CLIENT, msg_size, (uint8_t *)msg); + + print_socket_reply(); + + yajl_gen_free(gen); + + return 0; +} + +static int +subscribe(const char *event) +{ + const unsigned char *msg; + size_t msg_size; + + yajl_gen gen = yajl_gen_alloc(NULL); + + // Message format: + // { + // "event": "<event>", + // "action": "subscribe" + // } + // clang-format off + YMAP( + YSTR("event"); YSTR(event); + YSTR("action"); YSTR("subscribe"); + ) + // clang-format on + + yajl_gen_get_buf(gen, &msg, &msg_size); + + send_message(IPC_TYPE_SUBSCRIBE, msg_size, (uint8_t *)msg); + + if (!ignore_reply) + print_socket_reply(); + else + flush_socket_reply(); + + yajl_gen_free(gen); + + return 0; +} + +static void +usage_error(const char *prog_name, const char *format, ...) +{ + va_list args; + va_start(args, format); + + fprintf(stderr, "Error: "); + vfprintf(stderr, format, args); + fprintf(stderr, "\nusage: %s <command> [...]\n", prog_name); + fprintf(stderr, "Try '%s help'\n", prog_name); + + va_end(args); + exit(1); +} + +static void +print_usage(const char *name) +{ + printf("usage: %s [options] <command> [...]\n", name); + puts(""); + puts("Commands:"); + puts(" run_command <name> [args...] Run an IPC command"); + puts(""); + puts(" get_monitors Get monitor properties"); + puts(""); + puts(" get_tags Get list of tags"); + puts(""); + puts(" get_layouts Get list of layouts"); + puts(""); + puts(" get_dwm_client <window_id> Get dwm client proprties"); + puts(""); + puts(" subscribe [events...] Subscribe to specified events"); + puts(" Options: " IPC_EVENT_TAG_CHANGE ","); + puts(" " IPC_EVENT_LAYOUT_CHANGE ","); + puts(" " IPC_EVENT_CLIENT_FOCUS_CHANGE ","); + puts(" " IPC_EVENT_MONITOR_FOCUS_CHANGE ","); + puts(" " IPC_EVENT_FOCUSED_TITLE_CHANGE ","); + puts(" " IPC_EVENT_FOCUSED_STATE_CHANGE); + puts(""); + puts(" help Display this message"); + puts(""); + puts("Options:"); + puts(" --ignore-reply Don't print reply messages from"); + puts(" run_command and subscribe."); + puts(""); +} + +int +main(int argc, char *argv[]) +{ + const char *prog_name = argv[0]; + + connect_to_socket(); + if (sock_fd == -1) { + fprintf(stderr, "Failed to connect to socket\n"); + return 1; + } + + int i = 1; + if (i < argc && strcmp(argv[i], "--ignore-reply") == 0) { + ignore_reply = 1; + i++; + } + + if (i >= argc) usage_error(prog_name, "Expected an argument, got none"); + + if (strcmp(argv[i], "help") == 0) + print_usage(prog_name); + else if (strcmp(argv[i], "run_command") == 0) { + if (++i >= argc) usage_error(prog_name, "No command specified"); + // Command name + char *command = argv[i]; + // Command arguments are everything after command name + char **command_args = argv + ++i; + // Number of command arguments + int command_argc = argc - i; + run_command(command, command_args, command_argc); + } else if (strcmp(argv[i], "get_monitors") == 0) { + get_monitors(); + } else if (strcmp(argv[i], "get_tags") == 0) { + get_tags(); + } else if (strcmp(argv[i], "get_layouts") == 0) { + get_layouts(); + } else if (strcmp(argv[i], "get_dwm_client") == 0) { + if (++i < argc) { + if (is_unsigned_int(argv[i])) { + Window win = atol(argv[i]); + get_dwm_client(win); + } else + usage_error(prog_name, "Expected unsigned integer argument"); + } else + usage_error(prog_name, "Expected the window id"); + } else if (strcmp(argv[i], "subscribe") == 0) { + if (++i < argc) { + for (int j = i; j < argc; j++) subscribe(argv[j]); + } else + usage_error(prog_name, "Expected event name"); + // Keep listening for events forever + while (1) { + print_socket_reply(); + } + } else + usage_error(prog_name, "Invalid argument '%s'", argv[i]); + + return 0; +} diff --git a/dwm-msg.o b/dwm-msg.o Binary files differnew file mode 100644 index 0000000..16848fb --- /dev/null +++ b/dwm-msg.o @@ -30,6 +30,7 @@ #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> +#include <sys/epoll.h> #include <X11/cursorfont.h> #include <X11/keysym.h> #include <X11/Xatom.h> @@ -105,9 +106,21 @@ enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms * enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, ClkClientWin, ClkRootWin, ClkLast }; /* clicks */ +typedef struct TagState TagState; +struct TagState { + int selected; + int occupied; + int urgent; +}; + +typedef struct ClientState ClientState; +struct ClientState { + int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen; +}; + typedef union { - int i; - unsigned int ui; + long i; + unsigned long ui; float f; const void *v; } Arg; @@ -138,6 +151,7 @@ struct Client { Client *swallowing; Monitor *mon; Window win; + ClientState prevstate; }; typedef struct { @@ -155,6 +169,7 @@ typedef struct { typedef struct Pertag Pertag; struct Monitor { char ltsymbol[16]; + char lastltsymbol[16]; float mfact; int nmaster; int num; @@ -168,14 +183,17 @@ struct Monitor { unsigned int seltags; unsigned int sellt; unsigned int tagset[2]; + TagState tagstate; int showbar; int topbar; Client *clients; Client *sel; + Client *lastsel; Client *stack; Monitor *next; Window barwin; const Layout *lt[2]; + const Layout *lastlt; Pertag *pertag; }; @@ -232,6 +250,7 @@ static unsigned int getsystraywidth(); static int gettextprop(Window w, Atom atom, char *text, unsigned int size); static void grabbuttons(Client *c, int focused); static void grabkeys(void); +static int handlexevent(struct epoll_event *ev); static void incnmaster(const Arg *arg); static void keypress(XEvent *e); static void killclient(const Arg *arg); @@ -263,9 +282,11 @@ static void setclientstate(Client *c, long state); static void setfocus(Client *c); static void setfullscreen(Client *c, int fullscreen); static void setlayout(const Arg *arg); +static void setlayoutsafe(const Arg *arg); static void setcfact(const Arg *arg); static void setmfact(const Arg *arg); static void setup(void); +static void setupepoll(void); static void seturgent(Client *c, int urg); static void showhide(Client *c); static void spawn(const Arg *arg); @@ -340,23 +361,33 @@ static void (*handler[LASTEvent]) (XEvent *) = { [UnmapNotify] = unmapnotify }; static Atom wmatom[WMLast], netatom[NetLast], xatom[XLast]; +static int epoll_fd; +static int dpy_fd; static int running = 1; static Cur *cursor[CurLast]; static Clr **scheme; static Display *dpy; static Drw *drw; -static Monitor *mons, *selmon; +static Monitor *mons, *selmon, *lastselmon; static Window root, wmcheckwin; static int useargb = 0; static Visual *visual; static int depth; static Colormap cmap; +#include "ipc.h" + static xcb_connection_t *xcon; /* configuration, allows nested code to access above variables */ #include "config.h" +#ifdef VERSION +#include "IPCClient.c" +#include "yajl_dumps.c" +#include "ipc.c" +#endif + struct Pertag { unsigned int curtag, prevtag; /* current and previous tag */ int nmasters[LENGTH(tags) + 1]; /* number of windows in master area */ @@ -660,6 +691,12 @@ cleanup(void) XSync(dpy, False); XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime); XDeleteProperty(dpy, root, netatom[NetActiveWindow]); + + ipc_cleanup(); + + if (close(epoll_fd) < 0) { + fprintf(stderr, "Failed to close epoll file descriptor\n"); + } } void @@ -1251,6 +1288,25 @@ grabkeys(void) } } +int +handlexevent(struct epoll_event *ev) +{ + if (ev->events & EPOLLIN) { + XEvent ev; + while (running && XPending(dpy)) { + XNextEvent(dpy, &ev); + if (handler[ev.type]) { + handler[ev.type](&ev); /* call handler */ + ipc_send_events(mons, &lastselmon, selmon); + } + } + } else if (ev-> events & EPOLLHUP) { + return -1; + } + + return 0; +} + void incnmaster(const Arg *arg) { @@ -1757,12 +1813,40 @@ restack(Monitor *m) void run(void) { - XEvent ev; - /* main event loop */ + int event_count = 0; + const int MAX_EVENTS = 10; + struct epoll_event events[MAX_EVENTS]; + XSync(dpy, False); - while (running && !XNextEvent(dpy, &ev)) - if (handler[ev.type]) - handler[ev.type](&ev); /* call handler */ + + /* main event loop */ + while (running) { + event_count = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); + + for (int i = 0; i < event_count; i++) { + int event_fd = events[i].data.fd; + DEBUG("Got event from fd %d\n", event_fd); + + if (event_fd == dpy_fd) { + // -1 means EPOLLHUP + if (handlexevent(events + i) == -1) + return; + } else if (event_fd == ipc_get_sock_fd()) { + ipc_handle_socket_epoll_event(events + i); + } else if (ipc_is_client_registered(event_fd)){ + if (ipc_handle_client_epoll_event(events + i, mons, &lastselmon, selmon, + tags, LENGTH(tags), layouts, LENGTH(layouts)) < 0) { + fprintf(stderr, "Error handling IPC event on fd %d\n", event_fd); + } + } else { + fprintf(stderr, "Got event from unknown fd %d, ptr %p, u32 %d, u64 %lu", + event_fd, events[i].data.ptr, events[i].data.u32, + events[i].data.u64); + fprintf(stderr, " with events %d\n", events[i].events); + return; + } + } + } } void @@ -1928,6 +2012,18 @@ setcfact(const Arg *arg) { arrange(selmon); } +void +setlayoutsafe(const Arg *arg) +{ + const Layout *ltptr = (Layout *)arg->v; + if (ltptr == 0) + setlayout(arg); + for (int i = 0; i < LENGTH(layouts); i++) { + if (ltptr == &layouts[i]) + setlayout(arg); + } +} + /* arg > 1.0 will set mfact absolutely */ void setmfact(const Arg *arg) @@ -2033,6 +2129,36 @@ setup(void) XSelectInput(dpy, root, wa.event_mask); grabkeys(); focus(NULL); + setupepoll(); +} + +void +setupepoll(void) +{ + epoll_fd = epoll_create1(0); + dpy_fd = ConnectionNumber(dpy); + struct epoll_event dpy_event; + + // Initialize struct to 0 + memset(&dpy_event, 0, sizeof(dpy_event)); + + DEBUG("Display socket is fd %d\n", dpy_fd); + + if (epoll_fd == -1) { + fputs("Failed to create epoll file descriptor", stderr); + } + + dpy_event.events = EPOLLIN; + dpy_event.data.fd = dpy_fd; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, dpy_fd, &dpy_event)) { + fputs("Failed to add display file descriptor to epoll", stderr); + close(epoll_fd); + exit(1); + } + + if (ipc_init(ipcsockpath, epoll_fd, ipccommands, LENGTH(ipccommands)) < 0) { + fputs("Failed to initialize IPC\n", stderr); + } } void @@ -2600,10 +2726,18 @@ updatesystray(void) void updatetitle(Client *c) { + char oldname[sizeof(c->name)]; + strcpy(oldname, c->name); + if (!gettextprop(c->win, netatom[NetWMName], c->name, sizeof c->name)) gettextprop(c->win, XA_WM_NAME, c->name, sizeof c->name); if (c->name[0] == '\0') /* hack to mark broken clients */ strcpy(c->name, broken); + + for (Monitor *m = mons; m; m = m->next) { + if (m->sel == c && strcmp(oldname, c->name) != 0) + ipc_focused_title_change_event(m->num, c->win, oldname, c->name); + } } void @@ -0,0 +1,1202 @@ +#include "ipc.h" + +#include <errno.h> +#include <fcntl.h> +#include <inttypes.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/epoll.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <unistd.h> +#include <yajl/yajl_gen.h> +#include <yajl/yajl_tree.h> + +#include "util.h" +#include "yajl_dumps.h" + +static struct sockaddr_un sockaddr; +static struct epoll_event sock_epoll_event; +static IPCClientList ipc_clients = NULL; +static int epoll_fd = -1; +static int sock_fd = -1; +static IPCCommand *ipc_commands; +static unsigned int ipc_commands_len; +// Max size is 1 MB +static const uint32_t MAX_MESSAGE_SIZE = 1000000; +static const int IPC_SOCKET_BACKLOG = 5; + +/** + * Create IPC socket at specified path and return file descriptor to socket. + * This initializes the static variable sockaddr. + */ +static int +ipc_create_socket(const char *filename) +{ + char *normal_filename; + char *parent; + const size_t addr_size = sizeof(struct sockaddr_un); + const int sock_type = SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC; + + normalizepath(filename, &normal_filename); + + // In case socket file exists + unlink(normal_filename); + + // For portability clear the addr structure, since some implementations have + // nonstandard fields in the structure + memset(&sockaddr, 0, addr_size); + + parentdir(normal_filename, &parent); + // Create parent directories + mkdirp(parent); + free(parent); + + sockaddr.sun_family = AF_LOCAL; + strcpy(sockaddr.sun_path, normal_filename); + free(normal_filename); + + sock_fd = socket(AF_LOCAL, sock_type, 0); + if (sock_fd == -1) { + fputs("Failed to create socket\n", stderr); + return -1; + } + + DEBUG("Created socket at %s\n", sockaddr.sun_path); + + if (bind(sock_fd, (const struct sockaddr *)&sockaddr, addr_size) == -1) { + fputs("Failed to bind socket\n", stderr); + return -1; + } + + DEBUG("Socket binded\n"); + + if (listen(sock_fd, IPC_SOCKET_BACKLOG) < 0) { + fputs("Failed to listen for connections on socket\n", stderr); + return -1; + } + + DEBUG("Now listening for connections on socket\n"); + + return sock_fd; +} + +/** + * Internal function used to receive IPC messages from a given file descriptor. + * + * Returns -1 on error reading (could be EAGAIN or EINTR) + * Returns -2 if EOF before header could be read + * Returns -3 if invalid IPC header + * Returns -4 if message length exceeds MAX_MESSAGE_SIZE + */ +static int +ipc_recv_message(int fd, uint8_t *msg_type, uint32_t *reply_size, + uint8_t **reply) +{ + uint32_t read_bytes = 0; + const int32_t to_read = sizeof(dwm_ipc_header_t); + char header[to_read]; + char *walk = header; + + // Try to read header + while (read_bytes < to_read) { + const ssize_t n = read(fd, header + read_bytes, to_read - read_bytes); + + if (n == 0) { + if (read_bytes == 0) { + fprintf(stderr, "Unexpectedly reached EOF while reading header."); + fprintf(stderr, + "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", + read_bytes, to_read); + return -2; + } else { + fprintf(stderr, "Unexpectedly reached EOF while reading header."); + fprintf(stderr, + "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", + read_bytes, to_read); + return -3; + } + } else if (n == -1) { + // errno will still be set + return -1; + } + + read_bytes += n; + } + + // Check if magic string in header matches + if (memcmp(walk, IPC_MAGIC, IPC_MAGIC_LEN) != 0) { + fprintf(stderr, "Invalid magic string. Got '%.*s', expected '%s'\n", + IPC_MAGIC_LEN, walk, IPC_MAGIC); + return -3; + } + + walk += IPC_MAGIC_LEN; + + // Extract reply size + memcpy(reply_size, walk, sizeof(uint32_t)); + walk += sizeof(uint32_t); + + if (*reply_size > MAX_MESSAGE_SIZE) { + fprintf(stderr, "Message too long: %" PRIu32 " bytes. ", *reply_size); + fprintf(stderr, "Maximum message size is: %d\n", MAX_MESSAGE_SIZE); + return -4; + } + + // Extract message type + memcpy(msg_type, walk, sizeof(uint8_t)); + walk += sizeof(uint8_t); + + if (*reply_size > 0) + (*reply) = malloc(*reply_size); + else + return 0; + + read_bytes = 0; + while (read_bytes < *reply_size) { + const ssize_t n = read(fd, *reply + read_bytes, *reply_size - read_bytes); + + if (n == 0) { + fprintf(stderr, "Unexpectedly reached EOF while reading payload."); + fprintf(stderr, "Read %" PRIu32 " bytes, expected %" PRIu32 " bytes.\n", + read_bytes, *reply_size); + free(*reply); + return -2; + } else if (n == -1) { + // TODO: Should we return and wait for another epoll event? + // This would require saving the partial read in some way. + if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) continue; + + free(*reply); + return -1; + } + + read_bytes += n; + } + + return 0; +} + +/** + * Internal function used to write a buffer to a file descriptor + * + * Returns number of bytes written if successful write + * Returns 0 if no bytes were written due to EAGAIN or EWOULDBLOCK + * Returns -1 on unknown error trying to write, errno will carry over from + * write() call + */ +static ssize_t +ipc_write_message(int fd, const void *buf, size_t count) +{ + size_t written = 0; + + while (written < count) { + const ssize_t n = write(fd, (uint8_t *)buf + written, count - written); + + if (n == -1) { + if (errno == EAGAIN || errno == EWOULDBLOCK) + return written; + else if (errno == EINTR) + continue; + else + return n; + } + + written += n; + DEBUG("Wrote %zu/%zu to client at fd %d\n", written, count, fd); + } + + return written; +} + +/** + * Initialization for generic event message. This is used to allocate the yajl + * handle, set yajl options, and in the future any other initialization that + * should occur for event messages. + */ +static void +ipc_event_init_message(yajl_gen *gen) +{ + *gen = yajl_gen_alloc(NULL); + yajl_gen_config(*gen, yajl_gen_beautify, 1); +} + +/** + * Prepares buffers of IPC subscribers of specified event using buffer from yajl + * handle. + */ +static void +ipc_event_prepare_send_message(yajl_gen gen, IPCEvent event) +{ + const unsigned char *buffer; + size_t len = 0; + + yajl_gen_get_buf(gen, &buffer, &len); + len++; // For null char + + for (IPCClient *c = ipc_clients; c; c = c->next) { + if (c->subscriptions & event) { + DEBUG("Sending selected client change event to fd %d\n", c->fd); + ipc_prepare_send_message(c, IPC_TYPE_EVENT, len, (char *)buffer); + } + } + + // Not documented, but this frees temp_buffer + yajl_gen_free(gen); +} + +/** + * Initialization for generic reply message. This is used to allocate the yajl + * handle, set yajl options, and in the future any other initialization that + * should occur for reply messages. + */ +static void +ipc_reply_init_message(yajl_gen *gen) +{ + *gen = yajl_gen_alloc(NULL); + yajl_gen_config(*gen, yajl_gen_beautify, 1); +} + +/** + * Prepares the IPC client's buffer with a message using the buffer of the yajl + * handle. + */ +static void +ipc_reply_prepare_send_message(yajl_gen gen, IPCClient *c, + IPCMessageType msg_type) +{ + const unsigned char *buffer; + size_t len = 0; + + yajl_gen_get_buf(gen, &buffer, &len); + len++; // For null char + + ipc_prepare_send_message(c, msg_type, len, (const char *)buffer); + + // Not documented, but this frees temp_buffer + yajl_gen_free(gen); +} + +/** + * Find the IPCCommand with the specified name + * + * Returns 0 if a command with the specified name was found + * Returns -1 if a command with the specified name could not be found + */ +static int +ipc_get_ipc_command(const char *name, IPCCommand *ipc_command) +{ + for (int i = 0; i < ipc_commands_len; i++) { + if (strcmp(ipc_commands[i].name, name) == 0) { + *ipc_command = ipc_commands[i]; + return 0; + } + } + + return -1; +} + +/** + * Parse a IPC_TYPE_RUN_COMMAND message from a client. This function extracts + * the arguments, argument count, argument types, and command name and returns + * the parsed information as an IPCParsedCommand. If this function returns + * successfully, the parsed_command must be freed using + * ipc_free_parsed_command_members. + * + * Returns 0 if the message was successfully parsed + * Returns -1 otherwise + */ +static int +ipc_parse_run_command(char *msg, IPCParsedCommand *parsed_command) +{ + char error_buffer[1000]; + yajl_val parent = yajl_tree_parse(msg, error_buffer, 1000); + + if (parent == NULL) { + fputs("Failed to parse command from client\n", stderr); + fprintf(stderr, "%s\n", error_buffer); + fprintf(stderr, "Tried to parse: %s\n", msg); + return -1; + } + + // Format: + // { + // "command": "<command name>" + // "args": [ "arg1", "arg2", ... ] + // } + const char *command_path[] = {"command", 0}; + yajl_val command_val = yajl_tree_get(parent, command_path, yajl_t_string); + + if (command_val == NULL) { + fputs("No command key found in client message\n", stderr); + yajl_tree_free(parent); + return -1; + } + + const char *command_name = YAJL_GET_STRING(command_val); + size_t command_name_len = strlen(command_name); + parsed_command->name = (char *)malloc((command_name_len + 1) * sizeof(char)); + strcpy(parsed_command->name, command_name); + + DEBUG("Received command: %s\n", parsed_command->name); + + const char *args_path[] = {"args", 0}; + yajl_val args_val = yajl_tree_get(parent, args_path, yajl_t_array); + + if (args_val == NULL) { + fputs("No args key found in client message\n", stderr); + yajl_tree_free(parent); + return -1; + } + + unsigned int *argc = &parsed_command->argc; + Arg **args = &parsed_command->args; + ArgType **arg_types = &parsed_command->arg_types; + + *argc = args_val->u.array.len; + + // If no arguments are specified, make a dummy argument to pass to the + // function. This is just the way dwm's void(Arg*) functions are setup. + if (*argc == 0) { + *args = (Arg *)malloc(sizeof(Arg)); + *arg_types = (ArgType *)malloc(sizeof(ArgType)); + (*arg_types)[0] = ARG_TYPE_NONE; + (*args)[0].i = 0; + (*argc)++; + } else if (*argc > 0) { + *args = (Arg *)calloc(*argc, sizeof(Arg)); + *arg_types = (ArgType *)malloc(*argc * sizeof(ArgType)); + + for (int i = 0; i < *argc; i++) { + yajl_val arg_val = args_val->u.array.values[i]; + + if (YAJL_IS_NUMBER(arg_val)) { + if (YAJL_IS_INTEGER(arg_val)) { + // Any values below 0 must be a signed int + if (YAJL_GET_INTEGER(arg_val) < 0) { + (*args)[i].i = YAJL_GET_INTEGER(arg_val); + (*arg_types)[i] = ARG_TYPE_SINT; + DEBUG("i=%ld\n", (*args)[i].i); + // Any values above 0 should be an unsigned int + } else if (YAJL_GET_INTEGER(arg_val) >= 0) { + (*args)[i].ui = YAJL_GET_INTEGER(arg_val); + (*arg_types)[i] = ARG_TYPE_UINT; + DEBUG("ui=%ld\n", (*args)[i].i); + } + // If the number is not an integer, it must be a float + } else { + (*args)[i].f = (float)YAJL_GET_DOUBLE(arg_val); + (*arg_types)[i] = ARG_TYPE_FLOAT; + DEBUG("f=%f\n", (*args)[i].f); + // If argument is not a number, it must be a string + } + } else if (YAJL_IS_STRING(arg_val)) { + char *arg_s = YAJL_GET_STRING(arg_val); + size_t arg_s_size = (strlen(arg_s) + 1) * sizeof(char); + (*args)[i].v = (char *)malloc(arg_s_size); + (*arg_types)[i] = ARG_TYPE_STR; + strcpy((char *)(*args)[i].v, arg_s); + } + } + } + + yajl_tree_free(parent); + + return 0; +} + +/** + * Free the members of a IPCParsedCommand struct + */ +static void +ipc_free_parsed_command_members(IPCParsedCommand *command) +{ + for (int i = 0; i < command->argc; i++) { + if (command->arg_types[i] == ARG_TYPE_STR) free((void *)command->args[i].v); + } + free(command->args); + free(command->arg_types); + free(command->name); +} + +/** + * Check if the given arguments are the correct length and type. Also do any + * casting to correct the types. + * + * Returns 0 if the arguments were the correct length and types + * Returns -1 if the argument count doesn't match + * Returns -2 if the argument types don't match + */ +static int +ipc_validate_run_command(IPCParsedCommand *parsed, const IPCCommand actual) +{ + if (actual.argc != parsed->argc) return -1; + + for (int i = 0; i < parsed->argc; i++) { + ArgType ptype = parsed->arg_types[i]; + ArgType atype = actual.arg_types[i]; + + if (ptype != atype) { + if (ptype == ARG_TYPE_UINT && atype == ARG_TYPE_PTR) + // If this argument is supposed to be a void pointer, cast it + parsed->args[i].v = (void *)parsed->args[i].ui; + else if (ptype == ARG_TYPE_UINT && atype == ARG_TYPE_SINT) + // If this argument is supposed to be a signed int, cast it + parsed->args[i].i = parsed->args[i].ui; + else + return -2; + } + } + + return 0; +} + +/** + * Convert event name to their IPCEvent equivalent enum value + * + * Returns 0 if a valid event name was given + * Returns -1 otherwise + */ +static int +ipc_event_stoi(const char *subscription, IPCEvent *event) +{ + if (strcmp(subscription, "tag_change_event") == 0) + *event = IPC_EVENT_TAG_CHANGE; + else if (strcmp(subscription, "client_focus_change_event") == 0) + *event = IPC_EVENT_CLIENT_FOCUS_CHANGE; + else if (strcmp(subscription, "layout_change_event") == 0) + *event = IPC_EVENT_LAYOUT_CHANGE; + else if (strcmp(subscription, "monitor_focus_change_event") == 0) + *event = IPC_EVENT_MONITOR_FOCUS_CHANGE; + else if (strcmp(subscription, "focused_title_change_event") == 0) + *event = IPC_EVENT_FOCUSED_TITLE_CHANGE; + else if (strcmp(subscription, "focused_state_change_event") == 0) + *event = IPC_EVENT_FOCUSED_STATE_CHANGE; + else + return -1; + return 0; +} + +/** + * Parse a IPC_TYPE_SUBSCRIBE message from a client. This function extracts the + * event name and the subscription action from the message. + * + * Returns 0 if message was successfully parsed + * Returns -1 otherwise + */ +static int +ipc_parse_subscribe(const char *msg, IPCSubscriptionAction *subscribe, + IPCEvent *event) +{ + char error_buffer[100]; + yajl_val parent = yajl_tree_parse((char *)msg, error_buffer, 100); + + if (parent == NULL) { + fputs("Failed to parse command from client\n", stderr); + fprintf(stderr, "%s\n", error_buffer); + return -1; + } + + // Format: + // { + // "event": "<event name>" + // "action": "<subscribe|unsubscribe>" + // } + const char *event_path[] = {"event", 0}; + yajl_val event_val = yajl_tree_get(parent, event_path, yajl_t_string); + + if (event_val == NULL) { + fputs("No 'event' key found in client message\n", stderr); + return -1; + } + + const char *event_str = YAJL_GET_STRING(event_val); + DEBUG("Received event: %s\n", event_str); + + if (ipc_event_stoi(event_str, event) < 0) return -1; + + const char *action_path[] = {"action", 0}; + yajl_val action_val = yajl_tree_get(parent, action_path, yajl_t_string); + + if (action_val == NULL) { + fputs("No 'action' key found in client message\n", stderr); + return -1; + } + + const char *action = YAJL_GET_STRING(action_val); + + if (strcmp(action, "subscribe") == 0) + *subscribe = IPC_ACTION_SUBSCRIBE; + else if (strcmp(action, "unsubscribe") == 0) + *subscribe = IPC_ACTION_UNSUBSCRIBE; + else { + fputs("Invalid action specified for subscription\n", stderr); + return -1; + } + + yajl_tree_free(parent); + + return 0; +} + +/** + * Parse an IPC_TYPE_GET_DWM_CLIENT message from a client. This function + * extracts the window id from the message. + * + * Returns 0 if message was successfully parsed + * Returns -1 otherwise + */ +static int +ipc_parse_get_dwm_client(const char *msg, Window *win) +{ + char error_buffer[100]; + + yajl_val parent = yajl_tree_parse(msg, error_buffer, 100); + + if (parent == NULL) { + fputs("Failed to parse message from client\n", stderr); + fprintf(stderr, "%s\n", error_buffer); + return -1; + } + + // Format: + // { + // "client_window_id": <client window id> + // } + const char *win_path[] = {"client_window_id", 0}; + yajl_val win_val = yajl_tree_get(parent, win_path, yajl_t_number); + + if (win_val == NULL) { + fputs("No client window id found in client message\n", stderr); + return -1; + } + + *win = YAJL_GET_INTEGER(win_val); + + yajl_tree_free(parent); + + return 0; +} + +/** + * Called when an IPC_TYPE_RUN_COMMAND message is received from a client. This + * function parses, executes the given command, and prepares a reply message to + * the client indicating success/failure. + * + * NOTE: There is currently no check for argument validity beyond the number of + * arguments given and types of arguments. There is also no way to check if the + * function succeeded based on dwm's void(const Arg*) function types. Pointer + * arguments can cause crashes if they are not validated in the function itself. + * + * Returns 0 if message was successfully parsed + * Returns -1 on failure parsing message + */ +static int +ipc_run_command(IPCClient *ipc_client, char *msg) +{ + IPCParsedCommand parsed_command; + IPCCommand ipc_command; + + // Initialize struct + memset(&parsed_command, 0, sizeof(IPCParsedCommand)); + + if (ipc_parse_run_command(msg, &parsed_command) < 0) { + ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, + "Failed to parse run command"); + return -1; + } + + if (ipc_get_ipc_command(parsed_command.name, &ipc_command) < 0) { + ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, + "Command %s not found", parsed_command.name); + ipc_free_parsed_command_members(&parsed_command); + return -1; + } + + int res = ipc_validate_run_command(&parsed_command, ipc_command); + if (res < 0) { + if (res == -1) + ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, + "%u arguments provided, %u expected", + parsed_command.argc, ipc_command.argc); + else if (res == -2) + ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, + "Type mismatch"); + ipc_free_parsed_command_members(&parsed_command); + return -1; + } + + if (parsed_command.argc == 1) + ipc_command.func.single_param(parsed_command.args); + else if (parsed_command.argc > 1) + ipc_command.func.array_param(parsed_command.args, parsed_command.argc); + + DEBUG("Called function for command %s\n", parsed_command.name); + + ipc_free_parsed_command_members(&parsed_command); + + ipc_prepare_reply_success(ipc_client, IPC_TYPE_RUN_COMMAND); + return 0; +} + +/** + * Called when an IPC_TYPE_GET_MONITORS message is received from a client. It + * prepares a reply with the properties of all of the monitors in JSON. + */ +static void +ipc_get_monitors(IPCClient *c, Monitor *mons, Monitor *selmon) +{ + yajl_gen gen; + ipc_reply_init_message(&gen); + dump_monitors(gen, mons, selmon); + + ipc_reply_prepare_send_message(gen, c, IPC_TYPE_GET_MONITORS); +} + +/** + * Called when an IPC_TYPE_GET_TAGS message is received from a client. It + * prepares a reply with info about all the tags in JSON. + */ +static void +ipc_get_tags(IPCClient *c, const char *tags[], const int tags_len) +{ + yajl_gen gen; + ipc_reply_init_message(&gen); + + dump_tags(gen, tags, tags_len); + + ipc_reply_prepare_send_message(gen, c, IPC_TYPE_GET_TAGS); +} + +/** + * Called when an IPC_TYPE_GET_LAYOUTS message is received from a client. It + * prepares a reply with a JSON array of available layouts + */ +static void +ipc_get_layouts(IPCClient *c, const Layout layouts[], const int layouts_len) +{ + yajl_gen gen; + ipc_reply_init_message(&gen); + + dump_layouts(gen, layouts, layouts_len); + + ipc_reply_prepare_send_message(gen, c, IPC_TYPE_GET_LAYOUTS); +} + +/** + * Called when an IPC_TYPE_GET_DWM_CLIENT message is received from a client. It + * prepares a JSON reply with the properties of the client with the specified + * window XID. + * + * Returns 0 if the message was successfully parsed and if the client with the + * specified window XID was found + * Returns -1 if the message could not be parsed + */ +static int +ipc_get_dwm_client(IPCClient *ipc_client, const char *msg, const Monitor *mons) +{ + Window win; + + if (ipc_parse_get_dwm_client(msg, &win) < 0) return -1; + + // Find client with specified window XID + for (const Monitor *m = mons; m; m = m->next) + for (Client *c = m->clients; c; c = c->next) + if (c->win == win) { + yajl_gen gen; + ipc_reply_init_message(&gen); + + dump_client(gen, c); + + ipc_reply_prepare_send_message(gen, ipc_client, + IPC_TYPE_GET_DWM_CLIENT); + + return 0; + } + + ipc_prepare_reply_failure(ipc_client, IPC_TYPE_GET_DWM_CLIENT, + "Client with window id %d not found", win); + return -1; +} + +/** + * Called when an IPC_TYPE_SUBSCRIBE message is received from a client. It + * subscribes/unsubscribes the client from the specified event and replies with + * the result. + * + * Returns 0 if the message was successfully parsed. + * Returns -1 if the message could not be parsed + */ +static int +ipc_subscribe(IPCClient *c, const char *msg) +{ + IPCSubscriptionAction action = IPC_ACTION_SUBSCRIBE; + IPCEvent event = 0; + + if (ipc_parse_subscribe(msg, &action, &event)) { + ipc_prepare_reply_failure(c, IPC_TYPE_SUBSCRIBE, "Event does not exist"); + return -1; + } + + if (action == IPC_ACTION_SUBSCRIBE) { + DEBUG("Subscribing client on fd %d to %d\n", c->fd, event); + c->subscriptions |= event; + } else if (action == IPC_ACTION_UNSUBSCRIBE) { + DEBUG("Unsubscribing client on fd %d to %d\n", c->fd, event); + c->subscriptions ^= event; + } else { + ipc_prepare_reply_failure(c, IPC_TYPE_SUBSCRIBE, + "Invalid subscription action"); + return -1; + } + + ipc_prepare_reply_success(c, IPC_TYPE_SUBSCRIBE); + return 0; +} + +int +ipc_init(const char *socket_path, const int p_epoll_fd, IPCCommand commands[], + const int commands_len) +{ + // Initialize struct to 0 + memset(&sock_epoll_event, 0, sizeof(sock_epoll_event)); + + int socket_fd = ipc_create_socket(socket_path); + if (socket_fd < 0) return -1; + + ipc_commands = commands; + ipc_commands_len = commands_len; + + epoll_fd = p_epoll_fd; + + // Wake up to incoming connection requests + sock_epoll_event.data.fd = socket_fd; + sock_epoll_event.events = EPOLLIN; + if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &sock_epoll_event)) { + fputs("Failed to add sock file descriptor to epoll", stderr); + return -1; + } + + return socket_fd; +} + +void +ipc_cleanup() +{ + IPCClient *c = ipc_clients; + // Free clients and their buffers + while (c) { + ipc_drop_client(c); + c = ipc_clients; + } + + // Stop waking up for socket events + epoll_ctl(epoll_fd, EPOLL_CTL_DEL, sock_fd, &sock_epoll_event); + + // Uninitialize all static variables + epoll_fd = -1; + sock_fd = -1; + ipc_commands = NULL; + ipc_commands_len = 0; + memset(&sock_epoll_event, 0, sizeof(struct epoll_event)); + memset(&sockaddr, 0, sizeof(struct sockaddr_un)); + + // Delete socket + unlink(sockaddr.sun_path); + + shutdown(sock_fd, SHUT_RDWR); + close(sock_fd); +} + +int +ipc_get_sock_fd() +{ + return sock_fd; +} + +IPCClient * +ipc_get_client(int fd) +{ + return ipc_list_get_client(ipc_clients, fd); +} + +int +ipc_is_client_registered(int fd) +{ + return (ipc_get_client(fd) != NULL); +} + +int +ipc_accept_client() +{ + int fd = -1; + + struct sockaddr_un client_addr; + socklen_t len = 0; + + // For portability clear the addr structure, since some implementations + // have nonstandard fields in the structure + memset(&client_addr, 0, sizeof(struct sockaddr_un)); + + fd = accept(sock_fd, (struct sockaddr *)&client_addr, &len); + if (fd < 0 && errno != EINTR) { + fputs("Failed to accept IPC connection from client", stderr); + return -1; + } + + if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) { + shutdown(fd, SHUT_RDWR); + close(fd); + fputs("Failed to set flags on new client fd", stderr); + } + + IPCClient *nc = ipc_client_new(fd); + if (nc == NULL) return -1; + + // Wake up to messages from this client + nc->event.data.fd = fd; + nc->event.events = EPOLLIN | EPOLLHUP; + epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &nc->event); + + ipc_list_add_client(&ipc_clients, nc); + + DEBUG("%s%d\n", "New client at fd: ", fd); + + return fd; +} + +int +ipc_drop_client(IPCClient *c) +{ + int fd = c->fd; + shutdown(fd, SHUT_RDWR); + int res = close(fd); + + if (res == 0) { + struct epoll_event ev; + + // Stop waking up to messages from this client + epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev); + ipc_list_remove_client(&ipc_clients, c); + + free(c->buffer); + free(c); + + DEBUG("Successfully removed client on fd %d\n", fd); + } else if (res < 0 && res != EINTR) { + fprintf(stderr, "Failed to close fd %d\n", fd); + } + + return res; +} + +int +ipc_read_client(IPCClient *c, IPCMessageType *msg_type, uint32_t *msg_size, + char **msg) +{ + int fd = c->fd; + int ret = + ipc_recv_message(fd, (uint8_t *)msg_type, msg_size, (uint8_t **)msg); + + if (ret < 0) { + // This will happen if these errors occur while reading header + if (ret == -1 && + (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)) + return -2; + + fprintf(stderr, "Error reading message: dropping client at fd %d\n", fd); + ipc_drop_client(c); + + return -1; + } + + // Make sure receive message is null terminated to avoid parsing issues + if (*msg_size > 0) { + size_t len = *msg_size; + nullterminate(msg, &len); + *msg_size = len; + } + + DEBUG("[fd %d] ", fd); + if (*msg_size > 0) + DEBUG("Received message: '%.*s' ", *msg_size, *msg); + else + DEBUG("Received empty message "); + DEBUG("Message type: %" PRIu8 " ", (uint8_t)*msg_type); + DEBUG("Message size: %" PRIu32 "\n", *msg_size); + + return 0; +} + +ssize_t +ipc_write_client(IPCClient *c) +{ + const ssize_t n = ipc_write_message(c->fd, c->buffer, c->buffer_size); + + if (n < 0) return n; + + // TODO: Deal with client timeouts + + if (n == c->buffer_size) { + c->buffer_size = 0; + free(c->buffer); + // No dangling pointers! + c->buffer = NULL; + // Stop waking up when client is ready to receive messages + if (c->event.events & EPOLLOUT) { + c->event.events -= EPOLLOUT; + epoll_ctl(epoll_fd, EPOLL_CTL_MOD, c->fd, &c->event); + } + return n; + } + + // Shift unwritten buffer to beginning of buffer and reallocate + c->buffer_size -= n; + memmove(c->buffer, c->buffer + n, c->buffer_size); + c->buffer = (char *)realloc(c->buffer, c->buffer_size); + + return n; +} + +void +ipc_prepare_send_message(IPCClient *c, const IPCMessageType msg_type, + const uint32_t msg_size, const char *msg) +{ + dwm_ipc_header_t header = { + .magic = IPC_MAGIC_ARR, .type = msg_type, .size = msg_size}; + + uint32_t header_size = sizeof(dwm_ipc_header_t); + uint32_t packet_size = header_size + msg_size; + + if (c->buffer == NULL) + c->buffer = (char *)malloc(c->buffer_size + packet_size); + else + c->buffer = (char *)realloc(c->buffer, c->buffer_size + packet_size); + + // Copy header to end of client buffer + memcpy(c->buffer + c->buffer_size, &header, header_size); + c->buffer_size += header_size; + + // Copy message to end of client buffer + memcpy(c->buffer + c->buffer_size, msg, msg_size); + c->buffer_size += msg_size; + + // Wake up when client is ready to receive messages + c->event.events |= EPOLLOUT; + epoll_ctl(epoll_fd, EPOLL_CTL_MOD, c->fd, &c->event); +} + +void +ipc_prepare_reply_failure(IPCClient *c, IPCMessageType msg_type, + const char *format, ...) +{ + yajl_gen gen; + va_list args; + + // Get output size + va_start(args, format); + size_t len = vsnprintf(NULL, 0, format, args); + va_end(args); + char *buffer = (char *)malloc((len + 1) * sizeof(char)); + + ipc_reply_init_message(&gen); + + va_start(args, format); + vsnprintf(buffer, len + 1, format, args); + va_end(args); + dump_error_message(gen, buffer); + + ipc_reply_prepare_send_message(gen, c, msg_type); + fprintf(stderr, "[fd %d] Error: %s\n", c->fd, buffer); + + free(buffer); +} + +void +ipc_prepare_reply_success(IPCClient *c, IPCMessageType msg_type) +{ + const char *success_msg = "{\"result\":\"success\"}"; + const size_t msg_len = strlen(success_msg) + 1; // +1 for null char + + ipc_prepare_send_message(c, msg_type, msg_len, success_msg); +} + +void +ipc_tag_change_event(int mon_num, TagState old_state, TagState new_state) +{ + yajl_gen gen; + ipc_event_init_message(&gen); + dump_tag_event(gen, mon_num, old_state, new_state); + ipc_event_prepare_send_message(gen, IPC_EVENT_TAG_CHANGE); +} + +void +ipc_client_focus_change_event(int mon_num, Client *old_client, + Client *new_client) +{ + yajl_gen gen; + ipc_event_init_message(&gen); + dump_client_focus_change_event(gen, old_client, new_client, mon_num); + ipc_event_prepare_send_message(gen, IPC_EVENT_CLIENT_FOCUS_CHANGE); +} + +void +ipc_layout_change_event(const int mon_num, const char *old_symbol, + const Layout *old_layout, const char *new_symbol, + const Layout *new_layout) +{ + yajl_gen gen; + ipc_event_init_message(&gen); + dump_layout_change_event(gen, mon_num, old_symbol, old_layout, new_symbol, + new_layout); + ipc_event_prepare_send_message(gen, IPC_EVENT_LAYOUT_CHANGE); +} + +void +ipc_monitor_focus_change_event(const int last_mon_num, const int new_mon_num) +{ + yajl_gen gen; + ipc_event_init_message(&gen); + dump_monitor_focus_change_event(gen, last_mon_num, new_mon_num); + ipc_event_prepare_send_message(gen, IPC_EVENT_MONITOR_FOCUS_CHANGE); +} + +void +ipc_focused_title_change_event(const int mon_num, const Window client_id, + const char *old_name, const char *new_name) +{ + yajl_gen gen; + ipc_event_init_message(&gen); + dump_focused_title_change_event(gen, mon_num, client_id, old_name, new_name); + ipc_event_prepare_send_message(gen, IPC_EVENT_FOCUSED_TITLE_CHANGE); +} + +void +ipc_focused_state_change_event(const int mon_num, const Window client_id, + const ClientState *old_state, + const ClientState *new_state) +{ + yajl_gen gen; + ipc_event_init_message(&gen); + dump_focused_state_change_event(gen, mon_num, client_id, old_state, + new_state); + ipc_event_prepare_send_message(gen, IPC_EVENT_FOCUSED_STATE_CHANGE); +} + +void +ipc_send_events(Monitor *mons, Monitor **lastselmon, Monitor *selmon) +{ + for (Monitor *m = mons; m; m = m->next) { + unsigned int urg = 0, occ = 0, tagset = 0; + + for (Client *c = m->clients; c; c = c->next) { + occ |= c->tags; + + if (c->isurgent) urg |= c->tags; + } + tagset = m->tagset[m->seltags]; + + TagState new_state = {.selected = tagset, .occupied = occ, .urgent = urg}; + + if (memcmp(&m->tagstate, &new_state, sizeof(TagState)) != 0) { + ipc_tag_change_event(m->num, m->tagstate, new_state); + m->tagstate = new_state; + } + + if (m->lastsel != m->sel) { + ipc_client_focus_change_event(m->num, m->lastsel, m->sel); + m->lastsel = m->sel; + } + + if (strcmp(m->ltsymbol, m->lastltsymbol) != 0 || + m->lastlt != m->lt[m->sellt]) { + ipc_layout_change_event(m->num, m->lastltsymbol, m->lastlt, m->ltsymbol, + m->lt[m->sellt]); + strcpy(m->lastltsymbol, m->ltsymbol); + m->lastlt = m->lt[m->sellt]; + } + + if (*lastselmon != selmon) { + if (*lastselmon != NULL) + ipc_monitor_focus_change_event((*lastselmon)->num, selmon->num); + *lastselmon = selmon; + } + + Client *sel = m->sel; + if (!sel) continue; + ClientState *o = &m->sel->prevstate; + ClientState n = {.oldstate = sel->oldstate, + .isfixed = sel->isfixed, + .isfloating = sel->isfloating, + .isfullscreen = sel->isfullscreen, + .isurgent = sel->isurgent, + .neverfocus = sel->neverfocus}; + if (memcmp(o, &n, sizeof(ClientState)) != 0) { + ipc_focused_state_change_event(m->num, m->sel->win, o, &n); + *o = n; + } + } +} + +int +ipc_handle_client_epoll_event(struct epoll_event *ev, Monitor *mons, + Monitor **lastselmon, Monitor *selmon, + const char *tags[], const int tags_len, + const Layout *layouts, const int layouts_len) +{ + int fd = ev->data.fd; + IPCClient *c = ipc_get_client(fd); + + if (ev->events & EPOLLHUP) { + DEBUG("EPOLLHUP received from client at fd %d\n", fd); + ipc_drop_client(c); + } else if (ev->events & EPOLLOUT) { + DEBUG("Sending message to client at fd %d...\n", fd); + if (c->buffer_size) ipc_write_client(c); + } else if (ev->events & EPOLLIN) { + IPCMessageType msg_type = 0; + uint32_t msg_size = 0; + char *msg = NULL; + + DEBUG("Received message from fd %d\n", fd); + if (ipc_read_client(c, &msg_type, &msg_size, &msg) < 0) return -1; + + if (msg_type == IPC_TYPE_GET_MONITORS) + ipc_get_monitors(c, mons, selmon); + else if (msg_type == IPC_TYPE_GET_TAGS) + ipc_get_tags(c, tags, tags_len); + else if (msg_type == IPC_TYPE_GET_LAYOUTS) + ipc_get_layouts(c, layouts, layouts_len); + else if (msg_type == IPC_TYPE_RUN_COMMAND) { + if (ipc_run_command(c, msg) < 0) return -1; + ipc_send_events(mons, lastselmon, selmon); + } else if (msg_type == IPC_TYPE_GET_DWM_CLIENT) { + if (ipc_get_dwm_client(c, msg, mons) < 0) return -1; + } else if (msg_type == IPC_TYPE_SUBSCRIBE) { + if (ipc_subscribe(c, msg) < 0) return -1; + } else { + fprintf(stderr, "Invalid message type received from fd %d", fd); + ipc_prepare_reply_failure(c, msg_type, "Invalid message type: %d", + msg_type); + } + free(msg); + } else { + fprintf(stderr, "Epoll event returned %d from fd %d\n", ev->events, fd); + return -1; + } + + return 0; +} + +int +ipc_handle_socket_epoll_event(struct epoll_event *ev) +{ + if (!(ev->events & EPOLLIN)) return -1; + + // EPOLLIN means incoming client connection request + fputs("Received EPOLLIN event on socket\n", stderr); + int new_fd = ipc_accept_client(); + + return new_fd; +} @@ -0,0 +1,320 @@ +#ifndef IPC_H_ +#define IPC_H_ + +#include <stdint.h> +#include <sys/epoll.h> +#include <yajl/yajl_gen.h> + +#include "IPCClient.h" + +// clang-format off +#define IPC_MAGIC "DWM-IPC" +#define IPC_MAGIC_ARR { 'D', 'W', 'M', '-', 'I', 'P', 'C'} +#define IPC_MAGIC_LEN 7 // Not including null char + +#define IPCCOMMAND(FUNC, ARGC, TYPES) \ + { #FUNC, {FUNC }, ARGC, (ArgType[ARGC])TYPES } +// clang-format on + +typedef enum IPCMessageType { + IPC_TYPE_RUN_COMMAND = 0, + IPC_TYPE_GET_MONITORS = 1, + IPC_TYPE_GET_TAGS = 2, + IPC_TYPE_GET_LAYOUTS = 3, + IPC_TYPE_GET_DWM_CLIENT = 4, + IPC_TYPE_SUBSCRIBE = 5, + IPC_TYPE_EVENT = 6 +} IPCMessageType; + +typedef enum IPCEvent { + IPC_EVENT_TAG_CHANGE = 1 << 0, + IPC_EVENT_CLIENT_FOCUS_CHANGE = 1 << 1, + IPC_EVENT_LAYOUT_CHANGE = 1 << 2, + IPC_EVENT_MONITOR_FOCUS_CHANGE = 1 << 3, + IPC_EVENT_FOCUSED_TITLE_CHANGE = 1 << 4, + IPC_EVENT_FOCUSED_STATE_CHANGE = 1 << 5 +} IPCEvent; + +typedef enum IPCSubscriptionAction { + IPC_ACTION_UNSUBSCRIBE = 0, + IPC_ACTION_SUBSCRIBE = 1 +} IPCSubscriptionAction; + +/** + * Every IPC packet starts with this structure + */ +typedef struct dwm_ipc_header { + uint8_t magic[IPC_MAGIC_LEN]; + uint32_t size; + uint8_t type; +} __attribute((packed)) dwm_ipc_header_t; + +typedef enum ArgType { + ARG_TYPE_NONE = 0, + ARG_TYPE_UINT = 1, + ARG_TYPE_SINT = 2, + ARG_TYPE_FLOAT = 3, + ARG_TYPE_PTR = 4, + ARG_TYPE_STR = 5 +} ArgType; + +/** + * An IPCCommand function can have either of these function signatures + */ +typedef union ArgFunction { + void (*single_param)(const Arg *); + void (*array_param)(const Arg *, int); +} ArgFunction; + +typedef struct IPCCommand { + char *name; + ArgFunction func; + unsigned int argc; + ArgType *arg_types; +} IPCCommand; + +typedef struct IPCParsedCommand { + char *name; + Arg *args; + ArgType *arg_types; + unsigned int argc; +} IPCParsedCommand; + +/** + * Initialize the IPC socket and the IPC module + * + * @param socket_path Path to create the socket at + * @param epoll_fd File descriptor for epoll + * @param commands Address of IPCCommands array defined in config.h + * @param commands_len Length of commands[] array + * + * @return int The file descriptor of the socket if it was successfully created, + * -1 otherwise + */ +int ipc_init(const char *socket_path, const int p_epoll_fd, + IPCCommand commands[], const int commands_len); + +/** + * Uninitialize the socket and module. Free allocated memory and restore static + * variables to their state before ipc_init + */ +void ipc_cleanup(); + +/** + * Get the file descriptor of the IPC socket + * + * @return int File descriptor of IPC socket, -1 if socket not created. + */ +int ipc_get_sock_fd(); + +/** + * Get address to IPCClient with specified file descriptor + * + * @param fd File descriptor of IPC Client + * + * @return Address to IPCClient with specified file descriptor, -1 otherwise + */ +IPCClient *ipc_get_client(int fd); + +/** + * Check if an IPC client exists with the specified file descriptor + * + * @param fd File descriptor + * + * @return int 1 if client exists, 0 otherwise + */ +int ipc_is_client_registered(int fd); + +/** + * Disconnect an IPCClient from the socket and remove the client from the list + * of known connected clients + * + * @param c Address of IPCClient + * + * @return 0 if the client's file descriptor was closed successfully, the + * result of executing close() on the file descriptor otherwise. + */ +int ipc_drop_client(IPCClient *c); + +/** + * Accept an IPC Client requesting to connect to the socket and add it to the + * list of clients + * + * @return File descriptor of new client, -1 on error + */ +int ipc_accept_client(); + +/** + * Read an incoming message from an accepted IPC client + * + * @param c Address of IPCClient + * @param msg_type Address to IPCMessageType variable which will be assigned + * the message type of the received message + * @param msg_size Address to uint32_t variable which will be assigned the size + * of the received message + * @param msg Address to char* variable which will be assigned the address of + * the received message. This must be freed using free(). + * + * @return 0 on success, -1 on error reading message, -2 if reading the message + * resulted in EAGAIN, EINTR, or EWOULDBLOCK. + */ +int ipc_read_client(IPCClient *c, IPCMessageType *msg_type, uint32_t *msg_size, + char **msg); + +/** + * Write any pending buffer of the client to the client's socket + * + * @param c Client whose buffer to write + * + * @return Number of bytes written >= 0, -1 otherwise. errno will still be set + * from the write operation. + */ +ssize_t ipc_write_client(IPCClient *c); + +/** + * Prepare a message in the specified client's buffer. + * + * @param c Client to prepare message for + * @param msg_type Type of message to prepare + * @param msg_size Size of the message in bytes. Should not exceed + * MAX_MESSAGE_SIZE + * @param msg Message to prepare (not including header). This pointer can be + * freed after the function invocation. + */ +void ipc_prepare_send_message(IPCClient *c, const IPCMessageType msg_type, + const uint32_t msg_size, const char *msg); + +/** + * Prepare an error message in the specified client's buffer + * + * @param c Client to prepare message for + * @param msg_type Type of message + * @param format Format string following vsprintf + * @param ... Arguments for format string + */ +void ipc_prepare_reply_failure(IPCClient *c, IPCMessageType msg_type, + const char *format, ...); + +/** + * Prepare a success message in the specified client's buffer + * + * @param c Client to prepare message for + * @param msg_type Type of message + */ +void ipc_prepare_reply_success(IPCClient *c, IPCMessageType msg_type); + +/** + * Send a tag_change_event to all subscribers. Should be called only when there + * has been a tag state change. + * + * @param mon_num The index of the monitor (Monitor.num property) + * @param old_state The old tag state + * @param new_state The new (now current) tag state + */ +void ipc_tag_change_event(const int mon_num, TagState old_state, + TagState new_state); + +/** + * Send a client_focus_change_event to all subscribers. Should be called only + * when the client focus changes. + * + * @param mon_num The index of the monitor (Monitor.num property) + * @param old_client The old DWM client selection (Monitor.oldsel) + * @param new_client The new (now current) DWM client selection + */ +void ipc_client_focus_change_event(const int mon_num, Client *old_client, + Client *new_client); + +/** + * Send a layout_change_event to all subscribers. Should be called only + * when there has been a layout change. + * + * @param mon_num The index of the monitor (Monitor.num property) + * @param old_symbol The old layout symbol + * @param old_layout Address to the old Layout + * @param new_symbol The new (now current) layout symbol + * @param new_layout Address to the new Layout + */ +void ipc_layout_change_event(const int mon_num, const char *old_symbol, + const Layout *old_layout, const char *new_symbol, + const Layout *new_layout); + +/** + * Send a monitor_focus_change_event to all subscribers. Should be called only + * when the monitor focus changes. + * + * @param last_mon_num The index of the previously selected monitor + * @param new_mon_num The index of the newly selected monitor + */ +void ipc_monitor_focus_change_event(const int last_mon_num, + const int new_mon_num); + +/** + * Send a focused_title_change_event to all subscribers. Should only be called + * if a selected client has a title change. + * + * @param mon_num Index of the client's monitor + * @param client_id Window XID of client + * @param old_name Old name of the client window + * @param new_name New name of the client window + */ +void ipc_focused_title_change_event(const int mon_num, const Window client_id, + const char *old_name, const char *new_name); + +/** + * Send a focused_state_change_event to all subscribers. Should only be called + * if a selected client has a state change. + * + * @param mon_num Index of the client's monitor + * @param client_id Window XID of client + * @param old_state Old state of the client + * @param new_state New state of the client + */ +void ipc_focused_state_change_event(const int mon_num, const Window client_id, + const ClientState *old_state, + const ClientState *new_state); +/** + * Check to see if an event has occured and call the *_change_event functions + * accordingly + * + * @param mons Address of Monitor pointing to start of linked list + * @param lastselmon Address of pointer to previously selected monitor + * @param selmon Address of selected Monitor + */ +void ipc_send_events(Monitor *mons, Monitor **lastselmon, Monitor *selmon); + +/** + * Handle an epoll event caused by a registered IPC client. Read, process, and + * handle any received messages from clients. Write pending buffer to client if + * the client is ready to receive messages. Drop clients that have sent an + * EPOLLHUP. + * + * @param ev Associated epoll event returned by epoll_wait + * @param mons Address of Monitor pointing to start of linked list + * @param selmon Address of selected Monitor + * @param lastselmon Address of pointer to previously selected monitor + * @param tags Array of tag names + * @param tags_len Length of tags array + * @param layouts Array of available layouts + * @param layouts_len Length of layouts array + * + * @return 0 if event was successfully handled, -1 on any error receiving + * or handling incoming messages or unhandled epoll event. + */ +int ipc_handle_client_epoll_event(struct epoll_event *ev, Monitor *mons, + Monitor **lastselmon, Monitor *selmon, + const char *tags[], const int tags_len, + const Layout *layouts, const int layouts_len); + +/** + * Handle an epoll event caused by the IPC socket. This function only handles an + * EPOLLIN event indicating a new client requesting to connect to the socket. + * + * @param ev Associated epoll event returned by epoll_wait + * + * @return 0, if the event was successfully handled, -1 if not an EPOLLIN event + * or if a new IPC client connection request could not be accepted. + */ +int ipc_handle_socket_epoll_event(struct epoll_event *ev); + +#endif /* IPC_H_ */ diff --git a/patches/dwm-ipc-20201106-f04cac6.diff b/patches/dwm-ipc-20201106-f04cac6.diff new file mode 100644 index 0000000..5d947f6 --- /dev/null +++ b/patches/dwm-ipc-20201106-f04cac6.diff @@ -0,0 +1,3246 @@ +From 9c4c16485ac374583a1055ff7c26cba53ac92c05 Mon Sep 17 00:00:00 2001 +From: mihirlad55 <mihirlad55@gmail.com> +Date: Fri, 6 Nov 2020 17:13:42 +0000 +Subject: [PATCH] Add IPC support through a unix socket + +This patch currently supports the following requests: +* Run custom commands with arguments (similar to key bind functions) +* Get monitor properties +* Get all available layouts +* Get available tags +* Get client properties +* Subscribe to tag change, client focus change, and layout change, + monitor focus change, focused title change, and client state change + events + +This patch includes a dwm-msg cli program that supports all of the +above requests for easy integration into shell scripts. + +The messages are sent in a JSON format to promote integration to +increase scriptability in languages like Python/JavaScript. + +The patch requires YAJL for JSON parsing and a system with epoll +support. Portability is planned to be increased in the future. + +This patch is best applied after all other patches to avoid merge +conflicts. + +For more info on the IPC implementation and how to send/receive +messages, documentation can be found at +https://github.com/mihirlad55/dwm-ipc +--- + IPCClient.c | 66 +++ + IPCClient.h | 61 +++ + Makefile | 10 +- + config.def.h | 18 + + config.mk | 8 +- + dwm-msg.c | 548 +++++++++++++++++++++++ + dwm.c | 150 ++++++- + ipc.c | 1202 ++++++++++++++++++++++++++++++++++++++++++++++++++ + ipc.h | 320 ++++++++++++++ + util.c | 135 ++++++ + util.h | 10 + + yajl_dumps.c | 351 +++++++++++++++ + yajl_dumps.h | 65 +++ + 13 files changed, 2931 insertions(+), 13 deletions(-) + create mode 100644 IPCClient.c + create mode 100644 IPCClient.h + create mode 100644 dwm-msg.c + create mode 100644 ipc.c + create mode 100644 ipc.h + create mode 100644 yajl_dumps.c + create mode 100644 yajl_dumps.h + +diff --git a/IPCClient.c b/IPCClient.c +new file mode 100644 +index 0000000..0d3eefb +--- /dev/null ++++ b/IPCClient.c +@@ -0,0 +1,66 @@ ++#include "IPCClient.h" ++ ++#include <string.h> ++#include <sys/epoll.h> ++ ++#include "util.h" ++ ++IPCClient * ++ipc_client_new(int fd) ++{ ++ IPCClient *c = (IPCClient *)malloc(sizeof(IPCClient)); ++ ++ if (c == NULL) return NULL; ++ ++ // Initialize struct ++ memset(&c->event, 0, sizeof(struct epoll_event)); ++ ++ c->buffer_size = 0; ++ c->buffer = NULL; ++ c->fd = fd; ++ c->event.data.fd = fd; ++ c->next = NULL; ++ c->prev = NULL; ++ c->subscriptions = 0; ++ ++ return c; ++} ++ ++void ++ipc_list_add_client(IPCClientList *list, IPCClient *nc) ++{ ++ DEBUG("Adding client with fd %d to list\n", nc->fd); ++ ++ if (*list == NULL) { ++ // List is empty, point list at first client ++ *list = nc; ++ } else { ++ IPCClient *c; ++ // Go to last client in list ++ for (c = *list; c && c->next; c = c->next) ++ ; ++ c->next = nc; ++ nc->prev = c; ++ } ++} ++ ++void ++ipc_list_remove_client(IPCClientList *list, IPCClient *c) ++{ ++ IPCClient *cprev = c->prev; ++ IPCClient *cnext = c->next; ++ ++ if (cprev != NULL) cprev->next = c->next; ++ if (cnext != NULL) cnext->prev = c->prev; ++ if (c == *list) *list = c->next; ++} ++ ++IPCClient * ++ipc_list_get_client(IPCClientList list, int fd) ++{ ++ for (IPCClient *c = list; c; c = c->next) { ++ if (c->fd == fd) return c; ++ } ++ ++ return NULL; ++} +diff --git a/IPCClient.h b/IPCClient.h +new file mode 100644 +index 0000000..307dfba +--- /dev/null ++++ b/IPCClient.h +@@ -0,0 +1,61 @@ ++#ifndef IPC_CLIENT_H_ ++#define IPC_CLIENT_H_ ++ ++#include <stdio.h> ++#include <stdlib.h> ++#include <sys/epoll.h> ++ ++typedef struct IPCClient IPCClient; ++/** ++ * This structure contains the details of an IPC Client and pointers for a ++ * linked list ++ */ ++struct IPCClient { ++ int fd; ++ int subscriptions; ++ ++ char *buffer; ++ uint32_t buffer_size; ++ ++ struct epoll_event event; ++ IPCClient *next; ++ IPCClient *prev; ++}; ++ ++typedef IPCClient *IPCClientList; ++ ++/** ++ * Allocate memory for new IPCClient with the specified file descriptor and ++ * initialize struct. ++ * ++ * @param fd File descriptor of IPC client ++ * ++ * @return Address to allocated IPCClient struct ++ */ ++IPCClient *ipc_client_new(int fd); ++ ++/** ++ * Add an IPC Client to the specified list ++ * ++ * @param list Address of the list to add the client to ++ * @param nc Address of the IPCClient ++ */ ++void ipc_list_add_client(IPCClientList *list, IPCClient *nc); ++ ++/** ++ * Remove an IPCClient from the specified list ++ * ++ * @param list Address of the list to remove the client from ++ * @param c Address of the IPCClient ++ */ ++void ipc_list_remove_client(IPCClientList *list, IPCClient *c); ++ ++/** ++ * Get an IPCClient from the specified IPCClient list ++ * ++ * @param list List to remove the client from ++ * @param fd File descriptor of the IPCClient ++ */ ++IPCClient *ipc_list_get_client(IPCClientList list, int fd); ++ ++#endif // IPC_CLIENT_H_ +diff --git a/Makefile b/Makefile +index 77bcbc0..0456754 100644 +--- a/Makefile ++++ b/Makefile +@@ -6,7 +6,7 @@ include config.mk + SRC = drw.c dwm.c util.c + OBJ = ${SRC:.c=.o} + +-all: options dwm ++all: options dwm dwm-msg + + options: + @echo dwm build options: +@@ -25,8 +25,11 @@ config.h: + dwm: ${OBJ} + ${CC} -o $@ ${OBJ} ${LDFLAGS} + ++dwm-msg: dwm-msg.o ++ ${CC} -o $@ $< ${LDFLAGS} ++ + clean: +- rm -f dwm ${OBJ} dwm-${VERSION}.tar.gz ++ rm -f dwm dwm-msg ${OBJ} dwm-${VERSION}.tar.gz + + dist: clean + mkdir -p dwm-${VERSION} +@@ -38,8 +41,9 @@ dist: clean + + install: all + mkdir -p ${DESTDIR}${PREFIX}/bin +- cp -f dwm ${DESTDIR}${PREFIX}/bin ++ cp -f dwm dwm-msg ${DESTDIR}${PREFIX}/bin + chmod 755 ${DESTDIR}${PREFIX}/bin/dwm ++ chmod 755 ${DESTDIR}${PREFIX}/bin/dwm-msg + mkdir -p ${DESTDIR}${MANPREFIX}/man1 + sed "s/VERSION/${VERSION}/g" < dwm.1 > ${DESTDIR}${MANPREFIX}/man1/dwm.1 + chmod 644 ${DESTDIR}${MANPREFIX}/man1/dwm.1 +diff --git a/config.def.h b/config.def.h +index 1c0b587..059a831 100644 +--- a/config.def.h ++++ b/config.def.h +@@ -113,3 +113,21 @@ static Button buttons[] = { + { ClkTagBar, MODKEY, Button3, toggletag, {0} }, + }; + ++static const char *ipcsockpath = "/tmp/dwm.sock"; ++static IPCCommand ipccommands[] = { ++ IPCCOMMAND( view, 1, {ARG_TYPE_UINT} ), ++ IPCCOMMAND( toggleview, 1, {ARG_TYPE_UINT} ), ++ IPCCOMMAND( tag, 1, {ARG_TYPE_UINT} ), ++ IPCCOMMAND( toggletag, 1, {ARG_TYPE_UINT} ), ++ IPCCOMMAND( tagmon, 1, {ARG_TYPE_UINT} ), ++ IPCCOMMAND( focusmon, 1, {ARG_TYPE_SINT} ), ++ IPCCOMMAND( focusstack, 1, {ARG_TYPE_SINT} ), ++ IPCCOMMAND( zoom, 1, {ARG_TYPE_NONE} ), ++ IPCCOMMAND( incnmaster, 1, {ARG_TYPE_SINT} ), ++ IPCCOMMAND( killclient, 1, {ARG_TYPE_SINT} ), ++ IPCCOMMAND( togglefloating, 1, {ARG_TYPE_NONE} ), ++ IPCCOMMAND( setmfact, 1, {ARG_TYPE_FLOAT} ), ++ IPCCOMMAND( setlayoutsafe, 1, {ARG_TYPE_PTR} ), ++ IPCCOMMAND( quit, 1, {ARG_TYPE_NONE} ) ++}; ++ +diff --git a/config.mk b/config.mk +index 7084c33..8570938 100644 +--- a/config.mk ++++ b/config.mk +@@ -20,9 +20,13 @@ FREETYPEINC = /usr/include/freetype2 + # OpenBSD (uncomment) + #FREETYPEINC = ${X11INC}/freetype2 + ++# yajl ++YAJLLIBS = -lyajl ++YAJLINC = /usr/include/yajl ++ + # includes and libs +-INCS = -I${X11INC} -I${FREETYPEINC} +-LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} ++INCS = -I${X11INC} -I${FREETYPEINC} -I${YAJLINC} ++LIBS = -L${X11LIB} -lX11 ${XINERAMALIBS} ${FREETYPELIBS} ${YAJLLIBS} + + # flags + CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_POSIX_C_SOURCE=200809L -DVERSION=\"${VERSION}\" ${XINERAMAFLAGS} +diff --git a/dwm-msg.c b/dwm-msg.c +new file mode 100644 +index 0000000..1971d32 +--- /dev/null ++++ b/dwm-msg.c +@@ -0,0 +1,548 @@ ++#include <ctype.h> ++#include <errno.h> ++#include <inttypes.h> ++#include <stdarg.h> ++#include <stdint.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <string.h> ++#include <sys/socket.h> ++#include <sys/un.h> ++#include <unistd.h> ++#include <yajl/yajl_gen.h> ++ ++#define IPC_MAGIC "DWM-IPC" ++// clang-format off ++#define IPC_MAGIC_ARR { 'D', 'W', 'M', '-', 'I', 'P', 'C' } ++// clang-format on ++#define IPC_MAGIC_LEN 7 // Not including null char ++ ++#define IPC_EVENT_TAG_CHANGE "tag_change_event" ++#define IPC_EVENT_CLIENT_FOCUS_CHANGE "client_focus_change_event" ++#define IPC_EVENT_LAYOUT_CHANGE "layout_change_event" ++#define IPC_EVENT_MONITOR_FOCUS_CHANGE "monitor_focus_change_event" ++#define IPC_EVENT_FOCUSED_TITLE_CHANGE "focused_title_change_event" ++#define IPC_EVENT_FOCUSED_STATE_CHANGE "focused_state_change_event" ++ ++#define YSTR(str) yajl_gen_string(gen, (unsigned char *)str, strlen(str)) ++#define YINT(num) yajl_gen_integer(gen, num) ++#define YDOUBLE(num) yajl_gen_double(gen, num) ++#define YBOOL(v) yajl_gen_bool(gen, v) ++#define YNULL() yajl_gen_null(gen) ++#define YARR(body) \ ++ { \ ++ yajl_gen_array_open(gen); \ ++ body; \ ++ yajl_gen_array_close(gen); \ ++ } ++#define YMAP(body) \ ++ { \ ++ yajl_gen_map_open(gen); \ ++ body; \ ++ yajl_gen_map_close(gen); \ ++ } ++ ++typedef unsigned long Window; ++ ++const char *DEFAULT_SOCKET_PATH = "/tmp/dwm.sock"; ++static int sock_fd = -1; ++static unsigned int ignore_reply = 0; ++ ++typedef enum IPCMessageType { ++ IPC_TYPE_RUN_COMMAND = 0, ++ IPC_TYPE_GET_MONITORS = 1, ++ IPC_TYPE_GET_TAGS = 2, ++ IPC_TYPE_GET_LAYOUTS = 3, ++ IPC_TYPE_GET_DWM_CLIENT = 4, ++ IPC_TYPE_SUBSCRIBE = 5, ++ IPC_TYPE_EVENT = 6 ++} IPCMessageType; ++ ++// Every IPC message must begin with this ++typedef struct dwm_ipc_header { ++ uint8_t magic[IPC_MAGIC_LEN]; ++ uint32_t size; ++ uint8_t type; ++} __attribute((packed)) dwm_ipc_header_t; ++ ++static int ++recv_message(uint8_t *msg_type, uint32_t *reply_size, uint8_t **reply) ++{ ++ uint32_t read_bytes = 0; ++ const int32_t to_read = sizeof(dwm_ipc_header_t); ++ char header[to_read]; ++ char *walk = header; ++ ++ // Try to read header ++ while (read_bytes < to_read) { ++ ssize_t n = read(sock_fd, header + read_bytes, to_read - read_bytes); ++ ++ if (n == 0) { ++ if (read_bytes == 0) { ++ fprintf(stderr, "Unexpectedly reached EOF while reading header."); ++ fprintf(stderr, ++ "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", ++ read_bytes, to_read); ++ return -2; ++ } else { ++ fprintf(stderr, "Unexpectedly reached EOF while reading header."); ++ fprintf(stderr, ++ "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", ++ read_bytes, to_read); ++ return -3; ++ } ++ } else if (n == -1) { ++ return -1; ++ } ++ ++ read_bytes += n; ++ } ++ ++ // Check if magic string in header matches ++ if (memcmp(walk, IPC_MAGIC, IPC_MAGIC_LEN) != 0) { ++ fprintf(stderr, "Invalid magic string. Got '%.*s', expected '%s'\n", ++ IPC_MAGIC_LEN, walk, IPC_MAGIC); ++ return -3; ++ } ++ ++ walk += IPC_MAGIC_LEN; ++ ++ // Extract reply size ++ memcpy(reply_size, walk, sizeof(uint32_t)); ++ walk += sizeof(uint32_t); ++ ++ // Extract message type ++ memcpy(msg_type, walk, sizeof(uint8_t)); ++ walk += sizeof(uint8_t); ++ ++ (*reply) = malloc(*reply_size); ++ ++ // Extract payload ++ read_bytes = 0; ++ while (read_bytes < *reply_size) { ++ ssize_t n = read(sock_fd, *reply + read_bytes, *reply_size - read_bytes); ++ ++ if (n == 0) { ++ fprintf(stderr, "Unexpectedly reached EOF while reading payload."); ++ fprintf(stderr, "Read %" PRIu32 " bytes, expected %" PRIu32 " bytes.\n", ++ read_bytes, *reply_size); ++ free(*reply); ++ return -2; ++ } else if (n == -1) { ++ if (errno == EINTR || errno == EAGAIN) continue; ++ free(*reply); ++ return -1; ++ } ++ ++ read_bytes += n; ++ } ++ ++ return 0; ++} ++ ++static int ++read_socket(IPCMessageType *msg_type, uint32_t *msg_size, char **msg) ++{ ++ int ret = -1; ++ ++ while (ret != 0) { ++ ret = recv_message((uint8_t *)msg_type, msg_size, (uint8_t **)msg); ++ ++ if (ret < 0) { ++ // Try again (non-fatal error) ++ if (ret == -1 && (errno == EINTR || errno == EAGAIN)) continue; ++ ++ fprintf(stderr, "Error receiving response from socket. "); ++ fprintf(stderr, "The connection might have been lost.\n"); ++ exit(2); ++ } ++ } ++ ++ return 0; ++} ++ ++static ssize_t ++write_socket(const void *buf, size_t count) ++{ ++ size_t written = 0; ++ ++ while (written < count) { ++ const ssize_t n = ++ write(sock_fd, ((uint8_t *)buf) + written, count - written); ++ ++ if (n == -1) { ++ if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) ++ continue; ++ else ++ return n; ++ } ++ written += n; ++ } ++ return written; ++} ++ ++static void ++connect_to_socket() ++{ ++ struct sockaddr_un addr; ++ ++ int sock = socket(AF_UNIX, SOCK_STREAM, 0); ++ ++ // Initialize struct to 0 ++ memset(&addr, 0, sizeof(struct sockaddr_un)); ++ ++ addr.sun_family = AF_UNIX; ++ strcpy(addr.sun_path, DEFAULT_SOCKET_PATH); ++ ++ connect(sock, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)); ++ ++ sock_fd = sock; ++} ++ ++static int ++send_message(IPCMessageType msg_type, uint32_t msg_size, uint8_t *msg) ++{ ++ dwm_ipc_header_t header = { ++ .magic = IPC_MAGIC_ARR, .size = msg_size, .type = msg_type}; ++ ++ size_t header_size = sizeof(dwm_ipc_header_t); ++ size_t total_size = header_size + msg_size; ++ ++ uint8_t buffer[total_size]; ++ ++ // Copy header to buffer ++ memcpy(buffer, &header, header_size); ++ // Copy message to buffer ++ memcpy(buffer + header_size, msg, header.size); ++ ++ write_socket(buffer, total_size); ++ ++ return 0; ++} ++ ++static int ++is_float(const char *s) ++{ ++ size_t len = strlen(s); ++ int is_dot_used = 0; ++ int is_minus_used = 0; ++ ++ // Floats can only have one decimal point in between or digits ++ // Optionally, floats can also be below zero (negative) ++ for (int i = 0; i < len; i++) { ++ if (isdigit(s[i])) ++ continue; ++ else if (!is_dot_used && s[i] == '.' && i != 0 && i != len - 1) { ++ is_dot_used = 1; ++ continue; ++ } else if (!is_minus_used && s[i] == '-' && i == 0) { ++ is_minus_used = 1; ++ continue; ++ } else ++ return 0; ++ } ++ ++ return 1; ++} ++ ++static int ++is_unsigned_int(const char *s) ++{ ++ size_t len = strlen(s); ++ ++ // Unsigned int can only have digits ++ for (int i = 0; i < len; i++) { ++ if (isdigit(s[i])) ++ continue; ++ else ++ return 0; ++ } ++ ++ return 1; ++} ++ ++static int ++is_signed_int(const char *s) ++{ ++ size_t len = strlen(s); ++ ++ // Signed int can only have digits and a negative sign at the start ++ for (int i = 0; i < len; i++) { ++ if (isdigit(s[i])) ++ continue; ++ else if (i == 0 && s[i] == '-') { ++ continue; ++ } else ++ return 0; ++ } ++ ++ return 1; ++} ++ ++static void ++flush_socket_reply() ++{ ++ IPCMessageType reply_type; ++ uint32_t reply_size; ++ char *reply; ++ ++ read_socket(&reply_type, &reply_size, &reply); ++ ++ free(reply); ++} ++ ++static void ++print_socket_reply() ++{ ++ IPCMessageType reply_type; ++ uint32_t reply_size; ++ char *reply; ++ ++ read_socket(&reply_type, &reply_size, &reply); ++ ++ printf("%.*s\n", reply_size, reply); ++ fflush(stdout); ++ free(reply); ++} ++ ++static int ++run_command(const char *name, char *args[], int argc) ++{ ++ const unsigned char *msg; ++ size_t msg_size; ++ ++ yajl_gen gen = yajl_gen_alloc(NULL); ++ ++ // Message format: ++ // { ++ // "command": "<name>", ++ // "args": [ ... ] ++ // } ++ // clang-format off ++ YMAP( ++ YSTR("command"); YSTR(name); ++ YSTR("args"); YARR( ++ for (int i = 0; i < argc; i++) { ++ if (is_signed_int(args[i])) { ++ long long num = atoll(args[i]); ++ YINT(num); ++ } else if (is_float(args[i])) { ++ float num = atof(args[i]); ++ YDOUBLE(num); ++ } else { ++ YSTR(args[i]); ++ } ++ } ++ ) ++ ) ++ // clang-format on ++ ++ yajl_gen_get_buf(gen, &msg, &msg_size); ++ ++ send_message(IPC_TYPE_RUN_COMMAND, msg_size, (uint8_t *)msg); ++ ++ if (!ignore_reply) ++ print_socket_reply(); ++ else ++ flush_socket_reply(); ++ ++ yajl_gen_free(gen); ++ ++ return 0; ++} ++ ++static int ++get_monitors() ++{ ++ send_message(IPC_TYPE_GET_MONITORS, 1, (uint8_t *)""); ++ print_socket_reply(); ++ return 0; ++} ++ ++static int ++get_tags() ++{ ++ send_message(IPC_TYPE_GET_TAGS, 1, (uint8_t *)""); ++ print_socket_reply(); ++ ++ return 0; ++} ++ ++static int ++get_layouts() ++{ ++ send_message(IPC_TYPE_GET_LAYOUTS, 1, (uint8_t *)""); ++ print_socket_reply(); ++ ++ return 0; ++} ++ ++static int ++get_dwm_client(Window win) ++{ ++ const unsigned char *msg; ++ size_t msg_size; ++ ++ yajl_gen gen = yajl_gen_alloc(NULL); ++ ++ // Message format: ++ // { ++ // "client_window_id": "<win>" ++ // } ++ // clang-format off ++ YMAP( ++ YSTR("client_window_id"); YINT(win); ++ ) ++ // clang-format on ++ ++ yajl_gen_get_buf(gen, &msg, &msg_size); ++ ++ send_message(IPC_TYPE_GET_DWM_CLIENT, msg_size, (uint8_t *)msg); ++ ++ print_socket_reply(); ++ ++ yajl_gen_free(gen); ++ ++ return 0; ++} ++ ++static int ++subscribe(const char *event) ++{ ++ const unsigned char *msg; ++ size_t msg_size; ++ ++ yajl_gen gen = yajl_gen_alloc(NULL); ++ ++ // Message format: ++ // { ++ // "event": "<event>", ++ // "action": "subscribe" ++ // } ++ // clang-format off ++ YMAP( ++ YSTR("event"); YSTR(event); ++ YSTR("action"); YSTR("subscribe"); ++ ) ++ // clang-format on ++ ++ yajl_gen_get_buf(gen, &msg, &msg_size); ++ ++ send_message(IPC_TYPE_SUBSCRIBE, msg_size, (uint8_t *)msg); ++ ++ if (!ignore_reply) ++ print_socket_reply(); ++ else ++ flush_socket_reply(); ++ ++ yajl_gen_free(gen); ++ ++ return 0; ++} ++ ++static void ++usage_error(const char *prog_name, const char *format, ...) ++{ ++ va_list args; ++ va_start(args, format); ++ ++ fprintf(stderr, "Error: "); ++ vfprintf(stderr, format, args); ++ fprintf(stderr, "\nusage: %s <command> [...]\n", prog_name); ++ fprintf(stderr, "Try '%s help'\n", prog_name); ++ ++ va_end(args); ++ exit(1); ++} ++ ++static void ++print_usage(const char *name) ++{ ++ printf("usage: %s [options] <command> [...]\n", name); ++ puts(""); ++ puts("Commands:"); ++ puts(" run_command <name> [args...] Run an IPC command"); ++ puts(""); ++ puts(" get_monitors Get monitor properties"); ++ puts(""); ++ puts(" get_tags Get list of tags"); ++ puts(""); ++ puts(" get_layouts Get list of layouts"); ++ puts(""); ++ puts(" get_dwm_client <window_id> Get dwm client proprties"); ++ puts(""); ++ puts(" subscribe [events...] Subscribe to specified events"); ++ puts(" Options: " IPC_EVENT_TAG_CHANGE ","); ++ puts(" " IPC_EVENT_LAYOUT_CHANGE ","); ++ puts(" " IPC_EVENT_CLIENT_FOCUS_CHANGE ","); ++ puts(" " IPC_EVENT_MONITOR_FOCUS_CHANGE ","); ++ puts(" " IPC_EVENT_FOCUSED_TITLE_CHANGE ","); ++ puts(" " IPC_EVENT_FOCUSED_STATE_CHANGE); ++ puts(""); ++ puts(" help Display this message"); ++ puts(""); ++ puts("Options:"); ++ puts(" --ignore-reply Don't print reply messages from"); ++ puts(" run_command and subscribe."); ++ puts(""); ++} ++ ++int ++main(int argc, char *argv[]) ++{ ++ const char *prog_name = argv[0]; ++ ++ connect_to_socket(); ++ if (sock_fd == -1) { ++ fprintf(stderr, "Failed to connect to socket\n"); ++ return 1; ++ } ++ ++ int i = 1; ++ if (i < argc && strcmp(argv[i], "--ignore-reply") == 0) { ++ ignore_reply = 1; ++ i++; ++ } ++ ++ if (i >= argc) usage_error(prog_name, "Expected an argument, got none"); ++ ++ if (strcmp(argv[i], "help") == 0) ++ print_usage(prog_name); ++ else if (strcmp(argv[i], "run_command") == 0) { ++ if (++i >= argc) usage_error(prog_name, "No command specified"); ++ // Command name ++ char *command = argv[i]; ++ // Command arguments are everything after command name ++ char **command_args = argv + ++i; ++ // Number of command arguments ++ int command_argc = argc - i; ++ run_command(command, command_args, command_argc); ++ } else if (strcmp(argv[i], "get_monitors") == 0) { ++ get_monitors(); ++ } else if (strcmp(argv[i], "get_tags") == 0) { ++ get_tags(); ++ } else if (strcmp(argv[i], "get_layouts") == 0) { ++ get_layouts(); ++ } else if (strcmp(argv[i], "get_dwm_client") == 0) { ++ if (++i < argc) { ++ if (is_unsigned_int(argv[i])) { ++ Window win = atol(argv[i]); ++ get_dwm_client(win); ++ } else ++ usage_error(prog_name, "Expected unsigned integer argument"); ++ } else ++ usage_error(prog_name, "Expected the window id"); ++ } else if (strcmp(argv[i], "subscribe") == 0) { ++ if (++i < argc) { ++ for (int j = i; j < argc; j++) subscribe(argv[j]); ++ } else ++ usage_error(prog_name, "Expected event name"); ++ // Keep listening for events forever ++ while (1) { ++ print_socket_reply(); ++ } ++ } else ++ usage_error(prog_name, "Invalid argument '%s'", argv[i]); ++ ++ return 0; ++} +diff --git a/dwm.c b/dwm.c +index 9fd0286..c90c61a 100644 +--- a/dwm.c ++++ b/dwm.c +@@ -30,6 +30,7 @@ + #include <unistd.h> + #include <sys/types.h> + #include <sys/wait.h> ++#include <sys/epoll.h> + #include <X11/cursorfont.h> + #include <X11/keysym.h> + #include <X11/Xatom.h> +@@ -67,9 +68,21 @@ enum { WMProtocols, WMDelete, WMState, WMTakeFocus, WMLast }; /* default atoms * + enum { ClkTagBar, ClkLtSymbol, ClkStatusText, ClkWinTitle, + ClkClientWin, ClkRootWin, ClkLast }; /* clicks */ + ++typedef struct TagState TagState; ++struct TagState { ++ int selected; ++ int occupied; ++ int urgent; ++}; ++ ++typedef struct ClientState ClientState; ++struct ClientState { ++ int isfixed, isfloating, isurgent, neverfocus, oldstate, isfullscreen; ++}; ++ + typedef union { +- int i; +- unsigned int ui; ++ long i; ++ unsigned long ui; + float f; + const void *v; + } Arg; +@@ -97,6 +110,7 @@ struct Client { + Client *snext; + Monitor *mon; + Window win; ++ ClientState prevstate; + }; + + typedef struct { +@@ -111,8 +125,10 @@ typedef struct { + void (*arrange)(Monitor *); + } Layout; + ++ + struct Monitor { + char ltsymbol[16]; ++ char lastltsymbol[16]; + float mfact; + int nmaster; + int num; +@@ -122,14 +138,17 @@ struct Monitor { + unsigned int seltags; + unsigned int sellt; + unsigned int tagset[2]; ++ TagState tagstate; + int showbar; + int topbar; + Client *clients; + Client *sel; ++ Client *lastsel; + Client *stack; + Monitor *next; + Window barwin; + const Layout *lt[2]; ++ const Layout *lastlt; + }; + + typedef struct { +@@ -175,6 +194,7 @@ static long getstate(Window w); + static int gettextprop(Window w, Atom atom, char *text, unsigned int size); + static void grabbuttons(Client *c, int focused); + static void grabkeys(void); ++static int handlexevent(struct epoll_event *ev); + static void incnmaster(const Arg *arg); + static void keypress(XEvent *e); + static void killclient(const Arg *arg); +@@ -201,8 +221,10 @@ static void setclientstate(Client *c, long state); + static void setfocus(Client *c); + static void setfullscreen(Client *c, int fullscreen); + static void setlayout(const Arg *arg); ++static void setlayoutsafe(const Arg *arg); + static void setmfact(const Arg *arg); + static void setup(void); ++static void setupepoll(void); + static void seturgent(Client *c, int urg); + static void showhide(Client *c); + static void sigchld(int unused); +@@ -261,17 +283,27 @@ static void (*handler[LASTEvent]) (XEvent *) = { + [UnmapNotify] = unmapnotify + }; + static Atom wmatom[WMLast], netatom[NetLast]; ++static int epoll_fd; ++static int dpy_fd; + static int running = 1; + static Cur *cursor[CurLast]; + static Clr **scheme; + static Display *dpy; + static Drw *drw; +-static Monitor *mons, *selmon; ++static Monitor *mons, *selmon, *lastselmon; + static Window root, wmcheckwin; + ++#include "ipc.h" ++ + /* configuration, allows nested code to access above variables */ + #include "config.h" + ++#ifdef VERSION ++#include "IPCClient.c" ++#include "yajl_dumps.c" ++#include "ipc.c" ++#endif ++ + /* compile-time check if all tags fit into an unsigned int bit array. */ + struct NumTags { char limitexceeded[LENGTH(tags) > 31 ? -1 : 1]; }; + +@@ -492,6 +524,12 @@ cleanup(void) + XSync(dpy, False); + XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime); + XDeleteProperty(dpy, root, netatom[NetActiveWindow]); ++ ++ ipc_cleanup(); ++ ++ if (close(epoll_fd) < 0) { ++ fprintf(stderr, "Failed to close epoll file descriptor\n"); ++ } + } + + void +@@ -964,6 +1002,25 @@ grabkeys(void) + } + } + ++int ++handlexevent(struct epoll_event *ev) ++{ ++ if (ev->events & EPOLLIN) { ++ XEvent ev; ++ while (running && XPending(dpy)) { ++ XNextEvent(dpy, &ev); ++ if (handler[ev.type]) { ++ handler[ev.type](&ev); /* call handler */ ++ ipc_send_events(mons, &lastselmon, selmon); ++ } ++ } ++ } else if (ev-> events & EPOLLHUP) { ++ return -1; ++ } ++ ++ return 0; ++} ++ + void + incnmaster(const Arg *arg) + { +@@ -1373,12 +1430,40 @@ restack(Monitor *m) + void + run(void) + { +- XEvent ev; +- /* main event loop */ ++ int event_count = 0; ++ const int MAX_EVENTS = 10; ++ struct epoll_event events[MAX_EVENTS]; ++ + XSync(dpy, False); +- while (running && !XNextEvent(dpy, &ev)) +- if (handler[ev.type]) +- handler[ev.type](&ev); /* call handler */ ++ ++ /* main event loop */ ++ while (running) { ++ event_count = epoll_wait(epoll_fd, events, MAX_EVENTS, -1); ++ ++ for (int i = 0; i < event_count; i++) { ++ int event_fd = events[i].data.fd; ++ DEBUG("Got event from fd %d\n", event_fd); ++ ++ if (event_fd == dpy_fd) { ++ // -1 means EPOLLHUP ++ if (handlexevent(events + i) == -1) ++ return; ++ } else if (event_fd == ipc_get_sock_fd()) { ++ ipc_handle_socket_epoll_event(events + i); ++ } else if (ipc_is_client_registered(event_fd)){ ++ if (ipc_handle_client_epoll_event(events + i, mons, &lastselmon, selmon, ++ tags, LENGTH(tags), layouts, LENGTH(layouts)) < 0) { ++ fprintf(stderr, "Error handling IPC event on fd %d\n", event_fd); ++ } ++ } else { ++ fprintf(stderr, "Got event from unknown fd %d, ptr %p, u32 %d, u64 %lu", ++ event_fd, events[i].data.ptr, events[i].data.u32, ++ events[i].data.u64); ++ fprintf(stderr, " with events %d\n", events[i].events); ++ return; ++ } ++ } ++ } + } + + void +@@ -1512,6 +1597,18 @@ setlayout(const Arg *arg) + drawbar(selmon); + } + ++void ++setlayoutsafe(const Arg *arg) ++{ ++ const Layout *ltptr = (Layout *)arg->v; ++ if (ltptr == 0) ++ setlayout(arg); ++ for (int i = 0; i < LENGTH(layouts); i++) { ++ if (ltptr == &layouts[i]) ++ setlayout(arg); ++ } ++} ++ + /* arg > 1.0 will set mfact absolutely */ + void + setmfact(const Arg *arg) +@@ -1595,8 +1692,37 @@ setup(void) + XSelectInput(dpy, root, wa.event_mask); + grabkeys(); + focus(NULL); ++ setupepoll(); + } + ++void ++setupepoll(void) ++{ ++ epoll_fd = epoll_create1(0); ++ dpy_fd = ConnectionNumber(dpy); ++ struct epoll_event dpy_event; ++ ++ // Initialize struct to 0 ++ memset(&dpy_event, 0, sizeof(dpy_event)); ++ ++ DEBUG("Display socket is fd %d\n", dpy_fd); ++ ++ if (epoll_fd == -1) { ++ fputs("Failed to create epoll file descriptor", stderr); ++ } ++ ++ dpy_event.events = EPOLLIN; ++ dpy_event.data.fd = dpy_fd; ++ if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, dpy_fd, &dpy_event)) { ++ fputs("Failed to add display file descriptor to epoll", stderr); ++ close(epoll_fd); ++ exit(1); ++ } ++ ++ if (ipc_init(ipcsockpath, epoll_fd, ipccommands, LENGTH(ipccommands)) < 0) { ++ fputs("Failed to initialize IPC\n", stderr); ++ } ++} + + void + seturgent(Client *c, int urg) +@@ -1998,10 +2124,18 @@ updatestatus(void) + void + updatetitle(Client *c) + { ++ char oldname[sizeof(c->name)]; ++ strcpy(oldname, c->name); ++ + if (!gettextprop(c->win, netatom[NetWMName], c->name, sizeof c->name)) + gettextprop(c->win, XA_WM_NAME, c->name, sizeof c->name); + if (c->name[0] == '\0') /* hack to mark broken clients */ + strcpy(c->name, broken); ++ ++ for (Monitor *m = mons; m; m = m->next) { ++ if (m->sel == c && strcmp(oldname, c->name) != 0) ++ ipc_focused_title_change_event(m->num, c->win, oldname, c->name); ++ } + } + + void +diff --git a/ipc.c b/ipc.c +new file mode 100644 +index 0000000..c404791 +--- /dev/null ++++ b/ipc.c +@@ -0,0 +1,1202 @@ ++#include "ipc.h" ++ ++#include <errno.h> ++#include <fcntl.h> ++#include <inttypes.h> ++#include <stdarg.h> ++#include <stdio.h> ++#include <stdlib.h> ++#include <sys/epoll.h> ++#include <sys/socket.h> ++#include <sys/un.h> ++#include <unistd.h> ++#include <yajl/yajl_gen.h> ++#include <yajl/yajl_tree.h> ++ ++#include "util.h" ++#include "yajl_dumps.h" ++ ++static struct sockaddr_un sockaddr; ++static struct epoll_event sock_epoll_event; ++static IPCClientList ipc_clients = NULL; ++static int epoll_fd = -1; ++static int sock_fd = -1; ++static IPCCommand *ipc_commands; ++static unsigned int ipc_commands_len; ++// Max size is 1 MB ++static const uint32_t MAX_MESSAGE_SIZE = 1000000; ++static const int IPC_SOCKET_BACKLOG = 5; ++ ++/** ++ * Create IPC socket at specified path and return file descriptor to socket. ++ * This initializes the static variable sockaddr. ++ */ ++static int ++ipc_create_socket(const char *filename) ++{ ++ char *normal_filename; ++ char *parent; ++ const size_t addr_size = sizeof(struct sockaddr_un); ++ const int sock_type = SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC; ++ ++ normalizepath(filename, &normal_filename); ++ ++ // In case socket file exists ++ unlink(normal_filename); ++ ++ // For portability clear the addr structure, since some implementations have ++ // nonstandard fields in the structure ++ memset(&sockaddr, 0, addr_size); ++ ++ parentdir(normal_filename, &parent); ++ // Create parent directories ++ mkdirp(parent); ++ free(parent); ++ ++ sockaddr.sun_family = AF_LOCAL; ++ strcpy(sockaddr.sun_path, normal_filename); ++ free(normal_filename); ++ ++ sock_fd = socket(AF_LOCAL, sock_type, 0); ++ if (sock_fd == -1) { ++ fputs("Failed to create socket\n", stderr); ++ return -1; ++ } ++ ++ DEBUG("Created socket at %s\n", sockaddr.sun_path); ++ ++ if (bind(sock_fd, (const struct sockaddr *)&sockaddr, addr_size) == -1) { ++ fputs("Failed to bind socket\n", stderr); ++ return -1; ++ } ++ ++ DEBUG("Socket binded\n"); ++ ++ if (listen(sock_fd, IPC_SOCKET_BACKLOG) < 0) { ++ fputs("Failed to listen for connections on socket\n", stderr); ++ return -1; ++ } ++ ++ DEBUG("Now listening for connections on socket\n"); ++ ++ return sock_fd; ++} ++ ++/** ++ * Internal function used to receive IPC messages from a given file descriptor. ++ * ++ * Returns -1 on error reading (could be EAGAIN or EINTR) ++ * Returns -2 if EOF before header could be read ++ * Returns -3 if invalid IPC header ++ * Returns -4 if message length exceeds MAX_MESSAGE_SIZE ++ */ ++static int ++ipc_recv_message(int fd, uint8_t *msg_type, uint32_t *reply_size, ++ uint8_t **reply) ++{ ++ uint32_t read_bytes = 0; ++ const int32_t to_read = sizeof(dwm_ipc_header_t); ++ char header[to_read]; ++ char *walk = header; ++ ++ // Try to read header ++ while (read_bytes < to_read) { ++ const ssize_t n = read(fd, header + read_bytes, to_read - read_bytes); ++ ++ if (n == 0) { ++ if (read_bytes == 0) { ++ fprintf(stderr, "Unexpectedly reached EOF while reading header."); ++ fprintf(stderr, ++ "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", ++ read_bytes, to_read); ++ return -2; ++ } else { ++ fprintf(stderr, "Unexpectedly reached EOF while reading header."); ++ fprintf(stderr, ++ "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.\n", ++ read_bytes, to_read); ++ return -3; ++ } ++ } else if (n == -1) { ++ // errno will still be set ++ return -1; ++ } ++ ++ read_bytes += n; ++ } ++ ++ // Check if magic string in header matches ++ if (memcmp(walk, IPC_MAGIC, IPC_MAGIC_LEN) != 0) { ++ fprintf(stderr, "Invalid magic string. Got '%.*s', expected '%s'\n", ++ IPC_MAGIC_LEN, walk, IPC_MAGIC); ++ return -3; ++ } ++ ++ walk += IPC_MAGIC_LEN; ++ ++ // Extract reply size ++ memcpy(reply_size, walk, sizeof(uint32_t)); ++ walk += sizeof(uint32_t); ++ ++ if (*reply_size > MAX_MESSAGE_SIZE) { ++ fprintf(stderr, "Message too long: %" PRIu32 " bytes. ", *reply_size); ++ fprintf(stderr, "Maximum message size is: %d\n", MAX_MESSAGE_SIZE); ++ return -4; ++ } ++ ++ // Extract message type ++ memcpy(msg_type, walk, sizeof(uint8_t)); ++ walk += sizeof(uint8_t); ++ ++ if (*reply_size > 0) ++ (*reply) = malloc(*reply_size); ++ else ++ return 0; ++ ++ read_bytes = 0; ++ while (read_bytes < *reply_size) { ++ const ssize_t n = read(fd, *reply + read_bytes, *reply_size - read_bytes); ++ ++ if (n == 0) { ++ fprintf(stderr, "Unexpectedly reached EOF while reading payload."); ++ fprintf(stderr, "Read %" PRIu32 " bytes, expected %" PRIu32 " bytes.\n", ++ read_bytes, *reply_size); ++ free(*reply); ++ return -2; ++ } else if (n == -1) { ++ // TODO: Should we return and wait for another epoll event? ++ // This would require saving the partial read in some way. ++ if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) continue; ++ ++ free(*reply); ++ return -1; ++ } ++ ++ read_bytes += n; ++ } ++ ++ return 0; ++} ++ ++/** ++ * Internal function used to write a buffer to a file descriptor ++ * ++ * Returns number of bytes written if successful write ++ * Returns 0 if no bytes were written due to EAGAIN or EWOULDBLOCK ++ * Returns -1 on unknown error trying to write, errno will carry over from ++ * write() call ++ */ ++static ssize_t ++ipc_write_message(int fd, const void *buf, size_t count) ++{ ++ size_t written = 0; ++ ++ while (written < count) { ++ const ssize_t n = write(fd, (uint8_t *)buf + written, count - written); ++ ++ if (n == -1) { ++ if (errno == EAGAIN || errno == EWOULDBLOCK) ++ return written; ++ else if (errno == EINTR) ++ continue; ++ else ++ return n; ++ } ++ ++ written += n; ++ DEBUG("Wrote %zu/%zu to client at fd %d\n", written, count, fd); ++ } ++ ++ return written; ++} ++ ++/** ++ * Initialization for generic event message. This is used to allocate the yajl ++ * handle, set yajl options, and in the future any other initialization that ++ * should occur for event messages. ++ */ ++static void ++ipc_event_init_message(yajl_gen *gen) ++{ ++ *gen = yajl_gen_alloc(NULL); ++ yajl_gen_config(*gen, yajl_gen_beautify, 1); ++} ++ ++/** ++ * Prepares buffers of IPC subscribers of specified event using buffer from yajl ++ * handle. ++ */ ++static void ++ipc_event_prepare_send_message(yajl_gen gen, IPCEvent event) ++{ ++ const unsigned char *buffer; ++ size_t len = 0; ++ ++ yajl_gen_get_buf(gen, &buffer, &len); ++ len++; // For null char ++ ++ for (IPCClient *c = ipc_clients; c; c = c->next) { ++ if (c->subscriptions & event) { ++ DEBUG("Sending selected client change event to fd %d\n", c->fd); ++ ipc_prepare_send_message(c, IPC_TYPE_EVENT, len, (char *)buffer); ++ } ++ } ++ ++ // Not documented, but this frees temp_buffer ++ yajl_gen_free(gen); ++} ++ ++/** ++ * Initialization for generic reply message. This is used to allocate the yajl ++ * handle, set yajl options, and in the future any other initialization that ++ * should occur for reply messages. ++ */ ++static void ++ipc_reply_init_message(yajl_gen *gen) ++{ ++ *gen = yajl_gen_alloc(NULL); ++ yajl_gen_config(*gen, yajl_gen_beautify, 1); ++} ++ ++/** ++ * Prepares the IPC client's buffer with a message using the buffer of the yajl ++ * handle. ++ */ ++static void ++ipc_reply_prepare_send_message(yajl_gen gen, IPCClient *c, ++ IPCMessageType msg_type) ++{ ++ const unsigned char *buffer; ++ size_t len = 0; ++ ++ yajl_gen_get_buf(gen, &buffer, &len); ++ len++; // For null char ++ ++ ipc_prepare_send_message(c, msg_type, len, (const char *)buffer); ++ ++ // Not documented, but this frees temp_buffer ++ yajl_gen_free(gen); ++} ++ ++/** ++ * Find the IPCCommand with the specified name ++ * ++ * Returns 0 if a command with the specified name was found ++ * Returns -1 if a command with the specified name could not be found ++ */ ++static int ++ipc_get_ipc_command(const char *name, IPCCommand *ipc_command) ++{ ++ for (int i = 0; i < ipc_commands_len; i++) { ++ if (strcmp(ipc_commands[i].name, name) == 0) { ++ *ipc_command = ipc_commands[i]; ++ return 0; ++ } ++ } ++ ++ return -1; ++} ++ ++/** ++ * Parse a IPC_TYPE_RUN_COMMAND message from a client. This function extracts ++ * the arguments, argument count, argument types, and command name and returns ++ * the parsed information as an IPCParsedCommand. If this function returns ++ * successfully, the parsed_command must be freed using ++ * ipc_free_parsed_command_members. ++ * ++ * Returns 0 if the message was successfully parsed ++ * Returns -1 otherwise ++ */ ++static int ++ipc_parse_run_command(char *msg, IPCParsedCommand *parsed_command) ++{ ++ char error_buffer[1000]; ++ yajl_val parent = yajl_tree_parse(msg, error_buffer, 1000); ++ ++ if (parent == NULL) { ++ fputs("Failed to parse command from client\n", stderr); ++ fprintf(stderr, "%s\n", error_buffer); ++ fprintf(stderr, "Tried to parse: %s\n", msg); ++ return -1; ++ } ++ ++ // Format: ++ // { ++ // "command": "<command name>" ++ // "args": [ "arg1", "arg2", ... ] ++ // } ++ const char *command_path[] = {"command", 0}; ++ yajl_val command_val = yajl_tree_get(parent, command_path, yajl_t_string); ++ ++ if (command_val == NULL) { ++ fputs("No command key found in client message\n", stderr); ++ yajl_tree_free(parent); ++ return -1; ++ } ++ ++ const char *command_name = YAJL_GET_STRING(command_val); ++ size_t command_name_len = strlen(command_name); ++ parsed_command->name = (char *)malloc((command_name_len + 1) * sizeof(char)); ++ strcpy(parsed_command->name, command_name); ++ ++ DEBUG("Received command: %s\n", parsed_command->name); ++ ++ const char *args_path[] = {"args", 0}; ++ yajl_val args_val = yajl_tree_get(parent, args_path, yajl_t_array); ++ ++ if (args_val == NULL) { ++ fputs("No args key found in client message\n", stderr); ++ yajl_tree_free(parent); ++ return -1; ++ } ++ ++ unsigned int *argc = &parsed_command->argc; ++ Arg **args = &parsed_command->args; ++ ArgType **arg_types = &parsed_command->arg_types; ++ ++ *argc = args_val->u.array.len; ++ ++ // If no arguments are specified, make a dummy argument to pass to the ++ // function. This is just the way dwm's void(Arg*) functions are setup. ++ if (*argc == 0) { ++ *args = (Arg *)malloc(sizeof(Arg)); ++ *arg_types = (ArgType *)malloc(sizeof(ArgType)); ++ (*arg_types)[0] = ARG_TYPE_NONE; ++ (*args)[0].i = 0; ++ (*argc)++; ++ } else if (*argc > 0) { ++ *args = (Arg *)calloc(*argc, sizeof(Arg)); ++ *arg_types = (ArgType *)malloc(*argc * sizeof(ArgType)); ++ ++ for (int i = 0; i < *argc; i++) { ++ yajl_val arg_val = args_val->u.array.values[i]; ++ ++ if (YAJL_IS_NUMBER(arg_val)) { ++ if (YAJL_IS_INTEGER(arg_val)) { ++ // Any values below 0 must be a signed int ++ if (YAJL_GET_INTEGER(arg_val) < 0) { ++ (*args)[i].i = YAJL_GET_INTEGER(arg_val); ++ (*arg_types)[i] = ARG_TYPE_SINT; ++ DEBUG("i=%ld\n", (*args)[i].i); ++ // Any values above 0 should be an unsigned int ++ } else if (YAJL_GET_INTEGER(arg_val) >= 0) { ++ (*args)[i].ui = YAJL_GET_INTEGER(arg_val); ++ (*arg_types)[i] = ARG_TYPE_UINT; ++ DEBUG("ui=%ld\n", (*args)[i].i); ++ } ++ // If the number is not an integer, it must be a float ++ } else { ++ (*args)[i].f = (float)YAJL_GET_DOUBLE(arg_val); ++ (*arg_types)[i] = ARG_TYPE_FLOAT; ++ DEBUG("f=%f\n", (*args)[i].f); ++ // If argument is not a number, it must be a string ++ } ++ } else if (YAJL_IS_STRING(arg_val)) { ++ char *arg_s = YAJL_GET_STRING(arg_val); ++ size_t arg_s_size = (strlen(arg_s) + 1) * sizeof(char); ++ (*args)[i].v = (char *)malloc(arg_s_size); ++ (*arg_types)[i] = ARG_TYPE_STR; ++ strcpy((char *)(*args)[i].v, arg_s); ++ } ++ } ++ } ++ ++ yajl_tree_free(parent); ++ ++ return 0; ++} ++ ++/** ++ * Free the members of a IPCParsedCommand struct ++ */ ++static void ++ipc_free_parsed_command_members(IPCParsedCommand *command) ++{ ++ for (int i = 0; i < command->argc; i++) { ++ if (command->arg_types[i] == ARG_TYPE_STR) free((void *)command->args[i].v); ++ } ++ free(command->args); ++ free(command->arg_types); ++ free(command->name); ++} ++ ++/** ++ * Check if the given arguments are the correct length and type. Also do any ++ * casting to correct the types. ++ * ++ * Returns 0 if the arguments were the correct length and types ++ * Returns -1 if the argument count doesn't match ++ * Returns -2 if the argument types don't match ++ */ ++static int ++ipc_validate_run_command(IPCParsedCommand *parsed, const IPCCommand actual) ++{ ++ if (actual.argc != parsed->argc) return -1; ++ ++ for (int i = 0; i < parsed->argc; i++) { ++ ArgType ptype = parsed->arg_types[i]; ++ ArgType atype = actual.arg_types[i]; ++ ++ if (ptype != atype) { ++ if (ptype == ARG_TYPE_UINT && atype == ARG_TYPE_PTR) ++ // If this argument is supposed to be a void pointer, cast it ++ parsed->args[i].v = (void *)parsed->args[i].ui; ++ else if (ptype == ARG_TYPE_UINT && atype == ARG_TYPE_SINT) ++ // If this argument is supposed to be a signed int, cast it ++ parsed->args[i].i = parsed->args[i].ui; ++ else ++ return -2; ++ } ++ } ++ ++ return 0; ++} ++ ++/** ++ * Convert event name to their IPCEvent equivalent enum value ++ * ++ * Returns 0 if a valid event name was given ++ * Returns -1 otherwise ++ */ ++static int ++ipc_event_stoi(const char *subscription, IPCEvent *event) ++{ ++ if (strcmp(subscription, "tag_change_event") == 0) ++ *event = IPC_EVENT_TAG_CHANGE; ++ else if (strcmp(subscription, "client_focus_change_event") == 0) ++ *event = IPC_EVENT_CLIENT_FOCUS_CHANGE; ++ else if (strcmp(subscription, "layout_change_event") == 0) ++ *event = IPC_EVENT_LAYOUT_CHANGE; ++ else if (strcmp(subscription, "monitor_focus_change_event") == 0) ++ *event = IPC_EVENT_MONITOR_FOCUS_CHANGE; ++ else if (strcmp(subscription, "focused_title_change_event") == 0) ++ *event = IPC_EVENT_FOCUSED_TITLE_CHANGE; ++ else if (strcmp(subscription, "focused_state_change_event") == 0) ++ *event = IPC_EVENT_FOCUSED_STATE_CHANGE; ++ else ++ return -1; ++ return 0; ++} ++ ++/** ++ * Parse a IPC_TYPE_SUBSCRIBE message from a client. This function extracts the ++ * event name and the subscription action from the message. ++ * ++ * Returns 0 if message was successfully parsed ++ * Returns -1 otherwise ++ */ ++static int ++ipc_parse_subscribe(const char *msg, IPCSubscriptionAction *subscribe, ++ IPCEvent *event) ++{ ++ char error_buffer[100]; ++ yajl_val parent = yajl_tree_parse((char *)msg, error_buffer, 100); ++ ++ if (parent == NULL) { ++ fputs("Failed to parse command from client\n", stderr); ++ fprintf(stderr, "%s\n", error_buffer); ++ return -1; ++ } ++ ++ // Format: ++ // { ++ // "event": "<event name>" ++ // "action": "<subscribe|unsubscribe>" ++ // } ++ const char *event_path[] = {"event", 0}; ++ yajl_val event_val = yajl_tree_get(parent, event_path, yajl_t_string); ++ ++ if (event_val == NULL) { ++ fputs("No 'event' key found in client message\n", stderr); ++ return -1; ++ } ++ ++ const char *event_str = YAJL_GET_STRING(event_val); ++ DEBUG("Received event: %s\n", event_str); ++ ++ if (ipc_event_stoi(event_str, event) < 0) return -1; ++ ++ const char *action_path[] = {"action", 0}; ++ yajl_val action_val = yajl_tree_get(parent, action_path, yajl_t_string); ++ ++ if (action_val == NULL) { ++ fputs("No 'action' key found in client message\n", stderr); ++ return -1; ++ } ++ ++ const char *action = YAJL_GET_STRING(action_val); ++ ++ if (strcmp(action, "subscribe") == 0) ++ *subscribe = IPC_ACTION_SUBSCRIBE; ++ else if (strcmp(action, "unsubscribe") == 0) ++ *subscribe = IPC_ACTION_UNSUBSCRIBE; ++ else { ++ fputs("Invalid action specified for subscription\n", stderr); ++ return -1; ++ } ++ ++ yajl_tree_free(parent); ++ ++ return 0; ++} ++ ++/** ++ * Parse an IPC_TYPE_GET_DWM_CLIENT message from a client. This function ++ * extracts the window id from the message. ++ * ++ * Returns 0 if message was successfully parsed ++ * Returns -1 otherwise ++ */ ++static int ++ipc_parse_get_dwm_client(const char *msg, Window *win) ++{ ++ char error_buffer[100]; ++ ++ yajl_val parent = yajl_tree_parse(msg, error_buffer, 100); ++ ++ if (parent == NULL) { ++ fputs("Failed to parse message from client\n", stderr); ++ fprintf(stderr, "%s\n", error_buffer); ++ return -1; ++ } ++ ++ // Format: ++ // { ++ // "client_window_id": <client window id> ++ // } ++ const char *win_path[] = {"client_window_id", 0}; ++ yajl_val win_val = yajl_tree_get(parent, win_path, yajl_t_number); ++ ++ if (win_val == NULL) { ++ fputs("No client window id found in client message\n", stderr); ++ return -1; ++ } ++ ++ *win = YAJL_GET_INTEGER(win_val); ++ ++ yajl_tree_free(parent); ++ ++ return 0; ++} ++ ++/** ++ * Called when an IPC_TYPE_RUN_COMMAND message is received from a client. This ++ * function parses, executes the given command, and prepares a reply message to ++ * the client indicating success/failure. ++ * ++ * NOTE: There is currently no check for argument validity beyond the number of ++ * arguments given and types of arguments. There is also no way to check if the ++ * function succeeded based on dwm's void(const Arg*) function types. Pointer ++ * arguments can cause crashes if they are not validated in the function itself. ++ * ++ * Returns 0 if message was successfully parsed ++ * Returns -1 on failure parsing message ++ */ ++static int ++ipc_run_command(IPCClient *ipc_client, char *msg) ++{ ++ IPCParsedCommand parsed_command; ++ IPCCommand ipc_command; ++ ++ // Initialize struct ++ memset(&parsed_command, 0, sizeof(IPCParsedCommand)); ++ ++ if (ipc_parse_run_command(msg, &parsed_command) < 0) { ++ ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, ++ "Failed to parse run command"); ++ return -1; ++ } ++ ++ if (ipc_get_ipc_command(parsed_command.name, &ipc_command) < 0) { ++ ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, ++ "Command %s not found", parsed_command.name); ++ ipc_free_parsed_command_members(&parsed_command); ++ return -1; ++ } ++ ++ int res = ipc_validate_run_command(&parsed_command, ipc_command); ++ if (res < 0) { ++ if (res == -1) ++ ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, ++ "%u arguments provided, %u expected", ++ parsed_command.argc, ipc_command.argc); ++ else if (res == -2) ++ ipc_prepare_reply_failure(ipc_client, IPC_TYPE_RUN_COMMAND, ++ "Type mismatch"); ++ ipc_free_parsed_command_members(&parsed_command); ++ return -1; ++ } ++ ++ if (parsed_command.argc == 1) ++ ipc_command.func.single_param(parsed_command.args); ++ else if (parsed_command.argc > 1) ++ ipc_command.func.array_param(parsed_command.args, parsed_command.argc); ++ ++ DEBUG("Called function for command %s\n", parsed_command.name); ++ ++ ipc_free_parsed_command_members(&parsed_command); ++ ++ ipc_prepare_reply_success(ipc_client, IPC_TYPE_RUN_COMMAND); ++ return 0; ++} ++ ++/** ++ * Called when an IPC_TYPE_GET_MONITORS message is received from a client. It ++ * prepares a reply with the properties of all of the monitors in JSON. ++ */ ++static void ++ipc_get_monitors(IPCClient *c, Monitor *mons, Monitor *selmon) ++{ ++ yajl_gen gen; ++ ipc_reply_init_message(&gen); ++ dump_monitors(gen, mons, selmon); ++ ++ ipc_reply_prepare_send_message(gen, c, IPC_TYPE_GET_MONITORS); ++} ++ ++/** ++ * Called when an IPC_TYPE_GET_TAGS message is received from a client. It ++ * prepares a reply with info about all the tags in JSON. ++ */ ++static void ++ipc_get_tags(IPCClient *c, const char *tags[], const int tags_len) ++{ ++ yajl_gen gen; ++ ipc_reply_init_message(&gen); ++ ++ dump_tags(gen, tags, tags_len); ++ ++ ipc_reply_prepare_send_message(gen, c, IPC_TYPE_GET_TAGS); ++} ++ ++/** ++ * Called when an IPC_TYPE_GET_LAYOUTS message is received from a client. It ++ * prepares a reply with a JSON array of available layouts ++ */ ++static void ++ipc_get_layouts(IPCClient *c, const Layout layouts[], const int layouts_len) ++{ ++ yajl_gen gen; ++ ipc_reply_init_message(&gen); ++ ++ dump_layouts(gen, layouts, layouts_len); ++ ++ ipc_reply_prepare_send_message(gen, c, IPC_TYPE_GET_LAYOUTS); ++} ++ ++/** ++ * Called when an IPC_TYPE_GET_DWM_CLIENT message is received from a client. It ++ * prepares a JSON reply with the properties of the client with the specified ++ * window XID. ++ * ++ * Returns 0 if the message was successfully parsed and if the client with the ++ * specified window XID was found ++ * Returns -1 if the message could not be parsed ++ */ ++static int ++ipc_get_dwm_client(IPCClient *ipc_client, const char *msg, const Monitor *mons) ++{ ++ Window win; ++ ++ if (ipc_parse_get_dwm_client(msg, &win) < 0) return -1; ++ ++ // Find client with specified window XID ++ for (const Monitor *m = mons; m; m = m->next) ++ for (Client *c = m->clients; c; c = c->next) ++ if (c->win == win) { ++ yajl_gen gen; ++ ipc_reply_init_message(&gen); ++ ++ dump_client(gen, c); ++ ++ ipc_reply_prepare_send_message(gen, ipc_client, ++ IPC_TYPE_GET_DWM_CLIENT); ++ ++ return 0; ++ } ++ ++ ipc_prepare_reply_failure(ipc_client, IPC_TYPE_GET_DWM_CLIENT, ++ "Client with window id %d not found", win); ++ return -1; ++} ++ ++/** ++ * Called when an IPC_TYPE_SUBSCRIBE message is received from a client. It ++ * subscribes/unsubscribes the client from the specified event and replies with ++ * the result. ++ * ++ * Returns 0 if the message was successfully parsed. ++ * Returns -1 if the message could not be parsed ++ */ ++static int ++ipc_subscribe(IPCClient *c, const char *msg) ++{ ++ IPCSubscriptionAction action = IPC_ACTION_SUBSCRIBE; ++ IPCEvent event = 0; ++ ++ if (ipc_parse_subscribe(msg, &action, &event)) { ++ ipc_prepare_reply_failure(c, IPC_TYPE_SUBSCRIBE, "Event does not exist"); ++ return -1; ++ } ++ ++ if (action == IPC_ACTION_SUBSCRIBE) { ++ DEBUG("Subscribing client on fd %d to %d\n", c->fd, event); ++ c->subscriptions |= event; ++ } else if (action == IPC_ACTION_UNSUBSCRIBE) { ++ DEBUG("Unsubscribing client on fd %d to %d\n", c->fd, event); ++ c->subscriptions ^= event; ++ } else { ++ ipc_prepare_reply_failure(c, IPC_TYPE_SUBSCRIBE, ++ "Invalid subscription action"); ++ return -1; ++ } ++ ++ ipc_prepare_reply_success(c, IPC_TYPE_SUBSCRIBE); ++ return 0; ++} ++ ++int ++ipc_init(const char *socket_path, const int p_epoll_fd, IPCCommand commands[], ++ const int commands_len) ++{ ++ // Initialize struct to 0 ++ memset(&sock_epoll_event, 0, sizeof(sock_epoll_event)); ++ ++ int socket_fd = ipc_create_socket(socket_path); ++ if (socket_fd < 0) return -1; ++ ++ ipc_commands = commands; ++ ipc_commands_len = commands_len; ++ ++ epoll_fd = p_epoll_fd; ++ ++ // Wake up to incoming connection requests ++ sock_epoll_event.data.fd = socket_fd; ++ sock_epoll_event.events = EPOLLIN; ++ if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &sock_epoll_event)) { ++ fputs("Failed to add sock file descriptor to epoll", stderr); ++ return -1; ++ } ++ ++ return socket_fd; ++} ++ ++void ++ipc_cleanup() ++{ ++ IPCClient *c = ipc_clients; ++ // Free clients and their buffers ++ while (c) { ++ ipc_drop_client(c); ++ c = ipc_clients; ++ } ++ ++ // Stop waking up for socket events ++ epoll_ctl(epoll_fd, EPOLL_CTL_DEL, sock_fd, &sock_epoll_event); ++ ++ // Uninitialize all static variables ++ epoll_fd = -1; ++ sock_fd = -1; ++ ipc_commands = NULL; ++ ipc_commands_len = 0; ++ memset(&sock_epoll_event, 0, sizeof(struct epoll_event)); ++ memset(&sockaddr, 0, sizeof(struct sockaddr_un)); ++ ++ // Delete socket ++ unlink(sockaddr.sun_path); ++ ++ shutdown(sock_fd, SHUT_RDWR); ++ close(sock_fd); ++} ++ ++int ++ipc_get_sock_fd() ++{ ++ return sock_fd; ++} ++ ++IPCClient * ++ipc_get_client(int fd) ++{ ++ return ipc_list_get_client(ipc_clients, fd); ++} ++ ++int ++ipc_is_client_registered(int fd) ++{ ++ return (ipc_get_client(fd) != NULL); ++} ++ ++int ++ipc_accept_client() ++{ ++ int fd = -1; ++ ++ struct sockaddr_un client_addr; ++ socklen_t len = 0; ++ ++ // For portability clear the addr structure, since some implementations ++ // have nonstandard fields in the structure ++ memset(&client_addr, 0, sizeof(struct sockaddr_un)); ++ ++ fd = accept(sock_fd, (struct sockaddr *)&client_addr, &len); ++ if (fd < 0 && errno != EINTR) { ++ fputs("Failed to accept IPC connection from client", stderr); ++ return -1; ++ } ++ ++ if (fcntl(fd, F_SETFD, FD_CLOEXEC) < 0) { ++ shutdown(fd, SHUT_RDWR); ++ close(fd); ++ fputs("Failed to set flags on new client fd", stderr); ++ } ++ ++ IPCClient *nc = ipc_client_new(fd); ++ if (nc == NULL) return -1; ++ ++ // Wake up to messages from this client ++ nc->event.data.fd = fd; ++ nc->event.events = EPOLLIN | EPOLLHUP; ++ epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &nc->event); ++ ++ ipc_list_add_client(&ipc_clients, nc); ++ ++ DEBUG("%s%d\n", "New client at fd: ", fd); ++ ++ return fd; ++} ++ ++int ++ipc_drop_client(IPCClient *c) ++{ ++ int fd = c->fd; ++ shutdown(fd, SHUT_RDWR); ++ int res = close(fd); ++ ++ if (res == 0) { ++ struct epoll_event ev; ++ ++ // Stop waking up to messages from this client ++ epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &ev); ++ ipc_list_remove_client(&ipc_clients, c); ++ ++ free(c->buffer); ++ free(c); ++ ++ DEBUG("Successfully removed client on fd %d\n", fd); ++ } else if (res < 0 && res != EINTR) { ++ fprintf(stderr, "Failed to close fd %d\n", fd); ++ } ++ ++ return res; ++} ++ ++int ++ipc_read_client(IPCClient *c, IPCMessageType *msg_type, uint32_t *msg_size, ++ char **msg) ++{ ++ int fd = c->fd; ++ int ret = ++ ipc_recv_message(fd, (uint8_t *)msg_type, msg_size, (uint8_t **)msg); ++ ++ if (ret < 0) { ++ // This will happen if these errors occur while reading header ++ if (ret == -1 && ++ (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)) ++ return -2; ++ ++ fprintf(stderr, "Error reading message: dropping client at fd %d\n", fd); ++ ipc_drop_client(c); ++ ++ return -1; ++ } ++ ++ // Make sure receive message is null terminated to avoid parsing issues ++ if (*msg_size > 0) { ++ size_t len = *msg_size; ++ nullterminate(msg, &len); ++ *msg_size = len; ++ } ++ ++ DEBUG("[fd %d] ", fd); ++ if (*msg_size > 0) ++ DEBUG("Received message: '%.*s' ", *msg_size, *msg); ++ else ++ DEBUG("Received empty message "); ++ DEBUG("Message type: %" PRIu8 " ", (uint8_t)*msg_type); ++ DEBUG("Message size: %" PRIu32 "\n", *msg_size); ++ ++ return 0; ++} ++ ++ssize_t ++ipc_write_client(IPCClient *c) ++{ ++ const ssize_t n = ipc_write_message(c->fd, c->buffer, c->buffer_size); ++ ++ if (n < 0) return n; ++ ++ // TODO: Deal with client timeouts ++ ++ if (n == c->buffer_size) { ++ c->buffer_size = 0; ++ free(c->buffer); ++ // No dangling pointers! ++ c->buffer = NULL; ++ // Stop waking up when client is ready to receive messages ++ if (c->event.events & EPOLLOUT) { ++ c->event.events -= EPOLLOUT; ++ epoll_ctl(epoll_fd, EPOLL_CTL_MOD, c->fd, &c->event); ++ } ++ return n; ++ } ++ ++ // Shift unwritten buffer to beginning of buffer and reallocate ++ c->buffer_size -= n; ++ memmove(c->buffer, c->buffer + n, c->buffer_size); ++ c->buffer = (char *)realloc(c->buffer, c->buffer_size); ++ ++ return n; ++} ++ ++void ++ipc_prepare_send_message(IPCClient *c, const IPCMessageType msg_type, ++ const uint32_t msg_size, const char *msg) ++{ ++ dwm_ipc_header_t header = { ++ .magic = IPC_MAGIC_ARR, .type = msg_type, .size = msg_size}; ++ ++ uint32_t header_size = sizeof(dwm_ipc_header_t); ++ uint32_t packet_size = header_size + msg_size; ++ ++ if (c->buffer == NULL) ++ c->buffer = (char *)malloc(c->buffer_size + packet_size); ++ else ++ c->buffer = (char *)realloc(c->buffer, c->buffer_size + packet_size); ++ ++ // Copy header to end of client buffer ++ memcpy(c->buffer + c->buffer_size, &header, header_size); ++ c->buffer_size += header_size; ++ ++ // Copy message to end of client buffer ++ memcpy(c->buffer + c->buffer_size, msg, msg_size); ++ c->buffer_size += msg_size; ++ ++ // Wake up when client is ready to receive messages ++ c->event.events |= EPOLLOUT; ++ epoll_ctl(epoll_fd, EPOLL_CTL_MOD, c->fd, &c->event); ++} ++ ++void ++ipc_prepare_reply_failure(IPCClient *c, IPCMessageType msg_type, ++ const char *format, ...) ++{ ++ yajl_gen gen; ++ va_list args; ++ ++ // Get output size ++ va_start(args, format); ++ size_t len = vsnprintf(NULL, 0, format, args); ++ va_end(args); ++ char *buffer = (char *)malloc((len + 1) * sizeof(char)); ++ ++ ipc_reply_init_message(&gen); ++ ++ va_start(args, format); ++ vsnprintf(buffer, len + 1, format, args); ++ va_end(args); ++ dump_error_message(gen, buffer); ++ ++ ipc_reply_prepare_send_message(gen, c, msg_type); ++ fprintf(stderr, "[fd %d] Error: %s\n", c->fd, buffer); ++ ++ free(buffer); ++} ++ ++void ++ipc_prepare_reply_success(IPCClient *c, IPCMessageType msg_type) ++{ ++ const char *success_msg = "{\"result\":\"success\"}"; ++ const size_t msg_len = strlen(success_msg) + 1; // +1 for null char ++ ++ ipc_prepare_send_message(c, msg_type, msg_len, success_msg); ++} ++ ++void ++ipc_tag_change_event(int mon_num, TagState old_state, TagState new_state) ++{ ++ yajl_gen gen; ++ ipc_event_init_message(&gen); ++ dump_tag_event(gen, mon_num, old_state, new_state); ++ ipc_event_prepare_send_message(gen, IPC_EVENT_TAG_CHANGE); ++} ++ ++void ++ipc_client_focus_change_event(int mon_num, Client *old_client, ++ Client *new_client) ++{ ++ yajl_gen gen; ++ ipc_event_init_message(&gen); ++ dump_client_focus_change_event(gen, old_client, new_client, mon_num); ++ ipc_event_prepare_send_message(gen, IPC_EVENT_CLIENT_FOCUS_CHANGE); ++} ++ ++void ++ipc_layout_change_event(const int mon_num, const char *old_symbol, ++ const Layout *old_layout, const char *new_symbol, ++ const Layout *new_layout) ++{ ++ yajl_gen gen; ++ ipc_event_init_message(&gen); ++ dump_layout_change_event(gen, mon_num, old_symbol, old_layout, new_symbol, ++ new_layout); ++ ipc_event_prepare_send_message(gen, IPC_EVENT_LAYOUT_CHANGE); ++} ++ ++void ++ipc_monitor_focus_change_event(const int last_mon_num, const int new_mon_num) ++{ ++ yajl_gen gen; ++ ipc_event_init_message(&gen); ++ dump_monitor_focus_change_event(gen, last_mon_num, new_mon_num); ++ ipc_event_prepare_send_message(gen, IPC_EVENT_MONITOR_FOCUS_CHANGE); ++} ++ ++void ++ipc_focused_title_change_event(const int mon_num, const Window client_id, ++ const char *old_name, const char *new_name) ++{ ++ yajl_gen gen; ++ ipc_event_init_message(&gen); ++ dump_focused_title_change_event(gen, mon_num, client_id, old_name, new_name); ++ ipc_event_prepare_send_message(gen, IPC_EVENT_FOCUSED_TITLE_CHANGE); ++} ++ ++void ++ipc_focused_state_change_event(const int mon_num, const Window client_id, ++ const ClientState *old_state, ++ const ClientState *new_state) ++{ ++ yajl_gen gen; ++ ipc_event_init_message(&gen); ++ dump_focused_state_change_event(gen, mon_num, client_id, old_state, ++ new_state); ++ ipc_event_prepare_send_message(gen, IPC_EVENT_FOCUSED_STATE_CHANGE); ++} ++ ++void ++ipc_send_events(Monitor *mons, Monitor **lastselmon, Monitor *selmon) ++{ ++ for (Monitor *m = mons; m; m = m->next) { ++ unsigned int urg = 0, occ = 0, tagset = 0; ++ ++ for (Client *c = m->clients; c; c = c->next) { ++ occ |= c->tags; ++ ++ if (c->isurgent) urg |= c->tags; ++ } ++ tagset = m->tagset[m->seltags]; ++ ++ TagState new_state = {.selected = tagset, .occupied = occ, .urgent = urg}; ++ ++ if (memcmp(&m->tagstate, &new_state, sizeof(TagState)) != 0) { ++ ipc_tag_change_event(m->num, m->tagstate, new_state); ++ m->tagstate = new_state; ++ } ++ ++ if (m->lastsel != m->sel) { ++ ipc_client_focus_change_event(m->num, m->lastsel, m->sel); ++ m->lastsel = m->sel; ++ } ++ ++ if (strcmp(m->ltsymbol, m->lastltsymbol) != 0 || ++ m->lastlt != m->lt[m->sellt]) { ++ ipc_layout_change_event(m->num, m->lastltsymbol, m->lastlt, m->ltsymbol, ++ m->lt[m->sellt]); ++ strcpy(m->lastltsymbol, m->ltsymbol); ++ m->lastlt = m->lt[m->sellt]; ++ } ++ ++ if (*lastselmon != selmon) { ++ if (*lastselmon != NULL) ++ ipc_monitor_focus_change_event((*lastselmon)->num, selmon->num); ++ *lastselmon = selmon; ++ } ++ ++ Client *sel = m->sel; ++ if (!sel) continue; ++ ClientState *o = &m->sel->prevstate; ++ ClientState n = {.oldstate = sel->oldstate, ++ .isfixed = sel->isfixed, ++ .isfloating = sel->isfloating, ++ .isfullscreen = sel->isfullscreen, ++ .isurgent = sel->isurgent, ++ .neverfocus = sel->neverfocus}; ++ if (memcmp(o, &n, sizeof(ClientState)) != 0) { ++ ipc_focused_state_change_event(m->num, m->sel->win, o, &n); ++ *o = n; ++ } ++ } ++} ++ ++int ++ipc_handle_client_epoll_event(struct epoll_event *ev, Monitor *mons, ++ Monitor **lastselmon, Monitor *selmon, ++ const char *tags[], const int tags_len, ++ const Layout *layouts, const int layouts_len) ++{ ++ int fd = ev->data.fd; ++ IPCClient *c = ipc_get_client(fd); ++ ++ if (ev->events & EPOLLHUP) { ++ DEBUG("EPOLLHUP received from client at fd %d\n", fd); ++ ipc_drop_client(c); ++ } else if (ev->events & EPOLLOUT) { ++ DEBUG("Sending message to client at fd %d...\n", fd); ++ if (c->buffer_size) ipc_write_client(c); ++ } else if (ev->events & EPOLLIN) { ++ IPCMessageType msg_type = 0; ++ uint32_t msg_size = 0; ++ char *msg = NULL; ++ ++ DEBUG("Received message from fd %d\n", fd); ++ if (ipc_read_client(c, &msg_type, &msg_size, &msg) < 0) return -1; ++ ++ if (msg_type == IPC_TYPE_GET_MONITORS) ++ ipc_get_monitors(c, mons, selmon); ++ else if (msg_type == IPC_TYPE_GET_TAGS) ++ ipc_get_tags(c, tags, tags_len); ++ else if (msg_type == IPC_TYPE_GET_LAYOUTS) ++ ipc_get_layouts(c, layouts, layouts_len); ++ else if (msg_type == IPC_TYPE_RUN_COMMAND) { ++ if (ipc_run_command(c, msg) < 0) return -1; ++ ipc_send_events(mons, lastselmon, selmon); ++ } else if (msg_type == IPC_TYPE_GET_DWM_CLIENT) { ++ if (ipc_get_dwm_client(c, msg, mons) < 0) return -1; ++ } else if (msg_type == IPC_TYPE_SUBSCRIBE) { ++ if (ipc_subscribe(c, msg) < 0) return -1; ++ } else { ++ fprintf(stderr, "Invalid message type received from fd %d", fd); ++ ipc_prepare_reply_failure(c, msg_type, "Invalid message type: %d", ++ msg_type); ++ } ++ free(msg); ++ } else { ++ fprintf(stderr, "Epoll event returned %d from fd %d\n", ev->events, fd); ++ return -1; ++ } ++ ++ return 0; ++} ++ ++int ++ipc_handle_socket_epoll_event(struct epoll_event *ev) ++{ ++ if (!(ev->events & EPOLLIN)) return -1; ++ ++ // EPOLLIN means incoming client connection request ++ fputs("Received EPOLLIN event on socket\n", stderr); ++ int new_fd = ipc_accept_client(); ++ ++ return new_fd; ++} +diff --git a/ipc.h b/ipc.h +new file mode 100644 +index 0000000..e3b5bba +--- /dev/null ++++ b/ipc.h +@@ -0,0 +1,320 @@ ++#ifndef IPC_H_ ++#define IPC_H_ ++ ++#include <stdint.h> ++#include <sys/epoll.h> ++#include <yajl/yajl_gen.h> ++ ++#include "IPCClient.h" ++ ++// clang-format off ++#define IPC_MAGIC "DWM-IPC" ++#define IPC_MAGIC_ARR { 'D', 'W', 'M', '-', 'I', 'P', 'C'} ++#define IPC_MAGIC_LEN 7 // Not including null char ++ ++#define IPCCOMMAND(FUNC, ARGC, TYPES) \ ++ { #FUNC, {FUNC }, ARGC, (ArgType[ARGC])TYPES } ++// clang-format on ++ ++typedef enum IPCMessageType { ++ IPC_TYPE_RUN_COMMAND = 0, ++ IPC_TYPE_GET_MONITORS = 1, ++ IPC_TYPE_GET_TAGS = 2, ++ IPC_TYPE_GET_LAYOUTS = 3, ++ IPC_TYPE_GET_DWM_CLIENT = 4, ++ IPC_TYPE_SUBSCRIBE = 5, ++ IPC_TYPE_EVENT = 6 ++} IPCMessageType; ++ ++typedef enum IPCEvent { ++ IPC_EVENT_TAG_CHANGE = 1 << 0, ++ IPC_EVENT_CLIENT_FOCUS_CHANGE = 1 << 1, ++ IPC_EVENT_LAYOUT_CHANGE = 1 << 2, ++ IPC_EVENT_MONITOR_FOCUS_CHANGE = 1 << 3, ++ IPC_EVENT_FOCUSED_TITLE_CHANGE = 1 << 4, ++ IPC_EVENT_FOCUSED_STATE_CHANGE = 1 << 5 ++} IPCEvent; ++ ++typedef enum IPCSubscriptionAction { ++ IPC_ACTION_UNSUBSCRIBE = 0, ++ IPC_ACTION_SUBSCRIBE = 1 ++} IPCSubscriptionAction; ++ ++/** ++ * Every IPC packet starts with this structure ++ */ ++typedef struct dwm_ipc_header { ++ uint8_t magic[IPC_MAGIC_LEN]; ++ uint32_t size; ++ uint8_t type; ++} __attribute((packed)) dwm_ipc_header_t; ++ ++typedef enum ArgType { ++ ARG_TYPE_NONE = 0, ++ ARG_TYPE_UINT = 1, ++ ARG_TYPE_SINT = 2, ++ ARG_TYPE_FLOAT = 3, ++ ARG_TYPE_PTR = 4, ++ ARG_TYPE_STR = 5 ++} ArgType; ++ ++/** ++ * An IPCCommand function can have either of these function signatures ++ */ ++typedef union ArgFunction { ++ void (*single_param)(const Arg *); ++ void (*array_param)(const Arg *, int); ++} ArgFunction; ++ ++typedef struct IPCCommand { ++ char *name; ++ ArgFunction func; ++ unsigned int argc; ++ ArgType *arg_types; ++} IPCCommand; ++ ++typedef struct IPCParsedCommand { ++ char *name; ++ Arg *args; ++ ArgType *arg_types; ++ unsigned int argc; ++} IPCParsedCommand; ++ ++/** ++ * Initialize the IPC socket and the IPC module ++ * ++ * @param socket_path Path to create the socket at ++ * @param epoll_fd File descriptor for epoll ++ * @param commands Address of IPCCommands array defined in config.h ++ * @param commands_len Length of commands[] array ++ * ++ * @return int The file descriptor of the socket if it was successfully created, ++ * -1 otherwise ++ */ ++int ipc_init(const char *socket_path, const int p_epoll_fd, ++ IPCCommand commands[], const int commands_len); ++ ++/** ++ * Uninitialize the socket and module. Free allocated memory and restore static ++ * variables to their state before ipc_init ++ */ ++void ipc_cleanup(); ++ ++/** ++ * Get the file descriptor of the IPC socket ++ * ++ * @return int File descriptor of IPC socket, -1 if socket not created. ++ */ ++int ipc_get_sock_fd(); ++ ++/** ++ * Get address to IPCClient with specified file descriptor ++ * ++ * @param fd File descriptor of IPC Client ++ * ++ * @return Address to IPCClient with specified file descriptor, -1 otherwise ++ */ ++IPCClient *ipc_get_client(int fd); ++ ++/** ++ * Check if an IPC client exists with the specified file descriptor ++ * ++ * @param fd File descriptor ++ * ++ * @return int 1 if client exists, 0 otherwise ++ */ ++int ipc_is_client_registered(int fd); ++ ++/** ++ * Disconnect an IPCClient from the socket and remove the client from the list ++ * of known connected clients ++ * ++ * @param c Address of IPCClient ++ * ++ * @return 0 if the client's file descriptor was closed successfully, the ++ * result of executing close() on the file descriptor otherwise. ++ */ ++int ipc_drop_client(IPCClient *c); ++ ++/** ++ * Accept an IPC Client requesting to connect to the socket and add it to the ++ * list of clients ++ * ++ * @return File descriptor of new client, -1 on error ++ */ ++int ipc_accept_client(); ++ ++/** ++ * Read an incoming message from an accepted IPC client ++ * ++ * @param c Address of IPCClient ++ * @param msg_type Address to IPCMessageType variable which will be assigned ++ * the message type of the received message ++ * @param msg_size Address to uint32_t variable which will be assigned the size ++ * of the received message ++ * @param msg Address to char* variable which will be assigned the address of ++ * the received message. This must be freed using free(). ++ * ++ * @return 0 on success, -1 on error reading message, -2 if reading the message ++ * resulted in EAGAIN, EINTR, or EWOULDBLOCK. ++ */ ++int ipc_read_client(IPCClient *c, IPCMessageType *msg_type, uint32_t *msg_size, ++ char **msg); ++ ++/** ++ * Write any pending buffer of the client to the client's socket ++ * ++ * @param c Client whose buffer to write ++ * ++ * @return Number of bytes written >= 0, -1 otherwise. errno will still be set ++ * from the write operation. ++ */ ++ssize_t ipc_write_client(IPCClient *c); ++ ++/** ++ * Prepare a message in the specified client's buffer. ++ * ++ * @param c Client to prepare message for ++ * @param msg_type Type of message to prepare ++ * @param msg_size Size of the message in bytes. Should not exceed ++ * MAX_MESSAGE_SIZE ++ * @param msg Message to prepare (not including header). This pointer can be ++ * freed after the function invocation. ++ */ ++void ipc_prepare_send_message(IPCClient *c, const IPCMessageType msg_type, ++ const uint32_t msg_size, const char *msg); ++ ++/** ++ * Prepare an error message in the specified client's buffer ++ * ++ * @param c Client to prepare message for ++ * @param msg_type Type of message ++ * @param format Format string following vsprintf ++ * @param ... Arguments for format string ++ */ ++void ipc_prepare_reply_failure(IPCClient *c, IPCMessageType msg_type, ++ const char *format, ...); ++ ++/** ++ * Prepare a success message in the specified client's buffer ++ * ++ * @param c Client to prepare message for ++ * @param msg_type Type of message ++ */ ++void ipc_prepare_reply_success(IPCClient *c, IPCMessageType msg_type); ++ ++/** ++ * Send a tag_change_event to all subscribers. Should be called only when there ++ * has been a tag state change. ++ * ++ * @param mon_num The index of the monitor (Monitor.num property) ++ * @param old_state The old tag state ++ * @param new_state The new (now current) tag state ++ */ ++void ipc_tag_change_event(const int mon_num, TagState old_state, ++ TagState new_state); ++ ++/** ++ * Send a client_focus_change_event to all subscribers. Should be called only ++ * when the client focus changes. ++ * ++ * @param mon_num The index of the monitor (Monitor.num property) ++ * @param old_client The old DWM client selection (Monitor.oldsel) ++ * @param new_client The new (now current) DWM client selection ++ */ ++void ipc_client_focus_change_event(const int mon_num, Client *old_client, ++ Client *new_client); ++ ++/** ++ * Send a layout_change_event to all subscribers. Should be called only ++ * when there has been a layout change. ++ * ++ * @param mon_num The index of the monitor (Monitor.num property) ++ * @param old_symbol The old layout symbol ++ * @param old_layout Address to the old Layout ++ * @param new_symbol The new (now current) layout symbol ++ * @param new_layout Address to the new Layout ++ */ ++void ipc_layout_change_event(const int mon_num, const char *old_symbol, ++ const Layout *old_layout, const char *new_symbol, ++ const Layout *new_layout); ++ ++/** ++ * Send a monitor_focus_change_event to all subscribers. Should be called only ++ * when the monitor focus changes. ++ * ++ * @param last_mon_num The index of the previously selected monitor ++ * @param new_mon_num The index of the newly selected monitor ++ */ ++void ipc_monitor_focus_change_event(const int last_mon_num, ++ const int new_mon_num); ++ ++/** ++ * Send a focused_title_change_event to all subscribers. Should only be called ++ * if a selected client has a title change. ++ * ++ * @param mon_num Index of the client's monitor ++ * @param client_id Window XID of client ++ * @param old_name Old name of the client window ++ * @param new_name New name of the client window ++ */ ++void ipc_focused_title_change_event(const int mon_num, const Window client_id, ++ const char *old_name, const char *new_name); ++ ++/** ++ * Send a focused_state_change_event to all subscribers. Should only be called ++ * if a selected client has a state change. ++ * ++ * @param mon_num Index of the client's monitor ++ * @param client_id Window XID of client ++ * @param old_state Old state of the client ++ * @param new_state New state of the client ++ */ ++void ipc_focused_state_change_event(const int mon_num, const Window client_id, ++ const ClientState *old_state, ++ const ClientState *new_state); ++/** ++ * Check to see if an event has occured and call the *_change_event functions ++ * accordingly ++ * ++ * @param mons Address of Monitor pointing to start of linked list ++ * @param lastselmon Address of pointer to previously selected monitor ++ * @param selmon Address of selected Monitor ++ */ ++void ipc_send_events(Monitor *mons, Monitor **lastselmon, Monitor *selmon); ++ ++/** ++ * Handle an epoll event caused by a registered IPC client. Read, process, and ++ * handle any received messages from clients. Write pending buffer to client if ++ * the client is ready to receive messages. Drop clients that have sent an ++ * EPOLLHUP. ++ * ++ * @param ev Associated epoll event returned by epoll_wait ++ * @param mons Address of Monitor pointing to start of linked list ++ * @param selmon Address of selected Monitor ++ * @param lastselmon Address of pointer to previously selected monitor ++ * @param tags Array of tag names ++ * @param tags_len Length of tags array ++ * @param layouts Array of available layouts ++ * @param layouts_len Length of layouts array ++ * ++ * @return 0 if event was successfully handled, -1 on any error receiving ++ * or handling incoming messages or unhandled epoll event. ++ */ ++int ipc_handle_client_epoll_event(struct epoll_event *ev, Monitor *mons, ++ Monitor **lastselmon, Monitor *selmon, ++ const char *tags[], const int tags_len, ++ const Layout *layouts, const int layouts_len); ++ ++/** ++ * Handle an epoll event caused by the IPC socket. This function only handles an ++ * EPOLLIN event indicating a new client requesting to connect to the socket. ++ * ++ * @param ev Associated epoll event returned by epoll_wait ++ * ++ * @return 0, if the event was successfully handled, -1 if not an EPOLLIN event ++ * or if a new IPC client connection request could not be accepted. ++ */ ++int ipc_handle_socket_epoll_event(struct epoll_event *ev); ++ ++#endif /* IPC_H_ */ +diff --git a/util.c b/util.c +index fe044fc..dca4794 100644 +--- a/util.c ++++ b/util.c +@@ -3,6 +3,8 @@ + #include <stdio.h> + #include <stdlib.h> + #include <string.h> ++#include <errno.h> ++#include <sys/stat.h> + + #include "util.h" + +@@ -33,3 +35,136 @@ die(const char *fmt, ...) { + + exit(1); + } ++ ++int ++normalizepath(const char *path, char **normal) ++{ ++ size_t len = strlen(path); ++ *normal = (char *)malloc((len + 1) * sizeof(char)); ++ const char *walk = path; ++ const char *match; ++ size_t newlen = 0; ++ ++ while ((match = strchr(walk, '/'))) { ++ // Copy everything between match and walk ++ strncpy(*normal + newlen, walk, match - walk); ++ newlen += match - walk; ++ walk += match - walk; ++ ++ // Skip all repeating slashes ++ while (*walk == '/') ++ walk++; ++ ++ // If not last character in path ++ if (walk != path + len) ++ (*normal)[newlen++] = '/'; ++ } ++ ++ (*normal)[newlen++] = '\0'; ++ ++ // Copy remaining path ++ strcat(*normal, walk); ++ newlen += strlen(walk); ++ ++ *normal = (char *)realloc(*normal, newlen * sizeof(char)); ++ ++ return 0; ++} ++ ++int ++parentdir(const char *path, char **parent) ++{ ++ char *normal; ++ char *walk; ++ ++ normalizepath(path, &normal); ++ ++ // Pointer to last '/' ++ if (!(walk = strrchr(normal, '/'))) { ++ free(normal); ++ return -1; ++ } ++ ++ // Get path up to last '/' ++ size_t len = walk - normal; ++ *parent = (char *)malloc((len + 1) * sizeof(char)); ++ ++ // Copy path up to last '/' ++ strncpy(*parent, normal, len); ++ // Add null char ++ (*parent)[len] = '\0'; ++ ++ free(normal); ++ ++ return 0; ++} ++ ++int ++mkdirp(const char *path) ++{ ++ char *normal; ++ char *walk; ++ size_t normallen; ++ ++ normalizepath(path, &normal); ++ normallen = strlen(normal); ++ walk = normal; ++ ++ while (walk < normal + normallen + 1) { ++ // Get length from walk to next / ++ size_t n = strcspn(walk, "/"); ++ ++ // Skip path / ++ if (n == 0) { ++ walk++; ++ continue; ++ } ++ ++ // Length of current path segment ++ size_t curpathlen = walk - normal + n; ++ char curpath[curpathlen + 1]; ++ struct stat s; ++ ++ // Copy path segment to stat ++ strncpy(curpath, normal, curpathlen); ++ strcpy(curpath + curpathlen, ""); ++ int res = stat(curpath, &s); ++ ++ if (res < 0) { ++ if (errno == ENOENT) { ++ DEBUG("Making directory %s\n", curpath); ++ if (mkdir(curpath, 0700) < 0) { ++ fprintf(stderr, "Failed to make directory %s\n", curpath); ++ perror(""); ++ free(normal); ++ return -1; ++ } ++ } else { ++ fprintf(stderr, "Error statting directory %s\n", curpath); ++ perror(""); ++ free(normal); ++ return -1; ++ } ++ } ++ ++ // Continue to next path segment ++ walk += n; ++ } ++ ++ free(normal); ++ ++ return 0; ++} ++ ++int ++nullterminate(char **str, size_t *len) ++{ ++ if ((*str)[*len - 1] == '\0') ++ return 0; ++ ++ (*len)++; ++ *str = (char*)realloc(*str, *len * sizeof(char)); ++ (*str)[*len - 1] = '\0'; ++ ++ return 0; ++} +diff --git a/util.h b/util.h +index f633b51..73a238e 100644 +--- a/util.h ++++ b/util.h +@@ -4,5 +4,15 @@ + #define MIN(A, B) ((A) < (B) ? (A) : (B)) + #define BETWEEN(X, A, B) ((A) <= (X) && (X) <= (B)) + ++#ifdef _DEBUG ++#define DEBUG(...) fprintf(stderr, __VA_ARGS__) ++#else ++#define DEBUG(...) ++#endif ++ + void die(const char *fmt, ...); + void *ecalloc(size_t nmemb, size_t size); ++int normalizepath(const char *path, char **normal); ++int mkdirp(const char *path); ++int parentdir(const char *path, char **parent); ++int nullterminate(char **str, size_t *len); +diff --git a/yajl_dumps.c b/yajl_dumps.c +new file mode 100644 +index 0000000..8bf9688 +--- /dev/null ++++ b/yajl_dumps.c +@@ -0,0 +1,351 @@ ++#include "yajl_dumps.h" ++ ++#include <stdint.h> ++ ++int ++dump_tag(yajl_gen gen, const char *name, const int tag_mask) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("bit_mask"); YINT(tag_mask); ++ YSTR("name"); YSTR(name); ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_tags(yajl_gen gen, const char *tags[], int tags_len) ++{ ++ // clang-format off ++ YARR( ++ for (int i = 0; i < tags_len; i++) ++ dump_tag(gen, tags[i], 1 << i); ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_client(yajl_gen gen, Client *c) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("name"); YSTR(c->name); ++ YSTR("tags"); YINT(c->tags); ++ YSTR("window_id"); YINT(c->win); ++ YSTR("monitor_number"); YINT(c->mon->num); ++ ++ YSTR("geometry"); YMAP( ++ YSTR("current"); YMAP ( ++ YSTR("x"); YINT(c->x); ++ YSTR("y"); YINT(c->y); ++ YSTR("width"); YINT(c->w); ++ YSTR("height"); YINT(c->h); ++ ) ++ YSTR("old"); YMAP( ++ YSTR("x"); YINT(c->oldx); ++ YSTR("y"); YINT(c->oldy); ++ YSTR("width"); YINT(c->oldw); ++ YSTR("height"); YINT(c->oldh); ++ ) ++ ) ++ ++ YSTR("size_hints"); YMAP( ++ YSTR("base"); YMAP( ++ YSTR("width"); YINT(c->basew); ++ YSTR("height"); YINT(c->baseh); ++ ) ++ YSTR("step"); YMAP( ++ YSTR("width"); YINT(c->incw); ++ YSTR("height"); YINT(c->inch); ++ ) ++ YSTR("max"); YMAP( ++ YSTR("width"); YINT(c->maxw); ++ YSTR("height"); YINT(c->maxh); ++ ) ++ YSTR("min"); YMAP( ++ YSTR("width"); YINT(c->minw); ++ YSTR("height"); YINT(c->minh); ++ ) ++ YSTR("aspect_ratio"); YMAP( ++ YSTR("min"); YDOUBLE(c->mina); ++ YSTR("max"); YDOUBLE(c->maxa); ++ ) ++ ) ++ ++ YSTR("border_width"); YMAP( ++ YSTR("current"); YINT(c->bw); ++ YSTR("old"); YINT(c->oldbw); ++ ) ++ ++ YSTR("states"); YMAP( ++ YSTR("is_fixed"); YBOOL(c->isfixed); ++ YSTR("is_floating"); YBOOL(c->isfloating); ++ YSTR("is_urgent"); YBOOL(c->isurgent); ++ YSTR("never_focus"); YBOOL(c->neverfocus); ++ YSTR("old_state"); YBOOL(c->oldstate); ++ YSTR("is_fullscreen"); YBOOL(c->isfullscreen); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_monitor(yajl_gen gen, Monitor *mon, int is_selected) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("master_factor"); YDOUBLE(mon->mfact); ++ YSTR("num_master"); YINT(mon->nmaster); ++ YSTR("num"); YINT(mon->num); ++ YSTR("is_selected"); YBOOL(is_selected); ++ ++ YSTR("monitor_geometry"); YMAP( ++ YSTR("x"); YINT(mon->mx); ++ YSTR("y"); YINT(mon->my); ++ YSTR("width"); YINT(mon->mw); ++ YSTR("height"); YINT(mon->mh); ++ ) ++ ++ YSTR("window_geometry"); YMAP( ++ YSTR("x"); YINT(mon->wx); ++ YSTR("y"); YINT(mon->wy); ++ YSTR("width"); YINT(mon->ww); ++ YSTR("height"); YINT(mon->wh); ++ ) ++ ++ YSTR("tagset"); YMAP( ++ YSTR("current"); YINT(mon->tagset[mon->seltags]); ++ YSTR("old"); YINT(mon->tagset[mon->seltags ^ 1]); ++ ) ++ ++ YSTR("tag_state"); dump_tag_state(gen, mon->tagstate); ++ ++ YSTR("clients"); YMAP( ++ YSTR("selected"); YINT(mon->sel ? mon->sel->win : 0); ++ YSTR("stack"); YARR( ++ for (Client* c = mon->stack; c; c = c->snext) ++ YINT(c->win); ++ ) ++ YSTR("all"); YARR( ++ for (Client* c = mon->clients; c; c = c->next) ++ YINT(c->win); ++ ) ++ ) ++ ++ YSTR("layout"); YMAP( ++ YSTR("symbol"); YMAP( ++ YSTR("current"); YSTR(mon->ltsymbol); ++ YSTR("old"); YSTR(mon->lastltsymbol); ++ ) ++ YSTR("address"); YMAP( ++ YSTR("current"); YINT((uintptr_t)mon->lt[mon->sellt]); ++ YSTR("old"); YINT((uintptr_t)mon->lt[mon->sellt ^ 1]); ++ ) ++ ) ++ ++ YSTR("bar"); YMAP( ++ YSTR("y"); YINT(mon->by); ++ YSTR("is_shown"); YBOOL(mon->showbar); ++ YSTR("is_top"); YBOOL(mon->topbar); ++ YSTR("window_id"); YINT(mon->barwin); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_monitors(yajl_gen gen, Monitor *mons, Monitor *selmon) ++{ ++ // clang-format off ++ YARR( ++ for (Monitor *mon = mons; mon; mon = mon->next) { ++ if (mon == selmon) ++ dump_monitor(gen, mon, 1); ++ else ++ dump_monitor(gen, mon, 0); ++ } ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_layouts(yajl_gen gen, const Layout layouts[], const int layouts_len) ++{ ++ // clang-format off ++ YARR( ++ for (int i = 0; i < layouts_len; i++) { ++ YMAP( ++ // Check for a NULL pointer. The cycle layouts patch adds an entry at ++ // the end of the layouts array with a NULL pointer for the symbol ++ YSTR("symbol"); YSTR((layouts[i].symbol ? layouts[i].symbol : "")); ++ YSTR("address"); YINT((uintptr_t)(layouts + i)); ++ ) ++ } ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_tag_state(yajl_gen gen, TagState state) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("selected"); YINT(state.selected); ++ YSTR("occupied"); YINT(state.occupied); ++ YSTR("urgent"); YINT(state.urgent); ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_tag_event(yajl_gen gen, int mon_num, TagState old_state, ++ TagState new_state) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("tag_change_event"); YMAP( ++ YSTR("monitor_number"); YINT(mon_num); ++ YSTR("old_state"); dump_tag_state(gen, old_state); ++ YSTR("new_state"); dump_tag_state(gen, new_state); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_client_focus_change_event(yajl_gen gen, Client *old_client, ++ Client *new_client, int mon_num) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("client_focus_change_event"); YMAP( ++ YSTR("monitor_number"); YINT(mon_num); ++ YSTR("old_win_id"); old_client == NULL ? YNULL() : YINT(old_client->win); ++ YSTR("new_win_id"); new_client == NULL ? YNULL() : YINT(new_client->win); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_layout_change_event(yajl_gen gen, const int mon_num, ++ const char *old_symbol, const Layout *old_layout, ++ const char *new_symbol, const Layout *new_layout) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("layout_change_event"); YMAP( ++ YSTR("monitor_number"); YINT(mon_num); ++ YSTR("old_symbol"); YSTR(old_symbol); ++ YSTR("old_address"); YINT((uintptr_t)old_layout); ++ YSTR("new_symbol"); YSTR(new_symbol); ++ YSTR("new_address"); YINT((uintptr_t)new_layout); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_monitor_focus_change_event(yajl_gen gen, const int last_mon_num, ++ const int new_mon_num) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("monitor_focus_change_event"); YMAP( ++ YSTR("old_monitor_number"); YINT(last_mon_num); ++ YSTR("new_monitor_number"); YINT(new_mon_num); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_focused_title_change_event(yajl_gen gen, const int mon_num, ++ const Window client_id, const char *old_name, ++ const char *new_name) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("focused_title_change_event"); YMAP( ++ YSTR("monitor_number"); YINT(mon_num); ++ YSTR("client_window_id"); YINT(client_id); ++ YSTR("old_name"); YSTR(old_name); ++ YSTR("new_name"); YSTR(new_name); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_client_state(yajl_gen gen, const ClientState *state) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("old_state"); YBOOL(state->oldstate); ++ YSTR("is_fixed"); YBOOL(state->isfixed); ++ YSTR("is_floating"); YBOOL(state->isfloating); ++ YSTR("is_fullscreen"); YBOOL(state->isfullscreen); ++ YSTR("is_urgent"); YBOOL(state->isurgent); ++ YSTR("never_focus"); YBOOL(state->neverfocus); ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_focused_state_change_event(yajl_gen gen, const int mon_num, ++ const Window client_id, ++ const ClientState *old_state, ++ const ClientState *new_state) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("focused_state_change_event"); YMAP( ++ YSTR("monitor_number"); YINT(mon_num); ++ YSTR("client_window_id"); YINT(client_id); ++ YSTR("old_state"); dump_client_state(gen, old_state); ++ YSTR("new_state"); dump_client_state(gen, new_state); ++ ) ++ ) ++ // clang-format on ++ ++ return 0; ++} ++ ++int ++dump_error_message(yajl_gen gen, const char *reason) ++{ ++ // clang-format off ++ YMAP( ++ YSTR("result"); YSTR("error"); ++ YSTR("reason"); YSTR(reason); ++ ) ++ // clang-format on ++ ++ return 0; ++} +diff --git a/yajl_dumps.h b/yajl_dumps.h +new file mode 100644 +index 0000000..ee9948e +--- /dev/null ++++ b/yajl_dumps.h +@@ -0,0 +1,65 @@ ++#ifndef YAJL_DUMPS_H_ ++#define YAJL_DUMPS_H_ ++ ++#include <string.h> ++#include <yajl/yajl_gen.h> ++ ++#define YSTR(str) yajl_gen_string(gen, (unsigned char *)str, strlen(str)) ++#define YINT(num) yajl_gen_integer(gen, num) ++#define YDOUBLE(num) yajl_gen_double(gen, num) ++#define YBOOL(v) yajl_gen_bool(gen, v) ++#define YNULL() yajl_gen_null(gen) ++#define YARR(body) \ ++ { \ ++ yajl_gen_array_open(gen); \ ++ body; \ ++ yajl_gen_array_close(gen); \ ++ } ++#define YMAP(body) \ ++ { \ ++ yajl_gen_map_open(gen); \ ++ body; \ ++ yajl_gen_map_close(gen); \ ++ } ++ ++int dump_tag(yajl_gen gen, const char *name, const int tag_mask); ++ ++int dump_tags(yajl_gen gen, const char *tags[], int tags_len); ++ ++int dump_client(yajl_gen gen, Client *c); ++ ++int dump_monitor(yajl_gen gen, Monitor *mon, int is_selected); ++ ++int dump_monitors(yajl_gen gen, Monitor *mons, Monitor *selmon); ++ ++int dump_layouts(yajl_gen gen, const Layout layouts[], const int layouts_len); ++ ++int dump_tag_state(yajl_gen gen, TagState state); ++ ++int dump_tag_event(yajl_gen gen, int mon_num, TagState old_state, ++ TagState new_state); ++ ++int dump_client_focus_change_event(yajl_gen gen, Client *old_client, ++ Client *new_client, int mon_num); ++ ++int dump_layout_change_event(yajl_gen gen, const int mon_num, ++ const char *old_symbol, const Layout *old_layout, ++ const char *new_symbol, const Layout *new_layout); ++ ++int dump_monitor_focus_change_event(yajl_gen gen, const int last_mon_num, ++ const int new_mon_num); ++ ++int dump_focused_title_change_event(yajl_gen gen, const int mon_num, ++ const Window client_id, ++ const char *old_name, const char *new_name); ++ ++int dump_client_state(yajl_gen gen, const ClientState *state); ++ ++int dump_focused_state_change_event(yajl_gen gen, const int mon_num, ++ const Window client_id, ++ const ClientState *old_state, ++ const ClientState *new_state); ++ ++int dump_error_message(yajl_gen gen, const char *reason); ++ ++#endif // YAJL_DUMPS_H_ +-- +2.29.2 + @@ -4,6 +4,8 @@ #include <stdio.h> #include <stdlib.h> #include <string.h> +#include <errno.h> +#include <sys/stat.h> #include "util.h" @@ -35,3 +37,136 @@ ecalloc(size_t nmemb, size_t size) die("calloc:"); return p; } + +int +normalizepath(const char *path, char **normal) +{ + size_t len = strlen(path); + *normal = (char *)malloc((len + 1) * sizeof(char)); + const char *walk = path; + const char *match; + size_t newlen = 0; + + while ((match = strchr(walk, '/'))) { + // Copy everything between match and walk + strncpy(*normal + newlen, walk, match - walk); + newlen += match - walk; + walk += match - walk; + + // Skip all repeating slashes + while (*walk == '/') + walk++; + + // If not last character in path + if (walk != path + len) + (*normal)[newlen++] = '/'; + } + + (*normal)[newlen++] = '\0'; + + // Copy remaining path + strcat(*normal, walk); + newlen += strlen(walk); + + *normal = (char *)realloc(*normal, newlen * sizeof(char)); + + return 0; +} + +int +parentdir(const char *path, char **parent) +{ + char *normal; + char *walk; + + normalizepath(path, &normal); + + // Pointer to last '/' + if (!(walk = strrchr(normal, '/'))) { + free(normal); + return -1; + } + + // Get path up to last '/' + size_t len = walk - normal; + *parent = (char *)malloc((len + 1) * sizeof(char)); + + // Copy path up to last '/' + strncpy(*parent, normal, len); + // Add null char + (*parent)[len] = '\0'; + + free(normal); + + return 0; +} + +int +mkdirp(const char *path) +{ + char *normal; + char *walk; + size_t normallen; + + normalizepath(path, &normal); + normallen = strlen(normal); + walk = normal; + + while (walk < normal + normallen + 1) { + // Get length from walk to next / + size_t n = strcspn(walk, "/"); + + // Skip path / + if (n == 0) { + walk++; + continue; + } + + // Length of current path segment + size_t curpathlen = walk - normal + n; + char curpath[curpathlen + 1]; + struct stat s; + + // Copy path segment to stat + strncpy(curpath, normal, curpathlen); + strcpy(curpath + curpathlen, ""); + int res = stat(curpath, &s); + + if (res < 0) { + if (errno == ENOENT) { + DEBUG("Making directory %s\n", curpath); + if (mkdir(curpath, 0700) < 0) { + fprintf(stderr, "Failed to make directory %s\n", curpath); + perror(""); + free(normal); + return -1; + } + } else { + fprintf(stderr, "Error statting directory %s\n", curpath); + perror(""); + free(normal); + return -1; + } + } + + // Continue to next path segment + walk += n; + } + + free(normal); + + return 0; +} + +int +nullterminate(char **str, size_t *len) +{ + if ((*str)[*len - 1] == '\0') + return 0; + + (*len)++; + *str = (char*)realloc(*str, *len * sizeof(char)); + (*str)[*len - 1] = '\0'; + + return 0; +} @@ -5,5 +5,15 @@ #define BETWEEN(X, A, B) ((A) <= (X) && (X) <= (B)) #define LENGTH(X) (sizeof (X) / sizeof (X)[0]) +#ifdef _DEBUG +#define DEBUG(...) fprintf(stderr, __VA_ARGS__) +#else +#define DEBUG(...) +#endif + void die(const char *fmt, ...); void *ecalloc(size_t nmemb, size_t size); +int normalizepath(const char *path, char **normal); +int mkdirp(const char *path); +int parentdir(const char *path, char **parent); +int nullterminate(char **str, size_t *len); diff --git a/yajl_dumps.c b/yajl_dumps.c new file mode 100644 index 0000000..8bf9688 --- /dev/null +++ b/yajl_dumps.c @@ -0,0 +1,351 @@ +#include "yajl_dumps.h" + +#include <stdint.h> + +int +dump_tag(yajl_gen gen, const char *name, const int tag_mask) +{ + // clang-format off + YMAP( + YSTR("bit_mask"); YINT(tag_mask); + YSTR("name"); YSTR(name); + ) + // clang-format on + + return 0; +} + +int +dump_tags(yajl_gen gen, const char *tags[], int tags_len) +{ + // clang-format off + YARR( + for (int i = 0; i < tags_len; i++) + dump_tag(gen, tags[i], 1 << i); + ) + // clang-format on + + return 0; +} + +int +dump_client(yajl_gen gen, Client *c) +{ + // clang-format off + YMAP( + YSTR("name"); YSTR(c->name); + YSTR("tags"); YINT(c->tags); + YSTR("window_id"); YINT(c->win); + YSTR("monitor_number"); YINT(c->mon->num); + + YSTR("geometry"); YMAP( + YSTR("current"); YMAP ( + YSTR("x"); YINT(c->x); + YSTR("y"); YINT(c->y); + YSTR("width"); YINT(c->w); + YSTR("height"); YINT(c->h); + ) + YSTR("old"); YMAP( + YSTR("x"); YINT(c->oldx); + YSTR("y"); YINT(c->oldy); + YSTR("width"); YINT(c->oldw); + YSTR("height"); YINT(c->oldh); + ) + ) + + YSTR("size_hints"); YMAP( + YSTR("base"); YMAP( + YSTR("width"); YINT(c->basew); + YSTR("height"); YINT(c->baseh); + ) + YSTR("step"); YMAP( + YSTR("width"); YINT(c->incw); + YSTR("height"); YINT(c->inch); + ) + YSTR("max"); YMAP( + YSTR("width"); YINT(c->maxw); + YSTR("height"); YINT(c->maxh); + ) + YSTR("min"); YMAP( + YSTR("width"); YINT(c->minw); + YSTR("height"); YINT(c->minh); + ) + YSTR("aspect_ratio"); YMAP( + YSTR("min"); YDOUBLE(c->mina); + YSTR("max"); YDOUBLE(c->maxa); + ) + ) + + YSTR("border_width"); YMAP( + YSTR("current"); YINT(c->bw); + YSTR("old"); YINT(c->oldbw); + ) + + YSTR("states"); YMAP( + YSTR("is_fixed"); YBOOL(c->isfixed); + YSTR("is_floating"); YBOOL(c->isfloating); + YSTR("is_urgent"); YBOOL(c->isurgent); + YSTR("never_focus"); YBOOL(c->neverfocus); + YSTR("old_state"); YBOOL(c->oldstate); + YSTR("is_fullscreen"); YBOOL(c->isfullscreen); + ) + ) + // clang-format on + + return 0; +} + +int +dump_monitor(yajl_gen gen, Monitor *mon, int is_selected) +{ + // clang-format off + YMAP( + YSTR("master_factor"); YDOUBLE(mon->mfact); + YSTR("num_master"); YINT(mon->nmaster); + YSTR("num"); YINT(mon->num); + YSTR("is_selected"); YBOOL(is_selected); + + YSTR("monitor_geometry"); YMAP( + YSTR("x"); YINT(mon->mx); + YSTR("y"); YINT(mon->my); + YSTR("width"); YINT(mon->mw); + YSTR("height"); YINT(mon->mh); + ) + + YSTR("window_geometry"); YMAP( + YSTR("x"); YINT(mon->wx); + YSTR("y"); YINT(mon->wy); + YSTR("width"); YINT(mon->ww); + YSTR("height"); YINT(mon->wh); + ) + + YSTR("tagset"); YMAP( + YSTR("current"); YINT(mon->tagset[mon->seltags]); + YSTR("old"); YINT(mon->tagset[mon->seltags ^ 1]); + ) + + YSTR("tag_state"); dump_tag_state(gen, mon->tagstate); + + YSTR("clients"); YMAP( + YSTR("selected"); YINT(mon->sel ? mon->sel->win : 0); + YSTR("stack"); YARR( + for (Client* c = mon->stack; c; c = c->snext) + YINT(c->win); + ) + YSTR("all"); YARR( + for (Client* c = mon->clients; c; c = c->next) + YINT(c->win); + ) + ) + + YSTR("layout"); YMAP( + YSTR("symbol"); YMAP( + YSTR("current"); YSTR(mon->ltsymbol); + YSTR("old"); YSTR(mon->lastltsymbol); + ) + YSTR("address"); YMAP( + YSTR("current"); YINT((uintptr_t)mon->lt[mon->sellt]); + YSTR("old"); YINT((uintptr_t)mon->lt[mon->sellt ^ 1]); + ) + ) + + YSTR("bar"); YMAP( + YSTR("y"); YINT(mon->by); + YSTR("is_shown"); YBOOL(mon->showbar); + YSTR("is_top"); YBOOL(mon->topbar); + YSTR("window_id"); YINT(mon->barwin); + ) + ) + // clang-format on + + return 0; +} + +int +dump_monitors(yajl_gen gen, Monitor *mons, Monitor *selmon) +{ + // clang-format off + YARR( + for (Monitor *mon = mons; mon; mon = mon->next) { + if (mon == selmon) + dump_monitor(gen, mon, 1); + else + dump_monitor(gen, mon, 0); + } + ) + // clang-format on + + return 0; +} + +int +dump_layouts(yajl_gen gen, const Layout layouts[], const int layouts_len) +{ + // clang-format off + YARR( + for (int i = 0; i < layouts_len; i++) { + YMAP( + // Check for a NULL pointer. The cycle layouts patch adds an entry at + // the end of the layouts array with a NULL pointer for the symbol + YSTR("symbol"); YSTR((layouts[i].symbol ? layouts[i].symbol : "")); + YSTR("address"); YINT((uintptr_t)(layouts + i)); + ) + } + ) + // clang-format on + + return 0; +} + +int +dump_tag_state(yajl_gen gen, TagState state) +{ + // clang-format off + YMAP( + YSTR("selected"); YINT(state.selected); + YSTR("occupied"); YINT(state.occupied); + YSTR("urgent"); YINT(state.urgent); + ) + // clang-format on + + return 0; +} + +int +dump_tag_event(yajl_gen gen, int mon_num, TagState old_state, + TagState new_state) +{ + // clang-format off + YMAP( + YSTR("tag_change_event"); YMAP( + YSTR("monitor_number"); YINT(mon_num); + YSTR("old_state"); dump_tag_state(gen, old_state); + YSTR("new_state"); dump_tag_state(gen, new_state); + ) + ) + // clang-format on + + return 0; +} + +int +dump_client_focus_change_event(yajl_gen gen, Client *old_client, + Client *new_client, int mon_num) +{ + // clang-format off + YMAP( + YSTR("client_focus_change_event"); YMAP( + YSTR("monitor_number"); YINT(mon_num); + YSTR("old_win_id"); old_client == NULL ? YNULL() : YINT(old_client->win); + YSTR("new_win_id"); new_client == NULL ? YNULL() : YINT(new_client->win); + ) + ) + // clang-format on + + return 0; +} + +int +dump_layout_change_event(yajl_gen gen, const int mon_num, + const char *old_symbol, const Layout *old_layout, + const char *new_symbol, const Layout *new_layout) +{ + // clang-format off + YMAP( + YSTR("layout_change_event"); YMAP( + YSTR("monitor_number"); YINT(mon_num); + YSTR("old_symbol"); YSTR(old_symbol); + YSTR("old_address"); YINT((uintptr_t)old_layout); + YSTR("new_symbol"); YSTR(new_symbol); + YSTR("new_address"); YINT((uintptr_t)new_layout); + ) + ) + // clang-format on + + return 0; +} + +int +dump_monitor_focus_change_event(yajl_gen gen, const int last_mon_num, + const int new_mon_num) +{ + // clang-format off + YMAP( + YSTR("monitor_focus_change_event"); YMAP( + YSTR("old_monitor_number"); YINT(last_mon_num); + YSTR("new_monitor_number"); YINT(new_mon_num); + ) + ) + // clang-format on + + return 0; +} + +int +dump_focused_title_change_event(yajl_gen gen, const int mon_num, + const Window client_id, const char *old_name, + const char *new_name) +{ + // clang-format off + YMAP( + YSTR("focused_title_change_event"); YMAP( + YSTR("monitor_number"); YINT(mon_num); + YSTR("client_window_id"); YINT(client_id); + YSTR("old_name"); YSTR(old_name); + YSTR("new_name"); YSTR(new_name); + ) + ) + // clang-format on + + return 0; +} + +int +dump_client_state(yajl_gen gen, const ClientState *state) +{ + // clang-format off + YMAP( + YSTR("old_state"); YBOOL(state->oldstate); + YSTR("is_fixed"); YBOOL(state->isfixed); + YSTR("is_floating"); YBOOL(state->isfloating); + YSTR("is_fullscreen"); YBOOL(state->isfullscreen); + YSTR("is_urgent"); YBOOL(state->isurgent); + YSTR("never_focus"); YBOOL(state->neverfocus); + ) + // clang-format on + + return 0; +} + +int +dump_focused_state_change_event(yajl_gen gen, const int mon_num, + const Window client_id, + const ClientState *old_state, + const ClientState *new_state) +{ + // clang-format off + YMAP( + YSTR("focused_state_change_event"); YMAP( + YSTR("monitor_number"); YINT(mon_num); + YSTR("client_window_id"); YINT(client_id); + YSTR("old_state"); dump_client_state(gen, old_state); + YSTR("new_state"); dump_client_state(gen, new_state); + ) + ) + // clang-format on + + return 0; +} + +int +dump_error_message(yajl_gen gen, const char *reason) +{ + // clang-format off + YMAP( + YSTR("result"); YSTR("error"); + YSTR("reason"); YSTR(reason); + ) + // clang-format on + + return 0; +} diff --git a/yajl_dumps.h b/yajl_dumps.h new file mode 100644 index 0000000..ee9948e --- /dev/null +++ b/yajl_dumps.h @@ -0,0 +1,65 @@ +#ifndef YAJL_DUMPS_H_ +#define YAJL_DUMPS_H_ + +#include <string.h> +#include <yajl/yajl_gen.h> + +#define YSTR(str) yajl_gen_string(gen, (unsigned char *)str, strlen(str)) +#define YINT(num) yajl_gen_integer(gen, num) +#define YDOUBLE(num) yajl_gen_double(gen, num) +#define YBOOL(v) yajl_gen_bool(gen, v) +#define YNULL() yajl_gen_null(gen) +#define YARR(body) \ + { \ + yajl_gen_array_open(gen); \ + body; \ + yajl_gen_array_close(gen); \ + } +#define YMAP(body) \ + { \ + yajl_gen_map_open(gen); \ + body; \ + yajl_gen_map_close(gen); \ + } + +int dump_tag(yajl_gen gen, const char *name, const int tag_mask); + +int dump_tags(yajl_gen gen, const char *tags[], int tags_len); + +int dump_client(yajl_gen gen, Client *c); + +int dump_monitor(yajl_gen gen, Monitor *mon, int is_selected); + +int dump_monitors(yajl_gen gen, Monitor *mons, Monitor *selmon); + +int dump_layouts(yajl_gen gen, const Layout layouts[], const int layouts_len); + +int dump_tag_state(yajl_gen gen, TagState state); + +int dump_tag_event(yajl_gen gen, int mon_num, TagState old_state, + TagState new_state); + +int dump_client_focus_change_event(yajl_gen gen, Client *old_client, + Client *new_client, int mon_num); + +int dump_layout_change_event(yajl_gen gen, const int mon_num, + const char *old_symbol, const Layout *old_layout, + const char *new_symbol, const Layout *new_layout); + +int dump_monitor_focus_change_event(yajl_gen gen, const int last_mon_num, + const int new_mon_num); + +int dump_focused_title_change_event(yajl_gen gen, const int mon_num, + const Window client_id, + const char *old_name, const char *new_name); + +int dump_client_state(yajl_gen gen, const ClientState *state); + +int dump_focused_state_change_event(yajl_gen gen, const int mon_num, + const Window client_id, + const ClientState *old_state, + const ClientState *new_state); + +int dump_error_message(yajl_gen gen, const char *reason); + +#endif // YAJL_DUMPS_H_ |