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