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