[wiki] [sites] [dwm][patch] ipc initial commit || Mihir Lad

From: <git_AT_suckless.org>
Date: Sat, 25 Jul 2020 02:08:01 +0200

commit aa11118cf5c728bffd06156cd5109ddad947972d
Author: Mihir Lad <mihirlad55_AT_gmail.com>
Date: Fri Jul 24 20:05:56 2020 -0400

    [dwm][patch] ipc initial commit

diff --git a/dwm.suckless.org/patches/ipc/dwm-ipc-20200724-f04cac6.diff b/dwm.suckless.org/patches/ipc/dwm-ipc-20200724-f04cac6.diff
new file mode 100644
index 00000000..1910cf24
--- /dev/null
+++ b/dwm.suckless.org/patches/ipc/dwm-ipc-20200724-f04cac6.diff
_AT_@ -0,0 +1,3217 @@
+From c9f4dcf17d5b5ce8ca4d5d6e46be26cca6a8442a Mon Sep 17 00:00:00 2001
+From: mihirlad55 <mihirlad55_AT_gmail.com>
+Date: Fri, 24 Jul 2020 21:11:14 +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, selected client change, and layout 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 | 19 +
+ config.mk | 8 +-
+ dwm-msg.c | 519 ++++++++++++++++++++++
+ 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, 2903 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
+_AT_@ -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
", 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
+_AT_@ -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.
++ *
++ * _AT_param fd File descriptor of IPC client
++ *
++ * _AT_return Address to allocated IPCClient struct
++ */
++IPCClient *ipc_client_new(int fd);
++
++/**
++ * Add an IPC Client to the specified list
++ *
++ * _AT_param list Address of the list to add the client to
++ * _AT_param nc Address of the IPCClient
++ */
++void ipc_list_add_client(IPCClientList *list, IPCClient *nc);
++
++/**
++ * Remove an IPCClient from the specified list
++ *
++ * _AT_param list Address of the list to remove the client from
++ * _AT_param c Address of the IPCClient
++ */
++void ipc_list_remove_client(IPCClientList *list, IPCClient *c);
++
++/**
++ * Get an IPCClient from the specified IPCClient list
++ *
++ * _AT_param list List to remove the client from
++ * _AT_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
+_AT_@ -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:
+ _AT_echo dwm build options:
+_AT_@ -25,8 +25,11 @@ config.h:
+ dwm: ${OBJ}
+ ${CC} -o $_AT_ ${OBJ} ${LDFLAGS}
+
++dwm-msg: dwm-msg.o
++ ${CC} -o $_AT_ $< ${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}
+_AT_@ -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..3ad9785 100644
+--- a/config.def.h
++++ b/config.def.h
+_AT_@ -113,3 +113,22 @@ 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( spawn, 1, {ARG_TYPE_PTR} ),
++ 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
+_AT_@ -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..c957adf
+--- /dev/null
++++ b/dwm-msg.c
+_AT_@ -0,0 +1,519 @@
++#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;
++
++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.
",
++ read_bytes, to_read);
++ return -2;
++ } else {
++ fprintf(stderr, "Unexpectedly reached EOF while reading header.");
++ fprintf(stderr,
++ "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.
",
++ 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'
",
++ 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.
",
++ 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.
");
++ 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;
++
++ // Floats can only have one decimal point in between or digits
++ 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
++ 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
++print_socket_reply()
++{
++ IPCMessageType reply_type;
++ uint32_t reply_size;
++ char *reply;
++
++ read_socket(&reply_type, &reply_size, &reply);
++
++ printf("%.*s
", reply_size, reply);
++ 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);
++
++ print_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);
++
++ print_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, "
usage: %s <command> [...]
", prog_name);
++ fprintf(stderr, "Try '%s help'
", prog_name);
++
++ va_end(args);
++ exit(1);
++}
++
++static void
++print_usage(const char *name)
++{
++ printf("usage: %s <command> [...]
", 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("");
++}
++
++int
++main(int argc, char *argv[])
++{
++ const char *prog_name = argv[0];
++ // Need at least command argument
++ if (argc < 2) usage_error(prog_name, "Expected an argument, got none");
++
++ connect_to_socket();
++ if (sock_fd == -1) {
++ fprintf(stderr, "Failed to connect to socket
");
++ return 1;
++ }
++
++ for (int i = 1; i < argc; i++) {
++ if (strcmp(argv[i], "help") == 0) {
++ print_usage(prog_name);
++ return 0;
++ } 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);
++ return 0;
++ } else if (strcmp(argv[i], "get_monitors") == 0) {
++ get_monitors();
++ return 0;
++ } else if (strcmp(argv[i], "get_tags") == 0) {
++ get_tags();
++ return 0;
++ } else if (strcmp(argv[i], "get_layouts") == 0) {
++ get_layouts();
++ return 0;
++ } 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");
++ return 0;
++ } 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]);
++ }
++}
+diff --git a/dwm.c b/dwm.c
+index 9fd0286..c90c61a 100644
+--- a/dwm.c
++++ b/dwm.c
+_AT_@ -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>
+_AT_@ -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;
+_AT_@ -97,6 +110,7 @@ struct Client {
+ Client *snext;
+ Monitor *mon;
+ Window win;
++ ClientState prevstate;
+ };
+
+ typedef struct {
+_AT_@ -111,8 +125,10 @@ typedef struct {
+ void (*arrange)(Monitor *);
+ } Layout;
+
++
+ struct Monitor {
+ char ltsymbol[16];
++ char lastltsymbol[16];
+ float mfact;
+ int nmaster;
+ int num;
+_AT_@ -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 {
+_AT_@ -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);
+_AT_@ -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);
+_AT_@ -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]; };
+
+_AT_@ -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
");
++ }
+ }
+
+ void
+_AT_@ -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)
+ {
+_AT_@ -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
", 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
", 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
", events[i].events);
++ return;
++ }
++ }
++ }
+ }
+
+ void
+_AT_@ -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)
+_AT_@ -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
", 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
", stderr);
++ }
++}
+
+ void
+ seturgent(Client *c, int urg)
+_AT_@ -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] == '+ 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..1d435dc
+--- /dev/null
++++ b/ipc.c
+_AT_@ -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
", stderr);
++ return -1;
++ }
++
++ DEBUG("Created socket at %s
", sockaddr.sun_path);
++
++ if (bind(sock_fd, (const struct sockaddr *)&sockaddr, addr_size) == -1) {
++ fputs("Failed to bind socket
", stderr);
++ return -1;
++ }
++
++ DEBUG("Socket binded
");
++
++ if (listen(sock_fd, IPC_SOCKET_BACKLOG) < 0) {
++ fputs("Failed to listen for connections on socket
", stderr);
++ return -1;
++ }
++
++ DEBUG("Now listening for connections on socket
");
++
++ 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.
",
++ read_bytes, to_read);
++ return -2;
++ } else {
++ fprintf(stderr, "Unexpectedly reached EOF while reading header.");
++ fprintf(stderr,
++ "Read %" PRIu32 " bytes, expected %" PRIu32 " total bytes.
",
++ 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'
",
++ 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
", 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.
",
++ 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
", 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
", 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
", stderr);
++ fprintf(stderr, "%s
", error_buffer);
++ fprintf(stderr, "Tried to parse: %s
", 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
", 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
", 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
", 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].f = 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
", (*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
", (*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
", (*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
", stderr);
++ fprintf(stderr, "%s
", 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
", stderr);
++ return -1;
++ }
++
++ const char *event_str = YAJL_GET_STRING(event_val);
++ DEBUG("Received event: %s
", 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
", 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
", 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
", stderr);
++ fprintf(stderr, "%s
", 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
", 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
", 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
", c->fd, event);
++ c->subscriptions |= event;
++ } else if (action == IPC_ACTION_UNSUBSCRIBE) {
++ DEBUG("Unsubscribing client on fd %d to %d
", 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
", "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
", fd);
++ } else if (res < 0 && res != EINTR) {
++ fprintf(stderr, "Failed to close fd %d
", 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
", 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 "
", *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
", 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) return;
++ 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
", fd);
++ ipc_drop_client(c);
++ } else if (ev->events & EPOLLOUT) {
++ DEBUG("Sending message to client at fd %d...
", 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
", 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
", 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
", 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
+_AT_@ -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
++ *
++ * _AT_param socket_path Path to create the socket at
++ * _AT_param epoll_fd File descriptor for epoll
++ * _AT_param commands Address of IPCCommands array defined in config.h
++ * _AT_param commands_len Length of commands[] array
++ *
++ * _AT_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
++ *
++ * _AT_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
++ *
++ * _AT_param fd File descriptor of IPC Client
++ *
++ * _AT_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
++ *
++ * _AT_param fd File descriptor
++ *
++ * _AT_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
++ *
++ * _AT_param c Address of IPCClient
++ *
++ * _AT_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
++ *
++ * _AT_return File descriptor of new client, -1 on error
++ */
++int ipc_accept_client();
++
++/**
++ * Read an incoming message from an accepted IPC client
++ *
++ * _AT_param c Address of IPCClient
++ * _AT_param msg_type Address to IPCMessageType variable which will be assigned
++ * the message type of the received message
++ * _AT_param msg_size Address to uint32_t variable which will be assigned the size
++ * of the received message
++ * _AT_param msg Address to char* variable which will be assigned the address of
++ * the received message. This must be freed using free().
++ *
++ * _AT_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
++ *
++ * _AT_param c Client whose buffer to write
++ *
++ * _AT_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.
++ *
++ * _AT_param c Client to prepare message for
++ * _AT_param msg_type Type of message to prepare
++ * _AT_param msg_size Size of the message in bytes. Should not exceed
++ * MAX_MESSAGE_SIZE
++ * _AT_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
++ *
++ * _AT_param c Client to prepare message for
++ * _AT_param msg_type Type of message
++ * _AT_param format Format string following vsprintf
++ * _AT_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
++ *
++ * _AT_param c Client to prepare message for
++ * _AT_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.
++ *
++ * _AT_param mon_num The index of the monitor (Monitor.num property)
++ * _AT_param old_state The old tag state
++ * _AT_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.
++ *
++ * _AT_param mon_num The index of the monitor (Monitor.num property)
++ * _AT_param old_client The old DWM client selection (Monitor.oldsel)
++ * _AT_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.
++ *
++ * _AT_param mon_num The index of the monitor (Monitor.num property)
++ * _AT_param old_symbol The old layout symbol
++ * _AT_param old_layout Address to the old Layout
++ * _AT_param new_symbol The new (now current) layout symbol
++ * _AT_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.
++ *
++ * _AT_param last_mon_num The index of the previously selected monitor
++ * _AT_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.
++ *
++ * _AT_param mon_num Index of the client's monitor
++ * _AT_param client_id Window XID of client
++ * _AT_param old_name Old name of the client window
++ * _AT_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.
++ *
++ * _AT_param mon_num Index of the client's monitor
++ * _AT_param client_id Window XID of client
++ * _AT_param old_state Old state of the client
++ * _AT_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
++ *
++ * _AT_param mons Address of Monitor pointing to start of linked list
++ * _AT_param lastselmon Address of pointer to previously selected monitor
++ * _AT_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.
++ *
++ * _AT_param ev Associated epoll event returned by epoll_wait
++ * _AT_param mons Address of Monitor pointing to start of linked list
++ * _AT_param selmon Address of selected Monitor
++ * _AT_param lastselmon Address of pointer to previously selected monitor
++ * _AT_param tags Array of tag names
++ * _AT_param tags_len Length of tags array
++ * _AT_param layouts Array of available layouts
++ * _AT_param layouts_len Length of layouts array
++ *
++ * _AT_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.
++ *
++ * _AT_param ev Associated epoll event returned by epoll_wait
++ *
++ * _AT_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
+_AT_@ -3,6 +3,8 @@
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
++#include <errno.h>
++#include <sys/stat.h>
+
+ #include "util.h"
+
+_AT_@ -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++] = '++
++ // 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] = '++
++ 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
", curpath);
++ if (mkdir(curpath, 0700) < 0) {
++ fprintf(stderr, "Failed to make directory %s
", curpath);
++ perror("");
++ free(normal);
++ return -1;
++ }
++ } else {
++ fprintf(stderr, "Error statting directory %s
", 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] == '++ return 0;
++
++ (*len)++;
++ *str = (char*)realloc(*str, *len * sizeof(char));
++ (*str)[*len - 1] = '++
++ return 0;
++}
+diff --git a/util.h b/util.h
+index f633b51..73a238e 100644
+--- a/util.h
++++ b/util.h
+_AT_@ -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
+_AT_@ -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
+_AT_@ -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.27.0
+
diff --git a/dwm.suckless.org/patches/ipc/index.md b/dwm.suckless.org/patches/ipc/index.md
new file mode 100644
index 00000000..e3617f53
--- /dev/null
+++ b/dwm.suckless.org/patches/ipc/index.md
_AT_@ -0,0 +1,86 @@
+ipc
+====
+
+Description
+-----------
+dwm-ipc is a patch for dwm that implements inter-process communication through
+a UNIX socket. This allows you to query the window manager for information,
+listen for events such as tag changes or layout changes, as well as send
+commands to control the window manager from other programs/scripts.
+
+The project is being managed and developed on this GitHub
+[repo](https://github.com/mihirlad55/dwm-ipc). If you discover any bugs, feel
+free to create an issue there.
+
+
+Requirements
+------------
+In order to build dwm you need the Xlib header files. The patch
+additionally requires [yajl](https://github.com/lloyd/yajl) which is a tiny C
+JSON library.
+
+
+Applying the Patch
+------------------
+The patch is best applied after all of your other patches due to the number of
+additions to dwm.c. The patch was designed with compatability in mind, so there
+are minimal deletions.
+
+
+Patch Compatability
+-------------------
+At the moment, the patch will only work on systems that implement epoll and is
+not completely portable. Portability will be improved in the future.
+
+
+Supported IPC Messages
+----------------------
+At the moment the IPC patch supports the following message requests:
+* Run user-defined command (similar to key bindings)
+
+* Get information about available layouts
+
+* Get information about the tags available
+
+* Get the properties of all of the monitors
+
+* Get the properties of a specific dwm client
+
+* Subscribe to tag change, client focus change, layout change events, monitor
+ focus change events, focused title change events, and focused state change
+ events.
+
+For more info on the IPC protocol implementation, visit the
+[wiki](https://github.com/mihirlad55/dwm-ipc/wiki/).
+
+
+dwm-msg
+-------
+`dwm-msg` is a cli program included in the patch which supports all of the IPC
+message types listed above. The program can be used to run commands, query dwm
+for information, and listen for events. This program is particularly useful for
+creating custom shell scripts to control dwm.
+
+
+Download
+--------
+* IPC Patch v1.5.2:
+ [dwm-ipc-20200724-f04cac6.diff](dwm-ipc-20200724-f04cac6.diff)
+
+The latest releases of the patch will always be available first on the project
+[Releases](https://github.com/mihirlad55/dwm-ipc/releases) page. There are also
+"update" patches to update from previous versions of the patch.
+
+
+Related Projects
+----------------
+* [dwmipcpp](https://github.com/mihirlad55/dwmipcpp) is a C++ client library
+ for interacting with an IPC-patched dwm
+
+* [polybar-dwm-module](https://github.com/mihirlad55/polybar-dwm-module)
+ requires this patch
+
+
+Authors
+-------
+* Mihir Lad - <mihirlad55 at gmail>
Received on Sat Jul 25 2020 - 02:08:01 CEST