src/bin/e_user.c

   1 #include "e.h"
   2
   3
   4 static const char *_e_user_homedir = NULL;
   5 static size_t _e_user_homedir_len = 0;
   6
   7 /* externally accessible functions */
   8 EAPI const char *
   9 e_user_homedir_get(void)
  10 {
  11    char *d;
  12
  13    if (_e_user_homedir)
  14      return _e_user_homedir;
  15
  16    _e_user_homedir = d = getenv("HOME");
  17    if (!_e_user_homedir)
  18      {
  19         _e_user_homedir = "/tmp";
  20         _e_user_homedir_len = sizeof("/tmp") - 1;
  21         return _e_user_homedir;
  22      }
  23
  24    _e_user_homedir_len = strlen(_e_user_homedir);
  25    while ((_e_user_homedir_len > 1) &&
  26           (d[_e_user_homedir_len - 1] == '/'))
  27      {
  28         _e_user_homedir_len--;
  29         d[_e_user_homedir_len] = '\0';
  30      }
  31    return _e_user_homedir;
  32 }
  33
  34 /**
  35  * Concatenate '~/' and @a path.
  36  *
  37  * @return similar to snprintf(), this returns the number of bytes written or
  38  *     that would be required to write if greater or equal than size.
  39  */
  40 EAPI size_t
  41 e_user_homedir_concat_len(char *dst, size_t size, const char *path, size_t path_len)
  42 {
  43    if (!_e_user_homedir)
  44      e_user_homedir_get();
  45
  46    return eina_str_join_len(dst, size, '/', _e_user_homedir, _e_user_homedir_len, path, path_len);
  47 }
  48
  49 EAPI size_t
  50 e_user_homedir_concat(char *dst, size_t size, const char *path)
  51 {
  52    return e_user_homedir_concat_len(dst, size, path, strlen(path));
  53 }
  54
  55 /**
  56  * same as snprintf("~/"fmt, ...).
  57  */
  58 EAPI size_t
  59 e_user_homedir_snprintf(char *dst, size_t size, const char *fmt, ...)
  60 {
  61    size_t off, ret;
  62    va_list ap;
  63
  64    if (!_e_user_homedir)
  65      e_user_homedir_get();
  66    if (!_e_user_homedir)
  67      return 0;
  68
  69    va_start(ap, fmt);
  70
  71    off = _e_user_homedir_len + 1;
  72    if (size < _e_user_homedir_len + 2)
  73      {
  74         if (size > 1)
  75           {
  76              memcpy(dst, _e_user_homedir, size - 1);
  77              dst[size - 1] = '\0';
  78           }
  79         ret = off + vsnprintf(dst + off, size - off, fmt, ap);
  80         va_end(ap);
  81         return ret;
  82      }
  83
  84    memcpy(dst, _e_user_homedir, _e_user_homedir_len);
  85    dst[_e_user_homedir_len] = '/';
  86
  87    ret = off + vsnprintf(dst + off, size - off, fmt, ap);
  88    va_end(ap);
  89    return ret;
  90 }
  91
  92 /**
  93  * Return the directory where user .desktop files should be stored.
  94  * If the directory does not exist, it will be created. If it cannot be
  95  * created, a dialog will be displayed an NULL will be returned
  96  */
  97 EAPI const char *
  98 e_user_desktop_dir_get(void)
  99 {
 100    static char dir[PATH_MAX] = "";
 101
 102    if (!dir[0])
 103      snprintf(dir, sizeof(dir), "%s/applications", efreet_data_home_get());
 104
 105    return dir;
 106 }
 107
 108 /**
 109  * Return the directory where user .icon files should be stored.
 110  * If the directory does not exist, it will be created. If it cannot be
 111  * created, a dialog will be displayed an NULL will be returned
 112  */
 113 EAPI const char *
 114 e_user_icon_dir_get(void)
 115 {
 116    static char dir[PATH_MAX] = "";
 117
 118    if (!dir[0])
 119      snprintf(dir, sizeof(dir), "%s/icons", efreet_data_home_get());
 120
 121    return dir;
 122 }
 123
 124 static const char *_e_user_dir = NULL;
 125 static size_t _e_user_dir_len = 0;
 126
 127 /**
 128  * Return ~/.e/e
 129  */
 130 EAPI const char *
 131 e_user_dir_get(void)
 132 {
 133    static char dir[PATH_MAX] = "";
 134    static char buf[PATH_MAX] = "";
 135
 136    if (!dir[0])
 137      {
 138         char *e_home = getenv("E_HOME");
 139         if (e_home)
 140           {
 141              snprintf(buf, sizeof(buf), "%s/e", e_home);
 142           }
 143         else
 144           {
 145              snprintf(buf, sizeof(buf), ".e/e");
 146           }
 147         _e_user_dir_len = e_user_homedir_concat(dir, sizeof(dir), buf);
 148         _e_user_dir = dir;
 149      }
 150
 151    return dir;
 152 }
 153
 154 /**
 155  * Concatenate '~/.e/e' and @a path.
 156  *
 157  * @return similar to snprintf(), this returns the number of bytes written or
 158  *     that would be required to write if greater or equal than size.
 159  */
 160 EAPI size_t
 161 e_user_dir_concat_len(char *dst, size_t size, const char *path, size_t path_len)
 162 {
 163    if (!_e_user_dir)
 164      e_user_dir_get();
 165
 166    return eina_str_join_len(dst, size, '/', _e_user_dir, _e_user_dir_len, path, path_len);
 167 }
 168
 169 EAPI size_t
 170 e_user_dir_concat(char *dst, size_t size, const char *path)
 171 {
 172    return e_user_dir_concat_len(dst, size, path, strlen(path));
 173 }
 174
 175 /**
 176  * same as snprintf("~/.e/e/"fmt, ...).
 177  */
 178 EAPI size_t
 179 e_user_dir_snprintf(char *dst, size_t size, const char *fmt, ...)
 180 {
 181    size_t off, ret;
 182    va_list ap;
 183
 184    if (!_e_user_dir)
 185      e_user_dir_get();
 186    if (!_e_user_dir)
 187      return 0;
 188
 189    va_start(ap, fmt);
 190
 191    off = _e_user_dir_len + 1;
 192    if (size < _e_user_dir_len + 2)
 193      {
 194         if (size > 1)
 195           {
 196              memcpy(dst, _e_user_dir, size - 1);
 197              dst[size - 1] = '\0';
 198           }
 199         ret = off + vsnprintf(dst + off, size - off, fmt, ap);
 200         va_end(ap);
 201         return ret;
 202      }
 203
 204    memcpy(dst, _e_user_dir, _e_user_dir_len);
 205    dst[_e_user_dir_len] = '/';
 206
 207    ret = off + vsnprintf(dst + off, size - off, fmt, ap);
 208    va_end(ap);
 209    return ret;
 210 }