From: Michael Stapelberg Date: Tue, 28 Jul 2009 18:51:29 +0000 (+0200) Subject: Initial implementation of IPC via UNIX domain sockets X-Git-Tag: 3.c~42 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=a43846ea275bbd398ce0e2d009ed89c7e800cb95;p=i3%2Fi3 Initial implementation of IPC via UNIX domain sockets --- diff --git a/include/i3.h b/include/i3.h index 2a31b93b..18844e09 100644 --- a/include/i3.h +++ b/include/i3.h @@ -22,6 +22,7 @@ #define NUM_ATOMS 17 +extern xcb_connection_t *global_conn; extern char **start_argv; extern Display *xkbdpy; extern TAILQ_HEAD(bindings_head, Binding) bindings; diff --git a/include/i3/ipc.h b/include/i3/ipc.h new file mode 100644 index 00000000..40e01158 --- /dev/null +++ b/include/i3/ipc.h @@ -0,0 +1,24 @@ +/* + * vim:ts=8:expandtab + * + * i3 - an improved dynamic tiling window manager + * + * © 2009 Michael Stapelberg and contributors + * + * See file LICENSE for license information. + * + * This public header defines the different constants and message types to use + * for the IPC interface to i3 (see docs/ipc for more information). + * + */ + +#ifndef _I3_IPC_H +#define _I3_IPC_H + +/** Never change this, only on major IPC breakage (don’t do that) */ +#define I3_IPC_MAGIC "i3-ipc" + +/** The payload of the message will be interpreted as a command */ +#define I3_IPC_MESSAGE_TYPE_COMMAND 0 + +#endif diff --git a/include/ipc.h b/include/ipc.h new file mode 100644 index 00000000..478354b5 --- /dev/null +++ b/include/ipc.h @@ -0,0 +1,23 @@ +/* + * vim:ts=8:expandtab + * + * i3 - an improved dynamic tiling window manager + * + * © 2009 Michael Stapelberg and contributors + * + * See file LICENSE for license information. + * + */ + +#ifndef _IPC_H +#define _IPC_H + +#include + +#include "i3/ipc.h" + +void ipc_new_client(EV_P_ struct ev_io *w, int revents); + +int ipc_create_socket(const char *filename); + +#endif diff --git a/src/ipc.c b/src/ipc.c new file mode 100644 index 00000000..34675943 --- /dev/null +++ b/src/ipc.c @@ -0,0 +1,232 @@ +/* + * vim:ts=8:expandtab + * + * i3 - an improved dynamic tiling window manager + * + * © 2009 Michael Stapelberg and contributors + * + * See file LICENSE for license information. + * + * ipc.c: Everything about the UNIX domain sockets for IPC + * + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "queue.h" +#include "i3/ipc.h" +#include "i3.h" +#include "util.h" +#include "commands.h" + +typedef struct ipc_client { + int fd; + + TAILQ_ENTRY(ipc_client) clients; +} ipc_client; + +TAILQ_HEAD(ipc_client_head, ipc_client) all_clients = TAILQ_HEAD_INITIALIZER(all_clients); + +/* + * Puts the given socket file descriptor into non-blocking mode or dies if + * setting O_NONBLOCK failed. Non-blocking sockets are a good idea for our + * IPC model because we should by no means block the window manager. + * + */ +static void set_nonblock(int sockfd) { + int flags = fcntl(sockfd, F_GETFL, 0); + flags |= O_NONBLOCK; + if (fcntl(sockfd, F_SETFL, flags) < 0) + err(-1, "Could not set O_NONBLOCK"); +} + +#if 0 +void broadcast(EV_P_ struct ev_timer *t, int revents) { + ipc_client *current; + TAILQ_FOREACH(current, &all_clients, clients) { + write(current->fd, "hi there!\n", strlen("hi there!\n")); + } +} +#endif + +/* + * Decides what to do with the received message. + * + * message is the raw packet, as received from the UNIX domain socket. size + * is the remaining size of bytes for this packet. + * + * message_size is the size of the message as the sender specified it. + * message_type is the type of the message as the sender specified it. + * + */ +static void ipc_handle_message(uint8_t *message, int size, + uint32_t message_size, uint32_t message_type) { + LOG("handling message of size %d\n", size); + LOG("sender specified size %d\n", message_size); + LOG("sender specified type %d\n", message_type); + LOG("payload as a string = %s\n", message); + + switch (message_type) { + case I3_IPC_MESSAGE_TYPE_COMMAND: + parse_command(global_conn, (const char*)message); + + break; + default: + LOG("unhandled ipc message\n"); + break; + } +} + +/* + * Handler for activity on a client connection, receives a message from a + * client. + * + * For now, the maximum message size is 2048. I’m not sure for what the + * IPC interface will be used in the future, thus I’m not implementing a + * mechanism for arbitrarily long messages, as it seems like overkill + * at the moment. + * + */ +static void ipc_receive_message(EV_P_ struct ev_io *w, int revents) { + char buf[2048]; + int n = read(w->fd, buf, sizeof(buf)); + + /* On error or an empty message, we close the connection */ + if (n <= 0) { +#if 0 + /* FIXME: I get these when closing a client socket, + * therefore we just treat them as an error. Is this + * correct? */ + if (errno == EAGAIN || errno == EWOULDBLOCK) + return; +#endif + + /* If not, there was some kind of error. We don’t bother + * and close the connection */ + close(w->fd); + + /* Delete the client from the list of clients */ + struct ipc_client *current; + TAILQ_FOREACH(current, &all_clients, clients) { + if (current->fd != w->fd) + continue; + + /* We can call TAILQ_REMOVE because we break out of the + * TAILQ_FOREACH afterwards */ + TAILQ_REMOVE(&all_clients, current, clients); + break; + } + + ev_io_stop(EV_A_ w); + + LOG("IPC: client disconnected\n"); + return; + } + + /* Terminate the message correctly */ + buf[n] = '\0'; + + /* Check if the message starts with the i3 IPC magic code */ + if (n < strlen(I3_IPC_MAGIC)) { + LOG("IPC: message too short, ignoring\n"); + return; + } + + if (strncmp(buf, I3_IPC_MAGIC, strlen(I3_IPC_MAGIC)) != 0) { + LOG("IPC: message does not start with the IPC magic\n"); + return; + } + + uint8_t *message = (uint8_t*)buf; + message += strlen(I3_IPC_MAGIC); + n -= strlen(I3_IPC_MAGIC); + + /* The next 32 bit after the magic are the message size */ + uint32_t message_size = *((uint32_t*)message); + message += sizeof(uint32_t); + n -= sizeof(uint32_t); + + /* The last 32 bits of the header are the message type */ + uint32_t message_type = *((uint32_t*)message); + message += sizeof(uint32_t); + n -= sizeof(uint32_t); + + ipc_handle_message(message, n, message_size, message_type); +} + +/* + * Handler for activity on the listening socket, meaning that a new client + * has just connected and we should accept() him. Sets up the event handler + * for activity on the new connection and inserts the file descriptor into + * the list of clients. + * + */ +void ipc_new_client(EV_P_ struct ev_io *w, int revents) { + struct sockaddr_un peer; + socklen_t len = sizeof(struct sockaddr_un); + int client; + if ((client = accept(w->fd, (struct sockaddr*)&peer, &len)) < 0) { + if (errno == EINTR) + return; + else perror("accept()"); + return; + } + + set_nonblock(client); + + struct ev_io *package = calloc(sizeof(struct ev_io), 1); + ev_io_init(package, ipc_receive_message, client, EV_READ); + ev_io_start(EV_A_ package); + + LOG("IPC: new client connected\n"); + + struct ipc_client *new = calloc(sizeof(struct ipc_client), 1); + new->fd = client; + + TAILQ_INSERT_TAIL(&all_clients, new, clients); +} + +/* + * Creates the UNIX domain socket at the given path, sets it to non-blocking + * mode, bind()s and listen()s on it. + * + */ +int ipc_create_socket(const char *filename) { + int sockfd; + + /* Unlink the unix domain socket before */ + unlink(filename); + + if ((sockfd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0) { + perror("socket()"); + return -1; + } + + struct sockaddr_un addr; + memset(&addr, 0, sizeof(struct sockaddr_un)); + addr.sun_family = AF_LOCAL; + strcpy(addr.sun_path, filename); + if (bind(sockfd, (struct sockaddr*)&addr, sizeof(struct sockaddr_un)) < 0) { + perror("bind()"); + return -1; + } + + set_nonblock(sockfd); + + if (listen(sockfd, 5) < 0) { + perror("listen()"); + return -1; + } + + return sockfd; +} diff --git a/src/mainx.c b/src/mainx.c index 06330eb0..684526c6 100644 --- a/src/mainx.c +++ b/src/mainx.c @@ -45,6 +45,9 @@ #include "xcb.h" #include "xinerama.h" #include "manage.h" +#include "ipc.h" + +xcb_connection_t *global_conn; /* This is the path to i3, copied from argv[0] when starting up */ char **start_argv; @@ -148,7 +151,7 @@ int main(int argc, char *argv[], char *env[]) { memset(&evenths, 0, sizeof(xcb_event_handlers_t)); memset(&prophs, 0, sizeof(xcb_property_handlers_t)); - conn = xcb_connect(NULL, &screens); + conn = global_conn = xcb_connect(NULL, &screens); if (xcb_connection_has_error(conn)) die("Cannot open display\n"); @@ -366,6 +369,16 @@ int main(int argc, char *argv[], char *env[]) { c_ws = &workspaces[screen->current_workspace]; } + /* Create the UNIX domain socket for IPC */ + int ipc_socket = ipc_create_socket("/tmp/i3.s"); + if (ipc_socket == -1) { + LOG("Could not create the IPC socket, IPC disabled\n"); + } else { + struct ev_io *ipc_io = scalloc(sizeof(struct ev_io)); + ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ); + ev_io_start(loop, ipc_io); + } + /* Handle the events which arrived until now */ xcb_check_cb(NULL, NULL, 0);