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 getpeername
  88 #undef shutdown
  89 #undef setsockopt
  90 #undef listen
  91 #undef getsockname
  92 #undef accept
  93 #undef recvfrom
  94 #undef sendto
  95 #endif
  96
  97 #include "w32.h"
  98 #include "ndir.h"
  99 #include "w32heap.h"
 100 #include "systime.h"
 101
 102 extern Lisp_Object Vw32_downcase_file_names;
 103 extern Lisp_Object Vw32_generate_fake_inodes;
 104 extern Lisp_Object Vw32_get_true_file_attributes;
 105 extern Lisp_Object Vw32_num_mouse_buttons;
 106
 107 \f
 108 /* Equivalent of strerror for W32 error codes.  */
 109 char *
 110 w32_strerror (int error_no)
 111 {
 112   static char buf[500];
 113
 114   if (error_no == 0)
 115     error_no = GetLastError ();
 116
 117   buf[0] = '\0';
 118   if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM, NULL,
 119                       error_no,
 120                       0, /* choose most suitable language */
 121                       buf, sizeof (buf), NULL))
 122     sprintf (buf, "w32 error %u", error_no);
 123   return buf;
 124 }
 125
 126 static char startup_dir[MAXPATHLEN];
 127
 128 /* Get the current working directory.  */
 129 char *
 130 getwd (char *dir)
 131 {
 132 #if 0
 133   if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
 134     return dir;
 135   return NULL;
 136 #else
 137   /* Emacs doesn't actually change directory itself, and we want to
 138      force our real wd to be where emacs.exe is to avoid unnecessary
 139      conflicts when trying to rename or delete directories.  */
 140   strcpy (dir, startup_dir);
 141   return dir;
 142 #endif
 143 }
 144
 145 #ifndef HAVE_SOCKETS
 146 /* Emulate gethostname.  */
 147 int
 148 gethostname (char *buffer, int size)
 149 {
 150   /* NT only allows small host names, so the buffer is
 151      certainly large enough.  */
 152   return !GetComputerName (buffer, &size);
 153 }
 154 #endif /* HAVE_SOCKETS */
 155
 156 /* Emulate getloadavg.  */
 157 int
 158 getloadavg (double loadavg[], int nelem)
 159 {
 160   int i;
 161
 162   /* A faithful emulation is going to have to be saved for a rainy day.  */
 163   for (i = 0; i < nelem; i++)
 164     {
 165       loadavg[i] = 0.0;
 166     }
 167   return i;
 168 }
 169
 170 /* Emulate getpwuid, getpwnam and others.  */
 171
 172 #define PASSWD_FIELD_SIZE 256
 173
 174 static char the_passwd_name[PASSWD_FIELD_SIZE];
 175 static char the_passwd_passwd[PASSWD_FIELD_SIZE];
 176 static char the_passwd_gecos[PASSWD_FIELD_SIZE];
 177 static char the_passwd_dir[PASSWD_FIELD_SIZE];
 178 static char the_passwd_shell[PASSWD_FIELD_SIZE];
 179
 180 static struct passwd the_passwd =
 181 {
 182   the_passwd_name,
 183   the_passwd_passwd,
 184   0,
 185   0,
 186   0,
 187   the_passwd_gecos,
 188   the_passwd_dir,
 189   the_passwd_shell,
 190 };
 191
 192 int
 193 getuid ()
 194 {
 195   return the_passwd.pw_uid;
 196 }
 197
 198 int
 199 geteuid ()
 200 {
 201   /* I could imagine arguing for checking to see whether the user is
 202      in the Administrators group and returning a UID of 0 for that
 203      case, but I don't know how wise that would be in the long run.  */
 204   return getuid ();
 205 }
 206
 207 int
 208 getgid ()
 209 {
 210   return the_passwd.pw_gid;
 211 }
 212
 213 int
 214 getegid ()
 215 {
 216   return getgid ();
 217 }
 218
 219 struct passwd *
 220 getpwuid (int uid)
 221 {
 222   if (uid == the_passwd.pw_uid)
 223     return &the_passwd;
 224   return NULL;
 225 }
 226
 227 struct passwd *
 228 getpwnam (char *name)
 229 {
 230   struct passwd *pw;
 231
 232   pw = getpwuid (getuid ());
 233   if (!pw)
 234     return pw;
 235
 236   if (stricmp (name, pw->pw_name))
 237     return NULL;
 238
 239   return pw;
 240 }
 241
 242 void
 243 init_user_info ()
 244 {
 245   /* Find the user's real name by opening the process token and
 246      looking up the name associated with the user-sid in that token.
 247
 248      Use the relative portion of the identifier authority value from
 249      the user-sid as the user id value (same for group id using the
 250      primary group sid from the process token). */
 251
 252   char            user_sid[256], name[256], domain[256];
 253   DWORD           length = sizeof (name), dlength = sizeof (domain), trash;
 254   HANDLE          token = NULL;
 255   SID_NAME_USE    user_type;
 256
 257   if (OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &token)
 258       && GetTokenInformation (token, TokenUser,
 259                               (PVOID) user_sid, sizeof (user_sid), &trash)
 260       && LookupAccountSid (NULL, *((PSID *) user_sid), name, &length,
 261                            domain, &dlength, &user_type))
 262     {
 263       strcpy (the_passwd.pw_name, name);
 264       /* Determine a reasonable uid value. */
 265       if (stricmp ("administrator", name) == 0)
 266         {
 267           the_passwd.pw_uid = 0;
 268           the_passwd.pw_gid = 0;
 269         }
 270       else
 271         {
 272           SID_IDENTIFIER_AUTHORITY * pSIA;
 273
 274           pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
 275           /* I believe the relative portion is the last 4 bytes (of 6)
 276              with msb first. */
 277           the_passwd.pw_uid = ((pSIA->Value[2] << 24) +
 278                                (pSIA->Value[3] << 16) +
 279                                (pSIA->Value[4] << 8)  +
 280                                (pSIA->Value[5] << 0));
 281           /* restrict to conventional uid range for normal users */
 282           the_passwd.pw_uid = the_passwd.pw_uid % 60001;
 283
 284           /* Get group id */
 285           if (GetTokenInformation (token, TokenPrimaryGroup,
 286                                    (PVOID) user_sid, sizeof (user_sid), &trash))
 287             {
 288               SID_IDENTIFIER_AUTHORITY * pSIA;
 289
 290               pSIA = GetSidIdentifierAuthority (*((PSID *) user_sid));
 291               the_passwd.pw_gid = ((pSIA->Value[2] << 24) +
 292                                    (pSIA->Value[3] << 16) +
 293                                    (pSIA->Value[4] << 8)  +
 294                                    (pSIA->Value[5] << 0));
 295               /* I don't know if this is necessary, but for safety... */
 296               the_passwd.pw_gid = the_passwd.pw_gid % 60001;
 297             }
 298           else
 299             the_passwd.pw_gid = the_passwd.pw_uid;
 300         }
 301     }
 302   /* If security calls are not supported (presumably because we
 303        are running under Windows 95), fallback to this. */
 304   else if (GetUserName (name, &length))
 305     {
 306       strcpy (the_passwd.pw_name, name);
 307       if (stricmp ("administrator", name) == 0)
 308         the_passwd.pw_uid = 0;
 309       else
 310         the_passwd.pw_uid = 123;
 311       the_passwd.pw_gid = the_passwd.pw_uid;
 312     }
 313   else
 314     {
 315       strcpy (the_passwd.pw_name, "unknown");
 316       the_passwd.pw_uid = 123;
 317       the_passwd.pw_gid = 123;
 318     }
 319
 320   /* Ensure HOME and SHELL are defined. */
 321   if (getenv ("HOME") == NULL)
 322     abort ();
 323   if (getenv ("SHELL") == NULL)
 324     abort ();
 325
 326   /* Set dir and shell from environment variables. */
 327   strcpy (the_passwd.pw_dir, getenv ("HOME"));
 328   strcpy (the_passwd.pw_shell, getenv ("SHELL"));
 329
 330   if (token)
 331     CloseHandle (token);
 332 }
 333
 334 int
 335 random ()
 336 {
 337   /* rand () on NT gives us 15 random bits...hack together 30 bits.  */
 338   return ((rand () << 15) | rand ());
 339 }
 340
 341 void
 342 srandom (int seed)
 343 {
 344   srand (seed);
 345 }
 346
 347
 348 /* Normalize filename by converting all path separators to
 349    the specified separator.  Also conditionally convert upper
 350    case path name components to lower case.  */
 351
 352 static void
 353 normalize_filename (fp, path_sep)
 354      register char *fp;
 355      char path_sep;
 356 {
 357   char sep;
 358   char *elem;
 359
 360   /* Always lower-case drive letters a-z, even if the filesystem
 361      preserves case in filenames.
 362      This is so filenames can be compared by string comparison
 363      functions that are case-sensitive.  Even case-preserving filesystems
 364      do not distinguish case in drive letters.  */
 365   if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
 366     {
 367       *fp += 'a' - 'A';
 368       fp += 2;
 369     }
 370
 371   if (NILP (Vw32_downcase_file_names))
 372     {
 373       while (*fp)
 374         {
 375           if (*fp == '/' || *fp == '\\')
 376             *fp = path_sep;
 377           fp++;
 378         }
 379       return;
 380     }
 381
 382   sep = path_sep;               /* convert to this path separator */
 383   elem = fp;                    /* start of current path element */
 384
 385   do {
 386     if (*fp >= 'a' && *fp <= 'z')
 387       elem = 0;                 /* don't convert this element */
 388
 389     if (*fp == 0 || *fp == ':')
 390       {
 391         sep = *fp;              /* restore current separator (or 0) */
 392         *fp = '/';              /* after conversion of this element */
 393       }
 394
 395     if (*fp == '/' || *fp == '\\')
 396       {
 397         if (elem && elem != fp)
 398           {
 399             *fp = 0;            /* temporary end of string */
 400             _strlwr (elem);     /* while we convert to lower case */
 401           }
 402         *fp = sep;              /* convert (or restore) path separator */
 403         elem = fp + 1;          /* next element starts after separator */
 404         sep = path_sep;
 405       }
 406   } while (*fp++);
 407 }
 408
 409 /* Destructively turn backslashes into slashes.  */
 410 void
 411 dostounix_filename (p)
 412      register char *p;
 413 {
 414   normalize_filename (p, '/');
 415 }
 416
 417 /* Destructively turn slashes into backslashes.  */
 418 void
 419 unixtodos_filename (p)
 420      register char *p;
 421 {
 422   normalize_filename (p, '\\');
 423 }
 424
 425 /* Remove all CR's that are followed by a LF.
 426    (From msdos.c...probably should figure out a way to share it,
 427    although this code isn't going to ever change.)  */
 428 int
 429 crlf_to_lf (n, buf)
 430      register int n;
 431      register unsigned char *buf;
 432 {
 433   unsigned char *np = buf;
 434   unsigned char *startp = buf;
 435   unsigned char *endp = buf + n;
 436
 437   if (n == 0)
 438     return n;
 439   while (buf < endp - 1)
 440     {
 441       if (*buf == 0x0d)
 442         {
 443           if (*(++buf) != 0x0a)
 444             *np++ = 0x0d;
 445         }
 446       else
 447         *np++ = *buf++;
 448     }
 449   if (buf < endp)
 450     *np++ = *buf++;
 451   return np - startp;
 452 }
 453
 454 /* Parse the root part of file name, if present.  Return length and
 455     optionally store pointer to char after root.  */
 456 static int
 457 parse_root (char * name, char ** pPath)
 458 {
 459   char * start = name;
 460
 461   if (name == NULL)
 462     return 0;
 463
 464   /* find the root name of the volume if given */
 465   if (isalpha (name[0]) && name[1] == ':')
 466     {
 467       /* skip past drive specifier */
 468       name += 2;
 469       if (IS_DIRECTORY_SEP (name[0]))
 470         name++;
 471     }
 472   else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
 473     {
 474       int slashes = 2;
 475       name += 2;
 476       do
 477         {
 478           if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
 479             break;
 480           name++;
 481         }
 482       while ( *name );
 483       if (IS_DIRECTORY_SEP (name[0]))
 484         name++;
 485     }
 486
 487   if (pPath)
 488     *pPath = name;
 489
 490   return name - start;
 491 }
 492
 493 /* Get long base name for name; name is assumed to be absolute.  */
 494 static int
 495 get_long_basename (char * name, char * buf, int size)
 496 {
 497   WIN32_FIND_DATA find_data;
 498   HANDLE dir_handle;
 499   int len = 0;
 500
 501   /* must be valid filename, no wild cards or other invalid characters */
 502   if (strpbrk (name, "*?|<>\""))
 503     return 0;
 504
 505   dir_handle = FindFirstFile (name, &find_data);
 506   if (dir_handle != INVALID_HANDLE_VALUE)
 507     {
 508       if ((len = strlen (find_data.cFileName)) < size)
 509         memcpy (buf, find_data.cFileName, len + 1);
 510       else
 511         len = 0;
 512       FindClose (dir_handle);
 513     }
 514   return len;
 515 }
 516
 517 /* Get long name for file, if possible (assumed to be absolute).  */
 518 BOOL
 519 w32_get_long_filename (char * name, char * buf, int size)
 520 {
 521   char * o = buf;
 522   char * p;
 523   char * q;
 524   char full[ MAX_PATH ];
 525   int len;
 526
 527   len = strlen (name);
 528   if (len >= MAX_PATH)
 529     return FALSE;
 530
 531   /* Use local copy for destructive modification.  */
 532   memcpy (full, name, len+1);
 533   unixtodos_filename (full);
 534
 535   /* Copy root part verbatim.  */
 536   len = parse_root (full, &p);
 537   memcpy (o, full, len);
 538   o += len;
 539   *o = '\0';
 540   size -= len;
 541
 542   while (p != NULL && *p)
 543     {
 544       q = p;
 545       p = strchr (q, '\\');
 546       if (p) *p = '\0';
 547       len = get_long_basename (full, o, size);
 548       if (len > 0)
 549         {
 550           o += len;
 551           size -= len;
 552           if (p != NULL)
 553             {
 554               *p++ = '\\';
 555               if (size < 2)
 556                 return FALSE;
 557               *o++ = '\\';
 558               size--;
 559               *o = '\0';
 560             }
 561         }
 562       else
 563         return FALSE;
 564     }
 565
 566   return TRUE;
 567 }
 568
 569 int
 570 is_unc_volume (const char *filename)
 571 {
 572   const char *ptr = filename;
 573
 574   if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
 575     return 0;
 576
 577   if (strpbrk (ptr + 2, "*?|<>\"\\/"))
 578     return 0;
 579
 580   return 1;
 581 }
 582
 583 /* Routines that are no-ops on NT but are defined to get Emacs to compile.  */
 584
 585 int
 586 sigsetmask (int signal_mask)
 587 {
 588   return 0;
 589 }
 590
 591 int
 592 sigmask (int sig)
 593 {
 594   return 0;
 595 }
 596
 597 int
 598 sigblock (int sig)
 599 {
 600   return 0;
 601 }
 602
 603 int
 604 sigunblock (int sig)
 605 {
 606   return 0;
 607 }
 608
 609 int
 610 setpgrp (int pid, int gid)
 611 {
 612   return 0;
 613 }
 614
 615 int
 616 alarm (int seconds)
 617 {
 618   return 0;
 619 }
 620
 621 void
 622 unrequest_sigio (void)
 623 {
 624   return;
 625 }
 626
 627 void
 628 request_sigio (void)
 629 {
 630   return;
 631 }
 632
 633 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
 634
 635 LPBYTE
 636 w32_get_resource (key, lpdwtype)
 637     char *key;
 638     LPDWORD lpdwtype;
 639 {
 640   LPBYTE lpvalue;
 641   HKEY hrootkey = NULL;
 642   DWORD cbData;
 643   BOOL ok = FALSE;
 644
 645   /* Check both the current user and the local machine to see if
 646      we have any resources.  */
 647
 648   if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
 649     {
 650       lpvalue = NULL;
 651
 652       if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
 653           && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
 654           && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
 655         {
 656           return (lpvalue);
 657         }
 658
 659       if (lpvalue) xfree (lpvalue);
 660
 661       RegCloseKey (hrootkey);
 662     }
 663
 664   if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
 665     {
 666       lpvalue = NULL;
 667
 668       if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
 669           && (lpvalue = (LPBYTE) xmalloc (cbData)) != NULL
 670           && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
 671         {
 672           return (lpvalue);
 673         }
 674
 675       if (lpvalue) xfree (lpvalue);
 676
 677       RegCloseKey (hrootkey);
 678     }
 679
 680   return (NULL);
 681 }
 682
 683 char *get_emacs_configuration (void);
 684 extern Lisp_Object Vsystem_configuration;
 685
 686 void
 687 init_environment (char ** argv)
 688 {
 689   static const char * const tempdirs[] = {
 690     "$TMPDIR", "$TEMP", "$TMP", "c:/"
 691   };
 692   int i;
 693   const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
 694
 695   /* Make sure they have a usable $TMPDIR.  Many Emacs functions use
 696      temporary files and assume "/tmp" if $TMPDIR is unset, which
 697      will break on DOS/Windows.  Refuse to work if we cannot find
 698      a directory, not even "c:/", usable for that purpose.  */
 699   for (i = 0; i < imax ; i++)
 700     {
 701       const char *tmp = tempdirs[i];
 702
 703       if (*tmp == '$')
 704         tmp = getenv (tmp + 1);
 705       /* Note that `access' can lie to us if the directory resides on a
 706          read-only filesystem, like CD-ROM or a write-protected floppy.
 707          The only way to be really sure is to actually create a file and
 708          see if it succeeds.  But I think that's too much to ask.  */
 709       if (tmp && _access (tmp, D_OK) == 0)
 710         {
 711           char * var = alloca (strlen (tmp) + 8);
 712           sprintf (var, "TMPDIR=%s", tmp);
 713           _putenv (strdup (var));
 714           break;
 715         }
 716     }
 717   if (i >= imax)
 718     cmd_error_internal
 719       (Fcons (Qerror,
 720               Fcons (build_string ("no usable temporary directories found!!"),
 721                      Qnil)),
 722        "While setting TMPDIR: ");
 723
 724   /* Check for environment variables and use registry settings if they
 725      don't exist.  Fallback on default values where applicable.  */
 726   {
 727     int i;
 728     LPBYTE lpval;
 729     DWORD dwType;
 730     char locale_name[32];
 731
 732     static struct env_entry
 733     {
 734       char * name;
 735       char * def_value;
 736     } env_vars[] =
 737     {
 738       {"HOME", "C:/"},
 739       {"PRELOAD_WINSOCK", NULL},
 740       {"emacs_dir", "C:/emacs"},
 741       {"EMACSLOADPATH", "%emacs_dir%/site-lisp;%emacs_dir%/../site-lisp;%emacs_dir%/lisp;%emacs_dir%/leim"},
 742       {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
 743       {"EMACSDATA", "%emacs_dir%/etc"},
 744       {"EMACSPATH", "%emacs_dir%/bin"},
 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_IFDIR : _S_IFREG;
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 int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
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( getpeername );
2508       LOAD_PROC( WSACleanup );
2509       LOAD_PROC( setsockopt );
2510       LOAD_PROC( listen );
2511       LOAD_PROC( getsockname );
2512       LOAD_PROC( accept );
2513       LOAD_PROC( recvfrom );
2514       LOAD_PROC( sendto );
2515 #undef LOAD_PROC
2516
2517       /* specify version 1.1 of winsock */
2518       if (pfn_WSAStartup (0x101, &winsockData) == 0)
2519         {
2520           if (winsockData.wVersion != 0x101)
2521             goto fail;
2522
2523           if (!load_now)
2524             {
2525               /* Report that winsock exists and is usable, but leave
2526                  socket functions disabled.  I am assuming that calling
2527                  WSAStartup does not require any network interaction,
2528                  and in particular does not cause or require a dial-up
2529                  connection to be established. */
2530
2531               pfn_WSACleanup ();
2532               FreeLibrary (winsock_lib);
2533               winsock_lib = NULL;
2534             }
2535           winsock_inuse = 0;
2536           return TRUE;
2537         }
2538
2539     fail:
2540       FreeLibrary (winsock_lib);
2541       winsock_lib = NULL;
2542     }
2543
2544   return FALSE;
2545 }
2546
2547
2548 int h_errno = 0;
2549
2550 /* function to set h_errno for compatability; map winsock error codes to
2551    normal system codes where they overlap (non-overlapping definitions
2552    are already in <sys/socket.h> */
2553 static void set_errno ()
2554 {
2555   if (winsock_lib == NULL)
2556     h_errno = EINVAL;
2557   else
2558     h_errno = pfn_WSAGetLastError ();
2559
2560   switch (h_errno)
2561     {
2562     case WSAEACCES:             h_errno = EACCES; break;
2563     case WSAEBADF:              h_errno = EBADF; break;
2564     case WSAEFAULT:             h_errno = EFAULT; break;
2565     case WSAEINTR:              h_errno = EINTR; break;
2566     case WSAEINVAL:             h_errno = EINVAL; break;
2567     case WSAEMFILE:             h_errno = EMFILE; break;
2568     case WSAENAMETOOLONG:       h_errno = ENAMETOOLONG; break;
2569     case WSAENOTEMPTY:          h_errno = ENOTEMPTY; break;
2570     }
2571   errno = h_errno;
2572 }
2573
2574 static void check_errno ()
2575 {
2576   if (h_errno == 0 && winsock_lib != NULL)
2577     pfn_WSASetLastError (0);
2578 }
2579
2580 /* Extend strerror to handle the winsock-specific error codes.  */
2581 struct {
2582   int errnum;
2583   char * msg;
2584 } _wsa_errlist[] = {
2585   WSAEINTR                , "Interrupted function call",
2586   WSAEBADF                , "Bad file descriptor",
2587   WSAEACCES               , "Permission denied",
2588   WSAEFAULT               , "Bad address",
2589   WSAEINVAL               , "Invalid argument",
2590   WSAEMFILE               , "Too many open files",
2591
2592   WSAEWOULDBLOCK          , "Resource temporarily unavailable",
2593   WSAEINPROGRESS          , "Operation now in progress",
2594   WSAEALREADY             , "Operation already in progress",
2595   WSAENOTSOCK             , "Socket operation on non-socket",
2596   WSAEDESTADDRREQ         , "Destination address required",
2597   WSAEMSGSIZE             , "Message too long",
2598   WSAEPROTOTYPE           , "Protocol wrong type for socket",
2599   WSAENOPROTOOPT          , "Bad protocol option",
2600   WSAEPROTONOSUPPORT      , "Protocol not supported",
2601   WSAESOCKTNOSUPPORT      , "Socket type not supported",
2602   WSAEOPNOTSUPP           , "Operation not supported",
2603   WSAEPFNOSUPPORT         , "Protocol family not supported",
2604   WSAEAFNOSUPPORT         , "Address family not supported by protocol family",
2605   WSAEADDRINUSE           , "Address already in use",
2606   WSAEADDRNOTAVAIL        , "Cannot assign requested address",
2607   WSAENETDOWN             , "Network is down",
2608   WSAENETUNREACH          , "Network is unreachable",
2609   WSAENETRESET            , "Network dropped connection on reset",
2610   WSAECONNABORTED         , "Software caused connection abort",
2611   WSAECONNRESET           , "Connection reset by peer",
2612   WSAENOBUFS              , "No buffer space available",
2613   WSAEISCONN              , "Socket is already connected",
2614   WSAENOTCONN             , "Socket is not connected",
2615   WSAESHUTDOWN            , "Cannot send after socket shutdown",
2616   WSAETOOMANYREFS         , "Too many references",          /* not sure */
2617   WSAETIMEDOUT            , "Connection timed out",
2618   WSAECONNREFUSED         , "Connection refused",
2619   WSAELOOP                , "Network loop",                 /* not sure */
2620   WSAENAMETOOLONG         , "Name is too long",
2621   WSAEHOSTDOWN            , "Host is down",
2622   WSAEHOSTUNREACH         , "No route to host",
2623   WSAENOTEMPTY            , "Buffer not empty",             /* not sure */
2624   WSAEPROCLIM             , "Too many processes",
2625   WSAEUSERS               , "Too many users",               /* not sure */
2626   WSAEDQUOT               , "Double quote in host name",    /* really not sure */
2627   WSAESTALE               , "Data is stale",                /* not sure */
2628   WSAEREMOTE              , "Remote error",                 /* not sure */
2629
2630   WSASYSNOTREADY          , "Network subsystem is unavailable",
2631   WSAVERNOTSUPPORTED      , "WINSOCK.DLL version out of range",
2632   WSANOTINITIALISED       , "Winsock not initialized successfully",
2633   WSAEDISCON              , "Graceful shutdown in progress",
2634 #ifdef WSAENOMORE
2635   WSAENOMORE              , "No more operations allowed",   /* not sure */
2636   WSAECANCELLED           , "Operation cancelled",          /* not sure */
2637   WSAEINVALIDPROCTABLE    , "Invalid procedure table from service provider",
2638   WSAEINVALIDPROVIDER     , "Invalid service provider version number",
2639   WSAEPROVIDERFAILEDINIT  , "Unable to initialize a service provider",
2640   WSASYSCALLFAILURE       , "System call failured",
2641   WSASERVICE_NOT_FOUND    , "Service not found",            /* not sure */
2642   WSATYPE_NOT_FOUND       , "Class type not found",
2643   WSA_E_NO_MORE           , "No more resources available",  /* really not sure */
2644   WSA_E_CANCELLED         , "Operation already cancelled",  /* really not sure */
2645   WSAEREFUSED             , "Operation refused",            /* not sure */
2646 #endif
2647
2648   WSAHOST_NOT_FOUND       , "Host not found",
2649   WSATRY_AGAIN            , "Authoritative host not found during name lookup",
2650   WSANO_RECOVERY          , "Non-recoverable error during name lookup",
2651   WSANO_DATA              , "Valid name, no data record of requested type",
2652
2653   -1, NULL
2654 };
2655
2656 char *
2657 sys_strerror(int error_no)
2658 {
2659   int i;
2660   static char unknown_msg[40];
2661
2662   if (error_no >= 0 && error_no < sys_nerr)
2663     return sys_errlist[error_no];
2664
2665   for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
2666     if (_wsa_errlist[i].errnum == error_no)
2667       return _wsa_errlist[i].msg;
2668
2669   sprintf(unknown_msg, "Unidentified error: %d", error_no);
2670   return unknown_msg;
2671 }
2672
2673 /* [andrewi 3-May-96] I've had conflicting results using both methods,
2674    but I believe the method of keeping the socket handle separate (and
2675    insuring it is not inheritable) is the correct one. */
2676
2677 //#define SOCK_REPLACE_HANDLE
2678
2679 #ifdef SOCK_REPLACE_HANDLE
2680 #define SOCK_HANDLE(fd) ((SOCKET) _get_osfhandle (fd))
2681 #else
2682 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
2683 #endif
2684
2685 int socket_to_fd (SOCKET s);
2686
2687 int
2688 sys_socket(int af, int type, int protocol)
2689 {
2690   SOCKET s;
2691
2692   if (winsock_lib == NULL)
2693     {
2694       h_errno = ENETDOWN;
2695       return INVALID_SOCKET;
2696     }
2697
2698   check_errno ();
2699
2700   /* call the real socket function */
2701   s = pfn_socket (af, type, protocol);
2702
2703   if (s != INVALID_SOCKET)
2704     return socket_to_fd (s);
2705
2706   set_errno ();
2707   return -1;
2708 }
2709
2710 /* Convert a SOCKET to a file descriptor.  */
2711 int
2712 socket_to_fd (SOCKET s)
2713 {
2714   int fd;
2715   child_process * cp;
2716
2717   /* Although under NT 3.5 _open_osfhandle will accept a socket
2718      handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
2719      that does not work under NT 3.1.  However, we can get the same
2720      effect by using a backdoor function to replace an existing
2721      descriptor handle with the one we want. */
2722
2723   /* allocate a file descriptor (with appropriate flags) */
2724   fd = _open ("NUL:", _O_RDWR);
2725   if (fd >= 0)
2726     {
2727 #ifdef SOCK_REPLACE_HANDLE
2728       /* now replace handle to NUL with our socket handle */
2729       CloseHandle ((HANDLE) _get_osfhandle (fd));
2730       _free_osfhnd (fd);
2731       _set_osfhnd (fd, s);
2732       /* setmode (fd, _O_BINARY); */
2733 #else
2734       /* Make a non-inheritable copy of the socket handle.  Note
2735          that it is possible that sockets aren't actually kernel
2736          handles, which appears to be the case on Windows 9x when
2737          the MS Proxy winsock client is installed.  */
2738       {
2739         /* Apparently there is a bug in NT 3.51 with some service
2740            packs, which prevents using DuplicateHandle to make a
2741            socket handle non-inheritable (causes WSACleanup to
2742            hang).  The work-around is to use SetHandleInformation
2743            instead if it is available and implemented. */
2744         if (pfn_SetHandleInformation)
2745           {
2746             pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
2747           }
2748         else
2749           {
2750             HANDLE parent = GetCurrentProcess ();
2751             HANDLE new_s = INVALID_HANDLE_VALUE;
2752
2753             if (DuplicateHandle (parent,
2754                                  (HANDLE) s,
2755                                  parent,
2756                                  &new_s,
2757                                  0,
2758                                  FALSE,
2759                                  DUPLICATE_SAME_ACCESS))
2760               {
2761                 /* It is possible that DuplicateHandle succeeds even
2762                    though the socket wasn't really a kernel handle,
2763                    because a real handle has the same value.  So
2764                    test whether the new handle really is a socket.  */
2765                 long nonblocking = 0;
2766                 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
2767                   {
2768                     pfn_closesocket (s);
2769                     s = (SOCKET) new_s;
2770                   }
2771                 else
2772                   {
2773                     CloseHandle (new_s);
2774                   }
2775               }
2776           }
2777       }
2778       fd_info[fd].hnd = (HANDLE) s;
2779 #endif
2780
2781       /* set our own internal flags */
2782       fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
2783
2784       cp = new_child ();
2785       if (cp)
2786         {
2787           cp->fd = fd;
2788           cp->status = STATUS_READ_ACKNOWLEDGED;
2789
2790           /* attach child_process to fd_info */
2791           if (fd_info[ fd ].cp != NULL)
2792             {
2793               DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
2794               abort ();
2795             }
2796
2797           fd_info[ fd ].cp = cp;
2798
2799           /* success! */
2800           winsock_inuse++;      /* count open sockets */
2801           return fd;
2802         }
2803
2804       /* clean up */
2805       _close (fd);
2806     }
2807   pfn_closesocket (s);
2808   h_errno = EMFILE;
2809   return -1;
2810 }
2811
2812
2813 int
2814 sys_bind (int s, const struct sockaddr * addr, int namelen)
2815 {
2816   if (winsock_lib == NULL)
2817     {
2818       h_errno = ENOTSOCK;
2819       return SOCKET_ERROR;
2820     }
2821
2822   check_errno ();
2823   if (fd_info[s].flags & FILE_SOCKET)
2824     {
2825       int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
2826       if (rc == SOCKET_ERROR)
2827         set_errno ();
2828       return rc;
2829     }
2830   h_errno = ENOTSOCK;
2831   return SOCKET_ERROR;
2832 }
2833
2834
2835 int
2836 sys_connect (int s, const struct sockaddr * name, int namelen)
2837 {
2838   if (winsock_lib == NULL)
2839     {
2840       h_errno = ENOTSOCK;
2841       return SOCKET_ERROR;
2842     }
2843
2844   check_errno ();
2845   if (fd_info[s].flags & FILE_SOCKET)
2846     {
2847       int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
2848       if (rc == SOCKET_ERROR)
2849         set_errno ();
2850       return rc;
2851     }
2852   h_errno = ENOTSOCK;
2853   return SOCKET_ERROR;
2854 }
2855
2856 u_short
2857 sys_htons (u_short hostshort)
2858 {
2859   return (winsock_lib != NULL) ?
2860     pfn_htons (hostshort) : hostshort;
2861 }
2862
2863 u_short
2864 sys_ntohs (u_short netshort)
2865 {
2866   return (winsock_lib != NULL) ?
2867     pfn_ntohs (netshort) : netshort;
2868 }
2869
2870 unsigned long
2871 sys_inet_addr (const char * cp)
2872 {
2873   return (winsock_lib != NULL) ?
2874     pfn_inet_addr (cp) : INADDR_NONE;
2875 }
2876
2877 int
2878 sys_gethostname (char * name, int namelen)
2879 {
2880   if (winsock_lib != NULL)
2881     return pfn_gethostname (name, namelen);
2882
2883   if (namelen > MAX_COMPUTERNAME_LENGTH)
2884     return !GetComputerName (name, (DWORD *)&namelen);
2885
2886   h_errno = EFAULT;
2887   return SOCKET_ERROR;
2888 }
2889
2890 struct hostent *
2891 sys_gethostbyname(const char * name)
2892 {
2893   struct hostent * host;
2894
2895   if (winsock_lib == NULL)
2896     {
2897       h_errno = ENETDOWN;
2898       return NULL;
2899     }
2900
2901   check_errno ();
2902   host = pfn_gethostbyname (name);
2903   if (!host)
2904     set_errno ();
2905   return host;
2906 }
2907
2908 struct servent *
2909 sys_getservbyname(const char * name, const char * proto)
2910 {
2911   struct servent * serv;
2912
2913   if (winsock_lib == NULL)
2914     {
2915       h_errno = ENETDOWN;
2916       return NULL;
2917     }
2918
2919   check_errno ();
2920   serv = pfn_getservbyname (name, proto);
2921   if (!serv)
2922     set_errno ();
2923   return serv;
2924 }
2925
2926 int
2927 sys_getpeername (int s, struct sockaddr *addr, int * namelen)
2928 {
2929   if (winsock_lib == NULL)
2930     {
2931       h_errno = ENETDOWN;
2932       return SOCKET_ERROR;
2933     }
2934
2935   check_errno ();
2936   if (fd_info[s].flags & FILE_SOCKET)
2937     {
2938       int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
2939       if (rc == SOCKET_ERROR)
2940         set_errno ();
2941       return rc;
2942     }
2943   h_errno = ENOTSOCK;
2944   return SOCKET_ERROR;
2945 }
2946
2947
2948 int
2949 sys_shutdown (int s, int how)
2950 {
2951   if (winsock_lib == NULL)
2952     {
2953       h_errno = ENETDOWN;
2954       return SOCKET_ERROR;
2955     }
2956
2957   check_errno ();
2958   if (fd_info[s].flags & FILE_SOCKET)
2959     {
2960       int rc = pfn_shutdown (SOCK_HANDLE (s), how);
2961       if (rc == SOCKET_ERROR)
2962         set_errno ();
2963       return rc;
2964     }
2965   h_errno = ENOTSOCK;
2966   return SOCKET_ERROR;
2967 }
2968
2969 int
2970 sys_setsockopt (int s, int level, int optname, const char * optval, int optlen)
2971 {
2972   if (winsock_lib == NULL)
2973     {
2974       h_errno = ENETDOWN;
2975       return SOCKET_ERROR;
2976     }
2977
2978   check_errno ();
2979   if (fd_info[s].flags & FILE_SOCKET)
2980     {
2981       int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
2982                                optval, optlen);
2983       if (rc == SOCKET_ERROR)
2984         set_errno ();
2985       return rc;
2986     }
2987   h_errno = ENOTSOCK;
2988   return SOCKET_ERROR;
2989 }
2990
2991 int
2992 sys_listen (int s, int backlog)
2993 {
2994   if (winsock_lib == NULL)
2995     {
2996       h_errno = ENETDOWN;
2997       return SOCKET_ERROR;
2998     }
2999
3000   check_errno ();
3001   if (fd_info[s].flags & FILE_SOCKET)
3002     {
3003       int rc = pfn_listen (SOCK_HANDLE (s), backlog);
3004       if (rc == SOCKET_ERROR)
3005         set_errno ();
3006       return rc;
3007     }
3008   h_errno = ENOTSOCK;
3009   return SOCKET_ERROR;
3010 }
3011
3012 int
3013 sys_getsockname (int s, struct sockaddr * name, int * namelen)
3014 {
3015   if (winsock_lib == NULL)
3016     {
3017       h_errno = ENETDOWN;
3018       return SOCKET_ERROR;
3019     }
3020
3021   check_errno ();
3022   if (fd_info[s].flags & FILE_SOCKET)
3023     {
3024       int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
3025       if (rc == SOCKET_ERROR)
3026         set_errno ();
3027       return rc;
3028     }
3029   h_errno = ENOTSOCK;
3030   return SOCKET_ERROR;
3031 }
3032
3033 int
3034 sys_accept (int s, struct sockaddr * addr, int * addrlen)
3035 {
3036   if (winsock_lib == NULL)
3037     {
3038       h_errno = ENETDOWN;
3039       return -1;
3040     }
3041
3042   check_errno ();
3043   if (fd_info[s].flags & FILE_SOCKET)
3044     {
3045       SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
3046       if (t != INVALID_SOCKET)
3047         return socket_to_fd (t);
3048
3049       set_errno ();
3050       return -1;
3051     }
3052   h_errno = ENOTSOCK;
3053   return -1;
3054 }
3055
3056 int
3057 sys_recvfrom (int s, char * buf, int len, int flags,
3058           struct sockaddr * from, int * fromlen)
3059 {
3060   if (winsock_lib == NULL)
3061     {
3062       h_errno = ENETDOWN;
3063       return SOCKET_ERROR;
3064     }
3065
3066   check_errno ();
3067   if (fd_info[s].flags & FILE_SOCKET)
3068     {
3069       int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
3070       if (rc == SOCKET_ERROR)
3071         set_errno ();
3072       return rc;
3073     }
3074   h_errno = ENOTSOCK;
3075   return SOCKET_ERROR;
3076 }
3077
3078 int
3079 sys_sendto (int s, const char * buf, int len, int flags,
3080             const struct sockaddr * to, int tolen)
3081 {
3082   if (winsock_lib == NULL)
3083     {
3084       h_errno = ENETDOWN;
3085       return SOCKET_ERROR;
3086     }
3087
3088   check_errno ();
3089   if (fd_info[s].flags & FILE_SOCKET)
3090     {
3091       int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
3092       if (rc == SOCKET_ERROR)
3093         set_errno ();
3094       return rc;
3095     }
3096   h_errno = ENOTSOCK;
3097   return SOCKET_ERROR;
3098 }
3099
3100 /* Windows does not have an fcntl function.  Provide an implementation
3101    solely for making sockets non-blocking.  */
3102 int
3103 fcntl (int s, int cmd, int options)
3104 {
3105   if (winsock_lib == NULL)
3106     {
3107       h_errno = ENETDOWN;
3108       return -1;
3109     }
3110
3111   check_errno ();
3112   if (fd_info[s].flags & FILE_SOCKET)
3113     {
3114       if (cmd == F_SETFL && options == O_NDELAY)
3115         {
3116           unsigned long nblock = 1;
3117           int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
3118           if (rc == SOCKET_ERROR)
3119             set_errno();
3120           /* Keep track of the fact that we set this to non-blocking.  */
3121           fd_info[s].flags |= FILE_NDELAY;
3122           return rc;
3123         }
3124       else
3125         {
3126           h_errno = EINVAL;
3127           return SOCKET_ERROR;
3128         }
3129     }
3130   h_errno = ENOTSOCK;
3131   return SOCKET_ERROR;
3132 }
3133
3134 #endif /* HAVE_SOCKETS */
3135
3136
3137 /* Shadow main io functions: we need to handle pipes and sockets more
3138    intelligently, and implement non-blocking mode as well. */
3139
3140 int
3141 sys_close (int fd)
3142 {
3143   int rc;
3144
3145   if (fd < 0 || fd >= MAXDESC)
3146     {
3147       errno = EBADF;
3148       return -1;
3149     }
3150
3151   if (fd_info[fd].cp)
3152     {
3153       child_process * cp = fd_info[fd].cp;
3154
3155       fd_info[fd].cp = NULL;
3156
3157       if (CHILD_ACTIVE (cp))
3158         {
3159           /* if last descriptor to active child_process then cleanup */
3160           int i;
3161           for (i = 0; i < MAXDESC; i++)
3162             {
3163               if (i == fd)
3164                 continue;
3165               if (fd_info[i].cp == cp)
3166                 break;
3167             }
3168           if (i == MAXDESC)
3169             {
3170 #ifdef HAVE_SOCKETS
3171               if (fd_info[fd].flags & FILE_SOCKET)
3172                 {
3173 #ifndef SOCK_REPLACE_HANDLE
3174                   if (winsock_lib == NULL) abort ();
3175
3176                   pfn_shutdown (SOCK_HANDLE (fd), 2);
3177                   rc = pfn_closesocket (SOCK_HANDLE (fd));
3178 #endif
3179                   winsock_inuse--; /* count open sockets */
3180                 }
3181 #endif
3182               delete_child (cp);
3183             }
3184         }
3185     }
3186
3187   /* Note that sockets do not need special treatment here (at least on
3188      NT and Windows 95 using the standard tcp/ip stacks) - it appears that
3189      closesocket is equivalent to CloseHandle, which is to be expected
3190      because socket handles are fully fledged kernel handles. */
3191   rc = _close (fd);
3192
3193   if (rc == 0)
3194     fd_info[fd].flags = 0;
3195
3196   return rc;
3197 }
3198
3199 int
3200 sys_dup (int fd)
3201 {
3202   int new_fd;
3203
3204   new_fd = _dup (fd);
3205   if (new_fd >= 0)
3206     {
3207       /* duplicate our internal info as well */
3208       fd_info[new_fd] = fd_info[fd];
3209     }
3210   return new_fd;
3211 }
3212
3213
3214 int
3215 sys_dup2 (int src, int dst)
3216 {
3217   int rc;
3218
3219   if (dst < 0 || dst >= MAXDESC)
3220     {
3221       errno = EBADF;
3222       return -1;
3223     }
3224
3225   /* make sure we close the destination first if it's a pipe or socket */
3226   if (src != dst && fd_info[dst].flags != 0)
3227     sys_close (dst);
3228
3229   rc = _dup2 (src, dst);
3230   if (rc == 0)
3231     {
3232       /* duplicate our internal info as well */
3233       fd_info[dst] = fd_info[src];
3234     }
3235   return rc;
3236 }
3237
3238 /* Unix pipe() has only one arg */
3239 int
3240 sys_pipe (int * phandles)
3241 {
3242   int rc;
3243   unsigned flags;
3244
3245   /* make pipe handles non-inheritable; when we spawn a child, we
3246      replace the relevant handle with an inheritable one.  Also put
3247      pipes into binary mode; we will do text mode translation ourselves
3248      if required.  */
3249   rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
3250
3251   if (rc == 0)
3252     {
3253       flags = FILE_PIPE | FILE_READ | FILE_BINARY;
3254       fd_info[phandles[0]].flags = flags;
3255
3256       flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
3257       fd_info[phandles[1]].flags = flags;
3258     }
3259
3260   return rc;
3261 }
3262
3263 /* From ntproc.c */
3264 extern Lisp_Object Vw32_pipe_read_delay;
3265
3266 /* Function to do blocking read of one byte, needed to implement
3267    select.  It is only allowed on sockets and pipes. */
3268 int
3269 _sys_read_ahead (int fd)
3270 {
3271   child_process * cp;
3272   int rc;
3273
3274   if (fd < 0 || fd >= MAXDESC)
3275     return STATUS_READ_ERROR;
3276
3277   cp = fd_info[fd].cp;
3278
3279   if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
3280     return STATUS_READ_ERROR;
3281
3282   if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
3283       || (fd_info[fd].flags & FILE_READ) == 0)
3284     {
3285       DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe or socket!\n", fd));
3286       abort ();
3287     }
3288
3289   cp->status = STATUS_READ_IN_PROGRESS;
3290
3291   if (fd_info[fd].flags & FILE_PIPE)
3292     {
3293       rc = _read (fd, &cp->chr, sizeof (char));
3294
3295       /* Give subprocess time to buffer some more output for us before
3296          reporting that input is available; we need this because Windows 95
3297          connects DOS programs to pipes by making the pipe appear to be
3298          the normal console stdout - as a result most DOS programs will
3299          write to stdout without buffering, ie.  one character at a
3300          time.  Even some W32 programs do this - "dir" in a command
3301          shell on NT is very slow if we don't do this. */
3302       if (rc > 0)
3303         {
3304           int wait = XINT (Vw32_pipe_read_delay);
3305
3306           if (wait > 0)
3307             Sleep (wait);
3308           else if (wait < 0)
3309             while (++wait <= 0)
3310               /* Yield remainder of our time slice, effectively giving a
3311                  temporary priority boost to the child process. */
3312               Sleep (0);
3313         }
3314     }
3315 #ifdef HAVE_SOCKETS
3316   else if (fd_info[fd].flags & FILE_SOCKET)
3317     {
3318       unsigned long nblock = 0;
3319       /* We always want this to block, so temporarily disable NDELAY.  */
3320       if (fd_info[fd].flags & FILE_NDELAY)
3321         pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3322
3323       rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
3324
3325       if (fd_info[fd].flags & FILE_NDELAY)
3326         {
3327           nblock = 1;
3328           pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
3329         }
3330     }
3331 #endif
3332
3333   if (rc == sizeof (char))
3334     cp->status = STATUS_READ_SUCCEEDED;
3335   else
3336     cp->status = STATUS_READ_FAILED;
3337
3338   return cp->status;
3339 }
3340
3341 int
3342 sys_read (int fd, char * buffer, unsigned int count)
3343 {
3344   int nchars;
3345   int to_read;
3346   DWORD waiting;
3347   char * orig_buffer = buffer;
3348
3349   if (fd < 0 || fd >= MAXDESC)
3350     {
3351       errno = EBADF;
3352       return -1;
3353     }
3354
3355   if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3356     {
3357       child_process *cp = fd_info[fd].cp;
3358
3359       if ((fd_info[fd].flags & FILE_READ) == 0)
3360         {
3361           errno = EBADF;
3362           return -1;
3363         }
3364
3365       nchars = 0;
3366
3367       /* re-read CR carried over from last read */
3368       if (fd_info[fd].flags & FILE_LAST_CR)
3369         {
3370           if (fd_info[fd].flags & FILE_BINARY) abort ();
3371           *buffer++ = 0x0d;
3372           count--;
3373           nchars++;
3374           fd_info[fd].flags &= ~FILE_LAST_CR;
3375         }
3376
3377       /* presence of a child_process structure means we are operating in
3378          non-blocking mode - otherwise we just call _read directly.
3379          Note that the child_process structure might be missing because
3380          reap_subprocess has been called; in this case the pipe is
3381          already broken, so calling _read on it is okay. */
3382       if (cp)
3383         {
3384           int current_status = cp->status;
3385
3386           switch (current_status)
3387             {
3388             case STATUS_READ_FAILED:
3389             case STATUS_READ_ERROR:
3390               /* report normal EOF if nothing in buffer */
3391               if (nchars <= 0)
3392                 fd_info[fd].flags |= FILE_AT_EOF;
3393               return nchars;
3394
3395             case STATUS_READ_READY:
3396             case STATUS_READ_IN_PROGRESS:
3397               DebPrint (("sys_read called when read is in progress\n"));
3398               errno = EWOULDBLOCK;
3399               return -1;
3400
3401             case STATUS_READ_SUCCEEDED:
3402               /* consume read-ahead char */
3403               *buffer++ = cp->chr;
3404               count--;
3405               nchars++;
3406               cp->status = STATUS_READ_ACKNOWLEDGED;
3407               ResetEvent (cp->char_avail);
3408
3409             case STATUS_READ_ACKNOWLEDGED:
3410               break;
3411
3412             default:
3413               DebPrint (("sys_read: bad status %d\n", current_status));
3414               errno = EBADF;
3415               return -1;
3416             }
3417
3418           if (fd_info[fd].flags & FILE_PIPE)
3419             {
3420               PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
3421               to_read = min (waiting, (DWORD) count);
3422
3423               if (to_read > 0)
3424                 nchars += _read (fd, buffer, to_read);
3425             }
3426 #ifdef HAVE_SOCKETS
3427           else /* FILE_SOCKET */
3428             {
3429               if (winsock_lib == NULL) abort ();
3430
3431               /* do the equivalent of a non-blocking read */
3432               pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
3433               if (waiting == 0 && nchars == 0)
3434                 {
3435                   h_errno = errno = EWOULDBLOCK;
3436                   return -1;
3437                 }
3438
3439               if (waiting)
3440                 {
3441                   /* always use binary mode for sockets */
3442                   int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
3443                   if (res == SOCKET_ERROR)
3444                     {
3445                       DebPrint(("sys_read.recv failed with error %d on socket %ld\n",
3446                                 pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3447                       set_errno ();
3448                       return -1;
3449                     }
3450                   nchars += res;
3451                 }
3452             }
3453 #endif
3454         }
3455       else
3456         {
3457           int nread = _read (fd, buffer, count);
3458           if (nread >= 0)
3459             nchars += nread;
3460           else if (nchars == 0)
3461             nchars = nread;
3462         }
3463
3464       if (nchars <= 0)
3465         fd_info[fd].flags |= FILE_AT_EOF;
3466       /* Perform text mode translation if required.  */
3467       else if ((fd_info[fd].flags & FILE_BINARY) == 0)
3468         {
3469           nchars = crlf_to_lf (nchars, orig_buffer);
3470           /* If buffer contains only CR, return that.  To be absolutely
3471              sure we should attempt to read the next char, but in
3472              practice a CR to be followed by LF would not appear by
3473              itself in the buffer.  */
3474           if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
3475             {
3476               fd_info[fd].flags |= FILE_LAST_CR;
3477               nchars--;
3478             }
3479         }
3480     }
3481   else
3482     nchars = _read (fd, buffer, count);
3483
3484   return nchars;
3485 }
3486
3487 /* For now, don't bother with a non-blocking mode */
3488 int
3489 sys_write (int fd, const void * buffer, unsigned int count)
3490 {
3491   int nchars;
3492
3493   if (fd < 0 || fd >= MAXDESC)
3494     {
3495       errno = EBADF;
3496       return -1;
3497     }
3498
3499   if (fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET))
3500     {
3501       if ((fd_info[fd].flags & FILE_WRITE) == 0)
3502         {
3503           errno = EBADF;
3504           return -1;
3505         }
3506
3507       /* Perform text mode translation if required.  */
3508       if ((fd_info[fd].flags & FILE_BINARY) == 0)
3509         {
3510           char * tmpbuf = alloca (count * 2);
3511           unsigned char * src = (void *)buffer;
3512           unsigned char * dst = tmpbuf;
3513           int nbytes = count;
3514
3515           while (1)
3516             {
3517               unsigned char *next;
3518               /* copy next line or remaining bytes */
3519               next = _memccpy (dst, src, '\n', nbytes);
3520               if (next)
3521                 {
3522                   /* copied one line ending with '\n' */
3523                   int copied = next - dst;
3524                   nbytes -= copied;
3525                   src += copied;
3526                   /* insert '\r' before '\n' */
3527                   next[-1] = '\r';
3528                   next[0] = '\n';
3529                   dst = next + 1;
3530                   count++;
3531                 }
3532               else
3533                 /* copied remaining partial line -> now finished */
3534                 break;
3535             }
3536           buffer = tmpbuf;
3537         }
3538     }
3539
3540 #ifdef HAVE_SOCKETS
3541   if (fd_info[fd].flags & FILE_SOCKET)
3542     {
3543       if (winsock_lib == NULL) abort ();
3544       nchars =  pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
3545       if (nchars == SOCKET_ERROR)
3546         {
3547           DebPrint(("sys_read.send failed with error %d on socket %ld\n",
3548                     pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
3549           set_errno ();
3550         }
3551     }
3552   else
3553 #endif
3554     nchars = _write (fd, buffer, count);
3555
3556   return nchars;
3557 }
3558
3559 static void
3560 check_windows_init_file ()
3561 {
3562   extern int noninteractive, inhibit_window_system;
3563
3564   /* A common indication that Emacs is not installed properly is when
3565      it cannot find the Windows installation file.  If this file does
3566      not exist in the expected place, tell the user.  */
3567
3568   if (!noninteractive && !inhibit_window_system)
3569     {
3570       extern Lisp_Object Vwindow_system, Vload_path, Qfile_exists_p;
3571       Lisp_Object objs[2];
3572       Lisp_Object full_load_path;
3573       Lisp_Object init_file;
3574       int fd;
3575
3576       objs[0] = Vload_path;
3577       objs[1] = decode_env_path (0, (getenv ("EMACSLOADPATH")));
3578       full_load_path = Fappend (2, objs);
3579       init_file = build_string ("term/w32-win");
3580       fd = openp (full_load_path, init_file, Vload_suffixes, NULL, Qnil);
3581       if (fd < 0)
3582         {
3583           Lisp_Object load_path_print = Fprin1_to_string (full_load_path, Qnil);
3584           char *init_file_name = SDATA (init_file);
3585           char *load_path = SDATA (load_path_print);
3586           char *buffer = alloca (1024);
3587
3588           sprintf (buffer,
3589                    "The Emacs Windows initialization file \"%s.el\" "
3590                    "could not be found in your Emacs installation.  "
3591                    "Emacs checked the following directories for this file:\n"
3592                    "\n%s\n\n"
3593                    "When Emacs cannot find this file, it usually means that it "
3594                    "was not installed properly, or its distribution file was "
3595                    "not unpacked properly.\nSee the README.W32 file in the "
3596                    "top-level Emacs directory for more information.",
3597                    init_file_name, load_path);
3598           MessageBox (NULL,
3599                       buffer,
3600                       "Emacs Abort Dialog",
3601                       MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
3602       /* Use the low-level Emacs abort. */
3603 #undef abort
3604           abort ();
3605         }
3606       else
3607         {
3608           _close (fd);
3609         }
3610     }
3611 }
3612
3613 void
3614 term_ntproc ()
3615 {
3616 #ifdef HAVE_SOCKETS
3617   /* shutdown the socket interface if necessary */
3618   term_winsock ();
3619 #endif
3620 }
3621
3622 void
3623 init_ntproc ()
3624 {
3625 #ifdef HAVE_SOCKETS
3626   /* Initialise the socket interface now if available and requested by
3627      the user by defining PRELOAD_WINSOCK; otherwise loading will be
3628      delayed until open-network-stream is called (w32-has-winsock can
3629      also be used to dynamically load or reload winsock).
3630
3631      Conveniently, init_environment is called before us, so
3632      PRELOAD_WINSOCK can be set in the registry. */
3633
3634   /* Always initialize this correctly. */
3635   winsock_lib = NULL;
3636
3637   if (getenv ("PRELOAD_WINSOCK") != NULL)
3638     init_winsock (TRUE);
3639 #endif
3640
3641   /* Initial preparation for subprocess support: replace our standard
3642      handles with non-inheritable versions. */
3643   {
3644     HANDLE parent;
3645     HANDLE stdin_save =  INVALID_HANDLE_VALUE;
3646     HANDLE stdout_save = INVALID_HANDLE_VALUE;
3647     HANDLE stderr_save = INVALID_HANDLE_VALUE;
3648
3649     parent = GetCurrentProcess ();
3650
3651     /* ignore errors when duplicating and closing; typically the
3652        handles will be invalid when running as a gui program. */
3653     DuplicateHandle (parent,
3654                      GetStdHandle (STD_INPUT_HANDLE),
3655                      parent,
3656                      &stdin_save,
3657                      0,
3658                      FALSE,
3659                      DUPLICATE_SAME_ACCESS);
3660
3661     DuplicateHandle (parent,
3662                      GetStdHandle (STD_OUTPUT_HANDLE),
3663                      parent,
3664                      &stdout_save,
3665                      0,
3666                      FALSE,
3667                      DUPLICATE_SAME_ACCESS);
3668
3669     DuplicateHandle (parent,
3670                      GetStdHandle (STD_ERROR_HANDLE),
3671                      parent,
3672                      &stderr_save,
3673                      0,
3674                      FALSE,
3675                      DUPLICATE_SAME_ACCESS);
3676
3677     fclose (stdin);
3678     fclose (stdout);
3679     fclose (stderr);
3680
3681     if (stdin_save != INVALID_HANDLE_VALUE)
3682       _open_osfhandle ((long) stdin_save, O_TEXT);
3683     else
3684       _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
3685     _fdopen (0, "r");
3686
3687     if (stdout_save != INVALID_HANDLE_VALUE)
3688       _open_osfhandle ((long) stdout_save, O_TEXT);
3689     else
3690       _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
3691     _fdopen (1, "w");
3692
3693     if (stderr_save != INVALID_HANDLE_VALUE)
3694       _open_osfhandle ((long) stderr_save, O_TEXT);
3695     else
3696       _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
3697     _fdopen (2, "w");
3698   }
3699
3700   /* unfortunately, atexit depends on implementation of malloc */
3701   /* atexit (term_ntproc); */
3702   signal (SIGABRT, term_ntproc);
3703
3704   /* determine which drives are fixed, for GetCachedVolumeInformation */
3705   {
3706     /* GetDriveType must have trailing backslash. */
3707     char drive[] = "A:\\";
3708
3709     /* Loop over all possible drive letters */
3710     while (*drive <= 'Z')
3711     {
3712       /* Record if this drive letter refers to a fixed drive. */
3713       fixed_drives[DRIVE_INDEX (*drive)] =
3714         (GetDriveType (drive) == DRIVE_FIXED);
3715
3716       (*drive)++;
3717     }
3718
3719     /* Reset the volume info cache.  */
3720     volume_cache = NULL;
3721   }
3722
3723   /* Check to see if Emacs has been installed correctly.  */
3724   check_windows_init_file ();
3725 }
3726
3727 /* end of nt.c */