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 */
33 #include <sys/utime.h>
37 /* must include CRT headers *before* config.h */
40 #include <mbstring.h> /* for _mbspbrk */
73 #define _ANONYMOUS_UNION
74 #define _ANONYMOUS_STRUCT
77 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
78 use a different name to avoid compilation problems. */
79 typedef struct _MEMORY_STATUS_EX
{
82 DWORDLONG ullTotalPhys
;
83 DWORDLONG ullAvailPhys
;
84 DWORDLONG ullTotalPageFile
;
85 DWORDLONG ullAvailPageFile
;
86 DWORDLONG ullTotalVirtual
;
87 DWORDLONG ullAvailVirtual
;
88 DWORDLONG ullAvailExtendedVirtual
;
89 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
99 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
100 /* This either is not in psapi.h or guarded by higher value of
101 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
102 defines it in psapi.h */
103 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
105 DWORD PageFaultCount
;
106 SIZE_T PeakWorkingSetSize
;
107 SIZE_T WorkingSetSize
;
108 SIZE_T QuotaPeakPagedPoolUsage
;
109 SIZE_T QuotaPagedPoolUsage
;
110 SIZE_T QuotaPeakNonPagedPoolUsage
;
111 SIZE_T QuotaNonPagedPoolUsage
;
112 SIZE_T PagefileUsage
;
113 SIZE_T PeakPagefileUsage
;
115 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
118 #include <winioctl.h>
124 /* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
125 define them by hand if not already defined. */
126 #ifndef SDDL_REVISION_1
127 #define SDDL_REVISION_1 1
128 #endif /* SDDL_REVISION_1 */
131 /* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER and the
132 associated macros, except on ntifs.h, which cannot be included
133 because it triggers conflicts with other Windows API headers. So
134 we define it here by hand. */
136 typedef struct _REPARSE_DATA_BUFFER
{
138 USHORT ReparseDataLength
;
142 USHORT SubstituteNameOffset
;
143 USHORT SubstituteNameLength
;
144 USHORT PrintNameOffset
;
145 USHORT PrintNameLength
;
148 } SymbolicLinkReparseBuffer
;
150 USHORT SubstituteNameOffset
;
151 USHORT SubstituteNameLength
;
152 USHORT PrintNameOffset
;
153 USHORT PrintNameLength
;
155 } MountPointReparseBuffer
;
158 } GenericReparseBuffer
;
160 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
162 #ifndef FILE_DEVICE_FILE_SYSTEM
163 #define FILE_DEVICE_FILE_SYSTEM 9
165 #ifndef METHOD_BUFFERED
166 #define METHOD_BUFFERED 0
168 #ifndef FILE_ANY_ACCESS
169 #define FILE_ANY_ACCESS 0x00000000
172 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
174 #define FSCTL_GET_REPARSE_POINT \
175 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
178 /* TCP connection support. */
179 #include <sys/socket.h>
200 #include "w32common.h"
202 #include "w32select.h"
204 #include "dispextern.h" /* for xstrcasecmp */
205 #include "coding.h" /* for Vlocale_coding_system */
207 #include "careadlinkat.h"
208 #include "allocator.h"
210 /* For serial_configure and serial_open. */
213 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
214 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
216 Lisp_Object QCloaded_from
;
218 void globals_of_w32 (void);
219 static DWORD
get_rid (PSID
);
220 static int is_symlink (const char *);
221 static char * chase_symlinks (const char *);
222 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
223 static int restore_privilege (TOKEN_PRIVILEGES
*);
224 static BOOL WINAPI
revert_to_self (void);
226 extern int sys_access (const char *, int);
227 extern void *e_malloc (size_t);
228 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
229 EMACS_TIME
*, void *);
233 /* Initialization states.
235 WARNING: If you add any more such variables for additional APIs,
236 you MUST add initialization for them to globals_of_w32
237 below. This is because these variables might get set
238 to non-NULL values during dumping, but the dumped Emacs
239 cannot reuse those values, because it could be run on a
240 different version of the OS, where API addresses are
242 static BOOL g_b_init_is_windows_9x
;
243 static BOOL g_b_init_open_process_token
;
244 static BOOL g_b_init_get_token_information
;
245 static BOOL g_b_init_lookup_account_sid
;
246 static BOOL g_b_init_get_sid_sub_authority
;
247 static BOOL g_b_init_get_sid_sub_authority_count
;
248 static BOOL g_b_init_get_security_info
;
249 static BOOL g_b_init_get_file_security
;
250 static BOOL g_b_init_get_security_descriptor_owner
;
251 static BOOL g_b_init_get_security_descriptor_group
;
252 static BOOL g_b_init_is_valid_sid
;
253 static BOOL g_b_init_create_toolhelp32_snapshot
;
254 static BOOL g_b_init_process32_first
;
255 static BOOL g_b_init_process32_next
;
256 static BOOL g_b_init_open_thread_token
;
257 static BOOL g_b_init_impersonate_self
;
258 static BOOL g_b_init_revert_to_self
;
259 static BOOL g_b_init_get_process_memory_info
;
260 static BOOL g_b_init_get_process_working_set_size
;
261 static BOOL g_b_init_global_memory_status
;
262 static BOOL g_b_init_global_memory_status_ex
;
263 static BOOL g_b_init_get_length_sid
;
264 static BOOL g_b_init_equal_sid
;
265 static BOOL g_b_init_copy_sid
;
266 static BOOL g_b_init_get_native_system_info
;
267 static BOOL g_b_init_get_system_times
;
268 static BOOL g_b_init_create_symbolic_link
;
269 static BOOL g_b_init_get_security_descriptor_dacl
;
270 static BOOL g_b_init_convert_sd_to_sddl
;
271 static BOOL g_b_init_convert_sddl_to_sd
;
272 static BOOL g_b_init_is_valid_security_descriptor
;
273 static BOOL g_b_init_set_file_security
;
276 BEGIN: Wrapper functions around OpenProcessToken
277 and other functions in advapi32.dll that are only
278 supported in Windows NT / 2k / XP
280 /* ** Function pointer typedefs ** */
281 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
282 HANDLE ProcessHandle
,
284 PHANDLE TokenHandle
);
285 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
287 TOKEN_INFORMATION_CLASS TokenInformationClass
,
288 LPVOID TokenInformation
,
289 DWORD TokenInformationLength
,
290 PDWORD ReturnLength
);
291 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
292 HANDLE process_handle
,
293 LPFILETIME creation_time
,
294 LPFILETIME exit_time
,
295 LPFILETIME kernel_time
,
296 LPFILETIME user_time
);
298 GetProcessTimes_Proc get_process_times_fn
= NULL
;
301 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
302 const char * const GetFileSecurity_Name
= "GetFileSecurityW";
303 const char * const SetFileSecurity_Name
= "SetFileSecurityW";
305 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
306 const char * const GetFileSecurity_Name
= "GetFileSecurityA";
307 const char * const SetFileSecurity_Name
= "SetFileSecurityA";
309 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
310 LPCTSTR lpSystemName
,
315 LPDWORD cbDomainName
,
316 PSID_NAME_USE peUse
);
317 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
320 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
322 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
324 SE_OBJECT_TYPE ObjectType
,
325 SECURITY_INFORMATION SecurityInfo
,
330 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
331 typedef BOOL (WINAPI
* GetFileSecurity_Proc
) (
333 SECURITY_INFORMATION RequestedInformation
,
334 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
336 LPDWORD lpnLengthNeeded
);
337 typedef BOOL (WINAPI
*SetFileSecurity_Proc
) (
339 SECURITY_INFORMATION SecurityInformation
,
340 PSECURITY_DESCRIPTOR pSecurityDescriptor
);
341 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
342 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
344 LPBOOL lpbOwnerDefaulted
);
345 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
346 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
348 LPBOOL lpbGroupDefaulted
);
349 typedef BOOL (WINAPI
*GetSecurityDescriptorDacl_Proc
) (
350 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
351 LPBOOL lpbDaclPresent
,
353 LPBOOL lpbDaclDefaulted
);
354 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
356 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
358 DWORD th32ProcessID
);
359 typedef BOOL (WINAPI
* Process32First_Proc
) (
361 LPPROCESSENTRY32 lppe
);
362 typedef BOOL (WINAPI
* Process32Next_Proc
) (
364 LPPROCESSENTRY32 lppe
);
365 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
369 PHANDLE TokenHandle
);
370 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
371 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
372 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
373 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
375 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
377 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
379 PSIZE_T lpMinimumWorkingSetSize
,
380 PSIZE_T lpMaximumWorkingSetSize
);
381 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
382 LPMEMORYSTATUS lpBuffer
);
383 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
384 LPMEMORY_STATUS_EX lpBuffer
);
385 typedef BOOL (WINAPI
* CopySid_Proc
) (
386 DWORD nDestinationSidLength
,
387 PSID pDestinationSid
,
389 typedef BOOL (WINAPI
* EqualSid_Proc
) (
392 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
394 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
395 LPSYSTEM_INFO lpSystemInfo
);
396 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
397 LPFILETIME lpIdleTime
,
398 LPFILETIME lpKernelTime
,
399 LPFILETIME lpUserTime
);
400 typedef BOOLEAN (WINAPI
*CreateSymbolicLink_Proc
) (
401 LPTSTR lpSymlinkFileName
,
402 LPTSTR lpTargetFileName
,
404 typedef BOOL (WINAPI
*ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
) (
405 LPCTSTR StringSecurityDescriptor
,
406 DWORD StringSDRevision
,
407 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
408 PULONG SecurityDescriptorSize
);
409 typedef BOOL (WINAPI
*ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
) (
410 PSECURITY_DESCRIPTOR SecurityDescriptor
,
411 DWORD RequestedStringSDRevision
,
412 SECURITY_INFORMATION SecurityInformation
,
413 LPTSTR
*StringSecurityDescriptor
,
414 PULONG StringSecurityDescriptorLen
);
415 typedef BOOL (WINAPI
*IsValidSecurityDescriptor_Proc
) (PSECURITY_DESCRIPTOR
);
417 /* ** A utility function ** */
421 static BOOL s_b_ret
= 0;
422 OSVERSIONINFO os_ver
;
423 if (g_b_init_is_windows_9x
== 0)
425 g_b_init_is_windows_9x
= 1;
426 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
427 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
428 if (GetVersionEx (&os_ver
))
430 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
436 static Lisp_Object
ltime (ULONGLONG
);
438 /* Get total user and system times for get-internal-run-time.
439 Returns a list of integers if the times are provided by the OS
440 (NT derivatives), otherwise it returns the result of current-time. */
442 w32_get_internal_run_time (void)
444 if (get_process_times_fn
)
446 FILETIME create
, exit
, kernel
, user
;
447 HANDLE proc
= GetCurrentProcess ();
448 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
450 LARGE_INTEGER user_int
, kernel_int
, total
;
451 user_int
.LowPart
= user
.dwLowDateTime
;
452 user_int
.HighPart
= user
.dwHighDateTime
;
453 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
454 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
455 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
456 return ltime (total
.QuadPart
);
460 return Fcurrent_time ();
463 /* ** The wrapper functions ** */
466 open_process_token (HANDLE ProcessHandle
,
470 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
471 HMODULE hm_advapi32
= NULL
;
472 if (is_windows_9x () == TRUE
)
476 if (g_b_init_open_process_token
== 0)
478 g_b_init_open_process_token
= 1;
479 hm_advapi32
= LoadLibrary ("Advapi32.dll");
480 s_pfn_Open_Process_Token
=
481 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
483 if (s_pfn_Open_Process_Token
== NULL
)
488 s_pfn_Open_Process_Token (
496 get_token_information (HANDLE TokenHandle
,
497 TOKEN_INFORMATION_CLASS TokenInformationClass
,
498 LPVOID TokenInformation
,
499 DWORD TokenInformationLength
,
502 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
503 HMODULE hm_advapi32
= NULL
;
504 if (is_windows_9x () == TRUE
)
508 if (g_b_init_get_token_information
== 0)
510 g_b_init_get_token_information
= 1;
511 hm_advapi32
= LoadLibrary ("Advapi32.dll");
512 s_pfn_Get_Token_Information
=
513 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
515 if (s_pfn_Get_Token_Information
== NULL
)
520 s_pfn_Get_Token_Information (
522 TokenInformationClass
,
524 TokenInformationLength
,
530 lookup_account_sid (LPCTSTR lpSystemName
,
535 LPDWORD cbDomainName
,
538 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
539 HMODULE hm_advapi32
= NULL
;
540 if (is_windows_9x () == TRUE
)
544 if (g_b_init_lookup_account_sid
== 0)
546 g_b_init_lookup_account_sid
= 1;
547 hm_advapi32
= LoadLibrary ("Advapi32.dll");
548 s_pfn_Lookup_Account_Sid
=
549 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
551 if (s_pfn_Lookup_Account_Sid
== NULL
)
556 s_pfn_Lookup_Account_Sid (
568 get_sid_sub_authority (PSID pSid
, DWORD n
)
570 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
571 static DWORD zero
= 0U;
572 HMODULE hm_advapi32
= NULL
;
573 if (is_windows_9x () == TRUE
)
577 if (g_b_init_get_sid_sub_authority
== 0)
579 g_b_init_get_sid_sub_authority
= 1;
580 hm_advapi32
= LoadLibrary ("Advapi32.dll");
581 s_pfn_Get_Sid_Sub_Authority
=
582 (GetSidSubAuthority_Proc
) GetProcAddress (
583 hm_advapi32
, "GetSidSubAuthority");
585 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
589 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
593 get_sid_sub_authority_count (PSID pSid
)
595 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
596 static UCHAR zero
= 0U;
597 HMODULE hm_advapi32
= NULL
;
598 if (is_windows_9x () == TRUE
)
602 if (g_b_init_get_sid_sub_authority_count
== 0)
604 g_b_init_get_sid_sub_authority_count
= 1;
605 hm_advapi32
= LoadLibrary ("Advapi32.dll");
606 s_pfn_Get_Sid_Sub_Authority_Count
=
607 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
608 hm_advapi32
, "GetSidSubAuthorityCount");
610 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
614 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
618 get_security_info (HANDLE handle
,
619 SE_OBJECT_TYPE ObjectType
,
620 SECURITY_INFORMATION SecurityInfo
,
625 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
627 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
628 HMODULE hm_advapi32
= NULL
;
629 if (is_windows_9x () == TRUE
)
633 if (g_b_init_get_security_info
== 0)
635 g_b_init_get_security_info
= 1;
636 hm_advapi32
= LoadLibrary ("Advapi32.dll");
637 s_pfn_Get_Security_Info
=
638 (GetSecurityInfo_Proc
) GetProcAddress (
639 hm_advapi32
, "GetSecurityInfo");
641 if (s_pfn_Get_Security_Info
== NULL
)
645 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
646 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
647 ppSecurityDescriptor
));
651 get_file_security (LPCTSTR lpFileName
,
652 SECURITY_INFORMATION RequestedInformation
,
653 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
655 LPDWORD lpnLengthNeeded
)
657 static GetFileSecurity_Proc s_pfn_Get_File_Security
= NULL
;
658 HMODULE hm_advapi32
= NULL
;
659 if (is_windows_9x () == TRUE
)
664 if (g_b_init_get_file_security
== 0)
666 g_b_init_get_file_security
= 1;
667 hm_advapi32
= LoadLibrary ("Advapi32.dll");
668 s_pfn_Get_File_Security
=
669 (GetFileSecurity_Proc
) GetProcAddress (
670 hm_advapi32
, GetFileSecurity_Name
);
672 if (s_pfn_Get_File_Security
== NULL
)
677 return (s_pfn_Get_File_Security (lpFileName
, RequestedInformation
,
678 pSecurityDescriptor
, nLength
,
683 set_file_security (LPCTSTR lpFileName
,
684 SECURITY_INFORMATION SecurityInformation
,
685 PSECURITY_DESCRIPTOR pSecurityDescriptor
)
687 static SetFileSecurity_Proc s_pfn_Set_File_Security
= NULL
;
688 HMODULE hm_advapi32
= NULL
;
689 if (is_windows_9x () == TRUE
)
694 if (g_b_init_set_file_security
== 0)
696 g_b_init_set_file_security
= 1;
697 hm_advapi32
= LoadLibrary ("Advapi32.dll");
698 s_pfn_Set_File_Security
=
699 (SetFileSecurity_Proc
) GetProcAddress (
700 hm_advapi32
, SetFileSecurity_Name
);
702 if (s_pfn_Set_File_Security
== NULL
)
707 return (s_pfn_Set_File_Security (lpFileName
, SecurityInformation
,
708 pSecurityDescriptor
));
712 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
714 LPBOOL lpbOwnerDefaulted
)
716 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
717 HMODULE hm_advapi32
= NULL
;
718 if (is_windows_9x () == TRUE
)
723 if (g_b_init_get_security_descriptor_owner
== 0)
725 g_b_init_get_security_descriptor_owner
= 1;
726 hm_advapi32
= LoadLibrary ("Advapi32.dll");
727 s_pfn_Get_Security_Descriptor_Owner
=
728 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
729 hm_advapi32
, "GetSecurityDescriptorOwner");
731 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
736 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
741 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
743 LPBOOL lpbGroupDefaulted
)
745 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
746 HMODULE hm_advapi32
= NULL
;
747 if (is_windows_9x () == TRUE
)
752 if (g_b_init_get_security_descriptor_group
== 0)
754 g_b_init_get_security_descriptor_group
= 1;
755 hm_advapi32
= LoadLibrary ("Advapi32.dll");
756 s_pfn_Get_Security_Descriptor_Group
=
757 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
758 hm_advapi32
, "GetSecurityDescriptorGroup");
760 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
765 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
770 get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
771 LPBOOL lpbDaclPresent
,
773 LPBOOL lpbDaclDefaulted
)
775 static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl
= NULL
;
776 HMODULE hm_advapi32
= NULL
;
777 if (is_windows_9x () == TRUE
)
782 if (g_b_init_get_security_descriptor_dacl
== 0)
784 g_b_init_get_security_descriptor_dacl
= 1;
785 hm_advapi32
= LoadLibrary ("Advapi32.dll");
786 s_pfn_Get_Security_Descriptor_Dacl
=
787 (GetSecurityDescriptorDacl_Proc
) GetProcAddress (
788 hm_advapi32
, "GetSecurityDescriptorDacl");
790 if (s_pfn_Get_Security_Descriptor_Dacl
== NULL
)
795 return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor
,
796 lpbDaclPresent
, pDacl
,
801 is_valid_sid (PSID sid
)
803 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
804 HMODULE hm_advapi32
= NULL
;
805 if (is_windows_9x () == TRUE
)
809 if (g_b_init_is_valid_sid
== 0)
811 g_b_init_is_valid_sid
= 1;
812 hm_advapi32
= LoadLibrary ("Advapi32.dll");
814 (IsValidSid_Proc
) GetProcAddress (
815 hm_advapi32
, "IsValidSid");
817 if (s_pfn_Is_Valid_Sid
== NULL
)
821 return (s_pfn_Is_Valid_Sid (sid
));
825 equal_sid (PSID sid1
, PSID sid2
)
827 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
828 HMODULE hm_advapi32
= NULL
;
829 if (is_windows_9x () == TRUE
)
833 if (g_b_init_equal_sid
== 0)
835 g_b_init_equal_sid
= 1;
836 hm_advapi32
= LoadLibrary ("Advapi32.dll");
838 (EqualSid_Proc
) GetProcAddress (
839 hm_advapi32
, "EqualSid");
841 if (s_pfn_Equal_Sid
== NULL
)
845 return (s_pfn_Equal_Sid (sid1
, sid2
));
849 get_length_sid (PSID sid
)
851 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
852 HMODULE hm_advapi32
= NULL
;
853 if (is_windows_9x () == TRUE
)
857 if (g_b_init_get_length_sid
== 0)
859 g_b_init_get_length_sid
= 1;
860 hm_advapi32
= LoadLibrary ("Advapi32.dll");
861 s_pfn_Get_Length_Sid
=
862 (GetLengthSid_Proc
) GetProcAddress (
863 hm_advapi32
, "GetLengthSid");
865 if (s_pfn_Get_Length_Sid
== NULL
)
869 return (s_pfn_Get_Length_Sid (sid
));
873 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
875 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
876 HMODULE hm_advapi32
= NULL
;
877 if (is_windows_9x () == TRUE
)
881 if (g_b_init_copy_sid
== 0)
883 g_b_init_copy_sid
= 1;
884 hm_advapi32
= LoadLibrary ("Advapi32.dll");
886 (CopySid_Proc
) GetProcAddress (
887 hm_advapi32
, "CopySid");
889 if (s_pfn_Copy_Sid
== NULL
)
893 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
897 END: Wrapper functions around OpenProcessToken
898 and other functions in advapi32.dll that are only
899 supported in Windows NT / 2k / XP
903 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
905 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
906 if (is_windows_9x () != TRUE
)
908 if (g_b_init_get_native_system_info
== 0)
910 g_b_init_get_native_system_info
= 1;
911 s_pfn_Get_Native_System_Info
=
912 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
913 "GetNativeSystemInfo");
915 if (s_pfn_Get_Native_System_Info
!= NULL
)
916 s_pfn_Get_Native_System_Info (lpSystemInfo
);
919 lpSystemInfo
->dwNumberOfProcessors
= -1;
923 get_system_times (LPFILETIME lpIdleTime
,
924 LPFILETIME lpKernelTime
,
925 LPFILETIME lpUserTime
)
927 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
928 if (is_windows_9x () == TRUE
)
932 if (g_b_init_get_system_times
== 0)
934 g_b_init_get_system_times
= 1;
935 s_pfn_Get_System_times
=
936 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
939 if (s_pfn_Get_System_times
== NULL
)
941 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
944 static BOOLEAN WINAPI
945 create_symbolic_link (LPTSTR lpSymlinkFilename
,
946 LPTSTR lpTargetFileName
,
949 static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link
= NULL
;
952 if (is_windows_9x () == TRUE
)
957 if (g_b_init_create_symbolic_link
== 0)
959 g_b_init_create_symbolic_link
= 1;
961 s_pfn_Create_Symbolic_Link
=
962 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
963 "CreateSymbolicLinkW");
965 s_pfn_Create_Symbolic_Link
=
966 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
967 "CreateSymbolicLinkA");
970 if (s_pfn_Create_Symbolic_Link
== NULL
)
976 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
978 /* If we were denied creation of the symlink, try again after
979 enabling the SeCreateSymbolicLinkPrivilege for our process. */
982 TOKEN_PRIVILEGES priv_current
;
984 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
, &priv_current
))
986 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
988 restore_privilege (&priv_current
);
996 is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor
)
998 static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc
= NULL
;
1000 if (is_windows_9x () == TRUE
)
1006 if (g_b_init_is_valid_security_descriptor
== 0)
1008 g_b_init_is_valid_security_descriptor
= 1;
1009 s_pfn_Is_Valid_Security_Descriptor_Proc
=
1010 (IsValidSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1011 "IsValidSecurityDescriptor");
1013 if (s_pfn_Is_Valid_Security_Descriptor_Proc
== NULL
)
1019 return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor
);
1023 convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor
,
1024 DWORD RequestedStringSDRevision
,
1025 SECURITY_INFORMATION SecurityInformation
,
1026 LPTSTR
*StringSecurityDescriptor
,
1027 PULONG StringSecurityDescriptorLen
)
1029 static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL
= NULL
;
1032 if (is_windows_9x () == TRUE
)
1038 if (g_b_init_convert_sd_to_sddl
== 0)
1040 g_b_init_convert_sd_to_sddl
= 1;
1042 s_pfn_Convert_SD_To_SDDL
=
1043 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1044 "ConvertSecurityDescriptorToStringSecurityDescriptorW");
1046 s_pfn_Convert_SD_To_SDDL
=
1047 (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1048 "ConvertSecurityDescriptorToStringSecurityDescriptorA");
1051 if (s_pfn_Convert_SD_To_SDDL
== NULL
)
1057 retval
= s_pfn_Convert_SD_To_SDDL (SecurityDescriptor
,
1058 RequestedStringSDRevision
,
1059 SecurityInformation
,
1060 StringSecurityDescriptor
,
1061 StringSecurityDescriptorLen
);
1067 convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor
,
1068 DWORD StringSDRevision
,
1069 PSECURITY_DESCRIPTOR
*SecurityDescriptor
,
1070 PULONG SecurityDescriptorSize
)
1072 static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD
= NULL
;
1075 if (is_windows_9x () == TRUE
)
1081 if (g_b_init_convert_sddl_to_sd
== 0)
1083 g_b_init_convert_sddl_to_sd
= 1;
1085 s_pfn_Convert_SDDL_To_SD
=
1086 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1087 "ConvertStringSecurityDescriptorToSecurityDescriptorW");
1089 s_pfn_Convert_SDDL_To_SD
=
1090 (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc
)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
1091 "ConvertStringSecurityDescriptorToSecurityDescriptorA");
1094 if (s_pfn_Convert_SDDL_To_SD
== NULL
)
1100 retval
= s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor
,
1103 SecurityDescriptorSize
);
1110 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
1111 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
1113 This is called from alloc.c:valid_pointer_p. */
1115 w32_valid_pointer_p (void *p
, int size
)
1118 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
1122 unsigned char *buf
= alloca (size
);
1123 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
1132 static char startup_dir
[MAXPATHLEN
];
1134 /* Get the current working directory. */
1136 getcwd (char *dir
, int dirsize
)
1143 if (dirsize
<= strlen (startup_dir
))
1149 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
1153 /* Emacs doesn't actually change directory itself, it stays in the
1154 same directory where it was started. */
1155 strcpy (dir
, startup_dir
);
1160 /* Emulate getloadavg. */
1162 struct load_sample
{
1169 /* Number of processors on this machine. */
1170 static unsigned num_of_processors
;
1172 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
1173 static struct load_sample samples
[16*60];
1174 static int first_idx
= -1, last_idx
= -1;
1175 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
1180 int next_idx
= from
+ 1;
1182 if (next_idx
>= max_idx
)
1191 int prev_idx
= from
- 1;
1194 prev_idx
= max_idx
- 1;
1200 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
1202 SYSTEM_INFO sysinfo
;
1203 FILETIME ft_idle
, ft_user
, ft_kernel
;
1205 /* Initialize the number of processors on this machine. */
1206 if (num_of_processors
<= 0)
1208 get_native_system_info (&sysinfo
);
1209 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1210 if (num_of_processors
<= 0)
1212 GetSystemInfo (&sysinfo
);
1213 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
1215 if (num_of_processors
<= 0)
1216 num_of_processors
= 1;
1219 /* TODO: Take into account threads that are ready to run, by
1220 sampling the "\System\Processor Queue Length" performance
1221 counter. The code below accounts only for threads that are
1222 actually running. */
1224 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
1226 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1228 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1229 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1230 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1231 *idle
= uidle
.QuadPart
;
1232 *kernel
= ukernel
.QuadPart
;
1233 *user
= uuser
.QuadPart
;
1243 /* Produce the load average for a given time interval, using the
1244 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1245 1-minute, 5-minute, or 15-minute average, respectively. */
1249 double retval
= -1.0;
1252 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1253 time_t now
= samples
[last_idx
].sample_time
;
1255 if (first_idx
!= last_idx
)
1257 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1259 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1260 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1263 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1264 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1265 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1267 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1270 if (idx
== first_idx
)
1279 getloadavg (double loadavg
[], int nelem
)
1282 ULONGLONG idle
, kernel
, user
;
1283 time_t now
= time (NULL
);
1285 /* Store another sample. We ignore samples that are less than 1 sec
1287 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
1289 sample_system_load (&idle
, &kernel
, &user
);
1290 last_idx
= buf_next (last_idx
);
1291 samples
[last_idx
].sample_time
= now
;
1292 samples
[last_idx
].idle
= idle
;
1293 samples
[last_idx
].kernel
= kernel
;
1294 samples
[last_idx
].user
= user
;
1295 /* If the buffer has more that 15 min worth of samples, discard
1297 if (first_idx
== -1)
1298 first_idx
= last_idx
;
1299 while (first_idx
!= last_idx
1300 && (difftime (now
, samples
[first_idx
].sample_time
)
1301 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1302 first_idx
= buf_next (first_idx
);
1305 for (elem
= 0; elem
< nelem
; elem
++)
1307 double avg
= getavg (elem
);
1311 loadavg
[elem
] = avg
;
1317 /* Emulate getpwuid, getpwnam and others. */
1319 #define PASSWD_FIELD_SIZE 256
1321 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1322 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1323 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1324 static char dflt_passwd_dir
[PASSWD_FIELD_SIZE
];
1325 static char dflt_passwd_shell
[PASSWD_FIELD_SIZE
];
1327 static struct passwd dflt_passwd
=
1339 static char dflt_group_name
[GNLEN
+1];
1341 static struct group dflt_group
=
1343 /* When group information is not available, we return this as the
1344 group for all files. */
1352 return dflt_passwd
.pw_uid
;
1358 /* I could imagine arguing for checking to see whether the user is
1359 in the Administrators group and returning a UID of 0 for that
1360 case, but I don't know how wise that would be in the long run. */
1367 return dflt_passwd
.pw_gid
;
1377 getpwuid (unsigned uid
)
1379 if (uid
== dflt_passwd
.pw_uid
)
1380 return &dflt_passwd
;
1385 getgrgid (gid_t gid
)
1391 getpwnam (char *name
)
1395 pw
= getpwuid (getuid ());
1399 if (xstrcasecmp (name
, pw
->pw_name
))
1406 init_user_info (void)
1408 /* Find the user's real name by opening the process token and
1409 looking up the name associated with the user-sid in that token.
1411 Use the relative portion of the identifier authority value from
1412 the user-sid as the user id value (same for group id using the
1413 primary group sid from the process token). */
1415 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1416 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1417 DWORD glength
= sizeof (gname
);
1418 HANDLE token
= NULL
;
1419 SID_NAME_USE user_type
;
1420 unsigned char *buf
= NULL
;
1422 TOKEN_USER user_token
;
1423 TOKEN_PRIMARY_GROUP group_token
;
1426 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1429 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1430 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1432 buf
= xmalloc (blen
);
1433 result
= get_token_information (token
, TokenUser
,
1434 (LPVOID
)buf
, blen
, &needed
);
1437 memcpy (&user_token
, buf
, sizeof (user_token
));
1438 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1440 domain
, &dlength
, &user_type
);
1448 strcpy (dflt_passwd
.pw_name
, uname
);
1449 /* Determine a reasonable uid value. */
1450 if (xstrcasecmp ("administrator", uname
) == 0)
1452 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1453 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1457 /* Use the last sub-authority value of the RID, the relative
1458 portion of the SID, as user/group ID. */
1459 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1461 /* Get group id and name. */
1462 result
= get_token_information (token
, TokenPrimaryGroup
,
1463 (LPVOID
)buf
, blen
, &needed
);
1464 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1466 buf
= xrealloc (buf
, blen
= needed
);
1467 result
= get_token_information (token
, TokenPrimaryGroup
,
1468 (LPVOID
)buf
, blen
, &needed
);
1472 memcpy (&group_token
, buf
, sizeof (group_token
));
1473 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1474 dlength
= sizeof (domain
);
1475 /* If we can get at the real Primary Group name, use that.
1476 Otherwise, the default group name was already set to
1477 "None" in globals_of_w32. */
1478 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1479 gname
, &glength
, NULL
, &dlength
,
1481 strcpy (dflt_group_name
, gname
);
1484 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1487 /* If security calls are not supported (presumably because we
1488 are running under Windows 9X), fallback to this: */
1489 else if (GetUserName (uname
, &ulength
))
1491 strcpy (dflt_passwd
.pw_name
, uname
);
1492 if (xstrcasecmp ("administrator", uname
) == 0)
1493 dflt_passwd
.pw_uid
= 0;
1495 dflt_passwd
.pw_uid
= 123;
1496 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1500 strcpy (dflt_passwd
.pw_name
, "unknown");
1501 dflt_passwd
.pw_uid
= 123;
1502 dflt_passwd
.pw_gid
= 123;
1504 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1506 /* Ensure HOME and SHELL are defined. */
1507 if (getenv ("HOME") == NULL
)
1509 if (getenv ("SHELL") == NULL
)
1512 /* Set dir and shell from environment variables. */
1513 strcpy (dflt_passwd
.pw_dir
, getenv ("HOME"));
1514 strcpy (dflt_passwd
.pw_shell
, getenv ("SHELL"));
1518 CloseHandle (token
);
1524 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1525 return ((rand () << 15) | rand ());
1535 /* Normalize filename by converting all path separators to
1536 the specified separator. Also conditionally convert upper
1537 case path name components to lower case. */
1540 normalize_filename (register char *fp
, char path_sep
)
1545 /* Always lower-case drive letters a-z, even if the filesystem
1546 preserves case in filenames.
1547 This is so filenames can be compared by string comparison
1548 functions that are case-sensitive. Even case-preserving filesystems
1549 do not distinguish case in drive letters. */
1550 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
1556 if (NILP (Vw32_downcase_file_names
))
1560 if (*fp
== '/' || *fp
== '\\')
1567 sep
= path_sep
; /* convert to this path separator */
1568 elem
= fp
; /* start of current path element */
1571 if (*fp
>= 'a' && *fp
<= 'z')
1572 elem
= 0; /* don't convert this element */
1574 if (*fp
== 0 || *fp
== ':')
1576 sep
= *fp
; /* restore current separator (or 0) */
1577 *fp
= '/'; /* after conversion of this element */
1580 if (*fp
== '/' || *fp
== '\\')
1582 if (elem
&& elem
!= fp
)
1584 *fp
= 0; /* temporary end of string */
1585 _strlwr (elem
); /* while we convert to lower case */
1587 *fp
= sep
; /* convert (or restore) path separator */
1588 elem
= fp
+ 1; /* next element starts after separator */
1594 /* Destructively turn backslashes into slashes. */
1596 dostounix_filename (register char *p
)
1598 normalize_filename (p
, '/');
1601 /* Destructively turn slashes into backslashes. */
1603 unixtodos_filename (register char *p
)
1605 normalize_filename (p
, '\\');
1608 /* Remove all CR's that are followed by a LF.
1609 (From msdos.c...probably should figure out a way to share it,
1610 although this code isn't going to ever change.) */
1612 crlf_to_lf (register int n
, register unsigned char *buf
)
1614 unsigned char *np
= buf
;
1615 unsigned char *startp
= buf
;
1616 unsigned char *endp
= buf
+ n
;
1620 while (buf
< endp
- 1)
1624 if (*(++buf
) != 0x0a)
1635 /* Parse the root part of file name, if present. Return length and
1636 optionally store pointer to char after root. */
1638 parse_root (char * name
, char ** pPath
)
1640 char * start
= name
;
1645 /* find the root name of the volume if given */
1646 if (isalpha (name
[0]) && name
[1] == ':')
1648 /* skip past drive specifier */
1650 if (IS_DIRECTORY_SEP (name
[0]))
1653 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1659 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1664 if (IS_DIRECTORY_SEP (name
[0]))
1671 return name
- start
;
1674 /* Get long base name for name; name is assumed to be absolute. */
1676 get_long_basename (char * name
, char * buf
, int size
)
1678 WIN32_FIND_DATA find_data
;
1682 /* must be valid filename, no wild cards or other invalid characters */
1683 if (_mbspbrk (name
, "*?|<>\""))
1686 dir_handle
= FindFirstFile (name
, &find_data
);
1687 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1689 if ((len
= strlen (find_data
.cFileName
)) < size
)
1690 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1693 FindClose (dir_handle
);
1698 /* Get long name for file, if possible (assumed to be absolute). */
1700 w32_get_long_filename (char * name
, char * buf
, int size
)
1705 char full
[ MAX_PATH
];
1708 len
= strlen (name
);
1709 if (len
>= MAX_PATH
)
1712 /* Use local copy for destructive modification. */
1713 memcpy (full
, name
, len
+1);
1714 unixtodos_filename (full
);
1716 /* Copy root part verbatim. */
1717 len
= parse_root (full
, &p
);
1718 memcpy (o
, full
, len
);
1723 while (p
!= NULL
&& *p
)
1726 p
= strchr (q
, '\\');
1728 len
= get_long_basename (full
, o
, size
);
1751 is_unc_volume (const char *filename
)
1753 const char *ptr
= filename
;
1755 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1758 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1764 /* Emulate the Posix unsetenv. */
1766 unsetenv (const char *name
)
1772 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
1777 name_len
= strlen (name
);
1778 /* MS docs says an environment variable cannot be longer than 32K. */
1779 if (name_len
> 32767)
1784 /* It is safe to use 'alloca' with 32K size, since the stack is at
1785 least 2MB, and we set it to 8MB in the link command line. */
1786 var
= alloca (name_len
+ 2);
1787 strncpy (var
, name
, name_len
);
1788 var
[name_len
++] = '=';
1789 var
[name_len
] = '\0';
1790 return _putenv (var
);
1793 /* MS _putenv doesn't support removing a variable when the argument
1794 does not include the '=' character, so we fix that here. */
1796 sys_putenv (char *str
)
1798 const char *const name_end
= strchr (str
, '=');
1800 if (name_end
== NULL
)
1802 /* Remove the variable from the environment. */
1803 return unsetenv (str
);
1806 return _putenv (str
);
1809 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1812 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1815 HKEY hrootkey
= NULL
;
1818 /* Check both the current user and the local machine to see if
1819 we have any resources. */
1821 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1825 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1826 && (lpvalue
= xmalloc (cbData
)) != NULL
1827 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1829 RegCloseKey (hrootkey
);
1835 RegCloseKey (hrootkey
);
1838 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1842 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1843 && (lpvalue
= xmalloc (cbData
)) != NULL
1844 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1846 RegCloseKey (hrootkey
);
1852 RegCloseKey (hrootkey
);
1858 char *get_emacs_configuration (void);
1861 init_environment (char ** argv
)
1863 static const char * const tempdirs
[] = {
1864 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1869 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1871 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1872 temporary files and assume "/tmp" if $TMPDIR is unset, which
1873 will break on DOS/Windows. Refuse to work if we cannot find
1874 a directory, not even "c:/", usable for that purpose. */
1875 for (i
= 0; i
< imax
; i
++)
1877 const char *tmp
= tempdirs
[i
];
1880 tmp
= getenv (tmp
+ 1);
1881 /* Note that `access' can lie to us if the directory resides on a
1882 read-only filesystem, like CD-ROM or a write-protected floppy.
1883 The only way to be really sure is to actually create a file and
1884 see if it succeeds. But I think that's too much to ask. */
1886 /* MSVCRT's _access crashes with D_OK. */
1887 if (tmp
&& faccessat (AT_FDCWD
, tmp
, D_OK
, AT_EACCESS
) == 0)
1889 char * var
= alloca (strlen (tmp
) + 8);
1890 sprintf (var
, "TMPDIR=%s", tmp
);
1891 _putenv (strdup (var
));
1898 Fcons (build_string ("no usable temporary directories found!!"),
1900 "While setting TMPDIR: ");
1902 /* Check for environment variables and use registry settings if they
1903 don't exist. Fallback on default values where applicable. */
1908 char locale_name
[32];
1909 char default_home
[MAX_PATH
];
1912 static const struct env_entry
1918 /* If the default value is NULL, we will use the value from the
1919 outside environment or the Registry, but will not push the
1920 variable into the Emacs environment if it is defined neither
1921 in the Registry nor in the outside environment. */
1923 {"PRELOAD_WINSOCK", NULL
},
1924 {"emacs_dir", "C:/emacs"},
1925 {"EMACSLOADPATH", NULL
},
1926 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1927 {"EMACSDATA", NULL
},
1928 {"EMACSPATH", NULL
},
1935 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1937 /* We need to copy dflt_envvars[] and work on the copy because we
1938 don't want the dumped Emacs to inherit the values of
1939 environment variables we saw during dumping (which could be on
1940 a different system). The defaults above must be left intact. */
1941 struct env_entry env_vars
[N_ENV_VARS
];
1943 for (i
= 0; i
< N_ENV_VARS
; i
++)
1944 env_vars
[i
] = dflt_envvars
[i
];
1946 /* For backwards compatibility, check if a .emacs file exists in C:/
1947 If not, then we can try to default to the appdata directory under the
1948 user's profile, which is more likely to be writable. */
1949 if (!check_existing ("C:/.emacs"))
1951 HRESULT profile_result
;
1952 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1953 of Windows 95 and NT4 that have not been updated to include
1955 ShGetFolderPath_fn get_folder_path
;
1956 get_folder_path
= (ShGetFolderPath_fn
)
1957 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1959 if (get_folder_path
!= NULL
)
1961 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1964 /* If we can't get the appdata dir, revert to old behavior. */
1965 if (profile_result
== S_OK
)
1967 env_vars
[0].def_value
= default_home
;
1973 /* Get default locale info and use it for LANG. */
1974 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1975 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1976 locale_name
, sizeof (locale_name
)))
1978 for (i
= 0; i
< N_ENV_VARS
; i
++)
1980 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1982 env_vars
[i
].def_value
= locale_name
;
1988 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1990 /* Treat emacs_dir specially: set it unconditionally based on our
1994 char modname
[MAX_PATH
];
1996 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1998 if ((p
= strrchr (modname
, '\\')) == NULL
)
2002 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
2004 char buf
[SET_ENV_BUF_SIZE
];
2007 for (p
= modname
; *p
; p
++)
2008 if (*p
== '\\') *p
= '/';
2010 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2011 _putenv (strdup (buf
));
2013 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
2015 /* FIXME: should use substring of get_emacs_configuration ().
2016 But I don't think the Windows build supports alpha, mips etc
2017 anymore, so have taken the easy option for now. */
2018 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
2019 || xstrcasecmp (p
, "\\AMD64") == 0))
2022 p
= strrchr (modname
, '\\');
2026 p
= strrchr (modname
, '\\');
2027 if (p
&& xstrcasecmp (p
, "\\src") == 0)
2029 char buf
[SET_ENV_BUF_SIZE
];
2032 for (p
= modname
; *p
; p
++)
2033 if (*p
== '\\') *p
= '/';
2035 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2036 _putenv (strdup (buf
));
2042 for (i
= 0; i
< N_ENV_VARS
; i
++)
2044 if (!getenv (env_vars
[i
].name
))
2048 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2049 /* Also ignore empty environment variables. */
2053 lpval
= env_vars
[i
].def_value
;
2054 dwType
= REG_EXPAND_SZ
;
2056 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
2057 Vdelayed_warnings_list
2058 = Fcons (listn (CONSTYPE_HEAP
, 2,
2059 intern ("initialization"),
2060 build_string ("Setting HOME to C:\\ by default is deprecated")),
2061 Vdelayed_warnings_list
);
2066 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2068 if (dwType
== REG_EXPAND_SZ
)
2069 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2070 else if (dwType
== REG_SZ
)
2071 strcpy (buf1
, lpval
);
2072 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2074 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2076 _putenv (strdup (buf2
));
2086 /* Rebuild system configuration to reflect invoking system. */
2087 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2089 /* Another special case: on NT, the PATH variable is actually named
2090 "Path" although cmd.exe (perhaps NT itself) arranges for
2091 environment variable lookup and setting to be case insensitive.
2092 However, Emacs assumes a fully case sensitive environment, so we
2093 need to change "Path" to "PATH" to match the expectations of
2094 various elisp packages. We do this by the sneaky method of
2095 modifying the string in the C runtime environ entry.
2097 The same applies to COMSPEC. */
2101 for (envp
= environ
; *envp
; envp
++)
2102 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2103 memcpy (*envp
, "PATH=", 5);
2104 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2105 memcpy (*envp
, "COMSPEC=", 8);
2108 /* Remember the initial working directory for getcwd. */
2109 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2110 Does it matter anywhere in Emacs? */
2111 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
2115 static char modname
[MAX_PATH
];
2117 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2122 /* Determine if there is a middle mouse button, to allow parse_button
2123 to decide whether right mouse events should be mouse-2 or
2125 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2130 /* Called from expand-file-name when default-directory is not a string. */
2133 emacs_root_dir (void)
2135 static char root_dir
[FILENAME_MAX
];
2138 p
= getenv ("emacs_dir");
2141 strcpy (root_dir
, p
);
2142 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2143 dostounix_filename (root_dir
);
2147 /* We don't have scripts to automatically determine the system configuration
2148 for Emacs before it's compiled, and we don't want to have to make the
2149 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
2153 get_emacs_configuration (void)
2155 char *arch
, *oem
, *os
;
2157 static char configuration_buffer
[32];
2159 /* Determine the processor type. */
2160 switch (get_processor_type ())
2163 #ifdef PROCESSOR_INTEL_386
2164 case PROCESSOR_INTEL_386
:
2165 case PROCESSOR_INTEL_486
:
2166 case PROCESSOR_INTEL_PENTIUM
:
2174 #ifdef PROCESSOR_AMD_X8664
2175 case PROCESSOR_AMD_X8664
:
2180 #ifdef PROCESSOR_MIPS_R2000
2181 case PROCESSOR_MIPS_R2000
:
2182 case PROCESSOR_MIPS_R3000
:
2183 case PROCESSOR_MIPS_R4000
:
2188 #ifdef PROCESSOR_ALPHA_21064
2189 case PROCESSOR_ALPHA_21064
:
2199 /* Use the OEM field to reflect the compiler/library combination. */
2201 #define COMPILER_NAME "msvc"
2204 #define COMPILER_NAME "mingw"
2206 #define COMPILER_NAME "unknown"
2209 oem
= COMPILER_NAME
;
2211 switch (osinfo_cache
.dwPlatformId
) {
2212 case VER_PLATFORM_WIN32_NT
:
2214 build_num
= osinfo_cache
.dwBuildNumber
;
2216 case VER_PLATFORM_WIN32_WINDOWS
:
2217 if (osinfo_cache
.dwMinorVersion
== 0) {
2222 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2224 case VER_PLATFORM_WIN32s
:
2225 /* Not supported, should not happen. */
2227 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2235 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
2236 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
2237 get_w32_major_version (), get_w32_minor_version (), build_num
);
2239 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
2242 return configuration_buffer
;
2246 get_emacs_configuration_options (void)
2248 static char *options_buffer
;
2249 char cv
[32]; /* Enough for COMPILER_VERSION. */
2251 cv
, /* To be filled later. */
2255 #ifdef ENABLE_CHECKING
2256 " --enable-checking",
2258 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2259 with a starting space to save work here. */
2261 " --cflags", USER_CFLAGS
,
2264 " --ldflags", USER_LDFLAGS
,
2271 /* Work out the effective configure options for this build. */
2273 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2276 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2278 #define COMPILER_VERSION ""
2282 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2283 return "Error: not enough space for compiler version";
2284 cv
[sizeof (cv
) - 1] = '\0';
2286 for (i
= 0; options
[i
]; i
++)
2287 size
+= strlen (options
[i
]);
2289 options_buffer
= xmalloc (size
+ 1);
2290 options_buffer
[0] = '\0';
2292 for (i
= 0; options
[i
]; i
++)
2293 strcat (options_buffer
, options
[i
]);
2295 return options_buffer
;
2299 #include <sys/timeb.h>
2301 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2303 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2308 tv
->tv_sec
= tb
.time
;
2309 tv
->tv_usec
= tb
.millitm
* 1000L;
2310 /* Implementation note: _ftime sometimes doesn't update the dstflag
2311 according to the new timezone when the system timezone is
2312 changed. We could fix that by using GetSystemTime and
2313 GetTimeZoneInformation, but that doesn't seem necessary, since
2314 Emacs always calls gettimeofday with the 2nd argument NULL (see
2315 current_emacs_time). */
2318 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2319 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2323 /* Emulate fdutimens. */
2325 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2326 TIMESPEC[0] and TIMESPEC[1], respectively.
2327 FD must be either negative -- in which case it is ignored --
2328 or a file descriptor that is open on FILE.
2329 If FD is nonnegative, then FILE can be NULL, which means
2330 use just futimes instead of utimes.
2331 If TIMESPEC is null, FAIL.
2332 Return 0 on success, -1 (setting errno) on failure. */
2335 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2344 if (fd
< 0 && !file
)
2349 ut
.actime
= timespec
[0].tv_sec
;
2350 ut
.modtime
= timespec
[1].tv_sec
;
2352 return _futime (fd
, &ut
);
2354 return _utime (file
, &ut
);
2358 /* ------------------------------------------------------------------------- */
2359 /* IO support and wrapper functions for the Windows API. */
2360 /* ------------------------------------------------------------------------- */
2362 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2363 on network directories, so we handle that case here.
2364 (Ulrich Leodolter, 1/11/95). */
2366 sys_ctime (const time_t *t
)
2368 char *str
= (char *) ctime (t
);
2369 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2372 /* Emulate sleep...we could have done this with a define, but that
2373 would necessitate including windows.h in the files that used it.
2374 This is much easier. */
2376 sys_sleep (int seconds
)
2378 Sleep (seconds
* 1000);
2381 /* Internal MSVC functions for low-level descriptor munging */
2382 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2383 extern int __cdecl
_free_osfhnd (int fd
);
2385 /* parallel array of private info on file handles */
2386 filedesc fd_info
[ MAXDESC
];
2388 typedef struct volume_info_data
{
2389 struct volume_info_data
* next
;
2391 /* time when info was obtained */
2394 /* actual volume info */
2403 /* Global referenced by various functions. */
2404 static volume_info_data volume_info
;
2406 /* Vector to indicate which drives are local and fixed (for which cached
2407 data never expires). */
2408 static BOOL fixed_drives
[26];
2410 /* Consider cached volume information to be stale if older than 10s,
2411 at least for non-local drives. Info for fixed drives is never stale. */
2412 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2413 #define VOLINFO_STILL_VALID( root_dir, info ) \
2414 ( ( isalpha (root_dir[0]) && \
2415 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2416 || GetTickCount () - info->timestamp < 10000 )
2418 /* Cache support functions. */
2420 /* Simple linked list with linear search is sufficient. */
2421 static volume_info_data
*volume_cache
= NULL
;
2423 static volume_info_data
*
2424 lookup_volume_info (char * root_dir
)
2426 volume_info_data
* info
;
2428 for (info
= volume_cache
; info
; info
= info
->next
)
2429 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2435 add_volume_info (char * root_dir
, volume_info_data
* info
)
2437 info
->root_dir
= xstrdup (root_dir
);
2438 info
->next
= volume_cache
;
2439 volume_cache
= info
;
2443 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2444 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2445 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2446 static volume_info_data
*
2447 GetCachedVolumeInformation (char * root_dir
)
2449 volume_info_data
* info
;
2450 char default_root
[ MAX_PATH
];
2452 /* NULL for root_dir means use root from current directory. */
2453 if (root_dir
== NULL
)
2455 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2457 parse_root (default_root
, &root_dir
);
2459 root_dir
= default_root
;
2462 /* Local fixed drives can be cached permanently. Removable drives
2463 cannot be cached permanently, since the volume name and serial
2464 number (if nothing else) can change. Remote drives should be
2465 treated as if they are removable, since there is no sure way to
2466 tell whether they are or not. Also, the UNC association of drive
2467 letters mapped to remote volumes can be changed at any time (even
2468 by other processes) without notice.
2470 As a compromise, so we can benefit from caching info for remote
2471 volumes, we use a simple expiry mechanism to invalidate cache
2472 entries that are more than ten seconds old. */
2475 /* No point doing this, because WNetGetConnection is even slower than
2476 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2477 GetDriveType is about the only call of this type which does not
2478 involve network access, and so is extremely quick). */
2480 /* Map drive letter to UNC if remote. */
2481 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2483 char remote_name
[ 256 ];
2484 char drive
[3] = { root_dir
[0], ':' };
2486 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2488 /* do something */ ;
2492 info
= lookup_volume_info (root_dir
);
2494 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2502 /* Info is not cached, or is stale. */
2503 if (!GetVolumeInformation (root_dir
,
2504 name
, sizeof (name
),
2508 type
, sizeof (type
)))
2511 /* Cache the volume information for future use, overwriting existing
2512 entry if present. */
2515 info
= xmalloc (sizeof (volume_info_data
));
2516 add_volume_info (root_dir
, info
);
2524 info
->name
= xstrdup (name
);
2525 info
->serialnum
= serialnum
;
2526 info
->maxcomp
= maxcomp
;
2527 info
->flags
= flags
;
2528 info
->type
= xstrdup (type
);
2529 info
->timestamp
= GetTickCount ();
2535 /* Get information on the volume where NAME is held; set path pointer to
2536 start of pathname in NAME (past UNC header\volume header if present),
2537 if pPath is non-NULL.
2539 Note: if NAME includes symlinks, the information is for the volume
2540 of the symlink, not of its target. That's because, even though
2541 GetVolumeInformation returns information about the symlink target
2542 of its argument, we only pass the root directory to
2543 GetVolumeInformation, not the full NAME. */
2545 get_volume_info (const char * name
, const char ** pPath
)
2547 char temp
[MAX_PATH
];
2548 char *rootname
= NULL
; /* default to current volume */
2549 volume_info_data
* info
;
2554 /* Find the root name of the volume if given. */
2555 if (isalpha (name
[0]) && name
[1] == ':')
2563 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2570 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2583 info
= GetCachedVolumeInformation (rootname
);
2586 /* Set global referenced by other functions. */
2587 volume_info
= *info
;
2593 /* Determine if volume is FAT format (ie. only supports short 8.3
2594 names); also set path pointer to start of pathname in name, if
2595 pPath is non-NULL. */
2597 is_fat_volume (const char * name
, const char ** pPath
)
2599 if (get_volume_info (name
, pPath
))
2600 return (volume_info
.maxcomp
== 12);
2604 /* Map filename to a valid 8.3 name if necessary.
2605 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2607 map_w32_filename (const char * name
, const char ** pPath
)
2609 static char shortname
[MAX_PATH
];
2610 char * str
= shortname
;
2613 const char * save_name
= name
;
2615 if (strlen (name
) >= MAX_PATH
)
2617 /* Return a filename which will cause callers to fail. */
2618 strcpy (shortname
, "?");
2622 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2624 register int left
= 8; /* maximum number of chars in part */
2625 register int extn
= 0; /* extension added? */
2626 register int dots
= 2; /* maximum number of dots allowed */
2629 *str
++ = *name
++; /* skip past UNC header */
2631 while ((c
= *name
++))
2638 *str
++ = (c
== ':' ? ':' : '\\');
2639 extn
= 0; /* reset extension flags */
2640 dots
= 2; /* max 2 dots */
2641 left
= 8; /* max length 8 for main part */
2646 /* Convert path components of the form .xxx to _xxx,
2647 but leave . and .. as they are. This allows .emacs
2648 to be read as _emacs, for example. */
2652 IS_DIRECTORY_SEP (*name
))
2667 extn
= 1; /* we've got an extension */
2668 left
= 3; /* 3 chars in extension */
2672 /* any embedded dots after the first are converted to _ */
2677 case '#': /* don't lose these, they're important */
2679 str
[-1] = c
; /* replace last character of part */
2684 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2686 dots
= 0; /* started a path component */
2695 strcpy (shortname
, name
);
2696 unixtodos_filename (shortname
);
2700 *pPath
= shortname
+ (path
- save_name
);
2706 is_exec (const char * name
)
2708 char * p
= strrchr (name
, '.');
2711 && (xstrcasecmp (p
, ".exe") == 0 ||
2712 xstrcasecmp (p
, ".com") == 0 ||
2713 xstrcasecmp (p
, ".bat") == 0 ||
2714 xstrcasecmp (p
, ".cmd") == 0));
2717 /* Emulate the Unix directory procedures opendir, closedir,
2718 and readdir. We can't use the procedures supplied in sysdep.c,
2719 so we provide them here. */
2721 struct dirent dir_static
; /* simulated directory contents */
2722 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2723 static int dir_is_fat
;
2724 static char dir_pathname
[MAXPATHLEN
+1];
2725 static WIN32_FIND_DATA dir_find_data
;
2727 /* Support shares on a network resource as subdirectories of a read-only
2729 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2730 static HANDLE
open_unc_volume (const char *);
2731 static char *read_unc_volume (HANDLE
, char *, int);
2732 static void close_unc_volume (HANDLE
);
2735 opendir (char *filename
)
2739 /* Opening is done by FindFirstFile. However, a read is inherent to
2740 this operation, so we defer the open until read time. */
2742 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2744 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2747 /* Note: We don't support traversal of UNC volumes via symlinks.
2748 Doing so would mean punishing 99.99% of use cases by resolving
2749 all the possible symlinks in FILENAME, recursively. */
2750 if (is_unc_volume (filename
))
2752 wnet_enum_handle
= open_unc_volume (filename
);
2753 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2757 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2764 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2765 dir_pathname
[MAXPATHLEN
] = '\0';
2766 /* Note: We don't support symlinks to file names on FAT volumes.
2767 Doing so would mean punishing 99.99% of use cases by resolving
2768 all the possible symlinks in FILENAME, recursively. */
2769 dir_is_fat
= is_fat_volume (filename
, NULL
);
2775 closedir (DIR *dirp
)
2777 /* If we have a find-handle open, close it. */
2778 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2780 FindClose (dir_find_handle
);
2781 dir_find_handle
= INVALID_HANDLE_VALUE
;
2783 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2785 close_unc_volume (wnet_enum_handle
);
2786 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2788 xfree ((char *) dirp
);
2794 int downcase
= !NILP (Vw32_downcase_file_names
);
2796 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2798 if (!read_unc_volume (wnet_enum_handle
,
2799 dir_find_data
.cFileName
,
2803 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2804 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2806 char filename
[MAXNAMLEN
+ 3];
2809 strcpy (filename
, dir_pathname
);
2810 ln
= strlen (filename
) - 1;
2811 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2812 strcat (filename
, "\\");
2813 strcat (filename
, "*");
2815 /* Note: No need to resolve symlinks in FILENAME, because
2816 FindFirst opens the directory that is the target of a
2818 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2820 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2825 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2829 /* Emacs never uses this value, so don't bother making it match
2830 value returned by stat(). */
2831 dir_static
.d_ino
= 1;
2833 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2835 /* If the file name in cFileName[] includes `?' characters, it means
2836 the original file name used characters that cannot be represented
2837 by the current ANSI codepage. To avoid total lossage, retrieve
2838 the short 8+3 alias of the long file name. */
2839 if (_mbspbrk (dir_static
.d_name
, "?"))
2841 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2842 downcase
= 1; /* 8+3 aliases are returned in all caps */
2844 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2845 dir_static
.d_reclen
= sizeof (struct dirent
) - MAXNAMLEN
+ 3 +
2846 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2848 /* If the file name in cFileName[] includes `?' characters, it means
2849 the original file name used characters that cannot be represented
2850 by the current ANSI codepage. To avoid total lossage, retrieve
2851 the short 8+3 alias of the long file name. */
2852 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2854 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2855 /* 8+3 aliases are returned in all caps, which could break
2856 various alists that look at filenames' extensions. */
2860 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2861 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2863 _strlwr (dir_static
.d_name
);
2867 for (p
= dir_static
.d_name
; *p
; p
++)
2868 if (*p
>= 'a' && *p
<= 'z')
2871 _strlwr (dir_static
.d_name
);
2878 open_unc_volume (const char *path
)
2884 nr
.dwScope
= RESOURCE_GLOBALNET
;
2885 nr
.dwType
= RESOURCETYPE_DISK
;
2886 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2887 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2888 nr
.lpLocalName
= NULL
;
2889 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2890 nr
.lpComment
= NULL
;
2891 nr
.lpProvider
= NULL
;
2893 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2894 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2896 if (result
== NO_ERROR
)
2899 return INVALID_HANDLE_VALUE
;
2903 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2907 DWORD bufsize
= 512;
2912 buffer
= alloca (bufsize
);
2913 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2914 if (result
!= NO_ERROR
)
2917 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2918 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2920 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2923 strncpy (readbuf
, ptr
, size
);
2928 close_unc_volume (HANDLE henum
)
2930 if (henum
!= INVALID_HANDLE_VALUE
)
2931 WNetCloseEnum (henum
);
2935 unc_volume_file_attributes (const char *path
)
2940 henum
= open_unc_volume (path
);
2941 if (henum
== INVALID_HANDLE_VALUE
)
2944 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2946 close_unc_volume (henum
);
2951 /* Ensure a network connection is authenticated. */
2953 logon_network_drive (const char *path
)
2955 NETRESOURCE resource
;
2956 char share
[MAX_PATH
];
2961 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2962 drvtype
= DRIVE_REMOTE
;
2963 else if (path
[0] == '\0' || path
[1] != ':')
2964 drvtype
= GetDriveType (NULL
);
2971 drvtype
= GetDriveType (drive
);
2974 /* Only logon to networked drives. */
2975 if (drvtype
!= DRIVE_REMOTE
)
2979 strncpy (share
, path
, MAX_PATH
);
2980 /* Truncate to just server and share name. */
2981 for (i
= 2; i
< MAX_PATH
; i
++)
2983 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2990 resource
.dwType
= RESOURCETYPE_DISK
;
2991 resource
.lpLocalName
= NULL
;
2992 resource
.lpRemoteName
= share
;
2993 resource
.lpProvider
= NULL
;
2995 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2998 /* Emulate faccessat(2). */
3000 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3004 if (dirfd
!= AT_FDCWD
3005 && !(IS_DIRECTORY_SEP (path
[0])
3006 || IS_DEVICE_SEP (path
[1])))
3012 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3013 newer versions blow up when passed D_OK. */
3014 path
= map_w32_filename (path
, NULL
);
3015 /* If the last element of PATH is a symlink, we need to resolve it
3016 to get the attributes of its target file. Note: any symlinks in
3017 PATH elements other than the last one are transparently resolved
3018 by GetFileAttributes below. */
3019 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3020 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3021 path
= chase_symlinks (path
);
3023 if ((attributes
= GetFileAttributes (path
)) == -1)
3025 DWORD w32err
= GetLastError ();
3029 case ERROR_INVALID_NAME
:
3030 case ERROR_BAD_PATHNAME
:
3031 if (is_unc_volume (path
))
3033 attributes
= unc_volume_file_attributes (path
);
3034 if (attributes
== -1)
3042 case ERROR_FILE_NOT_FOUND
:
3043 case ERROR_BAD_NETPATH
:
3052 if ((mode
& X_OK
) != 0
3053 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3058 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3063 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3071 /* Shadow some MSVC runtime functions to map requests for long filenames
3072 to reasonable short names if necessary. This was originally added to
3073 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3077 sys_chdir (const char * path
)
3079 return _chdir (map_w32_filename (path
, NULL
));
3083 sys_chmod (const char * path
, int mode
)
3085 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3086 return _chmod (path
, mode
);
3090 sys_chown (const char *path
, uid_t owner
, gid_t group
)
3092 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
3098 sys_creat (const char * path
, int mode
)
3100 return _creat (map_w32_filename (path
, NULL
), mode
);
3104 sys_fopen (const char * path
, const char * mode
)
3108 const char * mode_save
= mode
;
3110 /* Force all file handles to be non-inheritable. This is necessary to
3111 ensure child processes don't unwittingly inherit handles that might
3112 prevent future file access. */
3116 else if (mode
[0] == 'w' || mode
[0] == 'a')
3117 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3121 /* Only do simplistic option parsing. */
3125 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3128 else if (mode
[0] == 'b')
3133 else if (mode
[0] == 't')
3140 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
3144 return _fdopen (fd
, mode_save
);
3147 /* This only works on NTFS volumes, but is useful to have. */
3149 sys_link (const char * old
, const char * new)
3153 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
3155 if (old
== NULL
|| new == NULL
)
3161 strcpy (oldname
, map_w32_filename (old
, NULL
));
3162 strcpy (newname
, map_w32_filename (new, NULL
));
3164 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
3165 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3166 if (fileh
!= INVALID_HANDLE_VALUE
)
3170 /* Confusingly, the "alternate" stream name field does not apply
3171 when restoring a hard link, and instead contains the actual
3172 stream data for the link (ie. the name of the link to create).
3173 The WIN32_STREAM_ID structure before the cStreamName field is
3174 the stream header, which is then immediately followed by the
3178 WIN32_STREAM_ID wid
;
3179 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3182 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
3183 data
.wid
.cStreamName
, MAX_PATH
);
3186 LPVOID context
= NULL
;
3189 data
.wid
.dwStreamId
= BACKUP_LINK
;
3190 data
.wid
.dwStreamAttributes
= 0;
3191 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3192 data
.wid
.Size
.HighPart
= 0;
3193 data
.wid
.dwStreamNameSize
= 0;
3195 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3196 offsetof (WIN32_STREAM_ID
, cStreamName
)
3197 + data
.wid
.Size
.LowPart
,
3198 &wbytes
, FALSE
, FALSE
, &context
)
3199 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3206 /* Should try mapping GetLastError to errno; for now just
3207 indicate a general error (eg. links not supported). */
3208 errno
= EINVAL
; // perhaps EMLINK?
3212 CloseHandle (fileh
);
3221 sys_mkdir (const char * path
)
3223 return _mkdir (map_w32_filename (path
, NULL
));
3226 /* Because of long name mapping issues, we need to implement this
3227 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
3228 a unique name, instead of setting the input template to an empty
3231 Standard algorithm seems to be use pid or tid with a letter on the
3232 front (in place of the 6 X's) and cycle through the letters to find a
3233 unique name. We extend that to allow any reasonable character as the
3234 first of the 6 X's. */
3236 sys_mktemp (char * template)
3240 unsigned uid
= GetCurrentThreadId ();
3241 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3243 if (template == NULL
)
3245 p
= template + strlen (template);
3247 /* replace up to the last 5 X's with uid in decimal */
3248 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3250 p
[0] = '0' + uid
% 10;
3254 if (i
< 0 && p
[0] == 'X')
3259 int save_errno
= errno
;
3260 p
[0] = first_char
[i
];
3261 if (faccessat (AT_FDCWD
, template, F_OK
, AT_EACCESS
) < 0)
3267 while (++i
< sizeof (first_char
));
3270 /* Template is badly formed or else we can't generate a unique name,
3271 so return empty string */
3277 sys_open (const char * path
, int oflag
, int mode
)
3279 const char* mpath
= map_w32_filename (path
, NULL
);
3280 /* Try to open file without _O_CREAT, to be able to write to hidden
3281 and system files. Force all file handles to be
3283 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3286 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3290 sys_rename (const char * oldname
, const char * newname
)
3293 char temp
[MAX_PATH
];
3297 /* MoveFile on Windows 95 doesn't correctly change the short file name
3298 alias in a number of circumstances (it is not easy to predict when
3299 just by looking at oldname and newname, unfortunately). In these
3300 cases, renaming through a temporary name avoids the problem.
3302 A second problem on Windows 95 is that renaming through a temp name when
3303 newname is uppercase fails (the final long name ends up in
3304 lowercase, although the short alias might be uppercase) UNLESS the
3305 long temp name is not 8.3.
3307 So, on Windows 95 we always rename through a temp name, and we make sure
3308 the temp name has a long extension to ensure correct renaming. */
3310 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3312 /* volume_info is set indirectly by map_w32_filename. */
3313 oldname_dev
= volume_info
.serialnum
;
3315 if (os_subtype
== OS_9X
)
3321 oldname
= map_w32_filename (oldname
, NULL
);
3322 if ((o
= strrchr (oldname
, '\\')))
3325 o
= (char *) oldname
;
3327 if ((p
= strrchr (temp
, '\\')))
3334 /* Force temp name to require a manufactured 8.3 alias - this
3335 seems to make the second rename work properly. */
3336 sprintf (p
, "_.%s.%u", o
, i
);
3338 result
= rename (oldname
, temp
);
3340 /* This loop must surely terminate! */
3341 while (result
< 0 && errno
== EEXIST
);
3346 /* Emulate Unix behavior - newname is deleted if it already exists
3347 (at least if it is a file; don't do this for directories).
3349 Since we mustn't do this if we are just changing the case of the
3350 file name (we would end up deleting the file we are trying to
3351 rename!), we let rename detect if the destination file already
3352 exists - that way we avoid the possible pitfalls of trying to
3353 determine ourselves whether two names really refer to the same
3354 file, which is not always possible in the general case. (Consider
3355 all the permutations of shared or subst'd drives, etc.) */
3357 newname
= map_w32_filename (newname
, NULL
);
3359 /* volume_info is set indirectly by map_w32_filename. */
3360 newname_dev
= volume_info
.serialnum
;
3362 result
= rename (temp
, newname
);
3366 DWORD w32err
= GetLastError ();
3369 && newname_dev
!= oldname_dev
)
3371 /* The implementation of `rename' on Windows does not return
3372 errno = EXDEV when you are moving a directory to a
3373 different storage device (ex. logical disk). It returns
3374 EACCES instead. So here we handle such situations and
3378 if ((attributes
= GetFileAttributes (temp
)) != -1
3379 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3382 else if (errno
== EEXIST
)
3384 if (_chmod (newname
, 0666) != 0)
3386 if (_unlink (newname
) != 0)
3388 result
= rename (temp
, newname
);
3390 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3391 && is_symlink (temp
))
3393 /* This is Windows prohibiting the user from creating a
3394 symlink in another place, since that requires
3404 sys_rmdir (const char * path
)
3406 return _rmdir (map_w32_filename (path
, NULL
));
3410 sys_unlink (const char * path
)
3412 path
= map_w32_filename (path
, NULL
);
3414 /* On Unix, unlink works without write permission. */
3415 _chmod (path
, 0666);
3416 return _unlink (path
);
3419 static FILETIME utc_base_ft
;
3420 static ULONGLONG utc_base
; /* In 100ns units */
3421 static int init
= 0;
3423 #define FILETIME_TO_U64(result, ft) \
3425 ULARGE_INTEGER uiTemp; \
3426 uiTemp.LowPart = (ft).dwLowDateTime; \
3427 uiTemp.HighPart = (ft).dwHighDateTime; \
3428 result = uiTemp.QuadPart; \
3432 initialize_utc_base (void)
3434 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3443 st
.wMilliseconds
= 0;
3445 SystemTimeToFileTime (&st
, &utc_base_ft
);
3446 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3450 convert_time (FILETIME ft
)
3456 initialize_utc_base ();
3460 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3463 FILETIME_TO_U64 (tmp
, ft
);
3464 return (time_t) ((tmp
- utc_base
) / 10000000L);
3468 convert_from_time_t (time_t time
, FILETIME
* pft
)
3474 initialize_utc_base ();
3478 /* time in 100ns units since 1-Jan-1601 */
3479 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3480 pft
->dwHighDateTime
= tmp
.HighPart
;
3481 pft
->dwLowDateTime
= tmp
.LowPart
;
3485 /* No reason to keep this; faking inode values either by hashing or even
3486 using the file index from GetInformationByHandle, is not perfect and
3487 so by default Emacs doesn't use the inode values on Windows.
3488 Instead, we now determine file-truename correctly (except for
3489 possible drive aliasing etc). */
3491 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3493 hashval (const unsigned char * str
)
3498 h
= (h
<< 4) + *str
++;
3504 /* Return the hash value of the canonical pathname, excluding the
3505 drive/UNC header, to get a hopefully unique inode number. */
3507 generate_inode_val (const char * name
)
3509 char fullname
[ MAX_PATH
];
3513 /* Get the truly canonical filename, if it exists. (Note: this
3514 doesn't resolve aliasing due to subst commands, or recognize hard
3516 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3519 parse_root (fullname
, &p
);
3520 /* Normal W32 filesystems are still case insensitive. */
3527 static PSECURITY_DESCRIPTOR
3528 get_file_security_desc_by_handle (HANDLE h
)
3530 PSECURITY_DESCRIPTOR psd
= NULL
;
3532 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3533 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3535 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3536 NULL
, NULL
, NULL
, NULL
, &psd
);
3537 if (err
!= ERROR_SUCCESS
)
3543 static PSECURITY_DESCRIPTOR
3544 get_file_security_desc_by_name (const char *fname
)
3546 PSECURITY_DESCRIPTOR psd
= NULL
;
3548 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3549 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3551 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3553 err
= GetLastError ();
3554 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3558 psd
= xmalloc (sd_len
);
3559 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3571 unsigned n_subauthorities
;
3573 /* Use the last sub-authority value of the RID, the relative
3574 portion of the SID, as user/group ID. */
3575 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3576 if (n_subauthorities
< 1)
3577 return 0; /* the "World" RID */
3578 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3581 /* Caching SID and account values for faster lokup. */
3584 # define FLEXIBLE_ARRAY_MEMBER
3586 # define FLEXIBLE_ARRAY_MEMBER 1
3591 struct w32_id
*next
;
3593 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3596 static struct w32_id
*w32_idlist
;
3599 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3601 struct w32_id
*tail
, *found
;
3603 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3605 if (equal_sid ((PSID
)tail
->sid
, sid
))
3614 strcpy (name
, found
->name
);
3622 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3625 struct w32_id
*new_entry
;
3627 /* We don't want to leave behind stale cache from when Emacs was
3631 sid_len
= get_length_sid (sid
);
3632 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3635 new_entry
->rid
= id
;
3636 strcpy (new_entry
->name
, name
);
3637 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3638 new_entry
->next
= w32_idlist
;
3639 w32_idlist
= new_entry
;
3648 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
3651 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3653 SID_NAME_USE ignore
;
3655 DWORD name_len
= sizeof (name
);
3657 DWORD domain_len
= sizeof (domain
);
3662 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3663 else if (what
== GID
)
3664 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3668 if (!result
|| !is_valid_sid (sid
))
3670 else if (!w32_cached_id (sid
, id
, nm
))
3672 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
3673 domain
, &domain_len
, &ignore
)
3674 || name_len
> UNLEN
+1)
3678 *id
= get_rid (sid
);
3680 w32_add_to_cache (sid
, *id
, name
);
3687 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
3689 int dflt_usr
= 0, dflt_grp
= 0;
3698 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
3700 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
3703 /* Consider files to belong to current user/group, if we cannot get
3704 more accurate information. */
3707 st
->st_uid
= dflt_passwd
.pw_uid
;
3708 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3712 st
->st_gid
= dflt_passwd
.pw_gid
;
3713 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3717 /* Return non-zero if NAME is a potentially slow filesystem. */
3719 is_slow_fs (const char *name
)
3724 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3725 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3726 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3727 devtype
= GetDriveType (NULL
); /* use root of current drive */
3730 /* GetDriveType needs the root directory of the drive. */
3731 strncpy (drive_root
, name
, 2);
3732 drive_root
[2] = '\\';
3733 drive_root
[3] = '\0';
3734 devtype
= GetDriveType (drive_root
);
3736 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3739 /* If this is non-zero, the caller wants accurate information about
3740 file's owner and group, which could be expensive to get. */
3741 int w32_stat_get_owner_group
;
3743 /* MSVC stat function can't cope with UNC names and has other bugs, so
3744 replace it with our own. This also allows us to calculate consistent
3745 inode values and owner/group without hacks in the main Emacs code. */
3748 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3750 char *name
, *save_name
, *r
;
3751 WIN32_FIND_DATA wfd
;
3753 unsigned __int64 fake_inode
= 0;
3756 int rootdir
= FALSE
;
3757 PSECURITY_DESCRIPTOR psd
= NULL
;
3758 int is_a_symlink
= 0;
3759 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3760 DWORD access_rights
= 0;
3761 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3762 FILETIME ctime
, atime
, wtime
;
3764 if (path
== NULL
|| buf
== NULL
)
3770 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3771 /* Must be valid filename, no wild cards or other invalid
3772 characters. We use _mbspbrk to support multibyte strings that
3773 might look to strpbrk as if they included literal *, ?, and other
3774 characters mentioned below that are disallowed by Windows
3776 if (_mbspbrk (name
, "*?|<>\""))
3782 /* Remove trailing directory separator, unless name is the root
3783 directory of a drive or UNC volume in which case ensure there
3784 is a trailing separator. */
3785 len
= strlen (name
);
3786 name
= strcpy (alloca (len
+ 2), name
);
3788 /* Avoid a somewhat costly call to is_symlink if the filesystem
3789 doesn't support symlinks. */
3790 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3791 is_a_symlink
= is_symlink (name
);
3793 /* Plan A: Open the file and get all the necessary information via
3794 the resulting handle. This solves several issues in one blow:
3796 . retrieves attributes for the target of a symlink, if needed
3797 . gets attributes of root directories and symlinks pointing to
3798 root directories, thus avoiding the need for special-casing
3799 these and detecting them by examining the file-name format
3800 . retrieves more accurate attributes (e.g., non-zero size for
3801 some directories, esp. directories that are junction points)
3802 . correctly resolves "c:/..", "/.." and similar file names
3803 . avoids run-time penalties for 99% of use cases
3805 Plan A is always tried first, unless the user asked not to (but
3806 if the file is a symlink and we need to follow links, we try Plan
3807 A even if the user asked not to).
3809 If Plan A fails, we go to Plan B (below), where various
3810 potentially expensive techniques must be used to handle "special"
3811 files such as UNC volumes etc. */
3812 if (!(NILP (Vw32_get_true_file_attributes
)
3813 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3814 /* Following symlinks requires getting the info by handle. */
3815 || (is_a_symlink
&& follow_symlinks
))
3817 BY_HANDLE_FILE_INFORMATION info
;
3819 if (is_a_symlink
&& !follow_symlinks
)
3820 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3821 /* READ_CONTROL access rights are required to get security info
3822 by handle. But if the OS doesn't support security in the
3823 first place, we don't need to try. */
3824 if (is_windows_9x () != TRUE
)
3825 access_rights
|= READ_CONTROL
;
3827 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3829 /* If CreateFile fails with READ_CONTROL, try again with zero as
3831 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3832 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3834 if (fh
== INVALID_HANDLE_VALUE
)
3835 goto no_true_file_attributes
;
3837 /* This is more accurate in terms of getting the correct number
3838 of links, but is quite slow (it is noticeable when Emacs is
3839 making a list of file name completions). */
3840 if (GetFileInformationByHandle (fh
, &info
))
3842 nlinks
= info
.nNumberOfLinks
;
3843 /* Might as well use file index to fake inode values, but this
3844 is not guaranteed to be unique unless we keep a handle open
3845 all the time (even then there are situations where it is
3846 not unique). Reputedly, there are at most 48 bits of info
3847 (on NTFS, presumably less on FAT). */
3848 fake_inode
= info
.nFileIndexHigh
;
3850 fake_inode
+= info
.nFileIndexLow
;
3851 serialnum
= info
.dwVolumeSerialNumber
;
3852 fs_high
= info
.nFileSizeHigh
;
3853 fs_low
= info
.nFileSizeLow
;
3854 ctime
= info
.ftCreationTime
;
3855 atime
= info
.ftLastAccessTime
;
3856 wtime
= info
.ftLastWriteTime
;
3857 fattrs
= info
.dwFileAttributes
;
3861 /* We don't go to Plan B here, because it's not clear that
3862 it's a good idea. The only known use case where
3863 CreateFile succeeds, but GetFileInformationByHandle fails
3864 (with ERROR_INVALID_FUNCTION) is for character devices
3865 such as NUL, PRN, etc. For these, switching to Plan B is
3866 a net loss, because we lose the character device
3867 attribute returned by GetFileType below (FindFirstFile
3868 doesn't set that bit in the attributes), and the other
3869 fields don't make sense for character devices anyway.
3870 Emacs doesn't really care for non-file entities in the
3871 context of l?stat, so neither do we. */
3873 /* w32err is assigned so one could put a breakpoint here and
3874 examine its value, when GetFileInformationByHandle
3876 DWORD w32err
= GetLastError ();
3880 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3886 /* Test for a symlink before testing for a directory, since
3887 symlinks to directories have the directory bit set, but we
3888 don't want them to appear as directories. */
3889 if (is_a_symlink
&& !follow_symlinks
)
3890 buf
->st_mode
= S_IFLNK
;
3891 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3892 buf
->st_mode
= S_IFDIR
;
3895 DWORD ftype
= GetFileType (fh
);
3899 case FILE_TYPE_DISK
:
3900 buf
->st_mode
= S_IFREG
;
3902 case FILE_TYPE_PIPE
:
3903 buf
->st_mode
= S_IFIFO
;
3905 case FILE_TYPE_CHAR
:
3906 case FILE_TYPE_UNKNOWN
:
3908 buf
->st_mode
= S_IFCHR
;
3911 /* We produce the fallback owner and group data, based on the
3912 current user that runs Emacs, in the following cases:
3914 . caller didn't request owner and group info
3915 . this is Windows 9X
3916 . getting security by handle failed, and we need to produce
3917 information for the target of a symlink (this is better
3918 than producing a potentially misleading info about the
3921 If getting security by handle fails, and we don't need to
3922 resolve symlinks, we try getting security by name. */
3923 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
3924 get_file_owner_and_group (NULL
, buf
);
3927 psd
= get_file_security_desc_by_handle (fh
);
3930 get_file_owner_and_group (psd
, buf
);
3933 else if (!(is_a_symlink
&& follow_symlinks
))
3935 psd
= get_file_security_desc_by_name (name
);
3936 get_file_owner_and_group (psd
, buf
);
3940 get_file_owner_and_group (NULL
, buf
);
3946 no_true_file_attributes
:
3947 /* Plan B: Either getting a handle on the file failed, or the
3948 caller explicitly asked us to not bother making this
3949 information more accurate.
3951 Implementation note: In Plan B, we never bother to resolve
3952 symlinks, even if we got here because we tried Plan A and
3953 failed. That's because, even if the caller asked for extra
3954 precision by setting Vw32_get_true_file_attributes to t,
3955 resolving symlinks requires acquiring a file handle to the
3956 symlink, which we already know will fail. And if the user
3957 did not ask for extra precision, resolving symlinks will fly
3958 in the face of that request, since the user then wants the
3959 lightweight version of the code. */
3960 rootdir
= (path
>= save_name
+ len
- 1
3961 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3963 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3964 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3965 if (IS_DIRECTORY_SEP (r
[0])
3966 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3969 /* Note: If NAME is a symlink to the root of a UNC volume
3970 (i.e. "\\SERVER"), we will not detect that here, and we will
3971 return data about the symlink as result of FindFirst below.
3972 This is unfortunate, but that marginal use case does not
3973 justify a call to chase_symlinks which would impose a penalty
3974 on all the other use cases. (We get here for symlinks to
3975 roots of UNC volumes because CreateFile above fails for them,
3976 unlike with symlinks to root directories X:\ of drives.) */
3977 if (is_unc_volume (name
))
3979 fattrs
= unc_volume_file_attributes (name
);
3983 ctime
= atime
= wtime
= utc_base_ft
;
3987 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3988 strcat (name
, "\\");
3989 if (GetDriveType (name
) < 2)
3995 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3996 ctime
= atime
= wtime
= utc_base_ft
;
4000 if (IS_DIRECTORY_SEP (name
[len
-1]))
4003 /* (This is hacky, but helps when doing file completions on
4004 network drives.) Optimize by using information available from
4005 active readdir if possible. */
4006 len
= strlen (dir_pathname
);
4007 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4009 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4010 && !(is_a_symlink
&& follow_symlinks
)
4011 && strnicmp (save_name
, dir_pathname
, len
) == 0
4012 && IS_DIRECTORY_SEP (name
[len
])
4013 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
4015 /* This was the last entry returned by readdir. */
4016 wfd
= dir_find_data
;
4020 logon_network_drive (name
);
4022 fh
= FindFirstFile (name
, &wfd
);
4023 if (fh
== INVALID_HANDLE_VALUE
)
4030 /* Note: if NAME is a symlink, the information we get from
4031 FindFirstFile is for the symlink, not its target. */
4032 fattrs
= wfd
.dwFileAttributes
;
4033 ctime
= wfd
.ftCreationTime
;
4034 atime
= wfd
.ftLastAccessTime
;
4035 wtime
= wfd
.ftLastWriteTime
;
4036 fs_high
= wfd
.nFileSizeHigh
;
4037 fs_low
= wfd
.nFileSizeLow
;
4040 serialnum
= volume_info
.serialnum
;
4042 if (is_a_symlink
&& !follow_symlinks
)
4043 buf
->st_mode
= S_IFLNK
;
4044 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4045 buf
->st_mode
= S_IFDIR
;
4047 buf
->st_mode
= S_IFREG
;
4049 get_file_owner_and_group (NULL
, buf
);
4053 /* Not sure if there is any point in this. */
4054 if (!NILP (Vw32_generate_fake_inodes
))
4055 fake_inode
= generate_inode_val (name
);
4056 else if (fake_inode
== 0)
4058 /* For want of something better, try to make everything unique. */
4059 static DWORD gen_num
= 0;
4060 fake_inode
= ++gen_num
;
4064 buf
->st_ino
= fake_inode
;
4066 buf
->st_dev
= serialnum
;
4067 buf
->st_rdev
= serialnum
;
4069 buf
->st_size
= fs_high
;
4070 buf
->st_size
<<= 32;
4071 buf
->st_size
+= fs_low
;
4072 buf
->st_nlink
= nlinks
;
4074 /* Convert timestamps to Unix format. */
4075 buf
->st_mtime
= convert_time (wtime
);
4076 buf
->st_atime
= convert_time (atime
);
4077 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4078 buf
->st_ctime
= convert_time (ctime
);
4079 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4081 /* determine rwx permissions */
4082 if (is_a_symlink
&& !follow_symlinks
)
4083 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
4086 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
4087 permission
= S_IREAD
;
4089 permission
= S_IREAD
| S_IWRITE
;
4091 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4092 permission
|= S_IEXEC
;
4093 else if (is_exec (name
))
4094 permission
|= S_IEXEC
;
4097 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4103 stat (const char * path
, struct stat
* buf
)
4105 return stat_worker (path
, buf
, 1);
4109 lstat (const char * path
, struct stat
* buf
)
4111 return stat_worker (path
, buf
, 0);
4114 /* Provide fstat and utime as well as stat for consistent handling of
4117 fstat (int desc
, struct stat
* buf
)
4119 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
4120 BY_HANDLE_FILE_INFORMATION info
;
4121 unsigned __int64 fake_inode
;
4124 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4126 case FILE_TYPE_DISK
:
4127 buf
->st_mode
= S_IFREG
;
4128 if (!GetFileInformationByHandle (fh
, &info
))
4134 case FILE_TYPE_PIPE
:
4135 buf
->st_mode
= S_IFIFO
;
4137 case FILE_TYPE_CHAR
:
4138 case FILE_TYPE_UNKNOWN
:
4140 buf
->st_mode
= S_IFCHR
;
4142 memset (&info
, 0, sizeof (info
));
4143 info
.dwFileAttributes
= 0;
4144 info
.ftCreationTime
= utc_base_ft
;
4145 info
.ftLastAccessTime
= utc_base_ft
;
4146 info
.ftLastWriteTime
= utc_base_ft
;
4149 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4150 buf
->st_mode
= S_IFDIR
;
4152 buf
->st_nlink
= info
.nNumberOfLinks
;
4153 /* Might as well use file index to fake inode values, but this
4154 is not guaranteed to be unique unless we keep a handle open
4155 all the time (even then there are situations where it is
4156 not unique). Reputedly, there are at most 48 bits of info
4157 (on NTFS, presumably less on FAT). */
4158 fake_inode
= info
.nFileIndexHigh
;
4160 fake_inode
+= info
.nFileIndexLow
;
4162 /* MSVC defines _ino_t to be short; other libc's might not. */
4163 if (sizeof (buf
->st_ino
) == 2)
4164 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4166 buf
->st_ino
= fake_inode
;
4168 /* Consider files to belong to current user.
4169 FIXME: this should use GetSecurityInfo API, but it is only
4170 available for _WIN32_WINNT >= 0x501. */
4171 buf
->st_uid
= dflt_passwd
.pw_uid
;
4172 buf
->st_gid
= dflt_passwd
.pw_gid
;
4173 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
4174 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
4176 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4177 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4179 buf
->st_size
= info
.nFileSizeHigh
;
4180 buf
->st_size
<<= 32;
4181 buf
->st_size
+= info
.nFileSizeLow
;
4183 /* Convert timestamps to Unix format. */
4184 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4185 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4186 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4187 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4188 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4190 /* determine rwx permissions */
4191 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4192 permission
= S_IREAD
;
4194 permission
= S_IREAD
| S_IWRITE
;
4196 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4197 permission
|= S_IEXEC
;
4200 #if 0 /* no way of knowing the filename */
4201 char * p
= strrchr (name
, '.');
4203 (xstrcasecmp (p
, ".exe") == 0 ||
4204 xstrcasecmp (p
, ".com") == 0 ||
4205 xstrcasecmp (p
, ".bat") == 0 ||
4206 xstrcasecmp (p
, ".cmd") == 0))
4207 permission
|= S_IEXEC
;
4211 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4217 utime (const char *name
, struct utimbuf
*times
)
4219 struct utimbuf deftime
;
4226 deftime
.modtime
= deftime
.actime
= time (NULL
);
4230 /* Need write access to set times. */
4231 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
4232 /* If NAME specifies a directory, FILE_SHARE_DELETE
4233 allows other processes to delete files inside it,
4234 while we have the directory open. */
4235 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4236 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4237 if (fh
!= INVALID_HANDLE_VALUE
)
4239 convert_from_time_t (times
->actime
, &atime
);
4240 convert_from_time_t (times
->modtime
, &mtime
);
4241 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4258 /* Symlink-related functions. */
4259 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4260 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4264 symlink (char const *filename
, char const *linkname
)
4266 char linkfn
[MAX_PATH
], *tgtfn
;
4268 int dir_access
, filename_ends_in_slash
;
4270 /* Diagnostics follows Posix as much as possible. */
4271 if (filename
== NULL
|| linkname
== NULL
)
4281 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4283 errno
= ENAMETOOLONG
;
4287 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4288 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4294 /* Note: since empty FILENAME was already rejected, we can safely
4295 refer to FILENAME[1]. */
4296 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4298 /* Non-absolute FILENAME is understood as being relative to
4299 LINKNAME's directory. We need to prepend that directory to
4300 FILENAME to get correct results from faccessat below, since
4301 otherwise it will interpret FILENAME relative to the
4302 directory where the Emacs process runs. Note that
4303 make-symbolic-link always makes sure LINKNAME is a fully
4304 expanded file name. */
4306 char *p
= linkfn
+ strlen (linkfn
);
4308 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4311 strncpy (tem
, linkfn
, p
- linkfn
);
4312 tem
[p
- linkfn
] = '\0';
4313 strcat (tem
, filename
);
4314 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4317 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4319 /* Since Windows distinguishes between symlinks to directories and
4320 to files, we provide a kludgy feature: if FILENAME doesn't
4321 exist, but ends in a slash, we create a symlink to directory. If
4322 FILENAME exists and is a directory, we always create a symlink to
4324 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4325 if (dir_access
== 0 || filename_ends_in_slash
)
4326 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4328 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4329 if (filename_ends_in_slash
)
4330 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4333 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4335 /* ENOSYS is set by create_symbolic_link, when it detects that
4336 the OS doesn't support the CreateSymbolicLink API. */
4337 if (errno
!= ENOSYS
)
4339 DWORD w32err
= GetLastError ();
4343 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4344 TGTFN point to the same file name, go figure. */
4346 case ERROR_FILE_EXISTS
:
4349 case ERROR_ACCESS_DENIED
:
4352 case ERROR_FILE_NOT_FOUND
:
4353 case ERROR_PATH_NOT_FOUND
:
4354 case ERROR_BAD_NETPATH
:
4355 case ERROR_INVALID_REPARSE_DATA
:
4358 case ERROR_DIRECTORY
:
4361 case ERROR_PRIVILEGE_NOT_HELD
:
4362 case ERROR_NOT_ALL_ASSIGNED
:
4365 case ERROR_DISK_FULL
:
4378 /* A quick inexpensive test of whether FILENAME identifies a file that
4379 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4380 must already be in the normalized form returned by
4383 Note: for repeated operations on many files, it is best to test
4384 whether the underlying volume actually supports symlinks, by
4385 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4386 avoid the call to this function if it doesn't. That's because the
4387 call to GetFileAttributes takes a non-negligible time, especially
4388 on non-local or removable filesystems. See stat_worker for an
4389 example of how to do that. */
4391 is_symlink (const char *filename
)
4394 WIN32_FIND_DATA wfd
;
4397 attrs
= GetFileAttributes (filename
);
4400 DWORD w32err
= GetLastError ();
4404 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4406 case ERROR_ACCESS_DENIED
:
4409 case ERROR_FILE_NOT_FOUND
:
4410 case ERROR_PATH_NOT_FOUND
:
4417 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4419 logon_network_drive (filename
);
4420 fh
= FindFirstFile (filename
, &wfd
);
4421 if (fh
== INVALID_HANDLE_VALUE
)
4424 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4425 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4428 /* If NAME identifies a symbolic link, copy into BUF the file name of
4429 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4430 null-terminate the target name, even if it fits. Return the number
4431 of bytes copied, or -1 if NAME is not a symlink or any error was
4432 encountered while resolving it. The file name copied into BUF is
4433 encoded in the current ANSI codepage. */
4435 readlink (const char *name
, char *buf
, size_t buf_size
)
4438 TOKEN_PRIVILEGES privs
;
4439 int restore_privs
= 0;
4454 path
= map_w32_filename (name
, NULL
);
4456 if (strlen (path
) > MAX_PATH
)
4458 errno
= ENAMETOOLONG
;
4463 if (is_windows_9x () == TRUE
4464 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4465 || !is_symlink (path
))
4468 errno
= EINVAL
; /* not a symlink */
4472 /* Done with simple tests, now we're in for some _real_ work. */
4473 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4475 /* Implementation note: From here and onward, don't return early,
4476 since that will fail to restore the original set of privileges of
4477 the calling thread. */
4479 retval
= -1; /* not too optimistic, are we? */
4481 /* Note: In the next call to CreateFile, we use zero as the 2nd
4482 argument because, when the symlink is a hidden/system file,
4483 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4484 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4485 and directory symlinks. */
4486 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4487 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4489 if (sh
!= INVALID_HANDLE_VALUE
)
4491 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4492 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4495 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4496 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4499 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4503 /* Copy the link target name, in wide characters, from
4504 reparse_data, then convert it to multibyte encoding in
4505 the current locale's codepage. */
4507 BYTE lname
[MAX_PATH
];
4510 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4512 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4513 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4515 /* According to MSDN, PrintNameLength does not include the
4516 terminating null character. */
4517 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4518 memcpy (lwname
, lwname_src
, lwname_len
);
4519 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4521 /* FIXME: Should we use the current file-name coding system
4522 instead of the fixed value of the ANSI codepage? */
4523 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4524 lname
, MAX_PATH
, NULL
, NULL
);
4527 /* WideCharToMultiByte failed. */
4528 DWORD w32err1
= GetLastError ();
4532 case ERROR_INSUFFICIENT_BUFFER
:
4533 errno
= ENAMETOOLONG
;
4535 case ERROR_INVALID_PARAMETER
:
4538 case ERROR_NO_UNICODE_TRANSLATION
:
4548 size_t size_to_copy
= buf_size
;
4550 BYTE
*pend
= p
+ lname_len
;
4552 /* Normalize like dostounix_filename does, but we don't
4553 want to assume that lname is null-terminated. */
4554 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4562 /* Testing for null-terminated LNAME is paranoia:
4563 WideCharToMultiByte should always return a
4564 null-terminated string when its 4th argument is -1
4565 and its 3rd argument is null-terminated (which they
4567 if (lname
[lname_len
- 1] == '\0')
4569 if (lname_len
<= buf_size
)
4570 size_to_copy
= lname_len
;
4571 strncpy (buf
, lname
, size_to_copy
);
4573 retval
= size_to_copy
;
4580 /* CreateFile failed. */
4581 DWORD w32err2
= GetLastError ();
4585 case ERROR_FILE_NOT_FOUND
:
4586 case ERROR_PATH_NOT_FOUND
:
4589 case ERROR_ACCESS_DENIED
:
4590 case ERROR_TOO_MANY_OPEN_FILES
:
4600 restore_privilege (&privs
);
4607 /* If FILE is a symlink, return its target (stored in a static
4608 buffer); otherwise return FILE.
4610 This function repeatedly resolves symlinks in the last component of
4611 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4612 until it arrives at a file whose last component is not a symlink,
4613 or some error occurs. It returns the target of the last
4614 successfully resolved symlink in the chain. If it succeeds to
4615 resolve even a single symlink, the value returned is an absolute
4616 file name with backslashes (result of GetFullPathName). By
4617 contrast, if the original FILE is returned, it is unaltered.
4619 Note: This function can set errno even if it succeeds.
4621 Implementation note: we only resolve the last portion ("basename")
4622 of the argument FILE and of each following file in the chain,
4623 disregarding any possible symlinks in its leading directories.
4624 This is because Windows system calls and library functions
4625 transparently resolve symlinks in leading directories and return
4626 correct information, as long as the basename is not a symlink. */
4628 chase_symlinks (const char *file
)
4630 static char target
[MAX_PATH
];
4631 char link
[MAX_PATH
];
4632 ssize_t res
, link_len
;
4635 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4636 return (char *)file
;
4638 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4639 return (char *)file
;
4644 /* Remove trailing slashes, as we want to resolve the last
4645 non-trivial part of the link name. */
4646 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4647 link
[link_len
--] = '\0';
4649 res
= readlink (link
, target
, MAX_PATH
);
4653 if (!(IS_DEVICE_SEP (target
[1])
4654 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4656 /* Target is relative. Append it to the directory part of
4657 the symlink, then copy the result back to target. */
4658 char *p
= link
+ link_len
;
4660 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4663 strcpy (target
, link
);
4665 /* Resolve any "." and ".." to get a fully-qualified file name
4667 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4669 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4671 if (loop_count
> 100)
4674 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4675 return (char *)file
;
4680 /* Posix ACL emulation. */
4683 acl_valid (acl_t acl
)
4685 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
4689 acl_to_text (acl_t acl
, ssize_t
*size
)
4692 SECURITY_INFORMATION flags
=
4693 OWNER_SECURITY_INFORMATION
|
4694 GROUP_SECURITY_INFORMATION
|
4695 DACL_SECURITY_INFORMATION
;
4696 char *retval
= NULL
;
4702 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
4705 /* We don't want to mix heaps, so we duplicate the string in our
4706 heap and free the one allocated by the API. */
4707 retval
= xstrdup (str_acl
);
4710 LocalFree (str_acl
);
4712 else if (errno
!= ENOTSUP
)
4719 acl_from_text (const char *acl_str
)
4721 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
4727 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
4730 retval
= xmalloc (sd_size
);
4731 memcpy (retval
, psd
, sd_size
);
4734 else if (errno
!= ENOTSUP
)
4741 acl_free (void *ptr
)
4748 acl_get_file (const char *fname
, acl_type_t type
)
4750 PSECURITY_DESCRIPTOR psd
= NULL
;
4751 const char *filename
;
4753 if (type
== ACL_TYPE_ACCESS
)
4756 SECURITY_INFORMATION si
=
4757 OWNER_SECURITY_INFORMATION
|
4758 GROUP_SECURITY_INFORMATION
|
4759 DACL_SECURITY_INFORMATION
;
4762 filename
= map_w32_filename (fname
, NULL
);
4763 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4764 fname
= chase_symlinks (filename
);
4769 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
4770 && errno
!= ENOTSUP
)
4772 err
= GetLastError ();
4773 if (err
== ERROR_INSUFFICIENT_BUFFER
)
4775 psd
= xmalloc (sd_len
);
4776 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4783 else if (err
== ERROR_FILE_NOT_FOUND
4784 || err
== ERROR_PATH_NOT_FOUND
)
4792 else if (type
!= ACL_TYPE_DEFAULT
)
4799 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
4801 TOKEN_PRIVILEGES old1
, old2
;
4804 int st
= 0, retval
= -1;
4805 SECURITY_INFORMATION flags
= 0;
4811 const char *filename
;
4813 if (acl_valid (acl
) != 0
4814 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
4820 if (type
== ACL_TYPE_DEFAULT
)
4826 filename
= map_w32_filename (fname
, NULL
);
4827 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4828 fname
= chase_symlinks (filename
);
4832 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
4834 flags
|= OWNER_SECURITY_INFORMATION
;
4835 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
4837 flags
|= GROUP_SECURITY_INFORMATION
;
4838 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
4841 flags
|= DACL_SECURITY_INFORMATION
;
4845 /* According to KB-245153, setting the owner will succeed if either:
4846 (1) the caller is the user who will be the new owner, and has the
4847 SE_TAKE_OWNERSHIP privilege, or
4848 (2) the caller has the SE_RESTORE privilege, in which case she can
4849 set any valid user or group as the owner
4851 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
4852 privileges, and disregard any failures in obtaining them. If
4853 these privileges cannot be obtained, and do not already exist in
4854 the calling thread's security token, this function could fail
4856 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
4858 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
4863 set_file_security ((char *)fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
);
4864 err
= GetLastError ();
4868 restore_privilege (&old2
);
4869 restore_privilege (&old1
);
4873 if (errno
== ENOTSUP
)
4875 else if (err
== ERROR_SUCCESS
)
4880 else if (err
== ERROR_INVALID_OWNER
|| err
== ERROR_NOT_ALL_ASSIGNED
)
4882 /* Maybe the requested ACL and the one the file already has are
4883 identical, in which case we can silently ignore the
4884 failure. (And no, Windows doesn't.) */
4885 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
4890 char *acl_from
= acl_to_text (current_acl
, NULL
);
4891 char *acl_to
= acl_to_text (acl
, NULL
);
4893 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
4899 acl_free (acl_from
);
4902 acl_free (current_acl
);
4905 else if (err
== ERROR_FILE_NOT_FOUND
|| err
== ERROR_PATH_NOT_FOUND
)
4912 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4913 have a fixed max size for file names, so we don't need the kind of
4914 alloc/malloc/realloc dance the gnulib version does. We also don't
4915 support FD-relative symlinks. */
4917 careadlinkat (int fd
, char const *filename
,
4918 char *buffer
, size_t buffer_size
,
4919 struct allocator
const *alloc
,
4920 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4922 char linkname
[MAX_PATH
];
4931 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4935 char *retval
= buffer
;
4937 linkname
[link_size
++] = '\0';
4938 if (link_size
> buffer_size
)
4939 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4941 memcpy (retval
, linkname
, link_size
);
4949 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4953 return readlink (filename
, buffer
, buffer_size
);
4957 /* Support for browsing other processes and their attributes. See
4958 process.c for the Lisp bindings. */
4960 /* Helper wrapper functions. */
4962 static HANDLE WINAPI
4963 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4965 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4967 if (g_b_init_create_toolhelp32_snapshot
== 0)
4969 g_b_init_create_toolhelp32_snapshot
= 1;
4970 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4971 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4972 "CreateToolhelp32Snapshot");
4974 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4976 return INVALID_HANDLE_VALUE
;
4978 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4982 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4984 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4986 if (g_b_init_process32_first
== 0)
4988 g_b_init_process32_first
= 1;
4989 s_pfn_Process32_First
= (Process32First_Proc
)
4990 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4993 if (s_pfn_Process32_First
== NULL
)
4997 return (s_pfn_Process32_First (hSnapshot
, lppe
));
5001 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5003 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
5005 if (g_b_init_process32_next
== 0)
5007 g_b_init_process32_next
= 1;
5008 s_pfn_Process32_Next
= (Process32Next_Proc
)
5009 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5012 if (s_pfn_Process32_Next
== NULL
)
5016 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
5020 open_thread_token (HANDLE ThreadHandle
,
5021 DWORD DesiredAccess
,
5023 PHANDLE TokenHandle
)
5025 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
5026 HMODULE hm_advapi32
= NULL
;
5027 if (is_windows_9x () == TRUE
)
5029 SetLastError (ERROR_NOT_SUPPORTED
);
5032 if (g_b_init_open_thread_token
== 0)
5034 g_b_init_open_thread_token
= 1;
5035 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5036 s_pfn_Open_Thread_Token
=
5037 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
5039 if (s_pfn_Open_Thread_Token
== NULL
)
5041 SetLastError (ERROR_NOT_SUPPORTED
);
5045 s_pfn_Open_Thread_Token (
5054 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
5056 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
5057 HMODULE hm_advapi32
= NULL
;
5058 if (is_windows_9x () == TRUE
)
5062 if (g_b_init_impersonate_self
== 0)
5064 g_b_init_impersonate_self
= 1;
5065 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5066 s_pfn_Impersonate_Self
=
5067 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
5069 if (s_pfn_Impersonate_Self
== NULL
)
5073 return s_pfn_Impersonate_Self (ImpersonationLevel
);
5077 revert_to_self (void)
5079 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
5080 HMODULE hm_advapi32
= NULL
;
5081 if (is_windows_9x () == TRUE
)
5085 if (g_b_init_revert_to_self
== 0)
5087 g_b_init_revert_to_self
= 1;
5088 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5089 s_pfn_Revert_To_Self
=
5090 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
5092 if (s_pfn_Revert_To_Self
== NULL
)
5096 return s_pfn_Revert_To_Self ();
5100 get_process_memory_info (HANDLE h_proc
,
5101 PPROCESS_MEMORY_COUNTERS mem_counters
,
5104 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
5105 HMODULE hm_psapi
= NULL
;
5106 if (is_windows_9x () == TRUE
)
5110 if (g_b_init_get_process_memory_info
== 0)
5112 g_b_init_get_process_memory_info
= 1;
5113 hm_psapi
= LoadLibrary ("Psapi.dll");
5115 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
5116 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
5118 if (s_pfn_Get_Process_Memory_Info
== NULL
)
5122 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
5126 get_process_working_set_size (HANDLE h_proc
,
5130 static GetProcessWorkingSetSize_Proc
5131 s_pfn_Get_Process_Working_Set_Size
= NULL
;
5133 if (is_windows_9x () == TRUE
)
5137 if (g_b_init_get_process_working_set_size
== 0)
5139 g_b_init_get_process_working_set_size
= 1;
5140 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
5141 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5142 "GetProcessWorkingSetSize");
5144 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
5148 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
5152 global_memory_status (MEMORYSTATUS
*buf
)
5154 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
5156 if (is_windows_9x () == TRUE
)
5160 if (g_b_init_global_memory_status
== 0)
5162 g_b_init_global_memory_status
= 1;
5163 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
5164 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5165 "GlobalMemoryStatus");
5167 if (s_pfn_Global_Memory_Status
== NULL
)
5171 return s_pfn_Global_Memory_Status (buf
);
5175 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
5177 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
5179 if (is_windows_9x () == TRUE
)
5183 if (g_b_init_global_memory_status_ex
== 0)
5185 g_b_init_global_memory_status_ex
= 1;
5186 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
5187 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5188 "GlobalMemoryStatusEx");
5190 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
5194 return s_pfn_Global_Memory_Status_Ex (buf
);
5198 list_system_processes (void)
5200 struct gcpro gcpro1
;
5201 Lisp_Object proclist
= Qnil
;
5204 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5206 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5208 PROCESSENTRY32 proc_entry
;
5214 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
5215 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
5216 res
= process32_next (h_snapshot
, &proc_entry
))
5218 proc_id
= proc_entry
.th32ProcessID
;
5219 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
5222 CloseHandle (h_snapshot
);
5224 proclist
= Fnreverse (proclist
);
5231 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
5233 TOKEN_PRIVILEGES priv
;
5234 DWORD priv_size
= sizeof (priv
);
5235 DWORD opriv_size
= sizeof (*old_priv
);
5236 HANDLE h_token
= NULL
;
5237 HANDLE h_thread
= GetCurrentThread ();
5241 res
= open_thread_token (h_thread
,
5242 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5244 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
5246 if (impersonate_self (SecurityImpersonation
))
5247 res
= open_thread_token (h_thread
,
5248 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5253 priv
.PrivilegeCount
= 1;
5254 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
5255 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
5256 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
5257 old_priv
, &opriv_size
)
5258 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5262 CloseHandle (h_token
);
5268 restore_privilege (TOKEN_PRIVILEGES
*priv
)
5270 DWORD priv_size
= sizeof (*priv
);
5271 HANDLE h_token
= NULL
;
5274 if (open_thread_token (GetCurrentThread (),
5275 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5278 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
5279 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5283 CloseHandle (h_token
);
5289 ltime (ULONGLONG time_100ns
)
5291 ULONGLONG time_sec
= time_100ns
/ 10000000;
5292 int subsec
= time_100ns
% 10000000;
5293 return list4 (make_number (time_sec
>> 16),
5294 make_number (time_sec
& 0xffff),
5295 make_number (subsec
/ 10),
5296 make_number (subsec
% 10 * 100000));
5299 #define U64_TO_LISP_TIME(time) ltime (time)
5302 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
5303 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
5306 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
5307 ULONGLONG tem1
, tem2
, tem3
, tem
;
5310 || !get_process_times_fn
5311 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
5312 &ft_kernel
, &ft_user
))
5315 GetSystemTimeAsFileTime (&ft_current
);
5317 FILETIME_TO_U64 (tem1
, ft_kernel
);
5318 *stime
= U64_TO_LISP_TIME (tem1
);
5320 FILETIME_TO_U64 (tem2
, ft_user
);
5321 *utime
= U64_TO_LISP_TIME (tem2
);
5324 *ttime
= U64_TO_LISP_TIME (tem3
);
5326 FILETIME_TO_U64 (tem
, ft_creation
);
5327 /* Process no 4 (System) returns zero creation time. */
5330 *ctime
= U64_TO_LISP_TIME (tem
);
5334 FILETIME_TO_U64 (tem3
, ft_current
);
5335 tem
= (tem3
- utc_base
) - tem
;
5337 *etime
= U64_TO_LISP_TIME (tem
);
5341 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
5352 system_process_attributes (Lisp_Object pid
)
5354 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5355 Lisp_Object attrs
= Qnil
;
5356 Lisp_Object cmd_str
, decoded_cmd
, tem
;
5357 HANDLE h_snapshot
, h_proc
;
5360 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
5361 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
5362 DWORD glength
= sizeof (gname
);
5363 HANDLE token
= NULL
;
5364 SID_NAME_USE user_type
;
5365 unsigned char *buf
= NULL
;
5367 TOKEN_USER user_token
;
5368 TOKEN_PRIMARY_GROUP group_token
;
5371 PROCESS_MEMORY_COUNTERS mem
;
5372 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
5373 SIZE_T minrss
, maxrss
;
5375 MEMORY_STATUS_EX memstex
;
5376 double totphys
= 0.0;
5377 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
5379 BOOL result
= FALSE
;
5381 CHECK_NUMBER_OR_FLOAT (pid
);
5382 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
5384 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5386 GCPRO3 (attrs
, decoded_cmd
, tem
);
5388 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5393 pe
.dwSize
= sizeof (PROCESSENTRY32
);
5394 for (res
= process32_first (h_snapshot
, &pe
); res
;
5395 res
= process32_next (h_snapshot
, &pe
))
5397 if (proc_id
== pe
.th32ProcessID
)
5400 decoded_cmd
= build_string ("Idle");
5403 /* Decode the command name from locale-specific
5405 cmd_str
= make_unibyte_string (pe
.szExeFile
,
5406 strlen (pe
.szExeFile
));
5408 code_convert_string_norecord (cmd_str
,
5409 Vlocale_coding_system
, 0);
5411 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
5412 attrs
= Fcons (Fcons (Qppid
,
5413 make_fixnum_or_float (pe
.th32ParentProcessID
)),
5415 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
5417 attrs
= Fcons (Fcons (Qthcount
,
5418 make_fixnum_or_float (pe
.cntThreads
)),
5425 CloseHandle (h_snapshot
);
5434 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5436 /* If we were denied a handle to the process, try again after
5437 enabling the SeDebugPrivilege in our process. */
5440 TOKEN_PRIVILEGES priv_current
;
5442 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
5444 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5446 restore_privilege (&priv_current
);
5452 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
5455 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
5456 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5458 buf
= xmalloc (blen
);
5459 result
= get_token_information (token
, TokenUser
,
5460 (LPVOID
)buf
, blen
, &needed
);
5463 memcpy (&user_token
, buf
, sizeof (user_token
));
5464 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
5466 euid
= get_rid (user_token
.User
.Sid
);
5467 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
5472 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
5475 strcpy (uname
, "unknown");
5479 ulength
= strlen (uname
);
5485 /* Determine a reasonable euid and gid values. */
5486 if (xstrcasecmp ("administrator", uname
) == 0)
5488 euid
= 500; /* well-known Administrator uid */
5489 egid
= 513; /* well-known None gid */
5493 /* Get group id and name. */
5494 result
= get_token_information (token
, TokenPrimaryGroup
,
5495 (LPVOID
)buf
, blen
, &needed
);
5496 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5498 buf
= xrealloc (buf
, blen
= needed
);
5499 result
= get_token_information (token
, TokenPrimaryGroup
,
5500 (LPVOID
)buf
, blen
, &needed
);
5504 memcpy (&group_token
, buf
, sizeof (group_token
));
5505 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5507 egid
= get_rid (group_token
.PrimaryGroup
);
5508 dlength
= sizeof (domain
);
5510 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5511 gname
, &glength
, NULL
, &dlength
,
5514 w32_add_to_cache (group_token
.PrimaryGroup
,
5518 strcpy (gname
, "None");
5522 glength
= strlen (gname
);
5530 if (!is_windows_9x ())
5532 /* We couldn't open the process token, presumably because of
5533 insufficient access rights. Assume this process is run
5535 strcpy (uname
, "SYSTEM");
5536 strcpy (gname
, "None");
5537 euid
= 18; /* SYSTEM */
5538 egid
= 513; /* None */
5539 glength
= strlen (gname
);
5540 ulength
= strlen (uname
);
5542 /* If we are running under Windows 9X, where security calls are
5543 not supported, we assume all processes are run by the current
5545 else if (GetUserName (uname
, &ulength
))
5547 if (xstrcasecmp ("administrator", uname
) == 0)
5552 strcpy (gname
, "None");
5553 glength
= strlen (gname
);
5554 ulength
= strlen (uname
);
5560 strcpy (uname
, "administrator");
5561 ulength
= strlen (uname
);
5562 strcpy (gname
, "None");
5563 glength
= strlen (gname
);
5566 CloseHandle (token
);
5569 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5570 tem
= make_unibyte_string (uname
, ulength
);
5571 attrs
= Fcons (Fcons (Quser
,
5572 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5574 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5575 tem
= make_unibyte_string (gname
, glength
);
5576 attrs
= Fcons (Fcons (Qgroup
,
5577 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5580 if (global_memory_status_ex (&memstex
))
5581 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5582 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5584 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5585 double, so we need to do this for it... */
5587 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5588 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5589 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5591 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5593 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5594 else if (global_memory_status (&memst
))
5595 totphys
= memst
.dwTotalPhys
/ 1024.0;
5598 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5601 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5603 attrs
= Fcons (Fcons (Qmajflt
,
5604 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5606 attrs
= Fcons (Fcons (Qvsize
,
5607 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5609 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5611 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5614 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5616 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5618 attrs
= Fcons (Fcons (Qmajflt
,
5619 make_fixnum_or_float (mem
.PageFaultCount
)),
5621 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5623 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5626 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5628 DWORD rss
= maxrss
/ 1024;
5630 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5632 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5635 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5637 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5638 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5639 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5640 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5641 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5642 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5645 /* FIXME: Retrieve command line by walking the PEB of the process. */
5648 CloseHandle (h_proc
);
5654 /* Wrappers for winsock functions to map between our file descriptors
5655 and winsock's handles; also set h_errno for convenience.
5657 To allow Emacs to run on systems which don't have winsock support
5658 installed, we dynamically link to winsock on startup if present, and
5659 otherwise provide the minimum necessary functionality
5660 (eg. gethostname). */
5662 /* function pointers for relevant socket functions */
5663 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5664 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5665 int (PASCAL
*pfn_WSAGetLastError
) (void);
5666 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5667 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5668 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5669 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5670 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5671 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5672 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5673 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5674 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5675 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5676 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5677 int (PASCAL
*pfn_WSACleanup
) (void);
5679 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5680 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5681 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5682 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5683 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5684 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5685 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5686 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5687 const char * optval
, int optlen
);
5688 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5689 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5691 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5692 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5693 struct sockaddr
* from
, int * fromlen
);
5694 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5695 const struct sockaddr
* to
, int tolen
);
5697 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5698 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5699 #ifndef HANDLE_FLAG_INHERIT
5700 #define HANDLE_FLAG_INHERIT 1
5704 static int winsock_inuse
;
5709 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5711 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5712 after WSAStartup returns successfully, but it seems reasonable
5713 to allow unloading winsock anyway in that case. */
5714 if (pfn_WSACleanup () == 0 ||
5715 pfn_WSAGetLastError () == WSAENETDOWN
)
5717 if (FreeLibrary (winsock_lib
))
5726 init_winsock (int load_now
)
5728 WSADATA winsockData
;
5730 if (winsock_lib
!= NULL
)
5733 pfn_SetHandleInformation
5734 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5735 "SetHandleInformation");
5737 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5739 if (winsock_lib
!= NULL
)
5741 /* dynamically link to socket functions */
5743 #define LOAD_PROC(fn) \
5744 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5747 LOAD_PROC (WSAStartup
);
5748 LOAD_PROC (WSASetLastError
);
5749 LOAD_PROC (WSAGetLastError
);
5750 LOAD_PROC (WSAEventSelect
);
5751 LOAD_PROC (WSACreateEvent
);
5752 LOAD_PROC (WSACloseEvent
);
5755 LOAD_PROC (connect
);
5756 LOAD_PROC (ioctlsocket
);
5759 LOAD_PROC (closesocket
);
5760 LOAD_PROC (shutdown
);
5763 LOAD_PROC (inet_addr
);
5764 LOAD_PROC (gethostname
);
5765 LOAD_PROC (gethostbyname
);
5766 LOAD_PROC (getservbyname
);
5767 LOAD_PROC (getpeername
);
5768 LOAD_PROC (WSACleanup
);
5769 LOAD_PROC (setsockopt
);
5771 LOAD_PROC (getsockname
);
5773 LOAD_PROC (recvfrom
);
5777 /* specify version 1.1 of winsock */
5778 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5780 if (winsockData
.wVersion
!= 0x101)
5785 /* Report that winsock exists and is usable, but leave
5786 socket functions disabled. I am assuming that calling
5787 WSAStartup does not require any network interaction,
5788 and in particular does not cause or require a dial-up
5789 connection to be established. */
5792 FreeLibrary (winsock_lib
);
5800 FreeLibrary (winsock_lib
);
5810 /* function to set h_errno for compatibility; map winsock error codes to
5811 normal system codes where they overlap (non-overlapping definitions
5812 are already in <sys/socket.h> */
5816 if (winsock_lib
== NULL
)
5819 h_errno
= pfn_WSAGetLastError ();
5823 case WSAEACCES
: h_errno
= EACCES
; break;
5824 case WSAEBADF
: h_errno
= EBADF
; break;
5825 case WSAEFAULT
: h_errno
= EFAULT
; break;
5826 case WSAEINTR
: h_errno
= EINTR
; break;
5827 case WSAEINVAL
: h_errno
= EINVAL
; break;
5828 case WSAEMFILE
: h_errno
= EMFILE
; break;
5829 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5830 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5838 if (h_errno
== 0 && winsock_lib
!= NULL
)
5839 pfn_WSASetLastError (0);
5842 /* Extend strerror to handle the winsock-specific error codes. */
5846 } _wsa_errlist
[] = {
5847 {WSAEINTR
, "Interrupted function call"},
5848 {WSAEBADF
, "Bad file descriptor"},
5849 {WSAEACCES
, "Permission denied"},
5850 {WSAEFAULT
, "Bad address"},
5851 {WSAEINVAL
, "Invalid argument"},
5852 {WSAEMFILE
, "Too many open files"},
5854 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5855 {WSAEINPROGRESS
, "Operation now in progress"},
5856 {WSAEALREADY
, "Operation already in progress"},
5857 {WSAENOTSOCK
, "Socket operation on non-socket"},
5858 {WSAEDESTADDRREQ
, "Destination address required"},
5859 {WSAEMSGSIZE
, "Message too long"},
5860 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5861 {WSAENOPROTOOPT
, "Bad protocol option"},
5862 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5863 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5864 {WSAEOPNOTSUPP
, "Operation not supported"},
5865 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5866 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5867 {WSAEADDRINUSE
, "Address already in use"},
5868 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5869 {WSAENETDOWN
, "Network is down"},
5870 {WSAENETUNREACH
, "Network is unreachable"},
5871 {WSAENETRESET
, "Network dropped connection on reset"},
5872 {WSAECONNABORTED
, "Software caused connection abort"},
5873 {WSAECONNRESET
, "Connection reset by peer"},
5874 {WSAENOBUFS
, "No buffer space available"},
5875 {WSAEISCONN
, "Socket is already connected"},
5876 {WSAENOTCONN
, "Socket is not connected"},
5877 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5878 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5879 {WSAETIMEDOUT
, "Connection timed out"},
5880 {WSAECONNREFUSED
, "Connection refused"},
5881 {WSAELOOP
, "Network loop"}, /* not sure */
5882 {WSAENAMETOOLONG
, "Name is too long"},
5883 {WSAEHOSTDOWN
, "Host is down"},
5884 {WSAEHOSTUNREACH
, "No route to host"},
5885 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5886 {WSAEPROCLIM
, "Too many processes"},
5887 {WSAEUSERS
, "Too many users"}, /* not sure */
5888 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5889 {WSAESTALE
, "Data is stale"}, /* not sure */
5890 {WSAEREMOTE
, "Remote error"}, /* not sure */
5892 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5893 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5894 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5895 {WSAEDISCON
, "Graceful shutdown in progress"},
5897 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5898 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5899 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5900 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5901 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5902 {WSASYSCALLFAILURE
, "System call failure"},
5903 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5904 {WSATYPE_NOT_FOUND
, "Class type not found"},
5905 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5906 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5907 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5910 {WSAHOST_NOT_FOUND
, "Host not found"},
5911 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5912 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5913 {WSANO_DATA
, "Valid name, no data record of requested type"},
5919 sys_strerror (int error_no
)
5922 static char unknown_msg
[40];
5924 if (error_no
>= 0 && error_no
< sys_nerr
)
5925 return sys_errlist
[error_no
];
5927 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5928 if (_wsa_errlist
[i
].errnum
== error_no
)
5929 return _wsa_errlist
[i
].msg
;
5931 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5935 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5936 but I believe the method of keeping the socket handle separate (and
5937 insuring it is not inheritable) is the correct one. */
5939 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5941 static int socket_to_fd (SOCKET s
);
5944 sys_socket (int af
, int type
, int protocol
)
5948 if (winsock_lib
== NULL
)
5951 return INVALID_SOCKET
;
5956 /* call the real socket function */
5957 s
= pfn_socket (af
, type
, protocol
);
5959 if (s
!= INVALID_SOCKET
)
5960 return socket_to_fd (s
);
5966 /* Convert a SOCKET to a file descriptor. */
5968 socket_to_fd (SOCKET s
)
5973 /* Although under NT 3.5 _open_osfhandle will accept a socket
5974 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5975 that does not work under NT 3.1. However, we can get the same
5976 effect by using a backdoor function to replace an existing
5977 descriptor handle with the one we want. */
5979 /* allocate a file descriptor (with appropriate flags) */
5980 fd
= _open ("NUL:", _O_RDWR
);
5983 /* Make a non-inheritable copy of the socket handle. Note
5984 that it is possible that sockets aren't actually kernel
5985 handles, which appears to be the case on Windows 9x when
5986 the MS Proxy winsock client is installed. */
5988 /* Apparently there is a bug in NT 3.51 with some service
5989 packs, which prevents using DuplicateHandle to make a
5990 socket handle non-inheritable (causes WSACleanup to
5991 hang). The work-around is to use SetHandleInformation
5992 instead if it is available and implemented. */
5993 if (pfn_SetHandleInformation
)
5995 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5999 HANDLE parent
= GetCurrentProcess ();
6000 HANDLE new_s
= INVALID_HANDLE_VALUE
;
6002 if (DuplicateHandle (parent
,
6008 DUPLICATE_SAME_ACCESS
))
6010 /* It is possible that DuplicateHandle succeeds even
6011 though the socket wasn't really a kernel handle,
6012 because a real handle has the same value. So
6013 test whether the new handle really is a socket. */
6014 long nonblocking
= 0;
6015 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
6017 pfn_closesocket (s
);
6022 CloseHandle (new_s
);
6027 fd_info
[fd
].hnd
= (HANDLE
) s
;
6029 /* set our own internal flags */
6030 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
6036 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6038 /* attach child_process to fd_info */
6039 if (fd_info
[ fd
].cp
!= NULL
)
6041 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
6045 fd_info
[ fd
].cp
= cp
;
6048 winsock_inuse
++; /* count open sockets */
6055 pfn_closesocket (s
);
6061 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
6063 if (winsock_lib
== NULL
)
6066 return SOCKET_ERROR
;
6070 if (fd_info
[s
].flags
& FILE_SOCKET
)
6072 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
6073 if (rc
== SOCKET_ERROR
)
6078 return SOCKET_ERROR
;
6082 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
6084 if (winsock_lib
== NULL
)
6087 return SOCKET_ERROR
;
6091 if (fd_info
[s
].flags
& FILE_SOCKET
)
6093 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
6094 if (rc
== SOCKET_ERROR
)
6099 return SOCKET_ERROR
;
6103 sys_htons (u_short hostshort
)
6105 return (winsock_lib
!= NULL
) ?
6106 pfn_htons (hostshort
) : hostshort
;
6110 sys_ntohs (u_short netshort
)
6112 return (winsock_lib
!= NULL
) ?
6113 pfn_ntohs (netshort
) : netshort
;
6117 sys_inet_addr (const char * cp
)
6119 return (winsock_lib
!= NULL
) ?
6120 pfn_inet_addr (cp
) : INADDR_NONE
;
6124 sys_gethostname (char * name
, int namelen
)
6126 if (winsock_lib
!= NULL
)
6127 return pfn_gethostname (name
, namelen
);
6129 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
6130 return !GetComputerName (name
, (DWORD
*)&namelen
);
6133 return SOCKET_ERROR
;
6137 sys_gethostbyname (const char * name
)
6139 struct hostent
* host
;
6141 if (winsock_lib
== NULL
)
6148 host
= pfn_gethostbyname (name
);
6155 sys_getservbyname (const char * name
, const char * proto
)
6157 struct servent
* serv
;
6159 if (winsock_lib
== NULL
)
6166 serv
= pfn_getservbyname (name
, proto
);
6173 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
6175 if (winsock_lib
== NULL
)
6178 return SOCKET_ERROR
;
6182 if (fd_info
[s
].flags
& FILE_SOCKET
)
6184 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
6185 if (rc
== SOCKET_ERROR
)
6190 return SOCKET_ERROR
;
6194 sys_shutdown (int s
, int how
)
6196 if (winsock_lib
== NULL
)
6199 return SOCKET_ERROR
;
6203 if (fd_info
[s
].flags
& FILE_SOCKET
)
6205 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
6206 if (rc
== SOCKET_ERROR
)
6211 return SOCKET_ERROR
;
6215 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
6217 if (winsock_lib
== NULL
)
6220 return SOCKET_ERROR
;
6224 if (fd_info
[s
].flags
& FILE_SOCKET
)
6226 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
6227 (const char *)optval
, optlen
);
6228 if (rc
== SOCKET_ERROR
)
6233 return SOCKET_ERROR
;
6237 sys_listen (int s
, int backlog
)
6239 if (winsock_lib
== NULL
)
6242 return SOCKET_ERROR
;
6246 if (fd_info
[s
].flags
& FILE_SOCKET
)
6248 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
6249 if (rc
== SOCKET_ERROR
)
6252 fd_info
[s
].flags
|= FILE_LISTEN
;
6256 return SOCKET_ERROR
;
6260 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
6262 if (winsock_lib
== NULL
)
6265 return SOCKET_ERROR
;
6269 if (fd_info
[s
].flags
& FILE_SOCKET
)
6271 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
6272 if (rc
== SOCKET_ERROR
)
6277 return SOCKET_ERROR
;
6281 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
6283 if (winsock_lib
== NULL
)
6290 if (fd_info
[s
].flags
& FILE_LISTEN
)
6292 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
6294 if (t
== INVALID_SOCKET
)
6297 fd
= socket_to_fd (t
);
6299 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6300 ResetEvent (fd_info
[s
].cp
->char_avail
);
6308 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
6309 struct sockaddr
* from
, int * fromlen
)
6311 if (winsock_lib
== NULL
)
6314 return SOCKET_ERROR
;
6318 if (fd_info
[s
].flags
& FILE_SOCKET
)
6320 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
6321 if (rc
== SOCKET_ERROR
)
6326 return SOCKET_ERROR
;
6330 sys_sendto (int s
, const char * buf
, int len
, int flags
,
6331 const struct sockaddr
* to
, int tolen
)
6333 if (winsock_lib
== NULL
)
6336 return SOCKET_ERROR
;
6340 if (fd_info
[s
].flags
& FILE_SOCKET
)
6342 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
6343 if (rc
== SOCKET_ERROR
)
6348 return SOCKET_ERROR
;
6351 /* Windows does not have an fcntl function. Provide an implementation
6352 solely for making sockets non-blocking. */
6354 fcntl (int s
, int cmd
, int options
)
6356 if (winsock_lib
== NULL
)
6363 if (fd_info
[s
].flags
& FILE_SOCKET
)
6365 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
6367 unsigned long nblock
= 1;
6368 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
6369 if (rc
== SOCKET_ERROR
)
6371 /* Keep track of the fact that we set this to non-blocking. */
6372 fd_info
[s
].flags
|= FILE_NDELAY
;
6378 return SOCKET_ERROR
;
6382 return SOCKET_ERROR
;
6386 /* Shadow main io functions: we need to handle pipes and sockets more
6387 intelligently, and implement non-blocking mode as well. */
6400 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
6402 child_process
* cp
= fd_info
[fd
].cp
;
6404 fd_info
[fd
].cp
= NULL
;
6406 if (CHILD_ACTIVE (cp
))
6408 /* if last descriptor to active child_process then cleanup */
6410 for (i
= 0; i
< MAXDESC
; i
++)
6414 if (fd_info
[i
].cp
== cp
)
6419 if (fd_info
[fd
].flags
& FILE_SOCKET
)
6421 if (winsock_lib
== NULL
) emacs_abort ();
6423 pfn_shutdown (SOCK_HANDLE (fd
), 2);
6424 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
6426 winsock_inuse
--; /* count open sockets */
6428 /* If the process handle is NULL, it's either a socket
6429 or serial connection, or a subprocess that was
6430 already reaped by reap_subprocess, but whose
6431 resources were not yet freed, because its output was
6432 not fully read yet by the time it was reaped. (This
6433 usually happens with async subprocesses whose output
6434 is being read by Emacs.) Otherwise, this process was
6435 not reaped yet, so we set its FD to a negative value
6436 to make sure sys_select will eventually get to
6437 calling the SIGCHLD handler for it, which will then
6438 invoke waitpid and reap_subprocess. */
6439 if (cp
->procinfo
.hProcess
== NULL
)
6447 /* Note that sockets do not need special treatment here (at least on
6448 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6449 closesocket is equivalent to CloseHandle, which is to be expected
6450 because socket handles are fully fledged kernel handles. */
6453 if (rc
== 0 && fd
< MAXDESC
)
6454 fd_info
[fd
].flags
= 0;
6465 if (new_fd
>= 0 && new_fd
< MAXDESC
)
6467 /* duplicate our internal info as well */
6468 fd_info
[new_fd
] = fd_info
[fd
];
6474 sys_dup2 (int src
, int dst
)
6478 if (dst
< 0 || dst
>= MAXDESC
)
6484 /* make sure we close the destination first if it's a pipe or socket */
6485 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
6488 rc
= _dup2 (src
, dst
);
6491 /* duplicate our internal info as well */
6492 fd_info
[dst
] = fd_info
[src
];
6497 /* Unix pipe() has only one arg */
6499 sys_pipe (int * phandles
)
6504 /* make pipe handles non-inheritable; when we spawn a child, we
6505 replace the relevant handle with an inheritable one. Also put
6506 pipes into binary mode; we will do text mode translation ourselves
6508 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
6512 /* Protect against overflow, since Windows can open more handles than
6513 our fd_info array has room for. */
6514 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
6516 _close (phandles
[0]);
6517 _close (phandles
[1]);
6522 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6523 fd_info
[phandles
[0]].flags
= flags
;
6525 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6526 fd_info
[phandles
[1]].flags
= flags
;
6533 /* Function to do blocking read of one byte, needed to implement
6534 select. It is only allowed on communication ports, sockets, or
6537 _sys_read_ahead (int fd
)
6542 if (fd
< 0 || fd
>= MAXDESC
)
6543 return STATUS_READ_ERROR
;
6545 cp
= fd_info
[fd
].cp
;
6547 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6548 return STATUS_READ_ERROR
;
6550 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6551 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6553 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6557 cp
->status
= STATUS_READ_IN_PROGRESS
;
6559 if (fd_info
[fd
].flags
& FILE_PIPE
)
6561 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6563 /* Give subprocess time to buffer some more output for us before
6564 reporting that input is available; we need this because Windows 95
6565 connects DOS programs to pipes by making the pipe appear to be
6566 the normal console stdout - as a result most DOS programs will
6567 write to stdout without buffering, ie. one character at a
6568 time. Even some W32 programs do this - "dir" in a command
6569 shell on NT is very slow if we don't do this. */
6572 int wait
= w32_pipe_read_delay
;
6578 /* Yield remainder of our time slice, effectively giving a
6579 temporary priority boost to the child process. */
6583 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6585 HANDLE hnd
= fd_info
[fd
].hnd
;
6586 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6589 /* Configure timeouts for blocking read. */
6590 if (!GetCommTimeouts (hnd
, &ct
))
6591 return STATUS_READ_ERROR
;
6592 ct
.ReadIntervalTimeout
= 0;
6593 ct
.ReadTotalTimeoutMultiplier
= 0;
6594 ct
.ReadTotalTimeoutConstant
= 0;
6595 if (!SetCommTimeouts (hnd
, &ct
))
6596 return STATUS_READ_ERROR
;
6598 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6600 if (GetLastError () != ERROR_IO_PENDING
)
6601 return STATUS_READ_ERROR
;
6602 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6603 return STATUS_READ_ERROR
;
6606 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6608 unsigned long nblock
= 0;
6609 /* We always want this to block, so temporarily disable NDELAY. */
6610 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6611 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6613 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6615 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6618 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6622 if (rc
== sizeof (char))
6623 cp
->status
= STATUS_READ_SUCCEEDED
;
6625 cp
->status
= STATUS_READ_FAILED
;
6631 _sys_wait_accept (int fd
)
6637 if (fd
< 0 || fd
>= MAXDESC
)
6638 return STATUS_READ_ERROR
;
6640 cp
= fd_info
[fd
].cp
;
6642 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6643 return STATUS_READ_ERROR
;
6645 cp
->status
= STATUS_READ_FAILED
;
6647 hEv
= pfn_WSACreateEvent ();
6648 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6649 if (rc
!= SOCKET_ERROR
)
6651 rc
= WaitForSingleObject (hEv
, INFINITE
);
6652 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6653 if (rc
== WAIT_OBJECT_0
)
6654 cp
->status
= STATUS_READ_SUCCEEDED
;
6656 pfn_WSACloseEvent (hEv
);
6662 sys_read (int fd
, char * buffer
, unsigned int count
)
6667 char * orig_buffer
= buffer
;
6675 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6677 child_process
*cp
= fd_info
[fd
].cp
;
6679 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6687 /* re-read CR carried over from last read */
6688 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6690 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6694 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6697 /* presence of a child_process structure means we are operating in
6698 non-blocking mode - otherwise we just call _read directly.
6699 Note that the child_process structure might be missing because
6700 reap_subprocess has been called; in this case the pipe is
6701 already broken, so calling _read on it is okay. */
6704 int current_status
= cp
->status
;
6706 switch (current_status
)
6708 case STATUS_READ_FAILED
:
6709 case STATUS_READ_ERROR
:
6710 /* report normal EOF if nothing in buffer */
6712 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6715 case STATUS_READ_READY
:
6716 case STATUS_READ_IN_PROGRESS
:
6717 DebPrint (("sys_read called when read is in progress\n"));
6718 errno
= EWOULDBLOCK
;
6721 case STATUS_READ_SUCCEEDED
:
6722 /* consume read-ahead char */
6723 *buffer
++ = cp
->chr
;
6726 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6727 ResetEvent (cp
->char_avail
);
6729 case STATUS_READ_ACKNOWLEDGED
:
6733 DebPrint (("sys_read: bad status %d\n", current_status
));
6738 if (fd_info
[fd
].flags
& FILE_PIPE
)
6740 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6741 to_read
= min (waiting
, (DWORD
) count
);
6744 nchars
+= _read (fd
, buffer
, to_read
);
6746 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6748 HANDLE hnd
= fd_info
[fd
].hnd
;
6749 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6755 /* Configure timeouts for non-blocking read. */
6756 if (!GetCommTimeouts (hnd
, &ct
))
6761 ct
.ReadIntervalTimeout
= MAXDWORD
;
6762 ct
.ReadTotalTimeoutMultiplier
= 0;
6763 ct
.ReadTotalTimeoutConstant
= 0;
6764 if (!SetCommTimeouts (hnd
, &ct
))
6770 if (!ResetEvent (ovl
->hEvent
))
6775 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6777 if (GetLastError () != ERROR_IO_PENDING
)
6782 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6791 else /* FILE_SOCKET */
6793 if (winsock_lib
== NULL
) emacs_abort ();
6795 /* do the equivalent of a non-blocking read */
6796 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6797 if (waiting
== 0 && nchars
== 0)
6799 h_errno
= errno
= EWOULDBLOCK
;
6805 /* always use binary mode for sockets */
6806 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6807 if (res
== SOCKET_ERROR
)
6809 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6810 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6820 int nread
= _read (fd
, buffer
, count
);
6823 else if (nchars
== 0)
6828 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6829 /* Perform text mode translation if required. */
6830 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6832 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6833 /* If buffer contains only CR, return that. To be absolutely
6834 sure we should attempt to read the next char, but in
6835 practice a CR to be followed by LF would not appear by
6836 itself in the buffer. */
6837 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6839 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6845 nchars
= _read (fd
, buffer
, count
);
6850 /* From w32xfns.c */
6851 extern HANDLE interrupt_handle
;
6853 /* For now, don't bother with a non-blocking mode */
6855 sys_write (int fd
, const void * buffer
, unsigned int count
)
6865 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6867 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6873 /* Perform text mode translation if required. */
6874 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6876 char * tmpbuf
= alloca (count
* 2);
6877 unsigned char * src
= (void *)buffer
;
6878 unsigned char * dst
= tmpbuf
;
6883 unsigned char *next
;
6884 /* copy next line or remaining bytes */
6885 next
= _memccpy (dst
, src
, '\n', nbytes
);
6888 /* copied one line ending with '\n' */
6889 int copied
= next
- dst
;
6892 /* insert '\r' before '\n' */
6899 /* copied remaining partial line -> now finished */
6906 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6908 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6909 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6910 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6913 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6915 if (GetLastError () != ERROR_IO_PENDING
)
6920 if (detect_input_pending ())
6921 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6924 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6925 if (active
== WAIT_OBJECT_0
)
6926 { /* User pressed C-g, cancel write, then leave. Don't bother
6927 cleaning up as we may only get stuck in buggy drivers. */
6928 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6933 if (active
== WAIT_OBJECT_0
+ 1
6934 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6941 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6943 unsigned long nblock
= 0;
6944 if (winsock_lib
== NULL
) emacs_abort ();
6946 /* TODO: implement select() properly so non-blocking I/O works. */
6947 /* For now, make sure the write blocks. */
6948 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6949 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6951 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6953 /* Set the socket back to non-blocking if it was before,
6954 for other operations that support it. */
6955 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6958 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6961 if (nchars
== SOCKET_ERROR
)
6963 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6964 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6970 /* Some networked filesystems don't like too large writes, so
6971 break them into smaller chunks. See the Comments section of
6972 the MSDN documentation of WriteFile for details behind the
6973 choice of the value of CHUNK below. See also the thread
6974 http://thread.gmane.org/gmane.comp.version-control.git/145294
6975 in the git mailing list. */
6976 const unsigned char *p
= buffer
;
6977 const unsigned chunk
= 30 * 1024 * 1024;
6982 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6983 int n
= _write (fd
, p
, this_chunk
);
6991 else if (n
< this_chunk
)
7001 /* The Windows CRT functions are "optimized for speed", so they don't
7002 check for timezone and DST changes if they were last called less
7003 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
7004 all Emacs features that repeatedly call time functions (e.g.,
7005 display-time) are in real danger of missing timezone and DST
7006 changes. Calling tzset before each localtime call fixes that. */
7008 sys_localtime (const time_t *t
)
7011 return localtime (t
);
7016 /* Try loading LIBRARY_ID from the file(s) specified in
7017 Vdynamic_library_alist. If the library is loaded successfully,
7018 return the handle of the DLL, and record the filename in the
7019 property :loaded-from of LIBRARY_ID. If the library could not be
7020 found, or when it was already loaded (because the handle is not
7021 recorded anywhere, and so is lost after use), return NULL.
7023 We could also save the handle in :loaded-from, but currently
7024 there's no use case for it. */
7026 w32_delayed_load (Lisp_Object library_id
)
7028 HMODULE library_dll
= NULL
;
7030 CHECK_SYMBOL (library_id
);
7032 if (CONSP (Vdynamic_library_alist
)
7033 && NILP (Fassq (library_id
, Vlibrary_cache
)))
7035 Lisp_Object found
= Qnil
;
7036 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
7039 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
7041 CHECK_STRING_CAR (dlls
);
7042 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
7044 char name
[MAX_PATH
];
7047 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
7048 found
= Fcons (XCAR (dlls
),
7050 /* Possibly truncated */
7051 ? make_specified_string (name
, -1, len
, 1)
7057 Fput (library_id
, QCloaded_from
, found
);
7065 check_windows_init_file (void)
7067 /* A common indication that Emacs is not installed properly is when
7068 it cannot find the Windows installation file. If this file does
7069 not exist in the expected place, tell the user. */
7071 if (!noninteractive
&& !inhibit_window_system
7072 /* Vload_path is not yet initialized when we are loading
7074 && NILP (Vpurify_flag
))
7076 Lisp_Object init_file
;
7079 init_file
= build_string ("term/w32-win");
7080 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
7083 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
7084 char *init_file_name
= SDATA (init_file
);
7085 char *load_path
= SDATA (load_path_print
);
7086 char *buffer
= alloca (1024
7087 + strlen (init_file_name
)
7088 + strlen (load_path
));
7091 "The Emacs Windows initialization file \"%s.el\" "
7092 "could not be found in your Emacs installation. "
7093 "Emacs checked the following directories for this file:\n"
7095 "When Emacs cannot find this file, it usually means that it "
7096 "was not installed properly, or its distribution file was "
7097 "not unpacked properly.\nSee the README.W32 file in the "
7098 "top-level Emacs directory for more information.",
7099 init_file_name
, load_path
);
7102 "Emacs Abort Dialog",
7103 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
7104 /* Use the low-level system abort. */
7115 term_ntproc (int ignored
)
7121 /* shutdown the socket interface if necessary */
7128 init_ntproc (int dumping
)
7130 sigset_t initial_mask
= 0;
7132 /* Initialize the socket interface now if available and requested by
7133 the user by defining PRELOAD_WINSOCK; otherwise loading will be
7134 delayed until open-network-stream is called (w32-has-winsock can
7135 also be used to dynamically load or reload winsock).
7137 Conveniently, init_environment is called before us, so
7138 PRELOAD_WINSOCK can be set in the registry. */
7140 /* Always initialize this correctly. */
7143 if (getenv ("PRELOAD_WINSOCK") != NULL
)
7144 init_winsock (TRUE
);
7146 /* Initial preparation for subprocess support: replace our standard
7147 handles with non-inheritable versions. */
7150 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
7151 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
7152 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
7154 parent
= GetCurrentProcess ();
7156 /* ignore errors when duplicating and closing; typically the
7157 handles will be invalid when running as a gui program. */
7158 DuplicateHandle (parent
,
7159 GetStdHandle (STD_INPUT_HANDLE
),
7164 DUPLICATE_SAME_ACCESS
);
7166 DuplicateHandle (parent
,
7167 GetStdHandle (STD_OUTPUT_HANDLE
),
7172 DUPLICATE_SAME_ACCESS
);
7174 DuplicateHandle (parent
,
7175 GetStdHandle (STD_ERROR_HANDLE
),
7180 DUPLICATE_SAME_ACCESS
);
7186 if (stdin_save
!= INVALID_HANDLE_VALUE
)
7187 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
7189 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
7192 if (stdout_save
!= INVALID_HANDLE_VALUE
)
7193 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
7195 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7198 if (stderr_save
!= INVALID_HANDLE_VALUE
)
7199 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
7201 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7205 /* unfortunately, atexit depends on implementation of malloc */
7206 /* atexit (term_ntproc); */
7209 /* Make sure we start with all signals unblocked. */
7210 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
7211 signal (SIGABRT
, term_ntproc
);
7215 /* determine which drives are fixed, for GetCachedVolumeInformation */
7217 /* GetDriveType must have trailing backslash. */
7218 char drive
[] = "A:\\";
7220 /* Loop over all possible drive letters */
7221 while (*drive
<= 'Z')
7223 /* Record if this drive letter refers to a fixed drive. */
7224 fixed_drives
[DRIVE_INDEX (*drive
)] =
7225 (GetDriveType (drive
) == DRIVE_FIXED
);
7230 /* Reset the volume info cache. */
7231 volume_cache
= NULL
;
7236 shutdown_handler ensures that buffers' autosave files are
7237 up to date when the user logs off, or the system shuts down.
7240 shutdown_handler (DWORD type
)
7242 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
7243 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
7244 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
7245 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
7247 /* Shut down cleanly, making sure autosave files are up to date. */
7248 shut_down_emacs (0, Qnil
);
7251 /* Allow other handlers to handle this signal. */
7256 globals_of_w32 is used to initialize those global variables that
7257 must always be initialized on startup even when the global variable
7258 initialized is non zero (see the function main in emacs.c).
7261 globals_of_w32 (void)
7263 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
7265 get_process_times_fn
= (GetProcessTimes_Proc
)
7266 GetProcAddress (kernel32
, "GetProcessTimes");
7268 DEFSYM (QCloaded_from
, ":loaded-from");
7270 g_b_init_is_windows_9x
= 0;
7271 g_b_init_open_process_token
= 0;
7272 g_b_init_get_token_information
= 0;
7273 g_b_init_lookup_account_sid
= 0;
7274 g_b_init_get_sid_sub_authority
= 0;
7275 g_b_init_get_sid_sub_authority_count
= 0;
7276 g_b_init_get_security_info
= 0;
7277 g_b_init_get_file_security
= 0;
7278 g_b_init_get_security_descriptor_owner
= 0;
7279 g_b_init_get_security_descriptor_group
= 0;
7280 g_b_init_is_valid_sid
= 0;
7281 g_b_init_create_toolhelp32_snapshot
= 0;
7282 g_b_init_process32_first
= 0;
7283 g_b_init_process32_next
= 0;
7284 g_b_init_open_thread_token
= 0;
7285 g_b_init_impersonate_self
= 0;
7286 g_b_init_revert_to_self
= 0;
7287 g_b_init_get_process_memory_info
= 0;
7288 g_b_init_get_process_working_set_size
= 0;
7289 g_b_init_global_memory_status
= 0;
7290 g_b_init_global_memory_status_ex
= 0;
7291 g_b_init_equal_sid
= 0;
7292 g_b_init_copy_sid
= 0;
7293 g_b_init_get_length_sid
= 0;
7294 g_b_init_get_native_system_info
= 0;
7295 g_b_init_get_system_times
= 0;
7296 g_b_init_create_symbolic_link
= 0;
7297 g_b_init_get_security_descriptor_dacl
= 0;
7298 g_b_init_convert_sd_to_sddl
= 0;
7299 g_b_init_convert_sddl_to_sd
= 0;
7300 g_b_init_is_valid_security_descriptor
= 0;
7301 g_b_init_set_file_security
= 0;
7302 num_of_processors
= 0;
7303 /* The following sets a handler for shutdown notifications for
7304 console apps. This actually applies to Emacs in both console and
7305 GUI modes, since we had to fool windows into thinking emacs is a
7306 console application to get console mode to work. */
7307 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
7309 /* "None" is the default group name on standalone workstations. */
7310 strcpy (dflt_group_name
, "None");
7312 /* Reset, in case it has some value inherited from dump time. */
7313 w32_stat_get_owner_group
= 0;
7316 /* For make-serial-process */
7318 serial_open (char *port
)
7324 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
7325 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
7326 if (hnd
== INVALID_HANDLE_VALUE
)
7327 error ("Could not open %s", port
);
7328 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
7330 error ("Could not open %s", port
);
7334 error ("Could not create child process");
7336 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7337 fd_info
[ fd
].hnd
= hnd
;
7338 fd_info
[ fd
].flags
|=
7339 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
7340 if (fd_info
[ fd
].cp
!= NULL
)
7342 error ("fd_info[fd = %d] is already in use", fd
);
7344 fd_info
[ fd
].cp
= cp
;
7345 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7346 if (cp
->ovl_read
.hEvent
== NULL
)
7347 error ("Could not create read event");
7348 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7349 if (cp
->ovl_write
.hEvent
== NULL
)
7350 error ("Could not create write event");
7355 /* For serial-process-configure */
7357 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
7359 Lisp_Object childp2
= Qnil
;
7360 Lisp_Object tem
= Qnil
;
7364 char summary
[4] = "???"; /* This usually becomes "8N1". */
7366 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
7367 error ("Not a serial process");
7368 hnd
= fd_info
[ p
->outfd
].hnd
;
7370 childp2
= Fcopy_sequence (p
->childp
);
7372 /* Initialize timeouts for blocking read and blocking write. */
7373 if (!GetCommTimeouts (hnd
, &ct
))
7374 error ("GetCommTimeouts() failed");
7375 ct
.ReadIntervalTimeout
= 0;
7376 ct
.ReadTotalTimeoutMultiplier
= 0;
7377 ct
.ReadTotalTimeoutConstant
= 0;
7378 ct
.WriteTotalTimeoutMultiplier
= 0;
7379 ct
.WriteTotalTimeoutConstant
= 0;
7380 if (!SetCommTimeouts (hnd
, &ct
))
7381 error ("SetCommTimeouts() failed");
7382 /* Read port attributes and prepare default configuration. */
7383 memset (&dcb
, 0, sizeof (dcb
));
7384 dcb
.DCBlength
= sizeof (DCB
);
7385 if (!GetCommState (hnd
, &dcb
))
7386 error ("GetCommState() failed");
7389 dcb
.fAbortOnError
= FALSE
;
7390 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7395 /* Configure speed. */
7396 if (!NILP (Fplist_member (contact
, QCspeed
)))
7397 tem
= Fplist_get (contact
, QCspeed
);
7399 tem
= Fplist_get (p
->childp
, QCspeed
);
7401 dcb
.BaudRate
= XINT (tem
);
7402 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
7404 /* Configure bytesize. */
7405 if (!NILP (Fplist_member (contact
, QCbytesize
)))
7406 tem
= Fplist_get (contact
, QCbytesize
);
7408 tem
= Fplist_get (p
->childp
, QCbytesize
);
7410 tem
= make_number (8);
7412 if (XINT (tem
) != 7 && XINT (tem
) != 8)
7413 error (":bytesize must be nil (8), 7, or 8");
7414 dcb
.ByteSize
= XINT (tem
);
7415 summary
[0] = XINT (tem
) + '0';
7416 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
7418 /* Configure parity. */
7419 if (!NILP (Fplist_member (contact
, QCparity
)))
7420 tem
= Fplist_get (contact
, QCparity
);
7422 tem
= Fplist_get (p
->childp
, QCparity
);
7423 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
7424 error (":parity must be nil (no parity), `even', or `odd'");
7425 dcb
.fParity
= FALSE
;
7426 dcb
.Parity
= NOPARITY
;
7427 dcb
.fErrorChar
= FALSE
;
7432 else if (EQ (tem
, Qeven
))
7436 dcb
.Parity
= EVENPARITY
;
7437 dcb
.fErrorChar
= TRUE
;
7439 else if (EQ (tem
, Qodd
))
7443 dcb
.Parity
= ODDPARITY
;
7444 dcb
.fErrorChar
= TRUE
;
7446 childp2
= Fplist_put (childp2
, QCparity
, tem
);
7448 /* Configure stopbits. */
7449 if (!NILP (Fplist_member (contact
, QCstopbits
)))
7450 tem
= Fplist_get (contact
, QCstopbits
);
7452 tem
= Fplist_get (p
->childp
, QCstopbits
);
7454 tem
= make_number (1);
7456 if (XINT (tem
) != 1 && XINT (tem
) != 2)
7457 error (":stopbits must be nil (1 stopbit), 1, or 2");
7458 summary
[2] = XINT (tem
) + '0';
7459 if (XINT (tem
) == 1)
7460 dcb
.StopBits
= ONESTOPBIT
;
7461 else if (XINT (tem
) == 2)
7462 dcb
.StopBits
= TWOSTOPBITS
;
7463 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
7465 /* Configure flowcontrol. */
7466 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
7467 tem
= Fplist_get (contact
, QCflowcontrol
);
7469 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
7470 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
7471 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7472 dcb
.fOutxCtsFlow
= FALSE
;
7473 dcb
.fOutxDsrFlow
= FALSE
;
7474 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
7475 dcb
.fDsrSensitivity
= FALSE
;
7476 dcb
.fTXContinueOnXoff
= FALSE
;
7479 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
7480 dcb
.XonChar
= 17; /* Control-Q */
7481 dcb
.XoffChar
= 19; /* Control-S */
7484 /* Already configured. */
7486 else if (EQ (tem
, Qhw
))
7488 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
7489 dcb
.fOutxCtsFlow
= TRUE
;
7491 else if (EQ (tem
, Qsw
))
7496 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
7498 /* Activate configuration. */
7499 if (!SetCommState (hnd
, &dcb
))
7500 error ("SetCommState() failed");
7502 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
7503 pset_childp (p
, childp2
);
7509 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
7514 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7515 int fd
= process
->infd
;
7519 n
= sys_read (fd
, (char*)buf
, sz
);
7526 if (err
== EWOULDBLOCK
)
7528 /* Set a small timeout. */
7529 timeout
= make_emacs_time (1, 0);
7531 FD_SET ((int)fd
, &fdset
);
7533 /* Use select with the timeout to poll the selector. */
7534 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7538 continue; /* Try again. */
7540 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7541 Also accept select return 0 as an indicator to EAGAIN. */
7542 if (sc
== 0 || errno
== EWOULDBLOCK
)
7545 err
= errno
; /* Other errors are just passed on. */
7548 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7555 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7557 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7558 int fd
= process
->outfd
;
7559 ssize_t n
= sys_write (fd
, buf
, sz
);
7561 /* 0 or more bytes written means everything went fine. */
7565 /* Negative bytes written means we got an error in errno.
7566 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7567 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7568 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7572 #endif /* HAVE_GNUTLS */