git.sur5r.net Git - i3/i3/blob - src/display_version.c

   1 #undef I3__FILE__
   2 #define I3__FILE__ "key_press.c"
   3 /*
   4  * vim:ts=4:sw=4:expandtab
   5  *
   6  * i3 - an improved dynamic tiling window manager
   7  * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
   8  *
   9  * display_version.c: displays the running i3 version, runs as part of
  10  *                    i3 --moreversion.
  11  *
  12  */
  13 #include <sys/types.h>
  14 #include <sys/stat.h>
  15 #include <sys/wait.h>
  16 #include <sys/socket.h>
  17 #include <sys/un.h>
  18 #include <fcntl.h>
  19 #include "all.h"
  20
  21 static bool human_readable_key;
  22 static char *human_readable_version;
  23
  24 #if YAJL_MAJOR >= 2
  25 static int version_string(void *ctx, const unsigned char *val, size_t len) {
  26 #else
  27 static int version_string(void *ctx, const unsigned char *val, unsigned int len) {
  28 #endif
  29     if (human_readable_key)
  30         sasprintf(&human_readable_version, "%.*s", (int)len, val);
  31     return 1;
  32 }
  33
  34 #if YAJL_MAJOR >= 2
  35 static int version_map_key(void *ctx, const unsigned char *stringval, size_t stringlen) {
  36 #else
  37 static int version_map_key(void *ctx, const unsigned char *stringval, unsigned int stringlen) {
  38 #endif
  39     human_readable_key = (stringlen == strlen("human_readable") &&
  40                    strncmp((const char*)stringval, "human_readable", strlen("human_readable")) == 0);
  41     return 1;
  42 }
  43
  44 static yajl_callbacks version_callbacks = {
  45     NULL, /* null */
  46     NULL, /* boolean */
  47     NULL, /* integer */
  48     NULL, /* double */
  49     NULL, /* number */
  50     &version_string,
  51     NULL, /* start_map */
  52     &version_map_key,
  53     NULL, /* end_map */
  54     NULL, /* start_array */
  55     NULL /* end_array */
  56 };
  57
  58 /*
  59  * Connects to i3 to find out the currently running version. Useful since it
  60  * might be different from the version compiled into this binary (maybe the
  61  * user didn’t correctly install i3 or forgot te restart it).
  62  *
  63  * The output looks like this:
  64  * Running i3 version: 4.2-202-gb8e782c (2012-08-12, branch "next") (pid 14804)
  65  *
  66  * The i3 binary you just called: /home/michael/i3/i3
  67  * The i3 binary you are running: /home/michael/i3/i3
  68  *
  69  */
  70 void display_running_version(void) {
  71     char *socket_path = root_atom_contents("I3_SOCKET_PATH", conn, conn_screen);
  72     if (socket_path == NULL)
  73         exit(EXIT_SUCCESS);
  74
  75     char *pid_from_atom = root_atom_contents("I3_PID", conn, conn_screen);
  76     if (pid_from_atom == NULL) {
  77         /* If I3_PID is not set, the running version is older than 4.2-200. */
  78         printf("\nRunning version: < 4.2-200\n");
  79         exit(EXIT_SUCCESS);
  80     }
  81
  82     /* Inform the user of what we are doing. While a single IPC request is
  83      * really fast normally, in case i3 hangs, this will not terminate. */
  84     printf("(Getting version from running i3, press ctrl-c to abort…)");
  85     fflush(stdout);
  86
  87     /* TODO: refactor this with the code for sending commands */
  88     int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
  89     if (sockfd == -1)
  90         err(EXIT_FAILURE, "Could not create socket");
  91
  92     struct sockaddr_un addr;
  93     memset(&addr, 0, sizeof(struct sockaddr_un));
  94     addr.sun_family = AF_LOCAL;
  95     strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
  96     if (connect(sockfd, (const struct sockaddr*)&addr, sizeof(struct sockaddr_un)) < 0)
  97         err(EXIT_FAILURE, "Could not connect to i3");
  98
  99     if (ipc_send_message(sockfd, 0, I3_IPC_MESSAGE_TYPE_GET_VERSION,
 100                          (uint8_t*)"") == -1)
 101         err(EXIT_FAILURE, "IPC: write()");
 102
 103     uint32_t reply_length;
 104     uint32_t reply_type;
 105     uint8_t *reply;
 106     int ret;
 107     if ((ret = ipc_recv_message(sockfd, &reply_type, &reply_length, &reply)) != 0) {
 108         if (ret == -1)
 109             err(EXIT_FAILURE, "IPC: read()");
 110         exit(EXIT_FAILURE);
 111     }
 112
 113     if (reply_type != I3_IPC_MESSAGE_TYPE_GET_VERSION)
 114         errx(EXIT_FAILURE, "Got reply type %d, but expected %d (GET_VERSION)", reply_type, I3_IPC_MESSAGE_TYPE_GET_VERSION);
 115
 116 #if YAJL_MAJOR >= 2
 117     yajl_handle handle = yajl_alloc(&version_callbacks, NULL, NULL);
 118 #else
 119     yajl_parser_config parse_conf = { 0, 0 };
 120
 121     yajl_handle handle = yajl_alloc(&version_callbacks, &parse_conf, NULL, NULL);
 122 #endif
 123
 124     yajl_status state = yajl_parse(handle, (const unsigned char*)reply, (int)reply_length);
 125     if (state != yajl_status_ok)
 126         errx(EXIT_FAILURE, "Could not parse my own reply. That's weird. reply is %.*s", (int)reply_length, reply);
 127
 128     printf("\rRunning i3 version: %s (pid %s)\n", human_readable_version, pid_from_atom);
 129
 130 #ifdef __linux__
 131     size_t destpath_size = 1024;
 132     ssize_t linksize;
 133     char *exepath;
 134     char *destpath = smalloc(destpath_size);
 135
 136     sasprintf(&exepath, "/proc/%d/exe", getpid());
 137
 138     while ((linksize = readlink(exepath, destpath, destpath_size)) == destpath_size) {
 139             destpath_size = destpath_size * 2;
 140             destpath = srealloc(destpath, destpath_size);
 141     }
 142     if (linksize == -1)
 143         err(EXIT_FAILURE, "readlink(%s)", exepath);
 144
 145     /* readlink() does not NULL-terminate strings, so we have to. */
 146     destpath[linksize] = '\0';
 147
 148     printf("\n");
 149     printf("The i3 binary you just called: %s\n", destpath);
 150
 151     free(exepath);
 152     sasprintf(&exepath, "/proc/%s/exe", pid_from_atom);
 153
 154     while ((linksize = readlink(exepath, destpath, destpath_size)) == destpath_size) {
 155         destpath_size = destpath_size * 2;
 156         destpath = srealloc(destpath, destpath_size);
 157     }
 158     if (linksize == -1)
 159         err(EXIT_FAILURE, "readlink(%s)", exepath);
 160
 161     /* readlink() does not NULL-terminate strings, so we have to. */
 162     destpath[linksize] = '\0';
 163
 164     /* Check if "(deleted)" is the readlink result. If so, the running version
 165      * does not match the file on disk. */
 166     if (strstr(destpath, "(deleted)") != NULL)
 167         printf("RUNNING BINARY DIFFERENT FROM BINARY ON DISK!\n");
 168
 169     /* Since readlink() might put a "(deleted)" somewhere in the buffer and
 170      * stripping that out seems hackish and ugly, we read the process’s argv[0]
 171      * instead. */
 172     free(exepath);
 173     sasprintf(&exepath, "/proc/%s/cmdline", pid_from_atom);
 174
 175     int fd;
 176     if ((fd = open(exepath, O_RDONLY)) == -1)
 177         err(EXIT_FAILURE, "open(%s)", exepath);
 178     if (read(fd, destpath, sizeof(destpath)) == -1)
 179         err(EXIT_FAILURE, "read(%s)", exepath);
 180     close(fd);
 181
 182     printf("The i3 binary you are running: %s\n", destpath);
 183
 184     free(exepath);
 185     free(destpath);
 186 #endif
 187
 188     yajl_free(handle);
 189 }