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

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * i3 - an improved dynamic tiling window manager
   5  *
   6  * © 2009-2011 Michael Stapelberg and contributors
   7  *
   8  * See file LICENSE for license information.
   9  *
  10  * util.c: Utility functions, which can be useful everywhere.
  11  *
  12  */
  13 #include <sys/wait.h>
  14 #include <stdarg.h>
  15 #include <iconv.h>
  16 #if defined(__OpenBSD__)
  17 #include <sys/cdefs.h>
  18 #endif
  19 #include <fcntl.h>
  20 #include <pwd.h>
  21 #include <yajl/yajl_version.h>
  22 #include <libgen.h>
  23
  24 #define SN_API_NOT_YET_FROZEN 1
  25 #include <libsn/sn-launcher.h>
  26
  27 #include "all.h"
  28
  29 static iconv_t conversion_descriptor = 0;
  30
  31 int min(int a, int b) {
  32     return (a < b ? a : b);
  33 }
  34
  35 int max(int a, int b) {
  36     return (a > b ? a : b);
  37 }
  38
  39 bool rect_contains(Rect rect, uint32_t x, uint32_t y) {
  40     return (x >= rect.x &&
  41             x <= (rect.x + rect.width) &&
  42             y >= rect.y &&
  43             y <= (rect.y + rect.height));
  44 }
  45
  46 Rect rect_add(Rect a, Rect b) {
  47     return (Rect){a.x + b.x,
  48                   a.y + b.y,
  49                   a.width + b.width,
  50                   a.height + b.height};
  51 }
  52
  53 /*
  54  * Updates *destination with new_value and returns true if it was changed or false
  55  * if it was the same
  56  *
  57  */
  58 bool update_if_necessary(uint32_t *destination, const uint32_t new_value) {
  59     uint32_t old_value = *destination;
  60
  61     return ((*destination = new_value) != old_value);
  62 }
  63
  64 /*
  65  * exec()s an i3 utility, for example the config file migration script or
  66  * i3-nagbar. This function first searches $PATH for the given utility named,
  67  * then falls back to the dirname() of the i3 executable path and then falls
  68  * back to the dirname() of the target of /proc/self/exe (on linux).
  69  *
  70  * This function should be called after fork()ing.
  71  *
  72  * The first argument of the given argv vector will be overwritten with the
  73  * executable name, so pass NULL.
  74  *
  75  * If the utility cannot be found in any of these locations, it exits with
  76  * return code 2.
  77  *
  78  */
  79 void exec_i3_utility(char *name, char *argv[]) {
  80     /* start the migration script, search PATH first */
  81     char *migratepath = name;
  82     argv[0] = migratepath;
  83     execvp(migratepath, argv);
  84
  85     /* if the script is not in path, maybe the user installed to a strange
  86      * location and runs the i3 binary with an absolute path. We use
  87      * argv[0]’s dirname */
  88     char *pathbuf = strdup(start_argv[0]);
  89     char *dir = dirname(pathbuf);
  90     asprintf(&migratepath, "%s/%s", dir, name);
  91     argv[0] = migratepath;
  92     execvp(migratepath, argv);
  93
  94 #if defined(__linux__)
  95     /* on linux, we have one more fall-back: dirname(/proc/self/exe) */
  96     char buffer[BUFSIZ];
  97     if (readlink("/proc/self/exe", buffer, BUFSIZ) == -1) {
  98         warn("could not read /proc/self/exe");
  99         exit(1);
 100     }
 101     dir = dirname(buffer);
 102     asprintf(&migratepath, "%s/%s", dir, name);
 103     argv[0] = migratepath;
 104     execvp(migratepath, argv);
 105 #endif
 106
 107     warn("Could not start %s", name);
 108     exit(2);
 109 }
 110
 111 /*
 112  * Checks a generic cookie for errors and quits with the given message if there
 113  * was an error.
 114  *
 115  */
 116 void check_error(xcb_connection_t *conn, xcb_void_cookie_t cookie, char *err_message) {
 117     xcb_generic_error_t *error = xcb_request_check(conn, cookie);
 118     if (error != NULL) {
 119         fprintf(stderr, "ERROR: %s (X error %d)\n", err_message , error->error_code);
 120         xcb_disconnect(conn);
 121         exit(-1);
 122     }
 123 }
 124
 125 /*
 126  * Converts the given string to UCS-2 big endian for use with
 127  * xcb_image_text_16(). The amount of real glyphs is stored in real_strlen,
 128  * a buffer containing the UCS-2 encoded string (16 bit per glyph) is
 129  * returned. It has to be freed when done.
 130  *
 131  */
 132 char *convert_utf8_to_ucs2(char *input, int *real_strlen) {
 133     size_t input_size = strlen(input) + 1;
 134     /* UCS-2 consumes exactly two bytes for each glyph */
 135     int buffer_size = input_size * 2;
 136
 137     char *buffer = smalloc(buffer_size);
 138     size_t output_size = buffer_size;
 139     /* We need to use an additional pointer, because iconv() modifies it */
 140     char *output = buffer;
 141
 142     /* We convert the input into UCS-2 big endian */
 143     if (conversion_descriptor == 0) {
 144         conversion_descriptor = iconv_open("UCS-2BE", "UTF-8");
 145         if (conversion_descriptor == 0) {
 146             fprintf(stderr, "error opening the conversion context\n");
 147             exit(1);
 148         }
 149     }
 150
 151     /* Get the conversion descriptor back to original state */
 152     iconv(conversion_descriptor, NULL, NULL, NULL, NULL);
 153
 154     /* Convert our text */
 155     int rc = iconv(conversion_descriptor, (void*)&input, &input_size, &output, &output_size);
 156     if (rc == (size_t)-1) {
 157         perror("Converting to UCS-2 failed");
 158         if (real_strlen != NULL)
 159             *real_strlen = 0;
 160         return NULL;
 161     }
 162
 163     if (real_strlen != NULL)
 164         *real_strlen = ((buffer_size - output_size) / 2) - 1;
 165
 166     return buffer;
 167 }
 168
 169 /*
 170  * This function resolves ~ in pathnames.
 171  * It may resolve wildcards in the first part of the path, but if no match
 172  * or multiple matches are found, it just returns a copy of path as given.
 173  *
 174  */
 175 char *resolve_tilde(const char *path) {
 176         static glob_t globbuf;
 177         char *head, *tail, *result;
 178
 179         tail = strchr(path, '/');
 180         head = strndup(path, tail ? tail - path : strlen(path));
 181
 182         int res = glob(head, GLOB_TILDE, NULL, &globbuf);
 183         free(head);
 184         /* no match, or many wildcard matches are bad */
 185         if (res == GLOB_NOMATCH || globbuf.gl_pathc != 1)
 186                 result = sstrdup(path);
 187         else if (res != 0) {
 188                 die("glob() failed");
 189         } else {
 190                 head = globbuf.gl_pathv[0];
 191                 result = scalloc(strlen(head) + (tail ? strlen(tail) : 0) + 1);
 192                 strncpy(result, head, strlen(head));
 193                 if (tail)
 194                     strncat(result, tail, strlen(tail));
 195         }
 196         globfree(&globbuf);
 197
 198         return result;
 199 }
 200
 201 /*
 202  * Checks if the given path exists by calling stat().
 203  *
 204  */
 205 bool path_exists(const char *path) {
 206         struct stat buf;
 207         return (stat(path, &buf) == 0);
 208 }
 209
 210 /*
 211  * Goes through the list of arguments (for exec()) and checks if the given argument
 212  * is present. If not, it copies the arguments (because we cannot realloc it) and
 213  * appends the given argument.
 214  *
 215  */
 216 static char **append_argument(char **original, char *argument) {
 217     int num_args;
 218     for (num_args = 0; original[num_args] != NULL; num_args++) {
 219         DLOG("original argument: \"%s\"\n", original[num_args]);
 220         /* If the argument is already present we return the original pointer */
 221         if (strcmp(original[num_args], argument) == 0)
 222             return original;
 223     }
 224     /* Copy the original array */
 225     char **result = smalloc((num_args+2) * sizeof(char*));
 226     memcpy(result, original, num_args * sizeof(char*));
 227     result[num_args] = argument;
 228     result[num_args+1] = NULL;
 229
 230     return result;
 231 }
 232
 233 /*
 234  * Returns the name of a temporary file with the specified prefix.
 235  *
 236  */
 237 char *get_process_filename(const char *prefix) {
 238     char *dir = getenv("XDG_RUNTIME_DIR");
 239     if (dir == NULL) {
 240         struct passwd *pw = getpwuid(getuid());
 241         const char *username = pw ? pw->pw_name : "unknown";
 242         if (asprintf(&dir, "/tmp/i3-%s", username) == -1) {
 243             perror("asprintf()");
 244             return NULL;
 245         }
 246     } else {
 247         char *tmp;
 248         if (asprintf(&tmp, "%s/i3", dir) == -1) {
 249             perror("asprintf()");
 250             return NULL;
 251         }
 252         dir = tmp;
 253     }
 254     if (!path_exists(dir)) {
 255         if (mkdir(dir, 0700) == -1) {
 256             perror("mkdir()");
 257             return NULL;
 258         }
 259     }
 260     char *filename;
 261     if (asprintf(&filename, "%s/%s.%d", dir, prefix, getpid()) == -1) {
 262         perror("asprintf()");
 263         filename = NULL;
 264     }
 265
 266     free(dir);
 267     return filename;
 268 }
 269
 270 #define y(x, ...) yajl_gen_ ## x (gen, ##__VA_ARGS__)
 271 #define ystr(str) yajl_gen_string(gen, (unsigned char*)str, strlen(str))
 272
 273 char *store_restart_layout() {
 274     setlocale(LC_NUMERIC, "C");
 275 #if YAJL_MAJOR >= 2
 276     yajl_gen gen = yajl_gen_alloc(NULL);
 277 #else
 278     yajl_gen gen = yajl_gen_alloc(NULL, NULL);
 279 #endif
 280
 281     dump_node(gen, croot, true);
 282
 283     setlocale(LC_NUMERIC, "");
 284
 285     const unsigned char *payload;
 286 #if YAJL_MAJOR >= 2
 287     size_t length;
 288 #else
 289     unsigned int length;
 290 #endif
 291     y(get_buf, &payload, &length);
 292
 293     /* create a temporary file if one hasn't been specified, or just
 294      * resolve the tildes in the specified path */
 295     char *filename;
 296     if (config.restart_state_path == NULL) {
 297         filename = get_process_filename("restart-state");
 298         if (!filename)
 299             return NULL;
 300     } else {
 301         filename = resolve_tilde(config.restart_state_path);
 302     }
 303
 304     int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
 305     if (fd == -1) {
 306         perror("open()");
 307         free(filename);
 308         return NULL;
 309     }
 310
 311     int written = 0;
 312     while (written < length) {
 313         int n = write(fd, payload + written, length - written);
 314         /* TODO: correct error-handling */
 315         if (n == -1) {
 316             perror("write()");
 317             free(filename);
 318             close(fd);
 319             return NULL;
 320         }
 321         if (n == 0) {
 322             printf("write == 0?\n");
 323             free(filename);
 324             close(fd);
 325             return NULL;
 326         }
 327         written += n;
 328 #if YAJL_MAJOR >= 2
 329         printf("written: %d of %zd\n", written, length);
 330 #else
 331         printf("written: %d of %d\n", written, length);
 332 #endif
 333     }
 334     close(fd);
 335
 336     if (length > 0) {
 337         printf("layout: %.*s\n", (int)length, payload);
 338     }
 339
 340     y(free);
 341
 342     return filename;
 343 }
 344
 345 /*
 346  * Restart i3 in-place
 347  * appends -a to argument list to disable autostart
 348  *
 349  */
 350 void i3_restart(bool forget_layout) {
 351     char *restart_filename = forget_layout ? NULL : store_restart_layout();
 352
 353     kill_configerror_nagbar(true);
 354
 355     restore_geometry();
 356
 357     ipc_shutdown();
 358
 359     LOG("restarting \"%s\"...\n", start_argv[0]);
 360     /* make sure -a is in the argument list or append it */
 361     start_argv = append_argument(start_argv, "-a");
 362
 363     /* replace -r <file> so that the layout is restored */
 364     if (restart_filename != NULL) {
 365         /* create the new argv */
 366         int num_args;
 367         for (num_args = 0; start_argv[num_args] != NULL; num_args++);
 368         char **new_argv = scalloc((num_args + 3) * sizeof(char*));
 369
 370         /* copy the arguments, but skip the ones we'll replace */
 371         int write_index = 0;
 372         bool skip_next = false;
 373         for (int i = 0; i < num_args; ++i) {
 374             if (skip_next)
 375                 skip_next = false;
 376             else if (!strcmp(start_argv[i], "-r") ||
 377                      !strcmp(start_argv[i], "--restart"))
 378                 skip_next = true;
 379             else
 380                 new_argv[write_index++] = start_argv[i];
 381         }
 382
 383         /* add the arguments we'll replace */
 384         new_argv[write_index++] = "--restart";
 385         new_argv[write_index] = restart_filename;
 386
 387         /* swap the argvs */
 388         start_argv = new_argv;
 389     }
 390
 391     execvp(start_argv[0], start_argv);
 392     /* not reached */
 393 }
 394
 395 #if defined(__OpenBSD__) || defined(__APPLE__)
 396
 397 /*
 398  * Taken from FreeBSD
 399  * Find the first occurrence of the byte string s in byte string l.
 400  *
 401  */
 402 void *memmem(const void *l, size_t l_len, const void *s, size_t s_len) {
 403     register char *cur, *last;
 404     const char *cl = (const char *)l;
 405     const char *cs = (const char *)s;
 406
 407     /* we need something to compare */
 408     if (l_len == 0 || s_len == 0)
 409         return NULL;
 410
 411     /* "s" must be smaller or equal to "l" */
 412     if (l_len < s_len)
 413         return NULL;
 414
 415     /* special case where s_len == 1 */
 416     if (s_len == 1)
 417         return memchr(l, (int)*cs, l_len);
 418
 419     /* the last position where its possible to find "s" in "l" */
 420     last = (char *)cl + l_len - s_len;
 421
 422     for (cur = (char *)cl; cur <= last; cur++)
 423         if (cur[0] == cs[0] && memcmp(cur, cs, s_len) == 0)
 424             return cur;
 425
 426     return NULL;
 427 }
 428
 429 #endif
 430
 431 #if defined(__APPLE__)
 432
 433 /*
 434  * Taken from FreeBSD
 435  * Returns a pointer to a new string which is a duplicate of the
 436  * string, but only copies at most n characters.
 437  *
 438  */
 439 char *strndup(const char *str, size_t n) {
 440     size_t len;
 441     char *copy;
 442
 443     for (len = 0; len < n && str[len]; len++)
 444         continue;
 445
 446     if ((copy = malloc(len + 1)) == NULL)
 447         return (NULL);
 448     memcpy(copy, str, len);
 449     copy[len] = '\0';
 450     return (copy);
 451 }
 452
 453 #endif