src/w32.c

   1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
   2    Copyright (C) 1994-1995, 2000-2013 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, either version 3 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /*
  20    Geoff Voelker (voelker@cs.washington.edu)                         7-29-94
  21 */
  22 #include <stddef.h> /* for offsetof */
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <float.h>      /* for DBL_EPSILON */
  26 #include <io.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <ctype.h>
  30 #include <signal.h>
  31 #include <sys/file.h>
  32 #include <sys/time.h>
  33 #include <sys/utime.h>
  34 #include <math.h>
  35 #include <time.h>
  36
  37 /* must include CRT headers *before* config.h */
  38
  39 #include <config.h>
  40 #include <mbstring.h>   /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
  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 #undef localtime
  66
  67 #include "lisp.h"
  68
  69 #include <pwd.h>
  70 #include <grp.h>
  71
  72 #ifdef __GNUC__
  73 #define _ANONYMOUS_UNION
  74 #define _ANONYMOUS_STRUCT
  75 #endif
  76 #include <windows.h>
  77 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
  78    use a different name to avoid compilation problems.  */
  79 typedef struct _MEMORY_STATUS_EX {
  80   DWORD dwLength;
  81   DWORD dwMemoryLoad;
  82   DWORDLONG ullTotalPhys;
  83   DWORDLONG ullAvailPhys;
  84   DWORDLONG ullTotalPageFile;
  85   DWORDLONG ullAvailPageFile;
  86   DWORDLONG ullTotalVirtual;
  87   DWORDLONG ullAvailVirtual;
  88   DWORDLONG ullAvailExtendedVirtual;
  89 } MEMORY_STATUS_EX,*LPMEMORY_STATUS_EX;
  90
  91 #include <lmcons.h>
  92 #include <shlobj.h>
  93
  94 #include <tlhelp32.h>
  95 #include <psapi.h>
  96 #ifndef _MSC_VER
  97 #include <w32api.h>
  98 #endif
  99 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
 100 /* This either is not in psapi.h or guarded by higher value of
 101    _WIN32_WINNT than what we use.  w32api supplied with MinGW 3.15
 102    defines it in psapi.h  */
 103 typedef struct _PROCESS_MEMORY_COUNTERS_EX {
 104   DWORD  cb;
 105   DWORD  PageFaultCount;
 106   SIZE_T PeakWorkingSetSize;
 107   SIZE_T WorkingSetSize;
 108   SIZE_T QuotaPeakPagedPoolUsage;
 109   SIZE_T QuotaPagedPoolUsage;
 110   SIZE_T QuotaPeakNonPagedPoolUsage;
 111   SIZE_T QuotaNonPagedPoolUsage;
 112   SIZE_T PagefileUsage;
 113   SIZE_T PeakPagefileUsage;
 114   SIZE_T PrivateUsage;
 115 } PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
 116 #endif
 117
 118 #include <winioctl.h>
 119 #include <aclapi.h>
 120 #include <sddl.h>
 121
 122 #include <sys/acl.h>
 123
 124 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
 125    define them by hand if not already defined.  */
 126 #ifndef SDDL_REVISION_1
 127 #define SDDL_REVISION_1 1
 128 #endif  /* SDDL_REVISION_1 */
 129
 130 #ifdef _MSC_VER
 131 /* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER and the
 132    associated macros, except on ntifs.h, which cannot be included
 133    because it triggers conflicts with other Windows API headers.  So
 134    we define it here by hand.  */
 135
 136 typedef struct _REPARSE_DATA_BUFFER {
 137     ULONG  ReparseTag;
 138     USHORT ReparseDataLength;
 139     USHORT Reserved;
 140     union {
 141         struct {
 142             USHORT SubstituteNameOffset;
 143             USHORT SubstituteNameLength;
 144             USHORT PrintNameOffset;
 145             USHORT PrintNameLength;
 146             ULONG Flags;
 147             WCHAR PathBuffer[1];
 148         } SymbolicLinkReparseBuffer;
 149         struct {
 150             USHORT SubstituteNameOffset;
 151             USHORT SubstituteNameLength;
 152             USHORT PrintNameOffset;
 153             USHORT PrintNameLength;
 154             WCHAR PathBuffer[1];
 155         } MountPointReparseBuffer;
 156         struct {
 157             UCHAR  DataBuffer[1];
 158         } GenericReparseBuffer;
 159     } DUMMYUNIONNAME;
 160 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
 161
 162 #ifndef FILE_DEVICE_FILE_SYSTEM
 163 #define FILE_DEVICE_FILE_SYSTEM 9
 164 #endif
 165 #ifndef METHOD_BUFFERED
 166 #define METHOD_BUFFERED         0
 167 #endif
 168 #ifndef FILE_ANY_ACCESS
 169 #define FILE_ANY_ACCESS         0x00000000
 170 #endif
 171 #ifndef CTL_CODE
 172 #define CTL_CODE(t,f,m,a)       (((t)<<16)|((a)<<14)|((f)<<2)|(m))
 173 #endif
 174 #define FSCTL_GET_REPARSE_POINT \
 175   CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
 176 #endif
 177
 178 /* TCP connection support.  */
 179 #include <sys/socket.h>
 180 #undef socket
 181 #undef bind
 182 #undef connect
 183 #undef htons
 184 #undef ntohs
 185 #undef inet_addr
 186 #undef gethostname
 187 #undef gethostbyname
 188 #undef getservbyname
 189 #undef getpeername
 190 #undef shutdown
 191 #undef setsockopt
 192 #undef listen
 193 #undef getsockname
 194 #undef accept
 195 #undef recvfrom
 196 #undef sendto
 197
 198 #include "w32.h"
 199 #include <dirent.h>
 200 #include "w32common.h"
 201 #include "w32heap.h"
 202 #include "w32select.h"
 203 #include "systime.h"
 204 #include "dispextern.h"         /* for xstrcasecmp */
 205 #include "coding.h"             /* for Vlocale_coding_system */
 206
 207 #include "careadlinkat.h"
 208 #include "allocator.h"
 209
 210 /* For serial_configure and serial_open.  */
 211 #include "process.h"
 212
 213 typedef HRESULT (WINAPI * ShGetFolderPath_fn)
 214   (IN HWND, IN int, IN HANDLE, IN DWORD, OUT char *);
 215
 216 Lisp_Object QCloaded_from;
 217
 218 void globals_of_w32 (void);
 219 static DWORD get_rid (PSID);
 220 static int is_symlink (const char *);
 221 static char * chase_symlinks (const char *);
 222 static int enable_privilege (LPCTSTR, BOOL, TOKEN_PRIVILEGES *);
 223 static int restore_privilege (TOKEN_PRIVILEGES *);
 224 static BOOL WINAPI revert_to_self (void);
 225
 226 extern int sys_access (const char *, int);
 227 extern void *e_malloc (size_t);
 228 extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
 229                        EMACS_TIME *, void *);
 230
 231
 232 \f
 233 /* Initialization states.
 234
 235    WARNING: If you add any more such variables for additional APIs,
 236             you MUST add initialization for them to globals_of_w32
 237             below.  This is because these variables might get set
 238             to non-NULL values during dumping, but the dumped Emacs
 239             cannot reuse those values, because it could be run on a
 240             different version of the OS, where API addresses are
 241             different.  */
 242 static BOOL g_b_init_is_windows_9x;
 243 static BOOL g_b_init_open_process_token;
 244 static BOOL g_b_init_get_token_information;
 245 static BOOL g_b_init_lookup_account_sid;
 246 static BOOL g_b_init_get_sid_sub_authority;
 247 static BOOL g_b_init_get_sid_sub_authority_count;
 248 static BOOL g_b_init_get_security_info;
 249 static BOOL g_b_init_get_file_security;
 250 static BOOL g_b_init_get_security_descriptor_owner;
 251 static BOOL g_b_init_get_security_descriptor_group;
 252 static BOOL g_b_init_is_valid_sid;
 253 static BOOL g_b_init_create_toolhelp32_snapshot;
 254 static BOOL g_b_init_process32_first;
 255 static BOOL g_b_init_process32_next;
 256 static BOOL g_b_init_open_thread_token;
 257 static BOOL g_b_init_impersonate_self;
 258 static BOOL g_b_init_revert_to_self;
 259 static BOOL g_b_init_get_process_memory_info;
 260 static BOOL g_b_init_get_process_working_set_size;
 261 static BOOL g_b_init_global_memory_status;
 262 static BOOL g_b_init_global_memory_status_ex;
 263 static BOOL g_b_init_get_length_sid;
 264 static BOOL g_b_init_equal_sid;
 265 static BOOL g_b_init_copy_sid;
 266 static BOOL g_b_init_get_native_system_info;
 267 static BOOL g_b_init_get_system_times;
 268 static BOOL g_b_init_create_symbolic_link;
 269 static BOOL g_b_init_get_security_descriptor_dacl;
 270 static BOOL g_b_init_convert_sd_to_sddl;
 271 static BOOL g_b_init_convert_sddl_to_sd;
 272 static BOOL g_b_init_is_valid_security_descriptor;
 273 static BOOL g_b_init_set_file_security;
 274
 275 /*
 276   BEGIN: Wrapper functions around OpenProcessToken
 277   and other functions in advapi32.dll that are only
 278   supported in Windows NT / 2k / XP
 279 */
 280   /* ** Function pointer typedefs ** */
 281 typedef BOOL (WINAPI * OpenProcessToken_Proc) (
 282     HANDLE ProcessHandle,
 283     DWORD DesiredAccess,
 284     PHANDLE TokenHandle);
 285 typedef BOOL (WINAPI * GetTokenInformation_Proc) (
 286     HANDLE TokenHandle,
 287     TOKEN_INFORMATION_CLASS TokenInformationClass,
 288     LPVOID TokenInformation,
 289     DWORD TokenInformationLength,
 290     PDWORD ReturnLength);
 291 typedef BOOL (WINAPI * GetProcessTimes_Proc) (
 292     HANDLE process_handle,
 293     LPFILETIME creation_time,
 294     LPFILETIME exit_time,
 295     LPFILETIME kernel_time,
 296     LPFILETIME user_time);
 297
 298 GetProcessTimes_Proc get_process_times_fn = NULL;
 299
 300 #ifdef _UNICODE
 301 const char * const LookupAccountSid_Name = "LookupAccountSidW";
 302 const char * const GetFileSecurity_Name =  "GetFileSecurityW";
 303 const char * const SetFileSecurity_Name =  "SetFileSecurityW";
 304 #else
 305 const char * const LookupAccountSid_Name = "LookupAccountSidA";
 306 const char * const GetFileSecurity_Name =  "GetFileSecurityA";
 307 const char * const SetFileSecurity_Name =  "SetFileSecurityA";
 308 #endif
 309 typedef BOOL (WINAPI * LookupAccountSid_Proc) (
 310     LPCTSTR lpSystemName,
 311     PSID Sid,
 312     LPTSTR Name,
 313     LPDWORD cbName,
 314     LPTSTR DomainName,
 315     LPDWORD cbDomainName,
 316     PSID_NAME_USE peUse);
 317 typedef PDWORD (WINAPI * GetSidSubAuthority_Proc) (
 318     PSID pSid,
 319     DWORD n);
 320 typedef PUCHAR (WINAPI * GetSidSubAuthorityCount_Proc) (
 321     PSID pSid);
 322 typedef DWORD (WINAPI * GetSecurityInfo_Proc) (
 323     HANDLE handle,
 324     SE_OBJECT_TYPE ObjectType,
 325     SECURITY_INFORMATION SecurityInfo,
 326     PSID *ppsidOwner,
 327     PSID *ppsidGroup,
 328     PACL *ppDacl,
 329     PACL *ppSacl,
 330     PSECURITY_DESCRIPTOR *ppSecurityDescriptor);
 331 typedef BOOL (WINAPI * GetFileSecurity_Proc) (
 332     LPCTSTR lpFileName,
 333     SECURITY_INFORMATION RequestedInformation,
 334     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 335     DWORD nLength,
 336     LPDWORD lpnLengthNeeded);
 337 typedef BOOL (WINAPI *SetFileSecurity_Proc) (
 338     LPCTSTR lpFileName,
 339     SECURITY_INFORMATION SecurityInformation,
 340     PSECURITY_DESCRIPTOR pSecurityDescriptor);
 341 typedef BOOL (WINAPI * GetSecurityDescriptorOwner_Proc) (
 342     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 343     PSID *pOwner,
 344     LPBOOL lpbOwnerDefaulted);
 345 typedef BOOL (WINAPI * GetSecurityDescriptorGroup_Proc) (
 346     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 347     PSID *pGroup,
 348     LPBOOL lpbGroupDefaulted);
 349 typedef BOOL (WINAPI *GetSecurityDescriptorDacl_Proc) (
 350     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 351     LPBOOL lpbDaclPresent,
 352     PACL *pDacl,
 353     LPBOOL lpbDaclDefaulted);
 354 typedef BOOL (WINAPI * IsValidSid_Proc) (
 355     PSID sid);
 356 typedef HANDLE (WINAPI * CreateToolhelp32Snapshot_Proc) (
 357     DWORD dwFlags,
 358     DWORD th32ProcessID);
 359 typedef BOOL (WINAPI * Process32First_Proc) (
 360     HANDLE hSnapshot,
 361     LPPROCESSENTRY32 lppe);
 362 typedef BOOL (WINAPI * Process32Next_Proc) (
 363     HANDLE hSnapshot,
 364     LPPROCESSENTRY32 lppe);
 365 typedef BOOL (WINAPI * OpenThreadToken_Proc) (
 366     HANDLE ThreadHandle,
 367     DWORD DesiredAccess,
 368     BOOL OpenAsSelf,
 369     PHANDLE TokenHandle);
 370 typedef BOOL (WINAPI * ImpersonateSelf_Proc) (
 371     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
 372 typedef BOOL (WINAPI * RevertToSelf_Proc) (void);
 373 typedef BOOL (WINAPI * GetProcessMemoryInfo_Proc) (
 374     HANDLE Process,
 375     PPROCESS_MEMORY_COUNTERS ppsmemCounters,
 376     DWORD cb);
 377 typedef BOOL (WINAPI * GetProcessWorkingSetSize_Proc) (
 378     HANDLE hProcess,
 379     PSIZE_T lpMinimumWorkingSetSize,
 380     PSIZE_T lpMaximumWorkingSetSize);
 381 typedef BOOL (WINAPI * GlobalMemoryStatus_Proc) (
 382     LPMEMORYSTATUS lpBuffer);
 383 typedef BOOL (WINAPI * GlobalMemoryStatusEx_Proc) (
 384     LPMEMORY_STATUS_EX lpBuffer);
 385 typedef BOOL (WINAPI * CopySid_Proc) (
 386     DWORD nDestinationSidLength,
 387     PSID pDestinationSid,
 388     PSID pSourceSid);
 389 typedef BOOL (WINAPI * EqualSid_Proc) (
 390     PSID pSid1,
 391     PSID pSid2);
 392 typedef DWORD (WINAPI * GetLengthSid_Proc) (
 393     PSID pSid);
 394 typedef void (WINAPI * GetNativeSystemInfo_Proc) (
 395     LPSYSTEM_INFO lpSystemInfo);
 396 typedef BOOL (WINAPI * GetSystemTimes_Proc) (
 397     LPFILETIME lpIdleTime,
 398     LPFILETIME lpKernelTime,
 399     LPFILETIME lpUserTime);
 400 typedef BOOLEAN (WINAPI *CreateSymbolicLink_Proc) (
 401     LPTSTR lpSymlinkFileName,
 402     LPTSTR lpTargetFileName,
 403     DWORD  dwFlags);
 404 typedef BOOL (WINAPI *ConvertStringSecurityDescriptorToSecurityDescriptor_Proc) (
 405     LPCTSTR StringSecurityDescriptor,
 406     DWORD StringSDRevision,
 407     PSECURITY_DESCRIPTOR  *SecurityDescriptor,
 408     PULONG  SecurityDescriptorSize);
 409 typedef BOOL (WINAPI *ConvertSecurityDescriptorToStringSecurityDescriptor_Proc) (
 410     PSECURITY_DESCRIPTOR  SecurityDescriptor,
 411     DWORD RequestedStringSDRevision,
 412     SECURITY_INFORMATION SecurityInformation,
 413     LPTSTR  *StringSecurityDescriptor,
 414     PULONG StringSecurityDescriptorLen);
 415 typedef BOOL (WINAPI *IsValidSecurityDescriptor_Proc) (PSECURITY_DESCRIPTOR);
 416
 417   /* ** A utility function ** */
 418 static BOOL
 419 is_windows_9x (void)
 420 {
 421   static BOOL s_b_ret = 0;
 422   OSVERSIONINFO os_ver;
 423   if (g_b_init_is_windows_9x == 0)
 424     {
 425       g_b_init_is_windows_9x = 1;
 426       ZeroMemory (&os_ver, sizeof (OSVERSIONINFO));
 427       os_ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
 428       if (GetVersionEx (&os_ver))
 429         {
 430           s_b_ret = (os_ver.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS);
 431         }
 432     }
 433   return s_b_ret;
 434 }
 435
 436 static Lisp_Object ltime (ULONGLONG);
 437
 438 /* Get total user and system times for get-internal-run-time.
 439    Returns a list of integers if the times are provided by the OS
 440    (NT derivatives), otherwise it returns the result of current-time. */
 441 Lisp_Object
 442 w32_get_internal_run_time (void)
 443 {
 444   if (get_process_times_fn)
 445     {
 446       FILETIME create, exit, kernel, user;
 447       HANDLE proc = GetCurrentProcess ();
 448       if ((*get_process_times_fn) (proc, &create, &exit, &kernel, &user))
 449         {
 450           LARGE_INTEGER user_int, kernel_int, total;
 451           user_int.LowPart = user.dwLowDateTime;
 452           user_int.HighPart = user.dwHighDateTime;
 453           kernel_int.LowPart = kernel.dwLowDateTime;
 454           kernel_int.HighPart = kernel.dwHighDateTime;
 455           total.QuadPart = user_int.QuadPart + kernel_int.QuadPart;
 456           return ltime (total.QuadPart);
 457         }
 458     }
 459
 460   return Fcurrent_time ();
 461 }
 462
 463   /* ** The wrapper functions ** */
 464
 465 static BOOL WINAPI
 466 open_process_token (HANDLE ProcessHandle,
 467                     DWORD DesiredAccess,
 468                     PHANDLE TokenHandle)
 469 {
 470   static OpenProcessToken_Proc s_pfn_Open_Process_Token = NULL;
 471   HMODULE hm_advapi32 = NULL;
 472   if (is_windows_9x () == TRUE)
 473     {
 474       return FALSE;
 475     }
 476   if (g_b_init_open_process_token == 0)
 477     {
 478       g_b_init_open_process_token = 1;
 479       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 480       s_pfn_Open_Process_Token =
 481         (OpenProcessToken_Proc) GetProcAddress (hm_advapi32, "OpenProcessToken");
 482     }
 483   if (s_pfn_Open_Process_Token == NULL)
 484     {
 485       return FALSE;
 486     }
 487   return (
 488       s_pfn_Open_Process_Token (
 489           ProcessHandle,
 490           DesiredAccess,
 491           TokenHandle)
 492       );
 493 }
 494
 495 static BOOL WINAPI
 496 get_token_information (HANDLE TokenHandle,
 497                        TOKEN_INFORMATION_CLASS TokenInformationClass,
 498                        LPVOID TokenInformation,
 499                        DWORD TokenInformationLength,
 500                        PDWORD ReturnLength)
 501 {
 502   static GetTokenInformation_Proc s_pfn_Get_Token_Information = NULL;
 503   HMODULE hm_advapi32 = NULL;
 504   if (is_windows_9x () == TRUE)
 505     {
 506       return FALSE;
 507     }
 508   if (g_b_init_get_token_information == 0)
 509     {
 510       g_b_init_get_token_information = 1;
 511       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 512       s_pfn_Get_Token_Information =
 513         (GetTokenInformation_Proc) GetProcAddress (hm_advapi32, "GetTokenInformation");
 514     }
 515   if (s_pfn_Get_Token_Information == NULL)
 516     {
 517       return FALSE;
 518     }
 519   return (
 520       s_pfn_Get_Token_Information (
 521           TokenHandle,
 522           TokenInformationClass,
 523           TokenInformation,
 524           TokenInformationLength,
 525           ReturnLength)
 526       );
 527 }
 528
 529 static BOOL WINAPI
 530 lookup_account_sid (LPCTSTR lpSystemName,
 531                     PSID Sid,
 532                     LPTSTR Name,
 533                     LPDWORD cbName,
 534                     LPTSTR DomainName,
 535                     LPDWORD cbDomainName,
 536                     PSID_NAME_USE peUse)
 537 {
 538   static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid = NULL;
 539   HMODULE hm_advapi32 = NULL;
 540   if (is_windows_9x () == TRUE)
 541     {
 542       return FALSE;
 543     }
 544   if (g_b_init_lookup_account_sid == 0)
 545     {
 546       g_b_init_lookup_account_sid = 1;
 547       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 548       s_pfn_Lookup_Account_Sid =
 549         (LookupAccountSid_Proc) GetProcAddress (hm_advapi32, LookupAccountSid_Name);
 550     }
 551   if (s_pfn_Lookup_Account_Sid == NULL)
 552     {
 553       return FALSE;
 554     }
 555   return (
 556       s_pfn_Lookup_Account_Sid (
 557           lpSystemName,
 558           Sid,
 559           Name,
 560           cbName,
 561           DomainName,
 562           cbDomainName,
 563           peUse)
 564       );
 565 }
 566
 567 static PDWORD WINAPI
 568 get_sid_sub_authority (PSID pSid, DWORD n)
 569 {
 570   static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority = NULL;
 571   static DWORD zero = 0U;
 572   HMODULE hm_advapi32 = NULL;
 573   if (is_windows_9x () == TRUE)
 574     {
 575       return &zero;
 576     }
 577   if (g_b_init_get_sid_sub_authority == 0)
 578     {
 579       g_b_init_get_sid_sub_authority = 1;
 580       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 581       s_pfn_Get_Sid_Sub_Authority =
 582         (GetSidSubAuthority_Proc) GetProcAddress (
 583             hm_advapi32, "GetSidSubAuthority");
 584     }
 585   if (s_pfn_Get_Sid_Sub_Authority == NULL)
 586     {
 587       return &zero;
 588     }
 589   return (s_pfn_Get_Sid_Sub_Authority (pSid, n));
 590 }
 591
 592 static PUCHAR WINAPI
 593 get_sid_sub_authority_count (PSID pSid)
 594 {
 595   static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count = NULL;
 596   static UCHAR zero = 0U;
 597   HMODULE hm_advapi32 = NULL;
 598   if (is_windows_9x () == TRUE)
 599     {
 600       return &zero;
 601     }
 602   if (g_b_init_get_sid_sub_authority_count == 0)
 603     {
 604       g_b_init_get_sid_sub_authority_count = 1;
 605       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 606       s_pfn_Get_Sid_Sub_Authority_Count =
 607         (GetSidSubAuthorityCount_Proc) GetProcAddress (
 608             hm_advapi32, "GetSidSubAuthorityCount");
 609     }
 610   if (s_pfn_Get_Sid_Sub_Authority_Count == NULL)
 611     {
 612       return &zero;
 613     }
 614   return (s_pfn_Get_Sid_Sub_Authority_Count (pSid));
 615 }
 616
 617 static DWORD WINAPI
 618 get_security_info (HANDLE handle,
 619                    SE_OBJECT_TYPE ObjectType,
 620                    SECURITY_INFORMATION SecurityInfo,
 621                    PSID *ppsidOwner,
 622                    PSID *ppsidGroup,
 623                    PACL *ppDacl,
 624                    PACL *ppSacl,
 625                    PSECURITY_DESCRIPTOR *ppSecurityDescriptor)
 626 {
 627   static GetSecurityInfo_Proc s_pfn_Get_Security_Info = NULL;
 628   HMODULE hm_advapi32 = NULL;
 629   if (is_windows_9x () == TRUE)
 630     {
 631       return FALSE;
 632     }
 633   if (g_b_init_get_security_info == 0)
 634     {
 635       g_b_init_get_security_info = 1;
 636       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 637       s_pfn_Get_Security_Info =
 638         (GetSecurityInfo_Proc) GetProcAddress (
 639             hm_advapi32, "GetSecurityInfo");
 640     }
 641   if (s_pfn_Get_Security_Info == NULL)
 642     {
 643       return FALSE;
 644     }
 645   return (s_pfn_Get_Security_Info (handle, ObjectType, SecurityInfo,
 646                                    ppsidOwner, ppsidGroup, ppDacl, ppSacl,
 647                                    ppSecurityDescriptor));
 648 }
 649
 650 static BOOL WINAPI
 651 get_file_security (LPCTSTR lpFileName,
 652                    SECURITY_INFORMATION RequestedInformation,
 653                    PSECURITY_DESCRIPTOR pSecurityDescriptor,
 654                    DWORD nLength,
 655                    LPDWORD lpnLengthNeeded)
 656 {
 657   static GetFileSecurity_Proc s_pfn_Get_File_Security = NULL;
 658   HMODULE hm_advapi32 = NULL;
 659   if (is_windows_9x () == TRUE)
 660     {
 661       errno = ENOTSUP;
 662       return FALSE;
 663     }
 664   if (g_b_init_get_file_security == 0)
 665     {
 666       g_b_init_get_file_security = 1;
 667       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 668       s_pfn_Get_File_Security =
 669         (GetFileSecurity_Proc) GetProcAddress (
 670             hm_advapi32, GetFileSecurity_Name);
 671     }
 672   if (s_pfn_Get_File_Security == NULL)
 673     {
 674       errno = ENOTSUP;
 675       return FALSE;
 676     }
 677   return (s_pfn_Get_File_Security (lpFileName, RequestedInformation,
 678                                    pSecurityDescriptor, nLength,
 679                                    lpnLengthNeeded));
 680 }
 681
 682 static BOOL WINAPI
 683 set_file_security (LPCTSTR lpFileName,
 684                    SECURITY_INFORMATION SecurityInformation,
 685                    PSECURITY_DESCRIPTOR pSecurityDescriptor)
 686 {
 687   static SetFileSecurity_Proc s_pfn_Set_File_Security = NULL;
 688   HMODULE hm_advapi32 = NULL;
 689   if (is_windows_9x () == TRUE)
 690     {
 691       errno = ENOTSUP;
 692       return FALSE;
 693     }
 694   if (g_b_init_set_file_security == 0)
 695     {
 696       g_b_init_set_file_security = 1;
 697       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 698       s_pfn_Set_File_Security =
 699         (SetFileSecurity_Proc) GetProcAddress (
 700             hm_advapi32, SetFileSecurity_Name);
 701     }
 702   if (s_pfn_Set_File_Security == NULL)
 703     {
 704       errno = ENOTSUP;
 705       return FALSE;
 706     }
 707   return (s_pfn_Set_File_Security (lpFileName, SecurityInformation,
 708                                    pSecurityDescriptor));
 709 }
 710
 711 static BOOL WINAPI
 712 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
 713                                PSID *pOwner,
 714                                LPBOOL lpbOwnerDefaulted)
 715 {
 716   static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner = NULL;
 717   HMODULE hm_advapi32 = NULL;
 718   if (is_windows_9x () == TRUE)
 719     {
 720       errno = ENOTSUP;
 721       return FALSE;
 722     }
 723   if (g_b_init_get_security_descriptor_owner == 0)
 724     {
 725       g_b_init_get_security_descriptor_owner = 1;
 726       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 727       s_pfn_Get_Security_Descriptor_Owner =
 728         (GetSecurityDescriptorOwner_Proc) GetProcAddress (
 729             hm_advapi32, "GetSecurityDescriptorOwner");
 730     }
 731   if (s_pfn_Get_Security_Descriptor_Owner == NULL)
 732     {
 733       errno = ENOTSUP;
 734       return FALSE;
 735     }
 736   return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor, pOwner,
 737                                                lpbOwnerDefaulted));
 738 }
 739
 740 static BOOL WINAPI
 741 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
 742                                PSID *pGroup,
 743                                LPBOOL lpbGroupDefaulted)
 744 {
 745   static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group = NULL;
 746   HMODULE hm_advapi32 = NULL;
 747   if (is_windows_9x () == TRUE)
 748     {
 749       errno = ENOTSUP;
 750       return FALSE;
 751     }
 752   if (g_b_init_get_security_descriptor_group == 0)
 753     {
 754       g_b_init_get_security_descriptor_group = 1;
 755       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 756       s_pfn_Get_Security_Descriptor_Group =
 757         (GetSecurityDescriptorGroup_Proc) GetProcAddress (
 758             hm_advapi32, "GetSecurityDescriptorGroup");
 759     }
 760   if (s_pfn_Get_Security_Descriptor_Group == NULL)
 761     {
 762       errno = ENOTSUP;
 763       return FALSE;
 764     }
 765   return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor, pGroup,
 766                                                lpbGroupDefaulted));
 767 }
 768
 769 static BOOL WINAPI
 770 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor,
 771                               LPBOOL lpbDaclPresent,
 772                               PACL *pDacl,
 773                               LPBOOL lpbDaclDefaulted)
 774 {
 775   static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl = NULL;
 776   HMODULE hm_advapi32 = NULL;
 777   if (is_windows_9x () == TRUE)
 778     {
 779       errno = ENOTSUP;
 780       return FALSE;
 781     }
 782   if (g_b_init_get_security_descriptor_dacl == 0)
 783     {
 784       g_b_init_get_security_descriptor_dacl = 1;
 785       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 786       s_pfn_Get_Security_Descriptor_Dacl =
 787         (GetSecurityDescriptorDacl_Proc) GetProcAddress (
 788             hm_advapi32, "GetSecurityDescriptorDacl");
 789     }
 790   if (s_pfn_Get_Security_Descriptor_Dacl == NULL)
 791     {
 792       errno = ENOTSUP;
 793       return FALSE;
 794     }
 795   return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor,
 796                                               lpbDaclPresent, pDacl,
 797                                               lpbDaclDefaulted));
 798 }
 799
 800 static BOOL WINAPI
 801 is_valid_sid (PSID sid)
 802 {
 803   static IsValidSid_Proc s_pfn_Is_Valid_Sid = NULL;
 804   HMODULE hm_advapi32 = NULL;
 805   if (is_windows_9x () == TRUE)
 806     {
 807       return FALSE;
 808     }
 809   if (g_b_init_is_valid_sid == 0)
 810     {
 811       g_b_init_is_valid_sid = 1;
 812       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 813       s_pfn_Is_Valid_Sid =
 814         (IsValidSid_Proc) GetProcAddress (
 815             hm_advapi32, "IsValidSid");
 816     }
 817   if (s_pfn_Is_Valid_Sid == NULL)
 818     {
 819       return FALSE;
 820     }
 821   return (s_pfn_Is_Valid_Sid (sid));
 822 }
 823
 824 static BOOL WINAPI
 825 equal_sid (PSID sid1, PSID sid2)
 826 {
 827   static EqualSid_Proc s_pfn_Equal_Sid = NULL;
 828   HMODULE hm_advapi32 = NULL;
 829   if (is_windows_9x () == TRUE)
 830     {
 831       return FALSE;
 832     }
 833   if (g_b_init_equal_sid == 0)
 834     {
 835       g_b_init_equal_sid = 1;
 836       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 837       s_pfn_Equal_Sid =
 838         (EqualSid_Proc) GetProcAddress (
 839             hm_advapi32, "EqualSid");
 840     }
 841   if (s_pfn_Equal_Sid == NULL)
 842     {
 843       return FALSE;
 844     }
 845   return (s_pfn_Equal_Sid (sid1, sid2));
 846 }
 847
 848 static DWORD WINAPI
 849 get_length_sid (PSID sid)
 850 {
 851   static GetLengthSid_Proc s_pfn_Get_Length_Sid = NULL;
 852   HMODULE hm_advapi32 = NULL;
 853   if (is_windows_9x () == TRUE)
 854     {
 855       return 0;
 856     }
 857   if (g_b_init_get_length_sid == 0)
 858     {
 859       g_b_init_get_length_sid = 1;
 860       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 861       s_pfn_Get_Length_Sid =
 862         (GetLengthSid_Proc) GetProcAddress (
 863             hm_advapi32, "GetLengthSid");
 864     }
 865   if (s_pfn_Get_Length_Sid == NULL)
 866     {
 867       return 0;
 868     }
 869   return (s_pfn_Get_Length_Sid (sid));
 870 }
 871
 872 static BOOL WINAPI
 873 copy_sid (DWORD destlen, PSID dest, PSID src)
 874 {
 875   static CopySid_Proc s_pfn_Copy_Sid = NULL;
 876   HMODULE hm_advapi32 = NULL;
 877   if (is_windows_9x () == TRUE)
 878     {
 879       return FALSE;
 880     }
 881   if (g_b_init_copy_sid == 0)
 882     {
 883       g_b_init_copy_sid = 1;
 884       hm_advapi32 = LoadLibrary ("Advapi32.dll");
 885       s_pfn_Copy_Sid =
 886         (CopySid_Proc) GetProcAddress (
 887             hm_advapi32, "CopySid");
 888     }
 889   if (s_pfn_Copy_Sid == NULL)
 890     {
 891       return FALSE;
 892     }
 893   return (s_pfn_Copy_Sid (destlen, dest, src));
 894 }
 895
 896 /*
 897   END: Wrapper functions around OpenProcessToken
 898   and other functions in advapi32.dll that are only
 899   supported in Windows NT / 2k / XP
 900 */
 901
 902 static void WINAPI
 903 get_native_system_info (LPSYSTEM_INFO lpSystemInfo)
 904 {
 905   static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info = NULL;
 906   if (is_windows_9x () != TRUE)
 907     {
 908       if (g_b_init_get_native_system_info == 0)
 909         {
 910           g_b_init_get_native_system_info = 1;
 911           s_pfn_Get_Native_System_Info =
 912             (GetNativeSystemInfo_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
 913                                                       "GetNativeSystemInfo");
 914         }
 915       if (s_pfn_Get_Native_System_Info != NULL)
 916         s_pfn_Get_Native_System_Info (lpSystemInfo);
 917     }
 918   else
 919     lpSystemInfo->dwNumberOfProcessors = -1;
 920 }
 921
 922 static BOOL WINAPI
 923 get_system_times (LPFILETIME lpIdleTime,
 924                   LPFILETIME lpKernelTime,
 925                   LPFILETIME lpUserTime)
 926 {
 927   static GetSystemTimes_Proc s_pfn_Get_System_times = NULL;
 928   if (is_windows_9x () == TRUE)
 929     {
 930       return FALSE;
 931     }
 932   if (g_b_init_get_system_times == 0)
 933     {
 934       g_b_init_get_system_times = 1;
 935       s_pfn_Get_System_times =
 936         (GetSystemTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
 937                                              "GetSystemTimes");
 938     }
 939   if (s_pfn_Get_System_times == NULL)
 940     return FALSE;
 941   return (s_pfn_Get_System_times (lpIdleTime, lpKernelTime, lpUserTime));
 942 }
 943
 944 static BOOLEAN WINAPI
 945 create_symbolic_link (LPTSTR lpSymlinkFilename,
 946                       LPTSTR lpTargetFileName,
 947                       DWORD dwFlags)
 948 {
 949   static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link = NULL;
 950   BOOLEAN retval;
 951
 952   if (is_windows_9x () == TRUE)
 953     {
 954       errno = ENOSYS;
 955       return 0;
 956     }
 957   if (g_b_init_create_symbolic_link == 0)
 958     {
 959       g_b_init_create_symbolic_link = 1;
 960 #ifdef _UNICODE
 961       s_pfn_Create_Symbolic_Link =
 962         (CreateSymbolicLink_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
 963                                                  "CreateSymbolicLinkW");
 964 #else
 965       s_pfn_Create_Symbolic_Link =
 966         (CreateSymbolicLink_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
 967                                                  "CreateSymbolicLinkA");
 968 #endif
 969     }
 970   if (s_pfn_Create_Symbolic_Link == NULL)
 971     {
 972       errno = ENOSYS;
 973       return 0;
 974     }
 975
 976   retval = s_pfn_Create_Symbolic_Link (lpSymlinkFilename, lpTargetFileName,
 977                                        dwFlags);
 978   /* If we were denied creation of the symlink, try again after
 979      enabling the SeCreateSymbolicLinkPrivilege for our process.  */
 980   if (!retval)
 981     {
 982       TOKEN_PRIVILEGES priv_current;
 983
 984       if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME, TRUE, &priv_current))
 985         {
 986           retval = s_pfn_Create_Symbolic_Link (lpSymlinkFilename, lpTargetFileName,
 987                                                dwFlags);
 988           restore_privilege (&priv_current);
 989           revert_to_self ();
 990         }
 991     }
 992   return retval;
 993 }
 994
 995 static BOOL WINAPI
 996 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor)
 997 {
 998   static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc = NULL;
 999
1000   if (is_windows_9x () == TRUE)
1001     {
1002       errno = ENOTSUP;
1003       return FALSE;
1004     }
1005
1006   if (g_b_init_is_valid_security_descriptor == 0)
1007     {
1008       g_b_init_is_valid_security_descriptor = 1;
1009       s_pfn_Is_Valid_Security_Descriptor_Proc =
1010         (IsValidSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1011                                                         "IsValidSecurityDescriptor");
1012     }
1013   if (s_pfn_Is_Valid_Security_Descriptor_Proc == NULL)
1014     {
1015       errno = ENOTSUP;
1016       return FALSE;
1017     }
1018
1019   return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor);
1020 }
1021
1022 static BOOL WINAPI
1023 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor,
1024                     DWORD RequestedStringSDRevision,
1025                     SECURITY_INFORMATION SecurityInformation,
1026                     LPTSTR  *StringSecurityDescriptor,
1027                     PULONG StringSecurityDescriptorLen)
1028 {
1029   static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL = NULL;
1030   BOOL retval;
1031
1032   if (is_windows_9x () == TRUE)
1033     {
1034       errno = ENOTSUP;
1035       return FALSE;
1036     }
1037
1038   if (g_b_init_convert_sd_to_sddl == 0)
1039     {
1040       g_b_init_convert_sd_to_sddl = 1;
1041 #ifdef _UNICODE
1042       s_pfn_Convert_SD_To_SDDL =
1043         (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1044                                                                                   "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1045 #else
1046       s_pfn_Convert_SD_To_SDDL =
1047         (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1048                                                                                   "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1049 #endif
1050     }
1051   if (s_pfn_Convert_SD_To_SDDL == NULL)
1052     {
1053       errno = ENOTSUP;
1054       return FALSE;
1055     }
1056
1057   retval = s_pfn_Convert_SD_To_SDDL (SecurityDescriptor,
1058                                      RequestedStringSDRevision,
1059                                      SecurityInformation,
1060                                      StringSecurityDescriptor,
1061                                      StringSecurityDescriptorLen);
1062
1063   return retval;
1064 }
1065
1066 static BOOL WINAPI
1067 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor,
1068                     DWORD StringSDRevision,
1069                     PSECURITY_DESCRIPTOR  *SecurityDescriptor,
1070                     PULONG  SecurityDescriptorSize)
1071 {
1072   static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD = NULL;
1073   BOOL retval;
1074
1075   if (is_windows_9x () == TRUE)
1076     {
1077       errno = ENOTSUP;
1078       return FALSE;
1079     }
1080
1081   if (g_b_init_convert_sddl_to_sd == 0)
1082     {
1083       g_b_init_convert_sddl_to_sd = 1;
1084 #ifdef _UNICODE
1085       s_pfn_Convert_SDDL_To_SD =
1086         (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1087                                                                                   "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1088 #else
1089       s_pfn_Convert_SDDL_To_SD =
1090         (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1091                                                                                   "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1092 #endif
1093     }
1094   if (s_pfn_Convert_SDDL_To_SD == NULL)
1095     {
1096       errno = ENOTSUP;
1097       return FALSE;
1098     }
1099
1100   retval = s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor,
1101                                      StringSDRevision,
1102                                      SecurityDescriptor,
1103                                      SecurityDescriptorSize);
1104
1105   return retval;
1106 }
1107
1108 \f
1109
1110 /* Return 1 if P is a valid pointer to an object of size SIZE.  Return
1111    0 if P is NOT a valid pointer.  Return -1 if we cannot validate P.
1112
1113    This is called from alloc.c:valid_pointer_p.  */
1114 int
1115 w32_valid_pointer_p (void *p, int size)
1116 {
1117   SIZE_T done;
1118   HANDLE h = OpenProcess (PROCESS_VM_READ, FALSE, GetCurrentProcessId ());
1119
1120   if (h)
1121     {
1122       unsigned char *buf = alloca (size);
1123       int retval = ReadProcessMemory (h, p, buf, size, &done);
1124
1125       CloseHandle (h);
1126       return retval;
1127     }
1128   else
1129     return -1;
1130 }
1131
1132 static char startup_dir[MAXPATHLEN];
1133
1134 /* Get the current working directory.  */
1135 char *
1136 getcwd (char *dir, int dirsize)
1137 {
1138   if (!dirsize)
1139     {
1140       errno = EINVAL;
1141       return NULL;
1142     }
1143   if (dirsize <= strlen (startup_dir))
1144     {
1145       errno = ERANGE;
1146       return NULL;
1147     }
1148 #if 0
1149   if (GetCurrentDirectory (MAXPATHLEN, dir) > 0)
1150     return dir;
1151   return NULL;
1152 #else
1153   /* Emacs doesn't actually change directory itself, it stays in the
1154      same directory where it was started.  */
1155   strcpy (dir, startup_dir);
1156   return dir;
1157 #endif
1158 }
1159
1160 /* Emulate getloadavg.  */
1161
1162 struct load_sample {
1163   time_t sample_time;
1164   ULONGLONG idle;
1165   ULONGLONG kernel;
1166   ULONGLONG user;
1167 };
1168
1169 /* Number of processors on this machine.  */
1170 static unsigned num_of_processors;
1171
1172 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer.  */
1173 static struct load_sample samples[16*60];
1174 static int first_idx = -1, last_idx = -1;
1175 static int max_idx = sizeof (samples) / sizeof (samples[0]);
1176
1177 static int
1178 buf_next (int from)
1179 {
1180   int next_idx = from + 1;
1181
1182   if (next_idx >= max_idx)
1183     next_idx = 0;
1184
1185   return next_idx;
1186 }
1187
1188 static int
1189 buf_prev (int from)
1190 {
1191   int prev_idx = from - 1;
1192
1193   if (prev_idx < 0)
1194     prev_idx = max_idx - 1;
1195
1196   return prev_idx;
1197 }
1198
1199 static void
1200 sample_system_load (ULONGLONG *idle, ULONGLONG *kernel, ULONGLONG *user)
1201 {
1202   SYSTEM_INFO sysinfo;
1203   FILETIME ft_idle, ft_user, ft_kernel;
1204
1205   /* Initialize the number of processors on this machine.  */
1206   if (num_of_processors <= 0)
1207     {
1208       get_native_system_info (&sysinfo);
1209       num_of_processors = sysinfo.dwNumberOfProcessors;
1210       if (num_of_processors <= 0)
1211         {
1212           GetSystemInfo (&sysinfo);
1213           num_of_processors = sysinfo.dwNumberOfProcessors;
1214         }
1215       if (num_of_processors <= 0)
1216         num_of_processors = 1;
1217     }
1218
1219   /* TODO: Take into account threads that are ready to run, by
1220      sampling the "\System\Processor Queue Length" performance
1221      counter.  The code below accounts only for threads that are
1222      actually running.  */
1223
1224   if (get_system_times (&ft_idle, &ft_kernel, &ft_user))
1225     {
1226       ULARGE_INTEGER uidle, ukernel, uuser;
1227
1228       memcpy (&uidle, &ft_idle, sizeof (ft_idle));
1229       memcpy (&ukernel, &ft_kernel, sizeof (ft_kernel));
1230       memcpy (&uuser, &ft_user, sizeof (ft_user));
1231       *idle = uidle.QuadPart;
1232       *kernel = ukernel.QuadPart;
1233       *user = uuser.QuadPart;
1234     }
1235   else
1236     {
1237       *idle = 0;
1238       *kernel = 0;
1239       *user = 0;
1240     }
1241 }
1242
1243 /* Produce the load average for a given time interval, using the
1244    samples in the samples[] array.  WHICH can be 0, 1, or 2, meaning
1245    1-minute, 5-minute, or 15-minute average, respectively. */
1246 static double
1247 getavg (int which)
1248 {
1249   double retval = -1.0;
1250   double tdiff;
1251   int idx;
1252   double span = (which == 0 ? 1.0 : (which == 1 ? 5.0 : 15.0)) * 60;
1253   time_t now = samples[last_idx].sample_time;
1254
1255   if (first_idx != last_idx)
1256     {
1257       for (idx = buf_prev (last_idx); ; idx = buf_prev (idx))
1258         {
1259           tdiff = difftime (now, samples[idx].sample_time);
1260           if (tdiff >= span - 2*DBL_EPSILON*now)
1261             {
1262               long double sys =
1263                 samples[last_idx].kernel + samples[last_idx].user
1264                 - (samples[idx].kernel + samples[idx].user);
1265               long double idl = samples[last_idx].idle - samples[idx].idle;
1266
1267               retval = (1.0 - idl / sys) * num_of_processors;
1268               break;
1269             }
1270           if (idx == first_idx)
1271             break;
1272         }
1273     }
1274
1275   return retval;
1276 }
1277
1278 int
1279 getloadavg (double loadavg[], int nelem)
1280 {
1281   int elem;
1282   ULONGLONG idle, kernel, user;
1283   time_t now = time (NULL);
1284
1285   /* Store another sample.  We ignore samples that are less than 1 sec
1286      apart.  */
1287   if (difftime (now, samples[last_idx].sample_time) >= 1.0 - 2*DBL_EPSILON*now)
1288     {
1289       sample_system_load (&idle, &kernel, &user);
1290       last_idx = buf_next (last_idx);
1291       samples[last_idx].sample_time = now;
1292       samples[last_idx].idle = idle;
1293       samples[last_idx].kernel = kernel;
1294       samples[last_idx].user = user;
1295       /* If the buffer has more that 15 min worth of samples, discard
1296          the old ones.  */
1297       if (first_idx == -1)
1298         first_idx = last_idx;
1299       while (first_idx != last_idx
1300              && (difftime (now, samples[first_idx].sample_time)
1301                  >= 15.0*60 + 2*DBL_EPSILON*now))
1302         first_idx = buf_next (first_idx);
1303     }
1304
1305   for (elem = 0; elem < nelem; elem++)
1306     {
1307       double avg = getavg (elem);
1308
1309       if (avg < 0)
1310         break;
1311       loadavg[elem] = avg;
1312     }
1313
1314   return elem;
1315 }
1316
1317 /* Emulate getpwuid, getpwnam and others.  */
1318
1319 #define PASSWD_FIELD_SIZE 256
1320
1321 static char dflt_passwd_name[PASSWD_FIELD_SIZE];
1322 static char dflt_passwd_passwd[PASSWD_FIELD_SIZE];
1323 static char dflt_passwd_gecos[PASSWD_FIELD_SIZE];
1324 static char dflt_passwd_dir[PASSWD_FIELD_SIZE];
1325 static char dflt_passwd_shell[PASSWD_FIELD_SIZE];
1326
1327 static struct passwd dflt_passwd =
1328 {
1329   dflt_passwd_name,
1330   dflt_passwd_passwd,
1331   0,
1332   0,
1333   0,
1334   dflt_passwd_gecos,
1335   dflt_passwd_dir,
1336   dflt_passwd_shell,
1337 };
1338
1339 static char dflt_group_name[GNLEN+1];
1340
1341 static struct group dflt_group =
1342 {
1343   /* When group information is not available, we return this as the
1344      group for all files.  */
1345   dflt_group_name,
1346   0,
1347 };
1348
1349 unsigned
1350 getuid (void)
1351 {
1352   return dflt_passwd.pw_uid;
1353 }
1354
1355 unsigned
1356 geteuid (void)
1357 {
1358   /* I could imagine arguing for checking to see whether the user is
1359      in the Administrators group and returning a UID of 0 for that
1360      case, but I don't know how wise that would be in the long run.  */
1361   return getuid ();
1362 }
1363
1364 unsigned
1365 getgid (void)
1366 {
1367   return dflt_passwd.pw_gid;
1368 }
1369
1370 unsigned
1371 getegid (void)
1372 {
1373   return getgid ();
1374 }
1375
1376 struct passwd *
1377 getpwuid (unsigned uid)
1378 {
1379   if (uid == dflt_passwd.pw_uid)
1380     return &dflt_passwd;
1381   return NULL;
1382 }
1383
1384 struct group *
1385 getgrgid (gid_t gid)
1386 {
1387   return &dflt_group;
1388 }
1389
1390 struct passwd *
1391 getpwnam (char *name)
1392 {
1393   struct passwd *pw;
1394
1395   pw = getpwuid (getuid ());
1396   if (!pw)
1397     return pw;
1398
1399   if (xstrcasecmp (name, pw->pw_name))
1400     return NULL;
1401
1402   return pw;
1403 }
1404
1405 static void
1406 init_user_info (void)
1407 {
1408   /* Find the user's real name by opening the process token and
1409      looking up the name associated with the user-sid in that token.
1410
1411      Use the relative portion of the identifier authority value from
1412      the user-sid as the user id value (same for group id using the
1413      primary group sid from the process token). */
1414
1415   char         uname[UNLEN+1], gname[GNLEN+1], domain[1025];
1416   DWORD        ulength = sizeof (uname), dlength = sizeof (domain), needed;
1417   DWORD        glength = sizeof (gname);
1418   HANDLE       token = NULL;
1419   SID_NAME_USE user_type;
1420   unsigned char *buf = NULL;
1421   DWORD        blen = 0;
1422   TOKEN_USER   user_token;
1423   TOKEN_PRIMARY_GROUP group_token;
1424   BOOL         result;
1425
1426   result = open_process_token (GetCurrentProcess (), TOKEN_QUERY, &token);
1427   if (result)
1428     {
1429       result = get_token_information (token, TokenUser, NULL, 0, &blen);
1430       if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1431         {
1432           buf = xmalloc (blen);
1433           result = get_token_information (token, TokenUser,
1434                                           (LPVOID)buf, blen, &needed);
1435           if (result)
1436             {
1437               memcpy (&user_token, buf, sizeof (user_token));
1438               result = lookup_account_sid (NULL, user_token.User.Sid,
1439                                            uname, &ulength,
1440                                            domain, &dlength, &user_type);
1441             }
1442         }
1443       else
1444         result = FALSE;
1445     }
1446   if (result)
1447     {
1448       strcpy (dflt_passwd.pw_name, uname);
1449       /* Determine a reasonable uid value.  */
1450       if (xstrcasecmp ("administrator", uname) == 0)
1451         {
1452           dflt_passwd.pw_uid = 500; /* well-known Administrator uid */
1453           dflt_passwd.pw_gid = 513; /* well-known None gid */
1454         }
1455       else
1456         {
1457           /* Use the last sub-authority value of the RID, the relative
1458              portion of the SID, as user/group ID. */
1459           dflt_passwd.pw_uid = get_rid (user_token.User.Sid);
1460
1461           /* Get group id and name.  */
1462           result = get_token_information (token, TokenPrimaryGroup,
1463                                           (LPVOID)buf, blen, &needed);
1464           if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
1465             {
1466               buf = xrealloc (buf, blen = needed);
1467               result = get_token_information (token, TokenPrimaryGroup,
1468                                               (LPVOID)buf, blen, &needed);
1469             }
1470           if (result)
1471             {
1472               memcpy (&group_token, buf, sizeof (group_token));
1473               dflt_passwd.pw_gid = get_rid (group_token.PrimaryGroup);
1474               dlength = sizeof (domain);
1475               /* If we can get at the real Primary Group name, use that.
1476                  Otherwise, the default group name was already set to
1477                  "None" in globals_of_w32.  */
1478               if (lookup_account_sid (NULL, group_token.PrimaryGroup,
1479                                       gname, &glength, NULL, &dlength,
1480                                       &user_type))
1481                 strcpy (dflt_group_name, gname);
1482             }
1483           else
1484             dflt_passwd.pw_gid = dflt_passwd.pw_uid;
1485         }
1486     }
1487   /* If security calls are not supported (presumably because we
1488      are running under Windows 9X), fallback to this: */
1489   else if (GetUserName (uname, &ulength))
1490     {
1491       strcpy (dflt_passwd.pw_name, uname);
1492       if (xstrcasecmp ("administrator", uname) == 0)
1493         dflt_passwd.pw_uid = 0;
1494       else
1495         dflt_passwd.pw_uid = 123;
1496       dflt_passwd.pw_gid = dflt_passwd.pw_uid;
1497     }
1498   else
1499     {
1500       strcpy (dflt_passwd.pw_name, "unknown");
1501       dflt_passwd.pw_uid = 123;
1502       dflt_passwd.pw_gid = 123;
1503     }
1504   dflt_group.gr_gid = dflt_passwd.pw_gid;
1505
1506   /* Ensure HOME and SHELL are defined. */
1507   if (getenv ("HOME") == NULL)
1508     emacs_abort ();
1509   if (getenv ("SHELL") == NULL)
1510     emacs_abort ();
1511
1512   /* Set dir and shell from environment variables. */
1513   strcpy (dflt_passwd.pw_dir, getenv ("HOME"));
1514   strcpy (dflt_passwd.pw_shell, getenv ("SHELL"));
1515
1516   xfree (buf);
1517   if (token)
1518     CloseHandle (token);
1519 }
1520
1521 int
1522 random (void)
1523 {
1524   /* rand () on NT gives us 15 random bits...hack together 30 bits.  */
1525   return ((rand () << 15) | rand ());
1526 }
1527
1528 void
1529 srandom (int seed)
1530 {
1531   srand (seed);
1532 }
1533
1534 /* Current codepage for encoding file names.  */
1535 static int file_name_codepage;
1536
1537 /* Return the maximum length in bytes of a multibyte character
1538    sequence encoded in the current ANSI codepage.  This is required to
1539    correctly walk the encoded file names one character at a time.  */
1540 static int
1541 max_filename_mbslen (void)
1542 {
1543   /* A simple cache to avoid calling GetCPInfo every time we need to
1544      normalize a file name.  The file-name encoding is not supposed to
1545      be changed too frequently, if ever.  */
1546   static Lisp_Object last_file_name_encoding;
1547   static int last_max_mbslen;
1548   Lisp_Object current_encoding;
1549
1550   current_encoding = Vfile_name_coding_system;
1551   if (NILP (current_encoding))
1552     current_encoding = Vdefault_file_name_coding_system;
1553
1554   if (!EQ (last_file_name_encoding, current_encoding))
1555     {
1556       CPINFO cp_info;
1557
1558       last_file_name_encoding = current_encoding;
1559       /* Default to the current ANSI codepage.  */
1560       file_name_codepage = w32_ansi_code_page;
1561       if (!NILP (current_encoding))
1562         {
1563           char *cpname = SDATA (SYMBOL_NAME (current_encoding));
1564           char *cp = NULL, *end;
1565           int cpnum;
1566
1567           if (strncmp (cpname, "cp", 2) == 0)
1568             cp = cpname + 2;
1569           else if (strncmp (cpname, "windows-", 8) == 0)
1570             cp = cpname + 8;
1571
1572           if (cp)
1573             {
1574               end = cp;
1575               cpnum = strtol (cp, &end, 10);
1576               if (cpnum && *end == '\0' && end - cp >= 2)
1577                 file_name_codepage = cpnum;
1578             }
1579         }
1580
1581       if (!file_name_codepage)
1582         file_name_codepage = CP_ACP; /* CP_ACP = 0, but let's not assume that */
1583
1584       if (!GetCPInfo (file_name_codepage, &cp_info))
1585         {
1586           file_name_codepage = CP_ACP;
1587           if (!GetCPInfo (file_name_codepage, &cp_info))
1588             emacs_abort ();
1589         }
1590       last_max_mbslen = cp_info.MaxCharSize;
1591     }
1592
1593   return last_max_mbslen;
1594 }
1595
1596 /* Normalize filename by converting all path separators to
1597    the specified separator.  Also conditionally convert upper
1598    case path name components to lower case.  */
1599
1600 static void
1601 normalize_filename (register char *fp, char path_sep)
1602 {
1603   char sep;
1604   char *elem, *p2;
1605   int dbcs_p = max_filename_mbslen () > 1;
1606
1607   /* Always lower-case drive letters a-z, even if the filesystem
1608      preserves case in filenames.
1609      This is so filenames can be compared by string comparison
1610      functions that are case-sensitive.  Even case-preserving filesystems
1611      do not distinguish case in drive letters.  */
1612   if (dbcs_p)
1613     p2 = CharNextExA (file_name_codepage, fp, 0);
1614   else
1615     p2 = fp + 1;
1616
1617   if (*p2 == ':' && *fp >= 'A' && *fp <= 'Z')
1618     {
1619       *fp += 'a' - 'A';
1620       fp += 2;
1621     }
1622
1623   if (NILP (Vw32_downcase_file_names))
1624     {
1625       while (*fp)
1626         {
1627           if (*fp == '/' || *fp == '\\')
1628             *fp = path_sep;
1629           if (!dbcs_p)
1630             fp++;
1631           else
1632             fp = CharNextExA (file_name_codepage, fp, 0);
1633         }
1634       return;
1635     }
1636
1637   sep = path_sep;               /* convert to this path separator */
1638   elem = fp;                    /* start of current path element */
1639
1640   do {
1641     if (*fp >= 'a' && *fp <= 'z')
1642       elem = 0;                 /* don't convert this element */
1643
1644     if (*fp == 0 || *fp == ':')
1645       {
1646         sep = *fp;              /* restore current separator (or 0) */
1647         *fp = '/';              /* after conversion of this element */
1648       }
1649
1650     if (*fp == '/' || *fp == '\\')
1651       {
1652         if (elem && elem != fp)
1653           {
1654             *fp = 0;            /* temporary end of string */
1655             _mbslwr (elem);     /* while we convert to lower case */
1656           }
1657         *fp = sep;              /* convert (or restore) path separator */
1658         elem = fp + 1;          /* next element starts after separator */
1659         sep = path_sep;
1660       }
1661     if (*fp)
1662       {
1663         if (!dbcs_p)
1664           fp++;
1665         else
1666           fp = CharNextExA (file_name_codepage, fp, 0);
1667       }
1668   } while (*fp);
1669 }
1670
1671 /* Destructively turn backslashes into slashes.  */
1672 void
1673 dostounix_filename (register char *p)
1674 {
1675   normalize_filename (p, '/');
1676 }
1677
1678 /* Destructively turn slashes into backslashes.  */
1679 void
1680 unixtodos_filename (register char *p)
1681 {
1682   normalize_filename (p, '\\');
1683 }
1684
1685 /* Remove all CR's that are followed by a LF.
1686    (From msdos.c...probably should figure out a way to share it,
1687    although this code isn't going to ever change.)  */
1688 static int
1689 crlf_to_lf (register int n, register unsigned char *buf)
1690 {
1691   unsigned char *np = buf;
1692   unsigned char *startp = buf;
1693   unsigned char *endp = buf + n;
1694
1695   if (n == 0)
1696     return n;
1697   while (buf < endp - 1)
1698     {
1699       if (*buf == 0x0d)
1700         {
1701           if (*(++buf) != 0x0a)
1702             *np++ = 0x0d;
1703         }
1704       else
1705         *np++ = *buf++;
1706     }
1707   if (buf < endp)
1708     *np++ = *buf++;
1709   return np - startp;
1710 }
1711
1712 /* Parse the root part of file name, if present.  Return length and
1713     optionally store pointer to char after root.  */
1714 static int
1715 parse_root (char * name, char ** pPath)
1716 {
1717   char * start = name;
1718
1719   if (name == NULL)
1720     return 0;
1721
1722   /* find the root name of the volume if given */
1723   if (isalpha (name[0]) && name[1] == ':')
1724     {
1725       /* skip past drive specifier */
1726       name += 2;
1727       if (IS_DIRECTORY_SEP (name[0]))
1728         name++;
1729     }
1730   else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
1731     {
1732       int slashes = 2;
1733       int dbcs_p = max_filename_mbslen () > 1;
1734
1735       name += 2;
1736       do
1737         {
1738           if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
1739             break;
1740           if (dbcs_p)
1741             name = CharNextExA (file_name_codepage, name, 0);
1742           else
1743             name++;
1744         }
1745       while ( *name );
1746       if (IS_DIRECTORY_SEP (name[0]))
1747         name++;
1748     }
1749
1750   if (pPath)
1751     *pPath = name;
1752
1753   return name - start;
1754 }
1755
1756 /* Get long base name for name; name is assumed to be absolute.  */
1757 static int
1758 get_long_basename (char * name, char * buf, int size)
1759 {
1760   WIN32_FIND_DATA find_data;
1761   HANDLE dir_handle;
1762   int len = 0;
1763
1764   /* must be valid filename, no wild cards or other invalid characters */
1765   if (_mbspbrk (name, "*?|<>\""))
1766     return 0;
1767
1768   dir_handle = FindFirstFile (name, &find_data);
1769   if (dir_handle != INVALID_HANDLE_VALUE)
1770     {
1771       if ((len = strlen (find_data.cFileName)) < size)
1772         memcpy (buf, find_data.cFileName, len + 1);
1773       else
1774         len = 0;
1775       FindClose (dir_handle);
1776     }
1777   return len;
1778 }
1779
1780 /* Get long name for file, if possible (assumed to be absolute).  */
1781 BOOL
1782 w32_get_long_filename (char * name, char * buf, int size)
1783 {
1784   char * o = buf;
1785   char * p;
1786   char * q;
1787   char full[ MAX_PATH ];
1788   int len;
1789
1790   len = strlen (name);
1791   if (len >= MAX_PATH)
1792     return FALSE;
1793
1794   /* Use local copy for destructive modification.  */
1795   memcpy (full, name, len+1);
1796   unixtodos_filename (full);
1797
1798   /* Copy root part verbatim.  */
1799   len = parse_root (full, &p);
1800   memcpy (o, full, len);
1801   o += len;
1802   *o = '\0';
1803   size -= len;
1804
1805   while (p != NULL && *p)
1806     {
1807       q = p;
1808       p = _mbschr (q, '\\');
1809       if (p) *p = '\0';
1810       len = get_long_basename (full, o, size);
1811       if (len > 0)
1812         {
1813           o += len;
1814           size -= len;
1815           if (p != NULL)
1816             {
1817               *p++ = '\\';
1818               if (size < 2)
1819                 return FALSE;
1820               *o++ = '\\';
1821               size--;
1822               *o = '\0';
1823             }
1824         }
1825       else
1826         return FALSE;
1827     }
1828
1829   return TRUE;
1830 }
1831
1832 static int
1833 is_unc_volume (const char *filename)
1834 {
1835   const char *ptr = filename;
1836
1837   if (!IS_DIRECTORY_SEP (ptr[0]) || !IS_DIRECTORY_SEP (ptr[1]) || !ptr[2])
1838     return 0;
1839
1840   if (_mbspbrk (ptr + 2, "*?|<>\"\\/"))
1841     return 0;
1842
1843   return 1;
1844 }
1845
1846 /* Emulate the Posix unsetenv.  */
1847 int
1848 unsetenv (const char *name)
1849 {
1850   char *var;
1851   size_t name_len;
1852   int retval;
1853
1854   if (name == NULL || *name == '\0' || strchr (name, '=') != NULL)
1855     {
1856       errno = EINVAL;
1857       return -1;
1858     }
1859   name_len = strlen (name);
1860   /* MS docs says an environment variable cannot be longer than 32K.  */
1861   if (name_len > 32767)
1862     {
1863       errno = ENOMEM;
1864       return 0;
1865     }
1866   /* It is safe to use 'alloca' with 32K size, since the stack is at
1867      least 2MB, and we set it to 8MB in the link command line.  */
1868   var = alloca (name_len + 2);
1869   strncpy (var, name, name_len);
1870   var[name_len++] = '=';
1871   var[name_len] = '\0';
1872   return _putenv (var);
1873 }
1874
1875 /* MS _putenv doesn't support removing a variable when the argument
1876    does not include the '=' character, so we fix that here.  */
1877 int
1878 sys_putenv (char *str)
1879 {
1880   const char *const name_end = strchr (str, '=');
1881
1882   if (name_end == NULL)
1883     {
1884       /* Remove the variable from the environment.  */
1885       return unsetenv (str);
1886     }
1887
1888   return _putenv (str);
1889 }
1890
1891 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1892
1893 LPBYTE
1894 w32_get_resource (char *key, LPDWORD lpdwtype)
1895 {
1896   LPBYTE lpvalue;
1897   HKEY hrootkey = NULL;
1898   DWORD cbData;
1899
1900   /* Check both the current user and the local machine to see if
1901      we have any resources.  */
1902
1903   if (RegOpenKeyEx (HKEY_CURRENT_USER, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1904     {
1905       lpvalue = NULL;
1906
1907       if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1908           && (lpvalue = xmalloc (cbData)) != NULL
1909           && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
1910         {
1911           RegCloseKey (hrootkey);
1912           return (lpvalue);
1913         }
1914
1915       xfree (lpvalue);
1916
1917       RegCloseKey (hrootkey);
1918     }
1919
1920   if (RegOpenKeyEx (HKEY_LOCAL_MACHINE, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
1921     {
1922       lpvalue = NULL;
1923
1924       if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS
1925           && (lpvalue = xmalloc (cbData)) != NULL
1926           && RegQueryValueEx (hrootkey, key, NULL, lpdwtype, lpvalue, &cbData) == ERROR_SUCCESS)
1927         {
1928           RegCloseKey (hrootkey);
1929           return (lpvalue);
1930         }
1931
1932       xfree (lpvalue);
1933
1934       RegCloseKey (hrootkey);
1935     }
1936
1937   return (NULL);
1938 }
1939
1940 char *get_emacs_configuration (void);
1941
1942 void
1943 init_environment (char ** argv)
1944 {
1945   static const char * const tempdirs[] = {
1946     "$TMPDIR", "$TEMP", "$TMP", "c:/"
1947   };
1948
1949   int i;
1950
1951   const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
1952
1953   /* Make sure they have a usable $TMPDIR.  Many Emacs functions use
1954      temporary files and assume "/tmp" if $TMPDIR is unset, which
1955      will break on DOS/Windows.  Refuse to work if we cannot find
1956      a directory, not even "c:/", usable for that purpose.  */
1957   for (i = 0; i < imax ; i++)
1958     {
1959       const char *tmp = tempdirs[i];
1960
1961       if (*tmp == '$')
1962         tmp = getenv (tmp + 1);
1963       /* Note that `access' can lie to us if the directory resides on a
1964          read-only filesystem, like CD-ROM or a write-protected floppy.
1965          The only way to be really sure is to actually create a file and
1966          see if it succeeds.  But I think that's too much to ask.  */
1967
1968       /* MSVCRT's _access crashes with D_OK.  */
1969       if (tmp && faccessat (AT_FDCWD, tmp, D_OK, AT_EACCESS) == 0)
1970         {
1971           char * var = alloca (strlen (tmp) + 8);
1972           sprintf (var, "TMPDIR=%s", tmp);
1973           _putenv (strdup (var));
1974           break;
1975         }
1976     }
1977   if (i >= imax)
1978     cmd_error_internal
1979       (Fcons (Qerror,
1980               Fcons (build_string ("no usable temporary directories found!!"),
1981                      Qnil)),
1982        "While setting TMPDIR: ");
1983
1984   /* Check for environment variables and use registry settings if they
1985      don't exist.  Fallback on default values where applicable.  */
1986   {
1987     int i;
1988     LPBYTE lpval;
1989     DWORD dwType;
1990     char locale_name[32];
1991     char default_home[MAX_PATH];
1992     int appdata = 0;
1993
1994     static const struct env_entry
1995     {
1996       char * name;
1997       char * def_value;
1998     } dflt_envvars[] =
1999     {
2000       /* If the default value is NULL, we will use the value from the
2001          outside environment or the Registry, but will not push the
2002          variable into the Emacs environment if it is defined neither
2003          in the Registry nor in the outside environment.  */
2004       {"HOME", "C:/"},
2005       {"PRELOAD_WINSOCK", NULL},
2006       {"emacs_dir", "C:/emacs"},
2007       {"EMACSLOADPATH", NULL},
2008       {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
2009       {"EMACSDATA", NULL},
2010       {"EMACSPATH", NULL},
2011       {"INFOPATH", NULL},
2012       {"EMACSDOC", NULL},
2013       {"TERM", "cmd"},
2014       {"LANG", NULL},
2015     };
2016
2017 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2018
2019     /* We need to copy dflt_envvars[] and work on the copy because we
2020        don't want the dumped Emacs to inherit the values of
2021        environment variables we saw during dumping (which could be on
2022        a different system).  The defaults above must be left intact.  */
2023     struct env_entry env_vars[N_ENV_VARS];
2024
2025     for (i = 0; i < N_ENV_VARS; i++)
2026       env_vars[i] = dflt_envvars[i];
2027
2028     /* For backwards compatibility, check if a .emacs file exists in C:/
2029        If not, then we can try to default to the appdata directory under the
2030        user's profile, which is more likely to be writable.   */
2031     if (!check_existing ("C:/.emacs"))
2032       {
2033         HRESULT profile_result;
2034         /* Dynamically load ShGetFolderPath, as it won't exist on versions
2035            of Windows 95 and NT4 that have not been updated to include
2036            MSIE 5.  */
2037         ShGetFolderPath_fn get_folder_path;
2038         get_folder_path = (ShGetFolderPath_fn)
2039           GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2040
2041         if (get_folder_path != NULL)
2042           {
2043             profile_result = get_folder_path (NULL, CSIDL_APPDATA, NULL,
2044                                               0, default_home);
2045
2046             /* If we can't get the appdata dir, revert to old behavior.  */
2047             if (profile_result == S_OK)
2048               {
2049                 env_vars[0].def_value = default_home;
2050                 appdata = 1;
2051               }
2052           }
2053       }
2054
2055   /* Get default locale info and use it for LANG.  */
2056   if (GetLocaleInfo (LOCALE_USER_DEFAULT,
2057                      LOCALE_SABBREVLANGNAME | LOCALE_USE_CP_ACP,
2058                      locale_name, sizeof (locale_name)))
2059     {
2060       for (i = 0; i < N_ENV_VARS; i++)
2061         {
2062           if (strcmp (env_vars[i].name, "LANG") == 0)
2063             {
2064               env_vars[i].def_value = locale_name;
2065               break;
2066             }
2067         }
2068     }
2069
2070 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2071
2072     /* Treat emacs_dir specially: set it unconditionally based on our
2073        location.  */
2074     {
2075       char *p;
2076       char modname[MAX_PATH];
2077
2078       if (!GetModuleFileName (NULL, modname, MAX_PATH))
2079         emacs_abort ();
2080       if ((p = _mbsrchr (modname, '\\')) == NULL)
2081         emacs_abort ();
2082       *p = 0;
2083
2084       if ((p = _mbsrchr (modname, '\\')) && xstrcasecmp (p, "\\bin") == 0)
2085         {
2086           char buf[SET_ENV_BUF_SIZE];
2087
2088           *p = 0;
2089           for (p = modname; *p; p = CharNext (p))
2090             if (*p == '\\') *p = '/';
2091
2092           _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
2093           _putenv (strdup (buf));
2094         }
2095       /* Handle running emacs from the build directory: src/oo-spd/i386/  */
2096
2097       /* FIXME: should use substring of get_emacs_configuration ().
2098          But I don't think the Windows build supports alpha, mips etc
2099          anymore, so have taken the easy option for now.  */
2100       else if (p && (xstrcasecmp (p, "\\i386") == 0
2101                      || xstrcasecmp (p, "\\AMD64") == 0))
2102         {
2103           *p = 0;
2104           p = _mbsrchr (modname, '\\');
2105           if (p != NULL)
2106             {
2107               *p = 0;
2108               p = _mbsrchr (modname, '\\');
2109               if (p && xstrcasecmp (p, "\\src") == 0)
2110                 {
2111                   char buf[SET_ENV_BUF_SIZE];
2112
2113                   *p = 0;
2114                   for (p = modname; *p; p = CharNext (p))
2115                     if (*p == '\\') *p = '/';
2116
2117                   _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
2118                   _putenv (strdup (buf));
2119                 }
2120             }
2121         }
2122     }
2123
2124     for (i = 0; i < N_ENV_VARS; i++)
2125       {
2126         if (!getenv (env_vars[i].name))
2127           {
2128             int dont_free = 0;
2129
2130             if ((lpval = w32_get_resource (env_vars[i].name, &dwType)) == NULL
2131                 /* Also ignore empty environment variables.  */
2132                 || *lpval == 0)
2133               {
2134                 xfree (lpval);
2135                 lpval = env_vars[i].def_value;
2136                 dwType = REG_EXPAND_SZ;
2137                 dont_free = 1;
2138                 if (!strcmp (env_vars[i].name, "HOME") && !appdata)
2139                   Vdelayed_warnings_list
2140                     = Fcons (listn (CONSTYPE_HEAP, 2,
2141                                     intern ("initialization"),
2142                                     build_string ("Setting HOME to C:\\ by default is deprecated")),
2143                              Vdelayed_warnings_list);
2144               }
2145
2146             if (lpval)
2147               {
2148                 char buf1[SET_ENV_BUF_SIZE], buf2[SET_ENV_BUF_SIZE];
2149
2150                 if (dwType == REG_EXPAND_SZ)
2151                   ExpandEnvironmentStrings ((LPSTR) lpval, buf1, sizeof (buf1));
2152                 else if (dwType == REG_SZ)
2153                   strcpy (buf1, lpval);
2154                 if (dwType == REG_EXPAND_SZ || dwType == REG_SZ)
2155                   {
2156                     _snprintf (buf2, sizeof (buf2)-1, "%s=%s", env_vars[i].name,
2157                                buf1);
2158                     _putenv (strdup (buf2));
2159                   }
2160
2161                 if (!dont_free)
2162                   xfree (lpval);
2163               }
2164           }
2165       }
2166   }
2167
2168   /* Rebuild system configuration to reflect invoking system.  */
2169   Vsystem_configuration = build_string (EMACS_CONFIGURATION);
2170
2171   /* Another special case: on NT, the PATH variable is actually named
2172      "Path" although cmd.exe (perhaps NT itself) arranges for
2173      environment variable lookup and setting to be case insensitive.
2174      However, Emacs assumes a fully case sensitive environment, so we
2175      need to change "Path" to "PATH" to match the expectations of
2176      various elisp packages.  We do this by the sneaky method of
2177      modifying the string in the C runtime environ entry.
2178
2179      The same applies to COMSPEC.  */
2180   {
2181     char ** envp;
2182
2183     for (envp = environ; *envp; envp++)
2184       if (_strnicmp (*envp, "PATH=", 5) == 0)
2185         memcpy (*envp, "PATH=", 5);
2186       else if (_strnicmp (*envp, "COMSPEC=", 8) == 0)
2187         memcpy (*envp, "COMSPEC=", 8);
2188   }
2189
2190   /* Remember the initial working directory for getcwd.  */
2191   /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2192      Does it matter anywhere in Emacs?  */
2193   if (!GetCurrentDirectory (MAXPATHLEN, startup_dir))
2194     emacs_abort ();
2195
2196   {
2197     static char modname[MAX_PATH];
2198
2199     if (!GetModuleFileName (NULL, modname, MAX_PATH))
2200       emacs_abort ();
2201     argv[0] = modname;
2202   }
2203
2204   /* Determine if there is a middle mouse button, to allow parse_button
2205      to decide whether right mouse events should be mouse-2 or
2206      mouse-3. */
2207   w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
2208
2209   init_user_info ();
2210 }
2211
2212 /* Called from expand-file-name when default-directory is not a string.  */
2213
2214 char *
2215 emacs_root_dir (void)
2216 {
2217   static char root_dir[FILENAME_MAX];
2218   const char *p;
2219
2220   p = getenv ("emacs_dir");
2221   if (p == NULL)
2222     emacs_abort ();
2223   strcpy (root_dir, p);
2224   root_dir[parse_root (root_dir, NULL)] = '\0';
2225   dostounix_filename (root_dir);
2226   return root_dir;
2227 }
2228
2229 /* We don't have scripts to automatically determine the system configuration
2230    for Emacs before it's compiled, and we don't want to have to make the
2231    user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
2232    routine.  */
2233
2234 char *
2235 get_emacs_configuration (void)
2236 {
2237   char *arch, *oem, *os;
2238   int build_num;
2239   static char configuration_buffer[32];
2240
2241   /* Determine the processor type.  */
2242   switch (get_processor_type ())
2243     {
2244
2245 #ifdef PROCESSOR_INTEL_386
2246     case PROCESSOR_INTEL_386:
2247     case PROCESSOR_INTEL_486:
2248     case PROCESSOR_INTEL_PENTIUM:
2249 #ifdef _WIN64
2250       arch = "amd64";
2251 #else
2252       arch = "i386";
2253 #endif
2254       break;
2255 #endif
2256 #ifdef PROCESSOR_AMD_X8664
2257     case PROCESSOR_AMD_X8664:
2258       arch = "amd64";
2259       break;
2260 #endif
2261
2262 #ifdef PROCESSOR_MIPS_R2000
2263     case PROCESSOR_MIPS_R2000:
2264     case PROCESSOR_MIPS_R3000:
2265     case PROCESSOR_MIPS_R4000:
2266       arch = "mips";
2267       break;
2268 #endif
2269
2270 #ifdef PROCESSOR_ALPHA_21064
2271     case PROCESSOR_ALPHA_21064:
2272       arch = "alpha";
2273       break;
2274 #endif
2275
2276     default:
2277       arch = "unknown";
2278       break;
2279     }
2280
2281   /* Use the OEM field to reflect the compiler/library combination.  */
2282 #ifdef _MSC_VER
2283 #define COMPILER_NAME   "msvc"
2284 #else
2285 #ifdef __GNUC__
2286 #define COMPILER_NAME   "mingw"
2287 #else
2288 #define COMPILER_NAME   "unknown"
2289 #endif
2290 #endif
2291   oem = COMPILER_NAME;
2292
2293   switch (osinfo_cache.dwPlatformId) {
2294   case VER_PLATFORM_WIN32_NT:
2295     os = "nt";
2296     build_num = osinfo_cache.dwBuildNumber;
2297     break;
2298   case VER_PLATFORM_WIN32_WINDOWS:
2299     if (osinfo_cache.dwMinorVersion == 0) {
2300       os = "windows95";
2301     } else {
2302       os = "windows98";
2303     }
2304     build_num = LOWORD (osinfo_cache.dwBuildNumber);
2305     break;
2306   case VER_PLATFORM_WIN32s:
2307     /* Not supported, should not happen. */
2308     os = "windows32s";
2309     build_num = LOWORD (osinfo_cache.dwBuildNumber);
2310     break;
2311   default:
2312     os = "unknown";
2313     build_num = 0;
2314     break;
2315   }
2316
2317   if (osinfo_cache.dwPlatformId == VER_PLATFORM_WIN32_NT) {
2318     sprintf (configuration_buffer, "%s-%s-%s%d.%d.%d", arch, oem, os,
2319              get_w32_major_version (), get_w32_minor_version (), build_num);
2320   } else {
2321     sprintf (configuration_buffer, "%s-%s-%s.%d", arch, oem, os, build_num);
2322   }
2323
2324   return configuration_buffer;
2325 }
2326
2327 char *
2328 get_emacs_configuration_options (void)
2329 {
2330   static char *options_buffer;
2331   char cv[32];  /* Enough for COMPILER_VERSION.  */
2332   char *options[] = {
2333     cv,  /* To be filled later.  */
2334 #ifdef EMACSDEBUG
2335     " --no-opt",
2336 #endif
2337 #ifdef ENABLE_CHECKING
2338     " --enable-checking",
2339 #endif
2340     /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2341        with a starting space to save work here.  */
2342 #ifdef USER_CFLAGS
2343     " --cflags", USER_CFLAGS,
2344 #endif
2345 #ifdef USER_LDFLAGS
2346     " --ldflags", USER_LDFLAGS,
2347 #endif
2348     NULL
2349   };
2350   size_t size = 0;
2351   int i;
2352
2353 /* Work out the effective configure options for this build.  */
2354 #ifdef _MSC_VER
2355 #define COMPILER_VERSION        "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2356 #else
2357 #ifdef __GNUC__
2358 #define COMPILER_VERSION        "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2359 #else
2360 #define COMPILER_VERSION        ""
2361 #endif
2362 #endif
2363
2364   if (_snprintf (cv, sizeof (cv) - 1, COMPILER_VERSION) < 0)
2365     return "Error: not enough space for compiler version";
2366   cv[sizeof (cv) - 1] = '\0';
2367
2368   for (i = 0; options[i]; i++)
2369     size += strlen (options[i]);
2370
2371   options_buffer = xmalloc (size + 1);
2372   options_buffer[0] = '\0';
2373
2374   for (i = 0; options[i]; i++)
2375     strcat (options_buffer, options[i]);
2376
2377   return options_buffer;
2378 }
2379
2380
2381 #include <sys/timeb.h>
2382
2383 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95).  */
2384 void
2385 gettimeofday (struct timeval *tv, struct timezone *tz)
2386 {
2387   struct _timeb tb;
2388   _ftime (&tb);
2389
2390   tv->tv_sec = tb.time;
2391   tv->tv_usec = tb.millitm * 1000L;
2392   /* Implementation note: _ftime sometimes doesn't update the dstflag
2393      according to the new timezone when the system timezone is
2394      changed.  We could fix that by using GetSystemTime and
2395      GetTimeZoneInformation, but that doesn't seem necessary, since
2396      Emacs always calls gettimeofday with the 2nd argument NULL (see
2397      current_emacs_time).  */
2398   if (tz)
2399     {
2400       tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich  */
2401       tz->tz_dsttime = tb.dstflag;      /* type of dst correction  */
2402     }
2403 }
2404
2405 /* Emulate fdutimens.  */
2406
2407 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2408    TIMESPEC[0] and TIMESPEC[1], respectively.
2409    FD must be either negative -- in which case it is ignored --
2410    or a file descriptor that is open on FILE.
2411    If FD is nonnegative, then FILE can be NULL, which means
2412    use just futimes instead of utimes.
2413    If TIMESPEC is null, FAIL.
2414    Return 0 on success, -1 (setting errno) on failure.  */
2415
2416 int
2417 fdutimens (int fd, char const *file, struct timespec const timespec[2])
2418 {
2419   struct _utimbuf ut;
2420
2421   if (!timespec)
2422     {
2423       errno = ENOSYS;
2424       return -1;
2425     }
2426   if (fd < 0 && !file)
2427     {
2428       errno = EBADF;
2429       return -1;
2430     }
2431   ut.actime = timespec[0].tv_sec;
2432   ut.modtime = timespec[1].tv_sec;
2433   if (fd >= 0)
2434     return _futime (fd, &ut);
2435   else
2436     return _utime (file, &ut);
2437 }
2438
2439
2440 /* ------------------------------------------------------------------------- */
2441 /* IO support and wrapper functions for the Windows API. */
2442 /* ------------------------------------------------------------------------- */
2443
2444 /* Place a wrapper around the MSVC version of ctime.  It returns NULL
2445    on network directories, so we handle that case here.
2446    (Ulrich Leodolter, 1/11/95).  */
2447 char *
2448 sys_ctime (const time_t *t)
2449 {
2450   char *str = (char *) ctime (t);
2451   return (str ? str : "Sun Jan 01 00:00:00 1970");
2452 }
2453
2454 /* Emulate sleep...we could have done this with a define, but that
2455    would necessitate including windows.h in the files that used it.
2456    This is much easier.  */
2457 void
2458 sys_sleep (int seconds)
2459 {
2460   Sleep (seconds * 1000);
2461 }
2462
2463 /* Internal MSVC functions for low-level descriptor munging */
2464 extern int __cdecl _set_osfhnd (int fd, long h);
2465 extern int __cdecl _free_osfhnd (int fd);
2466
2467 /* parallel array of private info on file handles */
2468 filedesc fd_info [ MAXDESC ];
2469
2470 typedef struct volume_info_data {
2471   struct volume_info_data * next;
2472
2473   /* time when info was obtained */
2474   DWORD     timestamp;
2475
2476   /* actual volume info */
2477   char *    root_dir;
2478   DWORD     serialnum;
2479   DWORD     maxcomp;
2480   DWORD     flags;
2481   char *    name;
2482   char *    type;
2483 } volume_info_data;
2484
2485 /* Global referenced by various functions.  */
2486 static volume_info_data volume_info;
2487
2488 /* Vector to indicate which drives are local and fixed (for which cached
2489    data never expires).  */
2490 static BOOL fixed_drives[26];
2491
2492 /* Consider cached volume information to be stale if older than 10s,
2493    at least for non-local drives.  Info for fixed drives is never stale.  */
2494 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2495 #define VOLINFO_STILL_VALID( root_dir, info )           \
2496   ( ( isalpha (root_dir[0]) &&                          \
2497       fixed_drives[ DRIVE_INDEX (root_dir[0]) ] )       \
2498     || GetTickCount () - info->timestamp < 10000 )
2499
2500 /* Cache support functions.  */
2501
2502 /* Simple linked list with linear search is sufficient.  */
2503 static volume_info_data *volume_cache = NULL;
2504
2505 static volume_info_data *
2506 lookup_volume_info (char * root_dir)
2507 {
2508   volume_info_data * info;
2509
2510   for (info = volume_cache; info; info = info->next)
2511     if (xstrcasecmp (info->root_dir, root_dir) == 0)
2512       break;
2513   return info;
2514 }
2515
2516 static void
2517 add_volume_info (char * root_dir, volume_info_data * info)
2518 {
2519   info->root_dir = xstrdup (root_dir);
2520   info->next = volume_cache;
2521   volume_cache = info;
2522 }
2523
2524
2525 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2526    performance penalty (~2ms on 486 for local drives, 7.5ms for local
2527    cdrom drive, ~5-10ms or more for remote drives on LAN).  */
2528 static volume_info_data *
2529 GetCachedVolumeInformation (char * root_dir)
2530 {
2531   volume_info_data * info;
2532   char default_root[ MAX_PATH ];
2533
2534   /* NULL for root_dir means use root from current directory.  */
2535   if (root_dir == NULL)
2536     {
2537       if (GetCurrentDirectory (MAX_PATH, default_root) == 0)
2538         return NULL;
2539       parse_root (default_root, &root_dir);
2540       *root_dir = 0;
2541       root_dir = default_root;
2542     }
2543
2544   /* Local fixed drives can be cached permanently.  Removable drives
2545      cannot be cached permanently, since the volume name and serial
2546      number (if nothing else) can change.  Remote drives should be
2547      treated as if they are removable, since there is no sure way to
2548      tell whether they are or not.  Also, the UNC association of drive
2549      letters mapped to remote volumes can be changed at any time (even
2550      by other processes) without notice.
2551
2552      As a compromise, so we can benefit from caching info for remote
2553      volumes, we use a simple expiry mechanism to invalidate cache
2554      entries that are more than ten seconds old.  */
2555
2556 #if 0
2557   /* No point doing this, because WNetGetConnection is even slower than
2558      GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2559      GetDriveType is about the only call of this type which does not
2560      involve network access, and so is extremely quick).  */
2561
2562   /* Map drive letter to UNC if remote. */
2563   if (isalpha (root_dir[0]) && !fixed[DRIVE_INDEX (root_dir[0])])
2564     {
2565       char remote_name[ 256 ];
2566       char drive[3] = { root_dir[0], ':' };
2567
2568       if (WNetGetConnection (drive, remote_name, sizeof (remote_name))
2569           == NO_ERROR)
2570         /* do something */ ;
2571     }
2572 #endif
2573
2574   info = lookup_volume_info (root_dir);
2575
2576   if (info == NULL || ! VOLINFO_STILL_VALID (root_dir, info))
2577     {
2578       char  name[ 256 ];
2579       DWORD serialnum;
2580       DWORD maxcomp;
2581       DWORD flags;
2582       char  type[ 256 ];
2583
2584       /* Info is not cached, or is stale. */
2585       if (!GetVolumeInformation (root_dir,
2586                                  name, sizeof (name),
2587                                  &serialnum,
2588                                  &maxcomp,
2589                                  &flags,
2590                                  type, sizeof (type)))
2591         return NULL;
2592
2593       /* Cache the volume information for future use, overwriting existing
2594          entry if present.  */
2595       if (info == NULL)
2596         {
2597           info = xmalloc (sizeof (volume_info_data));
2598           add_volume_info (root_dir, info);
2599         }
2600       else
2601         {
2602           xfree (info->name);
2603           xfree (info->type);
2604         }
2605
2606       info->name = xstrdup (name);
2607       info->serialnum = serialnum;
2608       info->maxcomp = maxcomp;
2609       info->flags = flags;
2610       info->type = xstrdup (type);
2611       info->timestamp = GetTickCount ();
2612     }
2613
2614   return info;
2615 }
2616
2617 /* Get information on the volume where NAME is held; set path pointer to
2618    start of pathname in NAME (past UNC header\volume header if present),
2619    if pPath is non-NULL.
2620
2621    Note: if NAME includes symlinks, the information is for the volume
2622    of the symlink, not of its target.  That's because, even though
2623    GetVolumeInformation returns information about the symlink target
2624    of its argument, we only pass the root directory to
2625    GetVolumeInformation, not the full NAME.  */
2626 static int
2627 get_volume_info (const char * name, const char ** pPath)
2628 {
2629   char temp[MAX_PATH];
2630   char *rootname = NULL;  /* default to current volume */
2631   volume_info_data * info;
2632
2633   if (name == NULL)
2634     return FALSE;
2635
2636   /* Find the root name of the volume if given.  */
2637   if (isalpha (name[0]) && name[1] == ':')
2638     {
2639       rootname = temp;
2640       temp[0] = *name++;
2641       temp[1] = *name++;
2642       temp[2] = '\\';
2643       temp[3] = 0;
2644     }
2645   else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
2646     {
2647       char *str = temp;
2648       int slashes = 4;
2649       int dbcs_p = max_filename_mbslen () > 1;
2650
2651       rootname = temp;
2652       do
2653         {
2654           if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
2655             break;
2656           if (!dbcs_p)
2657             *str++ = *name++;
2658           else
2659             {
2660               const char *p = name;
2661
2662               name = CharNextExA (file_name_codepage, name, 0);
2663               memcpy (str, p, name - p);
2664               str += name - p;
2665             }
2666         }
2667       while ( *name );
2668
2669       *str++ = '\\';
2670       *str = 0;
2671     }
2672
2673   if (pPath)
2674     *pPath = name;
2675
2676   info = GetCachedVolumeInformation (rootname);
2677   if (info != NULL)
2678     {
2679       /* Set global referenced by other functions.  */
2680       volume_info = *info;
2681       return TRUE;
2682     }
2683   return FALSE;
2684 }
2685
2686 /* Determine if volume is FAT format (ie. only supports short 8.3
2687    names); also set path pointer to start of pathname in name, if
2688    pPath is non-NULL.  */
2689 static int
2690 is_fat_volume (const char * name, const char ** pPath)
2691 {
2692   if (get_volume_info (name, pPath))
2693     return (volume_info.maxcomp == 12);
2694   return FALSE;
2695 }
2696
2697 /* Map filename to a valid 8.3 name if necessary.
2698    The result is a pointer to a static buffer, so CAVEAT EMPTOR!  */
2699 const char *
2700 map_w32_filename (const char * name, const char ** pPath)
2701 {
2702   static char shortname[MAX_PATH];
2703   char * str = shortname;
2704   char c;
2705   char * path;
2706   const char * save_name = name;
2707
2708   if (strlen (name) >= MAX_PATH)
2709     {
2710       /* Return a filename which will cause callers to fail.  */
2711       strcpy (shortname, "?");
2712       return shortname;
2713     }
2714
2715   if (is_fat_volume (name, (const char **)&path)) /* truncate to 8.3 */
2716     {
2717       register int left = 8;    /* maximum number of chars in part */
2718       register int extn = 0;    /* extension added? */
2719       register int dots = 2;    /* maximum number of dots allowed */
2720
2721       while (name < path)
2722         *str++ = *name++;       /* skip past UNC header */
2723
2724       while ((c = *name++))
2725         {
2726           switch ( c )
2727             {
2728             case ':':
2729             case '\\':
2730             case '/':
2731               *str++ = (c == ':' ? ':' : '\\');
2732               extn = 0;         /* reset extension flags */
2733               dots = 2;         /* max 2 dots */
2734               left = 8;         /* max length 8 for main part */
2735               break;
2736             case '.':
2737               if ( dots )
2738                 {
2739                   /* Convert path components of the form .xxx to _xxx,
2740                      but leave . and .. as they are.  This allows .emacs
2741                      to be read as _emacs, for example.  */
2742
2743                   if (! *name ||
2744                       *name == '.' ||
2745                       IS_DIRECTORY_SEP (*name))
2746                     {
2747                       *str++ = '.';
2748                       dots--;
2749                     }
2750                   else
2751                     {
2752                       *str++ = '_';
2753                       left--;
2754                       dots = 0;
2755                     }
2756                 }
2757               else if ( !extn )
2758                 {
2759                   *str++ = '.';
2760                   extn = 1;             /* we've got an extension */
2761                   left = 3;             /* 3 chars in extension */
2762                 }
2763               else
2764                 {
2765                   /* any embedded dots after the first are converted to _ */
2766                   *str++ = '_';
2767                 }
2768               break;
2769             case '~':
2770             case '#':                   /* don't lose these, they're important */
2771               if ( ! left )
2772                 str[-1] = c;            /* replace last character of part */
2773               /* FALLTHRU */
2774             default:
2775               if ( left )
2776                 {
2777                   *str++ = tolower (c); /* map to lower case (looks nicer) */
2778                   left--;
2779                   dots = 0;             /* started a path component */
2780                 }
2781               break;
2782             }
2783         }
2784       *str = '\0';
2785     }
2786   else
2787     {
2788       strcpy (shortname, name);
2789       unixtodos_filename (shortname);
2790     }
2791
2792   if (pPath)
2793     *pPath = shortname + (path - save_name);
2794
2795   return shortname;
2796 }
2797
2798 static int
2799 is_exec (const char * name)
2800 {
2801   char * p = strrchr (name, '.');
2802   return
2803     (p != NULL
2804      && (xstrcasecmp (p, ".exe") == 0 ||
2805          xstrcasecmp (p, ".com") == 0 ||
2806          xstrcasecmp (p, ".bat") == 0 ||
2807          xstrcasecmp (p, ".cmd") == 0));
2808 }
2809
2810 /* Emulate the Unix directory procedures opendir, closedir,
2811    and readdir.  We can't use the procedures supplied in sysdep.c,
2812    so we provide them here.  */
2813
2814 struct dirent dir_static;       /* simulated directory contents */
2815 static HANDLE dir_find_handle = INVALID_HANDLE_VALUE;
2816 static int    dir_is_fat;
2817 static char   dir_pathname[MAXPATHLEN+1];
2818 static WIN32_FIND_DATA dir_find_data;
2819
2820 /* Support shares on a network resource as subdirectories of a read-only
2821    root directory. */
2822 static HANDLE wnet_enum_handle = INVALID_HANDLE_VALUE;
2823 static HANDLE open_unc_volume (const char *);
2824 static char  *read_unc_volume (HANDLE, char *, int);
2825 static void   close_unc_volume (HANDLE);
2826
2827 DIR *
2828 opendir (const char *filename)
2829 {
2830   DIR *dirp;
2831
2832   /* Opening is done by FindFirstFile.  However, a read is inherent to
2833      this operation, so we defer the open until read time.  */
2834
2835   if (dir_find_handle != INVALID_HANDLE_VALUE)
2836     return NULL;
2837   if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2838     return NULL;
2839
2840   /* Note: We don't support traversal of UNC volumes via symlinks.
2841      Doing so would mean punishing 99.99% of use cases by resolving
2842      all the possible symlinks in FILENAME, recursively. */
2843   if (is_unc_volume (filename))
2844     {
2845       wnet_enum_handle = open_unc_volume (filename);
2846       if (wnet_enum_handle == INVALID_HANDLE_VALUE)
2847         return NULL;
2848     }
2849
2850   if (!(dirp = (DIR *) malloc (sizeof (DIR))))
2851     return NULL;
2852
2853   dirp->dd_fd = 0;
2854   dirp->dd_loc = 0;
2855   dirp->dd_size = 0;
2856
2857   strncpy (dir_pathname, map_w32_filename (filename, NULL), MAXPATHLEN);
2858   dir_pathname[MAXPATHLEN] = '\0';
2859   /* Note: We don't support symlinks to file names on FAT volumes.
2860      Doing so would mean punishing 99.99% of use cases by resolving
2861      all the possible symlinks in FILENAME, recursively.  */
2862   dir_is_fat = is_fat_volume (filename, NULL);
2863
2864   return dirp;
2865 }
2866
2867 void
2868 closedir (DIR *dirp)
2869 {
2870   /* If we have a find-handle open, close it.  */
2871   if (dir_find_handle != INVALID_HANDLE_VALUE)
2872     {
2873       FindClose (dir_find_handle);
2874       dir_find_handle = INVALID_HANDLE_VALUE;
2875     }
2876   else if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2877     {
2878       close_unc_volume (wnet_enum_handle);
2879       wnet_enum_handle = INVALID_HANDLE_VALUE;
2880     }
2881   xfree ((char *) dirp);
2882 }
2883
2884 struct dirent *
2885 readdir (DIR *dirp)
2886 {
2887   int downcase = !NILP (Vw32_downcase_file_names);
2888
2889   if (wnet_enum_handle != INVALID_HANDLE_VALUE)
2890     {
2891       if (!read_unc_volume (wnet_enum_handle,
2892                             dir_find_data.cFileName,
2893                             MAX_PATH))
2894         return NULL;
2895     }
2896   /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2897   else if (dir_find_handle == INVALID_HANDLE_VALUE)
2898     {
2899       char filename[MAXNAMLEN + 3];
2900       int ln;
2901       int dbcs_p = max_filename_mbslen () > 1;
2902
2903       strcpy (filename, dir_pathname);
2904       ln = strlen (filename) - 1;
2905       if (!dbcs_p)
2906         {
2907           if (!IS_DIRECTORY_SEP (filename[ln]))
2908             strcat (filename, "\\");
2909         }
2910       else
2911         {
2912           char *end = filename + ln + 1;
2913           char *last_char = CharPrevExA (file_name_codepage, filename, end, 0);
2914
2915           if (!IS_DIRECTORY_SEP (*last_char))
2916             strcat (filename, "\\");
2917         }
2918       strcat (filename, "*");
2919
2920       /* Note: No need to resolve symlinks in FILENAME, because
2921          FindFirst opens the directory that is the target of a
2922          symlink.  */
2923       dir_find_handle = FindFirstFile (filename, &dir_find_data);
2924
2925       if (dir_find_handle == INVALID_HANDLE_VALUE)
2926         return NULL;
2927     }
2928   else
2929     {
2930       if (!FindNextFile (dir_find_handle, &dir_find_data))
2931         return NULL;
2932     }
2933
2934   /* Emacs never uses this value, so don't bother making it match
2935      value returned by stat().  */
2936   dir_static.d_ino = 1;
2937
2938   strcpy (dir_static.d_name, dir_find_data.cFileName);
2939
2940   /* If the file name in cFileName[] includes `?' characters, it means
2941      the original file name used characters that cannot be represented
2942      by the current ANSI codepage.  To avoid total lossage, retrieve
2943      the short 8+3 alias of the long file name.  */
2944   if (_mbspbrk (dir_static.d_name, "?"))
2945     {
2946       strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2947       downcase = 1;     /* 8+3 aliases are returned in all caps */
2948     }
2949   dir_static.d_namlen = strlen (dir_static.d_name);
2950   dir_static.d_reclen = sizeof (struct dirent) - MAXNAMLEN + 3 +
2951     dir_static.d_namlen - dir_static.d_namlen % 4;
2952
2953   /* If the file name in cFileName[] includes `?' characters, it means
2954      the original file name used characters that cannot be represented
2955      by the current ANSI codepage.  To avoid total lossage, retrieve
2956      the short 8+3 alias of the long file name.  */
2957   if (_mbspbrk (dir_find_data.cFileName, "?"))
2958     {
2959       strcpy (dir_static.d_name, dir_find_data.cAlternateFileName);
2960       /* 8+3 aliases are returned in all caps, which could break
2961          various alists that look at filenames' extensions.  */
2962       downcase = 1;
2963     }
2964   else
2965     strcpy (dir_static.d_name, dir_find_data.cFileName);
2966   dir_static.d_namlen = strlen (dir_static.d_name);
2967   if (dir_is_fat)
2968     _mbslwr (dir_static.d_name);
2969   else if (downcase)
2970     {
2971       register char *p;
2972       int dbcs_p = max_filename_mbslen () > 1;
2973       for (p = dir_static.d_name; *p; )
2974         {
2975           if (*p >= 'a' && *p <= 'z')
2976             break;
2977           if (dbcs_p)
2978             p = CharNextExA (file_name_codepage, p, 0);
2979           else
2980             p++;
2981         }
2982       if (!*p)
2983         _mbslwr (dir_static.d_name);
2984     }
2985
2986   return &dir_static;
2987 }
2988
2989 static HANDLE
2990 open_unc_volume (const char *path)
2991 {
2992   NETRESOURCE nr;
2993   HANDLE henum;
2994   int result;
2995
2996   nr.dwScope = RESOURCE_GLOBALNET;
2997   nr.dwType = RESOURCETYPE_DISK;
2998   nr.dwDisplayType = RESOURCEDISPLAYTYPE_SERVER;
2999   nr.dwUsage = RESOURCEUSAGE_CONTAINER;
3000   nr.lpLocalName = NULL;
3001   nr.lpRemoteName = (LPSTR)map_w32_filename (path, NULL);
3002   nr.lpComment = NULL;
3003   nr.lpProvider = NULL;
3004
3005   result = WNetOpenEnum (RESOURCE_GLOBALNET, RESOURCETYPE_DISK,
3006                          RESOURCEUSAGE_CONNECTABLE, &nr, &henum);
3007
3008   if (result == NO_ERROR)
3009     return henum;
3010   else
3011     return INVALID_HANDLE_VALUE;
3012 }
3013
3014 static char *
3015 read_unc_volume (HANDLE henum, char *readbuf, int size)
3016 {
3017   DWORD count;
3018   int result;
3019   DWORD bufsize = 512;
3020   char *buffer;
3021   char *ptr;
3022   int dbcs_p = max_filename_mbslen () > 1;
3023
3024   count = 1;
3025   buffer = alloca (bufsize);
3026   result = WNetEnumResource (henum, &count, buffer, &bufsize);
3027   if (result != NO_ERROR)
3028     return NULL;
3029
3030   /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3031   ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
3032   ptr += 2;
3033   if (!dbcs_p)
3034     while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
3035   else
3036     {
3037       while (*ptr && !IS_DIRECTORY_SEP (*ptr))
3038         ptr = CharNextExA (file_name_codepage, ptr, 0);
3039     }
3040   ptr++;
3041
3042   strncpy (readbuf, ptr, size);
3043   return readbuf;
3044 }
3045
3046 static void
3047 close_unc_volume (HANDLE henum)
3048 {
3049   if (henum != INVALID_HANDLE_VALUE)
3050     WNetCloseEnum (henum);
3051 }
3052
3053 static DWORD
3054 unc_volume_file_attributes (const char *path)
3055 {
3056   HANDLE henum;
3057   DWORD attrs;
3058
3059   henum = open_unc_volume (path);
3060   if (henum == INVALID_HANDLE_VALUE)
3061     return -1;
3062
3063   attrs = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY;
3064
3065   close_unc_volume (henum);
3066
3067   return attrs;
3068 }
3069
3070 /* Ensure a network connection is authenticated.  */
3071 static void
3072 logon_network_drive (const char *path)
3073 {
3074   NETRESOURCE resource;
3075   char share[MAX_PATH];
3076   int n_slashes;
3077   char drive[4];
3078   UINT drvtype;
3079   char *p;
3080   int dbcs_p;
3081
3082   if (IS_DIRECTORY_SEP (path[0]) && IS_DIRECTORY_SEP (path[1]))
3083     drvtype = DRIVE_REMOTE;
3084   else if (path[0] == '\0' || path[1] != ':')
3085     drvtype = GetDriveType (NULL);
3086   else
3087     {
3088       drive[0] = path[0];
3089       drive[1] = ':';
3090       drive[2] = '\\';
3091       drive[3] = '\0';
3092       drvtype = GetDriveType (drive);
3093     }
3094
3095   /* Only logon to networked drives.  */
3096   if (drvtype != DRIVE_REMOTE)
3097     return;
3098
3099   n_slashes = 2;
3100   strncpy (share, path, MAX_PATH);
3101   /* Truncate to just server and share name.  */
3102   dbcs_p = max_filename_mbslen () > 1;
3103   for (p = share + 2; *p && p < share + MAX_PATH; )
3104     {
3105       if (IS_DIRECTORY_SEP (*p) && ++n_slashes > 3)
3106         {
3107           *p = '\0';
3108           break;
3109         }
3110       if (dbcs_p)
3111         p = CharNextExA (file_name_codepage, p, 0);
3112       else
3113         p++;
3114     }
3115
3116   resource.dwType = RESOURCETYPE_DISK;
3117   resource.lpLocalName = NULL;
3118   resource.lpRemoteName = share;
3119   resource.lpProvider = NULL;
3120
3121   WNetAddConnection2 (&resource, NULL, NULL, CONNECT_INTERACTIVE);
3122 }
3123
3124 /* Emulate faccessat(2).  */
3125 int
3126 faccessat (int dirfd, const char * path, int mode, int flags)
3127 {
3128   DWORD attributes;
3129
3130   if (dirfd != AT_FDCWD
3131       && !(IS_DIRECTORY_SEP (path[0])
3132            || IS_DEVICE_SEP (path[1])))
3133     {
3134       errno = EBADF;
3135       return -1;
3136     }
3137
3138   /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3139      newer versions blow up when passed D_OK.  */
3140   path = map_w32_filename (path, NULL);
3141   /* If the last element of PATH is a symlink, we need to resolve it
3142      to get the attributes of its target file.  Note: any symlinks in
3143      PATH elements other than the last one are transparently resolved
3144      by GetFileAttributes below.  */
3145   if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0
3146       && (flags & AT_SYMLINK_NOFOLLOW) == 0)
3147     path = chase_symlinks (path);
3148
3149   if ((attributes = GetFileAttributes (path)) == -1)
3150     {
3151       DWORD w32err = GetLastError ();
3152
3153       switch (w32err)
3154         {
3155         case ERROR_INVALID_NAME:
3156         case ERROR_BAD_PATHNAME:
3157           if (is_unc_volume (path))
3158             {
3159               attributes = unc_volume_file_attributes (path);
3160               if (attributes == -1)
3161                 {
3162                   errno = EACCES;
3163                   return -1;
3164                 }
3165               break;
3166             }
3167           /* FALLTHROUGH */
3168         case ERROR_FILE_NOT_FOUND:
3169         case ERROR_BAD_NETPATH:
3170           errno = ENOENT;
3171           break;
3172         default:
3173           errno = EACCES;
3174           break;
3175         }
3176       return -1;
3177     }
3178   if ((mode & X_OK) != 0
3179       && !(is_exec (path) || (attributes & FILE_ATTRIBUTE_DIRECTORY) != 0))
3180     {
3181       errno = EACCES;
3182       return -1;
3183     }
3184   if ((mode & W_OK) != 0 && (attributes & FILE_ATTRIBUTE_READONLY) != 0)
3185     {
3186       errno = EACCES;
3187       return -1;
3188     }
3189   if ((mode & D_OK) != 0 && (attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
3190     {
3191       errno = EACCES;
3192       return -1;
3193     }
3194   return 0;
3195 }
3196
3197 /* Shadow some MSVC runtime functions to map requests for long filenames
3198    to reasonable short names if necessary.  This was originally added to
3199    permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3200    long file names.  */
3201
3202 int
3203 sys_chdir (const char * path)
3204 {
3205   return _chdir (map_w32_filename (path, NULL));
3206 }
3207
3208 int
3209 sys_chmod (const char * path, int mode)
3210 {
3211   path = chase_symlinks (map_w32_filename (path, NULL));
3212   return _chmod (path, mode);
3213 }
3214
3215 int
3216 sys_chown (const char *path, uid_t owner, gid_t group)
3217 {
3218   if (sys_chmod (path, S_IREAD) == -1) /* check if file exists */
3219     return -1;
3220   return 0;
3221 }
3222
3223 int
3224 sys_creat (const char * path, int mode)
3225 {
3226   return _creat (map_w32_filename (path, NULL), mode);
3227 }
3228
3229 FILE *
3230 sys_fopen (const char * path, const char * mode)
3231 {
3232   int fd;
3233   int oflag;
3234   const char * mode_save = mode;
3235
3236   /* Force all file handles to be non-inheritable.  This is necessary to
3237      ensure child processes don't unwittingly inherit handles that might
3238      prevent future file access. */
3239
3240   if (mode[0] == 'r')
3241     oflag = O_RDONLY;
3242   else if (mode[0] == 'w' || mode[0] == 'a')
3243     oflag = O_WRONLY | O_CREAT | O_TRUNC;
3244   else
3245     return NULL;
3246
3247   /* Only do simplistic option parsing. */
3248   while (*++mode)
3249     if (mode[0] == '+')
3250       {
3251         oflag &= ~(O_RDONLY | O_WRONLY);
3252         oflag |= O_RDWR;
3253       }
3254     else if (mode[0] == 'b')
3255       {
3256         oflag &= ~O_TEXT;
3257         oflag |= O_BINARY;
3258       }
3259     else if (mode[0] == 't')
3260       {
3261         oflag &= ~O_BINARY;
3262         oflag |= O_TEXT;
3263       }
3264     else break;
3265
3266   fd = _open (map_w32_filename (path, NULL), oflag | _O_NOINHERIT, 0644);
3267   if (fd < 0)
3268     return NULL;
3269
3270   return _fdopen (fd, mode_save);
3271 }
3272
3273 /* This only works on NTFS volumes, but is useful to have.  */
3274 int
3275 sys_link (const char * old, const char * new)
3276 {
3277   HANDLE fileh;
3278   int   result = -1;
3279   char oldname[MAX_PATH], newname[MAX_PATH];
3280
3281   if (old == NULL || new == NULL)
3282     {
3283       errno = ENOENT;
3284       return -1;
3285     }
3286
3287   strcpy (oldname, map_w32_filename (old, NULL));
3288   strcpy (newname, map_w32_filename (new, NULL));
3289
3290   fileh = CreateFile (oldname, 0, 0, NULL, OPEN_EXISTING,
3291                       FILE_FLAG_BACKUP_SEMANTICS, NULL);
3292   if (fileh != INVALID_HANDLE_VALUE)
3293     {
3294       int wlen;
3295
3296       /* Confusingly, the "alternate" stream name field does not apply
3297          when restoring a hard link, and instead contains the actual
3298          stream data for the link (ie. the name of the link to create).
3299          The WIN32_STREAM_ID structure before the cStreamName field is
3300          the stream header, which is then immediately followed by the
3301          stream data.  */
3302
3303       struct {
3304         WIN32_STREAM_ID wid;
3305         WCHAR wbuffer[MAX_PATH];        /* extra space for link name */
3306       } data;
3307
3308       wlen = MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, newname, -1,
3309                                   data.wid.cStreamName, MAX_PATH);
3310       if (wlen > 0)
3311         {
3312           LPVOID context = NULL;
3313           DWORD wbytes = 0;
3314
3315           data.wid.dwStreamId = BACKUP_LINK;
3316           data.wid.dwStreamAttributes = 0;
3317           data.wid.Size.LowPart = wlen * sizeof (WCHAR);
3318           data.wid.Size.HighPart = 0;
3319           data.wid.dwStreamNameSize = 0;
3320
3321           if (BackupWrite (fileh, (LPBYTE)&data,
3322                            offsetof (WIN32_STREAM_ID, cStreamName)
3323                            + data.wid.Size.LowPart,
3324                            &wbytes, FALSE, FALSE, &context)
3325               && BackupWrite (fileh, NULL, 0, &wbytes, TRUE, FALSE, &context))
3326             {
3327               /* succeeded */
3328               result = 0;
3329             }
3330           else
3331             {
3332               /* Should try mapping GetLastError to errno; for now just
3333                  indicate a general error (eg. links not supported).  */
3334               errno = EINVAL;  // perhaps EMLINK?
3335             }
3336         }
3337
3338       CloseHandle (fileh);
3339     }
3340   else
3341     errno = ENOENT;
3342
3343   return result;
3344 }
3345
3346 int
3347 sys_mkdir (const char * path)
3348 {
3349   return _mkdir (map_w32_filename (path, NULL));
3350 }
3351
3352 /* Because of long name mapping issues, we need to implement this
3353    ourselves.  Also, MSVC's _mktemp returns NULL when it can't generate
3354    a unique name, instead of setting the input template to an empty
3355    string.
3356
3357    Standard algorithm seems to be use pid or tid with a letter on the
3358    front (in place of the 6 X's) and cycle through the letters to find a
3359    unique name.  We extend that to allow any reasonable character as the
3360    first of the 6 X's.  */
3361 char *
3362 sys_mktemp (char * template)
3363 {
3364   char * p;
3365   int i;
3366   unsigned uid = GetCurrentThreadId ();
3367   static char first_char[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3368
3369   if (template == NULL)
3370     return NULL;
3371   p = template + strlen (template);
3372   i = 5;
3373   /* replace up to the last 5 X's with uid in decimal */
3374   while (--p >= template && p[0] == 'X' && --i >= 0)
3375     {
3376       p[0] = '0' + uid % 10;
3377       uid /= 10;
3378     }
3379
3380   if (i < 0 && p[0] == 'X')
3381     {
3382       i = 0;
3383       do
3384         {
3385           int save_errno = errno;
3386           p[0] = first_char[i];
3387           if (faccessat (AT_FDCWD, template, F_OK, AT_EACCESS) < 0)
3388             {
3389               errno = save_errno;
3390               return template;
3391             }
3392         }
3393       while (++i < sizeof (first_char));
3394     }
3395
3396   /* Template is badly formed or else we can't generate a unique name,
3397      so return empty string */
3398   template[0] = 0;
3399   return template;
3400 }
3401
3402 int
3403 sys_open (const char * path, int oflag, int mode)
3404 {
3405   const char* mpath = map_w32_filename (path, NULL);
3406   /* Try to open file without _O_CREAT, to be able to write to hidden
3407      and system files. Force all file handles to be
3408      non-inheritable. */
3409   int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
3410   if (res < 0)
3411     res = _open (mpath, oflag | _O_NOINHERIT, mode);
3412   if (res >= 0 && res < MAXDESC)
3413     fd_info[res].flags = 0;
3414
3415   return res;
3416 }
3417
3418 int
3419 sys_rename (const char * oldname, const char * newname)
3420 {
3421   BOOL result;
3422   char temp[MAX_PATH];
3423   int newname_dev;
3424   int oldname_dev;
3425
3426   /* MoveFile on Windows 95 doesn't correctly change the short file name
3427      alias in a number of circumstances (it is not easy to predict when
3428      just by looking at oldname and newname, unfortunately).  In these
3429      cases, renaming through a temporary name avoids the problem.
3430
3431      A second problem on Windows 95 is that renaming through a temp name when
3432      newname is uppercase fails (the final long name ends up in
3433      lowercase, although the short alias might be uppercase) UNLESS the
3434      long temp name is not 8.3.
3435
3436      So, on Windows 95 we always rename through a temp name, and we make sure
3437      the temp name has a long extension to ensure correct renaming.  */
3438
3439   strcpy (temp, map_w32_filename (oldname, NULL));
3440
3441   /* volume_info is set indirectly by map_w32_filename.  */
3442   oldname_dev = volume_info.serialnum;
3443
3444   if (os_subtype == OS_9X)
3445     {
3446       char * o;
3447       char * p;
3448       int    i = 0;
3449
3450       oldname = map_w32_filename (oldname, NULL);
3451       if ((o = strrchr (oldname, '\\')))
3452         o++;
3453       else
3454         o = (char *) oldname;
3455
3456       if ((p = strrchr (temp, '\\')))
3457         p++;
3458       else
3459         p = temp;
3460
3461       do
3462         {
3463           /* Force temp name to require a manufactured 8.3 alias - this
3464              seems to make the second rename work properly.  */
3465           sprintf (p, "_.%s.%u", o, i);
3466           i++;
3467           result = rename (oldname, temp);
3468         }
3469       /* This loop must surely terminate!  */
3470       while (result < 0 && errno == EEXIST);
3471       if (result < 0)
3472         return -1;
3473     }
3474
3475   /* Emulate Unix behavior - newname is deleted if it already exists
3476      (at least if it is a file; don't do this for directories).
3477
3478      Since we mustn't do this if we are just changing the case of the
3479      file name (we would end up deleting the file we are trying to
3480      rename!), we let rename detect if the destination file already
3481      exists - that way we avoid the possible pitfalls of trying to
3482      determine ourselves whether two names really refer to the same
3483      file, which is not always possible in the general case.  (Consider
3484      all the permutations of shared or subst'd drives, etc.)  */
3485
3486   newname = map_w32_filename (newname, NULL);
3487
3488   /* volume_info is set indirectly by map_w32_filename.  */
3489   newname_dev = volume_info.serialnum;
3490
3491   result = rename (temp, newname);
3492
3493   if (result < 0)
3494     {
3495       DWORD w32err = GetLastError ();
3496
3497       if (errno == EACCES
3498           && newname_dev != oldname_dev)
3499         {
3500           /* The implementation of `rename' on Windows does not return
3501              errno = EXDEV when you are moving a directory to a
3502              different storage device (ex. logical disk).  It returns
3503              EACCES instead.  So here we handle such situations and
3504              return EXDEV.  */
3505           DWORD attributes;
3506
3507           if ((attributes = GetFileAttributes (temp)) != -1
3508               && (attributes & FILE_ATTRIBUTE_DIRECTORY))
3509             errno = EXDEV;
3510         }
3511       else if (errno == EEXIST)
3512         {
3513           if (_chmod (newname, 0666) != 0)
3514             return result;
3515           if (_unlink (newname) != 0)
3516             return result;
3517           result = rename (temp, newname);
3518         }
3519       else if (w32err == ERROR_PRIVILEGE_NOT_HELD
3520                && is_symlink (temp))
3521         {
3522           /* This is Windows prohibiting the user from creating a
3523              symlink in another place, since that requires
3524              privileges.  */
3525           errno = EPERM;
3526         }
3527     }
3528
3529   return result;
3530 }
3531
3532 int
3533 sys_rmdir (const char * path)
3534 {
3535   return _rmdir (map_w32_filename (path, NULL));
3536 }
3537
3538 int
3539 sys_unlink (const char * path)
3540 {
3541   path = map_w32_filename (path, NULL);
3542
3543   /* On Unix, unlink works without write permission. */
3544   _chmod (path, 0666);
3545   return _unlink (path);
3546 }
3547
3548 static FILETIME utc_base_ft;
3549 static ULONGLONG utc_base;  /* In 100ns units */
3550 static int init = 0;
3551
3552 #define FILETIME_TO_U64(result, ft)        \
3553   do {                                     \
3554     ULARGE_INTEGER uiTemp;                 \
3555     uiTemp.LowPart = (ft).dwLowDateTime;   \
3556     uiTemp.HighPart = (ft).dwHighDateTime; \
3557     result = uiTemp.QuadPart;              \
3558   } while (0)
3559
3560 static void
3561 initialize_utc_base (void)
3562 {
3563   /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3564   SYSTEMTIME st;
3565
3566   st.wYear = 1970;
3567   st.wMonth = 1;
3568   st.wDay = 1;
3569   st.wHour = 0;
3570   st.wMinute = 0;
3571   st.wSecond = 0;
3572   st.wMilliseconds = 0;
3573
3574   SystemTimeToFileTime (&st, &utc_base_ft);
3575   FILETIME_TO_U64 (utc_base, utc_base_ft);
3576 }
3577
3578 static time_t
3579 convert_time (FILETIME ft)
3580 {
3581   ULONGLONG tmp;
3582
3583   if (!init)
3584     {
3585       initialize_utc_base ();
3586       init = 1;
3587     }
3588
3589   if (CompareFileTime (&ft, &utc_base_ft) < 0)
3590     return 0;
3591
3592   FILETIME_TO_U64 (tmp, ft);
3593   return (time_t) ((tmp - utc_base) / 10000000L);
3594 }
3595
3596 static void
3597 convert_from_time_t (time_t time, FILETIME * pft)
3598 {
3599   ULARGE_INTEGER tmp;
3600
3601   if (!init)
3602     {
3603       initialize_utc_base ();
3604       init = 1;
3605     }
3606
3607   /* time in 100ns units since 1-Jan-1601 */
3608   tmp.QuadPart = (ULONGLONG) time * 10000000L + utc_base;
3609   pft->dwHighDateTime = tmp.HighPart;
3610   pft->dwLowDateTime = tmp.LowPart;
3611 }
3612
3613 #if 0
3614 /* No reason to keep this; faking inode values either by hashing or even
3615    using the file index from GetInformationByHandle, is not perfect and
3616    so by default Emacs doesn't use the inode values on Windows.
3617    Instead, we now determine file-truename correctly (except for
3618    possible drive aliasing etc).  */
3619
3620 /*  Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3621 static unsigned
3622 hashval (const unsigned char * str)
3623 {
3624   unsigned h = 0;
3625   while (*str)
3626     {
3627       h = (h << 4) + *str++;
3628       h ^= (h >> 28);
3629     }
3630   return h;
3631 }
3632
3633 /* Return the hash value of the canonical pathname, excluding the
3634    drive/UNC header, to get a hopefully unique inode number. */
3635 static DWORD
3636 generate_inode_val (const char * name)
3637 {
3638   char fullname[ MAX_PATH ];
3639   char * p;
3640   unsigned hash;
3641
3642   /* Get the truly canonical filename, if it exists.  (Note: this
3643      doesn't resolve aliasing due to subst commands, or recognize hard
3644      links.  */
3645   if (!w32_get_long_filename ((char *)name, fullname, MAX_PATH))
3646     emacs_abort ();
3647
3648   parse_root (fullname, &p);
3649   /* Normal W32 filesystems are still case insensitive. */
3650   _strlwr (p);
3651   return hashval (p);
3652 }
3653
3654 #endif
3655
3656 static PSECURITY_DESCRIPTOR
3657 get_file_security_desc_by_handle (HANDLE h)
3658 {
3659   PSECURITY_DESCRIPTOR psd = NULL;
3660   DWORD err;
3661   SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
3662     | GROUP_SECURITY_INFORMATION  /* | DACL_SECURITY_INFORMATION */ ;
3663
3664   err = get_security_info (h, SE_FILE_OBJECT, si,
3665                            NULL, NULL, NULL, NULL, &psd);
3666   if (err != ERROR_SUCCESS)
3667     return NULL;
3668
3669   return psd;
3670 }
3671
3672 static PSECURITY_DESCRIPTOR
3673 get_file_security_desc_by_name (const char *fname)
3674 {
3675   PSECURITY_DESCRIPTOR psd = NULL;
3676   DWORD sd_len, err;
3677   SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION
3678     | GROUP_SECURITY_INFORMATION  /* | DACL_SECURITY_INFORMATION */ ;
3679
3680   if (!get_file_security (fname, si, psd, 0, &sd_len))
3681     {
3682       err = GetLastError ();
3683       if (err != ERROR_INSUFFICIENT_BUFFER)
3684         return NULL;
3685     }
3686
3687   psd = xmalloc (sd_len);
3688   if (!get_file_security (fname, si, psd, sd_len, &sd_len))
3689     {
3690       xfree (psd);
3691       return NULL;
3692     }
3693
3694   return psd;
3695 }
3696
3697 static DWORD
3698 get_rid (PSID sid)
3699 {
3700   unsigned n_subauthorities;
3701
3702   /* Use the last sub-authority value of the RID, the relative
3703      portion of the SID, as user/group ID. */
3704   n_subauthorities = *get_sid_sub_authority_count (sid);
3705   if (n_subauthorities < 1)
3706     return 0;   /* the "World" RID */
3707   return *get_sid_sub_authority (sid, n_subauthorities - 1);
3708 }
3709
3710 /* Caching SID and account values for faster lokup.  */
3711
3712 #ifdef __GNUC__
3713 # define FLEXIBLE_ARRAY_MEMBER
3714 #else
3715 # define FLEXIBLE_ARRAY_MEMBER 1
3716 #endif
3717
3718 struct w32_id {
3719   unsigned rid;
3720   struct w32_id *next;
3721   char name[GNLEN+1];
3722   unsigned char sid[FLEXIBLE_ARRAY_MEMBER];
3723 };
3724
3725 static struct w32_id *w32_idlist;
3726
3727 static int
3728 w32_cached_id (PSID sid, unsigned *id, char *name)
3729 {
3730   struct w32_id *tail, *found;
3731
3732   for (found = NULL, tail = w32_idlist; tail; tail = tail->next)
3733     {
3734       if (equal_sid ((PSID)tail->sid, sid))
3735         {
3736           found = tail;
3737           break;
3738         }
3739     }
3740   if (found)
3741     {
3742       *id = found->rid;
3743       strcpy (name, found->name);
3744       return 1;
3745     }
3746   else
3747     return 0;
3748 }
3749
3750 static void
3751 w32_add_to_cache (PSID sid, unsigned id, char *name)
3752 {
3753   DWORD sid_len;
3754   struct w32_id *new_entry;
3755
3756   /* We don't want to leave behind stale cache from when Emacs was
3757      dumped.  */
3758   if (initialized)
3759     {
3760       sid_len = get_length_sid (sid);
3761       new_entry = xmalloc (offsetof (struct w32_id, sid) + sid_len);
3762       if (new_entry)
3763         {
3764           new_entry->rid = id;
3765           strcpy (new_entry->name, name);
3766           copy_sid (sid_len, (PSID)new_entry->sid, sid);
3767           new_entry->next = w32_idlist;
3768           w32_idlist = new_entry;
3769         }
3770     }
3771 }
3772
3773 #define UID 1
3774 #define GID 2
3775
3776 static int
3777 get_name_and_id (PSECURITY_DESCRIPTOR psd, unsigned *id, char *nm, int what)
3778 {
3779   PSID sid = NULL;
3780   BOOL dflt;
3781   SID_NAME_USE ignore;
3782   char name[UNLEN+1];
3783   DWORD name_len = sizeof (name);
3784   char domain[1024];
3785   DWORD domain_len = sizeof (domain);
3786   int use_dflt = 0;
3787   int result;
3788
3789   if (what == UID)
3790     result = get_security_descriptor_owner (psd, &sid, &dflt);
3791   else if (what == GID)
3792     result = get_security_descriptor_group (psd, &sid, &dflt);
3793   else
3794     result = 0;
3795
3796   if (!result || !is_valid_sid (sid))
3797     use_dflt = 1;
3798   else if (!w32_cached_id (sid, id, nm))
3799     {
3800       if (!lookup_account_sid (NULL, sid, name, &name_len,
3801                                domain, &domain_len, &ignore)
3802           || name_len > UNLEN+1)
3803         use_dflt = 1;
3804       else
3805         {
3806           *id = get_rid (sid);
3807           strcpy (nm, name);
3808           w32_add_to_cache (sid, *id, name);
3809         }
3810     }
3811   return use_dflt;
3812 }
3813
3814 static void
3815 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd, struct stat *st)
3816 {
3817   int dflt_usr = 0, dflt_grp = 0;
3818
3819   if (!psd)
3820     {
3821       dflt_usr = 1;
3822       dflt_grp = 1;
3823     }
3824   else
3825     {
3826       if (get_name_and_id (psd, &st->st_uid, st->st_uname, UID))
3827         dflt_usr = 1;
3828       if (get_name_and_id (psd, &st->st_gid, st->st_gname, GID))
3829         dflt_grp = 1;
3830     }
3831   /* Consider files to belong to current user/group, if we cannot get
3832      more accurate information.  */
3833   if (dflt_usr)
3834     {
3835       st->st_uid = dflt_passwd.pw_uid;
3836       strcpy (st->st_uname, dflt_passwd.pw_name);
3837     }
3838   if (dflt_grp)
3839     {
3840       st->st_gid = dflt_passwd.pw_gid;
3841       strcpy (st->st_gname, dflt_group.gr_name);
3842     }
3843 }
3844
3845 /* Return non-zero if NAME is a potentially slow filesystem.  */
3846 int
3847 is_slow_fs (const char *name)
3848 {
3849   char drive_root[4];
3850   UINT devtype;
3851
3852   if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
3853     devtype = DRIVE_REMOTE;        /* assume UNC name is remote */
3854   else if (!(strlen (name) >= 2 && IS_DEVICE_SEP (name[1])))
3855     devtype = GetDriveType (NULL); /* use root of current drive */
3856   else
3857     {
3858       /* GetDriveType needs the root directory of the drive.  */
3859       strncpy (drive_root, name, 2);
3860       drive_root[2] = '\\';
3861       drive_root[3] = '\0';
3862       devtype = GetDriveType (drive_root);
3863     }
3864   return !(devtype == DRIVE_FIXED || devtype == DRIVE_RAMDISK);
3865 }
3866
3867 /* If this is non-zero, the caller wants accurate information about
3868    file's owner and group, which could be expensive to get.  */
3869 int w32_stat_get_owner_group;
3870
3871 /* MSVC stat function can't cope with UNC names and has other bugs, so
3872    replace it with our own.  This also allows us to calculate consistent
3873    inode values and owner/group without hacks in the main Emacs code. */
3874
3875 static int
3876 stat_worker (const char * path, struct stat * buf, int follow_symlinks)
3877 {
3878   char *name, *save_name, *r;
3879   WIN32_FIND_DATA wfd;
3880   HANDLE fh;
3881   unsigned __int64 fake_inode = 0;
3882   int permission;
3883   int len;
3884   int rootdir = FALSE;
3885   PSECURITY_DESCRIPTOR psd = NULL;
3886   int is_a_symlink = 0;
3887   DWORD file_flags = FILE_FLAG_BACKUP_SEMANTICS;
3888   DWORD access_rights = 0;
3889   DWORD fattrs = 0, serialnum = 0, fs_high = 0, fs_low = 0, nlinks = 1;
3890   FILETIME ctime, atime, wtime;
3891   int dbcs_p;
3892
3893   if (path == NULL || buf == NULL)
3894     {
3895       errno = EFAULT;
3896       return -1;
3897     }
3898
3899   save_name = name = (char *) map_w32_filename (path, &path);
3900   /* Must be valid filename, no wild cards or other invalid
3901      characters.  We use _mbspbrk to support multibyte strings that
3902      might look to strpbrk as if they included literal *, ?, and other
3903      characters mentioned below that are disallowed by Windows
3904      filesystems.  */
3905   if (_mbspbrk (name, "*?|<>\""))
3906     {
3907       errno = ENOENT;
3908       return -1;
3909     }
3910
3911   /* Remove trailing directory separator, unless name is the root
3912      directory of a drive or UNC volume in which case ensure there
3913      is a trailing separator. */
3914   len = strlen (name);
3915   name = strcpy (alloca (len + 2), name);
3916
3917   /* Avoid a somewhat costly call to is_symlink if the filesystem
3918      doesn't support symlinks.  */
3919   if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
3920     is_a_symlink = is_symlink (name);
3921
3922   /* Plan A: Open the file and get all the necessary information via
3923      the resulting handle.  This solves several issues in one blow:
3924
3925       . retrieves attributes for the target of a symlink, if needed
3926       . gets attributes of root directories and symlinks pointing to
3927         root directories, thus avoiding the need for special-casing
3928         these and detecting them by examining the file-name format
3929       . retrieves more accurate attributes (e.g., non-zero size for
3930         some directories, esp. directories that are junction points)
3931       . correctly resolves "c:/..", "/.." and similar file names
3932       . avoids run-time penalties for 99% of use cases
3933
3934      Plan A is always tried first, unless the user asked not to (but
3935      if the file is a symlink and we need to follow links, we try Plan
3936      A even if the user asked not to).
3937
3938      If Plan A fails, we go to Plan B (below), where various
3939      potentially expensive techniques must be used to handle "special"
3940      files such as UNC volumes etc.  */
3941   if (!(NILP (Vw32_get_true_file_attributes)
3942         || (EQ (Vw32_get_true_file_attributes, Qlocal) && is_slow_fs (name)))
3943       /* Following symlinks requires getting the info by handle.  */
3944       || (is_a_symlink && follow_symlinks))
3945     {
3946       BY_HANDLE_FILE_INFORMATION info;
3947
3948       if (is_a_symlink && !follow_symlinks)
3949         file_flags |= FILE_FLAG_OPEN_REPARSE_POINT;
3950       /* READ_CONTROL access rights are required to get security info
3951          by handle.  But if the OS doesn't support security in the
3952          first place, we don't need to try.  */
3953       if (is_windows_9x () != TRUE)
3954         access_rights |= READ_CONTROL;
3955
3956       fh = CreateFile (name, access_rights, 0, NULL, OPEN_EXISTING,
3957                        file_flags, NULL);
3958       /* If CreateFile fails with READ_CONTROL, try again with zero as
3959          access rights.  */
3960       if (fh == INVALID_HANDLE_VALUE && access_rights)
3961         fh = CreateFile (name, 0, 0, NULL, OPEN_EXISTING,
3962                          file_flags, NULL);
3963       if (fh == INVALID_HANDLE_VALUE)
3964         goto no_true_file_attributes;
3965
3966       /* This is more accurate in terms of getting the correct number
3967          of links, but is quite slow (it is noticeable when Emacs is
3968          making a list of file name completions). */
3969       if (GetFileInformationByHandle (fh, &info))
3970         {
3971           nlinks = info.nNumberOfLinks;
3972           /* Might as well use file index to fake inode values, but this
3973              is not guaranteed to be unique unless we keep a handle open
3974              all the time (even then there are situations where it is
3975              not unique).  Reputedly, there are at most 48 bits of info
3976              (on NTFS, presumably less on FAT). */
3977           fake_inode = info.nFileIndexHigh;
3978           fake_inode <<= 32;
3979           fake_inode += info.nFileIndexLow;
3980           serialnum = info.dwVolumeSerialNumber;
3981           fs_high = info.nFileSizeHigh;
3982           fs_low  = info.nFileSizeLow;
3983           ctime = info.ftCreationTime;
3984           atime = info.ftLastAccessTime;
3985           wtime = info.ftLastWriteTime;
3986           fattrs = info.dwFileAttributes;
3987         }
3988       else
3989         {
3990           /* We don't go to Plan B here, because it's not clear that
3991              it's a good idea.  The only known use case where
3992              CreateFile succeeds, but GetFileInformationByHandle fails
3993              (with ERROR_INVALID_FUNCTION) is for character devices
3994              such as NUL, PRN, etc.  For these, switching to Plan B is
3995              a net loss, because we lose the character device
3996              attribute returned by GetFileType below (FindFirstFile
3997              doesn't set that bit in the attributes), and the other
3998              fields don't make sense for character devices anyway.
3999              Emacs doesn't really care for non-file entities in the
4000              context of l?stat, so neither do we.  */
4001
4002           /* w32err is assigned so one could put a breakpoint here and
4003              examine its value, when GetFileInformationByHandle
4004              fails. */
4005           DWORD w32err = GetLastError ();
4006
4007           switch (w32err)
4008             {
4009             case ERROR_FILE_NOT_FOUND: /* can this ever happen? */
4010               errno = ENOENT;
4011               return -1;
4012             }
4013         }
4014
4015       /* Test for a symlink before testing for a directory, since
4016          symlinks to directories have the directory bit set, but we
4017          don't want them to appear as directories.  */
4018       if (is_a_symlink && !follow_symlinks)
4019         buf->st_mode = S_IFLNK;
4020       else if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
4021         buf->st_mode = S_IFDIR;
4022       else
4023         {
4024           DWORD ftype = GetFileType (fh);
4025
4026           switch (ftype)
4027             {
4028             case FILE_TYPE_DISK:
4029               buf->st_mode = S_IFREG;
4030               break;
4031             case FILE_TYPE_PIPE:
4032               buf->st_mode = S_IFIFO;
4033               break;
4034             case FILE_TYPE_CHAR:
4035             case FILE_TYPE_UNKNOWN:
4036             default:
4037               buf->st_mode = S_IFCHR;
4038             }
4039         }
4040       /* We produce the fallback owner and group data, based on the
4041          current user that runs Emacs, in the following cases:
4042
4043           . caller didn't request owner and group info
4044           . this is Windows 9X
4045           . getting security by handle failed, and we need to produce
4046             information for the target of a symlink (this is better
4047             than producing a potentially misleading info about the
4048             symlink itself)
4049
4050          If getting security by handle fails, and we don't need to
4051          resolve symlinks, we try getting security by name.  */
4052       if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
4053         get_file_owner_and_group (NULL, buf);
4054       else
4055         {
4056           psd = get_file_security_desc_by_handle (fh);
4057           if (psd)
4058             {
4059               get_file_owner_and_group (psd, buf);
4060               LocalFree (psd);
4061             }
4062           else if (!(is_a_symlink && follow_symlinks))
4063             {
4064               psd = get_file_security_desc_by_name (name);
4065               get_file_owner_and_group (psd, buf);
4066               xfree (psd);
4067             }
4068           else
4069             get_file_owner_and_group (NULL, buf);
4070         }
4071       CloseHandle (fh);
4072     }
4073   else
4074     {
4075     no_true_file_attributes:
4076       /* Plan B: Either getting a handle on the file failed, or the
4077          caller explicitly asked us to not bother making this
4078          information more accurate.
4079
4080          Implementation note: In Plan B, we never bother to resolve
4081          symlinks, even if we got here because we tried Plan A and
4082          failed.  That's because, even if the caller asked for extra
4083          precision by setting Vw32_get_true_file_attributes to t,
4084          resolving symlinks requires acquiring a file handle to the
4085          symlink, which we already know will fail.  And if the user
4086          did not ask for extra precision, resolving symlinks will fly
4087          in the face of that request, since the user then wants the
4088          lightweight version of the code.  */
4089       dbcs_p = max_filename_mbslen () > 1;
4090       rootdir = (path >= save_name + len - 1
4091                  && (IS_DIRECTORY_SEP (*path) || *path == 0));
4092
4093       /* If name is "c:/.." or "/.." then stat "c:/" or "/".  */
4094       r = IS_DEVICE_SEP (name[1]) ? &name[2] : name;
4095       if (IS_DIRECTORY_SEP (r[0])
4096           && r[1] == '.' && r[2] == '.' && r[3] == '\0')
4097         r[1] = r[2] = '\0';
4098
4099       /* Note: If NAME is a symlink to the root of a UNC volume
4100          (i.e. "\\SERVER"), we will not detect that here, and we will
4101          return data about the symlink as result of FindFirst below.
4102          This is unfortunate, but that marginal use case does not
4103          justify a call to chase_symlinks which would impose a penalty
4104          on all the other use cases.  (We get here for symlinks to
4105          roots of UNC volumes because CreateFile above fails for them,
4106          unlike with symlinks to root directories X:\ of drives.)  */
4107       if (is_unc_volume (name))
4108         {
4109           fattrs = unc_volume_file_attributes (name);
4110           if (fattrs == -1)
4111             return -1;
4112
4113           ctime = atime = wtime = utc_base_ft;
4114         }
4115       else if (rootdir)
4116         {
4117           if (!dbcs_p)
4118             {
4119               if (!IS_DIRECTORY_SEP (name[len-1]))
4120                 strcat (name, "\\");
4121             }
4122           else
4123             {
4124               char *end = name + len;
4125               char *n = CharPrevExA (file_name_codepage, name, end, 0);
4126
4127               if (!IS_DIRECTORY_SEP (*n))
4128                 strcat (name, "\\");
4129             }
4130           if (GetDriveType (name) < 2)
4131             {
4132               errno = ENOENT;
4133               return -1;
4134             }
4135
4136           fattrs = FILE_ATTRIBUTE_DIRECTORY;
4137           ctime = atime = wtime = utc_base_ft;
4138         }
4139       else
4140         {
4141           if (!dbcs_p)
4142             {
4143               if (IS_DIRECTORY_SEP (name[len-1]))
4144                 name[len - 1] = 0;
4145             }
4146           else
4147             {
4148               char *end = name + len;
4149               char *n = CharPrevExA (file_name_codepage, name, end, 0);
4150
4151               if (IS_DIRECTORY_SEP (*n))
4152                 *n = 0;
4153             }
4154
4155           /* (This is hacky, but helps when doing file completions on
4156              network drives.)  Optimize by using information available from
4157              active readdir if possible.  */
4158           len = strlen (dir_pathname);
4159           if (!dbcs_p)
4160             {
4161               if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
4162                 len--;
4163             }
4164           else
4165             {
4166               char *end = dir_pathname + len;
4167               char *n = CharPrevExA (file_name_codepage, dir_pathname, end, 0);
4168
4169               if (IS_DIRECTORY_SEP (*n))
4170                 len--;
4171             }
4172           if (dir_find_handle != INVALID_HANDLE_VALUE
4173               && !(is_a_symlink && follow_symlinks)
4174               && strnicmp (save_name, dir_pathname, len) == 0
4175               && IS_DIRECTORY_SEP (name[len])
4176               && xstrcasecmp (name + len + 1, dir_static.d_name) == 0)
4177             {
4178               /* This was the last entry returned by readdir.  */
4179               wfd = dir_find_data;
4180             }
4181           else
4182             {
4183               logon_network_drive (name);
4184
4185               fh = FindFirstFile (name, &wfd);
4186               if (fh == INVALID_HANDLE_VALUE)
4187                 {
4188                   errno = ENOENT;
4189                   return -1;
4190                 }
4191               FindClose (fh);
4192             }
4193           /* Note: if NAME is a symlink, the information we get from
4194              FindFirstFile is for the symlink, not its target.  */
4195           fattrs = wfd.dwFileAttributes;
4196           ctime = wfd.ftCreationTime;
4197           atime = wfd.ftLastAccessTime;
4198           wtime = wfd.ftLastWriteTime;
4199           fs_high = wfd.nFileSizeHigh;
4200           fs_low = wfd.nFileSizeLow;
4201           fake_inode = 0;
4202           nlinks = 1;
4203           serialnum = volume_info.serialnum;
4204         }
4205       if (is_a_symlink && !follow_symlinks)
4206         buf->st_mode = S_IFLNK;
4207       else if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
4208         buf->st_mode = S_IFDIR;
4209       else
4210         buf->st_mode = S_IFREG;
4211
4212       get_file_owner_and_group (NULL, buf);
4213     }
4214
4215 #if 0
4216   /* Not sure if there is any point in this.  */
4217   if (!NILP (Vw32_generate_fake_inodes))
4218     fake_inode = generate_inode_val (name);
4219   else if (fake_inode == 0)
4220     {
4221       /* For want of something better, try to make everything unique.  */
4222       static DWORD gen_num = 0;
4223       fake_inode = ++gen_num;
4224     }
4225 #endif
4226
4227   buf->st_ino = fake_inode;
4228
4229   buf->st_dev = serialnum;
4230   buf->st_rdev = serialnum;
4231
4232   buf->st_size = fs_high;
4233   buf->st_size <<= 32;
4234   buf->st_size += fs_low;
4235   buf->st_nlink = nlinks;
4236
4237   /* Convert timestamps to Unix format. */
4238   buf->st_mtime = convert_time (wtime);
4239   buf->st_atime = convert_time (atime);
4240   if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
4241   buf->st_ctime = convert_time (ctime);
4242   if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
4243
4244   /* determine rwx permissions */
4245   if (is_a_symlink && !follow_symlinks)
4246     permission = S_IREAD | S_IWRITE | S_IEXEC; /* Posix expectations */
4247   else
4248     {
4249       if (fattrs & FILE_ATTRIBUTE_READONLY)
4250         permission = S_IREAD;
4251       else
4252         permission = S_IREAD | S_IWRITE;
4253
4254       if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
4255         permission |= S_IEXEC;
4256       else if (is_exec (name))
4257         permission |= S_IEXEC;
4258     }
4259
4260   buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
4261
4262   return 0;
4263 }
4264
4265 int
4266 stat (const char * path, struct stat * buf)
4267 {
4268   return stat_worker (path, buf, 1);
4269 }
4270
4271 int
4272 lstat (const char * path, struct stat * buf)
4273 {
4274   return stat_worker (path, buf, 0);
4275 }
4276
4277 int
4278 fstatat (int fd, char const *name, struct stat *st, int flags)
4279 {
4280   /* Rely on a hack: an open directory is modeled as file descriptor 0.
4281      This is good enough for the current usage in Emacs, but is fragile.
4282
4283      FIXME: Add proper support for fdopendir, fstatat, readlinkat.
4284      Gnulib does this and can serve as a model.  */
4285   char fullname[MAX_PATH];
4286
4287   if (fd != AT_FDCWD)
4288     {
4289       if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
4290           < 0)
4291         {
4292           errno = ENAMETOOLONG;
4293           return -1;
4294         }
4295       name = fullname;
4296     }
4297
4298   return stat_worker (name, st, ! (flags & AT_SYMLINK_NOFOLLOW));
4299 }
4300
4301 /* Provide fstat and utime as well as stat for consistent handling of
4302    file timestamps. */
4303 int
4304 fstat (int desc, struct stat * buf)
4305 {
4306   HANDLE fh = (HANDLE) _get_osfhandle (desc);
4307   BY_HANDLE_FILE_INFORMATION info;
4308   unsigned __int64 fake_inode;
4309   int permission;
4310
4311   switch (GetFileType (fh) & ~FILE_TYPE_REMOTE)
4312     {
4313     case FILE_TYPE_DISK:
4314       buf->st_mode = S_IFREG;
4315       if (!GetFileInformationByHandle (fh, &info))
4316         {
4317           errno = EACCES;
4318           return -1;
4319         }
4320       break;
4321     case FILE_TYPE_PIPE:
4322       buf->st_mode = S_IFIFO;
4323       goto non_disk;
4324     case FILE_TYPE_CHAR:
4325     case FILE_TYPE_UNKNOWN:
4326     default:
4327       buf->st_mode = S_IFCHR;
4328     non_disk:
4329       memset (&info, 0, sizeof (info));
4330       info.dwFileAttributes = 0;
4331       info.ftCreationTime = utc_base_ft;
4332       info.ftLastAccessTime = utc_base_ft;
4333       info.ftLastWriteTime = utc_base_ft;
4334     }
4335
4336   if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
4337       buf->st_mode = S_IFDIR;
4338
4339   buf->st_nlink = info.nNumberOfLinks;
4340   /* Might as well use file index to fake inode values, but this
4341      is not guaranteed to be unique unless we keep a handle open
4342      all the time (even then there are situations where it is
4343      not unique).  Reputedly, there are at most 48 bits of info
4344      (on NTFS, presumably less on FAT). */
4345   fake_inode = info.nFileIndexHigh;
4346   fake_inode <<= 32;
4347   fake_inode += info.nFileIndexLow;
4348
4349   /* MSVC defines _ino_t to be short; other libc's might not.  */
4350   if (sizeof (buf->st_ino) == 2)
4351     buf->st_ino = fake_inode ^ (fake_inode >> 16);
4352   else
4353     buf->st_ino = fake_inode;
4354
4355   /* If the caller so requested, get the true file owner and group.
4356      Otherwise, consider the file to belong to the current user.  */
4357   if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
4358     get_file_owner_and_group (NULL, buf);
4359   else
4360     {
4361       PSECURITY_DESCRIPTOR psd = NULL;
4362
4363       psd = get_file_security_desc_by_handle (fh);
4364       if (psd)
4365         {
4366           get_file_owner_and_group (psd, buf);
4367           LocalFree (psd);
4368         }
4369       else
4370         get_file_owner_and_group (NULL, buf);
4371     }
4372
4373   buf->st_dev = info.dwVolumeSerialNumber;
4374   buf->st_rdev = info.dwVolumeSerialNumber;
4375
4376   buf->st_size = info.nFileSizeHigh;
4377   buf->st_size <<= 32;
4378   buf->st_size += info.nFileSizeLow;
4379
4380   /* Convert timestamps to Unix format. */
4381   buf->st_mtime = convert_time (info.ftLastWriteTime);
4382   buf->st_atime = convert_time (info.ftLastAccessTime);
4383   if (buf->st_atime == 0) buf->st_atime = buf->st_mtime;
4384   buf->st_ctime = convert_time (info.ftCreationTime);
4385   if (buf->st_ctime == 0) buf->st_ctime = buf->st_mtime;
4386
4387   /* determine rwx permissions */
4388   if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
4389     permission = S_IREAD;
4390   else
4391     permission = S_IREAD | S_IWRITE;
4392
4393   if (info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
4394     permission |= S_IEXEC;
4395   else
4396     {
4397 #if 0 /* no way of knowing the filename */
4398       char * p = strrchr (name, '.');
4399       if (p != NULL &&
4400           (xstrcasecmp (p, ".exe") == 0 ||
4401            xstrcasecmp (p, ".com") == 0 ||
4402            xstrcasecmp (p, ".bat") == 0 ||
4403            xstrcasecmp (p, ".cmd") == 0))
4404         permission |= S_IEXEC;
4405 #endif
4406     }
4407
4408   buf->st_mode |= permission | (permission >> 3) | (permission >> 6);
4409
4410   return 0;
4411 }
4412
4413 int
4414 utime (const char *name, struct utimbuf *times)
4415 {
4416   struct utimbuf deftime;
4417   HANDLE fh;
4418   FILETIME mtime;
4419   FILETIME atime;
4420
4421   if (times == NULL)
4422     {
4423       deftime.modtime = deftime.actime = time (NULL);
4424       times = &deftime;
4425     }
4426
4427   /* Need write access to set times.  */
4428   fh = CreateFile (name, FILE_WRITE_ATTRIBUTES,
4429                    /* If NAME specifies a directory, FILE_SHARE_DELETE
4430                       allows other processes to delete files inside it,
4431                       while we have the directory open.  */
4432                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
4433                    0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
4434   if (fh != INVALID_HANDLE_VALUE)
4435     {
4436       convert_from_time_t (times->actime, &atime);
4437       convert_from_time_t (times->modtime, &mtime);
4438       if (!SetFileTime (fh, NULL, &atime, &mtime))
4439         {
4440           CloseHandle (fh);
4441           errno = EACCES;
4442           return -1;
4443         }
4444       CloseHandle (fh);
4445     }
4446   else
4447     {
4448       errno = EINVAL;
4449       return -1;
4450     }
4451   return 0;
4452 }
4453
4454 \f
4455 /* Symlink-related functions.  */
4456 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4457 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4458 #endif
4459
4460 int
4461 symlink (char const *filename, char const *linkname)
4462 {
4463   char linkfn[MAX_PATH], *tgtfn;
4464   DWORD flags = 0;
4465   int dir_access, filename_ends_in_slash;
4466   int dbcs_p;
4467
4468   /* Diagnostics follows Posix as much as possible.  */
4469   if (filename == NULL || linkname == NULL)
4470     {
4471       errno = EFAULT;
4472       return -1;
4473     }
4474   if (!*filename)
4475     {
4476       errno = ENOENT;
4477       return -1;
4478     }
4479   if (strlen (filename) > MAX_PATH || strlen (linkname) > MAX_PATH)
4480     {
4481       errno = ENAMETOOLONG;
4482       return -1;
4483     }
4484
4485   strcpy (linkfn, map_w32_filename (linkname, NULL));
4486   if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) == 0)
4487     {
4488       errno = EPERM;
4489       return -1;
4490     }
4491
4492   dbcs_p = max_filename_mbslen () > 1;
4493
4494   /* Note: since empty FILENAME was already rejected, we can safely
4495      refer to FILENAME[1].  */
4496   if (!(IS_DIRECTORY_SEP (filename[0]) || IS_DEVICE_SEP (filename[1])))
4497     {
4498       /* Non-absolute FILENAME is understood as being relative to
4499          LINKNAME's directory.  We need to prepend that directory to
4500          FILENAME to get correct results from faccessat below, since
4501          otherwise it will interpret FILENAME relative to the
4502          directory where the Emacs process runs.  Note that
4503          make-symbolic-link always makes sure LINKNAME is a fully
4504          expanded file name.  */
4505       char tem[MAX_PATH];
4506       char *p = linkfn + strlen (linkfn);
4507
4508       if (!dbcs_p)
4509         {
4510           while (p > linkfn && !IS_ANY_SEP (p[-1]))
4511             p--;
4512         }
4513       else
4514         {
4515           char *p1 = CharPrevExA (file_name_codepage, linkfn, p, 0);
4516
4517           while (p > linkfn && !IS_ANY_SEP (*p1))
4518             {
4519               p = p1;
4520               p1 = CharPrevExA (file_name_codepage, linkfn, p1, 0);
4521             }
4522         }
4523       if (p > linkfn)
4524         strncpy (tem, linkfn, p - linkfn);
4525       tem[p - linkfn] = '\0';
4526       strcat (tem, filename);
4527       dir_access = faccessat (AT_FDCWD, tem, D_OK, AT_EACCESS);
4528     }
4529   else
4530     dir_access = faccessat (AT_FDCWD, filename, D_OK, AT_EACCESS);
4531
4532   /* Since Windows distinguishes between symlinks to directories and
4533      to files, we provide a kludgy feature: if FILENAME doesn't
4534      exist, but ends in a slash, we create a symlink to directory.  If
4535      FILENAME exists and is a directory, we always create a symlink to
4536      directory.  */
4537   if (!dbcs_p)
4538     filename_ends_in_slash = IS_DIRECTORY_SEP (filename[strlen (filename) - 1]);
4539   else
4540     {
4541       const char *end = filename + strlen (filename);
4542       const char *n = CharPrevExA (file_name_codepage, filename, end, 0);
4543
4544       filename_ends_in_slash = IS_DIRECTORY_SEP (*n);
4545     }
4546   if (dir_access == 0 || filename_ends_in_slash)
4547     flags = SYMBOLIC_LINK_FLAG_DIRECTORY;
4548
4549   tgtfn = (char *)map_w32_filename (filename, NULL);
4550   if (filename_ends_in_slash)
4551     tgtfn[strlen (tgtfn) - 1] = '\0';
4552
4553   errno = 0;
4554   if (!create_symbolic_link (linkfn, tgtfn, flags))
4555     {
4556       /* ENOSYS is set by create_symbolic_link, when it detects that
4557          the OS doesn't support the CreateSymbolicLink API.  */
4558       if (errno != ENOSYS)
4559         {
4560           DWORD w32err = GetLastError ();
4561
4562           switch (w32err)
4563             {
4564               /* ERROR_SUCCESS is sometimes returned when LINKFN and
4565                  TGTFN point to the same file name, go figure.  */
4566             case ERROR_SUCCESS:
4567             case ERROR_FILE_EXISTS:
4568               errno = EEXIST;
4569               break;
4570             case ERROR_ACCESS_DENIED:
4571               errno = EACCES;
4572               break;
4573             case ERROR_FILE_NOT_FOUND:
4574             case ERROR_PATH_NOT_FOUND:
4575             case ERROR_BAD_NETPATH:
4576             case ERROR_INVALID_REPARSE_DATA:
4577               errno = ENOENT;
4578               break;
4579             case ERROR_DIRECTORY:
4580               errno = EISDIR;
4581               break;
4582             case ERROR_PRIVILEGE_NOT_HELD:
4583             case ERROR_NOT_ALL_ASSIGNED:
4584               errno = EPERM;
4585               break;
4586             case ERROR_DISK_FULL:
4587               errno = ENOSPC;
4588               break;
4589             default:
4590               errno = EINVAL;
4591               break;
4592             }
4593         }
4594       return -1;
4595     }
4596   return 0;
4597 }
4598
4599 /* A quick inexpensive test of whether FILENAME identifies a file that
4600    is a symlink.  Returns non-zero if it is, zero otherwise.  FILENAME
4601    must already be in the normalized form returned by
4602    map_w32_filename.
4603
4604    Note: for repeated operations on many files, it is best to test
4605    whether the underlying volume actually supports symlinks, by
4606    testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4607    avoid the call to this function if it doesn't.  That's because the
4608    call to GetFileAttributes takes a non-negligible time, especially
4609    on non-local or removable filesystems.  See stat_worker for an
4610    example of how to do that.  */
4611 static int
4612 is_symlink (const char *filename)
4613 {
4614   DWORD attrs;
4615   WIN32_FIND_DATA wfd;
4616   HANDLE fh;
4617
4618   attrs = GetFileAttributes (filename);
4619   if (attrs == -1)
4620     {
4621       DWORD w32err = GetLastError ();
4622
4623       switch (w32err)
4624         {
4625         case ERROR_BAD_NETPATH: /* network share, can't be a symlink */
4626           break;
4627         case ERROR_ACCESS_DENIED:
4628           errno = EACCES;
4629           break;
4630         case ERROR_FILE_NOT_FOUND:
4631         case ERROR_PATH_NOT_FOUND:
4632         default:
4633           errno = ENOENT;
4634           break;
4635         }
4636       return 0;
4637     }
4638   if ((attrs & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
4639     return 0;
4640   logon_network_drive (filename);
4641   fh = FindFirstFile (filename, &wfd);
4642   if (fh == INVALID_HANDLE_VALUE)
4643     return 0;
4644   FindClose (fh);
4645   return (wfd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0
4646           && (wfd.dwReserved0 & IO_REPARSE_TAG_SYMLINK) == IO_REPARSE_TAG_SYMLINK;
4647 }
4648
4649 /* If NAME identifies a symbolic link, copy into BUF the file name of
4650    the symlink's target.  Copy at most BUF_SIZE bytes, and do NOT
4651    null-terminate the target name, even if it fits.  Return the number
4652    of bytes copied, or -1 if NAME is not a symlink or any error was
4653    encountered while resolving it.  The file name copied into BUF is
4654    encoded in the current ANSI codepage.  */
4655 ssize_t
4656 readlink (const char *name, char *buf, size_t buf_size)
4657 {
4658   const char *path;
4659   TOKEN_PRIVILEGES privs;
4660   int restore_privs = 0;
4661   HANDLE sh;
4662   ssize_t retval;
4663
4664   if (name == NULL)
4665     {
4666       errno = EFAULT;
4667       return -1;
4668     }
4669   if (!*name)
4670     {
4671       errno = ENOENT;
4672       return -1;
4673     }
4674
4675   path = map_w32_filename (name, NULL);
4676
4677   if (strlen (path) > MAX_PATH)
4678     {
4679       errno = ENAMETOOLONG;
4680       return -1;
4681     }
4682
4683   errno = 0;
4684   if (is_windows_9x () == TRUE
4685       || (volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) == 0
4686       || !is_symlink (path))
4687     {
4688       if (!errno)
4689         errno = EINVAL; /* not a symlink */
4690       return -1;
4691     }
4692
4693   /* Done with simple tests, now we're in for some _real_ work.  */
4694   if (enable_privilege (SE_BACKUP_NAME, TRUE, &privs))
4695     restore_privs = 1;
4696   /* Implementation note: From here and onward, don't return early,
4697      since that will fail to restore the original set of privileges of
4698      the calling thread.  */
4699
4700   retval = -1;  /* not too optimistic, are we? */
4701
4702   /* Note: In the next call to CreateFile, we use zero as the 2nd
4703      argument because, when the symlink is a hidden/system file,
4704      e.g. 'C:\Users\All Users', GENERIC_READ fails with
4705      ERROR_ACCESS_DENIED.  Zero seems to work just fine, both for file
4706      and directory symlinks.  */
4707   sh = CreateFile (path, 0, 0, NULL, OPEN_EXISTING,
4708                    FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
4709                    NULL);
4710   if (sh != INVALID_HANDLE_VALUE)
4711     {
4712       BYTE reparse_buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
4713       REPARSE_DATA_BUFFER *reparse_data = (REPARSE_DATA_BUFFER *)&reparse_buf[0];
4714       DWORD retbytes;
4715
4716       if (!DeviceIoControl (sh, FSCTL_GET_REPARSE_POINT, NULL, 0,
4717                             reparse_buf, MAXIMUM_REPARSE_DATA_BUFFER_SIZE,
4718                             &retbytes, NULL))
4719         errno = EIO;
4720       else if (reparse_data->ReparseTag != IO_REPARSE_TAG_SYMLINK)
4721         errno = EINVAL;
4722       else
4723         {
4724           /* Copy the link target name, in wide characters, from
4725              reparse_data, then convert it to multibyte encoding in
4726              the current locale's codepage.  */
4727           WCHAR *lwname;
4728           BYTE  lname[MAX_PATH];
4729           USHORT lname_len;
4730           USHORT lwname_len =
4731             reparse_data->SymbolicLinkReparseBuffer.PrintNameLength;
4732           WCHAR *lwname_src =
4733             reparse_data->SymbolicLinkReparseBuffer.PathBuffer
4734             + reparse_data->SymbolicLinkReparseBuffer.PrintNameOffset/sizeof(WCHAR);
4735           /* This updates file_name_codepage which we need below.  */
4736           int dbcs_p = max_filename_mbslen () > 1;
4737
4738           /* According to MSDN, PrintNameLength does not include the
4739              terminating null character.  */
4740           lwname = alloca ((lwname_len + 1) * sizeof(WCHAR));
4741           memcpy (lwname, lwname_src, lwname_len);
4742           lwname[lwname_len/sizeof(WCHAR)] = 0; /* null-terminate */
4743
4744           lname_len = WideCharToMultiByte (file_name_codepage, 0, lwname, -1,
4745                                            lname, MAX_PATH, NULL, NULL);
4746           if (!lname_len)
4747             {
4748               /* WideCharToMultiByte failed.  */
4749               DWORD w32err1 = GetLastError ();
4750
4751               switch (w32err1)
4752                 {
4753                 case ERROR_INSUFFICIENT_BUFFER:
4754                   errno = ENAMETOOLONG;
4755                   break;
4756                 case ERROR_INVALID_PARAMETER:
4757                   errno = EFAULT;
4758                   break;
4759                 case ERROR_NO_UNICODE_TRANSLATION:
4760                   errno = ENOENT;
4761                   break;
4762                 default:
4763                   errno = EINVAL;
4764                   break;
4765                 }
4766             }
4767           else
4768             {
4769               size_t size_to_copy = buf_size;
4770               BYTE *p = lname, *p2;
4771               BYTE *pend = p + lname_len;
4772
4773               /* Normalize like dostounix_filename does, but we don't
4774                  want to assume that lname is null-terminated.  */
4775               if (dbcs_p)
4776                 p2 = CharNextExA (file_name_codepage, p, 0);
4777               else
4778                 p2 = p + 1;
4779               if (*p && *p2 == ':' && *p >= 'A' && *p <= 'Z')
4780                 {
4781                   *p += 'a' - 'A';
4782                   p += 2;
4783                 }
4784               while (p <= pend)
4785                 {
4786                   if (*p == '\\')
4787                     *p = '/';
4788                   if (dbcs_p)
4789                     {
4790                       p = CharNextExA (file_name_codepage, p, 0);
4791                       /* CharNextExA doesn't advance at null character.  */
4792                       if (!*p)
4793                         break;
4794                     }
4795                   else
4796                     ++p;
4797                 }
4798               /* Testing for null-terminated LNAME is paranoia:
4799                  WideCharToMultiByte should always return a
4800                  null-terminated string when its 4th argument is -1
4801                  and its 3rd argument is null-terminated (which they
4802                  are, see above).  */
4803               if (lname[lname_len - 1] == '\0')
4804                 lname_len--;
4805               if (lname_len <= buf_size)
4806                 size_to_copy = lname_len;
4807               strncpy (buf, lname, size_to_copy);
4808               /* Success!  */
4809               retval = size_to_copy;
4810             }
4811         }
4812       CloseHandle (sh);
4813     }
4814   else
4815     {
4816       /* CreateFile failed.  */
4817       DWORD w32err2 = GetLastError ();
4818
4819       switch (w32err2)
4820         {
4821         case ERROR_FILE_NOT_FOUND:
4822         case ERROR_PATH_NOT_FOUND:
4823           errno = ENOENT;
4824           break;
4825         case ERROR_ACCESS_DENIED:
4826         case ERROR_TOO_MANY_OPEN_FILES:
4827           errno = EACCES;
4828           break;
4829         default:
4830           errno = EPERM;
4831           break;
4832         }
4833     }
4834   if (restore_privs)
4835     {
4836       restore_privilege (&privs);
4837       revert_to_self ();
4838     }
4839
4840   return retval;
4841 }
4842
4843 ssize_t
4844 readlinkat (int fd, char const *name, char *buffer,
4845             size_t buffer_size)
4846 {
4847   /* Rely on a hack: an open directory is modeled as file descriptor 0,
4848      as in fstatat.  FIXME: Add proper support for readlinkat.  */
4849   char fullname[MAX_PATH];
4850
4851   if (fd != AT_FDCWD)
4852     {
4853       if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
4854           < 0)
4855         {
4856           errno = ENAMETOOLONG;
4857           return -1;
4858         }
4859       name = fullname;
4860     }
4861
4862   return readlink (name, buffer, buffer_size);
4863 }
4864
4865 /* If FILE is a symlink, return its target (stored in a static
4866    buffer); otherwise return FILE.
4867
4868    This function repeatedly resolves symlinks in the last component of
4869    a chain of symlink file names, as in foo -> bar -> baz -> ...,
4870    until it arrives at a file whose last component is not a symlink,
4871    or some error occurs.  It returns the target of the last
4872    successfully resolved symlink in the chain.  If it succeeds to
4873    resolve even a single symlink, the value returned is an absolute
4874    file name with backslashes (result of GetFullPathName).  By
4875    contrast, if the original FILE is returned, it is unaltered.
4876
4877    Note: This function can set errno even if it succeeds.
4878
4879    Implementation note: we only resolve the last portion ("basename")
4880    of the argument FILE and of each following file in the chain,
4881    disregarding any possible symlinks in its leading directories.
4882    This is because Windows system calls and library functions
4883    transparently resolve symlinks in leading directories and return
4884    correct information, as long as the basename is not a symlink.  */
4885 static char *
4886 chase_symlinks (const char *file)
4887 {
4888   static char target[MAX_PATH];
4889   char link[MAX_PATH];
4890   ssize_t res, link_len;
4891   int loop_count = 0;
4892   int dbcs_p;
4893
4894   if (is_windows_9x () == TRUE || !is_symlink (file))
4895     return (char *)file;
4896
4897   if ((link_len = GetFullPathName (file, MAX_PATH, link, NULL)) == 0)
4898     return (char *)file;
4899
4900   dbcs_p = max_filename_mbslen () > 1;
4901   target[0] = '\0';
4902   do {
4903
4904     /* Remove trailing slashes, as we want to resolve the last
4905        non-trivial part of the link name.  */
4906     if (!dbcs_p)
4907       {
4908         while (link_len > 3 && IS_DIRECTORY_SEP (link[link_len-1]))
4909           link[link_len--] = '\0';
4910       }
4911     else if (link_len > 3)
4912       {
4913         char *n = CharPrevExA (file_name_codepage, link, link + link_len, 0);
4914
4915         while (n >= link + 2 && IS_DIRECTORY_SEP (*n))
4916           {
4917             n[1] = '\0';
4918             n = CharPrevExA (file_name_codepage, link, n, 0);
4919           }
4920       }
4921
4922     res = readlink (link, target, MAX_PATH);
4923     if (res > 0)
4924       {
4925         target[res] = '\0';
4926         if (!(IS_DEVICE_SEP (target[1])
4927               || (IS_DIRECTORY_SEP (target[0]) && IS_DIRECTORY_SEP (target[1]))))
4928           {
4929             /* Target is relative.  Append it to the directory part of
4930                the symlink, then copy the result back to target.  */
4931             char *p = link + link_len;
4932
4933             if (!dbcs_p)
4934               {
4935                 while (p > link && !IS_ANY_SEP (p[-1]))
4936                   p--;
4937               }
4938             else
4939               {
4940                 char *p1 = CharPrevExA (file_name_codepage, link, p, 0);
4941
4942                 while (p > link && !IS_ANY_SEP (*p1))
4943                   {
4944                     p = p1;
4945                     p1 = CharPrevExA (file_name_codepage, link, p1, 0);
4946                   }
4947               }
4948             strcpy (p, target);
4949             strcpy (target, link);
4950           }
4951         /* Resolve any "." and ".." to get a fully-qualified file name
4952            in link[] again. */
4953         link_len = GetFullPathName (target, MAX_PATH, link, NULL);
4954       }
4955   } while (res > 0 && link_len > 0 && ++loop_count <= 100);
4956
4957   if (loop_count > 100)
4958     errno = ELOOP;
4959
4960   if (target[0] == '\0') /* not a single call to readlink succeeded */
4961     return (char *)file;
4962   return target;
4963 }
4964
4965 \f
4966 /* Posix ACL emulation.  */
4967
4968 int
4969 acl_valid (acl_t acl)
4970 {
4971   return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR)acl) ? 0 : -1;
4972 }
4973
4974 char *
4975 acl_to_text (acl_t acl, ssize_t *size)
4976 {
4977   LPTSTR str_acl;
4978   SECURITY_INFORMATION flags =
4979     OWNER_SECURITY_INFORMATION |
4980     GROUP_SECURITY_INFORMATION |
4981     DACL_SECURITY_INFORMATION;
4982   char *retval = NULL;
4983   ULONG local_size;
4984   int e = errno;
4985
4986   errno = 0;
4987
4988   if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR)acl, SDDL_REVISION_1, flags, &str_acl, &local_size))
4989     {
4990       errno = e;
4991       /* We don't want to mix heaps, so we duplicate the string in our
4992          heap and free the one allocated by the API.  */
4993       retval = xstrdup (str_acl);
4994       if (size)
4995         *size = local_size;
4996       LocalFree (str_acl);
4997     }
4998   else if (errno != ENOTSUP)
4999     errno = EINVAL;
5000
5001   return retval;
5002 }
5003
5004 acl_t
5005 acl_from_text (const char *acl_str)
5006 {
5007   PSECURITY_DESCRIPTOR psd, retval = NULL;
5008   ULONG sd_size;
5009   int e = errno;
5010
5011   errno = 0;
5012
5013   if (convert_sddl_to_sd (acl_str, SDDL_REVISION_1, &psd, &sd_size))
5014     {
5015       errno = e;
5016       retval = xmalloc (sd_size);
5017       memcpy (retval, psd, sd_size);
5018       LocalFree (psd);
5019     }
5020   else if (errno != ENOTSUP)
5021     errno = EINVAL;
5022
5023   return retval;
5024 }
5025
5026 int
5027 acl_free (void *ptr)
5028 {
5029   xfree (ptr);
5030   return 0;
5031 }
5032
5033 acl_t
5034 acl_get_file (const char *fname, acl_type_t type)
5035 {
5036   PSECURITY_DESCRIPTOR psd = NULL;
5037   const char *filename;
5038
5039   if (type == ACL_TYPE_ACCESS)
5040     {
5041       DWORD sd_len, err;
5042       SECURITY_INFORMATION si =
5043         OWNER_SECURITY_INFORMATION |
5044         GROUP_SECURITY_INFORMATION |
5045         DACL_SECURITY_INFORMATION ;
5046       int e = errno;
5047
5048       filename = map_w32_filename (fname, NULL);
5049       if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
5050         fname = chase_symlinks (filename);
5051       else
5052         fname = filename;
5053
5054       errno = 0;
5055       if (!get_file_security (fname, si, psd, 0, &sd_len)
5056           && errno != ENOTSUP)
5057         {
5058           err = GetLastError ();
5059           if (err == ERROR_INSUFFICIENT_BUFFER)
5060             {
5061               psd = xmalloc (sd_len);
5062               if (!get_file_security (fname, si, psd, sd_len, &sd_len))
5063                 {
5064                   xfree (psd);
5065                   errno = EIO;
5066                   psd = NULL;
5067                 }
5068             }
5069           else if (err == ERROR_FILE_NOT_FOUND
5070                    || err == ERROR_PATH_NOT_FOUND)
5071             errno = ENOENT;
5072           else
5073             errno = EIO;
5074         }
5075       else if (!errno)
5076         errno = e;
5077     }
5078   else if (type != ACL_TYPE_DEFAULT)
5079     errno = EINVAL;
5080
5081   return psd;
5082 }
5083
5084 int
5085 acl_set_file (const char *fname, acl_type_t type, acl_t acl)
5086 {
5087   TOKEN_PRIVILEGES old1, old2;
5088   DWORD err;
5089   int st = 0, retval = -1;
5090   SECURITY_INFORMATION flags = 0;
5091   PSID psid;
5092   PACL pacl;
5093   BOOL dflt;
5094   BOOL dacl_present;
5095   int e;
5096   const char *filename;
5097
5098   if (acl_valid (acl) != 0
5099       || (type != ACL_TYPE_DEFAULT && type != ACL_TYPE_ACCESS))
5100     {
5101       errno = EINVAL;
5102       return -1;
5103     }
5104
5105   if (type == ACL_TYPE_DEFAULT)
5106     {
5107       errno = ENOSYS;
5108       return -1;
5109     }
5110
5111   filename = map_w32_filename (fname, NULL);
5112   if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
5113     fname = chase_symlinks (filename);
5114   else
5115     fname = filename;
5116
5117   if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR)acl, &psid, &dflt)
5118       && psid)
5119     flags |= OWNER_SECURITY_INFORMATION;
5120   if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR)acl, &psid, &dflt)
5121       && psid)
5122     flags |= GROUP_SECURITY_INFORMATION;
5123   if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR)acl, &dacl_present,
5124                                     &pacl, &dflt)
5125       && dacl_present)
5126     flags |= DACL_SECURITY_INFORMATION;
5127   if (!flags)
5128     return 0;
5129
5130   /* According to KB-245153, setting the owner will succeed if either:
5131      (1) the caller is the user who will be the new owner, and has the
5132          SE_TAKE_OWNERSHIP privilege, or
5133      (2) the caller has the SE_RESTORE privilege, in which case she can
5134          set any valid user or group as the owner
5135
5136      We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
5137      privileges, and disregard any failures in obtaining them.  If
5138      these privileges cannot be obtained, and do not already exist in
5139      the calling thread's security token, this function could fail
5140      with EPERM.  */
5141   if (enable_privilege (SE_TAKE_OWNERSHIP_NAME, TRUE, &old1))
5142     st++;
5143   if (enable_privilege (SE_RESTORE_NAME, TRUE, &old2))
5144     st++;
5145
5146   e = errno;
5147   errno = 0;
5148   if (!set_file_security ((char *)fname, flags, (PSECURITY_DESCRIPTOR)acl))
5149     {
5150       err = GetLastError ();
5151
5152       if (errno == ENOTSUP)
5153         ;
5154       else if (err == ERROR_INVALID_OWNER
5155                || err == ERROR_NOT_ALL_ASSIGNED
5156                || err == ERROR_ACCESS_DENIED)
5157         {
5158           /* Maybe the requested ACL and the one the file already has
5159              are identical, in which case we can silently ignore the
5160              failure.  (And no, Windows doesn't.)  */
5161           acl_t current_acl = acl_get_file (fname, ACL_TYPE_ACCESS);
5162
5163           errno = EPERM;
5164           if (current_acl)
5165             {
5166               char *acl_from = acl_to_text (current_acl, NULL);
5167               char *acl_to = acl_to_text (acl, NULL);
5168
5169               if (acl_from && acl_to && xstrcasecmp (acl_from, acl_to) == 0)
5170                 {
5171                   retval = 0;
5172                   errno = e;
5173                 }
5174               if (acl_from)
5175                 acl_free (acl_from);
5176               if (acl_to)
5177                 acl_free (acl_to);
5178               acl_free (current_acl);
5179             }
5180         }
5181       else if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND)
5182         errno = ENOENT;
5183       else
5184         errno = EACCES;
5185     }
5186   else
5187     {
5188       retval = 0;
5189       errno = e;
5190     }
5191
5192   if (st)
5193     {
5194       if (st >= 2)
5195         restore_privilege (&old2);
5196       restore_privilege (&old1);
5197       revert_to_self ();
5198     }
5199
5200   return retval;
5201 }
5202
5203 \f
5204 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c).  We
5205    have a fixed max size for file names, so we don't need the kind of
5206    alloc/malloc/realloc dance the gnulib version does.  We also don't
5207    support FD-relative symlinks.  */
5208 char *
5209 careadlinkat (int fd, char const *filename,
5210               char *buffer, size_t buffer_size,
5211               struct allocator const *alloc,
5212               ssize_t (*preadlinkat) (int, char const *, char *, size_t))
5213 {
5214   char linkname[MAX_PATH];
5215   ssize_t link_size;
5216
5217   link_size = preadlinkat (fd, filename, linkname, sizeof(linkname));
5218
5219   if (link_size > 0)
5220     {
5221       char *retval = buffer;
5222
5223       linkname[link_size++] = '\0';
5224       if (link_size > buffer_size)
5225         retval = (char *)(alloc ? alloc->allocate : xmalloc) (link_size);
5226       if (retval)
5227         memcpy (retval, linkname, link_size);
5228
5229       return retval;
5230     }
5231   return NULL;
5232 }
5233
5234 \f
5235 /* Support for browsing other processes and their attributes.  See
5236    process.c for the Lisp bindings.  */
5237
5238 /* Helper wrapper functions.  */
5239
5240 static HANDLE WINAPI
5241 create_toolhelp32_snapshot (DWORD Flags, DWORD Ignored)
5242 {
5243   static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot = NULL;
5244
5245   if (g_b_init_create_toolhelp32_snapshot == 0)
5246     {
5247       g_b_init_create_toolhelp32_snapshot = 1;
5248       s_pfn_Create_Toolhelp32_Snapshot = (CreateToolhelp32Snapshot_Proc)
5249         GetProcAddress (GetModuleHandle ("kernel32.dll"),
5250                         "CreateToolhelp32Snapshot");
5251     }
5252   if (s_pfn_Create_Toolhelp32_Snapshot == NULL)
5253     {
5254       return INVALID_HANDLE_VALUE;
5255     }
5256   return (s_pfn_Create_Toolhelp32_Snapshot (Flags, Ignored));
5257 }
5258
5259 static BOOL WINAPI
5260 process32_first (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
5261 {
5262   static Process32First_Proc s_pfn_Process32_First = NULL;
5263
5264   if (g_b_init_process32_first == 0)
5265     {
5266       g_b_init_process32_first = 1;
5267       s_pfn_Process32_First = (Process32First_Proc)
5268         GetProcAddress (GetModuleHandle ("kernel32.dll"),
5269                         "Process32First");
5270     }
5271   if (s_pfn_Process32_First == NULL)
5272     {
5273       return FALSE;
5274     }
5275   return (s_pfn_Process32_First (hSnapshot, lppe));
5276 }
5277
5278 static BOOL WINAPI
5279 process32_next (HANDLE hSnapshot, LPPROCESSENTRY32 lppe)
5280 {
5281   static Process32Next_Proc s_pfn_Process32_Next = NULL;
5282
5283   if (g_b_init_process32_next == 0)
5284     {
5285       g_b_init_process32_next = 1;
5286       s_pfn_Process32_Next = (Process32Next_Proc)
5287         GetProcAddress (GetModuleHandle ("kernel32.dll"),
5288                         "Process32Next");
5289     }
5290   if (s_pfn_Process32_Next == NULL)
5291     {
5292       return FALSE;
5293     }
5294   return (s_pfn_Process32_Next (hSnapshot, lppe));
5295 }
5296
5297 static BOOL WINAPI
5298 open_thread_token (HANDLE ThreadHandle,
5299                    DWORD DesiredAccess,
5300                    BOOL OpenAsSelf,
5301                    PHANDLE TokenHandle)
5302 {
5303   static OpenThreadToken_Proc s_pfn_Open_Thread_Token = NULL;
5304   HMODULE hm_advapi32 = NULL;
5305   if (is_windows_9x () == TRUE)
5306     {
5307       SetLastError (ERROR_NOT_SUPPORTED);
5308       return FALSE;
5309     }
5310   if (g_b_init_open_thread_token == 0)
5311     {
5312       g_b_init_open_thread_token = 1;
5313       hm_advapi32 = LoadLibrary ("Advapi32.dll");
5314       s_pfn_Open_Thread_Token =
5315         (OpenThreadToken_Proc) GetProcAddress (hm_advapi32, "OpenThreadToken");
5316     }
5317   if (s_pfn_Open_Thread_Token == NULL)
5318     {
5319       SetLastError (ERROR_NOT_SUPPORTED);
5320       return FALSE;
5321     }
5322   return (
5323       s_pfn_Open_Thread_Token (
5324           ThreadHandle,
5325           DesiredAccess,
5326           OpenAsSelf,
5327           TokenHandle)
5328       );
5329 }
5330
5331 static BOOL WINAPI
5332 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
5333 {
5334   static ImpersonateSelf_Proc s_pfn_Impersonate_Self = NULL;
5335   HMODULE hm_advapi32 = NULL;
5336   if (is_windows_9x () == TRUE)
5337     {
5338       return FALSE;
5339     }
5340   if (g_b_init_impersonate_self == 0)
5341     {
5342       g_b_init_impersonate_self = 1;
5343       hm_advapi32 = LoadLibrary ("Advapi32.dll");
5344       s_pfn_Impersonate_Self =
5345         (ImpersonateSelf_Proc) GetProcAddress (hm_advapi32, "ImpersonateSelf");
5346     }
5347   if (s_pfn_Impersonate_Self == NULL)
5348     {
5349       return FALSE;
5350     }
5351   return s_pfn_Impersonate_Self (ImpersonationLevel);
5352 }
5353
5354 static BOOL WINAPI
5355 revert_to_self (void)
5356 {
5357   static RevertToSelf_Proc s_pfn_Revert_To_Self = NULL;
5358   HMODULE hm_advapi32 = NULL;
5359   if (is_windows_9x () == TRUE)
5360     {
5361       return FALSE;
5362     }
5363   if (g_b_init_revert_to_self == 0)
5364     {
5365       g_b_init_revert_to_self = 1;
5366       hm_advapi32 = LoadLibrary ("Advapi32.dll");
5367       s_pfn_Revert_To_Self =
5368         (RevertToSelf_Proc) GetProcAddress (hm_advapi32, "RevertToSelf");
5369     }
5370   if (s_pfn_Revert_To_Self == NULL)
5371     {
5372       return FALSE;
5373     }
5374   return s_pfn_Revert_To_Self ();
5375 }
5376
5377 static BOOL WINAPI
5378 get_process_memory_info (HANDLE h_proc,
5379                          PPROCESS_MEMORY_COUNTERS mem_counters,
5380                          DWORD bufsize)
5381 {
5382   static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info = NULL;
5383   HMODULE hm_psapi = NULL;
5384   if (is_windows_9x () == TRUE)
5385     {
5386       return FALSE;
5387     }
5388   if (g_b_init_get_process_memory_info == 0)
5389     {
5390       g_b_init_get_process_memory_info = 1;
5391       hm_psapi = LoadLibrary ("Psapi.dll");
5392       if (hm_psapi)
5393         s_pfn_Get_Process_Memory_Info = (GetProcessMemoryInfo_Proc)
5394           GetProcAddress (hm_psapi, "GetProcessMemoryInfo");
5395     }
5396   if (s_pfn_Get_Process_Memory_Info == NULL)
5397     {
5398       return FALSE;
5399     }
5400   return s_pfn_Get_Process_Memory_Info (h_proc, mem_counters, bufsize);
5401 }
5402
5403 static BOOL WINAPI
5404 get_process_working_set_size (HANDLE h_proc,
5405                               PSIZE_T minrss,
5406                               PSIZE_T maxrss)
5407 {
5408   static GetProcessWorkingSetSize_Proc
5409     s_pfn_Get_Process_Working_Set_Size = NULL;
5410
5411   if (is_windows_9x () == TRUE)
5412     {
5413       return FALSE;
5414     }
5415   if (g_b_init_get_process_working_set_size == 0)
5416     {
5417       g_b_init_get_process_working_set_size = 1;
5418       s_pfn_Get_Process_Working_Set_Size = (GetProcessWorkingSetSize_Proc)
5419         GetProcAddress (GetModuleHandle ("kernel32.dll"),
5420                         "GetProcessWorkingSetSize");
5421     }
5422   if (s_pfn_Get_Process_Working_Set_Size == NULL)
5423     {
5424       return FALSE;
5425     }
5426   return s_pfn_Get_Process_Working_Set_Size (h_proc, minrss, maxrss);
5427 }
5428
5429 static BOOL WINAPI
5430 global_memory_status (MEMORYSTATUS *buf)
5431 {
5432   static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status = NULL;
5433
5434   if (is_windows_9x () == TRUE)
5435     {
5436       return FALSE;
5437     }
5438   if (g_b_init_global_memory_status == 0)
5439     {
5440       g_b_init_global_memory_status = 1;
5441       s_pfn_Global_Memory_Status = (GlobalMemoryStatus_Proc)
5442         GetProcAddress (GetModuleHandle ("kernel32.dll"),
5443                         "GlobalMemoryStatus");
5444     }
5445   if (s_pfn_Global_Memory_Status == NULL)
5446     {
5447       return FALSE;
5448     }
5449   return s_pfn_Global_Memory_Status (buf);
5450 }
5451
5452 static BOOL WINAPI
5453 global_memory_status_ex (MEMORY_STATUS_EX *buf)
5454 {
5455   static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex = NULL;
5456
5457   if (is_windows_9x () == TRUE)
5458     {
5459       return FALSE;
5460     }
5461   if (g_b_init_global_memory_status_ex == 0)
5462     {
5463       g_b_init_global_memory_status_ex = 1;
5464       s_pfn_Global_Memory_Status_Ex = (GlobalMemoryStatusEx_Proc)
5465         GetProcAddress (GetModuleHandle ("kernel32.dll"),
5466                         "GlobalMemoryStatusEx");
5467     }
5468   if (s_pfn_Global_Memory_Status_Ex == NULL)
5469     {
5470       return FALSE;
5471     }
5472   return s_pfn_Global_Memory_Status_Ex (buf);
5473 }
5474
5475 Lisp_Object
5476 list_system_processes (void)
5477 {
5478   struct gcpro gcpro1;
5479   Lisp_Object proclist = Qnil;
5480   HANDLE h_snapshot;
5481
5482   h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
5483
5484   if (h_snapshot != INVALID_HANDLE_VALUE)
5485     {
5486       PROCESSENTRY32 proc_entry;
5487       DWORD proc_id;
5488       BOOL res;
5489
5490       GCPRO1 (proclist);
5491
5492       proc_entry.dwSize = sizeof (PROCESSENTRY32);
5493       for (res = process32_first (h_snapshot, &proc_entry); res;
5494            res = process32_next  (h_snapshot, &proc_entry))
5495         {
5496           proc_id = proc_entry.th32ProcessID;
5497           proclist = Fcons (make_fixnum_or_float (proc_id), proclist);
5498         }
5499
5500       CloseHandle (h_snapshot);
5501       UNGCPRO;
5502       proclist = Fnreverse (proclist);
5503     }
5504
5505   return proclist;
5506 }
5507
5508 static int
5509 enable_privilege (LPCTSTR priv_name, BOOL enable_p, TOKEN_PRIVILEGES *old_priv)
5510 {
5511   TOKEN_PRIVILEGES priv;
5512   DWORD priv_size = sizeof (priv);
5513   DWORD opriv_size = sizeof (*old_priv);
5514   HANDLE h_token = NULL;
5515   HANDLE h_thread = GetCurrentThread ();
5516   int ret_val = 0;
5517   BOOL res;
5518
5519   res = open_thread_token (h_thread,
5520                            TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
5521                            FALSE, &h_token);
5522   if (!res && GetLastError () == ERROR_NO_TOKEN)
5523     {
5524       if (impersonate_self (SecurityImpersonation))
5525           res = open_thread_token (h_thread,
5526                                    TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
5527                                    FALSE, &h_token);
5528     }
5529   if (res)
5530     {
5531       priv.PrivilegeCount = 1;
5532       priv.Privileges[0].Attributes = enable_p ? SE_PRIVILEGE_ENABLED : 0;
5533       LookupPrivilegeValue (NULL, priv_name, &priv.Privileges[0].Luid);
5534       if (AdjustTokenPrivileges (h_token, FALSE, &priv, priv_size,
5535                                  old_priv, &opriv_size)
5536           && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
5537         ret_val = 1;
5538     }
5539   if (h_token)
5540     CloseHandle (h_token);
5541
5542   return ret_val;
5543 }
5544
5545 static int
5546 restore_privilege (TOKEN_PRIVILEGES *priv)
5547 {
5548   DWORD priv_size = sizeof (*priv);
5549   HANDLE h_token = NULL;
5550   int ret_val = 0;
5551
5552   if (open_thread_token (GetCurrentThread (),
5553                          TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES,
5554                          FALSE, &h_token))
5555     {
5556       if (AdjustTokenPrivileges (h_token, FALSE, priv, priv_size, NULL, NULL)
5557           && GetLastError () != ERROR_NOT_ALL_ASSIGNED)
5558         ret_val = 1;
5559     }
5560   if (h_token)
5561     CloseHandle (h_token);
5562
5563   return ret_val;
5564 }
5565
5566 static Lisp_Object
5567 ltime (ULONGLONG time_100ns)
5568 {
5569   ULONGLONG time_sec = time_100ns / 10000000;
5570   int subsec = time_100ns % 10000000;
5571   return list4 (make_number (time_sec >> 16),
5572                 make_number (time_sec & 0xffff),
5573                 make_number (subsec / 10),
5574                 make_number (subsec % 10 * 100000));
5575 }
5576
5577 #define U64_TO_LISP_TIME(time) ltime (time)
5578
5579 static int
5580 process_times (HANDLE h_proc, Lisp_Object *ctime, Lisp_Object *etime,
5581                Lisp_Object *stime, Lisp_Object *utime, Lisp_Object *ttime,
5582                double *pcpu)
5583 {
5584   FILETIME ft_creation, ft_exit, ft_kernel, ft_user, ft_current;
5585   ULONGLONG tem1, tem2, tem3, tem;
5586
5587   if (!h_proc
5588       || !get_process_times_fn
5589       || !(*get_process_times_fn) (h_proc, &ft_creation, &ft_exit,
5590                                    &ft_kernel, &ft_user))
5591     return 0;
5592
5593   GetSystemTimeAsFileTime (&ft_current);
5594
5595   FILETIME_TO_U64 (tem1, ft_kernel);
5596   *stime = U64_TO_LISP_TIME (tem1);
5597
5598   FILETIME_TO_U64 (tem2, ft_user);
5599   *utime = U64_TO_LISP_TIME (tem2);
5600
5601   tem3 = tem1 + tem2;
5602   *ttime = U64_TO_LISP_TIME (tem3);
5603
5604   FILETIME_TO_U64 (tem, ft_creation);
5605   /* Process no 4 (System) returns zero creation time.  */
5606   if (tem)
5607     tem -= utc_base;
5608   *ctime = U64_TO_LISP_TIME (tem);
5609
5610   if (tem)
5611     {
5612       FILETIME_TO_U64 (tem3, ft_current);
5613       tem = (tem3 - utc_base) - tem;
5614     }
5615   *etime = U64_TO_LISP_TIME (tem);
5616
5617   if (tem)
5618     {
5619       *pcpu = 100.0 * (tem1 + tem2) / tem;
5620       if (*pcpu > 100)
5621         *pcpu = 100.0;
5622     }
5623   else
5624     *pcpu = 0;
5625
5626   return 1;
5627 }
5628
5629 Lisp_Object
5630 system_process_attributes (Lisp_Object pid)
5631 {
5632   struct gcpro gcpro1, gcpro2, gcpro3;
5633   Lisp_Object attrs = Qnil;
5634   Lisp_Object cmd_str, decoded_cmd, tem;
5635   HANDLE h_snapshot, h_proc;
5636   DWORD proc_id;
5637   int found_proc = 0;
5638   char uname[UNLEN+1], gname[GNLEN+1], domain[1025];
5639   DWORD ulength = sizeof (uname), dlength = sizeof (domain), needed;
5640   DWORD glength = sizeof (gname);
5641   HANDLE token = NULL;
5642   SID_NAME_USE user_type;
5643   unsigned char *buf = NULL;
5644   DWORD blen = 0;
5645   TOKEN_USER user_token;
5646   TOKEN_PRIMARY_GROUP group_token;
5647   unsigned euid;
5648   unsigned egid;
5649   PROCESS_MEMORY_COUNTERS mem;
5650   PROCESS_MEMORY_COUNTERS_EX mem_ex;
5651   SIZE_T minrss, maxrss;
5652   MEMORYSTATUS memst;
5653   MEMORY_STATUS_EX memstex;
5654   double totphys = 0.0;
5655   Lisp_Object ctime, stime, utime, etime, ttime;
5656   double pcpu;
5657   BOOL result = FALSE;
5658
5659   CHECK_NUMBER_OR_FLOAT (pid);
5660   proc_id = FLOATP (pid) ? XFLOAT_DATA (pid) : XINT (pid);
5661
5662   h_snapshot = create_toolhelp32_snapshot (TH32CS_SNAPPROCESS, 0);
5663
5664   GCPRO3 (attrs, decoded_cmd, tem);
5665
5666   if (h_snapshot != INVALID_HANDLE_VALUE)
5667     {
5668       PROCESSENTRY32 pe;
5669       BOOL res;
5670
5671       pe.dwSize = sizeof (PROCESSENTRY32);
5672       for (res = process32_first (h_snapshot, &pe); res;
5673            res = process32_next  (h_snapshot, &pe))
5674         {
5675           if (proc_id == pe.th32ProcessID)
5676             {
5677               if (proc_id == 0)
5678                 decoded_cmd = build_string ("Idle");
5679               else
5680                 {
5681                   /* Decode the command name from locale-specific
5682                      encoding.  */
5683                   cmd_str = make_unibyte_string (pe.szExeFile,
5684                                                  strlen (pe.szExeFile));
5685                   decoded_cmd =
5686                     code_convert_string_norecord (cmd_str,
5687                                                   Vlocale_coding_system, 0);
5688                 }
5689               attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
5690               attrs = Fcons (Fcons (Qppid,
5691                                     make_fixnum_or_float (pe.th32ParentProcessID)),
5692                              attrs);
5693               attrs = Fcons (Fcons (Qpri, make_number (pe.pcPriClassBase)),
5694                              attrs);
5695               attrs = Fcons (Fcons (Qthcount,
5696                                     make_fixnum_or_float (pe.cntThreads)),
5697                              attrs);
5698               found_proc = 1;
5699               break;
5700             }
5701         }
5702
5703       CloseHandle (h_snapshot);
5704     }
5705
5706   if (!found_proc)
5707     {
5708       UNGCPRO;
5709       return Qnil;
5710     }
5711
5712   h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
5713                         FALSE, proc_id);
5714   /* If we were denied a handle to the process, try again after
5715      enabling the SeDebugPrivilege in our process.  */
5716   if (!h_proc)
5717     {
5718       TOKEN_PRIVILEGES priv_current;
5719
5720       if (enable_privilege (SE_DEBUG_NAME, TRUE, &priv_current))
5721         {
5722           h_proc = OpenProcess (PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
5723                                 FALSE, proc_id);
5724           restore_privilege (&priv_current);
5725           revert_to_self ();
5726         }
5727     }
5728   if (h_proc)
5729     {
5730       result = open_process_token (h_proc, TOKEN_QUERY, &token);
5731       if (result)
5732         {
5733           result = get_token_information (token, TokenUser, NULL, 0, &blen);
5734           if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
5735             {
5736               buf = xmalloc (blen);
5737               result = get_token_information (token, TokenUser,
5738                                               (LPVOID)buf, blen, &needed);
5739               if (result)
5740                 {
5741                   memcpy (&user_token, buf, sizeof (user_token));
5742                   if (!w32_cached_id (user_token.User.Sid, &euid, uname))
5743                     {
5744                       euid = get_rid (user_token.User.Sid);
5745                       result = lookup_account_sid (NULL, user_token.User.Sid,
5746                                                    uname, &ulength,
5747                                                    domain, &dlength,
5748                                                    &user_type);
5749                       if (result)
5750                         w32_add_to_cache (user_token.User.Sid, euid, uname);
5751                       else
5752                         {
5753                           strcpy (uname, "unknown");
5754                           result = TRUE;
5755                         }
5756                     }
5757                   ulength = strlen (uname);
5758                 }
5759             }
5760         }
5761       if (result)
5762         {
5763           /* Determine a reasonable euid and gid values.  */
5764           if (xstrcasecmp ("administrator", uname) == 0)
5765             {
5766               euid = 500;       /* well-known Administrator uid */
5767               egid = 513;       /* well-known None gid */
5768             }
5769           else
5770             {
5771               /* Get group id and name.  */
5772               result = get_token_information (token, TokenPrimaryGroup,
5773                                               (LPVOID)buf, blen, &needed);
5774               if (!result && GetLastError () == ERROR_INSUFFICIENT_BUFFER)
5775                 {
5776                   buf = xrealloc (buf, blen = needed);
5777                   result = get_token_information (token, TokenPrimaryGroup,
5778                                                   (LPVOID)buf, blen, &needed);
5779                 }
5780               if (result)
5781                 {
5782                   memcpy (&group_token, buf, sizeof (group_token));
5783                   if (!w32_cached_id (group_token.PrimaryGroup, &egid, gname))
5784                     {
5785                       egid = get_rid (group_token.PrimaryGroup);
5786                       dlength = sizeof (domain);
5787                       result =
5788                         lookup_account_sid (NULL, group_token.PrimaryGroup,
5789                                             gname, &glength, NULL, &dlength,
5790                                             &user_type);
5791                       if (result)
5792                         w32_add_to_cache (group_token.PrimaryGroup,
5793                                           egid, gname);
5794                       else
5795                         {
5796                           strcpy (gname, "None");
5797                           result = TRUE;
5798                         }
5799                     }
5800                   glength = strlen (gname);
5801                 }
5802             }
5803         }
5804       xfree (buf);
5805     }
5806   if (!result)
5807     {
5808       if (!is_windows_9x ())
5809         {
5810           /* We couldn't open the process token, presumably because of
5811              insufficient access rights.  Assume this process is run
5812              by the system.  */
5813           strcpy (uname, "SYSTEM");
5814           strcpy (gname, "None");
5815           euid = 18;    /* SYSTEM */
5816           egid = 513;   /* None */
5817           glength = strlen (gname);
5818           ulength = strlen (uname);
5819         }
5820       /* If we are running under Windows 9X, where security calls are
5821          not supported, we assume all processes are run by the current
5822          user.  */
5823       else if (GetUserName (uname, &ulength))
5824         {
5825           if (xstrcasecmp ("administrator", uname) == 0)
5826             euid = 0;
5827           else
5828             euid = 123;
5829           egid = euid;
5830           strcpy (gname, "None");
5831           glength = strlen (gname);
5832           ulength = strlen (uname);
5833         }
5834       else
5835         {
5836           euid = 123;
5837           egid = 123;
5838           strcpy (uname, "administrator");
5839           ulength = strlen (uname);
5840           strcpy (gname, "None");
5841           glength = strlen (gname);
5842         }
5843       if (token)
5844         CloseHandle (token);
5845     }
5846
5847   attrs = Fcons (Fcons (Qeuid, make_fixnum_or_float (euid)), attrs);
5848   tem = make_unibyte_string (uname, ulength);
5849   attrs = Fcons (Fcons (Quser,
5850                          code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
5851                  attrs);
5852   attrs = Fcons (Fcons (Qegid, make_fixnum_or_float (egid)), attrs);
5853   tem = make_unibyte_string (gname, glength);
5854   attrs = Fcons (Fcons (Qgroup,
5855                          code_convert_string_norecord (tem, Vlocale_coding_system, 0)),
5856                  attrs);
5857
5858   if (global_memory_status_ex (&memstex))
5859 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5860     totphys = memstex.ullTotalPhys / 1024.0;
5861 #else
5862   /* Visual Studio 6 cannot convert an unsigned __int64 type to
5863      double, so we need to do this for it...  */
5864     {
5865       DWORD tot_hi = memstex.ullTotalPhys >> 32;
5866       DWORD tot_md = (memstex.ullTotalPhys & 0x00000000ffffffff) >> 10;
5867       DWORD tot_lo = memstex.ullTotalPhys % 1024;
5868
5869       totphys = tot_hi * 4194304.0 + tot_md + tot_lo / 1024.0;
5870     }
5871 #endif  /* __GNUC__ || _MSC_VER >= 1300 */
5872   else if (global_memory_status (&memst))
5873     totphys = memst.dwTotalPhys / 1024.0;
5874
5875   if (h_proc
5876       && get_process_memory_info (h_proc, (PROCESS_MEMORY_COUNTERS *)&mem_ex,
5877                                   sizeof (mem_ex)))
5878     {
5879       SIZE_T rss = mem_ex.WorkingSetSize / 1024;
5880
5881       attrs = Fcons (Fcons (Qmajflt,
5882                             make_fixnum_or_float (mem_ex.PageFaultCount)),
5883                      attrs);
5884       attrs = Fcons (Fcons (Qvsize,
5885                             make_fixnum_or_float (mem_ex.PrivateUsage / 1024)),
5886                      attrs);
5887       attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
5888       if (totphys)
5889         attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
5890     }
5891   else if (h_proc
5892            && get_process_memory_info (h_proc, &mem, sizeof (mem)))
5893     {
5894       SIZE_T rss = mem_ex.WorkingSetSize / 1024;
5895
5896       attrs = Fcons (Fcons (Qmajflt,
5897                             make_fixnum_or_float (mem.PageFaultCount)),
5898                      attrs);
5899       attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (rss)), attrs);
5900       if (totphys)
5901         attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
5902     }
5903   else if (h_proc
5904            && get_process_working_set_size (h_proc, &minrss, &maxrss))
5905     {
5906       DWORD rss = maxrss / 1024;
5907
5908       attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (maxrss / 1024)), attrs);
5909       if (totphys)
5910         attrs = Fcons (Fcons (Qpmem, make_float (100. * rss / totphys)), attrs);
5911     }
5912
5913   if (process_times (h_proc, &ctime, &etime, &stime, &utime, &ttime, &pcpu))
5914     {
5915       attrs = Fcons (Fcons (Qutime, utime), attrs);
5916       attrs = Fcons (Fcons (Qstime, stime), attrs);
5917       attrs = Fcons (Fcons (Qtime,  ttime), attrs);
5918       attrs = Fcons (Fcons (Qstart, ctime), attrs);
5919       attrs = Fcons (Fcons (Qetime, etime), attrs);
5920       attrs = Fcons (Fcons (Qpcpu, make_float (pcpu)), attrs);
5921     }
5922
5923   /* FIXME: Retrieve command line by walking the PEB of the process.  */
5924
5925   if (h_proc)
5926     CloseHandle (h_proc);
5927   UNGCPRO;
5928   return attrs;
5929 }
5930
5931 \f
5932 /* Wrappers for  winsock functions to map between our file descriptors
5933    and winsock's handles; also set h_errno for convenience.
5934
5935    To allow Emacs to run on systems which don't have winsock support
5936    installed, we dynamically link to winsock on startup if present, and
5937    otherwise provide the minimum necessary functionality
5938    (eg. gethostname). */
5939
5940 /* function pointers for relevant socket functions */
5941 int (PASCAL *pfn_WSAStartup) (WORD wVersionRequired, LPWSADATA lpWSAData);
5942 void (PASCAL *pfn_WSASetLastError) (int iError);
5943 int (PASCAL *pfn_WSAGetLastError) (void);
5944 int (PASCAL *pfn_WSAEventSelect) (SOCKET s, HANDLE hEventObject, long lNetworkEvents);
5945 HANDLE (PASCAL *pfn_WSACreateEvent) (void);
5946 int (PASCAL *pfn_WSACloseEvent) (HANDLE hEvent);
5947 int (PASCAL *pfn_socket) (int af, int type, int protocol);
5948 int (PASCAL *pfn_bind) (SOCKET s, const struct sockaddr *addr, int namelen);
5949 int (PASCAL *pfn_connect) (SOCKET s, const struct sockaddr *addr, int namelen);
5950 int (PASCAL *pfn_ioctlsocket) (SOCKET s, long cmd, u_long *argp);
5951 int (PASCAL *pfn_recv) (SOCKET s, char * buf, int len, int flags);
5952 int (PASCAL *pfn_send) (SOCKET s, const char * buf, int len, int flags);
5953 int (PASCAL *pfn_closesocket) (SOCKET s);
5954 int (PASCAL *pfn_shutdown) (SOCKET s, int how);
5955 int (PASCAL *pfn_WSACleanup) (void);
5956
5957 u_short (PASCAL *pfn_htons) (u_short hostshort);
5958 u_short (PASCAL *pfn_ntohs) (u_short netshort);
5959 unsigned long (PASCAL *pfn_inet_addr) (const char * cp);
5960 int (PASCAL *pfn_gethostname) (char * name, int namelen);
5961 struct hostent * (PASCAL *pfn_gethostbyname) (const char * name);
5962 struct servent * (PASCAL *pfn_getservbyname) (const char * name, const char * proto);
5963 int (PASCAL *pfn_getpeername) (SOCKET s, struct sockaddr *addr, int * namelen);
5964 int (PASCAL *pfn_setsockopt) (SOCKET s, int level, int optname,
5965                               const char * optval, int optlen);
5966 int (PASCAL *pfn_listen) (SOCKET s, int backlog);
5967 int (PASCAL *pfn_getsockname) (SOCKET s, struct sockaddr * name,
5968                                int * namelen);
5969 SOCKET (PASCAL *pfn_accept) (SOCKET s, struct sockaddr * addr, int * addrlen);
5970 int (PASCAL *pfn_recvfrom) (SOCKET s, char * buf, int len, int flags,
5971                        struct sockaddr * from, int * fromlen);
5972 int (PASCAL *pfn_sendto) (SOCKET s, const char * buf, int len, int flags,
5973                           const struct sockaddr * to, int tolen);
5974
5975 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5976 BOOL (WINAPI *pfn_SetHandleInformation) (HANDLE object, DWORD mask, DWORD flags);
5977 #ifndef HANDLE_FLAG_INHERIT
5978 #define HANDLE_FLAG_INHERIT     1
5979 #endif
5980
5981 HANDLE winsock_lib;
5982 static int winsock_inuse;
5983
5984 BOOL
5985 term_winsock (void)
5986 {
5987   if (winsock_lib != NULL && winsock_inuse == 0)
5988     {
5989       /* Not sure what would cause WSAENETDOWN, or even if it can happen
5990          after WSAStartup returns successfully, but it seems reasonable
5991          to allow unloading winsock anyway in that case. */
5992       if (pfn_WSACleanup () == 0 ||
5993           pfn_WSAGetLastError () == WSAENETDOWN)
5994         {
5995           if (FreeLibrary (winsock_lib))
5996           winsock_lib = NULL;
5997           return TRUE;
5998         }
5999     }
6000   return FALSE;
6001 }
6002
6003 BOOL
6004 init_winsock (int load_now)
6005 {
6006   WSADATA  winsockData;
6007
6008   if (winsock_lib != NULL)
6009     return TRUE;
6010
6011   pfn_SetHandleInformation
6012     = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
6013                                "SetHandleInformation");
6014
6015   winsock_lib = LoadLibrary ("Ws2_32.dll");
6016
6017   if (winsock_lib != NULL)
6018     {
6019       /* dynamically link to socket functions */
6020
6021 #define LOAD_PROC(fn) \
6022       if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
6023         goto fail;
6024
6025       LOAD_PROC (WSAStartup);
6026       LOAD_PROC (WSASetLastError);
6027       LOAD_PROC (WSAGetLastError);
6028       LOAD_PROC (WSAEventSelect);
6029       LOAD_PROC (WSACreateEvent);
6030       LOAD_PROC (WSACloseEvent);
6031       LOAD_PROC (socket);
6032       LOAD_PROC (bind);
6033       LOAD_PROC (connect);
6034       LOAD_PROC (ioctlsocket);
6035       LOAD_PROC (recv);
6036       LOAD_PROC (send);
6037       LOAD_PROC (closesocket);
6038       LOAD_PROC (shutdown);
6039       LOAD_PROC (htons);
6040       LOAD_PROC (ntohs);
6041       LOAD_PROC (inet_addr);
6042       LOAD_PROC (gethostname);
6043       LOAD_PROC (gethostbyname);
6044       LOAD_PROC (getservbyname);
6045       LOAD_PROC (getpeername);
6046       LOAD_PROC (WSACleanup);
6047       LOAD_PROC (setsockopt);
6048       LOAD_PROC (listen);
6049       LOAD_PROC (getsockname);
6050       LOAD_PROC (accept);
6051       LOAD_PROC (recvfrom);
6052       LOAD_PROC (sendto);
6053 #undef LOAD_PROC
6054
6055       /* specify version 1.1 of winsock */
6056       if (pfn_WSAStartup (0x101, &winsockData) == 0)
6057         {
6058           if (winsockData.wVersion != 0x101)
6059             goto fail;
6060
6061           if (!load_now)
6062             {
6063               /* Report that winsock exists and is usable, but leave
6064                  socket functions disabled.  I am assuming that calling
6065                  WSAStartup does not require any network interaction,
6066                  and in particular does not cause or require a dial-up
6067                  connection to be established. */
6068
6069               pfn_WSACleanup ();
6070               FreeLibrary (winsock_lib);
6071               winsock_lib = NULL;
6072             }
6073           winsock_inuse = 0;
6074           return TRUE;
6075         }
6076
6077     fail:
6078       FreeLibrary (winsock_lib);
6079       winsock_lib = NULL;
6080     }
6081
6082   return FALSE;
6083 }
6084
6085
6086 int h_errno = 0;
6087
6088 /* function to set h_errno for compatibility; map winsock error codes to
6089    normal system codes where they overlap (non-overlapping definitions
6090    are already in <sys/socket.h> */
6091 static void
6092 set_errno (void)
6093 {
6094   if (winsock_lib == NULL)
6095     h_errno = EINVAL;
6096   else
6097     h_errno = pfn_WSAGetLastError ();
6098
6099   switch (h_errno)
6100     {
6101     case WSAEACCES:             h_errno = EACCES; break;
6102     case WSAEBADF:              h_errno = EBADF; break;
6103     case WSAEFAULT:             h_errno = EFAULT; break;
6104     case WSAEINTR:              h_errno = EINTR; break;
6105     case WSAEINVAL:             h_errno = EINVAL; break;
6106     case WSAEMFILE:             h_errno = EMFILE; break;
6107     case WSAENAMETOOLONG:       h_errno = ENAMETOOLONG; break;
6108     case WSAENOTEMPTY:          h_errno = ENOTEMPTY; break;
6109     }
6110   errno = h_errno;
6111 }
6112
6113 static void
6114 check_errno (void)
6115 {
6116   if (h_errno == 0 && winsock_lib != NULL)
6117     pfn_WSASetLastError (0);
6118 }
6119
6120 /* Extend strerror to handle the winsock-specific error codes.  */
6121 struct {
6122   int errnum;
6123   char * msg;
6124 } _wsa_errlist[] = {
6125   {WSAEINTR                , "Interrupted function call"},
6126   {WSAEBADF                , "Bad file descriptor"},
6127   {WSAEACCES               , "Permission denied"},
6128   {WSAEFAULT               , "Bad address"},
6129   {WSAEINVAL               , "Invalid argument"},
6130   {WSAEMFILE               , "Too many open files"},
6131
6132   {WSAEWOULDBLOCK          , "Resource temporarily unavailable"},
6133   {WSAEINPROGRESS          , "Operation now in progress"},
6134   {WSAEALREADY             , "Operation already in progress"},
6135   {WSAENOTSOCK             , "Socket operation on non-socket"},
6136   {WSAEDESTADDRREQ         , "Destination address required"},
6137   {WSAEMSGSIZE             , "Message too long"},
6138   {WSAEPROTOTYPE           , "Protocol wrong type for socket"},
6139   {WSAENOPROTOOPT          , "Bad protocol option"},
6140   {WSAEPROTONOSUPPORT      , "Protocol not supported"},
6141   {WSAESOCKTNOSUPPORT      , "Socket type not supported"},
6142   {WSAEOPNOTSUPP           , "Operation not supported"},
6143   {WSAEPFNOSUPPORT         , "Protocol family not supported"},
6144   {WSAEAFNOSUPPORT         , "Address family not supported by protocol family"},
6145   {WSAEADDRINUSE           , "Address already in use"},
6146   {WSAEADDRNOTAVAIL        , "Cannot assign requested address"},
6147   {WSAENETDOWN             , "Network is down"},
6148   {WSAENETUNREACH          , "Network is unreachable"},
6149   {WSAENETRESET            , "Network dropped connection on reset"},
6150   {WSAECONNABORTED         , "Software caused connection abort"},
6151   {WSAECONNRESET           , "Connection reset by peer"},
6152   {WSAENOBUFS              , "No buffer space available"},
6153   {WSAEISCONN              , "Socket is already connected"},
6154   {WSAENOTCONN             , "Socket is not connected"},
6155   {WSAESHUTDOWN            , "Cannot send after socket shutdown"},
6156   {WSAETOOMANYREFS         , "Too many references"},        /* not sure */
6157   {WSAETIMEDOUT            , "Connection timed out"},
6158   {WSAECONNREFUSED         , "Connection refused"},
6159   {WSAELOOP                , "Network loop"},               /* not sure */
6160   {WSAENAMETOOLONG         , "Name is too long"},
6161   {WSAEHOSTDOWN            , "Host is down"},
6162   {WSAEHOSTUNREACH         , "No route to host"},
6163   {WSAENOTEMPTY            , "Buffer not empty"},           /* not sure */
6164   {WSAEPROCLIM             , "Too many processes"},
6165   {WSAEUSERS               , "Too many users"},             /* not sure */
6166   {WSAEDQUOT               , "Double quote in host name"},  /* really not sure */
6167   {WSAESTALE               , "Data is stale"},              /* not sure */
6168   {WSAEREMOTE              , "Remote error"},               /* not sure */
6169
6170   {WSASYSNOTREADY          , "Network subsystem is unavailable"},
6171   {WSAVERNOTSUPPORTED      , "WINSOCK.DLL version out of range"},
6172   {WSANOTINITIALISED       , "Winsock not initialized successfully"},
6173   {WSAEDISCON              , "Graceful shutdown in progress"},
6174 #ifdef WSAENOMORE
6175   {WSAENOMORE              , "No more operations allowed"}, /* not sure */
6176   {WSAECANCELLED           , "Operation cancelled"},        /* not sure */
6177   {WSAEINVALIDPROCTABLE    , "Invalid procedure table from service provider"},
6178   {WSAEINVALIDPROVIDER     , "Invalid service provider version number"},
6179   {WSAEPROVIDERFAILEDINIT  , "Unable to initialize a service provider"},
6180   {WSASYSCALLFAILURE       , "System call failure"},
6181   {WSASERVICE_NOT_FOUND    , "Service not found"},          /* not sure */
6182   {WSATYPE_NOT_FOUND       , "Class type not found"},
6183   {WSA_E_NO_MORE           , "No more resources available"}, /* really not sure */
6184   {WSA_E_CANCELLED         , "Operation already cancelled"}, /* really not sure */
6185   {WSAEREFUSED             , "Operation refused"},          /* not sure */
6186 #endif
6187
6188   {WSAHOST_NOT_FOUND       , "Host not found"},
6189   {WSATRY_AGAIN            , "Authoritative host not found during name lookup"},
6190   {WSANO_RECOVERY          , "Non-recoverable error during name lookup"},
6191   {WSANO_DATA              , "Valid name, no data record of requested type"},
6192
6193   {-1, NULL}
6194 };
6195
6196 char *
6197 sys_strerror (int error_no)
6198 {
6199   int i;
6200   static char unknown_msg[40];
6201
6202   if (error_no >= 0 && error_no < sys_nerr)
6203     return sys_errlist[error_no];
6204
6205   for (i = 0; _wsa_errlist[i].errnum >= 0; i++)
6206     if (_wsa_errlist[i].errnum == error_no)
6207       return _wsa_errlist[i].msg;
6208
6209   sprintf (unknown_msg, "Unidentified error: %d", error_no);
6210   return unknown_msg;
6211 }
6212
6213 /* [andrewi 3-May-96] I've had conflicting results using both methods,
6214    but I believe the method of keeping the socket handle separate (and
6215    insuring it is not inheritable) is the correct one. */
6216
6217 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
6218
6219 static int socket_to_fd (SOCKET s);
6220
6221 int
6222 sys_socket (int af, int type, int protocol)
6223 {
6224   SOCKET s;
6225
6226   if (winsock_lib == NULL)
6227     {
6228       h_errno = ENETDOWN;
6229       return INVALID_SOCKET;
6230     }
6231
6232   check_errno ();
6233
6234   /* call the real socket function */
6235   s = pfn_socket (af, type, protocol);
6236
6237   if (s != INVALID_SOCKET)
6238     return socket_to_fd (s);
6239
6240   set_errno ();
6241   return -1;
6242 }
6243
6244 /* Convert a SOCKET to a file descriptor.  */
6245 static int
6246 socket_to_fd (SOCKET s)
6247 {
6248   int fd;
6249   child_process * cp;
6250
6251   /* Although under NT 3.5 _open_osfhandle will accept a socket
6252      handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
6253      that does not work under NT 3.1.  However, we can get the same
6254      effect by using a backdoor function to replace an existing
6255      descriptor handle with the one we want. */
6256
6257   /* allocate a file descriptor (with appropriate flags) */
6258   fd = _open ("NUL:", _O_RDWR);
6259   if (fd >= 0)
6260     {
6261       /* Make a non-inheritable copy of the socket handle.  Note
6262          that it is possible that sockets aren't actually kernel
6263          handles, which appears to be the case on Windows 9x when
6264          the MS Proxy winsock client is installed.  */
6265       {
6266         /* Apparently there is a bug in NT 3.51 with some service
6267            packs, which prevents using DuplicateHandle to make a
6268            socket handle non-inheritable (causes WSACleanup to
6269            hang).  The work-around is to use SetHandleInformation
6270            instead if it is available and implemented. */
6271         if (pfn_SetHandleInformation)
6272           {
6273             pfn_SetHandleInformation ((HANDLE) s, HANDLE_FLAG_INHERIT, 0);
6274           }
6275         else
6276           {
6277             HANDLE parent = GetCurrentProcess ();
6278             HANDLE new_s = INVALID_HANDLE_VALUE;
6279
6280             if (DuplicateHandle (parent,
6281                                  (HANDLE) s,
6282                                  parent,
6283                                  &new_s,
6284                                  0,
6285                                  FALSE,
6286                                  DUPLICATE_SAME_ACCESS))
6287               {
6288                 /* It is possible that DuplicateHandle succeeds even
6289                    though the socket wasn't really a kernel handle,
6290                    because a real handle has the same value.  So
6291                    test whether the new handle really is a socket.  */
6292                 long nonblocking = 0;
6293                 if (pfn_ioctlsocket ((SOCKET) new_s, FIONBIO, &nonblocking) == 0)
6294                   {
6295                     pfn_closesocket (s);
6296                     s = (SOCKET) new_s;
6297                   }
6298                 else
6299                   {
6300                     CloseHandle (new_s);
6301                   }
6302               }
6303           }
6304       }
6305       fd_info[fd].hnd = (HANDLE) s;
6306
6307       /* set our own internal flags */
6308       fd_info[fd].flags = FILE_SOCKET | FILE_BINARY | FILE_READ | FILE_WRITE;
6309
6310       cp = new_child ();
6311       if (cp)
6312         {
6313           cp->fd = fd;
6314           cp->status = STATUS_READ_ACKNOWLEDGED;
6315
6316           /* attach child_process to fd_info */
6317           if (fd_info[ fd ].cp != NULL)
6318             {
6319               DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd));
6320               emacs_abort ();
6321             }
6322
6323           fd_info[ fd ].cp = cp;
6324
6325           /* success! */
6326           winsock_inuse++;      /* count open sockets */
6327           return fd;
6328         }
6329
6330       /* clean up */
6331       _close (fd);
6332     }
6333   pfn_closesocket (s);
6334   h_errno = EMFILE;
6335   return -1;
6336 }
6337
6338 int
6339 sys_bind (int s, const struct sockaddr * addr, int namelen)
6340 {
6341   if (winsock_lib == NULL)
6342     {
6343       h_errno = ENOTSOCK;
6344       return SOCKET_ERROR;
6345     }
6346
6347   check_errno ();
6348   if (fd_info[s].flags & FILE_SOCKET)
6349     {
6350       int rc = pfn_bind (SOCK_HANDLE (s), addr, namelen);
6351       if (rc == SOCKET_ERROR)
6352         set_errno ();
6353       return rc;
6354     }
6355   h_errno = ENOTSOCK;
6356   return SOCKET_ERROR;
6357 }
6358
6359 int
6360 sys_connect (int s, const struct sockaddr * name, int namelen)
6361 {
6362   if (winsock_lib == NULL)
6363     {
6364       h_errno = ENOTSOCK;
6365       return SOCKET_ERROR;
6366     }
6367
6368   check_errno ();
6369   if (fd_info[s].flags & FILE_SOCKET)
6370     {
6371       int rc = pfn_connect (SOCK_HANDLE (s), name, namelen);
6372       if (rc == SOCKET_ERROR)
6373         set_errno ();
6374       return rc;
6375     }
6376   h_errno = ENOTSOCK;
6377   return SOCKET_ERROR;
6378 }
6379
6380 u_short
6381 sys_htons (u_short hostshort)
6382 {
6383   return (winsock_lib != NULL) ?
6384     pfn_htons (hostshort) : hostshort;
6385 }
6386
6387 u_short
6388 sys_ntohs (u_short netshort)
6389 {
6390   return (winsock_lib != NULL) ?
6391     pfn_ntohs (netshort) : netshort;
6392 }
6393
6394 unsigned long
6395 sys_inet_addr (const char * cp)
6396 {
6397   return (winsock_lib != NULL) ?
6398     pfn_inet_addr (cp) : INADDR_NONE;
6399 }
6400
6401 int
6402 sys_gethostname (char * name, int namelen)
6403 {
6404   if (winsock_lib != NULL)
6405     return pfn_gethostname (name, namelen);
6406
6407   if (namelen > MAX_COMPUTERNAME_LENGTH)
6408     return !GetComputerName (name, (DWORD *)&namelen);
6409
6410   h_errno = EFAULT;
6411   return SOCKET_ERROR;
6412 }
6413
6414 struct hostent *
6415 sys_gethostbyname (const char * name)
6416 {
6417   struct hostent * host;
6418
6419   if (winsock_lib == NULL)
6420     {
6421       h_errno = ENETDOWN;
6422       return NULL;
6423     }
6424
6425   check_errno ();
6426   host = pfn_gethostbyname (name);
6427   if (!host)
6428     set_errno ();
6429   return host;
6430 }
6431
6432 struct servent *
6433 sys_getservbyname (const char * name, const char * proto)
6434 {
6435   struct servent * serv;
6436
6437   if (winsock_lib == NULL)
6438     {
6439       h_errno = ENETDOWN;
6440       return NULL;
6441     }
6442
6443   check_errno ();
6444   serv = pfn_getservbyname (name, proto);
6445   if (!serv)
6446     set_errno ();
6447   return serv;
6448 }
6449
6450 int
6451 sys_getpeername (int s, struct sockaddr *addr, int * namelen)
6452 {
6453   if (winsock_lib == NULL)
6454     {
6455       h_errno = ENETDOWN;
6456       return SOCKET_ERROR;
6457     }
6458
6459   check_errno ();
6460   if (fd_info[s].flags & FILE_SOCKET)
6461     {
6462       int rc = pfn_getpeername (SOCK_HANDLE (s), addr, namelen);
6463       if (rc == SOCKET_ERROR)
6464         set_errno ();
6465       return rc;
6466     }
6467   h_errno = ENOTSOCK;
6468   return SOCKET_ERROR;
6469 }
6470
6471 int
6472 sys_shutdown (int s, int how)
6473 {
6474   if (winsock_lib == NULL)
6475     {
6476       h_errno = ENETDOWN;
6477       return SOCKET_ERROR;
6478     }
6479
6480   check_errno ();
6481   if (fd_info[s].flags & FILE_SOCKET)
6482     {
6483       int rc = pfn_shutdown (SOCK_HANDLE (s), how);
6484       if (rc == SOCKET_ERROR)
6485         set_errno ();
6486       return rc;
6487     }
6488   h_errno = ENOTSOCK;
6489   return SOCKET_ERROR;
6490 }
6491
6492 int
6493 sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
6494 {
6495   if (winsock_lib == NULL)
6496     {
6497       h_errno = ENETDOWN;
6498       return SOCKET_ERROR;
6499     }
6500
6501   check_errno ();
6502   if (fd_info[s].flags & FILE_SOCKET)
6503     {
6504       int rc = pfn_setsockopt (SOCK_HANDLE (s), level, optname,
6505                                (const char *)optval, optlen);
6506       if (rc == SOCKET_ERROR)
6507         set_errno ();
6508       return rc;
6509     }
6510   h_errno = ENOTSOCK;
6511   return SOCKET_ERROR;
6512 }
6513
6514 int
6515 sys_listen (int s, int backlog)
6516 {
6517   if (winsock_lib == NULL)
6518     {
6519       h_errno = ENETDOWN;
6520       return SOCKET_ERROR;
6521     }
6522
6523   check_errno ();
6524   if (fd_info[s].flags & FILE_SOCKET)
6525     {
6526       int rc = pfn_listen (SOCK_HANDLE (s), backlog);
6527       if (rc == SOCKET_ERROR)
6528         set_errno ();
6529       else
6530         fd_info[s].flags |= FILE_LISTEN;
6531       return rc;
6532     }
6533   h_errno = ENOTSOCK;
6534   return SOCKET_ERROR;
6535 }
6536
6537 int
6538 sys_getsockname (int s, struct sockaddr * name, int * namelen)
6539 {
6540   if (winsock_lib == NULL)
6541     {
6542       h_errno = ENETDOWN;
6543       return SOCKET_ERROR;
6544     }
6545
6546   check_errno ();
6547   if (fd_info[s].flags & FILE_SOCKET)
6548     {
6549       int rc = pfn_getsockname (SOCK_HANDLE (s), name, namelen);
6550       if (rc == SOCKET_ERROR)
6551         set_errno ();
6552       return rc;
6553     }
6554   h_errno = ENOTSOCK;
6555   return SOCKET_ERROR;
6556 }
6557
6558 int
6559 sys_accept (int s, struct sockaddr * addr, int * addrlen)
6560 {
6561   if (winsock_lib == NULL)
6562     {
6563       h_errno = ENETDOWN;
6564       return -1;
6565     }
6566
6567   check_errno ();
6568   if (fd_info[s].flags & FILE_LISTEN)
6569     {
6570       SOCKET t = pfn_accept (SOCK_HANDLE (s), addr, addrlen);
6571       int fd = -1;
6572       if (t == INVALID_SOCKET)
6573         set_errno ();
6574       else
6575         fd = socket_to_fd (t);
6576
6577       fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
6578       ResetEvent (fd_info[s].cp->char_avail);
6579       return fd;
6580     }
6581   h_errno = ENOTSOCK;
6582   return -1;
6583 }
6584
6585 int
6586 sys_recvfrom (int s, char * buf, int len, int flags,
6587               struct sockaddr * from, int * fromlen)
6588 {
6589   if (winsock_lib == NULL)
6590     {
6591       h_errno = ENETDOWN;
6592       return SOCKET_ERROR;
6593     }
6594
6595   check_errno ();
6596   if (fd_info[s].flags & FILE_SOCKET)
6597     {
6598       int rc = pfn_recvfrom (SOCK_HANDLE (s), buf, len, flags, from, fromlen);
6599       if (rc == SOCKET_ERROR)
6600         set_errno ();
6601       return rc;
6602     }
6603   h_errno = ENOTSOCK;
6604   return SOCKET_ERROR;
6605 }
6606
6607 int
6608 sys_sendto (int s, const char * buf, int len, int flags,
6609             const struct sockaddr * to, int tolen)
6610 {
6611   if (winsock_lib == NULL)
6612     {
6613       h_errno = ENETDOWN;
6614       return SOCKET_ERROR;
6615     }
6616
6617   check_errno ();
6618   if (fd_info[s].flags & FILE_SOCKET)
6619     {
6620       int rc = pfn_sendto (SOCK_HANDLE (s), buf, len, flags, to, tolen);
6621       if (rc == SOCKET_ERROR)
6622         set_errno ();
6623       return rc;
6624     }
6625   h_errno = ENOTSOCK;
6626   return SOCKET_ERROR;
6627 }
6628
6629 /* Windows does not have an fcntl function.  Provide an implementation
6630    solely for making sockets non-blocking.  */
6631 int
6632 fcntl (int s, int cmd, int options)
6633 {
6634   if (winsock_lib == NULL)
6635     {
6636       h_errno = ENETDOWN;
6637       return -1;
6638     }
6639
6640   check_errno ();
6641   if (fd_info[s].flags & FILE_SOCKET)
6642     {
6643       if (cmd == F_SETFL && options == O_NONBLOCK)
6644         {
6645           unsigned long nblock = 1;
6646           int rc = pfn_ioctlsocket (SOCK_HANDLE (s), FIONBIO, &nblock);
6647           if (rc == SOCKET_ERROR)
6648             set_errno ();
6649           /* Keep track of the fact that we set this to non-blocking.  */
6650           fd_info[s].flags |= FILE_NDELAY;
6651           return rc;
6652         }
6653       else
6654         {
6655           h_errno = EINVAL;
6656           return SOCKET_ERROR;
6657         }
6658     }
6659   h_errno = ENOTSOCK;
6660   return SOCKET_ERROR;
6661 }
6662
6663
6664 /* Shadow main io functions: we need to handle pipes and sockets more
6665    intelligently, and implement non-blocking mode as well. */
6666
6667 int
6668 sys_close (int fd)
6669 {
6670   int rc;
6671
6672   if (fd < 0)
6673     {
6674       errno = EBADF;
6675       return -1;
6676     }
6677
6678   if (fd < MAXDESC && fd_info[fd].cp)
6679     {
6680       child_process * cp = fd_info[fd].cp;
6681
6682       fd_info[fd].cp = NULL;
6683
6684       if (CHILD_ACTIVE (cp))
6685         {
6686           /* if last descriptor to active child_process then cleanup */
6687           int i;
6688           for (i = 0; i < MAXDESC; i++)
6689             {
6690               if (i == fd)
6691                 continue;
6692               if (fd_info[i].cp == cp)
6693                 break;
6694             }
6695           if (i == MAXDESC)
6696             {
6697               if (fd_info[fd].flags & FILE_SOCKET)
6698                 {
6699                   if (winsock_lib == NULL) emacs_abort ();
6700
6701                   pfn_shutdown (SOCK_HANDLE (fd), 2);
6702                   rc = pfn_closesocket (SOCK_HANDLE (fd));
6703
6704                   winsock_inuse--; /* count open sockets */
6705                 }
6706               /* If the process handle is NULL, it's either a socket
6707                  or serial connection, or a subprocess that was
6708                  already reaped by reap_subprocess, but whose
6709                  resources were not yet freed, because its output was
6710                  not fully read yet by the time it was reaped.  (This
6711                  usually happens with async subprocesses whose output
6712                  is being read by Emacs.)  Otherwise, this process was
6713                  not reaped yet, so we set its FD to a negative value
6714                  to make sure sys_select will eventually get to
6715                  calling the SIGCHLD handler for it, which will then
6716                  invoke waitpid and reap_subprocess.  */
6717               if (cp->procinfo.hProcess == NULL)
6718                 delete_child (cp);
6719               else
6720                 cp->fd = -1;
6721             }
6722         }
6723     }
6724
6725   if (fd >= 0 && fd < MAXDESC)
6726     fd_info[fd].flags = 0;
6727
6728   /* Note that sockets do not need special treatment here (at least on
6729      NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6730      closesocket is equivalent to CloseHandle, which is to be expected
6731      because socket handles are fully fledged kernel handles. */
6732   rc = _close (fd);
6733
6734   return rc;
6735 }
6736
6737 int
6738 sys_dup (int fd)
6739 {
6740   int new_fd;
6741
6742   new_fd = _dup (fd);
6743   if (new_fd >= 0 && new_fd < MAXDESC)
6744     {
6745       /* duplicate our internal info as well */
6746       fd_info[new_fd] = fd_info[fd];
6747     }
6748   return new_fd;
6749 }
6750
6751 int
6752 sys_dup2 (int src, int dst)
6753 {
6754   int rc;
6755
6756   if (dst < 0 || dst >= MAXDESC)
6757     {
6758       errno = EBADF;
6759       return -1;
6760     }
6761
6762   /* make sure we close the destination first if it's a pipe or socket */
6763   if (src != dst && fd_info[dst].flags != 0)
6764     sys_close (dst);
6765
6766   rc = _dup2 (src, dst);
6767   if (rc == 0)
6768     {
6769       /* duplicate our internal info as well */
6770       fd_info[dst] = fd_info[src];
6771     }
6772   return rc;
6773 }
6774
6775 /* Unix pipe() has only one arg */
6776 int
6777 sys_pipe (int * phandles)
6778 {
6779   int rc;
6780   unsigned flags;
6781
6782   /* make pipe handles non-inheritable; when we spawn a child, we
6783      replace the relevant handle with an inheritable one.  Also put
6784      pipes into binary mode; we will do text mode translation ourselves
6785      if required.  */
6786   rc = _pipe (phandles, 0, _O_NOINHERIT | _O_BINARY);
6787
6788   if (rc == 0)
6789     {
6790       /* Protect against overflow, since Windows can open more handles than
6791          our fd_info array has room for.  */
6792       if (phandles[0] >= MAXDESC || phandles[1] >= MAXDESC)
6793         {
6794           _close (phandles[0]);
6795           _close (phandles[1]);
6796           rc = -1;
6797         }
6798       else
6799         {
6800           flags = FILE_PIPE | FILE_READ | FILE_BINARY;
6801           fd_info[phandles[0]].flags = flags;
6802
6803           flags = FILE_PIPE | FILE_WRITE | FILE_BINARY;
6804           fd_info[phandles[1]].flags = flags;
6805         }
6806     }
6807
6808   return rc;
6809 }
6810
6811 /* Function to do blocking read of one byte, needed to implement
6812    select.  It is only allowed on communication ports, sockets, or
6813    pipes. */
6814 int
6815 _sys_read_ahead (int fd)
6816 {
6817   child_process * cp;
6818   int rc;
6819
6820   if (fd < 0 || fd >= MAXDESC)
6821     return STATUS_READ_ERROR;
6822
6823   cp = fd_info[fd].cp;
6824
6825   if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
6826     return STATUS_READ_ERROR;
6827
6828   if ((fd_info[fd].flags & (FILE_PIPE | FILE_SERIAL | FILE_SOCKET)) == 0
6829       || (fd_info[fd].flags & FILE_READ) == 0)
6830     {
6831       DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd));
6832       emacs_abort ();
6833     }
6834
6835   cp->status = STATUS_READ_IN_PROGRESS;
6836
6837   if (fd_info[fd].flags & FILE_PIPE)
6838     {
6839       rc = _read (fd, &cp->chr, sizeof (char));
6840
6841       /* Give subprocess time to buffer some more output for us before
6842          reporting that input is available; we need this because Windows 95
6843          connects DOS programs to pipes by making the pipe appear to be
6844          the normal console stdout - as a result most DOS programs will
6845          write to stdout without buffering, ie. one character at a
6846          time.  Even some W32 programs do this - "dir" in a command
6847          shell on NT is very slow if we don't do this. */
6848       if (rc > 0)
6849         {
6850           int wait = w32_pipe_read_delay;
6851
6852           if (wait > 0)
6853             Sleep (wait);
6854           else if (wait < 0)
6855             while (++wait <= 0)
6856               /* Yield remainder of our time slice, effectively giving a
6857                  temporary priority boost to the child process. */
6858               Sleep (0);
6859         }
6860     }
6861   else if (fd_info[fd].flags & FILE_SERIAL)
6862     {
6863       HANDLE hnd = fd_info[fd].hnd;
6864       OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
6865       COMMTIMEOUTS ct;
6866
6867       /* Configure timeouts for blocking read.  */
6868       if (!GetCommTimeouts (hnd, &ct))
6869         return STATUS_READ_ERROR;
6870       ct.ReadIntervalTimeout            = 0;
6871       ct.ReadTotalTimeoutMultiplier     = 0;
6872       ct.ReadTotalTimeoutConstant       = 0;
6873       if (!SetCommTimeouts (hnd, &ct))
6874         return STATUS_READ_ERROR;
6875
6876       if (!ReadFile (hnd, &cp->chr, sizeof (char), (DWORD*) &rc, ovl))
6877         {
6878           if (GetLastError () != ERROR_IO_PENDING)
6879             return STATUS_READ_ERROR;
6880           if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
6881             return STATUS_READ_ERROR;
6882         }
6883     }
6884   else if (fd_info[fd].flags & FILE_SOCKET)
6885     {
6886       unsigned long nblock = 0;
6887       /* We always want this to block, so temporarily disable NDELAY.  */
6888       if (fd_info[fd].flags & FILE_NDELAY)
6889         pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
6890
6891       rc = pfn_recv (SOCK_HANDLE (fd), &cp->chr, sizeof (char), 0);
6892
6893       if (fd_info[fd].flags & FILE_NDELAY)
6894         {
6895           nblock = 1;
6896           pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
6897         }
6898     }
6899
6900   if (rc == sizeof (char))
6901     cp->status = STATUS_READ_SUCCEEDED;
6902   else
6903     cp->status = STATUS_READ_FAILED;
6904
6905   return cp->status;
6906 }
6907
6908 int
6909 _sys_wait_accept (int fd)
6910 {
6911   HANDLE hEv;
6912   child_process * cp;
6913   int rc;
6914
6915   if (fd < 0 || fd >= MAXDESC)
6916     return STATUS_READ_ERROR;
6917
6918   cp = fd_info[fd].cp;
6919
6920   if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
6921     return STATUS_READ_ERROR;
6922
6923   cp->status = STATUS_READ_FAILED;
6924
6925   hEv = pfn_WSACreateEvent ();
6926   rc = pfn_WSAEventSelect (SOCK_HANDLE (fd), hEv, FD_ACCEPT);
6927   if (rc != SOCKET_ERROR)
6928     {
6929       rc = WaitForSingleObject (hEv, INFINITE);
6930       pfn_WSAEventSelect (SOCK_HANDLE (fd), NULL, 0);
6931       if (rc == WAIT_OBJECT_0)
6932         cp->status = STATUS_READ_SUCCEEDED;
6933     }
6934   pfn_WSACloseEvent (hEv);
6935
6936   return cp->status;
6937 }
6938
6939 int
6940 sys_read (int fd, char * buffer, unsigned int count)
6941 {
6942   int nchars;
6943   int to_read;
6944   DWORD waiting;
6945   char * orig_buffer = buffer;
6946
6947   if (fd < 0)
6948     {
6949       errno = EBADF;
6950       return -1;
6951     }
6952
6953   if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
6954     {
6955       child_process *cp = fd_info[fd].cp;
6956
6957       if ((fd_info[fd].flags & FILE_READ) == 0)
6958         {
6959           errno = EBADF;
6960           return -1;
6961         }
6962
6963       nchars = 0;
6964
6965       /* re-read CR carried over from last read */
6966       if (fd_info[fd].flags & FILE_LAST_CR)
6967         {
6968           if (fd_info[fd].flags & FILE_BINARY) emacs_abort ();
6969           *buffer++ = 0x0d;
6970           count--;
6971           nchars++;
6972           fd_info[fd].flags &= ~FILE_LAST_CR;
6973         }
6974
6975       /* presence of a child_process structure means we are operating in
6976          non-blocking mode - otherwise we just call _read directly.
6977          Note that the child_process structure might be missing because
6978          reap_subprocess has been called; in this case the pipe is
6979          already broken, so calling _read on it is okay. */
6980       if (cp)
6981         {
6982           int current_status = cp->status;
6983
6984           switch (current_status)
6985             {
6986             case STATUS_READ_FAILED:
6987             case STATUS_READ_ERROR:
6988               /* report normal EOF if nothing in buffer */
6989               if (nchars <= 0)
6990                 fd_info[fd].flags |= FILE_AT_EOF;
6991               return nchars;
6992
6993             case STATUS_READ_READY:
6994             case STATUS_READ_IN_PROGRESS:
6995               DebPrint (("sys_read called when read is in progress\n"));
6996               errno = EWOULDBLOCK;
6997               return -1;
6998
6999             case STATUS_READ_SUCCEEDED:
7000               /* consume read-ahead char */
7001               *buffer++ = cp->chr;
7002               count--;
7003               nchars++;
7004               cp->status = STATUS_READ_ACKNOWLEDGED;
7005               ResetEvent (cp->char_avail);
7006
7007             case STATUS_READ_ACKNOWLEDGED:
7008               break;
7009
7010             default:
7011               DebPrint (("sys_read: bad status %d\n", current_status));
7012               errno = EBADF;
7013               return -1;
7014             }
7015
7016           if (fd_info[fd].flags & FILE_PIPE)
7017             {
7018               PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, &waiting, NULL);
7019               to_read = min (waiting, (DWORD) count);
7020
7021               if (to_read > 0)
7022                 nchars += _read (fd, buffer, to_read);
7023             }
7024           else if (fd_info[fd].flags & FILE_SERIAL)
7025             {
7026               HANDLE hnd = fd_info[fd].hnd;
7027               OVERLAPPED *ovl = &fd_info[fd].cp->ovl_read;
7028               int rc = 0;
7029               COMMTIMEOUTS ct;
7030
7031               if (count > 0)
7032                 {
7033                   /* Configure timeouts for non-blocking read.  */
7034                   if (!GetCommTimeouts (hnd, &ct))
7035                     {
7036                       errno = EIO;
7037                       return -1;
7038                     }
7039                   ct.ReadIntervalTimeout         = MAXDWORD;
7040                   ct.ReadTotalTimeoutMultiplier  = 0;
7041                   ct.ReadTotalTimeoutConstant    = 0;
7042                   if (!SetCommTimeouts (hnd, &ct))
7043                     {
7044                       errno = EIO;
7045                       return -1;
7046                     }
7047
7048                   if (!ResetEvent (ovl->hEvent))
7049                     {
7050                       errno = EIO;
7051                       return -1;
7052                     }
7053                   if (!ReadFile (hnd, buffer, count, (DWORD*) &rc, ovl))
7054                     {
7055                       if (GetLastError () != ERROR_IO_PENDING)
7056                         {
7057                           errno = EIO;
7058                           return -1;
7059                         }
7060                       if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
7061                         {
7062                           errno = EIO;
7063                           return -1;
7064                         }
7065                     }
7066                   nchars += rc;
7067                 }
7068             }
7069           else /* FILE_SOCKET */
7070             {
7071               if (winsock_lib == NULL) emacs_abort ();
7072
7073               /* do the equivalent of a non-blocking read */
7074               pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
7075               if (waiting == 0 && nchars == 0)
7076                 {
7077                   h_errno = errno = EWOULDBLOCK;
7078                   return -1;
7079                 }
7080
7081               if (waiting)
7082                 {
7083                   /* always use binary mode for sockets */
7084                   int res = pfn_recv (SOCK_HANDLE (fd), buffer, count, 0);
7085                   if (res == SOCKET_ERROR)
7086                     {
7087                       DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
7088                                  pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
7089                       set_errno ();
7090                       return -1;
7091                     }
7092                   nchars += res;
7093                 }
7094             }
7095         }
7096       else
7097         {
7098           int nread = _read (fd, buffer, count);
7099           if (nread >= 0)
7100             nchars += nread;
7101           else if (nchars == 0)
7102             nchars = nread;
7103         }
7104
7105       if (nchars <= 0)
7106         fd_info[fd].flags |= FILE_AT_EOF;
7107       /* Perform text mode translation if required.  */
7108       else if ((fd_info[fd].flags & FILE_BINARY) == 0)
7109         {
7110           nchars = crlf_to_lf (nchars, orig_buffer);
7111           /* If buffer contains only CR, return that.  To be absolutely
7112              sure we should attempt to read the next char, but in
7113              practice a CR to be followed by LF would not appear by
7114              itself in the buffer.  */
7115           if (nchars > 1 && orig_buffer[nchars - 1] == 0x0d)
7116             {
7117               fd_info[fd].flags |= FILE_LAST_CR;
7118               nchars--;
7119             }
7120         }
7121     }
7122   else
7123     nchars = _read (fd, buffer, count);
7124
7125   return nchars;
7126 }
7127
7128 /* From w32xfns.c */
7129 extern HANDLE interrupt_handle;
7130
7131 /* For now, don't bother with a non-blocking mode */
7132 int
7133 sys_write (int fd, const void * buffer, unsigned int count)
7134 {
7135   int nchars;
7136
7137   if (fd < 0)
7138     {
7139       errno = EBADF;
7140       return -1;
7141     }
7142
7143   if (fd < MAXDESC && fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET | FILE_SERIAL))
7144     {
7145       if ((fd_info[fd].flags & FILE_WRITE) == 0)
7146         {
7147           errno = EBADF;
7148           return -1;
7149         }
7150
7151       /* Perform text mode translation if required.  */
7152       if ((fd_info[fd].flags & FILE_BINARY) == 0)
7153         {
7154           char * tmpbuf = alloca (count * 2);
7155           unsigned char * src = (void *)buffer;
7156           unsigned char * dst = tmpbuf;
7157           int nbytes = count;
7158
7159           while (1)
7160             {
7161               unsigned char *next;
7162               /* copy next line or remaining bytes */
7163               next = _memccpy (dst, src, '\n', nbytes);
7164               if (next)
7165                 {
7166                   /* copied one line ending with '\n' */
7167                   int copied = next - dst;
7168                   nbytes -= copied;
7169                   src += copied;
7170                   /* insert '\r' before '\n' */
7171                   next[-1] = '\r';
7172                   next[0] = '\n';
7173                   dst = next + 1;
7174                   count++;
7175                 }
7176               else
7177                 /* copied remaining partial line -> now finished */
7178                 break;
7179             }
7180           buffer = tmpbuf;
7181         }
7182     }
7183
7184   if (fd < MAXDESC && fd_info[fd].flags & FILE_SERIAL)
7185     {
7186       HANDLE hnd = (HANDLE) _get_osfhandle (fd);
7187       OVERLAPPED *ovl = &fd_info[fd].cp->ovl_write;
7188       HANDLE wait_hnd[2] = { interrupt_handle, ovl->hEvent };
7189       DWORD active = 0;
7190
7191       if (!WriteFile (hnd, buffer, count, (DWORD*) &nchars, ovl))
7192         {
7193           if (GetLastError () != ERROR_IO_PENDING)
7194             {
7195               errno = EIO;
7196               return -1;
7197             }
7198           if (detect_input_pending ())
7199             active = MsgWaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE,
7200                                                 QS_ALLINPUT);
7201           else
7202             active = WaitForMultipleObjects (2, wait_hnd, FALSE, INFINITE);
7203           if (active == WAIT_OBJECT_0)
7204             { /* User pressed C-g, cancel write, then leave.  Don't bother
7205                  cleaning up as we may only get stuck in buggy drivers.  */
7206               PurgeComm (hnd, PURGE_TXABORT | PURGE_TXCLEAR);
7207               CancelIo (hnd);
7208               errno = EIO;
7209               return -1;
7210             }
7211           if (active == WAIT_OBJECT_0 + 1
7212               && !GetOverlappedResult (hnd, ovl, (DWORD*) &nchars, TRUE))
7213             {
7214               errno = EIO;
7215               return -1;
7216             }
7217         }
7218     }
7219   else if (fd < MAXDESC && fd_info[fd].flags & FILE_SOCKET)
7220     {
7221       unsigned long nblock = 0;
7222       if (winsock_lib == NULL) emacs_abort ();
7223
7224       /* TODO: implement select() properly so non-blocking I/O works. */
7225       /* For now, make sure the write blocks.  */
7226       if (fd_info[fd].flags & FILE_NDELAY)
7227         pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7228
7229       nchars =  pfn_send (SOCK_HANDLE (fd), buffer, count, 0);
7230
7231       /* Set the socket back to non-blocking if it was before,
7232          for other operations that support it.  */
7233       if (fd_info[fd].flags & FILE_NDELAY)
7234         {
7235           nblock = 1;
7236           pfn_ioctlsocket (SOCK_HANDLE (fd), FIONBIO, &nblock);
7237         }
7238
7239       if (nchars == SOCKET_ERROR)
7240         {
7241           DebPrint (("sys_write.send failed with error %d on socket %ld\n",
7242                      pfn_WSAGetLastError (), SOCK_HANDLE (fd)));
7243           set_errno ();
7244         }
7245     }
7246   else
7247     {
7248       /* Some networked filesystems don't like too large writes, so
7249          break them into smaller chunks.  See the Comments section of
7250          the MSDN documentation of WriteFile for details behind the
7251          choice of the value of CHUNK below.  See also the thread
7252          http://thread.gmane.org/gmane.comp.version-control.git/145294
7253          in the git mailing list.  */
7254       const unsigned char *p = buffer;
7255       const unsigned chunk = 30 * 1024 * 1024;
7256
7257       nchars = 0;
7258       while (count > 0)
7259         {
7260           unsigned this_chunk = count < chunk ? count : chunk;
7261           int n = _write (fd, p, this_chunk);
7262
7263           nchars += n;
7264           if (n < 0)
7265             {
7266               nchars = n;
7267               break;
7268             }
7269           else if (n < this_chunk)
7270             break;
7271           count -= n;
7272           p += n;
7273         }
7274     }
7275
7276   return nchars;
7277 }
7278
7279 /* The Windows CRT functions are "optimized for speed", so they don't
7280    check for timezone and DST changes if they were last called less
7281    than 1 minute ago (see http://support.microsoft.com/kb/821231).  So
7282    all Emacs features that repeatedly call time functions (e.g.,
7283    display-time) are in real danger of missing timezone and DST
7284    changes.  Calling tzset before each localtime call fixes that.  */
7285 struct tm *
7286 sys_localtime (const time_t *t)
7287 {
7288   tzset ();
7289   return localtime (t);
7290 }
7291
7292
7293 \f
7294 /* Try loading LIBRARY_ID from the file(s) specified in
7295    Vdynamic_library_alist.  If the library is loaded successfully,
7296    return the handle of the DLL, and record the filename in the
7297    property :loaded-from of LIBRARY_ID.  If the library could not be
7298    found, or when it was already loaded (because the handle is not
7299    recorded anywhere, and so is lost after use), return NULL.
7300
7301    We could also save the handle in :loaded-from, but currently
7302    there's no use case for it.  */
7303 HMODULE
7304 w32_delayed_load (Lisp_Object library_id)
7305 {
7306   HMODULE library_dll = NULL;
7307
7308   CHECK_SYMBOL (library_id);
7309
7310   if (CONSP (Vdynamic_library_alist)
7311       && NILP (Fassq (library_id, Vlibrary_cache)))
7312     {
7313       Lisp_Object found = Qnil;
7314       Lisp_Object dlls = Fassq (library_id, Vdynamic_library_alist);
7315
7316       if (CONSP (dlls))
7317         for (dlls = XCDR (dlls); CONSP (dlls); dlls = XCDR (dlls))
7318           {
7319             CHECK_STRING_CAR (dlls);
7320             if ((library_dll = LoadLibrary (SDATA (XCAR (dlls)))))
7321               {
7322                 char name[MAX_PATH];
7323                 DWORD len;
7324
7325                 len = GetModuleFileNameA (library_dll, name, sizeof (name));
7326                 found = Fcons (XCAR (dlls),
7327                                (len > 0)
7328                                /* Possibly truncated */
7329                                ? make_specified_string (name, -1, len, 1)
7330                                : Qnil);
7331                 break;
7332               }
7333           }
7334
7335       Fput (library_id, QCloaded_from, found);
7336     }
7337
7338   return library_dll;
7339 }
7340
7341 \f
7342 void
7343 check_windows_init_file (void)
7344 {
7345   /* A common indication that Emacs is not installed properly is when
7346      it cannot find the Windows installation file.  If this file does
7347      not exist in the expected place, tell the user.  */
7348
7349   if (!noninteractive && !inhibit_window_system
7350       /* Vload_path is not yet initialized when we are loading
7351          loadup.el.  */
7352       && NILP (Vpurify_flag))
7353     {
7354       Lisp_Object init_file;
7355       int fd;
7356
7357       init_file = build_string ("term/w32-win");
7358       fd = openp (Vload_path, init_file, Fget_load_suffixes (), NULL, Qnil);
7359       if (fd < 0)
7360         {
7361           Lisp_Object load_path_print = Fprin1_to_string (Vload_path, Qnil);
7362           char *init_file_name = SDATA (init_file);
7363           char *load_path = SDATA (load_path_print);
7364           char *buffer = alloca (1024
7365                                  + strlen (init_file_name)
7366                                  + strlen (load_path));
7367
7368           sprintf (buffer,
7369                    "The Emacs Windows initialization file \"%s.el\" "
7370                    "could not be found in your Emacs installation.  "
7371                    "Emacs checked the following directories for this file:\n"
7372                    "\n%s\n\n"
7373                    "When Emacs cannot find this file, it usually means that it "
7374                    "was not installed properly, or its distribution file was "
7375                    "not unpacked properly.\nSee the README.W32 file in the "
7376                    "top-level Emacs directory for more information.",
7377                    init_file_name, load_path);
7378           MessageBox (NULL,
7379                       buffer,
7380                       "Emacs Abort Dialog",
7381                       MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
7382           /* Use the low-level system abort. */
7383           abort ();
7384         }
7385       else
7386         {
7387           _close (fd);
7388         }
7389     }
7390 }
7391
7392 void
7393 term_ntproc (int ignored)
7394 {
7395   (void)ignored;
7396
7397   term_timers ();
7398
7399   /* shutdown the socket interface if necessary */
7400   term_winsock ();
7401
7402   term_w32select ();
7403 }
7404
7405 void
7406 init_ntproc (int dumping)
7407 {
7408   sigset_t initial_mask = 0;
7409
7410   /* Initialize the socket interface now if available and requested by
7411      the user by defining PRELOAD_WINSOCK; otherwise loading will be
7412      delayed until open-network-stream is called (w32-has-winsock can
7413      also be used to dynamically load or reload winsock).
7414
7415      Conveniently, init_environment is called before us, so
7416      PRELOAD_WINSOCK can be set in the registry. */
7417
7418   /* Always initialize this correctly. */
7419   winsock_lib = NULL;
7420
7421   if (getenv ("PRELOAD_WINSOCK") != NULL)
7422     init_winsock (TRUE);
7423
7424   /* Initial preparation for subprocess support: replace our standard
7425      handles with non-inheritable versions. */
7426   {
7427     HANDLE parent;
7428     HANDLE stdin_save =  INVALID_HANDLE_VALUE;
7429     HANDLE stdout_save = INVALID_HANDLE_VALUE;
7430     HANDLE stderr_save = INVALID_HANDLE_VALUE;
7431
7432     parent = GetCurrentProcess ();
7433
7434     /* ignore errors when duplicating and closing; typically the
7435        handles will be invalid when running as a gui program. */
7436     DuplicateHandle (parent,
7437                      GetStdHandle (STD_INPUT_HANDLE),
7438                      parent,
7439                      &stdin_save,
7440                      0,
7441                      FALSE,
7442                      DUPLICATE_SAME_ACCESS);
7443
7444     DuplicateHandle (parent,
7445                      GetStdHandle (STD_OUTPUT_HANDLE),
7446                      parent,
7447                      &stdout_save,
7448                      0,
7449                      FALSE,
7450                      DUPLICATE_SAME_ACCESS);
7451
7452     DuplicateHandle (parent,
7453                      GetStdHandle (STD_ERROR_HANDLE),
7454                      parent,
7455                      &stderr_save,
7456                      0,
7457                      FALSE,
7458                      DUPLICATE_SAME_ACCESS);
7459
7460     fclose (stdin);
7461     fclose (stdout);
7462     fclose (stderr);
7463
7464     if (stdin_save != INVALID_HANDLE_VALUE)
7465       _open_osfhandle ((intptr_t) stdin_save, O_TEXT);
7466     else
7467       _open ("nul", O_TEXT | O_NOINHERIT | O_RDONLY);
7468     _fdopen (0, "r");
7469
7470     if (stdout_save != INVALID_HANDLE_VALUE)
7471       _open_osfhandle ((intptr_t) stdout_save, O_TEXT);
7472     else
7473       _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
7474     _fdopen (1, "w");
7475
7476     if (stderr_save != INVALID_HANDLE_VALUE)
7477       _open_osfhandle ((intptr_t) stderr_save, O_TEXT);
7478     else
7479       _open ("nul", O_TEXT | O_NOINHERIT | O_WRONLY);
7480     _fdopen (2, "w");
7481   }
7482
7483   /* unfortunately, atexit depends on implementation of malloc */
7484   /* atexit (term_ntproc); */
7485   if (!dumping)
7486     {
7487       /* Make sure we start with all signals unblocked.  */
7488       sigprocmask (SIG_SETMASK, &initial_mask, NULL);
7489       signal (SIGABRT, term_ntproc);
7490     }
7491   init_timers ();
7492
7493   /* determine which drives are fixed, for GetCachedVolumeInformation */
7494   {
7495     /* GetDriveType must have trailing backslash. */
7496     char drive[] = "A:\\";
7497
7498     /* Loop over all possible drive letters */
7499     while (*drive <= 'Z')
7500     {
7501       /* Record if this drive letter refers to a fixed drive. */
7502       fixed_drives[DRIVE_INDEX (*drive)] =
7503         (GetDriveType (drive) == DRIVE_FIXED);
7504
7505       (*drive)++;
7506     }
7507
7508     /* Reset the volume info cache.  */
7509     volume_cache = NULL;
7510   }
7511 }
7512
7513 /*
7514         shutdown_handler ensures that buffers' autosave files are
7515         up to date when the user logs off, or the system shuts down.
7516 */
7517 static BOOL WINAPI
7518 shutdown_handler (DWORD type)
7519 {
7520   /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them.  */
7521   if (type == CTRL_CLOSE_EVENT        /* User closes console window.  */
7522       || type == CTRL_LOGOFF_EVENT    /* User logs off.  */
7523       || type == CTRL_SHUTDOWN_EVENT) /* User shutsdown.  */
7524     {
7525       /* Shut down cleanly, making sure autosave files are up to date.  */
7526       shut_down_emacs (0, Qnil);
7527     }
7528
7529   /* Allow other handlers to handle this signal.  */
7530   return FALSE;
7531 }
7532
7533 /*
7534         globals_of_w32 is used to initialize those global variables that
7535         must always be initialized on startup even when the global variable
7536         initialized is non zero (see the function main in emacs.c).
7537 */
7538 void
7539 globals_of_w32 (void)
7540 {
7541   HMODULE kernel32 = GetModuleHandle ("kernel32.dll");
7542
7543   get_process_times_fn = (GetProcessTimes_Proc)
7544     GetProcAddress (kernel32, "GetProcessTimes");
7545
7546   DEFSYM (QCloaded_from, ":loaded-from");
7547
7548   g_b_init_is_windows_9x = 0;
7549   g_b_init_open_process_token = 0;
7550   g_b_init_get_token_information = 0;
7551   g_b_init_lookup_account_sid = 0;
7552   g_b_init_get_sid_sub_authority = 0;
7553   g_b_init_get_sid_sub_authority_count = 0;
7554   g_b_init_get_security_info = 0;
7555   g_b_init_get_file_security = 0;
7556   g_b_init_get_security_descriptor_owner = 0;
7557   g_b_init_get_security_descriptor_group = 0;
7558   g_b_init_is_valid_sid = 0;
7559   g_b_init_create_toolhelp32_snapshot = 0;
7560   g_b_init_process32_first = 0;
7561   g_b_init_process32_next = 0;
7562   g_b_init_open_thread_token = 0;
7563   g_b_init_impersonate_self = 0;
7564   g_b_init_revert_to_self = 0;
7565   g_b_init_get_process_memory_info = 0;
7566   g_b_init_get_process_working_set_size = 0;
7567   g_b_init_global_memory_status = 0;
7568   g_b_init_global_memory_status_ex = 0;
7569   g_b_init_equal_sid = 0;
7570   g_b_init_copy_sid = 0;
7571   g_b_init_get_length_sid = 0;
7572   g_b_init_get_native_system_info = 0;
7573   g_b_init_get_system_times = 0;
7574   g_b_init_create_symbolic_link = 0;
7575   g_b_init_get_security_descriptor_dacl = 0;
7576   g_b_init_convert_sd_to_sddl = 0;
7577   g_b_init_convert_sddl_to_sd = 0;
7578   g_b_init_is_valid_security_descriptor = 0;
7579   g_b_init_set_file_security = 0;
7580   num_of_processors = 0;
7581   /* The following sets a handler for shutdown notifications for
7582      console apps. This actually applies to Emacs in both console and
7583      GUI modes, since we had to fool windows into thinking emacs is a
7584      console application to get console mode to work.  */
7585   SetConsoleCtrlHandler (shutdown_handler, TRUE);
7586
7587   /* "None" is the default group name on standalone workstations.  */
7588   strcpy (dflt_group_name, "None");
7589
7590   /* Reset, in case it has some value inherited from dump time.  */
7591   w32_stat_get_owner_group = 0;
7592 }
7593
7594 /* For make-serial-process  */
7595 int
7596 serial_open (char *port)
7597 {
7598   HANDLE hnd;
7599   child_process *cp;
7600   int fd = -1;
7601
7602   hnd = CreateFile (port, GENERIC_READ | GENERIC_WRITE, 0, 0,
7603                     OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
7604   if (hnd == INVALID_HANDLE_VALUE)
7605     error ("Could not open %s", port);
7606   fd = (int) _open_osfhandle ((intptr_t) hnd, 0);
7607   if (fd == -1)
7608     error ("Could not open %s", port);
7609
7610   cp = new_child ();
7611   if (!cp)
7612     error ("Could not create child process");
7613   cp->fd = fd;
7614   cp->status = STATUS_READ_ACKNOWLEDGED;
7615   fd_info[ fd ].hnd = hnd;
7616   fd_info[ fd ].flags |=
7617     FILE_READ | FILE_WRITE | FILE_BINARY | FILE_SERIAL;
7618   if (fd_info[ fd ].cp != NULL)
7619     {
7620       error ("fd_info[fd = %d] is already in use", fd);
7621     }
7622   fd_info[ fd ].cp = cp;
7623   cp->ovl_read.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
7624   if (cp->ovl_read.hEvent == NULL)
7625       error ("Could not create read event");
7626   cp->ovl_write.hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
7627   if (cp->ovl_write.hEvent == NULL)
7628       error ("Could not create write event");
7629
7630   return fd;
7631 }
7632
7633 /* For serial-process-configure  */
7634 void
7635 serial_configure (struct Lisp_Process *p, Lisp_Object contact)
7636 {
7637   Lisp_Object childp2 = Qnil;
7638   Lisp_Object tem = Qnil;
7639   HANDLE hnd;
7640   DCB dcb;
7641   COMMTIMEOUTS ct;
7642   char summary[4] = "???"; /* This usually becomes "8N1".  */
7643
7644   if ((fd_info[ p->outfd ].flags & FILE_SERIAL) == 0)
7645     error ("Not a serial process");
7646   hnd = fd_info[ p->outfd ].hnd;
7647
7648   childp2 = Fcopy_sequence (p->childp);
7649
7650   /* Initialize timeouts for blocking read and blocking write.  */
7651   if (!GetCommTimeouts (hnd, &ct))
7652     error ("GetCommTimeouts() failed");
7653   ct.ReadIntervalTimeout         = 0;
7654   ct.ReadTotalTimeoutMultiplier  = 0;
7655   ct.ReadTotalTimeoutConstant    = 0;
7656   ct.WriteTotalTimeoutMultiplier = 0;
7657   ct.WriteTotalTimeoutConstant   = 0;
7658   if (!SetCommTimeouts (hnd, &ct))
7659     error ("SetCommTimeouts() failed");
7660   /* Read port attributes and prepare default configuration.  */
7661   memset (&dcb, 0, sizeof (dcb));
7662   dcb.DCBlength = sizeof (DCB);
7663   if (!GetCommState (hnd, &dcb))
7664     error ("GetCommState() failed");
7665   dcb.fBinary       = TRUE;
7666   dcb.fNull         = FALSE;
7667   dcb.fAbortOnError = FALSE;
7668   /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7669   dcb.ErrorChar     = 0;
7670   dcb.EofChar       = 0;
7671   dcb.EvtChar       = 0;
7672
7673   /* Configure speed.  */
7674   if (!NILP (Fplist_member (contact, QCspeed)))
7675     tem = Fplist_get (contact, QCspeed);
7676   else
7677     tem = Fplist_get (p->childp, QCspeed);
7678   CHECK_NUMBER (tem);
7679   dcb.BaudRate = XINT (tem);
7680   childp2 = Fplist_put (childp2, QCspeed, tem);
7681
7682   /* Configure bytesize.  */
7683   if (!NILP (Fplist_member (contact, QCbytesize)))
7684     tem = Fplist_get (contact, QCbytesize);
7685   else
7686     tem = Fplist_get (p->childp, QCbytesize);
7687   if (NILP (tem))
7688     tem = make_number (8);
7689   CHECK_NUMBER (tem);
7690   if (XINT (tem) != 7 && XINT (tem) != 8)
7691     error (":bytesize must be nil (8), 7, or 8");
7692   dcb.ByteSize = XINT (tem);
7693   summary[0] = XINT (tem) + '0';
7694   childp2 = Fplist_put (childp2, QCbytesize, tem);
7695
7696   /* Configure parity.  */
7697   if (!NILP (Fplist_member (contact, QCparity)))
7698     tem = Fplist_get (contact, QCparity);
7699   else
7700     tem = Fplist_get (p->childp, QCparity);
7701   if (!NILP (tem) && !EQ (tem, Qeven) && !EQ (tem, Qodd))
7702     error (":parity must be nil (no parity), `even', or `odd'");
7703   dcb.fParity = FALSE;
7704   dcb.Parity = NOPARITY;
7705   dcb.fErrorChar = FALSE;
7706   if (NILP (tem))
7707     {
7708       summary[1] = 'N';
7709     }
7710   else if (EQ (tem, Qeven))
7711     {
7712       summary[1] = 'E';
7713       dcb.fParity = TRUE;
7714       dcb.Parity = EVENPARITY;
7715       dcb.fErrorChar = TRUE;
7716     }
7717   else if (EQ (tem, Qodd))
7718     {
7719       summary[1] = 'O';
7720       dcb.fParity = TRUE;
7721       dcb.Parity = ODDPARITY;
7722       dcb.fErrorChar = TRUE;
7723     }
7724   childp2 = Fplist_put (childp2, QCparity, tem);
7725
7726   /* Configure stopbits.  */
7727   if (!NILP (Fplist_member (contact, QCstopbits)))
7728     tem = Fplist_get (contact, QCstopbits);
7729   else
7730     tem = Fplist_get (p->childp, QCstopbits);
7731   if (NILP (tem))
7732     tem = make_number (1);
7733   CHECK_NUMBER (tem);
7734   if (XINT (tem) != 1 && XINT (tem) != 2)
7735     error (":stopbits must be nil (1 stopbit), 1, or 2");
7736   summary[2] = XINT (tem) + '0';
7737   if (XINT (tem) == 1)
7738     dcb.StopBits = ONESTOPBIT;
7739   else if (XINT (tem) == 2)
7740     dcb.StopBits = TWOSTOPBITS;
7741   childp2 = Fplist_put (childp2, QCstopbits, tem);
7742
7743   /* Configure flowcontrol.  */
7744   if (!NILP (Fplist_member (contact, QCflowcontrol)))
7745     tem = Fplist_get (contact, QCflowcontrol);
7746   else
7747     tem = Fplist_get (p->childp, QCflowcontrol);
7748   if (!NILP (tem) && !EQ (tem, Qhw) && !EQ (tem, Qsw))
7749     error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7750   dcb.fOutxCtsFlow      = FALSE;
7751   dcb.fOutxDsrFlow      = FALSE;
7752   dcb.fDtrControl       = DTR_CONTROL_DISABLE;
7753   dcb.fDsrSensitivity   = FALSE;
7754   dcb.fTXContinueOnXoff = FALSE;
7755   dcb.fOutX             = FALSE;
7756   dcb.fInX              = FALSE;
7757   dcb.fRtsControl       = RTS_CONTROL_DISABLE;
7758   dcb.XonChar           = 17; /* Control-Q  */
7759   dcb.XoffChar          = 19; /* Control-S  */
7760   if (NILP (tem))
7761     {
7762       /* Already configured.  */
7763     }
7764   else if (EQ (tem, Qhw))
7765     {
7766       dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
7767       dcb.fOutxCtsFlow = TRUE;
7768     }
7769   else if (EQ (tem, Qsw))
7770     {
7771       dcb.fOutX = TRUE;
7772       dcb.fInX = TRUE;
7773     }
7774   childp2 = Fplist_put (childp2, QCflowcontrol, tem);
7775
7776   /* Activate configuration.  */
7777   if (!SetCommState (hnd, &dcb))
7778     error ("SetCommState() failed");
7779
7780   childp2 = Fplist_put (childp2, QCsummary, build_string (summary));
7781   pset_childp (p, childp2);
7782 }
7783
7784 #ifdef HAVE_GNUTLS
7785
7786 ssize_t
7787 emacs_gnutls_pull (gnutls_transport_ptr_t p, void* buf, size_t sz)
7788 {
7789   int n, sc, err;
7790   SELECT_TYPE fdset;
7791   EMACS_TIME timeout;
7792   struct Lisp_Process *process = (struct Lisp_Process *)p;
7793   int fd = process->infd;
7794
7795   for (;;)
7796     {
7797       n = sys_read (fd, (char*)buf, sz);
7798
7799       if (n >= 0)
7800         return n;
7801
7802       err = errno;
7803
7804       if (err == EWOULDBLOCK)
7805         {
7806           /* Set a small timeout.  */
7807           timeout = make_emacs_time (1, 0);
7808           FD_ZERO (&fdset);
7809           FD_SET ((int)fd, &fdset);
7810
7811           /* Use select with the timeout to poll the selector.  */
7812           sc = select (fd + 1, &fdset, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
7813                        &timeout, NULL);
7814
7815           if (sc > 0)
7816             continue;  /* Try again.  */
7817
7818           /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7819              Also accept select return 0 as an indicator to EAGAIN.  */
7820           if (sc == 0 || errno == EWOULDBLOCK)
7821             err = EAGAIN;
7822           else
7823             err = errno; /* Other errors are just passed on.  */
7824         }
7825
7826       emacs_gnutls_transport_set_errno (process->gnutls_state, err);
7827
7828       return -1;
7829     }
7830 }
7831
7832 ssize_t
7833 emacs_gnutls_push (gnutls_transport_ptr_t p, const void* buf, size_t sz)
7834 {
7835   struct Lisp_Process *process = (struct Lisp_Process *)p;
7836   int fd = process->outfd;
7837   ssize_t n = sys_write (fd, buf, sz);
7838
7839   /* 0 or more bytes written means everything went fine.  */
7840   if (n >= 0)
7841     return n;
7842
7843   /* Negative bytes written means we got an error in errno.
7844      Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.  */
7845   emacs_gnutls_transport_set_errno (process->gnutls_state,
7846                                     errno == EWOULDBLOCK ? EAGAIN : errno);
7847
7848   return -1;
7849 }
7850 #endif /* HAVE_GNUTLS */
7851
7852 /* end of w32.c */