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>
34 #include <mbstring.h> /* for _mbspbrk */
38 /* must include CRT headers *before* config.h */
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>
178 #include "dispextern.h" /* for xstrcasecmp */
179 #include "coding.h" /* for Vlocale_coding_system */
181 #include "careadlinkat.h"
182 #include "allocator.h"
184 /* For serial_configure and serial_open. */
187 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
188 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
190 Lisp_Object QCloaded_from
;
192 void globals_of_w32 (void);
193 static DWORD
get_rid (PSID
);
194 static int is_symlink (const char *);
195 static char * chase_symlinks (const char *);
196 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
197 static int restore_privilege (TOKEN_PRIVILEGES
*);
198 static BOOL WINAPI
revert_to_self (void);
201 /* Initialization states.
203 WARNING: If you add any more such variables for additional APIs,
204 you MUST add initialization for them to globals_of_w32
205 below. This is because these variables might get set
206 to non-NULL values during dumping, but the dumped Emacs
207 cannot reuse those values, because it could be run on a
208 different version of the OS, where API addresses are
210 static BOOL g_b_init_is_windows_9x
;
211 static BOOL g_b_init_open_process_token
;
212 static BOOL g_b_init_get_token_information
;
213 static BOOL g_b_init_lookup_account_sid
;
214 static BOOL g_b_init_get_sid_sub_authority
;
215 static BOOL g_b_init_get_sid_sub_authority_count
;
216 static BOOL g_b_init_get_security_info
;
217 static BOOL g_b_init_get_file_security
;
218 static BOOL g_b_init_get_security_descriptor_owner
;
219 static BOOL g_b_init_get_security_descriptor_group
;
220 static BOOL g_b_init_is_valid_sid
;
221 static BOOL g_b_init_create_toolhelp32_snapshot
;
222 static BOOL g_b_init_process32_first
;
223 static BOOL g_b_init_process32_next
;
224 static BOOL g_b_init_open_thread_token
;
225 static BOOL g_b_init_impersonate_self
;
226 static BOOL g_b_init_revert_to_self
;
227 static BOOL g_b_init_get_process_memory_info
;
228 static BOOL g_b_init_get_process_working_set_size
;
229 static BOOL g_b_init_global_memory_status
;
230 static BOOL g_b_init_global_memory_status_ex
;
231 static BOOL g_b_init_get_length_sid
;
232 static BOOL g_b_init_equal_sid
;
233 static BOOL g_b_init_copy_sid
;
234 static BOOL g_b_init_get_native_system_info
;
235 static BOOL g_b_init_get_system_times
;
236 static BOOL g_b_init_create_symbolic_link
;
239 BEGIN: Wrapper functions around OpenProcessToken
240 and other functions in advapi32.dll that are only
241 supported in Windows NT / 2k / XP
243 /* ** Function pointer typedefs ** */
244 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
245 HANDLE ProcessHandle
,
247 PHANDLE TokenHandle
);
248 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
250 TOKEN_INFORMATION_CLASS TokenInformationClass
,
251 LPVOID TokenInformation
,
252 DWORD TokenInformationLength
,
253 PDWORD ReturnLength
);
254 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
255 HANDLE process_handle
,
256 LPFILETIME creation_time
,
257 LPFILETIME exit_time
,
258 LPFILETIME kernel_time
,
259 LPFILETIME user_time
);
261 GetProcessTimes_Proc get_process_times_fn
= NULL
;
264 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
265 const char * const GetFileSecurity_Name
= "GetFileSecurityW";
267 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
268 const char * const GetFileSecurity_Name
= "GetFileSecurityA";
270 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
271 LPCTSTR lpSystemName
,
276 LPDWORD cbDomainName
,
277 PSID_NAME_USE peUse
);
278 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
281 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
283 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
285 SE_OBJECT_TYPE ObjectType
,
286 SECURITY_INFORMATION SecurityInfo
,
291 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
292 typedef BOOL (WINAPI
* GetFileSecurity_Proc
) (
294 SECURITY_INFORMATION RequestedInformation
,
295 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
297 LPDWORD lpnLengthNeeded
);
298 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
299 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
301 LPBOOL lpbOwnerDefaulted
);
302 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
303 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
305 LPBOOL lpbGroupDefaulted
);
306 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
308 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
310 DWORD th32ProcessID
);
311 typedef BOOL (WINAPI
* Process32First_Proc
) (
313 LPPROCESSENTRY32 lppe
);
314 typedef BOOL (WINAPI
* Process32Next_Proc
) (
316 LPPROCESSENTRY32 lppe
);
317 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
321 PHANDLE TokenHandle
);
322 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
323 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
324 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
325 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
327 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
329 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
331 DWORD
* lpMinimumWorkingSetSize
,
332 DWORD
* lpMaximumWorkingSetSize
);
333 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
334 LPMEMORYSTATUS lpBuffer
);
335 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
336 LPMEMORY_STATUS_EX lpBuffer
);
337 typedef BOOL (WINAPI
* CopySid_Proc
) (
338 DWORD nDestinationSidLength
,
339 PSID pDestinationSid
,
341 typedef BOOL (WINAPI
* EqualSid_Proc
) (
344 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
346 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
347 LPSYSTEM_INFO lpSystemInfo
);
348 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
349 LPFILETIME lpIdleTime
,
350 LPFILETIME lpKernelTime
,
351 LPFILETIME lpUserTime
);
352 typedef BOOLEAN (WINAPI
*CreateSymbolicLink_Proc
) (
353 LPTSTR lpSymlinkFileName
,
354 LPTSTR lpTargetFileName
,
357 /* ** A utility function ** */
361 static BOOL s_b_ret
= 0;
362 OSVERSIONINFO os_ver
;
363 if (g_b_init_is_windows_9x
== 0)
365 g_b_init_is_windows_9x
= 1;
366 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
367 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
368 if (GetVersionEx (&os_ver
))
370 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
376 static Lisp_Object
ltime (ULONGLONG
);
378 /* Get total user and system times for get-internal-run-time.
379 Returns a list of integers if the times are provided by the OS
380 (NT derivatives), otherwise it returns the result of current-time. */
382 w32_get_internal_run_time (void)
384 if (get_process_times_fn
)
386 FILETIME create
, exit
, kernel
, user
;
387 HANDLE proc
= GetCurrentProcess ();
388 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
390 LARGE_INTEGER user_int
, kernel_int
, total
;
391 user_int
.LowPart
= user
.dwLowDateTime
;
392 user_int
.HighPart
= user
.dwHighDateTime
;
393 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
394 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
395 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
396 return ltime (total
.QuadPart
);
400 return Fcurrent_time ();
403 /* ** The wrapper functions ** */
406 open_process_token (HANDLE ProcessHandle
,
410 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
411 HMODULE hm_advapi32
= NULL
;
412 if (is_windows_9x () == TRUE
)
416 if (g_b_init_open_process_token
== 0)
418 g_b_init_open_process_token
= 1;
419 hm_advapi32
= LoadLibrary ("Advapi32.dll");
420 s_pfn_Open_Process_Token
=
421 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
423 if (s_pfn_Open_Process_Token
== NULL
)
428 s_pfn_Open_Process_Token (
436 get_token_information (HANDLE TokenHandle
,
437 TOKEN_INFORMATION_CLASS TokenInformationClass
,
438 LPVOID TokenInformation
,
439 DWORD TokenInformationLength
,
442 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
443 HMODULE hm_advapi32
= NULL
;
444 if (is_windows_9x () == TRUE
)
448 if (g_b_init_get_token_information
== 0)
450 g_b_init_get_token_information
= 1;
451 hm_advapi32
= LoadLibrary ("Advapi32.dll");
452 s_pfn_Get_Token_Information
=
453 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
455 if (s_pfn_Get_Token_Information
== NULL
)
460 s_pfn_Get_Token_Information (
462 TokenInformationClass
,
464 TokenInformationLength
,
470 lookup_account_sid (LPCTSTR lpSystemName
,
475 LPDWORD cbDomainName
,
478 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
479 HMODULE hm_advapi32
= NULL
;
480 if (is_windows_9x () == TRUE
)
484 if (g_b_init_lookup_account_sid
== 0)
486 g_b_init_lookup_account_sid
= 1;
487 hm_advapi32
= LoadLibrary ("Advapi32.dll");
488 s_pfn_Lookup_Account_Sid
=
489 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
491 if (s_pfn_Lookup_Account_Sid
== NULL
)
496 s_pfn_Lookup_Account_Sid (
508 get_sid_sub_authority (PSID pSid
, DWORD n
)
510 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
511 static DWORD zero
= 0U;
512 HMODULE hm_advapi32
= NULL
;
513 if (is_windows_9x () == TRUE
)
517 if (g_b_init_get_sid_sub_authority
== 0)
519 g_b_init_get_sid_sub_authority
= 1;
520 hm_advapi32
= LoadLibrary ("Advapi32.dll");
521 s_pfn_Get_Sid_Sub_Authority
=
522 (GetSidSubAuthority_Proc
) GetProcAddress (
523 hm_advapi32
, "GetSidSubAuthority");
525 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
529 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
533 get_sid_sub_authority_count (PSID pSid
)
535 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
536 static UCHAR zero
= 0U;
537 HMODULE hm_advapi32
= NULL
;
538 if (is_windows_9x () == TRUE
)
542 if (g_b_init_get_sid_sub_authority_count
== 0)
544 g_b_init_get_sid_sub_authority_count
= 1;
545 hm_advapi32
= LoadLibrary ("Advapi32.dll");
546 s_pfn_Get_Sid_Sub_Authority_Count
=
547 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
548 hm_advapi32
, "GetSidSubAuthorityCount");
550 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
554 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
558 get_security_info (HANDLE handle
,
559 SE_OBJECT_TYPE ObjectType
,
560 SECURITY_INFORMATION SecurityInfo
,
565 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
567 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
568 HMODULE hm_advapi32
= NULL
;
569 if (is_windows_9x () == TRUE
)
573 if (g_b_init_get_security_info
== 0)
575 g_b_init_get_security_info
= 1;
576 hm_advapi32
= LoadLibrary ("Advapi32.dll");
577 s_pfn_Get_Security_Info
=
578 (GetSecurityInfo_Proc
) GetProcAddress (
579 hm_advapi32
, "GetSecurityInfo");
581 if (s_pfn_Get_Security_Info
== NULL
)
585 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
586 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
587 ppSecurityDescriptor
));
591 get_file_security (LPCTSTR lpFileName
,
592 SECURITY_INFORMATION RequestedInformation
,
593 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
595 LPDWORD lpnLengthNeeded
)
597 static GetFileSecurity_Proc s_pfn_Get_File_Security
= NULL
;
598 HMODULE hm_advapi32
= NULL
;
599 if (is_windows_9x () == TRUE
)
603 if (g_b_init_get_file_security
== 0)
605 g_b_init_get_file_security
= 1;
606 hm_advapi32
= LoadLibrary ("Advapi32.dll");
607 s_pfn_Get_File_Security
=
608 (GetFileSecurity_Proc
) GetProcAddress (
609 hm_advapi32
, GetFileSecurity_Name
);
611 if (s_pfn_Get_File_Security
== NULL
)
615 return (s_pfn_Get_File_Security (lpFileName
, RequestedInformation
,
616 pSecurityDescriptor
, nLength
,
621 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
623 LPBOOL lpbOwnerDefaulted
)
625 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
626 HMODULE hm_advapi32
= NULL
;
627 if (is_windows_9x () == TRUE
)
631 if (g_b_init_get_security_descriptor_owner
== 0)
633 g_b_init_get_security_descriptor_owner
= 1;
634 hm_advapi32
= LoadLibrary ("Advapi32.dll");
635 s_pfn_Get_Security_Descriptor_Owner
=
636 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
637 hm_advapi32
, "GetSecurityDescriptorOwner");
639 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
643 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
648 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
650 LPBOOL lpbGroupDefaulted
)
652 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
653 HMODULE hm_advapi32
= NULL
;
654 if (is_windows_9x () == TRUE
)
658 if (g_b_init_get_security_descriptor_group
== 0)
660 g_b_init_get_security_descriptor_group
= 1;
661 hm_advapi32
= LoadLibrary ("Advapi32.dll");
662 s_pfn_Get_Security_Descriptor_Group
=
663 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
664 hm_advapi32
, "GetSecurityDescriptorGroup");
666 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
670 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
675 is_valid_sid (PSID sid
)
677 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
678 HMODULE hm_advapi32
= NULL
;
679 if (is_windows_9x () == TRUE
)
683 if (g_b_init_is_valid_sid
== 0)
685 g_b_init_is_valid_sid
= 1;
686 hm_advapi32
= LoadLibrary ("Advapi32.dll");
688 (IsValidSid_Proc
) GetProcAddress (
689 hm_advapi32
, "IsValidSid");
691 if (s_pfn_Is_Valid_Sid
== NULL
)
695 return (s_pfn_Is_Valid_Sid (sid
));
699 equal_sid (PSID sid1
, PSID sid2
)
701 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
702 HMODULE hm_advapi32
= NULL
;
703 if (is_windows_9x () == TRUE
)
707 if (g_b_init_equal_sid
== 0)
709 g_b_init_equal_sid
= 1;
710 hm_advapi32
= LoadLibrary ("Advapi32.dll");
712 (EqualSid_Proc
) GetProcAddress (
713 hm_advapi32
, "EqualSid");
715 if (s_pfn_Equal_Sid
== NULL
)
719 return (s_pfn_Equal_Sid (sid1
, sid2
));
723 get_length_sid (PSID sid
)
725 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
726 HMODULE hm_advapi32
= NULL
;
727 if (is_windows_9x () == TRUE
)
731 if (g_b_init_get_length_sid
== 0)
733 g_b_init_get_length_sid
= 1;
734 hm_advapi32
= LoadLibrary ("Advapi32.dll");
735 s_pfn_Get_Length_Sid
=
736 (GetLengthSid_Proc
) GetProcAddress (
737 hm_advapi32
, "GetLengthSid");
739 if (s_pfn_Get_Length_Sid
== NULL
)
743 return (s_pfn_Get_Length_Sid (sid
));
747 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
749 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
750 HMODULE hm_advapi32
= NULL
;
751 if (is_windows_9x () == TRUE
)
755 if (g_b_init_copy_sid
== 0)
757 g_b_init_copy_sid
= 1;
758 hm_advapi32
= LoadLibrary ("Advapi32.dll");
760 (CopySid_Proc
) GetProcAddress (
761 hm_advapi32
, "CopySid");
763 if (s_pfn_Copy_Sid
== NULL
)
767 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
771 END: Wrapper functions around OpenProcessToken
772 and other functions in advapi32.dll that are only
773 supported in Windows NT / 2k / XP
777 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
779 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
780 if (is_windows_9x () != TRUE
)
782 if (g_b_init_get_native_system_info
== 0)
784 g_b_init_get_native_system_info
= 1;
785 s_pfn_Get_Native_System_Info
=
786 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
787 "GetNativeSystemInfo");
789 if (s_pfn_Get_Native_System_Info
!= NULL
)
790 s_pfn_Get_Native_System_Info (lpSystemInfo
);
793 lpSystemInfo
->dwNumberOfProcessors
= -1;
797 get_system_times (LPFILETIME lpIdleTime
,
798 LPFILETIME lpKernelTime
,
799 LPFILETIME lpUserTime
)
801 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
802 if (is_windows_9x () == TRUE
)
806 if (g_b_init_get_system_times
== 0)
808 g_b_init_get_system_times
= 1;
809 s_pfn_Get_System_times
=
810 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
813 if (s_pfn_Get_System_times
== NULL
)
815 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
818 static BOOLEAN WINAPI
819 create_symbolic_link (LPTSTR lpSymlinkFilename
,
820 LPTSTR lpTargetFileName
,
823 static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link
= NULL
;
826 if (is_windows_9x () == TRUE
)
831 if (g_b_init_create_symbolic_link
== 0)
833 g_b_init_create_symbolic_link
= 1;
835 s_pfn_Create_Symbolic_Link
=
836 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
837 "CreateSymbolicLinkW");
839 s_pfn_Create_Symbolic_Link
=
840 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
841 "CreateSymbolicLinkA");
844 if (s_pfn_Create_Symbolic_Link
== NULL
)
850 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
852 /* If we were denied creation of the symlink, try again after
853 enabling the SeCreateSymbolicLinkPrivilege for our process. */
856 TOKEN_PRIVILEGES priv_current
;
858 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
, &priv_current
))
860 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
862 restore_privilege (&priv_current
);
869 /* Equivalent of strerror for W32 error codes. */
871 w32_strerror (int error_no
)
873 static char buf
[500];
876 error_no
= GetLastError ();
879 if (!FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
, NULL
,
881 0, /* choose most suitable language */
882 buf
, sizeof (buf
), NULL
))
883 sprintf (buf
, "w32 error %u", error_no
);
887 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
888 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
890 This is called from alloc.c:valid_pointer_p. */
892 w32_valid_pointer_p (void *p
, int size
)
895 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
899 unsigned char *buf
= alloca (size
);
900 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
909 static char startup_dir
[MAXPATHLEN
];
911 /* Get the current working directory. */
916 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
920 /* Emacs doesn't actually change directory itself, it stays in the
921 same directory where it was started. */
922 strcpy (dir
, startup_dir
);
927 /* Emulate getloadavg. */
936 /* Number of processors on this machine. */
937 static unsigned num_of_processors
;
939 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
940 static struct load_sample samples
[16*60];
941 static int first_idx
= -1, last_idx
= -1;
942 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
947 int next_idx
= from
+ 1;
949 if (next_idx
>= max_idx
)
958 int prev_idx
= from
- 1;
961 prev_idx
= max_idx
- 1;
967 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
970 FILETIME ft_idle
, ft_user
, ft_kernel
;
972 /* Initialize the number of processors on this machine. */
973 if (num_of_processors
<= 0)
975 get_native_system_info (&sysinfo
);
976 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
977 if (num_of_processors
<= 0)
979 GetSystemInfo (&sysinfo
);
980 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
982 if (num_of_processors
<= 0)
983 num_of_processors
= 1;
986 /* TODO: Take into account threads that are ready to run, by
987 sampling the "\System\Processor Queue Length" performance
988 counter. The code below accounts only for threads that are
991 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
993 ULARGE_INTEGER uidle
, ukernel
, uuser
;
995 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
996 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
997 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
998 *idle
= uidle
.QuadPart
;
999 *kernel
= ukernel
.QuadPart
;
1000 *user
= uuser
.QuadPart
;
1010 /* Produce the load average for a given time interval, using the
1011 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1012 1-minute, 5-minute, or 15-minute average, respectively. */
1016 double retval
= -1.0;
1019 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1020 time_t now
= samples
[last_idx
].sample_time
;
1022 if (first_idx
!= last_idx
)
1024 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1026 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1027 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1030 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1031 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1032 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1034 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1037 if (idx
== first_idx
)
1046 getloadavg (double loadavg
[], int nelem
)
1049 ULONGLONG idle
, kernel
, user
;
1050 time_t now
= time (NULL
);
1052 /* Store another sample. We ignore samples that are less than 1 sec
1054 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
1056 sample_system_load (&idle
, &kernel
, &user
);
1057 last_idx
= buf_next (last_idx
);
1058 samples
[last_idx
].sample_time
= now
;
1059 samples
[last_idx
].idle
= idle
;
1060 samples
[last_idx
].kernel
= kernel
;
1061 samples
[last_idx
].user
= user
;
1062 /* If the buffer has more that 15 min worth of samples, discard
1064 if (first_idx
== -1)
1065 first_idx
= last_idx
;
1066 while (first_idx
!= last_idx
1067 && (difftime (now
, samples
[first_idx
].sample_time
)
1068 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1069 first_idx
= buf_next (first_idx
);
1072 for (elem
= 0; elem
< nelem
; elem
++)
1074 double avg
= getavg (elem
);
1078 loadavg
[elem
] = avg
;
1084 /* Emulate getpwuid, getpwnam and others. */
1086 #define PASSWD_FIELD_SIZE 256
1088 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1089 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1090 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1091 static char dflt_passwd_dir
[PASSWD_FIELD_SIZE
];
1092 static char dflt_passwd_shell
[PASSWD_FIELD_SIZE
];
1094 static struct passwd dflt_passwd
=
1106 static char dflt_group_name
[GNLEN
+1];
1108 static struct group dflt_group
=
1110 /* When group information is not available, we return this as the
1111 group for all files. */
1119 return dflt_passwd
.pw_uid
;
1125 /* I could imagine arguing for checking to see whether the user is
1126 in the Administrators group and returning a UID of 0 for that
1127 case, but I don't know how wise that would be in the long run. */
1134 return dflt_passwd
.pw_gid
;
1144 getpwuid (unsigned uid
)
1146 if (uid
== dflt_passwd
.pw_uid
)
1147 return &dflt_passwd
;
1152 getgrgid (gid_t gid
)
1158 getpwnam (char *name
)
1162 pw
= getpwuid (getuid ());
1166 if (xstrcasecmp (name
, pw
->pw_name
))
1173 init_user_info (void)
1175 /* Find the user's real name by opening the process token and
1176 looking up the name associated with the user-sid in that token.
1178 Use the relative portion of the identifier authority value from
1179 the user-sid as the user id value (same for group id using the
1180 primary group sid from the process token). */
1182 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1183 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1184 DWORD glength
= sizeof (gname
);
1185 HANDLE token
= NULL
;
1186 SID_NAME_USE user_type
;
1187 unsigned char *buf
= NULL
;
1189 TOKEN_USER user_token
;
1190 TOKEN_PRIMARY_GROUP group_token
;
1193 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1196 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1197 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1199 buf
= xmalloc (blen
);
1200 result
= get_token_information (token
, TokenUser
,
1201 (LPVOID
)buf
, blen
, &needed
);
1204 memcpy (&user_token
, buf
, sizeof (user_token
));
1205 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1207 domain
, &dlength
, &user_type
);
1215 strcpy (dflt_passwd
.pw_name
, uname
);
1216 /* Determine a reasonable uid value. */
1217 if (xstrcasecmp ("administrator", uname
) == 0)
1219 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1220 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1224 /* Use the last sub-authority value of the RID, the relative
1225 portion of the SID, as user/group ID. */
1226 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1228 /* Get group id and name. */
1229 result
= get_token_information (token
, TokenPrimaryGroup
,
1230 (LPVOID
)buf
, blen
, &needed
);
1231 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1233 buf
= xrealloc (buf
, blen
= needed
);
1234 result
= get_token_information (token
, TokenPrimaryGroup
,
1235 (LPVOID
)buf
, blen
, &needed
);
1239 memcpy (&group_token
, buf
, sizeof (group_token
));
1240 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1241 dlength
= sizeof (domain
);
1242 /* If we can get at the real Primary Group name, use that.
1243 Otherwise, the default group name was already set to
1244 "None" in globals_of_w32. */
1245 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1246 gname
, &glength
, NULL
, &dlength
,
1248 strcpy (dflt_group_name
, gname
);
1251 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1254 /* If security calls are not supported (presumably because we
1255 are running under Windows 9X), fallback to this: */
1256 else if (GetUserName (uname
, &ulength
))
1258 strcpy (dflt_passwd
.pw_name
, uname
);
1259 if (xstrcasecmp ("administrator", uname
) == 0)
1260 dflt_passwd
.pw_uid
= 0;
1262 dflt_passwd
.pw_uid
= 123;
1263 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1267 strcpy (dflt_passwd
.pw_name
, "unknown");
1268 dflt_passwd
.pw_uid
= 123;
1269 dflt_passwd
.pw_gid
= 123;
1271 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1273 /* Ensure HOME and SHELL are defined. */
1274 if (getenv ("HOME") == NULL
)
1276 if (getenv ("SHELL") == NULL
)
1279 /* Set dir and shell from environment variables. */
1280 strcpy (dflt_passwd
.pw_dir
, getenv ("HOME"));
1281 strcpy (dflt_passwd
.pw_shell
, getenv ("SHELL"));
1285 CloseHandle (token
);
1291 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1292 return ((rand () << 15) | rand ());
1302 /* Normalize filename by converting all path separators to
1303 the specified separator. Also conditionally convert upper
1304 case path name components to lower case. */
1307 normalize_filename (register char *fp
, char path_sep
)
1312 /* Always lower-case drive letters a-z, even if the filesystem
1313 preserves case in filenames.
1314 This is so filenames can be compared by string comparison
1315 functions that are case-sensitive. Even case-preserving filesystems
1316 do not distinguish case in drive letters. */
1317 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
1323 if (NILP (Vw32_downcase_file_names
))
1327 if (*fp
== '/' || *fp
== '\\')
1334 sep
= path_sep
; /* convert to this path separator */
1335 elem
= fp
; /* start of current path element */
1338 if (*fp
>= 'a' && *fp
<= 'z')
1339 elem
= 0; /* don't convert this element */
1341 if (*fp
== 0 || *fp
== ':')
1343 sep
= *fp
; /* restore current separator (or 0) */
1344 *fp
= '/'; /* after conversion of this element */
1347 if (*fp
== '/' || *fp
== '\\')
1349 if (elem
&& elem
!= fp
)
1351 *fp
= 0; /* temporary end of string */
1352 _strlwr (elem
); /* while we convert to lower case */
1354 *fp
= sep
; /* convert (or restore) path separator */
1355 elem
= fp
+ 1; /* next element starts after separator */
1361 /* Destructively turn backslashes into slashes. */
1363 dostounix_filename (register char *p
)
1365 normalize_filename (p
, '/');
1368 /* Destructively turn slashes into backslashes. */
1370 unixtodos_filename (register char *p
)
1372 normalize_filename (p
, '\\');
1375 /* Remove all CR's that are followed by a LF.
1376 (From msdos.c...probably should figure out a way to share it,
1377 although this code isn't going to ever change.) */
1379 crlf_to_lf (register int n
, register unsigned char *buf
)
1381 unsigned char *np
= buf
;
1382 unsigned char *startp
= buf
;
1383 unsigned char *endp
= buf
+ n
;
1387 while (buf
< endp
- 1)
1391 if (*(++buf
) != 0x0a)
1402 /* Parse the root part of file name, if present. Return length and
1403 optionally store pointer to char after root. */
1405 parse_root (char * name
, char ** pPath
)
1407 char * start
= name
;
1412 /* find the root name of the volume if given */
1413 if (isalpha (name
[0]) && name
[1] == ':')
1415 /* skip past drive specifier */
1417 if (IS_DIRECTORY_SEP (name
[0]))
1420 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1426 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1431 if (IS_DIRECTORY_SEP (name
[0]))
1438 return name
- start
;
1441 /* Get long base name for name; name is assumed to be absolute. */
1443 get_long_basename (char * name
, char * buf
, int size
)
1445 WIN32_FIND_DATA find_data
;
1449 /* must be valid filename, no wild cards or other invalid characters */
1450 if (_mbspbrk (name
, "*?|<>\""))
1453 dir_handle
= FindFirstFile (name
, &find_data
);
1454 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1456 if ((len
= strlen (find_data
.cFileName
)) < size
)
1457 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1460 FindClose (dir_handle
);
1465 /* Get long name for file, if possible (assumed to be absolute). */
1467 w32_get_long_filename (char * name
, char * buf
, int size
)
1472 char full
[ MAX_PATH
];
1475 len
= strlen (name
);
1476 if (len
>= MAX_PATH
)
1479 /* Use local copy for destructive modification. */
1480 memcpy (full
, name
, len
+1);
1481 unixtodos_filename (full
);
1483 /* Copy root part verbatim. */
1484 len
= parse_root (full
, &p
);
1485 memcpy (o
, full
, len
);
1490 while (p
!= NULL
&& *p
)
1493 p
= strchr (q
, '\\');
1495 len
= get_long_basename (full
, o
, size
);
1518 is_unc_volume (const char *filename
)
1520 const char *ptr
= filename
;
1522 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1525 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1531 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1534 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1537 HKEY hrootkey
= NULL
;
1540 /* Check both the current user and the local machine to see if
1541 we have any resources. */
1543 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1547 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1548 && (lpvalue
= xmalloc (cbData
)) != NULL
1549 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1551 RegCloseKey (hrootkey
);
1557 RegCloseKey (hrootkey
);
1560 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1564 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1565 && (lpvalue
= xmalloc (cbData
)) != NULL
1566 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1568 RegCloseKey (hrootkey
);
1574 RegCloseKey (hrootkey
);
1580 char *get_emacs_configuration (void);
1583 init_environment (char ** argv
)
1585 static const char * const tempdirs
[] = {
1586 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1591 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1593 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1594 temporary files and assume "/tmp" if $TMPDIR is unset, which
1595 will break on DOS/Windows. Refuse to work if we cannot find
1596 a directory, not even "c:/", usable for that purpose. */
1597 for (i
= 0; i
< imax
; i
++)
1599 const char *tmp
= tempdirs
[i
];
1602 tmp
= getenv (tmp
+ 1);
1603 /* Note that `access' can lie to us if the directory resides on a
1604 read-only filesystem, like CD-ROM or a write-protected floppy.
1605 The only way to be really sure is to actually create a file and
1606 see if it succeeds. But I think that's too much to ask. */
1608 /* MSVCRT's _access crashes with D_OK. */
1609 if (tmp
&& sys_access (tmp
, D_OK
) == 0)
1611 char * var
= alloca (strlen (tmp
) + 8);
1612 sprintf (var
, "TMPDIR=%s", tmp
);
1613 _putenv (strdup (var
));
1620 Fcons (build_string ("no usable temporary directories found!!"),
1622 "While setting TMPDIR: ");
1624 /* Check for environment variables and use registry settings if they
1625 don't exist. Fallback on default values where applicable. */
1630 char locale_name
[32];
1631 struct stat ignored
;
1632 char default_home
[MAX_PATH
];
1635 static const struct env_entry
1641 /* If the default value is NULL, we will use the value from the
1642 outside environment or the Registry, but will not push the
1643 variable into the Emacs environment if it is defined neither
1644 in the Registry nor in the outside environment. */
1646 {"PRELOAD_WINSOCK", NULL
},
1647 {"emacs_dir", "C:/emacs"},
1648 {"EMACSLOADPATH", NULL
},
1649 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1650 {"EMACSDATA", NULL
},
1651 {"EMACSPATH", NULL
},
1658 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1660 /* We need to copy dflt_envvars[] and work on the copy because we
1661 don't want the dumped Emacs to inherit the values of
1662 environment variables we saw during dumping (which could be on
1663 a different system). The defaults above must be left intact. */
1664 struct env_entry env_vars
[N_ENV_VARS
];
1666 for (i
= 0; i
< N_ENV_VARS
; i
++)
1667 env_vars
[i
] = dflt_envvars
[i
];
1669 /* For backwards compatibility, check if a .emacs file exists in C:/
1670 If not, then we can try to default to the appdata directory under the
1671 user's profile, which is more likely to be writable. */
1672 if (stat ("C:/.emacs", &ignored
) < 0)
1674 HRESULT profile_result
;
1675 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1676 of Windows 95 and NT4 that have not been updated to include
1678 ShGetFolderPath_fn get_folder_path
;
1679 get_folder_path
= (ShGetFolderPath_fn
)
1680 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1682 if (get_folder_path
!= NULL
)
1684 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1687 /* If we can't get the appdata dir, revert to old behavior. */
1688 if (profile_result
== S_OK
)
1690 env_vars
[0].def_value
= default_home
;
1696 /* Get default locale info and use it for LANG. */
1697 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1698 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1699 locale_name
, sizeof (locale_name
)))
1701 for (i
= 0; i
< N_ENV_VARS
; i
++)
1703 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1705 env_vars
[i
].def_value
= locale_name
;
1711 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1713 /* Treat emacs_dir specially: set it unconditionally based on our
1717 char modname
[MAX_PATH
];
1719 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1721 if ((p
= strrchr (modname
, '\\')) == NULL
)
1725 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
1727 char buf
[SET_ENV_BUF_SIZE
];
1730 for (p
= modname
; *p
; p
++)
1731 if (*p
== '\\') *p
= '/';
1733 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1734 _putenv (strdup (buf
));
1736 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1738 /* FIXME: should use substring of get_emacs_configuration ().
1739 But I don't think the Windows build supports alpha, mips etc
1740 anymore, so have taken the easy option for now. */
1741 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
1742 || xstrcasecmp (p
, "\\AMD64") == 0))
1745 p
= strrchr (modname
, '\\');
1749 p
= strrchr (modname
, '\\');
1750 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1752 char buf
[SET_ENV_BUF_SIZE
];
1755 for (p
= modname
; *p
; p
++)
1756 if (*p
== '\\') *p
= '/';
1758 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1759 _putenv (strdup (buf
));
1765 for (i
= 0; i
< N_ENV_VARS
; i
++)
1767 if (!getenv (env_vars
[i
].name
))
1771 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1772 /* Also ignore empty environment variables. */
1776 lpval
= env_vars
[i
].def_value
;
1777 dwType
= REG_EXPAND_SZ
;
1779 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
1780 Vdelayed_warnings_list
1781 = Fcons (listn (CONSTYPE_HEAP
, 2,
1782 intern ("initialization"),
1783 build_string ("Setting HOME to C:\\ by default is deprecated")),
1784 Vdelayed_warnings_list
);
1789 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1791 if (dwType
== REG_EXPAND_SZ
)
1792 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1793 else if (dwType
== REG_SZ
)
1794 strcpy (buf1
, lpval
);
1795 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1797 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1799 _putenv (strdup (buf2
));
1809 /* Rebuild system configuration to reflect invoking system. */
1810 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1812 /* Another special case: on NT, the PATH variable is actually named
1813 "Path" although cmd.exe (perhaps NT itself) arranges for
1814 environment variable lookup and setting to be case insensitive.
1815 However, Emacs assumes a fully case sensitive environment, so we
1816 need to change "Path" to "PATH" to match the expectations of
1817 various elisp packages. We do this by the sneaky method of
1818 modifying the string in the C runtime environ entry.
1820 The same applies to COMSPEC. */
1824 for (envp
= environ
; *envp
; envp
++)
1825 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1826 memcpy (*envp
, "PATH=", 5);
1827 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1828 memcpy (*envp
, "COMSPEC=", 8);
1831 /* Remember the initial working directory for getwd. */
1832 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
1833 Does it matter anywhere in Emacs? */
1834 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1838 static char modname
[MAX_PATH
];
1840 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1845 /* Determine if there is a middle mouse button, to allow parse_button
1846 to decide whether right mouse events should be mouse-2 or
1848 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1853 /* Called from expand-file-name when default-directory is not a string. */
1856 emacs_root_dir (void)
1858 static char root_dir
[FILENAME_MAX
];
1861 p
= getenv ("emacs_dir");
1864 strcpy (root_dir
, p
);
1865 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1866 dostounix_filename (root_dir
);
1870 /* We don't have scripts to automatically determine the system configuration
1871 for Emacs before it's compiled, and we don't want to have to make the
1872 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1876 get_emacs_configuration (void)
1878 char *arch
, *oem
, *os
;
1880 static char configuration_buffer
[32];
1882 /* Determine the processor type. */
1883 switch (get_processor_type ())
1886 #ifdef PROCESSOR_INTEL_386
1887 case PROCESSOR_INTEL_386
:
1888 case PROCESSOR_INTEL_486
:
1889 case PROCESSOR_INTEL_PENTIUM
:
1897 #ifdef PROCESSOR_AMD_X8664
1898 case PROCESSOR_AMD_X8664
:
1903 #ifdef PROCESSOR_MIPS_R2000
1904 case PROCESSOR_MIPS_R2000
:
1905 case PROCESSOR_MIPS_R3000
:
1906 case PROCESSOR_MIPS_R4000
:
1911 #ifdef PROCESSOR_ALPHA_21064
1912 case PROCESSOR_ALPHA_21064
:
1922 /* Use the OEM field to reflect the compiler/library combination. */
1924 #define COMPILER_NAME "msvc"
1927 #define COMPILER_NAME "mingw"
1929 #define COMPILER_NAME "unknown"
1932 oem
= COMPILER_NAME
;
1934 switch (osinfo_cache
.dwPlatformId
) {
1935 case VER_PLATFORM_WIN32_NT
:
1937 build_num
= osinfo_cache
.dwBuildNumber
;
1939 case VER_PLATFORM_WIN32_WINDOWS
:
1940 if (osinfo_cache
.dwMinorVersion
== 0) {
1945 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1947 case VER_PLATFORM_WIN32s
:
1948 /* Not supported, should not happen. */
1950 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1958 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1959 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1960 get_w32_major_version (), get_w32_minor_version (), build_num
);
1962 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1965 return configuration_buffer
;
1969 get_emacs_configuration_options (void)
1971 static char *options_buffer
;
1972 char cv
[32]; /* Enough for COMPILER_VERSION. */
1974 cv
, /* To be filled later. */
1978 #ifdef ENABLE_CHECKING
1979 " --enable-checking",
1981 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1982 with a starting space to save work here. */
1984 " --cflags", USER_CFLAGS
,
1987 " --ldflags", USER_LDFLAGS
,
1994 /* Work out the effective configure options for this build. */
1996 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1999 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2001 #define COMPILER_VERSION ""
2005 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2006 return "Error: not enough space for compiler version";
2007 cv
[sizeof (cv
) - 1] = '\0';
2009 for (i
= 0; options
[i
]; i
++)
2010 size
+= strlen (options
[i
]);
2012 options_buffer
= xmalloc (size
+ 1);
2013 options_buffer
[0] = '\0';
2015 for (i
= 0; options
[i
]; i
++)
2016 strcat (options_buffer
, options
[i
]);
2018 return options_buffer
;
2022 #include <sys/timeb.h>
2024 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2026 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2031 tv
->tv_sec
= tb
.time
;
2032 tv
->tv_usec
= tb
.millitm
* 1000L;
2033 /* Implementation note: _ftime sometimes doesn't update the dstflag
2034 according to the new timezone when the system timezone is
2035 changed. We could fix that by using GetSystemTime and
2036 GetTimeZoneInformation, but that doesn't seem necessary, since
2037 Emacs always calls gettimeofday with the 2nd argument NULL (see
2038 current_emacs_time). */
2041 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2042 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2046 /* Emulate fdutimens. */
2048 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2049 TIMESPEC[0] and TIMESPEC[1], respectively.
2050 FD must be either negative -- in which case it is ignored --
2051 or a file descriptor that is open on FILE.
2052 If FD is nonnegative, then FILE can be NULL, which means
2053 use just futimes instead of utimes.
2054 If TIMESPEC is null, FAIL.
2055 Return 0 on success, -1 (setting errno) on failure. */
2058 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2067 if (fd
< 0 && !file
)
2072 ut
.actime
= timespec
[0].tv_sec
;
2073 ut
.modtime
= timespec
[1].tv_sec
;
2075 return _futime (fd
, &ut
);
2077 return _utime (file
, &ut
);
2081 /* ------------------------------------------------------------------------- */
2082 /* IO support and wrapper functions for the Windows API. */
2083 /* ------------------------------------------------------------------------- */
2085 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2086 on network directories, so we handle that case here.
2087 (Ulrich Leodolter, 1/11/95). */
2089 sys_ctime (const time_t *t
)
2091 char *str
= (char *) ctime (t
);
2092 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2095 /* Emulate sleep...we could have done this with a define, but that
2096 would necessitate including windows.h in the files that used it.
2097 This is much easier. */
2099 sys_sleep (int seconds
)
2101 Sleep (seconds
* 1000);
2104 /* Internal MSVC functions for low-level descriptor munging */
2105 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2106 extern int __cdecl
_free_osfhnd (int fd
);
2108 /* parallel array of private info on file handles */
2109 filedesc fd_info
[ MAXDESC
];
2111 typedef struct volume_info_data
{
2112 struct volume_info_data
* next
;
2114 /* time when info was obtained */
2117 /* actual volume info */
2126 /* Global referenced by various functions. */
2127 static volume_info_data volume_info
;
2129 /* Vector to indicate which drives are local and fixed (for which cached
2130 data never expires). */
2131 static BOOL fixed_drives
[26];
2133 /* Consider cached volume information to be stale if older than 10s,
2134 at least for non-local drives. Info for fixed drives is never stale. */
2135 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2136 #define VOLINFO_STILL_VALID( root_dir, info ) \
2137 ( ( isalpha (root_dir[0]) && \
2138 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2139 || GetTickCount () - info->timestamp < 10000 )
2141 /* Cache support functions. */
2143 /* Simple linked list with linear search is sufficient. */
2144 static volume_info_data
*volume_cache
= NULL
;
2146 static volume_info_data
*
2147 lookup_volume_info (char * root_dir
)
2149 volume_info_data
* info
;
2151 for (info
= volume_cache
; info
; info
= info
->next
)
2152 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2158 add_volume_info (char * root_dir
, volume_info_data
* info
)
2160 info
->root_dir
= xstrdup (root_dir
);
2161 info
->next
= volume_cache
;
2162 volume_cache
= info
;
2166 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2167 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2168 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2169 static volume_info_data
*
2170 GetCachedVolumeInformation (char * root_dir
)
2172 volume_info_data
* info
;
2173 char default_root
[ MAX_PATH
];
2175 /* NULL for root_dir means use root from current directory. */
2176 if (root_dir
== NULL
)
2178 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2180 parse_root (default_root
, &root_dir
);
2182 root_dir
= default_root
;
2185 /* Local fixed drives can be cached permanently. Removable drives
2186 cannot be cached permanently, since the volume name and serial
2187 number (if nothing else) can change. Remote drives should be
2188 treated as if they are removable, since there is no sure way to
2189 tell whether they are or not. Also, the UNC association of drive
2190 letters mapped to remote volumes can be changed at any time (even
2191 by other processes) without notice.
2193 As a compromise, so we can benefit from caching info for remote
2194 volumes, we use a simple expiry mechanism to invalidate cache
2195 entries that are more than ten seconds old. */
2198 /* No point doing this, because WNetGetConnection is even slower than
2199 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2200 GetDriveType is about the only call of this type which does not
2201 involve network access, and so is extremely quick). */
2203 /* Map drive letter to UNC if remote. */
2204 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2206 char remote_name
[ 256 ];
2207 char drive
[3] = { root_dir
[0], ':' };
2209 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2211 /* do something */ ;
2215 info
= lookup_volume_info (root_dir
);
2217 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2225 /* Info is not cached, or is stale. */
2226 if (!GetVolumeInformation (root_dir
,
2227 name
, sizeof (name
),
2231 type
, sizeof (type
)))
2234 /* Cache the volume information for future use, overwriting existing
2235 entry if present. */
2238 info
= xmalloc (sizeof (volume_info_data
));
2239 add_volume_info (root_dir
, info
);
2247 info
->name
= xstrdup (name
);
2248 info
->serialnum
= serialnum
;
2249 info
->maxcomp
= maxcomp
;
2250 info
->flags
= flags
;
2251 info
->type
= xstrdup (type
);
2252 info
->timestamp
= GetTickCount ();
2258 /* Get information on the volume where NAME is held; set path pointer to
2259 start of pathname in NAME (past UNC header\volume header if present),
2260 if pPath is non-NULL.
2262 Note: if NAME includes symlinks, the information is for the volume
2263 of the symlink, not of its target. That's because, even though
2264 GetVolumeInformation returns information about the symlink target
2265 of its argument, we only pass the root directory to
2266 GetVolumeInformation, not the full NAME. */
2268 get_volume_info (const char * name
, const char ** pPath
)
2270 char temp
[MAX_PATH
];
2271 char *rootname
= NULL
; /* default to current volume */
2272 volume_info_data
* info
;
2277 /* Find the root name of the volume if given. */
2278 if (isalpha (name
[0]) && name
[1] == ':')
2286 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2293 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2306 info
= GetCachedVolumeInformation (rootname
);
2309 /* Set global referenced by other functions. */
2310 volume_info
= *info
;
2316 /* Determine if volume is FAT format (ie. only supports short 8.3
2317 names); also set path pointer to start of pathname in name, if
2318 pPath is non-NULL. */
2320 is_fat_volume (const char * name
, const char ** pPath
)
2322 if (get_volume_info (name
, pPath
))
2323 return (volume_info
.maxcomp
== 12);
2327 /* Map filename to a valid 8.3 name if necessary.
2328 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2330 map_w32_filename (const char * name
, const char ** pPath
)
2332 static char shortname
[MAX_PATH
];
2333 char * str
= shortname
;
2336 const char * save_name
= name
;
2338 if (strlen (name
) >= MAX_PATH
)
2340 /* Return a filename which will cause callers to fail. */
2341 strcpy (shortname
, "?");
2345 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2347 register int left
= 8; /* maximum number of chars in part */
2348 register int extn
= 0; /* extension added? */
2349 register int dots
= 2; /* maximum number of dots allowed */
2352 *str
++ = *name
++; /* skip past UNC header */
2354 while ((c
= *name
++))
2361 *str
++ = (c
== ':' ? ':' : '\\');
2362 extn
= 0; /* reset extension flags */
2363 dots
= 2; /* max 2 dots */
2364 left
= 8; /* max length 8 for main part */
2369 /* Convert path components of the form .xxx to _xxx,
2370 but leave . and .. as they are. This allows .emacs
2371 to be read as _emacs, for example. */
2375 IS_DIRECTORY_SEP (*name
))
2390 extn
= 1; /* we've got an extension */
2391 left
= 3; /* 3 chars in extension */
2395 /* any embedded dots after the first are converted to _ */
2400 case '#': /* don't lose these, they're important */
2402 str
[-1] = c
; /* replace last character of part */
2407 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2409 dots
= 0; /* started a path component */
2418 strcpy (shortname
, name
);
2419 unixtodos_filename (shortname
);
2423 *pPath
= shortname
+ (path
- save_name
);
2429 is_exec (const char * name
)
2431 char * p
= strrchr (name
, '.');
2434 && (xstrcasecmp (p
, ".exe") == 0 ||
2435 xstrcasecmp (p
, ".com") == 0 ||
2436 xstrcasecmp (p
, ".bat") == 0 ||
2437 xstrcasecmp (p
, ".cmd") == 0));
2440 /* Emulate the Unix directory procedures opendir, closedir,
2441 and readdir. We can't use the procedures supplied in sysdep.c,
2442 so we provide them here. */
2444 struct direct dir_static
; /* simulated directory contents */
2445 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2446 static int dir_is_fat
;
2447 static char dir_pathname
[MAXPATHLEN
+1];
2448 static WIN32_FIND_DATA dir_find_data
;
2450 /* Support shares on a network resource as subdirectories of a read-only
2452 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2453 static HANDLE
open_unc_volume (const char *);
2454 static char *read_unc_volume (HANDLE
, char *, int);
2455 static void close_unc_volume (HANDLE
);
2458 opendir (char *filename
)
2462 /* Opening is done by FindFirstFile. However, a read is inherent to
2463 this operation, so we defer the open until read time. */
2465 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2467 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2470 /* Note: We don't support traversal of UNC volumes via symlinks.
2471 Doing so would mean punishing 99.99% of use cases by resolving
2472 all the possible symlinks in FILENAME, recursively. */
2473 if (is_unc_volume (filename
))
2475 wnet_enum_handle
= open_unc_volume (filename
);
2476 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2480 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2487 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2488 dir_pathname
[MAXPATHLEN
] = '\0';
2489 /* Note: We don't support symlinks to file names on FAT volumes.
2490 Doing so would mean punishing 99.99% of use cases by resolving
2491 all the possible symlinks in FILENAME, recursively. */
2492 dir_is_fat
= is_fat_volume (filename
, NULL
);
2498 closedir (DIR *dirp
)
2500 /* If we have a find-handle open, close it. */
2501 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2503 FindClose (dir_find_handle
);
2504 dir_find_handle
= INVALID_HANDLE_VALUE
;
2506 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2508 close_unc_volume (wnet_enum_handle
);
2509 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2511 xfree ((char *) dirp
);
2517 int downcase
= !NILP (Vw32_downcase_file_names
);
2519 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2521 if (!read_unc_volume (wnet_enum_handle
,
2522 dir_find_data
.cFileName
,
2526 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2527 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2529 char filename
[MAXNAMLEN
+ 3];
2532 strcpy (filename
, dir_pathname
);
2533 ln
= strlen (filename
) - 1;
2534 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2535 strcat (filename
, "\\");
2536 strcat (filename
, "*");
2538 /* Note: No need to resolve symlinks in FILENAME, because
2539 FindFirst opens the directory that is the target of a
2541 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2543 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2548 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2552 /* Emacs never uses this value, so don't bother making it match
2553 value returned by stat(). */
2554 dir_static
.d_ino
= 1;
2556 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2558 /* If the file name in cFileName[] includes `?' characters, it means
2559 the original file name used characters that cannot be represented
2560 by the current ANSI codepage. To avoid total lossage, retrieve
2561 the short 8+3 alias of the long file name. */
2562 if (_mbspbrk (dir_static
.d_name
, "?"))
2564 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2565 downcase
= 1; /* 8+3 aliases are returned in all caps */
2567 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2568 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
2569 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2571 /* If the file name in cFileName[] includes `?' characters, it means
2572 the original file name used characters that cannot be represented
2573 by the current ANSI codepage. To avoid total lossage, retrieve
2574 the short 8+3 alias of the long file name. */
2575 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2577 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2578 /* 8+3 aliases are returned in all caps, which could break
2579 various alists that look at filenames' extensions. */
2583 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2584 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2586 _strlwr (dir_static
.d_name
);
2590 for (p
= dir_static
.d_name
; *p
; p
++)
2591 if (*p
>= 'a' && *p
<= 'z')
2594 _strlwr (dir_static
.d_name
);
2601 open_unc_volume (const char *path
)
2607 nr
.dwScope
= RESOURCE_GLOBALNET
;
2608 nr
.dwType
= RESOURCETYPE_DISK
;
2609 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2610 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2611 nr
.lpLocalName
= NULL
;
2612 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2613 nr
.lpComment
= NULL
;
2614 nr
.lpProvider
= NULL
;
2616 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2617 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2619 if (result
== NO_ERROR
)
2622 return INVALID_HANDLE_VALUE
;
2626 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2630 DWORD bufsize
= 512;
2635 buffer
= alloca (bufsize
);
2636 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2637 if (result
!= NO_ERROR
)
2640 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2641 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2643 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2646 strncpy (readbuf
, ptr
, size
);
2651 close_unc_volume (HANDLE henum
)
2653 if (henum
!= INVALID_HANDLE_VALUE
)
2654 WNetCloseEnum (henum
);
2658 unc_volume_file_attributes (const char *path
)
2663 henum
= open_unc_volume (path
);
2664 if (henum
== INVALID_HANDLE_VALUE
)
2667 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2669 close_unc_volume (henum
);
2674 /* Ensure a network connection is authenticated. */
2676 logon_network_drive (const char *path
)
2678 NETRESOURCE resource
;
2679 char share
[MAX_PATH
];
2684 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2685 drvtype
= DRIVE_REMOTE
;
2686 else if (path
[0] == '\0' || path
[1] != ':')
2687 drvtype
= GetDriveType (NULL
);
2694 drvtype
= GetDriveType (drive
);
2697 /* Only logon to networked drives. */
2698 if (drvtype
!= DRIVE_REMOTE
)
2702 strncpy (share
, path
, MAX_PATH
);
2703 /* Truncate to just server and share name. */
2704 for (i
= 2; i
< MAX_PATH
; i
++)
2706 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2713 resource
.dwType
= RESOURCETYPE_DISK
;
2714 resource
.lpLocalName
= NULL
;
2715 resource
.lpRemoteName
= share
;
2716 resource
.lpProvider
= NULL
;
2718 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2721 /* Shadow some MSVC runtime functions to map requests for long filenames
2722 to reasonable short names if necessary. This was originally added to
2723 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2727 sys_access (const char * path
, int mode
)
2731 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
2732 newer versions blow up when passed D_OK. */
2733 path
= map_w32_filename (path
, NULL
);
2734 /* If the last element of PATH is a symlink, we need to resolve it
2735 to get the attributes of its target file. Note: any symlinks in
2736 PATH elements other than the last one are transparently resolved
2737 by GetFileAttributes below. */
2738 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
2739 path
= chase_symlinks (path
);
2741 if ((attributes
= GetFileAttributes (path
)) == -1)
2743 DWORD w32err
= GetLastError ();
2747 case ERROR_INVALID_NAME
:
2748 case ERROR_BAD_PATHNAME
:
2749 if (is_unc_volume (path
))
2751 attributes
= unc_volume_file_attributes (path
);
2752 if (attributes
== -1)
2760 case ERROR_FILE_NOT_FOUND
:
2761 case ERROR_BAD_NETPATH
:
2770 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2775 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2780 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2789 sys_chdir (const char * path
)
2791 return _chdir (map_w32_filename (path
, NULL
));
2795 sys_chmod (const char * path
, int mode
)
2797 path
= chase_symlinks (map_w32_filename (path
, NULL
));
2798 return _chmod (path
, mode
);
2802 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2804 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2810 sys_creat (const char * path
, int mode
)
2812 return _creat (map_w32_filename (path
, NULL
), mode
);
2816 sys_fopen (const char * path
, const char * mode
)
2820 const char * mode_save
= mode
;
2822 /* Force all file handles to be non-inheritable. This is necessary to
2823 ensure child processes don't unwittingly inherit handles that might
2824 prevent future file access. */
2828 else if (mode
[0] == 'w' || mode
[0] == 'a')
2829 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2833 /* Only do simplistic option parsing. */
2837 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2840 else if (mode
[0] == 'b')
2845 else if (mode
[0] == 't')
2852 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2856 return _fdopen (fd
, mode_save
);
2859 /* This only works on NTFS volumes, but is useful to have. */
2861 sys_link (const char * old
, const char * new)
2865 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2867 if (old
== NULL
|| new == NULL
)
2873 strcpy (oldname
, map_w32_filename (old
, NULL
));
2874 strcpy (newname
, map_w32_filename (new, NULL
));
2876 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2877 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2878 if (fileh
!= INVALID_HANDLE_VALUE
)
2882 /* Confusingly, the "alternate" stream name field does not apply
2883 when restoring a hard link, and instead contains the actual
2884 stream data for the link (ie. the name of the link to create).
2885 The WIN32_STREAM_ID structure before the cStreamName field is
2886 the stream header, which is then immediately followed by the
2890 WIN32_STREAM_ID wid
;
2891 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2894 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2895 data
.wid
.cStreamName
, MAX_PATH
);
2898 LPVOID context
= NULL
;
2901 data
.wid
.dwStreamId
= BACKUP_LINK
;
2902 data
.wid
.dwStreamAttributes
= 0;
2903 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
2904 data
.wid
.Size
.HighPart
= 0;
2905 data
.wid
.dwStreamNameSize
= 0;
2907 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2908 offsetof (WIN32_STREAM_ID
, cStreamName
)
2909 + data
.wid
.Size
.LowPart
,
2910 &wbytes
, FALSE
, FALSE
, &context
)
2911 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2918 /* Should try mapping GetLastError to errno; for now just
2919 indicate a general error (eg. links not supported). */
2920 errno
= EINVAL
; // perhaps EMLINK?
2924 CloseHandle (fileh
);
2933 sys_mkdir (const char * path
)
2935 return _mkdir (map_w32_filename (path
, NULL
));
2938 /* Because of long name mapping issues, we need to implement this
2939 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2940 a unique name, instead of setting the input template to an empty
2943 Standard algorithm seems to be use pid or tid with a letter on the
2944 front (in place of the 6 X's) and cycle through the letters to find a
2945 unique name. We extend that to allow any reasonable character as the
2946 first of the 6 X's. */
2948 sys_mktemp (char * template)
2952 unsigned uid
= GetCurrentThreadId ();
2953 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2955 if (template == NULL
)
2957 p
= template + strlen (template);
2959 /* replace up to the last 5 X's with uid in decimal */
2960 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2962 p
[0] = '0' + uid
% 10;
2966 if (i
< 0 && p
[0] == 'X')
2971 int save_errno
= errno
;
2972 p
[0] = first_char
[i
];
2973 if (sys_access (template, 0) < 0)
2979 while (++i
< sizeof (first_char
));
2982 /* Template is badly formed or else we can't generate a unique name,
2983 so return empty string */
2989 sys_open (const char * path
, int oflag
, int mode
)
2991 const char* mpath
= map_w32_filename (path
, NULL
);
2992 /* Try to open file without _O_CREAT, to be able to write to hidden
2993 and system files. Force all file handles to be
2995 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2998 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3002 sys_rename (const char * oldname
, const char * newname
)
3005 char temp
[MAX_PATH
];
3009 /* MoveFile on Windows 95 doesn't correctly change the short file name
3010 alias in a number of circumstances (it is not easy to predict when
3011 just by looking at oldname and newname, unfortunately). In these
3012 cases, renaming through a temporary name avoids the problem.
3014 A second problem on Windows 95 is that renaming through a temp name when
3015 newname is uppercase fails (the final long name ends up in
3016 lowercase, although the short alias might be uppercase) UNLESS the
3017 long temp name is not 8.3.
3019 So, on Windows 95 we always rename through a temp name, and we make sure
3020 the temp name has a long extension to ensure correct renaming. */
3022 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3024 /* volume_info is set indirectly by map_w32_filename. */
3025 oldname_dev
= volume_info
.serialnum
;
3027 if (os_subtype
== OS_9X
)
3033 oldname
= map_w32_filename (oldname
, NULL
);
3034 if ((o
= strrchr (oldname
, '\\')))
3037 o
= (char *) oldname
;
3039 if ((p
= strrchr (temp
, '\\')))
3046 /* Force temp name to require a manufactured 8.3 alias - this
3047 seems to make the second rename work properly. */
3048 sprintf (p
, "_.%s.%u", o
, i
);
3050 result
= rename (oldname
, temp
);
3052 /* This loop must surely terminate! */
3053 while (result
< 0 && errno
== EEXIST
);
3058 /* Emulate Unix behavior - newname is deleted if it already exists
3059 (at least if it is a file; don't do this for directories).
3061 Since we mustn't do this if we are just changing the case of the
3062 file name (we would end up deleting the file we are trying to
3063 rename!), we let rename detect if the destination file already
3064 exists - that way we avoid the possible pitfalls of trying to
3065 determine ourselves whether two names really refer to the same
3066 file, which is not always possible in the general case. (Consider
3067 all the permutations of shared or subst'd drives, etc.) */
3069 newname
= map_w32_filename (newname
, NULL
);
3071 /* volume_info is set indirectly by map_w32_filename. */
3072 newname_dev
= volume_info
.serialnum
;
3074 result
= rename (temp
, newname
);
3078 DWORD w32err
= GetLastError ();
3081 && newname_dev
!= oldname_dev
)
3083 /* The implementation of `rename' on Windows does not return
3084 errno = EXDEV when you are moving a directory to a
3085 different storage device (ex. logical disk). It returns
3086 EACCES instead. So here we handle such situations and
3090 if ((attributes
= GetFileAttributes (temp
)) != -1
3091 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3094 else if (errno
== EEXIST
)
3096 if (_chmod (newname
, 0666) != 0)
3098 if (_unlink (newname
) != 0)
3100 result
= rename (temp
, newname
);
3102 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3103 && is_symlink (temp
))
3105 /* This is Windows prohibiting the user from creating a
3106 symlink in another place, since that requires
3116 sys_rmdir (const char * path
)
3118 return _rmdir (map_w32_filename (path
, NULL
));
3122 sys_unlink (const char * path
)
3124 path
= map_w32_filename (path
, NULL
);
3126 /* On Unix, unlink works without write permission. */
3127 _chmod (path
, 0666);
3128 return _unlink (path
);
3131 static FILETIME utc_base_ft
;
3132 static ULONGLONG utc_base
; /* In 100ns units */
3133 static int init
= 0;
3135 #define FILETIME_TO_U64(result, ft) \
3137 ULARGE_INTEGER uiTemp; \
3138 uiTemp.LowPart = (ft).dwLowDateTime; \
3139 uiTemp.HighPart = (ft).dwHighDateTime; \
3140 result = uiTemp.QuadPart; \
3144 initialize_utc_base (void)
3146 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3155 st
.wMilliseconds
= 0;
3157 SystemTimeToFileTime (&st
, &utc_base_ft
);
3158 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3162 convert_time (FILETIME ft
)
3168 initialize_utc_base ();
3172 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3175 FILETIME_TO_U64 (tmp
, ft
);
3176 return (time_t) ((tmp
- utc_base
) / 10000000L);
3180 convert_from_time_t (time_t time
, FILETIME
* pft
)
3186 initialize_utc_base ();
3190 /* time in 100ns units since 1-Jan-1601 */
3191 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3192 pft
->dwHighDateTime
= tmp
.HighPart
;
3193 pft
->dwLowDateTime
= tmp
.LowPart
;
3197 /* No reason to keep this; faking inode values either by hashing or even
3198 using the file index from GetInformationByHandle, is not perfect and
3199 so by default Emacs doesn't use the inode values on Windows.
3200 Instead, we now determine file-truename correctly (except for
3201 possible drive aliasing etc). */
3203 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3205 hashval (const unsigned char * str
)
3210 h
= (h
<< 4) + *str
++;
3216 /* Return the hash value of the canonical pathname, excluding the
3217 drive/UNC header, to get a hopefully unique inode number. */
3219 generate_inode_val (const char * name
)
3221 char fullname
[ MAX_PATH
];
3225 /* Get the truly canonical filename, if it exists. (Note: this
3226 doesn't resolve aliasing due to subst commands, or recognize hard
3228 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3231 parse_root (fullname
, &p
);
3232 /* Normal W32 filesystems are still case insensitive. */
3239 static PSECURITY_DESCRIPTOR
3240 get_file_security_desc_by_handle (HANDLE h
)
3242 PSECURITY_DESCRIPTOR psd
= NULL
;
3244 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3245 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3247 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3248 NULL
, NULL
, NULL
, NULL
, &psd
);
3249 if (err
!= ERROR_SUCCESS
)
3255 static PSECURITY_DESCRIPTOR
3256 get_file_security_desc_by_name (const char *fname
)
3258 PSECURITY_DESCRIPTOR psd
= NULL
;
3260 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3261 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3263 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3265 err
= GetLastError ();
3266 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3270 psd
= xmalloc (sd_len
);
3271 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3283 unsigned n_subauthorities
;
3285 /* Use the last sub-authority value of the RID, the relative
3286 portion of the SID, as user/group ID. */
3287 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3288 if (n_subauthorities
< 1)
3289 return 0; /* the "World" RID */
3290 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3293 /* Caching SID and account values for faster lokup. */
3296 # define FLEXIBLE_ARRAY_MEMBER
3298 # define FLEXIBLE_ARRAY_MEMBER 1
3303 struct w32_id
*next
;
3305 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3308 static struct w32_id
*w32_idlist
;
3311 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3313 struct w32_id
*tail
, *found
;
3315 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3317 if (equal_sid ((PSID
)tail
->sid
, sid
))
3326 strcpy (name
, found
->name
);
3334 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3337 struct w32_id
*new_entry
;
3339 /* We don't want to leave behind stale cache from when Emacs was
3343 sid_len
= get_length_sid (sid
);
3344 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3347 new_entry
->rid
= id
;
3348 strcpy (new_entry
->name
, name
);
3349 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3350 new_entry
->next
= w32_idlist
;
3351 w32_idlist
= new_entry
;
3360 get_name_and_id (PSECURITY_DESCRIPTOR psd
, const char *fname
,
3361 unsigned *id
, char *nm
, int what
)
3364 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3366 SID_NAME_USE ignore
;
3368 DWORD name_len
= sizeof (name
);
3370 DWORD domain_len
= sizeof (domain
);
3376 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3377 else if (what
== GID
)
3378 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3382 if (!result
|| !is_valid_sid (sid
))
3384 else if (!w32_cached_id (sid
, id
, nm
))
3386 /* If FNAME is a UNC, we need to lookup account on the
3387 specified machine. */
3388 if (IS_DIRECTORY_SEP (fname
[0]) && IS_DIRECTORY_SEP (fname
[1])
3389 && fname
[2] != '\0')
3394 for (s
= fname
+ 2, p
= machine
;
3395 *s
&& !IS_DIRECTORY_SEP (*s
); s
++, p
++)
3401 if (!lookup_account_sid (mp
, sid
, name
, &name_len
,
3402 domain
, &domain_len
, &ignore
)
3403 || name_len
> UNLEN
+1)
3407 *id
= get_rid (sid
);
3409 w32_add_to_cache (sid
, *id
, name
);
3416 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
,
3420 int dflt_usr
= 0, dflt_grp
= 0;
3429 if (get_name_and_id (psd
, fname
, &st
->st_uid
, st
->st_uname
, UID
))
3431 if (get_name_and_id (psd
, fname
, &st
->st_gid
, st
->st_gname
, GID
))
3434 /* Consider files to belong to current user/group, if we cannot get
3435 more accurate information. */
3438 st
->st_uid
= dflt_passwd
.pw_uid
;
3439 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3443 st
->st_gid
= dflt_passwd
.pw_gid
;
3444 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3448 /* Return non-zero if NAME is a potentially slow filesystem. */
3450 is_slow_fs (const char *name
)
3455 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3456 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3457 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3458 devtype
= GetDriveType (NULL
); /* use root of current drive */
3461 /* GetDriveType needs the root directory of the drive. */
3462 strncpy (drive_root
, name
, 2);
3463 drive_root
[2] = '\\';
3464 drive_root
[3] = '\0';
3465 devtype
= GetDriveType (drive_root
);
3467 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3470 /* MSVC stat function can't cope with UNC names and has other bugs, so
3471 replace it with our own. This also allows us to calculate consistent
3472 inode values and owner/group without hacks in the main Emacs code. */
3475 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3477 char *name
, *save_name
, *r
;
3478 WIN32_FIND_DATA wfd
;
3480 unsigned __int64 fake_inode
= 0;
3483 int rootdir
= FALSE
;
3484 PSECURITY_DESCRIPTOR psd
= NULL
;
3485 int is_a_symlink
= 0;
3486 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3487 DWORD access_rights
= 0;
3488 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3489 FILETIME ctime
, atime
, wtime
;
3491 if (path
== NULL
|| buf
== NULL
)
3497 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3498 /* Must be valid filename, no wild cards or other invalid
3499 characters. We use _mbspbrk to support multibyte strings that
3500 might look to strpbrk as if they included literal *, ?, and other
3501 characters mentioned below that are disallowed by Windows
3503 if (_mbspbrk (name
, "*?|<>\""))
3509 /* Remove trailing directory separator, unless name is the root
3510 directory of a drive or UNC volume in which case ensure there
3511 is a trailing separator. */
3512 len
= strlen (name
);
3513 name
= strcpy (alloca (len
+ 2), name
);
3515 /* Avoid a somewhat costly call to is_symlink if the filesystem
3516 doesn't support symlinks. */
3517 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3518 is_a_symlink
= is_symlink (name
);
3520 /* Plan A: Open the file and get all the necessary information via
3521 the resulting handle. This solves several issues in one blow:
3523 . retrieves attributes for the target of a symlink, if needed
3524 . gets attributes of root directories and symlinks pointing to
3525 root directories, thus avoiding the need for special-casing
3526 these and detecting them by examining the file-name format
3527 . retrieves more accurate attributes (e.g., non-zero size for
3528 some directories, esp. directories that are junction points)
3529 . correctly resolves "c:/..", "/.." and similar file names
3530 . avoids run-time penalties for 99% of use cases
3532 Plan A is always tried first, unless the user asked not to (but
3533 if the file is a symlink and we need to follow links, we try Plan
3534 A even if the user asked not to).
3536 If Plan A fails, we go to Plan B (below), where various
3537 potentially expensive techniques must be used to handle "special"
3538 files such as UNC volumes etc. */
3539 if (!(NILP (Vw32_get_true_file_attributes
)
3540 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3541 /* Following symlinks requires getting the info by handle. */
3542 || (is_a_symlink
&& follow_symlinks
))
3544 BY_HANDLE_FILE_INFORMATION info
;
3546 if (is_a_symlink
&& !follow_symlinks
)
3547 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3548 /* READ_CONTROL access rights are required to get security info
3549 by handle. But if the OS doesn't support security in the
3550 first place, we don't need to try. */
3551 if (is_windows_9x () != TRUE
)
3552 access_rights
|= READ_CONTROL
;
3554 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3556 /* If CreateFile fails with READ_CONTROL, try again with zero as
3558 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3559 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3561 if (fh
== INVALID_HANDLE_VALUE
)
3562 goto no_true_file_attributes
;
3564 /* This is more accurate in terms of getting the correct number
3565 of links, but is quite slow (it is noticeable when Emacs is
3566 making a list of file name completions). */
3567 if (GetFileInformationByHandle (fh
, &info
))
3569 nlinks
= info
.nNumberOfLinks
;
3570 /* Might as well use file index to fake inode values, but this
3571 is not guaranteed to be unique unless we keep a handle open
3572 all the time (even then there are situations where it is
3573 not unique). Reputedly, there are at most 48 bits of info
3574 (on NTFS, presumably less on FAT). */
3575 fake_inode
= info
.nFileIndexHigh
;
3577 fake_inode
+= info
.nFileIndexLow
;
3578 serialnum
= info
.dwVolumeSerialNumber
;
3579 fs_high
= info
.nFileSizeHigh
;
3580 fs_low
= info
.nFileSizeLow
;
3581 ctime
= info
.ftCreationTime
;
3582 atime
= info
.ftLastAccessTime
;
3583 wtime
= info
.ftLastWriteTime
;
3584 fattrs
= info
.dwFileAttributes
;
3588 /* We don't go to Plan B here, because it's not clear that
3589 it's a good idea. The only known use case where
3590 CreateFile succeeds, but GetFileInformationByHandle fails
3591 (with ERROR_INVALID_FUNCTION) is for character devices
3592 such as NUL, PRN, etc. For these, switching to Plan B is
3593 a net loss, because we lose the character device
3594 attribute returned by GetFileType below (FindFirstFile
3595 doesn't set that bit in the attributes), and the other
3596 fields don't make sense for character devices anyway.
3597 Emacs doesn't really care for non-file entities in the
3598 context of l?stat, so neither do we. */
3600 /* w32err is assigned so one could put a breakpoint here and
3601 examine its value, when GetFileInformationByHandle
3603 DWORD w32err
= GetLastError ();
3607 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3613 /* Test for a symlink before testing for a directory, since
3614 symlinks to directories have the directory bit set, but we
3615 don't want them to appear as directories. */
3616 if (is_a_symlink
&& !follow_symlinks
)
3617 buf
->st_mode
= S_IFLNK
;
3618 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3619 buf
->st_mode
= S_IFDIR
;
3622 DWORD ftype
= GetFileType (fh
);
3626 case FILE_TYPE_DISK
:
3627 buf
->st_mode
= S_IFREG
;
3629 case FILE_TYPE_PIPE
:
3630 buf
->st_mode
= S_IFIFO
;
3632 case FILE_TYPE_CHAR
:
3633 case FILE_TYPE_UNKNOWN
:
3635 buf
->st_mode
= S_IFCHR
;
3638 /* We produce the fallback owner and group data, based on the
3639 current user that runs Emacs, in the following cases:
3641 . this is Windows 9X
3642 . getting security by handle failed, and we need to produce
3643 information for the target of a symlink (this is better
3644 than producing a potentially misleading info about the
3647 If getting security by handle fails, and we don't need to
3648 resolve symlinks, we try getting security by name. */
3649 if (is_windows_9x () != TRUE
)
3650 psd
= get_file_security_desc_by_handle (fh
);
3653 get_file_owner_and_group (psd
, name
, buf
);
3656 else if (is_windows_9x () == TRUE
)
3657 get_file_owner_and_group (NULL
, name
, buf
);
3658 else if (!(is_a_symlink
&& follow_symlinks
))
3660 psd
= get_file_security_desc_by_name (name
);
3661 get_file_owner_and_group (psd
, name
, buf
);
3665 get_file_owner_and_group (NULL
, name
, buf
);
3670 no_true_file_attributes
:
3671 /* Plan B: Either getting a handle on the file failed, or the
3672 caller explicitly asked us to not bother making this
3673 information more accurate.
3675 Implementation note: In Plan B, we never bother to resolve
3676 symlinks, even if we got here because we tried Plan A and
3677 failed. That's because, even if the caller asked for extra
3678 precision by setting Vw32_get_true_file_attributes to t,
3679 resolving symlinks requires acquiring a file handle to the
3680 symlink, which we already know will fail. And if the user
3681 did not ask for extra precision, resolving symlinks will fly
3682 in the face of that request, since the user then wants the
3683 lightweight version of the code. */
3684 rootdir
= (path
>= save_name
+ len
- 1
3685 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3687 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3688 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3689 if (IS_DIRECTORY_SEP (r
[0])
3690 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3693 /* Note: If NAME is a symlink to the root of a UNC volume
3694 (i.e. "\\SERVER"), we will not detect that here, and we will
3695 return data about the symlink as result of FindFirst below.
3696 This is unfortunate, but that marginal use case does not
3697 justify a call to chase_symlinks which would impose a penalty
3698 on all the other use cases. (We get here for symlinks to
3699 roots of UNC volumes because CreateFile above fails for them,
3700 unlike with symlinks to root directories X:\ of drives.) */
3701 if (is_unc_volume (name
))
3703 fattrs
= unc_volume_file_attributes (name
);
3707 ctime
= atime
= wtime
= utc_base_ft
;
3711 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3712 strcat (name
, "\\");
3713 if (GetDriveType (name
) < 2)
3719 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3720 ctime
= atime
= wtime
= utc_base_ft
;
3724 if (IS_DIRECTORY_SEP (name
[len
-1]))
3727 /* (This is hacky, but helps when doing file completions on
3728 network drives.) Optimize by using information available from
3729 active readdir if possible. */
3730 len
= strlen (dir_pathname
);
3731 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3733 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3734 && !(is_a_symlink
&& follow_symlinks
)
3735 && strnicmp (save_name
, dir_pathname
, len
) == 0
3736 && IS_DIRECTORY_SEP (name
[len
])
3737 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3739 /* This was the last entry returned by readdir. */
3740 wfd
= dir_find_data
;
3744 logon_network_drive (name
);
3746 fh
= FindFirstFile (name
, &wfd
);
3747 if (fh
== INVALID_HANDLE_VALUE
)
3754 /* Note: if NAME is a symlink, the information we get from
3755 FindFirstFile is for the symlink, not its target. */
3756 fattrs
= wfd
.dwFileAttributes
;
3757 ctime
= wfd
.ftCreationTime
;
3758 atime
= wfd
.ftLastAccessTime
;
3759 wtime
= wfd
.ftLastWriteTime
;
3760 fs_high
= wfd
.nFileSizeHigh
;
3761 fs_low
= wfd
.nFileSizeLow
;
3764 serialnum
= volume_info
.serialnum
;
3766 if (is_a_symlink
&& !follow_symlinks
)
3767 buf
->st_mode
= S_IFLNK
;
3768 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3769 buf
->st_mode
= S_IFDIR
;
3771 buf
->st_mode
= S_IFREG
;
3773 get_file_owner_and_group (NULL
, name
, buf
);
3777 /* Not sure if there is any point in this. */
3778 if (!NILP (Vw32_generate_fake_inodes
))
3779 fake_inode
= generate_inode_val (name
);
3780 else if (fake_inode
== 0)
3782 /* For want of something better, try to make everything unique. */
3783 static DWORD gen_num
= 0;
3784 fake_inode
= ++gen_num
;
3788 buf
->st_ino
= fake_inode
;
3790 buf
->st_dev
= serialnum
;
3791 buf
->st_rdev
= serialnum
;
3793 buf
->st_size
= fs_high
;
3794 buf
->st_size
<<= 32;
3795 buf
->st_size
+= fs_low
;
3796 buf
->st_nlink
= nlinks
;
3798 /* Convert timestamps to Unix format. */
3799 buf
->st_mtime
= convert_time (wtime
);
3800 buf
->st_atime
= convert_time (atime
);
3801 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3802 buf
->st_ctime
= convert_time (ctime
);
3803 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3805 /* determine rwx permissions */
3806 if (is_a_symlink
&& !follow_symlinks
)
3807 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
3810 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
3811 permission
= S_IREAD
;
3813 permission
= S_IREAD
| S_IWRITE
;
3815 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3816 permission
|= S_IEXEC
;
3817 else if (is_exec (name
))
3818 permission
|= S_IEXEC
;
3821 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3827 stat (const char * path
, struct stat
* buf
)
3829 return stat_worker (path
, buf
, 1);
3833 lstat (const char * path
, struct stat
* buf
)
3835 return stat_worker (path
, buf
, 0);
3838 /* Provide fstat and utime as well as stat for consistent handling of
3841 fstat (int desc
, struct stat
* buf
)
3843 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3844 BY_HANDLE_FILE_INFORMATION info
;
3845 unsigned __int64 fake_inode
;
3848 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3850 case FILE_TYPE_DISK
:
3851 buf
->st_mode
= S_IFREG
;
3852 if (!GetFileInformationByHandle (fh
, &info
))
3858 case FILE_TYPE_PIPE
:
3859 buf
->st_mode
= S_IFIFO
;
3861 case FILE_TYPE_CHAR
:
3862 case FILE_TYPE_UNKNOWN
:
3864 buf
->st_mode
= S_IFCHR
;
3866 memset (&info
, 0, sizeof (info
));
3867 info
.dwFileAttributes
= 0;
3868 info
.ftCreationTime
= utc_base_ft
;
3869 info
.ftLastAccessTime
= utc_base_ft
;
3870 info
.ftLastWriteTime
= utc_base_ft
;
3873 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3874 buf
->st_mode
= S_IFDIR
;
3876 buf
->st_nlink
= info
.nNumberOfLinks
;
3877 /* Might as well use file index to fake inode values, but this
3878 is not guaranteed to be unique unless we keep a handle open
3879 all the time (even then there are situations where it is
3880 not unique). Reputedly, there are at most 48 bits of info
3881 (on NTFS, presumably less on FAT). */
3882 fake_inode
= info
.nFileIndexHigh
;
3884 fake_inode
+= info
.nFileIndexLow
;
3886 /* MSVC defines _ino_t to be short; other libc's might not. */
3887 if (sizeof (buf
->st_ino
) == 2)
3888 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3890 buf
->st_ino
= fake_inode
;
3892 /* Consider files to belong to current user.
3893 FIXME: this should use GetSecurityInfo API, but it is only
3894 available for _WIN32_WINNT >= 0x501. */
3895 buf
->st_uid
= dflt_passwd
.pw_uid
;
3896 buf
->st_gid
= dflt_passwd
.pw_gid
;
3897 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3898 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3900 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3901 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3903 buf
->st_size
= info
.nFileSizeHigh
;
3904 buf
->st_size
<<= 32;
3905 buf
->st_size
+= info
.nFileSizeLow
;
3907 /* Convert timestamps to Unix format. */
3908 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3909 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3910 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3911 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3912 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3914 /* determine rwx permissions */
3915 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3916 permission
= S_IREAD
;
3918 permission
= S_IREAD
| S_IWRITE
;
3920 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3921 permission
|= S_IEXEC
;
3924 #if 0 /* no way of knowing the filename */
3925 char * p
= strrchr (name
, '.');
3927 (xstrcasecmp (p
, ".exe") == 0 ||
3928 xstrcasecmp (p
, ".com") == 0 ||
3929 xstrcasecmp (p
, ".bat") == 0 ||
3930 xstrcasecmp (p
, ".cmd") == 0))
3931 permission
|= S_IEXEC
;
3935 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3941 utime (const char *name
, struct utimbuf
*times
)
3943 struct utimbuf deftime
;
3950 deftime
.modtime
= deftime
.actime
= time (NULL
);
3954 /* Need write access to set times. */
3955 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3956 0, OPEN_EXISTING
, 0, NULL
);
3957 if (fh
!= INVALID_HANDLE_VALUE
)
3959 convert_from_time_t (times
->actime
, &atime
);
3960 convert_from_time_t (times
->modtime
, &mtime
);
3961 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
3978 /* Symlink-related functions. */
3979 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
3980 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
3984 symlink (char const *filename
, char const *linkname
)
3986 char linkfn
[MAX_PATH
], *tgtfn
;
3988 int dir_access
, filename_ends_in_slash
;
3990 /* Diagnostics follows Posix as much as possible. */
3991 if (filename
== NULL
|| linkname
== NULL
)
4001 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4003 errno
= ENAMETOOLONG
;
4007 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4008 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4014 /* Note: since empty FILENAME was already rejected, we can safely
4015 refer to FILENAME[1]. */
4016 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4018 /* Non-absolute FILENAME is understood as being relative to
4019 LINKNAME's directory. We need to prepend that directory to
4020 FILENAME to get correct results from sys_access below, since
4021 otherwise it will interpret FILENAME relative to the
4022 directory where the Emacs process runs. Note that
4023 make-symbolic-link always makes sure LINKNAME is a fully
4024 expanded file name. */
4026 char *p
= linkfn
+ strlen (linkfn
);
4028 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4031 strncpy (tem
, linkfn
, p
- linkfn
);
4032 tem
[p
- linkfn
] = '\0';
4033 strcat (tem
, filename
);
4034 dir_access
= sys_access (tem
, D_OK
);
4037 dir_access
= sys_access (filename
, D_OK
);
4039 /* Since Windows distinguishes between symlinks to directories and
4040 to files, we provide a kludgy feature: if FILENAME doesn't
4041 exist, but ends in a slash, we create a symlink to directory. If
4042 FILENAME exists and is a directory, we always create a symlink to
4044 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4045 if (dir_access
== 0 || filename_ends_in_slash
)
4046 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4048 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4049 if (filename_ends_in_slash
)
4050 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4053 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4055 /* ENOSYS is set by create_symbolic_link, when it detects that
4056 the OS doesn't support the CreateSymbolicLink API. */
4057 if (errno
!= ENOSYS
)
4059 DWORD w32err
= GetLastError ();
4063 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4064 TGTFN point to the same file name, go figure. */
4066 case ERROR_FILE_EXISTS
:
4069 case ERROR_ACCESS_DENIED
:
4072 case ERROR_FILE_NOT_FOUND
:
4073 case ERROR_PATH_NOT_FOUND
:
4074 case ERROR_BAD_NETPATH
:
4075 case ERROR_INVALID_REPARSE_DATA
:
4078 case ERROR_DIRECTORY
:
4081 case ERROR_PRIVILEGE_NOT_HELD
:
4082 case ERROR_NOT_ALL_ASSIGNED
:
4085 case ERROR_DISK_FULL
:
4098 /* A quick inexpensive test of whether FILENAME identifies a file that
4099 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4100 must already be in the normalized form returned by
4103 Note: for repeated operations on many files, it is best to test
4104 whether the underlying volume actually supports symlinks, by
4105 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4106 avoid the call to this function if it doesn't. That's because the
4107 call to GetFileAttributes takes a non-negligible time, especially
4108 on non-local or removable filesystems. See stat_worker for an
4109 example of how to do that. */
4111 is_symlink (const char *filename
)
4114 WIN32_FIND_DATA wfd
;
4117 attrs
= GetFileAttributes (filename
);
4120 DWORD w32err
= GetLastError ();
4124 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4126 case ERROR_ACCESS_DENIED
:
4129 case ERROR_FILE_NOT_FOUND
:
4130 case ERROR_PATH_NOT_FOUND
:
4137 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4139 logon_network_drive (filename
);
4140 fh
= FindFirstFile (filename
, &wfd
);
4141 if (fh
== INVALID_HANDLE_VALUE
)
4144 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4145 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4148 /* If NAME identifies a symbolic link, copy into BUF the file name of
4149 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4150 null-terminate the target name, even if it fits. Return the number
4151 of bytes copied, or -1 if NAME is not a symlink or any error was
4152 encountered while resolving it. The file name copied into BUF is
4153 encoded in the current ANSI codepage. */
4155 readlink (const char *name
, char *buf
, size_t buf_size
)
4158 TOKEN_PRIVILEGES privs
;
4159 int restore_privs
= 0;
4174 path
= map_w32_filename (name
, NULL
);
4176 if (strlen (path
) > MAX_PATH
)
4178 errno
= ENAMETOOLONG
;
4183 if (is_windows_9x () == TRUE
4184 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4185 || !is_symlink (path
))
4188 errno
= EINVAL
; /* not a symlink */
4192 /* Done with simple tests, now we're in for some _real_ work. */
4193 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4195 /* Implementation note: From here and onward, don't return early,
4196 since that will fail to restore the original set of privileges of
4197 the calling thread. */
4199 retval
= -1; /* not too optimistic, are we? */
4201 /* Note: In the next call to CreateFile, we use zero as the 2nd
4202 argument because, when the symlink is a hidden/system file,
4203 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4204 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4205 and directory symlinks. */
4206 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4207 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4209 if (sh
!= INVALID_HANDLE_VALUE
)
4211 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4212 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4215 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4216 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4219 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4223 /* Copy the link target name, in wide characters, fro
4224 reparse_data, then convert it to multibyte encoding in
4225 the current locale's codepage. */
4227 BYTE lname
[MAX_PATH
];
4230 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4232 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4233 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4235 /* According to MSDN, PrintNameLength does not include the
4236 terminating null character. */
4237 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4238 memcpy (lwname
, lwname_src
, lwname_len
);
4239 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4241 /* FIXME: Should we use the current file-name coding system
4242 instead of the fixed value of the ANSI codepage? */
4243 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4244 lname
, MAX_PATH
, NULL
, NULL
);
4247 /* WideCharToMultiByte failed. */
4248 DWORD w32err1
= GetLastError ();
4252 case ERROR_INSUFFICIENT_BUFFER
:
4253 errno
= ENAMETOOLONG
;
4255 case ERROR_INVALID_PARAMETER
:
4258 case ERROR_NO_UNICODE_TRANSLATION
:
4268 size_t size_to_copy
= buf_size
;
4270 BYTE
*pend
= p
+ lname_len
;
4272 /* Normalize like dostounix_filename does, but we don't
4273 want to assume that lname is null-terminated. */
4274 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4282 /* Testing for null-terminated LNAME is paranoia:
4283 WideCharToMultiByte should always return a
4284 null-terminated string when its 4th argument is -1
4285 and its 3rd argument is null-terminated (which they
4287 if (lname
[lname_len
- 1] == '\0')
4289 if (lname_len
<= buf_size
)
4290 size_to_copy
= lname_len
;
4291 strncpy (buf
, lname
, size_to_copy
);
4293 retval
= size_to_copy
;
4300 /* CreateFile failed. */
4301 DWORD w32err2
= GetLastError ();
4305 case ERROR_FILE_NOT_FOUND
:
4306 case ERROR_PATH_NOT_FOUND
:
4309 case ERROR_ACCESS_DENIED
:
4310 case ERROR_TOO_MANY_OPEN_FILES
:
4320 restore_privilege (&privs
);
4327 /* If FILE is a symlink, return its target (stored in a static
4328 buffer); otherwise return FILE.
4330 This function repeatedly resolves symlinks in the last component of
4331 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4332 until it arrives at a file whose last component is not a symlink,
4333 or some error occurs. It returns the target of the last
4334 successfully resolved symlink in the chain. If it succeeds to
4335 resolve even a single symlink, the value returned is an absolute
4336 file name with backslashes (result of GetFullPathName). By
4337 contrast, if the original FILE is returned, it is unaltered.
4339 Note: This function can set errno even if it succeeds.
4341 Implementation note: we only resolve the last portion ("basename")
4342 of the argument FILE and of each following file in the chain,
4343 disregarding any possible symlinks in its leading directories.
4344 This is because Windows system calls and library functions
4345 transparently resolve symlinks in leading directories and return
4346 correct information, as long as the basename is not a symlink. */
4348 chase_symlinks (const char *file
)
4350 static char target
[MAX_PATH
];
4351 char link
[MAX_PATH
];
4352 ssize_t res
, link_len
;
4355 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4356 return (char *)file
;
4358 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4359 return (char *)file
;
4364 /* Remove trailing slashes, as we want to resolve the last
4365 non-trivial part of the link name. */
4366 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4367 link
[link_len
--] = '\0';
4369 res
= readlink (link
, target
, MAX_PATH
);
4373 if (!(IS_DEVICE_SEP (target
[1])
4374 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4376 /* Target is relative. Append it to the directory part of
4377 the symlink, then copy the result back to target. */
4378 char *p
= link
+ link_len
;
4380 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4383 strcpy (target
, link
);
4385 /* Resolve any "." and ".." to get a fully-qualified file name
4387 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4389 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4391 if (loop_count
> 100)
4394 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4395 return (char *)file
;
4399 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4400 have a fixed max size for file names, so we don't need the kind of
4401 alloc/malloc/realloc dance the gnulib version does. We also don't
4402 support FD-relative symlinks. */
4404 careadlinkat (int fd
, char const *filename
,
4405 char *buffer
, size_t buffer_size
,
4406 struct allocator
const *alloc
,
4407 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4409 char linkname
[MAX_PATH
];
4418 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4422 char *retval
= buffer
;
4424 linkname
[link_size
++] = '\0';
4425 if (link_size
> buffer_size
)
4426 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4428 memcpy (retval
, linkname
, link_size
);
4436 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4440 return readlink (filename
, buffer
, buffer_size
);
4444 /* Support for browsing other processes and their attributes. See
4445 process.c for the Lisp bindings. */
4447 /* Helper wrapper functions. */
4449 static HANDLE WINAPI
4450 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4452 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4454 if (g_b_init_create_toolhelp32_snapshot
== 0)
4456 g_b_init_create_toolhelp32_snapshot
= 1;
4457 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4458 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4459 "CreateToolhelp32Snapshot");
4461 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4463 return INVALID_HANDLE_VALUE
;
4465 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4469 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4471 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4473 if (g_b_init_process32_first
== 0)
4475 g_b_init_process32_first
= 1;
4476 s_pfn_Process32_First
= (Process32First_Proc
)
4477 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4480 if (s_pfn_Process32_First
== NULL
)
4484 return (s_pfn_Process32_First (hSnapshot
, lppe
));
4488 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4490 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
4492 if (g_b_init_process32_next
== 0)
4494 g_b_init_process32_next
= 1;
4495 s_pfn_Process32_Next
= (Process32Next_Proc
)
4496 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4499 if (s_pfn_Process32_Next
== NULL
)
4503 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
4507 open_thread_token (HANDLE ThreadHandle
,
4508 DWORD DesiredAccess
,
4510 PHANDLE TokenHandle
)
4512 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
4513 HMODULE hm_advapi32
= NULL
;
4514 if (is_windows_9x () == TRUE
)
4516 SetLastError (ERROR_NOT_SUPPORTED
);
4519 if (g_b_init_open_thread_token
== 0)
4521 g_b_init_open_thread_token
= 1;
4522 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4523 s_pfn_Open_Thread_Token
=
4524 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
4526 if (s_pfn_Open_Thread_Token
== NULL
)
4528 SetLastError (ERROR_NOT_SUPPORTED
);
4532 s_pfn_Open_Thread_Token (
4541 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
4543 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
4544 HMODULE hm_advapi32
= NULL
;
4545 if (is_windows_9x () == TRUE
)
4549 if (g_b_init_impersonate_self
== 0)
4551 g_b_init_impersonate_self
= 1;
4552 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4553 s_pfn_Impersonate_Self
=
4554 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
4556 if (s_pfn_Impersonate_Self
== NULL
)
4560 return s_pfn_Impersonate_Self (ImpersonationLevel
);
4564 revert_to_self (void)
4566 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
4567 HMODULE hm_advapi32
= NULL
;
4568 if (is_windows_9x () == TRUE
)
4572 if (g_b_init_revert_to_self
== 0)
4574 g_b_init_revert_to_self
= 1;
4575 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4576 s_pfn_Revert_To_Self
=
4577 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
4579 if (s_pfn_Revert_To_Self
== NULL
)
4583 return s_pfn_Revert_To_Self ();
4587 get_process_memory_info (HANDLE h_proc
,
4588 PPROCESS_MEMORY_COUNTERS mem_counters
,
4591 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
4592 HMODULE hm_psapi
= NULL
;
4593 if (is_windows_9x () == TRUE
)
4597 if (g_b_init_get_process_memory_info
== 0)
4599 g_b_init_get_process_memory_info
= 1;
4600 hm_psapi
= LoadLibrary ("Psapi.dll");
4602 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
4603 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
4605 if (s_pfn_Get_Process_Memory_Info
== NULL
)
4609 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
4613 get_process_working_set_size (HANDLE h_proc
,
4617 static GetProcessWorkingSetSize_Proc
4618 s_pfn_Get_Process_Working_Set_Size
= NULL
;
4620 if (is_windows_9x () == TRUE
)
4624 if (g_b_init_get_process_working_set_size
== 0)
4626 g_b_init_get_process_working_set_size
= 1;
4627 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
4628 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4629 "GetProcessWorkingSetSize");
4631 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
4635 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
4639 global_memory_status (MEMORYSTATUS
*buf
)
4641 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
4643 if (is_windows_9x () == TRUE
)
4647 if (g_b_init_global_memory_status
== 0)
4649 g_b_init_global_memory_status
= 1;
4650 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
4651 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4652 "GlobalMemoryStatus");
4654 if (s_pfn_Global_Memory_Status
== NULL
)
4658 return s_pfn_Global_Memory_Status (buf
);
4662 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
4664 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
4666 if (is_windows_9x () == TRUE
)
4670 if (g_b_init_global_memory_status_ex
== 0)
4672 g_b_init_global_memory_status_ex
= 1;
4673 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
4674 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4675 "GlobalMemoryStatusEx");
4677 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
4681 return s_pfn_Global_Memory_Status_Ex (buf
);
4685 list_system_processes (void)
4687 struct gcpro gcpro1
;
4688 Lisp_Object proclist
= Qnil
;
4691 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4693 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4695 PROCESSENTRY32 proc_entry
;
4701 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
4702 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
4703 res
= process32_next (h_snapshot
, &proc_entry
))
4705 proc_id
= proc_entry
.th32ProcessID
;
4706 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
4709 CloseHandle (h_snapshot
);
4711 proclist
= Fnreverse (proclist
);
4718 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
4720 TOKEN_PRIVILEGES priv
;
4721 DWORD priv_size
= sizeof (priv
);
4722 DWORD opriv_size
= sizeof (*old_priv
);
4723 HANDLE h_token
= NULL
;
4724 HANDLE h_thread
= GetCurrentThread ();
4728 res
= open_thread_token (h_thread
,
4729 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4731 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
4733 if (impersonate_self (SecurityImpersonation
))
4734 res
= open_thread_token (h_thread
,
4735 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4740 priv
.PrivilegeCount
= 1;
4741 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
4742 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
4743 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
4744 old_priv
, &opriv_size
)
4745 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4749 CloseHandle (h_token
);
4755 restore_privilege (TOKEN_PRIVILEGES
*priv
)
4757 DWORD priv_size
= sizeof (*priv
);
4758 HANDLE h_token
= NULL
;
4761 if (open_thread_token (GetCurrentThread (),
4762 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4765 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
4766 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4770 CloseHandle (h_token
);
4776 ltime (ULONGLONG time_100ns
)
4778 ULONGLONG time_sec
= time_100ns
/ 10000000;
4779 int subsec
= time_100ns
% 10000000;
4780 return list4 (make_number (time_sec
>> 16),
4781 make_number (time_sec
& 0xffff),
4782 make_number (subsec
/ 10),
4783 make_number (subsec
% 10 * 100000));
4786 #define U64_TO_LISP_TIME(time) ltime (time)
4789 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
4790 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
4793 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
4794 ULONGLONG tem1
, tem2
, tem3
, tem
;
4797 || !get_process_times_fn
4798 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
4799 &ft_kernel
, &ft_user
))
4802 GetSystemTimeAsFileTime (&ft_current
);
4804 FILETIME_TO_U64 (tem1
, ft_kernel
);
4805 *stime
= U64_TO_LISP_TIME (tem1
);
4807 FILETIME_TO_U64 (tem2
, ft_user
);
4808 *utime
= U64_TO_LISP_TIME (tem2
);
4811 *ttime
= U64_TO_LISP_TIME (tem3
);
4813 FILETIME_TO_U64 (tem
, ft_creation
);
4814 /* Process no 4 (System) returns zero creation time. */
4817 *ctime
= U64_TO_LISP_TIME (tem
);
4821 FILETIME_TO_U64 (tem3
, ft_current
);
4822 tem
= (tem3
- utc_base
) - tem
;
4824 *etime
= U64_TO_LISP_TIME (tem
);
4828 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4839 system_process_attributes (Lisp_Object pid
)
4841 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4842 Lisp_Object attrs
= Qnil
;
4843 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4844 HANDLE h_snapshot
, h_proc
;
4847 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4848 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4849 DWORD glength
= sizeof (gname
);
4850 HANDLE token
= NULL
;
4851 SID_NAME_USE user_type
;
4852 unsigned char *buf
= NULL
;
4854 TOKEN_USER user_token
;
4855 TOKEN_PRIMARY_GROUP group_token
;
4858 PROCESS_MEMORY_COUNTERS mem
;
4859 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4860 DWORD minrss
, maxrss
;
4862 MEMORY_STATUS_EX memstex
;
4863 double totphys
= 0.0;
4864 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4866 BOOL result
= FALSE
;
4868 CHECK_NUMBER_OR_FLOAT (pid
);
4869 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4871 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4873 GCPRO3 (attrs
, decoded_cmd
, tem
);
4875 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4880 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4881 for (res
= process32_first (h_snapshot
, &pe
); res
;
4882 res
= process32_next (h_snapshot
, &pe
))
4884 if (proc_id
== pe
.th32ProcessID
)
4887 decoded_cmd
= build_string ("Idle");
4890 /* Decode the command name from locale-specific
4892 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4893 strlen (pe
.szExeFile
));
4895 code_convert_string_norecord (cmd_str
,
4896 Vlocale_coding_system
, 0);
4898 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4899 attrs
= Fcons (Fcons (Qppid
,
4900 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4902 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4904 attrs
= Fcons (Fcons (Qthcount
,
4905 make_fixnum_or_float (pe
.cntThreads
)),
4912 CloseHandle (h_snapshot
);
4921 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4923 /* If we were denied a handle to the process, try again after
4924 enabling the SeDebugPrivilege in our process. */
4927 TOKEN_PRIVILEGES priv_current
;
4929 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4931 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4933 restore_privilege (&priv_current
);
4939 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4942 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4943 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4945 buf
= xmalloc (blen
);
4946 result
= get_token_information (token
, TokenUser
,
4947 (LPVOID
)buf
, blen
, &needed
);
4950 memcpy (&user_token
, buf
, sizeof (user_token
));
4951 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4953 euid
= get_rid (user_token
.User
.Sid
);
4954 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4959 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4962 strcpy (uname
, "unknown");
4966 ulength
= strlen (uname
);
4972 /* Determine a reasonable euid and gid values. */
4973 if (xstrcasecmp ("administrator", uname
) == 0)
4975 euid
= 500; /* well-known Administrator uid */
4976 egid
= 513; /* well-known None gid */
4980 /* Get group id and name. */
4981 result
= get_token_information (token
, TokenPrimaryGroup
,
4982 (LPVOID
)buf
, blen
, &needed
);
4983 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4985 buf
= xrealloc (buf
, blen
= needed
);
4986 result
= get_token_information (token
, TokenPrimaryGroup
,
4987 (LPVOID
)buf
, blen
, &needed
);
4991 memcpy (&group_token
, buf
, sizeof (group_token
));
4992 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
4994 egid
= get_rid (group_token
.PrimaryGroup
);
4995 dlength
= sizeof (domain
);
4997 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
4998 gname
, &glength
, NULL
, &dlength
,
5001 w32_add_to_cache (group_token
.PrimaryGroup
,
5005 strcpy (gname
, "None");
5009 glength
= strlen (gname
);
5017 if (!is_windows_9x ())
5019 /* We couldn't open the process token, presumably because of
5020 insufficient access rights. Assume this process is run
5022 strcpy (uname
, "SYSTEM");
5023 strcpy (gname
, "None");
5024 euid
= 18; /* SYSTEM */
5025 egid
= 513; /* None */
5026 glength
= strlen (gname
);
5027 ulength
= strlen (uname
);
5029 /* If we are running under Windows 9X, where security calls are
5030 not supported, we assume all processes are run by the current
5032 else if (GetUserName (uname
, &ulength
))
5034 if (xstrcasecmp ("administrator", uname
) == 0)
5039 strcpy (gname
, "None");
5040 glength
= strlen (gname
);
5041 ulength
= strlen (uname
);
5047 strcpy (uname
, "administrator");
5048 ulength
= strlen (uname
);
5049 strcpy (gname
, "None");
5050 glength
= strlen (gname
);
5053 CloseHandle (token
);
5056 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5057 tem
= make_unibyte_string (uname
, ulength
);
5058 attrs
= Fcons (Fcons (Quser
,
5059 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5061 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5062 tem
= make_unibyte_string (gname
, glength
);
5063 attrs
= Fcons (Fcons (Qgroup
,
5064 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5067 if (global_memory_status_ex (&memstex
))
5068 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5069 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5071 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5072 double, so we need to do this for it... */
5074 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5075 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5076 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5078 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5080 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5081 else if (global_memory_status (&memst
))
5082 totphys
= memst
.dwTotalPhys
/ 1024.0;
5085 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5088 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5090 attrs
= Fcons (Fcons (Qmajflt
,
5091 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5093 attrs
= Fcons (Fcons (Qvsize
,
5094 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5096 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5098 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5101 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5103 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5105 attrs
= Fcons (Fcons (Qmajflt
,
5106 make_fixnum_or_float (mem
.PageFaultCount
)),
5108 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5110 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5113 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5115 DWORD rss
= maxrss
/ 1024;
5117 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5119 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5122 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5124 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5125 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5126 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5127 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5128 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5129 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5132 /* FIXME: Retrieve command line by walking the PEB of the process. */
5135 CloseHandle (h_proc
);
5141 /* Wrappers for winsock functions to map between our file descriptors
5142 and winsock's handles; also set h_errno for convenience.
5144 To allow Emacs to run on systems which don't have winsock support
5145 installed, we dynamically link to winsock on startup if present, and
5146 otherwise provide the minimum necessary functionality
5147 (eg. gethostname). */
5149 /* function pointers for relevant socket functions */
5150 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5151 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5152 int (PASCAL
*pfn_WSAGetLastError
) (void);
5153 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5154 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5155 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5156 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5157 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5158 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5159 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5160 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5161 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5162 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5163 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5164 int (PASCAL
*pfn_WSACleanup
) (void);
5166 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5167 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5168 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5169 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5170 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5171 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5172 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5173 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5174 const char * optval
, int optlen
);
5175 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5176 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5178 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5179 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5180 struct sockaddr
* from
, int * fromlen
);
5181 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5182 const struct sockaddr
* to
, int tolen
);
5184 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5185 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5186 #ifndef HANDLE_FLAG_INHERIT
5187 #define HANDLE_FLAG_INHERIT 1
5191 static int winsock_inuse
;
5196 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5198 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5199 after WSAStartup returns successfully, but it seems reasonable
5200 to allow unloading winsock anyway in that case. */
5201 if (pfn_WSACleanup () == 0 ||
5202 pfn_WSAGetLastError () == WSAENETDOWN
)
5204 if (FreeLibrary (winsock_lib
))
5213 init_winsock (int load_now
)
5215 WSADATA winsockData
;
5217 if (winsock_lib
!= NULL
)
5220 pfn_SetHandleInformation
5221 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5222 "SetHandleInformation");
5224 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5226 if (winsock_lib
!= NULL
)
5228 /* dynamically link to socket functions */
5230 #define LOAD_PROC(fn) \
5231 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5234 LOAD_PROC (WSAStartup
);
5235 LOAD_PROC (WSASetLastError
);
5236 LOAD_PROC (WSAGetLastError
);
5237 LOAD_PROC (WSAEventSelect
);
5238 LOAD_PROC (WSACreateEvent
);
5239 LOAD_PROC (WSACloseEvent
);
5242 LOAD_PROC (connect
);
5243 LOAD_PROC (ioctlsocket
);
5246 LOAD_PROC (closesocket
);
5247 LOAD_PROC (shutdown
);
5250 LOAD_PROC (inet_addr
);
5251 LOAD_PROC (gethostname
);
5252 LOAD_PROC (gethostbyname
);
5253 LOAD_PROC (getservbyname
);
5254 LOAD_PROC (getpeername
);
5255 LOAD_PROC (WSACleanup
);
5256 LOAD_PROC (setsockopt
);
5258 LOAD_PROC (getsockname
);
5260 LOAD_PROC (recvfrom
);
5264 /* specify version 1.1 of winsock */
5265 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5267 if (winsockData
.wVersion
!= 0x101)
5272 /* Report that winsock exists and is usable, but leave
5273 socket functions disabled. I am assuming that calling
5274 WSAStartup does not require any network interaction,
5275 and in particular does not cause or require a dial-up
5276 connection to be established. */
5279 FreeLibrary (winsock_lib
);
5287 FreeLibrary (winsock_lib
);
5297 /* function to set h_errno for compatibility; map winsock error codes to
5298 normal system codes where they overlap (non-overlapping definitions
5299 are already in <sys/socket.h> */
5303 if (winsock_lib
== NULL
)
5306 h_errno
= pfn_WSAGetLastError ();
5310 case WSAEACCES
: h_errno
= EACCES
; break;
5311 case WSAEBADF
: h_errno
= EBADF
; break;
5312 case WSAEFAULT
: h_errno
= EFAULT
; break;
5313 case WSAEINTR
: h_errno
= EINTR
; break;
5314 case WSAEINVAL
: h_errno
= EINVAL
; break;
5315 case WSAEMFILE
: h_errno
= EMFILE
; break;
5316 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5317 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5325 if (h_errno
== 0 && winsock_lib
!= NULL
)
5326 pfn_WSASetLastError (0);
5329 /* Extend strerror to handle the winsock-specific error codes. */
5333 } _wsa_errlist
[] = {
5334 {WSAEINTR
, "Interrupted function call"},
5335 {WSAEBADF
, "Bad file descriptor"},
5336 {WSAEACCES
, "Permission denied"},
5337 {WSAEFAULT
, "Bad address"},
5338 {WSAEINVAL
, "Invalid argument"},
5339 {WSAEMFILE
, "Too many open files"},
5341 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5342 {WSAEINPROGRESS
, "Operation now in progress"},
5343 {WSAEALREADY
, "Operation already in progress"},
5344 {WSAENOTSOCK
, "Socket operation on non-socket"},
5345 {WSAEDESTADDRREQ
, "Destination address required"},
5346 {WSAEMSGSIZE
, "Message too long"},
5347 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5348 {WSAENOPROTOOPT
, "Bad protocol option"},
5349 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5350 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5351 {WSAEOPNOTSUPP
, "Operation not supported"},
5352 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5353 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5354 {WSAEADDRINUSE
, "Address already in use"},
5355 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5356 {WSAENETDOWN
, "Network is down"},
5357 {WSAENETUNREACH
, "Network is unreachable"},
5358 {WSAENETRESET
, "Network dropped connection on reset"},
5359 {WSAECONNABORTED
, "Software caused connection abort"},
5360 {WSAECONNRESET
, "Connection reset by peer"},
5361 {WSAENOBUFS
, "No buffer space available"},
5362 {WSAEISCONN
, "Socket is already connected"},
5363 {WSAENOTCONN
, "Socket is not connected"},
5364 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5365 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5366 {WSAETIMEDOUT
, "Connection timed out"},
5367 {WSAECONNREFUSED
, "Connection refused"},
5368 {WSAELOOP
, "Network loop"}, /* not sure */
5369 {WSAENAMETOOLONG
, "Name is too long"},
5370 {WSAEHOSTDOWN
, "Host is down"},
5371 {WSAEHOSTUNREACH
, "No route to host"},
5372 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5373 {WSAEPROCLIM
, "Too many processes"},
5374 {WSAEUSERS
, "Too many users"}, /* not sure */
5375 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5376 {WSAESTALE
, "Data is stale"}, /* not sure */
5377 {WSAEREMOTE
, "Remote error"}, /* not sure */
5379 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5380 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5381 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5382 {WSAEDISCON
, "Graceful shutdown in progress"},
5384 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5385 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5386 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5387 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5388 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5389 {WSASYSCALLFAILURE
, "System call failure"},
5390 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5391 {WSATYPE_NOT_FOUND
, "Class type not found"},
5392 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5393 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5394 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5397 {WSAHOST_NOT_FOUND
, "Host not found"},
5398 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5399 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5400 {WSANO_DATA
, "Valid name, no data record of requested type"},
5406 sys_strerror (int error_no
)
5409 static char unknown_msg
[40];
5411 if (error_no
>= 0 && error_no
< sys_nerr
)
5412 return sys_errlist
[error_no
];
5414 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5415 if (_wsa_errlist
[i
].errnum
== error_no
)
5416 return _wsa_errlist
[i
].msg
;
5418 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5422 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5423 but I believe the method of keeping the socket handle separate (and
5424 insuring it is not inheritable) is the correct one. */
5426 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5428 static int socket_to_fd (SOCKET s
);
5431 sys_socket (int af
, int type
, int protocol
)
5435 if (winsock_lib
== NULL
)
5438 return INVALID_SOCKET
;
5443 /* call the real socket function */
5444 s
= pfn_socket (af
, type
, protocol
);
5446 if (s
!= INVALID_SOCKET
)
5447 return socket_to_fd (s
);
5453 /* Convert a SOCKET to a file descriptor. */
5455 socket_to_fd (SOCKET s
)
5460 /* Although under NT 3.5 _open_osfhandle will accept a socket
5461 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5462 that does not work under NT 3.1. However, we can get the same
5463 effect by using a backdoor function to replace an existing
5464 descriptor handle with the one we want. */
5466 /* allocate a file descriptor (with appropriate flags) */
5467 fd
= _open ("NUL:", _O_RDWR
);
5470 /* Make a non-inheritable copy of the socket handle. Note
5471 that it is possible that sockets aren't actually kernel
5472 handles, which appears to be the case on Windows 9x when
5473 the MS Proxy winsock client is installed. */
5475 /* Apparently there is a bug in NT 3.51 with some service
5476 packs, which prevents using DuplicateHandle to make a
5477 socket handle non-inheritable (causes WSACleanup to
5478 hang). The work-around is to use SetHandleInformation
5479 instead if it is available and implemented. */
5480 if (pfn_SetHandleInformation
)
5482 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5486 HANDLE parent
= GetCurrentProcess ();
5487 HANDLE new_s
= INVALID_HANDLE_VALUE
;
5489 if (DuplicateHandle (parent
,
5495 DUPLICATE_SAME_ACCESS
))
5497 /* It is possible that DuplicateHandle succeeds even
5498 though the socket wasn't really a kernel handle,
5499 because a real handle has the same value. So
5500 test whether the new handle really is a socket. */
5501 long nonblocking
= 0;
5502 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
5504 pfn_closesocket (s
);
5509 CloseHandle (new_s
);
5514 fd_info
[fd
].hnd
= (HANDLE
) s
;
5516 /* set our own internal flags */
5517 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
5523 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5525 /* attach child_process to fd_info */
5526 if (fd_info
[ fd
].cp
!= NULL
)
5528 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
5532 fd_info
[ fd
].cp
= cp
;
5535 winsock_inuse
++; /* count open sockets */
5542 pfn_closesocket (s
);
5548 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
5550 if (winsock_lib
== NULL
)
5553 return SOCKET_ERROR
;
5557 if (fd_info
[s
].flags
& FILE_SOCKET
)
5559 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
5560 if (rc
== SOCKET_ERROR
)
5565 return SOCKET_ERROR
;
5569 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
5571 if (winsock_lib
== NULL
)
5574 return SOCKET_ERROR
;
5578 if (fd_info
[s
].flags
& FILE_SOCKET
)
5580 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
5581 if (rc
== SOCKET_ERROR
)
5586 return SOCKET_ERROR
;
5590 sys_htons (u_short hostshort
)
5592 return (winsock_lib
!= NULL
) ?
5593 pfn_htons (hostshort
) : hostshort
;
5597 sys_ntohs (u_short netshort
)
5599 return (winsock_lib
!= NULL
) ?
5600 pfn_ntohs (netshort
) : netshort
;
5604 sys_inet_addr (const char * cp
)
5606 return (winsock_lib
!= NULL
) ?
5607 pfn_inet_addr (cp
) : INADDR_NONE
;
5611 sys_gethostname (char * name
, int namelen
)
5613 if (winsock_lib
!= NULL
)
5614 return pfn_gethostname (name
, namelen
);
5616 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
5617 return !GetComputerName (name
, (DWORD
*)&namelen
);
5620 return SOCKET_ERROR
;
5624 sys_gethostbyname (const char * name
)
5626 struct hostent
* host
;
5628 if (winsock_lib
== NULL
)
5635 host
= pfn_gethostbyname (name
);
5642 sys_getservbyname (const char * name
, const char * proto
)
5644 struct servent
* serv
;
5646 if (winsock_lib
== NULL
)
5653 serv
= pfn_getservbyname (name
, proto
);
5660 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
5662 if (winsock_lib
== NULL
)
5665 return SOCKET_ERROR
;
5669 if (fd_info
[s
].flags
& FILE_SOCKET
)
5671 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
5672 if (rc
== SOCKET_ERROR
)
5677 return SOCKET_ERROR
;
5681 sys_shutdown (int s
, int how
)
5683 if (winsock_lib
== NULL
)
5686 return SOCKET_ERROR
;
5690 if (fd_info
[s
].flags
& FILE_SOCKET
)
5692 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
5693 if (rc
== SOCKET_ERROR
)
5698 return SOCKET_ERROR
;
5702 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
5704 if (winsock_lib
== NULL
)
5707 return SOCKET_ERROR
;
5711 if (fd_info
[s
].flags
& FILE_SOCKET
)
5713 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
5714 (const char *)optval
, optlen
);
5715 if (rc
== SOCKET_ERROR
)
5720 return SOCKET_ERROR
;
5724 sys_listen (int s
, int backlog
)
5726 if (winsock_lib
== NULL
)
5729 return SOCKET_ERROR
;
5733 if (fd_info
[s
].flags
& FILE_SOCKET
)
5735 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
5736 if (rc
== SOCKET_ERROR
)
5739 fd_info
[s
].flags
|= FILE_LISTEN
;
5743 return SOCKET_ERROR
;
5747 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
5749 if (winsock_lib
== NULL
)
5752 return SOCKET_ERROR
;
5756 if (fd_info
[s
].flags
& FILE_SOCKET
)
5758 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
5759 if (rc
== SOCKET_ERROR
)
5764 return SOCKET_ERROR
;
5768 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
5770 if (winsock_lib
== NULL
)
5777 if (fd_info
[s
].flags
& FILE_LISTEN
)
5779 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
5781 if (t
== INVALID_SOCKET
)
5784 fd
= socket_to_fd (t
);
5786 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5787 ResetEvent (fd_info
[s
].cp
->char_avail
);
5795 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
5796 struct sockaddr
* from
, int * fromlen
)
5798 if (winsock_lib
== NULL
)
5801 return SOCKET_ERROR
;
5805 if (fd_info
[s
].flags
& FILE_SOCKET
)
5807 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
5808 if (rc
== SOCKET_ERROR
)
5813 return SOCKET_ERROR
;
5817 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5818 const struct sockaddr
* to
, int tolen
)
5820 if (winsock_lib
== NULL
)
5823 return SOCKET_ERROR
;
5827 if (fd_info
[s
].flags
& FILE_SOCKET
)
5829 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5830 if (rc
== SOCKET_ERROR
)
5835 return SOCKET_ERROR
;
5838 /* Windows does not have an fcntl function. Provide an implementation
5839 solely for making sockets non-blocking. */
5841 fcntl (int s
, int cmd
, int options
)
5843 if (winsock_lib
== NULL
)
5850 if (fd_info
[s
].flags
& FILE_SOCKET
)
5852 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
5854 unsigned long nblock
= 1;
5855 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5856 if (rc
== SOCKET_ERROR
)
5858 /* Keep track of the fact that we set this to non-blocking. */
5859 fd_info
[s
].flags
|= FILE_NDELAY
;
5865 return SOCKET_ERROR
;
5869 return SOCKET_ERROR
;
5873 /* Shadow main io functions: we need to handle pipes and sockets more
5874 intelligently, and implement non-blocking mode as well. */
5887 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5889 child_process
* cp
= fd_info
[fd
].cp
;
5891 fd_info
[fd
].cp
= NULL
;
5893 if (CHILD_ACTIVE (cp
))
5895 /* if last descriptor to active child_process then cleanup */
5897 for (i
= 0; i
< MAXDESC
; i
++)
5901 if (fd_info
[i
].cp
== cp
)
5906 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5908 if (winsock_lib
== NULL
) emacs_abort ();
5910 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5911 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5913 winsock_inuse
--; /* count open sockets */
5920 /* Note that sockets do not need special treatment here (at least on
5921 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5922 closesocket is equivalent to CloseHandle, which is to be expected
5923 because socket handles are fully fledged kernel handles. */
5926 if (rc
== 0 && fd
< MAXDESC
)
5927 fd_info
[fd
].flags
= 0;
5938 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5940 /* duplicate our internal info as well */
5941 fd_info
[new_fd
] = fd_info
[fd
];
5947 sys_dup2 (int src
, int dst
)
5951 if (dst
< 0 || dst
>= MAXDESC
)
5957 /* make sure we close the destination first if it's a pipe or socket */
5958 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5961 rc
= _dup2 (src
, dst
);
5964 /* duplicate our internal info as well */
5965 fd_info
[dst
] = fd_info
[src
];
5970 /* Unix pipe() has only one arg */
5972 sys_pipe (int * phandles
)
5977 /* make pipe handles non-inheritable; when we spawn a child, we
5978 replace the relevant handle with an inheritable one. Also put
5979 pipes into binary mode; we will do text mode translation ourselves
5981 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
5985 /* Protect against overflow, since Windows can open more handles than
5986 our fd_info array has room for. */
5987 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
5989 _close (phandles
[0]);
5990 _close (phandles
[1]);
5995 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
5996 fd_info
[phandles
[0]].flags
= flags
;
5998 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
5999 fd_info
[phandles
[1]].flags
= flags
;
6006 /* Function to do blocking read of one byte, needed to implement
6007 select. It is only allowed on sockets and pipes. */
6009 _sys_read_ahead (int fd
)
6014 if (fd
< 0 || fd
>= MAXDESC
)
6015 return STATUS_READ_ERROR
;
6017 cp
= fd_info
[fd
].cp
;
6019 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6020 return STATUS_READ_ERROR
;
6022 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6023 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6025 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6029 cp
->status
= STATUS_READ_IN_PROGRESS
;
6031 if (fd_info
[fd
].flags
& FILE_PIPE
)
6033 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6035 /* Give subprocess time to buffer some more output for us before
6036 reporting that input is available; we need this because Windows 95
6037 connects DOS programs to pipes by making the pipe appear to be
6038 the normal console stdout - as a result most DOS programs will
6039 write to stdout without buffering, ie. one character at a
6040 time. Even some W32 programs do this - "dir" in a command
6041 shell on NT is very slow if we don't do this. */
6044 int wait
= w32_pipe_read_delay
;
6050 /* Yield remainder of our time slice, effectively giving a
6051 temporary priority boost to the child process. */
6055 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6057 HANDLE hnd
= fd_info
[fd
].hnd
;
6058 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6061 /* Configure timeouts for blocking read. */
6062 if (!GetCommTimeouts (hnd
, &ct
))
6063 return STATUS_READ_ERROR
;
6064 ct
.ReadIntervalTimeout
= 0;
6065 ct
.ReadTotalTimeoutMultiplier
= 0;
6066 ct
.ReadTotalTimeoutConstant
= 0;
6067 if (!SetCommTimeouts (hnd
, &ct
))
6068 return STATUS_READ_ERROR
;
6070 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6072 if (GetLastError () != ERROR_IO_PENDING
)
6073 return STATUS_READ_ERROR
;
6074 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6075 return STATUS_READ_ERROR
;
6078 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6080 unsigned long nblock
= 0;
6081 /* We always want this to block, so temporarily disable NDELAY. */
6082 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6083 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6085 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6087 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6090 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6094 if (rc
== sizeof (char))
6095 cp
->status
= STATUS_READ_SUCCEEDED
;
6097 cp
->status
= STATUS_READ_FAILED
;
6103 _sys_wait_accept (int fd
)
6109 if (fd
< 0 || fd
>= MAXDESC
)
6110 return STATUS_READ_ERROR
;
6112 cp
= fd_info
[fd
].cp
;
6114 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6115 return STATUS_READ_ERROR
;
6117 cp
->status
= STATUS_READ_FAILED
;
6119 hEv
= pfn_WSACreateEvent ();
6120 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6121 if (rc
!= SOCKET_ERROR
)
6123 rc
= WaitForSingleObject (hEv
, INFINITE
);
6124 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6125 if (rc
== WAIT_OBJECT_0
)
6126 cp
->status
= STATUS_READ_SUCCEEDED
;
6128 pfn_WSACloseEvent (hEv
);
6134 sys_read (int fd
, char * buffer
, unsigned int count
)
6139 char * orig_buffer
= buffer
;
6147 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6149 child_process
*cp
= fd_info
[fd
].cp
;
6151 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6159 /* re-read CR carried over from last read */
6160 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6162 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6166 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6169 /* presence of a child_process structure means we are operating in
6170 non-blocking mode - otherwise we just call _read directly.
6171 Note that the child_process structure might be missing because
6172 reap_subprocess has been called; in this case the pipe is
6173 already broken, so calling _read on it is okay. */
6176 int current_status
= cp
->status
;
6178 switch (current_status
)
6180 case STATUS_READ_FAILED
:
6181 case STATUS_READ_ERROR
:
6182 /* report normal EOF if nothing in buffer */
6184 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6187 case STATUS_READ_READY
:
6188 case STATUS_READ_IN_PROGRESS
:
6189 DebPrint (("sys_read called when read is in progress\n"));
6190 errno
= EWOULDBLOCK
;
6193 case STATUS_READ_SUCCEEDED
:
6194 /* consume read-ahead char */
6195 *buffer
++ = cp
->chr
;
6198 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6199 ResetEvent (cp
->char_avail
);
6201 case STATUS_READ_ACKNOWLEDGED
:
6205 DebPrint (("sys_read: bad status %d\n", current_status
));
6210 if (fd_info
[fd
].flags
& FILE_PIPE
)
6212 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6213 to_read
= min (waiting
, (DWORD
) count
);
6216 nchars
+= _read (fd
, buffer
, to_read
);
6218 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6220 HANDLE hnd
= fd_info
[fd
].hnd
;
6221 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6227 /* Configure timeouts for non-blocking read. */
6228 if (!GetCommTimeouts (hnd
, &ct
))
6233 ct
.ReadIntervalTimeout
= MAXDWORD
;
6234 ct
.ReadTotalTimeoutMultiplier
= 0;
6235 ct
.ReadTotalTimeoutConstant
= 0;
6236 if (!SetCommTimeouts (hnd
, &ct
))
6242 if (!ResetEvent (ovl
->hEvent
))
6247 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6249 if (GetLastError () != ERROR_IO_PENDING
)
6254 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6263 else /* FILE_SOCKET */
6265 if (winsock_lib
== NULL
) emacs_abort ();
6267 /* do the equivalent of a non-blocking read */
6268 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6269 if (waiting
== 0 && nchars
== 0)
6271 h_errno
= errno
= EWOULDBLOCK
;
6277 /* always use binary mode for sockets */
6278 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6279 if (res
== SOCKET_ERROR
)
6281 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6282 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6292 int nread
= _read (fd
, buffer
, count
);
6295 else if (nchars
== 0)
6300 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6301 /* Perform text mode translation if required. */
6302 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6304 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6305 /* If buffer contains only CR, return that. To be absolutely
6306 sure we should attempt to read the next char, but in
6307 practice a CR to be followed by LF would not appear by
6308 itself in the buffer. */
6309 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6311 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6317 nchars
= _read (fd
, buffer
, count
);
6322 /* From w32xfns.c */
6323 extern HANDLE interrupt_handle
;
6325 /* For now, don't bother with a non-blocking mode */
6327 sys_write (int fd
, const void * buffer
, unsigned int count
)
6337 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6339 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6345 /* Perform text mode translation if required. */
6346 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6348 char * tmpbuf
= alloca (count
* 2);
6349 unsigned char * src
= (void *)buffer
;
6350 unsigned char * dst
= tmpbuf
;
6355 unsigned char *next
;
6356 /* copy next line or remaining bytes */
6357 next
= _memccpy (dst
, src
, '\n', nbytes
);
6360 /* copied one line ending with '\n' */
6361 int copied
= next
- dst
;
6364 /* insert '\r' before '\n' */
6371 /* copied remaining partial line -> now finished */
6378 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6380 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6381 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6382 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6385 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6387 if (GetLastError () != ERROR_IO_PENDING
)
6392 if (detect_input_pending ())
6393 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6396 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6397 if (active
== WAIT_OBJECT_0
)
6398 { /* User pressed C-g, cancel write, then leave. Don't bother
6399 cleaning up as we may only get stuck in buggy drivers. */
6400 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6405 if (active
== WAIT_OBJECT_0
+ 1
6406 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6413 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6415 unsigned long nblock
= 0;
6416 if (winsock_lib
== NULL
) emacs_abort ();
6418 /* TODO: implement select() properly so non-blocking I/O works. */
6419 /* For now, make sure the write blocks. */
6420 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6421 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6423 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6425 /* Set the socket back to non-blocking if it was before,
6426 for other operations that support it. */
6427 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6430 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6433 if (nchars
== SOCKET_ERROR
)
6435 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6436 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6442 /* Some networked filesystems don't like too large writes, so
6443 break them into smaller chunks. See the Comments section of
6444 the MSDN documentation of WriteFile for details behind the
6445 choice of the value of CHUNK below. See also the thread
6446 http://thread.gmane.org/gmane.comp.version-control.git/145294
6447 in the git mailing list. */
6448 const unsigned char *p
= buffer
;
6449 const unsigned chunk
= 30 * 1024 * 1024;
6454 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6455 int n
= _write (fd
, p
, this_chunk
);
6463 else if (n
< this_chunk
)
6473 /* The Windows CRT functions are "optimized for speed", so they don't
6474 check for timezone and DST changes if they were last called less
6475 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
6476 all Emacs features that repeatedly call time functions (e.g.,
6477 display-time) are in real danger of missing timezone and DST
6478 changes. Calling tzset before each localtime call fixes that. */
6480 sys_localtime (const time_t *t
)
6483 return localtime (t
);
6488 /* Try loading LIBRARY_ID from the file(s) specified in
6489 Vdynamic_library_alist. If the library is loaded successfully,
6490 return the handle of the DLL, and record the filename in the
6491 property :loaded-from of LIBRARY_ID. If the library could not be
6492 found, or when it was already loaded (because the handle is not
6493 recorded anywhere, and so is lost after use), return NULL.
6495 We could also save the handle in :loaded-from, but currently
6496 there's no use case for it. */
6498 w32_delayed_load (Lisp_Object library_id
)
6500 HMODULE library_dll
= NULL
;
6502 CHECK_SYMBOL (library_id
);
6504 if (CONSP (Vdynamic_library_alist
)
6505 && NILP (Fassq (library_id
, Vlibrary_cache
)))
6507 Lisp_Object found
= Qnil
;
6508 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
6511 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
6513 CHECK_STRING_CAR (dlls
);
6514 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
6516 char name
[MAX_PATH
];
6519 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
6520 found
= Fcons (XCAR (dlls
),
6522 /* Possibly truncated */
6523 ? make_specified_string (name
, -1, len
, 1)
6529 Fput (library_id
, QCloaded_from
, found
);
6537 check_windows_init_file (void)
6539 /* A common indication that Emacs is not installed properly is when
6540 it cannot find the Windows installation file. If this file does
6541 not exist in the expected place, tell the user. */
6543 if (!noninteractive
&& !inhibit_window_system
6544 /* Vload_path is not yet initialized when we are loading
6546 && NILP (Vpurify_flag
))
6548 Lisp_Object init_file
;
6551 init_file
= build_string ("term/w32-win");
6552 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
6555 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
6556 char *init_file_name
= SDATA (init_file
);
6557 char *load_path
= SDATA (load_path_print
);
6558 char *buffer
= alloca (1024
6559 + strlen (init_file_name
)
6560 + strlen (load_path
));
6563 "The Emacs Windows initialization file \"%s.el\" "
6564 "could not be found in your Emacs installation. "
6565 "Emacs checked the following directories for this file:\n"
6567 "When Emacs cannot find this file, it usually means that it "
6568 "was not installed properly, or its distribution file was "
6569 "not unpacked properly.\nSee the README.W32 file in the "
6570 "top-level Emacs directory for more information.",
6571 init_file_name
, load_path
);
6574 "Emacs Abort Dialog",
6575 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
6576 /* Use the low-level system abort. */
6587 term_ntproc (int ignored
)
6593 /* shutdown the socket interface if necessary */
6600 init_ntproc (int dumping
)
6602 sigset_t initial_mask
= 0;
6604 /* Initialize the socket interface now if available and requested by
6605 the user by defining PRELOAD_WINSOCK; otherwise loading will be
6606 delayed until open-network-stream is called (w32-has-winsock can
6607 also be used to dynamically load or reload winsock).
6609 Conveniently, init_environment is called before us, so
6610 PRELOAD_WINSOCK can be set in the registry. */
6612 /* Always initialize this correctly. */
6615 if (getenv ("PRELOAD_WINSOCK") != NULL
)
6616 init_winsock (TRUE
);
6618 /* Initial preparation for subprocess support: replace our standard
6619 handles with non-inheritable versions. */
6622 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
6623 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
6624 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
6626 parent
= GetCurrentProcess ();
6628 /* ignore errors when duplicating and closing; typically the
6629 handles will be invalid when running as a gui program. */
6630 DuplicateHandle (parent
,
6631 GetStdHandle (STD_INPUT_HANDLE
),
6636 DUPLICATE_SAME_ACCESS
);
6638 DuplicateHandle (parent
,
6639 GetStdHandle (STD_OUTPUT_HANDLE
),
6644 DUPLICATE_SAME_ACCESS
);
6646 DuplicateHandle (parent
,
6647 GetStdHandle (STD_ERROR_HANDLE
),
6652 DUPLICATE_SAME_ACCESS
);
6658 if (stdin_save
!= INVALID_HANDLE_VALUE
)
6659 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
6661 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
6664 if (stdout_save
!= INVALID_HANDLE_VALUE
)
6665 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
6667 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6670 if (stderr_save
!= INVALID_HANDLE_VALUE
)
6671 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
6673 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6677 /* unfortunately, atexit depends on implementation of malloc */
6678 /* atexit (term_ntproc); */
6681 /* Make sure we start with all signals unblocked. */
6682 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
6683 signal (SIGABRT
, term_ntproc
);
6687 /* determine which drives are fixed, for GetCachedVolumeInformation */
6689 /* GetDriveType must have trailing backslash. */
6690 char drive
[] = "A:\\";
6692 /* Loop over all possible drive letters */
6693 while (*drive
<= 'Z')
6695 /* Record if this drive letter refers to a fixed drive. */
6696 fixed_drives
[DRIVE_INDEX (*drive
)] =
6697 (GetDriveType (drive
) == DRIVE_FIXED
);
6702 /* Reset the volume info cache. */
6703 volume_cache
= NULL
;
6708 shutdown_handler ensures that buffers' autosave files are
6709 up to date when the user logs off, or the system shuts down.
6712 shutdown_handler (DWORD type
)
6714 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
6715 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
6716 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
6717 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
6719 /* Shut down cleanly, making sure autosave files are up to date. */
6720 shut_down_emacs (0, Qnil
);
6723 /* Allow other handlers to handle this signal. */
6728 globals_of_w32 is used to initialize those global variables that
6729 must always be initialized on startup even when the global variable
6730 initialized is non zero (see the function main in emacs.c).
6733 globals_of_w32 (void)
6735 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
6737 get_process_times_fn
= (GetProcessTimes_Proc
)
6738 GetProcAddress (kernel32
, "GetProcessTimes");
6740 DEFSYM (QCloaded_from
, ":loaded-from");
6742 g_b_init_is_windows_9x
= 0;
6743 g_b_init_open_process_token
= 0;
6744 g_b_init_get_token_information
= 0;
6745 g_b_init_lookup_account_sid
= 0;
6746 g_b_init_get_sid_sub_authority
= 0;
6747 g_b_init_get_sid_sub_authority_count
= 0;
6748 g_b_init_get_security_info
= 0;
6749 g_b_init_get_file_security
= 0;
6750 g_b_init_get_security_descriptor_owner
= 0;
6751 g_b_init_get_security_descriptor_group
= 0;
6752 g_b_init_is_valid_sid
= 0;
6753 g_b_init_create_toolhelp32_snapshot
= 0;
6754 g_b_init_process32_first
= 0;
6755 g_b_init_process32_next
= 0;
6756 g_b_init_open_thread_token
= 0;
6757 g_b_init_impersonate_self
= 0;
6758 g_b_init_revert_to_self
= 0;
6759 g_b_init_get_process_memory_info
= 0;
6760 g_b_init_get_process_working_set_size
= 0;
6761 g_b_init_global_memory_status
= 0;
6762 g_b_init_global_memory_status_ex
= 0;
6763 g_b_init_equal_sid
= 0;
6764 g_b_init_copy_sid
= 0;
6765 g_b_init_get_length_sid
= 0;
6766 g_b_init_get_native_system_info
= 0;
6767 g_b_init_get_system_times
= 0;
6768 g_b_init_create_symbolic_link
= 0;
6769 num_of_processors
= 0;
6770 /* The following sets a handler for shutdown notifications for
6771 console apps. This actually applies to Emacs in both console and
6772 GUI modes, since we had to fool windows into thinking emacs is a
6773 console application to get console mode to work. */
6774 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
6776 /* "None" is the default group name on standalone workstations. */
6777 strcpy (dflt_group_name
, "None");
6780 /* For make-serial-process */
6782 serial_open (char *port
)
6788 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
6789 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
6790 if (hnd
== INVALID_HANDLE_VALUE
)
6791 error ("Could not open %s", port
);
6792 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
6794 error ("Could not open %s", port
);
6798 error ("Could not create child process");
6800 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6801 fd_info
[ fd
].hnd
= hnd
;
6802 fd_info
[ fd
].flags
|=
6803 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
6804 if (fd_info
[ fd
].cp
!= NULL
)
6806 error ("fd_info[fd = %d] is already in use", fd
);
6808 fd_info
[ fd
].cp
= cp
;
6809 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6810 if (cp
->ovl_read
.hEvent
== NULL
)
6811 error ("Could not create read event");
6812 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6813 if (cp
->ovl_write
.hEvent
== NULL
)
6814 error ("Could not create write event");
6819 /* For serial-process-configure */
6821 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
6823 Lisp_Object childp2
= Qnil
;
6824 Lisp_Object tem
= Qnil
;
6828 char summary
[4] = "???"; /* This usually becomes "8N1". */
6830 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
6831 error ("Not a serial process");
6832 hnd
= fd_info
[ p
->outfd
].hnd
;
6834 childp2
= Fcopy_sequence (p
->childp
);
6836 /* Initialize timeouts for blocking read and blocking write. */
6837 if (!GetCommTimeouts (hnd
, &ct
))
6838 error ("GetCommTimeouts() failed");
6839 ct
.ReadIntervalTimeout
= 0;
6840 ct
.ReadTotalTimeoutMultiplier
= 0;
6841 ct
.ReadTotalTimeoutConstant
= 0;
6842 ct
.WriteTotalTimeoutMultiplier
= 0;
6843 ct
.WriteTotalTimeoutConstant
= 0;
6844 if (!SetCommTimeouts (hnd
, &ct
))
6845 error ("SetCommTimeouts() failed");
6846 /* Read port attributes and prepare default configuration. */
6847 memset (&dcb
, 0, sizeof (dcb
));
6848 dcb
.DCBlength
= sizeof (DCB
);
6849 if (!GetCommState (hnd
, &dcb
))
6850 error ("GetCommState() failed");
6853 dcb
.fAbortOnError
= FALSE
;
6854 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
6859 /* Configure speed. */
6860 if (!NILP (Fplist_member (contact
, QCspeed
)))
6861 tem
= Fplist_get (contact
, QCspeed
);
6863 tem
= Fplist_get (p
->childp
, QCspeed
);
6865 dcb
.BaudRate
= XINT (tem
);
6866 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
6868 /* Configure bytesize. */
6869 if (!NILP (Fplist_member (contact
, QCbytesize
)))
6870 tem
= Fplist_get (contact
, QCbytesize
);
6872 tem
= Fplist_get (p
->childp
, QCbytesize
);
6874 tem
= make_number (8);
6876 if (XINT (tem
) != 7 && XINT (tem
) != 8)
6877 error (":bytesize must be nil (8), 7, or 8");
6878 dcb
.ByteSize
= XINT (tem
);
6879 summary
[0] = XINT (tem
) + '0';
6880 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
6882 /* Configure parity. */
6883 if (!NILP (Fplist_member (contact
, QCparity
)))
6884 tem
= Fplist_get (contact
, QCparity
);
6886 tem
= Fplist_get (p
->childp
, QCparity
);
6887 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6888 error (":parity must be nil (no parity), `even', or `odd'");
6889 dcb
.fParity
= FALSE
;
6890 dcb
.Parity
= NOPARITY
;
6891 dcb
.fErrorChar
= FALSE
;
6896 else if (EQ (tem
, Qeven
))
6900 dcb
.Parity
= EVENPARITY
;
6901 dcb
.fErrorChar
= TRUE
;
6903 else if (EQ (tem
, Qodd
))
6907 dcb
.Parity
= ODDPARITY
;
6908 dcb
.fErrorChar
= TRUE
;
6910 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6912 /* Configure stopbits. */
6913 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6914 tem
= Fplist_get (contact
, QCstopbits
);
6916 tem
= Fplist_get (p
->childp
, QCstopbits
);
6918 tem
= make_number (1);
6920 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6921 error (":stopbits must be nil (1 stopbit), 1, or 2");
6922 summary
[2] = XINT (tem
) + '0';
6923 if (XINT (tem
) == 1)
6924 dcb
.StopBits
= ONESTOPBIT
;
6925 else if (XINT (tem
) == 2)
6926 dcb
.StopBits
= TWOSTOPBITS
;
6927 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6929 /* Configure flowcontrol. */
6930 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6931 tem
= Fplist_get (contact
, QCflowcontrol
);
6933 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6934 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6935 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6936 dcb
.fOutxCtsFlow
= FALSE
;
6937 dcb
.fOutxDsrFlow
= FALSE
;
6938 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6939 dcb
.fDsrSensitivity
= FALSE
;
6940 dcb
.fTXContinueOnXoff
= FALSE
;
6943 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6944 dcb
.XonChar
= 17; /* Control-Q */
6945 dcb
.XoffChar
= 19; /* Control-S */
6948 /* Already configured. */
6950 else if (EQ (tem
, Qhw
))
6952 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6953 dcb
.fOutxCtsFlow
= TRUE
;
6955 else if (EQ (tem
, Qsw
))
6960 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6962 /* Activate configuration. */
6963 if (!SetCommState (hnd
, &dcb
))
6964 error ("SetCommState() failed");
6966 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6967 pset_childp (p
, childp2
);
6973 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
6977 struct timeval timeout
;
6978 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
6979 int fd
= process
->infd
;
6983 n
= sys_read (fd
, (char*)buf
, sz
);
6990 if (err
== EWOULDBLOCK
)
6992 /* Set a small timeout. */
6994 timeout
.tv_usec
= 0;
6996 FD_SET ((int)fd
, &fdset
);
6998 /* Use select with the timeout to poll the selector. */
6999 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7003 continue; /* Try again. */
7005 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7006 Also accept select return 0 as an indicator to EAGAIN. */
7007 if (sc
== 0 || errno
== EWOULDBLOCK
)
7010 err
= errno
; /* Other errors are just passed on. */
7013 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7020 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7022 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7023 int fd
= process
->outfd
;
7024 ssize_t n
= sys_write (fd
, buf
, sz
);
7026 /* 0 or more bytes written means everything went fine. */
7030 /* Negative bytes written means we got an error in errno.
7031 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7032 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7033 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7037 #endif /* HAVE_GNUTLS */