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, _mbslwr, _mbsrchr, ... */
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
, int multibyte
)
1605 int dbcs_p
= max_filename_mbslen () > 1;
1607 /* Multibyte file names are in the Emacs internal representation, so
1608 we can traverse them by bytes with no problems. */
1612 /* Always lower-case drive letters a-z, even if the filesystem
1613 preserves case in filenames.
1614 This is so filenames can be compared by string comparison
1615 functions that are case-sensitive. Even case-preserving filesystems
1616 do not distinguish case in drive letters. */
1618 p2
= CharNextExA (file_name_codepage
, fp
, 0);
1622 if (*p2
== ':' && *fp
>= 'A' && *fp
<= 'Z')
1628 if (multibyte
|| NILP (Vw32_downcase_file_names
))
1632 if (*fp
== '/' || *fp
== '\\')
1637 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1642 sep
= path_sep
; /* convert to this path separator */
1643 elem
= fp
; /* start of current path element */
1646 if (*fp
>= 'a' && *fp
<= 'z')
1647 elem
= 0; /* don't convert this element */
1649 if (*fp
== 0 || *fp
== ':')
1651 sep
= *fp
; /* restore current separator (or 0) */
1652 *fp
= '/'; /* after conversion of this element */
1655 if (*fp
== '/' || *fp
== '\\')
1657 if (elem
&& elem
!= fp
)
1659 *fp
= 0; /* temporary end of string */
1660 _mbslwr (elem
); /* while we convert to lower case */
1662 *fp
= sep
; /* convert (or restore) path separator */
1663 elem
= fp
+ 1; /* next element starts after separator */
1671 fp
= CharNextExA (file_name_codepage
, fp
, 0);
1676 /* Destructively turn backslashes into slashes. MULTIBYTE non-zero
1677 means the file name is a multibyte string in Emacs's internal
1680 dostounix_filename (register char *p
, int multibyte
)
1682 normalize_filename (p
, '/', multibyte
);
1685 /* Destructively turn slashes into backslashes. */
1687 unixtodos_filename (register char *p
)
1689 normalize_filename (p
, '\\', 0);
1692 /* Remove all CR's that are followed by a LF.
1693 (From msdos.c...probably should figure out a way to share it,
1694 although this code isn't going to ever change.) */
1696 crlf_to_lf (register int n
, register unsigned char *buf
)
1698 unsigned char *np
= buf
;
1699 unsigned char *startp
= buf
;
1700 unsigned char *endp
= buf
+ n
;
1704 while (buf
< endp
- 1)
1708 if (*(++buf
) != 0x0a)
1719 /* Parse the root part of file name, if present. Return length and
1720 optionally store pointer to char after root. */
1722 parse_root (char * name
, char ** pPath
)
1724 char * start
= name
;
1729 /* find the root name of the volume if given */
1730 if (isalpha (name
[0]) && name
[1] == ':')
1732 /* skip past drive specifier */
1734 if (IS_DIRECTORY_SEP (name
[0]))
1737 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1740 int dbcs_p
= max_filename_mbslen () > 1;
1745 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1748 name
= CharNextExA (file_name_codepage
, name
, 0);
1753 if (IS_DIRECTORY_SEP (name
[0]))
1760 return name
- start
;
1763 /* Get long base name for name; name is assumed to be absolute. */
1765 get_long_basename (char * name
, char * buf
, int size
)
1767 WIN32_FIND_DATA find_data
;
1771 /* must be valid filename, no wild cards or other invalid characters */
1772 if (_mbspbrk (name
, "*?|<>\""))
1775 dir_handle
= FindFirstFile (name
, &find_data
);
1776 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1778 if ((len
= strlen (find_data
.cFileName
)) < size
)
1779 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1782 FindClose (dir_handle
);
1787 /* Get long name for file, if possible (assumed to be absolute). */
1789 w32_get_long_filename (char * name
, char * buf
, int size
)
1794 char full
[ MAX_PATH
];
1797 len
= strlen (name
);
1798 if (len
>= MAX_PATH
)
1801 /* Use local copy for destructive modification. */
1802 memcpy (full
, name
, len
+1);
1803 unixtodos_filename (full
);
1805 /* Copy root part verbatim. */
1806 len
= parse_root (full
, &p
);
1807 memcpy (o
, full
, len
);
1812 while (p
!= NULL
&& *p
)
1815 p
= _mbschr (q
, '\\');
1817 len
= get_long_basename (full
, o
, size
);
1840 is_unc_volume (const char *filename
)
1842 const char *ptr
= filename
;
1844 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1847 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1853 /* Emulate the Posix unsetenv. */
1855 unsetenv (const char *name
)
1861 if (name
== NULL
|| *name
== '\0' || strchr (name
, '=') != NULL
)
1866 name_len
= strlen (name
);
1867 /* MS docs says an environment variable cannot be longer than 32K. */
1868 if (name_len
> 32767)
1873 /* It is safe to use 'alloca' with 32K size, since the stack is at
1874 least 2MB, and we set it to 8MB in the link command line. */
1875 var
= alloca (name_len
+ 2);
1876 strncpy (var
, name
, name_len
);
1877 var
[name_len
++] = '=';
1878 var
[name_len
] = '\0';
1879 return _putenv (var
);
1882 /* MS _putenv doesn't support removing a variable when the argument
1883 does not include the '=' character, so we fix that here. */
1885 sys_putenv (char *str
)
1887 const char *const name_end
= strchr (str
, '=');
1889 if (name_end
== NULL
)
1891 /* Remove the variable from the environment. */
1892 return unsetenv (str
);
1895 return _putenv (str
);
1898 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1901 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1904 HKEY hrootkey
= NULL
;
1907 /* Check both the current user and the local machine to see if
1908 we have any resources. */
1910 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1914 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1915 && (lpvalue
= xmalloc (cbData
)) != NULL
1916 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1918 RegCloseKey (hrootkey
);
1924 RegCloseKey (hrootkey
);
1927 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1931 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1932 && (lpvalue
= xmalloc (cbData
)) != NULL
1933 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1935 RegCloseKey (hrootkey
);
1941 RegCloseKey (hrootkey
);
1947 char *get_emacs_configuration (void);
1950 init_environment (char ** argv
)
1952 static const char * const tempdirs
[] = {
1953 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1958 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1960 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1961 temporary files and assume "/tmp" if $TMPDIR is unset, which
1962 will break on DOS/Windows. Refuse to work if we cannot find
1963 a directory, not even "c:/", usable for that purpose. */
1964 for (i
= 0; i
< imax
; i
++)
1966 const char *tmp
= tempdirs
[i
];
1969 tmp
= getenv (tmp
+ 1);
1970 /* Note that `access' can lie to us if the directory resides on a
1971 read-only filesystem, like CD-ROM or a write-protected floppy.
1972 The only way to be really sure is to actually create a file and
1973 see if it succeeds. But I think that's too much to ask. */
1975 /* MSVCRT's _access crashes with D_OK. */
1976 if (tmp
&& faccessat (AT_FDCWD
, tmp
, D_OK
, AT_EACCESS
) == 0)
1978 char * var
= alloca (strlen (tmp
) + 8);
1979 sprintf (var
, "TMPDIR=%s", tmp
);
1980 _putenv (strdup (var
));
1987 Fcons (build_string ("no usable temporary directories found!!"),
1989 "While setting TMPDIR: ");
1991 /* Check for environment variables and use registry settings if they
1992 don't exist. Fallback on default values where applicable. */
1997 char locale_name
[32];
1998 char default_home
[MAX_PATH
];
2001 static const struct env_entry
2007 /* If the default value is NULL, we will use the value from the
2008 outside environment or the Registry, but will not push the
2009 variable into the Emacs environment if it is defined neither
2010 in the Registry nor in the outside environment. */
2012 {"PRELOAD_WINSOCK", NULL
},
2013 {"emacs_dir", "C:/emacs"},
2014 {"EMACSLOADPATH", NULL
},
2015 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
2016 {"EMACSDATA", NULL
},
2017 {"EMACSPATH", NULL
},
2024 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
2026 /* We need to copy dflt_envvars[] and work on the copy because we
2027 don't want the dumped Emacs to inherit the values of
2028 environment variables we saw during dumping (which could be on
2029 a different system). The defaults above must be left intact. */
2030 struct env_entry env_vars
[N_ENV_VARS
];
2032 for (i
= 0; i
< N_ENV_VARS
; i
++)
2033 env_vars
[i
] = dflt_envvars
[i
];
2035 /* For backwards compatibility, check if a .emacs file exists in C:/
2036 If not, then we can try to default to the appdata directory under the
2037 user's profile, which is more likely to be writable. */
2038 if (!check_existing ("C:/.emacs"))
2040 HRESULT profile_result
;
2041 /* Dynamically load ShGetFolderPath, as it won't exist on versions
2042 of Windows 95 and NT4 that have not been updated to include
2044 ShGetFolderPath_fn get_folder_path
;
2045 get_folder_path
= (ShGetFolderPath_fn
)
2046 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
2048 if (get_folder_path
!= NULL
)
2050 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
2053 /* If we can't get the appdata dir, revert to old behavior. */
2054 if (profile_result
== S_OK
)
2056 env_vars
[0].def_value
= default_home
;
2062 /* Get default locale info and use it for LANG. */
2063 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
2064 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
2065 locale_name
, sizeof (locale_name
)))
2067 for (i
= 0; i
< N_ENV_VARS
; i
++)
2069 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
2071 env_vars
[i
].def_value
= locale_name
;
2077 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
2079 /* Treat emacs_dir specially: set it unconditionally based on our
2083 char modname
[MAX_PATH
];
2085 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2087 if ((p
= _mbsrchr (modname
, '\\')) == NULL
)
2091 if ((p
= _mbsrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
2093 char buf
[SET_ENV_BUF_SIZE
];
2096 for (p
= modname
; *p
; p
= CharNext (p
))
2097 if (*p
== '\\') *p
= '/';
2099 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2100 _putenv (strdup (buf
));
2102 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
2104 /* FIXME: should use substring of get_emacs_configuration ().
2105 But I don't think the Windows build supports alpha, mips etc
2106 anymore, so have taken the easy option for now. */
2107 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
2108 || xstrcasecmp (p
, "\\AMD64") == 0))
2111 p
= _mbsrchr (modname
, '\\');
2115 p
= _mbsrchr (modname
, '\\');
2116 if (p
&& xstrcasecmp (p
, "\\src") == 0)
2118 char buf
[SET_ENV_BUF_SIZE
];
2121 for (p
= modname
; *p
; p
= CharNext (p
))
2122 if (*p
== '\\') *p
= '/';
2124 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
2125 _putenv (strdup (buf
));
2131 for (i
= 0; i
< N_ENV_VARS
; i
++)
2133 if (!getenv (env_vars
[i
].name
))
2137 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
2138 /* Also ignore empty environment variables. */
2142 lpval
= env_vars
[i
].def_value
;
2143 dwType
= REG_EXPAND_SZ
;
2145 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
2146 Vdelayed_warnings_list
2147 = Fcons (listn (CONSTYPE_HEAP
, 2,
2148 intern ("initialization"),
2149 build_string ("Setting HOME to C:\\ by default is deprecated")),
2150 Vdelayed_warnings_list
);
2155 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
2157 if (dwType
== REG_EXPAND_SZ
)
2158 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
2159 else if (dwType
== REG_SZ
)
2160 strcpy (buf1
, lpval
);
2161 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
2163 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
2165 _putenv (strdup (buf2
));
2175 /* Rebuild system configuration to reflect invoking system. */
2176 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
2178 /* Another special case: on NT, the PATH variable is actually named
2179 "Path" although cmd.exe (perhaps NT itself) arranges for
2180 environment variable lookup and setting to be case insensitive.
2181 However, Emacs assumes a fully case sensitive environment, so we
2182 need to change "Path" to "PATH" to match the expectations of
2183 various elisp packages. We do this by the sneaky method of
2184 modifying the string in the C runtime environ entry.
2186 The same applies to COMSPEC. */
2190 for (envp
= environ
; *envp
; envp
++)
2191 if (_strnicmp (*envp
, "PATH=", 5) == 0)
2192 memcpy (*envp
, "PATH=", 5);
2193 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
2194 memcpy (*envp
, "COMSPEC=", 8);
2197 /* Remember the initial working directory for getcwd. */
2198 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
2199 Does it matter anywhere in Emacs? */
2200 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
2204 static char modname
[MAX_PATH
];
2206 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
2211 /* Determine if there is a middle mouse button, to allow parse_button
2212 to decide whether right mouse events should be mouse-2 or
2214 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
2219 /* Called from expand-file-name when default-directory is not a string. */
2222 emacs_root_dir (void)
2224 static char root_dir
[FILENAME_MAX
];
2227 p
= getenv ("emacs_dir");
2230 strcpy (root_dir
, p
);
2231 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
2232 dostounix_filename (root_dir
, 0);
2236 /* We don't have scripts to automatically determine the system configuration
2237 for Emacs before it's compiled, and we don't want to have to make the
2238 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
2242 get_emacs_configuration (void)
2244 char *arch
, *oem
, *os
;
2246 static char configuration_buffer
[32];
2248 /* Determine the processor type. */
2249 switch (get_processor_type ())
2252 #ifdef PROCESSOR_INTEL_386
2253 case PROCESSOR_INTEL_386
:
2254 case PROCESSOR_INTEL_486
:
2255 case PROCESSOR_INTEL_PENTIUM
:
2263 #ifdef PROCESSOR_AMD_X8664
2264 case PROCESSOR_AMD_X8664
:
2269 #ifdef PROCESSOR_MIPS_R2000
2270 case PROCESSOR_MIPS_R2000
:
2271 case PROCESSOR_MIPS_R3000
:
2272 case PROCESSOR_MIPS_R4000
:
2277 #ifdef PROCESSOR_ALPHA_21064
2278 case PROCESSOR_ALPHA_21064
:
2288 /* Use the OEM field to reflect the compiler/library combination. */
2290 #define COMPILER_NAME "msvc"
2293 #define COMPILER_NAME "mingw"
2295 #define COMPILER_NAME "unknown"
2298 oem
= COMPILER_NAME
;
2300 switch (osinfo_cache
.dwPlatformId
) {
2301 case VER_PLATFORM_WIN32_NT
:
2303 build_num
= osinfo_cache
.dwBuildNumber
;
2305 case VER_PLATFORM_WIN32_WINDOWS
:
2306 if (osinfo_cache
.dwMinorVersion
== 0) {
2311 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2313 case VER_PLATFORM_WIN32s
:
2314 /* Not supported, should not happen. */
2316 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
2324 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
2325 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
2326 get_w32_major_version (), get_w32_minor_version (), build_num
);
2328 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
2331 return configuration_buffer
;
2335 get_emacs_configuration_options (void)
2337 static char *options_buffer
;
2338 char cv
[32]; /* Enough for COMPILER_VERSION. */
2340 cv
, /* To be filled later. */
2344 #ifdef ENABLE_CHECKING
2345 " --enable-checking",
2347 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
2348 with a starting space to save work here. */
2350 " --cflags", USER_CFLAGS
,
2353 " --ldflags", USER_LDFLAGS
,
2360 /* Work out the effective configure options for this build. */
2362 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2365 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2367 #define COMPILER_VERSION ""
2371 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2372 return "Error: not enough space for compiler version";
2373 cv
[sizeof (cv
) - 1] = '\0';
2375 for (i
= 0; options
[i
]; i
++)
2376 size
+= strlen (options
[i
]);
2378 options_buffer
= xmalloc (size
+ 1);
2379 options_buffer
[0] = '\0';
2381 for (i
= 0; options
[i
]; i
++)
2382 strcat (options_buffer
, options
[i
]);
2384 return options_buffer
;
2388 #include <sys/timeb.h>
2390 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2392 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2397 tv
->tv_sec
= tb
.time
;
2398 tv
->tv_usec
= tb
.millitm
* 1000L;
2399 /* Implementation note: _ftime sometimes doesn't update the dstflag
2400 according to the new timezone when the system timezone is
2401 changed. We could fix that by using GetSystemTime and
2402 GetTimeZoneInformation, but that doesn't seem necessary, since
2403 Emacs always calls gettimeofday with the 2nd argument NULL (see
2404 current_emacs_time). */
2407 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2408 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2412 /* Emulate fdutimens. */
2414 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2415 TIMESPEC[0] and TIMESPEC[1], respectively.
2416 FD must be either negative -- in which case it is ignored --
2417 or a file descriptor that is open on FILE.
2418 If FD is nonnegative, then FILE can be NULL, which means
2419 use just futimes instead of utimes.
2420 If TIMESPEC is null, FAIL.
2421 Return 0 on success, -1 (setting errno) on failure. */
2424 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2433 if (fd
< 0 && !file
)
2438 ut
.actime
= timespec
[0].tv_sec
;
2439 ut
.modtime
= timespec
[1].tv_sec
;
2441 return _futime (fd
, &ut
);
2443 return _utime (file
, &ut
);
2447 /* ------------------------------------------------------------------------- */
2448 /* IO support and wrapper functions for the Windows API. */
2449 /* ------------------------------------------------------------------------- */
2451 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2452 on network directories, so we handle that case here.
2453 (Ulrich Leodolter, 1/11/95). */
2455 sys_ctime (const time_t *t
)
2457 char *str
= (char *) ctime (t
);
2458 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2461 /* Emulate sleep...we could have done this with a define, but that
2462 would necessitate including windows.h in the files that used it.
2463 This is much easier. */
2465 sys_sleep (int seconds
)
2467 Sleep (seconds
* 1000);
2470 /* Internal MSVC functions for low-level descriptor munging */
2471 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2472 extern int __cdecl
_free_osfhnd (int fd
);
2474 /* parallel array of private info on file handles */
2475 filedesc fd_info
[ MAXDESC
];
2477 typedef struct volume_info_data
{
2478 struct volume_info_data
* next
;
2480 /* time when info was obtained */
2483 /* actual volume info */
2492 /* Global referenced by various functions. */
2493 static volume_info_data volume_info
;
2495 /* Vector to indicate which drives are local and fixed (for which cached
2496 data never expires). */
2497 static BOOL fixed_drives
[26];
2499 /* Consider cached volume information to be stale if older than 10s,
2500 at least for non-local drives. Info for fixed drives is never stale. */
2501 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2502 #define VOLINFO_STILL_VALID( root_dir, info ) \
2503 ( ( isalpha (root_dir[0]) && \
2504 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2505 || GetTickCount () - info->timestamp < 10000 )
2507 /* Cache support functions. */
2509 /* Simple linked list with linear search is sufficient. */
2510 static volume_info_data
*volume_cache
= NULL
;
2512 static volume_info_data
*
2513 lookup_volume_info (char * root_dir
)
2515 volume_info_data
* info
;
2517 for (info
= volume_cache
; info
; info
= info
->next
)
2518 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2524 add_volume_info (char * root_dir
, volume_info_data
* info
)
2526 info
->root_dir
= xstrdup (root_dir
);
2527 info
->next
= volume_cache
;
2528 volume_cache
= info
;
2532 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2533 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2534 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2535 static volume_info_data
*
2536 GetCachedVolumeInformation (char * root_dir
)
2538 volume_info_data
* info
;
2539 char default_root
[ MAX_PATH
];
2541 /* NULL for root_dir means use root from current directory. */
2542 if (root_dir
== NULL
)
2544 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2546 parse_root (default_root
, &root_dir
);
2548 root_dir
= default_root
;
2551 /* Local fixed drives can be cached permanently. Removable drives
2552 cannot be cached permanently, since the volume name and serial
2553 number (if nothing else) can change. Remote drives should be
2554 treated as if they are removable, since there is no sure way to
2555 tell whether they are or not. Also, the UNC association of drive
2556 letters mapped to remote volumes can be changed at any time (even
2557 by other processes) without notice.
2559 As a compromise, so we can benefit from caching info for remote
2560 volumes, we use a simple expiry mechanism to invalidate cache
2561 entries that are more than ten seconds old. */
2564 /* No point doing this, because WNetGetConnection is even slower than
2565 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2566 GetDriveType is about the only call of this type which does not
2567 involve network access, and so is extremely quick). */
2569 /* Map drive letter to UNC if remote. */
2570 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2572 char remote_name
[ 256 ];
2573 char drive
[3] = { root_dir
[0], ':' };
2575 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2577 /* do something */ ;
2581 info
= lookup_volume_info (root_dir
);
2583 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2591 /* Info is not cached, or is stale. */
2592 if (!GetVolumeInformation (root_dir
,
2593 name
, sizeof (name
),
2597 type
, sizeof (type
)))
2600 /* Cache the volume information for future use, overwriting existing
2601 entry if present. */
2604 info
= xmalloc (sizeof (volume_info_data
));
2605 add_volume_info (root_dir
, info
);
2613 info
->name
= xstrdup (name
);
2614 info
->serialnum
= serialnum
;
2615 info
->maxcomp
= maxcomp
;
2616 info
->flags
= flags
;
2617 info
->type
= xstrdup (type
);
2618 info
->timestamp
= GetTickCount ();
2624 /* Get information on the volume where NAME is held; set path pointer to
2625 start of pathname in NAME (past UNC header\volume header if present),
2626 if pPath is non-NULL.
2628 Note: if NAME includes symlinks, the information is for the volume
2629 of the symlink, not of its target. That's because, even though
2630 GetVolumeInformation returns information about the symlink target
2631 of its argument, we only pass the root directory to
2632 GetVolumeInformation, not the full NAME. */
2634 get_volume_info (const char * name
, const char ** pPath
)
2636 char temp
[MAX_PATH
];
2637 char *rootname
= NULL
; /* default to current volume */
2638 volume_info_data
* info
;
2643 /* Find the root name of the volume if given. */
2644 if (isalpha (name
[0]) && name
[1] == ':')
2652 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2656 int dbcs_p
= max_filename_mbslen () > 1;
2661 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2667 const char *p
= name
;
2669 name
= CharNextExA (file_name_codepage
, name
, 0);
2670 memcpy (str
, p
, name
- p
);
2683 info
= GetCachedVolumeInformation (rootname
);
2686 /* Set global referenced by other functions. */
2687 volume_info
= *info
;
2693 /* Determine if volume is FAT format (ie. only supports short 8.3
2694 names); also set path pointer to start of pathname in name, if
2695 pPath is non-NULL. */
2697 is_fat_volume (const char * name
, const char ** pPath
)
2699 if (get_volume_info (name
, pPath
))
2700 return (volume_info
.maxcomp
== 12);
2704 /* Map filename to a valid 8.3 name if necessary.
2705 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2707 map_w32_filename (const char * name
, const char ** pPath
)
2709 static char shortname
[MAX_PATH
];
2710 char * str
= shortname
;
2713 const char * save_name
= name
;
2715 if (strlen (name
) >= MAX_PATH
)
2717 /* Return a filename which will cause callers to fail. */
2718 strcpy (shortname
, "?");
2722 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2724 register int left
= 8; /* maximum number of chars in part */
2725 register int extn
= 0; /* extension added? */
2726 register int dots
= 2; /* maximum number of dots allowed */
2729 *str
++ = *name
++; /* skip past UNC header */
2731 while ((c
= *name
++))
2738 *str
++ = (c
== ':' ? ':' : '\\');
2739 extn
= 0; /* reset extension flags */
2740 dots
= 2; /* max 2 dots */
2741 left
= 8; /* max length 8 for main part */
2746 /* Convert path components of the form .xxx to _xxx,
2747 but leave . and .. as they are. This allows .emacs
2748 to be read as _emacs, for example. */
2752 IS_DIRECTORY_SEP (*name
))
2767 extn
= 1; /* we've got an extension */
2768 left
= 3; /* 3 chars in extension */
2772 /* any embedded dots after the first are converted to _ */
2777 case '#': /* don't lose these, they're important */
2779 str
[-1] = c
; /* replace last character of part */
2784 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2786 dots
= 0; /* started a path component */
2795 strcpy (shortname
, name
);
2796 unixtodos_filename (shortname
);
2800 *pPath
= shortname
+ (path
- save_name
);
2806 is_exec (const char * name
)
2808 char * p
= strrchr (name
, '.');
2811 && (xstrcasecmp (p
, ".exe") == 0 ||
2812 xstrcasecmp (p
, ".com") == 0 ||
2813 xstrcasecmp (p
, ".bat") == 0 ||
2814 xstrcasecmp (p
, ".cmd") == 0));
2817 /* Emulate the Unix directory procedures opendir, closedir,
2818 and readdir. We can't use the procedures supplied in sysdep.c,
2819 so we provide them here. */
2821 struct dirent dir_static
; /* simulated directory contents */
2822 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2823 static int dir_is_fat
;
2824 static char dir_pathname
[MAXPATHLEN
+1];
2825 static WIN32_FIND_DATA dir_find_data
;
2827 /* Support shares on a network resource as subdirectories of a read-only
2829 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2830 static HANDLE
open_unc_volume (const char *);
2831 static char *read_unc_volume (HANDLE
, char *, int);
2832 static void close_unc_volume (HANDLE
);
2835 opendir (const char *filename
)
2839 /* Opening is done by FindFirstFile. However, a read is inherent to
2840 this operation, so we defer the open until read time. */
2842 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2844 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2847 /* Note: We don't support traversal of UNC volumes via symlinks.
2848 Doing so would mean punishing 99.99% of use cases by resolving
2849 all the possible symlinks in FILENAME, recursively. */
2850 if (is_unc_volume (filename
))
2852 wnet_enum_handle
= open_unc_volume (filename
);
2853 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2857 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2864 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2865 dir_pathname
[MAXPATHLEN
] = '\0';
2866 /* Note: We don't support symlinks to file names on FAT volumes.
2867 Doing so would mean punishing 99.99% of use cases by resolving
2868 all the possible symlinks in FILENAME, recursively. */
2869 dir_is_fat
= is_fat_volume (filename
, NULL
);
2875 closedir (DIR *dirp
)
2877 /* If we have a find-handle open, close it. */
2878 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2880 FindClose (dir_find_handle
);
2881 dir_find_handle
= INVALID_HANDLE_VALUE
;
2883 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2885 close_unc_volume (wnet_enum_handle
);
2886 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2888 xfree ((char *) dirp
);
2894 int downcase
= !NILP (Vw32_downcase_file_names
);
2896 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2898 if (!read_unc_volume (wnet_enum_handle
,
2899 dir_find_data
.cFileName
,
2903 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2904 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2906 char filename
[MAXNAMLEN
+ 3];
2908 int dbcs_p
= max_filename_mbslen () > 1;
2910 strcpy (filename
, dir_pathname
);
2911 ln
= strlen (filename
) - 1;
2914 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2915 strcat (filename
, "\\");
2919 char *end
= filename
+ ln
+ 1;
2920 char *last_char
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
2922 if (!IS_DIRECTORY_SEP (*last_char
))
2923 strcat (filename
, "\\");
2925 strcat (filename
, "*");
2927 /* Note: No need to resolve symlinks in FILENAME, because
2928 FindFirst opens the directory that is the target of a
2930 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2932 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2937 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2941 /* Emacs never uses this value, so don't bother making it match
2942 value returned by stat(). */
2943 dir_static
.d_ino
= 1;
2945 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2947 /* If the file name in cFileName[] includes `?' characters, it means
2948 the original file name used characters that cannot be represented
2949 by the current ANSI codepage. To avoid total lossage, retrieve
2950 the short 8+3 alias of the long file name. */
2951 if (_mbspbrk (dir_static
.d_name
, "?"))
2953 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2954 downcase
= 1; /* 8+3 aliases are returned in all caps */
2956 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2957 dir_static
.d_reclen
= sizeof (struct dirent
) - MAXNAMLEN
+ 3 +
2958 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2960 /* If the file name in cFileName[] includes `?' characters, it means
2961 the original file name used characters that cannot be represented
2962 by the current ANSI codepage. To avoid total lossage, retrieve
2963 the short 8+3 alias of the long file name. */
2964 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2966 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2967 /* 8+3 aliases are returned in all caps, which could break
2968 various alists that look at filenames' extensions. */
2972 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2973 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2975 _mbslwr (dir_static
.d_name
);
2979 int dbcs_p
= max_filename_mbslen () > 1;
2980 for (p
= dir_static
.d_name
; *p
; )
2982 if (*p
>= 'a' && *p
<= 'z')
2985 p
= CharNextExA (file_name_codepage
, p
, 0);
2990 _mbslwr (dir_static
.d_name
);
2997 open_unc_volume (const char *path
)
3003 nr
.dwScope
= RESOURCE_GLOBALNET
;
3004 nr
.dwType
= RESOURCETYPE_DISK
;
3005 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
3006 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
3007 nr
.lpLocalName
= NULL
;
3008 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
3009 nr
.lpComment
= NULL
;
3010 nr
.lpProvider
= NULL
;
3012 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
3013 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
3015 if (result
== NO_ERROR
)
3018 return INVALID_HANDLE_VALUE
;
3022 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
3026 DWORD bufsize
= 512;
3029 int dbcs_p
= max_filename_mbslen () > 1;
3032 buffer
= alloca (bufsize
);
3033 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
3034 if (result
!= NO_ERROR
)
3037 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
3038 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
3041 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
3044 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
))
3045 ptr
= CharNextExA (file_name_codepage
, ptr
, 0);
3049 strncpy (readbuf
, ptr
, size
);
3054 close_unc_volume (HANDLE henum
)
3056 if (henum
!= INVALID_HANDLE_VALUE
)
3057 WNetCloseEnum (henum
);
3061 unc_volume_file_attributes (const char *path
)
3066 henum
= open_unc_volume (path
);
3067 if (henum
== INVALID_HANDLE_VALUE
)
3070 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
3072 close_unc_volume (henum
);
3077 /* Ensure a network connection is authenticated. */
3079 logon_network_drive (const char *path
)
3081 NETRESOURCE resource
;
3082 char share
[MAX_PATH
];
3089 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
3090 drvtype
= DRIVE_REMOTE
;
3091 else if (path
[0] == '\0' || path
[1] != ':')
3092 drvtype
= GetDriveType (NULL
);
3099 drvtype
= GetDriveType (drive
);
3102 /* Only logon to networked drives. */
3103 if (drvtype
!= DRIVE_REMOTE
)
3107 strncpy (share
, path
, MAX_PATH
);
3108 /* Truncate to just server and share name. */
3109 dbcs_p
= max_filename_mbslen () > 1;
3110 for (p
= share
+ 2; *p
&& p
< share
+ MAX_PATH
; )
3112 if (IS_DIRECTORY_SEP (*p
) && ++n_slashes
> 3)
3118 p
= CharNextExA (file_name_codepage
, p
, 0);
3123 resource
.dwType
= RESOURCETYPE_DISK
;
3124 resource
.lpLocalName
= NULL
;
3125 resource
.lpRemoteName
= share
;
3126 resource
.lpProvider
= NULL
;
3128 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
3131 /* Emulate faccessat(2). */
3133 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
3137 if (dirfd
!= AT_FDCWD
3138 && !(IS_DIRECTORY_SEP (path
[0])
3139 || IS_DEVICE_SEP (path
[1])))
3145 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
3146 newer versions blow up when passed D_OK. */
3147 path
= map_w32_filename (path
, NULL
);
3148 /* If the last element of PATH is a symlink, we need to resolve it
3149 to get the attributes of its target file. Note: any symlinks in
3150 PATH elements other than the last one are transparently resolved
3151 by GetFileAttributes below. */
3152 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
3153 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
3154 path
= chase_symlinks (path
);
3156 if ((attributes
= GetFileAttributes (path
)) == -1)
3158 DWORD w32err
= GetLastError ();
3162 case ERROR_INVALID_NAME
:
3163 case ERROR_BAD_PATHNAME
:
3164 if (is_unc_volume (path
))
3166 attributes
= unc_volume_file_attributes (path
);
3167 if (attributes
== -1)
3175 case ERROR_FILE_NOT_FOUND
:
3176 case ERROR_BAD_NETPATH
:
3185 if ((mode
& X_OK
) != 0
3186 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
3191 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
3196 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
3204 /* Shadow some MSVC runtime functions to map requests for long filenames
3205 to reasonable short names if necessary. This was originally added to
3206 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
3210 sys_chdir (const char * path
)
3212 return _chdir (map_w32_filename (path
, NULL
));
3216 sys_chmod (const char * path
, int mode
)
3218 path
= chase_symlinks (map_w32_filename (path
, NULL
));
3219 return _chmod (path
, mode
);
3223 sys_creat (const char * path
, int mode
)
3225 return _creat (map_w32_filename (path
, NULL
), mode
);
3229 sys_fopen (const char * path
, const char * mode
)
3233 const char * mode_save
= mode
;
3235 /* Force all file handles to be non-inheritable. This is necessary to
3236 ensure child processes don't unwittingly inherit handles that might
3237 prevent future file access. */
3241 else if (mode
[0] == 'w' || mode
[0] == 'a')
3242 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
3246 /* Only do simplistic option parsing. */
3250 oflag
&= ~(O_RDONLY
| O_WRONLY
);
3253 else if (mode
[0] == 'b')
3258 else if (mode
[0] == 't')
3265 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
3269 return _fdopen (fd
, mode_save
);
3272 /* This only works on NTFS volumes, but is useful to have. */
3274 sys_link (const char * old
, const char * new)
3278 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
3280 if (old
== NULL
|| new == NULL
)
3286 strcpy (oldname
, map_w32_filename (old
, NULL
));
3287 strcpy (newname
, map_w32_filename (new, NULL
));
3289 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
3290 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3291 if (fileh
!= INVALID_HANDLE_VALUE
)
3295 /* Confusingly, the "alternate" stream name field does not apply
3296 when restoring a hard link, and instead contains the actual
3297 stream data for the link (ie. the name of the link to create).
3298 The WIN32_STREAM_ID structure before the cStreamName field is
3299 the stream header, which is then immediately followed by the
3303 WIN32_STREAM_ID wid
;
3304 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
3307 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
3308 data
.wid
.cStreamName
, MAX_PATH
);
3311 LPVOID context
= NULL
;
3314 data
.wid
.dwStreamId
= BACKUP_LINK
;
3315 data
.wid
.dwStreamAttributes
= 0;
3316 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
3317 data
.wid
.Size
.HighPart
= 0;
3318 data
.wid
.dwStreamNameSize
= 0;
3320 if (BackupWrite (fileh
, (LPBYTE
)&data
,
3321 offsetof (WIN32_STREAM_ID
, cStreamName
)
3322 + data
.wid
.Size
.LowPart
,
3323 &wbytes
, FALSE
, FALSE
, &context
)
3324 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
3331 /* Should try mapping GetLastError to errno; for now just
3332 indicate a general error (eg. links not supported). */
3333 errno
= EINVAL
; // perhaps EMLINK?
3337 CloseHandle (fileh
);
3346 sys_mkdir (const char * path
)
3348 return _mkdir (map_w32_filename (path
, NULL
));
3351 /* Because of long name mapping issues, we need to implement this
3352 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
3353 a unique name, instead of setting the input template to an empty
3356 Standard algorithm seems to be use pid or tid with a letter on the
3357 front (in place of the 6 X's) and cycle through the letters to find a
3358 unique name. We extend that to allow any reasonable character as the
3359 first of the 6 X's. */
3361 sys_mktemp (char * template)
3365 unsigned uid
= GetCurrentThreadId ();
3366 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
3368 if (template == NULL
)
3370 p
= template + strlen (template);
3372 /* replace up to the last 5 X's with uid in decimal */
3373 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
3375 p
[0] = '0' + uid
% 10;
3379 if (i
< 0 && p
[0] == 'X')
3384 int save_errno
= errno
;
3385 p
[0] = first_char
[i
];
3386 if (faccessat (AT_FDCWD
, template, F_OK
, AT_EACCESS
) < 0)
3392 while (++i
< sizeof (first_char
));
3395 /* Template is badly formed or else we can't generate a unique name,
3396 so return empty string */
3402 sys_open (const char * path
, int oflag
, int mode
)
3404 const char* mpath
= map_w32_filename (path
, NULL
);
3407 /* If possible, try to open file without _O_CREAT, to be able to
3408 write to existing hidden and system files. Force all file
3409 handles to be non-inheritable. */
3410 if ((oflag
& (_O_CREAT
| _O_EXCL
)) != (_O_CREAT
| _O_EXCL
))
3411 res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3413 res
= _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3419 fchmod (int fd
, mode_t mode
)
3425 sys_rename_replace (const char *oldname
, const char *newname
, BOOL force
)
3428 char temp
[MAX_PATH
];
3432 /* MoveFile on Windows 95 doesn't correctly change the short file name
3433 alias in a number of circumstances (it is not easy to predict when
3434 just by looking at oldname and newname, unfortunately). In these
3435 cases, renaming through a temporary name avoids the problem.
3437 A second problem on Windows 95 is that renaming through a temp name when
3438 newname is uppercase fails (the final long name ends up in
3439 lowercase, although the short alias might be uppercase) UNLESS the
3440 long temp name is not 8.3.
3442 So, on Windows 95 we always rename through a temp name, and we make sure
3443 the temp name has a long extension to ensure correct renaming. */
3445 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3447 /* volume_info is set indirectly by map_w32_filename. */
3448 oldname_dev
= volume_info
.serialnum
;
3450 if (os_subtype
== OS_9X
)
3456 oldname
= map_w32_filename (oldname
, NULL
);
3457 if ((o
= strrchr (oldname
, '\\')))
3460 o
= (char *) oldname
;
3462 if ((p
= strrchr (temp
, '\\')))
3469 /* Force temp name to require a manufactured 8.3 alias - this
3470 seems to make the second rename work properly. */
3471 sprintf (p
, "_.%s.%u", o
, i
);
3473 result
= rename (oldname
, temp
);
3475 /* This loop must surely terminate! */
3476 while (result
< 0 && errno
== EEXIST
);
3481 /* If FORCE, emulate Unix behavior - newname is deleted if it already exists
3482 (at least if it is a file; don't do this for directories).
3484 Since we mustn't do this if we are just changing the case of the
3485 file name (we would end up deleting the file we are trying to
3486 rename!), we let rename detect if the destination file already
3487 exists - that way we avoid the possible pitfalls of trying to
3488 determine ourselves whether two names really refer to the same
3489 file, which is not always possible in the general case. (Consider
3490 all the permutations of shared or subst'd drives, etc.) */
3492 newname
= map_w32_filename (newname
, NULL
);
3494 /* volume_info is set indirectly by map_w32_filename. */
3495 newname_dev
= volume_info
.serialnum
;
3497 result
= rename (temp
, newname
);
3499 if (result
< 0 && force
)
3501 DWORD w32err
= GetLastError ();
3504 && newname_dev
!= oldname_dev
)
3506 /* The implementation of `rename' on Windows does not return
3507 errno = EXDEV when you are moving a directory to a
3508 different storage device (ex. logical disk). It returns
3509 EACCES instead. So here we handle such situations and
3513 if ((attributes
= GetFileAttributes (temp
)) != -1
3514 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3517 else if (errno
== EEXIST
)
3519 if (_chmod (newname
, 0666) != 0)
3521 if (_unlink (newname
) != 0)
3523 result
= rename (temp
, newname
);
3525 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3526 && is_symlink (temp
))
3528 /* This is Windows prohibiting the user from creating a
3529 symlink in another place, since that requires
3539 sys_rename (char const *old
, char const *new)
3541 return sys_rename_replace (old
, new, TRUE
);
3545 sys_rmdir (const char * path
)
3547 return _rmdir (map_w32_filename (path
, NULL
));
3551 sys_unlink (const char * path
)
3553 path
= map_w32_filename (path
, NULL
);
3555 /* On Unix, unlink works without write permission. */
3556 _chmod (path
, 0666);
3557 return _unlink (path
);
3560 static FILETIME utc_base_ft
;
3561 static ULONGLONG utc_base
; /* In 100ns units */
3562 static int init
= 0;
3564 #define FILETIME_TO_U64(result, ft) \
3566 ULARGE_INTEGER uiTemp; \
3567 uiTemp.LowPart = (ft).dwLowDateTime; \
3568 uiTemp.HighPart = (ft).dwHighDateTime; \
3569 result = uiTemp.QuadPart; \
3573 initialize_utc_base (void)
3575 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3584 st
.wMilliseconds
= 0;
3586 SystemTimeToFileTime (&st
, &utc_base_ft
);
3587 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3591 convert_time (FILETIME ft
)
3597 initialize_utc_base ();
3601 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3604 FILETIME_TO_U64 (tmp
, ft
);
3605 return (time_t) ((tmp
- utc_base
) / 10000000L);
3609 convert_from_time_t (time_t time
, FILETIME
* pft
)
3615 initialize_utc_base ();
3619 /* time in 100ns units since 1-Jan-1601 */
3620 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3621 pft
->dwHighDateTime
= tmp
.HighPart
;
3622 pft
->dwLowDateTime
= tmp
.LowPart
;
3626 /* No reason to keep this; faking inode values either by hashing or even
3627 using the file index from GetInformationByHandle, is not perfect and
3628 so by default Emacs doesn't use the inode values on Windows.
3629 Instead, we now determine file-truename correctly (except for
3630 possible drive aliasing etc). */
3632 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3634 hashval (const unsigned char * str
)
3639 h
= (h
<< 4) + *str
++;
3645 /* Return the hash value of the canonical pathname, excluding the
3646 drive/UNC header, to get a hopefully unique inode number. */
3648 generate_inode_val (const char * name
)
3650 char fullname
[ MAX_PATH
];
3654 /* Get the truly canonical filename, if it exists. (Note: this
3655 doesn't resolve aliasing due to subst commands, or recognize hard
3657 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3660 parse_root (fullname
, &p
);
3661 /* Normal W32 filesystems are still case insensitive. */
3668 static PSECURITY_DESCRIPTOR
3669 get_file_security_desc_by_handle (HANDLE h
)
3671 PSECURITY_DESCRIPTOR psd
= NULL
;
3673 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3674 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3676 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3677 NULL
, NULL
, NULL
, NULL
, &psd
);
3678 if (err
!= ERROR_SUCCESS
)
3684 static PSECURITY_DESCRIPTOR
3685 get_file_security_desc_by_name (const char *fname
)
3687 PSECURITY_DESCRIPTOR psd
= NULL
;
3689 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3690 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3692 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3694 err
= GetLastError ();
3695 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3699 psd
= xmalloc (sd_len
);
3700 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3712 unsigned n_subauthorities
;
3714 /* Use the last sub-authority value of the RID, the relative
3715 portion of the SID, as user/group ID. */
3716 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3717 if (n_subauthorities
< 1)
3718 return 0; /* the "World" RID */
3719 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3722 /* Caching SID and account values for faster lokup. */
3725 # define FLEXIBLE_ARRAY_MEMBER
3727 # define FLEXIBLE_ARRAY_MEMBER 1
3732 struct w32_id
*next
;
3734 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3737 static struct w32_id
*w32_idlist
;
3740 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3742 struct w32_id
*tail
, *found
;
3744 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3746 if (equal_sid ((PSID
)tail
->sid
, sid
))
3755 strcpy (name
, found
->name
);
3763 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3766 struct w32_id
*new_entry
;
3768 /* We don't want to leave behind stale cache from when Emacs was
3772 sid_len
= get_length_sid (sid
);
3773 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3776 new_entry
->rid
= id
;
3777 strcpy (new_entry
->name
, name
);
3778 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3779 new_entry
->next
= w32_idlist
;
3780 w32_idlist
= new_entry
;
3789 get_name_and_id (PSECURITY_DESCRIPTOR psd
, unsigned *id
, char *nm
, int what
)
3793 SID_NAME_USE ignore
;
3795 DWORD name_len
= sizeof (name
);
3797 DWORD domain_len
= sizeof (domain
);
3802 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3803 else if (what
== GID
)
3804 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3808 if (!result
|| !is_valid_sid (sid
))
3810 else if (!w32_cached_id (sid
, id
, nm
))
3812 if (!lookup_account_sid (NULL
, sid
, name
, &name_len
,
3813 domain
, &domain_len
, &ignore
)
3814 || name_len
> UNLEN
+1)
3818 *id
= get_rid (sid
);
3820 w32_add_to_cache (sid
, *id
, name
);
3827 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
, struct stat
*st
)
3829 int dflt_usr
= 0, dflt_grp
= 0;
3838 if (get_name_and_id (psd
, &st
->st_uid
, st
->st_uname
, UID
))
3840 if (get_name_and_id (psd
, &st
->st_gid
, st
->st_gname
, GID
))
3843 /* Consider files to belong to current user/group, if we cannot get
3844 more accurate information. */
3847 st
->st_uid
= dflt_passwd
.pw_uid
;
3848 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3852 st
->st_gid
= dflt_passwd
.pw_gid
;
3853 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3857 /* Return non-zero if NAME is a potentially slow filesystem. */
3859 is_slow_fs (const char *name
)
3864 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3865 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3866 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3867 devtype
= GetDriveType (NULL
); /* use root of current drive */
3870 /* GetDriveType needs the root directory of the drive. */
3871 strncpy (drive_root
, name
, 2);
3872 drive_root
[2] = '\\';
3873 drive_root
[3] = '\0';
3874 devtype
= GetDriveType (drive_root
);
3876 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3879 /* If this is non-zero, the caller wants accurate information about
3880 file's owner and group, which could be expensive to get. */
3881 int w32_stat_get_owner_group
;
3883 /* MSVC stat function can't cope with UNC names and has other bugs, so
3884 replace it with our own. This also allows us to calculate consistent
3885 inode values and owner/group without hacks in the main Emacs code. */
3888 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3890 char *name
, *save_name
, *r
;
3891 WIN32_FIND_DATA wfd
;
3893 unsigned __int64 fake_inode
= 0;
3896 int rootdir
= FALSE
;
3897 PSECURITY_DESCRIPTOR psd
= NULL
;
3898 int is_a_symlink
= 0;
3899 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3900 DWORD access_rights
= 0;
3901 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3902 FILETIME ctime
, atime
, wtime
;
3905 if (path
== NULL
|| buf
== NULL
)
3911 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3912 /* Must be valid filename, no wild cards or other invalid
3913 characters. We use _mbspbrk to support multibyte strings that
3914 might look to strpbrk as if they included literal *, ?, and other
3915 characters mentioned below that are disallowed by Windows
3917 if (_mbspbrk (name
, "*?|<>\""))
3923 /* Remove trailing directory separator, unless name is the root
3924 directory of a drive or UNC volume in which case ensure there
3925 is a trailing separator. */
3926 len
= strlen (name
);
3927 name
= strcpy (alloca (len
+ 2), name
);
3929 /* Avoid a somewhat costly call to is_symlink if the filesystem
3930 doesn't support symlinks. */
3931 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3932 is_a_symlink
= is_symlink (name
);
3934 /* Plan A: Open the file and get all the necessary information via
3935 the resulting handle. This solves several issues in one blow:
3937 . retrieves attributes for the target of a symlink, if needed
3938 . gets attributes of root directories and symlinks pointing to
3939 root directories, thus avoiding the need for special-casing
3940 these and detecting them by examining the file-name format
3941 . retrieves more accurate attributes (e.g., non-zero size for
3942 some directories, esp. directories that are junction points)
3943 . correctly resolves "c:/..", "/.." and similar file names
3944 . avoids run-time penalties for 99% of use cases
3946 Plan A is always tried first, unless the user asked not to (but
3947 if the file is a symlink and we need to follow links, we try Plan
3948 A even if the user asked not to).
3950 If Plan A fails, we go to Plan B (below), where various
3951 potentially expensive techniques must be used to handle "special"
3952 files such as UNC volumes etc. */
3953 if (!(NILP (Vw32_get_true_file_attributes
)
3954 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3955 /* Following symlinks requires getting the info by handle. */
3956 || (is_a_symlink
&& follow_symlinks
))
3958 BY_HANDLE_FILE_INFORMATION info
;
3960 if (is_a_symlink
&& !follow_symlinks
)
3961 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3962 /* READ_CONTROL access rights are required to get security info
3963 by handle. But if the OS doesn't support security in the
3964 first place, we don't need to try. */
3965 if (is_windows_9x () != TRUE
)
3966 access_rights
|= READ_CONTROL
;
3968 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3970 /* If CreateFile fails with READ_CONTROL, try again with zero as
3972 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3973 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3975 if (fh
== INVALID_HANDLE_VALUE
)
3976 goto no_true_file_attributes
;
3978 /* This is more accurate in terms of getting the correct number
3979 of links, but is quite slow (it is noticeable when Emacs is
3980 making a list of file name completions). */
3981 if (GetFileInformationByHandle (fh
, &info
))
3983 nlinks
= info
.nNumberOfLinks
;
3984 /* Might as well use file index to fake inode values, but this
3985 is not guaranteed to be unique unless we keep a handle open
3986 all the time (even then there are situations where it is
3987 not unique). Reputedly, there are at most 48 bits of info
3988 (on NTFS, presumably less on FAT). */
3989 fake_inode
= info
.nFileIndexHigh
;
3991 fake_inode
+= info
.nFileIndexLow
;
3992 serialnum
= info
.dwVolumeSerialNumber
;
3993 fs_high
= info
.nFileSizeHigh
;
3994 fs_low
= info
.nFileSizeLow
;
3995 ctime
= info
.ftCreationTime
;
3996 atime
= info
.ftLastAccessTime
;
3997 wtime
= info
.ftLastWriteTime
;
3998 fattrs
= info
.dwFileAttributes
;
4002 /* We don't go to Plan B here, because it's not clear that
4003 it's a good idea. The only known use case where
4004 CreateFile succeeds, but GetFileInformationByHandle fails
4005 (with ERROR_INVALID_FUNCTION) is for character devices
4006 such as NUL, PRN, etc. For these, switching to Plan B is
4007 a net loss, because we lose the character device
4008 attribute returned by GetFileType below (FindFirstFile
4009 doesn't set that bit in the attributes), and the other
4010 fields don't make sense for character devices anyway.
4011 Emacs doesn't really care for non-file entities in the
4012 context of l?stat, so neither do we. */
4014 /* w32err is assigned so one could put a breakpoint here and
4015 examine its value, when GetFileInformationByHandle
4017 DWORD w32err
= GetLastError ();
4021 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
4027 /* Test for a symlink before testing for a directory, since
4028 symlinks to directories have the directory bit set, but we
4029 don't want them to appear as directories. */
4030 if (is_a_symlink
&& !follow_symlinks
)
4031 buf
->st_mode
= S_IFLNK
;
4032 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4033 buf
->st_mode
= S_IFDIR
;
4036 DWORD ftype
= GetFileType (fh
);
4040 case FILE_TYPE_DISK
:
4041 buf
->st_mode
= S_IFREG
;
4043 case FILE_TYPE_PIPE
:
4044 buf
->st_mode
= S_IFIFO
;
4046 case FILE_TYPE_CHAR
:
4047 case FILE_TYPE_UNKNOWN
:
4049 buf
->st_mode
= S_IFCHR
;
4052 /* We produce the fallback owner and group data, based on the
4053 current user that runs Emacs, in the following cases:
4055 . caller didn't request owner and group info
4056 . this is Windows 9X
4057 . getting security by handle failed, and we need to produce
4058 information for the target of a symlink (this is better
4059 than producing a potentially misleading info about the
4062 If getting security by handle fails, and we don't need to
4063 resolve symlinks, we try getting security by name. */
4064 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4065 get_file_owner_and_group (NULL
, buf
);
4068 psd
= get_file_security_desc_by_handle (fh
);
4071 get_file_owner_and_group (psd
, buf
);
4074 else if (!(is_a_symlink
&& follow_symlinks
))
4076 psd
= get_file_security_desc_by_name (name
);
4077 get_file_owner_and_group (psd
, buf
);
4081 get_file_owner_and_group (NULL
, buf
);
4087 no_true_file_attributes
:
4088 /* Plan B: Either getting a handle on the file failed, or the
4089 caller explicitly asked us to not bother making this
4090 information more accurate.
4092 Implementation note: In Plan B, we never bother to resolve
4093 symlinks, even if we got here because we tried Plan A and
4094 failed. That's because, even if the caller asked for extra
4095 precision by setting Vw32_get_true_file_attributes to t,
4096 resolving symlinks requires acquiring a file handle to the
4097 symlink, which we already know will fail. And if the user
4098 did not ask for extra precision, resolving symlinks will fly
4099 in the face of that request, since the user then wants the
4100 lightweight version of the code. */
4101 dbcs_p
= max_filename_mbslen () > 1;
4102 rootdir
= (path
>= save_name
+ len
- 1
4103 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
4105 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
4106 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
4107 if (IS_DIRECTORY_SEP (r
[0])
4108 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
4111 /* Note: If NAME is a symlink to the root of a UNC volume
4112 (i.e. "\\SERVER"), we will not detect that here, and we will
4113 return data about the symlink as result of FindFirst below.
4114 This is unfortunate, but that marginal use case does not
4115 justify a call to chase_symlinks which would impose a penalty
4116 on all the other use cases. (We get here for symlinks to
4117 roots of UNC volumes because CreateFile above fails for them,
4118 unlike with symlinks to root directories X:\ of drives.) */
4119 if (is_unc_volume (name
))
4121 fattrs
= unc_volume_file_attributes (name
);
4125 ctime
= atime
= wtime
= utc_base_ft
;
4131 if (!IS_DIRECTORY_SEP (name
[len
-1]))
4132 strcat (name
, "\\");
4136 char *end
= name
+ len
;
4137 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4139 if (!IS_DIRECTORY_SEP (*n
))
4140 strcat (name
, "\\");
4142 if (GetDriveType (name
) < 2)
4148 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
4149 ctime
= atime
= wtime
= utc_base_ft
;
4155 if (IS_DIRECTORY_SEP (name
[len
-1]))
4160 char *end
= name
+ len
;
4161 char *n
= CharPrevExA (file_name_codepage
, name
, end
, 0);
4163 if (IS_DIRECTORY_SEP (*n
))
4167 /* (This is hacky, but helps when doing file completions on
4168 network drives.) Optimize by using information available from
4169 active readdir if possible. */
4170 len
= strlen (dir_pathname
);
4173 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
4178 char *end
= dir_pathname
+ len
;
4179 char *n
= CharPrevExA (file_name_codepage
, dir_pathname
, end
, 0);
4181 if (IS_DIRECTORY_SEP (*n
))
4184 if (dir_find_handle
!= INVALID_HANDLE_VALUE
4185 && !(is_a_symlink
&& follow_symlinks
)
4186 && strnicmp (save_name
, dir_pathname
, len
) == 0
4187 && IS_DIRECTORY_SEP (name
[len
])
4188 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
4190 /* This was the last entry returned by readdir. */
4191 wfd
= dir_find_data
;
4195 logon_network_drive (name
);
4197 fh
= FindFirstFile (name
, &wfd
);
4198 if (fh
== INVALID_HANDLE_VALUE
)
4205 /* Note: if NAME is a symlink, the information we get from
4206 FindFirstFile is for the symlink, not its target. */
4207 fattrs
= wfd
.dwFileAttributes
;
4208 ctime
= wfd
.ftCreationTime
;
4209 atime
= wfd
.ftLastAccessTime
;
4210 wtime
= wfd
.ftLastWriteTime
;
4211 fs_high
= wfd
.nFileSizeHigh
;
4212 fs_low
= wfd
.nFileSizeLow
;
4215 serialnum
= volume_info
.serialnum
;
4217 if (is_a_symlink
&& !follow_symlinks
)
4218 buf
->st_mode
= S_IFLNK
;
4219 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4220 buf
->st_mode
= S_IFDIR
;
4222 buf
->st_mode
= S_IFREG
;
4224 get_file_owner_and_group (NULL
, buf
);
4228 /* Not sure if there is any point in this. */
4229 if (!NILP (Vw32_generate_fake_inodes
))
4230 fake_inode
= generate_inode_val (name
);
4231 else if (fake_inode
== 0)
4233 /* For want of something better, try to make everything unique. */
4234 static DWORD gen_num
= 0;
4235 fake_inode
= ++gen_num
;
4239 buf
->st_ino
= fake_inode
;
4241 buf
->st_dev
= serialnum
;
4242 buf
->st_rdev
= serialnum
;
4244 buf
->st_size
= fs_high
;
4245 buf
->st_size
<<= 32;
4246 buf
->st_size
+= fs_low
;
4247 buf
->st_nlink
= nlinks
;
4249 /* Convert timestamps to Unix format. */
4250 buf
->st_mtime
= convert_time (wtime
);
4251 buf
->st_atime
= convert_time (atime
);
4252 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4253 buf
->st_ctime
= convert_time (ctime
);
4254 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4256 /* determine rwx permissions */
4257 if (is_a_symlink
&& !follow_symlinks
)
4258 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
4261 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
4262 permission
= S_IREAD
;
4264 permission
= S_IREAD
| S_IWRITE
;
4266 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
4267 permission
|= S_IEXEC
;
4268 else if (is_exec (name
))
4269 permission
|= S_IEXEC
;
4272 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4278 stat (const char * path
, struct stat
* buf
)
4280 return stat_worker (path
, buf
, 1);
4284 lstat (const char * path
, struct stat
* buf
)
4286 return stat_worker (path
, buf
, 0);
4290 fstatat (int fd
, char const *name
, struct stat
*st
, int flags
)
4292 /* Rely on a hack: an open directory is modeled as file descriptor 0.
4293 This is good enough for the current usage in Emacs, but is fragile.
4295 FIXME: Add proper support for fdopendir, fstatat, readlinkat.
4296 Gnulib does this and can serve as a model. */
4297 char fullname
[MAX_PATH
];
4301 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
4304 errno
= ENAMETOOLONG
;
4310 return stat_worker (name
, st
, ! (flags
& AT_SYMLINK_NOFOLLOW
));
4313 /* Provide fstat and utime as well as stat for consistent handling of
4316 fstat (int desc
, struct stat
* buf
)
4318 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
4319 BY_HANDLE_FILE_INFORMATION info
;
4320 unsigned __int64 fake_inode
;
4323 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
4325 case FILE_TYPE_DISK
:
4326 buf
->st_mode
= S_IFREG
;
4327 if (!GetFileInformationByHandle (fh
, &info
))
4333 case FILE_TYPE_PIPE
:
4334 buf
->st_mode
= S_IFIFO
;
4336 case FILE_TYPE_CHAR
:
4337 case FILE_TYPE_UNKNOWN
:
4339 buf
->st_mode
= S_IFCHR
;
4341 memset (&info
, 0, sizeof (info
));
4342 info
.dwFileAttributes
= 0;
4343 info
.ftCreationTime
= utc_base_ft
;
4344 info
.ftLastAccessTime
= utc_base_ft
;
4345 info
.ftLastWriteTime
= utc_base_ft
;
4348 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4349 buf
->st_mode
= S_IFDIR
;
4351 buf
->st_nlink
= info
.nNumberOfLinks
;
4352 /* Might as well use file index to fake inode values, but this
4353 is not guaranteed to be unique unless we keep a handle open
4354 all the time (even then there are situations where it is
4355 not unique). Reputedly, there are at most 48 bits of info
4356 (on NTFS, presumably less on FAT). */
4357 fake_inode
= info
.nFileIndexHigh
;
4359 fake_inode
+= info
.nFileIndexLow
;
4361 /* MSVC defines _ino_t to be short; other libc's might not. */
4362 if (sizeof (buf
->st_ino
) == 2)
4363 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
4365 buf
->st_ino
= fake_inode
;
4367 /* If the caller so requested, get the true file owner and group.
4368 Otherwise, consider the file to belong to the current user. */
4369 if (!w32_stat_get_owner_group
|| is_windows_9x () == TRUE
)
4370 get_file_owner_and_group (NULL
, buf
);
4373 PSECURITY_DESCRIPTOR psd
= NULL
;
4375 psd
= get_file_security_desc_by_handle (fh
);
4378 get_file_owner_and_group (psd
, buf
);
4382 get_file_owner_and_group (NULL
, buf
);
4385 buf
->st_dev
= info
.dwVolumeSerialNumber
;
4386 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
4388 buf
->st_size
= info
.nFileSizeHigh
;
4389 buf
->st_size
<<= 32;
4390 buf
->st_size
+= info
.nFileSizeLow
;
4392 /* Convert timestamps to Unix format. */
4393 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
4394 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
4395 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
4396 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
4397 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
4399 /* determine rwx permissions */
4400 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
4401 permission
= S_IREAD
;
4403 permission
= S_IREAD
| S_IWRITE
;
4405 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
4406 permission
|= S_IEXEC
;
4409 #if 0 /* no way of knowing the filename */
4410 char * p
= strrchr (name
, '.');
4412 (xstrcasecmp (p
, ".exe") == 0 ||
4413 xstrcasecmp (p
, ".com") == 0 ||
4414 xstrcasecmp (p
, ".bat") == 0 ||
4415 xstrcasecmp (p
, ".cmd") == 0))
4416 permission
|= S_IEXEC
;
4420 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
4426 utime (const char *name
, struct utimbuf
*times
)
4428 struct utimbuf deftime
;
4435 deftime
.modtime
= deftime
.actime
= time (NULL
);
4439 /* Need write access to set times. */
4440 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
4441 /* If NAME specifies a directory, FILE_SHARE_DELETE
4442 allows other processes to delete files inside it,
4443 while we have the directory open. */
4444 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
4445 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
4446 if (fh
!= INVALID_HANDLE_VALUE
)
4448 convert_from_time_t (times
->actime
, &atime
);
4449 convert_from_time_t (times
->modtime
, &mtime
);
4450 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4467 /* Symlink-related functions. */
4468 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4469 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4473 symlink (char const *filename
, char const *linkname
)
4475 char linkfn
[MAX_PATH
], *tgtfn
;
4477 int dir_access
, filename_ends_in_slash
;
4480 /* Diagnostics follows Posix as much as possible. */
4481 if (filename
== NULL
|| linkname
== NULL
)
4491 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4493 errno
= ENAMETOOLONG
;
4497 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4498 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4504 dbcs_p
= max_filename_mbslen () > 1;
4506 /* Note: since empty FILENAME was already rejected, we can safely
4507 refer to FILENAME[1]. */
4508 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4510 /* Non-absolute FILENAME is understood as being relative to
4511 LINKNAME's directory. We need to prepend that directory to
4512 FILENAME to get correct results from faccessat below, since
4513 otherwise it will interpret FILENAME relative to the
4514 directory where the Emacs process runs. Note that
4515 make-symbolic-link always makes sure LINKNAME is a fully
4516 expanded file name. */
4518 char *p
= linkfn
+ strlen (linkfn
);
4522 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4527 char *p1
= CharPrevExA (file_name_codepage
, linkfn
, p
, 0);
4529 while (p
> linkfn
&& !IS_ANY_SEP (*p1
))
4532 p1
= CharPrevExA (file_name_codepage
, linkfn
, p1
, 0);
4536 strncpy (tem
, linkfn
, p
- linkfn
);
4537 tem
[p
- linkfn
] = '\0';
4538 strcat (tem
, filename
);
4539 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4542 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4544 /* Since Windows distinguishes between symlinks to directories and
4545 to files, we provide a kludgy feature: if FILENAME doesn't
4546 exist, but ends in a slash, we create a symlink to directory. If
4547 FILENAME exists and is a directory, we always create a symlink to
4550 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4553 const char *end
= filename
+ strlen (filename
);
4554 const char *n
= CharPrevExA (file_name_codepage
, filename
, end
, 0);
4556 filename_ends_in_slash
= IS_DIRECTORY_SEP (*n
);
4558 if (dir_access
== 0 || filename_ends_in_slash
)
4559 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4561 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4562 if (filename_ends_in_slash
)
4563 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4566 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4568 /* ENOSYS is set by create_symbolic_link, when it detects that
4569 the OS doesn't support the CreateSymbolicLink API. */
4570 if (errno
!= ENOSYS
)
4572 DWORD w32err
= GetLastError ();
4576 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4577 TGTFN point to the same file name, go figure. */
4579 case ERROR_FILE_EXISTS
:
4582 case ERROR_ACCESS_DENIED
:
4585 case ERROR_FILE_NOT_FOUND
:
4586 case ERROR_PATH_NOT_FOUND
:
4587 case ERROR_BAD_NETPATH
:
4588 case ERROR_INVALID_REPARSE_DATA
:
4591 case ERROR_DIRECTORY
:
4594 case ERROR_PRIVILEGE_NOT_HELD
:
4595 case ERROR_NOT_ALL_ASSIGNED
:
4598 case ERROR_DISK_FULL
:
4611 /* A quick inexpensive test of whether FILENAME identifies a file that
4612 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4613 must already be in the normalized form returned by
4616 Note: for repeated operations on many files, it is best to test
4617 whether the underlying volume actually supports symlinks, by
4618 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4619 avoid the call to this function if it doesn't. That's because the
4620 call to GetFileAttributes takes a non-negligible time, especially
4621 on non-local or removable filesystems. See stat_worker for an
4622 example of how to do that. */
4624 is_symlink (const char *filename
)
4627 WIN32_FIND_DATA wfd
;
4630 attrs
= GetFileAttributes (filename
);
4633 DWORD w32err
= GetLastError ();
4637 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4639 case ERROR_ACCESS_DENIED
:
4642 case ERROR_FILE_NOT_FOUND
:
4643 case ERROR_PATH_NOT_FOUND
:
4650 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4652 logon_network_drive (filename
);
4653 fh
= FindFirstFile (filename
, &wfd
);
4654 if (fh
== INVALID_HANDLE_VALUE
)
4657 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4658 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4661 /* If NAME identifies a symbolic link, copy into BUF the file name of
4662 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4663 null-terminate the target name, even if it fits. Return the number
4664 of bytes copied, or -1 if NAME is not a symlink or any error was
4665 encountered while resolving it. The file name copied into BUF is
4666 encoded in the current ANSI codepage. */
4668 readlink (const char *name
, char *buf
, size_t buf_size
)
4671 TOKEN_PRIVILEGES privs
;
4672 int restore_privs
= 0;
4687 path
= map_w32_filename (name
, NULL
);
4689 if (strlen (path
) > MAX_PATH
)
4691 errno
= ENAMETOOLONG
;
4696 if (is_windows_9x () == TRUE
4697 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4698 || !is_symlink (path
))
4701 errno
= EINVAL
; /* not a symlink */
4705 /* Done with simple tests, now we're in for some _real_ work. */
4706 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4708 /* Implementation note: From here and onward, don't return early,
4709 since that will fail to restore the original set of privileges of
4710 the calling thread. */
4712 retval
= -1; /* not too optimistic, are we? */
4714 /* Note: In the next call to CreateFile, we use zero as the 2nd
4715 argument because, when the symlink is a hidden/system file,
4716 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4717 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4718 and directory symlinks. */
4719 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4720 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4722 if (sh
!= INVALID_HANDLE_VALUE
)
4724 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4725 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4728 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4729 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4732 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4736 /* Copy the link target name, in wide characters, from
4737 reparse_data, then convert it to multibyte encoding in
4738 the current locale's codepage. */
4740 BYTE lname
[MAX_PATH
];
4743 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4745 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4746 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4747 /* This updates file_name_codepage which we need below. */
4748 int dbcs_p
= max_filename_mbslen () > 1;
4750 /* According to MSDN, PrintNameLength does not include the
4751 terminating null character. */
4752 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4753 memcpy (lwname
, lwname_src
, lwname_len
);
4754 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4756 lname_len
= WideCharToMultiByte (file_name_codepage
, 0, lwname
, -1,
4757 lname
, MAX_PATH
, NULL
, NULL
);
4760 /* WideCharToMultiByte failed. */
4761 DWORD w32err1
= GetLastError ();
4765 case ERROR_INSUFFICIENT_BUFFER
:
4766 errno
= ENAMETOOLONG
;
4768 case ERROR_INVALID_PARAMETER
:
4771 case ERROR_NO_UNICODE_TRANSLATION
:
4781 size_t size_to_copy
= buf_size
;
4782 BYTE
*p
= lname
, *p2
;
4783 BYTE
*pend
= p
+ lname_len
;
4785 /* Normalize like dostounix_filename does, but we don't
4786 want to assume that lname is null-terminated. */
4788 p2
= CharNextExA (file_name_codepage
, p
, 0);
4791 if (*p
&& *p2
== ':' && *p
>= 'A' && *p
<= 'Z')
4802 p
= CharNextExA (file_name_codepage
, p
, 0);
4803 /* CharNextExA doesn't advance at null character. */
4810 /* Testing for null-terminated LNAME is paranoia:
4811 WideCharToMultiByte should always return a
4812 null-terminated string when its 4th argument is -1
4813 and its 3rd argument is null-terminated (which they
4815 if (lname
[lname_len
- 1] == '\0')
4817 if (lname_len
<= buf_size
)
4818 size_to_copy
= lname_len
;
4819 strncpy (buf
, lname
, size_to_copy
);
4821 retval
= size_to_copy
;
4828 /* CreateFile failed. */
4829 DWORD w32err2
= GetLastError ();
4833 case ERROR_FILE_NOT_FOUND
:
4834 case ERROR_PATH_NOT_FOUND
:
4837 case ERROR_ACCESS_DENIED
:
4838 case ERROR_TOO_MANY_OPEN_FILES
:
4848 restore_privilege (&privs
);
4856 readlinkat (int fd
, char const *name
, char *buffer
,
4859 /* Rely on a hack: an open directory is modeled as file descriptor 0,
4860 as in fstatat. FIXME: Add proper support for readlinkat. */
4861 char fullname
[MAX_PATH
];
4865 if (_snprintf (fullname
, sizeof fullname
, "%s/%s", dir_pathname
, name
)
4868 errno
= ENAMETOOLONG
;
4874 return readlink (name
, buffer
, buffer_size
);
4877 /* If FILE is a symlink, return its target (stored in a static
4878 buffer); otherwise return FILE.
4880 This function repeatedly resolves symlinks in the last component of
4881 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4882 until it arrives at a file whose last component is not a symlink,
4883 or some error occurs. It returns the target of the last
4884 successfully resolved symlink in the chain. If it succeeds to
4885 resolve even a single symlink, the value returned is an absolute
4886 file name with backslashes (result of GetFullPathName). By
4887 contrast, if the original FILE is returned, it is unaltered.
4889 Note: This function can set errno even if it succeeds.
4891 Implementation note: we only resolve the last portion ("basename")
4892 of the argument FILE and of each following file in the chain,
4893 disregarding any possible symlinks in its leading directories.
4894 This is because Windows system calls and library functions
4895 transparently resolve symlinks in leading directories and return
4896 correct information, as long as the basename is not a symlink. */
4898 chase_symlinks (const char *file
)
4900 static char target
[MAX_PATH
];
4901 char link
[MAX_PATH
];
4902 ssize_t res
, link_len
;
4906 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4907 return (char *)file
;
4909 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4910 return (char *)file
;
4912 dbcs_p
= max_filename_mbslen () > 1;
4916 /* Remove trailing slashes, as we want to resolve the last
4917 non-trivial part of the link name. */
4920 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4921 link
[link_len
--] = '\0';
4923 else if (link_len
> 3)
4925 char *n
= CharPrevExA (file_name_codepage
, link
, link
+ link_len
, 0);
4927 while (n
>= link
+ 2 && IS_DIRECTORY_SEP (*n
))
4930 n
= CharPrevExA (file_name_codepage
, link
, n
, 0);
4934 res
= readlink (link
, target
, MAX_PATH
);
4938 if (!(IS_DEVICE_SEP (target
[1])
4939 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4941 /* Target is relative. Append it to the directory part of
4942 the symlink, then copy the result back to target. */
4943 char *p
= link
+ link_len
;
4947 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4952 char *p1
= CharPrevExA (file_name_codepage
, link
, p
, 0);
4954 while (p
> link
&& !IS_ANY_SEP (*p1
))
4957 p1
= CharPrevExA (file_name_codepage
, link
, p1
, 0);
4961 strcpy (target
, link
);
4963 /* Resolve any "." and ".." to get a fully-qualified file name
4965 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4967 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4969 if (loop_count
> 100)
4972 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4973 return (char *)file
;
4978 /* Posix ACL emulation. */
4981 acl_valid (acl_t acl
)
4983 return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR
)acl
) ? 0 : -1;
4987 acl_to_text (acl_t acl
, ssize_t
*size
)
4990 SECURITY_INFORMATION flags
=
4991 OWNER_SECURITY_INFORMATION
|
4992 GROUP_SECURITY_INFORMATION
|
4993 DACL_SECURITY_INFORMATION
;
4994 char *retval
= NULL
;
5000 if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR
)acl
, SDDL_REVISION_1
, flags
, &str_acl
, &local_size
))
5003 /* We don't want to mix heaps, so we duplicate the string in our
5004 heap and free the one allocated by the API. */
5005 retval
= xstrdup (str_acl
);
5008 LocalFree (str_acl
);
5010 else if (errno
!= ENOTSUP
)
5017 acl_from_text (const char *acl_str
)
5019 PSECURITY_DESCRIPTOR psd
, retval
= NULL
;
5025 if (convert_sddl_to_sd (acl_str
, SDDL_REVISION_1
, &psd
, &sd_size
))
5028 retval
= xmalloc (sd_size
);
5029 memcpy (retval
, psd
, sd_size
);
5032 else if (errno
!= ENOTSUP
)
5039 acl_free (void *ptr
)
5046 acl_get_file (const char *fname
, acl_type_t type
)
5048 PSECURITY_DESCRIPTOR psd
= NULL
;
5049 const char *filename
;
5051 if (type
== ACL_TYPE_ACCESS
)
5054 SECURITY_INFORMATION si
=
5055 OWNER_SECURITY_INFORMATION
|
5056 GROUP_SECURITY_INFORMATION
|
5057 DACL_SECURITY_INFORMATION
;
5060 filename
= map_w32_filename (fname
, NULL
);
5061 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5062 fname
= chase_symlinks (filename
);
5067 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
)
5068 && errno
!= ENOTSUP
)
5070 err
= GetLastError ();
5071 if (err
== ERROR_INSUFFICIENT_BUFFER
)
5073 psd
= xmalloc (sd_len
);
5074 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
5081 else if (err
== ERROR_FILE_NOT_FOUND
5082 || err
== ERROR_PATH_NOT_FOUND
)
5090 else if (type
!= ACL_TYPE_DEFAULT
)
5097 acl_set_file (const char *fname
, acl_type_t type
, acl_t acl
)
5099 TOKEN_PRIVILEGES old1
, old2
;
5101 int st
= 0, retval
= -1;
5102 SECURITY_INFORMATION flags
= 0;
5108 const char *filename
;
5110 if (acl_valid (acl
) != 0
5111 || (type
!= ACL_TYPE_DEFAULT
&& type
!= ACL_TYPE_ACCESS
))
5117 if (type
== ACL_TYPE_DEFAULT
)
5123 filename
= map_w32_filename (fname
, NULL
);
5124 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
5125 fname
= chase_symlinks (filename
);
5129 if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5131 flags
|= OWNER_SECURITY_INFORMATION
;
5132 if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR
)acl
, &psid
, &dflt
)
5134 flags
|= GROUP_SECURITY_INFORMATION
;
5135 if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR
)acl
, &dacl_present
,
5138 flags
|= DACL_SECURITY_INFORMATION
;
5142 /* According to KB-245153, setting the owner will succeed if either:
5143 (1) the caller is the user who will be the new owner, and has the
5144 SE_TAKE_OWNERSHIP privilege, or
5145 (2) the caller has the SE_RESTORE privilege, in which case she can
5146 set any valid user or group as the owner
5148 We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
5149 privileges, and disregard any failures in obtaining them. If
5150 these privileges cannot be obtained, and do not already exist in
5151 the calling thread's security token, this function could fail
5153 if (enable_privilege (SE_TAKE_OWNERSHIP_NAME
, TRUE
, &old1
))
5155 if (enable_privilege (SE_RESTORE_NAME
, TRUE
, &old2
))
5160 if (!set_file_security ((char *)fname
, flags
, (PSECURITY_DESCRIPTOR
)acl
))
5162 err
= GetLastError ();
5164 if (errno
== ENOTSUP
)
5166 else if (err
== ERROR_INVALID_OWNER
5167 || err
== ERROR_NOT_ALL_ASSIGNED
5168 || err
== ERROR_ACCESS_DENIED
)
5170 /* Maybe the requested ACL and the one the file already has
5171 are identical, in which case we can silently ignore the
5172 failure. (And no, Windows doesn't.) */
5173 acl_t current_acl
= acl_get_file (fname
, ACL_TYPE_ACCESS
);
5178 char *acl_from
= acl_to_text (current_acl
, NULL
);
5179 char *acl_to
= acl_to_text (acl
, NULL
);
5181 if (acl_from
&& acl_to
&& xstrcasecmp (acl_from
, acl_to
) == 0)
5187 acl_free (acl_from
);
5190 acl_free (current_acl
);
5193 else if (err
== ERROR_FILE_NOT_FOUND
|| err
== ERROR_PATH_NOT_FOUND
)
5207 restore_privilege (&old2
);
5208 restore_privilege (&old1
);
5216 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
5217 have a fixed max size for file names, so we don't need the kind of
5218 alloc/malloc/realloc dance the gnulib version does. We also don't
5219 support FD-relative symlinks. */
5221 careadlinkat (int fd
, char const *filename
,
5222 char *buffer
, size_t buffer_size
,
5223 struct allocator
const *alloc
,
5224 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
5226 char linkname
[MAX_PATH
];
5229 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
5233 char *retval
= buffer
;
5235 linkname
[link_size
++] = '\0';
5236 if (link_size
> buffer_size
)
5237 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
5239 memcpy (retval
, linkname
, link_size
);
5247 /* Support for browsing other processes and their attributes. See
5248 process.c for the Lisp bindings. */
5250 /* Helper wrapper functions. */
5252 static HANDLE WINAPI
5253 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
5255 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
5257 if (g_b_init_create_toolhelp32_snapshot
== 0)
5259 g_b_init_create_toolhelp32_snapshot
= 1;
5260 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
5261 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5262 "CreateToolhelp32Snapshot");
5264 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
5266 return INVALID_HANDLE_VALUE
;
5268 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
5272 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5274 static Process32First_Proc s_pfn_Process32_First
= NULL
;
5276 if (g_b_init_process32_first
== 0)
5278 g_b_init_process32_first
= 1;
5279 s_pfn_Process32_First
= (Process32First_Proc
)
5280 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5283 if (s_pfn_Process32_First
== NULL
)
5287 return (s_pfn_Process32_First (hSnapshot
, lppe
));
5291 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
5293 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
5295 if (g_b_init_process32_next
== 0)
5297 g_b_init_process32_next
= 1;
5298 s_pfn_Process32_Next
= (Process32Next_Proc
)
5299 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5302 if (s_pfn_Process32_Next
== NULL
)
5306 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
5310 open_thread_token (HANDLE ThreadHandle
,
5311 DWORD DesiredAccess
,
5313 PHANDLE TokenHandle
)
5315 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
5316 HMODULE hm_advapi32
= NULL
;
5317 if (is_windows_9x () == TRUE
)
5319 SetLastError (ERROR_NOT_SUPPORTED
);
5322 if (g_b_init_open_thread_token
== 0)
5324 g_b_init_open_thread_token
= 1;
5325 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5326 s_pfn_Open_Thread_Token
=
5327 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
5329 if (s_pfn_Open_Thread_Token
== NULL
)
5331 SetLastError (ERROR_NOT_SUPPORTED
);
5335 s_pfn_Open_Thread_Token (
5344 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
5346 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
5347 HMODULE hm_advapi32
= NULL
;
5348 if (is_windows_9x () == TRUE
)
5352 if (g_b_init_impersonate_self
== 0)
5354 g_b_init_impersonate_self
= 1;
5355 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5356 s_pfn_Impersonate_Self
=
5357 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
5359 if (s_pfn_Impersonate_Self
== NULL
)
5363 return s_pfn_Impersonate_Self (ImpersonationLevel
);
5367 revert_to_self (void)
5369 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
5370 HMODULE hm_advapi32
= NULL
;
5371 if (is_windows_9x () == TRUE
)
5375 if (g_b_init_revert_to_self
== 0)
5377 g_b_init_revert_to_self
= 1;
5378 hm_advapi32
= LoadLibrary ("Advapi32.dll");
5379 s_pfn_Revert_To_Self
=
5380 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
5382 if (s_pfn_Revert_To_Self
== NULL
)
5386 return s_pfn_Revert_To_Self ();
5390 get_process_memory_info (HANDLE h_proc
,
5391 PPROCESS_MEMORY_COUNTERS mem_counters
,
5394 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
5395 HMODULE hm_psapi
= NULL
;
5396 if (is_windows_9x () == TRUE
)
5400 if (g_b_init_get_process_memory_info
== 0)
5402 g_b_init_get_process_memory_info
= 1;
5403 hm_psapi
= LoadLibrary ("Psapi.dll");
5405 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
5406 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
5408 if (s_pfn_Get_Process_Memory_Info
== NULL
)
5412 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
5416 get_process_working_set_size (HANDLE h_proc
,
5420 static GetProcessWorkingSetSize_Proc
5421 s_pfn_Get_Process_Working_Set_Size
= NULL
;
5423 if (is_windows_9x () == TRUE
)
5427 if (g_b_init_get_process_working_set_size
== 0)
5429 g_b_init_get_process_working_set_size
= 1;
5430 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
5431 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5432 "GetProcessWorkingSetSize");
5434 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
5438 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
5442 global_memory_status (MEMORYSTATUS
*buf
)
5444 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
5446 if (is_windows_9x () == TRUE
)
5450 if (g_b_init_global_memory_status
== 0)
5452 g_b_init_global_memory_status
= 1;
5453 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
5454 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5455 "GlobalMemoryStatus");
5457 if (s_pfn_Global_Memory_Status
== NULL
)
5461 return s_pfn_Global_Memory_Status (buf
);
5465 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
5467 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
5469 if (is_windows_9x () == TRUE
)
5473 if (g_b_init_global_memory_status_ex
== 0)
5475 g_b_init_global_memory_status_ex
= 1;
5476 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
5477 GetProcAddress (GetModuleHandle ("kernel32.dll"),
5478 "GlobalMemoryStatusEx");
5480 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
5484 return s_pfn_Global_Memory_Status_Ex (buf
);
5488 list_system_processes (void)
5490 struct gcpro gcpro1
;
5491 Lisp_Object proclist
= Qnil
;
5494 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5496 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5498 PROCESSENTRY32 proc_entry
;
5504 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
5505 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
5506 res
= process32_next (h_snapshot
, &proc_entry
))
5508 proc_id
= proc_entry
.th32ProcessID
;
5509 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
5512 CloseHandle (h_snapshot
);
5514 proclist
= Fnreverse (proclist
);
5521 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
5523 TOKEN_PRIVILEGES priv
;
5524 DWORD priv_size
= sizeof (priv
);
5525 DWORD opriv_size
= sizeof (*old_priv
);
5526 HANDLE h_token
= NULL
;
5527 HANDLE h_thread
= GetCurrentThread ();
5531 res
= open_thread_token (h_thread
,
5532 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5534 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
5536 if (impersonate_self (SecurityImpersonation
))
5537 res
= open_thread_token (h_thread
,
5538 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5543 priv
.PrivilegeCount
= 1;
5544 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
5545 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
5546 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
5547 old_priv
, &opriv_size
)
5548 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5552 CloseHandle (h_token
);
5558 restore_privilege (TOKEN_PRIVILEGES
*priv
)
5560 DWORD priv_size
= sizeof (*priv
);
5561 HANDLE h_token
= NULL
;
5564 if (open_thread_token (GetCurrentThread (),
5565 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
5568 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
5569 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
5573 CloseHandle (h_token
);
5579 ltime (ULONGLONG time_100ns
)
5581 ULONGLONG time_sec
= time_100ns
/ 10000000;
5582 int subsec
= time_100ns
% 10000000;
5583 return list4i (time_sec
>> 16, time_sec
& 0xffff,
5584 subsec
/ 10, subsec
% 10 * 100000);
5587 #define U64_TO_LISP_TIME(time) ltime (time)
5590 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
5591 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
5594 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
5595 ULONGLONG tem1
, tem2
, tem3
, tem
;
5598 || !get_process_times_fn
5599 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
5600 &ft_kernel
, &ft_user
))
5603 GetSystemTimeAsFileTime (&ft_current
);
5605 FILETIME_TO_U64 (tem1
, ft_kernel
);
5606 *stime
= U64_TO_LISP_TIME (tem1
);
5608 FILETIME_TO_U64 (tem2
, ft_user
);
5609 *utime
= U64_TO_LISP_TIME (tem2
);
5612 *ttime
= U64_TO_LISP_TIME (tem3
);
5614 FILETIME_TO_U64 (tem
, ft_creation
);
5615 /* Process no 4 (System) returns zero creation time. */
5618 *ctime
= U64_TO_LISP_TIME (tem
);
5622 FILETIME_TO_U64 (tem3
, ft_current
);
5623 tem
= (tem3
- utc_base
) - tem
;
5625 *etime
= U64_TO_LISP_TIME (tem
);
5629 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
5640 system_process_attributes (Lisp_Object pid
)
5642 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5643 Lisp_Object attrs
= Qnil
;
5644 Lisp_Object cmd_str
, decoded_cmd
, tem
;
5645 HANDLE h_snapshot
, h_proc
;
5648 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
5649 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
5650 DWORD glength
= sizeof (gname
);
5651 HANDLE token
= NULL
;
5652 SID_NAME_USE user_type
;
5653 unsigned char *buf
= NULL
;
5655 TOKEN_USER user_token
;
5656 TOKEN_PRIMARY_GROUP group_token
;
5659 PROCESS_MEMORY_COUNTERS mem
;
5660 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
5661 SIZE_T minrss
, maxrss
;
5663 MEMORY_STATUS_EX memstex
;
5664 double totphys
= 0.0;
5665 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
5667 BOOL result
= FALSE
;
5669 CHECK_NUMBER_OR_FLOAT (pid
);
5670 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
5672 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
5674 GCPRO3 (attrs
, decoded_cmd
, tem
);
5676 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
5681 pe
.dwSize
= sizeof (PROCESSENTRY32
);
5682 for (res
= process32_first (h_snapshot
, &pe
); res
;
5683 res
= process32_next (h_snapshot
, &pe
))
5685 if (proc_id
== pe
.th32ProcessID
)
5688 decoded_cmd
= build_string ("Idle");
5691 /* Decode the command name from locale-specific
5693 cmd_str
= make_unibyte_string (pe
.szExeFile
,
5694 strlen (pe
.szExeFile
));
5696 code_convert_string_norecord (cmd_str
,
5697 Vlocale_coding_system
, 0);
5699 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
5700 attrs
= Fcons (Fcons (Qppid
,
5701 make_fixnum_or_float (pe
.th32ParentProcessID
)),
5703 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
5705 attrs
= Fcons (Fcons (Qthcount
,
5706 make_fixnum_or_float (pe
.cntThreads
)),
5713 CloseHandle (h_snapshot
);
5722 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5724 /* If we were denied a handle to the process, try again after
5725 enabling the SeDebugPrivilege in our process. */
5728 TOKEN_PRIVILEGES priv_current
;
5730 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
5732 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
5734 restore_privilege (&priv_current
);
5740 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
5743 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
5744 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5746 buf
= xmalloc (blen
);
5747 result
= get_token_information (token
, TokenUser
,
5748 (LPVOID
)buf
, blen
, &needed
);
5751 memcpy (&user_token
, buf
, sizeof (user_token
));
5752 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
5754 euid
= get_rid (user_token
.User
.Sid
);
5755 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
5760 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
5763 strcpy (uname
, "unknown");
5767 ulength
= strlen (uname
);
5773 /* Determine a reasonable euid and gid values. */
5774 if (xstrcasecmp ("administrator", uname
) == 0)
5776 euid
= 500; /* well-known Administrator uid */
5777 egid
= 513; /* well-known None gid */
5781 /* Get group id and name. */
5782 result
= get_token_information (token
, TokenPrimaryGroup
,
5783 (LPVOID
)buf
, blen
, &needed
);
5784 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5786 buf
= xrealloc (buf
, blen
= needed
);
5787 result
= get_token_information (token
, TokenPrimaryGroup
,
5788 (LPVOID
)buf
, blen
, &needed
);
5792 memcpy (&group_token
, buf
, sizeof (group_token
));
5793 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5795 egid
= get_rid (group_token
.PrimaryGroup
);
5796 dlength
= sizeof (domain
);
5798 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5799 gname
, &glength
, NULL
, &dlength
,
5802 w32_add_to_cache (group_token
.PrimaryGroup
,
5806 strcpy (gname
, "None");
5810 glength
= strlen (gname
);
5818 if (!is_windows_9x ())
5820 /* We couldn't open the process token, presumably because of
5821 insufficient access rights. Assume this process is run
5823 strcpy (uname
, "SYSTEM");
5824 strcpy (gname
, "None");
5825 euid
= 18; /* SYSTEM */
5826 egid
= 513; /* None */
5827 glength
= strlen (gname
);
5828 ulength
= strlen (uname
);
5830 /* If we are running under Windows 9X, where security calls are
5831 not supported, we assume all processes are run by the current
5833 else if (GetUserName (uname
, &ulength
))
5835 if (xstrcasecmp ("administrator", uname
) == 0)
5840 strcpy (gname
, "None");
5841 glength
= strlen (gname
);
5842 ulength
= strlen (uname
);
5848 strcpy (uname
, "administrator");
5849 ulength
= strlen (uname
);
5850 strcpy (gname
, "None");
5851 glength
= strlen (gname
);
5854 CloseHandle (token
);
5857 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5858 tem
= make_unibyte_string (uname
, ulength
);
5859 attrs
= Fcons (Fcons (Quser
,
5860 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5862 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5863 tem
= make_unibyte_string (gname
, glength
);
5864 attrs
= Fcons (Fcons (Qgroup
,
5865 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5868 if (global_memory_status_ex (&memstex
))
5869 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5870 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5872 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5873 double, so we need to do this for it... */
5875 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5876 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5877 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5879 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5881 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5882 else if (global_memory_status (&memst
))
5883 totphys
= memst
.dwTotalPhys
/ 1024.0;
5886 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5889 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5891 attrs
= Fcons (Fcons (Qmajflt
,
5892 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5894 attrs
= Fcons (Fcons (Qvsize
,
5895 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5897 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5899 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5902 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5904 SIZE_T rss
= mem_ex
.WorkingSetSize
/ 1024;
5906 attrs
= Fcons (Fcons (Qmajflt
,
5907 make_fixnum_or_float (mem
.PageFaultCount
)),
5909 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5911 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5914 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5916 DWORD rss
= maxrss
/ 1024;
5918 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5920 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5923 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5925 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5926 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5927 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5928 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5929 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5930 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5933 /* FIXME: Retrieve command line by walking the PEB of the process. */
5936 CloseHandle (h_proc
);
5942 /* Wrappers for winsock functions to map between our file descriptors
5943 and winsock's handles; also set h_errno for convenience.
5945 To allow Emacs to run on systems which don't have winsock support
5946 installed, we dynamically link to winsock on startup if present, and
5947 otherwise provide the minimum necessary functionality
5948 (eg. gethostname). */
5950 /* function pointers for relevant socket functions */
5951 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5952 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5953 int (PASCAL
*pfn_WSAGetLastError
) (void);
5954 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5955 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5956 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5957 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5958 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5959 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5960 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5961 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5962 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5963 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5964 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5965 int (PASCAL
*pfn_WSACleanup
) (void);
5967 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5968 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5969 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5970 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5971 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5972 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5973 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5974 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5975 const char * optval
, int optlen
);
5976 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5977 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5979 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5980 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5981 struct sockaddr
* from
, int * fromlen
);
5982 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5983 const struct sockaddr
* to
, int tolen
);
5985 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5986 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5987 #ifndef HANDLE_FLAG_INHERIT
5988 #define HANDLE_FLAG_INHERIT 1
5992 static int winsock_inuse
;
5997 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5999 /* Not sure what would cause WSAENETDOWN, or even if it can happen
6000 after WSAStartup returns successfully, but it seems reasonable
6001 to allow unloading winsock anyway in that case. */
6002 if (pfn_WSACleanup () == 0 ||
6003 pfn_WSAGetLastError () == WSAENETDOWN
)
6005 if (FreeLibrary (winsock_lib
))
6014 init_winsock (int load_now
)
6016 WSADATA winsockData
;
6018 if (winsock_lib
!= NULL
)
6021 pfn_SetHandleInformation
6022 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
6023 "SetHandleInformation");
6025 winsock_lib
= LoadLibrary ("Ws2_32.dll");
6027 if (winsock_lib
!= NULL
)
6029 /* dynamically link to socket functions */
6031 #define LOAD_PROC(fn) \
6032 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
6035 LOAD_PROC (WSAStartup
);
6036 LOAD_PROC (WSASetLastError
);
6037 LOAD_PROC (WSAGetLastError
);
6038 LOAD_PROC (WSAEventSelect
);
6039 LOAD_PROC (WSACreateEvent
);
6040 LOAD_PROC (WSACloseEvent
);
6043 LOAD_PROC (connect
);
6044 LOAD_PROC (ioctlsocket
);
6047 LOAD_PROC (closesocket
);
6048 LOAD_PROC (shutdown
);
6051 LOAD_PROC (inet_addr
);
6052 LOAD_PROC (gethostname
);
6053 LOAD_PROC (gethostbyname
);
6054 LOAD_PROC (getservbyname
);
6055 LOAD_PROC (getpeername
);
6056 LOAD_PROC (WSACleanup
);
6057 LOAD_PROC (setsockopt
);
6059 LOAD_PROC (getsockname
);
6061 LOAD_PROC (recvfrom
);
6065 /* specify version 1.1 of winsock */
6066 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
6068 if (winsockData
.wVersion
!= 0x101)
6073 /* Report that winsock exists and is usable, but leave
6074 socket functions disabled. I am assuming that calling
6075 WSAStartup does not require any network interaction,
6076 and in particular does not cause or require a dial-up
6077 connection to be established. */
6080 FreeLibrary (winsock_lib
);
6088 FreeLibrary (winsock_lib
);
6098 /* Function to map winsock error codes to errno codes for those errno
6099 code defined in errno.h (errno values not defined by errno.h are
6100 already in nt/inc/sys/socket.h). */
6107 if (winsock_lib
== NULL
)
6110 wsa_err
= pfn_WSAGetLastError ();
6114 case WSAEACCES
: errno
= EACCES
; break;
6115 case WSAEBADF
: errno
= EBADF
; break;
6116 case WSAEFAULT
: errno
= EFAULT
; break;
6117 case WSAEINTR
: errno
= EINTR
; break;
6118 case WSAEINVAL
: errno
= EINVAL
; break;
6119 case WSAEMFILE
: errno
= EMFILE
; break;
6120 case WSAENAMETOOLONG
: errno
= ENAMETOOLONG
; break;
6121 case WSAENOTEMPTY
: errno
= ENOTEMPTY
; break;
6122 default: errno
= wsa_err
; break;
6130 if (winsock_lib
!= NULL
)
6131 pfn_WSASetLastError (0);
6134 /* Extend strerror to handle the winsock-specific error codes. */
6138 } _wsa_errlist
[] = {
6139 {WSAEINTR
, "Interrupted function call"},
6140 {WSAEBADF
, "Bad file descriptor"},
6141 {WSAEACCES
, "Permission denied"},
6142 {WSAEFAULT
, "Bad address"},
6143 {WSAEINVAL
, "Invalid argument"},
6144 {WSAEMFILE
, "Too many open files"},
6146 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
6147 {WSAEINPROGRESS
, "Operation now in progress"},
6148 {WSAEALREADY
, "Operation already in progress"},
6149 {WSAENOTSOCK
, "Socket operation on non-socket"},
6150 {WSAEDESTADDRREQ
, "Destination address required"},
6151 {WSAEMSGSIZE
, "Message too long"},
6152 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
6153 {WSAENOPROTOOPT
, "Bad protocol option"},
6154 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
6155 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
6156 {WSAEOPNOTSUPP
, "Operation not supported"},
6157 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
6158 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
6159 {WSAEADDRINUSE
, "Address already in use"},
6160 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
6161 {WSAENETDOWN
, "Network is down"},
6162 {WSAENETUNREACH
, "Network is unreachable"},
6163 {WSAENETRESET
, "Network dropped connection on reset"},
6164 {WSAECONNABORTED
, "Software caused connection abort"},
6165 {WSAECONNRESET
, "Connection reset by peer"},
6166 {WSAENOBUFS
, "No buffer space available"},
6167 {WSAEISCONN
, "Socket is already connected"},
6168 {WSAENOTCONN
, "Socket is not connected"},
6169 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
6170 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
6171 {WSAETIMEDOUT
, "Connection timed out"},
6172 {WSAECONNREFUSED
, "Connection refused"},
6173 {WSAELOOP
, "Network loop"}, /* not sure */
6174 {WSAENAMETOOLONG
, "Name is too long"},
6175 {WSAEHOSTDOWN
, "Host is down"},
6176 {WSAEHOSTUNREACH
, "No route to host"},
6177 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
6178 {WSAEPROCLIM
, "Too many processes"},
6179 {WSAEUSERS
, "Too many users"}, /* not sure */
6180 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
6181 {WSAESTALE
, "Data is stale"}, /* not sure */
6182 {WSAEREMOTE
, "Remote error"}, /* not sure */
6184 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
6185 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
6186 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
6187 {WSAEDISCON
, "Graceful shutdown in progress"},
6189 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
6190 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
6191 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
6192 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
6193 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
6194 {WSASYSCALLFAILURE
, "System call failure"},
6195 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
6196 {WSATYPE_NOT_FOUND
, "Class type not found"},
6197 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
6198 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
6199 {WSAEREFUSED
, "Operation refused"}, /* not sure */
6202 {WSAHOST_NOT_FOUND
, "Host not found"},
6203 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
6204 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
6205 {WSANO_DATA
, "Valid name, no data record of requested type"},
6211 sys_strerror (int error_no
)
6214 static char unknown_msg
[40];
6216 if (error_no
>= 0 && error_no
< sys_nerr
)
6217 return sys_errlist
[error_no
];
6219 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
6220 if (_wsa_errlist
[i
].errnum
== error_no
)
6221 return _wsa_errlist
[i
].msg
;
6223 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
6227 /* [andrewi 3-May-96] I've had conflicting results using both methods,
6228 but I believe the method of keeping the socket handle separate (and
6229 insuring it is not inheritable) is the correct one. */
6231 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
6233 static int socket_to_fd (SOCKET s
);
6236 sys_socket (int af
, int type
, int protocol
)
6240 if (winsock_lib
== NULL
)
6243 return INVALID_SOCKET
;
6248 /* call the real socket function */
6249 s
= pfn_socket (af
, type
, protocol
);
6251 if (s
!= INVALID_SOCKET
)
6252 return socket_to_fd (s
);
6258 /* Convert a SOCKET to a file descriptor. */
6260 socket_to_fd (SOCKET s
)
6265 /* Although under NT 3.5 _open_osfhandle will accept a socket
6266 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
6267 that does not work under NT 3.1. However, we can get the same
6268 effect by using a backdoor function to replace an existing
6269 descriptor handle with the one we want. */
6271 /* allocate a file descriptor (with appropriate flags) */
6272 fd
= _open ("NUL:", _O_RDWR
);
6275 /* Make a non-inheritable copy of the socket handle. Note
6276 that it is possible that sockets aren't actually kernel
6277 handles, which appears to be the case on Windows 9x when
6278 the MS Proxy winsock client is installed. */
6280 /* Apparently there is a bug in NT 3.51 with some service
6281 packs, which prevents using DuplicateHandle to make a
6282 socket handle non-inheritable (causes WSACleanup to
6283 hang). The work-around is to use SetHandleInformation
6284 instead if it is available and implemented. */
6285 if (pfn_SetHandleInformation
)
6287 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
6291 HANDLE parent
= GetCurrentProcess ();
6292 HANDLE new_s
= INVALID_HANDLE_VALUE
;
6294 if (DuplicateHandle (parent
,
6300 DUPLICATE_SAME_ACCESS
))
6302 /* It is possible that DuplicateHandle succeeds even
6303 though the socket wasn't really a kernel handle,
6304 because a real handle has the same value. So
6305 test whether the new handle really is a socket. */
6306 long nonblocking
= 0;
6307 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
6309 pfn_closesocket (s
);
6314 CloseHandle (new_s
);
6319 eassert (fd
< MAXDESC
);
6320 fd_info
[fd
].hnd
= (HANDLE
) s
;
6322 /* set our own internal flags */
6323 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
6329 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6331 /* attach child_process to fd_info */
6332 if (fd_info
[ fd
].cp
!= NULL
)
6334 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
6338 fd_info
[ fd
].cp
= cp
;
6341 winsock_inuse
++; /* count open sockets */
6349 pfn_closesocket (s
);
6355 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
6357 if (winsock_lib
== NULL
)
6360 return SOCKET_ERROR
;
6364 if (fd_info
[s
].flags
& FILE_SOCKET
)
6366 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
6367 if (rc
== SOCKET_ERROR
)
6372 return SOCKET_ERROR
;
6376 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
6378 if (winsock_lib
== NULL
)
6381 return SOCKET_ERROR
;
6385 if (fd_info
[s
].flags
& FILE_SOCKET
)
6387 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
6388 if (rc
== SOCKET_ERROR
)
6393 return SOCKET_ERROR
;
6397 sys_htons (u_short hostshort
)
6399 return (winsock_lib
!= NULL
) ?
6400 pfn_htons (hostshort
) : hostshort
;
6404 sys_ntohs (u_short netshort
)
6406 return (winsock_lib
!= NULL
) ?
6407 pfn_ntohs (netshort
) : netshort
;
6411 sys_inet_addr (const char * cp
)
6413 return (winsock_lib
!= NULL
) ?
6414 pfn_inet_addr (cp
) : INADDR_NONE
;
6418 sys_gethostname (char * name
, int namelen
)
6420 if (winsock_lib
!= NULL
)
6425 retval
= pfn_gethostname (name
, namelen
);
6426 if (retval
== SOCKET_ERROR
)
6431 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
6432 return !GetComputerName (name
, (DWORD
*)&namelen
);
6435 return SOCKET_ERROR
;
6439 sys_gethostbyname (const char * name
)
6441 struct hostent
* host
;
6442 int h_err
= h_errno
;
6444 if (winsock_lib
== NULL
)
6446 h_errno
= NO_RECOVERY
;
6452 host
= pfn_gethostbyname (name
);
6464 sys_getservbyname (const char * name
, const char * proto
)
6466 struct servent
* serv
;
6468 if (winsock_lib
== NULL
)
6475 serv
= pfn_getservbyname (name
, proto
);
6482 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
6484 if (winsock_lib
== NULL
)
6487 return SOCKET_ERROR
;
6491 if (fd_info
[s
].flags
& FILE_SOCKET
)
6493 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
6494 if (rc
== SOCKET_ERROR
)
6499 return SOCKET_ERROR
;
6503 sys_shutdown (int s
, int how
)
6505 if (winsock_lib
== NULL
)
6508 return SOCKET_ERROR
;
6512 if (fd_info
[s
].flags
& FILE_SOCKET
)
6514 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
6515 if (rc
== SOCKET_ERROR
)
6520 return SOCKET_ERROR
;
6524 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
6526 if (winsock_lib
== NULL
)
6529 return SOCKET_ERROR
;
6533 if (fd_info
[s
].flags
& FILE_SOCKET
)
6535 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
6536 (const char *)optval
, optlen
);
6537 if (rc
== SOCKET_ERROR
)
6542 return SOCKET_ERROR
;
6546 sys_listen (int s
, int backlog
)
6548 if (winsock_lib
== NULL
)
6551 return SOCKET_ERROR
;
6555 if (fd_info
[s
].flags
& FILE_SOCKET
)
6557 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
6558 if (rc
== SOCKET_ERROR
)
6561 fd_info
[s
].flags
|= FILE_LISTEN
;
6565 return SOCKET_ERROR
;
6569 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
6571 if (winsock_lib
== NULL
)
6574 return SOCKET_ERROR
;
6578 if (fd_info
[s
].flags
& FILE_SOCKET
)
6580 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
6581 if (rc
== SOCKET_ERROR
)
6586 return SOCKET_ERROR
;
6590 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
6592 if (winsock_lib
== NULL
)
6599 if (fd_info
[s
].flags
& FILE_LISTEN
)
6601 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
6603 if (t
== INVALID_SOCKET
)
6606 fd
= socket_to_fd (t
);
6610 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6611 ResetEvent (fd_info
[s
].cp
->char_avail
);
6620 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
6621 struct sockaddr
* from
, int * fromlen
)
6623 if (winsock_lib
== NULL
)
6626 return SOCKET_ERROR
;
6630 if (fd_info
[s
].flags
& FILE_SOCKET
)
6632 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
6633 if (rc
== SOCKET_ERROR
)
6638 return SOCKET_ERROR
;
6642 sys_sendto (int s
, const char * buf
, int len
, int flags
,
6643 const struct sockaddr
* to
, int tolen
)
6645 if (winsock_lib
== NULL
)
6648 return SOCKET_ERROR
;
6652 if (fd_info
[s
].flags
& FILE_SOCKET
)
6654 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
6655 if (rc
== SOCKET_ERROR
)
6660 return SOCKET_ERROR
;
6663 /* Windows does not have an fcntl function. Provide an implementation
6664 solely for making sockets non-blocking. */
6666 fcntl (int s
, int cmd
, int options
)
6668 if (winsock_lib
== NULL
)
6675 if (fd_info
[s
].flags
& FILE_SOCKET
)
6677 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
6679 unsigned long nblock
= 1;
6680 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
6681 if (rc
== SOCKET_ERROR
)
6683 /* Keep track of the fact that we set this to non-blocking. */
6684 fd_info
[s
].flags
|= FILE_NDELAY
;
6690 return SOCKET_ERROR
;
6694 return SOCKET_ERROR
;
6698 /* Shadow main io functions: we need to handle pipes and sockets more
6699 intelligently, and implement non-blocking mode as well. */
6712 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
6714 child_process
* cp
= fd_info
[fd
].cp
;
6716 fd_info
[fd
].cp
= NULL
;
6718 if (CHILD_ACTIVE (cp
))
6720 /* if last descriptor to active child_process then cleanup */
6722 for (i
= 0; i
< MAXDESC
; i
++)
6726 if (fd_info
[i
].cp
== cp
)
6731 if (fd_info
[fd
].flags
& FILE_SOCKET
)
6733 if (winsock_lib
== NULL
) emacs_abort ();
6735 pfn_shutdown (SOCK_HANDLE (fd
), 2);
6736 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
6738 winsock_inuse
--; /* count open sockets */
6740 /* If the process handle is NULL, it's either a socket
6741 or serial connection, or a subprocess that was
6742 already reaped by reap_subprocess, but whose
6743 resources were not yet freed, because its output was
6744 not fully read yet by the time it was reaped. (This
6745 usually happens with async subprocesses whose output
6746 is being read by Emacs.) Otherwise, this process was
6747 not reaped yet, so we set its FD to a negative value
6748 to make sure sys_select will eventually get to
6749 calling the SIGCHLD handler for it, which will then
6750 invoke waitpid and reap_subprocess. */
6751 if (cp
->procinfo
.hProcess
== NULL
)
6759 if (fd
>= 0 && fd
< MAXDESC
)
6760 fd_info
[fd
].flags
= 0;
6762 /* Note that sockets do not need special treatment here (at least on
6763 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
6764 closesocket is equivalent to CloseHandle, which is to be expected
6765 because socket handles are fully fledged kernel handles. */
6777 if (new_fd
>= 0 && new_fd
< MAXDESC
)
6779 /* duplicate our internal info as well */
6780 fd_info
[new_fd
] = fd_info
[fd
];
6786 sys_dup2 (int src
, int dst
)
6790 if (dst
< 0 || dst
>= MAXDESC
)
6796 /* make sure we close the destination first if it's a pipe or socket */
6797 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
6800 rc
= _dup2 (src
, dst
);
6803 /* duplicate our internal info as well */
6804 fd_info
[dst
] = fd_info
[src
];
6809 /* Unix pipe() has only one arg */
6811 sys_pipe (int * phandles
)
6816 /* make pipe handles non-inheritable; when we spawn a child, we
6817 replace the relevant handle with an inheritable one. Also put
6818 pipes into binary mode; we will do text mode translation ourselves
6820 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
6824 /* Protect against overflow, since Windows can open more handles than
6825 our fd_info array has room for. */
6826 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
6828 _close (phandles
[0]);
6829 _close (phandles
[1]);
6835 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6836 fd_info
[phandles
[0]].flags
= flags
;
6838 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6839 fd_info
[phandles
[1]].flags
= flags
;
6846 /* Function to do blocking read of one byte, needed to implement
6847 select. It is only allowed on communication ports, sockets, or
6850 _sys_read_ahead (int fd
)
6855 if (fd
< 0 || fd
>= MAXDESC
)
6856 return STATUS_READ_ERROR
;
6858 cp
= fd_info
[fd
].cp
;
6860 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6861 return STATUS_READ_ERROR
;
6863 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6864 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6866 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6870 cp
->status
= STATUS_READ_IN_PROGRESS
;
6872 if (fd_info
[fd
].flags
& FILE_PIPE
)
6874 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6876 /* Give subprocess time to buffer some more output for us before
6877 reporting that input is available; we need this because Windows 95
6878 connects DOS programs to pipes by making the pipe appear to be
6879 the normal console stdout - as a result most DOS programs will
6880 write to stdout without buffering, ie. one character at a
6881 time. Even some W32 programs do this - "dir" in a command
6882 shell on NT is very slow if we don't do this. */
6885 int wait
= w32_pipe_read_delay
;
6891 /* Yield remainder of our time slice, effectively giving a
6892 temporary priority boost to the child process. */
6896 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6898 HANDLE hnd
= fd_info
[fd
].hnd
;
6899 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6902 /* Configure timeouts for blocking read. */
6903 if (!GetCommTimeouts (hnd
, &ct
))
6905 cp
->status
= STATUS_READ_ERROR
;
6906 return STATUS_READ_ERROR
;
6908 ct
.ReadIntervalTimeout
= 0;
6909 ct
.ReadTotalTimeoutMultiplier
= 0;
6910 ct
.ReadTotalTimeoutConstant
= 0;
6911 if (!SetCommTimeouts (hnd
, &ct
))
6913 cp
->status
= STATUS_READ_ERROR
;
6914 return STATUS_READ_ERROR
;
6917 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6919 if (GetLastError () != ERROR_IO_PENDING
)
6921 cp
->status
= STATUS_READ_ERROR
;
6922 return STATUS_READ_ERROR
;
6924 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6926 cp
->status
= STATUS_READ_ERROR
;
6927 return STATUS_READ_ERROR
;
6931 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6933 unsigned long nblock
= 0;
6934 /* We always want this to block, so temporarily disable NDELAY. */
6935 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6936 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6938 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6940 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6943 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6947 if (rc
== sizeof (char))
6948 cp
->status
= STATUS_READ_SUCCEEDED
;
6950 cp
->status
= STATUS_READ_FAILED
;
6956 _sys_wait_accept (int fd
)
6962 if (fd
< 0 || fd
>= MAXDESC
)
6963 return STATUS_READ_ERROR
;
6965 cp
= fd_info
[fd
].cp
;
6967 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6968 return STATUS_READ_ERROR
;
6970 cp
->status
= STATUS_READ_FAILED
;
6972 hEv
= pfn_WSACreateEvent ();
6973 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6974 if (rc
!= SOCKET_ERROR
)
6976 rc
= WaitForSingleObject (hEv
, INFINITE
);
6977 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6978 if (rc
== WAIT_OBJECT_0
)
6979 cp
->status
= STATUS_READ_SUCCEEDED
;
6981 pfn_WSACloseEvent (hEv
);
6987 sys_read (int fd
, char * buffer
, unsigned int count
)
6992 char * orig_buffer
= buffer
;
7000 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7002 child_process
*cp
= fd_info
[fd
].cp
;
7004 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
7012 /* re-read CR carried over from last read */
7013 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
7015 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
7019 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
7022 /* presence of a child_process structure means we are operating in
7023 non-blocking mode - otherwise we just call _read directly.
7024 Note that the child_process structure might be missing because
7025 reap_subprocess has been called; in this case the pipe is
7026 already broken, so calling _read on it is okay. */
7029 int current_status
= cp
->status
;
7031 switch (current_status
)
7033 case STATUS_READ_FAILED
:
7034 case STATUS_READ_ERROR
:
7035 /* report normal EOF if nothing in buffer */
7037 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7040 case STATUS_READ_READY
:
7041 case STATUS_READ_IN_PROGRESS
:
7042 DebPrint (("sys_read called when read is in progress\n"));
7043 errno
= EWOULDBLOCK
;
7046 case STATUS_READ_SUCCEEDED
:
7047 /* consume read-ahead char */
7048 *buffer
++ = cp
->chr
;
7051 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7052 ResetEvent (cp
->char_avail
);
7054 case STATUS_READ_ACKNOWLEDGED
:
7058 DebPrint (("sys_read: bad status %d\n", current_status
));
7063 if (fd_info
[fd
].flags
& FILE_PIPE
)
7065 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
7066 to_read
= min (waiting
, (DWORD
) count
);
7069 nchars
+= _read (fd
, buffer
, to_read
);
7071 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
7073 HANDLE hnd
= fd_info
[fd
].hnd
;
7074 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
7080 /* Configure timeouts for non-blocking read. */
7081 if (!GetCommTimeouts (hnd
, &ct
))
7086 ct
.ReadIntervalTimeout
= MAXDWORD
;
7087 ct
.ReadTotalTimeoutMultiplier
= 0;
7088 ct
.ReadTotalTimeoutConstant
= 0;
7089 if (!SetCommTimeouts (hnd
, &ct
))
7095 if (!ResetEvent (ovl
->hEvent
))
7100 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
7102 if (GetLastError () != ERROR_IO_PENDING
)
7107 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
7116 else /* FILE_SOCKET */
7118 if (winsock_lib
== NULL
) emacs_abort ();
7120 /* do the equivalent of a non-blocking read */
7121 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
7122 if (waiting
== 0 && nchars
== 0)
7124 errno
= EWOULDBLOCK
;
7130 /* always use binary mode for sockets */
7131 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
7132 if (res
== SOCKET_ERROR
)
7134 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
7135 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7145 int nread
= _read (fd
, buffer
, count
);
7148 else if (nchars
== 0)
7153 fd_info
[fd
].flags
|= FILE_AT_EOF
;
7154 /* Perform text mode translation if required. */
7155 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7157 nchars
= crlf_to_lf (nchars
, orig_buffer
);
7158 /* If buffer contains only CR, return that. To be absolutely
7159 sure we should attempt to read the next char, but in
7160 practice a CR to be followed by LF would not appear by
7161 itself in the buffer. */
7162 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
7164 fd_info
[fd
].flags
|= FILE_LAST_CR
;
7170 nchars
= _read (fd
, buffer
, count
);
7175 /* From w32xfns.c */
7176 extern HANDLE interrupt_handle
;
7178 /* For now, don't bother with a non-blocking mode */
7180 sys_write (int fd
, const void * buffer
, unsigned int count
)
7190 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
7192 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
7198 /* Perform text mode translation if required. */
7199 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
7201 char * tmpbuf
= alloca (count
* 2);
7202 unsigned char * src
= (void *)buffer
;
7203 unsigned char * dst
= tmpbuf
;
7208 unsigned char *next
;
7209 /* copy next line or remaining bytes */
7210 next
= _memccpy (dst
, src
, '\n', nbytes
);
7213 /* copied one line ending with '\n' */
7214 int copied
= next
- dst
;
7217 /* insert '\r' before '\n' */
7224 /* copied remaining partial line -> now finished */
7231 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
7233 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
7234 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
7235 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
7238 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
7240 if (GetLastError () != ERROR_IO_PENDING
)
7245 if (detect_input_pending ())
7246 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
7249 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
7250 if (active
== WAIT_OBJECT_0
)
7251 { /* User pressed C-g, cancel write, then leave. Don't bother
7252 cleaning up as we may only get stuck in buggy drivers. */
7253 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
7258 if (active
== WAIT_OBJECT_0
+ 1
7259 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
7266 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
7268 unsigned long nblock
= 0;
7269 if (winsock_lib
== NULL
) emacs_abort ();
7271 /* TODO: implement select() properly so non-blocking I/O works. */
7272 /* For now, make sure the write blocks. */
7273 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7274 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7276 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
7278 /* Set the socket back to non-blocking if it was before,
7279 for other operations that support it. */
7280 if (fd_info
[fd
].flags
& FILE_NDELAY
)
7283 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
7286 if (nchars
== SOCKET_ERROR
)
7288 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
7289 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
7295 /* Some networked filesystems don't like too large writes, so
7296 break them into smaller chunks. See the Comments section of
7297 the MSDN documentation of WriteFile for details behind the
7298 choice of the value of CHUNK below. See also the thread
7299 http://thread.gmane.org/gmane.comp.version-control.git/145294
7300 in the git mailing list. */
7301 const unsigned char *p
= buffer
;
7302 const unsigned chunk
= 30 * 1024 * 1024;
7307 unsigned this_chunk
= count
< chunk
? count
: chunk
;
7308 int n
= _write (fd
, p
, this_chunk
);
7316 else if (n
< this_chunk
)
7326 /* The Windows CRT functions are "optimized for speed", so they don't
7327 check for timezone and DST changes if they were last called less
7328 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
7329 all Emacs features that repeatedly call time functions (e.g.,
7330 display-time) are in real danger of missing timezone and DST
7331 changes. Calling tzset before each localtime call fixes that. */
7333 sys_localtime (const time_t *t
)
7336 return localtime (t
);
7341 /* Try loading LIBRARY_ID from the file(s) specified in
7342 Vdynamic_library_alist. If the library is loaded successfully,
7343 return the handle of the DLL, and record the filename in the
7344 property :loaded-from of LIBRARY_ID. If the library could not be
7345 found, or when it was already loaded (because the handle is not
7346 recorded anywhere, and so is lost after use), return NULL.
7348 We could also save the handle in :loaded-from, but currently
7349 there's no use case for it. */
7351 w32_delayed_load (Lisp_Object library_id
)
7353 HMODULE library_dll
= NULL
;
7355 CHECK_SYMBOL (library_id
);
7357 if (CONSP (Vdynamic_library_alist
)
7358 && NILP (Fassq (library_id
, Vlibrary_cache
)))
7360 Lisp_Object found
= Qnil
;
7361 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
7364 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
7366 CHECK_STRING_CAR (dlls
);
7367 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
7369 char name
[MAX_PATH
];
7372 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
7373 found
= Fcons (XCAR (dlls
),
7375 /* Possibly truncated */
7376 ? make_specified_string (name
, -1, len
, 1)
7382 Fput (library_id
, QCloaded_from
, found
);
7390 check_windows_init_file (void)
7392 /* A common indication that Emacs is not installed properly is when
7393 it cannot find the Windows installation file. If this file does
7394 not exist in the expected place, tell the user. */
7396 if (!noninteractive
&& !inhibit_window_system
7397 /* Vload_path is not yet initialized when we are loading
7399 && NILP (Vpurify_flag
))
7401 Lisp_Object init_file
;
7404 init_file
= build_string ("term/w32-win");
7405 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
7408 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
7409 char *init_file_name
= SDATA (init_file
);
7410 char *load_path
= SDATA (load_path_print
);
7411 char *buffer
= alloca (1024
7412 + strlen (init_file_name
)
7413 + strlen (load_path
));
7416 "The Emacs Windows initialization file \"%s.el\" "
7417 "could not be found in your Emacs installation. "
7418 "Emacs checked the following directories for this file:\n"
7420 "When Emacs cannot find this file, it usually means that it "
7421 "was not installed properly, or its distribution file was "
7422 "not unpacked properly.\nSee the README.W32 file in the "
7423 "top-level Emacs directory for more information.",
7424 init_file_name
, load_path
);
7427 "Emacs Abort Dialog",
7428 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
7429 /* Use the low-level system abort. */
7440 term_ntproc (int ignored
)
7446 /* shutdown the socket interface if necessary */
7453 init_ntproc (int dumping
)
7455 sigset_t initial_mask
= 0;
7457 /* Initialize the socket interface now if available and requested by
7458 the user by defining PRELOAD_WINSOCK; otherwise loading will be
7459 delayed until open-network-stream is called (w32-has-winsock can
7460 also be used to dynamically load or reload winsock).
7462 Conveniently, init_environment is called before us, so
7463 PRELOAD_WINSOCK can be set in the registry. */
7465 /* Always initialize this correctly. */
7468 if (getenv ("PRELOAD_WINSOCK") != NULL
)
7469 init_winsock (TRUE
);
7471 /* Initial preparation for subprocess support: replace our standard
7472 handles with non-inheritable versions. */
7475 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
7476 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
7477 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
7479 parent
= GetCurrentProcess ();
7481 /* ignore errors when duplicating and closing; typically the
7482 handles will be invalid when running as a gui program. */
7483 DuplicateHandle (parent
,
7484 GetStdHandle (STD_INPUT_HANDLE
),
7489 DUPLICATE_SAME_ACCESS
);
7491 DuplicateHandle (parent
,
7492 GetStdHandle (STD_OUTPUT_HANDLE
),
7497 DUPLICATE_SAME_ACCESS
);
7499 DuplicateHandle (parent
,
7500 GetStdHandle (STD_ERROR_HANDLE
),
7505 DUPLICATE_SAME_ACCESS
);
7511 if (stdin_save
!= INVALID_HANDLE_VALUE
)
7512 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
7514 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
7517 if (stdout_save
!= INVALID_HANDLE_VALUE
)
7518 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
7520 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7523 if (stderr_save
!= INVALID_HANDLE_VALUE
)
7524 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
7526 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
7530 /* unfortunately, atexit depends on implementation of malloc */
7531 /* atexit (term_ntproc); */
7534 /* Make sure we start with all signals unblocked. */
7535 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
7536 signal (SIGABRT
, term_ntproc
);
7540 /* determine which drives are fixed, for GetCachedVolumeInformation */
7542 /* GetDriveType must have trailing backslash. */
7543 char drive
[] = "A:\\";
7545 /* Loop over all possible drive letters */
7546 while (*drive
<= 'Z')
7548 /* Record if this drive letter refers to a fixed drive. */
7549 fixed_drives
[DRIVE_INDEX (*drive
)] =
7550 (GetDriveType (drive
) == DRIVE_FIXED
);
7555 /* Reset the volume info cache. */
7556 volume_cache
= NULL
;
7561 shutdown_handler ensures that buffers' autosave files are
7562 up to date when the user logs off, or the system shuts down.
7565 shutdown_handler (DWORD type
)
7567 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
7568 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
7569 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
7570 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
7572 /* Shut down cleanly, making sure autosave files are up to date. */
7573 shut_down_emacs (0, Qnil
);
7576 /* Allow other handlers to handle this signal. */
7581 globals_of_w32 is used to initialize those global variables that
7582 must always be initialized on startup even when the global variable
7583 initialized is non zero (see the function main in emacs.c).
7586 globals_of_w32 (void)
7588 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
7590 get_process_times_fn
= (GetProcessTimes_Proc
)
7591 GetProcAddress (kernel32
, "GetProcessTimes");
7593 DEFSYM (QCloaded_from
, ":loaded-from");
7595 g_b_init_is_windows_9x
= 0;
7596 g_b_init_open_process_token
= 0;
7597 g_b_init_get_token_information
= 0;
7598 g_b_init_lookup_account_sid
= 0;
7599 g_b_init_get_sid_sub_authority
= 0;
7600 g_b_init_get_sid_sub_authority_count
= 0;
7601 g_b_init_get_security_info
= 0;
7602 g_b_init_get_file_security
= 0;
7603 g_b_init_get_security_descriptor_owner
= 0;
7604 g_b_init_get_security_descriptor_group
= 0;
7605 g_b_init_is_valid_sid
= 0;
7606 g_b_init_create_toolhelp32_snapshot
= 0;
7607 g_b_init_process32_first
= 0;
7608 g_b_init_process32_next
= 0;
7609 g_b_init_open_thread_token
= 0;
7610 g_b_init_impersonate_self
= 0;
7611 g_b_init_revert_to_self
= 0;
7612 g_b_init_get_process_memory_info
= 0;
7613 g_b_init_get_process_working_set_size
= 0;
7614 g_b_init_global_memory_status
= 0;
7615 g_b_init_global_memory_status_ex
= 0;
7616 g_b_init_equal_sid
= 0;
7617 g_b_init_copy_sid
= 0;
7618 g_b_init_get_length_sid
= 0;
7619 g_b_init_get_native_system_info
= 0;
7620 g_b_init_get_system_times
= 0;
7621 g_b_init_create_symbolic_link
= 0;
7622 g_b_init_get_security_descriptor_dacl
= 0;
7623 g_b_init_convert_sd_to_sddl
= 0;
7624 g_b_init_convert_sddl_to_sd
= 0;
7625 g_b_init_is_valid_security_descriptor
= 0;
7626 g_b_init_set_file_security
= 0;
7627 num_of_processors
= 0;
7628 /* The following sets a handler for shutdown notifications for
7629 console apps. This actually applies to Emacs in both console and
7630 GUI modes, since we had to fool windows into thinking emacs is a
7631 console application to get console mode to work. */
7632 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
7634 /* "None" is the default group name on standalone workstations. */
7635 strcpy (dflt_group_name
, "None");
7637 /* Reset, in case it has some value inherited from dump time. */
7638 w32_stat_get_owner_group
= 0;
7641 /* For make-serial-process */
7643 serial_open (char *port
)
7649 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
7650 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
7651 if (hnd
== INVALID_HANDLE_VALUE
)
7652 error ("Could not open %s", port
);
7653 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
7655 error ("Could not open %s", port
);
7659 error ("Could not create child process");
7661 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
7662 fd_info
[ fd
].hnd
= hnd
;
7663 fd_info
[ fd
].flags
|=
7664 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
7665 if (fd_info
[ fd
].cp
!= NULL
)
7667 error ("fd_info[fd = %d] is already in use", fd
);
7669 fd_info
[ fd
].cp
= cp
;
7670 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7671 if (cp
->ovl_read
.hEvent
== NULL
)
7672 error ("Could not create read event");
7673 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
7674 if (cp
->ovl_write
.hEvent
== NULL
)
7675 error ("Could not create write event");
7680 /* For serial-process-configure */
7682 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
7684 Lisp_Object childp2
= Qnil
;
7685 Lisp_Object tem
= Qnil
;
7689 char summary
[4] = "???"; /* This usually becomes "8N1". */
7691 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
7692 error ("Not a serial process");
7693 hnd
= fd_info
[ p
->outfd
].hnd
;
7695 childp2
= Fcopy_sequence (p
->childp
);
7697 /* Initialize timeouts for blocking read and blocking write. */
7698 if (!GetCommTimeouts (hnd
, &ct
))
7699 error ("GetCommTimeouts() failed");
7700 ct
.ReadIntervalTimeout
= 0;
7701 ct
.ReadTotalTimeoutMultiplier
= 0;
7702 ct
.ReadTotalTimeoutConstant
= 0;
7703 ct
.WriteTotalTimeoutMultiplier
= 0;
7704 ct
.WriteTotalTimeoutConstant
= 0;
7705 if (!SetCommTimeouts (hnd
, &ct
))
7706 error ("SetCommTimeouts() failed");
7707 /* Read port attributes and prepare default configuration. */
7708 memset (&dcb
, 0, sizeof (dcb
));
7709 dcb
.DCBlength
= sizeof (DCB
);
7710 if (!GetCommState (hnd
, &dcb
))
7711 error ("GetCommState() failed");
7714 dcb
.fAbortOnError
= FALSE
;
7715 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
7720 /* Configure speed. */
7721 if (!NILP (Fplist_member (contact
, QCspeed
)))
7722 tem
= Fplist_get (contact
, QCspeed
);
7724 tem
= Fplist_get (p
->childp
, QCspeed
);
7726 dcb
.BaudRate
= XINT (tem
);
7727 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
7729 /* Configure bytesize. */
7730 if (!NILP (Fplist_member (contact
, QCbytesize
)))
7731 tem
= Fplist_get (contact
, QCbytesize
);
7733 tem
= Fplist_get (p
->childp
, QCbytesize
);
7735 tem
= make_number (8);
7737 if (XINT (tem
) != 7 && XINT (tem
) != 8)
7738 error (":bytesize must be nil (8), 7, or 8");
7739 dcb
.ByteSize
= XINT (tem
);
7740 summary
[0] = XINT (tem
) + '0';
7741 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
7743 /* Configure parity. */
7744 if (!NILP (Fplist_member (contact
, QCparity
)))
7745 tem
= Fplist_get (contact
, QCparity
);
7747 tem
= Fplist_get (p
->childp
, QCparity
);
7748 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
7749 error (":parity must be nil (no parity), `even', or `odd'");
7750 dcb
.fParity
= FALSE
;
7751 dcb
.Parity
= NOPARITY
;
7752 dcb
.fErrorChar
= FALSE
;
7757 else if (EQ (tem
, Qeven
))
7761 dcb
.Parity
= EVENPARITY
;
7762 dcb
.fErrorChar
= TRUE
;
7764 else if (EQ (tem
, Qodd
))
7768 dcb
.Parity
= ODDPARITY
;
7769 dcb
.fErrorChar
= TRUE
;
7771 childp2
= Fplist_put (childp2
, QCparity
, tem
);
7773 /* Configure stopbits. */
7774 if (!NILP (Fplist_member (contact
, QCstopbits
)))
7775 tem
= Fplist_get (contact
, QCstopbits
);
7777 tem
= Fplist_get (p
->childp
, QCstopbits
);
7779 tem
= make_number (1);
7781 if (XINT (tem
) != 1 && XINT (tem
) != 2)
7782 error (":stopbits must be nil (1 stopbit), 1, or 2");
7783 summary
[2] = XINT (tem
) + '0';
7784 if (XINT (tem
) == 1)
7785 dcb
.StopBits
= ONESTOPBIT
;
7786 else if (XINT (tem
) == 2)
7787 dcb
.StopBits
= TWOSTOPBITS
;
7788 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
7790 /* Configure flowcontrol. */
7791 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
7792 tem
= Fplist_get (contact
, QCflowcontrol
);
7794 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
7795 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
7796 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
7797 dcb
.fOutxCtsFlow
= FALSE
;
7798 dcb
.fOutxDsrFlow
= FALSE
;
7799 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
7800 dcb
.fDsrSensitivity
= FALSE
;
7801 dcb
.fTXContinueOnXoff
= FALSE
;
7804 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
7805 dcb
.XonChar
= 17; /* Control-Q */
7806 dcb
.XoffChar
= 19; /* Control-S */
7809 /* Already configured. */
7811 else if (EQ (tem
, Qhw
))
7813 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
7814 dcb
.fOutxCtsFlow
= TRUE
;
7816 else if (EQ (tem
, Qsw
))
7821 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
7823 /* Activate configuration. */
7824 if (!SetCommState (hnd
, &dcb
))
7825 error ("SetCommState() failed");
7827 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
7828 pset_childp (p
, childp2
);
7834 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
7839 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7840 int fd
= process
->infd
;
7842 n
= sys_read (fd
, (char*)buf
, sz
);
7849 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7850 if (err
== EWOULDBLOCK
)
7853 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7859 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7861 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7862 int fd
= process
->outfd
;
7863 ssize_t n
= sys_write (fd
, buf
, sz
);
7865 /* 0 or more bytes written means everything went fine. */
7869 /* Negative bytes written means we got an error in errno.
7870 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7871 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7872 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7876 #endif /* HAVE_GNUTLS */