Dogcows Code - chaz/openbox/blob - obt/paths.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    obt/paths.c for the Openbox window manager
   4    Copyright (c) 2003-2007   Dana Jansens
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    See the COPYING file for a copy of the GNU General Public License.
  17 */
  18
  19 #include "obt/bsearch.h"
  20 #include "obt/paths.h"
  21 #include "obt/util.h"
  22
  23 #ifdef HAVE_STDLIB_H
  24 #  include <stdlib.h>
  25 #endif
  26 #ifdef HAVE_SYS_STAT_H
  27 #  include <sys/stat.h>
  28 #endif
  29 #ifdef HAVE_SYS_TYPES_H
  30 #  include <sys/types.h>
  31 #endif
  32 #ifdef HAVE_STRING_H
  33 #  include <string.h>
  34 #endif
  35 #ifdef HAVE_UNISTD_H
  36 #  include <unistd.h>
  37 #endif
  38 #ifdef HAVE_GRP_H
  39 #  include <grp.h>
  40 #endif
  41 #ifdef HAVE_PWD_H
  42 #  include <pwd.h>
  43 #endif
  44
  45 struct _ObtPaths
  46 {
  47     gint   ref;
  48     gchar  *config_home;
  49     gchar  *data_home;
  50     gchar  *cache_home;
  51     GSList *config_dirs;
  52     GSList *data_dirs;
  53     GSList *autostart_dirs;
  54     GSList *exec_dirs;
  55
  56     uid_t   uid;
  57     gid_t  *gid;
  58     guint   n_gid;
  59 };
  60
  61 static gint slist_path_cmp(const gchar *a, const gchar *b)
  62 {
  63     return strcmp(a, b);
  64 }
  65
  66 typedef GSList* (*GSListFunc) (gpointer list, gconstpointer data);
  67
  68 static GSList* slist_path_add(GSList *list, gpointer data, GSListFunc func)
  69 {
  70     g_assert(func);
  71
  72     if (!data)
  73         return list;
  74
  75     if (!g_slist_find_custom(list, data, (GCompareFunc) slist_path_cmp))
  76         list = func(list, data);
  77     else
  78         g_free(data);
  79
  80     return list;
  81 }
  82
  83 static GSList* split_paths(const gchar *paths)
  84 {
  85     GSList *list = NULL;
  86     gchar **spl, **it;
  87
  88     if (!paths)
  89         return NULL;
  90     spl = g_strsplit(paths, ":", -1);
  91     for (it = spl; *it; ++it) {
  92         if ((*it)[0]) /* skip empty strings */
  93             list = slist_path_add(list, *it, (GSListFunc) g_slist_append);
  94     }
  95     g_free(spl);
  96     return list;
  97 }
  98
  99 int gid_cmp(const void *va, const void *vb)
 100 {
 101     const gid_t a = *(const gid_t*)va, b = *(const gid_t*)vb;
 102     return a>b ? 1 : (a == b ? 0 : -1);
 103 }
 104
 105 static void find_uid_gid(uid_t *u, gid_t **g, guint *n)
 106 {
 107     struct passwd *pw;
 108     const gchar *name;
 109     struct group *gr;
 110
 111     *u = getuid();
 112     pw = getpwuid(*u);
 113     name = pw->pw_name;
 114
 115     *g = g_new(gid_t, *n=1);
 116     (*g)[0] = getgid();
 117
 118     while ((gr = getgrent())) {
 119         if (gr->gr_gid != (*g)[0]) { /* skip the main group */
 120             gchar **c;
 121             for (c = gr->gr_mem; *c; ++c)
 122                 if (strcmp(*c, name) == 0) {
 123                     *g = g_renew(gid_t, *g, ++(*n)); /* save the group */
 124                     (*g)[*n-1] = gr->gr_gid;
 125                     break;
 126                 }
 127         }
 128     }
 129     endgrent();
 130
 131     qsort(*g, *n, sizeof(gid_t), gid_cmp);
 132 }
 133
 134 ObtPaths* obt_paths_new(void)
 135 {
 136     ObtPaths *p;
 137     const gchar *path;
 138     GSList *it;
 139
 140     p = g_slice_new0(ObtPaths);
 141     p->ref = 1;
 142
 143     find_uid_gid(&p->uid, &p->gid, &p->n_gid);
 144
 145     path = g_getenv("XDG_CONFIG_HOME");
 146     if (path && path[0] != '\0') /* not unset or empty */
 147         p->config_home = g_build_filename(path, NULL);
 148     else
 149         p->config_home = g_build_filename(g_get_home_dir(), ".config", NULL);
 150
 151     path = g_getenv("XDG_DATA_HOME");
 152     if (path && path[0] != '\0') /* not unset or empty */
 153         p->data_home = g_build_filename(path, NULL);
 154     else
 155         p->data_home = g_build_filename(g_get_home_dir(), ".local",
 156                                         "share", NULL);
 157
 158     path = g_getenv("XDG_CACHE_HOME");
 159     if (path && path[0] != '\0') /* not unset or empty */
 160         p->cache_home = g_build_filename(path, NULL);
 161     else
 162         p->cache_home = g_build_filename(g_get_home_dir(), ".cache", NULL);
 163
 164     path = g_getenv("XDG_CONFIG_DIRS");
 165     if (path && path[0] != '\0') /* not unset or empty */
 166         p->config_dirs = split_paths(path);
 167     else {
 168         p->config_dirs = slist_path_add(p->config_dirs,
 169                                         g_strdup(CONFIGDIR),
 170                                         (GSListFunc) g_slist_append);
 171         p->config_dirs = slist_path_add(p->config_dirs,
 172                                         g_build_filename
 173                                         (G_DIR_SEPARATOR_S,
 174                                          "etc", "xdg", NULL),
 175                                         (GSListFunc) g_slist_append);
 176     }
 177     p->config_dirs = slist_path_add(p->config_dirs,
 178                                     g_strdup(p->config_home),
 179                                     (GSListFunc) g_slist_prepend);
 180
 181     for (it = p->config_dirs; it; it = g_slist_next(it)) {
 182         gchar *const s = g_strdup_printf("%s/autostart", (gchar*)it->data);
 183         p->autostart_dirs = g_slist_append(p->autostart_dirs, s);
 184     }
 185
 186     path = g_getenv("XDG_DATA_DIRS");
 187     if (path && path[0] != '\0') /* not unset or empty */
 188         p->data_dirs = split_paths(path);
 189     else {
 190         p->data_dirs = slist_path_add(p->data_dirs,
 191                                       g_strdup(DATADIR),
 192                                       (GSListFunc) g_slist_append);
 193         p->data_dirs = slist_path_add(p->data_dirs,
 194                                       g_build_filename
 195                                       (G_DIR_SEPARATOR_S,
 196                                        "usr", "local", "share", NULL),
 197                                       (GSListFunc) g_slist_append);
 198         p->data_dirs = slist_path_add(p->data_dirs,
 199                                       g_build_filename
 200                                       (G_DIR_SEPARATOR_S,
 201                                        "usr", "share", NULL),
 202                                       (GSListFunc) g_slist_append);
 203     }
 204     p->data_dirs = slist_path_add(p->data_dirs,
 205                                   g_strdup(p->data_home),
 206                                   (GSListFunc) g_slist_prepend);
 207
 208     path = g_getenv("PATH");
 209     if (path && path[0] != '\0') /* not unset or empty */
 210         p->exec_dirs = split_paths(path);
 211     else
 212         p->exec_dirs = NULL;
 213
 214     return p;
 215 }
 216
 217 void obt_paths_ref(ObtPaths *p)
 218 {
 219     ++p->ref;
 220 }
 221
 222 void obt_paths_unref(ObtPaths *p)
 223 {
 224     if (p && --p->ref == 0) {
 225         GSList *it;
 226
 227         for (it = p->config_dirs; it; it = g_slist_next(it))
 228             g_free(it->data);
 229         g_slist_free(p->config_dirs);
 230         for (it = p->data_dirs; it; it = g_slist_next(it))
 231             g_free(it->data);
 232         g_slist_free(p->data_dirs);
 233         for (it = p->autostart_dirs; it; it = g_slist_next(it))
 234             g_free(it->data);
 235         g_slist_free(p->autostart_dirs);
 236         for (it = p->exec_dirs; it; it = g_slist_next(it))
 237             g_free(it->data);
 238         g_slist_free(p->exec_dirs);
 239         g_free(p->config_home);
 240         g_free(p->data_home);
 241         g_free(p->cache_home);
 242         g_free(p->gid);
 243
 244         g_slice_free(ObtPaths, p);
 245     }
 246 }
 247
 248 gchar *obt_paths_expand_tilde(const gchar *f)
 249 {
 250     gchar *ret;
 251     GRegex *regex;
 252
 253     if (!f)
 254         return NULL;
 255
 256     regex = g_regex_new("(?:^|(?<=[ \\t]))~(?=[/ \\t$])", G_REGEX_MULTILINE | G_REGEX_RAW, 0, NULL);
 257     ret = g_regex_replace_literal(regex, f, -1, 0, g_get_home_dir(), 0, NULL);
 258     g_regex_unref(regex);
 259
 260     return ret;
 261 }
 262
 263 gboolean obt_paths_mkdir(const gchar *path, gint mode)
 264 {
 265     gboolean ret = TRUE;
 266
 267     g_return_val_if_fail(path != NULL, FALSE);
 268     g_return_val_if_fail(path[0] != '\0', FALSE);
 269
 270     if (!g_file_test(path, G_FILE_TEST_IS_DIR))
 271         if (mkdir(path, mode) == -1)
 272             ret = FALSE;
 273
 274     return ret;
 275 }
 276
 277 gboolean obt_paths_mkdir_path(const gchar *path, gint mode)
 278 {
 279     gboolean ret = TRUE;
 280
 281     g_return_val_if_fail(path != NULL, FALSE);
 282     g_return_val_if_fail(path[0] == '/', FALSE);
 283
 284     if (!g_file_test(path, G_FILE_TEST_IS_DIR)) {
 285         gchar *c, *e;
 286
 287         c = g_strdup(path);
 288         e = c;
 289         while ((e = strchr(e + 1, '/'))) {
 290             *e = '\0';
 291             if (!(ret = obt_paths_mkdir(c, mode)))
 292                 goto parse_mkdir_path_end;
 293             *e = '/';
 294         }
 295         ret = obt_paths_mkdir(c, mode);
 296
 297     parse_mkdir_path_end:
 298         g_free(c);
 299     }
 300
 301     return ret;
 302 }
 303
 304 const gchar* obt_paths_config_home(ObtPaths *p)
 305 {
 306     return p->config_home;
 307 }
 308
 309 const gchar* obt_paths_data_home(ObtPaths *p)
 310 {
 311     return p->data_home;
 312 }
 313
 314 const gchar* obt_paths_cache_home(ObtPaths *p)
 315 {
 316     return p->cache_home;
 317 }
 318
 319 GSList* obt_paths_config_dirs(ObtPaths *p)
 320 {
 321     return p->config_dirs;
 322 }
 323
 324 GSList* obt_paths_data_dirs(ObtPaths *p)
 325 {
 326     return p->data_dirs;
 327 }
 328
 329 GSList* obt_paths_autostart_dirs(ObtPaths *p)
 330 {
 331     return p->autostart_dirs;
 332 }
 333
 334 static inline gboolean try_exec(const ObtPaths *const p,
 335                                 const gchar *const path)
 336 {
 337     struct stat st;
 338     BSEARCH_SETUP(guint);
 339
 340     if (stat(path, &st) != 0)
 341         return FALSE;
 342
 343     if (!S_ISREG(st.st_mode))
 344         return FALSE;
 345     if (st.st_uid == p->uid)
 346         return st.st_mode & S_IXUSR;
 347     BSEARCH(guint, p->gid, 0, p->n_gid, st.st_gid);
 348     if (BSEARCH_FOUND())
 349         return st.st_mode & S_IXGRP;
 350     return st.st_mode & S_IXOTH;
 351 }
 352
 353 gboolean obt_paths_try_exec(ObtPaths *p, const gchar *path)
 354 {
 355     if (path[0] == '/') {
 356         return try_exec(p, path);
 357     }
 358     else {
 359         GSList *it;
 360
 361         for (it = p->exec_dirs; it; it = g_slist_next(it)) {
 362             gchar *f = g_strdup_printf(it->data, G_DIR_SEPARATOR_S, path);
 363             gboolean e = try_exec(p, f);
 364             g_free(f);
 365             if (e) return TRUE;
 366         }
 367     }
 368
 369     return FALSE;
 370 }