--- /dev/null
+#undef I3__FILE__
+#define I3__FILE__ "key_press.c"
+/*
+ * vim:ts=4:sw=4:expandtab
+ *
+ * i3 - an improved dynamic tiling window manager
+ * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
+ *
+ * display_version.c: displays the running i3 version, runs as part of
+ * i3 --moreversion.
+ *
+ */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <fcntl.h>
+#include "all.h"
+
+static bool human_readable_key;
+static char *human_readable_version;
+
+#if YAJL_MAJOR >= 2
+static int version_string(void *ctx, const unsigned char *val, size_t len) {
+#else
+static int version_string(void *ctx, const unsigned char *val, unsigned int len) {
+#endif
+ if (human_readable_key)
+ sasprintf(&human_readable_version, "%.*s", (int)len, val);
+ return 1;
+}
+
+#if YAJL_MAJOR >= 2
+static int version_map_key(void *ctx, const unsigned char *stringval, size_t stringlen) {
+#else
+static int version_map_key(void *ctx, const unsigned char *stringval, unsigned int stringlen) {
+#endif
+ human_readable_key = (stringlen == strlen("human_readable") &&
+ strncmp((const char*)stringval, "human_readable", strlen("human_readable")) == 0);
+ return 1;
+}
+
+static yajl_callbacks version_callbacks = {
+ NULL, /* null */
+ NULL, /* boolean */
+ NULL, /* integer */
+ NULL, /* double */
+ NULL, /* number */
+ &version_string,
+ NULL, /* start_map */
+ &version_map_key,
+ NULL, /* end_map */
+ NULL, /* start_array */
+ NULL /* end_array */
+};
+
+/*
+ * Connects to i3 to find out the currently running version. Useful since it
+ * might be different from the version compiled into this binary (maybe the
+ * user didn’t correctly install i3 or forgot te restart it).
+ *
+ * The output looks like this:
+ * Running i3 version: 4.2-202-gb8e782c (2012-08-12, branch "next") (pid 14804)
+ *
+ * The i3 binary you just called: /home/michael/i3/i3
+ * The i3 binary you are running: /home/michael/i3/i3
+ *
+ */
+void display_running_version(void) {
+ char *socket_path = root_atom_contents("I3_SOCKET_PATH");
+ if (socket_path == NULL)
+ exit(EXIT_SUCCESS);
+
+ char *pid_from_atom = root_atom_contents("I3_PID");
+ if (pid_from_atom == NULL) {
+ /* If I3_PID is not set, the running version is older than 4.2-200. */
+ printf("\nRunning version: < 4.2-200\n");
+ exit(EXIT_SUCCESS);
+ }
+
+ /* Inform the user of what we are doing. While a single IPC request is
+ * really fast normally, in case i3 hangs, this will not terminate. */
+ printf("(Getting version from running i3, press ctrl-c to abort…)");
+ fflush(stdout);
+
+ /* TODO: refactor this with the code for sending commands */
+ int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
+ if (sockfd == -1)
+ err(EXIT_FAILURE, "Could not create socket");
+
+ struct sockaddr_un addr;
+ memset(&addr, 0, sizeof(struct sockaddr_un));
+ addr.sun_family = AF_LOCAL;
+ strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
+ if (connect(sockfd, (const struct sockaddr*)&addr, sizeof(struct sockaddr_un)) < 0)
+ err(EXIT_FAILURE, "Could not connect to i3");
+
+ if (ipc_send_message(sockfd, 0, I3_IPC_MESSAGE_TYPE_GET_VERSION,
+ (uint8_t*)"") == -1)
+ err(EXIT_FAILURE, "IPC: write()");
+
+ uint32_t reply_length;
+ uint8_t *reply;
+ int ret;
+ if ((ret = ipc_recv_message(sockfd, I3_IPC_MESSAGE_TYPE_GET_VERSION,
+ &reply_length, &reply)) != 0) {
+ if (ret == -1)
+ err(EXIT_FAILURE, "IPC: read()");
+ exit(EXIT_FAILURE);
+ }
+
+#if YAJL_MAJOR >= 2
+ yajl_handle handle = yajl_alloc(&version_callbacks, NULL, NULL);
+#else
+ yajl_parser_config parse_conf = { 0, 0 };
+
+ yajl_handle handle = yajl_alloc(&version_callbacks, &parse_conf, NULL, NULL);
+#endif
+
+ yajl_status state = yajl_parse(handle, (const unsigned char*)reply, (int)reply_length);
+ if (state != yajl_status_ok)
+ err(EXIT_FAILURE, "Could not parse my own reply. That's weird. reply is %.*s", (int)reply_length, reply);
+
+ printf("\rRunning i3 version: %s (pid %s)\n", human_readable_version, pid_from_atom);
+ printf("\n");
+ char resolved_path[PATH_MAX];
+ if (realpath(start_argv[0], resolved_path) == NULL)
+ err(EXIT_FAILURE, "realpath(%s)", start_argv[0]);
+ printf("The i3 binary you just called: %s\n", resolved_path);
+
+#ifdef __linux__
+ char exepath[PATH_MAX],
+ destpath[PATH_MAX];
+ snprintf(exepath, sizeof(exepath), "/proc/%s/exe", pid_from_atom);
+
+ ssize_t linksize;
+ if ((linksize = readlink(exepath, destpath, sizeof(destpath))) == -1)
+ err(EXIT_FAILURE, "readlink(%s)", exepath);
+
+ /* readlink() does not NULL-terminate strings, so we have to. */
+ destpath[linksize] = '\0';
+
+ /* Check if "(deleted)" is the readlink result. If so, the running version
+ * does not match the file on disk. */
+ if (strstr(destpath, "(deleted)") != NULL)
+ printf("RUNNING BINARY DIFFERENT FROM BINARY ON DISK!\n");
+
+ /* Since readlink() might put a "(deleted)" somewhere in the buffer and
+ * stripping that out seems hackish and ugly, we read the process’s argv[0]
+ * instead. */
+ snprintf(exepath, sizeof(exepath), "/proc/%s/cmdline", pid_from_atom);
+
+ int fd;
+ if ((fd = open(exepath, O_RDONLY)) == -1)
+ err(EXIT_FAILURE, "open(%s)", exepath);
+ if (read(fd, destpath, sizeof(destpath)) == -1)
+ err(EXIT_FAILURE, "read(%s)", exepath);
+ close(fd);
+
+ printf("The i3 binary you are running: %s\n", destpath);
+#endif
+
+ yajl_free(handle);
+}
projects / i3 / i3 / blobdiff