1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994-1995, 2000-2012 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 var
[name_len
++] = '=';
1788 var
[name_len
] = '\0';
1789 return _putenv (var
);
1792 /* MS _putenv doesn't support removing a variable when the argument
1793 does not include the '=' character, so we fix that here. */
1795 sys_putenv (char *str
)
1797 const char *const name_end
= strchr (str
, '=');
1799 if (name_end
== NULL
)
1801 /* Remove the variable from the environment. */
1802 return unsetenv (str
);
1805 return _putenv (str
);
1808 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1811 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1814 HKEY hrootkey
= NULL
;
1817 /* Check both the current user and the local machine to see if
1818 we have any resources. */
1820 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1824 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1825 && (lpvalue
= xmalloc (cbData
)) != NULL
1826 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1828 RegCloseKey (hrootkey
);
1834 RegCloseKey (hrootkey
);
1837 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1841 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1842 && (lpvalue
= xmalloc (cbData
)) != NULL
1843 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1845 RegCloseKey (hrootkey
);
1851 RegCloseKey (hrootkey
);
1857 char *get_emacs_configuration (void);
1860 init_environment (char ** argv
)
1862 static const char * const tempdirs
[] = {
1863 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1868 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1870 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1871 temporary files and assume "/tmp" if $TMPDIR is unset, which
1872 will break on DOS/Windows. Refuse to work if we cannot find
1873 a directory, not even "c:/", usable for that purpose. */
1874 for (i
= 0; i
< imax
; i
++)
1876 const char *tmp
= tempdirs
[i
];
1879 tmp
= getenv (tmp
+ 1);
1880 /* Note that `access' can lie to us if the directory resides on a
1881 read-only filesystem, like CD-ROM or a write-protected floppy.
1882 The only way to be really sure is to actually create a file and
1883 see if it succeeds. But I think that's too much to ask. */
1885 /* MSVCRT's _access crashes with D_OK. */
1886 if (tmp
&& faccessat (AT_FDCWD
, tmp
, D_OK
, AT_EACCESS
) == 0)
1888 char * var
= alloca (strlen (tmp
) + 8);
1889 sprintf (var
, "TMPDIR=%s", tmp
);
1890 _putenv (strdup (var
));
1897 Fcons (build_string ("no usable temporary directories found!!"),
1899 "While setting TMPDIR: ");
1901 /* Check for environment variables and use registry settings if they
1902 don't exist. Fallback on default values where applicable. */
1907 char locale_name
[32];
1908 char default_home
[MAX_PATH
];
1911 static const struct env_entry
1917 /* If the default value is NULL, we will use the value from the
1918 outside environment or the Registry, but will not push the
1919 variable into the Emacs environment if it is defined neither
1920 in the Registry nor in the outside environment. */
1922 {"PRELOAD_WINSOCK", NULL
},
1923 {"emacs_dir", "C:/emacs"},
1924 {"EMACSLOADPATH", NULL
},
1925 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1926 {"EMACSDATA", NULL
},
1927 {"EMACSPATH", NULL
},
1934 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1936 /* We need to copy dflt_envvars[] and work on the copy because we
1937 don't want the dumped Emacs to inherit the values of
1938 environment variables we saw during dumping (which could be on
1939 a different system). The defaults above must be left intact. */
1940 struct env_entry env_vars
[N_ENV_VARS
];
1942 for (i
= 0; i
< N_ENV_VARS
; i
++)
1943 env_vars
[i
] = dflt_envvars
[i
];
1945 /* For backwards compatibility, check if a .emacs file exists in C:/
1946 If not, then we can try to default to the appdata directory under the
1947 user's profile, which is more likely to be writable. */
1948 if (!check_existing ("C:/.emacs"))
1950 HRESULT profile_result
;
1951 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1952 of Windows 95 and NT4 that have not been updated to include
1954 ShGetFolderPath_fn get_folder_path
;
1955 get_folder_path
= (ShGetFolderPath_fn
)
1956 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1958 if (get_folder_path
!= NULL
)
1960 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1963 /* If we can't get the appdata dir, revert to old behavior. */
1964 if (profile_result
== S_OK
)
1966 env_vars
[0].def_value
= default_home
;
1972 /* Get default locale info and use it for LANG. */
1973 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1974 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1975 locale_name
, sizeof (locale_name
)))
1977 for (i
= 0; i
< N_ENV_VARS
; i
++)
1979 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1981 env_vars
[i
].def_value
= locale_name
;
1987 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1989 /* Treat emacs_dir specially: set it unconditionally based on our
1993 char modname
[MAX_PATH
];
1995 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1997 if ((p
= strrchr (modname
, '\\')) == NULL
)
2001 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
2003 char buf
[SET_ENV_BUF_SIZE
];
2006 for (p
= modname
; *p
; p
++)
2007 if (*p
== '\\') *p
= '/';
2009 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2010 _putenv (strdup (buf
));
2012 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
2014 /* FIXME: should use substring of get_emacs_configuration ().
2015 But I don't think the Windows build supports alpha, mips etc
2016 anymore, so have taken the easy option for now. */
2017 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
2018 || xstrcasecmp (p
, "\\AMD64") == 0))
2021 p
= strrchr (modname
, '\\');
2025 p
= strrchr (modname
, '\\');
2026 if (p
&& xstrcasecmp (p
, "\\src") == 0)
2028 char buf
[SET_ENV_BUF_SIZE
];
2031 for (p
= modname
; *p
; p
++)
2032 if (*p
== '\\') *p
= '/';
2034 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2035 _putenv (strdup (buf
));
2041 for (i
= 0; i
< N_ENV_VARS
; i
++)
2043 if (!getenv (env_vars
[i
].name
))
2047 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2048 /* Also ignore empty environment variables. */
2052 lpval
= env_vars
[i
].def_value
;
2053 dwType
= REG_EXPAND_SZ
;
2055 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
2056 Vdelayed_warnings_list
2057 = Fcons (listn (CONSTYPE_HEAP
, 2,
2058 intern ("initialization"),
2059 build_string ("Setting HOME to C:\\ by default is deprecated")),
2060 Vdelayed_warnings_list
);
2065 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2067 if (dwType
== REG_EXPAND_SZ
)
2068 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2069 else if (dwType
== REG_SZ
)
2070 strcpy (buf1
, lpval
);
2071 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2073 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2075 _putenv (strdup (buf2
));
2085 /* Rebuild system configuration to reflect invoking system. */
2086 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2088 /* Another special case: on NT, the PATH variable is actually named
2089 "Path" although cmd.exe (perhaps NT itself) arranges for
2090 environment variable lookup and setting to be case insensitive.
2091 However, Emacs assumes a fully case sensitive environment, so we
2092 need to change "Path" to "PATH" to match the expectations of
2093 various elisp packages. We do this by the sneaky method of
2094 modifying the string in the C runtime environ entry.
2096 The same applies to COMSPEC. */
2100 for (envp
= environ
; *envp
; envp
++)
2101 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2102 memcpy (*envp
, "PATH=", 5);
2103 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2104 memcpy (*envp
, "COMSPEC=", 8);
2107 /* Remember the initial working directory for getcwd. */
2108 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2109 Does it matter anywhere in Emacs? */
2110 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
2114 static char modname
[MAX_PATH
];
2116 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2121 /* Determine if there is a middle mouse button, to allow parse_button
2122 to decide whether right mouse events should be mouse-2 or
2124 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2129 /* Called from expand-file-name when default-directory is not a string. */
2132 emacs_root_dir (void)
2134 static char root_dir
[FILENAME_MAX
];
2137 p
= getenv ("emacs_dir");
2140 strcpy (root_dir
, p
);
2141 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2142 dostounix_filename (root_dir
);
2146 /* We don't have scripts to automatically determine the system configuration
2147 for Emacs before it's compiled, and we don't want to have to make the
2148 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
2152 get_emacs_configuration (void)
2154 char *arch
, *oem
, *os
;
2156 static char configuration_buffer
[32];
2158 /* Determine the processor type. */
2159 switch (get_processor_type ())
2162 #ifdef PROCESSOR_INTEL_386
2163 case PROCESSOR_INTEL_386
:
2164 case PROCESSOR_INTEL_486
:
2165 case PROCESSOR_INTEL_PENTIUM
:
2173 #ifdef PROCESSOR_AMD_X8664
2174 case PROCESSOR_AMD_X8664
:
2179 #ifdef PROCESSOR_MIPS_R2000
2180 case PROCESSOR_MIPS_R2000
:
2181 case PROCESSOR_MIPS_R3000
:
2182 case PROCESSOR_MIPS_R4000
:
2187 #ifdef PROCESSOR_ALPHA_21064
2188 case PROCESSOR_ALPHA_21064
:
2198 /* Use the OEM field to reflect the compiler/library combination. */
2200 #define COMPILER_NAME "msvc"
2203 #define COMPILER_NAME "mingw"
2205 #define COMPILER_NAME "unknown"
2208 oem
= COMPILER_NAME
;
2210 switch (osinfo_cache
.dwPlatformId
) {
2211 case VER_PLATFORM_WIN32_NT
:
2213 build_num
= osinfo_cache
.dwBuildNumber
;
2215 case VER_PLATFORM_WIN32_WINDOWS
:
2216 if (osinfo_cache
.dwMinorVersion
== 0) {
2221 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2223 case VER_PLATFORM_WIN32s
:
2224 /* Not supported, should not happen. */
2226 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2234 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
2235 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
2236 get_w32_major_version (), get_w32_minor_version (), build_num
);
2238 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
2241 return configuration_buffer
;
2245 get_emacs_configuration_options (void)
2247 static char *options_buffer
;
2248 char cv
[32]; /* Enough for COMPILER_VERSION. */
2250 cv
, /* To be filled later. */
2254 #ifdef ENABLE_CHECKING
2255 " --enable-checking",
2257 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2258 with a starting space to save work here. */
2260 " --cflags", USER_CFLAGS
,
2263 " --ldflags", USER_LDFLAGS
,
2270 /* Work out the effective configure options for this build. */
2272 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2275 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2277 #define COMPILER_VERSION ""
2281 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2282 return "Error: not enough space for compiler version";
2283 cv
[sizeof (cv
) - 1] = '\0';
2285 for (i
= 0; options
[i
]; i
++)
2286 size
+= strlen (options
[i
]);
2288 options_buffer
= xmalloc (size
+ 1);
2289 options_buffer
[0] = '\0';
2291 for (i
= 0; options
[i
]; i
++)
2292 strcat (options_buffer
, options
[i
]);
2294 return options_buffer
;
2298 #include <sys/timeb.h>
2300 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2302 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2307 tv
->tv_sec
= tb
.time
;
2308 tv
->tv_usec
= tb
.millitm
* 1000L;
2309 /* Implementation note: _ftime sometimes doesn't update the dstflag
2310 according to the new timezone when the system timezone is
2311 changed. We could fix that by using GetSystemTime and
2312 GetTimeZoneInformation, but that doesn't seem necessary, since
2313 Emacs always calls gettimeofday with the 2nd argument NULL (see
2314 current_emacs_time). */
2317 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2318 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2322 /* Emulate fdutimens. */
2324 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2325 TIMESPEC[0] and TIMESPEC[1], respectively.
2326 FD must be either negative -- in which case it is ignored --
2327 or a file descriptor that is open on FILE.
2328 If FD is nonnegative, then FILE can be NULL, which means
2329 use just futimes instead of utimes.
2330 If TIMESPEC is null, FAIL.
2331 Return 0 on success, -1 (setting errno) on failure. */
2334 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2343 if (fd
< 0 && !file
)
2348 ut
.actime
= timespec
[0].tv_sec
;
2349 ut
.modtime
= timespec
[1].tv_sec
;
2351 return _futime (fd
, &ut
);
2353 return _utime (file
, &ut
);
2357 /* ------------------------------------------------------------------------- */
2358 /* IO support and wrapper functions for the Windows API. */
2359 /* ------------------------------------------------------------------------- */
2361 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2362 on network directories, so we handle that case here.
2363 (Ulrich Leodolter, 1/11/95). */
2365 sys_ctime (const time_t *t
)
2367 char *str
= (char *) ctime (t
);
2368 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2371 /* Emulate sleep...we could have done this with a define, but that
2372 would necessitate including windows.h in the files that used it.
2373 This is much easier. */
2375 sys_sleep (int seconds
)
2377 Sleep (seconds
* 1000);
2380 /* Internal MSVC functions for low-level descriptor munging */
2381 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2382 extern int __cdecl
_free_osfhnd (int fd
);
2384 /* parallel array of private info on file handles */
2385 filedesc fd_info
[ MAXDESC
];
2387 typedef struct volume_info_data
{
2388 struct volume_info_data
* next
;
2390 /* time when info was obtained */
2393 /* actual volume info */
2402 /* Global referenced by various functions. */
2403 static volume_info_data volume_info
;
2405 /* Vector to indicate which drives are local and fixed (for which cached
2406 data never expires). */
2407 static BOOL fixed_drives
[26];
2409 /* Consider cached volume information to be stale if older than 10s,
2410 at least for non-local drives. Info for fixed drives is never stale. */
2411 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2412 #define VOLINFO_STILL_VALID( root_dir, info ) \
2413 ( ( isalpha (root_dir[0]) && \
2414 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2415 || GetTickCount () - info->timestamp < 10000 )
2417 /* Cache support functions. */
2419 /* Simple linked list with linear search is sufficient. */
2420 static volume_info_data
*volume_cache
= NULL
;
2422 static volume_info_data
*
2423 lookup_volume_info (char * root_dir
)
2425 volume_info_data
* info
;
2427 for (info
= volume_cache
; info
; info
= info
->next
)
2428 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2434 add_volume_info (char * root_dir
, volume_info_data
* info
)
2436 info
->root_dir
= xstrdup (root_dir
);
2437 info
->next
= volume_cache
;
2438 volume_cache
= info
;
2442 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2443 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2444 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2445 static volume_info_data
*
2446 GetCachedVolumeInformation (char * root_dir
)
2448 volume_info_data
* info
;
2449 char default_root
[ MAX_PATH
];
2451 /* NULL for root_dir means use root from current directory. */
2452 if (root_dir
== NULL
)
2454 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2456 parse_root (default_root
, &root_dir
);
2458 root_dir
= default_root
;
2461 /* Local fixed drives can be cached permanently. Removable drives
2462 cannot be cached permanently, since the volume name and serial
2463 number (if nothing else) can change. Remote drives should be
2464 treated as if they are removable, since there is no sure way to
2465 tell whether they are or not. Also, the UNC association of drive
2466 letters mapped to remote volumes can be changed at any time (even
2467 by other processes) without notice.
2469 As a compromise, so we can benefit from caching info for remote
2470 volumes, we use a simple expiry mechanism to invalidate cache
2471 entries that are more than ten seconds old. */
2474 /* No point doing this, because WNetGetConnection is even slower than
2475 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2476 GetDriveType is about the only call of this type which does not
2477 involve network access, and so is extremely quick). */
2479 /* Map drive letter to UNC if remote. */
2480 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2482 char remote_name
[ 256 ];
2483 char drive
[3] = { root_dir
[0], ':' };
2485 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2487 /* do something */ ;
2491 info
= lookup_volume_info (root_dir
);
2493 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2501 /* Info is not cached, or is stale. */
2502 if (!GetVolumeInformation (root_dir
,
2503 name
, sizeof (name
),
2507 type
, sizeof (type
)))
2510 /* Cache the volume information for future use, overwriting existing
2511 entry if present. */
2514 info
= xmalloc (sizeof (volume_info_data
));
2515 add_volume_info (root_dir
, info
);
2523 info
->name
= xstrdup (name
);
2524 info
->serialnum
= serialnum
;
2525 info
->maxcomp
= maxcomp
;
2526 info
->flags
= flags
;
2527 info
->type
= xstrdup (type
);
2528 info
->timestamp
= GetTickCount ();
2534 /* Get information on the volume where NAME is held; set path pointer to
2535 start of pathname in NAME (past UNC header\volume header if present),
2536 if pPath is non-NULL.
2538 Note: if NAME includes symlinks, the information is for the volume
2539 of the symlink, not of its target. That's because, even though
2540 GetVolumeInformation returns information about the symlink target
2541 of its argument, we only pass the root directory to
2542 GetVolumeInformation, not the full NAME. */
2544 get_volume_info (const char * name
, const char ** pPath
)
2546 char temp
[MAX_PATH
];
2547 char *rootname
= NULL
; /* default to current volume */
2548 volume_info_data
* info
;
2553 /* Find the root name of the volume if given. */
2554 if (isalpha (name
[0]) && name
[1] == ':')
2562 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2569 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2582 info
= GetCachedVolumeInformation (rootname
);
2585 /* Set global referenced by other functions. */
2586 volume_info
= *info
;
2592 /* Determine if volume is FAT format (ie. only supports short 8.3
2593 names); also set path pointer to start of pathname in name, if
2594 pPath is non-NULL. */
2596 is_fat_volume (const char * name
, const char ** pPath
)
2598 if (get_volume_info (name
, pPath
))
2599 return (volume_info
.maxcomp
== 12);
2603 /* Map filename to a valid 8.3 name if necessary.
2604 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2606 map_w32_filename (const char * name
, const char ** pPath
)
2608 static char shortname
[MAX_PATH
];
2609 char * str
= shortname
;
2612 const char * save_name
= name
;
2614 if (strlen (name
) >= MAX_PATH
)
2616 /* Return a filename which will cause callers to fail. */
2617 strcpy (shortname
, "?");
2621 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2623 register int left
= 8; /* maximum number of chars in part */
2624 register int extn
= 0; /* extension added? */
2625 register int dots
= 2; /* maximum number of dots allowed */
2628 *str
++ = *name
++; /* skip past UNC header */
2630 while ((c
= *name
++))
2637 *str
++ = (c
== ':' ? ':' : '\\');
2638 extn
= 0; /* reset extension flags */
2639 dots
= 2; /* max 2 dots */
2640 left
= 8; /* max length 8 for main part */
2645 /* Convert path components of the form .xxx to _xxx,
2646 but leave . and .. as they are. This allows .emacs
2647 to be read as _emacs, for example. */
2651 IS_DIRECTORY_SEP (*name
))
2666 extn
= 1; /* we've got an extension */
2667 left
= 3; /* 3 chars in extension */
2671 /* any embedded dots after the first are converted to _ */
2676 case '#': /* don't lose these, they're important */
2678 str
[-1] = c
; /* replace last character of part */
2683 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2685 dots
= 0; /* started a path component */
2694 strcpy (shortname
, name
);
2695 unixtodos_filename (shortname
);
2699 *pPath
= shortname
+ (path
- save_name
);
2705 is_exec (const char * name
)
2707 char * p
= strrchr (name
, '.');
2710 && (xstrcasecmp (p
, ".exe") == 0 ||
2711 xstrcasecmp (p
, ".com") == 0 ||
2712 xstrcasecmp (p
, ".bat") == 0 ||
2713 xstrcasecmp (p
, ".cmd") == 0));
2716 /* Emulate the Unix directory procedures opendir, closedir,
2717 and readdir. We can't use the procedures supplied in sysdep.c,
2718 so we provide them here. */
2720 struct dirent dir_static
; /* simulated directory contents */
2721 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2722 static int dir_is_fat
;
2723 static char dir_pathname
[MAXPATHLEN
+1];
2724 static WIN32_FIND_DATA dir_find_data
;
2726 /* Support shares on a network resource as subdirectories of a read-only
2728 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2729 static HANDLE
open_unc_volume (const char *);
2730 static char *read_unc_volume (HANDLE
, char *, int);
2731 static void close_unc_volume (HANDLE
);
2734 opendir (char *filename
)
2738 /* Opening is done by FindFirstFile. However, a read is inherent to
2739 this operation, so we defer the open until read time. */
2741 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2743 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2746 /* Note: We don't support traversal of UNC volumes via symlinks.
2747 Doing so would mean punishing 99.99% of use cases by resolving
2748 all the possible symlinks in FILENAME, recursively. */
2749 if (is_unc_volume (filename
))
2751 wnet_enum_handle
= open_unc_volume (filename
);
2752 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2756 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2763 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2764 dir_pathname
[MAXPATHLEN
] = '\0';
2765 /* Note: We don't support symlinks to file names on FAT volumes.
2766 Doing so would mean punishing 99.99% of use cases by resolving
2767 all the possible symlinks in FILENAME, recursively. */
2768 dir_is_fat
= is_fat_volume (filename
, NULL
);
2774 closedir (DIR *dirp
)
2776 /* If we have a find-handle open, close it. */
2777 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2779 FindClose (dir_find_handle
);
2780 dir_find_handle
= INVALID_HANDLE_VALUE
;
2782 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2784 close_unc_volume (wnet_enum_handle
);
2785 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2787 xfree ((char *) dirp
);
2793 int downcase
= !NILP (Vw32_downcase_file_names
);
2795 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2797 if (!read_unc_volume (wnet_enum_handle
,
2798 dir_find_data
.cFileName
,
2802 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2803 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2805 char filename
[MAXNAMLEN
+ 3];
2808 strcpy (filename
, dir_pathname
);
2809 ln
= strlen (filename
) - 1;
2810 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2811 strcat (filename
, "\\");
2812 strcat (filename
, "*");
2814 /* Note: No need to resolve symlinks in FILENAME, because
2815 FindFirst opens the directory that is the target of a
2817 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2819 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2824 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2828 /* Emacs never uses this value, so don't bother making it match
2829 value returned by stat(). */
2830 dir_static
.d_ino
= 1;
2832 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2834 /* If the file name in cFileName[] includes `?' characters, it means
2835 the original file name used characters that cannot be represented
2836 by the current ANSI codepage. To avoid total lossage, retrieve
2837 the short 8+3 alias of the long file name. */
2838 if (_mbspbrk (dir_static
.d_name
, "?"))
2840 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2841 downcase
= 1; /* 8+3 aliases are returned in all caps */
2843 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2844 dir_static
.d_reclen
= sizeof (struct dirent
) - MAXNAMLEN
+ 3 +
2845 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2847 /* If the file name in cFileName[] includes `?' characters, it means
2848 the original file name used characters that cannot be represented
2849 by the current ANSI codepage. To avoid total lossage, retrieve
2850 the short 8+3 alias of the long file name. */
2851 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2853 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2854 /* 8+3 aliases are returned in all caps, which could break
2855 various alists that look at filenames' extensions. */
2859 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2860 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2862 _strlwr (dir_static
.d_name
);
2866 for (p
= dir_static
.d_name
; *p
; p
++)
2867 if (*p
>= 'a' && *p
<= 'z')
2870 _strlwr (dir_static
.d_name
);
2877 open_unc_volume (const char *path
)
2883 nr
.dwScope
= RESOURCE_GLOBALNET
;
2884 nr
.dwType
= RESOURCETYPE_DISK
;
2885 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2886 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2887 nr
.lpLocalName
= NULL
;
2888 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2889 nr
.lpComment
= NULL
;
2890 nr
.lpProvider
= NULL
;
2892 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2893 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2895 if (result
== NO_ERROR
)
2898 return INVALID_HANDLE_VALUE
;
2902 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2906 DWORD bufsize
= 512;
2911 buffer
= alloca (bufsize
);
2912 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2913 if (result
!= NO_ERROR
)
2916 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2917 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2919 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2922 strncpy (readbuf
, ptr
, size
);
2927 close_unc_volume (HANDLE henum
)
2929 if (henum
!= INVALID_HANDLE_VALUE
)
2930 WNetCloseEnum (henum
);
2934 unc_volume_file_attributes (const char *path
)
2939 henum
= open_unc_volume (path
);
2940 if (henum
== INVALID_HANDLE_VALUE
)
2943 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2945 close_unc_volume (henum
);
2950 /* Ensure a network connection is authenticated. */
2952 logon_network_drive (const char *path
)
2954 NETRESOURCE resource
;
2955 char share
[MAX_PATH
];
2960 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2961 drvtype
= DRIVE_REMOTE
;
2962 else if (path
[0] == '\0' || path
[1] != ':')
2963 drvtype
= GetDriveType (NULL
);
2970 drvtype
= GetDriveType (drive
);
2973 /* Only logon to networked drives. */
2974 if (drvtype
!= DRIVE_REMOTE
)
2978 strncpy (share
, path
, MAX_PATH
);
2979 /* Truncate to just server and share name. */
2980 for (i
= 2; i
< MAX_PATH
; i
++)
2982 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2989 resource
.dwType
= RESOURCETYPE_DISK
;
2990 resource
.lpLocalName
= NULL
;
2991 resource
.lpRemoteName
= share
;
2992 resource
.lpProvider
= NULL
;
2994 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2997 /* Emulate faccessat(2). */
2999 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3003 if (dirfd
!= AT_FDCWD
3004 && !(IS_DIRECTORY_SEP (path
[0])
3005 || IS_DEVICE_SEP (path
[1])))
3011 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3012 newer versions blow up when passed D_OK. */
3013 path
= map_w32_filename (path
, NULL
);
3014 /* If the last element of PATH is a symlink, we need to resolve it
3015 to get the attributes of its target file. Note: any symlinks in
3016 PATH elements other than the last one are transparently resolved
3017 by GetFileAttributes below. */
3018 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3019 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3020 path
= chase_symlinks (path
);
3022 if ((attributes
= GetFileAttributes (path
)) == -1)
3024 DWORD w32err
= GetLastError ();
3028 case ERROR_INVALID_NAME
:
3029 case ERROR_BAD_PATHNAME
:
3030 if (is_unc_volume (path
))
3032 attributes
= unc_volume_file_attributes (path
);
3033 if (attributes
== -1)
3041 case ERROR_FILE_NOT_FOUND
:
3042 case ERROR_BAD_NETPATH
:
3051 if ((mode
& X_OK
) != 0
3052 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3057 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3062 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3070 /* Shadow some MSVC runtime functions to map requests for long filenames
3071 to reasonable short names if necessary. This was originally added to
3072 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3076 sys_chdir (const char * path
)
3078 return _chdir (map_w32_filename (path
, NULL
));
3082 sys_chmod (const char * path
, int mode
)
3084 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3085 return _chmod (path
, mode
);
3089 sys_chown (const char *path
, uid_t owner
, gid_t group
)
3091 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
3097 sys_creat (const char * path
, int mode
)
3099 return _creat (map_w32_filename (path
, NULL
), mode
);
3103 sys_fopen (const char * path
, const char * mode
)
3107 const char * mode_save
= mode
;
3109 /* Force all file handles to be non-inheritable. This is necessary to
3110 ensure child processes don't unwittingly inherit handles that might
3111 prevent future file access. */
3115 else if (mode
[0] == 'w' || mode
[0] == 'a')
3116 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3120 /* Only do simplistic option parsing. */
3124 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3127 else if (mode
[0] == 'b')
3132 else if (mode
[0] == 't')
3139 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
3143 return _fdopen (fd
, mode_save
);
3146 /* This only works on NTFS volumes, but is useful to have. */
3148 sys_link (const char * old
, const char * new)
3152 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
3154 if (old
== NULL
|| new == NULL
)
3160 strcpy (oldname
, map_w32_filename (old
, NULL
));
3161 strcpy (newname
, map_w32_filename (new, NULL
));
3163 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
3164 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3165 if (fileh
!= INVALID_HANDLE_VALUE
)
3169 /* Confusingly, the "alternate" stream name field does not apply
3170 when restoring a hard link, and instead contains the actual
3171 stream data for the link (ie. the name of the link to create).
3172 The WIN32_STREAM_ID structure before the cStreamName field is
3173 the stream header, which is then immediately followed by the
3177 WIN32_STREAM_ID wid
;
3178 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3181 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
3182 data
.wid
.cStreamName
, MAX_PATH
);
3185 LPVOID context
= NULL
;
3188 data
.wid
.dwStreamId
= BACKUP_LINK
;
3189 data
.wid
.dwStreamAttributes
= 0;
3190 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3191 data
.wid
.Size
.HighPart
= 0;
3192 data
.wid
.dwStreamNameSize
= 0;
3194 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3195 offsetof (WIN32_STREAM_ID
, cStreamName
)
3196 + data
.wid
.Size
.LowPart
,
3197 &wbytes
, FALSE
, FALSE
, &context
)
3198 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3205 /* Should try mapping GetLastError to errno; for now just
3206 indicate a general error (eg. links not supported). */
3207 errno
= EINVAL
; // perhaps EMLINK?
3211 CloseHandle (fileh
);
3220 sys_mkdir (const char * path
)
3222 return _mkdir (map_w32_filename (path
, NULL
));
3225 /* Because of long name mapping issues, we need to implement this
3226 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
3227 a unique name, instead of setting the input template to an empty
3230 Standard algorithm seems to be use pid or tid with a letter on the
3231 front (in place of the 6 X's) and cycle through the letters to find a
3232 unique name. We extend that to allow any reasonable character as the
3233 first of the 6 X's. */
3235 sys_mktemp (char * template)
3239 unsigned uid
= GetCurrentThreadId ();
3240 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3242 if (template == NULL
)
3244 p
= template + strlen (template);
3246 /* replace up to the last 5 X's with uid in decimal */
3247 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3249 p
[0] = '0' + uid
% 10;
3253 if (i
< 0 && p
[0] == 'X')
3258 int save_errno
= errno
;
3259 p
[0] = first_char
[i
];
3260 if (faccessat (AT_FDCWD
, template, F_OK
, AT_EACCESS
) < 0)
3266 while (++i
< sizeof (first_char
));
3269 /* Template is badly formed or else we can't generate a unique name,
3270 so return empty string */
3276 sys_open (const char * path
, int oflag
, int mode
)
3278 const char* mpath
= map_w32_filename (path
, NULL
);
3279 /* Try to open file without _O_CREAT, to be able to write to hidden
3280 and system files. Force all file handles to be
3282 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3285 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3289 sys_rename (const char * oldname
, const char * newname
)
3292 char temp
[MAX_PATH
];
3296 /* MoveFile on Windows 95 doesn't correctly change the short file name
3297 alias in a number of circumstances (it is not easy to predict when
3298 just by looking at oldname and newname, unfortunately). In these
3299 cases, renaming through a temporary name avoids the problem.
3301 A second problem on Windows 95 is that renaming through a temp name when
3302 newname is uppercase fails (the final long name ends up in
3303 lowercase, although the short alias might be uppercase) UNLESS the
3304 long temp name is not 8.3.
3306 So, on Windows 95 we always rename through a temp name, and we make sure
3307 the temp name has a long extension to ensure correct renaming. */
3309 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3311 /* volume_info is set indirectly by map_w32_filename. */
3312 oldname_dev
= volume_info
.serialnum
;
3314 if (os_subtype
== OS_9X
)
3320 oldname
= map_w32_filename (oldname
, NULL
);
3321 if ((o
= strrchr (oldname
, '\\')))
3324 o
= (char *) oldname
;
3326 if ((p
= strrchr (temp
, '\\')))
3333 /* Force temp name to require a manufactured 8.3 alias - this
3334 seems to make the second rename work properly. */
3335 sprintf (p
, "_.%s.%u", o
, i
);
3337 result
= rename (oldname
, temp
);
3339 /* This loop must surely terminate! */
3340 while (result
< 0 && errno
== EEXIST
);
3345 /* Emulate Unix behavior - newname is deleted if it already exists
3346 (at least if it is a file; don't do this for directories).
3348 Since we mustn't do this if we are just changing the case of the
3349 file name (we would end up deleting the file we are trying to
3350 rename!), we let rename detect if the destination file already
3351 exists - that way we avoid the possible pitfalls of trying to
3352 determine ourselves whether two names really refer to the same
3353 file, which is not always possible in the general case. (Consider
3354 all the permutations of shared or subst'd drives, etc.) */
3356 newname
= map_w32_filename (newname
, NULL
);
3358 /* volume_info is set indirectly by map_w32_filename. */
3359 newname_dev
= volume_info
.serialnum
;
3361 result
= rename (temp
, newname
);
3365 DWORD w32err
= GetLastError ();
3368 && newname_dev
!= oldname_dev
)
3370 /* The implementation of `rename' on Windows does not return
3371 errno = EXDEV when you are moving a directory to a
3372 different storage device (ex. logical disk). It returns
3373 EACCES instead. So here we handle such situations and
3377 if ((attributes
= GetFileAttributes (temp
)) != -1
3378 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3381 else if (errno
== EEXIST
)
3383 if (_chmod (newname
, 0666) != 0)
3385 if (_unlink (newname
) != 0)
3387 result
= rename (temp
, newname
);
3389 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3390 && is_symlink (temp
))
3392 /* This is Windows prohibiting the user from creating a
3393 symlink in another place, since that requires
3403 sys_rmdir (const char * path
)
3405 return _rmdir (map_w32_filename (path
, NULL
));
3409 sys_unlink (const char * path
)
3411 path
= map_w32_filename (path
, NULL
);
3413 /* On Unix, unlink works without write permission. */
3414 _chmod (path
, 0666);
3415 return _unlink (path
);
3418 static FILETIME utc_base_ft
;
3419 static ULONGLONG utc_base
; /* In 100ns units */
3420 static int init
= 0;
3422 #define FILETIME_TO_U64(result, ft) \
3424 ULARGE_INTEGER uiTemp; \
3425 uiTemp.LowPart = (ft).dwLowDateTime; \
3426 uiTemp.HighPart = (ft).dwHighDateTime; \
3427 result = uiTemp.QuadPart; \
3431 initialize_utc_base (void)
3433 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3442 st
.wMilliseconds
= 0;
3444 SystemTimeToFileTime (&st
, &utc_base_ft
);
3445 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3449 convert_time (FILETIME ft
)
3455 initialize_utc_base ();
3459 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3462 FILETIME_TO_U64 (tmp
, ft
);
3463 return (time_t) ((tmp
- utc_base
) / 10000000L);
3467 convert_from_time_t (time_t time
, FILETIME
* pft
)
3473 initialize_utc_base ();
3477 /* time in 100ns units since 1-Jan-1601 */
3478 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3479 pft
->dwHighDateTime
= tmp
.HighPart
;
3480 pft
->dwLowDateTime
= tmp
.LowPart
;
3484 /* No reason to keep this; faking inode values either by hashing or even
3485 using the file index from GetInformationByHandle, is not perfect and
3486 so by default Emacs doesn't use the inode values on Windows.
3487 Instead, we now determine file-truename correctly (except for
3488 possible drive aliasing etc). */
3490 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3492 hashval (const unsigned char * str
)
3497 h
= (h
<< 4) + *str
++;
3503 /* Return the hash value of the canonical pathname, excluding the
3504 drive/UNC header, to get a hopefully unique inode number. */
3506 generate_inode_val (const char * name
)
3508 char fullname
[ MAX_PATH
];
3512 /* Get the truly canonical filename, if it exists. (Note: this
3513 doesn't resolve aliasing due to subst commands, or recognize hard
3515 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3518 parse_root (fullname
, &p
);
3519 /* Normal W32 filesystems are still case insensitive. */
3526 static PSECURITY_DESCRIPTOR
3527 get_file_security_desc_by_handle (HANDLE h
)
3529 PSECURITY_DESCRIPTOR psd
= NULL
;
3531 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3532 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3534 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3535 NULL
, NULL
, NULL
, NULL
, &psd
);
3536 if (err
!= ERROR_SUCCESS
)
3542 static PSECURITY_DESCRIPTOR
3543 get_file_security_desc_by_name (const char *fname
)
3545 PSECURITY_DESCRIPTOR psd
= NULL
;
3547 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3548 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3550 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3552 err
= GetLastError ();
3553 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3557 psd
= xmalloc (sd_len
);
3558 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3570 unsigned n_subauthorities
;
3572 /* Use the last sub-authority value of the RID, the relative
3573 portion of the SID, as user/group ID. */
3574 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3575 if (n_subauthorities
< 1)
3576 return 0; /* the "World" RID */
3577 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3580 /* Caching SID and account values for faster lokup. */
3583 # define FLEXIBLE_ARRAY_MEMBER
3585 # define FLEXIBLE_ARRAY_MEMBER 1
3590 struct w32_id
*next
;
3592 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3595 static struct w32_id
*w32_idlist
;
3598 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3600 struct w32_id
*tail
, *found
;
3602 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3604 if (equal_sid ((PSID
)tail
->sid
, sid
))
3613 strcpy (name
, found
->name
);
3621 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3624 struct w32_id
*new_entry
;
3626 /* We don't want to leave behind stale cache from when Emacs was
3630 sid_len
= get_length_sid (sid
);
3631 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3634 new_entry
->rid
= id
;
3635 strcpy (new_entry
->name
, name
);
3636 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3637 new_entry
->next
= w32_idlist
;
3638 w32_idlist
= new_entry
;
3647 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
3650 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3652 SID_NAME_USE ignore
;
3654 DWORD name_len
= sizeof (name
);
3656 DWORD domain_len
= sizeof (domain
);
3661 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3662 else if (what
== GID
)
3663 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3667 if (!result
|| !is_valid_sid (sid
))
3669 else if (!w32_cached_id (sid
, id
, nm
))
3671 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
3672 domain
, &domain_len
, &ignore
)
3673 || name_len
> UNLEN
+1)
3677 *id
= get_rid (sid
);
3679 w32_add_to_cache (sid
, *id
, name
);
3686 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
3688 int dflt_usr
= 0, dflt_grp
= 0;
3697 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
3699 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
3702 /* Consider files to belong to current user/group, if we cannot get
3703 more accurate information. */
3706 st
->st_uid
= dflt_passwd
.pw_uid
;
3707 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3711 st
->st_gid
= dflt_passwd
.pw_gid
;
3712 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3716 /* Return non-zero if NAME is a potentially slow filesystem. */
3718 is_slow_fs (const char *name
)
3723 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3724 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3725 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3726 devtype
= GetDriveType (NULL
); /* use root of current drive */
3729 /* GetDriveType needs the root directory of the drive. */
3730 strncpy (drive_root
, name
, 2);
3731 drive_root
[2] = '\\';
3732 drive_root
[3] = '\0';
3733 devtype
= GetDriveType (drive_root
);
3735 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3738 /* If this is non-zero, the caller wants accurate information about
3739 file's owner and group, which could be expensive to get. */
3740 int w32_stat_get_owner_group
;
3742 /* MSVC stat function can't cope with UNC names and has other bugs, so
3743 replace it with our own. This also allows us to calculate consistent
3744 inode values and owner/group without hacks in the main Emacs code. */
3747 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3749 char *name
, *save_name
, *r
;
3750 WIN32_FIND_DATA wfd
;
3752 unsigned __int64 fake_inode
= 0;
3755 int rootdir
= FALSE
;
3756 PSECURITY_DESCRIPTOR psd
= NULL
;
3757 int is_a_symlink
= 0;
3758 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3759 DWORD access_rights
= 0;
3760 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3761 FILETIME ctime
, atime
, wtime
;
3763 if (path
== NULL
|| buf
== NULL
)
3769 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3770 /* Must be valid filename, no wild cards or other invalid
3771 characters. We use _mbspbrk to support multibyte strings that
3772 might look to strpbrk as if they included literal *, ?, and other
3773 characters mentioned below that are disallowed by Windows
3775 if (_mbspbrk (name
, "*?|<>\""))
3781 /* Remove trailing directory separator, unless name is the root
3782 directory of a drive or UNC volume in which case ensure there
3783 is a trailing separator. */
3784 len
= strlen (name
);
3785 name
= strcpy (alloca (len
+ 2), name
);
3787 /* Avoid a somewhat costly call to is_symlink if the filesystem
3788 doesn't support symlinks. */
3789 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3790 is_a_symlink
= is_symlink (name
);
3792 /* Plan A: Open the file and get all the necessary information via
3793 the resulting handle. This solves several issues in one blow:
3795 . retrieves attributes for the target of a symlink, if needed
3796 . gets attributes of root directories and symlinks pointing to
3797 root directories, thus avoiding the need for special-casing
3798 these and detecting them by examining the file-name format
3799 . retrieves more accurate attributes (e.g., non-zero size for
3800 some directories, esp. directories that are junction points)
3801 . correctly resolves "c:/..", "/.." and similar file names
3802 . avoids run-time penalties for 99% of use cases
3804 Plan A is always tried first, unless the user asked not to (but
3805 if the file is a symlink and we need to follow links, we try Plan
3806 A even if the user asked not to).
3808 If Plan A fails, we go to Plan B (below), where various
3809 potentially expensive techniques must be used to handle "special"
3810 files such as UNC volumes etc. */
3811 if (!(NILP (Vw32_get_true_file_attributes
)
3812 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3813 /* Following symlinks requires getting the info by handle. */
3814 || (is_a_symlink
&& follow_symlinks
))
3816 BY_HANDLE_FILE_INFORMATION info
;
3818 if (is_a_symlink
&& !follow_symlinks
)
3819 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3820 /* READ_CONTROL access rights are required to get security info
3821 by handle. But if the OS doesn't support security in the
3822 first place, we don't need to try. */
3823 if (is_windows_9x () != TRUE
)
3824 access_rights
|= READ_CONTROL
;
3826 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3828 /* If CreateFile fails with READ_CONTROL, try again with zero as
3830 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3831 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3833 if (fh
== INVALID_HANDLE_VALUE
)
3834 goto no_true_file_attributes
;
3836 /* This is more accurate in terms of getting the correct number
3837 of links, but is quite slow (it is noticeable when Emacs is
3838 making a list of file name completions). */
3839 if (GetFileInformationByHandle (fh
, &info
))
3841 nlinks
= info
.nNumberOfLinks
;
3842 /* Might as well use file index to fake inode values, but this
3843 is not guaranteed to be unique unless we keep a handle open
3844 all the time (even then there are situations where it is
3845 not unique). Reputedly, there are at most 48 bits of info
3846 (on NTFS, presumably less on FAT). */
3847 fake_inode
= info
.nFileIndexHigh
;
3849 fake_inode
+= info
.nFileIndexLow
;
3850 serialnum
= info
.dwVolumeSerialNumber
;
3851 fs_high
= info
.nFileSizeHigh
;
3852 fs_low
= info
.nFileSizeLow
;
3853 ctime
= info
.ftCreationTime
;
3854 atime
= info
.ftLastAccessTime
;
3855 wtime
= info
.ftLastWriteTime
;
3856 fattrs
= info
.dwFileAttributes
;
3860 /* We don't go to Plan B here, because it's not clear that
3861 it's a good idea. The only known use case where
3862 CreateFile succeeds, but GetFileInformationByHandle fails
3863 (with ERROR_INVALID_FUNCTION) is for character devices
3864 such as NUL, PRN, etc. For these, switching to Plan B is
3865 a net loss, because we lose the character device
3866 attribute returned by GetFileType below (FindFirstFile
3867 doesn't set that bit in the attributes), and the other
3868 fields don't make sense for character devices anyway.
3869 Emacs doesn't really care for non-file entities in the
3870 context of l?stat, so neither do we. */
3872 /* w32err is assigned so one could put a breakpoint here and
3873 examine its value, when GetFileInformationByHandle
3875 DWORD w32err
= GetLastError ();
3879 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3885 /* Test for a symlink before testing for a directory, since
3886 symlinks to directories have the directory bit set, but we
3887 don't want them to appear as directories. */
3888 if (is_a_symlink
&& !follow_symlinks
)
3889 buf
->st_mode
= S_IFLNK
;
3890 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3891 buf
->st_mode
= S_IFDIR
;
3894 DWORD ftype
= GetFileType (fh
);
3898 case FILE_TYPE_DISK
:
3899 buf
->st_mode
= S_IFREG
;
3901 case FILE_TYPE_PIPE
:
3902 buf
->st_mode
= S_IFIFO
;
3904 case FILE_TYPE_CHAR
:
3905 case FILE_TYPE_UNKNOWN
:
3907 buf
->st_mode
= S_IFCHR
;
3910 /* We produce the fallback owner and group data, based on the
3911 current user that runs Emacs, in the following cases:
3913 . caller didn't request owner and group info
3914 . this is Windows 9X
3915 . getting security by handle failed, and we need to produce
3916 information for the target of a symlink (this is better
3917 than producing a potentially misleading info about the
3920 If getting security by handle fails, and we don't need to
3921 resolve symlinks, we try getting security by name. */
3922 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
3923 get_file_owner_and_group (NULL
, buf
);
3926 psd
= get_file_security_desc_by_handle (fh
);
3929 get_file_owner_and_group (psd
, buf
);
3932 else if (!(is_a_symlink
&& follow_symlinks
))
3934 psd
= get_file_security_desc_by_name (name
);
3935 get_file_owner_and_group (psd
, buf
);
3939 get_file_owner_and_group (NULL
, buf
);
3945 no_true_file_attributes
:
3946 /* Plan B: Either getting a handle on the file failed, or the
3947 caller explicitly asked us to not bother making this
3948 information more accurate.
3950 Implementation note: In Plan B, we never bother to resolve
3951 symlinks, even if we got here because we tried Plan A and
3952 failed. That's because, even if the caller asked for extra
3953 precision by setting Vw32_get_true_file_attributes to t,
3954 resolving symlinks requires acquiring a file handle to the
3955 symlink, which we already know will fail. And if the user
3956 did not ask for extra precision, resolving symlinks will fly
3957 in the face of that request, since the user then wants the
3958 lightweight version of the code. */
3959 rootdir
= (path
>= save_name
+ len
- 1
3960 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3962 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3963 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3964 if (IS_DIRECTORY_SEP (r
[0])
3965 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3968 /* Note: If NAME is a symlink to the root of a UNC volume
3969 (i.e. "\\SERVER"), we will not detect that here, and we will
3970 return data about the symlink as result of FindFirst below.
3971 This is unfortunate, but that marginal use case does not
3972 justify a call to chase_symlinks which would impose a penalty
3973 on all the other use cases. (We get here for symlinks to
3974 roots of UNC volumes because CreateFile above fails for them,
3975 unlike with symlinks to root directories X:\ of drives.) */
3976 if (is_unc_volume (name
))
3978 fattrs
= unc_volume_file_attributes (name
);
3982 ctime
= atime
= wtime
= utc_base_ft
;
3986 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3987 strcat (name
, "\\");
3988 if (GetDriveType (name
) < 2)
3994 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3995 ctime
= atime
= wtime
= utc_base_ft
;
3999 if (IS_DIRECTORY_SEP (name
[len
-1]))
4002 /* (This is hacky, but helps when doing file completions on
4003 network drives.) Optimize by using information available from
4004 active readdir if possible. */
4005 len
= strlen (dir_pathname
);
4006 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4008 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4009 && !(is_a_symlink
&& follow_symlinks
)
4010 && strnicmp (save_name
, dir_pathname
, len
) == 0
4011 && IS_DIRECTORY_SEP (name
[len
])
4012 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
4014 /* This was the last entry returned by readdir. */
4015 wfd
= dir_find_data
;
4019 logon_network_drive (name
);
4021 fh
= FindFirstFile (name
, &wfd
);
4022 if (fh
== INVALID_HANDLE_VALUE
)
4029 /* Note: if NAME is a symlink, the information we get from
4030 FindFirstFile is for the symlink, not its target. */
4031 fattrs
= wfd
.dwFileAttributes
;
4032 ctime
= wfd
.ftCreationTime
;
4033 atime
= wfd
.ftLastAccessTime
;
4034 wtime
= wfd
.ftLastWriteTime
;
4035 fs_high
= wfd
.nFileSizeHigh
;
4036 fs_low
= wfd
.nFileSizeLow
;
4039 serialnum
= volume_info
.serialnum
;
4041 if (is_a_symlink
&& !follow_symlinks
)
4042 buf
->st_mode
= S_IFLNK
;
4043 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4044 buf
->st_mode
= S_IFDIR
;
4046 buf
->st_mode
= S_IFREG
;
4048 get_file_owner_and_group (NULL
, buf
);
4052 /* Not sure if there is any point in this. */
4053 if (!NILP (Vw32_generate_fake_inodes
))
4054 fake_inode
= generate_inode_val (name
);
4055 else if (fake_inode
== 0)
4057 /* For want of something better, try to make everything unique. */
4058 static DWORD gen_num
= 0;
4059 fake_inode
= ++gen_num
;
4063 buf
->st_ino
= fake_inode
;
4065 buf
->st_dev
= serialnum
;
4066 buf
->st_rdev
= serialnum
;
4068 buf
->st_size
= fs_high
;
4069 buf
->st_size
<<= 32;
4070 buf
->st_size
+= fs_low
;
4071 buf
->st_nlink
= nlinks
;
4073 /* Convert timestamps to Unix format. */
4074 buf
->st_mtime
= convert_time (wtime
);
4075 buf
->st_atime
= convert_time (atime
);
4076 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4077 buf
->st_ctime
= convert_time (ctime
);
4078 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4080 /* determine rwx permissions */
4081 if (is_a_symlink
&& !follow_symlinks
)
4082 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
4085 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
4086 permission
= S_IREAD
;
4088 permission
= S_IREAD
| S_IWRITE
;
4090 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4091 permission
|= S_IEXEC
;
4092 else if (is_exec (name
))
4093 permission
|= S_IEXEC
;
4096 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4102 stat (const char * path
, struct stat
* buf
)
4104 return stat_worker (path
, buf
, 1);
4108 lstat (const char * path
, struct stat
* buf
)
4110 return stat_worker (path
, buf
, 0);
4113 /* Provide fstat and utime as well as stat for consistent handling of
4116 fstat (int desc
, struct stat
* buf
)
4118 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
4119 BY_HANDLE_FILE_INFORMATION info
;
4120 unsigned __int64 fake_inode
;
4123 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4125 case FILE_TYPE_DISK
:
4126 buf
->st_mode
= S_IFREG
;
4127 if (!GetFileInformationByHandle (fh
, &info
))
4133 case FILE_TYPE_PIPE
:
4134 buf
->st_mode
= S_IFIFO
;
4136 case FILE_TYPE_CHAR
:
4137 case FILE_TYPE_UNKNOWN
:
4139 buf
->st_mode
= S_IFCHR
;
4141 memset (&info
, 0, sizeof (info
));
4142 info
.dwFileAttributes
= 0;
4143 info
.ftCreationTime
= utc_base_ft
;
4144 info
.ftLastAccessTime
= utc_base_ft
;
4145 info
.ftLastWriteTime
= utc_base_ft
;
4148 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4149 buf
->st_mode
= S_IFDIR
;
4151 buf
->st_nlink
= info
.nNumberOfLinks
;
4152 /* Might as well use file index to fake inode values, but this
4153 is not guaranteed to be unique unless we keep a handle open
4154 all the time (even then there are situations where it is
4155 not unique). Reputedly, there are at most 48 bits of info
4156 (on NTFS, presumably less on FAT). */
4157 fake_inode
= info
.nFileIndexHigh
;
4159 fake_inode
+= info
.nFileIndexLow
;
4161 /* MSVC defines _ino_t to be short; other libc's might not. */
4162 if (sizeof (buf
->st_ino
) == 2)
4163 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4165 buf
->st_ino
= fake_inode
;
4167 /* Consider files to belong to current user.
4168 FIXME: this should use GetSecurityInfo API, but it is only
4169 available for _WIN32_WINNT >= 0x501. */
4170 buf
->st_uid
= dflt_passwd
.pw_uid
;
4171 buf
->st_gid
= dflt_passwd
.pw_gid
;
4172 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
4173 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
4175 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4176 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4178 buf
->st_size
= info
.nFileSizeHigh
;
4179 buf
->st_size
<<= 32;
4180 buf
->st_size
+= info
.nFileSizeLow
;
4182 /* Convert timestamps to Unix format. */
4183 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4184 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4185 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4186 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4187 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4189 /* determine rwx permissions */
4190 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4191 permission
= S_IREAD
;
4193 permission
= S_IREAD
| S_IWRITE
;
4195 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4196 permission
|= S_IEXEC
;
4199 #if 0 /* no way of knowing the filename */
4200 char * p
= strrchr (name
, '.');
4202 (xstrcasecmp (p
, ".exe") == 0 ||
4203 xstrcasecmp (p
, ".com") == 0 ||
4204 xstrcasecmp (p
, ".bat") == 0 ||
4205 xstrcasecmp (p
, ".cmd") == 0))
4206 permission
|= S_IEXEC
;
4210 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4216 utime (const char *name
, struct utimbuf
*times
)
4218 struct utimbuf deftime
;
4225 deftime
.modtime
= deftime
.actime
= time (NULL
);
4229 /* Need write access to set times. */
4230 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
4231 /* If NAME specifies a directory, FILE_SHARE_DELETE
4232 allows other processes to delete files inside it,
4233 while we have the directory open. */
4234 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4235 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4236 if (fh
!= INVALID_HANDLE_VALUE
)
4238 convert_from_time_t (times
->actime
, &atime
);
4239 convert_from_time_t (times
->modtime
, &mtime
);
4240 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4257 /* Symlink-related functions. */
4258 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4259 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4263 symlink (char const *filename
, char const *linkname
)
4265 char linkfn
[MAX_PATH
], *tgtfn
;
4267 int dir_access
, filename_ends_in_slash
;
4269 /* Diagnostics follows Posix as much as possible. */
4270 if (filename
== NULL
|| linkname
== NULL
)
4280 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4282 errno
= ENAMETOOLONG
;
4286 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4287 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4293 /* Note: since empty FILENAME was already rejected, we can safely
4294 refer to FILENAME[1]. */
4295 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4297 /* Non-absolute FILENAME is understood as being relative to
4298 LINKNAME's directory. We need to prepend that directory to
4299 FILENAME to get correct results from faccessat below, since
4300 otherwise it will interpret FILENAME relative to the
4301 directory where the Emacs process runs. Note that
4302 make-symbolic-link always makes sure LINKNAME is a fully
4303 expanded file name. */
4305 char *p
= linkfn
+ strlen (linkfn
);
4307 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4310 strncpy (tem
, linkfn
, p
- linkfn
);
4311 tem
[p
- linkfn
] = '\0';
4312 strcat (tem
, filename
);
4313 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4316 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4318 /* Since Windows distinguishes between symlinks to directories and
4319 to files, we provide a kludgy feature: if FILENAME doesn't
4320 exist, but ends in a slash, we create a symlink to directory. If
4321 FILENAME exists and is a directory, we always create a symlink to
4323 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4324 if (dir_access
== 0 || filename_ends_in_slash
)
4325 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4327 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4328 if (filename_ends_in_slash
)
4329 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4332 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4334 /* ENOSYS is set by create_symbolic_link, when it detects that
4335 the OS doesn't support the CreateSymbolicLink API. */
4336 if (errno
!= ENOSYS
)
4338 DWORD w32err
= GetLastError ();
4342 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4343 TGTFN point to the same file name, go figure. */
4345 case ERROR_FILE_EXISTS
:
4348 case ERROR_ACCESS_DENIED
:
4351 case ERROR_FILE_NOT_FOUND
:
4352 case ERROR_PATH_NOT_FOUND
:
4353 case ERROR_BAD_NETPATH
:
4354 case ERROR_INVALID_REPARSE_DATA
:
4357 case ERROR_DIRECTORY
:
4360 case ERROR_PRIVILEGE_NOT_HELD
:
4361 case ERROR_NOT_ALL_ASSIGNED
:
4364 case ERROR_DISK_FULL
:
4377 /* A quick inexpensive test of whether FILENAME identifies a file that
4378 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4379 must already be in the normalized form returned by
4382 Note: for repeated operations on many files, it is best to test
4383 whether the underlying volume actually supports symlinks, by
4384 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4385 avoid the call to this function if it doesn't. That's because the
4386 call to GetFileAttributes takes a non-negligible time, especially
4387 on non-local or removable filesystems. See stat_worker for an
4388 example of how to do that. */
4390 is_symlink (const char *filename
)
4393 WIN32_FIND_DATA wfd
;
4396 attrs
= GetFileAttributes (filename
);
4399 DWORD w32err
= GetLastError ();
4403 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4405 case ERROR_ACCESS_DENIED
:
4408 case ERROR_FILE_NOT_FOUND
:
4409 case ERROR_PATH_NOT_FOUND
:
4416 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4418 logon_network_drive (filename
);
4419 fh
= FindFirstFile (filename
, &wfd
);
4420 if (fh
== INVALID_HANDLE_VALUE
)
4423 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4424 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4427 /* If NAME identifies a symbolic link, copy into BUF the file name of
4428 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4429 null-terminate the target name, even if it fits. Return the number
4430 of bytes copied, or -1 if NAME is not a symlink or any error was
4431 encountered while resolving it. The file name copied into BUF is
4432 encoded in the current ANSI codepage. */
4434 readlink (const char *name
, char *buf
, size_t buf_size
)
4437 TOKEN_PRIVILEGES privs
;
4438 int restore_privs
= 0;
4453 path
= map_w32_filename (name
, NULL
);
4455 if (strlen (path
) > MAX_PATH
)
4457 errno
= ENAMETOOLONG
;
4462 if (is_windows_9x () == TRUE
4463 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4464 || !is_symlink (path
))
4467 errno
= EINVAL
; /* not a symlink */
4471 /* Done with simple tests, now we're in for some _real_ work. */
4472 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4474 /* Implementation note: From here and onward, don't return early,
4475 since that will fail to restore the original set of privileges of
4476 the calling thread. */
4478 retval
= -1; /* not too optimistic, are we? */
4480 /* Note: In the next call to CreateFile, we use zero as the 2nd
4481 argument because, when the symlink is a hidden/system file,
4482 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4483 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4484 and directory symlinks. */
4485 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4486 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4488 if (sh
!= INVALID_HANDLE_VALUE
)
4490 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4491 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4494 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4495 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4498 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4502 /* Copy the link target name, in wide characters, from
4503 reparse_data, then convert it to multibyte encoding in
4504 the current locale's codepage. */
4506 BYTE lname
[MAX_PATH
];
4509 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4511 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4512 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4514 /* According to MSDN, PrintNameLength does not include the
4515 terminating null character. */
4516 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4517 memcpy (lwname
, lwname_src
, lwname_len
);
4518 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4520 /* FIXME: Should we use the current file-name coding system
4521 instead of the fixed value of the ANSI codepage? */
4522 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4523 lname
, MAX_PATH
, NULL
, NULL
);
4526 /* WideCharToMultiByte failed. */
4527 DWORD w32err1
= GetLastError ();
4531 case ERROR_INSUFFICIENT_BUFFER
:
4532 errno
= ENAMETOOLONG
;
4534 case ERROR_INVALID_PARAMETER
:
4537 case ERROR_NO_UNICODE_TRANSLATION
:
4547 size_t size_to_copy
= buf_size
;
4549 BYTE
*pend
= p
+ lname_len
;
4551 /* Normalize like dostounix_filename does, but we don't
4552 want to assume that lname is null-terminated. */
4553 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4561 /* Testing for null-terminated LNAME is paranoia:
4562 WideCharToMultiByte should always return a
4563 null-terminated string when its 4th argument is -1
4564 and its 3rd argument is null-terminated (which they
4566 if (lname
[lname_len
- 1] == '\0')
4568 if (lname_len
<= buf_size
)
4569 size_to_copy
= lname_len
;
4570 strncpy (buf
, lname
, size_to_copy
);
4572 retval
= size_to_copy
;
4579 /* CreateFile failed. */
4580 DWORD w32err2
= GetLastError ();
4584 case ERROR_FILE_NOT_FOUND
:
4585 case ERROR_PATH_NOT_FOUND
:
4588 case ERROR_ACCESS_DENIED
:
4589 case ERROR_TOO_MANY_OPEN_FILES
:
4599 restore_privilege (&privs
);
4606 /* If FILE is a symlink, return its target (stored in a static
4607 buffer); otherwise return FILE.
4609 This function repeatedly resolves symlinks in the last component of
4610 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4611 until it arrives at a file whose last component is not a symlink,
4612 or some error occurs. It returns the target of the last
4613 successfully resolved symlink in the chain. If it succeeds to
4614 resolve even a single symlink, the value returned is an absolute
4615 file name with backslashes (result of GetFullPathName). By
4616 contrast, if the original FILE is returned, it is unaltered.
4618 Note: This function can set errno even if it succeeds.
4620 Implementation note: we only resolve the last portion ("basename")
4621 of the argument FILE and of each following file in the chain,
4622 disregarding any possible symlinks in its leading directories.
4623 This is because Windows system calls and library functions
4624 transparently resolve symlinks in leading directories and return
4625 correct information, as long as the basename is not a symlink. */
4627 chase_symlinks (const char *file
)
4629 static char target
[MAX_PATH
];
4630 char link
[MAX_PATH
];
4631 ssize_t res
, link_len
;
4634 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4635 return (char *)file
;
4637 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4638 return (char *)file
;
4643 /* Remove trailing slashes, as we want to resolve the last
4644 non-trivial part of the link name. */
4645 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4646 link
[link_len
--] = '\0';
4648 res
= readlink (link
, target
, MAX_PATH
);
4652 if (!(IS_DEVICE_SEP (target
[1])
4653 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4655 /* Target is relative. Append it to the directory part of
4656 the symlink, then copy the result back to target. */
4657 char *p
= link
+ link_len
;
4659 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4662 strcpy (target
, link
);
4664 /* Resolve any "." and ".." to get a fully-qualified file name
4666 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4668 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4670 if (loop_count
> 100)
4673 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4674 return (char *)file
;
4679 /* Posix ACL emulation. */
4682 acl_valid (acl_t acl
)
4684 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
4688 acl_to_text (acl_t acl
, ssize_t
*size
)
4691 SECURITY_INFORMATION flags
=
4692 OWNER_SECURITY_INFORMATION
|
4693 GROUP_SECURITY_INFORMATION
|
4694 DACL_SECURITY_INFORMATION
;
4695 char *retval
= NULL
;
4701 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
4704 /* We don't want to mix heaps, so we duplicate the string in our
4705 heap and free the one allocated by the API. */
4706 retval
= xstrdup (str_acl
);
4709 LocalFree (str_acl
);
4711 else if (errno
!= ENOTSUP
)
4718 acl_from_text (const char *acl_str
)
4720 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
4726 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
4729 retval
= xmalloc (sd_size
);
4730 memcpy (retval
, psd
, sd_size
);
4733 else if (errno
!= ENOTSUP
)
4740 acl_free (void *ptr
)
4747 acl_get_file (const char *fname
, acl_type_t type
)
4749 PSECURITY_DESCRIPTOR psd
= NULL
;
4750 const char *filename
;
4752 if (type
== ACL_TYPE_ACCESS
)
4755 SECURITY_INFORMATION si
=
4756 OWNER_SECURITY_INFORMATION
|
4757 GROUP_SECURITY_INFORMATION
|
4758 DACL_SECURITY_INFORMATION
;
4761 filename
= map_w32_filename (fname
, NULL
);
4762 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4763 fname
= chase_symlinks (filename
);
4768 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
4769 && errno
!= ENOTSUP
)
4771 err
= GetLastError ();
4772 if (err
== ERROR_INSUFFICIENT_BUFFER
)
4774 psd
= xmalloc (sd_len
);
4775 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4782 else if (err
== ERROR_FILE_NOT_FOUND
4783 || err
== ERROR_PATH_NOT_FOUND
)
4791 else if (type
!= ACL_TYPE_DEFAULT
)
4798 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
4800 TOKEN_PRIVILEGES old1
, old2
;
4803 int st
= 0, retval
= -1;
4804 SECURITY_INFORMATION flags
= 0;
4810 const char *filename
;
4812 if (acl_valid (acl
) != 0
4813 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
4819 if (type
== ACL_TYPE_DEFAULT
)
4825 filename
= map_w32_filename (fname
, NULL
);
4826 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4827 fname
= chase_symlinks (filename
);
4831 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
4833 flags
|= OWNER_SECURITY_INFORMATION
;
4834 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
4836 flags
|= GROUP_SECURITY_INFORMATION
;
4837 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
4840 flags
|= DACL_SECURITY_INFORMATION
;
4844 /* According to KB-245153, setting the owner will succeed if either:
4845 (1) the caller is the user who will be the new owner, and has the
4846 SE_TAKE_OWNERSHIP privilege, or
4847 (2) the caller has the SE_RESTORE privilege, in which case she can
4848 set any valid user or group as the owner
4850 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
4851 privileges, and disregard any failures in obtaining them. If
4852 these privileges cannot be obtained, and do not already exist in
4853 the calling thread's security token, this function could fail
4855 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
4857 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
4862 set_file_security ((char *)fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
);
4863 err
= GetLastError ();
4867 restore_privilege (&old2
);
4868 restore_privilege (&old1
);
4872 if (errno
== ENOTSUP
)
4874 else if (err
== ERROR_SUCCESS
)
4879 else if (err
== ERROR_INVALID_OWNER
|| err
== ERROR_NOT_ALL_ASSIGNED
)
4881 /* Maybe the requested ACL and the one the file already has are
4882 identical, in which case we can silently ignore the
4883 failure. (And no, Windows doesn't.) */
4884 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
4889 char *acl_from
= acl_to_text (current_acl
, NULL
);
4890 char *acl_to
= acl_to_text (acl
, NULL
);
4892 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
4898 acl_free (acl_from
);
4901 acl_free (current_acl
);
4904 else if (err
== ERROR_FILE_NOT_FOUND
|| err
== ERROR_PATH_NOT_FOUND
)
4911 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4912 have a fixed max size for file names, so we don't need the kind of
4913 alloc/malloc/realloc dance the gnulib version does. We also don't
4914 support FD-relative symlinks. */
4916 careadlinkat (int fd
, char const *filename
,
4917 char *buffer
, size_t buffer_size
,
4918 struct allocator
const *alloc
,
4919 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4921 char linkname
[MAX_PATH
];
4930 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4934 char *retval
= buffer
;
4936 linkname
[link_size
++] = '\0';
4937 if (link_size
> buffer_size
)
4938 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4940 memcpy (retval
, linkname
, link_size
);
4948 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4952 return readlink (filename
, buffer
, buffer_size
);
4956 /* Support for browsing other processes and their attributes. See
4957 process.c for the Lisp bindings. */
4959 /* Helper wrapper functions. */
4961 static HANDLE WINAPI
4962 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4964 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4966 if (g_b_init_create_toolhelp32_snapshot
== 0)
4968 g_b_init_create_toolhelp32_snapshot
= 1;
4969 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4970 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4971 "CreateToolhelp32Snapshot");
4973 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4975 return INVALID_HANDLE_VALUE
;
4977 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4981 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4983 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4985 if (g_b_init_process32_first
== 0)
4987 g_b_init_process32_first
= 1;
4988 s_pfn_Process32_First
= (Process32First_Proc
)
4989 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4992 if (s_pfn_Process32_First
== NULL
)
4996 return (s_pfn_Process32_First (hSnapshot
, lppe
));
5000 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5002 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
5004 if (g_b_init_process32_next
== 0)
5006 g_b_init_process32_next
= 1;
5007 s_pfn_Process32_Next
= (Process32Next_Proc
)
5008 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5011 if (s_pfn_Process32_Next
== NULL
)
5015 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
5019 open_thread_token (HANDLE ThreadHandle
,
5020 DWORD DesiredAccess
,
5022 PHANDLE TokenHandle
)
5024 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
5025 HMODULE hm_advapi32
= NULL
;
5026 if (is_windows_9x () == TRUE
)
5028 SetLastError (ERROR_NOT_SUPPORTED
);
5031 if (g_b_init_open_thread_token
== 0)
5033 g_b_init_open_thread_token
= 1;
5034 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5035 s_pfn_Open_Thread_Token
=
5036 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
5038 if (s_pfn_Open_Thread_Token
== NULL
)
5040 SetLastError (ERROR_NOT_SUPPORTED
);
5044 s_pfn_Open_Thread_Token (
5053 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
5055 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
5056 HMODULE hm_advapi32
= NULL
;
5057 if (is_windows_9x () == TRUE
)
5061 if (g_b_init_impersonate_self
== 0)
5063 g_b_init_impersonate_self
= 1;
5064 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5065 s_pfn_Impersonate_Self
=
5066 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
5068 if (s_pfn_Impersonate_Self
== NULL
)
5072 return s_pfn_Impersonate_Self (ImpersonationLevel
);
5076 revert_to_self (void)
5078 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
5079 HMODULE hm_advapi32
= NULL
;
5080 if (is_windows_9x () == TRUE
)
5084 if (g_b_init_revert_to_self
== 0)
5086 g_b_init_revert_to_self
= 1;
5087 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5088 s_pfn_Revert_To_Self
=
5089 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
5091 if (s_pfn_Revert_To_Self
== NULL
)
5095 return s_pfn_Revert_To_Self ();
5099 get_process_memory_info (HANDLE h_proc
,
5100 PPROCESS_MEMORY_COUNTERS mem_counters
,
5103 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
5104 HMODULE hm_psapi
= NULL
;
5105 if (is_windows_9x () == TRUE
)
5109 if (g_b_init_get_process_memory_info
== 0)
5111 g_b_init_get_process_memory_info
= 1;
5112 hm_psapi
= LoadLibrary ("Psapi.dll");
5114 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
5115 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
5117 if (s_pfn_Get_Process_Memory_Info
== NULL
)
5121 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
5125 get_process_working_set_size (HANDLE h_proc
,
5129 static GetProcessWorkingSetSize_Proc
5130 s_pfn_Get_Process_Working_Set_Size
= NULL
;
5132 if (is_windows_9x () == TRUE
)
5136 if (g_b_init_get_process_working_set_size
== 0)
5138 g_b_init_get_process_working_set_size
= 1;
5139 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
5140 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5141 "GetProcessWorkingSetSize");
5143 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
5147 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
5151 global_memory_status (MEMORYSTATUS
*buf
)
5153 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
5155 if (is_windows_9x () == TRUE
)
5159 if (g_b_init_global_memory_status
== 0)
5161 g_b_init_global_memory_status
= 1;
5162 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
5163 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5164 "GlobalMemoryStatus");
5166 if (s_pfn_Global_Memory_Status
== NULL
)
5170 return s_pfn_Global_Memory_Status (buf
);
5174 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
5176 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
5178 if (is_windows_9x () == TRUE
)
5182 if (g_b_init_global_memory_status_ex
== 0)
5184 g_b_init_global_memory_status_ex
= 1;
5185 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
5186 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5187 "GlobalMemoryStatusEx");
5189 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
5193 return s_pfn_Global_Memory_Status_Ex (buf
);
5197 list_system_processes (void)
5199 struct gcpro gcpro1
;
5200 Lisp_Object proclist
= Qnil
;
5203 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5205 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5207 PROCESSENTRY32 proc_entry
;
5213 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
5214 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
5215 res
= process32_next (h_snapshot
, &proc_entry
))
5217 proc_id
= proc_entry
.th32ProcessID
;
5218 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
5221 CloseHandle (h_snapshot
);
5223 proclist
= Fnreverse (proclist
);
5230 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
5232 TOKEN_PRIVILEGES priv
;
5233 DWORD priv_size
= sizeof (priv
);
5234 DWORD opriv_size
= sizeof (*old_priv
);
5235 HANDLE h_token
= NULL
;
5236 HANDLE h_thread
= GetCurrentThread ();
5240 res
= open_thread_token (h_thread
,
5241 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5243 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
5245 if (impersonate_self (SecurityImpersonation
))
5246 res
= open_thread_token (h_thread
,
5247 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5252 priv
.PrivilegeCount
= 1;
5253 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
5254 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
5255 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
5256 old_priv
, &opriv_size
)
5257 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5261 CloseHandle (h_token
);
5267 restore_privilege (TOKEN_PRIVILEGES
*priv
)
5269 DWORD priv_size
= sizeof (*priv
);
5270 HANDLE h_token
= NULL
;
5273 if (open_thread_token (GetCurrentThread (),
5274 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5277 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
5278 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5282 CloseHandle (h_token
);
5288 ltime (ULONGLONG time_100ns
)
5290 ULONGLONG time_sec
= time_100ns
/ 10000000;
5291 int subsec
= time_100ns
% 10000000;
5292 return list4 (make_number (time_sec
>> 16),
5293 make_number (time_sec
& 0xffff),
5294 make_number (subsec
/ 10),
5295 make_number (subsec
% 10 * 100000));
5298 #define U64_TO_LISP_TIME(time) ltime (time)
5301 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
5302 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
5305 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
5306 ULONGLONG tem1
, tem2
, tem3
, tem
;
5309 || !get_process_times_fn
5310 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
5311 &ft_kernel
, &ft_user
))
5314 GetSystemTimeAsFileTime (&ft_current
);
5316 FILETIME_TO_U64 (tem1
, ft_kernel
);
5317 *stime
= U64_TO_LISP_TIME (tem1
);
5319 FILETIME_TO_U64 (tem2
, ft_user
);
5320 *utime
= U64_TO_LISP_TIME (tem2
);
5323 *ttime
= U64_TO_LISP_TIME (tem3
);
5325 FILETIME_TO_U64 (tem
, ft_creation
);
5326 /* Process no 4 (System) returns zero creation time. */
5329 *ctime
= U64_TO_LISP_TIME (tem
);
5333 FILETIME_TO_U64 (tem3
, ft_current
);
5334 tem
= (tem3
- utc_base
) - tem
;
5336 *etime
= U64_TO_LISP_TIME (tem
);
5340 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
5351 system_process_attributes (Lisp_Object pid
)
5353 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5354 Lisp_Object attrs
= Qnil
;
5355 Lisp_Object cmd_str
, decoded_cmd
, tem
;
5356 HANDLE h_snapshot
, h_proc
;
5359 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
5360 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
5361 DWORD glength
= sizeof (gname
);
5362 HANDLE token
= NULL
;
5363 SID_NAME_USE user_type
;
5364 unsigned char *buf
= NULL
;
5366 TOKEN_USER user_token
;
5367 TOKEN_PRIMARY_GROUP group_token
;
5370 PROCESS_MEMORY_COUNTERS mem
;
5371 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
5372 SIZE_T minrss
, maxrss
;
5374 MEMORY_STATUS_EX memstex
;
5375 double totphys
= 0.0;
5376 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
5378 BOOL result
= FALSE
;
5380 CHECK_NUMBER_OR_FLOAT (pid
);
5381 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
5383 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5385 GCPRO3 (attrs
, decoded_cmd
, tem
);
5387 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5392 pe
.dwSize
= sizeof (PROCESSENTRY32
);
5393 for (res
= process32_first (h_snapshot
, &pe
); res
;
5394 res
= process32_next (h_snapshot
, &pe
))
5396 if (proc_id
== pe
.th32ProcessID
)
5399 decoded_cmd
= build_string ("Idle");
5402 /* Decode the command name from locale-specific
5404 cmd_str
= make_unibyte_string (pe
.szExeFile
,
5405 strlen (pe
.szExeFile
));
5407 code_convert_string_norecord (cmd_str
,
5408 Vlocale_coding_system
, 0);
5410 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
5411 attrs
= Fcons (Fcons (Qppid
,
5412 make_fixnum_or_float (pe
.th32ParentProcessID
)),
5414 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
5416 attrs
= Fcons (Fcons (Qthcount
,
5417 make_fixnum_or_float (pe
.cntThreads
)),
5424 CloseHandle (h_snapshot
);
5433 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5435 /* If we were denied a handle to the process, try again after
5436 enabling the SeDebugPrivilege in our process. */
5439 TOKEN_PRIVILEGES priv_current
;
5441 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
5443 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5445 restore_privilege (&priv_current
);
5451 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
5454 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
5455 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5457 buf
= xmalloc (blen
);
5458 result
= get_token_information (token
, TokenUser
,
5459 (LPVOID
)buf
, blen
, &needed
);
5462 memcpy (&user_token
, buf
, sizeof (user_token
));
5463 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
5465 euid
= get_rid (user_token
.User
.Sid
);
5466 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
5471 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
5474 strcpy (uname
, "unknown");
5478 ulength
= strlen (uname
);
5484 /* Determine a reasonable euid and gid values. */
5485 if (xstrcasecmp ("administrator", uname
) == 0)
5487 euid
= 500; /* well-known Administrator uid */
5488 egid
= 513; /* well-known None gid */
5492 /* Get group id and name. */
5493 result
= get_token_information (token
, TokenPrimaryGroup
,
5494 (LPVOID
)buf
, blen
, &needed
);
5495 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5497 buf
= xrealloc (buf
, blen
= needed
);
5498 result
= get_token_information (token
, TokenPrimaryGroup
,
5499 (LPVOID
)buf
, blen
, &needed
);
5503 memcpy (&group_token
, buf
, sizeof (group_token
));
5504 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5506 egid
= get_rid (group_token
.PrimaryGroup
);
5507 dlength
= sizeof (domain
);
5509 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5510 gname
, &glength
, NULL
, &dlength
,
5513 w32_add_to_cache (group_token
.PrimaryGroup
,
5517 strcpy (gname
, "None");
5521 glength
= strlen (gname
);
5529 if (!is_windows_9x ())
5531 /* We couldn't open the process token, presumably because of
5532 insufficient access rights. Assume this process is run
5534 strcpy (uname
, "SYSTEM");
5535 strcpy (gname
, "None");
5536 euid
= 18; /* SYSTEM */
5537 egid
= 513; /* None */
5538 glength
= strlen (gname
);
5539 ulength
= strlen (uname
);
5541 /* If we are running under Windows 9X, where security calls are
5542 not supported, we assume all processes are run by the current
5544 else if (GetUserName (uname
, &ulength
))
5546 if (xstrcasecmp ("administrator", uname
) == 0)
5551 strcpy (gname
, "None");
5552 glength
= strlen (gname
);
5553 ulength
= strlen (uname
);
5559 strcpy (uname
, "administrator");
5560 ulength
= strlen (uname
);
5561 strcpy (gname
, "None");
5562 glength
= strlen (gname
);
5565 CloseHandle (token
);
5568 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5569 tem
= make_unibyte_string (uname
, ulength
);
5570 attrs
= Fcons (Fcons (Quser
,
5571 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5573 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5574 tem
= make_unibyte_string (gname
, glength
);
5575 attrs
= Fcons (Fcons (Qgroup
,
5576 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5579 if (global_memory_status_ex (&memstex
))
5580 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5581 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5583 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5584 double, so we need to do this for it... */
5586 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5587 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5588 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5590 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5592 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5593 else if (global_memory_status (&memst
))
5594 totphys
= memst
.dwTotalPhys
/ 1024.0;
5597 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5600 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5602 attrs
= Fcons (Fcons (Qmajflt
,
5603 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5605 attrs
= Fcons (Fcons (Qvsize
,
5606 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5608 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5610 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5613 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5615 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5617 attrs
= Fcons (Fcons (Qmajflt
,
5618 make_fixnum_or_float (mem
.PageFaultCount
)),
5620 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5622 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5625 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5627 DWORD rss
= maxrss
/ 1024;
5629 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5631 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5634 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5636 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5637 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5638 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5639 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5640 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5641 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5644 /* FIXME: Retrieve command line by walking the PEB of the process. */
5647 CloseHandle (h_proc
);
5653 /* Wrappers for winsock functions to map between our file descriptors
5654 and winsock's handles; also set h_errno for convenience.
5656 To allow Emacs to run on systems which don't have winsock support
5657 installed, we dynamically link to winsock on startup if present, and
5658 otherwise provide the minimum necessary functionality
5659 (eg. gethostname). */
5661 /* function pointers for relevant socket functions */
5662 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5663 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5664 int (PASCAL
*pfn_WSAGetLastError
) (void);
5665 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5666 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5667 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5668 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5669 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5670 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5671 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5672 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5673 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5674 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5675 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5676 int (PASCAL
*pfn_WSACleanup
) (void);
5678 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5679 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5680 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5681 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5682 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5683 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5684 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5685 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5686 const char * optval
, int optlen
);
5687 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5688 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5690 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5691 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5692 struct sockaddr
* from
, int * fromlen
);
5693 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5694 const struct sockaddr
* to
, int tolen
);
5696 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5697 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5698 #ifndef HANDLE_FLAG_INHERIT
5699 #define HANDLE_FLAG_INHERIT 1
5703 static int winsock_inuse
;
5708 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5710 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5711 after WSAStartup returns successfully, but it seems reasonable
5712 to allow unloading winsock anyway in that case. */
5713 if (pfn_WSACleanup () == 0 ||
5714 pfn_WSAGetLastError () == WSAENETDOWN
)
5716 if (FreeLibrary (winsock_lib
))
5725 init_winsock (int load_now
)
5727 WSADATA winsockData
;
5729 if (winsock_lib
!= NULL
)
5732 pfn_SetHandleInformation
5733 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5734 "SetHandleInformation");
5736 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5738 if (winsock_lib
!= NULL
)
5740 /* dynamically link to socket functions */
5742 #define LOAD_PROC(fn) \
5743 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5746 LOAD_PROC (WSAStartup
);
5747 LOAD_PROC (WSASetLastError
);
5748 LOAD_PROC (WSAGetLastError
);
5749 LOAD_PROC (WSAEventSelect
);
5750 LOAD_PROC (WSACreateEvent
);
5751 LOAD_PROC (WSACloseEvent
);
5754 LOAD_PROC (connect
);
5755 LOAD_PROC (ioctlsocket
);
5758 LOAD_PROC (closesocket
);
5759 LOAD_PROC (shutdown
);
5762 LOAD_PROC (inet_addr
);
5763 LOAD_PROC (gethostname
);
5764 LOAD_PROC (gethostbyname
);
5765 LOAD_PROC (getservbyname
);
5766 LOAD_PROC (getpeername
);
5767 LOAD_PROC (WSACleanup
);
5768 LOAD_PROC (setsockopt
);
5770 LOAD_PROC (getsockname
);
5772 LOAD_PROC (recvfrom
);
5776 /* specify version 1.1 of winsock */
5777 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5779 if (winsockData
.wVersion
!= 0x101)
5784 /* Report that winsock exists and is usable, but leave
5785 socket functions disabled. I am assuming that calling
5786 WSAStartup does not require any network interaction,
5787 and in particular does not cause or require a dial-up
5788 connection to be established. */
5791 FreeLibrary (winsock_lib
);
5799 FreeLibrary (winsock_lib
);
5809 /* function to set h_errno for compatibility; map winsock error codes to
5810 normal system codes where they overlap (non-overlapping definitions
5811 are already in <sys/socket.h> */
5815 if (winsock_lib
== NULL
)
5818 h_errno
= pfn_WSAGetLastError ();
5822 case WSAEACCES
: h_errno
= EACCES
; break;
5823 case WSAEBADF
: h_errno
= EBADF
; break;
5824 case WSAEFAULT
: h_errno
= EFAULT
; break;
5825 case WSAEINTR
: h_errno
= EINTR
; break;
5826 case WSAEINVAL
: h_errno
= EINVAL
; break;
5827 case WSAEMFILE
: h_errno
= EMFILE
; break;
5828 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5829 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5837 if (h_errno
== 0 && winsock_lib
!= NULL
)
5838 pfn_WSASetLastError (0);
5841 /* Extend strerror to handle the winsock-specific error codes. */
5845 } _wsa_errlist
[] = {
5846 {WSAEINTR
, "Interrupted function call"},
5847 {WSAEBADF
, "Bad file descriptor"},
5848 {WSAEACCES
, "Permission denied"},
5849 {WSAEFAULT
, "Bad address"},
5850 {WSAEINVAL
, "Invalid argument"},
5851 {WSAEMFILE
, "Too many open files"},
5853 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5854 {WSAEINPROGRESS
, "Operation now in progress"},
5855 {WSAEALREADY
, "Operation already in progress"},
5856 {WSAENOTSOCK
, "Socket operation on non-socket"},
5857 {WSAEDESTADDRREQ
, "Destination address required"},
5858 {WSAEMSGSIZE
, "Message too long"},
5859 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5860 {WSAENOPROTOOPT
, "Bad protocol option"},
5861 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5862 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5863 {WSAEOPNOTSUPP
, "Operation not supported"},
5864 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5865 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5866 {WSAEADDRINUSE
, "Address already in use"},
5867 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5868 {WSAENETDOWN
, "Network is down"},
5869 {WSAENETUNREACH
, "Network is unreachable"},
5870 {WSAENETRESET
, "Network dropped connection on reset"},
5871 {WSAECONNABORTED
, "Software caused connection abort"},
5872 {WSAECONNRESET
, "Connection reset by peer"},
5873 {WSAENOBUFS
, "No buffer space available"},
5874 {WSAEISCONN
, "Socket is already connected"},
5875 {WSAENOTCONN
, "Socket is not connected"},
5876 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5877 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5878 {WSAETIMEDOUT
, "Connection timed out"},
5879 {WSAECONNREFUSED
, "Connection refused"},
5880 {WSAELOOP
, "Network loop"}, /* not sure */
5881 {WSAENAMETOOLONG
, "Name is too long"},
5882 {WSAEHOSTDOWN
, "Host is down"},
5883 {WSAEHOSTUNREACH
, "No route to host"},
5884 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5885 {WSAEPROCLIM
, "Too many processes"},
5886 {WSAEUSERS
, "Too many users"}, /* not sure */
5887 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5888 {WSAESTALE
, "Data is stale"}, /* not sure */
5889 {WSAEREMOTE
, "Remote error"}, /* not sure */
5891 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5892 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5893 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5894 {WSAEDISCON
, "Graceful shutdown in progress"},
5896 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5897 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5898 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5899 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5900 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5901 {WSASYSCALLFAILURE
, "System call failure"},
5902 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5903 {WSATYPE_NOT_FOUND
, "Class type not found"},
5904 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5905 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5906 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5909 {WSAHOST_NOT_FOUND
, "Host not found"},
5910 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5911 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5912 {WSANO_DATA
, "Valid name, no data record of requested type"},
5918 sys_strerror (int error_no
)
5921 static char unknown_msg
[40];
5923 if (error_no
>= 0 && error_no
< sys_nerr
)
5924 return sys_errlist
[error_no
];
5926 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5927 if (_wsa_errlist
[i
].errnum
== error_no
)
5928 return _wsa_errlist
[i
].msg
;
5930 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5934 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5935 but I believe the method of keeping the socket handle separate (and
5936 insuring it is not inheritable) is the correct one. */
5938 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5940 static int socket_to_fd (SOCKET s
);
5943 sys_socket (int af
, int type
, int protocol
)
5947 if (winsock_lib
== NULL
)
5950 return INVALID_SOCKET
;
5955 /* call the real socket function */
5956 s
= pfn_socket (af
, type
, protocol
);
5958 if (s
!= INVALID_SOCKET
)
5959 return socket_to_fd (s
);
5965 /* Convert a SOCKET to a file descriptor. */
5967 socket_to_fd (SOCKET s
)
5972 /* Although under NT 3.5 _open_osfhandle will accept a socket
5973 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5974 that does not work under NT 3.1. However, we can get the same
5975 effect by using a backdoor function to replace an existing
5976 descriptor handle with the one we want. */
5978 /* allocate a file descriptor (with appropriate flags) */
5979 fd
= _open ("NUL:", _O_RDWR
);
5982 /* Make a non-inheritable copy of the socket handle. Note
5983 that it is possible that sockets aren't actually kernel
5984 handles, which appears to be the case on Windows 9x when
5985 the MS Proxy winsock client is installed. */
5987 /* Apparently there is a bug in NT 3.51 with some service
5988 packs, which prevents using DuplicateHandle to make a
5989 socket handle non-inheritable (causes WSACleanup to
5990 hang). The work-around is to use SetHandleInformation
5991 instead if it is available and implemented. */
5992 if (pfn_SetHandleInformation
)
5994 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5998 HANDLE parent
= GetCurrentProcess ();
5999 HANDLE new_s
= INVALID_HANDLE_VALUE
;
6001 if (DuplicateHandle (parent
,
6007 DUPLICATE_SAME_ACCESS
))
6009 /* It is possible that DuplicateHandle succeeds even
6010 though the socket wasn't really a kernel handle,
6011 because a real handle has the same value. So
6012 test whether the new handle really is a socket. */
6013 long nonblocking
= 0;
6014 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
6016 pfn_closesocket (s
);
6021 CloseHandle (new_s
);
6026 fd_info
[fd
].hnd
= (HANDLE
) s
;
6028 /* set our own internal flags */
6029 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
6035 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6037 /* attach child_process to fd_info */
6038 if (fd_info
[ fd
].cp
!= NULL
)
6040 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
6044 fd_info
[ fd
].cp
= cp
;
6047 winsock_inuse
++; /* count open sockets */
6054 pfn_closesocket (s
);
6060 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
6062 if (winsock_lib
== NULL
)
6065 return SOCKET_ERROR
;
6069 if (fd_info
[s
].flags
& FILE_SOCKET
)
6071 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
6072 if (rc
== SOCKET_ERROR
)
6077 return SOCKET_ERROR
;
6081 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
6083 if (winsock_lib
== NULL
)
6086 return SOCKET_ERROR
;
6090 if (fd_info
[s
].flags
& FILE_SOCKET
)
6092 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
6093 if (rc
== SOCKET_ERROR
)
6098 return SOCKET_ERROR
;
6102 sys_htons (u_short hostshort
)
6104 return (winsock_lib
!= NULL
) ?
6105 pfn_htons (hostshort
) : hostshort
;
6109 sys_ntohs (u_short netshort
)
6111 return (winsock_lib
!= NULL
) ?
6112 pfn_ntohs (netshort
) : netshort
;
6116 sys_inet_addr (const char * cp
)
6118 return (winsock_lib
!= NULL
) ?
6119 pfn_inet_addr (cp
) : INADDR_NONE
;
6123 sys_gethostname (char * name
, int namelen
)
6125 if (winsock_lib
!= NULL
)
6126 return pfn_gethostname (name
, namelen
);
6128 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
6129 return !GetComputerName (name
, (DWORD
*)&namelen
);
6132 return SOCKET_ERROR
;
6136 sys_gethostbyname (const char * name
)
6138 struct hostent
* host
;
6140 if (winsock_lib
== NULL
)
6147 host
= pfn_gethostbyname (name
);
6154 sys_getservbyname (const char * name
, const char * proto
)
6156 struct servent
* serv
;
6158 if (winsock_lib
== NULL
)
6165 serv
= pfn_getservbyname (name
, proto
);
6172 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
6174 if (winsock_lib
== NULL
)
6177 return SOCKET_ERROR
;
6181 if (fd_info
[s
].flags
& FILE_SOCKET
)
6183 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
6184 if (rc
== SOCKET_ERROR
)
6189 return SOCKET_ERROR
;
6193 sys_shutdown (int s
, int how
)
6195 if (winsock_lib
== NULL
)
6198 return SOCKET_ERROR
;
6202 if (fd_info
[s
].flags
& FILE_SOCKET
)
6204 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
6205 if (rc
== SOCKET_ERROR
)
6210 return SOCKET_ERROR
;
6214 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
6216 if (winsock_lib
== NULL
)
6219 return SOCKET_ERROR
;
6223 if (fd_info
[s
].flags
& FILE_SOCKET
)
6225 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
6226 (const char *)optval
, optlen
);
6227 if (rc
== SOCKET_ERROR
)
6232 return SOCKET_ERROR
;
6236 sys_listen (int s
, int backlog
)
6238 if (winsock_lib
== NULL
)
6241 return SOCKET_ERROR
;
6245 if (fd_info
[s
].flags
& FILE_SOCKET
)
6247 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
6248 if (rc
== SOCKET_ERROR
)
6251 fd_info
[s
].flags
|= FILE_LISTEN
;
6255 return SOCKET_ERROR
;
6259 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
6261 if (winsock_lib
== NULL
)
6264 return SOCKET_ERROR
;
6268 if (fd_info
[s
].flags
& FILE_SOCKET
)
6270 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
6271 if (rc
== SOCKET_ERROR
)
6276 return SOCKET_ERROR
;
6280 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
6282 if (winsock_lib
== NULL
)
6289 if (fd_info
[s
].flags
& FILE_LISTEN
)
6291 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
6293 if (t
== INVALID_SOCKET
)
6296 fd
= socket_to_fd (t
);
6298 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6299 ResetEvent (fd_info
[s
].cp
->char_avail
);
6307 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
6308 struct sockaddr
* from
, int * fromlen
)
6310 if (winsock_lib
== NULL
)
6313 return SOCKET_ERROR
;
6317 if (fd_info
[s
].flags
& FILE_SOCKET
)
6319 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
6320 if (rc
== SOCKET_ERROR
)
6325 return SOCKET_ERROR
;
6329 sys_sendto (int s
, const char * buf
, int len
, int flags
,
6330 const struct sockaddr
* to
, int tolen
)
6332 if (winsock_lib
== NULL
)
6335 return SOCKET_ERROR
;
6339 if (fd_info
[s
].flags
& FILE_SOCKET
)
6341 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
6342 if (rc
== SOCKET_ERROR
)
6347 return SOCKET_ERROR
;
6350 /* Windows does not have an fcntl function. Provide an implementation
6351 solely for making sockets non-blocking. */
6353 fcntl (int s
, int cmd
, int options
)
6355 if (winsock_lib
== NULL
)
6362 if (fd_info
[s
].flags
& FILE_SOCKET
)
6364 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
6366 unsigned long nblock
= 1;
6367 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
6368 if (rc
== SOCKET_ERROR
)
6370 /* Keep track of the fact that we set this to non-blocking. */
6371 fd_info
[s
].flags
|= FILE_NDELAY
;
6377 return SOCKET_ERROR
;
6381 return SOCKET_ERROR
;
6385 /* Shadow main io functions: we need to handle pipes and sockets more
6386 intelligently, and implement non-blocking mode as well. */
6399 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
6401 child_process
* cp
= fd_info
[fd
].cp
;
6403 fd_info
[fd
].cp
= NULL
;
6405 if (CHILD_ACTIVE (cp
))
6407 /* if last descriptor to active child_process then cleanup */
6409 for (i
= 0; i
< MAXDESC
; i
++)
6413 if (fd_info
[i
].cp
== cp
)
6418 if (fd_info
[fd
].flags
& FILE_SOCKET
)
6420 if (winsock_lib
== NULL
) emacs_abort ();
6422 pfn_shutdown (SOCK_HANDLE (fd
), 2);
6423 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
6425 winsock_inuse
--; /* count open sockets */
6427 /* If the process handle is NULL, it's either a socket
6428 or serial connection, or a subprocess that was
6429 already reaped by reap_subprocess, but whose
6430 resources were not yet freed, because its output was
6431 not fully read yet by the time it was reaped. (This
6432 usually happens with async subprocesses whose output
6433 is being read by Emacs.) Otherwise, this process was
6434 not reaped yet, so we set its FD to a negative value
6435 to make sure sys_select will eventually get to
6436 calling the SIGCHLD handler for it, which will then
6437 invoke waitpid and reap_subprocess. */
6438 if (cp
->procinfo
.hProcess
== NULL
)
6446 /* Note that sockets do not need special treatment here (at least on
6447 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6448 closesocket is equivalent to CloseHandle, which is to be expected
6449 because socket handles are fully fledged kernel handles. */
6452 if (rc
== 0 && fd
< MAXDESC
)
6453 fd_info
[fd
].flags
= 0;
6464 if (new_fd
>= 0 && new_fd
< MAXDESC
)
6466 /* duplicate our internal info as well */
6467 fd_info
[new_fd
] = fd_info
[fd
];
6473 sys_dup2 (int src
, int dst
)
6477 if (dst
< 0 || dst
>= MAXDESC
)
6483 /* make sure we close the destination first if it's a pipe or socket */
6484 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
6487 rc
= _dup2 (src
, dst
);
6490 /* duplicate our internal info as well */
6491 fd_info
[dst
] = fd_info
[src
];
6496 /* Unix pipe() has only one arg */
6498 sys_pipe (int * phandles
)
6503 /* make pipe handles non-inheritable; when we spawn a child, we
6504 replace the relevant handle with an inheritable one. Also put
6505 pipes into binary mode; we will do text mode translation ourselves
6507 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
6511 /* Protect against overflow, since Windows can open more handles than
6512 our fd_info array has room for. */
6513 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
6515 _close (phandles
[0]);
6516 _close (phandles
[1]);
6521 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6522 fd_info
[phandles
[0]].flags
= flags
;
6524 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6525 fd_info
[phandles
[1]].flags
= flags
;
6532 /* Function to do blocking read of one byte, needed to implement
6533 select. It is only allowed on communication ports, sockets, or
6536 _sys_read_ahead (int fd
)
6541 if (fd
< 0 || fd
>= MAXDESC
)
6542 return STATUS_READ_ERROR
;
6544 cp
= fd_info
[fd
].cp
;
6546 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6547 return STATUS_READ_ERROR
;
6549 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6550 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6552 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6556 cp
->status
= STATUS_READ_IN_PROGRESS
;
6558 if (fd_info
[fd
].flags
& FILE_PIPE
)
6560 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6562 /* Give subprocess time to buffer some more output for us before
6563 reporting that input is available; we need this because Windows 95
6564 connects DOS programs to pipes by making the pipe appear to be
6565 the normal console stdout - as a result most DOS programs will
6566 write to stdout without buffering, ie. one character at a
6567 time. Even some W32 programs do this - "dir" in a command
6568 shell on NT is very slow if we don't do this. */
6571 int wait
= w32_pipe_read_delay
;
6577 /* Yield remainder of our time slice, effectively giving a
6578 temporary priority boost to the child process. */
6582 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6584 HANDLE hnd
= fd_info
[fd
].hnd
;
6585 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6588 /* Configure timeouts for blocking read. */
6589 if (!GetCommTimeouts (hnd
, &ct
))
6590 return STATUS_READ_ERROR
;
6591 ct
.ReadIntervalTimeout
= 0;
6592 ct
.ReadTotalTimeoutMultiplier
= 0;
6593 ct
.ReadTotalTimeoutConstant
= 0;
6594 if (!SetCommTimeouts (hnd
, &ct
))
6595 return STATUS_READ_ERROR
;
6597 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6599 if (GetLastError () != ERROR_IO_PENDING
)
6600 return STATUS_READ_ERROR
;
6601 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6602 return STATUS_READ_ERROR
;
6605 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6607 unsigned long nblock
= 0;
6608 /* We always want this to block, so temporarily disable NDELAY. */
6609 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6610 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6612 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6614 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6617 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6621 if (rc
== sizeof (char))
6622 cp
->status
= STATUS_READ_SUCCEEDED
;
6624 cp
->status
= STATUS_READ_FAILED
;
6630 _sys_wait_accept (int fd
)
6636 if (fd
< 0 || fd
>= MAXDESC
)
6637 return STATUS_READ_ERROR
;
6639 cp
= fd_info
[fd
].cp
;
6641 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6642 return STATUS_READ_ERROR
;
6644 cp
->status
= STATUS_READ_FAILED
;
6646 hEv
= pfn_WSACreateEvent ();
6647 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6648 if (rc
!= SOCKET_ERROR
)
6650 rc
= WaitForSingleObject (hEv
, INFINITE
);
6651 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6652 if (rc
== WAIT_OBJECT_0
)
6653 cp
->status
= STATUS_READ_SUCCEEDED
;
6655 pfn_WSACloseEvent (hEv
);
6661 sys_read (int fd
, char * buffer
, unsigned int count
)
6666 char * orig_buffer
= buffer
;
6674 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6676 child_process
*cp
= fd_info
[fd
].cp
;
6678 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6686 /* re-read CR carried over from last read */
6687 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6689 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6693 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6696 /* presence of a child_process structure means we are operating in
6697 non-blocking mode - otherwise we just call _read directly.
6698 Note that the child_process structure might be missing because
6699 reap_subprocess has been called; in this case the pipe is
6700 already broken, so calling _read on it is okay. */
6703 int current_status
= cp
->status
;
6705 switch (current_status
)
6707 case STATUS_READ_FAILED
:
6708 case STATUS_READ_ERROR
:
6709 /* report normal EOF if nothing in buffer */
6711 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6714 case STATUS_READ_READY
:
6715 case STATUS_READ_IN_PROGRESS
:
6716 DebPrint (("sys_read called when read is in progress\n"));
6717 errno
= EWOULDBLOCK
;
6720 case STATUS_READ_SUCCEEDED
:
6721 /* consume read-ahead char */
6722 *buffer
++ = cp
->chr
;
6725 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6726 ResetEvent (cp
->char_avail
);
6728 case STATUS_READ_ACKNOWLEDGED
:
6732 DebPrint (("sys_read: bad status %d\n", current_status
));
6737 if (fd_info
[fd
].flags
& FILE_PIPE
)
6739 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6740 to_read
= min (waiting
, (DWORD
) count
);
6743 nchars
+= _read (fd
, buffer
, to_read
);
6745 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6747 HANDLE hnd
= fd_info
[fd
].hnd
;
6748 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6754 /* Configure timeouts for non-blocking read. */
6755 if (!GetCommTimeouts (hnd
, &ct
))
6760 ct
.ReadIntervalTimeout
= MAXDWORD
;
6761 ct
.ReadTotalTimeoutMultiplier
= 0;
6762 ct
.ReadTotalTimeoutConstant
= 0;
6763 if (!SetCommTimeouts (hnd
, &ct
))
6769 if (!ResetEvent (ovl
->hEvent
))
6774 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6776 if (GetLastError () != ERROR_IO_PENDING
)
6781 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6790 else /* FILE_SOCKET */
6792 if (winsock_lib
== NULL
) emacs_abort ();
6794 /* do the equivalent of a non-blocking read */
6795 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6796 if (waiting
== 0 && nchars
== 0)
6798 h_errno
= errno
= EWOULDBLOCK
;
6804 /* always use binary mode for sockets */
6805 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6806 if (res
== SOCKET_ERROR
)
6808 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6809 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6819 int nread
= _read (fd
, buffer
, count
);
6822 else if (nchars
== 0)
6827 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6828 /* Perform text mode translation if required. */
6829 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6831 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6832 /* If buffer contains only CR, return that. To be absolutely
6833 sure we should attempt to read the next char, but in
6834 practice a CR to be followed by LF would not appear by
6835 itself in the buffer. */
6836 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6838 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6844 nchars
= _read (fd
, buffer
, count
);
6849 /* From w32xfns.c */
6850 extern HANDLE interrupt_handle
;
6852 /* For now, don't bother with a non-blocking mode */
6854 sys_write (int fd
, const void * buffer
, unsigned int count
)
6864 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6866 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6872 /* Perform text mode translation if required. */
6873 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6875 char * tmpbuf
= alloca (count
* 2);
6876 unsigned char * src
= (void *)buffer
;
6877 unsigned char * dst
= tmpbuf
;
6882 unsigned char *next
;
6883 /* copy next line or remaining bytes */
6884 next
= _memccpy (dst
, src
, '\n', nbytes
);
6887 /* copied one line ending with '\n' */
6888 int copied
= next
- dst
;
6891 /* insert '\r' before '\n' */
6898 /* copied remaining partial line -> now finished */
6905 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6907 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6908 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6909 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6912 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6914 if (GetLastError () != ERROR_IO_PENDING
)
6919 if (detect_input_pending ())
6920 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6923 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6924 if (active
== WAIT_OBJECT_0
)
6925 { /* User pressed C-g, cancel write, then leave. Don't bother
6926 cleaning up as we may only get stuck in buggy drivers. */
6927 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6932 if (active
== WAIT_OBJECT_0
+ 1
6933 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6940 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6942 unsigned long nblock
= 0;
6943 if (winsock_lib
== NULL
) emacs_abort ();
6945 /* TODO: implement select() properly so non-blocking I/O works. */
6946 /* For now, make sure the write blocks. */
6947 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6948 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6950 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6952 /* Set the socket back to non-blocking if it was before,
6953 for other operations that support it. */
6954 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6957 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6960 if (nchars
== SOCKET_ERROR
)
6962 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6963 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6969 /* Some networked filesystems don't like too large writes, so
6970 break them into smaller chunks. See the Comments section of
6971 the MSDN documentation of WriteFile for details behind the
6972 choice of the value of CHUNK below. See also the thread
6973 http://thread.gmane.org/gmane.comp.version-control.git/145294
6974 in the git mailing list. */
6975 const unsigned char *p
= buffer
;
6976 const unsigned chunk
= 30 * 1024 * 1024;
6981 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6982 int n
= _write (fd
, p
, this_chunk
);
6990 else if (n
< this_chunk
)
7000 /* The Windows CRT functions are "optimized for speed", so they don't
7001 check for timezone and DST changes if they were last called less
7002 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
7003 all Emacs features that repeatedly call time functions (e.g.,
7004 display-time) are in real danger of missing timezone and DST
7005 changes. Calling tzset before each localtime call fixes that. */
7007 sys_localtime (const time_t *t
)
7010 return localtime (t
);
7015 /* Try loading LIBRARY_ID from the file(s) specified in
7016 Vdynamic_library_alist. If the library is loaded successfully,
7017 return the handle of the DLL, and record the filename in the
7018 property :loaded-from of LIBRARY_ID. If the library could not be
7019 found, or when it was already loaded (because the handle is not
7020 recorded anywhere, and so is lost after use), return NULL.
7022 We could also save the handle in :loaded-from, but currently
7023 there's no use case for it. */
7025 w32_delayed_load (Lisp_Object library_id
)
7027 HMODULE library_dll
= NULL
;
7029 CHECK_SYMBOL (library_id
);
7031 if (CONSP (Vdynamic_library_alist
)
7032 && NILP (Fassq (library_id
, Vlibrary_cache
)))
7034 Lisp_Object found
= Qnil
;
7035 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
7038 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
7040 CHECK_STRING_CAR (dlls
);
7041 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
7043 char name
[MAX_PATH
];
7046 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
7047 found
= Fcons (XCAR (dlls
),
7049 /* Possibly truncated */
7050 ? make_specified_string (name
, -1, len
, 1)
7056 Fput (library_id
, QCloaded_from
, found
);
7064 check_windows_init_file (void)
7066 /* A common indication that Emacs is not installed properly is when
7067 it cannot find the Windows installation file. If this file does
7068 not exist in the expected place, tell the user. */
7070 if (!noninteractive
&& !inhibit_window_system
7071 /* Vload_path is not yet initialized when we are loading
7073 && NILP (Vpurify_flag
))
7075 Lisp_Object init_file
;
7078 init_file
= build_string ("term/w32-win");
7079 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
7082 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
7083 char *init_file_name
= SDATA (init_file
);
7084 char *load_path
= SDATA (load_path_print
);
7085 char *buffer
= alloca (1024
7086 + strlen (init_file_name
)
7087 + strlen (load_path
));
7090 "The Emacs Windows initialization file \"%s.el\" "
7091 "could not be found in your Emacs installation. "
7092 "Emacs checked the following directories for this file:\n"
7094 "When Emacs cannot find this file, it usually means that it "
7095 "was not installed properly, or its distribution file was "
7096 "not unpacked properly.\nSee the README.W32 file in the "
7097 "top-level Emacs directory for more information.",
7098 init_file_name
, load_path
);
7101 "Emacs Abort Dialog",
7102 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
7103 /* Use the low-level system abort. */
7114 term_ntproc (int ignored
)
7120 /* shutdown the socket interface if necessary */
7127 init_ntproc (int dumping
)
7129 sigset_t initial_mask
= 0;
7131 /* Initialize the socket interface now if available and requested by
7132 the user by defining PRELOAD_WINSOCK; otherwise loading will be
7133 delayed until open-network-stream is called (w32-has-winsock can
7134 also be used to dynamically load or reload winsock).
7136 Conveniently, init_environment is called before us, so
7137 PRELOAD_WINSOCK can be set in the registry. */
7139 /* Always initialize this correctly. */
7142 if (getenv ("PRELOAD_WINSOCK") != NULL
)
7143 init_winsock (TRUE
);
7145 /* Initial preparation for subprocess support: replace our standard
7146 handles with non-inheritable versions. */
7149 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
7150 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
7151 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
7153 parent
= GetCurrentProcess ();
7155 /* ignore errors when duplicating and closing; typically the
7156 handles will be invalid when running as a gui program. */
7157 DuplicateHandle (parent
,
7158 GetStdHandle (STD_INPUT_HANDLE
),
7163 DUPLICATE_SAME_ACCESS
);
7165 DuplicateHandle (parent
,
7166 GetStdHandle (STD_OUTPUT_HANDLE
),
7171 DUPLICATE_SAME_ACCESS
);
7173 DuplicateHandle (parent
,
7174 GetStdHandle (STD_ERROR_HANDLE
),
7179 DUPLICATE_SAME_ACCESS
);
7185 if (stdin_save
!= INVALID_HANDLE_VALUE
)
7186 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
7188 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
7191 if (stdout_save
!= INVALID_HANDLE_VALUE
)
7192 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
7194 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7197 if (stderr_save
!= INVALID_HANDLE_VALUE
)
7198 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
7200 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7204 /* unfortunately, atexit depends on implementation of malloc */
7205 /* atexit (term_ntproc); */
7208 /* Make sure we start with all signals unblocked. */
7209 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
7210 signal (SIGABRT
, term_ntproc
);
7214 /* determine which drives are fixed, for GetCachedVolumeInformation */
7216 /* GetDriveType must have trailing backslash. */
7217 char drive
[] = "A:\\";
7219 /* Loop over all possible drive letters */
7220 while (*drive
<= 'Z')
7222 /* Record if this drive letter refers to a fixed drive. */
7223 fixed_drives
[DRIVE_INDEX (*drive
)] =
7224 (GetDriveType (drive
) == DRIVE_FIXED
);
7229 /* Reset the volume info cache. */
7230 volume_cache
= NULL
;
7235 shutdown_handler ensures that buffers' autosave files are
7236 up to date when the user logs off, or the system shuts down.
7239 shutdown_handler (DWORD type
)
7241 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
7242 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
7243 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
7244 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
7246 /* Shut down cleanly, making sure autosave files are up to date. */
7247 shut_down_emacs (0, Qnil
);
7250 /* Allow other handlers to handle this signal. */
7255 globals_of_w32 is used to initialize those global variables that
7256 must always be initialized on startup even when the global variable
7257 initialized is non zero (see the function main in emacs.c).
7260 globals_of_w32 (void)
7262 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
7264 get_process_times_fn
= (GetProcessTimes_Proc
)
7265 GetProcAddress (kernel32
, "GetProcessTimes");
7267 DEFSYM (QCloaded_from
, ":loaded-from");
7269 g_b_init_is_windows_9x
= 0;
7270 g_b_init_open_process_token
= 0;
7271 g_b_init_get_token_information
= 0;
7272 g_b_init_lookup_account_sid
= 0;
7273 g_b_init_get_sid_sub_authority
= 0;
7274 g_b_init_get_sid_sub_authority_count
= 0;
7275 g_b_init_get_security_info
= 0;
7276 g_b_init_get_file_security
= 0;
7277 g_b_init_get_security_descriptor_owner
= 0;
7278 g_b_init_get_security_descriptor_group
= 0;
7279 g_b_init_is_valid_sid
= 0;
7280 g_b_init_create_toolhelp32_snapshot
= 0;
7281 g_b_init_process32_first
= 0;
7282 g_b_init_process32_next
= 0;
7283 g_b_init_open_thread_token
= 0;
7284 g_b_init_impersonate_self
= 0;
7285 g_b_init_revert_to_self
= 0;
7286 g_b_init_get_process_memory_info
= 0;
7287 g_b_init_get_process_working_set_size
= 0;
7288 g_b_init_global_memory_status
= 0;
7289 g_b_init_global_memory_status_ex
= 0;
7290 g_b_init_equal_sid
= 0;
7291 g_b_init_copy_sid
= 0;
7292 g_b_init_get_length_sid
= 0;
7293 g_b_init_get_native_system_info
= 0;
7294 g_b_init_get_system_times
= 0;
7295 g_b_init_create_symbolic_link
= 0;
7296 g_b_init_get_security_descriptor_dacl
= 0;
7297 g_b_init_convert_sd_to_sddl
= 0;
7298 g_b_init_convert_sddl_to_sd
= 0;
7299 g_b_init_is_valid_security_descriptor
= 0;
7300 g_b_init_set_file_security
= 0;
7301 num_of_processors
= 0;
7302 /* The following sets a handler for shutdown notifications for
7303 console apps. This actually applies to Emacs in both console and
7304 GUI modes, since we had to fool windows into thinking emacs is a
7305 console application to get console mode to work. */
7306 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
7308 /* "None" is the default group name on standalone workstations. */
7309 strcpy (dflt_group_name
, "None");
7311 /* Reset, in case it has some value inherited from dump time. */
7312 w32_stat_get_owner_group
= 0;
7315 /* For make-serial-process */
7317 serial_open (char *port
)
7323 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
7324 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
7325 if (hnd
== INVALID_HANDLE_VALUE
)
7326 error ("Could not open %s", port
);
7327 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
7329 error ("Could not open %s", port
);
7333 error ("Could not create child process");
7335 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7336 fd_info
[ fd
].hnd
= hnd
;
7337 fd_info
[ fd
].flags
|=
7338 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
7339 if (fd_info
[ fd
].cp
!= NULL
)
7341 error ("fd_info[fd = %d] is already in use", fd
);
7343 fd_info
[ fd
].cp
= cp
;
7344 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7345 if (cp
->ovl_read
.hEvent
== NULL
)
7346 error ("Could not create read event");
7347 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7348 if (cp
->ovl_write
.hEvent
== NULL
)
7349 error ("Could not create write event");
7354 /* For serial-process-configure */
7356 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
7358 Lisp_Object childp2
= Qnil
;
7359 Lisp_Object tem
= Qnil
;
7363 char summary
[4] = "???"; /* This usually becomes "8N1". */
7365 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
7366 error ("Not a serial process");
7367 hnd
= fd_info
[ p
->outfd
].hnd
;
7369 childp2
= Fcopy_sequence (p
->childp
);
7371 /* Initialize timeouts for blocking read and blocking write. */
7372 if (!GetCommTimeouts (hnd
, &ct
))
7373 error ("GetCommTimeouts() failed");
7374 ct
.ReadIntervalTimeout
= 0;
7375 ct
.ReadTotalTimeoutMultiplier
= 0;
7376 ct
.ReadTotalTimeoutConstant
= 0;
7377 ct
.WriteTotalTimeoutMultiplier
= 0;
7378 ct
.WriteTotalTimeoutConstant
= 0;
7379 if (!SetCommTimeouts (hnd
, &ct
))
7380 error ("SetCommTimeouts() failed");
7381 /* Read port attributes and prepare default configuration. */
7382 memset (&dcb
, 0, sizeof (dcb
));
7383 dcb
.DCBlength
= sizeof (DCB
);
7384 if (!GetCommState (hnd
, &dcb
))
7385 error ("GetCommState() failed");
7388 dcb
.fAbortOnError
= FALSE
;
7389 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7394 /* Configure speed. */
7395 if (!NILP (Fplist_member (contact
, QCspeed
)))
7396 tem
= Fplist_get (contact
, QCspeed
);
7398 tem
= Fplist_get (p
->childp
, QCspeed
);
7400 dcb
.BaudRate
= XINT (tem
);
7401 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
7403 /* Configure bytesize. */
7404 if (!NILP (Fplist_member (contact
, QCbytesize
)))
7405 tem
= Fplist_get (contact
, QCbytesize
);
7407 tem
= Fplist_get (p
->childp
, QCbytesize
);
7409 tem
= make_number (8);
7411 if (XINT (tem
) != 7 && XINT (tem
) != 8)
7412 error (":bytesize must be nil (8), 7, or 8");
7413 dcb
.ByteSize
= XINT (tem
);
7414 summary
[0] = XINT (tem
) + '0';
7415 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
7417 /* Configure parity. */
7418 if (!NILP (Fplist_member (contact
, QCparity
)))
7419 tem
= Fplist_get (contact
, QCparity
);
7421 tem
= Fplist_get (p
->childp
, QCparity
);
7422 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
7423 error (":parity must be nil (no parity), `even', or `odd'");
7424 dcb
.fParity
= FALSE
;
7425 dcb
.Parity
= NOPARITY
;
7426 dcb
.fErrorChar
= FALSE
;
7431 else if (EQ (tem
, Qeven
))
7435 dcb
.Parity
= EVENPARITY
;
7436 dcb
.fErrorChar
= TRUE
;
7438 else if (EQ (tem
, Qodd
))
7442 dcb
.Parity
= ODDPARITY
;
7443 dcb
.fErrorChar
= TRUE
;
7445 childp2
= Fplist_put (childp2
, QCparity
, tem
);
7447 /* Configure stopbits. */
7448 if (!NILP (Fplist_member (contact
, QCstopbits
)))
7449 tem
= Fplist_get (contact
, QCstopbits
);
7451 tem
= Fplist_get (p
->childp
, QCstopbits
);
7453 tem
= make_number (1);
7455 if (XINT (tem
) != 1 && XINT (tem
) != 2)
7456 error (":stopbits must be nil (1 stopbit), 1, or 2");
7457 summary
[2] = XINT (tem
) + '0';
7458 if (XINT (tem
) == 1)
7459 dcb
.StopBits
= ONESTOPBIT
;
7460 else if (XINT (tem
) == 2)
7461 dcb
.StopBits
= TWOSTOPBITS
;
7462 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
7464 /* Configure flowcontrol. */
7465 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
7466 tem
= Fplist_get (contact
, QCflowcontrol
);
7468 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
7469 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
7470 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7471 dcb
.fOutxCtsFlow
= FALSE
;
7472 dcb
.fOutxDsrFlow
= FALSE
;
7473 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
7474 dcb
.fDsrSensitivity
= FALSE
;
7475 dcb
.fTXContinueOnXoff
= FALSE
;
7478 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
7479 dcb
.XonChar
= 17; /* Control-Q */
7480 dcb
.XoffChar
= 19; /* Control-S */
7483 /* Already configured. */
7485 else if (EQ (tem
, Qhw
))
7487 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
7488 dcb
.fOutxCtsFlow
= TRUE
;
7490 else if (EQ (tem
, Qsw
))
7495 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
7497 /* Activate configuration. */
7498 if (!SetCommState (hnd
, &dcb
))
7499 error ("SetCommState() failed");
7501 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
7502 pset_childp (p
, childp2
);
7508 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
7513 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7514 int fd
= process
->infd
;
7518 n
= sys_read (fd
, (char*)buf
, sz
);
7525 if (err
== EWOULDBLOCK
)
7527 /* Set a small timeout. */
7528 timeout
= make_emacs_time (1, 0);
7530 FD_SET ((int)fd
, &fdset
);
7532 /* Use select with the timeout to poll the selector. */
7533 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7537 continue; /* Try again. */
7539 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7540 Also accept select return 0 as an indicator to EAGAIN. */
7541 if (sc
== 0 || errno
== EWOULDBLOCK
)
7544 err
= errno
; /* Other errors are just passed on. */
7547 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7554 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7556 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7557 int fd
= process
->outfd
;
7558 ssize_t n
= sys_write (fd
, buf
, sz
);
7560 /* 0 or more bytes written means everything went fine. */
7564 /* Negative bytes written means we got an error in errno.
7565 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7566 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7567 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7571 #endif /* HAVE_GNUTLS */