ROX-Filer/src/support.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 1999, Thomas Leonard, <tal197@ecs.soton.ac.uk>.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19  * Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* support.c - (non-GUI) useful routines */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <errno.h>
  27 #include <ctype.h>
  28 #include <sys/param.h>
  29 #include <unistd.h>
  30 #include <pwd.h>
  31 #include <grp.h>
  32 #include <fcntl.h>
  33 #include <sys/wait.h>
  34 #include <sys/stat.h>
  35 #include <string.h>
  36 #include <time.h>
  37
  38 #include <glib.h>
  39
  40 #include "main.h"
  41 #include "support.h"
  42
  43 static GHashTable *uid_hash = NULL;     /* UID -> User name */
  44 static GHashTable *gid_hash = NULL;     /* GID -> Group name */
  45
  46 /* Static prototypes */
  47
  48
  49 /* Like g_strdup, but does realpath() too (if possible) */
  50 char *pathdup(char *path)
  51 {
  52         char real[MAXPATHLEN];
  53
  54         g_return_val_if_fail(path != NULL, NULL);
  55
  56         if (realpath(path, real))
  57                 return g_strdup(real);
  58
  59         return g_strdup(path);
  60 }
  61
  62 /* Join the path to the leaf (adding a / between them) and
  63  * return a pointer to a buffer with the result. Buffer is valid until
  64  * the next call to make_path.
  65  */
  66 GString *make_path(char *dir, char *leaf)
  67 {
  68         static GString *buffer = NULL;
  69
  70         if (!buffer)
  71                 buffer = g_string_new(NULL);
  72
  73         g_return_val_if_fail(dir != NULL, buffer);
  74         g_return_val_if_fail(leaf != NULL, buffer);
  75
  76         g_string_sprintf(buffer, "%s%s%s",
  77                         dir,
  78                         dir[0] == '/' && dir[1] == '\0' ? "" : "/",
  79                         leaf);
  80
  81         return buffer;
  82 }
  83
  84 /* Return our complete host name */
  85 char *our_host_name()
  86 {
  87         static char *name = NULL;
  88
  89         if (!name)
  90         {
  91                 char buffer[4096];
  92
  93                 g_return_val_if_fail(gethostname(buffer, 4096) == 0,
  94                                         "localhost");
  95
  96                 buffer[4095] = '\0';
  97                 name = g_strdup(buffer);
  98         }
  99
 100         return name;
 101 }
 102
 103 /* fork() and run a new program.
 104  * Returns the new PID, or 0 on failure.
 105  */
 106 pid_t spawn(char **argv)
 107 {
 108         return spawn_full(argv, NULL);
 109 }
 110
 111 /* As spawn(), but cd to dir first (if dir is non-NULL) */
 112 pid_t spawn_full(char **argv, char *dir)
 113 {
 114         int     child;
 115
 116         child = fork();
 117
 118         if (child == -1)
 119                 return 0;       /* Failure */
 120         else if (child == 0)
 121         {
 122                 /* We are the child process */
 123                 if (dir)
 124                         if (chdir(dir))
 125                                 fprintf(stderr, "chdir() failed: %s\n",
 126                                                 g_strerror(errno));
 127                 dup2(to_error_log, STDERR_FILENO);
 128                 close_on_exec(STDERR_FILENO, FALSE);
 129                 execvp(argv[0], argv);
 130                 fprintf(stderr, "execvp(%s, ...) failed: %s\n",
 131                                 argv[0],
 132                                 g_strerror(errno));
 133                 _exit(0);
 134         }
 135
 136         /* We are the parent */
 137         return child;
 138 }
 139
 140 void debug_free_string(void *data)
 141 {
 142         g_print("Freeing string '%s'\n", (char *) data);
 143         g_free(data);
 144 }
 145
 146 char *user_name(uid_t uid)
 147 {
 148         char    *retval;
 149
 150         if (!uid_hash)
 151                 uid_hash = g_hash_table_new(NULL, NULL);
 152
 153         retval = g_hash_table_lookup(uid_hash, (gpointer) uid);
 154
 155         if (!retval)
 156         {
 157                 struct passwd *passwd;
 158
 159                 passwd = getpwuid(uid);
 160                 retval = passwd ? g_strdup(passwd->pw_name)
 161                                : g_strdup_printf("[%d]", (int) uid);
 162                 g_hash_table_insert(uid_hash, (gpointer) uid, retval);
 163         }
 164
 165         return retval;
 166 }
 167
 168 char *group_name(gid_t gid)
 169 {
 170         char    *retval;
 171
 172         if (!gid_hash)
 173                 gid_hash = g_hash_table_new(NULL, NULL);
 174
 175         retval = g_hash_table_lookup(gid_hash, (gpointer) gid);
 176
 177         if (!retval)
 178         {
 179                 struct group *group;
 180
 181                 group = getgrgid(gid);
 182                 retval = group ? g_strdup(group->gr_name)
 183                                : g_strdup_printf("[%d]", (int) gid);
 184                 g_hash_table_insert(gid_hash, (gpointer) gid, retval);
 185         }
 186
 187         return retval;
 188 }
 189
 190 /* Return a string in the form '23Mb' in a static buffer valid until
 191  * the next call.
 192  */
 193 char *format_size(unsigned long size)
 194 {
 195         static  char *buffer = NULL;
 196         char    *units;
 197
 198         if (size >= PRETTY_SIZE_LIMIT)
 199         {
 200                 size += 1023;
 201                 size >>= 10;
 202                 if (size >= PRETTY_SIZE_LIMIT)
 203                 {
 204                         size += 1023;
 205                         size >>= 10;
 206                         if (size >= PRETTY_SIZE_LIMIT)
 207                         {
 208                                 size += 1023;
 209                                 size >>= 10;
 210                                 units = "Gb";
 211                         }
 212                         else
 213                                 units = "Mb";
 214                 }
 215                 else
 216                         units = "K";
 217         }
 218         else
 219                 units = "bytes";
 220
 221         if (buffer)
 222                 g_free(buffer);
 223         buffer = g_strdup_printf("%ld %s", size, units);
 224
 225         return buffer;
 226 }
 227
 228 /* Return a string in the form '23Mb' in a static buffer valid until
 229  * the next call. Aligned to the right.
 230  */
 231 char *format_size_aligned(unsigned long size)
 232 {
 233         static  char *buffer = NULL;
 234         char    units;
 235
 236         if (size >= PRETTY_SIZE_LIMIT)
 237         {
 238                 size += 1023;
 239                 size >>= 10;
 240                 if (size >= PRETTY_SIZE_LIMIT)
 241                 {
 242                         size += 1023;
 243                         size >>= 10;
 244                         if (size >= PRETTY_SIZE_LIMIT)
 245                         {
 246                                 size += 1023;
 247                                 size >>= 10;
 248                                 units = 'G';
 249                         }
 250                         else
 251                                 units = 'M';
 252                 }
 253                 else
 254                         units = 'K';
 255         }
 256         else
 257                 units = ' ';
 258
 259         if (buffer)
 260                 g_free(buffer);
 261         buffer = g_strdup_printf("%4ld%c", size, units);
 262
 263         return buffer;
 264 }
 265
 266 /* Fork and exec argv. Wait and return the child's exit status.
 267  * -1 if spawn fails.
 268  */
 269 int fork_exec_wait(char **argv)
 270 {
 271         pid_t   child;
 272         int     status = -1;
 273
 274         child = spawn_full(argv, NULL);
 275
 276         while (child)
 277         {
 278                 if (waitpid(child, &status, 0) == -1)
 279                 {
 280                         if (errno != EINTR)
 281                                 return -1;
 282                 }
 283                 else
 284                         break;
 285         };
 286
 287         return status;
 288 }
 289
 290 /* If a file has this UID and GID, which permissions apply to us?
 291  * 0 = User, 1 = Group, 2 = World
 292  */
 293 gint applicable(uid_t uid, gid_t gid)
 294 {
 295         int     i;
 296
 297         if (uid == euid)
 298                 return 0;
 299
 300         if (gid == egid)
 301                 return 1;
 302
 303         for (i = 0; i < ngroups; i++)
 304         {
 305                 if (supplemental_groups[i] == gid)
 306                         return 1;
 307         }
 308
 309         return 2;
 310 }
 311
 312 /* Converts a file's mode to a string. Result is a pointer
 313  * to a static buffer, valid until the next call.
 314  */
 315 char *pretty_permissions(mode_t m)
 316 {
 317         static char buffer[] = "rwx,rwx,rwx/UGT";
 318
 319         buffer[0]  = m & S_IRUSR ? 'r' : '-';
 320         buffer[1]  = m & S_IWUSR ? 'w' : '-';
 321         buffer[2]  = m & S_IXUSR ? 'x' : '-';
 322
 323         buffer[4]  = m & S_IRGRP ? 'r' : '-';
 324         buffer[5]  = m & S_IWGRP ? 'w' : '-';
 325         buffer[6]  = m & S_IXGRP ? 'x' : '-';
 326
 327         buffer[8]  = m & S_IROTH ? 'r' : '-';
 328         buffer[9]  = m & S_IWOTH ? 'w' : '-';
 329         buffer[10] = m & S_IXOTH ? 'x' : '-';
 330
 331         buffer[12] = m & S_ISUID ? 'U' : '-';
 332         buffer[13] = m & S_ISGID ? 'G' : '-';
 333 #ifdef S_ISVTX
 334         buffer[14] = m & S_ISVTX ? 'T' : '-';
 335         buffer[15] = 0;
 336 #else
 337         buffer[14] = 0;
 338 #endif
 339
 340         return buffer;
 341 }
 342
 343 /* Convert a URI to a local pathname (or NULL if it isn't local).
 344  * The returned pointer points inside the input string.
 345  * Possible formats:
 346  *      /path
 347  *      ///path
 348  *      //host/path
 349  *      file://host/path
 350  */
 351 char *get_local_path(char *uri)
 352 {
 353         char    *host;
 354
 355         host = our_host_name();
 356
 357         if (*uri == '/')
 358         {
 359                 char    *path;
 360
 361                 if (uri[1] != '/')
 362                         return uri;     /* Just a local path - no host part */
 363
 364                 path = strchr(uri + 2, '/');
 365                 if (!path)
 366                         return NULL;        /* //something */
 367
 368                 if (path - uri == 2)
 369                         return path;    /* ///path */
 370                 if (strlen(host) == path - uri - 2 &&
 371                         strncmp(uri + 2, host, path - uri - 2) == 0)
 372                         return path;    /* //myhost/path */
 373
 374                 return NULL;        /* From a different host */
 375         }
 376         else
 377         {
 378                 if (strncasecmp(uri, "file:", 5))
 379                         return NULL;        /* Don't know this format */
 380
 381                 uri += 5;
 382
 383                 if (*uri == '/')
 384                         return get_local_path(uri);
 385
 386                 return NULL;
 387         }
 388 }
 389
 390 /* Set the close-on-exec flag for this FD.
 391  * TRUE means that an exec()'d process will not get the FD.
 392  */
 393 void close_on_exec(int fd, gboolean close)
 394 {
 395         if (fcntl(fd, F_SETFD, close))
 396                 g_warning("fcntl() failed: %s\n", g_strerror(errno));
 397 }
 398
 399 void set_blocking(int fd, gboolean blocking)
 400 {
 401         if (fcntl(fd, F_SETFL, blocking ? 0 : O_NONBLOCK))
 402                 g_warning("fcntl() failed: %s\n", g_strerror(errno));
 403 }
 404
 405 /* Format this time nicely. The result is a pointer to a static buffer,
 406  * valid until the next call.
 407  */
 408 char *pretty_time(time_t *time)
 409 {
 410         static char time_buf[32];
 411
 412         if (strftime(time_buf, sizeof(time_buf),
 413                         TIME_FORMAT, localtime(time)) == 0)
 414                 time_buf[0]= 0;
 415
 416         return time_buf;
 417 }
 418
 419