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