1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994-1995, 2000-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22 #include <stddef.h> /* for offsetof */
25 #include <float.h> /* for DBL_EPSILON */
33 #include <sys/utime.h>
37 /* must include CRT headers *before* config.h */
40 #include <mbstring.h> /* for _mbspbrk */
73 #define _ANONYMOUS_UNION
74 #define _ANONYMOUS_STRUCT
77 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
78 use a different name to avoid compilation problems. */
79 typedef struct _MEMORY_STATUS_EX
{
82 DWORDLONG ullTotalPhys
;
83 DWORDLONG ullAvailPhys
;
84 DWORDLONG ullTotalPageFile
;
85 DWORDLONG ullAvailPageFile
;
86 DWORDLONG ullTotalVirtual
;
87 DWORDLONG ullAvailVirtual
;
88 DWORDLONG ullAvailExtendedVirtual
;
89 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
99 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
100 /* This either is not in psapi.h or guarded by higher value of
101 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
102 defines it in psapi.h */
103 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
105 DWORD PageFaultCount
;
106 DWORD PeakWorkingSetSize
;
107 DWORD WorkingSetSize
;
108 DWORD QuotaPeakPagedPoolUsage
;
109 DWORD QuotaPagedPoolUsage
;
110 DWORD QuotaPeakNonPagedPoolUsage
;
111 DWORD QuotaNonPagedPoolUsage
;
113 DWORD PeakPagefileUsage
;
115 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
118 #include <winioctl.h>
122 /* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER, except
123 on ntifs.h, which cannot be included because it triggers conflicts
124 with other Windows API headers. So we define it here by hand. */
126 typedef struct _REPARSE_DATA_BUFFER
{
128 USHORT ReparseDataLength
;
132 USHORT SubstituteNameOffset
;
133 USHORT SubstituteNameLength
;
134 USHORT PrintNameOffset
;
135 USHORT PrintNameLength
;
138 } SymbolicLinkReparseBuffer
;
140 USHORT SubstituteNameOffset
;
141 USHORT SubstituteNameLength
;
142 USHORT PrintNameOffset
;
143 USHORT PrintNameLength
;
145 } MountPointReparseBuffer
;
148 } GenericReparseBuffer
;
150 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
154 /* TCP connection support. */
155 #include <sys/socket.h>
176 #include "w32common.h"
178 #include "w32select.h"
180 #include "dispextern.h" /* for xstrcasecmp */
181 #include "coding.h" /* for Vlocale_coding_system */
183 #include "careadlinkat.h"
184 #include "allocator.h"
186 /* For serial_configure and serial_open. */
189 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
190 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
192 Lisp_Object QCloaded_from
;
194 void globals_of_w32 (void);
195 static DWORD
get_rid (PSID
);
196 static int is_symlink (const char *);
197 static char * chase_symlinks (const char *);
198 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
199 static int restore_privilege (TOKEN_PRIVILEGES
*);
200 static BOOL WINAPI
revert_to_self (void);
202 extern int sys_access (const char *, int);
203 extern void *e_malloc (size_t);
204 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
205 EMACS_TIME
*, void *);
209 /* Initialization states.
211 WARNING: If you add any more such variables for additional APIs,
212 you MUST add initialization for them to globals_of_w32
213 below. This is because these variables might get set
214 to non-NULL values during dumping, but the dumped Emacs
215 cannot reuse those values, because it could be run on a
216 different version of the OS, where API addresses are
218 static BOOL g_b_init_is_windows_9x
;
219 static BOOL g_b_init_open_process_token
;
220 static BOOL g_b_init_get_token_information
;
221 static BOOL g_b_init_lookup_account_sid
;
222 static BOOL g_b_init_get_sid_sub_authority
;
223 static BOOL g_b_init_get_sid_sub_authority_count
;
224 static BOOL g_b_init_get_security_info
;
225 static BOOL g_b_init_get_file_security
;
226 static BOOL g_b_init_get_security_descriptor_owner
;
227 static BOOL g_b_init_get_security_descriptor_group
;
228 static BOOL g_b_init_is_valid_sid
;
229 static BOOL g_b_init_create_toolhelp32_snapshot
;
230 static BOOL g_b_init_process32_first
;
231 static BOOL g_b_init_process32_next
;
232 static BOOL g_b_init_open_thread_token
;
233 static BOOL g_b_init_impersonate_self
;
234 static BOOL g_b_init_revert_to_self
;
235 static BOOL g_b_init_get_process_memory_info
;
236 static BOOL g_b_init_get_process_working_set_size
;
237 static BOOL g_b_init_global_memory_status
;
238 static BOOL g_b_init_global_memory_status_ex
;
239 static BOOL g_b_init_get_length_sid
;
240 static BOOL g_b_init_equal_sid
;
241 static BOOL g_b_init_copy_sid
;
242 static BOOL g_b_init_get_native_system_info
;
243 static BOOL g_b_init_get_system_times
;
244 static BOOL g_b_init_create_symbolic_link
;
247 BEGIN: Wrapper functions around OpenProcessToken
248 and other functions in advapi32.dll that are only
249 supported in Windows NT / 2k / XP
251 /* ** Function pointer typedefs ** */
252 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
253 HANDLE ProcessHandle
,
255 PHANDLE TokenHandle
);
256 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
258 TOKEN_INFORMATION_CLASS TokenInformationClass
,
259 LPVOID TokenInformation
,
260 DWORD TokenInformationLength
,
261 PDWORD ReturnLength
);
262 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
263 HANDLE process_handle
,
264 LPFILETIME creation_time
,
265 LPFILETIME exit_time
,
266 LPFILETIME kernel_time
,
267 LPFILETIME user_time
);
269 GetProcessTimes_Proc get_process_times_fn
= NULL
;
272 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
273 const char * const GetFileSecurity_Name
= "GetFileSecurityW";
275 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
276 const char * const GetFileSecurity_Name
= "GetFileSecurityA";
278 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
279 LPCTSTR lpSystemName
,
284 LPDWORD cbDomainName
,
285 PSID_NAME_USE peUse
);
286 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
289 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
291 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
293 SE_OBJECT_TYPE ObjectType
,
294 SECURITY_INFORMATION SecurityInfo
,
299 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
300 typedef BOOL (WINAPI
* GetFileSecurity_Proc
) (
302 SECURITY_INFORMATION RequestedInformation
,
303 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
305 LPDWORD lpnLengthNeeded
);
306 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
307 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
309 LPBOOL lpbOwnerDefaulted
);
310 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
311 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
313 LPBOOL lpbGroupDefaulted
);
314 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
316 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
318 DWORD th32ProcessID
);
319 typedef BOOL (WINAPI
* Process32First_Proc
) (
321 LPPROCESSENTRY32 lppe
);
322 typedef BOOL (WINAPI
* Process32Next_Proc
) (
324 LPPROCESSENTRY32 lppe
);
325 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
329 PHANDLE TokenHandle
);
330 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
331 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
332 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
333 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
335 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
337 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
339 DWORD
* lpMinimumWorkingSetSize
,
340 DWORD
* lpMaximumWorkingSetSize
);
341 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
342 LPMEMORYSTATUS lpBuffer
);
343 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
344 LPMEMORY_STATUS_EX lpBuffer
);
345 typedef BOOL (WINAPI
* CopySid_Proc
) (
346 DWORD nDestinationSidLength
,
347 PSID pDestinationSid
,
349 typedef BOOL (WINAPI
* EqualSid_Proc
) (
352 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
354 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
355 LPSYSTEM_INFO lpSystemInfo
);
356 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
357 LPFILETIME lpIdleTime
,
358 LPFILETIME lpKernelTime
,
359 LPFILETIME lpUserTime
);
360 typedef BOOLEAN (WINAPI
*CreateSymbolicLink_Proc
) (
361 LPTSTR lpSymlinkFileName
,
362 LPTSTR lpTargetFileName
,
365 /* ** A utility function ** */
369 static BOOL s_b_ret
= 0;
370 OSVERSIONINFO os_ver
;
371 if (g_b_init_is_windows_9x
== 0)
373 g_b_init_is_windows_9x
= 1;
374 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
375 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
376 if (GetVersionEx (&os_ver
))
378 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
384 static Lisp_Object
ltime (ULONGLONG
);
386 /* Get total user and system times for get-internal-run-time.
387 Returns a list of integers if the times are provided by the OS
388 (NT derivatives), otherwise it returns the result of current-time. */
390 w32_get_internal_run_time (void)
392 if (get_process_times_fn
)
394 FILETIME create
, exit
, kernel
, user
;
395 HANDLE proc
= GetCurrentProcess ();
396 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
398 LARGE_INTEGER user_int
, kernel_int
, total
;
399 user_int
.LowPart
= user
.dwLowDateTime
;
400 user_int
.HighPart
= user
.dwHighDateTime
;
401 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
402 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
403 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
404 return ltime (total
.QuadPart
);
408 return Fcurrent_time ();
411 /* ** The wrapper functions ** */
414 open_process_token (HANDLE ProcessHandle
,
418 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
419 HMODULE hm_advapi32
= NULL
;
420 if (is_windows_9x () == TRUE
)
424 if (g_b_init_open_process_token
== 0)
426 g_b_init_open_process_token
= 1;
427 hm_advapi32
= LoadLibrary ("Advapi32.dll");
428 s_pfn_Open_Process_Token
=
429 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
431 if (s_pfn_Open_Process_Token
== NULL
)
436 s_pfn_Open_Process_Token (
444 get_token_information (HANDLE TokenHandle
,
445 TOKEN_INFORMATION_CLASS TokenInformationClass
,
446 LPVOID TokenInformation
,
447 DWORD TokenInformationLength
,
450 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
451 HMODULE hm_advapi32
= NULL
;
452 if (is_windows_9x () == TRUE
)
456 if (g_b_init_get_token_information
== 0)
458 g_b_init_get_token_information
= 1;
459 hm_advapi32
= LoadLibrary ("Advapi32.dll");
460 s_pfn_Get_Token_Information
=
461 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
463 if (s_pfn_Get_Token_Information
== NULL
)
468 s_pfn_Get_Token_Information (
470 TokenInformationClass
,
472 TokenInformationLength
,
478 lookup_account_sid (LPCTSTR lpSystemName
,
483 LPDWORD cbDomainName
,
486 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
487 HMODULE hm_advapi32
= NULL
;
488 if (is_windows_9x () == TRUE
)
492 if (g_b_init_lookup_account_sid
== 0)
494 g_b_init_lookup_account_sid
= 1;
495 hm_advapi32
= LoadLibrary ("Advapi32.dll");
496 s_pfn_Lookup_Account_Sid
=
497 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
499 if (s_pfn_Lookup_Account_Sid
== NULL
)
504 s_pfn_Lookup_Account_Sid (
516 get_sid_sub_authority (PSID pSid
, DWORD n
)
518 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
519 static DWORD zero
= 0U;
520 HMODULE hm_advapi32
= NULL
;
521 if (is_windows_9x () == TRUE
)
525 if (g_b_init_get_sid_sub_authority
== 0)
527 g_b_init_get_sid_sub_authority
= 1;
528 hm_advapi32
= LoadLibrary ("Advapi32.dll");
529 s_pfn_Get_Sid_Sub_Authority
=
530 (GetSidSubAuthority_Proc
) GetProcAddress (
531 hm_advapi32
, "GetSidSubAuthority");
533 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
537 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
541 get_sid_sub_authority_count (PSID pSid
)
543 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
544 static UCHAR zero
= 0U;
545 HMODULE hm_advapi32
= NULL
;
546 if (is_windows_9x () == TRUE
)
550 if (g_b_init_get_sid_sub_authority_count
== 0)
552 g_b_init_get_sid_sub_authority_count
= 1;
553 hm_advapi32
= LoadLibrary ("Advapi32.dll");
554 s_pfn_Get_Sid_Sub_Authority_Count
=
555 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
556 hm_advapi32
, "GetSidSubAuthorityCount");
558 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
562 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
566 get_security_info (HANDLE handle
,
567 SE_OBJECT_TYPE ObjectType
,
568 SECURITY_INFORMATION SecurityInfo
,
573 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
575 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
576 HMODULE hm_advapi32
= NULL
;
577 if (is_windows_9x () == TRUE
)
581 if (g_b_init_get_security_info
== 0)
583 g_b_init_get_security_info
= 1;
584 hm_advapi32
= LoadLibrary ("Advapi32.dll");
585 s_pfn_Get_Security_Info
=
586 (GetSecurityInfo_Proc
) GetProcAddress (
587 hm_advapi32
, "GetSecurityInfo");
589 if (s_pfn_Get_Security_Info
== NULL
)
593 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
594 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
595 ppSecurityDescriptor
));
599 get_file_security (LPCTSTR lpFileName
,
600 SECURITY_INFORMATION RequestedInformation
,
601 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
603 LPDWORD lpnLengthNeeded
)
605 static GetFileSecurity_Proc s_pfn_Get_File_Security
= NULL
;
606 HMODULE hm_advapi32
= NULL
;
607 if (is_windows_9x () == TRUE
)
611 if (g_b_init_get_file_security
== 0)
613 g_b_init_get_file_security
= 1;
614 hm_advapi32
= LoadLibrary ("Advapi32.dll");
615 s_pfn_Get_File_Security
=
616 (GetFileSecurity_Proc
) GetProcAddress (
617 hm_advapi32
, GetFileSecurity_Name
);
619 if (s_pfn_Get_File_Security
== NULL
)
623 return (s_pfn_Get_File_Security (lpFileName
, RequestedInformation
,
624 pSecurityDescriptor
, nLength
,
629 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
631 LPBOOL lpbOwnerDefaulted
)
633 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
634 HMODULE hm_advapi32
= NULL
;
635 if (is_windows_9x () == TRUE
)
639 if (g_b_init_get_security_descriptor_owner
== 0)
641 g_b_init_get_security_descriptor_owner
= 1;
642 hm_advapi32
= LoadLibrary ("Advapi32.dll");
643 s_pfn_Get_Security_Descriptor_Owner
=
644 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
645 hm_advapi32
, "GetSecurityDescriptorOwner");
647 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
651 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
656 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
658 LPBOOL lpbGroupDefaulted
)
660 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
661 HMODULE hm_advapi32
= NULL
;
662 if (is_windows_9x () == TRUE
)
666 if (g_b_init_get_security_descriptor_group
== 0)
668 g_b_init_get_security_descriptor_group
= 1;
669 hm_advapi32
= LoadLibrary ("Advapi32.dll");
670 s_pfn_Get_Security_Descriptor_Group
=
671 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
672 hm_advapi32
, "GetSecurityDescriptorGroup");
674 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
678 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
683 is_valid_sid (PSID sid
)
685 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
686 HMODULE hm_advapi32
= NULL
;
687 if (is_windows_9x () == TRUE
)
691 if (g_b_init_is_valid_sid
== 0)
693 g_b_init_is_valid_sid
= 1;
694 hm_advapi32
= LoadLibrary ("Advapi32.dll");
696 (IsValidSid_Proc
) GetProcAddress (
697 hm_advapi32
, "IsValidSid");
699 if (s_pfn_Is_Valid_Sid
== NULL
)
703 return (s_pfn_Is_Valid_Sid (sid
));
707 equal_sid (PSID sid1
, PSID sid2
)
709 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
710 HMODULE hm_advapi32
= NULL
;
711 if (is_windows_9x () == TRUE
)
715 if (g_b_init_equal_sid
== 0)
717 g_b_init_equal_sid
= 1;
718 hm_advapi32
= LoadLibrary ("Advapi32.dll");
720 (EqualSid_Proc
) GetProcAddress (
721 hm_advapi32
, "EqualSid");
723 if (s_pfn_Equal_Sid
== NULL
)
727 return (s_pfn_Equal_Sid (sid1
, sid2
));
731 get_length_sid (PSID sid
)
733 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
734 HMODULE hm_advapi32
= NULL
;
735 if (is_windows_9x () == TRUE
)
739 if (g_b_init_get_length_sid
== 0)
741 g_b_init_get_length_sid
= 1;
742 hm_advapi32
= LoadLibrary ("Advapi32.dll");
743 s_pfn_Get_Length_Sid
=
744 (GetLengthSid_Proc
) GetProcAddress (
745 hm_advapi32
, "GetLengthSid");
747 if (s_pfn_Get_Length_Sid
== NULL
)
751 return (s_pfn_Get_Length_Sid (sid
));
755 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
757 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
758 HMODULE hm_advapi32
= NULL
;
759 if (is_windows_9x () == TRUE
)
763 if (g_b_init_copy_sid
== 0)
765 g_b_init_copy_sid
= 1;
766 hm_advapi32
= LoadLibrary ("Advapi32.dll");
768 (CopySid_Proc
) GetProcAddress (
769 hm_advapi32
, "CopySid");
771 if (s_pfn_Copy_Sid
== NULL
)
775 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
779 END: Wrapper functions around OpenProcessToken
780 and other functions in advapi32.dll that are only
781 supported in Windows NT / 2k / XP
785 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
787 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
788 if (is_windows_9x () != TRUE
)
790 if (g_b_init_get_native_system_info
== 0)
792 g_b_init_get_native_system_info
= 1;
793 s_pfn_Get_Native_System_Info
=
794 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
795 "GetNativeSystemInfo");
797 if (s_pfn_Get_Native_System_Info
!= NULL
)
798 s_pfn_Get_Native_System_Info (lpSystemInfo
);
801 lpSystemInfo
->dwNumberOfProcessors
= -1;
805 get_system_times (LPFILETIME lpIdleTime
,
806 LPFILETIME lpKernelTime
,
807 LPFILETIME lpUserTime
)
809 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
810 if (is_windows_9x () == TRUE
)
814 if (g_b_init_get_system_times
== 0)
816 g_b_init_get_system_times
= 1;
817 s_pfn_Get_System_times
=
818 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
821 if (s_pfn_Get_System_times
== NULL
)
823 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
826 static BOOLEAN WINAPI
827 create_symbolic_link (LPTSTR lpSymlinkFilename
,
828 LPTSTR lpTargetFileName
,
831 static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link
= NULL
;
834 if (is_windows_9x () == TRUE
)
839 if (g_b_init_create_symbolic_link
== 0)
841 g_b_init_create_symbolic_link
= 1;
843 s_pfn_Create_Symbolic_Link
=
844 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
845 "CreateSymbolicLinkW");
847 s_pfn_Create_Symbolic_Link
=
848 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
849 "CreateSymbolicLinkA");
852 if (s_pfn_Create_Symbolic_Link
== NULL
)
858 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
860 /* If we were denied creation of the symlink, try again after
861 enabling the SeCreateSymbolicLinkPrivilege for our process. */
864 TOKEN_PRIVILEGES priv_current
;
866 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
, &priv_current
))
868 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
870 restore_privilege (&priv_current
);
878 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
879 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
881 This is called from alloc.c:valid_pointer_p. */
883 w32_valid_pointer_p (void *p
, int size
)
886 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
890 unsigned char *buf
= alloca (size
);
891 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
900 static char startup_dir
[MAXPATHLEN
];
902 /* Get the current working directory. */
907 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
911 /* Emacs doesn't actually change directory itself, it stays in the
912 same directory where it was started. */
913 strcpy (dir
, startup_dir
);
918 /* Emulate getloadavg. */
927 /* Number of processors on this machine. */
928 static unsigned num_of_processors
;
930 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
931 static struct load_sample samples
[16*60];
932 static int first_idx
= -1, last_idx
= -1;
933 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
938 int next_idx
= from
+ 1;
940 if (next_idx
>= max_idx
)
949 int prev_idx
= from
- 1;
952 prev_idx
= max_idx
- 1;
958 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
961 FILETIME ft_idle
, ft_user
, ft_kernel
;
963 /* Initialize the number of processors on this machine. */
964 if (num_of_processors
<= 0)
966 get_native_system_info (&sysinfo
);
967 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
968 if (num_of_processors
<= 0)
970 GetSystemInfo (&sysinfo
);
971 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
973 if (num_of_processors
<= 0)
974 num_of_processors
= 1;
977 /* TODO: Take into account threads that are ready to run, by
978 sampling the "\System\Processor Queue Length" performance
979 counter. The code below accounts only for threads that are
982 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
984 ULARGE_INTEGER uidle
, ukernel
, uuser
;
986 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
987 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
988 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
989 *idle
= uidle
.QuadPart
;
990 *kernel
= ukernel
.QuadPart
;
991 *user
= uuser
.QuadPart
;
1001 /* Produce the load average for a given time interval, using the
1002 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1003 1-minute, 5-minute, or 15-minute average, respectively. */
1007 double retval
= -1.0;
1010 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1011 time_t now
= samples
[last_idx
].sample_time
;
1013 if (first_idx
!= last_idx
)
1015 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1017 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1018 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1021 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1022 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1023 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1025 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1028 if (idx
== first_idx
)
1037 getloadavg (double loadavg
[], int nelem
)
1040 ULONGLONG idle
, kernel
, user
;
1041 time_t now
= time (NULL
);
1043 /* Store another sample. We ignore samples that are less than 1 sec
1045 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
1047 sample_system_load (&idle
, &kernel
, &user
);
1048 last_idx
= buf_next (last_idx
);
1049 samples
[last_idx
].sample_time
= now
;
1050 samples
[last_idx
].idle
= idle
;
1051 samples
[last_idx
].kernel
= kernel
;
1052 samples
[last_idx
].user
= user
;
1053 /* If the buffer has more that 15 min worth of samples, discard
1055 if (first_idx
== -1)
1056 first_idx
= last_idx
;
1057 while (first_idx
!= last_idx
1058 && (difftime (now
, samples
[first_idx
].sample_time
)
1059 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1060 first_idx
= buf_next (first_idx
);
1063 for (elem
= 0; elem
< nelem
; elem
++)
1065 double avg
= getavg (elem
);
1069 loadavg
[elem
] = avg
;
1075 /* Emulate getpwuid, getpwnam and others. */
1077 #define PASSWD_FIELD_SIZE 256
1079 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1080 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1081 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1082 static char dflt_passwd_dir
[PASSWD_FIELD_SIZE
];
1083 static char dflt_passwd_shell
[PASSWD_FIELD_SIZE
];
1085 static struct passwd dflt_passwd
=
1097 static char dflt_group_name
[GNLEN
+1];
1099 static struct group dflt_group
=
1101 /* When group information is not available, we return this as the
1102 group for all files. */
1110 return dflt_passwd
.pw_uid
;
1116 /* I could imagine arguing for checking to see whether the user is
1117 in the Administrators group and returning a UID of 0 for that
1118 case, but I don't know how wise that would be in the long run. */
1125 return dflt_passwd
.pw_gid
;
1135 getpwuid (unsigned uid
)
1137 if (uid
== dflt_passwd
.pw_uid
)
1138 return &dflt_passwd
;
1143 getgrgid (gid_t gid
)
1149 getpwnam (char *name
)
1153 pw
= getpwuid (getuid ());
1157 if (xstrcasecmp (name
, pw
->pw_name
))
1164 init_user_info (void)
1166 /* Find the user's real name by opening the process token and
1167 looking up the name associated with the user-sid in that token.
1169 Use the relative portion of the identifier authority value from
1170 the user-sid as the user id value (same for group id using the
1171 primary group sid from the process token). */
1173 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1174 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1175 DWORD glength
= sizeof (gname
);
1176 HANDLE token
= NULL
;
1177 SID_NAME_USE user_type
;
1178 unsigned char *buf
= NULL
;
1180 TOKEN_USER user_token
;
1181 TOKEN_PRIMARY_GROUP group_token
;
1184 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1187 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1188 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1190 buf
= xmalloc (blen
);
1191 result
= get_token_information (token
, TokenUser
,
1192 (LPVOID
)buf
, blen
, &needed
);
1195 memcpy (&user_token
, buf
, sizeof (user_token
));
1196 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1198 domain
, &dlength
, &user_type
);
1206 strcpy (dflt_passwd
.pw_name
, uname
);
1207 /* Determine a reasonable uid value. */
1208 if (xstrcasecmp ("administrator", uname
) == 0)
1210 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1211 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1215 /* Use the last sub-authority value of the RID, the relative
1216 portion of the SID, as user/group ID. */
1217 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1219 /* Get group id and name. */
1220 result
= get_token_information (token
, TokenPrimaryGroup
,
1221 (LPVOID
)buf
, blen
, &needed
);
1222 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1224 buf
= xrealloc (buf
, blen
= needed
);
1225 result
= get_token_information (token
, TokenPrimaryGroup
,
1226 (LPVOID
)buf
, blen
, &needed
);
1230 memcpy (&group_token
, buf
, sizeof (group_token
));
1231 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1232 dlength
= sizeof (domain
);
1233 /* If we can get at the real Primary Group name, use that.
1234 Otherwise, the default group name was already set to
1235 "None" in globals_of_w32. */
1236 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1237 gname
, &glength
, NULL
, &dlength
,
1239 strcpy (dflt_group_name
, gname
);
1242 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1245 /* If security calls are not supported (presumably because we
1246 are running under Windows 9X), fallback to this: */
1247 else if (GetUserName (uname
, &ulength
))
1249 strcpy (dflt_passwd
.pw_name
, uname
);
1250 if (xstrcasecmp ("administrator", uname
) == 0)
1251 dflt_passwd
.pw_uid
= 0;
1253 dflt_passwd
.pw_uid
= 123;
1254 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1258 strcpy (dflt_passwd
.pw_name
, "unknown");
1259 dflt_passwd
.pw_uid
= 123;
1260 dflt_passwd
.pw_gid
= 123;
1262 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1264 /* Ensure HOME and SHELL are defined. */
1265 if (getenv ("HOME") == NULL
)
1267 if (getenv ("SHELL") == NULL
)
1270 /* Set dir and shell from environment variables. */
1271 strcpy (dflt_passwd
.pw_dir
, getenv ("HOME"));
1272 strcpy (dflt_passwd
.pw_shell
, getenv ("SHELL"));
1276 CloseHandle (token
);
1282 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1283 return ((rand () << 15) | rand ());
1293 /* Normalize filename by converting all path separators to
1294 the specified separator. Also conditionally convert upper
1295 case path name components to lower case. */
1298 normalize_filename (register char *fp
, char path_sep
)
1303 /* Always lower-case drive letters a-z, even if the filesystem
1304 preserves case in filenames.
1305 This is so filenames can be compared by string comparison
1306 functions that are case-sensitive. Even case-preserving filesystems
1307 do not distinguish case in drive letters. */
1308 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
1314 if (NILP (Vw32_downcase_file_names
))
1318 if (*fp
== '/' || *fp
== '\\')
1325 sep
= path_sep
; /* convert to this path separator */
1326 elem
= fp
; /* start of current path element */
1329 if (*fp
>= 'a' && *fp
<= 'z')
1330 elem
= 0; /* don't convert this element */
1332 if (*fp
== 0 || *fp
== ':')
1334 sep
= *fp
; /* restore current separator (or 0) */
1335 *fp
= '/'; /* after conversion of this element */
1338 if (*fp
== '/' || *fp
== '\\')
1340 if (elem
&& elem
!= fp
)
1342 *fp
= 0; /* temporary end of string */
1343 _strlwr (elem
); /* while we convert to lower case */
1345 *fp
= sep
; /* convert (or restore) path separator */
1346 elem
= fp
+ 1; /* next element starts after separator */
1352 /* Destructively turn backslashes into slashes. */
1354 dostounix_filename (register char *p
)
1356 normalize_filename (p
, '/');
1359 /* Destructively turn slashes into backslashes. */
1361 unixtodos_filename (register char *p
)
1363 normalize_filename (p
, '\\');
1366 /* Remove all CR's that are followed by a LF.
1367 (From msdos.c...probably should figure out a way to share it,
1368 although this code isn't going to ever change.) */
1370 crlf_to_lf (register int n
, register unsigned char *buf
)
1372 unsigned char *np
= buf
;
1373 unsigned char *startp
= buf
;
1374 unsigned char *endp
= buf
+ n
;
1378 while (buf
< endp
- 1)
1382 if (*(++buf
) != 0x0a)
1393 /* Parse the root part of file name, if present. Return length and
1394 optionally store pointer to char after root. */
1396 parse_root (char * name
, char ** pPath
)
1398 char * start
= name
;
1403 /* find the root name of the volume if given */
1404 if (isalpha (name
[0]) && name
[1] == ':')
1406 /* skip past drive specifier */
1408 if (IS_DIRECTORY_SEP (name
[0]))
1411 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1417 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1422 if (IS_DIRECTORY_SEP (name
[0]))
1429 return name
- start
;
1432 /* Get long base name for name; name is assumed to be absolute. */
1434 get_long_basename (char * name
, char * buf
, int size
)
1436 WIN32_FIND_DATA find_data
;
1440 /* must be valid filename, no wild cards or other invalid characters */
1441 if (_mbspbrk (name
, "*?|<>\""))
1444 dir_handle
= FindFirstFile (name
, &find_data
);
1445 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1447 if ((len
= strlen (find_data
.cFileName
)) < size
)
1448 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1451 FindClose (dir_handle
);
1456 /* Get long name for file, if possible (assumed to be absolute). */
1458 w32_get_long_filename (char * name
, char * buf
, int size
)
1463 char full
[ MAX_PATH
];
1466 len
= strlen (name
);
1467 if (len
>= MAX_PATH
)
1470 /* Use local copy for destructive modification. */
1471 memcpy (full
, name
, len
+1);
1472 unixtodos_filename (full
);
1474 /* Copy root part verbatim. */
1475 len
= parse_root (full
, &p
);
1476 memcpy (o
, full
, len
);
1481 while (p
!= NULL
&& *p
)
1484 p
= strchr (q
, '\\');
1486 len
= get_long_basename (full
, o
, size
);
1509 is_unc_volume (const char *filename
)
1511 const char *ptr
= filename
;
1513 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1516 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1522 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1525 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1528 HKEY hrootkey
= NULL
;
1531 /* Check both the current user and the local machine to see if
1532 we have any resources. */
1534 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1538 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1539 && (lpvalue
= xmalloc (cbData
)) != NULL
1540 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1542 RegCloseKey (hrootkey
);
1548 RegCloseKey (hrootkey
);
1551 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1555 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1556 && (lpvalue
= xmalloc (cbData
)) != NULL
1557 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1559 RegCloseKey (hrootkey
);
1565 RegCloseKey (hrootkey
);
1571 char *get_emacs_configuration (void);
1574 init_environment (char ** argv
)
1576 static const char * const tempdirs
[] = {
1577 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1582 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1584 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1585 temporary files and assume "/tmp" if $TMPDIR is unset, which
1586 will break on DOS/Windows. Refuse to work if we cannot find
1587 a directory, not even "c:/", usable for that purpose. */
1588 for (i
= 0; i
< imax
; i
++)
1590 const char *tmp
= tempdirs
[i
];
1593 tmp
= getenv (tmp
+ 1);
1594 /* Note that `access' can lie to us if the directory resides on a
1595 read-only filesystem, like CD-ROM or a write-protected floppy.
1596 The only way to be really sure is to actually create a file and
1597 see if it succeeds. But I think that's too much to ask. */
1599 /* MSVCRT's _access crashes with D_OK. */
1600 if (tmp
&& faccessat (AT_FDCWD
, tmp
, D_OK
, AT_EACCESS
) == 0)
1602 char * var
= alloca (strlen (tmp
) + 8);
1603 sprintf (var
, "TMPDIR=%s", tmp
);
1604 _putenv (strdup (var
));
1611 Fcons (build_string ("no usable temporary directories found!!"),
1613 "While setting TMPDIR: ");
1615 /* Check for environment variables and use registry settings if they
1616 don't exist. Fallback on default values where applicable. */
1621 char locale_name
[32];
1622 char default_home
[MAX_PATH
];
1625 static const struct env_entry
1631 /* If the default value is NULL, we will use the value from the
1632 outside environment or the Registry, but will not push the
1633 variable into the Emacs environment if it is defined neither
1634 in the Registry nor in the outside environment. */
1636 {"PRELOAD_WINSOCK", NULL
},
1637 {"emacs_dir", "C:/emacs"},
1638 {"EMACSLOADPATH", NULL
},
1639 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1640 {"EMACSDATA", NULL
},
1641 {"EMACSPATH", NULL
},
1648 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1650 /* We need to copy dflt_envvars[] and work on the copy because we
1651 don't want the dumped Emacs to inherit the values of
1652 environment variables we saw during dumping (which could be on
1653 a different system). The defaults above must be left intact. */
1654 struct env_entry env_vars
[N_ENV_VARS
];
1656 for (i
= 0; i
< N_ENV_VARS
; i
++)
1657 env_vars
[i
] = dflt_envvars
[i
];
1659 /* For backwards compatibility, check if a .emacs file exists in C:/
1660 If not, then we can try to default to the appdata directory under the
1661 user's profile, which is more likely to be writable. */
1662 if (!check_existing ("C:/.emacs"))
1664 HRESULT profile_result
;
1665 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1666 of Windows 95 and NT4 that have not been updated to include
1668 ShGetFolderPath_fn get_folder_path
;
1669 get_folder_path
= (ShGetFolderPath_fn
)
1670 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1672 if (get_folder_path
!= NULL
)
1674 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1677 /* If we can't get the appdata dir, revert to old behavior. */
1678 if (profile_result
== S_OK
)
1680 env_vars
[0].def_value
= default_home
;
1686 /* Get default locale info and use it for LANG. */
1687 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1688 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1689 locale_name
, sizeof (locale_name
)))
1691 for (i
= 0; i
< N_ENV_VARS
; i
++)
1693 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1695 env_vars
[i
].def_value
= locale_name
;
1701 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1703 /* Treat emacs_dir specially: set it unconditionally based on our
1707 char modname
[MAX_PATH
];
1709 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1711 if ((p
= strrchr (modname
, '\\')) == NULL
)
1715 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
1717 char buf
[SET_ENV_BUF_SIZE
];
1720 for (p
= modname
; *p
; p
++)
1721 if (*p
== '\\') *p
= '/';
1723 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1724 _putenv (strdup (buf
));
1726 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1728 /* FIXME: should use substring of get_emacs_configuration ().
1729 But I don't think the Windows build supports alpha, mips etc
1730 anymore, so have taken the easy option for now. */
1731 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
1732 || xstrcasecmp (p
, "\\AMD64") == 0))
1735 p
= strrchr (modname
, '\\');
1739 p
= strrchr (modname
, '\\');
1740 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1742 char buf
[SET_ENV_BUF_SIZE
];
1745 for (p
= modname
; *p
; p
++)
1746 if (*p
== '\\') *p
= '/';
1748 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1749 _putenv (strdup (buf
));
1755 for (i
= 0; i
< N_ENV_VARS
; i
++)
1757 if (!getenv (env_vars
[i
].name
))
1761 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1762 /* Also ignore empty environment variables. */
1766 lpval
= env_vars
[i
].def_value
;
1767 dwType
= REG_EXPAND_SZ
;
1769 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
1770 Vdelayed_warnings_list
1771 = Fcons (listn (CONSTYPE_HEAP
, 2,
1772 intern ("initialization"),
1773 build_string ("Setting HOME to C:\\ by default is deprecated")),
1774 Vdelayed_warnings_list
);
1779 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1781 if (dwType
== REG_EXPAND_SZ
)
1782 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1783 else if (dwType
== REG_SZ
)
1784 strcpy (buf1
, lpval
);
1785 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1787 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1789 _putenv (strdup (buf2
));
1799 /* Rebuild system configuration to reflect invoking system. */
1800 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1802 /* Another special case: on NT, the PATH variable is actually named
1803 "Path" although cmd.exe (perhaps NT itself) arranges for
1804 environment variable lookup and setting to be case insensitive.
1805 However, Emacs assumes a fully case sensitive environment, so we
1806 need to change "Path" to "PATH" to match the expectations of
1807 various elisp packages. We do this by the sneaky method of
1808 modifying the string in the C runtime environ entry.
1810 The same applies to COMSPEC. */
1814 for (envp
= environ
; *envp
; envp
++)
1815 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1816 memcpy (*envp
, "PATH=", 5);
1817 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1818 memcpy (*envp
, "COMSPEC=", 8);
1821 /* Remember the initial working directory for getwd. */
1822 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
1823 Does it matter anywhere in Emacs? */
1824 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1828 static char modname
[MAX_PATH
];
1830 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1835 /* Determine if there is a middle mouse button, to allow parse_button
1836 to decide whether right mouse events should be mouse-2 or
1838 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1843 /* Called from expand-file-name when default-directory is not a string. */
1846 emacs_root_dir (void)
1848 static char root_dir
[FILENAME_MAX
];
1851 p
= getenv ("emacs_dir");
1854 strcpy (root_dir
, p
);
1855 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1856 dostounix_filename (root_dir
);
1860 /* We don't have scripts to automatically determine the system configuration
1861 for Emacs before it's compiled, and we don't want to have to make the
1862 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1866 get_emacs_configuration (void)
1868 char *arch
, *oem
, *os
;
1870 static char configuration_buffer
[32];
1872 /* Determine the processor type. */
1873 switch (get_processor_type ())
1876 #ifdef PROCESSOR_INTEL_386
1877 case PROCESSOR_INTEL_386
:
1878 case PROCESSOR_INTEL_486
:
1879 case PROCESSOR_INTEL_PENTIUM
:
1887 #ifdef PROCESSOR_AMD_X8664
1888 case PROCESSOR_AMD_X8664
:
1893 #ifdef PROCESSOR_MIPS_R2000
1894 case PROCESSOR_MIPS_R2000
:
1895 case PROCESSOR_MIPS_R3000
:
1896 case PROCESSOR_MIPS_R4000
:
1901 #ifdef PROCESSOR_ALPHA_21064
1902 case PROCESSOR_ALPHA_21064
:
1912 /* Use the OEM field to reflect the compiler/library combination. */
1914 #define COMPILER_NAME "msvc"
1917 #define COMPILER_NAME "mingw"
1919 #define COMPILER_NAME "unknown"
1922 oem
= COMPILER_NAME
;
1924 switch (osinfo_cache
.dwPlatformId
) {
1925 case VER_PLATFORM_WIN32_NT
:
1927 build_num
= osinfo_cache
.dwBuildNumber
;
1929 case VER_PLATFORM_WIN32_WINDOWS
:
1930 if (osinfo_cache
.dwMinorVersion
== 0) {
1935 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1937 case VER_PLATFORM_WIN32s
:
1938 /* Not supported, should not happen. */
1940 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1948 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1949 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1950 get_w32_major_version (), get_w32_minor_version (), build_num
);
1952 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1955 return configuration_buffer
;
1959 get_emacs_configuration_options (void)
1961 static char *options_buffer
;
1962 char cv
[32]; /* Enough for COMPILER_VERSION. */
1964 cv
, /* To be filled later. */
1968 #ifdef ENABLE_CHECKING
1969 " --enable-checking",
1971 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1972 with a starting space to save work here. */
1974 " --cflags", USER_CFLAGS
,
1977 " --ldflags", USER_LDFLAGS
,
1984 /* Work out the effective configure options for this build. */
1986 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1989 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1991 #define COMPILER_VERSION ""
1995 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
1996 return "Error: not enough space for compiler version";
1997 cv
[sizeof (cv
) - 1] = '\0';
1999 for (i
= 0; options
[i
]; i
++)
2000 size
+= strlen (options
[i
]);
2002 options_buffer
= xmalloc (size
+ 1);
2003 options_buffer
[0] = '\0';
2005 for (i
= 0; options
[i
]; i
++)
2006 strcat (options_buffer
, options
[i
]);
2008 return options_buffer
;
2012 #include <sys/timeb.h>
2014 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2016 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2021 tv
->tv_sec
= tb
.time
;
2022 tv
->tv_usec
= tb
.millitm
* 1000L;
2023 /* Implementation note: _ftime sometimes doesn't update the dstflag
2024 according to the new timezone when the system timezone is
2025 changed. We could fix that by using GetSystemTime and
2026 GetTimeZoneInformation, but that doesn't seem necessary, since
2027 Emacs always calls gettimeofday with the 2nd argument NULL (see
2028 current_emacs_time). */
2031 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2032 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2036 /* Emulate fdutimens. */
2038 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2039 TIMESPEC[0] and TIMESPEC[1], respectively.
2040 FD must be either negative -- in which case it is ignored --
2041 or a file descriptor that is open on FILE.
2042 If FD is nonnegative, then FILE can be NULL, which means
2043 use just futimes instead of utimes.
2044 If TIMESPEC is null, FAIL.
2045 Return 0 on success, -1 (setting errno) on failure. */
2048 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2057 if (fd
< 0 && !file
)
2062 ut
.actime
= timespec
[0].tv_sec
;
2063 ut
.modtime
= timespec
[1].tv_sec
;
2065 return _futime (fd
, &ut
);
2067 return _utime (file
, &ut
);
2071 /* ------------------------------------------------------------------------- */
2072 /* IO support and wrapper functions for the Windows API. */
2073 /* ------------------------------------------------------------------------- */
2075 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2076 on network directories, so we handle that case here.
2077 (Ulrich Leodolter, 1/11/95). */
2079 sys_ctime (const time_t *t
)
2081 char *str
= (char *) ctime (t
);
2082 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2085 /* Emulate sleep...we could have done this with a define, but that
2086 would necessitate including windows.h in the files that used it.
2087 This is much easier. */
2089 sys_sleep (int seconds
)
2091 Sleep (seconds
* 1000);
2094 /* Internal MSVC functions for low-level descriptor munging */
2095 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2096 extern int __cdecl
_free_osfhnd (int fd
);
2098 /* parallel array of private info on file handles */
2099 filedesc fd_info
[ MAXDESC
];
2101 typedef struct volume_info_data
{
2102 struct volume_info_data
* next
;
2104 /* time when info was obtained */
2107 /* actual volume info */
2116 /* Global referenced by various functions. */
2117 static volume_info_data volume_info
;
2119 /* Vector to indicate which drives are local and fixed (for which cached
2120 data never expires). */
2121 static BOOL fixed_drives
[26];
2123 /* Consider cached volume information to be stale if older than 10s,
2124 at least for non-local drives. Info for fixed drives is never stale. */
2125 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2126 #define VOLINFO_STILL_VALID( root_dir, info ) \
2127 ( ( isalpha (root_dir[0]) && \
2128 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2129 || GetTickCount () - info->timestamp < 10000 )
2131 /* Cache support functions. */
2133 /* Simple linked list with linear search is sufficient. */
2134 static volume_info_data
*volume_cache
= NULL
;
2136 static volume_info_data
*
2137 lookup_volume_info (char * root_dir
)
2139 volume_info_data
* info
;
2141 for (info
= volume_cache
; info
; info
= info
->next
)
2142 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2148 add_volume_info (char * root_dir
, volume_info_data
* info
)
2150 info
->root_dir
= xstrdup (root_dir
);
2151 info
->next
= volume_cache
;
2152 volume_cache
= info
;
2156 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2157 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2158 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2159 static volume_info_data
*
2160 GetCachedVolumeInformation (char * root_dir
)
2162 volume_info_data
* info
;
2163 char default_root
[ MAX_PATH
];
2165 /* NULL for root_dir means use root from current directory. */
2166 if (root_dir
== NULL
)
2168 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2170 parse_root (default_root
, &root_dir
);
2172 root_dir
= default_root
;
2175 /* Local fixed drives can be cached permanently. Removable drives
2176 cannot be cached permanently, since the volume name and serial
2177 number (if nothing else) can change. Remote drives should be
2178 treated as if they are removable, since there is no sure way to
2179 tell whether they are or not. Also, the UNC association of drive
2180 letters mapped to remote volumes can be changed at any time (even
2181 by other processes) without notice.
2183 As a compromise, so we can benefit from caching info for remote
2184 volumes, we use a simple expiry mechanism to invalidate cache
2185 entries that are more than ten seconds old. */
2188 /* No point doing this, because WNetGetConnection is even slower than
2189 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2190 GetDriveType is about the only call of this type which does not
2191 involve network access, and so is extremely quick). */
2193 /* Map drive letter to UNC if remote. */
2194 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2196 char remote_name
[ 256 ];
2197 char drive
[3] = { root_dir
[0], ':' };
2199 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2201 /* do something */ ;
2205 info
= lookup_volume_info (root_dir
);
2207 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2215 /* Info is not cached, or is stale. */
2216 if (!GetVolumeInformation (root_dir
,
2217 name
, sizeof (name
),
2221 type
, sizeof (type
)))
2224 /* Cache the volume information for future use, overwriting existing
2225 entry if present. */
2228 info
= xmalloc (sizeof (volume_info_data
));
2229 add_volume_info (root_dir
, info
);
2237 info
->name
= xstrdup (name
);
2238 info
->serialnum
= serialnum
;
2239 info
->maxcomp
= maxcomp
;
2240 info
->flags
= flags
;
2241 info
->type
= xstrdup (type
);
2242 info
->timestamp
= GetTickCount ();
2248 /* Get information on the volume where NAME is held; set path pointer to
2249 start of pathname in NAME (past UNC header\volume header if present),
2250 if pPath is non-NULL.
2252 Note: if NAME includes symlinks, the information is for the volume
2253 of the symlink, not of its target. That's because, even though
2254 GetVolumeInformation returns information about the symlink target
2255 of its argument, we only pass the root directory to
2256 GetVolumeInformation, not the full NAME. */
2258 get_volume_info (const char * name
, const char ** pPath
)
2260 char temp
[MAX_PATH
];
2261 char *rootname
= NULL
; /* default to current volume */
2262 volume_info_data
* info
;
2267 /* Find the root name of the volume if given. */
2268 if (isalpha (name
[0]) && name
[1] == ':')
2276 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2283 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2296 info
= GetCachedVolumeInformation (rootname
);
2299 /* Set global referenced by other functions. */
2300 volume_info
= *info
;
2306 /* Determine if volume is FAT format (ie. only supports short 8.3
2307 names); also set path pointer to start of pathname in name, if
2308 pPath is non-NULL. */
2310 is_fat_volume (const char * name
, const char ** pPath
)
2312 if (get_volume_info (name
, pPath
))
2313 return (volume_info
.maxcomp
== 12);
2317 /* Map filename to a valid 8.3 name if necessary.
2318 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2320 map_w32_filename (const char * name
, const char ** pPath
)
2322 static char shortname
[MAX_PATH
];
2323 char * str
= shortname
;
2326 const char * save_name
= name
;
2328 if (strlen (name
) >= MAX_PATH
)
2330 /* Return a filename which will cause callers to fail. */
2331 strcpy (shortname
, "?");
2335 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2337 register int left
= 8; /* maximum number of chars in part */
2338 register int extn
= 0; /* extension added? */
2339 register int dots
= 2; /* maximum number of dots allowed */
2342 *str
++ = *name
++; /* skip past UNC header */
2344 while ((c
= *name
++))
2351 *str
++ = (c
== ':' ? ':' : '\\');
2352 extn
= 0; /* reset extension flags */
2353 dots
= 2; /* max 2 dots */
2354 left
= 8; /* max length 8 for main part */
2359 /* Convert path components of the form .xxx to _xxx,
2360 but leave . and .. as they are. This allows .emacs
2361 to be read as _emacs, for example. */
2365 IS_DIRECTORY_SEP (*name
))
2380 extn
= 1; /* we've got an extension */
2381 left
= 3; /* 3 chars in extension */
2385 /* any embedded dots after the first are converted to _ */
2390 case '#': /* don't lose these, they're important */
2392 str
[-1] = c
; /* replace last character of part */
2397 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2399 dots
= 0; /* started a path component */
2408 strcpy (shortname
, name
);
2409 unixtodos_filename (shortname
);
2413 *pPath
= shortname
+ (path
- save_name
);
2419 is_exec (const char * name
)
2421 char * p
= strrchr (name
, '.');
2424 && (xstrcasecmp (p
, ".exe") == 0 ||
2425 xstrcasecmp (p
, ".com") == 0 ||
2426 xstrcasecmp (p
, ".bat") == 0 ||
2427 xstrcasecmp (p
, ".cmd") == 0));
2430 /* Emulate the Unix directory procedures opendir, closedir,
2431 and readdir. We can't use the procedures supplied in sysdep.c,
2432 so we provide them here. */
2434 struct direct dir_static
; /* simulated directory contents */
2435 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2436 static int dir_is_fat
;
2437 static char dir_pathname
[MAXPATHLEN
+1];
2438 static WIN32_FIND_DATA dir_find_data
;
2440 /* Support shares on a network resource as subdirectories of a read-only
2442 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2443 static HANDLE
open_unc_volume (const char *);
2444 static char *read_unc_volume (HANDLE
, char *, int);
2445 static void close_unc_volume (HANDLE
);
2448 opendir (char *filename
)
2452 /* Opening is done by FindFirstFile. However, a read is inherent to
2453 this operation, so we defer the open until read time. */
2455 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2457 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2460 /* Note: We don't support traversal of UNC volumes via symlinks.
2461 Doing so would mean punishing 99.99% of use cases by resolving
2462 all the possible symlinks in FILENAME, recursively. */
2463 if (is_unc_volume (filename
))
2465 wnet_enum_handle
= open_unc_volume (filename
);
2466 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2470 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2477 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2478 dir_pathname
[MAXPATHLEN
] = '\0';
2479 /* Note: We don't support symlinks to file names on FAT volumes.
2480 Doing so would mean punishing 99.99% of use cases by resolving
2481 all the possible symlinks in FILENAME, recursively. */
2482 dir_is_fat
= is_fat_volume (filename
, NULL
);
2488 closedir (DIR *dirp
)
2490 /* If we have a find-handle open, close it. */
2491 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2493 FindClose (dir_find_handle
);
2494 dir_find_handle
= INVALID_HANDLE_VALUE
;
2496 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2498 close_unc_volume (wnet_enum_handle
);
2499 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2501 xfree ((char *) dirp
);
2507 int downcase
= !NILP (Vw32_downcase_file_names
);
2509 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2511 if (!read_unc_volume (wnet_enum_handle
,
2512 dir_find_data
.cFileName
,
2516 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2517 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2519 char filename
[MAXNAMLEN
+ 3];
2522 strcpy (filename
, dir_pathname
);
2523 ln
= strlen (filename
) - 1;
2524 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2525 strcat (filename
, "\\");
2526 strcat (filename
, "*");
2528 /* Note: No need to resolve symlinks in FILENAME, because
2529 FindFirst opens the directory that is the target of a
2531 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2533 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2538 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2542 /* Emacs never uses this value, so don't bother making it match
2543 value returned by stat(). */
2544 dir_static
.d_ino
= 1;
2546 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2548 /* If the file name in cFileName[] includes `?' characters, it means
2549 the original file name used characters that cannot be represented
2550 by the current ANSI codepage. To avoid total lossage, retrieve
2551 the short 8+3 alias of the long file name. */
2552 if (_mbspbrk (dir_static
.d_name
, "?"))
2554 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2555 downcase
= 1; /* 8+3 aliases are returned in all caps */
2557 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2558 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
2559 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2561 /* If the file name in cFileName[] includes `?' characters, it means
2562 the original file name used characters that cannot be represented
2563 by the current ANSI codepage. To avoid total lossage, retrieve
2564 the short 8+3 alias of the long file name. */
2565 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2567 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2568 /* 8+3 aliases are returned in all caps, which could break
2569 various alists that look at filenames' extensions. */
2573 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2574 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2576 _strlwr (dir_static
.d_name
);
2580 for (p
= dir_static
.d_name
; *p
; p
++)
2581 if (*p
>= 'a' && *p
<= 'z')
2584 _strlwr (dir_static
.d_name
);
2591 open_unc_volume (const char *path
)
2597 nr
.dwScope
= RESOURCE_GLOBALNET
;
2598 nr
.dwType
= RESOURCETYPE_DISK
;
2599 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2600 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2601 nr
.lpLocalName
= NULL
;
2602 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2603 nr
.lpComment
= NULL
;
2604 nr
.lpProvider
= NULL
;
2606 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2607 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2609 if (result
== NO_ERROR
)
2612 return INVALID_HANDLE_VALUE
;
2616 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2620 DWORD bufsize
= 512;
2625 buffer
= alloca (bufsize
);
2626 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2627 if (result
!= NO_ERROR
)
2630 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2631 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2633 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2636 strncpy (readbuf
, ptr
, size
);
2641 close_unc_volume (HANDLE henum
)
2643 if (henum
!= INVALID_HANDLE_VALUE
)
2644 WNetCloseEnum (henum
);
2648 unc_volume_file_attributes (const char *path
)
2653 henum
= open_unc_volume (path
);
2654 if (henum
== INVALID_HANDLE_VALUE
)
2657 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2659 close_unc_volume (henum
);
2664 /* Ensure a network connection is authenticated. */
2666 logon_network_drive (const char *path
)
2668 NETRESOURCE resource
;
2669 char share
[MAX_PATH
];
2674 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2675 drvtype
= DRIVE_REMOTE
;
2676 else if (path
[0] == '\0' || path
[1] != ':')
2677 drvtype
= GetDriveType (NULL
);
2684 drvtype
= GetDriveType (drive
);
2687 /* Only logon to networked drives. */
2688 if (drvtype
!= DRIVE_REMOTE
)
2692 strncpy (share
, path
, MAX_PATH
);
2693 /* Truncate to just server and share name. */
2694 for (i
= 2; i
< MAX_PATH
; i
++)
2696 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2703 resource
.dwType
= RESOURCETYPE_DISK
;
2704 resource
.lpLocalName
= NULL
;
2705 resource
.lpRemoteName
= share
;
2706 resource
.lpProvider
= NULL
;
2708 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2711 /* Emulate faccessat(2). */
2713 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
2717 if (dirfd
!= AT_FDCWD
2718 && !(IS_DIRECTORY_SEP (path
[0])
2719 || IS_DEVICE_SEP (path
[1])))
2725 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
2726 newer versions blow up when passed D_OK. */
2727 path
= map_w32_filename (path
, NULL
);
2728 /* If the last element of PATH is a symlink, we need to resolve it
2729 to get the attributes of its target file. Note: any symlinks in
2730 PATH elements other than the last one are transparently resolved
2731 by GetFileAttributes below. */
2732 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
2733 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
2734 path
= chase_symlinks (path
);
2736 if ((attributes
= GetFileAttributes (path
)) == -1)
2738 DWORD w32err
= GetLastError ();
2742 case ERROR_INVALID_NAME
:
2743 case ERROR_BAD_PATHNAME
:
2744 if (is_unc_volume (path
))
2746 attributes
= unc_volume_file_attributes (path
);
2747 if (attributes
== -1)
2755 case ERROR_FILE_NOT_FOUND
:
2756 case ERROR_BAD_NETPATH
:
2765 if ((mode
& X_OK
) != 0
2766 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
2771 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2776 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2784 /* Shadow some MSVC runtime functions to map requests for long filenames
2785 to reasonable short names if necessary. This was originally added to
2786 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2790 sys_chdir (const char * path
)
2792 return _chdir (map_w32_filename (path
, NULL
));
2796 sys_chmod (const char * path
, int mode
)
2798 path
= chase_symlinks (map_w32_filename (path
, NULL
));
2799 return _chmod (path
, mode
);
2803 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2805 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2811 sys_creat (const char * path
, int mode
)
2813 return _creat (map_w32_filename (path
, NULL
), mode
);
2817 sys_fopen (const char * path
, const char * mode
)
2821 const char * mode_save
= mode
;
2823 /* Force all file handles to be non-inheritable. This is necessary to
2824 ensure child processes don't unwittingly inherit handles that might
2825 prevent future file access. */
2829 else if (mode
[0] == 'w' || mode
[0] == 'a')
2830 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2834 /* Only do simplistic option parsing. */
2838 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2841 else if (mode
[0] == 'b')
2846 else if (mode
[0] == 't')
2853 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2857 return _fdopen (fd
, mode_save
);
2860 /* This only works on NTFS volumes, but is useful to have. */
2862 sys_link (const char * old
, const char * new)
2866 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2868 if (old
== NULL
|| new == NULL
)
2874 strcpy (oldname
, map_w32_filename (old
, NULL
));
2875 strcpy (newname
, map_w32_filename (new, NULL
));
2877 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2878 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2879 if (fileh
!= INVALID_HANDLE_VALUE
)
2883 /* Confusingly, the "alternate" stream name field does not apply
2884 when restoring a hard link, and instead contains the actual
2885 stream data for the link (ie. the name of the link to create).
2886 The WIN32_STREAM_ID structure before the cStreamName field is
2887 the stream header, which is then immediately followed by the
2891 WIN32_STREAM_ID wid
;
2892 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2895 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2896 data
.wid
.cStreamName
, MAX_PATH
);
2899 LPVOID context
= NULL
;
2902 data
.wid
.dwStreamId
= BACKUP_LINK
;
2903 data
.wid
.dwStreamAttributes
= 0;
2904 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
2905 data
.wid
.Size
.HighPart
= 0;
2906 data
.wid
.dwStreamNameSize
= 0;
2908 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2909 offsetof (WIN32_STREAM_ID
, cStreamName
)
2910 + data
.wid
.Size
.LowPart
,
2911 &wbytes
, FALSE
, FALSE
, &context
)
2912 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2919 /* Should try mapping GetLastError to errno; for now just
2920 indicate a general error (eg. links not supported). */
2921 errno
= EINVAL
; // perhaps EMLINK?
2925 CloseHandle (fileh
);
2934 sys_mkdir (const char * path
)
2936 return _mkdir (map_w32_filename (path
, NULL
));
2939 /* Because of long name mapping issues, we need to implement this
2940 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2941 a unique name, instead of setting the input template to an empty
2944 Standard algorithm seems to be use pid or tid with a letter on the
2945 front (in place of the 6 X's) and cycle through the letters to find a
2946 unique name. We extend that to allow any reasonable character as the
2947 first of the 6 X's. */
2949 sys_mktemp (char * template)
2953 unsigned uid
= GetCurrentThreadId ();
2954 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2956 if (template == NULL
)
2958 p
= template + strlen (template);
2960 /* replace up to the last 5 X's with uid in decimal */
2961 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2963 p
[0] = '0' + uid
% 10;
2967 if (i
< 0 && p
[0] == 'X')
2972 int save_errno
= errno
;
2973 p
[0] = first_char
[i
];
2974 if (faccessat (AT_FDCWD
, template, F_OK
, AT_EACCESS
) < 0)
2980 while (++i
< sizeof (first_char
));
2983 /* Template is badly formed or else we can't generate a unique name,
2984 so return empty string */
2990 sys_open (const char * path
, int oflag
, int mode
)
2992 const char* mpath
= map_w32_filename (path
, NULL
);
2993 /* Try to open file without _O_CREAT, to be able to write to hidden
2994 and system files. Force all file handles to be
2996 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2999 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3003 sys_rename (const char * oldname
, const char * newname
)
3006 char temp
[MAX_PATH
];
3010 /* MoveFile on Windows 95 doesn't correctly change the short file name
3011 alias in a number of circumstances (it is not easy to predict when
3012 just by looking at oldname and newname, unfortunately). In these
3013 cases, renaming through a temporary name avoids the problem.
3015 A second problem on Windows 95 is that renaming through a temp name when
3016 newname is uppercase fails (the final long name ends up in
3017 lowercase, although the short alias might be uppercase) UNLESS the
3018 long temp name is not 8.3.
3020 So, on Windows 95 we always rename through a temp name, and we make sure
3021 the temp name has a long extension to ensure correct renaming. */
3023 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3025 /* volume_info is set indirectly by map_w32_filename. */
3026 oldname_dev
= volume_info
.serialnum
;
3028 if (os_subtype
== OS_9X
)
3034 oldname
= map_w32_filename (oldname
, NULL
);
3035 if ((o
= strrchr (oldname
, '\\')))
3038 o
= (char *) oldname
;
3040 if ((p
= strrchr (temp
, '\\')))
3047 /* Force temp name to require a manufactured 8.3 alias - this
3048 seems to make the second rename work properly. */
3049 sprintf (p
, "_.%s.%u", o
, i
);
3051 result
= rename (oldname
, temp
);
3053 /* This loop must surely terminate! */
3054 while (result
< 0 && errno
== EEXIST
);
3059 /* Emulate Unix behavior - newname is deleted if it already exists
3060 (at least if it is a file; don't do this for directories).
3062 Since we mustn't do this if we are just changing the case of the
3063 file name (we would end up deleting the file we are trying to
3064 rename!), we let rename detect if the destination file already
3065 exists - that way we avoid the possible pitfalls of trying to
3066 determine ourselves whether two names really refer to the same
3067 file, which is not always possible in the general case. (Consider
3068 all the permutations of shared or subst'd drives, etc.) */
3070 newname
= map_w32_filename (newname
, NULL
);
3072 /* volume_info is set indirectly by map_w32_filename. */
3073 newname_dev
= volume_info
.serialnum
;
3075 result
= rename (temp
, newname
);
3079 DWORD w32err
= GetLastError ();
3082 && newname_dev
!= oldname_dev
)
3084 /* The implementation of `rename' on Windows does not return
3085 errno = EXDEV when you are moving a directory to a
3086 different storage device (ex. logical disk). It returns
3087 EACCES instead. So here we handle such situations and
3091 if ((attributes
= GetFileAttributes (temp
)) != -1
3092 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3095 else if (errno
== EEXIST
)
3097 if (_chmod (newname
, 0666) != 0)
3099 if (_unlink (newname
) != 0)
3101 result
= rename (temp
, newname
);
3103 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3104 && is_symlink (temp
))
3106 /* This is Windows prohibiting the user from creating a
3107 symlink in another place, since that requires
3117 sys_rmdir (const char * path
)
3119 return _rmdir (map_w32_filename (path
, NULL
));
3123 sys_unlink (const char * path
)
3125 path
= map_w32_filename (path
, NULL
);
3127 /* On Unix, unlink works without write permission. */
3128 _chmod (path
, 0666);
3129 return _unlink (path
);
3132 static FILETIME utc_base_ft
;
3133 static ULONGLONG utc_base
; /* In 100ns units */
3134 static int init
= 0;
3136 #define FILETIME_TO_U64(result, ft) \
3138 ULARGE_INTEGER uiTemp; \
3139 uiTemp.LowPart = (ft).dwLowDateTime; \
3140 uiTemp.HighPart = (ft).dwHighDateTime; \
3141 result = uiTemp.QuadPart; \
3145 initialize_utc_base (void)
3147 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3156 st
.wMilliseconds
= 0;
3158 SystemTimeToFileTime (&st
, &utc_base_ft
);
3159 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3163 convert_time (FILETIME ft
)
3169 initialize_utc_base ();
3173 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3176 FILETIME_TO_U64 (tmp
, ft
);
3177 return (time_t) ((tmp
- utc_base
) / 10000000L);
3181 convert_from_time_t (time_t time
, FILETIME
* pft
)
3187 initialize_utc_base ();
3191 /* time in 100ns units since 1-Jan-1601 */
3192 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3193 pft
->dwHighDateTime
= tmp
.HighPart
;
3194 pft
->dwLowDateTime
= tmp
.LowPart
;
3198 /* No reason to keep this; faking inode values either by hashing or even
3199 using the file index from GetInformationByHandle, is not perfect and
3200 so by default Emacs doesn't use the inode values on Windows.
3201 Instead, we now determine file-truename correctly (except for
3202 possible drive aliasing etc). */
3204 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3206 hashval (const unsigned char * str
)
3211 h
= (h
<< 4) + *str
++;
3217 /* Return the hash value of the canonical pathname, excluding the
3218 drive/UNC header, to get a hopefully unique inode number. */
3220 generate_inode_val (const char * name
)
3222 char fullname
[ MAX_PATH
];
3226 /* Get the truly canonical filename, if it exists. (Note: this
3227 doesn't resolve aliasing due to subst commands, or recognize hard
3229 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3232 parse_root (fullname
, &p
);
3233 /* Normal W32 filesystems are still case insensitive. */
3240 static PSECURITY_DESCRIPTOR
3241 get_file_security_desc_by_handle (HANDLE h
)
3243 PSECURITY_DESCRIPTOR psd
= NULL
;
3245 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3246 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3248 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3249 NULL
, NULL
, NULL
, NULL
, &psd
);
3250 if (err
!= ERROR_SUCCESS
)
3256 static PSECURITY_DESCRIPTOR
3257 get_file_security_desc_by_name (const char *fname
)
3259 PSECURITY_DESCRIPTOR psd
= NULL
;
3261 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3262 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3264 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3266 err
= GetLastError ();
3267 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3271 psd
= xmalloc (sd_len
);
3272 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3284 unsigned n_subauthorities
;
3286 /* Use the last sub-authority value of the RID, the relative
3287 portion of the SID, as user/group ID. */
3288 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3289 if (n_subauthorities
< 1)
3290 return 0; /* the "World" RID */
3291 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3294 /* Caching SID and account values for faster lokup. */
3297 # define FLEXIBLE_ARRAY_MEMBER
3299 # define FLEXIBLE_ARRAY_MEMBER 1
3304 struct w32_id
*next
;
3306 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3309 static struct w32_id
*w32_idlist
;
3312 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3314 struct w32_id
*tail
, *found
;
3316 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3318 if (equal_sid ((PSID
)tail
->sid
, sid
))
3327 strcpy (name
, found
->name
);
3335 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3338 struct w32_id
*new_entry
;
3340 /* We don't want to leave behind stale cache from when Emacs was
3344 sid_len
= get_length_sid (sid
);
3345 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3348 new_entry
->rid
= id
;
3349 strcpy (new_entry
->name
, name
);
3350 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3351 new_entry
->next
= w32_idlist
;
3352 w32_idlist
= new_entry
;
3361 get_name_and_id (PSECURITY_DESCRIPTOR psd
, const char *fname
,
3362 unsigned *id
, char *nm
, int what
)
3365 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3367 SID_NAME_USE ignore
;
3369 DWORD name_len
= sizeof (name
);
3371 DWORD domain_len
= sizeof (domain
);
3377 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3378 else if (what
== GID
)
3379 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3383 if (!result
|| !is_valid_sid (sid
))
3385 else if (!w32_cached_id (sid
, id
, nm
))
3387 /* If FNAME is a UNC, we need to lookup account on the
3388 specified machine. */
3389 if (IS_DIRECTORY_SEP (fname
[0]) && IS_DIRECTORY_SEP (fname
[1])
3390 && fname
[2] != '\0')
3395 for (s
= fname
+ 2, p
= machine
;
3396 *s
&& !IS_DIRECTORY_SEP (*s
); s
++, p
++)
3402 if (!lookup_account_sid (mp
, sid
, name
, &name_len
,
3403 domain
, &domain_len
, &ignore
)
3404 || name_len
> UNLEN
+1)
3408 *id
= get_rid (sid
);
3410 w32_add_to_cache (sid
, *id
, name
);
3417 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
,
3421 int dflt_usr
= 0, dflt_grp
= 0;
3430 if (get_name_and_id (psd
, fname
, &st
->st_uid
, st
->st_uname
, UID
))
3432 if (get_name_and_id (psd
, fname
, &st
->st_gid
, st
->st_gname
, GID
))
3435 /* Consider files to belong to current user/group, if we cannot get
3436 more accurate information. */
3439 st
->st_uid
= dflt_passwd
.pw_uid
;
3440 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3444 st
->st_gid
= dflt_passwd
.pw_gid
;
3445 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3449 /* Return non-zero if NAME is a potentially slow filesystem. */
3451 is_slow_fs (const char *name
)
3456 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3457 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3458 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3459 devtype
= GetDriveType (NULL
); /* use root of current drive */
3462 /* GetDriveType needs the root directory of the drive. */
3463 strncpy (drive_root
, name
, 2);
3464 drive_root
[2] = '\\';
3465 drive_root
[3] = '\0';
3466 devtype
= GetDriveType (drive_root
);
3468 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3471 /* MSVC stat function can't cope with UNC names and has other bugs, so
3472 replace it with our own. This also allows us to calculate consistent
3473 inode values and owner/group without hacks in the main Emacs code. */
3476 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3478 char *name
, *save_name
, *r
;
3479 WIN32_FIND_DATA wfd
;
3481 unsigned __int64 fake_inode
= 0;
3484 int rootdir
= FALSE
;
3485 PSECURITY_DESCRIPTOR psd
= NULL
;
3486 int is_a_symlink
= 0;
3487 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3488 DWORD access_rights
= 0;
3489 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3490 FILETIME ctime
, atime
, wtime
;
3492 if (path
== NULL
|| buf
== NULL
)
3498 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3499 /* Must be valid filename, no wild cards or other invalid
3500 characters. We use _mbspbrk to support multibyte strings that
3501 might look to strpbrk as if they included literal *, ?, and other
3502 characters mentioned below that are disallowed by Windows
3504 if (_mbspbrk (name
, "*?|<>\""))
3510 /* Remove trailing directory separator, unless name is the root
3511 directory of a drive or UNC volume in which case ensure there
3512 is a trailing separator. */
3513 len
= strlen (name
);
3514 name
= strcpy (alloca (len
+ 2), name
);
3516 /* Avoid a somewhat costly call to is_symlink if the filesystem
3517 doesn't support symlinks. */
3518 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3519 is_a_symlink
= is_symlink (name
);
3521 /* Plan A: Open the file and get all the necessary information via
3522 the resulting handle. This solves several issues in one blow:
3524 . retrieves attributes for the target of a symlink, if needed
3525 . gets attributes of root directories and symlinks pointing to
3526 root directories, thus avoiding the need for special-casing
3527 these and detecting them by examining the file-name format
3528 . retrieves more accurate attributes (e.g., non-zero size for
3529 some directories, esp. directories that are junction points)
3530 . correctly resolves "c:/..", "/.." and similar file names
3531 . avoids run-time penalties for 99% of use cases
3533 Plan A is always tried first, unless the user asked not to (but
3534 if the file is a symlink and we need to follow links, we try Plan
3535 A even if the user asked not to).
3537 If Plan A fails, we go to Plan B (below), where various
3538 potentially expensive techniques must be used to handle "special"
3539 files such as UNC volumes etc. */
3540 if (!(NILP (Vw32_get_true_file_attributes
)
3541 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3542 /* Following symlinks requires getting the info by handle. */
3543 || (is_a_symlink
&& follow_symlinks
))
3545 BY_HANDLE_FILE_INFORMATION info
;
3547 if (is_a_symlink
&& !follow_symlinks
)
3548 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3549 /* READ_CONTROL access rights are required to get security info
3550 by handle. But if the OS doesn't support security in the
3551 first place, we don't need to try. */
3552 if (is_windows_9x () != TRUE
)
3553 access_rights
|= READ_CONTROL
;
3555 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3557 /* If CreateFile fails with READ_CONTROL, try again with zero as
3559 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3560 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3562 if (fh
== INVALID_HANDLE_VALUE
)
3563 goto no_true_file_attributes
;
3565 /* This is more accurate in terms of getting the correct number
3566 of links, but is quite slow (it is noticeable when Emacs is
3567 making a list of file name completions). */
3568 if (GetFileInformationByHandle (fh
, &info
))
3570 nlinks
= info
.nNumberOfLinks
;
3571 /* Might as well use file index to fake inode values, but this
3572 is not guaranteed to be unique unless we keep a handle open
3573 all the time (even then there are situations where it is
3574 not unique). Reputedly, there are at most 48 bits of info
3575 (on NTFS, presumably less on FAT). */
3576 fake_inode
= info
.nFileIndexHigh
;
3578 fake_inode
+= info
.nFileIndexLow
;
3579 serialnum
= info
.dwVolumeSerialNumber
;
3580 fs_high
= info
.nFileSizeHigh
;
3581 fs_low
= info
.nFileSizeLow
;
3582 ctime
= info
.ftCreationTime
;
3583 atime
= info
.ftLastAccessTime
;
3584 wtime
= info
.ftLastWriteTime
;
3585 fattrs
= info
.dwFileAttributes
;
3589 /* We don't go to Plan B here, because it's not clear that
3590 it's a good idea. The only known use case where
3591 CreateFile succeeds, but GetFileInformationByHandle fails
3592 (with ERROR_INVALID_FUNCTION) is for character devices
3593 such as NUL, PRN, etc. For these, switching to Plan B is
3594 a net loss, because we lose the character device
3595 attribute returned by GetFileType below (FindFirstFile
3596 doesn't set that bit in the attributes), and the other
3597 fields don't make sense for character devices anyway.
3598 Emacs doesn't really care for non-file entities in the
3599 context of l?stat, so neither do we. */
3601 /* w32err is assigned so one could put a breakpoint here and
3602 examine its value, when GetFileInformationByHandle
3604 DWORD w32err
= GetLastError ();
3608 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3614 /* Test for a symlink before testing for a directory, since
3615 symlinks to directories have the directory bit set, but we
3616 don't want them to appear as directories. */
3617 if (is_a_symlink
&& !follow_symlinks
)
3618 buf
->st_mode
= S_IFLNK
;
3619 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3620 buf
->st_mode
= S_IFDIR
;
3623 DWORD ftype
= GetFileType (fh
);
3627 case FILE_TYPE_DISK
:
3628 buf
->st_mode
= S_IFREG
;
3630 case FILE_TYPE_PIPE
:
3631 buf
->st_mode
= S_IFIFO
;
3633 case FILE_TYPE_CHAR
:
3634 case FILE_TYPE_UNKNOWN
:
3636 buf
->st_mode
= S_IFCHR
;
3639 /* We produce the fallback owner and group data, based on the
3640 current user that runs Emacs, in the following cases:
3642 . this is Windows 9X
3643 . getting security by handle failed, and we need to produce
3644 information for the target of a symlink (this is better
3645 than producing a potentially misleading info about the
3648 If getting security by handle fails, and we don't need to
3649 resolve symlinks, we try getting security by name. */
3650 if (is_windows_9x () != TRUE
)
3651 psd
= get_file_security_desc_by_handle (fh
);
3654 get_file_owner_and_group (psd
, name
, buf
);
3657 else if (is_windows_9x () == TRUE
)
3658 get_file_owner_and_group (NULL
, name
, buf
);
3659 else if (!(is_a_symlink
&& follow_symlinks
))
3661 psd
= get_file_security_desc_by_name (name
);
3662 get_file_owner_and_group (psd
, name
, buf
);
3666 get_file_owner_and_group (NULL
, name
, buf
);
3671 no_true_file_attributes
:
3672 /* Plan B: Either getting a handle on the file failed, or the
3673 caller explicitly asked us to not bother making this
3674 information more accurate.
3676 Implementation note: In Plan B, we never bother to resolve
3677 symlinks, even if we got here because we tried Plan A and
3678 failed. That's because, even if the caller asked for extra
3679 precision by setting Vw32_get_true_file_attributes to t,
3680 resolving symlinks requires acquiring a file handle to the
3681 symlink, which we already know will fail. And if the user
3682 did not ask for extra precision, resolving symlinks will fly
3683 in the face of that request, since the user then wants the
3684 lightweight version of the code. */
3685 rootdir
= (path
>= save_name
+ len
- 1
3686 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3688 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3689 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3690 if (IS_DIRECTORY_SEP (r
[0])
3691 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3694 /* Note: If NAME is a symlink to the root of a UNC volume
3695 (i.e. "\\SERVER"), we will not detect that here, and we will
3696 return data about the symlink as result of FindFirst below.
3697 This is unfortunate, but that marginal use case does not
3698 justify a call to chase_symlinks which would impose a penalty
3699 on all the other use cases. (We get here for symlinks to
3700 roots of UNC volumes because CreateFile above fails for them,
3701 unlike with symlinks to root directories X:\ of drives.) */
3702 if (is_unc_volume (name
))
3704 fattrs
= unc_volume_file_attributes (name
);
3708 ctime
= atime
= wtime
= utc_base_ft
;
3712 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3713 strcat (name
, "\\");
3714 if (GetDriveType (name
) < 2)
3720 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3721 ctime
= atime
= wtime
= utc_base_ft
;
3725 if (IS_DIRECTORY_SEP (name
[len
-1]))
3728 /* (This is hacky, but helps when doing file completions on
3729 network drives.) Optimize by using information available from
3730 active readdir if possible. */
3731 len
= strlen (dir_pathname
);
3732 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3734 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3735 && !(is_a_symlink
&& follow_symlinks
)
3736 && strnicmp (save_name
, dir_pathname
, len
) == 0
3737 && IS_DIRECTORY_SEP (name
[len
])
3738 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3740 /* This was the last entry returned by readdir. */
3741 wfd
= dir_find_data
;
3745 logon_network_drive (name
);
3747 fh
= FindFirstFile (name
, &wfd
);
3748 if (fh
== INVALID_HANDLE_VALUE
)
3755 /* Note: if NAME is a symlink, the information we get from
3756 FindFirstFile is for the symlink, not its target. */
3757 fattrs
= wfd
.dwFileAttributes
;
3758 ctime
= wfd
.ftCreationTime
;
3759 atime
= wfd
.ftLastAccessTime
;
3760 wtime
= wfd
.ftLastWriteTime
;
3761 fs_high
= wfd
.nFileSizeHigh
;
3762 fs_low
= wfd
.nFileSizeLow
;
3765 serialnum
= volume_info
.serialnum
;
3767 if (is_a_symlink
&& !follow_symlinks
)
3768 buf
->st_mode
= S_IFLNK
;
3769 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3770 buf
->st_mode
= S_IFDIR
;
3772 buf
->st_mode
= S_IFREG
;
3774 get_file_owner_and_group (NULL
, name
, buf
);
3778 /* Not sure if there is any point in this. */
3779 if (!NILP (Vw32_generate_fake_inodes
))
3780 fake_inode
= generate_inode_val (name
);
3781 else if (fake_inode
== 0)
3783 /* For want of something better, try to make everything unique. */
3784 static DWORD gen_num
= 0;
3785 fake_inode
= ++gen_num
;
3789 buf
->st_ino
= fake_inode
;
3791 buf
->st_dev
= serialnum
;
3792 buf
->st_rdev
= serialnum
;
3794 buf
->st_size
= fs_high
;
3795 buf
->st_size
<<= 32;
3796 buf
->st_size
+= fs_low
;
3797 buf
->st_nlink
= nlinks
;
3799 /* Convert timestamps to Unix format. */
3800 buf
->st_mtime
= convert_time (wtime
);
3801 buf
->st_atime
= convert_time (atime
);
3802 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3803 buf
->st_ctime
= convert_time (ctime
);
3804 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3806 /* determine rwx permissions */
3807 if (is_a_symlink
&& !follow_symlinks
)
3808 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
3811 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
3812 permission
= S_IREAD
;
3814 permission
= S_IREAD
| S_IWRITE
;
3816 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3817 permission
|= S_IEXEC
;
3818 else if (is_exec (name
))
3819 permission
|= S_IEXEC
;
3822 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3828 stat (const char * path
, struct stat
* buf
)
3830 return stat_worker (path
, buf
, 1);
3834 lstat (const char * path
, struct stat
* buf
)
3836 return stat_worker (path
, buf
, 0);
3839 /* Provide fstat and utime as well as stat for consistent handling of
3842 fstat (int desc
, struct stat
* buf
)
3844 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3845 BY_HANDLE_FILE_INFORMATION info
;
3846 unsigned __int64 fake_inode
;
3849 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3851 case FILE_TYPE_DISK
:
3852 buf
->st_mode
= S_IFREG
;
3853 if (!GetFileInformationByHandle (fh
, &info
))
3859 case FILE_TYPE_PIPE
:
3860 buf
->st_mode
= S_IFIFO
;
3862 case FILE_TYPE_CHAR
:
3863 case FILE_TYPE_UNKNOWN
:
3865 buf
->st_mode
= S_IFCHR
;
3867 memset (&info
, 0, sizeof (info
));
3868 info
.dwFileAttributes
= 0;
3869 info
.ftCreationTime
= utc_base_ft
;
3870 info
.ftLastAccessTime
= utc_base_ft
;
3871 info
.ftLastWriteTime
= utc_base_ft
;
3874 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3875 buf
->st_mode
= S_IFDIR
;
3877 buf
->st_nlink
= info
.nNumberOfLinks
;
3878 /* Might as well use file index to fake inode values, but this
3879 is not guaranteed to be unique unless we keep a handle open
3880 all the time (even then there are situations where it is
3881 not unique). Reputedly, there are at most 48 bits of info
3882 (on NTFS, presumably less on FAT). */
3883 fake_inode
= info
.nFileIndexHigh
;
3885 fake_inode
+= info
.nFileIndexLow
;
3887 /* MSVC defines _ino_t to be short; other libc's might not. */
3888 if (sizeof (buf
->st_ino
) == 2)
3889 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3891 buf
->st_ino
= fake_inode
;
3893 /* Consider files to belong to current user.
3894 FIXME: this should use GetSecurityInfo API, but it is only
3895 available for _WIN32_WINNT >= 0x501. */
3896 buf
->st_uid
= dflt_passwd
.pw_uid
;
3897 buf
->st_gid
= dflt_passwd
.pw_gid
;
3898 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3899 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3901 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3902 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3904 buf
->st_size
= info
.nFileSizeHigh
;
3905 buf
->st_size
<<= 32;
3906 buf
->st_size
+= info
.nFileSizeLow
;
3908 /* Convert timestamps to Unix format. */
3909 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3910 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3911 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3912 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3913 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3915 /* determine rwx permissions */
3916 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3917 permission
= S_IREAD
;
3919 permission
= S_IREAD
| S_IWRITE
;
3921 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3922 permission
|= S_IEXEC
;
3925 #if 0 /* no way of knowing the filename */
3926 char * p
= strrchr (name
, '.');
3928 (xstrcasecmp (p
, ".exe") == 0 ||
3929 xstrcasecmp (p
, ".com") == 0 ||
3930 xstrcasecmp (p
, ".bat") == 0 ||
3931 xstrcasecmp (p
, ".cmd") == 0))
3932 permission
|= S_IEXEC
;
3936 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3942 utime (const char *name
, struct utimbuf
*times
)
3944 struct utimbuf deftime
;
3951 deftime
.modtime
= deftime
.actime
= time (NULL
);
3955 /* Need write access to set times. */
3956 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
3957 /* If NAME specifies a directory, FILE_SHARE_DELETE
3958 allows other processes to delete files inside it,
3959 while we have the directory open. */
3960 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
3961 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3962 if (fh
!= INVALID_HANDLE_VALUE
)
3964 convert_from_time_t (times
->actime
, &atime
);
3965 convert_from_time_t (times
->modtime
, &mtime
);
3966 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
3983 /* Symlink-related functions. */
3984 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
3985 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
3989 symlink (char const *filename
, char const *linkname
)
3991 char linkfn
[MAX_PATH
], *tgtfn
;
3993 int dir_access
, filename_ends_in_slash
;
3995 /* Diagnostics follows Posix as much as possible. */
3996 if (filename
== NULL
|| linkname
== NULL
)
4006 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4008 errno
= ENAMETOOLONG
;
4012 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4013 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4019 /* Note: since empty FILENAME was already rejected, we can safely
4020 refer to FILENAME[1]. */
4021 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4023 /* Non-absolute FILENAME is understood as being relative to
4024 LINKNAME's directory. We need to prepend that directory to
4025 FILENAME to get correct results from faccessat below, since
4026 otherwise it will interpret FILENAME relative to the
4027 directory where the Emacs process runs. Note that
4028 make-symbolic-link always makes sure LINKNAME is a fully
4029 expanded file name. */
4031 char *p
= linkfn
+ strlen (linkfn
);
4033 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4036 strncpy (tem
, linkfn
, p
- linkfn
);
4037 tem
[p
- linkfn
] = '\0';
4038 strcat (tem
, filename
);
4039 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4042 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4044 /* Since Windows distinguishes between symlinks to directories and
4045 to files, we provide a kludgy feature: if FILENAME doesn't
4046 exist, but ends in a slash, we create a symlink to directory. If
4047 FILENAME exists and is a directory, we always create a symlink to
4049 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4050 if (dir_access
== 0 || filename_ends_in_slash
)
4051 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4053 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4054 if (filename_ends_in_slash
)
4055 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4058 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4060 /* ENOSYS is set by create_symbolic_link, when it detects that
4061 the OS doesn't support the CreateSymbolicLink API. */
4062 if (errno
!= ENOSYS
)
4064 DWORD w32err
= GetLastError ();
4068 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4069 TGTFN point to the same file name, go figure. */
4071 case ERROR_FILE_EXISTS
:
4074 case ERROR_ACCESS_DENIED
:
4077 case ERROR_FILE_NOT_FOUND
:
4078 case ERROR_PATH_NOT_FOUND
:
4079 case ERROR_BAD_NETPATH
:
4080 case ERROR_INVALID_REPARSE_DATA
:
4083 case ERROR_DIRECTORY
:
4086 case ERROR_PRIVILEGE_NOT_HELD
:
4087 case ERROR_NOT_ALL_ASSIGNED
:
4090 case ERROR_DISK_FULL
:
4103 /* A quick inexpensive test of whether FILENAME identifies a file that
4104 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4105 must already be in the normalized form returned by
4108 Note: for repeated operations on many files, it is best to test
4109 whether the underlying volume actually supports symlinks, by
4110 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4111 avoid the call to this function if it doesn't. That's because the
4112 call to GetFileAttributes takes a non-negligible time, especially
4113 on non-local or removable filesystems. See stat_worker for an
4114 example of how to do that. */
4116 is_symlink (const char *filename
)
4119 WIN32_FIND_DATA wfd
;
4122 attrs
= GetFileAttributes (filename
);
4125 DWORD w32err
= GetLastError ();
4129 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4131 case ERROR_ACCESS_DENIED
:
4134 case ERROR_FILE_NOT_FOUND
:
4135 case ERROR_PATH_NOT_FOUND
:
4142 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4144 logon_network_drive (filename
);
4145 fh
= FindFirstFile (filename
, &wfd
);
4146 if (fh
== INVALID_HANDLE_VALUE
)
4149 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4150 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4153 /* If NAME identifies a symbolic link, copy into BUF the file name of
4154 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4155 null-terminate the target name, even if it fits. Return the number
4156 of bytes copied, or -1 if NAME is not a symlink or any error was
4157 encountered while resolving it. The file name copied into BUF is
4158 encoded in the current ANSI codepage. */
4160 readlink (const char *name
, char *buf
, size_t buf_size
)
4163 TOKEN_PRIVILEGES privs
;
4164 int restore_privs
= 0;
4179 path
= map_w32_filename (name
, NULL
);
4181 if (strlen (path
) > MAX_PATH
)
4183 errno
= ENAMETOOLONG
;
4188 if (is_windows_9x () == TRUE
4189 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4190 || !is_symlink (path
))
4193 errno
= EINVAL
; /* not a symlink */
4197 /* Done with simple tests, now we're in for some _real_ work. */
4198 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4200 /* Implementation note: From here and onward, don't return early,
4201 since that will fail to restore the original set of privileges of
4202 the calling thread. */
4204 retval
= -1; /* not too optimistic, are we? */
4206 /* Note: In the next call to CreateFile, we use zero as the 2nd
4207 argument because, when the symlink is a hidden/system file,
4208 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4209 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4210 and directory symlinks. */
4211 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4212 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4214 if (sh
!= INVALID_HANDLE_VALUE
)
4216 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4217 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4220 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4221 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4224 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4228 /* Copy the link target name, in wide characters, fro
4229 reparse_data, then convert it to multibyte encoding in
4230 the current locale's codepage. */
4232 BYTE lname
[MAX_PATH
];
4235 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4237 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4238 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4240 /* According to MSDN, PrintNameLength does not include the
4241 terminating null character. */
4242 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4243 memcpy (lwname
, lwname_src
, lwname_len
);
4244 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4246 /* FIXME: Should we use the current file-name coding system
4247 instead of the fixed value of the ANSI codepage? */
4248 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4249 lname
, MAX_PATH
, NULL
, NULL
);
4252 /* WideCharToMultiByte failed. */
4253 DWORD w32err1
= GetLastError ();
4257 case ERROR_INSUFFICIENT_BUFFER
:
4258 errno
= ENAMETOOLONG
;
4260 case ERROR_INVALID_PARAMETER
:
4263 case ERROR_NO_UNICODE_TRANSLATION
:
4273 size_t size_to_copy
= buf_size
;
4275 BYTE
*pend
= p
+ lname_len
;
4277 /* Normalize like dostounix_filename does, but we don't
4278 want to assume that lname is null-terminated. */
4279 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4287 /* Testing for null-terminated LNAME is paranoia:
4288 WideCharToMultiByte should always return a
4289 null-terminated string when its 4th argument is -1
4290 and its 3rd argument is null-terminated (which they
4292 if (lname
[lname_len
- 1] == '\0')
4294 if (lname_len
<= buf_size
)
4295 size_to_copy
= lname_len
;
4296 strncpy (buf
, lname
, size_to_copy
);
4298 retval
= size_to_copy
;
4305 /* CreateFile failed. */
4306 DWORD w32err2
= GetLastError ();
4310 case ERROR_FILE_NOT_FOUND
:
4311 case ERROR_PATH_NOT_FOUND
:
4314 case ERROR_ACCESS_DENIED
:
4315 case ERROR_TOO_MANY_OPEN_FILES
:
4325 restore_privilege (&privs
);
4332 /* If FILE is a symlink, return its target (stored in a static
4333 buffer); otherwise return FILE.
4335 This function repeatedly resolves symlinks in the last component of
4336 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4337 until it arrives at a file whose last component is not a symlink,
4338 or some error occurs. It returns the target of the last
4339 successfully resolved symlink in the chain. If it succeeds to
4340 resolve even a single symlink, the value returned is an absolute
4341 file name with backslashes (result of GetFullPathName). By
4342 contrast, if the original FILE is returned, it is unaltered.
4344 Note: This function can set errno even if it succeeds.
4346 Implementation note: we only resolve the last portion ("basename")
4347 of the argument FILE and of each following file in the chain,
4348 disregarding any possible symlinks in its leading directories.
4349 This is because Windows system calls and library functions
4350 transparently resolve symlinks in leading directories and return
4351 correct information, as long as the basename is not a symlink. */
4353 chase_symlinks (const char *file
)
4355 static char target
[MAX_PATH
];
4356 char link
[MAX_PATH
];
4357 ssize_t res
, link_len
;
4360 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4361 return (char *)file
;
4363 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4364 return (char *)file
;
4369 /* Remove trailing slashes, as we want to resolve the last
4370 non-trivial part of the link name. */
4371 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4372 link
[link_len
--] = '\0';
4374 res
= readlink (link
, target
, MAX_PATH
);
4378 if (!(IS_DEVICE_SEP (target
[1])
4379 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4381 /* Target is relative. Append it to the directory part of
4382 the symlink, then copy the result back to target. */
4383 char *p
= link
+ link_len
;
4385 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4388 strcpy (target
, link
);
4390 /* Resolve any "." and ".." to get a fully-qualified file name
4392 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4394 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4396 if (loop_count
> 100)
4399 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4400 return (char *)file
;
4404 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4405 have a fixed max size for file names, so we don't need the kind of
4406 alloc/malloc/realloc dance the gnulib version does. We also don't
4407 support FD-relative symlinks. */
4409 careadlinkat (int fd
, char const *filename
,
4410 char *buffer
, size_t buffer_size
,
4411 struct allocator
const *alloc
,
4412 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4414 char linkname
[MAX_PATH
];
4423 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4427 char *retval
= buffer
;
4429 linkname
[link_size
++] = '\0';
4430 if (link_size
> buffer_size
)
4431 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4433 memcpy (retval
, linkname
, link_size
);
4441 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4445 return readlink (filename
, buffer
, buffer_size
);
4449 /* Support for browsing other processes and their attributes. See
4450 process.c for the Lisp bindings. */
4452 /* Helper wrapper functions. */
4454 static HANDLE WINAPI
4455 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4457 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4459 if (g_b_init_create_toolhelp32_snapshot
== 0)
4461 g_b_init_create_toolhelp32_snapshot
= 1;
4462 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4463 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4464 "CreateToolhelp32Snapshot");
4466 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4468 return INVALID_HANDLE_VALUE
;
4470 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4474 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4476 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4478 if (g_b_init_process32_first
== 0)
4480 g_b_init_process32_first
= 1;
4481 s_pfn_Process32_First
= (Process32First_Proc
)
4482 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4485 if (s_pfn_Process32_First
== NULL
)
4489 return (s_pfn_Process32_First (hSnapshot
, lppe
));
4493 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4495 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
4497 if (g_b_init_process32_next
== 0)
4499 g_b_init_process32_next
= 1;
4500 s_pfn_Process32_Next
= (Process32Next_Proc
)
4501 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4504 if (s_pfn_Process32_Next
== NULL
)
4508 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
4512 open_thread_token (HANDLE ThreadHandle
,
4513 DWORD DesiredAccess
,
4515 PHANDLE TokenHandle
)
4517 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
4518 HMODULE hm_advapi32
= NULL
;
4519 if (is_windows_9x () == TRUE
)
4521 SetLastError (ERROR_NOT_SUPPORTED
);
4524 if (g_b_init_open_thread_token
== 0)
4526 g_b_init_open_thread_token
= 1;
4527 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4528 s_pfn_Open_Thread_Token
=
4529 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
4531 if (s_pfn_Open_Thread_Token
== NULL
)
4533 SetLastError (ERROR_NOT_SUPPORTED
);
4537 s_pfn_Open_Thread_Token (
4546 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
4548 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
4549 HMODULE hm_advapi32
= NULL
;
4550 if (is_windows_9x () == TRUE
)
4554 if (g_b_init_impersonate_self
== 0)
4556 g_b_init_impersonate_self
= 1;
4557 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4558 s_pfn_Impersonate_Self
=
4559 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
4561 if (s_pfn_Impersonate_Self
== NULL
)
4565 return s_pfn_Impersonate_Self (ImpersonationLevel
);
4569 revert_to_self (void)
4571 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
4572 HMODULE hm_advapi32
= NULL
;
4573 if (is_windows_9x () == TRUE
)
4577 if (g_b_init_revert_to_self
== 0)
4579 g_b_init_revert_to_self
= 1;
4580 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4581 s_pfn_Revert_To_Self
=
4582 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
4584 if (s_pfn_Revert_To_Self
== NULL
)
4588 return s_pfn_Revert_To_Self ();
4592 get_process_memory_info (HANDLE h_proc
,
4593 PPROCESS_MEMORY_COUNTERS mem_counters
,
4596 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
4597 HMODULE hm_psapi
= NULL
;
4598 if (is_windows_9x () == TRUE
)
4602 if (g_b_init_get_process_memory_info
== 0)
4604 g_b_init_get_process_memory_info
= 1;
4605 hm_psapi
= LoadLibrary ("Psapi.dll");
4607 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
4608 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
4610 if (s_pfn_Get_Process_Memory_Info
== NULL
)
4614 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
4618 get_process_working_set_size (HANDLE h_proc
,
4622 static GetProcessWorkingSetSize_Proc
4623 s_pfn_Get_Process_Working_Set_Size
= NULL
;
4625 if (is_windows_9x () == TRUE
)
4629 if (g_b_init_get_process_working_set_size
== 0)
4631 g_b_init_get_process_working_set_size
= 1;
4632 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
4633 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4634 "GetProcessWorkingSetSize");
4636 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
4640 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
4644 global_memory_status (MEMORYSTATUS
*buf
)
4646 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
4648 if (is_windows_9x () == TRUE
)
4652 if (g_b_init_global_memory_status
== 0)
4654 g_b_init_global_memory_status
= 1;
4655 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
4656 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4657 "GlobalMemoryStatus");
4659 if (s_pfn_Global_Memory_Status
== NULL
)
4663 return s_pfn_Global_Memory_Status (buf
);
4667 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
4669 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
4671 if (is_windows_9x () == TRUE
)
4675 if (g_b_init_global_memory_status_ex
== 0)
4677 g_b_init_global_memory_status_ex
= 1;
4678 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
4679 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4680 "GlobalMemoryStatusEx");
4682 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
4686 return s_pfn_Global_Memory_Status_Ex (buf
);
4690 list_system_processes (void)
4692 struct gcpro gcpro1
;
4693 Lisp_Object proclist
= Qnil
;
4696 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4698 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4700 PROCESSENTRY32 proc_entry
;
4706 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
4707 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
4708 res
= process32_next (h_snapshot
, &proc_entry
))
4710 proc_id
= proc_entry
.th32ProcessID
;
4711 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
4714 CloseHandle (h_snapshot
);
4716 proclist
= Fnreverse (proclist
);
4723 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
4725 TOKEN_PRIVILEGES priv
;
4726 DWORD priv_size
= sizeof (priv
);
4727 DWORD opriv_size
= sizeof (*old_priv
);
4728 HANDLE h_token
= NULL
;
4729 HANDLE h_thread
= GetCurrentThread ();
4733 res
= open_thread_token (h_thread
,
4734 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4736 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
4738 if (impersonate_self (SecurityImpersonation
))
4739 res
= open_thread_token (h_thread
,
4740 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4745 priv
.PrivilegeCount
= 1;
4746 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
4747 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
4748 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
4749 old_priv
, &opriv_size
)
4750 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4754 CloseHandle (h_token
);
4760 restore_privilege (TOKEN_PRIVILEGES
*priv
)
4762 DWORD priv_size
= sizeof (*priv
);
4763 HANDLE h_token
= NULL
;
4766 if (open_thread_token (GetCurrentThread (),
4767 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4770 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
4771 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4775 CloseHandle (h_token
);
4781 ltime (ULONGLONG time_100ns
)
4783 ULONGLONG time_sec
= time_100ns
/ 10000000;
4784 int subsec
= time_100ns
% 10000000;
4785 return list4 (make_number (time_sec
>> 16),
4786 make_number (time_sec
& 0xffff),
4787 make_number (subsec
/ 10),
4788 make_number (subsec
% 10 * 100000));
4791 #define U64_TO_LISP_TIME(time) ltime (time)
4794 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
4795 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
4798 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
4799 ULONGLONG tem1
, tem2
, tem3
, tem
;
4802 || !get_process_times_fn
4803 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
4804 &ft_kernel
, &ft_user
))
4807 GetSystemTimeAsFileTime (&ft_current
);
4809 FILETIME_TO_U64 (tem1
, ft_kernel
);
4810 *stime
= U64_TO_LISP_TIME (tem1
);
4812 FILETIME_TO_U64 (tem2
, ft_user
);
4813 *utime
= U64_TO_LISP_TIME (tem2
);
4816 *ttime
= U64_TO_LISP_TIME (tem3
);
4818 FILETIME_TO_U64 (tem
, ft_creation
);
4819 /* Process no 4 (System) returns zero creation time. */
4822 *ctime
= U64_TO_LISP_TIME (tem
);
4826 FILETIME_TO_U64 (tem3
, ft_current
);
4827 tem
= (tem3
- utc_base
) - tem
;
4829 *etime
= U64_TO_LISP_TIME (tem
);
4833 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4844 system_process_attributes (Lisp_Object pid
)
4846 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4847 Lisp_Object attrs
= Qnil
;
4848 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4849 HANDLE h_snapshot
, h_proc
;
4852 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4853 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4854 DWORD glength
= sizeof (gname
);
4855 HANDLE token
= NULL
;
4856 SID_NAME_USE user_type
;
4857 unsigned char *buf
= NULL
;
4859 TOKEN_USER user_token
;
4860 TOKEN_PRIMARY_GROUP group_token
;
4863 PROCESS_MEMORY_COUNTERS mem
;
4864 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4865 DWORD minrss
, maxrss
;
4867 MEMORY_STATUS_EX memstex
;
4868 double totphys
= 0.0;
4869 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4871 BOOL result
= FALSE
;
4873 CHECK_NUMBER_OR_FLOAT (pid
);
4874 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4876 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4878 GCPRO3 (attrs
, decoded_cmd
, tem
);
4880 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4885 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4886 for (res
= process32_first (h_snapshot
, &pe
); res
;
4887 res
= process32_next (h_snapshot
, &pe
))
4889 if (proc_id
== pe
.th32ProcessID
)
4892 decoded_cmd
= build_string ("Idle");
4895 /* Decode the command name from locale-specific
4897 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4898 strlen (pe
.szExeFile
));
4900 code_convert_string_norecord (cmd_str
,
4901 Vlocale_coding_system
, 0);
4903 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4904 attrs
= Fcons (Fcons (Qppid
,
4905 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4907 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4909 attrs
= Fcons (Fcons (Qthcount
,
4910 make_fixnum_or_float (pe
.cntThreads
)),
4917 CloseHandle (h_snapshot
);
4926 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4928 /* If we were denied a handle to the process, try again after
4929 enabling the SeDebugPrivilege in our process. */
4932 TOKEN_PRIVILEGES priv_current
;
4934 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4936 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4938 restore_privilege (&priv_current
);
4944 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4947 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4948 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4950 buf
= xmalloc (blen
);
4951 result
= get_token_information (token
, TokenUser
,
4952 (LPVOID
)buf
, blen
, &needed
);
4955 memcpy (&user_token
, buf
, sizeof (user_token
));
4956 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4958 euid
= get_rid (user_token
.User
.Sid
);
4959 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4964 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4967 strcpy (uname
, "unknown");
4971 ulength
= strlen (uname
);
4977 /* Determine a reasonable euid and gid values. */
4978 if (xstrcasecmp ("administrator", uname
) == 0)
4980 euid
= 500; /* well-known Administrator uid */
4981 egid
= 513; /* well-known None gid */
4985 /* Get group id and name. */
4986 result
= get_token_information (token
, TokenPrimaryGroup
,
4987 (LPVOID
)buf
, blen
, &needed
);
4988 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4990 buf
= xrealloc (buf
, blen
= needed
);
4991 result
= get_token_information (token
, TokenPrimaryGroup
,
4992 (LPVOID
)buf
, blen
, &needed
);
4996 memcpy (&group_token
, buf
, sizeof (group_token
));
4997 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
4999 egid
= get_rid (group_token
.PrimaryGroup
);
5000 dlength
= sizeof (domain
);
5002 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5003 gname
, &glength
, NULL
, &dlength
,
5006 w32_add_to_cache (group_token
.PrimaryGroup
,
5010 strcpy (gname
, "None");
5014 glength
= strlen (gname
);
5022 if (!is_windows_9x ())
5024 /* We couldn't open the process token, presumably because of
5025 insufficient access rights. Assume this process is run
5027 strcpy (uname
, "SYSTEM");
5028 strcpy (gname
, "None");
5029 euid
= 18; /* SYSTEM */
5030 egid
= 513; /* None */
5031 glength
= strlen (gname
);
5032 ulength
= strlen (uname
);
5034 /* If we are running under Windows 9X, where security calls are
5035 not supported, we assume all processes are run by the current
5037 else if (GetUserName (uname
, &ulength
))
5039 if (xstrcasecmp ("administrator", uname
) == 0)
5044 strcpy (gname
, "None");
5045 glength
= strlen (gname
);
5046 ulength
= strlen (uname
);
5052 strcpy (uname
, "administrator");
5053 ulength
= strlen (uname
);
5054 strcpy (gname
, "None");
5055 glength
= strlen (gname
);
5058 CloseHandle (token
);
5061 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5062 tem
= make_unibyte_string (uname
, ulength
);
5063 attrs
= Fcons (Fcons (Quser
,
5064 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5066 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5067 tem
= make_unibyte_string (gname
, glength
);
5068 attrs
= Fcons (Fcons (Qgroup
,
5069 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5072 if (global_memory_status_ex (&memstex
))
5073 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5074 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5076 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5077 double, so we need to do this for it... */
5079 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5080 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5081 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5083 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5085 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5086 else if (global_memory_status (&memst
))
5087 totphys
= memst
.dwTotalPhys
/ 1024.0;
5090 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5093 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5095 attrs
= Fcons (Fcons (Qmajflt
,
5096 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5098 attrs
= Fcons (Fcons (Qvsize
,
5099 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5101 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5103 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5106 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5108 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5110 attrs
= Fcons (Fcons (Qmajflt
,
5111 make_fixnum_or_float (mem
.PageFaultCount
)),
5113 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5115 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5118 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5120 DWORD rss
= maxrss
/ 1024;
5122 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5124 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5127 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5129 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5130 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5131 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5132 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5133 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5134 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5137 /* FIXME: Retrieve command line by walking the PEB of the process. */
5140 CloseHandle (h_proc
);
5146 /* Wrappers for winsock functions to map between our file descriptors
5147 and winsock's handles; also set h_errno for convenience.
5149 To allow Emacs to run on systems which don't have winsock support
5150 installed, we dynamically link to winsock on startup if present, and
5151 otherwise provide the minimum necessary functionality
5152 (eg. gethostname). */
5154 /* function pointers for relevant socket functions */
5155 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5156 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5157 int (PASCAL
*pfn_WSAGetLastError
) (void);
5158 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5159 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5160 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5161 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5162 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5163 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5164 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5165 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5166 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5167 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5168 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5169 int (PASCAL
*pfn_WSACleanup
) (void);
5171 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5172 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5173 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5174 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5175 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5176 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5177 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5178 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5179 const char * optval
, int optlen
);
5180 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5181 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5183 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5184 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5185 struct sockaddr
* from
, int * fromlen
);
5186 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5187 const struct sockaddr
* to
, int tolen
);
5189 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5190 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5191 #ifndef HANDLE_FLAG_INHERIT
5192 #define HANDLE_FLAG_INHERIT 1
5196 static int winsock_inuse
;
5201 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5203 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5204 after WSAStartup returns successfully, but it seems reasonable
5205 to allow unloading winsock anyway in that case. */
5206 if (pfn_WSACleanup () == 0 ||
5207 pfn_WSAGetLastError () == WSAENETDOWN
)
5209 if (FreeLibrary (winsock_lib
))
5218 init_winsock (int load_now
)
5220 WSADATA winsockData
;
5222 if (winsock_lib
!= NULL
)
5225 pfn_SetHandleInformation
5226 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5227 "SetHandleInformation");
5229 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5231 if (winsock_lib
!= NULL
)
5233 /* dynamically link to socket functions */
5235 #define LOAD_PROC(fn) \
5236 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5239 LOAD_PROC (WSAStartup
);
5240 LOAD_PROC (WSASetLastError
);
5241 LOAD_PROC (WSAGetLastError
);
5242 LOAD_PROC (WSAEventSelect
);
5243 LOAD_PROC (WSACreateEvent
);
5244 LOAD_PROC (WSACloseEvent
);
5247 LOAD_PROC (connect
);
5248 LOAD_PROC (ioctlsocket
);
5251 LOAD_PROC (closesocket
);
5252 LOAD_PROC (shutdown
);
5255 LOAD_PROC (inet_addr
);
5256 LOAD_PROC (gethostname
);
5257 LOAD_PROC (gethostbyname
);
5258 LOAD_PROC (getservbyname
);
5259 LOAD_PROC (getpeername
);
5260 LOAD_PROC (WSACleanup
);
5261 LOAD_PROC (setsockopt
);
5263 LOAD_PROC (getsockname
);
5265 LOAD_PROC (recvfrom
);
5269 /* specify version 1.1 of winsock */
5270 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5272 if (winsockData
.wVersion
!= 0x101)
5277 /* Report that winsock exists and is usable, but leave
5278 socket functions disabled. I am assuming that calling
5279 WSAStartup does not require any network interaction,
5280 and in particular does not cause or require a dial-up
5281 connection to be established. */
5284 FreeLibrary (winsock_lib
);
5292 FreeLibrary (winsock_lib
);
5302 /* function to set h_errno for compatibility; map winsock error codes to
5303 normal system codes where they overlap (non-overlapping definitions
5304 are already in <sys/socket.h> */
5308 if (winsock_lib
== NULL
)
5311 h_errno
= pfn_WSAGetLastError ();
5315 case WSAEACCES
: h_errno
= EACCES
; break;
5316 case WSAEBADF
: h_errno
= EBADF
; break;
5317 case WSAEFAULT
: h_errno
= EFAULT
; break;
5318 case WSAEINTR
: h_errno
= EINTR
; break;
5319 case WSAEINVAL
: h_errno
= EINVAL
; break;
5320 case WSAEMFILE
: h_errno
= EMFILE
; break;
5321 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5322 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5330 if (h_errno
== 0 && winsock_lib
!= NULL
)
5331 pfn_WSASetLastError (0);
5334 /* Extend strerror to handle the winsock-specific error codes. */
5338 } _wsa_errlist
[] = {
5339 {WSAEINTR
, "Interrupted function call"},
5340 {WSAEBADF
, "Bad file descriptor"},
5341 {WSAEACCES
, "Permission denied"},
5342 {WSAEFAULT
, "Bad address"},
5343 {WSAEINVAL
, "Invalid argument"},
5344 {WSAEMFILE
, "Too many open files"},
5346 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5347 {WSAEINPROGRESS
, "Operation now in progress"},
5348 {WSAEALREADY
, "Operation already in progress"},
5349 {WSAENOTSOCK
, "Socket operation on non-socket"},
5350 {WSAEDESTADDRREQ
, "Destination address required"},
5351 {WSAEMSGSIZE
, "Message too long"},
5352 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5353 {WSAENOPROTOOPT
, "Bad protocol option"},
5354 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5355 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5356 {WSAEOPNOTSUPP
, "Operation not supported"},
5357 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5358 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5359 {WSAEADDRINUSE
, "Address already in use"},
5360 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5361 {WSAENETDOWN
, "Network is down"},
5362 {WSAENETUNREACH
, "Network is unreachable"},
5363 {WSAENETRESET
, "Network dropped connection on reset"},
5364 {WSAECONNABORTED
, "Software caused connection abort"},
5365 {WSAECONNRESET
, "Connection reset by peer"},
5366 {WSAENOBUFS
, "No buffer space available"},
5367 {WSAEISCONN
, "Socket is already connected"},
5368 {WSAENOTCONN
, "Socket is not connected"},
5369 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5370 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5371 {WSAETIMEDOUT
, "Connection timed out"},
5372 {WSAECONNREFUSED
, "Connection refused"},
5373 {WSAELOOP
, "Network loop"}, /* not sure */
5374 {WSAENAMETOOLONG
, "Name is too long"},
5375 {WSAEHOSTDOWN
, "Host is down"},
5376 {WSAEHOSTUNREACH
, "No route to host"},
5377 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5378 {WSAEPROCLIM
, "Too many processes"},
5379 {WSAEUSERS
, "Too many users"}, /* not sure */
5380 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5381 {WSAESTALE
, "Data is stale"}, /* not sure */
5382 {WSAEREMOTE
, "Remote error"}, /* not sure */
5384 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5385 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5386 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5387 {WSAEDISCON
, "Graceful shutdown in progress"},
5389 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5390 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5391 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5392 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5393 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5394 {WSASYSCALLFAILURE
, "System call failure"},
5395 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5396 {WSATYPE_NOT_FOUND
, "Class type not found"},
5397 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5398 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5399 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5402 {WSAHOST_NOT_FOUND
, "Host not found"},
5403 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5404 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5405 {WSANO_DATA
, "Valid name, no data record of requested type"},
5411 sys_strerror (int error_no
)
5414 static char unknown_msg
[40];
5416 if (error_no
>= 0 && error_no
< sys_nerr
)
5417 return sys_errlist
[error_no
];
5419 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5420 if (_wsa_errlist
[i
].errnum
== error_no
)
5421 return _wsa_errlist
[i
].msg
;
5423 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5427 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5428 but I believe the method of keeping the socket handle separate (and
5429 insuring it is not inheritable) is the correct one. */
5431 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5433 static int socket_to_fd (SOCKET s
);
5436 sys_socket (int af
, int type
, int protocol
)
5440 if (winsock_lib
== NULL
)
5443 return INVALID_SOCKET
;
5448 /* call the real socket function */
5449 s
= pfn_socket (af
, type
, protocol
);
5451 if (s
!= INVALID_SOCKET
)
5452 return socket_to_fd (s
);
5458 /* Convert a SOCKET to a file descriptor. */
5460 socket_to_fd (SOCKET s
)
5465 /* Although under NT 3.5 _open_osfhandle will accept a socket
5466 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5467 that does not work under NT 3.1. However, we can get the same
5468 effect by using a backdoor function to replace an existing
5469 descriptor handle with the one we want. */
5471 /* allocate a file descriptor (with appropriate flags) */
5472 fd
= _open ("NUL:", _O_RDWR
);
5475 /* Make a non-inheritable copy of the socket handle. Note
5476 that it is possible that sockets aren't actually kernel
5477 handles, which appears to be the case on Windows 9x when
5478 the MS Proxy winsock client is installed. */
5480 /* Apparently there is a bug in NT 3.51 with some service
5481 packs, which prevents using DuplicateHandle to make a
5482 socket handle non-inheritable (causes WSACleanup to
5483 hang). The work-around is to use SetHandleInformation
5484 instead if it is available and implemented. */
5485 if (pfn_SetHandleInformation
)
5487 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5491 HANDLE parent
= GetCurrentProcess ();
5492 HANDLE new_s
= INVALID_HANDLE_VALUE
;
5494 if (DuplicateHandle (parent
,
5500 DUPLICATE_SAME_ACCESS
))
5502 /* It is possible that DuplicateHandle succeeds even
5503 though the socket wasn't really a kernel handle,
5504 because a real handle has the same value. So
5505 test whether the new handle really is a socket. */
5506 long nonblocking
= 0;
5507 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
5509 pfn_closesocket (s
);
5514 CloseHandle (new_s
);
5519 fd_info
[fd
].hnd
= (HANDLE
) s
;
5521 /* set our own internal flags */
5522 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
5528 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5530 /* attach child_process to fd_info */
5531 if (fd_info
[ fd
].cp
!= NULL
)
5533 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
5537 fd_info
[ fd
].cp
= cp
;
5540 winsock_inuse
++; /* count open sockets */
5547 pfn_closesocket (s
);
5553 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
5555 if (winsock_lib
== NULL
)
5558 return SOCKET_ERROR
;
5562 if (fd_info
[s
].flags
& FILE_SOCKET
)
5564 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
5565 if (rc
== SOCKET_ERROR
)
5570 return SOCKET_ERROR
;
5574 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
5576 if (winsock_lib
== NULL
)
5579 return SOCKET_ERROR
;
5583 if (fd_info
[s
].flags
& FILE_SOCKET
)
5585 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
5586 if (rc
== SOCKET_ERROR
)
5591 return SOCKET_ERROR
;
5595 sys_htons (u_short hostshort
)
5597 return (winsock_lib
!= NULL
) ?
5598 pfn_htons (hostshort
) : hostshort
;
5602 sys_ntohs (u_short netshort
)
5604 return (winsock_lib
!= NULL
) ?
5605 pfn_ntohs (netshort
) : netshort
;
5609 sys_inet_addr (const char * cp
)
5611 return (winsock_lib
!= NULL
) ?
5612 pfn_inet_addr (cp
) : INADDR_NONE
;
5616 sys_gethostname (char * name
, int namelen
)
5618 if (winsock_lib
!= NULL
)
5619 return pfn_gethostname (name
, namelen
);
5621 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
5622 return !GetComputerName (name
, (DWORD
*)&namelen
);
5625 return SOCKET_ERROR
;
5629 sys_gethostbyname (const char * name
)
5631 struct hostent
* host
;
5633 if (winsock_lib
== NULL
)
5640 host
= pfn_gethostbyname (name
);
5647 sys_getservbyname (const char * name
, const char * proto
)
5649 struct servent
* serv
;
5651 if (winsock_lib
== NULL
)
5658 serv
= pfn_getservbyname (name
, proto
);
5665 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
5667 if (winsock_lib
== NULL
)
5670 return SOCKET_ERROR
;
5674 if (fd_info
[s
].flags
& FILE_SOCKET
)
5676 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
5677 if (rc
== SOCKET_ERROR
)
5682 return SOCKET_ERROR
;
5686 sys_shutdown (int s
, int how
)
5688 if (winsock_lib
== NULL
)
5691 return SOCKET_ERROR
;
5695 if (fd_info
[s
].flags
& FILE_SOCKET
)
5697 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
5698 if (rc
== SOCKET_ERROR
)
5703 return SOCKET_ERROR
;
5707 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
5709 if (winsock_lib
== NULL
)
5712 return SOCKET_ERROR
;
5716 if (fd_info
[s
].flags
& FILE_SOCKET
)
5718 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
5719 (const char *)optval
, optlen
);
5720 if (rc
== SOCKET_ERROR
)
5725 return SOCKET_ERROR
;
5729 sys_listen (int s
, int backlog
)
5731 if (winsock_lib
== NULL
)
5734 return SOCKET_ERROR
;
5738 if (fd_info
[s
].flags
& FILE_SOCKET
)
5740 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
5741 if (rc
== SOCKET_ERROR
)
5744 fd_info
[s
].flags
|= FILE_LISTEN
;
5748 return SOCKET_ERROR
;
5752 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
5754 if (winsock_lib
== NULL
)
5757 return SOCKET_ERROR
;
5761 if (fd_info
[s
].flags
& FILE_SOCKET
)
5763 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
5764 if (rc
== SOCKET_ERROR
)
5769 return SOCKET_ERROR
;
5773 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
5775 if (winsock_lib
== NULL
)
5782 if (fd_info
[s
].flags
& FILE_LISTEN
)
5784 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
5786 if (t
== INVALID_SOCKET
)
5789 fd
= socket_to_fd (t
);
5791 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5792 ResetEvent (fd_info
[s
].cp
->char_avail
);
5800 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
5801 struct sockaddr
* from
, int * fromlen
)
5803 if (winsock_lib
== NULL
)
5806 return SOCKET_ERROR
;
5810 if (fd_info
[s
].flags
& FILE_SOCKET
)
5812 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
5813 if (rc
== SOCKET_ERROR
)
5818 return SOCKET_ERROR
;
5822 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5823 const struct sockaddr
* to
, int tolen
)
5825 if (winsock_lib
== NULL
)
5828 return SOCKET_ERROR
;
5832 if (fd_info
[s
].flags
& FILE_SOCKET
)
5834 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5835 if (rc
== SOCKET_ERROR
)
5840 return SOCKET_ERROR
;
5843 /* Windows does not have an fcntl function. Provide an implementation
5844 solely for making sockets non-blocking. */
5846 fcntl (int s
, int cmd
, int options
)
5848 if (winsock_lib
== NULL
)
5855 if (fd_info
[s
].flags
& FILE_SOCKET
)
5857 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
5859 unsigned long nblock
= 1;
5860 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5861 if (rc
== SOCKET_ERROR
)
5863 /* Keep track of the fact that we set this to non-blocking. */
5864 fd_info
[s
].flags
|= FILE_NDELAY
;
5870 return SOCKET_ERROR
;
5874 return SOCKET_ERROR
;
5878 /* Shadow main io functions: we need to handle pipes and sockets more
5879 intelligently, and implement non-blocking mode as well. */
5892 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5894 child_process
* cp
= fd_info
[fd
].cp
;
5896 fd_info
[fd
].cp
= NULL
;
5898 if (CHILD_ACTIVE (cp
))
5900 /* if last descriptor to active child_process then cleanup */
5902 for (i
= 0; i
< MAXDESC
; i
++)
5906 if (fd_info
[i
].cp
== cp
)
5911 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5913 if (winsock_lib
== NULL
) emacs_abort ();
5915 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5916 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5918 winsock_inuse
--; /* count open sockets */
5925 /* Note that sockets do not need special treatment here (at least on
5926 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5927 closesocket is equivalent to CloseHandle, which is to be expected
5928 because socket handles are fully fledged kernel handles. */
5931 if (rc
== 0 && fd
< MAXDESC
)
5932 fd_info
[fd
].flags
= 0;
5943 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5945 /* duplicate our internal info as well */
5946 fd_info
[new_fd
] = fd_info
[fd
];
5952 sys_dup2 (int src
, int dst
)
5956 if (dst
< 0 || dst
>= MAXDESC
)
5962 /* make sure we close the destination first if it's a pipe or socket */
5963 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5966 rc
= _dup2 (src
, dst
);
5969 /* duplicate our internal info as well */
5970 fd_info
[dst
] = fd_info
[src
];
5975 /* Unix pipe() has only one arg */
5977 sys_pipe (int * phandles
)
5982 /* make pipe handles non-inheritable; when we spawn a child, we
5983 replace the relevant handle with an inheritable one. Also put
5984 pipes into binary mode; we will do text mode translation ourselves
5986 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
5990 /* Protect against overflow, since Windows can open more handles than
5991 our fd_info array has room for. */
5992 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
5994 _close (phandles
[0]);
5995 _close (phandles
[1]);
6000 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6001 fd_info
[phandles
[0]].flags
= flags
;
6003 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6004 fd_info
[phandles
[1]].flags
= flags
;
6011 /* Function to do blocking read of one byte, needed to implement
6012 select. It is only allowed on sockets and pipes. */
6014 _sys_read_ahead (int fd
)
6019 if (fd
< 0 || fd
>= MAXDESC
)
6020 return STATUS_READ_ERROR
;
6022 cp
= fd_info
[fd
].cp
;
6024 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6025 return STATUS_READ_ERROR
;
6027 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6028 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6030 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6034 cp
->status
= STATUS_READ_IN_PROGRESS
;
6036 if (fd_info
[fd
].flags
& FILE_PIPE
)
6038 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6040 /* Give subprocess time to buffer some more output for us before
6041 reporting that input is available; we need this because Windows 95
6042 connects DOS programs to pipes by making the pipe appear to be
6043 the normal console stdout - as a result most DOS programs will
6044 write to stdout without buffering, ie. one character at a
6045 time. Even some W32 programs do this - "dir" in a command
6046 shell on NT is very slow if we don't do this. */
6049 int wait
= w32_pipe_read_delay
;
6055 /* Yield remainder of our time slice, effectively giving a
6056 temporary priority boost to the child process. */
6060 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6062 HANDLE hnd
= fd_info
[fd
].hnd
;
6063 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6066 /* Configure timeouts for blocking read. */
6067 if (!GetCommTimeouts (hnd
, &ct
))
6068 return STATUS_READ_ERROR
;
6069 ct
.ReadIntervalTimeout
= 0;
6070 ct
.ReadTotalTimeoutMultiplier
= 0;
6071 ct
.ReadTotalTimeoutConstant
= 0;
6072 if (!SetCommTimeouts (hnd
, &ct
))
6073 return STATUS_READ_ERROR
;
6075 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6077 if (GetLastError () != ERROR_IO_PENDING
)
6078 return STATUS_READ_ERROR
;
6079 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6080 return STATUS_READ_ERROR
;
6083 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6085 unsigned long nblock
= 0;
6086 /* We always want this to block, so temporarily disable NDELAY. */
6087 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6088 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6090 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6092 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6095 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6099 if (rc
== sizeof (char))
6100 cp
->status
= STATUS_READ_SUCCEEDED
;
6102 cp
->status
= STATUS_READ_FAILED
;
6108 _sys_wait_accept (int fd
)
6114 if (fd
< 0 || fd
>= MAXDESC
)
6115 return STATUS_READ_ERROR
;
6117 cp
= fd_info
[fd
].cp
;
6119 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6120 return STATUS_READ_ERROR
;
6122 cp
->status
= STATUS_READ_FAILED
;
6124 hEv
= pfn_WSACreateEvent ();
6125 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6126 if (rc
!= SOCKET_ERROR
)
6128 rc
= WaitForSingleObject (hEv
, INFINITE
);
6129 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6130 if (rc
== WAIT_OBJECT_0
)
6131 cp
->status
= STATUS_READ_SUCCEEDED
;
6133 pfn_WSACloseEvent (hEv
);
6139 sys_read (int fd
, char * buffer
, unsigned int count
)
6144 char * orig_buffer
= buffer
;
6152 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6154 child_process
*cp
= fd_info
[fd
].cp
;
6156 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6164 /* re-read CR carried over from last read */
6165 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6167 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6171 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6174 /* presence of a child_process structure means we are operating in
6175 non-blocking mode - otherwise we just call _read directly.
6176 Note that the child_process structure might be missing because
6177 reap_subprocess has been called; in this case the pipe is
6178 already broken, so calling _read on it is okay. */
6181 int current_status
= cp
->status
;
6183 switch (current_status
)
6185 case STATUS_READ_FAILED
:
6186 case STATUS_READ_ERROR
:
6187 /* report normal EOF if nothing in buffer */
6189 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6192 case STATUS_READ_READY
:
6193 case STATUS_READ_IN_PROGRESS
:
6194 DebPrint (("sys_read called when read is in progress\n"));
6195 errno
= EWOULDBLOCK
;
6198 case STATUS_READ_SUCCEEDED
:
6199 /* consume read-ahead char */
6200 *buffer
++ = cp
->chr
;
6203 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6204 ResetEvent (cp
->char_avail
);
6206 case STATUS_READ_ACKNOWLEDGED
:
6210 DebPrint (("sys_read: bad status %d\n", current_status
));
6215 if (fd_info
[fd
].flags
& FILE_PIPE
)
6217 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6218 to_read
= min (waiting
, (DWORD
) count
);
6221 nchars
+= _read (fd
, buffer
, to_read
);
6223 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6225 HANDLE hnd
= fd_info
[fd
].hnd
;
6226 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6232 /* Configure timeouts for non-blocking read. */
6233 if (!GetCommTimeouts (hnd
, &ct
))
6238 ct
.ReadIntervalTimeout
= MAXDWORD
;
6239 ct
.ReadTotalTimeoutMultiplier
= 0;
6240 ct
.ReadTotalTimeoutConstant
= 0;
6241 if (!SetCommTimeouts (hnd
, &ct
))
6247 if (!ResetEvent (ovl
->hEvent
))
6252 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6254 if (GetLastError () != ERROR_IO_PENDING
)
6259 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6268 else /* FILE_SOCKET */
6270 if (winsock_lib
== NULL
) emacs_abort ();
6272 /* do the equivalent of a non-blocking read */
6273 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6274 if (waiting
== 0 && nchars
== 0)
6276 h_errno
= errno
= EWOULDBLOCK
;
6282 /* always use binary mode for sockets */
6283 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6284 if (res
== SOCKET_ERROR
)
6286 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6287 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6297 int nread
= _read (fd
, buffer
, count
);
6300 else if (nchars
== 0)
6305 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6306 /* Perform text mode translation if required. */
6307 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6309 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6310 /* If buffer contains only CR, return that. To be absolutely
6311 sure we should attempt to read the next char, but in
6312 practice a CR to be followed by LF would not appear by
6313 itself in the buffer. */
6314 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6316 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6322 nchars
= _read (fd
, buffer
, count
);
6327 /* From w32xfns.c */
6328 extern HANDLE interrupt_handle
;
6330 /* For now, don't bother with a non-blocking mode */
6332 sys_write (int fd
, const void * buffer
, unsigned int count
)
6342 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6344 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6350 /* Perform text mode translation if required. */
6351 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6353 char * tmpbuf
= alloca (count
* 2);
6354 unsigned char * src
= (void *)buffer
;
6355 unsigned char * dst
= tmpbuf
;
6360 unsigned char *next
;
6361 /* copy next line or remaining bytes */
6362 next
= _memccpy (dst
, src
, '\n', nbytes
);
6365 /* copied one line ending with '\n' */
6366 int copied
= next
- dst
;
6369 /* insert '\r' before '\n' */
6376 /* copied remaining partial line -> now finished */
6383 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6385 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6386 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6387 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6390 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6392 if (GetLastError () != ERROR_IO_PENDING
)
6397 if (detect_input_pending ())
6398 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6401 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6402 if (active
== WAIT_OBJECT_0
)
6403 { /* User pressed C-g, cancel write, then leave. Don't bother
6404 cleaning up as we may only get stuck in buggy drivers. */
6405 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6410 if (active
== WAIT_OBJECT_0
+ 1
6411 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6418 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6420 unsigned long nblock
= 0;
6421 if (winsock_lib
== NULL
) emacs_abort ();
6423 /* TODO: implement select() properly so non-blocking I/O works. */
6424 /* For now, make sure the write blocks. */
6425 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6426 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6428 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6430 /* Set the socket back to non-blocking if it was before,
6431 for other operations that support it. */
6432 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6435 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6438 if (nchars
== SOCKET_ERROR
)
6440 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6441 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6447 /* Some networked filesystems don't like too large writes, so
6448 break them into smaller chunks. See the Comments section of
6449 the MSDN documentation of WriteFile for details behind the
6450 choice of the value of CHUNK below. See also the thread
6451 http://thread.gmane.org/gmane.comp.version-control.git/145294
6452 in the git mailing list. */
6453 const unsigned char *p
= buffer
;
6454 const unsigned chunk
= 30 * 1024 * 1024;
6459 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6460 int n
= _write (fd
, p
, this_chunk
);
6468 else if (n
< this_chunk
)
6478 /* The Windows CRT functions are "optimized for speed", so they don't
6479 check for timezone and DST changes if they were last called less
6480 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
6481 all Emacs features that repeatedly call time functions (e.g.,
6482 display-time) are in real danger of missing timezone and DST
6483 changes. Calling tzset before each localtime call fixes that. */
6485 sys_localtime (const time_t *t
)
6488 return localtime (t
);
6493 /* Try loading LIBRARY_ID from the file(s) specified in
6494 Vdynamic_library_alist. If the library is loaded successfully,
6495 return the handle of the DLL, and record the filename in the
6496 property :loaded-from of LIBRARY_ID. If the library could not be
6497 found, or when it was already loaded (because the handle is not
6498 recorded anywhere, and so is lost after use), return NULL.
6500 We could also save the handle in :loaded-from, but currently
6501 there's no use case for it. */
6503 w32_delayed_load (Lisp_Object library_id
)
6505 HMODULE library_dll
= NULL
;
6507 CHECK_SYMBOL (library_id
);
6509 if (CONSP (Vdynamic_library_alist
)
6510 && NILP (Fassq (library_id
, Vlibrary_cache
)))
6512 Lisp_Object found
= Qnil
;
6513 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
6516 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
6518 CHECK_STRING_CAR (dlls
);
6519 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
6521 char name
[MAX_PATH
];
6524 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
6525 found
= Fcons (XCAR (dlls
),
6527 /* Possibly truncated */
6528 ? make_specified_string (name
, -1, len
, 1)
6534 Fput (library_id
, QCloaded_from
, found
);
6542 check_windows_init_file (void)
6544 /* A common indication that Emacs is not installed properly is when
6545 it cannot find the Windows installation file. If this file does
6546 not exist in the expected place, tell the user. */
6548 if (!noninteractive
&& !inhibit_window_system
6549 /* Vload_path is not yet initialized when we are loading
6551 && NILP (Vpurify_flag
))
6553 Lisp_Object init_file
;
6556 init_file
= build_string ("term/w32-win");
6557 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
6560 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
6561 char *init_file_name
= SDATA (init_file
);
6562 char *load_path
= SDATA (load_path_print
);
6563 char *buffer
= alloca (1024
6564 + strlen (init_file_name
)
6565 + strlen (load_path
));
6568 "The Emacs Windows initialization file \"%s.el\" "
6569 "could not be found in your Emacs installation. "
6570 "Emacs checked the following directories for this file:\n"
6572 "When Emacs cannot find this file, it usually means that it "
6573 "was not installed properly, or its distribution file was "
6574 "not unpacked properly.\nSee the README.W32 file in the "
6575 "top-level Emacs directory for more information.",
6576 init_file_name
, load_path
);
6579 "Emacs Abort Dialog",
6580 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
6581 /* Use the low-level system abort. */
6592 term_ntproc (int ignored
)
6598 /* shutdown the socket interface if necessary */
6605 init_ntproc (int dumping
)
6607 sigset_t initial_mask
= 0;
6609 /* Initialize the socket interface now if available and requested by
6610 the user by defining PRELOAD_WINSOCK; otherwise loading will be
6611 delayed until open-network-stream is called (w32-has-winsock can
6612 also be used to dynamically load or reload winsock).
6614 Conveniently, init_environment is called before us, so
6615 PRELOAD_WINSOCK can be set in the registry. */
6617 /* Always initialize this correctly. */
6620 if (getenv ("PRELOAD_WINSOCK") != NULL
)
6621 init_winsock (TRUE
);
6623 /* Initial preparation for subprocess support: replace our standard
6624 handles with non-inheritable versions. */
6627 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
6628 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
6629 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
6631 parent
= GetCurrentProcess ();
6633 /* ignore errors when duplicating and closing; typically the
6634 handles will be invalid when running as a gui program. */
6635 DuplicateHandle (parent
,
6636 GetStdHandle (STD_INPUT_HANDLE
),
6641 DUPLICATE_SAME_ACCESS
);
6643 DuplicateHandle (parent
,
6644 GetStdHandle (STD_OUTPUT_HANDLE
),
6649 DUPLICATE_SAME_ACCESS
);
6651 DuplicateHandle (parent
,
6652 GetStdHandle (STD_ERROR_HANDLE
),
6657 DUPLICATE_SAME_ACCESS
);
6663 if (stdin_save
!= INVALID_HANDLE_VALUE
)
6664 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
6666 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
6669 if (stdout_save
!= INVALID_HANDLE_VALUE
)
6670 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
6672 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6675 if (stderr_save
!= INVALID_HANDLE_VALUE
)
6676 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
6678 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6682 /* unfortunately, atexit depends on implementation of malloc */
6683 /* atexit (term_ntproc); */
6686 /* Make sure we start with all signals unblocked. */
6687 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
6688 signal (SIGABRT
, term_ntproc
);
6692 /* determine which drives are fixed, for GetCachedVolumeInformation */
6694 /* GetDriveType must have trailing backslash. */
6695 char drive
[] = "A:\\";
6697 /* Loop over all possible drive letters */
6698 while (*drive
<= 'Z')
6700 /* Record if this drive letter refers to a fixed drive. */
6701 fixed_drives
[DRIVE_INDEX (*drive
)] =
6702 (GetDriveType (drive
) == DRIVE_FIXED
);
6707 /* Reset the volume info cache. */
6708 volume_cache
= NULL
;
6713 shutdown_handler ensures that buffers' autosave files are
6714 up to date when the user logs off, or the system shuts down.
6717 shutdown_handler (DWORD type
)
6719 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
6720 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
6721 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
6722 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
6724 /* Shut down cleanly, making sure autosave files are up to date. */
6725 shut_down_emacs (0, Qnil
);
6728 /* Allow other handlers to handle this signal. */
6733 globals_of_w32 is used to initialize those global variables that
6734 must always be initialized on startup even when the global variable
6735 initialized is non zero (see the function main in emacs.c).
6738 globals_of_w32 (void)
6740 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
6742 get_process_times_fn
= (GetProcessTimes_Proc
)
6743 GetProcAddress (kernel32
, "GetProcessTimes");
6745 DEFSYM (QCloaded_from
, ":loaded-from");
6747 g_b_init_is_windows_9x
= 0;
6748 g_b_init_open_process_token
= 0;
6749 g_b_init_get_token_information
= 0;
6750 g_b_init_lookup_account_sid
= 0;
6751 g_b_init_get_sid_sub_authority
= 0;
6752 g_b_init_get_sid_sub_authority_count
= 0;
6753 g_b_init_get_security_info
= 0;
6754 g_b_init_get_file_security
= 0;
6755 g_b_init_get_security_descriptor_owner
= 0;
6756 g_b_init_get_security_descriptor_group
= 0;
6757 g_b_init_is_valid_sid
= 0;
6758 g_b_init_create_toolhelp32_snapshot
= 0;
6759 g_b_init_process32_first
= 0;
6760 g_b_init_process32_next
= 0;
6761 g_b_init_open_thread_token
= 0;
6762 g_b_init_impersonate_self
= 0;
6763 g_b_init_revert_to_self
= 0;
6764 g_b_init_get_process_memory_info
= 0;
6765 g_b_init_get_process_working_set_size
= 0;
6766 g_b_init_global_memory_status
= 0;
6767 g_b_init_global_memory_status_ex
= 0;
6768 g_b_init_equal_sid
= 0;
6769 g_b_init_copy_sid
= 0;
6770 g_b_init_get_length_sid
= 0;
6771 g_b_init_get_native_system_info
= 0;
6772 g_b_init_get_system_times
= 0;
6773 g_b_init_create_symbolic_link
= 0;
6774 num_of_processors
= 0;
6775 /* The following sets a handler for shutdown notifications for
6776 console apps. This actually applies to Emacs in both console and
6777 GUI modes, since we had to fool windows into thinking emacs is a
6778 console application to get console mode to work. */
6779 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
6781 /* "None" is the default group name on standalone workstations. */
6782 strcpy (dflt_group_name
, "None");
6785 /* For make-serial-process */
6787 serial_open (char *port
)
6793 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
6794 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
6795 if (hnd
== INVALID_HANDLE_VALUE
)
6796 error ("Could not open %s", port
);
6797 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
6799 error ("Could not open %s", port
);
6803 error ("Could not create child process");
6805 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6806 fd_info
[ fd
].hnd
= hnd
;
6807 fd_info
[ fd
].flags
|=
6808 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
6809 if (fd_info
[ fd
].cp
!= NULL
)
6811 error ("fd_info[fd = %d] is already in use", fd
);
6813 fd_info
[ fd
].cp
= cp
;
6814 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6815 if (cp
->ovl_read
.hEvent
== NULL
)
6816 error ("Could not create read event");
6817 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6818 if (cp
->ovl_write
.hEvent
== NULL
)
6819 error ("Could not create write event");
6824 /* For serial-process-configure */
6826 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
6828 Lisp_Object childp2
= Qnil
;
6829 Lisp_Object tem
= Qnil
;
6833 char summary
[4] = "???"; /* This usually becomes "8N1". */
6835 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
6836 error ("Not a serial process");
6837 hnd
= fd_info
[ p
->outfd
].hnd
;
6839 childp2
= Fcopy_sequence (p
->childp
);
6841 /* Initialize timeouts for blocking read and blocking write. */
6842 if (!GetCommTimeouts (hnd
, &ct
))
6843 error ("GetCommTimeouts() failed");
6844 ct
.ReadIntervalTimeout
= 0;
6845 ct
.ReadTotalTimeoutMultiplier
= 0;
6846 ct
.ReadTotalTimeoutConstant
= 0;
6847 ct
.WriteTotalTimeoutMultiplier
= 0;
6848 ct
.WriteTotalTimeoutConstant
= 0;
6849 if (!SetCommTimeouts (hnd
, &ct
))
6850 error ("SetCommTimeouts() failed");
6851 /* Read port attributes and prepare default configuration. */
6852 memset (&dcb
, 0, sizeof (dcb
));
6853 dcb
.DCBlength
= sizeof (DCB
);
6854 if (!GetCommState (hnd
, &dcb
))
6855 error ("GetCommState() failed");
6858 dcb
.fAbortOnError
= FALSE
;
6859 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
6864 /* Configure speed. */
6865 if (!NILP (Fplist_member (contact
, QCspeed
)))
6866 tem
= Fplist_get (contact
, QCspeed
);
6868 tem
= Fplist_get (p
->childp
, QCspeed
);
6870 dcb
.BaudRate
= XINT (tem
);
6871 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
6873 /* Configure bytesize. */
6874 if (!NILP (Fplist_member (contact
, QCbytesize
)))
6875 tem
= Fplist_get (contact
, QCbytesize
);
6877 tem
= Fplist_get (p
->childp
, QCbytesize
);
6879 tem
= make_number (8);
6881 if (XINT (tem
) != 7 && XINT (tem
) != 8)
6882 error (":bytesize must be nil (8), 7, or 8");
6883 dcb
.ByteSize
= XINT (tem
);
6884 summary
[0] = XINT (tem
) + '0';
6885 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
6887 /* Configure parity. */
6888 if (!NILP (Fplist_member (contact
, QCparity
)))
6889 tem
= Fplist_get (contact
, QCparity
);
6891 tem
= Fplist_get (p
->childp
, QCparity
);
6892 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6893 error (":parity must be nil (no parity), `even', or `odd'");
6894 dcb
.fParity
= FALSE
;
6895 dcb
.Parity
= NOPARITY
;
6896 dcb
.fErrorChar
= FALSE
;
6901 else if (EQ (tem
, Qeven
))
6905 dcb
.Parity
= EVENPARITY
;
6906 dcb
.fErrorChar
= TRUE
;
6908 else if (EQ (tem
, Qodd
))
6912 dcb
.Parity
= ODDPARITY
;
6913 dcb
.fErrorChar
= TRUE
;
6915 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6917 /* Configure stopbits. */
6918 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6919 tem
= Fplist_get (contact
, QCstopbits
);
6921 tem
= Fplist_get (p
->childp
, QCstopbits
);
6923 tem
= make_number (1);
6925 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6926 error (":stopbits must be nil (1 stopbit), 1, or 2");
6927 summary
[2] = XINT (tem
) + '0';
6928 if (XINT (tem
) == 1)
6929 dcb
.StopBits
= ONESTOPBIT
;
6930 else if (XINT (tem
) == 2)
6931 dcb
.StopBits
= TWOSTOPBITS
;
6932 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6934 /* Configure flowcontrol. */
6935 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6936 tem
= Fplist_get (contact
, QCflowcontrol
);
6938 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6939 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6940 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6941 dcb
.fOutxCtsFlow
= FALSE
;
6942 dcb
.fOutxDsrFlow
= FALSE
;
6943 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6944 dcb
.fDsrSensitivity
= FALSE
;
6945 dcb
.fTXContinueOnXoff
= FALSE
;
6948 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6949 dcb
.XonChar
= 17; /* Control-Q */
6950 dcb
.XoffChar
= 19; /* Control-S */
6953 /* Already configured. */
6955 else if (EQ (tem
, Qhw
))
6957 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6958 dcb
.fOutxCtsFlow
= TRUE
;
6960 else if (EQ (tem
, Qsw
))
6965 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6967 /* Activate configuration. */
6968 if (!SetCommState (hnd
, &dcb
))
6969 error ("SetCommState() failed");
6971 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6972 pset_childp (p
, childp2
);
6978 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
6983 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
6984 int fd
= process
->infd
;
6988 n
= sys_read (fd
, (char*)buf
, sz
);
6995 if (err
== EWOULDBLOCK
)
6997 /* Set a small timeout. */
6998 timeout
= make_emacs_time (1, 0);
7000 FD_SET ((int)fd
, &fdset
);
7002 /* Use select with the timeout to poll the selector. */
7003 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7007 continue; /* Try again. */
7009 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7010 Also accept select return 0 as an indicator to EAGAIN. */
7011 if (sc
== 0 || errno
== EWOULDBLOCK
)
7014 err
= errno
; /* Other errors are just passed on. */
7017 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7024 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7026 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7027 int fd
= process
->outfd
;
7028 ssize_t n
= sys_write (fd
, buf
, sz
);
7030 /* 0 or more bytes written means everything went fine. */
7034 /* Negative bytes written means we got an error in errno.
7035 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7036 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7037 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7041 #endif /* HAVE_GNUTLS */