ROX-Filer/src/support.c

   1 /*
   2  * $Id$
   3  *
   4  * ROX-Filer, filer for the ROX desktop project
   5  * Copyright (C) 2000, Thomas Leonard, <tal197@users.sourceforge.net>.
   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 "config.h"
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <netdb.h>
  29 #include <errno.h>
  30 #include <ctype.h>
  31 #include <sys/param.h>
  32 #include <pwd.h>
  33 #include <grp.h>
  34 #include <fcntl.h>
  35 #include <sys/wait.h>
  36 #include <string.h>
  37 #include <time.h>
  38 #include <unistd.h>
  39
  40 #include "global.h"
  41
  42 #include "main.h"
  43 #include "options.h"
  44 #include "support.h"
  45 #include "my_vfs.h"
  46
  47 static GHashTable *uid_hash = NULL;     /* UID -> User name */
  48 static GHashTable *gid_hash = NULL;     /* GID -> Group name */
  49
  50 /* Static prototypes */
  51
  52
  53 /* Like g_strdup, but does realpath() too (if possible) */
  54 char *pathdup(char *path)
  55 {
  56         char real[MAXPATHLEN];
  57
  58         g_return_val_if_fail(path != NULL, NULL);
  59
  60         if (realpath(path, real))
  61                 return g_strdup(real);
  62
  63         return g_strdup(path);
  64 }
  65
  66 /* Join the path to the leaf (adding a / between them) and
  67  * return a pointer to a buffer with the result. Buffer is valid until
  68  * the next call to make_path.
  69  */
  70 GString *make_path(char *dir, char *leaf)
  71 {
  72         static GString *buffer = NULL;
  73
  74         if (!buffer)
  75                 buffer = g_string_new(NULL);
  76
  77         g_return_val_if_fail(dir != NULL, buffer);
  78         g_return_val_if_fail(leaf != NULL, buffer);
  79
  80         g_string_sprintf(buffer, "%s%s%s",
  81                         dir,
  82                         dir[0] == '/' && dir[1] == '\0' ? "" : "/",
  83                         leaf);
  84
  85         return buffer;
  86 }
  87
  88 /* Return our complete host name */
  89 char *our_host_name(void)
  90 {
  91         static char *name = NULL;
  92
  93         if (option_get_int("dnd_no_hostnames"))
  94                 return "";
  95
  96         if (!name)
  97         {
  98                 char buffer[4096];
  99
 100                 if (gethostname(buffer, 4096) == 0)
 101                 {
 102                         /* gethostname doesn't always return the full name... */
 103                         struct hostent *ent;
 104
 105                         buffer[4095] = '\0';
 106                         ent = gethostbyname(buffer);
 107                         name = g_strdup(ent ? ent->h_name : buffer);
 108                 }
 109                 else
 110                 {
 111                         g_warning("gethostname() failed - using localhost\n");
 112                         name = g_strdup("localhost");
 113                 }
 114         }
 115
 116         return name;
 117 }
 118
 119 /* fork() and run a new program.
 120  * Returns the new PID, or 0 on failure.
 121  */
 122 pid_t spawn(char **argv)
 123 {
 124         return spawn_full(argv, NULL);
 125 }
 126
 127 /* As spawn(), but cd to dir first (if dir is non-NULL) */
 128 pid_t spawn_full(char **argv, char *dir)
 129 {
 130         int     child;
 131
 132         child = fork();
 133
 134         if (child == -1)
 135                 return 0;       /* Failure */
 136         else if (child == 0)
 137         {
 138                 /* We are the child process */
 139                 if (dir)
 140                         if (chdir(dir))
 141                                 fprintf(stderr, "chdir() failed: %s\n",
 142                                                 g_strerror(errno));
 143                 execvp(argv[0], argv);
 144                 fprintf(stderr, "execvp(%s, ...) failed: %s\n",
 145                                 argv[0],
 146                                 g_strerror(errno));
 147                 _exit(0);
 148         }
 149
 150         /* We are the parent */
 151         return child;
 152 }
 153
 154 void debug_free_string(void *data)
 155 {
 156         g_print("Freeing string '%s'\n", (char *) data);
 157         g_free(data);
 158 }
 159
 160 char *user_name(uid_t uid)
 161 {
 162         char    *retval;
 163
 164         if (!uid_hash)
 165                 uid_hash = g_hash_table_new(NULL, NULL);
 166
 167         retval = g_hash_table_lookup(uid_hash, GINT_TO_POINTER(uid));
 168
 169         if (!retval)
 170         {
 171                 struct passwd *passwd;
 172
 173                 passwd = getpwuid(uid);
 174                 retval = passwd ? g_strdup(passwd->pw_name)
 175                                : g_strdup_printf("[%d]", (int) uid);
 176                 g_hash_table_insert(uid_hash, GINT_TO_POINTER(uid), retval);
 177         }
 178
 179         return retval;
 180 }
 181
 182 char *group_name(gid_t gid)
 183 {
 184         char    *retval;
 185
 186         if (!gid_hash)
 187                 gid_hash = g_hash_table_new(NULL, NULL);
 188
 189         retval = g_hash_table_lookup(gid_hash, GINT_TO_POINTER(gid));
 190
 191         if (!retval)
 192         {
 193                 struct group *group;
 194
 195                 group = getgrgid(gid);
 196                 retval = group ? g_strdup(group->gr_name)
 197                                : g_strdup_printf("[%d]", (int) gid);
 198                 g_hash_table_insert(gid_hash, GINT_TO_POINTER(gid), retval);
 199         }
 200
 201         return retval;
 202 }
 203
 204 /* Return a string in the form '23Mb' in a static buffer valid until
 205  * the next call.
 206  */
 207 char *format_size(unsigned long size)
 208 {
 209         static  char *buffer = NULL;
 210         char    *units;
 211
 212         if (size >= PRETTY_SIZE_LIMIT)
 213         {
 214                 size += 1023;
 215                 size >>= 10;
 216                 if (size >= PRETTY_SIZE_LIMIT)
 217                 {
 218                         size += 1023;
 219                         size >>= 10;
 220                         if (size >= PRETTY_SIZE_LIMIT)
 221                         {
 222                                 size += 1023;
 223                                 size >>= 10;
 224                                 units = "Gb";
 225                         }
 226                         else
 227                                 units = "Mb";
 228                 }
 229                 else
 230                         units = "K";
 231         }
 232         else if (size == 1)
 233                 units = _("byte");
 234         else
 235                 units = _("bytes");
 236
 237         if (buffer)
 238                 g_free(buffer);
 239         buffer = g_strdup_printf("%ld %s", size, units);
 240
 241         return buffer;
 242 }
 243
 244 /* Return a string in the form '23Mb' in a static buffer valid until
 245  * the next call. Aligned to the right.
 246  */
 247 char *format_size_aligned(unsigned long size)
 248 {
 249         static  char *buffer = NULL;
 250         char    units;
 251
 252         if (size >= PRETTY_SIZE_LIMIT)
 253         {
 254                 size += 1023;
 255                 size >>= 10;
 256                 if (size >= PRETTY_SIZE_LIMIT)
 257                 {
 258                         size += 1023;
 259                         size >>= 10;
 260                         if (size >= PRETTY_SIZE_LIMIT)
 261                         {
 262                                 size += 1023;
 263                                 size >>= 10;
 264                                 units = 'G';
 265                         }
 266                         else
 267                                 units = 'M';
 268                 }
 269                 else
 270                         units = 'K';
 271         }
 272         else
 273                 units = ' ';
 274
 275         if (buffer)
 276                 g_free(buffer);
 277         buffer = g_strdup_printf("%4ld%c", size, units);
 278
 279         return buffer;
 280 }
 281
 282 /* Fork and exec argv. Wait and return the child's exit status.
 283  * -1 if spawn fails.
 284  */
 285 int fork_exec_wait(char **argv)
 286 {
 287         pid_t   child;
 288         int     status = -1;
 289
 290         child = spawn_full(argv, NULL);
 291
 292         while (child)
 293         {
 294                 if (waitpid(child, &status, 0) == -1)
 295                 {
 296                         if (errno != EINTR)
 297                                 return -1;
 298                 }
 299                 else
 300                         break;
 301         };
 302
 303         return status;
 304 }
 305
 306 /* If a file has this UID and GID, which permissions apply to us?
 307  * 0 = User, 1 = Group, 2 = World
 308  */
 309 gint applicable(uid_t uid, gid_t gid)
 310 {
 311         int     i;
 312
 313         if (uid == euid)
 314                 return 0;
 315
 316         if (gid == egid)
 317                 return 1;
 318
 319         for (i = 0; i < ngroups; i++)
 320         {
 321                 if (supplemental_groups[i] == gid)
 322                         return 1;
 323         }
 324
 325         return 2;
 326 }
 327
 328 /* Converts a file's mode to a string. Result is a pointer
 329  * to a static buffer, valid until the next call.
 330  */
 331 char *pretty_permissions(mode_t m)
 332 {
 333         static char buffer[] = "rwx,rwx,rwx/UGT";
 334
 335         buffer[0]  = m & S_IRUSR ? 'r' : '-';
 336         buffer[1]  = m & S_IWUSR ? 'w' : '-';
 337         buffer[2]  = m & S_IXUSR ? 'x' : '-';
 338
 339         buffer[4]  = m & S_IRGRP ? 'r' : '-';
 340         buffer[5]  = m & S_IWGRP ? 'w' : '-';
 341         buffer[6]  = m & S_IXGRP ? 'x' : '-';
 342
 343         buffer[8]  = m & S_IROTH ? 'r' : '-';
 344         buffer[9]  = m & S_IWOTH ? 'w' : '-';
 345         buffer[10] = m & S_IXOTH ? 'x' : '-';
 346
 347         buffer[12] = m & S_ISUID ? 'U' : '-';
 348         buffer[13] = m & S_ISGID ? 'G' : '-';
 349 #ifdef S_ISVTX
 350         buffer[14] = m & S_ISVTX ? 'T' : '-';
 351         buffer[15] = 0;
 352 #else
 353         buffer[14] = 0;
 354 #endif
 355
 356         return buffer;
 357 }
 358
 359 /* Gets the canonical name for address and compares to our_host_name() */
 360 static gboolean is_local_address(char *address)
 361 {
 362         struct hostent *ent;
 363
 364         ent = gethostbyname(address);
 365
 366         return strcmp(our_host_name(), ent ? ent->h_name : address) == 0;
 367 }
 368
 369 /* Convert a URI to a local pathname (or NULL if it isn't local).
 370  * The returned pointer points inside the input string.
 371  * Possible formats:
 372  *      /path
 373  *      ///path
 374  *      //host/path
 375  *      file://host/path
 376  */
 377 char *get_local_path(char *uri)
 378 {
 379         if (*uri == '/')
 380         {
 381                 char    *path, *uri_host;
 382
 383                 if (uri[1] != '/')
 384                         return uri;     /* Just a local path - no host part */
 385
 386                 path = strchr(uri + 2, '/');
 387                 if (!path)
 388                         return NULL;        /* //something */
 389
 390                 if (path - uri == 2)
 391                         return path;    /* ///path */
 392
 393                 uri_host = g_strndup(uri + 2, path - uri - 2);
 394                 if (is_local_address(uri_host))
 395                 {
 396                         g_free(uri_host);
 397                         return path;    /* //myhost/path */
 398                 }
 399                 g_free(uri_host);
 400
 401                 return NULL;        /* From a different host */
 402         }
 403         else
 404         {
 405                 if (strncasecmp(uri, "file:", 5))
 406                         return NULL;        /* Don't know this format */
 407
 408                 uri += 5;
 409
 410                 if (*uri == '/')
 411                         return get_local_path(uri);
 412
 413                 return NULL;
 414         }
 415 }
 416
 417 /* Set the close-on-exec flag for this FD.
 418  * TRUE means that an exec()'d process will not get the FD.
 419  */
 420 void close_on_exec(int fd, gboolean close)
 421 {
 422         if (fcntl(fd, F_SETFD, close))
 423                 g_warning("fcntl() failed: %s\n", g_strerror(errno));
 424 }
 425
 426 void set_blocking(int fd, gboolean blocking)
 427 {
 428         if (fcntl(fd, F_SETFL, blocking ? 0 : O_NONBLOCK))
 429                 g_warning("fcntl() failed: %s\n", g_strerror(errno));
 430 }
 431
 432 /* Format this time nicely. The result is a pointer to a static buffer,
 433  * valid until the next call.
 434  */
 435 char *pretty_time(time_t *time)
 436 {
 437         static char time_buf[32];
 438
 439         if (strftime(time_buf, sizeof(time_buf),
 440                         TIME_FORMAT, localtime(time)) == 0)
 441                 time_buf[0]= 0;
 442
 443         return time_buf;
 444 }
 445
 446 #ifndef O_NOFOLLOW
 447 #  define O_NOFOLLOW 0x0
 448 #endif
 449
 450 #ifdef HAVE_LIBVFS
 451 /* Copy data from 'read_fd' FD to 'write_fd' FD until EOF or error.
 452  * Returns 0 on success, -1 on error (and sets errno).
 453  */
 454 static int copy_fd(int read_fd, int write_fd)
 455 {
 456         char    buffer[4096];
 457         int     got;
 458
 459         while ((got = mc_read(read_fd, buffer, sizeof(buffer))) > 0)
 460         {
 461                 int sent = 0;
 462
 463                 while (sent < got)
 464                 {
 465                         int     c;
 466
 467                         c = mc_write(write_fd, buffer + sent, got - sent);
 468                         if (c < 0)
 469                                 return -1;
 470                         sent += c;
 471                 }
 472         }
 473
 474         return got;
 475 }
 476 #endif
 477
 478 /* 'from' and 'to' are complete pathnames of files (not dirs or symlinks).
 479  * This spawns 'cp' to do the copy if lstat() succeeds, otherwise we
 480  * do the copy manually using vfs.
 481  *
 482  * Returns an error string, or NULL on success.
 483  */
 484 guchar *copy_file(guchar *from, guchar *to)
 485 {
 486         char    *argv[] = {"cp", "-pRf", NULL, NULL, NULL};
 487
 488 #ifdef HAVE_LIBVFS
 489         struct  stat    info;
 490
 491         if (lstat(from, &info))
 492         {
 493                 int     read_fd = -1;
 494                 int     write_fd = -1;
 495                 int     error = 0;
 496
 497                 if (mc_lstat(from, &info))
 498                         return g_strerror(errno);
 499
 500                 /* Regular lstat() can't find it, but mc_lstat() can,
 501                  * so try reading it with VFS.
 502                  */
 503
 504                 if (!S_ISREG(info.st_mode))
 505                         goto err;
 506
 507                 read_fd = mc_open(from, O_RDONLY);
 508                 if (read_fd == -1)
 509                         goto err;
 510                 write_fd = mc_open(to,
 511                                 O_NOFOLLOW | O_WRONLY | O_CREAT | O_TRUNC,
 512                                 info.st_mode & 0777);
 513                 if (write_fd == -1)
 514                         goto err;
 515
 516                 if (copy_fd(read_fd, write_fd))
 517                         goto err;
 518
 519                 /* (yes, the single | is right) */
 520                 if (mc_close(read_fd) | mc_close(write_fd))
 521                         return g_strerror(errno);
 522                 return NULL;
 523 err:
 524                 error = errno;
 525                 if (read_fd != -1)
 526                         mc_close(read_fd);
 527                 if (write_fd != -1)
 528                         mc_close(write_fd);
 529                 return error ? g_strerror(error) : _("Copy error");
 530         }
 531 #endif
 532
 533         argv[2] = from;
 534         argv[3] = to;
 535
 536         if (fork_exec_wait(argv))
 537                 return _("Copy failed");
 538         return NULL;
 539 }
 540
 541 /* 'word' has all special characters escaped so that it may be inserted
 542  * into a shell command.
 543  * Eg: 'My Dir?' becomes 'My\ Dir\?'. g_free() the result.
 544  */
 545 guchar *shell_escape(guchar *word)
 546 {
 547         GString *tmp;
 548         guchar  *retval;
 549
 550         tmp = g_string_new(NULL);
 551
 552         while (*word)
 553         {
 554                 if (strchr(" ?*['\"$~\\|();!`&", *word))
 555                         g_string_append_c(tmp, '\\');
 556                 g_string_append_c(tmp, *word);
 557                 word++;
 558         }
 559
 560         retval = tmp->str;
 561         g_string_free(tmp, FALSE);
 562         return retval;
 563 }
 564
 565 /* TRUE iff `sub' is (or would be) an object inside the directory `parent',
 566  * (or the two are the same item/directory).
 567  * FALSE if parent doesn't exist.
 568  */
 569 gboolean is_sub_dir(char *sub, char *parent)
 570 {
 571         struct stat     parent_info;
 572
 573         /* These were pathdup()s, but that follows symlinks!
 574          * I guess they were here for a reason - something is probably
 575          * broken now...
 576          */
 577         sub = g_strdup(sub);
 578
 579         if (mc_stat(parent, &parent_info))
 580                 return FALSE;           /* Parent doesn't exist */
 581
 582         while (1)
 583         {
 584                 char        *slash;
 585                 struct stat info;
 586
 587                 if (mc_stat(sub, &info) == 0)
 588                 {
 589                         if (info.st_dev == parent_info.st_dev &&
 590                                 info.st_ino == parent_info.st_ino)
 591                         {
 592                                 g_free(sub);
 593                                 return TRUE;
 594                         }
 595                 }
 596
 597                 slash = strrchr(sub, '/');
 598                 if (!slash)
 599                         break;
 600                 if (slash == sub)
 601                 {
 602                         if (sub[1])
 603                                 sub[1] = '\0';
 604                         else
 605                                 break;
 606                 }
 607                 else
 608                         *slash = '\0';
 609         }
 610
 611         g_free(real_sub);
 612         g_free(real_parent);
 613         g_free(sub);
 614
 615         return retval;
 616 }
 617
 618 /* True if the string 'list' contains 'item'.
 619  * Eg ("close", "close, help") -> TRUE
 620  */
 621 gboolean in_list(guchar *item, guchar *list)
 622 {
 623         int     len;
 624
 625         len = strlen(item);
 626
 627         while (*list)
 628         {
 629                 if (strncmp(item, list, len) == 0 && !isalpha(list[len]))
 630                         return TRUE;
 631                 list = strchr(list, ',');
 632                 if (!list)
 633                         return FALSE;
 634                 while (isspace(*++list))
 635                         ;
 636         }
 637
 638         return FALSE;
 639 }