1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
3 Copyright (C) 1994-1995, 2000-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
24 #include <mingw_time.h>
25 #include <stddef.h> /* for offsetof */
28 #include <float.h> /* for DBL_EPSILON */
35 #include <time.h> /* must be before nt/inc/sys/time.h, for MinGW64 */
37 #include <sys/utime.h>
40 /* must include CRT headers *before* config.h */
43 #include <mbstring.h> /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
70 #include "epaths.h" /* for SHELL */
75 /* MinGW64 defines these in its _mingw.h. */
76 #ifndef _ANONYMOUS_UNION
77 # define _ANONYMOUS_UNION
79 #ifndef _ANONYMOUS_STRUCT
80 # define _ANONYMOUS_STRUCT
83 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
84 use a different name to avoid compilation problems. */
85 typedef struct _MEMORY_STATUS_EX
{
88 DWORDLONG ullTotalPhys
;
89 DWORDLONG ullAvailPhys
;
90 DWORDLONG ullTotalPageFile
;
91 DWORDLONG ullAvailPageFile
;
92 DWORDLONG ullTotalVirtual
;
93 DWORDLONG ullAvailVirtual
;
94 DWORDLONG ullAvailExtendedVirtual
;
95 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
97 /* These are here so that GDB would know about these data types. This
98 allows to attach GDB to Emacs when a fatal exception is triggered
99 and Windows pops up the "application needs to be closed" dialog.
100 At that point, _gnu_exception_handler, the top-level exception
101 handler installed by the MinGW startup code, is somewhere on the
102 call-stack of the main thread, so going to that call frame and
103 looking at the argument to _gnu_exception_handler, which is a
104 PEXCEPTION_POINTERS pointer, can reveal the exception code
105 (excptr->ExceptionRecord->ExceptionCode) and the address where the
106 exception happened (excptr->ExceptionRecord->ExceptionAddress), as
107 well as some additional information specific to the exception. */
108 PEXCEPTION_POINTERS excptr
;
109 PEXCEPTION_RECORD excprec
;
115 #include <tlhelp32.h>
120 #if _WIN32_WINNT < 0x0500
121 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
122 /* This either is not in psapi.h or guarded by higher value of
123 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
124 defines it in psapi.h */
125 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
127 DWORD PageFaultCount
;
128 SIZE_T PeakWorkingSetSize
;
129 SIZE_T WorkingSetSize
;
130 SIZE_T QuotaPeakPagedPoolUsage
;
131 SIZE_T QuotaPagedPoolUsage
;
132 SIZE_T QuotaPeakNonPagedPoolUsage
;
133 SIZE_T QuotaNonPagedPoolUsage
;
134 SIZE_T PagefileUsage
;
135 SIZE_T PeakPagefileUsage
;
137 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
141 #include <winioctl.h>
148 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
149 define them by hand if not already defined. */
150 #ifndef SDDL_REVISION_1
151 #define SDDL_REVISION_1 1
152 #endif /* SDDL_REVISION_1 */
154 #if defined(_MSC_VER) || defined(MINGW_W64)
155 /* MSVC and MinGW64 don't provide the definition of
156 REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
157 which cannot be included because it triggers conflicts with other
158 Windows API headers. So we define it here by hand. */
160 typedef struct _REPARSE_DATA_BUFFER
{
162 USHORT ReparseDataLength
;
166 USHORT SubstituteNameOffset
;
167 USHORT SubstituteNameLength
;
168 USHORT PrintNameOffset
;
169 USHORT PrintNameLength
;
172 } SymbolicLinkReparseBuffer
;
174 USHORT SubstituteNameOffset
;
175 USHORT SubstituteNameLength
;
176 USHORT PrintNameOffset
;
177 USHORT PrintNameLength
;
179 } MountPointReparseBuffer
;
182 } GenericReparseBuffer
;
184 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
186 #ifndef FILE_DEVICE_FILE_SYSTEM
187 #define FILE_DEVICE_FILE_SYSTEM 9
189 #ifndef METHOD_BUFFERED
190 #define METHOD_BUFFERED 0
192 #ifndef FILE_ANY_ACCESS
193 #define FILE_ANY_ACCESS 0x00000000
196 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
198 /* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h. */
199 #ifndef FSCTL_GET_REPARSE_POINT
200 #define FSCTL_GET_REPARSE_POINT \
201 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
205 /* TCP connection support. */
206 #include <sys/socket.h>
225 #include <iphlpapi.h> /* should be after winsock2.h */
229 #include "w32common.h"
231 #include "w32select.h"
233 #include "dispextern.h" /* for xstrcasecmp */
234 #include "coding.h" /* for Vlocale_coding_system */
236 #include "careadlinkat.h"
237 #include "allocator.h"
239 /* For serial_configure and serial_open. */
242 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
243 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
245 void globals_of_w32 (void);
246 static DWORD
get_rid (PSID
);
247 static int is_symlink (const char *);
248 static char * chase_symlinks (const char *);
249 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
250 static int restore_privilege (TOKEN_PRIVILEGES
*);
251 static BOOL WINAPI
revert_to_self (void);
253 static int sys_access (const char *, int);
254 extern void *e_malloc (size_t);
255 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
256 struct timespec
*, void *);
257 extern int sys_dup (int);
262 /* Initialization states.
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
271 static BOOL g_b_init_is_windows_9x
;
272 static BOOL g_b_init_open_process_token
;
273 static BOOL g_b_init_get_token_information
;
274 static BOOL g_b_init_lookup_account_sid
;
275 static BOOL g_b_init_get_sid_sub_authority
;
276 static BOOL g_b_init_get_sid_sub_authority_count
;
277 static BOOL g_b_init_get_security_info
;
278 static BOOL g_b_init_get_file_security_w
;
279 static BOOL g_b_init_get_file_security_a
;
280 static BOOL g_b_init_get_security_descriptor_owner
;
281 static BOOL g_b_init_get_security_descriptor_group
;
282 static BOOL g_b_init_is_valid_sid
;
283 static BOOL g_b_init_create_toolhelp32_snapshot
;
284 static BOOL g_b_init_process32_first
;
285 static BOOL g_b_init_process32_next
;
286 static BOOL g_b_init_open_thread_token
;
287 static BOOL g_b_init_impersonate_self
;
288 static BOOL g_b_init_revert_to_self
;
289 static BOOL g_b_init_get_process_memory_info
;
290 static BOOL g_b_init_get_process_working_set_size
;
291 static BOOL g_b_init_global_memory_status
;
292 static BOOL g_b_init_global_memory_status_ex
;
293 static BOOL g_b_init_get_length_sid
;
294 static BOOL g_b_init_equal_sid
;
295 static BOOL g_b_init_copy_sid
;
296 static BOOL g_b_init_get_native_system_info
;
297 static BOOL g_b_init_get_system_times
;
298 static BOOL g_b_init_create_symbolic_link_w
;
299 static BOOL g_b_init_create_symbolic_link_a
;
300 static BOOL g_b_init_get_security_descriptor_dacl
;
301 static BOOL g_b_init_convert_sd_to_sddl
;
302 static BOOL g_b_init_convert_sddl_to_sd
;
303 static BOOL g_b_init_is_valid_security_descriptor
;
304 static BOOL g_b_init_set_file_security_w
;
305 static BOOL g_b_init_set_file_security_a
;
306 static BOOL g_b_init_set_named_security_info_w
;
307 static BOOL g_b_init_set_named_security_info_a
;
308 static BOOL g_b_init_get_adapters_info
;
310 BOOL g_b_init_compare_string_w
;
313 BEGIN: Wrapper functions around OpenProcessToken
314 and other functions in advapi32.dll that are only
315 supported in Windows NT / 2k / XP
317 /* ** Function pointer typedefs ** */
318 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
319 HANDLE ProcessHandle
,
321 PHANDLE TokenHandle
);
322 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
324 TOKEN_INFORMATION_CLASS TokenInformationClass
,
325 LPVOID TokenInformation
,
326 DWORD TokenInformationLength
,
327 PDWORD ReturnLength
);
328 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
329 HANDLE process_handle
,
330 LPFILETIME creation_time
,
331 LPFILETIME exit_time
,
332 LPFILETIME kernel_time
,
333 LPFILETIME user_time
);
335 GetProcessTimes_Proc get_process_times_fn
= NULL
;
338 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
340 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
342 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
343 LPCTSTR lpSystemName
,
348 LPDWORD cbDomainName
,
349 PSID_NAME_USE peUse
);
350 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
353 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
355 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
357 SE_OBJECT_TYPE ObjectType
,
358 SECURITY_INFORMATION SecurityInfo
,
363 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
364 typedef BOOL (WINAPI
* GetFileSecurityW_Proc
) (
366 SECURITY_INFORMATION RequestedInformation
,
367 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
369 LPDWORD lpnLengthNeeded
);
370 typedef BOOL (WINAPI
* GetFileSecurityA_Proc
) (
372 SECURITY_INFORMATION RequestedInformation
,
373 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
375 LPDWORD lpnLengthNeeded
);
376 typedef BOOL (WINAPI
*SetFileSecurityW_Proc
) (
378 SECURITY_INFORMATION SecurityInformation
,
379 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
380 typedef BOOL (WINAPI
*SetFileSecurityA_Proc
) (
382 SECURITY_INFORMATION SecurityInformation
,
383 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
384 typedef DWORD (WINAPI
*SetNamedSecurityInfoW_Proc
) (
385 LPCWSTR lpObjectName
,
386 SE_OBJECT_TYPE ObjectType
,
387 SECURITY_INFORMATION SecurityInformation
,
392 typedef DWORD (WINAPI
*SetNamedSecurityInfoA_Proc
) (
394 SE_OBJECT_TYPE ObjectType
,
395 SECURITY_INFORMATION SecurityInformation
,
400 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
401 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
403 LPBOOL lpbOwnerDefaulted
);
404 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
405 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
407 LPBOOL lpbGroupDefaulted
);
408 typedef BOOL (WINAPI
*GetSecurityDescriptorDacl_Proc
) (
409 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
410 LPBOOL lpbDaclPresent
,
412 LPBOOL lpbDaclDefaulted
);
413 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
415 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
417 DWORD th32ProcessID
);
418 typedef BOOL (WINAPI
* Process32First_Proc
) (
420 LPPROCESSENTRY32 lppe
);
421 typedef BOOL (WINAPI
* Process32Next_Proc
) (
423 LPPROCESSENTRY32 lppe
);
424 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
428 PHANDLE TokenHandle
);
429 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
430 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
431 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
432 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
434 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
436 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
438 PSIZE_T lpMinimumWorkingSetSize
,
439 PSIZE_T lpMaximumWorkingSetSize
);
440 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
441 LPMEMORYSTATUS lpBuffer
);
442 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
443 LPMEMORY_STATUS_EX lpBuffer
);
444 typedef BOOL (WINAPI
* CopySid_Proc
) (
445 DWORD nDestinationSidLength
,
446 PSID pDestinationSid
,
448 typedef BOOL (WINAPI
* EqualSid_Proc
) (
451 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
453 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
454 LPSYSTEM_INFO lpSystemInfo
);
455 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
456 LPFILETIME lpIdleTime
,
457 LPFILETIME lpKernelTime
,
458 LPFILETIME lpUserTime
);
459 typedef BOOLEAN (WINAPI
*CreateSymbolicLinkW_Proc
) (
460 LPCWSTR lpSymlinkFileName
,
461 LPCWSTR lpTargetFileName
,
463 typedef BOOLEAN (WINAPI
*CreateSymbolicLinkA_Proc
) (
464 LPCSTR lpSymlinkFileName
,
465 LPCSTR lpTargetFileName
,
467 typedef BOOL (WINAPI
*ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
) (
468 LPCTSTR StringSecurityDescriptor
,
469 DWORD StringSDRevision
,
470 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
471 PULONG SecurityDescriptorSize
);
472 typedef BOOL (WINAPI
*ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
) (
473 PSECURITY_DESCRIPTOR SecurityDescriptor
,
474 DWORD RequestedStringSDRevision
,
475 SECURITY_INFORMATION SecurityInformation
,
476 LPTSTR
*StringSecurityDescriptor
,
477 PULONG StringSecurityDescriptorLen
);
478 typedef BOOL (WINAPI
*IsValidSecurityDescriptor_Proc
) (PSECURITY_DESCRIPTOR
);
479 typedef DWORD (WINAPI
*GetAdaptersInfo_Proc
) (
480 PIP_ADAPTER_INFO pAdapterInfo
,
483 int (WINAPI
*pMultiByteToWideChar
)(UINT
,DWORD
,LPCSTR
,int,LPWSTR
,int);
484 int (WINAPI
*pWideCharToMultiByte
)(UINT
,DWORD
,LPCWSTR
,int,LPSTR
,int,LPCSTR
,LPBOOL
);
486 /* ** A utility function ** */
490 static BOOL s_b_ret
= 0;
491 OSVERSIONINFO os_ver
;
492 if (g_b_init_is_windows_9x
== 0)
494 g_b_init_is_windows_9x
= 1;
495 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
496 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
497 if (GetVersionEx (&os_ver
))
499 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
505 static Lisp_Object
ltime (ULONGLONG
);
507 /* Get total user and system times for get-internal-run-time.
508 Returns a list of integers if the times are provided by the OS
509 (NT derivatives), otherwise it returns the result of current-time. */
511 w32_get_internal_run_time (void)
513 if (get_process_times_fn
)
515 FILETIME create
, exit
, kernel
, user
;
516 HANDLE proc
= GetCurrentProcess ();
517 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
519 LARGE_INTEGER user_int
, kernel_int
, total
;
520 user_int
.LowPart
= user
.dwLowDateTime
;
521 user_int
.HighPart
= user
.dwHighDateTime
;
522 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
523 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
524 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
525 return ltime (total
.QuadPart
);
529 return Fcurrent_time ();
532 /* ** The wrapper functions ** */
535 open_process_token (HANDLE ProcessHandle
,
539 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
540 HMODULE hm_advapi32
= NULL
;
541 if (is_windows_9x () == TRUE
)
545 if (g_b_init_open_process_token
== 0)
547 g_b_init_open_process_token
= 1;
548 hm_advapi32
= LoadLibrary ("Advapi32.dll");
549 s_pfn_Open_Process_Token
=
550 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
552 if (s_pfn_Open_Process_Token
== NULL
)
557 s_pfn_Open_Process_Token (
565 get_token_information (HANDLE TokenHandle
,
566 TOKEN_INFORMATION_CLASS TokenInformationClass
,
567 LPVOID TokenInformation
,
568 DWORD TokenInformationLength
,
571 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
572 HMODULE hm_advapi32
= NULL
;
573 if (is_windows_9x () == TRUE
)
577 if (g_b_init_get_token_information
== 0)
579 g_b_init_get_token_information
= 1;
580 hm_advapi32
= LoadLibrary ("Advapi32.dll");
581 s_pfn_Get_Token_Information
=
582 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
584 if (s_pfn_Get_Token_Information
== NULL
)
589 s_pfn_Get_Token_Information (
591 TokenInformationClass
,
593 TokenInformationLength
,
599 lookup_account_sid (LPCTSTR lpSystemName
,
604 LPDWORD cbDomainName
,
607 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
608 HMODULE hm_advapi32
= NULL
;
609 if (is_windows_9x () == TRUE
)
613 if (g_b_init_lookup_account_sid
== 0)
615 g_b_init_lookup_account_sid
= 1;
616 hm_advapi32
= LoadLibrary ("Advapi32.dll");
617 s_pfn_Lookup_Account_Sid
=
618 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
620 if (s_pfn_Lookup_Account_Sid
== NULL
)
625 s_pfn_Lookup_Account_Sid (
637 get_sid_sub_authority (PSID pSid
, DWORD n
)
639 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
640 static DWORD zero
= 0U;
641 HMODULE hm_advapi32
= NULL
;
642 if (is_windows_9x () == TRUE
)
646 if (g_b_init_get_sid_sub_authority
== 0)
648 g_b_init_get_sid_sub_authority
= 1;
649 hm_advapi32
= LoadLibrary ("Advapi32.dll");
650 s_pfn_Get_Sid_Sub_Authority
=
651 (GetSidSubAuthority_Proc
) GetProcAddress (
652 hm_advapi32
, "GetSidSubAuthority");
654 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
658 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
662 get_sid_sub_authority_count (PSID pSid
)
664 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
665 static UCHAR zero
= 0U;
666 HMODULE hm_advapi32
= NULL
;
667 if (is_windows_9x () == TRUE
)
671 if (g_b_init_get_sid_sub_authority_count
== 0)
673 g_b_init_get_sid_sub_authority_count
= 1;
674 hm_advapi32
= LoadLibrary ("Advapi32.dll");
675 s_pfn_Get_Sid_Sub_Authority_Count
=
676 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
677 hm_advapi32
, "GetSidSubAuthorityCount");
679 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
683 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
687 get_security_info (HANDLE handle
,
688 SE_OBJECT_TYPE ObjectType
,
689 SECURITY_INFORMATION SecurityInfo
,
694 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
696 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
697 HMODULE hm_advapi32
= NULL
;
698 if (is_windows_9x () == TRUE
)
702 if (g_b_init_get_security_info
== 0)
704 g_b_init_get_security_info
= 1;
705 hm_advapi32
= LoadLibrary ("Advapi32.dll");
706 s_pfn_Get_Security_Info
=
707 (GetSecurityInfo_Proc
) GetProcAddress (
708 hm_advapi32
, "GetSecurityInfo");
710 if (s_pfn_Get_Security_Info
== NULL
)
714 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
715 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
716 ppSecurityDescriptor
));
720 get_file_security (const char *lpFileName
,
721 SECURITY_INFORMATION RequestedInformation
,
722 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
724 LPDWORD lpnLengthNeeded
)
726 static GetFileSecurityA_Proc s_pfn_Get_File_SecurityA
= NULL
;
727 static GetFileSecurityW_Proc s_pfn_Get_File_SecurityW
= NULL
;
728 HMODULE hm_advapi32
= NULL
;
729 if (is_windows_9x () == TRUE
)
734 if (w32_unicode_filenames
)
736 wchar_t filename_w
[MAX_PATH
];
738 if (g_b_init_get_file_security_w
== 0)
740 g_b_init_get_file_security_w
= 1;
741 hm_advapi32
= LoadLibrary ("Advapi32.dll");
742 s_pfn_Get_File_SecurityW
=
743 (GetFileSecurityW_Proc
) GetProcAddress (hm_advapi32
,
746 if (s_pfn_Get_File_SecurityW
== NULL
)
751 filename_to_utf16 (lpFileName
, filename_w
);
752 return (s_pfn_Get_File_SecurityW (filename_w
, RequestedInformation
,
753 pSecurityDescriptor
, nLength
,
758 char filename_a
[MAX_PATH
];
760 if (g_b_init_get_file_security_a
== 0)
762 g_b_init_get_file_security_a
= 1;
763 hm_advapi32
= LoadLibrary ("Advapi32.dll");
764 s_pfn_Get_File_SecurityA
=
765 (GetFileSecurityA_Proc
) GetProcAddress (hm_advapi32
,
768 if (s_pfn_Get_File_SecurityA
== NULL
)
773 filename_to_ansi (lpFileName
, filename_a
);
774 return (s_pfn_Get_File_SecurityA (filename_a
, RequestedInformation
,
775 pSecurityDescriptor
, nLength
,
781 set_file_security (const char *lpFileName
,
782 SECURITY_INFORMATION SecurityInformation
,
783 PSECURITY_DESCRIPTOR pSecurityDescriptor
)
785 static SetFileSecurityW_Proc s_pfn_Set_File_SecurityW
= NULL
;
786 static SetFileSecurityA_Proc s_pfn_Set_File_SecurityA
= NULL
;
787 HMODULE hm_advapi32
= NULL
;
788 if (is_windows_9x () == TRUE
)
793 if (w32_unicode_filenames
)
795 wchar_t filename_w
[MAX_PATH
];
797 if (g_b_init_set_file_security_w
== 0)
799 g_b_init_set_file_security_w
= 1;
800 hm_advapi32
= LoadLibrary ("Advapi32.dll");
801 s_pfn_Set_File_SecurityW
=
802 (SetFileSecurityW_Proc
) GetProcAddress (hm_advapi32
,
805 if (s_pfn_Set_File_SecurityW
== NULL
)
810 filename_to_utf16 (lpFileName
, filename_w
);
811 return (s_pfn_Set_File_SecurityW (filename_w
, SecurityInformation
,
812 pSecurityDescriptor
));
816 char filename_a
[MAX_PATH
];
818 if (g_b_init_set_file_security_a
== 0)
820 g_b_init_set_file_security_a
= 1;
821 hm_advapi32
= LoadLibrary ("Advapi32.dll");
822 s_pfn_Set_File_SecurityA
=
823 (SetFileSecurityA_Proc
) GetProcAddress (hm_advapi32
,
826 if (s_pfn_Set_File_SecurityA
== NULL
)
831 filename_to_ansi (lpFileName
, filename_a
);
832 return (s_pfn_Set_File_SecurityA (filename_a
, SecurityInformation
,
833 pSecurityDescriptor
));
838 set_named_security_info (LPCTSTR lpObjectName
,
839 SE_OBJECT_TYPE ObjectType
,
840 SECURITY_INFORMATION SecurityInformation
,
846 static SetNamedSecurityInfoW_Proc s_pfn_Set_Named_Security_InfoW
= NULL
;
847 static SetNamedSecurityInfoA_Proc s_pfn_Set_Named_Security_InfoA
= NULL
;
848 HMODULE hm_advapi32
= NULL
;
849 if (is_windows_9x () == TRUE
)
854 if (w32_unicode_filenames
)
856 wchar_t filename_w
[MAX_PATH
];
858 if (g_b_init_set_named_security_info_w
== 0)
860 g_b_init_set_named_security_info_w
= 1;
861 hm_advapi32
= LoadLibrary ("Advapi32.dll");
862 s_pfn_Set_Named_Security_InfoW
=
863 (SetNamedSecurityInfoW_Proc
) GetProcAddress (hm_advapi32
,
864 "SetNamedSecurityInfoW");
866 if (s_pfn_Set_Named_Security_InfoW
== NULL
)
871 filename_to_utf16 (lpObjectName
, filename_w
);
872 return (s_pfn_Set_Named_Security_InfoW (filename_w
, ObjectType
,
873 SecurityInformation
, psidOwner
,
874 psidGroup
, pDacl
, pSacl
));
878 char filename_a
[MAX_PATH
];
880 if (g_b_init_set_named_security_info_a
== 0)
882 g_b_init_set_named_security_info_a
= 1;
883 hm_advapi32
= LoadLibrary ("Advapi32.dll");
884 s_pfn_Set_Named_Security_InfoA
=
885 (SetNamedSecurityInfoA_Proc
) GetProcAddress (hm_advapi32
,
886 "SetNamedSecurityInfoA");
888 if (s_pfn_Set_Named_Security_InfoA
== NULL
)
893 filename_to_ansi (lpObjectName
, filename_a
);
894 return (s_pfn_Set_Named_Security_InfoA (filename_a
, ObjectType
,
895 SecurityInformation
, psidOwner
,
896 psidGroup
, pDacl
, pSacl
));
901 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
903 LPBOOL lpbOwnerDefaulted
)
905 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
906 HMODULE hm_advapi32
= NULL
;
907 if (is_windows_9x () == TRUE
)
912 if (g_b_init_get_security_descriptor_owner
== 0)
914 g_b_init_get_security_descriptor_owner
= 1;
915 hm_advapi32
= LoadLibrary ("Advapi32.dll");
916 s_pfn_Get_Security_Descriptor_Owner
=
917 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
918 hm_advapi32
, "GetSecurityDescriptorOwner");
920 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
925 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
930 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
932 LPBOOL lpbGroupDefaulted
)
934 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
935 HMODULE hm_advapi32
= NULL
;
936 if (is_windows_9x () == TRUE
)
941 if (g_b_init_get_security_descriptor_group
== 0)
943 g_b_init_get_security_descriptor_group
= 1;
944 hm_advapi32
= LoadLibrary ("Advapi32.dll");
945 s_pfn_Get_Security_Descriptor_Group
=
946 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
947 hm_advapi32
, "GetSecurityDescriptorGroup");
949 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
954 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
959 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
960 LPBOOL lpbDaclPresent
,
962 LPBOOL lpbDaclDefaulted
)
964 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl
= NULL
;
965 HMODULE hm_advapi32
= NULL
;
966 if (is_windows_9x () == TRUE
)
971 if (g_b_init_get_security_descriptor_dacl
== 0)
973 g_b_init_get_security_descriptor_dacl
= 1;
974 hm_advapi32
= LoadLibrary ("Advapi32.dll");
975 s_pfn_Get_Security_Descriptor_Dacl
=
976 (GetSecurityDescriptorDacl_Proc
) GetProcAddress (
977 hm_advapi32
, "GetSecurityDescriptorDacl");
979 if (s_pfn_Get_Security_Descriptor_Dacl
== NULL
)
984 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor
,
985 lpbDaclPresent
, pDacl
,
990 is_valid_sid (PSID sid
)
992 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
993 HMODULE hm_advapi32
= NULL
;
994 if (is_windows_9x () == TRUE
)
998 if (g_b_init_is_valid_sid
== 0)
1000 g_b_init_is_valid_sid
= 1;
1001 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1002 s_pfn_Is_Valid_Sid
=
1003 (IsValidSid_Proc
) GetProcAddress (
1004 hm_advapi32
, "IsValidSid");
1006 if (s_pfn_Is_Valid_Sid
== NULL
)
1010 return (s_pfn_Is_Valid_Sid (sid
));
1014 equal_sid (PSID sid1
, PSID sid2
)
1016 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
1017 HMODULE hm_advapi32
= NULL
;
1018 if (is_windows_9x () == TRUE
)
1022 if (g_b_init_equal_sid
== 0)
1024 g_b_init_equal_sid
= 1;
1025 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1027 (EqualSid_Proc
) GetProcAddress (
1028 hm_advapi32
, "EqualSid");
1030 if (s_pfn_Equal_Sid
== NULL
)
1034 return (s_pfn_Equal_Sid (sid1
, sid2
));
1038 get_length_sid (PSID sid
)
1040 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
1041 HMODULE hm_advapi32
= NULL
;
1042 if (is_windows_9x () == TRUE
)
1046 if (g_b_init_get_length_sid
== 0)
1048 g_b_init_get_length_sid
= 1;
1049 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1050 s_pfn_Get_Length_Sid
=
1051 (GetLengthSid_Proc
) GetProcAddress (
1052 hm_advapi32
, "GetLengthSid");
1054 if (s_pfn_Get_Length_Sid
== NULL
)
1058 return (s_pfn_Get_Length_Sid (sid
));
1062 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
1064 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
1065 HMODULE hm_advapi32
= NULL
;
1066 if (is_windows_9x () == TRUE
)
1070 if (g_b_init_copy_sid
== 0)
1072 g_b_init_copy_sid
= 1;
1073 hm_advapi32
= LoadLibrary ("Advapi32.dll");
1075 (CopySid_Proc
) GetProcAddress (
1076 hm_advapi32
, "CopySid");
1078 if (s_pfn_Copy_Sid
== NULL
)
1082 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
1086 END: Wrapper functions around OpenProcessToken
1087 and other functions in advapi32.dll that are only
1088 supported in Windows NT / 2k / XP
1092 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
1094 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
1095 if (is_windows_9x () != TRUE
)
1097 if (g_b_init_get_native_system_info
== 0)
1099 g_b_init_get_native_system_info
= 1;
1100 s_pfn_Get_Native_System_Info
=
1101 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1102 "GetNativeSystemInfo");
1104 if (s_pfn_Get_Native_System_Info
!= NULL
)
1105 s_pfn_Get_Native_System_Info (lpSystemInfo
);
1108 lpSystemInfo
->dwNumberOfProcessors
= -1;
1112 get_system_times (LPFILETIME lpIdleTime
,
1113 LPFILETIME lpKernelTime
,
1114 LPFILETIME lpUserTime
)
1116 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
1117 if (is_windows_9x () == TRUE
)
1121 if (g_b_init_get_system_times
== 0)
1123 g_b_init_get_system_times
= 1;
1124 s_pfn_Get_System_times
=
1125 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1128 if (s_pfn_Get_System_times
== NULL
)
1130 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
1133 static BOOLEAN WINAPI
1134 create_symbolic_link (LPCSTR lpSymlinkFilename
,
1135 LPCSTR lpTargetFileName
,
1138 static CreateSymbolicLinkW_Proc s_pfn_Create_Symbolic_LinkW
= NULL
;
1139 static CreateSymbolicLinkA_Proc s_pfn_Create_Symbolic_LinkA
= NULL
;
1142 if (is_windows_9x () == TRUE
)
1147 if (w32_unicode_filenames
)
1149 wchar_t symfn_w
[MAX_PATH
], tgtfn_w
[MAX_PATH
];
1151 if (g_b_init_create_symbolic_link_w
== 0)
1153 g_b_init_create_symbolic_link_w
= 1;
1154 s_pfn_Create_Symbolic_LinkW
=
1155 (CreateSymbolicLinkW_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1156 "CreateSymbolicLinkW");
1158 if (s_pfn_Create_Symbolic_LinkW
== NULL
)
1164 filename_to_utf16 (lpSymlinkFilename
, symfn_w
);
1165 filename_to_utf16 (lpTargetFileName
, tgtfn_w
);
1166 retval
= s_pfn_Create_Symbolic_LinkW (symfn_w
, tgtfn_w
, dwFlags
);
1167 /* If we were denied creation of the symlink, try again after
1168 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1171 TOKEN_PRIVILEGES priv_current
;
1173 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
,
1176 retval
= s_pfn_Create_Symbolic_LinkW (symfn_w
, tgtfn_w
, dwFlags
);
1177 restore_privilege (&priv_current
);
1184 char symfn_a
[MAX_PATH
], tgtfn_a
[MAX_PATH
];
1186 if (g_b_init_create_symbolic_link_a
== 0)
1188 g_b_init_create_symbolic_link_a
= 1;
1189 s_pfn_Create_Symbolic_LinkA
=
1190 (CreateSymbolicLinkA_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
1191 "CreateSymbolicLinkA");
1193 if (s_pfn_Create_Symbolic_LinkA
== NULL
)
1199 filename_to_ansi (lpSymlinkFilename
, symfn_a
);
1200 filename_to_ansi (lpTargetFileName
, tgtfn_a
);
1201 retval
= s_pfn_Create_Symbolic_LinkA (symfn_a
, tgtfn_a
, dwFlags
);
1202 /* If we were denied creation of the symlink, try again after
1203 enabling the SeCreateSymbolicLinkPrivilege for our process. */
1206 TOKEN_PRIVILEGES priv_current
;
1208 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
,
1211 retval
= s_pfn_Create_Symbolic_LinkA (symfn_a
, tgtfn_a
, dwFlags
);
1212 restore_privilege (&priv_current
);
1221 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor
)
1223 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc
= NULL
;
1225 if (is_windows_9x () == TRUE
)
1231 if (g_b_init_is_valid_security_descriptor
== 0)
1233 g_b_init_is_valid_security_descriptor
= 1;
1234 s_pfn_Is_Valid_Security_Descriptor_Proc
=
1235 (IsValidSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1236 "IsValidSecurityDescriptor");
1238 if (s_pfn_Is_Valid_Security_Descriptor_Proc
== NULL
)
1244 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor
);
1248 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor
,
1249 DWORD RequestedStringSDRevision
,
1250 SECURITY_INFORMATION SecurityInformation
,
1251 LPTSTR
*StringSecurityDescriptor
,
1252 PULONG StringSecurityDescriptorLen
)
1254 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL
= NULL
;
1257 if (is_windows_9x () == TRUE
)
1263 if (g_b_init_convert_sd_to_sddl
== 0)
1265 g_b_init_convert_sd_to_sddl
= 1;
1267 s_pfn_Convert_SD_To_SDDL
=
1268 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1269 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1271 s_pfn_Convert_SD_To_SDDL
=
1272 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1273 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1276 if (s_pfn_Convert_SD_To_SDDL
== NULL
)
1282 retval
= s_pfn_Convert_SD_To_SDDL (SecurityDescriptor
,
1283 RequestedStringSDRevision
,
1284 SecurityInformation
,
1285 StringSecurityDescriptor
,
1286 StringSecurityDescriptorLen
);
1292 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor
,
1293 DWORD StringSDRevision
,
1294 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
1295 PULONG SecurityDescriptorSize
)
1297 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD
= NULL
;
1300 if (is_windows_9x () == TRUE
)
1306 if (g_b_init_convert_sddl_to_sd
== 0)
1308 g_b_init_convert_sddl_to_sd
= 1;
1310 s_pfn_Convert_SDDL_To_SD
=
1311 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1312 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1314 s_pfn_Convert_SDDL_To_SD
=
1315 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1316 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1319 if (s_pfn_Convert_SDDL_To_SD
== NULL
)
1325 retval
= s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor
,
1328 SecurityDescriptorSize
);
1334 get_adapters_info (PIP_ADAPTER_INFO pAdapterInfo
, PULONG pOutBufLen
)
1336 static GetAdaptersInfo_Proc s_pfn_Get_Adapters_Info
= NULL
;
1337 HMODULE hm_iphlpapi
= NULL
;
1339 if (is_windows_9x () == TRUE
)
1340 return ERROR_NOT_SUPPORTED
;
1342 if (g_b_init_get_adapters_info
== 0)
1344 g_b_init_get_adapters_info
= 1;
1345 hm_iphlpapi
= LoadLibrary ("Iphlpapi.dll");
1347 s_pfn_Get_Adapters_Info
= (GetAdaptersInfo_Proc
)
1348 GetProcAddress (hm_iphlpapi
, "GetAdaptersInfo");
1350 if (s_pfn_Get_Adapters_Info
== NULL
)
1351 return ERROR_NOT_SUPPORTED
;
1352 return s_pfn_Get_Adapters_Info (pAdapterInfo
, pOutBufLen
);
1357 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1358 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1360 This is called from alloc.c:valid_pointer_p. */
1362 w32_valid_pointer_p (void *p
, int size
)
1365 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
1369 unsigned char *buf
= alloca (size
);
1370 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
1381 /* Here's an overview of how the Windows build supports file names
1382 that cannot be encoded by the current system codepage.
1384 From the POV of Lisp and layers of C code above the functions here,
1385 Emacs on Windows pretends that its file names are encoded in UTF-8;
1386 see encode_file and decode_file on coding.c. Any file name that is
1387 passed as a unibyte string to C functions defined here is assumed
1388 to be in UTF-8 encoding. Any file name returned by functions
1389 defined here must be in UTF-8 encoding, with only a few exceptions
1390 reserved for a couple of special cases. (Be sure to use
1391 MAX_UTF8_PATH for char arrays that store UTF-8 encoded file names,
1392 as they can be much longer than MAX_PATH!)
1394 The UTF-8 encoded file names cannot be passed to system APIs, as
1395 Windows does not support that. Therefore, they are converted
1396 either to UTF-16 or to the ANSI codepage, depending on the value of
1397 w32-unicode-filenames, before calling any system APIs or CRT library
1398 functions. The default value of that variable is determined by the
1399 OS on which Emacs runs: nil on Windows 9X and t otherwise, but the
1400 user can change that default (although I don't see why would she
1403 The 4 functions defined below, filename_to_utf16, filename_to_ansi,
1404 filename_from_utf16, and filename_from_ansi, are the workhorses of
1405 these conversions. They rely on Windows native APIs
1406 MultiByteToWideChar and WideCharToMultiByte; we cannot use
1407 functions from coding.c here, because they allocate memory, which
1408 is a bad idea on the level of libc, which is what the functions
1409 here emulate. (If you worry about performance due to constant
1410 conversion back and forth from UTF-8 to UTF-16, then don't: first,
1411 it was measured to take only a few microseconds on a not-so-fast
1412 machine, and second, that's exactly what the ANSI APIs we used
1413 before did anyway, because they are just thin wrappers around the
1416 The variables file-name-coding-system and default-file-name-coding-system
1417 still exist, but are actually used only when a file name needs to
1418 be converted to the ANSI codepage. This happens all the time when
1419 w32-unicode-filenames is nil, but can also happen from time to time
1420 when it is t. Otherwise, these variables have no effect on file-name
1421 encoding when w32-unicode-filenames is t; this is similar to
1422 selection-coding-system.
1424 This arrangement works very well, but it has a few gotchas and
1427 . Lisp code that encodes or decodes file names manually should
1428 normally use 'utf-8' as the coding-system on Windows,
1429 disregarding file-name-coding-system. This is a somewhat
1430 unpleasant consequence, but it cannot be avoided. Fortunately,
1431 very few Lisp packages need to do that.
1433 More generally, passing to library functions (e.g., fopen or
1434 opendir) file names already encoded in the ANSI codepage is
1435 explicitly *verboten*, as all those functions, as shadowed and
1436 emulated here, assume they will receive UTF-8 encoded file names.
1438 For the same reasons, no CRT function or Win32 API can be called
1439 directly in Emacs sources, without either converting the file
1440 names from UTF-8 to UTF-16 or ANSI codepage, or going through
1441 some shadowing function defined here.
1443 . Environment variables stored in Vprocess_environment are encoded
1444 in the ANSI codepage, so if getenv/egetenv is used for a variable
1445 whose value is a file name or a list of directories, it needs to
1446 be converted to UTF-8, before it is used as argument to functions
1447 or decoded into a Lisp string.
1449 . File names passed to external libraries, like the image libraries
1450 and GnuTLS, need special handling. These libraries generally
1451 don't support UTF-16 or UTF-8 file names, so they must get file
1452 names encoded in the ANSI codepage. To facilitate using these
1453 libraries with file names that are not encodable in the ANSI
1454 codepage, use the function ansi_encode_filename, which will try
1455 to use the short 8+3 alias of a file name if that file name is
1456 not encodable in the ANSI codepage. See image.c and gnutls.c for
1457 examples of how this should be done.
1459 . Running subprocesses in non-ASCII directories and with non-ASCII
1460 file arguments is limited to the current codepage (even though
1461 Emacs is perfectly capable of finding an executable program file
1462 in a directory whose name cannot be encoded in the current
1463 codepage). This is because the command-line arguments are
1464 encoded _before_ they get to the w32-specific level, and the
1465 encoding is not known in advance (it doesn't have to be the
1466 current ANSI codepage), so w32proc.c functions cannot re-encode
1467 them in UTF-16. This should be fixed, but will also require
1468 changes in cmdproxy. The current limitation is not terribly bad
1469 anyway, since very few, if any, Windows console programs that are
1470 likely to be invoked by Emacs support UTF-16 encoded command
1473 . For similar reasons, server.el and emacsclient are also limited
1474 to the current ANSI codepage for now.
1476 . Emacs itself can only handle command-line arguments encoded in
1477 the current codepage.
1479 . Turning on w32-unicode-filename on Windows 9X (if it at all
1480 works) requires UNICOWS.DLL, which is thus a requirement even in
1481 non-GUI sessions, something the we previously avoided. */
1485 /* Converting file names from UTF-8 to either UTF-16 or the ANSI
1486 codepage defined by file-name-coding-system. */
1488 /* Current codepage for encoding file names. */
1489 static int file_name_codepage
;
1491 /* Produce a Windows ANSI codepage suitable for encoding file names.
1492 Return the information about that codepage in CP_INFO. */
1494 codepage_for_filenames (CPINFO
*cp_info
)
1496 /* A simple cache to avoid calling GetCPInfo every time we need to
1497 encode/decode a file name. The file-name encoding is not
1498 supposed to be changed too frequently, if ever. */
1499 static Lisp_Object last_file_name_encoding
;
1501 Lisp_Object current_encoding
;
1503 current_encoding
= Vfile_name_coding_system
;
1504 if (NILP (current_encoding
))
1505 current_encoding
= Vdefault_file_name_coding_system
;
1507 if (!EQ (last_file_name_encoding
, current_encoding
))
1509 /* Default to the current ANSI codepage. */
1510 file_name_codepage
= w32_ansi_code_page
;
1512 if (NILP (current_encoding
))
1514 char *cpname
= SDATA (SYMBOL_NAME (current_encoding
));
1515 char *cp
= NULL
, *end
;
1518 if (strncmp (cpname
, "cp", 2) == 0)
1520 else if (strncmp (cpname
, "windows-", 8) == 0)
1526 cpnum
= strtol (cp
, &end
, 10);
1527 if (cpnum
&& *end
== '\0' && end
- cp
>= 2)
1528 file_name_codepage
= cpnum
;
1532 if (!file_name_codepage
)
1533 file_name_codepage
= CP_ACP
; /* CP_ACP = 0, but let's not assume that */
1535 if (!GetCPInfo (file_name_codepage
, &cp
))
1537 file_name_codepage
= CP_ACP
;
1538 if (!GetCPInfo (file_name_codepage
, &cp
))
1545 return file_name_codepage
;
1549 filename_to_utf16 (const char *fn_in
, wchar_t *fn_out
)
1551 int result
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1556 DWORD err
= GetLastError ();
1560 case ERROR_INVALID_FLAGS
:
1561 case ERROR_INVALID_PARAMETER
:
1564 case ERROR_INSUFFICIENT_BUFFER
:
1565 case ERROR_NO_UNICODE_TRANSLATION
:
1576 filename_from_utf16 (const wchar_t *fn_in
, char *fn_out
)
1578 int result
= pWideCharToMultiByte (CP_UTF8
, 0, fn_in
, -1,
1579 fn_out
, MAX_UTF8_PATH
, NULL
, NULL
);
1583 DWORD err
= GetLastError ();
1587 case ERROR_INVALID_FLAGS
:
1588 case ERROR_INVALID_PARAMETER
:
1591 case ERROR_INSUFFICIENT_BUFFER
:
1592 case ERROR_NO_UNICODE_TRANSLATION
:
1603 filename_to_ansi (const char *fn_in
, char *fn_out
)
1605 wchar_t fn_utf16
[MAX_PATH
];
1607 if (filename_to_utf16 (fn_in
, fn_utf16
) == 0)
1610 int codepage
= codepage_for_filenames (NULL
);
1612 result
= pWideCharToMultiByte (codepage
, 0, fn_utf16
, -1,
1613 fn_out
, MAX_PATH
, NULL
, NULL
);
1616 DWORD err
= GetLastError ();
1620 case ERROR_INVALID_FLAGS
:
1621 case ERROR_INVALID_PARAMETER
:
1624 case ERROR_INSUFFICIENT_BUFFER
:
1625 case ERROR_NO_UNICODE_TRANSLATION
:
1638 filename_from_ansi (const char *fn_in
, char *fn_out
)
1640 wchar_t fn_utf16
[MAX_PATH
];
1641 int codepage
= codepage_for_filenames (NULL
);
1642 int result
= pMultiByteToWideChar (codepage
, MB_ERR_INVALID_CHARS
, fn_in
, -1,
1643 fn_utf16
, MAX_PATH
);
1647 DWORD err
= GetLastError ();
1651 case ERROR_INVALID_FLAGS
:
1652 case ERROR_INVALID_PARAMETER
:
1655 case ERROR_INSUFFICIENT_BUFFER
:
1656 case ERROR_NO_UNICODE_TRANSLATION
:
1663 return filename_from_utf16 (fn_utf16
, fn_out
);
1668 /* The directory where we started, in UTF-8. */
1669 static char startup_dir
[MAX_UTF8_PATH
];
1671 /* Get the current working directory. */
1673 getcwd (char *dir
, int dirsize
)
1680 if (dirsize
<= strlen (startup_dir
))
1686 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
1690 /* Emacs doesn't actually change directory itself, it stays in the
1691 same directory where it was started. */
1692 strcpy (dir
, startup_dir
);
1697 /* Emulate getloadavg. */
1699 struct load_sample
{
1706 /* Number of processors on this machine. */
1707 static unsigned num_of_processors
;
1709 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1710 static struct load_sample samples
[16*60];
1711 static int first_idx
= -1, last_idx
= -1;
1712 static int max_idx
= ARRAYELTS (samples
);
1717 int next_idx
= from
+ 1;
1719 if (next_idx
>= max_idx
)
1728 int prev_idx
= from
- 1;
1731 prev_idx
= max_idx
- 1;
1737 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
1739 SYSTEM_INFO sysinfo
;
1740 FILETIME ft_idle
, ft_user
, ft_kernel
;
1742 /* Initialize the number of processors on this machine. */
1743 if (num_of_processors
<= 0)
1745 get_native_system_info (&sysinfo
);
1746 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1747 if (num_of_processors
<= 0)
1749 GetSystemInfo (&sysinfo
);
1750 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1752 if (num_of_processors
<= 0)
1753 num_of_processors
= 1;
1756 /* TODO: Take into account threads that are ready to run, by
1757 sampling the "\System\Processor Queue Length" performance
1758 counter. The code below accounts only for threads that are
1759 actually running. */
1761 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
1763 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1765 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1766 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1767 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1768 *idle
= uidle
.QuadPart
;
1769 *kernel
= ukernel
.QuadPart
;
1770 *user
= uuser
.QuadPart
;
1780 /* Produce the load average for a given time interval, using the
1781 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1782 1-minute, 5-minute, or 15-minute average, respectively. */
1786 double retval
= -1.0;
1789 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1790 time_t now
= samples
[last_idx
].sample_time
;
1792 if (first_idx
!= last_idx
)
1794 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1796 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1797 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1800 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1801 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1802 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1804 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1807 if (idx
== first_idx
)
1816 getloadavg (double loadavg
[], int nelem
)
1819 ULONGLONG idle
, kernel
, user
;
1820 time_t now
= time (NULL
);
1822 /* If system time jumped back for some reason, delete all samples
1823 whose time is later than the current wall-clock time. This
1824 prevents load average figures from becoming frozen for prolonged
1825 periods of time, when system time is reset backwards. */
1828 while (difftime (now
, samples
[last_idx
].sample_time
) < -1.0)
1830 if (last_idx
== first_idx
)
1832 first_idx
= last_idx
= -1;
1835 last_idx
= buf_prev (last_idx
);
1839 /* Store another sample. We ignore samples that are less than 1 sec
1842 || (difftime (now
, samples
[last_idx
].sample_time
)
1843 >= 1.0 - 2*DBL_EPSILON
*now
))
1845 sample_system_load (&idle
, &kernel
, &user
);
1846 last_idx
= buf_next (last_idx
);
1847 samples
[last_idx
].sample_time
= now
;
1848 samples
[last_idx
].idle
= idle
;
1849 samples
[last_idx
].kernel
= kernel
;
1850 samples
[last_idx
].user
= user
;
1851 /* If the buffer has more that 15 min worth of samples, discard
1853 if (first_idx
== -1)
1854 first_idx
= last_idx
;
1855 while (first_idx
!= last_idx
1856 && (difftime (now
, samples
[first_idx
].sample_time
)
1857 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1858 first_idx
= buf_next (first_idx
);
1861 for (elem
= 0; elem
< nelem
; elem
++)
1863 double avg
= getavg (elem
);
1867 loadavg
[elem
] = avg
;
1873 /* Emulate getpwuid, getpwnam and others. */
1875 #define PASSWD_FIELD_SIZE 256
1877 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1878 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1879 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1880 static char dflt_passwd_dir
[MAX_UTF8_PATH
];
1881 static char dflt_passwd_shell
[MAX_UTF8_PATH
];
1883 static struct passwd dflt_passwd
=
1895 static char dflt_group_name
[GNLEN
+1];
1897 static struct group dflt_group
=
1899 /* When group information is not available, we return this as the
1900 group for all files. */
1908 return dflt_passwd
.pw_uid
;
1914 /* I could imagine arguing for checking to see whether the user is
1915 in the Administrators group and returning a UID of 0 for that
1916 case, but I don't know how wise that would be in the long run. */
1923 return dflt_passwd
.pw_gid
;
1933 getpwuid (unsigned uid
)
1935 if (uid
== dflt_passwd
.pw_uid
)
1936 return &dflt_passwd
;
1941 getgrgid (gid_t gid
)
1947 getpwnam (char *name
)
1951 pw
= getpwuid (getuid ());
1955 if (xstrcasecmp (name
, pw
->pw_name
))
1962 init_user_info (void)
1964 /* Find the user's real name by opening the process token and
1965 looking up the name associated with the user-sid in that token.
1967 Use the relative portion of the identifier authority value from
1968 the user-sid as the user id value (same for group id using the
1969 primary group sid from the process token). */
1971 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1972 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1973 DWORD glength
= sizeof (gname
);
1974 HANDLE token
= NULL
;
1975 SID_NAME_USE user_type
;
1976 unsigned char *buf
= NULL
;
1978 TOKEN_USER user_token
;
1979 TOKEN_PRIMARY_GROUP group_token
;
1982 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1985 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1986 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1988 buf
= xmalloc (blen
);
1989 result
= get_token_information (token
, TokenUser
,
1990 (LPVOID
)buf
, blen
, &needed
);
1993 memcpy (&user_token
, buf
, sizeof (user_token
));
1994 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1996 domain
, &dlength
, &user_type
);
2004 strcpy (dflt_passwd
.pw_name
, uname
);
2005 /* Determine a reasonable uid value. */
2006 if (xstrcasecmp ("administrator", uname
) == 0)
2008 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
2009 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
2013 /* Use the last sub-authority value of the RID, the relative
2014 portion of the SID, as user/group ID. */
2015 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
2017 /* Get group id and name. */
2018 result
= get_token_information (token
, TokenPrimaryGroup
,
2019 (LPVOID
)buf
, blen
, &needed
);
2020 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
2022 buf
= xrealloc (buf
, blen
= needed
);
2023 result
= get_token_information (token
, TokenPrimaryGroup
,
2024 (LPVOID
)buf
, blen
, &needed
);
2028 memcpy (&group_token
, buf
, sizeof (group_token
));
2029 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
2030 dlength
= sizeof (domain
);
2031 /* If we can get at the real Primary Group name, use that.
2032 Otherwise, the default group name was already set to
2033 "None" in globals_of_w32. */
2034 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
2035 gname
, &glength
, NULL
, &dlength
,
2037 strcpy (dflt_group_name
, gname
);
2040 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
2043 /* If security calls are not supported (presumably because we
2044 are running under Windows 9X), fallback to this: */
2045 else if (GetUserName (uname
, &ulength
))
2047 strcpy (dflt_passwd
.pw_name
, uname
);
2048 if (xstrcasecmp ("administrator", uname
) == 0)
2049 dflt_passwd
.pw_uid
= 0;
2051 dflt_passwd
.pw_uid
= 123;
2052 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
2056 strcpy (dflt_passwd
.pw_name
, "unknown");
2057 dflt_passwd
.pw_uid
= 123;
2058 dflt_passwd
.pw_gid
= 123;
2060 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
2062 /* Set dir and shell from environment variables. */
2063 if (w32_unicode_filenames
)
2065 wchar_t *home
= _wgetenv (L
"HOME");
2066 wchar_t *shell
= _wgetenv (L
"SHELL");
2068 /* Ensure HOME and SHELL are defined. */
2073 filename_from_utf16 (home
, dflt_passwd
.pw_dir
);
2074 filename_from_utf16 (shell
, dflt_passwd
.pw_shell
);
2078 char *home
= getenv ("HOME");
2079 char *shell
= getenv ("SHELL");
2085 filename_from_ansi (home
, dflt_passwd
.pw_dir
);
2086 filename_from_ansi (shell
, dflt_passwd
.pw_shell
);
2091 CloseHandle (token
);
2097 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
2098 return ((rand () << 15) | rand ());
2107 /* Return the maximum length in bytes of a multibyte character
2108 sequence encoded in the current ANSI codepage. This is required to
2109 correctly walk the encoded file names one character at a time. */
2111 max_filename_mbslen (void)
2115 codepage_for_filenames (&cp_info
);
2116 return cp_info
.MaxCharSize
;
2119 /* Normalize filename by converting in-place all of its path
2120 separators to the separator specified by PATH_SEP. */
2123 normalize_filename (register char *fp
, char path_sep
)
2127 /* Always lower-case drive letters a-z, even if the filesystem
2128 preserves case in filenames.
2129 This is so filenames can be compared by string comparison
2130 functions that are case-sensitive. Even case-preserving filesystems
2131 do not distinguish case in drive letters. */
2134 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
2142 if ((*fp
== '/' || *fp
== '\\') && *fp
!= path_sep
)
2148 /* Destructively turn backslashes into slashes. */
2150 dostounix_filename (register char *p
)
2152 normalize_filename (p
, '/');
2155 /* Destructively turn slashes into backslashes. */
2157 unixtodos_filename (register char *p
)
2159 normalize_filename (p
, '\\');
2162 /* Remove all CR's that are followed by a LF.
2163 (From msdos.c...probably should figure out a way to share it,
2164 although this code isn't going to ever change.) */
2166 crlf_to_lf (register int n
, register unsigned char *buf
)
2168 unsigned char *np
= buf
;
2169 unsigned char *startp
= buf
;
2170 unsigned char *endp
= buf
+ n
;
2174 while (buf
< endp
- 1)
2178 if (*(++buf
) != 0x0a)
2189 /* Parse the root part of file name, if present. Return length and
2190 optionally store pointer to char after root. */
2192 parse_root (const char * name
, const char ** pPath
)
2194 const char * start
= name
;
2199 /* find the root name of the volume if given */
2200 if (isalpha (name
[0]) && name
[1] == ':')
2202 /* skip past drive specifier */
2204 if (IS_DIRECTORY_SEP (name
[0]))
2207 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2214 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2219 if (IS_DIRECTORY_SEP (name
[0]))
2226 return name
- start
;
2229 /* Get long base name for name; name is assumed to be absolute. */
2231 get_long_basename (char * name
, char * buf
, int size
)
2233 HANDLE dir_handle
= INVALID_HANDLE_VALUE
;
2234 char fname_utf8
[MAX_UTF8_PATH
];
2238 /* Must be valid filename, no wild cards or other invalid characters. */
2239 if (strpbrk (name
, "*?|<>\""))
2242 if (w32_unicode_filenames
)
2244 wchar_t fname_utf16
[MAX_PATH
];
2245 WIN32_FIND_DATAW find_data_wide
;
2247 filename_to_utf16 (name
, fname_utf16
);
2248 dir_handle
= FindFirstFileW (fname_utf16
, &find_data_wide
);
2249 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2250 cstatus
= filename_from_utf16 (find_data_wide
.cFileName
, fname_utf8
);
2254 char fname_ansi
[MAX_PATH
];
2255 WIN32_FIND_DATAA find_data_ansi
;
2257 filename_to_ansi (name
, fname_ansi
);
2258 /* If the ANSI name includes ? characters, it is not encodable
2259 in the ANSI codepage. In that case, we deliver the question
2260 marks to the caller; calling FindFirstFileA in this case
2261 could return some unrelated file name in the same
2263 if (_mbspbrk (fname_ansi
, "?"))
2265 /* Find the basename of fname_ansi. */
2266 char *p
= strrchr (fname_ansi
, '\\');
2272 cstatus
= filename_from_ansi (p
, fname_utf8
);
2276 dir_handle
= FindFirstFileA (fname_ansi
, &find_data_ansi
);
2277 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2278 cstatus
= filename_from_ansi (find_data_ansi
.cFileName
, fname_utf8
);
2282 if (cstatus
== 0 && (len
= strlen (fname_utf8
)) < size
)
2283 memcpy (buf
, fname_utf8
, len
+ 1);
2287 if (dir_handle
!= INVALID_HANDLE_VALUE
)
2288 FindClose (dir_handle
);
2293 /* Get long name for file, if possible (assumed to be absolute). */
2295 w32_get_long_filename (const char * name
, char * buf
, int size
)
2300 char full
[ MAX_UTF8_PATH
];
2303 len
= strlen (name
);
2304 if (len
>= MAX_UTF8_PATH
)
2307 /* Use local copy for destructive modification. */
2308 memcpy (full
, name
, len
+1);
2309 unixtodos_filename (full
);
2311 /* Copy root part verbatim. */
2312 len
= parse_root (full
, (const char **)&p
);
2313 memcpy (o
, full
, len
);
2318 while (p
!= NULL
&& *p
)
2321 p
= strchr (q
, '\\');
2323 len
= get_long_basename (full
, o
, size
);
2346 w32_get_short_filename (const char * name
, char * buf
, int size
)
2348 if (w32_unicode_filenames
)
2350 wchar_t name_utf16
[MAX_PATH
], short_name
[MAX_PATH
];
2351 unsigned int retval
;
2353 filename_to_utf16 (name
, name_utf16
);
2354 retval
= GetShortPathNameW (name_utf16
, short_name
, size
);
2355 if (retval
&& retval
< size
)
2356 filename_from_utf16 (short_name
, buf
);
2361 char name_ansi
[MAX_PATH
];
2363 filename_to_ansi (name
, name_ansi
);
2364 return GetShortPathNameA (name_ansi
, buf
, size
);
2368 /* Re-encode FILENAME, a UTF-8 encoded unibyte string, using the
2369 MS-Windows ANSI codepage. If FILENAME includes characters not
2370 supported by the ANSI codepage, return the 8+3 alias of FILENAME,
2371 if it exists. This is needed because the w32 build wants to
2372 support file names outside of the system locale, but image
2373 libraries typically don't support wide (a.k.a. "Unicode") APIs
2374 required for that. */
2377 ansi_encode_filename (Lisp_Object filename
)
2379 Lisp_Object encoded_filename
;
2380 char fname
[MAX_PATH
];
2382 filename_to_ansi (SSDATA (filename
), fname
);
2383 if (_mbspbrk (fname
, "?"))
2385 char shortname
[MAX_PATH
];
2387 if (w32_get_short_filename (SDATA (filename
), shortname
, MAX_PATH
))
2389 dostounix_filename (shortname
);
2390 encoded_filename
= build_string (shortname
);
2393 encoded_filename
= build_unibyte_string (fname
);
2396 encoded_filename
= build_unibyte_string (fname
);
2397 return encoded_filename
;
2401 is_unc_volume (const char *filename
)
2403 const char *ptr
= filename
;
2405 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
2408 if (strpbrk (ptr
+ 2, "*?|<>\"\\/"))
2414 /* Emulate the Posix unsetenv. */
2416 unsetenv (const char *name
)
2421 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
2426 name_len
= strlen (name
);
2427 /* MS docs says an environment variable cannot be longer than 32K. */
2428 if (name_len
> 32767)
2433 /* It is safe to use 'alloca' with 32K size, since the stack is at
2434 least 2MB, and we set it to 8MB in the link command line. */
2435 var
= alloca (name_len
+ 2);
2436 strncpy (var
, name
, name_len
);
2437 var
[name_len
++] = '=';
2438 var
[name_len
] = '\0';
2439 return _putenv (var
);
2442 /* MS _putenv doesn't support removing a variable when the argument
2443 does not include the '=' character, so we fix that here. */
2445 sys_putenv (char *str
)
2447 const char *const name_end
= strchr (str
, '=');
2449 if (name_end
== NULL
)
2451 /* Remove the variable from the environment. */
2452 return unsetenv (str
);
2455 return _putenv (str
);
2458 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
2461 w32_get_resource (char *key
, LPDWORD lpdwtype
)
2464 HKEY hrootkey
= NULL
;
2467 /* Check both the current user and the local machine to see if
2468 we have any resources. */
2470 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2474 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2475 && (lpvalue
= xmalloc (cbData
)) != NULL
2476 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2478 RegCloseKey (hrootkey
);
2484 RegCloseKey (hrootkey
);
2487 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
2491 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
2492 && (lpvalue
= xmalloc (cbData
)) != NULL
2493 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
2495 RegCloseKey (hrootkey
);
2501 RegCloseKey (hrootkey
);
2507 /* The argv[] array holds ANSI-encoded strings, and so this function
2508 works with ANS_encoded strings. */
2510 init_environment (char ** argv
)
2512 static const char * const tempdirs
[] = {
2513 "$TMPDIR", "$TEMP", "$TMP", "c:/"
2518 const int imax
= ARRAYELTS (tempdirs
);
2520 /* Implementation note: This function explicitly works with ANSI
2521 file names, not with UTF-8 encoded file names. This is because
2522 this function pushes variables into the Emacs's environment, and
2523 the environment variables are always assumed to be in the
2524 locale-specific encoding. Do NOT call any functions that accept
2525 UTF-8 file names from this function! */
2527 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
2528 temporary files and assume "/tmp" if $TMPDIR is unset, which
2529 will break on DOS/Windows. Refuse to work if we cannot find
2530 a directory, not even "c:/", usable for that purpose. */
2531 for (i
= 0; i
< imax
; i
++)
2533 const char *tmp
= tempdirs
[i
];
2536 tmp
= getenv (tmp
+ 1);
2537 /* Note that `access' can lie to us if the directory resides on a
2538 read-only filesystem, like CD-ROM or a write-protected floppy.
2539 The only way to be really sure is to actually create a file and
2540 see if it succeeds. But I think that's too much to ask. */
2542 /* MSVCRT's _access crashes with D_OK, so we use our replacement. */
2543 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
2545 char * var
= alloca (strlen (tmp
) + 8);
2546 sprintf (var
, "TMPDIR=%s", tmp
);
2547 _putenv (strdup (var
));
2554 Fcons (build_string ("no usable temporary directories found!!"),
2556 "While setting TMPDIR: ");
2558 /* Check for environment variables and use registry settings if they
2559 don't exist. Fallback on default values where applicable. */
2564 char locale_name
[32];
2565 char default_home
[MAX_PATH
];
2568 static const struct env_entry
2574 /* If the default value is NULL, we will use the value from the
2575 outside environment or the Registry, but will not push the
2576 variable into the Emacs environment if it is defined neither
2577 in the Registry nor in the outside environment. */
2579 {"PRELOAD_WINSOCK", NULL
},
2580 {"emacs_dir", "C:/emacs"},
2581 {"EMACSLOADPATH", NULL
},
2582 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2583 {"EMACSDATA", NULL
},
2584 {"EMACSPATH", NULL
},
2591 #define N_ENV_VARS ARRAYELTS (dflt_envvars)
2593 /* We need to copy dflt_envvars[] and work on the copy because we
2594 don't want the dumped Emacs to inherit the values of
2595 environment variables we saw during dumping (which could be on
2596 a different system). The defaults above must be left intact. */
2597 struct env_entry env_vars
[N_ENV_VARS
];
2599 for (i
= 0; i
< N_ENV_VARS
; i
++)
2600 env_vars
[i
] = dflt_envvars
[i
];
2602 /* For backwards compatibility, check if a .emacs file exists in C:/
2603 If not, then we can try to default to the appdata directory under the
2604 user's profile, which is more likely to be writable. */
2605 if (sys_access ("C:/.emacs", F_OK
) != 0)
2607 HRESULT profile_result
;
2608 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2609 of Windows 95 and NT4 that have not been updated to include
2611 ShGetFolderPath_fn get_folder_path
;
2612 get_folder_path
= (ShGetFolderPath_fn
)
2613 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2615 if (get_folder_path
!= NULL
)
2617 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2620 /* If we can't get the appdata dir, revert to old behavior. */
2621 if (profile_result
== S_OK
)
2623 env_vars
[0].def_value
= default_home
;
2629 /* Get default locale info and use it for LANG. */
2630 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2631 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2632 locale_name
, sizeof (locale_name
)))
2634 for (i
= 0; i
< N_ENV_VARS
; i
++)
2636 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2638 env_vars
[i
].def_value
= locale_name
;
2644 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2646 /* Treat emacs_dir specially: set it unconditionally based on our
2650 char modname
[MAX_PATH
];
2652 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2654 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
2658 if ((p
= _mbsrchr (modname
, '\\'))
2659 /* From bin means installed Emacs, from src means uninstalled. */
2660 && (xstrcasecmp (p
, "\\bin") == 0 || xstrcasecmp (p
, "\\src") == 0))
2662 char buf
[SET_ENV_BUF_SIZE
];
2663 int within_build_tree
= xstrcasecmp (p
, "\\src") == 0;
2666 for (p
= modname
; *p
; p
= CharNext (p
))
2667 if (*p
== '\\') *p
= '/';
2669 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2670 _putenv (strdup (buf
));
2671 /* If we are running from the Posix-like build tree, define
2672 SHELL to point to our own cmdproxy. The loop below will
2673 then disregard PATH_EXEC and the default value. */
2674 if (within_build_tree
)
2676 _snprintf (buf
, sizeof (buf
) - 1,
2677 "SHELL=%s/nt/cmdproxy.exe", modname
);
2678 _putenv (strdup (buf
));
2683 for (i
= 0; i
< N_ENV_VARS
; i
++)
2685 if (!getenv (env_vars
[i
].name
))
2688 char bufc
[SET_ENV_BUF_SIZE
];
2690 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2691 /* Also ignore empty environment variables. */
2696 if (strcmp (env_vars
[i
].name
, "SHELL") == 0)
2698 /* Look for cmdproxy.exe in every directory in
2699 PATH_EXEC. FIXME: This does not find cmdproxy
2700 in nt/ when we run uninstalled. */
2701 char fname
[MAX_PATH
];
2702 const char *pstart
= PATH_EXEC
, *pend
;
2705 pend
= _mbschr (pstart
, ';');
2707 pend
= pstart
+ strlen (pstart
);
2708 /* Be defensive against series of ;;; characters. */
2711 strncpy (fname
, pstart
, pend
- pstart
);
2712 fname
[pend
- pstart
] = '/';
2713 strcpy (&fname
[pend
- pstart
+ 1], "cmdproxy.exe");
2714 ExpandEnvironmentStrings ((LPSTR
) fname
, bufc
,
2716 if (sys_access (bufc
, F_OK
) == 0)
2729 /* If not found in any directory, use the
2730 default as the last resort. */
2731 lpval
= env_vars
[i
].def_value
;
2732 dwType
= REG_EXPAND_SZ
;
2738 lpval
= env_vars
[i
].def_value
;
2739 dwType
= REG_EXPAND_SZ
;
2741 if (strcmp (env_vars
[i
].name
, "HOME") == 0 && !appdata
)
2742 Vdelayed_warnings_list
2743 = Fcons (listn (CONSTYPE_HEAP
, 2,
2744 intern ("initialization"),
2745 build_string ("Setting HOME to C:\\ by default is deprecated")),
2746 Vdelayed_warnings_list
);
2751 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2753 if (dwType
== REG_EXPAND_SZ
)
2754 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2755 else if (dwType
== REG_SZ
)
2756 strcpy (buf1
, lpval
);
2757 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2759 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2761 _putenv (strdup (buf2
));
2771 /* Rebuild system configuration to reflect invoking system. */
2772 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2774 /* Another special case: on NT, the PATH variable is actually named
2775 "Path" although cmd.exe (perhaps NT itself) arranges for
2776 environment variable lookup and setting to be case insensitive.
2777 However, Emacs assumes a fully case sensitive environment, so we
2778 need to change "Path" to "PATH" to match the expectations of
2779 various elisp packages. We do this by the sneaky method of
2780 modifying the string in the C runtime environ entry.
2782 The same applies to COMSPEC. */
2786 for (envp
= environ
; *envp
; envp
++)
2787 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2788 memcpy (*envp
, "PATH=", 5);
2789 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2790 memcpy (*envp
, "COMSPEC=", 8);
2793 /* Remember the initial working directory for getcwd. */
2794 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2795 Does it matter anywhere in Emacs? */
2796 if (w32_unicode_filenames
)
2798 wchar_t wstartup_dir
[MAX_PATH
];
2800 if (!GetCurrentDirectoryW (MAX_PATH
, wstartup_dir
))
2802 filename_from_utf16 (wstartup_dir
, startup_dir
);
2806 char astartup_dir
[MAX_PATH
];
2808 if (!GetCurrentDirectoryA (MAX_PATH
, astartup_dir
))
2810 filename_from_ansi (astartup_dir
, startup_dir
);
2814 static char modname
[MAX_PATH
];
2816 if (!GetModuleFileNameA (NULL
, modname
, MAX_PATH
))
2821 /* Determine if there is a middle mouse button, to allow parse_button
2822 to decide whether right mouse events should be mouse-2 or
2824 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2829 /* Called from expand-file-name when default-directory is not a string. */
2832 emacs_root_dir (void)
2834 static char root_dir
[MAX_UTF8_PATH
];
2837 p
= getenv ("emacs_dir");
2840 filename_from_ansi (p
, root_dir
);
2841 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2842 dostounix_filename (root_dir
);
2846 #include <sys/timeb.h>
2848 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2850 gettimeofday (struct timeval
*__restrict tv
, struct timezone
*__restrict tz
)
2855 tv
->tv_sec
= tb
.time
;
2856 tv
->tv_usec
= tb
.millitm
* 1000L;
2857 /* Implementation note: _ftime sometimes doesn't update the dstflag
2858 according to the new timezone when the system timezone is
2859 changed. We could fix that by using GetSystemTime and
2860 GetTimeZoneInformation, but that doesn't seem necessary, since
2861 Emacs always calls gettimeofday with the 2nd argument NULL (see
2862 current_emacs_time). */
2865 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2866 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2871 /* Emulate fdutimens. */
2873 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2874 TIMESPEC[0] and TIMESPEC[1], respectively.
2875 FD must be either negative -- in which case it is ignored --
2876 or a file descriptor that is open on FILE.
2877 If FD is nonnegative, then FILE can be NULL, which means
2878 use just futimes instead of utimes.
2879 If TIMESPEC is null, FAIL.
2880 Return 0 on success, -1 (setting errno) on failure. */
2883 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2890 if (fd
< 0 && !file
)
2895 /* _futime's prototype defines 2nd arg as having the type 'struct
2896 _utimbuf', while utime needs to accept 'struct utimbuf' for
2897 compatibility with Posix. So we need to use 2 different (but
2898 equivalent) types to avoid compiler warnings, sigh. */
2901 struct _utimbuf _ut
;
2903 _ut
.actime
= timespec
[0].tv_sec
;
2904 _ut
.modtime
= timespec
[1].tv_sec
;
2905 return _futime (fd
, &_ut
);
2911 ut
.actime
= timespec
[0].tv_sec
;
2912 ut
.modtime
= timespec
[1].tv_sec
;
2913 /* Call 'utime', which is implemented below, not the MS library
2914 function, which fails on directories. */
2915 return utime (file
, &ut
);
2920 /* ------------------------------------------------------------------------- */
2921 /* IO support and wrapper functions for the Windows API. */
2922 /* ------------------------------------------------------------------------- */
2924 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2925 on network directories, so we handle that case here.
2926 (Ulrich Leodolter, 1/11/95). */
2928 sys_ctime (const time_t *t
)
2930 char *str
= (char *) ctime (t
);
2931 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2934 /* Emulate sleep...we could have done this with a define, but that
2935 would necessitate including windows.h in the files that used it.
2936 This is much easier. */
2938 sys_sleep (int seconds
)
2940 Sleep (seconds
* 1000);
2943 /* Internal MSVC functions for low-level descriptor munging */
2944 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2945 extern int __cdecl
_free_osfhnd (int fd
);
2947 /* parallel array of private info on file handles */
2948 filedesc fd_info
[ MAXDESC
];
2950 typedef struct volume_info_data
{
2951 struct volume_info_data
* next
;
2953 /* time when info was obtained */
2956 /* actual volume info */
2965 /* Global referenced by various functions. */
2966 static volume_info_data volume_info
;
2968 /* Vector to indicate which drives are local and fixed (for which cached
2969 data never expires). */
2970 static BOOL fixed_drives
[26];
2972 /* Consider cached volume information to be stale if older than 10s,
2973 at least for non-local drives. Info for fixed drives is never stale. */
2974 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2975 #define VOLINFO_STILL_VALID( root_dir, info ) \
2976 ( ( isalpha (root_dir[0]) && \
2977 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2978 || GetTickCount () - info->timestamp < 10000 )
2980 /* Cache support functions. */
2982 /* Simple linked list with linear search is sufficient. */
2983 static volume_info_data
*volume_cache
= NULL
;
2985 static volume_info_data
*
2986 lookup_volume_info (char * root_dir
)
2988 volume_info_data
* info
;
2990 for (info
= volume_cache
; info
; info
= info
->next
)
2991 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2997 add_volume_info (char * root_dir
, volume_info_data
* info
)
2999 info
->root_dir
= xstrdup (root_dir
);
3000 unixtodos_filename (info
->root_dir
);
3001 info
->next
= volume_cache
;
3002 volume_cache
= info
;
3006 /* Wrapper for GetVolumeInformation, which uses caching to avoid
3007 performance penalty (~2ms on 486 for local drives, 7.5ms for local
3008 cdrom drive, ~5-10ms or more for remote drives on LAN). */
3009 static volume_info_data
*
3010 GetCachedVolumeInformation (char * root_dir
)
3012 volume_info_data
* info
;
3013 char default_root
[ MAX_UTF8_PATH
];
3014 char name
[MAX_PATH
+1];
3015 char type
[MAX_PATH
+1];
3017 /* NULL for root_dir means use root from current directory. */
3018 if (root_dir
== NULL
)
3020 if (w32_unicode_filenames
)
3022 wchar_t curdirw
[MAX_PATH
];
3024 if (GetCurrentDirectoryW (MAX_PATH
, curdirw
) == 0)
3026 filename_from_utf16 (curdirw
, default_root
);
3030 char curdira
[MAX_PATH
];
3032 if (GetCurrentDirectoryA (MAX_PATH
, curdira
) == 0)
3034 filename_from_ansi (curdira
, default_root
);
3036 parse_root (default_root
, (const char **)&root_dir
);
3038 root_dir
= default_root
;
3041 /* Local fixed drives can be cached permanently. Removable drives
3042 cannot be cached permanently, since the volume name and serial
3043 number (if nothing else) can change. Remote drives should be
3044 treated as if they are removable, since there is no sure way to
3045 tell whether they are or not. Also, the UNC association of drive
3046 letters mapped to remote volumes can be changed at any time (even
3047 by other processes) without notice.
3049 As a compromise, so we can benefit from caching info for remote
3050 volumes, we use a simple expiry mechanism to invalidate cache
3051 entries that are more than ten seconds old. */
3054 /* No point doing this, because WNetGetConnection is even slower than
3055 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
3056 GetDriveType is about the only call of this type which does not
3057 involve network access, and so is extremely quick). */
3059 /* Map drive letter to UNC if remote. */
3060 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
3062 char remote_name
[ 256 ];
3063 char drive
[3] = { root_dir
[0], ':' };
3065 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
3067 /* do something */ ;
3071 info
= lookup_volume_info (root_dir
);
3073 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
3079 /* Info is not cached, or is stale. */
3080 if (w32_unicode_filenames
)
3082 wchar_t root_w
[MAX_PATH
];
3083 wchar_t name_w
[MAX_PATH
+1];
3084 wchar_t type_w
[MAX_PATH
+1];
3086 filename_to_utf16 (root_dir
, root_w
);
3087 if (!GetVolumeInformationW (root_w
,
3088 name_w
, sizeof (name_w
),
3092 type_w
, sizeof (type_w
)))
3094 /* Hmm... not really 100% correct, as these 2 are not file
3096 filename_from_utf16 (name_w
, name
);
3097 filename_from_utf16 (type_w
, type
);
3101 char root_a
[MAX_PATH
];
3102 char name_a
[MAX_PATH
+1];
3103 char type_a
[MAX_PATH
+1];
3105 filename_to_ansi (root_dir
, root_a
);
3106 if (!GetVolumeInformationA (root_a
,
3107 name_a
, sizeof (name_a
),
3111 type_a
, sizeof (type_a
)))
3113 filename_from_ansi (name_a
, name
);
3114 filename_from_ansi (type_a
, type
);
3117 /* Cache the volume information for future use, overwriting existing
3118 entry if present. */
3121 info
= xmalloc (sizeof (volume_info_data
));
3122 add_volume_info (root_dir
, info
);
3130 info
->name
= xstrdup (name
);
3131 unixtodos_filename (info
->name
);
3132 info
->serialnum
= serialnum
;
3133 info
->maxcomp
= maxcomp
;
3134 info
->flags
= flags
;
3135 info
->type
= xstrdup (type
);
3136 info
->timestamp
= GetTickCount ();
3142 /* Get information on the volume where NAME is held; set path pointer to
3143 start of pathname in NAME (past UNC header\volume header if present),
3144 if pPath is non-NULL.
3146 Note: if NAME includes symlinks, the information is for the volume
3147 of the symlink, not of its target. That's because, even though
3148 GetVolumeInformation returns information about the symlink target
3149 of its argument, we only pass the root directory to
3150 GetVolumeInformation, not the full NAME. */
3152 get_volume_info (const char * name
, const char ** pPath
)
3154 char temp
[MAX_UTF8_PATH
];
3155 char *rootname
= NULL
; /* default to current volume */
3156 volume_info_data
* info
;
3157 int root_len
= parse_root (name
, pPath
);
3162 /* Copy the root name of the volume, if given. */
3165 strncpy (temp
, name
, root_len
);
3166 temp
[root_len
] = '\0';
3167 unixtodos_filename (temp
);
3171 info
= GetCachedVolumeInformation (rootname
);
3174 /* Set global referenced by other functions. */
3175 volume_info
= *info
;
3181 /* Determine if volume is FAT format (ie. only supports short 8.3
3182 names); also set path pointer to start of pathname in name, if
3183 pPath is non-NULL. */
3185 is_fat_volume (const char * name
, const char ** pPath
)
3187 if (get_volume_info (name
, pPath
))
3188 return (volume_info
.maxcomp
== 12);
3192 /* Convert all slashes in a filename to backslashes, and map filename
3193 to a valid 8.3 name if necessary. The result is a pointer to a
3194 static buffer, so CAVEAT EMPTOR! */
3196 map_w32_filename (const char * name
, const char ** pPath
)
3198 static char shortname
[MAX_UTF8_PATH
];
3199 char * str
= shortname
;
3202 const char * save_name
= name
;
3204 if (strlen (name
) >= sizeof (shortname
))
3206 /* Return a filename which will cause callers to fail. */
3207 strcpy (shortname
, "?");
3211 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
3213 register int left
= 8; /* maximum number of chars in part */
3214 register int extn
= 0; /* extension added? */
3215 register int dots
= 2; /* maximum number of dots allowed */
3218 *str
++ = *name
++; /* skip past UNC header */
3220 while ((c
= *name
++))
3227 *str
++ = (c
== ':' ? ':' : '\\');
3228 extn
= 0; /* reset extension flags */
3229 dots
= 2; /* max 2 dots */
3230 left
= 8; /* max length 8 for main part */
3235 /* Convert path components of the form .xxx to _xxx,
3236 but leave . and .. as they are. This allows .emacs
3237 to be read as _emacs, for example. */
3241 IS_DIRECTORY_SEP (*name
))
3256 extn
= 1; /* we've got an extension */
3257 left
= 3; /* 3 chars in extension */
3261 /* any embedded dots after the first are converted to _ */
3266 case '#': /* don't lose these, they're important */
3268 str
[-1] = c
; /* replace last character of part */
3271 if ( left
&& 'A' <= c
&& c
<= 'Z' )
3273 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
3275 dots
= 0; /* started a path component */
3284 strcpy (shortname
, name
);
3285 unixtodos_filename (shortname
);
3289 *pPath
= shortname
+ (path
- save_name
);
3295 is_exec (const char * name
)
3297 char * p
= strrchr (name
, '.');
3300 && (xstrcasecmp (p
, ".exe") == 0 ||
3301 xstrcasecmp (p
, ".com") == 0 ||
3302 xstrcasecmp (p
, ".bat") == 0 ||
3303 xstrcasecmp (p
, ".cmd") == 0));
3306 /* Emulate the Unix directory procedures opendir, closedir, and
3307 readdir. We rename them to sys_* names because some versions of
3308 MinGW startup code call opendir and readdir to glob wildcards, and
3309 the code that calls them doesn't grok UTF-8 encoded file names we
3310 produce in dirent->d_name[]. */
3312 struct dirent dir_static
; /* simulated directory contents */
3313 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
3314 static int dir_is_fat
;
3315 static char dir_pathname
[MAX_UTF8_PATH
];
3316 static WIN32_FIND_DATAW dir_find_data_w
;
3317 static WIN32_FIND_DATAA dir_find_data_a
;
3318 #define DIR_FIND_DATA_W 1
3319 #define DIR_FIND_DATA_A 2
3320 static int last_dir_find_data
= -1;
3322 /* Support shares on a network resource as subdirectories of a read-only
3324 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3325 static HANDLE
open_unc_volume (const char *);
3326 static void *read_unc_volume (HANDLE
, wchar_t *, char *, int);
3327 static void close_unc_volume (HANDLE
);
3330 sys_opendir (const char *filename
)
3334 /* Opening is done by FindFirstFile. However, a read is inherent to
3335 this operation, so we defer the open until read time. */
3337 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3339 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3342 /* Note: We don't support traversal of UNC volumes via symlinks.
3343 Doing so would mean punishing 99.99% of use cases by resolving
3344 all the possible symlinks in FILENAME, recursively. */
3345 if (is_unc_volume (filename
))
3347 wnet_enum_handle
= open_unc_volume (filename
);
3348 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
3352 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
3359 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAX_UTF8_PATH
- 1);
3360 dir_pathname
[MAX_UTF8_PATH
- 1] = '\0';
3361 /* Note: We don't support symlinks to file names on FAT volumes.
3362 Doing so would mean punishing 99.99% of use cases by resolving
3363 all the possible symlinks in FILENAME, recursively. */
3364 dir_is_fat
= is_fat_volume (filename
, NULL
);
3370 sys_closedir (DIR *dirp
)
3372 /* If we have a find-handle open, close it. */
3373 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
3375 FindClose (dir_find_handle
);
3376 dir_find_handle
= INVALID_HANDLE_VALUE
;
3378 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3380 close_unc_volume (wnet_enum_handle
);
3381 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
3383 xfree ((char *) dirp
);
3387 sys_readdir (DIR *dirp
)
3389 int downcase
= !NILP (Vw32_downcase_file_names
);
3391 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
3393 if (!read_unc_volume (wnet_enum_handle
,
3394 dir_find_data_w
.cFileName
,
3395 dir_find_data_a
.cFileName
,
3399 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
3400 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3402 char filename
[MAX_UTF8_PATH
];
3404 bool last_slash
= true;
3406 /* Note: We don't need to worry about dir_pathname being longer
3407 than MAX_UTF8_PATH, as sys_opendir already took care of that
3408 when it called map_w32_filename: that function will put a "?"
3409 in its return value in that case, thus failing all the calls
3411 strcpy (filename
, dir_pathname
);
3412 ln
= strlen (filename
);
3413 if (!IS_DIRECTORY_SEP (filename
[ln
- 1]))
3416 /* Note: No need to resolve symlinks in FILENAME, because
3417 FindFirst opens the directory that is the target of a
3419 if (w32_unicode_filenames
)
3421 wchar_t fnw
[MAX_PATH
+ 2];
3423 filename_to_utf16 (filename
, fnw
);
3425 wcscat (fnw
, L
"\\");
3427 dir_find_handle
= FindFirstFileW (fnw
, &dir_find_data_w
);
3431 char fna
[MAX_PATH
+ 2];
3433 filename_to_ansi (filename
, fna
);
3437 /* If FILENAME is not representable by the current ANSI
3438 codepage, we don't want FindFirstFileA to interpret the
3439 '?' characters as a wildcard. */
3440 if (_mbspbrk (fna
, "?"))
3441 dir_find_handle
= INVALID_HANDLE_VALUE
;
3443 dir_find_handle
= FindFirstFileA (fna
, &dir_find_data_a
);
3446 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3448 /* Any changes in the value of errno here should be in sync
3449 with what directory_files_internal does when it calls
3451 switch (GetLastError ())
3453 /* Windows uses this value when FindFirstFile finds no
3454 files that match the wildcard. This is not supposed
3455 to happen, since our wildcard is "*", but just in
3456 case, if there's some weird empty directory with not
3457 even "." and ".." entries... */
3458 case ERROR_FILE_NOT_FOUND
:
3463 case ERROR_ACCESS_DENIED
:
3464 case ERROR_NETWORK_ACCESS_DENIED
:
3467 case ERROR_PATH_NOT_FOUND
:
3468 case ERROR_INVALID_DRIVE
:
3469 case ERROR_NOT_READY
:
3470 case ERROR_BAD_NETPATH
:
3471 case ERROR_BAD_NET_NAME
:
3478 else if (w32_unicode_filenames
)
3480 if (!FindNextFileW (dir_find_handle
, &dir_find_data_w
))
3488 if (!FindNextFileA (dir_find_handle
, &dir_find_data_a
))
3495 /* Emacs never uses this value, so don't bother making it match
3496 value returned by stat(). */
3497 dir_static
.d_ino
= 1;
3499 if (w32_unicode_filenames
)
3501 if (downcase
|| dir_is_fat
)
3503 wchar_t tem
[MAX_PATH
];
3505 wcscpy (tem
, dir_find_data_w
.cFileName
);
3507 filename_from_utf16 (tem
, dir_static
.d_name
);
3510 filename_from_utf16 (dir_find_data_w
.cFileName
, dir_static
.d_name
);
3511 last_dir_find_data
= DIR_FIND_DATA_W
;
3517 /* If the file name in cFileName[] includes `?' characters, it
3518 means the original file name used characters that cannot be
3519 represented by the current ANSI codepage. To avoid total
3520 lossage, retrieve the short 8+3 alias of the long file
3522 if (_mbspbrk (dir_find_data_a
.cFileName
, "?"))
3524 strcpy (tem
, dir_find_data_a
.cAlternateFileName
);
3525 /* 8+3 aliases are returned in all caps, which could break
3526 various alists that look at filenames' extensions. */
3529 else if (downcase
|| dir_is_fat
)
3530 strcpy (tem
, dir_find_data_a
.cFileName
);
3532 filename_from_ansi (dir_find_data_a
.cFileName
, dir_static
.d_name
);
3533 if (downcase
|| dir_is_fat
)
3536 filename_from_ansi (tem
, dir_static
.d_name
);
3538 last_dir_find_data
= DIR_FIND_DATA_A
;
3541 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3542 dir_static
.d_reclen
= sizeof (struct dirent
) - MAX_UTF8_PATH
+ 3 +
3543 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
3549 open_unc_volume (const char *path
)
3551 const char *fn
= map_w32_filename (path
, NULL
);
3555 if (w32_unicode_filenames
)
3558 wchar_t fnw
[MAX_PATH
];
3560 nrw
.dwScope
= RESOURCE_GLOBALNET
;
3561 nrw
.dwType
= RESOURCETYPE_DISK
;
3562 nrw
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3563 nrw
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3564 nrw
.lpLocalName
= NULL
;
3565 filename_to_utf16 (fn
, fnw
);
3566 nrw
.lpRemoteName
= fnw
;
3567 nrw
.lpComment
= NULL
;
3568 nrw
.lpProvider
= NULL
;
3570 result
= WNetOpenEnumW (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3571 RESOURCEUSAGE_CONNECTABLE
, &nrw
, &henum
);
3578 nra
.dwScope
= RESOURCE_GLOBALNET
;
3579 nra
.dwType
= RESOURCETYPE_DISK
;
3580 nra
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3581 nra
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3582 nra
.lpLocalName
= NULL
;
3583 filename_to_ansi (fn
, fna
);
3584 nra
.lpRemoteName
= fna
;
3585 nra
.lpComment
= NULL
;
3586 nra
.lpProvider
= NULL
;
3588 result
= WNetOpenEnumA (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3589 RESOURCEUSAGE_CONNECTABLE
, &nra
, &henum
);
3591 if (result
== NO_ERROR
)
3595 /* Make sure directory_files_internal reports a sensible error. */
3597 return INVALID_HANDLE_VALUE
;
3602 read_unc_volume (HANDLE henum
, wchar_t *fname_w
, char *fname_a
, int size
)
3607 DWORD bufsize
= 512;
3611 if (w32_unicode_filenames
)
3616 buffer
= alloca (bufsize
);
3617 result
= WNetEnumResourceW (henum
, &count
, buffer
, &bufsize
);
3618 if (result
!= NO_ERROR
)
3620 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3621 ptrw
= ((LPNETRESOURCEW
) buffer
)->lpRemoteName
;
3623 while (*ptrw
&& *ptrw
!= L
'/' && *ptrw
!= L
'\\') ptrw
++;
3625 wcsncpy (fname_w
, ptrw
, size
);
3630 int dbcs_p
= max_filename_mbslen () > 1;
3633 buffer
= alloca (bufsize
);
3634 result
= WNetEnumResourceA (henum
, &count
, buffer
, &bufsize
);
3635 if (result
!= NO_ERROR
)
3637 ptra
= ((LPNETRESOURCEA
) buffer
)->lpRemoteName
;
3640 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
)) ptra
++;
3643 while (*ptra
&& !IS_DIRECTORY_SEP (*ptra
))
3644 ptra
= CharNextExA (file_name_codepage
, ptra
, 0);
3647 strncpy (fname_a
, ptra
, size
);
3655 close_unc_volume (HANDLE henum
)
3657 if (henum
!= INVALID_HANDLE_VALUE
)
3658 WNetCloseEnum (henum
);
3662 unc_volume_file_attributes (const char *path
)
3667 henum
= open_unc_volume (path
);
3668 if (henum
== INVALID_HANDLE_VALUE
)
3671 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3673 close_unc_volume (henum
);
3678 /* Ensure a network connection is authenticated. */
3680 logon_network_drive (const char *path
)
3682 char share
[MAX_UTF8_PATH
];
3689 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3690 drvtype
= DRIVE_REMOTE
;
3691 else if (path
[0] == '\0' || path
[1] != ':')
3692 drvtype
= GetDriveType (NULL
);
3699 drvtype
= GetDriveType (drive
);
3702 /* Only logon to networked drives. */
3703 if (drvtype
!= DRIVE_REMOTE
)
3707 strncpy (share
, path
, MAX_UTF8_PATH
);
3708 /* Truncate to just server and share name. */
3709 for (p
= share
+ 2; *p
&& p
< share
+ MAX_UTF8_PATH
; p
++)
3711 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3718 if (w32_unicode_filenames
)
3720 NETRESOURCEW resourcew
;
3721 wchar_t share_w
[MAX_PATH
];
3723 resourcew
.dwScope
= RESOURCE_GLOBALNET
;
3724 resourcew
.dwType
= RESOURCETYPE_DISK
;
3725 resourcew
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3726 resourcew
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3727 resourcew
.lpLocalName
= NULL
;
3728 filename_to_utf16 (share
, share_w
);
3729 resourcew
.lpRemoteName
= share_w
;
3730 resourcew
.lpProvider
= NULL
;
3732 val
= WNetAddConnection2W (&resourcew
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3736 NETRESOURCEA resourcea
;
3737 char share_a
[MAX_PATH
];
3739 resourcea
.dwScope
= RESOURCE_GLOBALNET
;
3740 resourcea
.dwType
= RESOURCETYPE_DISK
;
3741 resourcea
.dwDisplayType
= RESOURCEDISPLAYTYPE_SHARE
;
3742 resourcea
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3743 resourcea
.lpLocalName
= NULL
;
3744 filename_to_ansi (share
, share_a
);
3745 resourcea
.lpRemoteName
= share_a
;
3746 resourcea
.lpProvider
= NULL
;
3748 val
= WNetAddConnection2A (&resourcea
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3754 case ERROR_ALREADY_ASSIGNED
:
3756 case ERROR_ACCESS_DENIED
:
3757 case ERROR_LOGON_FAILURE
:
3763 case ERROR_BAD_NET_NAME
:
3764 case ERROR_NO_NET_OR_BAD_PATH
:
3765 case ERROR_NO_NETWORK
:
3766 case ERROR_CANCELLED
:
3773 /* Emulate faccessat(2). */
3775 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3779 if (dirfd
!= AT_FDCWD
3780 && !(IS_DIRECTORY_SEP (path
[0])
3781 || IS_DEVICE_SEP (path
[1])))
3787 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3788 newer versions blow up when passed D_OK. */
3789 path
= map_w32_filename (path
, NULL
);
3790 /* If the last element of PATH is a symlink, we need to resolve it
3791 to get the attributes of its target file. Note: any symlinks in
3792 PATH elements other than the last one are transparently resolved
3793 by GetFileAttributes below. */
3794 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3795 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3796 path
= chase_symlinks (path
);
3798 if (w32_unicode_filenames
)
3800 wchar_t path_w
[MAX_PATH
];
3802 filename_to_utf16 (path
, path_w
);
3803 attributes
= GetFileAttributesW (path_w
);
3807 char path_a
[MAX_PATH
];
3809 filename_to_ansi (path
, path_a
);
3810 attributes
= GetFileAttributesA (path_a
);
3813 if (attributes
== -1)
3815 DWORD w32err
= GetLastError ();
3819 case ERROR_INVALID_NAME
:
3820 case ERROR_BAD_PATHNAME
:
3821 if (is_unc_volume (path
))
3823 attributes
= unc_volume_file_attributes (path
);
3824 if (attributes
== -1)
3832 case ERROR_FILE_NOT_FOUND
:
3833 case ERROR_BAD_NETPATH
:
3844 if ((mode
& X_OK
) != 0
3845 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3850 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3855 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3863 /* A special test for DIRNAME being a directory accessible by the
3864 current user. This is needed because the security permissions in
3865 directory's ACLs are not visible in the Posix-style mode bits
3866 returned by 'stat' and in attributes returned by GetFileAttributes.
3867 So a directory would seem like it's readable by the current user,
3868 but will in fact error out with EACCES when they actually try. */
3870 w32_accessible_directory_p (const char *dirname
, ptrdiff_t dirlen
)
3872 char pattern
[MAX_UTF8_PATH
];
3873 bool last_slash
= dirlen
> 0 && IS_DIRECTORY_SEP (dirname
[dirlen
- 1]);
3876 /* Network volumes need a different reading method. */
3877 if (is_unc_volume (dirname
))
3879 void *read_result
= NULL
;
3880 wchar_t fnw
[MAX_PATH
];
3883 dh
= open_unc_volume (dirname
);
3884 if (dh
!= INVALID_HANDLE_VALUE
)
3886 read_result
= read_unc_volume (dh
, fnw
, fna
, MAX_PATH
);
3887 close_unc_volume (dh
);
3889 /* Treat empty volumes as accessible. */
3890 return read_result
!= NULL
|| GetLastError () == ERROR_NO_MORE_ITEMS
;
3893 /* Note: map_w32_filename makes sure DIRNAME is not longer than
3895 strcpy (pattern
, map_w32_filename (dirname
, NULL
));
3897 /* Note: No need to resolve symlinks in FILENAME, because FindFirst
3898 opens the directory that is the target of a symlink. */
3899 if (w32_unicode_filenames
)
3901 wchar_t pat_w
[MAX_PATH
+ 2];
3902 WIN32_FIND_DATAW dfd_w
;
3904 filename_to_utf16 (pattern
, pat_w
);
3906 wcscat (pat_w
, L
"\\");
3907 wcscat (pat_w
, L
"*");
3908 dh
= FindFirstFileW (pat_w
, &dfd_w
);
3912 char pat_a
[MAX_PATH
+ 2];
3913 WIN32_FIND_DATAA dfd_a
;
3915 filename_to_ansi (pattern
, pat_a
);
3917 strcpy (pat_a
, "\\");
3918 strcat (pat_a
, "*");
3919 /* In case DIRNAME cannot be expressed in characters from the
3920 current ANSI codepage. */
3921 if (_mbspbrk (pat_a
, "?"))
3922 dh
= INVALID_HANDLE_VALUE
;
3924 dh
= FindFirstFileA (pat_a
, &dfd_a
);
3927 if (dh
== INVALID_HANDLE_VALUE
)
3933 /* A version of 'access' to be used locally with file names in
3934 locale-specific encoding. Does not resolve symlinks and does not
3935 support file names on FAT12 and FAT16 volumes, but that's OK, since
3936 we only invoke this function for files inside the Emacs source or
3937 installation tree, on directories (so any symlinks should have the
3938 directory bit set), and on short file names such as "C:/.emacs". */
3940 sys_access (const char *fname
, int mode
)
3942 char fname_copy
[MAX_PATH
], *p
;
3945 strcpy (fname_copy
, fname
);
3946 /* Do the equivalent of unixtodos_filename. */
3947 for (p
= fname_copy
; *p
; p
= CharNext (p
))
3951 if ((attributes
= GetFileAttributesA (fname_copy
)) == -1)
3953 DWORD w32err
= GetLastError ();
3957 case ERROR_INVALID_NAME
:
3958 case ERROR_BAD_PATHNAME
:
3959 case ERROR_FILE_NOT_FOUND
:
3960 case ERROR_BAD_NETPATH
:
3969 if ((mode
& X_OK
) != 0
3970 && !(is_exec (fname_copy
)
3971 || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3976 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3981 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3989 /* Shadow some MSVC runtime functions to map requests for long filenames
3990 to reasonable short names if necessary. This was originally added to
3991 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3995 sys_chdir (const char * path
)
3997 path
= map_w32_filename (path
, NULL
);
3998 if (w32_unicode_filenames
)
4000 wchar_t newdir_w
[MAX_PATH
];
4002 if (filename_to_utf16 (path
, newdir_w
) == 0)
4003 return _wchdir (newdir_w
);
4008 char newdir_a
[MAX_PATH
];
4010 if (filename_to_ansi (path
, newdir_a
) == 0)
4011 return _chdir (newdir_a
);
4017 sys_chmod (const char * path
, int mode
)
4019 path
= chase_symlinks (map_w32_filename (path
, NULL
));
4020 if (w32_unicode_filenames
)
4022 wchar_t path_w
[MAX_PATH
];
4024 filename_to_utf16 (path
, path_w
);
4025 return _wchmod (path_w
, mode
);
4029 char path_a
[MAX_PATH
];
4031 filename_to_ansi (path
, path_a
);
4032 return _chmod (path_a
, mode
);
4037 sys_creat (const char * path
, int mode
)
4039 path
= map_w32_filename (path
, NULL
);
4040 if (w32_unicode_filenames
)
4042 wchar_t path_w
[MAX_PATH
];
4044 filename_to_utf16 (path
, path_w
);
4045 return _wcreat (path_w
, mode
);
4049 char path_a
[MAX_PATH
];
4051 filename_to_ansi (path
, path_a
);
4052 return _creat (path_a
, mode
);
4057 sys_fopen (const char * path
, const char * mode
)
4061 const char * mode_save
= mode
;
4063 /* Force all file handles to be non-inheritable. This is necessary to
4064 ensure child processes don't unwittingly inherit handles that might
4065 prevent future file access. */
4069 else if (mode
[0] == 'w' || mode
[0] == 'a')
4070 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
4074 /* Only do simplistic option parsing. */
4078 oflag
&= ~(O_RDONLY
| O_WRONLY
);
4081 else if (mode
[0] == 'b')
4086 else if (mode
[0] == 't')
4093 path
= map_w32_filename (path
, NULL
);
4094 if (w32_unicode_filenames
)
4096 wchar_t path_w
[MAX_PATH
];
4098 filename_to_utf16 (path
, path_w
);
4099 fd
= _wopen (path_w
, oflag
| _O_NOINHERIT
, 0644);
4103 char path_a
[MAX_PATH
];
4105 filename_to_ansi (path
, path_a
);
4106 fd
= _open (path_a
, oflag
| _O_NOINHERIT
, 0644);
4111 return _fdopen (fd
, mode_save
);
4114 /* This only works on NTFS volumes, but is useful to have. */
4116 sys_link (const char * old
, const char * new)
4120 char oldname
[MAX_UTF8_PATH
], newname
[MAX_UTF8_PATH
];
4121 wchar_t oldname_w
[MAX_PATH
];
4122 char oldname_a
[MAX_PATH
];
4124 if (old
== NULL
|| new == NULL
)
4130 strcpy (oldname
, map_w32_filename (old
, NULL
));
4131 strcpy (newname
, map_w32_filename (new, NULL
));
4133 if (w32_unicode_filenames
)
4135 filename_to_utf16 (oldname
, oldname_w
);
4136 fileh
= CreateFileW (oldname_w
, 0, 0, NULL
, OPEN_EXISTING
,
4137 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4141 filename_to_ansi (oldname
, oldname_a
);
4142 fileh
= CreateFileA (oldname_a
, 0, 0, NULL
, OPEN_EXISTING
,
4143 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4145 if (fileh
!= INVALID_HANDLE_VALUE
)
4149 /* Confusingly, the "alternate" stream name field does not apply
4150 when restoring a hard link, and instead contains the actual
4151 stream data for the link (ie. the name of the link to create).
4152 The WIN32_STREAM_ID structure before the cStreamName field is
4153 the stream header, which is then immediately followed by the
4157 WIN32_STREAM_ID wid
;
4158 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
4161 /* We used to pass MB_PRECOMPOSED as the 2nd arg here, but MSDN
4162 indicates that flag is unsupported for CP_UTF8, and OTOH says
4163 it is the default anyway. */
4164 wlen
= pMultiByteToWideChar (CP_UTF8
, 0, newname
, -1,
4165 data
.wid
.cStreamName
, MAX_PATH
);
4168 LPVOID context
= NULL
;
4171 data
.wid
.dwStreamId
= BACKUP_LINK
;
4172 data
.wid
.dwStreamAttributes
= 0;
4173 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
4174 data
.wid
.Size
.HighPart
= 0;
4175 data
.wid
.dwStreamNameSize
= 0;
4177 if (BackupWrite (fileh
, (LPBYTE
)&data
,
4178 offsetof (WIN32_STREAM_ID
, cStreamName
)
4179 + data
.wid
.Size
.LowPart
,
4180 &wbytes
, FALSE
, FALSE
, &context
)
4181 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
4188 DWORD err
= GetLastError ();
4193 case ERROR_ACCESS_DENIED
:
4194 /* This is what happens when OLDNAME is a directory,
4195 since Windows doesn't support hard links to
4196 directories. Posix says to set errno to EPERM in
4198 if (w32_unicode_filenames
)
4199 attributes
= GetFileAttributesW (oldname_w
);
4201 attributes
= GetFileAttributesA (oldname_a
);
4202 if (attributes
!= -1
4203 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0)
4205 else if (attributes
== -1
4206 && is_unc_volume (oldname
)
4207 && unc_volume_file_attributes (oldname
) != -1)
4212 case ERROR_TOO_MANY_LINKS
:
4215 case ERROR_NOT_SAME_DEVICE
:
4225 CloseHandle (fileh
);
4234 sys_mkdir (const char * path
)
4236 path
= map_w32_filename (path
, NULL
);
4238 if (w32_unicode_filenames
)
4240 wchar_t path_w
[MAX_PATH
];
4242 filename_to_utf16 (path
, path_w
);
4243 return _wmkdir (path_w
);
4247 char path_a
[MAX_PATH
];
4249 filename_to_ansi (path
, path_a
);
4250 return _mkdir (path_a
);
4255 sys_open (const char * path
, int oflag
, int mode
)
4257 const char* mpath
= map_w32_filename (path
, NULL
);
4260 if (w32_unicode_filenames
)
4262 wchar_t mpath_w
[MAX_PATH
];
4264 filename_to_utf16 (mpath
, mpath_w
);
4265 /* If possible, try to open file without _O_CREAT, to be able to
4266 write to existing hidden and system files. Force all file
4267 handles to be non-inheritable. */
4268 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4269 res
= _wopen (mpath_w
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4271 res
= _wopen (mpath_w
, oflag
| _O_NOINHERIT
, mode
);
4275 char mpath_a
[MAX_PATH
];
4277 filename_to_ansi (mpath
, mpath_a
);
4278 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
4279 res
= _open (mpath_a
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
4281 res
= _open (mpath_a
, oflag
| _O_NOINHERIT
, mode
);
4287 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
4290 Standard algorithm for generating a temporary file name seems to be
4291 use pid or tid with a letter on the front (in place of the 6 X's)
4292 and cycle through the letters to find a unique name. We extend
4293 that to allow any reasonable character as the first of the 6 X's,
4294 so that the number of simultaneously used temporary files will be
4298 mkostemp (char * template, int flags
)
4302 unsigned uid
= GetCurrentThreadId ();
4303 int save_errno
= errno
;
4304 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
4307 if (template == NULL
)
4310 p
= template + strlen (template);
4312 /* replace up to the last 5 X's with uid in decimal */
4313 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
4315 p
[0] = '0' + uid
% 10;
4319 if (i
< 0 && p
[0] == 'X')
4324 p
[0] = first_char
[i
];
4325 if ((fd
= sys_open (template,
4326 flags
| _O_CREAT
| _O_EXCL
| _O_RDWR
,
4327 S_IRUSR
| S_IWUSR
)) >= 0
4335 while (++i
< sizeof (first_char
));
4338 /* Template is badly formed or else we can't generate a unique name. */
4343 fchmod (int fd
, mode_t mode
)
4349 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
4352 char temp
[MAX_UTF8_PATH
], temp_a
[MAX_PATH
];;
4355 bool have_temp_a
= false;
4357 /* MoveFile on Windows 95 doesn't correctly change the short file name
4358 alias in a number of circumstances (it is not easy to predict when
4359 just by looking at oldname and newname, unfortunately). In these
4360 cases, renaming through a temporary name avoids the problem.
4362 A second problem on Windows 95 is that renaming through a temp name when
4363 newname is uppercase fails (the final long name ends up in
4364 lowercase, although the short alias might be uppercase) UNLESS the
4365 long temp name is not 8.3.
4367 So, on Windows 95 we always rename through a temp name, and we make sure
4368 the temp name has a long extension to ensure correct renaming. */
4370 strcpy (temp
, map_w32_filename (oldname
, NULL
));
4372 /* volume_info is set indirectly by map_w32_filename. */
4373 oldname_dev
= volume_info
.serialnum
;
4375 if (os_subtype
== OS_9X
)
4380 char oldname_a
[MAX_PATH
];
4382 oldname
= map_w32_filename (oldname
, NULL
);
4383 filename_to_ansi (oldname
, oldname_a
);
4384 filename_to_ansi (temp
, temp_a
);
4385 if ((o
= strrchr (oldname_a
, '\\')))
4388 o
= (char *) oldname_a
;
4390 if ((p
= strrchr (temp_a
, '\\')))
4397 /* Force temp name to require a manufactured 8.3 alias - this
4398 seems to make the second rename work properly. */
4399 sprintf (p
, "_.%s.%u", o
, i
);
4401 result
= rename (oldname_a
, temp_a
);
4403 /* This loop must surely terminate! */
4404 while (result
< 0 && errno
== EEXIST
);
4410 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
4411 (at least if it is a file; don't do this for directories).
4413 Since we mustn't do this if we are just changing the case of the
4414 file name (we would end up deleting the file we are trying to
4415 rename!), we let rename detect if the destination file already
4416 exists - that way we avoid the possible pitfalls of trying to
4417 determine ourselves whether two names really refer to the same
4418 file, which is not always possible in the general case. (Consider
4419 all the permutations of shared or subst'd drives, etc.) */
4421 newname
= map_w32_filename (newname
, NULL
);
4423 /* volume_info is set indirectly by map_w32_filename. */
4424 newname_dev
= volume_info
.serialnum
;
4426 if (w32_unicode_filenames
)
4428 wchar_t temp_w
[MAX_PATH
], newname_w
[MAX_PATH
];
4430 filename_to_utf16 (temp
, temp_w
);
4431 filename_to_utf16 (newname
, newname_w
);
4432 result
= _wrename (temp_w
, newname_w
);
4433 if (result
< 0 && force
)
4435 DWORD w32err
= GetLastError ();
4438 && newname_dev
!= oldname_dev
)
4440 /* The implementation of `rename' on Windows does not return
4441 errno = EXDEV when you are moving a directory to a
4442 different storage device (ex. logical disk). It returns
4443 EACCES instead. So here we handle such situations and
4447 if ((attributes
= GetFileAttributesW (temp_w
)) != -1
4448 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4451 else if (errno
== EEXIST
)
4453 if (_wchmod (newname_w
, 0666) != 0)
4455 if (_wunlink (newname_w
) != 0)
4457 result
= _wrename (temp_w
, newname_w
);
4459 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4460 && is_symlink (temp
))
4462 /* This is Windows prohibiting the user from creating a
4463 symlink in another place, since that requires
4471 char newname_a
[MAX_PATH
];
4474 filename_to_ansi (temp
, temp_a
);
4475 filename_to_ansi (newname
, newname_a
);
4476 result
= rename (temp_a
, newname_a
);
4477 if (result
< 0 && force
)
4479 DWORD w32err
= GetLastError ();
4482 && newname_dev
!= oldname_dev
)
4486 if ((attributes
= GetFileAttributesA (temp_a
)) != -1
4487 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
4490 else if (errno
== EEXIST
)
4492 if (_chmod (newname_a
, 0666) != 0)
4494 if (_unlink (newname_a
) != 0)
4496 result
= rename (temp_a
, newname_a
);
4498 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
4499 && is_symlink (temp
))
4508 sys_rename (char const *old
, char const *new)
4510 return sys_rename_replace (old
, new, TRUE
);
4514 sys_rmdir (const char * path
)
4516 path
= map_w32_filename (path
, NULL
);
4518 if (w32_unicode_filenames
)
4520 wchar_t path_w
[MAX_PATH
];
4522 filename_to_utf16 (path
, path_w
);
4523 return _wrmdir (path_w
);
4527 char path_a
[MAX_PATH
];
4529 filename_to_ansi (path
, path_a
);
4530 return _rmdir (path_a
);
4535 sys_unlink (const char * path
)
4537 path
= map_w32_filename (path
, NULL
);
4539 if (w32_unicode_filenames
)
4541 wchar_t path_w
[MAX_PATH
];
4543 filename_to_utf16 (path
, path_w
);
4544 /* On Unix, unlink works without write permission. */
4545 _wchmod (path_w
, 0666);
4546 return _wunlink (path_w
);
4550 char path_a
[MAX_PATH
];
4552 filename_to_ansi (path
, path_a
);
4553 _chmod (path_a
, 0666);
4554 return _unlink (path_a
);
4558 static FILETIME utc_base_ft
;
4559 static ULONGLONG utc_base
; /* In 100ns units */
4560 static int init
= 0;
4562 #define FILETIME_TO_U64(result, ft) \
4564 ULARGE_INTEGER uiTemp; \
4565 uiTemp.LowPart = (ft).dwLowDateTime; \
4566 uiTemp.HighPart = (ft).dwHighDateTime; \
4567 result = uiTemp.QuadPart; \
4571 initialize_utc_base (void)
4573 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
4582 st
.wMilliseconds
= 0;
4584 SystemTimeToFileTime (&st
, &utc_base_ft
);
4585 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
4589 convert_time (FILETIME ft
)
4595 initialize_utc_base ();
4599 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
4602 FILETIME_TO_U64 (tmp
, ft
);
4603 return (time_t) ((tmp
- utc_base
) / 10000000L);
4607 convert_from_time_t (time_t time
, FILETIME
* pft
)
4613 initialize_utc_base ();
4617 /* time in 100ns units since 1-Jan-1601 */
4618 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
4619 pft
->dwHighDateTime
= tmp
.HighPart
;
4620 pft
->dwLowDateTime
= tmp
.LowPart
;
4623 static PSECURITY_DESCRIPTOR
4624 get_file_security_desc_by_handle (HANDLE h
)
4626 PSECURITY_DESCRIPTOR psd
= NULL
;
4628 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4629 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4631 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
4632 NULL
, NULL
, NULL
, NULL
, &psd
);
4633 if (err
!= ERROR_SUCCESS
)
4639 static PSECURITY_DESCRIPTOR
4640 get_file_security_desc_by_name (const char *fname
)
4642 PSECURITY_DESCRIPTOR psd
= NULL
;
4644 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
4645 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
4647 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
4649 err
= GetLastError ();
4650 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
4654 psd
= xmalloc (sd_len
);
4655 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4667 unsigned n_subauthorities
;
4669 /* Use the last sub-authority value of the RID, the relative
4670 portion of the SID, as user/group ID. */
4671 n_subauthorities
= *get_sid_sub_authority_count (sid
);
4672 if (n_subauthorities
< 1)
4673 return 0; /* the "World" RID */
4674 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
4677 /* Caching SID and account values for faster lokup. */
4681 struct w32_id
*next
;
4683 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
4686 static struct w32_id
*w32_idlist
;
4689 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
4691 struct w32_id
*tail
, *found
;
4693 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
4695 if (equal_sid ((PSID
)tail
->sid
, sid
))
4704 strcpy (name
, found
->name
);
4712 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
4715 struct w32_id
*new_entry
;
4717 /* We don't want to leave behind stale cache from when Emacs was
4721 sid_len
= get_length_sid (sid
);
4722 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
4725 new_entry
->rid
= id
;
4726 strcpy (new_entry
->name
, name
);
4727 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
4728 new_entry
->next
= w32_idlist
;
4729 w32_idlist
= new_entry
;
4738 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
4742 SID_NAME_USE ignore
;
4744 DWORD name_len
= sizeof (name
);
4746 DWORD domain_len
= sizeof (domain
);
4751 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
4752 else if (what
== GID
)
4753 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
4757 if (!result
|| !is_valid_sid (sid
))
4759 else if (!w32_cached_id (sid
, id
, nm
))
4761 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
4762 domain
, &domain_len
, &ignore
)
4763 || name_len
> UNLEN
+1)
4767 *id
= get_rid (sid
);
4769 w32_add_to_cache (sid
, *id
, name
);
4776 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
4778 int dflt_usr
= 0, dflt_grp
= 0;
4787 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
4789 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
4792 /* Consider files to belong to current user/group, if we cannot get
4793 more accurate information. */
4796 st
->st_uid
= dflt_passwd
.pw_uid
;
4797 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
4801 st
->st_gid
= dflt_passwd
.pw_gid
;
4802 strcpy (st
->st_gname
, dflt_group
.gr_name
);
4806 /* Return non-zero if NAME is a potentially slow filesystem. */
4808 is_slow_fs (const char *name
)
4813 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
4814 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
4815 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
4816 devtype
= GetDriveType (NULL
); /* use root of current drive */
4819 /* GetDriveType needs the root directory of the drive. */
4820 strncpy (drive_root
, name
, 2);
4821 drive_root
[2] = '\\';
4822 drive_root
[3] = '\0';
4823 devtype
= GetDriveType (drive_root
);
4825 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
4828 /* If this is non-zero, the caller wants accurate information about
4829 file's owner and group, which could be expensive to get. dired.c
4830 uses this flag when needed for the job at hand. */
4831 int w32_stat_get_owner_group
;
4833 /* MSVC stat function can't cope with UNC names and has other bugs, so
4834 replace it with our own. This also allows us to calculate consistent
4835 inode values and owner/group without hacks in the main Emacs code,
4836 and support file names encoded in UTF-8. */
4839 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
4841 char *name
, *save_name
, *r
;
4842 WIN32_FIND_DATAW wfd_w
;
4843 WIN32_FIND_DATAA wfd_a
;
4845 unsigned __int64 fake_inode
= 0;
4848 int rootdir
= FALSE
;
4849 PSECURITY_DESCRIPTOR psd
= NULL
;
4850 int is_a_symlink
= 0;
4851 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
4852 DWORD access_rights
= 0;
4853 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
4854 FILETIME ctime
, atime
, wtime
;
4855 wchar_t name_w
[MAX_PATH
];
4856 char name_a
[MAX_PATH
];
4858 if (path
== NULL
|| buf
== NULL
)
4864 save_name
= name
= (char *) map_w32_filename (path
, &path
);
4865 /* Must be valid filename, no wild cards or other invalid
4867 if (strpbrk (name
, "*?|<>\""))
4873 len
= strlen (name
);
4874 /* Allocate 1 extra byte so that we could append a slash to a root
4875 directory, down below. */
4876 name
= strcpy (alloca (len
+ 2), name
);
4878 /* Avoid a somewhat costly call to is_symlink if the filesystem
4879 doesn't support symlinks. */
4880 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4881 is_a_symlink
= is_symlink (name
);
4883 /* Plan A: Open the file and get all the necessary information via
4884 the resulting handle. This solves several issues in one blow:
4886 . retrieves attributes for the target of a symlink, if needed
4887 . gets attributes of root directories and symlinks pointing to
4888 root directories, thus avoiding the need for special-casing
4889 these and detecting them by examining the file-name format
4890 . retrieves more accurate attributes (e.g., non-zero size for
4891 some directories, esp. directories that are junction points)
4892 . correctly resolves "c:/..", "/.." and similar file names
4893 . avoids run-time penalties for 99% of use cases
4895 Plan A is always tried first, unless the user asked not to (but
4896 if the file is a symlink and we need to follow links, we try Plan
4897 A even if the user asked not to).
4899 If Plan A fails, we go to Plan B (below), where various
4900 potentially expensive techniques must be used to handle "special"
4901 files such as UNC volumes etc. */
4902 if (!(NILP (Vw32_get_true_file_attributes
)
4903 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
4904 /* Following symlinks requires getting the info by handle. */
4905 || (is_a_symlink
&& follow_symlinks
))
4907 BY_HANDLE_FILE_INFORMATION info
;
4909 if (is_a_symlink
&& !follow_symlinks
)
4910 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
4911 /* READ_CONTROL access rights are required to get security info
4912 by handle. But if the OS doesn't support security in the
4913 first place, we don't need to try. */
4914 if (is_windows_9x () != TRUE
)
4915 access_rights
|= READ_CONTROL
;
4917 if (w32_unicode_filenames
)
4919 filename_to_utf16 (name
, name_w
);
4920 fh
= CreateFileW (name_w
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4922 /* If CreateFile fails with READ_CONTROL, try again with
4923 zero as access rights. */
4924 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4925 fh
= CreateFileW (name_w
, 0, 0, NULL
, OPEN_EXISTING
,
4930 filename_to_ansi (name
, name_a
);
4931 fh
= CreateFileA (name_a
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4933 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4934 fh
= CreateFileA (name_a
, 0, 0, NULL
, OPEN_EXISTING
,
4937 if (fh
== INVALID_HANDLE_VALUE
)
4938 goto no_true_file_attributes
;
4940 /* This is more accurate in terms of getting the correct number
4941 of links, but is quite slow (it is noticeable when Emacs is
4942 making a list of file name completions). */
4943 if (GetFileInformationByHandle (fh
, &info
))
4945 nlinks
= info
.nNumberOfLinks
;
4946 /* Might as well use file index to fake inode values, but this
4947 is not guaranteed to be unique unless we keep a handle open
4948 all the time (even then there are situations where it is
4949 not unique). Reputedly, there are at most 48 bits of info
4950 (on NTFS, presumably less on FAT). */
4951 fake_inode
= info
.nFileIndexHigh
;
4953 fake_inode
+= info
.nFileIndexLow
;
4954 serialnum
= info
.dwVolumeSerialNumber
;
4955 fs_high
= info
.nFileSizeHigh
;
4956 fs_low
= info
.nFileSizeLow
;
4957 ctime
= info
.ftCreationTime
;
4958 atime
= info
.ftLastAccessTime
;
4959 wtime
= info
.ftLastWriteTime
;
4960 fattrs
= info
.dwFileAttributes
;
4964 /* We don't go to Plan B here, because it's not clear that
4965 it's a good idea. The only known use case where
4966 CreateFile succeeds, but GetFileInformationByHandle fails
4967 (with ERROR_INVALID_FUNCTION) is for character devices
4968 such as NUL, PRN, etc. For these, switching to Plan B is
4969 a net loss, because we lose the character device
4970 attribute returned by GetFileType below (FindFirstFile
4971 doesn't set that bit in the attributes), and the other
4972 fields don't make sense for character devices anyway.
4973 Emacs doesn't really care for non-file entities in the
4974 context of l?stat, so neither do we. */
4976 /* w32err is assigned so one could put a breakpoint here and
4977 examine its value, when GetFileInformationByHandle
4979 DWORD w32err
= GetLastError ();
4983 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4989 /* Test for a symlink before testing for a directory, since
4990 symlinks to directories have the directory bit set, but we
4991 don't want them to appear as directories. */
4992 if (is_a_symlink
&& !follow_symlinks
)
4993 buf
->st_mode
= S_IFLNK
;
4994 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4995 buf
->st_mode
= S_IFDIR
;
4998 DWORD ftype
= GetFileType (fh
);
5002 case FILE_TYPE_DISK
:
5003 buf
->st_mode
= S_IFREG
;
5005 case FILE_TYPE_PIPE
:
5006 buf
->st_mode
= S_IFIFO
;
5008 case FILE_TYPE_CHAR
:
5009 case FILE_TYPE_UNKNOWN
:
5011 buf
->st_mode
= S_IFCHR
;
5014 /* We produce the fallback owner and group data, based on the
5015 current user that runs Emacs, in the following cases:
5017 . caller didn't request owner and group info
5018 . this is Windows 9X
5019 . getting security by handle failed, and we need to produce
5020 information for the target of a symlink (this is better
5021 than producing a potentially misleading info about the
5024 If getting security by handle fails, and we don't need to
5025 resolve symlinks, we try getting security by name. */
5026 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
5027 get_file_owner_and_group (NULL
, buf
);
5030 psd
= get_file_security_desc_by_handle (fh
);
5033 get_file_owner_and_group (psd
, buf
);
5036 else if (!(is_a_symlink
&& follow_symlinks
))
5038 psd
= get_file_security_desc_by_name (name
);
5039 get_file_owner_and_group (psd
, buf
);
5043 get_file_owner_and_group (NULL
, buf
);
5049 no_true_file_attributes
:
5050 /* Plan B: Either getting a handle on the file failed, or the
5051 caller explicitly asked us to not bother making this
5052 information more accurate.
5054 Implementation note: In Plan B, we never bother to resolve
5055 symlinks, even if we got here because we tried Plan A and
5056 failed. That's because, even if the caller asked for extra
5057 precision by setting Vw32_get_true_file_attributes to t,
5058 resolving symlinks requires acquiring a file handle to the
5059 symlink, which we already know will fail. And if the user
5060 did not ask for extra precision, resolving symlinks will fly
5061 in the face of that request, since the user then wants the
5062 lightweight version of the code. */
5063 rootdir
= (path
>= save_name
+ len
- 1
5064 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
5066 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
5067 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
5068 if (IS_DIRECTORY_SEP (r
[0])
5069 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
5072 /* Note: If NAME is a symlink to the root of a UNC volume
5073 (i.e. "\\SERVER"), we will not detect that here, and we will
5074 return data about the symlink as result of FindFirst below.
5075 This is unfortunate, but that marginal use case does not
5076 justify a call to chase_symlinks which would impose a penalty
5077 on all the other use cases. (We get here for symlinks to
5078 roots of UNC volumes because CreateFile above fails for them,
5079 unlike with symlinks to root directories X:\ of drives.) */
5080 if (is_unc_volume (name
))
5082 fattrs
= unc_volume_file_attributes (name
);
5086 ctime
= atime
= wtime
= utc_base_ft
;
5090 /* Make sure root directories end in a slash. */
5091 if (!IS_DIRECTORY_SEP (name
[len
-1]))
5092 strcpy (name
+ len
, "\\");
5093 if (GetDriveType (name
) < 2)
5099 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
5100 ctime
= atime
= wtime
= utc_base_ft
;
5106 /* Make sure non-root directories do NOT end in a slash,
5107 otherwise FindFirstFile might fail. */
5108 if (IS_DIRECTORY_SEP (name
[len
-1]))
5111 /* (This is hacky, but helps when doing file completions on
5112 network drives.) Optimize by using information available from
5113 active readdir if possible. */
5114 len
= strlen (dir_pathname
);
5115 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
5117 if (dir_find_handle
!= INVALID_HANDLE_VALUE
5118 && last_dir_find_data
!= -1
5119 && !(is_a_symlink
&& follow_symlinks
)
5120 /* The 2 file-name comparisons below support only ASCII
5121 characters, and will lose (compare not equal) when
5122 the file names include non-ASCII characters that are
5123 the same but for the case. However, doing this
5124 properly involves: (a) converting both file names to
5125 UTF-16, (b) lower-casing both names using CharLowerW,
5126 and (c) comparing the results; this would be quite a
5127 bit slower, whereas Plan B is for users who want
5128 lightweight albeit inaccurate version of 'stat'. */
5129 && c_strncasecmp (save_name
, dir_pathname
, len
) == 0
5130 && IS_DIRECTORY_SEP (name
[len
])
5131 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
5133 have_wfd
= last_dir_find_data
;
5134 /* This was the last entry returned by readdir. */
5135 if (last_dir_find_data
== DIR_FIND_DATA_W
)
5136 wfd_w
= dir_find_data_w
;
5138 wfd_a
= dir_find_data_a
;
5142 logon_network_drive (name
);
5144 if (w32_unicode_filenames
)
5146 filename_to_utf16 (name
, name_w
);
5147 fh
= FindFirstFileW (name_w
, &wfd_w
);
5148 have_wfd
= DIR_FIND_DATA_W
;
5152 filename_to_ansi (name
, name_a
);
5153 /* If NAME includes characters not representable by
5154 the current ANSI codepage, filename_to_ansi
5155 usually replaces them with a '?'. We don't want
5156 to let FindFirstFileA interpret those as wildcards,
5157 and "succeed", returning us data from some random
5158 file in the same directory. */
5159 if (_mbspbrk (name_a
, "?"))
5160 fh
= INVALID_HANDLE_VALUE
;
5162 fh
= FindFirstFileA (name_a
, &wfd_a
);
5163 have_wfd
= DIR_FIND_DATA_A
;
5165 if (fh
== INVALID_HANDLE_VALUE
)
5172 /* Note: if NAME is a symlink, the information we get from
5173 FindFirstFile is for the symlink, not its target. */
5174 if (have_wfd
== DIR_FIND_DATA_W
)
5176 fattrs
= wfd_w
.dwFileAttributes
;
5177 ctime
= wfd_w
.ftCreationTime
;
5178 atime
= wfd_w
.ftLastAccessTime
;
5179 wtime
= wfd_w
.ftLastWriteTime
;
5180 fs_high
= wfd_w
.nFileSizeHigh
;
5181 fs_low
= wfd_w
.nFileSizeLow
;
5185 fattrs
= wfd_a
.dwFileAttributes
;
5186 ctime
= wfd_a
.ftCreationTime
;
5187 atime
= wfd_a
.ftLastAccessTime
;
5188 wtime
= wfd_a
.ftLastWriteTime
;
5189 fs_high
= wfd_a
.nFileSizeHigh
;
5190 fs_low
= wfd_a
.nFileSizeLow
;
5194 serialnum
= volume_info
.serialnum
;
5196 if (is_a_symlink
&& !follow_symlinks
)
5197 buf
->st_mode
= S_IFLNK
;
5198 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5199 buf
->st_mode
= S_IFDIR
;
5201 buf
->st_mode
= S_IFREG
;
5203 get_file_owner_and_group (NULL
, buf
);
5206 buf
->st_ino
= fake_inode
;
5208 buf
->st_dev
= serialnum
;
5209 buf
->st_rdev
= serialnum
;
5211 buf
->st_size
= fs_high
;
5212 buf
->st_size
<<= 32;
5213 buf
->st_size
+= fs_low
;
5214 buf
->st_nlink
= nlinks
;
5216 /* Convert timestamps to Unix format. */
5217 buf
->st_mtime
= convert_time (wtime
);
5218 buf
->st_atime
= convert_time (atime
);
5219 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5220 buf
->st_ctime
= convert_time (ctime
);
5221 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5223 /* determine rwx permissions */
5224 if (is_a_symlink
&& !follow_symlinks
)
5225 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
5228 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
5229 permission
= S_IREAD
;
5231 permission
= S_IREAD
| S_IWRITE
;
5233 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
5234 permission
|= S_IEXEC
;
5235 else if (is_exec (name
))
5236 permission
|= S_IEXEC
;
5239 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5245 stat (const char * path
, struct stat
* buf
)
5247 return stat_worker (path
, buf
, 1);
5251 lstat (const char * path
, struct stat
* buf
)
5253 return stat_worker (path
, buf
, 0);
5257 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
5259 /* Rely on a hack: an open directory is modeled as file descriptor 0.
5260 This is good enough for the current usage in Emacs, but is fragile.
5262 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
5263 Gnulib does this and can serve as a model. */
5264 char fullname
[MAX_UTF8_PATH
];
5268 char lastc
= dir_pathname
[strlen (dir_pathname
) - 1];
5270 if (_snprintf (fullname
, sizeof fullname
, "%s%s%s",
5271 dir_pathname
, IS_DIRECTORY_SEP (lastc
) ? "" : "/", name
)
5274 errno
= ENAMETOOLONG
;
5280 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
5283 /* Provide fstat and utime as well as stat for consistent handling of
5286 fstat (int desc
, struct stat
* buf
)
5288 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
5289 BY_HANDLE_FILE_INFORMATION info
;
5290 unsigned __int64 fake_inode
;
5293 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
5295 case FILE_TYPE_DISK
:
5296 buf
->st_mode
= S_IFREG
;
5297 if (!GetFileInformationByHandle (fh
, &info
))
5303 case FILE_TYPE_PIPE
:
5304 buf
->st_mode
= S_IFIFO
;
5306 case FILE_TYPE_CHAR
:
5307 case FILE_TYPE_UNKNOWN
:
5309 buf
->st_mode
= S_IFCHR
;
5311 memset (&info
, 0, sizeof (info
));
5312 info
.dwFileAttributes
= 0;
5313 info
.ftCreationTime
= utc_base_ft
;
5314 info
.ftLastAccessTime
= utc_base_ft
;
5315 info
.ftLastWriteTime
= utc_base_ft
;
5318 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5319 buf
->st_mode
= S_IFDIR
;
5321 buf
->st_nlink
= info
.nNumberOfLinks
;
5322 /* Might as well use file index to fake inode values, but this
5323 is not guaranteed to be unique unless we keep a handle open
5324 all the time (even then there are situations where it is
5325 not unique). Reputedly, there are at most 48 bits of info
5326 (on NTFS, presumably less on FAT). */
5327 fake_inode
= info
.nFileIndexHigh
;
5329 fake_inode
+= info
.nFileIndexLow
;
5331 /* MSVC defines _ino_t to be short; other libc's might not. */
5332 if (sizeof (buf
->st_ino
) == 2)
5333 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
5335 buf
->st_ino
= fake_inode
;
5337 /* If the caller so requested, get the true file owner and group.
5338 Otherwise, consider the file to belong to the current user. */
5339 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
5340 get_file_owner_and_group (NULL
, buf
);
5343 PSECURITY_DESCRIPTOR psd
= NULL
;
5345 psd
= get_file_security_desc_by_handle (fh
);
5348 get_file_owner_and_group (psd
, buf
);
5352 get_file_owner_and_group (NULL
, buf
);
5355 buf
->st_dev
= info
.dwVolumeSerialNumber
;
5356 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
5358 buf
->st_size
= info
.nFileSizeHigh
;
5359 buf
->st_size
<<= 32;
5360 buf
->st_size
+= info
.nFileSizeLow
;
5362 /* Convert timestamps to Unix format. */
5363 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
5364 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
5365 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
5366 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
5367 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
5369 /* determine rwx permissions */
5370 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
5371 permission
= S_IREAD
;
5373 permission
= S_IREAD
| S_IWRITE
;
5375 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
5376 permission
|= S_IEXEC
;
5379 #if 0 /* no way of knowing the filename */
5380 char * p
= strrchr (name
, '.');
5382 (xstrcasecmp (p
, ".exe") == 0 ||
5383 xstrcasecmp (p
, ".com") == 0 ||
5384 xstrcasecmp (p
, ".bat") == 0 ||
5385 xstrcasecmp (p
, ".cmd") == 0))
5386 permission
|= S_IEXEC
;
5390 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
5395 /* A version of 'utime' which handles directories as well as
5399 utime (const char *name
, struct utimbuf
*times
)
5401 struct utimbuf deftime
;
5408 deftime
.modtime
= deftime
.actime
= time (NULL
);
5412 if (w32_unicode_filenames
)
5414 wchar_t name_utf16
[MAX_PATH
];
5416 if (filename_to_utf16 (name
, name_utf16
) != 0)
5417 return -1; /* errno set by filename_to_utf16 */
5419 /* Need write access to set times. */
5420 fh
= CreateFileW (name_utf16
, FILE_WRITE_ATTRIBUTES
,
5421 /* If NAME specifies a directory, FILE_SHARE_DELETE
5422 allows other processes to delete files inside it,
5423 while we have the directory open. */
5424 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5425 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5429 char name_ansi
[MAX_PATH
];
5431 if (filename_to_ansi (name
, name_ansi
) != 0)
5432 return -1; /* errno set by filename_to_ansi */
5434 fh
= CreateFileA (name_ansi
, FILE_WRITE_ATTRIBUTES
,
5435 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
5436 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
5438 if (fh
!= INVALID_HANDLE_VALUE
)
5440 convert_from_time_t (times
->actime
, &atime
);
5441 convert_from_time_t (times
->modtime
, &mtime
);
5442 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
5452 DWORD err
= GetLastError ();
5456 case ERROR_FILE_NOT_FOUND
:
5457 case ERROR_PATH_NOT_FOUND
:
5458 case ERROR_INVALID_DRIVE
:
5459 case ERROR_BAD_NETPATH
:
5460 case ERROR_DEV_NOT_EXIST
:
5461 /* ERROR_INVALID_NAME is the error CreateFile sets when the
5462 file name includes ?s, i.e. translation to ANSI failed. */
5463 case ERROR_INVALID_NAME
:
5466 case ERROR_TOO_MANY_OPEN_FILES
:
5469 case ERROR_ACCESS_DENIED
:
5470 case ERROR_SHARING_VIOLATION
:
5483 sys_umask (int mode
)
5485 static int current_mask
;
5486 int retval
, arg
= 0;
5488 /* The only bit we really support is the write bit. Files are
5489 always readable on MS-Windows, and the execute bit does not exist
5491 /* FIXME: if the GROUP and OTHER bits are reset, we should use ACLs
5492 to prevent access by other users on NTFS. */
5493 if ((mode
& S_IWRITE
) != 0)
5496 retval
= _umask (arg
);
5497 /* Merge into the return value the bits they've set the last time,
5498 which msvcrt.dll ignores and never returns. Emacs insists on its
5499 notion of mask being identical to what we return. */
5500 retval
|= (current_mask
& ~S_IWRITE
);
5501 current_mask
= mode
;
5507 /* Symlink-related functions. */
5508 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
5509 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
5513 symlink (char const *filename
, char const *linkname
)
5515 char linkfn
[MAX_UTF8_PATH
], *tgtfn
;
5517 int dir_access
, filename_ends_in_slash
;
5519 /* Diagnostics follows Posix as much as possible. */
5520 if (filename
== NULL
|| linkname
== NULL
)
5530 if (strlen (filename
) > MAX_UTF8_PATH
|| strlen (linkname
) > MAX_UTF8_PATH
)
5532 errno
= ENAMETOOLONG
;
5536 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
5537 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
5543 /* Note: since empty FILENAME was already rejected, we can safely
5544 refer to FILENAME[1]. */
5545 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
5547 /* Non-absolute FILENAME is understood as being relative to
5548 LINKNAME's directory. We need to prepend that directory to
5549 FILENAME to get correct results from faccessat below, since
5550 otherwise it will interpret FILENAME relative to the
5551 directory where the Emacs process runs. Note that
5552 make-symbolic-link always makes sure LINKNAME is a fully
5553 expanded file name. */
5554 char tem
[MAX_UTF8_PATH
];
5555 char *p
= linkfn
+ strlen (linkfn
);
5557 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
5560 strncpy (tem
, linkfn
, p
- linkfn
);
5561 strcpy (tem
+ (p
- linkfn
), filename
);
5562 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
5565 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
5567 /* Since Windows distinguishes between symlinks to directories and
5568 to files, we provide a kludgy feature: if FILENAME doesn't
5569 exist, but ends in a slash, we create a symlink to directory. If
5570 FILENAME exists and is a directory, we always create a symlink to
5572 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
5573 if (dir_access
== 0 || filename_ends_in_slash
)
5574 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
5576 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
5577 if (filename_ends_in_slash
)
5578 tgtfn
[strlen (tgtfn
) - 1] = '\0';
5581 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
5583 /* ENOSYS is set by create_symbolic_link, when it detects that
5584 the OS doesn't support the CreateSymbolicLink API. */
5585 if (errno
!= ENOSYS
)
5587 DWORD w32err
= GetLastError ();
5591 /* ERROR_SUCCESS is sometimes returned when LINKFN and
5592 TGTFN point to the same file name, go figure. */
5594 case ERROR_FILE_EXISTS
:
5597 case ERROR_ACCESS_DENIED
:
5600 case ERROR_FILE_NOT_FOUND
:
5601 case ERROR_PATH_NOT_FOUND
:
5602 case ERROR_BAD_NETPATH
:
5603 case ERROR_INVALID_REPARSE_DATA
:
5606 case ERROR_DIRECTORY
:
5609 case ERROR_PRIVILEGE_NOT_HELD
:
5610 case ERROR_NOT_ALL_ASSIGNED
:
5613 case ERROR_DISK_FULL
:
5626 /* A quick inexpensive test of whether FILENAME identifies a file that
5627 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
5628 must already be in the normalized form returned by
5631 Note: for repeated operations on many files, it is best to test
5632 whether the underlying volume actually supports symlinks, by
5633 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
5634 avoid the call to this function if it doesn't. That's because the
5635 call to GetFileAttributes takes a non-negligible time, especially
5636 on non-local or removable filesystems. See stat_worker for an
5637 example of how to do that. */
5639 is_symlink (const char *filename
)
5642 wchar_t filename_w
[MAX_PATH
];
5643 char filename_a
[MAX_PATH
];
5644 WIN32_FIND_DATAW wfdw
;
5645 WIN32_FIND_DATAA wfda
;
5647 int attrs_mean_symlink
;
5649 if (w32_unicode_filenames
)
5651 filename_to_utf16 (filename
, filename_w
);
5652 attrs
= GetFileAttributesW (filename_w
);
5656 filename_to_ansi (filename
, filename_a
);
5657 attrs
= GetFileAttributesA (filename_a
);
5661 DWORD w32err
= GetLastError ();
5665 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
5667 case ERROR_ACCESS_DENIED
:
5670 case ERROR_FILE_NOT_FOUND
:
5671 case ERROR_PATH_NOT_FOUND
:
5678 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
5680 logon_network_drive (filename
);
5681 if (w32_unicode_filenames
)
5683 fh
= FindFirstFileW (filename_w
, &wfdw
);
5684 attrs_mean_symlink
=
5685 (wfdw
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5686 && (wfdw
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5688 else if (_mbspbrk (filename_a
, "?"))
5690 /* filename_to_ansi failed to convert the file name. */
5696 fh
= FindFirstFileA (filename_a
, &wfda
);
5697 attrs_mean_symlink
=
5698 (wfda
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
5699 && (wfda
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
5701 if (fh
== INVALID_HANDLE_VALUE
)
5704 return attrs_mean_symlink
;
5707 /* If NAME identifies a symbolic link, copy into BUF the file name of
5708 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
5709 null-terminate the target name, even if it fits. Return the number
5710 of bytes copied, or -1 if NAME is not a symlink or any error was
5711 encountered while resolving it. The file name copied into BUF is
5712 encoded in the current ANSI codepage. */
5714 readlink (const char *name
, char *buf
, size_t buf_size
)
5717 TOKEN_PRIVILEGES privs
;
5718 int restore_privs
= 0;
5721 char resolved
[MAX_UTF8_PATH
];
5734 path
= map_w32_filename (name
, NULL
);
5736 if (strlen (path
) > MAX_UTF8_PATH
)
5738 errno
= ENAMETOOLONG
;
5743 if (is_windows_9x () == TRUE
5744 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
5745 || !is_symlink (path
))
5748 errno
= EINVAL
; /* not a symlink */
5752 /* Done with simple tests, now we're in for some _real_ work. */
5753 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
5755 /* Implementation note: From here and onward, don't return early,
5756 since that will fail to restore the original set of privileges of
5757 the calling thread. */
5759 retval
= -1; /* not too optimistic, are we? */
5761 /* Note: In the next call to CreateFile, we use zero as the 2nd
5762 argument because, when the symlink is a hidden/system file,
5763 e.g. 'C:\Users\All Users', GENERIC_READ fails with
5764 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
5765 and directory symlinks. */
5766 if (w32_unicode_filenames
)
5768 wchar_t path_w
[MAX_PATH
];
5770 filename_to_utf16 (path
, path_w
);
5771 sh
= CreateFileW (path_w
, 0, 0, NULL
, OPEN_EXISTING
,
5772 FILE_FLAG_OPEN_REPARSE_POINT
5773 | FILE_FLAG_BACKUP_SEMANTICS
,
5778 char path_a
[MAX_PATH
];
5780 filename_to_ansi (path
, path_a
);
5781 sh
= CreateFileA (path_a
, 0, 0, NULL
, OPEN_EXISTING
,
5782 FILE_FLAG_OPEN_REPARSE_POINT
5783 | FILE_FLAG_BACKUP_SEMANTICS
,
5786 if (sh
!= INVALID_HANDLE_VALUE
)
5788 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
5789 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
5792 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
5793 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
5796 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
5800 /* Copy the link target name, in wide characters, from
5801 reparse_data, then convert it to multibyte encoding in
5802 the current locale's codepage. */
5806 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
5808 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
5809 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
5810 size_t size_to_copy
= buf_size
;
5812 /* According to MSDN, PrintNameLength does not include the
5813 terminating null character. */
5814 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
5815 memcpy (lwname
, lwname_src
, lwname_len
);
5816 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
5817 filename_from_utf16 (lwname
, resolved
);
5818 dostounix_filename (resolved
);
5819 lname_size
= strlen (resolved
) + 1;
5820 if (lname_size
<= buf_size
)
5821 size_to_copy
= lname_size
;
5822 strncpy (buf
, resolved
, size_to_copy
);
5824 retval
= size_to_copy
;
5830 /* CreateFile failed. */
5831 DWORD w32err2
= GetLastError ();
5835 case ERROR_FILE_NOT_FOUND
:
5836 case ERROR_PATH_NOT_FOUND
:
5839 case ERROR_ACCESS_DENIED
:
5840 case ERROR_TOO_MANY_OPEN_FILES
:
5850 restore_privilege (&privs
);
5858 readlinkat (int fd
, char const *name
, char *buffer
,
5861 /* Rely on a hack: an open directory is modeled as file descriptor 0,
5862 as in fstatat. FIXME: Add proper support for readlinkat. */
5863 char fullname
[MAX_UTF8_PATH
];
5867 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
5870 errno
= ENAMETOOLONG
;
5876 return readlink (name
, buffer
, buffer_size
);
5879 /* If FILE is a symlink, return its target (stored in a static
5880 buffer); otherwise return FILE.
5882 This function repeatedly resolves symlinks in the last component of
5883 a chain of symlink file names, as in foo -> bar -> baz -> ...,
5884 until it arrives at a file whose last component is not a symlink,
5885 or some error occurs. It returns the target of the last
5886 successfully resolved symlink in the chain. If it succeeds to
5887 resolve even a single symlink, the value returned is an absolute
5888 file name with backslashes (result of GetFullPathName). By
5889 contrast, if the original FILE is returned, it is unaltered.
5891 Note: This function can set errno even if it succeeds.
5893 Implementation note: we only resolve the last portion ("basename")
5894 of the argument FILE and of each following file in the chain,
5895 disregarding any possible symlinks in its leading directories.
5896 This is because Windows system calls and library functions
5897 transparently resolve symlinks in leading directories and return
5898 correct information, as long as the basename is not a symlink. */
5900 chase_symlinks (const char *file
)
5902 static char target
[MAX_UTF8_PATH
];
5903 char link
[MAX_UTF8_PATH
];
5904 wchar_t target_w
[MAX_PATH
], link_w
[MAX_PATH
];
5905 char target_a
[MAX_PATH
], link_a
[MAX_PATH
];
5906 ssize_t res
, link_len
;
5909 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
5910 return (char *)file
;
5912 if (w32_unicode_filenames
)
5914 wchar_t file_w
[MAX_PATH
];
5916 filename_to_utf16 (file
, file_w
);
5917 if (GetFullPathNameW (file_w
, MAX_PATH
, link_w
, NULL
) == 0)
5918 return (char *)file
;
5919 filename_from_utf16 (link_w
, link
);
5923 char file_a
[MAX_PATH
];
5925 filename_to_ansi (file
, file_a
);
5926 if (GetFullPathNameA (file_a
, MAX_PATH
, link_a
, NULL
) == 0)
5927 return (char *)file
;
5928 filename_from_ansi (link_a
, link
);
5930 link_len
= strlen (link
);
5935 /* Remove trailing slashes, as we want to resolve the last
5936 non-trivial part of the link name. */
5937 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
5938 link
[link_len
--] = '\0';
5940 res
= readlink (link
, target
, MAX_UTF8_PATH
);
5944 if (!(IS_DEVICE_SEP (target
[1])
5945 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
5947 /* Target is relative. Append it to the directory part of
5948 the symlink, then copy the result back to target. */
5949 char *p
= link
+ link_len
;
5951 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
5954 strcpy (target
, link
);
5956 /* Resolve any "." and ".." to get a fully-qualified file name
5958 if (w32_unicode_filenames
)
5960 filename_to_utf16 (target
, target_w
);
5961 link_len
= GetFullPathNameW (target_w
, MAX_PATH
, link_w
, NULL
);
5963 filename_from_utf16 (link_w
, link
);
5967 filename_to_ansi (target
, target_a
);
5968 link_len
= GetFullPathNameA (target_a
, MAX_PATH
, link_a
, NULL
);
5970 filename_from_ansi (link_a
, link
);
5972 link_len
= strlen (link
);
5974 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
5976 if (loop_count
> 100)
5979 if (target
[0] == '\0') /* not a single call to readlink succeeded */
5980 return (char *)file
;
5985 /* Posix ACL emulation. */
5988 acl_valid (acl_t acl
)
5990 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
5994 acl_to_text (acl_t acl
, ssize_t
*size
)
5997 SECURITY_INFORMATION flags
=
5998 OWNER_SECURITY_INFORMATION
|
5999 GROUP_SECURITY_INFORMATION
|
6000 DACL_SECURITY_INFORMATION
;
6001 char *retval
= NULL
;
6007 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
6010 /* We don't want to mix heaps, so we duplicate the string in our
6011 heap and free the one allocated by the API. */
6012 retval
= xstrdup (str_acl
);
6015 LocalFree (str_acl
);
6017 else if (errno
!= ENOTSUP
)
6024 acl_from_text (const char *acl_str
)
6026 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
6032 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
6035 retval
= xmalloc (sd_size
);
6036 memcpy (retval
, psd
, sd_size
);
6039 else if (errno
!= ENOTSUP
)
6046 acl_free (void *ptr
)
6053 acl_get_file (const char *fname
, acl_type_t type
)
6055 PSECURITY_DESCRIPTOR psd
= NULL
;
6056 const char *filename
;
6058 if (type
== ACL_TYPE_ACCESS
)
6061 SECURITY_INFORMATION si
=
6062 OWNER_SECURITY_INFORMATION
|
6063 GROUP_SECURITY_INFORMATION
|
6064 DACL_SECURITY_INFORMATION
;
6067 filename
= map_w32_filename (fname
, NULL
);
6068 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
6069 fname
= chase_symlinks (filename
);
6074 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
6075 && errno
!= ENOTSUP
)
6077 err
= GetLastError ();
6078 if (err
== ERROR_INSUFFICIENT_BUFFER
)
6080 psd
= xmalloc (sd_len
);
6081 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
6088 else if (err
== ERROR_FILE_NOT_FOUND
6089 || err
== ERROR_PATH_NOT_FOUND
6090 /* ERROR_INVALID_NAME is what we get if
6091 w32-unicode-filenames is nil and the file cannot
6092 be encoded in the current ANSI codepage. */
6093 || err
== ERROR_INVALID_NAME
)
6101 else if (type
!= ACL_TYPE_DEFAULT
)
6108 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
6110 TOKEN_PRIVILEGES old1
, old2
;
6112 int st
= 0, retval
= -1;
6113 SECURITY_INFORMATION flags
= 0;
6114 PSID psidOwner
, psidGroup
;
6119 const char *filename
;
6121 if (acl_valid (acl
) != 0
6122 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
6128 if (type
== ACL_TYPE_DEFAULT
)
6134 filename
= map_w32_filename (fname
, NULL
);
6135 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
6136 fname
= chase_symlinks (filename
);
6140 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psidOwner
,
6143 flags
|= OWNER_SECURITY_INFORMATION
;
6144 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psidGroup
,
6147 flags
|= GROUP_SECURITY_INFORMATION
;
6148 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
6151 flags
|= DACL_SECURITY_INFORMATION
;
6155 /* According to KB-245153, setting the owner will succeed if either:
6156 (1) the caller is the user who will be the new owner, and has the
6157 SE_TAKE_OWNERSHIP privilege, or
6158 (2) the caller has the SE_RESTORE privilege, in which case she can
6159 set any valid user or group as the owner
6161 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
6162 privileges, and disregard any failures in obtaining them. If
6163 these privileges cannot be obtained, and do not already exist in
6164 the calling thread's security token, this function could fail
6166 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
6168 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
6173 /* SetFileSecurity is deprecated by MS, and sometimes fails when
6174 DACL inheritance is involved, but it seems to preserve ownership
6175 better than SetNamedSecurityInfo, which is important e.g., in
6177 if (!set_file_security (fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
6179 err
= GetLastError ();
6181 if (errno
!= ENOTSUP
)
6182 err
= set_named_security_info (fname
, SE_FILE_OBJECT
, flags
,
6183 psidOwner
, psidGroup
, pacl
, NULL
);
6186 err
= ERROR_SUCCESS
;
6187 if (err
!= ERROR_SUCCESS
)
6189 if (errno
== ENOTSUP
)
6191 else if (err
== ERROR_INVALID_OWNER
6192 || err
== ERROR_NOT_ALL_ASSIGNED
6193 || err
== ERROR_ACCESS_DENIED
)
6195 /* Maybe the requested ACL and the one the file already has
6196 are identical, in which case we can silently ignore the
6197 failure. (And no, Windows doesn't.) */
6198 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
6203 char *acl_from
= acl_to_text (current_acl
, NULL
);
6204 char *acl_to
= acl_to_text (acl
, NULL
);
6206 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
6212 acl_free (acl_from
);
6215 acl_free (current_acl
);
6218 else if (err
== ERROR_FILE_NOT_FOUND
6219 || err
== ERROR_PATH_NOT_FOUND
6220 /* ERROR_INVALID_NAME is what we get if
6221 w32-unicode-filenames is nil and the file cannot be
6222 encoded in the current ANSI codepage. */
6223 || err
== ERROR_INVALID_NAME
)
6237 restore_privilege (&old2
);
6238 restore_privilege (&old1
);
6246 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
6247 have a fixed max size for file names, so we don't need the kind of
6248 alloc/malloc/realloc dance the gnulib version does. We also don't
6249 support FD-relative symlinks. */
6251 careadlinkat (int fd
, char const *filename
,
6252 char *buffer
, size_t buffer_size
,
6253 struct allocator
const *alloc
,
6254 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
6256 char linkname
[MAX_UTF8_PATH
];
6259 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
6263 char *retval
= buffer
;
6265 linkname
[link_size
++] = '\0';
6266 if (link_size
> buffer_size
)
6267 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
6269 memcpy (retval
, linkname
, link_size
);
6277 w32_copy_file (const char *from
, const char *to
,
6278 int keep_time
, int preserve_ownership
, int copy_acls
)
6282 wchar_t from_w
[MAX_PATH
], to_w
[MAX_PATH
];
6283 char from_a
[MAX_PATH
], to_a
[MAX_PATH
];
6285 /* We ignore preserve_ownership for now. */
6286 preserve_ownership
= preserve_ownership
;
6290 acl
= acl_get_file (from
, ACL_TYPE_ACCESS
);
6291 if (acl
== NULL
&& acl_errno_valid (errno
))
6294 if (w32_unicode_filenames
)
6296 filename_to_utf16 (from
, from_w
);
6297 filename_to_utf16 (to
, to_w
);
6298 copy_result
= CopyFileW (from_w
, to_w
, FALSE
);
6302 filename_to_ansi (from
, from_a
);
6303 filename_to_ansi (to
, to_a
);
6304 copy_result
= CopyFileA (from_a
, to_a
, FALSE
);
6308 /* CopyFile doesn't set errno when it fails. By far the most
6309 "popular" reason is that the target is read-only. */
6310 DWORD err
= GetLastError ();
6314 case ERROR_FILE_NOT_FOUND
:
6317 case ERROR_ACCESS_DENIED
:
6320 case ERROR_ENCRYPTION_FAILED
:
6332 /* CopyFile retains the timestamp by default. However, see
6333 "Community Additions" for CopyFile: it sounds like that is not
6334 entirely true. Testing on Windows XP confirms that modified time
6335 is copied, but creation and last-access times are not.
6337 else if (!keep_time
)
6339 struct timespec now
;
6342 if (w32_unicode_filenames
)
6344 /* Ensure file is writable while its times are set. */
6345 attributes
= GetFileAttributesW (to_w
);
6346 SetFileAttributesW (to_w
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6347 now
= current_timespec ();
6348 if (set_file_times (-1, to
, now
, now
))
6350 /* Restore original attributes. */
6351 SetFileAttributesW (to_w
, attributes
);
6356 /* Restore original attributes. */
6357 SetFileAttributesW (to_w
, attributes
);
6361 attributes
= GetFileAttributesA (to_a
);
6362 SetFileAttributesA (to_a
, attributes
& ~FILE_ATTRIBUTE_READONLY
);
6363 now
= current_timespec ();
6364 if (set_file_times (-1, to
, now
, now
))
6366 SetFileAttributesA (to_a
, attributes
);
6371 SetFileAttributesA (to_a
, attributes
);
6377 acl_set_file (to
, ACL_TYPE_ACCESS
, acl
) != 0;
6379 if (fail
&& acl_errno_valid (errno
))
6387 /* Support for browsing other processes and their attributes. See
6388 process.c for the Lisp bindings. */
6390 /* Helper wrapper functions. */
6392 static HANDLE WINAPI
6393 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
6395 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
6397 if (g_b_init_create_toolhelp32_snapshot
== 0)
6399 g_b_init_create_toolhelp32_snapshot
= 1;
6400 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
6401 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6402 "CreateToolhelp32Snapshot");
6404 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
6406 return INVALID_HANDLE_VALUE
;
6408 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
6412 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6414 static Process32First_Proc s_pfn_Process32_First
= NULL
;
6416 if (g_b_init_process32_first
== 0)
6418 g_b_init_process32_first
= 1;
6419 s_pfn_Process32_First
= (Process32First_Proc
)
6420 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6423 if (s_pfn_Process32_First
== NULL
)
6427 return (s_pfn_Process32_First (hSnapshot
, lppe
));
6431 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
6433 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
6435 if (g_b_init_process32_next
== 0)
6437 g_b_init_process32_next
= 1;
6438 s_pfn_Process32_Next
= (Process32Next_Proc
)
6439 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6442 if (s_pfn_Process32_Next
== NULL
)
6446 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
6450 open_thread_token (HANDLE ThreadHandle
,
6451 DWORD DesiredAccess
,
6453 PHANDLE TokenHandle
)
6455 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
6456 HMODULE hm_advapi32
= NULL
;
6457 if (is_windows_9x () == TRUE
)
6459 SetLastError (ERROR_NOT_SUPPORTED
);
6462 if (g_b_init_open_thread_token
== 0)
6464 g_b_init_open_thread_token
= 1;
6465 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6466 s_pfn_Open_Thread_Token
=
6467 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
6469 if (s_pfn_Open_Thread_Token
== NULL
)
6471 SetLastError (ERROR_NOT_SUPPORTED
);
6475 s_pfn_Open_Thread_Token (
6484 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
6486 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
6487 HMODULE hm_advapi32
= NULL
;
6488 if (is_windows_9x () == TRUE
)
6492 if (g_b_init_impersonate_self
== 0)
6494 g_b_init_impersonate_self
= 1;
6495 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6496 s_pfn_Impersonate_Self
=
6497 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
6499 if (s_pfn_Impersonate_Self
== NULL
)
6503 return s_pfn_Impersonate_Self (ImpersonationLevel
);
6507 revert_to_self (void)
6509 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
6510 HMODULE hm_advapi32
= NULL
;
6511 if (is_windows_9x () == TRUE
)
6515 if (g_b_init_revert_to_self
== 0)
6517 g_b_init_revert_to_self
= 1;
6518 hm_advapi32
= LoadLibrary ("Advapi32.dll");
6519 s_pfn_Revert_To_Self
=
6520 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
6522 if (s_pfn_Revert_To_Self
== NULL
)
6526 return s_pfn_Revert_To_Self ();
6530 get_process_memory_info (HANDLE h_proc
,
6531 PPROCESS_MEMORY_COUNTERS mem_counters
,
6534 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
6535 HMODULE hm_psapi
= NULL
;
6536 if (is_windows_9x () == TRUE
)
6540 if (g_b_init_get_process_memory_info
== 0)
6542 g_b_init_get_process_memory_info
= 1;
6543 hm_psapi
= LoadLibrary ("Psapi.dll");
6545 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
6546 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
6548 if (s_pfn_Get_Process_Memory_Info
== NULL
)
6552 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
6556 get_process_working_set_size (HANDLE h_proc
,
6560 static GetProcessWorkingSetSize_Proc
6561 s_pfn_Get_Process_Working_Set_Size
= NULL
;
6563 if (is_windows_9x () == TRUE
)
6567 if (g_b_init_get_process_working_set_size
== 0)
6569 g_b_init_get_process_working_set_size
= 1;
6570 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
6571 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6572 "GetProcessWorkingSetSize");
6574 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
6578 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
6582 global_memory_status (MEMORYSTATUS
*buf
)
6584 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
6586 if (is_windows_9x () == TRUE
)
6590 if (g_b_init_global_memory_status
== 0)
6592 g_b_init_global_memory_status
= 1;
6593 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
6594 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6595 "GlobalMemoryStatus");
6597 if (s_pfn_Global_Memory_Status
== NULL
)
6601 return s_pfn_Global_Memory_Status (buf
);
6605 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
6607 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
6609 if (is_windows_9x () == TRUE
)
6613 if (g_b_init_global_memory_status_ex
== 0)
6615 g_b_init_global_memory_status_ex
= 1;
6616 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
6617 GetProcAddress (GetModuleHandle ("kernel32.dll"),
6618 "GlobalMemoryStatusEx");
6620 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
6624 return s_pfn_Global_Memory_Status_Ex (buf
);
6628 list_system_processes (void)
6630 Lisp_Object proclist
= Qnil
;
6633 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6635 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6637 PROCESSENTRY32 proc_entry
;
6641 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
6642 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
6643 res
= process32_next (h_snapshot
, &proc_entry
))
6645 proc_id
= proc_entry
.th32ProcessID
;
6646 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
6649 CloseHandle (h_snapshot
);
6650 proclist
= Fnreverse (proclist
);
6657 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
6659 TOKEN_PRIVILEGES priv
;
6660 DWORD priv_size
= sizeof (priv
);
6661 DWORD opriv_size
= sizeof (*old_priv
);
6662 HANDLE h_token
= NULL
;
6663 HANDLE h_thread
= GetCurrentThread ();
6667 res
= open_thread_token (h_thread
,
6668 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6670 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
6672 if (impersonate_self (SecurityImpersonation
))
6673 res
= open_thread_token (h_thread
,
6674 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6679 priv
.PrivilegeCount
= 1;
6680 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
6681 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
6682 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
6683 old_priv
, &opriv_size
)
6684 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6688 CloseHandle (h_token
);
6694 restore_privilege (TOKEN_PRIVILEGES
*priv
)
6696 DWORD priv_size
= sizeof (*priv
);
6697 HANDLE h_token
= NULL
;
6700 if (open_thread_token (GetCurrentThread (),
6701 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
6704 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
6705 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
6709 CloseHandle (h_token
);
6715 ltime (ULONGLONG time_100ns
)
6717 ULONGLONG time_sec
= time_100ns
/ 10000000;
6718 int subsec
= time_100ns
% 10000000;
6719 return list4i (time_sec
>> 16, time_sec
& 0xffff,
6720 subsec
/ 10, subsec
% 10 * 100000);
6723 #define U64_TO_LISP_TIME(time) ltime (time)
6726 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
6727 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
6730 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
6731 ULONGLONG tem1
, tem2
, tem3
, tem
;
6734 || !get_process_times_fn
6735 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
6736 &ft_kernel
, &ft_user
))
6739 GetSystemTimeAsFileTime (&ft_current
);
6741 FILETIME_TO_U64 (tem1
, ft_kernel
);
6742 *stime
= U64_TO_LISP_TIME (tem1
);
6744 FILETIME_TO_U64 (tem2
, ft_user
);
6745 *utime
= U64_TO_LISP_TIME (tem2
);
6748 *ttime
= U64_TO_LISP_TIME (tem3
);
6750 FILETIME_TO_U64 (tem
, ft_creation
);
6751 /* Process no 4 (System) returns zero creation time. */
6754 *ctime
= U64_TO_LISP_TIME (tem
);
6758 FILETIME_TO_U64 (tem3
, ft_current
);
6759 tem
= (tem3
- utc_base
) - tem
;
6761 *etime
= U64_TO_LISP_TIME (tem
);
6765 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
6776 system_process_attributes (Lisp_Object pid
)
6778 Lisp_Object attrs
= Qnil
;
6779 Lisp_Object cmd_str
, decoded_cmd
, tem
;
6780 HANDLE h_snapshot
, h_proc
;
6783 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
6784 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
6785 DWORD glength
= sizeof (gname
);
6786 HANDLE token
= NULL
;
6787 SID_NAME_USE user_type
;
6788 unsigned char *buf
= NULL
;
6790 TOKEN_USER user_token
;
6791 TOKEN_PRIMARY_GROUP group_token
;
6794 PROCESS_MEMORY_COUNTERS mem
;
6795 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
6796 SIZE_T minrss
, maxrss
;
6798 MEMORY_STATUS_EX memstex
;
6799 double totphys
= 0.0;
6800 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
6802 BOOL result
= FALSE
;
6804 CHECK_NUMBER_OR_FLOAT (pid
);
6805 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
6807 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
6809 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
6814 pe
.dwSize
= sizeof (PROCESSENTRY32
);
6815 for (res
= process32_first (h_snapshot
, &pe
); res
;
6816 res
= process32_next (h_snapshot
, &pe
))
6818 if (proc_id
== pe
.th32ProcessID
)
6821 decoded_cmd
= build_string ("Idle");
6824 /* Decode the command name from locale-specific
6826 cmd_str
= build_unibyte_string (pe
.szExeFile
);
6829 code_convert_string_norecord (cmd_str
,
6830 Vlocale_coding_system
, 0);
6832 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
6833 attrs
= Fcons (Fcons (Qppid
,
6834 make_fixnum_or_float (pe
.th32ParentProcessID
)),
6836 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
6838 attrs
= Fcons (Fcons (Qthcount
,
6839 make_fixnum_or_float (pe
.cntThreads
)),
6846 CloseHandle (h_snapshot
);
6852 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6854 /* If we were denied a handle to the process, try again after
6855 enabling the SeDebugPrivilege in our process. */
6858 TOKEN_PRIVILEGES priv_current
;
6860 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
6862 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
6864 restore_privilege (&priv_current
);
6870 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
6873 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
6874 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6876 buf
= xmalloc (blen
);
6877 result
= get_token_information (token
, TokenUser
,
6878 (LPVOID
)buf
, blen
, &needed
);
6881 memcpy (&user_token
, buf
, sizeof (user_token
));
6882 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
6884 euid
= get_rid (user_token
.User
.Sid
);
6885 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
6890 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
6893 strcpy (uname
, "unknown");
6897 ulength
= strlen (uname
);
6903 /* Determine a reasonable euid and gid values. */
6904 if (xstrcasecmp ("administrator", uname
) == 0)
6906 euid
= 500; /* well-known Administrator uid */
6907 egid
= 513; /* well-known None gid */
6911 /* Get group id and name. */
6912 result
= get_token_information (token
, TokenPrimaryGroup
,
6913 (LPVOID
)buf
, blen
, &needed
);
6914 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
6916 buf
= xrealloc (buf
, blen
= needed
);
6917 result
= get_token_information (token
, TokenPrimaryGroup
,
6918 (LPVOID
)buf
, blen
, &needed
);
6922 memcpy (&group_token
, buf
, sizeof (group_token
));
6923 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
6925 egid
= get_rid (group_token
.PrimaryGroup
);
6926 dlength
= sizeof (domain
);
6928 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
6929 gname
, &glength
, NULL
, &dlength
,
6932 w32_add_to_cache (group_token
.PrimaryGroup
,
6936 strcpy (gname
, "None");
6940 glength
= strlen (gname
);
6948 if (!is_windows_9x ())
6950 /* We couldn't open the process token, presumably because of
6951 insufficient access rights. Assume this process is run
6953 strcpy (uname
, "SYSTEM");
6954 strcpy (gname
, "None");
6955 euid
= 18; /* SYSTEM */
6956 egid
= 513; /* None */
6957 glength
= strlen (gname
);
6958 ulength
= strlen (uname
);
6960 /* If we are running under Windows 9X, where security calls are
6961 not supported, we assume all processes are run by the current
6963 else if (GetUserName (uname
, &ulength
))
6965 if (xstrcasecmp ("administrator", uname
) == 0)
6970 strcpy (gname
, "None");
6971 glength
= strlen (gname
);
6972 ulength
= strlen (uname
);
6978 strcpy (uname
, "administrator");
6979 ulength
= strlen (uname
);
6980 strcpy (gname
, "None");
6981 glength
= strlen (gname
);
6984 CloseHandle (token
);
6987 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
6988 tem
= make_unibyte_string (uname
, ulength
);
6989 attrs
= Fcons (Fcons (Quser
,
6990 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6992 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
6993 tem
= make_unibyte_string (gname
, glength
);
6994 attrs
= Fcons (Fcons (Qgroup
,
6995 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
6998 if (global_memory_status_ex (&memstex
))
6999 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
7000 totphys
= memstex
.ullTotalPhys
/ 1024.0;
7002 /* Visual Studio 6 cannot convert an unsigned __int64 type to
7003 double, so we need to do this for it... */
7005 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
7006 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
7007 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
7009 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
7011 #endif /* __GNUC__ || _MSC_VER >= 1300 */
7012 else if (global_memory_status (&memst
))
7013 totphys
= memst
.dwTotalPhys
/ 1024.0;
7016 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
7019 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
7021 attrs
= Fcons (Fcons (Qmajflt
,
7022 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
7024 attrs
= Fcons (Fcons (Qvsize
,
7025 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
7027 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
7029 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
7032 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
7034 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
7036 attrs
= Fcons (Fcons (Qmajflt
,
7037 make_fixnum_or_float (mem
.PageFaultCount
)),
7039 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
7041 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
7044 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
7046 DWORD rss
= maxrss
/ 1024;
7048 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
7050 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
7053 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
7055 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
7056 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
7057 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
7058 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
7059 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
7060 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
7063 /* FIXME: Retrieve command line by walking the PEB of the process. */
7066 CloseHandle (h_proc
);
7071 w32_memory_info (unsigned long long *totalram
, unsigned long long *freeram
,
7072 unsigned long long *totalswap
, unsigned long long *freeswap
)
7075 MEMORY_STATUS_EX memstex
;
7077 /* Use GlobalMemoryStatusEx if available, as it can report more than
7079 if (global_memory_status_ex (&memstex
))
7081 *totalram
= memstex
.ullTotalPhys
;
7082 *freeram
= memstex
.ullAvailPhys
;
7083 *totalswap
= memstex
.ullTotalPageFile
;
7084 *freeswap
= memstex
.ullAvailPageFile
;
7087 else if (global_memory_status (&memst
))
7089 *totalram
= memst
.dwTotalPhys
;
7090 *freeram
= memst
.dwAvailPhys
;
7091 *totalswap
= memst
.dwTotalPageFile
;
7092 *freeswap
= memst
.dwAvailPageFile
;
7100 /* Wrappers for winsock functions to map between our file descriptors
7101 and winsock's handles; also set h_errno for convenience.
7103 To allow Emacs to run on systems which don't have winsock support
7104 installed, we dynamically link to winsock on startup if present, and
7105 otherwise provide the minimum necessary functionality
7106 (eg. gethostname). */
7108 /* function pointers for relevant socket functions */
7109 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
7110 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
7111 int (PASCAL
*pfn_WSAGetLastError
) (void);
7112 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
7113 int (PASCAL
*pfn_WSAEnumNetworkEvents
) (SOCKET s
, HANDLE hEventObject
,
7114 WSANETWORKEVENTS
*NetworkEvents
);
7116 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
7117 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
7118 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
7119 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
7120 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
7121 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
7122 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
7123 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
7124 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
7125 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
7126 int (PASCAL
*pfn_WSACleanup
) (void);
7128 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
7129 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
7130 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
7131 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
7132 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
7133 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
7134 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
7135 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
7136 const char * optval
, int optlen
);
7137 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
7138 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
7140 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
7141 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
7142 struct sockaddr
* from
, int * fromlen
);
7143 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
7144 const struct sockaddr
* to
, int tolen
);
7146 /* SetHandleInformation is only needed to make sockets non-inheritable. */
7147 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
7148 #ifndef HANDLE_FLAG_INHERIT
7149 #define HANDLE_FLAG_INHERIT 1
7153 static int winsock_inuse
;
7158 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
7160 release_listen_threads ();
7161 /* Not sure what would cause WSAENETDOWN, or even if it can happen
7162 after WSAStartup returns successfully, but it seems reasonable
7163 to allow unloading winsock anyway in that case. */
7164 if (pfn_WSACleanup () == 0 ||
7165 pfn_WSAGetLastError () == WSAENETDOWN
)
7167 if (FreeLibrary (winsock_lib
))
7176 init_winsock (int load_now
)
7178 WSADATA winsockData
;
7180 if (winsock_lib
!= NULL
)
7183 pfn_SetHandleInformation
7184 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
7185 "SetHandleInformation");
7187 winsock_lib
= LoadLibrary ("Ws2_32.dll");
7189 if (winsock_lib
!= NULL
)
7191 /* dynamically link to socket functions */
7193 #define LOAD_PROC(fn) \
7194 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
7197 LOAD_PROC (WSAStartup
);
7198 LOAD_PROC (WSASetLastError
);
7199 LOAD_PROC (WSAGetLastError
);
7200 LOAD_PROC (WSAEventSelect
);
7201 LOAD_PROC (WSAEnumNetworkEvents
);
7202 LOAD_PROC (WSACreateEvent
);
7203 LOAD_PROC (WSACloseEvent
);
7206 LOAD_PROC (connect
);
7207 LOAD_PROC (ioctlsocket
);
7210 LOAD_PROC (closesocket
);
7211 LOAD_PROC (shutdown
);
7214 LOAD_PROC (inet_addr
);
7215 LOAD_PROC (gethostname
);
7216 LOAD_PROC (gethostbyname
);
7217 LOAD_PROC (getservbyname
);
7218 LOAD_PROC (getpeername
);
7219 LOAD_PROC (WSACleanup
);
7220 LOAD_PROC (setsockopt
);
7222 LOAD_PROC (getsockname
);
7224 LOAD_PROC (recvfrom
);
7228 /* specify version 1.1 of winsock */
7229 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
7231 if (winsockData
.wVersion
!= 0x101)
7236 /* Report that winsock exists and is usable, but leave
7237 socket functions disabled. I am assuming that calling
7238 WSAStartup does not require any network interaction,
7239 and in particular does not cause or require a dial-up
7240 connection to be established. */
7243 FreeLibrary (winsock_lib
);
7251 FreeLibrary (winsock_lib
);
7261 /* Function to map winsock error codes to errno codes for those errno
7262 code defined in errno.h (errno values not defined by errno.h are
7263 already in nt/inc/sys/socket.h). */
7270 if (winsock_lib
== NULL
)
7273 wsa_err
= pfn_WSAGetLastError ();
7277 case WSAEACCES
: errno
= EACCES
; break;
7278 case WSAEBADF
: errno
= EBADF
; break;
7279 case WSAEFAULT
: errno
= EFAULT
; break;
7280 case WSAEINTR
: errno
= EINTR
; break;
7281 case WSAEINVAL
: errno
= EINVAL
; break;
7282 case WSAEMFILE
: errno
= EMFILE
; break;
7283 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
7284 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
7285 case WSAEWOULDBLOCK
: errno
= EWOULDBLOCK
; break;
7286 case WSAENOTCONN
: errno
= ENOTCONN
; break;
7287 default: errno
= wsa_err
; break;
7295 if (winsock_lib
!= NULL
)
7296 pfn_WSASetLastError (0);
7299 /* Extend strerror to handle the winsock-specific error codes. */
7303 } _wsa_errlist
[] = {
7304 {WSAEINTR
, "Interrupted function call"},
7305 {WSAEBADF
, "Bad file descriptor"},
7306 {WSAEACCES
, "Permission denied"},
7307 {WSAEFAULT
, "Bad address"},
7308 {WSAEINVAL
, "Invalid argument"},
7309 {WSAEMFILE
, "Too many open files"},
7311 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
7312 {WSAEINPROGRESS
, "Operation now in progress"},
7313 {WSAEALREADY
, "Operation already in progress"},
7314 {WSAENOTSOCK
, "Socket operation on non-socket"},
7315 {WSAEDESTADDRREQ
, "Destination address required"},
7316 {WSAEMSGSIZE
, "Message too long"},
7317 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
7318 {WSAENOPROTOOPT
, "Bad protocol option"},
7319 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
7320 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
7321 {WSAEOPNOTSUPP
, "Operation not supported"},
7322 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
7323 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
7324 {WSAEADDRINUSE
, "Address already in use"},
7325 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
7326 {WSAENETDOWN
, "Network is down"},
7327 {WSAENETUNREACH
, "Network is unreachable"},
7328 {WSAENETRESET
, "Network dropped connection on reset"},
7329 {WSAECONNABORTED
, "Software caused connection abort"},
7330 {WSAECONNRESET
, "Connection reset by peer"},
7331 {WSAENOBUFS
, "No buffer space available"},
7332 {WSAEISCONN
, "Socket is already connected"},
7333 {WSAENOTCONN
, "Socket is not connected"},
7334 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
7335 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
7336 {WSAETIMEDOUT
, "Connection timed out"},
7337 {WSAECONNREFUSED
, "Connection refused"},
7338 {WSAELOOP
, "Network loop"}, /* not sure */
7339 {WSAENAMETOOLONG
, "Name is too long"},
7340 {WSAEHOSTDOWN
, "Host is down"},
7341 {WSAEHOSTUNREACH
, "No route to host"},
7342 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
7343 {WSAEPROCLIM
, "Too many processes"},
7344 {WSAEUSERS
, "Too many users"}, /* not sure */
7345 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
7346 {WSAESTALE
, "Data is stale"}, /* not sure */
7347 {WSAEREMOTE
, "Remote error"}, /* not sure */
7349 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
7350 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
7351 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
7352 {WSAEDISCON
, "Graceful shutdown in progress"},
7354 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
7355 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
7356 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
7357 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
7358 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
7359 {WSASYSCALLFAILURE
, "System call failure"},
7360 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
7361 {WSATYPE_NOT_FOUND
, "Class type not found"},
7362 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
7363 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
7364 {WSAEREFUSED
, "Operation refused"}, /* not sure */
7367 {WSAHOST_NOT_FOUND
, "Host not found"},
7368 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
7369 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
7370 {WSANO_DATA
, "Valid name, no data record of requested type"},
7376 sys_strerror (int error_no
)
7379 static char unknown_msg
[40];
7381 if (error_no
>= 0 && error_no
< sys_nerr
)
7382 return sys_errlist
[error_no
];
7384 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
7385 if (_wsa_errlist
[i
].errnum
== error_no
)
7386 return _wsa_errlist
[i
].msg
;
7388 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
7392 /* [andrewi 3-May-96] I've had conflicting results using both methods,
7393 but I believe the method of keeping the socket handle separate (and
7394 insuring it is not inheritable) is the correct one. */
7396 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
7398 static int socket_to_fd (SOCKET s
);
7401 sys_socket (int af
, int type
, int protocol
)
7405 if (winsock_lib
== NULL
)
7408 return INVALID_SOCKET
;
7413 /* call the real socket function */
7414 s
= pfn_socket (af
, type
, protocol
);
7416 if (s
!= INVALID_SOCKET
)
7417 return socket_to_fd (s
);
7423 /* Convert a SOCKET to a file descriptor. */
7425 socket_to_fd (SOCKET s
)
7430 /* Although under NT 3.5 _open_osfhandle will accept a socket
7431 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
7432 that does not work under NT 3.1. However, we can get the same
7433 effect by using a backdoor function to replace an existing
7434 descriptor handle with the one we want. */
7436 /* allocate a file descriptor (with appropriate flags) */
7437 fd
= _open ("NUL:", _O_RDWR
);
7440 /* Make a non-inheritable copy of the socket handle. Note
7441 that it is possible that sockets aren't actually kernel
7442 handles, which appears to be the case on Windows 9x when
7443 the MS Proxy winsock client is installed. */
7445 /* Apparently there is a bug in NT 3.51 with some service
7446 packs, which prevents using DuplicateHandle to make a
7447 socket handle non-inheritable (causes WSACleanup to
7448 hang). The work-around is to use SetHandleInformation
7449 instead if it is available and implemented. */
7450 if (pfn_SetHandleInformation
)
7452 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
7456 HANDLE parent
= GetCurrentProcess ();
7457 HANDLE new_s
= INVALID_HANDLE_VALUE
;
7459 if (DuplicateHandle (parent
,
7465 DUPLICATE_SAME_ACCESS
))
7467 /* It is possible that DuplicateHandle succeeds even
7468 though the socket wasn't really a kernel handle,
7469 because a real handle has the same value. So
7470 test whether the new handle really is a socket. */
7471 long nonblocking
= 0;
7472 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
7474 pfn_closesocket (s
);
7479 CloseHandle (new_s
);
7484 eassert (fd
< MAXDESC
);
7485 fd_info
[fd
].hnd
= (HANDLE
) s
;
7487 /* set our own internal flags */
7488 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
7494 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7496 /* attach child_process to fd_info */
7497 if (fd_info
[ fd
].cp
!= NULL
)
7499 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
7503 fd_info
[ fd
].cp
= cp
;
7506 winsock_inuse
++; /* count open sockets */
7514 pfn_closesocket (s
);
7520 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
7522 if (winsock_lib
== NULL
)
7525 return SOCKET_ERROR
;
7529 if (fd_info
[s
].flags
& FILE_SOCKET
)
7531 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
7532 if (rc
== SOCKET_ERROR
)
7537 return SOCKET_ERROR
;
7541 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
7543 if (winsock_lib
== NULL
)
7546 return SOCKET_ERROR
;
7550 if (fd_info
[s
].flags
& FILE_SOCKET
)
7552 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
7553 if (rc
== SOCKET_ERROR
)
7556 /* If this is a non-blocking 'connect', set the bit in flags
7557 that will tell reader_thread to wait for connection
7558 before trying to read. */
7559 if (errno
== EWOULDBLOCK
&& (fd_info
[s
].flags
& FILE_NDELAY
) != 0)
7561 errno
= EINPROGRESS
; /* that's what process.c expects */
7562 fd_info
[s
].flags
|= FILE_CONNECT
;
7568 return SOCKET_ERROR
;
7572 sys_htons (u_short hostshort
)
7574 return (winsock_lib
!= NULL
) ?
7575 pfn_htons (hostshort
) : hostshort
;
7579 sys_ntohs (u_short netshort
)
7581 return (winsock_lib
!= NULL
) ?
7582 pfn_ntohs (netshort
) : netshort
;
7586 sys_inet_addr (const char * cp
)
7588 return (winsock_lib
!= NULL
) ?
7589 pfn_inet_addr (cp
) : INADDR_NONE
;
7593 sys_gethostname (char * name
, int namelen
)
7595 if (winsock_lib
!= NULL
)
7600 retval
= pfn_gethostname (name
, namelen
);
7601 if (retval
== SOCKET_ERROR
)
7606 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
7607 return !GetComputerName (name
, (DWORD
*)&namelen
);
7610 return SOCKET_ERROR
;
7614 sys_gethostbyname (const char * name
)
7616 struct hostent
* host
;
7617 int h_err
= h_errno
;
7619 if (winsock_lib
== NULL
)
7621 h_errno
= NO_RECOVERY
;
7627 host
= pfn_gethostbyname (name
);
7639 sys_getservbyname (const char * name
, const char * proto
)
7641 struct servent
* serv
;
7643 if (winsock_lib
== NULL
)
7650 serv
= pfn_getservbyname (name
, proto
);
7657 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
7659 if (winsock_lib
== NULL
)
7662 return SOCKET_ERROR
;
7666 if (fd_info
[s
].flags
& FILE_SOCKET
)
7668 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
7669 if (rc
== SOCKET_ERROR
)
7674 return SOCKET_ERROR
;
7678 sys_shutdown (int s
, int how
)
7680 if (winsock_lib
== NULL
)
7683 return SOCKET_ERROR
;
7687 if (fd_info
[s
].flags
& FILE_SOCKET
)
7689 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
7690 if (rc
== SOCKET_ERROR
)
7695 return SOCKET_ERROR
;
7699 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
7701 if (winsock_lib
== NULL
)
7704 return SOCKET_ERROR
;
7708 if (fd_info
[s
].flags
& FILE_SOCKET
)
7710 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
7711 (const char *)optval
, optlen
);
7712 if (rc
== SOCKET_ERROR
)
7717 return SOCKET_ERROR
;
7721 sys_listen (int s
, int backlog
)
7723 if (winsock_lib
== NULL
)
7726 return SOCKET_ERROR
;
7730 if (fd_info
[s
].flags
& FILE_SOCKET
)
7732 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
7733 if (rc
== SOCKET_ERROR
)
7736 fd_info
[s
].flags
|= FILE_LISTEN
;
7740 return SOCKET_ERROR
;
7744 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
7746 if (winsock_lib
== NULL
)
7749 return SOCKET_ERROR
;
7753 if (fd_info
[s
].flags
& FILE_SOCKET
)
7755 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
7756 if (rc
== SOCKET_ERROR
)
7761 return SOCKET_ERROR
;
7765 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
7767 if (winsock_lib
== NULL
)
7774 if (fd_info
[s
].flags
& FILE_LISTEN
)
7776 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
7778 if (t
== INVALID_SOCKET
)
7781 fd
= socket_to_fd (t
);
7785 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7786 ResetEvent (fd_info
[s
].cp
->char_avail
);
7795 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
7796 struct sockaddr
* from
, int * fromlen
)
7798 if (winsock_lib
== NULL
)
7801 return SOCKET_ERROR
;
7805 if (fd_info
[s
].flags
& FILE_SOCKET
)
7807 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
7808 if (rc
== SOCKET_ERROR
)
7813 return SOCKET_ERROR
;
7817 sys_sendto (int s
, const char * buf
, int len
, int flags
,
7818 const struct sockaddr
* to
, int tolen
)
7820 if (winsock_lib
== NULL
)
7823 return SOCKET_ERROR
;
7827 if (fd_info
[s
].flags
& FILE_SOCKET
)
7829 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
7830 if (rc
== SOCKET_ERROR
)
7835 return SOCKET_ERROR
;
7838 /* Windows does not have an fcntl function. Provide an implementation
7839 good enough for Emacs. */
7841 fcntl (int s
, int cmd
, int options
)
7843 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
7844 invoked in a context where fd1 is closed and all descriptors less
7845 than fd1 are open, so sys_dup is an adequate implementation. */
7846 if (cmd
== F_DUPFD_CLOEXEC
)
7850 if (fd_info
[s
].flags
& FILE_SOCKET
)
7852 if (winsock_lib
== NULL
)
7858 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
7860 unsigned long nblock
= 1;
7861 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
7862 if (rc
== SOCKET_ERROR
)
7864 /* Keep track of the fact that we set this to non-blocking. */
7865 fd_info
[s
].flags
|= FILE_NDELAY
;
7871 return SOCKET_ERROR
;
7874 else if ((fd_info
[s
].flags
& (FILE_PIPE
| FILE_WRITE
))
7875 == (FILE_PIPE
| FILE_WRITE
))
7877 /* Force our writes to pipes be non-blocking. */
7878 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
7880 HANDLE h
= (HANDLE
)_get_osfhandle (s
);
7881 DWORD pipe_mode
= PIPE_NOWAIT
;
7883 if (!SetNamedPipeHandleState (h
, &pipe_mode
, NULL
, NULL
))
7885 DebPrint (("SetNamedPipeHandleState: %lu\n", GetLastError ()));
7886 return SOCKET_ERROR
;
7888 fd_info
[s
].flags
|= FILE_NDELAY
;
7894 return SOCKET_ERROR
;
7898 return SOCKET_ERROR
;
7902 /* Shadow main io functions: we need to handle pipes and sockets more
7916 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
7918 child_process
* cp
= fd_info
[fd
].cp
;
7920 fd_info
[fd
].cp
= NULL
;
7922 if (CHILD_ACTIVE (cp
))
7924 /* if last descriptor to active child_process then cleanup */
7926 for (i
= 0; i
< MAXDESC
; i
++)
7930 if (fd_info
[i
].cp
== cp
)
7935 if (fd_info
[fd
].flags
& FILE_SOCKET
)
7937 if (winsock_lib
== NULL
) emacs_abort ();
7939 pfn_shutdown (SOCK_HANDLE (fd
), 2);
7940 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
7942 winsock_inuse
--; /* count open sockets */
7944 /* If the process handle is NULL, it's either a socket
7945 or serial connection, or a subprocess that was
7946 already reaped by reap_subprocess, but whose
7947 resources were not yet freed, because its output was
7948 not fully read yet by the time it was reaped. (This
7949 usually happens with async subprocesses whose output
7950 is being read by Emacs.) Otherwise, this process was
7951 not reaped yet, so we set its FD to a negative value
7952 to make sure sys_select will eventually get to
7953 calling the SIGCHLD handler for it, which will then
7954 invoke waitpid and reap_subprocess. */
7955 if (cp
->procinfo
.hProcess
== NULL
)
7963 if (fd
>= 0 && fd
< MAXDESC
)
7964 fd_info
[fd
].flags
= 0;
7966 /* Note that sockets do not need special treatment here (at least on
7967 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
7968 closesocket is equivalent to CloseHandle, which is to be expected
7969 because socket handles are fully fledged kernel handles. */
7981 if (new_fd
>= 0 && new_fd
< MAXDESC
)
7983 /* duplicate our internal info as well */
7984 fd_info
[new_fd
] = fd_info
[fd
];
7990 sys_dup2 (int src
, int dst
)
7994 if (dst
< 0 || dst
>= MAXDESC
)
8000 /* make sure we close the destination first if it's a pipe or socket */
8001 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
8004 rc
= _dup2 (src
, dst
);
8007 /* duplicate our internal info as well */
8008 fd_info
[dst
] = fd_info
[src
];
8014 pipe2 (int * phandles
, int pipe2_flags
)
8019 eassert (pipe2_flags
== (O_BINARY
| O_CLOEXEC
));
8021 /* make pipe handles non-inheritable; when we spawn a child, we
8022 replace the relevant handle with an inheritable one. Also put
8023 pipes into binary mode; we will do text mode translation ourselves
8025 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
8029 /* Protect against overflow, since Windows can open more handles than
8030 our fd_info array has room for. */
8031 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
8033 _close (phandles
[0]);
8034 _close (phandles
[1]);
8040 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
8041 fd_info
[phandles
[0]].flags
= flags
;
8043 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
8044 fd_info
[phandles
[1]].flags
= flags
;
8051 /* Function to do blocking read of one byte, needed to implement
8052 select. It is only allowed on communication ports, sockets, or
8055 _sys_read_ahead (int fd
)
8060 if (fd
< 0 || fd
>= MAXDESC
)
8061 return STATUS_READ_ERROR
;
8063 cp
= fd_info
[fd
].cp
;
8065 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
8066 return STATUS_READ_ERROR
;
8068 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
8069 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
8071 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
8075 if ((fd_info
[fd
].flags
& FILE_CONNECT
) != 0)
8076 DebPrint (("_sys_read_ahead: read requested from fd %d, which waits for async connect!\n", fd
));
8077 cp
->status
= STATUS_READ_IN_PROGRESS
;
8079 if (fd_info
[fd
].flags
& FILE_PIPE
)
8081 rc
= _read (fd
, &cp
->chr
, sizeof (char));
8083 /* Give subprocess time to buffer some more output for us before
8084 reporting that input is available; we need this because Windows 95
8085 connects DOS programs to pipes by making the pipe appear to be
8086 the normal console stdout - as a result most DOS programs will
8087 write to stdout without buffering, ie. one character at a
8088 time. Even some W32 programs do this - "dir" in a command
8089 shell on NT is very slow if we don't do this. */
8092 int wait
= w32_pipe_read_delay
;
8098 /* Yield remainder of our time slice, effectively giving a
8099 temporary priority boost to the child process. */
8103 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
8105 HANDLE hnd
= fd_info
[fd
].hnd
;
8106 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
8109 /* Configure timeouts for blocking read. */
8110 if (!GetCommTimeouts (hnd
, &ct
))
8112 cp
->status
= STATUS_READ_ERROR
;
8113 return STATUS_READ_ERROR
;
8115 ct
.ReadIntervalTimeout
= 0;
8116 ct
.ReadTotalTimeoutMultiplier
= 0;
8117 ct
.ReadTotalTimeoutConstant
= 0;
8118 if (!SetCommTimeouts (hnd
, &ct
))
8120 cp
->status
= STATUS_READ_ERROR
;
8121 return STATUS_READ_ERROR
;
8124 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
8126 if (GetLastError () != ERROR_IO_PENDING
)
8128 cp
->status
= STATUS_READ_ERROR
;
8129 return STATUS_READ_ERROR
;
8131 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
8133 cp
->status
= STATUS_READ_ERROR
;
8134 return STATUS_READ_ERROR
;
8138 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
8140 unsigned long nblock
= 0;
8141 /* We always want this to block, so temporarily disable NDELAY. */
8142 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8143 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8145 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
8147 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8150 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8154 if (rc
== sizeof (char))
8155 cp
->status
= STATUS_READ_SUCCEEDED
;
8157 cp
->status
= STATUS_READ_FAILED
;
8163 _sys_wait_accept (int fd
)
8169 if (fd
< 0 || fd
>= MAXDESC
)
8170 return STATUS_READ_ERROR
;
8172 cp
= fd_info
[fd
].cp
;
8174 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
8175 return STATUS_READ_ERROR
;
8177 cp
->status
= STATUS_READ_FAILED
;
8179 hEv
= pfn_WSACreateEvent ();
8180 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
8181 if (rc
!= SOCKET_ERROR
)
8184 rc
= WaitForSingleObject (hEv
, 500);
8186 } while (rc
== WAIT_TIMEOUT
8187 && cp
->status
!= STATUS_READ_ERROR
8189 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
8190 if (rc
== WAIT_OBJECT_0
)
8191 cp
->status
= STATUS_READ_SUCCEEDED
;
8193 pfn_WSACloseEvent (hEv
);
8199 _sys_wait_connect (int fd
)
8205 if (fd
< 0 || fd
>= MAXDESC
)
8206 return STATUS_READ_ERROR
;
8208 cp
= fd_info
[fd
].cp
;
8209 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
8210 return STATUS_READ_ERROR
;
8212 cp
->status
= STATUS_READ_FAILED
;
8214 hEv
= pfn_WSACreateEvent ();
8215 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_CONNECT
);
8216 if (rc
!= SOCKET_ERROR
)
8219 rc
= WaitForSingleObject (hEv
, 500);
8221 } while (rc
== WAIT_TIMEOUT
8222 && cp
->status
!= STATUS_READ_ERROR
8224 if (rc
== WAIT_OBJECT_0
)
8226 /* We've got an event, but it could be a successful
8227 connection, or it could be a failure. Find out
8229 WSANETWORKEVENTS events
;
8231 pfn_WSAEnumNetworkEvents (SOCK_HANDLE (fd
), hEv
, &events
);
8232 if ((events
.lNetworkEvents
& FD_CONNECT
) != 0
8233 && events
.iErrorCode
[FD_CONNECT_BIT
])
8235 cp
->status
= STATUS_CONNECT_FAILED
;
8236 cp
->errcode
= events
.iErrorCode
[FD_CONNECT_BIT
];
8240 cp
->status
= STATUS_READ_SUCCEEDED
;
8244 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
8247 pfn_WSACloseEvent (hEv
);
8253 sys_read (int fd
, char * buffer
, unsigned int count
)
8258 char * orig_buffer
= buffer
;
8266 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8268 child_process
*cp
= fd_info
[fd
].cp
;
8270 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
8278 /* re-read CR carried over from last read */
8279 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
8281 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
8285 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
8288 /* presence of a child_process structure means we are operating in
8289 non-blocking mode - otherwise we just call _read directly.
8290 Note that the child_process structure might be missing because
8291 reap_subprocess has been called; in this case the pipe is
8292 already broken, so calling _read on it is okay. */
8295 int current_status
= cp
->status
;
8297 switch (current_status
)
8299 case STATUS_READ_FAILED
:
8300 case STATUS_READ_ERROR
:
8301 /* report normal EOF if nothing in buffer */
8303 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8306 case STATUS_READ_READY
:
8307 case STATUS_READ_IN_PROGRESS
:
8308 DebPrint (("sys_read called when read is in progress\n"));
8309 errno
= EWOULDBLOCK
;
8312 case STATUS_READ_SUCCEEDED
:
8313 /* consume read-ahead char */
8314 *buffer
++ = cp
->chr
;
8317 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
8318 ResetEvent (cp
->char_avail
);
8320 case STATUS_READ_ACKNOWLEDGED
:
8321 case STATUS_CONNECT_FAILED
:
8325 DebPrint (("sys_read: bad status %d\n", current_status
));
8330 if (fd_info
[fd
].flags
& FILE_PIPE
)
8332 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
8333 to_read
= min (waiting
, (DWORD
) count
);
8336 nchars
+= _read (fd
, buffer
, to_read
);
8338 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
8340 HANDLE hnd
= fd_info
[fd
].hnd
;
8341 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
8347 /* Configure timeouts for non-blocking read. */
8348 if (!GetCommTimeouts (hnd
, &ct
))
8353 ct
.ReadIntervalTimeout
= MAXDWORD
;
8354 ct
.ReadTotalTimeoutMultiplier
= 0;
8355 ct
.ReadTotalTimeoutConstant
= 0;
8356 if (!SetCommTimeouts (hnd
, &ct
))
8362 if (!ResetEvent (ovl
->hEvent
))
8367 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
8369 if (GetLastError () != ERROR_IO_PENDING
)
8374 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
8383 else /* FILE_SOCKET */
8385 if (winsock_lib
== NULL
) emacs_abort ();
8387 /* When a non-blocking 'connect' call fails,
8388 wait_reading_process_output detects this by calling
8389 'getpeername', and then attempts to obtain the connection
8390 error code by trying to read 1 byte from the socket. If
8391 we try to serve that read by calling 'recv' below, the
8392 error we get is a generic WSAENOTCONN, not the actual
8393 connection error. So instead, we use the actual error
8394 code stashed by '_sys_wait_connect' in cp->errcode.
8395 Alternatively, we could have used 'getsockopt', like on
8396 GNU/Linux, but: (a) I have no idea whether the winsock
8397 version could hang, as it does "on some systems" (see the
8398 comment in process.c); and (b) 'getsockopt' on Windows is
8399 documented to clear the socket error for the entire
8400 process, which I'm not sure is TRT; FIXME. */
8401 if (current_status
== STATUS_CONNECT_FAILED
8402 && (fd_info
[fd
].flags
& FILE_CONNECT
) != 0
8403 && cp
->errcode
!= 0)
8405 pfn_WSASetLastError (cp
->errcode
);
8409 /* Do the equivalent of a non-blocking read. */
8410 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
8411 if (waiting
== 0 && nchars
== 0)
8413 errno
= EWOULDBLOCK
;
8419 /* always use binary mode for sockets */
8420 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
8421 if (res
== SOCKET_ERROR
)
8424 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
8425 errno
, SOCK_HANDLE (fd
)));
8434 int nread
= _read (fd
, buffer
, count
);
8437 else if (nchars
== 0)
8442 fd_info
[fd
].flags
|= FILE_AT_EOF
;
8443 /* Perform text mode translation if required. */
8444 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8446 nchars
= crlf_to_lf (nchars
, orig_buffer
);
8447 /* If buffer contains only CR, return that. To be absolutely
8448 sure we should attempt to read the next char, but in
8449 practice a CR to be followed by LF would not appear by
8450 itself in the buffer. */
8451 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
8453 fd_info
[fd
].flags
|= FILE_LAST_CR
;
8459 nchars
= _read (fd
, buffer
, count
);
8464 /* From w32xfns.c */
8465 extern HANDLE interrupt_handle
;
8468 sys_write (int fd
, const void * buffer
, unsigned int count
)
8479 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
8481 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
8487 /* Perform text mode translation if required. */
8488 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
8491 const unsigned char * src
= buffer
;
8492 unsigned char * dst
;
8495 SAFE_NALLOCA (tmpbuf
, 2, count
);
8500 unsigned char *next
;
8501 /* Copy next line or remaining bytes. */
8502 next
= _memccpy (dst
, src
, '\n', nbytes
);
8505 /* Copied one line ending with '\n'. */
8506 int copied
= next
- dst
;
8509 /* Insert '\r' before '\n'. */
8516 /* Copied remaining partial line -> now finished. */
8523 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
8525 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
8526 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
8527 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
8530 /* This is async (a.k.a. "overlapped") I/O, so the return value
8531 of FALSE from WriteFile means either an error or the output
8532 will be completed asynchronously (ERROR_IO_PENDING). */
8533 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
8535 if (GetLastError () != ERROR_IO_PENDING
)
8542 /* Wait for the write to complete, and watch C-g while
8544 if (detect_input_pending ())
8545 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
,
8546 INFINITE
, QS_ALLINPUT
);
8548 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
8552 /* User pressed C-g, cancel write, then leave.
8553 Don't bother cleaning up as we may only get stuck
8554 in buggy drivers. */
8555 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
8557 errno
= EIO
; /* Why not EINTR? */
8560 case WAIT_OBJECT_0
+ 1:
8561 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
8571 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
8573 unsigned long nblock
= 0;
8574 if (winsock_lib
== NULL
) emacs_abort ();
8576 /* TODO: implement select() properly so non-blocking I/O works. */
8577 /* For now, make sure the write blocks. */
8578 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8579 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8581 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
8583 /* Set the socket back to non-blocking if it was before,
8584 for other operations that support it. */
8585 if (fd_info
[fd
].flags
& FILE_NDELAY
)
8588 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
8591 if (nchars
== SOCKET_ERROR
)
8593 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
8594 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
8600 /* Some networked filesystems don't like too large writes, so
8601 break them into smaller chunks. See the Comments section of
8602 the MSDN documentation of WriteFile for details behind the
8603 choice of the value of CHUNK below. See also the thread
8604 http://thread.gmane.org/gmane.comp.version-control.git/145294
8605 in the git mailing list. */
8606 const unsigned char *p
= buffer
;
8607 const unsigned chunk
= 30 * 1024 * 1024;
8612 unsigned this_chunk
= count
< chunk
? count
: chunk
;
8613 int n
= _write (fd
, p
, this_chunk
);
8618 /* When there's no buffer space in a pipe that is in the
8619 non-blocking mode, _write returns ENOSPC. We return
8620 EAGAIN instead, which should trigger the logic in
8621 send_process that enters waiting loop and calls
8622 wait_reading_process_output to allow process input to
8623 be accepted during the wait. Those calls to
8624 wait_reading_process_output allow sys_select to
8625 notice when process input becomes available, thus
8626 avoiding deadlock whereby each side of the pipe is
8627 blocked on write, waiting for the other party to read
8628 its end of the pipe. */
8631 && ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_NDELAY
))
8632 == (FILE_PIPE
| FILE_NDELAY
)))
8637 else if (n
< this_chunk
)
8649 /* Emulation of SIOCGIFCONF and getifaddrs, see process.c. */
8651 extern Lisp_Object
conv_sockaddr_to_lisp (struct sockaddr
*, int);
8653 /* Return information about network interface IFNAME, or about all
8654 interfaces (if IFNAME is nil). */
8656 network_interface_get_info (Lisp_Object ifname
)
8658 ULONG ainfo_len
= sizeof (IP_ADAPTER_INFO
);
8659 IP_ADAPTER_INFO
*adapter
, *ainfo
= xmalloc (ainfo_len
);
8660 DWORD retval
= get_adapters_info (ainfo
, &ainfo_len
);
8661 Lisp_Object res
= Qnil
;
8663 if (retval
== ERROR_BUFFER_OVERFLOW
)
8665 ainfo
= xrealloc (ainfo
, ainfo_len
);
8666 retval
= get_adapters_info (ainfo
, &ainfo_len
);
8669 if (retval
== ERROR_SUCCESS
)
8671 int eth_count
= 0, tr_count
= 0, fddi_count
= 0, ppp_count
= 0;
8672 int sl_count
= 0, wlan_count
= 0, lo_count
= 0, ifx_count
= 0;
8674 struct sockaddr_in sa
;
8676 /* For the below, we need some winsock functions, so make sure
8677 the winsock DLL is loaded. If we cannot successfully load
8678 it, they will have no use of the information we provide,
8680 if (!winsock_lib
&& !init_winsock (1))
8683 for (adapter
= ainfo
; adapter
; adapter
= adapter
->Next
)
8685 char namebuf
[MAX_ADAPTER_NAME_LENGTH
+ 4];
8687 /* Present Unix-compatible interface names, instead of the
8688 Windows names, which are really GUIDs not readable by
8690 static const char *ifmt
[] = {
8691 "eth%d", "tr%d", "fddi%d", "ppp%d", "sl%d", "wlan%d",
8706 switch (adapter
->Type
)
8708 case MIB_IF_TYPE_ETHERNET
:
8709 /* Windows before Vista reports wireless adapters as
8710 Ethernet. Work around by looking at the Description
8712 if (strstr (adapter
->Description
, "Wireless "))
8715 if_num
= wlan_count
++;
8719 ifmt_idx
= ETHERNET
;
8720 if_num
= eth_count
++;
8723 case MIB_IF_TYPE_TOKENRING
:
8724 ifmt_idx
= TOKENRING
;
8725 if_num
= tr_count
++;
8727 case MIB_IF_TYPE_FDDI
:
8729 if_num
= fddi_count
++;
8731 case MIB_IF_TYPE_PPP
:
8733 if_num
= ppp_count
++;
8735 case MIB_IF_TYPE_SLIP
:
8737 if_num
= sl_count
++;
8739 case IF_TYPE_IEEE80211
:
8741 if_num
= wlan_count
++;
8743 case MIB_IF_TYPE_LOOPBACK
:
8746 ifmt_idx
= LOOPBACK
;
8747 if_num
= lo_count
++;
8753 ifmt_idx
= OTHER_IF
;
8754 if_num
= ifx_count
++;
8757 if (ifmt_idx
== NONE
)
8759 sprintf (namebuf
, ifmt
[ifmt_idx
], if_num
);
8761 sa
.sin_family
= AF_INET
;
8762 ip_addr
= sys_inet_addr (adapter
->IpAddressList
.IpAddress
.String
);
8763 if (ip_addr
== INADDR_NONE
)
8765 /* Bogus address, skip this interface. */
8768 sa
.sin_addr
.s_addr
= ip_addr
;
8771 res
= Fcons (Fcons (build_string (namebuf
),
8772 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8773 sizeof (struct sockaddr
))),
8775 else if (strcmp (namebuf
, SSDATA (ifname
)) == 0)
8777 Lisp_Object hwaddr
= Fmake_vector (make_number (6), Qnil
);
8778 register struct Lisp_Vector
*p
= XVECTOR (hwaddr
);
8779 Lisp_Object flags
= Qnil
;
8783 /* Flags. We guess most of them by type, since the
8784 Windows flags are different and hard to get by. */
8785 flags
= Fcons (intern ("up"), flags
);
8786 if (ifmt_idx
== ETHERNET
|| ifmt_idx
== WLAN
)
8788 flags
= Fcons (intern ("broadcast"), flags
);
8789 flags
= Fcons (intern ("multicast"), flags
);
8791 flags
= Fcons (intern ("running"), flags
);
8792 if (ifmt_idx
== PPP
)
8794 flags
= Fcons (intern ("pointopoint"), flags
);
8795 flags
= Fcons (intern ("noarp"), flags
);
8797 if (adapter
->HaveWins
)
8798 flags
= Fcons (intern ("WINS"), flags
);
8799 if (adapter
->DhcpEnabled
)
8800 flags
= Fcons (intern ("dynamic"), flags
);
8802 res
= Fcons (flags
, res
);
8804 /* Hardware address and its family. */
8805 for (n
= 0; n
< adapter
->AddressLength
; n
++)
8806 p
->contents
[n
] = make_number ((int) adapter
->Address
[n
]);
8807 /* Windows does not support AF_LINK or AF_PACKET family
8808 of addresses. Use an arbitrary family number that is
8809 identical to what GNU/Linux returns. */
8810 res
= Fcons (Fcons (make_number (1), hwaddr
), res
);
8813 sa
.sin_family
= AF_INET
;
8814 net_mask
= sys_inet_addr (adapter
->IpAddressList
.IpMask
.String
);
8815 if (net_mask
!= INADDR_NONE
)
8817 sa
.sin_addr
.s_addr
= net_mask
;
8819 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8820 sizeof (struct sockaddr
)),
8824 res
= Fcons (Qnil
, res
);
8826 sa
.sin_family
= AF_INET
;
8827 if (ip_addr
!= INADDR_NONE
)
8829 /* Broadcast address is only reported by
8830 GetAdaptersAddresses, which is of limited
8831 availability. Generate it on our own. */
8832 u_long bcast_addr
= (ip_addr
& net_mask
) | ~net_mask
;
8834 sa
.sin_addr
.s_addr
= bcast_addr
;
8836 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8837 sizeof (struct sockaddr
)),
8841 sa
.sin_addr
.s_addr
= ip_addr
;
8843 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8844 sizeof (struct sockaddr
)),
8848 res
= Fcons (Qnil
, Fcons (Qnil
, res
));
8851 /* GetAdaptersInfo is documented to not report loopback
8852 interfaces, so we generate one out of thin air. */
8855 sa
.sin_family
= AF_INET
;
8859 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8860 res
= Fcons (Fcons (build_string ("lo"),
8861 conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8862 sizeof (struct sockaddr
))),
8865 else if (strcmp (SSDATA (ifname
), "lo") == 0)
8867 res
= Fcons (Fcons (intern ("running"),
8868 Fcons (intern ("loopback"),
8869 Fcons (intern ("up"), Qnil
))), Qnil
);
8870 /* 772 is what 3 different GNU/Linux systems report for
8871 the loopback interface. */
8872 res
= Fcons (Fcons (make_number (772),
8873 Fmake_vector (make_number (6),
8876 sa
.sin_addr
.s_addr
= sys_inet_addr ("255.0.0.0");
8877 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8878 sizeof (struct sockaddr
)),
8880 sa
.sin_addr
.s_addr
= sys_inet_addr ("0.0.0.0");
8881 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8882 sizeof (struct sockaddr
)),
8884 sa
.sin_addr
.s_addr
= sys_inet_addr ("127.0.0.1");
8885 res
= Fcons (conv_sockaddr_to_lisp ((struct sockaddr
*) &sa
,
8886 sizeof (struct sockaddr
)),
8899 network_interface_list (void)
8901 return network_interface_get_info (Qnil
);
8905 network_interface_info (Lisp_Object ifname
)
8907 CHECK_STRING (ifname
);
8908 return network_interface_get_info (ifname
);
8912 /* The Windows CRT functions are "optimized for speed", so they don't
8913 check for timezone and DST changes if they were last called less
8914 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
8915 all Emacs features that repeatedly call time functions (e.g.,
8916 display-time) are in real danger of missing timezone and DST
8917 changes. Calling tzset before each localtime call fixes that. */
8919 sys_localtime (const time_t *t
)
8922 return localtime (t
);
8927 /* Try loading LIBRARY_ID from the file(s) specified in
8928 Vdynamic_library_alist. If the library is loaded successfully,
8929 return the handle of the DLL, and record the filename in the
8930 property :loaded-from of LIBRARY_ID. If the library could not be
8931 found, or when it was already loaded (because the handle is not
8932 recorded anywhere, and so is lost after use), return NULL.
8934 We could also save the handle in :loaded-from, but currently
8935 there's no use case for it. */
8937 w32_delayed_load (Lisp_Object library_id
)
8939 HMODULE dll_handle
= NULL
;
8941 CHECK_SYMBOL (library_id
);
8943 if (CONSP (Vdynamic_library_alist
)
8944 && NILP (Fassq (library_id
, Vlibrary_cache
)))
8946 Lisp_Object found
= Qnil
;
8947 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
8950 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
8952 Lisp_Object dll
= XCAR (dlls
);
8953 char name
[MAX_UTF8_PATH
];
8957 dll
= ENCODE_FILE (dll
);
8958 if (w32_unicode_filenames
)
8960 wchar_t name_w
[MAX_PATH
];
8962 filename_to_utf16 (SSDATA (dll
), name_w
);
8963 dll_handle
= LoadLibraryW (name_w
);
8966 res
= GetModuleFileNameW (dll_handle
, name_w
,
8969 filename_from_utf16 (name_w
, name
);
8974 char name_a
[MAX_PATH
];
8976 filename_to_ansi (SSDATA (dll
), name_a
);
8977 dll_handle
= LoadLibraryA (name_a
);
8980 res
= GetModuleFileNameA (dll_handle
, name_a
,
8983 filename_from_ansi (name_a
, name
);
8988 ptrdiff_t len
= strlen (name
);
8991 /* Possibly truncated */
8992 ? make_specified_string (name
, -1, len
, 1)
8994 /* This prevents thread start and end notifications
8995 from being sent to the DLL, for every thread we
8996 start. We don't need those notifications because
8997 threads we create never use any of these DLLs, only
8998 the main thread uses them. This is supposed to
8999 speed up thread creation. */
9000 DisableThreadLibraryCalls (dll_handle
);
9005 Fput (library_id
, QCloaded_from
, found
);
9013 check_windows_init_file (void)
9015 /* A common indication that Emacs is not installed properly is when
9016 it cannot find the Windows installation file. If this file does
9017 not exist in the expected place, tell the user. */
9019 if (!noninteractive
&& !inhibit_window_system
9020 /* Vload_path is not yet initialized when we are loading
9022 && NILP (Vpurify_flag
))
9024 Lisp_Object init_file
;
9027 /* Implementation note: this function runs early during Emacs
9028 startup, before startup.el is run. So Vload_path is still in
9029 its initial unibyte form, but it holds UTF-8 encoded file
9030 names, since init_callproc was already called. So we do not
9031 need to ENCODE_FILE here, but we do need to convert the file
9032 names from UTF-8 to ANSI. */
9033 init_file
= build_string ("term/w32-win");
9034 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
, 0);
9037 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
9038 char *init_file_name
= SDATA (init_file
);
9039 char *load_path
= SDATA (load_path_print
);
9040 char *buffer
= alloca (1024
9041 + strlen (init_file_name
)
9042 + strlen (load_path
));
9047 "The Emacs Windows initialization file \"%s.el\" "
9048 "could not be found in your Emacs installation. "
9049 "Emacs checked the following directories for this file:\n"
9051 "When Emacs cannot find this file, it usually means that it "
9052 "was not installed properly, or its distribution file was "
9053 "not unpacked properly.\nSee the README.W32 file in the "
9054 "top-level Emacs directory for more information.",
9055 init_file_name
, load_path
);
9056 needed
= pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
,
9060 wchar_t *msg_w
= alloca ((needed
+ 1) * sizeof (wchar_t));
9062 pMultiByteToWideChar (CP_UTF8
, MB_ERR_INVALID_CHARS
, buffer
, -1,
9064 needed
= pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1,
9065 NULL
, 0, NULL
, NULL
);
9068 char *msg_a
= alloca (needed
+ 1);
9070 pWideCharToMultiByte (CP_ACP
, 0, msg_w
, -1, msg_a
, needed
,
9077 "Emacs Abort Dialog",
9078 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
9079 /* Use the low-level system abort. */
9090 term_ntproc (int ignored
)
9096 /* shutdown the socket interface if necessary */
9103 init_ntproc (int dumping
)
9105 sigset_t initial_mask
= 0;
9107 /* Initialize the socket interface now if available and requested by
9108 the user by defining PRELOAD_WINSOCK; otherwise loading will be
9109 delayed until open-network-stream is called (w32-has-winsock can
9110 also be used to dynamically load or reload winsock).
9112 Conveniently, init_environment is called before us, so
9113 PRELOAD_WINSOCK can be set in the registry. */
9115 /* Always initialize this correctly. */
9118 if (getenv ("PRELOAD_WINSOCK") != NULL
)
9119 init_winsock (TRUE
);
9121 /* Initial preparation for subprocess support: replace our standard
9122 handles with non-inheritable versions. */
9125 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
9126 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
9127 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
9129 parent
= GetCurrentProcess ();
9131 /* ignore errors when duplicating and closing; typically the
9132 handles will be invalid when running as a gui program. */
9133 DuplicateHandle (parent
,
9134 GetStdHandle (STD_INPUT_HANDLE
),
9139 DUPLICATE_SAME_ACCESS
);
9141 DuplicateHandle (parent
,
9142 GetStdHandle (STD_OUTPUT_HANDLE
),
9147 DUPLICATE_SAME_ACCESS
);
9149 DuplicateHandle (parent
,
9150 GetStdHandle (STD_ERROR_HANDLE
),
9155 DUPLICATE_SAME_ACCESS
);
9161 if (stdin_save
!= INVALID_HANDLE_VALUE
)
9162 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
9164 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
9167 if (stdout_save
!= INVALID_HANDLE_VALUE
)
9168 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
9170 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
9173 if (stderr_save
!= INVALID_HANDLE_VALUE
)
9174 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
9176 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
9180 /* unfortunately, atexit depends on implementation of malloc */
9181 /* atexit (term_ntproc); */
9184 /* Make sure we start with all signals unblocked. */
9185 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
9186 signal (SIGABRT
, term_ntproc
);
9190 /* determine which drives are fixed, for GetCachedVolumeInformation */
9192 /* GetDriveType must have trailing backslash. */
9193 char drive
[] = "A:\\";
9195 /* Loop over all possible drive letters */
9196 while (*drive
<= 'Z')
9198 /* Record if this drive letter refers to a fixed drive. */
9199 fixed_drives
[DRIVE_INDEX (*drive
)] =
9200 (GetDriveType (drive
) == DRIVE_FIXED
);
9205 /* Reset the volume info cache. */
9206 volume_cache
= NULL
;
9211 shutdown_handler ensures that buffers' autosave files are
9212 up to date when the user logs off, or the system shuts down.
9215 shutdown_handler (DWORD type
)
9217 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
9218 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
9219 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
9220 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
9222 /* Shut down cleanly, making sure autosave files are up to date. */
9223 shut_down_emacs (0, Qnil
);
9226 /* Allow other handlers to handle this signal. */
9230 /* On Windows 9X, load UNICOWS.DLL and return its handle, or die. On
9231 NT, return a handle to GDI32.DLL. */
9233 maybe_load_unicows_dll (void)
9235 if (os_subtype
== OS_9X
)
9237 HANDLE ret
= LoadLibrary ("Unicows.dll");
9240 /* These two functions are present on Windows 9X as stubs
9241 that always fail. We need the real implementations from
9242 UNICOWS.DLL, so we must call these functions through
9243 pointers, and assign the correct addresses to these
9244 pointers at program startup (see emacs.c, which calls
9245 this function early on). */
9246 pMultiByteToWideChar
= GetProcAddress (ret
, "MultiByteToWideChar");
9247 pWideCharToMultiByte
= GetProcAddress (ret
, "WideCharToMultiByte");
9254 button
= MessageBox (NULL
,
9255 "Emacs cannot load the UNICOWS.DLL library.\n"
9256 "This library is essential for using Emacs\n"
9257 "on this system. You need to install it.\n\n"
9258 "Emacs will exit when you click OK.",
9259 "Emacs cannot load UNICOWS.DLL",
9260 MB_ICONERROR
| MB_TASKMODAL
9261 | MB_SETFOREGROUND
| MB_OK
);
9272 /* On NT family of Windows, these two functions are always
9273 linked in, so we just assign their addresses to the 2
9274 pointers; no need for the LoadLibrary dance. */
9275 pMultiByteToWideChar
= MultiByteToWideChar
;
9276 pWideCharToMultiByte
= WideCharToMultiByte
;
9277 return LoadLibrary ("Gdi32.dll");
9282 globals_of_w32 is used to initialize those global variables that
9283 must always be initialized on startup even when the global variable
9284 initialized is non zero (see the function main in emacs.c).
9287 globals_of_w32 (void)
9289 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
9291 get_process_times_fn
= (GetProcessTimes_Proc
)
9292 GetProcAddress (kernel32
, "GetProcessTimes");
9294 DEFSYM (QCloaded_from
, ":loaded-from");
9296 g_b_init_is_windows_9x
= 0;
9297 g_b_init_open_process_token
= 0;
9298 g_b_init_get_token_information
= 0;
9299 g_b_init_lookup_account_sid
= 0;
9300 g_b_init_get_sid_sub_authority
= 0;
9301 g_b_init_get_sid_sub_authority_count
= 0;
9302 g_b_init_get_security_info
= 0;
9303 g_b_init_get_file_security_w
= 0;
9304 g_b_init_get_file_security_a
= 0;
9305 g_b_init_get_security_descriptor_owner
= 0;
9306 g_b_init_get_security_descriptor_group
= 0;
9307 g_b_init_is_valid_sid
= 0;
9308 g_b_init_create_toolhelp32_snapshot
= 0;
9309 g_b_init_process32_first
= 0;
9310 g_b_init_process32_next
= 0;
9311 g_b_init_open_thread_token
= 0;
9312 g_b_init_impersonate_self
= 0;
9313 g_b_init_revert_to_self
= 0;
9314 g_b_init_get_process_memory_info
= 0;
9315 g_b_init_get_process_working_set_size
= 0;
9316 g_b_init_global_memory_status
= 0;
9317 g_b_init_global_memory_status_ex
= 0;
9318 g_b_init_equal_sid
= 0;
9319 g_b_init_copy_sid
= 0;
9320 g_b_init_get_length_sid
= 0;
9321 g_b_init_get_native_system_info
= 0;
9322 g_b_init_get_system_times
= 0;
9323 g_b_init_create_symbolic_link_w
= 0;
9324 g_b_init_create_symbolic_link_a
= 0;
9325 g_b_init_get_security_descriptor_dacl
= 0;
9326 g_b_init_convert_sd_to_sddl
= 0;
9327 g_b_init_convert_sddl_to_sd
= 0;
9328 g_b_init_is_valid_security_descriptor
= 0;
9329 g_b_init_set_file_security_w
= 0;
9330 g_b_init_set_file_security_a
= 0;
9331 g_b_init_set_named_security_info_w
= 0;
9332 g_b_init_set_named_security_info_a
= 0;
9333 g_b_init_get_adapters_info
= 0;
9334 g_b_init_compare_string_w
= 0;
9335 num_of_processors
= 0;
9336 /* The following sets a handler for shutdown notifications for
9337 console apps. This actually applies to Emacs in both console and
9338 GUI modes, since we had to fool windows into thinking emacs is a
9339 console application to get console mode to work. */
9340 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
9342 /* "None" is the default group name on standalone workstations. */
9343 strcpy (dflt_group_name
, "None");
9345 /* Reset, in case it has some value inherited from dump time. */
9346 w32_stat_get_owner_group
= 0;
9348 /* If w32_unicode_filenames is non-zero, we will be using Unicode
9349 (a.k.a. "wide") APIs to invoke functions that accept file
9351 if (is_windows_9x ())
9352 w32_unicode_filenames
= 0;
9354 w32_unicode_filenames
= 1;
9357 /* For make-serial-process */
9359 serial_open (Lisp_Object port_obj
)
9361 char *port
= SSDATA (port_obj
);
9366 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
9367 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
9368 if (hnd
== INVALID_HANDLE_VALUE
)
9369 error ("Could not open %s", port
);
9370 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
9372 error ("Could not open %s", port
);
9376 error ("Could not create child process");
9378 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
9379 fd_info
[ fd
].hnd
= hnd
;
9380 fd_info
[ fd
].flags
|=
9381 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
9382 if (fd_info
[ fd
].cp
!= NULL
)
9384 error ("fd_info[fd = %d] is already in use", fd
);
9386 fd_info
[ fd
].cp
= cp
;
9387 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9388 if (cp
->ovl_read
.hEvent
== NULL
)
9389 error ("Could not create read event");
9390 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
9391 if (cp
->ovl_write
.hEvent
== NULL
)
9392 error ("Could not create write event");
9397 /* For serial-process-configure */
9399 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
9401 Lisp_Object childp2
= Qnil
;
9402 Lisp_Object tem
= Qnil
;
9406 char summary
[4] = "???"; /* This usually becomes "8N1". */
9408 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
9409 error ("Not a serial process");
9410 hnd
= fd_info
[ p
->outfd
].hnd
;
9412 childp2
= Fcopy_sequence (p
->childp
);
9414 /* Initialize timeouts for blocking read and blocking write. */
9415 if (!GetCommTimeouts (hnd
, &ct
))
9416 error ("GetCommTimeouts() failed");
9417 ct
.ReadIntervalTimeout
= 0;
9418 ct
.ReadTotalTimeoutMultiplier
= 0;
9419 ct
.ReadTotalTimeoutConstant
= 0;
9420 ct
.WriteTotalTimeoutMultiplier
= 0;
9421 ct
.WriteTotalTimeoutConstant
= 0;
9422 if (!SetCommTimeouts (hnd
, &ct
))
9423 error ("SetCommTimeouts() failed");
9424 /* Read port attributes and prepare default configuration. */
9425 memset (&dcb
, 0, sizeof (dcb
));
9426 dcb
.DCBlength
= sizeof (DCB
);
9427 if (!GetCommState (hnd
, &dcb
))
9428 error ("GetCommState() failed");
9431 dcb
.fAbortOnError
= FALSE
;
9432 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
9437 /* Configure speed. */
9438 if (!NILP (Fplist_member (contact
, QCspeed
)))
9439 tem
= Fplist_get (contact
, QCspeed
);
9441 tem
= Fplist_get (p
->childp
, QCspeed
);
9443 dcb
.BaudRate
= XINT (tem
);
9444 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
9446 /* Configure bytesize. */
9447 if (!NILP (Fplist_member (contact
, QCbytesize
)))
9448 tem
= Fplist_get (contact
, QCbytesize
);
9450 tem
= Fplist_get (p
->childp
, QCbytesize
);
9452 tem
= make_number (8);
9454 if (XINT (tem
) != 7 && XINT (tem
) != 8)
9455 error (":bytesize must be nil (8), 7, or 8");
9456 dcb
.ByteSize
= XINT (tem
);
9457 summary
[0] = XINT (tem
) + '0';
9458 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
9460 /* Configure parity. */
9461 if (!NILP (Fplist_member (contact
, QCparity
)))
9462 tem
= Fplist_get (contact
, QCparity
);
9464 tem
= Fplist_get (p
->childp
, QCparity
);
9465 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
9466 error (":parity must be nil (no parity), `even', or `odd'");
9467 dcb
.fParity
= FALSE
;
9468 dcb
.Parity
= NOPARITY
;
9469 dcb
.fErrorChar
= FALSE
;
9474 else if (EQ (tem
, Qeven
))
9478 dcb
.Parity
= EVENPARITY
;
9479 dcb
.fErrorChar
= TRUE
;
9481 else if (EQ (tem
, Qodd
))
9485 dcb
.Parity
= ODDPARITY
;
9486 dcb
.fErrorChar
= TRUE
;
9488 childp2
= Fplist_put (childp2
, QCparity
, tem
);
9490 /* Configure stopbits. */
9491 if (!NILP (Fplist_member (contact
, QCstopbits
)))
9492 tem
= Fplist_get (contact
, QCstopbits
);
9494 tem
= Fplist_get (p
->childp
, QCstopbits
);
9496 tem
= make_number (1);
9498 if (XINT (tem
) != 1 && XINT (tem
) != 2)
9499 error (":stopbits must be nil (1 stopbit), 1, or 2");
9500 summary
[2] = XINT (tem
) + '0';
9501 if (XINT (tem
) == 1)
9502 dcb
.StopBits
= ONESTOPBIT
;
9503 else if (XINT (tem
) == 2)
9504 dcb
.StopBits
= TWOSTOPBITS
;
9505 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
9507 /* Configure flowcontrol. */
9508 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
9509 tem
= Fplist_get (contact
, QCflowcontrol
);
9511 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
9512 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
9513 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
9514 dcb
.fOutxCtsFlow
= FALSE
;
9515 dcb
.fOutxDsrFlow
= FALSE
;
9516 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
9517 dcb
.fDsrSensitivity
= FALSE
;
9518 dcb
.fTXContinueOnXoff
= FALSE
;
9521 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
9522 dcb
.XonChar
= 17; /* Control-Q */
9523 dcb
.XoffChar
= 19; /* Control-S */
9526 /* Already configured. */
9528 else if (EQ (tem
, Qhw
))
9530 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
9531 dcb
.fOutxCtsFlow
= TRUE
;
9533 else if (EQ (tem
, Qsw
))
9538 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
9540 /* Activate configuration. */
9541 if (!SetCommState (hnd
, &dcb
))
9542 error ("SetCommState() failed");
9544 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
9545 pset_childp (p
, childp2
);
9548 /* For make-pipe-process */
9550 register_aux_fd (int infd
)
9556 error ("Could not create child process");
9558 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
9560 if (fd_info
[ infd
].cp
!= NULL
)
9562 error ("fd_info[fd = %d] is already in use", infd
);
9564 fd_info
[ infd
].cp
= cp
;
9565 fd_info
[ infd
].hnd
= (HANDLE
) _get_osfhandle (infd
);
9571 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
9574 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9575 int fd
= process
->infd
;
9577 n
= sys_read (fd
, (char*)buf
, sz
);
9584 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9585 if (err
== EWOULDBLOCK
)
9588 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
9594 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
9596 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
9597 int fd
= process
->outfd
;
9598 ssize_t n
= sys_write (fd
, buf
, sz
);
9600 /* 0 or more bytes written means everything went fine. */
9604 /* Negative bytes written means we got an error in errno.
9605 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
9606 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
9607 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
9611 #endif /* HAVE_GNUTLS */