1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994-1995, 2000-2013 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22 #include <stddef.h> /* for offsetof */
25 #include <float.h> /* for DBL_EPSILON */
33 #include <sys/utime.h>
37 /* must include CRT headers *before* config.h */
40 #include <mbstring.h> /* for _mbspbrk and _mbslwr */
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 ());
1534 /* Current codepage for encoding file names. */
1535 static int file_name_codepage
;
1537 /* Return the maximum length in bytes of a multibyte character
1538 sequence encoded in the current ANSI codepage. This is required to
1539 correctly walk the encoded file names one character at a time. */
1541 max_filename_mbslen (void)
1543 /* A simple cache to avoid calling GetCPInfo every time we need to
1544 normalize a file name. The file-name encoding is not supposed to
1545 be changed too frequently, if ever. */
1546 static Lisp_Object last_file_name_encoding
;
1547 static int last_max_mbslen
;
1548 Lisp_Object current_encoding
;
1550 current_encoding
= Vfile_name_coding_system
;
1551 if (NILP (current_encoding
))
1552 current_encoding
= Vdefault_file_name_coding_system
;
1554 if (!EQ (last_file_name_encoding
, current_encoding
))
1558 last_file_name_encoding
= current_encoding
;
1559 /* Default to the current ANSI codepage. */
1560 file_name_codepage
= w32_ansi_code_page
;
1561 if (!NILP (current_encoding
))
1563 char *cpname
= SDATA (SYMBOL_NAME (current_encoding
));
1564 char *cp
= NULL
, *end
;
1567 if (strncmp (cpname
, "cp", 2) == 0)
1569 else if (strncmp (cpname
, "windows-", 8) == 0)
1575 cpnum
= strtol (cp
, &end
, 10);
1576 if (cpnum
&& *end
== '\0' && end
- cp
>= 2)
1577 file_name_codepage
= cpnum
;
1581 if (!file_name_codepage
)
1582 file_name_codepage
= CP_ACP
; /* CP_ACP = 0, but let's not assume that */
1584 if (!GetCPInfo (file_name_codepage
, &cp_info
))
1586 file_name_codepage
= CP_ACP
;
1587 if (!GetCPInfo (file_name_codepage
, &cp_info
))
1590 last_max_mbslen
= cp_info
.MaxCharSize
;
1593 return last_max_mbslen
;
1596 /* Normalize filename by converting all path separators to
1597 the specified separator. Also conditionally convert upper
1598 case path name components to lower case. */
1601 normalize_filename (register char *fp
, char path_sep
)
1605 int dbcs_p
= max_filename_mbslen () > 1;
1607 /* Always lower-case drive letters a-z, even if the filesystem
1608 preserves case in filenames.
1609 This is so filenames can be compared by string comparison
1610 functions that are case-sensitive. Even case-preserving filesystems
1611 do not distinguish case in drive letters. */
1613 p2
= CharNextExA (file_name_codepage
, fp
, 0);
1617 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
1623 if (NILP (Vw32_downcase_file_names
))
1627 if (*fp
== '/' || *fp
== '\\')
1632 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1637 sep
= path_sep
; /* convert to this path separator */
1638 elem
= fp
; /* start of current path element */
1641 if (*fp
>= 'a' && *fp
<= 'z')
1642 elem
= 0; /* don't convert this element */
1644 if (*fp
== 0 || *fp
== ':')
1646 sep
= *fp
; /* restore current separator (or 0) */
1647 *fp
= '/'; /* after conversion of this element */
1650 if (*fp
== '/' || *fp
== '\\')
1652 if (elem
&& elem
!= fp
)
1654 *fp
= 0; /* temporary end of string */
1655 _mbslwr (elem
); /* while we convert to lower case */
1657 *fp
= sep
; /* convert (or restore) path separator */
1658 elem
= fp
+ 1; /* next element starts after separator */
1666 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1671 /* Destructively turn backslashes into slashes. */
1673 dostounix_filename (register char *p
)
1675 normalize_filename (p
, '/');
1678 /* Destructively turn slashes into backslashes. */
1680 unixtodos_filename (register char *p
)
1682 normalize_filename (p
, '\\');
1685 /* Remove all CR's that are followed by a LF.
1686 (From msdos.c...probably should figure out a way to share it,
1687 although this code isn't going to ever change.) */
1689 crlf_to_lf (register int n
, register unsigned char *buf
)
1691 unsigned char *np
= buf
;
1692 unsigned char *startp
= buf
;
1693 unsigned char *endp
= buf
+ n
;
1697 while (buf
< endp
- 1)
1701 if (*(++buf
) != 0x0a)
1712 /* Parse the root part of file name, if present. Return length and
1713 optionally store pointer to char after root. */
1715 parse_root (char * name
, char ** pPath
)
1717 char * start
= name
;
1722 /* find the root name of the volume if given */
1723 if (isalpha (name
[0]) && name
[1] == ':')
1725 /* skip past drive specifier */
1727 if (IS_DIRECTORY_SEP (name
[0]))
1730 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1736 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1741 if (IS_DIRECTORY_SEP (name
[0]))
1748 return name
- start
;
1751 /* Get long base name for name; name is assumed to be absolute. */
1753 get_long_basename (char * name
, char * buf
, int size
)
1755 WIN32_FIND_DATA find_data
;
1759 /* must be valid filename, no wild cards or other invalid characters */
1760 if (_mbspbrk (name
, "*?|<>\""))
1763 dir_handle
= FindFirstFile (name
, &find_data
);
1764 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1766 if ((len
= strlen (find_data
.cFileName
)) < size
)
1767 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1770 FindClose (dir_handle
);
1775 /* Get long name for file, if possible (assumed to be absolute). */
1777 w32_get_long_filename (char * name
, char * buf
, int size
)
1782 char full
[ MAX_PATH
];
1785 len
= strlen (name
);
1786 if (len
>= MAX_PATH
)
1789 /* Use local copy for destructive modification. */
1790 memcpy (full
, name
, len
+1);
1791 unixtodos_filename (full
);
1793 /* Copy root part verbatim. */
1794 len
= parse_root (full
, &p
);
1795 memcpy (o
, full
, len
);
1800 while (p
!= NULL
&& *p
)
1803 p
= strchr (q
, '\\');
1805 len
= get_long_basename (full
, o
, size
);
1828 is_unc_volume (const char *filename
)
1830 const char *ptr
= filename
;
1832 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1835 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1841 /* Emulate the Posix unsetenv. */
1843 unsetenv (const char *name
)
1849 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
1854 name_len
= strlen (name
);
1855 /* MS docs says an environment variable cannot be longer than 32K. */
1856 if (name_len
> 32767)
1861 /* It is safe to use 'alloca' with 32K size, since the stack is at
1862 least 2MB, and we set it to 8MB in the link command line. */
1863 var
= alloca (name_len
+ 2);
1864 strncpy (var
, name
, name_len
);
1865 var
[name_len
++] = '=';
1866 var
[name_len
] = '\0';
1867 return _putenv (var
);
1870 /* MS _putenv doesn't support removing a variable when the argument
1871 does not include the '=' character, so we fix that here. */
1873 sys_putenv (char *str
)
1875 const char *const name_end
= strchr (str
, '=');
1877 if (name_end
== NULL
)
1879 /* Remove the variable from the environment. */
1880 return unsetenv (str
);
1883 return _putenv (str
);
1886 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1889 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1892 HKEY hrootkey
= NULL
;
1895 /* Check both the current user and the local machine to see if
1896 we have any resources. */
1898 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1902 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1903 && (lpvalue
= xmalloc (cbData
)) != NULL
1904 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1906 RegCloseKey (hrootkey
);
1912 RegCloseKey (hrootkey
);
1915 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1919 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1920 && (lpvalue
= xmalloc (cbData
)) != NULL
1921 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1923 RegCloseKey (hrootkey
);
1929 RegCloseKey (hrootkey
);
1935 char *get_emacs_configuration (void);
1938 init_environment (char ** argv
)
1940 static const char * const tempdirs
[] = {
1941 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1946 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1948 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1949 temporary files and assume "/tmp" if $TMPDIR is unset, which
1950 will break on DOS/Windows. Refuse to work if we cannot find
1951 a directory, not even "c:/", usable for that purpose. */
1952 for (i
= 0; i
< imax
; i
++)
1954 const char *tmp
= tempdirs
[i
];
1957 tmp
= getenv (tmp
+ 1);
1958 /* Note that `access' can lie to us if the directory resides on a
1959 read-only filesystem, like CD-ROM or a write-protected floppy.
1960 The only way to be really sure is to actually create a file and
1961 see if it succeeds. But I think that's too much to ask. */
1963 /* MSVCRT's _access crashes with D_OK. */
1964 if (tmp
&& faccessat (AT_FDCWD
, tmp
, D_OK
, AT_EACCESS
) == 0)
1966 char * var
= alloca (strlen (tmp
) + 8);
1967 sprintf (var
, "TMPDIR=%s", tmp
);
1968 _putenv (strdup (var
));
1975 Fcons (build_string ("no usable temporary directories found!!"),
1977 "While setting TMPDIR: ");
1979 /* Check for environment variables and use registry settings if they
1980 don't exist. Fallback on default values where applicable. */
1985 char locale_name
[32];
1986 char default_home
[MAX_PATH
];
1989 static const struct env_entry
1995 /* If the default value is NULL, we will use the value from the
1996 outside environment or the Registry, but will not push the
1997 variable into the Emacs environment if it is defined neither
1998 in the Registry nor in the outside environment. */
2000 {"PRELOAD_WINSOCK", NULL
},
2001 {"emacs_dir", "C:/emacs"},
2002 {"EMACSLOADPATH", NULL
},
2003 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
2004 {"EMACSDATA", NULL
},
2005 {"EMACSPATH", NULL
},
2012 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2014 /* We need to copy dflt_envvars[] and work on the copy because we
2015 don't want the dumped Emacs to inherit the values of
2016 environment variables we saw during dumping (which could be on
2017 a different system). The defaults above must be left intact. */
2018 struct env_entry env_vars
[N_ENV_VARS
];
2020 for (i
= 0; i
< N_ENV_VARS
; i
++)
2021 env_vars
[i
] = dflt_envvars
[i
];
2023 /* For backwards compatibility, check if a .emacs file exists in C:/
2024 If not, then we can try to default to the appdata directory under the
2025 user's profile, which is more likely to be writable. */
2026 if (!check_existing ("C:/.emacs"))
2028 HRESULT profile_result
;
2029 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2030 of Windows 95 and NT4 that have not been updated to include
2032 ShGetFolderPath_fn get_folder_path
;
2033 get_folder_path
= (ShGetFolderPath_fn
)
2034 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2036 if (get_folder_path
!= NULL
)
2038 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2041 /* If we can't get the appdata dir, revert to old behavior. */
2042 if (profile_result
== S_OK
)
2044 env_vars
[0].def_value
= default_home
;
2050 /* Get default locale info and use it for LANG. */
2051 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2052 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2053 locale_name
, sizeof (locale_name
)))
2055 for (i
= 0; i
< N_ENV_VARS
; i
++)
2057 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2059 env_vars
[i
].def_value
= locale_name
;
2065 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2067 /* Treat emacs_dir specially: set it unconditionally based on our
2071 char modname
[MAX_PATH
];
2073 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2075 if ((p
= strrchr (modname
, '\\')) == NULL
)
2079 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
2081 char buf
[SET_ENV_BUF_SIZE
];
2084 for (p
= modname
; *p
; p
++)
2085 if (*p
== '\\') *p
= '/';
2087 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2088 _putenv (strdup (buf
));
2090 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
2092 /* FIXME: should use substring of get_emacs_configuration ().
2093 But I don't think the Windows build supports alpha, mips etc
2094 anymore, so have taken the easy option for now. */
2095 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
2096 || xstrcasecmp (p
, "\\AMD64") == 0))
2099 p
= strrchr (modname
, '\\');
2103 p
= strrchr (modname
, '\\');
2104 if (p
&& xstrcasecmp (p
, "\\src") == 0)
2106 char buf
[SET_ENV_BUF_SIZE
];
2109 for (p
= modname
; *p
; p
++)
2110 if (*p
== '\\') *p
= '/';
2112 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2113 _putenv (strdup (buf
));
2119 for (i
= 0; i
< N_ENV_VARS
; i
++)
2121 if (!getenv (env_vars
[i
].name
))
2125 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2126 /* Also ignore empty environment variables. */
2130 lpval
= env_vars
[i
].def_value
;
2131 dwType
= REG_EXPAND_SZ
;
2133 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
2134 Vdelayed_warnings_list
2135 = Fcons (listn (CONSTYPE_HEAP
, 2,
2136 intern ("initialization"),
2137 build_string ("Setting HOME to C:\\ by default is deprecated")),
2138 Vdelayed_warnings_list
);
2143 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2145 if (dwType
== REG_EXPAND_SZ
)
2146 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2147 else if (dwType
== REG_SZ
)
2148 strcpy (buf1
, lpval
);
2149 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2151 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2153 _putenv (strdup (buf2
));
2163 /* Rebuild system configuration to reflect invoking system. */
2164 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2166 /* Another special case: on NT, the PATH variable is actually named
2167 "Path" although cmd.exe (perhaps NT itself) arranges for
2168 environment variable lookup and setting to be case insensitive.
2169 However, Emacs assumes a fully case sensitive environment, so we
2170 need to change "Path" to "PATH" to match the expectations of
2171 various elisp packages. We do this by the sneaky method of
2172 modifying the string in the C runtime environ entry.
2174 The same applies to COMSPEC. */
2178 for (envp
= environ
; *envp
; envp
++)
2179 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2180 memcpy (*envp
, "PATH=", 5);
2181 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2182 memcpy (*envp
, "COMSPEC=", 8);
2185 /* Remember the initial working directory for getcwd. */
2186 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2187 Does it matter anywhere in Emacs? */
2188 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
2192 static char modname
[MAX_PATH
];
2194 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2199 /* Determine if there is a middle mouse button, to allow parse_button
2200 to decide whether right mouse events should be mouse-2 or
2202 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2207 /* Called from expand-file-name when default-directory is not a string. */
2210 emacs_root_dir (void)
2212 static char root_dir
[FILENAME_MAX
];
2215 p
= getenv ("emacs_dir");
2218 strcpy (root_dir
, p
);
2219 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2220 dostounix_filename (root_dir
);
2224 /* We don't have scripts to automatically determine the system configuration
2225 for Emacs before it's compiled, and we don't want to have to make the
2226 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
2230 get_emacs_configuration (void)
2232 char *arch
, *oem
, *os
;
2234 static char configuration_buffer
[32];
2236 /* Determine the processor type. */
2237 switch (get_processor_type ())
2240 #ifdef PROCESSOR_INTEL_386
2241 case PROCESSOR_INTEL_386
:
2242 case PROCESSOR_INTEL_486
:
2243 case PROCESSOR_INTEL_PENTIUM
:
2251 #ifdef PROCESSOR_AMD_X8664
2252 case PROCESSOR_AMD_X8664
:
2257 #ifdef PROCESSOR_MIPS_R2000
2258 case PROCESSOR_MIPS_R2000
:
2259 case PROCESSOR_MIPS_R3000
:
2260 case PROCESSOR_MIPS_R4000
:
2265 #ifdef PROCESSOR_ALPHA_21064
2266 case PROCESSOR_ALPHA_21064
:
2276 /* Use the OEM field to reflect the compiler/library combination. */
2278 #define COMPILER_NAME "msvc"
2281 #define COMPILER_NAME "mingw"
2283 #define COMPILER_NAME "unknown"
2286 oem
= COMPILER_NAME
;
2288 switch (osinfo_cache
.dwPlatformId
) {
2289 case VER_PLATFORM_WIN32_NT
:
2291 build_num
= osinfo_cache
.dwBuildNumber
;
2293 case VER_PLATFORM_WIN32_WINDOWS
:
2294 if (osinfo_cache
.dwMinorVersion
== 0) {
2299 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2301 case VER_PLATFORM_WIN32s
:
2302 /* Not supported, should not happen. */
2304 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2312 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
2313 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
2314 get_w32_major_version (), get_w32_minor_version (), build_num
);
2316 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
2319 return configuration_buffer
;
2323 get_emacs_configuration_options (void)
2325 static char *options_buffer
;
2326 char cv
[32]; /* Enough for COMPILER_VERSION. */
2328 cv
, /* To be filled later. */
2332 #ifdef ENABLE_CHECKING
2333 " --enable-checking",
2335 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2336 with a starting space to save work here. */
2338 " --cflags", USER_CFLAGS
,
2341 " --ldflags", USER_LDFLAGS
,
2348 /* Work out the effective configure options for this build. */
2350 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2353 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2355 #define COMPILER_VERSION ""
2359 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2360 return "Error: not enough space for compiler version";
2361 cv
[sizeof (cv
) - 1] = '\0';
2363 for (i
= 0; options
[i
]; i
++)
2364 size
+= strlen (options
[i
]);
2366 options_buffer
= xmalloc (size
+ 1);
2367 options_buffer
[0] = '\0';
2369 for (i
= 0; options
[i
]; i
++)
2370 strcat (options_buffer
, options
[i
]);
2372 return options_buffer
;
2376 #include <sys/timeb.h>
2378 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2380 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2385 tv
->tv_sec
= tb
.time
;
2386 tv
->tv_usec
= tb
.millitm
* 1000L;
2387 /* Implementation note: _ftime sometimes doesn't update the dstflag
2388 according to the new timezone when the system timezone is
2389 changed. We could fix that by using GetSystemTime and
2390 GetTimeZoneInformation, but that doesn't seem necessary, since
2391 Emacs always calls gettimeofday with the 2nd argument NULL (see
2392 current_emacs_time). */
2395 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2396 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2400 /* Emulate fdutimens. */
2402 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2403 TIMESPEC[0] and TIMESPEC[1], respectively.
2404 FD must be either negative -- in which case it is ignored --
2405 or a file descriptor that is open on FILE.
2406 If FD is nonnegative, then FILE can be NULL, which means
2407 use just futimes instead of utimes.
2408 If TIMESPEC is null, FAIL.
2409 Return 0 on success, -1 (setting errno) on failure. */
2412 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2421 if (fd
< 0 && !file
)
2426 ut
.actime
= timespec
[0].tv_sec
;
2427 ut
.modtime
= timespec
[1].tv_sec
;
2429 return _futime (fd
, &ut
);
2431 return _utime (file
, &ut
);
2435 /* ------------------------------------------------------------------------- */
2436 /* IO support and wrapper functions for the Windows API. */
2437 /* ------------------------------------------------------------------------- */
2439 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2440 on network directories, so we handle that case here.
2441 (Ulrich Leodolter, 1/11/95). */
2443 sys_ctime (const time_t *t
)
2445 char *str
= (char *) ctime (t
);
2446 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2449 /* Emulate sleep...we could have done this with a define, but that
2450 would necessitate including windows.h in the files that used it.
2451 This is much easier. */
2453 sys_sleep (int seconds
)
2455 Sleep (seconds
* 1000);
2458 /* Internal MSVC functions for low-level descriptor munging */
2459 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2460 extern int __cdecl
_free_osfhnd (int fd
);
2462 /* parallel array of private info on file handles */
2463 filedesc fd_info
[ MAXDESC
];
2465 typedef struct volume_info_data
{
2466 struct volume_info_data
* next
;
2468 /* time when info was obtained */
2471 /* actual volume info */
2480 /* Global referenced by various functions. */
2481 static volume_info_data volume_info
;
2483 /* Vector to indicate which drives are local and fixed (for which cached
2484 data never expires). */
2485 static BOOL fixed_drives
[26];
2487 /* Consider cached volume information to be stale if older than 10s,
2488 at least for non-local drives. Info for fixed drives is never stale. */
2489 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2490 #define VOLINFO_STILL_VALID( root_dir, info ) \
2491 ( ( isalpha (root_dir[0]) && \
2492 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2493 || GetTickCount () - info->timestamp < 10000 )
2495 /* Cache support functions. */
2497 /* Simple linked list with linear search is sufficient. */
2498 static volume_info_data
*volume_cache
= NULL
;
2500 static volume_info_data
*
2501 lookup_volume_info (char * root_dir
)
2503 volume_info_data
* info
;
2505 for (info
= volume_cache
; info
; info
= info
->next
)
2506 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2512 add_volume_info (char * root_dir
, volume_info_data
* info
)
2514 info
->root_dir
= xstrdup (root_dir
);
2515 info
->next
= volume_cache
;
2516 volume_cache
= info
;
2520 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2521 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2522 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2523 static volume_info_data
*
2524 GetCachedVolumeInformation (char * root_dir
)
2526 volume_info_data
* info
;
2527 char default_root
[ MAX_PATH
];
2529 /* NULL for root_dir means use root from current directory. */
2530 if (root_dir
== NULL
)
2532 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2534 parse_root (default_root
, &root_dir
);
2536 root_dir
= default_root
;
2539 /* Local fixed drives can be cached permanently. Removable drives
2540 cannot be cached permanently, since the volume name and serial
2541 number (if nothing else) can change. Remote drives should be
2542 treated as if they are removable, since there is no sure way to
2543 tell whether they are or not. Also, the UNC association of drive
2544 letters mapped to remote volumes can be changed at any time (even
2545 by other processes) without notice.
2547 As a compromise, so we can benefit from caching info for remote
2548 volumes, we use a simple expiry mechanism to invalidate cache
2549 entries that are more than ten seconds old. */
2552 /* No point doing this, because WNetGetConnection is even slower than
2553 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2554 GetDriveType is about the only call of this type which does not
2555 involve network access, and so is extremely quick). */
2557 /* Map drive letter to UNC if remote. */
2558 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2560 char remote_name
[ 256 ];
2561 char drive
[3] = { root_dir
[0], ':' };
2563 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2565 /* do something */ ;
2569 info
= lookup_volume_info (root_dir
);
2571 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2579 /* Info is not cached, or is stale. */
2580 if (!GetVolumeInformation (root_dir
,
2581 name
, sizeof (name
),
2585 type
, sizeof (type
)))
2588 /* Cache the volume information for future use, overwriting existing
2589 entry if present. */
2592 info
= xmalloc (sizeof (volume_info_data
));
2593 add_volume_info (root_dir
, info
);
2601 info
->name
= xstrdup (name
);
2602 info
->serialnum
= serialnum
;
2603 info
->maxcomp
= maxcomp
;
2604 info
->flags
= flags
;
2605 info
->type
= xstrdup (type
);
2606 info
->timestamp
= GetTickCount ();
2612 /* Get information on the volume where NAME is held; set path pointer to
2613 start of pathname in NAME (past UNC header\volume header if present),
2614 if pPath is non-NULL.
2616 Note: if NAME includes symlinks, the information is for the volume
2617 of the symlink, not of its target. That's because, even though
2618 GetVolumeInformation returns information about the symlink target
2619 of its argument, we only pass the root directory to
2620 GetVolumeInformation, not the full NAME. */
2622 get_volume_info (const char * name
, const char ** pPath
)
2624 char temp
[MAX_PATH
];
2625 char *rootname
= NULL
; /* default to current volume */
2626 volume_info_data
* info
;
2631 /* Find the root name of the volume if given. */
2632 if (isalpha (name
[0]) && name
[1] == ':')
2640 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2647 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2660 info
= GetCachedVolumeInformation (rootname
);
2663 /* Set global referenced by other functions. */
2664 volume_info
= *info
;
2670 /* Determine if volume is FAT format (ie. only supports short 8.3
2671 names); also set path pointer to start of pathname in name, if
2672 pPath is non-NULL. */
2674 is_fat_volume (const char * name
, const char ** pPath
)
2676 if (get_volume_info (name
, pPath
))
2677 return (volume_info
.maxcomp
== 12);
2681 /* Map filename to a valid 8.3 name if necessary.
2682 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2684 map_w32_filename (const char * name
, const char ** pPath
)
2686 static char shortname
[MAX_PATH
];
2687 char * str
= shortname
;
2690 const char * save_name
= name
;
2692 if (strlen (name
) >= MAX_PATH
)
2694 /* Return a filename which will cause callers to fail. */
2695 strcpy (shortname
, "?");
2699 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2701 register int left
= 8; /* maximum number of chars in part */
2702 register int extn
= 0; /* extension added? */
2703 register int dots
= 2; /* maximum number of dots allowed */
2706 *str
++ = *name
++; /* skip past UNC header */
2708 while ((c
= *name
++))
2715 *str
++ = (c
== ':' ? ':' : '\\');
2716 extn
= 0; /* reset extension flags */
2717 dots
= 2; /* max 2 dots */
2718 left
= 8; /* max length 8 for main part */
2723 /* Convert path components of the form .xxx to _xxx,
2724 but leave . and .. as they are. This allows .emacs
2725 to be read as _emacs, for example. */
2729 IS_DIRECTORY_SEP (*name
))
2744 extn
= 1; /* we've got an extension */
2745 left
= 3; /* 3 chars in extension */
2749 /* any embedded dots after the first are converted to _ */
2754 case '#': /* don't lose these, they're important */
2756 str
[-1] = c
; /* replace last character of part */
2761 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2763 dots
= 0; /* started a path component */
2772 strcpy (shortname
, name
);
2773 unixtodos_filename (shortname
);
2777 *pPath
= shortname
+ (path
- save_name
);
2783 is_exec (const char * name
)
2785 char * p
= strrchr (name
, '.');
2788 && (xstrcasecmp (p
, ".exe") == 0 ||
2789 xstrcasecmp (p
, ".com") == 0 ||
2790 xstrcasecmp (p
, ".bat") == 0 ||
2791 xstrcasecmp (p
, ".cmd") == 0));
2794 /* Emulate the Unix directory procedures opendir, closedir,
2795 and readdir. We can't use the procedures supplied in sysdep.c,
2796 so we provide them here. */
2798 struct dirent dir_static
; /* simulated directory contents */
2799 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2800 static int dir_is_fat
;
2801 static char dir_pathname
[MAXPATHLEN
+1];
2802 static WIN32_FIND_DATA dir_find_data
;
2804 /* Support shares on a network resource as subdirectories of a read-only
2806 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2807 static HANDLE
open_unc_volume (const char *);
2808 static char *read_unc_volume (HANDLE
, char *, int);
2809 static void close_unc_volume (HANDLE
);
2812 opendir (const char *filename
)
2816 /* Opening is done by FindFirstFile. However, a read is inherent to
2817 this operation, so we defer the open until read time. */
2819 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2821 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2824 /* Note: We don't support traversal of UNC volumes via symlinks.
2825 Doing so would mean punishing 99.99% of use cases by resolving
2826 all the possible symlinks in FILENAME, recursively. */
2827 if (is_unc_volume (filename
))
2829 wnet_enum_handle
= open_unc_volume (filename
);
2830 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2834 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2841 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2842 dir_pathname
[MAXPATHLEN
] = '\0';
2843 /* Note: We don't support symlinks to file names on FAT volumes.
2844 Doing so would mean punishing 99.99% of use cases by resolving
2845 all the possible symlinks in FILENAME, recursively. */
2846 dir_is_fat
= is_fat_volume (filename
, NULL
);
2852 closedir (DIR *dirp
)
2854 /* If we have a find-handle open, close it. */
2855 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2857 FindClose (dir_find_handle
);
2858 dir_find_handle
= INVALID_HANDLE_VALUE
;
2860 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2862 close_unc_volume (wnet_enum_handle
);
2863 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2865 xfree ((char *) dirp
);
2871 int downcase
= !NILP (Vw32_downcase_file_names
);
2873 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2875 if (!read_unc_volume (wnet_enum_handle
,
2876 dir_find_data
.cFileName
,
2880 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2881 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2883 char filename
[MAXNAMLEN
+ 3];
2886 strcpy (filename
, dir_pathname
);
2887 ln
= strlen (filename
) - 1;
2888 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2889 strcat (filename
, "\\");
2890 strcat (filename
, "*");
2892 /* Note: No need to resolve symlinks in FILENAME, because
2893 FindFirst opens the directory that is the target of a
2895 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2897 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2902 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2906 /* Emacs never uses this value, so don't bother making it match
2907 value returned by stat(). */
2908 dir_static
.d_ino
= 1;
2910 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2912 /* If the file name in cFileName[] includes `?' characters, it means
2913 the original file name used characters that cannot be represented
2914 by the current ANSI codepage. To avoid total lossage, retrieve
2915 the short 8+3 alias of the long file name. */
2916 if (_mbspbrk (dir_static
.d_name
, "?"))
2918 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2919 downcase
= 1; /* 8+3 aliases are returned in all caps */
2921 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2922 dir_static
.d_reclen
= sizeof (struct dirent
) - MAXNAMLEN
+ 3 +
2923 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2925 /* If the file name in cFileName[] includes `?' characters, it means
2926 the original file name used characters that cannot be represented
2927 by the current ANSI codepage. To avoid total lossage, retrieve
2928 the short 8+3 alias of the long file name. */
2929 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2931 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2932 /* 8+3 aliases are returned in all caps, which could break
2933 various alists that look at filenames' extensions. */
2937 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2938 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2940 _mbslwr (dir_static
.d_name
);
2944 int dbcs_p
= max_filename_mbslen () > 1;
2945 for (p
= dir_static
.d_name
; *p
; )
2947 if (*p
>= 'a' && *p
<= 'z')
2950 p
= CharNextExA (file_name_codepage
, p
, 0);
2955 _mbslwr (dir_static
.d_name
);
2962 open_unc_volume (const char *path
)
2968 nr
.dwScope
= RESOURCE_GLOBALNET
;
2969 nr
.dwType
= RESOURCETYPE_DISK
;
2970 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2971 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2972 nr
.lpLocalName
= NULL
;
2973 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2974 nr
.lpComment
= NULL
;
2975 nr
.lpProvider
= NULL
;
2977 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2978 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2980 if (result
== NO_ERROR
)
2983 return INVALID_HANDLE_VALUE
;
2987 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2991 DWORD bufsize
= 512;
2996 buffer
= alloca (bufsize
);
2997 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2998 if (result
!= NO_ERROR
)
3001 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3002 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
3004 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
3007 strncpy (readbuf
, ptr
, size
);
3012 close_unc_volume (HANDLE henum
)
3014 if (henum
!= INVALID_HANDLE_VALUE
)
3015 WNetCloseEnum (henum
);
3019 unc_volume_file_attributes (const char *path
)
3024 henum
= open_unc_volume (path
);
3025 if (henum
== INVALID_HANDLE_VALUE
)
3028 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3030 close_unc_volume (henum
);
3035 /* Ensure a network connection is authenticated. */
3037 logon_network_drive (const char *path
)
3039 NETRESOURCE resource
;
3040 char share
[MAX_PATH
];
3045 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3046 drvtype
= DRIVE_REMOTE
;
3047 else if (path
[0] == '\0' || path
[1] != ':')
3048 drvtype
= GetDriveType (NULL
);
3055 drvtype
= GetDriveType (drive
);
3058 /* Only logon to networked drives. */
3059 if (drvtype
!= DRIVE_REMOTE
)
3063 strncpy (share
, path
, MAX_PATH
);
3064 /* Truncate to just server and share name. */
3065 for (i
= 2; i
< MAX_PATH
; i
++)
3067 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
3074 resource
.dwType
= RESOURCETYPE_DISK
;
3075 resource
.lpLocalName
= NULL
;
3076 resource
.lpRemoteName
= share
;
3077 resource
.lpProvider
= NULL
;
3079 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3082 /* Emulate faccessat(2). */
3084 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3088 if (dirfd
!= AT_FDCWD
3089 && !(IS_DIRECTORY_SEP (path
[0])
3090 || IS_DEVICE_SEP (path
[1])))
3096 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3097 newer versions blow up when passed D_OK. */
3098 path
= map_w32_filename (path
, NULL
);
3099 /* If the last element of PATH is a symlink, we need to resolve it
3100 to get the attributes of its target file. Note: any symlinks in
3101 PATH elements other than the last one are transparently resolved
3102 by GetFileAttributes below. */
3103 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3104 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3105 path
= chase_symlinks (path
);
3107 if ((attributes
= GetFileAttributes (path
)) == -1)
3109 DWORD w32err
= GetLastError ();
3113 case ERROR_INVALID_NAME
:
3114 case ERROR_BAD_PATHNAME
:
3115 if (is_unc_volume (path
))
3117 attributes
= unc_volume_file_attributes (path
);
3118 if (attributes
== -1)
3126 case ERROR_FILE_NOT_FOUND
:
3127 case ERROR_BAD_NETPATH
:
3136 if ((mode
& X_OK
) != 0
3137 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3142 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3147 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3155 /* Shadow some MSVC runtime functions to map requests for long filenames
3156 to reasonable short names if necessary. This was originally added to
3157 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3161 sys_chdir (const char * path
)
3163 return _chdir (map_w32_filename (path
, NULL
));
3167 sys_chmod (const char * path
, int mode
)
3169 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3170 return _chmod (path
, mode
);
3174 sys_chown (const char *path
, uid_t owner
, gid_t group
)
3176 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
3182 sys_creat (const char * path
, int mode
)
3184 return _creat (map_w32_filename (path
, NULL
), mode
);
3188 sys_fopen (const char * path
, const char * mode
)
3192 const char * mode_save
= mode
;
3194 /* Force all file handles to be non-inheritable. This is necessary to
3195 ensure child processes don't unwittingly inherit handles that might
3196 prevent future file access. */
3200 else if (mode
[0] == 'w' || mode
[0] == 'a')
3201 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3205 /* Only do simplistic option parsing. */
3209 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3212 else if (mode
[0] == 'b')
3217 else if (mode
[0] == 't')
3224 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
3228 return _fdopen (fd
, mode_save
);
3231 /* This only works on NTFS volumes, but is useful to have. */
3233 sys_link (const char * old
, const char * new)
3237 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
3239 if (old
== NULL
|| new == NULL
)
3245 strcpy (oldname
, map_w32_filename (old
, NULL
));
3246 strcpy (newname
, map_w32_filename (new, NULL
));
3248 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
3249 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3250 if (fileh
!= INVALID_HANDLE_VALUE
)
3254 /* Confusingly, the "alternate" stream name field does not apply
3255 when restoring a hard link, and instead contains the actual
3256 stream data for the link (ie. the name of the link to create).
3257 The WIN32_STREAM_ID structure before the cStreamName field is
3258 the stream header, which is then immediately followed by the
3262 WIN32_STREAM_ID wid
;
3263 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3266 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
3267 data
.wid
.cStreamName
, MAX_PATH
);
3270 LPVOID context
= NULL
;
3273 data
.wid
.dwStreamId
= BACKUP_LINK
;
3274 data
.wid
.dwStreamAttributes
= 0;
3275 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3276 data
.wid
.Size
.HighPart
= 0;
3277 data
.wid
.dwStreamNameSize
= 0;
3279 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3280 offsetof (WIN32_STREAM_ID
, cStreamName
)
3281 + data
.wid
.Size
.LowPart
,
3282 &wbytes
, FALSE
, FALSE
, &context
)
3283 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3290 /* Should try mapping GetLastError to errno; for now just
3291 indicate a general error (eg. links not supported). */
3292 errno
= EINVAL
; // perhaps EMLINK?
3296 CloseHandle (fileh
);
3305 sys_mkdir (const char * path
)
3307 return _mkdir (map_w32_filename (path
, NULL
));
3310 /* Because of long name mapping issues, we need to implement this
3311 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
3312 a unique name, instead of setting the input template to an empty
3315 Standard algorithm seems to be use pid or tid with a letter on the
3316 front (in place of the 6 X's) and cycle through the letters to find a
3317 unique name. We extend that to allow any reasonable character as the
3318 first of the 6 X's. */
3320 sys_mktemp (char * template)
3324 unsigned uid
= GetCurrentThreadId ();
3325 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3327 if (template == NULL
)
3329 p
= template + strlen (template);
3331 /* replace up to the last 5 X's with uid in decimal */
3332 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3334 p
[0] = '0' + uid
% 10;
3338 if (i
< 0 && p
[0] == 'X')
3343 int save_errno
= errno
;
3344 p
[0] = first_char
[i
];
3345 if (faccessat (AT_FDCWD
, template, F_OK
, AT_EACCESS
) < 0)
3351 while (++i
< sizeof (first_char
));
3354 /* Template is badly formed or else we can't generate a unique name,
3355 so return empty string */
3361 sys_open (const char * path
, int oflag
, int mode
)
3363 const char* mpath
= map_w32_filename (path
, NULL
);
3364 /* Try to open file without _O_CREAT, to be able to write to hidden
3365 and system files. Force all file handles to be
3367 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3370 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3374 sys_rename (const char * oldname
, const char * newname
)
3377 char temp
[MAX_PATH
];
3381 /* MoveFile on Windows 95 doesn't correctly change the short file name
3382 alias in a number of circumstances (it is not easy to predict when
3383 just by looking at oldname and newname, unfortunately). In these
3384 cases, renaming through a temporary name avoids the problem.
3386 A second problem on Windows 95 is that renaming through a temp name when
3387 newname is uppercase fails (the final long name ends up in
3388 lowercase, although the short alias might be uppercase) UNLESS the
3389 long temp name is not 8.3.
3391 So, on Windows 95 we always rename through a temp name, and we make sure
3392 the temp name has a long extension to ensure correct renaming. */
3394 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3396 /* volume_info is set indirectly by map_w32_filename. */
3397 oldname_dev
= volume_info
.serialnum
;
3399 if (os_subtype
== OS_9X
)
3405 oldname
= map_w32_filename (oldname
, NULL
);
3406 if ((o
= strrchr (oldname
, '\\')))
3409 o
= (char *) oldname
;
3411 if ((p
= strrchr (temp
, '\\')))
3418 /* Force temp name to require a manufactured 8.3 alias - this
3419 seems to make the second rename work properly. */
3420 sprintf (p
, "_.%s.%u", o
, i
);
3422 result
= rename (oldname
, temp
);
3424 /* This loop must surely terminate! */
3425 while (result
< 0 && errno
== EEXIST
);
3430 /* Emulate Unix behavior - newname is deleted if it already exists
3431 (at least if it is a file; don't do this for directories).
3433 Since we mustn't do this if we are just changing the case of the
3434 file name (we would end up deleting the file we are trying to
3435 rename!), we let rename detect if the destination file already
3436 exists - that way we avoid the possible pitfalls of trying to
3437 determine ourselves whether two names really refer to the same
3438 file, which is not always possible in the general case. (Consider
3439 all the permutations of shared or subst'd drives, etc.) */
3441 newname
= map_w32_filename (newname
, NULL
);
3443 /* volume_info is set indirectly by map_w32_filename. */
3444 newname_dev
= volume_info
.serialnum
;
3446 result
= rename (temp
, newname
);
3450 DWORD w32err
= GetLastError ();
3453 && newname_dev
!= oldname_dev
)
3455 /* The implementation of `rename' on Windows does not return
3456 errno = EXDEV when you are moving a directory to a
3457 different storage device (ex. logical disk). It returns
3458 EACCES instead. So here we handle such situations and
3462 if ((attributes
= GetFileAttributes (temp
)) != -1
3463 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3466 else if (errno
== EEXIST
)
3468 if (_chmod (newname
, 0666) != 0)
3470 if (_unlink (newname
) != 0)
3472 result
= rename (temp
, newname
);
3474 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3475 && is_symlink (temp
))
3477 /* This is Windows prohibiting the user from creating a
3478 symlink in another place, since that requires
3488 sys_rmdir (const char * path
)
3490 return _rmdir (map_w32_filename (path
, NULL
));
3494 sys_unlink (const char * path
)
3496 path
= map_w32_filename (path
, NULL
);
3498 /* On Unix, unlink works without write permission. */
3499 _chmod (path
, 0666);
3500 return _unlink (path
);
3503 static FILETIME utc_base_ft
;
3504 static ULONGLONG utc_base
; /* In 100ns units */
3505 static int init
= 0;
3507 #define FILETIME_TO_U64(result, ft) \
3509 ULARGE_INTEGER uiTemp; \
3510 uiTemp.LowPart = (ft).dwLowDateTime; \
3511 uiTemp.HighPart = (ft).dwHighDateTime; \
3512 result = uiTemp.QuadPart; \
3516 initialize_utc_base (void)
3518 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3527 st
.wMilliseconds
= 0;
3529 SystemTimeToFileTime (&st
, &utc_base_ft
);
3530 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3534 convert_time (FILETIME ft
)
3540 initialize_utc_base ();
3544 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3547 FILETIME_TO_U64 (tmp
, ft
);
3548 return (time_t) ((tmp
- utc_base
) / 10000000L);
3552 convert_from_time_t (time_t time
, FILETIME
* pft
)
3558 initialize_utc_base ();
3562 /* time in 100ns units since 1-Jan-1601 */
3563 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3564 pft
->dwHighDateTime
= tmp
.HighPart
;
3565 pft
->dwLowDateTime
= tmp
.LowPart
;
3569 /* No reason to keep this; faking inode values either by hashing or even
3570 using the file index from GetInformationByHandle, is not perfect and
3571 so by default Emacs doesn't use the inode values on Windows.
3572 Instead, we now determine file-truename correctly (except for
3573 possible drive aliasing etc). */
3575 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3577 hashval (const unsigned char * str
)
3582 h
= (h
<< 4) + *str
++;
3588 /* Return the hash value of the canonical pathname, excluding the
3589 drive/UNC header, to get a hopefully unique inode number. */
3591 generate_inode_val (const char * name
)
3593 char fullname
[ MAX_PATH
];
3597 /* Get the truly canonical filename, if it exists. (Note: this
3598 doesn't resolve aliasing due to subst commands, or recognize hard
3600 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3603 parse_root (fullname
, &p
);
3604 /* Normal W32 filesystems are still case insensitive. */
3611 static PSECURITY_DESCRIPTOR
3612 get_file_security_desc_by_handle (HANDLE h
)
3614 PSECURITY_DESCRIPTOR psd
= NULL
;
3616 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3617 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3619 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3620 NULL
, NULL
, NULL
, NULL
, &psd
);
3621 if (err
!= ERROR_SUCCESS
)
3627 static PSECURITY_DESCRIPTOR
3628 get_file_security_desc_by_name (const char *fname
)
3630 PSECURITY_DESCRIPTOR psd
= NULL
;
3632 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3633 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3635 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3637 err
= GetLastError ();
3638 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3642 psd
= xmalloc (sd_len
);
3643 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3655 unsigned n_subauthorities
;
3657 /* Use the last sub-authority value of the RID, the relative
3658 portion of the SID, as user/group ID. */
3659 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3660 if (n_subauthorities
< 1)
3661 return 0; /* the "World" RID */
3662 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3665 /* Caching SID and account values for faster lokup. */
3668 # define FLEXIBLE_ARRAY_MEMBER
3670 # define FLEXIBLE_ARRAY_MEMBER 1
3675 struct w32_id
*next
;
3677 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3680 static struct w32_id
*w32_idlist
;
3683 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3685 struct w32_id
*tail
, *found
;
3687 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3689 if (equal_sid ((PSID
)tail
->sid
, sid
))
3698 strcpy (name
, found
->name
);
3706 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3709 struct w32_id
*new_entry
;
3711 /* We don't want to leave behind stale cache from when Emacs was
3715 sid_len
= get_length_sid (sid
);
3716 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3719 new_entry
->rid
= id
;
3720 strcpy (new_entry
->name
, name
);
3721 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3722 new_entry
->next
= w32_idlist
;
3723 w32_idlist
= new_entry
;
3732 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
3736 SID_NAME_USE ignore
;
3738 DWORD name_len
= sizeof (name
);
3740 DWORD domain_len
= sizeof (domain
);
3745 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3746 else if (what
== GID
)
3747 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3751 if (!result
|| !is_valid_sid (sid
))
3753 else if (!w32_cached_id (sid
, id
, nm
))
3755 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
3756 domain
, &domain_len
, &ignore
)
3757 || name_len
> UNLEN
+1)
3761 *id
= get_rid (sid
);
3763 w32_add_to_cache (sid
, *id
, name
);
3770 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
3772 int dflt_usr
= 0, dflt_grp
= 0;
3781 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
3783 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
3786 /* Consider files to belong to current user/group, if we cannot get
3787 more accurate information. */
3790 st
->st_uid
= dflt_passwd
.pw_uid
;
3791 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3795 st
->st_gid
= dflt_passwd
.pw_gid
;
3796 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3800 /* Return non-zero if NAME is a potentially slow filesystem. */
3802 is_slow_fs (const char *name
)
3807 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3808 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3809 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3810 devtype
= GetDriveType (NULL
); /* use root of current drive */
3813 /* GetDriveType needs the root directory of the drive. */
3814 strncpy (drive_root
, name
, 2);
3815 drive_root
[2] = '\\';
3816 drive_root
[3] = '\0';
3817 devtype
= GetDriveType (drive_root
);
3819 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3822 /* If this is non-zero, the caller wants accurate information about
3823 file's owner and group, which could be expensive to get. */
3824 int w32_stat_get_owner_group
;
3826 /* MSVC stat function can't cope with UNC names and has other bugs, so
3827 replace it with our own. This also allows us to calculate consistent
3828 inode values and owner/group without hacks in the main Emacs code. */
3831 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3833 char *name
, *save_name
, *r
;
3834 WIN32_FIND_DATA wfd
;
3836 unsigned __int64 fake_inode
= 0;
3839 int rootdir
= FALSE
;
3840 PSECURITY_DESCRIPTOR psd
= NULL
;
3841 int is_a_symlink
= 0;
3842 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3843 DWORD access_rights
= 0;
3844 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3845 FILETIME ctime
, atime
, wtime
;
3847 if (path
== NULL
|| buf
== NULL
)
3853 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3854 /* Must be valid filename, no wild cards or other invalid
3855 characters. We use _mbspbrk to support multibyte strings that
3856 might look to strpbrk as if they included literal *, ?, and other
3857 characters mentioned below that are disallowed by Windows
3859 if (_mbspbrk (name
, "*?|<>\""))
3865 /* Remove trailing directory separator, unless name is the root
3866 directory of a drive or UNC volume in which case ensure there
3867 is a trailing separator. */
3868 len
= strlen (name
);
3869 name
= strcpy (alloca (len
+ 2), name
);
3871 /* Avoid a somewhat costly call to is_symlink if the filesystem
3872 doesn't support symlinks. */
3873 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3874 is_a_symlink
= is_symlink (name
);
3876 /* Plan A: Open the file and get all the necessary information via
3877 the resulting handle. This solves several issues in one blow:
3879 . retrieves attributes for the target of a symlink, if needed
3880 . gets attributes of root directories and symlinks pointing to
3881 root directories, thus avoiding the need for special-casing
3882 these and detecting them by examining the file-name format
3883 . retrieves more accurate attributes (e.g., non-zero size for
3884 some directories, esp. directories that are junction points)
3885 . correctly resolves "c:/..", "/.." and similar file names
3886 . avoids run-time penalties for 99% of use cases
3888 Plan A is always tried first, unless the user asked not to (but
3889 if the file is a symlink and we need to follow links, we try Plan
3890 A even if the user asked not to).
3892 If Plan A fails, we go to Plan B (below), where various
3893 potentially expensive techniques must be used to handle "special"
3894 files such as UNC volumes etc. */
3895 if (!(NILP (Vw32_get_true_file_attributes
)
3896 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3897 /* Following symlinks requires getting the info by handle. */
3898 || (is_a_symlink
&& follow_symlinks
))
3900 BY_HANDLE_FILE_INFORMATION info
;
3902 if (is_a_symlink
&& !follow_symlinks
)
3903 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3904 /* READ_CONTROL access rights are required to get security info
3905 by handle. But if the OS doesn't support security in the
3906 first place, we don't need to try. */
3907 if (is_windows_9x () != TRUE
)
3908 access_rights
|= READ_CONTROL
;
3910 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3912 /* If CreateFile fails with READ_CONTROL, try again with zero as
3914 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3915 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3917 if (fh
== INVALID_HANDLE_VALUE
)
3918 goto no_true_file_attributes
;
3920 /* This is more accurate in terms of getting the correct number
3921 of links, but is quite slow (it is noticeable when Emacs is
3922 making a list of file name completions). */
3923 if (GetFileInformationByHandle (fh
, &info
))
3925 nlinks
= info
.nNumberOfLinks
;
3926 /* Might as well use file index to fake inode values, but this
3927 is not guaranteed to be unique unless we keep a handle open
3928 all the time (even then there are situations where it is
3929 not unique). Reputedly, there are at most 48 bits of info
3930 (on NTFS, presumably less on FAT). */
3931 fake_inode
= info
.nFileIndexHigh
;
3933 fake_inode
+= info
.nFileIndexLow
;
3934 serialnum
= info
.dwVolumeSerialNumber
;
3935 fs_high
= info
.nFileSizeHigh
;
3936 fs_low
= info
.nFileSizeLow
;
3937 ctime
= info
.ftCreationTime
;
3938 atime
= info
.ftLastAccessTime
;
3939 wtime
= info
.ftLastWriteTime
;
3940 fattrs
= info
.dwFileAttributes
;
3944 /* We don't go to Plan B here, because it's not clear that
3945 it's a good idea. The only known use case where
3946 CreateFile succeeds, but GetFileInformationByHandle fails
3947 (with ERROR_INVALID_FUNCTION) is for character devices
3948 such as NUL, PRN, etc. For these, switching to Plan B is
3949 a net loss, because we lose the character device
3950 attribute returned by GetFileType below (FindFirstFile
3951 doesn't set that bit in the attributes), and the other
3952 fields don't make sense for character devices anyway.
3953 Emacs doesn't really care for non-file entities in the
3954 context of l?stat, so neither do we. */
3956 /* w32err is assigned so one could put a breakpoint here and
3957 examine its value, when GetFileInformationByHandle
3959 DWORD w32err
= GetLastError ();
3963 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3969 /* Test for a symlink before testing for a directory, since
3970 symlinks to directories have the directory bit set, but we
3971 don't want them to appear as directories. */
3972 if (is_a_symlink
&& !follow_symlinks
)
3973 buf
->st_mode
= S_IFLNK
;
3974 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3975 buf
->st_mode
= S_IFDIR
;
3978 DWORD ftype
= GetFileType (fh
);
3982 case FILE_TYPE_DISK
:
3983 buf
->st_mode
= S_IFREG
;
3985 case FILE_TYPE_PIPE
:
3986 buf
->st_mode
= S_IFIFO
;
3988 case FILE_TYPE_CHAR
:
3989 case FILE_TYPE_UNKNOWN
:
3991 buf
->st_mode
= S_IFCHR
;
3994 /* We produce the fallback owner and group data, based on the
3995 current user that runs Emacs, in the following cases:
3997 . caller didn't request owner and group info
3998 . this is Windows 9X
3999 . getting security by handle failed, and we need to produce
4000 information for the target of a symlink (this is better
4001 than producing a potentially misleading info about the
4004 If getting security by handle fails, and we don't need to
4005 resolve symlinks, we try getting security by name. */
4006 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4007 get_file_owner_and_group (NULL
, buf
);
4010 psd
= get_file_security_desc_by_handle (fh
);
4013 get_file_owner_and_group (psd
, buf
);
4016 else if (!(is_a_symlink
&& follow_symlinks
))
4018 psd
= get_file_security_desc_by_name (name
);
4019 get_file_owner_and_group (psd
, buf
);
4023 get_file_owner_and_group (NULL
, buf
);
4029 no_true_file_attributes
:
4030 /* Plan B: Either getting a handle on the file failed, or the
4031 caller explicitly asked us to not bother making this
4032 information more accurate.
4034 Implementation note: In Plan B, we never bother to resolve
4035 symlinks, even if we got here because we tried Plan A and
4036 failed. That's because, even if the caller asked for extra
4037 precision by setting Vw32_get_true_file_attributes to t,
4038 resolving symlinks requires acquiring a file handle to the
4039 symlink, which we already know will fail. And if the user
4040 did not ask for extra precision, resolving symlinks will fly
4041 in the face of that request, since the user then wants the
4042 lightweight version of the code. */
4043 rootdir
= (path
>= save_name
+ len
- 1
4044 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4046 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4047 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4048 if (IS_DIRECTORY_SEP (r
[0])
4049 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4052 /* Note: If NAME is a symlink to the root of a UNC volume
4053 (i.e. "\\SERVER"), we will not detect that here, and we will
4054 return data about the symlink as result of FindFirst below.
4055 This is unfortunate, but that marginal use case does not
4056 justify a call to chase_symlinks which would impose a penalty
4057 on all the other use cases. (We get here for symlinks to
4058 roots of UNC volumes because CreateFile above fails for them,
4059 unlike with symlinks to root directories X:\ of drives.) */
4060 if (is_unc_volume (name
))
4062 fattrs
= unc_volume_file_attributes (name
);
4066 ctime
= atime
= wtime
= utc_base_ft
;
4070 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4071 strcat (name
, "\\");
4072 if (GetDriveType (name
) < 2)
4078 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4079 ctime
= atime
= wtime
= utc_base_ft
;
4083 if (IS_DIRECTORY_SEP (name
[len
-1]))
4086 /* (This is hacky, but helps when doing file completions on
4087 network drives.) Optimize by using information available from
4088 active readdir if possible. */
4089 len
= strlen (dir_pathname
);
4090 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4092 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4093 && !(is_a_symlink
&& follow_symlinks
)
4094 && strnicmp (save_name
, dir_pathname
, len
) == 0
4095 && IS_DIRECTORY_SEP (name
[len
])
4096 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
4098 /* This was the last entry returned by readdir. */
4099 wfd
= dir_find_data
;
4103 logon_network_drive (name
);
4105 fh
= FindFirstFile (name
, &wfd
);
4106 if (fh
== INVALID_HANDLE_VALUE
)
4113 /* Note: if NAME is a symlink, the information we get from
4114 FindFirstFile is for the symlink, not its target. */
4115 fattrs
= wfd
.dwFileAttributes
;
4116 ctime
= wfd
.ftCreationTime
;
4117 atime
= wfd
.ftLastAccessTime
;
4118 wtime
= wfd
.ftLastWriteTime
;
4119 fs_high
= wfd
.nFileSizeHigh
;
4120 fs_low
= wfd
.nFileSizeLow
;
4123 serialnum
= volume_info
.serialnum
;
4125 if (is_a_symlink
&& !follow_symlinks
)
4126 buf
->st_mode
= S_IFLNK
;
4127 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4128 buf
->st_mode
= S_IFDIR
;
4130 buf
->st_mode
= S_IFREG
;
4132 get_file_owner_and_group (NULL
, buf
);
4136 /* Not sure if there is any point in this. */
4137 if (!NILP (Vw32_generate_fake_inodes
))
4138 fake_inode
= generate_inode_val (name
);
4139 else if (fake_inode
== 0)
4141 /* For want of something better, try to make everything unique. */
4142 static DWORD gen_num
= 0;
4143 fake_inode
= ++gen_num
;
4147 buf
->st_ino
= fake_inode
;
4149 buf
->st_dev
= serialnum
;
4150 buf
->st_rdev
= serialnum
;
4152 buf
->st_size
= fs_high
;
4153 buf
->st_size
<<= 32;
4154 buf
->st_size
+= fs_low
;
4155 buf
->st_nlink
= nlinks
;
4157 /* Convert timestamps to Unix format. */
4158 buf
->st_mtime
= convert_time (wtime
);
4159 buf
->st_atime
= convert_time (atime
);
4160 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4161 buf
->st_ctime
= convert_time (ctime
);
4162 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4164 /* determine rwx permissions */
4165 if (is_a_symlink
&& !follow_symlinks
)
4166 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
4169 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
4170 permission
= S_IREAD
;
4172 permission
= S_IREAD
| S_IWRITE
;
4174 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4175 permission
|= S_IEXEC
;
4176 else if (is_exec (name
))
4177 permission
|= S_IEXEC
;
4180 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4186 stat (const char * path
, struct stat
* buf
)
4188 return stat_worker (path
, buf
, 1);
4192 lstat (const char * path
, struct stat
* buf
)
4194 return stat_worker (path
, buf
, 0);
4197 /* Provide fstat and utime as well as stat for consistent handling of
4200 fstat (int desc
, struct stat
* buf
)
4202 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
4203 BY_HANDLE_FILE_INFORMATION info
;
4204 unsigned __int64 fake_inode
;
4207 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4209 case FILE_TYPE_DISK
:
4210 buf
->st_mode
= S_IFREG
;
4211 if (!GetFileInformationByHandle (fh
, &info
))
4217 case FILE_TYPE_PIPE
:
4218 buf
->st_mode
= S_IFIFO
;
4220 case FILE_TYPE_CHAR
:
4221 case FILE_TYPE_UNKNOWN
:
4223 buf
->st_mode
= S_IFCHR
;
4225 memset (&info
, 0, sizeof (info
));
4226 info
.dwFileAttributes
= 0;
4227 info
.ftCreationTime
= utc_base_ft
;
4228 info
.ftLastAccessTime
= utc_base_ft
;
4229 info
.ftLastWriteTime
= utc_base_ft
;
4232 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4233 buf
->st_mode
= S_IFDIR
;
4235 buf
->st_nlink
= info
.nNumberOfLinks
;
4236 /* Might as well use file index to fake inode values, but this
4237 is not guaranteed to be unique unless we keep a handle open
4238 all the time (even then there are situations where it is
4239 not unique). Reputedly, there are at most 48 bits of info
4240 (on NTFS, presumably less on FAT). */
4241 fake_inode
= info
.nFileIndexHigh
;
4243 fake_inode
+= info
.nFileIndexLow
;
4245 /* MSVC defines _ino_t to be short; other libc's might not. */
4246 if (sizeof (buf
->st_ino
) == 2)
4247 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4249 buf
->st_ino
= fake_inode
;
4251 /* If the caller so requested, get the true file owner and group.
4252 Otherwise, consider the file to belong to the current user. */
4253 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4254 get_file_owner_and_group (NULL
, buf
);
4257 PSECURITY_DESCRIPTOR psd
= NULL
;
4259 psd
= get_file_security_desc_by_handle (fh
);
4262 get_file_owner_and_group (psd
, buf
);
4266 get_file_owner_and_group (NULL
, buf
);
4269 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4270 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4272 buf
->st_size
= info
.nFileSizeHigh
;
4273 buf
->st_size
<<= 32;
4274 buf
->st_size
+= info
.nFileSizeLow
;
4276 /* Convert timestamps to Unix format. */
4277 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4278 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4279 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4280 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4281 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4283 /* determine rwx permissions */
4284 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4285 permission
= S_IREAD
;
4287 permission
= S_IREAD
| S_IWRITE
;
4289 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4290 permission
|= S_IEXEC
;
4293 #if 0 /* no way of knowing the filename */
4294 char * p
= strrchr (name
, '.');
4296 (xstrcasecmp (p
, ".exe") == 0 ||
4297 xstrcasecmp (p
, ".com") == 0 ||
4298 xstrcasecmp (p
, ".bat") == 0 ||
4299 xstrcasecmp (p
, ".cmd") == 0))
4300 permission
|= S_IEXEC
;
4304 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4310 utime (const char *name
, struct utimbuf
*times
)
4312 struct utimbuf deftime
;
4319 deftime
.modtime
= deftime
.actime
= time (NULL
);
4323 /* Need write access to set times. */
4324 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
4325 /* If NAME specifies a directory, FILE_SHARE_DELETE
4326 allows other processes to delete files inside it,
4327 while we have the directory open. */
4328 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4329 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4330 if (fh
!= INVALID_HANDLE_VALUE
)
4332 convert_from_time_t (times
->actime
, &atime
);
4333 convert_from_time_t (times
->modtime
, &mtime
);
4334 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4351 /* Symlink-related functions. */
4352 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4353 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4357 symlink (char const *filename
, char const *linkname
)
4359 char linkfn
[MAX_PATH
], *tgtfn
;
4361 int dir_access
, filename_ends_in_slash
;
4363 /* Diagnostics follows Posix as much as possible. */
4364 if (filename
== NULL
|| linkname
== NULL
)
4374 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4376 errno
= ENAMETOOLONG
;
4380 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4381 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4387 /* Note: since empty FILENAME was already rejected, we can safely
4388 refer to FILENAME[1]. */
4389 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4391 /* Non-absolute FILENAME is understood as being relative to
4392 LINKNAME's directory. We need to prepend that directory to
4393 FILENAME to get correct results from faccessat below, since
4394 otherwise it will interpret FILENAME relative to the
4395 directory where the Emacs process runs. Note that
4396 make-symbolic-link always makes sure LINKNAME is a fully
4397 expanded file name. */
4399 char *p
= linkfn
+ strlen (linkfn
);
4401 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4404 strncpy (tem
, linkfn
, p
- linkfn
);
4405 tem
[p
- linkfn
] = '\0';
4406 strcat (tem
, filename
);
4407 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4410 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4412 /* Since Windows distinguishes between symlinks to directories and
4413 to files, we provide a kludgy feature: if FILENAME doesn't
4414 exist, but ends in a slash, we create a symlink to directory. If
4415 FILENAME exists and is a directory, we always create a symlink to
4417 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4418 if (dir_access
== 0 || filename_ends_in_slash
)
4419 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4421 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4422 if (filename_ends_in_slash
)
4423 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4426 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4428 /* ENOSYS is set by create_symbolic_link, when it detects that
4429 the OS doesn't support the CreateSymbolicLink API. */
4430 if (errno
!= ENOSYS
)
4432 DWORD w32err
= GetLastError ();
4436 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4437 TGTFN point to the same file name, go figure. */
4439 case ERROR_FILE_EXISTS
:
4442 case ERROR_ACCESS_DENIED
:
4445 case ERROR_FILE_NOT_FOUND
:
4446 case ERROR_PATH_NOT_FOUND
:
4447 case ERROR_BAD_NETPATH
:
4448 case ERROR_INVALID_REPARSE_DATA
:
4451 case ERROR_DIRECTORY
:
4454 case ERROR_PRIVILEGE_NOT_HELD
:
4455 case ERROR_NOT_ALL_ASSIGNED
:
4458 case ERROR_DISK_FULL
:
4471 /* A quick inexpensive test of whether FILENAME identifies a file that
4472 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4473 must already be in the normalized form returned by
4476 Note: for repeated operations on many files, it is best to test
4477 whether the underlying volume actually supports symlinks, by
4478 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4479 avoid the call to this function if it doesn't. That's because the
4480 call to GetFileAttributes takes a non-negligible time, especially
4481 on non-local or removable filesystems. See stat_worker for an
4482 example of how to do that. */
4484 is_symlink (const char *filename
)
4487 WIN32_FIND_DATA wfd
;
4490 attrs
= GetFileAttributes (filename
);
4493 DWORD w32err
= GetLastError ();
4497 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4499 case ERROR_ACCESS_DENIED
:
4502 case ERROR_FILE_NOT_FOUND
:
4503 case ERROR_PATH_NOT_FOUND
:
4510 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4512 logon_network_drive (filename
);
4513 fh
= FindFirstFile (filename
, &wfd
);
4514 if (fh
== INVALID_HANDLE_VALUE
)
4517 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4518 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4521 /* If NAME identifies a symbolic link, copy into BUF the file name of
4522 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4523 null-terminate the target name, even if it fits. Return the number
4524 of bytes copied, or -1 if NAME is not a symlink or any error was
4525 encountered while resolving it. The file name copied into BUF is
4526 encoded in the current ANSI codepage. */
4528 readlink (const char *name
, char *buf
, size_t buf_size
)
4531 TOKEN_PRIVILEGES privs
;
4532 int restore_privs
= 0;
4547 path
= map_w32_filename (name
, NULL
);
4549 if (strlen (path
) > MAX_PATH
)
4551 errno
= ENAMETOOLONG
;
4556 if (is_windows_9x () == TRUE
4557 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4558 || !is_symlink (path
))
4561 errno
= EINVAL
; /* not a symlink */
4565 /* Done with simple tests, now we're in for some _real_ work. */
4566 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4568 /* Implementation note: From here and onward, don't return early,
4569 since that will fail to restore the original set of privileges of
4570 the calling thread. */
4572 retval
= -1; /* not too optimistic, are we? */
4574 /* Note: In the next call to CreateFile, we use zero as the 2nd
4575 argument because, when the symlink is a hidden/system file,
4576 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4577 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4578 and directory symlinks. */
4579 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4580 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4582 if (sh
!= INVALID_HANDLE_VALUE
)
4584 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4585 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4588 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4589 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4592 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4596 /* Copy the link target name, in wide characters, from
4597 reparse_data, then convert it to multibyte encoding in
4598 the current locale's codepage. */
4600 BYTE lname
[MAX_PATH
];
4603 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4605 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4606 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4608 /* According to MSDN, PrintNameLength does not include the
4609 terminating null character. */
4610 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4611 memcpy (lwname
, lwname_src
, lwname_len
);
4612 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4614 /* FIXME: Should we use the current file-name coding system
4615 instead of the fixed value of the ANSI codepage? */
4616 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4617 lname
, MAX_PATH
, NULL
, NULL
);
4620 /* WideCharToMultiByte failed. */
4621 DWORD w32err1
= GetLastError ();
4625 case ERROR_INSUFFICIENT_BUFFER
:
4626 errno
= ENAMETOOLONG
;
4628 case ERROR_INVALID_PARAMETER
:
4631 case ERROR_NO_UNICODE_TRANSLATION
:
4641 size_t size_to_copy
= buf_size
;
4643 BYTE
*pend
= p
+ lname_len
;
4645 /* Normalize like dostounix_filename does, but we don't
4646 want to assume that lname is null-terminated. */
4647 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4655 /* Testing for null-terminated LNAME is paranoia:
4656 WideCharToMultiByte should always return a
4657 null-terminated string when its 4th argument is -1
4658 and its 3rd argument is null-terminated (which they
4660 if (lname
[lname_len
- 1] == '\0')
4662 if (lname_len
<= buf_size
)
4663 size_to_copy
= lname_len
;
4664 strncpy (buf
, lname
, size_to_copy
);
4666 retval
= size_to_copy
;
4673 /* CreateFile failed. */
4674 DWORD w32err2
= GetLastError ();
4678 case ERROR_FILE_NOT_FOUND
:
4679 case ERROR_PATH_NOT_FOUND
:
4682 case ERROR_ACCESS_DENIED
:
4683 case ERROR_TOO_MANY_OPEN_FILES
:
4693 restore_privilege (&privs
);
4700 /* If FILE is a symlink, return its target (stored in a static
4701 buffer); otherwise return FILE.
4703 This function repeatedly resolves symlinks in the last component of
4704 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4705 until it arrives at a file whose last component is not a symlink,
4706 or some error occurs. It returns the target of the last
4707 successfully resolved symlink in the chain. If it succeeds to
4708 resolve even a single symlink, the value returned is an absolute
4709 file name with backslashes (result of GetFullPathName). By
4710 contrast, if the original FILE is returned, it is unaltered.
4712 Note: This function can set errno even if it succeeds.
4714 Implementation note: we only resolve the last portion ("basename")
4715 of the argument FILE and of each following file in the chain,
4716 disregarding any possible symlinks in its leading directories.
4717 This is because Windows system calls and library functions
4718 transparently resolve symlinks in leading directories and return
4719 correct information, as long as the basename is not a symlink. */
4721 chase_symlinks (const char *file
)
4723 static char target
[MAX_PATH
];
4724 char link
[MAX_PATH
];
4725 ssize_t res
, link_len
;
4728 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4729 return (char *)file
;
4731 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4732 return (char *)file
;
4737 /* Remove trailing slashes, as we want to resolve the last
4738 non-trivial part of the link name. */
4739 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4740 link
[link_len
--] = '\0';
4742 res
= readlink (link
, target
, MAX_PATH
);
4746 if (!(IS_DEVICE_SEP (target
[1])
4747 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4749 /* Target is relative. Append it to the directory part of
4750 the symlink, then copy the result back to target. */
4751 char *p
= link
+ link_len
;
4753 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4756 strcpy (target
, link
);
4758 /* Resolve any "." and ".." to get a fully-qualified file name
4760 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4762 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4764 if (loop_count
> 100)
4767 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4768 return (char *)file
;
4773 /* Posix ACL emulation. */
4776 acl_valid (acl_t acl
)
4778 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
4782 acl_to_text (acl_t acl
, ssize_t
*size
)
4785 SECURITY_INFORMATION flags
=
4786 OWNER_SECURITY_INFORMATION
|
4787 GROUP_SECURITY_INFORMATION
|
4788 DACL_SECURITY_INFORMATION
;
4789 char *retval
= NULL
;
4795 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
4798 /* We don't want to mix heaps, so we duplicate the string in our
4799 heap and free the one allocated by the API. */
4800 retval
= xstrdup (str_acl
);
4803 LocalFree (str_acl
);
4805 else if (errno
!= ENOTSUP
)
4812 acl_from_text (const char *acl_str
)
4814 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
4820 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
4823 retval
= xmalloc (sd_size
);
4824 memcpy (retval
, psd
, sd_size
);
4827 else if (errno
!= ENOTSUP
)
4834 acl_free (void *ptr
)
4841 acl_get_file (const char *fname
, acl_type_t type
)
4843 PSECURITY_DESCRIPTOR psd
= NULL
;
4844 const char *filename
;
4846 if (type
== ACL_TYPE_ACCESS
)
4849 SECURITY_INFORMATION si
=
4850 OWNER_SECURITY_INFORMATION
|
4851 GROUP_SECURITY_INFORMATION
|
4852 DACL_SECURITY_INFORMATION
;
4855 filename
= map_w32_filename (fname
, NULL
);
4856 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4857 fname
= chase_symlinks (filename
);
4862 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
4863 && errno
!= ENOTSUP
)
4865 err
= GetLastError ();
4866 if (err
== ERROR_INSUFFICIENT_BUFFER
)
4868 psd
= xmalloc (sd_len
);
4869 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
4876 else if (err
== ERROR_FILE_NOT_FOUND
4877 || err
== ERROR_PATH_NOT_FOUND
)
4885 else if (type
!= ACL_TYPE_DEFAULT
)
4892 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
4894 TOKEN_PRIVILEGES old1
, old2
;
4896 int st
= 0, retval
= -1;
4897 SECURITY_INFORMATION flags
= 0;
4903 const char *filename
;
4905 if (acl_valid (acl
) != 0
4906 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
4912 if (type
== ACL_TYPE_DEFAULT
)
4918 filename
= map_w32_filename (fname
, NULL
);
4919 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
4920 fname
= chase_symlinks (filename
);
4924 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
4926 flags
|= OWNER_SECURITY_INFORMATION
;
4927 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
4929 flags
|= GROUP_SECURITY_INFORMATION
;
4930 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
4933 flags
|= DACL_SECURITY_INFORMATION
;
4937 /* According to KB-245153, setting the owner will succeed if either:
4938 (1) the caller is the user who will be the new owner, and has the
4939 SE_TAKE_OWNERSHIP privilege, or
4940 (2) the caller has the SE_RESTORE privilege, in which case she can
4941 set any valid user or group as the owner
4943 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
4944 privileges, and disregard any failures in obtaining them. If
4945 these privileges cannot be obtained, and do not already exist in
4946 the calling thread's security token, this function could fail
4948 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
4950 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
4955 if (!set_file_security ((char *)fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
4957 err
= GetLastError ();
4959 if (errno
== ENOTSUP
)
4961 else if (err
== ERROR_INVALID_OWNER
4962 || err
== ERROR_NOT_ALL_ASSIGNED
4963 || err
== ERROR_ACCESS_DENIED
)
4965 /* Maybe the requested ACL and the one the file already has
4966 are identical, in which case we can silently ignore the
4967 failure. (And no, Windows doesn't.) */
4968 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
4973 char *acl_from
= acl_to_text (current_acl
, NULL
);
4974 char *acl_to
= acl_to_text (acl
, NULL
);
4976 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
4982 acl_free (acl_from
);
4985 acl_free (current_acl
);
4988 else if (err
== ERROR_FILE_NOT_FOUND
|| err
== ERROR_PATH_NOT_FOUND
)
5002 restore_privilege (&old2
);
5003 restore_privilege (&old1
);
5011 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
5012 have a fixed max size for file names, so we don't need the kind of
5013 alloc/malloc/realloc dance the gnulib version does. We also don't
5014 support FD-relative symlinks. */
5016 careadlinkat (int fd
, char const *filename
,
5017 char *buffer
, size_t buffer_size
,
5018 struct allocator
const *alloc
,
5019 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
5021 char linkname
[MAX_PATH
];
5030 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
5034 char *retval
= buffer
;
5036 linkname
[link_size
++] = '\0';
5037 if (link_size
> buffer_size
)
5038 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
5040 memcpy (retval
, linkname
, link_size
);
5048 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
5052 return readlink (filename
, buffer
, buffer_size
);
5056 /* Support for browsing other processes and their attributes. See
5057 process.c for the Lisp bindings. */
5059 /* Helper wrapper functions. */
5061 static HANDLE WINAPI
5062 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
5064 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
5066 if (g_b_init_create_toolhelp32_snapshot
== 0)
5068 g_b_init_create_toolhelp32_snapshot
= 1;
5069 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
5070 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5071 "CreateToolhelp32Snapshot");
5073 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
5075 return INVALID_HANDLE_VALUE
;
5077 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
5081 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5083 static Process32First_Proc s_pfn_Process32_First
= NULL
;
5085 if (g_b_init_process32_first
== 0)
5087 g_b_init_process32_first
= 1;
5088 s_pfn_Process32_First
= (Process32First_Proc
)
5089 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5092 if (s_pfn_Process32_First
== NULL
)
5096 return (s_pfn_Process32_First (hSnapshot
, lppe
));
5100 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5102 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
5104 if (g_b_init_process32_next
== 0)
5106 g_b_init_process32_next
= 1;
5107 s_pfn_Process32_Next
= (Process32Next_Proc
)
5108 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5111 if (s_pfn_Process32_Next
== NULL
)
5115 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
5119 open_thread_token (HANDLE ThreadHandle
,
5120 DWORD DesiredAccess
,
5122 PHANDLE TokenHandle
)
5124 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
5125 HMODULE hm_advapi32
= NULL
;
5126 if (is_windows_9x () == TRUE
)
5128 SetLastError (ERROR_NOT_SUPPORTED
);
5131 if (g_b_init_open_thread_token
== 0)
5133 g_b_init_open_thread_token
= 1;
5134 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5135 s_pfn_Open_Thread_Token
=
5136 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
5138 if (s_pfn_Open_Thread_Token
== NULL
)
5140 SetLastError (ERROR_NOT_SUPPORTED
);
5144 s_pfn_Open_Thread_Token (
5153 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
5155 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
5156 HMODULE hm_advapi32
= NULL
;
5157 if (is_windows_9x () == TRUE
)
5161 if (g_b_init_impersonate_self
== 0)
5163 g_b_init_impersonate_self
= 1;
5164 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5165 s_pfn_Impersonate_Self
=
5166 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
5168 if (s_pfn_Impersonate_Self
== NULL
)
5172 return s_pfn_Impersonate_Self (ImpersonationLevel
);
5176 revert_to_self (void)
5178 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
5179 HMODULE hm_advapi32
= NULL
;
5180 if (is_windows_9x () == TRUE
)
5184 if (g_b_init_revert_to_self
== 0)
5186 g_b_init_revert_to_self
= 1;
5187 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5188 s_pfn_Revert_To_Self
=
5189 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
5191 if (s_pfn_Revert_To_Self
== NULL
)
5195 return s_pfn_Revert_To_Self ();
5199 get_process_memory_info (HANDLE h_proc
,
5200 PPROCESS_MEMORY_COUNTERS mem_counters
,
5203 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
5204 HMODULE hm_psapi
= NULL
;
5205 if (is_windows_9x () == TRUE
)
5209 if (g_b_init_get_process_memory_info
== 0)
5211 g_b_init_get_process_memory_info
= 1;
5212 hm_psapi
= LoadLibrary ("Psapi.dll");
5214 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
5215 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
5217 if (s_pfn_Get_Process_Memory_Info
== NULL
)
5221 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
5225 get_process_working_set_size (HANDLE h_proc
,
5229 static GetProcessWorkingSetSize_Proc
5230 s_pfn_Get_Process_Working_Set_Size
= NULL
;
5232 if (is_windows_9x () == TRUE
)
5236 if (g_b_init_get_process_working_set_size
== 0)
5238 g_b_init_get_process_working_set_size
= 1;
5239 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
5240 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5241 "GetProcessWorkingSetSize");
5243 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
5247 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
5251 global_memory_status (MEMORYSTATUS
*buf
)
5253 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
5255 if (is_windows_9x () == TRUE
)
5259 if (g_b_init_global_memory_status
== 0)
5261 g_b_init_global_memory_status
= 1;
5262 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
5263 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5264 "GlobalMemoryStatus");
5266 if (s_pfn_Global_Memory_Status
== NULL
)
5270 return s_pfn_Global_Memory_Status (buf
);
5274 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
5276 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
5278 if (is_windows_9x () == TRUE
)
5282 if (g_b_init_global_memory_status_ex
== 0)
5284 g_b_init_global_memory_status_ex
= 1;
5285 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
5286 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5287 "GlobalMemoryStatusEx");
5289 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
5293 return s_pfn_Global_Memory_Status_Ex (buf
);
5297 list_system_processes (void)
5299 struct gcpro gcpro1
;
5300 Lisp_Object proclist
= Qnil
;
5303 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5305 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5307 PROCESSENTRY32 proc_entry
;
5313 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
5314 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
5315 res
= process32_next (h_snapshot
, &proc_entry
))
5317 proc_id
= proc_entry
.th32ProcessID
;
5318 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
5321 CloseHandle (h_snapshot
);
5323 proclist
= Fnreverse (proclist
);
5330 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
5332 TOKEN_PRIVILEGES priv
;
5333 DWORD priv_size
= sizeof (priv
);
5334 DWORD opriv_size
= sizeof (*old_priv
);
5335 HANDLE h_token
= NULL
;
5336 HANDLE h_thread
= GetCurrentThread ();
5340 res
= open_thread_token (h_thread
,
5341 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5343 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
5345 if (impersonate_self (SecurityImpersonation
))
5346 res
= open_thread_token (h_thread
,
5347 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5352 priv
.PrivilegeCount
= 1;
5353 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
5354 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
5355 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
5356 old_priv
, &opriv_size
)
5357 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5361 CloseHandle (h_token
);
5367 restore_privilege (TOKEN_PRIVILEGES
*priv
)
5369 DWORD priv_size
= sizeof (*priv
);
5370 HANDLE h_token
= NULL
;
5373 if (open_thread_token (GetCurrentThread (),
5374 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5377 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
5378 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5382 CloseHandle (h_token
);
5388 ltime (ULONGLONG time_100ns
)
5390 ULONGLONG time_sec
= time_100ns
/ 10000000;
5391 int subsec
= time_100ns
% 10000000;
5392 return list4 (make_number (time_sec
>> 16),
5393 make_number (time_sec
& 0xffff),
5394 make_number (subsec
/ 10),
5395 make_number (subsec
% 10 * 100000));
5398 #define U64_TO_LISP_TIME(time) ltime (time)
5401 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
5402 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
5405 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
5406 ULONGLONG tem1
, tem2
, tem3
, tem
;
5409 || !get_process_times_fn
5410 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
5411 &ft_kernel
, &ft_user
))
5414 GetSystemTimeAsFileTime (&ft_current
);
5416 FILETIME_TO_U64 (tem1
, ft_kernel
);
5417 *stime
= U64_TO_LISP_TIME (tem1
);
5419 FILETIME_TO_U64 (tem2
, ft_user
);
5420 *utime
= U64_TO_LISP_TIME (tem2
);
5423 *ttime
= U64_TO_LISP_TIME (tem3
);
5425 FILETIME_TO_U64 (tem
, ft_creation
);
5426 /* Process no 4 (System) returns zero creation time. */
5429 *ctime
= U64_TO_LISP_TIME (tem
);
5433 FILETIME_TO_U64 (tem3
, ft_current
);
5434 tem
= (tem3
- utc_base
) - tem
;
5436 *etime
= U64_TO_LISP_TIME (tem
);
5440 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
5451 system_process_attributes (Lisp_Object pid
)
5453 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5454 Lisp_Object attrs
= Qnil
;
5455 Lisp_Object cmd_str
, decoded_cmd
, tem
;
5456 HANDLE h_snapshot
, h_proc
;
5459 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
5460 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
5461 DWORD glength
= sizeof (gname
);
5462 HANDLE token
= NULL
;
5463 SID_NAME_USE user_type
;
5464 unsigned char *buf
= NULL
;
5466 TOKEN_USER user_token
;
5467 TOKEN_PRIMARY_GROUP group_token
;
5470 PROCESS_MEMORY_COUNTERS mem
;
5471 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
5472 SIZE_T minrss
, maxrss
;
5474 MEMORY_STATUS_EX memstex
;
5475 double totphys
= 0.0;
5476 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
5478 BOOL result
= FALSE
;
5480 CHECK_NUMBER_OR_FLOAT (pid
);
5481 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
5483 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5485 GCPRO3 (attrs
, decoded_cmd
, tem
);
5487 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5492 pe
.dwSize
= sizeof (PROCESSENTRY32
);
5493 for (res
= process32_first (h_snapshot
, &pe
); res
;
5494 res
= process32_next (h_snapshot
, &pe
))
5496 if (proc_id
== pe
.th32ProcessID
)
5499 decoded_cmd
= build_string ("Idle");
5502 /* Decode the command name from locale-specific
5504 cmd_str
= make_unibyte_string (pe
.szExeFile
,
5505 strlen (pe
.szExeFile
));
5507 code_convert_string_norecord (cmd_str
,
5508 Vlocale_coding_system
, 0);
5510 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
5511 attrs
= Fcons (Fcons (Qppid
,
5512 make_fixnum_or_float (pe
.th32ParentProcessID
)),
5514 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
5516 attrs
= Fcons (Fcons (Qthcount
,
5517 make_fixnum_or_float (pe
.cntThreads
)),
5524 CloseHandle (h_snapshot
);
5533 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5535 /* If we were denied a handle to the process, try again after
5536 enabling the SeDebugPrivilege in our process. */
5539 TOKEN_PRIVILEGES priv_current
;
5541 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
5543 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5545 restore_privilege (&priv_current
);
5551 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
5554 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
5555 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5557 buf
= xmalloc (blen
);
5558 result
= get_token_information (token
, TokenUser
,
5559 (LPVOID
)buf
, blen
, &needed
);
5562 memcpy (&user_token
, buf
, sizeof (user_token
));
5563 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
5565 euid
= get_rid (user_token
.User
.Sid
);
5566 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
5571 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
5574 strcpy (uname
, "unknown");
5578 ulength
= strlen (uname
);
5584 /* Determine a reasonable euid and gid values. */
5585 if (xstrcasecmp ("administrator", uname
) == 0)
5587 euid
= 500; /* well-known Administrator uid */
5588 egid
= 513; /* well-known None gid */
5592 /* Get group id and name. */
5593 result
= get_token_information (token
, TokenPrimaryGroup
,
5594 (LPVOID
)buf
, blen
, &needed
);
5595 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5597 buf
= xrealloc (buf
, blen
= needed
);
5598 result
= get_token_information (token
, TokenPrimaryGroup
,
5599 (LPVOID
)buf
, blen
, &needed
);
5603 memcpy (&group_token
, buf
, sizeof (group_token
));
5604 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5606 egid
= get_rid (group_token
.PrimaryGroup
);
5607 dlength
= sizeof (domain
);
5609 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5610 gname
, &glength
, NULL
, &dlength
,
5613 w32_add_to_cache (group_token
.PrimaryGroup
,
5617 strcpy (gname
, "None");
5621 glength
= strlen (gname
);
5629 if (!is_windows_9x ())
5631 /* We couldn't open the process token, presumably because of
5632 insufficient access rights. Assume this process is run
5634 strcpy (uname
, "SYSTEM");
5635 strcpy (gname
, "None");
5636 euid
= 18; /* SYSTEM */
5637 egid
= 513; /* None */
5638 glength
= strlen (gname
);
5639 ulength
= strlen (uname
);
5641 /* If we are running under Windows 9X, where security calls are
5642 not supported, we assume all processes are run by the current
5644 else if (GetUserName (uname
, &ulength
))
5646 if (xstrcasecmp ("administrator", uname
) == 0)
5651 strcpy (gname
, "None");
5652 glength
= strlen (gname
);
5653 ulength
= strlen (uname
);
5659 strcpy (uname
, "administrator");
5660 ulength
= strlen (uname
);
5661 strcpy (gname
, "None");
5662 glength
= strlen (gname
);
5665 CloseHandle (token
);
5668 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5669 tem
= make_unibyte_string (uname
, ulength
);
5670 attrs
= Fcons (Fcons (Quser
,
5671 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5673 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5674 tem
= make_unibyte_string (gname
, glength
);
5675 attrs
= Fcons (Fcons (Qgroup
,
5676 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5679 if (global_memory_status_ex (&memstex
))
5680 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5681 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5683 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5684 double, so we need to do this for it... */
5686 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5687 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5688 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5690 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5692 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5693 else if (global_memory_status (&memst
))
5694 totphys
= memst
.dwTotalPhys
/ 1024.0;
5697 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5700 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5702 attrs
= Fcons (Fcons (Qmajflt
,
5703 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5705 attrs
= Fcons (Fcons (Qvsize
,
5706 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5708 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5710 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5713 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5715 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5717 attrs
= Fcons (Fcons (Qmajflt
,
5718 make_fixnum_or_float (mem
.PageFaultCount
)),
5720 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5722 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5725 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5727 DWORD rss
= maxrss
/ 1024;
5729 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5731 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5734 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5736 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5737 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5738 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5739 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5740 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5741 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5744 /* FIXME: Retrieve command line by walking the PEB of the process. */
5747 CloseHandle (h_proc
);
5753 /* Wrappers for winsock functions to map between our file descriptors
5754 and winsock's handles; also set h_errno for convenience.
5756 To allow Emacs to run on systems which don't have winsock support
5757 installed, we dynamically link to winsock on startup if present, and
5758 otherwise provide the minimum necessary functionality
5759 (eg. gethostname). */
5761 /* function pointers for relevant socket functions */
5762 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5763 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5764 int (PASCAL
*pfn_WSAGetLastError
) (void);
5765 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5766 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5767 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5768 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5769 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5770 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5771 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5772 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5773 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5774 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5775 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5776 int (PASCAL
*pfn_WSACleanup
) (void);
5778 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5779 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5780 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5781 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5782 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5783 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5784 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5785 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5786 const char * optval
, int optlen
);
5787 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5788 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5790 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5791 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5792 struct sockaddr
* from
, int * fromlen
);
5793 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5794 const struct sockaddr
* to
, int tolen
);
5796 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5797 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5798 #ifndef HANDLE_FLAG_INHERIT
5799 #define HANDLE_FLAG_INHERIT 1
5803 static int winsock_inuse
;
5808 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5810 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5811 after WSAStartup returns successfully, but it seems reasonable
5812 to allow unloading winsock anyway in that case. */
5813 if (pfn_WSACleanup () == 0 ||
5814 pfn_WSAGetLastError () == WSAENETDOWN
)
5816 if (FreeLibrary (winsock_lib
))
5825 init_winsock (int load_now
)
5827 WSADATA winsockData
;
5829 if (winsock_lib
!= NULL
)
5832 pfn_SetHandleInformation
5833 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5834 "SetHandleInformation");
5836 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5838 if (winsock_lib
!= NULL
)
5840 /* dynamically link to socket functions */
5842 #define LOAD_PROC(fn) \
5843 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5846 LOAD_PROC (WSAStartup
);
5847 LOAD_PROC (WSASetLastError
);
5848 LOAD_PROC (WSAGetLastError
);
5849 LOAD_PROC (WSAEventSelect
);
5850 LOAD_PROC (WSACreateEvent
);
5851 LOAD_PROC (WSACloseEvent
);
5854 LOAD_PROC (connect
);
5855 LOAD_PROC (ioctlsocket
);
5858 LOAD_PROC (closesocket
);
5859 LOAD_PROC (shutdown
);
5862 LOAD_PROC (inet_addr
);
5863 LOAD_PROC (gethostname
);
5864 LOAD_PROC (gethostbyname
);
5865 LOAD_PROC (getservbyname
);
5866 LOAD_PROC (getpeername
);
5867 LOAD_PROC (WSACleanup
);
5868 LOAD_PROC (setsockopt
);
5870 LOAD_PROC (getsockname
);
5872 LOAD_PROC (recvfrom
);
5876 /* specify version 1.1 of winsock */
5877 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5879 if (winsockData
.wVersion
!= 0x101)
5884 /* Report that winsock exists and is usable, but leave
5885 socket functions disabled. I am assuming that calling
5886 WSAStartup does not require any network interaction,
5887 and in particular does not cause or require a dial-up
5888 connection to be established. */
5891 FreeLibrary (winsock_lib
);
5899 FreeLibrary (winsock_lib
);
5909 /* function to set h_errno for compatibility; map winsock error codes to
5910 normal system codes where they overlap (non-overlapping definitions
5911 are already in <sys/socket.h> */
5915 if (winsock_lib
== NULL
)
5918 h_errno
= pfn_WSAGetLastError ();
5922 case WSAEACCES
: h_errno
= EACCES
; break;
5923 case WSAEBADF
: h_errno
= EBADF
; break;
5924 case WSAEFAULT
: h_errno
= EFAULT
; break;
5925 case WSAEINTR
: h_errno
= EINTR
; break;
5926 case WSAEINVAL
: h_errno
= EINVAL
; break;
5927 case WSAEMFILE
: h_errno
= EMFILE
; break;
5928 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5929 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5937 if (h_errno
== 0 && winsock_lib
!= NULL
)
5938 pfn_WSASetLastError (0);
5941 /* Extend strerror to handle the winsock-specific error codes. */
5945 } _wsa_errlist
[] = {
5946 {WSAEINTR
, "Interrupted function call"},
5947 {WSAEBADF
, "Bad file descriptor"},
5948 {WSAEACCES
, "Permission denied"},
5949 {WSAEFAULT
, "Bad address"},
5950 {WSAEINVAL
, "Invalid argument"},
5951 {WSAEMFILE
, "Too many open files"},
5953 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5954 {WSAEINPROGRESS
, "Operation now in progress"},
5955 {WSAEALREADY
, "Operation already in progress"},
5956 {WSAENOTSOCK
, "Socket operation on non-socket"},
5957 {WSAEDESTADDRREQ
, "Destination address required"},
5958 {WSAEMSGSIZE
, "Message too long"},
5959 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5960 {WSAENOPROTOOPT
, "Bad protocol option"},
5961 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5962 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5963 {WSAEOPNOTSUPP
, "Operation not supported"},
5964 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5965 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5966 {WSAEADDRINUSE
, "Address already in use"},
5967 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5968 {WSAENETDOWN
, "Network is down"},
5969 {WSAENETUNREACH
, "Network is unreachable"},
5970 {WSAENETRESET
, "Network dropped connection on reset"},
5971 {WSAECONNABORTED
, "Software caused connection abort"},
5972 {WSAECONNRESET
, "Connection reset by peer"},
5973 {WSAENOBUFS
, "No buffer space available"},
5974 {WSAEISCONN
, "Socket is already connected"},
5975 {WSAENOTCONN
, "Socket is not connected"},
5976 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5977 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5978 {WSAETIMEDOUT
, "Connection timed out"},
5979 {WSAECONNREFUSED
, "Connection refused"},
5980 {WSAELOOP
, "Network loop"}, /* not sure */
5981 {WSAENAMETOOLONG
, "Name is too long"},
5982 {WSAEHOSTDOWN
, "Host is down"},
5983 {WSAEHOSTUNREACH
, "No route to host"},
5984 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5985 {WSAEPROCLIM
, "Too many processes"},
5986 {WSAEUSERS
, "Too many users"}, /* not sure */
5987 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5988 {WSAESTALE
, "Data is stale"}, /* not sure */
5989 {WSAEREMOTE
, "Remote error"}, /* not sure */
5991 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5992 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5993 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5994 {WSAEDISCON
, "Graceful shutdown in progress"},
5996 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5997 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5998 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5999 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
6000 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
6001 {WSASYSCALLFAILURE
, "System call failure"},
6002 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
6003 {WSATYPE_NOT_FOUND
, "Class type not found"},
6004 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
6005 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
6006 {WSAEREFUSED
, "Operation refused"}, /* not sure */
6009 {WSAHOST_NOT_FOUND
, "Host not found"},
6010 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
6011 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
6012 {WSANO_DATA
, "Valid name, no data record of requested type"},
6018 sys_strerror (int error_no
)
6021 static char unknown_msg
[40];
6023 if (error_no
>= 0 && error_no
< sys_nerr
)
6024 return sys_errlist
[error_no
];
6026 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
6027 if (_wsa_errlist
[i
].errnum
== error_no
)
6028 return _wsa_errlist
[i
].msg
;
6030 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
6034 /* [andrewi 3-May-96] I've had conflicting results using both methods,
6035 but I believe the method of keeping the socket handle separate (and
6036 insuring it is not inheritable) is the correct one. */
6038 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
6040 static int socket_to_fd (SOCKET s
);
6043 sys_socket (int af
, int type
, int protocol
)
6047 if (winsock_lib
== NULL
)
6050 return INVALID_SOCKET
;
6055 /* call the real socket function */
6056 s
= pfn_socket (af
, type
, protocol
);
6058 if (s
!= INVALID_SOCKET
)
6059 return socket_to_fd (s
);
6065 /* Convert a SOCKET to a file descriptor. */
6067 socket_to_fd (SOCKET s
)
6072 /* Although under NT 3.5 _open_osfhandle will accept a socket
6073 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
6074 that does not work under NT 3.1. However, we can get the same
6075 effect by using a backdoor function to replace an existing
6076 descriptor handle with the one we want. */
6078 /* allocate a file descriptor (with appropriate flags) */
6079 fd
= _open ("NUL:", _O_RDWR
);
6082 /* Make a non-inheritable copy of the socket handle. Note
6083 that it is possible that sockets aren't actually kernel
6084 handles, which appears to be the case on Windows 9x when
6085 the MS Proxy winsock client is installed. */
6087 /* Apparently there is a bug in NT 3.51 with some service
6088 packs, which prevents using DuplicateHandle to make a
6089 socket handle non-inheritable (causes WSACleanup to
6090 hang). The work-around is to use SetHandleInformation
6091 instead if it is available and implemented. */
6092 if (pfn_SetHandleInformation
)
6094 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
6098 HANDLE parent
= GetCurrentProcess ();
6099 HANDLE new_s
= INVALID_HANDLE_VALUE
;
6101 if (DuplicateHandle (parent
,
6107 DUPLICATE_SAME_ACCESS
))
6109 /* It is possible that DuplicateHandle succeeds even
6110 though the socket wasn't really a kernel handle,
6111 because a real handle has the same value. So
6112 test whether the new handle really is a socket. */
6113 long nonblocking
= 0;
6114 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
6116 pfn_closesocket (s
);
6121 CloseHandle (new_s
);
6126 fd_info
[fd
].hnd
= (HANDLE
) s
;
6128 /* set our own internal flags */
6129 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
6135 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6137 /* attach child_process to fd_info */
6138 if (fd_info
[ fd
].cp
!= NULL
)
6140 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
6144 fd_info
[ fd
].cp
= cp
;
6147 winsock_inuse
++; /* count open sockets */
6154 pfn_closesocket (s
);
6160 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
6162 if (winsock_lib
== NULL
)
6165 return SOCKET_ERROR
;
6169 if (fd_info
[s
].flags
& FILE_SOCKET
)
6171 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
6172 if (rc
== SOCKET_ERROR
)
6177 return SOCKET_ERROR
;
6181 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
6183 if (winsock_lib
== NULL
)
6186 return SOCKET_ERROR
;
6190 if (fd_info
[s
].flags
& FILE_SOCKET
)
6192 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
6193 if (rc
== SOCKET_ERROR
)
6198 return SOCKET_ERROR
;
6202 sys_htons (u_short hostshort
)
6204 return (winsock_lib
!= NULL
) ?
6205 pfn_htons (hostshort
) : hostshort
;
6209 sys_ntohs (u_short netshort
)
6211 return (winsock_lib
!= NULL
) ?
6212 pfn_ntohs (netshort
) : netshort
;
6216 sys_inet_addr (const char * cp
)
6218 return (winsock_lib
!= NULL
) ?
6219 pfn_inet_addr (cp
) : INADDR_NONE
;
6223 sys_gethostname (char * name
, int namelen
)
6225 if (winsock_lib
!= NULL
)
6226 return pfn_gethostname (name
, namelen
);
6228 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
6229 return !GetComputerName (name
, (DWORD
*)&namelen
);
6232 return SOCKET_ERROR
;
6236 sys_gethostbyname (const char * name
)
6238 struct hostent
* host
;
6240 if (winsock_lib
== NULL
)
6247 host
= pfn_gethostbyname (name
);
6254 sys_getservbyname (const char * name
, const char * proto
)
6256 struct servent
* serv
;
6258 if (winsock_lib
== NULL
)
6265 serv
= pfn_getservbyname (name
, proto
);
6272 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
6274 if (winsock_lib
== NULL
)
6277 return SOCKET_ERROR
;
6281 if (fd_info
[s
].flags
& FILE_SOCKET
)
6283 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
6284 if (rc
== SOCKET_ERROR
)
6289 return SOCKET_ERROR
;
6293 sys_shutdown (int s
, int how
)
6295 if (winsock_lib
== NULL
)
6298 return SOCKET_ERROR
;
6302 if (fd_info
[s
].flags
& FILE_SOCKET
)
6304 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
6305 if (rc
== SOCKET_ERROR
)
6310 return SOCKET_ERROR
;
6314 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
6316 if (winsock_lib
== NULL
)
6319 return SOCKET_ERROR
;
6323 if (fd_info
[s
].flags
& FILE_SOCKET
)
6325 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
6326 (const char *)optval
, optlen
);
6327 if (rc
== SOCKET_ERROR
)
6332 return SOCKET_ERROR
;
6336 sys_listen (int s
, int backlog
)
6338 if (winsock_lib
== NULL
)
6341 return SOCKET_ERROR
;
6345 if (fd_info
[s
].flags
& FILE_SOCKET
)
6347 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
6348 if (rc
== SOCKET_ERROR
)
6351 fd_info
[s
].flags
|= FILE_LISTEN
;
6355 return SOCKET_ERROR
;
6359 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
6361 if (winsock_lib
== NULL
)
6364 return SOCKET_ERROR
;
6368 if (fd_info
[s
].flags
& FILE_SOCKET
)
6370 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
6371 if (rc
== SOCKET_ERROR
)
6376 return SOCKET_ERROR
;
6380 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
6382 if (winsock_lib
== NULL
)
6389 if (fd_info
[s
].flags
& FILE_LISTEN
)
6391 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
6393 if (t
== INVALID_SOCKET
)
6396 fd
= socket_to_fd (t
);
6398 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6399 ResetEvent (fd_info
[s
].cp
->char_avail
);
6407 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
6408 struct sockaddr
* from
, int * fromlen
)
6410 if (winsock_lib
== NULL
)
6413 return SOCKET_ERROR
;
6417 if (fd_info
[s
].flags
& FILE_SOCKET
)
6419 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
6420 if (rc
== SOCKET_ERROR
)
6425 return SOCKET_ERROR
;
6429 sys_sendto (int s
, const char * buf
, int len
, int flags
,
6430 const struct sockaddr
* to
, int tolen
)
6432 if (winsock_lib
== NULL
)
6435 return SOCKET_ERROR
;
6439 if (fd_info
[s
].flags
& FILE_SOCKET
)
6441 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
6442 if (rc
== SOCKET_ERROR
)
6447 return SOCKET_ERROR
;
6450 /* Windows does not have an fcntl function. Provide an implementation
6451 solely for making sockets non-blocking. */
6453 fcntl (int s
, int cmd
, int options
)
6455 if (winsock_lib
== NULL
)
6462 if (fd_info
[s
].flags
& FILE_SOCKET
)
6464 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
6466 unsigned long nblock
= 1;
6467 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
6468 if (rc
== SOCKET_ERROR
)
6470 /* Keep track of the fact that we set this to non-blocking. */
6471 fd_info
[s
].flags
|= FILE_NDELAY
;
6477 return SOCKET_ERROR
;
6481 return SOCKET_ERROR
;
6485 /* Shadow main io functions: we need to handle pipes and sockets more
6486 intelligently, and implement non-blocking mode as well. */
6499 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
6501 child_process
* cp
= fd_info
[fd
].cp
;
6503 fd_info
[fd
].cp
= NULL
;
6505 if (CHILD_ACTIVE (cp
))
6507 /* if last descriptor to active child_process then cleanup */
6509 for (i
= 0; i
< MAXDESC
; i
++)
6513 if (fd_info
[i
].cp
== cp
)
6518 if (fd_info
[fd
].flags
& FILE_SOCKET
)
6520 if (winsock_lib
== NULL
) emacs_abort ();
6522 pfn_shutdown (SOCK_HANDLE (fd
), 2);
6523 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
6525 winsock_inuse
--; /* count open sockets */
6527 /* If the process handle is NULL, it's either a socket
6528 or serial connection, or a subprocess that was
6529 already reaped by reap_subprocess, but whose
6530 resources were not yet freed, because its output was
6531 not fully read yet by the time it was reaped. (This
6532 usually happens with async subprocesses whose output
6533 is being read by Emacs.) Otherwise, this process was
6534 not reaped yet, so we set its FD to a negative value
6535 to make sure sys_select will eventually get to
6536 calling the SIGCHLD handler for it, which will then
6537 invoke waitpid and reap_subprocess. */
6538 if (cp
->procinfo
.hProcess
== NULL
)
6546 /* Note that sockets do not need special treatment here (at least on
6547 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6548 closesocket is equivalent to CloseHandle, which is to be expected
6549 because socket handles are fully fledged kernel handles. */
6552 if (rc
== 0 && fd
< MAXDESC
)
6553 fd_info
[fd
].flags
= 0;
6564 if (new_fd
>= 0 && new_fd
< MAXDESC
)
6566 /* duplicate our internal info as well */
6567 fd_info
[new_fd
] = fd_info
[fd
];
6573 sys_dup2 (int src
, int dst
)
6577 if (dst
< 0 || dst
>= MAXDESC
)
6583 /* make sure we close the destination first if it's a pipe or socket */
6584 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
6587 rc
= _dup2 (src
, dst
);
6590 /* duplicate our internal info as well */
6591 fd_info
[dst
] = fd_info
[src
];
6596 /* Unix pipe() has only one arg */
6598 sys_pipe (int * phandles
)
6603 /* make pipe handles non-inheritable; when we spawn a child, we
6604 replace the relevant handle with an inheritable one. Also put
6605 pipes into binary mode; we will do text mode translation ourselves
6607 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
6611 /* Protect against overflow, since Windows can open more handles than
6612 our fd_info array has room for. */
6613 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
6615 _close (phandles
[0]);
6616 _close (phandles
[1]);
6621 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6622 fd_info
[phandles
[0]].flags
= flags
;
6624 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6625 fd_info
[phandles
[1]].flags
= flags
;
6632 /* Function to do blocking read of one byte, needed to implement
6633 select. It is only allowed on communication ports, sockets, or
6636 _sys_read_ahead (int fd
)
6641 if (fd
< 0 || fd
>= MAXDESC
)
6642 return STATUS_READ_ERROR
;
6644 cp
= fd_info
[fd
].cp
;
6646 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6647 return STATUS_READ_ERROR
;
6649 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6650 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6652 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6656 cp
->status
= STATUS_READ_IN_PROGRESS
;
6658 if (fd_info
[fd
].flags
& FILE_PIPE
)
6660 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6662 /* Give subprocess time to buffer some more output for us before
6663 reporting that input is available; we need this because Windows 95
6664 connects DOS programs to pipes by making the pipe appear to be
6665 the normal console stdout - as a result most DOS programs will
6666 write to stdout without buffering, ie. one character at a
6667 time. Even some W32 programs do this - "dir" in a command
6668 shell on NT is very slow if we don't do this. */
6671 int wait
= w32_pipe_read_delay
;
6677 /* Yield remainder of our time slice, effectively giving a
6678 temporary priority boost to the child process. */
6682 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6684 HANDLE hnd
= fd_info
[fd
].hnd
;
6685 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6688 /* Configure timeouts for blocking read. */
6689 if (!GetCommTimeouts (hnd
, &ct
))
6690 return STATUS_READ_ERROR
;
6691 ct
.ReadIntervalTimeout
= 0;
6692 ct
.ReadTotalTimeoutMultiplier
= 0;
6693 ct
.ReadTotalTimeoutConstant
= 0;
6694 if (!SetCommTimeouts (hnd
, &ct
))
6695 return STATUS_READ_ERROR
;
6697 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6699 if (GetLastError () != ERROR_IO_PENDING
)
6700 return STATUS_READ_ERROR
;
6701 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6702 return STATUS_READ_ERROR
;
6705 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6707 unsigned long nblock
= 0;
6708 /* We always want this to block, so temporarily disable NDELAY. */
6709 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6710 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6712 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6714 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6717 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6721 if (rc
== sizeof (char))
6722 cp
->status
= STATUS_READ_SUCCEEDED
;
6724 cp
->status
= STATUS_READ_FAILED
;
6730 _sys_wait_accept (int fd
)
6736 if (fd
< 0 || fd
>= MAXDESC
)
6737 return STATUS_READ_ERROR
;
6739 cp
= fd_info
[fd
].cp
;
6741 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6742 return STATUS_READ_ERROR
;
6744 cp
->status
= STATUS_READ_FAILED
;
6746 hEv
= pfn_WSACreateEvent ();
6747 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6748 if (rc
!= SOCKET_ERROR
)
6750 rc
= WaitForSingleObject (hEv
, INFINITE
);
6751 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6752 if (rc
== WAIT_OBJECT_0
)
6753 cp
->status
= STATUS_READ_SUCCEEDED
;
6755 pfn_WSACloseEvent (hEv
);
6761 sys_read (int fd
, char * buffer
, unsigned int count
)
6766 char * orig_buffer
= buffer
;
6774 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6776 child_process
*cp
= fd_info
[fd
].cp
;
6778 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6786 /* re-read CR carried over from last read */
6787 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6789 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6793 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6796 /* presence of a child_process structure means we are operating in
6797 non-blocking mode - otherwise we just call _read directly.
6798 Note that the child_process structure might be missing because
6799 reap_subprocess has been called; in this case the pipe is
6800 already broken, so calling _read on it is okay. */
6803 int current_status
= cp
->status
;
6805 switch (current_status
)
6807 case STATUS_READ_FAILED
:
6808 case STATUS_READ_ERROR
:
6809 /* report normal EOF if nothing in buffer */
6811 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6814 case STATUS_READ_READY
:
6815 case STATUS_READ_IN_PROGRESS
:
6816 DebPrint (("sys_read called when read is in progress\n"));
6817 errno
= EWOULDBLOCK
;
6820 case STATUS_READ_SUCCEEDED
:
6821 /* consume read-ahead char */
6822 *buffer
++ = cp
->chr
;
6825 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6826 ResetEvent (cp
->char_avail
);
6828 case STATUS_READ_ACKNOWLEDGED
:
6832 DebPrint (("sys_read: bad status %d\n", current_status
));
6837 if (fd_info
[fd
].flags
& FILE_PIPE
)
6839 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6840 to_read
= min (waiting
, (DWORD
) count
);
6843 nchars
+= _read (fd
, buffer
, to_read
);
6845 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6847 HANDLE hnd
= fd_info
[fd
].hnd
;
6848 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6854 /* Configure timeouts for non-blocking read. */
6855 if (!GetCommTimeouts (hnd
, &ct
))
6860 ct
.ReadIntervalTimeout
= MAXDWORD
;
6861 ct
.ReadTotalTimeoutMultiplier
= 0;
6862 ct
.ReadTotalTimeoutConstant
= 0;
6863 if (!SetCommTimeouts (hnd
, &ct
))
6869 if (!ResetEvent (ovl
->hEvent
))
6874 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6876 if (GetLastError () != ERROR_IO_PENDING
)
6881 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6890 else /* FILE_SOCKET */
6892 if (winsock_lib
== NULL
) emacs_abort ();
6894 /* do the equivalent of a non-blocking read */
6895 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6896 if (waiting
== 0 && nchars
== 0)
6898 h_errno
= errno
= EWOULDBLOCK
;
6904 /* always use binary mode for sockets */
6905 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6906 if (res
== SOCKET_ERROR
)
6908 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6909 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6919 int nread
= _read (fd
, buffer
, count
);
6922 else if (nchars
== 0)
6927 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6928 /* Perform text mode translation if required. */
6929 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6931 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6932 /* If buffer contains only CR, return that. To be absolutely
6933 sure we should attempt to read the next char, but in
6934 practice a CR to be followed by LF would not appear by
6935 itself in the buffer. */
6936 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6938 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6944 nchars
= _read (fd
, buffer
, count
);
6949 /* From w32xfns.c */
6950 extern HANDLE interrupt_handle
;
6952 /* For now, don't bother with a non-blocking mode */
6954 sys_write (int fd
, const void * buffer
, unsigned int count
)
6964 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6966 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6972 /* Perform text mode translation if required. */
6973 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6975 char * tmpbuf
= alloca (count
* 2);
6976 unsigned char * src
= (void *)buffer
;
6977 unsigned char * dst
= tmpbuf
;
6982 unsigned char *next
;
6983 /* copy next line or remaining bytes */
6984 next
= _memccpy (dst
, src
, '\n', nbytes
);
6987 /* copied one line ending with '\n' */
6988 int copied
= next
- dst
;
6991 /* insert '\r' before '\n' */
6998 /* copied remaining partial line -> now finished */
7005 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
7007 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
7008 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
7009 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
7012 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
7014 if (GetLastError () != ERROR_IO_PENDING
)
7019 if (detect_input_pending ())
7020 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
7023 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
7024 if (active
== WAIT_OBJECT_0
)
7025 { /* User pressed C-g, cancel write, then leave. Don't bother
7026 cleaning up as we may only get stuck in buggy drivers. */
7027 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
7032 if (active
== WAIT_OBJECT_0
+ 1
7033 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
7040 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
7042 unsigned long nblock
= 0;
7043 if (winsock_lib
== NULL
) emacs_abort ();
7045 /* TODO: implement select() properly so non-blocking I/O works. */
7046 /* For now, make sure the write blocks. */
7047 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7048 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7050 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
7052 /* Set the socket back to non-blocking if it was before,
7053 for other operations that support it. */
7054 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7057 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7060 if (nchars
== SOCKET_ERROR
)
7062 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
7063 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7069 /* Some networked filesystems don't like too large writes, so
7070 break them into smaller chunks. See the Comments section of
7071 the MSDN documentation of WriteFile for details behind the
7072 choice of the value of CHUNK below. See also the thread
7073 http://thread.gmane.org/gmane.comp.version-control.git/145294
7074 in the git mailing list. */
7075 const unsigned char *p
= buffer
;
7076 const unsigned chunk
= 30 * 1024 * 1024;
7081 unsigned this_chunk
= count
< chunk
? count
: chunk
;
7082 int n
= _write (fd
, p
, this_chunk
);
7090 else if (n
< this_chunk
)
7100 /* The Windows CRT functions are "optimized for speed", so they don't
7101 check for timezone and DST changes if they were last called less
7102 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
7103 all Emacs features that repeatedly call time functions (e.g.,
7104 display-time) are in real danger of missing timezone and DST
7105 changes. Calling tzset before each localtime call fixes that. */
7107 sys_localtime (const time_t *t
)
7110 return localtime (t
);
7115 /* Try loading LIBRARY_ID from the file(s) specified in
7116 Vdynamic_library_alist. If the library is loaded successfully,
7117 return the handle of the DLL, and record the filename in the
7118 property :loaded-from of LIBRARY_ID. If the library could not be
7119 found, or when it was already loaded (because the handle is not
7120 recorded anywhere, and so is lost after use), return NULL.
7122 We could also save the handle in :loaded-from, but currently
7123 there's no use case for it. */
7125 w32_delayed_load (Lisp_Object library_id
)
7127 HMODULE library_dll
= NULL
;
7129 CHECK_SYMBOL (library_id
);
7131 if (CONSP (Vdynamic_library_alist
)
7132 && NILP (Fassq (library_id
, Vlibrary_cache
)))
7134 Lisp_Object found
= Qnil
;
7135 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
7138 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
7140 CHECK_STRING_CAR (dlls
);
7141 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
7143 char name
[MAX_PATH
];
7146 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
7147 found
= Fcons (XCAR (dlls
),
7149 /* Possibly truncated */
7150 ? make_specified_string (name
, -1, len
, 1)
7156 Fput (library_id
, QCloaded_from
, found
);
7164 check_windows_init_file (void)
7166 /* A common indication that Emacs is not installed properly is when
7167 it cannot find the Windows installation file. If this file does
7168 not exist in the expected place, tell the user. */
7170 if (!noninteractive
&& !inhibit_window_system
7171 /* Vload_path is not yet initialized when we are loading
7173 && NILP (Vpurify_flag
))
7175 Lisp_Object init_file
;
7178 init_file
= build_string ("term/w32-win");
7179 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
7182 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
7183 char *init_file_name
= SDATA (init_file
);
7184 char *load_path
= SDATA (load_path_print
);
7185 char *buffer
= alloca (1024
7186 + strlen (init_file_name
)
7187 + strlen (load_path
));
7190 "The Emacs Windows initialization file \"%s.el\" "
7191 "could not be found in your Emacs installation. "
7192 "Emacs checked the following directories for this file:\n"
7194 "When Emacs cannot find this file, it usually means that it "
7195 "was not installed properly, or its distribution file was "
7196 "not unpacked properly.\nSee the README.W32 file in the "
7197 "top-level Emacs directory for more information.",
7198 init_file_name
, load_path
);
7201 "Emacs Abort Dialog",
7202 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
7203 /* Use the low-level system abort. */
7214 term_ntproc (int ignored
)
7220 /* shutdown the socket interface if necessary */
7227 init_ntproc (int dumping
)
7229 sigset_t initial_mask
= 0;
7231 /* Initialize the socket interface now if available and requested by
7232 the user by defining PRELOAD_WINSOCK; otherwise loading will be
7233 delayed until open-network-stream is called (w32-has-winsock can
7234 also be used to dynamically load or reload winsock).
7236 Conveniently, init_environment is called before us, so
7237 PRELOAD_WINSOCK can be set in the registry. */
7239 /* Always initialize this correctly. */
7242 if (getenv ("PRELOAD_WINSOCK") != NULL
)
7243 init_winsock (TRUE
);
7245 /* Initial preparation for subprocess support: replace our standard
7246 handles with non-inheritable versions. */
7249 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
7250 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
7251 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
7253 parent
= GetCurrentProcess ();
7255 /* ignore errors when duplicating and closing; typically the
7256 handles will be invalid when running as a gui program. */
7257 DuplicateHandle (parent
,
7258 GetStdHandle (STD_INPUT_HANDLE
),
7263 DUPLICATE_SAME_ACCESS
);
7265 DuplicateHandle (parent
,
7266 GetStdHandle (STD_OUTPUT_HANDLE
),
7271 DUPLICATE_SAME_ACCESS
);
7273 DuplicateHandle (parent
,
7274 GetStdHandle (STD_ERROR_HANDLE
),
7279 DUPLICATE_SAME_ACCESS
);
7285 if (stdin_save
!= INVALID_HANDLE_VALUE
)
7286 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
7288 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
7291 if (stdout_save
!= INVALID_HANDLE_VALUE
)
7292 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
7294 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7297 if (stderr_save
!= INVALID_HANDLE_VALUE
)
7298 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
7300 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7304 /* unfortunately, atexit depends on implementation of malloc */
7305 /* atexit (term_ntproc); */
7308 /* Make sure we start with all signals unblocked. */
7309 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
7310 signal (SIGABRT
, term_ntproc
);
7314 /* determine which drives are fixed, for GetCachedVolumeInformation */
7316 /* GetDriveType must have trailing backslash. */
7317 char drive
[] = "A:\\";
7319 /* Loop over all possible drive letters */
7320 while (*drive
<= 'Z')
7322 /* Record if this drive letter refers to a fixed drive. */
7323 fixed_drives
[DRIVE_INDEX (*drive
)] =
7324 (GetDriveType (drive
) == DRIVE_FIXED
);
7329 /* Reset the volume info cache. */
7330 volume_cache
= NULL
;
7335 shutdown_handler ensures that buffers' autosave files are
7336 up to date when the user logs off, or the system shuts down.
7339 shutdown_handler (DWORD type
)
7341 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
7342 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
7343 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
7344 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
7346 /* Shut down cleanly, making sure autosave files are up to date. */
7347 shut_down_emacs (0, Qnil
);
7350 /* Allow other handlers to handle this signal. */
7355 globals_of_w32 is used to initialize those global variables that
7356 must always be initialized on startup even when the global variable
7357 initialized is non zero (see the function main in emacs.c).
7360 globals_of_w32 (void)
7362 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
7364 get_process_times_fn
= (GetProcessTimes_Proc
)
7365 GetProcAddress (kernel32
, "GetProcessTimes");
7367 DEFSYM (QCloaded_from
, ":loaded-from");
7369 g_b_init_is_windows_9x
= 0;
7370 g_b_init_open_process_token
= 0;
7371 g_b_init_get_token_information
= 0;
7372 g_b_init_lookup_account_sid
= 0;
7373 g_b_init_get_sid_sub_authority
= 0;
7374 g_b_init_get_sid_sub_authority_count
= 0;
7375 g_b_init_get_security_info
= 0;
7376 g_b_init_get_file_security
= 0;
7377 g_b_init_get_security_descriptor_owner
= 0;
7378 g_b_init_get_security_descriptor_group
= 0;
7379 g_b_init_is_valid_sid
= 0;
7380 g_b_init_create_toolhelp32_snapshot
= 0;
7381 g_b_init_process32_first
= 0;
7382 g_b_init_process32_next
= 0;
7383 g_b_init_open_thread_token
= 0;
7384 g_b_init_impersonate_self
= 0;
7385 g_b_init_revert_to_self
= 0;
7386 g_b_init_get_process_memory_info
= 0;
7387 g_b_init_get_process_working_set_size
= 0;
7388 g_b_init_global_memory_status
= 0;
7389 g_b_init_global_memory_status_ex
= 0;
7390 g_b_init_equal_sid
= 0;
7391 g_b_init_copy_sid
= 0;
7392 g_b_init_get_length_sid
= 0;
7393 g_b_init_get_native_system_info
= 0;
7394 g_b_init_get_system_times
= 0;
7395 g_b_init_create_symbolic_link
= 0;
7396 g_b_init_get_security_descriptor_dacl
= 0;
7397 g_b_init_convert_sd_to_sddl
= 0;
7398 g_b_init_convert_sddl_to_sd
= 0;
7399 g_b_init_is_valid_security_descriptor
= 0;
7400 g_b_init_set_file_security
= 0;
7401 num_of_processors
= 0;
7402 /* The following sets a handler for shutdown notifications for
7403 console apps. This actually applies to Emacs in both console and
7404 GUI modes, since we had to fool windows into thinking emacs is a
7405 console application to get console mode to work. */
7406 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
7408 /* "None" is the default group name on standalone workstations. */
7409 strcpy (dflt_group_name
, "None");
7411 /* Reset, in case it has some value inherited from dump time. */
7412 w32_stat_get_owner_group
= 0;
7415 /* For make-serial-process */
7417 serial_open (char *port
)
7423 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
7424 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
7425 if (hnd
== INVALID_HANDLE_VALUE
)
7426 error ("Could not open %s", port
);
7427 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
7429 error ("Could not open %s", port
);
7433 error ("Could not create child process");
7435 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7436 fd_info
[ fd
].hnd
= hnd
;
7437 fd_info
[ fd
].flags
|=
7438 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
7439 if (fd_info
[ fd
].cp
!= NULL
)
7441 error ("fd_info[fd = %d] is already in use", fd
);
7443 fd_info
[ fd
].cp
= cp
;
7444 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7445 if (cp
->ovl_read
.hEvent
== NULL
)
7446 error ("Could not create read event");
7447 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7448 if (cp
->ovl_write
.hEvent
== NULL
)
7449 error ("Could not create write event");
7454 /* For serial-process-configure */
7456 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
7458 Lisp_Object childp2
= Qnil
;
7459 Lisp_Object tem
= Qnil
;
7463 char summary
[4] = "???"; /* This usually becomes "8N1". */
7465 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
7466 error ("Not a serial process");
7467 hnd
= fd_info
[ p
->outfd
].hnd
;
7469 childp2
= Fcopy_sequence (p
->childp
);
7471 /* Initialize timeouts for blocking read and blocking write. */
7472 if (!GetCommTimeouts (hnd
, &ct
))
7473 error ("GetCommTimeouts() failed");
7474 ct
.ReadIntervalTimeout
= 0;
7475 ct
.ReadTotalTimeoutMultiplier
= 0;
7476 ct
.ReadTotalTimeoutConstant
= 0;
7477 ct
.WriteTotalTimeoutMultiplier
= 0;
7478 ct
.WriteTotalTimeoutConstant
= 0;
7479 if (!SetCommTimeouts (hnd
, &ct
))
7480 error ("SetCommTimeouts() failed");
7481 /* Read port attributes and prepare default configuration. */
7482 memset (&dcb
, 0, sizeof (dcb
));
7483 dcb
.DCBlength
= sizeof (DCB
);
7484 if (!GetCommState (hnd
, &dcb
))
7485 error ("GetCommState() failed");
7488 dcb
.fAbortOnError
= FALSE
;
7489 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7494 /* Configure speed. */
7495 if (!NILP (Fplist_member (contact
, QCspeed
)))
7496 tem
= Fplist_get (contact
, QCspeed
);
7498 tem
= Fplist_get (p
->childp
, QCspeed
);
7500 dcb
.BaudRate
= XINT (tem
);
7501 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
7503 /* Configure bytesize. */
7504 if (!NILP (Fplist_member (contact
, QCbytesize
)))
7505 tem
= Fplist_get (contact
, QCbytesize
);
7507 tem
= Fplist_get (p
->childp
, QCbytesize
);
7509 tem
= make_number (8);
7511 if (XINT (tem
) != 7 && XINT (tem
) != 8)
7512 error (":bytesize must be nil (8), 7, or 8");
7513 dcb
.ByteSize
= XINT (tem
);
7514 summary
[0] = XINT (tem
) + '0';
7515 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
7517 /* Configure parity. */
7518 if (!NILP (Fplist_member (contact
, QCparity
)))
7519 tem
= Fplist_get (contact
, QCparity
);
7521 tem
= Fplist_get (p
->childp
, QCparity
);
7522 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
7523 error (":parity must be nil (no parity), `even', or `odd'");
7524 dcb
.fParity
= FALSE
;
7525 dcb
.Parity
= NOPARITY
;
7526 dcb
.fErrorChar
= FALSE
;
7531 else if (EQ (tem
, Qeven
))
7535 dcb
.Parity
= EVENPARITY
;
7536 dcb
.fErrorChar
= TRUE
;
7538 else if (EQ (tem
, Qodd
))
7542 dcb
.Parity
= ODDPARITY
;
7543 dcb
.fErrorChar
= TRUE
;
7545 childp2
= Fplist_put (childp2
, QCparity
, tem
);
7547 /* Configure stopbits. */
7548 if (!NILP (Fplist_member (contact
, QCstopbits
)))
7549 tem
= Fplist_get (contact
, QCstopbits
);
7551 tem
= Fplist_get (p
->childp
, QCstopbits
);
7553 tem
= make_number (1);
7555 if (XINT (tem
) != 1 && XINT (tem
) != 2)
7556 error (":stopbits must be nil (1 stopbit), 1, or 2");
7557 summary
[2] = XINT (tem
) + '0';
7558 if (XINT (tem
) == 1)
7559 dcb
.StopBits
= ONESTOPBIT
;
7560 else if (XINT (tem
) == 2)
7561 dcb
.StopBits
= TWOSTOPBITS
;
7562 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
7564 /* Configure flowcontrol. */
7565 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
7566 tem
= Fplist_get (contact
, QCflowcontrol
);
7568 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
7569 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
7570 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7571 dcb
.fOutxCtsFlow
= FALSE
;
7572 dcb
.fOutxDsrFlow
= FALSE
;
7573 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
7574 dcb
.fDsrSensitivity
= FALSE
;
7575 dcb
.fTXContinueOnXoff
= FALSE
;
7578 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
7579 dcb
.XonChar
= 17; /* Control-Q */
7580 dcb
.XoffChar
= 19; /* Control-S */
7583 /* Already configured. */
7585 else if (EQ (tem
, Qhw
))
7587 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
7588 dcb
.fOutxCtsFlow
= TRUE
;
7590 else if (EQ (tem
, Qsw
))
7595 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
7597 /* Activate configuration. */
7598 if (!SetCommState (hnd
, &dcb
))
7599 error ("SetCommState() failed");
7601 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
7602 pset_childp (p
, childp2
);
7608 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
7613 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7614 int fd
= process
->infd
;
7618 n
= sys_read (fd
, (char*)buf
, sz
);
7625 if (err
== EWOULDBLOCK
)
7627 /* Set a small timeout. */
7628 timeout
= make_emacs_time (1, 0);
7630 FD_SET ((int)fd
, &fdset
);
7632 /* Use select with the timeout to poll the selector. */
7633 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7637 continue; /* Try again. */
7639 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7640 Also accept select return 0 as an indicator to EAGAIN. */
7641 if (sc
== 0 || errno
== EWOULDBLOCK
)
7644 err
= errno
; /* Other errors are just passed on. */
7647 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7654 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7656 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7657 int fd
= process
->outfd
;
7658 ssize_t n
= sys_write (fd
, buf
, sz
);
7660 /* 0 or more bytes written means everything went fine. */
7664 /* Negative bytes written means we got an error in errno.
7665 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7666 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7667 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7671 #endif /* HAVE_GNUTLS */