1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994-1995, 2000-2013 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22 #include <stddef.h> /* for offsetof */
25 #include <float.h> /* for DBL_EPSILON */
32 #include <time.h> /* must be before nt/inc/sys/time.h, for MinGW64 */
34 #include <sys/utime.h>
37 /* must include CRT headers *before* config.h */
40 #include <mbstring.h> /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
67 #include "epaths.h" /* for SHELL */
72 /* MinGW64 (_W64) defines these in its _mingw.h. */
73 #if defined(__GNUC__) && !defined(_W64)
74 #define _ANONYMOUS_UNION
75 #define _ANONYMOUS_STRUCT
78 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
79 use a different name to avoid compilation problems. */
80 typedef struct _MEMORY_STATUS_EX
{
83 DWORDLONG ullTotalPhys
;
84 DWORDLONG ullAvailPhys
;
85 DWORDLONG ullTotalPageFile
;
86 DWORDLONG ullAvailPageFile
;
87 DWORDLONG ullTotalVirtual
;
88 DWORDLONG ullAvailVirtual
;
89 DWORDLONG ullAvailExtendedVirtual
;
90 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
100 #if _WIN32_WINNT < 0x0500
101 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
102 /* This either is not in psapi.h or guarded by higher value of
103 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
104 defines it in psapi.h */
105 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
107 DWORD PageFaultCount
;
108 SIZE_T PeakWorkingSetSize
;
109 SIZE_T WorkingSetSize
;
110 SIZE_T QuotaPeakPagedPoolUsage
;
111 SIZE_T QuotaPagedPoolUsage
;
112 SIZE_T QuotaPeakNonPagedPoolUsage
;
113 SIZE_T QuotaNonPagedPoolUsage
;
114 SIZE_T PagefileUsage
;
115 SIZE_T PeakPagefileUsage
;
117 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
121 #include <winioctl.h>
127 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
128 define them by hand if not already defined. */
129 #ifndef SDDL_REVISION_1
130 #define SDDL_REVISION_1 1
131 #endif /* SDDL_REVISION_1 */
133 #if defined(_MSC_VER) || defined(_W64)
134 /* MSVC and MinGW64 don't provide the definition of
135 REPARSE_DATA_BUFFER and the associated macros, except on ntifs.h,
136 which cannot be included because it triggers conflicts with other
137 Windows API headers. So we define it here by hand. */
139 typedef struct _REPARSE_DATA_BUFFER
{
141 USHORT ReparseDataLength
;
145 USHORT SubstituteNameOffset
;
146 USHORT SubstituteNameLength
;
147 USHORT PrintNameOffset
;
148 USHORT PrintNameLength
;
151 } SymbolicLinkReparseBuffer
;
153 USHORT SubstituteNameOffset
;
154 USHORT SubstituteNameLength
;
155 USHORT PrintNameOffset
;
156 USHORT PrintNameLength
;
158 } MountPointReparseBuffer
;
161 } GenericReparseBuffer
;
163 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
165 #ifndef FILE_DEVICE_FILE_SYSTEM
166 #define FILE_DEVICE_FILE_SYSTEM 9
168 #ifndef METHOD_BUFFERED
169 #define METHOD_BUFFERED 0
171 #ifndef FILE_ANY_ACCESS
172 #define FILE_ANY_ACCESS 0x00000000
175 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
177 /* MinGW64 defines FSCTL_GET_REPARSE_POINT on winioctl.h. */
178 #ifndef FSCTL_GET_REPARSE_POINT
179 #define FSCTL_GET_REPARSE_POINT \
180 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
184 /* TCP connection support. */
185 #include <sys/socket.h>
206 #include "w32common.h"
208 #include "w32select.h"
210 #include "dispextern.h" /* for xstrcasecmp */
211 #include "coding.h" /* for Vlocale_coding_system */
213 #include "careadlinkat.h"
214 #include "allocator.h"
216 /* For serial_configure and serial_open. */
219 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
220 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
222 Lisp_Object QCloaded_from
;
224 void globals_of_w32 (void);
225 static DWORD
get_rid (PSID
);
226 static int is_symlink (const char *);
227 static char * chase_symlinks (const char *);
228 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
229 static int restore_privilege (TOKEN_PRIVILEGES
*);
230 static BOOL WINAPI
revert_to_self (void);
232 extern int sys_access (const char *, int);
233 extern void *e_malloc (size_t);
234 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
235 EMACS_TIME
*, void *);
236 extern int sys_dup (int);
241 /* Initialization states.
243 WARNING: If you add any more such variables for additional APIs,
244 you MUST add initialization for them to globals_of_w32
245 below. This is because these variables might get set
246 to non-NULL values during dumping, but the dumped Emacs
247 cannot reuse those values, because it could be run on a
248 different version of the OS, where API addresses are
250 static BOOL g_b_init_is_windows_9x
;
251 static BOOL g_b_init_open_process_token
;
252 static BOOL g_b_init_get_token_information
;
253 static BOOL g_b_init_lookup_account_sid
;
254 static BOOL g_b_init_get_sid_sub_authority
;
255 static BOOL g_b_init_get_sid_sub_authority_count
;
256 static BOOL g_b_init_get_security_info
;
257 static BOOL g_b_init_get_file_security
;
258 static BOOL g_b_init_get_security_descriptor_owner
;
259 static BOOL g_b_init_get_security_descriptor_group
;
260 static BOOL g_b_init_is_valid_sid
;
261 static BOOL g_b_init_create_toolhelp32_snapshot
;
262 static BOOL g_b_init_process32_first
;
263 static BOOL g_b_init_process32_next
;
264 static BOOL g_b_init_open_thread_token
;
265 static BOOL g_b_init_impersonate_self
;
266 static BOOL g_b_init_revert_to_self
;
267 static BOOL g_b_init_get_process_memory_info
;
268 static BOOL g_b_init_get_process_working_set_size
;
269 static BOOL g_b_init_global_memory_status
;
270 static BOOL g_b_init_global_memory_status_ex
;
271 static BOOL g_b_init_get_length_sid
;
272 static BOOL g_b_init_equal_sid
;
273 static BOOL g_b_init_copy_sid
;
274 static BOOL g_b_init_get_native_system_info
;
275 static BOOL g_b_init_get_system_times
;
276 static BOOL g_b_init_create_symbolic_link
;
277 static BOOL g_b_init_get_security_descriptor_dacl
;
278 static BOOL g_b_init_convert_sd_to_sddl
;
279 static BOOL g_b_init_convert_sddl_to_sd
;
280 static BOOL g_b_init_is_valid_security_descriptor
;
281 static BOOL g_b_init_set_file_security
;
284 BEGIN: Wrapper functions around OpenProcessToken
285 and other functions in advapi32.dll that are only
286 supported in Windows NT / 2k / XP
288 /* ** Function pointer typedefs ** */
289 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
290 HANDLE ProcessHandle
,
292 PHANDLE TokenHandle
);
293 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
295 TOKEN_INFORMATION_CLASS TokenInformationClass
,
296 LPVOID TokenInformation
,
297 DWORD TokenInformationLength
,
298 PDWORD ReturnLength
);
299 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
300 HANDLE process_handle
,
301 LPFILETIME creation_time
,
302 LPFILETIME exit_time
,
303 LPFILETIME kernel_time
,
304 LPFILETIME user_time
);
306 GetProcessTimes_Proc get_process_times_fn
= NULL
;
309 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
310 const char * const GetFileSecurity_Name
= "GetFileSecurityW";
311 const char * const SetFileSecurity_Name
= "SetFileSecurityW";
313 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
314 const char * const GetFileSecurity_Name
= "GetFileSecurityA";
315 const char * const SetFileSecurity_Name
= "SetFileSecurityA";
317 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
318 LPCTSTR lpSystemName
,
323 LPDWORD cbDomainName
,
324 PSID_NAME_USE peUse
);
325 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
328 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
330 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
332 SE_OBJECT_TYPE ObjectType
,
333 SECURITY_INFORMATION SecurityInfo
,
338 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
339 typedef BOOL (WINAPI
* GetFileSecurity_Proc
) (
341 SECURITY_INFORMATION RequestedInformation
,
342 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
344 LPDWORD lpnLengthNeeded
);
345 typedef BOOL (WINAPI
*SetFileSecurity_Proc
) (
347 SECURITY_INFORMATION SecurityInformation
,
348 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
349 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
350 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
352 LPBOOL lpbOwnerDefaulted
);
353 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
354 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
356 LPBOOL lpbGroupDefaulted
);
357 typedef BOOL (WINAPI
*GetSecurityDescriptorDacl_Proc
) (
358 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
359 LPBOOL lpbDaclPresent
,
361 LPBOOL lpbDaclDefaulted
);
362 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
364 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
366 DWORD th32ProcessID
);
367 typedef BOOL (WINAPI
* Process32First_Proc
) (
369 LPPROCESSENTRY32 lppe
);
370 typedef BOOL (WINAPI
* Process32Next_Proc
) (
372 LPPROCESSENTRY32 lppe
);
373 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
377 PHANDLE TokenHandle
);
378 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
379 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
380 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
381 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
383 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
385 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
387 PSIZE_T lpMinimumWorkingSetSize
,
388 PSIZE_T lpMaximumWorkingSetSize
);
389 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
390 LPMEMORYSTATUS lpBuffer
);
391 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
392 LPMEMORY_STATUS_EX lpBuffer
);
393 typedef BOOL (WINAPI
* CopySid_Proc
) (
394 DWORD nDestinationSidLength
,
395 PSID pDestinationSid
,
397 typedef BOOL (WINAPI
* EqualSid_Proc
) (
400 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
402 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
403 LPSYSTEM_INFO lpSystemInfo
);
404 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
405 LPFILETIME lpIdleTime
,
406 LPFILETIME lpKernelTime
,
407 LPFILETIME lpUserTime
);
408 typedef BOOLEAN (WINAPI
*CreateSymbolicLink_Proc
) (
409 LPTSTR lpSymlinkFileName
,
410 LPTSTR lpTargetFileName
,
412 typedef BOOL (WINAPI
*ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
) (
413 LPCTSTR StringSecurityDescriptor
,
414 DWORD StringSDRevision
,
415 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
416 PULONG SecurityDescriptorSize
);
417 typedef BOOL (WINAPI
*ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
) (
418 PSECURITY_DESCRIPTOR SecurityDescriptor
,
419 DWORD RequestedStringSDRevision
,
420 SECURITY_INFORMATION SecurityInformation
,
421 LPTSTR
*StringSecurityDescriptor
,
422 PULONG StringSecurityDescriptorLen
);
423 typedef BOOL (WINAPI
*IsValidSecurityDescriptor_Proc
) (PSECURITY_DESCRIPTOR
);
425 /* ** A utility function ** */
429 static BOOL s_b_ret
= 0;
430 OSVERSIONINFO os_ver
;
431 if (g_b_init_is_windows_9x
== 0)
433 g_b_init_is_windows_9x
= 1;
434 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
435 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
436 if (GetVersionEx (&os_ver
))
438 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
444 static Lisp_Object
ltime (ULONGLONG
);
446 /* Get total user and system times for get-internal-run-time.
447 Returns a list of integers if the times are provided by the OS
448 (NT derivatives), otherwise it returns the result of current-time. */
450 w32_get_internal_run_time (void)
452 if (get_process_times_fn
)
454 FILETIME create
, exit
, kernel
, user
;
455 HANDLE proc
= GetCurrentProcess ();
456 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
458 LARGE_INTEGER user_int
, kernel_int
, total
;
459 user_int
.LowPart
= user
.dwLowDateTime
;
460 user_int
.HighPart
= user
.dwHighDateTime
;
461 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
462 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
463 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
464 return ltime (total
.QuadPart
);
468 return Fcurrent_time ();
471 /* ** The wrapper functions ** */
474 open_process_token (HANDLE ProcessHandle
,
478 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
479 HMODULE hm_advapi32
= NULL
;
480 if (is_windows_9x () == TRUE
)
484 if (g_b_init_open_process_token
== 0)
486 g_b_init_open_process_token
= 1;
487 hm_advapi32
= LoadLibrary ("Advapi32.dll");
488 s_pfn_Open_Process_Token
=
489 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
491 if (s_pfn_Open_Process_Token
== NULL
)
496 s_pfn_Open_Process_Token (
504 get_token_information (HANDLE TokenHandle
,
505 TOKEN_INFORMATION_CLASS TokenInformationClass
,
506 LPVOID TokenInformation
,
507 DWORD TokenInformationLength
,
510 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
511 HMODULE hm_advapi32
= NULL
;
512 if (is_windows_9x () == TRUE
)
516 if (g_b_init_get_token_information
== 0)
518 g_b_init_get_token_information
= 1;
519 hm_advapi32
= LoadLibrary ("Advapi32.dll");
520 s_pfn_Get_Token_Information
=
521 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
523 if (s_pfn_Get_Token_Information
== NULL
)
528 s_pfn_Get_Token_Information (
530 TokenInformationClass
,
532 TokenInformationLength
,
538 lookup_account_sid (LPCTSTR lpSystemName
,
543 LPDWORD cbDomainName
,
546 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
547 HMODULE hm_advapi32
= NULL
;
548 if (is_windows_9x () == TRUE
)
552 if (g_b_init_lookup_account_sid
== 0)
554 g_b_init_lookup_account_sid
= 1;
555 hm_advapi32
= LoadLibrary ("Advapi32.dll");
556 s_pfn_Lookup_Account_Sid
=
557 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
559 if (s_pfn_Lookup_Account_Sid
== NULL
)
564 s_pfn_Lookup_Account_Sid (
576 get_sid_sub_authority (PSID pSid
, DWORD n
)
578 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
579 static DWORD zero
= 0U;
580 HMODULE hm_advapi32
= NULL
;
581 if (is_windows_9x () == TRUE
)
585 if (g_b_init_get_sid_sub_authority
== 0)
587 g_b_init_get_sid_sub_authority
= 1;
588 hm_advapi32
= LoadLibrary ("Advapi32.dll");
589 s_pfn_Get_Sid_Sub_Authority
=
590 (GetSidSubAuthority_Proc
) GetProcAddress (
591 hm_advapi32
, "GetSidSubAuthority");
593 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
597 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
601 get_sid_sub_authority_count (PSID pSid
)
603 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
604 static UCHAR zero
= 0U;
605 HMODULE hm_advapi32
= NULL
;
606 if (is_windows_9x () == TRUE
)
610 if (g_b_init_get_sid_sub_authority_count
== 0)
612 g_b_init_get_sid_sub_authority_count
= 1;
613 hm_advapi32
= LoadLibrary ("Advapi32.dll");
614 s_pfn_Get_Sid_Sub_Authority_Count
=
615 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
616 hm_advapi32
, "GetSidSubAuthorityCount");
618 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
622 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
626 get_security_info (HANDLE handle
,
627 SE_OBJECT_TYPE ObjectType
,
628 SECURITY_INFORMATION SecurityInfo
,
633 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
635 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
636 HMODULE hm_advapi32
= NULL
;
637 if (is_windows_9x () == TRUE
)
641 if (g_b_init_get_security_info
== 0)
643 g_b_init_get_security_info
= 1;
644 hm_advapi32
= LoadLibrary ("Advapi32.dll");
645 s_pfn_Get_Security_Info
=
646 (GetSecurityInfo_Proc
) GetProcAddress (
647 hm_advapi32
, "GetSecurityInfo");
649 if (s_pfn_Get_Security_Info
== NULL
)
653 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
654 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
655 ppSecurityDescriptor
));
659 get_file_security (LPCTSTR lpFileName
,
660 SECURITY_INFORMATION RequestedInformation
,
661 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
663 LPDWORD lpnLengthNeeded
)
665 static GetFileSecurity_Proc s_pfn_Get_File_Security
= NULL
;
666 HMODULE hm_advapi32
= NULL
;
667 if (is_windows_9x () == TRUE
)
672 if (g_b_init_get_file_security
== 0)
674 g_b_init_get_file_security
= 1;
675 hm_advapi32
= LoadLibrary ("Advapi32.dll");
676 s_pfn_Get_File_Security
=
677 (GetFileSecurity_Proc
) GetProcAddress (
678 hm_advapi32
, GetFileSecurity_Name
);
680 if (s_pfn_Get_File_Security
== NULL
)
685 return (s_pfn_Get_File_Security (lpFileName
, RequestedInformation
,
686 pSecurityDescriptor
, nLength
,
691 set_file_security (LPCTSTR lpFileName
,
692 SECURITY_INFORMATION SecurityInformation
,
693 PSECURITY_DESCRIPTOR pSecurityDescriptor
)
695 static SetFileSecurity_Proc s_pfn_Set_File_Security
= NULL
;
696 HMODULE hm_advapi32
= NULL
;
697 if (is_windows_9x () == TRUE
)
702 if (g_b_init_set_file_security
== 0)
704 g_b_init_set_file_security
= 1;
705 hm_advapi32
= LoadLibrary ("Advapi32.dll");
706 s_pfn_Set_File_Security
=
707 (SetFileSecurity_Proc
) GetProcAddress (
708 hm_advapi32
, SetFileSecurity_Name
);
710 if (s_pfn_Set_File_Security
== NULL
)
715 return (s_pfn_Set_File_Security (lpFileName
, SecurityInformation
,
716 pSecurityDescriptor
));
720 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
722 LPBOOL lpbOwnerDefaulted
)
724 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
725 HMODULE hm_advapi32
= NULL
;
726 if (is_windows_9x () == TRUE
)
731 if (g_b_init_get_security_descriptor_owner
== 0)
733 g_b_init_get_security_descriptor_owner
= 1;
734 hm_advapi32
= LoadLibrary ("Advapi32.dll");
735 s_pfn_Get_Security_Descriptor_Owner
=
736 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
737 hm_advapi32
, "GetSecurityDescriptorOwner");
739 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
744 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
749 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
751 LPBOOL lpbGroupDefaulted
)
753 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
754 HMODULE hm_advapi32
= NULL
;
755 if (is_windows_9x () == TRUE
)
760 if (g_b_init_get_security_descriptor_group
== 0)
762 g_b_init_get_security_descriptor_group
= 1;
763 hm_advapi32
= LoadLibrary ("Advapi32.dll");
764 s_pfn_Get_Security_Descriptor_Group
=
765 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
766 hm_advapi32
, "GetSecurityDescriptorGroup");
768 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
773 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
778 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
779 LPBOOL lpbDaclPresent
,
781 LPBOOL lpbDaclDefaulted
)
783 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl
= NULL
;
784 HMODULE hm_advapi32
= NULL
;
785 if (is_windows_9x () == TRUE
)
790 if (g_b_init_get_security_descriptor_dacl
== 0)
792 g_b_init_get_security_descriptor_dacl
= 1;
793 hm_advapi32
= LoadLibrary ("Advapi32.dll");
794 s_pfn_Get_Security_Descriptor_Dacl
=
795 (GetSecurityDescriptorDacl_Proc
) GetProcAddress (
796 hm_advapi32
, "GetSecurityDescriptorDacl");
798 if (s_pfn_Get_Security_Descriptor_Dacl
== NULL
)
803 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor
,
804 lpbDaclPresent
, pDacl
,
809 is_valid_sid (PSID sid
)
811 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
812 HMODULE hm_advapi32
= NULL
;
813 if (is_windows_9x () == TRUE
)
817 if (g_b_init_is_valid_sid
== 0)
819 g_b_init_is_valid_sid
= 1;
820 hm_advapi32
= LoadLibrary ("Advapi32.dll");
822 (IsValidSid_Proc
) GetProcAddress (
823 hm_advapi32
, "IsValidSid");
825 if (s_pfn_Is_Valid_Sid
== NULL
)
829 return (s_pfn_Is_Valid_Sid (sid
));
833 equal_sid (PSID sid1
, PSID sid2
)
835 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
836 HMODULE hm_advapi32
= NULL
;
837 if (is_windows_9x () == TRUE
)
841 if (g_b_init_equal_sid
== 0)
843 g_b_init_equal_sid
= 1;
844 hm_advapi32
= LoadLibrary ("Advapi32.dll");
846 (EqualSid_Proc
) GetProcAddress (
847 hm_advapi32
, "EqualSid");
849 if (s_pfn_Equal_Sid
== NULL
)
853 return (s_pfn_Equal_Sid (sid1
, sid2
));
857 get_length_sid (PSID sid
)
859 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
860 HMODULE hm_advapi32
= NULL
;
861 if (is_windows_9x () == TRUE
)
865 if (g_b_init_get_length_sid
== 0)
867 g_b_init_get_length_sid
= 1;
868 hm_advapi32
= LoadLibrary ("Advapi32.dll");
869 s_pfn_Get_Length_Sid
=
870 (GetLengthSid_Proc
) GetProcAddress (
871 hm_advapi32
, "GetLengthSid");
873 if (s_pfn_Get_Length_Sid
== NULL
)
877 return (s_pfn_Get_Length_Sid (sid
));
881 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
883 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
884 HMODULE hm_advapi32
= NULL
;
885 if (is_windows_9x () == TRUE
)
889 if (g_b_init_copy_sid
== 0)
891 g_b_init_copy_sid
= 1;
892 hm_advapi32
= LoadLibrary ("Advapi32.dll");
894 (CopySid_Proc
) GetProcAddress (
895 hm_advapi32
, "CopySid");
897 if (s_pfn_Copy_Sid
== NULL
)
901 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
905 END: Wrapper functions around OpenProcessToken
906 and other functions in advapi32.dll that are only
907 supported in Windows NT / 2k / XP
911 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
913 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
914 if (is_windows_9x () != TRUE
)
916 if (g_b_init_get_native_system_info
== 0)
918 g_b_init_get_native_system_info
= 1;
919 s_pfn_Get_Native_System_Info
=
920 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
921 "GetNativeSystemInfo");
923 if (s_pfn_Get_Native_System_Info
!= NULL
)
924 s_pfn_Get_Native_System_Info (lpSystemInfo
);
927 lpSystemInfo
->dwNumberOfProcessors
= -1;
931 get_system_times (LPFILETIME lpIdleTime
,
932 LPFILETIME lpKernelTime
,
933 LPFILETIME lpUserTime
)
935 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
936 if (is_windows_9x () == TRUE
)
940 if (g_b_init_get_system_times
== 0)
942 g_b_init_get_system_times
= 1;
943 s_pfn_Get_System_times
=
944 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
947 if (s_pfn_Get_System_times
== NULL
)
949 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
952 static BOOLEAN WINAPI
953 create_symbolic_link (LPTSTR lpSymlinkFilename
,
954 LPTSTR lpTargetFileName
,
957 static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link
= NULL
;
960 if (is_windows_9x () == TRUE
)
965 if (g_b_init_create_symbolic_link
== 0)
967 g_b_init_create_symbolic_link
= 1;
969 s_pfn_Create_Symbolic_Link
=
970 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
971 "CreateSymbolicLinkW");
973 s_pfn_Create_Symbolic_Link
=
974 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
975 "CreateSymbolicLinkA");
978 if (s_pfn_Create_Symbolic_Link
== NULL
)
984 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
986 /* If we were denied creation of the symlink, try again after
987 enabling the SeCreateSymbolicLinkPrivilege for our process. */
990 TOKEN_PRIVILEGES priv_current
;
992 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
, &priv_current
))
994 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
996 restore_privilege (&priv_current
);
1004 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor
)
1006 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc
= NULL
;
1008 if (is_windows_9x () == TRUE
)
1014 if (g_b_init_is_valid_security_descriptor
== 0)
1016 g_b_init_is_valid_security_descriptor
= 1;
1017 s_pfn_Is_Valid_Security_Descriptor_Proc
=
1018 (IsValidSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1019 "IsValidSecurityDescriptor");
1021 if (s_pfn_Is_Valid_Security_Descriptor_Proc
== NULL
)
1027 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor
);
1031 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor
,
1032 DWORD RequestedStringSDRevision
,
1033 SECURITY_INFORMATION SecurityInformation
,
1034 LPTSTR
*StringSecurityDescriptor
,
1035 PULONG StringSecurityDescriptorLen
)
1037 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL
= NULL
;
1040 if (is_windows_9x () == TRUE
)
1046 if (g_b_init_convert_sd_to_sddl
== 0)
1048 g_b_init_convert_sd_to_sddl
= 1;
1050 s_pfn_Convert_SD_To_SDDL
=
1051 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1052 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1054 s_pfn_Convert_SD_To_SDDL
=
1055 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1056 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1059 if (s_pfn_Convert_SD_To_SDDL
== NULL
)
1065 retval
= s_pfn_Convert_SD_To_SDDL (SecurityDescriptor
,
1066 RequestedStringSDRevision
,
1067 SecurityInformation
,
1068 StringSecurityDescriptor
,
1069 StringSecurityDescriptorLen
);
1075 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor
,
1076 DWORD StringSDRevision
,
1077 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
1078 PULONG SecurityDescriptorSize
)
1080 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD
= NULL
;
1083 if (is_windows_9x () == TRUE
)
1089 if (g_b_init_convert_sddl_to_sd
== 0)
1091 g_b_init_convert_sddl_to_sd
= 1;
1093 s_pfn_Convert_SDDL_To_SD
=
1094 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1095 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1097 s_pfn_Convert_SDDL_To_SD
=
1098 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1099 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1102 if (s_pfn_Convert_SDDL_To_SD
== NULL
)
1108 retval
= s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor
,
1111 SecurityDescriptorSize
);
1118 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1119 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1121 This is called from alloc.c:valid_pointer_p. */
1123 w32_valid_pointer_p (void *p
, int size
)
1126 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
1130 unsigned char *buf
= alloca (size
);
1131 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
1140 static char startup_dir
[MAXPATHLEN
];
1142 /* Get the current working directory. */
1144 getcwd (char *dir
, int dirsize
)
1151 if (dirsize
<= strlen (startup_dir
))
1157 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
1161 /* Emacs doesn't actually change directory itself, it stays in the
1162 same directory where it was started. */
1163 strcpy (dir
, startup_dir
);
1168 /* Emulate getloadavg. */
1170 struct load_sample
{
1177 /* Number of processors on this machine. */
1178 static unsigned num_of_processors
;
1180 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1181 static struct load_sample samples
[16*60];
1182 static int first_idx
= -1, last_idx
= -1;
1183 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
1188 int next_idx
= from
+ 1;
1190 if (next_idx
>= max_idx
)
1199 int prev_idx
= from
- 1;
1202 prev_idx
= max_idx
- 1;
1208 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
1210 SYSTEM_INFO sysinfo
;
1211 FILETIME ft_idle
, ft_user
, ft_kernel
;
1213 /* Initialize the number of processors on this machine. */
1214 if (num_of_processors
<= 0)
1216 get_native_system_info (&sysinfo
);
1217 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1218 if (num_of_processors
<= 0)
1220 GetSystemInfo (&sysinfo
);
1221 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1223 if (num_of_processors
<= 0)
1224 num_of_processors
= 1;
1227 /* TODO: Take into account threads that are ready to run, by
1228 sampling the "\System\Processor Queue Length" performance
1229 counter. The code below accounts only for threads that are
1230 actually running. */
1232 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
1234 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1236 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1237 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1238 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1239 *idle
= uidle
.QuadPart
;
1240 *kernel
= ukernel
.QuadPart
;
1241 *user
= uuser
.QuadPart
;
1251 /* Produce the load average for a given time interval, using the
1252 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1253 1-minute, 5-minute, or 15-minute average, respectively. */
1257 double retval
= -1.0;
1260 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1261 time_t now
= samples
[last_idx
].sample_time
;
1263 if (first_idx
!= last_idx
)
1265 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1267 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1268 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1271 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1272 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1273 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1275 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1278 if (idx
== first_idx
)
1287 getloadavg (double loadavg
[], int nelem
)
1290 ULONGLONG idle
, kernel
, user
;
1291 time_t now
= time (NULL
);
1293 /* Store another sample. We ignore samples that are less than 1 sec
1295 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
1297 sample_system_load (&idle
, &kernel
, &user
);
1298 last_idx
= buf_next (last_idx
);
1299 samples
[last_idx
].sample_time
= now
;
1300 samples
[last_idx
].idle
= idle
;
1301 samples
[last_idx
].kernel
= kernel
;
1302 samples
[last_idx
].user
= user
;
1303 /* If the buffer has more that 15 min worth of samples, discard
1305 if (first_idx
== -1)
1306 first_idx
= last_idx
;
1307 while (first_idx
!= last_idx
1308 && (difftime (now
, samples
[first_idx
].sample_time
)
1309 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1310 first_idx
= buf_next (first_idx
);
1313 for (elem
= 0; elem
< nelem
; elem
++)
1315 double avg
= getavg (elem
);
1319 loadavg
[elem
] = avg
;
1325 /* Emulate getpwuid, getpwnam and others. */
1327 #define PASSWD_FIELD_SIZE 256
1329 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1330 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1331 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1332 static char dflt_passwd_dir
[PASSWD_FIELD_SIZE
];
1333 static char dflt_passwd_shell
[PASSWD_FIELD_SIZE
];
1335 static struct passwd dflt_passwd
=
1347 static char dflt_group_name
[GNLEN
+1];
1349 static struct group dflt_group
=
1351 /* When group information is not available, we return this as the
1352 group for all files. */
1360 return dflt_passwd
.pw_uid
;
1366 /* I could imagine arguing for checking to see whether the user is
1367 in the Administrators group and returning a UID of 0 for that
1368 case, but I don't know how wise that would be in the long run. */
1375 return dflt_passwd
.pw_gid
;
1385 getpwuid (unsigned uid
)
1387 if (uid
== dflt_passwd
.pw_uid
)
1388 return &dflt_passwd
;
1393 getgrgid (gid_t gid
)
1399 getpwnam (char *name
)
1403 pw
= getpwuid (getuid ());
1407 if (xstrcasecmp (name
, pw
->pw_name
))
1414 init_user_info (void)
1416 /* Find the user's real name by opening the process token and
1417 looking up the name associated with the user-sid in that token.
1419 Use the relative portion of the identifier authority value from
1420 the user-sid as the user id value (same for group id using the
1421 primary group sid from the process token). */
1423 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1424 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1425 DWORD glength
= sizeof (gname
);
1426 HANDLE token
= NULL
;
1427 SID_NAME_USE user_type
;
1428 unsigned char *buf
= NULL
;
1430 TOKEN_USER user_token
;
1431 TOKEN_PRIMARY_GROUP group_token
;
1434 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1437 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1438 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1440 buf
= xmalloc (blen
);
1441 result
= get_token_information (token
, TokenUser
,
1442 (LPVOID
)buf
, blen
, &needed
);
1445 memcpy (&user_token
, buf
, sizeof (user_token
));
1446 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1448 domain
, &dlength
, &user_type
);
1456 strcpy (dflt_passwd
.pw_name
, uname
);
1457 /* Determine a reasonable uid value. */
1458 if (xstrcasecmp ("administrator", uname
) == 0)
1460 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1461 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1465 /* Use the last sub-authority value of the RID, the relative
1466 portion of the SID, as user/group ID. */
1467 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1469 /* Get group id and name. */
1470 result
= get_token_information (token
, TokenPrimaryGroup
,
1471 (LPVOID
)buf
, blen
, &needed
);
1472 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1474 buf
= xrealloc (buf
, blen
= needed
);
1475 result
= get_token_information (token
, TokenPrimaryGroup
,
1476 (LPVOID
)buf
, blen
, &needed
);
1480 memcpy (&group_token
, buf
, sizeof (group_token
));
1481 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1482 dlength
= sizeof (domain
);
1483 /* If we can get at the real Primary Group name, use that.
1484 Otherwise, the default group name was already set to
1485 "None" in globals_of_w32. */
1486 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1487 gname
, &glength
, NULL
, &dlength
,
1489 strcpy (dflt_group_name
, gname
);
1492 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1495 /* If security calls are not supported (presumably because we
1496 are running under Windows 9X), fallback to this: */
1497 else if (GetUserName (uname
, &ulength
))
1499 strcpy (dflt_passwd
.pw_name
, uname
);
1500 if (xstrcasecmp ("administrator", uname
) == 0)
1501 dflt_passwd
.pw_uid
= 0;
1503 dflt_passwd
.pw_uid
= 123;
1504 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1508 strcpy (dflt_passwd
.pw_name
, "unknown");
1509 dflt_passwd
.pw_uid
= 123;
1510 dflt_passwd
.pw_gid
= 123;
1512 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1514 /* Ensure HOME and SHELL are defined. */
1515 if (getenv ("HOME") == NULL
)
1517 if (getenv ("SHELL") == NULL
)
1520 /* Set dir and shell from environment variables. */
1521 strcpy (dflt_passwd
.pw_dir
, getenv ("HOME"));
1522 strcpy (dflt_passwd
.pw_shell
, getenv ("SHELL"));
1526 CloseHandle (token
);
1532 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1533 return ((rand () << 15) | rand ());
1542 /* Current codepage for encoding file names. */
1543 static int file_name_codepage
;
1545 /* Return the maximum length in bytes of a multibyte character
1546 sequence encoded in the current ANSI codepage. This is required to
1547 correctly walk the encoded file names one character at a time. */
1549 max_filename_mbslen (void)
1551 /* A simple cache to avoid calling GetCPInfo every time we need to
1552 normalize a file name. The file-name encoding is not supposed to
1553 be changed too frequently, if ever. */
1554 static Lisp_Object last_file_name_encoding
;
1555 static int last_max_mbslen
;
1556 Lisp_Object current_encoding
;
1558 current_encoding
= Vfile_name_coding_system
;
1559 if (NILP (current_encoding
))
1560 current_encoding
= Vdefault_file_name_coding_system
;
1562 if (!EQ (last_file_name_encoding
, current_encoding
))
1566 last_file_name_encoding
= current_encoding
;
1567 /* Default to the current ANSI codepage. */
1568 file_name_codepage
= w32_ansi_code_page
;
1569 if (!NILP (current_encoding
))
1571 char *cpname
= SDATA (SYMBOL_NAME (current_encoding
));
1572 char *cp
= NULL
, *end
;
1575 if (strncmp (cpname
, "cp", 2) == 0)
1577 else if (strncmp (cpname
, "windows-", 8) == 0)
1583 cpnum
= strtol (cp
, &end
, 10);
1584 if (cpnum
&& *end
== '\0' && end
- cp
>= 2)
1585 file_name_codepage
= cpnum
;
1589 if (!file_name_codepage
)
1590 file_name_codepage
= CP_ACP
; /* CP_ACP = 0, but let's not assume that */
1592 if (!GetCPInfo (file_name_codepage
, &cp_info
))
1594 file_name_codepage
= CP_ACP
;
1595 if (!GetCPInfo (file_name_codepage
, &cp_info
))
1598 last_max_mbslen
= cp_info
.MaxCharSize
;
1601 return last_max_mbslen
;
1604 /* Normalize filename by converting all path separators to
1605 the specified separator. Also conditionally convert upper
1606 case path name components to lower case. */
1609 normalize_filename (register char *fp
, char path_sep
, int multibyte
)
1613 int dbcs_p
= max_filename_mbslen () > 1;
1615 /* Multibyte file names are in the Emacs internal representation, so
1616 we can traverse them by bytes with no problems. */
1620 /* Always lower-case drive letters a-z, even if the filesystem
1621 preserves case in filenames.
1622 This is so filenames can be compared by string comparison
1623 functions that are case-sensitive. Even case-preserving filesystems
1624 do not distinguish case in drive letters. */
1626 p2
= CharNextExA (file_name_codepage
, fp
, 0);
1630 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
1636 if (multibyte
|| NILP (Vw32_downcase_file_names
))
1640 if (*fp
== '/' || *fp
== '\\')
1645 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1650 sep
= path_sep
; /* convert to this path separator */
1651 elem
= fp
; /* start of current path element */
1654 if (*fp
>= 'a' && *fp
<= 'z')
1655 elem
= 0; /* don't convert this element */
1657 if (*fp
== 0 || *fp
== ':')
1659 sep
= *fp
; /* restore current separator (or 0) */
1660 *fp
= '/'; /* after conversion of this element */
1663 if (*fp
== '/' || *fp
== '\\')
1665 if (elem
&& elem
!= fp
)
1667 *fp
= 0; /* temporary end of string */
1668 _mbslwr (elem
); /* while we convert to lower case */
1670 *fp
= sep
; /* convert (or restore) path separator */
1671 elem
= fp
+ 1; /* next element starts after separator */
1679 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1684 /* Destructively turn backslashes into slashes. MULTIBYTE non-zero
1685 means the file name is a multibyte string in Emacs's internal
1688 dostounix_filename (register char *p
, int multibyte
)
1690 normalize_filename (p
, '/', multibyte
);
1693 /* Destructively turn slashes into backslashes. */
1695 unixtodos_filename (register char *p
)
1697 normalize_filename (p
, '\\', 0);
1700 /* Remove all CR's that are followed by a LF.
1701 (From msdos.c...probably should figure out a way to share it,
1702 although this code isn't going to ever change.) */
1704 crlf_to_lf (register int n
, register unsigned char *buf
)
1706 unsigned char *np
= buf
;
1707 unsigned char *startp
= buf
;
1708 unsigned char *endp
= buf
+ n
;
1712 while (buf
< endp
- 1)
1716 if (*(++buf
) != 0x0a)
1727 /* Parse the root part of file name, if present. Return length and
1728 optionally store pointer to char after root. */
1730 parse_root (char * name
, char ** pPath
)
1732 char * start
= name
;
1737 /* find the root name of the volume if given */
1738 if (isalpha (name
[0]) && name
[1] == ':')
1740 /* skip past drive specifier */
1742 if (IS_DIRECTORY_SEP (name
[0]))
1745 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1748 int dbcs_p
= max_filename_mbslen () > 1;
1753 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1756 name
= CharNextExA (file_name_codepage
, name
, 0);
1761 if (IS_DIRECTORY_SEP (name
[0]))
1768 return name
- start
;
1771 /* Get long base name for name; name is assumed to be absolute. */
1773 get_long_basename (char * name
, char * buf
, int size
)
1775 WIN32_FIND_DATA find_data
;
1779 /* must be valid filename, no wild cards or other invalid characters */
1780 if (_mbspbrk (name
, "*?|<>\""))
1783 dir_handle
= FindFirstFile (name
, &find_data
);
1784 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1786 if ((len
= strlen (find_data
.cFileName
)) < size
)
1787 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1790 FindClose (dir_handle
);
1795 /* Get long name for file, if possible (assumed to be absolute). */
1797 w32_get_long_filename (char * name
, char * buf
, int size
)
1802 char full
[ MAX_PATH
];
1805 len
= strlen (name
);
1806 if (len
>= MAX_PATH
)
1809 /* Use local copy for destructive modification. */
1810 memcpy (full
, name
, len
+1);
1811 unixtodos_filename (full
);
1813 /* Copy root part verbatim. */
1814 len
= parse_root (full
, &p
);
1815 memcpy (o
, full
, len
);
1820 while (p
!= NULL
&& *p
)
1823 p
= _mbschr (q
, '\\');
1825 len
= get_long_basename (full
, o
, size
);
1848 is_unc_volume (const char *filename
)
1850 const char *ptr
= filename
;
1852 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1855 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1861 /* Emulate the Posix unsetenv. */
1863 unsetenv (const char *name
)
1869 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
1874 name_len
= strlen (name
);
1875 /* MS docs says an environment variable cannot be longer than 32K. */
1876 if (name_len
> 32767)
1881 /* It is safe to use 'alloca' with 32K size, since the stack is at
1882 least 2MB, and we set it to 8MB in the link command line. */
1883 var
= alloca (name_len
+ 2);
1884 strncpy (var
, name
, name_len
);
1885 var
[name_len
++] = '=';
1886 var
[name_len
] = '\0';
1887 return _putenv (var
);
1890 /* MS _putenv doesn't support removing a variable when the argument
1891 does not include the '=' character, so we fix that here. */
1893 sys_putenv (char *str
)
1895 const char *const name_end
= strchr (str
, '=');
1897 if (name_end
== NULL
)
1899 /* Remove the variable from the environment. */
1900 return unsetenv (str
);
1903 return _putenv (str
);
1906 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1909 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1912 HKEY hrootkey
= NULL
;
1915 /* Check both the current user and the local machine to see if
1916 we have any resources. */
1918 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1922 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1923 && (lpvalue
= xmalloc (cbData
)) != NULL
1924 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1926 RegCloseKey (hrootkey
);
1932 RegCloseKey (hrootkey
);
1935 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1939 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1940 && (lpvalue
= xmalloc (cbData
)) != NULL
1941 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1943 RegCloseKey (hrootkey
);
1949 RegCloseKey (hrootkey
);
1955 char *get_emacs_configuration (void);
1958 init_environment (char ** argv
)
1960 static const char * const tempdirs
[] = {
1961 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1966 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1968 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1969 temporary files and assume "/tmp" if $TMPDIR is unset, which
1970 will break on DOS/Windows. Refuse to work if we cannot find
1971 a directory, not even "c:/", usable for that purpose. */
1972 for (i
= 0; i
< imax
; i
++)
1974 const char *tmp
= tempdirs
[i
];
1977 tmp
= getenv (tmp
+ 1);
1978 /* Note that `access' can lie to us if the directory resides on a
1979 read-only filesystem, like CD-ROM or a write-protected floppy.
1980 The only way to be really sure is to actually create a file and
1981 see if it succeeds. But I think that's too much to ask. */
1983 /* MSVCRT's _access crashes with D_OK. */
1984 if (tmp
&& faccessat (AT_FDCWD
, tmp
, D_OK
, AT_EACCESS
) == 0)
1986 char * var
= alloca (strlen (tmp
) + 8);
1987 sprintf (var
, "TMPDIR=%s", tmp
);
1988 _putenv (strdup (var
));
1995 Fcons (build_string ("no usable temporary directories found!!"),
1997 "While setting TMPDIR: ");
1999 /* Check for environment variables and use registry settings if they
2000 don't exist. Fallback on default values where applicable. */
2005 char locale_name
[32];
2006 char default_home
[MAX_PATH
];
2009 static const struct env_entry
2015 /* If the default value is NULL, we will use the value from the
2016 outside environment or the Registry, but will not push the
2017 variable into the Emacs environment if it is defined neither
2018 in the Registry nor in the outside environment. */
2020 {"PRELOAD_WINSOCK", NULL
},
2021 {"emacs_dir", "C:/emacs"},
2022 {"EMACSLOADPATH", NULL
},
2023 {"SHELL", "cmdproxy.exe"}, /* perhaps it is somewhere on PATH */
2024 {"EMACSDATA", NULL
},
2025 {"EMACSPATH", NULL
},
2032 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2034 /* We need to copy dflt_envvars[] and work on the copy because we
2035 don't want the dumped Emacs to inherit the values of
2036 environment variables we saw during dumping (which could be on
2037 a different system). The defaults above must be left intact. */
2038 struct env_entry env_vars
[N_ENV_VARS
];
2040 for (i
= 0; i
< N_ENV_VARS
; i
++)
2041 env_vars
[i
] = dflt_envvars
[i
];
2043 /* For backwards compatibility, check if a .emacs file exists in C:/
2044 If not, then we can try to default to the appdata directory under the
2045 user's profile, which is more likely to be writable. */
2046 if (!check_existing ("C:/.emacs"))
2048 HRESULT profile_result
;
2049 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2050 of Windows 95 and NT4 that have not been updated to include
2052 ShGetFolderPath_fn get_folder_path
;
2053 get_folder_path
= (ShGetFolderPath_fn
)
2054 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2056 if (get_folder_path
!= NULL
)
2058 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2061 /* If we can't get the appdata dir, revert to old behavior. */
2062 if (profile_result
== S_OK
)
2064 env_vars
[0].def_value
= default_home
;
2070 /* Get default locale info and use it for LANG. */
2071 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2072 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2073 locale_name
, sizeof (locale_name
)))
2075 for (i
= 0; i
< N_ENV_VARS
; i
++)
2077 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2079 env_vars
[i
].def_value
= locale_name
;
2085 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2087 /* Treat emacs_dir specially: set it unconditionally based on our
2091 char modname
[MAX_PATH
];
2093 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2095 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
2099 if ((p
= _mbsrchr (modname
, '\\'))
2100 /* From bin means installed Emacs, from src means uninstalled. */
2101 && (xstrcasecmp (p
, "\\bin") == 0 || xstrcasecmp (p
, "\\src") == 0))
2103 char buf
[SET_ENV_BUF_SIZE
];
2104 int within_build_tree
= xstrcasecmp (p
, "\\src") == 0;
2107 for (p
= modname
; *p
; p
= CharNext (p
))
2108 if (*p
== '\\') *p
= '/';
2110 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2111 _putenv (strdup (buf
));
2112 /* If we are running from the Posix-like build tree, define
2113 SHELL to point to our own cmdproxy. The loop below will
2114 then disregard PATH_EXEC and the default value. */
2115 if (within_build_tree
)
2117 _snprintf (buf
, sizeof (buf
) - 1,
2118 "SHELL=%s/nt/cmdproxy.exe", modname
);
2119 _putenv (strdup (buf
));
2122 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
2124 /* FIXME: should use substring of get_emacs_configuration ().
2125 But I don't think the Windows build supports alpha, mips etc
2126 anymore, so have taken the easy option for now. */
2127 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
2128 || xstrcasecmp (p
, "\\AMD64") == 0))
2131 p
= _mbsrchr (modname
, '\\');
2135 p
= _mbsrchr (modname
, '\\');
2136 if (p
&& xstrcasecmp (p
, "\\src") == 0)
2138 char buf
[SET_ENV_BUF_SIZE
];
2141 for (p
= modname
; *p
; p
= CharNext (p
))
2142 if (*p
== '\\') *p
= '/';
2144 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2145 _putenv (strdup (buf
));
2151 for (i
= 0; i
< N_ENV_VARS
; i
++)
2153 if (!getenv (env_vars
[i
].name
))
2156 char bufc
[SET_ENV_BUF_SIZE
];
2158 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2159 /* Also ignore empty environment variables. */
2164 if (strcmp (env_vars
[i
].name
, "SHELL") == 0)
2166 /* Look for cmdproxy.exe in every directory in
2167 PATH_EXEC. FIXME: This does not find cmdproxy
2168 in nt/ when we run uninstalled. */
2169 char fname
[MAX_PATH
];
2170 const char *pstart
= PATH_EXEC
, *pend
;
2173 pend
= _mbschr (pstart
, ';');
2175 pend
= pstart
+ strlen (pstart
);
2176 /* Be defensive against series of ;;; characters. */
2179 strncpy (fname
, pstart
, pend
- pstart
);
2180 fname
[pend
- pstart
] = '/';
2181 strcpy (&fname
[pend
- pstart
+ 1], "cmdproxy.exe");
2182 ExpandEnvironmentStrings ((LPSTR
) fname
, bufc
,
2184 if (check_existing (bufc
))
2197 /* If not found in any directory, use the
2198 default as the last resort. */
2199 lpval
= env_vars
[i
].def_value
;
2200 dwType
= REG_EXPAND_SZ
;
2206 lpval
= env_vars
[i
].def_value
;
2207 dwType
= REG_EXPAND_SZ
;
2209 if (strcmp (env_vars
[i
].name
, "HOME") == 0 && !appdata
)
2210 Vdelayed_warnings_list
2211 = Fcons (listn (CONSTYPE_HEAP
, 2,
2212 intern ("initialization"),
2213 build_string ("Setting HOME to C:\\ by default is deprecated")),
2214 Vdelayed_warnings_list
);
2219 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2221 if (dwType
== REG_EXPAND_SZ
)
2222 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2223 else if (dwType
== REG_SZ
)
2224 strcpy (buf1
, lpval
);
2225 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2227 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2229 _putenv (strdup (buf2
));
2239 /* Rebuild system configuration to reflect invoking system. */
2240 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2242 /* Another special case: on NT, the PATH variable is actually named
2243 "Path" although cmd.exe (perhaps NT itself) arranges for
2244 environment variable lookup and setting to be case insensitive.
2245 However, Emacs assumes a fully case sensitive environment, so we
2246 need to change "Path" to "PATH" to match the expectations of
2247 various elisp packages. We do this by the sneaky method of
2248 modifying the string in the C runtime environ entry.
2250 The same applies to COMSPEC. */
2254 for (envp
= environ
; *envp
; envp
++)
2255 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2256 memcpy (*envp
, "PATH=", 5);
2257 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2258 memcpy (*envp
, "COMSPEC=", 8);
2261 /* Remember the initial working directory for getcwd. */
2262 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2263 Does it matter anywhere in Emacs? */
2264 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
2268 static char modname
[MAX_PATH
];
2270 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2275 /* Determine if there is a middle mouse button, to allow parse_button
2276 to decide whether right mouse events should be mouse-2 or
2278 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2283 /* Called from expand-file-name when default-directory is not a string. */
2286 emacs_root_dir (void)
2288 static char root_dir
[FILENAME_MAX
];
2291 p
= getenv ("emacs_dir");
2294 strcpy (root_dir
, p
);
2295 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2296 dostounix_filename (root_dir
, 0);
2300 /* We don't have scripts to automatically determine the system configuration
2301 for Emacs before it's compiled, and we don't want to have to make the
2302 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
2306 get_emacs_configuration (void)
2308 char *arch
, *oem
, *os
;
2310 static char configuration_buffer
[32];
2312 /* Determine the processor type. */
2313 switch (get_processor_type ())
2316 #ifdef PROCESSOR_INTEL_386
2317 case PROCESSOR_INTEL_386
:
2318 case PROCESSOR_INTEL_486
:
2319 case PROCESSOR_INTEL_PENTIUM
:
2327 #ifdef PROCESSOR_AMD_X8664
2328 case PROCESSOR_AMD_X8664
:
2333 #ifdef PROCESSOR_MIPS_R2000
2334 case PROCESSOR_MIPS_R2000
:
2335 case PROCESSOR_MIPS_R3000
:
2336 case PROCESSOR_MIPS_R4000
:
2341 #ifdef PROCESSOR_ALPHA_21064
2342 case PROCESSOR_ALPHA_21064
:
2352 /* Use the OEM field to reflect the compiler/library combination. */
2354 #define COMPILER_NAME "msvc"
2357 #define COMPILER_NAME "mingw"
2359 #define COMPILER_NAME "unknown"
2362 oem
= COMPILER_NAME
;
2364 switch (osinfo_cache
.dwPlatformId
) {
2365 case VER_PLATFORM_WIN32_NT
:
2367 build_num
= osinfo_cache
.dwBuildNumber
;
2369 case VER_PLATFORM_WIN32_WINDOWS
:
2370 if (osinfo_cache
.dwMinorVersion
== 0) {
2375 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2377 case VER_PLATFORM_WIN32s
:
2378 /* Not supported, should not happen. */
2380 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2388 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
2389 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
2390 get_w32_major_version (), get_w32_minor_version (), build_num
);
2392 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
2395 return configuration_buffer
;
2399 get_emacs_configuration_options (void)
2401 static char *options_buffer
;
2402 char cv
[32]; /* Enough for COMPILER_VERSION. */
2404 cv
, /* To be filled later. */
2408 #ifdef ENABLE_CHECKING
2409 " --enable-checking",
2411 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2412 with a starting space to save work here. */
2414 " --cflags", USER_CFLAGS
,
2417 " --ldflags", USER_LDFLAGS
,
2424 /* Work out the effective configure options for this build. */
2426 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2429 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2431 #define COMPILER_VERSION ""
2435 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2436 return "Error: not enough space for compiler version";
2437 cv
[sizeof (cv
) - 1] = '\0';
2439 for (i
= 0; options
[i
]; i
++)
2440 size
+= strlen (options
[i
]);
2442 options_buffer
= xmalloc (size
+ 1);
2443 options_buffer
[0] = '\0';
2445 for (i
= 0; options
[i
]; i
++)
2446 strcat (options_buffer
, options
[i
]);
2448 return options_buffer
;
2452 #include <sys/timeb.h>
2454 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2456 gettimeofday (struct timeval
*__restrict tv
, struct timezone
*__restrict tz
)
2461 tv
->tv_sec
= tb
.time
;
2462 tv
->tv_usec
= tb
.millitm
* 1000L;
2463 /* Implementation note: _ftime sometimes doesn't update the dstflag
2464 according to the new timezone when the system timezone is
2465 changed. We could fix that by using GetSystemTime and
2466 GetTimeZoneInformation, but that doesn't seem necessary, since
2467 Emacs always calls gettimeofday with the 2nd argument NULL (see
2468 current_emacs_time). */
2471 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2472 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2477 /* Emulate fdutimens. */
2479 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2480 TIMESPEC[0] and TIMESPEC[1], respectively.
2481 FD must be either negative -- in which case it is ignored --
2482 or a file descriptor that is open on FILE.
2483 If FD is nonnegative, then FILE can be NULL, which means
2484 use just futimes instead of utimes.
2485 If TIMESPEC is null, FAIL.
2486 Return 0 on success, -1 (setting errno) on failure. */
2489 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2498 if (fd
< 0 && !file
)
2503 ut
.actime
= timespec
[0].tv_sec
;
2504 ut
.modtime
= timespec
[1].tv_sec
;
2506 return _futime (fd
, &ut
);
2508 return _utime (file
, &ut
);
2512 /* ------------------------------------------------------------------------- */
2513 /* IO support and wrapper functions for the Windows API. */
2514 /* ------------------------------------------------------------------------- */
2516 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2517 on network directories, so we handle that case here.
2518 (Ulrich Leodolter, 1/11/95). */
2520 sys_ctime (const time_t *t
)
2522 char *str
= (char *) ctime (t
);
2523 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2526 /* Emulate sleep...we could have done this with a define, but that
2527 would necessitate including windows.h in the files that used it.
2528 This is much easier. */
2530 sys_sleep (int seconds
)
2532 Sleep (seconds
* 1000);
2535 /* Internal MSVC functions for low-level descriptor munging */
2536 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2537 extern int __cdecl
_free_osfhnd (int fd
);
2539 /* parallel array of private info on file handles */
2540 filedesc fd_info
[ MAXDESC
];
2542 typedef struct volume_info_data
{
2543 struct volume_info_data
* next
;
2545 /* time when info was obtained */
2548 /* actual volume info */
2557 /* Global referenced by various functions. */
2558 static volume_info_data volume_info
;
2560 /* Vector to indicate which drives are local and fixed (for which cached
2561 data never expires). */
2562 static BOOL fixed_drives
[26];
2564 /* Consider cached volume information to be stale if older than 10s,
2565 at least for non-local drives. Info for fixed drives is never stale. */
2566 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2567 #define VOLINFO_STILL_VALID( root_dir, info ) \
2568 ( ( isalpha (root_dir[0]) && \
2569 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2570 || GetTickCount () - info->timestamp < 10000 )
2572 /* Cache support functions. */
2574 /* Simple linked list with linear search is sufficient. */
2575 static volume_info_data
*volume_cache
= NULL
;
2577 static volume_info_data
*
2578 lookup_volume_info (char * root_dir
)
2580 volume_info_data
* info
;
2582 for (info
= volume_cache
; info
; info
= info
->next
)
2583 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2589 add_volume_info (char * root_dir
, volume_info_data
* info
)
2591 info
->root_dir
= xstrdup (root_dir
);
2592 info
->next
= volume_cache
;
2593 volume_cache
= info
;
2597 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2598 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2599 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2600 static volume_info_data
*
2601 GetCachedVolumeInformation (char * root_dir
)
2603 volume_info_data
* info
;
2604 char default_root
[ MAX_PATH
];
2606 /* NULL for root_dir means use root from current directory. */
2607 if (root_dir
== NULL
)
2609 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2611 parse_root (default_root
, &root_dir
);
2613 root_dir
= default_root
;
2616 /* Local fixed drives can be cached permanently. Removable drives
2617 cannot be cached permanently, since the volume name and serial
2618 number (if nothing else) can change. Remote drives should be
2619 treated as if they are removable, since there is no sure way to
2620 tell whether they are or not. Also, the UNC association of drive
2621 letters mapped to remote volumes can be changed at any time (even
2622 by other processes) without notice.
2624 As a compromise, so we can benefit from caching info for remote
2625 volumes, we use a simple expiry mechanism to invalidate cache
2626 entries that are more than ten seconds old. */
2629 /* No point doing this, because WNetGetConnection is even slower than
2630 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2631 GetDriveType is about the only call of this type which does not
2632 involve network access, and so is extremely quick). */
2634 /* Map drive letter to UNC if remote. */
2635 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2637 char remote_name
[ 256 ];
2638 char drive
[3] = { root_dir
[0], ':' };
2640 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2642 /* do something */ ;
2646 info
= lookup_volume_info (root_dir
);
2648 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2656 /* Info is not cached, or is stale. */
2657 if (!GetVolumeInformation (root_dir
,
2658 name
, sizeof (name
),
2662 type
, sizeof (type
)))
2665 /* Cache the volume information for future use, overwriting existing
2666 entry if present. */
2669 info
= xmalloc (sizeof (volume_info_data
));
2670 add_volume_info (root_dir
, info
);
2678 info
->name
= xstrdup (name
);
2679 info
->serialnum
= serialnum
;
2680 info
->maxcomp
= maxcomp
;
2681 info
->flags
= flags
;
2682 info
->type
= xstrdup (type
);
2683 info
->timestamp
= GetTickCount ();
2689 /* Get information on the volume where NAME is held; set path pointer to
2690 start of pathname in NAME (past UNC header\volume header if present),
2691 if pPath is non-NULL.
2693 Note: if NAME includes symlinks, the information is for the volume
2694 of the symlink, not of its target. That's because, even though
2695 GetVolumeInformation returns information about the symlink target
2696 of its argument, we only pass the root directory to
2697 GetVolumeInformation, not the full NAME. */
2699 get_volume_info (const char * name
, const char ** pPath
)
2701 char temp
[MAX_PATH
];
2702 char *rootname
= NULL
; /* default to current volume */
2703 volume_info_data
* info
;
2708 /* Find the root name of the volume if given. */
2709 if (isalpha (name
[0]) && name
[1] == ':')
2717 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2721 int dbcs_p
= max_filename_mbslen () > 1;
2726 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2732 const char *p
= name
;
2734 name
= CharNextExA (file_name_codepage
, name
, 0);
2735 memcpy (str
, p
, name
- p
);
2748 info
= GetCachedVolumeInformation (rootname
);
2751 /* Set global referenced by other functions. */
2752 volume_info
= *info
;
2758 /* Determine if volume is FAT format (ie. only supports short 8.3
2759 names); also set path pointer to start of pathname in name, if
2760 pPath is non-NULL. */
2762 is_fat_volume (const char * name
, const char ** pPath
)
2764 if (get_volume_info (name
, pPath
))
2765 return (volume_info
.maxcomp
== 12);
2769 /* Map filename to a valid 8.3 name if necessary.
2770 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2772 map_w32_filename (const char * name
, const char ** pPath
)
2774 static char shortname
[MAX_PATH
];
2775 char * str
= shortname
;
2778 const char * save_name
= name
;
2780 if (strlen (name
) >= MAX_PATH
)
2782 /* Return a filename which will cause callers to fail. */
2783 strcpy (shortname
, "?");
2787 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2789 register int left
= 8; /* maximum number of chars in part */
2790 register int extn
= 0; /* extension added? */
2791 register int dots
= 2; /* maximum number of dots allowed */
2794 *str
++ = *name
++; /* skip past UNC header */
2796 while ((c
= *name
++))
2803 *str
++ = (c
== ':' ? ':' : '\\');
2804 extn
= 0; /* reset extension flags */
2805 dots
= 2; /* max 2 dots */
2806 left
= 8; /* max length 8 for main part */
2811 /* Convert path components of the form .xxx to _xxx,
2812 but leave . and .. as they are. This allows .emacs
2813 to be read as _emacs, for example. */
2817 IS_DIRECTORY_SEP (*name
))
2832 extn
= 1; /* we've got an extension */
2833 left
= 3; /* 3 chars in extension */
2837 /* any embedded dots after the first are converted to _ */
2842 case '#': /* don't lose these, they're important */
2844 str
[-1] = c
; /* replace last character of part */
2849 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2851 dots
= 0; /* started a path component */
2860 strcpy (shortname
, name
);
2861 unixtodos_filename (shortname
);
2865 *pPath
= shortname
+ (path
- save_name
);
2871 is_exec (const char * name
)
2873 char * p
= strrchr (name
, '.');
2876 && (xstrcasecmp (p
, ".exe") == 0 ||
2877 xstrcasecmp (p
, ".com") == 0 ||
2878 xstrcasecmp (p
, ".bat") == 0 ||
2879 xstrcasecmp (p
, ".cmd") == 0));
2882 /* Emulate the Unix directory procedures opendir, closedir,
2883 and readdir. We can't use the procedures supplied in sysdep.c,
2884 so we provide them here. */
2886 struct dirent dir_static
; /* simulated directory contents */
2887 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2888 static int dir_is_fat
;
2889 static char dir_pathname
[MAXPATHLEN
+1];
2890 static WIN32_FIND_DATA dir_find_data
;
2892 /* Support shares on a network resource as subdirectories of a read-only
2894 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2895 static HANDLE
open_unc_volume (const char *);
2896 static char *read_unc_volume (HANDLE
, char *, int);
2897 static void close_unc_volume (HANDLE
);
2900 opendir (const char *filename
)
2904 /* Opening is done by FindFirstFile. However, a read is inherent to
2905 this operation, so we defer the open until read time. */
2907 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2909 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2912 /* Note: We don't support traversal of UNC volumes via symlinks.
2913 Doing so would mean punishing 99.99% of use cases by resolving
2914 all the possible symlinks in FILENAME, recursively. */
2915 if (is_unc_volume (filename
))
2917 wnet_enum_handle
= open_unc_volume (filename
);
2918 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2922 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2929 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2930 dir_pathname
[MAXPATHLEN
] = '\0';
2931 /* Note: We don't support symlinks to file names on FAT volumes.
2932 Doing so would mean punishing 99.99% of use cases by resolving
2933 all the possible symlinks in FILENAME, recursively. */
2934 dir_is_fat
= is_fat_volume (filename
, NULL
);
2940 closedir (DIR *dirp
)
2942 /* If we have a find-handle open, close it. */
2943 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2945 FindClose (dir_find_handle
);
2946 dir_find_handle
= INVALID_HANDLE_VALUE
;
2948 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2950 close_unc_volume (wnet_enum_handle
);
2951 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2953 xfree ((char *) dirp
);
2959 int downcase
= !NILP (Vw32_downcase_file_names
);
2961 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2963 if (!read_unc_volume (wnet_enum_handle
,
2964 dir_find_data
.cFileName
,
2968 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2969 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2971 char filename
[MAXNAMLEN
+ 3];
2973 int dbcs_p
= max_filename_mbslen () > 1;
2975 strcpy (filename
, dir_pathname
);
2976 ln
= strlen (filename
) - 1;
2979 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2980 strcat (filename
, "\\");
2984 char *end
= filename
+ ln
+ 1;
2985 char *last_char
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
2987 if (!IS_DIRECTORY_SEP (*last_char
))
2988 strcat (filename
, "\\");
2990 strcat (filename
, "*");
2992 /* Note: No need to resolve symlinks in FILENAME, because
2993 FindFirst opens the directory that is the target of a
2995 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2997 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
3002 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
3006 /* Emacs never uses this value, so don't bother making it match
3007 value returned by stat(). */
3008 dir_static
.d_ino
= 1;
3010 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
3012 /* If the file name in cFileName[] includes `?' characters, it means
3013 the original file name used characters that cannot be represented
3014 by the current ANSI codepage. To avoid total lossage, retrieve
3015 the short 8+3 alias of the long file name. */
3016 if (_mbspbrk (dir_static
.d_name
, "?"))
3018 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
3019 downcase
= 1; /* 8+3 aliases are returned in all caps */
3021 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3022 dir_static
.d_reclen
= sizeof (struct dirent
) - MAXNAMLEN
+ 3 +
3023 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
3025 /* If the file name in cFileName[] includes `?' characters, it means
3026 the original file name used characters that cannot be represented
3027 by the current ANSI codepage. To avoid total lossage, retrieve
3028 the short 8+3 alias of the long file name. */
3029 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
3031 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
3032 /* 8+3 aliases are returned in all caps, which could break
3033 various alists that look at filenames' extensions. */
3037 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
3038 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
3040 _mbslwr (dir_static
.d_name
);
3044 int dbcs_p
= max_filename_mbslen () > 1;
3045 for (p
= dir_static
.d_name
; *p
; )
3047 if (*p
>= 'a' && *p
<= 'z')
3050 p
= CharNextExA (file_name_codepage
, p
, 0);
3055 _mbslwr (dir_static
.d_name
);
3062 open_unc_volume (const char *path
)
3068 nr
.dwScope
= RESOURCE_GLOBALNET
;
3069 nr
.dwType
= RESOURCETYPE_DISK
;
3070 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3071 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3072 nr
.lpLocalName
= NULL
;
3073 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
3074 nr
.lpComment
= NULL
;
3075 nr
.lpProvider
= NULL
;
3077 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3078 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
3080 if (result
== NO_ERROR
)
3083 return INVALID_HANDLE_VALUE
;
3087 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
3091 DWORD bufsize
= 512;
3094 int dbcs_p
= max_filename_mbslen () > 1;
3097 buffer
= alloca (bufsize
);
3098 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
3099 if (result
!= NO_ERROR
)
3102 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3103 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
3106 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
3109 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
))
3110 ptr
= CharNextExA (file_name_codepage
, ptr
, 0);
3114 strncpy (readbuf
, ptr
, size
);
3119 close_unc_volume (HANDLE henum
)
3121 if (henum
!= INVALID_HANDLE_VALUE
)
3122 WNetCloseEnum (henum
);
3126 unc_volume_file_attributes (const char *path
)
3131 henum
= open_unc_volume (path
);
3132 if (henum
== INVALID_HANDLE_VALUE
)
3135 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3137 close_unc_volume (henum
);
3142 /* Ensure a network connection is authenticated. */
3144 logon_network_drive (const char *path
)
3146 NETRESOURCE resource
;
3147 char share
[MAX_PATH
];
3154 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3155 drvtype
= DRIVE_REMOTE
;
3156 else if (path
[0] == '\0' || path
[1] != ':')
3157 drvtype
= GetDriveType (NULL
);
3164 drvtype
= GetDriveType (drive
);
3167 /* Only logon to networked drives. */
3168 if (drvtype
!= DRIVE_REMOTE
)
3172 strncpy (share
, path
, MAX_PATH
);
3173 /* Truncate to just server and share name. */
3174 dbcs_p
= max_filename_mbslen () > 1;
3175 for (p
= share
+ 2; *p
&& p
< share
+ MAX_PATH
; )
3177 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3183 p
= CharNextExA (file_name_codepage
, p
, 0);
3188 resource
.dwType
= RESOURCETYPE_DISK
;
3189 resource
.lpLocalName
= NULL
;
3190 resource
.lpRemoteName
= share
;
3191 resource
.lpProvider
= NULL
;
3193 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3196 /* Emulate faccessat(2). */
3198 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3202 if (dirfd
!= AT_FDCWD
3203 && !(IS_DIRECTORY_SEP (path
[0])
3204 || IS_DEVICE_SEP (path
[1])))
3210 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3211 newer versions blow up when passed D_OK. */
3212 path
= map_w32_filename (path
, NULL
);
3213 /* If the last element of PATH is a symlink, we need to resolve it
3214 to get the attributes of its target file. Note: any symlinks in
3215 PATH elements other than the last one are transparently resolved
3216 by GetFileAttributes below. */
3217 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3218 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3219 path
= chase_symlinks (path
);
3221 if ((attributes
= GetFileAttributes (path
)) == -1)
3223 DWORD w32err
= GetLastError ();
3227 case ERROR_INVALID_NAME
:
3228 case ERROR_BAD_PATHNAME
:
3229 if (is_unc_volume (path
))
3231 attributes
= unc_volume_file_attributes (path
);
3232 if (attributes
== -1)
3240 case ERROR_FILE_NOT_FOUND
:
3241 case ERROR_BAD_NETPATH
:
3250 if ((mode
& X_OK
) != 0
3251 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3256 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3261 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3269 /* Shadow some MSVC runtime functions to map requests for long filenames
3270 to reasonable short names if necessary. This was originally added to
3271 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3275 sys_chdir (const char * path
)
3277 return _chdir (map_w32_filename (path
, NULL
));
3281 sys_chmod (const char * path
, int mode
)
3283 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3284 return _chmod (path
, mode
);
3288 sys_creat (const char * path
, int mode
)
3290 return _creat (map_w32_filename (path
, NULL
), mode
);
3294 sys_fopen (const char * path
, const char * mode
)
3298 const char * mode_save
= mode
;
3300 /* Force all file handles to be non-inheritable. This is necessary to
3301 ensure child processes don't unwittingly inherit handles that might
3302 prevent future file access. */
3306 else if (mode
[0] == 'w' || mode
[0] == 'a')
3307 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3311 /* Only do simplistic option parsing. */
3315 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3318 else if (mode
[0] == 'b')
3323 else if (mode
[0] == 't')
3330 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
3334 return _fdopen (fd
, mode_save
);
3337 /* This only works on NTFS volumes, but is useful to have. */
3339 sys_link (const char * old
, const char * new)
3343 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
3345 if (old
== NULL
|| new == NULL
)
3351 strcpy (oldname
, map_w32_filename (old
, NULL
));
3352 strcpy (newname
, map_w32_filename (new, NULL
));
3354 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
3355 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3356 if (fileh
!= INVALID_HANDLE_VALUE
)
3360 /* Confusingly, the "alternate" stream name field does not apply
3361 when restoring a hard link, and instead contains the actual
3362 stream data for the link (ie. the name of the link to create).
3363 The WIN32_STREAM_ID structure before the cStreamName field is
3364 the stream header, which is then immediately followed by the
3368 WIN32_STREAM_ID wid
;
3369 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3372 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
3373 data
.wid
.cStreamName
, MAX_PATH
);
3376 LPVOID context
= NULL
;
3379 data
.wid
.dwStreamId
= BACKUP_LINK
;
3380 data
.wid
.dwStreamAttributes
= 0;
3381 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3382 data
.wid
.Size
.HighPart
= 0;
3383 data
.wid
.dwStreamNameSize
= 0;
3385 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3386 offsetof (WIN32_STREAM_ID
, cStreamName
)
3387 + data
.wid
.Size
.LowPart
,
3388 &wbytes
, FALSE
, FALSE
, &context
)
3389 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3396 /* Should try mapping GetLastError to errno; for now just
3397 indicate a general error (eg. links not supported). */
3398 errno
= EINVAL
; // perhaps EMLINK?
3402 CloseHandle (fileh
);
3411 sys_mkdir (const char * path
)
3413 return _mkdir (map_w32_filename (path
, NULL
));
3417 sys_open (const char * path
, int oflag
, int mode
)
3419 const char* mpath
= map_w32_filename (path
, NULL
);
3422 /* If possible, try to open file without _O_CREAT, to be able to
3423 write to existing hidden and system files. Force all file
3424 handles to be non-inheritable. */
3425 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
3426 res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3428 res
= _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3433 /* Implementation of mkostemp for MS-Windows, to avoid race conditions
3436 Standard algorithm for generating a temporary file name seems to be
3437 use pid or tid with a letter on the front (in place of the 6 X's)
3438 and cycle through the letters to find a unique name. We extend
3439 that to allow any reasonable character as the first of the 6 X's,
3440 so that the number of simultaneously used temporary files will be
3444 mkostemp (char * template, int flags
)
3448 unsigned uid
= GetCurrentThreadId ();
3449 int save_errno
= errno
;
3450 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3453 if (template == NULL
)
3456 p
= template + strlen (template);
3458 /* replace up to the last 5 X's with uid in decimal */
3459 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3461 p
[0] = '0' + uid
% 10;
3465 if (i
< 0 && p
[0] == 'X')
3470 p
[0] = first_char
[i
];
3471 if ((fd
= sys_open (template,
3472 flags
| _O_CREAT
| _O_EXCL
| _O_RDWR
,
3473 S_IRUSR
| S_IWUSR
)) >= 0
3481 while (++i
< sizeof (first_char
));
3484 /* Template is badly formed or else we can't generate a unique name. */
3489 fchmod (int fd
, mode_t mode
)
3495 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
3498 char temp
[MAX_PATH
];
3502 /* MoveFile on Windows 95 doesn't correctly change the short file name
3503 alias in a number of circumstances (it is not easy to predict when
3504 just by looking at oldname and newname, unfortunately). In these
3505 cases, renaming through a temporary name avoids the problem.
3507 A second problem on Windows 95 is that renaming through a temp name when
3508 newname is uppercase fails (the final long name ends up in
3509 lowercase, although the short alias might be uppercase) UNLESS the
3510 long temp name is not 8.3.
3512 So, on Windows 95 we always rename through a temp name, and we make sure
3513 the temp name has a long extension to ensure correct renaming. */
3515 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3517 /* volume_info is set indirectly by map_w32_filename. */
3518 oldname_dev
= volume_info
.serialnum
;
3520 if (os_subtype
== OS_9X
)
3526 oldname
= map_w32_filename (oldname
, NULL
);
3527 if ((o
= strrchr (oldname
, '\\')))
3530 o
= (char *) oldname
;
3532 if ((p
= strrchr (temp
, '\\')))
3539 /* Force temp name to require a manufactured 8.3 alias - this
3540 seems to make the second rename work properly. */
3541 sprintf (p
, "_.%s.%u", o
, i
);
3543 result
= rename (oldname
, temp
);
3545 /* This loop must surely terminate! */
3546 while (result
< 0 && errno
== EEXIST
);
3551 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
3552 (at least if it is a file; don't do this for directories).
3554 Since we mustn't do this if we are just changing the case of the
3555 file name (we would end up deleting the file we are trying to
3556 rename!), we let rename detect if the destination file already
3557 exists - that way we avoid the possible pitfalls of trying to
3558 determine ourselves whether two names really refer to the same
3559 file, which is not always possible in the general case. (Consider
3560 all the permutations of shared or subst'd drives, etc.) */
3562 newname
= map_w32_filename (newname
, NULL
);
3564 /* volume_info is set indirectly by map_w32_filename. */
3565 newname_dev
= volume_info
.serialnum
;
3567 result
= rename (temp
, newname
);
3569 if (result
< 0 && force
)
3571 DWORD w32err
= GetLastError ();
3574 && newname_dev
!= oldname_dev
)
3576 /* The implementation of `rename' on Windows does not return
3577 errno = EXDEV when you are moving a directory to a
3578 different storage device (ex. logical disk). It returns
3579 EACCES instead. So here we handle such situations and
3583 if ((attributes
= GetFileAttributes (temp
)) != -1
3584 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3587 else if (errno
== EEXIST
)
3589 if (_chmod (newname
, 0666) != 0)
3591 if (_unlink (newname
) != 0)
3593 result
= rename (temp
, newname
);
3595 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3596 && is_symlink (temp
))
3598 /* This is Windows prohibiting the user from creating a
3599 symlink in another place, since that requires
3609 sys_rename (char const *old
, char const *new)
3611 return sys_rename_replace (old
, new, TRUE
);
3615 sys_rmdir (const char * path
)
3617 return _rmdir (map_w32_filename (path
, NULL
));
3621 sys_unlink (const char * path
)
3623 path
= map_w32_filename (path
, NULL
);
3625 /* On Unix, unlink works without write permission. */
3626 _chmod (path
, 0666);
3627 return _unlink (path
);
3630 static FILETIME utc_base_ft
;
3631 static ULONGLONG utc_base
; /* In 100ns units */
3632 static int init
= 0;
3634 #define FILETIME_TO_U64(result, ft) \
3636 ULARGE_INTEGER uiTemp; \
3637 uiTemp.LowPart = (ft).dwLowDateTime; \
3638 uiTemp.HighPart = (ft).dwHighDateTime; \
3639 result = uiTemp.QuadPart; \
3643 initialize_utc_base (void)
3645 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3654 st
.wMilliseconds
= 0;
3656 SystemTimeToFileTime (&st
, &utc_base_ft
);
3657 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3661 convert_time (FILETIME ft
)
3667 initialize_utc_base ();
3671 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3674 FILETIME_TO_U64 (tmp
, ft
);
3675 return (time_t) ((tmp
- utc_base
) / 10000000L);
3679 convert_from_time_t (time_t time
, FILETIME
* pft
)
3685 initialize_utc_base ();
3689 /* time in 100ns units since 1-Jan-1601 */
3690 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3691 pft
->dwHighDateTime
= tmp
.HighPart
;
3692 pft
->dwLowDateTime
= tmp
.LowPart
;
3696 /* No reason to keep this; faking inode values either by hashing or even
3697 using the file index from GetInformationByHandle, is not perfect and
3698 so by default Emacs doesn't use the inode values on Windows.
3699 Instead, we now determine file-truename correctly (except for
3700 possible drive aliasing etc). */
3702 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3704 hashval (const unsigned char * str
)
3709 h
= (h
<< 4) + *str
++;
3715 /* Return the hash value of the canonical pathname, excluding the
3716 drive/UNC header, to get a hopefully unique inode number. */
3718 generate_inode_val (const char * name
)
3720 char fullname
[ MAX_PATH
];
3724 /* Get the truly canonical filename, if it exists. (Note: this
3725 doesn't resolve aliasing due to subst commands, or recognize hard
3727 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3730 parse_root (fullname
, &p
);
3731 /* Normal W32 filesystems are still case insensitive. */
3738 static PSECURITY_DESCRIPTOR
3739 get_file_security_desc_by_handle (HANDLE h
)
3741 PSECURITY_DESCRIPTOR psd
= NULL
;
3743 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3744 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3746 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3747 NULL
, NULL
, NULL
, NULL
, &psd
);
3748 if (err
!= ERROR_SUCCESS
)
3754 static PSECURITY_DESCRIPTOR
3755 get_file_security_desc_by_name (const char *fname
)
3757 PSECURITY_DESCRIPTOR psd
= NULL
;
3759 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3760 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3762 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3764 err
= GetLastError ();
3765 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3769 psd
= xmalloc (sd_len
);
3770 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3782 unsigned n_subauthorities
;
3784 /* Use the last sub-authority value of the RID, the relative
3785 portion of the SID, as user/group ID. */
3786 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3787 if (n_subauthorities
< 1)
3788 return 0; /* the "World" RID */
3789 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3792 /* Caching SID and account values for faster lokup. */
3796 struct w32_id
*next
;
3798 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3801 static struct w32_id
*w32_idlist
;
3804 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3806 struct w32_id
*tail
, *found
;
3808 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3810 if (equal_sid ((PSID
)tail
->sid
, sid
))
3819 strcpy (name
, found
->name
);
3827 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3830 struct w32_id
*new_entry
;
3832 /* We don't want to leave behind stale cache from when Emacs was
3836 sid_len
= get_length_sid (sid
);
3837 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3840 new_entry
->rid
= id
;
3841 strcpy (new_entry
->name
, name
);
3842 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3843 new_entry
->next
= w32_idlist
;
3844 w32_idlist
= new_entry
;
3853 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
3857 SID_NAME_USE ignore
;
3859 DWORD name_len
= sizeof (name
);
3861 DWORD domain_len
= sizeof (domain
);
3866 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3867 else if (what
== GID
)
3868 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3872 if (!result
|| !is_valid_sid (sid
))
3874 else if (!w32_cached_id (sid
, id
, nm
))
3876 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
3877 domain
, &domain_len
, &ignore
)
3878 || name_len
> UNLEN
+1)
3882 *id
= get_rid (sid
);
3884 w32_add_to_cache (sid
, *id
, name
);
3891 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
3893 int dflt_usr
= 0, dflt_grp
= 0;
3902 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
3904 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
3907 /* Consider files to belong to current user/group, if we cannot get
3908 more accurate information. */
3911 st
->st_uid
= dflt_passwd
.pw_uid
;
3912 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3916 st
->st_gid
= dflt_passwd
.pw_gid
;
3917 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3921 /* Return non-zero if NAME is a potentially slow filesystem. */
3923 is_slow_fs (const char *name
)
3928 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3929 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3930 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3931 devtype
= GetDriveType (NULL
); /* use root of current drive */
3934 /* GetDriveType needs the root directory of the drive. */
3935 strncpy (drive_root
, name
, 2);
3936 drive_root
[2] = '\\';
3937 drive_root
[3] = '\0';
3938 devtype
= GetDriveType (drive_root
);
3940 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3943 /* If this is non-zero, the caller wants accurate information about
3944 file's owner and group, which could be expensive to get. */
3945 int w32_stat_get_owner_group
;
3947 /* MSVC stat function can't cope with UNC names and has other bugs, so
3948 replace it with our own. This also allows us to calculate consistent
3949 inode values and owner/group without hacks in the main Emacs code. */
3952 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3954 char *name
, *save_name
, *r
;
3955 WIN32_FIND_DATA wfd
;
3957 unsigned __int64 fake_inode
= 0;
3960 int rootdir
= FALSE
;
3961 PSECURITY_DESCRIPTOR psd
= NULL
;
3962 int is_a_symlink
= 0;
3963 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3964 DWORD access_rights
= 0;
3965 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3966 FILETIME ctime
, atime
, wtime
;
3969 if (path
== NULL
|| buf
== NULL
)
3975 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3976 /* Must be valid filename, no wild cards or other invalid
3977 characters. We use _mbspbrk to support multibyte strings that
3978 might look to strpbrk as if they included literal *, ?, and other
3979 characters mentioned below that are disallowed by Windows
3981 if (_mbspbrk (name
, "*?|<>\""))
3987 /* Remove trailing directory separator, unless name is the root
3988 directory of a drive or UNC volume in which case ensure there
3989 is a trailing separator. */
3990 len
= strlen (name
);
3991 name
= strcpy (alloca (len
+ 2), name
);
3993 /* Avoid a somewhat costly call to is_symlink if the filesystem
3994 doesn't support symlinks. */
3995 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3996 is_a_symlink
= is_symlink (name
);
3998 /* Plan A: Open the file and get all the necessary information via
3999 the resulting handle. This solves several issues in one blow:
4001 . retrieves attributes for the target of a symlink, if needed
4002 . gets attributes of root directories and symlinks pointing to
4003 root directories, thus avoiding the need for special-casing
4004 these and detecting them by examining the file-name format
4005 . retrieves more accurate attributes (e.g., non-zero size for
4006 some directories, esp. directories that are junction points)
4007 . correctly resolves "c:/..", "/.." and similar file names
4008 . avoids run-time penalties for 99% of use cases
4010 Plan A is always tried first, unless the user asked not to (but
4011 if the file is a symlink and we need to follow links, we try Plan
4012 A even if the user asked not to).
4014 If Plan A fails, we go to Plan B (below), where various
4015 potentially expensive techniques must be used to handle "special"
4016 files such as UNC volumes etc. */
4017 if (!(NILP (Vw32_get_true_file_attributes
)
4018 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
4019 /* Following symlinks requires getting the info by handle. */
4020 || (is_a_symlink
&& follow_symlinks
))
4022 BY_HANDLE_FILE_INFORMATION info
;
4024 if (is_a_symlink
&& !follow_symlinks
)
4025 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
4026 /* READ_CONTROL access rights are required to get security info
4027 by handle. But if the OS doesn't support security in the
4028 first place, we don't need to try. */
4029 if (is_windows_9x () != TRUE
)
4030 access_rights
|= READ_CONTROL
;
4032 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
4034 /* If CreateFile fails with READ_CONTROL, try again with zero as
4036 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
4037 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
4039 if (fh
== INVALID_HANDLE_VALUE
)
4040 goto no_true_file_attributes
;
4042 /* This is more accurate in terms of getting the correct number
4043 of links, but is quite slow (it is noticeable when Emacs is
4044 making a list of file name completions). */
4045 if (GetFileInformationByHandle (fh
, &info
))
4047 nlinks
= info
.nNumberOfLinks
;
4048 /* Might as well use file index to fake inode values, but this
4049 is not guaranteed to be unique unless we keep a handle open
4050 all the time (even then there are situations where it is
4051 not unique). Reputedly, there are at most 48 bits of info
4052 (on NTFS, presumably less on FAT). */
4053 fake_inode
= info
.nFileIndexHigh
;
4055 fake_inode
+= info
.nFileIndexLow
;
4056 serialnum
= info
.dwVolumeSerialNumber
;
4057 fs_high
= info
.nFileSizeHigh
;
4058 fs_low
= info
.nFileSizeLow
;
4059 ctime
= info
.ftCreationTime
;
4060 atime
= info
.ftLastAccessTime
;
4061 wtime
= info
.ftLastWriteTime
;
4062 fattrs
= info
.dwFileAttributes
;
4066 /* We don't go to Plan B here, because it's not clear that
4067 it's a good idea. The only known use case where
4068 CreateFile succeeds, but GetFileInformationByHandle fails
4069 (with ERROR_INVALID_FUNCTION) is for character devices
4070 such as NUL, PRN, etc. For these, switching to Plan B is
4071 a net loss, because we lose the character device
4072 attribute returned by GetFileType below (FindFirstFile
4073 doesn't set that bit in the attributes), and the other
4074 fields don't make sense for character devices anyway.
4075 Emacs doesn't really care for non-file entities in the
4076 context of l?stat, so neither do we. */
4078 /* w32err is assigned so one could put a breakpoint here and
4079 examine its value, when GetFileInformationByHandle
4081 DWORD w32err
= GetLastError ();
4085 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4091 /* Test for a symlink before testing for a directory, since
4092 symlinks to directories have the directory bit set, but we
4093 don't want them to appear as directories. */
4094 if (is_a_symlink
&& !follow_symlinks
)
4095 buf
->st_mode
= S_IFLNK
;
4096 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4097 buf
->st_mode
= S_IFDIR
;
4100 DWORD ftype
= GetFileType (fh
);
4104 case FILE_TYPE_DISK
:
4105 buf
->st_mode
= S_IFREG
;
4107 case FILE_TYPE_PIPE
:
4108 buf
->st_mode
= S_IFIFO
;
4110 case FILE_TYPE_CHAR
:
4111 case FILE_TYPE_UNKNOWN
:
4113 buf
->st_mode
= S_IFCHR
;
4116 /* We produce the fallback owner and group data, based on the
4117 current user that runs Emacs, in the following cases:
4119 . caller didn't request owner and group info
4120 . this is Windows 9X
4121 . getting security by handle failed, and we need to produce
4122 information for the target of a symlink (this is better
4123 than producing a potentially misleading info about the
4126 If getting security by handle fails, and we don't need to
4127 resolve symlinks, we try getting security by name. */
4128 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4129 get_file_owner_and_group (NULL
, buf
);
4132 psd
= get_file_security_desc_by_handle (fh
);
4135 get_file_owner_and_group (psd
, buf
);
4138 else if (!(is_a_symlink
&& follow_symlinks
))
4140 psd
= get_file_security_desc_by_name (name
);
4141 get_file_owner_and_group (psd
, buf
);
4145 get_file_owner_and_group (NULL
, buf
);
4151 no_true_file_attributes
:
4152 /* Plan B: Either getting a handle on the file failed, or the
4153 caller explicitly asked us to not bother making this
4154 information more accurate.
4156 Implementation note: In Plan B, we never bother to resolve
4157 symlinks, even if we got here because we tried Plan A and
4158 failed. That's because, even if the caller asked for extra
4159 precision by setting Vw32_get_true_file_attributes to t,
4160 resolving symlinks requires acquiring a file handle to the
4161 symlink, which we already know will fail. And if the user
4162 did not ask for extra precision, resolving symlinks will fly
4163 in the face of that request, since the user then wants the
4164 lightweight version of the code. */
4165 dbcs_p
= max_filename_mbslen () > 1;
4166 rootdir
= (path
>= save_name
+ len
- 1
4167 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4169 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4170 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4171 if (IS_DIRECTORY_SEP (r
[0])
4172 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4175 /* Note: If NAME is a symlink to the root of a UNC volume
4176 (i.e. "\\SERVER"), we will not detect that here, and we will
4177 return data about the symlink as result of FindFirst below.
4178 This is unfortunate, but that marginal use case does not
4179 justify a call to chase_symlinks which would impose a penalty
4180 on all the other use cases. (We get here for symlinks to
4181 roots of UNC volumes because CreateFile above fails for them,
4182 unlike with symlinks to root directories X:\ of drives.) */
4183 if (is_unc_volume (name
))
4185 fattrs
= unc_volume_file_attributes (name
);
4189 ctime
= atime
= wtime
= utc_base_ft
;
4195 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4196 strcat (name
, "\\");
4200 char *end
= name
+ len
;
4201 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4203 if (!IS_DIRECTORY_SEP (*n
))
4204 strcat (name
, "\\");
4206 if (GetDriveType (name
) < 2)
4212 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4213 ctime
= atime
= wtime
= utc_base_ft
;
4219 if (IS_DIRECTORY_SEP (name
[len
-1]))
4224 char *end
= name
+ len
;
4225 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4227 if (IS_DIRECTORY_SEP (*n
))
4231 /* (This is hacky, but helps when doing file completions on
4232 network drives.) Optimize by using information available from
4233 active readdir if possible. */
4234 len
= strlen (dir_pathname
);
4237 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4242 char *end
= dir_pathname
+ len
;
4243 char *n
= CharPrevExA (file_name_codepage
, dir_pathname
, end
, 0);
4245 if (IS_DIRECTORY_SEP (*n
))
4248 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4249 && !(is_a_symlink
&& follow_symlinks
)
4250 && strnicmp (save_name
, dir_pathname
, len
) == 0
4251 && IS_DIRECTORY_SEP (name
[len
])
4252 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
4254 /* This was the last entry returned by readdir. */
4255 wfd
= dir_find_data
;
4259 logon_network_drive (name
);
4261 fh
= FindFirstFile (name
, &wfd
);
4262 if (fh
== INVALID_HANDLE_VALUE
)
4269 /* Note: if NAME is a symlink, the information we get from
4270 FindFirstFile is for the symlink, not its target. */
4271 fattrs
= wfd
.dwFileAttributes
;
4272 ctime
= wfd
.ftCreationTime
;
4273 atime
= wfd
.ftLastAccessTime
;
4274 wtime
= wfd
.ftLastWriteTime
;
4275 fs_high
= wfd
.nFileSizeHigh
;
4276 fs_low
= wfd
.nFileSizeLow
;
4279 serialnum
= volume_info
.serialnum
;
4281 if (is_a_symlink
&& !follow_symlinks
)
4282 buf
->st_mode
= S_IFLNK
;
4283 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4284 buf
->st_mode
= S_IFDIR
;
4286 buf
->st_mode
= S_IFREG
;
4288 get_file_owner_and_group (NULL
, buf
);
4292 /* Not sure if there is any point in this. */
4293 if (!NILP (Vw32_generate_fake_inodes
))
4294 fake_inode
= generate_inode_val (name
);
4295 else if (fake_inode
== 0)
4297 /* For want of something better, try to make everything unique. */
4298 static DWORD gen_num
= 0;
4299 fake_inode
= ++gen_num
;
4303 buf
->st_ino
= fake_inode
;
4305 buf
->st_dev
= serialnum
;
4306 buf
->st_rdev
= serialnum
;
4308 buf
->st_size
= fs_high
;
4309 buf
->st_size
<<= 32;
4310 buf
->st_size
+= fs_low
;
4311 buf
->st_nlink
= nlinks
;
4313 /* Convert timestamps to Unix format. */
4314 buf
->st_mtime
= convert_time (wtime
);
4315 buf
->st_atime
= convert_time (atime
);
4316 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4317 buf
->st_ctime
= convert_time (ctime
);
4318 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4320 /* determine rwx permissions */
4321 if (is_a_symlink
&& !follow_symlinks
)
4322 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
4325 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
4326 permission
= S_IREAD
;
4328 permission
= S_IREAD
| S_IWRITE
;
4330 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4331 permission
|= S_IEXEC
;
4332 else if (is_exec (name
))
4333 permission
|= S_IEXEC
;
4336 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4342 stat (const char * path
, struct stat
* buf
)
4344 return stat_worker (path
, buf
, 1);
4348 lstat (const char * path
, struct stat
* buf
)
4350 return stat_worker (path
, buf
, 0);
4354 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
4356 /* Rely on a hack: an open directory is modeled as file descriptor 0.
4357 This is good enough for the current usage in Emacs, but is fragile.
4359 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
4360 Gnulib does this and can serve as a model. */
4361 char fullname
[MAX_PATH
];
4365 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
4368 errno
= ENAMETOOLONG
;
4374 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
4377 /* Provide fstat and utime as well as stat for consistent handling of
4380 fstat (int desc
, struct stat
* buf
)
4382 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
4383 BY_HANDLE_FILE_INFORMATION info
;
4384 unsigned __int64 fake_inode
;
4387 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4389 case FILE_TYPE_DISK
:
4390 buf
->st_mode
= S_IFREG
;
4391 if (!GetFileInformationByHandle (fh
, &info
))
4397 case FILE_TYPE_PIPE
:
4398 buf
->st_mode
= S_IFIFO
;
4400 case FILE_TYPE_CHAR
:
4401 case FILE_TYPE_UNKNOWN
:
4403 buf
->st_mode
= S_IFCHR
;
4405 memset (&info
, 0, sizeof (info
));
4406 info
.dwFileAttributes
= 0;
4407 info
.ftCreationTime
= utc_base_ft
;
4408 info
.ftLastAccessTime
= utc_base_ft
;
4409 info
.ftLastWriteTime
= utc_base_ft
;
4412 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4413 buf
->st_mode
= S_IFDIR
;
4415 buf
->st_nlink
= info
.nNumberOfLinks
;
4416 /* Might as well use file index to fake inode values, but this
4417 is not guaranteed to be unique unless we keep a handle open
4418 all the time (even then there are situations where it is
4419 not unique). Reputedly, there are at most 48 bits of info
4420 (on NTFS, presumably less on FAT). */
4421 fake_inode
= info
.nFileIndexHigh
;
4423 fake_inode
+= info
.nFileIndexLow
;
4425 /* MSVC defines _ino_t to be short; other libc's might not. */
4426 if (sizeof (buf
->st_ino
) == 2)
4427 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4429 buf
->st_ino
= fake_inode
;
4431 /* If the caller so requested, get the true file owner and group.
4432 Otherwise, consider the file to belong to the current user. */
4433 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4434 get_file_owner_and_group (NULL
, buf
);
4437 PSECURITY_DESCRIPTOR psd
= NULL
;
4439 psd
= get_file_security_desc_by_handle (fh
);
4442 get_file_owner_and_group (psd
, buf
);
4446 get_file_owner_and_group (NULL
, buf
);
4449 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4450 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4452 buf
->st_size
= info
.nFileSizeHigh
;
4453 buf
->st_size
<<= 32;
4454 buf
->st_size
+= info
.nFileSizeLow
;
4456 /* Convert timestamps to Unix format. */
4457 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4458 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4459 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4460 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4461 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4463 /* determine rwx permissions */
4464 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4465 permission
= S_IREAD
;
4467 permission
= S_IREAD
| S_IWRITE
;
4469 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4470 permission
|= S_IEXEC
;
4473 #if 0 /* no way of knowing the filename */
4474 char * p
= strrchr (name
, '.');
4476 (xstrcasecmp (p
, ".exe") == 0 ||
4477 xstrcasecmp (p
, ".com") == 0 ||
4478 xstrcasecmp (p
, ".bat") == 0 ||
4479 xstrcasecmp (p
, ".cmd") == 0))
4480 permission
|= S_IEXEC
;
4484 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4490 utime (const char *name
, struct utimbuf
*times
)
4492 struct utimbuf deftime
;
4499 deftime
.modtime
= deftime
.actime
= time (NULL
);
4503 /* Need write access to set times. */
4504 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
4505 /* If NAME specifies a directory, FILE_SHARE_DELETE
4506 allows other processes to delete files inside it,
4507 while we have the directory open. */
4508 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4509 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4510 if (fh
!= INVALID_HANDLE_VALUE
)
4512 convert_from_time_t (times
->actime
, &atime
);
4513 convert_from_time_t (times
->modtime
, &mtime
);
4514 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4531 /* Symlink-related functions. */
4532 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4533 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4537 symlink (char const *filename
, char const *linkname
)
4539 char linkfn
[MAX_PATH
], *tgtfn
;
4541 int dir_access
, filename_ends_in_slash
;
4544 /* Diagnostics follows Posix as much as possible. */
4545 if (filename
== NULL
|| linkname
== NULL
)
4555 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4557 errno
= ENAMETOOLONG
;
4561 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4562 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4568 dbcs_p
= max_filename_mbslen () > 1;
4570 /* Note: since empty FILENAME was already rejected, we can safely
4571 refer to FILENAME[1]. */
4572 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4574 /* Non-absolute FILENAME is understood as being relative to
4575 LINKNAME's directory. We need to prepend that directory to
4576 FILENAME to get correct results from faccessat below, since
4577 otherwise it will interpret FILENAME relative to the
4578 directory where the Emacs process runs. Note that
4579 make-symbolic-link always makes sure LINKNAME is a fully
4580 expanded file name. */
4582 char *p
= linkfn
+ strlen (linkfn
);
4586 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4591 char *p1
= CharPrevExA (file_name_codepage
, linkfn
, p
, 0);
4593 while (p
> linkfn
&& !IS_ANY_SEP (*p1
))
4596 p1
= CharPrevExA (file_name_codepage
, linkfn
, p1
, 0);
4600 strncpy (tem
, linkfn
, p
- linkfn
);
4601 tem
[p
- linkfn
] = '\0';
4602 strcat (tem
, filename
);
4603 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4606 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4608 /* Since Windows distinguishes between symlinks to directories and
4609 to files, we provide a kludgy feature: if FILENAME doesn't
4610 exist, but ends in a slash, we create a symlink to directory. If
4611 FILENAME exists and is a directory, we always create a symlink to
4614 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4617 const char *end
= filename
+ strlen (filename
);
4618 const char *n
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
4620 filename_ends_in_slash
= IS_DIRECTORY_SEP (*n
);
4622 if (dir_access
== 0 || filename_ends_in_slash
)
4623 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4625 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4626 if (filename_ends_in_slash
)
4627 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4630 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4632 /* ENOSYS is set by create_symbolic_link, when it detects that
4633 the OS doesn't support the CreateSymbolicLink API. */
4634 if (errno
!= ENOSYS
)
4636 DWORD w32err
= GetLastError ();
4640 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4641 TGTFN point to the same file name, go figure. */
4643 case ERROR_FILE_EXISTS
:
4646 case ERROR_ACCESS_DENIED
:
4649 case ERROR_FILE_NOT_FOUND
:
4650 case ERROR_PATH_NOT_FOUND
:
4651 case ERROR_BAD_NETPATH
:
4652 case ERROR_INVALID_REPARSE_DATA
:
4655 case ERROR_DIRECTORY
:
4658 case ERROR_PRIVILEGE_NOT_HELD
:
4659 case ERROR_NOT_ALL_ASSIGNED
:
4662 case ERROR_DISK_FULL
:
4675 /* A quick inexpensive test of whether FILENAME identifies a file that
4676 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4677 must already be in the normalized form returned by
4680 Note: for repeated operations on many files, it is best to test
4681 whether the underlying volume actually supports symlinks, by
4682 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4683 avoid the call to this function if it doesn't. That's because the
4684 call to GetFileAttributes takes a non-negligible time, especially
4685 on non-local or removable filesystems. See stat_worker for an
4686 example of how to do that. */
4688 is_symlink (const char *filename
)
4691 WIN32_FIND_DATA wfd
;
4694 attrs
= GetFileAttributes (filename
);
4697 DWORD w32err
= GetLastError ();
4701 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4703 case ERROR_ACCESS_DENIED
:
4706 case ERROR_FILE_NOT_FOUND
:
4707 case ERROR_PATH_NOT_FOUND
:
4714 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4716 logon_network_drive (filename
);
4717 fh
= FindFirstFile (filename
, &wfd
);
4718 if (fh
== INVALID_HANDLE_VALUE
)
4721 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4722 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4725 /* If NAME identifies a symbolic link, copy into BUF the file name of
4726 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4727 null-terminate the target name, even if it fits. Return the number
4728 of bytes copied, or -1 if NAME is not a symlink or any error was
4729 encountered while resolving it. The file name copied into BUF is
4730 encoded in the current ANSI codepage. */
4732 readlink (const char *name
, char *buf
, size_t buf_size
)
4735 TOKEN_PRIVILEGES privs
;
4736 int restore_privs
= 0;
4751 path
= map_w32_filename (name
, NULL
);
4753 if (strlen (path
) > MAX_PATH
)
4755 errno
= ENAMETOOLONG
;
4760 if (is_windows_9x () == TRUE
4761 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4762 || !is_symlink (path
))
4765 errno
= EINVAL
; /* not a symlink */
4769 /* Done with simple tests, now we're in for some _real_ work. */
4770 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4772 /* Implementation note: From here and onward, don't return early,
4773 since that will fail to restore the original set of privileges of
4774 the calling thread. */
4776 retval
= -1; /* not too optimistic, are we? */
4778 /* Note: In the next call to CreateFile, we use zero as the 2nd
4779 argument because, when the symlink is a hidden/system file,
4780 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4781 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4782 and directory symlinks. */
4783 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4784 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4786 if (sh
!= INVALID_HANDLE_VALUE
)
4788 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4789 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4792 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4793 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4796 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4800 /* Copy the link target name, in wide characters, from
4801 reparse_data, then convert it to multibyte encoding in
4802 the current locale's codepage. */
4804 BYTE lname
[MAX_PATH
];
4807 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4809 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4810 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4811 /* This updates file_name_codepage which we need below. */
4812 int dbcs_p
= max_filename_mbslen () > 1;
4814 /* According to MSDN, PrintNameLength does not include the
4815 terminating null character. */
4816 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4817 memcpy (lwname
, lwname_src
, lwname_len
);
4818 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4820 lname_len
= WideCharToMultiByte (file_name_codepage
, 0, lwname
, -1,
4821 lname
, MAX_PATH
, NULL
, NULL
);
4824 /* WideCharToMultiByte failed. */
4825 DWORD w32err1
= GetLastError ();
4829 case ERROR_INSUFFICIENT_BUFFER
:
4830 errno
= ENAMETOOLONG
;
4832 case ERROR_INVALID_PARAMETER
:
4835 case ERROR_NO_UNICODE_TRANSLATION
:
4845 size_t size_to_copy
= buf_size
;
4846 BYTE
*p
= lname
, *p2
;
4847 BYTE
*pend
= p
+ lname_len
;
4849 /* Normalize like dostounix_filename does, but we don't
4850 want to assume that lname is null-terminated. */
4852 p2
= CharNextExA (file_name_codepage
, p
, 0);
4855 if (*p
&& *p2
== ':' && *p
>= 'A' && *p
<= 'Z')
4866 p
= CharNextExA (file_name_codepage
, p
, 0);
4867 /* CharNextExA doesn't advance at null character. */
4874 /* Testing for null-terminated LNAME is paranoia:
4875 WideCharToMultiByte should always return a
4876 null-terminated string when its 4th argument is -1
4877 and its 3rd argument is null-terminated (which they
4879 if (lname
[lname_len
- 1] == '\0')
4881 if (lname_len
<= buf_size
)
4882 size_to_copy
= lname_len
;
4883 strncpy (buf
, lname
, size_to_copy
);
4885 retval
= size_to_copy
;
4892 /* CreateFile failed. */
4893 DWORD w32err2
= GetLastError ();
4897 case ERROR_FILE_NOT_FOUND
:
4898 case ERROR_PATH_NOT_FOUND
:
4901 case ERROR_ACCESS_DENIED
:
4902 case ERROR_TOO_MANY_OPEN_FILES
:
4912 restore_privilege (&privs
);
4920 readlinkat (int fd
, char const *name
, char *buffer
,
4923 /* Rely on a hack: an open directory is modeled as file descriptor 0,
4924 as in fstatat. FIXME: Add proper support for readlinkat. */
4925 char fullname
[MAX_PATH
];
4929 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
4932 errno
= ENAMETOOLONG
;
4938 return readlink (name
, buffer
, buffer_size
);
4941 /* If FILE is a symlink, return its target (stored in a static
4942 buffer); otherwise return FILE.
4944 This function repeatedly resolves symlinks in the last component of
4945 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4946 until it arrives at a file whose last component is not a symlink,
4947 or some error occurs. It returns the target of the last
4948 successfully resolved symlink in the chain. If it succeeds to
4949 resolve even a single symlink, the value returned is an absolute
4950 file name with backslashes (result of GetFullPathName). By
4951 contrast, if the original FILE is returned, it is unaltered.
4953 Note: This function can set errno even if it succeeds.
4955 Implementation note: we only resolve the last portion ("basename")
4956 of the argument FILE and of each following file in the chain,
4957 disregarding any possible symlinks in its leading directories.
4958 This is because Windows system calls and library functions
4959 transparently resolve symlinks in leading directories and return
4960 correct information, as long as the basename is not a symlink. */
4962 chase_symlinks (const char *file
)
4964 static char target
[MAX_PATH
];
4965 char link
[MAX_PATH
];
4966 ssize_t res
, link_len
;
4970 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4971 return (char *)file
;
4973 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4974 return (char *)file
;
4976 dbcs_p
= max_filename_mbslen () > 1;
4980 /* Remove trailing slashes, as we want to resolve the last
4981 non-trivial part of the link name. */
4984 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4985 link
[link_len
--] = '\0';
4987 else if (link_len
> 3)
4989 char *n
= CharPrevExA (file_name_codepage
, link
, link
+ link_len
, 0);
4991 while (n
>= link
+ 2 && IS_DIRECTORY_SEP (*n
))
4994 n
= CharPrevExA (file_name_codepage
, link
, n
, 0);
4998 res
= readlink (link
, target
, MAX_PATH
);
5002 if (!(IS_DEVICE_SEP (target
[1])
5003 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
5005 /* Target is relative. Append it to the directory part of
5006 the symlink, then copy the result back to target. */
5007 char *p
= link
+ link_len
;
5011 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
5016 char *p1
= CharPrevExA (file_name_codepage
, link
, p
, 0);
5018 while (p
> link
&& !IS_ANY_SEP (*p1
))
5021 p1
= CharPrevExA (file_name_codepage
, link
, p1
, 0);
5025 strcpy (target
, link
);
5027 /* Resolve any "." and ".." to get a fully-qualified file name
5029 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
5031 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
5033 if (loop_count
> 100)
5036 if (target
[0] == '\0') /* not a single call to readlink succeeded */
5037 return (char *)file
;
5042 /* Posix ACL emulation. */
5045 acl_valid (acl_t acl
)
5047 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
5051 acl_to_text (acl_t acl
, ssize_t
*size
)
5054 SECURITY_INFORMATION flags
=
5055 OWNER_SECURITY_INFORMATION
|
5056 GROUP_SECURITY_INFORMATION
|
5057 DACL_SECURITY_INFORMATION
;
5058 char *retval
= NULL
;
5064 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
5067 /* We don't want to mix heaps, so we duplicate the string in our
5068 heap and free the one allocated by the API. */
5069 retval
= xstrdup (str_acl
);
5072 LocalFree (str_acl
);
5074 else if (errno
!= ENOTSUP
)
5081 acl_from_text (const char *acl_str
)
5083 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
5089 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
5092 retval
= xmalloc (sd_size
);
5093 memcpy (retval
, psd
, sd_size
);
5096 else if (errno
!= ENOTSUP
)
5103 acl_free (void *ptr
)
5110 acl_get_file (const char *fname
, acl_type_t type
)
5112 PSECURITY_DESCRIPTOR psd
= NULL
;
5113 const char *filename
;
5115 if (type
== ACL_TYPE_ACCESS
)
5118 SECURITY_INFORMATION si
=
5119 OWNER_SECURITY_INFORMATION
|
5120 GROUP_SECURITY_INFORMATION
|
5121 DACL_SECURITY_INFORMATION
;
5124 filename
= map_w32_filename (fname
, NULL
);
5125 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5126 fname
= chase_symlinks (filename
);
5131 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
5132 && errno
!= ENOTSUP
)
5134 err
= GetLastError ();
5135 if (err
== ERROR_INSUFFICIENT_BUFFER
)
5137 psd
= xmalloc (sd_len
);
5138 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
5145 else if (err
== ERROR_FILE_NOT_FOUND
5146 || err
== ERROR_PATH_NOT_FOUND
)
5154 else if (type
!= ACL_TYPE_DEFAULT
)
5161 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
5163 TOKEN_PRIVILEGES old1
, old2
;
5165 int st
= 0, retval
= -1;
5166 SECURITY_INFORMATION flags
= 0;
5172 const char *filename
;
5174 if (acl_valid (acl
) != 0
5175 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
5181 if (type
== ACL_TYPE_DEFAULT
)
5187 filename
= map_w32_filename (fname
, NULL
);
5188 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5189 fname
= chase_symlinks (filename
);
5193 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5195 flags
|= OWNER_SECURITY_INFORMATION
;
5196 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5198 flags
|= GROUP_SECURITY_INFORMATION
;
5199 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
5202 flags
|= DACL_SECURITY_INFORMATION
;
5206 /* According to KB-245153, setting the owner will succeed if either:
5207 (1) the caller is the user who will be the new owner, and has the
5208 SE_TAKE_OWNERSHIP privilege, or
5209 (2) the caller has the SE_RESTORE privilege, in which case she can
5210 set any valid user or group as the owner
5212 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
5213 privileges, and disregard any failures in obtaining them. If
5214 these privileges cannot be obtained, and do not already exist in
5215 the calling thread's security token, this function could fail
5217 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
5219 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
5224 if (!set_file_security ((char *)fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
5226 err
= GetLastError ();
5228 if (errno
== ENOTSUP
)
5230 else if (err
== ERROR_INVALID_OWNER
5231 || err
== ERROR_NOT_ALL_ASSIGNED
5232 || err
== ERROR_ACCESS_DENIED
)
5234 /* Maybe the requested ACL and the one the file already has
5235 are identical, in which case we can silently ignore the
5236 failure. (And no, Windows doesn't.) */
5237 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
5242 char *acl_from
= acl_to_text (current_acl
, NULL
);
5243 char *acl_to
= acl_to_text (acl
, NULL
);
5245 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
5251 acl_free (acl_from
);
5254 acl_free (current_acl
);
5257 else if (err
== ERROR_FILE_NOT_FOUND
|| err
== ERROR_PATH_NOT_FOUND
)
5271 restore_privilege (&old2
);
5272 restore_privilege (&old1
);
5280 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
5281 have a fixed max size for file names, so we don't need the kind of
5282 alloc/malloc/realloc dance the gnulib version does. We also don't
5283 support FD-relative symlinks. */
5285 careadlinkat (int fd
, char const *filename
,
5286 char *buffer
, size_t buffer_size
,
5287 struct allocator
const *alloc
,
5288 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
5290 char linkname
[MAX_PATH
];
5293 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
5297 char *retval
= buffer
;
5299 linkname
[link_size
++] = '\0';
5300 if (link_size
> buffer_size
)
5301 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
5303 memcpy (retval
, linkname
, link_size
);
5311 /* Support for browsing other processes and their attributes. See
5312 process.c for the Lisp bindings. */
5314 /* Helper wrapper functions. */
5316 static HANDLE WINAPI
5317 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
5319 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
5321 if (g_b_init_create_toolhelp32_snapshot
== 0)
5323 g_b_init_create_toolhelp32_snapshot
= 1;
5324 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
5325 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5326 "CreateToolhelp32Snapshot");
5328 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
5330 return INVALID_HANDLE_VALUE
;
5332 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
5336 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5338 static Process32First_Proc s_pfn_Process32_First
= NULL
;
5340 if (g_b_init_process32_first
== 0)
5342 g_b_init_process32_first
= 1;
5343 s_pfn_Process32_First
= (Process32First_Proc
)
5344 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5347 if (s_pfn_Process32_First
== NULL
)
5351 return (s_pfn_Process32_First (hSnapshot
, lppe
));
5355 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5357 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
5359 if (g_b_init_process32_next
== 0)
5361 g_b_init_process32_next
= 1;
5362 s_pfn_Process32_Next
= (Process32Next_Proc
)
5363 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5366 if (s_pfn_Process32_Next
== NULL
)
5370 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
5374 open_thread_token (HANDLE ThreadHandle
,
5375 DWORD DesiredAccess
,
5377 PHANDLE TokenHandle
)
5379 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
5380 HMODULE hm_advapi32
= NULL
;
5381 if (is_windows_9x () == TRUE
)
5383 SetLastError (ERROR_NOT_SUPPORTED
);
5386 if (g_b_init_open_thread_token
== 0)
5388 g_b_init_open_thread_token
= 1;
5389 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5390 s_pfn_Open_Thread_Token
=
5391 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
5393 if (s_pfn_Open_Thread_Token
== NULL
)
5395 SetLastError (ERROR_NOT_SUPPORTED
);
5399 s_pfn_Open_Thread_Token (
5408 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
5410 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
5411 HMODULE hm_advapi32
= NULL
;
5412 if (is_windows_9x () == TRUE
)
5416 if (g_b_init_impersonate_self
== 0)
5418 g_b_init_impersonate_self
= 1;
5419 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5420 s_pfn_Impersonate_Self
=
5421 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
5423 if (s_pfn_Impersonate_Self
== NULL
)
5427 return s_pfn_Impersonate_Self (ImpersonationLevel
);
5431 revert_to_self (void)
5433 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
5434 HMODULE hm_advapi32
= NULL
;
5435 if (is_windows_9x () == TRUE
)
5439 if (g_b_init_revert_to_self
== 0)
5441 g_b_init_revert_to_self
= 1;
5442 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5443 s_pfn_Revert_To_Self
=
5444 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
5446 if (s_pfn_Revert_To_Self
== NULL
)
5450 return s_pfn_Revert_To_Self ();
5454 get_process_memory_info (HANDLE h_proc
,
5455 PPROCESS_MEMORY_COUNTERS mem_counters
,
5458 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
5459 HMODULE hm_psapi
= NULL
;
5460 if (is_windows_9x () == TRUE
)
5464 if (g_b_init_get_process_memory_info
== 0)
5466 g_b_init_get_process_memory_info
= 1;
5467 hm_psapi
= LoadLibrary ("Psapi.dll");
5469 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
5470 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
5472 if (s_pfn_Get_Process_Memory_Info
== NULL
)
5476 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
5480 get_process_working_set_size (HANDLE h_proc
,
5484 static GetProcessWorkingSetSize_Proc
5485 s_pfn_Get_Process_Working_Set_Size
= NULL
;
5487 if (is_windows_9x () == TRUE
)
5491 if (g_b_init_get_process_working_set_size
== 0)
5493 g_b_init_get_process_working_set_size
= 1;
5494 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
5495 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5496 "GetProcessWorkingSetSize");
5498 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
5502 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
5506 global_memory_status (MEMORYSTATUS
*buf
)
5508 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
5510 if (is_windows_9x () == TRUE
)
5514 if (g_b_init_global_memory_status
== 0)
5516 g_b_init_global_memory_status
= 1;
5517 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
5518 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5519 "GlobalMemoryStatus");
5521 if (s_pfn_Global_Memory_Status
== NULL
)
5525 return s_pfn_Global_Memory_Status (buf
);
5529 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
5531 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
5533 if (is_windows_9x () == TRUE
)
5537 if (g_b_init_global_memory_status_ex
== 0)
5539 g_b_init_global_memory_status_ex
= 1;
5540 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
5541 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5542 "GlobalMemoryStatusEx");
5544 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
5548 return s_pfn_Global_Memory_Status_Ex (buf
);
5552 list_system_processes (void)
5554 struct gcpro gcpro1
;
5555 Lisp_Object proclist
= Qnil
;
5558 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5560 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5562 PROCESSENTRY32 proc_entry
;
5568 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
5569 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
5570 res
= process32_next (h_snapshot
, &proc_entry
))
5572 proc_id
= proc_entry
.th32ProcessID
;
5573 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
5576 CloseHandle (h_snapshot
);
5578 proclist
= Fnreverse (proclist
);
5585 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
5587 TOKEN_PRIVILEGES priv
;
5588 DWORD priv_size
= sizeof (priv
);
5589 DWORD opriv_size
= sizeof (*old_priv
);
5590 HANDLE h_token
= NULL
;
5591 HANDLE h_thread
= GetCurrentThread ();
5595 res
= open_thread_token (h_thread
,
5596 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5598 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
5600 if (impersonate_self (SecurityImpersonation
))
5601 res
= open_thread_token (h_thread
,
5602 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5607 priv
.PrivilegeCount
= 1;
5608 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
5609 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
5610 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
5611 old_priv
, &opriv_size
)
5612 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5616 CloseHandle (h_token
);
5622 restore_privilege (TOKEN_PRIVILEGES
*priv
)
5624 DWORD priv_size
= sizeof (*priv
);
5625 HANDLE h_token
= NULL
;
5628 if (open_thread_token (GetCurrentThread (),
5629 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5632 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
5633 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5637 CloseHandle (h_token
);
5643 ltime (ULONGLONG time_100ns
)
5645 ULONGLONG time_sec
= time_100ns
/ 10000000;
5646 int subsec
= time_100ns
% 10000000;
5647 return list4i (time_sec
>> 16, time_sec
& 0xffff,
5648 subsec
/ 10, subsec
% 10 * 100000);
5651 #define U64_TO_LISP_TIME(time) ltime (time)
5654 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
5655 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
5658 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
5659 ULONGLONG tem1
, tem2
, tem3
, tem
;
5662 || !get_process_times_fn
5663 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
5664 &ft_kernel
, &ft_user
))
5667 GetSystemTimeAsFileTime (&ft_current
);
5669 FILETIME_TO_U64 (tem1
, ft_kernel
);
5670 *stime
= U64_TO_LISP_TIME (tem1
);
5672 FILETIME_TO_U64 (tem2
, ft_user
);
5673 *utime
= U64_TO_LISP_TIME (tem2
);
5676 *ttime
= U64_TO_LISP_TIME (tem3
);
5678 FILETIME_TO_U64 (tem
, ft_creation
);
5679 /* Process no 4 (System) returns zero creation time. */
5682 *ctime
= U64_TO_LISP_TIME (tem
);
5686 FILETIME_TO_U64 (tem3
, ft_current
);
5687 tem
= (tem3
- utc_base
) - tem
;
5689 *etime
= U64_TO_LISP_TIME (tem
);
5693 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
5704 system_process_attributes (Lisp_Object pid
)
5706 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5707 Lisp_Object attrs
= Qnil
;
5708 Lisp_Object cmd_str
, decoded_cmd
, tem
;
5709 HANDLE h_snapshot
, h_proc
;
5712 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
5713 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
5714 DWORD glength
= sizeof (gname
);
5715 HANDLE token
= NULL
;
5716 SID_NAME_USE user_type
;
5717 unsigned char *buf
= NULL
;
5719 TOKEN_USER user_token
;
5720 TOKEN_PRIMARY_GROUP group_token
;
5723 PROCESS_MEMORY_COUNTERS mem
;
5724 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
5725 SIZE_T minrss
, maxrss
;
5727 MEMORY_STATUS_EX memstex
;
5728 double totphys
= 0.0;
5729 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
5731 BOOL result
= FALSE
;
5733 CHECK_NUMBER_OR_FLOAT (pid
);
5734 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
5736 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5738 GCPRO3 (attrs
, decoded_cmd
, tem
);
5740 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5745 pe
.dwSize
= sizeof (PROCESSENTRY32
);
5746 for (res
= process32_first (h_snapshot
, &pe
); res
;
5747 res
= process32_next (h_snapshot
, &pe
))
5749 if (proc_id
== pe
.th32ProcessID
)
5752 decoded_cmd
= build_string ("Idle");
5755 /* Decode the command name from locale-specific
5757 cmd_str
= make_unibyte_string (pe
.szExeFile
,
5758 strlen (pe
.szExeFile
));
5760 code_convert_string_norecord (cmd_str
,
5761 Vlocale_coding_system
, 0);
5763 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
5764 attrs
= Fcons (Fcons (Qppid
,
5765 make_fixnum_or_float (pe
.th32ParentProcessID
)),
5767 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
5769 attrs
= Fcons (Fcons (Qthcount
,
5770 make_fixnum_or_float (pe
.cntThreads
)),
5777 CloseHandle (h_snapshot
);
5786 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5788 /* If we were denied a handle to the process, try again after
5789 enabling the SeDebugPrivilege in our process. */
5792 TOKEN_PRIVILEGES priv_current
;
5794 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
5796 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5798 restore_privilege (&priv_current
);
5804 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
5807 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
5808 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5810 buf
= xmalloc (blen
);
5811 result
= get_token_information (token
, TokenUser
,
5812 (LPVOID
)buf
, blen
, &needed
);
5815 memcpy (&user_token
, buf
, sizeof (user_token
));
5816 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
5818 euid
= get_rid (user_token
.User
.Sid
);
5819 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
5824 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
5827 strcpy (uname
, "unknown");
5831 ulength
= strlen (uname
);
5837 /* Determine a reasonable euid and gid values. */
5838 if (xstrcasecmp ("administrator", uname
) == 0)
5840 euid
= 500; /* well-known Administrator uid */
5841 egid
= 513; /* well-known None gid */
5845 /* Get group id and name. */
5846 result
= get_token_information (token
, TokenPrimaryGroup
,
5847 (LPVOID
)buf
, blen
, &needed
);
5848 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5850 buf
= xrealloc (buf
, blen
= needed
);
5851 result
= get_token_information (token
, TokenPrimaryGroup
,
5852 (LPVOID
)buf
, blen
, &needed
);
5856 memcpy (&group_token
, buf
, sizeof (group_token
));
5857 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5859 egid
= get_rid (group_token
.PrimaryGroup
);
5860 dlength
= sizeof (domain
);
5862 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5863 gname
, &glength
, NULL
, &dlength
,
5866 w32_add_to_cache (group_token
.PrimaryGroup
,
5870 strcpy (gname
, "None");
5874 glength
= strlen (gname
);
5882 if (!is_windows_9x ())
5884 /* We couldn't open the process token, presumably because of
5885 insufficient access rights. Assume this process is run
5887 strcpy (uname
, "SYSTEM");
5888 strcpy (gname
, "None");
5889 euid
= 18; /* SYSTEM */
5890 egid
= 513; /* None */
5891 glength
= strlen (gname
);
5892 ulength
= strlen (uname
);
5894 /* If we are running under Windows 9X, where security calls are
5895 not supported, we assume all processes are run by the current
5897 else if (GetUserName (uname
, &ulength
))
5899 if (xstrcasecmp ("administrator", uname
) == 0)
5904 strcpy (gname
, "None");
5905 glength
= strlen (gname
);
5906 ulength
= strlen (uname
);
5912 strcpy (uname
, "administrator");
5913 ulength
= strlen (uname
);
5914 strcpy (gname
, "None");
5915 glength
= strlen (gname
);
5918 CloseHandle (token
);
5921 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5922 tem
= make_unibyte_string (uname
, ulength
);
5923 attrs
= Fcons (Fcons (Quser
,
5924 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5926 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5927 tem
= make_unibyte_string (gname
, glength
);
5928 attrs
= Fcons (Fcons (Qgroup
,
5929 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5932 if (global_memory_status_ex (&memstex
))
5933 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5934 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5936 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5937 double, so we need to do this for it... */
5939 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5940 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5941 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5943 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5945 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5946 else if (global_memory_status (&memst
))
5947 totphys
= memst
.dwTotalPhys
/ 1024.0;
5950 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5953 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5955 attrs
= Fcons (Fcons (Qmajflt
,
5956 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5958 attrs
= Fcons (Fcons (Qvsize
,
5959 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5961 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5963 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5966 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5968 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5970 attrs
= Fcons (Fcons (Qmajflt
,
5971 make_fixnum_or_float (mem
.PageFaultCount
)),
5973 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5975 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5978 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5980 DWORD rss
= maxrss
/ 1024;
5982 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5984 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5987 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5989 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5990 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5991 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5992 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5993 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5994 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5997 /* FIXME: Retrieve command line by walking the PEB of the process. */
6000 CloseHandle (h_proc
);
6006 /* Wrappers for winsock functions to map between our file descriptors
6007 and winsock's handles; also set h_errno for convenience.
6009 To allow Emacs to run on systems which don't have winsock support
6010 installed, we dynamically link to winsock on startup if present, and
6011 otherwise provide the minimum necessary functionality
6012 (eg. gethostname). */
6014 /* function pointers for relevant socket functions */
6015 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
6016 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
6017 int (PASCAL
*pfn_WSAGetLastError
) (void);
6018 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
6019 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
6020 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
6021 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
6022 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6023 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
6024 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
6025 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
6026 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
6027 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
6028 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
6029 int (PASCAL
*pfn_WSACleanup
) (void);
6031 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
6032 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
6033 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
6034 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
6035 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
6036 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
6037 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
6038 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
6039 const char * optval
, int optlen
);
6040 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
6041 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
6043 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
6044 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
6045 struct sockaddr
* from
, int * fromlen
);
6046 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
6047 const struct sockaddr
* to
, int tolen
);
6049 /* SetHandleInformation is only needed to make sockets non-inheritable. */
6050 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
6051 #ifndef HANDLE_FLAG_INHERIT
6052 #define HANDLE_FLAG_INHERIT 1
6056 static int winsock_inuse
;
6061 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
6063 /* Not sure what would cause WSAENETDOWN, or even if it can happen
6064 after WSAStartup returns successfully, but it seems reasonable
6065 to allow unloading winsock anyway in that case. */
6066 if (pfn_WSACleanup () == 0 ||
6067 pfn_WSAGetLastError () == WSAENETDOWN
)
6069 if (FreeLibrary (winsock_lib
))
6078 init_winsock (int load_now
)
6080 WSADATA winsockData
;
6082 if (winsock_lib
!= NULL
)
6085 pfn_SetHandleInformation
6086 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
6087 "SetHandleInformation");
6089 winsock_lib
= LoadLibrary ("Ws2_32.dll");
6091 if (winsock_lib
!= NULL
)
6093 /* dynamically link to socket functions */
6095 #define LOAD_PROC(fn) \
6096 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
6099 LOAD_PROC (WSAStartup
);
6100 LOAD_PROC (WSASetLastError
);
6101 LOAD_PROC (WSAGetLastError
);
6102 LOAD_PROC (WSAEventSelect
);
6103 LOAD_PROC (WSACreateEvent
);
6104 LOAD_PROC (WSACloseEvent
);
6107 LOAD_PROC (connect
);
6108 LOAD_PROC (ioctlsocket
);
6111 LOAD_PROC (closesocket
);
6112 LOAD_PROC (shutdown
);
6115 LOAD_PROC (inet_addr
);
6116 LOAD_PROC (gethostname
);
6117 LOAD_PROC (gethostbyname
);
6118 LOAD_PROC (getservbyname
);
6119 LOAD_PROC (getpeername
);
6120 LOAD_PROC (WSACleanup
);
6121 LOAD_PROC (setsockopt
);
6123 LOAD_PROC (getsockname
);
6125 LOAD_PROC (recvfrom
);
6129 /* specify version 1.1 of winsock */
6130 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
6132 if (winsockData
.wVersion
!= 0x101)
6137 /* Report that winsock exists and is usable, but leave
6138 socket functions disabled. I am assuming that calling
6139 WSAStartup does not require any network interaction,
6140 and in particular does not cause or require a dial-up
6141 connection to be established. */
6144 FreeLibrary (winsock_lib
);
6152 FreeLibrary (winsock_lib
);
6162 /* Function to map winsock error codes to errno codes for those errno
6163 code defined in errno.h (errno values not defined by errno.h are
6164 already in nt/inc/sys/socket.h). */
6171 if (winsock_lib
== NULL
)
6174 wsa_err
= pfn_WSAGetLastError ();
6178 case WSAEACCES
: errno
= EACCES
; break;
6179 case WSAEBADF
: errno
= EBADF
; break;
6180 case WSAEFAULT
: errno
= EFAULT
; break;
6181 case WSAEINTR
: errno
= EINTR
; break;
6182 case WSAEINVAL
: errno
= EINVAL
; break;
6183 case WSAEMFILE
: errno
= EMFILE
; break;
6184 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
6185 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
6186 default: errno
= wsa_err
; break;
6194 if (winsock_lib
!= NULL
)
6195 pfn_WSASetLastError (0);
6198 /* Extend strerror to handle the winsock-specific error codes. */
6202 } _wsa_errlist
[] = {
6203 {WSAEINTR
, "Interrupted function call"},
6204 {WSAEBADF
, "Bad file descriptor"},
6205 {WSAEACCES
, "Permission denied"},
6206 {WSAEFAULT
, "Bad address"},
6207 {WSAEINVAL
, "Invalid argument"},
6208 {WSAEMFILE
, "Too many open files"},
6210 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
6211 {WSAEINPROGRESS
, "Operation now in progress"},
6212 {WSAEALREADY
, "Operation already in progress"},
6213 {WSAENOTSOCK
, "Socket operation on non-socket"},
6214 {WSAEDESTADDRREQ
, "Destination address required"},
6215 {WSAEMSGSIZE
, "Message too long"},
6216 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
6217 {WSAENOPROTOOPT
, "Bad protocol option"},
6218 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
6219 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
6220 {WSAEOPNOTSUPP
, "Operation not supported"},
6221 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
6222 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
6223 {WSAEADDRINUSE
, "Address already in use"},
6224 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
6225 {WSAENETDOWN
, "Network is down"},
6226 {WSAENETUNREACH
, "Network is unreachable"},
6227 {WSAENETRESET
, "Network dropped connection on reset"},
6228 {WSAECONNABORTED
, "Software caused connection abort"},
6229 {WSAECONNRESET
, "Connection reset by peer"},
6230 {WSAENOBUFS
, "No buffer space available"},
6231 {WSAEISCONN
, "Socket is already connected"},
6232 {WSAENOTCONN
, "Socket is not connected"},
6233 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
6234 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
6235 {WSAETIMEDOUT
, "Connection timed out"},
6236 {WSAECONNREFUSED
, "Connection refused"},
6237 {WSAELOOP
, "Network loop"}, /* not sure */
6238 {WSAENAMETOOLONG
, "Name is too long"},
6239 {WSAEHOSTDOWN
, "Host is down"},
6240 {WSAEHOSTUNREACH
, "No route to host"},
6241 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
6242 {WSAEPROCLIM
, "Too many processes"},
6243 {WSAEUSERS
, "Too many users"}, /* not sure */
6244 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
6245 {WSAESTALE
, "Data is stale"}, /* not sure */
6246 {WSAEREMOTE
, "Remote error"}, /* not sure */
6248 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
6249 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
6250 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
6251 {WSAEDISCON
, "Graceful shutdown in progress"},
6253 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
6254 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
6255 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
6256 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
6257 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
6258 {WSASYSCALLFAILURE
, "System call failure"},
6259 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
6260 {WSATYPE_NOT_FOUND
, "Class type not found"},
6261 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
6262 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
6263 {WSAEREFUSED
, "Operation refused"}, /* not sure */
6266 {WSAHOST_NOT_FOUND
, "Host not found"},
6267 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
6268 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
6269 {WSANO_DATA
, "Valid name, no data record of requested type"},
6275 sys_strerror (int error_no
)
6278 static char unknown_msg
[40];
6280 if (error_no
>= 0 && error_no
< sys_nerr
)
6281 return sys_errlist
[error_no
];
6283 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
6284 if (_wsa_errlist
[i
].errnum
== error_no
)
6285 return _wsa_errlist
[i
].msg
;
6287 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
6291 /* [andrewi 3-May-96] I've had conflicting results using both methods,
6292 but I believe the method of keeping the socket handle separate (and
6293 insuring it is not inheritable) is the correct one. */
6295 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
6297 static int socket_to_fd (SOCKET s
);
6300 sys_socket (int af
, int type
, int protocol
)
6304 if (winsock_lib
== NULL
)
6307 return INVALID_SOCKET
;
6312 /* call the real socket function */
6313 s
= pfn_socket (af
, type
, protocol
);
6315 if (s
!= INVALID_SOCKET
)
6316 return socket_to_fd (s
);
6322 /* Convert a SOCKET to a file descriptor. */
6324 socket_to_fd (SOCKET s
)
6329 /* Although under NT 3.5 _open_osfhandle will accept a socket
6330 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
6331 that does not work under NT 3.1. However, we can get the same
6332 effect by using a backdoor function to replace an existing
6333 descriptor handle with the one we want. */
6335 /* allocate a file descriptor (with appropriate flags) */
6336 fd
= _open ("NUL:", _O_RDWR
);
6339 /* Make a non-inheritable copy of the socket handle. Note
6340 that it is possible that sockets aren't actually kernel
6341 handles, which appears to be the case on Windows 9x when
6342 the MS Proxy winsock client is installed. */
6344 /* Apparently there is a bug in NT 3.51 with some service
6345 packs, which prevents using DuplicateHandle to make a
6346 socket handle non-inheritable (causes WSACleanup to
6347 hang). The work-around is to use SetHandleInformation
6348 instead if it is available and implemented. */
6349 if (pfn_SetHandleInformation
)
6351 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
6355 HANDLE parent
= GetCurrentProcess ();
6356 HANDLE new_s
= INVALID_HANDLE_VALUE
;
6358 if (DuplicateHandle (parent
,
6364 DUPLICATE_SAME_ACCESS
))
6366 /* It is possible that DuplicateHandle succeeds even
6367 though the socket wasn't really a kernel handle,
6368 because a real handle has the same value. So
6369 test whether the new handle really is a socket. */
6370 long nonblocking
= 0;
6371 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
6373 pfn_closesocket (s
);
6378 CloseHandle (new_s
);
6383 eassert (fd
< MAXDESC
);
6384 fd_info
[fd
].hnd
= (HANDLE
) s
;
6386 /* set our own internal flags */
6387 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
6393 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6395 /* attach child_process to fd_info */
6396 if (fd_info
[ fd
].cp
!= NULL
)
6398 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
6402 fd_info
[ fd
].cp
= cp
;
6405 winsock_inuse
++; /* count open sockets */
6413 pfn_closesocket (s
);
6419 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
6421 if (winsock_lib
== NULL
)
6424 return SOCKET_ERROR
;
6428 if (fd_info
[s
].flags
& FILE_SOCKET
)
6430 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
6431 if (rc
== SOCKET_ERROR
)
6436 return SOCKET_ERROR
;
6440 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
6442 if (winsock_lib
== NULL
)
6445 return SOCKET_ERROR
;
6449 if (fd_info
[s
].flags
& FILE_SOCKET
)
6451 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
6452 if (rc
== SOCKET_ERROR
)
6457 return SOCKET_ERROR
;
6461 sys_htons (u_short hostshort
)
6463 return (winsock_lib
!= NULL
) ?
6464 pfn_htons (hostshort
) : hostshort
;
6468 sys_ntohs (u_short netshort
)
6470 return (winsock_lib
!= NULL
) ?
6471 pfn_ntohs (netshort
) : netshort
;
6475 sys_inet_addr (const char * cp
)
6477 return (winsock_lib
!= NULL
) ?
6478 pfn_inet_addr (cp
) : INADDR_NONE
;
6482 sys_gethostname (char * name
, int namelen
)
6484 if (winsock_lib
!= NULL
)
6489 retval
= pfn_gethostname (name
, namelen
);
6490 if (retval
== SOCKET_ERROR
)
6495 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
6496 return !GetComputerName (name
, (DWORD
*)&namelen
);
6499 return SOCKET_ERROR
;
6503 sys_gethostbyname (const char * name
)
6505 struct hostent
* host
;
6506 int h_err
= h_errno
;
6508 if (winsock_lib
== NULL
)
6510 h_errno
= NO_RECOVERY
;
6516 host
= pfn_gethostbyname (name
);
6528 sys_getservbyname (const char * name
, const char * proto
)
6530 struct servent
* serv
;
6532 if (winsock_lib
== NULL
)
6539 serv
= pfn_getservbyname (name
, proto
);
6546 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
6548 if (winsock_lib
== NULL
)
6551 return SOCKET_ERROR
;
6555 if (fd_info
[s
].flags
& FILE_SOCKET
)
6557 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
6558 if (rc
== SOCKET_ERROR
)
6563 return SOCKET_ERROR
;
6567 sys_shutdown (int s
, int how
)
6569 if (winsock_lib
== NULL
)
6572 return SOCKET_ERROR
;
6576 if (fd_info
[s
].flags
& FILE_SOCKET
)
6578 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
6579 if (rc
== SOCKET_ERROR
)
6584 return SOCKET_ERROR
;
6588 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
6590 if (winsock_lib
== NULL
)
6593 return SOCKET_ERROR
;
6597 if (fd_info
[s
].flags
& FILE_SOCKET
)
6599 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
6600 (const char *)optval
, optlen
);
6601 if (rc
== SOCKET_ERROR
)
6606 return SOCKET_ERROR
;
6610 sys_listen (int s
, int backlog
)
6612 if (winsock_lib
== NULL
)
6615 return SOCKET_ERROR
;
6619 if (fd_info
[s
].flags
& FILE_SOCKET
)
6621 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
6622 if (rc
== SOCKET_ERROR
)
6625 fd_info
[s
].flags
|= FILE_LISTEN
;
6629 return SOCKET_ERROR
;
6633 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
6635 if (winsock_lib
== NULL
)
6638 return SOCKET_ERROR
;
6642 if (fd_info
[s
].flags
& FILE_SOCKET
)
6644 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
6645 if (rc
== SOCKET_ERROR
)
6650 return SOCKET_ERROR
;
6654 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
6656 if (winsock_lib
== NULL
)
6663 if (fd_info
[s
].flags
& FILE_LISTEN
)
6665 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
6667 if (t
== INVALID_SOCKET
)
6670 fd
= socket_to_fd (t
);
6674 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6675 ResetEvent (fd_info
[s
].cp
->char_avail
);
6684 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
6685 struct sockaddr
* from
, int * fromlen
)
6687 if (winsock_lib
== NULL
)
6690 return SOCKET_ERROR
;
6694 if (fd_info
[s
].flags
& FILE_SOCKET
)
6696 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
6697 if (rc
== SOCKET_ERROR
)
6702 return SOCKET_ERROR
;
6706 sys_sendto (int s
, const char * buf
, int len
, int flags
,
6707 const struct sockaddr
* to
, int tolen
)
6709 if (winsock_lib
== NULL
)
6712 return SOCKET_ERROR
;
6716 if (fd_info
[s
].flags
& FILE_SOCKET
)
6718 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
6719 if (rc
== SOCKET_ERROR
)
6724 return SOCKET_ERROR
;
6727 /* Windows does not have an fcntl function. Provide an implementation
6728 good enough for Emacs. */
6730 fcntl (int s
, int cmd
, int options
)
6732 /* In the w32 Emacs port, fcntl (fd, F_DUPFD_CLOEXEC, fd1) is always
6733 invoked in a context where fd1 is closed and all descriptors less
6734 than fd1 are open, so sys_dup is an adequate implementation. */
6735 if (cmd
== F_DUPFD_CLOEXEC
)
6738 if (winsock_lib
== NULL
)
6745 if (fd_info
[s
].flags
& FILE_SOCKET
)
6747 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
6749 unsigned long nblock
= 1;
6750 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
6751 if (rc
== SOCKET_ERROR
)
6753 /* Keep track of the fact that we set this to non-blocking. */
6754 fd_info
[s
].flags
|= FILE_NDELAY
;
6760 return SOCKET_ERROR
;
6764 return SOCKET_ERROR
;
6768 /* Shadow main io functions: we need to handle pipes and sockets more
6769 intelligently, and implement non-blocking mode as well. */
6782 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
6784 child_process
* cp
= fd_info
[fd
].cp
;
6786 fd_info
[fd
].cp
= NULL
;
6788 if (CHILD_ACTIVE (cp
))
6790 /* if last descriptor to active child_process then cleanup */
6792 for (i
= 0; i
< MAXDESC
; i
++)
6796 if (fd_info
[i
].cp
== cp
)
6801 if (fd_info
[fd
].flags
& FILE_SOCKET
)
6803 if (winsock_lib
== NULL
) emacs_abort ();
6805 pfn_shutdown (SOCK_HANDLE (fd
), 2);
6806 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
6808 winsock_inuse
--; /* count open sockets */
6810 /* If the process handle is NULL, it's either a socket
6811 or serial connection, or a subprocess that was
6812 already reaped by reap_subprocess, but whose
6813 resources were not yet freed, because its output was
6814 not fully read yet by the time it was reaped. (This
6815 usually happens with async subprocesses whose output
6816 is being read by Emacs.) Otherwise, this process was
6817 not reaped yet, so we set its FD to a negative value
6818 to make sure sys_select will eventually get to
6819 calling the SIGCHLD handler for it, which will then
6820 invoke waitpid and reap_subprocess. */
6821 if (cp
->procinfo
.hProcess
== NULL
)
6829 if (fd
>= 0 && fd
< MAXDESC
)
6830 fd_info
[fd
].flags
= 0;
6832 /* Note that sockets do not need special treatment here (at least on
6833 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6834 closesocket is equivalent to CloseHandle, which is to be expected
6835 because socket handles are fully fledged kernel handles. */
6847 if (new_fd
>= 0 && new_fd
< MAXDESC
)
6849 /* duplicate our internal info as well */
6850 fd_info
[new_fd
] = fd_info
[fd
];
6856 sys_dup2 (int src
, int dst
)
6860 if (dst
< 0 || dst
>= MAXDESC
)
6866 /* make sure we close the destination first if it's a pipe or socket */
6867 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
6870 rc
= _dup2 (src
, dst
);
6873 /* duplicate our internal info as well */
6874 fd_info
[dst
] = fd_info
[src
];
6880 pipe2 (int * phandles
, int pipe2_flags
)
6885 eassert (pipe2_flags
== O_CLOEXEC
);
6887 /* make pipe handles non-inheritable; when we spawn a child, we
6888 replace the relevant handle with an inheritable one. Also put
6889 pipes into binary mode; we will do text mode translation ourselves
6891 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
6895 /* Protect against overflow, since Windows can open more handles than
6896 our fd_info array has room for. */
6897 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
6899 _close (phandles
[0]);
6900 _close (phandles
[1]);
6906 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6907 fd_info
[phandles
[0]].flags
= flags
;
6909 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6910 fd_info
[phandles
[1]].flags
= flags
;
6917 /* Function to do blocking read of one byte, needed to implement
6918 select. It is only allowed on communication ports, sockets, or
6921 _sys_read_ahead (int fd
)
6926 if (fd
< 0 || fd
>= MAXDESC
)
6927 return STATUS_READ_ERROR
;
6929 cp
= fd_info
[fd
].cp
;
6931 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6932 return STATUS_READ_ERROR
;
6934 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6935 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6937 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6941 cp
->status
= STATUS_READ_IN_PROGRESS
;
6943 if (fd_info
[fd
].flags
& FILE_PIPE
)
6945 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6947 /* Give subprocess time to buffer some more output for us before
6948 reporting that input is available; we need this because Windows 95
6949 connects DOS programs to pipes by making the pipe appear to be
6950 the normal console stdout - as a result most DOS programs will
6951 write to stdout without buffering, ie. one character at a
6952 time. Even some W32 programs do this - "dir" in a command
6953 shell on NT is very slow if we don't do this. */
6956 int wait
= w32_pipe_read_delay
;
6962 /* Yield remainder of our time slice, effectively giving a
6963 temporary priority boost to the child process. */
6967 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6969 HANDLE hnd
= fd_info
[fd
].hnd
;
6970 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6973 /* Configure timeouts for blocking read. */
6974 if (!GetCommTimeouts (hnd
, &ct
))
6976 cp
->status
= STATUS_READ_ERROR
;
6977 return STATUS_READ_ERROR
;
6979 ct
.ReadIntervalTimeout
= 0;
6980 ct
.ReadTotalTimeoutMultiplier
= 0;
6981 ct
.ReadTotalTimeoutConstant
= 0;
6982 if (!SetCommTimeouts (hnd
, &ct
))
6984 cp
->status
= STATUS_READ_ERROR
;
6985 return STATUS_READ_ERROR
;
6988 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6990 if (GetLastError () != ERROR_IO_PENDING
)
6992 cp
->status
= STATUS_READ_ERROR
;
6993 return STATUS_READ_ERROR
;
6995 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6997 cp
->status
= STATUS_READ_ERROR
;
6998 return STATUS_READ_ERROR
;
7002 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
7004 unsigned long nblock
= 0;
7005 /* We always want this to block, so temporarily disable NDELAY. */
7006 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7007 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7009 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
7011 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7014 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7018 if (rc
== sizeof (char))
7019 cp
->status
= STATUS_READ_SUCCEEDED
;
7021 cp
->status
= STATUS_READ_FAILED
;
7027 _sys_wait_accept (int fd
)
7033 if (fd
< 0 || fd
>= MAXDESC
)
7034 return STATUS_READ_ERROR
;
7036 cp
= fd_info
[fd
].cp
;
7038 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
7039 return STATUS_READ_ERROR
;
7041 cp
->status
= STATUS_READ_FAILED
;
7043 hEv
= pfn_WSACreateEvent ();
7044 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
7045 if (rc
!= SOCKET_ERROR
)
7047 rc
= WaitForSingleObject (hEv
, INFINITE
);
7048 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
7049 if (rc
== WAIT_OBJECT_0
)
7050 cp
->status
= STATUS_READ_SUCCEEDED
;
7052 pfn_WSACloseEvent (hEv
);
7058 sys_read (int fd
, char * buffer
, unsigned int count
)
7063 char * orig_buffer
= buffer
;
7071 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7073 child_process
*cp
= fd_info
[fd
].cp
;
7075 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
7083 /* re-read CR carried over from last read */
7084 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
7086 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
7090 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
7093 /* presence of a child_process structure means we are operating in
7094 non-blocking mode - otherwise we just call _read directly.
7095 Note that the child_process structure might be missing because
7096 reap_subprocess has been called; in this case the pipe is
7097 already broken, so calling _read on it is okay. */
7100 int current_status
= cp
->status
;
7102 switch (current_status
)
7104 case STATUS_READ_FAILED
:
7105 case STATUS_READ_ERROR
:
7106 /* report normal EOF if nothing in buffer */
7108 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7111 case STATUS_READ_READY
:
7112 case STATUS_READ_IN_PROGRESS
:
7113 DebPrint (("sys_read called when read is in progress\n"));
7114 errno
= EWOULDBLOCK
;
7117 case STATUS_READ_SUCCEEDED
:
7118 /* consume read-ahead char */
7119 *buffer
++ = cp
->chr
;
7122 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7123 ResetEvent (cp
->char_avail
);
7125 case STATUS_READ_ACKNOWLEDGED
:
7129 DebPrint (("sys_read: bad status %d\n", current_status
));
7134 if (fd_info
[fd
].flags
& FILE_PIPE
)
7136 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
7137 to_read
= min (waiting
, (DWORD
) count
);
7140 nchars
+= _read (fd
, buffer
, to_read
);
7142 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7144 HANDLE hnd
= fd_info
[fd
].hnd
;
7145 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7151 /* Configure timeouts for non-blocking read. */
7152 if (!GetCommTimeouts (hnd
, &ct
))
7157 ct
.ReadIntervalTimeout
= MAXDWORD
;
7158 ct
.ReadTotalTimeoutMultiplier
= 0;
7159 ct
.ReadTotalTimeoutConstant
= 0;
7160 if (!SetCommTimeouts (hnd
, &ct
))
7166 if (!ResetEvent (ovl
->hEvent
))
7171 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
7173 if (GetLastError () != ERROR_IO_PENDING
)
7178 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7187 else /* FILE_SOCKET */
7189 if (winsock_lib
== NULL
) emacs_abort ();
7191 /* do the equivalent of a non-blocking read */
7192 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
7193 if (waiting
== 0 && nchars
== 0)
7195 errno
= EWOULDBLOCK
;
7201 /* always use binary mode for sockets */
7202 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
7203 if (res
== SOCKET_ERROR
)
7205 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
7206 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7216 int nread
= _read (fd
, buffer
, count
);
7219 else if (nchars
== 0)
7224 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7225 /* Perform text mode translation if required. */
7226 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7228 nchars
= crlf_to_lf (nchars
, orig_buffer
);
7229 /* If buffer contains only CR, return that. To be absolutely
7230 sure we should attempt to read the next char, but in
7231 practice a CR to be followed by LF would not appear by
7232 itself in the buffer. */
7233 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
7235 fd_info
[fd
].flags
|= FILE_LAST_CR
;
7241 nchars
= _read (fd
, buffer
, count
);
7246 /* From w32xfns.c */
7247 extern HANDLE interrupt_handle
;
7249 /* For now, don't bother with a non-blocking mode */
7251 sys_write (int fd
, const void * buffer
, unsigned int count
)
7261 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7263 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
7269 /* Perform text mode translation if required. */
7270 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7272 char * tmpbuf
= alloca (count
* 2);
7273 unsigned char * src
= (void *)buffer
;
7274 unsigned char * dst
= tmpbuf
;
7279 unsigned char *next
;
7280 /* copy next line or remaining bytes */
7281 next
= _memccpy (dst
, src
, '\n', nbytes
);
7284 /* copied one line ending with '\n' */
7285 int copied
= next
- dst
;
7288 /* insert '\r' before '\n' */
7295 /* copied remaining partial line -> now finished */
7302 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
7304 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
7305 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
7306 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
7309 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
7311 if (GetLastError () != ERROR_IO_PENDING
)
7316 if (detect_input_pending ())
7317 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
7320 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
7321 if (active
== WAIT_OBJECT_0
)
7322 { /* User pressed C-g, cancel write, then leave. Don't bother
7323 cleaning up as we may only get stuck in buggy drivers. */
7324 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
7329 if (active
== WAIT_OBJECT_0
+ 1
7330 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
7337 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
7339 unsigned long nblock
= 0;
7340 if (winsock_lib
== NULL
) emacs_abort ();
7342 /* TODO: implement select() properly so non-blocking I/O works. */
7343 /* For now, make sure the write blocks. */
7344 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7345 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7347 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
7349 /* Set the socket back to non-blocking if it was before,
7350 for other operations that support it. */
7351 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7354 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7357 if (nchars
== SOCKET_ERROR
)
7359 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
7360 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7366 /* Some networked filesystems don't like too large writes, so
7367 break them into smaller chunks. See the Comments section of
7368 the MSDN documentation of WriteFile for details behind the
7369 choice of the value of CHUNK below. See also the thread
7370 http://thread.gmane.org/gmane.comp.version-control.git/145294
7371 in the git mailing list. */
7372 const unsigned char *p
= buffer
;
7373 const unsigned chunk
= 30 * 1024 * 1024;
7378 unsigned this_chunk
= count
< chunk
? count
: chunk
;
7379 int n
= _write (fd
, p
, this_chunk
);
7387 else if (n
< this_chunk
)
7397 /* The Windows CRT functions are "optimized for speed", so they don't
7398 check for timezone and DST changes if they were last called less
7399 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
7400 all Emacs features that repeatedly call time functions (e.g.,
7401 display-time) are in real danger of missing timezone and DST
7402 changes. Calling tzset before each localtime call fixes that. */
7404 sys_localtime (const time_t *t
)
7407 return localtime (t
);
7412 /* Try loading LIBRARY_ID from the file(s) specified in
7413 Vdynamic_library_alist. If the library is loaded successfully,
7414 return the handle of the DLL, and record the filename in the
7415 property :loaded-from of LIBRARY_ID. If the library could not be
7416 found, or when it was already loaded (because the handle is not
7417 recorded anywhere, and so is lost after use), return NULL.
7419 We could also save the handle in :loaded-from, but currently
7420 there's no use case for it. */
7422 w32_delayed_load (Lisp_Object library_id
)
7424 HMODULE library_dll
= NULL
;
7426 CHECK_SYMBOL (library_id
);
7428 if (CONSP (Vdynamic_library_alist
)
7429 && NILP (Fassq (library_id
, Vlibrary_cache
)))
7431 Lisp_Object found
= Qnil
;
7432 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
7435 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
7437 CHECK_STRING_CAR (dlls
);
7438 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
7440 char name
[MAX_PATH
];
7443 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
7444 found
= Fcons (XCAR (dlls
),
7446 /* Possibly truncated */
7447 ? make_specified_string (name
, -1, len
, 1)
7453 Fput (library_id
, QCloaded_from
, found
);
7461 check_windows_init_file (void)
7463 /* A common indication that Emacs is not installed properly is when
7464 it cannot find the Windows installation file. If this file does
7465 not exist in the expected place, tell the user. */
7467 if (!noninteractive
&& !inhibit_window_system
7468 /* Vload_path is not yet initialized when we are loading
7470 && NILP (Vpurify_flag
))
7472 Lisp_Object init_file
;
7475 init_file
= build_string ("term/w32-win");
7476 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
7479 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
7480 char *init_file_name
= SDATA (init_file
);
7481 char *load_path
= SDATA (load_path_print
);
7482 char *buffer
= alloca (1024
7483 + strlen (init_file_name
)
7484 + strlen (load_path
));
7487 "The Emacs Windows initialization file \"%s.el\" "
7488 "could not be found in your Emacs installation. "
7489 "Emacs checked the following directories for this file:\n"
7491 "When Emacs cannot find this file, it usually means that it "
7492 "was not installed properly, or its distribution file was "
7493 "not unpacked properly.\nSee the README.W32 file in the "
7494 "top-level Emacs directory for more information.",
7495 init_file_name
, load_path
);
7498 "Emacs Abort Dialog",
7499 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
7500 /* Use the low-level system abort. */
7511 term_ntproc (int ignored
)
7517 /* shutdown the socket interface if necessary */
7524 init_ntproc (int dumping
)
7526 sigset_t initial_mask
= 0;
7528 /* Initialize the socket interface now if available and requested by
7529 the user by defining PRELOAD_WINSOCK; otherwise loading will be
7530 delayed until open-network-stream is called (w32-has-winsock can
7531 also be used to dynamically load or reload winsock).
7533 Conveniently, init_environment is called before us, so
7534 PRELOAD_WINSOCK can be set in the registry. */
7536 /* Always initialize this correctly. */
7539 if (getenv ("PRELOAD_WINSOCK") != NULL
)
7540 init_winsock (TRUE
);
7542 /* Initial preparation for subprocess support: replace our standard
7543 handles with non-inheritable versions. */
7546 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
7547 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
7548 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
7550 parent
= GetCurrentProcess ();
7552 /* ignore errors when duplicating and closing; typically the
7553 handles will be invalid when running as a gui program. */
7554 DuplicateHandle (parent
,
7555 GetStdHandle (STD_INPUT_HANDLE
),
7560 DUPLICATE_SAME_ACCESS
);
7562 DuplicateHandle (parent
,
7563 GetStdHandle (STD_OUTPUT_HANDLE
),
7568 DUPLICATE_SAME_ACCESS
);
7570 DuplicateHandle (parent
,
7571 GetStdHandle (STD_ERROR_HANDLE
),
7576 DUPLICATE_SAME_ACCESS
);
7582 if (stdin_save
!= INVALID_HANDLE_VALUE
)
7583 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
7585 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
7588 if (stdout_save
!= INVALID_HANDLE_VALUE
)
7589 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
7591 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7594 if (stderr_save
!= INVALID_HANDLE_VALUE
)
7595 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
7597 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7601 /* unfortunately, atexit depends on implementation of malloc */
7602 /* atexit (term_ntproc); */
7605 /* Make sure we start with all signals unblocked. */
7606 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
7607 signal (SIGABRT
, term_ntproc
);
7611 /* determine which drives are fixed, for GetCachedVolumeInformation */
7613 /* GetDriveType must have trailing backslash. */
7614 char drive
[] = "A:\\";
7616 /* Loop over all possible drive letters */
7617 while (*drive
<= 'Z')
7619 /* Record if this drive letter refers to a fixed drive. */
7620 fixed_drives
[DRIVE_INDEX (*drive
)] =
7621 (GetDriveType (drive
) == DRIVE_FIXED
);
7626 /* Reset the volume info cache. */
7627 volume_cache
= NULL
;
7632 shutdown_handler ensures that buffers' autosave files are
7633 up to date when the user logs off, or the system shuts down.
7636 shutdown_handler (DWORD type
)
7638 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
7639 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
7640 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
7641 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
7643 /* Shut down cleanly, making sure autosave files are up to date. */
7644 shut_down_emacs (0, Qnil
);
7647 /* Allow other handlers to handle this signal. */
7652 globals_of_w32 is used to initialize those global variables that
7653 must always be initialized on startup even when the global variable
7654 initialized is non zero (see the function main in emacs.c).
7657 globals_of_w32 (void)
7659 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
7661 get_process_times_fn
= (GetProcessTimes_Proc
)
7662 GetProcAddress (kernel32
, "GetProcessTimes");
7664 DEFSYM (QCloaded_from
, ":loaded-from");
7666 g_b_init_is_windows_9x
= 0;
7667 g_b_init_open_process_token
= 0;
7668 g_b_init_get_token_information
= 0;
7669 g_b_init_lookup_account_sid
= 0;
7670 g_b_init_get_sid_sub_authority
= 0;
7671 g_b_init_get_sid_sub_authority_count
= 0;
7672 g_b_init_get_security_info
= 0;
7673 g_b_init_get_file_security
= 0;
7674 g_b_init_get_security_descriptor_owner
= 0;
7675 g_b_init_get_security_descriptor_group
= 0;
7676 g_b_init_is_valid_sid
= 0;
7677 g_b_init_create_toolhelp32_snapshot
= 0;
7678 g_b_init_process32_first
= 0;
7679 g_b_init_process32_next
= 0;
7680 g_b_init_open_thread_token
= 0;
7681 g_b_init_impersonate_self
= 0;
7682 g_b_init_revert_to_self
= 0;
7683 g_b_init_get_process_memory_info
= 0;
7684 g_b_init_get_process_working_set_size
= 0;
7685 g_b_init_global_memory_status
= 0;
7686 g_b_init_global_memory_status_ex
= 0;
7687 g_b_init_equal_sid
= 0;
7688 g_b_init_copy_sid
= 0;
7689 g_b_init_get_length_sid
= 0;
7690 g_b_init_get_native_system_info
= 0;
7691 g_b_init_get_system_times
= 0;
7692 g_b_init_create_symbolic_link
= 0;
7693 g_b_init_get_security_descriptor_dacl
= 0;
7694 g_b_init_convert_sd_to_sddl
= 0;
7695 g_b_init_convert_sddl_to_sd
= 0;
7696 g_b_init_is_valid_security_descriptor
= 0;
7697 g_b_init_set_file_security
= 0;
7698 num_of_processors
= 0;
7699 /* The following sets a handler for shutdown notifications for
7700 console apps. This actually applies to Emacs in both console and
7701 GUI modes, since we had to fool windows into thinking emacs is a
7702 console application to get console mode to work. */
7703 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
7705 /* "None" is the default group name on standalone workstations. */
7706 strcpy (dflt_group_name
, "None");
7708 /* Reset, in case it has some value inherited from dump time. */
7709 w32_stat_get_owner_group
= 0;
7712 /* For make-serial-process */
7714 serial_open (Lisp_Object port_obj
)
7716 char *port
= SSDATA (port_obj
);
7721 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
7722 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
7723 if (hnd
== INVALID_HANDLE_VALUE
)
7724 error ("Could not open %s", port
);
7725 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
7727 error ("Could not open %s", port
);
7731 error ("Could not create child process");
7733 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7734 fd_info
[ fd
].hnd
= hnd
;
7735 fd_info
[ fd
].flags
|=
7736 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
7737 if (fd_info
[ fd
].cp
!= NULL
)
7739 error ("fd_info[fd = %d] is already in use", fd
);
7741 fd_info
[ fd
].cp
= cp
;
7742 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7743 if (cp
->ovl_read
.hEvent
== NULL
)
7744 error ("Could not create read event");
7745 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7746 if (cp
->ovl_write
.hEvent
== NULL
)
7747 error ("Could not create write event");
7752 /* For serial-process-configure */
7754 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
7756 Lisp_Object childp2
= Qnil
;
7757 Lisp_Object tem
= Qnil
;
7761 char summary
[4] = "???"; /* This usually becomes "8N1". */
7763 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
7764 error ("Not a serial process");
7765 hnd
= fd_info
[ p
->outfd
].hnd
;
7767 childp2
= Fcopy_sequence (p
->childp
);
7769 /* Initialize timeouts for blocking read and blocking write. */
7770 if (!GetCommTimeouts (hnd
, &ct
))
7771 error ("GetCommTimeouts() failed");
7772 ct
.ReadIntervalTimeout
= 0;
7773 ct
.ReadTotalTimeoutMultiplier
= 0;
7774 ct
.ReadTotalTimeoutConstant
= 0;
7775 ct
.WriteTotalTimeoutMultiplier
= 0;
7776 ct
.WriteTotalTimeoutConstant
= 0;
7777 if (!SetCommTimeouts (hnd
, &ct
))
7778 error ("SetCommTimeouts() failed");
7779 /* Read port attributes and prepare default configuration. */
7780 memset (&dcb
, 0, sizeof (dcb
));
7781 dcb
.DCBlength
= sizeof (DCB
);
7782 if (!GetCommState (hnd
, &dcb
))
7783 error ("GetCommState() failed");
7786 dcb
.fAbortOnError
= FALSE
;
7787 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7792 /* Configure speed. */
7793 if (!NILP (Fplist_member (contact
, QCspeed
)))
7794 tem
= Fplist_get (contact
, QCspeed
);
7796 tem
= Fplist_get (p
->childp
, QCspeed
);
7798 dcb
.BaudRate
= XINT (tem
);
7799 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
7801 /* Configure bytesize. */
7802 if (!NILP (Fplist_member (contact
, QCbytesize
)))
7803 tem
= Fplist_get (contact
, QCbytesize
);
7805 tem
= Fplist_get (p
->childp
, QCbytesize
);
7807 tem
= make_number (8);
7809 if (XINT (tem
) != 7 && XINT (tem
) != 8)
7810 error (":bytesize must be nil (8), 7, or 8");
7811 dcb
.ByteSize
= XINT (tem
);
7812 summary
[0] = XINT (tem
) + '0';
7813 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
7815 /* Configure parity. */
7816 if (!NILP (Fplist_member (contact
, QCparity
)))
7817 tem
= Fplist_get (contact
, QCparity
);
7819 tem
= Fplist_get (p
->childp
, QCparity
);
7820 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
7821 error (":parity must be nil (no parity), `even', or `odd'");
7822 dcb
.fParity
= FALSE
;
7823 dcb
.Parity
= NOPARITY
;
7824 dcb
.fErrorChar
= FALSE
;
7829 else if (EQ (tem
, Qeven
))
7833 dcb
.Parity
= EVENPARITY
;
7834 dcb
.fErrorChar
= TRUE
;
7836 else if (EQ (tem
, Qodd
))
7840 dcb
.Parity
= ODDPARITY
;
7841 dcb
.fErrorChar
= TRUE
;
7843 childp2
= Fplist_put (childp2
, QCparity
, tem
);
7845 /* Configure stopbits. */
7846 if (!NILP (Fplist_member (contact
, QCstopbits
)))
7847 tem
= Fplist_get (contact
, QCstopbits
);
7849 tem
= Fplist_get (p
->childp
, QCstopbits
);
7851 tem
= make_number (1);
7853 if (XINT (tem
) != 1 && XINT (tem
) != 2)
7854 error (":stopbits must be nil (1 stopbit), 1, or 2");
7855 summary
[2] = XINT (tem
) + '0';
7856 if (XINT (tem
) == 1)
7857 dcb
.StopBits
= ONESTOPBIT
;
7858 else if (XINT (tem
) == 2)
7859 dcb
.StopBits
= TWOSTOPBITS
;
7860 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
7862 /* Configure flowcontrol. */
7863 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
7864 tem
= Fplist_get (contact
, QCflowcontrol
);
7866 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
7867 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
7868 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7869 dcb
.fOutxCtsFlow
= FALSE
;
7870 dcb
.fOutxDsrFlow
= FALSE
;
7871 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
7872 dcb
.fDsrSensitivity
= FALSE
;
7873 dcb
.fTXContinueOnXoff
= FALSE
;
7876 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
7877 dcb
.XonChar
= 17; /* Control-Q */
7878 dcb
.XoffChar
= 19; /* Control-S */
7881 /* Already configured. */
7883 else if (EQ (tem
, Qhw
))
7885 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
7886 dcb
.fOutxCtsFlow
= TRUE
;
7888 else if (EQ (tem
, Qsw
))
7893 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
7895 /* Activate configuration. */
7896 if (!SetCommState (hnd
, &dcb
))
7897 error ("SetCommState() failed");
7899 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
7900 pset_childp (p
, childp2
);
7906 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
7911 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7912 int fd
= process
->infd
;
7914 n
= sys_read (fd
, (char*)buf
, sz
);
7921 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7922 if (err
== EWOULDBLOCK
)
7925 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7931 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7933 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7934 int fd
= process
->outfd
;
7935 ssize_t n
= sys_write (fd
, buf
, sz
);
7937 /* 0 or more bytes written means everything went fine. */
7941 /* Negative bytes written means we got an error in errno.
7942 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7943 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7944 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7948 #endif /* HAVE_GNUTLS */