sites

dwm-ipc-20200726-f04cac6.diff (89943B)

---

 From 930156d1771a2af6c572856ea97b113e537cf13d Mon Sep 17 00:00:00 2001
 From: mihirlad55 <mihirlad55@gmail.com>
 Date: Sun, 26 Jul 2020 03:51:15 +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 |   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
 @@ -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..3ad9785 100644
 --- a/config.def.h
 +++ b/config.def.h
 @@ -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
 @@ -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
 @@ -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.\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;
 +
 +  // 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\n", 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, "\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 <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("");
 +}
 +
 +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\n");
 +    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
 @@ -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..e527e23
 --- /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].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\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.27.0