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