1 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
2 Copyright (C) 1994-1995, 2000-2012 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 Geoff Voelker (voelker@cs.washington.edu) 7-29-94
22 #include <stddef.h> /* for offsetof */
25 #include <float.h> /* for DBL_EPSILON */
33 #include <sys/utime.h>
37 /* must include CRT headers *before* config.h */
40 #include <mbstring.h> /* for _mbspbrk */
73 #define _ANONYMOUS_UNION
74 #define _ANONYMOUS_STRUCT
77 /* Some versions of compiler define MEMORYSTATUSEX, some don't, so we
78 use a different name to avoid compilation problems. */
79 typedef struct _MEMORY_STATUS_EX
{
82 DWORDLONG ullTotalPhys
;
83 DWORDLONG ullAvailPhys
;
84 DWORDLONG ullTotalPageFile
;
85 DWORDLONG ullAvailPageFile
;
86 DWORDLONG ullTotalVirtual
;
87 DWORDLONG ullAvailVirtual
;
88 DWORDLONG ullAvailExtendedVirtual
;
89 } MEMORY_STATUS_EX
,*LPMEMORY_STATUS_EX
;
99 #if !defined (__MINGW32__) || __W32API_MAJOR_VERSION < 3 || (__W32API_MAJOR_VERSION == 3 && __W32API_MINOR_VERSION < 15)
100 /* This either is not in psapi.h or guarded by higher value of
101 _WIN32_WINNT than what we use. w32api supplied with MinGW 3.15
102 defines it in psapi.h */
103 typedef struct _PROCESS_MEMORY_COUNTERS_EX
{
105 DWORD PageFaultCount
;
106 DWORD PeakWorkingSetSize
;
107 DWORD WorkingSetSize
;
108 DWORD QuotaPeakPagedPoolUsage
;
109 DWORD QuotaPagedPoolUsage
;
110 DWORD QuotaPeakNonPagedPoolUsage
;
111 DWORD QuotaNonPagedPoolUsage
;
113 DWORD PeakPagefileUsage
;
115 } PROCESS_MEMORY_COUNTERS_EX
,*PPROCESS_MEMORY_COUNTERS_EX
;
118 #include <winioctl.h>
122 /* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER and the
123 associated macros, except on ntifs.h, which cannot be included
124 because it triggers conflicts with other Windows API headers. So
125 we define it here by hand. */
127 typedef struct _REPARSE_DATA_BUFFER
{
129 USHORT ReparseDataLength
;
133 USHORT SubstituteNameOffset
;
134 USHORT SubstituteNameLength
;
135 USHORT PrintNameOffset
;
136 USHORT PrintNameLength
;
139 } SymbolicLinkReparseBuffer
;
141 USHORT SubstituteNameOffset
;
142 USHORT SubstituteNameLength
;
143 USHORT PrintNameOffset
;
144 USHORT PrintNameLength
;
146 } MountPointReparseBuffer
;
149 } GenericReparseBuffer
;
151 } REPARSE_DATA_BUFFER
, *PREPARSE_DATA_BUFFER
;
153 #ifndef FILE_DEVICE_FILE_SYSTEM
154 #define FILE_DEVICE_FILE_SYSTEM 9
156 #ifndef METHOD_BUFFERED
157 #define METHOD_BUFFERED 0
159 #ifndef FILE_ANY_ACCESS
160 #define FILE_ANY_ACCESS 0x00000000
163 #define CTL_CODE(t,f,m,a) (((t)<<16)|((a)<<14)|((f)<<2)|(m))
165 #define FSCTL_GET_REPARSE_POINT \
166 CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS)
169 /* TCP connection support. */
170 #include <sys/socket.h>
191 #include "w32common.h"
193 #include "w32select.h"
195 #include "dispextern.h" /* for xstrcasecmp */
196 #include "coding.h" /* for Vlocale_coding_system */
198 #include "careadlinkat.h"
199 #include "allocator.h"
201 /* For serial_configure and serial_open. */
204 typedef HRESULT (WINAPI
* ShGetFolderPath_fn
)
205 (IN HWND
, IN
int, IN HANDLE
, IN DWORD
, OUT
char *);
207 Lisp_Object QCloaded_from
;
209 void globals_of_w32 (void);
210 static DWORD
get_rid (PSID
);
211 static int is_symlink (const char *);
212 static char * chase_symlinks (const char *);
213 static int enable_privilege (LPCTSTR
, BOOL
, TOKEN_PRIVILEGES
*);
214 static int restore_privilege (TOKEN_PRIVILEGES
*);
215 static BOOL WINAPI
revert_to_self (void);
217 extern int sys_access (const char *, int);
218 extern void *e_malloc (size_t);
219 extern int sys_select (int, SELECT_TYPE
*, SELECT_TYPE
*, SELECT_TYPE
*,
220 EMACS_TIME
*, void *);
224 /* Initialization states.
226 WARNING: If you add any more such variables for additional APIs,
227 you MUST add initialization for them to globals_of_w32
228 below. This is because these variables might get set
229 to non-NULL values during dumping, but the dumped Emacs
230 cannot reuse those values, because it could be run on a
231 different version of the OS, where API addresses are
233 static BOOL g_b_init_is_windows_9x
;
234 static BOOL g_b_init_open_process_token
;
235 static BOOL g_b_init_get_token_information
;
236 static BOOL g_b_init_lookup_account_sid
;
237 static BOOL g_b_init_get_sid_sub_authority
;
238 static BOOL g_b_init_get_sid_sub_authority_count
;
239 static BOOL g_b_init_get_security_info
;
240 static BOOL g_b_init_get_file_security
;
241 static BOOL g_b_init_get_security_descriptor_owner
;
242 static BOOL g_b_init_get_security_descriptor_group
;
243 static BOOL g_b_init_is_valid_sid
;
244 static BOOL g_b_init_create_toolhelp32_snapshot
;
245 static BOOL g_b_init_process32_first
;
246 static BOOL g_b_init_process32_next
;
247 static BOOL g_b_init_open_thread_token
;
248 static BOOL g_b_init_impersonate_self
;
249 static BOOL g_b_init_revert_to_self
;
250 static BOOL g_b_init_get_process_memory_info
;
251 static BOOL g_b_init_get_process_working_set_size
;
252 static BOOL g_b_init_global_memory_status
;
253 static BOOL g_b_init_global_memory_status_ex
;
254 static BOOL g_b_init_get_length_sid
;
255 static BOOL g_b_init_equal_sid
;
256 static BOOL g_b_init_copy_sid
;
257 static BOOL g_b_init_get_native_system_info
;
258 static BOOL g_b_init_get_system_times
;
259 static BOOL g_b_init_create_symbolic_link
;
262 BEGIN: Wrapper functions around OpenProcessToken
263 and other functions in advapi32.dll that are only
264 supported in Windows NT / 2k / XP
266 /* ** Function pointer typedefs ** */
267 typedef BOOL (WINAPI
* OpenProcessToken_Proc
) (
268 HANDLE ProcessHandle
,
270 PHANDLE TokenHandle
);
271 typedef BOOL (WINAPI
* GetTokenInformation_Proc
) (
273 TOKEN_INFORMATION_CLASS TokenInformationClass
,
274 LPVOID TokenInformation
,
275 DWORD TokenInformationLength
,
276 PDWORD ReturnLength
);
277 typedef BOOL (WINAPI
* GetProcessTimes_Proc
) (
278 HANDLE process_handle
,
279 LPFILETIME creation_time
,
280 LPFILETIME exit_time
,
281 LPFILETIME kernel_time
,
282 LPFILETIME user_time
);
284 GetProcessTimes_Proc get_process_times_fn
= NULL
;
287 const char * const LookupAccountSid_Name
= "LookupAccountSidW";
288 const char * const GetFileSecurity_Name
= "GetFileSecurityW";
290 const char * const LookupAccountSid_Name
= "LookupAccountSidA";
291 const char * const GetFileSecurity_Name
= "GetFileSecurityA";
293 typedef BOOL (WINAPI
* LookupAccountSid_Proc
) (
294 LPCTSTR lpSystemName
,
299 LPDWORD cbDomainName
,
300 PSID_NAME_USE peUse
);
301 typedef PDWORD (WINAPI
* GetSidSubAuthority_Proc
) (
304 typedef PUCHAR (WINAPI
* GetSidSubAuthorityCount_Proc
) (
306 typedef DWORD (WINAPI
* GetSecurityInfo_Proc
) (
308 SE_OBJECT_TYPE ObjectType
,
309 SECURITY_INFORMATION SecurityInfo
,
314 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
);
315 typedef BOOL (WINAPI
* GetFileSecurity_Proc
) (
317 SECURITY_INFORMATION RequestedInformation
,
318 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
320 LPDWORD lpnLengthNeeded
);
321 typedef BOOL (WINAPI
* GetSecurityDescriptorOwner_Proc
) (
322 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
324 LPBOOL lpbOwnerDefaulted
);
325 typedef BOOL (WINAPI
* GetSecurityDescriptorGroup_Proc
) (
326 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
328 LPBOOL lpbGroupDefaulted
);
329 typedef BOOL (WINAPI
* IsValidSid_Proc
) (
331 typedef HANDLE (WINAPI
* CreateToolhelp32Snapshot_Proc
) (
333 DWORD th32ProcessID
);
334 typedef BOOL (WINAPI
* Process32First_Proc
) (
336 LPPROCESSENTRY32 lppe
);
337 typedef BOOL (WINAPI
* Process32Next_Proc
) (
339 LPPROCESSENTRY32 lppe
);
340 typedef BOOL (WINAPI
* OpenThreadToken_Proc
) (
344 PHANDLE TokenHandle
);
345 typedef BOOL (WINAPI
* ImpersonateSelf_Proc
) (
346 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
);
347 typedef BOOL (WINAPI
* RevertToSelf_Proc
) (void);
348 typedef BOOL (WINAPI
* GetProcessMemoryInfo_Proc
) (
350 PPROCESS_MEMORY_COUNTERS ppsmemCounters
,
352 typedef BOOL (WINAPI
* GetProcessWorkingSetSize_Proc
) (
354 DWORD
* lpMinimumWorkingSetSize
,
355 DWORD
* lpMaximumWorkingSetSize
);
356 typedef BOOL (WINAPI
* GlobalMemoryStatus_Proc
) (
357 LPMEMORYSTATUS lpBuffer
);
358 typedef BOOL (WINAPI
* GlobalMemoryStatusEx_Proc
) (
359 LPMEMORY_STATUS_EX lpBuffer
);
360 typedef BOOL (WINAPI
* CopySid_Proc
) (
361 DWORD nDestinationSidLength
,
362 PSID pDestinationSid
,
364 typedef BOOL (WINAPI
* EqualSid_Proc
) (
367 typedef DWORD (WINAPI
* GetLengthSid_Proc
) (
369 typedef void (WINAPI
* GetNativeSystemInfo_Proc
) (
370 LPSYSTEM_INFO lpSystemInfo
);
371 typedef BOOL (WINAPI
* GetSystemTimes_Proc
) (
372 LPFILETIME lpIdleTime
,
373 LPFILETIME lpKernelTime
,
374 LPFILETIME lpUserTime
);
375 typedef BOOLEAN (WINAPI
*CreateSymbolicLink_Proc
) (
376 LPTSTR lpSymlinkFileName
,
377 LPTSTR lpTargetFileName
,
380 /* ** A utility function ** */
384 static BOOL s_b_ret
= 0;
385 OSVERSIONINFO os_ver
;
386 if (g_b_init_is_windows_9x
== 0)
388 g_b_init_is_windows_9x
= 1;
389 ZeroMemory (&os_ver
, sizeof (OSVERSIONINFO
));
390 os_ver
.dwOSVersionInfoSize
= sizeof (OSVERSIONINFO
);
391 if (GetVersionEx (&os_ver
))
393 s_b_ret
= (os_ver
.dwPlatformId
== VER_PLATFORM_WIN32_WINDOWS
);
399 static Lisp_Object
ltime (ULONGLONG
);
401 /* Get total user and system times for get-internal-run-time.
402 Returns a list of integers if the times are provided by the OS
403 (NT derivatives), otherwise it returns the result of current-time. */
405 w32_get_internal_run_time (void)
407 if (get_process_times_fn
)
409 FILETIME create
, exit
, kernel
, user
;
410 HANDLE proc
= GetCurrentProcess ();
411 if ((*get_process_times_fn
) (proc
, &create
, &exit
, &kernel
, &user
))
413 LARGE_INTEGER user_int
, kernel_int
, total
;
414 user_int
.LowPart
= user
.dwLowDateTime
;
415 user_int
.HighPart
= user
.dwHighDateTime
;
416 kernel_int
.LowPart
= kernel
.dwLowDateTime
;
417 kernel_int
.HighPart
= kernel
.dwHighDateTime
;
418 total
.QuadPart
= user_int
.QuadPart
+ kernel_int
.QuadPart
;
419 return ltime (total
.QuadPart
);
423 return Fcurrent_time ();
426 /* ** The wrapper functions ** */
429 open_process_token (HANDLE ProcessHandle
,
433 static OpenProcessToken_Proc s_pfn_Open_Process_Token
= NULL
;
434 HMODULE hm_advapi32
= NULL
;
435 if (is_windows_9x () == TRUE
)
439 if (g_b_init_open_process_token
== 0)
441 g_b_init_open_process_token
= 1;
442 hm_advapi32
= LoadLibrary ("Advapi32.dll");
443 s_pfn_Open_Process_Token
=
444 (OpenProcessToken_Proc
) GetProcAddress (hm_advapi32
, "OpenProcessToken");
446 if (s_pfn_Open_Process_Token
== NULL
)
451 s_pfn_Open_Process_Token (
459 get_token_information (HANDLE TokenHandle
,
460 TOKEN_INFORMATION_CLASS TokenInformationClass
,
461 LPVOID TokenInformation
,
462 DWORD TokenInformationLength
,
465 static GetTokenInformation_Proc s_pfn_Get_Token_Information
= NULL
;
466 HMODULE hm_advapi32
= NULL
;
467 if (is_windows_9x () == TRUE
)
471 if (g_b_init_get_token_information
== 0)
473 g_b_init_get_token_information
= 1;
474 hm_advapi32
= LoadLibrary ("Advapi32.dll");
475 s_pfn_Get_Token_Information
=
476 (GetTokenInformation_Proc
) GetProcAddress (hm_advapi32
, "GetTokenInformation");
478 if (s_pfn_Get_Token_Information
== NULL
)
483 s_pfn_Get_Token_Information (
485 TokenInformationClass
,
487 TokenInformationLength
,
493 lookup_account_sid (LPCTSTR lpSystemName
,
498 LPDWORD cbDomainName
,
501 static LookupAccountSid_Proc s_pfn_Lookup_Account_Sid
= NULL
;
502 HMODULE hm_advapi32
= NULL
;
503 if (is_windows_9x () == TRUE
)
507 if (g_b_init_lookup_account_sid
== 0)
509 g_b_init_lookup_account_sid
= 1;
510 hm_advapi32
= LoadLibrary ("Advapi32.dll");
511 s_pfn_Lookup_Account_Sid
=
512 (LookupAccountSid_Proc
) GetProcAddress (hm_advapi32
, LookupAccountSid_Name
);
514 if (s_pfn_Lookup_Account_Sid
== NULL
)
519 s_pfn_Lookup_Account_Sid (
531 get_sid_sub_authority (PSID pSid
, DWORD n
)
533 static GetSidSubAuthority_Proc s_pfn_Get_Sid_Sub_Authority
= NULL
;
534 static DWORD zero
= 0U;
535 HMODULE hm_advapi32
= NULL
;
536 if (is_windows_9x () == TRUE
)
540 if (g_b_init_get_sid_sub_authority
== 0)
542 g_b_init_get_sid_sub_authority
= 1;
543 hm_advapi32
= LoadLibrary ("Advapi32.dll");
544 s_pfn_Get_Sid_Sub_Authority
=
545 (GetSidSubAuthority_Proc
) GetProcAddress (
546 hm_advapi32
, "GetSidSubAuthority");
548 if (s_pfn_Get_Sid_Sub_Authority
== NULL
)
552 return (s_pfn_Get_Sid_Sub_Authority (pSid
, n
));
556 get_sid_sub_authority_count (PSID pSid
)
558 static GetSidSubAuthorityCount_Proc s_pfn_Get_Sid_Sub_Authority_Count
= NULL
;
559 static UCHAR zero
= 0U;
560 HMODULE hm_advapi32
= NULL
;
561 if (is_windows_9x () == TRUE
)
565 if (g_b_init_get_sid_sub_authority_count
== 0)
567 g_b_init_get_sid_sub_authority_count
= 1;
568 hm_advapi32
= LoadLibrary ("Advapi32.dll");
569 s_pfn_Get_Sid_Sub_Authority_Count
=
570 (GetSidSubAuthorityCount_Proc
) GetProcAddress (
571 hm_advapi32
, "GetSidSubAuthorityCount");
573 if (s_pfn_Get_Sid_Sub_Authority_Count
== NULL
)
577 return (s_pfn_Get_Sid_Sub_Authority_Count (pSid
));
581 get_security_info (HANDLE handle
,
582 SE_OBJECT_TYPE ObjectType
,
583 SECURITY_INFORMATION SecurityInfo
,
588 PSECURITY_DESCRIPTOR
*ppSecurityDescriptor
)
590 static GetSecurityInfo_Proc s_pfn_Get_Security_Info
= NULL
;
591 HMODULE hm_advapi32
= NULL
;
592 if (is_windows_9x () == TRUE
)
596 if (g_b_init_get_security_info
== 0)
598 g_b_init_get_security_info
= 1;
599 hm_advapi32
= LoadLibrary ("Advapi32.dll");
600 s_pfn_Get_Security_Info
=
601 (GetSecurityInfo_Proc
) GetProcAddress (
602 hm_advapi32
, "GetSecurityInfo");
604 if (s_pfn_Get_Security_Info
== NULL
)
608 return (s_pfn_Get_Security_Info (handle
, ObjectType
, SecurityInfo
,
609 ppsidOwner
, ppsidGroup
, ppDacl
, ppSacl
,
610 ppSecurityDescriptor
));
614 get_file_security (LPCTSTR lpFileName
,
615 SECURITY_INFORMATION RequestedInformation
,
616 PSECURITY_DESCRIPTOR pSecurityDescriptor
,
618 LPDWORD lpnLengthNeeded
)
620 static GetFileSecurity_Proc s_pfn_Get_File_Security
= NULL
;
621 HMODULE hm_advapi32
= NULL
;
622 if (is_windows_9x () == TRUE
)
626 if (g_b_init_get_file_security
== 0)
628 g_b_init_get_file_security
= 1;
629 hm_advapi32
= LoadLibrary ("Advapi32.dll");
630 s_pfn_Get_File_Security
=
631 (GetFileSecurity_Proc
) GetProcAddress (
632 hm_advapi32
, GetFileSecurity_Name
);
634 if (s_pfn_Get_File_Security
== NULL
)
638 return (s_pfn_Get_File_Security (lpFileName
, RequestedInformation
,
639 pSecurityDescriptor
, nLength
,
644 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
646 LPBOOL lpbOwnerDefaulted
)
648 static GetSecurityDescriptorOwner_Proc s_pfn_Get_Security_Descriptor_Owner
= NULL
;
649 HMODULE hm_advapi32
= NULL
;
650 if (is_windows_9x () == TRUE
)
654 if (g_b_init_get_security_descriptor_owner
== 0)
656 g_b_init_get_security_descriptor_owner
= 1;
657 hm_advapi32
= LoadLibrary ("Advapi32.dll");
658 s_pfn_Get_Security_Descriptor_Owner
=
659 (GetSecurityDescriptorOwner_Proc
) GetProcAddress (
660 hm_advapi32
, "GetSecurityDescriptorOwner");
662 if (s_pfn_Get_Security_Descriptor_Owner
== NULL
)
666 return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor
, pOwner
,
671 get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor
,
673 LPBOOL lpbGroupDefaulted
)
675 static GetSecurityDescriptorGroup_Proc s_pfn_Get_Security_Descriptor_Group
= NULL
;
676 HMODULE hm_advapi32
= NULL
;
677 if (is_windows_9x () == TRUE
)
681 if (g_b_init_get_security_descriptor_group
== 0)
683 g_b_init_get_security_descriptor_group
= 1;
684 hm_advapi32
= LoadLibrary ("Advapi32.dll");
685 s_pfn_Get_Security_Descriptor_Group
=
686 (GetSecurityDescriptorGroup_Proc
) GetProcAddress (
687 hm_advapi32
, "GetSecurityDescriptorGroup");
689 if (s_pfn_Get_Security_Descriptor_Group
== NULL
)
693 return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor
, pGroup
,
698 is_valid_sid (PSID sid
)
700 static IsValidSid_Proc s_pfn_Is_Valid_Sid
= NULL
;
701 HMODULE hm_advapi32
= NULL
;
702 if (is_windows_9x () == TRUE
)
706 if (g_b_init_is_valid_sid
== 0)
708 g_b_init_is_valid_sid
= 1;
709 hm_advapi32
= LoadLibrary ("Advapi32.dll");
711 (IsValidSid_Proc
) GetProcAddress (
712 hm_advapi32
, "IsValidSid");
714 if (s_pfn_Is_Valid_Sid
== NULL
)
718 return (s_pfn_Is_Valid_Sid (sid
));
722 equal_sid (PSID sid1
, PSID sid2
)
724 static EqualSid_Proc s_pfn_Equal_Sid
= NULL
;
725 HMODULE hm_advapi32
= NULL
;
726 if (is_windows_9x () == TRUE
)
730 if (g_b_init_equal_sid
== 0)
732 g_b_init_equal_sid
= 1;
733 hm_advapi32
= LoadLibrary ("Advapi32.dll");
735 (EqualSid_Proc
) GetProcAddress (
736 hm_advapi32
, "EqualSid");
738 if (s_pfn_Equal_Sid
== NULL
)
742 return (s_pfn_Equal_Sid (sid1
, sid2
));
746 get_length_sid (PSID sid
)
748 static GetLengthSid_Proc s_pfn_Get_Length_Sid
= NULL
;
749 HMODULE hm_advapi32
= NULL
;
750 if (is_windows_9x () == TRUE
)
754 if (g_b_init_get_length_sid
== 0)
756 g_b_init_get_length_sid
= 1;
757 hm_advapi32
= LoadLibrary ("Advapi32.dll");
758 s_pfn_Get_Length_Sid
=
759 (GetLengthSid_Proc
) GetProcAddress (
760 hm_advapi32
, "GetLengthSid");
762 if (s_pfn_Get_Length_Sid
== NULL
)
766 return (s_pfn_Get_Length_Sid (sid
));
770 copy_sid (DWORD destlen
, PSID dest
, PSID src
)
772 static CopySid_Proc s_pfn_Copy_Sid
= NULL
;
773 HMODULE hm_advapi32
= NULL
;
774 if (is_windows_9x () == TRUE
)
778 if (g_b_init_copy_sid
== 0)
780 g_b_init_copy_sid
= 1;
781 hm_advapi32
= LoadLibrary ("Advapi32.dll");
783 (CopySid_Proc
) GetProcAddress (
784 hm_advapi32
, "CopySid");
786 if (s_pfn_Copy_Sid
== NULL
)
790 return (s_pfn_Copy_Sid (destlen
, dest
, src
));
794 END: Wrapper functions around OpenProcessToken
795 and other functions in advapi32.dll that are only
796 supported in Windows NT / 2k / XP
800 get_native_system_info (LPSYSTEM_INFO lpSystemInfo
)
802 static GetNativeSystemInfo_Proc s_pfn_Get_Native_System_Info
= NULL
;
803 if (is_windows_9x () != TRUE
)
805 if (g_b_init_get_native_system_info
== 0)
807 g_b_init_get_native_system_info
= 1;
808 s_pfn_Get_Native_System_Info
=
809 (GetNativeSystemInfo_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
810 "GetNativeSystemInfo");
812 if (s_pfn_Get_Native_System_Info
!= NULL
)
813 s_pfn_Get_Native_System_Info (lpSystemInfo
);
816 lpSystemInfo
->dwNumberOfProcessors
= -1;
820 get_system_times (LPFILETIME lpIdleTime
,
821 LPFILETIME lpKernelTime
,
822 LPFILETIME lpUserTime
)
824 static GetSystemTimes_Proc s_pfn_Get_System_times
= NULL
;
825 if (is_windows_9x () == TRUE
)
829 if (g_b_init_get_system_times
== 0)
831 g_b_init_get_system_times
= 1;
832 s_pfn_Get_System_times
=
833 (GetSystemTimes_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
836 if (s_pfn_Get_System_times
== NULL
)
838 return (s_pfn_Get_System_times (lpIdleTime
, lpKernelTime
, lpUserTime
));
841 static BOOLEAN WINAPI
842 create_symbolic_link (LPTSTR lpSymlinkFilename
,
843 LPTSTR lpTargetFileName
,
846 static CreateSymbolicLink_Proc s_pfn_Create_Symbolic_Link
= NULL
;
849 if (is_windows_9x () == TRUE
)
854 if (g_b_init_create_symbolic_link
== 0)
856 g_b_init_create_symbolic_link
= 1;
858 s_pfn_Create_Symbolic_Link
=
859 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
860 "CreateSymbolicLinkW");
862 s_pfn_Create_Symbolic_Link
=
863 (CreateSymbolicLink_Proc
)GetProcAddress (GetModuleHandle ("kernel32.dll"),
864 "CreateSymbolicLinkA");
867 if (s_pfn_Create_Symbolic_Link
== NULL
)
873 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
875 /* If we were denied creation of the symlink, try again after
876 enabling the SeCreateSymbolicLinkPrivilege for our process. */
879 TOKEN_PRIVILEGES priv_current
;
881 if (enable_privilege (SE_CREATE_SYMBOLIC_LINK_NAME
, TRUE
, &priv_current
))
883 retval
= s_pfn_Create_Symbolic_Link (lpSymlinkFilename
, lpTargetFileName
,
885 restore_privilege (&priv_current
);
893 /* Return 1 if P is a valid pointer to an object of size SIZE. Return
894 0 if P is NOT a valid pointer. Return -1 if we cannot validate P.
896 This is called from alloc.c:valid_pointer_p. */
898 w32_valid_pointer_p (void *p
, int size
)
901 HANDLE h
= OpenProcess (PROCESS_VM_READ
, FALSE
, GetCurrentProcessId ());
905 unsigned char *buf
= alloca (size
);
906 int retval
= ReadProcessMemory (h
, p
, buf
, size
, &done
);
915 static char startup_dir
[MAXPATHLEN
];
917 /* Get the current working directory. */
919 getcwd (char *dir
, int dirsize
)
926 if (dirsize
<= strlen (startup_dir
))
932 if (GetCurrentDirectory (MAXPATHLEN
, dir
) > 0)
936 /* Emacs doesn't actually change directory itself, it stays in the
937 same directory where it was started. */
938 strcpy (dir
, startup_dir
);
943 /* Emulate getloadavg. */
952 /* Number of processors on this machine. */
953 static unsigned num_of_processors
;
955 /* We maintain 1-sec samples for the last 16 minutes in a circular buffer. */
956 static struct load_sample samples
[16*60];
957 static int first_idx
= -1, last_idx
= -1;
958 static int max_idx
= sizeof (samples
) / sizeof (samples
[0]);
963 int next_idx
= from
+ 1;
965 if (next_idx
>= max_idx
)
974 int prev_idx
= from
- 1;
977 prev_idx
= max_idx
- 1;
983 sample_system_load (ULONGLONG
*idle
, ULONGLONG
*kernel
, ULONGLONG
*user
)
986 FILETIME ft_idle
, ft_user
, ft_kernel
;
988 /* Initialize the number of processors on this machine. */
989 if (num_of_processors
<= 0)
991 get_native_system_info (&sysinfo
);
992 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
993 if (num_of_processors
<= 0)
995 GetSystemInfo (&sysinfo
);
996 num_of_processors
= sysinfo
.dwNumberOfProcessors
;
998 if (num_of_processors
<= 0)
999 num_of_processors
= 1;
1002 /* TODO: Take into account threads that are ready to run, by
1003 sampling the "\System\Processor Queue Length" performance
1004 counter. The code below accounts only for threads that are
1005 actually running. */
1007 if (get_system_times (&ft_idle
, &ft_kernel
, &ft_user
))
1009 ULARGE_INTEGER uidle
, ukernel
, uuser
;
1011 memcpy (&uidle
, &ft_idle
, sizeof (ft_idle
));
1012 memcpy (&ukernel
, &ft_kernel
, sizeof (ft_kernel
));
1013 memcpy (&uuser
, &ft_user
, sizeof (ft_user
));
1014 *idle
= uidle
.QuadPart
;
1015 *kernel
= ukernel
.QuadPart
;
1016 *user
= uuser
.QuadPart
;
1026 /* Produce the load average for a given time interval, using the
1027 samples in the samples[] array. WHICH can be 0, 1, or 2, meaning
1028 1-minute, 5-minute, or 15-minute average, respectively. */
1032 double retval
= -1.0;
1035 double span
= (which
== 0 ? 1.0 : (which
== 1 ? 5.0 : 15.0)) * 60;
1036 time_t now
= samples
[last_idx
].sample_time
;
1038 if (first_idx
!= last_idx
)
1040 for (idx
= buf_prev (last_idx
); ; idx
= buf_prev (idx
))
1042 tdiff
= difftime (now
, samples
[idx
].sample_time
);
1043 if (tdiff
>= span
- 2*DBL_EPSILON
*now
)
1046 samples
[last_idx
].kernel
+ samples
[last_idx
].user
1047 - (samples
[idx
].kernel
+ samples
[idx
].user
);
1048 long double idl
= samples
[last_idx
].idle
- samples
[idx
].idle
;
1050 retval
= (1.0 - idl
/ sys
) * num_of_processors
;
1053 if (idx
== first_idx
)
1062 getloadavg (double loadavg
[], int nelem
)
1065 ULONGLONG idle
, kernel
, user
;
1066 time_t now
= time (NULL
);
1068 /* Store another sample. We ignore samples that are less than 1 sec
1070 if (difftime (now
, samples
[last_idx
].sample_time
) >= 1.0 - 2*DBL_EPSILON
*now
)
1072 sample_system_load (&idle
, &kernel
, &user
);
1073 last_idx
= buf_next (last_idx
);
1074 samples
[last_idx
].sample_time
= now
;
1075 samples
[last_idx
].idle
= idle
;
1076 samples
[last_idx
].kernel
= kernel
;
1077 samples
[last_idx
].user
= user
;
1078 /* If the buffer has more that 15 min worth of samples, discard
1080 if (first_idx
== -1)
1081 first_idx
= last_idx
;
1082 while (first_idx
!= last_idx
1083 && (difftime (now
, samples
[first_idx
].sample_time
)
1084 >= 15.0*60 + 2*DBL_EPSILON
*now
))
1085 first_idx
= buf_next (first_idx
);
1088 for (elem
= 0; elem
< nelem
; elem
++)
1090 double avg
= getavg (elem
);
1094 loadavg
[elem
] = avg
;
1100 /* Emulate getpwuid, getpwnam and others. */
1102 #define PASSWD_FIELD_SIZE 256
1104 static char dflt_passwd_name
[PASSWD_FIELD_SIZE
];
1105 static char dflt_passwd_passwd
[PASSWD_FIELD_SIZE
];
1106 static char dflt_passwd_gecos
[PASSWD_FIELD_SIZE
];
1107 static char dflt_passwd_dir
[PASSWD_FIELD_SIZE
];
1108 static char dflt_passwd_shell
[PASSWD_FIELD_SIZE
];
1110 static struct passwd dflt_passwd
=
1122 static char dflt_group_name
[GNLEN
+1];
1124 static struct group dflt_group
=
1126 /* When group information is not available, we return this as the
1127 group for all files. */
1135 return dflt_passwd
.pw_uid
;
1141 /* I could imagine arguing for checking to see whether the user is
1142 in the Administrators group and returning a UID of 0 for that
1143 case, but I don't know how wise that would be in the long run. */
1150 return dflt_passwd
.pw_gid
;
1160 getpwuid (unsigned uid
)
1162 if (uid
== dflt_passwd
.pw_uid
)
1163 return &dflt_passwd
;
1168 getgrgid (gid_t gid
)
1174 getpwnam (char *name
)
1178 pw
= getpwuid (getuid ());
1182 if (xstrcasecmp (name
, pw
->pw_name
))
1189 init_user_info (void)
1191 /* Find the user's real name by opening the process token and
1192 looking up the name associated with the user-sid in that token.
1194 Use the relative portion of the identifier authority value from
1195 the user-sid as the user id value (same for group id using the
1196 primary group sid from the process token). */
1198 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
1199 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
1200 DWORD glength
= sizeof (gname
);
1201 HANDLE token
= NULL
;
1202 SID_NAME_USE user_type
;
1203 unsigned char *buf
= NULL
;
1205 TOKEN_USER user_token
;
1206 TOKEN_PRIMARY_GROUP group_token
;
1209 result
= open_process_token (GetCurrentProcess (), TOKEN_QUERY
, &token
);
1212 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
1213 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1215 buf
= xmalloc (blen
);
1216 result
= get_token_information (token
, TokenUser
,
1217 (LPVOID
)buf
, blen
, &needed
);
1220 memcpy (&user_token
, buf
, sizeof (user_token
));
1221 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
1223 domain
, &dlength
, &user_type
);
1231 strcpy (dflt_passwd
.pw_name
, uname
);
1232 /* Determine a reasonable uid value. */
1233 if (xstrcasecmp ("administrator", uname
) == 0)
1235 dflt_passwd
.pw_uid
= 500; /* well-known Administrator uid */
1236 dflt_passwd
.pw_gid
= 513; /* well-known None gid */
1240 /* Use the last sub-authority value of the RID, the relative
1241 portion of the SID, as user/group ID. */
1242 dflt_passwd
.pw_uid
= get_rid (user_token
.User
.Sid
);
1244 /* Get group id and name. */
1245 result
= get_token_information (token
, TokenPrimaryGroup
,
1246 (LPVOID
)buf
, blen
, &needed
);
1247 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
1249 buf
= xrealloc (buf
, blen
= needed
);
1250 result
= get_token_information (token
, TokenPrimaryGroup
,
1251 (LPVOID
)buf
, blen
, &needed
);
1255 memcpy (&group_token
, buf
, sizeof (group_token
));
1256 dflt_passwd
.pw_gid
= get_rid (group_token
.PrimaryGroup
);
1257 dlength
= sizeof (domain
);
1258 /* If we can get at the real Primary Group name, use that.
1259 Otherwise, the default group name was already set to
1260 "None" in globals_of_w32. */
1261 if (lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
1262 gname
, &glength
, NULL
, &dlength
,
1264 strcpy (dflt_group_name
, gname
);
1267 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1270 /* If security calls are not supported (presumably because we
1271 are running under Windows 9X), fallback to this: */
1272 else if (GetUserName (uname
, &ulength
))
1274 strcpy (dflt_passwd
.pw_name
, uname
);
1275 if (xstrcasecmp ("administrator", uname
) == 0)
1276 dflt_passwd
.pw_uid
= 0;
1278 dflt_passwd
.pw_uid
= 123;
1279 dflt_passwd
.pw_gid
= dflt_passwd
.pw_uid
;
1283 strcpy (dflt_passwd
.pw_name
, "unknown");
1284 dflt_passwd
.pw_uid
= 123;
1285 dflt_passwd
.pw_gid
= 123;
1287 dflt_group
.gr_gid
= dflt_passwd
.pw_gid
;
1289 /* Ensure HOME and SHELL are defined. */
1290 if (getenv ("HOME") == NULL
)
1292 if (getenv ("SHELL") == NULL
)
1295 /* Set dir and shell from environment variables. */
1296 strcpy (dflt_passwd
.pw_dir
, getenv ("HOME"));
1297 strcpy (dflt_passwd
.pw_shell
, getenv ("SHELL"));
1301 CloseHandle (token
);
1307 /* rand () on NT gives us 15 random bits...hack together 30 bits. */
1308 return ((rand () << 15) | rand ());
1318 /* Normalize filename by converting all path separators to
1319 the specified separator. Also conditionally convert upper
1320 case path name components to lower case. */
1323 normalize_filename (register char *fp
, char path_sep
)
1328 /* Always lower-case drive letters a-z, even if the filesystem
1329 preserves case in filenames.
1330 This is so filenames can be compared by string comparison
1331 functions that are case-sensitive. Even case-preserving filesystems
1332 do not distinguish case in drive letters. */
1333 if (fp
[1] == ':' && *fp
>= 'A' && *fp
<= 'Z')
1339 if (NILP (Vw32_downcase_file_names
))
1343 if (*fp
== '/' || *fp
== '\\')
1350 sep
= path_sep
; /* convert to this path separator */
1351 elem
= fp
; /* start of current path element */
1354 if (*fp
>= 'a' && *fp
<= 'z')
1355 elem
= 0; /* don't convert this element */
1357 if (*fp
== 0 || *fp
== ':')
1359 sep
= *fp
; /* restore current separator (or 0) */
1360 *fp
= '/'; /* after conversion of this element */
1363 if (*fp
== '/' || *fp
== '\\')
1365 if (elem
&& elem
!= fp
)
1367 *fp
= 0; /* temporary end of string */
1368 _strlwr (elem
); /* while we convert to lower case */
1370 *fp
= sep
; /* convert (or restore) path separator */
1371 elem
= fp
+ 1; /* next element starts after separator */
1377 /* Destructively turn backslashes into slashes. */
1379 dostounix_filename (register char *p
)
1381 normalize_filename (p
, '/');
1384 /* Destructively turn slashes into backslashes. */
1386 unixtodos_filename (register char *p
)
1388 normalize_filename (p
, '\\');
1391 /* Remove all CR's that are followed by a LF.
1392 (From msdos.c...probably should figure out a way to share it,
1393 although this code isn't going to ever change.) */
1395 crlf_to_lf (register int n
, register unsigned char *buf
)
1397 unsigned char *np
= buf
;
1398 unsigned char *startp
= buf
;
1399 unsigned char *endp
= buf
+ n
;
1403 while (buf
< endp
- 1)
1407 if (*(++buf
) != 0x0a)
1418 /* Parse the root part of file name, if present. Return length and
1419 optionally store pointer to char after root. */
1421 parse_root (char * name
, char ** pPath
)
1423 char * start
= name
;
1428 /* find the root name of the volume if given */
1429 if (isalpha (name
[0]) && name
[1] == ':')
1431 /* skip past drive specifier */
1433 if (IS_DIRECTORY_SEP (name
[0]))
1436 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
1442 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
1447 if (IS_DIRECTORY_SEP (name
[0]))
1454 return name
- start
;
1457 /* Get long base name for name; name is assumed to be absolute. */
1459 get_long_basename (char * name
, char * buf
, int size
)
1461 WIN32_FIND_DATA find_data
;
1465 /* must be valid filename, no wild cards or other invalid characters */
1466 if (_mbspbrk (name
, "*?|<>\""))
1469 dir_handle
= FindFirstFile (name
, &find_data
);
1470 if (dir_handle
!= INVALID_HANDLE_VALUE
)
1472 if ((len
= strlen (find_data
.cFileName
)) < size
)
1473 memcpy (buf
, find_data
.cFileName
, len
+ 1);
1476 FindClose (dir_handle
);
1481 /* Get long name for file, if possible (assumed to be absolute). */
1483 w32_get_long_filename (char * name
, char * buf
, int size
)
1488 char full
[ MAX_PATH
];
1491 len
= strlen (name
);
1492 if (len
>= MAX_PATH
)
1495 /* Use local copy for destructive modification. */
1496 memcpy (full
, name
, len
+1);
1497 unixtodos_filename (full
);
1499 /* Copy root part verbatim. */
1500 len
= parse_root (full
, &p
);
1501 memcpy (o
, full
, len
);
1506 while (p
!= NULL
&& *p
)
1509 p
= strchr (q
, '\\');
1511 len
= get_long_basename (full
, o
, size
);
1534 is_unc_volume (const char *filename
)
1536 const char *ptr
= filename
;
1538 if (!IS_DIRECTORY_SEP (ptr
[0]) || !IS_DIRECTORY_SEP (ptr
[1]) || !ptr
[2])
1541 if (_mbspbrk (ptr
+ 2, "*?|<>\"\\/"))
1547 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
1550 w32_get_resource (char *key
, LPDWORD lpdwtype
)
1553 HKEY hrootkey
= NULL
;
1556 /* Check both the current user and the local machine to see if
1557 we have any resources. */
1559 if (RegOpenKeyEx (HKEY_CURRENT_USER
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1563 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1564 && (lpvalue
= xmalloc (cbData
)) != NULL
1565 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1567 RegCloseKey (hrootkey
);
1573 RegCloseKey (hrootkey
);
1576 if (RegOpenKeyEx (HKEY_LOCAL_MACHINE
, REG_ROOT
, 0, KEY_READ
, &hrootkey
) == ERROR_SUCCESS
)
1580 if (RegQueryValueEx (hrootkey
, key
, NULL
, NULL
, NULL
, &cbData
) == ERROR_SUCCESS
1581 && (lpvalue
= xmalloc (cbData
)) != NULL
1582 && RegQueryValueEx (hrootkey
, key
, NULL
, lpdwtype
, lpvalue
, &cbData
) == ERROR_SUCCESS
)
1584 RegCloseKey (hrootkey
);
1590 RegCloseKey (hrootkey
);
1596 char *get_emacs_configuration (void);
1599 init_environment (char ** argv
)
1601 static const char * const tempdirs
[] = {
1602 "$TMPDIR", "$TEMP", "$TMP", "c:/"
1607 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
1609 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
1610 temporary files and assume "/tmp" if $TMPDIR is unset, which
1611 will break on DOS/Windows. Refuse to work if we cannot find
1612 a directory, not even "c:/", usable for that purpose. */
1613 for (i
= 0; i
< imax
; i
++)
1615 const char *tmp
= tempdirs
[i
];
1618 tmp
= getenv (tmp
+ 1);
1619 /* Note that `access' can lie to us if the directory resides on a
1620 read-only filesystem, like CD-ROM or a write-protected floppy.
1621 The only way to be really sure is to actually create a file and
1622 see if it succeeds. But I think that's too much to ask. */
1624 /* MSVCRT's _access crashes with D_OK. */
1625 if (tmp
&& faccessat (AT_FDCWD
, tmp
, D_OK
, AT_EACCESS
) == 0)
1627 char * var
= alloca (strlen (tmp
) + 8);
1628 sprintf (var
, "TMPDIR=%s", tmp
);
1629 _putenv (strdup (var
));
1636 Fcons (build_string ("no usable temporary directories found!!"),
1638 "While setting TMPDIR: ");
1640 /* Check for environment variables and use registry settings if they
1641 don't exist. Fallback on default values where applicable. */
1646 char locale_name
[32];
1647 char default_home
[MAX_PATH
];
1650 static const struct env_entry
1656 /* If the default value is NULL, we will use the value from the
1657 outside environment or the Registry, but will not push the
1658 variable into the Emacs environment if it is defined neither
1659 in the Registry nor in the outside environment. */
1661 {"PRELOAD_WINSOCK", NULL
},
1662 {"emacs_dir", "C:/emacs"},
1663 {"EMACSLOADPATH", NULL
},
1664 {"SHELL", "%emacs_dir%/bin/cmdproxy.exe"},
1665 {"EMACSDATA", NULL
},
1666 {"EMACSPATH", NULL
},
1673 #define N_ENV_VARS sizeof (dflt_envvars)/sizeof (dflt_envvars[0])
1675 /* We need to copy dflt_envvars[] and work on the copy because we
1676 don't want the dumped Emacs to inherit the values of
1677 environment variables we saw during dumping (which could be on
1678 a different system). The defaults above must be left intact. */
1679 struct env_entry env_vars
[N_ENV_VARS
];
1681 for (i
= 0; i
< N_ENV_VARS
; i
++)
1682 env_vars
[i
] = dflt_envvars
[i
];
1684 /* For backwards compatibility, check if a .emacs file exists in C:/
1685 If not, then we can try to default to the appdata directory under the
1686 user's profile, which is more likely to be writable. */
1687 if (!check_existing ("C:/.emacs"))
1689 HRESULT profile_result
;
1690 /* Dynamically load ShGetFolderPath, as it won't exist on versions
1691 of Windows 95 and NT4 that have not been updated to include
1693 ShGetFolderPath_fn get_folder_path
;
1694 get_folder_path
= (ShGetFolderPath_fn
)
1695 GetProcAddress (GetModuleHandle ("shell32.dll"), "SHGetFolderPathA");
1697 if (get_folder_path
!= NULL
)
1699 profile_result
= get_folder_path (NULL
, CSIDL_APPDATA
, NULL
,
1702 /* If we can't get the appdata dir, revert to old behavior. */
1703 if (profile_result
== S_OK
)
1705 env_vars
[0].def_value
= default_home
;
1711 /* Get default locale info and use it for LANG. */
1712 if (GetLocaleInfo (LOCALE_USER_DEFAULT
,
1713 LOCALE_SABBREVLANGNAME
| LOCALE_USE_CP_ACP
,
1714 locale_name
, sizeof (locale_name
)))
1716 for (i
= 0; i
< N_ENV_VARS
; i
++)
1718 if (strcmp (env_vars
[i
].name
, "LANG") == 0)
1720 env_vars
[i
].def_value
= locale_name
;
1726 #define SET_ENV_BUF_SIZE (4 * MAX_PATH) /* to cover EMACSLOADPATH */
1728 /* Treat emacs_dir specially: set it unconditionally based on our
1732 char modname
[MAX_PATH
];
1734 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1736 if ((p
= strrchr (modname
, '\\')) == NULL
)
1740 if ((p
= strrchr (modname
, '\\')) && xstrcasecmp (p
, "\\bin") == 0)
1742 char buf
[SET_ENV_BUF_SIZE
];
1745 for (p
= modname
; *p
; p
++)
1746 if (*p
== '\\') *p
= '/';
1748 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1749 _putenv (strdup (buf
));
1751 /* Handle running emacs from the build directory: src/oo-spd/i386/ */
1753 /* FIXME: should use substring of get_emacs_configuration ().
1754 But I don't think the Windows build supports alpha, mips etc
1755 anymore, so have taken the easy option for now. */
1756 else if (p
&& (xstrcasecmp (p
, "\\i386") == 0
1757 || xstrcasecmp (p
, "\\AMD64") == 0))
1760 p
= strrchr (modname
, '\\');
1764 p
= strrchr (modname
, '\\');
1765 if (p
&& xstrcasecmp (p
, "\\src") == 0)
1767 char buf
[SET_ENV_BUF_SIZE
];
1770 for (p
= modname
; *p
; p
++)
1771 if (*p
== '\\') *p
= '/';
1773 _snprintf (buf
, sizeof (buf
)-1, "emacs_dir=%s", modname
);
1774 _putenv (strdup (buf
));
1780 for (i
= 0; i
< N_ENV_VARS
; i
++)
1782 if (!getenv (env_vars
[i
].name
))
1786 if ((lpval
= w32_get_resource (env_vars
[i
].name
, &dwType
)) == NULL
1787 /* Also ignore empty environment variables. */
1791 lpval
= env_vars
[i
].def_value
;
1792 dwType
= REG_EXPAND_SZ
;
1794 if (!strcmp (env_vars
[i
].name
, "HOME") && !appdata
)
1795 Vdelayed_warnings_list
1796 = Fcons (listn (CONSTYPE_HEAP
, 2,
1797 intern ("initialization"),
1798 build_string ("Setting HOME to C:\\ by default is deprecated")),
1799 Vdelayed_warnings_list
);
1804 char buf1
[SET_ENV_BUF_SIZE
], buf2
[SET_ENV_BUF_SIZE
];
1806 if (dwType
== REG_EXPAND_SZ
)
1807 ExpandEnvironmentStrings ((LPSTR
) lpval
, buf1
, sizeof (buf1
));
1808 else if (dwType
== REG_SZ
)
1809 strcpy (buf1
, lpval
);
1810 if (dwType
== REG_EXPAND_SZ
|| dwType
== REG_SZ
)
1812 _snprintf (buf2
, sizeof (buf2
)-1, "%s=%s", env_vars
[i
].name
,
1814 _putenv (strdup (buf2
));
1824 /* Rebuild system configuration to reflect invoking system. */
1825 Vsystem_configuration
= build_string (EMACS_CONFIGURATION
);
1827 /* Another special case: on NT, the PATH variable is actually named
1828 "Path" although cmd.exe (perhaps NT itself) arranges for
1829 environment variable lookup and setting to be case insensitive.
1830 However, Emacs assumes a fully case sensitive environment, so we
1831 need to change "Path" to "PATH" to match the expectations of
1832 various elisp packages. We do this by the sneaky method of
1833 modifying the string in the C runtime environ entry.
1835 The same applies to COMSPEC. */
1839 for (envp
= environ
; *envp
; envp
++)
1840 if (_strnicmp (*envp
, "PATH=", 5) == 0)
1841 memcpy (*envp
, "PATH=", 5);
1842 else if (_strnicmp (*envp
, "COMSPEC=", 8) == 0)
1843 memcpy (*envp
, "COMSPEC=", 8);
1846 /* Remember the initial working directory for getcwd. */
1847 /* FIXME: Do we need to resolve possible symlinks in startup_dir?
1848 Does it matter anywhere in Emacs? */
1849 if (!GetCurrentDirectory (MAXPATHLEN
, startup_dir
))
1853 static char modname
[MAX_PATH
];
1855 if (!GetModuleFileName (NULL
, modname
, MAX_PATH
))
1860 /* Determine if there is a middle mouse button, to allow parse_button
1861 to decide whether right mouse events should be mouse-2 or
1863 w32_num_mouse_buttons
= GetSystemMetrics (SM_CMOUSEBUTTONS
);
1868 /* Called from expand-file-name when default-directory is not a string. */
1871 emacs_root_dir (void)
1873 static char root_dir
[FILENAME_MAX
];
1876 p
= getenv ("emacs_dir");
1879 strcpy (root_dir
, p
);
1880 root_dir
[parse_root (root_dir
, NULL
)] = '\0';
1881 dostounix_filename (root_dir
);
1885 /* We don't have scripts to automatically determine the system configuration
1886 for Emacs before it's compiled, and we don't want to have to make the
1887 user enter it, so we define EMACS_CONFIGURATION to invoke this runtime
1891 get_emacs_configuration (void)
1893 char *arch
, *oem
, *os
;
1895 static char configuration_buffer
[32];
1897 /* Determine the processor type. */
1898 switch (get_processor_type ())
1901 #ifdef PROCESSOR_INTEL_386
1902 case PROCESSOR_INTEL_386
:
1903 case PROCESSOR_INTEL_486
:
1904 case PROCESSOR_INTEL_PENTIUM
:
1912 #ifdef PROCESSOR_AMD_X8664
1913 case PROCESSOR_AMD_X8664
:
1918 #ifdef PROCESSOR_MIPS_R2000
1919 case PROCESSOR_MIPS_R2000
:
1920 case PROCESSOR_MIPS_R3000
:
1921 case PROCESSOR_MIPS_R4000
:
1926 #ifdef PROCESSOR_ALPHA_21064
1927 case PROCESSOR_ALPHA_21064
:
1937 /* Use the OEM field to reflect the compiler/library combination. */
1939 #define COMPILER_NAME "msvc"
1942 #define COMPILER_NAME "mingw"
1944 #define COMPILER_NAME "unknown"
1947 oem
= COMPILER_NAME
;
1949 switch (osinfo_cache
.dwPlatformId
) {
1950 case VER_PLATFORM_WIN32_NT
:
1952 build_num
= osinfo_cache
.dwBuildNumber
;
1954 case VER_PLATFORM_WIN32_WINDOWS
:
1955 if (osinfo_cache
.dwMinorVersion
== 0) {
1960 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1962 case VER_PLATFORM_WIN32s
:
1963 /* Not supported, should not happen. */
1965 build_num
= LOWORD (osinfo_cache
.dwBuildNumber
);
1973 if (osinfo_cache
.dwPlatformId
== VER_PLATFORM_WIN32_NT
) {
1974 sprintf (configuration_buffer
, "%s-%s-%s%d.%d.%d", arch
, oem
, os
,
1975 get_w32_major_version (), get_w32_minor_version (), build_num
);
1977 sprintf (configuration_buffer
, "%s-%s-%s.%d", arch
, oem
, os
, build_num
);
1980 return configuration_buffer
;
1984 get_emacs_configuration_options (void)
1986 static char *options_buffer
;
1987 char cv
[32]; /* Enough for COMPILER_VERSION. */
1989 cv
, /* To be filled later. */
1993 #ifdef ENABLE_CHECKING
1994 " --enable-checking",
1996 /* configure.bat already sets USER_CFLAGS and USER_LDFLAGS
1997 with a starting space to save work here. */
1999 " --cflags", USER_CFLAGS
,
2002 " --ldflags", USER_LDFLAGS
,
2009 /* Work out the effective configure options for this build. */
2011 #define COMPILER_VERSION "--with-msvc (%d.%02d)", _MSC_VER / 100, _MSC_VER % 100
2014 #define COMPILER_VERSION "--with-gcc (%d.%d)", __GNUC__, __GNUC_MINOR__
2016 #define COMPILER_VERSION ""
2020 if (_snprintf (cv
, sizeof (cv
) - 1, COMPILER_VERSION
) < 0)
2021 return "Error: not enough space for compiler version";
2022 cv
[sizeof (cv
) - 1] = '\0';
2024 for (i
= 0; options
[i
]; i
++)
2025 size
+= strlen (options
[i
]);
2027 options_buffer
= xmalloc (size
+ 1);
2028 options_buffer
[0] = '\0';
2030 for (i
= 0; options
[i
]; i
++)
2031 strcat (options_buffer
, options
[i
]);
2033 return options_buffer
;
2037 #include <sys/timeb.h>
2039 /* Emulate gettimeofday (Ulrich Leodolter, 1/11/95). */
2041 gettimeofday (struct timeval
*tv
, struct timezone
*tz
)
2046 tv
->tv_sec
= tb
.time
;
2047 tv
->tv_usec
= tb
.millitm
* 1000L;
2048 /* Implementation note: _ftime sometimes doesn't update the dstflag
2049 according to the new timezone when the system timezone is
2050 changed. We could fix that by using GetSystemTime and
2051 GetTimeZoneInformation, but that doesn't seem necessary, since
2052 Emacs always calls gettimeofday with the 2nd argument NULL (see
2053 current_emacs_time). */
2056 tz
->tz_minuteswest
= tb
.timezone
; /* minutes west of Greenwich */
2057 tz
->tz_dsttime
= tb
.dstflag
; /* type of dst correction */
2061 /* Emulate fdutimens. */
2063 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
2064 TIMESPEC[0] and TIMESPEC[1], respectively.
2065 FD must be either negative -- in which case it is ignored --
2066 or a file descriptor that is open on FILE.
2067 If FD is nonnegative, then FILE can be NULL, which means
2068 use just futimes instead of utimes.
2069 If TIMESPEC is null, FAIL.
2070 Return 0 on success, -1 (setting errno) on failure. */
2073 fdutimens (int fd
, char const *file
, struct timespec
const timespec
[2])
2082 if (fd
< 0 && !file
)
2087 ut
.actime
= timespec
[0].tv_sec
;
2088 ut
.modtime
= timespec
[1].tv_sec
;
2090 return _futime (fd
, &ut
);
2092 return _utime (file
, &ut
);
2096 /* ------------------------------------------------------------------------- */
2097 /* IO support and wrapper functions for the Windows API. */
2098 /* ------------------------------------------------------------------------- */
2100 /* Place a wrapper around the MSVC version of ctime. It returns NULL
2101 on network directories, so we handle that case here.
2102 (Ulrich Leodolter, 1/11/95). */
2104 sys_ctime (const time_t *t
)
2106 char *str
= (char *) ctime (t
);
2107 return (str
? str
: "Sun Jan 01 00:00:00 1970");
2110 /* Emulate sleep...we could have done this with a define, but that
2111 would necessitate including windows.h in the files that used it.
2112 This is much easier. */
2114 sys_sleep (int seconds
)
2116 Sleep (seconds
* 1000);
2119 /* Internal MSVC functions for low-level descriptor munging */
2120 extern int __cdecl
_set_osfhnd (int fd
, long h
);
2121 extern int __cdecl
_free_osfhnd (int fd
);
2123 /* parallel array of private info on file handles */
2124 filedesc fd_info
[ MAXDESC
];
2126 typedef struct volume_info_data
{
2127 struct volume_info_data
* next
;
2129 /* time when info was obtained */
2132 /* actual volume info */
2141 /* Global referenced by various functions. */
2142 static volume_info_data volume_info
;
2144 /* Vector to indicate which drives are local and fixed (for which cached
2145 data never expires). */
2146 static BOOL fixed_drives
[26];
2148 /* Consider cached volume information to be stale if older than 10s,
2149 at least for non-local drives. Info for fixed drives is never stale. */
2150 #define DRIVE_INDEX( c ) ( (c) <= 'Z' ? (c) - 'A' : (c) - 'a' )
2151 #define VOLINFO_STILL_VALID( root_dir, info ) \
2152 ( ( isalpha (root_dir[0]) && \
2153 fixed_drives[ DRIVE_INDEX (root_dir[0]) ] ) \
2154 || GetTickCount () - info->timestamp < 10000 )
2156 /* Cache support functions. */
2158 /* Simple linked list with linear search is sufficient. */
2159 static volume_info_data
*volume_cache
= NULL
;
2161 static volume_info_data
*
2162 lookup_volume_info (char * root_dir
)
2164 volume_info_data
* info
;
2166 for (info
= volume_cache
; info
; info
= info
->next
)
2167 if (xstrcasecmp (info
->root_dir
, root_dir
) == 0)
2173 add_volume_info (char * root_dir
, volume_info_data
* info
)
2175 info
->root_dir
= xstrdup (root_dir
);
2176 info
->next
= volume_cache
;
2177 volume_cache
= info
;
2181 /* Wrapper for GetVolumeInformation, which uses caching to avoid
2182 performance penalty (~2ms on 486 for local drives, 7.5ms for local
2183 cdrom drive, ~5-10ms or more for remote drives on LAN). */
2184 static volume_info_data
*
2185 GetCachedVolumeInformation (char * root_dir
)
2187 volume_info_data
* info
;
2188 char default_root
[ MAX_PATH
];
2190 /* NULL for root_dir means use root from current directory. */
2191 if (root_dir
== NULL
)
2193 if (GetCurrentDirectory (MAX_PATH
, default_root
) == 0)
2195 parse_root (default_root
, &root_dir
);
2197 root_dir
= default_root
;
2200 /* Local fixed drives can be cached permanently. Removable drives
2201 cannot be cached permanently, since the volume name and serial
2202 number (if nothing else) can change. Remote drives should be
2203 treated as if they are removable, since there is no sure way to
2204 tell whether they are or not. Also, the UNC association of drive
2205 letters mapped to remote volumes can be changed at any time (even
2206 by other processes) without notice.
2208 As a compromise, so we can benefit from caching info for remote
2209 volumes, we use a simple expiry mechanism to invalidate cache
2210 entries that are more than ten seconds old. */
2213 /* No point doing this, because WNetGetConnection is even slower than
2214 GetVolumeInformation, consistently taking ~50ms on a 486 (FWIW,
2215 GetDriveType is about the only call of this type which does not
2216 involve network access, and so is extremely quick). */
2218 /* Map drive letter to UNC if remote. */
2219 if (isalpha (root_dir
[0]) && !fixed
[DRIVE_INDEX (root_dir
[0])])
2221 char remote_name
[ 256 ];
2222 char drive
[3] = { root_dir
[0], ':' };
2224 if (WNetGetConnection (drive
, remote_name
, sizeof (remote_name
))
2226 /* do something */ ;
2230 info
= lookup_volume_info (root_dir
);
2232 if (info
== NULL
|| ! VOLINFO_STILL_VALID (root_dir
, info
))
2240 /* Info is not cached, or is stale. */
2241 if (!GetVolumeInformation (root_dir
,
2242 name
, sizeof (name
),
2246 type
, sizeof (type
)))
2249 /* Cache the volume information for future use, overwriting existing
2250 entry if present. */
2253 info
= xmalloc (sizeof (volume_info_data
));
2254 add_volume_info (root_dir
, info
);
2262 info
->name
= xstrdup (name
);
2263 info
->serialnum
= serialnum
;
2264 info
->maxcomp
= maxcomp
;
2265 info
->flags
= flags
;
2266 info
->type
= xstrdup (type
);
2267 info
->timestamp
= GetTickCount ();
2273 /* Get information on the volume where NAME is held; set path pointer to
2274 start of pathname in NAME (past UNC header\volume header if present),
2275 if pPath is non-NULL.
2277 Note: if NAME includes symlinks, the information is for the volume
2278 of the symlink, not of its target. That's because, even though
2279 GetVolumeInformation returns information about the symlink target
2280 of its argument, we only pass the root directory to
2281 GetVolumeInformation, not the full NAME. */
2283 get_volume_info (const char * name
, const char ** pPath
)
2285 char temp
[MAX_PATH
];
2286 char *rootname
= NULL
; /* default to current volume */
2287 volume_info_data
* info
;
2292 /* Find the root name of the volume if given. */
2293 if (isalpha (name
[0]) && name
[1] == ':')
2301 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
2308 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
2321 info
= GetCachedVolumeInformation (rootname
);
2324 /* Set global referenced by other functions. */
2325 volume_info
= *info
;
2331 /* Determine if volume is FAT format (ie. only supports short 8.3
2332 names); also set path pointer to start of pathname in name, if
2333 pPath is non-NULL. */
2335 is_fat_volume (const char * name
, const char ** pPath
)
2337 if (get_volume_info (name
, pPath
))
2338 return (volume_info
.maxcomp
== 12);
2342 /* Map filename to a valid 8.3 name if necessary.
2343 The result is a pointer to a static buffer, so CAVEAT EMPTOR! */
2345 map_w32_filename (const char * name
, const char ** pPath
)
2347 static char shortname
[MAX_PATH
];
2348 char * str
= shortname
;
2351 const char * save_name
= name
;
2353 if (strlen (name
) >= MAX_PATH
)
2355 /* Return a filename which will cause callers to fail. */
2356 strcpy (shortname
, "?");
2360 if (is_fat_volume (name
, (const char **)&path
)) /* truncate to 8.3 */
2362 register int left
= 8; /* maximum number of chars in part */
2363 register int extn
= 0; /* extension added? */
2364 register int dots
= 2; /* maximum number of dots allowed */
2367 *str
++ = *name
++; /* skip past UNC header */
2369 while ((c
= *name
++))
2376 *str
++ = (c
== ':' ? ':' : '\\');
2377 extn
= 0; /* reset extension flags */
2378 dots
= 2; /* max 2 dots */
2379 left
= 8; /* max length 8 for main part */
2384 /* Convert path components of the form .xxx to _xxx,
2385 but leave . and .. as they are. This allows .emacs
2386 to be read as _emacs, for example. */
2390 IS_DIRECTORY_SEP (*name
))
2405 extn
= 1; /* we've got an extension */
2406 left
= 3; /* 3 chars in extension */
2410 /* any embedded dots after the first are converted to _ */
2415 case '#': /* don't lose these, they're important */
2417 str
[-1] = c
; /* replace last character of part */
2422 *str
++ = tolower (c
); /* map to lower case (looks nicer) */
2424 dots
= 0; /* started a path component */
2433 strcpy (shortname
, name
);
2434 unixtodos_filename (shortname
);
2438 *pPath
= shortname
+ (path
- save_name
);
2444 is_exec (const char * name
)
2446 char * p
= strrchr (name
, '.');
2449 && (xstrcasecmp (p
, ".exe") == 0 ||
2450 xstrcasecmp (p
, ".com") == 0 ||
2451 xstrcasecmp (p
, ".bat") == 0 ||
2452 xstrcasecmp (p
, ".cmd") == 0));
2455 /* Emulate the Unix directory procedures opendir, closedir,
2456 and readdir. We can't use the procedures supplied in sysdep.c,
2457 so we provide them here. */
2459 struct dirent dir_static
; /* simulated directory contents */
2460 static HANDLE dir_find_handle
= INVALID_HANDLE_VALUE
;
2461 static int dir_is_fat
;
2462 static char dir_pathname
[MAXPATHLEN
+1];
2463 static WIN32_FIND_DATA dir_find_data
;
2465 /* Support shares on a network resource as subdirectories of a read-only
2467 static HANDLE wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2468 static HANDLE
open_unc_volume (const char *);
2469 static char *read_unc_volume (HANDLE
, char *, int);
2470 static void close_unc_volume (HANDLE
);
2473 opendir (char *filename
)
2477 /* Opening is done by FindFirstFile. However, a read is inherent to
2478 this operation, so we defer the open until read time. */
2480 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2482 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2485 /* Note: We don't support traversal of UNC volumes via symlinks.
2486 Doing so would mean punishing 99.99% of use cases by resolving
2487 all the possible symlinks in FILENAME, recursively. */
2488 if (is_unc_volume (filename
))
2490 wnet_enum_handle
= open_unc_volume (filename
);
2491 if (wnet_enum_handle
== INVALID_HANDLE_VALUE
)
2495 if (!(dirp
= (DIR *) malloc (sizeof (DIR))))
2502 strncpy (dir_pathname
, map_w32_filename (filename
, NULL
), MAXPATHLEN
);
2503 dir_pathname
[MAXPATHLEN
] = '\0';
2504 /* Note: We don't support symlinks to file names on FAT volumes.
2505 Doing so would mean punishing 99.99% of use cases by resolving
2506 all the possible symlinks in FILENAME, recursively. */
2507 dir_is_fat
= is_fat_volume (filename
, NULL
);
2513 closedir (DIR *dirp
)
2515 /* If we have a find-handle open, close it. */
2516 if (dir_find_handle
!= INVALID_HANDLE_VALUE
)
2518 FindClose (dir_find_handle
);
2519 dir_find_handle
= INVALID_HANDLE_VALUE
;
2521 else if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2523 close_unc_volume (wnet_enum_handle
);
2524 wnet_enum_handle
= INVALID_HANDLE_VALUE
;
2526 xfree ((char *) dirp
);
2532 int downcase
= !NILP (Vw32_downcase_file_names
);
2534 if (wnet_enum_handle
!= INVALID_HANDLE_VALUE
)
2536 if (!read_unc_volume (wnet_enum_handle
,
2537 dir_find_data
.cFileName
,
2541 /* If we aren't dir_finding, do a find-first, otherwise do a find-next. */
2542 else if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2544 char filename
[MAXNAMLEN
+ 3];
2547 strcpy (filename
, dir_pathname
);
2548 ln
= strlen (filename
) - 1;
2549 if (!IS_DIRECTORY_SEP (filename
[ln
]))
2550 strcat (filename
, "\\");
2551 strcat (filename
, "*");
2553 /* Note: No need to resolve symlinks in FILENAME, because
2554 FindFirst opens the directory that is the target of a
2556 dir_find_handle
= FindFirstFile (filename
, &dir_find_data
);
2558 if (dir_find_handle
== INVALID_HANDLE_VALUE
)
2563 if (!FindNextFile (dir_find_handle
, &dir_find_data
))
2567 /* Emacs never uses this value, so don't bother making it match
2568 value returned by stat(). */
2569 dir_static
.d_ino
= 1;
2571 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2573 /* If the file name in cFileName[] includes `?' characters, it means
2574 the original file name used characters that cannot be represented
2575 by the current ANSI codepage. To avoid total lossage, retrieve
2576 the short 8+3 alias of the long file name. */
2577 if (_mbspbrk (dir_static
.d_name
, "?"))
2579 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2580 downcase
= 1; /* 8+3 aliases are returned in all caps */
2582 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2583 dir_static
.d_reclen
= sizeof (struct dirent
) - MAXNAMLEN
+ 3 +
2584 dir_static
.d_namlen
- dir_static
.d_namlen
% 4;
2586 /* If the file name in cFileName[] includes `?' characters, it means
2587 the original file name used characters that cannot be represented
2588 by the current ANSI codepage. To avoid total lossage, retrieve
2589 the short 8+3 alias of the long file name. */
2590 if (_mbspbrk (dir_find_data
.cFileName
, "?"))
2592 strcpy (dir_static
.d_name
, dir_find_data
.cAlternateFileName
);
2593 /* 8+3 aliases are returned in all caps, which could break
2594 various alists that look at filenames' extensions. */
2598 strcpy (dir_static
.d_name
, dir_find_data
.cFileName
);
2599 dir_static
.d_namlen
= strlen (dir_static
.d_name
);
2601 _strlwr (dir_static
.d_name
);
2605 for (p
= dir_static
.d_name
; *p
; p
++)
2606 if (*p
>= 'a' && *p
<= 'z')
2609 _strlwr (dir_static
.d_name
);
2616 open_unc_volume (const char *path
)
2622 nr
.dwScope
= RESOURCE_GLOBALNET
;
2623 nr
.dwType
= RESOURCETYPE_DISK
;
2624 nr
.dwDisplayType
= RESOURCEDISPLAYTYPE_SERVER
;
2625 nr
.dwUsage
= RESOURCEUSAGE_CONTAINER
;
2626 nr
.lpLocalName
= NULL
;
2627 nr
.lpRemoteName
= (LPSTR
)map_w32_filename (path
, NULL
);
2628 nr
.lpComment
= NULL
;
2629 nr
.lpProvider
= NULL
;
2631 result
= WNetOpenEnum (RESOURCE_GLOBALNET
, RESOURCETYPE_DISK
,
2632 RESOURCEUSAGE_CONNECTABLE
, &nr
, &henum
);
2634 if (result
== NO_ERROR
)
2637 return INVALID_HANDLE_VALUE
;
2641 read_unc_volume (HANDLE henum
, char *readbuf
, int size
)
2645 DWORD bufsize
= 512;
2650 buffer
= alloca (bufsize
);
2651 result
= WNetEnumResource (henum
, &count
, buffer
, &bufsize
);
2652 if (result
!= NO_ERROR
)
2655 /* WNetEnumResource returns \\resource\share...skip forward to "share". */
2656 ptr
= ((LPNETRESOURCE
) buffer
)->lpRemoteName
;
2658 while (*ptr
&& !IS_DIRECTORY_SEP (*ptr
)) ptr
++;
2661 strncpy (readbuf
, ptr
, size
);
2666 close_unc_volume (HANDLE henum
)
2668 if (henum
!= INVALID_HANDLE_VALUE
)
2669 WNetCloseEnum (henum
);
2673 unc_volume_file_attributes (const char *path
)
2678 henum
= open_unc_volume (path
);
2679 if (henum
== INVALID_HANDLE_VALUE
)
2682 attrs
= FILE_ATTRIBUTE_READONLY
| FILE_ATTRIBUTE_DIRECTORY
;
2684 close_unc_volume (henum
);
2689 /* Ensure a network connection is authenticated. */
2691 logon_network_drive (const char *path
)
2693 NETRESOURCE resource
;
2694 char share
[MAX_PATH
];
2699 if (IS_DIRECTORY_SEP (path
[0]) && IS_DIRECTORY_SEP (path
[1]))
2700 drvtype
= DRIVE_REMOTE
;
2701 else if (path
[0] == '\0' || path
[1] != ':')
2702 drvtype
= GetDriveType (NULL
);
2709 drvtype
= GetDriveType (drive
);
2712 /* Only logon to networked drives. */
2713 if (drvtype
!= DRIVE_REMOTE
)
2717 strncpy (share
, path
, MAX_PATH
);
2718 /* Truncate to just server and share name. */
2719 for (i
= 2; i
< MAX_PATH
; i
++)
2721 if (IS_DIRECTORY_SEP (share
[i
]) && ++n_slashes
> 3)
2728 resource
.dwType
= RESOURCETYPE_DISK
;
2729 resource
.lpLocalName
= NULL
;
2730 resource
.lpRemoteName
= share
;
2731 resource
.lpProvider
= NULL
;
2733 WNetAddConnection2 (&resource
, NULL
, NULL
, CONNECT_INTERACTIVE
);
2736 /* Emulate faccessat(2). */
2738 faccessat (int dirfd
, const char * path
, int mode
, int flags
)
2742 if (dirfd
!= AT_FDCWD
2743 && !(IS_DIRECTORY_SEP (path
[0])
2744 || IS_DEVICE_SEP (path
[1])))
2750 /* MSVCRT implementation of 'access' doesn't recognize D_OK, and its
2751 newer versions blow up when passed D_OK. */
2752 path
= map_w32_filename (path
, NULL
);
2753 /* If the last element of PATH is a symlink, we need to resolve it
2754 to get the attributes of its target file. Note: any symlinks in
2755 PATH elements other than the last one are transparently resolved
2756 by GetFileAttributes below. */
2757 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0
2758 && (flags
& AT_SYMLINK_NOFOLLOW
) == 0)
2759 path
= chase_symlinks (path
);
2761 if ((attributes
= GetFileAttributes (path
)) == -1)
2763 DWORD w32err
= GetLastError ();
2767 case ERROR_INVALID_NAME
:
2768 case ERROR_BAD_PATHNAME
:
2769 if (is_unc_volume (path
))
2771 attributes
= unc_volume_file_attributes (path
);
2772 if (attributes
== -1)
2780 case ERROR_FILE_NOT_FOUND
:
2781 case ERROR_BAD_NETPATH
:
2790 if ((mode
& X_OK
) != 0
2791 && !(is_exec (path
) || (attributes
& FILE_ATTRIBUTE_DIRECTORY
) != 0))
2796 if ((mode
& W_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_READONLY
) != 0)
2801 if ((mode
& D_OK
) != 0 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
) == 0)
2809 /* Shadow some MSVC runtime functions to map requests for long filenames
2810 to reasonable short names if necessary. This was originally added to
2811 permit running Emacs on NT 3.1 on a FAT partition, which doesn't support
2815 sys_chdir (const char * path
)
2817 return _chdir (map_w32_filename (path
, NULL
));
2821 sys_chmod (const char * path
, int mode
)
2823 path
= chase_symlinks (map_w32_filename (path
, NULL
));
2824 return _chmod (path
, mode
);
2828 sys_chown (const char *path
, uid_t owner
, gid_t group
)
2830 if (sys_chmod (path
, S_IREAD
) == -1) /* check if file exists */
2836 sys_creat (const char * path
, int mode
)
2838 return _creat (map_w32_filename (path
, NULL
), mode
);
2842 sys_fopen (const char * path
, const char * mode
)
2846 const char * mode_save
= mode
;
2848 /* Force all file handles to be non-inheritable. This is necessary to
2849 ensure child processes don't unwittingly inherit handles that might
2850 prevent future file access. */
2854 else if (mode
[0] == 'w' || mode
[0] == 'a')
2855 oflag
= O_WRONLY
| O_CREAT
| O_TRUNC
;
2859 /* Only do simplistic option parsing. */
2863 oflag
&= ~(O_RDONLY
| O_WRONLY
);
2866 else if (mode
[0] == 'b')
2871 else if (mode
[0] == 't')
2878 fd
= _open (map_w32_filename (path
, NULL
), oflag
| _O_NOINHERIT
, 0644);
2882 return _fdopen (fd
, mode_save
);
2885 /* This only works on NTFS volumes, but is useful to have. */
2887 sys_link (const char * old
, const char * new)
2891 char oldname
[MAX_PATH
], newname
[MAX_PATH
];
2893 if (old
== NULL
|| new == NULL
)
2899 strcpy (oldname
, map_w32_filename (old
, NULL
));
2900 strcpy (newname
, map_w32_filename (new, NULL
));
2902 fileh
= CreateFile (oldname
, 0, 0, NULL
, OPEN_EXISTING
,
2903 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2904 if (fileh
!= INVALID_HANDLE_VALUE
)
2908 /* Confusingly, the "alternate" stream name field does not apply
2909 when restoring a hard link, and instead contains the actual
2910 stream data for the link (ie. the name of the link to create).
2911 The WIN32_STREAM_ID structure before the cStreamName field is
2912 the stream header, which is then immediately followed by the
2916 WIN32_STREAM_ID wid
;
2917 WCHAR wbuffer
[MAX_PATH
]; /* extra space for link name */
2920 wlen
= MultiByteToWideChar (CP_ACP
, MB_PRECOMPOSED
, newname
, -1,
2921 data
.wid
.cStreamName
, MAX_PATH
);
2924 LPVOID context
= NULL
;
2927 data
.wid
.dwStreamId
= BACKUP_LINK
;
2928 data
.wid
.dwStreamAttributes
= 0;
2929 data
.wid
.Size
.LowPart
= wlen
* sizeof (WCHAR
);
2930 data
.wid
.Size
.HighPart
= 0;
2931 data
.wid
.dwStreamNameSize
= 0;
2933 if (BackupWrite (fileh
, (LPBYTE
)&data
,
2934 offsetof (WIN32_STREAM_ID
, cStreamName
)
2935 + data
.wid
.Size
.LowPart
,
2936 &wbytes
, FALSE
, FALSE
, &context
)
2937 && BackupWrite (fileh
, NULL
, 0, &wbytes
, TRUE
, FALSE
, &context
))
2944 /* Should try mapping GetLastError to errno; for now just
2945 indicate a general error (eg. links not supported). */
2946 errno
= EINVAL
; // perhaps EMLINK?
2950 CloseHandle (fileh
);
2959 sys_mkdir (const char * path
)
2961 return _mkdir (map_w32_filename (path
, NULL
));
2964 /* Because of long name mapping issues, we need to implement this
2965 ourselves. Also, MSVC's _mktemp returns NULL when it can't generate
2966 a unique name, instead of setting the input template to an empty
2969 Standard algorithm seems to be use pid or tid with a letter on the
2970 front (in place of the 6 X's) and cycle through the letters to find a
2971 unique name. We extend that to allow any reasonable character as the
2972 first of the 6 X's. */
2974 sys_mktemp (char * template)
2978 unsigned uid
= GetCurrentThreadId ();
2979 static char first_char
[] = "abcdefghijklmnopqrstuvwyz0123456789!%-_@#";
2981 if (template == NULL
)
2983 p
= template + strlen (template);
2985 /* replace up to the last 5 X's with uid in decimal */
2986 while (--p
>= template && p
[0] == 'X' && --i
>= 0)
2988 p
[0] = '0' + uid
% 10;
2992 if (i
< 0 && p
[0] == 'X')
2997 int save_errno
= errno
;
2998 p
[0] = first_char
[i
];
2999 if (faccessat (AT_FDCWD
, template, F_OK
, AT_EACCESS
) < 0)
3005 while (++i
< sizeof (first_char
));
3008 /* Template is badly formed or else we can't generate a unique name,
3009 so return empty string */
3015 sys_open (const char * path
, int oflag
, int mode
)
3017 const char* mpath
= map_w32_filename (path
, NULL
);
3018 /* Try to open file without _O_CREAT, to be able to write to hidden
3019 and system files. Force all file handles to be
3021 int res
= _open (mpath
, (oflag
& ~_O_CREAT
) | _O_NOINHERIT
, mode
);
3024 return _open (mpath
, oflag
| _O_NOINHERIT
, mode
);
3028 sys_rename (const char * oldname
, const char * newname
)
3031 char temp
[MAX_PATH
];
3035 /* MoveFile on Windows 95 doesn't correctly change the short file name
3036 alias in a number of circumstances (it is not easy to predict when
3037 just by looking at oldname and newname, unfortunately). In these
3038 cases, renaming through a temporary name avoids the problem.
3040 A second problem on Windows 95 is that renaming through a temp name when
3041 newname is uppercase fails (the final long name ends up in
3042 lowercase, although the short alias might be uppercase) UNLESS the
3043 long temp name is not 8.3.
3045 So, on Windows 95 we always rename through a temp name, and we make sure
3046 the temp name has a long extension to ensure correct renaming. */
3048 strcpy (temp
, map_w32_filename (oldname
, NULL
));
3050 /* volume_info is set indirectly by map_w32_filename. */
3051 oldname_dev
= volume_info
.serialnum
;
3053 if (os_subtype
== OS_9X
)
3059 oldname
= map_w32_filename (oldname
, NULL
);
3060 if ((o
= strrchr (oldname
, '\\')))
3063 o
= (char *) oldname
;
3065 if ((p
= strrchr (temp
, '\\')))
3072 /* Force temp name to require a manufactured 8.3 alias - this
3073 seems to make the second rename work properly. */
3074 sprintf (p
, "_.%s.%u", o
, i
);
3076 result
= rename (oldname
, temp
);
3078 /* This loop must surely terminate! */
3079 while (result
< 0 && errno
== EEXIST
);
3084 /* Emulate Unix behavior - newname is deleted if it already exists
3085 (at least if it is a file; don't do this for directories).
3087 Since we mustn't do this if we are just changing the case of the
3088 file name (we would end up deleting the file we are trying to
3089 rename!), we let rename detect if the destination file already
3090 exists - that way we avoid the possible pitfalls of trying to
3091 determine ourselves whether two names really refer to the same
3092 file, which is not always possible in the general case. (Consider
3093 all the permutations of shared or subst'd drives, etc.) */
3095 newname
= map_w32_filename (newname
, NULL
);
3097 /* volume_info is set indirectly by map_w32_filename. */
3098 newname_dev
= volume_info
.serialnum
;
3100 result
= rename (temp
, newname
);
3104 DWORD w32err
= GetLastError ();
3107 && newname_dev
!= oldname_dev
)
3109 /* The implementation of `rename' on Windows does not return
3110 errno = EXDEV when you are moving a directory to a
3111 different storage device (ex. logical disk). It returns
3112 EACCES instead. So here we handle such situations and
3116 if ((attributes
= GetFileAttributes (temp
)) != -1
3117 && (attributes
& FILE_ATTRIBUTE_DIRECTORY
))
3120 else if (errno
== EEXIST
)
3122 if (_chmod (newname
, 0666) != 0)
3124 if (_unlink (newname
) != 0)
3126 result
= rename (temp
, newname
);
3128 else if (w32err
== ERROR_PRIVILEGE_NOT_HELD
3129 && is_symlink (temp
))
3131 /* This is Windows prohibiting the user from creating a
3132 symlink in another place, since that requires
3142 sys_rmdir (const char * path
)
3144 return _rmdir (map_w32_filename (path
, NULL
));
3148 sys_unlink (const char * path
)
3150 path
= map_w32_filename (path
, NULL
);
3152 /* On Unix, unlink works without write permission. */
3153 _chmod (path
, 0666);
3154 return _unlink (path
);
3157 static FILETIME utc_base_ft
;
3158 static ULONGLONG utc_base
; /* In 100ns units */
3159 static int init
= 0;
3161 #define FILETIME_TO_U64(result, ft) \
3163 ULARGE_INTEGER uiTemp; \
3164 uiTemp.LowPart = (ft).dwLowDateTime; \
3165 uiTemp.HighPart = (ft).dwHighDateTime; \
3166 result = uiTemp.QuadPart; \
3170 initialize_utc_base (void)
3172 /* Determine the delta between 1-Jan-1601 and 1-Jan-1970. */
3181 st
.wMilliseconds
= 0;
3183 SystemTimeToFileTime (&st
, &utc_base_ft
);
3184 FILETIME_TO_U64 (utc_base
, utc_base_ft
);
3188 convert_time (FILETIME ft
)
3194 initialize_utc_base ();
3198 if (CompareFileTime (&ft
, &utc_base_ft
) < 0)
3201 FILETIME_TO_U64 (tmp
, ft
);
3202 return (time_t) ((tmp
- utc_base
) / 10000000L);
3206 convert_from_time_t (time_t time
, FILETIME
* pft
)
3212 initialize_utc_base ();
3216 /* time in 100ns units since 1-Jan-1601 */
3217 tmp
.QuadPart
= (ULONGLONG
) time
* 10000000L + utc_base
;
3218 pft
->dwHighDateTime
= tmp
.HighPart
;
3219 pft
->dwLowDateTime
= tmp
.LowPart
;
3223 /* No reason to keep this; faking inode values either by hashing or even
3224 using the file index from GetInformationByHandle, is not perfect and
3225 so by default Emacs doesn't use the inode values on Windows.
3226 Instead, we now determine file-truename correctly (except for
3227 possible drive aliasing etc). */
3229 /* Modified version of "PJW" algorithm (see the "Dragon" compiler book). */
3231 hashval (const unsigned char * str
)
3236 h
= (h
<< 4) + *str
++;
3242 /* Return the hash value of the canonical pathname, excluding the
3243 drive/UNC header, to get a hopefully unique inode number. */
3245 generate_inode_val (const char * name
)
3247 char fullname
[ MAX_PATH
];
3251 /* Get the truly canonical filename, if it exists. (Note: this
3252 doesn't resolve aliasing due to subst commands, or recognize hard
3254 if (!w32_get_long_filename ((char *)name
, fullname
, MAX_PATH
))
3257 parse_root (fullname
, &p
);
3258 /* Normal W32 filesystems are still case insensitive. */
3265 static PSECURITY_DESCRIPTOR
3266 get_file_security_desc_by_handle (HANDLE h
)
3268 PSECURITY_DESCRIPTOR psd
= NULL
;
3270 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3271 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3273 err
= get_security_info (h
, SE_FILE_OBJECT
, si
,
3274 NULL
, NULL
, NULL
, NULL
, &psd
);
3275 if (err
!= ERROR_SUCCESS
)
3281 static PSECURITY_DESCRIPTOR
3282 get_file_security_desc_by_name (const char *fname
)
3284 PSECURITY_DESCRIPTOR psd
= NULL
;
3286 SECURITY_INFORMATION si
= OWNER_SECURITY_INFORMATION
3287 | GROUP_SECURITY_INFORMATION
/* | DACL_SECURITY_INFORMATION */ ;
3289 if (!get_file_security (fname
, si
, psd
, 0, &sd_len
))
3291 err
= GetLastError ();
3292 if (err
!= ERROR_INSUFFICIENT_BUFFER
)
3296 psd
= xmalloc (sd_len
);
3297 if (!get_file_security (fname
, si
, psd
, sd_len
, &sd_len
))
3309 unsigned n_subauthorities
;
3311 /* Use the last sub-authority value of the RID, the relative
3312 portion of the SID, as user/group ID. */
3313 n_subauthorities
= *get_sid_sub_authority_count (sid
);
3314 if (n_subauthorities
< 1)
3315 return 0; /* the "World" RID */
3316 return *get_sid_sub_authority (sid
, n_subauthorities
- 1);
3319 /* Caching SID and account values for faster lokup. */
3322 # define FLEXIBLE_ARRAY_MEMBER
3324 # define FLEXIBLE_ARRAY_MEMBER 1
3329 struct w32_id
*next
;
3331 unsigned char sid
[FLEXIBLE_ARRAY_MEMBER
];
3334 static struct w32_id
*w32_idlist
;
3337 w32_cached_id (PSID sid
, unsigned *id
, char *name
)
3339 struct w32_id
*tail
, *found
;
3341 for (found
= NULL
, tail
= w32_idlist
; tail
; tail
= tail
->next
)
3343 if (equal_sid ((PSID
)tail
->sid
, sid
))
3352 strcpy (name
, found
->name
);
3360 w32_add_to_cache (PSID sid
, unsigned id
, char *name
)
3363 struct w32_id
*new_entry
;
3365 /* We don't want to leave behind stale cache from when Emacs was
3369 sid_len
= get_length_sid (sid
);
3370 new_entry
= xmalloc (offsetof (struct w32_id
, sid
) + sid_len
);
3373 new_entry
->rid
= id
;
3374 strcpy (new_entry
->name
, name
);
3375 copy_sid (sid_len
, (PSID
)new_entry
->sid
, sid
);
3376 new_entry
->next
= w32_idlist
;
3377 w32_idlist
= new_entry
;
3386 get_name_and_id (PSECURITY_DESCRIPTOR psd
, const char *fname
,
3387 unsigned *id
, char *nm
, int what
)
3390 char machine
[MAX_COMPUTERNAME_LENGTH
+1];
3392 SID_NAME_USE ignore
;
3394 DWORD name_len
= sizeof (name
);
3396 DWORD domain_len
= sizeof (domain
);
3402 result
= get_security_descriptor_owner (psd
, &sid
, &dflt
);
3403 else if (what
== GID
)
3404 result
= get_security_descriptor_group (psd
, &sid
, &dflt
);
3408 if (!result
|| !is_valid_sid (sid
))
3410 else if (!w32_cached_id (sid
, id
, nm
))
3412 /* If FNAME is a UNC, we need to lookup account on the
3413 specified machine. */
3414 if (IS_DIRECTORY_SEP (fname
[0]) && IS_DIRECTORY_SEP (fname
[1])
3415 && fname
[2] != '\0')
3420 for (s
= fname
+ 2, p
= machine
;
3421 *s
&& !IS_DIRECTORY_SEP (*s
); s
++, p
++)
3427 if (!lookup_account_sid (mp
, sid
, name
, &name_len
,
3428 domain
, &domain_len
, &ignore
)
3429 || name_len
> UNLEN
+1)
3433 *id
= get_rid (sid
);
3435 w32_add_to_cache (sid
, *id
, name
);
3442 get_file_owner_and_group (PSECURITY_DESCRIPTOR psd
,
3446 int dflt_usr
= 0, dflt_grp
= 0;
3455 if (get_name_and_id (psd
, fname
, &st
->st_uid
, st
->st_uname
, UID
))
3457 if (get_name_and_id (psd
, fname
, &st
->st_gid
, st
->st_gname
, GID
))
3460 /* Consider files to belong to current user/group, if we cannot get
3461 more accurate information. */
3464 st
->st_uid
= dflt_passwd
.pw_uid
;
3465 strcpy (st
->st_uname
, dflt_passwd
.pw_name
);
3469 st
->st_gid
= dflt_passwd
.pw_gid
;
3470 strcpy (st
->st_gname
, dflt_group
.gr_name
);
3474 /* Return non-zero if NAME is a potentially slow filesystem. */
3476 is_slow_fs (const char *name
)
3481 if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
3482 devtype
= DRIVE_REMOTE
; /* assume UNC name is remote */
3483 else if (!(strlen (name
) >= 2 && IS_DEVICE_SEP (name
[1])))
3484 devtype
= GetDriveType (NULL
); /* use root of current drive */
3487 /* GetDriveType needs the root directory of the drive. */
3488 strncpy (drive_root
, name
, 2);
3489 drive_root
[2] = '\\';
3490 drive_root
[3] = '\0';
3491 devtype
= GetDriveType (drive_root
);
3493 return !(devtype
== DRIVE_FIXED
|| devtype
== DRIVE_RAMDISK
);
3496 /* MSVC stat function can't cope with UNC names and has other bugs, so
3497 replace it with our own. This also allows us to calculate consistent
3498 inode values and owner/group without hacks in the main Emacs code. */
3501 stat_worker (const char * path
, struct stat
* buf
, int follow_symlinks
)
3503 char *name
, *save_name
, *r
;
3504 WIN32_FIND_DATA wfd
;
3506 unsigned __int64 fake_inode
= 0;
3509 int rootdir
= FALSE
;
3510 PSECURITY_DESCRIPTOR psd
= NULL
;
3511 int is_a_symlink
= 0;
3512 DWORD file_flags
= FILE_FLAG_BACKUP_SEMANTICS
;
3513 DWORD access_rights
= 0;
3514 DWORD fattrs
= 0, serialnum
= 0, fs_high
= 0, fs_low
= 0, nlinks
= 1;
3515 FILETIME ctime
, atime
, wtime
;
3517 if (path
== NULL
|| buf
== NULL
)
3523 save_name
= name
= (char *) map_w32_filename (path
, &path
);
3524 /* Must be valid filename, no wild cards or other invalid
3525 characters. We use _mbspbrk to support multibyte strings that
3526 might look to strpbrk as if they included literal *, ?, and other
3527 characters mentioned below that are disallowed by Windows
3529 if (_mbspbrk (name
, "*?|<>\""))
3535 /* Remove trailing directory separator, unless name is the root
3536 directory of a drive or UNC volume in which case ensure there
3537 is a trailing separator. */
3538 len
= strlen (name
);
3539 name
= strcpy (alloca (len
+ 2), name
);
3541 /* Avoid a somewhat costly call to is_symlink if the filesystem
3542 doesn't support symlinks. */
3543 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) != 0)
3544 is_a_symlink
= is_symlink (name
);
3546 /* Plan A: Open the file and get all the necessary information via
3547 the resulting handle. This solves several issues in one blow:
3549 . retrieves attributes for the target of a symlink, if needed
3550 . gets attributes of root directories and symlinks pointing to
3551 root directories, thus avoiding the need for special-casing
3552 these and detecting them by examining the file-name format
3553 . retrieves more accurate attributes (e.g., non-zero size for
3554 some directories, esp. directories that are junction points)
3555 . correctly resolves "c:/..", "/.." and similar file names
3556 . avoids run-time penalties for 99% of use cases
3558 Plan A is always tried first, unless the user asked not to (but
3559 if the file is a symlink and we need to follow links, we try Plan
3560 A even if the user asked not to).
3562 If Plan A fails, we go to Plan B (below), where various
3563 potentially expensive techniques must be used to handle "special"
3564 files such as UNC volumes etc. */
3565 if (!(NILP (Vw32_get_true_file_attributes
)
3566 || (EQ (Vw32_get_true_file_attributes
, Qlocal
) && is_slow_fs (name
)))
3567 /* Following symlinks requires getting the info by handle. */
3568 || (is_a_symlink
&& follow_symlinks
))
3570 BY_HANDLE_FILE_INFORMATION info
;
3572 if (is_a_symlink
&& !follow_symlinks
)
3573 file_flags
|= FILE_FLAG_OPEN_REPARSE_POINT
;
3574 /* READ_CONTROL access rights are required to get security info
3575 by handle. But if the OS doesn't support security in the
3576 first place, we don't need to try. */
3577 if (is_windows_9x () != TRUE
)
3578 access_rights
|= READ_CONTROL
;
3580 fh
= CreateFile (name
, access_rights
, 0, NULL
, OPEN_EXISTING
,
3582 /* If CreateFile fails with READ_CONTROL, try again with zero as
3584 if (fh
== INVALID_HANDLE_VALUE
&& access_rights
)
3585 fh
= CreateFile (name
, 0, 0, NULL
, OPEN_EXISTING
,
3587 if (fh
== INVALID_HANDLE_VALUE
)
3588 goto no_true_file_attributes
;
3590 /* This is more accurate in terms of getting the correct number
3591 of links, but is quite slow (it is noticeable when Emacs is
3592 making a list of file name completions). */
3593 if (GetFileInformationByHandle (fh
, &info
))
3595 nlinks
= info
.nNumberOfLinks
;
3596 /* Might as well use file index to fake inode values, but this
3597 is not guaranteed to be unique unless we keep a handle open
3598 all the time (even then there are situations where it is
3599 not unique). Reputedly, there are at most 48 bits of info
3600 (on NTFS, presumably less on FAT). */
3601 fake_inode
= info
.nFileIndexHigh
;
3603 fake_inode
+= info
.nFileIndexLow
;
3604 serialnum
= info
.dwVolumeSerialNumber
;
3605 fs_high
= info
.nFileSizeHigh
;
3606 fs_low
= info
.nFileSizeLow
;
3607 ctime
= info
.ftCreationTime
;
3608 atime
= info
.ftLastAccessTime
;
3609 wtime
= info
.ftLastWriteTime
;
3610 fattrs
= info
.dwFileAttributes
;
3614 /* We don't go to Plan B here, because it's not clear that
3615 it's a good idea. The only known use case where
3616 CreateFile succeeds, but GetFileInformationByHandle fails
3617 (with ERROR_INVALID_FUNCTION) is for character devices
3618 such as NUL, PRN, etc. For these, switching to Plan B is
3619 a net loss, because we lose the character device
3620 attribute returned by GetFileType below (FindFirstFile
3621 doesn't set that bit in the attributes), and the other
3622 fields don't make sense for character devices anyway.
3623 Emacs doesn't really care for non-file entities in the
3624 context of l?stat, so neither do we. */
3626 /* w32err is assigned so one could put a breakpoint here and
3627 examine its value, when GetFileInformationByHandle
3629 DWORD w32err
= GetLastError ();
3633 case ERROR_FILE_NOT_FOUND
: /* can this ever happen? */
3639 /* Test for a symlink before testing for a directory, since
3640 symlinks to directories have the directory bit set, but we
3641 don't want them to appear as directories. */
3642 if (is_a_symlink
&& !follow_symlinks
)
3643 buf
->st_mode
= S_IFLNK
;
3644 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3645 buf
->st_mode
= S_IFDIR
;
3648 DWORD ftype
= GetFileType (fh
);
3652 case FILE_TYPE_DISK
:
3653 buf
->st_mode
= S_IFREG
;
3655 case FILE_TYPE_PIPE
:
3656 buf
->st_mode
= S_IFIFO
;
3658 case FILE_TYPE_CHAR
:
3659 case FILE_TYPE_UNKNOWN
:
3661 buf
->st_mode
= S_IFCHR
;
3664 /* We produce the fallback owner and group data, based on the
3665 current user that runs Emacs, in the following cases:
3667 . this is Windows 9X
3668 . getting security by handle failed, and we need to produce
3669 information for the target of a symlink (this is better
3670 than producing a potentially misleading info about the
3673 If getting security by handle fails, and we don't need to
3674 resolve symlinks, we try getting security by name. */
3675 if (is_windows_9x () != TRUE
)
3676 psd
= get_file_security_desc_by_handle (fh
);
3679 get_file_owner_and_group (psd
, name
, buf
);
3682 else if (is_windows_9x () == TRUE
)
3683 get_file_owner_and_group (NULL
, name
, buf
);
3684 else if (!(is_a_symlink
&& follow_symlinks
))
3686 psd
= get_file_security_desc_by_name (name
);
3687 get_file_owner_and_group (psd
, name
, buf
);
3691 get_file_owner_and_group (NULL
, name
, buf
);
3696 no_true_file_attributes
:
3697 /* Plan B: Either getting a handle on the file failed, or the
3698 caller explicitly asked us to not bother making this
3699 information more accurate.
3701 Implementation note: In Plan B, we never bother to resolve
3702 symlinks, even if we got here because we tried Plan A and
3703 failed. That's because, even if the caller asked for extra
3704 precision by setting Vw32_get_true_file_attributes to t,
3705 resolving symlinks requires acquiring a file handle to the
3706 symlink, which we already know will fail. And if the user
3707 did not ask for extra precision, resolving symlinks will fly
3708 in the face of that request, since the user then wants the
3709 lightweight version of the code. */
3710 rootdir
= (path
>= save_name
+ len
- 1
3711 && (IS_DIRECTORY_SEP (*path
) || *path
== 0));
3713 /* If name is "c:/.." or "/.." then stat "c:/" or "/". */
3714 r
= IS_DEVICE_SEP (name
[1]) ? &name
[2] : name
;
3715 if (IS_DIRECTORY_SEP (r
[0])
3716 && r
[1] == '.' && r
[2] == '.' && r
[3] == '\0')
3719 /* Note: If NAME is a symlink to the root of a UNC volume
3720 (i.e. "\\SERVER"), we will not detect that here, and we will
3721 return data about the symlink as result of FindFirst below.
3722 This is unfortunate, but that marginal use case does not
3723 justify a call to chase_symlinks which would impose a penalty
3724 on all the other use cases. (We get here for symlinks to
3725 roots of UNC volumes because CreateFile above fails for them,
3726 unlike with symlinks to root directories X:\ of drives.) */
3727 if (is_unc_volume (name
))
3729 fattrs
= unc_volume_file_attributes (name
);
3733 ctime
= atime
= wtime
= utc_base_ft
;
3737 if (!IS_DIRECTORY_SEP (name
[len
-1]))
3738 strcat (name
, "\\");
3739 if (GetDriveType (name
) < 2)
3745 fattrs
= FILE_ATTRIBUTE_DIRECTORY
;
3746 ctime
= atime
= wtime
= utc_base_ft
;
3750 if (IS_DIRECTORY_SEP (name
[len
-1]))
3753 /* (This is hacky, but helps when doing file completions on
3754 network drives.) Optimize by using information available from
3755 active readdir if possible. */
3756 len
= strlen (dir_pathname
);
3757 if (IS_DIRECTORY_SEP (dir_pathname
[len
-1]))
3759 if (dir_find_handle
!= INVALID_HANDLE_VALUE
3760 && !(is_a_symlink
&& follow_symlinks
)
3761 && strnicmp (save_name
, dir_pathname
, len
) == 0
3762 && IS_DIRECTORY_SEP (name
[len
])
3763 && xstrcasecmp (name
+ len
+ 1, dir_static
.d_name
) == 0)
3765 /* This was the last entry returned by readdir. */
3766 wfd
= dir_find_data
;
3770 logon_network_drive (name
);
3772 fh
= FindFirstFile (name
, &wfd
);
3773 if (fh
== INVALID_HANDLE_VALUE
)
3780 /* Note: if NAME is a symlink, the information we get from
3781 FindFirstFile is for the symlink, not its target. */
3782 fattrs
= wfd
.dwFileAttributes
;
3783 ctime
= wfd
.ftCreationTime
;
3784 atime
= wfd
.ftLastAccessTime
;
3785 wtime
= wfd
.ftLastWriteTime
;
3786 fs_high
= wfd
.nFileSizeHigh
;
3787 fs_low
= wfd
.nFileSizeLow
;
3790 serialnum
= volume_info
.serialnum
;
3792 if (is_a_symlink
&& !follow_symlinks
)
3793 buf
->st_mode
= S_IFLNK
;
3794 else if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3795 buf
->st_mode
= S_IFDIR
;
3797 buf
->st_mode
= S_IFREG
;
3799 get_file_owner_and_group (NULL
, name
, buf
);
3803 /* Not sure if there is any point in this. */
3804 if (!NILP (Vw32_generate_fake_inodes
))
3805 fake_inode
= generate_inode_val (name
);
3806 else if (fake_inode
== 0)
3808 /* For want of something better, try to make everything unique. */
3809 static DWORD gen_num
= 0;
3810 fake_inode
= ++gen_num
;
3814 buf
->st_ino
= fake_inode
;
3816 buf
->st_dev
= serialnum
;
3817 buf
->st_rdev
= serialnum
;
3819 buf
->st_size
= fs_high
;
3820 buf
->st_size
<<= 32;
3821 buf
->st_size
+= fs_low
;
3822 buf
->st_nlink
= nlinks
;
3824 /* Convert timestamps to Unix format. */
3825 buf
->st_mtime
= convert_time (wtime
);
3826 buf
->st_atime
= convert_time (atime
);
3827 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3828 buf
->st_ctime
= convert_time (ctime
);
3829 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3831 /* determine rwx permissions */
3832 if (is_a_symlink
&& !follow_symlinks
)
3833 permission
= S_IREAD
| S_IWRITE
| S_IEXEC
; /* Posix expectations */
3836 if (fattrs
& FILE_ATTRIBUTE_READONLY
)
3837 permission
= S_IREAD
;
3839 permission
= S_IREAD
| S_IWRITE
;
3841 if (fattrs
& FILE_ATTRIBUTE_DIRECTORY
)
3842 permission
|= S_IEXEC
;
3843 else if (is_exec (name
))
3844 permission
|= S_IEXEC
;
3847 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3853 stat (const char * path
, struct stat
* buf
)
3855 return stat_worker (path
, buf
, 1);
3859 lstat (const char * path
, struct stat
* buf
)
3861 return stat_worker (path
, buf
, 0);
3864 /* Provide fstat and utime as well as stat for consistent handling of
3867 fstat (int desc
, struct stat
* buf
)
3869 HANDLE fh
= (HANDLE
) _get_osfhandle (desc
);
3870 BY_HANDLE_FILE_INFORMATION info
;
3871 unsigned __int64 fake_inode
;
3874 switch (GetFileType (fh
) & ~FILE_TYPE_REMOTE
)
3876 case FILE_TYPE_DISK
:
3877 buf
->st_mode
= S_IFREG
;
3878 if (!GetFileInformationByHandle (fh
, &info
))
3884 case FILE_TYPE_PIPE
:
3885 buf
->st_mode
= S_IFIFO
;
3887 case FILE_TYPE_CHAR
:
3888 case FILE_TYPE_UNKNOWN
:
3890 buf
->st_mode
= S_IFCHR
;
3892 memset (&info
, 0, sizeof (info
));
3893 info
.dwFileAttributes
= 0;
3894 info
.ftCreationTime
= utc_base_ft
;
3895 info
.ftLastAccessTime
= utc_base_ft
;
3896 info
.ftLastWriteTime
= utc_base_ft
;
3899 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3900 buf
->st_mode
= S_IFDIR
;
3902 buf
->st_nlink
= info
.nNumberOfLinks
;
3903 /* Might as well use file index to fake inode values, but this
3904 is not guaranteed to be unique unless we keep a handle open
3905 all the time (even then there are situations where it is
3906 not unique). Reputedly, there are at most 48 bits of info
3907 (on NTFS, presumably less on FAT). */
3908 fake_inode
= info
.nFileIndexHigh
;
3910 fake_inode
+= info
.nFileIndexLow
;
3912 /* MSVC defines _ino_t to be short; other libc's might not. */
3913 if (sizeof (buf
->st_ino
) == 2)
3914 buf
->st_ino
= fake_inode
^ (fake_inode
>> 16);
3916 buf
->st_ino
= fake_inode
;
3918 /* Consider files to belong to current user.
3919 FIXME: this should use GetSecurityInfo API, but it is only
3920 available for _WIN32_WINNT >= 0x501. */
3921 buf
->st_uid
= dflt_passwd
.pw_uid
;
3922 buf
->st_gid
= dflt_passwd
.pw_gid
;
3923 strcpy (buf
->st_uname
, dflt_passwd
.pw_name
);
3924 strcpy (buf
->st_gname
, dflt_group
.gr_name
);
3926 buf
->st_dev
= info
.dwVolumeSerialNumber
;
3927 buf
->st_rdev
= info
.dwVolumeSerialNumber
;
3929 buf
->st_size
= info
.nFileSizeHigh
;
3930 buf
->st_size
<<= 32;
3931 buf
->st_size
+= info
.nFileSizeLow
;
3933 /* Convert timestamps to Unix format. */
3934 buf
->st_mtime
= convert_time (info
.ftLastWriteTime
);
3935 buf
->st_atime
= convert_time (info
.ftLastAccessTime
);
3936 if (buf
->st_atime
== 0) buf
->st_atime
= buf
->st_mtime
;
3937 buf
->st_ctime
= convert_time (info
.ftCreationTime
);
3938 if (buf
->st_ctime
== 0) buf
->st_ctime
= buf
->st_mtime
;
3940 /* determine rwx permissions */
3941 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
)
3942 permission
= S_IREAD
;
3944 permission
= S_IREAD
| S_IWRITE
;
3946 if (info
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
3947 permission
|= S_IEXEC
;
3950 #if 0 /* no way of knowing the filename */
3951 char * p
= strrchr (name
, '.');
3953 (xstrcasecmp (p
, ".exe") == 0 ||
3954 xstrcasecmp (p
, ".com") == 0 ||
3955 xstrcasecmp (p
, ".bat") == 0 ||
3956 xstrcasecmp (p
, ".cmd") == 0))
3957 permission
|= S_IEXEC
;
3961 buf
->st_mode
|= permission
| (permission
>> 3) | (permission
>> 6);
3967 utime (const char *name
, struct utimbuf
*times
)
3969 struct utimbuf deftime
;
3976 deftime
.modtime
= deftime
.actime
= time (NULL
);
3980 /* Need write access to set times. */
3981 fh
= CreateFile (name
, FILE_WRITE_ATTRIBUTES
,
3982 /* If NAME specifies a directory, FILE_SHARE_DELETE
3983 allows other processes to delete files inside it,
3984 while we have the directory open. */
3985 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
3986 0, OPEN_EXISTING
, FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
3987 if (fh
!= INVALID_HANDLE_VALUE
)
3989 convert_from_time_t (times
->actime
, &atime
);
3990 convert_from_time_t (times
->modtime
, &mtime
);
3991 if (!SetFileTime (fh
, NULL
, &atime
, &mtime
))
4008 /* Symlink-related functions. */
4009 #ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
4010 #define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
4014 symlink (char const *filename
, char const *linkname
)
4016 char linkfn
[MAX_PATH
], *tgtfn
;
4018 int dir_access
, filename_ends_in_slash
;
4020 /* Diagnostics follows Posix as much as possible. */
4021 if (filename
== NULL
|| linkname
== NULL
)
4031 if (strlen (filename
) > MAX_PATH
|| strlen (linkname
) > MAX_PATH
)
4033 errno
= ENAMETOOLONG
;
4037 strcpy (linkfn
, map_w32_filename (linkname
, NULL
));
4038 if ((volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0)
4044 /* Note: since empty FILENAME was already rejected, we can safely
4045 refer to FILENAME[1]. */
4046 if (!(IS_DIRECTORY_SEP (filename
[0]) || IS_DEVICE_SEP (filename
[1])))
4048 /* Non-absolute FILENAME is understood as being relative to
4049 LINKNAME's directory. We need to prepend that directory to
4050 FILENAME to get correct results from faccessat below, since
4051 otherwise it will interpret FILENAME relative to the
4052 directory where the Emacs process runs. Note that
4053 make-symbolic-link always makes sure LINKNAME is a fully
4054 expanded file name. */
4056 char *p
= linkfn
+ strlen (linkfn
);
4058 while (p
> linkfn
&& !IS_ANY_SEP (p
[-1]))
4061 strncpy (tem
, linkfn
, p
- linkfn
);
4062 tem
[p
- linkfn
] = '\0';
4063 strcat (tem
, filename
);
4064 dir_access
= faccessat (AT_FDCWD
, tem
, D_OK
, AT_EACCESS
);
4067 dir_access
= faccessat (AT_FDCWD
, filename
, D_OK
, AT_EACCESS
);
4069 /* Since Windows distinguishes between symlinks to directories and
4070 to files, we provide a kludgy feature: if FILENAME doesn't
4071 exist, but ends in a slash, we create a symlink to directory. If
4072 FILENAME exists and is a directory, we always create a symlink to
4074 filename_ends_in_slash
= IS_DIRECTORY_SEP (filename
[strlen (filename
) - 1]);
4075 if (dir_access
== 0 || filename_ends_in_slash
)
4076 flags
= SYMBOLIC_LINK_FLAG_DIRECTORY
;
4078 tgtfn
= (char *)map_w32_filename (filename
, NULL
);
4079 if (filename_ends_in_slash
)
4080 tgtfn
[strlen (tgtfn
) - 1] = '\0';
4083 if (!create_symbolic_link (linkfn
, tgtfn
, flags
))
4085 /* ENOSYS is set by create_symbolic_link, when it detects that
4086 the OS doesn't support the CreateSymbolicLink API. */
4087 if (errno
!= ENOSYS
)
4089 DWORD w32err
= GetLastError ();
4093 /* ERROR_SUCCESS is sometimes returned when LINKFN and
4094 TGTFN point to the same file name, go figure. */
4096 case ERROR_FILE_EXISTS
:
4099 case ERROR_ACCESS_DENIED
:
4102 case ERROR_FILE_NOT_FOUND
:
4103 case ERROR_PATH_NOT_FOUND
:
4104 case ERROR_BAD_NETPATH
:
4105 case ERROR_INVALID_REPARSE_DATA
:
4108 case ERROR_DIRECTORY
:
4111 case ERROR_PRIVILEGE_NOT_HELD
:
4112 case ERROR_NOT_ALL_ASSIGNED
:
4115 case ERROR_DISK_FULL
:
4128 /* A quick inexpensive test of whether FILENAME identifies a file that
4129 is a symlink. Returns non-zero if it is, zero otherwise. FILENAME
4130 must already be in the normalized form returned by
4133 Note: for repeated operations on many files, it is best to test
4134 whether the underlying volume actually supports symlinks, by
4135 testing the FILE_SUPPORTS_REPARSE_POINTS bit in volume's flags, and
4136 avoid the call to this function if it doesn't. That's because the
4137 call to GetFileAttributes takes a non-negligible time, especially
4138 on non-local or removable filesystems. See stat_worker for an
4139 example of how to do that. */
4141 is_symlink (const char *filename
)
4144 WIN32_FIND_DATA wfd
;
4147 attrs
= GetFileAttributes (filename
);
4150 DWORD w32err
= GetLastError ();
4154 case ERROR_BAD_NETPATH
: /* network share, can't be a symlink */
4156 case ERROR_ACCESS_DENIED
:
4159 case ERROR_FILE_NOT_FOUND
:
4160 case ERROR_PATH_NOT_FOUND
:
4167 if ((attrs
& FILE_ATTRIBUTE_REPARSE_POINT
) == 0)
4169 logon_network_drive (filename
);
4170 fh
= FindFirstFile (filename
, &wfd
);
4171 if (fh
== INVALID_HANDLE_VALUE
)
4174 return (wfd
.dwFileAttributes
& FILE_ATTRIBUTE_REPARSE_POINT
) != 0
4175 && (wfd
.dwReserved0
& IO_REPARSE_TAG_SYMLINK
) == IO_REPARSE_TAG_SYMLINK
;
4178 /* If NAME identifies a symbolic link, copy into BUF the file name of
4179 the symlink's target. Copy at most BUF_SIZE bytes, and do NOT
4180 null-terminate the target name, even if it fits. Return the number
4181 of bytes copied, or -1 if NAME is not a symlink or any error was
4182 encountered while resolving it. The file name copied into BUF is
4183 encoded in the current ANSI codepage. */
4185 readlink (const char *name
, char *buf
, size_t buf_size
)
4188 TOKEN_PRIVILEGES privs
;
4189 int restore_privs
= 0;
4204 path
= map_w32_filename (name
, NULL
);
4206 if (strlen (path
) > MAX_PATH
)
4208 errno
= ENAMETOOLONG
;
4213 if (is_windows_9x () == TRUE
4214 || (volume_info
.flags
& FILE_SUPPORTS_REPARSE_POINTS
) == 0
4215 || !is_symlink (path
))
4218 errno
= EINVAL
; /* not a symlink */
4222 /* Done with simple tests, now we're in for some _real_ work. */
4223 if (enable_privilege (SE_BACKUP_NAME
, TRUE
, &privs
))
4225 /* Implementation note: From here and onward, don't return early,
4226 since that will fail to restore the original set of privileges of
4227 the calling thread. */
4229 retval
= -1; /* not too optimistic, are we? */
4231 /* Note: In the next call to CreateFile, we use zero as the 2nd
4232 argument because, when the symlink is a hidden/system file,
4233 e.g. 'C:\Users\All Users', GENERIC_READ fails with
4234 ERROR_ACCESS_DENIED. Zero seems to work just fine, both for file
4235 and directory symlinks. */
4236 sh
= CreateFile (path
, 0, 0, NULL
, OPEN_EXISTING
,
4237 FILE_FLAG_OPEN_REPARSE_POINT
| FILE_FLAG_BACKUP_SEMANTICS
,
4239 if (sh
!= INVALID_HANDLE_VALUE
)
4241 BYTE reparse_buf
[MAXIMUM_REPARSE_DATA_BUFFER_SIZE
];
4242 REPARSE_DATA_BUFFER
*reparse_data
= (REPARSE_DATA_BUFFER
*)&reparse_buf
[0];
4245 if (!DeviceIoControl (sh
, FSCTL_GET_REPARSE_POINT
, NULL
, 0,
4246 reparse_buf
, MAXIMUM_REPARSE_DATA_BUFFER_SIZE
,
4249 else if (reparse_data
->ReparseTag
!= IO_REPARSE_TAG_SYMLINK
)
4253 /* Copy the link target name, in wide characters, fro
4254 reparse_data, then convert it to multibyte encoding in
4255 the current locale's codepage. */
4257 BYTE lname
[MAX_PATH
];
4260 reparse_data
->SymbolicLinkReparseBuffer
.PrintNameLength
;
4262 reparse_data
->SymbolicLinkReparseBuffer
.PathBuffer
4263 + reparse_data
->SymbolicLinkReparseBuffer
.PrintNameOffset
/sizeof(WCHAR
);
4265 /* According to MSDN, PrintNameLength does not include the
4266 terminating null character. */
4267 lwname
= alloca ((lwname_len
+ 1) * sizeof(WCHAR
));
4268 memcpy (lwname
, lwname_src
, lwname_len
);
4269 lwname
[lwname_len
/sizeof(WCHAR
)] = 0; /* null-terminate */
4271 /* FIXME: Should we use the current file-name coding system
4272 instead of the fixed value of the ANSI codepage? */
4273 lname_len
= WideCharToMultiByte (w32_ansi_code_page
, 0, lwname
, -1,
4274 lname
, MAX_PATH
, NULL
, NULL
);
4277 /* WideCharToMultiByte failed. */
4278 DWORD w32err1
= GetLastError ();
4282 case ERROR_INSUFFICIENT_BUFFER
:
4283 errno
= ENAMETOOLONG
;
4285 case ERROR_INVALID_PARAMETER
:
4288 case ERROR_NO_UNICODE_TRANSLATION
:
4298 size_t size_to_copy
= buf_size
;
4300 BYTE
*pend
= p
+ lname_len
;
4302 /* Normalize like dostounix_filename does, but we don't
4303 want to assume that lname is null-terminated. */
4304 if (*p
&& p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4312 /* Testing for null-terminated LNAME is paranoia:
4313 WideCharToMultiByte should always return a
4314 null-terminated string when its 4th argument is -1
4315 and its 3rd argument is null-terminated (which they
4317 if (lname
[lname_len
- 1] == '\0')
4319 if (lname_len
<= buf_size
)
4320 size_to_copy
= lname_len
;
4321 strncpy (buf
, lname
, size_to_copy
);
4323 retval
= size_to_copy
;
4330 /* CreateFile failed. */
4331 DWORD w32err2
= GetLastError ();
4335 case ERROR_FILE_NOT_FOUND
:
4336 case ERROR_PATH_NOT_FOUND
:
4339 case ERROR_ACCESS_DENIED
:
4340 case ERROR_TOO_MANY_OPEN_FILES
:
4350 restore_privilege (&privs
);
4357 /* If FILE is a symlink, return its target (stored in a static
4358 buffer); otherwise return FILE.
4360 This function repeatedly resolves symlinks in the last component of
4361 a chain of symlink file names, as in foo -> bar -> baz -> ...,
4362 until it arrives at a file whose last component is not a symlink,
4363 or some error occurs. It returns the target of the last
4364 successfully resolved symlink in the chain. If it succeeds to
4365 resolve even a single symlink, the value returned is an absolute
4366 file name with backslashes (result of GetFullPathName). By
4367 contrast, if the original FILE is returned, it is unaltered.
4369 Note: This function can set errno even if it succeeds.
4371 Implementation note: we only resolve the last portion ("basename")
4372 of the argument FILE and of each following file in the chain,
4373 disregarding any possible symlinks in its leading directories.
4374 This is because Windows system calls and library functions
4375 transparently resolve symlinks in leading directories and return
4376 correct information, as long as the basename is not a symlink. */
4378 chase_symlinks (const char *file
)
4380 static char target
[MAX_PATH
];
4381 char link
[MAX_PATH
];
4382 ssize_t res
, link_len
;
4385 if (is_windows_9x () == TRUE
|| !is_symlink (file
))
4386 return (char *)file
;
4388 if ((link_len
= GetFullPathName (file
, MAX_PATH
, link
, NULL
)) == 0)
4389 return (char *)file
;
4394 /* Remove trailing slashes, as we want to resolve the last
4395 non-trivial part of the link name. */
4396 while (link_len
> 3 && IS_DIRECTORY_SEP (link
[link_len
-1]))
4397 link
[link_len
--] = '\0';
4399 res
= readlink (link
, target
, MAX_PATH
);
4403 if (!(IS_DEVICE_SEP (target
[1])
4404 || (IS_DIRECTORY_SEP (target
[0]) && IS_DIRECTORY_SEP (target
[1]))))
4406 /* Target is relative. Append it to the directory part of
4407 the symlink, then copy the result back to target. */
4408 char *p
= link
+ link_len
;
4410 while (p
> link
&& !IS_ANY_SEP (p
[-1]))
4413 strcpy (target
, link
);
4415 /* Resolve any "." and ".." to get a fully-qualified file name
4417 link_len
= GetFullPathName (target
, MAX_PATH
, link
, NULL
);
4419 } while (res
> 0 && link_len
> 0 && ++loop_count
<= 100);
4421 if (loop_count
> 100)
4424 if (target
[0] == '\0') /* not a single call to readlink succeeded */
4425 return (char *)file
;
4429 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c). We
4430 have a fixed max size for file names, so we don't need the kind of
4431 alloc/malloc/realloc dance the gnulib version does. We also don't
4432 support FD-relative symlinks. */
4434 careadlinkat (int fd
, char const *filename
,
4435 char *buffer
, size_t buffer_size
,
4436 struct allocator
const *alloc
,
4437 ssize_t (*preadlinkat
) (int, char const *, char *, size_t))
4439 char linkname
[MAX_PATH
];
4448 link_size
= preadlinkat (fd
, filename
, linkname
, sizeof(linkname
));
4452 char *retval
= buffer
;
4454 linkname
[link_size
++] = '\0';
4455 if (link_size
> buffer_size
)
4456 retval
= (char *)(alloc
? alloc
->allocate
: xmalloc
) (link_size
);
4458 memcpy (retval
, linkname
, link_size
);
4466 careadlinkatcwd (int fd
, char const *filename
, char *buffer
,
4470 return readlink (filename
, buffer
, buffer_size
);
4474 /* Support for browsing other processes and their attributes. See
4475 process.c for the Lisp bindings. */
4477 /* Helper wrapper functions. */
4479 static HANDLE WINAPI
4480 create_toolhelp32_snapshot (DWORD Flags
, DWORD Ignored
)
4482 static CreateToolhelp32Snapshot_Proc s_pfn_Create_Toolhelp32_Snapshot
= NULL
;
4484 if (g_b_init_create_toolhelp32_snapshot
== 0)
4486 g_b_init_create_toolhelp32_snapshot
= 1;
4487 s_pfn_Create_Toolhelp32_Snapshot
= (CreateToolhelp32Snapshot_Proc
)
4488 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4489 "CreateToolhelp32Snapshot");
4491 if (s_pfn_Create_Toolhelp32_Snapshot
== NULL
)
4493 return INVALID_HANDLE_VALUE
;
4495 return (s_pfn_Create_Toolhelp32_Snapshot (Flags
, Ignored
));
4499 process32_first (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4501 static Process32First_Proc s_pfn_Process32_First
= NULL
;
4503 if (g_b_init_process32_first
== 0)
4505 g_b_init_process32_first
= 1;
4506 s_pfn_Process32_First
= (Process32First_Proc
)
4507 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4510 if (s_pfn_Process32_First
== NULL
)
4514 return (s_pfn_Process32_First (hSnapshot
, lppe
));
4518 process32_next (HANDLE hSnapshot
, LPPROCESSENTRY32 lppe
)
4520 static Process32Next_Proc s_pfn_Process32_Next
= NULL
;
4522 if (g_b_init_process32_next
== 0)
4524 g_b_init_process32_next
= 1;
4525 s_pfn_Process32_Next
= (Process32Next_Proc
)
4526 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4529 if (s_pfn_Process32_Next
== NULL
)
4533 return (s_pfn_Process32_Next (hSnapshot
, lppe
));
4537 open_thread_token (HANDLE ThreadHandle
,
4538 DWORD DesiredAccess
,
4540 PHANDLE TokenHandle
)
4542 static OpenThreadToken_Proc s_pfn_Open_Thread_Token
= NULL
;
4543 HMODULE hm_advapi32
= NULL
;
4544 if (is_windows_9x () == TRUE
)
4546 SetLastError (ERROR_NOT_SUPPORTED
);
4549 if (g_b_init_open_thread_token
== 0)
4551 g_b_init_open_thread_token
= 1;
4552 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4553 s_pfn_Open_Thread_Token
=
4554 (OpenThreadToken_Proc
) GetProcAddress (hm_advapi32
, "OpenThreadToken");
4556 if (s_pfn_Open_Thread_Token
== NULL
)
4558 SetLastError (ERROR_NOT_SUPPORTED
);
4562 s_pfn_Open_Thread_Token (
4571 impersonate_self (SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
4573 static ImpersonateSelf_Proc s_pfn_Impersonate_Self
= NULL
;
4574 HMODULE hm_advapi32
= NULL
;
4575 if (is_windows_9x () == TRUE
)
4579 if (g_b_init_impersonate_self
== 0)
4581 g_b_init_impersonate_self
= 1;
4582 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4583 s_pfn_Impersonate_Self
=
4584 (ImpersonateSelf_Proc
) GetProcAddress (hm_advapi32
, "ImpersonateSelf");
4586 if (s_pfn_Impersonate_Self
== NULL
)
4590 return s_pfn_Impersonate_Self (ImpersonationLevel
);
4594 revert_to_self (void)
4596 static RevertToSelf_Proc s_pfn_Revert_To_Self
= NULL
;
4597 HMODULE hm_advapi32
= NULL
;
4598 if (is_windows_9x () == TRUE
)
4602 if (g_b_init_revert_to_self
== 0)
4604 g_b_init_revert_to_self
= 1;
4605 hm_advapi32
= LoadLibrary ("Advapi32.dll");
4606 s_pfn_Revert_To_Self
=
4607 (RevertToSelf_Proc
) GetProcAddress (hm_advapi32
, "RevertToSelf");
4609 if (s_pfn_Revert_To_Self
== NULL
)
4613 return s_pfn_Revert_To_Self ();
4617 get_process_memory_info (HANDLE h_proc
,
4618 PPROCESS_MEMORY_COUNTERS mem_counters
,
4621 static GetProcessMemoryInfo_Proc s_pfn_Get_Process_Memory_Info
= NULL
;
4622 HMODULE hm_psapi
= NULL
;
4623 if (is_windows_9x () == TRUE
)
4627 if (g_b_init_get_process_memory_info
== 0)
4629 g_b_init_get_process_memory_info
= 1;
4630 hm_psapi
= LoadLibrary ("Psapi.dll");
4632 s_pfn_Get_Process_Memory_Info
= (GetProcessMemoryInfo_Proc
)
4633 GetProcAddress (hm_psapi
, "GetProcessMemoryInfo");
4635 if (s_pfn_Get_Process_Memory_Info
== NULL
)
4639 return s_pfn_Get_Process_Memory_Info (h_proc
, mem_counters
, bufsize
);
4643 get_process_working_set_size (HANDLE h_proc
,
4647 static GetProcessWorkingSetSize_Proc
4648 s_pfn_Get_Process_Working_Set_Size
= NULL
;
4650 if (is_windows_9x () == TRUE
)
4654 if (g_b_init_get_process_working_set_size
== 0)
4656 g_b_init_get_process_working_set_size
= 1;
4657 s_pfn_Get_Process_Working_Set_Size
= (GetProcessWorkingSetSize_Proc
)
4658 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4659 "GetProcessWorkingSetSize");
4661 if (s_pfn_Get_Process_Working_Set_Size
== NULL
)
4665 return s_pfn_Get_Process_Working_Set_Size (h_proc
, minrss
, maxrss
);
4669 global_memory_status (MEMORYSTATUS
*buf
)
4671 static GlobalMemoryStatus_Proc s_pfn_Global_Memory_Status
= NULL
;
4673 if (is_windows_9x () == TRUE
)
4677 if (g_b_init_global_memory_status
== 0)
4679 g_b_init_global_memory_status
= 1;
4680 s_pfn_Global_Memory_Status
= (GlobalMemoryStatus_Proc
)
4681 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4682 "GlobalMemoryStatus");
4684 if (s_pfn_Global_Memory_Status
== NULL
)
4688 return s_pfn_Global_Memory_Status (buf
);
4692 global_memory_status_ex (MEMORY_STATUS_EX
*buf
)
4694 static GlobalMemoryStatusEx_Proc s_pfn_Global_Memory_Status_Ex
= NULL
;
4696 if (is_windows_9x () == TRUE
)
4700 if (g_b_init_global_memory_status_ex
== 0)
4702 g_b_init_global_memory_status_ex
= 1;
4703 s_pfn_Global_Memory_Status_Ex
= (GlobalMemoryStatusEx_Proc
)
4704 GetProcAddress (GetModuleHandle ("kernel32.dll"),
4705 "GlobalMemoryStatusEx");
4707 if (s_pfn_Global_Memory_Status_Ex
== NULL
)
4711 return s_pfn_Global_Memory_Status_Ex (buf
);
4715 list_system_processes (void)
4717 struct gcpro gcpro1
;
4718 Lisp_Object proclist
= Qnil
;
4721 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4723 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4725 PROCESSENTRY32 proc_entry
;
4731 proc_entry
.dwSize
= sizeof (PROCESSENTRY32
);
4732 for (res
= process32_first (h_snapshot
, &proc_entry
); res
;
4733 res
= process32_next (h_snapshot
, &proc_entry
))
4735 proc_id
= proc_entry
.th32ProcessID
;
4736 proclist
= Fcons (make_fixnum_or_float (proc_id
), proclist
);
4739 CloseHandle (h_snapshot
);
4741 proclist
= Fnreverse (proclist
);
4748 enable_privilege (LPCTSTR priv_name
, BOOL enable_p
, TOKEN_PRIVILEGES
*old_priv
)
4750 TOKEN_PRIVILEGES priv
;
4751 DWORD priv_size
= sizeof (priv
);
4752 DWORD opriv_size
= sizeof (*old_priv
);
4753 HANDLE h_token
= NULL
;
4754 HANDLE h_thread
= GetCurrentThread ();
4758 res
= open_thread_token (h_thread
,
4759 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4761 if (!res
&& GetLastError () == ERROR_NO_TOKEN
)
4763 if (impersonate_self (SecurityImpersonation
))
4764 res
= open_thread_token (h_thread
,
4765 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4770 priv
.PrivilegeCount
= 1;
4771 priv
.Privileges
[0].Attributes
= enable_p
? SE_PRIVILEGE_ENABLED
: 0;
4772 LookupPrivilegeValue (NULL
, priv_name
, &priv
.Privileges
[0].Luid
);
4773 if (AdjustTokenPrivileges (h_token
, FALSE
, &priv
, priv_size
,
4774 old_priv
, &opriv_size
)
4775 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4779 CloseHandle (h_token
);
4785 restore_privilege (TOKEN_PRIVILEGES
*priv
)
4787 DWORD priv_size
= sizeof (*priv
);
4788 HANDLE h_token
= NULL
;
4791 if (open_thread_token (GetCurrentThread (),
4792 TOKEN_QUERY
| TOKEN_ADJUST_PRIVILEGES
,
4795 if (AdjustTokenPrivileges (h_token
, FALSE
, priv
, priv_size
, NULL
, NULL
)
4796 && GetLastError () != ERROR_NOT_ALL_ASSIGNED
)
4800 CloseHandle (h_token
);
4806 ltime (ULONGLONG time_100ns
)
4808 ULONGLONG time_sec
= time_100ns
/ 10000000;
4809 int subsec
= time_100ns
% 10000000;
4810 return list4 (make_number (time_sec
>> 16),
4811 make_number (time_sec
& 0xffff),
4812 make_number (subsec
/ 10),
4813 make_number (subsec
% 10 * 100000));
4816 #define U64_TO_LISP_TIME(time) ltime (time)
4819 process_times (HANDLE h_proc
, Lisp_Object
*ctime
, Lisp_Object
*etime
,
4820 Lisp_Object
*stime
, Lisp_Object
*utime
, Lisp_Object
*ttime
,
4823 FILETIME ft_creation
, ft_exit
, ft_kernel
, ft_user
, ft_current
;
4824 ULONGLONG tem1
, tem2
, tem3
, tem
;
4827 || !get_process_times_fn
4828 || !(*get_process_times_fn
) (h_proc
, &ft_creation
, &ft_exit
,
4829 &ft_kernel
, &ft_user
))
4832 GetSystemTimeAsFileTime (&ft_current
);
4834 FILETIME_TO_U64 (tem1
, ft_kernel
);
4835 *stime
= U64_TO_LISP_TIME (tem1
);
4837 FILETIME_TO_U64 (tem2
, ft_user
);
4838 *utime
= U64_TO_LISP_TIME (tem2
);
4841 *ttime
= U64_TO_LISP_TIME (tem3
);
4843 FILETIME_TO_U64 (tem
, ft_creation
);
4844 /* Process no 4 (System) returns zero creation time. */
4847 *ctime
= U64_TO_LISP_TIME (tem
);
4851 FILETIME_TO_U64 (tem3
, ft_current
);
4852 tem
= (tem3
- utc_base
) - tem
;
4854 *etime
= U64_TO_LISP_TIME (tem
);
4858 *pcpu
= 100.0 * (tem1
+ tem2
) / tem
;
4869 system_process_attributes (Lisp_Object pid
)
4871 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4872 Lisp_Object attrs
= Qnil
;
4873 Lisp_Object cmd_str
, decoded_cmd
, tem
;
4874 HANDLE h_snapshot
, h_proc
;
4877 char uname
[UNLEN
+1], gname
[GNLEN
+1], domain
[1025];
4878 DWORD ulength
= sizeof (uname
), dlength
= sizeof (domain
), needed
;
4879 DWORD glength
= sizeof (gname
);
4880 HANDLE token
= NULL
;
4881 SID_NAME_USE user_type
;
4882 unsigned char *buf
= NULL
;
4884 TOKEN_USER user_token
;
4885 TOKEN_PRIMARY_GROUP group_token
;
4888 PROCESS_MEMORY_COUNTERS mem
;
4889 PROCESS_MEMORY_COUNTERS_EX mem_ex
;
4890 DWORD minrss
, maxrss
;
4892 MEMORY_STATUS_EX memstex
;
4893 double totphys
= 0.0;
4894 Lisp_Object ctime
, stime
, utime
, etime
, ttime
;
4896 BOOL result
= FALSE
;
4898 CHECK_NUMBER_OR_FLOAT (pid
);
4899 proc_id
= FLOATP (pid
) ? XFLOAT_DATA (pid
) : XINT (pid
);
4901 h_snapshot
= create_toolhelp32_snapshot (TH32CS_SNAPPROCESS
, 0);
4903 GCPRO3 (attrs
, decoded_cmd
, tem
);
4905 if (h_snapshot
!= INVALID_HANDLE_VALUE
)
4910 pe
.dwSize
= sizeof (PROCESSENTRY32
);
4911 for (res
= process32_first (h_snapshot
, &pe
); res
;
4912 res
= process32_next (h_snapshot
, &pe
))
4914 if (proc_id
== pe
.th32ProcessID
)
4917 decoded_cmd
= build_string ("Idle");
4920 /* Decode the command name from locale-specific
4922 cmd_str
= make_unibyte_string (pe
.szExeFile
,
4923 strlen (pe
.szExeFile
));
4925 code_convert_string_norecord (cmd_str
,
4926 Vlocale_coding_system
, 0);
4928 attrs
= Fcons (Fcons (Qcomm
, decoded_cmd
), attrs
);
4929 attrs
= Fcons (Fcons (Qppid
,
4930 make_fixnum_or_float (pe
.th32ParentProcessID
)),
4932 attrs
= Fcons (Fcons (Qpri
, make_number (pe
.pcPriClassBase
)),
4934 attrs
= Fcons (Fcons (Qthcount
,
4935 make_fixnum_or_float (pe
.cntThreads
)),
4942 CloseHandle (h_snapshot
);
4951 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4953 /* If we were denied a handle to the process, try again after
4954 enabling the SeDebugPrivilege in our process. */
4957 TOKEN_PRIVILEGES priv_current
;
4959 if (enable_privilege (SE_DEBUG_NAME
, TRUE
, &priv_current
))
4961 h_proc
= OpenProcess (PROCESS_QUERY_INFORMATION
| PROCESS_VM_READ
,
4963 restore_privilege (&priv_current
);
4969 result
= open_process_token (h_proc
, TOKEN_QUERY
, &token
);
4972 result
= get_token_information (token
, TokenUser
, NULL
, 0, &blen
);
4973 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
4975 buf
= xmalloc (blen
);
4976 result
= get_token_information (token
, TokenUser
,
4977 (LPVOID
)buf
, blen
, &needed
);
4980 memcpy (&user_token
, buf
, sizeof (user_token
));
4981 if (!w32_cached_id (user_token
.User
.Sid
, &euid
, uname
))
4983 euid
= get_rid (user_token
.User
.Sid
);
4984 result
= lookup_account_sid (NULL
, user_token
.User
.Sid
,
4989 w32_add_to_cache (user_token
.User
.Sid
, euid
, uname
);
4992 strcpy (uname
, "unknown");
4996 ulength
= strlen (uname
);
5002 /* Determine a reasonable euid and gid values. */
5003 if (xstrcasecmp ("administrator", uname
) == 0)
5005 euid
= 500; /* well-known Administrator uid */
5006 egid
= 513; /* well-known None gid */
5010 /* Get group id and name. */
5011 result
= get_token_information (token
, TokenPrimaryGroup
,
5012 (LPVOID
)buf
, blen
, &needed
);
5013 if (!result
&& GetLastError () == ERROR_INSUFFICIENT_BUFFER
)
5015 buf
= xrealloc (buf
, blen
= needed
);
5016 result
= get_token_information (token
, TokenPrimaryGroup
,
5017 (LPVOID
)buf
, blen
, &needed
);
5021 memcpy (&group_token
, buf
, sizeof (group_token
));
5022 if (!w32_cached_id (group_token
.PrimaryGroup
, &egid
, gname
))
5024 egid
= get_rid (group_token
.PrimaryGroup
);
5025 dlength
= sizeof (domain
);
5027 lookup_account_sid (NULL
, group_token
.PrimaryGroup
,
5028 gname
, &glength
, NULL
, &dlength
,
5031 w32_add_to_cache (group_token
.PrimaryGroup
,
5035 strcpy (gname
, "None");
5039 glength
= strlen (gname
);
5047 if (!is_windows_9x ())
5049 /* We couldn't open the process token, presumably because of
5050 insufficient access rights. Assume this process is run
5052 strcpy (uname
, "SYSTEM");
5053 strcpy (gname
, "None");
5054 euid
= 18; /* SYSTEM */
5055 egid
= 513; /* None */
5056 glength
= strlen (gname
);
5057 ulength
= strlen (uname
);
5059 /* If we are running under Windows 9X, where security calls are
5060 not supported, we assume all processes are run by the current
5062 else if (GetUserName (uname
, &ulength
))
5064 if (xstrcasecmp ("administrator", uname
) == 0)
5069 strcpy (gname
, "None");
5070 glength
= strlen (gname
);
5071 ulength
= strlen (uname
);
5077 strcpy (uname
, "administrator");
5078 ulength
= strlen (uname
);
5079 strcpy (gname
, "None");
5080 glength
= strlen (gname
);
5083 CloseHandle (token
);
5086 attrs
= Fcons (Fcons (Qeuid
, make_fixnum_or_float (euid
)), attrs
);
5087 tem
= make_unibyte_string (uname
, ulength
);
5088 attrs
= Fcons (Fcons (Quser
,
5089 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5091 attrs
= Fcons (Fcons (Qegid
, make_fixnum_or_float (egid
)), attrs
);
5092 tem
= make_unibyte_string (gname
, glength
);
5093 attrs
= Fcons (Fcons (Qgroup
,
5094 code_convert_string_norecord (tem
, Vlocale_coding_system
, 0)),
5097 if (global_memory_status_ex (&memstex
))
5098 #if __GNUC__ || (defined (_MSC_VER) && _MSC_VER >= 1300)
5099 totphys
= memstex
.ullTotalPhys
/ 1024.0;
5101 /* Visual Studio 6 cannot convert an unsigned __int64 type to
5102 double, so we need to do this for it... */
5104 DWORD tot_hi
= memstex
.ullTotalPhys
>> 32;
5105 DWORD tot_md
= (memstex
.ullTotalPhys
& 0x00000000ffffffff) >> 10;
5106 DWORD tot_lo
= memstex
.ullTotalPhys
% 1024;
5108 totphys
= tot_hi
* 4194304.0 + tot_md
+ tot_lo
/ 1024.0;
5110 #endif /* __GNUC__ || _MSC_VER >= 1300 */
5111 else if (global_memory_status (&memst
))
5112 totphys
= memst
.dwTotalPhys
/ 1024.0;
5115 && get_process_memory_info (h_proc
, (PROCESS_MEMORY_COUNTERS
*)&mem_ex
,
5118 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5120 attrs
= Fcons (Fcons (Qmajflt
,
5121 make_fixnum_or_float (mem_ex
.PageFaultCount
)),
5123 attrs
= Fcons (Fcons (Qvsize
,
5124 make_fixnum_or_float (mem_ex
.PrivateUsage
/ 1024)),
5126 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5128 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5131 && get_process_memory_info (h_proc
, &mem
, sizeof (mem
)))
5133 DWORD rss
= mem_ex
.WorkingSetSize
/ 1024;
5135 attrs
= Fcons (Fcons (Qmajflt
,
5136 make_fixnum_or_float (mem
.PageFaultCount
)),
5138 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (rss
)), attrs
);
5140 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5143 && get_process_working_set_size (h_proc
, &minrss
, &maxrss
))
5145 DWORD rss
= maxrss
/ 1024;
5147 attrs
= Fcons (Fcons (Qrss
, make_fixnum_or_float (maxrss
/ 1024)), attrs
);
5149 attrs
= Fcons (Fcons (Qpmem
, make_float (100. * rss
/ totphys
)), attrs
);
5152 if (process_times (h_proc
, &ctime
, &etime
, &stime
, &utime
, &ttime
, &pcpu
))
5154 attrs
= Fcons (Fcons (Qutime
, utime
), attrs
);
5155 attrs
= Fcons (Fcons (Qstime
, stime
), attrs
);
5156 attrs
= Fcons (Fcons (Qtime
, ttime
), attrs
);
5157 attrs
= Fcons (Fcons (Qstart
, ctime
), attrs
);
5158 attrs
= Fcons (Fcons (Qetime
, etime
), attrs
);
5159 attrs
= Fcons (Fcons (Qpcpu
, make_float (pcpu
)), attrs
);
5162 /* FIXME: Retrieve command line by walking the PEB of the process. */
5165 CloseHandle (h_proc
);
5171 /* Wrappers for winsock functions to map between our file descriptors
5172 and winsock's handles; also set h_errno for convenience.
5174 To allow Emacs to run on systems which don't have winsock support
5175 installed, we dynamically link to winsock on startup if present, and
5176 otherwise provide the minimum necessary functionality
5177 (eg. gethostname). */
5179 /* function pointers for relevant socket functions */
5180 int (PASCAL
*pfn_WSAStartup
) (WORD wVersionRequired
, LPWSADATA lpWSAData
);
5181 void (PASCAL
*pfn_WSASetLastError
) (int iError
);
5182 int (PASCAL
*pfn_WSAGetLastError
) (void);
5183 int (PASCAL
*pfn_WSAEventSelect
) (SOCKET s
, HANDLE hEventObject
, long lNetworkEvents
);
5184 HANDLE (PASCAL
*pfn_WSACreateEvent
) (void);
5185 int (PASCAL
*pfn_WSACloseEvent
) (HANDLE hEvent
);
5186 int (PASCAL
*pfn_socket
) (int af
, int type
, int protocol
);
5187 int (PASCAL
*pfn_bind
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5188 int (PASCAL
*pfn_connect
) (SOCKET s
, const struct sockaddr
*addr
, int namelen
);
5189 int (PASCAL
*pfn_ioctlsocket
) (SOCKET s
, long cmd
, u_long
*argp
);
5190 int (PASCAL
*pfn_recv
) (SOCKET s
, char * buf
, int len
, int flags
);
5191 int (PASCAL
*pfn_send
) (SOCKET s
, const char * buf
, int len
, int flags
);
5192 int (PASCAL
*pfn_closesocket
) (SOCKET s
);
5193 int (PASCAL
*pfn_shutdown
) (SOCKET s
, int how
);
5194 int (PASCAL
*pfn_WSACleanup
) (void);
5196 u_short (PASCAL
*pfn_htons
) (u_short hostshort
);
5197 u_short (PASCAL
*pfn_ntohs
) (u_short netshort
);
5198 unsigned long (PASCAL
*pfn_inet_addr
) (const char * cp
);
5199 int (PASCAL
*pfn_gethostname
) (char * name
, int namelen
);
5200 struct hostent
* (PASCAL
*pfn_gethostbyname
) (const char * name
);
5201 struct servent
* (PASCAL
*pfn_getservbyname
) (const char * name
, const char * proto
);
5202 int (PASCAL
*pfn_getpeername
) (SOCKET s
, struct sockaddr
*addr
, int * namelen
);
5203 int (PASCAL
*pfn_setsockopt
) (SOCKET s
, int level
, int optname
,
5204 const char * optval
, int optlen
);
5205 int (PASCAL
*pfn_listen
) (SOCKET s
, int backlog
);
5206 int (PASCAL
*pfn_getsockname
) (SOCKET s
, struct sockaddr
* name
,
5208 SOCKET (PASCAL
*pfn_accept
) (SOCKET s
, struct sockaddr
* addr
, int * addrlen
);
5209 int (PASCAL
*pfn_recvfrom
) (SOCKET s
, char * buf
, int len
, int flags
,
5210 struct sockaddr
* from
, int * fromlen
);
5211 int (PASCAL
*pfn_sendto
) (SOCKET s
, const char * buf
, int len
, int flags
,
5212 const struct sockaddr
* to
, int tolen
);
5214 /* SetHandleInformation is only needed to make sockets non-inheritable. */
5215 BOOL (WINAPI
*pfn_SetHandleInformation
) (HANDLE object
, DWORD mask
, DWORD flags
);
5216 #ifndef HANDLE_FLAG_INHERIT
5217 #define HANDLE_FLAG_INHERIT 1
5221 static int winsock_inuse
;
5226 if (winsock_lib
!= NULL
&& winsock_inuse
== 0)
5228 /* Not sure what would cause WSAENETDOWN, or even if it can happen
5229 after WSAStartup returns successfully, but it seems reasonable
5230 to allow unloading winsock anyway in that case. */
5231 if (pfn_WSACleanup () == 0 ||
5232 pfn_WSAGetLastError () == WSAENETDOWN
)
5234 if (FreeLibrary (winsock_lib
))
5243 init_winsock (int load_now
)
5245 WSADATA winsockData
;
5247 if (winsock_lib
!= NULL
)
5250 pfn_SetHandleInformation
5251 = (void *) GetProcAddress (GetModuleHandle ("kernel32.dll"),
5252 "SetHandleInformation");
5254 winsock_lib
= LoadLibrary ("Ws2_32.dll");
5256 if (winsock_lib
!= NULL
)
5258 /* dynamically link to socket functions */
5260 #define LOAD_PROC(fn) \
5261 if ((pfn_##fn = (void *) GetProcAddress (winsock_lib, #fn)) == NULL) \
5264 LOAD_PROC (WSAStartup
);
5265 LOAD_PROC (WSASetLastError
);
5266 LOAD_PROC (WSAGetLastError
);
5267 LOAD_PROC (WSAEventSelect
);
5268 LOAD_PROC (WSACreateEvent
);
5269 LOAD_PROC (WSACloseEvent
);
5272 LOAD_PROC (connect
);
5273 LOAD_PROC (ioctlsocket
);
5276 LOAD_PROC (closesocket
);
5277 LOAD_PROC (shutdown
);
5280 LOAD_PROC (inet_addr
);
5281 LOAD_PROC (gethostname
);
5282 LOAD_PROC (gethostbyname
);
5283 LOAD_PROC (getservbyname
);
5284 LOAD_PROC (getpeername
);
5285 LOAD_PROC (WSACleanup
);
5286 LOAD_PROC (setsockopt
);
5288 LOAD_PROC (getsockname
);
5290 LOAD_PROC (recvfrom
);
5294 /* specify version 1.1 of winsock */
5295 if (pfn_WSAStartup (0x101, &winsockData
) == 0)
5297 if (winsockData
.wVersion
!= 0x101)
5302 /* Report that winsock exists and is usable, but leave
5303 socket functions disabled. I am assuming that calling
5304 WSAStartup does not require any network interaction,
5305 and in particular does not cause or require a dial-up
5306 connection to be established. */
5309 FreeLibrary (winsock_lib
);
5317 FreeLibrary (winsock_lib
);
5327 /* function to set h_errno for compatibility; map winsock error codes to
5328 normal system codes where they overlap (non-overlapping definitions
5329 are already in <sys/socket.h> */
5333 if (winsock_lib
== NULL
)
5336 h_errno
= pfn_WSAGetLastError ();
5340 case WSAEACCES
: h_errno
= EACCES
; break;
5341 case WSAEBADF
: h_errno
= EBADF
; break;
5342 case WSAEFAULT
: h_errno
= EFAULT
; break;
5343 case WSAEINTR
: h_errno
= EINTR
; break;
5344 case WSAEINVAL
: h_errno
= EINVAL
; break;
5345 case WSAEMFILE
: h_errno
= EMFILE
; break;
5346 case WSAENAMETOOLONG
: h_errno
= ENAMETOOLONG
; break;
5347 case WSAENOTEMPTY
: h_errno
= ENOTEMPTY
; break;
5355 if (h_errno
== 0 && winsock_lib
!= NULL
)
5356 pfn_WSASetLastError (0);
5359 /* Extend strerror to handle the winsock-specific error codes. */
5363 } _wsa_errlist
[] = {
5364 {WSAEINTR
, "Interrupted function call"},
5365 {WSAEBADF
, "Bad file descriptor"},
5366 {WSAEACCES
, "Permission denied"},
5367 {WSAEFAULT
, "Bad address"},
5368 {WSAEINVAL
, "Invalid argument"},
5369 {WSAEMFILE
, "Too many open files"},
5371 {WSAEWOULDBLOCK
, "Resource temporarily unavailable"},
5372 {WSAEINPROGRESS
, "Operation now in progress"},
5373 {WSAEALREADY
, "Operation already in progress"},
5374 {WSAENOTSOCK
, "Socket operation on non-socket"},
5375 {WSAEDESTADDRREQ
, "Destination address required"},
5376 {WSAEMSGSIZE
, "Message too long"},
5377 {WSAEPROTOTYPE
, "Protocol wrong type for socket"},
5378 {WSAENOPROTOOPT
, "Bad protocol option"},
5379 {WSAEPROTONOSUPPORT
, "Protocol not supported"},
5380 {WSAESOCKTNOSUPPORT
, "Socket type not supported"},
5381 {WSAEOPNOTSUPP
, "Operation not supported"},
5382 {WSAEPFNOSUPPORT
, "Protocol family not supported"},
5383 {WSAEAFNOSUPPORT
, "Address family not supported by protocol family"},
5384 {WSAEADDRINUSE
, "Address already in use"},
5385 {WSAEADDRNOTAVAIL
, "Cannot assign requested address"},
5386 {WSAENETDOWN
, "Network is down"},
5387 {WSAENETUNREACH
, "Network is unreachable"},
5388 {WSAENETRESET
, "Network dropped connection on reset"},
5389 {WSAECONNABORTED
, "Software caused connection abort"},
5390 {WSAECONNRESET
, "Connection reset by peer"},
5391 {WSAENOBUFS
, "No buffer space available"},
5392 {WSAEISCONN
, "Socket is already connected"},
5393 {WSAENOTCONN
, "Socket is not connected"},
5394 {WSAESHUTDOWN
, "Cannot send after socket shutdown"},
5395 {WSAETOOMANYREFS
, "Too many references"}, /* not sure */
5396 {WSAETIMEDOUT
, "Connection timed out"},
5397 {WSAECONNREFUSED
, "Connection refused"},
5398 {WSAELOOP
, "Network loop"}, /* not sure */
5399 {WSAENAMETOOLONG
, "Name is too long"},
5400 {WSAEHOSTDOWN
, "Host is down"},
5401 {WSAEHOSTUNREACH
, "No route to host"},
5402 {WSAENOTEMPTY
, "Buffer not empty"}, /* not sure */
5403 {WSAEPROCLIM
, "Too many processes"},
5404 {WSAEUSERS
, "Too many users"}, /* not sure */
5405 {WSAEDQUOT
, "Double quote in host name"}, /* really not sure */
5406 {WSAESTALE
, "Data is stale"}, /* not sure */
5407 {WSAEREMOTE
, "Remote error"}, /* not sure */
5409 {WSASYSNOTREADY
, "Network subsystem is unavailable"},
5410 {WSAVERNOTSUPPORTED
, "WINSOCK.DLL version out of range"},
5411 {WSANOTINITIALISED
, "Winsock not initialized successfully"},
5412 {WSAEDISCON
, "Graceful shutdown in progress"},
5414 {WSAENOMORE
, "No more operations allowed"}, /* not sure */
5415 {WSAECANCELLED
, "Operation cancelled"}, /* not sure */
5416 {WSAEINVALIDPROCTABLE
, "Invalid procedure table from service provider"},
5417 {WSAEINVALIDPROVIDER
, "Invalid service provider version number"},
5418 {WSAEPROVIDERFAILEDINIT
, "Unable to initialize a service provider"},
5419 {WSASYSCALLFAILURE
, "System call failure"},
5420 {WSASERVICE_NOT_FOUND
, "Service not found"}, /* not sure */
5421 {WSATYPE_NOT_FOUND
, "Class type not found"},
5422 {WSA_E_NO_MORE
, "No more resources available"}, /* really not sure */
5423 {WSA_E_CANCELLED
, "Operation already cancelled"}, /* really not sure */
5424 {WSAEREFUSED
, "Operation refused"}, /* not sure */
5427 {WSAHOST_NOT_FOUND
, "Host not found"},
5428 {WSATRY_AGAIN
, "Authoritative host not found during name lookup"},
5429 {WSANO_RECOVERY
, "Non-recoverable error during name lookup"},
5430 {WSANO_DATA
, "Valid name, no data record of requested type"},
5436 sys_strerror (int error_no
)
5439 static char unknown_msg
[40];
5441 if (error_no
>= 0 && error_no
< sys_nerr
)
5442 return sys_errlist
[error_no
];
5444 for (i
= 0; _wsa_errlist
[i
].errnum
>= 0; i
++)
5445 if (_wsa_errlist
[i
].errnum
== error_no
)
5446 return _wsa_errlist
[i
].msg
;
5448 sprintf (unknown_msg
, "Unidentified error: %d", error_no
);
5452 /* [andrewi 3-May-96] I've had conflicting results using both methods,
5453 but I believe the method of keeping the socket handle separate (and
5454 insuring it is not inheritable) is the correct one. */
5456 #define SOCK_HANDLE(fd) ((SOCKET) fd_info[fd].hnd)
5458 static int socket_to_fd (SOCKET s
);
5461 sys_socket (int af
, int type
, int protocol
)
5465 if (winsock_lib
== NULL
)
5468 return INVALID_SOCKET
;
5473 /* call the real socket function */
5474 s
= pfn_socket (af
, type
, protocol
);
5476 if (s
!= INVALID_SOCKET
)
5477 return socket_to_fd (s
);
5483 /* Convert a SOCKET to a file descriptor. */
5485 socket_to_fd (SOCKET s
)
5490 /* Although under NT 3.5 _open_osfhandle will accept a socket
5491 handle, if opened with SO_OPENTYPE == SO_SYNCHRONOUS_NONALERT,
5492 that does not work under NT 3.1. However, we can get the same
5493 effect by using a backdoor function to replace an existing
5494 descriptor handle with the one we want. */
5496 /* allocate a file descriptor (with appropriate flags) */
5497 fd
= _open ("NUL:", _O_RDWR
);
5500 /* Make a non-inheritable copy of the socket handle. Note
5501 that it is possible that sockets aren't actually kernel
5502 handles, which appears to be the case on Windows 9x when
5503 the MS Proxy winsock client is installed. */
5505 /* Apparently there is a bug in NT 3.51 with some service
5506 packs, which prevents using DuplicateHandle to make a
5507 socket handle non-inheritable (causes WSACleanup to
5508 hang). The work-around is to use SetHandleInformation
5509 instead if it is available and implemented. */
5510 if (pfn_SetHandleInformation
)
5512 pfn_SetHandleInformation ((HANDLE
) s
, HANDLE_FLAG_INHERIT
, 0);
5516 HANDLE parent
= GetCurrentProcess ();
5517 HANDLE new_s
= INVALID_HANDLE_VALUE
;
5519 if (DuplicateHandle (parent
,
5525 DUPLICATE_SAME_ACCESS
))
5527 /* It is possible that DuplicateHandle succeeds even
5528 though the socket wasn't really a kernel handle,
5529 because a real handle has the same value. So
5530 test whether the new handle really is a socket. */
5531 long nonblocking
= 0;
5532 if (pfn_ioctlsocket ((SOCKET
) new_s
, FIONBIO
, &nonblocking
) == 0)
5534 pfn_closesocket (s
);
5539 CloseHandle (new_s
);
5544 fd_info
[fd
].hnd
= (HANDLE
) s
;
5546 /* set our own internal flags */
5547 fd_info
[fd
].flags
= FILE_SOCKET
| FILE_BINARY
| FILE_READ
| FILE_WRITE
;
5553 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5555 /* attach child_process to fd_info */
5556 if (fd_info
[ fd
].cp
!= NULL
)
5558 DebPrint (("sys_socket: fd_info[%d] apparently in use!\n", fd
));
5562 fd_info
[ fd
].cp
= cp
;
5565 winsock_inuse
++; /* count open sockets */
5572 pfn_closesocket (s
);
5578 sys_bind (int s
, const struct sockaddr
* addr
, int namelen
)
5580 if (winsock_lib
== NULL
)
5583 return SOCKET_ERROR
;
5587 if (fd_info
[s
].flags
& FILE_SOCKET
)
5589 int rc
= pfn_bind (SOCK_HANDLE (s
), addr
, namelen
);
5590 if (rc
== SOCKET_ERROR
)
5595 return SOCKET_ERROR
;
5599 sys_connect (int s
, const struct sockaddr
* name
, int namelen
)
5601 if (winsock_lib
== NULL
)
5604 return SOCKET_ERROR
;
5608 if (fd_info
[s
].flags
& FILE_SOCKET
)
5610 int rc
= pfn_connect (SOCK_HANDLE (s
), name
, namelen
);
5611 if (rc
== SOCKET_ERROR
)
5616 return SOCKET_ERROR
;
5620 sys_htons (u_short hostshort
)
5622 return (winsock_lib
!= NULL
) ?
5623 pfn_htons (hostshort
) : hostshort
;
5627 sys_ntohs (u_short netshort
)
5629 return (winsock_lib
!= NULL
) ?
5630 pfn_ntohs (netshort
) : netshort
;
5634 sys_inet_addr (const char * cp
)
5636 return (winsock_lib
!= NULL
) ?
5637 pfn_inet_addr (cp
) : INADDR_NONE
;
5641 sys_gethostname (char * name
, int namelen
)
5643 if (winsock_lib
!= NULL
)
5644 return pfn_gethostname (name
, namelen
);
5646 if (namelen
> MAX_COMPUTERNAME_LENGTH
)
5647 return !GetComputerName (name
, (DWORD
*)&namelen
);
5650 return SOCKET_ERROR
;
5654 sys_gethostbyname (const char * name
)
5656 struct hostent
* host
;
5658 if (winsock_lib
== NULL
)
5665 host
= pfn_gethostbyname (name
);
5672 sys_getservbyname (const char * name
, const char * proto
)
5674 struct servent
* serv
;
5676 if (winsock_lib
== NULL
)
5683 serv
= pfn_getservbyname (name
, proto
);
5690 sys_getpeername (int s
, struct sockaddr
*addr
, int * namelen
)
5692 if (winsock_lib
== NULL
)
5695 return SOCKET_ERROR
;
5699 if (fd_info
[s
].flags
& FILE_SOCKET
)
5701 int rc
= pfn_getpeername (SOCK_HANDLE (s
), addr
, namelen
);
5702 if (rc
== SOCKET_ERROR
)
5707 return SOCKET_ERROR
;
5711 sys_shutdown (int s
, int how
)
5713 if (winsock_lib
== NULL
)
5716 return SOCKET_ERROR
;
5720 if (fd_info
[s
].flags
& FILE_SOCKET
)
5722 int rc
= pfn_shutdown (SOCK_HANDLE (s
), how
);
5723 if (rc
== SOCKET_ERROR
)
5728 return SOCKET_ERROR
;
5732 sys_setsockopt (int s
, int level
, int optname
, const void * optval
, int optlen
)
5734 if (winsock_lib
== NULL
)
5737 return SOCKET_ERROR
;
5741 if (fd_info
[s
].flags
& FILE_SOCKET
)
5743 int rc
= pfn_setsockopt (SOCK_HANDLE (s
), level
, optname
,
5744 (const char *)optval
, optlen
);
5745 if (rc
== SOCKET_ERROR
)
5750 return SOCKET_ERROR
;
5754 sys_listen (int s
, int backlog
)
5756 if (winsock_lib
== NULL
)
5759 return SOCKET_ERROR
;
5763 if (fd_info
[s
].flags
& FILE_SOCKET
)
5765 int rc
= pfn_listen (SOCK_HANDLE (s
), backlog
);
5766 if (rc
== SOCKET_ERROR
)
5769 fd_info
[s
].flags
|= FILE_LISTEN
;
5773 return SOCKET_ERROR
;
5777 sys_getsockname (int s
, struct sockaddr
* name
, int * namelen
)
5779 if (winsock_lib
== NULL
)
5782 return SOCKET_ERROR
;
5786 if (fd_info
[s
].flags
& FILE_SOCKET
)
5788 int rc
= pfn_getsockname (SOCK_HANDLE (s
), name
, namelen
);
5789 if (rc
== SOCKET_ERROR
)
5794 return SOCKET_ERROR
;
5798 sys_accept (int s
, struct sockaddr
* addr
, int * addrlen
)
5800 if (winsock_lib
== NULL
)
5807 if (fd_info
[s
].flags
& FILE_LISTEN
)
5809 SOCKET t
= pfn_accept (SOCK_HANDLE (s
), addr
, addrlen
);
5811 if (t
== INVALID_SOCKET
)
5814 fd
= socket_to_fd (t
);
5816 fd_info
[s
].cp
->status
= STATUS_READ_ACKNOWLEDGED
;
5817 ResetEvent (fd_info
[s
].cp
->char_avail
);
5825 sys_recvfrom (int s
, char * buf
, int len
, int flags
,
5826 struct sockaddr
* from
, int * fromlen
)
5828 if (winsock_lib
== NULL
)
5831 return SOCKET_ERROR
;
5835 if (fd_info
[s
].flags
& FILE_SOCKET
)
5837 int rc
= pfn_recvfrom (SOCK_HANDLE (s
), buf
, len
, flags
, from
, fromlen
);
5838 if (rc
== SOCKET_ERROR
)
5843 return SOCKET_ERROR
;
5847 sys_sendto (int s
, const char * buf
, int len
, int flags
,
5848 const struct sockaddr
* to
, int tolen
)
5850 if (winsock_lib
== NULL
)
5853 return SOCKET_ERROR
;
5857 if (fd_info
[s
].flags
& FILE_SOCKET
)
5859 int rc
= pfn_sendto (SOCK_HANDLE (s
), buf
, len
, flags
, to
, tolen
);
5860 if (rc
== SOCKET_ERROR
)
5865 return SOCKET_ERROR
;
5868 /* Windows does not have an fcntl function. Provide an implementation
5869 solely for making sockets non-blocking. */
5871 fcntl (int s
, int cmd
, int options
)
5873 if (winsock_lib
== NULL
)
5880 if (fd_info
[s
].flags
& FILE_SOCKET
)
5882 if (cmd
== F_SETFL
&& options
== O_NONBLOCK
)
5884 unsigned long nblock
= 1;
5885 int rc
= pfn_ioctlsocket (SOCK_HANDLE (s
), FIONBIO
, &nblock
);
5886 if (rc
== SOCKET_ERROR
)
5888 /* Keep track of the fact that we set this to non-blocking. */
5889 fd_info
[s
].flags
|= FILE_NDELAY
;
5895 return SOCKET_ERROR
;
5899 return SOCKET_ERROR
;
5903 /* Shadow main io functions: we need to handle pipes and sockets more
5904 intelligently, and implement non-blocking mode as well. */
5917 if (fd
< MAXDESC
&& fd_info
[fd
].cp
)
5919 child_process
* cp
= fd_info
[fd
].cp
;
5921 fd_info
[fd
].cp
= NULL
;
5923 if (CHILD_ACTIVE (cp
))
5925 /* if last descriptor to active child_process then cleanup */
5927 for (i
= 0; i
< MAXDESC
; i
++)
5931 if (fd_info
[i
].cp
== cp
)
5936 if (fd_info
[fd
].flags
& FILE_SOCKET
)
5938 if (winsock_lib
== NULL
) emacs_abort ();
5940 pfn_shutdown (SOCK_HANDLE (fd
), 2);
5941 rc
= pfn_closesocket (SOCK_HANDLE (fd
));
5943 winsock_inuse
--; /* count open sockets */
5950 /* Note that sockets do not need special treatment here (at least on
5951 NT and Windows 95 using the standard tcp/ip stacks) - it appears that
5952 closesocket is equivalent to CloseHandle, which is to be expected
5953 because socket handles are fully fledged kernel handles. */
5956 if (rc
== 0 && fd
< MAXDESC
)
5957 fd_info
[fd
].flags
= 0;
5968 if (new_fd
>= 0 && new_fd
< MAXDESC
)
5970 /* duplicate our internal info as well */
5971 fd_info
[new_fd
] = fd_info
[fd
];
5977 sys_dup2 (int src
, int dst
)
5981 if (dst
< 0 || dst
>= MAXDESC
)
5987 /* make sure we close the destination first if it's a pipe or socket */
5988 if (src
!= dst
&& fd_info
[dst
].flags
!= 0)
5991 rc
= _dup2 (src
, dst
);
5994 /* duplicate our internal info as well */
5995 fd_info
[dst
] = fd_info
[src
];
6000 /* Unix pipe() has only one arg */
6002 sys_pipe (int * phandles
)
6007 /* make pipe handles non-inheritable; when we spawn a child, we
6008 replace the relevant handle with an inheritable one. Also put
6009 pipes into binary mode; we will do text mode translation ourselves
6011 rc
= _pipe (phandles
, 0, _O_NOINHERIT
| _O_BINARY
);
6015 /* Protect against overflow, since Windows can open more handles than
6016 our fd_info array has room for. */
6017 if (phandles
[0] >= MAXDESC
|| phandles
[1] >= MAXDESC
)
6019 _close (phandles
[0]);
6020 _close (phandles
[1]);
6025 flags
= FILE_PIPE
| FILE_READ
| FILE_BINARY
;
6026 fd_info
[phandles
[0]].flags
= flags
;
6028 flags
= FILE_PIPE
| FILE_WRITE
| FILE_BINARY
;
6029 fd_info
[phandles
[1]].flags
= flags
;
6036 /* Function to do blocking read of one byte, needed to implement
6037 select. It is only allowed on sockets and pipes. */
6039 _sys_read_ahead (int fd
)
6044 if (fd
< 0 || fd
>= MAXDESC
)
6045 return STATUS_READ_ERROR
;
6047 cp
= fd_info
[fd
].cp
;
6049 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6050 return STATUS_READ_ERROR
;
6052 if ((fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SERIAL
| FILE_SOCKET
)) == 0
6053 || (fd_info
[fd
].flags
& FILE_READ
) == 0)
6055 DebPrint (("_sys_read_ahead: internal error: fd %d is not a pipe, serial port, or socket!\n", fd
));
6059 cp
->status
= STATUS_READ_IN_PROGRESS
;
6061 if (fd_info
[fd
].flags
& FILE_PIPE
)
6063 rc
= _read (fd
, &cp
->chr
, sizeof (char));
6065 /* Give subprocess time to buffer some more output for us before
6066 reporting that input is available; we need this because Windows 95
6067 connects DOS programs to pipes by making the pipe appear to be
6068 the normal console stdout - as a result most DOS programs will
6069 write to stdout without buffering, ie. one character at a
6070 time. Even some W32 programs do this - "dir" in a command
6071 shell on NT is very slow if we don't do this. */
6074 int wait
= w32_pipe_read_delay
;
6080 /* Yield remainder of our time slice, effectively giving a
6081 temporary priority boost to the child process. */
6085 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6087 HANDLE hnd
= fd_info
[fd
].hnd
;
6088 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6091 /* Configure timeouts for blocking read. */
6092 if (!GetCommTimeouts (hnd
, &ct
))
6093 return STATUS_READ_ERROR
;
6094 ct
.ReadIntervalTimeout
= 0;
6095 ct
.ReadTotalTimeoutMultiplier
= 0;
6096 ct
.ReadTotalTimeoutConstant
= 0;
6097 if (!SetCommTimeouts (hnd
, &ct
))
6098 return STATUS_READ_ERROR
;
6100 if (!ReadFile (hnd
, &cp
->chr
, sizeof (char), (DWORD
*) &rc
, ovl
))
6102 if (GetLastError () != ERROR_IO_PENDING
)
6103 return STATUS_READ_ERROR
;
6104 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6105 return STATUS_READ_ERROR
;
6108 else if (fd_info
[fd
].flags
& FILE_SOCKET
)
6110 unsigned long nblock
= 0;
6111 /* We always want this to block, so temporarily disable NDELAY. */
6112 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6113 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6115 rc
= pfn_recv (SOCK_HANDLE (fd
), &cp
->chr
, sizeof (char), 0);
6117 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6120 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6124 if (rc
== sizeof (char))
6125 cp
->status
= STATUS_READ_SUCCEEDED
;
6127 cp
->status
= STATUS_READ_FAILED
;
6133 _sys_wait_accept (int fd
)
6139 if (fd
< 0 || fd
>= MAXDESC
)
6140 return STATUS_READ_ERROR
;
6142 cp
= fd_info
[fd
].cp
;
6144 if (cp
== NULL
|| cp
->fd
!= fd
|| cp
->status
!= STATUS_READ_READY
)
6145 return STATUS_READ_ERROR
;
6147 cp
->status
= STATUS_READ_FAILED
;
6149 hEv
= pfn_WSACreateEvent ();
6150 rc
= pfn_WSAEventSelect (SOCK_HANDLE (fd
), hEv
, FD_ACCEPT
);
6151 if (rc
!= SOCKET_ERROR
)
6153 rc
= WaitForSingleObject (hEv
, INFINITE
);
6154 pfn_WSAEventSelect (SOCK_HANDLE (fd
), NULL
, 0);
6155 if (rc
== WAIT_OBJECT_0
)
6156 cp
->status
= STATUS_READ_SUCCEEDED
;
6158 pfn_WSACloseEvent (hEv
);
6164 sys_read (int fd
, char * buffer
, unsigned int count
)
6169 char * orig_buffer
= buffer
;
6177 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6179 child_process
*cp
= fd_info
[fd
].cp
;
6181 if ((fd_info
[fd
].flags
& FILE_READ
) == 0)
6189 /* re-read CR carried over from last read */
6190 if (fd_info
[fd
].flags
& FILE_LAST_CR
)
6192 if (fd_info
[fd
].flags
& FILE_BINARY
) emacs_abort ();
6196 fd_info
[fd
].flags
&= ~FILE_LAST_CR
;
6199 /* presence of a child_process structure means we are operating in
6200 non-blocking mode - otherwise we just call _read directly.
6201 Note that the child_process structure might be missing because
6202 reap_subprocess has been called; in this case the pipe is
6203 already broken, so calling _read on it is okay. */
6206 int current_status
= cp
->status
;
6208 switch (current_status
)
6210 case STATUS_READ_FAILED
:
6211 case STATUS_READ_ERROR
:
6212 /* report normal EOF if nothing in buffer */
6214 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6217 case STATUS_READ_READY
:
6218 case STATUS_READ_IN_PROGRESS
:
6219 DebPrint (("sys_read called when read is in progress\n"));
6220 errno
= EWOULDBLOCK
;
6223 case STATUS_READ_SUCCEEDED
:
6224 /* consume read-ahead char */
6225 *buffer
++ = cp
->chr
;
6228 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6229 ResetEvent (cp
->char_avail
);
6231 case STATUS_READ_ACKNOWLEDGED
:
6235 DebPrint (("sys_read: bad status %d\n", current_status
));
6240 if (fd_info
[fd
].flags
& FILE_PIPE
)
6242 PeekNamedPipe ((HANDLE
) _get_osfhandle (fd
), NULL
, 0, NULL
, &waiting
, NULL
);
6243 to_read
= min (waiting
, (DWORD
) count
);
6246 nchars
+= _read (fd
, buffer
, to_read
);
6248 else if (fd_info
[fd
].flags
& FILE_SERIAL
)
6250 HANDLE hnd
= fd_info
[fd
].hnd
;
6251 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_read
;
6257 /* Configure timeouts for non-blocking read. */
6258 if (!GetCommTimeouts (hnd
, &ct
))
6263 ct
.ReadIntervalTimeout
= MAXDWORD
;
6264 ct
.ReadTotalTimeoutMultiplier
= 0;
6265 ct
.ReadTotalTimeoutConstant
= 0;
6266 if (!SetCommTimeouts (hnd
, &ct
))
6272 if (!ResetEvent (ovl
->hEvent
))
6277 if (!ReadFile (hnd
, buffer
, count
, (DWORD
*) &rc
, ovl
))
6279 if (GetLastError () != ERROR_IO_PENDING
)
6284 if (!GetOverlappedResult (hnd
, ovl
, (DWORD
*) &rc
, TRUE
))
6293 else /* FILE_SOCKET */
6295 if (winsock_lib
== NULL
) emacs_abort ();
6297 /* do the equivalent of a non-blocking read */
6298 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONREAD
, &waiting
);
6299 if (waiting
== 0 && nchars
== 0)
6301 h_errno
= errno
= EWOULDBLOCK
;
6307 /* always use binary mode for sockets */
6308 int res
= pfn_recv (SOCK_HANDLE (fd
), buffer
, count
, 0);
6309 if (res
== SOCKET_ERROR
)
6311 DebPrint (("sys_read.recv failed with error %d on socket %ld\n",
6312 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6322 int nread
= _read (fd
, buffer
, count
);
6325 else if (nchars
== 0)
6330 fd_info
[fd
].flags
|= FILE_AT_EOF
;
6331 /* Perform text mode translation if required. */
6332 else if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6334 nchars
= crlf_to_lf (nchars
, orig_buffer
);
6335 /* If buffer contains only CR, return that. To be absolutely
6336 sure we should attempt to read the next char, but in
6337 practice a CR to be followed by LF would not appear by
6338 itself in the buffer. */
6339 if (nchars
> 1 && orig_buffer
[nchars
- 1] == 0x0d)
6341 fd_info
[fd
].flags
|= FILE_LAST_CR
;
6347 nchars
= _read (fd
, buffer
, count
);
6352 /* From w32xfns.c */
6353 extern HANDLE interrupt_handle
;
6355 /* For now, don't bother with a non-blocking mode */
6357 sys_write (int fd
, const void * buffer
, unsigned int count
)
6367 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& (FILE_PIPE
| FILE_SOCKET
| FILE_SERIAL
))
6369 if ((fd_info
[fd
].flags
& FILE_WRITE
) == 0)
6375 /* Perform text mode translation if required. */
6376 if ((fd_info
[fd
].flags
& FILE_BINARY
) == 0)
6378 char * tmpbuf
= alloca (count
* 2);
6379 unsigned char * src
= (void *)buffer
;
6380 unsigned char * dst
= tmpbuf
;
6385 unsigned char *next
;
6386 /* copy next line or remaining bytes */
6387 next
= _memccpy (dst
, src
, '\n', nbytes
);
6390 /* copied one line ending with '\n' */
6391 int copied
= next
- dst
;
6394 /* insert '\r' before '\n' */
6401 /* copied remaining partial line -> now finished */
6408 if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SERIAL
)
6410 HANDLE hnd
= (HANDLE
) _get_osfhandle (fd
);
6411 OVERLAPPED
*ovl
= &fd_info
[fd
].cp
->ovl_write
;
6412 HANDLE wait_hnd
[2] = { interrupt_handle
, ovl
->hEvent
};
6415 if (!WriteFile (hnd
, buffer
, count
, (DWORD
*) &nchars
, ovl
))
6417 if (GetLastError () != ERROR_IO_PENDING
)
6422 if (detect_input_pending ())
6423 active
= MsgWaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
,
6426 active
= WaitForMultipleObjects (2, wait_hnd
, FALSE
, INFINITE
);
6427 if (active
== WAIT_OBJECT_0
)
6428 { /* User pressed C-g, cancel write, then leave. Don't bother
6429 cleaning up as we may only get stuck in buggy drivers. */
6430 PurgeComm (hnd
, PURGE_TXABORT
| PURGE_TXCLEAR
);
6435 if (active
== WAIT_OBJECT_0
+ 1
6436 && !GetOverlappedResult (hnd
, ovl
, (DWORD
*) &nchars
, TRUE
))
6443 else if (fd
< MAXDESC
&& fd_info
[fd
].flags
& FILE_SOCKET
)
6445 unsigned long nblock
= 0;
6446 if (winsock_lib
== NULL
) emacs_abort ();
6448 /* TODO: implement select() properly so non-blocking I/O works. */
6449 /* For now, make sure the write blocks. */
6450 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6451 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6453 nchars
= pfn_send (SOCK_HANDLE (fd
), buffer
, count
, 0);
6455 /* Set the socket back to non-blocking if it was before,
6456 for other operations that support it. */
6457 if (fd_info
[fd
].flags
& FILE_NDELAY
)
6460 pfn_ioctlsocket (SOCK_HANDLE (fd
), FIONBIO
, &nblock
);
6463 if (nchars
== SOCKET_ERROR
)
6465 DebPrint (("sys_write.send failed with error %d on socket %ld\n",
6466 pfn_WSAGetLastError (), SOCK_HANDLE (fd
)));
6472 /* Some networked filesystems don't like too large writes, so
6473 break them into smaller chunks. See the Comments section of
6474 the MSDN documentation of WriteFile for details behind the
6475 choice of the value of CHUNK below. See also the thread
6476 http://thread.gmane.org/gmane.comp.version-control.git/145294
6477 in the git mailing list. */
6478 const unsigned char *p
= buffer
;
6479 const unsigned chunk
= 30 * 1024 * 1024;
6484 unsigned this_chunk
= count
< chunk
? count
: chunk
;
6485 int n
= _write (fd
, p
, this_chunk
);
6493 else if (n
< this_chunk
)
6503 /* The Windows CRT functions are "optimized for speed", so they don't
6504 check for timezone and DST changes if they were last called less
6505 than 1 minute ago (see http://support.microsoft.com/kb/821231). So
6506 all Emacs features that repeatedly call time functions (e.g.,
6507 display-time) are in real danger of missing timezone and DST
6508 changes. Calling tzset before each localtime call fixes that. */
6510 sys_localtime (const time_t *t
)
6513 return localtime (t
);
6518 /* Try loading LIBRARY_ID from the file(s) specified in
6519 Vdynamic_library_alist. If the library is loaded successfully,
6520 return the handle of the DLL, and record the filename in the
6521 property :loaded-from of LIBRARY_ID. If the library could not be
6522 found, or when it was already loaded (because the handle is not
6523 recorded anywhere, and so is lost after use), return NULL.
6525 We could also save the handle in :loaded-from, but currently
6526 there's no use case for it. */
6528 w32_delayed_load (Lisp_Object library_id
)
6530 HMODULE library_dll
= NULL
;
6532 CHECK_SYMBOL (library_id
);
6534 if (CONSP (Vdynamic_library_alist
)
6535 && NILP (Fassq (library_id
, Vlibrary_cache
)))
6537 Lisp_Object found
= Qnil
;
6538 Lisp_Object dlls
= Fassq (library_id
, Vdynamic_library_alist
);
6541 for (dlls
= XCDR (dlls
); CONSP (dlls
); dlls
= XCDR (dlls
))
6543 CHECK_STRING_CAR (dlls
);
6544 if ((library_dll
= LoadLibrary (SDATA (XCAR (dlls
)))))
6546 char name
[MAX_PATH
];
6549 len
= GetModuleFileNameA (library_dll
, name
, sizeof (name
));
6550 found
= Fcons (XCAR (dlls
),
6552 /* Possibly truncated */
6553 ? make_specified_string (name
, -1, len
, 1)
6559 Fput (library_id
, QCloaded_from
, found
);
6567 check_windows_init_file (void)
6569 /* A common indication that Emacs is not installed properly is when
6570 it cannot find the Windows installation file. If this file does
6571 not exist in the expected place, tell the user. */
6573 if (!noninteractive
&& !inhibit_window_system
6574 /* Vload_path is not yet initialized when we are loading
6576 && NILP (Vpurify_flag
))
6578 Lisp_Object init_file
;
6581 init_file
= build_string ("term/w32-win");
6582 fd
= openp (Vload_path
, init_file
, Fget_load_suffixes (), NULL
, Qnil
);
6585 Lisp_Object load_path_print
= Fprin1_to_string (Vload_path
, Qnil
);
6586 char *init_file_name
= SDATA (init_file
);
6587 char *load_path
= SDATA (load_path_print
);
6588 char *buffer
= alloca (1024
6589 + strlen (init_file_name
)
6590 + strlen (load_path
));
6593 "The Emacs Windows initialization file \"%s.el\" "
6594 "could not be found in your Emacs installation. "
6595 "Emacs checked the following directories for this file:\n"
6597 "When Emacs cannot find this file, it usually means that it "
6598 "was not installed properly, or its distribution file was "
6599 "not unpacked properly.\nSee the README.W32 file in the "
6600 "top-level Emacs directory for more information.",
6601 init_file_name
, load_path
);
6604 "Emacs Abort Dialog",
6605 MB_OK
| MB_ICONEXCLAMATION
| MB_TASKMODAL
);
6606 /* Use the low-level system abort. */
6617 term_ntproc (int ignored
)
6623 /* shutdown the socket interface if necessary */
6630 init_ntproc (int dumping
)
6632 sigset_t initial_mask
= 0;
6634 /* Initialize the socket interface now if available and requested by
6635 the user by defining PRELOAD_WINSOCK; otherwise loading will be
6636 delayed until open-network-stream is called (w32-has-winsock can
6637 also be used to dynamically load or reload winsock).
6639 Conveniently, init_environment is called before us, so
6640 PRELOAD_WINSOCK can be set in the registry. */
6642 /* Always initialize this correctly. */
6645 if (getenv ("PRELOAD_WINSOCK") != NULL
)
6646 init_winsock (TRUE
);
6648 /* Initial preparation for subprocess support: replace our standard
6649 handles with non-inheritable versions. */
6652 HANDLE stdin_save
= INVALID_HANDLE_VALUE
;
6653 HANDLE stdout_save
= INVALID_HANDLE_VALUE
;
6654 HANDLE stderr_save
= INVALID_HANDLE_VALUE
;
6656 parent
= GetCurrentProcess ();
6658 /* ignore errors when duplicating and closing; typically the
6659 handles will be invalid when running as a gui program. */
6660 DuplicateHandle (parent
,
6661 GetStdHandle (STD_INPUT_HANDLE
),
6666 DUPLICATE_SAME_ACCESS
);
6668 DuplicateHandle (parent
,
6669 GetStdHandle (STD_OUTPUT_HANDLE
),
6674 DUPLICATE_SAME_ACCESS
);
6676 DuplicateHandle (parent
,
6677 GetStdHandle (STD_ERROR_HANDLE
),
6682 DUPLICATE_SAME_ACCESS
);
6688 if (stdin_save
!= INVALID_HANDLE_VALUE
)
6689 _open_osfhandle ((intptr_t) stdin_save
, O_TEXT
);
6691 _open ("nul", O_TEXT
| O_NOINHERIT
| O_RDONLY
);
6694 if (stdout_save
!= INVALID_HANDLE_VALUE
)
6695 _open_osfhandle ((intptr_t) stdout_save
, O_TEXT
);
6697 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6700 if (stderr_save
!= INVALID_HANDLE_VALUE
)
6701 _open_osfhandle ((intptr_t) stderr_save
, O_TEXT
);
6703 _open ("nul", O_TEXT
| O_NOINHERIT
| O_WRONLY
);
6707 /* unfortunately, atexit depends on implementation of malloc */
6708 /* atexit (term_ntproc); */
6711 /* Make sure we start with all signals unblocked. */
6712 sigprocmask (SIG_SETMASK
, &initial_mask
, NULL
);
6713 signal (SIGABRT
, term_ntproc
);
6717 /* determine which drives are fixed, for GetCachedVolumeInformation */
6719 /* GetDriveType must have trailing backslash. */
6720 char drive
[] = "A:\\";
6722 /* Loop over all possible drive letters */
6723 while (*drive
<= 'Z')
6725 /* Record if this drive letter refers to a fixed drive. */
6726 fixed_drives
[DRIVE_INDEX (*drive
)] =
6727 (GetDriveType (drive
) == DRIVE_FIXED
);
6732 /* Reset the volume info cache. */
6733 volume_cache
= NULL
;
6738 shutdown_handler ensures that buffers' autosave files are
6739 up to date when the user logs off, or the system shuts down.
6742 shutdown_handler (DWORD type
)
6744 /* Ctrl-C and Ctrl-Break are already suppressed, so don't handle them. */
6745 if (type
== CTRL_CLOSE_EVENT
/* User closes console window. */
6746 || type
== CTRL_LOGOFF_EVENT
/* User logs off. */
6747 || type
== CTRL_SHUTDOWN_EVENT
) /* User shutsdown. */
6749 /* Shut down cleanly, making sure autosave files are up to date. */
6750 shut_down_emacs (0, Qnil
);
6753 /* Allow other handlers to handle this signal. */
6758 globals_of_w32 is used to initialize those global variables that
6759 must always be initialized on startup even when the global variable
6760 initialized is non zero (see the function main in emacs.c).
6763 globals_of_w32 (void)
6765 HMODULE kernel32
= GetModuleHandle ("kernel32.dll");
6767 get_process_times_fn
= (GetProcessTimes_Proc
)
6768 GetProcAddress (kernel32
, "GetProcessTimes");
6770 DEFSYM (QCloaded_from
, ":loaded-from");
6772 g_b_init_is_windows_9x
= 0;
6773 g_b_init_open_process_token
= 0;
6774 g_b_init_get_token_information
= 0;
6775 g_b_init_lookup_account_sid
= 0;
6776 g_b_init_get_sid_sub_authority
= 0;
6777 g_b_init_get_sid_sub_authority_count
= 0;
6778 g_b_init_get_security_info
= 0;
6779 g_b_init_get_file_security
= 0;
6780 g_b_init_get_security_descriptor_owner
= 0;
6781 g_b_init_get_security_descriptor_group
= 0;
6782 g_b_init_is_valid_sid
= 0;
6783 g_b_init_create_toolhelp32_snapshot
= 0;
6784 g_b_init_process32_first
= 0;
6785 g_b_init_process32_next
= 0;
6786 g_b_init_open_thread_token
= 0;
6787 g_b_init_impersonate_self
= 0;
6788 g_b_init_revert_to_self
= 0;
6789 g_b_init_get_process_memory_info
= 0;
6790 g_b_init_get_process_working_set_size
= 0;
6791 g_b_init_global_memory_status
= 0;
6792 g_b_init_global_memory_status_ex
= 0;
6793 g_b_init_equal_sid
= 0;
6794 g_b_init_copy_sid
= 0;
6795 g_b_init_get_length_sid
= 0;
6796 g_b_init_get_native_system_info
= 0;
6797 g_b_init_get_system_times
= 0;
6798 g_b_init_create_symbolic_link
= 0;
6799 num_of_processors
= 0;
6800 /* The following sets a handler for shutdown notifications for
6801 console apps. This actually applies to Emacs in both console and
6802 GUI modes, since we had to fool windows into thinking emacs is a
6803 console application to get console mode to work. */
6804 SetConsoleCtrlHandler (shutdown_handler
, TRUE
);
6806 /* "None" is the default group name on standalone workstations. */
6807 strcpy (dflt_group_name
, "None");
6810 /* For make-serial-process */
6812 serial_open (char *port
)
6818 hnd
= CreateFile (port
, GENERIC_READ
| GENERIC_WRITE
, 0, 0,
6819 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
6820 if (hnd
== INVALID_HANDLE_VALUE
)
6821 error ("Could not open %s", port
);
6822 fd
= (int) _open_osfhandle ((intptr_t) hnd
, 0);
6824 error ("Could not open %s", port
);
6828 error ("Could not create child process");
6830 cp
->status
= STATUS_READ_ACKNOWLEDGED
;
6831 fd_info
[ fd
].hnd
= hnd
;
6832 fd_info
[ fd
].flags
|=
6833 FILE_READ
| FILE_WRITE
| FILE_BINARY
| FILE_SERIAL
;
6834 if (fd_info
[ fd
].cp
!= NULL
)
6836 error ("fd_info[fd = %d] is already in use", fd
);
6838 fd_info
[ fd
].cp
= cp
;
6839 cp
->ovl_read
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6840 if (cp
->ovl_read
.hEvent
== NULL
)
6841 error ("Could not create read event");
6842 cp
->ovl_write
.hEvent
= CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
6843 if (cp
->ovl_write
.hEvent
== NULL
)
6844 error ("Could not create write event");
6849 /* For serial-process-configure */
6851 serial_configure (struct Lisp_Process
*p
, Lisp_Object contact
)
6853 Lisp_Object childp2
= Qnil
;
6854 Lisp_Object tem
= Qnil
;
6858 char summary
[4] = "???"; /* This usually becomes "8N1". */
6860 if ((fd_info
[ p
->outfd
].flags
& FILE_SERIAL
) == 0)
6861 error ("Not a serial process");
6862 hnd
= fd_info
[ p
->outfd
].hnd
;
6864 childp2
= Fcopy_sequence (p
->childp
);
6866 /* Initialize timeouts for blocking read and blocking write. */
6867 if (!GetCommTimeouts (hnd
, &ct
))
6868 error ("GetCommTimeouts() failed");
6869 ct
.ReadIntervalTimeout
= 0;
6870 ct
.ReadTotalTimeoutMultiplier
= 0;
6871 ct
.ReadTotalTimeoutConstant
= 0;
6872 ct
.WriteTotalTimeoutMultiplier
= 0;
6873 ct
.WriteTotalTimeoutConstant
= 0;
6874 if (!SetCommTimeouts (hnd
, &ct
))
6875 error ("SetCommTimeouts() failed");
6876 /* Read port attributes and prepare default configuration. */
6877 memset (&dcb
, 0, sizeof (dcb
));
6878 dcb
.DCBlength
= sizeof (DCB
);
6879 if (!GetCommState (hnd
, &dcb
))
6880 error ("GetCommState() failed");
6883 dcb
.fAbortOnError
= FALSE
;
6884 /* dcb.XonLim and dcb.XoffLim are set by GetCommState() */
6889 /* Configure speed. */
6890 if (!NILP (Fplist_member (contact
, QCspeed
)))
6891 tem
= Fplist_get (contact
, QCspeed
);
6893 tem
= Fplist_get (p
->childp
, QCspeed
);
6895 dcb
.BaudRate
= XINT (tem
);
6896 childp2
= Fplist_put (childp2
, QCspeed
, tem
);
6898 /* Configure bytesize. */
6899 if (!NILP (Fplist_member (contact
, QCbytesize
)))
6900 tem
= Fplist_get (contact
, QCbytesize
);
6902 tem
= Fplist_get (p
->childp
, QCbytesize
);
6904 tem
= make_number (8);
6906 if (XINT (tem
) != 7 && XINT (tem
) != 8)
6907 error (":bytesize must be nil (8), 7, or 8");
6908 dcb
.ByteSize
= XINT (tem
);
6909 summary
[0] = XINT (tem
) + '0';
6910 childp2
= Fplist_put (childp2
, QCbytesize
, tem
);
6912 /* Configure parity. */
6913 if (!NILP (Fplist_member (contact
, QCparity
)))
6914 tem
= Fplist_get (contact
, QCparity
);
6916 tem
= Fplist_get (p
->childp
, QCparity
);
6917 if (!NILP (tem
) && !EQ (tem
, Qeven
) && !EQ (tem
, Qodd
))
6918 error (":parity must be nil (no parity), `even', or `odd'");
6919 dcb
.fParity
= FALSE
;
6920 dcb
.Parity
= NOPARITY
;
6921 dcb
.fErrorChar
= FALSE
;
6926 else if (EQ (tem
, Qeven
))
6930 dcb
.Parity
= EVENPARITY
;
6931 dcb
.fErrorChar
= TRUE
;
6933 else if (EQ (tem
, Qodd
))
6937 dcb
.Parity
= ODDPARITY
;
6938 dcb
.fErrorChar
= TRUE
;
6940 childp2
= Fplist_put (childp2
, QCparity
, tem
);
6942 /* Configure stopbits. */
6943 if (!NILP (Fplist_member (contact
, QCstopbits
)))
6944 tem
= Fplist_get (contact
, QCstopbits
);
6946 tem
= Fplist_get (p
->childp
, QCstopbits
);
6948 tem
= make_number (1);
6950 if (XINT (tem
) != 1 && XINT (tem
) != 2)
6951 error (":stopbits must be nil (1 stopbit), 1, or 2");
6952 summary
[2] = XINT (tem
) + '0';
6953 if (XINT (tem
) == 1)
6954 dcb
.StopBits
= ONESTOPBIT
;
6955 else if (XINT (tem
) == 2)
6956 dcb
.StopBits
= TWOSTOPBITS
;
6957 childp2
= Fplist_put (childp2
, QCstopbits
, tem
);
6959 /* Configure flowcontrol. */
6960 if (!NILP (Fplist_member (contact
, QCflowcontrol
)))
6961 tem
= Fplist_get (contact
, QCflowcontrol
);
6963 tem
= Fplist_get (p
->childp
, QCflowcontrol
);
6964 if (!NILP (tem
) && !EQ (tem
, Qhw
) && !EQ (tem
, Qsw
))
6965 error (":flowcontrol must be nil (no flowcontrol), `hw', or `sw'");
6966 dcb
.fOutxCtsFlow
= FALSE
;
6967 dcb
.fOutxDsrFlow
= FALSE
;
6968 dcb
.fDtrControl
= DTR_CONTROL_DISABLE
;
6969 dcb
.fDsrSensitivity
= FALSE
;
6970 dcb
.fTXContinueOnXoff
= FALSE
;
6973 dcb
.fRtsControl
= RTS_CONTROL_DISABLE
;
6974 dcb
.XonChar
= 17; /* Control-Q */
6975 dcb
.XoffChar
= 19; /* Control-S */
6978 /* Already configured. */
6980 else if (EQ (tem
, Qhw
))
6982 dcb
.fRtsControl
= RTS_CONTROL_HANDSHAKE
;
6983 dcb
.fOutxCtsFlow
= TRUE
;
6985 else if (EQ (tem
, Qsw
))
6990 childp2
= Fplist_put (childp2
, QCflowcontrol
, tem
);
6992 /* Activate configuration. */
6993 if (!SetCommState (hnd
, &dcb
))
6994 error ("SetCommState() failed");
6996 childp2
= Fplist_put (childp2
, QCsummary
, build_string (summary
));
6997 pset_childp (p
, childp2
);
7003 emacs_gnutls_pull (gnutls_transport_ptr_t p
, void* buf
, size_t sz
)
7008 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7009 int fd
= process
->infd
;
7013 n
= sys_read (fd
, (char*)buf
, sz
);
7020 if (err
== EWOULDBLOCK
)
7022 /* Set a small timeout. */
7023 timeout
= make_emacs_time (1, 0);
7025 FD_SET ((int)fd
, &fdset
);
7027 /* Use select with the timeout to poll the selector. */
7028 sc
= select (fd
+ 1, &fdset
, (SELECT_TYPE
*)0, (SELECT_TYPE
*)0,
7032 continue; /* Try again. */
7034 /* Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN.
7035 Also accept select return 0 as an indicator to EAGAIN. */
7036 if (sc
== 0 || errno
== EWOULDBLOCK
)
7039 err
= errno
; /* Other errors are just passed on. */
7042 emacs_gnutls_transport_set_errno (process
->gnutls_state
, err
);
7049 emacs_gnutls_push (gnutls_transport_ptr_t p
, const void* buf
, size_t sz
)
7051 struct Lisp_Process
*process
= (struct Lisp_Process
*)p
;
7052 int fd
= process
->outfd
;
7053 ssize_t n
= sys_write (fd
, buf
, sz
);
7055 /* 0 or more bytes written means everything went fine. */
7059 /* Negative bytes written means we got an error in errno.
7060 Translate the WSAEWOULDBLOCK alias EWOULDBLOCK to EAGAIN. */
7061 emacs_gnutls_transport_set_errno (process
->gnutls_state
,
7062 errno
== EWOULDBLOCK
? EAGAIN
: errno
);
7066 #endif /* HAVE_GNUTLS */