src/w32.c

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