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)
1744 p
= strrchr (modname
, '\\');
1748 p
= strrchr (modname
, '\\');
1749 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1751 char buf
[SET_ENV_BUF_SIZE
];
1754 for (p
= modname
; *p
; p
++)
1755 if (*p
== '\\') *p
= '/';
1757 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1758 _putenv (strdup (buf
));
1764 for (i
= 0; i
< N_ENV_VARS
; i
++)
1766 if (!getenv (env_vars
[i
].name
))
1770 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1771 /* Also ignore empty environment variables. */
1775 lpval
= env_vars
[i
].def_value
;
1776 dwType
= REG_EXPAND_SZ
;
1778 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
1779 Vdelayed_warnings_list
1780 = Fcons (listn (CONSTYPE_HEAP
, 2,
1781 intern ("initialization"),
1782 build_string ("Setting HOME to C:\\ by default is deprecated")),
1783 Vdelayed_warnings_list
);
1788 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1790 if (dwType
== REG_EXPAND_SZ
)
1791 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1792 else if (dwType
== REG_SZ
)
1793 strcpy (buf1
, lpval
);
1794 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1796 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1798 _putenv (strdup (buf2
));
1808 /* Rebuild system configuration to reflect invoking system. */
1809 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1811 /* Another special case: on NT, the PATH variable is actually named
1812 "Path" although cmd.exe (perhaps NT itself) arranges for
1813 environment variable lookup and setting to be case insensitive.
1814 However, Emacs assumes a fully case sensitive environment, so we
1815 need to change "Path" to "PATH" to match the expectations of
1816 various elisp packages. We do this by the sneaky method of
1817 modifying the string in the C runtime environ entry.
1819 The same applies to COMSPEC. */
1823 for (envp
= environ
; *envp
; envp
++)
1824 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1825 memcpy (*envp
, "PATH=", 5);
1826 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1827 memcpy (*envp
, "COMSPEC=", 8);
1830 /* Remember the initial working directory for getwd. */
1831 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
1832 Does it matter anywhere in Emacs? */
1833 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1837 static char modname
[MAX_PATH
];
1839 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1844 /* Determine if there is a middle mouse button, to allow parse_button
1845 to decide whether right mouse events should be mouse-2 or
1847 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1852 /* Called from expand-file-name when default-directory is not a string. */
1855 emacs_root_dir (void)
1857 static char root_dir
[FILENAME_MAX
];
1860 p
= getenv ("emacs_dir");
1863 strcpy (root_dir
, p
);
1864 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1865 dostounix_filename (root_dir
);
1869 /* We don't have scripts to automatically determine the system configuration
1870 for Emacs before it's compiled, and we don't want to have to make the
1871 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1875 get_emacs_configuration (void)
1877 char *arch
, *oem
, *os
;
1879 static char configuration_buffer
[32];
1881 /* Determine the processor type. */
1882 switch (get_processor_type ())
1885 #ifdef PROCESSOR_INTEL_386
1886 case PROCESSOR_INTEL_386
:
1887 case PROCESSOR_INTEL_486
:
1888 case PROCESSOR_INTEL_PENTIUM
:
1893 #ifdef PROCESSOR_MIPS_R2000
1894 case PROCESSOR_MIPS_R2000
:
1895 case PROCESSOR_MIPS_R3000
:
1896 case PROCESSOR_MIPS_R4000
:
1901 #ifdef PROCESSOR_ALPHA_21064
1902 case PROCESSOR_ALPHA_21064
:
1912 /* Use the OEM field to reflect the compiler/library combination. */
1914 #define COMPILER_NAME "msvc"
1917 #define COMPILER_NAME "mingw"
1919 #define COMPILER_NAME "unknown"
1922 oem
= COMPILER_NAME
;
1924 switch (osinfo_cache
.dwPlatformId
) {
1925 case VER_PLATFORM_WIN32_NT
:
1927 build_num
= osinfo_cache
.dwBuildNumber
;
1929 case VER_PLATFORM_WIN32_WINDOWS
:
1930 if (osinfo_cache
.dwMinorVersion
== 0) {
1935 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1937 case VER_PLATFORM_WIN32s
:
1938 /* Not supported, should not happen. */
1940 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1948 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1949 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1950 get_w32_major_version (), get_w32_minor_version (), build_num
);
1952 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1955 return configuration_buffer
;
1959 get_emacs_configuration_options (void)
1961 static char *options_buffer
;
1962 char cv
[32]; /* Enough for COMPILER_VERSION. */
1964 cv
, /* To be filled later. */
1968 #ifdef ENABLE_CHECKING
1969 " --enable-checking",
1971 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1972 with a starting space to save work here. */
1974 " --cflags", USER_CFLAGS
,
1977 " --ldflags", USER_LDFLAGS
,
1984 /* Work out the effective configure options for this build. */
1986 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
1989 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
1991 #define COMPILER_VERSION ""
1995 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
1996 return "Error: not enough space for compiler version";
1997 cv
[sizeof (cv
) - 1] = '\0';
1999 for (i
= 0; options
[i
]; i
++)
2000 size
+= strlen (options
[i
]);
2002 options_buffer
= xmalloc (size
+ 1);
2003 options_buffer
[0] = '\0';
2005 for (i
= 0; options
[i
]; i
++)
2006 strcat (options_buffer
, options
[i
]);
2008 return options_buffer
;
2012 #include <sys/timeb.h>
2014 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2016 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2021 tv
->tv_sec
= tb
.time
;
2022 tv
->tv_usec
= tb
.millitm
* 1000L;
2023 /* Implementation note: _ftime sometimes doesn't update the dstflag
2024 according to the new timezone when the system timezone is
2025 changed. We could fix that by using GetSystemTime and
2026 GetTimeZoneInformation, but that doesn't seem necessary, since
2027 Emacs always calls gettimeofday with the 2nd argument NULL (see
2028 current_emacs_time). */
2031 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2032 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2036 /* Emulate fdutimens. */
2038 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2039 TIMESPEC[0] and TIMESPEC[1], respectively.
2040 FD must be either negative -- in which case it is ignored --
2041 or a file descriptor that is open on FILE.
2042 If FD is nonnegative, then FILE can be NULL, which means
2043 use just futimes instead of utimes.
2044 If TIMESPEC is null, FAIL.
2045 Return 0 on success, -1 (setting errno) on failure. */
2048 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2057 if (fd
< 0 && !file
)
2062 ut
.actime
= timespec
[0].tv_sec
;
2063 ut
.modtime
= timespec
[1].tv_sec
;
2065 return _futime (fd
, &ut
);
2067 return _utime (file
, &ut
);
2071 /* ------------------------------------------------------------------------- */
2072 /* IO support and wrapper functions for the Windows API. */
2073 /* ------------------------------------------------------------------------- */
2075 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2076 on network directories, so we handle that case here.
2077 (Ulrich Leodolter, 1/11/95). */
2079 sys_ctime (const time_t *t
)
2081 char *str
= (char *) ctime (t
);
2082 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2085 /* Emulate sleep...we could have done this with a define, but that
2086 would necessitate including windows.h in the files that used it.
2087 This is much easier. */
2089 sys_sleep (int seconds
)
2091 Sleep (seconds
* 1000);
2094 /* Internal MSVC functions for low-level descriptor munging */
2095 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2096 extern int __cdecl
_free_osfhnd (int fd
);
2098 /* parallel array of private info on file handles */
2099 filedesc fd_info
[ MAXDESC
];
2101 typedef struct volume_info_data
{
2102 struct volume_info_data
* next
;
2104 /* time when info was obtained */
2107 /* actual volume info */
2116 /* Global referenced by various functions. */
2117 static volume_info_data volume_info
;
2119 /* Vector to indicate which drives are local and fixed (for which cached
2120 data never expires). */
2121 static BOOL fixed_drives
[26];
2123 /* Consider cached volume information to be stale if older than 10s,
2124 at least for non-local drives. Info for fixed drives is never stale. */
2125 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2126 #define VOLINFO_STILL_VALID( root_dir, info ) \
2127 ( ( isalpha (root_dir[0]) && \
2128 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2129 || GetTickCount () - info->timestamp < 10000 )
2131 /* Cache support functions. */
2133 /* Simple linked list with linear search is sufficient. */
2134 static volume_info_data
*volume_cache
= NULL
;
2136 static volume_info_data
*
2137 lookup_volume_info (char * root_dir
)
2139 volume_info_data
* info
;
2141 for (info
= volume_cache
; info
; info
= info
->next
)
2142 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2148 add_volume_info (char * root_dir
, volume_info_data
* info
)
2150 info
->root_dir
= xstrdup (root_dir
);
2151 info
->next
= volume_cache
;
2152 volume_cache
= info
;
2156 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2157 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2158 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2159 static volume_info_data
*
2160 GetCachedVolumeInformation (char * root_dir
)
2162 volume_info_data
* info
;
2163 char default_root
[ MAX_PATH
];
2165 /* NULL for root_dir means use root from current directory. */
2166 if (root_dir
== NULL
)
2168 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2170 parse_root (default_root
, &root_dir
);
2172 root_dir
= default_root
;
2175 /* Local fixed drives can be cached permanently. Removable drives
2176 cannot be cached permanently, since the volume name and serial
2177 number (if nothing else) can change. Remote drives should be
2178 treated as if they are removable, since there is no sure way to
2179 tell whether they are or not. Also, the UNC association of drive
2180 letters mapped to remote volumes can be changed at any time (even
2181 by other processes) without notice.
2183 As a compromise, so we can benefit from caching info for remote
2184 volumes, we use a simple expiry mechanism to invalidate cache
2185 entries that are more than ten seconds old. */
2188 /* No point doing this, because WNetGetConnection is even slower than
2189 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2190 GetDriveType is about the only call of this type which does not
2191 involve network access, and so is extremely quick). */
2193 /* Map drive letter to UNC if remote. */
2194 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2196 char remote_name
[ 256 ];
2197 char drive
[3] = { root_dir
[0], ':' };
2199 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2201 /* do something */ ;
2205 info
= lookup_volume_info (root_dir
);
2207 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2215 /* Info is not cached, or is stale. */
2216 if (!GetVolumeInformation (root_dir
,
2217 name
, sizeof (name
),
2221 type
, sizeof (type
)))
2224 /* Cache the volume information for future use, overwriting existing
2225 entry if present. */
2228 info
= xmalloc (sizeof (volume_info_data
));
2229 add_volume_info (root_dir
, info
);
2237 info
->name
= xstrdup (name
);
2238 info
->serialnum
= serialnum
;
2239 info
->maxcomp
= maxcomp
;
2240 info
->flags
= flags
;
2241 info
->type
= xstrdup (type
);
2242 info
->timestamp
= GetTickCount ();
2248 /* Get information on the volume where NAME is held; set path pointer to
2249 start of pathname in NAME (past UNC header\volume header if present),
2250 if pPath is non-NULL.
2252 Note: if NAME includes symlinks, the information is for the volume
2253 of the symlink, not of its target. That's because, even though
2254 GetVolumeInformation returns information about the symlink target
2255 of its argument, we only pass the root directory to
2256 GetVolumeInformation, not the full NAME. */
2258 get_volume_info (const char * name
, const char ** pPath
)
2260 char temp
[MAX_PATH
];
2261 char *rootname
= NULL
; /* default to current volume */
2262 volume_info_data
* info
;
2267 /* Find the root name of the volume if given. */
2268 if (isalpha (name
[0]) && name
[1] == ':')
2276 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2283 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2296 info
= GetCachedVolumeInformation (rootname
);
2299 /* Set global referenced by other functions. */
2300 volume_info
= *info
;
2306 /* Determine if volume is FAT format (ie. only supports short 8.3
2307 names); also set path pointer to start of pathname in name, if
2308 pPath is non-NULL. */
2310 is_fat_volume (const char * name
, const char ** pPath
)
2312 if (get_volume_info (name
, pPath
))
2313 return (volume_info
.maxcomp
== 12);
2317 /* Map filename to a valid 8.3 name if necessary.
2318 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2320 map_w32_filename (const char * name
, const char ** pPath
)
2322 static char shortname
[MAX_PATH
];
2323 char * str
= shortname
;
2326 const char * save_name
= name
;
2328 if (strlen (name
) >= MAX_PATH
)
2330 /* Return a filename which will cause callers to fail. */
2331 strcpy (shortname
, "?");
2335 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2337 register int left
= 8; /* maximum number of chars in part */
2338 register int extn
= 0; /* extension added? */
2339 register int dots
= 2; /* maximum number of dots allowed */
2342 *str
++ = *name
++; /* skip past UNC header */
2344 while ((c
= *name
++))
2351 *str
++ = (c
== ':' ? ':' : '\\');
2352 extn
= 0; /* reset extension flags */
2353 dots
= 2; /* max 2 dots */
2354 left
= 8; /* max length 8 for main part */
2359 /* Convert path components of the form .xxx to _xxx,
2360 but leave . and .. as they are. This allows .emacs
2361 to be read as _emacs, for example. */
2365 IS_DIRECTORY_SEP (*name
))
2380 extn
= 1; /* we've got an extension */
2381 left
= 3; /* 3 chars in extension */
2385 /* any embedded dots after the first are converted to _ */
2390 case '#': /* don't lose these, they're important */
2392 str
[-1] = c
; /* replace last character of part */
2397 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2399 dots
= 0; /* started a path component */
2408 strcpy (shortname
, name
);
2409 unixtodos_filename (shortname
);
2413 *pPath
= shortname
+ (path
- save_name
);
2419 is_exec (const char * name
)
2421 char * p
= strrchr (name
, '.');
2424 && (xstrcasecmp (p
, ".exe") == 0 ||
2425 xstrcasecmp (p
, ".com") == 0 ||
2426 xstrcasecmp (p
, ".bat") == 0 ||
2427 xstrcasecmp (p
, ".cmd") == 0));
2430 /* Emulate the Unix directory procedures opendir, closedir,
2431 and readdir. We can't use the procedures supplied in sysdep.c,
2432 so we provide them here. */
2434 struct direct dir_static
; /* simulated directory contents */
2435 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2436 static int dir_is_fat
;
2437 static char dir_pathname
[MAXPATHLEN
+1];
2438 static WIN32_FIND_DATA dir_find_data
;
2440 /* Support shares on a network resource as subdirectories of a read-only
2442 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2443 static HANDLE
open_unc_volume (const char *);
2444 static char *read_unc_volume (HANDLE
, char *, int);
2445 static void close_unc_volume (HANDLE
);
2448 opendir (char *filename
)
2452 /* Opening is done by FindFirstFile. However, a read is inherent to
2453 this operation, so we defer the open until read time. */
2455 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2457 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2460 /* Note: We don't support traversal of UNC volumes via symlinks.
2461 Doing so would mean punishing 99.99% of use cases by resolving
2462 all the possible symlinks in FILENAME, recursively. */
2463 if (is_unc_volume (filename
))
2465 wnet_enum_handle
= open_unc_volume (filename
);
2466 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2470 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2477 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2478 dir_pathname
[MAXPATHLEN
] = '\0';
2479 /* Note: We don't support symlinks to file names on FAT volumes.
2480 Doing so would mean punishing 99.99% of use cases by resolving
2481 all the possible symlinks in FILENAME, recursively. */
2482 dir_is_fat
= is_fat_volume (filename
, NULL
);
2488 closedir (DIR *dirp
)
2490 /* If we have a find-handle open, close it. */
2491 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2493 FindClose (dir_find_handle
);
2494 dir_find_handle
= INVALID_HANDLE_VALUE
;
2496 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2498 close_unc_volume (wnet_enum_handle
);
2499 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2501 xfree ((char *) dirp
);
2507 int downcase
= !NILP (Vw32_downcase_file_names
);
2509 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2511 if (!read_unc_volume (wnet_enum_handle
,
2512 dir_find_data
.cFileName
,
2516 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2517 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2519 char filename
[MAXNAMLEN
+ 3];
2522 strcpy (filename
, dir_pathname
);
2523 ln
= strlen (filename
) - 1;
2524 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2525 strcat (filename
, "\\");
2526 strcat (filename
, "*");
2528 /* Note: No need to resolve symlinks in FILENAME, because
2529 FindFirst opens the directory that is the target of a
2531 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2533 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2538 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2542 /* Emacs never uses this value, so don't bother making it match
2543 value returned by stat(). */
2544 dir_static
.d_ino
= 1;
2546 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2548 /* If the file name in cFileName[] includes `?' characters, it means
2549 the original file name used characters that cannot be represented
2550 by the current ANSI codepage. To avoid total lossage, retrieve
2551 the short 8+3 alias of the long file name. */
2552 if (_mbspbrk (dir_static
.d_name
, "?"))
2554 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2555 downcase
= 1; /* 8+3 aliases are returned in all caps */
2557 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2558 dir_static
.d_reclen
= sizeof (struct direct
) - MAXNAMLEN
+ 3 +
2559 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2561 /* If the file name in cFileName[] includes `?' characters, it means
2562 the original file name used characters that cannot be represented
2563 by the current ANSI codepage. To avoid total lossage, retrieve
2564 the short 8+3 alias of the long file name. */
2565 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2567 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2568 /* 8+3 aliases are returned in all caps, which could break
2569 various alists that look at filenames' extensions. */
2573 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2574 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2576 _strlwr (dir_static
.d_name
);
2580 for (p
= dir_static
.d_name
; *p
; p
++)
2581 if (*p
>= 'a' && *p
<= 'z')
2584 _strlwr (dir_static
.d_name
);
2591 open_unc_volume (const char *path
)
2597 nr
.dwScope
= RESOURCE_GLOBALNET
;
2598 nr
.dwType
= RESOURCETYPE_DISK
;
2599 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2600 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2601 nr
.lpLocalName
= NULL
;
2602 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2603 nr
.lpComment
= NULL
;
2604 nr
.lpProvider
= NULL
;
2606 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2607 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2609 if (result
== NO_ERROR
)
2612 return INVALID_HANDLE_VALUE
;
2616 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2620 DWORD bufsize
= 512;
2625 buffer
= alloca (bufsize
);
2626 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2627 if (result
!= NO_ERROR
)
2630 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2631 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2633 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2636 strncpy (readbuf
, ptr
, size
);
2641 close_unc_volume (HANDLE henum
)
2643 if (henum
!= INVALID_HANDLE_VALUE
)
2644 WNetCloseEnum (henum
);
2648 unc_volume_file_attributes (const char *path
)
2653 henum
= open_unc_volume (path
);
2654 if (henum
== INVALID_HANDLE_VALUE
)
2657 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2659 close_unc_volume (henum
);
2664 /* Ensure a network connection is authenticated. */
2666 logon_network_drive (const char *path
)
2668 NETRESOURCE resource
;
2669 char share
[MAX_PATH
];
2674 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2675 drvtype
= DRIVE_REMOTE
;
2676 else if (path
[0] == '\0' || path
[1] != ':')
2677 drvtype
= GetDriveType (NULL
);
2684 drvtype
= GetDriveType (drive
);
2687 /* Only logon to networked drives. */
2688 if (drvtype
!= DRIVE_REMOTE
)
2692 strncpy (share
, path
, MAX_PATH
);
2693 /* Truncate to just server and share name. */
2694 for (i
= 2; i
< MAX_PATH
; i
++)
2696 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2703 resource
.dwType
= RESOURCETYPE_DISK
;
2704 resource
.lpLocalName
= NULL
;
2705 resource
.lpRemoteName
= share
;
2706 resource
.lpProvider
= NULL
;
2708 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2711 /* Shadow some MSVC runtime functions to map requests for long filenames
2712 to reasonable short names if necessary. This was originally added to
2713 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2717 sys_access (const char * path
, int mode
)
2721 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
2722 newer versions blow up when passed D_OK. */
2723 path
= map_w32_filename (path
, NULL
);
2724 /* If the last element of PATH is a symlink, we need to resolve it
2725 to get the attributes of its target file. Note: any symlinks in
2726 PATH elements other than the last one are transparently resolved
2727 by GetFileAttributes below. */
2728 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
2729 path
= chase_symlinks (path
);
2731 if ((attributes
= GetFileAttributes (path
)) == -1)
2733 DWORD w32err
= GetLastError ();
2737 case ERROR_INVALID_NAME
:
2738 case ERROR_BAD_PATHNAME
:
2739 if (is_unc_volume (path
))
2741 attributes
= unc_volume_file_attributes (path
);
2742 if (attributes
== -1)
2750 case ERROR_FILE_NOT_FOUND
:
2751 case ERROR_BAD_NETPATH
:
2760 if ((mode
& X_OK
) != 0 && !is_exec (path
))
2765 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2770 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2779 sys_chdir (const char * path
)
2781 return _chdir (map_w32_filename (path
, NULL
));
2785 sys_chmod (const char * path
, int mode
)
2787 path
= chase_symlinks (map_w32_filename (path
, NULL
));
2788 return _chmod (path
, mode
);
2792 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2794 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2800 sys_creat (const char * path
, int mode
)
2802 return _creat (map_w32_filename (path
, NULL
), mode
);
2806 sys_fopen (const char * path
, const char * mode
)
2810 const char * mode_save
= mode
;
2812 /* Force all file handles to be non-inheritable. This is necessary to
2813 ensure child processes don't unwittingly inherit handles that might
2814 prevent future file access. */
2818 else if (mode
[0] == 'w' || mode
[0] == 'a')
2819 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2823 /* Only do simplistic option parsing. */
2827 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2830 else if (mode
[0] == 'b')
2835 else if (mode
[0] == 't')
2842 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2846 return _fdopen (fd
, mode_save
);
2849 /* This only works on NTFS volumes, but is useful to have. */
2851 sys_link (const char * old
, const char * new)
2855 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2857 if (old
== NULL
|| new == NULL
)
2863 strcpy (oldname
, map_w32_filename (old
, NULL
));
2864 strcpy (newname
, map_w32_filename (new, NULL
));
2866 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2867 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2868 if (fileh
!= INVALID_HANDLE_VALUE
)
2872 /* Confusingly, the "alternate" stream name field does not apply
2873 when restoring a hard link, and instead contains the actual
2874 stream data for the link (ie. the name of the link to create).
2875 The WIN32_STREAM_ID structure before the cStreamName field is
2876 the stream header, which is then immediately followed by the
2880 WIN32_STREAM_ID wid
;
2881 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2884 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2885 data
.wid
.cStreamName
, MAX_PATH
);
2888 LPVOID context
= NULL
;
2891 data
.wid
.dwStreamId
= BACKUP_LINK
;
2892 data
.wid
.dwStreamAttributes
= 0;
2893 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
2894 data
.wid
.Size
.HighPart
= 0;
2895 data
.wid
.dwStreamNameSize
= 0;
2897 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2898 offsetof (WIN32_STREAM_ID
, cStreamName
)
2899 + data
.wid
.Size
.LowPart
,
2900 &wbytes
, FALSE
, FALSE
, &context
)
2901 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2908 /* Should try mapping GetLastError to errno; for now just
2909 indicate a general error (eg. links not supported). */
2910 errno
= EINVAL
; // perhaps EMLINK?
2914 CloseHandle (fileh
);
2923 sys_mkdir (const char * path
)
2925 return _mkdir (map_w32_filename (path
, NULL
));
2928 /* Because of long name mapping issues, we need to implement this
2929 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2930 a unique name, instead of setting the input template to an empty
2933 Standard algorithm seems to be use pid or tid with a letter on the
2934 front (in place of the 6 X's) and cycle through the letters to find a
2935 unique name. We extend that to allow any reasonable character as the
2936 first of the 6 X's. */
2938 sys_mktemp (char * template)
2942 unsigned uid
= GetCurrentThreadId ();
2943 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2945 if (template == NULL
)
2947 p
= template + strlen (template);
2949 /* replace up to the last 5 X's with uid in decimal */
2950 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2952 p
[0] = '0' + uid
% 10;
2956 if (i
< 0 && p
[0] == 'X')
2961 int save_errno
= errno
;
2962 p
[0] = first_char
[i
];
2963 if (sys_access (template, 0) < 0)
2969 while (++i
< sizeof (first_char
));
2972 /* Template is badly formed or else we can't generate a unique name,
2973 so return empty string */
2979 sys_open (const char * path
, int oflag
, int mode
)
2981 const char* mpath
= map_w32_filename (path
, NULL
);
2982 /* Try to open file without _O_CREAT, to be able to write to hidden
2983 and system files. Force all file handles to be
2985 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
2988 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
2992 sys_rename (const char * oldname
, const char * newname
)
2995 char temp
[MAX_PATH
];
2999 /* MoveFile on Windows 95 doesn't correctly change the short file name
3000 alias in a number of circumstances (it is not easy to predict when
3001 just by looking at oldname and newname, unfortunately). In these
3002 cases, renaming through a temporary name avoids the problem.
3004 A second problem on Windows 95 is that renaming through a temp name when
3005 newname is uppercase fails (the final long name ends up in
3006 lowercase, although the short alias might be uppercase) UNLESS the
3007 long temp name is not 8.3.
3009 So, on Windows 95 we always rename through a temp name, and we make sure
3010 the temp name has a long extension to ensure correct renaming. */
3012 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3014 /* volume_info is set indirectly by map_w32_filename. */
3015 oldname_dev
= volume_info
.serialnum
;
3017 if (os_subtype
== OS_9X
)
3023 oldname
= map_w32_filename (oldname
, NULL
);
3024 if ((o
= strrchr (oldname
, '\\')))
3027 o
= (char *) oldname
;
3029 if ((p
= strrchr (temp
, '\\')))
3036 /* Force temp name to require a manufactured 8.3 alias - this
3037 seems to make the second rename work properly. */
3038 sprintf (p
, "_.%s.%u", o
, i
);
3040 result
= rename (oldname
, temp
);
3042 /* This loop must surely terminate! */
3043 while (result
< 0 && errno
== EEXIST
);
3048 /* Emulate Unix behavior - newname is deleted if it already exists
3049 (at least if it is a file; don't do this for directories).
3051 Since we mustn't do this if we are just changing the case of the
3052 file name (we would end up deleting the file we are trying to
3053 rename!), we let rename detect if the destination file already
3054 exists - that way we avoid the possible pitfalls of trying to
3055 determine ourselves whether two names really refer to the same
3056 file, which is not always possible in the general case. (Consider
3057 all the permutations of shared or subst'd drives, etc.) */
3059 newname
= map_w32_filename (newname
, NULL
);
3061 /* volume_info is set indirectly by map_w32_filename. */
3062 newname_dev
= volume_info
.serialnum
;
3064 result
= rename (temp
, newname
);
3068 DWORD w32err
= GetLastError ();
3071 && newname_dev
!= oldname_dev
)
3073 /* The implementation of `rename' on Windows does not return
3074 errno = EXDEV when you are moving a directory to a
3075 different storage device (ex. logical disk). It returns
3076 EACCES instead. So here we handle such situations and
3080 if ((attributes
= GetFileAttributes (temp
)) != -1
3081 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3084 else if (errno
== EEXIST
)
3086 if (_chmod (newname
, 0666) != 0)
3088 if (_unlink (newname
) != 0)
3090 result
= rename (temp
, newname
);
3092 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3093 && is_symlink (temp
))
3095 /* This is Windows prohibiting the user from creating a
3096 symlink in another place, since that requires
3106 sys_rmdir (const char * path
)
3108 return _rmdir (map_w32_filename (path
, NULL
));
3112 sys_unlink (const char * path
)
3114 path
= map_w32_filename (path
, NULL
);
3116 /* On Unix, unlink works without write permission. */
3117 _chmod (path
, 0666);
3118 return _unlink (path
);
3121 static FILETIME utc_base_ft
;
3122 static ULONGLONG utc_base
; /* In 100ns units */
3123 static int init
= 0;
3125 #define FILETIME_TO_U64(result, ft) \
3127 ULARGE_INTEGER uiTemp; \
3128 uiTemp.LowPart = (ft).dwLowDateTime; \
3129 uiTemp.HighPart = (ft).dwHighDateTime; \
3130 result = uiTemp.QuadPart; \
3134 initialize_utc_base (void)
3136 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3145 st
.wMilliseconds
= 0;
3147 SystemTimeToFileTime (&st
, &utc_base_ft
);
3148 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3152 convert_time (FILETIME ft
)
3158 initialize_utc_base ();
3162 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3165 FILETIME_TO_U64 (tmp
, ft
);
3166 return (time_t) ((tmp
- utc_base
) / 10000000L);
3170 convert_from_time_t (time_t time
, FILETIME
* pft
)
3176 initialize_utc_base ();
3180 /* time in 100ns units since 1-Jan-1601 */
3181 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3182 pft
->dwHighDateTime
= tmp
.HighPart
;
3183 pft
->dwLowDateTime
= tmp
.LowPart
;
3187 /* No reason to keep this; faking inode values either by hashing or even
3188 using the file index from GetInformationByHandle, is not perfect and
3189 so by default Emacs doesn't use the inode values on Windows.
3190 Instead, we now determine file-truename correctly (except for
3191 possible drive aliasing etc). */
3193 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3195 hashval (const unsigned char * str
)
3200 h
= (h
<< 4) + *str
++;
3206 /* Return the hash value of the canonical pathname, excluding the
3207 drive/UNC header, to get a hopefully unique inode number. */
3209 generate_inode_val (const char * name
)
3211 char fullname
[ MAX_PATH
];
3215 /* Get the truly canonical filename, if it exists. (Note: this
3216 doesn't resolve aliasing due to subst commands, or recognize hard
3218 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3221 parse_root (fullname
, &p
);
3222 /* Normal W32 filesystems are still case insensitive. */
3229 static PSECURITY_DESCRIPTOR
3230 get_file_security_desc_by_handle (HANDLE h
)
3232 PSECURITY_DESCRIPTOR psd
= NULL
;
3234 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3235 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3237 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3238 NULL
, NULL
, NULL
, NULL
, &psd
);
3239 if (err
!= ERROR_SUCCESS
)
3245 static PSECURITY_DESCRIPTOR
3246 get_file_security_desc_by_name (const char *fname
)
3248 PSECURITY_DESCRIPTOR psd
= NULL
;
3250 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3251 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3253 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3255 err
= GetLastError ();
3256 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3260 psd
= xmalloc (sd_len
);
3261 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3273 unsigned n_subauthorities
;
3275 /* Use the last sub-authority value of the RID, the relative
3276 portion of the SID, as user/group ID. */
3277 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3278 if (n_subauthorities
< 1)
3279 return 0; /* the "World" RID */
3280 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3283 /* Caching SID and account values for faster lokup. */
3286 # define FLEXIBLE_ARRAY_MEMBER
3288 # define FLEXIBLE_ARRAY_MEMBER 1
3293 struct w32_id
*next
;
3295 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3298 static struct w32_id
*w32_idlist
;
3301 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3303 struct w32_id
*tail
, *found
;
3305 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3307 if (equal_sid ((PSID
)tail
->sid
, sid
))
3316 strcpy (name
, found
->name
);
3324 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3327 struct w32_id
*new_entry
;
3329 /* We don't want to leave behind stale cache from when Emacs was
3333 sid_len
= get_length_sid (sid
);
3334 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3337 new_entry
->rid
= id
;
3338 strcpy (new_entry
->name
, name
);
3339 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3340 new_entry
->next
= w32_idlist
;
3341 w32_idlist
= new_entry
;
3350 get_name_and_id (PSECURITY_DESCRIPTOR psd
, const char *fname
,
3351 unsigned *id
, char *nm
, int what
)
3354 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3356 SID_NAME_USE ignore
;
3358 DWORD name_len
= sizeof (name
);
3360 DWORD domain_len
= sizeof (domain
);
3366 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3367 else if (what
== GID
)
3368 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3372 if (!result
|| !is_valid_sid (sid
))
3374 else if (!w32_cached_id (sid
, id
, nm
))
3376 /* If FNAME is a UNC, we need to lookup account on the
3377 specified machine. */
3378 if (IS_DIRECTORY_SEP (fname
[0]) && IS_DIRECTORY_SEP (fname
[1])
3379 && fname
[2] != '\0')
3384 for (s
= fname
+ 2, p
= machine
;
3385 *s
&& !IS_DIRECTORY_SEP (*s
); s
++, p
++)
3391 if (!lookup_account_sid (mp
, sid
, name
, &name_len
,
3392 domain
, &domain_len
, &ignore
)
3393 || name_len
> UNLEN
+1)
3397 *id
= get_rid (sid
);
3399 w32_add_to_cache (sid
, *id
, name
);
3406 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
,
3410 int dflt_usr
= 0, dflt_grp
= 0;
3419 if (get_name_and_id (psd
, fname
, &st
->st_uid
, st
->st_uname
, UID
))
3421 if (get_name_and_id (psd
, fname
, &st
->st_gid
, st
->st_gname
, GID
))
3424 /* Consider files to belong to current user/group, if we cannot get
3425 more accurate information. */
3428 st
->st_uid
= dflt_passwd
.pw_uid
;
3429 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3433 st
->st_gid
= dflt_passwd
.pw_gid
;
3434 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3438 /* Return non-zero if NAME is a potentially slow filesystem. */
3440 is_slow_fs (const char *name
)
3445 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3446 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3447 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3448 devtype
= GetDriveType (NULL
); /* use root of current drive */
3451 /* GetDriveType needs the root directory of the drive. */
3452 strncpy (drive_root
, name
, 2);
3453 drive_root
[2] = '\\';
3454 drive_root
[3] = '\0';
3455 devtype
= GetDriveType (drive_root
);
3457 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3460 /* MSVC stat function can't cope with UNC names and has other bugs, so
3461 replace it with our own. This also allows us to calculate consistent
3462 inode values and owner/group without hacks in the main Emacs code. */
3465 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3467 char *name
, *save_name
, *r
;
3468 WIN32_FIND_DATA wfd
;
3470 unsigned __int64 fake_inode
= 0;
3473 int rootdir
= FALSE
;
3474 PSECURITY_DESCRIPTOR psd
= NULL
;
3475 int is_a_symlink
= 0;
3476 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3477 DWORD access_rights
= 0;
3478 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3479 FILETIME ctime
, atime
, wtime
;
3481 if (path
== NULL
|| buf
== NULL
)
3487 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3488 /* Must be valid filename, no wild cards or other invalid
3489 characters. We use _mbspbrk to support multibyte strings that
3490 might look to strpbrk as if they included literal *, ?, and other
3491 characters mentioned below that are disallowed by Windows
3493 if (_mbspbrk (name
, "*?|<>\""))
3499 /* Remove trailing directory separator, unless name is the root
3500 directory of a drive or UNC volume in which case ensure there
3501 is a trailing separator. */
3502 len
= strlen (name
);
3503 name
= strcpy (alloca (len
+ 2), name
);
3505 /* Avoid a somewhat costly call to is_symlink if the filesystem
3506 doesn't support symlinks. */
3507 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3508 is_a_symlink
= is_symlink (name
);
3510 /* Plan A: Open the file and get all the necessary information via
3511 the resulting handle. This solves several issues in one blow:
3513 . retrieves attributes for the target of a symlink, if needed
3514 . gets attributes of root directories and symlinks pointing to
3515 root directories, thus avoiding the need for special-casing
3516 these and detecting them by examining the file-name format
3517 . retrieves more accurate attributes (e.g., non-zero size for
3518 some directories, esp. directories that are junction points)
3519 . correctly resolves "c:/..", "/.." and similar file names
3520 . avoids run-time penalties for 99% of use cases
3522 Plan A is always tried first, unless the user asked not to (but
3523 if the file is a symlink and we need to follow links, we try Plan
3524 A even if the user asked not to).
3526 If Plan A fails, we go to Plan B (below), where various
3527 potentially expensive techniques must be used to handle "special"
3528 files such as UNC volumes etc. */
3529 if (!(NILP (Vw32_get_true_file_attributes
)
3530 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3531 /* Following symlinks requires getting the info by handle. */
3532 || (is_a_symlink
&& follow_symlinks
))
3534 BY_HANDLE_FILE_INFORMATION info
;
3536 if (is_a_symlink
&& !follow_symlinks
)
3537 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3538 /* READ_CONTROL access rights are required to get security info
3539 by handle. But if the OS doesn't support security in the
3540 first place, we don't need to try. */
3541 if (is_windows_9x () != TRUE
)
3542 access_rights
|= READ_CONTROL
;
3544 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3546 /* If CreateFile fails with READ_CONTROL, try again with zero as
3548 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3549 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3551 if (fh
== INVALID_HANDLE_VALUE
)
3552 goto no_true_file_attributes
;
3554 /* This is more accurate in terms of getting the correct number
3555 of links, but is quite slow (it is noticeable when Emacs is
3556 making a list of file name completions). */
3557 if (GetFileInformationByHandle (fh
, &info
))
3559 nlinks
= info
.nNumberOfLinks
;
3560 /* Might as well use file index to fake inode values, but this
3561 is not guaranteed to be unique unless we keep a handle open
3562 all the time (even then there are situations where it is
3563 not unique). Reputedly, there are at most 48 bits of info
3564 (on NTFS, presumably less on FAT). */
3565 fake_inode
= info
.nFileIndexHigh
;
3567 fake_inode
+= info
.nFileIndexLow
;
3568 serialnum
= info
.dwVolumeSerialNumber
;
3569 fs_high
= info
.nFileSizeHigh
;
3570 fs_low
= info
.nFileSizeLow
;
3571 ctime
= info
.ftCreationTime
;
3572 atime
= info
.ftLastAccessTime
;
3573 wtime
= info
.ftLastWriteTime
;
3574 fattrs
= info
.dwFileAttributes
;
3578 /* We don't go to Plan B here, because it's not clear that
3579 it's a good idea. The only known use case where
3580 CreateFile succeeds, but GetFileInformationByHandle fails
3581 (with ERROR_INVALID_FUNCTION) is for character devices
3582 such as NUL, PRN, etc. For these, switching to Plan B is
3583 a net loss, because we lose the character device
3584 attribute returned by GetFileType below (FindFirstFile
3585 doesn't set that bit in the attributes), and the other
3586 fields don't make sense for character devices anyway.
3587 Emacs doesn't really care for non-file entities in the
3588 context of l?stat, so neither do we. */
3590 /* w32err is assigned so one could put a breakpoint here and
3591 examine its value, when GetFileInformationByHandle
3593 DWORD w32err
= GetLastError ();
3597 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3603 /* Test for a symlink before testing for a directory, since
3604 symlinks to directories have the directory bit set, but we
3605 don't want them to appear as directories. */
3606 if (is_a_symlink
&& !follow_symlinks
)
3607 buf
->st_mode
= S_IFLNK
;
3608 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3609 buf
->st_mode
= S_IFDIR
;
3612 DWORD ftype
= GetFileType (fh
);
3616 case FILE_TYPE_DISK
:
3617 buf
->st_mode
= S_IFREG
;
3619 case FILE_TYPE_PIPE
:
3620 buf
->st_mode
= S_IFIFO
;
3622 case FILE_TYPE_CHAR
:
3623 case FILE_TYPE_UNKNOWN
:
3625 buf
->st_mode
= S_IFCHR
;
3628 /* We produce the fallback owner and group data, based on the
3629 current user that runs Emacs, in the following cases:
3631 . this is Windows 9X
3632 . getting security by handle failed, and we need to produce
3633 information for the target of a symlink (this is better
3634 than producing a potentially misleading info about the
3637 If getting security by handle fails, and we don't need to
3638 resolve symlinks, we try getting security by name. */
3639 if (is_windows_9x () != TRUE
)
3640 psd
= get_file_security_desc_by_handle (fh
);
3643 get_file_owner_and_group (psd
, name
, buf
);
3646 else if (is_windows_9x () == TRUE
)
3647 get_file_owner_and_group (NULL
, name
, buf
);
3648 else if (!(is_a_symlink
&& follow_symlinks
))
3650 psd
= get_file_security_desc_by_name (name
);
3651 get_file_owner_and_group (psd
, name
, buf
);
3655 get_file_owner_and_group (NULL
, name
, buf
);
3660 no_true_file_attributes
:
3661 /* Plan B: Either getting a handle on the file failed, or the
3662 caller explicitly asked us to not bother making this
3663 information more accurate.
3665 Implementation note: In Plan B, we never bother to resolve
3666 symlinks, even if we got here because we tried Plan A and
3667 failed. That's because, even if the caller asked for extra
3668 precision by setting Vw32_get_true_file_attributes to t,
3669 resolving symlinks requires acquiring a file handle to the
3670 symlink, which we already know will fail. And if the user
3671 did not ask for extra precision, resolving symlinks will fly
3672 in the face of that request, since the user then wants the
3673 lightweight version of the code. */
3674 rootdir
= (path
>= save_name
+ len
- 1
3675 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3677 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3678 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3679 if (IS_DIRECTORY_SEP (r
[0])
3680 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3683 /* Note: If NAME is a symlink to the root of a UNC volume
3684 (i.e. "\\SERVER"), we will not detect that here, and we will
3685 return data about the symlink as result of FindFirst below.
3686 This is unfortunate, but that marginal use case does not
3687 justify a call to chase_symlinks which would impose a penalty
3688 on all the other use cases. (We get here for symlinks to
3689 roots of UNC volumes because CreateFile above fails for them,
3690 unlike with symlinks to root directories X:\ of drives.) */
3691 if (is_unc_volume (name
))
3693 fattrs
= unc_volume_file_attributes (name
);
3697 ctime
= atime
= wtime
= utc_base_ft
;
3701 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3702 strcat (name
, "\\");
3703 if (GetDriveType (name
) < 2)
3709 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3710 ctime
= atime
= wtime
= utc_base_ft
;
3714 if (IS_DIRECTORY_SEP (name
[len
-1]))
3717 /* (This is hacky, but helps when doing file completions on
3718 network drives.) Optimize by using information available from
3719 active readdir if possible. */
3720 len
= strlen (dir_pathname
);
3721 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3723 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3724 && !(is_a_symlink
&& follow_symlinks
)
3725 && strnicmp (save_name
, dir_pathname
, len
) == 0
3726 && IS_DIRECTORY_SEP (name
[len
])
3727 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3729 /* This was the last entry returned by readdir. */
3730 wfd
= dir_find_data
;
3734 logon_network_drive (name
);
3736 fh
= FindFirstFile (name
, &wfd
);
3737 if (fh
== INVALID_HANDLE_VALUE
)
3744 /* Note: if NAME is a symlink, the information we get from
3745 FindFirstFile is for the symlink, not its target. */
3746 fattrs
= wfd
.dwFileAttributes
;
3747 ctime
= wfd
.ftCreationTime
;
3748 atime
= wfd
.ftLastAccessTime
;
3749 wtime
= wfd
.ftLastWriteTime
;
3750 fs_high
= wfd
.nFileSizeHigh
;
3751 fs_low
= wfd
.nFileSizeLow
;
3754 serialnum
= volume_info
.serialnum
;
3756 if (is_a_symlink
&& !follow_symlinks
)
3757 buf
->st_mode
= S_IFLNK
;
3758 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3759 buf
->st_mode
= S_IFDIR
;
3761 buf
->st_mode
= S_IFREG
;
3763 get_file_owner_and_group (NULL
, name
, buf
);
3767 /* Not sure if there is any point in this. */
3768 if (!NILP (Vw32_generate_fake_inodes
))
3769 fake_inode
= generate_inode_val (name
);
3770 else if (fake_inode
== 0)
3772 /* For want of something better, try to make everything unique. */
3773 static DWORD gen_num
= 0;
3774 fake_inode
= ++gen_num
;
3778 buf
->st_ino
= fake_inode
;
3780 buf
->st_dev
= serialnum
;
3781 buf
->st_rdev
= serialnum
;
3783 buf
->st_size
= fs_high
;
3784 buf
->st_size
<<= 32;
3785 buf
->st_size
+= fs_low
;
3786 buf
->st_nlink
= nlinks
;
3788 /* Convert timestamps to Unix format. */
3789 buf
->st_mtime
= convert_time (wtime
);
3790 buf
->st_atime
= convert_time (atime
);
3791 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3792 buf
->st_ctime
= convert_time (ctime
);
3793 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3795 /* determine rwx permissions */
3796 if (is_a_symlink
&& !follow_symlinks
)
3797 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
3800 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
3801 permission
= S_IREAD
;
3803 permission
= S_IREAD
| S_IWRITE
;
3805 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3806 permission
|= S_IEXEC
;
3807 else if (is_exec (name
))
3808 permission
|= S_IEXEC
;
3811 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3817 stat (const char * path
, struct stat
* buf
)
3819 return stat_worker (path
, buf
, 1);
3823 lstat (const char * path
, struct stat
* buf
)
3825 return stat_worker (path
, buf
, 0);
3828 /* Provide fstat and utime as well as stat for consistent handling of
3831 fstat (int desc
, struct stat
* buf
)
3833 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3834 BY_HANDLE_FILE_INFORMATION info
;
3835 unsigned __int64 fake_inode
;
3838 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3840 case FILE_TYPE_DISK
:
3841 buf
->st_mode
= S_IFREG
;
3842 if (!GetFileInformationByHandle (fh
, &info
))
3848 case FILE_TYPE_PIPE
:
3849 buf
->st_mode
= S_IFIFO
;
3851 case FILE_TYPE_CHAR
:
3852 case FILE_TYPE_UNKNOWN
:
3854 buf
->st_mode
= S_IFCHR
;
3856 memset (&info
, 0, sizeof (info
));
3857 info
.dwFileAttributes
= 0;
3858 info
.ftCreationTime
= utc_base_ft
;
3859 info
.ftLastAccessTime
= utc_base_ft
;
3860 info
.ftLastWriteTime
= utc_base_ft
;
3863 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3864 buf
->st_mode
= S_IFDIR
;
3866 buf
->st_nlink
= info
.nNumberOfLinks
;
3867 /* Might as well use file index to fake inode values, but this
3868 is not guaranteed to be unique unless we keep a handle open
3869 all the time (even then there are situations where it is
3870 not unique). Reputedly, there are at most 48 bits of info
3871 (on NTFS, presumably less on FAT). */
3872 fake_inode
= info
.nFileIndexHigh
;
3874 fake_inode
+= info
.nFileIndexLow
;
3876 /* MSVC defines _ino_t to be short; other libc's might not. */
3877 if (sizeof (buf
->st_ino
) == 2)
3878 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3880 buf
->st_ino
= fake_inode
;
3882 /* Consider files to belong to current user.
3883 FIXME: this should use GetSecurityInfo API, but it is only
3884 available for _WIN32_WINNT >= 0x501. */
3885 buf
->st_uid
= dflt_passwd
.pw_uid
;
3886 buf
->st_gid
= dflt_passwd
.pw_gid
;
3887 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3888 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3890 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3891 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3893 buf
->st_size
= info
.nFileSizeHigh
;
3894 buf
->st_size
<<= 32;
3895 buf
->st_size
+= info
.nFileSizeLow
;
3897 /* Convert timestamps to Unix format. */
3898 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3899 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3900 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3901 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3902 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3904 /* determine rwx permissions */
3905 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3906 permission
= S_IREAD
;
3908 permission
= S_IREAD
| S_IWRITE
;
3910 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3911 permission
|= S_IEXEC
;
3914 #if 0 /* no way of knowing the filename */
3915 char * p
= strrchr (name
, '.');
3917 (xstrcasecmp (p
, ".exe") == 0 ||
3918 xstrcasecmp (p
, ".com") == 0 ||
3919 xstrcasecmp (p
, ".bat") == 0 ||
3920 xstrcasecmp (p
, ".cmd") == 0))
3921 permission
|= S_IEXEC
;
3925 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3931 utime (const char *name
, struct utimbuf
*times
)
3933 struct utimbuf deftime
;
3940 deftime
.modtime
= deftime
.actime
= time (NULL
);
3944 /* Need write access to set times. */
3945 fh
= CreateFile (name
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3946 0, OPEN_EXISTING
, 0, NULL
);
3949 convert_from_time_t (times
->actime
, &atime
);
3950 convert_from_time_t (times
->modtime
, &mtime
);
3951 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
3968 /* Symlink-related functions. */
3969 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
3970 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
3974 symlink (char const *filename
, char const *linkname
)
3976 char linkfn
[MAX_PATH
], *tgtfn
;
3978 int dir_access
, filename_ends_in_slash
;
3980 /* Diagnostics follows Posix as much as possible. */
3981 if (filename
== NULL
|| linkname
== NULL
)
3991 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
3993 errno
= ENAMETOOLONG
;
3997 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
3998 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4004 /* Note: since empty FILENAME was already rejected, we can safely
4005 refer to FILENAME[1]. */
4006 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4008 /* Non-absolute FILENAME is understood as being relative to
4009 LINKNAME's directory. We need to prepend that directory to
4010 FILENAME to get correct results from sys_access below, since
4011 otherwise it will interpret FILENAME relative to the
4012 directory where the Emacs process runs. Note that
4013 make-symbolic-link always makes sure LINKNAME is a fully
4014 expanded file name. */
4016 char *p
= linkfn
+ strlen (linkfn
);
4018 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4021 strncpy (tem
, linkfn
, p
- linkfn
);
4022 tem
[p
- linkfn
] = '\0';
4023 strcat (tem
, filename
);
4024 dir_access
= sys_access (tem
, D_OK
);
4027 dir_access
= sys_access (filename
, D_OK
);
4029 /* Since Windows distinguishes between symlinks to directories and
4030 to files, we provide a kludgy feature: if FILENAME doesn't
4031 exist, but ends in a slash, we create a symlink to directory. If
4032 FILENAME exists and is a directory, we always create a symlink to
4034 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4035 if (dir_access
== 0 || filename_ends_in_slash
)
4036 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4038 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4039 if (filename_ends_in_slash
)
4040 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4043 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4045 /* ENOSYS is set by create_symbolic_link, when it detects that
4046 the OS doesn't support the CreateSymbolicLink API. */
4047 if (errno
!= ENOSYS
)
4049 DWORD w32err
= GetLastError ();
4053 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4054 TGTFN point to the same file name, go figure. */
4056 case ERROR_FILE_EXISTS
:
4059 case ERROR_ACCESS_DENIED
:
4062 case ERROR_FILE_NOT_FOUND
:
4063 case ERROR_PATH_NOT_FOUND
:
4064 case ERROR_BAD_NETPATH
:
4065 case ERROR_INVALID_REPARSE_DATA
:
4068 case ERROR_DIRECTORY
:
4071 case ERROR_PRIVILEGE_NOT_HELD
:
4072 case ERROR_NOT_ALL_ASSIGNED
:
4075 case ERROR_DISK_FULL
:
4088 /* A quick inexpensive test of whether FILENAME identifies a file that
4089 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4090 must already be in the normalized form returned by
4093 Note: for repeated operations on many files, it is best to test
4094 whether the underlying volume actually supports symlinks, by
4095 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4096 avoid the call to this function if it doesn't. That's because the
4097 call to GetFileAttributes takes a non-negligible time, especially
4098 on non-local or removable filesystems. See stat_worker for an
4099 example of how to do that. */
4101 is_symlink (const char *filename
)
4104 WIN32_FIND_DATA wfd
;
4107 attrs
= GetFileAttributes (filename
);
4110 DWORD w32err
= GetLastError ();
4114 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4116 case ERROR_ACCESS_DENIED
:
4119 case ERROR_FILE_NOT_FOUND
:
4120 case ERROR_PATH_NOT_FOUND
:
4127 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4129 logon_network_drive (filename
);
4130 fh
= FindFirstFile (filename
, &wfd
);
4131 if (fh
== INVALID_HANDLE_VALUE
)
4134 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4135 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4138 /* If NAME identifies a symbolic link, copy into BUF the file name of
4139 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4140 null-terminate the target name, even if it fits. Return the number
4141 of bytes copied, or -1 if NAME is not a symlink or any error was
4142 encountered while resolving it. The file name copied into BUF is
4143 encoded in the current ANSI codepage. */
4145 readlink (const char *name
, char *buf
, size_t buf_size
)
4148 TOKEN_PRIVILEGES privs
;
4149 int restore_privs
= 0;
4164 path
= map_w32_filename (name
, NULL
);
4166 if (strlen (path
) > MAX_PATH
)
4168 errno
= ENAMETOOLONG
;
4173 if (is_windows_9x () == TRUE
4174 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4175 || !is_symlink (path
))
4178 errno
= EINVAL
; /* not a symlink */
4182 /* Done with simple tests, now we're in for some _real_ work. */
4183 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4185 /* Implementation note: From here and onward, don't return early,
4186 since that will fail to restore the original set of privileges of
4187 the calling thread. */
4189 retval
= -1; /* not too optimistic, are we? */
4191 /* Note: In the next call to CreateFile, we use zero as the 2nd
4192 argument because, when the symlink is a hidden/system file,
4193 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4194 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4195 and directory symlinks. */
4196 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4197 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4199 if (sh
!= INVALID_HANDLE_VALUE
)
4201 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4202 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4205 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4206 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4209 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4213 /* Copy the link target name, in wide characters, fro
4214 reparse_data, then convert it to multibyte encoding in
4215 the current locale's codepage. */
4217 BYTE lname
[MAX_PATH
];
4220 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4222 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4223 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4225 /* According to MSDN, PrintNameLength does not include the
4226 terminating null character. */
4227 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4228 memcpy (lwname
, lwname_src
, lwname_len
);
4229 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4231 /* FIXME: Should we use the current file-name coding system
4232 instead of the fixed value of the ANSI codepage? */
4233 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4234 lname
, MAX_PATH
, NULL
, NULL
);
4237 /* WideCharToMultiByte failed. */
4238 DWORD w32err1
= GetLastError ();
4242 case ERROR_INSUFFICIENT_BUFFER
:
4243 errno
= ENAMETOOLONG
;
4245 case ERROR_INVALID_PARAMETER
:
4248 case ERROR_NO_UNICODE_TRANSLATION
:
4258 size_t size_to_copy
= buf_size
;
4260 BYTE
*pend
= p
+ lname_len
;
4262 /* Normalize like dostounix_filename does, but we don't
4263 want to assume that lname is null-terminated. */
4264 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4272 /* Testing for null-terminated LNAME is paranoia:
4273 WideCharToMultiByte should always return a
4274 null-terminated string when its 4th argument is -1
4275 and its 3rd argument is null-terminated (which they
4277 if (lname
[lname_len
- 1] == '\0')
4279 if (lname_len
<= buf_size
)
4280 size_to_copy
= lname_len
;
4281 strncpy (buf
, lname
, size_to_copy
);
4283 retval
= size_to_copy
;
4290 /* CreateFile failed. */
4291 DWORD w32err2
= GetLastError ();
4295 case ERROR_FILE_NOT_FOUND
:
4296 case ERROR_PATH_NOT_FOUND
:
4299 case ERROR_ACCESS_DENIED
:
4300 case ERROR_TOO_MANY_OPEN_FILES
:
4310 restore_privilege (&privs
);
4317 /* If FILE is a symlink, return its target (stored in a static
4318 buffer); otherwise return FILE.
4320 This function repeatedly resolves symlinks in the last component of
4321 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4322 until it arrives at a file whose last component is not a symlink,
4323 or some error occurs. It returns the target of the last
4324 successfully resolved symlink in the chain. If it succeeds to
4325 resolve even a single symlink, the value returned is an absolute
4326 file name with backslashes (result of GetFullPathName). By
4327 contrast, if the original FILE is returned, it is unaltered.
4329 Note: This function can set errno even if it succeeds.
4331 Implementation note: we only resolve the last portion ("basename")
4332 of the argument FILE and of each following file in the chain,
4333 disregarding any possible symlinks in its leading directories.
4334 This is because Windows system calls and library functions
4335 transparently resolve symlinks in leading directories and return
4336 correct information, as long as the basename is not a symlink. */
4338 chase_symlinks (const char *file
)
4340 static char target
[MAX_PATH
];
4341 char link
[MAX_PATH
];
4342 ssize_t res
, link_len
;
4345 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4346 return (char *)file
;
4348 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4349 return (char *)file
;
4354 /* Remove trailing slashes, as we want to resolve the last
4355 non-trivial part of the link name. */
4356 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4357 link
[link_len
--] = '\0';
4359 res
= readlink (link
, target
, MAX_PATH
);
4363 if (!(IS_DEVICE_SEP (target
[1])
4364 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4366 /* Target is relative. Append it to the directory part of
4367 the symlink, then copy the result back to target. */
4368 char *p
= link
+ link_len
;
4370 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4373 strcpy (target
, link
);
4375 /* Resolve any "." and ".." to get a fully-qualified file name
4377 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4379 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4381 if (loop_count
> 100)
4384 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4385 return (char *)file
;
4389 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4390 have a fixed max size for file names, so we don't need the kind of
4391 alloc/malloc/realloc dance the gnulib version does. We also don't
4392 support FD-relative symlinks. */
4394 careadlinkat (int fd
, char const *filename
,
4395 char *buffer
, size_t buffer_size
,
4396 struct allocator
const *alloc
,
4397 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4399 char linkname
[MAX_PATH
];
4408 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4412 char *retval
= buffer
;
4414 linkname
[link_size
++] = '\0';
4415 if (link_size
> buffer_size
)
4416 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4418 memcpy (retval
, linkname
, link_size
);
4426 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4430 return readlink (filename
, buffer
, buffer_size
);
4434 /* Support for browsing other processes and their attributes. See
4435 process.c for the Lisp bindings. */
4437 /* Helper wrapper functions. */
4439 static HANDLE WINAPI
4440 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4442 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4444 if (g_b_init_create_toolhelp32_snapshot
== 0)
4446 g_b_init_create_toolhelp32_snapshot
= 1;
4447 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4448 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4449 "CreateToolhelp32Snapshot");
4451 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4453 return INVALID_HANDLE_VALUE
;
4455 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4459 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4461 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4463 if (g_b_init_process32_first
== 0)
4465 g_b_init_process32_first
= 1;
4466 s_pfn_Process32_First
= (Process32First_Proc
)
4467 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4470 if (s_pfn_Process32_First
== NULL
)
4474 return (s_pfn_Process32_First (hSnapshot
, lppe
));
4478 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4480 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
4482 if (g_b_init_process32_next
== 0)
4484 g_b_init_process32_next
= 1;
4485 s_pfn_Process32_Next
= (Process32Next_Proc
)
4486 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4489 if (s_pfn_Process32_Next
== NULL
)
4493 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
4497 open_thread_token (HANDLE ThreadHandle
,
4498 DWORD DesiredAccess
,
4500 PHANDLE TokenHandle
)
4502 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
4503 HMODULE hm_advapi32
= NULL
;
4504 if (is_windows_9x () == TRUE
)
4506 SetLastError (ERROR_NOT_SUPPORTED
);
4509 if (g_b_init_open_thread_token
== 0)
4511 g_b_init_open_thread_token
= 1;
4512 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4513 s_pfn_Open_Thread_Token
=
4514 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
4516 if (s_pfn_Open_Thread_Token
== NULL
)
4518 SetLastError (ERROR_NOT_SUPPORTED
);
4522 s_pfn_Open_Thread_Token (
4531 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
4533 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
4534 HMODULE hm_advapi32
= NULL
;
4535 if (is_windows_9x () == TRUE
)
4539 if (g_b_init_impersonate_self
== 0)
4541 g_b_init_impersonate_self
= 1;
4542 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4543 s_pfn_Impersonate_Self
=
4544 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
4546 if (s_pfn_Impersonate_Self
== NULL
)
4550 return s_pfn_Impersonate_Self (ImpersonationLevel
);
4554 revert_to_self (void)
4556 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
4557 HMODULE hm_advapi32
= NULL
;
4558 if (is_windows_9x () == TRUE
)
4562 if (g_b_init_revert_to_self
== 0)
4564 g_b_init_revert_to_self
= 1;
4565 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4566 s_pfn_Revert_To_Self
=
4567 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
4569 if (s_pfn_Revert_To_Self
== NULL
)
4573 return s_pfn_Revert_To_Self ();
4577 get_process_memory_info (HANDLE h_proc
,
4578 PPROCESS_MEMORY_COUNTERS mem_counters
,
4581 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
4582 HMODULE hm_psapi
= NULL
;
4583 if (is_windows_9x () == TRUE
)
4587 if (g_b_init_get_process_memory_info
== 0)
4589 g_b_init_get_process_memory_info
= 1;
4590 hm_psapi
= LoadLibrary ("Psapi.dll");
4592 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
4593 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
4595 if (s_pfn_Get_Process_Memory_Info
== NULL
)
4599 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
4603 get_process_working_set_size (HANDLE h_proc
,
4607 static GetProcessWorkingSetSize_Proc
4608 s_pfn_Get_Process_Working_Set_Size
= NULL
;
4610 if (is_windows_9x () == TRUE
)
4614 if (g_b_init_get_process_working_set_size
== 0)
4616 g_b_init_get_process_working_set_size
= 1;
4617 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
4618 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4619 "GetProcessWorkingSetSize");
4621 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
4625 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
4629 global_memory_status (MEMORYSTATUS
*buf
)
4631 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
4633 if (is_windows_9x () == TRUE
)
4637 if (g_b_init_global_memory_status
== 0)
4639 g_b_init_global_memory_status
= 1;
4640 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
4641 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4642 "GlobalMemoryStatus");
4644 if (s_pfn_Global_Memory_Status
== NULL
)
4648 return s_pfn_Global_Memory_Status (buf
);
4652 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
4654 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
4656 if (is_windows_9x () == TRUE
)
4660 if (g_b_init_global_memory_status_ex
== 0)
4662 g_b_init_global_memory_status_ex
= 1;
4663 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
4664 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4665 "GlobalMemoryStatusEx");
4667 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
4671 return s_pfn_Global_Memory_Status_Ex (buf
);
4675 list_system_processes (void)
4677 struct gcpro gcpro1
;
4678 Lisp_Object proclist
= Qnil
;
4681 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4683 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4685 PROCESSENTRY32 proc_entry
;
4691 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
4692 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
4693 res
= process32_next (h_snapshot
, &proc_entry
))
4695 proc_id
= proc_entry
.th32ProcessID
;
4696 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
4699 CloseHandle (h_snapshot
);
4701 proclist
= Fnreverse (proclist
);
4708 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
4710 TOKEN_PRIVILEGES priv
;
4711 DWORD priv_size
= sizeof (priv
);
4712 DWORD opriv_size
= sizeof (*old_priv
);
4713 HANDLE h_token
= NULL
;
4714 HANDLE h_thread
= GetCurrentThread ();
4718 res
= open_thread_token (h_thread
,
4719 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4721 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
4723 if (impersonate_self (SecurityImpersonation
))
4724 res
= open_thread_token (h_thread
,
4725 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4730 priv
.PrivilegeCount
= 1;
4731 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
4732 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
4733 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
4734 old_priv
, &opriv_size
)
4735 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4739 CloseHandle (h_token
);
4745 restore_privilege (TOKEN_PRIVILEGES
*priv
)
4747 DWORD priv_size
= sizeof (*priv
);
4748 HANDLE h_token
= NULL
;
4751 if (open_thread_token (GetCurrentThread (),
4752 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4755 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
4756 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4760 CloseHandle (h_token
);
4766 ltime (ULONGLONG time_100ns
)
4768 ULONGLONG time_sec
= time_100ns
/ 10000000;
4769 int subsec
= time_100ns
% 10000000;
4770 return list4 (make_number (time_sec
>> 16),
4771 make_number (time_sec
& 0xffff),
4772 make_number (subsec
/ 10),
4773 make_number (subsec
% 10 * 100000));
4776 #define U64_TO_LISP_TIME(time) ltime (time)
4779 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
4780 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
4783 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
4784 ULONGLONG tem1
, tem2
, tem3
, tem
;
4787 || !get_process_times_fn
4788 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
4789 &ft_kernel
, &ft_user
))
4792 GetSystemTimeAsFileTime (&ft_current
);
4794 FILETIME_TO_U64 (tem1
, ft_kernel
);
4795 *stime
= U64_TO_LISP_TIME (tem1
);
4797 FILETIME_TO_U64 (tem2
, ft_user
);
4798 *utime
= U64_TO_LISP_TIME (tem2
);
4801 *ttime
= U64_TO_LISP_TIME (tem3
);
4803 FILETIME_TO_U64 (tem
, ft_creation
);
4804 /* Process no 4 (System) returns zero creation time. */
4807 *ctime
= U64_TO_LISP_TIME (tem
);
4811 FILETIME_TO_U64 (tem3
, ft_current
);
4812 tem
= (tem3
- utc_base
) - tem
;
4814 *etime
= U64_TO_LISP_TIME (tem
);
4818 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4829 system_process_attributes (Lisp_Object pid
)
4831 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4832 Lisp_Object attrs
= Qnil
;
4833 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4834 HANDLE h_snapshot
, h_proc
;
4837 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4838 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4839 DWORD glength
= sizeof (gname
);
4840 HANDLE token
= NULL
;
4841 SID_NAME_USE user_type
;
4842 unsigned char *buf
= NULL
;
4844 TOKEN_USER user_token
;
4845 TOKEN_PRIMARY_GROUP group_token
;
4848 PROCESS_MEMORY_COUNTERS mem
;
4849 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4850 DWORD minrss
, maxrss
;
4852 MEMORY_STATUS_EX memstex
;
4853 double totphys
= 0.0;
4854 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4856 BOOL result
= FALSE
;
4858 CHECK_NUMBER_OR_FLOAT (pid
);
4859 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4861 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4863 GCPRO3 (attrs
, decoded_cmd
, tem
);
4865 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4870 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4871 for (res
= process32_first (h_snapshot
, &pe
); res
;
4872 res
= process32_next (h_snapshot
, &pe
))
4874 if (proc_id
== pe
.th32ProcessID
)
4877 decoded_cmd
= build_string ("Idle");
4880 /* Decode the command name from locale-specific
4882 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4883 strlen (pe
.szExeFile
));
4885 code_convert_string_norecord (cmd_str
,
4886 Vlocale_coding_system
, 0);
4888 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4889 attrs
= Fcons (Fcons (Qppid
,
4890 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4892 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4894 attrs
= Fcons (Fcons (Qthcount
,
4895 make_fixnum_or_float (pe
.cntThreads
)),
4902 CloseHandle (h_snapshot
);
4911 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4913 /* If we were denied a handle to the process, try again after
4914 enabling the SeDebugPrivilege in our process. */
4917 TOKEN_PRIVILEGES priv_current
;
4919 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4921 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4923 restore_privilege (&priv_current
);
4929 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4932 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4933 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4935 buf
= xmalloc (blen
);
4936 result
= get_token_information (token
, TokenUser
,
4937 (LPVOID
)buf
, blen
, &needed
);
4940 memcpy (&user_token
, buf
, sizeof (user_token
));
4941 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4943 euid
= get_rid (user_token
.User
.Sid
);
4944 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4949 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4952 strcpy (uname
, "unknown");
4956 ulength
= strlen (uname
);
4962 /* Determine a reasonable euid and gid values. */
4963 if (xstrcasecmp ("administrator", uname
) == 0)
4965 euid
= 500; /* well-known Administrator uid */
4966 egid
= 513; /* well-known None gid */
4970 /* Get group id and name. */
4971 result
= get_token_information (token
, TokenPrimaryGroup
,
4972 (LPVOID
)buf
, blen
, &needed
);
4973 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4975 buf
= xrealloc (buf
, blen
= needed
);
4976 result
= get_token_information (token
, TokenPrimaryGroup
,
4977 (LPVOID
)buf
, blen
, &needed
);
4981 memcpy (&group_token
, buf
, sizeof (group_token
));
4982 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
4984 egid
= get_rid (group_token
.PrimaryGroup
);
4985 dlength
= sizeof (domain
);
4987 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
4988 gname
, &glength
, NULL
, &dlength
,
4991 w32_add_to_cache (group_token
.PrimaryGroup
,
4995 strcpy (gname
, "None");
4999 glength
= strlen (gname
);
5007 if (!is_windows_9x ())
5009 /* We couldn't open the process token, presumably because of
5010 insufficient access rights. Assume this process is run
5012 strcpy (uname
, "SYSTEM");
5013 strcpy (gname
, "None");
5014 euid
= 18; /* SYSTEM */
5015 egid
= 513; /* None */
5016 glength
= strlen (gname
);
5017 ulength
= strlen (uname
);
5019 /* If we are running under Windows 9X, where security calls are
5020 not supported, we assume all processes are run by the current
5022 else if (GetUserName (uname
, &ulength
))
5024 if (xstrcasecmp ("administrator", uname
) == 0)
5029 strcpy (gname
, "None");
5030 glength
= strlen (gname
);
5031 ulength
= strlen (uname
);
5037 strcpy (uname
, "administrator");
5038 ulength
= strlen (uname
);
5039 strcpy (gname
, "None");
5040 glength
= strlen (gname
);
5043 CloseHandle (token
);
5046 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5047 tem
= make_unibyte_string (uname
, ulength
);
5048 attrs
= Fcons (Fcons (Quser
,
5049 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5051 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5052 tem
= make_unibyte_string (gname
, glength
);
5053 attrs
= Fcons (Fcons (Qgroup
,
5054 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5057 if (global_memory_status_ex (&memstex
))
5058 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5059 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5061 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5062 double, so we need to do this for it... */
5064 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5065 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5066 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5068 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5070 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5071 else if (global_memory_status (&memst
))
5072 totphys
= memst
.dwTotalPhys
/ 1024.0;
5075 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5078 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5080 attrs
= Fcons (Fcons (Qmajflt
,
5081 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5083 attrs
= Fcons (Fcons (Qvsize
,
5084 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5086 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5088 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5091 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5093 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5095 attrs
= Fcons (Fcons (Qmajflt
,
5096 make_fixnum_or_float (mem
.PageFaultCount
)),
5098 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5100 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5103 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5105 DWORD rss
= maxrss
/ 1024;
5107 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5109 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5112 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5114 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5115 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5116 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5117 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5118 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5119 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5122 /* FIXME: Retrieve command line by walking the PEB of the process. */
5125 CloseHandle (h_proc
);
5131 /* Wrappers for winsock functions to map between our file descriptors
5132 and winsock's handles; also set h_errno for convenience.
5134 To allow Emacs to run on systems which don't have winsock support
5135 installed, we dynamically link to winsock on startup if present, and
5136 otherwise provide the minimum necessary functionality
5137 (eg. gethostname). */
5139 /* function pointers for relevant socket functions */
5140 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5141 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5142 int (PASCAL
*pfn_WSAGetLastError
) (void);
5143 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5144 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5145 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5146 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5147 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5148 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5149 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5150 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5151 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5152 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5153 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5154 int (PASCAL
*pfn_WSACleanup
) (void);
5156 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5157 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5158 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5159 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5160 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5161 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5162 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5163 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5164 const char * optval
, int optlen
);
5165 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5166 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5168 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5169 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5170 struct sockaddr
* from
, int * fromlen
);
5171 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5172 const struct sockaddr
* to
, int tolen
);
5174 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5175 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5176 #ifndef HANDLE_FLAG_INHERIT
5177 #define HANDLE_FLAG_INHERIT 1
5181 static int winsock_inuse
;
5186 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5188 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5189 after WSAStartup returns successfully, but it seems reasonable
5190 to allow unloading winsock anyway in that case. */
5191 if (pfn_WSACleanup () == 0 ||
5192 pfn_WSAGetLastError () == WSAENETDOWN
)
5194 if (FreeLibrary (winsock_lib
))
5203 init_winsock (int load_now
)
5205 WSADATA winsockData
;
5207 if (winsock_lib
!= NULL
)
5210 pfn_SetHandleInformation
5211 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5212 "SetHandleInformation");
5214 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5216 if (winsock_lib
!= NULL
)
5218 /* dynamically link to socket functions */
5220 #define LOAD_PROC(fn) \
5221 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5224 LOAD_PROC (WSAStartup
);
5225 LOAD_PROC (WSASetLastError
);
5226 LOAD_PROC (WSAGetLastError
);
5227 LOAD_PROC (WSAEventSelect
);
5228 LOAD_PROC (WSACreateEvent
);
5229 LOAD_PROC (WSACloseEvent
);
5232 LOAD_PROC (connect
);
5233 LOAD_PROC (ioctlsocket
);
5236 LOAD_PROC (closesocket
);
5237 LOAD_PROC (shutdown
);
5240 LOAD_PROC (inet_addr
);
5241 LOAD_PROC (gethostname
);
5242 LOAD_PROC (gethostbyname
);
5243 LOAD_PROC (getservbyname
);
5244 LOAD_PROC (getpeername
);
5245 LOAD_PROC (WSACleanup
);
5246 LOAD_PROC (setsockopt
);
5248 LOAD_PROC (getsockname
);
5250 LOAD_PROC (recvfrom
);
5254 /* specify version 1.1 of winsock */
5255 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5257 if (winsockData
.wVersion
!= 0x101)
5262 /* Report that winsock exists and is usable, but leave
5263 socket functions disabled. I am assuming that calling
5264 WSAStartup does not require any network interaction,
5265 and in particular does not cause or require a dial-up
5266 connection to be established. */
5269 FreeLibrary (winsock_lib
);
5277 FreeLibrary (winsock_lib
);
5287 /* function to set h_errno for compatibility; map winsock error codes to
5288 normal system codes where they overlap (non-overlapping definitions
5289 are already in <sys/socket.h> */
5293 if (winsock_lib
== NULL
)
5296 h_errno
= pfn_WSAGetLastError ();
5300 case WSAEACCES
: h_errno
= EACCES
; break;
5301 case WSAEBADF
: h_errno
= EBADF
; break;
5302 case WSAEFAULT
: h_errno
= EFAULT
; break;
5303 case WSAEINTR
: h_errno
= EINTR
; break;
5304 case WSAEINVAL
: h_errno
= EINVAL
; break;
5305 case WSAEMFILE
: h_errno
= EMFILE
; break;
5306 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5307 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5315 if (h_errno
== 0 && winsock_lib
!= NULL
)
5316 pfn_WSASetLastError (0);
5319 /* Extend strerror to handle the winsock-specific error codes. */
5323 } _wsa_errlist
[] = {
5324 {WSAEINTR
, "Interrupted function call"},
5325 {WSAEBADF
, "Bad file descriptor"},
5326 {WSAEACCES
, "Permission denied"},
5327 {WSAEFAULT
, "Bad address"},
5328 {WSAEINVAL
, "Invalid argument"},
5329 {WSAEMFILE
, "Too many open files"},
5331 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5332 {WSAEINPROGRESS
, "Operation now in progress"},
5333 {WSAEALREADY
, "Operation already in progress"},
5334 {WSAENOTSOCK
, "Socket operation on non-socket"},
5335 {WSAEDESTADDRREQ
, "Destination address required"},
5336 {WSAEMSGSIZE
, "Message too long"},
5337 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5338 {WSAENOPROTOOPT
, "Bad protocol option"},
5339 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5340 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5341 {WSAEOPNOTSUPP
, "Operation not supported"},
5342 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5343 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5344 {WSAEADDRINUSE
, "Address already in use"},
5345 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5346 {WSAENETDOWN
, "Network is down"},
5347 {WSAENETUNREACH
, "Network is unreachable"},
5348 {WSAENETRESET
, "Network dropped connection on reset"},
5349 {WSAECONNABORTED
, "Software caused connection abort"},
5350 {WSAECONNRESET
, "Connection reset by peer"},
5351 {WSAENOBUFS
, "No buffer space available"},
5352 {WSAEISCONN
, "Socket is already connected"},
5353 {WSAENOTCONN
, "Socket is not connected"},
5354 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5355 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5356 {WSAETIMEDOUT
, "Connection timed out"},
5357 {WSAECONNREFUSED
, "Connection refused"},
5358 {WSAELOOP
, "Network loop"}, /* not sure */
5359 {WSAENAMETOOLONG
, "Name is too long"},
5360 {WSAEHOSTDOWN
, "Host is down"},
5361 {WSAEHOSTUNREACH
, "No route to host"},
5362 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5363 {WSAEPROCLIM
, "Too many processes"},
5364 {WSAEUSERS
, "Too many users"}, /* not sure */
5365 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5366 {WSAESTALE
, "Data is stale"}, /* not sure */
5367 {WSAEREMOTE
, "Remote error"}, /* not sure */
5369 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5370 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5371 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5372 {WSAEDISCON
, "Graceful shutdown in progress"},
5374 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5375 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5376 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5377 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5378 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5379 {WSASYSCALLFAILURE
, "System call failure"},
5380 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5381 {WSATYPE_NOT_FOUND
, "Class type not found"},
5382 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5383 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5384 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5387 {WSAHOST_NOT_FOUND
, "Host not found"},
5388 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5389 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5390 {WSANO_DATA
, "Valid name, no data record of requested type"},
5396 sys_strerror (int error_no
)
5399 static char unknown_msg
[40];
5401 if (error_no
>= 0 && error_no
< sys_nerr
)
5402 return sys_errlist
[error_no
];
5404 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5405 if (_wsa_errlist
[i
].errnum
== error_no
)
5406 return _wsa_errlist
[i
].msg
;
5408 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5412 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5413 but I believe the method of keeping the socket handle separate (and
5414 insuring it is not inheritable) is the correct one. */
5416 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5418 static int socket_to_fd (SOCKET s
);
5421 sys_socket (int af
, int type
, int protocol
)
5425 if (winsock_lib
== NULL
)
5428 return INVALID_SOCKET
;
5433 /* call the real socket function */
5434 s
= pfn_socket (af
, type
, protocol
);
5436 if (s
!= INVALID_SOCKET
)
5437 return socket_to_fd (s
);
5443 /* Convert a SOCKET to a file descriptor. */
5445 socket_to_fd (SOCKET s
)
5450 /* Although under NT 3.5 _open_osfhandle will accept a socket
5451 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5452 that does not work under NT 3.1. However, we can get the same
5453 effect by using a backdoor function to replace an existing
5454 descriptor handle with the one we want. */
5456 /* allocate a file descriptor (with appropriate flags) */
5457 fd
= _open ("NUL:", _O_RDWR
);
5460 /* Make a non-inheritable copy of the socket handle. Note
5461 that it is possible that sockets aren't actually kernel
5462 handles, which appears to be the case on Windows 9x when
5463 the MS Proxy winsock client is installed. */
5465 /* Apparently there is a bug in NT 3.51 with some service
5466 packs, which prevents using DuplicateHandle to make a
5467 socket handle non-inheritable (causes WSACleanup to
5468 hang). The work-around is to use SetHandleInformation
5469 instead if it is available and implemented. */
5470 if (pfn_SetHandleInformation
)
5472 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5476 HANDLE parent
= GetCurrentProcess ();
5477 HANDLE new_s
= INVALID_HANDLE_VALUE
;
5479 if (DuplicateHandle (parent
,
5485 DUPLICATE_SAME_ACCESS
))
5487 /* It is possible that DuplicateHandle succeeds even
5488 though the socket wasn't really a kernel handle,
5489 because a real handle has the same value. So
5490 test whether the new handle really is a socket. */
5491 long nonblocking
= 0;
5492 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
5494 pfn_closesocket (s
);
5499 CloseHandle (new_s
);
5504 fd_info
[fd
].hnd
= (HANDLE
) s
;
5506 /* set our own internal flags */
5507 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
5513 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5515 /* attach child_process to fd_info */
5516 if (fd_info
[ fd
].cp
!= NULL
)
5518 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
5522 fd_info
[ fd
].cp
= cp
;
5525 winsock_inuse
++; /* count open sockets */
5532 pfn_closesocket (s
);
5538 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
5540 if (winsock_lib
== NULL
)
5543 return SOCKET_ERROR
;
5547 if (fd_info
[s
].flags
& FILE_SOCKET
)
5549 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
5550 if (rc
== SOCKET_ERROR
)
5555 return SOCKET_ERROR
;
5559 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
5561 if (winsock_lib
== NULL
)
5564 return SOCKET_ERROR
;
5568 if (fd_info
[s
].flags
& FILE_SOCKET
)
5570 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
5571 if (rc
== SOCKET_ERROR
)
5576 return SOCKET_ERROR
;
5580 sys_htons (u_short hostshort
)
5582 return (winsock_lib
!= NULL
) ?
5583 pfn_htons (hostshort
) : hostshort
;
5587 sys_ntohs (u_short netshort
)
5589 return (winsock_lib
!= NULL
) ?
5590 pfn_ntohs (netshort
) : netshort
;
5594 sys_inet_addr (const char * cp
)
5596 return (winsock_lib
!= NULL
) ?
5597 pfn_inet_addr (cp
) : INADDR_NONE
;
5601 sys_gethostname (char * name
, int namelen
)
5603 if (winsock_lib
!= NULL
)
5604 return pfn_gethostname (name
, namelen
);
5606 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
5607 return !GetComputerName (name
, (DWORD
*)&namelen
);
5610 return SOCKET_ERROR
;
5614 sys_gethostbyname (const char * name
)
5616 struct hostent
* host
;
5618 if (winsock_lib
== NULL
)
5625 host
= pfn_gethostbyname (name
);
5632 sys_getservbyname (const char * name
, const char * proto
)
5634 struct servent
* serv
;
5636 if (winsock_lib
== NULL
)
5643 serv
= pfn_getservbyname (name
, proto
);
5650 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
5652 if (winsock_lib
== NULL
)
5655 return SOCKET_ERROR
;
5659 if (fd_info
[s
].flags
& FILE_SOCKET
)
5661 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
5662 if (rc
== SOCKET_ERROR
)
5667 return SOCKET_ERROR
;
5671 sys_shutdown (int s
, int how
)
5673 if (winsock_lib
== NULL
)
5676 return SOCKET_ERROR
;
5680 if (fd_info
[s
].flags
& FILE_SOCKET
)
5682 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
5683 if (rc
== SOCKET_ERROR
)
5688 return SOCKET_ERROR
;
5692 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
5694 if (winsock_lib
== NULL
)
5697 return SOCKET_ERROR
;
5701 if (fd_info
[s
].flags
& FILE_SOCKET
)
5703 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
5704 (const char *)optval
, optlen
);
5705 if (rc
== SOCKET_ERROR
)
5710 return SOCKET_ERROR
;
5714 sys_listen (int s
, int backlog
)
5716 if (winsock_lib
== NULL
)
5719 return SOCKET_ERROR
;
5723 if (fd_info
[s
].flags
& FILE_SOCKET
)
5725 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
5726 if (rc
== SOCKET_ERROR
)
5729 fd_info
[s
].flags
|= FILE_LISTEN
;
5733 return SOCKET_ERROR
;
5737 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
5739 if (winsock_lib
== NULL
)
5742 return SOCKET_ERROR
;
5746 if (fd_info
[s
].flags
& FILE_SOCKET
)
5748 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
5749 if (rc
== SOCKET_ERROR
)
5754 return SOCKET_ERROR
;
5758 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
5760 if (winsock_lib
== NULL
)
5767 if (fd_info
[s
].flags
& FILE_LISTEN
)
5769 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
5771 if (t
== INVALID_SOCKET
)
5774 fd
= socket_to_fd (t
);
5776 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5777 ResetEvent (fd_info
[s
].cp
->char_avail
);
5785 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
5786 struct sockaddr
* from
, int * fromlen
)
5788 if (winsock_lib
== NULL
)
5791 return SOCKET_ERROR
;
5795 if (fd_info
[s
].flags
& FILE_SOCKET
)
5797 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
5798 if (rc
== SOCKET_ERROR
)
5803 return SOCKET_ERROR
;
5807 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5808 const struct sockaddr
* to
, int tolen
)
5810 if (winsock_lib
== NULL
)
5813 return SOCKET_ERROR
;
5817 if (fd_info
[s
].flags
& FILE_SOCKET
)
5819 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5820 if (rc
== SOCKET_ERROR
)
5825 return SOCKET_ERROR
;
5828 /* Windows does not have an fcntl function. Provide an implementation
5829 solely for making sockets non-blocking. */
5831 fcntl (int s
, int cmd
, int options
)
5833 if (winsock_lib
== NULL
)
5840 if (fd_info
[s
].flags
& FILE_SOCKET
)
5842 if (cmd
== F_SETFL
&& options
== O_NDELAY
)
5844 unsigned long nblock
= 1;
5845 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5846 if (rc
== SOCKET_ERROR
)
5848 /* Keep track of the fact that we set this to non-blocking. */
5849 fd_info
[s
].flags
|= FILE_NDELAY
;
5855 return SOCKET_ERROR
;
5859 return SOCKET_ERROR
;
5863 /* Shadow main io functions: we need to handle pipes and sockets more
5864 intelligently, and implement non-blocking mode as well. */
5877 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5879 child_process
* cp
= fd_info
[fd
].cp
;
5881 fd_info
[fd
].cp
= NULL
;
5883 if (CHILD_ACTIVE (cp
))
5885 /* if last descriptor to active child_process then cleanup */
5887 for (i
= 0; i
< MAXDESC
; i
++)
5891 if (fd_info
[i
].cp
== cp
)
5896 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5898 if (winsock_lib
== NULL
) emacs_abort ();
5900 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5901 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5903 winsock_inuse
--; /* count open sockets */
5910 /* Note that sockets do not need special treatment here (at least on
5911 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5912 closesocket is equivalent to CloseHandle, which is to be expected
5913 because socket handles are fully fledged kernel handles. */
5916 if (rc
== 0 && fd
< MAXDESC
)
5917 fd_info
[fd
].flags
= 0;
5928 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5930 /* duplicate our internal info as well */
5931 fd_info
[new_fd
] = fd_info
[fd
];
5937 sys_dup2 (int src
, int dst
)
5941 if (dst
< 0 || dst
>= MAXDESC
)
5947 /* make sure we close the destination first if it's a pipe or socket */
5948 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5951 rc
= _dup2 (src
, dst
);
5954 /* duplicate our internal info as well */
5955 fd_info
[dst
] = fd_info
[src
];
5960 /* Unix pipe() has only one arg */
5962 sys_pipe (int * phandles
)
5967 /* make pipe handles non-inheritable; when we spawn a child, we
5968 replace the relevant handle with an inheritable one. Also put
5969 pipes into binary mode; we will do text mode translation ourselves
5971 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
5975 /* Protect against overflow, since Windows can open more handles than
5976 our fd_info array has room for. */
5977 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
5979 _close (phandles
[0]);
5980 _close (phandles
[1]);
5985 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
5986 fd_info
[phandles
[0]].flags
= flags
;
5988 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
5989 fd_info
[phandles
[1]].flags
= flags
;
5996 /* Function to do blocking read of one byte, needed to implement
5997 select. It is only allowed on sockets and pipes. */
5999 _sys_read_ahead (int fd
)
6004 if (fd
< 0 || fd
>= MAXDESC
)
6005 return STATUS_READ_ERROR
;
6007 cp
= fd_info
[fd
].cp
;
6009 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6010 return STATUS_READ_ERROR
;
6012 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6013 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6015 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6019 cp
->status
= STATUS_READ_IN_PROGRESS
;
6021 if (fd_info
[fd
].flags
& FILE_PIPE
)
6023 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6025 /* Give subprocess time to buffer some more output for us before
6026 reporting that input is available; we need this because Windows 95
6027 connects DOS programs to pipes by making the pipe appear to be
6028 the normal console stdout - as a result most DOS programs will
6029 write to stdout without buffering, ie. one character at a
6030 time. Even some W32 programs do this - "dir" in a command
6031 shell on NT is very slow if we don't do this. */
6034 int wait
= w32_pipe_read_delay
;
6040 /* Yield remainder of our time slice, effectively giving a
6041 temporary priority boost to the child process. */
6045 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6047 HANDLE hnd
= fd_info
[fd
].hnd
;
6048 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6051 /* Configure timeouts for blocking read. */
6052 if (!GetCommTimeouts (hnd
, &ct
))
6053 return STATUS_READ_ERROR
;
6054 ct
.ReadIntervalTimeout
= 0;
6055 ct
.ReadTotalTimeoutMultiplier
= 0;
6056 ct
.ReadTotalTimeoutConstant
= 0;
6057 if (!SetCommTimeouts (hnd
, &ct
))
6058 return STATUS_READ_ERROR
;
6060 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6062 if (GetLastError () != ERROR_IO_PENDING
)
6063 return STATUS_READ_ERROR
;
6064 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6065 return STATUS_READ_ERROR
;
6068 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6070 unsigned long nblock
= 0;
6071 /* We always want this to block, so temporarily disable NDELAY. */
6072 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6073 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6075 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6077 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6080 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6084 if (rc
== sizeof (char))
6085 cp
->status
= STATUS_READ_SUCCEEDED
;
6087 cp
->status
= STATUS_READ_FAILED
;
6093 _sys_wait_accept (int fd
)
6099 if (fd
< 0 || fd
>= MAXDESC
)
6100 return STATUS_READ_ERROR
;
6102 cp
= fd_info
[fd
].cp
;
6104 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6105 return STATUS_READ_ERROR
;
6107 cp
->status
= STATUS_READ_FAILED
;
6109 hEv
= pfn_WSACreateEvent ();
6110 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6111 if (rc
!= SOCKET_ERROR
)
6113 rc
= WaitForSingleObject (hEv
, INFINITE
);
6114 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6115 if (rc
== WAIT_OBJECT_0
)
6116 cp
->status
= STATUS_READ_SUCCEEDED
;
6118 pfn_WSACloseEvent (hEv
);
6124 sys_read (int fd
, char * buffer
, unsigned int count
)
6129 char * orig_buffer
= buffer
;
6137 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6139 child_process
*cp
= fd_info
[fd
].cp
;
6141 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6149 /* re-read CR carried over from last read */
6150 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6152 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6156 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6159 /* presence of a child_process structure means we are operating in
6160 non-blocking mode - otherwise we just call _read directly.
6161 Note that the child_process structure might be missing because
6162 reap_subprocess has been called; in this case the pipe is
6163 already broken, so calling _read on it is okay. */
6166 int current_status
= cp
->status
;
6168 switch (current_status
)
6170 case STATUS_READ_FAILED
:
6171 case STATUS_READ_ERROR
:
6172 /* report normal EOF if nothing in buffer */
6174 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6177 case STATUS_READ_READY
:
6178 case STATUS_READ_IN_PROGRESS
:
6179 DebPrint (("sys_read called when read is in progress\n"));
6180 errno
= EWOULDBLOCK
;
6183 case STATUS_READ_SUCCEEDED
:
6184 /* consume read-ahead char */
6185 *buffer
++ = cp
->chr
;
6188 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6189 ResetEvent (cp
->char_avail
);
6191 case STATUS_READ_ACKNOWLEDGED
:
6195 DebPrint (("sys_read: bad status %d\n", current_status
));
6200 if (fd_info
[fd
].flags
& FILE_PIPE
)
6202 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6203 to_read
= min (waiting
, (DWORD
) count
);
6206 nchars
+= _read (fd
, buffer
, to_read
);
6208 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6210 HANDLE hnd
= fd_info
[fd
].hnd
;
6211 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6217 /* Configure timeouts for non-blocking read. */
6218 if (!GetCommTimeouts (hnd
, &ct
))
6223 ct
.ReadIntervalTimeout
= MAXDWORD
;
6224 ct
.ReadTotalTimeoutMultiplier
= 0;
6225 ct
.ReadTotalTimeoutConstant
= 0;
6226 if (!SetCommTimeouts (hnd
, &ct
))
6232 if (!ResetEvent (ovl
->hEvent
))
6237 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6239 if (GetLastError () != ERROR_IO_PENDING
)
6244 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6253 else /* FILE_SOCKET */
6255 if (winsock_lib
== NULL
) emacs_abort ();
6257 /* do the equivalent of a non-blocking read */
6258 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6259 if (waiting
== 0 && nchars
== 0)
6261 h_errno
= errno
= EWOULDBLOCK
;
6267 /* always use binary mode for sockets */
6268 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6269 if (res
== SOCKET_ERROR
)
6271 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6272 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6282 int nread
= _read (fd
, buffer
, count
);
6285 else if (nchars
== 0)
6290 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6291 /* Perform text mode translation if required. */
6292 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6294 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6295 /* If buffer contains only CR, return that. To be absolutely
6296 sure we should attempt to read the next char, but in
6297 practice a CR to be followed by LF would not appear by
6298 itself in the buffer. */
6299 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6301 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6307 nchars
= _read (fd
, buffer
, count
);
6312 /* From w32xfns.c */
6313 extern HANDLE interrupt_handle
;
6315 /* For now, don't bother with a non-blocking mode */
6317 sys_write (int fd
, const void * buffer
, unsigned int count
)
6327 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6329 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6335 /* Perform text mode translation if required. */
6336 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6338 char * tmpbuf
= alloca (count
* 2);
6339 unsigned char * src
= (void *)buffer
;
6340 unsigned char * dst
= tmpbuf
;
6345 unsigned char *next
;
6346 /* copy next line or remaining bytes */
6347 next
= _memccpy (dst
, src
, '\n', nbytes
);
6350 /* copied one line ending with '\n' */
6351 int copied
= next
- dst
;
6354 /* insert '\r' before '\n' */
6361 /* copied remaining partial line -> now finished */
6368 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6370 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6371 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6372 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6375 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6377 if (GetLastError () != ERROR_IO_PENDING
)
6382 if (detect_input_pending ())
6383 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6386 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6387 if (active
== WAIT_OBJECT_0
)
6388 { /* User pressed C-g, cancel write, then leave. Don't bother
6389 cleaning up as we may only get stuck in buggy drivers. */
6390 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6395 if (active
== WAIT_OBJECT_0
+ 1
6396 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6403 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6405 unsigned long nblock
= 0;
6406 if (winsock_lib
== NULL
) emacs_abort ();
6408 /* TODO: implement select() properly so non-blocking I/O works. */
6409 /* For now, make sure the write blocks. */
6410 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6411 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6413 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6415 /* Set the socket back to non-blocking if it was before,
6416 for other operations that support it. */
6417 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6420 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6423 if (nchars
== SOCKET_ERROR
)
6425 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6426 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6432 /* Some networked filesystems don't like too large writes, so
6433 break them into smaller chunks. See the Comments section of
6434 the MSDN documentation of WriteFile for details behind the
6435 choice of the value of CHUNK below. See also the thread
6436 http://thread.gmane.org/gmane.comp.version-control.git/145294
6437 in the git mailing list. */
6438 const unsigned char *p
= buffer
;
6439 const unsigned chunk
= 30 * 1024 * 1024;
6444 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6445 int n
= _write (fd
, p
, this_chunk
);
6453 else if (n
< this_chunk
)
6463 /* The Windows CRT functions are "optimized for speed", so they don't
6464 check for timezone and DST changes if they were last called less
6465 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
6466 all Emacs features that repeatedly call time functions (e.g.,
6467 display-time) are in real danger of missing timezone and DST
6468 changes. Calling tzset before each localtime call fixes that. */
6470 sys_localtime (const time_t *t
)
6473 return localtime (t
);
6478 /* Try loading LIBRARY_ID from the file(s) specified in
6479 Vdynamic_library_alist. If the library is loaded successfully,
6480 return the handle of the DLL, and record the filename in the
6481 property :loaded-from of LIBRARY_ID. If the library could not be
6482 found, or when it was already loaded (because the handle is not
6483 recorded anywhere, and so is lost after use), return NULL.
6485 We could also save the handle in :loaded-from, but currently
6486 there's no use case for it. */
6488 w32_delayed_load (Lisp_Object library_id
)
6490 HMODULE library_dll
= NULL
;
6492 CHECK_SYMBOL (library_id
);
6494 if (CONSP (Vdynamic_library_alist
)
6495 && NILP (Fassq (library_id
, Vlibrary_cache
)))
6497 Lisp_Object found
= Qnil
;
6498 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
6501 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
6503 CHECK_STRING_CAR (dlls
);
6504 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
6506 char name
[MAX_PATH
];
6509 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
6510 found
= Fcons (XCAR (dlls
),
6512 /* Possibly truncated */
6513 ? make_specified_string (name
, -1, len
, 1)
6519 Fput (library_id
, QCloaded_from
, found
);
6527 check_windows_init_file (void)
6529 /* A common indication that Emacs is not installed properly is when
6530 it cannot find the Windows installation file. If this file does
6531 not exist in the expected place, tell the user. */
6533 if (!noninteractive
&& !inhibit_window_system
6534 /* Vload_path is not yet initialized when we are loading
6536 && NILP (Vpurify_flag
))
6538 Lisp_Object init_file
;
6541 init_file
= build_string ("term/w32-win");
6542 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
6545 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
6546 char *init_file_name
= SDATA (init_file
);
6547 char *load_path
= SDATA (load_path_print
);
6548 char *buffer
= alloca (1024
6549 + strlen (init_file_name
)
6550 + strlen (load_path
));
6553 "The Emacs Windows initialization file \"%s.el\" "
6554 "could not be found in your Emacs installation. "
6555 "Emacs checked the following directories for this file:\n"
6557 "When Emacs cannot find this file, it usually means that it "
6558 "was not installed properly, or its distribution file was "
6559 "not unpacked properly.\nSee the README.W32 file in the "
6560 "top-level Emacs directory for more information.",
6561 init_file_name
, load_path
);
6564 "Emacs Abort Dialog",
6565 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
6566 /* Use the low-level system abort. */
6577 term_ntproc (int ignored
)
6583 /* shutdown the socket interface if necessary */
6590 init_ntproc (int dumping
)
6592 sigset_t initial_mask
= 0;
6594 /* Initialize the socket interface now if available and requested by
6595 the user by defining PRELOAD_WINSOCK; otherwise loading will be
6596 delayed until open-network-stream is called (w32-has-winsock can
6597 also be used to dynamically load or reload winsock).
6599 Conveniently, init_environment is called before us, so
6600 PRELOAD_WINSOCK can be set in the registry. */
6602 /* Always initialize this correctly. */
6605 if (getenv ("PRELOAD_WINSOCK") != NULL
)
6606 init_winsock (TRUE
);
6608 /* Initial preparation for subprocess support: replace our standard
6609 handles with non-inheritable versions. */
6612 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
6613 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
6614 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
6616 parent
= GetCurrentProcess ();
6618 /* ignore errors when duplicating and closing; typically the
6619 handles will be invalid when running as a gui program. */
6620 DuplicateHandle (parent
,
6621 GetStdHandle (STD_INPUT_HANDLE
),
6626 DUPLICATE_SAME_ACCESS
);
6628 DuplicateHandle (parent
,
6629 GetStdHandle (STD_OUTPUT_HANDLE
),
6634 DUPLICATE_SAME_ACCESS
);
6636 DuplicateHandle (parent
,
6637 GetStdHandle (STD_ERROR_HANDLE
),
6642 DUPLICATE_SAME_ACCESS
);
6648 if (stdin_save
!= INVALID_HANDLE_VALUE
)
6649 _open_osfhandle ((long) stdin_save
, O_TEXT
);
6651 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
6654 if (stdout_save
!= INVALID_HANDLE_VALUE
)
6655 _open_osfhandle ((long) stdout_save
, O_TEXT
);
6657 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6660 if (stderr_save
!= INVALID_HANDLE_VALUE
)
6661 _open_osfhandle ((long) stderr_save
, O_TEXT
);
6663 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6667 /* unfortunately, atexit depends on implementation of malloc */
6668 /* atexit (term_ntproc); */
6671 /* Make sure we start with all signals unblocked. */
6672 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
6673 signal (SIGABRT
, term_ntproc
);
6677 /* determine which drives are fixed, for GetCachedVolumeInformation */
6679 /* GetDriveType must have trailing backslash. */
6680 char drive
[] = "A:\\";
6682 /* Loop over all possible drive letters */
6683 while (*drive
<= 'Z')
6685 /* Record if this drive letter refers to a fixed drive. */
6686 fixed_drives
[DRIVE_INDEX (*drive
)] =
6687 (GetDriveType (drive
) == DRIVE_FIXED
);
6692 /* Reset the volume info cache. */
6693 volume_cache
= NULL
;
6698 shutdown_handler ensures that buffers' autosave files are
6699 up to date when the user logs off, or the system shuts down.
6702 shutdown_handler (DWORD type
)
6704 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
6705 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
6706 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
6707 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
6709 /* Shut down cleanly, making sure autosave files are up to date. */
6710 shut_down_emacs (0, Qnil
);
6713 /* Allow other handlers to handle this signal. */
6718 globals_of_w32 is used to initialize those global variables that
6719 must always be initialized on startup even when the global variable
6720 initialized is non zero (see the function main in emacs.c).
6723 globals_of_w32 (void)
6725 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
6727 get_process_times_fn
= (GetProcessTimes_Proc
)
6728 GetProcAddress (kernel32
, "GetProcessTimes");
6730 DEFSYM (QCloaded_from
, ":loaded-from");
6732 g_b_init_is_windows_9x
= 0;
6733 g_b_init_open_process_token
= 0;
6734 g_b_init_get_token_information
= 0;
6735 g_b_init_lookup_account_sid
= 0;
6736 g_b_init_get_sid_sub_authority
= 0;
6737 g_b_init_get_sid_sub_authority_count
= 0;
6738 g_b_init_get_security_info
= 0;
6739 g_b_init_get_file_security
= 0;
6740 g_b_init_get_security_descriptor_owner
= 0;
6741 g_b_init_get_security_descriptor_group
= 0;
6742 g_b_init_is_valid_sid
= 0;
6743 g_b_init_create_toolhelp32_snapshot
= 0;
6744 g_b_init_process32_first
= 0;
6745 g_b_init_process32_next
= 0;
6746 g_b_init_open_thread_token
= 0;
6747 g_b_init_impersonate_self
= 0;
6748 g_b_init_revert_to_self
= 0;
6749 g_b_init_get_process_memory_info
= 0;
6750 g_b_init_get_process_working_set_size
= 0;
6751 g_b_init_global_memory_status
= 0;
6752 g_b_init_global_memory_status_ex
= 0;
6753 g_b_init_equal_sid
= 0;
6754 g_b_init_copy_sid
= 0;
6755 g_b_init_get_length_sid
= 0;
6756 g_b_init_get_native_system_info
= 0;
6757 g_b_init_get_system_times
= 0;
6758 g_b_init_create_symbolic_link
= 0;
6759 num_of_processors
= 0;
6760 /* The following sets a handler for shutdown notifications for
6761 console apps. This actually applies to Emacs in both console and
6762 GUI modes, since we had to fool windows into thinking emacs is a
6763 console application to get console mode to work. */
6764 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
6766 /* "None" is the default group name on standalone workstations. */
6767 strcpy (dflt_group_name
, "None");
6770 /* For make-serial-process */
6772 serial_open (char *port
)
6778 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
6779 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
6780 if (hnd
== INVALID_HANDLE_VALUE
)
6781 error ("Could not open %s", port
);
6782 fd
= (int) _open_osfhandle ((int) hnd
, 0);
6784 error ("Could not open %s", port
);
6788 error ("Could not create child process");
6790 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6791 fd_info
[ fd
].hnd
= hnd
;
6792 fd_info
[ fd
].flags
|=
6793 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
6794 if (fd_info
[ fd
].cp
!= NULL
)
6796 error ("fd_info[fd = %d] is already in use", fd
);
6798 fd_info
[ fd
].cp
= cp
;
6799 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6800 if (cp
->ovl_read
.hEvent
== NULL
)
6801 error ("Could not create read event");
6802 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6803 if (cp
->ovl_write
.hEvent
== NULL
)
6804 error ("Could not create write event");
6809 /* For serial-process-configure */
6811 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
6813 Lisp_Object childp2
= Qnil
;
6814 Lisp_Object tem
= Qnil
;
6818 char summary
[4] = "???"; /* This usually becomes "8N1". */
6820 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
6821 error ("Not a serial process");
6822 hnd
= fd_info
[ p
->outfd
].hnd
;
6824 childp2
= Fcopy_sequence (p
->childp
);
6826 /* Initialize timeouts for blocking read and blocking write. */
6827 if (!GetCommTimeouts (hnd
, &ct
))
6828 error ("GetCommTimeouts() failed");
6829 ct
.ReadIntervalTimeout
= 0;
6830 ct
.ReadTotalTimeoutMultiplier
= 0;
6831 ct
.ReadTotalTimeoutConstant
= 0;
6832 ct
.WriteTotalTimeoutMultiplier
= 0;
6833 ct
.WriteTotalTimeoutConstant
= 0;
6834 if (!SetCommTimeouts (hnd
, &ct
))
6835 error ("SetCommTimeouts() failed");
6836 /* Read port attributes and prepare default configuration. */
6837 memset (&dcb
, 0, sizeof (dcb
));
6838 dcb
.DCBlength
= sizeof (DCB
);
6839 if (!GetCommState (hnd
, &dcb
))
6840 error ("GetCommState() failed");
6843 dcb
.fAbortOnError
= FALSE
;
6844 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
6849 /* Configure speed. */
6850 if (!NILP (Fplist_member (contact
, QCspeed
)))
6851 tem
= Fplist_get (contact
, QCspeed
);
6853 tem
= Fplist_get (p
->childp
, QCspeed
);
6855 dcb
.BaudRate
= XINT (tem
);
6856 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
6858 /* Configure bytesize. */
6859 if (!NILP (Fplist_member (contact
, QCbytesize
)))
6860 tem
= Fplist_get (contact
, QCbytesize
);
6862 tem
= Fplist_get (p
->childp
, QCbytesize
);
6864 tem
= make_number (8);
6866 if (XINT (tem
) != 7 && XINT (tem
) != 8)
6867 error (":bytesize must be nil (8), 7, or 8");
6868 dcb
.ByteSize
= XINT (tem
);
6869 summary
[0] = XINT (tem
) + '0';
6870 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
6872 /* Configure parity. */
6873 if (!NILP (Fplist_member (contact
, QCparity
)))
6874 tem
= Fplist_get (contact
, QCparity
);
6876 tem
= Fplist_get (p
->childp
, QCparity
);
6877 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6878 error (":parity must be nil (no parity), `even', or `odd'");
6879 dcb
.fParity
= FALSE
;
6880 dcb
.Parity
= NOPARITY
;
6881 dcb
.fErrorChar
= FALSE
;
6886 else if (EQ (tem
, Qeven
))
6890 dcb
.Parity
= EVENPARITY
;
6891 dcb
.fErrorChar
= TRUE
;
6893 else if (EQ (tem
, Qodd
))
6897 dcb
.Parity
= ODDPARITY
;
6898 dcb
.fErrorChar
= TRUE
;
6900 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6902 /* Configure stopbits. */
6903 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6904 tem
= Fplist_get (contact
, QCstopbits
);
6906 tem
= Fplist_get (p
->childp
, QCstopbits
);
6908 tem
= make_number (1);
6910 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6911 error (":stopbits must be nil (1 stopbit), 1, or 2");
6912 summary
[2] = XINT (tem
) + '0';
6913 if (XINT (tem
) == 1)
6914 dcb
.StopBits
= ONESTOPBIT
;
6915 else if (XINT (tem
) == 2)
6916 dcb
.StopBits
= TWOSTOPBITS
;
6917 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6919 /* Configure flowcontrol. */
6920 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6921 tem
= Fplist_get (contact
, QCflowcontrol
);
6923 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6924 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6925 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6926 dcb
.fOutxCtsFlow
= FALSE
;
6927 dcb
.fOutxDsrFlow
= FALSE
;
6928 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6929 dcb
.fDsrSensitivity
= FALSE
;
6930 dcb
.fTXContinueOnXoff
= FALSE
;
6933 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6934 dcb
.XonChar
= 17; /* Control-Q */
6935 dcb
.XoffChar
= 19; /* Control-S */
6938 /* Already configured. */
6940 else if (EQ (tem
, Qhw
))
6942 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6943 dcb
.fOutxCtsFlow
= TRUE
;
6945 else if (EQ (tem
, Qsw
))
6950 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6952 /* Activate configuration. */
6953 if (!SetCommState (hnd
, &dcb
))
6954 error ("SetCommState() failed");
6956 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6957 pset_childp (p
, childp2
);
6963 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
6967 struct timeval timeout
;
6968 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
6969 int fd
= process
->infd
;
6973 n
= sys_read (fd
, (char*)buf
, sz
);
6980 if (err
== EWOULDBLOCK
)
6982 /* Set a small timeout. */
6984 timeout
.tv_usec
= 0;
6986 FD_SET ((int)fd
, &fdset
);
6988 /* Use select with the timeout to poll the selector. */
6989 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
6993 continue; /* Try again. */
6995 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
6996 Also accept select return 0 as an indicator to EAGAIN. */
6997 if (sc
== 0 || errno
== EWOULDBLOCK
)
7000 err
= errno
; /* Other errors are just passed on. */
7003 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7010 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7012 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7013 int fd
= process
->outfd
;
7014 ssize_t n
= sys_write (fd
, buf
, sz
);
7016 /* 0 or more bytes written means everything went fine. */
7020 /* Negative bytes written means we got an error in errno.
7021 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7022 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7023 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7027 #endif /* HAVE_GNUTLS */