src/w32.c

   1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft W32 API.
   2    Copyright (C) 1994, 1995, 2000, 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs 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 GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.
  20
  21    Geoff Voelker (voelker@cs.washington.edu)                         7-29-94
  22 */
  23
  24
  25 #include <stddef.h> /* for offsetof */
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <io.h>
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <ctype.h>
  32 #include <signal.h>
  33 #include <sys/file.h>
  34 #include <sys/time.h>
  35 #include <sys/utime.h>
  36
  37 /* must include CRT headers *before* config.h */
  38
  39 #ifdef HAVE_CONFIG_H
  40 #include <config.h>
  41 #endif
  42
  43 #undef access
  44 #undef chdir
  45 #undef chmod
  46 #undef creat
  47 #undef ctime
  48 #undef fopen
  49 #undef link
  50 #undef mkdir
  51 #undef mktemp
  52 #undef open
  53 #undef rename
  54 #undef rmdir
  55 #undef unlink
  56
  57 #undef close
  58 #undef dup
  59 #undef dup2
  60 #undef pipe
  61 #undef read
  62 #undef write
  63
  64 #undef strerror
  65
  66 #include "lisp.h"
  67
  68 #include <pwd.h>
  69
  70 #ifdef __GNUC__
  71 #define _ANONYMOUS_UNION
  72 #define _ANONYMOUS_STRUCT
  73 #endif
  74 #include <windows.h>
  75
  76 #ifdef HAVE_SOCKETS     /* TCP connection support, if kernel can do it */
  77 #include <sys/socket.h>
  78 #undef socket
  79 #undef bind
  80 #undef connect
  81 #undef htons
  82 #undef ntohs
  83 #undef inet_addr
  84 #undef gethostname
  85 #undef gethostbyname
  86 #undef getservbyname
  87 #undef shutdown
  88 #undef setsockopt
  89 #undef listen
  90 #undef getsockname
  91 #undef accept
  92 #undef recvfrom
  93 #undef sendto
  94 #endif
  95
  96 #include "w32.h"
  97 #include "ndir.h"
  98 #include "w32heap.h"
  99 #include "systime.h"
 100
 101 extern Lisp_Object Vw32_downcase_file_names;
 102 extern Lisp_Object Vw32_generate_fake_inodes;
 103 extern Lisp_Object Vw32_get_true_file_attributes;
 104 extern Lisp_Object Vw32_num_mouse_buttons;
 105
 106 \f
 107 /* Equivalent of strerror for W32 error codes.  */
 108 char *
 109 w32_strerror (int error_no)
 110 {
 111   static char buf[500];
 112
 113   if (error_no == 0)
 114     error_no = GetLastError ();
 115
 116   buf[0] = '\0';
 117   if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL,
 118                       error_no,
 119                       0, /* choose most suitable language */
 120                       buf, sizeof (buf), NULL))
 121     sprintf (buf, "w32 error %u", error_no);
 122   return buf;
 123 }
 124
 125 static char startup_dir[MAXPATHLEN];
 126
 127 /* Get the current working directory.  */
 128 char *
 129 getwd (char *dir)
 130 {
 131 #if 0
 132   if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
 133     return dir;
 134   return NULL;
 135 #else
 136   /* Emacs doesn't actually change directory itself, and we want to
 137      force our real wd to be where emacs.exe is to avoid unnecessary
 138      conflicts when trying to rename or delete directories.  */
 139   strcpy (dir, startup_dir);
 140   return dir;
 141 #endif
 142 }
 143
 144 #ifndef HAVE_SOCKETS
 145 /* Emulate gethostname.  */
 146 int
 147 gethostname (char *buffer, int size)
 148 {
 149   /* NT only allows small host names, so the buffer is
 150      certainly large enough.  */
 151   return !GetComputerName (buffer, &size);
 152 }
 153 #endif /* HAVE_SOCKETS */
 154
 155 /* Emulate getloadavg.  */
 156 int
 157 getloadavg (double loadavg[], int nelem)
 158 {
 159   int i;
 160
 161   /* A faithful emulation is going to have to be saved for a rainy day.  */
 162   for (i = 0; i < nelem; i++)
 163     {
 164       loadavg[i] = 0.0;
 165     }
 166   return i;
 167 }
 168
 169 /* Emulate getpwuid, getpwnam and others.  */
 170
 171 #define PASSWD_FIELD_SIZE 256
 172
 173 static char the_passwd_name[PASSWD_FIELD_SIZE];
 174 static char the_passwd_passwd[PASSWD_FIELD_SIZE];
 175 static char the_passwd_gecos[PASSWD_FIELD_SIZE];
 176 static char the_passwd_dir[PASSWD_FIELD_SIZE];
 177 static char the_passwd_shell[PASSWD_FIELD_SIZE];
 178
 179 static struct passwd the_passwd =
 180 {
 181   the_passwd_name,
 182   the_passwd_passwd,
 183   0,
 184   0,
 185   0,
 186   the_passwd_gecos,
 187   the_passwd_dir,
 188   the_passwd_shell,
 189 };
 190
 191 int
 192 getuid ()
 193 {
 194   return the_passwd.pw_uid;
 195 }
 196
 197 int
 198 geteuid ()
 199 {
 200   /* I could imagine arguing for checking to see whether the user is
 201      in the Administrators group and returning a UID of 0 for that
 202      case, but I don't know how wise that would be in the long run.  */
 203   return getuid ();
 204 }
 205
 206 int
 207 getgid ()
 208 {
 209   return the_passwd.pw_gid;
 210 }
 211
 212 int
 213 getegid ()
 214 {
 215   return getgid ();
 216 }
 217
 218 struct passwd *
 219 getpwuid (int uid)
 220 {
 221   if (uid == the_passwd.pw_uid)
 222     return &the_passwd;
 223   return NULL;
 224 }
 225
 226 struct passwd *
 227 getpwnam (char *name)
 228 {
 229   struct passwd *pw;
 230
 231   pw = getpwuid (getuid ());
 232   if (!pw)
 233     return pw;
 234
 235   if (stricmp (name, pw->pw_name))
 236     return NULL;
 237
 238   return pw;
 239 }
 240
 241 void
 242 init_user_info ()
 243 {
 244   /* Find the user's real name by opening the process token and
 245      looking up the name associated with the user-sid in that token.
 246
 247      Use the relative portion of the identifier authority value from
 248      the user-sid as the user id value (same for group id using the
 249      primary group sid from the process token). */
 250
 251   char            user_sid[256], name[256], domain[256];
 252   DWORD           length = sizeof (name), dlength = sizeof (domain), trash;
 253   HANDLE          token = NULL;
 254   SID_NAME_USE    user_type;
 255
 256   if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &token)
 257       && GetTokenInformation (token, TokenUser,
 258                               (PVOID) user_sid, sizeof (user_sid), &trash)
 259       && LookupAccountSid (NULL, *((PSID *) user_sid), name, &length,
 260                            domain, &dlength, &user_type))
 261     {
 262       strcpy (the_passwd.pw_name, name);
 263       /* Determine a reasonable uid value. */
 264       if (stricmp ("administrator", name) == 0)
 265         {
 266           the_passwd.pw_uid = 0;
 267           the_passwd.pw_gid = 0;
 268         }
 269       else
 270         {
 271           SID_IDENTIFIER_AUTHORITY * pSIA;
 272
 273           pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
 274           /* I believe the relative portion is the last 4 bytes (of 6)
 275              with msb first. */
 276           the_passwd.pw_uid = ((pSIA->Value[2] << 24) +
 277                                (pSIA->Value[3] << 16) +
 278                                (pSIA->Value[4] << 8)  +
 279                                (pSIA->Value[5] << 0));
 280           /* restrict to conventional uid range for normal users */
 281           the_passwd.pw_uid = the_passwd.pw_uid % 60001;
 282
 283           /* Get group id */
 284           if (GetTokenInformation (token, TokenPrimaryGroup,
 285                                    (PVOID) user_sid, sizeof (user_sid), &trash))
 286             {
 287               SID_IDENTIFIER_AUTHORITY * pSIA;
 288
 289               pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
 290               the_passwd.pw_gid = ((pSIA->Value[2] << 24) +
 291                                    (pSIA->Value[3] << 16) +
 292                                    (pSIA->Value[4] << 8)  +
 293                                    (pSIA->Value[5] << 0));
 294               /* I don't know if this is necessary, but for safety... */
 295               the_passwd.pw_gid = the_passwd.pw_gid % 60001;
 296             }
 297           else
 298             the_passwd.pw_gid = the_passwd.pw_uid;
 299         }
 300     }
 301   /* If security calls are not supported (presumably because we
 302        are running under Windows 95), fallback to this. */
 303   else if (GetUserName (name, &length))
 304     {
 305       strcpy (the_passwd.pw_name, name);
 306       if (stricmp ("administrator", name) == 0)
 307         the_passwd.pw_uid = 0;
 308       else
 309         the_passwd.pw_uid = 123;
 310       the_passwd.pw_gid = the_passwd.pw_uid;
 311     }
 312   else
 313     {
 314       strcpy (the_passwd.pw_name, "unknown");
 315       the_passwd.pw_uid = 123;
 316       the_passwd.pw_gid = 123;
 317     }
 318
 319   /* Ensure HOME and SHELL are defined. */
 320   if (getenv ("HOME") == NULL)
 321     abort ();
 322   if (getenv ("SHELL") == NULL)
 323     abort ();
 324
 325   /* Set dir and shell from environment variables. */
 326   strcpy (the_passwd.pw_dir, getenv ("HOME"));
 327   strcpy (the_passwd.pw_shell, getenv ("SHELL"));
 328
 329   if (token)
 330     CloseHandle (token);
 331 }
 332
 333 int
 334 random ()
 335 {
 336   /* rand () on NT gives us 15 random bits...hack together 30 bits.  */
 337   return ((rand () << 15) | rand ());
 338 }
 339
 340 void
 341 srandom (int seed)
 342 {
 343   srand (seed);
 344 }
 345
 346
 347 /* Normalize filename by converting all path separators to
 348    the specified separator.  Also conditionally convert upper
 349    case path name components to lower case.  */
 350
 351 static void
 352 normalize_filename (fp, path_sep)
 353      register char *fp;
 354      char path_sep;
 355 {
 356   char sep;
 357   char *elem;
 358
 359   /* Always lower-case drive letters a-z, even if the filesystem
 360      preserves case in filenames.
 361      This is so filenames can be compared by string comparison
 362      functions that are case-sensitive.  Even case-preserving filesystems
 363      do not distinguish case in drive letters.  */
 364   if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
 365     {
 366       *fp += 'a' - 'A';
 367       fp += 2;
 368     }
 369
 370   if (NILP (Vw32_downcase_file_names))
 371     {
 372       while (*fp)
 373         {
 374           if (*fp == '/' || *fp == '\\')
 375             *fp = path_sep;
 376           fp++;
 377         }
 378       return;
 379     }
 380
 381   sep = path_sep;               /* convert to this path separator */
 382   elem = fp;                    /* start of current path element */
 383
 384   do {
 385     if (*fp >= 'a' && *fp <= 'z')
 386       elem = 0;                 /* don't convert this element */
 387
 388     if (*fp == 0 || *fp == ':')
 389       {
 390         sep = *fp;              /* restore current separator (or 0) */
 391         *fp = '/';              /* after conversion of this element */
 392       }
 393
 394     if (*fp == '/' || *fp == '\\')
 395       {
 396         if (elem && elem != fp)
 397           {
 398             *fp = 0;            /* temporary end of string */
 399             _strlwr (elem);     /* while we convert to lower case */
 400           }
 401         *fp = sep;              /* convert (or restore) path separator */
 402         elem = fp + 1;          /* next element starts after separator */
 403         sep = path_sep;
 404       }
 405   } while (*fp++);
 406 }
 407
 408 /* Destructively turn backslashes into slashes.  */
 409 void
 410 dostounix_filename (p)
 411      register char *p;
 412 {
 413   normalize_filename (p, '/');
 414 }
 415
 416 /* Destructively turn slashes into backslashes.  */
 417 void
 418 unixtodos_filename (p)
 419      register char *p;
 420 {
 421   normalize_filename (p, '\\');
 422 }
 423
 424 /* Remove all CR's that are followed by a LF.
 425    (From msdos.c...probably should figure out a way to share it,
 426    although this code isn't going to ever change.)  */
 427 int
 428 crlf_to_lf (n, buf)
 429      register int n;
 430      register unsigned char *buf;
 431 {
 432   unsigned char *np = buf;
 433   unsigned char *startp = buf;
 434   unsigned char *endp = buf + n;
 435
 436   if (n == 0)
 437     return n;
 438   while (buf < endp - 1)
 439     {
 440       if (*buf == 0x0d)
 441         {
 442           if (*(++buf) != 0x0a)
 443             *np++ = 0x0d;
 444         }
 445       else
 446         *np++ = *buf++;
 447     }
 448   if (buf < endp)
 449     *np++ = *buf++;
 450   return np - startp;
 451 }
 452
 453 /* Parse the root part of file name, if present.  Return length and
 454     optionally store pointer to char after root.  */
 455 static int
 456 parse_root (char * name, char ** pPath)
 457 {
 458   char * start = name;
 459
 460   if (name == NULL)
 461     return 0;
 462
 463   /* find the root name of the volume if given */
 464   if (isalpha (name[0]) && name[1] == ':')
 465     {
 466       /* skip past drive specifier */
 467       name += 2;
 468       if (IS_DIRECTORY_SEP (name[0]))
 469         name++;
 470     }
 471   else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
 472     {
 473       int slashes = 2;
 474       name += 2;
 475       do
 476         {
 477           if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
 478             break;
 479           name++;
 480         }
 481       while ( *name );
 482       if (IS_DIRECTORY_SEP (name[0]))
 483         name++;
 484     }
 485
 486   if (pPath)
 487     *pPath = name;
 488
 489   return name - start;
 490 }
 491
 492 /* Get long base name for name; name is assumed to be absolute.  */
 493 static int
 494 get_long_basename (char * name, char * buf, int size)
 495 {
 496   WIN32_FIND_DATA find_data;
 497   HANDLE dir_handle;
 498   int len = 0;
 499
 500   /* must be valid filename, no wild cards or other invalid characters */
 501   if (strpbrk (name, "*?|<>\""))
 502     return 0;
 503
 504   dir_handle = FindFirstFile (name, &find_data);
 505   if (dir_handle != INVALID_HANDLE_VALUE)
 506     {
 507       if ((len = strlen (find_data.cFileName)) < size)
 508         memcpy (buf, find_data.cFileName, len + 1);
 509       else
 510         len = 0;
 511       FindClose (dir_handle);
 512     }
 513   return len;
 514 }
 515
 516 /* Get long name for file, if possible (assumed to be absolute).  */
 517 BOOL
 518 w32_get_long_filename (char * name, char * buf, int size)
 519 {
 520   char * o = buf;
 521   char * p;
 522   char * q;
 523   char full[ MAX_PATH ];
 524   int len;
 525
 526   len = strlen (name);
 527   if (len >= MAX_PATH)
 528     return FALSE;
 529
 530   /* Use local copy for destructive modification.  */
 531   memcpy (full, name, len+1);
 532   unixtodos_filename (full);
 533
 534   /* Copy root part verbatim.  */
 535   len = parse_root (full, &p);
 536   memcpy (o, full, len);
 537   o += len;
 538   *o = '\0';
 539   size -= len;
 540
 541   while (p != NULL && *p)
 542     {
 543       q = p;
 544       p = strchr (q, '\\');
 545       if (p) *p = '\0';
 546       len = get_long_basename (full, o, size);
 547       if (len > 0)
 548         {
 549           o += len;
 550           size -= len;
 551           if (p != NULL)
 552             {
 553               *p++ = '\\';
 554               if (size < 2)
 555                 return FALSE;
 556               *o++ = '\\';
 557               size--;
 558               *o = '\0';
 559             }
 560         }
 561       else
 562         return FALSE;
 563     }
 564
 565   return TRUE;
 566 }
 567
 568 int
 569 is_unc_volume (const char *filename)
 570 {
 571   const char *ptr = filename;
 572
 573   if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
 574     return 0;
 575
 576   if (strpbrk (ptr + 2, "*?|<>\"\\/"))
 577     return 0;
 578
 579   return 1;
 580 }
 581
 582 /* Routines that are no-ops on NT but are defined to get Emacs to compile.  */
 583
 584 int
 585 sigsetmask (int signal_mask)
 586 {
 587   return 0;
 588 }
 589
 590 int
 591 sigmask (int sig)
 592 {
 593   return 0;
 594 }
 595
 596 int
 597 sigblock (int sig)
 598 {
 599   return 0;
 600 }
 601
 602 int
 603 sigunblock (int sig)
 604 {
 605   return 0;
 606 }
 607
 608 int
 609 setpgrp (int pid, int gid)
 610 {
 611   return 0;
 612 }
 613
 614 int
 615 alarm (int seconds)
 616 {
 617   return 0;
 618 }
 619
 620 void
 621 unrequest_sigio (void)
 622 {
 623   return;
 624 }
 625
 626 void
 627 request_sigio (void)
 628 {
 629   return;
 630 }
 631
 632 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
 633
 634 LPBYTE
 635 w32_get_resource (key, lpdwtype)
 636     char *key;
 637     LPDWORD lpdwtype;
 638 {
 639   LPBYTE lpvalue;
 640   HKEY hrootkey = NULL;
 641   DWORD cbData;
 642   BOOL ok = FALSE;
 643
 644   /* Check both the current user and the local machine to see if
 645      we have any resources.  */
 646
 647   if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
 648     {
 649       lpvalue = NULL;
 650
 651       if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
 652           && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
 653           && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
 654         {
 655           return (lpvalue);
 656         }
 657
 658       if (lpvalue) xfree (lpvalue);
 659
 660       RegCloseKey (hrootkey);
 661     }
 662
 663   if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
 664     {
 665       lpvalue = NULL;
 666
 667       if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
 668           && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
 669           && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
 670         {
 671           return (lpvalue);
 672         }
 673
 674       if (lpvalue) xfree (lpvalue);
 675
 676       RegCloseKey (hrootkey);
 677     }
 678
 679   return (NULL);
 680 }
 681
 682 char *get_emacs_configuration (void);
 683 extern Lisp_Object Vsystem_configuration;
 684
 685 void
 686 init_environment (char ** argv)
 687 {
 688   static const char * const tempdirs[] = {
 689     "$TMPDIR", "$TEMP", "$TMP", "c:/"
 690   };
 691   int i;
 692   const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
 693
 694   /* Make sure they have a usable $TMPDIR.  Many Emacs functions use
 695      temporary files and assume "/tmp" if $TMPDIR is unset, which
 696      will break on DOS/Windows.  Refuse to work if we cannot find
 697      a directory, not even "c:/", usable for that purpose.  */
 698   for (i = 0; i < imax ; i++)
 699     {
 700       const char *tmp = tempdirs[i];
 701
 702       if (*tmp == '$')
 703         tmp = getenv (tmp + 1);
 704       /* Note that `access' can lie to us if the directory resides on a
 705          read-only filesystem, like CD-ROM or a write-protected floppy.
 706          The only way to be really sure is to actually create a file and
 707          see if it succeeds.  But I think that's too much to ask.  */
 708       if (tmp && _access (tmp, D_OK) == 0)
 709         {
 710           char * var = alloca (strlen (tmp) + 8);
 711           sprintf (var, "TMPDIR=%s", tmp);
 712           _putenv (strdup (var));
 713           break;
 714         }
 715     }
 716   if (i >= imax)
 717     cmd_error_internal
 718       (Fcons (Qerror,
 719               Fcons (build_string ("no usable temporary directories found!!"),
 720                      Qnil)),
 721        "While setting TMPDIR: ");
 722
 723   /* Check for environment variables and use registry settings if they
 724      don't exist.  Fallback on default values where applicable.  */
 725   {
 726     int i;
 727     LPBYTE lpval;
 728     DWORD dwType;
 729     char locale_name[32];
 730
 731     static struct env_entry
 732     {
 733       char * name;
 734       char * def_value;
 735     } env_vars[] =
 736     {
 737       {"HOME", "C:/"},
 738       {"PRELOAD_WINSOCK", NULL},
 739       {"emacs_dir", "C:/emacs"},
 740       {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
 741       {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
 742       {"EMACSDATA", "%emacs_dir%/etc"},
 743       {"EMACSPATH", "%emacs_dir%/bin"},
 744       {"EMACSLOCKDIR", "%emacs_dir%/lock"},
 745       /* We no longer set INFOPATH because Info-default-directory-list
 746          is then ignored.  */
 747       /*  {"INFOPATH", "%emacs_dir%/info"},  */
 748       {"EMACSDOC", "%emacs_dir%/etc"},
 749       {"TERM", "cmd"},
 750       {"LANG", NULL},
 751     };
 752
 753   /* Get default locale info and use it for LANG.  */
 754   if (GetLocaleInfo (LOCALE_USER_DEFAULT,
 755                      LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
 756                      locale_name, sizeof (locale_name)))
 757     {
 758       for (i = 0; i < (sizeof (env_vars) / sizeof (env_vars[0])); i++)
 759         {
 760           if (strcmp (env_vars[i].name, "LANG") == 0)
 761             {
 762               env_vars[i].def_value = locale_name;
 763               break;
 764             }
 765         }
 766     }
 767
 768 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
 769
 770     /* Treat emacs_dir specially: set it unconditionally based on our
 771        location, if it appears that we are running from the bin subdir
 772        of a standard installation.  */
 773     {
 774       char *p;
 775       char modname[MAX_PATH];
 776
 777       if (!GetModuleFileName (NULL, modname, MAX_PATH))
 778         abort ();
 779       if ((p = strrchr (modname, '\\')) == NULL)
 780         abort ();
 781       *p = 0;
 782
 783       if ((p = strrchr (modname, '\\')) && stricmp (p, "\\bin") == 0)
 784         {
 785           char buf[SET_ENV_BUF_SIZE];
 786
 787           *p = 0;
 788           for (p = modname; *p; p++)
 789             if (*p == '\\') *p = '/';
 790
 791           _snprintf (buf, sizeof(buf)-1, "emacs_dir=%s", modname);
 792           _putenv (strdup (buf));
 793         }
 794     }
 795
 796     for (i = 0; i < (sizeof (env_vars) / sizeof (env_vars[0])); i++)
 797       {
 798         if (!getenv (env_vars[i].name))
 799           {
 800             int dont_free = 0;
 801
 802             if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL)
 803               {
 804                 lpval = env_vars[i].def_value;
 805                 dwType = REG_EXPAND_SZ;
 806                 dont_free = 1;
 807               }
 808
 809             if (lpval)
 810               {
 811                 if (dwType == REG_EXPAND_SZ)
 812                   {
 813                     char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
 814
 815                     ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof(buf1));
 816                     _snprintf (buf2, sizeof(buf2)-1, "%s=%s", env_vars[i].name, buf1);
 817                     _putenv (strdup (buf2));
 818                   }
 819                 else if (dwType == REG_SZ)
 820                   {
 821                     char buf[SET_ENV_BUF_SIZE];
 822
 823                     _snprintf (buf, sizeof(buf)-1, "%s=%s", env_vars[i].name, lpval);
 824                     _putenv (strdup (buf));
 825                   }
 826
 827                 if (!dont_free)
 828                   xfree (lpval);
 829               }
 830           }
 831       }
 832   }
 833
 834   /* Rebuild system configuration to reflect invoking system.  */
 835   Vsystem_configuration = build_string (EMACS_CONFIGURATION);
 836
 837   /* Another special case: on NT, the PATH variable is actually named
 838      "Path" although cmd.exe (perhaps NT itself) arranges for
 839      environment variable lookup and setting to be case insensitive.
 840      However, Emacs assumes a fully case sensitive environment, so we
 841      need to change "Path" to "PATH" to match the expectations of
 842      various elisp packages.  We do this by the sneaky method of
 843      modifying the string in the C runtime environ entry.
 844
 845      The same applies to COMSPEC.  */
 846   {
 847     char ** envp;
 848
 849     for (envp = environ; *envp; envp++)
 850       if (_strnicmp (*envp, "PATH=", 5) == 0)
 851         memcpy (*envp, "PATH=", 5);
 852       else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
 853         memcpy (*envp, "COMSPEC=", 8);
 854   }
 855
 856   /* Remember the initial working directory for getwd, then make the
 857      real wd be the location of emacs.exe to avoid conflicts when
 858      renaming or deleting directories.  (We also don't call chdir when
 859      running subprocesses for the same reason.)  */
 860   if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
 861     abort ();
 862
 863   {
 864     char *p;
 865     static char modname[MAX_PATH];
 866
 867     if (!GetModuleFileName (NULL, modname, MAX_PATH))
 868       abort ();
 869     if ((p = strrchr (modname, '\\')) == NULL)
 870       abort ();
 871     *p = 0;
 872
 873     SetCurrentDirectory (modname);
 874
 875     /* Ensure argv[0] has the full path to Emacs.  */
 876     *p = '\\';
 877     argv[0] = modname;
 878   }
 879
 880   /* Determine if there is a middle mouse button, to allow parse_button
 881      to decide whether right mouse events should be mouse-2 or
 882      mouse-3. */
 883   XSETINT (Vw32_num_mouse_buttons, GetSystemMetrics (SM_CMOUSEBUTTONS));
 884
 885   init_user_info ();
 886 }
 887
 888 char *
 889 emacs_root_dir (void)
 890 {
 891   static char root_dir[FILENAME_MAX];
 892   const char *p;
 893
 894   p = getenv ("emacs_dir");
 895   if (p == NULL)
 896     abort ();
 897   strcpy (root_dir, p);
 898   root_dir[parse_root (root_dir, NULL)] = '\0';
 899   dostounix_filename (root_dir);
 900   return root_dir;
 901 }
 902
 903 /* We don't have scripts to automatically determine the system configuration
 904    for Emacs before it's compiled, and we don't want to have to make the
 905    user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
 906    routine.  */
 907
 908 char *
 909 get_emacs_configuration (void)
 910 {
 911   char *arch, *oem, *os;
 912   int build_num;
 913   static char configuration_buffer[32];
 914
 915   /* Determine the processor type.  */
 916   switch (get_processor_type ())
 917     {
 918
 919 #ifdef PROCESSOR_INTEL_386
 920     case PROCESSOR_INTEL_386:
 921     case PROCESSOR_INTEL_486:
 922     case PROCESSOR_INTEL_PENTIUM:
 923       arch = "i386";
 924       break;
 925 #endif
 926
 927 #ifdef PROCESSOR_INTEL_860
 928     case PROCESSOR_INTEL_860:
 929       arch = "i860";
 930       break;
 931 #endif
 932
 933 #ifdef PROCESSOR_MIPS_R2000
 934     case PROCESSOR_MIPS_R2000:
 935     case PROCESSOR_MIPS_R3000:
 936     case PROCESSOR_MIPS_R4000:
 937       arch = "mips";
 938       break;
 939 #endif
 940
 941 #ifdef PROCESSOR_ALPHA_21064
 942     case PROCESSOR_ALPHA_21064:
 943       arch = "alpha";
 944       break;
 945 #endif
 946
 947     default:
 948       arch = "unknown";
 949       break;
 950     }
 951
 952   /* Use the OEM field to reflect the compiler/library combination.  */
 953 #ifdef _MSC_VER
 954 #define COMPILER_NAME   "msvc"
 955 #else
 956 #ifdef __GNUC__
 957 #define COMPILER_NAME   "mingw"
 958 #else
 959 #define COMPILER_NAME   "unknown"
 960 #endif
 961 #endif
 962   oem = COMPILER_NAME;
 963
 964   switch (osinfo_cache.dwPlatformId) {
 965   case VER_PLATFORM_WIN32_NT:
 966     os = "nt";
 967     build_num = osinfo_cache.dwBuildNumber;
 968     break;
 969   case VER_PLATFORM_WIN32_WINDOWS:
 970     if (osinfo_cache.dwMinorVersion == 0) {
 971       os = "windows95";
 972     } else {
 973       os = "windows98";
 974     }
 975     build_num = LOWORD (osinfo_cache.dwBuildNumber);
 976     break;
 977   case VER_PLATFORM_WIN32s:
 978     /* Not supported, should not happen. */
 979     os = "windows32s";
 980     build_num = LOWORD (osinfo_cache.dwBuildNumber);
 981     break;
 982   default:
 983     os = "unknown";
 984     build_num = 0;
 985     break;
 986   }
 987
 988   if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
 989     sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
 990              get_w32_major_version (), get_w32_minor_version (), build_num);
 991   } else {
 992     sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
 993   }
 994
 995   return configuration_buffer;
 996 }
 997
 998 char *
 999 get_emacs_configuration_options (void)
1000 {
1001   static char options_buffer[256];
1002
1003 /* Work out the effective configure options for this build.  */
1004 #ifdef _MSC_VER
1005 #define COMPILER_VERSION        "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1006 #else
1007 #ifdef __GNUC__
1008 #define COMPILER_VERSION        "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1009 #else
1010 #define COMPILER_VERSION        ""
1011 #endif
1012 #endif
1013
1014   sprintf (options_buffer, COMPILER_VERSION);
1015 #ifdef EMACSDEBUG
1016   strcat (options_buffer, " --no-opt");
1017 #endif
1018 #ifdef USER_CFLAGS
1019   strcat (options_buffer, " --cflags");
1020   strcat (options_buffer, USER_CFLAGS);
1021 #endif
1022 #ifdef USER_LDFLAGS
1023   strcat (options_buffer, " --ldflags");
1024   strcat (options_buffer, USER_LDFLAGS);
1025 #endif
1026   return options_buffer;
1027 }
1028
1029
1030 #include <sys/timeb.h>
1031
1032 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95).  */
1033 void
1034 gettimeofday (struct timeval *tv, struct timezone *tz)
1035 {
1036   struct timeb tb;
1037   _ftime (&tb);
1038
1039   tv->tv_sec = tb.time;
1040   tv->tv_usec = tb.millitm * 1000L;
1041   if (tz)
1042     {
1043       tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich  */
1044       tz->tz_dsttime = tb.dstflag;      /* type of dst correction  */
1045     }
1046 }
1047
1048 /* ------------------------------------------------------------------------- */
1049 /* IO support and wrapper functions for W32 API. */
1050 /* ------------------------------------------------------------------------- */
1051
1052 /* Place a wrapper around the MSVC version of ctime.  It returns NULL
1053    on network directories, so we handle that case here.
1054    (Ulrich Leodolter, 1/11/95).  */
1055 char *
1056 sys_ctime (const time_t *t)
1057 {
1058   char *str = (char *) ctime (t);
1059   return (str ? str : "Sun Jan 01 00:00:00 1970");
1060 }
1061
1062 /* Emulate sleep...we could have done this with a define, but that
1063    would necessitate including windows.h in the files that used it.
1064    This is much easier.  */
1065 void
1066 sys_sleep (int seconds)
1067 {
1068   Sleep (seconds * 1000);
1069 }
1070
1071 /* Internal MSVC functions for low-level descriptor munging */
1072 extern int __cdecl _set_osfhnd (int fd, long h);
1073 extern int __cdecl _free_osfhnd (int fd);
1074
1075 /* parallel array of private info on file handles */
1076 filedesc fd_info [ MAXDESC ];
1077
1078 typedef struct volume_info_data {
1079   struct volume_info_data * next;
1080
1081   /* time when info was obtained */
1082   DWORD     timestamp;
1083
1084   /* actual volume info */
1085   char *    root_dir;
1086   DWORD     serialnum;
1087   DWORD     maxcomp;
1088   DWORD     flags;
1089   char *    name;
1090   char *    type;
1091 } volume_info_data;
1092
1093 /* Global referenced by various functions.  */
1094 static volume_info_data volume_info;
1095
1096 /* Vector to indicate which drives are local and fixed (for which cached
1097    data never expires).  */
1098 static BOOL fixed_drives[26];
1099
1100 /* Consider cached volume information to be stale if older than 10s,
1101    at least for non-local drives.  Info for fixed drives is never stale.  */
1102 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
1103 #define VOLINFO_STILL_VALID( root_dir, info )           \
1104   ( ( isalpha (root_dir[0]) &&                          \
1105       fixed_drives[ DRIVE_INDEX (root_dir[0]) ] )       \
1106     || GetTickCount () - info->timestamp < 10000 )
1107
1108 /* Cache support functions.  */
1109
1110 /* Simple linked list with linear search is sufficient.  */
1111 static volume_info_data *volume_cache = NULL;
1112
1113 static volume_info_data *
1114 lookup_volume_info (char * root_dir)
1115 {
1116   volume_info_data * info;
1117
1118   for (info = volume_cache; info; info = info->next)
1119     if (stricmp (info->root_dir, root_dir) == 0)
1120       break;
1121   return info;
1122 }
1123
1124 static void
1125 add_volume_info (char * root_dir, volume_info_data * info)
1126 {
1127   info->root_dir = xstrdup (root_dir);
1128   info->next = volume_cache;
1129   volume_cache = info;
1130 }
1131
1132
1133 /* Wrapper for GetVolumeInformation, which uses caching to avoid
1134    performance penalty (~2ms on 486 for local drives, 7.5ms for local
1135    cdrom drive, ~5-10ms or more for remote drives on LAN).  */
1136 volume_info_data *
1137 GetCachedVolumeInformation (char * root_dir)
1138 {
1139   volume_info_data * info;
1140   char default_root[ MAX_PATH ];
1141
1142   /* NULL for root_dir means use root from current directory.  */
1143   if (root_dir == NULL)
1144     {
1145       if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
1146         return NULL;
1147       parse_root (default_root, &root_dir);
1148       *root_dir = 0;
1149       root_dir = default_root;
1150     }
1151
1152   /* Local fixed drives can be cached permanently.  Removable drives
1153      cannot be cached permanently, since the volume name and serial
1154      number (if nothing else) can change.  Remote drives should be
1155      treated as if they are removable, since there is no sure way to
1156      tell whether they are or not.  Also, the UNC association of drive
1157      letters mapped to remote volumes can be changed at any time (even
1158      by other processes) without notice.
1159
1160      As a compromise, so we can benefit from caching info for remote
1161      volumes, we use a simple expiry mechanism to invalidate cache
1162      entries that are more than ten seconds old.  */
1163
1164 #if 0
1165   /* No point doing this, because WNetGetConnection is even slower than
1166      GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
1167      GetDriveType is about the only call of this type which does not
1168      involve network access, and so is extremely quick).  */
1169
1170   /* Map drive letter to UNC if remote. */
1171   if ( isalpha( root_dir[0] ) && !fixed[ DRIVE_INDEX( root_dir[0] ) ] )
1172     {
1173       char remote_name[ 256 ];
1174       char drive[3] = { root_dir[0], ':' };
1175
1176       if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
1177           == NO_ERROR)
1178         /* do something */ ;
1179     }
1180 #endif
1181
1182   info = lookup_volume_info (root_dir);
1183
1184   if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
1185   {
1186     char  name[ 256 ];
1187     DWORD serialnum;
1188     DWORD maxcomp;
1189     DWORD flags;
1190     char  type[ 256 ];
1191
1192     /* Info is not cached, or is stale. */
1193     if (!GetVolumeInformation (root_dir,
1194                                name, sizeof (name),
1195                                &serialnum,
1196                                &maxcomp,
1197                                &flags,
1198                                type, sizeof (type)))
1199       return NULL;
1200
1201     /* Cache the volume information for future use, overwriting existing
1202        entry if present.  */
1203     if (info == NULL)
1204       {
1205         info = (volume_info_data *) xmalloc (sizeof (volume_info_data));
1206         add_volume_info (root_dir, info);
1207       }
1208     else
1209       {
1210         xfree (info->name);
1211         xfree (info->type);
1212       }
1213
1214     info->name = xstrdup (name);
1215     info->serialnum = serialnum;
1216     info->maxcomp = maxcomp;
1217     info->flags = flags;
1218     info->type = xstrdup (type);
1219     info->timestamp = GetTickCount ();
1220   }
1221
1222   return info;
1223 }
1224
1225 /* Get information on the volume where name is held; set path pointer to
1226    start of pathname in name (past UNC header\volume header if present).  */
1227 int
1228 get_volume_info (const char * name, const char ** pPath)
1229 {
1230   char temp[MAX_PATH];
1231   char *rootname = NULL;  /* default to current volume */
1232   volume_info_data * info;
1233
1234   if (name == NULL)
1235     return FALSE;
1236
1237   /* find the root name of the volume if given */
1238   if (isalpha (name[0]) && name[1] == ':')
1239     {
1240       rootname = temp;
1241       temp[0] = *name++;
1242       temp[1] = *name++;
1243       temp[2] = '\\';
1244       temp[3] = 0;
1245     }
1246   else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
1247     {
1248       char *str = temp;
1249       int slashes = 4;
1250       rootname = temp;
1251       do
1252         {
1253           if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
1254             break;
1255           *str++ = *name++;
1256         }
1257       while ( *name );
1258
1259       *str++ = '\\';
1260       *str = 0;
1261     }
1262
1263   if (pPath)
1264     *pPath = name;
1265
1266   info = GetCachedVolumeInformation (rootname);
1267   if (info != NULL)
1268     {
1269       /* Set global referenced by other functions.  */
1270       volume_info = *info;
1271       return TRUE;
1272     }
1273   return FALSE;
1274 }
1275
1276 /* Determine if volume is FAT format (ie. only supports short 8.3
1277    names); also set path pointer to start of pathname in name.  */
1278 int
1279 is_fat_volume (const char * name, const char ** pPath)
1280 {
1281   if (get_volume_info (name, pPath))
1282     return (volume_info.maxcomp == 12);
1283   return FALSE;
1284 }
1285
1286 /* Map filename to a legal 8.3 name if necessary. */
1287 const char *
1288 map_w32_filename (const char * name, const char ** pPath)
1289 {
1290   static char shortname[MAX_PATH];
1291   char * str = shortname;
1292   char c;
1293   char * path;
1294   const char * save_name = name;
1295
1296   if (strlen (name) >= MAX_PATH)
1297     {
1298       /* Return a filename which will cause callers to fail.  */
1299       strcpy (shortname, "?");
1300       return shortname;
1301     }
1302
1303   if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
1304     {
1305       register int left = 8;    /* maximum number of chars in part */
1306       register int extn = 0;    /* extension added? */
1307       register int dots = 2;    /* maximum number of dots allowed */
1308
1309       while (name < path)
1310         *str++ = *name++;       /* skip past UNC header */
1311
1312       while ((c = *name++))
1313         {
1314           switch ( c )
1315             {
1316             case '\\':
1317             case '/':
1318               *str++ = '\\';
1319               extn = 0;         /* reset extension flags */
1320               dots = 2;         /* max 2 dots */
1321               left = 8;         /* max length 8 for main part */
1322               break;
1323             case ':':
1324               *str++ = ':';
1325               extn = 0;         /* reset extension flags */
1326               dots = 2;         /* max 2 dots */
1327               left = 8;         /* max length 8 for main part */
1328               break;
1329             case '.':
1330               if ( dots )
1331                 {
1332                   /* Convert path components of the form .xxx to _xxx,
1333                      but leave . and .. as they are.  This allows .emacs
1334                      to be read as _emacs, for example.  */
1335
1336                   if (! *name ||
1337                       *name == '.' ||
1338                       IS_DIRECTORY_SEP (*name))
1339                     {
1340                       *str++ = '.';
1341                       dots--;
1342                     }
1343                   else
1344                     {
1345                       *str++ = '_';
1346                       left--;
1347                       dots = 0;
1348                     }
1349                 }
1350               else if ( !extn )
1351                 {
1352                   *str++ = '.';
1353                   extn = 1;             /* we've got an extension */
1354                   left = 3;             /* 3 chars in extension */
1355                 }
1356               else
1357                 {
1358                   /* any embedded dots after the first are converted to _ */
1359                   *str++ = '_';
1360                 }
1361               break;
1362             case '~':
1363             case '#':                   /* don't lose these, they're important */
1364               if ( ! left )
1365                 str[-1] = c;            /* replace last character of part */
1366               /* FALLTHRU */
1367             default:
1368               if ( left )
1369                 {
1370                   *str++ = tolower (c); /* map to lower case (looks nicer) */
1371                   left--;
1372                   dots = 0;             /* started a path component */
1373                 }
1374               break;
1375             }
1376         }
1377       *str = '\0';
1378     }
1379   else
1380     {
1381       strcpy (shortname, name);
1382       unixtodos_filename (shortname);
1383     }
1384
1385   if (pPath)
1386     *pPath = shortname + (path - save_name);
1387
1388   return shortname;
1389 }
1390
1391 static int
1392 is_exec (const char * name)
1393 {
1394   char * p = strrchr (name, '.');
1395   return
1396     (p != NULL
1397      && (stricmp (p, ".exe") == 0 ||
1398          stricmp (p, ".com") == 0 ||
1399          stricmp (p, ".bat") == 0 ||
1400          stricmp (p, ".cmd") == 0));
1401 }
1402
1403 /* Emulate the Unix directory procedures opendir, closedir,
1404    and readdir.  We can't use the procedures supplied in sysdep.c,
1405    so we provide them here.  */
1406
1407 struct direct dir_static;       /* simulated directory contents */
1408 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
1409 static int    dir_is_fat;
1410 static char   dir_pathname[MAXPATHLEN+1];
1411 static WIN32_FIND_DATA dir_find_data;
1412
1413 /* Support shares on a network resource as subdirectories of a read-only
1414    root directory. */
1415 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
1416 HANDLE open_unc_volume (char *);
1417 char  *read_unc_volume (HANDLE, char *, int);
1418 void   close_unc_volume (HANDLE);
1419
1420 DIR *
1421 opendir (char *filename)
1422 {
1423   DIR *dirp;
1424
1425   /* Opening is done by FindFirstFile.  However, a read is inherent to
1426      this operation, so we defer the open until read time.  */
1427
1428   if (dir_find_handle != INVALID_HANDLE_VALUE)
1429     return NULL;
1430   if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1431     return NULL;
1432
1433   if (is_unc_volume (filename))
1434     {
1435       wnet_enum_handle = open_unc_volume (filename);
1436       if (wnet_enum_handle == INVALID_HANDLE_VALUE)
1437         return NULL;
1438     }
1439
1440   if (!(dirp = (DIR *) malloc (sizeof (DIR))))
1441     return NULL;
1442
1443   dirp->dd_fd = 0;
1444   dirp->dd_loc = 0;
1445   dirp->dd_size = 0;
1446
1447   strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
1448   dir_pathname[MAXPATHLEN] = '\0';
1449   dir_is_fat = is_fat_volume (filename, NULL);
1450
1451   return dirp;
1452 }
1453
1454 void
1455 closedir (DIR *dirp)
1456 {
1457   /* If we have a find-handle open, close it.  */
1458   if (dir_find_handle != INVALID_HANDLE_VALUE)
1459     {
1460       FindClose (dir_find_handle);
1461       dir_find_handle = INVALID_HANDLE_VALUE;
1462     }
1463   else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1464     {
1465       close_unc_volume (wnet_enum_handle);
1466       wnet_enum_handle = INVALID_HANDLE_VALUE;
1467     }
1468   xfree ((char *) dirp);
1469 }
1470
1471 struct direct *
1472 readdir (DIR *dirp)
1473 {
1474   if (wnet_enum_handle != INVALID_HANDLE_VALUE)
1475     {
1476       if (!read_unc_volume (wnet_enum_handle,
1477                               dir_find_data.cFileName,
1478                               MAX_PATH))
1479         return NULL;
1480     }
1481   /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
1482   else if (dir_find_handle == INVALID_HANDLE_VALUE)
1483     {
1484       char filename[MAXNAMLEN + 3];
1485       int ln;
1486
1487       strcpy (filename, dir_pathname);
1488       ln = strlen (filename) - 1;
1489       if (!IS_DIRECTORY_SEP (filename[ln]))
1490         strcat (filename, "\\");
1491       strcat (filename, "*");
1492
1493       dir_find_handle = FindFirstFile (filename, &dir_find_data);
1494
1495       if (dir_find_handle == INVALID_HANDLE_VALUE)
1496         return NULL;
1497     }
1498   else
1499     {
1500       if (!FindNextFile (dir_find_handle, &dir_find_data))
1501         return NULL;
1502     }
1503
1504   /* Emacs never uses this value, so don't bother making it match
1505      value returned by stat().  */
1506   dir_static.d_ino = 1;
1507
1508   dir_static.d_reclen = sizeof (struct direct) - MAXNAMLEN + 3 +
1509     dir_static.d_namlen - dir_static.d_namlen % 4;
1510
1511   dir_static.d_namlen = strlen (dir_find_data.cFileName);
1512   strcpy (dir_static.d_name, dir_find_data.cFileName);
1513   if (dir_is_fat)
1514     _strlwr (dir_static.d_name);
1515   else if (!NILP (Vw32_downcase_file_names))
1516     {
1517       register char *p;
1518       for (p = dir_static.d_name; *p; p++)
1519         if (*p >= 'a' && *p <= 'z')
1520           break;
1521       if (!*p)
1522         _strlwr (dir_static.d_name);
1523     }
1524
1525   return &dir_static;
1526 }
1527
1528 HANDLE
1529 open_unc_volume (char *path)
1530 {
1531   NETRESOURCE nr;
1532   HANDLE henum;
1533   int result;
1534
1535   nr.dwScope = RESOURCE_GLOBALNET;
1536   nr.dwType = RESOURCETYPE_DISK;
1537   nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
1538   nr.dwUsage = RESOURCEUSAGE_CONTAINER;
1539   nr.lpLocalName = NULL;
1540   nr.lpRemoteName = map_w32_filename (path, NULL);
1541   nr.lpComment = NULL;
1542   nr.lpProvider = NULL;
1543
1544   result = WNetOpenEnum(RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
1545                         RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
1546
1547   if (result == NO_ERROR)
1548     return henum;
1549   else
1550     return INVALID_HANDLE_VALUE;
1551 }
1552
1553 char *
1554 read_unc_volume (HANDLE henum, char *readbuf, int size)
1555 {
1556   DWORD count;
1557   int result;
1558   DWORD bufsize = 512;
1559   char *buffer;
1560   char *ptr;
1561
1562   count = 1;
1563   buffer = alloca (bufsize);
1564   result = WNetEnumResource (wnet_enum_handle, &count, buffer, &bufsize);
1565   if (result != NO_ERROR)
1566     return NULL;
1567
1568   /* WNetEnumResource returns \\resource\share...skip forward to "share". */
1569   ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
1570   ptr += 2;
1571   while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
1572   ptr++;
1573
1574   strncpy (readbuf, ptr, size);
1575   return readbuf;
1576 }
1577
1578 void
1579 close_unc_volume (HANDLE henum)
1580 {
1581   if (henum != INVALID_HANDLE_VALUE)
1582     WNetCloseEnum (henum);
1583 }
1584
1585 DWORD
1586 unc_volume_file_attributes (char *path)
1587 {
1588   HANDLE henum;
1589   DWORD attrs;
1590
1591   henum = open_unc_volume (path);
1592   if (henum == INVALID_HANDLE_VALUE)
1593     return -1;
1594
1595   attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
1596
1597   close_unc_volume (henum);
1598
1599   return attrs;
1600 }
1601
1602
1603 /* Shadow some MSVC runtime functions to map requests for long filenames
1604    to reasonable short names if necessary.  This was originally added to
1605    permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
1606    long file names.  */
1607
1608 int
1609 sys_access (const char * path, int mode)
1610 {
1611   DWORD attributes;
1612
1613   /* MSVC implementation doesn't recognize D_OK.  */
1614   path = map_w32_filename (path, NULL);
1615   if (is_unc_volume (path))
1616     {
1617       attributes = unc_volume_file_attributes (path);
1618       if (attributes == -1) {
1619         errno = EACCES;
1620         return -1;
1621       }
1622     }
1623   else if ((attributes = GetFileAttributes (path)) == -1)
1624     {
1625       /* Should try mapping GetLastError to errno; for now just indicate
1626          that path doesn't exist.  */
1627       errno = EACCES;
1628       return -1;
1629     }
1630   if ((mode & X_OK) != 0 && !is_exec (path))
1631     {
1632       errno = EACCES;
1633       return -1;
1634     }
1635   if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
1636     {
1637       errno = EACCES;
1638       return -1;
1639     }
1640   if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
1641     {
1642       errno = EACCES;
1643       return -1;
1644     }
1645   return 0;
1646 }
1647
1648 int
1649 sys_chdir (const char * path)
1650 {
1651   return _chdir (map_w32_filename (path, NULL));
1652 }
1653
1654 int
1655 sys_chmod (const char * path, int mode)
1656 {
1657   return _chmod (map_w32_filename (path, NULL), mode);
1658 }
1659
1660 int
1661 sys_creat (const char * path, int mode)
1662 {
1663   return _creat (map_w32_filename (path, NULL), mode);
1664 }
1665
1666 FILE *
1667 sys_fopen(const char * path, const char * mode)
1668 {
1669   int fd;
1670   int oflag;
1671   const char * mode_save = mode;
1672
1673   /* Force all file handles to be non-inheritable.  This is necessary to
1674      ensure child processes don't unwittingly inherit handles that might
1675      prevent future file access. */
1676
1677   if (mode[0] == 'r')
1678     oflag = O_RDONLY;
1679   else if (mode[0] == 'w' || mode[0] == 'a')
1680     oflag = O_WRONLY | O_CREAT | O_TRUNC;
1681   else
1682     return NULL;
1683
1684   /* Only do simplistic option parsing. */
1685   while (*++mode)
1686     if (mode[0] == '+')
1687       {
1688         oflag &= ~(O_RDONLY | O_WRONLY);
1689         oflag |= O_RDWR;
1690       }
1691     else if (mode[0] == 'b')
1692       {
1693         oflag &= ~O_TEXT;
1694         oflag |= O_BINARY;
1695       }
1696     else if (mode[0] == 't')
1697       {
1698         oflag &= ~O_BINARY;
1699         oflag |= O_TEXT;
1700       }
1701     else break;
1702
1703   fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
1704   if (fd < 0)
1705     return NULL;
1706
1707   return _fdopen (fd, mode_save);
1708 }
1709
1710 /* This only works on NTFS volumes, but is useful to have.  */
1711 int
1712 sys_link (const char * old, const char * new)
1713 {
1714   HANDLE fileh;
1715   int   result = -1;
1716   char oldname[MAX_PATH], newname[MAX_PATH];
1717
1718   if (old == NULL || new == NULL)
1719     {
1720       errno = ENOENT;
1721       return -1;
1722     }
1723
1724   strcpy (oldname, map_w32_filename (old, NULL));
1725   strcpy (newname, map_w32_filename (new, NULL));
1726
1727   fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
1728                       FILE_FLAG_BACKUP_SEMANTICS, NULL);
1729   if (fileh != INVALID_HANDLE_VALUE)
1730     {
1731       int wlen;
1732
1733       /* Confusingly, the "alternate" stream name field does not apply
1734          when restoring a hard link, and instead contains the actual
1735          stream data for the link (ie. the name of the link to create).
1736          The WIN32_STREAM_ID structure before the cStreamName field is
1737          the stream header, which is then immediately followed by the
1738          stream data.  */
1739
1740       struct {
1741         WIN32_STREAM_ID wid;
1742         WCHAR wbuffer[MAX_PATH];        /* extra space for link name */
1743       } data;
1744
1745       wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
1746                                   data.wid.cStreamName, MAX_PATH);
1747       if (wlen > 0)
1748         {
1749           LPVOID context = NULL;
1750           DWORD wbytes = 0;
1751
1752           data.wid.dwStreamId = BACKUP_LINK;
1753           data.wid.dwStreamAttributes = 0;
1754           data.wid.Size.LowPart = wlen * sizeof(WCHAR);
1755           data.wid.Size.HighPart = 0;
1756           data.wid.dwStreamNameSize = 0;
1757
1758           if (BackupWrite (fileh, (LPBYTE)&data,
1759                            offsetof (WIN32_STREAM_ID, cStreamName)
1760                            + data.wid.Size.LowPart,
1761                            &wbytes, FALSE, FALSE, &context)
1762               && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
1763             {
1764               /* succeeded */
1765               result = 0;
1766             }
1767           else
1768             {
1769               /* Should try mapping GetLastError to errno; for now just
1770                  indicate a general error (eg. links not supported).  */
1771               errno = EINVAL;  // perhaps EMLINK?
1772             }
1773         }
1774
1775       CloseHandle (fileh);
1776     }
1777   else
1778     errno = ENOENT;
1779
1780   return result;
1781 }
1782
1783 int
1784 sys_mkdir (const char * path)
1785 {
1786   return _mkdir (map_w32_filename (path, NULL));
1787 }
1788
1789 /* Because of long name mapping issues, we need to implement this
1790    ourselves.  Also, MSVC's _mktemp returns NULL when it can't generate
1791    a unique name, instead of setting the input template to an empty
1792    string.
1793
1794    Standard algorithm seems to be use pid or tid with a letter on the
1795    front (in place of the 6 X's) and cycle through the letters to find a
1796    unique name.  We extend that to allow any reasonable character as the
1797    first of the 6 X's.  */
1798 char *
1799 sys_mktemp (char * template)
1800 {
1801   char * p;
1802   int i;
1803   unsigned uid = GetCurrentThreadId ();
1804   static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
1805
1806   if (template == NULL)
1807     return NULL;
1808   p = template + strlen (template);
1809   i = 5;
1810   /* replace up to the last 5 X's with uid in decimal */
1811   while (--p >= template && p[0] == 'X' && --i >= 0)
1812     {
1813       p[0] = '0' + uid % 10;
1814       uid /= 10;
1815     }
1816
1817   if (i < 0 && p[0] == 'X')
1818     {
1819       i = 0;
1820       do
1821         {
1822           int save_errno = errno;
1823           p[0] = first_char[i];
1824           if (sys_access (template, 0) < 0)
1825             {
1826               errno = save_errno;
1827               return template;
1828             }
1829         }
1830       while (++i < sizeof (first_char));
1831     }
1832
1833   /* Template is badly formed or else we can't generate a unique name,
1834      so return empty string */
1835   template[0] = 0;
1836   return template;
1837 }
1838
1839 int
1840 sys_open (const char * path, int oflag, int mode)
1841 {
1842   const char* mpath = map_w32_filename (path, NULL);
1843   /* Try to open file without _O_CREAT, to be able to write to hidden
1844      and system files. Force all file handles to be
1845      non-inheritable. */
1846   int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
1847   if (res >= 0)
1848     return res;
1849   return _open (mpath, oflag | _O_NOINHERIT, mode);
1850 }
1851
1852 int
1853 sys_rename (const char * oldname, const char * newname)
1854 {
1855   BOOL result;
1856   char temp[MAX_PATH];
1857
1858   /* MoveFile on Windows 95 doesn't correctly change the short file name
1859      alias in a number of circumstances (it is not easy to predict when
1860      just by looking at oldname and newname, unfortunately).  In these
1861      cases, renaming through a temporary name avoids the problem.
1862
1863      A second problem on Windows 95 is that renaming through a temp name when
1864      newname is uppercase fails (the final long name ends up in
1865      lowercase, although the short alias might be uppercase) UNLESS the
1866      long temp name is not 8.3.
1867
1868      So, on Windows 95 we always rename through a temp name, and we make sure
1869      the temp name has a long extension to ensure correct renaming.  */
1870
1871   strcpy (temp, map_w32_filename (oldname, NULL));
1872
1873   if (os_subtype == OS_WIN95)
1874     {
1875       char * o;
1876       char * p;
1877       int    i = 0;
1878
1879       oldname = map_w32_filename (oldname, NULL);
1880       if (o = strrchr (oldname, '\\'))
1881         o++;
1882       else
1883         o = (char *) oldname;
1884
1885       if (p = strrchr (temp, '\\'))
1886         p++;
1887       else
1888         p = temp;
1889
1890       do
1891         {
1892           /* Force temp name to require a manufactured 8.3 alias - this
1893              seems to make the second rename work properly.  */
1894           sprintf (p, "_.%s.%u", o, i);
1895           i++;
1896           result = rename (oldname, temp);
1897         }
1898       /* This loop must surely terminate!  */
1899       while (result < 0 && errno == EEXIST);
1900       if (result < 0)
1901         return -1;
1902     }
1903
1904   /* Emulate Unix behaviour - newname is deleted if it already exists
1905      (at least if it is a file; don't do this for directories).
1906
1907      Since we mustn't do this if we are just changing the case of the
1908      file name (we would end up deleting the file we are trying to
1909      rename!), we let rename detect if the destination file already
1910      exists - that way we avoid the possible pitfalls of trying to
1911      determine ourselves whether two names really refer to the same
1912      file, which is not always possible in the general case.  (Consider
1913      all the permutations of shared or subst'd drives, etc.)  */
1914
1915   newname = map_w32_filename (newname, NULL);
1916   result = rename (temp, newname);
1917
1918   if (result < 0
1919       && errno == EEXIST
1920       && _chmod (newname, 0666) == 0
1921       && _unlink (newname) == 0)
1922     result = rename (temp, newname);
1923
1924   return result;
1925 }
1926
1927 int
1928 sys_rmdir (const char * path)
1929 {
1930   return _rmdir (map_w32_filename (path, NULL));
1931 }
1932
1933 int
1934 sys_unlink (const char * path)
1935 {
1936   path = map_w32_filename (path, NULL);
1937
1938   /* On Unix, unlink works without write permission. */
1939   _chmod (path, 0666);
1940   return _unlink (path);
1941 }
1942
1943 static FILETIME utc_base_ft;
1944 static long double utc_base;
1945 static int init = 0;
1946
1947 static time_t
1948 convert_time (FILETIME ft)
1949 {
1950   long double ret;
1951
1952   if (!init)
1953     {
1954       /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1955       SYSTEMTIME st;
1956
1957       st.wYear = 1970;
1958       st.wMonth = 1;
1959       st.wDay = 1;
1960       st.wHour = 0;
1961       st.wMinute = 0;
1962       st.wSecond = 0;
1963       st.wMilliseconds = 0;
1964
1965       SystemTimeToFileTime (&st, &utc_base_ft);
1966       utc_base = (long double) utc_base_ft.dwHighDateTime
1967         * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
1968       init = 1;
1969     }
1970
1971   if (CompareFileTime (&ft, &utc_base_ft) < 0)
1972     return 0;
1973
1974   ret = (long double) ft.dwHighDateTime * 4096 * 1024 * 1024 + ft.dwLowDateTime;
1975   ret -= utc_base;
1976   return (time_t) (ret * 1e-7);
1977 }
1978
1979 void
1980 convert_from_time_t (time_t time, FILETIME * pft)
1981 {
1982   long double tmp;
1983
1984   if (!init)
1985     {
1986       /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
1987       SYSTEMTIME st;
1988
1989       st.wYear = 1970;
1990       st.wMonth = 1;
1991       st.wDay = 1;
1992       st.wHour = 0;
1993       st.wMinute = 0;
1994       st.wSecond = 0;
1995       st.wMilliseconds = 0;
1996
1997       SystemTimeToFileTime (&st, &utc_base_ft);
1998       utc_base = (long double) utc_base_ft.dwHighDateTime
1999         * 4096 * 1024 * 1024 + utc_base_ft.dwLowDateTime;
2000       init = 1;
2001     }
2002
2003   /* time in 100ns units since 1-Jan-1601 */
2004   tmp = (long double) time * 1e7 + utc_base;
2005   pft->dwHighDateTime = (DWORD) (tmp / (4096.0 * 1024 * 1024));
2006   pft->dwLowDateTime = (DWORD) (tmp - (4096.0 * 1024 * 1024) * pft->dwHighDateTime);
2007 }
2008
2009 #if 0
2010 /* No reason to keep this; faking inode values either by hashing or even
2011    using the file index from GetInformationByHandle, is not perfect and
2012    so by default Emacs doesn't use the inode values on Windows.
2013    Instead, we now determine file-truename correctly (except for
2014    possible drive aliasing etc).  */
2015
2016 /*  Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
2017 static unsigned
2018 hashval (const unsigned char * str)
2019 {
2020   unsigned h = 0;
2021   while (*str)
2022     {
2023       h = (h << 4) + *str++;
2024       h ^= (h >> 28);
2025     }
2026   return h;
2027 }
2028
2029 /* Return the hash value of the canonical pathname, excluding the
2030    drive/UNC header, to get a hopefully unique inode number. */
2031 static DWORD
2032 generate_inode_val (const char * name)
2033 {
2034   char fullname[ MAX_PATH ];
2035   char * p;
2036   unsigned hash;
2037
2038   /* Get the truly canonical filename, if it exists.  (Note: this
2039      doesn't resolve aliasing due to subst commands, or recognise hard
2040      links.  */
2041   if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
2042     abort ();
2043
2044   parse_root (fullname, &p);
2045   /* Normal W32 filesystems are still case insensitive. */
2046   _strlwr (p);
2047   return hashval (p);
2048 }
2049
2050 #endif
2051
2052 /* MSVC stat function can't cope with UNC names and has other bugs, so
2053    replace it with our own.  This also allows us to calculate consistent
2054    inode values without hacks in the main Emacs code. */
2055 int
2056 stat (const char * path, struct stat * buf)
2057 {
2058   char *name, *r;
2059   WIN32_FIND_DATA wfd;
2060   HANDLE fh;
2061   DWORD fake_inode;
2062   int permission;
2063   int len;
2064   int rootdir = FALSE;
2065
2066   if (path == NULL || buf == NULL)
2067     {
2068       errno = EFAULT;
2069       return -1;
2070     }
2071
2072   name = (char *) map_w32_filename (path, &path);
2073   /* must be valid filename, no wild cards or other invalid characters */
2074   if (strpbrk (name, "*?|<>\""))
2075     {
2076       errno = ENOENT;
2077       return -1;
2078     }
2079
2080   /* If name is "c:/.." or "/.." then stat "c:/" or "/".  */
2081   r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
2082   if (IS_DIRECTORY_SEP (r[0]) && r[1] == '.' && r[2] == '.' && r[3] == '\0')
2083     {
2084       r[1] = r[2] = '\0';
2085     }
2086
2087   /* Remove trailing directory separator, unless name is the root
2088      directory of a drive or UNC volume in which case ensure there
2089      is a trailing separator. */
2090   len = strlen (name);
2091   rootdir = (path >= name + len - 1
2092              && (IS_DIRECTORY_SEP (*path) || *path == 0));
2093   name = strcpy (alloca (len + 2), name);
2094
2095   if (is_unc_volume (name))
2096     {
2097       DWORD attrs = unc_volume_file_attributes (name);
2098
2099       if (attrs == -1)
2100         return -1;
2101
2102       memset (&wfd, 0, sizeof (wfd));
2103       wfd.dwFileAttributes = attrs;
2104       wfd.ftCreationTime = utc_base_ft;
2105       wfd.ftLastAccessTime = utc_base_ft;
2106       wfd.ftLastWriteTime = utc_base_ft;
2107       strcpy (wfd.cFileName, name);
2108     }
2109   else if (rootdir)
2110     {
2111       if (!IS_DIRECTORY_SEP (name[len-1]))
2112         strcat (name, "\\");
2113       if (GetDriveType (name) < 2)
2114         {
2115           errno = ENOENT;
2116           return -1;
2117         }
2118       memset (&wfd, 0, sizeof (wfd));
2119       wfd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
2120       wfd.ftCreationTime = utc_base_ft;
2121       wfd.ftLastAccessTime = utc_base_ft;
2122       wfd.ftLastWriteTime = utc_base_ft;
2123       strcpy (wfd.cFileName, name);
2124     }
2125   else
2126     {
2127       if (IS_DIRECTORY_SEP (name[len-1]))
2128         name[len - 1] = 0;
2129
2130       /* (This is hacky, but helps when doing file completions on
2131          network drives.)  Optimize by using information available from
2132          active readdir if possible.  */
2133       len = strlen (dir_pathname);
2134       if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
2135         len--;
2136       if (dir_find_handle != INVALID_HANDLE_VALUE
2137           && strnicmp (name, dir_pathname, len) == 0
2138           && IS_DIRECTORY_SEP (name[len])
2139           && stricmp (name + len + 1, dir_static.d_name) == 0)
2140         {
2141           /* This was the last entry returned by readdir.  */
2142           wfd = dir_find_data;
2143         }
2144       else
2145         {
2146           fh = FindFirstFile (name, &wfd);
2147           if (fh == INVALID_HANDLE_VALUE)
2148             {
2149               errno = ENOENT;
2150               return -1;
2151             }
2152           FindClose (fh);
2153         }
2154     }
2155
2156   if (!NILP (Vw32_get_true_file_attributes)
2157       /* No access rights required to get info.  */
2158       && (fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
2159                            FILE_FLAG_BACKUP_SEMANTICS, NULL))
2160          != INVALID_HANDLE_VALUE)
2161     {
2162       /* This is more accurate in terms of gettting the correct number
2163          of links, but is quite slow (it is noticable when Emacs is
2164          making a list of file name completions). */
2165       BY_HANDLE_FILE_INFORMATION info;
2166
2167       if (GetFileInformationByHandle (fh, &info))
2168         {
2169           buf->st_nlink = info.nNumberOfLinks;
2170           /* Might as well use file index to fake inode values, but this
2171              is not guaranteed to be unique unless we keep a handle open
2172              all the time (even then there are situations where it is
2173              not unique).  Reputedly, there are at most 48 bits of info
2174              (on NTFS, presumably less on FAT). */
2175           fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
2176         }
2177       else
2178         {
2179           buf->st_nlink = 1;
2180           fake_inode = 0;
2181         }
2182
2183       if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2184         {
2185           buf->st_mode = _S_IFDIR;
2186         }
2187       else
2188         {
2189           switch (GetFileType (fh))
2190             {
2191             case FILE_TYPE_DISK:
2192               buf->st_mode = _S_IFREG;
2193               break;
2194             case FILE_TYPE_PIPE:
2195               buf->st_mode = _S_IFIFO;
2196               break;
2197             case FILE_TYPE_CHAR:
2198             case FILE_TYPE_UNKNOWN:
2199             default:
2200               buf->st_mode = _S_IFCHR;
2201             }
2202         }
2203       CloseHandle (fh);
2204     }
2205   else
2206     {
2207       /* Don't bother to make this information more accurate.  */
2208       buf->st_mode = (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ?
2209         _S_IFREG : _S_IFDIR;
2210       buf->st_nlink = 1;
2211       fake_inode = 0;
2212     }
2213
2214 #if 0
2215   /* Not sure if there is any point in this.  */
2216   if (!NILP (Vw32_generate_fake_inodes))
2217     fake_inode = generate_inode_val (name);
2218   else if (fake_inode == 0)
2219     {
2220       /* For want of something better, try to make everything unique.  */
2221       static DWORD gen_num = 0;
2222       fake_inode = ++gen_num;
2223     }
2224 #endif
2225
2226   /* MSVC defines _ino_t to be short; other libc's might not.  */
2227   if (sizeof (buf->st_ino) == 2)
2228     buf->st_ino = fake_inode ^ (fake_inode >> 16);
2229   else
2230     buf->st_ino = fake_inode;
2231
2232   /* consider files to belong to current user */
2233   buf->st_uid = the_passwd.pw_uid;
2234   buf->st_gid = the_passwd.pw_gid;
2235
2236   /* volume_info is set indirectly by map_w32_filename */
2237   buf->st_dev = volume_info.serialnum;
2238   buf->st_rdev = volume_info.serialnum;
2239
2240
2241   buf->st_size = wfd.nFileSizeLow;
2242
2243   /* Convert timestamps to Unix format. */
2244   buf->st_mtime = convert_time (wfd.ftLastWriteTime);
2245   buf->st_atime = convert_time (wfd.ftLastAccessTime);
2246   if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
2247   buf->st_ctime = convert_time (wfd.ftCreationTime);
2248   if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
2249
2250   /* determine rwx permissions */
2251   if (wfd.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
2252     permission = _S_IREAD;
2253   else
2254     permission = _S_IREAD | _S_IWRITE;
2255
2256   if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2257     permission |= _S_IEXEC;
2258   else if (is_exec (name))
2259     permission |= _S_IEXEC;
2260
2261   buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
2262
2263   return 0;
2264 }
2265
2266 /* Provide fstat and utime as well as stat for consistent handling of
2267    file timestamps. */
2268 int
2269 fstat (int desc, struct stat * buf)
2270 {
2271   HANDLE fh = (HANDLE) _get_osfhandle (desc);
2272   BY_HANDLE_FILE_INFORMATION info;
2273   DWORD fake_inode;
2274   int permission;
2275
2276   switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
2277     {
2278     case FILE_TYPE_DISK:
2279       buf->st_mode = _S_IFREG;
2280       if (!GetFileInformationByHandle (fh, &info))
2281         {
2282           errno = EACCES;
2283           return -1;
2284         }
2285       break;
2286     case FILE_TYPE_PIPE:
2287       buf->st_mode = _S_IFIFO;
2288       goto non_disk;
2289     case FILE_TYPE_CHAR:
2290     case FILE_TYPE_UNKNOWN:
2291     default:
2292       buf->st_mode = _S_IFCHR;
2293     non_disk:
2294       memset (&info, 0, sizeof (info));
2295       info.dwFileAttributes = 0;
2296       info.ftCreationTime = utc_base_ft;
2297       info.ftLastAccessTime = utc_base_ft;
2298       info.ftLastWriteTime = utc_base_ft;
2299     }
2300
2301   if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2302       buf->st_mode = _S_IFDIR;
2303
2304   buf->st_nlink = info.nNumberOfLinks;
2305   /* Might as well use file index to fake inode values, but this
2306      is not guaranteed to be unique unless we keep a handle open
2307      all the time (even then there are situations where it is
2308      not unique).  Reputedly, there are at most 48 bits of info
2309      (on NTFS, presumably less on FAT). */
2310   fake_inode = info.nFileIndexLow ^ info.nFileIndexHigh;
2311
2312   /* MSVC defines _ino_t to be short; other libc's might not.  */
2313   if (sizeof (buf->st_ino) == 2)
2314     buf->st_ino = fake_inode ^ (fake_inode >> 16);
2315   else
2316     buf->st_ino = fake_inode;
2317
2318   /* consider files to belong to current user */
2319   buf->st_uid = 0;
2320   buf->st_gid = 0;
2321
2322   buf->st_dev = info.dwVolumeSerialNumber;
2323   buf->st_rdev = info.dwVolumeSerialNumber;
2324
2325   buf->st_size = info.nFileSizeLow;
2326
2327   /* Convert timestamps to Unix format. */
2328   buf->st_mtime = convert_time (info.ftLastWriteTime);
2329   buf->st_atime = convert_time (info.ftLastAccessTime);
2330   if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
2331   buf->st_ctime = convert_time (info.ftCreationTime);
2332   if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
2333
2334   /* determine rwx permissions */
2335   if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
2336     permission = _S_IREAD;
2337   else
2338     permission = _S_IREAD | _S_IWRITE;
2339
2340   if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2341     permission |= _S_IEXEC;
2342   else
2343     {
2344 #if 0 /* no way of knowing the filename */
2345       char * p = strrchr (name, '.');
2346       if (p != NULL &&
2347           (stricmp (p, ".exe") == 0 ||
2348            stricmp (p, ".com") == 0 ||
2349            stricmp (p, ".bat") == 0 ||
2350            stricmp (p, ".cmd") == 0))
2351         permission |= _S_IEXEC;
2352 #endif
2353     }
2354
2355   buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
2356
2357   return 0;
2358 }
2359
2360 int
2361 utime (const char *name, struct utimbuf *times)
2362 {
2363   struct utimbuf deftime;
2364   HANDLE fh;
2365   FILETIME mtime;
2366   FILETIME atime;
2367
2368   if (times == NULL)
2369     {
2370       deftime.modtime = deftime.actime = time (NULL);
2371       times = &deftime;
2372     }
2373
2374   /* Need write access to set times.  */
2375   fh = CreateFile (name, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
2376                    0, OPEN_EXISTING, 0, NULL);
2377   if (fh)
2378     {
2379       convert_from_time_t (times->actime, &atime);
2380       convert_from_time_t (times->modtime, &mtime);
2381       if (!SetFileTime (fh, NULL, &atime, &mtime))
2382         {
2383           CloseHandle (fh);
2384           errno = EACCES;
2385           return -1;
2386         }
2387       CloseHandle (fh);
2388     }
2389   else
2390     {
2391       errno = EINVAL;
2392       return -1;
2393     }
2394   return 0;
2395 }
2396
2397 #ifdef HAVE_SOCKETS
2398
2399 /* Wrappers for  winsock functions to map between our file descriptors
2400    and winsock's handles; also set h_errno for convenience.
2401
2402    To allow Emacs to run on systems which don't have winsock support
2403    installed, we dynamically link to winsock on startup if present, and
2404    otherwise provide the minimum necessary functionality
2405    (eg. gethostname). */
2406
2407 /* function pointers for relevant socket functions */
2408 int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
2409 void (PASCAL *pfn_WSASetLastError) (int iError);
2410 int (PASCAL *pfn_WSAGetLastError) (void);
2411 int (PASCAL *pfn_socket) (int af, int type, int protocol);
2412 int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
2413 int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
2414 int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
2415 int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
2416 int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
2417 int (PASCAL *pfn_closesocket) (SOCKET s);
2418 int (PASCAL *pfn_shutdown) (SOCKET s, int how);
2419 int (PASCAL *pfn_WSACleanup) (void);
2420
2421 u_short (PASCAL *pfn_htons) (u_short hostshort);
2422 u_short (PASCAL *pfn_ntohs) (u_short netshort);
2423 unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
2424 int (PASCAL *pfn_gethostname) (char * name, int namelen);
2425 struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
2426 struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
2427
2428 int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
2429                               const char * optval, int optlen);
2430 int (PASCAL *pfn_listen) (SOCKET s, int backlog);
2431 int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
2432                                int * namelen);
2433 SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
2434 int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
2435                        struct sockaddr * from, int * fromlen);
2436 int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
2437                           const struct sockaddr * to, int tolen);
2438
2439 /* SetHandleInformation is only needed to make sockets non-inheritable. */
2440 BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
2441 #ifndef HANDLE_FLAG_INHERIT
2442 #define HANDLE_FLAG_INHERIT     1
2443 #endif
2444
2445 HANDLE winsock_lib;
2446 static int winsock_inuse;
2447
2448 BOOL
2449 term_winsock (void)
2450 {
2451   if (winsock_lib != NULL && winsock_inuse == 0)
2452     {
2453       /* Not sure what would cause WSAENETDOWN, or even if it can happen
2454          after WSAStartup returns successfully, but it seems reasonable
2455          to allow unloading winsock anyway in that case. */
2456       if (pfn_WSACleanup () == 0 ||
2457           pfn_WSAGetLastError () == WSAENETDOWN)
2458         {
2459           if (FreeLibrary (winsock_lib))
2460           winsock_lib = NULL;
2461           return TRUE;
2462         }
2463     }
2464   return FALSE;
2465 }
2466
2467 BOOL
2468 init_winsock (int load_now)
2469 {
2470   WSADATA  winsockData;
2471
2472   if (winsock_lib != NULL)
2473     return TRUE;
2474
2475   pfn_SetHandleInformation = NULL;
2476   pfn_SetHandleInformation
2477     = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
2478                                "SetHandleInformation");
2479
2480   winsock_lib = LoadLibrary ("wsock32.dll");
2481
2482   if (winsock_lib != NULL)
2483     {
2484       /* dynamically link to socket functions */
2485
2486 #define LOAD_PROC(fn) \
2487       if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
2488         goto fail;
2489
2490       LOAD_PROC( WSAStartup );
2491       LOAD_PROC( WSASetLastError );
2492       LOAD_PROC( WSAGetLastError );
2493       LOAD_PROC( socket );
2494       LOAD_PROC( bind );
2495       LOAD_PROC( connect );
2496       LOAD_PROC( ioctlsocket );
2497       LOAD_PROC( recv );
2498       LOAD_PROC( send );
2499       LOAD_PROC( closesocket );
2500       LOAD_PROC( shutdown );
2501       LOAD_PROC( htons );
2502       LOAD_PROC( ntohs );
2503       LOAD_PROC( inet_addr );
2504       LOAD_PROC( gethostname );
2505       LOAD_PROC( gethostbyname );
2506       LOAD_PROC( getservbyname );
2507       LOAD_PROC( WSACleanup );
2508       LOAD_PROC( setsockopt );
2509       LOAD_PROC( listen );
2510       LOAD_PROC( getsockname );
2511       LOAD_PROC( accept );
2512       LOAD_PROC( recvfrom );
2513       LOAD_PROC( sendto );
2514 #undef LOAD_PROC
2515
2516       /* specify version 1.1 of winsock */
2517       if (pfn_WSAStartup (0x101, &winsockData) == 0)
2518         {
2519           if (winsockData.wVersion != 0x101)
2520             goto fail;
2521
2522           if (!load_now)
2523             {
2524               /* Report that winsock exists and is usable, but leave
2525                  socket functions disabled.  I am assuming that calling
2526                  WSAStartup does not require any network interaction,
2527                  and in particular does not cause or require a dial-up
2528                  connection to be established. */
2529
2530               pfn_WSACleanup ();
2531               FreeLibrary (winsock_lib);
2532               winsock_lib = NULL;
2533             }
2534           winsock_inuse = 0;
2535           return TRUE;
2536         }
2537
2538     fail:
2539       FreeLibrary (winsock_lib);
2540       winsock_lib = NULL;
2541     }
2542
2543   return FALSE;
2544 }
2545
2546
2547 int h_errno = 0;
2548
2549 /* function to set h_errno for compatability; map winsock error codes to
2550    normal system codes where they overlap (non-overlapping definitions
2551    are already in <sys/socket.h> */
2552 static void set_errno ()
2553 {
2554   if (winsock_lib == NULL)
2555     h_errno = EINVAL;
2556   else
2557     h_errno = pfn_WSAGetLastError ();
2558
2559   switch (h_errno)
2560     {
2561     case WSAEACCES:             h_errno = EACCES; break;
2562     case WSAEBADF:              h_errno = EBADF; break;
2563     case WSAEFAULT:             h_errno = EFAULT; break;
2564     case WSAEINTR:              h_errno = EINTR; break;
2565     case WSAEINVAL:             h_errno = EINVAL; break;
2566     case WSAEMFILE:             h_errno = EMFILE; break;
2567     case WSAENAMETOOLONG:       h_errno = ENAMETOOLONG; break;
2568     case WSAENOTEMPTY:          h_errno = ENOTEMPTY; break;
2569     }
2570   errno = h_errno;
2571 }
2572
2573 static void check_errno ()
2574 {
2575   if (h_errno == 0 && winsock_lib != NULL)
2576     pfn_WSASetLastError (0);
2577 }
2578
2579 /* Extend strerror to handle the winsock-specific error codes.  */
2580 struct {
2581   int errnum;
2582   char * msg;
2583 } _wsa_errlist[] = {
2584   WSAEINTR                , "Interrupted function call",
2585   WSAEBADF                , "Bad file descriptor",
2586   WSAEACCES               , "Permission denied",
2587   WSAEFAULT               , "Bad address",
2588   WSAEINVAL               , "Invalid argument",
2589   WSAEMFILE               , "Too many open files",
2590
2591   WSAEWOULDBLOCK          , "Resource temporarily unavailable",
2592   WSAEINPROGRESS          , "Operation now in progress",
2593   WSAEALREADY             , "Operation already in progress",
2594   WSAENOTSOCK             , "Socket operation on non-socket",
2595   WSAEDESTADDRREQ         , "Destination address required",
2596   WSAEMSGSIZE             , "Message too long",
2597   WSAEPROTOTYPE           , "Protocol wrong type for socket",
2598   WSAENOPROTOOPT          , "Bad protocol option",
2599   WSAEPROTONOSUPPORT      , "Protocol not supported",
2600   WSAESOCKTNOSUPPORT      , "Socket type not supported",
2601   WSAEOPNOTSUPP           , "Operation not supported",
2602   WSAEPFNOSUPPORT         , "Protocol family not supported",
2603   WSAEAFNOSUPPORT         , "Address family not supported by protocol family",
2604   WSAEADDRINUSE           , "Address already in use",
2605   WSAEADDRNOTAVAIL        , "Cannot assign requested address",
2606   WSAENETDOWN             , "Network is down",
2607   WSAENETUNREACH          , "Network is unreachable",
2608   WSAENETRESET            , "Network dropped connection on reset",
2609   WSAECONNABORTED         , "Software caused connection abort",
2610   WSAECONNRESET           , "Connection reset by peer",
2611   WSAENOBUFS              , "No buffer space available",
2612   WSAEISCONN              , "Socket is already connected",
2613   WSAENOTCONN             , "Socket is not connected",
2614   WSAESHUTDOWN            , "Cannot send after socket shutdown",
2615   WSAETOOMANYREFS         , "Too many references",          /* not sure */
2616   WSAETIMEDOUT            , "Connection timed out",
2617   WSAECONNREFUSED         , "Connection refused",
2618   WSAELOOP                , "Network loop",                 /* not sure */
2619   WSAENAMETOOLONG         , "Name is too long",
2620   WSAEHOSTDOWN            , "Host is down",
2621   WSAEHOSTUNREACH         , "No route to host",
2622   WSAENOTEMPTY            , "Buffer not empty",             /* not sure */
2623   WSAEPROCLIM             , "Too many processes",
2624   WSAEUSERS               , "Too many users",               /* not sure */
2625   WSAEDQUOT               , "Double quote in host name",    /* really not sure */
2626   WSAESTALE               , "Data is stale",                /* not sure */
2627   WSAEREMOTE              , "Remote error",                 /* not sure */
2628
2629   WSASYSNOTREADY          , "Network subsystem is unavailable",
2630   WSAVERNOTSUPPORTED      , "WINSOCK.DLL version out of range",
2631   WSANOTINITIALISED       , "Winsock not initialized successfully",
2632   WSAEDISCON              , "Graceful shutdown in progress",
2633 #ifdef WSAENOMORE
2634   WSAENOMORE              , "No more operations allowed",   /* not sure */
2635   WSAECANCELLED           , "Operation cancelled",          /* not sure */
2636   WSAEINVALIDPROCTABLE    , "Invalid procedure table from service provider",
2637   WSAEINVALIDPROVIDER     , "Invalid service provider version number",
2638   WSAEPROVIDERFAILEDINIT  , "Unable to initialize a service provider",
2639   WSASYSCALLFAILURE       , "System call failured",
2640   WSASERVICE_NOT_FOUND    , "Service not found",            /* not sure */
2641   WSATYPE_NOT_FOUND       , "Class type not found",
2642   WSA_E_NO_MORE           , "No more resources available",  /* really not sure */
2643   WSA_E_CANCELLED         , "Operation already cancelled",  /* really not sure */
2644   WSAEREFUSED             , "Operation refused",            /* not sure */
2645 #endif
2646
2647   WSAHOST_NOT_FOUND       , "Host not found",
2648   WSATRY_AGAIN            , "Authoritative host not found during name lookup",
2649   WSANO_RECOVERY          , "Non-recoverable error during name lookup",
2650   WSANO_DATA              , "Valid name, no data record of requested type",
2651
2652   -1, NULL
2653 };
2654
2655 char *
2656 sys_strerror(int error_no)
2657 {
2658   int i;
2659   static char unknown_msg[40];
2660
2661   if (error_no >= 0 && error_no < sys_nerr)
2662     return sys_errlist[error_no];
2663
2664   for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
2665     if (_wsa_errlist[i].errnum == error_no)
2666       return _wsa_errlist[i].msg;
2667
2668   sprintf(unknown_msg, "Unidentified error: %d", error_no);
2669   return unknown_msg;
2670 }
2671
2672 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2673    but I believe the method of keeping the socket handle separate (and
2674    insuring it is not inheritable) is the correct one. */
2675
2676 //#define SOCK_REPLACE_HANDLE
2677
2678 #ifdef SOCK_REPLACE_HANDLE
2679 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2680 #else
2681 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2682 #endif
2683
2684 int socket_to_fd (SOCKET s);
2685
2686 int
2687 sys_socket(int af, int type, int protocol)
2688 {
2689   SOCKET s;
2690
2691   if (winsock_lib == NULL)
2692     {
2693       h_errno = ENETDOWN;
2694       return INVALID_SOCKET;
2695     }
2696
2697   check_errno ();
2698
2699   /* call the real socket function */
2700   s = pfn_socket (af, type, protocol);
2701
2702   if (s != INVALID_SOCKET)
2703     return socket_to_fd (s);
2704
2705   set_errno ();
2706   return -1;
2707 }
2708
2709 /* Convert a SOCKET to a file descriptor.  */
2710 int
2711 socket_to_fd (SOCKET s)
2712 {
2713   int fd;
2714   child_process * cp;
2715
2716   /* Although under NT 3.5 _open_osfhandle will accept a socket
2717      handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2718      that does not work under NT 3.1.  However, we can get the same
2719      effect by using a backdoor function to replace an existing
2720      descriptor handle with the one we want. */
2721
2722   /* allocate a file descriptor (with appropriate flags) */
2723   fd = _open ("NUL:", _O_RDWR);
2724   if (fd >= 0)
2725     {
2726 #ifdef SOCK_REPLACE_HANDLE
2727       /* now replace handle to NUL with our socket handle */
2728       CloseHandle ((HANDLE) _get_osfhandle (fd));
2729       _free_osfhnd (fd);
2730       _set_osfhnd (fd, s);
2731       /* setmode (fd, _O_BINARY); */
2732 #else
2733       /* Make a non-inheritable copy of the socket handle.  Note
2734          that it is possible that sockets aren't actually kernel
2735          handles, which appears to be the case on Windows 9x when
2736          the MS Proxy winsock client is installed.  */
2737       {
2738         /* Apparently there is a bug in NT 3.51 with some service
2739            packs, which prevents using DuplicateHandle to make a
2740            socket handle non-inheritable (causes WSACleanup to
2741            hang).  The work-around is to use SetHandleInformation
2742            instead if it is available and implemented. */
2743         if (pfn_SetHandleInformation)
2744           {
2745             pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
2746           }
2747         else
2748           {
2749             HANDLE parent = GetCurrentProcess ();
2750             HANDLE new_s = INVALID_HANDLE_VALUE;
2751
2752             if (DuplicateHandle (parent,
2753                                  (HANDLE) s,
2754                                  parent,
2755                                  &new_s,
2756                                  0,
2757                                  FALSE,
2758                                  DUPLICATE_SAME_ACCESS))
2759               {
2760                 /* It is possible that DuplicateHandle succeeds even
2761                    though the socket wasn't really a kernel handle,
2762                    because a real handle has the same value.  So
2763                    test whether the new handle really is a socket.  */
2764                 long nonblocking = 0;
2765                 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
2766                   {
2767                     pfn_closesocket (s);
2768                     s = (SOCKET) new_s;
2769                   }
2770                 else
2771                   {
2772                     CloseHandle (new_s);
2773                   }
2774               }
2775           }
2776       }
2777       fd_info[fd].hnd = (HANDLE) s;
2778 #endif
2779
2780       /* set our own internal flags */
2781       fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
2782
2783       cp = new_child ();
2784       if (cp)
2785         {
2786           cp->fd = fd;
2787           cp->status = STATUS_READ_ACKNOWLEDGED;
2788
2789           /* attach child_process to fd_info */
2790           if (fd_info[ fd ].cp != NULL)
2791             {
2792               DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
2793               abort ();
2794             }
2795
2796           fd_info[ fd ].cp = cp;
2797
2798           /* success! */
2799           winsock_inuse++;      /* count open sockets */
2800           return fd;
2801         }
2802
2803       /* clean up */
2804       _close (fd);
2805     }
2806   pfn_closesocket (s);
2807   h_errno = EMFILE;
2808   return -1;
2809 }
2810
2811
2812 int
2813 sys_bind (int s, const struct sockaddr * addr, int namelen)
2814 {
2815   if (winsock_lib == NULL)
2816     {
2817       h_errno = ENOTSOCK;
2818       return SOCKET_ERROR;
2819     }
2820
2821   check_errno ();
2822   if (fd_info[s].flags & FILE_SOCKET)
2823     {
2824       int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
2825       if (rc == SOCKET_ERROR)
2826         set_errno ();
2827       return rc;
2828     }
2829   h_errno = ENOTSOCK;
2830   return SOCKET_ERROR;
2831 }
2832
2833
2834 int
2835 sys_connect (int s, const struct sockaddr * name, int namelen)
2836 {
2837   if (winsock_lib == NULL)
2838     {
2839       h_errno = ENOTSOCK;
2840       return SOCKET_ERROR;
2841     }
2842
2843   check_errno ();
2844   if (fd_info[s].flags & FILE_SOCKET)
2845     {
2846       int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
2847       if (rc == SOCKET_ERROR)
2848         set_errno ();
2849       return rc;
2850     }
2851   h_errno = ENOTSOCK;
2852   return SOCKET_ERROR;
2853 }
2854
2855 u_short
2856 sys_htons (u_short hostshort)
2857 {
2858   return (winsock_lib != NULL) ?
2859     pfn_htons (hostshort) : hostshort;
2860 }
2861
2862 u_short
2863 sys_ntohs (u_short netshort)
2864 {
2865   return (winsock_lib != NULL) ?
2866     pfn_ntohs (netshort) : netshort;
2867 }
2868
2869 unsigned long
2870 sys_inet_addr (const char * cp)
2871 {
2872   return (winsock_lib != NULL) ?
2873     pfn_inet_addr (cp) : INADDR_NONE;
2874 }
2875
2876 int
2877 sys_gethostname (char * name, int namelen)
2878 {
2879   if (winsock_lib != NULL)
2880     return pfn_gethostname (name, namelen);
2881
2882   if (namelen > MAX_COMPUTERNAME_LENGTH)
2883     return !GetComputerName (name, (DWORD *)&namelen);
2884
2885   h_errno = EFAULT;
2886   return SOCKET_ERROR;
2887 }
2888
2889 struct hostent *
2890 sys_gethostbyname(const char * name)
2891 {
2892   struct hostent * host;
2893
2894   if (winsock_lib == NULL)
2895     {
2896       h_errno = ENETDOWN;
2897       return NULL;
2898     }
2899
2900   check_errno ();
2901   host = pfn_gethostbyname (name);
2902   if (!host)
2903     set_errno ();
2904   return host;
2905 }
2906
2907 struct servent *
2908 sys_getservbyname(const char * name, const char * proto)
2909 {
2910   struct servent * serv;
2911
2912   if (winsock_lib == NULL)
2913     {
2914       h_errno = ENETDOWN;
2915       return NULL;
2916     }
2917
2918   check_errno ();
2919   serv = pfn_getservbyname (name, proto);
2920   if (!serv)
2921     set_errno ();
2922   return serv;
2923 }
2924
2925 int
2926 sys_shutdown (int s, int how)
2927 {
2928   if (winsock_lib == NULL)
2929     {
2930       h_errno = ENETDOWN;
2931       return SOCKET_ERROR;
2932     }
2933
2934   check_errno ();
2935   if (fd_info[s].flags & FILE_SOCKET)
2936     {
2937       int rc = pfn_shutdown (SOCK_HANDLE (s), how);
2938       if (rc == SOCKET_ERROR)
2939         set_errno ();
2940       return rc;
2941     }
2942   h_errno = ENOTSOCK;
2943   return SOCKET_ERROR;
2944 }
2945
2946 int
2947 sys_setsockopt (int s, int level, int optname, const char * optval, int optlen)
2948 {
2949   if (winsock_lib == NULL)
2950     {
2951       h_errno = ENETDOWN;
2952       return SOCKET_ERROR;
2953     }
2954
2955   check_errno ();
2956   if (fd_info[s].flags & FILE_SOCKET)
2957     {
2958       int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
2959                                optval, optlen);
2960       if (rc == SOCKET_ERROR)
2961         set_errno ();
2962       return rc;
2963     }
2964   h_errno = ENOTSOCK;
2965   return SOCKET_ERROR;
2966 }
2967
2968 int
2969 sys_listen (int s, int backlog)
2970 {
2971   if (winsock_lib == NULL)
2972     {
2973       h_errno = ENETDOWN;
2974       return SOCKET_ERROR;
2975     }
2976
2977   check_errno ();
2978   if (fd_info[s].flags & FILE_SOCKET)
2979     {
2980       int rc = pfn_listen (SOCK_HANDLE (s), backlog);
2981       if (rc == SOCKET_ERROR)
2982         set_errno ();
2983       return rc;
2984     }
2985   h_errno = ENOTSOCK;
2986   return SOCKET_ERROR;
2987 }
2988
2989 int
2990 sys_getsockname (int s, struct sockaddr * name, int * namelen)
2991 {
2992   if (winsock_lib == NULL)
2993     {
2994       h_errno = ENETDOWN;
2995       return SOCKET_ERROR;
2996     }
2997
2998   check_errno ();
2999   if (fd_info[s].flags & FILE_SOCKET)
3000     {
3001       int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
3002       if (rc == SOCKET_ERROR)
3003         set_errno ();
3004       return rc;
3005     }
3006   h_errno = ENOTSOCK;
3007   return SOCKET_ERROR;
3008 }
3009
3010 int
3011 sys_accept (int s, struct sockaddr * addr, int * addrlen)
3012 {
3013   if (winsock_lib == NULL)
3014     {
3015       h_errno = ENETDOWN;
3016       return -1;
3017     }
3018
3019   check_errno ();
3020   if (fd_info[s].flags & FILE_SOCKET)
3021     {
3022       SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
3023       if (t != INVALID_SOCKET)
3024         return socket_to_fd (t);
3025
3026       set_errno ();
3027       return -1;
3028     }
3029   h_errno = ENOTSOCK;
3030   return -1;
3031 }
3032
3033 int
3034 sys_recvfrom (int s, char * buf, int len, int flags,
3035           struct sockaddr * from, int * fromlen)
3036 {
3037   if (winsock_lib == NULL)
3038     {
3039       h_errno = ENETDOWN;
3040       return SOCKET_ERROR;
3041     }
3042
3043   check_errno ();
3044   if (fd_info[s].flags & FILE_SOCKET)
3045     {
3046       int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
3047       if (rc == SOCKET_ERROR)
3048         set_errno ();
3049       return rc;
3050     }
3051   h_errno = ENOTSOCK;
3052   return SOCKET_ERROR;
3053 }
3054
3055 int
3056 sys_sendto (int s, const char * buf, int len, int flags,
3057             const struct sockaddr * to, int tolen)
3058 {
3059   if (winsock_lib == NULL)
3060     {
3061       h_errno = ENETDOWN;
3062       return SOCKET_ERROR;
3063     }
3064
3065   check_errno ();
3066   if (fd_info[s].flags & FILE_SOCKET)
3067     {
3068       int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
3069       if (rc == SOCKET_ERROR)
3070         set_errno ();
3071       return rc;
3072     }
3073   h_errno = ENOTSOCK;
3074   return SOCKET_ERROR;
3075 }
3076
3077 #endif /* HAVE_SOCKETS */
3078
3079
3080 /* Shadow main io functions: we need to handle pipes and sockets more
3081    intelligently, and implement non-blocking mode as well. */
3082
3083 int
3084 sys_close (int fd)
3085 {
3086   int rc;
3087
3088   if (fd < 0 || fd >= MAXDESC)
3089     {
3090       errno = EBADF;
3091       return -1;
3092     }
3093
3094   if (fd_info[fd].cp)
3095     {
3096       child_process * cp = fd_info[fd].cp;
3097
3098       fd_info[fd].cp = NULL;
3099
3100       if (CHILD_ACTIVE (cp))
3101         {
3102           /* if last descriptor to active child_process then cleanup */
3103           int i;
3104           for (i = 0; i < MAXDESC; i++)
3105             {
3106               if (i == fd)
3107                 continue;
3108               if (fd_info[i].cp == cp)
3109                 break;
3110             }
3111           if (i == MAXDESC)
3112             {
3113 #ifdef HAVE_SOCKETS
3114               if (fd_info[fd].flags & FILE_SOCKET)
3115                 {
3116 #ifndef SOCK_REPLACE_HANDLE
3117                   if (winsock_lib == NULL) abort ();
3118
3119                   pfn_shutdown (SOCK_HANDLE (fd), 2);
3120                   rc = pfn_closesocket (SOCK_HANDLE (fd));
3121 #endif
3122                   winsock_inuse--; /* count open sockets */
3123                 }
3124 #endif
3125               delete_child (cp);
3126             }
3127         }
3128     }
3129
3130   /* Note that sockets do not need special treatment here (at least on
3131      NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3132      closesocket is equivalent to CloseHandle, which is to be expected
3133      because socket handles are fully fledged kernel handles. */
3134   rc = _close (fd);
3135
3136   if (rc == 0)
3137     fd_info[fd].flags = 0;
3138
3139   return rc;
3140 }
3141
3142 int
3143 sys_dup (int fd)
3144 {
3145   int new_fd;
3146
3147   new_fd = _dup (fd);
3148   if (new_fd >= 0)
3149     {
3150       /* duplicate our internal info as well */
3151       fd_info[new_fd] = fd_info[fd];
3152     }
3153   return new_fd;
3154 }
3155
3156
3157 int
3158 sys_dup2 (int src, int dst)
3159 {
3160   int rc;
3161
3162   if (dst < 0 || dst >= MAXDESC)
3163     {
3164       errno = EBADF;
3165       return -1;
3166     }
3167
3168   /* make sure we close the destination first if it's a pipe or socket */
3169   if (src != dst && fd_info[dst].flags != 0)
3170     sys_close (dst);
3171
3172   rc = _dup2 (src, dst);
3173   if (rc == 0)
3174     {
3175       /* duplicate our internal info as well */
3176       fd_info[dst] = fd_info[src];
3177     }
3178   return rc;
3179 }
3180
3181 /* Unix pipe() has only one arg */
3182 int
3183 sys_pipe (int * phandles)
3184 {
3185   int rc;
3186   unsigned flags;
3187
3188   /* make pipe handles non-inheritable; when we spawn a child, we
3189      replace the relevant handle with an inheritable one.  Also put
3190      pipes into binary mode; we will do text mode translation ourselves
3191      if required.  */
3192   rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
3193
3194   if (rc == 0)
3195     {
3196       flags = FILE_PIPE | FILE_READ | FILE_BINARY;
3197       fd_info[phandles[0]].flags = flags;
3198
3199       flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
3200       fd_info[phandles[1]].flags = flags;
3201     }
3202
3203   return rc;
3204 }
3205
3206 /* From ntproc.c */
3207 extern Lisp_Object Vw32_pipe_read_delay;
3208
3209 /* Function to do blocking read of one byte, needed to implement
3210    select.  It is only allowed on sockets and pipes. */
3211 int
3212 _sys_read_ahead (int fd)
3213 {
3214   child_process * cp;
3215   int rc;
3216
3217   if (fd < 0 || fd >= MAXDESC)
3218     return STATUS_READ_ERROR;
3219
3220   cp = fd_info[fd].cp;
3221
3222   if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
3223     return STATUS_READ_ERROR;
3224
3225   if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
3226       || (fd_info[fd].flags & FILE_READ) == 0)
3227     {
3228       DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd));
3229       abort ();
3230     }
3231
3232   cp->status = STATUS_READ_IN_PROGRESS;
3233
3234   if (fd_info[fd].flags & FILE_PIPE)
3235     {
3236       rc = _read (fd, &cp->chr, sizeof (char));
3237
3238       /* Give subprocess time to buffer some more output for us before
3239          reporting that input is available; we need this because Windows 95
3240          connects DOS programs to pipes by making the pipe appear to be
3241          the normal console stdout - as a result most DOS programs will
3242          write to stdout without buffering, ie.  one character at a
3243          time.  Even some W32 programs do this - "dir" in a command
3244          shell on NT is very slow if we don't do this. */
3245       if (rc > 0)
3246         {
3247           int wait = XINT (Vw32_pipe_read_delay);
3248
3249           if (wait > 0)
3250             Sleep (wait);
3251           else if (wait < 0)
3252             while (++wait <= 0)
3253               /* Yield remainder of our time slice, effectively giving a
3254                  temporary priority boost to the child process. */
3255               Sleep (0);
3256         }
3257     }
3258 #ifdef HAVE_SOCKETS
3259   else if (fd_info[fd].flags & FILE_SOCKET)
3260     rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
3261 #endif
3262
3263   if (rc == sizeof (char))
3264     cp->status = STATUS_READ_SUCCEEDED;
3265   else
3266     cp->status = STATUS_READ_FAILED;
3267
3268   return cp->status;
3269 }
3270
3271 int
3272 sys_read (int fd, char * buffer, unsigned int count)
3273 {
3274   int nchars;
3275   int to_read;
3276   DWORD waiting;
3277   char * orig_buffer = buffer;
3278
3279   if (fd < 0 || fd >= MAXDESC)
3280     {
3281       errno = EBADF;
3282       return -1;
3283     }
3284
3285   if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3286     {
3287       child_process *cp = fd_info[fd].cp;
3288
3289       if ((fd_info[fd].flags & FILE_READ) == 0)
3290         {
3291           errno = EBADF;
3292           return -1;
3293         }
3294
3295       nchars = 0;
3296
3297       /* re-read CR carried over from last read */
3298       if (fd_info[fd].flags & FILE_LAST_CR)
3299         {
3300           if (fd_info[fd].flags & FILE_BINARY) abort ();
3301           *buffer++ = 0x0d;
3302           count--;
3303           nchars++;
3304           fd_info[fd].flags &= ~FILE_LAST_CR;
3305         }
3306
3307       /* presence of a child_process structure means we are operating in
3308          non-blocking mode - otherwise we just call _read directly.
3309          Note that the child_process structure might be missing because
3310          reap_subprocess has been called; in this case the pipe is
3311          already broken, so calling _read on it is okay. */
3312       if (cp)
3313         {
3314           int current_status = cp->status;
3315
3316           switch (current_status)
3317             {
3318             case STATUS_READ_FAILED:
3319             case STATUS_READ_ERROR:
3320               /* report normal EOF if nothing in buffer */
3321               if (nchars <= 0)
3322                 fd_info[fd].flags |= FILE_AT_EOF;
3323               return nchars;
3324
3325             case STATUS_READ_READY:
3326             case STATUS_READ_IN_PROGRESS:
3327               DebPrint (("sys_read called when read is in progress\n"));
3328               errno = EWOULDBLOCK;
3329               return -1;
3330
3331             case STATUS_READ_SUCCEEDED:
3332               /* consume read-ahead char */
3333               *buffer++ = cp->chr;
3334               count--;
3335               nchars++;
3336               cp->status = STATUS_READ_ACKNOWLEDGED;
3337               ResetEvent (cp->char_avail);
3338
3339             case STATUS_READ_ACKNOWLEDGED:
3340               break;
3341
3342             default:
3343               DebPrint (("sys_read: bad status %d\n", current_status));
3344               errno = EBADF;
3345               return -1;
3346             }
3347
3348           if (fd_info[fd].flags & FILE_PIPE)
3349             {
3350               PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
3351               to_read = min (waiting, (DWORD) count);
3352
3353               if (to_read > 0)
3354                 nchars += _read (fd, buffer, to_read);
3355             }
3356 #ifdef HAVE_SOCKETS
3357           else /* FILE_SOCKET */
3358             {
3359               if (winsock_lib == NULL) abort ();
3360
3361               /* do the equivalent of a non-blocking read */
3362               pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
3363               if (waiting == 0 && nchars == 0)
3364                 {
3365                   h_errno = errno = EWOULDBLOCK;
3366                   return -1;
3367                 }
3368
3369               if (waiting)
3370                 {
3371                   /* always use binary mode for sockets */
3372                   int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
3373                   if (res == SOCKET_ERROR)
3374                     {
3375                       DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3376                                 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3377                       set_errno ();
3378                       return -1;
3379                     }
3380                   nchars += res;
3381                 }
3382             }
3383 #endif
3384         }
3385       else
3386         {
3387           int nread = _read (fd, buffer, count);
3388           if (nread >= 0)
3389             nchars += nread;
3390           else if (nchars == 0)
3391             nchars = nread;
3392         }
3393
3394       if (nchars <= 0)
3395         fd_info[fd].flags |= FILE_AT_EOF;
3396       /* Perform text mode translation if required.  */
3397       else if ((fd_info[fd].flags & FILE_BINARY) == 0)
3398         {
3399           nchars = crlf_to_lf (nchars, orig_buffer);
3400           /* If buffer contains only CR, return that.  To be absolutely
3401              sure we should attempt to read the next char, but in
3402              practice a CR to be followed by LF would not appear by
3403              itself in the buffer.  */
3404           if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
3405             {
3406               fd_info[fd].flags |= FILE_LAST_CR;
3407               nchars--;
3408             }
3409         }
3410     }
3411   else
3412     nchars = _read (fd, buffer, count);
3413
3414   return nchars;
3415 }
3416
3417 /* For now, don't bother with a non-blocking mode */
3418 int
3419 sys_write (int fd, const void * buffer, unsigned int count)
3420 {
3421   int nchars;
3422
3423   if (fd < 0 || fd >= MAXDESC)
3424     {
3425       errno = EBADF;
3426       return -1;
3427     }
3428
3429   if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3430     {
3431       if ((fd_info[fd].flags & FILE_WRITE) == 0)
3432         {
3433           errno = EBADF;
3434           return -1;
3435         }
3436
3437       /* Perform text mode translation if required.  */
3438       if ((fd_info[fd].flags & FILE_BINARY) == 0)
3439         {
3440           char * tmpbuf = alloca (count * 2);
3441           unsigned char * src = (void *)buffer;
3442           unsigned char * dst = tmpbuf;
3443           int nbytes = count;
3444
3445           while (1)
3446             {
3447               unsigned char *next;
3448               /* copy next line or remaining bytes */
3449               next = _memccpy (dst, src, '\n', nbytes);
3450               if (next)
3451                 {
3452                   /* copied one line ending with '\n' */
3453                   int copied = next - dst;
3454                   nbytes -= copied;
3455                   src += copied;
3456                   /* insert '\r' before '\n' */
3457                   next[-1] = '\r';
3458                   next[0] = '\n';
3459                   dst = next + 1;
3460                   count++;
3461                 }
3462               else
3463                 /* copied remaining partial line -> now finished */
3464                 break;
3465             }
3466           buffer = tmpbuf;
3467         }
3468     }
3469
3470 #ifdef HAVE_SOCKETS
3471   if (fd_info[fd].flags & FILE_SOCKET)
3472     {
3473       if (winsock_lib == NULL) abort ();
3474       nchars =  pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
3475       if (nchars == SOCKET_ERROR)
3476         {
3477           DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3478                     pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3479           set_errno ();
3480         }
3481     }
3482   else
3483 #endif
3484     nchars = _write (fd, buffer, count);
3485
3486   return nchars;
3487 }
3488
3489 static void
3490 check_windows_init_file ()
3491 {
3492   extern int noninteractive, inhibit_window_system;
3493
3494   /* A common indication that Emacs is not installed properly is when
3495      it cannot find the Windows installation file.  If this file does
3496      not exist in the expected place, tell the user.  */
3497
3498   if (!noninteractive && !inhibit_window_system)
3499     {
3500       extern Lisp_Object Vwindow_system, Vload_path, Qfile_exists_p;
3501       Lisp_Object objs[2];
3502       Lisp_Object full_load_path;
3503       Lisp_Object init_file;
3504       int fd;
3505
3506       objs[0] = Vload_path;
3507       objs[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3508       full_load_path = Fappend (2, objs);
3509       init_file = build_string ("term/w32-win");
3510       fd = openp (full_load_path, init_file, Vload_suffixes, NULL, 0);
3511       if (fd < 0)
3512         {
3513           Lisp_Object load_path_print = Fprin1_to_string (full_load_path, Qnil);
3514           char *init_file_name = XSTRING (init_file)->data;
3515           char *load_path = XSTRING (load_path_print)->data;
3516           char *buffer = alloca (1024);
3517
3518           sprintf (buffer,
3519                    "The Emacs Windows initialization file \"%s.el\" "
3520                    "could not be found in your Emacs installation.  "
3521                    "Emacs checked the following directories for this file:\n"
3522                    "\n%s\n\n"
3523                    "When Emacs cannot find this file, it usually means that it "
3524                    "was not installed properly, or its distribution file was "
3525                    "not unpacked properly.\nSee the README.W32 file in the "
3526                    "top-level Emacs directory for more information.",
3527                    init_file_name, load_path);
3528           MessageBox (NULL,
3529                       buffer,
3530                       "Emacs Abort Dialog",
3531                       MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
3532       /* Use the low-level Emacs abort. */
3533 #undef abort
3534           abort ();
3535         }
3536       else
3537         {
3538           _close (fd);
3539         }
3540     }
3541 }
3542
3543 void
3544 term_ntproc ()
3545 {
3546 #ifdef HAVE_SOCKETS
3547   /* shutdown the socket interface if necessary */
3548   term_winsock ();
3549 #endif
3550 }
3551
3552 void
3553 init_ntproc ()
3554 {
3555 #ifdef HAVE_SOCKETS
3556   /* Initialise the socket interface now if available and requested by
3557      the user by defining PRELOAD_WINSOCK; otherwise loading will be
3558      delayed until open-network-stream is called (w32-has-winsock can
3559      also be used to dynamically load or reload winsock).
3560
3561      Conveniently, init_environment is called before us, so
3562      PRELOAD_WINSOCK can be set in the registry. */
3563
3564   /* Always initialize this correctly. */
3565   winsock_lib = NULL;
3566
3567   if (getenv ("PRELOAD_WINSOCK") != NULL)
3568     init_winsock (TRUE);
3569 #endif
3570
3571   /* Initial preparation for subprocess support: replace our standard
3572      handles with non-inheritable versions. */
3573   {
3574     HANDLE parent;
3575     HANDLE stdin_save =  INVALID_HANDLE_VALUE;
3576     HANDLE stdout_save = INVALID_HANDLE_VALUE;
3577     HANDLE stderr_save = INVALID_HANDLE_VALUE;
3578
3579     parent = GetCurrentProcess ();
3580
3581     /* ignore errors when duplicating and closing; typically the
3582        handles will be invalid when running as a gui program. */
3583     DuplicateHandle (parent,
3584                      GetStdHandle (STD_INPUT_HANDLE),
3585                      parent,
3586                      &stdin_save,
3587                      0,
3588                      FALSE,
3589                      DUPLICATE_SAME_ACCESS);
3590
3591     DuplicateHandle (parent,
3592                      GetStdHandle (STD_OUTPUT_HANDLE),
3593                      parent,
3594                      &stdout_save,
3595                      0,
3596                      FALSE,
3597                      DUPLICATE_SAME_ACCESS);
3598
3599     DuplicateHandle (parent,
3600                      GetStdHandle (STD_ERROR_HANDLE),
3601                      parent,
3602                      &stderr_save,
3603                      0,
3604                      FALSE,
3605                      DUPLICATE_SAME_ACCESS);
3606
3607     fclose (stdin);
3608     fclose (stdout);
3609     fclose (stderr);
3610
3611     if (stdin_save != INVALID_HANDLE_VALUE)
3612       _open_osfhandle ((long) stdin_save, O_TEXT);
3613     else
3614       _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
3615     _fdopen (0, "r");
3616
3617     if (stdout_save != INVALID_HANDLE_VALUE)
3618       _open_osfhandle ((long) stdout_save, O_TEXT);
3619     else
3620       _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
3621     _fdopen (1, "w");
3622
3623     if (stderr_save != INVALID_HANDLE_VALUE)
3624       _open_osfhandle ((long) stderr_save, O_TEXT);
3625     else
3626       _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
3627     _fdopen (2, "w");
3628   }
3629
3630   /* unfortunately, atexit depends on implementation of malloc */
3631   /* atexit (term_ntproc); */
3632   signal (SIGABRT, term_ntproc);
3633
3634   /* determine which drives are fixed, for GetCachedVolumeInformation */
3635   {
3636     /* GetDriveType must have trailing backslash. */
3637     char drive[] = "A:\\";
3638
3639     /* Loop over all possible drive letters */
3640     while (*drive <= 'Z')
3641     {
3642       /* Record if this drive letter refers to a fixed drive. */
3643       fixed_drives[DRIVE_INDEX (*drive)] =
3644         (GetDriveType (drive) == DRIVE_FIXED);
3645
3646       (*drive)++;
3647     }
3648
3649     /* Reset the volume info cache.  */
3650     volume_cache = NULL;
3651   }
3652
3653   /* Check to see if Emacs has been installed correctly.  */
3654   check_windows_init_file ();
3655 }
3656
3657 /* end of nt.c */