home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 19 / AACD19.BIN / AACD / Programming / cvs-1.11 / source / src / filesubr.c next >
Encoding:
C/C++ Source or Header  |  2001-02-03  |  22.6 KB  |  1,013 lines
  1. /* filesubr.c --- subroutines for dealing with files
  2.    Jim Blandy <jimb@cyclic.com>
  3.  
  4.    This file is part of GNU CVS.
  5.  
  6.    GNU CVS is free software; you can redistribute it and/or modify it
  7.    under the terms of the GNU General Public License as published by the
  8.    Free Software Foundation; either version 2, or (at your option) any
  9.    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. /* These functions were moved out of subr.c because they need different
  17.    definitions under operating systems (like, say, Windows NT) with different
  18.    file system semantics.  */
  19.  
  20. #include "cvs.h"
  21.  
  22. static int deep_remove_dir PROTO((const char *path));
  23.  
  24. /*
  25.  * Copies "from" to "to".
  26.  */
  27. void
  28. copy_file (from, to)
  29.     const char *from;
  30.     const char *to;
  31. {
  32.     struct stat sb;
  33.     struct utimbuf t;
  34.     int fdin, fdout;
  35.  
  36.     if (trace)
  37.     (void) fprintf (stderr, "%s-> copy(%s,%s)\n",
  38.             CLIENT_SERVER_STR, from, to);
  39.     if (noexec)
  40.     return;
  41.  
  42.     /* If the file to be copied is a link or a device, then just create
  43.        the new link or device appropriately. */
  44.     if (islink (from))
  45.     {
  46.     char *source = xreadlink (from);
  47.     symlink (source, to);
  48.     free (source);
  49.     return;
  50.     }
  51.  
  52.     if (isdevice (from))
  53.     {
  54. #if defined(HAVE_MKNOD) && defined(HAVE_ST_RDEV)
  55.     if (stat (from, &sb) < 0)
  56.         error (1, errno, "cannot stat %s", from);
  57.     mknod (to, sb.st_mode, sb.st_rdev);
  58. #else
  59.     error (1, 0, "cannot copy device files on this system (%s)", from);
  60. #endif
  61.     }
  62.     else
  63.     {
  64.     /* Not a link or a device... probably a regular file. */
  65.     if ((fdin = open (from, O_RDONLY, 0)) < 0) /* olsen */
  66.         error (1, errno, "cannot open %s for copying", from);
  67.     if (fstat (fdin, &sb) < 0)
  68.         error (1, errno, "cannot fstat %s", from);
  69.     if ((fdout = creat (to, (int) sb.st_mode & 07777)) < 0)
  70.         error (1, errno, "cannot create %s for copying", to);
  71.     if (sb.st_size > 0)
  72.     {
  73.         char buf[BUFSIZ];
  74.         int n;
  75.         
  76.         for (;;) 
  77.         {
  78.         n = read (fdin, buf, sizeof(buf));
  79.         if (n == -1)
  80.         {
  81. #ifdef EINTR
  82.             if (errno == EINTR)
  83.             continue;
  84. #endif
  85.             error (1, errno, "cannot read file %s for copying", from);
  86.         }
  87.         else if (n == 0) 
  88.             break;
  89.         
  90.         if (write(fdout, buf, n) != n) {
  91.             error (1, errno, "cannot write file %s for copying", to);
  92.         }
  93.         }
  94.  
  95. #ifdef HAVE_FSYNC
  96.         if (fsync (fdout)) 
  97.         error (1, errno, "cannot fsync file %s after copying", to);
  98. #endif
  99.     }
  100.  
  101.     if (close (fdin) < 0) 
  102.         error (0, errno, "cannot close %s", from);
  103.     if (close (fdout) < 0)
  104.         error (1, errno, "cannot close %s", to);
  105.     }
  106.  
  107.     /* now, set the times for the copied file to match those of the original */
  108.     memset ((char *) &t, 0, sizeof (t));
  109.     t.actime = sb.st_atime;
  110.     t.modtime = sb.st_mtime;
  111.     (void) utime (to, &t);
  112.  
  113.     #ifdef AMIGA
  114.     (void) chmod (to, sb.st_mode | S_IREAD | S_IWRITE | S_IDELETE);
  115.     #endif /* AMIGA */
  116. }
  117.  
  118. /* FIXME-krp: these functions would benefit from caching the char * &
  119.    stat buf.  */
  120.  
  121. /*
  122.  * Returns non-zero if the argument file is a directory, or is a symbolic
  123.  * link which points to a directory.
  124.  */
  125. int
  126. isdir (file)
  127.     const char *file;
  128. {
  129.     struct stat sb;
  130.  
  131.     if (stat (file, &sb) < 0)
  132.     return (0);
  133.     return (S_ISDIR (sb.st_mode));
  134. }
  135.  
  136. /*
  137.  * Returns non-zero if the argument file is a symbolic link.
  138.  */
  139. int
  140. islink (file)
  141.     const char *file;
  142. {
  143. #ifdef S_ISLNK
  144.     struct stat sb;
  145.  
  146.     if (CVS_LSTAT (file, &sb) < 0)
  147.     return (0);
  148.     return (S_ISLNK (sb.st_mode));
  149. #else
  150.     return (0);
  151. #endif
  152. }
  153.  
  154. /*
  155.  * Returns non-zero if the argument file is a block or
  156.  * character special device.
  157.  */
  158. int
  159. isdevice (file)
  160.     const char *file;
  161. {
  162.     struct stat sb;
  163.  
  164.     if (CVS_LSTAT (file, &sb) < 0)
  165.     return (0);
  166. #ifdef S_ISBLK
  167.     if (S_ISBLK (sb.st_mode))
  168.     return 1;
  169. #endif
  170. #ifdef S_ISCHR
  171.     if (S_ISCHR (sb.st_mode))
  172.     return 1;
  173. #endif
  174.     return 0;
  175. }
  176.  
  177. /*
  178.  * Returns non-zero if the argument file exists.
  179.  */
  180. int
  181. isfile (file)
  182.     const char *file;
  183. {
  184.     return isaccessible(file, F_OK);
  185. }
  186.  
  187. /*
  188.  * Returns non-zero if the argument file is readable.
  189.  */
  190. int
  191. isreadable (file)
  192.     const char *file;
  193. {
  194.     return isaccessible(file, R_OK);
  195. }
  196.  
  197. /*
  198.  * Returns non-zero if the argument file is writable.
  199.  */
  200. int
  201. iswritable (file)
  202.     const char *file;
  203. {
  204.     return isaccessible(file, W_OK);
  205. }
  206.  
  207. /*
  208.  * Returns non-zero if the argument file is accessable according to
  209.  * mode.  If compiled with SETXID_SUPPORT also works if cvs has setxid
  210.  * bits set.
  211.  */
  212. int
  213. isaccessible (file, mode)
  214.     const char *file;
  215.     const int mode;
  216. {
  217. #ifdef SETXID_SUPPORT
  218.     struct stat sb;
  219.     int umask = 0;
  220.     int gmask = 0;
  221.     int omask = 0;
  222.     int uid;
  223.     
  224.     if (stat(file, &sb) == -1)
  225.     return 0;
  226.     if (mode == F_OK)
  227.     return 1;
  228.  
  229.     uid = geteuid();
  230.     if (uid == 0)        /* superuser */
  231.     {
  232.     if (mode & X_OK)
  233.         return sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH);
  234.     else
  235.         return 1;
  236.     }
  237.     
  238.     if (mode & R_OK)
  239.     {
  240.     umask |= S_IRUSR;
  241.     gmask |= S_IRGRP;
  242.     omask |= S_IROTH;
  243.     }
  244.     if (mode & W_OK)
  245.     {
  246.     umask |= S_IWUSR;
  247.     gmask |= S_IWGRP;
  248.     omask |= S_IWOTH;
  249.     }
  250.     if (mode & X_OK)
  251.     {
  252.     umask |= S_IXUSR;
  253.     gmask |= S_IXGRP;
  254.     omask |= S_IXOTH;
  255.     }
  256.  
  257.     if (sb.st_uid == uid)
  258.     return (sb.st_mode & umask) == umask;
  259.     else if (sb.st_gid == getegid())
  260.     return (sb.st_mode & gmask) == gmask;
  261.     else
  262.     return (sb.st_mode & omask) == omask;
  263. #else
  264.     return access(file, mode) == 0;
  265. #endif
  266. }
  267.  
  268. /*
  269.  * Open a file and die if it fails
  270.  */
  271. FILE *
  272. open_file (name, mode)
  273.     const char *name;
  274.     const char *mode;
  275. {
  276.     FILE *fp;
  277.  
  278.     if ((fp = fopen (name, mode)) == NULL)
  279.     error (1, errno, "cannot open %s", name);
  280.     return (fp);
  281. }
  282.  
  283. /*
  284.  * Make a directory and die if it fails
  285.  */
  286. void
  287. make_directory (name)
  288.     const char *name;
  289. {
  290.     struct stat sb;
  291.  
  292.     if (stat (name, &sb) == 0 && (!S_ISDIR (sb.st_mode)))
  293.         error (0, 0, "%s already exists but is not a directory", name);
  294.     if (!noexec && mkdir (name, 0777) < 0)
  295.     error (1, errno, "cannot make directory %s", name);
  296. }
  297.  
  298. /*
  299.  * Make a path to the argument directory, printing a message if something
  300.  * goes wrong.
  301.  */
  302. void
  303. make_directories (name)
  304.     const char *name;
  305. {
  306.     char *cp;
  307.  
  308.     if (noexec)
  309.     return;
  310.  
  311.     if (mkdir (name, 0777) == 0 || errno == EEXIST)
  312.     return;
  313.     if (! existence_error (errno))
  314.     {
  315.     error (0, errno, "cannot make path to %s", name);
  316.     return;
  317.     }
  318.     if ((cp = strrchr (name, '/')) == NULL)
  319.     return;
  320.     *cp = '\0';
  321.     make_directories (name);
  322.     *cp++ = '/';
  323.     if (*cp == '\0')
  324.     return;
  325.     (void) mkdir (name, 0777);
  326. }
  327.  
  328. /* Create directory NAME if it does not already exist; fatal error for
  329.    other errors.  Returns 0 if directory was created; 1 if it already
  330.    existed.  */
  331. int
  332. mkdir_if_needed (name)
  333.     char *name;
  334. {
  335.     if (mkdir (name, 0777) < 0)
  336.     {
  337.     if (!(errno == EEXIST
  338.           || (errno == EACCES && isdir (name))))
  339.         error (1, errno, "cannot make directory %s", name);
  340.     return 1;
  341.     }
  342.     return 0;
  343. }
  344.  
  345. /*
  346.  * Change the mode of a file, either adding write permissions, or removing
  347.  * all write permissions.  Either change honors the current umask setting.
  348.  *
  349.  * Don't do anything if PreservePermissions is set to `yes'.  This may
  350.  * have unexpected consequences for some uses of xchmod.
  351.  */
  352. void
  353. xchmod (fname, writable)
  354.     char *fname;
  355.     int writable;
  356. {
  357.     struct stat sb;
  358.     mode_t mode, oumask;
  359.  
  360.     if (preserve_perms)
  361.     return;
  362.  
  363.     if (stat (fname, &sb) < 0)
  364.     {
  365.     if (!noexec)
  366.         error (0, errno, "cannot stat %s", fname);
  367.     return;
  368.     }
  369.     oumask = umask (0);
  370.     (void) umask (oumask);
  371.     if (writable)
  372.     {
  373.     mode = sb.st_mode | (~oumask
  374.                  & (((sb.st_mode & S_IRUSR) ? S_IWUSR : 0)
  375.                 | ((sb.st_mode & S_IRGRP) ? S_IWGRP : 0)
  376.                 | ((sb.st_mode & S_IROTH) ? S_IWOTH : 0)));
  377.     }
  378.     else
  379.     {
  380.     mode = sb.st_mode & ~(S_IWRITE | S_IWGRP | S_IWOTH) & ~oumask;
  381.     }
  382.  
  383.     if (trace)
  384.     (void) fprintf (stderr, "%s-> chmod(%s,%o)\n",
  385.             CLIENT_SERVER_STR, fname,
  386.             (unsigned int) mode);
  387.     if (noexec)
  388.     return;
  389.  
  390.     if (chmod (fname, mode) < 0)
  391.     error (0, errno, "cannot change mode of file %s", fname);
  392. }
  393.  
  394. /*
  395.  * Rename a file and die if it fails
  396.  */
  397. void
  398. rename_file (from, to)
  399.     const char *from;
  400.     const char *to;
  401. {
  402.     if (trace)
  403.     (void) fprintf (stderr, "%s-> rename(%s,%s)\n",
  404.             CLIENT_SERVER_STR, from, to);
  405.     if (noexec)
  406.     return;
  407.  
  408.     if (rename (from, to) < 0)
  409.     error (1, errno, "cannot rename file %s to %s", from, to);
  410. }
  411.  
  412. /*
  413.  * unlink a file, if possible.
  414.  */
  415. int
  416. unlink_file (f)
  417.     const char *f;
  418. {
  419.     if (trace)
  420.     (void) fprintf (stderr, "%s-> unlink(%s)\n",
  421.             CLIENT_SERVER_STR, f);
  422.     if (noexec)
  423.     return (0);
  424.  
  425.     return (unlink (f));
  426. }
  427.  
  428. /*
  429.  * Unlink a file or dir, if possible.  If it is a directory do a deep
  430.  * removal of all of the files in the directory.  Return -1 on error
  431.  * (in which case errno is set).
  432.  */
  433. #ifndef AMIGA
  434. int
  435. unlink_file_dir (f)
  436.     const char *f;
  437. {
  438.     struct stat sb;
  439.  
  440.     if (trace
  441. #ifdef SERVER_SUPPORT
  442.     /* This is called by the server parent process in contexts where
  443.        it is not OK to send output (e.g. after we sent "ok" to the
  444.        client).  */
  445.     && !server_active
  446. #endif
  447.     )
  448.     (void) fprintf (stderr, "-> unlink_file_dir(%s)\n", f);
  449.  
  450.     if (noexec)
  451.     return (0);
  452.  
  453.     /* For at least some unices, if root tries to unlink() a directory,
  454.        instead of doing something rational like returning EISDIR,
  455.        the system will gleefully go ahead and corrupt the filesystem.
  456.        So we first call stat() to see if it is OK to call unlink().  This
  457.        doesn't quite work--if someone creates a directory between the
  458.        call to stat() and the call to unlink(), we'll still corrupt
  459.        the filesystem.  Where is the Unix Haters Handbook when you need
  460.        it?  */
  461.     if (stat (f, &sb) < 0)
  462.     {
  463.     if (existence_error (errno))
  464.     {
  465.         /* The file or directory doesn't exist anyhow.  */
  466.         return -1;
  467.     }
  468.     }
  469.     else if (S_ISDIR (sb.st_mode))
  470.     return deep_remove_dir (f);
  471.  
  472.     return unlink (f);
  473. }
  474. #endif /* AMIGA */
  475.  
  476. /* Remove a directory and everything it contains.  Returns 0 for
  477.  * success, -1 for failure (in which case errno is set).
  478.  */
  479.  
  480. static int
  481. deep_remove_dir (path)
  482.     const char *path;
  483. {
  484.     DIR          *dirp;
  485.     struct dirent *dp;
  486.  
  487.     if (rmdir (path) != 0)
  488.     {
  489.     if (errno == ENOTEMPTY
  490.         || errno == EEXIST
  491.         /* Ugly workaround for ugly AIX 4.1 (and 3.2) header bug
  492.            (it defines ENOTEMPTY and EEXIST to 17 but actually
  493.            returns 87).  */
  494.         || (ENOTEMPTY == 17 && EEXIST == 17 && errno == 87))
  495.     {
  496.         if ((dirp = opendir (path)) == NULL)
  497.         /* If unable to open the directory return
  498.          * an error
  499.          */
  500.         return -1;
  501.  
  502.         errno = 0;
  503.         while ((dp = readdir (dirp)) != NULL)
  504.         {
  505.         char *buf;
  506.  
  507.         if (strcmp (dp->d_name, ".") == 0 ||
  508.                 strcmp (dp->d_name, "..") == 0)
  509.             continue;
  510.  
  511.         buf = xmalloc (strlen (path) + strlen (dp->d_name) + 5);
  512.         sprintf (buf, "%s/%s", path, dp->d_name);
  513.  
  514.         /* See comment in unlink_file_dir explanation of why we use
  515.            isdir instead of just calling unlink and checking the
  516.            status.  */
  517.         if (isdir(buf)) 
  518.         {
  519.             if (deep_remove_dir(buf))
  520.             {
  521.             closedir(dirp);
  522.             free (buf);
  523.             return -1;
  524.             }
  525.         }
  526.         else
  527.         {
  528.             if (unlink (buf) != 0)
  529.             {
  530.             closedir(dirp);
  531.             free (buf);
  532.             return -1;
  533.             }
  534.         }
  535.         free (buf);
  536.  
  537.         errno = 0;
  538.         }
  539.         if (errno != 0)
  540.         {
  541.         int save_errno = errno;
  542.         closedir (dirp);
  543.         errno = save_errno;
  544.         return -1;
  545.         }
  546.         closedir (dirp);
  547.         return rmdir (path);
  548.     }
  549.     else
  550.         return -1;
  551.     }
  552.  
  553.     /* Was able to remove the directory return 0 */
  554.     return 0;
  555. }
  556.  
  557. /* Read NCHARS bytes from descriptor FD into BUF.
  558.    Return the number of characters successfully read.
  559.    The number returned is always NCHARS unless end-of-file or error.  */
  560. static size_t
  561. block_read (fd, buf, nchars)
  562.     int fd;
  563.     char *buf;
  564.     size_t nchars;
  565. {
  566.     char *bp = buf;
  567.     size_t nread;
  568.  
  569.     do 
  570.     {
  571.     nread = read (fd, bp, nchars);
  572.     if (nread == (size_t)-1)
  573.     {
  574. #ifdef EINTR
  575.         if (errno == EINTR)
  576.         continue;
  577. #endif
  578.         return (size_t)-1;
  579.     }
  580.  
  581.     if (nread == 0)
  582.         break; 
  583.  
  584.     bp += nread;
  585.     nchars -= nread;
  586.     } while (nchars != 0);
  587.  
  588.     return (size_t)(bp - buf); /* olsen */
  589. } 
  590.  
  591.     
  592. /*
  593.  * Compare "file1" to "file2". Return non-zero if they don't compare exactly.
  594.  * If FILE1 and FILE2 are special files, compare their salient characteristics
  595.  * (i.e. major/minor device numbers, links, etc.
  596.  */
  597. int
  598. xcmp (file1, file2)
  599.     const char *file1;
  600.     const char *file2;
  601. {
  602.     char *buf1, *buf2;
  603.     struct stat sb1, sb2;
  604.     int fd1, fd2;
  605.     int ret;
  606.  
  607.     if (CVS_LSTAT (file1, &sb1) < 0)
  608.     error (1, errno, "cannot lstat %s", file1);
  609.     if (CVS_LSTAT (file2, &sb2) < 0)
  610.     error (1, errno, "cannot lstat %s", file2);
  611.  
  612.     /* If FILE1 and FILE2 are not the same file type, they are unequal. */
  613.     if ((sb1.st_mode & S_IFMT) != (sb2.st_mode & S_IFMT))
  614.     return 1;
  615.  
  616.     /* If FILE1 and FILE2 are symlinks, they are equal if they point to
  617.        the same thing. */
  618.     if (S_ISLNK (sb1.st_mode) && S_ISLNK (sb2.st_mode))
  619.     {
  620.     int result;
  621.     buf1 = xreadlink (file1);
  622.     buf2 = xreadlink (file2);
  623.     result = (strcmp (buf1, buf2) == 0);
  624.     free (buf1);
  625.     free (buf2);
  626.     return result;
  627.     }
  628.  
  629. #ifndef AMIGA
  630.     /* If FILE1 and FILE2 are devices, they are equal if their device
  631.        numbers match. */
  632.     if (S_ISBLK (sb1.st_mode) || S_ISCHR (sb1.st_mode))
  633.     {
  634. #ifdef HAVE_ST_RDEV
  635.     if (sb1.st_rdev == sb2.st_rdev)
  636.         return 0;
  637.     else
  638.         return 1;
  639. #else
  640.     error (1, 0, "cannot compare device files on this system (%s and %s)",
  641.            file1, file2);
  642. #endif
  643.     }
  644. #endif /* AMIGA */
  645.  
  646.     if ((fd1 = open (file1, O_RDONLY, 0)) < 0) /* olsen */
  647.     error (1, errno, "cannot open file %s for comparing", file1);
  648.     if ((fd2 = open (file2, O_RDONLY, 0)) < 0) /* olsen */
  649.     error (1, errno, "cannot open file %s for comparing", file2);
  650.  
  651.     /* A generic file compare routine might compare st_dev & st_ino here 
  652.        to see if the two files being compared are actually the same file.
  653.        But that won't happen in CVS, so we won't bother. */
  654.  
  655.     if (sb1.st_size != sb2.st_size)
  656.     ret = 1;
  657.     else if (sb1.st_size == 0)
  658.     ret = 0;
  659.     else
  660.     {
  661.     /* FIXME: compute the optimal buffer size by computing the least
  662.        common multiple of the files st_blocks field */
  663.     size_t buf_size = 8 * 1024;
  664.     size_t read1;
  665.     size_t read2;
  666.  
  667.     buf1 = xmalloc (buf_size);
  668.     buf2 = xmalloc (buf_size);
  669.  
  670.     do 
  671.     {
  672.         read1 = block_read (fd1, buf1, buf_size);
  673.         if (read1 == (size_t)-1)
  674.         error (1, errno, "cannot read file %s for comparing", file1);
  675.  
  676.         read2 = block_read (fd2, buf2, buf_size);
  677.         if (read2 == (size_t)-1)
  678.         error (1, errno, "cannot read file %s for comparing", file2);
  679.  
  680.         /* assert (read1 == read2); */
  681.  
  682.         ret = memcmp(buf1, buf2, read1);
  683.     } while (ret == 0 && read1 == buf_size);
  684.  
  685.     free (buf1);
  686.     free (buf2);
  687.     }
  688.     
  689.     (void) close (fd1);
  690.     (void) close (fd2);
  691.     return (ret);
  692. }
  693.  
  694. #ifndef AMIGA
  695. /* Generate a unique temporary filename.  Returns a pointer to a newly
  696.    malloc'd string containing the name.  Returns successfully or not at
  697.    all.  */
  698. /* There are at least three functions for generating temporary
  699.    filenames.  We use tempnam (SVID 3) if possible, else mktemp (BSD
  700.    4.3), and as last resort tmpnam (POSIX). Reason is that tempnam and
  701.    mktemp both allow to specify the directory in which the temporary
  702.    file will be created.  */
  703. #ifdef HAVE_TEMPNAM
  704. char *
  705. cvs_temp_name ()
  706. {
  707.     char *retval;
  708.  
  709.     retval = tempnam (Tmpdir, "cvs");
  710.     if (retval == NULL)
  711.     error (1, errno, "cannot generate temporary filename");
  712.     /* tempnam returns a pointer to a newly malloc'd string, so there's
  713.        no need for a xstrdup  */
  714.     return retval;
  715. }
  716. #else
  717. char *
  718. cvs_temp_name ()
  719. {
  720. #  ifdef HAVE_MKTEMP
  721.     char *value;
  722.     char *retval;
  723.     char *fmt; /* olsen */
  724.  
  725.     value = xmalloc (strlen (Tmpdir) + 40);
  726.     fmt = "%s/%s"; /* olsen */
  727.  
  728.     #ifdef AMIGA
  729.     {
  730.         int len;
  731.  
  732.         len = strlen(Tmpdir);
  733.         if(len > 0 && (Tmpdir[len-1] != ':' && Tmpdir[len-1] != '/'))
  734.             fmt = "%s/%s";
  735.         else
  736.             fmt = "%s%s";
  737.     }
  738.     #endif /* AMIGA */
  739.  
  740.     sprintf (value, fmt, Tmpdir, "cvsXXXXXX" ); /* olsen */
  741.     retval = mktemp (value);
  742.  
  743.     if (retval == NULL)
  744.     error (1, errno, "cannot generate temporary filename");
  745.     return value;
  746. #  else
  747.     char value[L_tmpnam + 1];
  748.     char *retval;
  749.  
  750.     retval = tmpnam (value);
  751.     if (retval == NULL)
  752.     error (1, errno, "cannot generate temporary filename");
  753.     return xstrdup (value);
  754. #  endif
  755. }
  756. #endif
  757. #endif /* AMIGA */
  758.  
  759. #ifndef AMIGA
  760. /* Return non-zero iff FILENAME is absolute.
  761.    Trivial under Unix, but more complicated under other systems.  */
  762. int
  763. isabsolute (filename)
  764.     const char *filename;
  765. {
  766.     return filename[0] == '/';
  767. }
  768. #endif /* AMIGA */
  769.  
  770. /*
  771.  * Return a string (dynamically allocated) with the name of the file to which
  772.  * LINK is symlinked.
  773.  */
  774. char *
  775. xreadlink (link)
  776.     const char *link;
  777. {
  778.     char *file = NULL;
  779.     char *tfile;
  780.     int buflen = 128;
  781.     int link_name_len;
  782.  
  783.     if (!islink (link))
  784.     return NULL;
  785.  
  786.     /* Get the name of the file to which `from' is linked.
  787.        FIXME: what portability issues arise here?  Are readlink &
  788.        ENAMETOOLONG defined on all systems? -twp */
  789.     do
  790.     {
  791.     file = xrealloc (file, buflen);
  792.     link_name_len = readlink (link, file, buflen - 1);
  793.     buflen *= 2;
  794.     }
  795.     while (link_name_len < 0 && errno == ENAMETOOLONG);
  796.  
  797.     if (link_name_len < 0)
  798.     error (1, errno, "cannot readlink %s", link);
  799.  
  800.     file[link_name_len] = '\0';
  801.  
  802.     tfile = xstrdup (file);
  803.     free (file);
  804.  
  805.     return tfile;
  806. }
  807.  
  808. #ifndef AMIGA
  809. /* Return a pointer into PATH's last component.  */
  810. char *
  811. last_component (path)
  812.     char *path;
  813. {
  814.     char *last = strrchr (path, '/');
  815.     
  816.     if (last && (last != path))
  817.         return last + 1;
  818.     else
  819.         return path;
  820. }
  821. #endif /* AMIGA */
  822.  
  823. /* Return the home directory.  Returns a pointer to storage
  824.    managed by this function or its callees (currently getenv).
  825.    This function will return the same thing every time it is
  826.    called.  Returns NULL if there is no home directory.
  827.  
  828.    Note that for a pserver server, this may return root's home
  829.    directory.  What typically happens is that upon being started from
  830.    inetd, before switching users, the code in cvsrc.c calls
  831.    get_homedir which remembers root's home directory in the static
  832.    variable.  Then the switch happens and get_homedir might return a
  833.    directory that we don't even have read or execute permissions for
  834.    (which is bad, when various parts of CVS try to read there).  One
  835.    fix would be to make the value returned by get_homedir only good
  836.    until the next call (which would free the old value).  Another fix
  837.    would be to just always malloc our answer, and let the caller free
  838.    it (that is best, because some day we may need to be reentrant).
  839.  
  840.    The workaround is to put -f in inetd.conf which means that
  841.    get_homedir won't get called until after the switch in user ID.
  842.  
  843.    The whole concept of a "home directory" on the server is pretty
  844.    iffy, although I suppose some people probably are relying on it for
  845.    .cvsrc and such, in the cases where it works.  */
  846. char *
  847. get_homedir ()
  848. {
  849.     static char *home = NULL;
  850.     char *env = getenv ("HOME");
  851.     struct passwd *pw;
  852.  
  853.     if (home != NULL)
  854.     return home;
  855.  
  856.     if (env)
  857.     home = env;
  858.     else if ((pw = (struct passwd *) getpwuid (getuid ()))
  859.          && pw->pw_dir)
  860.     home = xstrdup (pw->pw_dir);
  861.     else
  862.     return 0;
  863.  
  864.     return home;
  865. }
  866.  
  867. #ifndef AMIGA
  868. /* See cvs.h for description.  On unix this does nothing, because the
  869.    shell expands the wildcards.  */
  870. void
  871. expand_wild (argc, argv, pargc, pargv)
  872.     int argc;
  873.     char **argv;
  874.     int *pargc;
  875.     char ***pargv;
  876. {
  877.     int i;
  878.     *pargc = argc;
  879.     *pargv = (char **) xmalloc (argc * sizeof (char *));
  880.     for (i = 0; i < argc; ++i)
  881.     (*pargv)[i] = xstrdup (argv[i]);
  882. }
  883. #endif /* AMIGA */
  884.  
  885. #ifdef SERVER_SUPPORT
  886. /* Case-insensitive string compare.  I know that some systems
  887.    have such a routine, but I'm not sure I see any reasons for
  888.    dealing with the hair of figuring out whether they do (I haven't
  889.    looked into whether this is a performance bottleneck; I would guess
  890.    not).  */
  891. int
  892. cvs_casecmp (str1, str2)
  893.     char *str1;
  894.     char *str2;
  895. {
  896.     char *p;
  897.     char *q;
  898.     int pqdiff;
  899.  
  900.     p = str1;
  901.     q = str2;
  902.     while ((pqdiff = tolower (*p) - tolower (*q)) == 0)
  903.     {
  904.     if (*p == '\0')
  905.         return 0;
  906.     ++p;
  907.     ++q;
  908.     }
  909.     return pqdiff;
  910. }
  911.  
  912. /* Case-insensitive file open.  As you can see, this is an expensive
  913.    call.  We don't regard it as our main strategy for dealing with
  914.    case-insensitivity.  Returns errno code or 0 for success.  Puts the
  915.    new file in *FP.  NAME and MODE are as for fopen.  If PATHP is not
  916.    NULL, then put a malloc'd string containing the pathname as found
  917.    into *PATHP.  *PATHP is only set if the return value is 0.
  918.  
  919.    Might be cleaner to separate the file finding (which just gives
  920.    *PATHP) from the file opening (which the caller can do).  For one
  921.    thing, might make it easier to know whether to put NAME or *PATHP
  922.    into error messages.  */
  923. int
  924. fopen_case (name, mode, fp, pathp)
  925.     char *name;
  926.     char *mode;
  927.     FILE **fp;
  928.     char **pathp;
  929. {
  930.     struct dirent *dp;
  931.     DIR *dirp;
  932.     char *dir;
  933.     char *fname;
  934.     char *found_name;
  935.     int retval;
  936.  
  937.     /* Separate NAME into directory DIR and filename within the directory
  938.        FNAME.  */
  939.     dir = xstrdup (name);
  940.     fname = strrchr (dir, '/');
  941.     if (fname == NULL)
  942.     error (1, 0, "internal error: relative pathname in fopen_case");
  943.     *fname++ = '\0';
  944.  
  945.     found_name = NULL;
  946.     dirp = CVS_OPENDIR (dir);
  947.     if (dirp == NULL)
  948.     {
  949.     if (existence_error (errno))
  950.     {
  951.         /* This can happen if we are looking in the Attic and the Attic
  952.            directory does not exist.  Return the error to the caller;
  953.            they know what to do with it.  */
  954.         retval = errno;
  955.         goto out;
  956.     }
  957.     else
  958.     {
  959.         /* Give a fatal error; that way the error message can be
  960.            more specific than if we returned the error to the caller.  */
  961.         error (1, errno, "cannot read directory %s", dir);
  962.     }
  963.     }
  964.     errno = 0;
  965.     while ((dp = readdir (dirp)) != NULL)
  966.     {
  967.     if (cvs_casecmp (dp->d_name, fname) == 0)
  968.     {
  969.         if (found_name != NULL)
  970.         error (1, 0, "%s is ambiguous; could mean %s or %s",
  971.                fname, dp->d_name, found_name);
  972.         found_name = xstrdup (dp->d_name);
  973.     }
  974.     }
  975.     if (errno != 0)
  976.     error (1, errno, "cannot read directory %s", dir);
  977.     closedir (dirp);
  978.  
  979.     if (found_name == NULL)
  980.     {
  981.     *fp = NULL;
  982.     retval = ENOENT;
  983.     }
  984.     else
  985.     {
  986.     char *p;
  987.  
  988.     /* Copy the found name back into DIR.  We are assuming that
  989.        found_name is the same length as fname, which is true as
  990.        long as the above code is just ignoring case and not other
  991.        aspects of filename syntax.  */
  992.     p = dir + strlen (dir);
  993.     *p++ = '/';
  994.     strcpy (p, found_name);
  995.     *fp = fopen (dir, mode);
  996.     if (*fp == NULL)
  997.         retval = errno;
  998.     else
  999.         retval = 0;
  1000.     }
  1001.  
  1002.     if (pathp == NULL)
  1003.     free (dir);
  1004.     else if (retval != 0)
  1005.     free (dir);
  1006.     else
  1007.     *pathp = dir;
  1008.     free (found_name);
  1009.  out:
  1010.     return retval;
  1011. }
  1012. #endif /* SERVER_SUPPORT */
  1013.