home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / cvs-1.8.7-src.tgz / tar.out / fsf / cvs / windows-NT / filesubr.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  23KB  |  983 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.    You should have received a copy of the GNU General Public License
  17.    along with this program; if not, write to the Free Software
  18.    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /* These functions were moved out of subr.c because they need different
  21.    definitions under operating systems (like, say, Windows NT) with different
  22.    file system semantics.  */
  23.  
  24. #include <io.h>
  25. #include <windows.h>
  26.  
  27. #include "cvs.h"
  28.  
  29. static int deep_remove_dir PROTO((const char *path));
  30.  
  31. /*
  32.  * Copies "from" to "to".
  33.  */
  34. void
  35. copy_file (from, to)
  36.     const char *from;
  37.     const char *to;
  38. {
  39.     struct stat sb;
  40.     struct utimbuf t;
  41.     int fdin, fdout;
  42.  
  43.     if (trace)
  44. #ifdef SERVER_SUPPORT
  45.     (void) fprintf (stderr, "%c-> copy(%s,%s)\n",
  46.             (server_active) ? 'S' : ' ', from, to);
  47. #else
  48.     (void) fprintf (stderr, "-> copy(%s,%s)\n", from, to);
  49. #endif
  50.     if (noexec)
  51.     return;
  52.  
  53.     if ((fdin = open (from, O_RDONLY | O_BINARY)) < 0)
  54.     error (1, errno, "cannot open %s for copying", from);
  55.     if (fstat (fdin, &sb) < 0)
  56.     error (1, errno, "cannot fstat %s", from);
  57.     if ((fdout = open (to, O_CREAT | O_TRUNC | O_RDWR | O_BINARY,
  58.                (int) sb.st_mode & 07777)) < 0)
  59.     error (1, errno, "cannot create %s for copying", to);
  60.     if (sb.st_size > 0)
  61.     {
  62.     char buf[BUFSIZ];
  63.     int n;
  64.  
  65.     for (;;) 
  66.     {
  67.         n = read (fdin, buf, sizeof(buf));
  68.         if (n == -1)
  69.         {
  70. #ifdef EINTR
  71.         if (errno == EINTR)
  72.             continue;
  73. #endif
  74.         error (1, errno, "cannot read file %s for copying", from);
  75.         }
  76.             else if (n == 0) 
  77.         break;
  78.   
  79.         if (write(fdout, buf, n) != n) {
  80.         error (1, errno, "cannot write file %s for copying", to);
  81.         }
  82.     }
  83.  
  84. #ifdef HAVE_FSYNC
  85.     if (fsync (fdout)) 
  86.         error (1, errno, "cannot fsync file %s after copying", to);
  87. #endif
  88.     }
  89.  
  90.     if (close (fdin) < 0) 
  91.     error (0, errno, "cannot close %s", from);
  92.     if (close (fdout) < 0)
  93.     error (1, errno, "cannot close %s", to);
  94.  
  95.     /* now, set the times for the copied file to match those of the original */
  96.     memset ((char *) &t, 0, sizeof (t));
  97.     t.actime = sb.st_atime;
  98.     t.modtime = sb.st_mtime;
  99.     (void) utime (to, &t);
  100. }
  101.  
  102. /*
  103.  * link a file, if possible.  Warning: the Windows NT version of this
  104.  * function just copies the file, so only use this function in ways
  105.  * that can deal with either a link or a copy.
  106.  */
  107. int
  108. link_file (from, to)
  109.     const char *from;
  110.     const char *to;
  111. {
  112.     copy_file (from, to);
  113.     return 0;
  114. }
  115.  
  116. /* FIXME-krp: these functions would benefit from caching the char * &
  117.    stat buf.  */
  118.  
  119. /*
  120.  * Returns non-zero if the argument file is a directory, or is a symbolic
  121.  * link which points to a directory.
  122.  */
  123. int
  124. isdir (file)
  125.     const char *file;
  126. {
  127.     struct stat sb;
  128.  
  129.     if (stat (file, &sb) < 0)
  130.     return (0);
  131.     return (S_ISDIR (sb.st_mode));
  132. }
  133.  
  134. /*
  135.  * Returns non-zero if the argument file is a symbolic link.
  136.  */
  137. int
  138. islink (file)
  139.     const char *file;
  140. {
  141. #ifdef S_ISLNK
  142.     struct stat sb;
  143.  
  144.     if (lstat (file, &sb) < 0)
  145.     return (0);
  146.     return (S_ISLNK (sb.st_mode));
  147. #else
  148.     return (0);
  149. #endif
  150. }
  151.  
  152. /*
  153.  * Returns non-zero if the argument file exists.
  154.  */
  155. int
  156. isfile (file)
  157.     const char *file;
  158. {
  159.     return isaccessible(file, F_OK);
  160. }
  161.  
  162. /*
  163.  * Returns non-zero if the argument file is readable.
  164.  */
  165. int
  166. isreadable (file)
  167.     const char *file;
  168. {
  169.     return isaccessible(file, R_OK);
  170. }
  171.  
  172. /*
  173.  * Returns non-zero if the argument file is writable.
  174.  */
  175. int
  176. iswritable (file)
  177.     const char *file;
  178. {
  179.     return isaccessible(file, W_OK);
  180. }
  181.  
  182. /*
  183.  * Returns non-zero if the argument file is accessable according to
  184.  * mode.  If compiled with SETXID_SUPPORT also works if cvs has setxid
  185.  * bits set.
  186.  */
  187. int
  188. isaccessible (file, mode)
  189.     const char *file;
  190.     const int mode;
  191. {
  192. #ifdef SETXID_SUPPORT
  193.     struct stat sb;
  194.     int umask = 0;
  195.     int gmask = 0;
  196.     int omask = 0;
  197.     int uid;
  198.     
  199.     if (stat(file, &sb) == -1)
  200.     return 0;
  201.     if (mode == F_OK)
  202.     return 1;
  203.  
  204.     uid = geteuid();
  205.     if (uid == 0)        /* superuser */
  206.     {
  207.     if (mode & X_OK)
  208.         return sb.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH);
  209.     else
  210.         return 1;
  211.     }
  212.     
  213.     if (mode & R_OK)
  214.     {
  215.     umask |= S_IRUSR;
  216.     gmask |= S_IRGRP;
  217.     omask |= S_IROTH;
  218.     }
  219.     if (mode & W_OK)
  220.     {
  221.     umask |= S_IWUSR;
  222.     gmask |= S_IWGRP;
  223.     omask |= S_IWOTH;
  224.     }
  225.     if (mode & X_OK)
  226.     {
  227.     umask |= S_IXUSR;
  228.     gmask |= S_IXGRP;
  229.     omask |= S_IXOTH;
  230.     }
  231.  
  232.     if (sb.st_uid == uid)
  233.     return (sb.st_mode & umask) == umask;
  234.     else if (sb.st_gid == getegid())
  235.     return (sb.st_mode & gmask) == gmask;
  236.     else
  237.     return (sb.st_mode & omask) == omask;
  238. #else
  239.     return access(file, mode) == 0;
  240. #endif
  241. }
  242.  
  243. /*
  244.  * Open a file and die if it fails
  245.  */
  246. FILE *
  247. open_file (name, mode)
  248.     const char *name;
  249.     const char *mode;
  250. {
  251.     FILE *fp;
  252.  
  253.     if ((fp = fopen (name, mode)) == NULL)
  254.     error (1, errno, "cannot open %s", name);
  255.     return (fp);
  256. }
  257.  
  258. /*
  259.  * Make a directory and die if it fails
  260.  */
  261. void
  262. make_directory (name)
  263.     const char *name;
  264. {
  265.     struct stat sb;
  266.  
  267.     if (stat (name, &sb) == 0 && (!S_ISDIR (sb.st_mode)))
  268.         error (0, 0, "%s already exists but is not a directory", name);
  269.     if (!noexec && mkdir (name) < 0)
  270.     error (1, errno, "cannot make directory %s", name);
  271. }
  272.  
  273. /*
  274.  * Make a path to the argument directory, printing a message if something
  275.  * goes wrong.
  276.  */
  277. void
  278. make_directories (name)
  279.     const char *name;
  280. {
  281.     char *cp;
  282.  
  283.     if (noexec)
  284.     return;
  285.  
  286.     if (mkdir (name) == 0 || errno == EEXIST)
  287.     return;
  288.     if (errno != ENOENT)
  289.     {
  290.     error (0, errno, "cannot make path to %s", name);
  291.     return;
  292.     }
  293.     if ((cp = strrchr (name, '/')) == NULL)
  294.     return;
  295.     *cp = '\0';
  296.     make_directories (name);
  297.     *cp++ = '/';
  298.     if (*cp == '\0')
  299.     return;
  300.     (void) mkdir (name);
  301. }
  302.  
  303. /* Create directory NAME if it does not already exist; fatal error for
  304.    other errors.  Returns 0 if directory was created; 1 if it already
  305.    existed.  */
  306. int
  307. mkdir_if_needed (name)
  308.     char *name;
  309. {
  310.     if (mkdir (name) < 0)
  311.     {
  312.     if (errno != EEXIST
  313. #ifdef EACCESS
  314.         /* This was copied over from the OS/2 code; I would guess it
  315.            isn't needed here but that has not been verified.  */
  316.         && errno != EACCESS
  317. #endif
  318. #ifdef EACCES
  319.         /* This is said to be needed by NT on Alpha or PowerPC
  320.            (not sure what version) --August, 1996.  */
  321.         && errno != EACCES
  322. #endif
  323.         )
  324.         error (1, errno, "cannot make directory %s", name);
  325.     return 1;
  326.     }
  327.     return 0;
  328. }
  329.  
  330. /*
  331.  * Change the mode of a file, either adding write permissions, or removing
  332.  * all write permissions.  Adding write permissions honors the current umask
  333.  * setting.
  334.  */
  335. void
  336. xchmod (fname, writable)
  337.     char *fname;
  338.     int writable;
  339. {
  340.     struct stat sb;
  341.     mode_t mode, oumask;
  342.  
  343.     if (stat (fname, &sb) < 0)
  344.     {
  345.     if (!noexec)
  346.         error (0, errno, "cannot stat %s", fname);
  347.     return;
  348.     }
  349.     if (writable)
  350.     {
  351.     oumask = umask (0);
  352.     (void) umask (oumask);
  353.     mode = sb.st_mode | ~oumask & (((sb.st_mode & S_IRUSR) ? S_IWUSR : 0) |
  354.                        ((sb.st_mode & S_IRGRP) ? S_IWGRP : 0) |
  355.                        ((sb.st_mode & S_IROTH) ? S_IWOTH : 0));
  356.     }
  357.     else
  358.     {
  359.     mode = sb.st_mode & ~(S_IWRITE | S_IWGRP | S_IWOTH);
  360.     }
  361.  
  362.     if (trace)
  363. #ifdef SERVER_SUPPORT
  364.     (void) fprintf (stderr, "%c-> chmod(%s,%o)\n",
  365.             (server_active) ? 'S' : ' ', fname, mode);
  366. #else
  367.     (void) fprintf (stderr, "-> chmod(%s,%o)\n", fname, mode);
  368. #endif
  369.     if (noexec)
  370.     return;
  371.  
  372.     if (chmod (fname, mode) < 0)
  373.     error (0, errno, "cannot change mode of file %s", fname);
  374. }
  375.  
  376.  
  377. /* Read the value of a symbolic link.
  378.    Under Windows NT, this function always returns EINVAL.  */
  379. int
  380. readlink (char *path, char *buf, int buf_size)
  381. {
  382.     errno = EINVAL;
  383.     return -1;
  384. }
  385.  
  386. /*
  387.  * Rename a file and die if it fails
  388.  */
  389. void
  390. rename_file (from, to)
  391.     const char *from;
  392.     const char *to;
  393. {
  394.     if (trace)
  395. #ifdef SERVER_SUPPORT
  396.     (void) fprintf (stderr, "%c-> rename(%s,%s)\n",
  397.             (server_active) ? 'S' : ' ', from, to);
  398. #else
  399.     (void) fprintf (stderr, "-> rename(%s,%s)\n", from, to);
  400. #endif
  401.     if (noexec)
  402.     return;
  403.  
  404.     /* Win32 unlink is stupid --- it fails if the file is read-only  */
  405.     chmod(to, S_IWRITE);
  406.     unlink(to);
  407.     if (rename (from, to) < 0)
  408.     error (1, errno, "cannot rename file %s to %s", from, to);
  409. }
  410.  
  411. /* Windows NT doesn't have hard links or symbolic links.
  412.    There was only one place in CVS which used this function,
  413.    so I rewrote it to work another way, so this function isn't
  414.    used any more.  */
  415. #if 0
  416. /*
  417.  * link a file, if possible.
  418.  */
  419. int
  420. link_file (from, to)
  421.     const char *from;
  422.     const char *to;
  423. {
  424.     if (trace)
  425. #ifdef SERVER_SUPPORT
  426.     (void) fprintf (stderr, "%c-> link(%s,%s)\n",
  427.             (server_active) ? 'S' : ' ', from, to);
  428. #else
  429.     (void) fprintf (stderr, "-> link(%s,%s)\n", from, to);
  430. #endif
  431.     if (noexec)
  432.     return (0);
  433.  
  434.     return (link (from, to));
  435. }
  436. #endif
  437.  
  438. /*
  439.  * unlink a file, if possible.
  440.  */
  441. int
  442. unlink_file (f)
  443.     const char *f;
  444. {
  445.     if (trace)
  446. #ifdef SERVER_SUPPORT
  447.     (void) fprintf (stderr, "%c-> unlink(%s)\n",
  448.             (server_active) ? 'S' : ' ', f);
  449. #else
  450.     (void) fprintf (stderr, "-> unlink(%s)\n", f);
  451. #endif
  452.     if (noexec)
  453.     return (0);
  454.  
  455.     /* Win32 unlink is stupid - it fails if the file is read-only */
  456.     chmod (f, _S_IWRITE);
  457.     return (unlink (f));
  458. }
  459.  
  460. /*
  461.  * Unlink a file or dir, if possible.  If it is a directory do a deep
  462.  * removal of all of the files in the directory.  Return -1 on error
  463.  * (in which case errno is set).
  464.  */
  465. int
  466. unlink_file_dir (f)
  467.     const char *f;
  468. {
  469.     if (trace)
  470. #ifdef SERVER_SUPPORT
  471.     (void) fprintf (stderr, "%c-> unlink_file_dir(%s)\n",
  472.             (server_active) ? 'S' : ' ', f);
  473. #else
  474.     (void) fprintf (stderr, "-> unlink_file_dir(%s)\n", f);
  475. #endif
  476.     if (noexec)
  477.     return (0);
  478.  
  479.     /* Win32 unlink is stupid - it fails if the file is read-only */
  480.     chmod (f, _S_IWRITE);
  481.     if (unlink (f) != 0)
  482.     {
  483.     /* under Windows NT, unlink returns EACCES if the path
  484.        is a directory.  Under Windows 95, ENOENT.  */
  485.         if (errno == EISDIR || errno == EACCES || errno == ENOENT)
  486.                 return deep_remove_dir (f);
  487.         else
  488.         /* The file wasn't a directory and some other
  489.          * error occured
  490.          */
  491.                 return -1;
  492.     }
  493.     /* We were able to remove the file from the disk */
  494.     return 0;
  495. }
  496.  
  497. /* Remove a directory and everything it contains.  Returns 0 for
  498.  * success, -1 for failure (in which case errno is set).
  499.  */
  500.  
  501. static int
  502. deep_remove_dir (path)
  503.     const char *path;
  504. {
  505.     DIR          *dirp;
  506.     struct dirent *dp;
  507.     char       buf[PATH_MAX];
  508.  
  509.     /* ENOTEMPTY for NT (obvious) but EACCES for Win95 (not obvious) */
  510.     if (rmdir (path) != 0
  511.     && (errno == ENOTEMPTY || errno == EACCES))
  512.     {
  513.     if ((dirp = opendir (path)) == NULL)
  514.         /* If unable to open the directory return
  515.          * an error
  516.          */
  517.         return -1;
  518.  
  519.     while ((dp = readdir (dirp)) != NULL)
  520.     {
  521.         if (strcmp (dp->d_name, ".") == 0 ||
  522.             strcmp (dp->d_name, "..") == 0)
  523.         continue;
  524.  
  525.         sprintf (buf, "%s/%s", path, dp->d_name);
  526.  
  527.         /* Win32 unlink is stupid - it fails if the file is read-only */
  528.         chmod (buf, _S_IWRITE);
  529.         if (unlink (buf) != 0 )
  530.         {
  531.         /* Under Windows NT, unlink returns EACCES if the path
  532.            is a directory.  Under Windows 95, ENOENT.  It
  533.            isn't really clear to me whether checking errno is
  534.            better or worse than using _stat to check for a directory.
  535.            We aren't really trying to prevent race conditions here
  536.            (e.g. what if something changes between readdir and
  537.            unlink?)  */
  538.         if (errno == EISDIR || errno == EACCES || errno == ENOENT)
  539.         {
  540.             if (deep_remove_dir (buf))
  541.             {
  542.             closedir (dirp);
  543.             return -1;
  544.             }
  545.         }
  546.         else
  547.         {
  548.             /* buf isn't a directory, or there are
  549.              * some sort of permision problems
  550.              */
  551.             closedir (dirp);
  552.             return -1;
  553.         }
  554.         }
  555.     }
  556.     closedir (dirp);
  557.     return rmdir (path);
  558.     }
  559.     /* Was able to remove the directory return 0 */
  560.     return 0;
  561. }
  562.  
  563. /* Read NCHARS bytes from descriptor FD into BUF.
  564.    Return the number of characters successfully read.
  565.    The number returned is always NCHARS unless end-of-file or error.  */
  566. static size_t
  567. block_read (fd, buf, nchars)
  568.     int fd;
  569.     char *buf;
  570.     size_t nchars;
  571. {
  572.     char *bp = buf;
  573.     size_t nread;
  574.  
  575.     do 
  576.     {
  577.     nread = read (fd, bp, nchars);
  578.     if (nread == (size_t)-1)
  579.     {
  580. #ifdef EINTR
  581.         if (errno == EINTR)
  582.         continue;
  583. #endif
  584.         return (size_t)-1;
  585.     }
  586.  
  587.     if (nread == 0)
  588.         break; 
  589.  
  590.     bp += nread;
  591.     nchars -= nread;
  592.     } while (nchars != 0);
  593.  
  594.     return bp - buf;
  595. } 
  596.  
  597.     
  598. /*
  599.  * Compare "file1" to "file2". Return non-zero if they don't compare exactly.
  600.  */
  601. int
  602. xcmp (file1, file2)
  603.     const char *file1;
  604.     const char *file2;
  605. {
  606.     char *buf1, *buf2;
  607.     struct stat sb1, sb2;
  608.     int fd1, fd2;
  609.     int ret;
  610.  
  611.     if ((fd1 = open (file1, O_RDONLY | O_BINARY)) < 0)
  612.     error (1, errno, "cannot open file %s for comparing", file1);
  613.     if ((fd2 = open (file2, O_RDONLY | O_BINARY)) < 0)
  614.     error (1, errno, "cannot open file %s for comparing", file2);
  615.     if (fstat (fd1, &sb1) < 0)
  616.     error (1, errno, "cannot fstat %s", file1);
  617.     if (fstat (fd2, &sb2) < 0)
  618.     error (1, errno, "cannot fstat %s", file2);
  619.  
  620.     /* A generic file compare routine might compare st_dev & st_ino here 
  621.        to see if the two files being compared are actually the same file.
  622.        But that won't happen in CVS, so we won't bother. */
  623.  
  624.     if (sb1.st_size != sb2.st_size)
  625.     ret = 1;
  626.     else if (sb1.st_size == 0)
  627.     ret = 0;
  628.     else
  629.     {
  630.     /* FIXME: compute the optimal buffer size by computing the least
  631.        common multiple of the files st_blocks field */
  632.     size_t buf_size = 8 * 1024;
  633.     size_t read1;
  634.     size_t read2;
  635.  
  636.     buf1 = xmalloc (buf_size);
  637.     buf2 = xmalloc (buf_size);
  638.  
  639.     do 
  640.     {
  641.         read1 = block_read (fd1, buf1, buf_size);
  642.         if (read1 == (size_t)-1)
  643.         error (1, errno, "cannot read file %s for comparing", file1);
  644.  
  645.         read2 = block_read (fd2, buf2, buf_size);
  646.         if (read2 == (size_t)-1)
  647.         error (1, errno, "cannot read file %s for comparing", file2);
  648.  
  649.         /* assert (read1 == read2); */
  650.  
  651.         ret = memcmp(buf1, buf2, read1);
  652.     } while (ret == 0 && read1 == buf_size);
  653.  
  654.     free (buf1);
  655.     free (buf2);
  656.     }
  657.     
  658.     (void) close (fd1);
  659.     (void) close (fd2);
  660.     return (ret);
  661. }
  662.  
  663.  
  664. /* The equivalence class mapping for filenames.
  665.    Windows NT filenames are case-insensitive, but case-preserving.
  666.    Both / and \ are path element separators.
  667.    Thus, this table maps both upper and lower case to lower case, and
  668.    both / and \ to /.  */
  669.  
  670. #if 0
  671. main ()
  672. {
  673.   int c;
  674.  
  675.   for (c = 0; c < 256; c++)
  676.     {
  677.       int t;
  678.  
  679.       if (c == '\\')
  680.         t = '/';
  681.       else
  682.         t = tolower (c);
  683.       
  684.       if ((c & 0x7) == 0x0)
  685.          printf ("    ");
  686.       printf ("0x%02x,", t);
  687.       if ((c & 0x7) == 0x7)
  688.          putchar ('\n');
  689.       else if ((c & 0x7) == 0x3)
  690.          putchar (' ');
  691.     }
  692. }
  693. #endif
  694.  
  695.  
  696. unsigned char
  697. WNT_filename_classes[] =
  698. {
  699.     0x00,0x01,0x02,0x03, 0x04,0x05,0x06,0x07,
  700.     0x08,0x09,0x0a,0x0b, 0x0c,0x0d,0x0e,0x0f,
  701.     0x10,0x11,0x12,0x13, 0x14,0x15,0x16,0x17,
  702.     0x18,0x19,0x1a,0x1b, 0x1c,0x1d,0x1e,0x1f,
  703.     0x20,0x21,0x22,0x23, 0x24,0x25,0x26,0x27,
  704.     0x28,0x29,0x2a,0x2b, 0x2c,0x2d,0x2e,0x2f,
  705.     0x30,0x31,0x32,0x33, 0x34,0x35,0x36,0x37,
  706.     0x38,0x39,0x3a,0x3b, 0x3c,0x3d,0x3e,0x3f,
  707.     0x40,0x61,0x62,0x63, 0x64,0x65,0x66,0x67,
  708.     0x68,0x69,0x6a,0x6b, 0x6c,0x6d,0x6e,0x6f,
  709.     0x70,0x71,0x72,0x73, 0x74,0x75,0x76,0x77,
  710.     0x78,0x79,0x7a,0x5b, 0x2f,0x5d,0x5e,0x5f,
  711.     0x60,0x61,0x62,0x63, 0x64,0x65,0x66,0x67,
  712.     0x68,0x69,0x6a,0x6b, 0x6c,0x6d,0x6e,0x6f,
  713.     0x70,0x71,0x72,0x73, 0x74,0x75,0x76,0x77,
  714.     0x78,0x79,0x7a,0x7b, 0x7c,0x7d,0x7e,0x7f,
  715.     0x80,0x81,0x82,0x83, 0x84,0x85,0x86,0x87,
  716.     0x88,0x89,0x8a,0x8b, 0x8c,0x8d,0x8e,0x8f,
  717.     0x90,0x91,0x92,0x93, 0x94,0x95,0x96,0x97,
  718.     0x98,0x99,0x9a,0x9b, 0x9c,0x9d,0x9e,0x9f,
  719.     0xa0,0xa1,0xa2,0xa3, 0xa4,0xa5,0xa6,0xa7,
  720.     0xa8,0xa9,0xaa,0xab, 0xac,0xad,0xae,0xaf,
  721.     0xb0,0xb1,0xb2,0xb3, 0xb4,0xb5,0xb6,0xb7,
  722.     0xb8,0xb9,0xba,0xbb, 0xbc,0xbd,0xbe,0xbf,
  723.     0xc0,0xc1,0xc2,0xc3, 0xc4,0xc5,0xc6,0xc7,
  724.     0xc8,0xc9,0xca,0xcb, 0xcc,0xcd,0xce,0xcf,
  725.     0xd0,0xd1,0xd2,0xd3, 0xd4,0xd5,0xd6,0xd7,
  726.     0xd8,0xd9,0xda,0xdb, 0xdc,0xdd,0xde,0xdf,
  727.     0xe0,0xe1,0xe2,0xe3, 0xe4,0xe5,0xe6,0xe7,
  728.     0xe8,0xe9,0xea,0xeb, 0xec,0xed,0xee,0xef,
  729.     0xf0,0xf1,0xf2,0xf3, 0xf4,0xf5,0xf6,0xf7,
  730.     0xf8,0xf9,0xfa,0xfb, 0xfc,0xfd,0xfe,0xff,
  731. };
  732.  
  733. /* Like strcmp, but with the appropriate tweaks for file names.
  734.    Under Windows NT, filenames are case-insensitive but case-preserving,
  735.    and both \ and / are path element separators.  */
  736. int
  737. fncmp (const char *n1, const char *n2)
  738. {
  739.     while (*n1 && *n2
  740.            && (WNT_filename_classes[(unsigned char) *n1]
  741.            == WNT_filename_classes[(unsigned char) *n2]))
  742.         n1++, n2++;
  743.     return (WNT_filename_classes[(unsigned char) *n1]
  744.             - WNT_filename_classes[(unsigned char) *n2]);
  745. }
  746.  
  747. /* Fold characters in FILENAME to their canonical forms.  
  748.    If FOLD_FN_CHAR is not #defined, the system provides a default
  749.    definition for this.  */
  750. void
  751. fnfold (char *filename)
  752. {
  753.     while (*filename)
  754.     {
  755.         *filename = FOLD_FN_CHAR (*filename);
  756.     filename++;
  757.     }
  758. }
  759.  
  760.  
  761. /* Generate a unique temporary filename.  Returns a pointer to a newly
  762.    malloc'd string containing the name.  Returns successfully or not at
  763.    all.  */
  764. char *
  765. cvs_temp_name ()
  766. {
  767.     char *retval;
  768.  
  769.     retval = _tempnam (NULL, NULL);
  770.     if (retval == NULL)
  771.     error (1, errno, "cannot generate temporary filename");
  772.     return retval;
  773. }
  774.  
  775. /* Return non-zero iff FILENAME is absolute.
  776.    Trivial under Unix, but more complicated under other systems.  */
  777. int
  778. isabsolute (filename)
  779.     const char *filename;
  780. {
  781.     return (ISDIRSEP (filename[0])
  782.             || (filename[0] != '\0'
  783.                 && filename[1] == ':'
  784.                 && ISDIRSEP (filename[2])));
  785. }
  786.  
  787. /* Return a pointer into PATH's last component.  */
  788. char *
  789. last_component (char *path)
  790. {
  791.     char *scan;
  792.     char *last = 0;
  793.  
  794.     for (scan = path; *scan; scan++)
  795.         if (ISDIRSEP (*scan))
  796.         last = scan;
  797.  
  798.     if (last)
  799.         return last + 1;
  800.     else
  801.         return path;
  802. }
  803.  
  804.  
  805. /* Read data from INFILE, and copy it to OUTFILE. 
  806.    Open INFILE using INFLAGS, and OUTFILE using OUTFLAGS.
  807.    This is useful for converting between CRLF and LF line formats.  */
  808. void
  809. convert_file (char *infile,  int inflags,
  810.           char *outfile, int outflags)
  811. {
  812.     int infd, outfd;
  813.     char buf[8192];
  814.     int len;
  815.  
  816.     if ((infd = open (infile, inflags)) < 0)
  817.         error (1, errno, "couldn't read %s", infile);
  818.     if ((outfd = open (outfile, outflags, S_IWRITE)) < 0)
  819.         error (1, errno, "couldn't write %s", outfile);
  820.  
  821.     while ((len = read (infd, buf, sizeof (buf))) > 0)
  822.         if (write (outfd, buf, len) < 0)
  823.         error (1, errno, "error writing %s", outfile);
  824.     if (len < 0)
  825.         error (1, errno, "error reading %s", infile);
  826.  
  827.     if (close (outfd) < 0)
  828.         error (0, errno, "warning: couldn't close %s", outfile);
  829.     if (close (infd) < 0)
  830.         error (0, errno, "warning: couldn't close %s", infile);
  831. }
  832.  
  833.  
  834. /* NT has two evironment variables, HOMEPATH and HOMEDRIVE, which,
  835.    when combined as ${HOMEDRIVE}${HOMEPATH}, give the unix equivalent
  836.    of HOME.  Some NT users are just too unixy, though, and set the
  837.    HOME variable themselves.  Therefore, we check for HOME first, and
  838.    then try to combine the other two if that fails.  */
  839.  
  840. char *
  841. get_homedir ()
  842. {
  843.     static char pathbuf[PATH_MAX * 2];
  844.     char *hd, *hp;
  845.  
  846.     if ((hd = getenv ("HOME")))
  847.     return hd;
  848.     else if ((hd = getenv ("HOMEDRIVE")) && (hp = getenv ("HOMEPATH")))
  849.     {
  850.     /* Watch for buffer overruns. */
  851.  
  852. #define cvs_min(x,y) ((x <= y) ? (x) : (y))
  853.  
  854.     int ld = cvs_min (PATH_MAX, strlen (hd));
  855.     int lp = cvs_min (PATH_MAX, strlen (hp));
  856.  
  857.     strncpy (pathbuf, hd, ld);
  858.     strncpy (pathbuf + ld, hp, lp);
  859.  
  860.     return pathbuf;
  861.     }
  862.     else
  863.     return NULL;
  864. }
  865.  
  866. /* See cvs.h for description.  */
  867. void
  868. expand_wild (argc, argv, pargc, pargv)
  869.     int argc;
  870.     char **argv;
  871.     int *pargc;
  872.     char ***pargv;
  873. {
  874.     int i;
  875.     int new_argc;
  876.     char **new_argv;
  877.     /* Allocated size of new_argv.  We arrange it so there is always room for
  878.        one more element.  */
  879.     int max_new_argc;
  880.  
  881.     new_argc = 0;
  882.     /* Add one so this is never zero.  */
  883.     max_new_argc = argc + 1;
  884.     new_argv = (char **) xmalloc (max_new_argc * sizeof (char *));
  885.     for (i = 0; i < argc; ++i)
  886.     {
  887.     HANDLE h;
  888.     WIN32_FIND_DATA fdata;
  889.  
  890.     /* These variables help us extract the directory name from the
  891.            given pathname. */
  892.  
  893.     char *last_forw_slash, *last_back_slash, *end_of_dirname;
  894.     int dirname_length = 0;
  895.  
  896.     /* FindFirstFile doesn't return pathnames, so we have to do
  897.        this ourselves.  Luckily, it's no big deal, since globbing
  898.        characters under Win32s can only occur in the last segment
  899.        of the path.  For example,
  900.                 /a/path/q*.h                      valid
  901.             /w32/q*.dir/cant/do/this/q*.h     invalid */
  902.  
  903.     /* Win32 can handle both forward and backward slashes as
  904.            filenames -- check for both. */
  905.          
  906.     last_forw_slash = strrchr (argv[i], '/');
  907.     last_back_slash = strrchr (argv[i], '\\');
  908.  
  909. #define cvs_max(x,y) ((x >= y) ? (x) : (y))
  910.  
  911.     end_of_dirname = cvs_max (last_forw_slash, last_back_slash);
  912.  
  913.     if (end_of_dirname == NULL)
  914.       dirname_length = 0;    /* no directory name */
  915.     else
  916.       dirname_length = end_of_dirname - argv[i] + 1; /* include slash */
  917.  
  918.     h = FindFirstFile (argv[i], &fdata);
  919.     if (h == INVALID_HANDLE_VALUE)
  920.     {
  921.         if (GetLastError () == ENOENT)
  922.         {
  923.         /* No match.  The file specified didn't contain a wildcard (in which case
  924.            we clearly should return it unchanged), or it contained a wildcard which
  925.            didn't match (in which case it might be better for it to be an error,
  926.            but we don't try to do that).  */
  927.         new_argv [new_argc++] = xstrdup (argv[i]);
  928.         if (new_argc == max_new_argc)
  929.         {
  930.             max_new_argc *= 2;
  931.             new_argv = xrealloc (new_argv, max_new_argc * sizeof (char *));
  932.         }
  933.         }
  934.         else
  935.         {
  936.         error (1, errno, "cannot find %s", argv[i]);
  937.         }
  938.     }
  939.     else
  940.     {
  941.         while (1)
  942.         {
  943.         new_argv[new_argc] =
  944.             (char *) xmalloc (strlen (fdata.cFileName) + 1
  945.                       + dirname_length);
  946.  
  947.         /* Copy the directory name, if there is one. */
  948.  
  949.         if (dirname_length)
  950.         {
  951.             strncpy (new_argv[new_argc], argv[i], dirname_length);
  952.             new_argv[new_argc][dirname_length] = '\0';
  953.         }
  954.         else
  955.             new_argv[new_argc][0] = '\0';
  956.  
  957.         /* Copy the file name. */
  958.         
  959.         strcat (new_argv[new_argc], fdata.cFileName);
  960.  
  961.         new_argc++;
  962.  
  963.         if (new_argc == max_new_argc)
  964.         {
  965.             max_new_argc *= 2;
  966.             new_argv = xrealloc (new_argv, max_new_argc * sizeof (char *));
  967.         }
  968.         if (!FindNextFile (h, &fdata))
  969.         {
  970.             if (GetLastError () == ERROR_NO_MORE_FILES)
  971.             break;
  972.             else
  973.             error (1, errno, "cannot find %s", argv[i]);
  974.         }
  975.         }
  976.         if (!FindClose (h))
  977.         error (1, GetLastError (), "cannot close %s", argv[i]);
  978.     }
  979.     }
  980.     *pargc = new_argc;
  981.     *pargv = new_argv;
  982. }
  983.