[ tor-browser ].git.dasho

nsinstall.c (11510B)
      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
      2 /* This Source Code Form is subject to the terms of the Mozilla Public
      3 * License, v. 2.0. If a copy of the MPL was not distributed with this
      4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      5 
      6 /*
      7 ** Netscape portable install command.
      8 **
      9 ** Brendan Eich, 7/20/95
     10 */
     11 #include <stdio.h> /* OSF/1 requires this before grp.h, so put it first */
     12 #include <assert.h>
     13 #include <fcntl.h>
     14 #include <grp.h>
     15 #include <pwd.h>
     16 #include <stdlib.h>
     17 #include <string.h>
     18 #include <unistd.h>
     19 #include <utime.h>
     20 #include <sys/types.h>
     21 #include <sys/stat.h>
     22 #include <dirent.h>
     23 #include <errno.h>
     24 #include <stdarg.h>
     25 #ifdef USE_REENTRANT_LIBC
     26 #  include "libc_r.h"
     27 #endif /* USE_REENTRANT_LIBC */
     28 
     29 #include "pathsub.h"
     30 
     31 #define HAVE_FCHMOD
     32 
     33 /*
     34 * Does getcwd() take NULL as the first argument and malloc
     35 * the result buffer?
     36 */
     37 #if !defined(DARWIN)
     38 #  define GETCWD_CAN_MALLOC
     39 #endif
     40 
     41 #if defined(LINUX) || defined(__GNU__) || defined(__GLIBC__)
     42 #  include <getopt.h>
     43 #endif
     44 
     45 #ifdef QNX
     46 #  define d_ino d_stat.st_ino
     47 #endif
     48 
     49 static void usage(void) {
     50  fprintf(stderr,
     51          "usage: %s [-C cwd] [-L linkprefix] [-m mode] [-o owner] [-g group]\n"
     52          "       %*s [-DdltR] file [file ...] directory\n",
     53          program, (int)strlen(program), "");
     54  exit(2);
     55 }
     56 
     57 static int mkdirs(char* path, mode_t mode) {
     58  char* cp;
     59  struct stat sb;
     60  int res;
     61 
     62  while (*path == '/' && path[1] == '/') {
     63    path++;
     64  }
     65  for (cp = strrchr(path, '/'); cp && cp != path && cp[-1] == '/'; cp--);
     66  if (cp && cp != path) {
     67    *cp = '\0';
     68    if ((stat(path, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
     69        mkdirs(path, mode) < 0) {
     70      return -1;
     71    }
     72    *cp = '/';
     73  }
     74  res = mkdir(path, mode);
     75  if ((res != 0) && (errno == EEXIST)) {
     76    return 0;
     77  } else {
     78    return res;
     79  }
     80 }
     81 
     82 static uid_t touid(char* owner) {
     83  struct passwd* pw;
     84  uid_t uid;
     85  char* cp;
     86 
     87  pw = getpwnam(owner);
     88  if (pw) {
     89    return pw->pw_uid;
     90  }
     91  uid = strtol(owner, &cp, 0);
     92  if (uid == 0 && cp == owner) {
     93    fail("cannot find uid for %s", owner);
     94  }
     95  return uid;
     96 }
     97 
     98 static gid_t togid(char* group) {
     99  struct group* gr;
    100  gid_t gid;
    101  char* cp;
    102 
    103  gr = getgrnam(group);
    104  if (gr) {
    105    return gr->gr_gid;
    106  }
    107  gid = strtol(group, &cp, 0);
    108  if (gid == 0 && cp == group) {
    109    fail("cannot find gid for %s", group);
    110  }
    111  return gid;
    112 }
    113 
    114 int main(int argc, char** argv) {
    115  int onlydir, dodir, dolink, dorelsymlink, dotimes, opt, len, lplen, tdlen,
    116      bnlen, exists, fromfd, tofd, cc, wc;
    117  mode_t mode = 0755;
    118  char *linkprefix, *owner, *group, *cp, *cwd, *todir, *toname, *name, *base,
    119      *linkname, *bp, buf[BUFSIZ];
    120  uid_t uid;
    121  gid_t gid;
    122  struct stat sb, tosb;
    123  struct utimbuf utb;
    124 
    125  program = argv[0];
    126  cwd = linkname = linkprefix = owner = group = 0;
    127  onlydir = dodir = dolink = dorelsymlink = dotimes = lplen = 0;
    128 
    129  while ((opt = getopt(argc, argv, "C:DdlL:Rm:o:g:t")) != EOF) {
    130    switch (opt) {
    131      case 'C':
    132        cwd = optarg;
    133        break;
    134      case 'D':
    135        onlydir = 1;
    136        break;
    137      case 'd':
    138        dodir = 1;
    139        break;
    140      case 'l':
    141        dolink = 1;
    142        break;
    143      case 'L':
    144        linkprefix = optarg;
    145        lplen = strlen(linkprefix);
    146        dolink = 1;
    147        break;
    148      case 'R':
    149        dolink = dorelsymlink = 1;
    150        break;
    151      case 'm':
    152        mode = strtoul(optarg, &cp, 8);
    153        if (mode == 0 && cp == optarg) {
    154          usage();
    155        }
    156        break;
    157      case 'o':
    158        owner = optarg;
    159        break;
    160      case 'g':
    161        group = optarg;
    162        break;
    163      case 't':
    164        dotimes = 1;
    165        break;
    166      default:
    167        usage();
    168    }
    169  }
    170 
    171  argc -= optind;
    172  argv += optind;
    173  if (argc < 2 - onlydir) {
    174    usage();
    175  }
    176 
    177  todir = argv[argc - 1];
    178  if ((stat(todir, &sb) < 0 || !S_ISDIR(sb.st_mode)) &&
    179      mkdirs(todir, 0777) < 0) {
    180    fail("cannot make directory %s", todir);
    181  }
    182  if (onlydir) {
    183    return 0;
    184  }
    185 
    186  if (!cwd) {
    187 #ifdef GETCWD_CAN_MALLOC
    188    cwd = getcwd(0, PATH_MAX);
    189 #else
    190    cwd = malloc(PATH_MAX + 1);
    191    cwd = getcwd(cwd, PATH_MAX);
    192 #endif
    193  }
    194  xchdir(todir);
    195 #ifdef GETCWD_CAN_MALLOC
    196  todir = getcwd(0, PATH_MAX);
    197 #else
    198  todir = malloc(PATH_MAX + 1);
    199  todir = getcwd(todir, PATH_MAX);
    200 #endif
    201  xchdir(cwd);
    202  tdlen = strlen(todir);
    203 
    204  uid = owner ? touid(owner) : -1;
    205  gid = group ? togid(group) : -1;
    206 
    207  while (--argc > 0) {
    208    name = *argv++;
    209    len = strlen(name);
    210    base = xbasename(name);
    211    bnlen = strlen(base);
    212    toname = (char*)xmalloc(tdlen + 1 + bnlen + 1);
    213    sprintf(toname, "%s/%s", todir, base);
    214    exists = (lstat(toname, &tosb) == 0);
    215 
    216    if (dodir) {
    217      /* -d means create a directory, always */
    218      if (exists && !S_ISDIR(tosb.st_mode)) {
    219        (void)unlink(toname);
    220        exists = 0;
    221      }
    222      if (!exists && mkdir(toname, mode) < 0) {
    223        fail("cannot make directory %s", toname);
    224      }
    225      if ((owner || group) && chown(toname, uid, gid) < 0) {
    226        fail("cannot change owner of %s", toname);
    227      }
    228    } else if (dolink) {
    229      if (*name == '/') {
    230        /* source is absolute pathname, link to it directly */
    231        linkname = 0;
    232      } else {
    233        if (linkprefix) {
    234          /* -L implies -l and prefixes names with a $cwd arg. */
    235          len += lplen + 1;
    236          linkname = (char*)xmalloc(len + 1);
    237          sprintf(linkname, "%s/%s", linkprefix, name);
    238        } else if (dorelsymlink) {
    239          /* Symlink the relative path from todir to source name. */
    240          linkname = (char*)xmalloc(PATH_MAX);
    241 
    242          if (*todir == '/') {
    243            /* todir is absolute: skip over common prefix. */
    244            lplen = relatepaths(todir, cwd, linkname);
    245            strcpy(linkname + lplen, name);
    246          } else {
    247            /* todir is named by a relative path: reverse it. */
    248            reversepath(todir, name, len, linkname);
    249            xchdir(cwd);
    250          }
    251 
    252          len = strlen(linkname);
    253        }
    254        name = linkname;
    255      }
    256 
    257      /* Check for a pre-existing symlink with identical content. */
    258      if (exists &&
    259          (!S_ISLNK(tosb.st_mode) || readlink(toname, buf, sizeof buf) != len ||
    260           strncmp(buf, name, len) != 0)) {
    261        (void)(S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
    262        exists = 0;
    263      }
    264      if (!exists && symlink(name, toname) < 0) {
    265        fail("cannot make symbolic link %s", toname);
    266      }
    267 #ifdef HAVE_LCHOWN
    268      if ((owner || group) && lchown(toname, uid, gid) < 0) {
    269        fail("cannot change owner of %s", toname);
    270      }
    271 #endif
    272 
    273      if (linkname) {
    274        free(linkname);
    275        linkname = 0;
    276      }
    277    } else {
    278      /* Copy from name to toname, which might be the same file. */
    279      fromfd = open(name, O_RDONLY);
    280      if (fromfd < 0 || fstat(fromfd, &sb) < 0) {
    281        fail("cannot access %s", name);
    282      }
    283      if (exists && (!S_ISREG(tosb.st_mode) || access(toname, W_OK) < 0)) {
    284        (void)(S_ISDIR(tosb.st_mode) ? rmdir : unlink)(toname);
    285      }
    286      tofd = open(toname, O_CREAT | O_WRONLY, 0666);
    287      if (tofd < 0) {
    288        fail("cannot create %s", toname);
    289      }
    290 
    291      bp = buf;
    292      while ((cc = read(fromfd, bp, sizeof buf)) > 0) {
    293        while ((wc = write(tofd, bp, cc)) > 0) {
    294          if ((cc -= wc) == 0) {
    295            break;
    296          }
    297          bp += wc;
    298        }
    299        if (wc < 0) {
    300          fail("cannot write to %s", toname);
    301        }
    302      }
    303      if (cc < 0) {
    304        fail("cannot read from %s", name);
    305      }
    306 
    307      if (ftruncate(tofd, sb.st_size) < 0) {
    308        fail("cannot truncate %s", toname);
    309      }
    310      if (dotimes) {
    311        utb.actime = sb.st_atime;
    312        utb.modtime = sb.st_mtime;
    313        if (utime(toname, &utb) < 0) {
    314          fail("cannot set times of %s", toname);
    315        }
    316      }
    317 #ifdef HAVE_FCHMOD
    318      if (fchmod(tofd, mode) < 0)
    319 #else
    320      if (chmod(toname, mode) < 0)
    321 #endif
    322        fail("cannot change mode of %s", toname);
    323      if ((owner || group) && fchown(tofd, uid, gid) < 0) {
    324        fail("cannot change owner of %s", toname);
    325      }
    326 
    327      /* Must check for delayed (NFS) write errors on close. */
    328      if (close(tofd) < 0) {
    329        fail("cannot write to %s", toname);
    330      }
    331      close(fromfd);
    332    }
    333 
    334    free(toname);
    335  }
    336 
    337  free(cwd);
    338  free(todir);
    339  return 0;
    340 }
    341 
    342 /*
    343 ** Pathname subroutines.
    344 **
    345 ** Brendan Eich, 8/29/95
    346 */
    347 
    348 char* program;
    349 
    350 void fail(char* format, ...) {
    351  int error;
    352  va_list ap;
    353 
    354 #ifdef USE_REENTRANT_LIBC
    355  R_STRERROR_INIT_R();
    356 #endif
    357 
    358  error = errno;
    359  fprintf(stderr, "%s: ", program);
    360  va_start(ap, format);
    361  vfprintf(stderr, format, ap);
    362  va_end(ap);
    363  if (error)
    364 
    365 #ifdef USE_REENTRANT_LIBC
    366    R_STRERROR_R(errno);
    367  fprintf(stderr, ": %s", r_strerror_r);
    368 #else
    369    fprintf(stderr, ": %s", strerror(errno));
    370 #endif
    371 
    372  putc('\n', stderr);
    373  exit(1);
    374 }
    375 
    376 char* getcomponent(char* path, char* name) {
    377  if (*path == '\0') {
    378    return 0;
    379  }
    380  if (*path == '/') {
    381    *name++ = '/';
    382  } else {
    383    do {
    384      *name++ = *path++;
    385    } while (*path != '/' && *path != '\0');
    386  }
    387  *name = '\0';
    388  while (*path == '/') {
    389    path++;
    390  }
    391  return path;
    392 }
    393 
    394 char* ino2name(ino_t ino, char* dir) {
    395  DIR* dp;
    396  struct dirent* ep;
    397  char* name;
    398 
    399  dp = opendir("..");
    400  if (!dp) {
    401    fail("cannot read parent directory");
    402  }
    403  for (;;) {
    404    if (!(ep = readdir(dp))) {
    405      fail("cannot find current directory");
    406    }
    407    if (ep->d_ino == ino) {
    408      break;
    409    }
    410  }
    411  name = xstrdup(ep->d_name);
    412  closedir(dp);
    413  return name;
    414 }
    415 
    416 void* xmalloc(size_t size) {
    417  void* p = malloc(size);
    418  if (!p) {
    419    fail("cannot allocate %u bytes", size);
    420  }
    421  return p;
    422 }
    423 
    424 char* xstrdup(char* s) { return strcpy((char*)xmalloc(strlen(s) + 1), s); }
    425 
    426 char* xbasename(char* path) {
    427  char* cp;
    428 
    429  while ((cp = strrchr(path, '/')) && cp[1] == '\0') {
    430    *cp = '\0';
    431  }
    432  if (!cp) {
    433    return path;
    434  }
    435  return cp + 1;
    436 }
    437 
    438 void xchdir(char* dir) {
    439  if (chdir(dir) < 0) {
    440    fail("cannot change directory to %s", dir);
    441  }
    442 }
    443 
    444 int relatepaths(char* from, char* to, char* outpath) {
    445  char *cp, *cp2;
    446  int len;
    447  char buf[NAME_MAX];
    448 
    449  assert(*from == '/' && *to == '/');
    450  for (cp = to, cp2 = from; *cp == *cp2; cp++, cp2++)
    451    if (*cp == '\0') {
    452      break;
    453    }
    454  while (cp[-1] != '/') {
    455    cp--, cp2--;
    456  }
    457  if (cp - 1 == to) {
    458    /* closest common ancestor is /, so use full pathname */
    459    len = strlen(strcpy(outpath, to));
    460    if (outpath[len] != '/') {
    461      outpath[len++] = '/';
    462      outpath[len] = '\0';
    463    }
    464  } else {
    465    len = 0;
    466    while ((cp2 = getcomponent(cp2, buf)) != 0) {
    467      strcpy(outpath + len, "../");
    468      len += 3;
    469    }
    470    while ((cp = getcomponent(cp, buf)) != 0) {
    471      sprintf(outpath + len, "%s/", buf);
    472      len += strlen(outpath + len);
    473    }
    474  }
    475  return len;
    476 }
    477 
    478 void reversepath(char* inpath, char* name, int len, char* outpath) {
    479  char *cp, *cp2;
    480  char buf[NAME_MAX];
    481  struct stat sb;
    482 
    483  cp = strcpy(outpath + PATH_MAX - (len + 1), name);
    484  cp2 = inpath;
    485  while ((cp2 = getcomponent(cp2, buf)) != 0) {
    486    if (strcmp(buf, ".") == 0) {
    487      continue;
    488    }
    489    if (strcmp(buf, "..") == 0) {
    490      if (stat(".", &sb) < 0) {
    491        fail("cannot stat current directory");
    492      }
    493      name = ino2name(sb.st_ino, "..");
    494      len = strlen(name);
    495      cp -= len + 1;
    496      strcpy(cp, name);
    497      cp[len] = '/';
    498      free(name);
    499      xchdir("..");
    500    } else {
    501      cp -= 3;
    502      memcpy(cp, "../", 3);
    503      xchdir(buf);
    504    }
    505  }
    506  strcpy(outpath, cp);
    507 }
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE