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